2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2006-06-08 22:56:16 -06:00
|
|
|
* Copyright (c) 2000-2006 Silicon Graphics, Inc.
|
2005-11-01 20:58:39 -07:00
|
|
|
* All Rights Reserved.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
2005-04-16 16:20:36 -06:00
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* 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.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* 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
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_fs.h"
|
2013-10-22 17:36:05 -06:00
|
|
|
#include "xfs_shared.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_format.h"
|
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_bit.h"
|
|
|
|
#include "xfs_sb.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_mount.h"
|
2013-10-14 16:17:51 -06:00
|
|
|
#include "xfs_da_format.h"
|
2014-12-03 15:43:17 -07:00
|
|
|
#include "xfs_da_btree.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_inode.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_trans.h"
|
|
|
|
#include "xfs_log.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_log_priv.h"
|
|
|
|
#include "xfs_log_recover.h"
|
2013-10-22 17:51:50 -06:00
|
|
|
#include "xfs_inode_item.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_extfree_item.h"
|
|
|
|
#include "xfs_trans_priv.h"
|
2013-10-22 17:51:50 -06:00
|
|
|
#include "xfs_alloc.h"
|
|
|
|
#include "xfs_ialloc.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_quota.h"
|
xfs: add CRC checks to the log
Implement CRCs for the log buffers. We re-use a field in
struct xlog_rec_header that was used for a weak checksum of the
log buffer payload in debug builds before.
The new checksumming uses the crc32c checksum we will use elsewhere
in XFS, and also protects the record header and addition cycle data.
Due to this there are some interesting changes in xlog_sync, as we
need to do the cycle wrapping for the split buffer case much earlier,
as we would touch the buffer after generating the checksum otherwise.
The CRC calculation is always enabled, even for non-CRC filesystems,
as adding this CRC does not change the log format. On non-CRC
filesystems, only issue an alert if a CRC mismatch is found and
allow recovery to continue - this will act as an indicator that
log recovery problems are a result of log corruption. On CRC enabled
filesystems, however, log recovery will fail.
Note that existing debug kernels will write a simple checksum value
to the log, so the first time this is run on a filesystem taht was
last used on a debug kernel it will through CRC mismatch warning
errors. These can be ignored.
Initially based on a patch from Dave Chinner, then modified
significantly by Christoph Hellwig. Modified again by Dave Chinner
to get to this version.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 04:54:24 -07:00
|
|
|
#include "xfs_cksum.h"
|
2009-12-14 16:14:59 -07:00
|
|
|
#include "xfs_trace.h"
|
2012-10-08 04:56:11 -06:00
|
|
|
#include "xfs_icache.h"
|
2013-10-22 17:51:50 -06:00
|
|
|
#include "xfs_bmap_btree.h"
|
|
|
|
#include "xfs_error.h"
|
2013-08-12 04:49:37 -06:00
|
|
|
#include "xfs_dir2.h"
|
2016-08-02 20:09:48 -06:00
|
|
|
#include "xfs_rmap_item.h"
|
xfs: update metadata LSN in buffers during log recovery
Log recovery is currently broken for v5 superblocks in that it never
updates the metadata LSN of buffers written out during recovery. The
metadata LSN is recorded in various bits of metadata to provide recovery
ordering criteria that prevents transient corruption states reported by
buffer write verifiers. Without such ordering logic, buffer updates can
be replayed out of order and lead to false positive transient corruption
states. This is generally not a corruption vector on its own, but
corruption detection shuts down the filesystem and ultimately prevents a
mount if it occurs during log recovery. This requires an xfs_repair run
that clears the log and potentially loses filesystem updates.
This problem is avoided in most cases as metadata writes during normal
filesystem operation update the metadata LSN appropriately. The problem
with log recovery not updating metadata LSNs manifests if the system
happens to crash shortly after log recovery itself. In this scenario, it
is possible for log recovery to complete all metadata I/O such that the
filesystem is consistent. If a crash occurs after that point but before
the log tail is pushed forward by subsequent operations, however, the
next mount performs the same log recovery over again. If a buffer is
updated multiple times in the dirty range of the log, an earlier update
in the log might not be valid based on the current state of the
associated buffer after all of the updates in the log had been replayed
(before the previous crash). If a verifier happens to detect such a
problem, the filesystem claims corruption and immediately shuts down.
This commonly manifests in practice as directory block verifier failures
such as the following, likely due to directory verifiers being
particularly detailed in their checks as compared to most others:
...
Mounting V5 Filesystem
XFS (dm-0): Starting recovery (logdev: internal)
XFS (dm-0): Internal error XFS_WANT_CORRUPTED_RETURN at line ... of \
file fs/xfs/libxfs/xfs_dir2_data.c. Caller xfs_dir3_data_verify ...
...
Update log recovery to update the metadata LSN of recovered buffers.
Since metadata LSNs are already updated by write verifer functions via
attached log items, attach a dummy log item to the buffer during
validation and explicitly set the LSN of the current transaction. This
ensures that the metadata LSN of a buffer is updated based on whether
the recovery I/O actually completes, and if so, that subsequent recovery
attempts identify that the buffer is already up to date with respect to
the current transaction.
Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-09-25 16:34:27 -06:00
|
|
|
#include "xfs_buf_item.h"
|
2016-10-03 10:11:21 -06:00
|
|
|
#include "xfs_refcount_item.h"
|
2016-10-03 10:11:26 -06:00
|
|
|
#include "xfs_bmap_item.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-08-12 04:49:22 -06:00
|
|
|
#define BLK_AVG(blk1, blk2) ((blk1+blk2) >> 1)
|
|
|
|
|
2012-06-14 08:22:16 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_find_zeroed(
|
|
|
|
struct xlog *,
|
|
|
|
xfs_daddr_t *);
|
|
|
|
STATIC int
|
|
|
|
xlog_clear_stale_blocks(
|
|
|
|
struct xlog *,
|
|
|
|
xfs_lsn_t);
|
2005-04-16 16:20:36 -06:00
|
|
|
#if defined(DEBUG)
|
2012-06-14 08:22:16 -06:00
|
|
|
STATIC void
|
|
|
|
xlog_recover_check_summary(
|
|
|
|
struct xlog *);
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
|
|
|
#define xlog_recover_check_summary(log)
|
|
|
|
#endif
|
2016-01-04 13:40:16 -07:00
|
|
|
STATIC int
|
|
|
|
xlog_do_recovery_pass(
|
|
|
|
struct xlog *, xfs_daddr_t, xfs_daddr_t, int, xfs_daddr_t *);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-01 15:06:22 -07:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Sector aligned buffer routines for buffer create/read/write/access
|
|
|
|
*/
|
|
|
|
|
2010-04-12 23:22:58 -06:00
|
|
|
/*
|
|
|
|
* Verify the given count of basic blocks is valid number of blocks
|
|
|
|
* to specify for an operation involving the given XFS log buffer.
|
|
|
|
* Returns nonzero if the count is valid, 0 otherwise.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
xlog_buf_bbcount_valid(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2010-04-12 23:22:58 -06:00
|
|
|
int bbcount)
|
|
|
|
{
|
|
|
|
return bbcount > 0 && bbcount <= log->l_logBBsize;
|
|
|
|
}
|
|
|
|
|
2010-04-12 23:21:13 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-11-19 08:52:00 -07:00
|
|
|
STATIC xfs_buf_t *
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_get_bp(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2009-01-21 21:37:47 -07:00
|
|
|
int nbblks)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-07-08 06:36:25 -06:00
|
|
|
struct xfs_buf *bp;
|
|
|
|
|
2010-04-12 23:22:58 -06:00
|
|
|
if (!xlog_buf_bbcount_valid(log, nbblks)) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
|
2010-04-12 23:22:58 -06:00
|
|
|
nbblks);
|
|
|
|
XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
|
2009-01-21 21:37:47 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-12 23:21:13 -06:00
|
|
|
/*
|
|
|
|
* 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
|
2011-03-30 19:57:33 -06:00
|
|
|
* requested size to accommodate the basic blocks required
|
2010-04-12 23:21:13 -06:00
|
|
|
* 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
|
2011-03-30 19:57:33 -06:00
|
|
|
* there's space to accommodate this possibility.
|
2010-04-12 23:21:13 -06:00
|
|
|
*/
|
2010-04-20 01:09:59 -06:00
|
|
|
if (nbblks > 1 && log->l_sectBBsize > 1)
|
|
|
|
nbblks += log->l_sectBBsize;
|
|
|
|
nbblks = round_up(nbblks, log->l_sectBBsize);
|
2010-04-12 23:21:13 -06:00
|
|
|
|
2012-04-22 23:58:49 -06:00
|
|
|
bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, nbblks, 0);
|
2011-07-08 06:36:25 -06:00
|
|
|
if (bp)
|
|
|
|
xfs_buf_unlock(bp);
|
|
|
|
return bp;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-11-19 08:52:00 -07:00
|
|
|
STATIC void
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_put_bp(
|
|
|
|
xfs_buf_t *bp)
|
|
|
|
{
|
|
|
|
xfs_buf_free(bp);
|
|
|
|
}
|
|
|
|
|
2010-04-20 01:10:21 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2015-06-21 17:45:10 -06:00
|
|
|
STATIC char *
|
2009-03-16 01:24:13 -06:00
|
|
|
xlog_align(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2009-03-16 01:24:13 -06:00
|
|
|
xfs_daddr_t blk_no,
|
|
|
|
int nbblks,
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xfs_buf *bp)
|
2009-03-16 01:24:13 -06:00
|
|
|
{
|
2010-05-10 11:28:14 -06:00
|
|
|
xfs_daddr_t offset = blk_no & ((xfs_daddr_t)log->l_sectBBsize - 1);
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2012-04-22 23:58:51 -06:00
|
|
|
ASSERT(offset + nbblks <= bp->b_length);
|
2011-07-22 17:40:15 -06:00
|
|
|
return bp->b_addr + BBTOB(offset);
|
2009-03-16 01:24:13 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* nbblks should be uint, but oh well. Just want to catch that 32-bit length.
|
|
|
|
*/
|
2009-03-16 01:24:13 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_bread_noalign(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t blk_no,
|
|
|
|
int nbblks,
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xfs_buf *bp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2010-04-12 23:22:58 -06:00
|
|
|
if (!xlog_buf_bbcount_valid(log, nbblks)) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
|
2010-04-12 23:22:58 -06:00
|
|
|
nbblks);
|
|
|
|
XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2009-01-21 21:37:47 -07:00
|
|
|
}
|
|
|
|
|
2010-04-20 01:09:59 -06:00
|
|
|
blk_no = round_down(blk_no, log->l_sectBBsize);
|
|
|
|
nbblks = round_up(nbblks, log->l_sectBBsize);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT(nbblks > 0);
|
2012-04-22 23:58:51 -06:00
|
|
|
ASSERT(nbblks <= bp->b_length);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
|
2016-02-09 21:01:11 -07:00
|
|
|
bp->b_flags |= XBF_READ;
|
2012-04-22 23:58:52 -06:00
|
|
|
bp->b_io_length = nbblks;
|
2012-04-22 23:58:46 -06:00
|
|
|
bp->b_error = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-10-01 17:05:14 -06:00
|
|
|
error = xfs_buf_submit_wait(bp);
|
|
|
|
if (error && !XFS_FORCED_SHUTDOWN(log->l_mp))
|
2011-10-10 10:52:49 -06:00
|
|
|
xfs_buf_ioerror_alert(bp, __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2009-03-16 01:24:13 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_bread(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2009-03-16 01:24:13 -06:00
|
|
|
xfs_daddr_t blk_no,
|
|
|
|
int nbblks,
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xfs_buf *bp,
|
2015-06-21 17:45:10 -06:00
|
|
|
char **offset)
|
2009-03-16 01:24:13 -06:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2011-04-21 03:34:27 -06:00
|
|
|
/*
|
|
|
|
* 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(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2011-04-21 03:34:27 -06:00
|
|
|
xfs_daddr_t blk_no, /* block to read from */
|
|
|
|
int nbblks, /* blocks to read */
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xfs_buf *bp,
|
2015-06-21 17:45:10 -06:00
|
|
|
char *offset)
|
2011-04-21 03:34:27 -06:00
|
|
|
{
|
2015-06-21 17:45:10 -06:00
|
|
|
char *orig_offset = bp->b_addr;
|
2012-04-22 23:58:51 -06:00
|
|
|
int orig_len = BBTOB(bp->b_length);
|
2011-04-21 03:34:27 -06:00
|
|
|
int error, error2;
|
|
|
|
|
2011-07-22 17:40:22 -06:00
|
|
|
error = xfs_buf_associate_memory(bp, offset, BBTOB(nbblks));
|
2011-04-21 03:34:27 -06:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
error = xlog_bread_noalign(log, blk_no, nbblks, bp);
|
|
|
|
|
|
|
|
/* must reset buffer pointer even on error */
|
2011-07-22 17:40:22 -06:00
|
|
|
error2 = xfs_buf_associate_memory(bp, orig_offset, orig_len);
|
2011-04-21 03:34:27 -06:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
return error2;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-06-20 23:36:52 -06:00
|
|
|
STATIC int
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_bwrite(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t blk_no,
|
|
|
|
int nbblks,
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xfs_buf *bp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2010-04-12 23:22:58 -06:00
|
|
|
if (!xlog_buf_bbcount_valid(log, nbblks)) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
|
2010-04-12 23:22:58 -06:00
|
|
|
nbblks);
|
|
|
|
XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2009-01-21 21:37:47 -07:00
|
|
|
}
|
|
|
|
|
2010-04-20 01:09:59 -06:00
|
|
|
blk_no = round_down(blk_no, log->l_sectBBsize);
|
|
|
|
nbblks = round_up(nbblks, log->l_sectBBsize);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT(nbblks > 0);
|
2012-04-22 23:58:51 -06:00
|
|
|
ASSERT(nbblks <= bp->b_length);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
|
2011-07-22 17:40:04 -06:00
|
|
|
xfs_buf_hold(bp);
|
2011-07-08 06:36:19 -06:00
|
|
|
xfs_buf_lock(bp);
|
2012-04-22 23:58:52 -06:00
|
|
|
bp->b_io_length = nbblks;
|
2012-04-22 23:58:46 -06:00
|
|
|
bp->b_error = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-08-23 02:28:07 -06:00
|
|
|
error = xfs_bwrite(bp);
|
2011-10-10 10:52:49 -06:00
|
|
|
if (error)
|
|
|
|
xfs_buf_ioerror_alert(bp, __func__);
|
2011-08-23 02:28:07 -06:00
|
|
|
xfs_buf_relse(bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
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)
|
|
|
|
{
|
2013-10-11 19:59:05 -06:00
|
|
|
xfs_debug(mp, "%s: SB : uuid = %pU, fmt = %d",
|
2009-12-14 19:01:10 -07:00
|
|
|
__func__, &mp->m_sb.sb_uuid, XLOG_FMT);
|
2013-10-11 19:59:05 -06:00
|
|
|
xfs_debug(mp, " log : uuid = %pU, fmt = %d",
|
2009-12-14 19:01:10 -07:00
|
|
|
&head->h_fs_uuid, be32_to_cpu(head->h_fmt));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#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)
|
|
|
|
{
|
2011-07-08 06:36:05 -06:00
|
|
|
ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2011-07-08 06:36:05 -06:00
|
|
|
if (unlikely(head->h_fmt != cpu_to_be32(XLOG_FMT))) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp,
|
|
|
|
"dirty log written in incompatible format - can't recover");
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_header_check_dump(mp, head);
|
|
|
|
XFS_ERROR_REPORT("xlog_header_check_recover(1)",
|
|
|
|
XFS_ERRLEVEL_HIGH, mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp,
|
|
|
|
"dirty log entry has mismatched uuid - can't recover");
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_header_check_dump(mp, head);
|
|
|
|
XFS_ERROR_REPORT("xlog_header_check_recover(2)",
|
|
|
|
XFS_ERRLEVEL_HIGH, mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
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)
|
|
|
|
{
|
2011-07-08 06:36:05 -06:00
|
|
|
ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (uuid_is_nil(&head->h_fs_uuid)) {
|
|
|
|
/*
|
|
|
|
* IRIX doesn't write the h_fs_uuid or h_fmt fields. If
|
|
|
|
* h_fs_uuid is nil, we assume this log was last mounted
|
|
|
|
* by IRIX and continue.
|
|
|
|
*/
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp, "nil uuid in log - IRIX style log");
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp, "log has mismatched uuid - can't recover");
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_header_check_dump(mp, head);
|
|
|
|
XFS_ERROR_REPORT("xlog_header_check_mount",
|
|
|
|
XFS_ERRLEVEL_HIGH, mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_iodone(
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
2011-07-22 17:39:51 -06:00
|
|
|
if (bp->b_error) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* We're not going to bother about retrying
|
|
|
|
* this during recovery. One strike!
|
|
|
|
*/
|
2014-10-01 17:05:14 -06:00
|
|
|
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);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
xfs: update metadata LSN in buffers during log recovery
Log recovery is currently broken for v5 superblocks in that it never
updates the metadata LSN of buffers written out during recovery. The
metadata LSN is recorded in various bits of metadata to provide recovery
ordering criteria that prevents transient corruption states reported by
buffer write verifiers. Without such ordering logic, buffer updates can
be replayed out of order and lead to false positive transient corruption
states. This is generally not a corruption vector on its own, but
corruption detection shuts down the filesystem and ultimately prevents a
mount if it occurs during log recovery. This requires an xfs_repair run
that clears the log and potentially loses filesystem updates.
This problem is avoided in most cases as metadata writes during normal
filesystem operation update the metadata LSN appropriately. The problem
with log recovery not updating metadata LSNs manifests if the system
happens to crash shortly after log recovery itself. In this scenario, it
is possible for log recovery to complete all metadata I/O such that the
filesystem is consistent. If a crash occurs after that point but before
the log tail is pushed forward by subsequent operations, however, the
next mount performs the same log recovery over again. If a buffer is
updated multiple times in the dirty range of the log, an earlier update
in the log might not be valid based on the current state of the
associated buffer after all of the updates in the log had been replayed
(before the previous crash). If a verifier happens to detect such a
problem, the filesystem claims corruption and immediately shuts down.
This commonly manifests in practice as directory block verifier failures
such as the following, likely due to directory verifiers being
particularly detailed in their checks as compared to most others:
...
Mounting V5 Filesystem
XFS (dm-0): Starting recovery (logdev: internal)
XFS (dm-0): Internal error XFS_WANT_CORRUPTED_RETURN at line ... of \
file fs/xfs/libxfs/xfs_dir2_data.c. Caller xfs_dir3_data_verify ...
...
Update log recovery to update the metadata LSN of recovered buffers.
Since metadata LSNs are already updated by write verifer functions via
attached log items, attach a dummy log item to the buffer during
validation and explicitly set the LSN of the current transaction. This
ensures that the metadata LSN of a buffer is updated based on whether
the recovery I/O actually completes, and if so, that subsequent recovery
attempts identify that the buffer is already up to date with respect to
the current transaction.
Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-09-25 16:34:27 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
2011-07-13 05:43:49 -06:00
|
|
|
bp->b_iodone = NULL;
|
2014-10-01 17:04:22 -06:00
|
|
|
xfs_buf_ioend(bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2007-11-22 22:28:09 -07:00
|
|
|
STATIC int
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_find_cycle_start(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct xfs_buf *bp,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t first_blk,
|
|
|
|
xfs_daddr_t *last_blk,
|
|
|
|
uint cycle)
|
|
|
|
{
|
2015-06-21 17:45:10 -06:00
|
|
|
char *offset;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t mid_blk;
|
2010-04-15 12:17:30 -06:00
|
|
|
xfs_daddr_t end_blk;
|
2005-04-16 16:20:36 -06:00
|
|
|
uint mid_cycle;
|
|
|
|
int error;
|
|
|
|
|
2010-04-15 12:17:30 -06:00
|
|
|
end_blk = *last_blk;
|
|
|
|
mid_blk = BLK_AVG(first_blk, end_blk);
|
|
|
|
while (mid_blk != first_blk && mid_blk != end_blk) {
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, mid_blk, 1, bp, &offset);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
2007-10-11 18:58:05 -06:00
|
|
|
mid_cycle = xlog_get_cycle(offset);
|
2010-04-15 12:17:30 -06:00
|
|
|
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);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-04-15 12:17:30 -06:00
|
|
|
ASSERT((mid_blk == first_blk && mid_blk+1 == end_blk) ||
|
|
|
|
(mid_blk == end_blk && mid_blk-1 == first_blk));
|
|
|
|
|
|
|
|
*last_blk = end_blk;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-04-15 12:17:34 -06:00
|
|
|
* 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.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_find_verify_cycle(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
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;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *buf = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
int error = 0;
|
|
|
|
|
2010-04-12 23:22:29 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
bufblks = 1 << ffs(nbblks);
|
2012-04-27 03:45:22 -06:00
|
|
|
while (bufblks > log->l_logBBsize)
|
|
|
|
bufblks >>= 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
while (!(bp = xlog_get_bp(log, bufblks))) {
|
|
|
|
bufblks >>= 1;
|
2010-04-20 01:09:59 -06:00
|
|
|
if (bufblks < log->l_sectBBsize)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
|
|
|
|
int bcount;
|
|
|
|
|
|
|
|
bcount = min(bufblks, (start_blk + nbblks - i));
|
|
|
|
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, i, bcount, bp, &buf);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
for (j = 0; j < bcount; j++) {
|
2007-10-11 18:58:05 -06:00
|
|
|
cycle = xlog_get_cycle(buf);
|
2005-04-16 16:20:36 -06:00
|
|
|
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(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t start_blk,
|
|
|
|
xfs_daddr_t *last_blk,
|
|
|
|
int extra_bblks)
|
|
|
|
{
|
|
|
|
xfs_daddr_t i;
|
|
|
|
xfs_buf_t *bp;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *offset = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
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)))
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
smallmem = 1;
|
|
|
|
} else {
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, start_blk, num_blks, bp, &offset);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
offset += ((num_blks - 1) << BBSHIFT);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = (*last_blk) - 1; i >= 0; i--) {
|
|
|
|
if (i < start_blk) {
|
|
|
|
/* valid log record not found */
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp,
|
|
|
|
"Log inconsistent (didn't find previous header)");
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(0);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (smallmem) {
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, i, 1, bp, &offset);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
head = (xlog_rec_header_t *)offset;
|
|
|
|
|
2011-07-08 06:36:05 -06:00
|
|
|
if (head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
|
2005-04-16 16:20:36 -06:00
|
|
|
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) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
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.
|
|
|
|
*/
|
2008-03-05 19:44:28 -07:00
|
|
|
if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
|
2007-10-11 18:59:34 -06:00
|
|
|
uint h_size = be32_to_cpu(head->h_size);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
|
|
|
|
if (h_size % XLOG_HEADER_CYCLE_SIZE)
|
|
|
|
xhdrs++;
|
|
|
|
} else {
|
|
|
|
xhdrs = 1;
|
|
|
|
}
|
|
|
|
|
2007-10-11 18:59:34 -06:00
|
|
|
if (*last_blk - i + extra_bblks !=
|
|
|
|
BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
|
2005-04-16 16:20:36 -06:00
|
|
|
*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
|
2013-08-07 04:11:08 -06:00
|
|
|
* could go. This means that incomplete LR writes at the end are
|
2005-04-16 16:20:36 -06:00
|
|
|
* 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.
|
|
|
|
*/
|
2005-06-20 23:36:52 -06:00
|
|
|
STATIC int
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_find_head(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t *return_head_blk)
|
|
|
|
{
|
|
|
|
xfs_buf_t *bp;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *offset;
|
2005-04-16 16:20:36 -06:00
|
|
|
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? */
|
2014-06-24 22:58:08 -06:00
|
|
|
error = xlog_find_zeroed(log, &first_blk);
|
|
|
|
if (error < 0) {
|
|
|
|
xfs_warn(log->l_mp, "empty log check failed");
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
if (error == 1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
*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
|
|
|
|
*/
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp, "totally zeroed log");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
first_blk = 0; /* get cycle # of 1st block */
|
|
|
|
bp = xlog_get_bp(log, 1);
|
|
|
|
if (!bp)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
|
|
|
error = xlog_bread(log, 0, 1, bp, &offset);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto bp_err;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2007-10-11 18:58:05 -06:00
|
|
|
first_half_cycle = xlog_get_cycle(offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
last_blk = head_blk = log_bbnum - 1; /* get cycle # of last block */
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, last_blk, 1, bp, &offset);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto bp_err;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2007-10-11 18:58:05 -06:00
|
|
|
last_half_cycle = xlog_get_cycle(offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
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
|
2006-03-28 15:55:14 -07:00
|
|
|
* In this case the head really is somewhere at the end of the
|
2005-04-16 16:20:36 -06:00
|
|
|
* 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
|
2010-04-15 12:17:34 -06:00
|
|
|
* x + 1 ... | x ... | x
|
2005-04-16 16:20:36 -06:00
|
|
|
* 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
|
2010-04-15 12:17:34 -06:00
|
|
|
* v binary search stopped here
|
|
|
|
* x + 1 ... | x | x + 1 | x ... | x
|
|
|
|
* ^ but we want to locate this spot
|
2005-04-16 16:20:36 -06:00
|
|
|
* or
|
|
|
|
* <---------> less than scan distance
|
2010-04-15 12:17:34 -06:00
|
|
|
* x + 1 ... | x ... | x - 1 | x
|
|
|
|
* ^ we want to locate this spot
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
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 = 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 &&
|
2010-04-15 12:17:34 -06:00
|
|
|
(xfs_daddr_t) num_scan_bblks >= head_blk);
|
|
|
|
start_blk = log_bbnum - (num_scan_bblks - head_blk);
|
2005-04-16 16:20:36 -06:00
|
|
|
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;
|
2010-04-15 12:17:26 -06:00
|
|
|
goto validate_head;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2010-04-15 12:17:26 -06:00
|
|
|
validate_head:
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 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 */
|
2014-06-24 22:58:08 -06:00
|
|
|
error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0);
|
|
|
|
if (error == 1)
|
|
|
|
error = -EIO;
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto bp_err;
|
|
|
|
} else {
|
|
|
|
start_blk = 0;
|
|
|
|
ASSERT(head_blk <= INT_MAX);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = xlog_find_verify_log_record(log, start_blk, &head_blk, 0);
|
|
|
|
if (error < 0)
|
|
|
|
goto bp_err;
|
|
|
|
if (error == 1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* We hit the beginning of the log during our search */
|
2010-04-15 12:17:34 -06:00
|
|
|
start_blk = log_bbnum - (num_scan_bblks - head_blk);
|
2005-04-16 16:20:36 -06:00
|
|
|
new_blk = log_bbnum;
|
|
|
|
ASSERT(start_blk <= INT_MAX &&
|
|
|
|
(xfs_daddr_t) log_bbnum-start_blk >= 0);
|
|
|
|
ASSERT(head_blk <= INT_MAX);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = xlog_find_verify_log_record(log, start_blk,
|
|
|
|
&new_blk, (int)head_blk);
|
|
|
|
if (error == 1)
|
|
|
|
error = -EIO;
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
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)
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp, "failed to find log head");
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2016-01-03 21:55:10 -07:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2016-01-04 13:40:16 -07:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check the log tail for torn writes. This is required when torn writes are
|
|
|
|
* detected at the head and the head had to be walked back to a previous record.
|
|
|
|
* The tail of the previous record must now be verified to ensure the torn
|
|
|
|
* writes didn't corrupt the previous tail.
|
|
|
|
*
|
|
|
|
* Return an error if CRC verification fails as recovery cannot proceed.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_verify_tail(
|
|
|
|
struct xlog *log,
|
|
|
|
xfs_daddr_t head_blk,
|
|
|
|
xfs_daddr_t tail_blk)
|
|
|
|
{
|
|
|
|
struct xlog_rec_header *thead;
|
|
|
|
struct xfs_buf *bp;
|
|
|
|
xfs_daddr_t first_bad;
|
|
|
|
int count;
|
|
|
|
int error = 0;
|
|
|
|
bool wrapped;
|
|
|
|
xfs_daddr_t tmp_head;
|
|
|
|
|
|
|
|
bp = xlog_get_bp(log, 1);
|
|
|
|
if (!bp)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Seek XLOG_MAX_ICLOGS + 1 records past the current tail record to get
|
|
|
|
* a temporary head block that points after the last possible
|
|
|
|
* concurrently written record of the tail.
|
|
|
|
*/
|
|
|
|
count = xlog_seek_logrec_hdr(log, head_blk, tail_blk,
|
|
|
|
XLOG_MAX_ICLOGS + 1, bp, &tmp_head, &thead,
|
|
|
|
&wrapped);
|
|
|
|
if (count < 0) {
|
|
|
|
error = count;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the call above didn't find XLOG_MAX_ICLOGS + 1 records, we ran
|
|
|
|
* into the actual log head. tmp_head points to the start of the record
|
|
|
|
* so update it to the actual head block.
|
|
|
|
*/
|
|
|
|
if (count < XLOG_MAX_ICLOGS + 1)
|
|
|
|
tmp_head = head_blk;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We now have a tail and temporary head block that covers at least
|
|
|
|
* XLOG_MAX_ICLOGS records from the tail. We need to verify that these
|
|
|
|
* records were completely written. Run a CRC verification pass from
|
|
|
|
* tail to head and return the result.
|
|
|
|
*/
|
|
|
|
error = xlog_do_recovery_pass(log, tmp_head, tail_blk,
|
|
|
|
XLOG_RECOVER_CRCPASS, &first_bad);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
/*
|
2016-03-06 14:22:22 -07:00
|
|
|
* 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.
|
2016-01-04 13:40:16 -07:00
|
|
|
*/
|
|
|
|
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) {
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now verify the tail based on the updated head. This is
|
|
|
|
* required because the torn writes trimmed from the head could
|
|
|
|
* have been written over the tail of a previous record. Return
|
|
|
|
* any errors since recovery cannot proceed if the tail is
|
|
|
|
* corrupt.
|
|
|
|
*
|
|
|
|
* XXX: This leaves a gap in truly robust protection from torn
|
|
|
|
* writes in the log. If the head is behind the tail, the tail
|
|
|
|
* pushes forward to create some space and then a crash occurs
|
|
|
|
* causing the writes into the previous record's tail region to
|
|
|
|
* tear, log recovery isn't able to recover.
|
|
|
|
*
|
|
|
|
* How likely is this to occur? If possible, can we do something
|
|
|
|
* more intelligent here? Is it safe to push the tail forward if
|
|
|
|
* we can determine that the tail is within the range of the
|
|
|
|
* torn write (e.g., the kernel can only overwrite the tail if
|
|
|
|
* it has actually been pushed forward)? Alternatively, could we
|
|
|
|
* somehow prevent this condition at runtime?
|
|
|
|
*/
|
|
|
|
error = xlog_verify_tail(log, *head_blk, *tail_blk);
|
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2016-03-06 14:22:22 -07:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2016-03-06 14:22:22 -07:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-11-19 08:52:00 -07:00
|
|
|
STATIC int
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_find_tail(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t *head_blk,
|
2006-01-10 21:34:19 -07:00
|
|
|
xfs_daddr_t *tail_blk)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xlog_rec_header_t *rhead;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *offset = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_buf_t *bp;
|
2016-01-04 13:40:16 -07:00
|
|
|
int error;
|
|
|
|
xfs_daddr_t rhead_blk;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_lsn_t tail_lsn;
|
2016-01-03 21:55:10 -07:00
|
|
|
bool wrapped = false;
|
2016-03-06 14:22:22 -07:00
|
|
|
bool clean = false;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find previous log record
|
|
|
|
*/
|
|
|
|
if ((error = xlog_find_head(log, head_blk)))
|
|
|
|
return error;
|
2016-03-06 14:22:22 -07:00
|
|
|
ASSERT(*head_blk < INT_MAX);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
bp = xlog_get_bp(log, 1);
|
|
|
|
if (!bp)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (*head_blk == 0) { /* special case */
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, 0, 1, bp, &offset);
|
|
|
|
if (error)
|
2010-04-15 12:17:26 -06:00
|
|
|
goto done;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2007-10-11 18:58:05 -06:00
|
|
|
if (xlog_get_cycle(offset) == 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
*tail_blk = 0;
|
|
|
|
/* leave all other log inited values alone */
|
2010-04-15 12:17:26 -06:00
|
|
|
goto done;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-03-06 14:22:22 -07:00
|
|
|
* 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.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2016-03-06 14:22:22 -07:00
|
|
|
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));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2016-03-06 14:22:22 -07:00
|
|
|
* Set the log state based on the current head record.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2016-03-06 14:22:22 -07:00
|
|
|
xlog_set_state(log, *head_blk, rhead, rhead_blk, wrapped);
|
2016-03-06 14:22:22 -07:00
|
|
|
tail_lsn = atomic64_read(&log->l_tail_lsn);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2016-03-06 14:22:22 -07:00
|
|
|
* Look for an unmount record at the head of the log. This sets the log
|
|
|
|
* state to determine whether recovery is necessary.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2016-03-06 14:22:22 -07:00
|
|
|
error = xlog_check_unmount_rec(log, head_blk, tail_blk, rhead,
|
|
|
|
rhead_blk, bp, &clean);
|
|
|
|
if (error)
|
|
|
|
goto done;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2016-03-06 14:22:22 -07:00
|
|
|
* 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.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2016-03-06 14:22:22 -07:00
|
|
|
* 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.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2016-03-06 14:22:22 -07:00
|
|
|
if (!clean) {
|
|
|
|
xfs_daddr_t orig_head = *head_blk;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-03-06 14:22:22 -07:00
|
|
|
error = xlog_verify_head(log, head_blk, tail_blk, bp,
|
|
|
|
&rhead_blk, &rhead, &wrapped);
|
2009-03-16 01:24:13 -06:00
|
|
|
if (error)
|
2010-04-15 12:17:26 -06:00
|
|
|
goto done;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2016-03-06 14:22:22 -07:00
|
|
|
/* 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;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-06 14:22:22 -07:00
|
|
|
/*
|
|
|
|
* 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;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2010-04-15 12:17:26 -06:00
|
|
|
if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp))
|
2005-04-16 16:20:36 -06:00
|
|
|
error = xlog_clear_stale_blocks(log, tail_lsn);
|
|
|
|
|
2010-04-15 12:17:26 -06:00
|
|
|
done:
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_put_bp(bp);
|
|
|
|
|
|
|
|
if (error)
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp, "failed to locate log tail");
|
2005-04-16 16:20:36 -06:00
|
|
|
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
|
2014-06-24 22:58:08 -06:00
|
|
|
* 1 => use *blk_no as the first block of the log
|
|
|
|
* <0 => error has occurred
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-11-22 22:28:09 -07:00
|
|
|
STATIC int
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_find_zeroed(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t *blk_no)
|
|
|
|
{
|
|
|
|
xfs_buf_t *bp;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *offset;
|
2005-04-16 16:20:36 -06:00
|
|
|
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;
|
|
|
|
|
2006-06-27 18:13:52 -06:00
|
|
|
*blk_no = 0;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* check totally zeroed log */
|
|
|
|
bp = xlog_get_bp(log, 1);
|
|
|
|
if (!bp)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, 0, 1, bp, &offset);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto bp_err;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2007-10-11 18:58:05 -06:00
|
|
|
first_cycle = xlog_get_cycle(offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (first_cycle == 0) { /* completely zeroed log */
|
|
|
|
*blk_no = 0;
|
|
|
|
xlog_put_bp(bp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* check partially zeroed log */
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto bp_err;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2007-10-11 18:58:05 -06:00
|
|
|
last_cycle = xlog_get_cycle(offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
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.
|
|
|
|
*/
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp,
|
|
|
|
"Log inconsistent or not a log (last==0, first!=1)");
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EINVAL;
|
2013-07-31 19:32:30 -06:00
|
|
|
goto bp_err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
2014-06-24 22:58:08 -06:00
|
|
|
error = xlog_find_verify_log_record(log, start_blk, &last_blk, 0);
|
|
|
|
if (error == 1)
|
|
|
|
error = -EIO;
|
|
|
|
if (error)
|
|
|
|
goto bp_err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
*blk_no = last_blk;
|
|
|
|
bp_err:
|
|
|
|
xlog_put_bp(bp);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2014-06-24 22:58:08 -06:00
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2015-06-21 17:45:10 -06:00
|
|
|
char *buf,
|
2005-04-16 16:20:36 -06:00
|
|
|
int cycle,
|
|
|
|
int block,
|
|
|
|
int tail_cycle,
|
|
|
|
int tail_block)
|
|
|
|
{
|
|
|
|
xlog_rec_header_t *recp = (xlog_rec_header_t *)buf;
|
|
|
|
|
|
|
|
memset(buf, 0, BBSIZE);
|
2007-10-11 18:59:34 -06:00
|
|
|
recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
|
|
|
|
recp->h_cycle = cpu_to_be32(cycle);
|
|
|
|
recp->h_version = cpu_to_be32(
|
2008-03-05 19:44:28 -07:00
|
|
|
xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
|
2007-10-11 18:59:34 -06:00
|
|
|
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);
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
|
|
|
xlog_write_log_records(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
int cycle,
|
|
|
|
int start_block,
|
|
|
|
int blocks,
|
|
|
|
int tail_cycle,
|
|
|
|
int tail_block)
|
|
|
|
{
|
2015-06-21 17:45:10 -06:00
|
|
|
char *offset;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_buf_t *bp;
|
|
|
|
int balign, ealign;
|
2010-04-20 01:09:59 -06:00
|
|
|
int sectbb = log->l_sectBBsize;
|
2005-04-16 16:20:36 -06:00
|
|
|
int end_block = start_block + blocks;
|
|
|
|
int bufblks;
|
|
|
|
int error = 0;
|
|
|
|
int i, j = 0;
|
|
|
|
|
2010-04-12 23:22:29 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
bufblks = 1 << ffs(blocks);
|
2012-04-27 03:45:22 -06:00
|
|
|
while (bufblks > log->l_logBBsize)
|
|
|
|
bufblks >>= 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
while (!(bp = xlog_get_bp(log, bufblks))) {
|
|
|
|
bufblks >>= 1;
|
2010-04-20 01:09:59 -06:00
|
|
|
if (bufblks < sectbb)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
2010-04-12 23:22:48 -06:00
|
|
|
balign = round_down(start_block, sectbb);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (balign != start_block) {
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread_noalign(log, start_block, 1, bp);
|
|
|
|
if (error)
|
|
|
|
goto out_put_bp;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
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.
|
|
|
|
*/
|
2010-04-12 23:22:48 -06:00
|
|
|
ealign = round_down(end_block, sectbb);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (j == 0 && (start_block + endcount > ealign)) {
|
2011-07-22 17:40:15 -06:00
|
|
|
offset = bp->b_addr + BBTOB(ealign - start_block);
|
2011-04-21 03:34:27 -06:00
|
|
|
error = xlog_bread_offset(log, ealign, sectbb,
|
|
|
|
bp, offset);
|
2009-03-16 01:24:13 -06:00
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2009-03-16 01:24:13 -06:00
|
|
|
|
|
|
|
out_put_bp:
|
2005-04-16 16:20:36 -06:00
|
|
|
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(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_lsn_t tail_lsn)
|
|
|
|
{
|
|
|
|
int tail_cycle, head_cycle;
|
|
|
|
int tail_block, head_block;
|
|
|
|
int tail_distance, max_distance;
|
|
|
|
int distance;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
tail_cycle = CYCLE_LSN(tail_lsn);
|
|
|
|
tail_block = BLOCK_LSN(tail_lsn);
|
|
|
|
head_cycle = log->l_curr_cycle;
|
|
|
|
head_block = log->l_curr_block;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Figure out the distance between the new head of the log
|
|
|
|
* and the tail. We want to write over any blocks beyond the
|
|
|
|
* head that we may have written just before the crash, but
|
|
|
|
* we don't want to overwrite the tail of the log.
|
|
|
|
*/
|
|
|
|
if (head_cycle == tail_cycle) {
|
|
|
|
/*
|
|
|
|
* The tail is behind the head in the physical log,
|
|
|
|
* so the distance from the head to the tail is the
|
|
|
|
* distance from the head to the end of the log plus
|
|
|
|
* the distance from the beginning of the log to the
|
|
|
|
* tail.
|
|
|
|
*/
|
|
|
|
if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
|
|
|
|
XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
|
|
|
|
XFS_ERRLEVEL_LOW, log->l_mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
tail_distance = tail_block + (log->l_logBBsize - head_block);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The head is behind the tail in the physical log,
|
|
|
|
* so the distance from the head to the tail is just
|
|
|
|
* the tail block minus the head block.
|
|
|
|
*/
|
|
|
|
if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
|
|
|
|
XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
|
|
|
|
XFS_ERRLEVEL_LOW, log->l_mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
tail_distance = tail_block - head_block;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the head is right up against the tail, we can't clear
|
|
|
|
* anything.
|
|
|
|
*/
|
|
|
|
if (tail_distance <= 0) {
|
|
|
|
ASSERT(tail_distance == 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
max_distance = XLOG_TOTAL_REC_SHIFT(log);
|
|
|
|
/*
|
|
|
|
* Take the smaller of the maximum amount of outstanding I/O
|
|
|
|
* we could have and the distance to the tail to clear out.
|
|
|
|
* We take the smaller so that we don't overwrite the tail and
|
|
|
|
* we don't waste all day writing from the head to the tail
|
|
|
|
* for no reason.
|
|
|
|
*/
|
|
|
|
max_distance = MIN(max_distance, tail_distance);
|
|
|
|
|
|
|
|
if ((head_block + max_distance) <= log->l_logBBsize) {
|
|
|
|
/*
|
|
|
|
* We can stomp all the blocks we need to without
|
|
|
|
* wrapping around the end of the log. Just do it
|
|
|
|
* in a single write. Use the cycle number of the
|
|
|
|
* current cycle minus one so that the log will look like:
|
|
|
|
* n ... | n - 1 ...
|
|
|
|
*/
|
|
|
|
error = xlog_write_log_records(log, (head_cycle - 1),
|
|
|
|
head_block, max_distance, tail_cycle,
|
|
|
|
tail_block);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We need to wrap around the end of the physical log in
|
|
|
|
* order to clear all the blocks. Do it in two separate
|
|
|
|
* I/Os. The first write should be from the head to the
|
|
|
|
* end of the physical log, and it should use the current
|
|
|
|
* cycle number minus one just like above.
|
|
|
|
*/
|
|
|
|
distance = log->l_logBBsize - head_block;
|
|
|
|
error = xlog_write_log_records(log, (head_cycle - 1),
|
|
|
|
head_block, distance, tail_cycle,
|
|
|
|
tail_block);
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now write the blocks at the start of the physical log.
|
|
|
|
* This writes the remainder of the blocks we want to clear.
|
|
|
|
* It uses the current cycle number since we're now on the
|
|
|
|
* same cycle as the head so that we get:
|
|
|
|
* n ... n ... | n - 1 ...
|
|
|
|
* ^^^^^ blocks we're writing
|
|
|
|
*/
|
|
|
|
distance = max_distance - (log->l_logBBsize - head_block);
|
|
|
|
error = xlog_write_log_records(log, head_cycle, 0, distance,
|
|
|
|
tail_cycle, tail_block);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* Log recover routines
|
|
|
|
*
|
|
|
|
******************************************************************************
|
|
|
|
*/
|
|
|
|
|
2010-01-11 04:49:57 -07:00
|
|
|
/*
|
2013-06-04 20:09:07 -06:00
|
|
|
* Sort the log items in the transaction.
|
|
|
|
*
|
|
|
|
* The ordering constraints are defined by the inode allocation and unlink
|
|
|
|
* behaviour. The rules are:
|
|
|
|
*
|
|
|
|
* 1. Every item is only logged once in a given transaction. Hence it
|
|
|
|
* represents the last logged state of the item. Hence ordering is
|
|
|
|
* dependent on the order in which operations need to be performed so
|
|
|
|
* required initial conditions are always met.
|
|
|
|
*
|
|
|
|
* 2. Cancelled buffers are recorded in pass 1 in a separate table and
|
|
|
|
* there's nothing to replay from them so we can simply cull them
|
|
|
|
* from the transaction. However, we can't do that until after we've
|
|
|
|
* replayed all the other items because they may be dependent on the
|
|
|
|
* cancelled buffer and replaying the cancelled buffer can remove it
|
|
|
|
* form the cancelled buffer table. Hence they have tobe done last.
|
|
|
|
*
|
|
|
|
* 3. Inode allocation buffers must be replayed before inode items that
|
2013-06-27 00:04:55 -06:00
|
|
|
* read the buffer and replay changes into it. For filesystems using the
|
|
|
|
* ICREATE transactions, this means XFS_LI_ICREATE objects need to get
|
|
|
|
* treated the same as inode allocation buffers as they create and
|
|
|
|
* initialise the buffers directly.
|
2013-06-04 20:09:07 -06:00
|
|
|
*
|
|
|
|
* 4. Inode unlink buffers must be replayed after inode items are replayed.
|
|
|
|
* This ensures that inodes are completely flushed to the inode buffer
|
|
|
|
* in a "free" state before we remove the unlinked inode list pointer.
|
|
|
|
*
|
|
|
|
* Hence the ordering needs to be inode allocation buffers first, inode items
|
|
|
|
* second, inode unlink buffers third and cancelled buffers last.
|
|
|
|
*
|
|
|
|
* But there's a problem with that - we can't tell an inode allocation buffer
|
|
|
|
* apart from a regular buffer, so we can't separate them. We can, however,
|
|
|
|
* tell an inode unlink buffer from the others, and so we can separate them out
|
|
|
|
* from all the other buffers and move them to last.
|
|
|
|
*
|
|
|
|
* Hence, 4 lists, in order from head to tail:
|
2013-06-27 00:04:55 -06:00
|
|
|
* - buffer_list for all buffers except cancelled/inode unlink buffers
|
|
|
|
* - item_list for all non-buffer items
|
|
|
|
* - inode_buffer_list for inode unlink buffers
|
|
|
|
* - cancel_list for the cancelled buffers
|
|
|
|
*
|
|
|
|
* Note that we add objects to the tail of the lists so that first-to-last
|
|
|
|
* ordering is preserved within the lists. Adding objects to the head of the
|
|
|
|
* list means when we traverse from the head we walk them in last-to-first
|
|
|
|
* order. For cancelled buffers and inode unlink buffers this doesn't matter,
|
|
|
|
* but for all other items there may be specific ordering that we need to
|
|
|
|
* preserve.
|
2010-01-11 04:49:57 -07:00
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_recover_reorder_trans(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover *trans,
|
2010-04-12 23:06:46 -06:00
|
|
|
int pass)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-01-11 04:49:57 -07:00
|
|
|
xlog_recover_item_t *item, *n;
|
2013-10-02 06:51:12 -06:00
|
|
|
int error = 0;
|
2010-01-11 04:49:57 -07:00
|
|
|
LIST_HEAD(sort_list);
|
2013-06-04 20:09:07 -06:00
|
|
|
LIST_HEAD(cancel_list);
|
|
|
|
LIST_HEAD(buffer_list);
|
|
|
|
LIST_HEAD(inode_buffer_list);
|
|
|
|
LIST_HEAD(inode_list);
|
2010-01-11 04:49:57 -07:00
|
|
|
|
|
|
|
list_splice_init(&trans->r_itemq, &sort_list);
|
|
|
|
list_for_each_entry_safe(item, n, &sort_list, ri_list) {
|
2010-06-23 02:11:15 -06:00
|
|
|
xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-01-11 04:49:57 -07:00
|
|
|
switch (ITEM_TYPE(item)) {
|
2013-06-27 00:04:55 -06:00
|
|
|
case XFS_LI_ICREATE:
|
|
|
|
list_move_tail(&item->ri_list, &buffer_list);
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
case XFS_LI_BUF:
|
2013-06-04 20:09:07 -06:00
|
|
|
if (buf_f->blf_flags & XFS_BLF_CANCEL) {
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_item_reorder_head(log,
|
|
|
|
trans, item, pass);
|
2013-06-04 20:09:07 -06:00
|
|
|
list_move(&item->ri_list, &cancel_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
2013-06-04 20:09:07 -06:00
|
|
|
if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
|
|
|
|
list_move(&item->ri_list, &inode_buffer_list);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
list_move_tail(&item->ri_list, &buffer_list);
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
case XFS_LI_INODE:
|
|
|
|
case XFS_LI_DQUOT:
|
|
|
|
case XFS_LI_QUOTAOFF:
|
|
|
|
case XFS_LI_EFD:
|
|
|
|
case XFS_LI_EFI:
|
2016-08-02 20:09:48 -06:00
|
|
|
case XFS_LI_RUI:
|
|
|
|
case XFS_LI_RUD:
|
2016-10-03 10:11:21 -06:00
|
|
|
case XFS_LI_CUI:
|
|
|
|
case XFS_LI_CUD:
|
2016-10-03 10:11:26 -06:00
|
|
|
case XFS_LI_BUI:
|
|
|
|
case XFS_LI_BUD:
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_item_reorder_tail(log,
|
|
|
|
trans, item, pass);
|
2013-06-04 20:09:07 -06:00
|
|
|
list_move_tail(&item->ri_list, &inode_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp,
|
|
|
|
"%s: unrecognized type of log operation",
|
|
|
|
__func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(0);
|
2013-10-02 06:51:12 -06:00
|
|
|
/*
|
|
|
|
* return the remaining items back to the transaction
|
|
|
|
* item list so they can be freed in caller.
|
|
|
|
*/
|
|
|
|
if (!list_empty(&sort_list))
|
|
|
|
list_splice_init(&sort_list, &trans->r_itemq);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EIO;
|
2013-10-02 06:51:12 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-01-11 04:49:57 -07:00
|
|
|
}
|
2013-10-02 06:51:12 -06:00
|
|
|
out:
|
2010-01-11 04:49:57 -07:00
|
|
|
ASSERT(list_empty(&sort_list));
|
2013-06-04 20:09:07 -06:00
|
|
|
if (!list_empty(&buffer_list))
|
|
|
|
list_splice(&buffer_list, &trans->r_itemq);
|
|
|
|
if (!list_empty(&inode_list))
|
|
|
|
list_splice_tail(&inode_list, &trans->r_itemq);
|
|
|
|
if (!list_empty(&inode_buffer_list))
|
|
|
|
list_splice_tail(&inode_buffer_list, &trans->r_itemq);
|
|
|
|
if (!list_empty(&cancel_list))
|
|
|
|
list_splice_tail(&cancel_list, &trans->r_itemq);
|
2013-10-02 06:51:12 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Build up the table of buf cancel records so that we don't replay
|
|
|
|
* cancelled data in the second pass. For buffer records that are
|
|
|
|
* not cancel records, there is nothing to do here so we just return.
|
|
|
|
*
|
|
|
|
* If we get a cancel record which is already in the table, this indicates
|
|
|
|
* that the buffer was cancelled multiple times. In order to ensure
|
|
|
|
* that during pass 2 we keep the record in the table until we reach its
|
|
|
|
* last occurrence in the log, we keep a reference count in the cancel
|
|
|
|
* record in the table to tell us how many times we expect to see this
|
|
|
|
* record during the second pass.
|
|
|
|
*/
|
2010-12-01 15:06:24 -07:00
|
|
|
STATIC int
|
|
|
|
xlog_recover_buffer_pass1(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-12-01 15:06:24 -07:00
|
|
|
xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
|
2010-12-01 15:06:22 -07:00
|
|
|
struct list_head *bucket;
|
|
|
|
struct xfs_buf_cancel *bcp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this isn't a cancel buffer item, then just return.
|
|
|
|
*/
|
2010-12-01 15:06:21 -07:00
|
|
|
if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_buf_not_cancel(log, buf_f);
|
2010-12-01 15:06:24 -07:00
|
|
|
return 0;
|
2010-04-12 23:06:46 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2010-12-01 15:06:22 -07:00
|
|
|
* Insert an xfs_buf_cancel record into the hash table of them.
|
|
|
|
* If there is already an identical record, bump its reference count.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-12-01 15:06:22 -07:00
|
|
|
bucket = XLOG_BUF_CANCEL_BUCKET(log, buf_f->blf_blkno);
|
|
|
|
list_for_each_entry(bcp, bucket, bc_list) {
|
|
|
|
if (bcp->bc_blkno == buf_f->blf_blkno &&
|
|
|
|
bcp->bc_len == buf_f->blf_len) {
|
|
|
|
bcp->bc_refcount++;
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_buf_cancel_ref_inc(log, buf_f);
|
2010-12-01 15:06:24 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-12-01 15:06:22 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
bcp = kmem_alloc(sizeof(struct xfs_buf_cancel), KM_SLEEP);
|
|
|
|
bcp->bc_blkno = buf_f->blf_blkno;
|
|
|
|
bcp->bc_len = buf_f->blf_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
bcp->bc_refcount = 1;
|
2010-12-01 15:06:22 -07:00
|
|
|
list_add_tail(&bcp->bc_list, bucket);
|
|
|
|
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_buf_cancel_add(log, buf_f);
|
2010-12-01 15:06:24 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check to see whether the buffer being recovered has a corresponding
|
2013-08-26 16:10:53 -06:00
|
|
|
* entry in the buffer cancel record table. If it is, return the cancel
|
|
|
|
* buffer structure to the caller.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2013-08-26 16:10:53 -06:00
|
|
|
STATIC struct xfs_buf_cancel *
|
|
|
|
xlog_peek_buffer_cancelled(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t blkno,
|
|
|
|
uint len,
|
2016-11-07 17:55:48 -07:00
|
|
|
unsigned short flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-12-01 15:06:22 -07:00
|
|
|
struct list_head *bucket;
|
|
|
|
struct xfs_buf_cancel *bcp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-08-26 16:10:53 -06:00
|
|
|
if (!log->l_buf_cancel_table) {
|
|
|
|
/* empty table means no cancelled buffers in the log */
|
2010-05-06 19:05:19 -06:00
|
|
|
ASSERT(!(flags & XFS_BLF_CANCEL));
|
2013-08-26 16:10:53 -06:00
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-12-01 15:06:22 -07:00
|
|
|
bucket = XLOG_BUF_CANCEL_BUCKET(log, blkno);
|
|
|
|
list_for_each_entry(bcp, bucket, bc_list) {
|
|
|
|
if (bcp->bc_blkno == blkno && bcp->bc_len == len)
|
2013-08-26 16:10:53 -06:00
|
|
|
return bcp;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-12-01 15:06:22 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2010-12-01 15:06:22 -07:00
|
|
|
* We didn't find a corresponding entry in the table, so return 0 so
|
|
|
|
* that the buffer is NOT cancelled.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-05-06 19:05:19 -06:00
|
|
|
ASSERT(!(flags & XFS_BLF_CANCEL));
|
2013-08-26 16:10:53 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the buffer is being cancelled then return 1 so that it will be cancelled,
|
|
|
|
* otherwise return 0. If the buffer is actually a buffer cancel item
|
|
|
|
* (XFS_BLF_CANCEL is set), then decrement the refcount on the entry in the
|
|
|
|
* table and remove it from the table if this is the last reference.
|
|
|
|
*
|
|
|
|
* We remove the cancel record from the table when we encounter its last
|
|
|
|
* occurrence in the log so that if the same buffer is re-used again after its
|
|
|
|
* last cancellation we actually replay the changes made at that point.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_check_buffer_cancelled(
|
|
|
|
struct xlog *log,
|
|
|
|
xfs_daddr_t blkno,
|
|
|
|
uint len,
|
2016-11-07 17:55:48 -07:00
|
|
|
unsigned short flags)
|
2013-08-26 16:10:53 -06:00
|
|
|
{
|
|
|
|
struct xfs_buf_cancel *bcp;
|
|
|
|
|
|
|
|
bcp = xlog_peek_buffer_cancelled(log, blkno, len, flags);
|
|
|
|
if (!bcp)
|
|
|
|
return 0;
|
2010-12-01 15:06:22 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We've go a match, so return 1 so that the recovery of this buffer
|
|
|
|
* is cancelled. If this buffer is actually a buffer cancel log
|
|
|
|
* item, then decrement the refcount on the one in the table and
|
|
|
|
* remove it if this is the last reference.
|
|
|
|
*/
|
|
|
|
if (flags & XFS_BLF_CANCEL) {
|
|
|
|
if (--bcp->bc_refcount == 0) {
|
|
|
|
list_del(&bcp->bc_list);
|
|
|
|
kmem_free(bcp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-12-01 15:06:21 -07:00
|
|
|
* Perform recovery for a buffer full of inodes. In these buffers, the only
|
|
|
|
* data which should be recovered is that which corresponds to the
|
|
|
|
* di_next_unlinked pointers in the on disk inode structures. The rest of the
|
|
|
|
* data for the inodes is always logged through the inodes themselves rather
|
|
|
|
* than the inode buffer and is recovered in xlog_recover_inode_pass2().
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2010-12-01 15:06:21 -07:00
|
|
|
* The only time when buffers full of inodes are fully recovered is when the
|
|
|
|
* buffer is full of newly allocated inodes. In this case the buffer will
|
|
|
|
* not be marked as an inode buffer and so will be sent to
|
|
|
|
* xlog_recover_do_reg_buffer() below during recovery.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_do_inode_buffer(
|
2010-12-01 15:06:21 -07:00
|
|
|
struct xfs_mount *mp,
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_recover_item_t *item,
|
2010-12-01 15:06:21 -07:00
|
|
|
struct xfs_buf *bp,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_buf_log_format_t *buf_f)
|
|
|
|
{
|
|
|
|
int i;
|
2010-12-01 15:06:21 -07:00
|
|
|
int item_index = 0;
|
|
|
|
int bit = 0;
|
|
|
|
int nbits = 0;
|
|
|
|
int reg_buf_offset = 0;
|
|
|
|
int reg_buf_bytes = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
int next_unlinked_offset;
|
|
|
|
int inodes_per_buf;
|
|
|
|
xfs_agino_t *logged_nextp;
|
|
|
|
xfs_agino_t *buffer_nextp;
|
|
|
|
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_buf_inode_buf(mp->m_log, buf_f);
|
2013-06-11 20:19:06 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Post recovery validation only works properly on CRC enabled
|
|
|
|
* filesystems.
|
|
|
|
*/
|
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb))
|
|
|
|
bp->b_ops = &xfs_inode_buf_ops;
|
2010-04-12 23:06:46 -06:00
|
|
|
|
2012-04-22 23:58:52 -06:00
|
|
|
inodes_per_buf = BBTOB(bp->b_io_length) >> mp->m_sb.sb_inodelog;
|
2005-04-16 16:20:36 -06:00
|
|
|
for (i = 0; i < inodes_per_buf; i++) {
|
|
|
|
next_unlinked_offset = (i * mp->m_sb.sb_inodesize) +
|
|
|
|
offsetof(xfs_dinode_t, di_next_unlinked);
|
|
|
|
|
|
|
|
while (next_unlinked_offset >=
|
|
|
|
(reg_buf_offset + reg_buf_bytes)) {
|
|
|
|
/*
|
|
|
|
* The next di_next_unlinked field is beyond
|
|
|
|
* the current logged region. Find the next
|
|
|
|
* logged region that contains or is beyond
|
|
|
|
* the current di_next_unlinked field.
|
|
|
|
*/
|
|
|
|
bit += nbits;
|
2010-12-01 15:06:21 -07:00
|
|
|
bit = xfs_next_bit(buf_f->blf_data_map,
|
|
|
|
buf_f->blf_map_size, bit);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are no more logged regions in the
|
|
|
|
* buffer, then we're done.
|
|
|
|
*/
|
2010-12-01 15:06:21 -07:00
|
|
|
if (bit == -1)
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
2010-12-01 15:06:21 -07:00
|
|
|
nbits = xfs_contig_bits(buf_f->blf_data_map,
|
|
|
|
buf_f->blf_map_size, bit);
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(nbits > 0);
|
2010-05-06 19:05:19 -06:00
|
|
|
reg_buf_offset = bit << XFS_BLF_SHIFT;
|
|
|
|
reg_buf_bytes = nbits << XFS_BLF_SHIFT;
|
2005-04-16 16:20:36 -06:00
|
|
|
item_index++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the current logged region starts after the current
|
|
|
|
* di_next_unlinked field, then move on to the next
|
|
|
|
* di_next_unlinked field.
|
|
|
|
*/
|
2010-12-01 15:06:21 -07:00
|
|
|
if (next_unlinked_offset < reg_buf_offset)
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
|
|
|
|
ASSERT(item->ri_buf[item_index].i_addr != NULL);
|
2010-05-06 19:05:19 -06:00
|
|
|
ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0);
|
2012-04-22 23:58:52 -06:00
|
|
|
ASSERT((reg_buf_offset + reg_buf_bytes) <=
|
|
|
|
BBTOB(bp->b_io_length));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The current logged region contains a copy of the
|
|
|
|
* current di_next_unlinked field. Extract its value
|
|
|
|
* and copy it to the buffer copy.
|
|
|
|
*/
|
2010-06-23 02:11:15 -06:00
|
|
|
logged_nextp = item->ri_buf[item_index].i_addr +
|
|
|
|
next_unlinked_offset - reg_buf_offset;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (unlikely(*logged_nextp == 0)) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(mp,
|
|
|
|
"Bad inode buffer log record (ptr = 0x%p, bp = 0x%p). "
|
|
|
|
"Trying to replay bad (0) inode di_next_unlinked field.",
|
2005-04-16 16:20:36 -06:00
|
|
|
item, bp);
|
|
|
|
XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
|
|
|
|
XFS_ERRLEVEL_LOW, mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2015-06-21 17:44:29 -06:00
|
|
|
buffer_nextp = xfs_buf_offset(bp, next_unlinked_offset);
|
2006-06-08 22:56:16 -06:00
|
|
|
*buffer_nextp = *logged_nextp;
|
2013-06-04 20:09:08 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If necessary, recalculate the CRC in the on-disk inode. We
|
|
|
|
* have to leave the inode in a consistent state for whoever
|
|
|
|
* reads it next....
|
|
|
|
*/
|
2015-06-21 17:44:29 -06:00
|
|
|
xfs_dinode_calc_crc(mp,
|
2013-06-04 20:09:08 -06:00
|
|
|
xfs_buf_offset(bp, i * mp->m_sb.sb_inodesize));
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-28 05:22:47 -06:00
|
|
|
/*
|
|
|
|
* V5 filesystems know the age of the buffer on disk being recovered. We can
|
|
|
|
* have newer objects on disk than we are replaying, and so for these cases we
|
|
|
|
* don't want to replay the current change as that will make the buffer contents
|
|
|
|
* temporarily invalid on disk.
|
|
|
|
*
|
|
|
|
* The magic number might not match the buffer type we are going to recover
|
|
|
|
* (e.g. reallocated blocks), so we ignore the xfs_buf_log_format flags. Hence
|
|
|
|
* extract the LSN of the existing object in the buffer based on it's current
|
|
|
|
* magic number. If we don't recognise the magic number in the buffer, then
|
|
|
|
* return a LSN of -1 so that the caller knows it was an unrecognised block and
|
|
|
|
* so can recover the buffer.
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
*
|
|
|
|
* Note: we cannot rely solely on magic number matches to determine that the
|
|
|
|
* buffer has a valid LSN - we also need to verify that it belongs to this
|
|
|
|
* filesystem, so we need to extract the object's LSN and compare it to that
|
|
|
|
* which we read from the superblock. If the UUIDs don't match, then we've got a
|
|
|
|
* stale metadata block from an old filesystem instance that we need to recover
|
|
|
|
* over the top of.
|
2013-08-28 05:22:47 -06:00
|
|
|
*/
|
|
|
|
static xfs_lsn_t
|
|
|
|
xlog_recover_get_buf_lsn(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
2017-06-16 12:00:05 -06:00
|
|
|
uint32_t magic32;
|
|
|
|
uint16_t magic16;
|
|
|
|
uint16_t magicda;
|
2013-08-28 05:22:47 -06:00
|
|
|
void *blk = bp->b_addr;
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
uuid_t *uuid;
|
|
|
|
xfs_lsn_t lsn = -1;
|
2013-08-28 05:22:47 -06:00
|
|
|
|
|
|
|
/* v4 filesystems always recover immediately */
|
|
|
|
if (!xfs_sb_version_hascrc(&mp->m_sb))
|
|
|
|
goto recover_immediately;
|
|
|
|
|
|
|
|
magic32 = be32_to_cpu(*(__be32 *)blk);
|
|
|
|
switch (magic32) {
|
|
|
|
case XFS_ABTB_CRC_MAGIC:
|
|
|
|
case XFS_ABTC_CRC_MAGIC:
|
|
|
|
case XFS_ABTB_MAGIC:
|
|
|
|
case XFS_ABTC_MAGIC:
|
2016-08-02 20:17:11 -06:00
|
|
|
case XFS_RMAP_CRC_MAGIC:
|
2016-10-03 10:11:23 -06:00
|
|
|
case XFS_REFC_CRC_MAGIC:
|
2013-08-28 05:22:47 -06:00
|
|
|
case XFS_IBT_CRC_MAGIC:
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
case XFS_IBT_MAGIC: {
|
|
|
|
struct xfs_btree_block *btb = blk;
|
|
|
|
|
|
|
|
lsn = be64_to_cpu(btb->bb_u.s.bb_lsn);
|
|
|
|
uuid = &btb->bb_u.s.bb_uuid;
|
|
|
|
break;
|
|
|
|
}
|
2013-08-28 05:22:47 -06:00
|
|
|
case XFS_BMAP_CRC_MAGIC:
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
case XFS_BMAP_MAGIC: {
|
|
|
|
struct xfs_btree_block *btb = blk;
|
|
|
|
|
|
|
|
lsn = be64_to_cpu(btb->bb_u.l.bb_lsn);
|
|
|
|
uuid = &btb->bb_u.l.bb_uuid;
|
|
|
|
break;
|
|
|
|
}
|
2013-08-28 05:22:47 -06:00
|
|
|
case XFS_AGF_MAGIC:
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
lsn = be64_to_cpu(((struct xfs_agf *)blk)->agf_lsn);
|
|
|
|
uuid = &((struct xfs_agf *)blk)->agf_uuid;
|
|
|
|
break;
|
2013-08-28 05:22:47 -06:00
|
|
|
case XFS_AGFL_MAGIC:
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
lsn = be64_to_cpu(((struct xfs_agfl *)blk)->agfl_lsn);
|
|
|
|
uuid = &((struct xfs_agfl *)blk)->agfl_uuid;
|
|
|
|
break;
|
2013-08-28 05:22:47 -06:00
|
|
|
case XFS_AGI_MAGIC:
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
lsn = be64_to_cpu(((struct xfs_agi *)blk)->agi_lsn);
|
|
|
|
uuid = &((struct xfs_agi *)blk)->agi_uuid;
|
|
|
|
break;
|
2013-08-28 05:22:47 -06:00
|
|
|
case XFS_SYMLINK_MAGIC:
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
lsn = be64_to_cpu(((struct xfs_dsymlink_hdr *)blk)->sl_lsn);
|
|
|
|
uuid = &((struct xfs_dsymlink_hdr *)blk)->sl_uuid;
|
|
|
|
break;
|
2013-08-28 05:22:47 -06:00
|
|
|
case XFS_DIR3_BLOCK_MAGIC:
|
|
|
|
case XFS_DIR3_DATA_MAGIC:
|
|
|
|
case XFS_DIR3_FREE_MAGIC:
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
lsn = be64_to_cpu(((struct xfs_dir3_blk_hdr *)blk)->lsn);
|
|
|
|
uuid = &((struct xfs_dir3_blk_hdr *)blk)->uuid;
|
|
|
|
break;
|
2013-08-28 05:22:47 -06:00
|
|
|
case XFS_ATTR3_RMT_MAGIC:
|
xfs: remote attribute headers contain an invalid LSN
In recent testing, a system that crashed failed log recovery on
restart with a bad symlink buffer magic number:
XFS (vda): Starting recovery (logdev: internal)
XFS (vda): Bad symlink block magic!
XFS: Assertion failed: 0, file: fs/xfs/xfs_log_recover.c, line: 2060
On examination of the log via xfs_logprint, none of the symlink
buffers in the log had a bad magic number, nor were any other types
of buffer log format headers mis-identified as symlink buffers.
Tracing was used to find the buffer the kernel was tripping over,
and xfs_db identified it's contents as:
000: 5841524d 00000000 00000346 64d82b48 8983e692 d71e4680 a5f49e2c b317576e
020: 00000000 00602038 00000000 006034ce d0020000 00000000 4d4d4d4d 4d4d4d4d
040: 4d4d4d4d 4d4d4d4d 4d4d4d4d 4d4d4d4d 4d4d4d4d 4d4d4d4d 4d4d4d4d 4d4d4d4d
060: 4d4d4d4d 4d4d4d4d 4d4d4d4d 4d4d4d4d 4d4d4d4d 4d4d4d4d 4d4d4d4d 4d4d4d4d
.....
This is a remote attribute buffer, which are notable in that they
are not logged but are instead written synchronously by the remote
attribute code so that they exist on disk before the attribute
transactions are committed to the journal.
The above remote attribute block has an invalid LSN in it - cycle
0xd002000, block 0 - which means when log recovery comes along to
determine if the transaction that writes to the underlying block
should be replayed, it sees a block that has a future LSN and so
does not replay the buffer data in the transaction. Instead, it
validates the buffer magic number and attaches the buffer verifier
to it. It is this buffer magic number check that is failing in the
above assert, indicating that we skipped replay due to the LSN of
the underlying buffer.
The problem here is that the remote attribute buffers cannot have a
valid LSN placed into them, because the transaction that contains
the attribute tree pointer changes and the block allocation that the
attribute data is being written to hasn't yet been committed. Hence
the LSN field in the attribute block is completely unwritten,
thereby leaving the underlying contents of the block in the LSN
field. It could have any value, and hence a future overwrite of the
block by log recovery may or may not work correctly.
Fix this by always writing an invalid LSN to the remote attribute
block, as any buffer in log recovery that needs to write over the
remote attribute should occur. We are protected from having old data
written over the attribute by the fact that freeing the block before
the remote attribute is written will result in the buffer being
marked stale in the log and so all changes prior to the buffer stale
transaction will be cancelled by log recovery.
Hence it is safe to ignore the LSN in the case or synchronously
written, unlogged metadata such as remote attribute blocks, and to
ensure we do that correctly, we need to write an invalid LSN to all
remote attribute blocks to trigger immediate recovery of metadata
that is written over the top.
As a further protection for filesystems that may already have remote
attribute blocks with bad LSNs on disk, change the log recovery code
to always trigger immediate recovery of metadata over remote
attribute blocks.
cc: <stable@vger.kernel.org>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-07-28 19:48:01 -06:00
|
|
|
/*
|
|
|
|
* Remote attr blocks are written synchronously, rather than
|
|
|
|
* being logged. That means they do not contain a valid LSN
|
|
|
|
* (i.e. transactionally ordered) in them, and hence any time we
|
|
|
|
* see a buffer to replay over the top of a remote attribute
|
|
|
|
* block we should simply do so.
|
|
|
|
*/
|
|
|
|
goto recover_immediately;
|
2013-08-28 05:22:47 -06:00
|
|
|
case XFS_SB_MAGIC:
|
2015-08-18 18:31:54 -06:00
|
|
|
/*
|
|
|
|
* superblock uuids are magic. We may or may not have a
|
|
|
|
* sb_meta_uuid on disk, but it will be set in the in-core
|
|
|
|
* superblock. We set the uuid pointer for verification
|
|
|
|
* according to the superblock feature mask to ensure we check
|
|
|
|
* the relevant UUID in the superblock.
|
|
|
|
*/
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
lsn = be64_to_cpu(((struct xfs_dsb *)blk)->sb_lsn);
|
2015-08-18 18:31:54 -06:00
|
|
|
if (xfs_sb_version_hasmetauuid(&mp->m_sb))
|
|
|
|
uuid = &((struct xfs_dsb *)blk)->sb_meta_uuid;
|
|
|
|
else
|
|
|
|
uuid = &((struct xfs_dsb *)blk)->sb_uuid;
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
break;
|
2013-08-28 05:22:47 -06:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
if (lsn != (xfs_lsn_t)-1) {
|
2015-08-18 18:31:54 -06:00
|
|
|
if (!uuid_equal(&mp->m_sb.sb_meta_uuid, uuid))
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
goto recover_immediately;
|
|
|
|
return lsn;
|
|
|
|
}
|
|
|
|
|
2013-08-28 05:22:47 -06:00
|
|
|
magicda = be16_to_cpu(((struct xfs_da_blkinfo *)blk)->magic);
|
|
|
|
switch (magicda) {
|
|
|
|
case XFS_DIR3_LEAF1_MAGIC:
|
|
|
|
case XFS_DIR3_LEAFN_MAGIC:
|
|
|
|
case XFS_DA3_NODE_MAGIC:
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
lsn = be64_to_cpu(((struct xfs_da3_blkinfo *)blk)->lsn);
|
|
|
|
uuid = &((struct xfs_da3_blkinfo *)blk)->uuid;
|
|
|
|
break;
|
2013-08-28 05:22:47 -06:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
xfs: log recovery lsn ordering needs uuid check
After a fair number of xfstests runs, xfs/182 started to fail
regularly with a corrupted directory - a directory read verifier was
failing after recovery because it found a block with a XARM magic
number (remote attribute block) rather than a directory data block.
The first time I saw this repeated failure I did /something/ and the
problem went away, so I was never able to find the underlying
problem. Test xfs/182 failed again today, and I found the root
cause before I did /something else/ that made it go away.
Tracing indicated that the block in question was being correctly
logged, the log was being flushed by sync, but the buffer was not
being written back before the shutdown occurred. Tracing also
indicated that log recovery was also reading the block, but then
never writing it before log recovery invalidated the cache,
indicating that it was not modified by log recovery.
More detailed analysis of the corpse indicated that the filesystem
had a uuid of "a4131074-1872-4cac-9323-2229adbcb886" but the XARM
block had a uuid of "8f32f043-c3c9-e7f8-f947-4e7f989c05d3", which
indicated it was a block from an older filesystem. The reason that
log recovery didn't replay it was that the LSN in the XARM block was
larger than the LSN of the transaction being replayed, and so the
block was not overwritten by log recovery.
Hence, log recovery cant blindly trust the magic number and LSN in
the block - it must verify that it belongs to the filesystem being
recovered before using the LSN. i.e. if the UUIDs don't match, we
need to unconditionally recovery the change held in the log.
This patch was first tested on a block device that was repeatedly
causing xfs/182 to fail with the same failure on the same block with
the same directory read corruption signature (i.e. XARM block). It
did not fail, and hasn't failed since.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-09-24 00:01:16 -06:00
|
|
|
if (lsn != (xfs_lsn_t)-1) {
|
|
|
|
if (!uuid_equal(&mp->m_sb.sb_uuid, uuid))
|
|
|
|
goto recover_immediately;
|
|
|
|
return lsn;
|
|
|
|
}
|
|
|
|
|
2013-08-28 05:22:47 -06:00
|
|
|
/*
|
|
|
|
* We do individual object checks on dquot and inode buffers as they
|
|
|
|
* have their own individual LSN records. Also, we could have a stale
|
|
|
|
* buffer here, so we have to at least recognise these buffer types.
|
|
|
|
*
|
|
|
|
* A notd complexity here is inode unlinked list processing - it logs
|
|
|
|
* the inode directly in the buffer, but we don't know which inodes have
|
|
|
|
* been modified, and there is no global buffer LSN. Hence we need to
|
|
|
|
* recover all inode buffer types immediately. This problem will be
|
|
|
|
* fixed by logical logging of the unlinked list modifications.
|
|
|
|
*/
|
|
|
|
magic16 = be16_to_cpu(*(__be16 *)blk);
|
|
|
|
switch (magic16) {
|
|
|
|
case XFS_DQUOT_MAGIC:
|
|
|
|
case XFS_DINODE_MAGIC:
|
|
|
|
goto recover_immediately;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* unknown buffer contents, recover immediately */
|
|
|
|
|
|
|
|
recover_immediately:
|
|
|
|
return (xfs_lsn_t)-1;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2013-04-02 23:11:29 -06:00
|
|
|
* Validate the recovered buffer is of the correct type and attach the
|
|
|
|
* appropriate buffer operations to them for writeback. Magic numbers are in a
|
|
|
|
* few places:
|
|
|
|
* the first 16 bits of the buffer (inode buffer, dquot buffer),
|
|
|
|
* the first 32 bits of the buffer (most blocks),
|
|
|
|
* inside a struct xfs_da_blkinfo at the start of the buffer.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2013-04-02 23:11:29 -06:00
|
|
|
static void
|
2013-08-28 05:22:47 -06:00
|
|
|
xlog_recover_validate_buf_type(
|
2010-04-12 23:06:46 -06:00
|
|
|
struct xfs_mount *mp,
|
2010-12-01 15:06:21 -07:00
|
|
|
struct xfs_buf *bp,
|
2016-09-25 16:32:07 -06:00
|
|
|
xfs_buf_log_format_t *buf_f,
|
|
|
|
xfs_lsn_t current_lsn)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-04-02 23:11:29 -06:00
|
|
|
struct xfs_da_blkinfo *info = bp->b_addr;
|
2017-06-16 12:00:05 -06:00
|
|
|
uint32_t magic32;
|
|
|
|
uint16_t magic16;
|
|
|
|
uint16_t magicda;
|
2016-09-25 16:32:50 -06:00
|
|
|
char *warnmsg = NULL;
|
2013-04-02 23:11:29 -06:00
|
|
|
|
2014-08-03 20:43:06 -06:00
|
|
|
/*
|
|
|
|
* We can only do post recovery validation on items on CRC enabled
|
|
|
|
* fielsystems as we need to know when the buffer was written to be able
|
|
|
|
* to determine if we should have replayed the item. If we replay old
|
|
|
|
* metadata over a newer buffer, then it will enter a temporarily
|
|
|
|
* inconsistent state resulting in verification failures. Hence for now
|
|
|
|
* just avoid the verification stage for non-crc filesystems
|
|
|
|
*/
|
|
|
|
if (!xfs_sb_version_hascrc(&mp->m_sb))
|
|
|
|
return;
|
|
|
|
|
2013-04-02 23:11:29 -06:00
|
|
|
magic32 = be32_to_cpu(*(__be32 *)bp->b_addr);
|
|
|
|
magic16 = be16_to_cpu(*(__be16*)bp->b_addr);
|
|
|
|
magicda = be16_to_cpu(info->magic);
|
2013-04-02 23:11:30 -06:00
|
|
|
switch (xfs_blft_from_flags(buf_f)) {
|
|
|
|
case XFS_BLFT_BTREE_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
switch (magic32) {
|
2013-04-21 13:53:46 -06:00
|
|
|
case XFS_ABTB_CRC_MAGIC:
|
|
|
|
case XFS_ABTC_CRC_MAGIC:
|
|
|
|
case XFS_ABTB_MAGIC:
|
|
|
|
case XFS_ABTC_MAGIC:
|
|
|
|
bp->b_ops = &xfs_allocbt_buf_ops;
|
|
|
|
break;
|
|
|
|
case XFS_IBT_CRC_MAGIC:
|
2014-04-24 00:00:52 -06:00
|
|
|
case XFS_FIBT_CRC_MAGIC:
|
2013-04-21 13:53:46 -06:00
|
|
|
case XFS_IBT_MAGIC:
|
2014-04-24 00:00:52 -06:00
|
|
|
case XFS_FIBT_MAGIC:
|
2013-04-21 13:53:46 -06:00
|
|
|
bp->b_ops = &xfs_inobt_buf_ops;
|
|
|
|
break;
|
|
|
|
case XFS_BMAP_CRC_MAGIC:
|
|
|
|
case XFS_BMAP_MAGIC:
|
|
|
|
bp->b_ops = &xfs_bmbt_buf_ops;
|
|
|
|
break;
|
2016-08-02 20:17:11 -06:00
|
|
|
case XFS_RMAP_CRC_MAGIC:
|
|
|
|
bp->b_ops = &xfs_rmapbt_buf_ops;
|
|
|
|
break;
|
2016-10-03 10:11:23 -06:00
|
|
|
case XFS_REFC_CRC_MAGIC:
|
|
|
|
bp->b_ops = &xfs_refcountbt_buf_ops;
|
|
|
|
break;
|
2013-04-21 13:53:46 -06:00
|
|
|
default:
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad btree block magic!";
|
2013-04-21 13:53:46 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_AGF_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magic32 != XFS_AGF_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad AGF block magic!";
|
2013-04-02 23:11:13 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_agf_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_AGFL_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magic32 != XFS_AGFL_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad AGFL block magic!";
|
2013-04-02 23:11:14 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_agfl_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_AGI_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magic32 != XFS_AGI_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad AGI block magic!";
|
2013-04-02 23:11:15 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_agi_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_UDQUOT_BUF:
|
|
|
|
case XFS_BLFT_PDQUOT_BUF:
|
|
|
|
case XFS_BLFT_GDQUOT_BUF:
|
2013-04-30 05:39:33 -06:00
|
|
|
#ifdef CONFIG_XFS_QUOTA
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magic16 != XFS_DQUOT_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad DQUOT block magic!";
|
2013-04-02 23:11:16 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_dquot_buf_ops;
|
2013-04-30 05:39:33 -06:00
|
|
|
#else
|
|
|
|
xfs_alert(mp,
|
|
|
|
"Trying to recover dquots without QUOTA support built in!");
|
|
|
|
ASSERT(0);
|
|
|
|
#endif
|
2013-04-02 23:11:16 -06:00
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_DINO_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magic16 != XFS_DINODE_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad INODE block magic!";
|
2013-04-02 23:11:17 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_inode_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_SYMLINK_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magic32 != XFS_SYMLINK_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad symlink block magic!";
|
2013-04-02 23:11:19 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_symlink_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_DIR_BLOCK_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magic32 != XFS_DIR2_BLOCK_MAGIC &&
|
|
|
|
magic32 != XFS_DIR3_BLOCK_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad dir block magic!";
|
2013-04-02 23:11:29 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_dir3_block_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_DIR_DATA_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magic32 != XFS_DIR2_DATA_MAGIC &&
|
|
|
|
magic32 != XFS_DIR3_DATA_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad dir data magic!";
|
2013-04-02 23:11:29 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_dir3_data_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_DIR_FREE_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magic32 != XFS_DIR2_FREE_MAGIC &&
|
|
|
|
magic32 != XFS_DIR3_FREE_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad dir3 free magic!";
|
2013-04-02 23:11:29 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_dir3_free_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_DIR_LEAF1_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magicda != XFS_DIR2_LEAF1_MAGIC &&
|
|
|
|
magicda != XFS_DIR3_LEAF1_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad dir leaf1 magic!";
|
2013-04-02 23:11:29 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_dir3_leaf1_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_DIR_LEAFN_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magicda != XFS_DIR2_LEAFN_MAGIC &&
|
|
|
|
magicda != XFS_DIR3_LEAFN_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad dir leafn magic!";
|
2013-04-02 23:11:29 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_dir3_leafn_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_DA_NODE_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magicda != XFS_DA_NODE_MAGIC &&
|
|
|
|
magicda != XFS_DA3_NODE_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad da node magic!";
|
2013-04-02 23:11:29 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_da3_node_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_ATTR_LEAF_BUF:
|
2013-04-02 23:11:29 -06:00
|
|
|
if (magicda != XFS_ATTR_LEAF_MAGIC &&
|
|
|
|
magicda != XFS_ATTR3_LEAF_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad attr leaf magic!";
|
2013-04-02 23:11:29 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_attr3_leaf_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:30 -06:00
|
|
|
case XFS_BLFT_ATTR_RMT_BUF:
|
2013-04-30 05:39:36 -06:00
|
|
|
if (magic32 != XFS_ATTR3_RMT_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad attr remote magic!";
|
2013-04-02 23:11:29 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_attr3_rmt_buf_ops;
|
|
|
|
break;
|
2013-04-02 23:11:31 -06:00
|
|
|
case XFS_BLFT_SB_BUF:
|
|
|
|
if (magic32 != XFS_SB_MAGIC) {
|
2016-09-25 16:32:50 -06:00
|
|
|
warnmsg = "Bad SB block magic!";
|
2013-04-02 23:11:31 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bp->b_ops = &xfs_sb_buf_ops;
|
|
|
|
break;
|
2016-02-08 22:41:31 -07:00
|
|
|
#ifdef CONFIG_XFS_RT
|
|
|
|
case XFS_BLFT_RTBITMAP_BUF:
|
|
|
|
case XFS_BLFT_RTSUMMARY_BUF:
|
2016-02-08 22:41:45 -07:00
|
|
|
/* no magic numbers for verification of RT buffers */
|
|
|
|
bp->b_ops = &xfs_rtbuf_ops;
|
2016-02-08 22:41:31 -07:00
|
|
|
break;
|
|
|
|
#endif /* CONFIG_XFS_RT */
|
2013-04-21 13:53:46 -06:00
|
|
|
default:
|
2013-04-02 23:11:30 -06:00
|
|
|
xfs_warn(mp, "Unknown buffer type %d!",
|
|
|
|
xfs_blft_from_flags(buf_f));
|
2013-04-21 13:53:46 -06:00
|
|
|
break;
|
|
|
|
}
|
2016-09-25 16:32:50 -06:00
|
|
|
|
|
|
|
/*
|
xfs: update metadata LSN in buffers during log recovery
Log recovery is currently broken for v5 superblocks in that it never
updates the metadata LSN of buffers written out during recovery. The
metadata LSN is recorded in various bits of metadata to provide recovery
ordering criteria that prevents transient corruption states reported by
buffer write verifiers. Without such ordering logic, buffer updates can
be replayed out of order and lead to false positive transient corruption
states. This is generally not a corruption vector on its own, but
corruption detection shuts down the filesystem and ultimately prevents a
mount if it occurs during log recovery. This requires an xfs_repair run
that clears the log and potentially loses filesystem updates.
This problem is avoided in most cases as metadata writes during normal
filesystem operation update the metadata LSN appropriately. The problem
with log recovery not updating metadata LSNs manifests if the system
happens to crash shortly after log recovery itself. In this scenario, it
is possible for log recovery to complete all metadata I/O such that the
filesystem is consistent. If a crash occurs after that point but before
the log tail is pushed forward by subsequent operations, however, the
next mount performs the same log recovery over again. If a buffer is
updated multiple times in the dirty range of the log, an earlier update
in the log might not be valid based on the current state of the
associated buffer after all of the updates in the log had been replayed
(before the previous crash). If a verifier happens to detect such a
problem, the filesystem claims corruption and immediately shuts down.
This commonly manifests in practice as directory block verifier failures
such as the following, likely due to directory verifiers being
particularly detailed in their checks as compared to most others:
...
Mounting V5 Filesystem
XFS (dm-0): Starting recovery (logdev: internal)
XFS (dm-0): Internal error XFS_WANT_CORRUPTED_RETURN at line ... of \
file fs/xfs/libxfs/xfs_dir2_data.c. Caller xfs_dir3_data_verify ...
...
Update log recovery to update the metadata LSN of recovered buffers.
Since metadata LSNs are already updated by write verifer functions via
attached log items, attach a dummy log item to the buffer during
validation and explicitly set the LSN of the current transaction. This
ensures that the metadata LSN of a buffer is updated based on whether
the recovery I/O actually completes, and if so, that subsequent recovery
attempts identify that the buffer is already up to date with respect to
the current transaction.
Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-09-25 16:34:27 -06:00
|
|
|
* Nothing else to do in the case of a NULL current LSN as this means
|
|
|
|
* the buffer is more recent than the change in the log and will be
|
|
|
|
* skipped.
|
2016-09-25 16:32:50 -06:00
|
|
|
*/
|
xfs: update metadata LSN in buffers during log recovery
Log recovery is currently broken for v5 superblocks in that it never
updates the metadata LSN of buffers written out during recovery. The
metadata LSN is recorded in various bits of metadata to provide recovery
ordering criteria that prevents transient corruption states reported by
buffer write verifiers. Without such ordering logic, buffer updates can
be replayed out of order and lead to false positive transient corruption
states. This is generally not a corruption vector on its own, but
corruption detection shuts down the filesystem and ultimately prevents a
mount if it occurs during log recovery. This requires an xfs_repair run
that clears the log and potentially loses filesystem updates.
This problem is avoided in most cases as metadata writes during normal
filesystem operation update the metadata LSN appropriately. The problem
with log recovery not updating metadata LSNs manifests if the system
happens to crash shortly after log recovery itself. In this scenario, it
is possible for log recovery to complete all metadata I/O such that the
filesystem is consistent. If a crash occurs after that point but before
the log tail is pushed forward by subsequent operations, however, the
next mount performs the same log recovery over again. If a buffer is
updated multiple times in the dirty range of the log, an earlier update
in the log might not be valid based on the current state of the
associated buffer after all of the updates in the log had been replayed
(before the previous crash). If a verifier happens to detect such a
problem, the filesystem claims corruption and immediately shuts down.
This commonly manifests in practice as directory block verifier failures
such as the following, likely due to directory verifiers being
particularly detailed in their checks as compared to most others:
...
Mounting V5 Filesystem
XFS (dm-0): Starting recovery (logdev: internal)
XFS (dm-0): Internal error XFS_WANT_CORRUPTED_RETURN at line ... of \
file fs/xfs/libxfs/xfs_dir2_data.c. Caller xfs_dir3_data_verify ...
...
Update log recovery to update the metadata LSN of recovered buffers.
Since metadata LSNs are already updated by write verifer functions via
attached log items, attach a dummy log item to the buffer during
validation and explicitly set the LSN of the current transaction. This
ensures that the metadata LSN of a buffer is updated based on whether
the recovery I/O actually completes, and if so, that subsequent recovery
attempts identify that the buffer is already up to date with respect to
the current transaction.
Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-09-25 16:34:27 -06:00
|
|
|
if (current_lsn == NULLCOMMITLSN)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (warnmsg) {
|
2016-09-25 16:32:50 -06:00
|
|
|
xfs_warn(mp, warnmsg);
|
|
|
|
ASSERT(0);
|
|
|
|
}
|
xfs: update metadata LSN in buffers during log recovery
Log recovery is currently broken for v5 superblocks in that it never
updates the metadata LSN of buffers written out during recovery. The
metadata LSN is recorded in various bits of metadata to provide recovery
ordering criteria that prevents transient corruption states reported by
buffer write verifiers. Without such ordering logic, buffer updates can
be replayed out of order and lead to false positive transient corruption
states. This is generally not a corruption vector on its own, but
corruption detection shuts down the filesystem and ultimately prevents a
mount if it occurs during log recovery. This requires an xfs_repair run
that clears the log and potentially loses filesystem updates.
This problem is avoided in most cases as metadata writes during normal
filesystem operation update the metadata LSN appropriately. The problem
with log recovery not updating metadata LSNs manifests if the system
happens to crash shortly after log recovery itself. In this scenario, it
is possible for log recovery to complete all metadata I/O such that the
filesystem is consistent. If a crash occurs after that point but before
the log tail is pushed forward by subsequent operations, however, the
next mount performs the same log recovery over again. If a buffer is
updated multiple times in the dirty range of the log, an earlier update
in the log might not be valid based on the current state of the
associated buffer after all of the updates in the log had been replayed
(before the previous crash). If a verifier happens to detect such a
problem, the filesystem claims corruption and immediately shuts down.
This commonly manifests in practice as directory block verifier failures
such as the following, likely due to directory verifiers being
particularly detailed in their checks as compared to most others:
...
Mounting V5 Filesystem
XFS (dm-0): Starting recovery (logdev: internal)
XFS (dm-0): Internal error XFS_WANT_CORRUPTED_RETURN at line ... of \
file fs/xfs/libxfs/xfs_dir2_data.c. Caller xfs_dir3_data_verify ...
...
Update log recovery to update the metadata LSN of recovered buffers.
Since metadata LSNs are already updated by write verifer functions via
attached log items, attach a dummy log item to the buffer during
validation and explicitly set the LSN of the current transaction. This
ensures that the metadata LSN of a buffer is updated based on whether
the recovery I/O actually completes, and if so, that subsequent recovery
attempts identify that the buffer is already up to date with respect to
the current transaction.
Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-09-25 16:34:27 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We must update the metadata LSN of the buffer as it is written out to
|
|
|
|
* ensure that older transactions never replay over this one and corrupt
|
|
|
|
* the buffer. This can occur if log recovery is interrupted at some
|
|
|
|
* point after the current transaction completes, at which point a
|
|
|
|
* subsequent mount starts recovery from the beginning.
|
|
|
|
*
|
|
|
|
* Write verifiers update the metadata LSN from log items attached to
|
|
|
|
* the buffer. Therefore, initialize a bli purely to carry the LSN to
|
|
|
|
* the verifier. We'll clean it up in our ->iodone() callback.
|
|
|
|
*/
|
|
|
|
if (bp->b_ops) {
|
|
|
|
struct xfs_buf_log_item *bip;
|
|
|
|
|
|
|
|
ASSERT(!bp->b_iodone || bp->b_iodone == xlog_recover_iodone);
|
|
|
|
bp->b_iodone = xlog_recover_iodone;
|
|
|
|
xfs_buf_item_init(bp, mp);
|
|
|
|
bip = bp->b_fspriv;
|
|
|
|
bip->bli_item.li_lsn = current_lsn;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-04-02 23:11:29 -06:00
|
|
|
/*
|
|
|
|
* Perform a 'normal' buffer recovery. Each logged region of the
|
|
|
|
* buffer should be copied over the corresponding region in the
|
|
|
|
* given buffer. The bitmap in the buf log format structure indicates
|
|
|
|
* where to place the logged data.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_do_reg_buffer(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xlog_recover_item_t *item,
|
|
|
|
struct xfs_buf *bp,
|
2016-09-25 16:32:07 -06:00
|
|
|
xfs_buf_log_format_t *buf_f,
|
|
|
|
xfs_lsn_t current_lsn)
|
2013-04-02 23:11:29 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int bit;
|
|
|
|
int nbits;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
trace_xfs_log_recover_buf_reg_buf(mp->m_log, buf_f);
|
|
|
|
|
|
|
|
bit = 0;
|
|
|
|
i = 1; /* 0 is the buf format structure */
|
|
|
|
while (1) {
|
|
|
|
bit = xfs_next_bit(buf_f->blf_data_map,
|
|
|
|
buf_f->blf_map_size, bit);
|
|
|
|
if (bit == -1)
|
|
|
|
break;
|
|
|
|
nbits = xfs_contig_bits(buf_f->blf_data_map,
|
|
|
|
buf_f->blf_map_size, bit);
|
|
|
|
ASSERT(nbits > 0);
|
|
|
|
ASSERT(item->ri_buf[i].i_addr != NULL);
|
|
|
|
ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0);
|
|
|
|
ASSERT(BBTOB(bp->b_io_length) >=
|
|
|
|
((uint)bit << XFS_BLF_SHIFT) + (nbits << XFS_BLF_SHIFT));
|
|
|
|
|
xfs: fix split buffer vector log recovery support
A long time ago in a galaxy far away....
.. the was a commit made to fix some ilinux specific "fragmented
buffer" log recovery problem:
http://oss.sgi.com/cgi-bin/gitweb.cgi?p=archive/xfs-import.git;a=commitdiff;h=b29c0bece51da72fb3ff3b61391a391ea54e1603
That problem occurred when a contiguous dirty region of a buffer was
split across across two pages of an unmapped buffer. It's been a
long time since that has been done in XFS, and the changes to log
the entire inode buffers for CRC enabled filesystems has
re-introduced that corner case.
And, of course, it turns out that the above commit didn't actually
fix anything - it just ensured that log recovery is guaranteed to
fail when this situation occurs. And now for the gory details.
xfstest xfs/085 is failing with this assert:
XFS (vdb): bad number of regions (0) in inode log format
XFS: Assertion failed: 0, file: fs/xfs/xfs_log_recover.c, line: 1583
Largely undocumented factoid #1: Log recovery depends on all log
buffer format items starting with this format:
struct foo_log_format {
__uint16_t type;
__uint16_t size;
....
As recoery uses the size field and assumptions about 32 bit
alignment in decoding format items. So don't pay much attention to
the fact log recovery thinks that it decoding an inode log format
item - it just uses them to determine what the size of the item is.
But why would it see a log format item with a zero size? Well,
luckily enough xfs_logprint uses the same code and gives the same
error, so with a bit of gdb magic, it turns out that it isn't a log
format that is being decoded. What logprint tells us is this:
Oper (130): tid: a0375e1a len: 28 clientid: TRANS flags: none
BUF: #regs: 2 start blkno: 144 (0x90) len: 16 bmap size: 2 flags: 0x4000
Oper (131): tid: a0375e1a len: 4096 clientid: TRANS flags: none
BUF DATA
----------------------------------------------------------------------------
Oper (132): tid: a0375e1a len: 4096 clientid: TRANS flags: none
xfs_logprint: unknown log operation type (4e49)
**********************************************************************
* ERROR: data block=2 *
**********************************************************************
That we've got a buffer format item (oper 130) that has two regions;
the format item itself and one dirty region. The subsequent region
after the buffer format item and it's data is them what we are
tripping over, and the first bytes of it at an inode magic number.
Not a log opheader like there is supposed to be.
That means there's a problem with the buffer format item. It's dirty
data region is 4096 bytes, and it contains - you guessed it -
initialised inodes. But inode buffers are 8k, not 4k, and we log
them in their entirety. So something is wrong here. The buffer
format item contains:
(gdb) p /x *(struct xfs_buf_log_format *)in_f
$22 = {blf_type = 0x123c, blf_size = 0x2, blf_flags = 0x4000,
blf_len = 0x10, blf_blkno = 0x90, blf_map_size = 0x2,
blf_data_map = {0xffffffff, 0xffffffff, .... }}
Two regions, and a signle dirty contiguous region of 64 bits. 64 *
128 = 8k, so this should be followed by a single 8k region of data.
And the blf_flags tell us that the type of buffer is a
XFS_BLFT_DINO_BUF. It contains inodes. And because it doesn't have
the XFS_BLF_INODE_BUF flag set, that means it's an inode allocation
buffer. So, it should be followed by 8k of inode data.
But we know that the next region has a header of:
(gdb) p /x *ohead
$25 = {oh_tid = 0x1a5e37a0, oh_len = 0x100000, oh_clientid = 0x69,
oh_flags = 0x0, oh_res2 = 0x0}
and so be32_to_cpu(oh_len) = 0x1000 = 4096 bytes. It's simply not
long enough to hold all the logged data. There must be another
region. There is - there's a following opheader for another 4k of
data that contains the other half of the inode cluster data - the
one we assert fail on because it's not a log format header.
So why is the second part of the data not being accounted to the
correct buffer log format structure? It took a little more work with
gdb to work out that the buffer log format structure was both
expecting it to be there but hadn't accounted for it. It was at that
point I went to the kernel code, as clearly this wasn't a bug in
xfs_logprint and the kernel was writing bad stuff to the log.
First port of call was the buffer item formatting code, and the
discontiguous memory/contiguous dirty region handling code
immediately stood out. I've wondered for a long time why the code
had this comment in it:
vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
vecp->i_len = nbits * XFS_BLF_CHUNK;
vecp->i_type = XLOG_REG_TYPE_BCHUNK;
/*
* You would think we need to bump the nvecs here too, but we do not
* this number is used by recovery, and it gets confused by the boundary
* split here
* nvecs++;
*/
vecp++;
And it didn't account for the extra vector pointer. The case being
handled here is that a contiguous dirty region lies across a
boundary that cannot be memcpy()d across, and so has to be split
into two separate operations for xlog_write() to perform.
What this code assumes is that what is written to the log is two
consecutive blocks of data that are accounted in the buf log format
item as the same contiguous dirty region and so will get decoded as
such by the log recovery code.
The thing is, xlog_write() knows nothing about this, and so just
does it's normal thing of adding an opheader for each vector. That
means the 8k region gets written to the log as two separate regions
of 4k each, but because nvecs has not been incremented, the buf log
format item accounts for only one of them.
Hence when we come to log recovery, we process the first 4k region
and then expect to come across a new item that starts with a log
format structure of some kind that tells us whenteh next data is
going to be. Instead, we hit raw buffer data and things go bad real
quick.
So, the commit from 2002 that commented out nvecs++ is just plain
wrong. It breaks log recovery completely, and it would seem the only
reason this hasn't been since then is that we don't log large
contigous regions of multi-page unmapped buffers very often. Never
would be a closer estimate, at least until the CRC code came along....
So, lets fix that by restoring the nvecs accounting for the extra
region when we hit this case.....
.... and there's the problemin log recovery it is apparently working
around:
XFS: Assertion failed: i == item->ri_total, file: fs/xfs/xfs_log_recover.c, line: 2135
Yup, xlog_recover_do_reg_buffer() doesn't handle contigous dirty
regions being broken up into multiple regions by the log formatting
code. That's an easy fix, though - if the number of contiguous dirty
bits exceeds the length of the region being copied out of the log,
only account for the number of dirty bits that region covers, and
then loop again and copy more from the next region. It's a 2 line
fix.
Now xfstests xfs/085 passes, we have one less piece of mystery
code, and one more important piece of knowledge about how to
structure new log format items..
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-05-27 00:38:23 -06:00
|
|
|
/*
|
|
|
|
* The dirty regions logged in the buffer, even though
|
|
|
|
* contiguous, may span multiple chunks. This is because the
|
|
|
|
* dirty region may span a physical page boundary in a buffer
|
|
|
|
* and hence be split into two separate vectors for writing into
|
|
|
|
* the log. Hence we need to trim nbits back to the length of
|
|
|
|
* the current region being copied out of the log.
|
|
|
|
*/
|
|
|
|
if (item->ri_buf[i].i_len < (nbits << XFS_BLF_SHIFT))
|
|
|
|
nbits = item->ri_buf[i].i_len >> XFS_BLF_SHIFT;
|
|
|
|
|
2013-04-02 23:11:29 -06:00
|
|
|
/*
|
|
|
|
* Do a sanity check if this is a dquot buffer. Just checking
|
|
|
|
* the first dquot in the buffer should do. XXXThis is
|
|
|
|
* probably a good thing to do for other buf types also.
|
|
|
|
*/
|
|
|
|
error = 0;
|
|
|
|
if (buf_f->blf_flags &
|
|
|
|
(XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
|
|
|
|
if (item->ri_buf[i].i_addr == NULL) {
|
|
|
|
xfs_alert(mp,
|
|
|
|
"XFS: NULL dquot in %s.", __func__);
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
if (item->ri_buf[i].i_len < sizeof(xfs_disk_dquot_t)) {
|
|
|
|
xfs_alert(mp,
|
|
|
|
"XFS: dquot too small (%d) in %s.",
|
|
|
|
item->ri_buf[i].i_len, __func__);
|
|
|
|
goto next;
|
|
|
|
}
|
2013-10-14 16:17:52 -06:00
|
|
|
error = xfs_dqcheck(mp, item->ri_buf[i].i_addr,
|
2013-04-02 23:11:29 -06:00
|
|
|
-1, 0, XFS_QMOPT_DOWARN,
|
|
|
|
"dquot_buf_recover");
|
|
|
|
if (error)
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(xfs_buf_offset(bp,
|
|
|
|
(uint)bit << XFS_BLF_SHIFT), /* dest */
|
|
|
|
item->ri_buf[i].i_addr, /* source */
|
|
|
|
nbits<<XFS_BLF_SHIFT); /* length */
|
|
|
|
next:
|
|
|
|
i++;
|
|
|
|
bit += nbits;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Shouldn't be any more regions */
|
|
|
|
ASSERT(i == item->ri_total);
|
|
|
|
|
2016-09-25 16:32:07 -06:00
|
|
|
xlog_recover_validate_buf_type(mp, bp, buf_f, current_lsn);
|
2013-04-02 23:11:29 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Perform a dquot buffer recovery.
|
2013-08-11 21:15:01 -06:00
|
|
|
* Simple algorithm: if we have found a QUOTAOFF log item of the same type
|
2005-04-16 16:20:36 -06:00
|
|
|
* (ie. USR or GRP), then just toss this buffer away; don't recover it.
|
|
|
|
* Else, treat it as a regular buffer and do recovery.
|
2014-08-03 20:59:31 -06:00
|
|
|
*
|
|
|
|
* Return false if the buffer was tossed and true if we recovered the buffer to
|
|
|
|
* indicate to the caller if the buffer needs writing.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2014-08-03 20:59:31 -06:00
|
|
|
STATIC bool
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_recover_do_dquot_buffer(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item,
|
|
|
|
struct xfs_buf *bp,
|
|
|
|
struct xfs_buf_log_format *buf_f)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
uint type;
|
|
|
|
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_buf_dquot_buf(log, buf_f);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Filesystems are required to send in quota flags at mount time.
|
|
|
|
*/
|
2014-08-03 20:59:31 -06:00
|
|
|
if (!mp->m_qflags)
|
|
|
|
return false;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
type = 0;
|
2010-05-06 19:05:19 -06:00
|
|
|
if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
|
2005-04-16 16:20:36 -06:00
|
|
|
type |= XFS_DQ_USER;
|
2010-05-06 19:05:19 -06:00
|
|
|
if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
|
2005-06-20 23:38:48 -06:00
|
|
|
type |= XFS_DQ_PROJ;
|
2010-05-06 19:05:19 -06:00
|
|
|
if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
|
2005-04-16 16:20:36 -06:00
|
|
|
type |= XFS_DQ_GROUP;
|
|
|
|
/*
|
|
|
|
* This type of quotas was turned off, so ignore this buffer
|
|
|
|
*/
|
|
|
|
if (log->l_quotaoffs_flag & type)
|
2014-08-03 20:59:31 -06:00
|
|
|
return false;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-09-25 16:32:07 -06:00
|
|
|
xlog_recover_do_reg_buffer(mp, item, bp, buf_f, NULLCOMMITLSN);
|
2014-08-03 20:59:31 -06:00
|
|
|
return true;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine replays a modification made to a buffer at runtime.
|
|
|
|
* There are actually two types of buffer, regular and inode, which
|
|
|
|
* are handled differently. Inode buffers are handled differently
|
|
|
|
* in that we only recover a specific set of data from them, namely
|
|
|
|
* the inode di_next_unlinked fields. This is because all other inode
|
|
|
|
* data is actually logged via inode records and any data we replay
|
|
|
|
* here which overlaps that may be stale.
|
|
|
|
*
|
|
|
|
* When meta-data buffers are freed at run time we log a buffer item
|
2010-05-06 19:05:19 -06:00
|
|
|
* with the XFS_BLF_CANCEL bit set to indicate that previous copies
|
2005-04-16 16:20:36 -06:00
|
|
|
* of the buffer in the log should not be replayed at recovery time.
|
|
|
|
* This is so that if the blocks covered by the buffer are reused for
|
|
|
|
* file data before we crash we don't end up replaying old, freed
|
|
|
|
* meta-data into a user's file.
|
|
|
|
*
|
|
|
|
* To handle the cancellation of buffer log items, we make two passes
|
|
|
|
* over the log during recovery. During the first we build a table of
|
|
|
|
* those buffers which have been cancelled, and during the second we
|
|
|
|
* only replay those buffers which do not have corresponding cancel
|
2013-08-07 04:11:07 -06:00
|
|
|
* records in the table. See xlog_recover_buffer_pass[1,2] above
|
2005-04-16 16:20:36 -06:00
|
|
|
* for more details on the implementation of the table of cancel records.
|
|
|
|
*/
|
|
|
|
STATIC int
|
2010-12-01 15:06:24 -07:00
|
|
|
xlog_recover_buffer_pass2(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct list_head *buffer_list,
|
2013-08-28 05:22:47 -06:00
|
|
|
struct xlog_recover_item *item,
|
|
|
|
xfs_lsn_t current_lsn)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-06-23 02:11:15 -06:00
|
|
|
xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
|
2010-12-01 15:06:21 -07:00
|
|
|
xfs_mount_t *mp = log->l_mp;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_buf_t *bp;
|
|
|
|
int error;
|
2009-11-24 11:02:23 -07:00
|
|
|
uint buf_flags;
|
2013-08-28 05:22:47 -06:00
|
|
|
xfs_lsn_t lsn;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-01 15:06:24 -07:00
|
|
|
/*
|
|
|
|
* In this pass we only want to recover all the buffers which have
|
|
|
|
* not been cancelled and are not cancellation buffers themselves.
|
|
|
|
*/
|
|
|
|
if (xlog_check_buffer_cancelled(log, buf_f->blf_blkno,
|
|
|
|
buf_f->blf_len, buf_f->blf_flags)) {
|
|
|
|
trace_xfs_log_recover_buf_cancel(log, buf_f);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2010-12-01 15:06:24 -07:00
|
|
|
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_buf_recover(log, buf_f);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-04-22 23:58:54 -06:00
|
|
|
buf_flags = 0;
|
2012-04-22 23:59:07 -06:00
|
|
|
if (buf_f->blf_flags & XFS_BLF_INODE_BUF)
|
|
|
|
buf_flags |= XBF_UNMAPPED;
|
2009-11-24 11:02:23 -07:00
|
|
|
|
2010-12-01 15:06:21 -07:00
|
|
|
bp = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len,
|
2012-11-12 04:54:01 -07:00
|
|
|
buf_flags, NULL);
|
2011-08-02 20:18:29 -06:00
|
|
|
if (!bp)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2011-08-02 20:18:34 -06:00
|
|
|
error = bp->b_error;
|
2011-07-22 17:39:51 -06:00
|
|
|
if (error) {
|
2011-10-10 10:52:49 -06:00
|
|
|
xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
|
2013-08-28 05:22:47 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-08-28 05:22:47 -06:00
|
|
|
/*
|
2014-08-03 20:43:06 -06:00
|
|
|
* Recover the buffer only if we get an LSN from it and it's less than
|
2013-08-28 05:22:47 -06:00
|
|
|
* the lsn of the transaction we are replaying.
|
2014-08-03 20:43:06 -06:00
|
|
|
*
|
|
|
|
* Note that we have to be extremely careful of readahead here.
|
|
|
|
* Readahead does not attach verfiers to the buffers so if we don't
|
|
|
|
* actually do any replay after readahead because of the LSN we found
|
|
|
|
* in the buffer if more recent than that current transaction then we
|
|
|
|
* need to attach the verifier directly. Failure to do so can lead to
|
|
|
|
* future recovery actions (e.g. EFI and unlinked list recovery) can
|
|
|
|
* operate on the buffers and they won't get the verifier attached. This
|
|
|
|
* can lead to blocks on disk having the correct content but a stale
|
|
|
|
* CRC.
|
|
|
|
*
|
|
|
|
* It is safe to assume these clean buffers are currently up to date.
|
|
|
|
* If the buffer is dirtied by a later transaction being replayed, then
|
|
|
|
* the verifier will be reset to match whatever recover turns that
|
|
|
|
* buffer into.
|
2013-08-28 05:22:47 -06:00
|
|
|
*/
|
|
|
|
lsn = xlog_recover_get_buf_lsn(mp, bp);
|
2014-08-03 20:43:06 -06:00
|
|
|
if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) {
|
2016-09-25 16:34:52 -06:00
|
|
|
trace_xfs_log_recover_buf_skip(log, buf_f);
|
2016-09-25 16:32:07 -06:00
|
|
|
xlog_recover_validate_buf_type(mp, bp, buf_f, NULLCOMMITLSN);
|
2013-08-28 05:22:47 -06:00
|
|
|
goto out_release;
|
2014-08-03 20:43:06 -06:00
|
|
|
}
|
2013-08-28 05:22:47 -06:00
|
|
|
|
2010-12-01 15:06:21 -07:00
|
|
|
if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
|
2005-04-16 16:20:36 -06:00
|
|
|
error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
|
2014-08-03 20:59:31 -06:00
|
|
|
if (error)
|
|
|
|
goto out_release;
|
2010-12-01 15:06:21 -07:00
|
|
|
} else if (buf_f->blf_flags &
|
2010-05-06 19:05:19 -06:00
|
|
|
(XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
|
2014-08-03 20:59:31 -06:00
|
|
|
bool dirty;
|
|
|
|
|
|
|
|
dirty = xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
|
|
|
|
if (!dirty)
|
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2016-09-25 16:32:07 -06:00
|
|
|
xlog_recover_do_reg_buffer(mp, item, bp, buf_f, current_lsn);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform delayed write on the buffer. Asynchronous writes will be
|
|
|
|
* slower when taking into account all the buffers to be flushed.
|
|
|
|
*
|
|
|
|
* Also make sure that only inode buffers with good sizes stay in
|
|
|
|
* the buffer cache. The kernel moves inodes in buffers of 1 block
|
2013-12-12 21:51:48 -07:00
|
|
|
* or mp->m_inode_cluster_size bytes, whichever is bigger. The inode
|
2005-04-16 16:20:36 -06:00
|
|
|
* buffers in the log can be a different size if the log was generated
|
|
|
|
* by an older kernel using unclustered inode buffers or a newer kernel
|
|
|
|
* running with a different inode cluster size. Regardless, if the
|
2013-12-12 21:51:48 -07:00
|
|
|
* the inode buffer size isn't MAX(blocksize, mp->m_inode_cluster_size)
|
|
|
|
* for *our* value of mp->m_inode_cluster_size, then we need to keep
|
2005-04-16 16:20:36 -06:00
|
|
|
* the buffer out of the buffer cache so that the buffer won't
|
|
|
|
* overlap with future reads of those inodes.
|
|
|
|
*/
|
|
|
|
if (XFS_DINODE_MAGIC ==
|
2007-10-11 18:59:34 -06:00
|
|
|
be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
|
2012-04-22 23:58:52 -06:00
|
|
|
(BBTOB(bp->b_io_length) != MAX(log->l_mp->m_sb.sb_blocksize,
|
2017-06-16 12:00:05 -06:00
|
|
|
(uint32_t)log->l_mp->m_inode_cluster_size))) {
|
2011-10-10 10:52:46 -06:00
|
|
|
xfs_buf_stale(bp);
|
2011-08-23 02:28:07 -06:00
|
|
|
error = xfs_bwrite(bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2010-09-21 18:47:20 -06:00
|
|
|
ASSERT(bp->b_target->bt_mount == mp);
|
2011-07-13 05:43:49 -06:00
|
|
|
bp->b_iodone = xlog_recover_iodone;
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
xfs_buf_delwri_queue(bp, buffer_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-08-28 05:22:47 -06:00
|
|
|
out_release:
|
2011-08-23 02:28:07 -06:00
|
|
|
xfs_buf_relse(bp);
|
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
/*
|
|
|
|
* Inode fork owner changes
|
|
|
|
*
|
|
|
|
* If we have been told that we have to reparent the inode fork, it's because an
|
|
|
|
* extent swap operation on a CRC enabled filesystem has been done and we are
|
|
|
|
* replaying it. We need to walk the BMBT of the appropriate fork and change the
|
|
|
|
* owners of it.
|
|
|
|
*
|
|
|
|
* The complexity here is that we don't have an inode context to work with, so
|
|
|
|
* after we've replayed the inode we need to instantiate one. This is where the
|
|
|
|
* fun begins.
|
|
|
|
*
|
|
|
|
* We are in the middle of log recovery, so we can't run transactions. That
|
|
|
|
* means we cannot use cache coherent inode instantiation via xfs_iget(), as
|
|
|
|
* that will result in the corresponding iput() running the inode through
|
|
|
|
* xfs_inactive(). If we've just replayed an inode core that changes the link
|
|
|
|
* count to zero (i.e. it's been unlinked), then xfs_inactive() will run
|
|
|
|
* transactions (bad!).
|
|
|
|
*
|
|
|
|
* So, to avoid this, we instantiate an inode directly from the inode core we've
|
|
|
|
* just recovered. We have the buffer still locked, and all we really need to
|
|
|
|
* instantiate is the inode core and the forks being modified. We can do this
|
|
|
|
* manually, then run the inode btree owner change, and then tear down the
|
|
|
|
* xfs_inode without having to run any transactions at all.
|
|
|
|
*
|
|
|
|
* Also, because we don't have a transaction context available here but need to
|
|
|
|
* gather all the buffers we modify for writeback so we pass the buffer_list
|
|
|
|
* instead for the operation to use.
|
|
|
|
*/
|
|
|
|
|
|
|
|
STATIC int
|
|
|
|
xfs_recover_inode_owner_change(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_dinode *dip,
|
|
|
|
struct xfs_inode_log_format *in_f,
|
|
|
|
struct list_head *buffer_list)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
ASSERT(in_f->ilf_fields & (XFS_ILOG_DOWNER|XFS_ILOG_AOWNER));
|
|
|
|
|
|
|
|
ip = xfs_inode_alloc(mp, in_f->ilf_ino);
|
|
|
|
if (!ip)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
|
|
|
|
/* instantiate the inode */
|
2016-02-08 22:54:58 -07:00
|
|
|
xfs_inode_from_disk(ip, dip);
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
ASSERT(ip->i_d.di_version >= 3);
|
|
|
|
|
|
|
|
error = xfs_iformat_fork(ip, dip);
|
|
|
|
if (error)
|
|
|
|
goto out_free_ip;
|
|
|
|
|
|
|
|
|
|
|
|
if (in_f->ilf_fields & XFS_ILOG_DOWNER) {
|
|
|
|
ASSERT(in_f->ilf_fields & XFS_ILOG_DBROOT);
|
|
|
|
error = xfs_bmbt_change_owner(NULL, ip, XFS_DATA_FORK,
|
|
|
|
ip->i_ino, buffer_list);
|
|
|
|
if (error)
|
|
|
|
goto out_free_ip;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (in_f->ilf_fields & XFS_ILOG_AOWNER) {
|
|
|
|
ASSERT(in_f->ilf_fields & XFS_ILOG_ABROOT);
|
|
|
|
error = xfs_bmbt_change_owner(NULL, ip, XFS_ATTR_FORK,
|
|
|
|
ip->i_ino, buffer_list);
|
|
|
|
if (error)
|
|
|
|
goto out_free_ip;
|
|
|
|
}
|
|
|
|
|
|
|
|
out_free_ip:
|
|
|
|
xfs_inode_free(ip);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
STATIC int
|
2010-12-01 15:06:24 -07:00
|
|
|
xlog_recover_inode_pass2(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct list_head *buffer_list,
|
2013-08-28 05:22:47 -06:00
|
|
|
struct xlog_recover_item *item,
|
|
|
|
xfs_lsn_t current_lsn)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xfs_inode_log_format_t *in_f;
|
2010-12-01 15:06:24 -07:00
|
|
|
xfs_mount_t *mp = log->l_mp;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_buf_t *bp;
|
|
|
|
xfs_dinode_t *dip;
|
|
|
|
int len;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *src;
|
|
|
|
char *dest;
|
2005-04-16 16:20:36 -06:00
|
|
|
int error;
|
|
|
|
int attr_index;
|
|
|
|
uint fields;
|
2016-02-08 22:54:58 -07:00
|
|
|
struct xfs_log_dinode *ldip;
|
2013-04-02 23:11:17 -06:00
|
|
|
uint isize;
|
2006-06-08 22:55:38 -06:00
|
|
|
int need_free = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-08 22:55:38 -06:00
|
|
|
if (item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t)) {
|
2010-06-23 02:11:15 -06:00
|
|
|
in_f = item->ri_buf[0].i_addr;
|
2006-06-08 22:55:38 -06:00
|
|
|
} else {
|
2010-06-23 02:11:15 -06:00
|
|
|
in_f = kmem_alloc(sizeof(xfs_inode_log_format_t), KM_SLEEP);
|
2006-06-08 22:55:38 -06:00
|
|
|
need_free = 1;
|
|
|
|
error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
|
|
|
|
if (error)
|
|
|
|
goto error;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Inode buffers can be freed, look out for it,
|
|
|
|
* and do not replay the inode.
|
|
|
|
*/
|
2008-11-27 20:23:40 -07:00
|
|
|
if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno,
|
|
|
|
in_f->ilf_len, 0)) {
|
2006-06-08 22:55:38 -06:00
|
|
|
error = 0;
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_inode_cancel(log, in_f);
|
2006-06-08 22:55:38 -06:00
|
|
|
goto error;
|
|
|
|
}
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_inode_recover(log, in_f);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-12 04:54:01 -07:00
|
|
|
bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len, 0,
|
2013-04-02 23:11:17 -06:00
|
|
|
&xfs_inode_buf_ops);
|
2011-08-02 20:18:29 -06:00
|
|
|
if (!bp) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -ENOMEM;
|
2011-08-02 20:18:29 -06:00
|
|
|
goto error;
|
|
|
|
}
|
2011-08-02 20:18:34 -06:00
|
|
|
error = bp->b_error;
|
2011-07-22 17:39:51 -06:00
|
|
|
if (error) {
|
2011-10-10 10:52:49 -06:00
|
|
|
xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#2)");
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
|
2015-06-21 17:44:29 -06:00
|
|
|
dip = xfs_buf_offset(bp, in_f->ilf_boffset);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure the place we're flushing out to really looks
|
|
|
|
* like an inode!
|
|
|
|
*/
|
2011-07-08 06:36:05 -06:00
|
|
|
if (unlikely(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC))) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(mp,
|
|
|
|
"%s: Bad inode magic number, dip = 0x%p, dino bp = 0x%p, ino = %Ld",
|
|
|
|
__func__, dip, bp, in_f->ilf_ino);
|
2010-12-01 15:06:24 -07:00
|
|
|
XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)",
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_ERRLEVEL_LOW, mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EFSCORRUPTED;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2016-02-08 22:54:58 -07:00
|
|
|
ldip = item->ri_buf[1].i_addr;
|
|
|
|
if (unlikely(ldip->di_magic != XFS_DINODE_MAGIC)) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(mp,
|
|
|
|
"%s: Bad inode log record, rec ptr 0x%p, ino %Ld",
|
|
|
|
__func__, item, in_f->ilf_ino);
|
2010-12-01 15:06:24 -07:00
|
|
|
XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)",
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_ERRLEVEL_LOW, mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EFSCORRUPTED;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-08-28 05:22:47 -06:00
|
|
|
/*
|
|
|
|
* If the inode has an LSN in it, recover the inode only if it's less
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
* than the lsn of the transaction we are replaying. Note: we still
|
|
|
|
* need to replay an owner change even though the inode is more recent
|
|
|
|
* than the transaction as there is no guarantee that all the btree
|
|
|
|
* blocks are more recent than this transaction, too.
|
2013-08-28 05:22:47 -06:00
|
|
|
*/
|
|
|
|
if (dip->di_version >= 3) {
|
|
|
|
xfs_lsn_t lsn = be64_to_cpu(dip->di_lsn);
|
|
|
|
|
|
|
|
if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) {
|
|
|
|
trace_xfs_log_recover_inode_skip(log, in_f);
|
|
|
|
error = 0;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_owner_change;
|
2013-08-28 05:22:47 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
xfs: di_flushiter considered harmful
When we made all inode updates transactional, we no longer needed
the log recovery detection for inodes being newer on disk than the
transaction being replayed - it was redundant as replay of the log
would always result in the latest version of the inode would be on
disk. It was redundant, but left in place because it wasn't
considered to be a problem.
However, with the new "don't read inodes on create" optimisation,
flushiter has come back to bite us. Essentially, the optimisation
made always initialises flushiter to zero in the create transaction,
and so if we then crash and run recovery and the inode already on
disk has a non-zero flushiter it will skip recovery of that inode.
As a result, log recovery does the wrong thing and we end up with a
corrupt filesystem.
Because we have to support old kernel to new kernel upgrades, we
can't just get rid of the flushiter support in log recovery as we
might be upgrading from a kernel that doesn't have fully transactional
inode updates. Unfortunately, for v4 superblocks there is no way to
guarantee that log recovery knows about this fact.
We cannot add a new inode format flag to say it's a "special inode
create" because it won't be understood by older kernels and so
recovery could do the wrong thing on downgrade. We cannot specially
detect the combination of zero mode/non-zero flushiter on disk to
non-zero mode, zero flushiter in the log item during recovery
because wrapping of the flushiter can result in false detection.
Hence that makes this "don't use flushiter" optimisation limited to
a disk format that guarantees that we don't need it. And that means
the only fix here is to limit the "no read IO on create"
optimisation to version 5 superblocks....
Reported-by: Markus Trippelsdorf <markus@trippelsdorf.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-07-23 23:47:30 -06:00
|
|
|
/*
|
|
|
|
* di_flushiter is only valid for v1/2 inodes. All changes for v3 inodes
|
|
|
|
* are transactional and if ordering is necessary we can determine that
|
|
|
|
* more accurately by the LSN field in the V3 inode core. Don't trust
|
|
|
|
* the inode versions we might be changing them here - use the
|
|
|
|
* superblock flag to determine whether we need to look at di_flushiter
|
|
|
|
* to skip replay when the on disk inode is newer than the log one
|
|
|
|
*/
|
|
|
|
if (!xfs_sb_version_hascrc(&mp->m_sb) &&
|
2016-02-08 22:54:58 -07:00
|
|
|
ldip->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Deal with the wrap case, DI_MAX_FLUSH is less
|
|
|
|
* than smaller numbers
|
|
|
|
*/
|
2008-11-27 20:23:39 -07:00
|
|
|
if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
|
2016-02-08 22:54:58 -07:00
|
|
|
ldip->di_flushiter < (DI_MAX_FLUSH >> 1)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* do nothing */
|
|
|
|
} else {
|
2010-04-12 23:06:46 -06:00
|
|
|
trace_xfs_log_recover_inode_skip(log, in_f);
|
2006-06-08 22:55:38 -06:00
|
|
|
error = 0;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
xfs: di_flushiter considered harmful
When we made all inode updates transactional, we no longer needed
the log recovery detection for inodes being newer on disk than the
transaction being replayed - it was redundant as replay of the log
would always result in the latest version of the inode would be on
disk. It was redundant, but left in place because it wasn't
considered to be a problem.
However, with the new "don't read inodes on create" optimisation,
flushiter has come back to bite us. Essentially, the optimisation
made always initialises flushiter to zero in the create transaction,
and so if we then crash and run recovery and the inode already on
disk has a non-zero flushiter it will skip recovery of that inode.
As a result, log recovery does the wrong thing and we end up with a
corrupt filesystem.
Because we have to support old kernel to new kernel upgrades, we
can't just get rid of the flushiter support in log recovery as we
might be upgrading from a kernel that doesn't have fully transactional
inode updates. Unfortunately, for v4 superblocks there is no way to
guarantee that log recovery knows about this fact.
We cannot add a new inode format flag to say it's a "special inode
create" because it won't be understood by older kernels and so
recovery could do the wrong thing on downgrade. We cannot specially
detect the combination of zero mode/non-zero flushiter on disk to
non-zero mode, zero flushiter in the log item during recovery
because wrapping of the flushiter can result in false detection.
Hence that makes this "don't use flushiter" optimisation limited to
a disk format that guarantees that we don't need it. And that means
the only fix here is to limit the "no read IO on create"
optimisation to version 5 superblocks....
Reported-by: Markus Trippelsdorf <markus@trippelsdorf.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-07-23 23:47:30 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Take the opportunity to reset the flush iteration count */
|
2016-02-08 22:54:58 -07:00
|
|
|
ldip->di_flushiter = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-02-08 22:54:58 -07:00
|
|
|
if (unlikely(S_ISREG(ldip->di_mode))) {
|
|
|
|
if ((ldip->di_format != XFS_DINODE_FMT_EXTENTS) &&
|
|
|
|
(ldip->di_format != XFS_DINODE_FMT_BTREE)) {
|
2010-12-01 15:06:24 -07:00
|
|
|
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)",
|
2016-02-08 22:54:58 -07:00
|
|
|
XFS_ERRLEVEL_LOW, mp, ldip);
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(mp,
|
|
|
|
"%s: Bad regular inode log record, rec ptr 0x%p, "
|
|
|
|
"ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
|
|
|
|
__func__, item, dip, bp, in_f->ilf_ino);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EFSCORRUPTED;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2016-02-08 22:54:58 -07:00
|
|
|
} else if (unlikely(S_ISDIR(ldip->di_mode))) {
|
|
|
|
if ((ldip->di_format != XFS_DINODE_FMT_EXTENTS) &&
|
|
|
|
(ldip->di_format != XFS_DINODE_FMT_BTREE) &&
|
|
|
|
(ldip->di_format != XFS_DINODE_FMT_LOCAL)) {
|
2010-12-01 15:06:24 -07:00
|
|
|
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(4)",
|
2016-02-08 22:54:58 -07:00
|
|
|
XFS_ERRLEVEL_LOW, mp, ldip);
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(mp,
|
|
|
|
"%s: Bad dir inode log record, rec ptr 0x%p, "
|
|
|
|
"ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
|
|
|
|
__func__, item, dip, bp, in_f->ilf_ino);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EFSCORRUPTED;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2016-02-08 22:54:58 -07:00
|
|
|
if (unlikely(ldip->di_nextents + ldip->di_anextents > ldip->di_nblocks)){
|
2010-12-01 15:06:24 -07:00
|
|
|
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)",
|
2016-02-08 22:54:58 -07:00
|
|
|
XFS_ERRLEVEL_LOW, mp, ldip);
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(mp,
|
|
|
|
"%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
|
|
|
|
"dino bp 0x%p, ino %Ld, total extents = %d, nblocks = %Ld",
|
|
|
|
__func__, item, dip, bp, in_f->ilf_ino,
|
2016-02-08 22:54:58 -07:00
|
|
|
ldip->di_nextents + ldip->di_anextents,
|
|
|
|
ldip->di_nblocks);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EFSCORRUPTED;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2016-02-08 22:54:58 -07:00
|
|
|
if (unlikely(ldip->di_forkoff > mp->m_sb.sb_inodesize)) {
|
2010-12-01 15:06:24 -07:00
|
|
|
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)",
|
2016-02-08 22:54:58 -07:00
|
|
|
XFS_ERRLEVEL_LOW, mp, ldip);
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(mp,
|
|
|
|
"%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
|
|
|
|
"dino bp 0x%p, ino %Ld, forkoff 0x%x", __func__,
|
2016-02-08 22:54:58 -07:00
|
|
|
item, dip, bp, in_f->ilf_ino, ldip->di_forkoff);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EFSCORRUPTED;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2016-02-08 22:54:58 -07:00
|
|
|
isize = xfs_log_dinode_size(ldip->di_version);
|
2013-04-02 23:11:17 -06:00
|
|
|
if (unlikely(item->ri_buf[1].i_len > isize)) {
|
2010-12-01 15:06:24 -07:00
|
|
|
XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)",
|
2016-02-08 22:54:58 -07:00
|
|
|
XFS_ERRLEVEL_LOW, mp, ldip);
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(mp,
|
|
|
|
"%s: Bad inode log record length %d, rec ptr 0x%p",
|
|
|
|
__func__, item->ri_buf[1].i_len, item);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EFSCORRUPTED;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2016-02-08 22:54:58 -07:00
|
|
|
/* recover the log dinode inode into the on disk inode */
|
|
|
|
xfs_log_dinode_to_disk(ldip, dip);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* the rest is in on-disk format */
|
2013-04-02 23:11:17 -06:00
|
|
|
if (item->ri_buf[1].i_len > isize) {
|
|
|
|
memcpy((char *)dip + isize,
|
|
|
|
item->ri_buf[1].i_addr + isize,
|
|
|
|
item->ri_buf[1].i_len - isize);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fields = in_f->ilf_fields;
|
|
|
|
switch (fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) {
|
|
|
|
case XFS_ILOG_DEV:
|
2008-11-27 20:23:39 -07:00
|
|
|
xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case XFS_ILOG_UUID:
|
2008-11-27 20:23:39 -07:00
|
|
|
memcpy(XFS_DFORK_DPTR(dip),
|
|
|
|
&in_f->ilf_u.ilfu_uuid,
|
|
|
|
sizeof(uuid_t));
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (in_f->ilf_size == 2)
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_owner_change;
|
2005-04-16 16:20:36 -06:00
|
|
|
len = item->ri_buf[2].i_len;
|
|
|
|
src = item->ri_buf[2].i_addr;
|
|
|
|
ASSERT(in_f->ilf_size <= 4);
|
|
|
|
ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK));
|
|
|
|
ASSERT(!(fields & XFS_ILOG_DFORK) ||
|
|
|
|
(len == in_f->ilf_dsize));
|
|
|
|
|
|
|
|
switch (fields & XFS_ILOG_DFORK) {
|
|
|
|
case XFS_ILOG_DDATA:
|
|
|
|
case XFS_ILOG_DEXT:
|
2008-11-27 20:23:39 -07:00
|
|
|
memcpy(XFS_DFORK_DPTR(dip), src, len);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case XFS_ILOG_DBROOT:
|
2008-10-30 00:14:34 -06:00
|
|
|
xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, len,
|
2008-11-27 20:23:39 -07:00
|
|
|
(xfs_bmdr_block_t *)XFS_DFORK_DPTR(dip),
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DFORK_DSIZE(dip, mp));
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* There are no data fork flags set.
|
|
|
|
*/
|
|
|
|
ASSERT((fields & XFS_ILOG_DFORK) == 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we logged any attribute data, recover it. There may or
|
|
|
|
* may not have been any other non-core data logged in this
|
|
|
|
* transaction.
|
|
|
|
*/
|
|
|
|
if (in_f->ilf_fields & XFS_ILOG_AFORK) {
|
|
|
|
if (in_f->ilf_fields & XFS_ILOG_DFORK) {
|
|
|
|
attr_index = 3;
|
|
|
|
} else {
|
|
|
|
attr_index = 2;
|
|
|
|
}
|
|
|
|
len = item->ri_buf[attr_index].i_len;
|
|
|
|
src = item->ri_buf[attr_index].i_addr;
|
|
|
|
ASSERT(len == in_f->ilf_asize);
|
|
|
|
|
|
|
|
switch (in_f->ilf_fields & XFS_ILOG_AFORK) {
|
|
|
|
case XFS_ILOG_ADATA:
|
|
|
|
case XFS_ILOG_AEXT:
|
|
|
|
dest = XFS_DFORK_APTR(dip);
|
|
|
|
ASSERT(len <= XFS_DFORK_ASIZE(dip, mp));
|
|
|
|
memcpy(dest, src, len);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case XFS_ILOG_ABROOT:
|
|
|
|
dest = XFS_DFORK_APTR(dip);
|
2008-10-30 00:14:34 -06:00
|
|
|
xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src,
|
|
|
|
len, (xfs_bmdr_block_t*)dest,
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_DFORK_ASIZE(dip, mp));
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp, "%s: Invalid flag", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(0);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EIO;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
goto out_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
out_owner_change:
|
|
|
|
if (in_f->ilf_fields & (XFS_ILOG_DOWNER|XFS_ILOG_AOWNER))
|
|
|
|
error = xfs_recover_inode_owner_change(mp, dip, in_f,
|
|
|
|
buffer_list);
|
2013-04-02 23:11:17 -06:00
|
|
|
/* re-generate the checksum. */
|
|
|
|
xfs_dinode_calc_crc(log->l_mp, dip);
|
|
|
|
|
2010-09-21 18:47:20 -06:00
|
|
|
ASSERT(bp->b_target->bt_mount == mp);
|
2011-07-13 05:43:49 -06:00
|
|
|
bp->b_iodone = xlog_recover_iodone;
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
xfs_buf_delwri_queue(bp, buffer_list);
|
2013-08-28 05:22:47 -06:00
|
|
|
|
|
|
|
out_release:
|
2011-08-23 02:28:06 -06:00
|
|
|
xfs_buf_relse(bp);
|
2006-06-08 22:55:38 -06:00
|
|
|
error:
|
|
|
|
if (need_free)
|
2008-05-19 00:31:57 -06:00
|
|
|
kmem_free(in_f);
|
2014-06-21 23:04:54 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-06-14 08:22:16 -06:00
|
|
|
* Recover QUOTAOFF records. We simply make a note of it in the xlog
|
2005-04-16 16:20:36 -06:00
|
|
|
* structure, so that we know not to do any dquot item or dquot buffer recovery,
|
|
|
|
* of that type.
|
|
|
|
*/
|
|
|
|
STATIC int
|
2010-12-01 15:06:24 -07:00
|
|
|
xlog_recover_quotaoff_pass1(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-12-01 15:06:24 -07:00
|
|
|
xfs_qoff_logformat_t *qoff_f = item->ri_buf[0].i_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(qoff_f);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The logitem format's flag tells us if this was user quotaoff,
|
2006-01-10 21:35:57 -07:00
|
|
|
* group/project quotaoff or both.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
|
|
|
|
log->l_quotaoffs_flag |= XFS_DQ_USER;
|
2006-01-10 21:35:57 -07:00
|
|
|
if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
|
|
|
|
log->l_quotaoffs_flag |= XFS_DQ_PROJ;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
|
|
|
|
log->l_quotaoffs_flag |= XFS_DQ_GROUP;
|
|
|
|
|
2014-06-21 23:03:54 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Recover a dquot record
|
|
|
|
*/
|
|
|
|
STATIC int
|
2010-12-01 15:06:24 -07:00
|
|
|
xlog_recover_dquot_pass2(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct list_head *buffer_list,
|
2013-08-28 05:22:47 -06:00
|
|
|
struct xlog_recover_item *item,
|
|
|
|
xfs_lsn_t current_lsn)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-12-01 15:06:24 -07:00
|
|
|
xfs_mount_t *mp = log->l_mp;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_buf_t *bp;
|
|
|
|
struct xfs_disk_dquot *ddq, *recddq;
|
|
|
|
int error;
|
|
|
|
xfs_dq_logformat_t *dq_f;
|
|
|
|
uint type;
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Filesystems are required to send in quota flags at mount time.
|
|
|
|
*/
|
|
|
|
if (mp->m_qflags == 0)
|
2014-06-21 23:03:54 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-23 02:11:15 -06:00
|
|
|
recddq = item->ri_buf[1].i_addr;
|
|
|
|
if (recddq == NULL) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2009-06-08 07:33:21 -06:00
|
|
|
}
|
2009-11-16 04:57:02 -07:00
|
|
|
if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
|
2009-06-08 07:33:21 -06:00
|
|
|
item->ri_buf[1].i_len, __func__);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2009-06-08 07:33:21 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* This type of quotas was turned off, so ignore this record.
|
|
|
|
*/
|
2007-10-11 18:59:34 -06:00
|
|
|
type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(type);
|
|
|
|
if (log->l_quotaoffs_flag & type)
|
2014-06-21 23:03:54 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* At this point we know that quota was _not_ turned off.
|
|
|
|
* Since the mount flags are not indicating to us otherwise, this
|
|
|
|
* must mean that quota is on, and the dquot needs to be replayed.
|
|
|
|
* Remember that we may not have fully recovered the superblock yet,
|
|
|
|
* so we can't do the usual trick of looking at the SB quota bits.
|
|
|
|
*
|
|
|
|
* The other possibility, of course, is that the quota subsystem was
|
|
|
|
* removed since the last mount - ENOSYS.
|
|
|
|
*/
|
2010-06-23 02:11:15 -06:00
|
|
|
dq_f = item->ri_buf[0].i_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(dq_f);
|
2013-10-14 16:17:52 -06:00
|
|
|
error = xfs_dqcheck(mp, recddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
|
2011-03-06 16:01:35 -07:00
|
|
|
"xlog_recover_dquot_pass2 (log copy)");
|
|
|
|
if (error)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(dq_f->qlf_len == 1);
|
|
|
|
|
2014-08-03 20:59:31 -06:00
|
|
|
/*
|
|
|
|
* At this point we are assuming that the dquots have been allocated
|
|
|
|
* and hence the buffer has valid dquots stamped in it. It should,
|
|
|
|
* therefore, pass verifier validation. If the dquot is bad, then the
|
|
|
|
* we'll return an error here, so we don't need to specifically check
|
|
|
|
* the dquot in the buffer after the verifier has run.
|
|
|
|
*/
|
2012-04-22 23:58:55 -06:00
|
|
|
error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dq_f->qlf_blkno,
|
2012-11-12 04:54:01 -07:00
|
|
|
XFS_FSB_TO_BB(mp, dq_f->qlf_len), 0, &bp,
|
2014-08-03 20:59:31 -06:00
|
|
|
&xfs_dquot_buf_ops);
|
2012-04-22 23:58:55 -06:00
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
2012-04-22 23:58:55 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(bp);
|
2015-06-21 17:44:29 -06:00
|
|
|
ddq = xfs_buf_offset(bp, dq_f->qlf_boffset);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-08-28 05:22:47 -06:00
|
|
|
/*
|
|
|
|
* If the dquot has an LSN in it, recover the dquot only if it's less
|
|
|
|
* than the lsn of the transaction we are replaying.
|
|
|
|
*/
|
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb)) {
|
|
|
|
struct xfs_dqblk *dqb = (struct xfs_dqblk *)ddq;
|
|
|
|
xfs_lsn_t lsn = be64_to_cpu(dqb->dd_lsn);
|
|
|
|
|
|
|
|
if (lsn && lsn != -1 && XFS_LSN_CMP(lsn, current_lsn) >= 0) {
|
|
|
|
goto out_release;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy(ddq, recddq, item->ri_buf[1].i_len);
|
xfs: rework dquot CRCs
Calculating dquot CRCs when the backing buffer is written back just
doesn't work reliably. There are several places which manipulate
dquots directly in the buffers, and they don't calculate CRCs
appropriately, nor do they always set the buffer up to calculate
CRCs appropriately.
Firstly, if we log a dquot buffer (e.g. during allocation) it gets
logged without valid CRC, and so on recovery we end up with a dquot
that is not valid.
Secondly, if we recover/repair a dquot, we don't have a verifier
attached to the buffer and hence CRCs are not calculated on the way
down to disk.
Thirdly, calculating the CRC after we've changed the contents means
that if we re-read the dquot from the buffer, we cannot verify the
contents of the dquot are valid, as the CRC is invalid.
So, to avoid all the dquot CRC errors that are being detected by the
read verifier, change to using the same model as for inodes. That
is, dquot CRCs are calculated and written to the backing buffer at
the time the dquot is flushed to the backing buffer. If we modify
the dquot directly in the backing buffer, calculate the CRC
immediately after the modification is complete. Hence the dquot in
the on-disk buffer should always have a valid CRC.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-06-02 23:28:46 -06:00
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb)) {
|
|
|
|
xfs_update_cksum((char *)ddq, sizeof(struct xfs_dqblk),
|
|
|
|
XFS_DQUOT_CRC_OFF);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT(dq_f->qlf_size == 2);
|
2010-09-21 18:47:20 -06:00
|
|
|
ASSERT(bp->b_target->bt_mount == mp);
|
2011-07-13 05:43:49 -06:00
|
|
|
bp->b_iodone = xlog_recover_iodone;
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
xfs_buf_delwri_queue(bp, buffer_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-08-28 05:22:47 -06:00
|
|
|
out_release:
|
|
|
|
xfs_buf_relse(bp);
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called to create an in-core extent free intent
|
|
|
|
* item from the efi format structure which was logged on disk.
|
|
|
|
* It allocates an in-core efi, copies the extents from the format
|
|
|
|
* structure into it, and adds the efi to the AIL with the given
|
|
|
|
* LSN.
|
|
|
|
*/
|
2006-06-08 22:55:38 -06:00
|
|
|
STATIC int
|
2010-12-01 15:06:24 -07:00
|
|
|
xlog_recover_efi_pass2(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item,
|
|
|
|
xfs_lsn_t lsn)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-08-18 17:52:21 -06:00
|
|
|
int error;
|
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
struct xfs_efi_log_item *efip;
|
|
|
|
struct xfs_efi_log_format *efi_formatp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-23 02:11:15 -06:00
|
|
|
efi_formatp = item->ri_buf[0].i_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
|
2015-08-18 17:52:21 -06:00
|
|
|
error = xfs_efi_copy_format(&item->ri_buf[0], &efip->efi_format);
|
|
|
|
if (error) {
|
2006-06-08 22:55:38 -06:00
|
|
|
xfs_efi_item_free(efip);
|
|
|
|
return error;
|
|
|
|
}
|
2010-12-19 17:59:49 -07:00
|
|
|
atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-30 00:39:35 -06:00
|
|
|
spin_lock(&log->l_ailp->xa_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2015-08-18 17:52:21 -06:00
|
|
|
* The EFI has two references. One for the EFD and one for EFI to ensure
|
|
|
|
* it makes it into the AIL. Insert the EFI into the AIL directly and
|
|
|
|
* drop the EFI reference. Note that xfs_trans_ail_update() drops the
|
|
|
|
* AIL lock.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-12-19 18:34:26 -07:00
|
|
|
xfs_trans_ail_update(log->l_ailp, &efip->efi_item, lsn);
|
2015-08-18 17:52:21 -06:00
|
|
|
xfs_efi_release(efip);
|
2006-06-08 22:55:38 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2015-08-18 17:52:21 -06:00
|
|
|
* This routine is called when an EFD format structure is found in a committed
|
|
|
|
* transaction in the log. Its purpose is to cancel the corresponding EFI if it
|
|
|
|
* was still in the log. To do this it searches the AIL for the EFI with an id
|
|
|
|
* equal to that in the EFD format structure. If we find it we drop the EFD
|
|
|
|
* reference, which removes the EFI from the AIL and frees it.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-12-01 15:06:24 -07:00
|
|
|
STATIC int
|
|
|
|
xlog_recover_efd_pass2(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xfs_efd_log_format_t *efd_formatp;
|
|
|
|
xfs_efi_log_item_t *efip = NULL;
|
|
|
|
xfs_log_item_t *lip;
|
2017-06-16 12:00:05 -06:00
|
|
|
uint64_t efi_id;
|
2008-10-30 00:38:39 -06:00
|
|
|
struct xfs_ail_cursor cur;
|
2008-10-30 00:39:58 -06:00
|
|
|
struct xfs_ail *ailp = log->l_ailp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-23 02:11:15 -06:00
|
|
|
efd_formatp = item->ri_buf[0].i_addr;
|
2006-06-08 22:55:38 -06:00
|
|
|
ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) +
|
|
|
|
((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) ||
|
|
|
|
(item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) +
|
|
|
|
((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t)))));
|
2005-04-16 16:20:36 -06:00
|
|
|
efi_id = efd_formatp->efd_efi_id;
|
|
|
|
|
|
|
|
/*
|
2015-08-18 17:52:21 -06:00
|
|
|
* Search for the EFI with the id in the EFD format structure in the
|
|
|
|
* AIL.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-10-30 00:39:35 -06:00
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
while (lip != NULL) {
|
|
|
|
if (lip->li_type == XFS_LI_EFI) {
|
|
|
|
efip = (xfs_efi_log_item_t *)lip;
|
|
|
|
if (efip->efi_format.efi_id == efi_id) {
|
|
|
|
/*
|
2015-08-18 17:52:21 -06:00
|
|
|
* Drop the EFD reference to the EFI. This
|
|
|
|
* removes the EFI from the AIL and frees it.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2015-08-18 17:52:21 -06:00
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
xfs_efi_release(efip);
|
2008-10-30 00:39:35 -06:00
|
|
|
spin_lock(&ailp->xa_lock);
|
2008-10-30 00:38:39 -06:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2008-10-30 00:39:35 -06:00
|
|
|
lip = xfs_trans_ail_cursor_next(ailp, &cur);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2015-08-18 17:52:21 -06:00
|
|
|
|
2014-04-14 03:06:05 -06:00
|
|
|
xfs_trans_ail_cursor_done(&cur);
|
2008-10-30 00:39:35 -06:00
|
|
|
spin_unlock(&ailp->xa_lock);
|
2010-12-01 15:06:24 -07:00
|
|
|
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2016-08-02 20:09:48 -06:00
|
|
|
/*
|
|
|
|
* This routine is called to create an in-core extent rmap update
|
|
|
|
* item from the rui format structure which was logged on disk.
|
|
|
|
* It allocates an in-core rui, copies the extents from the format
|
|
|
|
* structure into it, and adds the rui to the AIL with the given
|
|
|
|
* LSN.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_rui_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item,
|
|
|
|
xfs_lsn_t lsn)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
struct xfs_rui_log_item *ruip;
|
|
|
|
struct xfs_rui_log_format *rui_formatp;
|
|
|
|
|
|
|
|
rui_formatp = item->ri_buf[0].i_addr;
|
|
|
|
|
|
|
|
ruip = xfs_rui_init(mp, rui_formatp->rui_nextents);
|
|
|
|
error = xfs_rui_copy_format(&item->ri_buf[0], &ruip->rui_format);
|
|
|
|
if (error) {
|
|
|
|
xfs_rui_item_free(ruip);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
atomic_set(&ruip->rui_next_extent, rui_formatp->rui_nextents);
|
|
|
|
|
|
|
|
spin_lock(&log->l_ailp->xa_lock);
|
|
|
|
/*
|
|
|
|
* The RUI has two references. One for the RUD and one for RUI to ensure
|
|
|
|
* it makes it into the AIL. Insert the RUI into the AIL directly and
|
|
|
|
* drop the RUI reference. Note that xfs_trans_ail_update() drops the
|
|
|
|
* AIL lock.
|
|
|
|
*/
|
|
|
|
xfs_trans_ail_update(log->l_ailp, &ruip->rui_item, lsn);
|
|
|
|
xfs_rui_release(ruip);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called when an RUD format structure is found in a committed
|
|
|
|
* transaction in the log. Its purpose is to cancel the corresponding RUI if it
|
|
|
|
* was still in the log. To do this it searches the AIL for the RUI with an id
|
|
|
|
* equal to that in the RUD format structure. If we find it we drop the RUD
|
|
|
|
* reference, which removes the RUI from the AIL and frees it.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_rud_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item)
|
|
|
|
{
|
|
|
|
struct xfs_rud_log_format *rud_formatp;
|
|
|
|
struct xfs_rui_log_item *ruip = NULL;
|
|
|
|
struct xfs_log_item *lip;
|
2017-06-16 12:00:05 -06:00
|
|
|
uint64_t rui_id;
|
2016-08-02 20:09:48 -06:00
|
|
|
struct xfs_ail_cursor cur;
|
|
|
|
struct xfs_ail *ailp = log->l_ailp;
|
|
|
|
|
|
|
|
rud_formatp = item->ri_buf[0].i_addr;
|
2016-08-02 20:28:43 -06:00
|
|
|
ASSERT(item->ri_buf[0].i_len == sizeof(struct xfs_rud_log_format));
|
2016-08-02 20:09:48 -06:00
|
|
|
rui_id = rud_formatp->rud_rui_id;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search for the RUI with the id in the RUD format structure in the
|
|
|
|
* AIL.
|
|
|
|
*/
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
|
|
|
|
while (lip != NULL) {
|
|
|
|
if (lip->li_type == XFS_LI_RUI) {
|
|
|
|
ruip = (struct xfs_rui_log_item *)lip;
|
|
|
|
if (ruip->rui_format.rui_id == rui_id) {
|
|
|
|
/*
|
|
|
|
* Drop the RUD reference to the RUI. This
|
|
|
|
* removes the RUI from the AIL and frees it.
|
|
|
|
*/
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
xfs_rui_release(ruip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
lip = xfs_trans_ail_cursor_next(ailp, &cur);
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_trans_ail_cursor_done(&cur);
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-03 10:11:21 -06:00
|
|
|
/*
|
|
|
|
* Copy an CUI format buffer from the given buf, and into the destination
|
|
|
|
* CUI format structure. The CUI/CUD items were designed not to need any
|
|
|
|
* special alignment handling.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_cui_copy_format(
|
|
|
|
struct xfs_log_iovec *buf,
|
|
|
|
struct xfs_cui_log_format *dst_cui_fmt)
|
|
|
|
{
|
|
|
|
struct xfs_cui_log_format *src_cui_fmt;
|
|
|
|
uint len;
|
|
|
|
|
|
|
|
src_cui_fmt = buf->i_addr;
|
|
|
|
len = xfs_cui_log_format_sizeof(src_cui_fmt->cui_nextents);
|
|
|
|
|
|
|
|
if (buf->i_len == len) {
|
|
|
|
memcpy(dst_cui_fmt, src_cui_fmt, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called to create an in-core extent refcount update
|
|
|
|
* item from the cui format structure which was logged on disk.
|
|
|
|
* It allocates an in-core cui, copies the extents from the format
|
|
|
|
* structure into it, and adds the cui to the AIL with the given
|
|
|
|
* LSN.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_cui_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item,
|
|
|
|
xfs_lsn_t lsn)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
struct xfs_cui_log_item *cuip;
|
|
|
|
struct xfs_cui_log_format *cui_formatp;
|
|
|
|
|
|
|
|
cui_formatp = item->ri_buf[0].i_addr;
|
|
|
|
|
|
|
|
cuip = xfs_cui_init(mp, cui_formatp->cui_nextents);
|
|
|
|
error = xfs_cui_copy_format(&item->ri_buf[0], &cuip->cui_format);
|
|
|
|
if (error) {
|
|
|
|
xfs_cui_item_free(cuip);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
atomic_set(&cuip->cui_next_extent, cui_formatp->cui_nextents);
|
|
|
|
|
|
|
|
spin_lock(&log->l_ailp->xa_lock);
|
|
|
|
/*
|
|
|
|
* The CUI has two references. One for the CUD and one for CUI to ensure
|
|
|
|
* it makes it into the AIL. Insert the CUI into the AIL directly and
|
|
|
|
* drop the CUI reference. Note that xfs_trans_ail_update() drops the
|
|
|
|
* AIL lock.
|
|
|
|
*/
|
|
|
|
xfs_trans_ail_update(log->l_ailp, &cuip->cui_item, lsn);
|
|
|
|
xfs_cui_release(cuip);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called when an CUD format structure is found in a committed
|
|
|
|
* transaction in the log. Its purpose is to cancel the corresponding CUI if it
|
|
|
|
* was still in the log. To do this it searches the AIL for the CUI with an id
|
|
|
|
* equal to that in the CUD format structure. If we find it we drop the CUD
|
|
|
|
* reference, which removes the CUI from the AIL and frees it.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_cud_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item)
|
|
|
|
{
|
|
|
|
struct xfs_cud_log_format *cud_formatp;
|
|
|
|
struct xfs_cui_log_item *cuip = NULL;
|
|
|
|
struct xfs_log_item *lip;
|
2017-06-16 12:00:05 -06:00
|
|
|
uint64_t cui_id;
|
2016-10-03 10:11:21 -06:00
|
|
|
struct xfs_ail_cursor cur;
|
|
|
|
struct xfs_ail *ailp = log->l_ailp;
|
|
|
|
|
|
|
|
cud_formatp = item->ri_buf[0].i_addr;
|
|
|
|
if (item->ri_buf[0].i_len != sizeof(struct xfs_cud_log_format))
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
cui_id = cud_formatp->cud_cui_id;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search for the CUI with the id in the CUD format structure in the
|
|
|
|
* AIL.
|
|
|
|
*/
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
|
|
|
|
while (lip != NULL) {
|
|
|
|
if (lip->li_type == XFS_LI_CUI) {
|
|
|
|
cuip = (struct xfs_cui_log_item *)lip;
|
|
|
|
if (cuip->cui_format.cui_id == cui_id) {
|
|
|
|
/*
|
|
|
|
* Drop the CUD reference to the CUI. This
|
|
|
|
* removes the CUI from the AIL and frees it.
|
|
|
|
*/
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
xfs_cui_release(cuip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
lip = xfs_trans_ail_cursor_next(ailp, &cur);
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_trans_ail_cursor_done(&cur);
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-03 10:11:26 -06:00
|
|
|
/*
|
|
|
|
* Copy an BUI format buffer from the given buf, and into the destination
|
|
|
|
* BUI format structure. The BUI/BUD items were designed not to need any
|
|
|
|
* special alignment handling.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_bui_copy_format(
|
|
|
|
struct xfs_log_iovec *buf,
|
|
|
|
struct xfs_bui_log_format *dst_bui_fmt)
|
|
|
|
{
|
|
|
|
struct xfs_bui_log_format *src_bui_fmt;
|
|
|
|
uint len;
|
|
|
|
|
|
|
|
src_bui_fmt = buf->i_addr;
|
|
|
|
len = xfs_bui_log_format_sizeof(src_bui_fmt->bui_nextents);
|
|
|
|
|
|
|
|
if (buf->i_len == len) {
|
|
|
|
memcpy(dst_bui_fmt, src_bui_fmt, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called to create an in-core extent bmap update
|
|
|
|
* item from the bui format structure which was logged on disk.
|
|
|
|
* It allocates an in-core bui, copies the extents from the format
|
|
|
|
* structure into it, and adds the bui to the AIL with the given
|
|
|
|
* LSN.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_bui_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item,
|
|
|
|
xfs_lsn_t lsn)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
struct xfs_bui_log_item *buip;
|
|
|
|
struct xfs_bui_log_format *bui_formatp;
|
|
|
|
|
|
|
|
bui_formatp = item->ri_buf[0].i_addr;
|
|
|
|
|
|
|
|
if (bui_formatp->bui_nextents != XFS_BUI_MAX_FAST_EXTENTS)
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
buip = xfs_bui_init(mp);
|
|
|
|
error = xfs_bui_copy_format(&item->ri_buf[0], &buip->bui_format);
|
|
|
|
if (error) {
|
|
|
|
xfs_bui_item_free(buip);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
atomic_set(&buip->bui_next_extent, bui_formatp->bui_nextents);
|
|
|
|
|
|
|
|
spin_lock(&log->l_ailp->xa_lock);
|
|
|
|
/*
|
|
|
|
* The RUI has two references. One for the RUD and one for RUI to ensure
|
|
|
|
* it makes it into the AIL. Insert the RUI into the AIL directly and
|
|
|
|
* drop the RUI reference. Note that xfs_trans_ail_update() drops the
|
|
|
|
* AIL lock.
|
|
|
|
*/
|
|
|
|
xfs_trans_ail_update(log->l_ailp, &buip->bui_item, lsn);
|
|
|
|
xfs_bui_release(buip);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called when an BUD format structure is found in a committed
|
|
|
|
* transaction in the log. Its purpose is to cancel the corresponding BUI if it
|
|
|
|
* was still in the log. To do this it searches the AIL for the BUI with an id
|
|
|
|
* equal to that in the BUD format structure. If we find it we drop the BUD
|
|
|
|
* reference, which removes the BUI from the AIL and frees it.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_bud_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item)
|
|
|
|
{
|
|
|
|
struct xfs_bud_log_format *bud_formatp;
|
|
|
|
struct xfs_bui_log_item *buip = NULL;
|
|
|
|
struct xfs_log_item *lip;
|
2017-06-16 12:00:05 -06:00
|
|
|
uint64_t bui_id;
|
2016-10-03 10:11:26 -06:00
|
|
|
struct xfs_ail_cursor cur;
|
|
|
|
struct xfs_ail *ailp = log->l_ailp;
|
|
|
|
|
|
|
|
bud_formatp = item->ri_buf[0].i_addr;
|
|
|
|
if (item->ri_buf[0].i_len != sizeof(struct xfs_bud_log_format))
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
bui_id = bud_formatp->bud_bui_id;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Search for the BUI with the id in the BUD format structure in the
|
|
|
|
* AIL.
|
|
|
|
*/
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
|
|
|
|
while (lip != NULL) {
|
|
|
|
if (lip->li_type == XFS_LI_BUI) {
|
|
|
|
buip = (struct xfs_bui_log_item *)lip;
|
|
|
|
if (buip->bui_format.bui_id == bui_id) {
|
|
|
|
/*
|
|
|
|
* Drop the BUD reference to the BUI. This
|
|
|
|
* removes the BUI from the AIL and frees it.
|
|
|
|
*/
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
xfs_bui_release(buip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
lip = xfs_trans_ail_cursor_next(ailp, &cur);
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_trans_ail_cursor_done(&cur);
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-27 00:04:55 -06:00
|
|
|
/*
|
|
|
|
* This routine is called when an inode create format structure is found in a
|
|
|
|
* committed transaction in the log. It's purpose is to initialise the inodes
|
|
|
|
* being allocated on disk. This requires us to get inode cluster buffers that
|
2017-05-08 16:57:53 -06:00
|
|
|
* match the range to be initialised, stamped with inode templates and written
|
2013-06-27 00:04:55 -06:00
|
|
|
* by delayed write so that subsequent modifications will hit the cached buffer
|
|
|
|
* and only need writing out at the end of recovery.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_do_icreate_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct list_head *buffer_list,
|
|
|
|
xlog_recover_item_t *item)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
struct xfs_icreate_log *icl;
|
|
|
|
xfs_agnumber_t agno;
|
|
|
|
xfs_agblock_t agbno;
|
|
|
|
unsigned int count;
|
|
|
|
unsigned int isize;
|
|
|
|
xfs_agblock_t length;
|
2015-08-18 17:59:38 -06:00
|
|
|
int blks_per_cluster;
|
|
|
|
int bb_per_cluster;
|
|
|
|
int cancel_count;
|
|
|
|
int nbufs;
|
|
|
|
int i;
|
2013-06-27 00:04:55 -06:00
|
|
|
|
|
|
|
icl = (struct xfs_icreate_log *)item->ri_buf[0].i_addr;
|
|
|
|
if (icl->icl_type != XFS_LI_ICREATE) {
|
|
|
|
xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad type");
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EINVAL;
|
2013-06-27 00:04:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (icl->icl_size != 1) {
|
|
|
|
xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad icl size");
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EINVAL;
|
2013-06-27 00:04:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
agno = be32_to_cpu(icl->icl_ag);
|
|
|
|
if (agno >= mp->m_sb.sb_agcount) {
|
|
|
|
xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agno");
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EINVAL;
|
2013-06-27 00:04:55 -06:00
|
|
|
}
|
|
|
|
agbno = be32_to_cpu(icl->icl_agbno);
|
|
|
|
if (!agbno || agbno == NULLAGBLOCK || agbno >= mp->m_sb.sb_agblocks) {
|
|
|
|
xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agbno");
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EINVAL;
|
2013-06-27 00:04:55 -06:00
|
|
|
}
|
|
|
|
isize = be32_to_cpu(icl->icl_isize);
|
|
|
|
if (isize != mp->m_sb.sb_inodesize) {
|
|
|
|
xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad isize");
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EINVAL;
|
2013-06-27 00:04:55 -06:00
|
|
|
}
|
|
|
|
count = be32_to_cpu(icl->icl_count);
|
|
|
|
if (!count) {
|
|
|
|
xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count");
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EINVAL;
|
2013-06-27 00:04:55 -06:00
|
|
|
}
|
|
|
|
length = be32_to_cpu(icl->icl_length);
|
|
|
|
if (!length || length >= mp->m_sb.sb_agblocks) {
|
|
|
|
xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad length");
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EINVAL;
|
2013-06-27 00:04:55 -06:00
|
|
|
}
|
|
|
|
|
2015-05-28 17:06:30 -06:00
|
|
|
/*
|
|
|
|
* The inode chunk is either full or sparse and we only support
|
|
|
|
* m_ialloc_min_blks sized sparse allocations at this time.
|
|
|
|
*/
|
|
|
|
if (length != mp->m_ialloc_blks &&
|
|
|
|
length != mp->m_ialloc_min_blks) {
|
|
|
|
xfs_warn(log->l_mp,
|
|
|
|
"%s: unsupported chunk length", __FUNCTION__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* verify inode count is consistent with extent length */
|
|
|
|
if ((count >> mp->m_sb.sb_inopblog) != length) {
|
|
|
|
xfs_warn(log->l_mp,
|
|
|
|
"%s: inconsistent inode count and chunk length",
|
|
|
|
__FUNCTION__);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EINVAL;
|
2013-06-27 00:04:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-08-18 17:59:38 -06:00
|
|
|
* The icreate transaction can cover multiple cluster buffers and these
|
|
|
|
* buffers could have been freed and reused. Check the individual
|
|
|
|
* buffers for cancellation so we don't overwrite anything written after
|
|
|
|
* a cancellation.
|
|
|
|
*/
|
|
|
|
blks_per_cluster = xfs_icluster_size_fsb(mp);
|
|
|
|
bb_per_cluster = XFS_FSB_TO_BB(mp, blks_per_cluster);
|
|
|
|
nbufs = length / blks_per_cluster;
|
|
|
|
for (i = 0, cancel_count = 0; i < nbufs; i++) {
|
|
|
|
xfs_daddr_t daddr;
|
|
|
|
|
|
|
|
daddr = XFS_AGB_TO_DADDR(mp, agno,
|
|
|
|
agbno + i * blks_per_cluster);
|
|
|
|
if (xlog_check_buffer_cancelled(log, daddr, bb_per_cluster, 0))
|
|
|
|
cancel_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We currently only use icreate for a single allocation at a time. This
|
|
|
|
* means we should expect either all or none of the buffers to be
|
|
|
|
* cancelled. Be conservative and skip replay if at least one buffer is
|
|
|
|
* cancelled, but warn the user that something is awry if the buffers
|
|
|
|
* are not consistent.
|
2013-06-27 00:04:55 -06:00
|
|
|
*
|
2015-08-18 17:59:38 -06:00
|
|
|
* XXX: This must be refined to only skip cancelled clusters once we use
|
|
|
|
* icreate for multiple chunk allocations.
|
2013-06-27 00:04:55 -06:00
|
|
|
*/
|
2015-08-18 17:59:38 -06:00
|
|
|
ASSERT(!cancel_count || cancel_count == nbufs);
|
|
|
|
if (cancel_count) {
|
|
|
|
if (cancel_count != nbufs)
|
|
|
|
xfs_warn(mp,
|
|
|
|
"WARNING: partial inode chunk cancellation, skipped icreate.");
|
2015-08-18 17:58:48 -06:00
|
|
|
trace_xfs_log_recover_icreate_cancel(log, icl);
|
2013-06-27 00:04:55 -06:00
|
|
|
return 0;
|
2015-08-18 17:58:48 -06:00
|
|
|
}
|
2013-06-27 00:04:55 -06:00
|
|
|
|
2015-08-18 17:58:48 -06:00
|
|
|
trace_xfs_log_recover_icreate_recover(log, icl);
|
2015-08-18 17:59:38 -06:00
|
|
|
return xfs_ialloc_inode_init(mp, NULL, buffer_list, count, agno, agbno,
|
|
|
|
length, be32_to_cpu(icl->icl_gen));
|
2013-06-27 00:04:55 -06:00
|
|
|
}
|
|
|
|
|
2013-08-14 01:16:03 -06:00
|
|
|
STATIC void
|
|
|
|
xlog_recover_buffer_ra_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item)
|
|
|
|
{
|
|
|
|
struct xfs_buf_log_format *buf_f = item->ri_buf[0].i_addr;
|
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
|
2013-08-26 16:10:53 -06:00
|
|
|
if (xlog_peek_buffer_cancelled(log, buf_f->blf_blkno,
|
2013-08-14 01:16:03 -06:00
|
|
|
buf_f->blf_len, buf_f->blf_flags)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_buf_readahead(mp->m_ddev_targp, buf_f->blf_blkno,
|
|
|
|
buf_f->blf_len, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_inode_ra_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item)
|
|
|
|
{
|
|
|
|
struct xfs_inode_log_format ilf_buf;
|
|
|
|
struct xfs_inode_log_format *ilfp;
|
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format)) {
|
|
|
|
ilfp = item->ri_buf[0].i_addr;
|
|
|
|
} else {
|
|
|
|
ilfp = &ilf_buf;
|
|
|
|
memset(ilfp, 0, sizeof(*ilfp));
|
|
|
|
error = xfs_inode_item_format_convert(&item->ri_buf[0], ilfp);
|
|
|
|
if (error)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-08-26 16:10:53 -06:00
|
|
|
if (xlog_peek_buffer_cancelled(log, ilfp->ilf_blkno, ilfp->ilf_len, 0))
|
2013-08-14 01:16:03 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
xfs_buf_readahead(mp->m_ddev_targp, ilfp->ilf_blkno,
|
2013-08-26 19:39:37 -06:00
|
|
|
ilfp->ilf_len, &xfs_inode_buf_ra_ops);
|
2013-08-14 01:16:03 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_dquot_ra_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
struct xfs_disk_dquot *recddq;
|
|
|
|
struct xfs_dq_logformat *dq_f;
|
|
|
|
uint type;
|
2016-01-11 13:04:01 -07:00
|
|
|
int len;
|
2013-08-14 01:16:03 -06:00
|
|
|
|
|
|
|
|
|
|
|
if (mp->m_qflags == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
recddq = item->ri_buf[1].i_addr;
|
|
|
|
if (recddq == NULL)
|
|
|
|
return;
|
|
|
|
if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot))
|
|
|
|
return;
|
|
|
|
|
|
|
|
type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
|
|
|
|
ASSERT(type);
|
|
|
|
if (log->l_quotaoffs_flag & type)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dq_f = item->ri_buf[0].i_addr;
|
|
|
|
ASSERT(dq_f);
|
|
|
|
ASSERT(dq_f->qlf_len == 1);
|
|
|
|
|
2016-01-11 13:04:01 -07:00
|
|
|
len = XFS_FSB_TO_BB(mp, dq_f->qlf_len);
|
|
|
|
if (xlog_peek_buffer_cancelled(log, dq_f->qlf_blkno, len, 0))
|
|
|
|
return;
|
|
|
|
|
|
|
|
xfs_buf_readahead(mp->m_ddev_targp, dq_f->qlf_blkno, len,
|
|
|
|
&xfs_dquot_buf_ra_ops);
|
2013-08-14 01:16:03 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_ra_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover_item *item)
|
|
|
|
{
|
|
|
|
switch (ITEM_TYPE(item)) {
|
|
|
|
case XFS_LI_BUF:
|
|
|
|
xlog_recover_buffer_ra_pass2(log, item);
|
|
|
|
break;
|
|
|
|
case XFS_LI_INODE:
|
|
|
|
xlog_recover_inode_ra_pass2(log, item);
|
|
|
|
break;
|
|
|
|
case XFS_LI_DQUOT:
|
|
|
|
xlog_recover_dquot_ra_pass2(log, item);
|
|
|
|
break;
|
|
|
|
case XFS_LI_EFI:
|
|
|
|
case XFS_LI_EFD:
|
|
|
|
case XFS_LI_QUOTAOFF:
|
2016-08-02 20:09:48 -06:00
|
|
|
case XFS_LI_RUI:
|
|
|
|
case XFS_LI_RUD:
|
2016-10-03 10:11:21 -06:00
|
|
|
case XFS_LI_CUI:
|
|
|
|
case XFS_LI_CUD:
|
2016-10-03 10:11:26 -06:00
|
|
|
case XFS_LI_BUI:
|
|
|
|
case XFS_LI_BUD:
|
2013-08-14 01:16:03 -06:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-01 15:06:23 -07:00
|
|
|
STATIC int
|
2010-12-01 15:06:24 -07:00
|
|
|
xlog_recover_commit_pass1(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover *trans,
|
|
|
|
struct xlog_recover_item *item)
|
2010-12-01 15:06:23 -07:00
|
|
|
{
|
2010-12-01 15:06:24 -07:00
|
|
|
trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS1);
|
2010-12-01 15:06:23 -07:00
|
|
|
|
|
|
|
switch (ITEM_TYPE(item)) {
|
|
|
|
case XFS_LI_BUF:
|
2010-12-01 15:06:24 -07:00
|
|
|
return xlog_recover_buffer_pass1(log, item);
|
|
|
|
case XFS_LI_QUOTAOFF:
|
|
|
|
return xlog_recover_quotaoff_pass1(log, item);
|
2010-12-01 15:06:23 -07:00
|
|
|
case XFS_LI_INODE:
|
|
|
|
case XFS_LI_EFI:
|
|
|
|
case XFS_LI_EFD:
|
2010-12-01 15:06:24 -07:00
|
|
|
case XFS_LI_DQUOT:
|
2013-06-27 00:04:55 -06:00
|
|
|
case XFS_LI_ICREATE:
|
2016-08-02 20:09:48 -06:00
|
|
|
case XFS_LI_RUI:
|
|
|
|
case XFS_LI_RUD:
|
2016-10-03 10:11:21 -06:00
|
|
|
case XFS_LI_CUI:
|
|
|
|
case XFS_LI_CUD:
|
2016-10-03 10:11:26 -06:00
|
|
|
case XFS_LI_BUI:
|
|
|
|
case XFS_LI_BUD:
|
2010-12-01 15:06:24 -07:00
|
|
|
/* nothing to do in pass 1 */
|
2010-12-01 15:06:23 -07:00
|
|
|
return 0;
|
2010-12-01 15:06:24 -07:00
|
|
|
default:
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp, "%s: invalid item type (%d)",
|
|
|
|
__func__, ITEM_TYPE(item));
|
2010-12-01 15:06:24 -07:00
|
|
|
ASSERT(0);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2010-12-01 15:06:24 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_commit_pass2(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover *trans,
|
|
|
|
struct list_head *buffer_list,
|
|
|
|
struct xlog_recover_item *item)
|
2010-12-01 15:06:24 -07:00
|
|
|
{
|
|
|
|
trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS2);
|
|
|
|
|
|
|
|
switch (ITEM_TYPE(item)) {
|
|
|
|
case XFS_LI_BUF:
|
2013-08-28 05:22:47 -06:00
|
|
|
return xlog_recover_buffer_pass2(log, buffer_list, item,
|
|
|
|
trans->r_lsn);
|
2010-12-01 15:06:24 -07:00
|
|
|
case XFS_LI_INODE:
|
2013-08-28 05:22:47 -06:00
|
|
|
return xlog_recover_inode_pass2(log, buffer_list, item,
|
|
|
|
trans->r_lsn);
|
2010-12-01 15:06:24 -07:00
|
|
|
case XFS_LI_EFI:
|
|
|
|
return xlog_recover_efi_pass2(log, item, trans->r_lsn);
|
|
|
|
case XFS_LI_EFD:
|
|
|
|
return xlog_recover_efd_pass2(log, item);
|
2016-08-02 20:09:48 -06:00
|
|
|
case XFS_LI_RUI:
|
|
|
|
return xlog_recover_rui_pass2(log, item, trans->r_lsn);
|
|
|
|
case XFS_LI_RUD:
|
|
|
|
return xlog_recover_rud_pass2(log, item);
|
2016-10-03 10:11:21 -06:00
|
|
|
case XFS_LI_CUI:
|
|
|
|
return xlog_recover_cui_pass2(log, item, trans->r_lsn);
|
|
|
|
case XFS_LI_CUD:
|
|
|
|
return xlog_recover_cud_pass2(log, item);
|
2016-10-03 10:11:26 -06:00
|
|
|
case XFS_LI_BUI:
|
|
|
|
return xlog_recover_bui_pass2(log, item, trans->r_lsn);
|
|
|
|
case XFS_LI_BUD:
|
|
|
|
return xlog_recover_bud_pass2(log, item);
|
2010-12-01 15:06:23 -07:00
|
|
|
case XFS_LI_DQUOT:
|
2013-08-28 05:22:47 -06:00
|
|
|
return xlog_recover_dquot_pass2(log, buffer_list, item,
|
|
|
|
trans->r_lsn);
|
2013-06-27 00:04:55 -06:00
|
|
|
case XFS_LI_ICREATE:
|
|
|
|
return xlog_recover_do_icreate_pass2(log, buffer_list, item);
|
2010-12-01 15:06:23 -07:00
|
|
|
case XFS_LI_QUOTAOFF:
|
2010-12-01 15:06:24 -07:00
|
|
|
/* nothing to do in pass2 */
|
|
|
|
return 0;
|
2010-12-01 15:06:23 -07:00
|
|
|
default:
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp, "%s: invalid item type (%d)",
|
|
|
|
__func__, ITEM_TYPE(item));
|
2010-12-01 15:06:23 -07:00
|
|
|
ASSERT(0);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2010-12-01 15:06:23 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-14 01:16:03 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_recover_items_pass2(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover *trans,
|
|
|
|
struct list_head *buffer_list,
|
|
|
|
struct list_head *item_list)
|
|
|
|
{
|
|
|
|
struct xlog_recover_item *item;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
list_for_each_entry(item, item_list, ri_list) {
|
|
|
|
error = xlog_recover_commit_pass2(log, trans,
|
|
|
|
buffer_list, item);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2010-12-01 15:06:23 -07:00
|
|
|
/*
|
|
|
|
* Perform the transaction.
|
|
|
|
*
|
|
|
|
* If the transaction modifies a buffer or inode, do it now. Otherwise,
|
|
|
|
* EFIs and EFDs get queued up by adding entries into the AIL for them.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_recover_commit_trans(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2010-12-01 15:06:23 -07:00
|
|
|
struct xlog_recover *trans,
|
2016-09-25 16:22:16 -06:00
|
|
|
int pass,
|
|
|
|
struct list_head *buffer_list)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-08-14 01:16:03 -06:00
|
|
|
int error = 0;
|
|
|
|
int items_queued = 0;
|
|
|
|
struct xlog_recover_item *item;
|
|
|
|
struct xlog_recover_item *next;
|
|
|
|
LIST_HEAD (ra_list);
|
|
|
|
LIST_HEAD (done_list);
|
|
|
|
|
|
|
|
#define XLOG_RECOVER_COMMIT_QUEUE_MAX 100
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-06-24 11:11:41 -06:00
|
|
|
hlist_del_init(&trans->r_list);
|
2010-12-01 15:06:23 -07:00
|
|
|
|
|
|
|
error = xlog_recover_reorder_trans(log, trans, pass);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
2010-12-01 15:06:23 -07:00
|
|
|
|
2013-08-14 01:16:03 -06:00
|
|
|
list_for_each_entry_safe(item, next, &trans->r_itemq, ri_list) {
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
switch (pass) {
|
|
|
|
case XLOG_RECOVER_PASS1:
|
2010-12-01 15:06:24 -07:00
|
|
|
error = xlog_recover_commit_pass1(log, trans, item);
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
break;
|
|
|
|
case XLOG_RECOVER_PASS2:
|
2013-08-14 01:16:03 -06:00
|
|
|
xlog_recover_ra_pass2(log, item);
|
|
|
|
list_move_tail(&item->ri_list, &ra_list);
|
|
|
|
items_queued++;
|
|
|
|
if (items_queued >= XLOG_RECOVER_COMMIT_QUEUE_MAX) {
|
|
|
|
error = xlog_recover_items_pass2(log, trans,
|
2016-09-25 16:22:16 -06:00
|
|
|
buffer_list, &ra_list);
|
2013-08-14 01:16:03 -06:00
|
|
|
list_splice_tail_init(&ra_list, &done_list);
|
|
|
|
items_queued = 0;
|
|
|
|
}
|
|
|
|
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ASSERT(0);
|
|
|
|
}
|
|
|
|
|
2010-12-01 15:06:23 -07:00
|
|
|
if (error)
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
goto out;
|
2010-12-01 15:06:23 -07:00
|
|
|
}
|
|
|
|
|
2013-08-14 01:16:03 -06:00
|
|
|
out:
|
|
|
|
if (!list_empty(&ra_list)) {
|
|
|
|
if (!error)
|
|
|
|
error = xlog_recover_items_pass2(log, trans,
|
2016-09-25 16:22:16 -06:00
|
|
|
buffer_list, &ra_list);
|
2013-08-14 01:16:03 -06:00
|
|
|
list_splice_tail_init(&ra_list, &done_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!list_empty(&done_list))
|
|
|
|
list_splice_init(&done_list, &trans->r_itemq);
|
|
|
|
|
2016-09-25 16:22:16 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-09-28 17:45:42 -06:00
|
|
|
STATIC void
|
|
|
|
xlog_recover_add_item(
|
|
|
|
struct list_head *head)
|
|
|
|
{
|
|
|
|
xlog_recover_item_t *item;
|
|
|
|
|
|
|
|
item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
|
|
|
|
INIT_LIST_HEAD(&item->ri_list);
|
|
|
|
list_add_tail(&item->ri_list, head);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
STATIC int
|
2014-09-28 17:45:42 -06:00
|
|
|
xlog_recover_add_to_cont_trans(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover *trans,
|
2015-06-21 17:45:10 -06:00
|
|
|
char *dp,
|
2014-09-28 17:45:42 -06:00
|
|
|
int len)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-09-28 17:45:42 -06:00
|
|
|
xlog_recover_item_t *item;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *ptr, *old_ptr;
|
2014-09-28 17:45:42 -06:00
|
|
|
int old_len;
|
|
|
|
|
2015-07-28 19:51:10 -06:00
|
|
|
/*
|
|
|
|
* If the transaction is empty, the header was split across this and the
|
|
|
|
* previous record. Copy the rest of the header.
|
|
|
|
*/
|
2014-09-28 17:45:42 -06:00
|
|
|
if (list_empty(&trans->r_itemq)) {
|
2015-11-09 16:10:33 -07:00
|
|
|
ASSERT(len <= sizeof(struct xfs_trans_header));
|
2015-07-28 19:51:10 -06:00
|
|
|
if (len > sizeof(struct xfs_trans_header)) {
|
|
|
|
xfs_warn(log->l_mp, "%s: bad header length", __func__);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2014-09-28 17:45:42 -06:00
|
|
|
xlog_recover_add_item(&trans->r_itemq);
|
2015-06-21 17:45:10 -06:00
|
|
|
ptr = (char *)&trans->r_theader +
|
2015-07-28 19:51:10 -06:00
|
|
|
sizeof(struct xfs_trans_header) - len;
|
2014-09-28 17:45:42 -06:00
|
|
|
memcpy(ptr, dp, len);
|
|
|
|
return 0;
|
|
|
|
}
|
2015-07-28 19:51:10 -06:00
|
|
|
|
2014-09-28 17:45:42 -06:00
|
|
|
/* take the tail entry */
|
|
|
|
item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
|
|
|
|
|
|
|
|
old_ptr = item->ri_buf[item->ri_cnt-1].i_addr;
|
|
|
|
old_len = item->ri_buf[item->ri_cnt-1].i_len;
|
|
|
|
|
2016-04-05 17:47:01 -06:00
|
|
|
ptr = kmem_realloc(old_ptr, len + old_len, KM_SLEEP);
|
2014-09-28 17:45:42 -06:00
|
|
|
memcpy(&ptr[old_len], dp, len);
|
|
|
|
item->ri_buf[item->ri_cnt-1].i_len += len;
|
|
|
|
item->ri_buf[item->ri_cnt-1].i_addr = ptr;
|
|
|
|
trace_xfs_log_recover_item_add_cont(log, trans, item, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-28 17:45:42 -06:00
|
|
|
/*
|
|
|
|
* The next region to add is the start of a new region. It could be
|
|
|
|
* a whole region or it could be the first part of a new region. Because
|
|
|
|
* of this, the assumption here is that the type and size fields of all
|
|
|
|
* format structures fit into the first 32 bits of the structure.
|
|
|
|
*
|
|
|
|
* This works because all regions must be 32 bit aligned. Therefore, we
|
|
|
|
* either have both fields or we have neither field. In the case we have
|
|
|
|
* neither field, the data part of the region is zero length. We only have
|
|
|
|
* a log_op_header and can throw away the header since a new one will appear
|
|
|
|
* later. If we have at least 4 bytes, then we can determine how many regions
|
|
|
|
* will appear in the current log item.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_add_to_trans(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover *trans,
|
2015-06-21 17:45:10 -06:00
|
|
|
char *dp,
|
2014-09-28 17:45:42 -06:00
|
|
|
int len)
|
|
|
|
{
|
|
|
|
xfs_inode_log_format_t *in_f; /* any will do */
|
|
|
|
xlog_recover_item_t *item;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *ptr;
|
2014-09-28 17:45:42 -06:00
|
|
|
|
|
|
|
if (!len)
|
|
|
|
return 0;
|
|
|
|
if (list_empty(&trans->r_itemq)) {
|
|
|
|
/* we need to catch log corruptions here */
|
|
|
|
if (*(uint *)dp != XFS_TRANS_HEADER_MAGIC) {
|
|
|
|
xfs_warn(log->l_mp, "%s: bad header magic number",
|
|
|
|
__func__);
|
|
|
|
ASSERT(0);
|
|
|
|
return -EIO;
|
|
|
|
}
|
2015-07-28 19:51:10 -06:00
|
|
|
|
|
|
|
if (len > sizeof(struct xfs_trans_header)) {
|
|
|
|
xfs_warn(log->l_mp, "%s: bad header length", __func__);
|
|
|
|
ASSERT(0);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The transaction header can be arbitrarily split across op
|
|
|
|
* records. If we don't have the whole thing here, copy what we
|
|
|
|
* do have and handle the rest in the next record.
|
|
|
|
*/
|
|
|
|
if (len == sizeof(struct xfs_trans_header))
|
2014-09-28 17:45:42 -06:00
|
|
|
xlog_recover_add_item(&trans->r_itemq);
|
|
|
|
memcpy(&trans->r_theader, dp, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr = kmem_alloc(len, KM_SLEEP);
|
|
|
|
memcpy(ptr, dp, len);
|
|
|
|
in_f = (xfs_inode_log_format_t *)ptr;
|
|
|
|
|
|
|
|
/* take the tail entry */
|
|
|
|
item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
|
|
|
|
if (item->ri_total != 0 &&
|
|
|
|
item->ri_total == item->ri_cnt) {
|
|
|
|
/* tail item is in use, get a new one */
|
|
|
|
xlog_recover_add_item(&trans->r_itemq);
|
|
|
|
item = list_entry(trans->r_itemq.prev,
|
|
|
|
xlog_recover_item_t, ri_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (item->ri_total == 0) { /* first region to be added */
|
|
|
|
if (in_f->ilf_size == 0 ||
|
|
|
|
in_f->ilf_size > XLOG_MAX_REGIONS_IN_ITEM) {
|
|
|
|
xfs_warn(log->l_mp,
|
|
|
|
"bad number of regions (%d) in inode log format",
|
|
|
|
in_f->ilf_size);
|
|
|
|
ASSERT(0);
|
|
|
|
kmem_free(ptr);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
item->ri_total = in_f->ilf_size;
|
|
|
|
item->ri_buf =
|
|
|
|
kmem_zalloc(item->ri_total * sizeof(xfs_log_iovec_t),
|
|
|
|
KM_SLEEP);
|
|
|
|
}
|
|
|
|
ASSERT(item->ri_total > item->ri_cnt);
|
|
|
|
/* Description region is ri_buf[0] */
|
|
|
|
item->ri_buf[item->ri_cnt].i_addr = ptr;
|
|
|
|
item->ri_buf[item->ri_cnt].i_len = len;
|
|
|
|
item->ri_cnt++;
|
|
|
|
trace_xfs_log_recover_item_add(log, trans, item, 0);
|
|
|
|
return 0;
|
|
|
|
}
|
2014-09-28 17:45:54 -06:00
|
|
|
|
2014-09-28 17:45:42 -06:00
|
|
|
/*
|
|
|
|
* Free up any resources allocated by the transaction
|
|
|
|
*
|
|
|
|
* Remember that EFIs, EFDs, and IUNLINKs are handled later.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_free_trans(
|
|
|
|
struct xlog_recover *trans)
|
|
|
|
{
|
|
|
|
xlog_recover_item_t *item, *n;
|
|
|
|
int i;
|
|
|
|
|
2017-06-24 11:11:41 -06:00
|
|
|
hlist_del_init(&trans->r_list);
|
|
|
|
|
2014-09-28 17:45:42 -06:00
|
|
|
list_for_each_entry_safe(item, n, &trans->r_itemq, ri_list) {
|
|
|
|
/* Free the regions in the item. */
|
|
|
|
list_del(&item->ri_list);
|
|
|
|
for (i = 0; i < item->ri_cnt; i++)
|
|
|
|
kmem_free(item->ri_buf[i].i_addr);
|
|
|
|
/* Free the item itself */
|
|
|
|
kmem_free(item->ri_buf);
|
|
|
|
kmem_free(item);
|
|
|
|
}
|
|
|
|
/* Free the transaction recover structure */
|
|
|
|
kmem_free(trans);
|
|
|
|
}
|
|
|
|
|
2014-09-28 17:45:18 -06:00
|
|
|
/*
|
|
|
|
* On error or completion, trans is freed.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
STATIC int
|
2014-09-28 17:45:03 -06:00
|
|
|
xlog_recovery_process_trans(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_recover *trans,
|
2015-06-21 17:45:10 -06:00
|
|
|
char *dp,
|
2014-09-28 17:45:03 -06:00
|
|
|
unsigned int len,
|
|
|
|
unsigned int flags,
|
2016-09-25 16:22:16 -06:00
|
|
|
int pass,
|
|
|
|
struct list_head *buffer_list)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-09-28 17:45:18 -06:00
|
|
|
int error = 0;
|
|
|
|
bool freeit = false;
|
2014-09-28 17:45:03 -06:00
|
|
|
|
|
|
|
/* mask off ophdr transaction container flags */
|
|
|
|
flags &= ~XLOG_END_TRANS;
|
|
|
|
if (flags & XLOG_WAS_CONT_TRANS)
|
|
|
|
flags &= ~XLOG_CONTINUE_TRANS;
|
|
|
|
|
2014-09-28 17:45:32 -06:00
|
|
|
/*
|
|
|
|
* Callees must not free the trans structure. We'll decide if we need to
|
|
|
|
* free it or not based on the operation being done and it's result.
|
|
|
|
*/
|
2014-09-28 17:45:03 -06:00
|
|
|
switch (flags) {
|
|
|
|
/* expected flag values */
|
|
|
|
case 0:
|
|
|
|
case XLOG_CONTINUE_TRANS:
|
|
|
|
error = xlog_recover_add_to_trans(log, trans, dp, len);
|
|
|
|
break;
|
|
|
|
case XLOG_WAS_CONT_TRANS:
|
|
|
|
error = xlog_recover_add_to_cont_trans(log, trans, dp, len);
|
|
|
|
break;
|
|
|
|
case XLOG_COMMIT_TRANS:
|
2016-09-25 16:22:16 -06:00
|
|
|
error = xlog_recover_commit_trans(log, trans, pass,
|
|
|
|
buffer_list);
|
2014-09-28 17:45:32 -06:00
|
|
|
/* success or fail, we are now done with this transaction. */
|
|
|
|
freeit = true;
|
2014-09-28 17:45:03 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* unexpected flag values */
|
|
|
|
case XLOG_UNMOUNT_TRANS:
|
2014-09-28 17:45:18 -06:00
|
|
|
/* just skip trans */
|
2014-09-28 17:45:03 -06:00
|
|
|
xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
|
2014-09-28 17:45:18 -06:00
|
|
|
freeit = true;
|
2014-09-28 17:45:03 -06:00
|
|
|
break;
|
|
|
|
case XLOG_START_TRANS:
|
|
|
|
default:
|
|
|
|
xfs_warn(log->l_mp, "%s: bad flag 0x%x", __func__, flags);
|
|
|
|
ASSERT(0);
|
2014-09-28 17:45:18 -06:00
|
|
|
error = -EIO;
|
2014-09-28 17:45:03 -06:00
|
|
|
break;
|
|
|
|
}
|
2014-09-28 17:45:18 -06:00
|
|
|
if (error || freeit)
|
|
|
|
xlog_recover_free_trans(trans);
|
2014-09-28 17:45:03 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2014-09-28 17:45:54 -06:00
|
|
|
/*
|
|
|
|
* Lookup the transaction recovery structure associated with the ID in the
|
|
|
|
* current ophdr. If the transaction doesn't exist and the start flag is set in
|
|
|
|
* the ophdr, then allocate a new transaction for future ID matches to find.
|
|
|
|
* Either way, return what we found during the lookup - an existing transaction
|
|
|
|
* or nothing.
|
|
|
|
*/
|
2014-09-28 17:45:03 -06:00
|
|
|
STATIC struct xlog_recover *
|
|
|
|
xlog_recover_ophdr_to_trans(
|
|
|
|
struct hlist_head rhash[],
|
|
|
|
struct xlog_rec_header *rhead,
|
|
|
|
struct xlog_op_header *ohead)
|
|
|
|
{
|
|
|
|
struct xlog_recover *trans;
|
|
|
|
xlog_tid_t tid;
|
|
|
|
struct hlist_head *rhp;
|
|
|
|
|
|
|
|
tid = be32_to_cpu(ohead->oh_tid);
|
|
|
|
rhp = &rhash[XLOG_RHASH(tid)];
|
2014-09-28 17:45:54 -06:00
|
|
|
hlist_for_each_entry(trans, rhp, r_list) {
|
|
|
|
if (trans->r_log_tid == tid)
|
|
|
|
return trans;
|
|
|
|
}
|
2014-09-28 17:45:03 -06:00
|
|
|
|
|
|
|
/*
|
2014-09-28 17:45:54 -06:00
|
|
|
* skip over non-start transaction headers - we could be
|
|
|
|
* processing slack space before the next transaction starts
|
|
|
|
*/
|
|
|
|
if (!(ohead->oh_flags & XLOG_START_TRANS))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ASSERT(be32_to_cpu(ohead->oh_len) == 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is a new transaction so allocate a new recovery container to
|
|
|
|
* hold the recovery ops that will follow.
|
|
|
|
*/
|
|
|
|
trans = kmem_zalloc(sizeof(struct xlog_recover), KM_SLEEP);
|
|
|
|
trans->r_log_tid = tid;
|
|
|
|
trans->r_lsn = be64_to_cpu(rhead->h_lsn);
|
|
|
|
INIT_LIST_HEAD(&trans->r_itemq);
|
|
|
|
INIT_HLIST_NODE(&trans->r_list);
|
|
|
|
hlist_add_head(&trans->r_list, rhp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Nothing more to do for this ophdr. Items to be added to this new
|
|
|
|
* transaction will be in subsequent ophdr containers.
|
2014-09-28 17:45:03 -06:00
|
|
|
*/
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_process_ophdr(
|
|
|
|
struct xlog *log,
|
|
|
|
struct hlist_head rhash[],
|
|
|
|
struct xlog_rec_header *rhead,
|
|
|
|
struct xlog_op_header *ohead,
|
2015-06-21 17:45:10 -06:00
|
|
|
char *dp,
|
|
|
|
char *end,
|
2016-09-25 16:22:16 -06:00
|
|
|
int pass,
|
|
|
|
struct list_head *buffer_list)
|
2014-09-28 17:45:03 -06:00
|
|
|
{
|
|
|
|
struct xlog_recover *trans;
|
|
|
|
unsigned int len;
|
2016-09-25 16:22:16 -06:00
|
|
|
int error;
|
2014-09-28 17:45:03 -06:00
|
|
|
|
|
|
|
/* Do we understand who wrote this op? */
|
|
|
|
if (ohead->oh_clientid != XFS_TRANSACTION &&
|
|
|
|
ohead->oh_clientid != XFS_LOG) {
|
|
|
|
xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
|
|
|
|
__func__, ohead->oh_clientid);
|
|
|
|
ASSERT(0);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check the ophdr contains all the data it is supposed to contain.
|
|
|
|
*/
|
|
|
|
len = be32_to_cpu(ohead->oh_len);
|
|
|
|
if (dp + len > end) {
|
|
|
|
xfs_warn(log->l_mp, "%s: bad length 0x%x", __func__, len);
|
|
|
|
WARN_ON(1);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
trans = xlog_recover_ophdr_to_trans(rhash, rhead, ohead);
|
|
|
|
if (!trans) {
|
|
|
|
/* nothing to do, so skip over this ophdr */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-09-25 16:22:16 -06:00
|
|
|
/*
|
|
|
|
* The recovered buffer queue is drained only once we know that all
|
|
|
|
* recovery items for the current LSN have been processed. This is
|
|
|
|
* required because:
|
|
|
|
*
|
|
|
|
* - Buffer write submission updates the metadata LSN of the buffer.
|
|
|
|
* - Log recovery skips items with a metadata LSN >= the current LSN of
|
|
|
|
* the recovery item.
|
|
|
|
* - Separate recovery items against the same metadata buffer can share
|
|
|
|
* a current LSN. I.e., consider that the LSN of a recovery item is
|
|
|
|
* defined as the starting LSN of the first record in which its
|
|
|
|
* transaction appears, that a record can hold multiple transactions,
|
|
|
|
* and/or that a transaction can span multiple records.
|
|
|
|
*
|
|
|
|
* In other words, we are allowed to submit a buffer from log recovery
|
|
|
|
* once per current LSN. Otherwise, we may incorrectly skip recovery
|
|
|
|
* items and cause corruption.
|
|
|
|
*
|
|
|
|
* We don't know up front whether buffers are updated multiple times per
|
|
|
|
* LSN. Therefore, track the current LSN of each commit log record as it
|
|
|
|
* is processed and drain the queue when it changes. Use commit records
|
|
|
|
* because they are ordered correctly by the logging code.
|
|
|
|
*/
|
|
|
|
if (log->l_recovery_lsn != trans->r_lsn &&
|
|
|
|
ohead->oh_flags & XLOG_COMMIT_TRANS) {
|
|
|
|
error = xfs_buf_delwri_submit(buffer_list);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
log->l_recovery_lsn = trans->r_lsn;
|
|
|
|
}
|
|
|
|
|
2014-09-28 17:45:18 -06:00
|
|
|
return xlog_recovery_process_trans(log, trans, dp, len,
|
2016-09-25 16:22:16 -06:00
|
|
|
ohead->oh_flags, pass, buffer_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There are two valid states of the r_state field. 0 indicates that the
|
|
|
|
* transaction structure is in a normal state. We have either seen the
|
|
|
|
* start of the transaction or the last operation we added was not a partial
|
|
|
|
* operation. If the last operation we added to the transaction was a
|
|
|
|
* partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
|
|
|
|
*
|
|
|
|
* NOTE: skip LRs with 0 data length.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_process_data(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2010-01-11 04:49:57 -07:00
|
|
|
struct hlist_head rhash[],
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog_rec_header *rhead,
|
2015-06-21 17:45:10 -06:00
|
|
|
char *dp,
|
2016-09-25 16:22:16 -06:00
|
|
|
int pass,
|
|
|
|
struct list_head *buffer_list)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-09-28 17:45:03 -06:00
|
|
|
struct xlog_op_header *ohead;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *end;
|
2005-04-16 16:20:36 -06:00
|
|
|
int num_logops;
|
|
|
|
int error;
|
|
|
|
|
2014-09-28 17:45:03 -06:00
|
|
|
end = dp + be32_to_cpu(rhead->h_len);
|
2007-10-11 18:59:34 -06:00
|
|
|
num_logops = be32_to_cpu(rhead->h_num_logops);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* check the log format matches our own - else we can't recover */
|
|
|
|
if (xlog_header_check_recover(log->l_mp, rhead))
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-09-25 16:34:52 -06:00
|
|
|
trace_xfs_log_recover_record(log, rhead, pass);
|
2014-09-28 17:45:03 -06:00
|
|
|
while ((dp < end) && num_logops) {
|
|
|
|
|
|
|
|
ohead = (struct xlog_op_header *)dp;
|
|
|
|
dp += sizeof(*ohead);
|
|
|
|
ASSERT(dp <= end);
|
|
|
|
|
|
|
|
/* errors will abort recovery */
|
|
|
|
error = xlog_recover_process_ophdr(log, rhash, rhead, ohead,
|
2016-09-25 16:22:16 -06:00
|
|
|
dp, end, pass, buffer_list);
|
2014-09-28 17:45:03 -06:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2007-10-11 18:58:59 -06:00
|
|
|
dp += be32_to_cpu(ohead->oh_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
num_logops--;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-08-02 19:23:49 -06:00
|
|
|
/* Recover the EFI if necessary. */
|
2008-04-09 20:21:11 -06:00
|
|
|
STATIC int
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_recover_process_efi(
|
2016-08-02 19:23:49 -06:00
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item *lip)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2016-08-02 19:23:49 -06:00
|
|
|
struct xfs_efi_log_item *efip;
|
|
|
|
int error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2016-08-02 19:23:49 -06:00
|
|
|
* Skip EFIs that we've already processed.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2016-08-02 19:23:49 -06:00
|
|
|
efip = container_of(lip, struct xfs_efi_log_item, efi_item);
|
|
|
|
if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags))
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-08-02 19:23:49 -06:00
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
error = xfs_efi_recover(mp, efip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-08-02 19:23:49 -06:00
|
|
|
return error;
|
|
|
|
}
|
2015-08-18 17:51:43 -06:00
|
|
|
|
2016-08-02 19:23:49 -06:00
|
|
|
/* Release the EFI since we're cancelling everything. */
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_cancel_efi(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
struct xfs_efi_log_item *efip;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-08-02 19:23:49 -06:00
|
|
|
efip = container_of(lip, struct xfs_efi_log_item, efi_item);
|
2008-04-09 20:21:53 -06:00
|
|
|
|
2016-08-02 19:23:49 -06:00
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
xfs_efi_release(efip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
}
|
|
|
|
|
2016-08-02 20:09:48 -06:00
|
|
|
/* Recover the RUI if necessary. */
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_process_rui(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
struct xfs_rui_log_item *ruip;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Skip RUIs that we've already processed.
|
|
|
|
*/
|
|
|
|
ruip = container_of(lip, struct xfs_rui_log_item, rui_item);
|
|
|
|
if (test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
error = xfs_rui_recover(mp, ruip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Release the RUI since we're cancelling everything. */
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_cancel_rui(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
struct xfs_rui_log_item *ruip;
|
|
|
|
|
|
|
|
ruip = container_of(lip, struct xfs_rui_log_item, rui_item);
|
|
|
|
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
xfs_rui_release(ruip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
}
|
|
|
|
|
2016-10-03 10:11:21 -06:00
|
|
|
/* Recover the CUI if necessary. */
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_process_cui(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
struct xfs_cui_log_item *cuip;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Skip CUIs that we've already processed.
|
|
|
|
*/
|
|
|
|
cuip = container_of(lip, struct xfs_cui_log_item, cui_item);
|
|
|
|
if (test_bit(XFS_CUI_RECOVERED, &cuip->cui_flags))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
error = xfs_cui_recover(mp, cuip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Release the CUI since we're cancelling everything. */
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_cancel_cui(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
struct xfs_cui_log_item *cuip;
|
|
|
|
|
|
|
|
cuip = container_of(lip, struct xfs_cui_log_item, cui_item);
|
|
|
|
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
xfs_cui_release(cuip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
}
|
|
|
|
|
2016-10-03 10:11:26 -06:00
|
|
|
/* Recover the BUI if necessary. */
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_process_bui(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
struct xfs_bui_log_item *buip;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Skip BUIs that we've already processed.
|
|
|
|
*/
|
|
|
|
buip = container_of(lip, struct xfs_bui_log_item, bui_item);
|
|
|
|
if (test_bit(XFS_BUI_RECOVERED, &buip->bui_flags))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
error = xfs_bui_recover(mp, buip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Release the BUI since we're cancelling everything. */
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_cancel_bui(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_ail *ailp,
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
struct xfs_bui_log_item *buip;
|
|
|
|
|
|
|
|
buip = container_of(lip, struct xfs_bui_log_item, bui_item);
|
|
|
|
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
xfs_bui_release(buip);
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
}
|
|
|
|
|
2016-08-02 19:23:49 -06:00
|
|
|
/* Is this log item a deferred action intent? */
|
|
|
|
static inline bool xlog_item_is_intent(struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
switch (lip->li_type) {
|
|
|
|
case XFS_LI_EFI:
|
2016-08-02 20:09:48 -06:00
|
|
|
case XFS_LI_RUI:
|
2016-10-03 10:11:21 -06:00
|
|
|
case XFS_LI_CUI:
|
2016-10-03 10:11:26 -06:00
|
|
|
case XFS_LI_BUI:
|
2016-08-02 19:23:49 -06:00
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-08-02 19:23:49 -06:00
|
|
|
* When this is called, all of the log intent items which did not have
|
|
|
|
* corresponding log done items should be in the AIL. What we do now
|
|
|
|
* is update the data structures associated with each one.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2016-08-02 19:23:49 -06:00
|
|
|
* Since we process the log intent items in normal transactions, they
|
|
|
|
* will be removed at some point after the commit. This prevents us
|
|
|
|
* from just walking down the list processing each one. We'll use a
|
|
|
|
* flag in the intent item to skip those that we've already processed
|
|
|
|
* and use the AIL iteration mechanism's generation count to try to
|
|
|
|
* speed this up at least a bit.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2016-08-02 19:23:49 -06:00
|
|
|
* When we start, we know that the intents are the only things in the
|
|
|
|
* AIL. As we process them, however, other items are added to the
|
|
|
|
* AIL.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-04-09 20:21:11 -06:00
|
|
|
STATIC int
|
2016-08-02 19:23:49 -06:00
|
|
|
xlog_recover_process_intents(
|
2015-08-18 17:58:36 -06:00
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-08-18 17:58:36 -06:00
|
|
|
struct xfs_log_item *lip;
|
2008-04-09 20:21:11 -06:00
|
|
|
int error = 0;
|
2008-10-30 00:38:39 -06:00
|
|
|
struct xfs_ail_cursor cur;
|
2008-10-30 00:39:35 -06:00
|
|
|
struct xfs_ail *ailp;
|
2016-08-02 19:23:49 -06:00
|
|
|
xfs_lsn_t last_lsn;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-30 00:39:35 -06:00
|
|
|
ailp = log->l_ailp;
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
|
2016-08-02 19:23:49 -06:00
|
|
|
last_lsn = xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block);
|
2005-04-16 16:20:36 -06:00
|
|
|
while (lip != NULL) {
|
|
|
|
/*
|
2016-08-02 19:23:49 -06:00
|
|
|
* We're done when we see something other than an intent.
|
|
|
|
* There should be no intents left in the AIL now.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2016-08-02 19:23:49 -06:00
|
|
|
if (!xlog_item_is_intent(lip)) {
|
2008-10-30 00:38:39 -06:00
|
|
|
#ifdef DEBUG
|
2008-10-30 00:39:35 -06:00
|
|
|
for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
|
2016-08-02 19:23:49 -06:00
|
|
|
ASSERT(!xlog_item_is_intent(lip));
|
2008-10-30 00:38:39 -06:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-08-02 19:23:49 -06:00
|
|
|
* We should never see a redo item with a LSN higher than
|
|
|
|
* the last transaction we found in the log at the start
|
|
|
|
* of recovery.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2016-08-02 19:23:49 -06:00
|
|
|
ASSERT(XFS_LSN_CMP(last_lsn, lip->li_lsn) >= 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-08-02 19:23:49 -06:00
|
|
|
switch (lip->li_type) {
|
|
|
|
case XFS_LI_EFI:
|
|
|
|
error = xlog_recover_process_efi(log->l_mp, ailp, lip);
|
|
|
|
break;
|
2016-08-02 20:09:48 -06:00
|
|
|
case XFS_LI_RUI:
|
|
|
|
error = xlog_recover_process_rui(log->l_mp, ailp, lip);
|
|
|
|
break;
|
2016-10-03 10:11:21 -06:00
|
|
|
case XFS_LI_CUI:
|
|
|
|
error = xlog_recover_process_cui(log->l_mp, ailp, lip);
|
|
|
|
break;
|
2016-10-03 10:11:26 -06:00
|
|
|
case XFS_LI_BUI:
|
|
|
|
error = xlog_recover_process_bui(log->l_mp, ailp, lip);
|
|
|
|
break;
|
2016-08-02 19:23:49 -06:00
|
|
|
}
|
2008-10-30 00:38:39 -06:00
|
|
|
if (error)
|
|
|
|
goto out;
|
2008-10-30 00:39:35 -06:00
|
|
|
lip = xfs_trans_ail_cursor_next(ailp, &cur);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-10-30 00:38:39 -06:00
|
|
|
out:
|
2014-04-14 03:06:05 -06:00
|
|
|
xfs_trans_ail_cursor_done(&cur);
|
2008-10-30 00:39:35 -06:00
|
|
|
spin_unlock(&ailp->xa_lock);
|
2008-04-09 20:21:11 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2015-08-18 17:58:36 -06:00
|
|
|
/*
|
2016-08-02 19:23:49 -06:00
|
|
|
* A cancel occurs when the mount has failed and we're bailing out.
|
|
|
|
* Release all pending log intent items so they don't pin the AIL.
|
2015-08-18 17:58:36 -06:00
|
|
|
*/
|
|
|
|
STATIC int
|
2016-08-02 19:23:49 -06:00
|
|
|
xlog_recover_cancel_intents(
|
2015-08-18 17:58:36 -06:00
|
|
|
struct xlog *log)
|
|
|
|
{
|
|
|
|
struct xfs_log_item *lip;
|
|
|
|
int error = 0;
|
|
|
|
struct xfs_ail_cursor cur;
|
|
|
|
struct xfs_ail *ailp;
|
|
|
|
|
|
|
|
ailp = log->l_ailp;
|
|
|
|
spin_lock(&ailp->xa_lock);
|
|
|
|
lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
|
|
|
|
while (lip != NULL) {
|
|
|
|
/*
|
2016-08-02 19:23:49 -06:00
|
|
|
* We're done when we see something other than an intent.
|
|
|
|
* There should be no intents left in the AIL now.
|
2015-08-18 17:58:36 -06:00
|
|
|
*/
|
2016-08-02 19:23:49 -06:00
|
|
|
if (!xlog_item_is_intent(lip)) {
|
2015-08-18 17:58:36 -06:00
|
|
|
#ifdef DEBUG
|
|
|
|
for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
|
2016-08-02 19:23:49 -06:00
|
|
|
ASSERT(!xlog_item_is_intent(lip));
|
2015-08-18 17:58:36 -06:00
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-08-02 19:23:49 -06:00
|
|
|
switch (lip->li_type) {
|
|
|
|
case XFS_LI_EFI:
|
|
|
|
xlog_recover_cancel_efi(log->l_mp, ailp, lip);
|
|
|
|
break;
|
2016-08-02 20:09:48 -06:00
|
|
|
case XFS_LI_RUI:
|
|
|
|
xlog_recover_cancel_rui(log->l_mp, ailp, lip);
|
|
|
|
break;
|
2016-10-03 10:11:21 -06:00
|
|
|
case XFS_LI_CUI:
|
|
|
|
xlog_recover_cancel_cui(log->l_mp, ailp, lip);
|
|
|
|
break;
|
2016-10-03 10:11:26 -06:00
|
|
|
case XFS_LI_BUI:
|
|
|
|
xlog_recover_cancel_bui(log->l_mp, ailp, lip);
|
|
|
|
break;
|
2016-08-02 19:23:49 -06:00
|
|
|
}
|
2015-08-18 17:58:36 -06:00
|
|
|
|
|
|
|
lip = xfs_trans_ail_cursor_next(ailp, &cur);
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_trans_ail_cursor_done(&cur);
|
|
|
|
spin_unlock(&ailp->xa_lock);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* This routine performs a transaction to null out a bad inode pointer
|
|
|
|
* in an agi unlinked inode hash bucket.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xlog_recover_clear_agi_bucket(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
xfs_agnumber_t agno,
|
|
|
|
int bucket)
|
|
|
|
{
|
|
|
|
xfs_trans_t *tp;
|
|
|
|
xfs_agi_t *agi;
|
|
|
|
xfs_buf_t *agibp;
|
|
|
|
int offset;
|
|
|
|
int error;
|
|
|
|
|
2016-04-05 17:19:55 -06:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_clearagi, 0, 0, 0, &tp);
|
2008-04-09 20:21:18 -06:00
|
|
|
if (error)
|
2016-04-05 17:19:55 -06:00
|
|
|
goto out_error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-27 20:23:37 -07:00
|
|
|
error = xfs_read_agi(mp, tp, agno, &agibp);
|
|
|
|
if (error)
|
2008-04-09 20:21:18 -06:00
|
|
|
goto out_abort;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-27 20:23:37 -07:00
|
|
|
agi = XFS_BUF_TO_AGI(agibp);
|
2005-11-01 21:11:25 -07:00
|
|
|
agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
|
2005-04-16 16:20:36 -06:00
|
|
|
offset = offsetof(xfs_agi_t, agi_unlinked) +
|
|
|
|
(sizeof(xfs_agino_t) * bucket);
|
|
|
|
xfs_trans_log_buf(tp, agibp, offset,
|
|
|
|
(offset + sizeof(xfs_agino_t) - 1));
|
|
|
|
|
2015-06-03 21:48:08 -06:00
|
|
|
error = xfs_trans_commit(tp);
|
2008-04-09 20:21:18 -06:00
|
|
|
if (error)
|
|
|
|
goto out_error;
|
|
|
|
return;
|
|
|
|
|
|
|
|
out_abort:
|
2015-06-03 21:47:56 -06:00
|
|
|
xfs_trans_cancel(tp);
|
2008-04-09 20:21:18 -06:00
|
|
|
out_error:
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp, "%s: failed to clear agi %d. Continuing.", __func__, agno);
|
2008-04-09 20:21:18 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-11-27 20:23:40 -07:00
|
|
|
STATIC xfs_agino_t
|
|
|
|
xlog_recover_process_one_iunlink(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_agnumber_t agno,
|
|
|
|
xfs_agino_t agino,
|
|
|
|
int bucket)
|
|
|
|
{
|
|
|
|
struct xfs_buf *ibp;
|
|
|
|
struct xfs_dinode *dip;
|
|
|
|
struct xfs_inode *ip;
|
|
|
|
xfs_ino_t ino;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
ino = XFS_AGINO_TO_INO(mp, agno, agino);
|
2010-06-23 19:35:17 -06:00
|
|
|
error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
|
2008-11-27 20:23:40 -07:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the on disk inode to find the next inode in the bucket.
|
|
|
|
*/
|
2012-07-03 10:21:22 -06:00
|
|
|
error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &ibp, 0, 0);
|
2008-11-27 20:23:40 -07:00
|
|
|
if (error)
|
2008-11-27 20:23:42 -07:00
|
|
|
goto fail_iput;
|
2008-11-27 20:23:40 -07:00
|
|
|
|
2016-10-03 10:11:29 -06:00
|
|
|
xfs_iflags_clear(ip, XFS_IRECOVERY);
|
2016-02-08 22:54:58 -07:00
|
|
|
ASSERT(VFS_I(ip)->i_nlink == 0);
|
2016-02-08 22:54:58 -07:00
|
|
|
ASSERT(VFS_I(ip)->i_mode != 0);
|
2008-11-27 20:23:40 -07:00
|
|
|
|
|
|
|
/* setup for the next pass */
|
|
|
|
agino = be32_to_cpu(dip->di_next_unlinked);
|
|
|
|
xfs_buf_relse(ibp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prevent any DMAPI event from being sent when the reference on
|
|
|
|
* the inode is dropped.
|
|
|
|
*/
|
|
|
|
ip->i_d.di_dmevmask = 0;
|
|
|
|
|
2008-11-27 20:23:42 -07:00
|
|
|
IRELE(ip);
|
2008-11-27 20:23:40 -07:00
|
|
|
return agino;
|
|
|
|
|
2008-11-27 20:23:42 -07:00
|
|
|
fail_iput:
|
|
|
|
IRELE(ip);
|
2008-11-27 20:23:40 -07:00
|
|
|
fail:
|
|
|
|
/*
|
|
|
|
* We can't read in the inode this bucket points to, or this inode
|
|
|
|
* is messed up. Just ditch this bucket of inodes. We will lose
|
|
|
|
* some inodes and space, but at least we won't hang.
|
|
|
|
*
|
|
|
|
* Call xlog_recover_clear_agi_bucket() to perform a transaction to
|
|
|
|
* clear the inode pointer in the bucket.
|
|
|
|
*/
|
|
|
|
xlog_recover_clear_agi_bucket(mp, agno, bucket);
|
|
|
|
return NULLAGINO;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* xlog_iunlink_recover
|
|
|
|
*
|
|
|
|
* This is called during recovery to process any inodes which
|
|
|
|
* we unlinked but not freed when the system crashed. These
|
|
|
|
* inodes will be on the lists in the AGI blocks. What we do
|
|
|
|
* here is scan all the AGIs and fully truncate and free any
|
|
|
|
* inodes found on the lists. Each inode is removed from the
|
|
|
|
* lists when it has been fully truncated and is freed. The
|
|
|
|
* freeing of the inode and its removal from the list must be
|
|
|
|
* atomic.
|
|
|
|
*/
|
2009-07-01 23:09:33 -06:00
|
|
|
STATIC void
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_recover_process_iunlinks(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xfs_mount_t *mp;
|
|
|
|
xfs_agnumber_t agno;
|
|
|
|
xfs_agi_t *agi;
|
|
|
|
xfs_buf_t *agibp;
|
|
|
|
xfs_agino_t agino;
|
|
|
|
int bucket;
|
|
|
|
int error;
|
|
|
|
uint mp_dmevmask;
|
|
|
|
|
|
|
|
mp = log->l_mp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prevent any DMAPI event from being sent while in this function.
|
|
|
|
*/
|
|
|
|
mp_dmevmask = mp->m_dmevmask;
|
|
|
|
mp->m_dmevmask = 0;
|
|
|
|
|
|
|
|
for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
|
|
|
|
/*
|
|
|
|
* Find the agi for this ag.
|
|
|
|
*/
|
2008-11-27 20:23:37 -07:00
|
|
|
error = xfs_read_agi(mp, NULL, agno, &agibp);
|
|
|
|
if (error) {
|
|
|
|
/*
|
|
|
|
* AGI is b0rked. Don't process it.
|
|
|
|
*
|
|
|
|
* We should probably mark the filesystem as corrupt
|
|
|
|
* after we've recovered all the ag's we can....
|
|
|
|
*/
|
|
|
|
continue;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-03-15 03:34:02 -06:00
|
|
|
/*
|
|
|
|
* Unlock the buffer so that it can be acquired in the normal
|
|
|
|
* course of the transaction to truncate and free each inode.
|
|
|
|
* Because we are not racing with anyone else here for the AGI
|
|
|
|
* buffer, we don't even need to hold it locked to read the
|
|
|
|
* initial unlinked bucket entries out of the buffer. We keep
|
|
|
|
* buffer reference though, so that it stays pinned in memory
|
|
|
|
* while we need the buffer.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
agi = XFS_BUF_TO_AGI(agibp);
|
2012-03-15 03:34:02 -06:00
|
|
|
xfs_buf_unlock(agibp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) {
|
2005-11-01 21:11:25 -07:00
|
|
|
agino = be32_to_cpu(agi->agi_unlinked[bucket]);
|
2005-04-16 16:20:36 -06:00
|
|
|
while (agino != NULLAGINO) {
|
2008-11-27 20:23:40 -07:00
|
|
|
agino = xlog_recover_process_one_iunlink(mp,
|
|
|
|
agno, agino, bucket);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2012-03-15 03:34:02 -06:00
|
|
|
xfs_buf_rele(agibp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
mp->m_dmevmask = mp_dmevmask;
|
|
|
|
}
|
|
|
|
|
xfs: add CRC checks to the log
Implement CRCs for the log buffers. We re-use a field in
struct xlog_rec_header that was used for a weak checksum of the
log buffer payload in debug builds before.
The new checksumming uses the crc32c checksum we will use elsewhere
in XFS, and also protects the record header and addition cycle data.
Due to this there are some interesting changes in xlog_sync, as we
need to do the cycle wrapping for the split buffer case much earlier,
as we would touch the buffer after generating the checksum otherwise.
The CRC calculation is always enabled, even for non-CRC filesystems,
as adding this CRC does not change the log format. On non-CRC
filesystems, only issue an alert if a CRC mismatch is found and
allow recovery to continue - this will act as an indicator that
log recovery problems are a result of log corruption. On CRC enabled
filesystems, however, log recovery will fail.
Note that existing debug kernels will write a simple checksum value
to the log, so the first time this is run on a filesystem taht was
last used on a debug kernel it will through CRC mismatch warning
errors. These can be ignored.
Initially based on a patch from Dave Chinner, then modified
significantly by Christoph Hellwig. Modified again by Dave Chinner
to get to this version.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 04:54:24 -07:00
|
|
|
STATIC int
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_unpack_data(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog_rec_header *rhead,
|
2015-06-21 17:45:10 -06:00
|
|
|
char *dp,
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i, j, k;
|
|
|
|
|
2007-10-11 18:59:34 -06:00
|
|
|
for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) &&
|
2005-04-16 16:20:36 -06:00
|
|
|
i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
|
2007-10-11 18:59:34 -06:00
|
|
|
*(__be32 *)dp = *(__be32 *)&rhead->h_cycle_data[i];
|
2005-04-16 16:20:36 -06:00
|
|
|
dp += BBSIZE;
|
|
|
|
}
|
|
|
|
|
2008-03-05 19:44:28 -07:00
|
|
|
if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
|
2008-11-27 20:23:38 -07:00
|
|
|
xlog_in_core_2_t *xhdr = (xlog_in_core_2_t *)rhead;
|
2007-10-11 18:59:34 -06:00
|
|
|
for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
|
|
|
|
k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
|
2007-10-11 18:59:34 -06:00
|
|
|
*(__be32 *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];
|
2005-04-16 16:20:36 -06:00
|
|
|
dp += BBSIZE;
|
|
|
|
}
|
|
|
|
}
|
xfs: add CRC checks to the log
Implement CRCs for the log buffers. We re-use a field in
struct xlog_rec_header that was used for a weak checksum of the
log buffer payload in debug builds before.
The new checksumming uses the crc32c checksum we will use elsewhere
in XFS, and also protects the record header and addition cycle data.
Due to this there are some interesting changes in xlog_sync, as we
need to do the cycle wrapping for the split buffer case much earlier,
as we would touch the buffer after generating the checksum otherwise.
The CRC calculation is always enabled, even for non-CRC filesystems,
as adding this CRC does not change the log format. On non-CRC
filesystems, only issue an alert if a CRC mismatch is found and
allow recovery to continue - this will act as an indicator that
log recovery problems are a result of log corruption. On CRC enabled
filesystems, however, log recovery will fail.
Note that existing debug kernels will write a simple checksum value
to the log, so the first time this is run on a filesystem taht was
last used on a debug kernel it will through CRC mismatch warning
errors. These can be ignored.
Initially based on a patch from Dave Chinner, then modified
significantly by Christoph Hellwig. Modified again by Dave Chinner
to get to this version.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 04:54:24 -07:00
|
|
|
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2016-01-03 21:55:10 -07:00
|
|
|
/*
|
2016-01-03 21:55:10 -07:00
|
|
|
* CRC check, unpack and process a log record.
|
2016-01-03 21:55:10 -07:00
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_recover_process(
|
|
|
|
struct xlog *log,
|
|
|
|
struct hlist_head rhash[],
|
|
|
|
struct xlog_rec_header *rhead,
|
|
|
|
char *dp,
|
2016-09-25 16:22:16 -06:00
|
|
|
int pass,
|
|
|
|
struct list_head *buffer_list)
|
2016-01-03 21:55:10 -07:00
|
|
|
{
|
|
|
|
int error;
|
2016-12-04 20:40:32 -07:00
|
|
|
__le32 old_crc = rhead->h_crc;
|
2016-01-03 21:55:10 -07:00
|
|
|
__le32 crc;
|
|
|
|
|
2016-12-04 20:40:32 -07:00
|
|
|
|
2016-01-03 21:55:10 -07:00
|
|
|
crc = xlog_cksum(log, rhead, dp, be32_to_cpu(rhead->h_len));
|
|
|
|
|
2016-01-03 21:55:10 -07:00
|
|
|
/*
|
2016-01-03 21:55:10 -07:00
|
|
|
* Nothing else to do if this is a CRC verification pass. Just return
|
|
|
|
* if this a record with a non-zero crc. Unfortunately, mkfs always
|
2016-12-04 20:40:32 -07:00
|
|
|
* sets old_crc to 0 so we must consider this valid even on v5 supers.
|
2016-01-03 21:55:10 -07:00
|
|
|
* Otherwise, return EFSBADCRC on failure so the callers up the stack
|
|
|
|
* know precisely what failed.
|
|
|
|
*/
|
|
|
|
if (pass == XLOG_RECOVER_CRCPASS) {
|
2016-12-04 20:40:32 -07:00
|
|
|
if (old_crc && crc != old_crc)
|
2016-01-03 21:55:10 -07:00
|
|
|
return -EFSBADCRC;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We're in the normal recovery path. Issue a warning if and only if the
|
|
|
|
* CRC in the header is non-zero. This is an advisory warning and the
|
|
|
|
* zero CRC check prevents warnings from being emitted when upgrading
|
|
|
|
* the kernel from one that does not add CRCs by default.
|
2016-01-03 21:55:10 -07:00
|
|
|
*/
|
2016-12-04 20:40:32 -07:00
|
|
|
if (crc != old_crc) {
|
|
|
|
if (old_crc || xfs_sb_version_hascrc(&log->l_mp->m_sb)) {
|
2016-01-03 21:55:10 -07:00
|
|
|
xfs_alert(log->l_mp,
|
|
|
|
"log record CRC mismatch: found 0x%x, expected 0x%x.",
|
2016-12-04 20:40:32 -07:00
|
|
|
le32_to_cpu(old_crc),
|
2016-01-03 21:55:10 -07:00
|
|
|
le32_to_cpu(crc));
|
|
|
|
xfs_hex_dump(dp, 32);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the filesystem is CRC enabled, this mismatch becomes a
|
|
|
|
* fatal log corruption failure.
|
|
|
|
*/
|
|
|
|
if (xfs_sb_version_hascrc(&log->l_mp->m_sb))
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
}
|
2016-01-03 21:55:10 -07:00
|
|
|
|
|
|
|
error = xlog_unpack_data(rhead, dp, log);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2016-09-25 16:22:16 -06:00
|
|
|
return xlog_recover_process_data(log, rhash, rhead, dp, pass,
|
|
|
|
buffer_list);
|
2016-01-03 21:55:10 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_valid_rec_header(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_rec_header *rhead,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t blkno)
|
|
|
|
{
|
|
|
|
int hlen;
|
|
|
|
|
2011-07-08 06:36:05 -06:00
|
|
|
if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
|
|
|
|
XFS_ERRLEVEL_LOW, log->l_mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (unlikely(
|
|
|
|
(!rhead->h_version ||
|
2007-10-11 18:59:34 -06:00
|
|
|
(be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp, "%s: unrecognised log version (%d).",
|
2008-04-09 20:19:21 -06:00
|
|
|
__func__, be32_to_cpu(rhead->h_version));
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* LR body must have data or it wouldn't have been written */
|
2007-10-11 18:59:34 -06:00
|
|
|
hlen = be32_to_cpu(rhead->h_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
|
|
|
|
XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
|
|
|
|
XFS_ERRLEVEL_LOW, log->l_mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
|
|
|
|
XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
|
|
|
|
XFS_ERRLEVEL_LOW, log->l_mp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EFSCORRUPTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the log from tail to head and process the log records found.
|
|
|
|
* Handle the two cases where the tail and head are in the same cycle
|
|
|
|
* and where the active portion of the log wraps around the end of
|
|
|
|
* the physical log separately. The pass parameter is passed through
|
|
|
|
* to the routines called to process the data and is not looked at
|
|
|
|
* here.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_do_recovery_pass(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t head_blk,
|
|
|
|
xfs_daddr_t tail_blk,
|
2016-01-03 21:55:10 -07:00
|
|
|
int pass,
|
|
|
|
xfs_daddr_t *first_bad) /* out: first bad log rec */
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xlog_rec_header_t *rhead;
|
|
|
|
xfs_daddr_t blk_no;
|
2016-01-03 21:55:10 -07:00
|
|
|
xfs_daddr_t rhead_blk;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *offset;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_buf_t *hbp, *dbp;
|
2016-01-03 21:55:10 -07:00
|
|
|
int error = 0, h_size, h_len;
|
2016-09-25 16:22:16 -06:00
|
|
|
int error2 = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
int bblks, split_bblks;
|
|
|
|
int hblks, split_hblks, wrapped_hblks;
|
2017-06-24 11:11:41 -06:00
|
|
|
int i;
|
2010-01-11 04:49:57 -07:00
|
|
|
struct hlist_head rhash[XLOG_RHASH_SIZE];
|
2016-09-25 16:22:16 -06:00
|
|
|
LIST_HEAD (buffer_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT(head_blk != tail_blk);
|
2016-01-03 21:55:10 -07:00
|
|
|
rhead_blk = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-06-24 11:11:41 -06:00
|
|
|
for (i = 0; i < XLOG_RHASH_SIZE; i++)
|
|
|
|
INIT_HLIST_HEAD(&rhash[i]);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Read the header of the tail block and get the iclog buffer size from
|
|
|
|
* h_size. Use this to tell how many sectors make up the log header.
|
|
|
|
*/
|
2008-03-05 19:44:28 -07:00
|
|
|
if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* When using variable length iclogs, read first sector of
|
|
|
|
* iclog header and extract the header size from it. Get a
|
|
|
|
* new hbp that is the correct size.
|
|
|
|
*/
|
|
|
|
hbp = xlog_get_bp(log, 1);
|
|
|
|
if (!hbp)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
|
|
|
error = xlog_bread(log, tail_blk, 1, hbp, &offset);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto bread_err1;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
rhead = (xlog_rec_header_t *)offset;
|
|
|
|
error = xlog_valid_rec_header(log, rhead, tail_blk);
|
|
|
|
if (error)
|
|
|
|
goto bread_err1;
|
2016-01-03 21:55:10 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* xfsprogs has a bug where record length is based on lsunit but
|
|
|
|
* h_size (iclog size) is hardcoded to 32k. Now that we
|
|
|
|
* unconditionally CRC verify the unmount record, this means the
|
|
|
|
* log buffer can be too small for the record and cause an
|
|
|
|
* overrun.
|
|
|
|
*
|
|
|
|
* Detect this condition here. Use lsunit for the buffer size as
|
|
|
|
* long as this looks like the mkfs case. Otherwise, return an
|
|
|
|
* error to avoid a buffer overrun.
|
|
|
|
*/
|
2007-10-11 18:59:34 -06:00
|
|
|
h_size = be32_to_cpu(rhead->h_size);
|
2016-01-03 21:55:10 -07:00
|
|
|
h_len = be32_to_cpu(rhead->h_len);
|
|
|
|
if (h_len > h_size) {
|
|
|
|
if (h_len <= log->l_mp->m_logbsize &&
|
|
|
|
be32_to_cpu(rhead->h_num_logops) == 1) {
|
|
|
|
xfs_warn(log->l_mp,
|
|
|
|
"invalid iclog size (%d bytes), using lsunit (%d bytes)",
|
|
|
|
h_size, log->l_mp->m_logbsize);
|
|
|
|
h_size = log->l_mp->m_logbsize;
|
|
|
|
} else
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
}
|
|
|
|
|
2007-10-11 18:59:34 -06:00
|
|
|
if ((be32_to_cpu(rhead->h_version) & XLOG_VERSION_2) &&
|
2005-04-16 16:20:36 -06:00
|
|
|
(h_size > XLOG_HEADER_CYCLE_SIZE)) {
|
|
|
|
hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
|
|
|
|
if (h_size % XLOG_HEADER_CYCLE_SIZE)
|
|
|
|
hblks++;
|
|
|
|
xlog_put_bp(hbp);
|
|
|
|
hbp = xlog_get_bp(log, hblks);
|
|
|
|
} else {
|
|
|
|
hblks = 1;
|
|
|
|
}
|
|
|
|
} else {
|
2010-04-20 01:09:59 -06:00
|
|
|
ASSERT(log->l_sectBBsize == 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
hblks = 1;
|
|
|
|
hbp = xlog_get_bp(log, 1);
|
|
|
|
h_size = XLOG_BIG_RECORD_BSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!hbp)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
dbp = xlog_get_bp(log, BTOBB(h_size));
|
|
|
|
if (!dbp) {
|
|
|
|
xlog_put_bp(hbp);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
memset(rhash, 0, sizeof(rhash));
|
2016-01-03 21:55:10 -07:00
|
|
|
blk_no = rhead_blk = tail_blk;
|
2014-09-08 19:57:29 -06:00
|
|
|
if (tail_blk > head_blk) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Perform recovery around the end of the physical log.
|
|
|
|
* When the head is not on the same cycle number as the tail,
|
2014-09-08 19:57:29 -06:00
|
|
|
* we can't do a sequential recovery.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
while (blk_no < log->l_logBBsize) {
|
|
|
|
/*
|
|
|
|
* Check for header wrapping around physical end-of-log
|
|
|
|
*/
|
2011-07-22 17:40:15 -06:00
|
|
|
offset = hbp->b_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
split_hblks = 0;
|
|
|
|
wrapped_hblks = 0;
|
|
|
|
if (blk_no + hblks <= log->l_logBBsize) {
|
|
|
|
/* Read header in one read */
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, blk_no, hblks, hbp,
|
|
|
|
&offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
|
|
|
goto bread_err2;
|
|
|
|
} else {
|
|
|
|
/* This LR is split across physical log end */
|
|
|
|
if (blk_no != log->l_logBBsize) {
|
|
|
|
/* some data before physical log end */
|
|
|
|
ASSERT(blk_no <= INT_MAX);
|
|
|
|
split_hblks = log->l_logBBsize - (int)blk_no;
|
|
|
|
ASSERT(split_hblks > 0);
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, blk_no,
|
|
|
|
split_hblks, hbp,
|
|
|
|
&offset);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto bread_err2;
|
|
|
|
}
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Note: this black magic still works with
|
|
|
|
* large sector sizes (non-512) only because:
|
|
|
|
* - we increased the buffer size originally
|
|
|
|
* by 1 sector giving us enough extra space
|
|
|
|
* for the second read;
|
|
|
|
* - the log start is guaranteed to be sector
|
|
|
|
* aligned;
|
|
|
|
* - we read the log end (LR header start)
|
|
|
|
* _first_, then the log start (LR header end)
|
|
|
|
* - order is important.
|
|
|
|
*/
|
2008-04-09 20:24:24 -06:00
|
|
|
wrapped_hblks = hblks - split_hblks;
|
2011-04-21 03:34:27 -06:00
|
|
|
error = xlog_bread_offset(log, 0,
|
|
|
|
wrapped_hblks, hbp,
|
|
|
|
offset + BBTOB(split_hblks));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
|
|
|
goto bread_err2;
|
|
|
|
}
|
|
|
|
rhead = (xlog_rec_header_t *)offset;
|
|
|
|
error = xlog_valid_rec_header(log, rhead,
|
|
|
|
split_hblks ? blk_no : 0);
|
|
|
|
if (error)
|
|
|
|
goto bread_err2;
|
|
|
|
|
2007-10-11 18:59:34 -06:00
|
|
|
bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
|
2005-04-16 16:20:36 -06:00
|
|
|
blk_no += hblks;
|
|
|
|
|
|
|
|
/* Read in data for log record */
|
|
|
|
if (blk_no + bblks <= log->l_logBBsize) {
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, blk_no, bblks, dbp,
|
|
|
|
&offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error)
|
|
|
|
goto bread_err2;
|
|
|
|
} else {
|
|
|
|
/* This log record is split across the
|
|
|
|
* physical end of log */
|
2011-07-22 17:40:15 -06:00
|
|
|
offset = dbp->b_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
split_bblks = 0;
|
|
|
|
if (blk_no != log->l_logBBsize) {
|
|
|
|
/* some data is before the physical
|
|
|
|
* end of log */
|
|
|
|
ASSERT(!wrapped_hblks);
|
|
|
|
ASSERT(blk_no <= INT_MAX);
|
|
|
|
split_bblks =
|
|
|
|
log->l_logBBsize - (int)blk_no;
|
|
|
|
ASSERT(split_bblks > 0);
|
2009-03-16 01:24:13 -06:00
|
|
|
error = xlog_bread(log, blk_no,
|
|
|
|
split_bblks, dbp,
|
|
|
|
&offset);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto bread_err2;
|
|
|
|
}
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Note: this black magic still works with
|
|
|
|
* large sector sizes (non-512) only because:
|
|
|
|
* - we increased the buffer size originally
|
|
|
|
* by 1 sector giving us enough extra space
|
|
|
|
* for the second read;
|
|
|
|
* - the log start is guaranteed to be sector
|
|
|
|
* aligned;
|
|
|
|
* - we read the log end (LR header start)
|
|
|
|
* _first_, then the log start (LR header end)
|
|
|
|
* - order is important.
|
|
|
|
*/
|
2011-04-21 03:34:27 -06:00
|
|
|
error = xlog_bread_offset(log, 0,
|
2012-11-01 18:38:44 -06:00
|
|
|
bblks - split_bblks, dbp,
|
2011-04-21 03:34:27 -06:00
|
|
|
offset + BBTOB(split_bblks));
|
2009-03-16 01:24:13 -06:00
|
|
|
if (error)
|
|
|
|
goto bread_err2;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
xfs: add CRC checks to the log
Implement CRCs for the log buffers. We re-use a field in
struct xlog_rec_header that was used for a weak checksum of the
log buffer payload in debug builds before.
The new checksumming uses the crc32c checksum we will use elsewhere
in XFS, and also protects the record header and addition cycle data.
Due to this there are some interesting changes in xlog_sync, as we
need to do the cycle wrapping for the split buffer case much earlier,
as we would touch the buffer after generating the checksum otherwise.
The CRC calculation is always enabled, even for non-CRC filesystems,
as adding this CRC does not change the log format. On non-CRC
filesystems, only issue an alert if a CRC mismatch is found and
allow recovery to continue - this will act as an indicator that
log recovery problems are a result of log corruption. On CRC enabled
filesystems, however, log recovery will fail.
Note that existing debug kernels will write a simple checksum value
to the log, so the first time this is run on a filesystem taht was
last used on a debug kernel it will through CRC mismatch warning
errors. These can be ignored.
Initially based on a patch from Dave Chinner, then modified
significantly by Christoph Hellwig. Modified again by Dave Chinner
to get to this version.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 04:54:24 -07:00
|
|
|
|
2016-01-03 21:55:10 -07:00
|
|
|
error = xlog_recover_process(log, rhash, rhead, offset,
|
2016-09-25 16:22:16 -06:00
|
|
|
pass, &buffer_list);
|
xfs: add CRC checks to the log
Implement CRCs for the log buffers. We re-use a field in
struct xlog_rec_header that was used for a weak checksum of the
log buffer payload in debug builds before.
The new checksumming uses the crc32c checksum we will use elsewhere
in XFS, and also protects the record header and addition cycle data.
Due to this there are some interesting changes in xlog_sync, as we
need to do the cycle wrapping for the split buffer case much earlier,
as we would touch the buffer after generating the checksum otherwise.
The CRC calculation is always enabled, even for non-CRC filesystems,
as adding this CRC does not change the log format. On non-CRC
filesystems, only issue an alert if a CRC mismatch is found and
allow recovery to continue - this will act as an indicator that
log recovery problems are a result of log corruption. On CRC enabled
filesystems, however, log recovery will fail.
Note that existing debug kernels will write a simple checksum value
to the log, so the first time this is run on a filesystem taht was
last used on a debug kernel it will through CRC mismatch warning
errors. These can be ignored.
Initially based on a patch from Dave Chinner, then modified
significantly by Christoph Hellwig. Modified again by Dave Chinner
to get to this version.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 04:54:24 -07:00
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto bread_err2;
|
2016-01-03 21:55:10 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
blk_no += bblks;
|
2016-01-03 21:55:10 -07:00
|
|
|
rhead_blk = blk_no;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(blk_no >= log->l_logBBsize);
|
|
|
|
blk_no -= log->l_logBBsize;
|
2016-01-03 21:55:10 -07:00
|
|
|
rhead_blk = blk_no;
|
2014-09-08 19:57:29 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-09-08 19:57:29 -06:00
|
|
|
/* read first part of physical log */
|
|
|
|
while (blk_no < head_blk) {
|
|
|
|
error = xlog_bread(log, blk_no, hblks, hbp, &offset);
|
|
|
|
if (error)
|
|
|
|
goto bread_err2;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2014-09-08 19:57:29 -06:00
|
|
|
rhead = (xlog_rec_header_t *)offset;
|
|
|
|
error = xlog_valid_rec_header(log, rhead, blk_no);
|
|
|
|
if (error)
|
|
|
|
goto bread_err2;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2014-09-08 19:57:29 -06:00
|
|
|
/* blocks in data section */
|
|
|
|
bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
|
|
|
|
error = xlog_bread(log, blk_no+hblks, bblks, dbp,
|
|
|
|
&offset);
|
|
|
|
if (error)
|
|
|
|
goto bread_err2;
|
2009-03-16 01:24:13 -06:00
|
|
|
|
2016-09-25 16:22:16 -06:00
|
|
|
error = xlog_recover_process(log, rhash, rhead, offset, pass,
|
|
|
|
&buffer_list);
|
2014-09-08 19:57:29 -06:00
|
|
|
if (error)
|
|
|
|
goto bread_err2;
|
2016-01-03 21:55:10 -07:00
|
|
|
|
2014-09-08 19:57:29 -06:00
|
|
|
blk_no += bblks + hblks;
|
2016-01-03 21:55:10 -07:00
|
|
|
rhead_blk = blk_no;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
bread_err2:
|
|
|
|
xlog_put_bp(dbp);
|
|
|
|
bread_err1:
|
|
|
|
xlog_put_bp(hbp);
|
2016-01-03 21:55:10 -07:00
|
|
|
|
2016-09-25 16:22:16 -06:00
|
|
|
/*
|
|
|
|
* Submit buffers that have been added from the last record processed,
|
|
|
|
* regardless of error status.
|
|
|
|
*/
|
|
|
|
if (!list_empty(&buffer_list))
|
|
|
|
error2 = xfs_buf_delwri_submit(&buffer_list);
|
|
|
|
|
2016-01-03 21:55:10 -07:00
|
|
|
if (error && first_bad)
|
|
|
|
*first_bad = rhead_blk;
|
|
|
|
|
2017-06-24 11:11:41 -06:00
|
|
|
/*
|
|
|
|
* Transactions are freed at commit time but transactions without commit
|
|
|
|
* records on disk are never committed. Free any that may be left in the
|
|
|
|
* hash table.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < XLOG_RHASH_SIZE; i++) {
|
|
|
|
struct hlist_node *tmp;
|
|
|
|
struct xlog_recover *trans;
|
|
|
|
|
|
|
|
hlist_for_each_entry_safe(trans, tmp, &rhash[i], r_list)
|
|
|
|
xlog_recover_free_trans(trans);
|
|
|
|
}
|
|
|
|
|
2016-09-25 16:22:16 -06:00
|
|
|
return error ? error : error2;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do the recovery of the log. We actually do this in two phases.
|
|
|
|
* The two passes are necessary in order to implement the function
|
|
|
|
* of cancelling a record written into the log. The first pass
|
|
|
|
* determines those things which have been cancelled, and the
|
|
|
|
* second pass replays log items normally except for those which
|
|
|
|
* have been cancelled. The handling of the replay and cancellations
|
|
|
|
* takes place in the log item type specific routines.
|
|
|
|
*
|
|
|
|
* The table of items which have cancel records in the log is allocated
|
|
|
|
* and freed at this level, since only here do we know when all of
|
|
|
|
* the log recovery has been completed.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_do_log_recovery(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t head_blk,
|
|
|
|
xfs_daddr_t tail_blk)
|
|
|
|
{
|
2010-12-01 15:06:22 -07:00
|
|
|
int error, i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT(head_blk != tail_blk);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First do a pass to find all of the cancelled buf log items.
|
|
|
|
* Store them in the buf_cancel_table for use in the second pass.
|
|
|
|
*/
|
2010-12-01 15:06:22 -07:00
|
|
|
log->l_buf_cancel_table = kmem_zalloc(XLOG_BC_TABLE_SIZE *
|
|
|
|
sizeof(struct list_head),
|
2005-04-16 16:20:36 -06:00
|
|
|
KM_SLEEP);
|
2010-12-01 15:06:22 -07:00
|
|
|
for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
|
|
|
|
INIT_LIST_HEAD(&log->l_buf_cancel_table[i]);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
error = xlog_do_recovery_pass(log, head_blk, tail_blk,
|
2016-01-03 21:55:10 -07:00
|
|
|
XLOG_RECOVER_PASS1, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error != 0) {
|
2008-05-19 00:31:57 -06:00
|
|
|
kmem_free(log->l_buf_cancel_table);
|
2005-04-16 16:20:36 -06:00
|
|
|
log->l_buf_cancel_table = NULL;
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Then do a second pass to actually recover the items in the log.
|
|
|
|
* When it is complete free the table of buf cancel items.
|
|
|
|
*/
|
|
|
|
error = xlog_do_recovery_pass(log, head_blk, tail_blk,
|
2016-01-03 21:55:10 -07:00
|
|
|
XLOG_RECOVER_PASS2, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef DEBUG
|
2006-06-08 22:55:38 -06:00
|
|
|
if (!error) {
|
2005-04-16 16:20:36 -06:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
|
2010-12-01 15:06:22 -07:00
|
|
|
ASSERT(list_empty(&log->l_buf_cancel_table[i]));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif /* DEBUG */
|
|
|
|
|
2008-05-19 00:31:57 -06:00
|
|
|
kmem_free(log->l_buf_cancel_table);
|
2005-04-16 16:20:36 -06:00
|
|
|
log->l_buf_cancel_table = NULL;
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do the actual recovery
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_do_recover(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_daddr_t head_blk,
|
|
|
|
xfs_daddr_t tail_blk)
|
|
|
|
{
|
2016-03-06 14:39:36 -07:00
|
|
|
struct xfs_mount *mp = log->l_mp;
|
2005-04-16 16:20:36 -06:00
|
|
|
int error;
|
|
|
|
xfs_buf_t *bp;
|
|
|
|
xfs_sb_t *sbp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First replay the images in the log.
|
|
|
|
*/
|
|
|
|
error = xlog_do_log_recovery(log, head_blk, tail_blk);
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If IO errors happened during recovery, bail out.
|
|
|
|
*/
|
2016-03-06 14:39:36 -07:00
|
|
|
if (XFS_FORCED_SHUTDOWN(mp)) {
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We now update the tail_lsn since much of the recovery has completed
|
|
|
|
* and there may be space available to use. If there were no extent
|
|
|
|
* or iunlinks, we can free up the entire log and set the tail_lsn to
|
|
|
|
* be the last_sync_lsn. This was set in xlog_find_tail to be the
|
|
|
|
* lsn of the last known good LR on disk. If there are extent frees
|
|
|
|
* or iunlinks they will have some entries in the AIL; so we look at
|
|
|
|
* the AIL to determine how to set the tail_lsn.
|
|
|
|
*/
|
2016-03-06 14:39:36 -07:00
|
|
|
xlog_assign_tail_lsn(mp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now that we've finished replaying all buffer and inode
|
2012-11-12 04:54:03 -07:00
|
|
|
* updates, re-read in the superblock and reverify it.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2016-03-06 14:39:36 -07:00
|
|
|
bp = xfs_getsb(mp, 0);
|
2016-02-09 21:01:11 -07:00
|
|
|
bp->b_flags &= ~(XBF_DONE | XBF_ASYNC);
|
2016-02-09 21:01:11 -07:00
|
|
|
ASSERT(!(bp->b_flags & XBF_WRITE));
|
2016-02-09 21:01:11 -07:00
|
|
|
bp->b_flags |= XBF_READ;
|
2012-11-13 23:54:40 -07:00
|
|
|
bp->b_ops = &xfs_sb_buf_ops;
|
2013-12-17 01:03:52 -07:00
|
|
|
|
2014-10-01 17:05:14 -06:00
|
|
|
error = xfs_buf_submit_wait(bp);
|
2008-04-09 20:22:17 -06:00
|
|
|
if (error) {
|
2016-03-06 14:39:36 -07:00
|
|
|
if (!XFS_FORCED_SHUTDOWN(mp)) {
|
2014-10-01 17:05:14 -06:00
|
|
|
xfs_buf_ioerror_alert(bp, __func__);
|
|
|
|
ASSERT(0);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_buf_relse(bp);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert superblock from on-disk format */
|
2016-03-06 14:39:36 -07:00
|
|
|
sbp = &mp->m_sb;
|
2012-11-12 04:54:03 -07:00
|
|
|
xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_buf_relse(bp);
|
|
|
|
|
2016-03-06 14:39:36 -07:00
|
|
|
/* re-initialise in-core superblock and geometry structures */
|
|
|
|
xfs_reinit_percpu_counters(mp);
|
|
|
|
error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
|
|
|
|
if (error) {
|
|
|
|
xfs_warn(mp, "Failed post-recovery per-ag init: %d", error);
|
|
|
|
return error;
|
|
|
|
}
|
2016-08-02 19:38:24 -06:00
|
|
|
mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
|
2007-02-10 00:36:29 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_recover_check_summary(log);
|
|
|
|
|
|
|
|
/* Normal transactions can now occur */
|
|
|
|
log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform recovery and re-initialize some log variables in xlog_find_tail.
|
|
|
|
*
|
|
|
|
* Return error or zero.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xlog_recover(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xfs_daddr_t head_blk, tail_blk;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* find the tail of the log */
|
2015-10-11 22:59:25 -06:00
|
|
|
error = xlog_find_tail(log, &head_blk, &tail_blk);
|
|
|
|
if (error)
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
|
|
|
|
2015-10-11 22:59:25 -06:00
|
|
|
/*
|
|
|
|
* The superblock was read before the log was available and thus the LSN
|
|
|
|
* could not be verified. Check the superblock LSN against the current
|
|
|
|
* LSN now that it's known.
|
|
|
|
*/
|
|
|
|
if (xfs_sb_version_hascrc(&log->l_mp->m_sb) &&
|
|
|
|
!xfs_log_check_lsn(log->l_mp, log->l_mp->m_sb.sb_lsn))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tail_blk != head_blk) {
|
|
|
|
/* There used to be a comment here:
|
|
|
|
*
|
|
|
|
* disallow recovery on read-only mounts. note -- mount
|
|
|
|
* checks for ENOSPC and turns it into an intelligent
|
|
|
|
* error message.
|
|
|
|
* ...but this is no longer true. Now, unless you specify
|
|
|
|
* NORECOVERY (in which case this function would never be
|
|
|
|
* called), we just go ahead and recover. We do this all
|
|
|
|
* under the vfs layer, so we can get away with it unless
|
|
|
|
* the device itself is read-only, in which case we fail.
|
|
|
|
*/
|
2007-05-07 21:50:06 -06:00
|
|
|
if ((error = xfs_dev_is_read_only(log->l_mp, "recovery"))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2013-04-02 23:11:32 -06:00
|
|
|
/*
|
|
|
|
* Version 5 superblock log feature mask validation. We know the
|
|
|
|
* log is dirty so check if there are any unknown log features
|
|
|
|
* in what we need to recover. If there are unknown features
|
|
|
|
* (e.g. unsupported transactions, then simply reject the
|
|
|
|
* attempt at recovery before touching anything.
|
|
|
|
*/
|
|
|
|
if (XFS_SB_VERSION_NUM(&log->l_mp->m_sb) == XFS_SB_VERSION_5 &&
|
|
|
|
xfs_sb_has_incompat_log_feature(&log->l_mp->m_sb,
|
|
|
|
XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN)) {
|
|
|
|
xfs_warn(log->l_mp,
|
2015-07-28 19:52:04 -06:00
|
|
|
"Superblock has unknown incompatible log features (0x%x) enabled.",
|
2013-04-02 23:11:32 -06:00
|
|
|
(log->l_mp->m_sb.sb_features_log_incompat &
|
|
|
|
XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
|
2015-07-28 19:52:04 -06:00
|
|
|
xfs_warn(log->l_mp,
|
|
|
|
"The log can not be fully and/or safely recovered by this kernel.");
|
|
|
|
xfs_warn(log->l_mp,
|
|
|
|
"Please recover the log on a kernel that supports the unknown features.");
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EINVAL;
|
2013-04-02 23:11:32 -06:00
|
|
|
}
|
|
|
|
|
2014-09-08 19:56:13 -06:00
|
|
|
/*
|
|
|
|
* Delay log recovery if the debug hook is set. This is debug
|
|
|
|
* instrumention to coordinate simulation of I/O failures with
|
|
|
|
* log recovery.
|
|
|
|
*/
|
|
|
|
if (xfs_globals.log_recovery_delay) {
|
|
|
|
xfs_notice(log->l_mp,
|
|
|
|
"Delaying log recovery for %d seconds.",
|
|
|
|
xfs_globals.log_recovery_delay);
|
|
|
|
msleep(xfs_globals.log_recovery_delay * 1000);
|
|
|
|
}
|
|
|
|
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_notice(log->l_mp, "Starting recovery (logdev: %s)",
|
|
|
|
log->l_mp->m_logname ? log->l_mp->m_logname
|
|
|
|
: "internal");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
error = xlog_do_recover(log, head_blk, tail_blk);
|
|
|
|
log->l_flags |= XLOG_RECOVERY_NEEDED;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In the first part of recovery we replay inodes and buffers and build
|
|
|
|
* up the list of extent free items which need to be processed. Here
|
|
|
|
* we process the extent free items and clean up the on disk unlinked
|
|
|
|
* inode lists. This is separated from the first part of recovery so
|
|
|
|
* that the root and real-time bitmap inodes can be read in from disk in
|
|
|
|
* between the two stages. This is necessary so that we can free space
|
|
|
|
* in the real-time portion of the file system.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xlog_recover_finish(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Now we're ready to do the transactions needed for the
|
|
|
|
* rest of recovery. Start with completing all the extent
|
|
|
|
* free intent records and then process the unlinked inode
|
|
|
|
* lists. At this point, we essentially run in normal mode
|
|
|
|
* except that we're still performing recovery actions
|
|
|
|
* rather than accepting new requests.
|
|
|
|
*/
|
|
|
|
if (log->l_flags & XLOG_RECOVERY_NEEDED) {
|
2008-04-09 20:21:11 -06:00
|
|
|
int error;
|
2016-08-02 19:23:49 -06:00
|
|
|
error = xlog_recover_process_intents(log);
|
2008-04-09 20:21:11 -06:00
|
|
|
if (error) {
|
2016-08-02 19:23:49 -06:00
|
|
|
xfs_alert(log->l_mp, "Failed to recover intents");
|
2008-04-09 20:21:11 -06:00
|
|
|
return error;
|
|
|
|
}
|
2016-08-02 20:09:48 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2016-08-02 19:23:49 -06:00
|
|
|
* Sync the log to get all the intents out of the AIL.
|
2005-04-16 16:20:36 -06:00
|
|
|
* This isn't absolutely necessary, but it helps in
|
|
|
|
* case the unlink transactions would have problems
|
2016-08-02 19:23:49 -06:00
|
|
|
* pushing the intents out of the way.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-01-19 02:56:46 -07:00
|
|
|
xfs_log_force(log->l_mp, XFS_LOG_SYNC);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-13 00:49:32 -06:00
|
|
|
xlog_recover_process_iunlinks(log);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
xlog_recover_check_summary(log);
|
|
|
|
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_notice(log->l_mp, "Ending recovery (logdev: %s)",
|
|
|
|
log->l_mp->m_logname ? log->l_mp->m_logname
|
|
|
|
: "internal");
|
2005-04-16 16:20:36 -06:00
|
|
|
log->l_flags &= ~XLOG_RECOVERY_NEEDED;
|
|
|
|
} else {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_info(log->l_mp, "Ending clean mount");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-18 17:58:36 -06:00
|
|
|
int
|
|
|
|
xlog_recover_cancel(
|
|
|
|
struct xlog *log)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (log->l_flags & XLOG_RECOVERY_NEEDED)
|
2016-08-02 19:23:49 -06:00
|
|
|
error = xlog_recover_cancel_intents(log);
|
2015-08-18 17:58:36 -06:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#if defined(DEBUG)
|
|
|
|
/*
|
|
|
|
* Read all of the agf and agi counters and check that they
|
|
|
|
* are consistent with the superblock counters.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xlog_recover_check_summary(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xfs_mount_t *mp;
|
|
|
|
xfs_agf_t *agfp;
|
|
|
|
xfs_buf_t *agfbp;
|
|
|
|
xfs_buf_t *agibp;
|
|
|
|
xfs_agnumber_t agno;
|
2017-06-16 12:00:05 -06:00
|
|
|
uint64_t freeblks;
|
|
|
|
uint64_t itotal;
|
|
|
|
uint64_t ifree;
|
2008-11-27 20:23:37 -07:00
|
|
|
int error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mp = log->l_mp;
|
|
|
|
|
|
|
|
freeblks = 0LL;
|
|
|
|
itotal = 0LL;
|
|
|
|
ifree = 0LL;
|
|
|
|
for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
|
2008-11-27 20:23:38 -07:00
|
|
|
error = xfs_read_agf(mp, NULL, agno, 0, &agfbp);
|
|
|
|
if (error) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(mp, "%s agf read failed agno %d error %d",
|
|
|
|
__func__, agno, error);
|
2008-11-27 20:23:38 -07:00
|
|
|
} else {
|
|
|
|
agfp = XFS_BUF_TO_AGF(agfbp);
|
|
|
|
freeblks += be32_to_cpu(agfp->agf_freeblks) +
|
|
|
|
be32_to_cpu(agfp->agf_flcount);
|
|
|
|
xfs_buf_relse(agfbp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-11-27 20:23:37 -07:00
|
|
|
error = xfs_read_agi(mp, NULL, agno, &agibp);
|
2011-03-06 16:01:35 -07:00
|
|
|
if (error) {
|
|
|
|
xfs_alert(mp, "%s agi read failed agno %d error %d",
|
|
|
|
__func__, agno, error);
|
|
|
|
} else {
|
2008-11-27 20:23:37 -07:00
|
|
|
struct xfs_agi *agi = XFS_BUF_TO_AGI(agibp);
|
2005-11-01 21:11:25 -07:00
|
|
|
|
2008-11-27 20:23:37 -07:00
|
|
|
itotal += be32_to_cpu(agi->agi_count);
|
|
|
|
ifree += be32_to_cpu(agi->agi_freecount);
|
|
|
|
xfs_buf_relse(agibp);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* DEBUG */
|