fs/xfs/xfs_log_recover.c

   1 /*
   2  * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of version 2 of the GNU General Public License as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it would be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * Further, this software is distributed without any warranty that it is
  13  * free of the rightful claim of any third person regarding infringement
  14  * or the like.  Any license provided herein, whether implied or
  15  * otherwise, applies only to this software file.  Patent licenses, if
  16  * any, provided herein do not apply to combinations of this program with
  17  * other software, or any other product whatsoever.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write the Free Software Foundation, Inc., 59
  21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
  22  *
  23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  24  * Mountain View, CA  94043, or:
  25  *
  26  * http://www.sgi.com
  27  *
  28  * For further information regarding this notice, see:
  29  *
  30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
  31  */
  32
  33 #include "xfs.h"
  34 #include "xfs_macros.h"
  35 #include "xfs_types.h"
  36 #include "xfs_inum.h"
  37 #include "xfs_log.h"
  38 #include "xfs_ag.h"
  39 #include "xfs_sb.h"
  40 #include "xfs_trans.h"
  41 #include "xfs_dir.h"
  42 #include "xfs_dir2.h"
  43 #include "xfs_dmapi.h"
  44 #include "xfs_mount.h"
  45 #include "xfs_error.h"
  46 #include "xfs_bmap_btree.h"
  47 #include "xfs_alloc.h"
  48 #include "xfs_attr_sf.h"
  49 #include "xfs_dir_sf.h"
  50 #include "xfs_dir2_sf.h"
  51 #include "xfs_dinode.h"
  52 #include "xfs_imap.h"
  53 #include "xfs_inode_item.h"
  54 #include "xfs_inode.h"
  55 #include "xfs_ialloc_btree.h"
  56 #include "xfs_ialloc.h"
  57 #include "xfs_log_priv.h"
  58 #include "xfs_buf_item.h"
  59 #include "xfs_alloc_btree.h"
  60 #include "xfs_log_recover.h"
  61 #include "xfs_extfree_item.h"
  62 #include "xfs_trans_priv.h"
  63 #include "xfs_bit.h"
  64 #include "xfs_quota.h"
  65 #include "xfs_rw.h"
  66
  67 STATIC int      xlog_find_zeroed(xlog_t *, xfs_daddr_t *);
  68 STATIC int      xlog_clear_stale_blocks(xlog_t *, xfs_lsn_t);
  69 STATIC void     xlog_recover_insert_item_backq(xlog_recover_item_t **q,
  70                                                xlog_recover_item_t *item);
  71 #if defined(DEBUG)
  72 STATIC void     xlog_recover_check_summary(xlog_t *);
  73 STATIC void     xlog_recover_check_ail(xfs_mount_t *, xfs_log_item_t *, int);
  74 #else
  75 #define xlog_recover_check_summary(log)
  76 #define xlog_recover_check_ail(mp, lip, gen)
  77 #endif
  78
  79
  80 /*
  81  * Sector aligned buffer routines for buffer create/read/write/access
  82  */
  83
  84 #define XLOG_SECTOR_ROUNDUP_BBCOUNT(log, bbs)   \
  85         ( ((log)->l_sectbb_mask && (bbs & (log)->l_sectbb_mask)) ? \
  86         ((bbs + (log)->l_sectbb_mask + 1) & ~(log)->l_sectbb_mask) : (bbs) )
  87 #define XLOG_SECTOR_ROUNDDOWN_BLKNO(log, bno)   ((bno) & ~(log)->l_sectbb_mask)
  88
  89 xfs_buf_t *
  90 xlog_get_bp(
  91         xlog_t          *log,
  92         int             num_bblks)
  93 {
  94         ASSERT(num_bblks > 0);
  95
  96         if (log->l_sectbb_log) {
  97                 if (num_bblks > 1)
  98                         num_bblks += XLOG_SECTOR_ROUNDUP_BBCOUNT(log, 1);
  99                 num_bblks = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, num_bblks);
 100         }
 101         return xfs_buf_get_noaddr(BBTOB(num_bblks), log->l_mp->m_logdev_targp);
 102 }
 103
 104 void
 105 xlog_put_bp(
 106         xfs_buf_t       *bp)
 107 {
 108         xfs_buf_free(bp);
 109 }
 110
 111
 112 /*
 113  * nbblks should be uint, but oh well.  Just want to catch that 32-bit length.
 114  */
 115 int
 116 xlog_bread(
 117         xlog_t          *log,
 118         xfs_daddr_t     blk_no,
 119         int             nbblks,
 120         xfs_buf_t       *bp)
 121 {
 122         int             error;
 123
 124         if (log->l_sectbb_log) {
 125                 blk_no = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, blk_no);
 126                 nbblks = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, nbblks);
 127         }
 128
 129         ASSERT(nbblks > 0);
 130         ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));
 131         ASSERT(bp);
 132
 133         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
 134         XFS_BUF_READ(bp);
 135         XFS_BUF_BUSY(bp);
 136         XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
 137         XFS_BUF_SET_TARGET(bp, log->l_mp->m_logdev_targp);
 138
 139         xfsbdstrat(log->l_mp, bp);
 140         if ((error = xfs_iowait(bp)))
 141                 xfs_ioerror_alert("xlog_bread", log->l_mp,
 142                                   bp, XFS_BUF_ADDR(bp));
 143         return error;
 144 }
 145
 146 /*
 147  * Write out the buffer at the given block for the given number of blocks.
 148  * The buffer is kept locked across the write and is returned locked.
 149  * This can only be used for synchronous log writes.
 150  */
 151 int
 152 xlog_bwrite(
 153         xlog_t          *log,
 154         xfs_daddr_t     blk_no,
 155         int             nbblks,
 156         xfs_buf_t       *bp)
 157 {
 158         int             error;
 159
 160         if (log->l_sectbb_log) {
 161                 blk_no = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, blk_no);
 162                 nbblks = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, nbblks);
 163         }
 164
 165         ASSERT(nbblks > 0);
 166         ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));
 167
 168         XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
 169         XFS_BUF_ZEROFLAGS(bp);
 170         XFS_BUF_BUSY(bp);
 171         XFS_BUF_HOLD(bp);
 172         XFS_BUF_PSEMA(bp, PRIBIO);
 173         XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
 174         XFS_BUF_SET_TARGET(bp, log->l_mp->m_logdev_targp);
 175
 176         if ((error = xfs_bwrite(log->l_mp, bp)))
 177                 xfs_ioerror_alert("xlog_bwrite", log->l_mp,
 178                                   bp, XFS_BUF_ADDR(bp));
 179         return error;
 180 }
 181
 182 xfs_caddr_t
 183 xlog_align(
 184         xlog_t          *log,
 185         xfs_daddr_t     blk_no,
 186         int             nbblks,
 187         xfs_buf_t       *bp)
 188 {
 189         xfs_caddr_t     ptr;
 190
 191         if (!log->l_sectbb_log)
 192                 return XFS_BUF_PTR(bp);
 193
 194         ptr = XFS_BUF_PTR(bp) + BBTOB((int)blk_no & log->l_sectbb_mask);
 195         ASSERT(XFS_BUF_SIZE(bp) >=
 196                 BBTOB(nbblks + (blk_no & log->l_sectbb_mask)));
 197         return ptr;
 198 }
 199
 200 #ifdef DEBUG
 201 /*
 202  * dump debug superblock and log record information
 203  */
 204 STATIC void
 205 xlog_header_check_dump(
 206         xfs_mount_t             *mp,
 207         xlog_rec_header_t       *head)
 208 {
 209         int                     b;
 210
 211         printk("%s:  SB : uuid = ", __FUNCTION__);
 212         for (b = 0; b < 16; b++)
 213                 printk("%02x",((unsigned char *)&mp->m_sb.sb_uuid)[b]);
 214         printk(", fmt = %d\n", XLOG_FMT);
 215         printk("    log : uuid = ");
 216         for (b = 0; b < 16; b++)
 217                 printk("%02x",((unsigned char *)&head->h_fs_uuid)[b]);
 218         printk(", fmt = %d\n", INT_GET(head->h_fmt, ARCH_CONVERT));
 219 }
 220 #else
 221 #define xlog_header_check_dump(mp, head)
 222 #endif
 223
 224 /*
 225  * check log record header for recovery
 226  */
 227 STATIC int
 228 xlog_header_check_recover(
 229         xfs_mount_t             *mp,
 230         xlog_rec_header_t       *head)
 231 {
 232         ASSERT(INT_GET(head->h_magicno, ARCH_CONVERT) == XLOG_HEADER_MAGIC_NUM);
 233
 234         /*
 235          * IRIX doesn't write the h_fmt field and leaves it zeroed
 236          * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
 237          * a dirty log created in IRIX.
 238          */
 239         if (unlikely(INT_GET(head->h_fmt, ARCH_CONVERT) != XLOG_FMT)) {
 240                 xlog_warn(
 241         "XFS: dirty log written in incompatible format - can't recover");
 242                 xlog_header_check_dump(mp, head);
 243                 XFS_ERROR_REPORT("xlog_header_check_recover(1)",
 244                                  XFS_ERRLEVEL_HIGH, mp);
 245                 return XFS_ERROR(EFSCORRUPTED);
 246         } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
 247                 xlog_warn(
 248         "XFS: dirty log entry has mismatched uuid - can't recover");
 249                 xlog_header_check_dump(mp, head);
 250                 XFS_ERROR_REPORT("xlog_header_check_recover(2)",
 251                                  XFS_ERRLEVEL_HIGH, mp);
 252                 return XFS_ERROR(EFSCORRUPTED);
 253         }
 254         return 0;
 255 }
 256
 257 /*
 258  * read the head block of the log and check the header
 259  */
 260 STATIC int
 261 xlog_header_check_mount(
 262         xfs_mount_t             *mp,
 263         xlog_rec_header_t       *head)
 264 {
 265         ASSERT(INT_GET(head->h_magicno, ARCH_CONVERT) == XLOG_HEADER_MAGIC_NUM);
 266
 267         if (uuid_is_nil(&head->h_fs_uuid)) {
 268                 /*
 269                  * IRIX doesn't write the h_fs_uuid or h_fmt fields. If
 270                  * h_fs_uuid is nil, we assume this log was last mounted
 271                  * by IRIX and continue.
 272                  */
 273                 xlog_warn("XFS: nil uuid in log - IRIX style log");
 274         } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
 275                 xlog_warn("XFS: log has mismatched uuid - can't recover");
 276                 xlog_header_check_dump(mp, head);
 277                 XFS_ERROR_REPORT("xlog_header_check_mount",
 278                                  XFS_ERRLEVEL_HIGH, mp);
 279                 return XFS_ERROR(EFSCORRUPTED);
 280         }
 281         return 0;
 282 }
 283
 284 STATIC void
 285 xlog_recover_iodone(
 286         struct xfs_buf  *bp)
 287 {
 288         xfs_mount_t     *mp;
 289
 290         ASSERT(XFS_BUF_FSPRIVATE(bp, void *));
 291
 292         if (XFS_BUF_GETERROR(bp)) {
 293                 /*
 294                  * We're not going to bother about retrying
 295                  * this during recovery. One strike!
 296                  */
 297                 mp = XFS_BUF_FSPRIVATE(bp, xfs_mount_t *);
 298                 xfs_ioerror_alert("xlog_recover_iodone",
 299                                   mp, bp, XFS_BUF_ADDR(bp));
 300                 xfs_force_shutdown(mp, XFS_METADATA_IO_ERROR);
 301         }
 302         XFS_BUF_SET_FSPRIVATE(bp, NULL);
 303         XFS_BUF_CLR_IODONE_FUNC(bp);
 304         xfs_biodone(bp);
 305 }
 306
 307 /*
 308  * This routine finds (to an approximation) the first block in the physical
 309  * log which contains the given cycle.  It uses a binary search algorithm.
 310  * Note that the algorithm can not be perfect because the disk will not
 311  * necessarily be perfect.
 312  */
 313 int
 314 xlog_find_cycle_start(
 315         xlog_t          *log,
 316         xfs_buf_t       *bp,
 317         xfs_daddr_t     first_blk,
 318         xfs_daddr_t     *last_blk,
 319         uint            cycle)
 320 {
 321         xfs_caddr_t     offset;
 322         xfs_daddr_t     mid_blk;
 323         uint            mid_cycle;
 324         int             error;
 325
 326         mid_blk = BLK_AVG(first_blk, *last_blk);
 327         while (mid_blk != first_blk && mid_blk != *last_blk) {
 328                 if ((error = xlog_bread(log, mid_blk, 1, bp)))
 329                         return error;
 330                 offset = xlog_align(log, mid_blk, 1, bp);
 331                 mid_cycle = GET_CYCLE(offset, ARCH_CONVERT);
 332                 if (mid_cycle == cycle) {
 333                         *last_blk = mid_blk;
 334                         /* last_half_cycle == mid_cycle */
 335                 } else {
 336                         first_blk = mid_blk;
 337                         /* first_half_cycle == mid_cycle */
 338                 }
 339                 mid_blk = BLK_AVG(first_blk, *last_blk);
 340         }
 341         ASSERT((mid_blk == first_blk && mid_blk+1 == *last_blk) ||
 342                (mid_blk == *last_blk && mid_blk-1 == first_blk));
 343
 344         return 0;
 345 }
 346
 347 /*
 348  * Check that the range of blocks does not contain the cycle number
 349  * given.  The scan needs to occur from front to back and the ptr into the
 350  * region must be updated since a later routine will need to perform another
 351  * test.  If the region is completely good, we end up returning the same
 352  * last block number.
 353  *
 354  * Set blkno to -1 if we encounter no errors.  This is an invalid block number
 355  * since we don't ever expect logs to get this large.
 356  */
 357 STATIC int
 358 xlog_find_verify_cycle(
 359         xlog_t          *log,
 360         xfs_daddr_t     start_blk,
 361         int             nbblks,
 362         uint            stop_on_cycle_no,
 363         xfs_daddr_t     *new_blk)
 364 {
 365         xfs_daddr_t     i, j;
 366         uint            cycle;
 367         xfs_buf_t       *bp;
 368         xfs_daddr_t     bufblks;
 369         xfs_caddr_t     buf = NULL;
 370         int             error = 0;
 371
 372         bufblks = 1 << ffs(nbblks);
 373
 374         while (!(bp = xlog_get_bp(log, bufblks))) {
 375                 /* can't get enough memory to do everything in one big buffer */
 376                 bufblks >>= 1;
 377                 if (bufblks <= log->l_sectbb_log)
 378                         return ENOMEM;
 379         }
 380
 381         for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
 382                 int     bcount;
 383
 384                 bcount = min(bufblks, (start_blk + nbblks - i));
 385
 386                 if ((error = xlog_bread(log, i, bcount, bp)))
 387                         goto out;
 388
 389                 buf = xlog_align(log, i, bcount, bp);
 390                 for (j = 0; j < bcount; j++) {
 391                         cycle = GET_CYCLE(buf, ARCH_CONVERT);
 392                         if (cycle == stop_on_cycle_no) {
 393                                 *new_blk = i+j;
 394                                 goto out;
 395                         }
 396
 397                         buf += BBSIZE;
 398                 }
 399         }
 400
 401         *new_blk = -1;
 402
 403 out:
 404         xlog_put_bp(bp);
 405         return error;
 406 }
 407
 408 /*
 409  * Potentially backup over partial log record write.
 410  *
 411  * In the typical case, last_blk is the number of the block directly after
 412  * a good log record.  Therefore, we subtract one to get the block number
 413  * of the last block in the given buffer.  extra_bblks contains the number
 414  * of blocks we would have read on a previous read.  This happens when the
 415  * last log record is split over the end of the physical log.
 416  *
 417  * extra_bblks is the number of blocks potentially verified on a previous
 418  * call to this routine.
 419  */
 420 STATIC int
 421 xlog_find_verify_log_record(
 422         xlog_t                  *log,
 423         xfs_daddr_t             start_blk,
 424         xfs_daddr_t             *last_blk,
 425         int                     extra_bblks)
 426 {
 427         xfs_daddr_t             i;
 428         xfs_buf_t               *bp;
 429         xfs_caddr_t             offset = NULL;
 430         xlog_rec_header_t       *head = NULL;
 431         int                     error = 0;
 432         int                     smallmem = 0;
 433         int                     num_blks = *last_blk - start_blk;
 434         int                     xhdrs;
 435
 436         ASSERT(start_blk != 0 || *last_blk != start_blk);
 437
 438         if (!(bp = xlog_get_bp(log, num_blks))) {
 439                 if (!(bp = xlog_get_bp(log, 1)))
 440                         return ENOMEM;
 441                 smallmem = 1;
 442         } else {
 443                 if ((error = xlog_bread(log, start_blk, num_blks, bp)))
 444                         goto out;
 445                 offset = xlog_align(log, start_blk, num_blks, bp);
 446                 offset += ((num_blks - 1) << BBSHIFT);
 447         }
 448
 449         for (i = (*last_blk) - 1; i >= 0; i--) {
 450                 if (i < start_blk) {
 451                         /* valid log record not found */
 452                         xlog_warn(
 453                 "XFS: Log inconsistent (didn't find previous header)");
 454                         ASSERT(0);
 455                         error = XFS_ERROR(EIO);
 456                         goto out;
 457                 }
 458
 459                 if (smallmem) {
 460                         if ((error = xlog_bread(log, i, 1, bp)))
 461                                 goto out;
 462                         offset = xlog_align(log, i, 1, bp);
 463                 }
 464
 465                 head = (xlog_rec_header_t *)offset;
 466
 467                 if (XLOG_HEADER_MAGIC_NUM ==
 468                     INT_GET(head->h_magicno, ARCH_CONVERT))
 469                         break;
 470
 471                 if (!smallmem)
 472                         offset -= BBSIZE;
 473         }
 474
 475         /*
 476          * We hit the beginning of the physical log & still no header.  Return
 477          * to caller.  If caller can handle a return of -1, then this routine
 478          * will be called again for the end of the physical log.
 479          */
 480         if (i == -1) {
 481                 error = -1;
 482                 goto out;
 483         }
 484
 485         /*
 486          * We have the final block of the good log (the first block
 487          * of the log record _before_ the head. So we check the uuid.
 488          */
 489         if ((error = xlog_header_check_mount(log->l_mp, head)))
 490                 goto out;
 491
 492         /*
 493          * We may have found a log record header before we expected one.
 494          * last_blk will be the 1st block # with a given cycle #.  We may end
 495          * up reading an entire log record.  In this case, we don't want to
 496          * reset last_blk.  Only when last_blk points in the middle of a log
 497          * record do we update last_blk.
 498          */
 499         if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
 500                 uint    h_size = INT_GET(head->h_size, ARCH_CONVERT);
 501
 502                 xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
 503                 if (h_size % XLOG_HEADER_CYCLE_SIZE)
 504                         xhdrs++;
 505         } else {
 506                 xhdrs = 1;
 507         }
 508
 509         if (*last_blk - i + extra_bblks
 510                         != BTOBB(INT_GET(head->h_len, ARCH_CONVERT)) + xhdrs)
 511                 *last_blk = i;
 512
 513 out:
 514         xlog_put_bp(bp);
 515         return error;
 516 }
 517
 518 /*
 519  * Head is defined to be the point of the log where the next log write
 520  * write could go.  This means that incomplete LR writes at the end are
 521  * eliminated when calculating the head.  We aren't guaranteed that previous
 522  * LR have complete transactions.  We only know that a cycle number of
 523  * current cycle number -1 won't be present in the log if we start writing
 524  * from our current block number.
 525  *
 526  * last_blk contains the block number of the first block with a given
 527  * cycle number.
 528  *
 529  * Return: zero if normal, non-zero if error.
 530  */
 531 int
 532 xlog_find_head(
 533         xlog_t          *log,
 534         xfs_daddr_t     *return_head_blk)
 535 {
 536         xfs_buf_t       *bp;
 537         xfs_caddr_t     offset;
 538         xfs_daddr_t     new_blk, first_blk, start_blk, last_blk, head_blk;
 539         int             num_scan_bblks;
 540         uint            first_half_cycle, last_half_cycle;
 541         uint            stop_on_cycle;
 542         int             error, log_bbnum = log->l_logBBsize;
 543
 544         /* Is the end of the log device zeroed? */
 545         if ((error = xlog_find_zeroed(log, &first_blk)) == -1) {
 546                 *return_head_blk = first_blk;
 547
 548                 /* Is the whole lot zeroed? */
 549                 if (!first_blk) {
 550                         /* Linux XFS shouldn't generate totally zeroed logs -
 551                          * mkfs etc write a dummy unmount record to a fresh
 552                          * log so we can store the uuid in there
 553                          */
 554                         xlog_warn("XFS: totally zeroed log");
 555                 }
 556
 557                 return 0;
 558         } else if (error) {
 559                 xlog_warn("XFS: empty log check failed");
 560                 return error;
 561         }
 562
 563         first_blk = 0;                  /* get cycle # of 1st block */
 564         bp = xlog_get_bp(log, 1);
 565         if (!bp)
 566                 return ENOMEM;
 567         if ((error = xlog_bread(log, 0, 1, bp)))
 568                 goto bp_err;
 569         offset = xlog_align(log, 0, 1, bp);
 570         first_half_cycle = GET_CYCLE(offset, ARCH_CONVERT);
 571
 572         last_blk = head_blk = log_bbnum - 1;    /* get cycle # of last block */
 573         if ((error = xlog_bread(log, last_blk, 1, bp)))
 574                 goto bp_err;
 575         offset = xlog_align(log, last_blk, 1, bp);
 576         last_half_cycle = GET_CYCLE(offset, ARCH_CONVERT);
 577         ASSERT(last_half_cycle != 0);
 578
 579         /*
 580          * If the 1st half cycle number is equal to the last half cycle number,
 581          * then the entire log is stamped with the same cycle number.  In this
 582          * case, head_blk can't be set to zero (which makes sense).  The below
 583          * math doesn't work out properly with head_blk equal to zero.  Instead,
 584          * we set it to log_bbnum which is an invalid block number, but this
 585          * value makes the math correct.  If head_blk doesn't changed through
 586          * all the tests below, *head_blk is set to zero at the very end rather
 587          * than log_bbnum.  In a sense, log_bbnum and zero are the same block
 588          * in a circular file.
 589          */
 590         if (first_half_cycle == last_half_cycle) {
 591                 /*
 592                  * In this case we believe that the entire log should have
 593                  * cycle number last_half_cycle.  We need to scan backwards
 594                  * from the end verifying that there are no holes still
 595                  * containing last_half_cycle - 1.  If we find such a hole,
 596                  * then the start of that hole will be the new head.  The
 597                  * simple case looks like
 598                  *        x | x ... | x - 1 | x
 599                  * Another case that fits this picture would be
 600                  *        x | x + 1 | x ... | x
 601                  * In this case the head really is somwhere at the end of the
 602                  * log, as one of the latest writes at the beginning was
 603                  * incomplete.
 604                  * One more case is
 605                  *        x | x + 1 | x ... | x - 1 | x
 606                  * This is really the combination of the above two cases, and
 607                  * the head has to end up at the start of the x-1 hole at the
 608                  * end of the log.
 609                  *
 610                  * In the 256k log case, we will read from the beginning to the
 611                  * end of the log and search for cycle numbers equal to x-1.
 612                  * We don't worry about the x+1 blocks that we encounter,
 613                  * because we know that they cannot be the head since the log
 614                  * started with x.
 615                  */
 616                 head_blk = log_bbnum;
 617                 stop_on_cycle = last_half_cycle - 1;
 618         } else {
 619                 /*
 620                  * In this case we want to find the first block with cycle
 621                  * number matching last_half_cycle.  We expect the log to be
 622                  * some variation on
 623                  *        x + 1 ... | x ...
 624                  * The first block with cycle number x (last_half_cycle) will
 625                  * be where the new head belongs.  First we do a binary search
 626                  * for the first occurrence of last_half_cycle.  The binary
 627                  * search may not be totally accurate, so then we scan back
 628                  * from there looking for occurrences of last_half_cycle before
 629                  * us.  If that backwards scan wraps around the beginning of
 630                  * the log, then we look for occurrences of last_half_cycle - 1
 631                  * at the end of the log.  The cases we're looking for look
 632                  * like
 633                  *        x + 1 ... | x | x + 1 | x ...
 634                  *                               ^ binary search stopped here
 635                  * or
 636                  *        x + 1 ... | x ... | x - 1 | x
 637                  *        <---------> less than scan distance
 638                  */
 639                 stop_on_cycle = last_half_cycle;
 640                 if ((error = xlog_find_cycle_start(log, bp, first_blk,
 641                                                 &head_blk, last_half_cycle)))
 642                         goto bp_err;
 643         }
 644
 645         /*
 646          * Now validate the answer.  Scan back some number of maximum possible
 647          * blocks and make sure each one has the expected cycle number.  The
 648          * maximum is determined by the total possible amount of buffering
 649          * in the in-core log.  The following number can be made tighter if
 650          * we actually look at the block size of the filesystem.
 651          */
 652         num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
 653         if (head_blk >= num_scan_bblks) {
 654                 /*
 655                  * We are guaranteed that the entire check can be performed
 656                  * in one buffer.
 657                  */
 658                 start_blk = head_blk - num_scan_bblks;
 659                 if ((error = xlog_find_verify_cycle(log,
 660                                                 start_blk, num_scan_bblks,
 661                                                 stop_on_cycle, &new_blk)))
 662                         goto bp_err;
 663                 if (new_blk != -1)
 664                         head_blk = new_blk;
 665         } else {                /* need to read 2 parts of log */
 666                 /*
 667                  * We are going to scan backwards in the log in two parts.
 668                  * First we scan the physical end of the log.  In this part
 669                  * of the log, we are looking for blocks with cycle number
 670                  * last_half_cycle - 1.
 671                  * If we find one, then we know that the log starts there, as
 672                  * we've found a hole that didn't get written in going around
 673                  * the end of the physical log.  The simple case for this is
 674                  *        x + 1 ... | x ... | x - 1 | x
 675                  *        <---------> less than scan distance
 676                  * If all of the blocks at the end of the log have cycle number
 677                  * last_half_cycle, then we check the blocks at the start of
 678                  * the log looking for occurrences of last_half_cycle.  If we
 679                  * find one, then our current estimate for the location of the
 680                  * first occurrence of last_half_cycle is wrong and we move
 681                  * back to the hole we've found.  This case looks like
 682                  *        x + 1 ... | x | x + 1 | x ...
 683                  *                               ^ binary search stopped here
 684                  * Another case we need to handle that only occurs in 256k
 685                  * logs is
 686                  *        x + 1 ... | x ... | x+1 | x ...
 687                  *                   ^ binary search stops here
 688                  * In a 256k log, the scan at the end of the log will see the
 689                  * x + 1 blocks.  We need to skip past those since that is
 690                  * certainly not the head of the log.  By searching for
 691                  * last_half_cycle-1 we accomplish that.
 692                  */
 693                 start_blk = log_bbnum - num_scan_bblks + head_blk;
 694                 ASSERT(head_blk <= INT_MAX &&
 695                         (xfs_daddr_t) num_scan_bblks - head_blk >= 0);
 696                 if ((error = xlog_find_verify_cycle(log, start_blk,
 697                                         num_scan_bblks - (int)head_blk,
 698                                         (stop_on_cycle - 1), &new_blk)))
 699                         goto bp_err;
 700                 if (new_blk != -1) {
 701                         head_blk = new_blk;
 702                         goto bad_blk;
 703                 }
 704
 705                 /*
 706                  * Scan beginning of log now.  The last part of the physical
 707                  * log is good.  This scan needs to verify that it doesn't find
 708                  * the last_half_cycle.
 709                  */
 710                 start_blk = 0;
 711                 ASSERT(head_blk <= INT_MAX);
 712                 if ((error = xlog_find_verify_cycle(log,
 713                                         start_blk, (int)head_blk,
 714                                         stop_on_cycle, &new_blk)))
 715                         goto bp_err;
 716                 if (new_blk != -1)
 717                         head_blk = new_blk;
 718         }
 719
 720  bad_blk:
 721         /*
 722          * Now we need to make sure head_blk is not pointing to a block in
 723          * the middle of a log record.
 724          */
 725         num_scan_bblks = XLOG_REC_SHIFT(log);
 726         if (head_blk >= num_scan_bblks) {
 727                 start_blk = head_blk - num_scan_bblks; /* don't read head_blk */
 728
 729                 /* start ptr at last block ptr before head_blk */
 730                 if ((error = xlog_find_verify_log_record(log, start_blk,
 731                                                         &head_blk, 0)) == -1) {
 732                         error = XFS_ERROR(EIO);
 733                         goto bp_err;
 734                 } else if (error)
 735                         goto bp_err;
 736         } else {
 737                 start_blk = 0;
 738                 ASSERT(head_blk <= INT_MAX);
 739                 if ((error = xlog_find_verify_log_record(log, start_blk,
 740                                                         &head_blk, 0)) == -1) {
 741                         /* We hit the beginning of the log during our search */
 742                         start_blk = log_bbnum - num_scan_bblks + head_blk;
 743                         new_blk = log_bbnum;
 744                         ASSERT(start_blk <= INT_MAX &&
 745                                 (xfs_daddr_t) log_bbnum-start_blk >= 0);
 746                         ASSERT(head_blk <= INT_MAX);
 747                         if ((error = xlog_find_verify_log_record(log,
 748                                                         start_blk, &new_blk,
 749                                                         (int)head_blk)) == -1) {
 750                                 error = XFS_ERROR(EIO);
 751                                 goto bp_err;
 752                         } else if (error)
 753                                 goto bp_err;
 754                         if (new_blk != log_bbnum)
 755                                 head_blk = new_blk;
 756                 } else if (error)
 757                         goto bp_err;
 758         }
 759
 760         xlog_put_bp(bp);
 761         if (head_blk == log_bbnum)
 762                 *return_head_blk = 0;
 763         else
 764                 *return_head_blk = head_blk;
 765         /*
 766          * When returning here, we have a good block number.  Bad block
 767          * means that during a previous crash, we didn't have a clean break
 768          * from cycle number N to cycle number N-1.  In this case, we need
 769          * to find the first block with cycle number N-1.
 770          */
 771         return 0;
 772
 773  bp_err:
 774         xlog_put_bp(bp);
 775
 776         if (error)
 777             xlog_warn("XFS: failed to find log head");
 778         return error;
 779 }
 780
 781 /*
 782  * Find the sync block number or the tail of the log.
 783  *
 784  * This will be the block number of the last record to have its
 785  * associated buffers synced to disk.  Every log record header has
 786  * a sync lsn embedded in it.  LSNs hold block numbers, so it is easy
 787  * to get a sync block number.  The only concern is to figure out which
 788  * log record header to believe.
 789  *
 790  * The following algorithm uses the log record header with the largest
 791  * lsn.  The entire log record does not need to be valid.  We only care
 792  * that the header is valid.
 793  *
 794  * We could speed up search by using current head_blk buffer, but it is not
 795  * available.
 796  */
 797 int
 798 xlog_find_tail(
 799         xlog_t                  *log,
 800         xfs_daddr_t             *head_blk,
 801         xfs_daddr_t             *tail_blk,
 802         int                     readonly)
 803 {
 804         xlog_rec_header_t       *rhead;
 805         xlog_op_header_t        *op_head;
 806         xfs_caddr_t             offset = NULL;
 807         xfs_buf_t               *bp;
 808         int                     error, i, found;
 809         xfs_daddr_t             umount_data_blk;
 810         xfs_daddr_t             after_umount_blk;
 811         xfs_lsn_t               tail_lsn;
 812         int                     hblks;
 813
 814         found = 0;
 815
 816         /*
 817          * Find previous log record
 818          */
 819         if ((error = xlog_find_head(log, head_blk)))
 820                 return error;
 821
 822         bp = xlog_get_bp(log, 1);
 823         if (!bp)
 824                 return ENOMEM;
 825         if (*head_blk == 0) {                           /* special case */
 826                 if ((error = xlog_bread(log, 0, 1, bp)))
 827                         goto bread_err;
 828                 offset = xlog_align(log, 0, 1, bp);
 829                 if (GET_CYCLE(offset, ARCH_CONVERT) == 0) {
 830                         *tail_blk = 0;
 831                         /* leave all other log inited values alone */
 832                         goto exit;
 833                 }
 834         }
 835
 836         /*
 837          * Search backwards looking for log record header block
 838          */
 839         ASSERT(*head_blk < INT_MAX);
 840         for (i = (int)(*head_blk) - 1; i >= 0; i--) {
 841                 if ((error = xlog_bread(log, i, 1, bp)))
 842                         goto bread_err;
 843                 offset = xlog_align(log, i, 1, bp);
 844                 if (XLOG_HEADER_MAGIC_NUM ==
 845                     INT_GET(*(uint *)offset, ARCH_CONVERT)) {
 846                         found = 1;
 847                         break;
 848                 }
 849         }
 850         /*
 851          * If we haven't found the log record header block, start looking
 852          * again from the end of the physical log.  XXXmiken: There should be
 853          * a check here to make sure we didn't search more than N blocks in
 854          * the previous code.
 855          */
 856         if (!found) {
 857                 for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {
 858                         if ((error = xlog_bread(log, i, 1, bp)))
 859                                 goto bread_err;
 860                         offset = xlog_align(log, i, 1, bp);
 861                         if (XLOG_HEADER_MAGIC_NUM ==
 862                             INT_GET(*(uint*)offset, ARCH_CONVERT)) {
 863                                 found = 2;
 864                                 break;
 865                         }
 866                 }
 867         }
 868         if (!found) {
 869                 xlog_warn("XFS: xlog_find_tail: couldn't find sync record");
 870                 ASSERT(0);
 871                 return XFS_ERROR(EIO);
 872         }
 873
 874         /* find blk_no of tail of log */
 875         rhead = (xlog_rec_header_t *)offset;
 876         *tail_blk = BLOCK_LSN(rhead->h_tail_lsn, ARCH_CONVERT);
 877
 878         /*
 879          * Reset log values according to the state of the log when we
 880          * crashed.  In the case where head_blk == 0, we bump curr_cycle
 881          * one because the next write starts a new cycle rather than
 882          * continuing the cycle of the last good log record.  At this
 883          * point we have guaranteed that all partial log records have been
 884          * accounted for.  Therefore, we know that the last good log record
 885          * written was complete and ended exactly on the end boundary
 886          * of the physical log.
 887          */
 888         log->l_prev_block = i;
 889         log->l_curr_block = (int)*head_blk;
 890         log->l_curr_cycle = INT_GET(rhead->h_cycle, ARCH_CONVERT);
 891         if (found == 2)
 892                 log->l_curr_cycle++;
 893         log->l_tail_lsn = INT_GET(rhead->h_tail_lsn, ARCH_CONVERT);
 894         log->l_last_sync_lsn = INT_GET(rhead->h_lsn, ARCH_CONVERT);
 895         log->l_grant_reserve_cycle = log->l_curr_cycle;
 896         log->l_grant_reserve_bytes = BBTOB(log->l_curr_block);
 897         log->l_grant_write_cycle = log->l_curr_cycle;
 898         log->l_grant_write_bytes = BBTOB(log->l_curr_block);
 899
 900         /*
 901          * Look for unmount record.  If we find it, then we know there
 902          * was a clean unmount.  Since 'i' could be the last block in
 903          * the physical log, we convert to a log block before comparing
 904          * to the head_blk.
 905          *
 906          * Save the current tail lsn to use to pass to
 907          * xlog_clear_stale_blocks() below.  We won't want to clear the
 908          * unmount record if there is one, so we pass the lsn of the
 909          * unmount record rather than the block after it.
 910          */
 911         if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
 912                 int     h_size = INT_GET(rhead->h_size, ARCH_CONVERT);
 913                 int     h_version = INT_GET(rhead->h_version, ARCH_CONVERT);
 914
 915                 if ((h_version & XLOG_VERSION_2) &&
 916                     (h_size > XLOG_HEADER_CYCLE_SIZE)) {
 917                         hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
 918                         if (h_size % XLOG_HEADER_CYCLE_SIZE)
 919                                 hblks++;
 920                 } else {
 921                         hblks = 1;
 922                 }
 923         } else {
 924                 hblks = 1;
 925         }
 926         after_umount_blk = (i + hblks + (int)
 927                 BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT))) % log->l_logBBsize;
 928         tail_lsn = log->l_tail_lsn;
 929         if (*head_blk == after_umount_blk &&
 930             INT_GET(rhead->h_num_logops, ARCH_CONVERT) == 1) {
 931                 umount_data_blk = (i + hblks) % log->l_logBBsize;
 932                 if ((error = xlog_bread(log, umount_data_blk, 1, bp))) {
 933                         goto bread_err;
 934                 }
 935                 offset = xlog_align(log, umount_data_blk, 1, bp);
 936                 op_head = (xlog_op_header_t *)offset;
 937                 if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
 938                         /*
 939                          * Set tail and last sync so that newly written
 940                          * log records will point recovery to after the
 941                          * current unmount record.
 942                          */
 943                         ASSIGN_ANY_LSN(log->l_tail_lsn, log->l_curr_cycle,
 944                                         after_umount_blk, ARCH_NOCONVERT);
 945                         ASSIGN_ANY_LSN(log->l_last_sync_lsn, log->l_curr_cycle,
 946                                         after_umount_blk, ARCH_NOCONVERT);
 947                         *tail_blk = after_umount_blk;
 948                 }
 949         }
 950
 951         /*
 952          * Make sure that there are no blocks in front of the head
 953          * with the same cycle number as the head.  This can happen
 954          * because we allow multiple outstanding log writes concurrently,
 955          * and the later writes might make it out before earlier ones.
 956          *
 957          * We use the lsn from before modifying it so that we'll never
 958          * overwrite the unmount record after a clean unmount.
 959          *
 960          * Do this only if we are going to recover the filesystem
 961          *
 962          * NOTE: This used to say "if (!readonly)"
 963          * However on Linux, we can & do recover a read-only filesystem.
 964          * We only skip recovery if NORECOVERY is specified on mount,
 965          * in which case we would not be here.
 966          *
 967          * But... if the -device- itself is readonly, just skip this.
 968          * We can't recover this device anyway, so it won't matter.
 969          */
 970         if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp)) {
 971                 error = xlog_clear_stale_blocks(log, tail_lsn);
 972         }
 973
 974 bread_err:
 975 exit:
 976         xlog_put_bp(bp);
 977
 978         if (error)
 979                 xlog_warn("XFS: failed to locate log tail");
 980         return error;
 981 }
 982
 983 /*
 984  * Is the log zeroed at all?
 985  *
 986  * The last binary search should be changed to perform an X block read
 987  * once X becomes small enough.  You can then search linearly through
 988  * the X blocks.  This will cut down on the number of reads we need to do.
 989  *
 990  * If the log is partially zeroed, this routine will pass back the blkno
 991  * of the first block with cycle number 0.  It won't have a complete LR
 992  * preceding it.
 993  *
 994  * Return:
 995  *      0  => the log is completely written to
 996  *      -1 => use *blk_no as the first block of the log
 997  *      >0 => error has occurred
 998  */
 999 int
