1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc. 4 * Copyright (C) 2010 Red Hat, Inc. 5 * All Rights Reserved. 6 */ 7 #include "xfs.h" 8 #include "xfs_fs.h" 9 #include "xfs_shared.h" 10 #include "xfs_format.h" 11 #include "xfs_log_format.h" 12 #include "xfs_trans_resv.h" 13 #include "xfs_mount.h" 14 #include "xfs_extent_busy.h" 15 #include "xfs_quota.h" 16 #include "xfs_trans.h" 17 #include "xfs_trans_priv.h" 18 #include "xfs_log.h" 19 #include "xfs_trace.h" 20 #include "xfs_error.h" 21 #include "xfs_defer.h" 22 23 kmem_zone_t *xfs_trans_zone; 24 25 #if defined(CONFIG_TRACEPOINTS) 26 static void 27 xfs_trans_trace_reservations( 28 struct xfs_mount *mp) 29 { 30 struct xfs_trans_res resv; 31 struct xfs_trans_res *res; 32 struct xfs_trans_res *end_res; 33 int i; 34 35 res = (struct xfs_trans_res *)M_RES(mp); 36 end_res = (struct xfs_trans_res *)(M_RES(mp) + 1); 37 for (i = 0; res < end_res; i++, res++) 38 trace_xfs_trans_resv_calc(mp, i, res); 39 xfs_log_get_max_trans_res(mp, &resv); 40 trace_xfs_trans_resv_calc(mp, -1, &resv); 41 } 42 #else 43 # define xfs_trans_trace_reservations(mp) 44 #endif 45 46 /* 47 * Initialize the precomputed transaction reservation values 48 * in the mount structure. 49 */ 50 void 51 xfs_trans_init( 52 struct xfs_mount *mp) 53 { 54 xfs_trans_resv_calc(mp, M_RES(mp)); 55 xfs_trans_trace_reservations(mp); 56 } 57 58 /* 59 * Free the transaction structure. If there is more clean up 60 * to do when the structure is freed, add it here. 61 */ 62 STATIC void 63 xfs_trans_free( 64 struct xfs_trans *tp) 65 { 66 xfs_extent_busy_sort(&tp->t_busy); 67 xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false); 68 69 trace_xfs_trans_free(tp, _RET_IP_); 70 atomic_dec(&tp->t_mountp->m_active_trans); 71 if (!(tp->t_flags & XFS_TRANS_NO_WRITECOUNT)) 72 sb_end_intwrite(tp->t_mountp->m_super); 73 xfs_trans_free_dqinfo(tp); 74 kmem_zone_free(xfs_trans_zone, tp); 75 } 76 77 /* 78 * This is called to create a new transaction which will share the 79 * permanent log reservation of the given transaction. The remaining 80 * unused block and rt extent reservations are also inherited. This 81 * implies that the original transaction is no longer allowed to allocate 82 * blocks. Locks and log items, however, are no inherited. They must 83 * be added to the new transaction explicitly. 84 */ 85 STATIC struct xfs_trans * 86 xfs_trans_dup( 87 struct xfs_trans *tp) 88 { 89 struct xfs_trans *ntp; 90 91 trace_xfs_trans_dup(tp, _RET_IP_); 92 93 ntp = kmem_zone_zalloc(xfs_trans_zone, 0); 94 95 /* 96 * Initialize the new transaction structure. 97 */ 98 ntp->t_magic = XFS_TRANS_HEADER_MAGIC; 99 ntp->t_mountp = tp->t_mountp; 100 INIT_LIST_HEAD(&ntp->t_items); 101 INIT_LIST_HEAD(&ntp->t_busy); 102 INIT_LIST_HEAD(&ntp->t_dfops); 103 ntp->t_firstblock = NULLFSBLOCK; 104 105 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 106 ASSERT(tp->t_ticket != NULL); 107 108 ntp->t_flags = XFS_TRANS_PERM_LOG_RES | 109 (tp->t_flags & XFS_TRANS_RESERVE) | 110 (tp->t_flags & XFS_TRANS_NO_WRITECOUNT); 111 /* We gave our writer reference to the new transaction */ 112 tp->t_flags |= XFS_TRANS_NO_WRITECOUNT; 113 ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket); 114 115 ASSERT(tp->t_blk_res >= tp->t_blk_res_used); 116 ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used; 117 tp->t_blk_res = tp->t_blk_res_used; 118 119 ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used; 120 tp->t_rtx_res = tp->t_rtx_res_used; 121 ntp->t_pflags = tp->t_pflags; 122 123 /* move deferred ops over to the new tp */ 124 xfs_defer_move(ntp, tp); 125 126 xfs_trans_dup_dqinfo(tp, ntp); 127 128 atomic_inc(&tp->t_mountp->m_active_trans); 129 return ntp; 130 } 131 132 /* 133 * This is called to reserve free disk blocks and log space for the 134 * given transaction. This must be done before allocating any resources 135 * within the transaction. 136 * 137 * This will return ENOSPC if there are not enough blocks available. 138 * It will sleep waiting for available log space. 139 * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which 140 * is used by long running transactions. If any one of the reservations 141 * fails then they will all be backed out. 142 * 143 * This does not do quota reservations. That typically is done by the 144 * caller afterwards. 145 */ 146 static int 147 xfs_trans_reserve( 148 struct xfs_trans *tp, 149 struct xfs_trans_res *resp, 150 uint blocks, 151 uint rtextents) 152 { 153 int error = 0; 154 bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0; 155 156 /* Mark this thread as being in a transaction */ 157 current_set_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS); 158 159 /* 160 * Attempt to reserve the needed disk blocks by decrementing 161 * the number needed from the number available. This will 162 * fail if the count would go below zero. 163 */ 164 if (blocks > 0) { 165 error = xfs_mod_fdblocks(tp->t_mountp, -((int64_t)blocks), rsvd); 166 if (error != 0) { 167 current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS); 168 return -ENOSPC; 169 } 170 tp->t_blk_res += blocks; 171 } 172 173 /* 174 * Reserve the log space needed for this transaction. 175 */ 176 if (resp->tr_logres > 0) { 177 bool permanent = false; 178 179 ASSERT(tp->t_log_res == 0 || 180 tp->t_log_res == resp->tr_logres); 181 ASSERT(tp->t_log_count == 0 || 182 tp->t_log_count == resp->tr_logcount); 183 184 if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) { 185 tp->t_flags |= XFS_TRANS_PERM_LOG_RES; 186 permanent = true; 187 } else { 188 ASSERT(tp->t_ticket == NULL); 189 ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES)); 190 } 191 192 if (tp->t_ticket != NULL) { 193 ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES); 194 error = xfs_log_regrant(tp->t_mountp, tp->t_ticket); 195 } else { 196 error = xfs_log_reserve(tp->t_mountp, 197 resp->tr_logres, 198 resp->tr_logcount, 199 &tp->t_ticket, XFS_TRANSACTION, 200 permanent); 201 } 202 203 if (error) 204 goto undo_blocks; 205 206 tp->t_log_res = resp->tr_logres; 207 tp->t_log_count = resp->tr_logcount; 208 } 209 210 /* 211 * Attempt to reserve the needed realtime extents by decrementing 212 * the number needed from the number available. This will 213 * fail if the count would go below zero. 214 */ 215 if (rtextents > 0) { 216 error = xfs_mod_frextents(tp->t_mountp, -((int64_t)rtextents)); 217 if (error) { 218 error = -ENOSPC; 219 goto undo_log; 220 } 221 tp->t_rtx_res += rtextents; 222 } 223 224 return 0; 225 226 /* 227 * Error cases jump to one of these labels to undo any 228 * reservations which have already been performed. 229 */ 230 undo_log: 231 if (resp->tr_logres > 0) { 232 xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, false); 233 tp->t_ticket = NULL; 234 tp->t_log_res = 0; 235 tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES; 236 } 237 238 undo_blocks: 239 if (blocks > 0) { 240 xfs_mod_fdblocks(tp->t_mountp, (int64_t)blocks, rsvd); 241 tp->t_blk_res = 0; 242 } 243 244 current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS); 245 246 return error; 247 } 248 249 int 250 xfs_trans_alloc( 251 struct xfs_mount *mp, 252 struct xfs_trans_res *resp, 253 uint blocks, 254 uint rtextents, 255 uint flags, 256 struct xfs_trans **tpp) 257 { 258 struct xfs_trans *tp; 259 int error; 260 261 /* 262 * Allocate the handle before we do our freeze accounting and setting up 263 * GFP_NOFS allocation context so that we avoid lockdep false positives 264 * by doing GFP_KERNEL allocations inside sb_start_intwrite(). 265 */ 266 tp = kmem_zone_zalloc(xfs_trans_zone, 0); 267 if (!(flags & XFS_TRANS_NO_WRITECOUNT)) 268 sb_start_intwrite(mp->m_super); 269 270 /* 271 * Zero-reservation ("empty") transactions can't modify anything, so 272 * they're allowed to run while we're frozen. 273 */ 274 WARN_ON(resp->tr_logres > 0 && 275 mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE); 276 atomic_inc(&mp->m_active_trans); 277 278 tp->t_magic = XFS_TRANS_HEADER_MAGIC; 279 tp->t_flags = flags; 280 tp->t_mountp = mp; 281 INIT_LIST_HEAD(&tp->t_items); 282 INIT_LIST_HEAD(&tp->t_busy); 283 INIT_LIST_HEAD(&tp->t_dfops); 284 tp->t_firstblock = NULLFSBLOCK; 285 286 error = xfs_trans_reserve(tp, resp, blocks, rtextents); 287 if (error) { 288 xfs_trans_cancel(tp); 289 return error; 290 } 291 292 trace_xfs_trans_alloc(tp, _RET_IP_); 293 294 *tpp = tp; 295 return 0; 296 } 297 298 /* 299 * Create an empty transaction with no reservation. This is a defensive 300 * mechanism for routines that query metadata without actually modifying 301 * them -- if the metadata being queried is somehow cross-linked (think a 302 * btree block pointer that points higher in the tree), we risk deadlock. 303 * However, blocks grabbed as part of a transaction can be re-grabbed. 304 * The verifiers will notice the corrupt block and the operation will fail 305 * back to userspace without deadlocking. 306 * 307 * Note the zero-length reservation; this transaction MUST be cancelled 308 * without any dirty data. 309 */ 310 int 311 xfs_trans_alloc_empty( 312 struct xfs_mount *mp, 313 struct xfs_trans **tpp) 314 { 315 struct xfs_trans_res resv = {0}; 316 317 return xfs_trans_alloc(mp, &resv, 0, 0, XFS_TRANS_NO_WRITECOUNT, tpp); 318 } 319 320 /* 321 * Record the indicated change to the given field for application 322 * to the file system's superblock when the transaction commits. 323 * For now, just store the change in the transaction structure. 324 * 325 * Mark the transaction structure to indicate that the superblock 326 * needs to be updated before committing. 327 * 328 * Because we may not be keeping track of allocated/free inodes and 329 * used filesystem blocks in the superblock, we do not mark the 330 * superblock dirty in this transaction if we modify these fields. 331 * We still need to update the transaction deltas so that they get 332 * applied to the incore superblock, but we don't want them to 333 * cause the superblock to get locked and logged if these are the 334 * only fields in the superblock that the transaction modifies. 335 */ 336 void 337 xfs_trans_mod_sb( 338 xfs_trans_t *tp, 339 uint field, 340 int64_t delta) 341 { 342 uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY); 343 xfs_mount_t *mp = tp->t_mountp; 344 345 switch (field) { 346 case XFS_TRANS_SB_ICOUNT: 347 tp->t_icount_delta += delta; 348 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 349 flags &= ~XFS_TRANS_SB_DIRTY; 350 break; 351 case XFS_TRANS_SB_IFREE: 352 tp->t_ifree_delta += delta; 353 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 354 flags &= ~XFS_TRANS_SB_DIRTY; 355 break; 356 case XFS_TRANS_SB_FDBLOCKS: 357 /* 358 * Track the number of blocks allocated in the transaction. 359 * Make sure it does not exceed the number reserved. If so, 360 * shutdown as this can lead to accounting inconsistency. 361 */ 362 if (delta < 0) { 363 tp->t_blk_res_used += (uint)-delta; 364 if (tp->t_blk_res_used > tp->t_blk_res) 365 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 366 } 367 tp->t_fdblocks_delta += delta; 368 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 369 flags &= ~XFS_TRANS_SB_DIRTY; 370 break; 371 case XFS_TRANS_SB_RES_FDBLOCKS: 372 /* 373 * The allocation has already been applied to the 374 * in-core superblock's counter. This should only 375 * be applied to the on-disk superblock. 376 */ 377 tp->t_res_fdblocks_delta += delta; 378 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 379 flags &= ~XFS_TRANS_SB_DIRTY; 380 break; 381 case XFS_TRANS_SB_FREXTENTS: 382 /* 383 * Track the number of blocks allocated in the 384 * transaction. Make sure it does not exceed the 385 * number reserved. 386 */ 387 if (delta < 0) { 388 tp->t_rtx_res_used += (uint)-delta; 389 ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res); 390 } 391 tp->t_frextents_delta += delta; 392 break; 393 case XFS_TRANS_SB_RES_FREXTENTS: 394 /* 395 * The allocation has already been applied to the 396 * in-core superblock's counter. This should only 397 * be applied to the on-disk superblock. 398 */ 399 ASSERT(delta < 0); 400 tp->t_res_frextents_delta += delta; 401 break; 402 case XFS_TRANS_SB_DBLOCKS: 403 ASSERT(delta > 0); 404 tp->t_dblocks_delta += delta; 405 break; 406 case XFS_TRANS_SB_AGCOUNT: 407 ASSERT(delta > 0); 408 tp->t_agcount_delta += delta; 409 break; 410 case XFS_TRANS_SB_IMAXPCT: 411 tp->t_imaxpct_delta += delta; 412 break; 413 case XFS_TRANS_SB_REXTSIZE: 414 tp->t_rextsize_delta += delta; 415 break; 416 case XFS_TRANS_SB_RBMBLOCKS: 417 tp->t_rbmblocks_delta += delta; 418 break; 419 case XFS_TRANS_SB_RBLOCKS: 420 tp->t_rblocks_delta += delta; 421 break; 422 case XFS_TRANS_SB_REXTENTS: 423 tp->t_rextents_delta += delta; 424 break; 425 case XFS_TRANS_SB_REXTSLOG: 426 tp->t_rextslog_delta += delta; 427 break; 428 default: 429 ASSERT(0); 430 return; 431 } 432 433 tp->t_flags |= flags; 434 } 435 436 /* 437 * xfs_trans_apply_sb_deltas() is called from the commit code 438 * to bring the superblock buffer into the current transaction 439 * and modify it as requested by earlier calls to xfs_trans_mod_sb(). 440 * 441 * For now we just look at each field allowed to change and change 442 * it if necessary. 443 */ 444 STATIC void 445 xfs_trans_apply_sb_deltas( 446 xfs_trans_t *tp) 447 { 448 xfs_dsb_t *sbp; 449 xfs_buf_t *bp; 450 int whole = 0; 451 452 bp = xfs_trans_getsb(tp, tp->t_mountp); 453 sbp = XFS_BUF_TO_SBP(bp); 454 455 /* 456 * Check that superblock mods match the mods made to AGF counters. 457 */ 458 ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) == 459 (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta + 460 tp->t_ag_btree_delta)); 461 462 /* 463 * Only update the superblock counters if we are logging them 464 */ 465 if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) { 466 if (tp->t_icount_delta) 467 be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta); 468 if (tp->t_ifree_delta) 469 be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta); 470 if (tp->t_fdblocks_delta) 471 be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta); 472 if (tp->t_res_fdblocks_delta) 473 be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta); 474 } 475 476 if (tp->t_frextents_delta) 477 be64_add_cpu(&sbp->sb_frextents, tp->t_frextents_delta); 478 if (tp->t_res_frextents_delta) 479 be64_add_cpu(&sbp->sb_frextents, tp->t_res_frextents_delta); 480 481 if (tp->t_dblocks_delta) { 482 be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta); 483 whole = 1; 484 } 485 if (tp->t_agcount_delta) { 486 be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta); 487 whole = 1; 488 } 489 if (tp->t_imaxpct_delta) { 490 sbp->sb_imax_pct += tp->t_imaxpct_delta; 491 whole = 1; 492 } 493 if (tp->t_rextsize_delta) { 494 be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta); 495 whole = 1; 496 } 497 if (tp->t_rbmblocks_delta) { 498 be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta); 499 whole = 1; 500 } 501 if (tp->t_rblocks_delta) { 502 be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta); 503 whole = 1; 504 } 505 if (tp->t_rextents_delta) { 506 be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta); 507 whole = 1; 508 } 509 if (tp->t_rextslog_delta) { 510 sbp->sb_rextslog += tp->t_rextslog_delta; 511 whole = 1; 512 } 513 514 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF); 515 if (whole) 516 /* 517 * Log the whole thing, the fields are noncontiguous. 518 */ 519 xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1); 520 else 521 /* 522 * Since all the modifiable fields are contiguous, we 523 * can get away with this. 524 */ 525 xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount), 526 offsetof(xfs_dsb_t, sb_frextents) + 527 sizeof(sbp->sb_frextents) - 1); 528 } 529 530 STATIC int 531 xfs_sb_mod8( 532 uint8_t *field, 533 int8_t delta) 534 { 535 int8_t counter = *field; 536 537 counter += delta; 538 if (counter < 0) { 539 ASSERT(0); 540 return -EINVAL; 541 } 542 *field = counter; 543 return 0; 544 } 545 546 STATIC int 547 xfs_sb_mod32( 548 uint32_t *field, 549 int32_t delta) 550 { 551 int32_t counter = *field; 552 553 counter += delta; 554 if (counter < 0) { 555 ASSERT(0); 556 return -EINVAL; 557 } 558 *field = counter; 559 return 0; 560 } 561 562 STATIC int 563 xfs_sb_mod64( 564 uint64_t *field, 565 int64_t delta) 566 { 567 int64_t counter = *field; 568 569 counter += delta; 570 if (counter < 0) { 571 ASSERT(0); 572 return -EINVAL; 573 } 574 *field = counter; 575 return 0; 576 } 577 578 /* 579 * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations 580 * and apply superblock counter changes to the in-core superblock. The 581 * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT 582 * applied to the in-core superblock. The idea is that that has already been 583 * done. 584 * 585 * If we are not logging superblock counters, then the inode allocated/free and 586 * used block counts are not updated in the on disk superblock. In this case, 587 * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we 588 * still need to update the incore superblock with the changes. 589 */ 590 void 591 xfs_trans_unreserve_and_mod_sb( 592 struct xfs_trans *tp) 593 { 594 struct xfs_mount *mp = tp->t_mountp; 595 bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0; 596 int64_t blkdelta = 0; 597 int64_t rtxdelta = 0; 598 int64_t idelta = 0; 599 int64_t ifreedelta = 0; 600 int error; 601 602 /* calculate deltas */ 603 if (tp->t_blk_res > 0) 604 blkdelta = tp->t_blk_res; 605 if ((tp->t_fdblocks_delta != 0) && 606 (xfs_sb_version_haslazysbcount(&mp->m_sb) || 607 (tp->t_flags & XFS_TRANS_SB_DIRTY))) 608 blkdelta += tp->t_fdblocks_delta; 609 610 if (tp->t_rtx_res > 0) 611 rtxdelta = tp->t_rtx_res; 612 if ((tp->t_frextents_delta != 0) && 613 (tp->t_flags & XFS_TRANS_SB_DIRTY)) 614 rtxdelta += tp->t_frextents_delta; 615 616 if (xfs_sb_version_haslazysbcount(&mp->m_sb) || 617 (tp->t_flags & XFS_TRANS_SB_DIRTY)) { 618 idelta = tp->t_icount_delta; 619 ifreedelta = tp->t_ifree_delta; 620 } 621 622 /* apply the per-cpu counters */ 623 if (blkdelta) { 624 error = xfs_mod_fdblocks(mp, blkdelta, rsvd); 625 if (error) 626 goto out; 627 } 628 629 if (idelta) { 630 error = xfs_mod_icount(mp, idelta); 631 if (error) 632 goto out_undo_fdblocks; 633 } 634 635 if (ifreedelta) { 636 error = xfs_mod_ifree(mp, ifreedelta); 637 if (error) 638 goto out_undo_icount; 639 } 640 641 if (rtxdelta == 0 && !(tp->t_flags & XFS_TRANS_SB_DIRTY)) 642 return; 643 644 /* apply remaining deltas */ 645 spin_lock(&mp->m_sb_lock); 646 if (rtxdelta) { 647 error = xfs_sb_mod64(&mp->m_sb.sb_frextents, rtxdelta); 648 if (error) 649 goto out_undo_ifree; 650 } 651 652 if (tp->t_dblocks_delta != 0) { 653 error = xfs_sb_mod64(&mp->m_sb.sb_dblocks, tp->t_dblocks_delta); 654 if (error) 655 goto out_undo_frextents; 656 } 657 if (tp->t_agcount_delta != 0) { 658 error = xfs_sb_mod32(&mp->m_sb.sb_agcount, tp->t_agcount_delta); 659 if (error) 660 goto out_undo_dblocks; 661 } 662 if (tp->t_imaxpct_delta != 0) { 663 error = xfs_sb_mod8(&mp->m_sb.sb_imax_pct, tp->t_imaxpct_delta); 664 if (error) 665 goto out_undo_agcount; 666 } 667 if (tp->t_rextsize_delta != 0) { 668 error = xfs_sb_mod32(&mp->m_sb.sb_rextsize, 669 tp->t_rextsize_delta); 670 if (error) 671 goto out_undo_imaxpct; 672 } 673 if (tp->t_rbmblocks_delta != 0) { 674 error = xfs_sb_mod32(&mp->m_sb.sb_rbmblocks, 675 tp->t_rbmblocks_delta); 676 if (error) 677 goto out_undo_rextsize; 678 } 679 if (tp->t_rblocks_delta != 0) { 680 error = xfs_sb_mod64(&mp->m_sb.sb_rblocks, tp->t_rblocks_delta); 681 if (error) 682 goto out_undo_rbmblocks; 683 } 684 if (tp->t_rextents_delta != 0) { 685 error = xfs_sb_mod64(&mp->m_sb.sb_rextents, 686 tp->t_rextents_delta); 687 if (error) 688 goto out_undo_rblocks; 689 } 690 if (tp->t_rextslog_delta != 0) { 691 error = xfs_sb_mod8(&mp->m_sb.sb_rextslog, 692 tp->t_rextslog_delta); 693 if (error) 694 goto out_undo_rextents; 695 } 696 spin_unlock(&mp->m_sb_lock); 697 return; 698 699 out_undo_rextents: 700 if (tp->t_rextents_delta) 701 xfs_sb_mod64(&mp->m_sb.sb_rextents, -tp->t_rextents_delta); 702 out_undo_rblocks: 703 if (tp->t_rblocks_delta) 704 xfs_sb_mod64(&mp->m_sb.sb_rblocks, -tp->t_rblocks_delta); 705 out_undo_rbmblocks: 706 if (tp->t_rbmblocks_delta) 707 xfs_sb_mod32(&mp->m_sb.sb_rbmblocks, -tp->t_rbmblocks_delta); 708 out_undo_rextsize: 709 if (tp->t_rextsize_delta) 710 xfs_sb_mod32(&mp->m_sb.sb_rextsize, -tp->t_rextsize_delta); 711 out_undo_imaxpct: 712 if (tp->t_rextsize_delta) 713 xfs_sb_mod8(&mp->m_sb.sb_imax_pct, -tp->t_imaxpct_delta); 714 out_undo_agcount: 715 if (tp->t_agcount_delta) 716 xfs_sb_mod32(&mp->m_sb.sb_agcount, -tp->t_agcount_delta); 717 out_undo_dblocks: 718 if (tp->t_dblocks_delta) 719 xfs_sb_mod64(&mp->m_sb.sb_dblocks, -tp->t_dblocks_delta); 720 out_undo_frextents: 721 if (rtxdelta) 722 xfs_sb_mod64(&mp->m_sb.sb_frextents, -rtxdelta); 723 out_undo_ifree: 724 spin_unlock(&mp->m_sb_lock); 725 if (ifreedelta) 726 xfs_mod_ifree(mp, -ifreedelta); 727 out_undo_icount: 728 if (idelta) 729 xfs_mod_icount(mp, -idelta); 730 out_undo_fdblocks: 731 if (blkdelta) 732 xfs_mod_fdblocks(mp, -blkdelta, rsvd); 733 out: 734 ASSERT(error == 0); 735 return; 736 } 737 738 /* Add the given log item to the transaction's list of log items. */ 739 void 740 xfs_trans_add_item( 741 struct xfs_trans *tp, 742 struct xfs_log_item *lip) 743 { 744 ASSERT(lip->li_mountp == tp->t_mountp); 745 ASSERT(lip->li_ailp == tp->t_mountp->m_ail); 746 ASSERT(list_empty(&lip->li_trans)); 747 ASSERT(!test_bit(XFS_LI_DIRTY, &lip->li_flags)); 748 749 list_add_tail(&lip->li_trans, &tp->t_items); 750 trace_xfs_trans_add_item(tp, _RET_IP_); 751 } 752 753 /* 754 * Unlink the log item from the transaction. the log item is no longer 755 * considered dirty in this transaction, as the linked transaction has 756 * finished, either by abort or commit completion. 757 */ 758 void 759 xfs_trans_del_item( 760 struct xfs_log_item *lip) 761 { 762 clear_bit(XFS_LI_DIRTY, &lip->li_flags); 763 list_del_init(&lip->li_trans); 764 } 765 766 /* Detach and unlock all of the items in a transaction */ 767 static void 768 xfs_trans_free_items( 769 struct xfs_trans *tp, 770 bool abort) 771 { 772 struct xfs_log_item *lip, *next; 773 774 trace_xfs_trans_free_items(tp, _RET_IP_); 775 776 list_for_each_entry_safe(lip, next, &tp->t_items, li_trans) { 777 xfs_trans_del_item(lip); 778 if (abort) 779 set_bit(XFS_LI_ABORTED, &lip->li_flags); 780 if (lip->li_ops->iop_release) 781 lip->li_ops->iop_release(lip); 782 } 783 } 784 785 static inline void 786 xfs_log_item_batch_insert( 787 struct xfs_ail *ailp, 788 struct xfs_ail_cursor *cur, 789 struct xfs_log_item **log_items, 790 int nr_items, 791 xfs_lsn_t commit_lsn) 792 { 793 int i; 794 795 spin_lock(&ailp->ail_lock); 796 /* xfs_trans_ail_update_bulk drops ailp->ail_lock */ 797 xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn); 798 799 for (i = 0; i < nr_items; i++) { 800 struct xfs_log_item *lip = log_items[i]; 801 802 if (lip->li_ops->iop_unpin) 803 lip->li_ops->iop_unpin(lip, 0); 804 } 805 } 806 807 /* 808 * Bulk operation version of xfs_trans_committed that takes a log vector of 809 * items to insert into the AIL. This uses bulk AIL insertion techniques to 810 * minimise lock traffic. 811 * 812 * If we are called with the aborted flag set, it is because a log write during 813 * a CIL checkpoint commit has failed. In this case, all the items in the 814 * checkpoint have already gone through iop_committed and iop_committing, which 815 * means that checkpoint commit abort handling is treated exactly the same 816 * as an iclog write error even though we haven't started any IO yet. Hence in 817 * this case all we need to do is iop_committed processing, followed by an 818 * iop_unpin(aborted) call. 819 * 820 * The AIL cursor is used to optimise the insert process. If commit_lsn is not 821 * at the end of the AIL, the insert cursor avoids the need to walk 822 * the AIL to find the insertion point on every xfs_log_item_batch_insert() 823 * call. This saves a lot of needless list walking and is a net win, even 824 * though it slightly increases that amount of AIL lock traffic to set it up 825 * and tear it down. 826 */ 827 void 828 xfs_trans_committed_bulk( 829 struct xfs_ail *ailp, 830 struct xfs_log_vec *log_vector, 831 xfs_lsn_t commit_lsn, 832 bool aborted) 833 { 834 #define LOG_ITEM_BATCH_SIZE 32 835 struct xfs_log_item *log_items[LOG_ITEM_BATCH_SIZE]; 836 struct xfs_log_vec *lv; 837 struct xfs_ail_cursor cur; 838 int i = 0; 839 840 spin_lock(&ailp->ail_lock); 841 xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn); 842 spin_unlock(&ailp->ail_lock); 843 844 /* unpin all the log items */ 845 for (lv = log_vector; lv; lv = lv->lv_next ) { 846 struct xfs_log_item *lip = lv->lv_item; 847 xfs_lsn_t item_lsn; 848 849 if (aborted) 850 set_bit(XFS_LI_ABORTED, &lip->li_flags); 851 852 if (lip->li_ops->flags & XFS_ITEM_RELEASE_WHEN_COMMITTED) { 853 lip->li_ops->iop_release(lip); 854 continue; 855 } 856 857 if (lip->li_ops->iop_committed) 858 item_lsn = lip->li_ops->iop_committed(lip, commit_lsn); 859 else 860 item_lsn = commit_lsn; 861 862 /* item_lsn of -1 means the item needs no further processing */ 863 if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0) 864 continue; 865 866 /* 867 * if we are aborting the operation, no point in inserting the 868 * object into the AIL as we are in a shutdown situation. 869 */ 870 if (aborted) { 871 ASSERT(XFS_FORCED_SHUTDOWN(ailp->ail_mount)); 872 if (lip->li_ops->iop_unpin) 873 lip->li_ops->iop_unpin(lip, 1); 874 continue; 875 } 876 877 if (item_lsn != commit_lsn) { 878 879 /* 880 * Not a bulk update option due to unusual item_lsn. 881 * Push into AIL immediately, rechecking the lsn once 882 * we have the ail lock. Then unpin the item. This does 883 * not affect the AIL cursor the bulk insert path is 884 * using. 885 */ 886 spin_lock(&ailp->ail_lock); 887 if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) 888 xfs_trans_ail_update(ailp, lip, item_lsn); 889 else 890 spin_unlock(&ailp->ail_lock); 891 if (lip->li_ops->iop_unpin) 892 lip->li_ops->iop_unpin(lip, 0); 893 continue; 894 } 895 896 /* Item is a candidate for bulk AIL insert. */ 897 log_items[i++] = lv->lv_item; 898 if (i >= LOG_ITEM_BATCH_SIZE) { 899 xfs_log_item_batch_insert(ailp, &cur, log_items, 900 LOG_ITEM_BATCH_SIZE, commit_lsn); 901 i = 0; 902 } 903 } 904 905 /* make sure we insert the remainder! */ 906 if (i) 907 xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn); 908 909 spin_lock(&ailp->ail_lock); 910 xfs_trans_ail_cursor_done(&cur); 911 spin_unlock(&ailp->ail_lock); 912 } 913 914 /* 915 * Commit the given transaction to the log. 916 * 917 * XFS disk error handling mechanism is not based on a typical 918 * transaction abort mechanism. Logically after the filesystem 919 * gets marked 'SHUTDOWN', we can't let any new transactions 920 * be durable - ie. committed to disk - because some metadata might 921 * be inconsistent. In such cases, this returns an error, and the 922 * caller may assume that all locked objects joined to the transaction 923 * have already been unlocked as if the commit had succeeded. 924 * Do not reference the transaction structure after this call. 925 */ 926 static int 927 __xfs_trans_commit( 928 struct xfs_trans *tp, 929 bool regrant) 930 { 931 struct xfs_mount *mp = tp->t_mountp; 932 xfs_lsn_t commit_lsn = -1; 933 int error = 0; 934 int sync = tp->t_flags & XFS_TRANS_SYNC; 935 936 trace_xfs_trans_commit(tp, _RET_IP_); 937 938 /* 939 * Finish deferred items on final commit. Only permanent transactions 940 * should ever have deferred ops. 941 */ 942 WARN_ON_ONCE(!list_empty(&tp->t_dfops) && 943 !(tp->t_flags & XFS_TRANS_PERM_LOG_RES)); 944 if (!regrant && (tp->t_flags & XFS_TRANS_PERM_LOG_RES)) { 945 error = xfs_defer_finish_noroll(&tp); 946 if (error) 947 goto out_unreserve; 948 } 949 950 /* 951 * If there is nothing to be logged by the transaction, 952 * then unlock all of the items associated with the 953 * transaction and free the transaction structure. 954 * Also make sure to return any reserved blocks to 955 * the free pool. 956 */ 957 if (!(tp->t_flags & XFS_TRANS_DIRTY)) 958 goto out_unreserve; 959 960 if (XFS_FORCED_SHUTDOWN(mp)) { 961 error = -EIO; 962 goto out_unreserve; 963 } 964 965 ASSERT(tp->t_ticket != NULL); 966 967 /* 968 * If we need to update the superblock, then do it now. 969 */ 970 if (tp->t_flags & XFS_TRANS_SB_DIRTY) 971 xfs_trans_apply_sb_deltas(tp); 972 xfs_trans_apply_dquot_deltas(tp); 973 974 xfs_log_commit_cil(mp, tp, &commit_lsn, regrant); 975 976 current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS); 977 xfs_trans_free(tp); 978 979 /* 980 * If the transaction needs to be synchronous, then force the 981 * log out now and wait for it. 982 */ 983 if (sync) { 984 error = xfs_log_force_lsn(mp, commit_lsn, XFS_LOG_SYNC, NULL); 985 XFS_STATS_INC(mp, xs_trans_sync); 986 } else { 987 XFS_STATS_INC(mp, xs_trans_async); 988 } 989 990 return error; 991 992 out_unreserve: 993 xfs_trans_unreserve_and_mod_sb(tp); 994 995 /* 996 * It is indeed possible for the transaction to be not dirty but 997 * the dqinfo portion to be. All that means is that we have some 998 * (non-persistent) quota reservations that need to be unreserved. 999 */ 1000 xfs_trans_unreserve_and_mod_dquots(tp); 1001 if (tp->t_ticket) { 1002 commit_lsn = xfs_log_done(mp, tp->t_ticket, NULL, regrant); 1003 if (commit_lsn == -1 && !error) 1004 error = -EIO; 1005 tp->t_ticket = NULL; 1006 } 1007 current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS); 1008 xfs_trans_free_items(tp, !!error); 1009 xfs_trans_free(tp); 1010 1011 XFS_STATS_INC(mp, xs_trans_empty); 1012 return error; 1013 } 1014 1015 int 1016 xfs_trans_commit( 1017 struct xfs_trans *tp) 1018 { 1019 return __xfs_trans_commit(tp, false); 1020 } 1021 1022 /* 1023 * Unlock all of the transaction's items and free the transaction. 1024 * The transaction must not have modified any of its items, because 1025 * there is no way to restore them to their previous state. 1026 * 1027 * If the transaction has made a log reservation, make sure to release 1028 * it as well. 1029 */ 1030 void 1031 xfs_trans_cancel( 1032 struct xfs_trans *tp) 1033 { 1034 struct xfs_mount *mp = tp->t_mountp; 1035 bool dirty = (tp->t_flags & XFS_TRANS_DIRTY); 1036 1037 trace_xfs_trans_cancel(tp, _RET_IP_); 1038 1039 if (tp->t_flags & XFS_TRANS_PERM_LOG_RES) 1040 xfs_defer_cancel(tp); 1041 1042 /* 1043 * See if the caller is relying on us to shut down the 1044 * filesystem. This happens in paths where we detect 1045 * corruption and decide to give up. 1046 */ 1047 if (dirty && !XFS_FORCED_SHUTDOWN(mp)) { 1048 XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp); 1049 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 1050 } 1051 #ifdef DEBUG 1052 if (!dirty && !XFS_FORCED_SHUTDOWN(mp)) { 1053 struct xfs_log_item *lip; 1054 1055 list_for_each_entry(lip, &tp->t_items, li_trans) 1056 ASSERT(!(lip->li_type == XFS_LI_EFD)); 1057 } 1058 #endif 1059 xfs_trans_unreserve_and_mod_sb(tp); 1060 xfs_trans_unreserve_and_mod_dquots(tp); 1061 1062 if (tp->t_ticket) { 1063 xfs_log_done(mp, tp->t_ticket, NULL, false); 1064 tp->t_ticket = NULL; 1065 } 1066 1067 /* mark this thread as no longer being in a transaction */ 1068 current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS); 1069 1070 xfs_trans_free_items(tp, dirty); 1071 xfs_trans_free(tp); 1072 } 1073 1074 /* 1075 * Roll from one trans in the sequence of PERMANENT transactions to 1076 * the next: permanent transactions are only flushed out when 1077 * committed with xfs_trans_commit(), but we still want as soon 1078 * as possible to let chunks of it go to the log. So we commit the 1079 * chunk we've been working on and get a new transaction to continue. 1080 */ 1081 int 1082 xfs_trans_roll( 1083 struct xfs_trans **tpp) 1084 { 1085 struct xfs_trans *trans = *tpp; 1086 struct xfs_trans_res tres; 1087 int error; 1088 1089 trace_xfs_trans_roll(trans, _RET_IP_); 1090 1091 /* 1092 * Copy the critical parameters from one trans to the next. 1093 */ 1094 tres.tr_logres = trans->t_log_res; 1095 tres.tr_logcount = trans->t_log_count; 1096 1097 *tpp = xfs_trans_dup(trans); 1098 1099 /* 1100 * Commit the current transaction. 1101 * If this commit failed, then it'd just unlock those items that 1102 * are not marked ihold. That also means that a filesystem shutdown 1103 * is in progress. The caller takes the responsibility to cancel 1104 * the duplicate transaction that gets returned. 1105 */ 1106 error = __xfs_trans_commit(trans, true); 1107 if (error) 1108 return error; 1109 1110 /* 1111 * Reserve space in the log for the next transaction. 1112 * This also pushes items in the "AIL", the list of logged items, 1113 * out to disk if they are taking up space at the tail of the log 1114 * that we want to use. This requires that either nothing be locked 1115 * across this call, or that anything that is locked be logged in 1116 * the prior and the next transactions. 1117 */ 1118 tres.tr_logflags = XFS_TRANS_PERM_LOG_RES; 1119 return xfs_trans_reserve(*tpp, &tres, 0, 0); 1120 } 1121