fs/xfs/xfs_log_recover.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_log_format.h"
  11 #include "xfs_trans_resv.h"
  12 #include "xfs_bit.h"
  13 #include "xfs_sb.h"
  14 #include "xfs_mount.h"
  15 #include "xfs_defer.h"
  16 #include "xfs_da_format.h"
  17 #include "xfs_da_btree.h"
  18 #include "xfs_inode.h"
  19 #include "xfs_trans.h"
  20 #include "xfs_log.h"
  21 #include "xfs_log_priv.h"
  22 #include "xfs_log_recover.h"
  23 #include "xfs_inode_item.h"
  24 #include "xfs_extfree_item.h"
  25 #include "xfs_trans_priv.h"
  26 #include "xfs_alloc.h"
  27 #include "xfs_ialloc.h"
  28 #include "xfs_quota.h"
  29 #include "xfs_cksum.h"
  30 #include "xfs_trace.h"
  31 #include "xfs_icache.h"
  32 #include "xfs_bmap_btree.h"
  33 #include "xfs_error.h"
  34 #include "xfs_dir2.h"
  35 #include "xfs_rmap_item.h"
  36 #include "xfs_buf_item.h"
  37 #include "xfs_refcount_item.h"
  38 #include "xfs_bmap_item.h"
  39
  40 #define BLK_AVG(blk1, blk2)     ((blk1+blk2) >> 1)
  41
  42 STATIC int
  43 xlog_find_zeroed(
  44         struct xlog     *,
  45         xfs_daddr_t     *);
  46 STATIC int
  47 xlog_clear_stale_blocks(
  48         struct xlog     *,
  49         xfs_lsn_t);
  50 #if defined(DEBUG)
  51 STATIC void
  52 xlog_recover_check_summary(
  53         struct xlog *);
  54 #else
  55 #define xlog_recover_check_summary(log)
  56 #endif
  57 STATIC int
  58 xlog_do_recovery_pass(
  59         struct xlog *, xfs_daddr_t, xfs_daddr_t, int, xfs_daddr_t *);
  60
  61 /*
  62  * This structure is used during recovery to record the buf log items which
  63  * have been canceled and should not be replayed.
  64  */
  65 struct xfs_buf_cancel {
  66         xfs_daddr_t             bc_blkno;
  67         uint                    bc_len;
  68         int                     bc_refcount;
  69         struct list_head        bc_list;
  70 };
  71
  72 /*
  73  * Sector aligned buffer routines for buffer create/read/write/access
  74  */
  75
  76 /*
  77  * Verify the log-relative block number and length in basic blocks are valid for
  78  * an operation involving the given XFS log buffer. Returns true if the fields
  79  * are valid, false otherwise.
  80  */
  81 static inline bool
  82 xlog_verify_bp(
  83         struct xlog     *log,
  84         xfs_daddr_t     blk_no,
  85         int             bbcount)
  86 {
  87         if (blk_no < 0 || blk_no >= log->l_logBBsize)
  88                 return false;
  89         if (bbcount <= 0 || (blk_no + bbcount) > log->l_logBBsize)
  90                 return false;
  91         return true;
  92 }
  93
  94 /*
  95  * Allocate a buffer to hold log data.  The buffer needs to be able
  96  * to map to a range of nbblks basic blocks at any valid (basic
  97  * block) offset within the log.
  98  */
  99 STATIC xfs_buf_t *
 100 xlog_get_bp(
 101         struct xlog     *log,
 102         int             nbblks)
 103 {
 104         struct xfs_buf  *bp;
 105
 106         /*
 107          * Pass log block 0 since we don't have an addr yet, buffer will be
 108          * verified on read.
 109          */
 110         if (!xlog_verify_bp(log, 0, nbblks)) {
 111                 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
 112                         nbblks);
 113                 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
 114                 return NULL;
 115         }
 116
 117         /*
 118          * We do log I/O in units of log sectors (a power-of-2
 119          * multiple of the basic block size), so we round up the
 120          * requested size to accommodate the basic blocks required
 121          * for complete log sectors.
 122          *
 123          * In addition, the buffer may be used for a non-sector-
 124          * aligned block offset, in which case an I/O of the
 125          * requested size could extend beyond the end of the
 126          * buffer.  If the requested size is only 1 basic block it
 127          * will never straddle a sector boundary, so this won't be
 128          * an issue.  Nor will this be a problem if the log I/O is
 129          * done in basic blocks (sector size 1).  But otherwise we
 130          * extend the buffer by one extra log sector to ensure
 131          * there's space to accommodate this possibility.
 132          */
 133         if (nbblks > 1 && log->l_sectBBsize > 1)
 134                 nbblks += log->l_sectBBsize;
 135         nbblks = round_up(nbblks, log->l_sectBBsize);
 136
 137         bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, nbblks, 0);
 138         if (bp)
 139                 xfs_buf_unlock(bp);
 140         return bp;
 141 }
 142
 143 STATIC void
 144 xlog_put_bp(
 145         xfs_buf_t       *bp)
 146 {
 147         xfs_buf_free(bp);
 148 }
 149
 150 /*
 151  * Return the address of the start of the given block number's data
 152  * in a log buffer.  The buffer covers a log sector-aligned region.
 153  */
 154 STATIC char *
 155 xlog_align(
 156         struct xlog     *log,
 157         xfs_daddr_t     blk_no,
 158         int             nbblks,
 159         struct xfs_buf  *bp)
 160 {
 161         xfs_daddr_t     offset = blk_no & ((xfs_daddr_t)log->l_sectBBsize - 1);
 162
 163         ASSERT(offset + nbblks <= bp->b_length);
 164         return bp->b_addr + BBTOB(offset);
 165 }
 166
 167
 168 /*
 169  * nbblks should be uint, but oh well.  Just want to catch that 32-bit length.
 170  */
 171 STATIC int
 172 xlog_bread_noalign(
 173         struct xlog     *log,
 174         xfs_daddr_t     blk_no,
 175         int             nbblks,
 176         struct xfs_buf  *bp)
 177 {
 178         int             error;
 179
 180         if (!xlog_verify_bp(log, blk_no, nbblks)) {
 181                 xfs_warn(log->l_mp,
 182                          "Invalid log block/length (0x%llx, 0x%x) for buffer",
 183                          blk_no, nbblks);
 184                 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
 185                 return -EFSCORRUPTED;
 186         }
 187
 188         blk_no = round_down(blk_no, log->l_sectBBsize);
 189         nbblks = round_up(nbblks, log->l_sectBBsize);
 190
 191         ASSERT(nbblks > 0);
 192         ASSERT(nbblks <= bp->b_length);
 193
 194         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
 195         bp->b_flags |= XBF_READ;
 196         bp->b_io_length = nbblks;
 197         bp->b_error = 0;
 198
 199         error = xfs_buf_submit(bp);
 200         if (error && !XFS_FORCED_SHUTDOWN(log->l_mp))
 201                 xfs_buf_ioerror_alert(bp, __func__);
 202         return error;
 203 }
 204
 205 STATIC int
 206 xlog_bread(
 207         struct xlog     *log,
 208         xfs_daddr_t     blk_no,
 209         int             nbblks,
 210         struct xfs_buf  *bp,
 211         char            **offset)
 212 {
 213         int             error;
 214
 215         error = xlog_bread_noalign(log, blk_no, nbblks, bp);
 216         if (error)
 217                 return error;
 218
 219         *offset = xlog_align(log, blk_no, nbblks, bp);
 220         return 0;
 221 }
 222
 223 /*
 224  * Read at an offset into the buffer. Returns with the buffer in it's original
 225  * state regardless of the result of the read.
 226  */
 227 STATIC int
 228 xlog_bread_offset(
 229         struct xlog     *log,
 230         xfs_daddr_t     blk_no,         /* block to read from */
 231         int             nbblks,         /* blocks to read */
 232         struct xfs_buf  *bp,
 233         char            *offset)
 234 {
 235         char            *orig_offset = bp->b_addr;
 236         int             orig_len = BBTOB(bp->b_length);
 237         int             error, error2;
 238
 239         error = xfs_buf_associate_memory(bp, offset, BBTOB(nbblks));
 240         if (error)
 241                 return error;
 242
 243         error = xlog_bread_noalign(log, blk_no, nbblks, bp);
 244
 245         /* must reset buffer pointer even on error */
 246         error2 = xfs_buf_associate_memory(bp, orig_offset, orig_len);
 247         if (error)
 248                 return error;
 249         return error2;
 250 }
 251
 252 /*
 253  * Write out the buffer at the given block for the given number of blocks.
 254  * The buffer is kept locked across the write and is returned locked.
 255  * This can only be used for synchronous log writes.
 256  */
 257 STATIC int
 258 xlog_bwrite(
 259         struct xlog     *log,
 260         xfs_daddr_t     blk_no,
 261         int             nbblks,
 262         struct xfs_buf  *bp)
 263 {
 264         int             error;
 265
 266         if (!xlog_verify_bp(log, blk_no, nbblks)) {
 267                 xfs_warn(log->l_mp,
 268                          "Invalid log block/length (0x%llx, 0x%x) for buffer",
 269                          blk_no, nbblks);
 270                 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
 271                 return -EFSCORRUPTED;
 272         }
 273
 274         blk_no = round_down(blk_no, log->l_sectBBsize);
 275         nbblks = round_up(nbblks, log->l_sectBBsize);
 276
 277         ASSERT(nbblks > 0);
 278         ASSERT(nbblks <= bp->b_length);
 279
 280         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
 281         xfs_buf_hold(bp);
 282         xfs_buf_lock(bp);
 283         bp->b_io_length = nbblks;
 284         bp->b_error = 0;
 285
 286         error = xfs_bwrite(bp);
 287         if (error)
 288                 xfs_buf_ioerror_alert(bp, __func__);
 289         xfs_buf_relse(bp);
 290         return error;
 291 }
 292
 293 #ifdef DEBUG
 294 /*
 295  * dump debug superblock and log record information
 296  */
 297 STATIC void
 298 xlog_header_check_dump(
 299         xfs_mount_t             *mp,
 300         xlog_rec_header_t       *head)
 301 {
 302         xfs_debug(mp, "%s:  SB : uuid = %pU, fmt = %d",
 303                 __func__, &mp->m_sb.sb_uuid, XLOG_FMT);
 304         xfs_debug(mp, "    log : uuid = %pU, fmt = %d",
 305                 &head->h_fs_uuid, be32_to_cpu(head->h_fmt));
 306 }
 307 #else
 308 #define xlog_header_check_dump(mp, head)
 309 #endif
 310
 311 /*
 312  * check log record header for recovery
 313  */
 314 STATIC int
 315 xlog_header_check_recover(
 316         xfs_mount_t             *mp,
 317         xlog_rec_header_t       *head)
 318 {
 319         ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
 320
 321         /*
 322          * IRIX doesn't write the h_fmt field and leaves it zeroed
 323          * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
 324          * a dirty log created in IRIX.
 325          */
 326         if (unlikely(head->h_fmt != cpu_to_be32(XLOG_FMT))) {
 327                 xfs_warn(mp,
 328         "dirty log written in incompatible format - can't recover");
 329                 xlog_header_check_dump(mp, head);
 330                 XFS_ERROR_REPORT("xlog_header_check_recover(1)",
 331                                  XFS_ERRLEVEL_HIGH, mp);
 332                 return -EFSCORRUPTED;
 333         } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
 334                 xfs_warn(mp,
 335         "dirty log entry has mismatched uuid - can't recover");
 336                 xlog_header_check_dump(mp, head);
 337                 XFS_ERROR_REPORT("xlog_header_check_recover(2)",
 338                                  XFS_ERRLEVEL_HIGH, mp);
 339                 return -EFSCORRUPTED;
 340         }
 341         return 0;
 342 }
 343
 344 /*
 345  * read the head block of the log and check the header
 346  */
 347 STATIC int
 348 xlog_header_check_mount(
 349         xfs_mount_t             *mp,
 350         xlog_rec_header_t       *head)
 351 {
 352         ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
 353
 354         if (uuid_is_null(&head->h_fs_uuid)) {
 355                 /*
 356                  * IRIX doesn't write the h_fs_uuid or h_fmt fields. If
 357                  * h_fs_uuid is null, we assume this log was last mounted
 358                  * by IRIX and continue.
 359                  */
 360                 xfs_warn(mp, "null uuid in log - IRIX style log");
 361         } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
 362                 xfs_warn(mp, "log has mismatched uuid - can't recover");
 363                 xlog_header_check_dump(mp, head);
 364                 XFS_ERROR_REPORT("xlog_header_check_mount",
 365                                  XFS_ERRLEVEL_HIGH, mp);
 366                 return -EFSCORRUPTED;
 367         }
 368         return 0;
 369 }
 370
 371 STATIC void
 372 xlog_recover_iodone(
 373         struct xfs_buf  *bp)
 374 {
 375         if (bp->b_error) {
 376                 /*
 377                  * We're not going to bother about retrying
 378                  * this during recovery. One strike!
 379                  */
 380                 if (!XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
 381                         xfs_buf_ioerror_alert(bp, __func__);
 382                         xfs_force_shutdown(bp->b_target->bt_mount,
 383                                                 SHUTDOWN_META_IO_ERROR);
 384                 }
 385         }
 386
 387         /*
 388          * On v5 supers, a bli could be attached to update the metadata LSN.
 389          * Clean it up.
 390          */
 391         if (bp->b_log_item)
 392                 xfs_buf_item_relse(bp);
 393         ASSERT(bp->b_log_item == NULL);
 394
 395         bp->b_iodone = NULL;
 396         xfs_buf_ioend(bp);
 397 }
 398
 399 /*
 400  * This routine finds (to an approximation) the first block in the physical
 401  * log which contains the given cycle.  It uses a binary search algorithm.
 402  * Note that the algorithm can not be perfect because the disk will not
 403  * necessarily be perfect.
 404  */
 405 STATIC int
 406 xlog_find_cycle_start(
 407         struct xlog     *log,
 408         struct xfs_buf  *bp,
 409         xfs_daddr_t     first_blk,
 410         xfs_daddr_t     *last_blk,
 411         uint            cycle)
 412 {
 413         char            *offset;
 414         xfs_daddr_t     mid_blk;
 415         xfs_daddr_t     end_blk;
 416         uint            mid_cycle;
 417         int             error;
 418
 419         end_blk = *last_blk;
 420         mid_blk = BLK_AVG(first_blk, end_blk);
 421         while (mid_blk != first_blk && mid_blk != end_blk) {
 422                 error = xlog_bread(log, mid_blk, 1, bp, &offset);
 423                 if (error)
 424                         return error;
 425                 mid_cycle = xlog_get_cycle(offset);
 426                 if (mid_cycle == cycle)
 427                         end_blk = mid_blk;   /* last_half_cycle == mid_cycle */
 428                 else
 429                         first_blk = mid_blk; /* first_half_cycle == mid_cycle */
 430                 mid_blk = BLK_AVG(first_blk, end_blk);
 431         }
 432         ASSERT((mid_blk == first_blk && mid_blk+1 == end_blk) ||
 433                (mid_blk == end_blk && mid_blk-1 == first_blk));
 434
 435         *last_blk = end_blk;
 436
 437         return 0;
 438 }
 439
 440 /*
 441  * Check that a range of blocks does not contain stop_on_cycle_no.
 442  * Fill in *new_blk with the block offset where such a block is
 443  * found, or with -1 (an invalid block number) if there is no such
 444  * block in the range.  The scan needs to occur from front to back
 445  * and the pointer into the region must be updated since a later
 446  * routine will need to perform another test.
 447  */
 448 STATIC int
 449 xlog_find_verify_cycle(
 450         struct xlog     *log,
 451         xfs_daddr_t     start_blk,
 452         int             nbblks,
 453         uint            stop_on_cycle_no,
 454         xfs_daddr_t     *new_blk)
 455 {
 456         xfs_daddr_t     i, j;
 457         uint            cycle;
 458         xfs_buf_t       *bp;
 459         xfs_daddr_t     bufblks;
 460         char            *buf = NULL;
 461         int             error = 0;
 462
 463         /*
 464          * Greedily allocate a buffer big enough to handle the full
 465          * range of basic blocks we'll be examining.  If that fails,
 466          * try a smaller size.  We need to be able to read at least
 467          * a log sector, or we're out of luck.
 468          */
 469         bufblks = 1 << ffs(nbblks);
 470         while (bufblks > log->l_logBBsize)
 471                 bufblks >>= 1;
 472         while (!(bp = xlog_get_bp(log, bufblks))) {
 473                 bufblks >>= 1;
 474                 if (bufblks < log->l_sectBBsize)
 475                         return -ENOMEM;
 476         }
 477
 478         for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
 479                 int     bcount;
 480
 481                 bcount = min(bufblks, (start_blk + nbblks - i));
 482
 483                 error = xlog_bread(log, i, bcount, bp, &buf);
 484                 if (error)
 485                         goto out;
 486
 487                 for (j = 0; j < bcount; j++) {
 488                         cycle = xlog_get_cycle(buf);
 489                         if (cycle == stop_on_cycle_no) {
 490                                 *new_blk = i+j;
 491                                 goto out;
 492                         }
 493
 494                         buf += BBSIZE;
 495                 }
 496         }
 497
 498         *new_blk = -1;
 499
 500 out:
 501         xlog_put_bp(bp);
 502         return error;
 503 }
 504
 505 /*
 506  * Potentially backup over partial log record write.
 507  *
 508  * In the typical case, last_blk is the number of the block directly after
 509  * a good log record.  Therefore, we subtract one to get the block number
 510  * of the last block in the given buffer.  extra_bblks contains the number
 511  * of blocks we would have read on a previous read.  This happens when the
 512  * last log record is split over the end of the physical log.
 513  *
 514  * extra_bblks is the number of blocks potentially verified on a previous
 515  * call to this routine.
 516  */
 517 STATIC int
 518 xlog_find_verify_log_record(
 519         struct xlog             *log,
 520         xfs_daddr_t             start_blk,
 521         xfs_daddr_t             *last_blk,
 522         int                     extra_bblks)
 523 {
 524         xfs_daddr_t             i;
 525         xfs_buf_t               *bp;
 526         char                    *offset = NULL;
 527         xlog_rec_header_t       *head = NULL;
 528         int                     error = 0;
 529         int                     smallmem = 0;
 530         int                     num_blks = *last_blk - start_blk;
 531         int                     xhdrs;
 532
 533         ASSERT(start_blk != 0 || *last_blk != start_blk);
 534
 535         if (!(bp = xlog_get_bp(log, num_blks))) {
 536                 if (!(bp = xlog_get_bp(log, 1)))
 537                         return -ENOMEM;
 538                 smallmem = 1;
 539         } else {
 540                 error = xlog_bread(log, start_blk, num_blks, bp, &offset);
 541                 if (error)
 542                         goto out;
 543                 offset += ((num_blks - 1) << BBSHIFT);
 544         }
 545
 546         for (i = (*last_blk) - 1; i >= 0; i--) {
 547                 if (i < start_blk) {
 548                         /* valid log record not found */
 549                         xfs_warn(log->l_mp,
 550                 "Log inconsistent (didn't find previous header)");
 551                         ASSERT(0);
 552                         error = -EIO;
 553                         goto out;
 554                 }
 555
 556                 if (smallmem) {
 557                         error = xlog_bread(log, i, 1, bp, &offset);
 558                         if (error)
 559                                 goto out;
 560                 }
 561
 562                 head = (xlog_rec_header_t *)offset;
 563
 564                 if (head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
 565                         break;
 566
 567                 if (!smallmem)
 568                         offset -= BBSIZE;
 569         }
 570
 571         /*
 572          * We hit the beginning of the physical log & still no header.  Return
 573          * to caller.  If caller can handle a return of -1, then this routine
 574          * will be called again for the end of the physical log.
 575          */
 576         if (i == -1) {
 577                 error = 1;
 578                 goto out;
 579         }
 580
 581         /*
 582          * We have the final block of the good log (the first block
 583          * of the log record _before_ the head. So we check the uuid.
 584          */
 585         if ((error = xlog_header_check_mount(log->l_mp, head)))
 586                 goto out;
 587
 588         /*
 589          * We may have found a log record header before we expected one.
 590          * last_blk will be the 1st block # with a given cycle #.  We may end
 591          * up reading an entire log record.  In this case, we don't want to
 592          * reset last_blk.  Only when last_blk points in the middle of a log
 593          * record do we update last_blk.
 594          */
 595         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
 596                 uint    h_size = be32_to_cpu(head->h_size);
 597
 598                 xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
 599                 if (h_size % XLOG_HEADER_CYCLE_SIZE)
 600                         xhdrs++;
 601         } else {
 602                 xhdrs = 1;
 603         }
 604
 605         if (*last_blk - i + extra_bblks !=
 606             BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
 607                 *last_blk = i;
 608
 609 out:
 610         xlog_put_bp(bp);
 611         return error;
 612 }
 613
 614 /*
 615  * Head is defined to be the point of the log where the next log write
 616  * could go.  This means that incomplete LR writes at the end are
 617  * eliminated when calculating the head.  We aren't guaranteed that previous
 618  * LR have complete transactions.  We only know that a cycle number of
 619  * current cycle number -1 won't be present in the log if we start writing
 620  * from our current block number.
 621  *
 622  * last_blk contains the block number of the first block with a given
 623  * cycle number.
 624  *
 625  * Return: zero if normal, non-zero if error.
 626  */
 627 STATIC int
 628 xlog_find_head(
 629         struct xlog     *log,
 630         xfs_daddr_t     *return_head_blk)
 631 {
 632         xfs_buf_t       *bp;
 633         char            *offset;
 634         xfs_daddr_t     new_blk, first_blk, start_blk, last_blk, head_blk;
 635         int             num_scan_bblks;
 636         uint            first_half_cycle, last_half_cycle;
 637         uint            stop_on_cycle;
 638         int             error, log_bbnum = log->l_logBBsize;
 639
 640         /* Is the end of the log device zeroed? */
 641         error = xlog_find_zeroed(log, &first_blk);
 642         if (error < 0) {
 643                 xfs_warn(log->l_mp, "empty log check failed");
 644                 return error;
 645         }
 646         if (error == 1) {
 647                 *return_head_blk = first_blk;
 648
 649                 /* Is the whole lot zeroed? */
 650                 if (!first_blk) {
 651                         /* Linux XFS shouldn't generate totally zeroed logs -
 652                          * mkfs etc write a dummy unmount record to a fresh
 653                          * log so we can store the uuid in there
 654                          */
 655                         xfs_warn(log->l_mp, "totally zeroed log");
 656                 }
 657
 658                 return 0;
 659         }
 660
 661         first_blk = 0;                  /* get cycle # of 1st block */
 662         bp = xlog_get_bp(log, 1);
 663         if (!bp)
 664                 return -ENOMEM;
 665
 666         error = xlog_bread(log, 0, 1, bp, &offset);
 667         if (error)
 668                 goto bp_err;
 669
 670         first_half_cycle = xlog_get_cycle(offset);
 671
 672         last_blk = head_blk = log_bbnum - 1;    /* get cycle # of last block */
 673         error = xlog_bread(log, last_blk, 1, bp, &offset);
 674         if (error)
 675                 goto bp_err;
 676
 677         last_half_cycle = xlog_get_cycle(offset);
 678         ASSERT(last_half_cycle != 0);
 679
 680         /*
 681          * If the 1st half cycle number is equal to the last half cycle number,
 682          * then the entire log is stamped with the same cycle number.  In this
 683          * case, head_blk can't be set to zero (which makes sense).  The below
 684          * math doesn't work out properly with head_blk equal to zero.  Instead,
 685          * we set it to log_bbnum which is an invalid block number, but this
 686          * value makes the math correct.  If head_blk doesn't changed through
 687          * all the tests below, *head_blk is set to zero at the very end rather
 688          * than log_bbnum.  In a sense, log_bbnum and zero are the same block
 689          * in a circular file.
 690          */
 691         if (first_half_cycle == last_half_cycle) {
 692                 /*
 693                  * In this case we believe that the entire log should have
 694                  * cycle number last_half_cycle.  We need to scan backwards
 695                  * from the end verifying that there are no holes still
 696                  * containing last_half_cycle - 1.  If we find such a hole,
 697                  * then the start of that hole will be the new head.  The
 698                  * simple case looks like
 699                  *        x | x ... | x - 1 | x
 700                  * Another case that fits this picture would be
 701                  *        x | x + 1 | x ... | x
 702                  * In this case the head really is somewhere at the end of the
 703                  * log, as one of the latest writes at the beginning was
 704                  * incomplete.
 705                  * One more case is
 706                  *        x | x + 1 | x ... | x - 1 | x
 707                  * This is really the combination of the above two cases, and
 708                  * the head has to end up at the start of the x-1 hole at the
 709                  * end of the log.
 710                  *
 711                  * In the 256k log case, we will read from the beginning to the
 712                  * end of the log and search for cycle numbers equal to x-1.
 713                  * We don't worry about the x+1 blocks that we encounter,
 714                  * because we know that they cannot be the head since the log
 715                  * started with x.
 716                  */
 717                 head_blk = log_bbnum;
 718                 stop_on_cycle = last_half_cycle - 1;
 719         } else {
 720                 /*
 721                  * In this case we want to find the first block with cycle
 722                  * number matching last_half_cycle.  We expect the log to be
 723                  * some variation on
 724                  *        x + 1 ... | x ... | x
 725                  * The first block with cycle number x (last_half_cycle) will
 726                  * be where the new head belongs.  First we do a binary search
 727                  * for the first occurrence of last_half_cycle.  The binary
 728                  * search may not be totally accurate, so then we scan back
 729                  * from there looking for occurrences of last_half_cycle before
 730                  * us.  If that backwards scan wraps around the beginning of
 731                  * the log, then we look for occurrences of last_half_cycle - 1
 732                  * at the end of the log.  The cases we're looking for look
 733                  * like
 734                  *                               v binary search stopped here
 735                  *        x + 1 ... | x | x + 1 | x ... | x
 736                  *                   ^ but we want to locate this spot
 737                  * or
 738                  *        <---------> less than scan distance
 739                  *        x + 1 ... | x ... | x - 1 | x
 740                  *                           ^ we want to locate this spot
 741                  */
 742                 stop_on_cycle = last_half_cycle;
 743                 if ((error = xlog_find_cycle_start(log, bp, first_blk,
 744                                                 &head_blk, last_half_cycle)))
 745                         goto bp_err;
 746         }
 747
 748         /*
 749          * Now validate the answer.  Scan back some number of maximum possible
 750          * blocks and make sure each one has the expected cycle number.  The
 751          * maximum is determined by the total possible amount of buffering
 752          * in the in-core log.  The following number can be made tighter if
 753          * we actually look at the block size of the filesystem.
 754          */
 755         num_scan_bblks = min_t(int, log_bbnum, XLOG_TOTAL_REC_SHIFT(log));
 756         if (head_blk >= num_scan_bblks) {
 757                 /*
 758                  * We are guaranteed that the entire check can be performed
 759                  * in one buffer.
 760                  */
 761                 start_blk = head_blk - num_scan_bblks;
 762                 if ((error = xlog_find_verify_cycle(log,
 763                                                 start_blk, num_scan_bblks,
 764                                                 stop_on_cycle, &new_blk)))
 765                         goto bp_err;
 766                 if (new_blk != -1)
 767                         head_blk = new_blk;
 768         } else {                /* need to read 2 parts of log */
 769                 /*
 770                  * We are going to scan backwards in the log in two parts.
 771                  * First we scan the physical end of the log.  In this part
 772                  * of the log, we are looking for blocks with cycle number
 773                  * last_half_cycle - 1.
 774                  * If we find one, then we know that the log starts there, as
 775                  * we've found a hole that didn't get written in going around
 776                  * the end of the physical log.  The simple case for this is
 777                  *        x + 1 ... | x ... | x - 1 | x
 778                  *        <---------> less than scan distance
 779                  * If all of the blocks at the end of the log have cycle number
 780                  * last_half_cycle, then we check the blocks at the start of
 781                  * the log looking for occurrences of last_half_cycle.  If we
 782                  * find one, then our current estimate for the location of the
 783                  * first occurrence of last_half_cycle is wrong and we move
 784                  * back to the hole we've found.  This case looks like
 785                  *        x + 1 ... | x | x + 1 | x ...
 786                  *                               ^ binary search stopped here
 787                  * Another case we need to handle that only occurs in 256k
 788                  * logs is
 789                  *        x + 1 ... | x ... | x+1 | x ...
 790                  *                   ^ binary search stops here
 791                  * In a 256k log, the scan at the end of the log will see the
 792                  * x + 1 blocks.  We need to skip past those since that is
 793                  * certainly not the head of the log.  By searching for
 794                  * last_half_cycle-1 we accomplish that.
 795                  */
 796                 ASSERT(head_blk <= INT_MAX &&
 797                         (xfs_daddr_t) num_scan_bblks >= head_blk);
 798                 start_blk = log_bbnum - (num_scan_bblks - head_blk);
 799                 if ((error = xlog_find_verify_cycle(log, start_blk,
 800                                         num_scan_bblks - (int)head_blk,
 801                                         (stop_on_cycle - 1), &new_blk)))
 802                         goto bp_err;
 803                 if (new_blk != -1) {
 804                         head_blk = new_blk;
 805                         goto validate_head;
 806                 }
 807
 808                 /*
 809                  * Scan beginning of log now.  The last part of the physical
 810                  * log is good.  This scan needs to verify that it doesn't find
 811                  * the last_half_cycle.
 812                  */
 813                 start_blk = 0;
 814                 ASSERT(head_blk <= INT_MAX);
 815                 if ((error = xlog_find_verify_cycle(log,
 816                                         start_blk, (int)head_blk,
 817                                         stop_on_cycle, &new_blk)))
 818                         goto bp_err;
 819                 if (new_blk != -1)
 820                         head_blk = new_blk;
 821         }
 822
 823 validate_head:
 824         /*
 825          * Now we need to make sure head_blk is not pointing to a block in
 826          * the middle of a log record.
 827          */
 828         num_scan_bblks = XLOG_REC_SHIFT(log);
 829         if (head_blk >= num_scan_bblks) {
 830                 start_blk = head_blk - num_scan_bblks; /* don't read head_blk */
 831
 832                 /* start ptr at last block ptr before head_blk */
 833                 error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0);
 834                 if (error == 1)
 835                         error = -EIO;
 836                 if (error)
 837                         goto bp_err;
 838         } else {
 839                 start_blk = 0;
 840                 ASSERT(head_blk <= INT_MAX);
 841                 error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0);
 842                 if (error < 0)
 843                         goto bp_err;
 844                 if (error == 1) {
 845                         /* We hit the beginning of the log during our search */
 846                         start_blk = log_bbnum - (num_scan_bblks - head_blk);
 847                         new_blk = log_bbnum;
 848                         ASSERT(start_blk <= INT_MAX &&
 849                                 (xfs_daddr_t) log_bbnum-start_blk >= 0);
 850                         ASSERT(head_blk <= INT_MAX);
 851                         error = xlog_find_verify_log_record(log, start_blk,
 852                                                         &new_blk, (int)head_blk);
 853                         if (error == 1)
 854                                 error = -EIO;
 855                         if (error)
 856                                 goto bp_err;
 857                         if (new_blk != log_bbnum)
 858                                 head_blk = new_blk;
 859                 } else if (error)
 860                         goto bp_err;
 861         }
 862
 863         xlog_put_bp(bp);
 864         if (head_blk == log_bbnum)
 865                 *return_head_blk = 0;
 866         else
 867                 *return_head_blk = head_blk;
 868         /*
 869          * When returning here, we have a good block number.  Bad block
 870          * means that during a previous crash, we didn't have a clean break
 871          * from cycle number N to cycle number N-1.  In this case, we need
 872          * to find the first block with cycle number N-1.
 873          */
 874         return 0;
 875
 876  bp_err:
 877         xlog_put_bp(bp);
 878
 879         if (error)
 880                 xfs_warn(log->l_mp, "failed to find log head");
 881         return error;
 882 }
 883
 884 /*
 885  * Seek backwards in the log for log record headers.
 886  *
 887  * Given a starting log block, walk backwards until we find the provided number
 888  * of records or hit the provided tail block. The return value is the number of
 889  * records encountered or a negative error code. The log block and buffer
 890  * pointer of the last record seen are returned in rblk and rhead respectively.
 891  */
 892 STATIC int
 893 xlog_rseek_logrec_hdr(
 894         struct xlog             *log,
 895         xfs_daddr_t             head_blk,
 896         xfs_daddr_t             tail_blk,
 897         int                     count,
 898         struct xfs_buf          *bp,
 899         xfs_daddr_t             *rblk,
 900         struct xlog_rec_header  **rhead,
 901         bool                    *wrapped)
 902 {
 903         int                     i;
 904         int                     error;
 905         int                     found = 0;
 906         char                    *offset = NULL;
 907         xfs_daddr_t             end_blk;
 908
 909         *wrapped = false;
 910
 911         /*
 912          * Walk backwards from the head block until we hit the tail or the first
 913          * block in the log.
 914          */
 915         end_blk = head_blk > tail_blk ? tail_blk : 0;
 916         for (i = (int) head_blk - 1; i >= end_blk; i--) {
 917                 error = xlog_bread(log, i, 1, bp, &offset);
 918                 if (error)
 919                         goto out_error;
 920
 921                 if (*(__be32 *) offset == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
 922                         *rblk = i;
 923                         *rhead = (struct xlog_rec_header *) offset;
 924                         if (++found == count)
 925                                 break;
 926                 }
 927         }
 928
 929         /*
 930          * If we haven't hit the tail block or the log record header count,
 931          * start looking again from the end of the physical log. Note that
 932          * callers can pass head == tail if the tail is not yet known.
 933          */
 934         if (tail_blk >= head_blk && found != count) {
 935                 for (i = log->l_logBBsize - 1; i >= (int) tail_blk; i--) {
 936                         error = xlog_bread(log, i, 1, bp, &offset);
 937                         if (error)
 938                                 goto out_error;
 939
 940                         if (*(__be32 *)offset ==
 941                             cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
 942                                 *wrapped = true;
 943                                 *rblk = i;
 944                                 *rhead = (struct xlog_rec_header *) offset;
 945                                 if (++found == count)
 946                                         break;
 947                         }
 948                 }
 949         }
 950
 951         return found;
 952
 953 out_error:
 954         return error;
 955 }
 956
 957 /*
 958  * Seek forward in the log for log record headers.
 959  *
 960  * Given head and tail blocks, walk forward from the tail block until we find
 961  * the provided number of records or hit the head block. The return value is the
 962  * number of records encountered or a negative error code. The log block and
 963  * buffer pointer of the last record seen are returned in rblk and rhead
 964  * respectively.
 965  */
 966 STATIC int
 967 xlog_seek_logrec_hdr(
 968         struct xlog             *log,
 969         xfs_daddr_t             head_blk,
 970         xfs_daddr_t             tail_blk,
 971         int                     count,
 972         struct xfs_buf          *bp,
 973         xfs_daddr_t             *rblk,
 974         struct xlog_rec_header  **rhead,
 975         bool                    *wrapped)
 976 {
 977         int                     i;
 978         int                     error;
 979         int                     found = 0;
 980         char                    *offset = NULL;
 981         xfs_daddr_t             end_blk;
 982
 983         *wrapped = false;
 984
 985         /*
 986          * Walk forward from the tail block until we hit the head or the last
 987          * block in the log.
 988          */
 989         end_blk = head_blk > tail_blk ? head_blk : log->l_logBBsize - 1;
 990         for (i = (int) tail_blk; i <= end_blk; i++) {
 991                 error = xlog_bread(log, i, 1, bp, &offset);
 992                 if (error)
 993                         goto out_error;
 994
 995                 if (*(__be32 *) offset == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
 996                         *rblk = i;
 997                         *rhead = (struct xlog_rec_header *) offset;
 998                         if (++found == count)
 999                                 break;
1000                 }
1001         }
1002
1003         /*
1004          * If we haven't hit the head block or the log record header count,
1005          * start looking again from the start of the physical log.
1006          */
1007         if (tail_blk > head_blk && found != count) {
1008                 for (i = 0; i < (int) head_blk; i++) {
1009                         error = xlog_bread(log, i, 1, bp, &offset);
1010                         if (error)
1011                                 goto out_error;
1012
1013                         if (*(__be32 *)offset ==
1014                             cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
1015                                 *wrapped = true;
1016                                 *rblk = i;
1017                                 *rhead = (struct xlog_rec_header *) offset;
1018                                 if (++found == count)
1019                                         break;
1020                         }
1021                 }
1022         }
1023
1024         return found;
1025
1026 out_error:
1027         return error;
1028 }
1029
1030 /*
1031  * Calculate distance from head to tail (i.e., unused space in the log).
1032  */
1033 static inline int
1034 xlog_tail_distance(
1035         struct xlog     *log,
1036         xfs_daddr_t     head_blk,
1037         xfs_daddr_t     tail_blk)
1038 {
1039         if (head_blk < tail_blk)
1040                 return tail_blk - head_blk;
1041
1042         return tail_blk + (log->l_logBBsize - head_blk);
1043 }
1044
1045 /*
1046  * Verify the log tail. This is particularly important when torn or incomplete
1047  * writes have been detected near the front of the log and the head has been
1048  * walked back accordingly.
1049  *
1050  * We also have to handle the case where the tail was pinned and the head
1051  * blocked behind the tail right before a crash. If the tail had been pushed
1052  * immediately prior to the crash and the subsequent checkpoint was only
1053  * partially written, it's possible it overwrote the last referenced tail in the
1054  * log with garbage. This is not a coherency problem because the tail must have
1055  * been pushed before it can be overwritten, but appears as log corruption to
1056  * recovery because we have no way to know the tail was updated if the
1057  * subsequent checkpoint didn't write successfully.
1058  *
1059  * Therefore, CRC check the log from tail to head. If a failure occurs and the
1060  * offending record is within max iclog bufs from the head, walk the tail
1061  * forward and retry until a valid tail is found or corruption is detected out
1062  * of the range of a possible overwrite.
1063  */
1064 STATIC int
1065 xlog_verify_tail(
1066         struct xlog             *log,
1067         xfs_daddr_t             head_blk,
1068         xfs_daddr_t             *tail_blk,
1069         int                     hsize)
1070 {
1071         struct xlog_rec_header  *thead;
1072         struct xfs_buf          *bp;
1073         xfs_daddr_t             first_bad;
1074         int                     error = 0;
1075         bool                    wrapped;
1076         xfs_daddr_t             tmp_tail;
1077         xfs_daddr_t             orig_tail = *tail_blk;
1078
1079         bp = xlog_get_bp(log, 1);
1080         if (!bp)
1081                 return -ENOMEM;
1082
1083         /*
1084          * Make sure the tail points to a record (returns positive count on
1085          * success).
1086          */
1087         error = xlog_seek_logrec_hdr(log, head_blk, *tail_blk, 1, bp,
1088                         &tmp_tail, &thead, &wrapped);
1089         if (error < 0)
1090                 goto out;
1091         if (*tail_blk != tmp_tail)
1092                 *tail_blk = tmp_tail;
1093
1094         /*
1095          * Run a CRC check from the tail to the head. We can't just check
1096          * MAX_ICLOGS records past the tail because the tail may point to stale
1097          * blocks cleared during the search for the head/tail. These blocks are
1098          * overwritten with zero-length records and thus record count is not a
1099          * reliable indicator of the iclog state before a crash.
1100          */
1101         first_bad = 0;
1102         error = xlog_do_recovery_pass(log, head_blk, *tail_blk,
1103                                       XLOG_RECOVER_CRCPASS, &first_bad);
1104         while ((error == -EFSBADCRC || error == -EFSCORRUPTED) && first_bad) {
1105                 int     tail_distance;
1106
1107                 /*
1108                  * Is corruption within range of the head? If so, retry from
1109                  * the next record. Otherwise return an error.
1110                  */
1111                 tail_distance = xlog_tail_distance(log, head_blk, first_bad);
1112                 if (tail_distance > BTOBB(XLOG_MAX_ICLOGS * hsize))
1113                         break;
1114
1115                 /* skip to the next record; returns positive count on success */
1116                 error = xlog_seek_logrec_hdr(log, head_blk, first_bad, 2, bp,
1117                                 &tmp_tail, &thead, &wrapped);
1118                 if (error < 0)
1119                         goto out;
1120
1121                 *tail_blk = tmp_tail;
1122                 first_bad = 0;
1123                 error = xlog_do_recovery_pass(log, head_blk, *tail_blk,
1124                                               XLOG_RECOVER_CRCPASS, &first_bad);
1125         }
1126
1127         if (!error && *tail_blk != orig_tail)
1128                 xfs_warn(log->l_mp,
1129                 "Tail block (0x%llx) overwrite detected. Updated to 0x%llx",
1130                          orig_tail, *tail_blk);
1131 out:
1132         xlog_put_bp(bp);
1133         return error;
1134 }
1135
1136 /*
1137  * Detect and trim torn writes from the head of the log.
1138  *
1139  * Storage without sector atomicity guarantees can result in torn writes in the
1140  * log in the event of a crash. Our only means to detect this scenario is via
1141  * CRC verification. While we can't always be certain that CRC verification
1142  * failure is due to a torn write vs. an unrelated corruption, we do know that
1143  * only a certain number (XLOG_MAX_ICLOGS) of log records can be written out at
1144  * one time. Therefore, CRC verify up to XLOG_MAX_ICLOGS records at the head of
1145  * the log and treat failures in this range as torn writes as a matter of
1146  * policy. In the event of CRC failure, the head is walked back to the last good
1147  * record in the log and the tail is updated from that record and verified.
1148  */
1149 STATIC int
1150 xlog_verify_head(
1151         struct xlog             *log,
1152         xfs_daddr_t             *head_blk,      /* in/out: unverified head */
1153         xfs_daddr_t             *tail_blk,      /* out: tail block */
1154         struct xfs_buf          *bp,
1155         xfs_daddr_t             *rhead_blk,     /* start blk of last record */
1156         struct xlog_rec_header  **rhead,        /* ptr to last record */
1157         bool                    *wrapped)       /* last rec. wraps phys. log */
1158 {
1159         struct xlog_rec_header  *tmp_rhead;
1160         struct xfs_buf          *tmp_bp;
1161         xfs_daddr_t             first_bad;
1162         xfs_daddr_t             tmp_rhead_blk;
1163         int                     found;
1164         int                     error;
1165         bool                    tmp_wrapped;
1166
1167         /*
1168          * Check the head of the log for torn writes. Search backwards from the
1169          * head until we hit the tail or the maximum number of log record I/Os
1170          * that could have been in flight at one time. Use a temporary buffer so
1171          * we don't trash the rhead/bp pointers from the caller.
1172          */
1173         tmp_bp = xlog_get_bp(log, 1);
1174         if (!tmp_bp)
1175                 return -ENOMEM;
1176         error = xlog_rseek_logrec_hdr(log, *head_blk, *tail_blk,
1177                                       XLOG_MAX_ICLOGS, tmp_bp, &tmp_rhead_blk,
1178                                       &tmp_rhead, &tmp_wrapped);
1179         xlog_put_bp(tmp_bp);
1180         if (error < 0)
1181                 return error;
1182
1183         /*
1184          * Now run a CRC verification pass over the records starting at the
1185          * block found above to the current head. If a CRC failure occurs, the
1186          * log block of the first bad record is saved in first_bad.
1187          */
1188         error = xlog_do_recovery_pass(log, *head_blk, tmp_rhead_blk,
1189                                       XLOG_RECOVER_CRCPASS, &first_bad);
1190         if ((error == -EFSBADCRC || error == -EFSCORRUPTED) && first_bad) {
1191                 /*
1192                  * We've hit a potential torn write. Reset the error and warn
1193                  * about it.
1194                  */
1195                 error = 0;
1196                 xfs_warn(log->l_mp,
1197 "Torn write (CRC failure) detected at log block 0x%llx. Truncating head block from 0x%llx.",
1198                          first_bad, *head_blk);
1199
1200                 /*
1201                  * Get the header block and buffer pointer for the last good
1202                  * record before the bad record.
1203                  *
1204                  * Note that xlog_find_tail() clears the blocks at the new head
1205                  * (i.e., the records with invalid CRC) if the cycle number
1206                  * matches the the current cycle.
1207                  */
1208                 found = xlog_rseek_logrec_hdr(log, first_bad, *tail_blk, 1, bp,
1209                                               rhead_blk, rhead, wrapped);
1210                 if (found < 0)
1211                         return found;
1212                 if (found == 0)         /* XXX: right thing to do here? */
1213                         return -EIO;
1214
1215                 /*
1216                  * Reset the head block to the starting block of the first bad
1217                  * log record and set the tail block based on the last good
1218                  * record.
1219                  *
1220                  * Bail out if the updated head/tail match as this indicates
1221                  * possible corruption outside of the acceptable
1222                  * (XLOG_MAX_ICLOGS) range. This is a job for xfs_repair...
1223                  */
1224                 *head_blk = first_bad;
1225                 *tail_blk = BLOCK_LSN(be64_to_cpu((*rhead)->h_tail_lsn));
1226                 if (*head_blk == *tail_blk) {
1227                         ASSERT(0);
1228                         return 0;
1229                 }
1230         }
1231         if (error)
1232                 return error;
1233
1234         return xlog_verify_tail(log, *head_blk, tail_blk,
1235                                 be32_to_cpu((*rhead)->h_size));
1236 }
1237
1238 /*
1239  * We need to make sure we handle log wrapping properly, so we can't use the
1240  * calculated logbno directly. Make sure it wraps to the correct bno inside the
1241  * log.
1242  *
1243  * The log is limited to 32 bit sizes, so we use the appropriate modulus
1244  * operation here and cast it back to a 64 bit daddr on return.
1245  */
1246 static inline xfs_daddr_t
1247 xlog_wrap_logbno(
1248         struct xlog             *log,
1249         xfs_daddr_t             bno)
1250 {
1251         int                     mod;
1252
1253         div_s64_rem(bno, log->l_logBBsize, &mod);
1254         return mod;
1255 }
1256
1257 /*
1258  * Check whether the head of the log points to an unmount record. In other
1259  * words, determine whether the log is clean. If so, update the in-core state
1260  * appropriately.
1261  */
1262 static int
1263 xlog_check_unmount_rec(
1264         struct xlog             *log,
1265         xfs_daddr_t             *head_blk,
1266         xfs_daddr_t             *tail_blk,
1267         struct xlog_rec_header  *rhead,
1268         xfs_daddr_t             rhead_blk,
1269         struct xfs_buf          *bp,
1270         bool                    *clean)
1271 {
1272         struct xlog_op_header   *op_head;
1273         xfs_daddr_t             umount_data_blk;
1274         xfs_daddr_t             after_umount_blk;
1275         int                     hblks;
1276         int                     error;
1277         char                    *offset;
1278
1279         *clean = false;
1280
1281         /*
1282          * Look for unmount record. If we find it, then we know there was a
1283          * clean unmount. Since 'i' could be the last block in the physical
1284          * log, we convert to a log block before comparing to the head_blk.
1285          *
1286          * Save the current tail lsn to use to pass to xlog_clear_stale_blocks()
1287          * below. We won't want to clear the unmount record if there is one, so
1288          * we pass the lsn of the unmount record rather than the block after it.
1289          */
1290         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
1291                 int     h_size = be32_to_cpu(rhead->h_size);
1292                 int     h_version = be32_to_cpu(rhead->h_version);
1293
1294                 if ((h_version & XLOG_VERSION_2) &&
1295                     (h_size > XLOG_HEADER_CYCLE_SIZE)) {
1296                         hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
1297                         if (h_size % XLOG_HEADER_CYCLE_SIZE)
1298                                 hblks++;
1299                 } else {
1300                         hblks = 1;
1301                 }
1302         } else {
1303                 hblks = 1;
1304         }
1305
1306         after_umount_blk = xlog_wrap_logbno(log,
1307                         rhead_blk + hblks + BTOBB(be32_to_cpu(rhead->h_len)));
1308
1309         if (*head_blk == after_umount_blk &&
1310             be32_to_cpu(rhead->h_num_logops) == 1) {
1311                 umount_data_blk = xlog_wrap_logbno(log, rhead_blk + hblks);
1312                 error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
1313                 if (error)
1314                         return error;
1315
1316                 op_head = (struct xlog_op_header *)offset;
1317                 if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
1318                         /*
1319                          * Set tail and last sync so that newly written log
1320                          * records will point recovery to after the current
1321                          * unmount record.
1322                          */
1323                         xlog_assign_atomic_lsn(&log->l_tail_lsn,
1324                                         log->l_curr_cycle, after_umount_blk);
1325                         xlog_assign_atomic_lsn(&log->l_last_sync_lsn,
1326                                         log->l_curr_cycle, after_umount_blk);
1327                         *tail_blk = after_umount_blk;
1328
1329                         *clean = true;
1330                 }
1331         }
1332
1333         return 0;
1334 }
1335
1336 static void
1337 xlog_set_state(
1338         struct xlog             *log,
1339         xfs_daddr_t             head_blk,
1340         struct xlog_rec_header  *rhead,
1341         xfs_daddr_t             rhead_blk,
1342         bool                    bump_cycle)
1343 {
1344         /*
1345          * Reset log values according to the state of the log when we
1346          * crashed.  In the case where head_blk == 0, we bump curr_cycle
1347          * one because the next write starts a new cycle rather than
1348          * continuing the cycle of the last good log record.  At this
1349          * point we have guaranteed that all partial log records have been
1350          * accounted for.  Therefore, we know that the last good log record
1351          * written was complete and ended exactly on the end boundary
1352          * of the physical log.
1353          */
1354         log->l_prev_block = rhead_blk;
1355         log->l_curr_block = (int)head_blk;
1356         log->l_curr_cycle = be32_to_cpu(rhead->h_cycle);
1357         if (bump_cycle)
1358                 log->l_curr_cycle++;
1359         atomic64_set(&log->l_tail_lsn, be64_to_cpu(rhead->h_tail_lsn));
1360         atomic64_set(&log->l_last_sync_lsn, be64_to_cpu(rhead->h_lsn));
1361         xlog_assign_grant_head(&log->l_reserve_head.grant, log->l_curr_cycle,
1362                                         BBTOB(log->l_curr_block));
1363         xlog_assign_grant_head(&log->l_write_head.grant, log->l_curr_cycle,
1364                                         BBTOB(log->l_curr_block));
1365 }
1366
1367 /*
1368  * Find the sync block number or the tail of the log.
1369  *
1370  * This will be the block number of the last record to have its
1371  * associated buffers synced to disk.  Every log record header has
1372  * a sync lsn embedded in it.  LSNs hold block numbers, so it is easy
1373  * to get a sync block number.  The only concern is to figure out which
1374  * log record header to believe.
1375  *
1376  * The following algorithm uses the log record header with the largest
1377  * lsn.  The entire log record does not need to be valid.  We only care
1378  * that the header is valid.
1379  *
1380  * We could speed up search by using current head_blk buffer, but it is not
1381  * available.
1382  */
1383 STATIC int
1384 xlog_find_tail(
1385         struct xlog             *log,
1386         xfs_daddr_t             *head_blk,
1387         xfs_daddr_t             *tail_blk)
1388 {
1389         xlog_rec_header_t       *rhead;
1390         char                    *offset = NULL;
1391         xfs_buf_t               *bp;
1392         int                     error;
1393         xfs_daddr_t             rhead_blk;
1394         xfs_lsn_t               tail_lsn;
1395         bool                    wrapped = false;
1396         bool                    clean = false;
1397
1398         /*
1399          * Find previous log record
1400          */
1401         if ((error = xlog_find_head(log, head_blk)))
1402                 return error;
1403         ASSERT(*head_blk < INT_MAX);
1404
1405         bp = xlog_get_bp(log, 1);
1406         if (!bp)
1407                 return -ENOMEM;
1408         if (*head_blk == 0) {                           /* special case */
1409                 error = xlog_bread(log, 0, 1, bp, &offset);
1410                 if (error)
1411                         goto done;
1412
1413                 if (xlog_get_cycle(offset) == 0) {
1414                         *tail_blk = 0;
1415                         /* leave all other log inited values alone */
1416                         goto done;
1417                 }
1418         }
1419
1420         /*
1421          * Search backwards through the log looking for the log record header
1422          * block. This wraps all the way back around to the head so something is
1423          * seriously wrong if we can't find it.
1424          */
1425         error = xlog_rseek_logrec_hdr(log, *head_blk, *head_blk, 1, bp,
1426                                       &rhead_blk, &rhead, &wrapped);
1427         if (error < 0)
1428                 return error;
1429         if (!error) {
1430                 xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__);
1431                 return -EIO;
1432         }
1433         *tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn));
1434
1435         /*
1436          * Set the log state based on the current head record.
1437          */
1438         xlog_set_state(log, *head_blk, rhead, rhead_blk, wrapped);
1439         tail_lsn = atomic64_read(&log->l_tail_lsn);
1440
1441         /*
1442          * Look for an unmount record at the head of the log. This sets the log
1443          * state to determine whether recovery is necessary.
1444          */
1445         error = xlog_check_unmount_rec(log, head_blk, tail_blk, rhead,
1446                                        rhead_blk, bp, &clean);
1447         if (error)
1448                 goto done;
1449
1450         /*
1451          * Verify the log head if the log is not clean (e.g., we have anything
1452          * but an unmount record at the head). This uses CRC verification to
1453          * detect and trim torn writes. If discovered, CRC failures are
1454          * considered torn writes and the log head is trimmed accordingly.
1455          *
1456          * Note that we can only run CRC verification when the log is dirty
1457          * because there's no guarantee that the log data behind an unmount
1458          * record is compatible with the current architecture.
1459          */
1460         if (!clean) {
1461                 xfs_daddr_t     orig_head = *head_blk;
1462
1463                 error = xlog_verify_head(log, head_blk, tail_blk, bp,
1464                                          &rhead_blk, &rhead, &wrapped);
1465                 if (error)
1466                         goto done;
1467
1468                 /* update in-core state again if the head changed */
1469                 if (*head_blk != orig_head) {
1470                         xlog_set_state(log, *head_blk, rhead, rhead_blk,
1471                                        wrapped);
1472                         tail_lsn = atomic64_read(&log->l_tail_lsn);
1473                         error = xlog_check_unmount_rec(log, head_blk, tail_blk,
1474                                                        rhead, rhead_blk, bp,
1475                                                        &clean);
1476                         if (error)
1477                                 goto done;
1478                 }
1479         }
1480
1481         /*
1482          * Note that the unmount was clean. If the unmount was not clean, we
1483          * need to know this to rebuild the superblock counters from the perag
1484          * headers if we have a filesystem using non-persistent counters.
1485          */
1486         if (clean)
1487                 log->l_mp->m_flags |= XFS_MOUNT_WAS_CLEAN;
1488
1489         /*
1490          * Make sure that there are no blocks in front of the head
1491          * with the same cycle number as the head.  This can happen
1492          * because we allow multiple outstanding log writes concurrently,
1493          * and the later writes might make it out before earlier ones.
1494          *
1495          * We use the lsn from before modifying it so that we'll never
1496          * overwrite the unmount record after a clean unmount.
1497          *
1498          * Do this only if we are going to recover the filesystem
1499          *
1500          * NOTE: This used to say "if (!readonly)"
1501          * However on Linux, we can & do recover a read-only filesystem.
1502          * We only skip recovery if NORECOVERY is specified on mount,
1503          * in which case we would not be here.
1504          *
1505          * But... if the -device- itself is readonly, just skip this.
1506          * We can't recover this device anyway, so it won't matter.
1507          */
1508         if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp))
1509                 error = xlog_clear_stale_blocks(log, tail_lsn);
1510
1511 done:
1512         xlog_put_bp(bp);
1513
1514         if (error)
1515                 xfs_warn(log->l_mp, "failed to locate log tail");
1516         return error;
1517 }
1518
1519 /*
1520  * Is the log zeroed at all?
1521  *
1522  * The last binary search should be changed to perform an X block read
1523  * once X becomes small enough.  You can then search linearly through
1524  * the X blocks.  This will cut down on the number of reads we need to do.
1525  *
1526  * If the log is partially zeroed, this routine will pass back the blkno
1527  * of the first block with cycle number 0.  It won't have a complete LR
1528  * preceding it.
1529  *
1530  * Return:
1531  *      0  => the log is completely written to
1532  *      1 => use *blk_no as the first block of the log
1533  *      <0 => error has occurred
1534  */
1535 STATIC int
1536 xlog_find_zeroed(
1537         struct xlog     *log,
1538         xfs_daddr_t     *blk_no)
1539 {
1540         xfs_buf_t       *bp;
1541         char            *offset;
1542         uint            first_cycle, last_cycle;
1543         xfs_daddr_t     new_blk, last_blk, start_blk;
1544         xfs_daddr_t     num_scan_bblks;
1545         int             error, log_bbnum = log->l_logBBsize;
1546
1547         *blk_no = 0;
1548
1549         /* check totally zeroed log */
1550         bp = xlog_get_bp(log, 1);
1551         if (!bp)
1552                 return -ENOMEM;
1553         error = xlog_bread(log, 0, 1, bp, &offset);
1554         if (error)
1555                 goto bp_err;
1556
1557         first_cycle = xlog_get_cycle(offset);
1558         if (first_cycle == 0) {         /* completely zeroed log */
1559                 *blk_no = 0;
1560                 xlog_put_bp(bp);
1561                 return 1;
1562         }
1563
1564         /* check partially zeroed log */
1565         error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
1566         if (error)
1567                 goto bp_err;
1568
1569         last_cycle = xlog_get_cycle(offset);
1570         if (last_cycle != 0) {          /* log completely written to */
1571                 xlog_put_bp(bp);
1572                 return 0;
1573         }
1574
1575         /* we have a partially zeroed log */
1576         last_blk = log_bbnum-1;
1577         if ((error = xlog_find_cycle_start(log, bp, 0, &last_blk, 0)))
1578                 goto bp_err;
1579
1580         /*
1581          * Validate the answer.  Because there is no way to guarantee that
1582          * the entire log is made up of log records which are the same size,
1583          * we scan over the defined maximum blocks.  At this point, the maximum
1584          * is not chosen to mean anything special.   XXXmiken
1585          */
1586         num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
1587         ASSERT(num_scan_bblks <= INT_MAX);
1588
1589         if (last_blk < num_scan_bblks)
1590                 num_scan_bblks = last_blk;
1591         start_blk = last_blk - num_scan_bblks;
1592
1593         /*
1594          * We search for any instances of cycle number 0 that occur before
1595          * our current estimate of the head.  What we're trying to detect is
1596          *        1 ... | 0 | 1 | 0...
1597          *                       ^ binary search ends here
1598          */
1599         if ((error = xlog_find_verify_cycle(log, start_blk,
1600                                          (int)num_scan_bblks, 0, &new_blk)))
1601                 goto bp_err;
1602         if (new_blk != -1)
1603                 last_blk = new_blk;
1604
1605         /*
1606          * Potentially backup over partial log record write.  We don't need
1607          * to search the end of the log because we know it is zero.
1608          */
1609         error = xlog_find_verify_log_record(log, start_blk, &last_blk, 0);
1610         if (error == 1)
1611                 error = -EIO;
1612         if (error)
1613                 goto bp_err;
1614
1615         *blk_no = last_blk;
1616 bp_err:
1617         xlog_put_bp(bp);
1618         if (error)
1619                 return error;
1620         return 1;
1621 }
1622
1623 /*
1624  * These are simple subroutines used by xlog_clear_stale_blocks() below
1625  * to initialize a buffer full of empty log record headers and write
1626  * them into the log.
1627  */
1628 STATIC void
1629 xlog_add_record(
1630         struct xlog             *log,
1631         char                    *buf,
1632         int                     cycle,
1633         int                     block,
1634         int                     tail_cycle,
1635         int                     tail_block)
1636 {
1637         xlog_rec_header_t       *recp = (xlog_rec_header_t *)buf;
1638
1639         memset(buf, 0, BBSIZE);
1640         recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
1641         recp->h_cycle = cpu_to_be32(cycle);
1642         recp->h_version = cpu_to_be32(
1643                         xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
1644         recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block));
1645         recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block));
1646         recp->h_fmt = cpu_to_be32(XLOG_FMT);
1647         memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
1648 }
1649
1650 STATIC int
1651 xlog_write_log_records(
1652         struct xlog     *log,
1653         int             cycle,
1654         int             start_block,
1655         int             blocks,
1656         int             tail_cycle,
1657         int             tail_block)
1658 {
1659         char            *offset;
1660         xfs_buf_t       *bp;
1661         int             balign, ealign;
1662         int             sectbb = log->l_sectBBsize;
1663         int             end_block = start_block + blocks;
1664         int             bufblks;
1665         int             error = 0;
1666         int             i, j = 0;
1667
1668         /*
1669          * Greedily allocate a buffer big enough to handle the full
1670          * range of basic blocks to be written.  If that fails, try
1671          * a smaller size.  We need to be able to write at least a
1672          * log sector, or we're out of luck.
1673          */
1674         bufblks = 1 << ffs(blocks);
1675         while (bufblks > log->l_logBBsize)
1676                 bufblks >>= 1;
1677         while (!(bp = xlog_get_bp(log, bufblks))) {
1678                 bufblks >>= 1;
1679                 if (bufblks < sectbb)
1680                         return -ENOMEM;
1681         }
1682
1683         /* We may need to do a read at the start to fill in part of
1684          * the buffer in the starting sector not covered by the first
1685          * write below.
1686          */
1687         balign = round_down(start_block, sectbb);
1688         if (balign != start_block) {
1689                 error = xlog_bread_noalign(log, start_block, 1, bp);
1690                 if (error)
1691                         goto out_put_bp;
1692
1693                 j = start_block - balign;
1694         }
1695
1696         for (i = start_block; i < end_block; i += bufblks) {
1697                 int             bcount, endcount;
1698
1699                 bcount = min(bufblks, end_block - start_block);
1700                 endcount = bcount - j;
1701
1702                 /* We may need to do a read at the end to fill in part of
1703                  * the buffer in the final sector not covered by the write.
1704                  * If this is the same sector as the above read, skip it.
1705                  */
1706                 ealign = round_down(end_block, sectbb);
1707                 if (j == 0 && (start_block + endcount > ealign)) {
1708                         offset = bp->b_addr + BBTOB(ealign - start_block);
1709                         error = xlog_bread_offset(log, ealign, sectbb,
1710                                                         bp, offset);
1711                         if (error)
1712                                 break;
1713
1714                 }
1715
1716                 offset = xlog_align(log, start_block, endcount, bp);
1717                 for (; j < endcount; j++) {
1718                         xlog_add_record(log, offset, cycle, i+j,
1719                                         tail_cycle, tail_block);
1720                         offset += BBSIZE;
1721                 }
1722                 error = xlog_bwrite(log, start_block, endcount, bp);
1723                 if (error)
1724                         break;
1725                 start_block += endcount;
1726                 j = 0;
1727         }
1728
1729  out_put_bp:
1730         xlog_put_bp(bp);
1731         return error;
1732 }
1733
1734 /*
1735  * This routine is called to blow away any incomplete log writes out
1736  * in front of the log head.  We do this so that we won't become confused
1737  * if we come up, write only a little bit more, and then crash again.
1738  * If we leave the partial log records out there, this situation could
1739  * cause us to think those partial writes are valid blocks since they
1740  * have the current cycle number.  We get rid of them by overwriting them
1741  * with empty log records with the old cycle number rather than the
1742  * current one.
1743  *
1744  * The tail lsn is passed in rather than taken from
1745  * the log so that we will not write over the unmount record after a
1746  * clean unmount in a 512 block log.  Doing so would leave the log without
1747  * any valid log records in it until a new one was written.  If we crashed
1748  * during that time we would not be able to recover.
1749  */
1750 STATIC int
1751 xlog_clear_stale_blocks(
1752         struct xlog     *log,
1753         xfs_lsn_t       tail_lsn)
1754 {
1755         int             tail_cycle, head_cycle;
1756         int             tail_block, head_block;
1757         int             tail_distance, max_distance;
1758         int             distance;
1759         int             error;
1760
1761         tail_cycle = CYCLE_LSN(tail_lsn);
1762         tail_block = BLOCK_LSN(tail_lsn);
1763         head_cycle = log->l_curr_cycle;
1764         head_block = log->l_curr_block;
1765
1766         /*
1767          * Figure out the distance between the new head of the log
1768          * and the tail.  We want to write over any blocks beyond the
1769          * head that we may have written just before the crash, but
1770          * we don't want to overwrite the tail of the log.
1771          */
1772         if (head_cycle == tail_cycle) {
1773                 /*
1774                  * The tail is behind the head in the physical log,
1775                  * so the distance from the head to the tail is the
1776                  * distance from the head to the end of the log plus
1777                  * the distance from the beginning of the log to the
1778                  * tail.
1779                  */
1780                 if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
1781                         XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
1782                                          XFS_ERRLEVEL_LOW, log->l_mp);
1783                         return -EFSCORRUPTED;
1784                 }
1785                 tail_distance = tail_block + (log->l_logBBsize - head_block);
1786         } else {
1787                 /*
1788                  * The head is behind the tail in the physical log,
1789                  * so the distance from the head to the tail is just
1790                  * the tail block minus the head block.
1791                  */
1792                 if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
1793                         XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
1794                                          XFS_ERRLEVEL_LOW, log->l_mp);
1795                         return -EFSCORRUPTED;
1796                 }
1797                 tail_distance = tail_block - head_block;
1798         }
1799
1800         /*
1801          * If the head is right up against the tail, we can't clear
1802          * anything.
1803          */
1804         if (tail_distance <= 0) {
1805                 ASSERT(tail_distance == 0);
1806                 return 0;
1807         }
1808
1809         max_distance = XLOG_TOTAL_REC_SHIFT(log);
1810         /*
1811          * Take the smaller of the maximum amount of outstanding I/O
1812          * we could have and the distance to the tail to clear out.
1813          * We take the smaller so that we don't overwrite the tail and
1814          * we don't waste all day writing from the head to the tail
1815          * for no reason.
1816          */
1817         max_distance = min(max_distance, tail_distance);
1818
1819         if ((head_block + max_distance) <= log->l_logBBsize) {
1820                 /*
1821                  * We can stomp all the blocks we need to without
1822                  * wrapping around the end of the log.  Just do it
1823                  * in a single write.  Use the cycle number of the
1824                  * current cycle minus one so that the log will look like:
1825                  *     n ... | n - 1 ...
1826                  */
1827                 error = xlog_write_log_records(log, (head_cycle - 1),
1828                                 head_block, max_distance, tail_cycle,
1829                                 tail_block);
1830                 if (error)
1831                         return error;
1832         } else {
1833                 /*
1834                  * We need to wrap around the end of the physical log in
1835                  * order to clear all the blocks.  Do it in two separate
1836                  * I/Os.  The first write should be from the head to the
1837                  * end of the physical log, and it should use the current
1838                  * cycle number minus one just like above.
1839                  */
1840                 distance = log->l_logBBsize - head_block;
1841                 error = xlog_write_log_records(log, (head_cycle - 1),
1842                                 head_block, distance, tail_cycle,
1843                                 tail_block);
1844
1845                 if (error)
1846                         return error;
1847
1848                 /*
1849                  * Now write the blocks at the start of the physical log.
1850                  * This writes the remainder of the blocks we want to clear.
1851                  * It uses the current cycle number since we're now on the
1852                  * same cycle as the head so that we get:
1853                  *    n ... n ... | n - 1 ...
1854                  *    ^^^^^ blocks we're writing
1855                  */
1856                 distance = max_distance - (log->l_logBBsize - head_block);
1857                 error = xlog_write_log_records(log, head_cycle, 0, distance,
1858                                 tail_cycle, tail_block);
1859                 if (error)
1860                         return error;
1861         }
1862
1863         return 0;
1864 }
1865
1866 /******************************************************************************
1867  *
1868  *              Log recover routines
1869  *
1870  ******************************************************************************
1871  */
1872
1873 /*
1874  * Sort the log items in the transaction.
1875  *
1876  * The ordering constraints are defined by the inode allocation and unlink
1877  * behaviour. The rules are:
1878  *
1879  *      1. Every item is only logged once in a given transaction. Hence it
1880  *         represents the last logged state of the item. Hence ordering is
1881  *         dependent on the order in which operations need to be performed so
1882  *         required initial conditions are always met.
1883  *
1884  *      2. Cancelled buffers are recorded in pass 1 in a separate table and
1885  *         there's nothing to replay from them so we can simply cull them
1886  *         from the transaction. However, we can't do that until after we've
1887  *         replayed all the other items because they may be dependent on the
1888  *         cancelled buffer and replaying the cancelled buffer can remove it
1889  *         form the cancelled buffer table. Hence they have tobe done last.
1890  *
1891  *      3. Inode allocation buffers must be replayed before inode items that
1892  *         read the buffer and replay changes into it. For filesystems using the
1893  *         ICREATE transactions, this means XFS_LI_ICREATE objects need to get
1894  *         treated the same as inode allocation buffers as they create and
1895  *         initialise the buffers directly.
1896  *
1897  *      4. Inode unlink buffers must be replayed after inode items are replayed.
1898  *         This ensures that inodes are completely flushed to the inode buffer
1899  *         in a "free" state before we remove the unlinked inode list pointer.
1900  *
1901  * Hence the ordering needs to be inode allocation buffers first, inode items
1902  * second, inode unlink buffers third and cancelled buffers last.
1903  *
1904  * But there's a problem with that - we can't tell an inode allocation buffer
1905  * apart from a regular buffer, so we can't separate them. We can, however,
1906  * tell an inode unlink buffer from the others, and so we can separate them out
1907  * from all the other buffers and move them to last.
1908  *
1909  * Hence, 4 lists, in order from head to tail:
1910  *      - buffer_list for all buffers except cancelled/inode unlink buffers
1911  *      - item_list for all non-buffer items
1912  *      - inode_buffer_list for inode unlink buffers
1913  *      - cancel_list for the cancelled buffers
1914  *
1915  * Note that we add objects to the tail of the lists so that first-to-last
1916  * ordering is preserved within the lists. Adding objects to the head of the
1917  * list means when we traverse from the head we walk them in last-to-first
1918  * order. For cancelled buffers and inode unlink buffers this doesn't matter,
1919  * but for all other items there may be specific ordering that we need to
1920  * preserve.
1921  */
1922 STATIC int
1923 xlog_recover_reorder_trans(
1924         struct xlog             *log,
1925         struct xlog_recover     *trans,
1926         int                     pass)
1927 {
1928         xlog_recover_item_t     *item, *n;
1929         int                     error = 0;
1930         LIST_HEAD(sort_list);
1931         LIST_HEAD(cancel_list);
1932         LIST_HEAD(buffer_list);
1933         LIST_HEAD(inode_buffer_list);
1934         LIST_HEAD(inode_list);
1935
1936         list_splice_init(&trans->r_itemq, &sort_list);
1937         list_for_each_entry_safe(item, n, &sort_list, ri_list) {
1938                 xfs_buf_log_format_t    *buf_f = item->ri_buf[0].i_addr;
1939
1940                 switch (ITEM_TYPE(item)) {
1941                 case XFS_LI_ICREATE:
1942                         list_move_tail(&item->ri_list, &buffer_list);
1943                         break;
1944                 case XFS_LI_BUF:
1945                         if (buf_f->blf_flags & XFS_BLF_CANCEL) {
1946                                 trace_xfs_log_recover_item_reorder_head(log,
1947                                                         trans, item, pass);
1948                                 list_move(&item->ri_list, &cancel_list);
1949                                 break;
1950                         }
1951                         if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
1952                                 list_move(&item->ri_list, &inode_buffer_list);
1953                                 break;
1954                         }
1955                         list_move_tail(&item->ri_list, &buffer_list);
1956                         break;
1957                 case XFS_LI_INODE:
1958                 case XFS_LI_DQUOT:
1959                 case XFS_LI_QUOTAOFF:
1960                 case XFS_LI_EFD:
1961                 case XFS_LI_EFI:
1962                 case XFS_LI_RUI:
1963                 case XFS_LI_RUD:
1964                 case XFS_LI_CUI:
1965                 case XFS_LI_CUD:
1966                 case XFS_LI_BUI:
1967                 case XFS_LI_BUD:
1968                         trace_xfs_log_recover_item_reorder_tail(log,
1969                                                         trans, item, pass);
1970                         list_move_tail(&item->ri_list, &inode_list);
1971                         break;
1972                 default:
1973                         xfs_warn(log->l_mp,
1974                                 "%s: unrecognized type of log operation",
1975                                 __func__);
1976                         ASSERT(0);
1977                         /*
1978                          * return the remaining items back to the transaction
1979                          * item list so they can be freed in caller.
1980                          */
1981                         if (!list_empty(&sort_list))
1982                                 list_splice_init(&sort_list, &trans->r_itemq);
1983                         error = -EIO;
1984                         goto out;
1985                 }
1986         }
1987 out:
1988         ASSERT(list_empty(&sort_list));
1989         if (!list_empty(&buffer_list))
1990                 list_splice(&buffer_list, &trans->r_itemq);
1991         if (!list_empty(&inode_list))
1992                 list_splice_tail(&inode_list, &trans->r_itemq);
1993         if (!list_empty(&inode_buffer_list))
1994                 list_splice_tail(&inode_buffer_list, &trans->r_itemq);
1995         if (!list_empty(&cancel_list))
1996                 list_splice_tail(&cancel_list, &trans->r_itemq);
1997         return error;
1998 }
1999
2000 /*
2001  * Build up the table of buf cancel records so that we don't replay
2002  * cancelled data in the second pass.  For buffer records that are
2003  * not cancel records, there is nothing to do here so we just return.
2004  *
2005  * If we get a cancel record which is already in the table, this indicates
2006  * that the buffer was cancelled multiple times.  In order to ensure
2007  * that during pass 2 we keep the record in the table until we reach its
2008  * last occurrence in the log, we keep a reference count in the cancel
2009  * record in the table to tell us how many times we expect to see this
2010  * record during the second pass.
2011  */
2012 STATIC int
2013 xlog_recover_buffer_pass1(
2014         struct xlog                     *log,
2015         struct xlog_recover_item        *item)
2016 {
2017         xfs_buf_log_format_t    *buf_f = item->ri_buf[0].i_addr;
2018         struct list_head        *bucket;
2019         struct xfs_buf_cancel   *bcp;
2020
2021         /*
2022          * If this isn't a cancel buffer item, then just return.
2023          */
2024         if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
2025                 trace_xfs_log_recover_buf_not_cancel(log, buf_f);
2026                 return 0;
2027         }
2028
2029         /*
2030          * Insert an xfs_buf_cancel record into the hash table of them.
2031          * If there is already an identical record, bump its reference count.
2032          */
2033         bucket = XLOG_BUF_CANCEL_BUCKET(log, buf_f->blf_blkno);
2034         list_for_each_entry(bcp, bucket, bc_list) {
2035                 if (bcp->bc_blkno == buf_f->blf_blkno &&
2036                     bcp->bc_len == buf_f->blf_len) {
2037                         bcp->bc_refcount++;
2038                         trace_xfs_log_recover_buf_cancel_ref_inc(log, buf_f);
2039                         return 0;
2040                 }
2041         }
2042
2043         bcp = kmem_alloc(sizeof(struct xfs_buf_cancel), KM_SLEEP);
2044         bcp->bc_blkno = buf_f->blf_blkno;
2045         bcp->bc_len = buf_f->blf_len;
2046         bcp->bc_refcount = 1;
2047         list_add_tail(&bcp->bc_list, bucket);
2048
2049         trace_xfs_log_recover_buf_cancel_add(log, buf_f);
2050         return 0;
2051 }
2052
2053 /*
2054  * Check to see whether the buffer being recovered has a corresponding
2055  * entry in the buffer cancel record table. If it is, return the cancel
2056  * buffer structure to the caller.
2057  */
2058 STATIC struct xfs_buf_cancel *
2059 xlog_peek_buffer_cancelled(
2060         struct xlog             *log,
2061         xfs_daddr_t             blkno,
2062         uint                    len,
2063         unsigned short                  flags)
2064 {
2065         struct list_head        *bucket;
2066         struct xfs_buf_cancel   *bcp;
2067
2068         if (!log->l_buf_cancel_table) {
2069                 /* empty table means no cancelled buffers in the log */
2070                 ASSERT(!(flags & XFS_BLF_CANCEL));
2071                 return NULL;
2072         }
2073
2074         bucket = XLOG_BUF_CANCEL_BUCKET(log, blkno);
2075         list_for_each_entry(bcp, bucket, bc_list) {
2076                 if (bcp->bc_blkno == blkno && bcp->bc_len == len)
2077                         return bcp;
2078         }
2079
2080         /*
2081          * We didn't find a corresponding entry in the table, so return 0 so
2082          * that the buffer is NOT cancelled.
2083          */
2084         ASSERT(!(flags & XFS_BLF_CANCEL));
2085         return NULL;
2086 }
2087
2088 /*
2089  * If the buffer is being cancelled then return 1 so that it will be cancelled,
2090  * otherwise return 0.  If the buffer is actually a buffer cancel item
2091  * (XFS_BLF_CANCEL is set), then decrement the refcount on the entry in the
2092  * table and remove it from the table if this is the last reference.
2093  *
2094  * We remove the cancel record from the table when we encounter its last
2095  * occurrence in the log so that if the same buffer is re-used again after its
2096  * last cancellation we actually replay the changes made at that point.
2097  */
2098 STATIC int
2099 xlog_check_buffer_cancelled(
2100         struct xlog             *log,
2101         xfs_daddr_t             blkno,
2102         uint                    len,
2103         unsigned short                  flags)
2104 {
2105         struct xfs_buf_cancel   *bcp;
2106
2107         bcp = xlog_peek_buffer_cancelled(log, blkno, len, flags);
2108         if (!bcp)
2109                 return 0;
2110
2111         /*
2112          * We've go a match, so return 1 so that the recovery of this buffer
2113          * is cancelled.  If this buffer is actually a buffer cancel log
2114          * item, then decrement the refcount on the one in the table and
2115          * remove it if this is the last reference.
2116          */
2117         if (flags & XFS_BLF_CANCEL) {
2118                 if (--bcp->bc_refcount == 0) {
2119                         list_del(&bcp->bc_list);
2120                         kmem_free(bcp);
2121                 }
2122         }
2123         return 1;
2124 }
2125
2126 /*
2127  * Perform recovery for a buffer full of inodes.  In these buffers, the only
2128  * data which should be recovered is that which corresponds to the
2129  * di_next_unlinked pointers in the on disk inode structures.  The rest of the
2130  * data for the inodes is always logged through the inodes themselves rather
2131  * than the inode buffer and is recovered in xlog_recover_inode_pass2().
2132  *
2133  * The only time when buffers full of inodes are fully recovered is when the
2134  * buffer is full of newly allocated inodes.  In this case the buffer will
2135  * not be marked as an inode buffer and so will be sent to
2136  * xlog_recover_do_reg_buffer() below during recovery.
2137  */
2138 STATIC int
2139 xlog_recover_do_inode_buffer(
2140         struct xfs_mount        *mp,
2141         xlog_recover_item_t     *item,
2142         struct xfs_buf          *bp,
2143         xfs_buf_log_format_t    *buf_f)
2144 {
2145         int                     i;
2146         int                     item_index = 0;
2147         int                     bit = 0;
2148         int                     nbits = 0;
2149         int                     reg_buf_offset = 0;
2150         int                     reg_buf_bytes = 0;
2151         int                     next_unlinked_offset;
2152         int                     inodes_per_buf;
2153         xfs_agino_t             *logged_nextp;
2154         xfs_agino_t             *buffer_nextp;
2155
2156         trace_xfs_log_recover_buf_inode_buf(mp->m_log, buf_f);
2157
2158         /*
2159          * Post recovery validation only works properly on CRC enabled
2160          * filesystems.
2161          */
2162         if (xfs_sb_version_hascrc(&mp->m_sb))
2163                 bp->b_ops = &xfs_inode_buf_ops;
2164
2165         inodes_per_buf = BBTOB(bp->b_io_length) >> mp->m_sb.sb_inodelog;
2166         for (i = 0; i < inodes_per_buf; i++) {
2167                 next_unlinked_offset = (i * mp->m_sb.sb_inodesize) +
2168                         offsetof(xfs_dinode_t, di_next_unlinked);
2169
2170                 while (next_unlinked_offset >=
2171                        (reg_buf_offset + reg_buf_bytes)) {
2172                         /*
2173                          * The next di_next_unlinked field is beyond
2174                          * the current logged region.  Find the next
2175                          * logged region that contains or is beyond
2176                          * the current di_next_unlinked field.
2177                          */
2178                         bit += nbits;
2179                         bit = xfs_next_bit(buf_f->blf_data_map,
2180                                            buf_f->blf_map_size, bit);
2181
2182                         /*
2183                          * If there are no more logged regions in the
2184                          * buffer, then we're done.
2185                          */
2186                         if (bit == -1)
2187                                 return 0;
2188
2189                         nbits = xfs_contig_bits(buf_f->blf_data_map,
2190                                                 buf_f->blf_map_size, bit);
2191                         ASSERT(nbits > 0);
2192                         reg_buf_offset = bit << XFS_BLF_SHIFT;
2193                         reg_buf_bytes = nbits << XFS_BLF_SHIFT;
2194                         item_index++;
2195                 }
2196
2197                 /*
2198                  * If the current logged region starts after the current
2199                  * di_next_unlinked field, then move on to the next
2200                  * di_next_unlinked field.
2201                  */
2202                 if (next_unlinked_offset < reg_buf_offset)
2203                         continue;
2204
2205                 ASSERT(item->ri_buf[item_index].i_addr != NULL);
2206                 ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0);
2207                 ASSERT((reg_buf_offset + reg_buf_bytes) <=
2208                                                         BBTOB(bp->b_io_length));
2209
2210                 /*
2211                  * The current logged region contains a copy of the
2212                  * current di_next_unlinked field.  Extract its value
2213                  * and copy it to the buffer copy.
2214                  */
2215                 logged_nextp = item->ri_buf[item_index].i_addr +
2216                                 next_unlinked_offset - reg_buf_offset;
2217                 if (unlikely(*logged_nextp == 0)) {
2218                         xfs_alert(mp,
2219                 "Bad inode buffer log record (ptr = "PTR_FMT", bp = "PTR_FMT"). "
2220                 "Trying to replay bad (0) inode di_next_unlinked field.",
2221                                 item, bp);
2222                         XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
2223                                          XFS_ERRLEVEL_LOW, mp);
2224                         return -EFSCORRUPTED;
2225                 }
2226
2227                 buffer_nextp = xfs_buf_offset(bp, next_unlinked_offset);
2228                 *buffer_nextp = *logged_nextp;
2229
2230                 /*
2231                  * If necessary, recalculate the CRC in the on-disk inode. We
2232                  * have to leave the inode in a consistent state for whoever
2233                  * reads it next....
2234                  */
2235                 xfs_dinode_calc_crc(mp,
2236                                 xfs_buf_offset(bp, i * mp->m_sb.sb_inodesize));
2237
2238         }
2239
2240         return 0;
2241 }
2242
2243 /*
2244  * V5 filesystems know the age of the buffer on disk being recovered. We can
2245  * have newer objects on disk than we are replaying, and so for these cases we
2246  * don't want to replay the current change as that will make the buffer contents
2247  * temporarily invalid on disk.
2248  *
2249  * The magic number might not match the buffer type we are going to recover
2250  * (e.g. reallocated blocks), so we ignore the xfs_buf_log_format flags.  Hence
2251  * extract the LSN of the existing object in the buffer based on it's current
2252  * magic number.  If we don't recognise the magic number in the buffer, then
2253  * return a LSN of -1 so that the caller knows it was an unrecognised block and
2254  * so can recover the buffer.
2255  *
2256  * Note: we cannot rely solely on magic number matches to determine that the
2257  * buffer has a valid LSN - we also need to verify that it belongs to this
2258  * filesystem, so we need to extract the object's LSN and compare it to that
2259  * which we read from the superblock. If the UUIDs don't match, then we've got a
2260  * stale metadata block from an old filesystem instance that we need to recover
2261  * over the top of.
2262  */
2263 static xfs_lsn_t
2264 xlog_recover_get_buf_lsn(
2265         struct xfs_mount        *mp,
2266         struct xfs_buf          *bp)
2267 {
2268         uint32_t                magic32;
2269         uint16_t                magic16;
2270         uint16_t                magicda;
2271         void                    *blk = bp->b_addr;
2272         uuid_t                  *uuid;
2273         xfs_lsn_t               lsn = -1;
2274
2275         /* v4 filesystems always recover immediately */
2276         if (!xfs_sb_version_hascrc(&mp->m_sb))
2277                 goto recover_immediately;
2278
2279         magic32 = be32_to_cpu(*(__be32 *)blk);
2280         switch (magic32) {
2281         case XFS_ABTB_CRC_MAGIC:
2282         case XFS_ABTC_CRC_MAGIC:
2283         case XFS_ABTB_MAGIC:
2284         case XFS_ABTC_MAGIC:
2285         case XFS_RMAP_CRC_MAGIC:
2286         case XFS_REFC_CRC_MAGIC:
2287         case XFS_IBT_CRC_MAGIC:
2288         case XFS_IBT_MAGIC: {
2289                 struct xfs_btree_block *btb = blk;
2290
2291                 lsn = be64_to_cpu(btb->bb_u.s.bb_lsn);
2292                 uuid = &btb->bb_u.s.bb_uuid;
2293                 break;
2294         }
2295         case XFS_BMAP_CRC_MAGIC:
2296         case XFS_BMAP_MAGIC: {
2297                 struct xfs_btree_block *btb = blk;
2298
2299                 lsn = be64_to_cpu(btb->bb_u.l.bb_lsn);
2300                 uuid = &btb->bb_u.l.bb_uuid;
2301                 break;
2302         }
2303         case XFS_AGF_MAGIC:
2304                 lsn = be64_to_cpu(((struct xfs_agf *)blk)->agf_lsn);
2305                 uuid = &((struct xfs_agf *)blk)->agf_uuid;
2306                 break;
2307         case XFS_AGFL_MAGIC:
2308                 lsn = be64_to_cpu(((struct xfs_agfl *)blk)->agfl_lsn);
2309                 uuid = &((struct xfs_agfl *)blk)->agfl_uuid;
2310                 break;
2311         case XFS_AGI_MAGIC:
2312                 lsn = be64_to_cpu(((struct xfs_agi *)blk)->agi_lsn);
2313                 uuid = &((struct xfs_agi *)blk)->agi_uuid;
2314                 break;
2315         case XFS_SYMLINK_MAGIC:
2316                 lsn = be64_to_cpu(((struct xfs_dsymlink_hdr *)blk)->sl_lsn);
2317                 uuid = &((struct xfs_dsymlink_hdr *)blk)->sl_uuid;
2318                 break;
2319         case XFS_DIR3_BLOCK_MAGIC:
2320         case XFS_DIR3_DATA_MAGIC:
2321         case XFS_DIR3_FREE_MAGIC:
2322                 lsn = be64_to_cpu(((struct xfs_dir3_blk_hdr *)blk)->lsn);
2323                 uuid = &((struct xfs_dir3_blk_hdr *)blk)->uuid;
2324                 break;
2325         case XFS_ATTR3_RMT_MAGIC:
2326                 /*
2327                  * Remote attr blocks are written synchronously, rather than
2328                  * being logged. That means they do not contain a valid LSN
2329                  * (i.e. transactionally ordered) in them, and hence any time we
2330                  * see a buffer to replay over the top of a remote attribute
2331                  * block we should simply do so.
2332                  */
2333                 goto recover_immediately;
2334         case XFS_SB_MAGIC:
2335                 /*
2336                  * superblock uuids are magic. We may or may not have a
2337                  * sb_meta_uuid on disk, but it will be set in the in-core
2338                  * superblock. We set the uuid pointer for verification
2339                  * according to the superblock feature mask to ensure we check
2340                  * the relevant UUID in the superblock.
2341                  */
2342                 lsn = be64_to_cpu(((struct xfs_dsb *)blk)->sb_lsn);
2343                 if (xfs_sb_version_hasmetauuid(&mp->m_sb))
2344                         uuid = &((struct xfs_dsb *)blk)->sb_meta_uuid;
2345                 else
2346                         uuid = &((struct xfs_dsb *)blk)->sb_uuid;
2347                 break;
2348         default:
2349                 break;
2350         }
2351
2352         if (lsn != (xfs_lsn_t)-1) {
2353                 if (!uuid_equal(&mp->m_sb.sb_meta_uuid, uuid))
2354                         goto recover_immediately;
2355                 return lsn;
2356         }
2357
2358         magicda = be16_to_cpu(((struct xfs_da_blkinfo *)blk)->magic);
2359         switch (magicda) {
2360         case XFS_DIR3_LEAF1_MAGIC:
2361         case XFS_DIR3_LEAFN_MAGIC:
2362         case XFS_DA3_NODE_MAGIC:
2363                 lsn = be64_to_cpu(((struct xfs_da3_blkinfo *)blk)->lsn);
2364                 uuid = &((struct xfs_da3_blkinfo *)blk)->uuid;
2365                 break;
2366         default:
2367                 break;
2368         }
2369
2370         if (lsn != (xfs_lsn_t)-1) {
2371                 if (!uuid_equal(&mp->m_sb.sb_uuid, uuid))
2372                         goto recover_immediately;
2373                 return lsn;
2374         }
2375
2376         /*
2377          * We do individual object checks on dquot and inode buffers as they
2378          * have their own individual LSN records. Also, we could have a stale
2379          * buffer here, so we have to at least recognise these buffer types.
2380          *
2381          * A notd complexity here is inode unlinked list processing - it logs
2382          * the inode directly in the buffer, but we don't know which inodes have
2383          * been modified, and there is no global buffer LSN. Hence we need to
2384          * recover all inode buffer types immediately. This problem will be
2385          * fixed by logical logging of the unlinked list modifications.
2386          */
2387         magic16 = be16_to_cpu(*(__be16 *)blk);
2388         switch (magic16) {
2389         case XFS_DQUOT_MAGIC:
2390         case XFS_DINODE_MAGIC:
2391                 goto recover_immediately;
2392         default:
2393                 break;
2394         }
2395
2396         /* unknown buffer contents, recover immediately */
2397
2398 recover_immediately:
2399         return (xfs_lsn_t)-1;
2400
2401 }
2402
2403 /*
2404  * Validate the recovered buffer is of the correct type and attach the
2405  * appropriate buffer operations to them for writeback. Magic numbers are in a
2406  * few places:
2407  *      the first 16 bits of the buffer (inode buffer, dquot buffer),
2408  *      the first 32 bits of the buffer (most blocks),
2409  *      inside a struct xfs_da_blkinfo at the start of the buffer.
2410  */
2411 static void
2412 xlog_recover_validate_buf_type(
2413         struct xfs_mount        *mp,
2414         struct xfs_buf          *bp,
2415         xfs_buf_log_format_t    *buf_f,
2416         xfs_lsn_t               current_lsn)
2417 {
2418         struct xfs_da_blkinfo   *info = bp->b_addr;
2419         uint32_t                magic32;
2420         uint16_t                magic16;
2421         uint16_t                magicda;
2422         char                    *warnmsg = NULL;
2423
2424         /*
2425          * We can only do post recovery validation on items on CRC enabled
2426          * fielsystems as we need to know when the buffer was written to be able
2427          * to determine if we should have replayed the item. If we replay old
2428          * metadata over a newer buffer, then it will enter a temporarily
2429          * inconsistent state resulting in verification failures. Hence for now
2430          * just avoid the verification stage for non-crc filesystems
2431          */
2432         if (!xfs_sb_version_hascrc(&mp->m_sb))
2433                 return;
2434
2435         magic32 = be32_to_cpu(*(__be32 *)bp->b_addr);
2436         magic16 = be16_to_cpu(*(__be16*)bp->b_addr);
2437         magicda = be16_to_cpu(info->magic);
2438         switch (xfs_blft_from_flags(buf_f)) {
2439         case XFS_BLFT_BTREE_BUF:
2440                 switch (magic32) {
2441                 case XFS_ABTB_CRC_MAGIC:
2442                 case XFS_ABTC_CRC_MAGIC:
2443                 case XFS_ABTB_MAGIC:
2444                 case XFS_ABTC_MAGIC:
2445                         bp->b_ops = &xfs_allocbt_buf_ops;
2446                         break;
2447                 case XFS_IBT_CRC_MAGIC:
2448                 case XFS_FIBT_CRC_MAGIC:
2449                 case XFS_IBT_MAGIC:
2450                 case XFS_FIBT_MAGIC:
2451                         bp->b_ops = &xfs_inobt_buf_ops;
2452                         break;
2453                 case XFS_BMAP_CRC_MAGIC:
2454                 case XFS_BMAP_MAGIC:
2455                         bp->b_ops = &xfs_bmbt_buf_ops;
2456                         break;
2457                 case XFS_RMAP_CRC_MAGIC:
2458                         bp->b_ops = &xfs_rmapbt_buf_ops;
2459                         break;
2460                 case XFS_REFC_CRC_MAGIC:
2461                         bp->b_ops = &xfs_refcountbt_buf_ops;
2462                         break;
2463                 default:
2464                         warnmsg = "Bad btree block magic!";
2465                         break;
2466                 }
2467                 break;
2468         case XFS_BLFT_AGF_BUF:
2469                 if (magic32 != XFS_AGF_MAGIC) {
2470                         warnmsg = "Bad AGF block magic!";
2471                         break;
2472                 }
2473                 bp->b_ops = &xfs_agf_buf_ops;
2474                 break;
2475         case XFS_BLFT_AGFL_BUF:
2476                 if (magic32 != XFS_AGFL_MAGIC) {
2477                         warnmsg = "Bad AGFL block magic!";
2478                         break;
2479                 }
2480                 bp->b_ops = &xfs_agfl_buf_ops;
2481                 break;
2482         case XFS_BLFT_AGI_BUF:
2483                 if (magic32 != XFS_AGI_MAGIC) {
2484                         warnmsg = "Bad AGI block magic!";
2485                         break;
2486                 }
2487                 bp->b_ops = &xfs_agi_buf_ops;
2488                 break;
2489         case XFS_BLFT_UDQUOT_BUF:
2490         case XFS_BLFT_PDQUOT_BUF:
2491         case XFS_BLFT_GDQUOT_BUF:
2492 #ifdef CONFIG_XFS_QUOTA
2493                 if (magic16 != XFS_DQUOT_MAGIC) {
2494                         warnmsg = "Bad DQUOT block magic!";
2495                         break;
2496                 }
2497                 bp->b_ops = &xfs_dquot_buf_ops;
2498 #else
2499                 xfs_alert(mp,
2500         "Trying to recover dquots without QUOTA support built in!");
2501                 ASSERT(0);
2502 #endif
2503                 break;
2504         case XFS_BLFT_DINO_BUF:
2505                 if (magic16 != XFS_DINODE_MAGIC) {
2506                         warnmsg = "Bad INODE block magic!";
2507                         break;
2508                 }
2509                 bp->b_ops = &xfs_inode_buf_ops;
2510                 break;
2511         case XFS_BLFT_SYMLINK_BUF:
2512                 if (magic32 != XFS_SYMLINK_MAGIC) {
2513                         warnmsg = "Bad symlink block magic!";
2514                         break;
2515                 }
2516                 bp->b_ops = &xfs_symlink_buf_ops;
2517                 break;
2518         case XFS_BLFT_DIR_BLOCK_BUF:
2519                 if (magic32 != XFS_DIR2_BLOCK_MAGIC &&
2520                     magic32 != XFS_DIR3_BLOCK_MAGIC) {
2521                         warnmsg = "Bad dir block magic!";
2522                         break;
2523                 }
2524                 bp->b_ops = &xfs_dir3_block_buf_ops;
2525                 break;
2526         case XFS_BLFT_DIR_DATA_BUF:
2527                 if (magic32 != XFS_DIR2_DATA_MAGIC &&
2528                     magic32 != XFS_DIR3_DATA_MAGIC) {
2529                         warnmsg = "Bad dir data magic!";
2530                         break;
2531                 }
2532                 bp->b_ops = &xfs_dir3_data_buf_ops;
2533                 break;
2534         case XFS_BLFT_DIR_FREE_BUF:
2535                 if (magic32 != XFS_DIR2_FREE_MAGIC &&
2536                     magic32 != XFS_DIR3_FREE_MAGIC) {
2537                         warnmsg = "Bad dir3 free magic!";
2538                         break;
2539                 }
2540                 bp->b_ops = &xfs_dir3_free_buf_ops;
2541                 break;
2542         case XFS_BLFT_DIR_LEAF1_BUF:
2543                 if (magicda != XFS_DIR2_LEAF1_MAGIC &&
2544                     magicda != XFS_DIR3_LEAF1_MAGIC) {
2545                         warnmsg = "Bad dir leaf1 magic!";
2546                         break;
2547                 }
2548                 bp->b_ops = &xfs_dir3_leaf1_buf_ops;
2549                 break;
2550         case XFS_BLFT_DIR_LEAFN_BUF:
2551                 if (magicda != XFS_DIR2_LEAFN_MAGIC &&
2552                     magicda != XFS_DIR3_LEAFN_MAGIC) {
2553                         warnmsg = "Bad dir leafn magic!";
2554                         break;
2555                 }
2556                 bp->b_ops = &xfs_dir3_leafn_buf_ops;
2557                 break;
2558         case XFS_BLFT_DA_NODE_BUF:
2559                 if (magicda != XFS_DA_NODE_MAGIC &&
2560                     magicda != XFS_DA3_NODE_MAGIC) {
2561                         warnmsg = "Bad da node magic!";
2562                         break;
2563                 }
2564                 bp->b_ops = &xfs_da3_node_buf_ops;
2565                 break;
2566         case XFS_BLFT_ATTR_LEAF_BUF:
2567                 if (magicda != XFS_ATTR_LEAF_MAGIC &&
2568                     magicda != XFS_ATTR3_LEAF_MAGIC) {
2569                         warnmsg = "Bad attr leaf magic!";
2570                         break;
2571                 }
2572                 bp->b_ops = &xfs_attr3_leaf_buf_ops;
2573                 break;
2574         case XFS_BLFT_ATTR_RMT_BUF:
2575                 if (magic32 != XFS_ATTR3_RMT_MAGIC) {
2576                         warnmsg = "Bad attr remote magic!";
2577                         break;
2578                 }
2579                 bp->b_ops = &xfs_attr3_rmt_buf_ops;
2580                 break;
2581         case XFS_BLFT_SB_BUF:
2582                 if (magic32 != XFS_SB_MAGIC) {
2583                         warnmsg = "Bad SB block magic!";
2584                         break;
2585                 }
2586                 bp->b_ops = &xfs_sb_buf_ops;
2587                 break;
2588 #ifdef CONFIG_XFS_RT
2589         case XFS_BLFT_RTBITMAP_BUF:
2590         case XFS_BLFT_RTSUMMARY_BUF:
2591                 /* no magic numbers for verification of RT buffers */
2592                 bp->b_ops = &xfs_rtbuf_ops;
2593                 break;
2594 #endif /* CONFIG_XFS_RT */
2595         default:
2596                 xfs_warn(mp, "Unknown buffer type %d!",
2597                          xfs_blft_from_flags(buf_f));
2598                 break;
2599         }
2600
2601         /*
2602          * Nothing else to do in the case of a NULL current LSN as this means
2603          * the buffer is more recent than the change in the log and will be
2604          * skipped.
2605          */
2606         if (current_lsn == NULLCOMMITLSN)
2607                 return;
2608
2609         if (warnmsg) {
2610                 xfs_warn(mp, warnmsg);
2611                 ASSERT(0);
2612         }
2613
2614         /*
2615          * We must update the metadata LSN of the buffer as it is written out to
2616          * ensure that older transactions never replay over this one and corrupt
2617          * the buffer. This can occur if log recovery is interrupted at some
2618          * point after the current transaction completes, at which point a
2619          * subsequent mount starts recovery from the beginning.
2620          *
2621          * Write verifiers update the metadata LSN from log items attached to
2622          * the buffer. Therefore, initialize a bli purely to carry the LSN to
2623          * the verifier. We'll clean it up in our ->iodone() callback.
2624          */
2625         if (bp->b_ops) {
2626                 struct xfs_buf_log_item *bip;
2627
2628                 ASSERT(!bp->b_iodone || bp->b_iodone == xlog_recover_iodone);
2629                 bp->b_iodone = xlog_recover_iodone;
2630                 xfs_buf_item_init(bp, mp);
2631                 bip = bp->b_log_item;
2632                 bip->bli_item.li_lsn = current_lsn;
2633         }
2634 }
2635
2636 /*
2637  * Perform a 'normal' buffer recovery.  Each logged region of the
2638  * buffer should be copied over the corresponding region in the
2639  * given buffer.  The bitmap in the buf log format structure indicates
2640  * where to place the logged data.
2641  */
2642 STATIC void
2643 xlog_recover_do_reg_buffer(
2644         struct xfs_mount        *mp,
2645         xlog_recover_item_t     *item,
2646         struct xfs_buf          *bp,
2647         xfs_buf_log_format_t    *buf_f,
2648         xfs_lsn_t               current_lsn)
2649 {
2650         int                     i;
2651         int                     bit;
2652         int                     nbits;
2653         xfs_failaddr_t          fa;
2654
2655         trace_xfs_log_recover_buf_reg_buf(mp->m_log, buf_f);
2656
2657         bit = 0;
2658         i = 1;  /* 0 is the buf format structure */
2659         while (1) {
2660                 bit = xfs_next_bit(buf_f->blf_data_map,
2661                                    buf_f->blf_map_size, bit);
2662                 if (bit == -1)
2663                         break;
2664                 nbits = xfs_contig_bits(buf_f->blf_data_map,
2665                                         buf_f->blf_map_size, bit);
2666                 ASSERT(nbits > 0);
2667                 ASSERT(item->ri_buf[i].i_addr != NULL);
2668                 ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0);
2669                 ASSERT(BBTOB(bp->b_io_length) >=
2670                        ((uint)bit << XFS_BLF_SHIFT) + (nbits << XFS_BLF_SHIFT));
2671
2672                 /*
2673                  * The dirty regions logged in the buffer, even though
2674                  * contiguous, may span multiple chunks. This is because the
2675                  * dirty region may span a physical page boundary in a buffer
2676                  * and hence be split into two separate vectors for writing into
2677                  * the log. Hence we need to trim nbits back to the length of
2678                  * the current region being copied out of the log.
2679                  */
2680                 if (item->ri_buf[i].i_len < (nbits << XFS_BLF_SHIFT))
2681                         nbits = item->ri_buf[i].i_len >> XFS_BLF_SHIFT;
2682
2683                 /*
2684                  * Do a sanity check if this is a dquot buffer. Just checking
2685                  * the first dquot in the buffer should do. XXXThis is
2686                  * probably a good thing to do for other buf types also.
2687                  */
2688                 fa = NULL;
2689                 if (buf_f->blf_flags &
2690                    (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
2691                         if (item->ri_buf[i].i_addr == NULL) {
2692                                 xfs_alert(mp,
2693                                         "XFS: NULL dquot in %s.", __func__);
2694                                 goto next;
2695                         }
2696                         if (item->ri_buf[i].i_len < sizeof(xfs_disk_dquot_t)) {
2697                                 xfs_alert(mp,
2698                                         "XFS: dquot too small (%d) in %s.",
2699                                         item->ri_buf[i].i_len, __func__);
2700                                 goto next;
2701                         }
2702                         fa = xfs_dquot_verify(mp, item->ri_buf[i].i_addr,
2703                                                -1, 0);
2704                         if (fa) {
2705                                 xfs_alert(mp,
2706         "dquot corrupt at %pS trying to replay into block 0x%llx",
2707                                         fa, bp->b_bn);
2708                                 goto next;
2709                         }
2710                 }
2711
2712                 memcpy(xfs_buf_offset(bp,
2713                         (uint)bit << XFS_BLF_SHIFT),    /* dest */
2714                         item->ri_buf[i].i_addr,         /* source */
2715                         nbits<<XFS_BLF_SHIFT);          /* length */
2716  next:
2717                 i++;
2718                 bit += nbits;
2719         }
2720
2721         /* Shouldn't be any more regions */
2722         ASSERT(i == item->ri_total);
2723
2724         xlog_recover_validate_buf_type(mp, bp, buf_f, current_lsn);
2725 }
2726
2727 /*
2728  * Perform a dquot buffer recovery.
2729  * Simple algorithm: if we have found a QUOTAOFF log item of the same type
2730  * (ie. USR or GRP), then just toss this buffer away; don't recover it.
2731  * Else, treat it as a regular buffer and do recovery.
2732  *
2733  * Return false if the buffer was tossed and true if we recovered the buffer to
2734  * indicate to the caller if the buffer needs writing.
2735  */
2736 STATIC bool
2737 xlog_recover_do_dquot_buffer(
2738         struct xfs_mount                *mp,
2739         struct xlog                     *log,
2740         struct xlog_recover_item        *item,
2741         struct xfs_buf                  *bp,
2742         struct xfs_buf_log_format       *buf_f)
2743 {
2744         uint                    type;
2745
2746         trace_xfs_log_recover_buf_dquot_buf(log, buf_f);
2747
2748         /*
2749          * Filesystems are required to send in quota flags at mount time.
2750          */
2751         if (!mp->m_qflags)
2752                 return false;
2753
2754         type = 0;
2755         if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
2756                 type |= XFS_DQ_USER;
2757         if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
2758                 type |= XFS_DQ_PROJ;
2759         if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
2760                 type |= XFS_DQ_GROUP;
2761         /*
2762          * This type of quotas was turned off, so ignore this buffer
2763          */
2764         if (log->l_quotaoffs_flag & type)
2765                 return false;
2766
2767         xlog_recover_do_reg_buffer(mp, item, bp, buf_f, NULLCOMMITLSN);
2768         return true;
2769 }
2770
2771 /*
2772  * This routine replays a modification made to a buffer at runtime.
2773  * There are actually two types of buffer, regular and inode, which
2774  * are handled differently.  Inode buffers are handled differently
2775  * in that we only recover a specific set of data from them, namely
2776  * the inode di_next_unlinked fields.  This is because all other inode
2777  * data is actually logged via inode records and any data we replay
2778  * here which overlaps that may be stale.
2779  *
2780  * When meta-data buffers are freed at run time we log a buffer item
2781  * with the XFS_BLF_CANCEL bit set to indicate that previous copies
2782  * of the buffer in the log should not be replayed at recovery time.
2783  * This is so that if the blocks covered by the buffer are reused for
2784  * file data before we crash we don't end up replaying old, freed
2785  * meta-data into a user's file.
2786  *
2787  * To handle the cancellation of buffer log items, we make two passes
2788  * over the log during recovery.  During the first we build a table of
2789  * those buffers which have been cancelled, and during the second we
2790  * only replay those buffers which do not have corresponding cancel
2791  * records in the table.  See xlog_recover_buffer_pass[1,2] above
2792  * for more details on the implementation of the table of cancel records.
2793  */
2794 STATIC int
2795 xlog_recover_buffer_pass2(
2796         struct xlog                     *log,
2797         struct list_head                *buffer_list,
2798         struct xlog_recover_item        *item,
2799         xfs_lsn_t                       current_lsn)
2800 {
2801         xfs_buf_log_format_t    *buf_f = item->ri_buf[0].i_addr;
2802         xfs_mount_t             *mp = log->l_mp;
2803         xfs_buf_t               *bp;
2804         int                     error;
2805         uint                    buf_flags;
2806         xfs_lsn_t               lsn;
2807
2808         /*
2809          * In this pass we only want to recover all the buffers which have
2810          * not been cancelled and are not cancellation buffers themselves.
2811          */
2812         if (xlog_check_buffer_cancelled(log, buf_f->blf_blkno,
2813                         buf_f->blf_len, buf_f->blf_flags)) {
2814                 trace_xfs_log_recover_buf_cancel(log, buf_f);
2815                 return 0;
2816         }
2817
2818         trace_xfs_log_recover_buf_recover(log, buf_f);
2819
2820         buf_flags = 0;
2821         if (buf_f->blf_flags & XFS_BLF_INODE_BUF)
2822                 buf_flags |= XBF_UNMAPPED;
2823
2824         bp = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len,
2825                           buf_flags, NULL);
2826         if (!bp)
2827                 return -ENOMEM;
2828         error = bp->b_error;
2829         if (error) {
2830                 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
2831                 goto out_release;
2832         }
2833
2834         /*
2835          * Recover the buffer only if we get an LSN from it and it's less than
2836          * the lsn of the transaction we are replaying.
2837          *
2838          * Note that we have to be extremely careful of readahead here.
2839          * Readahead does not attach verfiers to the buffers so if we don't
2840          * actually do any replay after readahead because of the LSN we found
2841          * in the buffer if more recent than that current transaction then we
2842          * need to attach the verifier directly. Failure to do so can lead to
2843          * future recovery actions (e.g. EFI and unlinked list recovery) can
2844          * operate on the buffers and they won't get the verifier attached. This
2845          * can lead to blocks on disk having the correct content but a stale
2846          * CRC.
2847          *
2848          * It is safe to assume these clean buffers are currently up to date.
2849          * If the buffer is dirtied by a later transaction being replayed, then
2850          * the verifier will be reset to match whatever recover turns that
2851          * buffer into.
2852          */
2853         lsn = xlog_recover_get_buf_lsn(mp, bp);
2854         if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) {
2855                 trace_xfs_log_recover_buf_skip(log, buf_f);
2856                 xlog_recover_validate_buf_type(mp, bp, buf_f, NULLCOMMITLSN);
2857                 goto out_release;
2858         }
2859
2860         if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
2861                 error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
2862                 if (error)
2863                         goto out_release;
2864         } else if (buf_f->blf_flags &
2865                   (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
2866                 bool    dirty;
2867
2868                 dirty = xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
2869                 if (!dirty)
2870                         goto out_release;
2871         } else {
2872                 xlog_recover_do_reg_buffer(mp, item, bp, buf_f, current_lsn);
2873         }
2874
2875         /*
2876          * Perform delayed write on the buffer.  Asynchronous writes will be
2877          * slower when taking into account all the buffers to be flushed.
2878          *
2879          * Also make sure that only inode buffers with good sizes stay in
2880          * the buffer cache.  The kernel moves inodes in buffers of 1 block
2881          * or mp->m_inode_cluster_size bytes, whichever is bigger.  The inode
2882          * buffers in the log can be a different size if the log was generated
2883          * by an older kernel using unclustered inode buffers or a newer kernel
2884          * running with a different inode cluster size.  Regardless, if the
2885          * the inode buffer size isn't max(blocksize, mp->m_inode_cluster_size)
2886          * for *our* value of mp->m_inode_cluster_size, then we need to keep
2887          * the buffer out of the buffer cache so that the buffer won't
2888          * overlap with future reads of those inodes.
2889          */
2890         if (XFS_DINODE_MAGIC ==
2891             be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
2892             (BBTOB(bp->b_io_length) != max(log->l_mp->m_sb.sb_blocksize,
2893                         (uint32_t)log->l_mp->m_inode_cluster_size))) {
2894                 xfs_buf_stale(bp);
2895                 error = xfs_bwrite(bp);
2896         } else {
2897                 ASSERT(bp->b_target->bt_mount == mp);
2898                 bp->b_iodone = xlog_recover_iodone;
2899                 xfs_buf_delwri_queue(bp, buffer_list);
2900         }
2901
2902 out_release:
2903         xfs_buf_relse(bp);
2904         return error;
2905 }
2906
2907 /*
2908  * Inode fork owner changes
2909  *
2910  * If we have been told that we have to reparent the inode fork, it's because an
2911  * extent swap operation on a CRC enabled filesystem has been done and we are
2912  * replaying it. We need to walk the BMBT of the appropriate fork and change the
2913  * owners of it.
2914  *
2915  * The complexity here is that we don't have an inode context to work with, so
2916  * after we've replayed the inode we need to instantiate one.  This is where the
2917  * fun begins.
2918  *
2919  * We are in the middle of log recovery, so we can't run transactions. That
2920  * means we cannot use cache coherent inode instantiation via xfs_iget(), as
2921  * that will result in the corresponding iput() running the inode through
2922  * xfs_inactive(). If we've just replayed an inode core that changes the link
2923  * count to zero (i.e. it's been unlinked), then xfs_inactive() will run
2924  * transactions (bad!).
2925  *
2926  * So, to avoid this, we instantiate an inode directly from the inode core we've
2927  * just recovered. We have the buffer still locked, and all we really need to
2928  * instantiate is the inode core and the forks being modified. We can do this
2929  * manually, then run the inode btree owner change, and then tear down the
2930  * xfs_inode without having to run any transactions at all.
2931  *
2932  * Also, because we don't have a transaction context available here but need to
2933  * gather all the buffers we modify for writeback so we pass the buffer_list
2934  * instead for the operation to use.
2935  */
2936
2937 STATIC int
2938 xfs_recover_inode_owner_change(
2939         struct xfs_mount        *mp,
2940         struct xfs_dinode       *dip,
2941         struct xfs_inode_log_format *in_f,
2942         struct list_head        *buffer_list)
2943 {
2944         struct xfs_inode        *ip;
2945         int                     error;
2946
2947         ASSERT(in_f->ilf_fields & (XFS_ILOG_DOWNER|XFS_ILOG_AOWNER));
2948
2949         ip = xfs_inode_alloc(mp, in_f->ilf_ino);
2950         if (!ip)
2951                 return -ENOMEM;
2952
2953         /* instantiate the inode */
2954         xfs_inode_from_disk(ip, dip);
2955         ASSERT(ip->i_d.di_version >= 3);
2956
2957         error = xfs_iformat_fork(ip, dip);
2958         if (error)
2959                 goto out_free_ip;
2960
2961         if (!xfs_inode_verify_forks(ip)) {
2962                 error = -EFSCORRUPTED;
2963                 goto out_free_ip;
2964         }
2965
2966         if (in_f->ilf_fields & XFS_ILOG_DOWNER) {
2967                 ASSERT(in_f->ilf_fields & XFS_ILOG_DBROOT);
2968                 error = xfs_bmbt_change_owner(NULL, ip, XFS_DATA_FORK,
2969                                               ip->i_ino, buffer_list);
2970                 if (error)
2971                         goto out_free_ip;
2972         }
2973
2974         if (in_f->ilf_fields & XFS_ILOG_AOWNER) {
2975                 ASSERT(in_f->ilf_fields & XFS_ILOG_ABROOT);
2976                 error = xfs_bmbt_change_owner(NULL, ip, XFS_ATTR_FORK,
2977                                               ip->i_ino, buffer_list);
2978                 if (error)
2979                         goto out_free_ip;
2980         }
2981
2982 out_free_ip:
2983         xfs_inode_free(ip);
2984         return error;
2985 }
2986
2987 STATIC int
2988 xlog_recover_inode_pass2(
2989         struct xlog                     *log,
2990         struct list_head                *buffer_list,
2991         struct xlog_recover_item        *item,
2992         xfs_lsn_t                       current_lsn)
2993 {
2994         struct xfs_inode_log_format     *in_f;
2995         xfs_mount_t             *mp = log->l_mp;
2996         xfs_buf_t               *bp;
2997         xfs_dinode_t            *dip;
2998         int                     len;
2999         char                    *src;
3000         char                    *dest;
3001         int                     error;
3002         int                     attr_index;
3003         uint                    fields;
3004         struct xfs_log_dinode   *ldip;
3005         uint                    isize;
3006         int                     need_free = 0;
3007
3008         if (item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format)) {
3009                 in_f = item->ri_buf[0].i_addr;
3010         } else {
3011                 in_f = kmem_alloc(sizeof(struct xfs_inode_log_format), KM_SLEEP);
3012                 need_free = 1;
3013                 error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
3014                 if (error)
3015                         goto error;
3016         }
3017
3018         /*
3019          * Inode buffers can be freed, look out for it,
3020          * and do not replay the inode.
3021          */
3022         if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno,
3023                                         in_f->ilf_len, 0)) {
3024                 error = 0;
3025                 trace_xfs_log_recover_inode_cancel(log, in_f);
3026                 goto error;
3027         }
3028         trace_xfs_log_recover_inode_recover(log, in_f);
3029
3030         bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len, 0,
3031                           &xfs_inode_buf_ops);
3032         if (!bp) {
3033                 error = -ENOMEM;
3034                 goto error;
3035         }
3036         error = bp->b_error;
3037         if (error) {
3038                 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#2)");
3039                 goto out_release;
3040         }
3041         ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
3042         dip = xfs_buf_offset(bp, in_f->ilf_boffset);
3043
3044         /*
3045          * Make sure the place we're flushing out to really looks
3046          * like an inode!
3047          */
3048         if (unlikely(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC))) {
3049                 xfs_alert(mp,
3050         "%s: Bad inode magic number, dip = "PTR_FMT", dino bp = "PTR_FMT", ino = %Ld",
3051                         __func__, dip, bp, in_f->ilf_ino);
3052                 XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)",
3053                                  XFS_ERRLEVEL_LOW, mp);
3054                 error = -EFSCORRUPTED;
3055                 goto out_release;
3056         }
3057         ldip = item->ri_buf[1].i_addr;
3058         if (unlikely(ldip->di_magic != XFS_DINODE_MAGIC)) {
3059                 xfs_alert(mp,
3060                         "%s: Bad inode log record, rec ptr "PTR_FMT", ino %Ld",
3061                         __func__, item, in_f->ilf_ino);
3062                 XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)",
3063                                  XFS_ERRLEVEL_LOW, mp);
3064                 error = -EFSCORRUPTED;
3065                 goto out_release;
3066         }
3067
3068         /*
3069          * If the inode has an LSN in it, recover the inode only if it's less
3070          * than the lsn of the transaction we are replaying. Note: we still
3071          * need to replay an owner change even though the inode is more recent
3072          * than the transaction as there is no guarantee that all the btree
3073          * blocks are more recent than this transaction, too.
3074          */
3075         if (dip->di_version >= 3) {
3076                 xfs_lsn_t       lsn = be64_to_cpu(dip->di_lsn);
3077
3078                 if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) {
3079                         trace_xfs_log_recover_inode_skip(log, in_f);
3080                         error = 0;
3081                         goto out_owner_change;
3082                 }
3083         }
3084
3085         /*
3086          * di_flushiter is only valid for v1/2 inodes. All changes for v3 inodes
3087          * are transactional and if ordering is necessary we can determine that
3088          * more accurately by the LSN field in the V3 inode core. Don't trust
3089          * the inode versions we might be changing them here - use the
3090          * superblock flag to determine whether we need to look at di_flushiter
3091          * to skip replay when the on disk inode is newer than the log one
3092          */
3093         if (!xfs_sb_version_hascrc(&mp->m_sb) &&
3094             ldip->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
3095                 /*
3096                  * Deal with the wrap case, DI_MAX_FLUSH is less
3097                  * than smaller numbers
3098                  */
3099                 if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
3100                     ldip->di_flushiter < (DI_MAX_FLUSH >> 1)) {
3101                         /* do nothing */
3102                 } else {
3103                         trace_xfs_log_recover_inode_skip(log, in_f);
3104                         error = 0;
3105                         goto out_release;
3106                 }
3107         }
3108
3109         /* Take the opportunity to reset the flush iteration count */
3110         ldip->di_flushiter = 0;
3111
3112         if (unlikely(S_ISREG(ldip->di_mode))) {
3113                 if ((ldip->di_format != XFS_DINODE_FMT_EXTENTS) &&
3114                     (ldip->di_format != XFS_DINODE_FMT_BTREE)) {
3115                         XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)",
3116                                          XFS_ERRLEVEL_LOW, mp, ldip,
3117                                          sizeof(*ldip));
3118                         xfs_alert(mp,
3119                 "%s: Bad regular inode log record, rec ptr "PTR_FMT", "
3120                 "ino ptr = "PTR_FMT", ino bp = "PTR_FMT", ino %Ld",
3121                                 __func__, item, dip, bp, in_f->ilf_ino);
3122                         error = -EFSCORRUPTED;
3123                         goto out_release;
3124                 }
3125         } else if (unlikely(S_ISDIR(ldip->di_mode))) {
3126                 if ((ldip->di_format != XFS_DINODE_FMT_EXTENTS) &&
3127                     (ldip->di_format != XFS_DINODE_FMT_BTREE) &&
3128                     (ldip->di_format != XFS_DINODE_FMT_LOCAL)) {
3129                         XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(4)",
3130                                              XFS_ERRLEVEL_LOW, mp, ldip,
3131                                              sizeof(*ldip));
3132                         xfs_alert(mp,
3133                 "%s: Bad dir inode log record, rec ptr "PTR_FMT", "
3134                 "ino ptr = "PTR_FMT", ino bp = "PTR_FMT", ino %Ld",
3135                                 __func__, item, dip, bp, in_f->ilf_ino);
3136                         error = -EFSCORRUPTED;
3137                         goto out_release;
3138                 }
3139         }
3140         if (unlikely(ldip->di_nextents + ldip->di_anextents > ldip->di_nblocks)){
3141                 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)",
3142                                      XFS_ERRLEVEL_LOW, mp, ldip,
3143                                      sizeof(*ldip));
3144                 xfs_alert(mp,
3145         "%s: Bad inode log record, rec ptr "PTR_FMT", dino ptr "PTR_FMT", "
3146         "dino bp "PTR_FMT", ino %Ld, total extents = %d, nblocks = %Ld",
3147                         __func__, item, dip, bp, in_f->ilf_ino,
3148                         ldip->di_nextents + ldip->di_anextents,
3149                         ldip->di_nblocks);
3150                 error = -EFSCORRUPTED;
3151                 goto out_release;
3152         }
3153         if (unlikely(ldip->di_forkoff > mp->m_sb.sb_inodesize)) {
3154                 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)",
3155                                      XFS_ERRLEVEL_LOW, mp, ldip,
3156                                      sizeof(*ldip));
3157                 xfs_alert(mp,
3158         "%s: Bad inode log record, rec ptr "PTR_FMT", dino ptr "PTR_FMT", "
3159         "dino bp "PTR_FMT", ino %Ld, forkoff 0x%x", __func__,
3160                         item, dip, bp, in_f->ilf_ino, ldip->di_forkoff);
3161                 error = -EFSCORRUPTED;
3162                 goto out_release;
3163         }
3164         isize = xfs_log_dinode_size(ldip->di_version);
3165         if (unlikely(item->ri_buf[1].i_len > isize)) {
3166                 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)",
3167                                      XFS_ERRLEVEL_LOW, mp, ldip,
3168                                      sizeof(*ldip));
3169                 xfs_alert(mp,
3170                         "%s: Bad inode log record length %d, rec ptr "PTR_FMT,
3171                         __func__, item->ri_buf[1].i_len, item);
3172                 error = -EFSCORRUPTED;
3173                 goto out_release;
3174         }
3175
3176         /* recover the log dinode inode into the on disk inode */
3177         xfs_log_dinode_to_disk(ldip, dip);
3178
3179         fields = in_f->ilf_fields;
3180         if (fields & XFS_ILOG_DEV)
3181                 xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev);
3182
3183         if (in_f->ilf_size == 2)
3184                 goto out_owner_change;
3185         len = item->ri_buf[2].i_len;
3186         src = item->ri_buf[2].i_addr;
3187         ASSERT(in_f->ilf_size <= 4);
3188         ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK));
3189         ASSERT(!(fields & XFS_ILOG_DFORK) ||
3190                (len == in_f->ilf_dsize));
3191
3192         switch (fields & XFS_ILOG_DFORK) {
3193         case XFS_ILOG_DDATA:
3194         case XFS_ILOG_DEXT:
3195                 memcpy(XFS_DFORK_DPTR(dip), src, len);
3196                 break;
3197
3198         case XFS_ILOG_DBROOT:
3199                 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, len,
3200                                  (xfs_bmdr_block_t *)XFS_DFORK_DPTR(dip),
3201                                  XFS_DFORK_DSIZE(dip, mp));
3202                 break;
3203
3204         default:
3205                 /*
3206                  * There are no data fork flags set.
3207                  */
3208                 ASSERT((fields & XFS_ILOG_DFORK) == 0);
3209                 break;
3210         }
3211
3212         /*
3213          * If we logged any attribute data, recover it.  There may or
3214          * may not have been any other non-core data logged in this
3215          * transaction.
3216          */
3217         if (in_f->ilf_fields & XFS_ILOG_AFORK) {
3218                 if (in_f->ilf_fields & XFS_ILOG_DFORK) {
3219                         attr_index = 3;
3220                 } else {
3221                         attr_index = 2;
3222                 }
3223                 len = item->ri_buf[attr_index].i_len;
3224                 src = item->ri_buf[attr_index].i_addr;
3225                 ASSERT(len == in_f->ilf_asize);
3226
3227                 switch (in_f->ilf_fields & XFS_ILOG_AFORK) {
3228                 case XFS_ILOG_ADATA:
3229                 case XFS_ILOG_AEXT:
3230                         dest = XFS_DFORK_APTR(dip);
3231                         ASSERT(len <= XFS_DFORK_ASIZE(dip, mp));
3232                         memcpy(dest, src, len);
3233                         break;
3234
3235                 case XFS_ILOG_ABROOT:
3236                         dest = XFS_DFORK_APTR(dip);
3237                         xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src,
3238                                          len, (xfs_bmdr_block_t*)dest,
3239                                          XFS_DFORK_ASIZE(dip, mp));
3240                         break;
3241
3242                 default:
3243                         xfs_warn(log->l_mp, "%s: Invalid flag", __func__);
3244                         ASSERT(0);
3245                         error = -EIO;
3246                         goto out_release;
3247                 }
3248         }
3249
3250 out_owner_change:
3251         /* Recover the swapext owner change unless inode has been deleted */
3252         if ((in_f->ilf_fields & (XFS_ILOG_DOWNER|XFS_ILOG_AOWNER)) &&
3253             (dip->di_mode != 0))
3254                 error = xfs_recover_inode_owner_change(mp, dip, in_f,
3255                                                        buffer_list);
3256         /* re-generate the checksum. */
3257         xfs_dinode_calc_crc(log->l_mp, dip);
3258
3259         ASSERT(bp->b_target->bt_mount == mp);
3260         bp->b_iodone = xlog_recover_iodone;
3261         xfs_buf_delwri_queue(bp, buffer_list);
3262
3263 out_release:
3264         xfs_buf_relse(bp);
3265 error:
3266         if (need_free)
3267                 kmem_free(in_f);
3268         return error;
3269 }
3270
3271 /*
3272  * Recover QUOTAOFF records. We simply make a note of it in the xlog
3273  * structure, so that we know not to do any dquot item or dquot buffer recovery,
3274  * of that type.
3275  */
3276 STATIC int
3277 xlog_recover_quotaoff_pass1(
3278         struct xlog                     *log,
3279         struct xlog_recover_item        *item)
3280 {
3281         xfs_qoff_logformat_t    *qoff_f = item->ri_buf[0].i_addr;
3282         ASSERT(qoff_f);
3283
3284         /*
3285          * The logitem format's flag tells us if this was user quotaoff,
3286          * group/project quotaoff or both.
3287          */
3288         if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
3289                 log->l_quotaoffs_flag |= XFS_DQ_USER;
3290         if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
3291                 log->l_quotaoffs_flag |= XFS_DQ_PROJ;
3292         if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
3293                 log->l_quotaoffs_flag |= XFS_DQ_GROUP;
3294
3295         return 0;
3296 }
3297
3298 /*
3299  * Recover a dquot record
3300  */
3301 STATIC int
3302 xlog_recover_dquot_pass2(
3303         struct xlog                     *log,
3304         struct list_head                *buffer_list,
3305         struct xlog_recover_item        *item,
3306         xfs_lsn_t                       current_lsn)
3307 {
3308         xfs_mount_t             *mp = log->l_mp;
3309         xfs_buf_t               *bp;
3310         struct xfs_disk_dquot   *ddq, *recddq;
3311         xfs_failaddr_t          fa;
3312         int                     error;
3313         xfs_dq_logformat_t      *dq_f;
3314         uint                    type;
3315
3316
3317         /*
3318          * Filesystems are required to send in quota flags at mount time.
3319          */
3320         if (mp->m_qflags == 0)
3321                 return 0;
3322
3323         recddq = item->ri_buf[1].i_addr;
3324         if (recddq == NULL) {
3325                 xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
3326                 return -EIO;
3327         }
3328         if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
3329                 xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
3330                         item->ri_buf[1].i_len, __func__);
3331                 return -EIO;
3332         }
3333
3334         /*
3335          * This type of quotas was turned off, so ignore this record.
3336          */
3337         type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
3338         ASSERT(type);
3339         if (log->l_quotaoffs_flag & type)
3340                 return 0;
3341
3342         /*
3343          * At this point we know that quota was _not_ turned off.
3344          * Since the mount flags are not indicating to us otherwise, this
3345          * must mean that quota is on, and the dquot needs to be replayed.
3346          * Remember that we may not have fully recovered the superblock yet,
3347          * so we can't do the usual trick of looking at the SB quota bits.
3348          *
3349          * The other possibility, of course, is that the quota subsystem was
3350          * removed since the last mount - ENOSYS.
3351          */
3352         dq_f = item->ri_buf[0].i_addr;
3353         ASSERT(dq_f);
3354         fa = xfs_dquot_verify(mp, recddq, dq_f->qlf_id, 0);
3355         if (fa) {
3356                 xfs_alert(mp, "corrupt dquot ID 0x%x in log at %pS",
3357                                 dq_f->qlf_id, fa);
3358                 return -EIO;
3359         }
3360         ASSERT(dq_f->qlf_len == 1);
3361
3362         /*
3363          * At this point we are assuming that the dquots have been allocated
3364          * and hence the buffer has valid dquots stamped in it. It should,
3365          * therefore, pass verifier validation. If the dquot is bad, then the
3366          * we'll return an error here, so we don't need to specifically check
3367          * the dquot in the buffer after the verifier has run.
3368          */
3369         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dq_f->qlf_blkno,
3370                                    XFS_FSB_TO_BB(mp, dq_f->qlf_len), 0, &bp,
3371                                    &xfs_dquot_buf_ops);
3372         if (error)
3373                 return error;
3374
3375         ASSERT(bp);
3376         ddq = xfs_buf_offset(bp, dq_f->qlf_boffset);
3377
3378         /*
3379          * If the dquot has an LSN in it, recover the dquot only if it's less
3380          * than the lsn of the transaction we are replaying.
3381          */
3382         if (xfs_sb_version_hascrc(&mp->m_sb)) {
3383                 struct xfs_dqblk *dqb = (struct xfs_dqblk *)ddq;
3384                 xfs_lsn_t       lsn = be64_to_cpu(dqb->dd_lsn);
3385
3386                 if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) {
3387                         goto out_release;
3388                 }
3389         }
3390
3391         memcpy(ddq, recddq, item->ri_buf[1].i_len);
3392         if (xfs_sb_version_hascrc(&mp->m_sb)) {
3393                 xfs_update_cksum((char *)ddq, sizeof(struct xfs_dqblk),
3394                                  XFS_DQUOT_CRC_OFF);
3395         }
3396
3397         ASSERT(dq_f->qlf_size == 2);
3398         ASSERT(bp->b_target->bt_mount == mp);
3399         bp->b_iodone = xlog_recover_iodone;
3400         xfs_buf_delwri_queue(bp, buffer_list);
3401
3402 out_release:
3403         xfs_buf_relse(bp);
3404         return 0;
3405 }
3406
3407 /*
3408  * This routine is called to create an in-core extent free intent
3409  * item from the efi format structure which was logged on disk.
3410  * It allocates an in-core efi, copies the extents from the format
3411  * structure into it, and adds the efi to the AIL with the given
3412  * LSN.
3413  */
3414 STATIC int
3415 xlog_recover_efi_pass2(
3416         struct xlog                     *log,
3417         struct xlog_recover_item        *item,
3418         xfs_lsn_t                       lsn)
3419 {
3420         int                             error;
3421         struct xfs_mount                *mp = log->l_mp;
3422         struct xfs_efi_log_item         *efip;
3423         struct xfs_efi_log_format       *efi_formatp;
3424
3425         efi_formatp = item->ri_buf[0].i_addr;
3426
3427         efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
3428         error = xfs_efi_copy_format(&item->ri_buf[0], &efip->efi_format);
3429         if (error) {
3430                 xfs_efi_item_free(efip);
3431                 return error;
3432         }
3433         atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
3434
3435         spin_lock(&log->l_ailp->ail_lock);
3436         /*
3437          * The EFI has two references. One for the EFD and one for EFI to ensure
3438          * it makes it into the AIL. Insert the EFI into the AIL directly and
3439          * drop the EFI reference. Note that xfs_trans_ail_update() drops the
3440          * AIL lock.
3441          */
3442         xfs_trans_ail_update(log->l_ailp, &efip->efi_item, lsn);
3443         xfs_efi_release(efip);
3444         return 0;
3445 }
3446
3447
3448 /*
3449  * This routine is called when an EFD format structure is found in a committed
3450  * transaction in the log. Its purpose is to cancel the corresponding EFI if it
3451  * was still in the log. To do this it searches the AIL for the EFI with an id
3452  * equal to that in the EFD format structure. If we find it we drop the EFD
3453  * reference, which removes the EFI from the AIL and frees it.
3454  */
3455 STATIC int
3456 xlog_recover_efd_pass2(
3457         struct xlog                     *log,
3458         struct xlog_recover_item        *item)
3459 {
3460         xfs_efd_log_format_t    *efd_formatp;
3461         xfs_efi_log_item_t      *efip = NULL;
3462         xfs_log_item_t          *lip;
3463         uint64_t                efi_id;
3464         struct xfs_ail_cursor   cur;
3465         struct xfs_ail          *ailp = log->l_ailp;
3466
3467         efd_formatp = item->ri_buf[0].i_addr;
3468         ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) +
3469                 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) ||
3470                (item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) +
3471                 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t)))));
3472         efi_id = efd_formatp->efd_efi_id;
3473
3474         /*
3475          * Search for the EFI with the id in the EFD format structure in the
3476          * AIL.
3477          */
3478         spin_lock(&ailp->ail_lock);
3479         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
3480         while (lip != NULL) {
3481                 if (lip->li_type == XFS_LI_EFI) {
3482                         efip = (xfs_efi_log_item_t *)lip;
3483                         if (efip->efi_format.efi_id == efi_id) {
3484                                 /*
3485                                  * Drop the EFD reference to the EFI. This
3486                                  * removes the EFI from the AIL and frees it.
3487                                  */
3488                                 spin_unlock(&ailp->ail_lock);
3489                                 xfs_efi_release(efip);
3490                                 spin_lock(&ailp->ail_lock);
3491                                 break;
3492                         }
3493                 }
3494                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
3495         }
3496
3497         xfs_trans_ail_cursor_done(&cur);
3498         spin_unlock(&ailp->ail_lock);
3499
3500         return 0;
3501 }
3502
3503 /*
3504  * This routine is called to create an in-core extent rmap update
3505  * item from the rui format structure which was logged on disk.
3506  * It allocates an in-core rui, copies the extents from the format
3507  * structure into it, and adds the rui to the AIL with the given
3508  * LSN.
3509  */
3510 STATIC int
3511 xlog_recover_rui_pass2(
3512         struct xlog                     *log,
3513         struct xlog_recover_item        *item,
3514         xfs_lsn_t                       lsn)
3515 {
3516         int                             error;
3517         struct xfs_mount                *mp = log->l_mp;
3518         struct xfs_rui_log_item         *ruip;
3519         struct xfs_rui_log_format       *rui_formatp;
3520
3521         rui_formatp = item->ri_buf[0].i_addr;
3522
3523         ruip = xfs_rui_init(mp, rui_formatp->rui_nextents);
3524         error = xfs_rui_copy_format(&item->ri_buf[0], &ruip->rui_format);
3525         if (error) {
3526                 xfs_rui_item_free(ruip);
3527                 return error;
3528         }
3529         atomic_set(&ruip->rui_next_extent, rui_formatp->rui_nextents);
3530
3531         spin_lock(&log->l_ailp->ail_lock);
3532         /*
3533          * The RUI has two references. One for the RUD and one for RUI to ensure
3534          * it makes it into the AIL. Insert the RUI into the AIL directly and
3535          * drop the RUI reference. Note that xfs_trans_ail_update() drops the
3536          * AIL lock.
3537          */
3538         xfs_trans_ail_update(log->l_ailp, &ruip->rui_item, lsn);
3539         xfs_rui_release(ruip);
3540         return 0;
3541 }
3542
3543
3544 /*
3545  * This routine is called when an RUD format structure is found in a committed
3546  * transaction in the log. Its purpose is to cancel the corresponding RUI if it
3547  * was still in the log. To do this it searches the AIL for the RUI with an id
3548  * equal to that in the RUD format structure. If we find it we drop the RUD
3549  * reference, which removes the RUI from the AIL and frees it.
3550  */
3551 STATIC int
3552 xlog_recover_rud_pass2(
3553         struct xlog                     *log,
3554         struct xlog_recover_item        *item)
3555 {
3556         struct xfs_rud_log_format       *rud_formatp;
3557         struct xfs_rui_log_item         *ruip = NULL;
3558         struct xfs_log_item             *lip;
3559         uint64_t                        rui_id;
3560         struct xfs_ail_cursor           cur;
3561         struct xfs_ail                  *ailp = log->l_ailp;
3562
3563         rud_formatp = item->ri_buf[0].i_addr;
3564         ASSERT(item->ri_buf[0].i_len == sizeof(struct xfs_rud_log_format));
3565         rui_id = rud_formatp->rud_rui_id;
3566
3567         /*
3568          * Search for the RUI with the id in the RUD format structure in the
3569          * AIL.
3570          */
3571         spin_lock(&ailp->ail_lock);
3572         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
3573         while (lip != NULL) {
3574                 if (lip->li_type == XFS_LI_RUI) {
3575                         ruip = (struct xfs_rui_log_item *)lip;
3576                         if (ruip->rui_format.rui_id == rui_id) {
3577                                 /*
3578                                  * Drop the RUD reference to the RUI. This
3579                                  * removes the RUI from the AIL and frees it.
3580                                  */
3581                                 spin_unlock(&ailp->ail_lock);
3582                                 xfs_rui_release(ruip);
3583                                 spin_lock(&ailp->ail_lock);
3584                                 break;
3585                         }
3586                 }
3587                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
3588         }
3589
3590         xfs_trans_ail_cursor_done(&cur);
3591         spin_unlock(&ailp->ail_lock);
3592
3593         return 0;
3594 }
3595
3596 /*
3597  * Copy an CUI format buffer from the given buf, and into the destination
3598  * CUI format structure.  The CUI/CUD items were designed not to need any
3599  * special alignment handling.
3600  */
3601 static int
3602 xfs_cui_copy_format(
3603         struct xfs_log_iovec            *buf,
3604         struct xfs_cui_log_format       *dst_cui_fmt)
3605 {
3606         struct xfs_cui_log_format       *src_cui_fmt;
3607         uint                            len;
3608
3609         src_cui_fmt = buf->i_addr;
3610         len = xfs_cui_log_format_sizeof(src_cui_fmt->cui_nextents);
3611
3612         if (buf->i_len == len) {
3613                 memcpy(dst_cui_fmt, src_cui_fmt, len);
3614                 return 0;
3615         }
3616         return -EFSCORRUPTED;
3617 }
3618
3619 /*
3620  * This routine is called to create an in-core extent refcount update
3621  * item from the cui format structure which was logged on disk.
3622  * It allocates an in-core cui, copies the extents from the format
3623  * structure into it, and adds the cui to the AIL with the given
3624  * LSN.
3625  */
3626 STATIC int
3627 xlog_recover_cui_pass2(
3628         struct xlog                     *log,
3629         struct xlog_recover_item        *item,
3630         xfs_lsn_t                       lsn)
3631 {
3632         int                             error;
3633         struct xfs_mount                *mp = log->l_mp;
3634         struct xfs_cui_log_item         *cuip;
3635         struct xfs_cui_log_format       *cui_formatp;
3636
3637         cui_formatp = item->ri_buf[0].i_addr;
3638
3639         cuip = xfs_cui_init(mp, cui_formatp->cui_nextents);
3640         error = xfs_cui_copy_format(&item->ri_buf[0], &cuip->cui_format);
3641         if (error) {
3642                 xfs_cui_item_free(cuip);
3643                 return error;
3644         }
3645         atomic_set(&cuip->cui_next_extent, cui_formatp->cui_nextents);
3646
3647         spin_lock(&log->l_ailp->ail_lock);
3648         /*
3649          * The CUI has two references. One for the CUD and one for CUI to ensure
3650          * it makes it into the AIL. Insert the CUI into the AIL directly and
3651          * drop the CUI reference. Note that xfs_trans_ail_update() drops the
3652          * AIL lock.
3653          */
3654         xfs_trans_ail_update(log->l_ailp, &cuip->cui_item, lsn);
3655         xfs_cui_release(cuip);
3656         return 0;
3657 }
3658
3659
3660 /*
3661  * This routine is called when an CUD format structure is found in a committed
3662  * transaction in the log. Its purpose is to cancel the corresponding CUI if it
3663  * was still in the log. To do this it searches the AIL for the CUI with an id
3664  * equal to that in the CUD format structure. If we find it we drop the CUD
3665  * reference, which removes the CUI from the AIL and frees it.
3666  */
3667 STATIC int
3668 xlog_recover_cud_pass2(
3669         struct xlog                     *log,
3670         struct xlog_recover_item        *item)
3671 {
3672         struct xfs_cud_log_format       *cud_formatp;
3673         struct xfs_cui_log_item         *cuip = NULL;
3674         struct xfs_log_item             *lip;
3675         uint64_t                        cui_id;
3676         struct xfs_ail_cursor           cur;
3677         struct xfs_ail                  *ailp = log->l_ailp;
3678
3679         cud_formatp = item->ri_buf[0].i_addr;
3680         if (item->ri_buf[0].i_len != sizeof(struct xfs_cud_log_format))
3681                 return -EFSCORRUPTED;
3682         cui_id = cud_formatp->cud_cui_id;
3683
3684         /*
3685          * Search for the CUI with the id in the CUD format structure in the
3686          * AIL.
3687          */
3688         spin_lock(&ailp->ail_lock);
3689         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
3690         while (lip != NULL) {
3691                 if (lip->li_type == XFS_LI_CUI) {
3692                         cuip = (struct xfs_cui_log_item *)lip;
3693                         if (cuip->cui_format.cui_id == cui_id) {
3694                                 /*
3695                                  * Drop the CUD reference to the CUI. This
3696                                  * removes the CUI from the AIL and frees it.
3697                                  */
3698                                 spin_unlock(&ailp->ail_lock);
3699                                 xfs_cui_release(cuip);
3700                                 spin_lock(&ailp->ail_lock);
3701                                 break;
3702                         }
3703                 }
3704                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
3705         }
3706
3707         xfs_trans_ail_cursor_done(&cur);
3708         spin_unlock(&ailp->ail_lock);
3709
3710         return 0;
3711 }
3712
3713 /*
3714  * Copy an BUI format buffer from the given buf, and into the destination
3715  * BUI format structure.  The BUI/BUD items were designed not to need any
3716  * special alignment handling.
3717  */
3718 static int
3719 xfs_bui_copy_format(
3720         struct xfs_log_iovec            *buf,
3721         struct xfs_bui_log_format       *dst_bui_fmt)
3722 {
3723         struct xfs_bui_log_format       *src_bui_fmt;
3724         uint                            len;
3725
3726         src_bui_fmt = buf->i_addr;
3727         len = xfs_bui_log_format_sizeof(src_bui_fmt->bui_nextents);
3728
3729         if (buf->i_len == len) {
3730                 memcpy(dst_bui_fmt, src_bui_fmt, len);
3731                 return 0;
3732         }
3733         return -EFSCORRUPTED;
3734 }
3735
3736 /*
3737  * This routine is called to create an in-core extent bmap update
3738  * item from the bui format structure which was logged on disk.
3739  * It allocates an in-core bui, copies the extents from the format
3740  * structure into it, and adds the bui to the AIL with the given
3741  * LSN.
3742  */
3743 STATIC int
3744 xlog_recover_bui_pass2(
3745         struct xlog                     *log,
3746         struct xlog_recover_item        *item,
3747         xfs_lsn_t                       lsn)
3748 {
3749         int                             error;
3750         struct xfs_mount                *mp = log->l_mp;
3751         struct xfs_bui_log_item         *buip;
3752         struct xfs_bui_log_format       *bui_formatp;
3753
3754         bui_formatp = item->ri_buf[0].i_addr;
3755
3756         if (bui_formatp->bui_nextents != XFS_BUI_MAX_FAST_EXTENTS)
3757                 return -EFSCORRUPTED;
3758         buip = xfs_bui_init(mp);
3759         error = xfs_bui_copy_format(&item->ri_buf[0], &buip->bui_format);
3760         if (error) {
3761                 xfs_bui_item_free(buip);
3762                 return error;
3763         }
3764         atomic_set(&buip->bui_next_extent, bui_formatp->bui_nextents);
3765
3766         spin_lock(&log->l_ailp->ail_lock);
3767         /*
3768          * The RUI has two references. One for the RUD and one for RUI to ensure
3769          * it makes it into the AIL. Insert the RUI into the AIL directly and
3770          * drop the RUI reference. Note that xfs_trans_ail_update() drops the
3771          * AIL lock.
3772          */
3773         xfs_trans_ail_update(log->l_ailp, &buip->bui_item, lsn);
3774         xfs_bui_release(buip);
3775         return 0;
3776 }
3777
3778
3779 /*
3780  * This routine is called when an BUD format structure is found in a committed
3781  * transaction in the log. Its purpose is to cancel the corresponding BUI if it
3782  * was still in the log. To do this it searches the AIL for the BUI with an id
3783  * equal to that in the BUD format structure. If we find it we drop the BUD
3784  * reference, which removes the BUI from the AIL and frees it.
3785  */
3786 STATIC int
3787 xlog_recover_bud_pass2(
3788         struct xlog                     *log,
3789         struct xlog_recover_item        *item)
3790 {
3791         struct xfs_bud_log_format       *bud_formatp;
3792         struct xfs_bui_log_item         *buip = NULL;
3793         struct xfs_log_item             *lip;
3794         uint64_t                        bui_id;
3795         struct xfs_ail_cursor           cur;
3796         struct xfs_ail                  *ailp = log->l_ailp;
3797
3798         bud_formatp = item->ri_buf[0].i_addr;
3799         if (item->ri_buf[0].i_len != sizeof(struct xfs_bud_log_format))
3800                 return -EFSCORRUPTED;
3801         bui_id = bud_formatp->bud_bui_id;
3802
3803         /*
3804          * Search for the BUI with the id in the BUD format structure in the
3805          * AIL.
3806          */
3807         spin_lock(&ailp->ail_lock);
3808         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
3809         while (lip != NULL) {
3810                 if (lip->li_type == XFS_LI_BUI) {
3811                         buip = (struct xfs_bui_log_item *)lip;
3812                         if (buip->bui_format.bui_id == bui_id) {
3813                                 /*
3814                                  * Drop the BUD reference to the BUI. This
3815                                  * removes the BUI from the AIL and frees it.
3816                                  */
3817                                 spin_unlock(&ailp->ail_lock);
3818                                 xfs_bui_release(buip);
3819                                 spin_lock(&ailp->ail_lock);
3820                                 break;
3821                         }
3822                 }
3823                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
3824         }
3825
3826         xfs_trans_ail_cursor_done(&cur);
3827         spin_unlock(&ailp->ail_lock);
3828
3829         return 0;
3830 }
3831
3832 /*
3833  * This routine is called when an inode create format structure is found in a
3834  * committed transaction in the log.  It's purpose is to initialise the inodes
3835  * being allocated on disk. This requires us to get inode cluster buffers that
3836  * match the range to be initialised, stamped with inode templates and written
3837  * by delayed write so that subsequent modifications will hit the cached buffer
3838  * and only need writing out at the end of recovery.
3839  */
3840 STATIC int
3841 xlog_recover_do_icreate_pass2(
3842         struct xlog             *log,
3843         struct list_head        *buffer_list,
3844         xlog_recover_item_t     *item)
3845 {
3846         struct xfs_mount        *mp = log->l_mp;
3847         struct xfs_icreate_log  *icl;
3848         xfs_agnumber_t          agno;
3849         xfs_agblock_t           agbno;
3850         unsigned int            count;
3851         unsigned int            isize;
3852         xfs_agblock_t           length;
3853         int                     blks_per_cluster;
3854         int                     bb_per_cluster;
3855         int                     cancel_count;
3856         int                     nbufs;
3857         int                     i;
3858
3859         icl = (struct xfs_icreate_log *)item->ri_buf[0].i_addr;
3860         if (icl->icl_type != XFS_LI_ICREATE) {
3861                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad type");
3862                 return -EINVAL;
3863         }
3864
3865         if (icl->icl_size != 1) {
3866                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad icl size");
3867                 return -EINVAL;
3868         }
3869
3870         agno = be32_to_cpu(icl->icl_ag);
3871         if (agno >= mp->m_sb.sb_agcount) {
3872                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agno");
3873                 return -EINVAL;
3874         }
3875         agbno = be32_to_cpu(icl->icl_agbno);
3876         if (!agbno || agbno == NULLAGBLOCK || agbno >= mp->m_sb.sb_agblocks) {
3877                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agbno");
3878                 return -EINVAL;
3879         }
3880         isize = be32_to_cpu(icl->icl_isize);
3881         if (isize != mp->m_sb.sb_inodesize) {
3882                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad isize");
3883                 return -EINVAL;
3884         }
3885         count = be32_to_cpu(icl->icl_count);
3886         if (!count) {
3887                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count");
3888                 return -EINVAL;
3889         }
3890         length = be32_to_cpu(icl->icl_length);
3891         if (!length || length >= mp->m_sb.sb_agblocks) {
3892                 xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad length");
3893                 return -EINVAL;
3894         }
3895
3896         /*
3897          * The inode chunk is either full or sparse and we only support
3898          * m_ialloc_min_blks sized sparse allocations at this time.
3899          */
3900         if (length != mp->m_ialloc_blks &&
3901             length != mp->m_ialloc_min_blks) {
3902                 xfs_warn(log->l_mp,
3903                          "%s: unsupported chunk length", __FUNCTION__);
3904                 return -EINVAL;
3905         }
3906
3907         /* verify inode count is consistent with extent length */
3908         if ((count >> mp->m_sb.sb_inopblog) != length) {
3909                 xfs_warn(log->l_mp,
3910                          "%s: inconsistent inode count and chunk length",
3911                          __FUNCTION__);
3912                 return -EINVAL;
3913         }
3914
3915         /*
3916          * The icreate transaction can cover multiple cluster buffers and these
3917          * buffers could have been freed and reused. Check the individual
3918          * buffers for cancellation so we don't overwrite anything written after
3919          * a cancellation.
3920          */
3921         blks_per_cluster = xfs_icluster_size_fsb(mp);
3922         bb_per_cluster = XFS_FSB_TO_BB(mp, blks_per_cluster);
3923         nbufs = length / blks_per_cluster;
3924         for (i = 0, cancel_count = 0; i < nbufs; i++) {
3925                 xfs_daddr_t     daddr;
3926
3927                 daddr = XFS_AGB_TO_DADDR(mp, agno,
3928                                          agbno + i * blks_per_cluster);
3929                 if (xlog_check_buffer_cancelled(log, daddr, bb_per_cluster, 0))
3930                         cancel_count++;
3931         }
3932
3933         /*
3934          * We currently only use icreate for a single allocation at a time. This
3935          * means we should expect either all or none of the buffers to be
3936          * cancelled. Be conservative and skip replay if at least one buffer is
3937          * cancelled, but warn the user that something is awry if the buffers
3938          * are not consistent.
3939          *
3940          * XXX: This must be refined to only skip cancelled clusters once we use
3941          * icreate for multiple chunk allocations.
3942          */
3943         ASSERT(!cancel_count || cancel_count == nbufs);
3944         if (cancel_count) {
3945                 if (cancel_count != nbufs)
3946                         xfs_warn(mp,
3947         "WARNING: partial inode chunk cancellation, skipped icreate.");
3948                 trace_xfs_log_recover_icreate_cancel(log, icl);
3949                 return 0;
3950         }
3951
3952         trace_xfs_log_recover_icreate_recover(log, icl);
3953         return xfs_ialloc_inode_init(mp, NULL, buffer_list, count, agno, agbno,
3954                                      length, be32_to_cpu(icl->icl_gen));
3955 }
3956
3957 STATIC void
3958 xlog_recover_buffer_ra_pass2(
3959         struct xlog                     *log,
3960         struct xlog_recover_item        *item)
3961 {
3962         struct xfs_buf_log_format       *buf_f = item->ri_buf[0].i_addr;
3963         struct xfs_mount                *mp = log->l_mp;
3964
3965         if (xlog_peek_buffer_cancelled(log, buf_f->blf_blkno,
3966                         buf_f->blf_len, buf_f->blf_flags)) {
3967                 return;
3968         }
3969
3970         xfs_buf_readahead(mp->m_ddev_targp, buf_f->blf_blkno,
3971                                 buf_f->blf_len, NULL);
3972 }
3973
3974 STATIC void
3975 xlog_recover_inode_ra_pass2(
3976         struct xlog                     *log,
3977         struct xlog_recover_item        *item)
3978 {
3979         struct xfs_inode_log_format     ilf_buf;
3980         struct xfs_inode_log_format     *ilfp;
3981         struct xfs_mount                *mp = log->l_mp;
3982         int                     error;
3983
3984         if (item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format)) {
3985                 ilfp = item->ri_buf[0].i_addr;
3986         } else {
3987                 ilfp = &ilf_buf;
3988                 memset(ilfp, 0, sizeof(*ilfp));
3989                 error = xfs_inode_item_format_convert(&item->ri_buf[0], ilfp);
3990                 if (error)
3991                         return;
3992         }
3993
3994         if (xlog_peek_buffer_cancelled(log, ilfp->ilf_blkno, ilfp->ilf_len, 0))
3995                 return;
3996
3997         xfs_buf_readahead(mp->m_ddev_targp, ilfp->ilf_blkno,
3998                                 ilfp->ilf_len, &xfs_inode_buf_ra_ops);
3999 }
4000
4001 STATIC void
4002 xlog_recover_dquot_ra_pass2(
4003         struct xlog                     *log,
4004         struct xlog_recover_item        *item)
4005 {
4006         struct xfs_mount        *mp = log->l_mp;
4007         struct xfs_disk_dquot   *recddq;
4008         struct xfs_dq_logformat *dq_f;
4009         uint                    type;
4010         int                     len;
4011
4012
4013         if (mp->m_qflags == 0)
4014                 return;
4015
4016         recddq = item->ri_buf[1].i_addr;
4017         if (recddq == NULL)
4018                 return;
4019         if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot))
4020                 return;
4021
4022         type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
4023         ASSERT(type);
4024         if (log->l_quotaoffs_flag & type)
4025                 return;
4026
4027         dq_f = item->ri_buf[0].i_addr;
4028         ASSERT(dq_f);
4029         ASSERT(dq_f->qlf_len == 1);
4030
4031         len = XFS_FSB_TO_BB(mp, dq_f->qlf_len);
4032         if (xlog_peek_buffer_cancelled(log, dq_f->qlf_blkno, len, 0))
4033                 return;
4034
4035         xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno, len,
4036                           &xfs_dquot_buf_ra_ops);
4037 }
4038
4039 STATIC void
4040 xlog_recover_ra_pass2(
4041         struct xlog                     *log,
4042         struct xlog_recover_item        *item)
4043 {
4044         switch (ITEM_TYPE(item)) {
4045         case XFS_LI_BUF:
4046                 xlog_recover_buffer_ra_pass2(log, item);
4047                 break;
4048         case XFS_LI_INODE:
4049                 xlog_recover_inode_ra_pass2(log, item);
4050                 break;
4051         case XFS_LI_DQUOT:
4052                 xlog_recover_dquot_ra_pass2(log, item);
4053                 break;
4054         case XFS_LI_EFI:
4055         case XFS_LI_EFD:
4056         case XFS_LI_QUOTAOFF:
4057         case XFS_LI_RUI:
4058         case XFS_LI_RUD:
4059         case XFS_LI_CUI:
4060         case XFS_LI_CUD:
4061         case XFS_LI_BUI:
4062         case XFS_LI_BUD:
4063         default:
4064                 break;
4065         }
4066 }
4067
4068 STATIC int
4069 xlog_recover_commit_pass1(
4070         struct xlog                     *log,
4071         struct xlog_recover             *trans,
4072         struct xlog_recover_item        *item)
4073 {
4074         trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS1);
4075
4076         switch (ITEM_TYPE(item)) {
4077         case XFS_LI_BUF:
4078                 return xlog_recover_buffer_pass1(log, item);
4079         case XFS_LI_QUOTAOFF:
4080                 return xlog_recover_quotaoff_pass1(log, item);
4081         case XFS_LI_INODE:
4082         case XFS_LI_EFI:
4083         case XFS_LI_EFD:
4084         case XFS_LI_DQUOT:
4085         case XFS_LI_ICREATE:
4086         case XFS_LI_RUI:
4087         case XFS_LI_RUD:
4088         case XFS_LI_CUI:
4089         case XFS_LI_CUD:
4090         case XFS_LI_BUI:
4091         case XFS_LI_BUD:
4092                 /* nothing to do in pass 1 */
4093                 return 0;
4094         default:
4095                 xfs_warn(log->l_mp, "%s: invalid item type (%d)",
4096                         __func__, ITEM_TYPE(item));
4097                 ASSERT(0);
4098                 return -EIO;
4099         }
4100 }
4101
4102 STATIC int
4103 xlog_recover_commit_pass2(
4104         struct xlog                     *log,
4105         struct xlog_recover             *trans,
4106         struct list_head                *buffer_list,
4107         struct xlog_recover_item        *item)
4108 {
4109         trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS2);
4110
4111         switch (ITEM_TYPE(item)) {
4112         case XFS_LI_BUF:
4113                 return xlog_recover_buffer_pass2(log, buffer_list, item,
4114                                                  trans->r_lsn);
4115         case XFS_LI_INODE:
4116                 return xlog_recover_inode_pass2(log, buffer_list, item,
4117                                                  trans->r_lsn);
4118         case XFS_LI_EFI:
4119                 return xlog_recover_efi_pass2(log, item, trans->r_lsn);
4120         case XFS_LI_EFD:
4121                 return xlog_recover_efd_pass2(log, item);
4122         case XFS_LI_RUI:
4123                 return xlog_recover_rui_pass2(log, item, trans->r_lsn);
4124         case XFS_LI_RUD:
4125                 return xlog_recover_rud_pass2(log, item);
4126         case XFS_LI_CUI:
4127                 return xlog_recover_cui_pass2(log, item, trans->r_lsn);
4128         case XFS_LI_CUD:
4129                 return xlog_recover_cud_pass2(log, item);
4130         case XFS_LI_BUI:
4131                 return xlog_recover_bui_pass2(log, item, trans->r_lsn);
4132         case XFS_LI_BUD:
4133                 return xlog_recover_bud_pass2(log, item);
4134         case XFS_LI_DQUOT:
4135                 return xlog_recover_dquot_pass2(log, buffer_list, item,
4136                                                 trans->r_lsn);
4137         case XFS_LI_ICREATE:
4138                 return xlog_recover_do_icreate_pass2(log, buffer_list, item);
4139         case XFS_LI_QUOTAOFF:
4140                 /* nothing to do in pass2 */
4141                 return 0;
4142         default:
4143                 xfs_warn(log->l_mp, "%s: invalid item type (%d)",
4144                         __func__, ITEM_TYPE(item));
4145                 ASSERT(0);
4146                 return -EIO;
4147         }
4148 }
4149
4150 STATIC int
4151 xlog_recover_items_pass2(
4152         struct xlog                     *log,
4153         struct xlog_recover             *trans,
4154         struct list_head                *buffer_list,
4155         struct list_head                *item_list)
4156 {
4157         struct xlog_recover_item        *item;
4158         int                             error = 0;
4159
4160         list_for_each_entry(item, item_list, ri_list) {
4161                 error = xlog_recover_commit_pass2(log, trans,
4162                                           buffer_list, item);
4163                 if (error)
4164                         return error;
4165         }
4166
4167         return error;
4168 }
4169
4170 /*
4171  * Perform the transaction.
4172  *
4173  * If the transaction modifies a buffer or inode, do it now.  Otherwise,
4174  * EFIs and EFDs get queued up by adding entries into the AIL for them.
4175  */
4176 STATIC int
4177 xlog_recover_commit_trans(
4178         struct xlog             *log,
4179         struct xlog_recover     *trans,
4180         int                     pass,
4181         struct list_head        *buffer_list)
4182 {
4183         int                             error = 0;
4184         int                             items_queued = 0;
4185         struct xlog_recover_item        *item;
4186         struct xlog_recover_item        *next;
4187         LIST_HEAD                       (ra_list);
4188         LIST_HEAD                       (done_list);
4189
4190         #define XLOG_RECOVER_COMMIT_QUEUE_MAX 100
4191
4192         hlist_del_init(&trans->r_list);
4193
4194         error = xlog_recover_reorder_trans(log, trans, pass);
4195         if (error)
4196                 return error;
4197
4198         list_for_each_entry_safe(item, next, &trans->r_itemq, ri_list) {
4199                 switch (pass) {
4200                 case XLOG_RECOVER_PASS1:
4201                         error = xlog_recover_commit_pass1(log, trans, item);
4202                         break;
4203                 case XLOG_RECOVER_PASS2:
4204                         xlog_recover_ra_pass2(log, item);
4205                         list_move_tail(&item->ri_list, &ra_list);
4206                         items_queued++;
4207                         if (items_queued >= XLOG_RECOVER_COMMIT_QUEUE_MAX) {
4208                                 error = xlog_recover_items_pass2(log, trans,
4209                                                 buffer_list, &ra_list);
4210                                 list_splice_tail_init(&ra_list, &done_list);
4211                                 items_queued = 0;
4212                         }
4213
4214                         break;
4215                 default:
4216                         ASSERT(0);
4217                 }
4218
4219                 if (error)
4220                         goto out;
4221         }
4222
4223 out:
4224         if (!list_empty(&ra_list)) {
4225                 if (!error)
4226                         error = xlog_recover_items_pass2(log, trans,
4227                                         buffer_list, &ra_list);
4228                 list_splice_tail_init(&ra_list, &done_list);
4229         }
4230
4231         if (!list_empty(&done_list))
4232                 list_splice_init(&done_list, &trans->r_itemq);
4233
4234         return error;
4235 }
4236
4237 STATIC void
4238 xlog_recover_add_item(
4239         struct list_head        *head)
4240 {
4241         xlog_recover_item_t     *item;
4242
4243         item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
4244         INIT_LIST_HEAD(&item->ri_list);
4245         list_add_tail(&item->ri_list, head);
4246 }
4247
4248 STATIC int
4249 xlog_recover_add_to_cont_trans(
4250         struct xlog             *log,
4251         struct xlog_recover     *trans,
4252         char                    *dp,
4253         int                     len)
4254 {
4255         xlog_recover_item_t     *item;
4256         char                    *ptr, *old_ptr;
4257         int                     old_len;
4258
4259         /*
4260          * If the transaction is empty, the header was split across this and the
4261          * previous record. Copy the rest of the header.
4262          */
4263         if (list_empty(&trans->r_itemq)) {
4264                 ASSERT(len <= sizeof(struct xfs_trans_header));
4265                 if (len > sizeof(struct xfs_trans_header)) {
4266                         xfs_warn(log->l_mp, "%s: bad header length", __func__);
4267                         return -EIO;
4268                 }
4269
4270                 xlog_recover_add_item(&trans->r_itemq);
4271                 ptr = (char *)&trans->r_theader +
4272                                 sizeof(struct xfs_trans_header) - len;
4273                 memcpy(ptr, dp, len);
4274                 return 0;
4275         }
4276
4277         /* take the tail entry */
4278         item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
4279
4280         old_ptr = item->ri_buf[item->ri_cnt-1].i_addr;
4281         old_len = item->ri_buf[item->ri_cnt-1].i_len;
4282
4283         ptr = kmem_realloc(old_ptr, len + old_len, KM_SLEEP);
4284         memcpy(&ptr[old_len], dp, len);
4285         item->ri_buf[item->ri_cnt-1].i_len += len;
4286         item->ri_buf[item->ri_cnt-1].i_addr = ptr;
4287         trace_xfs_log_recover_item_add_cont(log, trans, item, 0);
4288         return 0;
4289 }
4290
4291 /*
4292  * The next region to add is the start of a new region.  It could be
4293  * a whole region or it could be the first part of a new region.  Because
4294  * of this, the assumption here is that the type and size fields of all
4295  * format structures fit into the first 32 bits of the structure.
4296  *
4297  * This works because all regions must be 32 bit aligned.  Therefore, we
4298  * either have both fields or we have neither field.  In the case we have
4299  * neither field, the data part of the region is zero length.  We only have
4300  * a log_op_header and can throw away the header since a new one will appear
4301  * later.  If we have at least 4 bytes, then we can determine how many regions
4302  * will appear in the current log item.
4303  */
4304 STATIC int
4305 xlog_recover_add_to_trans(
4306         struct xlog             *log,
4307         struct xlog_recover     *trans,
4308         char                    *dp,
4309         int                     len)
4310 {
4311         struct xfs_inode_log_format     *in_f;                  /* any will do */
4312         xlog_recover_item_t     *item;
4313         char                    *ptr;
4314
4315         if (!len)
4316                 return 0;
4317         if (list_empty(&trans->r_itemq)) {
4318                 /* we need to catch log corruptions here */
4319                 if (*(uint *)dp != XFS_TRANS_HEADER_MAGIC) {
4320                         xfs_warn(log->l_mp, "%s: bad header magic number",
4321                                 __func__);
4322                         ASSERT(0);
4323                         return -EIO;
4324                 }
4325
4326                 if (len > sizeof(struct xfs_trans_header)) {
4327                         xfs_warn(log->l_mp, "%s: bad header length", __func__);
4328                         ASSERT(0);
4329                         return -EIO;
4330                 }
4331
4332                 /*
4333                  * The transaction header can be arbitrarily split across op
4334                  * records. If we don't have the whole thing here, copy what we
4335                  * do have and handle the rest in the next record.
4336                  */
4337                 if (len == sizeof(struct xfs_trans_header))
4338                         xlog_recover_add_item(&trans->r_itemq);
4339                 memcpy(&trans->r_theader, dp, len);
4340                 return 0;
4341         }
4342
4343         ptr = kmem_alloc(len, KM_SLEEP);
4344         memcpy(ptr, dp, len);
4345         in_f = (struct xfs_inode_log_format *)ptr;
4346
4347         /* take the tail entry */
4348         item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
4349         if (item->ri_total != 0 &&
4350              item->ri_total == item->ri_cnt) {
4351                 /* tail item is in use, get a new one */
4352                 xlog_recover_add_item(&trans->r_itemq);
4353                 item = list_entry(trans->r_itemq.prev,
4354                                         xlog_recover_item_t, ri_list);
4355         }
4356
4357         if (item->ri_total == 0) {              /* first region to be added */
4358                 if (in_f->ilf_size == 0 ||
4359                     in_f->ilf_size > XLOG_MAX_REGIONS_IN_ITEM) {
4360                         xfs_warn(log->l_mp,
4361                 "bad number of regions (%d) in inode log format",
4362                                   in_f->ilf_size);
4363                         ASSERT(0);
4364                         kmem_free(ptr);
4365                         return -EIO;
4366                 }
4367
4368                 item->ri_total = in_f->ilf_size;
4369                 item->ri_buf =
4370                         kmem_zalloc(item->ri_total * sizeof(xfs_log_iovec_t),
4371                                     KM_SLEEP);
4372         }
4373         ASSERT(item->ri_total > item->ri_cnt);
4374         /* Description region is ri_buf[0] */
4375         item->ri_buf[item->ri_cnt].i_addr = ptr;
4376         item->ri_buf[item->ri_cnt].i_len  = len;
4377         item->ri_cnt++;
4378         trace_xfs_log_recover_item_add(log, trans, item, 0);
4379         return 0;
4380 }
4381
4382 /*
4383  * Free up any resources allocated by the transaction
4384  *
4385  * Remember that EFIs, EFDs, and IUNLINKs are handled later.
4386  */
4387 STATIC void
4388 xlog_recover_free_trans(
4389         struct xlog_recover     *trans)
4390 {
4391         xlog_recover_item_t     *item, *n;
4392         int                     i;
4393
4394         hlist_del_init(&trans->r_list);
4395
4396         list_for_each_entry_safe(item, n, &trans->r_itemq, ri_list) {
4397                 /* Free the regions in the item. */
4398                 list_del(&item->ri_list);
4399                 for (i = 0; i < item->ri_cnt; i++)
4400                         kmem_free(item->ri_buf[i].i_addr);
4401                 /* Free the item itself */
4402                 kmem_free(item->ri_buf);
4403                 kmem_free(item);
4404         }
4405         /* Free the transaction recover structure */
4406         kmem_free(trans);
4407 }
4408
4409 /*
4410  * On error or completion, trans is freed.
4411  */
4412 STATIC int
4413 xlog_recovery_process_trans(
4414         struct xlog             *log,
4415         struct xlog_recover     *trans,
4416         char                    *dp,
4417         unsigned int            len,
4418         unsigned int            flags,
4419         int                     pass,
4420         struct list_head        *buffer_list)
4421 {
4422         int                     error = 0;
4423         bool                    freeit = false;
4424
4425         /* mask off ophdr transaction container flags */
4426         flags &= ~XLOG_END_TRANS;
4427         if (flags & XLOG_WAS_CONT_TRANS)
4428                 flags &= ~XLOG_CONTINUE_TRANS;
4429
4430         /*
4431          * Callees must not free the trans structure. We'll decide if we need to
4432          * free it or not based on the operation being done and it's result.
4433          */
4434         switch (flags) {
4435         /* expected flag values */
4436         case 0:
4437         case XLOG_CONTINUE_TRANS:
4438                 error = xlog_recover_add_to_trans(log, trans, dp, len);
4439                 break;
4440         case XLOG_WAS_CONT_TRANS:
4441                 error = xlog_recover_add_to_cont_trans(log, trans, dp, len);
4442                 break;
4443         case XLOG_COMMIT_TRANS:
4444                 error = xlog_recover_commit_trans(log, trans, pass,
4445                                                   buffer_list);
4446                 /* success or fail, we are now done with this transaction. */
4447                 freeit = true;
4448                 break;
4449
4450         /* unexpected flag values */
4451         case XLOG_UNMOUNT_TRANS:
4452                 /* just skip trans */
4453                 xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
4454                 freeit = true;
4455                 break;
4456         case XLOG_START_TRANS:
4457         default:
4458                 xfs_warn(log->l_mp, "%s: bad flag 0x%x", __func__, flags);
4459                 ASSERT(0);
4460                 error = -EIO;
4461                 break;
4462         }
4463         if (error || freeit)
4464                 xlog_recover_free_trans(trans);
4465         return error;
4466 }
4467
4468 /*
4469  * Lookup the transaction recovery structure associated with the ID in the
4470  * current ophdr. If the transaction doesn't exist and the start flag is set in
4471  * the ophdr, then allocate a new transaction for future ID matches to find.
4472  * Either way, return what we found during the lookup - an existing transaction
4473  * or nothing.
4474  */
4475 STATIC struct xlog_recover *
4476 xlog_recover_ophdr_to_trans(
4477         struct hlist_head       rhash[],
4478         struct xlog_rec_header  *rhead,
4479         struct xlog_op_header   *ohead)
4480 {
4481         struct xlog_recover     *trans;
4482         xlog_tid_t              tid;
4483         struct hlist_head       *rhp;
4484
4485         tid = be32_to_cpu(ohead->oh_tid);
4486         rhp = &rhash[XLOG_RHASH(tid)];
4487         hlist_for_each_entry(trans, rhp, r_list) {
4488                 if (trans->r_log_tid == tid)
4489                         return trans;
4490         }
4491
4492         /*
4493          * skip over non-start transaction headers - we could be
4494          * processing slack space before the next transaction starts
4495          */
4496         if (!(ohead->oh_flags & XLOG_START_TRANS))
4497                 return NULL;
4498
4499         ASSERT(be32_to_cpu(ohead->oh_len) == 0);
4500
4501         /*
4502          * This is a new transaction so allocate a new recovery container to
4503          * hold the recovery ops that will follow.
4504          */
4505         trans = kmem_zalloc(sizeof(struct xlog_recover), KM_SLEEP);
4506         trans->r_log_tid = tid;
4507         trans->r_lsn = be64_to_cpu(rhead->h_lsn);
4508         INIT_LIST_HEAD(&trans->r_itemq);
4509         INIT_HLIST_NODE(&trans->r_list);
4510         hlist_add_head(&trans->r_list, rhp);
4511
4512         /*
4513          * Nothing more to do for this ophdr. Items to be added to this new
4514          * transaction will be in subsequent ophdr containers.
4515          */
4516         return NULL;
4517 }
4518
4519 STATIC int
4520 xlog_recover_process_ophdr(
4521         struct xlog             *log,
4522         struct hlist_head       rhash[],
4523         struct xlog_rec_header  *rhead,
4524         struct xlog_op_header   *ohead,
4525         char                    *dp,
4526         char                    *end,
4527         int                     pass,
4528         struct list_head        *buffer_list)
4529 {
4530         struct xlog_recover     *trans;
4531         unsigned int            len;
4532         int                     error;
4533
4534         /* Do we understand who wrote this op? */
4535         if (ohead->oh_clientid != XFS_TRANSACTION &&
4536             ohead->oh_clientid != XFS_LOG) {
4537                 xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
4538                         __func__, ohead->oh_clientid);
4539                 ASSERT(0);
4540                 return -EIO;
4541         }
4542
4543         /*
4544          * Check the ophdr contains all the data it is supposed to contain.
4545          */
4546         len = be32_to_cpu(ohead->oh_len);
4547         if (dp + len > end) {
4548                 xfs_warn(log->l_mp, "%s: bad length 0x%x", __func__, len);
4549                 WARN_ON(1);
4550                 return -EIO;
4551         }
4552
4553         trans = xlog_recover_ophdr_to_trans(rhash, rhead, ohead);
4554         if (!trans) {
4555                 /* nothing to do, so skip over this ophdr */
4556                 return 0;
4557         }
4558
4559         /*
4560          * The recovered buffer queue is drained only once we know that all
4561          * recovery items for the current LSN have been processed. This is
4562          * required because:
4563          *
4564          * - Buffer write submission updates the metadata LSN of the buffer.
4565          * - Log recovery skips items with a metadata LSN >= the current LSN of
4566          *   the recovery item.
4567          * - Separate recovery items against the same metadata buffer can share
4568          *   a current LSN. I.e., consider that the LSN of a recovery item is
4569          *   defined as the starting LSN of the first record in which its
4570          *   transaction appears, that a record can hold multiple transactions,
4571          *   and/or that a transaction can span multiple records.
4572          *
4573          * In other words, we are allowed to submit a buffer from log recovery
4574          * once per current LSN. Otherwise, we may incorrectly skip recovery
4575          * items and cause corruption.
4576          *
4577          * We don't know up front whether buffers are updated multiple times per
4578          * LSN. Therefore, track the current LSN of each commit log record as it
4579          * is processed and drain the queue when it changes. Use commit records
4580          * because they are ordered correctly by the logging code.
4581          */
4582         if (log->l_recovery_lsn != trans->r_lsn &&
4583             ohead->oh_flags & XLOG_COMMIT_TRANS) {
4584                 error = xfs_buf_delwri_submit(buffer_list);
4585                 if (error)
4586                         return error;
4587                 log->l_recovery_lsn = trans->r_lsn;
4588         }
4589
4590         return xlog_recovery_process_trans(log, trans, dp, len,
4591                                            ohead->oh_flags, pass, buffer_list);
4592 }
4593
4594 /*
4595  * There are two valid states of the r_state field.  0 indicates that the
4596  * transaction structure is in a normal state.  We have either seen the
4597  * start of the transaction or the last operation we added was not a partial
4598  * operation.  If the last operation we added to the transaction was a
4599  * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
4600  *
4601  * NOTE: skip LRs with 0 data length.
4602  */
4603 STATIC int
4604 xlog_recover_process_data(
4605         struct xlog             *log,
4606         struct hlist_head       rhash[],
4607         struct xlog_rec_header  *rhead,
4608         char                    *dp,
4609         int                     pass,
4610         struct list_head        *buffer_list)
4611 {
4612         struct xlog_op_header   *ohead;
4613         char                    *end;
4614         int                     num_logops;
4615         int                     error;
4616
4617         end = dp + be32_to_cpu(rhead->h_len);
4618         num_logops = be32_to_cpu(rhead->h_num_logops);
4619
4620         /* check the log format matches our own - else we can't recover */
4621         if (xlog_header_check_recover(log->l_mp, rhead))
4622                 return -EIO;
4623
4624         trace_xfs_log_recover_record(log, rhead, pass);
4625         while ((dp < end) && num_logops) {
4626
4627                 ohead = (struct xlog_op_header *)dp;
4628                 dp += sizeof(*ohead);
4629                 ASSERT(dp <= end);
4630
4631                 /* errors will abort recovery */
4632                 error = xlog_recover_process_ophdr(log, rhash, rhead, ohead,
4633                                                    dp, end, pass, buffer_list);
4634                 if (error)
4635                         return error;
4636
4637                 dp += be32_to_cpu(ohead->oh_len);
4638                 num_logops--;
4639         }
4640         return 0;
4641 }
4642
4643 /* Recover the EFI if necessary. */
4644 STATIC int
4645 xlog_recover_process_efi(
4646         struct xfs_mount                *mp,
4647         struct xfs_ail                  *ailp,
4648         struct xfs_log_item             *lip)
4649 {
4650         struct xfs_efi_log_item         *efip;
4651         int                             error;
4652
4653         /*
4654          * Skip EFIs that we've already processed.
4655          */
4656         efip = container_of(lip, struct xfs_efi_log_item, efi_item);
4657         if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags))
4658                 return 0;
4659
4660         spin_unlock(&ailp->ail_lock);
4661         error = xfs_efi_recover(mp, efip);
4662         spin_lock(&ailp->ail_lock);
4663
4664         return error;
4665 }
4666
4667 /* Release the EFI since we're cancelling everything. */
4668 STATIC void
4669 xlog_recover_cancel_efi(
4670         struct xfs_mount                *mp,
4671         struct xfs_ail                  *ailp,
4672         struct xfs_log_item             *lip)
4673 {
4674         struct xfs_efi_log_item         *efip;
4675
4676         efip = container_of(lip, struct xfs_efi_log_item, efi_item);
4677
4678         spin_unlock(&ailp->ail_lock);
4679         xfs_efi_release(efip);
4680         spin_lock(&ailp->ail_lock);
4681 }
4682
4683 /* Recover the RUI if necessary. */
4684 STATIC int
4685 xlog_recover_process_rui(
4686         struct xfs_mount                *mp,
4687         struct xfs_ail                  *ailp,
4688         struct xfs_log_item             *lip)
4689 {
4690         struct xfs_rui_log_item         *ruip;
4691         int                             error;
4692
4693         /*
4694          * Skip RUIs that we've already processed.
4695          */
4696         ruip = container_of(lip, struct xfs_rui_log_item, rui_item);
4697         if (test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags))
4698                 return 0;
4699
4700         spin_unlock(&ailp->ail_lock);
4701         error = xfs_rui_recover(mp, ruip);
4702         spin_lock(&ailp->ail_lock);
4703
4704         return error;
4705 }
4706
4707 /* Release the RUI since we're cancelling everything. */
4708 STATIC void
4709 xlog_recover_cancel_rui(
4710         struct xfs_mount                *mp,
4711         struct xfs_ail                  *ailp,
4712         struct xfs_log_item             *lip)
4713 {
4714         struct xfs_rui_log_item         *ruip;
4715
4716         ruip = container_of(lip, struct xfs_rui_log_item, rui_item);
4717
4718         spin_unlock(&ailp->ail_lock);
4719         xfs_rui_release(ruip);
4720         spin_lock(&ailp->ail_lock);
4721 }
4722
4723 /* Recover the CUI if necessary. */
4724 STATIC int
4725 xlog_recover_process_cui(
4726         struct xfs_trans                *parent_tp,
4727         struct xfs_ail                  *ailp,
4728         struct xfs_log_item             *lip)
4729 {
4730         struct xfs_cui_log_item         *cuip;
4731         int                             error;
4732
4733         /*
4734          * Skip CUIs that we've already processed.
4735          */
4736         cuip = container_of(lip, struct xfs_cui_log_item, cui_item);
4737         if (test_bit(XFS_CUI_RECOVERED, &cuip->cui_flags))
4738                 return 0;
4739
4740         spin_unlock(&ailp->ail_lock);
4741         error = xfs_cui_recover(parent_tp, cuip);
4742         spin_lock(&ailp->ail_lock);
4743
4744         return error;
4745 }
4746
4747 /* Release the CUI since we're cancelling everything. */
4748 STATIC void
4749 xlog_recover_cancel_cui(
4750         struct xfs_mount                *mp,
4751         struct xfs_ail                  *ailp,
4752         struct xfs_log_item             *lip)
4753 {
4754         struct xfs_cui_log_item         *cuip;
4755
4756         cuip = container_of(lip, struct xfs_cui_log_item, cui_item);
4757
4758         spin_unlock(&ailp->ail_lock);
4759         xfs_cui_release(cuip);
4760         spin_lock(&ailp->ail_lock);
4761 }
4762
4763 /* Recover the BUI if necessary. */
4764 STATIC int
4765 xlog_recover_process_bui(
4766         struct xfs_trans                *parent_tp,
4767         struct xfs_ail                  *ailp,
4768         struct xfs_log_item             *lip)
4769 {
4770         struct xfs_bui_log_item         *buip;
4771         int                             error;
4772
4773         /*
4774          * Skip BUIs that we've already processed.
4775          */
4776         buip = container_of(lip, struct xfs_bui_log_item, bui_item);
4777         if (test_bit(XFS_BUI_RECOVERED, &buip->bui_flags))
4778                 return 0;
4779
4780         spin_unlock(&ailp->ail_lock);
4781         error = xfs_bui_recover(parent_tp, buip);
4782         spin_lock(&ailp->ail_lock);
4783
4784         return error;
4785 }
4786
4787 /* Release the BUI since we're cancelling everything. */
4788 STATIC void
4789 xlog_recover_cancel_bui(
4790         struct xfs_mount                *mp,
4791         struct xfs_ail                  *ailp,
4792         struct xfs_log_item             *lip)
4793 {
4794         struct xfs_bui_log_item         *buip;
4795
4796         buip = container_of(lip, struct xfs_bui_log_item, bui_item);
4797
4798         spin_unlock(&ailp->ail_lock);
4799         xfs_bui_release(buip);
4800         spin_lock(&ailp->ail_lock);
4801 }
4802
4803 /* Is this log item a deferred action intent? */
4804 static inline bool xlog_item_is_intent(struct xfs_log_item *lip)
4805 {
4806         switch (lip->li_type) {
4807         case XFS_LI_EFI:
4808         case XFS_LI_RUI:
4809         case XFS_LI_CUI:
4810         case XFS_LI_BUI:
4811                 return true;
4812         default:
4813                 return false;
4814         }
4815 }
4816
4817 /* Take all the collected deferred ops and finish them in order. */
4818 static int
4819 xlog_finish_defer_ops(
4820         struct xfs_trans        *parent_tp)
4821 {
4822         struct xfs_mount        *mp = parent_tp->t_mountp;
4823         struct xfs_trans        *tp;
4824         int64_t                 freeblks;
4825         uint                    resblks;
4826         int                     error;
4827
4828         /*
4829          * We're finishing the defer_ops that accumulated as a result of
4830          * recovering unfinished intent items during log recovery.  We
4831          * reserve an itruncate transaction because it is the largest
4832          * permanent transaction type.  Since we're the only user of the fs
4833          * right now, take 93% (15/16) of the available free blocks.  Use
4834          * weird math to avoid a 64-bit division.
4835          */
4836         freeblks = percpu_counter_sum(&mp->m_fdblocks);
4837         if (freeblks <= 0)
4838                 return -ENOSPC;
4839         resblks = min_t(int64_t, UINT_MAX, freeblks);
4840         resblks = (resblks * 15) >> 4;
4841         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, resblks,
4842                         0, XFS_TRANS_RESERVE, &tp);
4843         if (error)
4844                 return error;
4845         /* transfer all collected dfops to this transaction */
4846         xfs_defer_move(tp, parent_tp);
4847
4848         return xfs_trans_commit(tp);
4849 }
4850
4851 /*
4852  * When this is called, all of the log intent items which did not have
4853  * corresponding log done items should be in the AIL.  What we do now
4854  * is update the data structures associated with each one.
4855  *
4856  * Since we process the log intent items in normal transactions, they
4857  * will be removed at some point after the commit.  This prevents us
4858  * from just walking down the list processing each one.  We'll use a
4859  * flag in the intent item to skip those that we've already processed
4860  * and use the AIL iteration mechanism's generation count to try to
4861  * speed this up at least a bit.
4862  *
4863  * When we start, we know that the intents are the only things in the
4864  * AIL.  As we process them, however, other items are added to the
4865  * AIL.
4866  */
4867 STATIC int
4868 xlog_recover_process_intents(
4869         struct xlog             *log)
4870 {
4871         struct xfs_trans        *parent_tp;
4872         struct xfs_ail_cursor   cur;
4873         struct xfs_log_item     *lip;
4874         struct xfs_ail          *ailp;
4875         int                     error;
4876 #if defined(DEBUG) || defined(XFS_WARN)
4877         xfs_lsn_t               last_lsn;
4878 #endif
4879
4880         /*
4881          * The intent recovery handlers commit transactions to complete recovery
4882          * for individual intents, but any new deferred operations that are
4883          * queued during that process are held off until the very end. The
4884          * purpose of this transaction is to serve as a container for deferred
4885          * operations. Each intent recovery handler must transfer dfops here
4886          * before its local transaction commits, and we'll finish the entire
4887          * list below.
4888          */
4889         error = xfs_trans_alloc_empty(log->l_mp, &parent_tp);
4890         if (error)
4891                 return error;
4892
4893         ailp = log->l_ailp;
4894         spin_lock(&ailp->ail_lock);
4895         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
4896 #if defined(DEBUG) || defined(XFS_WARN)
4897         last_lsn = xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block);
4898 #endif
4899         while (lip != NULL) {
4900                 /*
4901                  * We're done when we see something other than an intent.
4902                  * There should be no intents left in the AIL now.
4903                  */
4904                 if (!xlog_item_is_intent(lip)) {
4905 #ifdef DEBUG
4906                         for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
4907                                 ASSERT(!xlog_item_is_intent(lip));
4908 #endif
4909                         break;
4910                 }
4911
4912                 /*
4913                  * We should never see a redo item with a LSN higher than
4914                  * the last transaction we found in the log at the start
4915                  * of recovery.
4916                  */
4917                 ASSERT(XFS_LSN_CMP(last_lsn, lip->li_lsn) >= 0);
4918
4919                 /*
4920                  * NOTE: If your intent processing routine can create more
4921                  * deferred ops, you /must/ attach them to the dfops in this
4922                  * routine or else those subsequent intents will get
4923                  * replayed in the wrong order!
4924                  */
4925                 switch (lip->li_type) {
4926                 case XFS_LI_EFI:
4927                         error = xlog_recover_process_efi(log->l_mp, ailp, lip);
4928                         break;
4929                 case XFS_LI_RUI:
4930                         error = xlog_recover_process_rui(log->l_mp, ailp, lip);
4931                         break;
4932                 case XFS_LI_CUI:
4933                         error = xlog_recover_process_cui(parent_tp, ailp, lip);
4934                         break;
4935                 case XFS_LI_BUI:
4936                         error = xlog_recover_process_bui(parent_tp, ailp, lip);
4937                         break;
4938                 }
4939                 if (error)
4940                         goto out;
4941                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
4942         }
4943 out:
4944         xfs_trans_ail_cursor_done(&cur);
4945         spin_unlock(&ailp->ail_lock);
4946         if (!error)
4947                 error = xlog_finish_defer_ops(parent_tp);
4948         xfs_trans_cancel(parent_tp);
4949
4950         return error;
4951 }
4952
4953 /*
4954  * A cancel occurs when the mount has failed and we're bailing out.
4955  * Release all pending log intent items so they don't pin the AIL.
4956  */
4957 STATIC int
4958 xlog_recover_cancel_intents(
4959         struct xlog             *log)
4960 {
4961         struct xfs_log_item     *lip;
4962         int                     error = 0;
4963         struct xfs_ail_cursor   cur;
4964         struct xfs_ail          *ailp;
4965
4966         ailp = log->l_ailp;
4967         spin_lock(&ailp->ail_lock);
4968         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
4969         while (lip != NULL) {
4970                 /*
4971                  * We're done when we see something other than an intent.
4972                  * There should be no intents left in the AIL now.
4973                  */
4974                 if (!xlog_item_is_intent(lip)) {
4975 #ifdef DEBUG
4976                         for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
4977                                 ASSERT(!xlog_item_is_intent(lip));
4978 #endif
4979                         break;
4980                 }
4981
4982                 switch (lip->li_type) {
4983                 case XFS_LI_EFI:
4984                         xlog_recover_cancel_efi(log->l_mp, ailp, lip);
4985                         break;
4986                 case XFS_LI_RUI:
4987                         xlog_recover_cancel_rui(log->l_mp, ailp, lip);
4988                         break;
4989                 case XFS_LI_CUI:
4990                         xlog_recover_cancel_cui(log->l_mp, ailp, lip);
4991                         break;
4992                 case XFS_LI_BUI:
4993                         xlog_recover_cancel_bui(log->l_mp, ailp, lip);
4994                         break;
4995                 }
4996
4997                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
4998         }
4999
5000         xfs_trans_ail_cursor_done(&cur);
5001         spin_unlock(&ailp->ail_lock);
5002         return error;
5003 }
5004
5005 /*
5006  * This routine performs a transaction to null out a bad inode pointer
5007  * in an agi unlinked inode hash bucket.
5008  */
5009 STATIC void
5010 xlog_recover_clear_agi_bucket(
5011         xfs_mount_t     *mp,
5012         xfs_agnumber_t  agno,
5013         int             bucket)
5014 {
5015         xfs_trans_t     *tp;
5016         xfs_agi_t       *agi;
5017         xfs_buf_t       *agibp;
5018         int             offset;
5019         int             error;
5020
5021         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_clearagi, 0, 0, 0, &tp);
5022         if (error)
5023                 goto out_error;
5024
5025         error = xfs_read_agi(mp, tp, agno, &agibp);
5026         if (error)
5027                 goto out_abort;
5028
5029         agi = XFS_BUF_TO_AGI(agibp);
5030         agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
5031         offset = offsetof(xfs_agi_t, agi_unlinked) +
5032                  (sizeof(xfs_agino_t) * bucket);
5033         xfs_trans_log_buf(tp, agibp, offset,
5034                           (offset + sizeof(xfs_agino_t) - 1));
5035
5036         error = xfs_trans_commit(tp);
5037         if (error)
5038                 goto out_error;
5039         return;
5040
5041 out_abort:
5042         xfs_trans_cancel(tp);
5043 out_error:
5044         xfs_warn(mp, "%s: failed to clear agi %d. Continuing.", __func__, agno);
5045         return;
5046 }
5047
5048 STATIC xfs_agino_t
5049 xlog_recover_process_one_iunlink(
5050         struct xfs_mount                *mp,
5051         xfs_agnumber_t                  agno,
5052         xfs_agino_t                     agino,
5053         int                             bucket)
5054 {
5055         struct xfs_buf                  *ibp;
5056         struct xfs_dinode               *dip;
5057         struct xfs_inode                *ip;
5058         xfs_ino_t                       ino;
5059         int                             error;
5060
5061         ino = XFS_AGINO_TO_INO(mp, agno, agino);
5062         error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
5063         if (error)
5064                 goto fail;
5065
5066         /*
5067          * Get the on disk inode to find the next inode in the bucket.
5068          */
5069         error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &ibp, 0, 0);
5070         if (error)
5071                 goto fail_iput;
5072
5073         xfs_iflags_clear(ip, XFS_IRECOVERY);
5074         ASSERT(VFS_I(ip)->i_nlink == 0);
5075         ASSERT(VFS_I(ip)->i_mode != 0);
5076
5077         /* setup for the next pass */
5078         agino = be32_to_cpu(dip->di_next_unlinked);
5079         xfs_buf_relse(ibp);
5080
5081         /*
5082          * Prevent any DMAPI event from being sent when the reference on
5083          * the inode is dropped.
5084          */
5085         ip->i_d.di_dmevmask = 0;
5086
5087         xfs_irele(ip);
5088         return agino;
5089
5090  fail_iput:
5091         xfs_irele(ip);
5092  fail:
5093         /*
5094          * We can't read in the inode this bucket points to, or this inode
5095          * is messed up.  Just ditch this bucket of inodes.  We will lose
5096          * some inodes and space, but at least we won't hang.
5097          *
5098          * Call xlog_recover_clear_agi_bucket() to perform a transaction to
5099          * clear the inode pointer in the bucket.
5100          */
5101         xlog_recover_clear_agi_bucket(mp, agno, bucket);
5102         return NULLAGINO;
5103 }
5104
5105 /*
5106  * xlog_iunlink_recover
5107  *
5108  * This is called during recovery to process any inodes which
5109  * we unlinked but not freed when the system crashed.  These
5110  * inodes will be on the lists in the AGI blocks.  What we do
5111  * here is scan all the AGIs and fully truncate and free any
5112  * inodes found on the lists.  Each inode is removed from the
5113  * lists when it has been fully truncated and is freed.  The
5114  * freeing of the inode and its removal from the list must be
5115  * atomic.
5116  */
5117 STATIC void
5118 xlog_recover_process_iunlinks(
5119         struct xlog     *log)
5120 {
5121         xfs_mount_t     *mp;
5122         xfs_agnumber_t  agno;
5123         xfs_agi_t       *agi;
5124         xfs_buf_t       *agibp;
5125         xfs_agino_t     agino;
5126         int             bucket;
5127         int             error;
5128
5129         mp = log->l_mp;
5130
5131         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
5132                 /*
5133                  * Find the agi for this ag.
5134                  */
5135                 error = xfs_read_agi(mp, NULL, agno, &agibp);
5136                 if (error) {
5137                         /*
5138                          * AGI is b0rked. Don't process it.
5139                          *
5140                          * We should probably mark the filesystem as corrupt
5141                          * after we've recovered all the ag's we can....
5142                          */
5143                         continue;
5144                 }
5145                 /*
5146                  * Unlock the buffer so that it can be acquired in the normal
5147                  * course of the transaction to truncate and free each inode.
5148                  * Because we are not racing with anyone else here for the AGI
5149                  * buffer, we don't even need to hold it locked to read the
5150                  * initial unlinked bucket entries out of the buffer. We keep
5151                  * buffer reference though, so that it stays pinned in memory
5152                  * while we need the buffer.
5153                  */
5154                 agi = XFS_BUF_TO_AGI(agibp);
5155                 xfs_buf_unlock(agibp);
5156
5157                 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) {
5158                         agino = be32_to_cpu(agi->agi_unlinked[bucket]);
5159                         while (agino != NULLAGINO) {
5160                                 agino = xlog_recover_process_one_iunlink(mp,
5161                                                         agno, agino, bucket);
5162                         }
5163                 }
5164                 xfs_buf_rele(agibp);
5165         }
5166 }
5167
5168 STATIC int
5169 xlog_unpack_data(
5170         struct xlog_rec_header  *rhead,
5171         char                    *dp,
5172         struct xlog             *log)
5173 {
5174         int                     i, j, k;
5175
5176         for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) &&
5177                   i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
5178                 *(__be32 *)dp = *(__be32 *)&rhead->h_cycle_data[i];
5179                 dp += BBSIZE;
5180         }
5181
5182         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
5183                 xlog_in_core_2_t *xhdr = (xlog_in_core_2_t *)rhead;
5184                 for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
5185                         j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
5186                         k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
5187                         *(__be32 *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];
5188                         dp += BBSIZE;
5189                 }
5190         }
5191
5192         return 0;
5193 }
5194
5195 /*
5196  * CRC check, unpack and process a log record.
5197  */
5198 STATIC int
5199 xlog_recover_process(
5200         struct xlog             *log,
5201         struct hlist_head       rhash[],
5202         struct xlog_rec_header  *rhead,
5203         char                    *dp,
5204         int                     pass,
5205         struct list_head        *buffer_list)
5206 {
5207         int                     error;
5208         __le32                  old_crc = rhead->h_crc;
5209         __le32                  crc;
5210
5211
5212         crc = xlog_cksum(log, rhead, dp, be32_to_cpu(rhead->h_len));
5213
5214         /*
5215          * Nothing else to do if this is a CRC verification pass. Just return
5216          * if this a record with a non-zero crc. Unfortunately, mkfs always
5217          * sets old_crc to 0 so we must consider this valid even on v5 supers.
5218          * Otherwise, return EFSBADCRC on failure so the callers up the stack
5219          * know precisely what failed.
5220          */
5221         if (pass == XLOG_RECOVER_CRCPASS) {
5222                 if (old_crc && crc != old_crc)
5223                         return -EFSBADCRC;
5224                 return 0;
5225         }
5226
5227         /*
5228          * We're in the normal recovery path. Issue a warning if and only if the
5229          * CRC in the header is non-zero. This is an advisory warning and the
5230          * zero CRC check prevents warnings from being emitted when upgrading
5231          * the kernel from one that does not add CRCs by default.
5232          */
5233         if (crc != old_crc) {
5234                 if (old_crc || xfs_sb_version_hascrc(&log->l_mp->m_sb)) {
5235                         xfs_alert(log->l_mp,
5236                 "log record CRC mismatch: found 0x%x, expected 0x%x.",
5237                                         le32_to_cpu(old_crc),
5238                                         le32_to_cpu(crc));
5239                         xfs_hex_dump(dp, 32);
5240                 }
5241
5242                 /*
5243                  * If the filesystem is CRC enabled, this mismatch becomes a
5244                  * fatal log corruption failure.
5245                  */
5246                 if (xfs_sb_version_hascrc(&log->l_mp->m_sb))
5247                         return -EFSCORRUPTED;
5248         }
5249
5250         error = xlog_unpack_data(rhead, dp, log);
5251         if (error)
5252                 return error;
5253
5254         return xlog_recover_process_data(log, rhash, rhead, dp, pass,
5255                                          buffer_list);
5256 }
5257
5258 STATIC int
5259 xlog_valid_rec_header(
5260         struct xlog             *log,
5261         struct xlog_rec_header  *rhead,
5262         xfs_daddr_t             blkno)
5263 {
5264         int                     hlen;
5265
5266         if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) {
5267                 XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
5268                                 XFS_ERRLEVEL_LOW, log->l_mp);
5269                 return -EFSCORRUPTED;
5270         }
5271         if (unlikely(
5272             (!rhead->h_version ||
5273             (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
5274                 xfs_warn(log->l_mp, "%s: unrecognised log version (%d).",
5275                         __func__, be32_to_cpu(rhead->h_version));
5276                 return -EIO;
5277         }
5278
5279         /* LR body must have data or it wouldn't have been written */
5280         hlen = be32_to_cpu(rhead->h_len);
5281         if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
5282                 XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
5283                                 XFS_ERRLEVEL_LOW, log->l_mp);
5284                 return -EFSCORRUPTED;
5285         }
5286         if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
5287                 XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
5288                                 XFS_ERRLEVEL_LOW, log->l_mp);
5289                 return -EFSCORRUPTED;
5290         }
5291         return 0;
5292 }
5293
5294 /*
5295  * Read the log from tail to head and process the log records found.
5296  * Handle the two cases where the tail and head are in the same cycle
5297  * and where the active portion of the log wraps around the end of
5298  * the physical log separately.  The pass parameter is passed through
5299  * to the routines called to process the data and is not looked at
5300  * here.
5301  */
5302 STATIC int
5303 xlog_do_recovery_pass(
5304         struct xlog             *log,
5305         xfs_daddr_t             head_blk,
5306         xfs_daddr_t             tail_blk,
5307         int                     pass,
5308         xfs_daddr_t             *first_bad)     /* out: first bad log rec */
5309 {
5310         xlog_rec_header_t       *rhead;
5311         xfs_daddr_t             blk_no, rblk_no;
5312         xfs_daddr_t             rhead_blk;
5313         char                    *offset;
5314         xfs_buf_t               *hbp, *dbp;
5315         int                     error = 0, h_size, h_len;
5316         int                     error2 = 0;
5317         int                     bblks, split_bblks;
5318         int                     hblks, split_hblks, wrapped_hblks;
5319         int                     i;
5320         struct hlist_head       rhash[XLOG_RHASH_SIZE];
5321         LIST_HEAD               (buffer_list);
5322
5323         ASSERT(head_blk != tail_blk);
5324         blk_no = rhead_blk = tail_blk;
5325
5326         for (i = 0; i < XLOG_RHASH_SIZE; i++)
5327                 INIT_HLIST_HEAD(&rhash[i]);
5328
5329         /*
5330          * Read the header of the tail block and get the iclog buffer size from
5331          * h_size.  Use this to tell how many sectors make up the log header.
5332          */
5333         if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
5334                 /*
5335                  * When using variable length iclogs, read first sector of
5336                  * iclog header and extract the header size from it.  Get a
5337                  * new hbp that is the correct size.
5338                  */
5339                 hbp = xlog_get_bp(log, 1);
5340                 if (!hbp)
5341                         return -ENOMEM;
5342
5343                 error = xlog_bread(log, tail_blk, 1, hbp, &offset);
5344                 if (error)
5345                         goto bread_err1;
5346
5347                 rhead = (xlog_rec_header_t *)offset;
5348                 error = xlog_valid_rec_header(log, rhead, tail_blk);
5349                 if (error)
5350                         goto bread_err1;
5351
5352                 /*
5353                  * xfsprogs has a bug where record length is based on lsunit but
5354                  * h_size (iclog size) is hardcoded to 32k. Now that we
5355                  * unconditionally CRC verify the unmount record, this means the
5356                  * log buffer can be too small for the record and cause an
5357                  * overrun.
5358                  *
5359                  * Detect this condition here. Use lsunit for the buffer size as
5360                  * long as this looks like the mkfs case. Otherwise, return an
5361                  * error to avoid a buffer overrun.
5362                  */
5363                 h_size = be32_to_cpu(rhead->h_size);
5364                 h_len = be32_to_cpu(rhead->h_len);
5365                 if (h_len > h_size) {
5366                         if (h_len <= log->l_mp->m_logbsize &&
5367                             be32_to_cpu(rhead->h_num_logops) == 1) {
5368                                 xfs_warn(log->l_mp,
5369                 "invalid iclog size (%d bytes), using lsunit (%d bytes)",
5370                                          h_size, log->l_mp->m_logbsize);
5371                                 h_size = log->l_mp->m_logbsize;
5372                         } else
5373                                 return -EFSCORRUPTED;
5374                 }
5375
5376                 if ((be32_to_cpu(rhead->h_version) & XLOG_VERSION_2) &&
5377                     (h_size > XLOG_HEADER_CYCLE_SIZE)) {
5378                         hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
5379                         if (h_size % XLOG_HEADER_CYCLE_SIZE)
5380                                 hblks++;
5381                         xlog_put_bp(hbp);
5382                         hbp = xlog_get_bp(log, hblks);
5383                 } else {
5384                         hblks = 1;
5385                 }
5386         } else {
5387                 ASSERT(log->l_sectBBsize == 1);
5388                 hblks = 1;
5389                 hbp = xlog_get_bp(log, 1);
5390                 h_size = XLOG_BIG_RECORD_BSIZE;
5391         }
5392
5393         if (!hbp)
5394                 return -ENOMEM;
5395         dbp = xlog_get_bp(log, BTOBB(h_size));
5396         if (!dbp) {
5397                 xlog_put_bp(hbp);
5398                 return -ENOMEM;
5399         }
5400
5401         memset(rhash, 0, sizeof(rhash));
5402         if (tail_blk > head_blk) {
5403                 /*
5404                  * Perform recovery around the end of the physical log.
5405                  * When the head is not on the same cycle number as the tail,
5406                  * we can't do a sequential recovery.
5407                  */
5408                 while (blk_no < log->l_logBBsize) {
5409                         /*
5410                          * Check for header wrapping around physical end-of-log
5411                          */
5412                         offset = hbp->b_addr;
5413                         split_hblks = 0;
5414                         wrapped_hblks = 0;
5415                         if (blk_no + hblks <= log->l_logBBsize) {
5416                                 /* Read header in one read */
5417                                 error = xlog_bread(log, blk_no, hblks, hbp,
5418                                                    &offset);
5419                                 if (error)
5420                                         goto bread_err2;
5421                         } else {
5422                                 /* This LR is split across physical log end */
5423                                 if (blk_no != log->l_logBBsize) {
5424                                         /* some data before physical log end */
5425                                         ASSERT(blk_no <= INT_MAX);
5426                                         split_hblks = log->l_logBBsize - (int)blk_no;
5427                                         ASSERT(split_hblks > 0);
5428                                         error = xlog_bread(log, blk_no,
5429                                                            split_hblks, hbp,
5430                                                            &offset);
5431                                         if (error)
5432                                                 goto bread_err2;
5433                                 }
5434
5435                                 /*
5436                                  * Note: this black magic still works with
5437                                  * large sector sizes (non-512) only because:
5438                                  * - we increased the buffer size originally
5439                                  *   by 1 sector giving us enough extra space
5440                                  *   for the second read;
5441                                  * - the log start is guaranteed to be sector
5442                                  *   aligned;
5443                                  * - we read the log end (LR header start)
5444                                  *   _first_, then the log start (LR header end)
5445                                  *   - order is important.
5446                                  */
5447                                 wrapped_hblks = hblks - split_hblks;
5448                                 error = xlog_bread_offset(log, 0,
5449                                                 wrapped_hblks, hbp,
5450                                                 offset + BBTOB(split_hblks));
5451                                 if (error)
5452                                         goto bread_err2;
5453                         }
5454                         rhead = (xlog_rec_header_t *)offset;
5455                         error = xlog_valid_rec_header(log, rhead,
5456                                                 split_hblks ? blk_no : 0);
5457                         if (error)
5458                                 goto bread_err2;
5459
5460                         bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
5461                         blk_no += hblks;
5462
5463                         /*
5464                          * Read the log record data in multiple reads if it
5465                          * wraps around the end of the log. Note that if the
5466                          * header already wrapped, blk_no could point past the
5467                          * end of the log. The record data is contiguous in
5468                          * that case.
5469                          */
5470                         if (blk_no + bblks <= log->l_logBBsize ||
5471                             blk_no >= log->l_logBBsize) {
5472                                 rblk_no = xlog_wrap_logbno(log, blk_no);
5473                                 error = xlog_bread(log, rblk_no, bblks, dbp,
5474                                                    &offset);
5475                                 if (error)
5476                                         goto bread_err2;
5477                         } else {
5478                                 /* This log record is split across the
5479                                  * physical end of log */
5480                                 offset = dbp->b_addr;
5481                                 split_bblks = 0;
5482                                 if (blk_no != log->l_logBBsize) {
5483                                         /* some data is before the physical
5484                                          * end of log */
5485                                         ASSERT(!wrapped_hblks);
5486                                         ASSERT(blk_no <= INT_MAX);
5487                                         split_bblks =
5488                                                 log->l_logBBsize - (int)blk_no;
5489                                         ASSERT(split_bblks > 0);
5490                                         error = xlog_bread(log, blk_no,
5491                                                         split_bblks, dbp,
5492                                                         &offset);
5493                                         if (error)
5494                                                 goto bread_err2;
5495                                 }
5496
5497                                 /*
5498                                  * Note: this black magic still works with
5499                                  * large sector sizes (non-512) only because:
5500                                  * - we increased the buffer size originally
5501                                  *   by 1 sector giving us enough extra space
5502                                  *   for the second read;
5503                                  * - the log start is guaranteed to be sector
5504                                  *   aligned;
5505                                  * - we read the log end (LR header start)
5506                                  *   _first_, then the log start (LR header end)
5507                                  *   - order is important.
5508                                  */
5509                                 error = xlog_bread_offset(log, 0,
5510                                                 bblks - split_bblks, dbp,
5511                                                 offset + BBTOB(split_bblks));
5512                                 if (error)
5513                                         goto bread_err2;
5514                         }
5515
5516                         error = xlog_recover_process(log, rhash, rhead, offset,
5517                                                      pass, &buffer_list);
5518                         if (error)
5519                                 goto bread_err2;
5520
5521                         blk_no += bblks;
5522                         rhead_blk = blk_no;
5523                 }
5524
5525                 ASSERT(blk_no >= log->l_logBBsize);
5526                 blk_no -= log->l_logBBsize;
5527                 rhead_blk = blk_no;
5528         }
5529
5530         /* read first part of physical log */
5531         while (blk_no < head_blk) {
5532                 error = xlog_bread(log, blk_no, hblks, hbp, &offset);
5533                 if (error)
5534                         goto bread_err2;
5535
5536                 rhead = (xlog_rec_header_t *)offset;
5537                 error = xlog_valid_rec_header(log, rhead, blk_no);
5538                 if (error)
5539                         goto bread_err2;
5540
5541                 /* blocks in data section */
5542                 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
5543                 error = xlog_bread(log, blk_no+hblks, bblks, dbp,
5544                                    &offset);
5545                 if (error)
5546                         goto bread_err2;
5547
5548                 error = xlog_recover_process(log, rhash, rhead, offset, pass,
5549                                              &buffer_list);
5550                 if (error)
5551                         goto bread_err2;
5552
5553                 blk_no += bblks + hblks;
5554                 rhead_blk = blk_no;
5555         }
5556
5557  bread_err2:
5558         xlog_put_bp(dbp);
5559  bread_err1:
5560         xlog_put_bp(hbp);
5561
5562         /*
5563          * Submit buffers that have been added from the last record processed,
5564          * regardless of error status.
5565          */
5566         if (!list_empty(&buffer_list))
5567                 error2 = xfs_buf_delwri_submit(&buffer_list);
5568
5569         if (error && first_bad)
5570                 *first_bad = rhead_blk;
5571
5572         /*
5573          * Transactions are freed at commit time but transactions without commit
5574          * records on disk are never committed. Free any that may be left in the
5575          * hash table.
5576          */
5577         for (i = 0; i < XLOG_RHASH_SIZE; i++) {
5578                 struct hlist_node       *tmp;
5579                 struct xlog_recover     *trans;
5580
5581                 hlist_for_each_entry_safe(trans, tmp, &rhash[i], r_list)
5582                         xlog_recover_free_trans(trans);
5583         }
5584
5585         return error ? error : error2;
5586 }
5587
5588 /*
5589  * Do the recovery of the log.  We actually do this in two phases.
5590  * The two passes are necessary in order to implement the function
5591  * of cancelling a record written into the log.  The first pass
5592  * determines those things which have been cancelled, and the
5593  * second pass replays log items normally except for those which
5594  * have been cancelled.  The handling of the replay and cancellations
5595  * takes place in the log item type specific routines.
5596  *
5597  * The table of items which have cancel records in the log is allocated
5598  * and freed at this level, since only here do we know when all of
5599  * the log recovery has been completed.
5600  */
5601 STATIC int
5602 xlog_do_log_recovery(
5603         struct xlog     *log,
5604         xfs_daddr_t     head_blk,
5605         xfs_daddr_t     tail_blk)
5606 {
5607         int             error, i;
5608
5609         ASSERT(head_blk != tail_blk);
5610
5611         /*
5612          * First do a pass to find all of the cancelled buf log items.
5613          * Store them in the buf_cancel_table for use in the second pass.
5614          */
5615         log->l_buf_cancel_table = kmem_zalloc(XLOG_BC_TABLE_SIZE *
5616                                                  sizeof(struct list_head),
5617                                                  KM_SLEEP);
5618         for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
5619                 INIT_LIST_HEAD(&log->l_buf_cancel_table[i]);
5620
5621         error = xlog_do_recovery_pass(log, head_blk, tail_blk,
5622                                       XLOG_RECOVER_PASS1, NULL);
5623         if (error != 0) {
5624                 kmem_free(log->l_buf_cancel_table);
5625                 log->l_buf_cancel_table = NULL;
5626                 return error;
5627         }
5628         /*
5629          * Then do a second pass to actually recover the items in the log.
5630          * When it is complete free the table of buf cancel items.
5631          */
5632         error = xlog_do_recovery_pass(log, head_blk, tail_blk,
5633                                       XLOG_RECOVER_PASS2, NULL);
5634 #ifdef DEBUG
5635         if (!error) {
5636                 int     i;
5637
5638                 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
5639                         ASSERT(list_empty(&log->l_buf_cancel_table[i]));
5640         }
5641 #endif  /* DEBUG */
5642
5643         kmem_free(log->l_buf_cancel_table);
5644         log->l_buf_cancel_table = NULL;
5645
5646         return error;
5647 }
5648
5649 /*
5650  * Do the actual recovery
5651  */
5652 STATIC int
5653 xlog_do_recover(
5654         struct xlog     *log,
5655         xfs_daddr_t     head_blk,
5656         xfs_daddr_t     tail_blk)
5657 {
5658         struct xfs_mount *mp = log->l_mp;
5659         int             error;
5660         xfs_buf_t       *bp;
5661         xfs_sb_t        *sbp;
5662
5663         trace_xfs_log_recover(log, head_blk, tail_blk);
5664
5665         /*
5666          * First replay the images in the log.
5667          */
5668         error = xlog_do_log_recovery(log, head_blk, tail_blk);
5669         if (error)
5670                 return error;
5671
5672         /*
5673          * If IO errors happened during recovery, bail out.
5674          */
5675         if (XFS_FORCED_SHUTDOWN(mp)) {
5676                 return -EIO;
5677         }
5678
5679         /*
5680          * We now update the tail_lsn since much of the recovery has completed
5681          * and there may be space available to use.  If there were no extent
5682          * or iunlinks, we can free up the entire log and set the tail_lsn to
5683          * be the last_sync_lsn.  This was set in xlog_find_tail to be the
5684          * lsn of the last known good LR on disk.  If there are extent frees
5685          * or iunlinks they will have some entries in the AIL; so we look at
5686          * the AIL to determine how to set the tail_lsn.
5687          */
5688         xlog_assign_tail_lsn(mp);
5689
5690         /*
5691          * Now that we've finished replaying all buffer and inode
5692          * updates, re-read in the superblock and reverify it.
5693          */
5694         bp = xfs_getsb(mp, 0);
5695         bp->b_flags &= ~(XBF_DONE | XBF_ASYNC);
5696         ASSERT(!(bp->b_flags & XBF_WRITE));
5697         bp->b_flags |= XBF_READ;
5698         bp->b_ops = &xfs_sb_buf_ops;
5699
5700         error = xfs_buf_submit(bp);
5701         if (error) {
5702                 if (!XFS_FORCED_SHUTDOWN(mp)) {
5703                         xfs_buf_ioerror_alert(bp, __func__);
5704                         ASSERT(0);
5705                 }
5706                 xfs_buf_relse(bp);
5707                 return error;
5708         }
5709
5710         /* Convert superblock from on-disk format */
5711         sbp = &mp->m_sb;
5712         xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
5713         xfs_buf_relse(bp);
5714
5715         /* re-initialise in-core superblock and geometry structures */
5716         xfs_reinit_percpu_counters(mp);
5717         error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
5718         if (error) {
5719                 xfs_warn(mp, "Failed post-recovery per-ag init: %d", error);
5720                 return error;
5721         }
5722         mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
5723
5724         xlog_recover_check_summary(log);
5725
5726         /* Normal transactions can now occur */
5727         log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
5728         return 0;
5729 }
5730
5731 /*
5732  * Perform recovery and re-initialize some log variables in xlog_find_tail.
5733  *
5734  * Return error or zero.
5735  */
5736 int
5737 xlog_recover(
5738         struct xlog     *log)
5739 {
5740         xfs_daddr_t     head_blk, tail_blk;
5741         int             error;
5742
5743         /* find the tail of the log */
5744         error = xlog_find_tail(log, &head_blk, &tail_blk);
5745         if (error)
5746                 return error;
5747
5748         /*
5749          * The superblock was read before the log was available and thus the LSN
5750          * could not be verified. Check the superblock LSN against the current
5751          * LSN now that it's known.
5752          */
5753         if (xfs_sb_version_hascrc(&log->l_mp->m_sb) &&
5754             !xfs_log_check_lsn(log->l_mp, log->l_mp->m_sb.sb_lsn))
5755                 return -EINVAL;
5756
5757         if (tail_blk != head_blk) {
5758                 /* There used to be a comment here:
5759                  *
5760                  * disallow recovery on read-only mounts.  note -- mount
5761                  * checks for ENOSPC and turns it into an intelligent
5762                  * error message.
5763                  * ...but this is no longer true.  Now, unless you specify
5764                  * NORECOVERY (in which case this function would never be
5765                  * called), we just go ahead and recover.  We do this all
5766                  * under the vfs layer, so we can get away with it unless
5767                  * the device itself is read-only, in which case we fail.
5768                  */
5769                 if ((error = xfs_dev_is_read_only(log->l_mp, "recovery"))) {
5770                         return error;
5771                 }
5772
5773                 /*
5774                  * Version 5 superblock log feature mask validation. We know the
5775                  * log is dirty so check if there are any unknown log features
5776                  * in what we need to recover. If there are unknown features
5777                  * (e.g. unsupported transactions, then simply reject the
5778                  * attempt at recovery before touching anything.
5779                  */
5780                 if (XFS_SB_VERSION_NUM(&log->l_mp->m_sb) == XFS_SB_VERSION_5 &&
5781                     xfs_sb_has_incompat_log_feature(&log->l_mp->m_sb,
5782                                         XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN)) {
5783                         xfs_warn(log->l_mp,
5784 "Superblock has unknown incompatible log features (0x%x) enabled.",
5785                                 (log->l_mp->m_sb.sb_features_log_incompat &
5786                                         XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
5787                         xfs_warn(log->l_mp,
5788 "The log can not be fully and/or safely recovered by this kernel.");
5789                         xfs_warn(log->l_mp,
5790 "Please recover the log on a kernel that supports the unknown features.");
5791                         return -EINVAL;
5792                 }
5793
5794                 /*
5795                  * Delay log recovery if the debug hook is set. This is debug
5796                  * instrumention to coordinate simulation of I/O failures with
5797                  * log recovery.
5798                  */
5799                 if (xfs_globals.log_recovery_delay) {
5800                         xfs_notice(log->l_mp,
5801                                 "Delaying log recovery for %d seconds.",
5802                                 xfs_globals.log_recovery_delay);
5803                         msleep(xfs_globals.log_recovery_delay * 1000);
5804                 }
5805
5806                 xfs_notice(log->l_mp, "Starting recovery (logdev: %s)",
5807                                 log->l_mp->m_logname ? log->l_mp->m_logname
5808                                                      : "internal");
5809
5810                 error = xlog_do_recover(log, head_blk, tail_blk);
5811                 log->l_flags |= XLOG_RECOVERY_NEEDED;
5812         }
5813         return error;
5814 }
5815
5816 /*
5817  * In the first part of recovery we replay inodes and buffers and build
5818  * up the list of extent free items which need to be processed.  Here
5819  * we process the extent free items and clean up the on disk unlinked
5820  * inode lists.  This is separated from the first part of recovery so
5821  * that the root and real-time bitmap inodes can be read in from disk in
5822  * between the two stages.  This is necessary so that we can free space
5823  * in the real-time portion of the file system.
5824  */
5825 int
5826 xlog_recover_finish(
5827         struct xlog     *log)
5828 {
5829         /*
5830          * Now we're ready to do the transactions needed for the
5831          * rest of recovery.  Start with completing all the extent
5832          * free intent records and then process the unlinked inode
5833          * lists.  At this point, we essentially run in normal mode
5834          * except that we're still performing recovery actions
5835          * rather than accepting new requests.
5836          */
5837         if (log->l_flags & XLOG_RECOVERY_NEEDED) {
5838                 int     error;
5839                 error = xlog_recover_process_intents(log);
5840                 if (error) {
5841                         xfs_alert(log->l_mp, "Failed to recover intents");
5842                         return error;
5843                 }
5844
5845                 /*
5846                  * Sync the log to get all the intents out of the AIL.
5847                  * This isn't absolutely necessary, but it helps in
5848                  * case the unlink transactions would have problems
5849                  * pushing the intents out of the way.
5850                  */
5851                 xfs_log_force(log->l_mp, XFS_LOG_SYNC);
5852
5853                 xlog_recover_process_iunlinks(log);
5854
5855                 xlog_recover_check_summary(log);
5856
5857                 xfs_notice(log->l_mp, "Ending recovery (logdev: %s)",
5858                                 log->l_mp->m_logname ? log->l_mp->m_logname
5859                                                      : "internal");
5860                 log->l_flags &= ~XLOG_RECOVERY_NEEDED;
5861         } else {
5862                 xfs_info(log->l_mp, "Ending clean mount");
5863         }
5864         return 0;
5865 }
5866
5867 int
5868 xlog_recover_cancel(
5869         struct xlog     *log)
5870 {
5871         int             error = 0;
5872
5873         if (log->l_flags & XLOG_RECOVERY_NEEDED)
5874                 error = xlog_recover_cancel_intents(log);
5875
5876         return error;
5877 }
5878
5879 #if defined(DEBUG)
5880 /*
5881  * Read all of the agf and agi counters and check that they
5882  * are consistent with the superblock counters.
5883  */
5884 STATIC void
5885 xlog_recover_check_summary(
5886         struct xlog     *log)
5887 {
5888         xfs_mount_t     *mp;
5889         xfs_agf_t       *agfp;
5890         xfs_buf_t       *agfbp;
5891         xfs_buf_t       *agibp;
5892         xfs_agnumber_t  agno;
5893         uint64_t        freeblks;
5894         uint64_t        itotal;
5895         uint64_t        ifree;
5896         int             error;
5897
5898         mp = log->l_mp;
5899
5900         freeblks = 0LL;
5901         itotal = 0LL;
5902         ifree = 0LL;
5903         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
5904                 error = xfs_read_agf(mp, NULL, agno, 0, &agfbp);
5905                 if (error) {
5906                         xfs_alert(mp, "%s agf read failed agno %d error %d",
5907                                                 __func__, agno, error);
5908                 } else {
5909                         agfp = XFS_BUF_TO_AGF(agfbp);
5910                         freeblks += be32_to_cpu(agfp->agf_freeblks) +
5911                                     be32_to_cpu(agfp->agf_flcount);
5912                         xfs_buf_relse(agfbp);
5913                 }
5914
5915                 error = xfs_read_agi(mp, NULL, agno, &agibp);
5916                 if (error) {
5917                         xfs_alert(mp, "%s agi read failed agno %d error %d",
5918                                                 __func__, agno, error);
5919                 } else {
5920                         struct xfs_agi  *agi = XFS_BUF_TO_AGI(agibp);
5921
5922                         itotal += be32_to_cpu(agi->agi_count);
5923                         ifree += be32_to_cpu(agi->agi_freecount);
5924                         xfs_buf_relse(agibp);
5925                 }
5926         }
5927 }
5928 #endif /* DEBUG */