1000 xlog_find_zeroed(
1001         xlog_t          *log,
1002         xfs_daddr_t     *blk_no)
1003 {
1004         xfs_buf_t       *bp;
1005         xfs_caddr_t     offset;
1006         uint            first_cycle, last_cycle;
1007         xfs_daddr_t     new_blk, last_blk, start_blk;
1008         xfs_daddr_t     num_scan_bblks;
1009         int             error, log_bbnum = log->l_logBBsize;
1010
1011         /* check totally zeroed log */
1012         bp = xlog_get_bp(log, 1);
1013         if (!bp)
1014                 return ENOMEM;
1015         if ((error = xlog_bread(log, 0, 1, bp)))
1016                 goto bp_err;
1017         offset = xlog_align(log, 0, 1, bp);
1018         first_cycle = GET_CYCLE(offset, ARCH_CONVERT);
1019         if (first_cycle == 0) {         /* completely zeroed log */
1020                 *blk_no = 0;
1021                 xlog_put_bp(bp);
1022                 return -1;
1023         }
1024
1025         /* check partially zeroed log */
1026         if ((error = xlog_bread(log, log_bbnum-1, 1, bp)))
1027                 goto bp_err;
1028         offset = xlog_align(log, log_bbnum-1, 1, bp);
1029         last_cycle = GET_CYCLE(offset, ARCH_CONVERT);
1030         if (last_cycle != 0) {          /* log completely written to */
1031                 xlog_put_bp(bp);
1032                 return 0;
1033         } else if (first_cycle != 1) {
1034                 /*
1035                  * If the cycle of the last block is zero, the cycle of
1036                  * the first block must be 1. If it's not, maybe we're
1037                  * not looking at a log... Bail out.
1038                  */
1039                 xlog_warn("XFS: Log inconsistent or not a log (last==0, first!=1)");
1040                 return XFS_ERROR(EINVAL);
1041         }
1042
1043         /* we have a partially zeroed log */
1044         last_blk = log_bbnum-1;
1045         if ((error = xlog_find_cycle_start(log, bp, 0, &last_blk, 0)))
1046                 goto bp_err;
1047
1048         /*
1049          * Validate the answer.  Because there is no way to guarantee that
1050          * the entire log is made up of log records which are the same size,
1051          * we scan over the defined maximum blocks.  At this point, the maximum
1052          * is not chosen to mean anything special.   XXXmiken
1053          */
1054         num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
1055         ASSERT(num_scan_bblks <= INT_MAX);
1056
1057         if (last_blk < num_scan_bblks)
1058                 num_scan_bblks = last_blk;
1059         start_blk = last_blk - num_scan_bblks;
1060
1061         /*
1062          * We search for any instances of cycle number 0 that occur before
1063          * our current estimate of the head.  What we're trying to detect is
1064          *        1 ... | 0 | 1 | 0...
1065          *                       ^ binary search ends here
1066          */
1067         if ((error = xlog_find_verify_cycle(log, start_blk,
1068                                          (int)num_scan_bblks, 0, &new_blk)))
1069                 goto bp_err;
1070         if (new_blk != -1)
1071                 last_blk = new_blk;
1072
1073         /*
1074          * Potentially backup over partial log record write.  We don't need
1075          * to search the end of the log because we know it is zero.
1076          */
1077         if ((error = xlog_find_verify_log_record(log, start_blk,
1078                                 &last_blk, 0)) == -1) {
1079             error = XFS_ERROR(EIO);
1080             goto bp_err;
1081         } else if (error)
1082             goto bp_err;
1083
1084         *blk_no = last_blk;
1085 bp_err:
1086         xlog_put_bp(bp);
1087         if (error)
1088                 return error;
1089         return -1;
1090 }
1091
1092 /*
1093  * These are simple subroutines used by xlog_clear_stale_blocks() below
1094  * to initialize a buffer full of empty log record headers and write
1095  * them into the log.
1096  */
1097 STATIC void
1098 xlog_add_record(
1099         xlog_t                  *log,
1100         xfs_caddr_t             buf,
1101         int                     cycle,
1102         int                     block,
1103         int                     tail_cycle,
1104         int                     tail_block)
1105 {
1106         xlog_rec_header_t       *recp = (xlog_rec_header_t *)buf;
1107
1108         memset(buf, 0, BBSIZE);
1109         INT_SET(recp->h_magicno, ARCH_CONVERT, XLOG_HEADER_MAGIC_NUM);
1110         INT_SET(recp->h_cycle, ARCH_CONVERT, cycle);
1111         INT_SET(recp->h_version, ARCH_CONVERT,
1112                         XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) ? 2 : 1);
1113         ASSIGN_ANY_LSN(recp->h_lsn, cycle, block, ARCH_CONVERT);
1114         ASSIGN_ANY_LSN(recp->h_tail_lsn, tail_cycle, tail_block, ARCH_CONVERT);
1115         INT_SET(recp->h_fmt, ARCH_CONVERT, XLOG_FMT);
1116         memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
1117 }
1118
1119 STATIC int
1120 xlog_write_log_records(
1121         xlog_t          *log,
1122         int             cycle,
1123         int             start_block,
1124         int             blocks,
1125         int             tail_cycle,
1126         int             tail_block)
1127 {
1128         xfs_caddr_t     offset;
1129         xfs_buf_t       *bp;
1130         int             balign, ealign;
1131         int             sectbb = XLOG_SECTOR_ROUNDUP_BBCOUNT(log, 1);
1132         int             end_block = start_block + blocks;
1133         int             bufblks;
1134         int             error = 0;
1135         int             i, j = 0;
1136
1137         bufblks = 1 << ffs(blocks);
1138         while (!(bp = xlog_get_bp(log, bufblks))) {
1139                 bufblks >>= 1;
1140                 if (bufblks <= log->l_sectbb_log)
1141                         return ENOMEM;
1142         }
1143
1144         /* We may need to do a read at the start to fill in part of
1145          * the buffer in the starting sector not covered by the first
1146          * write below.
1147          */
1148         balign = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, start_block);
1149         if (balign != start_block) {
1150                 if ((error = xlog_bread(log, start_block, 1, bp))) {
1151                         xlog_put_bp(bp);
1152                         return error;
1153                 }
1154                 j = start_block - balign;
1155         }
1156
1157         for (i = start_block; i < end_block; i += bufblks) {
1158                 int             bcount, endcount;
1159
1160                 bcount = min(bufblks, end_block - start_block);
1161                 endcount = bcount - j;
1162
1163                 /* We may need to do a read at the end to fill in part of
1164                  * the buffer in the final sector not covered by the write.
1165                  * If this is the same sector as the above read, skip it.
1166                  */
1167                 ealign = XLOG_SECTOR_ROUNDDOWN_BLKNO(log, end_block);
1168                 if (j == 0 && (start_block + endcount > ealign)) {
1169                         offset = XFS_BUF_PTR(bp);
1170                         balign = BBTOB(ealign - start_block);
1171                         XFS_BUF_SET_PTR(bp, offset + balign, BBTOB(sectbb));
1172                         if ((error = xlog_bread(log, ealign, sectbb, bp)))
1173                                 break;
1174                         XFS_BUF_SET_PTR(bp, offset, bufblks);
1175                 }
1176
1177                 offset = xlog_align(log, start_block, endcount, bp);
1178                 for (; j < endcount; j++) {
1179                         xlog_add_record(log, offset, cycle, i+j,
1180                                         tail_cycle, tail_block);
1181                         offset += BBSIZE;
1182                 }
1183                 error = xlog_bwrite(log, start_block, endcount, bp);
1184                 if (error)
1185                         break;
1186                 start_block += endcount;
1187                 j = 0;
1188         }
1189         xlog_put_bp(bp);
1190         return error;
1191 }
1192
1193 /*
1194  * This routine is called to blow away any incomplete log writes out
1195  * in front of the log head.  We do this so that we won't become confused
1196  * if we come up, write only a little bit more, and then crash again.
1197  * If we leave the partial log records out there, this situation could
1198  * cause us to think those partial writes are valid blocks since they
1199  * have the current cycle number.  We get rid of them by overwriting them
1200  * with empty log records with the old cycle number rather than the
1201  * current one.
1202  *
1203  * The tail lsn is passed in rather than taken from
1204  * the log so that we will not write over the unmount record after a
1205  * clean unmount in a 512 block log.  Doing so would leave the log without
1206  * any valid log records in it until a new one was written.  If we crashed
1207  * during that time we would not be able to recover.
1208  */
1209 STATIC int
1210 xlog_clear_stale_blocks(
1211         xlog_t          *log,
1212         xfs_lsn_t       tail_lsn)
1213 {
1214         int             tail_cycle, head_cycle;
1215         int             tail_block, head_block;
1216         int             tail_distance, max_distance;
1217         int             distance;
1218         int             error;
1219
1220         tail_cycle = CYCLE_LSN(tail_lsn, ARCH_NOCONVERT);
1221         tail_block = BLOCK_LSN(tail_lsn, ARCH_NOCONVERT);
1222         head_cycle = log->l_curr_cycle;
1223         head_block = log->l_curr_block;
1224
1225         /*
1226          * Figure out the distance between the new head of the log
1227          * and the tail.  We want to write over any blocks beyond the
1228          * head that we may have written just before the crash, but
1229          * we don't want to overwrite the tail of the log.
1230          */
1231         if (head_cycle == tail_cycle) {
1232                 /*
1233                  * The tail is behind the head in the physical log,
1234                  * so the distance from the head to the tail is the
1235                  * distance from the head to the end of the log plus
1236                  * the distance from the beginning of the log to the
1237                  * tail.
1238                  */
1239                 if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
1240                         XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
1241                                          XFS_ERRLEVEL_LOW, log->l_mp);
1242                         return XFS_ERROR(EFSCORRUPTED);
1243                 }
1244                 tail_distance = tail_block + (log->l_logBBsize - head_block);
1245         } else {
1246                 /*
1247                  * The head is behind the tail in the physical log,
1248                  * so the distance from the head to the tail is just
1249                  * the tail block minus the head block.
1250                  */
1251                 if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
1252                         XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
1253                                          XFS_ERRLEVEL_LOW, log->l_mp);
1254                         return XFS_ERROR(EFSCORRUPTED);
1255                 }
1256                 tail_distance = tail_block - head_block;
1257         }
1258
1259         /*
1260          * If the head is right up against the tail, we can't clear
1261          * anything.
1262          */
1263         if (tail_distance <= 0) {
1264                 ASSERT(tail_distance == 0);
1265                 return 0;
1266         }
1267
1268         max_distance = XLOG_TOTAL_REC_SHIFT(log);
1269         /*
1270          * Take the smaller of the maximum amount of outstanding I/O
1271          * we could have and the distance to the tail to clear out.
1272          * We take the smaller so that we don't overwrite the tail and
1273          * we don't waste all day writing from the head to the tail
1274          * for no reason.
1275          */
1276         max_distance = MIN(max_distance, tail_distance);
1277
1278         if ((head_block + max_distance) <= log->l_logBBsize) {
1279                 /*
1280                  * We can stomp all the blocks we need to without
1281                  * wrapping around the end of the log.  Just do it
1282                  * in a single write.  Use the cycle number of the
1283                  * current cycle minus one so that the log will look like:
1284                  *     n ... | n - 1 ...
1285                  */
1286                 error = xlog_write_log_records(log, (head_cycle - 1),
1287                                 head_block, max_distance, tail_cycle,
1288                                 tail_block);
1289                 if (error)
1290                         return error;
1291         } else {
1292                 /*
1293                  * We need to wrap around the end of the physical log in
1294                  * order to clear all the blocks.  Do it in two separate
1295                  * I/Os.  The first write should be from the head to the
1296                  * end of the physical log, and it should use the current
1297                  * cycle number minus one just like above.
1298                  */
1299                 distance = log->l_logBBsize - head_block;
1300                 error = xlog_write_log_records(log, (head_cycle - 1),
1301                                 head_block, distance, tail_cycle,
1302                                 tail_block);
1303
1304                 if (error)
1305                         return error;
1306
1307                 /*
1308                  * Now write the blocks at the start of the physical log.
1309                  * This writes the remainder of the blocks we want to clear.
1310                  * It uses the current cycle number since we're now on the
1311                  * same cycle as the head so that we get:
1312                  *    n ... n ... | n - 1 ...
1313                  *    ^^^^^ blocks we're writing
1314                  */
1315                 distance = max_distance - (log->l_logBBsize - head_block);
1316                 error = xlog_write_log_records(log, head_cycle, 0, distance,
1317                                 tail_cycle, tail_block);
1318                 if (error)
1319                         return error;
1320         }
1321
1322         return 0;
1323 }
1324
1325 /******************************************************************************
1326  *
1327  *              Log recover routines
1328  *
1329  ******************************************************************************
1330  */
1331
1332 STATIC xlog_recover_t *
1333 xlog_recover_find_tid(
1334         xlog_recover_t          *q,
1335         xlog_tid_t              tid)
1336 {
1337         xlog_recover_t          *p = q;
1338
1339         while (p != NULL) {
1340                 if (p->r_log_tid == tid)
1341                     break;
1342                 p = p->r_next;
1343         }
1344         return p;
1345 }
1346
1347 STATIC void
1348 xlog_recover_put_hashq(
1349         xlog_recover_t          **q,
1350         xlog_recover_t          *trans)
1351 {
1352         trans->r_next = *q;
1353         *q = trans;
1354 }
1355
1356 STATIC void
1357 xlog_recover_add_item(
1358         xlog_recover_item_t     **itemq)
1359 {
1360         xlog_recover_item_t     *item;
1361
1362         item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
1363         xlog_recover_insert_item_backq(itemq, item);
1364 }
1365
1366 STATIC int
1367 xlog_recover_add_to_cont_trans(
1368         xlog_recover_t          *trans,
1369         xfs_caddr_t             dp,
1370         int                     len)
1371 {
1372         xlog_recover_item_t     *item;
1373         xfs_caddr_t             ptr, old_ptr;
1374         int                     old_len;
1375
1376         item = trans->r_itemq;
1377         if (item == 0) {
1378                 /* finish copying rest of trans header */
1379                 xlog_recover_add_item(&trans->r_itemq);
1380                 ptr = (xfs_caddr_t) &trans->r_theader +
1381                                 sizeof(xfs_trans_header_t) - len;
1382                 memcpy(ptr, dp, len); /* d, s, l */
1383                 return 0;
1384         }
1385         item = item->ri_prev;
1386
1387         old_ptr = item->ri_buf[item->ri_cnt-1].i_addr;
1388         old_len = item->ri_buf[item->ri_cnt-1].i_len;
1389
1390         ptr = kmem_realloc(old_ptr, len+old_len, old_len, 0);
1391         memcpy(&ptr[old_len], dp, len); /* d, s, l */
1392         item->ri_buf[item->ri_cnt-1].i_len += len;
1393         item->ri_buf[item->ri_cnt-1].i_addr = ptr;
1394         return 0;
1395 }
1396
1397 /*
1398  * The next region to add is the start of a new region.  It could be
1399  * a whole region or it could be the first part of a new region.  Because
1400  * of this, the assumption here is that the type and size fields of all
1401  * format structures fit into the first 32 bits of the structure.
1402  *
1403  * This works because all regions must be 32 bit aligned.  Therefore, we
1404  * either have both fields or we have neither field.  In the case we have
1405  * neither field, the data part of the region is zero length.  We only have
1406  * a log_op_header and can throw away the header since a new one will appear
1407  * later.  If we have at least 4 bytes, then we can determine how many regions
1408  * will appear in the current log item.
1409  */
1410 STATIC int
1411 xlog_recover_add_to_trans(
1412         xlog_recover_t          *trans,
1413         xfs_caddr_t             dp,
1414         int                     len)
1415 {
1416         xfs_inode_log_format_t  *in_f;                  /* any will do */
1417         xlog_recover_item_t     *item;
1418         xfs_caddr_t             ptr;
1419
1420         if (!len)
1421                 return 0;
1422         item = trans->r_itemq;
1423         if (item == 0) {
1424                 ASSERT(*(uint *)dp == XFS_TRANS_HEADER_MAGIC);
1425                 if (len == sizeof(xfs_trans_header_t))
1426                         xlog_recover_add_item(&trans->r_itemq);
1427                 memcpy(&trans->r_theader, dp, len); /* d, s, l */
1428                 return 0;
1429         }
1430
1431         ptr = kmem_alloc(len, KM_SLEEP);
1432         memcpy(ptr, dp, len);
1433         in_f = (xfs_inode_log_format_t *)ptr;
1434
1435         if (item->ri_prev->ri_total != 0 &&
1436              item->ri_prev->ri_total == item->ri_prev->ri_cnt) {
1437                 xlog_recover_add_item(&trans->r_itemq);
1438         }
1439         item = trans->r_itemq;
1440         item = item->ri_prev;
1441
1442         if (item->ri_total == 0) {              /* first region to be added */
1443                 item->ri_total  = in_f->ilf_size;
1444                 ASSERT(item->ri_total <= XLOG_MAX_REGIONS_IN_ITEM);
1445                 item->ri_buf = kmem_zalloc((item->ri_total *
1446                                             sizeof(xfs_log_iovec_t)), KM_SLEEP);
1447         }
1448         ASSERT(item->ri_total > item->ri_cnt);
1449         /* Description region is ri_buf[0] */
1450         item->ri_buf[item->ri_cnt].i_addr = ptr;
1451         item->ri_buf[item->ri_cnt].i_len  = len;
1452         item->ri_cnt++;
1453         return 0;
1454 }
1455
1456 STATIC void
1457 xlog_recover_new_tid(
1458         xlog_recover_t          **q,
1459         xlog_tid_t              tid,
1460         xfs_lsn_t               lsn)
1461 {
1462         xlog_recover_t          *trans;
1463
1464         trans = kmem_zalloc(sizeof(xlog_recover_t), KM_SLEEP);
1465         trans->r_log_tid   = tid;
1466         trans->r_lsn       = lsn;
1467         xlog_recover_put_hashq(q, trans);
1468 }
1469
1470 STATIC int
1471 xlog_recover_unlink_tid(
1472         xlog_recover_t          **q,
1473         xlog_recover_t          *trans)
1474 {
1475         xlog_recover_t          *tp;
1476         int                     found = 0;
1477
1478         ASSERT(trans != 0);
1479         if (trans == *q) {
1480                 *q = (*q)->r_next;
1481         } else {
1482                 tp = *q;
1483                 while (tp != 0) {
1484                         if (tp->r_next == trans) {
1485                                 found = 1;
1486                                 break;
1487                         }
1488                         tp = tp->r_next;
1489                 }
1490                 if (!found) {
1491                         xlog_warn(
1492                              "XFS: xlog_recover_unlink_tid: trans not found");
1493                         ASSERT(0);
1494                         return XFS_ERROR(EIO);
1495                 }
1496                 tp->r_next = tp->r_next->r_next;
1497         }
1498         return 0;
1499 }
1500
1501 STATIC void
1502 xlog_recover_insert_item_backq(
1503         xlog_recover_item_t     **q,
1504         xlog_recover_item_t     *item)
1505 {
1506         if (*q == 0) {
1507                 item->ri_prev = item->ri_next = item;
1508                 *q = item;
1509         } else {
1510                 item->ri_next           = *q;
1511                 item->ri_prev           = (*q)->ri_prev;
1512                 (*q)->ri_prev           = item;
1513                 item->ri_prev->ri_next  = item;
1514         }
1515 }
1516
1517 STATIC void
1518 xlog_recover_insert_item_frontq(
1519         xlog_recover_item_t     **q,
1520         xlog_recover_item_t     *item)
1521 {
1522         xlog_recover_insert_item_backq(q, item);
1523         *q = item;
1524 }
1525
1526 STATIC int
1527 xlog_recover_reorder_trans(
1528         xlog_t                  *log,
1529         xlog_recover_t          *trans)
1530 {
1531         xlog_recover_item_t     *first_item, *itemq, *itemq_next;
1532         xfs_buf_log_format_t    *buf_f;
1533         xfs_buf_log_format_v1_t *obuf_f;
1534         ushort                  flags = 0;
1535
1536         first_item = itemq = trans->r_itemq;
1537         trans->r_itemq = NULL;
1538         do {
1539                 itemq_next = itemq->ri_next;
1540                 buf_f = (xfs_buf_log_format_t *)itemq->ri_buf[0].i_addr;
1541                 switch (ITEM_TYPE(itemq)) {
1542                 case XFS_LI_BUF:
1543                         flags = buf_f->blf_flags;
1544                         break;
1545                 case XFS_LI_6_1_BUF:
1546                 case XFS_LI_5_3_BUF:
1547                         obuf_f = (xfs_buf_log_format_v1_t*)buf_f;
1548                         flags = obuf_f->blf_flags;
1549                         break;
1550                 }
1551
1552                 switch (ITEM_TYPE(itemq)) {
1553                 case XFS_LI_BUF:
1554                 case XFS_LI_6_1_BUF:
1555                 case XFS_LI_5_3_BUF:
1556                         if (!(flags & XFS_BLI_CANCEL)) {
1557                                 xlog_recover_insert_item_frontq(&trans->r_itemq,
1558                                                                 itemq);
1559                                 break;
1560                         }
1561                 case XFS_LI_INODE:
1562                 case XFS_LI_6_1_INODE:
1563                 case XFS_LI_5_3_INODE:
1564                 case XFS_LI_DQUOT:
1565                 case XFS_LI_QUOTAOFF:
1566                 case XFS_LI_EFD:
1567                 case XFS_LI_EFI:
1568                         xlog_recover_insert_item_backq(&trans->r_itemq, itemq);
1569                         break;
1570                 default:
1571                         xlog_warn(
1572         "XFS: xlog_recover_reorder_trans: unrecognized type of log operation");
1573                         ASSERT(0);
1574                         return XFS_ERROR(EIO);
1575                 }
1576                 itemq = itemq_next;
1577         } while (first_item != itemq);
1578         return 0;
1579 }
1580
1581 /*
1582  * Build up the table of buf cancel records so that we don't replay
1583  * cancelled data in the second pass.  For buffer records that are
1584  * not cancel records, there is nothing to do here so we just return.
1585  *
1586  * If we get a cancel record which is already in the table, this indicates
1587  * that the buffer was cancelled multiple times.  In order to ensure
1588  * that during pass 2 we keep the record in the table until we reach its
1589  * last occurrence in the log, we keep a reference count in the cancel
1590  * record in the table to tell us how many times we expect to see this
1591  * record during the second pass.
1592  */
1593 STATIC void
1594 xlog_recover_do_buffer_pass1(
1595         xlog_t                  *log,
1596         xfs_buf_log_format_t    *buf_f)
1597 {
1598         xfs_buf_cancel_t        *bcp;
1599         xfs_buf_cancel_t        *nextp;
1600         xfs_buf_cancel_t        *prevp;
1601         xfs_buf_cancel_t        **bucket;
1602         xfs_buf_log_format_v1_t *obuf_f;
1603         xfs_daddr_t             blkno = 0;
1604         uint                    len = 0;
1605         ushort                  flags = 0;
1606
1607         switch (buf_f->blf_type) {
1608         case XFS_LI_BUF:
1609                 blkno = buf_f->blf_blkno;
1610                 len = buf_f->blf_len;
1611                 flags = buf_f->blf_flags;
1612                 break;
1613         case XFS_LI_6_1_BUF:
1614         case XFS_LI_5_3_BUF:
1615                 obuf_f = (xfs_buf_log_format_v1_t*)buf_f;
1616                 blkno = (xfs_daddr_t) obuf_f->blf_blkno;
1617                 len = obuf_f->blf_len;
1618                 flags = obuf_f->blf_flags;
1619                 break;
1620         }
1621
1622         /*
1623          * If this isn't a cancel buffer item, then just return.
1624          */
1625         if (!(flags & XFS_BLI_CANCEL))
1626                 return;
1627
1628         /*
1629          * Insert an xfs_buf_cancel record into the hash table of
1630          * them.  If there is already an identical record, bump
1631          * its reference count.
1632          */
1633         bucket = &log->l_buf_cancel_table[(__uint64_t)blkno %
1634                                           XLOG_BC_TABLE_SIZE];
1635         /*
1636          * If the hash bucket is empty then just insert a new record into
1637          * the bucket.
1638          */
1639         if (*bucket == NULL) {
1640                 bcp = (xfs_buf_cancel_t *)kmem_alloc(sizeof(xfs_buf_cancel_t),
1641                                                      KM_SLEEP);
1642                 bcp->bc_blkno = blkno;
1643                 bcp->bc_len = len;
1644                 bcp->bc_refcount = 1;
1645                 bcp->bc_next = NULL;
1646                 *bucket = bcp;
1647                 return;
1648         }
1649
1650         /*
1651          * The hash bucket is not empty, so search for duplicates of our
1652          * record.  If we find one them just bump its refcount.  If not
1653          * then add us at the end of the list.
1654          */
1655         prevp = NULL;
1656         nextp = *bucket;
1657         while (nextp != NULL) {
1658                 if (nextp->bc_blkno == blkno && nextp->bc_len == len) {
1659                         nextp->bc_refcount++;
1660                         return;
1661                 }
1662                 prevp = nextp;
1663                 nextp = nextp->bc_next;
1664         }
1665         ASSERT(prevp != NULL);
1666         bcp = (xfs_buf_cancel_t *)kmem_alloc(sizeof(xfs_buf_cancel_t),
1667                                              KM_SLEEP);
1668         bcp->bc_blkno = blkno;
1669         bcp->bc_len = len;
1670         bcp->bc_refcount = 1;
1671         bcp->bc_next = NULL;
1672         prevp->bc_next = bcp;
1673 }
1674
1675 /*
1676  * Check to see whether the buffer being recovered has a corresponding
1677  * entry in the buffer cancel record table.  If it does then return 1
1678  * so that it will be cancelled, otherwise return 0.  If the buffer is
1679  * actually a buffer cancel item (XFS_BLI_CANCEL is set), then decrement
1680  * the refcount on the entry in the table and remove it from the table
1681  * if this is the last reference.
1682  *
1683  * We remove the cancel record from the table when we encounter its
1684  * last occurrence in the log so that if the same buffer is re-used
1685  * again after its last cancellation we actually replay the changes
1686  * made at that point.
1687  */
1688 STATIC int
1689 xlog_check_buffer_cancelled(
1690         xlog_t                  *log,
1691         xfs_daddr_t             blkno,
1692         uint                    len,
1693         ushort                  flags)
1694 {
1695         xfs_buf_cancel_t        *bcp;
1696         xfs_buf_cancel_t        *prevp;
1697         xfs_buf_cancel_t        **bucket;
1698
1699         if (log->l_buf_cancel_table == NULL) {
1700                 /*
1701                  * There is nothing in the table built in pass one,
1702                  * so this buffer must not be cancelled.
1703                  */
1704                 ASSERT(!(flags & XFS_BLI_CANCEL));
1705                 return 0;
1706         }
1707
1708         bucket = &log->l_buf_cancel_table[(__uint64_t)blkno %
1709                                           XLOG_BC_TABLE_SIZE];
1710         bcp = *bucket;
1711         if (bcp == NULL) {
1712                 /*
1713                  * There is no corresponding entry in the table built
1714                  * in pass one, so this buffer has not been cancelled.
1715                  */
1716                 ASSERT(!(flags & XFS_BLI_CANCEL));
1717                 return 0;
1718         }
1719
1720         /*
1721          * Search for an entry in the buffer cancel table that
1722          * matches our buffer.
1723          */
1724         prevp = NULL;
1725         while (bcp != NULL) {
1726                 if (bcp->bc_blkno == blkno && bcp->bc_len == len) {
1727                         /*
1728                          * We've go a match, so return 1 so that the
1729                          * recovery of this buffer is cancelled.
1730                          * If this buffer is actually a buffer cancel
1731                          * log item, then decrement the refcount on the
1732                          * one in the table and remove it if this is the
1733                          * last reference.
1734                          */
1735                         if (flags & XFS_BLI_CANCEL) {
1736                                 bcp->bc_refcount--;
1737                                 if (bcp->bc_refcount == 0) {
1738                                         if (prevp == NULL) {
1739                                                 *bucket = bcp->bc_next;
1740                                         } else {
1741                                                 prevp->bc_next = bcp->bc_next;
1742                                         }
1743                                         kmem_free(bcp,
1744                                                   sizeof(xfs_buf_cancel_t));
1745                                 }
1746                         }
1747                         return 1;
1748                 }
1749                 prevp = bcp;
1750                 bcp = bcp->bc_next;
1751         }
1752         /*
1753          * We didn't find a corresponding entry in the table, so
1754          * return 0 so that the buffer is NOT cancelled.
1755          */
1756         ASSERT(!(flags & XFS_BLI_CANCEL));
1757         return 0;
1758 }
1759
1760 STATIC int
1761 xlog_recover_do_buffer_pass2(
1762         xlog_t                  *log,
1763         xfs_buf_log_format_t    *buf_f)
1764 {
1765         xfs_buf_log_format_v1_t *obuf_f;
1766         xfs_daddr_t             blkno = 0;
1767         ushort                  flags = 0;
1768         uint                    len = 0;
1769
1770         switch (buf_f->blf_type) {
1771         case XFS_LI_BUF:
1772                 blkno = buf_f->blf_blkno;
1773                 flags = buf_f->blf_flags;
1774                 len = buf_f->blf_len;
1775                 break;
1776         case XFS_LI_6_1_BUF:
1777         case XFS_LI_5_3_BUF:
1778                 obuf_f = (xfs_buf_log_format_v1_t*)buf_f;
1779                 blkno = (xfs_daddr_t) obuf_f->blf_blkno;
1780                 flags = obuf_f->blf_flags;
1781                 len = (xfs_daddr_t) obuf_f->blf_len;
1782                 break;
1783         }
1784
1785         return xlog_check_buffer_cancelled(log, blkno, len, flags);
1786 }
1787
1788 /*
1789  * Perform recovery for a buffer full of inodes.  In these buffers,
1790  * the only data which should be recovered is that which corresponds
1791  * to the di_next_unlinked pointers in the on disk inode structures.
1792  * The rest of the data for the inodes is always logged through the
1793  * inodes themselves rather than the inode buffer and is recovered
1794  * in xlog_recover_do_inode_trans().
1795  *
1796  * The only time when buffers full of inodes are fully recovered is
1797  * when the buffer is full of newly allocated inodes.  In this case
1798  * the buffer will not be marked as an inode buffer and so will be
1799  * sent to xlog_recover_do_reg_buffer() below during recovery.
1800  */
1801 STATIC int
1802 xlog_recover_do_inode_buffer(
1803         xfs_mount_t             *mp,
1804         xlog_recover_item_t     *item,
1805         xfs_buf_t               *bp,
1806         xfs_buf_log_format_t    *buf_f)
1807 {
1808         int                     i;
1809         int                     item_index;
1810         int                     bit;
1811         int                     nbits;
1812         int                     reg_buf_offset;
1813         int                     reg_buf_bytes;
1814         int                     next_unlinked_offset;
1815         int                     inodes_per_buf;
1816         xfs_agino_t             *logged_nextp;
1817         xfs_agino_t             *buffer_nextp;
1818         xfs_buf_log_format_v1_t *obuf_f;
1819         unsigned int            *data_map = NULL;
1820         unsigned int            map_size = 0;
1821
1822         switch (buf_f->blf_type) {
1823         case XFS_LI_BUF:
1824                 data_map = buf_f->blf_data_map;
1825                 map_size = buf_f->blf_map_size;
1826                 break;
1827         case XFS_LI_6_1_BUF:
1828         case XFS_LI_5_3_BUF:
1829                 obuf_f = (xfs_buf_log_format_v1_t*)buf_f;
1830                 data_map = obuf_f->blf_data_map;
1831                 map_size = obuf_f->blf_map_size;
1832                 break;
1833         }
1834         /*
1835          * Set the variables corresponding to the current region to
1836          * 0 so that we'll initialize them on the first pass through
1837          * the loop.
1838          */
1839         reg_buf_offset = 0;
1840         reg_buf_bytes = 0;
1841         bit = 0;
1842         nbits = 0;
1843         item_index = 0;
1844         inodes_per_buf = XFS_BUF_COUNT(bp) >> mp->m_sb.sb_inodelog;
1845         for (i = 0; i < inodes_per_buf; i++) {
1846                 next_unlinked_offset = (i * mp->m_sb.sb_inodesize) +
1847                         offsetof(xfs_dinode_t, di_next_unlinked);
1848
1849                 while (next_unlinked_offset >=
1850                        (reg_buf_offset + reg_buf_bytes)) {
1851                         /*
1852                          * The next di_next_unlinked field is beyond
1853                          * the current logged region.  Find the next
1854                          * logged region that contains or is beyond
1855                          * the current di_next_unlinked field.
1856                          */
1857                         bit += nbits;
1858                         bit = xfs_next_bit(data_map, map_size, bit);
1859
1860                         /*
1861                          * If there are no more logged regions in the
1862                          * buffer, then we're done.
1863                          */
1864                         if (bit == -1) {
1865                                 return 0;
1866                         }
1867
1868                         nbits = xfs_contig_bits(data_map, map_size,
1869                                                          bit);
1870                         reg_buf_offset = bit << XFS_BLI_SHIFT;
1871                         reg_buf_bytes = nbits << XFS_BLI_SHIFT;
1872                         item_index++;
1873                 }
1874
1875                 /*
1876                  * If the current logged region starts after the current
1877                  * di_next_unlinked field, then move on to the next
1878                  * di_next_unlinked field.
1879                  */
1880                 if (next_unlinked_offset < reg_buf_offset) {
1881                         continue;
1882                 }
1883
1884                 ASSERT(item->ri_buf[item_index].i_addr != NULL);
1885                 ASSERT((item->ri_buf[item_index].i_len % XFS_BLI_CHUNK) == 0);
1886                 ASSERT((reg_buf_offset + reg_buf_bytes) <= XFS_BUF_COUNT(bp));
1887
1888                 /*
1889                  * The current logged region contains a copy of the
1890                  * current di_next_unlinked field.  Extract its value
1891                  * and copy it to the buffer copy.
1892                  */
1893                 logged_nextp = (xfs_agino_t *)
1894                                ((char *)(item->ri_buf[item_index].i_addr) +
1895                                 (next_unlinked_offset - reg_buf_offset));
1896                 if (unlikely(*logged_nextp == 0)) {
1897                         xfs_fs_cmn_err(CE_ALERT, mp,
1898                                 "bad inode buffer log record (ptr = 0x%p, bp = 0x%p).  XFS trying to replay bad (0) inode di_next_unlinked field",
1899                                 item, bp);
1900                         XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
1901                                          XFS_ERRLEVEL_LOW, mp);
1902                         return XFS_ERROR(EFSCORRUPTED);
1903                 }
1904
1905                 buffer_nextp = (xfs_agino_t *)xfs_buf_offset(bp,
1906                                               next_unlinked_offset);
1907                 INT_SET(*buffer_nextp, ARCH_CONVERT, *logged_nextp);
1908         }
1909
1910         return 0;
1911 }
1912
1913 /*
1914  * Perform a 'normal' buffer recovery.  Each logged region of the
1915  * buffer should be copied over the corresponding region in the
1916  * given buffer.  The bitmap in the buf log format structure indicates
1917  * where to place the logged data.
1918  */
1919 /*ARGSUSED*/
1920 STATIC void
1921 xlog_recover_do_reg_buffer(
1922         xfs_mount_t             *mp,
1923         xlog_recover_item_t     *item,
1924         xfs_buf_t               *bp,
1925         xfs_buf_log_format_t    *buf_f)
1926 {
1927         int                     i;
1928         int                     bit;
1929         int                     nbits;
1930         xfs_buf_log_format_v1_t *obuf_f;
1931         unsigned int            *data_map = NULL;
1932         unsigned int            map_size = 0;
1933         int                     error;
1934
1935         switch (buf_f->blf_type) {
1936         case XFS_LI_BUF:
1937                 data_map = buf_f->blf_data_map;
1938                 map_size = buf_f->blf_map_size;
1939                 break;
1940         case XFS_LI_6_1_BUF:
1941         case XFS_LI_5_3_BUF:
1942                 obuf_f = (xfs_buf_log_format_v1_t*)buf_f;
1943                 data_map = obuf_f->blf_data_map;
1944                 map_size = obuf_f->blf_map_size;
1945                 break;
1946         }
1947         bit = 0;
1948         i = 1;  /* 0 is the buf format structure */
1949         while (1) {
1950                 bit = xfs_next_bit(data_map, map_size, bit);
1951                 if (bit == -1)
1952                         break;
1953                 nbits = xfs_contig_bits(data_map, map_size, bit);
1954                 ASSERT(item->ri_buf[i].i_addr != 0);
1955                 ASSERT(item->ri_buf[i].i_len % XFS_BLI_CHUNK == 0);
1956                 ASSERT(XFS_BUF_COUNT(bp) >=
1957                        ((uint)bit << XFS_BLI_SHIFT)+(nbits<<XFS_BLI_SHIFT));
1958
1959                 /*
1960                  * Do a sanity check if this is a dquot buffer. Just checking
1961                  * the first dquot in the buffer should do. XXXThis is
1962                  * probably a good thing to do for other buf types also.
1963                  */
1964                 error = 0;
1965                 if (buf_f->blf_flags & (XFS_BLI_UDQUOT_BUF|XFS_BLI_GDQUOT_BUF)) {
1966                         error = xfs_qm_dqcheck((xfs_disk_dquot_t *)
1967                                                item->ri_buf[i].i_addr,
1968                                                -1, 0, XFS_QMOPT_DOWARN,
1969                                                "dquot_buf_recover");
1970                 }
1971                 if (!error)
1972                         memcpy(xfs_buf_offset(bp,
1973                                 (uint)bit << XFS_BLI_SHIFT),    /* dest */
1974                                 item->ri_buf[i].i_addr,         /* source */
1975                                 nbits<<XFS_BLI_SHIFT);          /* length */
1976                 i++;
1977                 bit += nbits;
1978         }
1979
1980         /* Shouldn't be any more regions */
1981         ASSERT(i == item->ri_total);
1982 }
1983
1984 /*
1985  * Do some primitive error checking on ondisk dquot data structures.
1986  */
1987 int
1988 xfs_qm_dqcheck(
1989         xfs_disk_dquot_t *ddq,
1990         xfs_dqid_t       id,
1991         uint             type,    /* used only when IO_dorepair is true */
1992         uint             flags,
1993         char             *str)
1994 {
1995         xfs_dqblk_t      *d = (xfs_dqblk_t *)ddq;
1996         int             errs = 0;
1997
1998         /*
1999          * We can encounter an uninitialized dquot buffer for 2 reasons:
2000          * 1. If we crash while deleting the quotainode(s), and those blks got
2001          *    used for user data. This is because we take the path of regular
2002          *    file deletion; however, the size field of quotainodes is never
2003          *    updated, so all the tricks that we play in itruncate_finish
2004          *    don't quite matter.
2005          *
2006          * 2. We don't play the quota buffers when there's a quotaoff logitem.
2007          *    But the allocation will be replayed so we'll end up with an
2008          *    uninitialized quota block.
2009          *
2010          * This is all fine; things are still consistent, and we haven't lost
2011          * any quota information. Just don't complain about bad dquot blks.
2012          */
2013         if (INT_GET(ddq->d_magic, ARCH_CONVERT) != XFS_DQUOT_MAGIC) {
2014                 if (flags & XFS_QMOPT_DOWARN)
2015                         cmn_err(CE_ALERT,
2016                         "%s : XFS dquot ID 0x%x, magic 0x%x != 0x%x",
2017                         str, id,
2018                         INT_GET(ddq->d_magic, ARCH_CONVERT), XFS_DQUOT_MAGIC);
2019                 errs++;
2020         }
2021         if (INT_GET(ddq->d_version, ARCH_CONVERT) != XFS_DQUOT_VERSION) {
2022                 if (flags & XFS_QMOPT_DOWARN)
2023                         cmn_err(CE_ALERT,
2024                         "%s : XFS dquot ID 0x%x, version 0x%x != 0x%x",
2025                         str, id,
2026                         INT_GET(ddq->d_magic, ARCH_CONVERT), XFS_DQUOT_VERSION);
2027                 errs++;
2028         }
2029
2030         if (INT_GET(ddq->d_flags, ARCH_CONVERT) != XFS_DQ_USER &&
2031             INT_GET(ddq->d_flags, ARCH_CONVERT) != XFS_DQ_GROUP) {
2032                 if (flags & XFS_QMOPT_DOWARN)
2033                         cmn_err(CE_ALERT,
2034                         "%s : XFS dquot ID 0x%x, unknown flags 0x%x",
2035                         str, id, INT_GET(ddq->d_flags, ARCH_CONVERT));
2036                 errs++;
2037         }
2038
2039         if (id != -1 && id != INT_GET(ddq->d_id, ARCH_CONVERT)) {
2040                 if (flags & XFS_QMOPT_DOWARN)
2041                         cmn_err(CE_ALERT,
2042                         "%s : ondisk-dquot 0x%p, ID mismatch: "
2043                         "0x%x expected, found id 0x%x",
2044                         str, ddq, id, INT_GET(ddq->d_id, ARCH_CONVERT));
2045                 errs++;
2046         }
2047
2048         if (! errs) {
2049                 if (INT_GET(ddq->d_blk_softlimit, ARCH_CONVERT) &&
2050                     INT_GET(ddq->d_bcount, ARCH_CONVERT) >=
2051                                 INT_GET(ddq->d_blk_softlimit, ARCH_CONVERT)) {
2052                         if (INT_ISZERO(ddq->d_btimer, ARCH_CONVERT) &&
2053                             !INT_ISZERO(ddq->d_id, ARCH_CONVERT)) {
2054                                 if (flags & XFS_QMOPT_DOWARN)
2055                                         cmn_err(CE_ALERT,
2056                                         "%s : Dquot ID 0x%x (0x%p) "
2057                                         "BLK TIMER NOT STARTED",
2058                                         str, (int)
2059                                         INT_GET(ddq->d_id, ARCH_CONVERT), ddq);
2060                                 errs++;
2061                         }
2062                 }
2063                 if (INT_GET(ddq->d_ino_softlimit, ARCH_CONVERT) &&
2064                     INT_GET(ddq->d_icount, ARCH_CONVERT) >=
2065                                 INT_GET(ddq->d_ino_softlimit, ARCH_CONVERT)) {
2066                         if (INT_ISZERO(ddq->d_itimer, ARCH_CONVERT) &&
2067                             !INT_ISZERO(ddq->d_id, ARCH_CONVERT)) {
2068                                 if (flags & XFS_QMOPT_DOWARN)
2069                                         cmn_err(CE_ALERT,
2070                                         "%s : Dquot ID 0x%x (0x%p) "
2071                                         "INODE TIMER NOT STARTED",
2072                                         str, (int)
2073                                         INT_GET(ddq->d_id, ARCH_CONVERT), ddq);
2074                                 errs++;
2075                         }
2076                 }
2077         }
2078
2079         if (!errs || !(flags & XFS_QMOPT_DQREPAIR))
2080                 return errs;
2081
2082         if (flags & XFS_QMOPT_DOWARN)
2083                 cmn_err(CE_NOTE, "Re-initializing dquot ID 0x%x", id);
2084
2085         /*
2086          * Typically, a repair is only requested by quotacheck.
2087          */
2088         ASSERT(id != -1);
2089         ASSERT(flags & XFS_QMOPT_DQREPAIR);
2090         memset(d, 0, sizeof(xfs_dqblk_t));
2091         INT_SET(d->dd_diskdq.d_magic, ARCH_CONVERT, XFS_DQUOT_MAGIC);
2092         INT_SET(d->dd_diskdq.d_version, ARCH_CONVERT, XFS_DQUOT_VERSION);
2093         INT_SET(d->dd_diskdq.d_id, ARCH_CONVERT, id);
2094         INT_SET(d->dd_diskdq.d_flags, ARCH_CONVERT, type);
2095
2096         return errs;
2097 }
2098
2099 /*
2100  * Perform a dquot buffer recovery.
2101  * Simple algorithm: if we have found a QUOTAOFF logitem of the same type
2102  * (ie. USR or GRP), then just toss this buffer away; don't recover it.
2103  * Else, treat it as a regular buffer and do recovery.
2104  */
2105 STATIC void
2106 xlog_recover_do_dquot_buffer(
2107         xfs_mount_t             *mp,
2108         xlog_t                  *log,
2109         xlog_recover_item_t     *item,
2110         xfs_buf_t               *bp,
2111         xfs_buf_log_format_t    *buf_f)
2112 {
2113         uint                    type;
2114
2115         /*
2116          * Filesystems are required to send in quota flags at mount time.
2117          */
2118         if (mp->m_qflags == 0) {
2119                 return;
2120         }
2121
2122         type = 0;
2123         if (buf_f->blf_flags & XFS_BLI_UDQUOT_BUF)
2124                 type |= XFS_DQ_USER;
2125         if (buf_f->blf_flags & XFS_BLI_GDQUOT_BUF)
2126                 type |= XFS_DQ_GROUP;
2127         /*
2128          * This type of quotas was turned off, so ignore this buffer
2129          */
2130         if (log->l_quotaoffs_flag & type)
2131                 return;
2132
2133         xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
2134 }
2135
2136 /*
2137  * This routine replays a modification made to a buffer at runtime.
2138  * There are actually two types of buffer, regular and inode, which
2139  * are handled differently.  Inode buffers are handled differently
2140  * in that we only recover a specific set of data from them, namely
2141  * the inode di_next_unlinked fields.  This is because all other inode
2142  * data is actually logged via inode records and any data we replay
2143  * here which overlaps that may be stale.
2144  *
2145  * When meta-data buffers are freed at run time we log a buffer item
2146  * with the XFS_BLI_CANCEL bit set to indicate that previous copies
2147  * of the buffer in the log should not be replayed at recovery time.
2148  * This is so that if the blocks covered by the buffer are reused for
2149  * file data before we crash we don't end up replaying old, freed
2150  * meta-data into a user's file.
2151  *
2152  * To handle the cancellation of buffer log items, we make two passes
2153  * over the log during recovery.  During the first we build a table of
2154  * those buffers which have been cancelled, and during the second we
2155  * only replay those buffers which do not have corresponding cancel
2156  * records in the table.  See xlog_recover_do_buffer_pass[1,2] above
2157  * for more details on the implementation of the table of cancel records.
2158  */
2159 STATIC int
2160 xlog_recover_do_buffer_trans(
2161         xlog_t                  *log,
2162         xlog_recover_item_t     *item,
2163         int                     pass)
2164 {
2165         xfs_buf_log_format_t    *buf_f;
2166         xfs_buf_log_format_v1_t *obuf_f;
2167         xfs_mount_t             *mp;
2168         xfs_buf_t               *bp;
2169         int                     error;
2170         int                     cancel;
2171         xfs_daddr_t             blkno;
2172         int                     len;
2173         ushort                  flags;
2174
2175         buf_f = (xfs_buf_log_format_t *)item->ri_buf[0].i_addr;
2176
2177         if (pass == XLOG_RECOVER_PASS1) {
2178                 /*
2179                  * In this pass we're only looking for buf items
2180                  * with the XFS_BLI_CANCEL bit set.
2181                  */
2182                 xlog_recover_do_buffer_pass1(log, buf_f);
2183                 return 0;
2184         } else {
2185                 /*
2186                  * In this pass we want to recover all the buffers
2187                  * which have not been cancelled and are not
2188                  * cancellation buffers themselves.  The routine
2189                  * we call here will tell us whether or not to
2190                  * continue with the replay of this buffer.
2191                  */
2192                 cancel = xlog_recover_do_buffer_pass2(log, buf_f);
2193                 if (cancel) {
2194                         return 0;
2195                 }
2196         }
2197         switch (buf_f->blf_type) {
2198         case XFS_LI_BUF:
2199                 blkno = buf_f->blf_blkno;
2200                 len = buf_f->blf_len;
2201                 flags = buf_f->blf_flags;
2202                 break;
2203         case XFS_LI_6_1_BUF:
2204         case XFS_LI_5_3_BUF:
2205                 obuf_f = (xfs_buf_log_format_v1_t*)buf_f;
2206                 blkno = obuf_f->blf_blkno;
2207                 len = obuf_f->blf_len;
2208                 flags = obuf_f->blf_flags;
2209                 break;
2210         default:
2211                 xfs_fs_cmn_err(CE_ALERT, log->l_mp,
2212                         "xfs_log_recover: unknown buffer type 0x%x, dev %s",
2213                         buf_f->blf_type, XFS_BUFTARG_NAME(log->l_targ));
2214                 XFS_ERROR_REPORT("xlog_recover_do_buffer_trans",
2215                                  XFS_ERRLEVEL_LOW, log->l_mp);
2216                 return XFS_ERROR(EFSCORRUPTED);
2217         }
2218
2219         mp = log->l_mp;
2220         if (flags & XFS_BLI_INODE_BUF) {
2221                 bp = xfs_buf_read_flags(mp->m_ddev_targp, blkno, len,
2222                                                                 XFS_BUF_LOCK);
2223         } else {
2224                 bp = xfs_buf_read(mp->m_ddev_targp, blkno, len, 0);
2225         }
2226         if (XFS_BUF_ISERROR(bp)) {
2227                 xfs_ioerror_alert("xlog_recover_do..(read#1)", log->l_mp,
2228                                   bp, blkno);
2229                 error = XFS_BUF_GETERROR(bp);
2230                 xfs_buf_relse(bp);
2231                 return error;
2232         }
2233
2234         error = 0;
2235         if (flags & XFS_BLI_INODE_BUF) {
2236                 error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
2237         } else if (flags & (XFS_BLI_UDQUOT_BUF | XFS_BLI_GDQUOT_BUF)) {
2238                 xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
2239         } else {
2240                 xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
2241         }
2242         if (error)
2243                 return XFS_ERROR(error);
2244
2245         /*
2246          * Perform delayed write on the buffer.  Asynchronous writes will be
2247          * slower when taking into account all the buffers to be flushed.
2248          *
2249          * Also make sure that only inode buffers with good sizes stay in
2250          * the buffer cache.  The kernel moves inodes in buffers of 1 block
2251          * or XFS_INODE_CLUSTER_SIZE bytes, whichever is bigger.  The inode
2252          * buffers in the log can be a different size if the log was generated
2253          * by an older kernel using unclustered inode buffers or a newer kernel
2254          * running with a different inode cluster size.  Regardless, if the
2255          * the inode buffer size isn't MAX(blocksize, XFS_INODE_CLUSTER_SIZE)
2256          * for *our* value of XFS_INODE_CLUSTER_SIZE, then we need to keep
2257          * the buffer out of the buffer cache so that the buffer won't
2258          * overlap with future reads of those inodes.
2259          */
2260         if (XFS_DINODE_MAGIC ==
2261             INT_GET(*((__uint16_t *)(xfs_buf_offset(bp, 0))), ARCH_CONVERT) &&
2262             (XFS_BUF_COUNT(bp) != MAX(log->l_mp->m_sb.sb_blocksize,
2263                         (__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {
2264                 XFS_BUF_STALE(bp);
2265                 error = xfs_bwrite(mp, bp);
2266         } else {
2267                 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) == NULL ||
2268                        XFS_BUF_FSPRIVATE(bp, xfs_mount_t *) == mp);
2269                 XFS_BUF_SET_FSPRIVATE(bp, mp);
2270                 XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
2271                 xfs_bdwrite(mp, bp);
2272         }
2273
2274         return (error);
2275 }
2276
2277 STATIC int
2278 xlog_recover_do_inode_trans(
2279         xlog_t                  *log,
2280         xlog_recover_item_t     *item,
2281         int                     pass)
2282 {
2283         xfs_inode_log_format_t  *in_f;
2284         xfs_mount_t             *mp;
2285         xfs_buf_t               *bp;
2286         xfs_imap_t              imap;
2287         xfs_dinode_t            *dip;
2288         xfs_ino_t               ino;
2289         int                     len;
2290         xfs_caddr_t             src;
2291         xfs_caddr_t             dest;
2292         int                     error;
2293         int                     attr_index;
2294         uint                    fields;
2295         xfs_dinode_core_t       *dicp;
2296
2297         if (pass == XLOG_RECOVER_PASS1) {
2298                 return 0;
2299         }
2300
2301         in_f = (xfs_inode_log_format_t *)item->ri_buf[0].i_addr;
2302         ino = in_f->ilf_ino;
2303         mp = log->l_mp;
2304         if (ITEM_TYPE(item) == XFS_LI_INODE) {
2305                 imap.im_blkno = (xfs_daddr_t)in_f->ilf_blkno;
2306                 imap.im_len = in_f->ilf_len;
2307                 imap.im_boffset = in_f->ilf_boffset;
2308         } else {
2309                 /*
2310                  * It's an old inode format record.  We don't know where
2311                  * its cluster is located on disk, and we can't allow
2312                  * xfs_imap() to figure it out because the inode btrees
2313                  * are not ready to be used.  Therefore do not pass the
2314                  * XFS_IMAP_LOOKUP flag to xfs_imap().  This will give
2315                  * us only the single block in which the inode lives
2316                  * rather than its cluster, so we must make sure to
2317                  * invalidate the buffer when we write it out below.
2318                  */
2319                 imap.im_blkno = 0;
2320                 xfs_imap(log->l_mp, 0, ino, &imap, 0);
2321         }
2322
2323         /*
2324          * Inode buffers can be freed, look out for it,
2325          * and do not replay the inode.
2326          */
2327         if (xlog_check_buffer_cancelled(log, imap.im_blkno, imap.im_len, 0))
2328                 return 0;
2329
2330         bp = xfs_buf_read_flags(mp->m_ddev_targp, imap.im_blkno, imap.im_len,
2331                                                                 XFS_BUF_LOCK);
2332         if (XFS_BUF_ISERROR(bp)) {
2333                 xfs_ioerror_alert("xlog_recover_do..(read#2)", mp,
2334                                   bp, imap.im_blkno);
2335                 error = XFS_BUF_GETERROR(bp);
2336                 xfs_buf_relse(bp);
2337                 return error;
2338         }
2339         error = 0;
2340         ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
2341         dip = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset);
2342
2343         /*
2344          * Make sure the place we're flushing out to really looks
2345          * like an inode!
2346          */
2347         if (unlikely(INT_GET(dip->di_core.di_magic, ARCH_CONVERT) != XFS_DINODE_MAGIC)) {
2348                 xfs_buf_relse(bp);
2349                 xfs_fs_cmn_err(CE_ALERT, mp,
2350                         "xfs_inode_recover: Bad inode magic number, dino ptr = 0x%p, dino bp = 0x%p, ino = %Ld",
2351                         dip, bp, ino);
2352                 XFS_ERROR_REPORT("xlog_recover_do_inode_trans(1)",
2353                                  XFS_ERRLEVEL_LOW, mp);
2354                 return XFS_ERROR(EFSCORRUPTED);
2355         }
2356         dicp = (xfs_dinode_core_t*)(item->ri_buf[1].i_addr);
2357         if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) {
2358                 xfs_buf_relse(bp);
2359                 xfs_fs_cmn_err(CE_ALERT, mp,
2360                         "xfs_inode_recover: Bad inode log record, rec ptr 0x%p, ino %Ld",
2361                         item, ino);
2362                 XFS_ERROR_REPORT("xlog_recover_do_inode_trans(2)",
2363                                  XFS_ERRLEVEL_LOW, mp);
2364                 return XFS_ERROR(EFSCORRUPTED);
2365         }
2366
2367         /* Skip replay when the on disk inode is newer than the log one */
2368         if (dicp->di_flushiter <
2369             INT_GET(dip->di_core.di_flushiter, ARCH_CONVERT)) {
2370                 /*
2371                  * Deal with the wrap case, DI_MAX_FLUSH is less
2372                  * than smaller numbers
2373                  */
2374                 if ((INT_GET(dip->di_core.di_flushiter, ARCH_CONVERT)
2375                                                         == DI_MAX_FLUSH) &&
2376                     (dicp->di_flushiter < (DI_MAX_FLUSH>>1))) {
2377                         /* do nothing */
2378                 } else {
2379                         xfs_buf_relse(bp);
2380                         return 0;
2381                 }
2382         }
2383         /* Take the opportunity to reset the flush iteration count */
2384         dicp->di_flushiter = 0;
2385
2386         if (unlikely((dicp->di_mode & S_IFMT) == S_IFREG)) {
2387                 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2388                     (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
2389                         XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(3)",
2390                                          XFS_ERRLEVEL_LOW, mp, dicp);
2391                         xfs_buf_relse(bp);
2392                         xfs_fs_cmn_err(CE_ALERT, mp,
2393                                 "xfs_inode_recover: Bad regular inode log record, rec ptr 0x%p, ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2394                                 item, dip, bp, ino);
2395                         return XFS_ERROR(EFSCORRUPTED);
2396                 }
2397         } else if (unlikely((dicp->di_mode & S_IFMT) == S_IFDIR)) {
2398                 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2399                     (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
2400                     (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
2401                         XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(4)",
2402                                              XFS_ERRLEVEL_LOW, mp, dicp);
2403                         xfs_buf_relse(bp);
2404                         xfs_fs_cmn_err(CE_ALERT, mp,
2405                                 "xfs_inode_recover: Bad dir inode log record, rec ptr 0x%p, ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2406                                 item, dip, bp, ino);
2407                         return XFS_ERROR(EFSCORRUPTED);
2408                 }
2409         }
2410         if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){
2411                 XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(5)",
2412                                      XFS_ERRLEVEL_LOW, mp, dicp);
2413                 xfs_buf_relse(bp);
2414                 xfs_fs_cmn_err(CE_ALERT, mp,
2415                         "xfs_inode_recover: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, dino bp 0x%p, ino %Ld, total extents = %d, nblocks = %Ld",
2416                         item, dip, bp, ino,
2417                         dicp->di_nextents + dicp->di_anextents,
2418                         dicp->di_nblocks);
2419                 return XFS_ERROR(EFSCORRUPTED);
2420         }
2421         if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
2422                 XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(6)",
2423                                      XFS_ERRLEVEL_LOW, mp, dicp);
2424                 xfs_buf_relse(bp);
2425                 xfs_fs_cmn_err(CE_ALERT, mp,
2426                         "xfs_inode_recover: Bad inode log rec ptr 0x%p, dino ptr 0x%p, dino bp 0x%p, ino %Ld, forkoff 0x%x",
2427                         item, dip, bp, ino, dicp->di_forkoff);
2428                 return XFS_ERROR(EFSCORRUPTED);
2429         }
2430         if (unlikely(item->ri_buf[1].i_len > sizeof(xfs_dinode_core_t))) {
2431                 XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(7)",
2432                                      XFS_ERRLEVEL_LOW, mp, dicp);
2433                 xfs_buf_relse(bp);
2434                 xfs_fs_cmn_err(CE_ALERT, mp,
2435                         "xfs_inode_recover: Bad inode log record length %d, rec ptr 0x%p",
2436                         item->ri_buf[1].i_len, item);
2437                 return XFS_ERROR(EFSCORRUPTED);
2438         }
2439
2440         /* The core is in in-core format */
2441         xfs_xlate_dinode_core((xfs_caddr_t)&dip->di_core,
2442                               (xfs_dinode_core_t*)item->ri_buf[1].i_addr,
2443                               -1, ARCH_CONVERT);
2444         /* the rest is in on-disk format */
2445         if (item->ri_buf[1].i_len > sizeof(xfs_dinode_core_t)) {
2446                 memcpy((xfs_caddr_t) dip + sizeof(xfs_dinode_core_t),
2447                         item->ri_buf[1].i_addr + sizeof(xfs_dinode_core_t),
2448                         item->ri_buf[1].i_len  - sizeof(xfs_dinode_core_t));
2449         }
2450
2451         fields = in_f->ilf_fields;
2452         switch (fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) {
2453         case XFS_ILOG_DEV:
2454                 INT_SET(dip->di_u.di_dev, ARCH_CONVERT, in_f->ilf_u.ilfu_rdev);
2455
2456                 break;
2457         case XFS_ILOG_UUID:
2458                 dip->di_u.di_muuid = in_f->ilf_u.ilfu_uuid;
2459                 break;
2460         }
2461
2462         if (in_f->ilf_size == 2)
2463                 goto write_inode_buffer;
2464         len = item->ri_buf[2].i_len;
2465         src = item->ri_buf[2].i_addr;
2466         ASSERT(in_f->ilf_size <= 4);
2467         ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK));
2468         ASSERT(!(fields & XFS_ILOG_DFORK) ||
2469                (len == in_f->ilf_dsize));
2470
2471         switch (fields & XFS_ILOG_DFORK) {
2472         case XFS_ILOG_DDATA:
2473         case XFS_ILOG_DEXT:
2474                 memcpy(&dip->di_u, src, len);
2475                 break;
2476
2477         case XFS_ILOG_DBROOT:
2478                 xfs_bmbt_to_bmdr((xfs_bmbt_block_t *)src, len,
2479                                  &(dip->di_u.di_bmbt),
2480                                  XFS_DFORK_DSIZE(dip, mp));
2481                 break;
2482
2483         default:
2484                 /*
2485                  * There are no data fork flags set.
2486                  */
2487                 ASSERT((fields & XFS_ILOG_DFORK) == 0);
2488                 break;
2489         }
2490
2491         /*
2492          * If we logged any attribute data, recover it.  There may or
2493          * may not have been any other non-core data logged in this
2494          * transaction.
2495          */
2496         if (in_f->ilf_fields & XFS_ILOG_AFORK) {
2497                 if (in_f->ilf_fields & XFS_ILOG_DFORK) {
2498                         attr_index = 3;
2499                 } else {
2500                         attr_index = 2;
2501                 }
2502                 len = item->ri_buf[attr_index].i_len;
2503                 src = item->ri_buf[attr_index].i_addr;
2504                 ASSERT(len == in_f->ilf_asize);
2505
2506                 switch (in_f->ilf_fields & XFS_ILOG_AFORK) {
2507                 case XFS_ILOG_ADATA:
2508                 case XFS_ILOG_AEXT:
2509                         dest = XFS_DFORK_APTR(dip);
2510                         ASSERT(len <= XFS_DFORK_ASIZE(dip, mp));
2511                         memcpy(dest, src, len);
2512                         break;
2513
2514                 case XFS_ILOG_ABROOT:
2515                         dest = XFS_DFORK_APTR(dip);
2516                         xfs_bmbt_to_bmdr((xfs_bmbt_block_t *)src, len,
2517                                          (xfs_bmdr_block_t*)dest,
2518                                          XFS_DFORK_ASIZE(dip, mp));
2519                         break;
2520
2521                 default:
2522                         xlog_warn("XFS: xlog_recover_do_inode_trans: Invalid flag");
2523                         ASSERT(0);
2524                         xfs_buf_relse(bp);
2525                         return XFS_ERROR(EIO);
2526                 }
2527         }
2528
2529 write_inode_buffer:
2530         if (ITEM_TYPE(item) == XFS_LI_INODE) {
2531                 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) == NULL ||
2532                        XFS_BUF_FSPRIVATE(bp, xfs_mount_t *) == mp);
2533                 XFS_BUF_SET_FSPRIVATE(bp, mp);
2534                 XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
2535                 xfs_bdwrite(mp, bp);
2536         } else {
2537                 XFS_BUF_STALE(bp);
2538                 error = xfs_bwrite(mp, bp);
2539         }
2540
2541         return (error);
2542 }
2543
2544 /*
2545  * Recover QUOTAOFF records. We simply make a note of it in the xlog_t
2546  * structure, so that we know not to do any dquot item or dquot buffer recovery,
2547  * of that type.
2548  */
2549 STATIC int
2550 xlog_recover_do_quotaoff_trans(
2551         xlog_t                  *log,
2552         xlog_recover_item_t     *item,
2553         int                     pass)
2554 {
2555         xfs_qoff_logformat_t    *qoff_f;
2556
2557         if (pass == XLOG_RECOVER_PASS2) {
2558                 return (0);
2559         }
2560
2561         qoff_f = (xfs_qoff_logformat_t *)item->ri_buf[0].i_addr;
2562         ASSERT(qoff_f);
2563
2564         /*
2565          * The logitem format's flag tells us if this was user quotaoff,
2566          * group quotaoff or both.
2567          */
2568         if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
2569                 log->l_quotaoffs_flag |= XFS_DQ_USER;
2570         if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
2571                 log->l_quotaoffs_flag |= XFS_DQ_GROUP;
2572
2573         return (0);
2574 }
2575
2576 /*
2577  * Recover a dquot record
2578  */
2579 STATIC int
2580 xlog_recover_do_dquot_trans(
2581         xlog_t                  *log,
2582         xlog_recover_item_t     *item,
2583         int                     pass)
2584 {
2585         xfs_mount_t             *mp;
2586         xfs_buf_t               *bp;
2587         struct xfs_disk_dquot   *ddq, *recddq;
2588         int                     error;
2589         xfs_dq_logformat_t      *dq_f;
2590         uint                    type;
2591
2592         if (pass == XLOG_RECOVER_PASS1) {
2593                 return 0;
2594         }
2595         mp = log->l_mp;
2596
2597         /*
2598          * Filesystems are required to send in quota flags at mount time.
2599          */
2600         if (mp->m_qflags == 0)
2601                 return (0);
2602
2603         recddq = (xfs_disk_dquot_t *)item->ri_buf[1].i_addr;
2604         ASSERT(recddq);
2605         /*
2606          * This type of quotas was turned off, so ignore this record.
2607          */
2608         type = INT_GET(recddq->d_flags, ARCH_CONVERT) &
2609                         (XFS_DQ_USER | XFS_DQ_GROUP);
2610         ASSERT(type);
2611         if (log->l_quotaoffs_flag & type)
2612                 return (0);
2613
2614         /*
2615          * At this point we know that quota was _not_ turned off.
2616          * Since the mount flags are not indicating to us otherwise, this
2617          * must mean that quota is on, and the dquot needs to be replayed.
2618          * Remember that we may not have fully recovered the superblock yet,
2619          * so we can't do the usual trick of looking at the SB quota bits.
2620          *
2621          * The other possibility, of course, is that the quota subsystem was
2622          * removed since the last mount - ENOSYS.
2623          */
2624         dq_f = (xfs_dq_logformat_t *)item->ri_buf[0].i_addr;
2625         ASSERT(dq_f);
2626         if ((error = xfs_qm_dqcheck(recddq,
2627                            dq_f->qlf_id,
2628                            0, XFS_QMOPT_DOWARN,
2629                            "xlog_recover_do_dquot_trans (log copy)"))) {
2630                 return XFS_ERROR(EIO);
2631         }
2632         ASSERT(dq_f->qlf_len == 1);
2633
2634         error = xfs_read_buf(mp, mp->m_ddev_targp,
2635                              dq_f->qlf_blkno,
2636                              XFS_FSB_TO_BB(mp, dq_f->qlf_len),
2637                              0, &bp);
2638         if (error) {
2639                 xfs_ioerror_alert("xlog_recover_do..(read#3)", mp,
2640                                   bp, dq_f->qlf_blkno);
2641                 return error;
2642         }
2643         ASSERT(bp);
2644         ddq = (xfs_disk_dquot_t *)xfs_buf_offset(bp, dq_f->qlf_boffset);
2645
2646         /*
2647          * At least the magic num portion should be on disk because this
2648          * was among a chunk of dquots created earlier, and we did some
2649          * minimal initialization then.
2650          */
2651         if (xfs_qm_dqcheck(ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
2652                            "xlog_recover_do_dquot_trans")) {
2653                 xfs_buf_relse(bp);
2654                 return XFS_ERROR(EIO);
2655         }
2656
2657         memcpy(ddq, recddq, item->ri_buf[1].i_len);
2658
2659         ASSERT(dq_f->qlf_size == 2);
2660         ASSERT(XFS_BUF_FSPRIVATE(bp, void *) == NULL ||
2661                XFS_BUF_FSPRIVATE(bp, xfs_mount_t *) == mp);
2662         XFS_BUF_SET_FSPRIVATE(bp, mp);
2663         XFS_BUF_SET_IODONE_FUNC(bp, xlog_recover_iodone);
2664         xfs_bdwrite(mp, bp);
2665
2666         return (0);
2667 }
2668
2669 /*
2670  * This routine is called to create an in-core extent free intent
2671  * item from the efi format structure which was logged on disk.
2672  * It allocates an in-core efi, copies the extents from the format
2673  * structure into it, and adds the efi to the AIL with the given
2674  * LSN.
2675  */
2676 STATIC void
2677 xlog_recover_do_efi_trans(
2678         xlog_t                  *log,
2679         xlog_recover_item_t     *item,
2680         xfs_lsn_t               lsn,
2681         int                     pass)
2682 {
2683         xfs_mount_t             *mp;
2684         xfs_efi_log_item_t      *efip;
2685         xfs_efi_log_format_t    *efi_formatp;
2686         SPLDECL(s);
2687
2688         if (pass == XLOG_RECOVER_PASS1) {
2689                 return;
2690         }
2691
2692         efi_formatp = (xfs_efi_log_format_t *)item->ri_buf[0].i_addr;
2693         ASSERT(item->ri_buf[0].i_len ==
2694                (sizeof(xfs_efi_log_format_t) +
2695                 ((efi_formatp->efi_nextents - 1) * sizeof(xfs_extent_t))));
2696
2697         mp = log->l_mp;
2698         efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
2699         memcpy((char *)&(efip->efi_format), (char *)efi_formatp,
2700               sizeof(xfs_efi_log_format_t) +
2701               ((efi_formatp->efi_nextents - 1) * sizeof(xfs_extent_t)));
2702         efip->efi_next_extent = efi_formatp->efi_nextents;
2703         efip->efi_flags |= XFS_EFI_COMMITTED;
2704
2705         AIL_LOCK(mp,s);
2706         /*
2707          * xfs_trans_update_ail() drops the AIL lock.
2708          */
2709         xfs_trans_update_ail(mp, (xfs_log_item_t *)efip, lsn, s);
2710 }
2711
2712
2713 /*
2714  * This routine is called when an efd format structure is found in
2715  * a committed transaction in the log.  It's purpose is to cancel
2716  * the corresponding efi if it was still in the log.  To do this
2717  * it searches the AIL for the efi with an id equal to that in the
2718  * efd format structure.  If we find it, we remove the efi from the
2719  * AIL and free it.
2720  */
2721 STATIC void
2722 xlog_recover_do_efd_trans(
2723         xlog_t                  *log,
2724         xlog_recover_item_t     *item,
2725         int                     pass)
2726 {
2727         xfs_mount_t             *mp;
2728         xfs_efd_log_format_t    *efd_formatp;
2729         xfs_efi_log_item_t      *efip = NULL;
2730         xfs_log_item_t          *lip;
2731         int                     gen;
2732         int                     nexts;
2733         __uint64_t              efi_id;
2734         SPLDECL(s);
2735
2736         if (pass == XLOG_RECOVER_PASS1) {
2737                 return;
2738         }
2739
2740         efd_formatp = (xfs_efd_log_format_t *)item->ri_buf[0].i_addr;
2741         ASSERT(item->ri_buf[0].i_len ==
2742                (sizeof(xfs_efd_log_format_t) +
2743                 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_t))));
2744         efi_id = efd_formatp->efd_efi_id;
2745
2746         /*
2747          * Search for the efi with the id in the efd format structure
2748          * in the AIL.
2749          */
2750         mp = log->l_mp;
2751         AIL_LOCK(mp,s);
2752         lip = xfs_trans_first_ail(mp, &gen);
2753         while (lip != NULL) {
2754                 if (lip->li_type == XFS_LI_EFI) {
2755                         efip = (xfs_efi_log_item_t *)lip;
2756                         if (efip->efi_format.efi_id == efi_id) {
2757                                 /*
2758                                  * xfs_trans_delete_ail() drops the
2759                                  * AIL lock.
2760                                  */
2761                                 xfs_trans_delete_ail(mp, lip, s);
2762                                 break;
2763                         }
2764                 }
2765                 lip = xfs_trans_next_ail(mp, lip, &gen, NULL);
2766         }
2767         if (lip == NULL) {
2768                 AIL_UNLOCK(mp, s);
2769         }
2770
2771         /*
2772          * If we found it, then free it up.  If it wasn't there, it
2773          * must have been overwritten in the log.  Oh well.
2774          */
2775         if (lip != NULL) {
2776                 nexts = efip->efi_format.efi_nextents;
2777                 if (nexts > XFS_EFI_MAX_FAST_EXTENTS) {
2778                         kmem_free(lip, sizeof(xfs_efi_log_item_t) +
2779                                   ((nexts - 1) * sizeof(xfs_extent_t)));
2780                 } else {
2781                         kmem_zone_free(xfs_efi_zone, efip);
2782                 }
2783         }
2784 }
2785
2786 /*
2787  * Perform the transaction
2788  *
2789  * If the transaction modifies a buffer or inode, do it now.  Otherwise,
2790  * EFIs and EFDs get queued up by adding entries into the AIL for them.
2791  */
2792 STATIC int
2793 xlog_recover_do_trans(
2794         xlog_t                  *log,
2795         xlog_recover_t          *trans,
2796         int                     pass)
2797 {
2798         int                     error = 0;
2799         xlog_recover_item_t     *item, *first_item;
2800
2801         if ((error = xlog_recover_reorder_trans(log, trans)))
2802                 return error;
2803         first_item = item = trans->r_itemq;
2804         do {
2805                 /*
2806                  * we don't need to worry about the block number being
2807                  * truncated in > 1 TB buffers because in user-land,
2808                  * we're now n32 or 64-bit so xfs_daddr_t is 64-bits so
2809                  * the blkno's will get through the user-mode buffer
2810                  * cache properly.  The only bad case is o32 kernels
2811                  * where xfs_daddr_t is 32-bits but mount will warn us
2812                  * off a > 1 TB filesystem before we get here.
2813                  */
2814                 if ((ITEM_TYPE(item) == XFS_LI_BUF) ||
2815                     (ITEM_TYPE(item) == XFS_LI_6_1_BUF) ||
2816                     (ITEM_TYPE(item) == XFS_LI_5_3_BUF)) {
2817                         if  ((error = xlog_recover_do_buffer_trans(log, item,
2818                                                                  pass)))
2819                                 break;
2820                 } else if ((ITEM_TYPE(item) == XFS_LI_INODE) ||
2821                            (ITEM_TYPE(item) == XFS_LI_6_1_INODE) ||
2822                            (ITEM_TYPE(item) == XFS_LI_5_3_INODE)) {
2823                         if ((error = xlog_recover_do_inode_trans(log, item,
2824                                                                 pass)))
2825                                 break;
2826                 } else if (ITEM_TYPE(item) == XFS_LI_EFI) {
2827                         xlog_recover_do_efi_trans(log, item, trans->r_lsn,
2828                                                   pass);
2829                 } else if (ITEM_TYPE(item) == XFS_LI_EFD) {
2830                         xlog_recover_do_efd_trans(log, item, pass);
2831                 } else if (ITEM_TYPE(item) == XFS_LI_DQUOT) {
2832                         if ((error = xlog_recover_do_dquot_trans(log, item,
2833                                                                    pass)))
2834                                         break;
2835                 } else if ((ITEM_TYPE(item) == XFS_LI_QUOTAOFF)) {
2836                         if ((error = xlog_recover_do_quotaoff_trans(log, item,
2837                                                                    pass)))
2838                                         break;
2839                 } else {
2840                         xlog_warn("XFS: xlog_recover_do_trans");
2841                         ASSERT(0);
2842                         error = XFS_ERROR(EIO);
2843                         break;
2844                 }
2845                 item = item->ri_next;
2846         } while (first_item != item);
2847
2848         return error;
2849 }
2850
2851 /*
2852  * Free up any resources allocated by the transaction
2853  *
2854  * Remember that EFIs, EFDs, and IUNLINKs are handled later.
2855  */
2856 STATIC void
2857 xlog_recover_free_trans(
2858         xlog_recover_t          *trans)
2859 {
2860         xlog_recover_item_t     *first_item, *item, *free_item;
2861         int                     i;
2862
2863         item = first_item = trans->r_itemq;
2864         do {
2865                 free_item = item;
2866                 item = item->ri_next;
2867                  /* Free the regions in the item. */
2868                 for (i = 0; i < free_item->ri_cnt; i++) {
2869                         kmem_free(free_item->ri_buf[i].i_addr,
2870                                   free_item->ri_buf[i].i_len);
2871                 }
2872                 /* Free the item itself */
2873                 kmem_free(free_item->ri_buf,
2874                           (free_item->ri_total * sizeof(xfs_log_iovec_t)));
2875                 kmem_free(free_item, sizeof(xlog_recover_item_t));
2876         } while (first_item != item);
2877         /* Free the transaction recover structure */
2878         kmem_free(trans, sizeof(xlog_recover_t));
2879 }
2880
2881 STATIC int
2882 xlog_recover_commit_trans(
2883         xlog_t                  *log,
2884         xlog_recover_t          **q,
2885         xlog_recover_t          *trans,
2886         int                     pass)
2887 {
2888         int                     error;
2889
2890         if ((error = xlog_recover_unlink_tid(q, trans)))
2891                 return error;
2892         if ((error = xlog_recover_do_trans(log, trans, pass)))
2893                 return error;
2894         xlog_recover_free_trans(trans);                 /* no error */
2895         return 0;
2896 }
2897
2898 STATIC int
2899 xlog_recover_unmount_trans(
2900         xlog_recover_t          *trans)
2901 {
2902         /* Do nothing now */
2903         xlog_warn("XFS: xlog_recover_unmount_trans: Unmount LR");
2904         return 0;
2905 }
2906
2907 /*
2908  * There are two valid states of the r_state field.  0 indicates that the
2909  * transaction structure is in a normal state.  We have either seen the
2910  * start of the transaction or the last operation we added was not a partial
2911  * operation.  If the last operation we added to the transaction was a
2912  * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
2913  *
2914  * NOTE: skip LRs with 0 data length.
2915  */
2916 STATIC int
2917 xlog_recover_process_data(
2918         xlog_t                  *log,
2919         xlog_recover_t          *rhash[],
2920         xlog_rec_header_t       *rhead,
2921         xfs_caddr_t             dp,
2922         int                     pass)
2923 {
2924         xfs_caddr_t             lp;
2925         int                     num_logops;
2926         xlog_op_header_t        *ohead;
2927         xlog_recover_t          *trans;
2928         xlog_tid_t              tid;
2929         int                     error;
2930         unsigned long           hash;
2931         uint                    flags;
2932
2933         lp = dp + INT_GET(rhead->h_len, ARCH_CONVERT);
2934         num_logops = INT_GET(rhead->h_num_logops, ARCH_CONVERT);
2935
2936         /* check the log format matches our own - else we can't recover */
2937         if (xlog_header_check_recover(log->l_mp, rhead))
2938                 return (XFS_ERROR(EIO));
2939
2940         while ((dp < lp) && num_logops) {
2941                 ASSERT(dp + sizeof(xlog_op_header_t) <= lp);
2942                 ohead = (xlog_op_header_t *)dp;
2943                 dp += sizeof(xlog_op_header_t);
2944                 if (ohead->oh_clientid != XFS_TRANSACTION &&
2945                     ohead->oh_clientid != XFS_LOG) {
2946                         xlog_warn(
2947                 "XFS: xlog_recover_process_data: bad clientid");
2948                         ASSERT(0);
2949                         return (XFS_ERROR(EIO));
2950                 }
2951                 tid = INT_GET(ohead->oh_tid, ARCH_CONVERT);
2952                 hash = XLOG_RHASH(tid);
2953                 trans = xlog_recover_find_tid(rhash[hash], tid);
2954                 if (trans == NULL) {               /* not found; add new tid */
2955                         if (ohead->oh_flags & XLOG_START_TRANS)
2956                                 xlog_recover_new_tid(&rhash[hash], tid,
2957                                         INT_GET(rhead->h_lsn, ARCH_CONVERT));
2958                 } else {
2959                         ASSERT(dp+INT_GET(ohead->oh_len, ARCH_CONVERT) <= lp);
2960                         flags = ohead->oh_flags & ~XLOG_END_TRANS;
2961                         if (flags & XLOG_WAS_CONT_TRANS)
2962                                 flags &= ~XLOG_CONTINUE_TRANS;
2963                         switch (flags) {
2964                         case XLOG_COMMIT_TRANS:
2965                                 error = xlog_recover_commit_trans(log,
2966                                                 &rhash[hash], trans, pass);
2967                                 break;
2968                         case XLOG_UNMOUNT_TRANS:
2969                                 error = xlog_recover_unmount_trans(trans);
2970                                 break;
2971                         case XLOG_WAS_CONT_TRANS:
2972                                 error = xlog_recover_add_to_cont_trans(trans,
2973                                                 dp, INT_GET(ohead->oh_len,
2974                                                         ARCH_CONVERT));
2975                                 break;
2976                         case XLOG_START_TRANS:
2977                                 xlog_warn(
2978                         "XFS: xlog_recover_process_data: bad transaction");
2979                                 ASSERT(0);
2980                                 error = XFS_ERROR(EIO);
2981                                 break;
2982                         case 0:
2983                         case XLOG_CONTINUE_TRANS:
2984                                 error = xlog_recover_add_to_trans(trans,
2985                                                 dp, INT_GET(ohead->oh_len,
2986                                                         ARCH_CONVERT));
2987                                 break;
2988                         default:
2989                                 xlog_warn(
2990                         "XFS: xlog_recover_process_data: bad flag");
2991                                 ASSERT(0);
2992                                 error = XFS_ERROR(EIO);
2993                                 break;
2994                         }
2995                         if (error)
2996                                 return error;
2997                 }
2998                 dp += INT_GET(ohead->oh_len, ARCH_CONVERT);
2999                 num_logops--;
3000         }
3001         return 0;
3002 }
3003
3004 /*
3005  * Process an extent free intent item that was recovered from
3006  * the log.  We need to free the extents that it describes.
3007  */
3008 STATIC void
3009 xlog_recover_process_efi(
3010         xfs_mount_t             *mp,
3011         xfs_efi_log_item_t      *efip)
3012 {
3013         xfs_efd_log_item_t      *efdp;
3014         xfs_trans_t             *tp;
3015         int                     i;
3016         xfs_extent_t            *extp;
3017         xfs_fsblock_t           startblock_fsb;
3018
3019         ASSERT(!(efip->efi_flags & XFS_EFI_RECOVERED));
3020
3021         /*
3022          * First check the validity of the extents described by the
3023          * EFI.  If any are bad, then assume that all are bad and
3024          * just toss the EFI.
3025          */
3026         for (i = 0; i < efip->efi_format.efi_nextents; i++) {
3027                 extp = &(efip->efi_format.efi_extents[i]);
3028                 startblock_fsb = XFS_BB_TO_FSB(mp,
3029                                    XFS_FSB_TO_DADDR(mp, extp->ext_start));
3030                 if ((startblock_fsb == 0) ||
3031                     (extp->ext_len == 0) ||
3032                     (startblock_fsb >= mp->m_sb.sb_dblocks) ||
3033                     (extp->ext_len >= mp->m_sb.sb_agblocks)) {
3034                         /*
3035                          * This will pull the EFI from the AIL and
3036                          * free the memory associated with it.
3037                          */
3038                         xfs_efi_release(efip, efip->efi_format.efi_nextents);
3039                         return;
3040                 }
3041         }
3042
3043         tp = xfs_trans_alloc(mp, 0);
3044         xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0, 0, 0);
3045         efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
3046
3047         for (i = 0; i < efip->efi_format.efi_nextents; i++) {
3048                 extp = &(efip->efi_format.efi_extents[i]);
3049                 xfs_free_extent(tp, extp->ext_start, extp->ext_len);
3050                 xfs_trans_log_efd_extent(tp, efdp, extp->ext_start,
3051                                          extp->ext_len);
3052         }
3053
3054         efip->efi_flags |= XFS_EFI_RECOVERED;
3055         xfs_trans_commit(tp, 0, NULL);
3056 }
3057
3058 /*
3059  * Verify that once we've encountered something other than an EFI
3060  * in the AIL that there are no more EFIs in the AIL.
3061  */
3062 #if defined(DEBUG)
3063 STATIC void
3064 xlog_recover_check_ail(
3065         xfs_mount_t             *mp,
3066         xfs_log_item_t          *lip,
3067         int                     gen)
3068 {
3069         int                     orig_gen = gen;
3070
3071         do {
3072                 ASSERT(lip->li_type != XFS_LI_EFI);
3073                 lip = xfs_trans_next_ail(mp, lip, &gen, NULL);
3074                 /*
3075                  * The check will be bogus if we restart from the
3076                  * beginning of the AIL, so ASSERT that we don't.
3077                  * We never should since we're holding the AIL lock
3078                  * the entire time.
3079                  */
3080                 ASSERT(gen == orig_gen);
3081         } while (lip != NULL);
3082 }
3083 #endif  /* DEBUG */
3084
3085 /*
3086  * When this is called, all of the EFIs which did not have
3087  * corresponding EFDs should be in the AIL.  What we do now
3088  * is free the extents associated with each one.
3089  *
3090  * Since we process the EFIs in normal transactions, they
3091  * will be removed at some point after the commit.  This prevents
3092  * us from just walking down the list processing each one.
3093  * We'll use a flag in the EFI to skip those that we've already
3094  * processed and use the AIL iteration mechanism's generation
3095  * count to try to speed this up at least a bit.
3096  *
3097  * When we start, we know that the EFIs are the only things in
3098  * the AIL.  As we process them, however, other items are added
3099  * to the AIL.  Since everything added to the AIL must come after
3100  * everything already in the AIL, we stop processing as soon as
3101  * we see something other than an EFI in the AIL.
3102  */
3103 STATIC void
3104 xlog_recover_process_efis(
3105         xlog_t                  *log)
3106 {
3107         xfs_log_item_t          *lip;
3108         xfs_efi_log_item_t      *efip;
3109         int                     gen;
3110         xfs_mount_t             *mp;
3111         SPLDECL(s);
3112
3113         mp = log->l_mp;
3114         AIL_LOCK(mp,s);
3115
3116         lip = xfs_trans_first_ail(mp, &gen);
3117         while (lip != NULL) {
3118                 /*
3119                  * We're done when we see something other than an EFI.
3120                  */
3121                 if (lip->li_type != XFS_LI_EFI) {
3122                         xlog_recover_check_ail(mp, lip, gen);
3123                         break;
3124                 }
3125
3126                 /*
3127                  * Skip EFIs that we've already processed.
3128                  */
3129                 efip = (xfs_efi_log_item_t *)lip;
3130                 if (efip->efi_flags & XFS_EFI_RECOVERED) {
3131                         lip = xfs_trans_next_ail(mp, lip, &gen, NULL);
3132                         continue;
3133                 }
3134
3135                 AIL_UNLOCK(mp, s);
3136                 xlog_recover_process_efi(mp, efip);
3137                 AIL_LOCK(mp,s);
3138                 lip = xfs_trans_next_ail(mp, lip, &gen, NULL);
3139         }
3140         AIL_UNLOCK(mp, s);
3141 }
3142
3143 /*
3144  * This routine performs a transaction to null out a bad inode pointer
3145  * in an agi unlinked inode hash bucket.
3146  */
3147 STATIC void
3148 xlog_recover_clear_agi_bucket(
3149         xfs_mount_t     *mp,
3150         xfs_agnumber_t  agno,
3151         int             bucket)
3152 {
3153         xfs_trans_t     *tp;
3154         xfs_agi_t       *agi;
3155         xfs_buf_t       *agibp;
3156         int             offset;
3157         int             error;
3158
3159         tp = xfs_trans_alloc(mp, XFS_TRANS_CLEAR_AGI_BUCKET);
3160         xfs_trans_reserve(tp, 0, XFS_CLEAR_AGI_BUCKET_LOG_RES(mp), 0, 0, 0);
3161
3162         error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
3163                                    XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
3164                                    XFS_FSS_TO_BB(mp, 1), 0, &agibp);
3165         if (error) {
3166                 xfs_trans_cancel(tp, XFS_TRANS_ABORT);
3167                 return;
3168         }
3169
3170         agi = XFS_BUF_TO_AGI(agibp);
3171         if (INT_GET(agi->agi_magicnum, ARCH_CONVERT) != XFS_AGI_MAGIC) {
3172                 xfs_trans_cancel(tp, XFS_TRANS_ABORT);
3173                 return;
3174         }
3175         ASSERT(INT_GET(agi->agi_magicnum, ARCH_CONVERT) == XFS_AGI_MAGIC);
3176
3177         INT_SET(agi->agi_unlinked[bucket], ARCH_CONVERT, NULLAGINO);
3178         offset = offsetof(xfs_agi_t, agi_unlinked) +
3179                  (sizeof(xfs_agino_t) * bucket);
3180         xfs_trans_log_buf(tp, agibp, offset,
3181                           (offset + sizeof(xfs_agino_t) - 1));
3182
3183         (void) xfs_trans_commit(tp, 0, NULL);
3184 }
3185
3186 /*
3187  * xlog_iunlink_recover
3188  *
3189  * This is called during recovery to process any inodes which
3190  * we unlinked but not freed when the system crashed.  These
3191  * inodes will be on the lists in the AGI blocks.  What we do
3192  * here is scan all the AGIs and fully truncate and free any
3193  * inodes found on the lists.  Each inode is removed from the
3194  * lists when it has been fully truncated and is freed.  The
3195  * freeing of the inode and its removal from the list must be
3196  * atomic.
3197  */
3198 void
3199 xlog_recover_process_iunlinks(
3200         xlog_t          *log)
3201 {
3202         xfs_mount_t     *mp;
3203         xfs_agnumber_t  agno;
3204         xfs_agi_t       *agi;
3205         xfs_buf_t       *agibp;
3206         xfs_buf_t       *ibp;
3207         xfs_dinode_t    *dip;
3208         xfs_inode_t     *ip;
3209         xfs_agino_t     agino;
3210         xfs_ino_t       ino;
3211         int             bucket;
3212         int             error;
3213         uint            mp_dmevmask;
3214
3215         mp = log->l_mp;
3216
3217         /*
3218          * Prevent any DMAPI event from being sent while in this function.
3219          */
3220         mp_dmevmask = mp->m_dmevmask;
3221         mp->m_dmevmask = 0;
3222
3223         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
3224                 /*
3225                  * Find the agi for this ag.
3226                  */
3227                 agibp = xfs_buf_read(mp->m_ddev_targp,
3228                                 XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
3229                                 XFS_FSS_TO_BB(mp, 1), 0);
3230                 if (XFS_BUF_ISERROR(agibp)) {
3231                         xfs_ioerror_alert("xlog_recover_process_iunlinks(#1)",
3232                                 log->l_mp, agibp,
3233                                 XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)));
3234                 }
3235                 agi = XFS_BUF_TO_AGI(agibp);
3236                 ASSERT(XFS_AGI_MAGIC ==
3237                         INT_GET(agi->agi_magicnum, ARCH_CONVERT));
3238
3239                 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) {
3240
3241                         agino = INT_GET(agi->agi_unlinked[bucket], ARCH_CONVERT);
3242                         while (agino != NULLAGINO) {
3243
3244                                 /*
3245                                  * Release the agi buffer so that it can
3246                                  * be acquired in the normal course of the
3247                                  * transaction to truncate and free the inode.
3248                                  */
3249                                 xfs_buf_relse(agibp);
3250
3251                                 ino = XFS_AGINO_TO_INO(mp, agno, agino);
3252                                 error = xfs_iget(mp, NULL, ino, 0, &ip, 0);
3253                                 ASSERT(error || (ip != NULL));
3254
3255                                 if (!error) {
3256                                         /*
3257                                          * Get the on disk inode to find the
3258                                          * next inode in the bucket.
3259                                          */
3260                                         error = xfs_itobp(mp, NULL, ip, &dip,
3261                                                         &ibp, 0);
3262                                         ASSERT(error || (dip != NULL));
3263                                 }
3264
3265                                 if (!error) {
3266                                         ASSERT(ip->i_d.di_nlink == 0);
3267
3268                                         /* setup for the next pass */
3269                                         agino = INT_GET(dip->di_next_unlinked,
3270                                                         ARCH_CONVERT);
3271                                         xfs_buf_relse(ibp);
3272                                         /*
3273                                          * Prevent any DMAPI event from
3274                                          * being sent when the
3275                                          * reference on the inode is
3276                                          * dropped.
3277                                          */
3278                                         ip->i_d.di_dmevmask = 0;
3279
3280                                         /*
3281                                          * If this is a new inode, handle
3282                                          * it specially.  Otherwise,
3283                                          * just drop our reference to the
3284                                          * inode.  If there are no
3285                                          * other references, this will
3286                                          * send the inode to
3287                                          * xfs_inactive() which will
3288                                          * truncate the file and free
3289                                          * the inode.
3290                                          */
3291                                         if (ip->i_d.di_mode == 0)
3292                                                 xfs_iput_new(ip, 0);
3293                                         else
3294                                                 VN_RELE(XFS_ITOV(ip));
3295                                 } else {
3296                                         /*
3297                                          * We can't read in the inode
3298                                          * this bucket points to, or
3299                                          * this inode is messed up.  Just
3300                                          * ditch this bucket of inodes.  We
3301                                          * will lose some inodes and space,
3302                                          * but at least we won't hang.  Call
3303                                          * xlog_recover_clear_agi_bucket()
3304                                          * to perform a transaction to clear
3305                                          * the inode pointer in the bucket.
3306                                          */
3307                                         xlog_recover_clear_agi_bucket(mp, agno,
3308                                                         bucket);
3309
3310                                         agino = NULLAGINO;
3311                                 }
3312
3313                                 /*
3314                                  * Reacquire the agibuffer and continue around
3315                                  * the loop.
3316                                  */
3317                                 agibp = xfs_buf_read(mp->m_ddev_targp,
3318                                                 XFS_AG_DADDR(mp, agno,
3319                                                         XFS_AGI_DADDR(mp)),
3320                                                 XFS_FSS_TO_BB(mp, 1), 0);
3321                                 if (XFS_BUF_ISERROR(agibp)) {
3322                                         xfs_ioerror_alert(
3323                                 "xlog_recover_process_iunlinks(#2)",
3324                                                 log->l_mp, agibp,
3325                                                 XFS_AG_DADDR(mp, agno,
3326                                                         XFS_AGI_DADDR(mp)));
3327                                 }
3328                                 agi = XFS_BUF_TO_AGI(agibp);
3329                                 ASSERT(XFS_AGI_MAGIC == INT_GET(
3330                                         agi->agi_magicnum, ARCH_CONVERT));
3331                         }
3332                 }
3333
3334                 /*
3335                  * Release the buffer for the current agi so we can
3336                  * go on to the next one.
3337                  */
3338                 xfs_buf_relse(agibp);
3339         }
3340
3341         mp->m_dmevmask = mp_dmevmask;
3342 }
3343
3344
3345 #ifdef DEBUG
3346 STATIC void
3347 xlog_pack_data_checksum(
3348         xlog_t          *log,
3349         xlog_in_core_t  *iclog,
3350         int             size)
3351 {
3352         int             i;
3353         uint            *up;
3354         uint            chksum = 0;
3355
3356         up = (uint *)iclog->ic_datap;
3357         /* divide length by 4 to get # words */
3358         for (i = 0; i < (size >> 2); i++) {
3359                 chksum ^= INT_GET(*up, ARCH_CONVERT);
3360                 up++;
3361         }
3362         INT_SET(iclog->ic_header.h_chksum, ARCH_CONVERT, chksum);
3363 }
3364 #else
3365 #define xlog_pack_data_checksum(log, iclog, size)
3366 #endif
3367
3368 /*
3369  * Stamp cycle number in every block
3370  */
3371 void
3372 xlog_pack_data(
3373         xlog_t                  *log,
3374         xlog_in_core_t          *iclog)
3375 {
3376         int                     i, j, k;
3377         int                     size = iclog->ic_offset + iclog->ic_roundoff;
3378         uint                    cycle_lsn;
3379         xfs_caddr_t             dp;
3380         xlog_in_core_2_t        *xhdr;
3381
3382         xlog_pack_data_checksum(log, iclog, size);
3383
3384         cycle_lsn = CYCLE_LSN_NOCONV(iclog->ic_header.h_lsn, ARCH_CONVERT);
3385
3386         dp = iclog->ic_datap;
3387         for (i = 0; i < BTOBB(size) &&
3388                 i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
3389                 iclog->ic_header.h_cycle_data[i] = *(uint *)dp;
3390                 *(uint *)dp = cycle_lsn;
3391                 dp += BBSIZE;
3392         }
3393
3394         if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
3395                 xhdr = (xlog_in_core_2_t *)&iclog->ic_header;
3396                 for ( ; i < BTOBB(size); i++) {
3397                         j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3398                         k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3399                         xhdr[j].hic_xheader.xh_cycle_data[k] = *(uint *)dp;
3400                         *(uint *)dp = cycle_lsn;
3401                         dp += BBSIZE;
3402                 }
3403
3404                 for (i = 1; i < log->l_iclog_heads; i++) {
3405                         xhdr[i].hic_xheader.xh_cycle = cycle_lsn;
3406                 }
3407         }
3408 }
3409
3410 #if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
3411 STATIC void
3412 xlog_unpack_data_checksum(
3413         xlog_rec_header_t       *rhead,
3414         xfs_caddr_t             dp,
3415         xlog_t                  *log)
3416 {
3417         uint                    *up = (uint *)dp;
3418         uint                    chksum = 0;
3419         int                     i;
3420
3421         /* divide length by 4 to get # words */
3422         for (i=0; i < INT_GET(rhead->h_len, ARCH_CONVERT) >> 2; i++) {
3423                 chksum ^= INT_GET(*up, ARCH_CONVERT);
3424                 up++;
3425         }
3426         if (chksum != INT_GET(rhead->h_chksum, ARCH_CONVERT)) {
3427             if (!INT_ISZERO(rhead->h_chksum, ARCH_CONVERT) ||
3428                 ((log->l_flags & XLOG_CHKSUM_MISMATCH) == 0)) {
3429                     cmn_err(CE_DEBUG,
3430                         "XFS: LogR chksum mismatch: was (0x%x) is (0x%x)",
3431                             INT_GET(rhead->h_chksum, ARCH_CONVERT), chksum);
3432                     cmn_err(CE_DEBUG,
3433 "XFS: Disregard message if filesystem was created with non-DEBUG kernel");
3434                     if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
3435                             cmn_err(CE_DEBUG,
3436                                 "XFS: LogR this is a LogV2 filesystem");
3437                     }
3438                     log->l_flags |= XLOG_CHKSUM_MISMATCH;
3439             }
3440         }
3441 }
3442 #else
3443 #define xlog_unpack_data_checksum(rhead, dp, log)
3444 #endif
3445
3446 STATIC void
3447 xlog_unpack_data(
3448         xlog_rec_header_t       *rhead,
3449         xfs_caddr_t             dp,
3450         xlog_t                  *log)
3451 {
3452         int                     i, j, k;
3453         xlog_in_core_2_t        *xhdr;
3454
3455         for (i = 0; i < BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT)) &&
3456                   i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
3457                 *(uint *)dp = *(uint *)&rhead->h_cycle_data[i];
3458                 dp += BBSIZE;
3459         }
3460
3461         if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
3462                 xhdr = (xlog_in_core_2_t *)rhead;
3463                 for ( ; i < BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT)); i++) {
3464                         j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3465                         k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3466                         *(uint *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];
3467                         dp += BBSIZE;
3468                 }
3469         }
3470
3471         xlog_unpack_data_checksum(rhead, dp, log);
3472 }
3473
3474 STATIC int
3475 xlog_valid_rec_header(
3476         xlog_t                  *log,
3477         xlog_rec_header_t       *rhead,
3478         xfs_daddr_t             blkno)
3479 {
3480         int                     hlen;
3481
3482         if (unlikely(
3483             (INT_GET(rhead->h_magicno, ARCH_CONVERT) !=
3484                         XLOG_HEADER_MAGIC_NUM))) {
3485                 XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
3486                                 XFS_ERRLEVEL_LOW, log->l_mp);
3487                 return XFS_ERROR(EFSCORRUPTED);
3488         }
3489         if (unlikely(
3490             (INT_ISZERO(rhead->h_version, ARCH_CONVERT) ||
3491             (INT_GET(rhead->h_version, ARCH_CONVERT) &
3492                         (~XLOG_VERSION_OKBITS)) != 0))) {
3493                 xlog_warn("XFS: %s: unrecognised log version (%d).",
3494                         __FUNCTION__, INT_GET(rhead->h_version, ARCH_CONVERT));
3495                 return XFS_ERROR(EIO);
3496         }
3497
3498         /* LR body must have data or it wouldn't have been written */
3499         hlen = INT_GET(rhead->h_len, ARCH_CONVERT);
3500         if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
3501                 XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
3502                                 XFS_ERRLEVEL_LOW, log->l_mp);
3503                 return XFS_ERROR(EFSCORRUPTED);
3504         }
3505         if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
3506                 XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
3507                                 XFS_ERRLEVEL_LOW, log->l_mp);
3508                 return XFS_ERROR(EFSCORRUPTED);
3509         }
3510         return 0;
3511 }
3512
3513 /*
3514  * Read the log from tail to head and process the log records found.
3515  * Handle the two cases where the tail and head are in the same cycle
3516  * and where the active portion of the log wraps around the end of
3517  * the physical log separately.  The pass parameter is passed through
3518  * to the routines called to process the data and is not looked at
3519  * here.
3520  */
3521 STATIC int
3522 xlog_do_recovery_pass(
3523         xlog_t                  *log,
3524         xfs_daddr_t             head_blk,
3525         xfs_daddr_t             tail_blk,
3526         int                     pass)
3527 {
3528         xlog_rec_header_t       *rhead;
3529         xfs_daddr_t             blk_no;
3530         xfs_caddr_t             bufaddr, offset;
3531         xfs_buf_t               *hbp, *dbp;
3532         int                     error = 0, h_size;
3533         int                     bblks, split_bblks;
3534         int                     hblks, split_hblks, wrapped_hblks;
3535         xlog_recover_t          *rhash[XLOG_RHASH_SIZE];
3536
3537         ASSERT(head_blk != tail_blk);
3538
3539         /*
3540          * Read the header of the tail block and get the iclog buffer size from
3541          * h_size.  Use this to tell how many sectors make up the log header.
3542          */
3543         if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
3544                 /*
3545                  * When using variable length iclogs, read first sector of
3546                  * iclog header and extract the header size from it.  Get a
3547                  * new hbp that is the correct size.
3548                  */
3549                 hbp = xlog_get_bp(log, 1);
3550                 if (!hbp)
3551                         return ENOMEM;
3552                 if ((error = xlog_bread(log, tail_blk, 1, hbp)))
3553                         goto bread_err1;
3554                 offset = xlog_align(log, tail_blk, 1, hbp);
3555                 rhead = (xlog_rec_header_t *)offset;
3556                 error = xlog_valid_rec_header(log, rhead, tail_blk);
3557                 if (error)
3558                         goto bread_err1;
3559                 h_size = INT_GET(rhead->h_size, ARCH_CONVERT);
3560                 if ((INT_GET(rhead->h_version, ARCH_CONVERT)
3561                                 & XLOG_VERSION_2) &&
3562                     (h_size > XLOG_HEADER_CYCLE_SIZE)) {
3563                         hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
3564                         if (h_size % XLOG_HEADER_CYCLE_SIZE)
3565                                 hblks++;
3566                         xlog_put_bp(hbp);
3567                         hbp = xlog_get_bp(log, hblks);
3568                 } else {
3569                         hblks = 1;
3570                 }
3571         } else {
3572                 ASSERT(log->l_sectbb_log == 0);
3573                 hblks = 1;
3574                 hbp = xlog_get_bp(log, 1);
3575                 h_size = XLOG_BIG_RECORD_BSIZE;
3576         }
3577
3578         if (!hbp)
3579                 return ENOMEM;
3580         dbp = xlog_get_bp(log, BTOBB(h_size));
3581         if (!dbp) {
3582                 xlog_put_bp(hbp);
3583                 return ENOMEM;
3584         }
3585
3586         memset(rhash, 0, sizeof(rhash));
3587         if (tail_blk <= head_blk) {
3588                 for (blk_no = tail_blk; blk_no < head_blk; ) {
3589                         if ((error = xlog_bread(log, blk_no, hblks, hbp)))
3590                                 goto bread_err2;
3591                         offset = xlog_align(log, blk_no, hblks, hbp);
3592                         rhead = (xlog_rec_header_t *)offset;
3593                         error = xlog_valid_rec_header(log, rhead, blk_no);
3594                         if (error)
3595                                 goto bread_err2;
3596
3597                         /* blocks in data section */
3598                         bblks = (int)BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT));
3599                         error = xlog_bread(log, blk_no + hblks, bblks, dbp);
3600                         if (error)
3601                                 goto bread_err2;
3602                         offset = xlog_align(log, blk_no + hblks, bblks, dbp);
3603                         xlog_unpack_data(rhead, offset, log);
3604                         if ((error = xlog_recover_process_data(log,
3605                                                 rhash, rhead, offset, pass)))
3606                                 goto bread_err2;
3607                         blk_no += bblks + hblks;
3608                 }
3609         } else {
3610                 /*
3611                  * Perform recovery around the end of the physical log.
3612                  * When the head is not on the same cycle number as the tail,
3613                  * we can't do a sequential recovery as above.
3614                  */
3615                 blk_no = tail_blk;
3616                 while (blk_no < log->l_logBBsize) {
3617                         /*
3618                          * Check for header wrapping around physical end-of-log
3619                          */
3620                         offset = NULL;
3621                         split_hblks = 0;
3622                         wrapped_hblks = 0;
3623                         if (blk_no + hblks <= log->l_logBBsize) {
3624                                 /* Read header in one read */
3625                                 error = xlog_bread(log, blk_no, hblks, hbp);
3626                                 if (error)
3627                                         goto bread_err2;
3628                                 offset = xlog_align(log, blk_no, hblks, hbp);
3629                         } else {
3630                                 /* This LR is split across physical log end */
3631                                 if (blk_no != log->l_logBBsize) {
3632                                         /* some data before physical log end */
3633                                         ASSERT(blk_no <= INT_MAX);
3634                                         split_hblks = log->l_logBBsize - (int)blk_no;
3635                                         ASSERT(split_hblks > 0);
3636                                         if ((error = xlog_bread(log, blk_no,
3637                                                         split_hblks, hbp)))
3638                                                 goto bread_err2;
3639                                         offset = xlog_align(log, blk_no,
3640                                                         split_hblks, hbp);
3641                                 }
3642                                 /*
3643                                  * Note: this black magic still works with
3644                                  * large sector sizes (non-512) only because:
3645                                  * - we increased the buffer size originally
3646                                  *   by 1 sector giving us enough extra space
3647                                  *   for the second read;
3648                                  * - the log start is guaranteed to be sector
3649                                  *   aligned;
3650                                  * - we read the log end (LR header start)
3651                                  *   _first_, then the log start (LR header end)
3652                                  *   - order is important.
3653                                  */
3654                                 bufaddr = XFS_BUF_PTR(hbp);
3655                                 XFS_BUF_SET_PTR(hbp,
3656                                                 bufaddr + BBTOB(split_hblks),
3657                                                 BBTOB(hblks - split_hblks));
3658                                 wrapped_hblks = hblks - split_hblks;
3659                                 error = xlog_bread(log, 0, wrapped_hblks, hbp);
3660                                 if (error)
3661                                         goto bread_err2;
3662                                 XFS_BUF_SET_PTR(hbp, bufaddr, BBTOB(hblks));
3663                                 if (!offset)
3664                                         offset = xlog_align(log, 0,
3665                                                         wrapped_hblks, hbp);
3666                         }
3667                         rhead = (xlog_rec_header_t *)offset;
3668                         error = xlog_valid_rec_header(log, rhead,
3669                                                 split_hblks ? blk_no : 0);
3670                         if (error)
3671                                 goto bread_err2;
3672
3673                         bblks = (int)BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT));
3674                         blk_no += hblks;
3675
3676                         /* Read in data for log record */
3677                         if (blk_no + bblks <= log->l_logBBsize) {
3678                                 error = xlog_bread(log, blk_no, bblks, dbp);
3679                                 if (error)
3680                                         goto bread_err2;
3681                                 offset = xlog_align(log, blk_no, bblks, dbp);
3682                         } else {
3683                                 /* This log record is split across the
3684                                  * physical end of log */
3685                                 offset = NULL;
3686                                 split_bblks = 0;
3687                                 if (blk_no != log->l_logBBsize) {
3688                                         /* some data is before the physical
3689                                          * end of log */
3690                                         ASSERT(!wrapped_hblks);
3691                                         ASSERT(blk_no <= INT_MAX);
3692                                         split_bblks =
3693                                                 log->l_logBBsize - (int)blk_no;
3694                                         ASSERT(split_bblks > 0);
3695                                         if ((error = xlog_bread(log, blk_no,
3696                                                         split_bblks, dbp)))
3697                                                 goto bread_err2;
3698                                         offset = xlog_align(log, blk_no,
3699                                                         split_bblks, dbp);
3700                                 }
3701                                 /*
3702                                  * Note: this black magic still works with
3703                                  * large sector sizes (non-512) only because:
3704                                  * - we increased the buffer size originally
3705                                  *   by 1 sector giving us enough extra space
3706                                  *   for the second read;
3707                                  * - the log start is guaranteed to be sector
3708                                  *   aligned;
3709                                  * - we read the log end (LR header start)
3710                                  *   _first_, then the log start (LR header end)
3711                                  *   - order is important.
3712                                  */
3713                                 bufaddr = XFS_BUF_PTR(dbp);
3714                                 XFS_BUF_SET_PTR(dbp,
3715                                                 bufaddr + BBTOB(split_bblks),
3716                                                 BBTOB(bblks - split_bblks));
3717                                 if ((error = xlog_bread(log, wrapped_hblks,
3718                                                 bblks - split_bblks, dbp)))
3719                                         goto bread_err2;
3720                                 XFS_BUF_SET_PTR(dbp, bufaddr, h_size);
3721                                 if (!offset)
3722                                         offset = xlog_align(log, wrapped_hblks,
3723                                                 bblks - split_bblks, dbp);
3724                         }
3725                         xlog_unpack_data(rhead, offset, log);
3726                         if ((error = xlog_recover_process_data(log, rhash,
3727                                                         rhead, offset, pass)))
3728                                 goto bread_err2;
3729                         blk_no += bblks;
3730                 }
3731
3732                 ASSERT(blk_no >= log->l_logBBsize);
3733                 blk_no -= log->l_logBBsize;
3734
3735                 /* read first part of physical log */
3736                 while (blk_no < head_blk) {
3737                         if ((error = xlog_bread(log, blk_no, hblks, hbp)))
3738                                 goto bread_err2;
3739                         offset = xlog_align(log, blk_no, hblks, hbp);
3740                         rhead = (xlog_rec_header_t *)offset;
3741                         error = xlog_valid_rec_header(log, rhead, blk_no);
3742                         if (error)
3743                                 goto bread_err2;
3744                         bblks = (int)BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT));
3745                         if ((error = xlog_bread(log, blk_no+hblks, bblks, dbp)))
3746                                 goto bread_err2;
3747                         offset = xlog_align(log, blk_no+hblks, bblks, dbp);
3748                         xlog_unpack_data(rhead, offset, log);
3749                         if ((error = xlog_recover_process_data(log, rhash,
3750                                                         rhead, offset, pass)))
3751                                 goto bread_err2;
3752                         blk_no += bblks + hblks;
3753                 }
3754         }
3755
3756  bread_err2:
3757         xlog_put_bp(dbp);
3758  bread_err1:
3759         xlog_put_bp(hbp);
3760         return error;
3761 }
3762
3763 /*
3764  * Do the recovery of the log.  We actually do this in two phases.
3765  * The two passes are necessary in order to implement the function
3766  * of cancelling a record written into the log.  The first pass
3767  * determines those things which have been cancelled, and the
3768  * second pass replays log items normally except for those which
3769  * have been cancelled.  The handling of the replay and cancellations
3770  * takes place in the log item type specific routines.
3771  *
3772  * The table of items which have cancel records in the log is allocated
3773  * and freed at this level, since only here do we know when all of
3774  * the log recovery has been completed.
3775  */
3776 STATIC int
3777 xlog_do_log_recovery(
3778         xlog_t          *log,
3779         xfs_daddr_t     head_blk,
3780         xfs_daddr_t     tail_blk)
3781 {
3782         int             error;
3783
3784         ASSERT(head_blk != tail_blk);
3785
3786         /*
3787          * First do a pass to find all of the cancelled buf log items.
3788          * Store them in the buf_cancel_table for use in the second pass.
3789          */
3790         log->l_buf_cancel_table =
3791                 (xfs_buf_cancel_t **)kmem_zalloc(XLOG_BC_TABLE_SIZE *
3792                                                  sizeof(xfs_buf_cancel_t*),
3793                                                  KM_SLEEP);
3794         error = xlog_do_recovery_pass(log, head_blk, tail_blk,
3795                                       XLOG_RECOVER_PASS1);
3796         if (error != 0) {
3797                 kmem_free(log->l_buf_cancel_table,
3798                           XLOG_BC_TABLE_SIZE * sizeof(xfs_buf_cancel_t*));
3799                 log->l_buf_cancel_table = NULL;
3800                 return error;
3801         }
3802         /*
3803          * Then do a second pass to actually recover the items in the log.
3804          * When it is complete free the table of buf cancel items.
3805          */
3806         error = xlog_do_recovery_pass(log, head_blk, tail_blk,
3807                                       XLOG_RECOVER_PASS2);
3808 #ifdef DEBUG
3809         {
3810                 int     i;
3811
3812                 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
3813                         ASSERT(log->l_buf_cancel_table[i] == NULL);
3814         }
3815 #endif  /* DEBUG */
3816
3817         kmem_free(log->l_buf_cancel_table,
3818                   XLOG_BC_TABLE_SIZE * sizeof(xfs_buf_cancel_t*));
3819         log->l_buf_cancel_table = NULL;
3820
3821         return error;
3822 }
3823
3824 /*
3825  * Do the actual recovery
3826  */
3827 STATIC int
3828 xlog_do_recover(
3829         xlog_t          *log,
3830         xfs_daddr_t     head_blk,
3831         xfs_daddr_t     tail_blk)
3832 {
3833         int             error;
3834         xfs_buf_t       *bp;
3835         xfs_sb_t        *sbp;
3836
3837         /*
3838          * First replay the images in the log.
3839          */
3840         error = xlog_do_log_recovery(log, head_blk, tail_blk);
3841         if (error) {
3842                 return error;
3843         }
3844
3845         XFS_bflush(log->l_mp->m_ddev_targp);
3846
3847         /*
3848          * If IO errors happened during recovery, bail out.
3849          */
3850         if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
3851                 return (EIO);
3852         }
3853
3854         /*
3855          * We now update the tail_lsn since much of the recovery has completed
3856          * and there may be space available to use.  If there were no extent
3857          * or iunlinks, we can free up the entire log and set the tail_lsn to
3858          * be the last_sync_lsn.  This was set in xlog_find_tail to be the
3859          * lsn of the last known good LR on disk.  If there are extent frees
3860          * or iunlinks they will have some entries in the AIL; so we look at
3861          * the AIL to determine how to set the tail_lsn.
3862          */
3863         xlog_assign_tail_lsn(log->l_mp);
3864
3865         /*
3866          * Now that we've finished replaying all buffer and inode
3867          * updates, re-read in the superblock.
3868          */
3869         bp = xfs_getsb(log->l_mp, 0);
3870         XFS_BUF_UNDONE(bp);
3871         XFS_BUF_READ(bp);
3872         xfsbdstrat(log->l_mp, bp);
3873         if ((error = xfs_iowait(bp))) {
3874                 xfs_ioerror_alert("xlog_do_recover",
3875                                   log->l_mp, bp, XFS_BUF_ADDR(bp));
3876                 ASSERT(0);
3877                 xfs_buf_relse(bp);
3878                 return error;
3879         }
3880
3881         /* Convert superblock from on-disk format */
3882         sbp = &log->l_mp->m_sb;
3883         xfs_xlatesb(XFS_BUF_TO_SBP(bp), sbp, 1, ARCH_CONVERT, XFS_SB_ALL_BITS);
3884         ASSERT(sbp->sb_magicnum == XFS_SB_MAGIC);
3885         ASSERT(XFS_SB_GOOD_VERSION(sbp));
3886         xfs_buf_relse(bp);
3887
3888         xlog_recover_check_summary(log);
3889
3890         /* Normal transactions can now occur */
3891         log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
3892         return 0;
3893 }
3894
3895 /*
3896  * Perform recovery and re-initialize some log variables in xlog_find_tail.
3897  *
3898  * Return error or zero.
3899  */
3900 int
3901 xlog_recover(
3902         xlog_t          *log,
3903         int             readonly)
3904 {
3905         xfs_daddr_t     head_blk, tail_blk;
3906         int             error;
3907
3908         /* find the tail of the log */
3909         if ((error = xlog_find_tail(log, &head_blk, &tail_blk, readonly)))
3910                 return error;
3911
3912         if (tail_blk != head_blk) {
3913                 /* There used to be a comment here:
3914                  *
3915                  * disallow recovery on read-only mounts.  note -- mount
3916                  * checks for ENOSPC and turns it into an intelligent
3917                  * error message.
3918                  * ...but this is no longer true.  Now, unless you specify
3919                  * NORECOVERY (in which case this function would never be
3920                  * called), we just go ahead and recover.  We do this all
3921                  * under the vfs layer, so we can get away with it unless
3922                  * the device itself is read-only, in which case we fail.
3923                  */
3924                 if ((error = xfs_dev_is_read_only(log->l_mp,
3925                                                 "recovery required"))) {
3926                         return error;
3927                 }
3928
3929                 cmn_err(CE_NOTE,
3930                         "Starting XFS recovery on filesystem: %s (dev: %s)",
3931                         log->l_mp->m_fsname, XFS_BUFTARG_NAME(log->l_targ));
3932
3933                 error = xlog_do_recover(log, head_blk, tail_blk);
3934                 log->l_flags |= XLOG_RECOVERY_NEEDED;
3935         }
3936         return error;
3937 }
3938
3939 /*
3940  * In the first part of recovery we replay inodes and buffers and build
3941  * up the list of extent free items which need to be processed.  Here
3942  * we process the extent free items and clean up the on disk unlinked
3943  * inode lists.  This is separated from the first part of recovery so
3944  * that the root and real-time bitmap inodes can be read in from disk in
3945  * between the two stages.  This is necessary so that we can free space
3946  * in the real-time portion of the file system.
3947  */
3948 int
3949 xlog_recover_finish(
3950         xlog_t          *log,
3951         int             mfsi_flags)
3952 {
3953         /*
3954          * Now we're ready to do the transactions needed for the
3955          * rest of recovery.  Start with completing all the extent
3956          * free intent records and then process the unlinked inode
3957          * lists.  At this point, we essentially run in normal mode
3958          * except that we're still performing recovery actions
3959          * rather than accepting new requests.
3960          */
3961         if (log->l_flags & XLOG_RECOVERY_NEEDED) {
3962                 xlog_recover_process_efis(log);
3963                 /*
3964                  * Sync the log to get all the EFIs out of the AIL.
3965                  * This isn't absolutely necessary, but it helps in
3966                  * case the unlink transactions would have problems
3967                  * pushing the EFIs out of the way.
3968                  */
3969                 xfs_log_force(log->l_mp, (xfs_lsn_t)0,
3970                               (XFS_LOG_FORCE | XFS_LOG_SYNC));
3971
3972                 if ( (mfsi_flags & XFS_MFSI_NOUNLINK) == 0 ) {
3973                         xlog_recover_process_iunlinks(log);
3974                 }
3975
3976                 xlog_recover_check_summary(log);
3977
3978                 cmn_err(CE_NOTE,
3979                         "Ending XFS recovery on filesystem: %s (dev: %s)",
3980                         log->l_mp->m_fsname, XFS_BUFTARG_NAME(log->l_targ));
3981                 log->l_flags &= ~XLOG_RECOVERY_NEEDED;
3982         } else {
3983                 cmn_err(CE_DEBUG,
3984                         "!Ending clean XFS mount for filesystem: %s",
3985                         log->l_mp->m_fsname);
3986         }
3987         return 0;
3988 }
3989
3990
3991 #if defined(DEBUG)
3992 /*
3993  * Read all of the agf and agi counters and check that they
3994  * are consistent with the superblock counters.
3995  */
3996 void
3997 xlog_recover_check_summary(
3998         xlog_t          *log)
3999 {
4000         xfs_mount_t     *mp;
4001         xfs_agf_t       *agfp;
4002         xfs_agi_t       *agip;
4003         xfs_buf_t       *agfbp;
4004         xfs_buf_t       *agibp;
4005         xfs_daddr_t     agfdaddr;
4006         xfs_daddr_t     agidaddr;
4007         xfs_buf_t       *sbbp;
4008 #ifdef XFS_LOUD_RECOVERY
4009         xfs_sb_t        *sbp;
4010 #endif
4011         xfs_agnumber_t  agno;
4012         __uint64_t      freeblks;
4013         __uint64_t      itotal;
4014         __uint64_t      ifree;
4015
4016         mp = log->l_mp;
4017
4018         freeblks = 0LL;
4019         itotal = 0LL;
4020         ifree = 0LL;
4021         for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
4022                 agfdaddr = XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp));
4023                 agfbp = xfs_buf_read(mp->m_ddev_targp, agfdaddr,
4024                                 XFS_FSS_TO_BB(mp, 1), 0);
4025                 if (XFS_BUF_ISERROR(agfbp)) {
4026                         xfs_ioerror_alert("xlog_recover_check_summary(agf)",
4027                                                 mp, agfbp, agfdaddr);
4028                 }
4029                 agfp = XFS_BUF_TO_AGF(agfbp);
4030                 ASSERT(XFS_AGF_MAGIC ==
4031                         INT_GET(agfp->agf_magicnum, ARCH_CONVERT));
4032                 ASSERT(XFS_AGF_GOOD_VERSION(
4033                         INT_GET(agfp->agf_versionnum, ARCH_CONVERT)));
4034                 ASSERT(INT_GET(agfp->agf_seqno, ARCH_CONVERT) == agno);
4035
4036                 freeblks += INT_GET(agfp->agf_freeblks, ARCH_CONVERT) +
4037                             INT_GET(agfp->agf_flcount, ARCH_CONVERT);
4038                 xfs_buf_relse(agfbp);
4039
4040                 agidaddr = XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp));
4041                 agibp = xfs_buf_read(mp->m_ddev_targp, agidaddr,
4042                                 XFS_FSS_TO_BB(mp, 1), 0);
4043                 if (XFS_BUF_ISERROR(agibp)) {
4044                         xfs_ioerror_alert("xlog_recover_check_summary(agi)",
4045                                           mp, agibp, agidaddr);
4046                 }
4047                 agip = XFS_BUF_TO_AGI(agibp);
4048                 ASSERT(XFS_AGI_MAGIC ==
4049                         INT_GET(agip->agi_magicnum, ARCH_CONVERT));
4050                 ASSERT(XFS_AGI_GOOD_VERSION(
4051                         INT_GET(agip->agi_versionnum, ARCH_CONVERT)));
4052                 ASSERT(INT_GET(agip->agi_seqno, ARCH_CONVERT) == agno);
4053
4054                 itotal += INT_GET(agip->agi_count, ARCH_CONVERT);
4055                 ifree += INT_GET(agip->agi_freecount, ARCH_CONVERT);
4056                 xfs_buf_relse(agibp);
4057         }
4058
4059         sbbp = xfs_getsb(mp, 0);
4060 #ifdef XFS_LOUD_RECOVERY
4061         sbp = &mp->m_sb;
4062         xfs_xlatesb(XFS_BUF_TO_SBP(sbbp), sbp, 1, ARCH_CONVERT, XFS_SB_ALL_BITS);
4063         cmn_err(CE_NOTE,
4064                 "xlog_recover_check_summary: sb_icount %Lu itotal %Lu",
4065                 sbp->sb_icount, itotal);
4066         cmn_err(CE_NOTE,
4067                 "xlog_recover_check_summary: sb_ifree %Lu itotal %Lu",
4068                 sbp->sb_ifree, ifree);
4069         cmn_err(CE_NOTE,
4070                 "xlog_recover_check_summary: sb_fdblocks %Lu freeblks %Lu",
4071                 sbp->sb_fdblocks, freeblks);
4072 #if 0
4073         /*
4074          * This is turned off until I account for the allocation
4075          * btree blocks which live in free space.
4076          */
4077         ASSERT(sbp->sb_icount == itotal);
4078         ASSERT(sbp->sb_ifree == ifree);
4079         ASSERT(sbp->sb_fdblocks == freeblks);
4080 #endif
4081 #endif
4082         xfs_buf_relse(sbbp);
4083 }
4084 #endif /* DEBUG */