fs/xfs/xfs_buf_item.c

   1 /*
   2  * Copyright (c) 2000-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_dmapi.h"
  28 #include "xfs_mount.h"
  29 #include "xfs_buf_item.h"
  30 #include "xfs_trans_priv.h"
  31 #include "xfs_error.h"
  32 #include "xfs_trace.h"
  33
  34
  35 kmem_zone_t     *xfs_buf_item_zone;
  36
  37 #ifdef XFS_TRANS_DEBUG
  38 /*
  39  * This function uses an alternate strategy for tracking the bytes
  40  * that the user requests to be logged.  This can then be used
  41  * in conjunction with the bli_orig array in the buf log item to
  42  * catch bugs in our callers' code.
  43  *
  44  * We also double check the bits set in xfs_buf_item_log using a
  45  * simple algorithm to check that every byte is accounted for.
  46  */
  47 STATIC void
  48 xfs_buf_item_log_debug(
  49         xfs_buf_log_item_t      *bip,
  50         uint                    first,
  51         uint                    last)
  52 {
  53         uint    x;
  54         uint    byte;
  55         uint    nbytes;
  56         uint    chunk_num;
  57         uint    word_num;
  58         uint    bit_num;
  59         uint    bit_set;
  60         uint    *wordp;
  61
  62         ASSERT(bip->bli_logged != NULL);
  63         byte = first;
  64         nbytes = last - first + 1;
  65         bfset(bip->bli_logged, first, nbytes);
  66         for (x = 0; x < nbytes; x++) {
  67                 chunk_num = byte >> XFS_BLI_SHIFT;
  68                 word_num = chunk_num >> BIT_TO_WORD_SHIFT;
  69                 bit_num = chunk_num & (NBWORD - 1);
  70                 wordp = &(bip->bli_format.blf_data_map[word_num]);
  71                 bit_set = *wordp & (1 << bit_num);
  72                 ASSERT(bit_set);
  73                 byte++;
  74         }
  75 }
  76
  77 /*
  78  * This function is called when we flush something into a buffer without
  79  * logging it.  This happens for things like inodes which are logged
  80  * separately from the buffer.
  81  */
  82 void
  83 xfs_buf_item_flush_log_debug(
  84         xfs_buf_t       *bp,
  85         uint            first,
  86         uint            last)
  87 {
  88         xfs_buf_log_item_t      *bip;
  89         uint                    nbytes;
  90
  91         bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t*);
  92         if ((bip == NULL) || (bip->bli_item.li_type != XFS_LI_BUF)) {
  93                 return;
  94         }
  95
  96         ASSERT(bip->bli_logged != NULL);
  97         nbytes = last - first + 1;
  98         bfset(bip->bli_logged, first, nbytes);
  99 }
 100
 101 /*
 102  * This function is called to verify that our callers have logged
 103  * all the bytes that they changed.
 104  *
 105  * It does this by comparing the original copy of the buffer stored in
 106  * the buf log item's bli_orig array to the current copy of the buffer
 107  * and ensuring that all bytes which mismatch are set in the bli_logged
 108  * array of the buf log item.
 109  */
 110 STATIC void
 111 xfs_buf_item_log_check(
 112         xfs_buf_log_item_t      *bip)
 113 {
 114         char            *orig;
 115         char            *buffer;
 116         int             x;
 117         xfs_buf_t       *bp;
 118
 119         ASSERT(bip->bli_orig != NULL);
 120         ASSERT(bip->bli_logged != NULL);
 121
 122         bp = bip->bli_buf;
 123         ASSERT(XFS_BUF_COUNT(bp) > 0);
 124         ASSERT(XFS_BUF_PTR(bp) != NULL);
 125         orig = bip->bli_orig;
 126         buffer = XFS_BUF_PTR(bp);
 127         for (x = 0; x < XFS_BUF_COUNT(bp); x++) {
 128                 if (orig[x] != buffer[x] && !btst(bip->bli_logged, x))
 129                         cmn_err(CE_PANIC,
 130         "xfs_buf_item_log_check bip %x buffer %x orig %x index %d",
 131                                 bip, bp, orig, x);
 132         }
 133 }
 134 #else
 135 #define         xfs_buf_item_log_debug(x,y,z)
 136 #define         xfs_buf_item_log_check(x)
 137 #endif
 138
 139 STATIC void     xfs_buf_error_relse(xfs_buf_t *bp);
 140 STATIC void     xfs_buf_do_callbacks(xfs_buf_t *bp, xfs_log_item_t *lip);
 141
 142 /*
 143  * This returns the number of log iovecs needed to log the
 144  * given buf log item.
 145  *
 146  * It calculates this as 1 iovec for the buf log format structure
 147  * and 1 for each stretch of non-contiguous chunks to be logged.
 148  * Contiguous chunks are logged in a single iovec.
 149  *
 150  * If the XFS_BLI_STALE flag has been set, then log nothing.
 151  */
 152 STATIC uint
 153 xfs_buf_item_size(
 154         xfs_buf_log_item_t      *bip)
 155 {
 156         uint            nvecs;
 157         int             next_bit;
 158         int             last_bit;
 159         xfs_buf_t       *bp;
 160
 161         ASSERT(atomic_read(&bip->bli_refcount) > 0);
 162         if (bip->bli_flags & XFS_BLI_STALE) {
 163                 /*
 164                  * The buffer is stale, so all we need to log
 165                  * is the buf log format structure with the
 166                  * cancel flag in it.
 167                  */
 168                 trace_xfs_buf_item_size_stale(bip);
 169                 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
 170                 return 1;
 171         }
 172
 173         bp = bip->bli_buf;
 174         ASSERT(bip->bli_flags & XFS_BLI_LOGGED);
 175         nvecs = 1;
 176         last_bit = xfs_next_bit(bip->bli_format.blf_data_map,
 177                                          bip->bli_format.blf_map_size, 0);
 178         ASSERT(last_bit != -1);
 179         nvecs++;
 180         while (last_bit != -1) {
 181                 /*
 182                  * This takes the bit number to start looking from and
 183                  * returns the next set bit from there.  It returns -1
 184                  * if there are no more bits set or the start bit is
 185                  * beyond the end of the bitmap.
 186                  */
 187                 next_bit = xfs_next_bit(bip->bli_format.blf_data_map,
 188                                                  bip->bli_format.blf_map_size,
 189                                                  last_bit + 1);
 190                 /*
 191                  * If we run out of bits, leave the loop,
 192                  * else if we find a new set of bits bump the number of vecs,
 193                  * else keep scanning the current set of bits.
 194                  */
 195                 if (next_bit == -1) {
 196                         last_bit = -1;
 197                 } else if (next_bit != last_bit + 1) {
 198                         last_bit = next_bit;
 199                         nvecs++;
 200                 } else if (xfs_buf_offset(bp, next_bit * XFS_BLI_CHUNK) !=
 201                            (xfs_buf_offset(bp, last_bit * XFS_BLI_CHUNK) +
 202                             XFS_BLI_CHUNK)) {
 203                         last_bit = next_bit;
 204                         nvecs++;
 205                 } else {
 206                         last_bit++;
 207                 }
 208         }
 209
 210         trace_xfs_buf_item_size(bip);
 211         return nvecs;
 212 }
 213
 214 /*
 215  * This is called to fill in the vector of log iovecs for the
 216  * given log buf item.  It fills the first entry with a buf log
 217  * format structure, and the rest point to contiguous chunks
 218  * within the buffer.
 219  */
 220 STATIC void
 221 xfs_buf_item_format(
 222         xfs_buf_log_item_t      *bip,
 223         xfs_log_iovec_t         *log_vector)
 224 {
 225         uint            base_size;
 226         uint            nvecs;
 227         xfs_log_iovec_t *vecp;
 228         xfs_buf_t       *bp;
 229         int             first_bit;
 230         int             last_bit;
 231         int             next_bit;
 232         uint            nbits;
 233         uint            buffer_offset;
 234
 235         ASSERT(atomic_read(&bip->bli_refcount) > 0);
 236         ASSERT((bip->bli_flags & XFS_BLI_LOGGED) ||
 237                (bip->bli_flags & XFS_BLI_STALE));
 238         bp = bip->bli_buf;
 239         vecp = log_vector;
 240
 241         /*
 242          * The size of the base structure is the size of the
 243          * declared structure plus the space for the extra words
 244          * of the bitmap.  We subtract one from the map size, because
 245          * the first element of the bitmap is accounted for in the
 246          * size of the base structure.
 247          */
 248         base_size =
 249                 (uint)(sizeof(xfs_buf_log_format_t) +
 250                        ((bip->bli_format.blf_map_size - 1) * sizeof(uint)));
 251         vecp->i_addr = (xfs_caddr_t)&bip->bli_format;
 252         vecp->i_len = base_size;
 253         XLOG_VEC_SET_TYPE(vecp, XLOG_REG_TYPE_BFORMAT);
 254         vecp++;
 255         nvecs = 1;
 256
 257         if (bip->bli_flags & XFS_BLI_STALE) {
 258                 /*
 259                  * The buffer is stale, so all we need to log
 260                  * is the buf log format structure with the
 261                  * cancel flag in it.
 262                  */
 263                 trace_xfs_buf_item_format_stale(bip);
 264                 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
 265                 bip->bli_format.blf_size = nvecs;
 266                 return;
 267         }
 268
 269         /*
 270          * Fill in an iovec for each set of contiguous chunks.
 271          */
 272         first_bit = xfs_next_bit(bip->bli_format.blf_data_map,
 273                                          bip->bli_format.blf_map_size, 0);
 274         ASSERT(first_bit != -1);
 275         last_bit = first_bit;
 276         nbits = 1;
 277         for (;;) {
 278                 /*
 279                  * This takes the bit number to start looking from and
 280                  * returns the next set bit from there.  It returns -1
 281                  * if there are no more bits set or the start bit is
 282                  * beyond the end of the bitmap.
 283                  */
 284                 next_bit = xfs_next_bit(bip->bli_format.blf_data_map,
 285                                                  bip->bli_format.blf_map_size,
 286                                                  (uint)last_bit + 1);
 287                 /*
 288                  * If we run out of bits fill in the last iovec and get
 289                  * out of the loop.
 290                  * Else if we start a new set of bits then fill in the
 291                  * iovec for the series we were looking at and start
 292                  * counting the bits in the new one.
 293                  * Else we're still in the same set of bits so just
 294                  * keep counting and scanning.
 295                  */
 296                 if (next_bit == -1) {
 297                         buffer_offset = first_bit * XFS_BLI_CHUNK;
 298                         vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
 299                         vecp->i_len = nbits * XFS_BLI_CHUNK;
 300                         XLOG_VEC_SET_TYPE(vecp, XLOG_REG_TYPE_BCHUNK);
 301                         nvecs++;
 302                         break;
 303                 } else if (next_bit != last_bit + 1) {
 304                         buffer_offset = first_bit * XFS_BLI_CHUNK;
 305                         vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
 306                         vecp->i_len = nbits * XFS_BLI_CHUNK;
 307                         XLOG_VEC_SET_TYPE(vecp, XLOG_REG_TYPE_BCHUNK);
 308                         nvecs++;
 309                         vecp++;
 310                         first_bit = next_bit;
 311                         last_bit = next_bit;
 312                         nbits = 1;
 313                 } else if (xfs_buf_offset(bp, next_bit << XFS_BLI_SHIFT) !=
 314                            (xfs_buf_offset(bp, last_bit << XFS_BLI_SHIFT) +
 315                             XFS_BLI_CHUNK)) {
 316                         buffer_offset = first_bit * XFS_BLI_CHUNK;
 317                         vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
 318                         vecp->i_len = nbits * XFS_BLI_CHUNK;
 319                         XLOG_VEC_SET_TYPE(vecp, XLOG_REG_TYPE_BCHUNK);
 320 /* You would think we need to bump the nvecs here too, but we do not
 321  * this number is used by recovery, and it gets confused by the boundary
 322  * split here
 323  *                      nvecs++;
 324  */
 325                         vecp++;
 326                         first_bit = next_bit;
 327                         last_bit = next_bit;
 328                         nbits = 1;
 329                 } else {
 330                         last_bit++;
 331                         nbits++;
 332                 }
 333         }
 334         bip->bli_format.blf_size = nvecs;
 335
 336         /*
 337          * Check to make sure everything is consistent.
 338          */
 339         trace_xfs_buf_item_format(bip);
 340         xfs_buf_item_log_check(bip);
 341 }
 342
 343 /*
 344  * This is called to pin the buffer associated with the buf log
 345  * item in memory so it cannot be written out.  Simply call bpin()
 346  * on the buffer to do this.
 347  */
 348 STATIC void
 349 xfs_buf_item_pin(
 350         xfs_buf_log_item_t      *bip)
 351 {
 352         xfs_buf_t       *bp;
 353
 354         bp = bip->bli_buf;
 355         ASSERT(XFS_BUF_ISBUSY(bp));
 356         ASSERT(atomic_read(&bip->bli_refcount) > 0);
 357         ASSERT((bip->bli_flags & XFS_BLI_LOGGED) ||
 358                (bip->bli_flags & XFS_BLI_STALE));
 359         trace_xfs_buf_item_pin(bip);
 360         xfs_bpin(bp);
 361 }
 362
 363
 364 /*
 365  * This is called to unpin the buffer associated with the buf log
 366  * item which was previously pinned with a call to xfs_buf_item_pin().
 367  * Just call bunpin() on the buffer to do this.
 368  *
 369  * Also drop the reference to the buf item for the current transaction.
 370  * If the XFS_BLI_STALE flag is set and we are the last reference,
 371  * then free up the buf log item and unlock the buffer.
 372  */
 373 STATIC void
 374 xfs_buf_item_unpin(
 375         xfs_buf_log_item_t      *bip,
 376         int                     stale)
 377 {
 378         struct xfs_ail  *ailp;
 379         xfs_buf_t       *bp;
 380         int             freed;
 381
 382         bp = bip->bli_buf;
 383         ASSERT(bp != NULL);
 384         ASSERT(XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *) == bip);
 385         ASSERT(atomic_read(&bip->bli_refcount) > 0);
 386         trace_xfs_buf_item_unpin(bip);
 387
 388         freed = atomic_dec_and_test(&bip->bli_refcount);
 389         ailp = bip->bli_item.li_ailp;
 390         xfs_bunpin(bp);
 391         if (freed && stale) {
 392                 ASSERT(bip->bli_flags & XFS_BLI_STALE);
 393                 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
 394                 ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
 395                 ASSERT(XFS_BUF_ISSTALE(bp));
 396                 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
 397                 trace_xfs_buf_item_unpin_stale(bip);
 398
 399                 /*
 400                  * If we get called here because of an IO error, we may
 401                  * or may not have the item on the AIL. xfs_trans_ail_delete()
 402                  * will take care of that situation.
 403                  * xfs_trans_ail_delete() drops the AIL lock.
 404                  */
 405                 if (bip->bli_flags & XFS_BLI_STALE_INODE) {
 406                         xfs_buf_do_callbacks(bp, (xfs_log_item_t *)bip);
 407                         XFS_BUF_SET_FSPRIVATE(bp, NULL);
 408                         XFS_BUF_CLR_IODONE_FUNC(bp);
 409                 } else {
 410                         spin_lock(&ailp->xa_lock);
 411                         xfs_trans_ail_delete(ailp, (xfs_log_item_t *)bip);
 412                         xfs_buf_item_relse(bp);
 413                         ASSERT(XFS_BUF_FSPRIVATE(bp, void *) == NULL);
 414                 }
 415                 xfs_buf_relse(bp);
 416         }
 417 }
 418
 419 /*
 420  * this is called from uncommit in the forced-shutdown path.
 421  * we need to check to see if the reference count on the log item
 422  * is going to drop to zero.  If so, unpin will free the log item
 423  * so we need to free the item's descriptor (that points to the item)
 424  * in the transaction.
 425  */
 426 STATIC void
 427 xfs_buf_item_unpin_remove(
 428         xfs_buf_log_item_t      *bip,
 429         xfs_trans_t             *tp)
 430 {
 431         xfs_buf_t               *bp;
 432         xfs_log_item_desc_t     *lidp;
 433         int                     stale = 0;
 434
 435         bp = bip->bli_buf;
 436         /*
 437          * will xfs_buf_item_unpin() call xfs_buf_item_relse()?
 438          */
 439         if ((atomic_read(&bip->bli_refcount) == 1) &&
 440             (bip->bli_flags & XFS_BLI_STALE)) {
 441                 ASSERT(XFS_BUF_VALUSEMA(bip->bli_buf) <= 0);
 442                 trace_xfs_buf_item_unpin_stale(bip);
 443
 444                 /*
 445                  * yes -- clear the xaction descriptor in-use flag
 446                  * and free the chunk if required.  We can safely
 447                  * do some work here and then call buf_item_unpin
 448                  * to do the rest because if the if is true, then
 449                  * we are holding the buffer locked so no one else
 450                  * will be able to bump up the refcount.
 451                  */
 452                 lidp = xfs_trans_find_item(tp, (xfs_log_item_t *) bip);
 453                 stale = lidp->lid_flags & XFS_LID_BUF_STALE;
 454                 xfs_trans_free_item(tp, lidp);
 455                 /*
 456                  * Since the transaction no longer refers to the buffer,
 457                  * the buffer should no longer refer to the transaction.
 458                  */
 459                 XFS_BUF_SET_FSPRIVATE2(bp, NULL);
 460         }
 461
 462         xfs_buf_item_unpin(bip, stale);
 463
 464         return;
 465 }
 466
 467 /*
 468  * This is called to attempt to lock the buffer associated with this
 469  * buf log item.  Don't sleep on the buffer lock.  If we can't get
 470  * the lock right away, return 0.  If we can get the lock, pull the
 471  * buffer from the free list, mark it busy, and return 1.
 472  */
 473 STATIC uint
 474 xfs_buf_item_trylock(
 475         xfs_buf_log_item_t      *bip)
 476 {
 477         xfs_buf_t       *bp;
 478
 479         bp = bip->bli_buf;
 480
 481         if (XFS_BUF_ISPINNED(bp)) {
 482                 return XFS_ITEM_PINNED;
 483         }
 484
 485         if (!XFS_BUF_CPSEMA(bp)) {
 486                 return XFS_ITEM_LOCKED;
 487         }
 488
 489         /*
 490          * Remove the buffer from the free list.  Only do this
 491          * if it's on the free list.  Private buffers like the
 492          * superblock buffer are not.
 493          */
 494         XFS_BUF_HOLD(bp);
 495
 496         ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
 497         trace_xfs_buf_item_trylock(bip);
 498         return XFS_ITEM_SUCCESS;
 499 }
 500
 501 /*
 502  * Release the buffer associated with the buf log item.
 503  * If there is no dirty logged data associated with the
 504  * buffer recorded in the buf log item, then free the
 505  * buf log item and remove the reference to it in the
 506  * buffer.
 507  *
 508  * This call ignores the recursion count.  It is only called
 509  * when the buffer should REALLY be unlocked, regardless
 510  * of the recursion count.
 511  *
 512  * If the XFS_BLI_HOLD flag is set in the buf log item, then
 513  * free the log item if necessary but do not unlock the buffer.
 514  * This is for support of xfs_trans_bhold(). Make sure the
 515  * XFS_BLI_HOLD field is cleared if we don't free the item.
 516  */
 517 STATIC void
 518 xfs_buf_item_unlock(
 519         xfs_buf_log_item_t      *bip)
 520 {
 521         int             aborted;
 522         xfs_buf_t       *bp;
 523         uint            hold;
 524
 525         bp = bip->bli_buf;
 526
 527         /*
 528          * Clear the buffer's association with this transaction.
 529          */
 530         XFS_BUF_SET_FSPRIVATE2(bp, NULL);
 531
 532         /*
 533          * If this is a transaction abort, don't return early.
 534          * Instead, allow the brelse to happen.
 535          * Normally it would be done for stale (cancelled) buffers
 536          * at unpin time, but we'll never go through the pin/unpin
 537          * cycle if we abort inside commit.
 538          */
 539         aborted = (bip->bli_item.li_flags & XFS_LI_ABORTED) != 0;
 540
 541         /*
 542          * If the buf item is marked stale, then don't do anything.
 543          * We'll unlock the buffer and free the buf item when the
 544          * buffer is unpinned for the last time.
 545          */
 546         if (bip->bli_flags & XFS_BLI_STALE) {
 547                 bip->bli_flags &= ~XFS_BLI_LOGGED;
 548                 trace_xfs_buf_item_unlock_stale(bip);
 549                 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
 550                 if (!aborted)
 551                         return;
 552         }
 553
 554         /*
 555          * Drop the transaction's reference to the log item if
 556          * it was not logged as part of the transaction.  Otherwise
 557          * we'll drop the reference in xfs_buf_item_unpin() when
 558          * the transaction is really through with the buffer.
 559          */
 560         if (!(bip->bli_flags & XFS_BLI_LOGGED)) {
 561                 atomic_dec(&bip->bli_refcount);
 562         } else {
 563                 /*
 564                  * Clear the logged flag since this is per
 565                  * transaction state.
 566                  */
 567                 bip->bli_flags &= ~XFS_BLI_LOGGED;
 568         }
 569
 570         /*
 571          * Before possibly freeing the buf item, determine if we should
 572          * release the buffer at the end of this routine.
 573          */
 574         hold = bip->bli_flags & XFS_BLI_HOLD;
 575         trace_xfs_buf_item_unlock(bip);
 576
 577         /*
 578          * If the buf item isn't tracking any data, free it.
 579          * Otherwise, if XFS_BLI_HOLD is set clear it.
 580          */
 581         if (xfs_bitmap_empty(bip->bli_format.blf_data_map,
 582                              bip->bli_format.blf_map_size)) {
 583                 xfs_buf_item_relse(bp);
 584         } else if (hold) {
 585                 bip->bli_flags &= ~XFS_BLI_HOLD;
 586         }
 587
 588         /*
 589          * Release the buffer if XFS_BLI_HOLD was not set.
 590          */
 591         if (!hold) {
 592                 xfs_buf_relse(bp);
 593         }
 594 }
 595
 596 /*
 597  * This is called to find out where the oldest active copy of the
 598  * buf log item in the on disk log resides now that the last log
 599  * write of it completed at the given lsn.
 600  * We always re-log all the dirty data in a buffer, so usually the
 601  * latest copy in the on disk log is the only one that matters.  For
 602  * those cases we simply return the given lsn.
 603  *
 604  * The one exception to this is for buffers full of newly allocated
 605  * inodes.  These buffers are only relogged with the XFS_BLI_INODE_BUF
 606  * flag set, indicating that only the di_next_unlinked fields from the
 607  * inodes in the buffers will be replayed during recovery.  If the
 608  * original newly allocated inode images have not yet been flushed
 609  * when the buffer is so relogged, then we need to make sure that we
 610  * keep the old images in the 'active' portion of the log.  We do this
 611  * by returning the original lsn of that transaction here rather than
 612  * the current one.
 613  */
 614 STATIC xfs_lsn_t
 615 xfs_buf_item_committed(
 616         xfs_buf_log_item_t      *bip,
 617         xfs_lsn_t               lsn)
 618 {
 619         trace_xfs_buf_item_committed(bip);
 620
 621         if ((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) &&
 622             (bip->bli_item.li_lsn != 0)) {
 623                 return bip->bli_item.li_lsn;
 624         }
 625         return (lsn);
 626 }
 627
 628 /*
 629  * This is called to asynchronously write the buffer associated with this
 630  * buf log item out to disk. The buffer will already have been locked by
 631  * a successful call to xfs_buf_item_trylock().  If the buffer still has
 632  * B_DELWRI set, then get it going out to disk with a call to bawrite().
 633  * If not, then just release the buffer.
 634  */
 635 STATIC void
 636 xfs_buf_item_push(
 637         xfs_buf_log_item_t      *bip)
 638 {
 639         xfs_buf_t       *bp;
 640
 641         ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
 642         trace_xfs_buf_item_push(bip);
 643
 644         bp = bip->bli_buf;
 645
 646         if (XFS_BUF_ISDELAYWRITE(bp)) {
 647                 int     error;
 648                 error = xfs_bawrite(bip->bli_item.li_mountp, bp);
 649                 if (error)
 650                         xfs_fs_cmn_err(CE_WARN, bip->bli_item.li_mountp,
 651                         "xfs_buf_item_push: pushbuf error %d on bip %p, bp %p",
 652                                         error, bip, bp);
 653         } else {
 654                 xfs_buf_relse(bp);
 655         }
 656 }
 657
 658 /* ARGSUSED */
 659 STATIC void
 660 xfs_buf_item_committing(xfs_buf_log_item_t *bip, xfs_lsn_t commit_lsn)
 661 {
 662 }
 663
 664 /*
 665  * This is the ops vector shared by all buf log items.
 666  */
 667 static struct xfs_item_ops xfs_buf_item_ops = {
 668         .iop_size       = (uint(*)(xfs_log_item_t*))xfs_buf_item_size,
 669         .iop_format     = (void(*)(xfs_log_item_t*, xfs_log_iovec_t*))
 670                                         xfs_buf_item_format,
 671         .iop_pin        = (void(*)(xfs_log_item_t*))xfs_buf_item_pin,
 672         .iop_unpin      = (void(*)(xfs_log_item_t*, int))xfs_buf_item_unpin,
 673         .iop_unpin_remove = (void(*)(xfs_log_item_t*, xfs_trans_t *))
 674                                         xfs_buf_item_unpin_remove,
 675         .iop_trylock    = (uint(*)(xfs_log_item_t*))xfs_buf_item_trylock,
 676         .iop_unlock     = (void(*)(xfs_log_item_t*))xfs_buf_item_unlock,
 677         .iop_committed  = (xfs_lsn_t(*)(xfs_log_item_t*, xfs_lsn_t))
 678                                         xfs_buf_item_committed,
 679         .iop_push       = (void(*)(xfs_log_item_t*))xfs_buf_item_push,
 680         .iop_pushbuf    = NULL,
 681         .iop_committing = (void(*)(xfs_log_item_t*, xfs_lsn_t))
 682                                         xfs_buf_item_committing
 683 };
 684
 685
 686 /*
 687  * Allocate a new buf log item to go with the given buffer.
 688  * Set the buffer's b_fsprivate field to point to the new
 689  * buf log item.  If there are other item's attached to the
 690  * buffer (see xfs_buf_attach_iodone() below), then put the
 691  * buf log item at the front.
 692  */
 693 void
 694 xfs_buf_item_init(
 695         xfs_buf_t       *bp,
 696         xfs_mount_t     *mp)
 697 {
 698         xfs_log_item_t          *lip;
 699         xfs_buf_log_item_t      *bip;
 700         int                     chunks;
 701         int                     map_size;
 702
 703         /*
 704          * Check to see if there is already a buf log item for
 705          * this buffer.  If there is, it is guaranteed to be
 706          * the first.  If we do already have one, there is
 707          * nothing to do here so return.
 708          */
 709         if (bp->b_mount != mp)
 710                 bp->b_mount = mp;
 711         XFS_BUF_SET_BDSTRAT_FUNC(bp, xfs_bdstrat_cb);
 712         if (XFS_BUF_FSPRIVATE(bp, void *) != NULL) {
 713                 lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
 714                 if (lip->li_type == XFS_LI_BUF) {
 715                         return;
 716                 }
 717         }
 718
 719         /*
 720          * chunks is the number of XFS_BLI_CHUNK size pieces
 721          * the buffer can be divided into. Make sure not to
 722          * truncate any pieces.  map_size is the size of the
 723          * bitmap needed to describe the chunks of the buffer.
 724          */
 725         chunks = (int)((XFS_BUF_COUNT(bp) + (XFS_BLI_CHUNK - 1)) >> XFS_BLI_SHIFT);
 726         map_size = (int)((chunks + NBWORD) >> BIT_TO_WORD_SHIFT);
 727
 728         bip = (xfs_buf_log_item_t*)kmem_zone_zalloc(xfs_buf_item_zone,
 729                                                     KM_SLEEP);
 730         bip->bli_item.li_type = XFS_LI_BUF;
 731         bip->bli_item.li_ops = &xfs_buf_item_ops;
 732         bip->bli_item.li_mountp = mp;
 733         bip->bli_item.li_ailp = mp->m_ail;
 734         bip->bli_buf = bp;
 735         xfs_buf_hold(bp);
 736         bip->bli_format.blf_type = XFS_LI_BUF;
 737         bip->bli_format.blf_blkno = (__int64_t)XFS_BUF_ADDR(bp);
 738         bip->bli_format.blf_len = (ushort)BTOBB(XFS_BUF_COUNT(bp));
 739         bip->bli_format.blf_map_size = map_size;
 740
 741 #ifdef XFS_TRANS_DEBUG
 742         /*
 743          * Allocate the arrays for tracking what needs to be logged
 744          * and what our callers request to be logged.  bli_orig
 745          * holds a copy of the original, clean buffer for comparison
 746          * against, and bli_logged keeps a 1 bit flag per byte in
 747          * the buffer to indicate which bytes the callers have asked
 748          * to have logged.
 749          */
 750         bip->bli_orig = (char *)kmem_alloc(XFS_BUF_COUNT(bp), KM_SLEEP);
 751         memcpy(bip->bli_orig, XFS_BUF_PTR(bp), XFS_BUF_COUNT(bp));
 752         bip->bli_logged = (char *)kmem_zalloc(XFS_BUF_COUNT(bp) / NBBY, KM_SLEEP);
 753 #endif
 754
 755         /*
 756          * Put the buf item into the list of items attached to the
 757          * buffer at the front.
 758          */
 759         if (XFS_BUF_FSPRIVATE(bp, void *) != NULL) {
 760                 bip->bli_item.li_bio_list =
 761                                 XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
 762         }
 763         XFS_BUF_SET_FSPRIVATE(bp, bip);
 764 }
 765
 766
 767 /*
 768  * Mark bytes first through last inclusive as dirty in the buf
 769  * item's bitmap.
 770  */
 771 void
 772 xfs_buf_item_log(
 773         xfs_buf_log_item_t      *bip,
 774         uint                    first,
 775         uint                    last)
 776 {
 777         uint            first_bit;
 778         uint            last_bit;
 779         uint            bits_to_set;
 780         uint            bits_set;
 781         uint            word_num;
 782         uint            *wordp;
 783         uint            bit;
 784         uint            end_bit;
 785         uint            mask;
 786
 787         /*
 788          * Mark the item as having some dirty data for
 789          * quick reference in xfs_buf_item_dirty.
 790          */
 791         bip->bli_flags |= XFS_BLI_DIRTY;
 792
 793         /*
 794          * Convert byte offsets to bit numbers.
 795          */
 796         first_bit = first >> XFS_BLI_SHIFT;
 797         last_bit = last >> XFS_BLI_SHIFT;
 798
 799         /*
 800          * Calculate the total number of bits to be set.
 801          */
 802         bits_to_set = last_bit - first_bit + 1;
 803
 804         /*
 805          * Get a pointer to the first word in the bitmap
 806          * to set a bit in.
 807          */
 808         word_num = first_bit >> BIT_TO_WORD_SHIFT;
 809         wordp = &(bip->bli_format.blf_data_map[word_num]);
 810
 811         /*
 812          * Calculate the starting bit in the first word.
 813          */
 814         bit = first_bit & (uint)(NBWORD - 1);
 815
 816         /*
 817          * First set any bits in the first word of our range.
 818          * If it starts at bit 0 of the word, it will be
 819          * set below rather than here.  That is what the variable
 820          * bit tells us. The variable bits_set tracks the number
 821          * of bits that have been set so far.  End_bit is the number
 822          * of the last bit to be set in this word plus one.
 823          */
 824         if (bit) {
 825                 end_bit = MIN(bit + bits_to_set, (uint)NBWORD);
 826                 mask = ((1 << (end_bit - bit)) - 1) << bit;
 827                 *wordp |= mask;
 828                 wordp++;
 829                 bits_set = end_bit - bit;
 830         } else {
 831                 bits_set = 0;
 832         }
 833
 834         /*
 835          * Now set bits a whole word at a time that are between
 836          * first_bit and last_bit.
 837          */
 838         while ((bits_to_set - bits_set) >= NBWORD) {
 839                 *wordp |= 0xffffffff;
 840                 bits_set += NBWORD;
 841                 wordp++;
 842         }
 843
 844         /*
 845          * Finally, set any bits left to be set in one last partial word.
 846          */
 847         end_bit = bits_to_set - bits_set;
 848         if (end_bit) {
 849                 mask = (1 << end_bit) - 1;
 850                 *wordp |= mask;
 851         }
 852
 853         xfs_buf_item_log_debug(bip, first, last);
 854 }
 855
 856
 857 /*
 858  * Return 1 if the buffer has some data that has been logged (at any
 859  * point, not just the current transaction) and 0 if not.
 860  */
 861 uint
 862 xfs_buf_item_dirty(
 863         xfs_buf_log_item_t      *bip)
 864 {
 865         return (bip->bli_flags & XFS_BLI_DIRTY);
 866 }
 867
 868 STATIC void
 869 xfs_buf_item_free(
 870         xfs_buf_log_item_t      *bip)
 871 {
 872 #ifdef XFS_TRANS_DEBUG
 873         kmem_free(bip->bli_orig);
 874         kmem_free(bip->bli_logged);
 875 #endif /* XFS_TRANS_DEBUG */
 876
 877         kmem_zone_free(xfs_buf_item_zone, bip);
 878 }
 879
 880 /*
 881  * This is called when the buf log item is no longer needed.  It should
 882  * free the buf log item associated with the given buffer and clear
 883  * the buffer's pointer to the buf log item.  If there are no more
 884  * items in the list, clear the b_iodone field of the buffer (see
 885  * xfs_buf_attach_iodone() below).
 886  */
 887 void
 888 xfs_buf_item_relse(
 889         xfs_buf_t       *bp)
 890 {
 891         xfs_buf_log_item_t      *bip;
 892
 893         trace_xfs_buf_item_relse(bp, _RET_IP_);
 894
 895         bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t*);
 896         XFS_BUF_SET_FSPRIVATE(bp, bip->bli_item.li_bio_list);
 897         if ((XFS_BUF_FSPRIVATE(bp, void *) == NULL) &&
 898             (XFS_BUF_IODONE_FUNC(bp) != NULL)) {
 899                 XFS_BUF_CLR_IODONE_FUNC(bp);
 900         }
 901         xfs_buf_rele(bp);
 902         xfs_buf_item_free(bip);
 903 }
 904
 905
 906 /*
 907  * Add the given log item with its callback to the list of callbacks
 908  * to be called when the buffer's I/O completes.  If it is not set
 909  * already, set the buffer's b_iodone() routine to be
 910  * xfs_buf_iodone_callbacks() and link the log item into the list of
 911  * items rooted at b_fsprivate.  Items are always added as the second
 912  * entry in the list if there is a first, because the buf item code
 913  * assumes that the buf log item is first.
 914  */
 915 void
 916 xfs_buf_attach_iodone(
 917         xfs_buf_t       *bp,
 918         void            (*cb)(xfs_buf_t *, xfs_log_item_t *),
 919         xfs_log_item_t  *lip)
 920 {
 921         xfs_log_item_t  *head_lip;
 922
 923         ASSERT(XFS_BUF_ISBUSY(bp));
 924         ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
 925
 926         lip->li_cb = cb;
 927         if (XFS_BUF_FSPRIVATE(bp, void *) != NULL) {
 928                 head_lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
 929                 lip->li_bio_list = head_lip->li_bio_list;
 930                 head_lip->li_bio_list = lip;
 931         } else {
 932                 XFS_BUF_SET_FSPRIVATE(bp, lip);
 933         }
 934
 935         ASSERT((XFS_BUF_IODONE_FUNC(bp) == xfs_buf_iodone_callbacks) ||
 936                (XFS_BUF_IODONE_FUNC(bp) == NULL));
 937         XFS_BUF_SET_IODONE_FUNC(bp, xfs_buf_iodone_callbacks);
 938 }
 939
 940 STATIC void
 941 xfs_buf_do_callbacks(
 942         xfs_buf_t       *bp,
 943         xfs_log_item_t  *lip)
 944 {
 945         xfs_log_item_t  *nlip;
 946
 947         while (lip != NULL) {
 948                 nlip = lip->li_bio_list;
 949                 ASSERT(lip->li_cb != NULL);
 950                 /*
 951                  * Clear the next pointer so we don't have any
 952                  * confusion if the item is added to another buf.
 953                  * Don't touch the log item after calling its
 954                  * callback, because it could have freed itself.
 955                  */
 956                 lip->li_bio_list = NULL;
 957                 lip->li_cb(bp, lip);
 958                 lip = nlip;
 959         }
 960 }
 961
 962 /*
 963  * This is the iodone() function for buffers which have had callbacks
 964  * attached to them by xfs_buf_attach_iodone().  It should remove each
 965  * log item from the buffer's list and call the callback of each in turn.
 966  * When done, the buffer's fsprivate field is set to NULL and the buffer
 967  * is unlocked with a call to iodone().
 968  */
 969 void
 970 xfs_buf_iodone_callbacks(
 971         xfs_buf_t       *bp)
 972 {
 973         xfs_log_item_t  *lip;
 974         static ulong    lasttime;
 975         static xfs_buftarg_t *lasttarg;
 976         xfs_mount_t     *mp;
 977
 978         ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
 979         lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
 980
 981         if (XFS_BUF_GETERROR(bp) != 0) {
 982                 /*
 983                  * If we've already decided to shutdown the filesystem
 984                  * because of IO errors, there's no point in giving this
 985                  * a retry.
 986                  */
 987                 mp = lip->li_mountp;
 988                 if (XFS_FORCED_SHUTDOWN(mp)) {
 989                         ASSERT(XFS_BUF_TARGET(bp) == mp->m_ddev_targp);
 990                         XFS_BUF_SUPER_STALE(bp);
 991                         trace_xfs_buf_item_iodone(bp, _RET_IP_);
 992                         xfs_buf_do_callbacks(bp, lip);
 993                         XFS_BUF_SET_FSPRIVATE(bp, NULL);
 994                         XFS_BUF_CLR_IODONE_FUNC(bp);
 995                         xfs_biodone(bp);
 996                         return;
 997                 }
 998
 999                 if ((XFS_BUF_TARGET(bp) != lasttarg) ||
1000                     (time_after(jiffies, (lasttime + 5*HZ)))) {
1001                         lasttime = jiffies;
1002                         cmn_err(CE_ALERT, "Device %s, XFS metadata write error"
1003                                         " block 0x%llx in %s",
1004                                 XFS_BUFTARG_NAME(XFS_BUF_TARGET(bp)),
1005                               (__uint64_t)XFS_BUF_ADDR(bp), mp->m_fsname);
1006                 }
1007                 lasttarg = XFS_BUF_TARGET(bp);
1008
1009                 if (XFS_BUF_ISASYNC(bp)) {
1010                         /*
1011                          * If the write was asynchronous then noone will be
1012                          * looking for the error.  Clear the error state
1013                          * and write the buffer out again delayed write.
1014                          *
1015                          * XXXsup This is OK, so long as we catch these
1016                          * before we start the umount; we don't want these
1017                          * DELWRI metadata bufs to be hanging around.
1018                          */
1019                         XFS_BUF_ERROR(bp,0); /* errno of 0 unsets the flag */
1020
1021                         if (!(XFS_BUF_ISSTALE(bp))) {
1022                                 XFS_BUF_DELAYWRITE(bp);
1023                                 XFS_BUF_DONE(bp);
1024                                 XFS_BUF_SET_START(bp);
1025                         }
1026                         ASSERT(XFS_BUF_IODONE_FUNC(bp));
1027                         trace_xfs_buf_item_iodone_async(bp, _RET_IP_);
1028                         xfs_buf_relse(bp);
1029                 } else {
1030                         /*
1031                          * If the write of the buffer was not asynchronous,
1032                          * then we want to make sure to return the error
1033                          * to the caller of bwrite().  Because of this we
1034                          * cannot clear the B_ERROR state at this point.
1035                          * Instead we install a callback function that
1036                          * will be called when the buffer is released, and
1037                          * that routine will clear the error state and
1038                          * set the buffer to be written out again after
1039                          * some delay.
1040                          */
1041                         /* We actually overwrite the existing b-relse
1042                            function at times, but we're gonna be shutting down
1043                            anyway. */
1044                         XFS_BUF_SET_BRELSE_FUNC(bp,xfs_buf_error_relse);
1045                         XFS_BUF_DONE(bp);
1046                         XFS_BUF_FINISH_IOWAIT(bp);
1047                 }
1048                 return;
1049         }
1050
1051         xfs_buf_do_callbacks(bp, lip);
1052         XFS_BUF_SET_FSPRIVATE(bp, NULL);
1053         XFS_BUF_CLR_IODONE_FUNC(bp);
1054         xfs_biodone(bp);
1055 }
1056
1057 /*
1058  * This is a callback routine attached to a buffer which gets an error
1059  * when being written out synchronously.
1060  */
1061 STATIC void
1062 xfs_buf_error_relse(
1063         xfs_buf_t       *bp)
1064 {
1065         xfs_log_item_t  *lip;
1066         xfs_mount_t     *mp;
1067
1068         lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
1069         mp = (xfs_mount_t *)lip->li_mountp;
1070         ASSERT(XFS_BUF_TARGET(bp) == mp->m_ddev_targp);
1071
1072         XFS_BUF_STALE(bp);
1073         XFS_BUF_DONE(bp);
1074         XFS_BUF_UNDELAYWRITE(bp);
1075         XFS_BUF_ERROR(bp,0);
1076
1077         trace_xfs_buf_error_relse(bp, _RET_IP_);
1078
1079         if (! XFS_FORCED_SHUTDOWN(mp))
1080                 xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1081         /*
1082          * We have to unpin the pinned buffers so do the
1083          * callbacks.
1084          */
1085         xfs_buf_do_callbacks(bp, lip);
1086         XFS_BUF_SET_FSPRIVATE(bp, NULL);
1087         XFS_BUF_CLR_IODONE_FUNC(bp);
1088         XFS_BUF_SET_BRELSE_FUNC(bp,NULL);
1089         xfs_buf_relse(bp);
1090 }
1091
1092
1093 /*
1094  * This is the iodone() function for buffers which have been
1095  * logged.  It is called when they are eventually flushed out.
1096  * It should remove the buf item from the AIL, and free the buf item.
1097  * It is called by xfs_buf_iodone_callbacks() above which will take
1098  * care of cleaning up the buffer itself.
1099  */
1100 /* ARGSUSED */
1101 void
1102 xfs_buf_iodone(
1103         xfs_buf_t               *bp,
1104         xfs_buf_log_item_t      *bip)
1105 {
1106         struct xfs_ail          *ailp = bip->bli_item.li_ailp;
1107
1108         ASSERT(bip->bli_buf == bp);
1109
1110         xfs_buf_rele(bp);
1111
1112         /*
1113          * If we are forcibly shutting down, this may well be
1114          * off the AIL already. That's because we simulate the
1115          * log-committed callbacks to unpin these buffers. Or we may never
1116          * have put this item on AIL because of the transaction was
1117          * aborted forcibly. xfs_trans_ail_delete() takes care of these.
1118          *
1119          * Either way, AIL is useless if we're forcing a shutdown.
1120          */
1121         spin_lock(&ailp->xa_lock);
1122         xfs_trans_ail_delete(ailp, (xfs_log_item_t *)bip);
1123         xfs_buf_item_free(bip);
1124 }