2 * Copyright (C) 2017 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
11 * This program is distributed in the hope that it would be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
22 #include "xfs_shared.h"
23 #include "xfs_format.h"
24 #include "xfs_trans_resv.h"
25 #include "xfs_mount.h"
26 #include "xfs_defer.h"
27 #include "xfs_btree.h"
29 #include "xfs_log_format.h"
30 #include "xfs_trans.h"
32 #include "xfs_inode.h"
33 #include "xfs_inode_fork.h"
34 #include "xfs_da_format.h"
35 #include "xfs_da_btree.h"
37 #include "xfs_dir2_priv.h"
38 #include "xfs_attr_leaf.h"
39 #include "scrub/xfs_scrub.h"
40 #include "scrub/scrub.h"
41 #include "scrub/common.h"
42 #include "scrub/trace.h"
43 #include "scrub/dabtree.h"
45 /* Directory/Attribute Btree */
48 * Check for da btree operation errors. See the section about handling
49 * operational errors in common.c.
52 xfs_scrub_da_process_error(
53 struct xfs_scrub_da_btree *ds,
57 struct xfs_scrub_context *sc = ds->sc;
64 /* Used to restart an op with deadlock avoidance. */
65 trace_xfs_scrub_deadlock_retry(sc->ip, sc->sm, *error);
69 /* Note the badness but don't abort. */
70 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
74 trace_xfs_scrub_file_op_error(sc, ds->dargs.whichfork,
75 xfs_dir2_da_to_db(ds->dargs.geo,
76 ds->state->path.blk[level].blkno),
77 *error, __return_address);
84 * Check for da btree corruption. See the section about handling
85 * operational errors in common.c.
88 xfs_scrub_da_set_corrupt(
89 struct xfs_scrub_da_btree *ds,
92 struct xfs_scrub_context *sc = ds->sc;
94 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
96 trace_xfs_scrub_fblock_error(sc, ds->dargs.whichfork,
97 xfs_dir2_da_to_db(ds->dargs.geo,
98 ds->state->path.blk[level].blkno),
102 /* Find an entry at a certain level in a da btree. */
104 xfs_scrub_da_btree_entry(
105 struct xfs_scrub_da_btree *ds,
110 struct xfs_da_state_blk *blk;
113 /* Dispatch the entry finding function. */
114 blk = &ds->state->path.blk[level];
115 baddr = blk->bp->b_addr;
116 switch (blk->magic) {
117 case XFS_ATTR_LEAF_MAGIC:
118 case XFS_ATTR3_LEAF_MAGIC:
119 ents = (char *)xfs_attr3_leaf_entryp(baddr);
120 return ents + (rec * sizeof(struct xfs_attr_leaf_entry));
121 case XFS_DIR2_LEAFN_MAGIC:
122 case XFS_DIR3_LEAFN_MAGIC:
123 ents = (char *)ds->dargs.dp->d_ops->leaf_ents_p(baddr);
124 return ents + (rec * sizeof(struct xfs_dir2_leaf_entry));
125 case XFS_DIR2_LEAF1_MAGIC:
126 case XFS_DIR3_LEAF1_MAGIC:
127 ents = (char *)ds->dargs.dp->d_ops->leaf_ents_p(baddr);
128 return ents + (rec * sizeof(struct xfs_dir2_leaf_entry));
129 case XFS_DA_NODE_MAGIC:
130 case XFS_DA3_NODE_MAGIC:
131 ents = (char *)ds->dargs.dp->d_ops->node_tree_p(baddr);
132 return ents + (rec * sizeof(struct xfs_da_node_entry));
138 /* Scrub a da btree hash (key). */
140 xfs_scrub_da_btree_hash(
141 struct xfs_scrub_da_btree *ds,
145 struct xfs_da_state_blk *blks;
146 struct xfs_da_node_entry *entry;
148 xfs_dahash_t parent_hash;
150 /* Is this hash in order? */
151 hash = be32_to_cpu(*hashp);
152 if (hash < ds->hashes[level])
153 xfs_scrub_da_set_corrupt(ds, level);
154 ds->hashes[level] = hash;
159 /* Is this hash no larger than the parent hash? */
160 blks = ds->state->path.blk;
161 entry = xfs_scrub_da_btree_entry(ds, level - 1, blks[level - 1].index);
162 parent_hash = be32_to_cpu(entry->hashval);
163 if (parent_hash < hash)
164 xfs_scrub_da_set_corrupt(ds, level);
170 * Check a da btree pointer. Returns true if it's ok to use this
174 xfs_scrub_da_btree_ptr_ok(
175 struct xfs_scrub_da_btree *ds,
179 if (blkno < ds->lowest || (ds->highest != 0 && blkno >= ds->highest)) {
180 xfs_scrub_da_set_corrupt(ds, level);
188 * The da btree scrubber can handle leaf1 blocks as a degenerate
189 * form of leafn blocks. Since the regular da code doesn't handle
190 * leaf1, we must multiplex the verifiers.
193 xfs_scrub_da_btree_read_verify(
196 struct xfs_da_blkinfo *info = bp->b_addr;
198 switch (be16_to_cpu(info->magic)) {
199 case XFS_DIR2_LEAF1_MAGIC:
200 case XFS_DIR3_LEAF1_MAGIC:
201 bp->b_ops = &xfs_dir3_leaf1_buf_ops;
202 bp->b_ops->verify_read(bp);
206 * xfs_da3_node_buf_ops already know how to handle
207 * DA*_NODE, ATTR*_LEAF, and DIR*_LEAFN blocks.
209 bp->b_ops = &xfs_da3_node_buf_ops;
210 bp->b_ops->verify_read(bp);
215 xfs_scrub_da_btree_write_verify(
218 struct xfs_da_blkinfo *info = bp->b_addr;
220 switch (be16_to_cpu(info->magic)) {
221 case XFS_DIR2_LEAF1_MAGIC:
222 case XFS_DIR3_LEAF1_MAGIC:
223 bp->b_ops = &xfs_dir3_leaf1_buf_ops;
224 bp->b_ops->verify_write(bp);
228 * xfs_da3_node_buf_ops already know how to handle
229 * DA*_NODE, ATTR*_LEAF, and DIR*_LEAFN blocks.
231 bp->b_ops = &xfs_da3_node_buf_ops;
232 bp->b_ops->verify_write(bp);
237 static const struct xfs_buf_ops xfs_scrub_da_btree_buf_ops = {
238 .name = "xfs_scrub_da_btree",
239 .verify_read = xfs_scrub_da_btree_read_verify,
240 .verify_write = xfs_scrub_da_btree_write_verify,
243 /* Check a block's sibling. */
245 xfs_scrub_da_btree_block_check_sibling(
246 struct xfs_scrub_da_btree *ds,
254 memcpy(&ds->state->altpath, &ds->state->path,
255 sizeof(ds->state->altpath));
258 * If the pointer is null, we shouldn't be able to move the upper
259 * level pointer anywhere.
262 error = xfs_da3_path_shift(ds->state, &ds->state->altpath,
263 direction, false, &retval);
264 if (error == 0 && retval == 0)
265 xfs_scrub_da_set_corrupt(ds, level);
270 /* Move the alternate cursor one block in the direction given. */
271 error = xfs_da3_path_shift(ds->state, &ds->state->altpath,
272 direction, false, &retval);
273 if (!xfs_scrub_da_process_error(ds, level, &error))
276 xfs_scrub_da_set_corrupt(ds, level);
280 /* Compare upper level pointer to sibling pointer. */
281 if (ds->state->altpath.blk[level].blkno != sibling)
282 xfs_scrub_da_set_corrupt(ds, level);
283 xfs_trans_brelse(ds->dargs.trans, ds->state->altpath.blk[level].bp);
288 /* Check a block's sibling pointers. */
290 xfs_scrub_da_btree_block_check_siblings(
291 struct xfs_scrub_da_btree *ds,
293 struct xfs_da_blkinfo *hdr)
299 forw = be32_to_cpu(hdr->forw);
300 back = be32_to_cpu(hdr->back);
302 /* Top level blocks should not have sibling pointers. */
304 if (forw != 0 || back != 0)
305 xfs_scrub_da_set_corrupt(ds, level);
310 * Check back (left) and forw (right) pointers. These functions
311 * absorb error codes for us.
313 error = xfs_scrub_da_btree_block_check_sibling(ds, level, 0, back);
316 error = xfs_scrub_da_btree_block_check_sibling(ds, level, 1, forw);
319 memset(&ds->state->altpath, 0, sizeof(ds->state->altpath));
323 /* Load a dir/attribute block from a btree. */
325 xfs_scrub_da_btree_block(
326 struct xfs_scrub_da_btree *ds,
330 struct xfs_da_state_blk *blk;
331 struct xfs_da_intnode *node;
332 struct xfs_da_node_entry *btree;
333 struct xfs_da3_blkinfo *hdr3;
334 struct xfs_da_args *dargs = &ds->dargs;
335 struct xfs_inode *ip = ds->dargs.dp;
338 struct xfs_da3_icnode_hdr nodehdr;
341 blk = &ds->state->path.blk[level];
342 ds->state->path.active = level + 1;
344 /* Release old block. */
346 xfs_trans_brelse(dargs->trans, blk->bp);
350 /* Check the pointer. */
352 if (!xfs_scrub_da_btree_ptr_ok(ds, level, blkno))
355 /* Read the buffer. */
356 error = xfs_da_read_buf(dargs->trans, dargs->dp, blk->blkno, -2,
357 &blk->bp, dargs->whichfork,
358 &xfs_scrub_da_btree_buf_ops);
359 if (!xfs_scrub_da_process_error(ds, level, &error))
363 * We didn't find a dir btree root block, which means that
364 * there's no LEAF1/LEAFN tree (at least not where it's supposed
365 * to be), so jump out now.
367 if (ds->dargs.whichfork == XFS_DATA_FORK && level == 0 &&
371 /* It's /not/ ok for attr trees not to have a da btree. */
372 if (blk->bp == NULL) {
373 xfs_scrub_da_set_corrupt(ds, level);
377 hdr3 = blk->bp->b_addr;
378 blk->magic = be16_to_cpu(hdr3->hdr.magic);
379 pmaxrecs = &ds->maxrecs[level];
381 /* We only started zeroing the header on v5 filesystems. */
382 if (xfs_sb_version_hascrc(&ds->sc->mp->m_sb) && hdr3->hdr.pad)
383 xfs_scrub_da_set_corrupt(ds, level);
385 /* Check the owner. */
386 if (xfs_sb_version_hascrc(&ip->i_mount->m_sb)) {
387 owner = be64_to_cpu(hdr3->owner);
388 if (owner != ip->i_ino)
389 xfs_scrub_da_set_corrupt(ds, level);
392 /* Check the siblings. */
393 error = xfs_scrub_da_btree_block_check_siblings(ds, level, &hdr3->hdr);
397 /* Interpret the buffer. */
398 switch (blk->magic) {
399 case XFS_ATTR_LEAF_MAGIC:
400 case XFS_ATTR3_LEAF_MAGIC:
401 xfs_trans_buf_set_type(dargs->trans, blk->bp,
402 XFS_BLFT_ATTR_LEAF_BUF);
403 blk->magic = XFS_ATTR_LEAF_MAGIC;
404 blk->hashval = xfs_attr_leaf_lasthash(blk->bp, pmaxrecs);
405 if (ds->tree_level != 0)
406 xfs_scrub_da_set_corrupt(ds, level);
408 case XFS_DIR2_LEAFN_MAGIC:
409 case XFS_DIR3_LEAFN_MAGIC:
410 xfs_trans_buf_set_type(dargs->trans, blk->bp,
411 XFS_BLFT_DIR_LEAFN_BUF);
412 blk->magic = XFS_DIR2_LEAFN_MAGIC;
413 blk->hashval = xfs_dir2_leaf_lasthash(ip, blk->bp, pmaxrecs);
414 if (ds->tree_level != 0)
415 xfs_scrub_da_set_corrupt(ds, level);
417 case XFS_DIR2_LEAF1_MAGIC:
418 case XFS_DIR3_LEAF1_MAGIC:
419 xfs_trans_buf_set_type(dargs->trans, blk->bp,
420 XFS_BLFT_DIR_LEAF1_BUF);
421 blk->magic = XFS_DIR2_LEAF1_MAGIC;
422 blk->hashval = xfs_dir2_leaf_lasthash(ip, blk->bp, pmaxrecs);
423 if (ds->tree_level != 0)
424 xfs_scrub_da_set_corrupt(ds, level);
426 case XFS_DA_NODE_MAGIC:
427 case XFS_DA3_NODE_MAGIC:
428 xfs_trans_buf_set_type(dargs->trans, blk->bp,
429 XFS_BLFT_DA_NODE_BUF);
430 blk->magic = XFS_DA_NODE_MAGIC;
431 node = blk->bp->b_addr;
432 ip->d_ops->node_hdr_from_disk(&nodehdr, node);
433 btree = ip->d_ops->node_tree_p(node);
434 *pmaxrecs = nodehdr.count;
435 blk->hashval = be32_to_cpu(btree[*pmaxrecs - 1].hashval);
437 if (nodehdr.level >= XFS_DA_NODE_MAXDEPTH) {
438 xfs_scrub_da_set_corrupt(ds, level);
441 ds->tree_level = nodehdr.level;
443 if (ds->tree_level != nodehdr.level) {
444 xfs_scrub_da_set_corrupt(ds, level);
449 /* XXX: Check hdr3.pad32 once we know how to fix it. */
452 xfs_scrub_da_set_corrupt(ds, level);
459 xfs_trans_brelse(dargs->trans, blk->bp);
466 /* Visit all nodes and leaves of a da btree. */
469 struct xfs_scrub_context *sc,
471 xfs_scrub_da_btree_rec_fn scrub_fn,
474 struct xfs_scrub_da_btree ds = {};
475 struct xfs_mount *mp = sc->mp;
476 struct xfs_da_state_blk *blks;
477 struct xfs_da_node_entry *key;
483 /* Skip short format data structures; no btree to scan. */
484 if (XFS_IFORK_FORMAT(sc->ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
485 XFS_IFORK_FORMAT(sc->ip, whichfork) != XFS_DINODE_FMT_BTREE)
488 /* Set up initial da state. */
489 ds.dargs.dp = sc->ip;
490 ds.dargs.whichfork = whichfork;
491 ds.dargs.trans = sc->tp;
492 ds.dargs.op_flags = XFS_DA_OP_OKNOENT;
493 ds.state = xfs_da_state_alloc();
494 ds.state->args = &ds.dargs;
497 ds.private = private;
498 if (whichfork == XFS_ATTR_FORK) {
499 ds.dargs.geo = mp->m_attr_geo;
503 ds.dargs.geo = mp->m_dir_geo;
504 ds.lowest = ds.dargs.geo->leafblk;
505 ds.highest = ds.dargs.geo->freeblk;
510 /* Find the root of the da tree, if present. */
511 blks = ds.state->path.blk;
512 error = xfs_scrub_da_btree_block(&ds, level, blkno);
516 * We didn't find a block at ds.lowest, which means that there's
517 * no LEAF1/LEAFN tree (at least not where it's supposed to be),
520 if (blks[level].bp == NULL)
523 blks[level].index = 0;
524 while (level >= 0 && level < XFS_DA_NODE_MAXDEPTH) {
525 /* Handle leaf block. */
526 if (blks[level].magic != XFS_DA_NODE_MAGIC) {
527 /* End of leaf, pop back towards the root. */
528 if (blks[level].index >= ds.maxrecs[level]) {
530 blks[level - 1].index++;
536 /* Dispatch record scrubbing. */
537 rec = xfs_scrub_da_btree_entry(&ds, level,
539 error = scrub_fn(&ds, level, rec);
542 if (xfs_scrub_should_terminate(sc, &error) ||
543 (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
551 /* End of node, pop back towards the root. */
552 if (blks[level].index >= ds.maxrecs[level]) {
554 blks[level - 1].index++;
560 /* Hashes in order for scrub? */
561 key = xfs_scrub_da_btree_entry(&ds, level, blks[level].index);
562 error = xfs_scrub_da_btree_hash(&ds, level, &key->hashval);
566 /* Drill another level deeper. */
567 blkno = be32_to_cpu(key->before);
570 error = xfs_scrub_da_btree_block(&ds, level, blkno);
573 if (blks[level].bp == NULL)
576 blks[level].index = 0;
580 /* Release all the buffers we're tracking. */
581 for (level = 0; level < XFS_DA_NODE_MAXDEPTH; level++) {
582 if (blks[level].bp == NULL)
584 xfs_trans_brelse(sc->tp, blks[level].bp);
585 blks[level].bp = NULL;
589 xfs_da_state_free(ds.state);