1 /* 2 * Copyright (c) 2000-2002,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_mount.h" 28 #include "xfs_bmap_btree.h" 29 #include "xfs_alloc_btree.h" 30 #include "xfs_ialloc_btree.h" 31 #include "xfs_dinode.h" 32 #include "xfs_inode.h" 33 #include "xfs_buf_item.h" 34 #include "xfs_trans_priv.h" 35 #include "xfs_error.h" 36 #include "xfs_rw.h" 37 #include "xfs_trace.h" 38 39 /* 40 * Check to see if a buffer matching the given parameters is already 41 * a part of the given transaction. 42 */ 43 STATIC struct xfs_buf * 44 xfs_trans_buf_item_match( 45 struct xfs_trans *tp, 46 struct xfs_buftarg *target, 47 xfs_daddr_t blkno, 48 int len) 49 { 50 struct xfs_log_item_desc *lidp; 51 struct xfs_buf_log_item *blip; 52 53 len = BBTOB(len); 54 list_for_each_entry(lidp, &tp->t_items, lid_trans) { 55 blip = (struct xfs_buf_log_item *)lidp->lid_item; 56 if (blip->bli_item.li_type == XFS_LI_BUF && 57 XFS_BUF_TARGET(blip->bli_buf) == target && 58 XFS_BUF_ADDR(blip->bli_buf) == blkno && 59 XFS_BUF_COUNT(blip->bli_buf) == len) 60 return blip->bli_buf; 61 } 62 63 return NULL; 64 } 65 66 /* 67 * Add the locked buffer to the transaction. 68 * 69 * The buffer must be locked, and it cannot be associated with any 70 * transaction. 71 * 72 * If the buffer does not yet have a buf log item associated with it, 73 * then allocate one for it. Then add the buf item to the transaction. 74 */ 75 STATIC void 76 _xfs_trans_bjoin( 77 struct xfs_trans *tp, 78 struct xfs_buf *bp, 79 int reset_recur) 80 { 81 struct xfs_buf_log_item *bip; 82 83 ASSERT(XFS_BUF_ISBUSY(bp)); 84 ASSERT(bp->b_transp == NULL); 85 86 /* 87 * The xfs_buf_log_item pointer is stored in b_fsprivate. If 88 * it doesn't have one yet, then allocate one and initialize it. 89 * The checks to see if one is there are in xfs_buf_item_init(). 90 */ 91 xfs_buf_item_init(bp, tp->t_mountp); 92 bip = bp->b_fspriv; 93 ASSERT(!(bip->bli_flags & XFS_BLI_STALE)); 94 ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL)); 95 ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED)); 96 if (reset_recur) 97 bip->bli_recur = 0; 98 99 /* 100 * Take a reference for this transaction on the buf item. 101 */ 102 atomic_inc(&bip->bli_refcount); 103 104 /* 105 * Get a log_item_desc to point at the new item. 106 */ 107 xfs_trans_add_item(tp, &bip->bli_item); 108 109 /* 110 * Initialize b_fsprivate2 so we can find it with incore_match() 111 * in xfs_trans_get_buf() and friends above. 112 */ 113 bp->b_transp = tp; 114 115 } 116 117 void 118 xfs_trans_bjoin( 119 struct xfs_trans *tp, 120 struct xfs_buf *bp) 121 { 122 _xfs_trans_bjoin(tp, bp, 0); 123 trace_xfs_trans_bjoin(bp->b_fspriv); 124 } 125 126 /* 127 * Get and lock the buffer for the caller if it is not already 128 * locked within the given transaction. If it is already locked 129 * within the transaction, just increment its lock recursion count 130 * and return a pointer to it. 131 * 132 * If the transaction pointer is NULL, make this just a normal 133 * get_buf() call. 134 */ 135 xfs_buf_t * 136 xfs_trans_get_buf(xfs_trans_t *tp, 137 xfs_buftarg_t *target_dev, 138 xfs_daddr_t blkno, 139 int len, 140 uint flags) 141 { 142 xfs_buf_t *bp; 143 xfs_buf_log_item_t *bip; 144 145 if (flags == 0) 146 flags = XBF_LOCK | XBF_MAPPED; 147 148 /* 149 * Default to a normal get_buf() call if the tp is NULL. 150 */ 151 if (tp == NULL) 152 return xfs_buf_get(target_dev, blkno, len, 153 flags | XBF_DONT_BLOCK); 154 155 /* 156 * If we find the buffer in the cache with this transaction 157 * pointer in its b_fsprivate2 field, then we know we already 158 * have it locked. In this case we just increment the lock 159 * recursion count and return the buffer to the caller. 160 */ 161 bp = xfs_trans_buf_item_match(tp, target_dev, blkno, len); 162 if (bp != NULL) { 163 ASSERT(xfs_buf_islocked(bp)); 164 if (XFS_FORCED_SHUTDOWN(tp->t_mountp)) 165 XFS_BUF_SUPER_STALE(bp); 166 167 /* 168 * If the buffer is stale then it was binval'ed 169 * since last read. This doesn't matter since the 170 * caller isn't allowed to use the data anyway. 171 */ 172 else if (XFS_BUF_ISSTALE(bp)) 173 ASSERT(!XFS_BUF_ISDELAYWRITE(bp)); 174 175 ASSERT(bp->b_transp == tp); 176 bip = bp->b_fspriv; 177 ASSERT(bip != NULL); 178 ASSERT(atomic_read(&bip->bli_refcount) > 0); 179 bip->bli_recur++; 180 trace_xfs_trans_get_buf_recur(bip); 181 return (bp); 182 } 183 184 /* 185 * We always specify the XBF_DONT_BLOCK flag within a transaction 186 * so that get_buf does not try to push out a delayed write buffer 187 * which might cause another transaction to take place (if the 188 * buffer was delayed alloc). Such recursive transactions can 189 * easily deadlock with our current transaction as well as cause 190 * us to run out of stack space. 191 */ 192 bp = xfs_buf_get(target_dev, blkno, len, flags | XBF_DONT_BLOCK); 193 if (bp == NULL) { 194 return NULL; 195 } 196 197 ASSERT(!XFS_BUF_GETERROR(bp)); 198 199 _xfs_trans_bjoin(tp, bp, 1); 200 trace_xfs_trans_get_buf(bp->b_fspriv); 201 return (bp); 202 } 203 204 /* 205 * Get and lock the superblock buffer of this file system for the 206 * given transaction. 207 * 208 * We don't need to use incore_match() here, because the superblock 209 * buffer is a private buffer which we keep a pointer to in the 210 * mount structure. 211 */ 212 xfs_buf_t * 213 xfs_trans_getsb(xfs_trans_t *tp, 214 struct xfs_mount *mp, 215 int flags) 216 { 217 xfs_buf_t *bp; 218 xfs_buf_log_item_t *bip; 219 220 /* 221 * Default to just trying to lock the superblock buffer 222 * if tp is NULL. 223 */ 224 if (tp == NULL) { 225 return (xfs_getsb(mp, flags)); 226 } 227 228 /* 229 * If the superblock buffer already has this transaction 230 * pointer in its b_fsprivate2 field, then we know we already 231 * have it locked. In this case we just increment the lock 232 * recursion count and return the buffer to the caller. 233 */ 234 bp = mp->m_sb_bp; 235 if (bp->b_transp == tp) { 236 bip = bp->b_fspriv; 237 ASSERT(bip != NULL); 238 ASSERT(atomic_read(&bip->bli_refcount) > 0); 239 bip->bli_recur++; 240 trace_xfs_trans_getsb_recur(bip); 241 return (bp); 242 } 243 244 bp = xfs_getsb(mp, flags); 245 if (bp == NULL) 246 return NULL; 247 248 _xfs_trans_bjoin(tp, bp, 1); 249 trace_xfs_trans_getsb(bp->b_fspriv); 250 return (bp); 251 } 252 253 #ifdef DEBUG 254 xfs_buftarg_t *xfs_error_target; 255 int xfs_do_error; 256 int xfs_req_num; 257 int xfs_error_mod = 33; 258 #endif 259 260 /* 261 * Get and lock the buffer for the caller if it is not already 262 * locked within the given transaction. If it has not yet been 263 * read in, read it from disk. If it is already locked 264 * within the transaction and already read in, just increment its 265 * lock recursion count and return a pointer to it. 266 * 267 * If the transaction pointer is NULL, make this just a normal 268 * read_buf() call. 269 */ 270 int 271 xfs_trans_read_buf( 272 xfs_mount_t *mp, 273 xfs_trans_t *tp, 274 xfs_buftarg_t *target, 275 xfs_daddr_t blkno, 276 int len, 277 uint flags, 278 xfs_buf_t **bpp) 279 { 280 xfs_buf_t *bp; 281 xfs_buf_log_item_t *bip; 282 int error; 283 284 if (flags == 0) 285 flags = XBF_LOCK | XBF_MAPPED; 286 287 /* 288 * Default to a normal get_buf() call if the tp is NULL. 289 */ 290 if (tp == NULL) { 291 bp = xfs_buf_read(target, blkno, len, flags | XBF_DONT_BLOCK); 292 if (!bp) 293 return (flags & XBF_TRYLOCK) ? 294 EAGAIN : XFS_ERROR(ENOMEM); 295 296 if (XFS_BUF_GETERROR(bp) != 0) { 297 xfs_ioerror_alert("xfs_trans_read_buf", mp, 298 bp, blkno); 299 error = XFS_BUF_GETERROR(bp); 300 xfs_buf_relse(bp); 301 return error; 302 } 303 #ifdef DEBUG 304 if (xfs_do_error) { 305 if (xfs_error_target == target) { 306 if (((xfs_req_num++) % xfs_error_mod) == 0) { 307 xfs_buf_relse(bp); 308 xfs_debug(mp, "Returning error!"); 309 return XFS_ERROR(EIO); 310 } 311 } 312 } 313 #endif 314 if (XFS_FORCED_SHUTDOWN(mp)) 315 goto shutdown_abort; 316 *bpp = bp; 317 return 0; 318 } 319 320 /* 321 * If we find the buffer in the cache with this transaction 322 * pointer in its b_fsprivate2 field, then we know we already 323 * have it locked. If it is already read in we just increment 324 * the lock recursion count and return the buffer to the caller. 325 * If the buffer is not yet read in, then we read it in, increment 326 * the lock recursion count, and return it to the caller. 327 */ 328 bp = xfs_trans_buf_item_match(tp, target, blkno, len); 329 if (bp != NULL) { 330 ASSERT(xfs_buf_islocked(bp)); 331 ASSERT(bp->b_transp == tp); 332 ASSERT(bp->b_fspriv != NULL); 333 ASSERT((XFS_BUF_ISERROR(bp)) == 0); 334 if (!(XFS_BUF_ISDONE(bp))) { 335 trace_xfs_trans_read_buf_io(bp, _RET_IP_); 336 ASSERT(!XFS_BUF_ISASYNC(bp)); 337 XFS_BUF_READ(bp); 338 xfsbdstrat(tp->t_mountp, bp); 339 error = xfs_buf_iowait(bp); 340 if (error) { 341 xfs_ioerror_alert("xfs_trans_read_buf", mp, 342 bp, blkno); 343 xfs_buf_relse(bp); 344 /* 345 * We can gracefully recover from most read 346 * errors. Ones we can't are those that happen 347 * after the transaction's already dirty. 348 */ 349 if (tp->t_flags & XFS_TRANS_DIRTY) 350 xfs_force_shutdown(tp->t_mountp, 351 SHUTDOWN_META_IO_ERROR); 352 return error; 353 } 354 } 355 /* 356 * We never locked this buf ourselves, so we shouldn't 357 * brelse it either. Just get out. 358 */ 359 if (XFS_FORCED_SHUTDOWN(mp)) { 360 trace_xfs_trans_read_buf_shut(bp, _RET_IP_); 361 *bpp = NULL; 362 return XFS_ERROR(EIO); 363 } 364 365 366 bip = bp->b_fspriv; 367 bip->bli_recur++; 368 369 ASSERT(atomic_read(&bip->bli_refcount) > 0); 370 trace_xfs_trans_read_buf_recur(bip); 371 *bpp = bp; 372 return 0; 373 } 374 375 /* 376 * We always specify the XBF_DONT_BLOCK flag within a transaction 377 * so that get_buf does not try to push out a delayed write buffer 378 * which might cause another transaction to take place (if the 379 * buffer was delayed alloc). Such recursive transactions can 380 * easily deadlock with our current transaction as well as cause 381 * us to run out of stack space. 382 */ 383 bp = xfs_buf_read(target, blkno, len, flags | XBF_DONT_BLOCK); 384 if (bp == NULL) { 385 *bpp = NULL; 386 return (flags & XBF_TRYLOCK) ? 387 0 : XFS_ERROR(ENOMEM); 388 } 389 if (XFS_BUF_GETERROR(bp) != 0) { 390 XFS_BUF_SUPER_STALE(bp); 391 error = XFS_BUF_GETERROR(bp); 392 393 xfs_ioerror_alert("xfs_trans_read_buf", mp, 394 bp, blkno); 395 if (tp->t_flags & XFS_TRANS_DIRTY) 396 xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR); 397 xfs_buf_relse(bp); 398 return error; 399 } 400 #ifdef DEBUG 401 if (xfs_do_error && !(tp->t_flags & XFS_TRANS_DIRTY)) { 402 if (xfs_error_target == target) { 403 if (((xfs_req_num++) % xfs_error_mod) == 0) { 404 xfs_force_shutdown(tp->t_mountp, 405 SHUTDOWN_META_IO_ERROR); 406 xfs_buf_relse(bp); 407 xfs_debug(mp, "Returning trans error!"); 408 return XFS_ERROR(EIO); 409 } 410 } 411 } 412 #endif 413 if (XFS_FORCED_SHUTDOWN(mp)) 414 goto shutdown_abort; 415 416 _xfs_trans_bjoin(tp, bp, 1); 417 trace_xfs_trans_read_buf(bp->b_fspriv); 418 419 *bpp = bp; 420 return 0; 421 422 shutdown_abort: 423 /* 424 * the theory here is that buffer is good but we're 425 * bailing out because the filesystem is being forcibly 426 * shut down. So we should leave the b_flags alone since 427 * the buffer's not staled and just get out. 428 */ 429 #if defined(DEBUG) 430 if (XFS_BUF_ISSTALE(bp) && XFS_BUF_ISDELAYWRITE(bp)) 431 xfs_notice(mp, "about to pop assert, bp == 0x%p", bp); 432 #endif 433 ASSERT((XFS_BUF_BFLAGS(bp) & (XBF_STALE|XBF_DELWRI)) != 434 (XBF_STALE|XBF_DELWRI)); 435 436 trace_xfs_trans_read_buf_shut(bp, _RET_IP_); 437 xfs_buf_relse(bp); 438 *bpp = NULL; 439 return XFS_ERROR(EIO); 440 } 441 442 443 /* 444 * Release the buffer bp which was previously acquired with one of the 445 * xfs_trans_... buffer allocation routines if the buffer has not 446 * been modified within this transaction. If the buffer is modified 447 * within this transaction, do decrement the recursion count but do 448 * not release the buffer even if the count goes to 0. If the buffer is not 449 * modified within the transaction, decrement the recursion count and 450 * release the buffer if the recursion count goes to 0. 451 * 452 * If the buffer is to be released and it was not modified before 453 * this transaction began, then free the buf_log_item associated with it. 454 * 455 * If the transaction pointer is NULL, make this just a normal 456 * brelse() call. 457 */ 458 void 459 xfs_trans_brelse(xfs_trans_t *tp, 460 xfs_buf_t *bp) 461 { 462 xfs_buf_log_item_t *bip; 463 464 /* 465 * Default to a normal brelse() call if the tp is NULL. 466 */ 467 if (tp == NULL) { 468 struct xfs_log_item *lip = bp->b_fspriv; 469 470 ASSERT(bp->b_transp == NULL); 471 472 /* 473 * If there's a buf log item attached to the buffer, 474 * then let the AIL know that the buffer is being 475 * unlocked. 476 */ 477 if (lip != NULL && lip->li_type == XFS_LI_BUF) { 478 bip = bp->b_fspriv; 479 xfs_trans_unlocked_item(bip->bli_item.li_ailp, lip); 480 } 481 xfs_buf_relse(bp); 482 return; 483 } 484 485 ASSERT(bp->b_transp == tp); 486 bip = bp->b_fspriv; 487 ASSERT(bip->bli_item.li_type == XFS_LI_BUF); 488 ASSERT(!(bip->bli_flags & XFS_BLI_STALE)); 489 ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL)); 490 ASSERT(atomic_read(&bip->bli_refcount) > 0); 491 492 trace_xfs_trans_brelse(bip); 493 494 /* 495 * If the release is just for a recursive lock, 496 * then decrement the count and return. 497 */ 498 if (bip->bli_recur > 0) { 499 bip->bli_recur--; 500 return; 501 } 502 503 /* 504 * If the buffer is dirty within this transaction, we can't 505 * release it until we commit. 506 */ 507 if (bip->bli_item.li_desc->lid_flags & XFS_LID_DIRTY) 508 return; 509 510 /* 511 * If the buffer has been invalidated, then we can't release 512 * it until the transaction commits to disk unless it is re-dirtied 513 * as part of this transaction. This prevents us from pulling 514 * the item from the AIL before we should. 515 */ 516 if (bip->bli_flags & XFS_BLI_STALE) 517 return; 518 519 ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED)); 520 521 /* 522 * Free up the log item descriptor tracking the released item. 523 */ 524 xfs_trans_del_item(&bip->bli_item); 525 526 /* 527 * Clear the hold flag in the buf log item if it is set. 528 * We wouldn't want the next user of the buffer to 529 * get confused. 530 */ 531 if (bip->bli_flags & XFS_BLI_HOLD) { 532 bip->bli_flags &= ~XFS_BLI_HOLD; 533 } 534 535 /* 536 * Drop our reference to the buf log item. 537 */ 538 atomic_dec(&bip->bli_refcount); 539 540 /* 541 * If the buf item is not tracking data in the log, then 542 * we must free it before releasing the buffer back to the 543 * free pool. Before releasing the buffer to the free pool, 544 * clear the transaction pointer in b_fsprivate2 to dissolve 545 * its relation to this transaction. 546 */ 547 if (!xfs_buf_item_dirty(bip)) { 548 /*** 549 ASSERT(bp->b_pincount == 0); 550 ***/ 551 ASSERT(atomic_read(&bip->bli_refcount) == 0); 552 ASSERT(!(bip->bli_item.li_flags & XFS_LI_IN_AIL)); 553 ASSERT(!(bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF)); 554 xfs_buf_item_relse(bp); 555 bip = NULL; 556 } 557 bp->b_transp = NULL; 558 559 /* 560 * If we've still got a buf log item on the buffer, then 561 * tell the AIL that the buffer is being unlocked. 562 */ 563 if (bip != NULL) { 564 xfs_trans_unlocked_item(bip->bli_item.li_ailp, 565 (xfs_log_item_t*)bip); 566 } 567 568 xfs_buf_relse(bp); 569 return; 570 } 571 572 /* 573 * Mark the buffer as not needing to be unlocked when the buf item's 574 * IOP_UNLOCK() routine is called. The buffer must already be locked 575 * and associated with the given transaction. 576 */ 577 /* ARGSUSED */ 578 void 579 xfs_trans_bhold(xfs_trans_t *tp, 580 xfs_buf_t *bp) 581 { 582 xfs_buf_log_item_t *bip = bp->b_fspriv; 583 584 ASSERT(XFS_BUF_ISBUSY(bp)); 585 ASSERT(bp->b_transp == tp); 586 ASSERT(bip != NULL); 587 ASSERT(!(bip->bli_flags & XFS_BLI_STALE)); 588 ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL)); 589 ASSERT(atomic_read(&bip->bli_refcount) > 0); 590 591 bip->bli_flags |= XFS_BLI_HOLD; 592 trace_xfs_trans_bhold(bip); 593 } 594 595 /* 596 * Cancel the previous buffer hold request made on this buffer 597 * for this transaction. 598 */ 599 void 600 xfs_trans_bhold_release(xfs_trans_t *tp, 601 xfs_buf_t *bp) 602 { 603 xfs_buf_log_item_t *bip = bp->b_fspriv; 604 605 ASSERT(XFS_BUF_ISBUSY(bp)); 606 ASSERT(bp->b_transp == tp); 607 ASSERT(bip != NULL); 608 ASSERT(!(bip->bli_flags & XFS_BLI_STALE)); 609 ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL)); 610 ASSERT(atomic_read(&bip->bli_refcount) > 0); 611 ASSERT(bip->bli_flags & XFS_BLI_HOLD); 612 613 bip->bli_flags &= ~XFS_BLI_HOLD; 614 trace_xfs_trans_bhold_release(bip); 615 } 616 617 /* 618 * This is called to mark bytes first through last inclusive of the given 619 * buffer as needing to be logged when the transaction is committed. 620 * The buffer must already be associated with the given transaction. 621 * 622 * First and last are numbers relative to the beginning of this buffer, 623 * so the first byte in the buffer is numbered 0 regardless of the 624 * value of b_blkno. 625 */ 626 void 627 xfs_trans_log_buf(xfs_trans_t *tp, 628 xfs_buf_t *bp, 629 uint first, 630 uint last) 631 { 632 xfs_buf_log_item_t *bip = bp->b_fspriv; 633 634 ASSERT(XFS_BUF_ISBUSY(bp)); 635 ASSERT(bp->b_transp == tp); 636 ASSERT(bip != NULL); 637 ASSERT((first <= last) && (last < XFS_BUF_COUNT(bp))); 638 ASSERT(bp->b_iodone == NULL || 639 bp->b_iodone == xfs_buf_iodone_callbacks); 640 641 /* 642 * Mark the buffer as needing to be written out eventually, 643 * and set its iodone function to remove the buffer's buf log 644 * item from the AIL and free it when the buffer is flushed 645 * to disk. See xfs_buf_attach_iodone() for more details 646 * on li_cb and xfs_buf_iodone_callbacks(). 647 * If we end up aborting this transaction, we trap this buffer 648 * inside the b_bdstrat callback so that this won't get written to 649 * disk. 650 */ 651 XFS_BUF_DELAYWRITE(bp); 652 XFS_BUF_DONE(bp); 653 654 ASSERT(atomic_read(&bip->bli_refcount) > 0); 655 bp->b_iodone = xfs_buf_iodone_callbacks; 656 bip->bli_item.li_cb = xfs_buf_iodone; 657 658 trace_xfs_trans_log_buf(bip); 659 660 /* 661 * If we invalidated the buffer within this transaction, then 662 * cancel the invalidation now that we're dirtying the buffer 663 * again. There are no races with the code in xfs_buf_item_unpin(), 664 * because we have a reference to the buffer this entire time. 665 */ 666 if (bip->bli_flags & XFS_BLI_STALE) { 667 bip->bli_flags &= ~XFS_BLI_STALE; 668 ASSERT(XFS_BUF_ISSTALE(bp)); 669 XFS_BUF_UNSTALE(bp); 670 bip->bli_format.blf_flags &= ~XFS_BLF_CANCEL; 671 } 672 673 tp->t_flags |= XFS_TRANS_DIRTY; 674 bip->bli_item.li_desc->lid_flags |= XFS_LID_DIRTY; 675 bip->bli_flags |= XFS_BLI_LOGGED; 676 xfs_buf_item_log(bip, first, last); 677 } 678 679 680 /* 681 * This called to invalidate a buffer that is being used within 682 * a transaction. Typically this is because the blocks in the 683 * buffer are being freed, so we need to prevent it from being 684 * written out when we're done. Allowing it to be written again 685 * might overwrite data in the free blocks if they are reallocated 686 * to a file. 687 * 688 * We prevent the buffer from being written out by clearing the 689 * B_DELWRI flag. We can't always 690 * get rid of the buf log item at this point, though, because 691 * the buffer may still be pinned by another transaction. If that 692 * is the case, then we'll wait until the buffer is committed to 693 * disk for the last time (we can tell by the ref count) and 694 * free it in xfs_buf_item_unpin(). Until it is cleaned up we 695 * will keep the buffer locked so that the buffer and buf log item 696 * are not reused. 697 */ 698 void 699 xfs_trans_binval( 700 xfs_trans_t *tp, 701 xfs_buf_t *bp) 702 { 703 xfs_buf_log_item_t *bip = bp->b_fspriv; 704 705 ASSERT(XFS_BUF_ISBUSY(bp)); 706 ASSERT(bp->b_transp == tp); 707 ASSERT(bip != NULL); 708 ASSERT(atomic_read(&bip->bli_refcount) > 0); 709 710 trace_xfs_trans_binval(bip); 711 712 if (bip->bli_flags & XFS_BLI_STALE) { 713 /* 714 * If the buffer is already invalidated, then 715 * just return. 716 */ 717 ASSERT(!(XFS_BUF_ISDELAYWRITE(bp))); 718 ASSERT(XFS_BUF_ISSTALE(bp)); 719 ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY))); 720 ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_INODE_BUF)); 721 ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL); 722 ASSERT(bip->bli_item.li_desc->lid_flags & XFS_LID_DIRTY); 723 ASSERT(tp->t_flags & XFS_TRANS_DIRTY); 724 return; 725 } 726 727 /* 728 * Clear the dirty bit in the buffer and set the STALE flag 729 * in the buf log item. The STALE flag will be used in 730 * xfs_buf_item_unpin() to determine if it should clean up 731 * when the last reference to the buf item is given up. 732 * We set the XFS_BLF_CANCEL flag in the buf log format structure 733 * and log the buf item. This will be used at recovery time 734 * to determine that copies of the buffer in the log before 735 * this should not be replayed. 736 * We mark the item descriptor and the transaction dirty so 737 * that we'll hold the buffer until after the commit. 738 * 739 * Since we're invalidating the buffer, we also clear the state 740 * about which parts of the buffer have been logged. We also 741 * clear the flag indicating that this is an inode buffer since 742 * the data in the buffer will no longer be valid. 743 * 744 * We set the stale bit in the buffer as well since we're getting 745 * rid of it. 746 */ 747 XFS_BUF_UNDELAYWRITE(bp); 748 XFS_BUF_STALE(bp); 749 bip->bli_flags |= XFS_BLI_STALE; 750 bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY); 751 bip->bli_format.blf_flags &= ~XFS_BLF_INODE_BUF; 752 bip->bli_format.blf_flags |= XFS_BLF_CANCEL; 753 memset((char *)(bip->bli_format.blf_data_map), 0, 754 (bip->bli_format.blf_map_size * sizeof(uint))); 755 bip->bli_item.li_desc->lid_flags |= XFS_LID_DIRTY; 756 tp->t_flags |= XFS_TRANS_DIRTY; 757 } 758 759 /* 760 * This call is used to indicate that the buffer contains on-disk inodes which 761 * must be handled specially during recovery. They require special handling 762 * because only the di_next_unlinked from the inodes in the buffer should be 763 * recovered. The rest of the data in the buffer is logged via the inodes 764 * themselves. 765 * 766 * All we do is set the XFS_BLI_INODE_BUF flag in the items flags so it can be 767 * transferred to the buffer's log format structure so that we'll know what to 768 * do at recovery time. 769 */ 770 void 771 xfs_trans_inode_buf( 772 xfs_trans_t *tp, 773 xfs_buf_t *bp) 774 { 775 xfs_buf_log_item_t *bip = bp->b_fspriv; 776 777 ASSERT(XFS_BUF_ISBUSY(bp)); 778 ASSERT(bp->b_transp == tp); 779 ASSERT(bip != NULL); 780 ASSERT(atomic_read(&bip->bli_refcount) > 0); 781 782 bip->bli_flags |= XFS_BLI_INODE_BUF; 783 } 784 785 /* 786 * This call is used to indicate that the buffer is going to 787 * be staled and was an inode buffer. This means it gets 788 * special processing during unpin - where any inodes 789 * associated with the buffer should be removed from ail. 790 * There is also special processing during recovery, 791 * any replay of the inodes in the buffer needs to be 792 * prevented as the buffer may have been reused. 793 */ 794 void 795 xfs_trans_stale_inode_buf( 796 xfs_trans_t *tp, 797 xfs_buf_t *bp) 798 { 799 xfs_buf_log_item_t *bip = bp->b_fspriv; 800 801 ASSERT(XFS_BUF_ISBUSY(bp)); 802 ASSERT(bp->b_transp == tp); 803 ASSERT(bip != NULL); 804 ASSERT(atomic_read(&bip->bli_refcount) > 0); 805 806 bip->bli_flags |= XFS_BLI_STALE_INODE; 807 bip->bli_item.li_cb = xfs_buf_iodone; 808 } 809 810 /* 811 * Mark the buffer as being one which contains newly allocated 812 * inodes. We need to make sure that even if this buffer is 813 * relogged as an 'inode buf' we still recover all of the inode 814 * images in the face of a crash. This works in coordination with 815 * xfs_buf_item_committed() to ensure that the buffer remains in the 816 * AIL at its original location even after it has been relogged. 817 */ 818 /* ARGSUSED */ 819 void 820 xfs_trans_inode_alloc_buf( 821 xfs_trans_t *tp, 822 xfs_buf_t *bp) 823 { 824 xfs_buf_log_item_t *bip = bp->b_fspriv; 825 826 ASSERT(XFS_BUF_ISBUSY(bp)); 827 ASSERT(bp->b_transp == tp); 828 ASSERT(bip != NULL); 829 ASSERT(atomic_read(&bip->bli_refcount) > 0); 830 831 bip->bli_flags |= XFS_BLI_INODE_ALLOC_BUF; 832 } 833 834 835 /* 836 * Similar to xfs_trans_inode_buf(), this marks the buffer as a cluster of 837 * dquots. However, unlike in inode buffer recovery, dquot buffers get 838 * recovered in their entirety. (Hence, no XFS_BLI_DQUOT_ALLOC_BUF flag). 839 * The only thing that makes dquot buffers different from regular 840 * buffers is that we must not replay dquot bufs when recovering 841 * if a _corresponding_ quotaoff has happened. We also have to distinguish 842 * between usr dquot bufs and grp dquot bufs, because usr and grp quotas 843 * can be turned off independently. 844 */ 845 /* ARGSUSED */ 846 void 847 xfs_trans_dquot_buf( 848 xfs_trans_t *tp, 849 xfs_buf_t *bp, 850 uint type) 851 { 852 xfs_buf_log_item_t *bip = bp->b_fspriv; 853 854 ASSERT(XFS_BUF_ISBUSY(bp)); 855 ASSERT(bp->b_transp == tp); 856 ASSERT(bip != NULL); 857 ASSERT(type == XFS_BLF_UDQUOT_BUF || 858 type == XFS_BLF_PDQUOT_BUF || 859 type == XFS_BLF_GDQUOT_BUF); 860 ASSERT(atomic_read(&bip->bli_refcount) > 0); 861 862 bip->bli_format.blf_flags |= type; 863 } 864