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         vecp->i_type = 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                         vecp->i_type = 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                         vecp->i_type = 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                         vecp->i_type = 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 {
 377         struct xfs_ail  *ailp;
 378         xfs_buf_t       *bp;
 379         int             freed;
 380         int             stale = bip->bli_flags & XFS_BLI_STALE;
 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         /* will xfs_buf_item_unpin() call xfs_buf_item_relse()? */
 432         if ((atomic_read(&bip->bli_refcount) == 1) &&
 433             (bip->bli_flags & XFS_BLI_STALE)) {
 434                 /*
 435                  * yes -- We can safely do some work here and then call
 436                  * buf_item_unpin to do the rest because we are
 437                  * are holding the buffer locked so no one else will be
 438                  * able to bump up the refcount. We have to remove the
 439                  * log item from the transaction as we are about to release
 440                  * our reference to the buffer. If we don't, the unlock that
 441                  * occurs later in the xfs_trans_uncommit() will try to
 442                  * reference the buffer which we no longer have a hold on.
 443                  */
 444                 struct xfs_log_item_desc *lidp;
 445
 446                 ASSERT(XFS_BUF_VALUSEMA(bip->bli_buf) <= 0);
 447                 trace_xfs_buf_item_unpin_stale(bip);
 448
 449                 lidp = xfs_trans_find_item(tp, (xfs_log_item_t *)bip);
 450                 xfs_trans_free_item(tp, lidp);
 451
 452                 /*
 453                  * Since the transaction no longer refers to the buffer, the
 454                  * buffer should no longer refer to the transaction.
 455                  */
 456                 XFS_BUF_SET_FSPRIVATE2(bip->bli_buf, NULL);
 457         }
 458         xfs_buf_item_unpin(bip);
 459 }
 460
 461 /*
 462  * This is called to attempt to lock the buffer associated with this
 463  * buf log item.  Don't sleep on the buffer lock.  If we can't get
 464  * the lock right away, return 0.  If we can get the lock, take a
 465  * reference to the buffer. If this is a delayed write buffer that
 466  * needs AIL help to be written back, invoke the pushbuf routine
 467  * rather than the normal success path.
 468  */
 469 STATIC uint
 470 xfs_buf_item_trylock(
 471         xfs_buf_log_item_t      *bip)
 472 {
 473         xfs_buf_t       *bp;
 474
 475         bp = bip->bli_buf;
 476         if (XFS_BUF_ISPINNED(bp))
 477                 return XFS_ITEM_PINNED;
 478         if (!XFS_BUF_CPSEMA(bp))
 479                 return XFS_ITEM_LOCKED;
 480
 481         /* take a reference to the buffer.  */
 482         XFS_BUF_HOLD(bp);
 483
 484         ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
 485         trace_xfs_buf_item_trylock(bip);
 486         if (XFS_BUF_ISDELAYWRITE(bp))
 487                 return XFS_ITEM_PUSHBUF;
 488         return XFS_ITEM_SUCCESS;
 489 }
 490
 491 /*
 492  * Release the buffer associated with the buf log item.
 493  * If there is no dirty logged data associated with the
 494  * buffer recorded in the buf log item, then free the
 495  * buf log item and remove the reference to it in the
 496  * buffer.
 497  *
 498  * This call ignores the recursion count.  It is only called
 499  * when the buffer should REALLY be unlocked, regardless
 500  * of the recursion count.
 501  *
 502  * If the XFS_BLI_HOLD flag is set in the buf log item, then
 503  * free the log item if necessary but do not unlock the buffer.
 504  * This is for support of xfs_trans_bhold(). Make sure the
 505  * XFS_BLI_HOLD field is cleared if we don't free the item.
 506  */
 507 STATIC void
 508 xfs_buf_item_unlock(
 509         xfs_buf_log_item_t      *bip)
 510 {
 511         int             aborted;
 512         xfs_buf_t       *bp;
 513         uint            hold;
 514
 515         bp = bip->bli_buf;
 516
 517         /*
 518          * Clear the buffer's association with this transaction.
 519          */
 520         XFS_BUF_SET_FSPRIVATE2(bp, NULL);
 521
 522         /*
 523          * If this is a transaction abort, don't return early.
 524          * Instead, allow the brelse to happen.
 525          * Normally it would be done for stale (cancelled) buffers
 526          * at unpin time, but we'll never go through the pin/unpin
 527          * cycle if we abort inside commit.
 528          */
 529         aborted = (bip->bli_item.li_flags & XFS_LI_ABORTED) != 0;
 530
 531         /*
 532          * If the buf item is marked stale, then don't do anything.
 533          * We'll unlock the buffer and free the buf item when the
 534          * buffer is unpinned for the last time.
 535          */
 536         if (bip->bli_flags & XFS_BLI_STALE) {
 537                 bip->bli_flags &= ~XFS_BLI_LOGGED;
 538                 trace_xfs_buf_item_unlock_stale(bip);
 539                 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
 540                 if (!aborted)
 541                         return;
 542         }
 543
 544         /*
 545          * Drop the transaction's reference to the log item if
 546          * it was not logged as part of the transaction.  Otherwise
 547          * we'll drop the reference in xfs_buf_item_unpin() when
 548          * the transaction is really through with the buffer.
 549          */
 550         if (!(bip->bli_flags & XFS_BLI_LOGGED)) {
 551                 atomic_dec(&bip->bli_refcount);
 552         } else {
 553                 /*
 554                  * Clear the logged flag since this is per
 555                  * transaction state.
 556                  */
 557                 bip->bli_flags &= ~XFS_BLI_LOGGED;
 558         }
 559
 560         /*
 561          * Before possibly freeing the buf item, determine if we should
 562          * release the buffer at the end of this routine.
 563          */
 564         hold = bip->bli_flags & XFS_BLI_HOLD;
 565         trace_xfs_buf_item_unlock(bip);
 566
 567         /*
 568          * If the buf item isn't tracking any data, free it.
 569          * Otherwise, if XFS_BLI_HOLD is set clear it.
 570          */
 571         if (xfs_bitmap_empty(bip->bli_format.blf_data_map,
 572                              bip->bli_format.blf_map_size)) {
 573                 xfs_buf_item_relse(bp);
 574         } else if (hold) {
 575                 bip->bli_flags &= ~XFS_BLI_HOLD;
 576         }
 577
 578         /*
 579          * Release the buffer if XFS_BLI_HOLD was not set.
 580          */
 581         if (!hold) {
 582                 xfs_buf_relse(bp);
 583         }
 584 }
 585
 586 /*
 587  * This is called to find out where the oldest active copy of the
 588  * buf log item in the on disk log resides now that the last log
 589  * write of it completed at the given lsn.
 590  * We always re-log all the dirty data in a buffer, so usually the
 591  * latest copy in the on disk log is the only one that matters.  For
 592  * those cases we simply return the given lsn.
 593  *
 594  * The one exception to this is for buffers full of newly allocated
 595  * inodes.  These buffers are only relogged with the XFS_BLI_INODE_BUF
 596  * flag set, indicating that only the di_next_unlinked fields from the
 597  * inodes in the buffers will be replayed during recovery.  If the
 598  * original newly allocated inode images have not yet been flushed
 599  * when the buffer is so relogged, then we need to make sure that we
 600  * keep the old images in the 'active' portion of the log.  We do this
 601  * by returning the original lsn of that transaction here rather than
 602  * the current one.
 603  */
 604 STATIC xfs_lsn_t
 605 xfs_buf_item_committed(
 606         xfs_buf_log_item_t      *bip,
 607         xfs_lsn_t               lsn)
 608 {
 609         trace_xfs_buf_item_committed(bip);
 610
 611         if ((bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF) &&
 612             (bip->bli_item.li_lsn != 0)) {
 613                 return bip->bli_item.li_lsn;
 614         }
 615         return (lsn);
 616 }
 617
 618 /*
 619  * The buffer is locked, but is not a delayed write buffer. This happens
 620  * if we race with IO completion and hence we don't want to try to write it
 621  * again. Just release the buffer.
 622  */
 623 STATIC void
 624 xfs_buf_item_push(
 625         xfs_buf_log_item_t      *bip)
 626 {
 627         xfs_buf_t       *bp;
 628
 629         ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
 630         trace_xfs_buf_item_push(bip);
 631
 632         bp = bip->bli_buf;
 633         ASSERT(!XFS_BUF_ISDELAYWRITE(bp));
 634         xfs_buf_relse(bp);
 635 }
 636
 637 /*
 638  * The buffer is locked and is a delayed write buffer. Promote the buffer
 639  * in the delayed write queue as the caller knows that they must invoke
 640  * the xfsbufd to get this buffer written. We have to unlock the buffer
 641  * to allow the xfsbufd to write it, too.
 642  */
 643 STATIC void
 644 xfs_buf_item_pushbuf(
 645         xfs_buf_log_item_t      *bip)
 646 {
 647         xfs_buf_t       *bp;
 648
 649         ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
 650         trace_xfs_buf_item_pushbuf(bip);
 651
 652         bp = bip->bli_buf;
 653         ASSERT(XFS_BUF_ISDELAYWRITE(bp));
 654         xfs_buf_delwri_promote(bp);
 655         xfs_buf_relse(bp);
 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*))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    = (void(*)(xfs_log_item_t*))xfs_buf_item_pushbuf,
 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         xfs_log_item_init(mp, &bip->bli_item, XFS_LI_BUF, &xfs_buf_item_ops);
 731         bip->bli_buf = bp;
 732         xfs_buf_hold(bp);
 733         bip->bli_format.blf_type = XFS_LI_BUF;
 734         bip->bli_format.blf_blkno = (__int64_t)XFS_BUF_ADDR(bp);
 735         bip->bli_format.blf_len = (ushort)BTOBB(XFS_BUF_COUNT(bp));
 736         bip->bli_format.blf_map_size = map_size;
 737
 738 #ifdef XFS_TRANS_DEBUG
 739         /*
 740          * Allocate the arrays for tracking what needs to be logged
 741          * and what our callers request to be logged.  bli_orig
 742          * holds a copy of the original, clean buffer for comparison
 743          * against, and bli_logged keeps a 1 bit flag per byte in
 744          * the buffer to indicate which bytes the callers have asked
 745          * to have logged.
 746          */
 747         bip->bli_orig = (char *)kmem_alloc(XFS_BUF_COUNT(bp), KM_SLEEP);
 748         memcpy(bip->bli_orig, XFS_BUF_PTR(bp), XFS_BUF_COUNT(bp));
 749         bip->bli_logged = (char *)kmem_zalloc(XFS_BUF_COUNT(bp) / NBBY, KM_SLEEP);
 750 #endif
 751
 752         /*
 753          * Put the buf item into the list of items attached to the
 754          * buffer at the front.
 755          */
 756         if (XFS_BUF_FSPRIVATE(bp, void *) != NULL) {
 757                 bip->bli_item.li_bio_list =
 758                                 XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
 759         }
 760         XFS_BUF_SET_FSPRIVATE(bp, bip);
 761 }
 762
 763
 764 /*
 765  * Mark bytes first through last inclusive as dirty in the buf
 766  * item's bitmap.
 767  */
 768 void
 769 xfs_buf_item_log(
 770         xfs_buf_log_item_t      *bip,
 771         uint                    first,
 772         uint                    last)
 773 {
 774         uint            first_bit;
 775         uint            last_bit;
 776         uint            bits_to_set;
 777         uint            bits_set;
 778         uint            word_num;
 779         uint            *wordp;
 780         uint            bit;
 781         uint            end_bit;
 782         uint            mask;
 783
 784         /*
 785          * Mark the item as having some dirty data for
 786          * quick reference in xfs_buf_item_dirty.
 787          */
 788         bip->bli_flags |= XFS_BLI_DIRTY;
 789
 790         /*
 791          * Convert byte offsets to bit numbers.
 792          */
 793         first_bit = first >> XFS_BLI_SHIFT;
 794         last_bit = last >> XFS_BLI_SHIFT;
 795
 796         /*
 797          * Calculate the total number of bits to be set.
 798          */
 799         bits_to_set = last_bit - first_bit + 1;
 800
 801         /*
 802          * Get a pointer to the first word in the bitmap
 803          * to set a bit in.
 804          */
 805         word_num = first_bit >> BIT_TO_WORD_SHIFT;
 806         wordp = &(bip->bli_format.blf_data_map[word_num]);
 807
 808         /*
 809          * Calculate the starting bit in the first word.
 810          */
 811         bit = first_bit & (uint)(NBWORD - 1);
 812
 813         /*
 814          * First set any bits in the first word of our range.
 815          * If it starts at bit 0 of the word, it will be
 816          * set below rather than here.  That is what the variable
 817          * bit tells us. The variable bits_set tracks the number
 818          * of bits that have been set so far.  End_bit is the number
 819          * of the last bit to be set in this word plus one.
 820          */
 821         if (bit) {
 822                 end_bit = MIN(bit + bits_to_set, (uint)NBWORD);
 823                 mask = ((1 << (end_bit - bit)) - 1) << bit;
 824                 *wordp |= mask;
 825                 wordp++;
 826                 bits_set = end_bit - bit;
 827         } else {
 828                 bits_set = 0;
 829         }
 830
 831         /*
 832          * Now set bits a whole word at a time that are between
 833          * first_bit and last_bit.
 834          */
 835         while ((bits_to_set - bits_set) >= NBWORD) {
 836                 *wordp |= 0xffffffff;
 837                 bits_set += NBWORD;
 838                 wordp++;
 839         }
 840
 841         /*
 842          * Finally, set any bits left to be set in one last partial word.
 843          */
 844         end_bit = bits_to_set - bits_set;
 845         if (end_bit) {
 846                 mask = (1 << end_bit) - 1;
 847                 *wordp |= mask;
 848         }
 849
 850         xfs_buf_item_log_debug(bip, first, last);
 851 }
 852
 853
 854 /*
 855  * Return 1 if the buffer has some data that has been logged (at any
 856  * point, not just the current transaction) and 0 if not.
 857  */
 858 uint
 859 xfs_buf_item_dirty(
 860         xfs_buf_log_item_t      *bip)
 861 {
 862         return (bip->bli_flags & XFS_BLI_DIRTY);
 863 }
 864
 865 STATIC void
 866 xfs_buf_item_free(
 867         xfs_buf_log_item_t      *bip)
 868 {
 869 #ifdef XFS_TRANS_DEBUG
 870         kmem_free(bip->bli_orig);
 871         kmem_free(bip->bli_logged);
 872 #endif /* XFS_TRANS_DEBUG */
 873
 874         kmem_zone_free(xfs_buf_item_zone, bip);
 875 }
 876
 877 /*
 878  * This is called when the buf log item is no longer needed.  It should
 879  * free the buf log item associated with the given buffer and clear
 880  * the buffer's pointer to the buf log item.  If there are no more
 881  * items in the list, clear the b_iodone field of the buffer (see
 882  * xfs_buf_attach_iodone() below).
 883  */
 884 void
 885 xfs_buf_item_relse(
 886         xfs_buf_t       *bp)
 887 {
 888         xfs_buf_log_item_t      *bip;
 889
 890         trace_xfs_buf_item_relse(bp, _RET_IP_);
 891
 892         bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t*);
 893         XFS_BUF_SET_FSPRIVATE(bp, bip->bli_item.li_bio_list);
 894         if ((XFS_BUF_FSPRIVATE(bp, void *) == NULL) &&
 895             (XFS_BUF_IODONE_FUNC(bp) != NULL)) {
 896                 XFS_BUF_CLR_IODONE_FUNC(bp);
 897         }
 898         xfs_buf_rele(bp);
 899         xfs_buf_item_free(bip);
 900 }
 901
 902
 903 /*
 904  * Add the given log item with its callback to the list of callbacks
 905  * to be called when the buffer's I/O completes.  If it is not set
 906  * already, set the buffer's b_iodone() routine to be
 907  * xfs_buf_iodone_callbacks() and link the log item into the list of
 908  * items rooted at b_fsprivate.  Items are always added as the second
 909  * entry in the list if there is a first, because the buf item code
 910  * assumes that the buf log item is first.
 911  */
 912 void
 913 xfs_buf_attach_iodone(
 914         xfs_buf_t       *bp,
 915         void            (*cb)(xfs_buf_t *, xfs_log_item_t *),
 916         xfs_log_item_t  *lip)
 917 {
 918         xfs_log_item_t  *head_lip;
 919
 920         ASSERT(XFS_BUF_ISBUSY(bp));
 921         ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
 922
 923         lip->li_cb = cb;
 924         if (XFS_BUF_FSPRIVATE(bp, void *) != NULL) {
 925                 head_lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
 926                 lip->li_bio_list = head_lip->li_bio_list;
 927                 head_lip->li_bio_list = lip;
 928         } else {
 929                 XFS_BUF_SET_FSPRIVATE(bp, lip);
 930         }
 931
 932         ASSERT((XFS_BUF_IODONE_FUNC(bp) == xfs_buf_iodone_callbacks) ||
 933                (XFS_BUF_IODONE_FUNC(bp) == NULL));
 934         XFS_BUF_SET_IODONE_FUNC(bp, xfs_buf_iodone_callbacks);
 935 }
 936
 937 STATIC void
 938 xfs_buf_do_callbacks(
 939         xfs_buf_t       *bp,
 940         xfs_log_item_t  *lip)
 941 {
 942         xfs_log_item_t  *nlip;
 943
 944         while (lip != NULL) {
 945                 nlip = lip->li_bio_list;
 946                 ASSERT(lip->li_cb != NULL);
 947                 /*
 948                  * Clear the next pointer so we don't have any
 949                  * confusion if the item is added to another buf.
 950                  * Don't touch the log item after calling its
 951                  * callback, because it could have freed itself.
 952                  */
 953                 lip->li_bio_list = NULL;
 954                 lip->li_cb(bp, lip);
 955                 lip = nlip;
 956         }
 957 }
 958
 959 /*
 960  * This is the iodone() function for buffers which have had callbacks
 961  * attached to them by xfs_buf_attach_iodone().  It should remove each
 962  * log item from the buffer's list and call the callback of each in turn.
 963  * When done, the buffer's fsprivate field is set to NULL and the buffer
 964  * is unlocked with a call to iodone().
 965  */
 966 void
 967 xfs_buf_iodone_callbacks(
 968         xfs_buf_t       *bp)
 969 {
 970         xfs_log_item_t  *lip;
 971         static ulong    lasttime;
 972         static xfs_buftarg_t *lasttarg;
 973         xfs_mount_t     *mp;
 974
 975         ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
 976         lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
 977
 978         if (XFS_BUF_GETERROR(bp) != 0) {
 979                 /*
 980                  * If we've already decided to shutdown the filesystem
 981                  * because of IO errors, there's no point in giving this
 982                  * a retry.
 983                  */
 984                 mp = lip->li_mountp;
 985                 if (XFS_FORCED_SHUTDOWN(mp)) {
 986                         ASSERT(XFS_BUF_TARGET(bp) == mp->m_ddev_targp);
 987                         XFS_BUF_SUPER_STALE(bp);
 988                         trace_xfs_buf_item_iodone(bp, _RET_IP_);
 989                         xfs_buf_do_callbacks(bp, lip);
 990                         XFS_BUF_SET_FSPRIVATE(bp, NULL);
 991                         XFS_BUF_CLR_IODONE_FUNC(bp);
 992                         xfs_biodone(bp);
 993                         return;
 994                 }
 995
 996                 if ((XFS_BUF_TARGET(bp) != lasttarg) ||
 997                     (time_after(jiffies, (lasttime + 5*HZ)))) {
 998                         lasttime = jiffies;
 999                         cmn_err(CE_ALERT, "Device %s, XFS metadata write error"
1000                                         " block 0x%llx in %s",
1001                                 XFS_BUFTARG_NAME(XFS_BUF_TARGET(bp)),
1002                               (__uint64_t)XFS_BUF_ADDR(bp), mp->m_fsname);
1003                 }
1004                 lasttarg = XFS_BUF_TARGET(bp);
1005
1006                 if (XFS_BUF_ISASYNC(bp)) {
1007                         /*
1008                          * If the write was asynchronous then noone will be
1009                          * looking for the error.  Clear the error state
1010                          * and write the buffer out again delayed write.
1011                          *
1012                          * XXXsup This is OK, so long as we catch these
1013                          * before we start the umount; we don't want these
1014                          * DELWRI metadata bufs to be hanging around.
1015                          */
1016                         XFS_BUF_ERROR(bp,0); /* errno of 0 unsets the flag */
1017
1018                         if (!(XFS_BUF_ISSTALE(bp))) {
1019                                 XFS_BUF_DELAYWRITE(bp);
1020                                 XFS_BUF_DONE(bp);
1021                                 XFS_BUF_SET_START(bp);
1022                         }
1023                         ASSERT(XFS_BUF_IODONE_FUNC(bp));
1024                         trace_xfs_buf_item_iodone_async(bp, _RET_IP_);
1025                         xfs_buf_relse(bp);
1026                 } else {
1027                         /*
1028                          * If the write of the buffer was not asynchronous,
1029                          * then we want to make sure to return the error
1030                          * to the caller of bwrite().  Because of this we
1031                          * cannot clear the B_ERROR state at this point.
1032                          * Instead we install a callback function that
1033                          * will be called when the buffer is released, and
1034                          * that routine will clear the error state and
1035                          * set the buffer to be written out again after
1036                          * some delay.
1037                          */
1038                         /* We actually overwrite the existing b-relse
1039                            function at times, but we're gonna be shutting down
1040                            anyway. */
1041                         XFS_BUF_SET_BRELSE_FUNC(bp,xfs_buf_error_relse);
1042                         XFS_BUF_DONE(bp);
1043                         XFS_BUF_FINISH_IOWAIT(bp);
1044                 }
1045                 return;
1046         }
1047
1048         xfs_buf_do_callbacks(bp, lip);
1049         XFS_BUF_SET_FSPRIVATE(bp, NULL);
1050         XFS_BUF_CLR_IODONE_FUNC(bp);
1051         xfs_biodone(bp);
1052 }
1053
1054 /*
1055  * This is a callback routine attached to a buffer which gets an error
1056  * when being written out synchronously.
1057  */
1058 STATIC void
1059 xfs_buf_error_relse(
1060         xfs_buf_t       *bp)
1061 {
1062         xfs_log_item_t  *lip;
1063         xfs_mount_t     *mp;
1064
1065         lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
1066         mp = (xfs_mount_t *)lip->li_mountp;
1067         ASSERT(XFS_BUF_TARGET(bp) == mp->m_ddev_targp);
1068
1069         XFS_BUF_STALE(bp);
1070         XFS_BUF_DONE(bp);
1071         XFS_BUF_UNDELAYWRITE(bp);
1072         XFS_BUF_ERROR(bp,0);
1073
1074         trace_xfs_buf_error_relse(bp, _RET_IP_);
1075
1076         if (! XFS_FORCED_SHUTDOWN(mp))
1077                 xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
1078         /*
1079          * We have to unpin the pinned buffers so do the
1080          * callbacks.
1081          */
1082         xfs_buf_do_callbacks(bp, lip);
1083         XFS_BUF_SET_FSPRIVATE(bp, NULL);
1084         XFS_BUF_CLR_IODONE_FUNC(bp);
1085         XFS_BUF_SET_BRELSE_FUNC(bp,NULL);
1086         xfs_buf_relse(bp);
1087 }
1088
1089
1090 /*
1091  * This is the iodone() function for buffers which have been
1092  * logged.  It is called when they are eventually flushed out.
1093  * It should remove the buf item from the AIL, and free the buf item.
1094  * It is called by xfs_buf_iodone_callbacks() above which will take
1095  * care of cleaning up the buffer itself.
1096  */
1097 /* ARGSUSED */
1098 void
1099 xfs_buf_iodone(
1100         xfs_buf_t               *bp,
1101         xfs_buf_log_item_t      *bip)
1102 {
1103         struct xfs_ail          *ailp = bip->bli_item.li_ailp;
1104
1105         ASSERT(bip->bli_buf == bp);
1106
1107         xfs_buf_rele(bp);
1108
1109         /*
1110          * If we are forcibly shutting down, this may well be
1111          * off the AIL already. That's because we simulate the
1112          * log-committed callbacks to unpin these buffers. Or we may never
1113          * have put this item on AIL because of the transaction was
1114          * aborted forcibly. xfs_trans_ail_delete() takes care of these.
1115          *
1116          * Either way, AIL is useless if we're forcing a shutdown.
1117          */
1118         spin_lock(&ailp->xa_lock);
1119         xfs_trans_ail_delete(ailp, (xfs_log_item_t *)bip);
1120         xfs_buf_item_free(bip);
1121 }