1 /* 2 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18 #include "xfs.h" 19 #include "xfs_fs.h" 20 #include "xfs_types.h" 21 #include "xfs_bit.h" 22 #include "xfs_log.h" 23 #include "xfs_inum.h" 24 #include "xfs_trans.h" 25 #include "xfs_sb.h" 26 #include "xfs_ag.h" 27 #include "xfs_dir2.h" 28 #include "xfs_dmapi.h" 29 #include "xfs_mount.h" 30 #include "xfs_error.h" 31 #include "xfs_da_btree.h" 32 #include "xfs_bmap_btree.h" 33 #include "xfs_alloc_btree.h" 34 #include "xfs_ialloc_btree.h" 35 #include "xfs_dir2_sf.h" 36 #include "xfs_attr_sf.h" 37 #include "xfs_dinode.h" 38 #include "xfs_inode.h" 39 #include "xfs_btree.h" 40 #include "xfs_ialloc.h" 41 #include "xfs_alloc.h" 42 #include "xfs_bmap.h" 43 #include "xfs_quota.h" 44 #include "xfs_trans_priv.h" 45 #include "xfs_trans_space.h" 46 47 48 STATIC void xfs_trans_apply_sb_deltas(xfs_trans_t *); 49 STATIC uint xfs_trans_count_vecs(xfs_trans_t *); 50 STATIC void xfs_trans_fill_vecs(xfs_trans_t *, xfs_log_iovec_t *); 51 STATIC void xfs_trans_uncommit(xfs_trans_t *, uint); 52 STATIC void xfs_trans_committed(xfs_trans_t *, int); 53 STATIC void xfs_trans_chunk_committed(xfs_log_item_chunk_t *, xfs_lsn_t, int); 54 STATIC void xfs_trans_free(xfs_trans_t *); 55 56 kmem_zone_t *xfs_trans_zone; 57 58 59 /* 60 * Reservation functions here avoid a huge stack in xfs_trans_init 61 * due to register overflow from temporaries in the calculations. 62 */ 63 64 STATIC uint 65 xfs_calc_write_reservation(xfs_mount_t *mp) 66 { 67 return XFS_CALC_WRITE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 68 } 69 70 STATIC uint 71 xfs_calc_itruncate_reservation(xfs_mount_t *mp) 72 { 73 return XFS_CALC_ITRUNCATE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 74 } 75 76 STATIC uint 77 xfs_calc_rename_reservation(xfs_mount_t *mp) 78 { 79 return XFS_CALC_RENAME_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 80 } 81 82 STATIC uint 83 xfs_calc_link_reservation(xfs_mount_t *mp) 84 { 85 return XFS_CALC_LINK_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 86 } 87 88 STATIC uint 89 xfs_calc_remove_reservation(xfs_mount_t *mp) 90 { 91 return XFS_CALC_REMOVE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 92 } 93 94 STATIC uint 95 xfs_calc_symlink_reservation(xfs_mount_t *mp) 96 { 97 return XFS_CALC_SYMLINK_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 98 } 99 100 STATIC uint 101 xfs_calc_create_reservation(xfs_mount_t *mp) 102 { 103 return XFS_CALC_CREATE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 104 } 105 106 STATIC uint 107 xfs_calc_mkdir_reservation(xfs_mount_t *mp) 108 { 109 return XFS_CALC_MKDIR_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 110 } 111 112 STATIC uint 113 xfs_calc_ifree_reservation(xfs_mount_t *mp) 114 { 115 return XFS_CALC_IFREE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 116 } 117 118 STATIC uint 119 xfs_calc_ichange_reservation(xfs_mount_t *mp) 120 { 121 return XFS_CALC_ICHANGE_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 122 } 123 124 STATIC uint 125 xfs_calc_growdata_reservation(xfs_mount_t *mp) 126 { 127 return XFS_CALC_GROWDATA_LOG_RES(mp); 128 } 129 130 STATIC uint 131 xfs_calc_growrtalloc_reservation(xfs_mount_t *mp) 132 { 133 return XFS_CALC_GROWRTALLOC_LOG_RES(mp); 134 } 135 136 STATIC uint 137 xfs_calc_growrtzero_reservation(xfs_mount_t *mp) 138 { 139 return XFS_CALC_GROWRTZERO_LOG_RES(mp); 140 } 141 142 STATIC uint 143 xfs_calc_growrtfree_reservation(xfs_mount_t *mp) 144 { 145 return XFS_CALC_GROWRTFREE_LOG_RES(mp); 146 } 147 148 STATIC uint 149 xfs_calc_swrite_reservation(xfs_mount_t *mp) 150 { 151 return XFS_CALC_SWRITE_LOG_RES(mp); 152 } 153 154 STATIC uint 155 xfs_calc_writeid_reservation(xfs_mount_t *mp) 156 { 157 return XFS_CALC_WRITEID_LOG_RES(mp); 158 } 159 160 STATIC uint 161 xfs_calc_addafork_reservation(xfs_mount_t *mp) 162 { 163 return XFS_CALC_ADDAFORK_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 164 } 165 166 STATIC uint 167 xfs_calc_attrinval_reservation(xfs_mount_t *mp) 168 { 169 return XFS_CALC_ATTRINVAL_LOG_RES(mp); 170 } 171 172 STATIC uint 173 xfs_calc_attrset_reservation(xfs_mount_t *mp) 174 { 175 return XFS_CALC_ATTRSET_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 176 } 177 178 STATIC uint 179 xfs_calc_attrrm_reservation(xfs_mount_t *mp) 180 { 181 return XFS_CALC_ATTRRM_LOG_RES(mp) + XFS_DQUOT_LOGRES(mp); 182 } 183 184 STATIC uint 185 xfs_calc_clear_agi_bucket_reservation(xfs_mount_t *mp) 186 { 187 return XFS_CALC_CLEAR_AGI_BUCKET_LOG_RES(mp); 188 } 189 190 /* 191 * Initialize the precomputed transaction reservation values 192 * in the mount structure. 193 */ 194 void 195 xfs_trans_init( 196 xfs_mount_t *mp) 197 { 198 xfs_trans_reservations_t *resp; 199 200 resp = &(mp->m_reservations); 201 resp->tr_write = xfs_calc_write_reservation(mp); 202 resp->tr_itruncate = xfs_calc_itruncate_reservation(mp); 203 resp->tr_rename = xfs_calc_rename_reservation(mp); 204 resp->tr_link = xfs_calc_link_reservation(mp); 205 resp->tr_remove = xfs_calc_remove_reservation(mp); 206 resp->tr_symlink = xfs_calc_symlink_reservation(mp); 207 resp->tr_create = xfs_calc_create_reservation(mp); 208 resp->tr_mkdir = xfs_calc_mkdir_reservation(mp); 209 resp->tr_ifree = xfs_calc_ifree_reservation(mp); 210 resp->tr_ichange = xfs_calc_ichange_reservation(mp); 211 resp->tr_growdata = xfs_calc_growdata_reservation(mp); 212 resp->tr_swrite = xfs_calc_swrite_reservation(mp); 213 resp->tr_writeid = xfs_calc_writeid_reservation(mp); 214 resp->tr_addafork = xfs_calc_addafork_reservation(mp); 215 resp->tr_attrinval = xfs_calc_attrinval_reservation(mp); 216 resp->tr_attrset = xfs_calc_attrset_reservation(mp); 217 resp->tr_attrrm = xfs_calc_attrrm_reservation(mp); 218 resp->tr_clearagi = xfs_calc_clear_agi_bucket_reservation(mp); 219 resp->tr_growrtalloc = xfs_calc_growrtalloc_reservation(mp); 220 resp->tr_growrtzero = xfs_calc_growrtzero_reservation(mp); 221 resp->tr_growrtfree = xfs_calc_growrtfree_reservation(mp); 222 } 223 224 /* 225 * This routine is called to allocate a transaction structure. 226 * The type parameter indicates the type of the transaction. These 227 * are enumerated in xfs_trans.h. 228 * 229 * Dynamically allocate the transaction structure from the transaction 230 * zone, initialize it, and return it to the caller. 231 */ 232 xfs_trans_t * 233 xfs_trans_alloc( 234 xfs_mount_t *mp, 235 uint type) 236 { 237 vfs_wait_for_freeze(XFS_MTOVFS(mp), SB_FREEZE_TRANS); 238 return _xfs_trans_alloc(mp, type); 239 } 240 241 xfs_trans_t * 242 _xfs_trans_alloc( 243 xfs_mount_t *mp, 244 uint type) 245 { 246 xfs_trans_t *tp; 247 248 atomic_inc(&mp->m_active_trans); 249 250 tp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP); 251 tp->t_magic = XFS_TRANS_MAGIC; 252 tp->t_type = type; 253 tp->t_mountp = mp; 254 tp->t_items_free = XFS_LIC_NUM_SLOTS; 255 tp->t_busy_free = XFS_LBC_NUM_SLOTS; 256 XFS_LIC_INIT(&(tp->t_items)); 257 XFS_LBC_INIT(&(tp->t_busy)); 258 return tp; 259 } 260 261 /* 262 * This is called to create a new transaction which will share the 263 * permanent log reservation of the given transaction. The remaining 264 * unused block and rt extent reservations are also inherited. This 265 * implies that the original transaction is no longer allowed to allocate 266 * blocks. Locks and log items, however, are no inherited. They must 267 * be added to the new transaction explicitly. 268 */ 269 xfs_trans_t * 270 xfs_trans_dup( 271 xfs_trans_t *tp) 272 { 273 xfs_trans_t *ntp; 274 275 ntp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP); 276 277 /* 278 * Initialize the new transaction structure. 279 */ 280 ntp->t_magic = XFS_TRANS_MAGIC; 281 ntp->t_type = tp->t_type; 282 ntp->t_mountp = tp->t_mountp; 283 ntp->t_items_free = XFS_LIC_NUM_SLOTS; 284 ntp->t_busy_free = XFS_LBC_NUM_SLOTS; 285 XFS_LIC_INIT(&(ntp->t_items)); 286 XFS_LBC_INIT(&(ntp->t_busy)); 287 288 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 289 ASSERT(tp->t_ticket != NULL); 290 291 ntp->t_flags = XFS_TRANS_PERM_LOG_RES | (tp->t_flags & XFS_TRANS_RESERVE); 292 ntp->t_ticket = tp->t_ticket; 293 ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used; 294 tp->t_blk_res = tp->t_blk_res_used; 295 ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used; 296 tp->t_rtx_res = tp->t_rtx_res_used; 297 ntp->t_pflags = tp->t_pflags; 298 299 XFS_TRANS_DUP_DQINFO(tp->t_mountp, tp, ntp); 300 301 atomic_inc(&tp->t_mountp->m_active_trans); 302 return ntp; 303 } 304 305 /* 306 * This is called to reserve free disk blocks and log space for the 307 * given transaction. This must be done before allocating any resources 308 * within the transaction. 309 * 310 * This will return ENOSPC if there are not enough blocks available. 311 * It will sleep waiting for available log space. 312 * The only valid value for the flags parameter is XFS_RES_LOG_PERM, which 313 * is used by long running transactions. If any one of the reservations 314 * fails then they will all be backed out. 315 * 316 * This does not do quota reservations. That typically is done by the 317 * caller afterwards. 318 */ 319 int 320 xfs_trans_reserve( 321 xfs_trans_t *tp, 322 uint blocks, 323 uint logspace, 324 uint rtextents, 325 uint flags, 326 uint logcount) 327 { 328 int log_flags; 329 int error = 0; 330 int rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0; 331 332 /* Mark this thread as being in a transaction */ 333 current_set_flags_nested(&tp->t_pflags, PF_FSTRANS); 334 335 /* 336 * Attempt to reserve the needed disk blocks by decrementing 337 * the number needed from the number available. This will 338 * fail if the count would go below zero. 339 */ 340 if (blocks > 0) { 341 error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FDBLOCKS, 342 -((int64_t)blocks), rsvd); 343 if (error != 0) { 344 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 345 return (XFS_ERROR(ENOSPC)); 346 } 347 tp->t_blk_res += blocks; 348 } 349 350 /* 351 * Reserve the log space needed for this transaction. 352 */ 353 if (logspace > 0) { 354 ASSERT((tp->t_log_res == 0) || (tp->t_log_res == logspace)); 355 ASSERT((tp->t_log_count == 0) || 356 (tp->t_log_count == logcount)); 357 if (flags & XFS_TRANS_PERM_LOG_RES) { 358 log_flags = XFS_LOG_PERM_RESERV; 359 tp->t_flags |= XFS_TRANS_PERM_LOG_RES; 360 } else { 361 ASSERT(tp->t_ticket == NULL); 362 ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES)); 363 log_flags = 0; 364 } 365 366 error = xfs_log_reserve(tp->t_mountp, logspace, logcount, 367 &tp->t_ticket, 368 XFS_TRANSACTION, log_flags, tp->t_type); 369 if (error) { 370 goto undo_blocks; 371 } 372 tp->t_log_res = logspace; 373 tp->t_log_count = logcount; 374 } 375 376 /* 377 * Attempt to reserve the needed realtime extents by decrementing 378 * the number needed from the number available. This will 379 * fail if the count would go below zero. 380 */ 381 if (rtextents > 0) { 382 error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FREXTENTS, 383 -((int64_t)rtextents), rsvd); 384 if (error) { 385 error = XFS_ERROR(ENOSPC); 386 goto undo_log; 387 } 388 tp->t_rtx_res += rtextents; 389 } 390 391 return 0; 392 393 /* 394 * Error cases jump to one of these labels to undo any 395 * reservations which have already been performed. 396 */ 397 undo_log: 398 if (logspace > 0) { 399 if (flags & XFS_TRANS_PERM_LOG_RES) { 400 log_flags = XFS_LOG_REL_PERM_RESERV; 401 } else { 402 log_flags = 0; 403 } 404 xfs_log_done(tp->t_mountp, tp->t_ticket, NULL, log_flags); 405 tp->t_ticket = NULL; 406 tp->t_log_res = 0; 407 tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES; 408 } 409 410 undo_blocks: 411 if (blocks > 0) { 412 (void) xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FDBLOCKS, 413 (int64_t)blocks, rsvd); 414 tp->t_blk_res = 0; 415 } 416 417 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 418 419 return error; 420 } 421 422 423 /* 424 * Record the indicated change to the given field for application 425 * to the file system's superblock when the transaction commits. 426 * For now, just store the change in the transaction structure. 427 * 428 * Mark the transaction structure to indicate that the superblock 429 * needs to be updated before committing. 430 * 431 * Because we may not be keeping track of allocated/free inodes and 432 * used filesystem blocks in the superblock, we do not mark the 433 * superblock dirty in this transaction if we modify these fields. 434 * We still need to update the transaction deltas so that they get 435 * applied to the incore superblock, but we don't want them to 436 * cause the superblock to get locked and logged if these are the 437 * only fields in the superblock that the transaction modifies. 438 */ 439 void 440 xfs_trans_mod_sb( 441 xfs_trans_t *tp, 442 uint field, 443 int64_t delta) 444 { 445 uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY); 446 xfs_mount_t *mp = tp->t_mountp; 447 448 switch (field) { 449 case XFS_TRANS_SB_ICOUNT: 450 tp->t_icount_delta += delta; 451 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 452 flags &= ~XFS_TRANS_SB_DIRTY; 453 break; 454 case XFS_TRANS_SB_IFREE: 455 tp->t_ifree_delta += delta; 456 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 457 flags &= ~XFS_TRANS_SB_DIRTY; 458 break; 459 case XFS_TRANS_SB_FDBLOCKS: 460 /* 461 * Track the number of blocks allocated in the 462 * transaction. Make sure it does not exceed the 463 * number reserved. 464 */ 465 if (delta < 0) { 466 tp->t_blk_res_used += (uint)-delta; 467 ASSERT(tp->t_blk_res_used <= tp->t_blk_res); 468 } 469 tp->t_fdblocks_delta += delta; 470 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 471 flags &= ~XFS_TRANS_SB_DIRTY; 472 break; 473 case XFS_TRANS_SB_RES_FDBLOCKS: 474 /* 475 * The allocation has already been applied to the 476 * in-core superblock's counter. This should only 477 * be applied to the on-disk superblock. 478 */ 479 ASSERT(delta < 0); 480 tp->t_res_fdblocks_delta += delta; 481 if (xfs_sb_version_haslazysbcount(&mp->m_sb)) 482 flags &= ~XFS_TRANS_SB_DIRTY; 483 break; 484 case XFS_TRANS_SB_FREXTENTS: 485 /* 486 * Track the number of blocks allocated in the 487 * transaction. Make sure it does not exceed the 488 * number reserved. 489 */ 490 if (delta < 0) { 491 tp->t_rtx_res_used += (uint)-delta; 492 ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res); 493 } 494 tp->t_frextents_delta += delta; 495 break; 496 case XFS_TRANS_SB_RES_FREXTENTS: 497 /* 498 * The allocation has already been applied to the 499 * in-core superblock's counter. This should only 500 * be applied to the on-disk superblock. 501 */ 502 ASSERT(delta < 0); 503 tp->t_res_frextents_delta += delta; 504 break; 505 case XFS_TRANS_SB_DBLOCKS: 506 ASSERT(delta > 0); 507 tp->t_dblocks_delta += delta; 508 break; 509 case XFS_TRANS_SB_AGCOUNT: 510 ASSERT(delta > 0); 511 tp->t_agcount_delta += delta; 512 break; 513 case XFS_TRANS_SB_IMAXPCT: 514 tp->t_imaxpct_delta += delta; 515 break; 516 case XFS_TRANS_SB_REXTSIZE: 517 tp->t_rextsize_delta += delta; 518 break; 519 case XFS_TRANS_SB_RBMBLOCKS: 520 tp->t_rbmblocks_delta += delta; 521 break; 522 case XFS_TRANS_SB_RBLOCKS: 523 tp->t_rblocks_delta += delta; 524 break; 525 case XFS_TRANS_SB_REXTENTS: 526 tp->t_rextents_delta += delta; 527 break; 528 case XFS_TRANS_SB_REXTSLOG: 529 tp->t_rextslog_delta += delta; 530 break; 531 default: 532 ASSERT(0); 533 return; 534 } 535 536 tp->t_flags |= flags; 537 } 538 539 /* 540 * xfs_trans_apply_sb_deltas() is called from the commit code 541 * to bring the superblock buffer into the current transaction 542 * and modify it as requested by earlier calls to xfs_trans_mod_sb(). 543 * 544 * For now we just look at each field allowed to change and change 545 * it if necessary. 546 */ 547 STATIC void 548 xfs_trans_apply_sb_deltas( 549 xfs_trans_t *tp) 550 { 551 xfs_sb_t *sbp; 552 xfs_buf_t *bp; 553 int whole = 0; 554 555 bp = xfs_trans_getsb(tp, tp->t_mountp, 0); 556 sbp = XFS_BUF_TO_SBP(bp); 557 558 /* 559 * Check that superblock mods match the mods made to AGF counters. 560 */ 561 ASSERT((tp->t_fdblocks_delta + tp->t_res_fdblocks_delta) == 562 (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta + 563 tp->t_ag_btree_delta)); 564 565 /* 566 * Only update the superblock counters if we are logging them 567 */ 568 if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) { 569 if (tp->t_icount_delta != 0) { 570 INT_MOD(sbp->sb_icount, ARCH_CONVERT, tp->t_icount_delta); 571 } 572 if (tp->t_ifree_delta != 0) { 573 INT_MOD(sbp->sb_ifree, ARCH_CONVERT, tp->t_ifree_delta); 574 } 575 576 if (tp->t_fdblocks_delta != 0) { 577 INT_MOD(sbp->sb_fdblocks, ARCH_CONVERT, tp->t_fdblocks_delta); 578 } 579 if (tp->t_res_fdblocks_delta != 0) { 580 INT_MOD(sbp->sb_fdblocks, ARCH_CONVERT, tp->t_res_fdblocks_delta); 581 } 582 } 583 584 if (tp->t_frextents_delta != 0) { 585 INT_MOD(sbp->sb_frextents, ARCH_CONVERT, tp->t_frextents_delta); 586 } 587 if (tp->t_res_frextents_delta != 0) { 588 INT_MOD(sbp->sb_frextents, ARCH_CONVERT, tp->t_res_frextents_delta); 589 } 590 if (tp->t_dblocks_delta != 0) { 591 INT_MOD(sbp->sb_dblocks, ARCH_CONVERT, tp->t_dblocks_delta); 592 whole = 1; 593 } 594 if (tp->t_agcount_delta != 0) { 595 INT_MOD(sbp->sb_agcount, ARCH_CONVERT, tp->t_agcount_delta); 596 whole = 1; 597 } 598 if (tp->t_imaxpct_delta != 0) { 599 INT_MOD(sbp->sb_imax_pct, ARCH_CONVERT, tp->t_imaxpct_delta); 600 whole = 1; 601 } 602 if (tp->t_rextsize_delta != 0) { 603 INT_MOD(sbp->sb_rextsize, ARCH_CONVERT, tp->t_rextsize_delta); 604 whole = 1; 605 } 606 if (tp->t_rbmblocks_delta != 0) { 607 INT_MOD(sbp->sb_rbmblocks, ARCH_CONVERT, tp->t_rbmblocks_delta); 608 whole = 1; 609 } 610 if (tp->t_rblocks_delta != 0) { 611 INT_MOD(sbp->sb_rblocks, ARCH_CONVERT, tp->t_rblocks_delta); 612 whole = 1; 613 } 614 if (tp->t_rextents_delta != 0) { 615 INT_MOD(sbp->sb_rextents, ARCH_CONVERT, tp->t_rextents_delta); 616 whole = 1; 617 } 618 if (tp->t_rextslog_delta != 0) { 619 INT_MOD(sbp->sb_rextslog, ARCH_CONVERT, tp->t_rextslog_delta); 620 whole = 1; 621 } 622 623 if (whole) 624 /* 625 * Log the whole thing, the fields are noncontiguous. 626 */ 627 xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_sb_t) - 1); 628 else 629 /* 630 * Since all the modifiable fields are contiguous, we 631 * can get away with this. 632 */ 633 xfs_trans_log_buf(tp, bp, offsetof(xfs_sb_t, sb_icount), 634 offsetof(xfs_sb_t, sb_frextents) + 635 sizeof(sbp->sb_frextents) - 1); 636 637 XFS_MTOVFS(tp->t_mountp)->vfs_super->s_dirt = 1; 638 } 639 640 /* 641 * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations 642 * and apply superblock counter changes to the in-core superblock. The 643 * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT 644 * applied to the in-core superblock. The idea is that that has already been 645 * done. 646 * 647 * This is done efficiently with a single call to xfs_mod_incore_sb_batch(). 648 * However, we have to ensure that we only modify each superblock field only 649 * once because the application of the delta values may not be atomic. That can 650 * lead to ENOSPC races occurring if we have two separate modifcations of the 651 * free space counter to put back the entire reservation and then take away 652 * what we used. 653 * 654 * If we are not logging superblock counters, then the inode allocated/free and 655 * used block counts are not updated in the on disk superblock. In this case, 656 * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we 657 * still need to update the incore superblock with the changes. 658 */ 659 STATIC void 660 xfs_trans_unreserve_and_mod_sb( 661 xfs_trans_t *tp) 662 { 663 xfs_mod_sb_t msb[14]; /* If you add cases, add entries */ 664 xfs_mod_sb_t *msbp; 665 xfs_mount_t *mp = tp->t_mountp; 666 /* REFERENCED */ 667 int error; 668 int rsvd; 669 int64_t blkdelta = 0; 670 int64_t rtxdelta = 0; 671 672 msbp = msb; 673 rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0; 674 675 /* calculate free blocks delta */ 676 if (tp->t_blk_res > 0) 677 blkdelta = tp->t_blk_res; 678 679 if ((tp->t_fdblocks_delta != 0) && 680 (xfs_sb_version_haslazysbcount(&mp->m_sb) || 681 (tp->t_flags & XFS_TRANS_SB_DIRTY))) 682 blkdelta += tp->t_fdblocks_delta; 683 684 if (blkdelta != 0) { 685 msbp->msb_field = XFS_SBS_FDBLOCKS; 686 msbp->msb_delta = blkdelta; 687 msbp++; 688 } 689 690 /* calculate free realtime extents delta */ 691 if (tp->t_rtx_res > 0) 692 rtxdelta = tp->t_rtx_res; 693 694 if ((tp->t_frextents_delta != 0) && 695 (tp->t_flags & XFS_TRANS_SB_DIRTY)) 696 rtxdelta += tp->t_frextents_delta; 697 698 if (rtxdelta != 0) { 699 msbp->msb_field = XFS_SBS_FREXTENTS; 700 msbp->msb_delta = rtxdelta; 701 msbp++; 702 } 703 704 /* apply remaining deltas */ 705 706 if (xfs_sb_version_haslazysbcount(&mp->m_sb) || 707 (tp->t_flags & XFS_TRANS_SB_DIRTY)) { 708 if (tp->t_icount_delta != 0) { 709 msbp->msb_field = XFS_SBS_ICOUNT; 710 msbp->msb_delta = tp->t_icount_delta; 711 msbp++; 712 } 713 if (tp->t_ifree_delta != 0) { 714 msbp->msb_field = XFS_SBS_IFREE; 715 msbp->msb_delta = tp->t_ifree_delta; 716 msbp++; 717 } 718 } 719 720 if (tp->t_flags & XFS_TRANS_SB_DIRTY) { 721 if (tp->t_dblocks_delta != 0) { 722 msbp->msb_field = XFS_SBS_DBLOCKS; 723 msbp->msb_delta = tp->t_dblocks_delta; 724 msbp++; 725 } 726 if (tp->t_agcount_delta != 0) { 727 msbp->msb_field = XFS_SBS_AGCOUNT; 728 msbp->msb_delta = tp->t_agcount_delta; 729 msbp++; 730 } 731 if (tp->t_imaxpct_delta != 0) { 732 msbp->msb_field = XFS_SBS_IMAX_PCT; 733 msbp->msb_delta = tp->t_imaxpct_delta; 734 msbp++; 735 } 736 if (tp->t_rextsize_delta != 0) { 737 msbp->msb_field = XFS_SBS_REXTSIZE; 738 msbp->msb_delta = tp->t_rextsize_delta; 739 msbp++; 740 } 741 if (tp->t_rbmblocks_delta != 0) { 742 msbp->msb_field = XFS_SBS_RBMBLOCKS; 743 msbp->msb_delta = tp->t_rbmblocks_delta; 744 msbp++; 745 } 746 if (tp->t_rblocks_delta != 0) { 747 msbp->msb_field = XFS_SBS_RBLOCKS; 748 msbp->msb_delta = tp->t_rblocks_delta; 749 msbp++; 750 } 751 if (tp->t_rextents_delta != 0) { 752 msbp->msb_field = XFS_SBS_REXTENTS; 753 msbp->msb_delta = tp->t_rextents_delta; 754 msbp++; 755 } 756 if (tp->t_rextslog_delta != 0) { 757 msbp->msb_field = XFS_SBS_REXTSLOG; 758 msbp->msb_delta = tp->t_rextslog_delta; 759 msbp++; 760 } 761 } 762 763 /* 764 * If we need to change anything, do it. 765 */ 766 if (msbp > msb) { 767 error = xfs_mod_incore_sb_batch(tp->t_mountp, msb, 768 (uint)(msbp - msb), rsvd); 769 ASSERT(error == 0); 770 } 771 } 772 773 774 /* 775 * xfs_trans_commit 776 * 777 * Commit the given transaction to the log a/synchronously. 778 * 779 * XFS disk error handling mechanism is not based on a typical 780 * transaction abort mechanism. Logically after the filesystem 781 * gets marked 'SHUTDOWN', we can't let any new transactions 782 * be durable - ie. committed to disk - because some metadata might 783 * be inconsistent. In such cases, this returns an error, and the 784 * caller may assume that all locked objects joined to the transaction 785 * have already been unlocked as if the commit had succeeded. 786 * Do not reference the transaction structure after this call. 787 */ 788 /*ARGSUSED*/ 789 int 790 _xfs_trans_commit( 791 xfs_trans_t *tp, 792 uint flags, 793 int *log_flushed) 794 { 795 xfs_log_iovec_t *log_vector; 796 int nvec; 797 xfs_mount_t *mp; 798 xfs_lsn_t commit_lsn; 799 /* REFERENCED */ 800 int error; 801 int log_flags; 802 int sync; 803 #define XFS_TRANS_LOGVEC_COUNT 16 804 xfs_log_iovec_t log_vector_fast[XFS_TRANS_LOGVEC_COUNT]; 805 void *commit_iclog; 806 int shutdown; 807 808 commit_lsn = -1; 809 810 /* 811 * Determine whether this commit is releasing a permanent 812 * log reservation or not. 813 */ 814 if (flags & XFS_TRANS_RELEASE_LOG_RES) { 815 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 816 log_flags = XFS_LOG_REL_PERM_RESERV; 817 } else { 818 log_flags = 0; 819 } 820 mp = tp->t_mountp; 821 822 /* 823 * If there is nothing to be logged by the transaction, 824 * then unlock all of the items associated with the 825 * transaction and free the transaction structure. 826 * Also make sure to return any reserved blocks to 827 * the free pool. 828 */ 829 shut_us_down: 830 shutdown = XFS_FORCED_SHUTDOWN(mp) ? EIO : 0; 831 if (!(tp->t_flags & XFS_TRANS_DIRTY) || shutdown) { 832 xfs_trans_unreserve_and_mod_sb(tp); 833 /* 834 * It is indeed possible for the transaction to be 835 * not dirty but the dqinfo portion to be. All that 836 * means is that we have some (non-persistent) quota 837 * reservations that need to be unreserved. 838 */ 839 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp, tp); 840 if (tp->t_ticket) { 841 commit_lsn = xfs_log_done(mp, tp->t_ticket, 842 NULL, log_flags); 843 if (commit_lsn == -1 && !shutdown) 844 shutdown = XFS_ERROR(EIO); 845 } 846 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 847 xfs_trans_free_items(tp, shutdown? XFS_TRANS_ABORT : 0); 848 xfs_trans_free_busy(tp); 849 xfs_trans_free(tp); 850 XFS_STATS_INC(xs_trans_empty); 851 return (shutdown); 852 } 853 ASSERT(tp->t_ticket != NULL); 854 855 /* 856 * If we need to update the superblock, then do it now. 857 */ 858 if (tp->t_flags & XFS_TRANS_SB_DIRTY) { 859 xfs_trans_apply_sb_deltas(tp); 860 } 861 XFS_TRANS_APPLY_DQUOT_DELTAS(mp, tp); 862 863 /* 864 * Ask each log item how many log_vector entries it will 865 * need so we can figure out how many to allocate. 866 * Try to avoid the kmem_alloc() call in the common case 867 * by using a vector from the stack when it fits. 868 */ 869 nvec = xfs_trans_count_vecs(tp); 870 if (nvec == 0) { 871 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR); 872 goto shut_us_down; 873 } else if (nvec <= XFS_TRANS_LOGVEC_COUNT) { 874 log_vector = log_vector_fast; 875 } else { 876 log_vector = (xfs_log_iovec_t *)kmem_alloc(nvec * 877 sizeof(xfs_log_iovec_t), 878 KM_SLEEP); 879 } 880 881 /* 882 * Fill in the log_vector and pin the logged items, and 883 * then write the transaction to the log. 884 */ 885 xfs_trans_fill_vecs(tp, log_vector); 886 887 error = xfs_log_write(mp, log_vector, nvec, tp->t_ticket, &(tp->t_lsn)); 888 889 /* 890 * The transaction is committed incore here, and can go out to disk 891 * at any time after this call. However, all the items associated 892 * with the transaction are still locked and pinned in memory. 893 */ 894 commit_lsn = xfs_log_done(mp, tp->t_ticket, &commit_iclog, log_flags); 895 896 tp->t_commit_lsn = commit_lsn; 897 if (nvec > XFS_TRANS_LOGVEC_COUNT) { 898 kmem_free(log_vector, nvec * sizeof(xfs_log_iovec_t)); 899 } 900 901 /* 902 * If we got a log write error. Unpin the logitems that we 903 * had pinned, clean up, free trans structure, and return error. 904 */ 905 if (error || commit_lsn == -1) { 906 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 907 xfs_trans_uncommit(tp, flags|XFS_TRANS_ABORT); 908 return XFS_ERROR(EIO); 909 } 910 911 /* 912 * Once the transaction has committed, unused 913 * reservations need to be released and changes to 914 * the superblock need to be reflected in the in-core 915 * version. Do that now. 916 */ 917 xfs_trans_unreserve_and_mod_sb(tp); 918 919 sync = tp->t_flags & XFS_TRANS_SYNC; 920 921 /* 922 * Tell the LM to call the transaction completion routine 923 * when the log write with LSN commit_lsn completes (e.g. 924 * when the transaction commit really hits the on-disk log). 925 * After this call we cannot reference tp, because the call 926 * can happen at any time and the call will free the transaction 927 * structure pointed to by tp. The only case where we call 928 * the completion routine (xfs_trans_committed) directly is 929 * if the log is turned off on a debug kernel or we're 930 * running in simulation mode (the log is explicitly turned 931 * off). 932 */ 933 tp->t_logcb.cb_func = (void(*)(void*, int))xfs_trans_committed; 934 tp->t_logcb.cb_arg = tp; 935 936 /* 937 * We need to pass the iclog buffer which was used for the 938 * transaction commit record into this function, and attach 939 * the callback to it. The callback must be attached before 940 * the items are unlocked to avoid racing with other threads 941 * waiting for an item to unlock. 942 */ 943 shutdown = xfs_log_notify(mp, commit_iclog, &(tp->t_logcb)); 944 945 /* 946 * Mark this thread as no longer being in a transaction 947 */ 948 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 949 950 /* 951 * Once all the items of the transaction have been copied 952 * to the in core log and the callback is attached, the 953 * items can be unlocked. 954 * 955 * This will free descriptors pointing to items which were 956 * not logged since there is nothing more to do with them. 957 * For items which were logged, we will keep pointers to them 958 * so they can be unpinned after the transaction commits to disk. 959 * This will also stamp each modified meta-data item with 960 * the commit lsn of this transaction for dependency tracking 961 * purposes. 962 */ 963 xfs_trans_unlock_items(tp, commit_lsn); 964 965 /* 966 * If we detected a log error earlier, finish committing 967 * the transaction now (unpin log items, etc). 968 * 969 * Order is critical here, to avoid using the transaction 970 * pointer after its been freed (by xfs_trans_committed 971 * either here now, or as a callback). We cannot do this 972 * step inside xfs_log_notify as was done earlier because 973 * of this issue. 974 */ 975 if (shutdown) 976 xfs_trans_committed(tp, XFS_LI_ABORTED); 977 978 /* 979 * Now that the xfs_trans_committed callback has been attached, 980 * and the items are released we can finally allow the iclog to 981 * go to disk. 982 */ 983 error = xfs_log_release_iclog(mp, commit_iclog); 984 985 /* 986 * If the transaction needs to be synchronous, then force the 987 * log out now and wait for it. 988 */ 989 if (sync) { 990 if (!error) { 991 error = _xfs_log_force(mp, commit_lsn, 992 XFS_LOG_FORCE | XFS_LOG_SYNC, 993 log_flushed); 994 } 995 XFS_STATS_INC(xs_trans_sync); 996 } else { 997 XFS_STATS_INC(xs_trans_async); 998 } 999 1000 return (error); 1001 } 1002 1003 1004 /* 1005 * Total up the number of log iovecs needed to commit this 1006 * transaction. The transaction itself needs one for the 1007 * transaction header. Ask each dirty item in turn how many 1008 * it needs to get the total. 1009 */ 1010 STATIC uint 1011 xfs_trans_count_vecs( 1012 xfs_trans_t *tp) 1013 { 1014 int nvecs; 1015 xfs_log_item_desc_t *lidp; 1016 1017 nvecs = 1; 1018 lidp = xfs_trans_first_item(tp); 1019 ASSERT(lidp != NULL); 1020 1021 /* In the non-debug case we need to start bailing out if we 1022 * didn't find a log_item here, return zero and let trans_commit 1023 * deal with it. 1024 */ 1025 if (lidp == NULL) 1026 return 0; 1027 1028 while (lidp != NULL) { 1029 /* 1030 * Skip items which aren't dirty in this transaction. 1031 */ 1032 if (!(lidp->lid_flags & XFS_LID_DIRTY)) { 1033 lidp = xfs_trans_next_item(tp, lidp); 1034 continue; 1035 } 1036 lidp->lid_size = IOP_SIZE(lidp->lid_item); 1037 nvecs += lidp->lid_size; 1038 lidp = xfs_trans_next_item(tp, lidp); 1039 } 1040 1041 return nvecs; 1042 } 1043 1044 /* 1045 * Called from the trans_commit code when we notice that 1046 * the filesystem is in the middle of a forced shutdown. 1047 */ 1048 STATIC void 1049 xfs_trans_uncommit( 1050 xfs_trans_t *tp, 1051 uint flags) 1052 { 1053 xfs_log_item_desc_t *lidp; 1054 1055 for (lidp = xfs_trans_first_item(tp); 1056 lidp != NULL; 1057 lidp = xfs_trans_next_item(tp, lidp)) { 1058 /* 1059 * Unpin all but those that aren't dirty. 1060 */ 1061 if (lidp->lid_flags & XFS_LID_DIRTY) 1062 IOP_UNPIN_REMOVE(lidp->lid_item, tp); 1063 } 1064 1065 xfs_trans_unreserve_and_mod_sb(tp); 1066 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(tp->t_mountp, tp); 1067 1068 xfs_trans_free_items(tp, flags); 1069 xfs_trans_free_busy(tp); 1070 xfs_trans_free(tp); 1071 } 1072 1073 /* 1074 * Fill in the vector with pointers to data to be logged 1075 * by this transaction. The transaction header takes 1076 * the first vector, and then each dirty item takes the 1077 * number of vectors it indicated it needed in xfs_trans_count_vecs(). 1078 * 1079 * As each item fills in the entries it needs, also pin the item 1080 * so that it cannot be flushed out until the log write completes. 1081 */ 1082 STATIC void 1083 xfs_trans_fill_vecs( 1084 xfs_trans_t *tp, 1085 xfs_log_iovec_t *log_vector) 1086 { 1087 xfs_log_item_desc_t *lidp; 1088 xfs_log_iovec_t *vecp; 1089 uint nitems; 1090 1091 /* 1092 * Skip over the entry for the transaction header, we'll 1093 * fill that in at the end. 1094 */ 1095 vecp = log_vector + 1; /* pointer arithmetic */ 1096 1097 nitems = 0; 1098 lidp = xfs_trans_first_item(tp); 1099 ASSERT(lidp != NULL); 1100 while (lidp != NULL) { 1101 /* 1102 * Skip items which aren't dirty in this transaction. 1103 */ 1104 if (!(lidp->lid_flags & XFS_LID_DIRTY)) { 1105 lidp = xfs_trans_next_item(tp, lidp); 1106 continue; 1107 } 1108 /* 1109 * The item may be marked dirty but not log anything. 1110 * This can be used to get called when a transaction 1111 * is committed. 1112 */ 1113 if (lidp->lid_size) { 1114 nitems++; 1115 } 1116 IOP_FORMAT(lidp->lid_item, vecp); 1117 vecp += lidp->lid_size; /* pointer arithmetic */ 1118 IOP_PIN(lidp->lid_item); 1119 lidp = xfs_trans_next_item(tp, lidp); 1120 } 1121 1122 /* 1123 * Now that we've counted the number of items in this 1124 * transaction, fill in the transaction header. 1125 */ 1126 tp->t_header.th_magic = XFS_TRANS_HEADER_MAGIC; 1127 tp->t_header.th_type = tp->t_type; 1128 tp->t_header.th_num_items = nitems; 1129 log_vector->i_addr = (xfs_caddr_t)&tp->t_header; 1130 log_vector->i_len = sizeof(xfs_trans_header_t); 1131 XLOG_VEC_SET_TYPE(log_vector, XLOG_REG_TYPE_TRANSHDR); 1132 } 1133 1134 1135 /* 1136 * Unlock all of the transaction's items and free the transaction. 1137 * The transaction must not have modified any of its items, because 1138 * there is no way to restore them to their previous state. 1139 * 1140 * If the transaction has made a log reservation, make sure to release 1141 * it as well. 1142 */ 1143 void 1144 xfs_trans_cancel( 1145 xfs_trans_t *tp, 1146 int flags) 1147 { 1148 int log_flags; 1149 #ifdef DEBUG 1150 xfs_log_item_chunk_t *licp; 1151 xfs_log_item_desc_t *lidp; 1152 xfs_log_item_t *lip; 1153 int i; 1154 #endif 1155 xfs_mount_t *mp = tp->t_mountp; 1156 1157 /* 1158 * See if the caller is being too lazy to figure out if 1159 * the transaction really needs an abort. 1160 */ 1161 if ((flags & XFS_TRANS_ABORT) && !(tp->t_flags & XFS_TRANS_DIRTY)) 1162 flags &= ~XFS_TRANS_ABORT; 1163 /* 1164 * See if the caller is relying on us to shut down the 1165 * filesystem. This happens in paths where we detect 1166 * corruption and decide to give up. 1167 */ 1168 if ((tp->t_flags & XFS_TRANS_DIRTY) && !XFS_FORCED_SHUTDOWN(mp)) { 1169 XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp); 1170 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 1171 } 1172 #ifdef DEBUG 1173 if (!(flags & XFS_TRANS_ABORT)) { 1174 licp = &(tp->t_items); 1175 while (licp != NULL) { 1176 lidp = licp->lic_descs; 1177 for (i = 0; i < licp->lic_unused; i++, lidp++) { 1178 if (XFS_LIC_ISFREE(licp, i)) { 1179 continue; 1180 } 1181 1182 lip = lidp->lid_item; 1183 if (!XFS_FORCED_SHUTDOWN(mp)) 1184 ASSERT(!(lip->li_type == XFS_LI_EFD)); 1185 } 1186 licp = licp->lic_next; 1187 } 1188 } 1189 #endif 1190 xfs_trans_unreserve_and_mod_sb(tp); 1191 XFS_TRANS_UNRESERVE_AND_MOD_DQUOTS(mp, tp); 1192 1193 if (tp->t_ticket) { 1194 if (flags & XFS_TRANS_RELEASE_LOG_RES) { 1195 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); 1196 log_flags = XFS_LOG_REL_PERM_RESERV; 1197 } else { 1198 log_flags = 0; 1199 } 1200 xfs_log_done(mp, tp->t_ticket, NULL, log_flags); 1201 } 1202 1203 /* mark this thread as no longer being in a transaction */ 1204 current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); 1205 1206 xfs_trans_free_items(tp, flags); 1207 xfs_trans_free_busy(tp); 1208 xfs_trans_free(tp); 1209 } 1210 1211 1212 /* 1213 * Free the transaction structure. If there is more clean up 1214 * to do when the structure is freed, add it here. 1215 */ 1216 STATIC void 1217 xfs_trans_free( 1218 xfs_trans_t *tp) 1219 { 1220 atomic_dec(&tp->t_mountp->m_active_trans); 1221 XFS_TRANS_FREE_DQINFO(tp->t_mountp, tp); 1222 kmem_zone_free(xfs_trans_zone, tp); 1223 } 1224 1225 1226 /* 1227 * THIS SHOULD BE REWRITTEN TO USE xfs_trans_next_item(). 1228 * 1229 * This is typically called by the LM when a transaction has been fully 1230 * committed to disk. It needs to unpin the items which have 1231 * been logged by the transaction and update their positions 1232 * in the AIL if necessary. 1233 * This also gets called when the transactions didn't get written out 1234 * because of an I/O error. Abortflag & XFS_LI_ABORTED is set then. 1235 * 1236 * Call xfs_trans_chunk_committed() to process the items in 1237 * each chunk. 1238 */ 1239 STATIC void 1240 xfs_trans_committed( 1241 xfs_trans_t *tp, 1242 int abortflag) 1243 { 1244 xfs_log_item_chunk_t *licp; 1245 xfs_log_item_chunk_t *next_licp; 1246 xfs_log_busy_chunk_t *lbcp; 1247 xfs_log_busy_slot_t *lbsp; 1248 int i; 1249 1250 /* 1251 * Call the transaction's completion callback if there 1252 * is one. 1253 */ 1254 if (tp->t_callback != NULL) { 1255 tp->t_callback(tp, tp->t_callarg); 1256 } 1257 1258 /* 1259 * Special case the chunk embedded in the transaction. 1260 */ 1261 licp = &(tp->t_items); 1262 if (!(XFS_LIC_ARE_ALL_FREE(licp))) { 1263 xfs_trans_chunk_committed(licp, tp->t_lsn, abortflag); 1264 } 1265 1266 /* 1267 * Process the items in each chunk in turn. 1268 */ 1269 licp = licp->lic_next; 1270 while (licp != NULL) { 1271 ASSERT(!XFS_LIC_ARE_ALL_FREE(licp)); 1272 xfs_trans_chunk_committed(licp, tp->t_lsn, abortflag); 1273 next_licp = licp->lic_next; 1274 kmem_free(licp, sizeof(xfs_log_item_chunk_t)); 1275 licp = next_licp; 1276 } 1277 1278 /* 1279 * Clear all the per-AG busy list items listed in this transaction 1280 */ 1281 lbcp = &tp->t_busy; 1282 while (lbcp != NULL) { 1283 for (i = 0, lbsp = lbcp->lbc_busy; i < lbcp->lbc_unused; i++, lbsp++) { 1284 if (!XFS_LBC_ISFREE(lbcp, i)) { 1285 xfs_alloc_clear_busy(tp, lbsp->lbc_ag, 1286 lbsp->lbc_idx); 1287 } 1288 } 1289 lbcp = lbcp->lbc_next; 1290 } 1291 xfs_trans_free_busy(tp); 1292 1293 /* 1294 * That's it for the transaction structure. Free it. 1295 */ 1296 xfs_trans_free(tp); 1297 } 1298 1299 /* 1300 * This is called to perform the commit processing for each 1301 * item described by the given chunk. 1302 * 1303 * The commit processing consists of unlocking items which were 1304 * held locked with the SYNC_UNLOCK attribute, calling the committed 1305 * routine of each logged item, updating the item's position in the AIL 1306 * if necessary, and unpinning each item. If the committed routine 1307 * returns -1, then do nothing further with the item because it 1308 * may have been freed. 1309 * 1310 * Since items are unlocked when they are copied to the incore 1311 * log, it is possible for two transactions to be completing 1312 * and manipulating the same item simultaneously. The AIL lock 1313 * will protect the lsn field of each item. The value of this 1314 * field can never go backwards. 1315 * 1316 * We unpin the items after repositioning them in the AIL, because 1317 * otherwise they could be immediately flushed and we'd have to race 1318 * with the flusher trying to pull the item from the AIL as we add it. 1319 */ 1320 STATIC void 1321 xfs_trans_chunk_committed( 1322 xfs_log_item_chunk_t *licp, 1323 xfs_lsn_t lsn, 1324 int aborted) 1325 { 1326 xfs_log_item_desc_t *lidp; 1327 xfs_log_item_t *lip; 1328 xfs_lsn_t item_lsn; 1329 struct xfs_mount *mp; 1330 int i; 1331 SPLDECL(s); 1332 1333 lidp = licp->lic_descs; 1334 for (i = 0; i < licp->lic_unused; i++, lidp++) { 1335 if (XFS_LIC_ISFREE(licp, i)) { 1336 continue; 1337 } 1338 1339 lip = lidp->lid_item; 1340 if (aborted) 1341 lip->li_flags |= XFS_LI_ABORTED; 1342 1343 /* 1344 * Send in the ABORTED flag to the COMMITTED routine 1345 * so that it knows whether the transaction was aborted 1346 * or not. 1347 */ 1348 item_lsn = IOP_COMMITTED(lip, lsn); 1349 1350 /* 1351 * If the committed routine returns -1, make 1352 * no more references to the item. 1353 */ 1354 if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0) { 1355 continue; 1356 } 1357 1358 /* 1359 * If the returned lsn is greater than what it 1360 * contained before, update the location of the 1361 * item in the AIL. If it is not, then do nothing. 1362 * Items can never move backwards in the AIL. 1363 * 1364 * While the new lsn should usually be greater, it 1365 * is possible that a later transaction completing 1366 * simultaneously with an earlier one using the 1367 * same item could complete first with a higher lsn. 1368 * This would cause the earlier transaction to fail 1369 * the test below. 1370 */ 1371 mp = lip->li_mountp; 1372 AIL_LOCK(mp,s); 1373 if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0) { 1374 /* 1375 * This will set the item's lsn to item_lsn 1376 * and update the position of the item in 1377 * the AIL. 1378 * 1379 * xfs_trans_update_ail() drops the AIL lock. 1380 */ 1381 xfs_trans_update_ail(mp, lip, item_lsn, s); 1382 } else { 1383 AIL_UNLOCK(mp, s); 1384 } 1385 1386 /* 1387 * Now that we've repositioned the item in the AIL, 1388 * unpin it so it can be flushed. Pass information 1389 * about buffer stale state down from the log item 1390 * flags, if anyone else stales the buffer we do not 1391 * want to pay any attention to it. 1392 */ 1393 IOP_UNPIN(lip, lidp->lid_flags & XFS_LID_BUF_STALE); 1394 } 1395 } 1396