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