mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-26 05:34:13 +08:00
xfs: scrub directory/attribute btrees
Provide a way to check the shape and scrub the hashes and records in a directory or extended attribute btree. These are helper functions for the directory & attribute scrubbers in subsequent patches. Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com> [fengguang: remove unneeded variable to store return value] Signed-off-by: Fengguang Wu <fengguang.wu@intel.com> Reviewed-by: Dave Chinner <dchinner@redhat.com>
This commit is contained in:
Darrick J. Wong
parent
99d9d8d05d
commit
7c4a07a424
@ -148,6 +148,7 @@ xfs-y += $(addprefix scrub/, \
|
||||
bmap.o \
|
||||
btree.o \
|
||||
common.o \
|
||||
dabtree.o \
|
||||
ialloc.o \
|
||||
inode.o \
|
||||
refcount.o \
|
||||
|
||||
588
fs/xfs/scrub/dabtree.c
Normal file
588
fs/xfs/scrub/dabtree.c
Normal file
@ -0,0 +1,588 @@
|
||||
/*
|
||||
* Copyright (C) 2017 Oracle. All Rights Reserved.
|
||||
*
|
||||
* Author: Darrick J. Wong <darrick.wong@oracle.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it would be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
#include "xfs.h"
|
||||
#include "xfs_fs.h"
|
||||
#include "xfs_shared.h"
|
||||
#include "xfs_format.h"
|
||||
#include "xfs_trans_resv.h"
|
||||
#include "xfs_mount.h"
|
||||
#include "xfs_defer.h"
|
||||
#include "xfs_btree.h"
|
||||
#include "xfs_bit.h"
|
||||
#include "xfs_log_format.h"
|
||||
#include "xfs_trans.h"
|
||||
#include "xfs_sb.h"
|
||||
#include "xfs_inode.h"
|
||||
#include "xfs_inode_fork.h"
|
||||
#include "xfs_da_format.h"
|
||||
#include "xfs_da_btree.h"
|
||||
#include "xfs_dir2.h"
|
||||
#include "xfs_dir2_priv.h"
|
||||
#include "xfs_attr_leaf.h"
|
||||
#include "scrub/xfs_scrub.h"
|
||||
#include "scrub/scrub.h"
|
||||
#include "scrub/common.h"
|
||||
#include "scrub/trace.h"
|
||||
#include "scrub/dabtree.h"
|
||||
|
||||
/* Directory/Attribute Btree */
|
||||
|
||||
/*
|
||||
* Check for da btree operation errors. See the section about handling
|
||||
* operational errors in common.c.
|
||||
*/
|
||||
bool
|
||||
xfs_scrub_da_process_error(
|
||||
struct xfs_scrub_da_btree *ds,
|
||||
int level,
|
||||
int *error)
|
||||
{
|
||||
struct xfs_scrub_context *sc = ds->sc;
|
||||
|
||||
if (*error == 0)
|
||||
return true;
|
||||
|
||||
switch (*error) {
|
||||
case -EDEADLOCK:
|
||||
/* Used to restart an op with deadlock avoidance. */
|
||||
trace_xfs_scrub_deadlock_retry(sc->ip, sc->sm, *error);
|
||||
break;
|
||||
case -EFSBADCRC:
|
||||
case -EFSCORRUPTED:
|
||||
/* Note the badness but don't abort. */
|
||||
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
|
||||
*error = 0;
|
||||
/* fall through */
|
||||
default:
|
||||
trace_xfs_scrub_file_op_error(sc, ds->dargs.whichfork,
|
||||
xfs_dir2_da_to_db(ds->dargs.geo,
|
||||
ds->state->path.blk[level].blkno),
|
||||
*error, __return_address);
|
||||
break;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check for da btree corruption. See the section about handling
|
||||
* operational errors in common.c.
|
||||
*/
|
||||
void
|
||||
xfs_scrub_da_set_corrupt(
|
||||
struct xfs_scrub_da_btree *ds,
|
||||
int level)
|
||||
{
|
||||
struct xfs_scrub_context *sc = ds->sc;
|
||||
|
||||
sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
|
||||
|
||||
trace_xfs_scrub_fblock_error(sc, ds->dargs.whichfork,
|
||||
xfs_dir2_da_to_db(ds->dargs.geo,
|
||||
ds->state->path.blk[level].blkno),
|
||||
__return_address);
|
||||
}
|
||||
|
||||
/* Find an entry at a certain level in a da btree. */
|
||||
STATIC void *
|
||||
xfs_scrub_da_btree_entry(
|
||||
struct xfs_scrub_da_btree *ds,
|
||||
int level,
|
||||
int rec)
|
||||
{
|
||||
char *ents;
|
||||
struct xfs_da_state_blk *blk;
|
||||
void *baddr;
|
||||
|
||||
/* Dispatch the entry finding function. */
|
||||
blk = &ds->state->path.blk[level];
|
||||
baddr = blk->bp->b_addr;
|
||||
switch (blk->magic) {
|
||||
case XFS_ATTR_LEAF_MAGIC:
|
||||
case XFS_ATTR3_LEAF_MAGIC:
|
||||
ents = (char *)xfs_attr3_leaf_entryp(baddr);
|
||||
return ents + (rec * sizeof(struct xfs_attr_leaf_entry));
|
||||
case XFS_DIR2_LEAFN_MAGIC:
|
||||
case XFS_DIR3_LEAFN_MAGIC:
|
||||
ents = (char *)ds->dargs.dp->d_ops->leaf_ents_p(baddr);
|
||||
return ents + (rec * sizeof(struct xfs_dir2_leaf_entry));
|
||||
case XFS_DIR2_LEAF1_MAGIC:
|
||||
case XFS_DIR3_LEAF1_MAGIC:
|
||||
ents = (char *)ds->dargs.dp->d_ops->leaf_ents_p(baddr);
|
||||
return ents + (rec * sizeof(struct xfs_dir2_leaf_entry));
|
||||
case XFS_DA_NODE_MAGIC:
|
||||
case XFS_DA3_NODE_MAGIC:
|
||||
ents = (char *)ds->dargs.dp->d_ops->node_tree_p(baddr);
|
||||
return ents + (rec * sizeof(struct xfs_da_node_entry));
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Scrub a da btree hash (key). */
|
||||
int
|
||||
xfs_scrub_da_btree_hash(
|
||||
struct xfs_scrub_da_btree *ds,
|
||||
int level,
|
||||
__be32 *hashp)
|
||||
{
|
||||
struct xfs_da_state_blk *blks;
|
||||
struct xfs_da_node_entry *entry;
|
||||
xfs_dahash_t hash;
|
||||
xfs_dahash_t parent_hash;
|
||||
|
||||
/* Is this hash in order? */
|
||||
hash = be32_to_cpu(*hashp);
|
||||
if (hash < ds->hashes[level])
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
ds->hashes[level] = hash;
|
||||
|
||||
if (level == 0)
|
||||
return 0;
|
||||
|
||||
/* Is this hash no larger than the parent hash? */
|
||||
blks = ds->state->path.blk;
|
||||
entry = xfs_scrub_da_btree_entry(ds, level - 1, blks[level - 1].index);
|
||||
parent_hash = be32_to_cpu(entry->hashval);
|
||||
if (parent_hash < hash)
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check a da btree pointer. Returns true if it's ok to use this
|
||||
* pointer.
|
||||
*/
|
||||
STATIC bool
|
||||
xfs_scrub_da_btree_ptr_ok(
|
||||
struct xfs_scrub_da_btree *ds,
|
||||
int level,
|
||||
xfs_dablk_t blkno)
|
||||
{
|
||||
if (blkno < ds->lowest || (ds->highest != 0 && blkno >= ds->highest)) {
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* The da btree scrubber can handle leaf1 blocks as a degenerate
|
||||
* form of leafn blocks. Since the regular da code doesn't handle
|
||||
* leaf1, we must multiplex the verifiers.
|
||||
*/
|
||||
static void
|
||||
xfs_scrub_da_btree_read_verify(
|
||||
struct xfs_buf *bp)
|
||||
{
|
||||
struct xfs_da_blkinfo *info = bp->b_addr;
|
||||
|
||||
switch (be16_to_cpu(info->magic)) {
|
||||
case XFS_DIR2_LEAF1_MAGIC:
|
||||
case XFS_DIR3_LEAF1_MAGIC:
|
||||
bp->b_ops = &xfs_dir3_leaf1_buf_ops;
|
||||
bp->b_ops->verify_read(bp);
|
||||
return;
|
||||
default:
|
||||
/*
|
||||
* xfs_da3_node_buf_ops already know how to handle
|
||||
* DA*_NODE, ATTR*_LEAF, and DIR*_LEAFN blocks.
|
||||
*/
|
||||
bp->b_ops = &xfs_da3_node_buf_ops;
|
||||
bp->b_ops->verify_read(bp);
|
||||
return;
|
||||
}
|
||||
}
|
||||
static void
|
||||
xfs_scrub_da_btree_write_verify(
|
||||
struct xfs_buf *bp)
|
||||
{
|
||||
struct xfs_da_blkinfo *info = bp->b_addr;
|
||||
|
||||
switch (be16_to_cpu(info->magic)) {
|
||||
case XFS_DIR2_LEAF1_MAGIC:
|
||||
case XFS_DIR3_LEAF1_MAGIC:
|
||||
bp->b_ops = &xfs_dir3_leaf1_buf_ops;
|
||||
bp->b_ops->verify_write(bp);
|
||||
return;
|
||||
default:
|
||||
/*
|
||||
* xfs_da3_node_buf_ops already know how to handle
|
||||
* DA*_NODE, ATTR*_LEAF, and DIR*_LEAFN blocks.
|
||||
*/
|
||||
bp->b_ops = &xfs_da3_node_buf_ops;
|
||||
bp->b_ops->verify_write(bp);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
static const struct xfs_buf_ops xfs_scrub_da_btree_buf_ops = {
|
||||
.name = "xfs_scrub_da_btree",
|
||||
.verify_read = xfs_scrub_da_btree_read_verify,
|
||||
.verify_write = xfs_scrub_da_btree_write_verify,
|
||||
};
|
||||
|
||||
/* Check a block's sibling. */
|
||||
STATIC int
|
||||
xfs_scrub_da_btree_block_check_sibling(
|
||||
struct xfs_scrub_da_btree *ds,
|
||||
int level,
|
||||
int direction,
|
||||
xfs_dablk_t sibling)
|
||||
{
|
||||
int retval;
|
||||
int error;
|
||||
|
||||
memcpy(&ds->state->altpath, &ds->state->path,
|
||||
sizeof(ds->state->altpath));
|
||||
|
||||
/*
|
||||
* If the pointer is null, we shouldn't be able to move the upper
|
||||
* level pointer anywhere.
|
||||
*/
|
||||
if (sibling == 0) {
|
||||
error = xfs_da3_path_shift(ds->state, &ds->state->altpath,
|
||||
direction, false, &retval);
|
||||
if (error == 0 && retval == 0)
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
error = 0;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* Move the alternate cursor one block in the direction given. */
|
||||
error = xfs_da3_path_shift(ds->state, &ds->state->altpath,
|
||||
direction, false, &retval);
|
||||
if (!xfs_scrub_da_process_error(ds, level, &error))
|
||||
return error;
|
||||
if (retval) {
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
return error;
|
||||
}
|
||||
|
||||
/* Compare upper level pointer to sibling pointer. */
|
||||
if (ds->state->altpath.blk[level].blkno != sibling)
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
xfs_trans_brelse(ds->dargs.trans, ds->state->altpath.blk[level].bp);
|
||||
out:
|
||||
return error;
|
||||
}
|
||||
|
||||
/* Check a block's sibling pointers. */
|
||||
STATIC int
|
||||
xfs_scrub_da_btree_block_check_siblings(
|
||||
struct xfs_scrub_da_btree *ds,
|
||||
int level,
|
||||
struct xfs_da_blkinfo *hdr)
|
||||
{
|
||||
xfs_dablk_t forw;
|
||||
xfs_dablk_t back;
|
||||
int error = 0;
|
||||
|
||||
forw = be32_to_cpu(hdr->forw);
|
||||
back = be32_to_cpu(hdr->back);
|
||||
|
||||
/* Top level blocks should not have sibling pointers. */
|
||||
if (level == 0) {
|
||||
if (forw != 0 || back != 0)
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check back (left) and forw (right) pointers. These functions
|
||||
* absorb error codes for us.
|
||||
*/
|
||||
error = xfs_scrub_da_btree_block_check_sibling(ds, level, 0, back);
|
||||
if (error)
|
||||
goto out;
|
||||
error = xfs_scrub_da_btree_block_check_sibling(ds, level, 1, forw);
|
||||
|
||||
out:
|
||||
memset(&ds->state->altpath, 0, sizeof(ds->state->altpath));
|
||||
return error;
|
||||
}
|
||||
|
||||
/* Load a dir/attribute block from a btree. */
|
||||
STATIC int
|
||||
xfs_scrub_da_btree_block(
|
||||
struct xfs_scrub_da_btree *ds,
|
||||
int level,
|
||||
xfs_dablk_t blkno)
|
||||
{
|
||||
struct xfs_da_state_blk *blk;
|
||||
struct xfs_da_intnode *node;
|
||||
struct xfs_da_node_entry *btree;
|
||||
struct xfs_da3_blkinfo *hdr3;
|
||||
struct xfs_da_args *dargs = &ds->dargs;
|
||||
struct xfs_inode *ip = ds->dargs.dp;
|
||||
xfs_ino_t owner;
|
||||
int *pmaxrecs;
|
||||
struct xfs_da3_icnode_hdr nodehdr;
|
||||
int error;
|
||||
|
||||
blk = &ds->state->path.blk[level];
|
||||
ds->state->path.active = level + 1;
|
||||
|
||||
/* Release old block. */
|
||||
if (blk->bp) {
|
||||
xfs_trans_brelse(dargs->trans, blk->bp);
|
||||
blk->bp = NULL;
|
||||
}
|
||||
|
||||
/* Check the pointer. */
|
||||
blk->blkno = blkno;
|
||||
if (!xfs_scrub_da_btree_ptr_ok(ds, level, blkno))
|
||||
goto out_nobuf;
|
||||
|
||||
/* Read the buffer. */
|
||||
error = xfs_da_read_buf(dargs->trans, dargs->dp, blk->blkno, -2,
|
||||
&blk->bp, dargs->whichfork,
|
||||
&xfs_scrub_da_btree_buf_ops);
|
||||
if (!xfs_scrub_da_process_error(ds, level, &error))
|
||||
goto out_nobuf;
|
||||
|
||||
/*
|
||||
* We didn't find a dir btree root block, which means that
|
||||
* there's no LEAF1/LEAFN tree (at least not where it's supposed
|
||||
* to be), so jump out now.
|
||||
*/
|
||||
if (ds->dargs.whichfork == XFS_DATA_FORK && level == 0 &&
|
||||
blk->bp == NULL)
|
||||
goto out_nobuf;
|
||||
|
||||
/* It's /not/ ok for attr trees not to have a da btree. */
|
||||
if (blk->bp == NULL) {
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
goto out_nobuf;
|
||||
}
|
||||
|
||||
hdr3 = blk->bp->b_addr;
|
||||
blk->magic = be16_to_cpu(hdr3->hdr.magic);
|
||||
pmaxrecs = &ds->maxrecs[level];
|
||||
|
||||
if (hdr3->hdr.pad != cpu_to_be16(0))
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
|
||||
/* Check the owner. */
|
||||
if (xfs_sb_version_hascrc(&ip->i_mount->m_sb)) {
|
||||
owner = be64_to_cpu(hdr3->owner);
|
||||
if (owner != ip->i_ino)
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
}
|
||||
|
||||
/* Check the siblings. */
|
||||
error = xfs_scrub_da_btree_block_check_siblings(ds, level, &hdr3->hdr);
|
||||
if (error)
|
||||
goto out;
|
||||
|
||||
/* Interpret the buffer. */
|
||||
switch (blk->magic) {
|
||||
case XFS_ATTR_LEAF_MAGIC:
|
||||
case XFS_ATTR3_LEAF_MAGIC:
|
||||
xfs_trans_buf_set_type(dargs->trans, blk->bp,
|
||||
XFS_BLFT_ATTR_LEAF_BUF);
|
||||
blk->magic = XFS_ATTR_LEAF_MAGIC;
|
||||
blk->hashval = xfs_attr_leaf_lasthash(blk->bp, pmaxrecs);
|
||||
if (ds->tree_level != 0)
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
break;
|
||||
case XFS_DIR2_LEAFN_MAGIC:
|
||||
case XFS_DIR3_LEAFN_MAGIC:
|
||||
xfs_trans_buf_set_type(dargs->trans, blk->bp,
|
||||
XFS_BLFT_DIR_LEAFN_BUF);
|
||||
blk->magic = XFS_DIR2_LEAFN_MAGIC;
|
||||
blk->hashval = xfs_dir2_leaf_lasthash(ip, blk->bp, pmaxrecs);
|
||||
if (ds->tree_level != 0)
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
break;
|
||||
case XFS_DIR2_LEAF1_MAGIC:
|
||||
case XFS_DIR3_LEAF1_MAGIC:
|
||||
xfs_trans_buf_set_type(dargs->trans, blk->bp,
|
||||
XFS_BLFT_DIR_LEAF1_BUF);
|
||||
blk->magic = XFS_DIR2_LEAF1_MAGIC;
|
||||
blk->hashval = xfs_dir2_leaf_lasthash(ip, blk->bp, pmaxrecs);
|
||||
if (ds->tree_level != 0)
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
break;
|
||||
case XFS_DA_NODE_MAGIC:
|
||||
case XFS_DA3_NODE_MAGIC:
|
||||
xfs_trans_buf_set_type(dargs->trans, blk->bp,
|
||||
XFS_BLFT_DA_NODE_BUF);
|
||||
blk->magic = XFS_DA_NODE_MAGIC;
|
||||
node = blk->bp->b_addr;
|
||||
ip->d_ops->node_hdr_from_disk(&nodehdr, node);
|
||||
btree = ip->d_ops->node_tree_p(node);
|
||||
*pmaxrecs = nodehdr.count;
|
||||
blk->hashval = be32_to_cpu(btree[*pmaxrecs - 1].hashval);
|
||||
if (level == 0) {
|
||||
if (nodehdr.level >= XFS_DA_NODE_MAXDEPTH) {
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
goto out_freebp;
|
||||
}
|
||||
ds->tree_level = nodehdr.level;
|
||||
} else {
|
||||
if (ds->tree_level != nodehdr.level) {
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
goto out_freebp;
|
||||
}
|
||||
}
|
||||
|
||||
/* XXX: Check hdr3.pad32 once we know how to fix it. */
|
||||
break;
|
||||
default:
|
||||
xfs_scrub_da_set_corrupt(ds, level);
|
||||
goto out_freebp;
|
||||
}
|
||||
|
||||
out:
|
||||
return error;
|
||||
out_freebp:
|
||||
xfs_trans_brelse(dargs->trans, blk->bp);
|
||||
blk->bp = NULL;
|
||||
out_nobuf:
|
||||
blk->blkno = 0;
|
||||
return error;
|
||||
}
|
||||
|
||||
/* Visit all nodes and leaves of a da btree. */
|
||||
int
|
||||
xfs_scrub_da_btree(
|
||||
struct xfs_scrub_context *sc,
|
||||
int whichfork,
|
||||
xfs_scrub_da_btree_rec_fn scrub_fn)
|
||||
{
|
||||
struct xfs_scrub_da_btree ds = {};
|
||||
struct xfs_mount *mp = sc->mp;
|
||||
struct xfs_da_state_blk *blks;
|
||||
struct xfs_da_node_entry *key;
|
||||
void *rec;
|
||||
xfs_dablk_t blkno;
|
||||
int level;
|
||||
int error;
|
||||
|
||||
/* Skip short format data structures; no btree to scan. */
|
||||
if (XFS_IFORK_FORMAT(sc->ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
|
||||
XFS_IFORK_FORMAT(sc->ip, whichfork) != XFS_DINODE_FMT_BTREE)
|
||||
return 0;
|
||||
|
||||
/* Set up initial da state. */
|
||||
ds.dargs.dp = sc->ip;
|
||||
ds.dargs.whichfork = whichfork;
|
||||
ds.dargs.trans = sc->tp;
|
||||
ds.dargs.op_flags = XFS_DA_OP_OKNOENT;
|
||||
ds.state = xfs_da_state_alloc();
|
||||
ds.state->args = &ds.dargs;
|
||||
ds.state->mp = mp;
|
||||
ds.sc = sc;
|
||||
if (whichfork == XFS_ATTR_FORK) {
|
||||
ds.dargs.geo = mp->m_attr_geo;
|
||||
ds.lowest = 0;
|
||||
ds.highest = 0;
|
||||
} else {
|
||||
ds.dargs.geo = mp->m_dir_geo;
|
||||
ds.lowest = ds.dargs.geo->leafblk;
|
||||
ds.highest = ds.dargs.geo->freeblk;
|
||||
}
|
||||
blkno = ds.lowest;
|
||||
level = 0;
|
||||
|
||||
/* Find the root of the da tree, if present. */
|
||||
blks = ds.state->path.blk;
|
||||
error = xfs_scrub_da_btree_block(&ds, level, blkno);
|
||||
if (error)
|
||||
goto out_state;
|
||||
/*
|
||||
* We didn't find a block at ds.lowest, which means that there's
|
||||
* no LEAF1/LEAFN tree (at least not where it's supposed to be),
|
||||
* so jump out now.
|
||||
*/
|
||||
if (blks[level].bp == NULL)
|
||||
goto out_state;
|
||||
|
||||
blks[level].index = 0;
|
||||
while (level >= 0 && level < XFS_DA_NODE_MAXDEPTH) {
|
||||
/* Handle leaf block. */
|
||||
if (blks[level].magic != XFS_DA_NODE_MAGIC) {
|
||||
/* End of leaf, pop back towards the root. */
|
||||
if (blks[level].index >= ds.maxrecs[level]) {
|
||||
if (level > 0)
|
||||
blks[level - 1].index++;
|
||||
ds.tree_level++;
|
||||
level--;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Dispatch record scrubbing. */
|
||||
rec = xfs_scrub_da_btree_entry(&ds, level,
|
||||
blks[level].index);
|
||||
error = scrub_fn(&ds, level, rec);
|
||||
if (error)
|
||||
break;
|
||||
if (xfs_scrub_should_terminate(sc, &error) ||
|
||||
(sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
|
||||
break;
|
||||
|
||||
blks[level].index++;
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
/* End of node, pop back towards the root. */
|
||||
if (blks[level].index >= ds.maxrecs[level]) {
|
||||
if (level > 0)
|
||||
blks[level - 1].index++;
|
||||
ds.tree_level++;
|
||||
level--;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Hashes in order for scrub? */
|
||||
key = xfs_scrub_da_btree_entry(&ds, level, blks[level].index);
|
||||
error = xfs_scrub_da_btree_hash(&ds, level, &key->hashval);
|
||||
if (error)
|
||||
goto out;
|
||||
|
||||
/* Drill another level deeper. */
|
||||
blkno = be32_to_cpu(key->before);
|
||||
level++;
|
||||
ds.tree_level--;
|
||||
error = xfs_scrub_da_btree_block(&ds, level, blkno);
|
||||
if (error)
|
||||
goto out;
|
||||
if (blks[level].bp == NULL)
|
||||
goto out;
|
||||
|
||||
blks[level].index = 0;
|
||||
}
|
||||
|
||||
out:
|
||||
/* Release all the buffers we're tracking. */
|
||||
for (level = 0; level < XFS_DA_NODE_MAXDEPTH; level++) {
|
||||
if (blks[level].bp == NULL)
|
||||
continue;
|
||||
xfs_trans_brelse(sc->tp, blks[level].bp);
|
||||
blks[level].bp = NULL;
|
||||
}
|
||||
|
||||
out_state:
|
||||
xfs_da_state_free(ds.state);
|
||||
return error;
|
||||
}
|
||||
58
fs/xfs/scrub/dabtree.h
Normal file
58
fs/xfs/scrub/dabtree.h
Normal file
@ -0,0 +1,58 @@
|
||||
/*
|
||||
* Copyright (C) 2017 Oracle. All Rights Reserved.
|
||||
*
|
||||
* Author: Darrick J. Wong <darrick.wong@oracle.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it would be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
#ifndef __XFS_SCRUB_DABTREE_H__
|
||||
#define __XFS_SCRUB_DABTREE_H__
|
||||
|
||||
/* dir/attr btree */
|
||||
|
||||
struct xfs_scrub_da_btree {
|
||||
struct xfs_da_args dargs;
|
||||
xfs_dahash_t hashes[XFS_DA_NODE_MAXDEPTH];
|
||||
int maxrecs[XFS_DA_NODE_MAXDEPTH];
|
||||
struct xfs_da_state *state;
|
||||
struct xfs_scrub_context *sc;
|
||||
|
||||
/*
|
||||
* Lowest and highest directory block address in which we expect
|
||||
* to find dir/attr btree node blocks. For a directory this
|
||||
* (presumably) means between LEAF_OFFSET and FREE_OFFSET; for
|
||||
* attributes there is no limit.
|
||||
*/
|
||||
xfs_dablk_t lowest;
|
||||
xfs_dablk_t highest;
|
||||
|
||||
int tree_level;
|
||||
};
|
||||
|
||||
typedef int (*xfs_scrub_da_btree_rec_fn)(struct xfs_scrub_da_btree *ds,
|
||||
int level, void *rec);
|
||||
|
||||
/* Check for da btree operation errors. */
|
||||
bool xfs_scrub_da_process_error(struct xfs_scrub_da_btree *ds, int level, int *error);
|
||||
|
||||
/* Check for da btree corruption. */
|
||||
void xfs_scrub_da_set_corrupt(struct xfs_scrub_da_btree *ds, int level);
|
||||
|
||||
int xfs_scrub_da_btree_hash(struct xfs_scrub_da_btree *ds, int level,
|
||||
__be32 *hashp);
|
||||
int xfs_scrub_da_btree(struct xfs_scrub_context *sc, int whichfork,
|
||||
xfs_scrub_da_btree_rec_fn scrub_fn);
|
||||
|
||||
#endif /* __XFS_SCRUB_DABTREE_H__ */
|
||||
Loading…
Reference in New Issue
Block a user