fs/xfs/scrub/dabtree.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2017 Oracle.  All Rights Reserved.
   4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
   5  */
   6 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_trans_resv.h"
  11 #include "xfs_mount.h"
  12 #include "xfs_log_format.h"
  13 #include "xfs_trans.h"
  14 #include "xfs_inode.h"
  15 #include "xfs_dir2.h"
  16 #include "xfs_dir2_priv.h"
  17 #include "xfs_attr_leaf.h"
  18 #include "scrub/scrub.h"
  19 #include "scrub/common.h"
  20 #include "scrub/trace.h"
  21 #include "scrub/dabtree.h"
  22
  23 /* Directory/Attribute Btree */
  24
  25 /*
  26  * Check for da btree operation errors.  See the section about handling
  27  * operational errors in common.c.
  28  */
  29 bool
  30 xchk_da_process_error(
  31         struct xchk_da_btree    *ds,
  32         int                     level,
  33         int                     *error)
  34 {
  35         struct xfs_scrub        *sc = ds->sc;
  36
  37         if (*error == 0)
  38                 return true;
  39
  40         switch (*error) {
  41         case -EDEADLOCK:
  42                 /* Used to restart an op with deadlock avoidance. */
  43                 trace_xchk_deadlock_retry(sc->ip, sc->sm, *error);
  44                 break;
  45         case -EFSBADCRC:
  46         case -EFSCORRUPTED:
  47                 /* Note the badness but don't abort. */
  48                 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
  49                 *error = 0;
  50                 /* fall through */
  51         default:
  52                 trace_xchk_file_op_error(sc, ds->dargs.whichfork,
  53                                 xfs_dir2_da_to_db(ds->dargs.geo,
  54                                         ds->state->path.blk[level].blkno),
  55                                 *error, __return_address);
  56                 break;
  57         }
  58         return false;
  59 }
  60
  61 /*
  62  * Check for da btree corruption.  See the section about handling
  63  * operational errors in common.c.
  64  */
  65 void
  66 xchk_da_set_corrupt(
  67         struct xchk_da_btree    *ds,
  68         int                     level)
  69 {
  70         struct xfs_scrub        *sc = ds->sc;
  71
  72         sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
  73
  74         trace_xchk_fblock_error(sc, ds->dargs.whichfork,
  75                         xfs_dir2_da_to_db(ds->dargs.geo,
  76                                 ds->state->path.blk[level].blkno),
  77                         __return_address);
  78 }
  79
  80 static struct xfs_da_node_entry *
  81 xchk_da_btree_node_entry(
  82         struct xchk_da_btree            *ds,
  83         int                             level)
  84 {
  85         struct xfs_da_state_blk         *blk = &ds->state->path.blk[level];
  86         struct xfs_da3_icnode_hdr       hdr;
  87
  88         ASSERT(blk->magic == XFS_DA_NODE_MAGIC);
  89
  90         xfs_da3_node_hdr_from_disk(ds->sc->mp, &hdr, blk->bp->b_addr);
  91         return hdr.btree + blk->index;
  92 }
  93
  94 /* Scrub a da btree hash (key). */
  95 int
  96 xchk_da_btree_hash(
  97         struct xchk_da_btree            *ds,
  98         int                             level,
  99         __be32                          *hashp)
 100 {
 101         struct xfs_da_node_entry        *entry;
 102         xfs_dahash_t                    hash;
 103         xfs_dahash_t                    parent_hash;
 104
 105         /* Is this hash in order? */
 106         hash = be32_to_cpu(*hashp);
 107         if (hash < ds->hashes[level])
 108                 xchk_da_set_corrupt(ds, level);
 109         ds->hashes[level] = hash;
 110
 111         if (level == 0)
 112                 return 0;
 113
 114         /* Is this hash no larger than the parent hash? */
 115         entry = xchk_da_btree_node_entry(ds, level - 1);
 116         parent_hash = be32_to_cpu(entry->hashval);
 117         if (parent_hash < hash)
 118                 xchk_da_set_corrupt(ds, level);
 119
 120         return 0;
 121 }
 122
 123 /*
 124  * Check a da btree pointer.  Returns true if it's ok to use this
 125  * pointer.
 126  */
 127 STATIC bool
 128 xchk_da_btree_ptr_ok(
 129         struct xchk_da_btree    *ds,
 130         int                     level,
 131         xfs_dablk_t             blkno)
 132 {
 133         if (blkno < ds->lowest || (ds->highest != 0 && blkno >= ds->highest)) {
 134                 xchk_da_set_corrupt(ds, level);
 135                 return false;
 136         }
 137
 138         return true;
 139 }
 140
 141 /*
 142  * The da btree scrubber can handle leaf1 blocks as a degenerate
 143  * form of leafn blocks.  Since the regular da code doesn't handle
 144  * leaf1, we must multiplex the verifiers.
 145  */
 146 static void
 147 xchk_da_btree_read_verify(
 148         struct xfs_buf          *bp)
 149 {
 150         struct xfs_da_blkinfo   *info = bp->b_addr;
 151
 152         switch (be16_to_cpu(info->magic)) {
 153         case XFS_DIR2_LEAF1_MAGIC:
 154         case XFS_DIR3_LEAF1_MAGIC:
 155                 bp->b_ops = &xfs_dir3_leaf1_buf_ops;
 156                 bp->b_ops->verify_read(bp);
 157                 return;
 158         default:
 159                 /*
 160                  * xfs_da3_node_buf_ops already know how to handle
 161                  * DA*_NODE, ATTR*_LEAF, and DIR*_LEAFN blocks.
 162                  */
 163                 bp->b_ops = &xfs_da3_node_buf_ops;
 164                 bp->b_ops->verify_read(bp);
 165                 return;
 166         }
 167 }
 168 static void
 169 xchk_da_btree_write_verify(
 170         struct xfs_buf          *bp)
 171 {
 172         struct xfs_da_blkinfo   *info = bp->b_addr;
 173
 174         switch (be16_to_cpu(info->magic)) {
 175         case XFS_DIR2_LEAF1_MAGIC:
 176         case XFS_DIR3_LEAF1_MAGIC:
 177                 bp->b_ops = &xfs_dir3_leaf1_buf_ops;
 178                 bp->b_ops->verify_write(bp);
 179                 return;
 180         default:
 181                 /*
 182                  * xfs_da3_node_buf_ops already know how to handle
 183                  * DA*_NODE, ATTR*_LEAF, and DIR*_LEAFN blocks.
 184                  */
 185                 bp->b_ops = &xfs_da3_node_buf_ops;
 186                 bp->b_ops->verify_write(bp);
 187                 return;
 188         }
 189 }
 190 static void *
 191 xchk_da_btree_verify(
 192         struct xfs_buf          *bp)
 193 {
 194         struct xfs_da_blkinfo   *info = bp->b_addr;
 195
 196         switch (be16_to_cpu(info->magic)) {
 197         case XFS_DIR2_LEAF1_MAGIC:
 198         case XFS_DIR3_LEAF1_MAGIC:
 199                 bp->b_ops = &xfs_dir3_leaf1_buf_ops;
 200                 return bp->b_ops->verify_struct(bp);
 201         default:
 202                 bp->b_ops = &xfs_da3_node_buf_ops;
 203                 return bp->b_ops->verify_struct(bp);
 204         }
 205 }
 206
 207 static const struct xfs_buf_ops xchk_da_btree_buf_ops = {
 208         .name = "xchk_da_btree",
 209         .verify_read = xchk_da_btree_read_verify,
 210         .verify_write = xchk_da_btree_write_verify,
 211         .verify_struct = xchk_da_btree_verify,
 212 };
 213
 214 /* Check a block's sibling. */
 215 STATIC int
 216 xchk_da_btree_block_check_sibling(
 217         struct xchk_da_btree    *ds,
 218         int                     level,
 219         int                     direction,
 220         xfs_dablk_t             sibling)
 221 {
 222         struct xfs_da_state_path *path = &ds->state->path;
 223         struct xfs_da_state_path *altpath = &ds->state->altpath;
 224         int                     retval;
 225         int                     plevel;
 226         int                     error;
 227
 228         memcpy(altpath, path, sizeof(ds->state->altpath));
 229
 230         /*
 231          * If the pointer is null, we shouldn't be able to move the upper
 232          * level pointer anywhere.
 233          */
 234         if (sibling == 0) {
 235                 error = xfs_da3_path_shift(ds->state, altpath, direction,
 236                                 false, &retval);
 237                 if (error == 0 && retval == 0)
 238                         xchk_da_set_corrupt(ds, level);
 239                 error = 0;
 240                 goto out;
 241         }
 242
 243         /* Move the alternate cursor one block in the direction given. */
 244         error = xfs_da3_path_shift(ds->state, altpath, direction, false,
 245                         &retval);
 246         if (!xchk_da_process_error(ds, level, &error))
 247                 goto out;
 248         if (retval) {
 249                 xchk_da_set_corrupt(ds, level);
 250                 goto out;
 251         }
 252         if (altpath->blk[level].bp)
 253                 xchk_buffer_recheck(ds->sc, altpath->blk[level].bp);
 254
 255         /* Compare upper level pointer to sibling pointer. */
 256         if (altpath->blk[level].blkno != sibling)
 257                 xchk_da_set_corrupt(ds, level);
 258
 259 out:
 260         /* Free all buffers in the altpath that aren't referenced from path. */
 261         for (plevel = 0; plevel < altpath->active; plevel++) {
 262                 if (altpath->blk[plevel].bp == NULL ||
 263                     (plevel < path->active &&
 264                      altpath->blk[plevel].bp == path->blk[plevel].bp))
 265                         continue;
 266
 267                 xfs_trans_brelse(ds->dargs.trans, altpath->blk[plevel].bp);
 268                 altpath->blk[plevel].bp = NULL;
 269         }
 270
 271         return error;
 272 }
 273
 274 /* Check a block's sibling pointers. */
 275 STATIC int
 276 xchk_da_btree_block_check_siblings(
 277         struct xchk_da_btree    *ds,
 278         int                     level,
 279         struct xfs_da_blkinfo   *hdr)
 280 {
 281         xfs_dablk_t             forw;
 282         xfs_dablk_t             back;
 283         int                     error = 0;
 284
 285         forw = be32_to_cpu(hdr->forw);
 286         back = be32_to_cpu(hdr->back);
 287
 288         /* Top level blocks should not have sibling pointers. */
 289         if (level == 0) {
 290                 if (forw != 0 || back != 0)
 291                         xchk_da_set_corrupt(ds, level);
 292                 return 0;
 293         }
 294
 295         /*
 296          * Check back (left) and forw (right) pointers.  These functions
 297          * absorb error codes for us.
 298          */
 299         error = xchk_da_btree_block_check_sibling(ds, level, 0, back);
 300         if (error)
 301                 goto out;
 302         error = xchk_da_btree_block_check_sibling(ds, level, 1, forw);
 303
 304 out:
 305         memset(&ds->state->altpath, 0, sizeof(ds->state->altpath));
 306         return error;
 307 }
 308
 309 /* Load a dir/attribute block from a btree. */
 310 STATIC int
 311 xchk_da_btree_block(
 312         struct xchk_da_btree            *ds,
 313         int                             level,
 314         xfs_dablk_t                     blkno)
 315 {
 316         struct xfs_da_state_blk         *blk;
 317         struct xfs_da_intnode           *node;
 318         struct xfs_da_node_entry        *btree;
 319         struct xfs_da3_blkinfo          *hdr3;
 320         struct xfs_da_args              *dargs = &ds->dargs;
 321         struct xfs_inode                *ip = ds->dargs.dp;
 322         xfs_ino_t                       owner;
 323         int                             *pmaxrecs;
 324         struct xfs_da3_icnode_hdr       nodehdr;
 325         int                             error = 0;
 326
 327         blk = &ds->state->path.blk[level];
 328         ds->state->path.active = level + 1;
 329
 330         /* Release old block. */
 331         if (blk->bp) {
 332                 xfs_trans_brelse(dargs->trans, blk->bp);
 333                 blk->bp = NULL;
 334         }
 335
 336         /* Check the pointer. */
 337         blk->blkno = blkno;
 338         if (!xchk_da_btree_ptr_ok(ds, level, blkno))
 339                 goto out_nobuf;
 340
 341         /* Read the buffer. */
 342         error = xfs_da_read_buf(dargs->trans, dargs->dp, blk->blkno,
 343                         XFS_DABUF_MAP_HOLE_OK, &blk->bp, dargs->whichfork,
 344                         &xchk_da_btree_buf_ops);
 345         if (!xchk_da_process_error(ds, level, &error))
 346                 goto out_nobuf;
 347         if (blk->bp)
 348                 xchk_buffer_recheck(ds->sc, blk->bp);
 349
 350         /*
 351          * We didn't find a dir btree root block, which means that
 352          * there's no LEAF1/LEAFN tree (at least not where it's supposed
 353          * to be), so jump out now.
 354          */
 355         if (ds->dargs.whichfork == XFS_DATA_FORK && level == 0 &&
 356                         blk->bp == NULL)
 357                 goto out_nobuf;
 358
 359         /* It's /not/ ok for attr trees not to have a da btree. */
 360         if (blk->bp == NULL) {
 361                 xchk_da_set_corrupt(ds, level);
 362                 goto out_nobuf;
 363         }
 364
 365         hdr3 = blk->bp->b_addr;
 366         blk->magic = be16_to_cpu(hdr3->hdr.magic);
 367         pmaxrecs = &ds->maxrecs[level];
 368
 369         /* We only started zeroing the header on v5 filesystems. */
 370         if (xfs_sb_version_hascrc(&ds->sc->mp->m_sb) && hdr3->hdr.pad)
 371                 xchk_da_set_corrupt(ds, level);
 372
 373         /* Check the owner. */
 374         if (xfs_sb_version_hascrc(&ip->i_mount->m_sb)) {
 375                 owner = be64_to_cpu(hdr3->owner);
 376                 if (owner != ip->i_ino)
 377                         xchk_da_set_corrupt(ds, level);
 378         }
 379
 380         /* Check the siblings. */
 381         error = xchk_da_btree_block_check_siblings(ds, level, &hdr3->hdr);
 382         if (error)
 383                 goto out;
 384
 385         /* Interpret the buffer. */
 386         switch (blk->magic) {
 387         case XFS_ATTR_LEAF_MAGIC:
 388         case XFS_ATTR3_LEAF_MAGIC:
 389                 xfs_trans_buf_set_type(dargs->trans, blk->bp,
 390                                 XFS_BLFT_ATTR_LEAF_BUF);
 391                 blk->magic = XFS_ATTR_LEAF_MAGIC;
 392                 blk->hashval = xfs_attr_leaf_lasthash(blk->bp, pmaxrecs);
 393                 if (ds->tree_level != 0)
 394                         xchk_da_set_corrupt(ds, level);
 395                 break;
 396         case XFS_DIR2_LEAFN_MAGIC:
 397         case XFS_DIR3_LEAFN_MAGIC:
 398                 xfs_trans_buf_set_type(dargs->trans, blk->bp,
 399                                 XFS_BLFT_DIR_LEAFN_BUF);
 400                 blk->magic = XFS_DIR2_LEAFN_MAGIC;
 401                 blk->hashval = xfs_dir2_leaf_lasthash(ip, blk->bp, pmaxrecs);
 402                 if (ds->tree_level != 0)
 403                         xchk_da_set_corrupt(ds, level);
 404                 break;
 405         case XFS_DIR2_LEAF1_MAGIC:
 406         case XFS_DIR3_LEAF1_MAGIC:
 407                 xfs_trans_buf_set_type(dargs->trans, blk->bp,
 408                                 XFS_BLFT_DIR_LEAF1_BUF);
 409                 blk->magic = XFS_DIR2_LEAF1_MAGIC;
 410                 blk->hashval = xfs_dir2_leaf_lasthash(ip, blk->bp, pmaxrecs);
 411                 if (ds->tree_level != 0)
 412                         xchk_da_set_corrupt(ds, level);
 413                 break;
 414         case XFS_DA_NODE_MAGIC:
 415         case XFS_DA3_NODE_MAGIC:
 416                 xfs_trans_buf_set_type(dargs->trans, blk->bp,
 417                                 XFS_BLFT_DA_NODE_BUF);
 418                 blk->magic = XFS_DA_NODE_MAGIC;
 419                 node = blk->bp->b_addr;
 420                 xfs_da3_node_hdr_from_disk(ip->i_mount, &nodehdr, node);
 421                 btree = nodehdr.btree;
 422                 *pmaxrecs = nodehdr.count;
 423                 blk->hashval = be32_to_cpu(btree[*pmaxrecs - 1].hashval);
 424                 if (level == 0) {
 425                         if (nodehdr.level >= XFS_DA_NODE_MAXDEPTH) {
 426                                 xchk_da_set_corrupt(ds, level);
 427                                 goto out_freebp;
 428                         }
 429                         ds->tree_level = nodehdr.level;
 430                 } else {
 431                         if (ds->tree_level != nodehdr.level) {
 432                                 xchk_da_set_corrupt(ds, level);
 433                                 goto out_freebp;
 434                         }
 435                 }
 436
 437                 /* XXX: Check hdr3.pad32 once we know how to fix it. */
 438                 break;
 439         default:
 440                 xchk_da_set_corrupt(ds, level);
 441                 goto out_freebp;
 442         }
 443
 444         /*
 445          * If we've been handed a block that is below the dabtree root, does
 446          * its hashval match what the parent block expected to see?
 447          */
 448         if (level > 0) {
 449                 struct xfs_da_node_entry        *key;
 450
 451                 key = xchk_da_btree_node_entry(ds, level - 1);
 452                 if (be32_to_cpu(key->hashval) != blk->hashval) {
 453                         xchk_da_set_corrupt(ds, level);
 454                         goto out_freebp;
 455                 }
 456         }
 457
 458 out:
 459         return error;
 460 out_freebp:
 461         xfs_trans_brelse(dargs->trans, blk->bp);
 462         blk->bp = NULL;
 463 out_nobuf:
 464         blk->blkno = 0;
 465         return error;
 466 }
 467
 468 /* Visit all nodes and leaves of a da btree. */
 469 int
 470 xchk_da_btree(
 471         struct xfs_scrub                *sc,
 472         int                             whichfork,
 473         xchk_da_btree_rec_fn            scrub_fn,
 474         void                            *private)
 475 {
 476         struct xchk_da_btree            ds = {};
 477         struct xfs_mount                *mp = sc->mp;
 478         struct xfs_da_state_blk         *blks;
 479         struct xfs_da_node_entry        *key;
 480         xfs_dablk_t                     blkno;
 481         int                             level;
 482         int                             error;
 483
 484         /* Skip short format data structures; no btree to scan. */
 485         if (!xfs_ifork_has_extents(XFS_IFORK_PTR(sc->ip, whichfork)))
 486                 return 0;
 487
 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(&ds.dargs);
 494         ds.sc = sc;
 495         ds.private = private;
 496         if (whichfork == XFS_ATTR_FORK) {
 497                 ds.dargs.geo = mp->m_attr_geo;
 498                 ds.lowest = 0;
 499                 ds.highest = 0;
 500         } else {
 501                 ds.dargs.geo = mp->m_dir_geo;
 502                 ds.lowest = ds.dargs.geo->leafblk;
 503                 ds.highest = ds.dargs.geo->freeblk;
 504         }
 505         blkno = ds.lowest;
 506         level = 0;
 507
 508         /* Find the root of the da tree, if present. */
 509         blks = ds.state->path.blk;
 510         error = xchk_da_btree_block(&ds, level, blkno);
 511         if (error)
 512                 goto out_state;
 513         /*
 514          * We didn't find a block at ds.lowest, which means that there's
 515          * no LEAF1/LEAFN tree (at least not where it's supposed to be),
 516          * so jump out now.
 517          */
 518         if (blks[level].bp == NULL)
 519                 goto out_state;
 520
 521         blks[level].index = 0;
 522         while (level >= 0 && level < XFS_DA_NODE_MAXDEPTH) {
 523                 /* Handle leaf block. */
 524                 if (blks[level].magic != XFS_DA_NODE_MAGIC) {
 525                         /* End of leaf, pop back towards the root. */
 526                         if (blks[level].index >= ds.maxrecs[level]) {
 527                                 if (level > 0)
 528                                         blks[level - 1].index++;
 529                                 ds.tree_level++;
 530                                 level--;
 531                                 continue;
 532                         }
 533
 534                         /* Dispatch record scrubbing. */
 535                         error = scrub_fn(&ds, level);
 536                         if (error)
 537                                 break;
 538                         if (xchk_should_terminate(sc, &error) ||
 539                             (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
 540                                 break;
 541
 542                         blks[level].index++;
 543                         continue;
 544                 }
 545
 546
 547                 /* End of node, pop back towards the root. */
 548                 if (blks[level].index >= ds.maxrecs[level]) {
 549                         if (level > 0)
 550                                 blks[level - 1].index++;
 551                         ds.tree_level++;
 552                         level--;
 553                         continue;
 554                 }
 555
 556                 /* Hashes in order for scrub? */
 557                 key = xchk_da_btree_node_entry(&ds, level);
 558                 error = xchk_da_btree_hash(&ds, level, &key->hashval);
 559                 if (error)
 560                         goto out;
 561
 562                 /* Drill another level deeper. */
 563                 blkno = be32_to_cpu(key->before);
 564                 level++;
 565                 if (level >= XFS_DA_NODE_MAXDEPTH) {
 566                         /* Too deep! */
 567                         xchk_da_set_corrupt(&ds, level - 1);
 568                         break;
 569                 }
 570                 ds.tree_level--;
 571                 error = xchk_da_btree_block(&ds, level, blkno);
 572                 if (error)
 573                         goto out;
 574                 if (blks[level].bp == NULL)
 575                         goto out;
 576
 577                 blks[level].index = 0;
 578         }
 579
 580 out:
 581         /* Release all the buffers we're tracking. */
 582         for (level = 0; level < XFS_DA_NODE_MAXDEPTH; level++) {
 583                 if (blks[level].bp == NULL)
 584                         continue;
 585                 xfs_trans_brelse(sc->tp, blks[level].bp);
 586                 blks[level].bp = NULL;
 587         }
 588
 589 out_state:
 590         xfs_da_state_free(ds.state);
 591         return error;
 592 }