/fs/xfs/xfs_log_recover.c
C | 5872 lines | 3674 code | 564 blank | 1634 comment | 694 complexity | 38acf4b57544ad66eb9765d057c186f1 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
Large files files are truncated, but you can click here to view the full file
- /*
- * Copyright (c) 2000-2006 Silicon Graphics, Inc.
- * All Rights Reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it would be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
- #include "xfs.h"
- #include "xfs_fs.h"
- #include "xfs_shared.h"
- #include "xfs_format.h"
- #include "xfs_log_format.h"
- #include "xfs_trans_resv.h"
- #include "xfs_bit.h"
- #include "xfs_sb.h"
- #include "xfs_mount.h"
- #include "xfs_da_format.h"
- #include "xfs_da_btree.h"
- #include "xfs_inode.h"
- #include "xfs_trans.h"
- #include "xfs_log.h"
- #include "xfs_log_priv.h"
- #include "xfs_log_recover.h"
- #include "xfs_inode_item.h"
- #include "xfs_extfree_item.h"
- #include "xfs_trans_priv.h"
- #include "xfs_alloc.h"
- #include "xfs_ialloc.h"
- #include "xfs_quota.h"
- #include "xfs_cksum.h"
- #include "xfs_trace.h"
- #include "xfs_icache.h"
- #include "xfs_bmap_btree.h"
- #include "xfs_error.h"
- #include "xfs_dir2.h"
- #include "xfs_rmap_item.h"
- #include "xfs_buf_item.h"
- #include "xfs_refcount_item.h"
- #include "xfs_bmap_item.h"
- #define BLK_AVG(blk1, blk2) ((blk1+blk2) >> 1)
- STATIC int
- xlog_find_zeroed(
- struct xlog *,
- xfs_daddr_t *);
- STATIC int
- xlog_clear_stale_blocks(
- struct xlog *,
- xfs_lsn_t);
- #if defined(DEBUG)
- STATIC void
- xlog_recover_check_summary(
- struct xlog *);
- #else
- #define xlog_recover_check_summary(log)
- #endif
- STATIC int
- xlog_do_recovery_pass(
- struct xlog *, xfs_daddr_t, xfs_daddr_t, int, xfs_daddr_t *);
- /*
- * This structure is used during recovery to record the buf log items which
- * have been canceled and should not be replayed.
- */
- struct xfs_buf_cancel {
- xfs_daddr_t bc_blkno;
- uint bc_len;
- int bc_refcount;
- struct list_head bc_list;
- };
- /*
- * Sector aligned buffer routines for buffer create/read/write/access
- */
- /*
- * Verify the log-relative block number and length in basic blocks are valid for
- * an operation involving the given XFS log buffer. Returns true if the fields
- * are valid, false otherwise.
- */
- static inline bool
- xlog_verify_bp(
- struct xlog *log,
- xfs_daddr_t blk_no,
- int bbcount)
- {
- if (blk_no < 0 || blk_no >= log->l_logBBsize)
- return false;
- if (bbcount <= 0 || (blk_no + bbcount) > log->l_logBBsize)
- return false;
- return true;
- }
- /*
- * Allocate a buffer to hold log data. The buffer needs to be able
- * to map to a range of nbblks basic blocks at any valid (basic
- * block) offset within the log.
- */
- STATIC xfs_buf_t *
- xlog_get_bp(
- struct xlog *log,
- int nbblks)
- {
- struct xfs_buf *bp;
- /*
- * Pass log block 0 since we don't have an addr yet, buffer will be
- * verified on read.
- */
- if (!xlog_verify_bp(log, 0, nbblks)) {
- xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
- nbblks);
- XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
- return NULL;
- }
- /*
- * We do log I/O in units of log sectors (a power-of-2
- * multiple of the basic block size), so we round up the
- * requested size to accommodate the basic blocks required
- * for complete log sectors.
- *
- * In addition, the buffer may be used for a non-sector-
- * aligned block offset, in which case an I/O of the
- * requested size could extend beyond the end of the
- * buffer. If the requested size is only 1 basic block it
- * will never straddle a sector boundary, so this won't be
- * an issue. Nor will this be a problem if the log I/O is
- * done in basic blocks (sector size 1). But otherwise we
- * extend the buffer by one extra log sector to ensure
- * there's space to accommodate this possibility.
- */
- if (nbblks > 1 && log->l_sectBBsize > 1)
- nbblks += log->l_sectBBsize;
- nbblks = round_up(nbblks, log->l_sectBBsize);
- bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, nbblks, 0);
- if (bp)
- xfs_buf_unlock(bp);
- return bp;
- }
- STATIC void
- xlog_put_bp(
- xfs_buf_t *bp)
- {
- xfs_buf_free(bp);
- }
- /*
- * Return the address of the start of the given block number's data
- * in a log buffer. The buffer covers a log sector-aligned region.
- */
- STATIC char *
- xlog_align(
- struct xlog *log,
- xfs_daddr_t blk_no,
- int nbblks,
- struct xfs_buf *bp)
- {
- xfs_daddr_t offset = blk_no & ((xfs_daddr_t)log->l_sectBBsize - 1);
- ASSERT(offset + nbblks <= bp->b_length);
- return bp->b_addr + BBTOB(offset);
- }
- /*
- * nbblks should be uint, but oh well. Just want to catch that 32-bit length.
- */
- STATIC int
- xlog_bread_noalign(
- struct xlog *log,
- xfs_daddr_t blk_no,
- int nbblks,
- struct xfs_buf *bp)
- {
- int error;
- if (!xlog_verify_bp(log, blk_no, nbblks)) {
- xfs_warn(log->l_mp,
- "Invalid log block/length (0x%llx, 0x%x) for buffer",
- blk_no, nbblks);
- XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
- return -EFSCORRUPTED;
- }
- blk_no = round_down(blk_no, log->l_sectBBsize);
- nbblks = round_up(nbblks, log->l_sectBBsize);
- ASSERT(nbblks > 0);
- ASSERT(nbblks <= bp->b_length);
- XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
- bp->b_flags |= XBF_READ;
- bp->b_io_length = nbblks;
- bp->b_error = 0;
- error = xfs_buf_submit_wait(bp);
- if (error && !XFS_FORCED_SHUTDOWN(log->l_mp))
- xfs_buf_ioerror_alert(bp, __func__);
- return error;
- }
- STATIC int
- xlog_bread(
- struct xlog *log,
- xfs_daddr_t blk_no,
- int nbblks,
- struct xfs_buf *bp,
- char **offset)
- {
- int error;
- error = xlog_bread_noalign(log, blk_no, nbblks, bp);
- if (error)
- return error;
- *offset = xlog_align(log, blk_no, nbblks, bp);
- return 0;
- }
- /*
- * Read at an offset into the buffer. Returns with the buffer in it's original
- * state regardless of the result of the read.
- */
- STATIC int
- xlog_bread_offset(
- struct xlog *log,
- xfs_daddr_t blk_no, /* block to read from */
- int nbblks, /* blocks to read */
- struct xfs_buf *bp,
- char *offset)
- {
- char *orig_offset = bp->b_addr;
- int orig_len = BBTOB(bp->b_length);
- int error, error2;
- error = xfs_buf_associate_memory(bp, offset, BBTOB(nbblks));
- if (error)
- return error;
- error = xlog_bread_noalign(log, blk_no, nbblks, bp);
- /* must reset buffer pointer even on error */
- error2 = xfs_buf_associate_memory(bp, orig_offset, orig_len);
- if (error)
- return error;
- return error2;
- }
- /*
- * Write out the buffer at the given block for the given number of blocks.
- * The buffer is kept locked across the write and is returned locked.
- * This can only be used for synchronous log writes.
- */
- STATIC int
- xlog_bwrite(
- struct xlog *log,
- xfs_daddr_t blk_no,
- int nbblks,
- struct xfs_buf *bp)
- {
- int error;
- if (!xlog_verify_bp(log, blk_no, nbblks)) {
- xfs_warn(log->l_mp,
- "Invalid log block/length (0x%llx, 0x%x) for buffer",
- blk_no, nbblks);
- XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
- return -EFSCORRUPTED;
- }
- blk_no = round_down(blk_no, log->l_sectBBsize);
- nbblks = round_up(nbblks, log->l_sectBBsize);
- ASSERT(nbblks > 0);
- ASSERT(nbblks <= bp->b_length);
- XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
- xfs_buf_hold(bp);
- xfs_buf_lock(bp);
- bp->b_io_length = nbblks;
- bp->b_error = 0;
- error = xfs_bwrite(bp);
- if (error)
- xfs_buf_ioerror_alert(bp, __func__);
- xfs_buf_relse(bp);
- return error;
- }
- #ifdef DEBUG
- /*
- * dump debug superblock and log record information
- */
- STATIC void
- xlog_header_check_dump(
- xfs_mount_t *mp,
- xlog_rec_header_t *head)
- {
- xfs_debug(mp, "%s: SB : uuid = %pU, fmt = %d",
- __func__, &mp->m_sb.sb_uuid, XLOG_FMT);
- xfs_debug(mp, " log : uuid = %pU, fmt = %d",
- &head->h_fs_uuid, be32_to_cpu(head->h_fmt));
- }
- #else
- #define xlog_header_check_dump(mp, head)
- #endif
- /*
- * check log record header for recovery
- */
- STATIC int
- xlog_header_check_recover(
- xfs_mount_t *mp,
- xlog_rec_header_t *head)
- {
- ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
- /*
- * IRIX doesn't write the h_fmt field and leaves it zeroed
- * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
- * a dirty log created in IRIX.
- */
- if (unlikely(head->h_fmt != cpu_to_be32(XLOG_FMT))) {
- xfs_warn(mp,
- "dirty log written in incompatible format - can't recover");
- xlog_header_check_dump(mp, head);
- XFS_ERROR_REPORT("xlog_header_check_recover(1)",
- XFS_ERRLEVEL_HIGH, mp);
- return -EFSCORRUPTED;
- } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
- xfs_warn(mp,
- "dirty log entry has mismatched uuid - can't recover");
- xlog_header_check_dump(mp, head);
- XFS_ERROR_REPORT("xlog_header_check_recover(2)",
- XFS_ERRLEVEL_HIGH, mp);
- return -EFSCORRUPTED;
- }
- return 0;
- }
- /*
- * read the head block of the log and check the header
- */
- STATIC int
- xlog_header_check_mount(
- xfs_mount_t *mp,
- xlog_rec_header_t *head)
- {
- ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
- if (uuid_is_null(&head->h_fs_uuid)) {
- /*
- * IRIX doesn't write the h_fs_uuid or h_fmt fields. If
- * h_fs_uuid is null, we assume this log was last mounted
- * by IRIX and continue.
- */
- xfs_warn(mp, "null uuid in log - IRIX style log");
- } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
- xfs_warn(mp, "log has mismatched uuid - can't recover");
- xlog_header_check_dump(mp, head);
- XFS_ERROR_REPORT("xlog_header_check_mount",
- XFS_ERRLEVEL_HIGH, mp);
- return -EFSCORRUPTED;
- }
- return 0;
- }
- STATIC void
- xlog_recover_iodone(
- struct xfs_buf *bp)
- {
- if (bp->b_error) {
- /*
- * We're not going to bother about retrying
- * this during recovery. One strike!
- */
- if (!XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
- xfs_buf_ioerror_alert(bp, __func__);
- xfs_force_shutdown(bp->b_target->bt_mount,
- SHUTDOWN_META_IO_ERROR);
- }
- }
- /*
- * On v5 supers, a bli could be attached to update the metadata LSN.
- * Clean it up.
- */
- if (bp->b_fspriv)
- xfs_buf_item_relse(bp);
- ASSERT(bp->b_fspriv == NULL);
- bp->b_iodone = NULL;
- xfs_buf_ioend(bp);
- }
- /*
- * This routine finds (to an approximation) the first block in the physical
- * log which contains the given cycle. It uses a binary search algorithm.
- * Note that the algorithm can not be perfect because the disk will not
- * necessarily be perfect.
- */
- STATIC int
- xlog_find_cycle_start(
- struct xlog *log,
- struct xfs_buf *bp,
- xfs_daddr_t first_blk,
- xfs_daddr_t *last_blk,
- uint cycle)
- {
- char *offset;
- xfs_daddr_t mid_blk;
- xfs_daddr_t end_blk;
- uint mid_cycle;
- int error;
- end_blk = *last_blk;
- mid_blk = BLK_AVG(first_blk, end_blk);
- while (mid_blk != first_blk && mid_blk != end_blk) {
- error = xlog_bread(log, mid_blk, 1, bp, &offset);
- if (error)
- return error;
- mid_cycle = xlog_get_cycle(offset);
- if (mid_cycle == cycle)
- end_blk = mid_blk; /* last_half_cycle == mid_cycle */
- else
- first_blk = mid_blk; /* first_half_cycle == mid_cycle */
- mid_blk = BLK_AVG(first_blk, end_blk);
- }
- ASSERT((mid_blk == first_blk && mid_blk+1 == end_blk) ||
- (mid_blk == end_blk && mid_blk-1 == first_blk));
- *last_blk = end_blk;
- return 0;
- }
- /*
- * Check that a range of blocks does not contain stop_on_cycle_no.
- * Fill in *new_blk with the block offset where such a block is
- * found, or with -1 (an invalid block number) if there is no such
- * block in the range. The scan needs to occur from front to back
- * and the pointer into the region must be updated since a later
- * routine will need to perform another test.
- */
- STATIC int
- xlog_find_verify_cycle(
- struct xlog *log,
- xfs_daddr_t start_blk,
- int nbblks,
- uint stop_on_cycle_no,
- xfs_daddr_t *new_blk)
- {
- xfs_daddr_t i, j;
- uint cycle;
- xfs_buf_t *bp;
- xfs_daddr_t bufblks;
- char *buf = NULL;
- int error = 0;
- /*
- * Greedily allocate a buffer big enough to handle the full
- * range of basic blocks we'll be examining. If that fails,
- * try a smaller size. We need to be able to read at least
- * a log sector, or we're out of luck.
- */
- bufblks = 1 << ffs(nbblks);
- while (bufblks > log->l_logBBsize)
- bufblks >>= 1;
- while (!(bp = xlog_get_bp(log, bufblks))) {
- bufblks >>= 1;
- if (bufblks < log->l_sectBBsize)
- return -ENOMEM;
- }
- for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
- int bcount;
- bcount = min(bufblks, (start_blk + nbblks - i));
- error = xlog_bread(log, i, bcount, bp, &buf);
- if (error)
- goto out;
- for (j = 0; j < bcount; j++) {
- cycle = xlog_get_cycle(buf);
- if (cycle == stop_on_cycle_no) {
- *new_blk = i+j;
- goto out;
- }
- buf += BBSIZE;
- }
- }
- *new_blk = -1;
- out:
- xlog_put_bp(bp);
- return error;
- }
- /*
- * Potentially backup over partial log record write.
- *
- * In the typical case, last_blk is the number of the block directly after
- * a good log record. Therefore, we subtract one to get the block number
- * of the last block in the given buffer. extra_bblks contains the number
- * of blocks we would have read on a previous read. This happens when the
- * last log record is split over the end of the physical log.
- *
- * extra_bblks is the number of blocks potentially verified on a previous
- * call to this routine.
- */
- STATIC int
- xlog_find_verify_log_record(
- struct xlog *log,
- xfs_daddr_t start_blk,
- xfs_daddr_t *last_blk,
- int extra_bblks)
- {
- xfs_daddr_t i;
- xfs_buf_t *bp;
- char *offset = NULL;
- xlog_rec_header_t *head = NULL;
- int error = 0;
- int smallmem = 0;
- int num_blks = *last_blk - start_blk;
- int xhdrs;
- ASSERT(start_blk != 0 || *last_blk != start_blk);
- if (!(bp = xlog_get_bp(log, num_blks))) {
- if (!(bp = xlog_get_bp(log, 1)))
- return -ENOMEM;
- smallmem = 1;
- } else {
- error = xlog_bread(log, start_blk, num_blks, bp, &offset);
- if (error)
- goto out;
- offset += ((num_blks - 1) << BBSHIFT);
- }
- for (i = (*last_blk) - 1; i >= 0; i--) {
- if (i < start_blk) {
- /* valid log record not found */
- xfs_warn(log->l_mp,
- "Log inconsistent (didn't find previous header)");
- ASSERT(0);
- error = -EIO;
- goto out;
- }
- if (smallmem) {
- error = xlog_bread(log, i, 1, bp, &offset);
- if (error)
- goto out;
- }
- head = (xlog_rec_header_t *)offset;
- if (head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
- break;
- if (!smallmem)
- offset -= BBSIZE;
- }
- /*
- * We hit the beginning of the physical log & still no header. Return
- * to caller. If caller can handle a return of -1, then this routine
- * will be called again for the end of the physical log.
- */
- if (i == -1) {
- error = 1;
- goto out;
- }
- /*
- * We have the final block of the good log (the first block
- * of the log record _before_ the head. So we check the uuid.
- */
- if ((error = xlog_header_check_mount(log->l_mp, head)))
- goto out;
- /*
- * We may have found a log record header before we expected one.
- * last_blk will be the 1st block # with a given cycle #. We may end
- * up reading an entire log record. In this case, we don't want to
- * reset last_blk. Only when last_blk points in the middle of a log
- * record do we update last_blk.
- */
- if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
- uint h_size = be32_to_cpu(head->h_size);
- xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
- if (h_size % XLOG_HEADER_CYCLE_SIZE)
- xhdrs++;
- } else {
- xhdrs = 1;
- }
- if (*last_blk - i + extra_bblks !=
- BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
- *last_blk = i;
- out:
- xlog_put_bp(bp);
- return error;
- }
- /*
- * Head is defined to be the point of the log where the next log write
- * could go. This means that incomplete LR writes at the end are
- * eliminated when calculating the head. We aren't guaranteed that previous
- * LR have complete transactions. We only know that a cycle number of
- * current cycle number -1 won't be present in the log if we start writing
- * from our current block number.
- *
- * last_blk contains the block number of the first block with a given
- * cycle number.
- *
- * Return: zero if normal, non-zero if error.
- */
- STATIC int
- xlog_find_head(
- struct xlog *log,
- xfs_daddr_t *return_head_blk)
- {
- xfs_buf_t *bp;
- char *offset;
- xfs_daddr_t new_blk, first_blk, start_blk, last_blk, head_blk;
- int num_scan_bblks;
- uint first_half_cycle, last_half_cycle;
- uint stop_on_cycle;
- int error, log_bbnum = log->l_logBBsize;
- /* Is the end of the log device zeroed? */
- error = xlog_find_zeroed(log, &first_blk);
- if (error < 0) {
- xfs_warn(log->l_mp, "empty log check failed");
- return error;
- }
- if (error == 1) {
- *return_head_blk = first_blk;
- /* Is the whole lot zeroed? */
- if (!first_blk) {
- /* Linux XFS shouldn't generate totally zeroed logs -
- * mkfs etc write a dummy unmount record to a fresh
- * log so we can store the uuid in there
- */
- xfs_warn(log->l_mp, "totally zeroed log");
- }
- return 0;
- }
- first_blk = 0; /* get cycle # of 1st block */
- bp = xlog_get_bp(log, 1);
- if (!bp)
- return -ENOMEM;
- error = xlog_bread(log, 0, 1, bp, &offset);
- if (error)
- goto bp_err;
- first_half_cycle = xlog_get_cycle(offset);
- last_blk = head_blk = log_bbnum - 1; /* get cycle # of last block */
- error = xlog_bread(log, last_blk, 1, bp, &offset);
- if (error)
- goto bp_err;
- last_half_cycle = xlog_get_cycle(offset);
- ASSERT(last_half_cycle != 0);
- /*
- * If the 1st half cycle number is equal to the last half cycle number,
- * then the entire log is stamped with the same cycle number. In this
- * case, head_blk can't be set to zero (which makes sense). The below
- * math doesn't work out properly with head_blk equal to zero. Instead,
- * we set it to log_bbnum which is an invalid block number, but this
- * value makes the math correct. If head_blk doesn't changed through
- * all the tests below, *head_blk is set to zero at the very end rather
- * than log_bbnum. In a sense, log_bbnum and zero are the same block
- * in a circular file.
- */
- if (first_half_cycle == last_half_cycle) {
- /*
- * In this case we believe that the entire log should have
- * cycle number last_half_cycle. We need to scan backwards
- * from the end verifying that there are no holes still
- * containing last_half_cycle - 1. If we find such a hole,
- * then the start of that hole will be the new head. The
- * simple case looks like
- * x | x ... | x - 1 | x
- * Another case that fits this picture would be
- * x | x + 1 | x ... | x
- * In this case the head really is somewhere at the end of the
- * log, as one of the latest writes at the beginning was
- * incomplete.
- * One more case is
- * x | x + 1 | x ... | x - 1 | x
- * This is really the combination of the above two cases, and
- * the head has to end up at the start of the x-1 hole at the
- * end of the log.
- *
- * In the 256k log case, we will read from the beginning to the
- * end of the log and search for cycle numbers equal to x-1.
- * We don't worry about the x+1 blocks that we encounter,
- * because we know that they cannot be the head since the log
- * started with x.
- */
- head_blk = log_bbnum;
- stop_on_cycle = last_half_cycle - 1;
- } else {
- /*
- * In this case we want to find the first block with cycle
- * number matching last_half_cycle. We expect the log to be
- * some variation on
- * x + 1 ... | x ... | x
- * The first block with cycle number x (last_half_cycle) will
- * be where the new head belongs. First we do a binary search
- * for the first occurrence of last_half_cycle. The binary
- * search may not be totally accurate, so then we scan back
- * from there looking for occurrences of last_half_cycle before
- * us. If that backwards scan wraps around the beginning of
- * the log, then we look for occurrences of last_half_cycle - 1
- * at the end of the log. The cases we're looking for look
- * like
- * v binary search stopped here
- * x + 1 ... | x | x + 1 | x ... | x
- * ^ but we want to locate this spot
- * or
- * <---------> less than scan distance
- * x + 1 ... | x ... | x - 1 | x
- * ^ we want to locate this spot
- */
- stop_on_cycle = last_half_cycle;
- if ((error = xlog_find_cycle_start(log, bp, first_blk,
- &head_blk, last_half_cycle)))
- goto bp_err;
- }
- /*
- * Now validate the answer. Scan back some number of maximum possible
- * blocks and make sure each one has the expected cycle number. The
- * maximum is determined by the total possible amount of buffering
- * in the in-core log. The following number can be made tighter if
- * we actually look at the block size of the filesystem.
- */
- num_scan_bblks = min_t(int, log_bbnum, XLOG_TOTAL_REC_SHIFT(log));
- if (head_blk >= num_scan_bblks) {
- /*
- * We are guaranteed that the entire check can be performed
- * in one buffer.
- */
- start_blk = head_blk - num_scan_bblks;
- if ((error = xlog_find_verify_cycle(log,
- start_blk, num_scan_bblks,
- stop_on_cycle, &new_blk)))
- goto bp_err;
- if (new_blk != -1)
- head_blk = new_blk;
- } else { /* need to read 2 parts of log */
- /*
- * We are going to scan backwards in the log in two parts.
- * First we scan the physical end of the log. In this part
- * of the log, we are looking for blocks with cycle number
- * last_half_cycle - 1.
- * If we find one, then we know that the log starts there, as
- * we've found a hole that didn't get written in going around
- * the end of the physical log. The simple case for this is
- * x + 1 ... | x ... | x - 1 | x
- * <---------> less than scan distance
- * If all of the blocks at the end of the log have cycle number
- * last_half_cycle, then we check the blocks at the start of
- * the log looking for occurrences of last_half_cycle. If we
- * find one, then our current estimate for the location of the
- * first occurrence of last_half_cycle is wrong and we move
- * back to the hole we've found. This case looks like
- * x + 1 ... | x | x + 1 | x ...
- * ^ binary search stopped here
- * Another case we need to handle that only occurs in 256k
- * logs is
- * x + 1 ... | x ... | x+1 | x ...
- * ^ binary search stops here
- * In a 256k log, the scan at the end of the log will see the
- * x + 1 blocks. We need to skip past those since that is
- * certainly not the head of the log. By searching for
- * last_half_cycle-1 we accomplish that.
- */
- ASSERT(head_blk <= INT_MAX &&
- (xfs_daddr_t) num_scan_bblks >= head_blk);
- start_blk = log_bbnum - (num_scan_bblks - head_blk);
- if ((error = xlog_find_verify_cycle(log, start_blk,
- num_scan_bblks - (int)head_blk,
- (stop_on_cycle - 1), &new_blk)))
- goto bp_err;
- if (new_blk != -1) {
- head_blk = new_blk;
- goto validate_head;
- }
- /*
- * Scan beginning of log now. The last part of the physical
- * log is good. This scan needs to verify that it doesn't find
- * the last_half_cycle.
- */
- start_blk = 0;
- ASSERT(head_blk <= INT_MAX);
- if ((error = xlog_find_verify_cycle(log,
- start_blk, (int)head_blk,
- stop_on_cycle, &new_blk)))
- goto bp_err;
- if (new_blk != -1)
- head_blk = new_blk;
- }
- validate_head:
- /*
- * Now we need to make sure head_blk is not pointing to a block in
- * the middle of a log record.
- */
- num_scan_bblks = XLOG_REC_SHIFT(log);
- if (head_blk >= num_scan_bblks) {
- start_blk = head_blk - num_scan_bblks; /* don't read head_blk */
- /* start ptr at last block ptr before head_blk */
- error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0);
- if (error == 1)
- error = -EIO;
- if (error)
- goto bp_err;
- } else {
- start_blk = 0;
- ASSERT(head_blk <= INT_MAX);
- error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0);
- if (error < 0)
- goto bp_err;
- if (error == 1) {
- /* We hit the beginning of the log during our search */
- start_blk = log_bbnum - (num_scan_bblks - head_blk);
- new_blk = log_bbnum;
- ASSERT(start_blk <= INT_MAX &&
- (xfs_daddr_t) log_bbnum-start_blk >= 0);
- ASSERT(head_blk <= INT_MAX);
- error = xlog_find_verify_log_record(log, start_blk,
- &new_blk, (int)head_blk);
- if (error == 1)
- error = -EIO;
- if (error)
- goto bp_err;
- if (new_blk != log_bbnum)
- head_blk = new_blk;
- } else if (error)
- goto bp_err;
- }
- xlog_put_bp(bp);
- if (head_blk == log_bbnum)
- *return_head_blk = 0;
- else
- *return_head_blk = head_blk;
- /*
- * When returning here, we have a good block number. Bad block
- * means that during a previous crash, we didn't have a clean break
- * from cycle number N to cycle number N-1. In this case, we need
- * to find the first block with cycle number N-1.
- */
- return 0;
- bp_err:
- xlog_put_bp(bp);
- if (error)
- xfs_warn(log->l_mp, "failed to find log head");
- return error;
- }
- /*
- * Seek backwards in the log for log record headers.
- *
- * Given a starting log block, walk backwards until we find the provided number
- * of records or hit the provided tail block. The return value is the number of
- * records encountered or a negative error code. The log block and buffer
- * pointer of the last record seen are returned in rblk and rhead respectively.
- */
- STATIC int
- xlog_rseek_logrec_hdr(
- struct xlog *log,
- xfs_daddr_t head_blk,
- xfs_daddr_t tail_blk,
- int count,
- struct xfs_buf *bp,
- xfs_daddr_t *rblk,
- struct xlog_rec_header **rhead,
- bool *wrapped)
- {
- int i;
- int error;
- int found = 0;
- char *offset = NULL;
- xfs_daddr_t end_blk;
- *wrapped = false;
- /*
- * Walk backwards from the head block until we hit the tail or the first
- * block in the log.
- */
- end_blk = head_blk > tail_blk ? tail_blk : 0;
- for (i = (int) head_blk - 1; i >= end_blk; i--) {
- error = xlog_bread(log, i, 1, bp, &offset);
- if (error)
- goto out_error;
- if (*(__be32 *) offset == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
- *rblk = i;
- *rhead = (struct xlog_rec_header *) offset;
- if (++found == count)
- break;
- }
- }
- /*
- * If we haven't hit the tail block or the log record header count,
- * start looking again from the end of the physical log. Note that
- * callers can pass head == tail if the tail is not yet known.
- */
- if (tail_blk >= head_blk && found != count) {
- for (i = log->l_logBBsize - 1; i >= (int) tail_blk; i--) {
- error = xlog_bread(log, i, 1, bp, &offset);
- if (error)
- goto out_error;
- if (*(__be32 *)offset ==
- cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
- *wrapped = true;
- *rblk = i;
- *rhead = (struct xlog_rec_header *) offset;
- if (++found == count)
- break;
- }
- }
- }
- return found;
- out_error:
- return error;
- }
- /*
- * Seek forward in the log for log record headers.
- *
- * Given head and tail blocks, walk forward from the tail block until we find
- * the provided number of records or hit the head block. The return value is the
- * number of records encountered or a negative error code. The log block and
- * buffer pointer of the last record seen are returned in rblk and rhead
- * respectively.
- */
- STATIC int
- xlog_seek_logrec_hdr(
- struct xlog *log,
- xfs_daddr_t head_blk,
- xfs_daddr_t tail_blk,
- int count,
- struct xfs_buf *bp,
- xfs_daddr_t *rblk,
- struct xlog_rec_header **rhead,
- bool *wrapped)
- {
- int i;
- int error;
- int found = 0;
- char *offset = NULL;
- xfs_daddr_t end_blk;
- *wrapped = false;
- /*
- * Walk forward from the tail block until we hit the head or the last
- * block in the log.
- */
- end_blk = head_blk > tail_blk ? head_blk : log->l_logBBsize - 1;
- for (i = (int) tail_blk; i <= end_blk; i++) {
- error = xlog_bread(log, i, 1, bp, &offset);
- if (error)
- goto out_error;
- if (*(__be32 *) offset == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
- *rblk = i;
- *rhead = (struct xlog_rec_header *) offset;
- if (++found == count)
- break;
- }
- }
- /*
- * If we haven't hit the head block or the log record header count,
- * start looking again from the start of the physical log.
- */
- if (tail_blk > head_blk && found != count) {
- for (i = 0; i < (int) head_blk; i++) {
- error = xlog_bread(log, i, 1, bp, &offset);
- if (error)
- goto out_error;
- if (*(__be32 *)offset ==
- cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
- *wrapped = true;
- *rblk = i;
- *rhead = (struct xlog_rec_header *) offset;
- if (++found == count)
- break;
- }
- }
- }
- return found;
- out_error:
- return error;
- }
- /*
- * Calculate distance from head to tail (i.e., unused space in the log).
- */
- static inline int
- xlog_tail_distance(
- struct xlog *log,
- xfs_daddr_t head_blk,
- xfs_daddr_t tail_blk)
- {
- if (head_blk < tail_blk)
- return tail_blk - head_blk;
- return tail_blk + (log->l_logBBsize - head_blk);
- }
- /*
- * Verify the log tail. This is particularly important when torn or incomplete
- * writes have been detected near the front of the log and the head has been
- * walked back accordingly.
- *
- * We also have to handle the case where the tail was pinned and the head
- * blocked behind the tail right before a crash. If the tail had been pushed
- * immediately prior to the crash and the subsequent checkpoint was only
- * partially written, it's possible it overwrote the last referenced tail in the
- * log with garbage. This is not a coherency problem because the tail must have
- * been pushed before it can be overwritten, but appears as log corruption to
- * recovery because we have no way to know the tail was updated if the
- * subsequent checkpoint didn't write successfully.
- *
- * Therefore, CRC check the log from tail to head. If a failure occurs and the
- * offending record is within max iclog bufs from the head, walk the tail
- * forward and retry until a valid tail is found or corruption is detected out
- * of the range of a possible overwrite.
- */
- STATIC int
- xlog_verify_tail(
- struct xlog *log,
- xfs_daddr_t head_blk,
- xfs_daddr_t *tail_blk,
- int hsize)
- {
- struct xlog_rec_header *thead;
- struct xfs_buf *bp;
- xfs_daddr_t first_bad;
- int error = 0;
- bool wrapped;
- xfs_daddr_t tmp_tail;
- xfs_daddr_t orig_tail = *tail_blk;
- bp = xlog_get_bp(log, 1);
- if (!bp)
- return -ENOMEM;
- /*
- * Make sure the tail points to a record (returns positive count on
- * success).
- */
- error = xlog_seek_logrec_hdr(log, head_blk, *tail_blk, 1, bp,
- &tmp_tail, &thead, &wrapped);
- if (error < 0)
- goto out;
- if (*tail_blk != tmp_tail)
- *tail_blk = tmp_tail;
- /*
- * Run a CRC check from the tail to the head. We can't just check
- * MAX_ICLOGS records past the tail because the tail may point to stale
- * blocks cleared during the search for the head/tail. These blocks are
- * overwritten with zero-length records and thus record count is not a
- * reliable indicator of the iclog state before a crash.
- */
- first_bad = 0;
- error = xlog_do_recovery_pass(log, head_blk, *tail_blk,
- XLOG_RECOVER_CRCPASS, &first_bad);
- while ((error == -EFSBADCRC || error == -EFSCORRUPTED) && first_bad) {
- int tail_distance;
- /*
- * Is corruption within range of the head? If so, retry from
- * the next record. Otherwise return an error.
- */
- tail_distance = xlog_tail_distance(log, head_blk, first_bad);
- if (tail_distance > BTOBB(XLOG_MAX_ICLOGS * hsize))
- break;
- /* skip to the next record; returns positive count on success */
- error = xlog_seek_logrec_hdr(log, head_blk, first_bad, 2, bp,
- &tmp_tail, &thead, &wrapped);
- if (error < 0)
- goto out;
- *tail_blk = tmp_tail;
- first_bad = 0;
- error = xlog_do_recovery_pass(log, head_blk, *tail_blk,
- XLOG_RECOVER_CRCPASS, &first_bad);
- }
- if (!error && *tail_blk != orig_tail)
- xfs_warn(log->l_mp,
- "Tail block (0x%llx) overwrite detected. Updated to 0x%llx",
- orig_tail, *tail_blk);
- out:
- xlog_put_bp(bp);
- return error;
- }
- /*
- * Detect and trim torn writes from the head of the log.
- *
- * Storage without sector atomicity guarantees can result in torn writes in the
- * log in the event of a crash. Our only means to detect this scenario is via
- * CRC verification. While we can't always be certain that CRC verification
- * failure is due to a torn write vs. an unrelated corruption, we do know that
- * only a certain number (XLOG_MAX_ICLOGS) of log records can be written out at
- * one time. Therefore, CRC verify up to XLOG_MAX_ICLOGS records at the head of
- * the log and treat failures in this range as torn writes as a matter of
- * policy. In the event of CRC failure, the head is walked back to the last good
- * record in the log and the tail is updated from that record and verified.
- */
- STATIC int
- xlog_verify_head(
- struct xlog *log,
- xfs_daddr_t *head_blk, /* in/out: unverified head */
- xfs_daddr_t *tail_blk, /* out: tail block */
- struct xfs_buf *bp,
- xfs_daddr_t *rhead_blk, /* start blk of last record */
- struct xlog_rec_header **rhead, /* ptr to last record */
- bool *wrapped) /* last rec. wraps phys. log */
- {
- struct xlog_rec_header *tmp_rhead;
- struct xfs_buf *tmp_bp;
- xfs_daddr_t first_bad;
- xfs_daddr_t tmp_rhead_blk;
- int found;
- int error;
- bool tmp_wrapped;
- /*
- * Check the head of the log for torn writes. Search backwards from the
- * head until we hit the tail or the maximum number of log record I/Os
- * that could have been in flight at one time. Use a temporary buffer so
- * we don't trash the rhead/bp pointers from the caller.
- */
- tmp_bp = xlog_get_bp(log, 1);
- if (!tmp_bp)
- return -ENOMEM;
- error = xlog_rseek_logrec_hdr(log, *head_blk, *tail_blk,
- XLOG_MAX_ICLOGS, tmp_bp, &tmp_rhead_blk,
- &tmp_rhead, &tmp_wrapped);
- xlog_put_bp(tmp_bp);
- if (error < 0)
- return error;
- /*
- * Now run a CRC verification pass over the records starting at the
- * block found above to the current head. If a CRC failure occurs, the
- * log block of the first bad record is saved in first_bad.
- */
- error = xlog_do_recovery_pass(log, *head_blk, tmp_rhead_blk,
- XLOG_RECOVER_CRCPASS, &first_bad);
- if ((error == -EFSBADCRC || error == -EFSCORRUPTED) && first_bad) {
- /*
- * We've hit a potential torn write. Reset the error and warn
- * about it.
- */
- error = 0;
- xfs_warn(log->l_mp,
- "Torn write (CRC failure) detected at log block 0x%llx. Truncating head block from 0x%llx.",
- first_bad, *head_blk);
- /*
- * Get the header block and buffer pointer for the last good
- * record before the bad record.
- *
- * Note that xlog_find_tail() clears the blocks at the new head
- * (i.e., the records with invalid CRC) if the cycle number
- * matches the the current cycle.
- */
- found = xlog_rseek_logrec_hdr(log, first_bad, *tail_blk, 1, bp,
- rhead_blk, rhead, wrapped);
- if (found < 0)
- return found;
- if (found == 0) /* XXX: right thing to do here? */
- return -EIO;
- /*
- * Reset the head block to the starting block of the first bad
- * log record and set the tail block based on the last good
- * record.
- *
- * Bail out if the updated head/tail match as this indicates
- * possible corruption outside of the acceptable
- * (XLOG_MAX_ICLOGS) range. This is a job for xfs_repair...
- */
- *head_blk = first_bad;
- *tail_blk = BLOCK_LSN(be64_to_cpu((*rhead)->h_tail_lsn));
- if (*head_blk == *tail_blk) {
- ASSERT(0);
- return 0;
- }
- }
- if (error)
- return error;
- return xlog_verify_tail(log, *head_blk, tail_blk,
- be32_to_cpu((*rhead)->h_size));
- }
- /*
- * Check whether the head of the log points to an unmount record. In other
- * words, determine whether the log is clean. If so, update the in-core state
- * appropriately.
- */
- static int
- xlog_check_unmount_rec(
- struct xlog *log,
- xfs_daddr_t *head_blk,
- xfs_daddr_t *tail_blk,
- struct xlog_rec_header *rhead,
- xfs_daddr_t rhead_blk,
- struct xfs_buf *bp,
- bool *clean)
- {
- struct xlog_op_header *op_head;
- xfs_daddr_t umount_data_blk;
- xfs_daddr_t after_umount_blk;
- int hblks;
- int error;
- char *offset;
- *clean = false;
- /*
- * Look for unmount record. If we find it, then we know there was a
- * clean unmount. Since 'i' could be the last block in the physical
- * log, we convert to a log block before comparing to the head_blk.
- *
- * Save the current tail lsn to use to pass to xlog_clear_stale_blocks()
- * below. We won't want to clear the unmount record if there is one, so
- * we pass the lsn of the unmount record rather than the block after it.
- */
- if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
- int h_size = be32_to_cpu(rhead->h_size);
- int h_version = be32_to_cpu(rhead->h_version);
- if ((h_version & XLOG_VERSION_2) &&
- (h_size > XLOG_HEADER_CYCLE_SIZE)) {
- hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
- if (h_size % XLOG_HEADER_CYCLE_SIZE)
- hblks++;
- } else {
- hblks = 1;
- }
- } else {
- hblks = 1;
- }
- after_umount_blk = rhead_blk + hblks + BTOBB(be32_to_cpu(rhead->h_len));
- after_umount_blk = do_mod(after_umount_blk, log->l_logBBsize);
- if (*head_blk == after_umount_blk &&
- be32_to_cpu(rhead->h_num_logops) == 1) {
- umount_data_blk = rhead_blk + hblks;
- umount_data_blk = do_mod(umount_data_blk, log->l_logBBsize);
- error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
- if (error)
- return error;
- op_head = (struct xlog_op_header *)offset;
- if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
- /*
- * Set tail and last sync so that newly written log
- * records will point recovery to after the current
- * unmount record.
- */
- xlog_assign_atomic_lsn(&log->l_tail_lsn,
- log->l_curr_cycle, after_umount_blk);
- xlog_assign_atomic_lsn(&log->l_last_sync_lsn,
- log->l_curr_cycle, after_umount_blk);
- *tail_blk = after_umount_blk;
- *clean = true;
- }
- }
- return 0;
- }
- static void
- xlog_set_state(
- struct xlog *log,
- xfs_daddr_t head_blk,
- struct xlog_rec_header *rhead,
- xfs_daddr_t rhead_blk,
- bool bump_cycle)
- {
- /*
- * Reset log values according to the state of the log when we
- * crashed. In the case where head_blk == 0, we bump curr_cycle
- * one because the next write starts a new cycle rather than
- * continuing the cycle of the last good log record. At this
- * point we have guaranteed that all partial log records have been
- * accounted for. Therefore, we know that the last good log record
- * written was complete and ended exactly on the end boundary
- * of the physical log.
- */
- log->l_prev_block = rhead_blk;
- log->l_curr_block = (int)head_blk;
- log->l_curr_cycle = be32_to_cpu(rhead->h_cycle);
- if (bump_cycle)
- log->l_curr_cycle++;
- atomic64_set(&log->l_tail_lsn, be64_to_cpu(rhead->h_tail_lsn));
- atomic64_set(&log->l_last_sync_lsn, be64_to_cpu(rhead->h_lsn));
- xlog_assign_grant_head(&log->l_reserve_head.grant, log->l_curr_cycle,
- BBTOB(log->l_curr_block));
- xlog_assign_grant_head(&log->l_write_head.grant, log->l_curr_cycle,
- BBTOB(log->l_curr_block));
- }
- /*
- * Find the sync block number or the tail of the log.
- *
- * This will be the block number of the last record to have its
- * associated buffers synced to disk. Every log record header has
- * a sync lsn embedded in it. LSNs hold block numbers, so it is easy
- * to get a sync block number. The only concern is to figure out which
- * log record header to believe.
- *
- * The following algorithm uses the log record header with the largest
- * lsn. The entire log record does not need to be valid. We only care
- * that the header is valid.
- *
- * We could speed up search by using current head_blk buffer, but it is not
- * available.
- */
- STATIC int
- xlog_find_tail(
- struct xlog *log,
- xfs_daddr_t *head_blk,
- xfs_daddr_t *tail_blk)
- {
- xlog_rec_header_t *rhead;
- char *offset = NULL;
- xfs_buf_t *bp;
- int error;
- xfs_daddr_t rhead_blk;
- xfs_lsn_t tail_lsn;
- bool wrapped = false;
- bool clean = false;
- /*
- * Find previous log record
- */
- if ((error = xlog_find_head(log, head_blk)))
- return error;
- ASSERT(*head_blk < INT_MAX);
- bp = xlog_get_bp(log, 1);
- if (!bp)
- return -ENOMEM;
- if (*head_blk == 0) { /* special case */
- error = xlog_bread(log, 0, 1, bp, &offset);
- if (error)
- goto done;
- if (xlog_get_cycle(offset) == 0) {
- *tail_blk = 0;
- /* leave all other log inited values alone */
- goto done;
- }
- }
- /*
- * Search backwards through the log looking for the log record header
- * block. This wraps all the way back around to the head so something is
- * seriously wrong if we can't find it.
- */
- error = xlog_rseek_logrec_hdr(log, *head_blk, *head_blk, 1, bp,
- &rhead_blk, &rhead, &wrapped);
- if (error < 0)
- return error;
- if (!error) {
- xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__);
- return -EIO;
- }
- *tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn));
- /*
- * Set the log state based on the current head record.
- */
- xlog_set_state(log, *head_blk, rhead, rhead_blk, wrapped);
- tail_lsn = atomic64_read(&log->l_tail_lsn);
- /*
- * Look for an unmount record at the head of the log. This sets the log
- * state to determine whether recovery is necessary.
- */
- error = xlog_check_unmount_rec(log, head_blk, tail_blk, rhead,
- rhead_blk, bp, &clean);
- if (error)
- goto done;
- /*
- * Verify the log head if the log is not clean (e.g., we have anything
- * but an unmount record at the head). This uses CRC verification to
- * detect and trim torn writes. If discovered, CRC failures are
- * considered torn writes and the log head is trimmed accordingly.
- *
- * Note that we can only run CRC verification when the log is dirty
- * because there's no guarantee that the log data behind an unmount
- * record is compatible with the current architecture.
- */
- if (!clean) {
- xfs_daddr_t orig_head = *head_blk;
- error = xlog_verify_head(log, head_blk, tail_blk, bp,
- &rhead_blk, &rhead, &wrapped);
- if (error)
- goto done;
- /* update in-core state again if the head changed */
- if (*head_blk != orig_head) {
- xlog_set_state(log, *head_blk, rhead, rhead_blk,
- wrapped);
- tail_lsn = atomic64_read(&log->l_tail_lsn);
- error = xlog_check_unmount_rec(log, head_blk, tail_blk,
- rhead, rhead_blk, bp,
- &clean);
- if (error)
- goto done;
- }
- }
- /*
- * Note that the unmount was clean. If the unmount was not clean, we
- * need to know this to rebuild the superblock counters from the perag
- * headers if we have a filesystem using non-persistent counters.
- */
- if (clean)
- log->l_mp->m_flags |= XFS_MOUNT_WAS_CLEAN;
- /*
- * Make sure that there are no blocks in front of the head
- * with the same cycle number as the head. This can happen
- * because we allow multiple outstanding log writes concurrently,
- * and the later writes might make it out before earlier ones.
- *
- * We use the lsn from before modifying it so that we'll never
- * overwrite the unmount record after a clean unmount.
- *
- * Do this only if we are going to recover the filesystem
- *
- * NOTE: This used to say "if (!readonly)"
- * However on Linux, we can & do recover a read-only filesystem.
- * We only skip recovery if NORECOVERY is specified on mount,
- * in which case we would not be here.
- *
- * But... if the -device- itself is readonly, just skip this.
- * We can't recover this device anyway, so it won't matter.
- */
- if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp))
- error = xlog_clear_stale_blocks(log, tail_lsn);
- done:
- xlog_put_bp(bp);
- if (error)
- xfs_warn(log->l_mp, "failed to locate log tail");
- return error;
- }
- /*
- * Is the log zeroed at all?
- *
- * The last binary search should be changed to perform an X block read
- * once X becomes small enough. You can then search linearly through
- * the X blocks. This will cut down on the number of reads we need to do.
- *
- * If the log is partially zeroed, this routine will pass back the blkno
- * of the first block with cycle number 0. It won't have a complete LR
- * preceding it.
- *
- * Return:
- * 0 => the log is completely written to
- * 1 => use *blk_no as the first block of the log
- * <0 => error has occurred
- */
- STATIC int
- xlog_find_zeroed(
- struct xlog *log,
- xfs_daddr_t *blk_no)
- {
- xfs_buf_t *bp;
- char *offset;
- uint first_cycle, last_cycle;
- xfs_daddr_t new_blk, last_blk, start_blk;
- xfs_daddr_t num_scan_bblks;
- int error, log_bbnum = log->l_logBBsize;
- *blk_no = 0;
- /* check totally zeroed log */
- bp = xlog_get_bp(log, 1);
- if (!bp)
- return -ENOMEM;
- error = xlog_bread(log, 0, 1, bp, &offset);
- if (error)
- goto bp_err;
- first_cycle = xlog_get_cycle(offset);
- if (first_cycle == 0) { /* completely zeroed log */
- *blk_no = 0;
- xlog_put_bp(bp);
- return 1;
- }
- /* check partially zeroed log */
- error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
- if (error)
- goto bp_err;
- last_cycle = xlog_get_cycle(offset);
- if (last_cycle != 0) { /* log completely written to */
- xlog_put_bp(bp);
- return 0;
- } else if (first_cycle != 1) {
- /*
- * If the cycle of the last block is zero, the cycle of
- * the first block must be 1. If it's not, maybe we're
- * not looking at a log... Bail out.
- */
- xfs_warn(log->l_mp,
- "Log inconsistent or not a log (last==0, first!=1)");
- error = -EINVAL;
- goto bp_err;
- }
- /* we have a partially zeroed log */
- last_blk = log_bbnum-1;
- if ((error = xlog_find_cycle_start(log, bp, 0, &last_blk, 0)))
- goto bp_err;
- /*
- * Validate the answer. Because there is no way to guarantee that
- * the entire log is made up of log records which are the same size,
- * we scan over the defined maximum blocks. At this point, the maximum
- * is not chosen to mean anything special. XXXmiken
- */
- num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
- ASSERT(num_scan_bblks <= INT_MAX);
- if (last_blk < num_scan_bblks)
- num_scan_bblks = last_blk;
- start_blk = last_blk - num_scan_bblks;
- /*
- * We search for any instances of cycle number 0 that occur before
- * our current estimate of the head. What we're trying to detect is
- * 1 ... | 0 | 1 | 0...
- * ^ binary search ends here
- */
- if ((error = xlog_find_verify_cycle(log, start_blk,
- (int)num_scan_bblks, 0, &new_blk)))
- goto bp_err;
- if (new_blk != -1)
- last_blk = new_blk;
- /*
- * Potentially backup over partial log record write. We don't need
- * to search the end of the log because we know it is zero.
- */
- error = xlog_find_verify_log_record(log, start_blk, &last_blk, 0);
- if (error == 1)
- error = -EIO;
- if (error)
- goto bp_err;
- *blk_no = last_blk;
- bp_err:
- xlog_put_bp(bp);
- if (error)
- return error;
- return 1;
- }
- /*
- * These are simple subroutines used by xlog_clear_stale_blocks() below
- * to initialize a buffer full of empty log record headers and write
- * them into the log.
- */
- STATIC void
- xlog_add_record(
- struct xlog *log,
- char *buf,
- int cycle,
- int block,
- int tail_cycle,
- int tail_block)
- {
- xlog_rec_header_t *recp = (xlog_rec_header_t *)buf;
- memset(buf, 0, BBSIZE);
- recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
- recp->h_cycle = cpu_to_be32(cycle);
- recp->h_version = cpu_to_be32(
- xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
- recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block));
- recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block));
- recp->h_fmt = cpu_to_be32(XLOG_FMT);
- memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
- }
- STATIC int
- xlog_write_log_records(
- struct xlog *log,
- int cycle,
- int start_block,
- int blocks,
- int tail_cycle,
- int tail_block)
- {
- char *offset;
- xfs_buf_t *bp;
- int balign, ealign;
- int sectbb = log->l_sectBBsize;
- int end_block = start_block + blocks;
- int bufblks;
- int error = 0;
- int i, j = 0;
- /*
- * Greedily allocate a buffer big enough to handle the full
- * range of basic blocks to be written. If that fails, try
- * a smaller size. We need to be able to write at least a
- * log sector, or we're out of luck.
- */
- bufblks = 1 << ffs(blocks);
- while (bufblks > log->l_logBBsize)
- bufblks >>= 1;
- while (!(bp = xlog_get_bp(log, bufblks))) {
- bufblks >>= 1;
- if (bufblks < sectbb)
- return -ENOMEM;
- }
- /* We may need to do a read at the start to fill in part of
- * the buffer in the starting sector not covered by the first
- * write below.
- */
- balign = round_down(start_block, sectbb);
- if (balign != start_block) {
- error = xlog_bread_noalign(log, start_block, 1, bp);
- if (error)
- goto out_put_bp;
- j = start_block - balign;
- }
- for (i = start_block; i < end_block; i += bufblks) {
- int bcount, endcount;
- bcount = min(bufblks, end_block - start_block);
- endcount = bcount - j;
- /* We may need to do a read at the end to fill in part of
- * the buffer in the final sector not covered by the write.
- * If this is the same sector as the above read, skip it.
- */
- ealign = round_down(end_block, sectbb);
- if (j == 0 && (start_block + endcount > ealign)) {
- offset = bp->b_addr + BBTOB(ealign - start_block);
- error = xlog_bread_offset(log, ealign, sectbb,
- bp, offset);
- if (error)
- break;
- }
- offset = xlog_align(log, start_block, endcount, bp);
- for (; j < endcount; j++) {
- xlog_add_record(log, offset, cycle, i+j,
- tail_cycle, tail_block);
- offset += BBSIZE;
- }
- error = xlog_bwrite(log, start_block, endcount, bp);
- if (error)
- break;
- start_block += endcount;
- j = 0;
- }
- out_put_bp:
- xlog_put_bp(bp);
- return error;
- }
- /*
- * This routine is called to blow away any incomplete log writes out
- * in front of the log head. We do this so that we won't become confused
- * if we come up, write only a little bit more, and then crash again.
- * If we leave the partial log records out there, this situation could
- * cause us to think those partial writes are valid blocks since they
- * have the current cycle number. We get rid of them by overwriting them
- * with empty log records with the old cycle number rather than the
- * current one.
- *
- * The tail lsn is passed in rather than taken from
- * the log so that we will not write over the unmount record after a
- * clean unmount in a 512 block log. Doing so would leave the log without
- * any valid log records in it until a new one was written. If we crashed
- * during that time we would not be able to recover.
- */
- STATIC int
- xlog_clear_stale_blocks(
- struct xlog *log,
- xfs_lsn_t tail_lsn)
- {
- int tail_cycle, head_cycle;
- int tail_block, head_block;
- int …
Large files files are truncated, but you can click here to view the full file