1 /* 2 * Copyright (C) 2017 Oracle. All Rights Reserved. 3 * 4 * Author: Darrick J. Wong <darrick.wong@oracle.com> 5 * 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. 10 * 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. 15 * 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. 19 */ 20 #include "xfs.h" 21 #include "xfs_fs.h" 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" 28 #include "xfs_bit.h" 29 #include "xfs_log_format.h" 30 #include "xfs_trans.h" 31 #include "xfs_sb.h" 32 #include "xfs_inode.h" 33 #include "xfs_inode_fork.h" 34 #include "xfs_da_format.h" 35 #include "xfs_da_btree.h" 36 #include "xfs_dir2.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" 44 45 /* Directory/Attribute Btree */ 46 47 /* 48 * Check for da btree operation errors. See the section about handling 49 * operational errors in common.c. 50 */ 51 bool 52 xfs_scrub_da_process_error( 53 struct xfs_scrub_da_btree *ds, 54 int level, 55 int *error) 56 { 57 struct xfs_scrub_context *sc = ds->sc; 58 59 if (*error == 0) 60 return true; 61 62 switch (*error) { 63 case -EDEADLOCK: 64 /* Used to restart an op with deadlock avoidance. */ 65 trace_xfs_scrub_deadlock_retry(sc->ip, sc->sm, *error); 66 break; 67 case -EFSBADCRC: 68 case -EFSCORRUPTED: 69 /* Note the badness but don't abort. */ 70 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT; 71 *error = 0; 72 /* fall through */ 73 default: 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); 78 break; 79 } 80 return false; 81 } 82 83 /* 84 * Check for da btree corruption. See the section about handling 85 * operational errors in common.c. 86 */ 87 void 88 xfs_scrub_da_set_corrupt( 89 struct xfs_scrub_da_btree *ds, 90 int level) 91 { 92 struct xfs_scrub_context *sc = ds->sc; 93 94 sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT; 95 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), 99 __return_address); 100 } 101 102 /* Find an entry at a certain level in a da btree. */ 103 STATIC void * 104 xfs_scrub_da_btree_entry( 105 struct xfs_scrub_da_btree *ds, 106 int level, 107 int rec) 108 { 109 char *ents; 110 struct xfs_da_state_blk *blk; 111 void *baddr; 112 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)); 133 } 134 135 return NULL; 136 } 137 138 /* Scrub a da btree hash (key). */ 139 int 140 xfs_scrub_da_btree_hash( 141 struct xfs_scrub_da_btree *ds, 142 int level, 143 __be32 *hashp) 144 { 145 struct xfs_da_state_blk *blks; 146 struct xfs_da_node_entry *entry; 147 xfs_dahash_t hash; 148 xfs_dahash_t parent_hash; 149 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; 155 156 if (level == 0) 157 return 0; 158 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); 165 166 return 0; 167 } 168 169 /* 170 * Check a da btree pointer. Returns true if it's ok to use this 171 * pointer. 172 */ 173 STATIC bool 174 xfs_scrub_da_btree_ptr_ok( 175 struct xfs_scrub_da_btree *ds, 176 int level, 177 xfs_dablk_t blkno) 178 { 179 if (blkno < ds->lowest || (ds->highest != 0 && blkno >= ds->highest)) { 180 xfs_scrub_da_set_corrupt(ds, level); 181 return false; 182 } 183 184 return true; 185 } 186 187 /* 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. 191 */ 192 static void 193 xfs_scrub_da_btree_read_verify( 194 struct xfs_buf *bp) 195 { 196 struct xfs_da_blkinfo *info = bp->b_addr; 197 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); 203 return; 204 default: 205 /* 206 * xfs_da3_node_buf_ops already know how to handle 207 * DA*_NODE, ATTR*_LEAF, and DIR*_LEAFN blocks. 208 */ 209 bp->b_ops = &xfs_da3_node_buf_ops; 210 bp->b_ops->verify_read(bp); 211 return; 212 } 213 } 214 static void 215 xfs_scrub_da_btree_write_verify( 216 struct xfs_buf *bp) 217 { 218 struct xfs_da_blkinfo *info = bp->b_addr; 219 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); 225 return; 226 default: 227 /* 228 * xfs_da3_node_buf_ops already know how to handle 229 * DA*_NODE, ATTR*_LEAF, and DIR*_LEAFN blocks. 230 */ 231 bp->b_ops = &xfs_da3_node_buf_ops; 232 bp->b_ops->verify_write(bp); 233 return; 234 } 235 } 236 static void * 237 xfs_scrub_da_btree_verify( 238 struct xfs_buf *bp) 239 { 240 struct xfs_da_blkinfo *info = bp->b_addr; 241 242 switch (be16_to_cpu(info->magic)) { 243 case XFS_DIR2_LEAF1_MAGIC: 244 case XFS_DIR3_LEAF1_MAGIC: 245 bp->b_ops = &xfs_dir3_leaf1_buf_ops; 246 return bp->b_ops->verify_struct(bp); 247 default: 248 bp->b_ops = &xfs_da3_node_buf_ops; 249 return bp->b_ops->verify_struct(bp); 250 } 251 } 252 253 static const struct xfs_buf_ops xfs_scrub_da_btree_buf_ops = { 254 .name = "xfs_scrub_da_btree", 255 .verify_read = xfs_scrub_da_btree_read_verify, 256 .verify_write = xfs_scrub_da_btree_write_verify, 257 .verify_struct = xfs_scrub_da_btree_verify, 258 }; 259 260 /* Check a block's sibling. */ 261 STATIC int 262 xfs_scrub_da_btree_block_check_sibling( 263 struct xfs_scrub_da_btree *ds, 264 int level, 265 int direction, 266 xfs_dablk_t sibling) 267 { 268 int retval; 269 int error; 270 271 memcpy(&ds->state->altpath, &ds->state->path, 272 sizeof(ds->state->altpath)); 273 274 /* 275 * If the pointer is null, we shouldn't be able to move the upper 276 * level pointer anywhere. 277 */ 278 if (sibling == 0) { 279 error = xfs_da3_path_shift(ds->state, &ds->state->altpath, 280 direction, false, &retval); 281 if (error == 0 && retval == 0) 282 xfs_scrub_da_set_corrupt(ds, level); 283 error = 0; 284 goto out; 285 } 286 287 /* Move the alternate cursor one block in the direction given. */ 288 error = xfs_da3_path_shift(ds->state, &ds->state->altpath, 289 direction, false, &retval); 290 if (!xfs_scrub_da_process_error(ds, level, &error)) 291 return error; 292 if (retval) { 293 xfs_scrub_da_set_corrupt(ds, level); 294 return error; 295 } 296 if (ds->state->altpath.blk[level].bp) 297 xfs_scrub_buffer_recheck(ds->sc, 298 ds->state->altpath.blk[level].bp); 299 300 /* Compare upper level pointer to sibling pointer. */ 301 if (ds->state->altpath.blk[level].blkno != sibling) 302 xfs_scrub_da_set_corrupt(ds, level); 303 xfs_trans_brelse(ds->dargs.trans, ds->state->altpath.blk[level].bp); 304 out: 305 return error; 306 } 307 308 /* Check a block's sibling pointers. */ 309 STATIC int 310 xfs_scrub_da_btree_block_check_siblings( 311 struct xfs_scrub_da_btree *ds, 312 int level, 313 struct xfs_da_blkinfo *hdr) 314 { 315 xfs_dablk_t forw; 316 xfs_dablk_t back; 317 int error = 0; 318 319 forw = be32_to_cpu(hdr->forw); 320 back = be32_to_cpu(hdr->back); 321 322 /* Top level blocks should not have sibling pointers. */ 323 if (level == 0) { 324 if (forw != 0 || back != 0) 325 xfs_scrub_da_set_corrupt(ds, level); 326 return 0; 327 } 328 329 /* 330 * Check back (left) and forw (right) pointers. These functions 331 * absorb error codes for us. 332 */ 333 error = xfs_scrub_da_btree_block_check_sibling(ds, level, 0, back); 334 if (error) 335 goto out; 336 error = xfs_scrub_da_btree_block_check_sibling(ds, level, 1, forw); 337 338 out: 339 memset(&ds->state->altpath, 0, sizeof(ds->state->altpath)); 340 return error; 341 } 342 343 /* Load a dir/attribute block from a btree. */ 344 STATIC int 345 xfs_scrub_da_btree_block( 346 struct xfs_scrub_da_btree *ds, 347 int level, 348 xfs_dablk_t blkno) 349 { 350 struct xfs_da_state_blk *blk; 351 struct xfs_da_intnode *node; 352 struct xfs_da_node_entry *btree; 353 struct xfs_da3_blkinfo *hdr3; 354 struct xfs_da_args *dargs = &ds->dargs; 355 struct xfs_inode *ip = ds->dargs.dp; 356 xfs_ino_t owner; 357 int *pmaxrecs; 358 struct xfs_da3_icnode_hdr nodehdr; 359 int error = 0; 360 361 blk = &ds->state->path.blk[level]; 362 ds->state->path.active = level + 1; 363 364 /* Release old block. */ 365 if (blk->bp) { 366 xfs_trans_brelse(dargs->trans, blk->bp); 367 blk->bp = NULL; 368 } 369 370 /* Check the pointer. */ 371 blk->blkno = blkno; 372 if (!xfs_scrub_da_btree_ptr_ok(ds, level, blkno)) 373 goto out_nobuf; 374 375 /* Read the buffer. */ 376 error = xfs_da_read_buf(dargs->trans, dargs->dp, blk->blkno, -2, 377 &blk->bp, dargs->whichfork, 378 &xfs_scrub_da_btree_buf_ops); 379 if (!xfs_scrub_da_process_error(ds, level, &error)) 380 goto out_nobuf; 381 if (blk->bp) 382 xfs_scrub_buffer_recheck(ds->sc, blk->bp); 383 384 /* 385 * We didn't find a dir btree root block, which means that 386 * there's no LEAF1/LEAFN tree (at least not where it's supposed 387 * to be), so jump out now. 388 */ 389 if (ds->dargs.whichfork == XFS_DATA_FORK && level == 0 && 390 blk->bp == NULL) 391 goto out_nobuf; 392 393 /* It's /not/ ok for attr trees not to have a da btree. */ 394 if (blk->bp == NULL) { 395 xfs_scrub_da_set_corrupt(ds, level); 396 goto out_nobuf; 397 } 398 399 hdr3 = blk->bp->b_addr; 400 blk->magic = be16_to_cpu(hdr3->hdr.magic); 401 pmaxrecs = &ds->maxrecs[level]; 402 403 /* We only started zeroing the header on v5 filesystems. */ 404 if (xfs_sb_version_hascrc(&ds->sc->mp->m_sb) && hdr3->hdr.pad) 405 xfs_scrub_da_set_corrupt(ds, level); 406 407 /* Check the owner. */ 408 if (xfs_sb_version_hascrc(&ip->i_mount->m_sb)) { 409 owner = be64_to_cpu(hdr3->owner); 410 if (owner != ip->i_ino) 411 xfs_scrub_da_set_corrupt(ds, level); 412 } 413 414 /* Check the siblings. */ 415 error = xfs_scrub_da_btree_block_check_siblings(ds, level, &hdr3->hdr); 416 if (error) 417 goto out; 418 419 /* Interpret the buffer. */ 420 switch (blk->magic) { 421 case XFS_ATTR_LEAF_MAGIC: 422 case XFS_ATTR3_LEAF_MAGIC: 423 xfs_trans_buf_set_type(dargs->trans, blk->bp, 424 XFS_BLFT_ATTR_LEAF_BUF); 425 blk->magic = XFS_ATTR_LEAF_MAGIC; 426 blk->hashval = xfs_attr_leaf_lasthash(blk->bp, pmaxrecs); 427 if (ds->tree_level != 0) 428 xfs_scrub_da_set_corrupt(ds, level); 429 break; 430 case XFS_DIR2_LEAFN_MAGIC: 431 case XFS_DIR3_LEAFN_MAGIC: 432 xfs_trans_buf_set_type(dargs->trans, blk->bp, 433 XFS_BLFT_DIR_LEAFN_BUF); 434 blk->magic = XFS_DIR2_LEAFN_MAGIC; 435 blk->hashval = xfs_dir2_leaf_lasthash(ip, blk->bp, pmaxrecs); 436 if (ds->tree_level != 0) 437 xfs_scrub_da_set_corrupt(ds, level); 438 break; 439 case XFS_DIR2_LEAF1_MAGIC: 440 case XFS_DIR3_LEAF1_MAGIC: 441 xfs_trans_buf_set_type(dargs->trans, blk->bp, 442 XFS_BLFT_DIR_LEAF1_BUF); 443 blk->magic = XFS_DIR2_LEAF1_MAGIC; 444 blk->hashval = xfs_dir2_leaf_lasthash(ip, blk->bp, pmaxrecs); 445 if (ds->tree_level != 0) 446 xfs_scrub_da_set_corrupt(ds, level); 447 break; 448 case XFS_DA_NODE_MAGIC: 449 case XFS_DA3_NODE_MAGIC: 450 xfs_trans_buf_set_type(dargs->trans, blk->bp, 451 XFS_BLFT_DA_NODE_BUF); 452 blk->magic = XFS_DA_NODE_MAGIC; 453 node = blk->bp->b_addr; 454 ip->d_ops->node_hdr_from_disk(&nodehdr, node); 455 btree = ip->d_ops->node_tree_p(node); 456 *pmaxrecs = nodehdr.count; 457 blk->hashval = be32_to_cpu(btree[*pmaxrecs - 1].hashval); 458 if (level == 0) { 459 if (nodehdr.level >= XFS_DA_NODE_MAXDEPTH) { 460 xfs_scrub_da_set_corrupt(ds, level); 461 goto out_freebp; 462 } 463 ds->tree_level = nodehdr.level; 464 } else { 465 if (ds->tree_level != nodehdr.level) { 466 xfs_scrub_da_set_corrupt(ds, level); 467 goto out_freebp; 468 } 469 } 470 471 /* XXX: Check hdr3.pad32 once we know how to fix it. */ 472 break; 473 default: 474 xfs_scrub_da_set_corrupt(ds, level); 475 goto out_freebp; 476 } 477 478 out: 479 return error; 480 out_freebp: 481 xfs_trans_brelse(dargs->trans, blk->bp); 482 blk->bp = NULL; 483 out_nobuf: 484 blk->blkno = 0; 485 return error; 486 } 487 488 /* Visit all nodes and leaves of a da btree. */ 489 int 490 xfs_scrub_da_btree( 491 struct xfs_scrub_context *sc, 492 int whichfork, 493 xfs_scrub_da_btree_rec_fn scrub_fn, 494 void *private) 495 { 496 struct xfs_scrub_da_btree ds = {}; 497 struct xfs_mount *mp = sc->mp; 498 struct xfs_da_state_blk *blks; 499 struct xfs_da_node_entry *key; 500 void *rec; 501 xfs_dablk_t blkno; 502 int level; 503 int error; 504 505 /* Skip short format data structures; no btree to scan. */ 506 if (XFS_IFORK_FORMAT(sc->ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 507 XFS_IFORK_FORMAT(sc->ip, whichfork) != XFS_DINODE_FMT_BTREE) 508 return 0; 509 510 /* Set up initial da state. */ 511 ds.dargs.dp = sc->ip; 512 ds.dargs.whichfork = whichfork; 513 ds.dargs.trans = sc->tp; 514 ds.dargs.op_flags = XFS_DA_OP_OKNOENT; 515 ds.state = xfs_da_state_alloc(); 516 ds.state->args = &ds.dargs; 517 ds.state->mp = mp; 518 ds.sc = sc; 519 ds.private = private; 520 if (whichfork == XFS_ATTR_FORK) { 521 ds.dargs.geo = mp->m_attr_geo; 522 ds.lowest = 0; 523 ds.highest = 0; 524 } else { 525 ds.dargs.geo = mp->m_dir_geo; 526 ds.lowest = ds.dargs.geo->leafblk; 527 ds.highest = ds.dargs.geo->freeblk; 528 } 529 blkno = ds.lowest; 530 level = 0; 531 532 /* Find the root of the da tree, if present. */ 533 blks = ds.state->path.blk; 534 error = xfs_scrub_da_btree_block(&ds, level, blkno); 535 if (error) 536 goto out_state; 537 /* 538 * We didn't find a block at ds.lowest, which means that there's 539 * no LEAF1/LEAFN tree (at least not where it's supposed to be), 540 * so jump out now. 541 */ 542 if (blks[level].bp == NULL) 543 goto out_state; 544 545 blks[level].index = 0; 546 while (level >= 0 && level < XFS_DA_NODE_MAXDEPTH) { 547 /* Handle leaf block. */ 548 if (blks[level].magic != XFS_DA_NODE_MAGIC) { 549 /* End of leaf, pop back towards the root. */ 550 if (blks[level].index >= ds.maxrecs[level]) { 551 if (level > 0) 552 blks[level - 1].index++; 553 ds.tree_level++; 554 level--; 555 continue; 556 } 557 558 /* Dispatch record scrubbing. */ 559 rec = xfs_scrub_da_btree_entry(&ds, level, 560 blks[level].index); 561 error = scrub_fn(&ds, level, rec); 562 if (error) 563 break; 564 if (xfs_scrub_should_terminate(sc, &error) || 565 (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)) 566 break; 567 568 blks[level].index++; 569 continue; 570 } 571 572 573 /* End of node, pop back towards the root. */ 574 if (blks[level].index >= ds.maxrecs[level]) { 575 if (level > 0) 576 blks[level - 1].index++; 577 ds.tree_level++; 578 level--; 579 continue; 580 } 581 582 /* Hashes in order for scrub? */ 583 key = xfs_scrub_da_btree_entry(&ds, level, blks[level].index); 584 error = xfs_scrub_da_btree_hash(&ds, level, &key->hashval); 585 if (error) 586 goto out; 587 588 /* Drill another level deeper. */ 589 blkno = be32_to_cpu(key->before); 590 level++; 591 ds.tree_level--; 592 error = xfs_scrub_da_btree_block(&ds, level, blkno); 593 if (error) 594 goto out; 595 if (blks[level].bp == NULL) 596 goto out; 597 598 blks[level].index = 0; 599 } 600 601 out: 602 /* Release all the buffers we're tracking. */ 603 for (level = 0; level < XFS_DA_NODE_MAXDEPTH; level++) { 604 if (blks[level].bp == NULL) 605 continue; 606 xfs_trans_brelse(sc->tp, blks[level].bp); 607 blks[level].bp = NULL; 608 } 609 610 out_state: 611 xfs_da_state_free(ds.state); 612 return error; 613 } 614