1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright (C) Qu Wenruo 2017. All rights reserved. 4 */ 5 6/* 7 * The module is used to catch unexpected/corrupted tree block data. 8 * Such behavior can be caused either by a fuzzed image or bugs. 9 * 10 * The objective is to do leaf/node validation checks when tree block is read 11 * from disk, and check *every* possible member, so other code won't 12 * need to checking them again. 13 * 14 * Due to the potential and unwanted damage, every checker needs to be 15 * carefully reviewed otherwise so it does not prevent mount of valid images. 16 */ 17 18#include <linux/types.h> 19#include <linux/stddef.h> 20#include <linux/error-injection.h> 21#include "ctree.h" 22#include "tree-checker.h" 23#include "disk-io.h" 24#include "compression.h" 25#include "volumes.h" 26#include "misc.h" 27 28/* 29 * Error message should follow the following format: 30 * corrupt <type>: <identifier>, <reason>[, <bad_value>] 31 * 32 * @type: leaf or node 33 * @identifier: the necessary info to locate the leaf/node. 34 * It's recommended to decode key.objecitd/offset if it's 35 * meaningful. 36 * @reason: describe the error 37 * @bad_value: optional, it's recommended to output bad value and its 38 * expected value (range). 39 * 40 * Since comma is used to separate the components, only space is allowed 41 * inside each component. 42 */ 43 44/* 45 * Append generic "corrupt leaf/node root=%llu block=%llu slot=%d: " to @fmt. 46 * Allows callers to customize the output. 47 */ 48__printf(3, 4) 49__cold 50static void generic_err(const struct extent_buffer *eb, int slot, 51 const char *fmt, ...) 52{ 53 const struct btrfs_fs_info *fs_info = eb->fs_info; 54 struct va_format vaf; 55 va_list args; 56 57 va_start(args, fmt); 58 59 vaf.fmt = fmt; 60 vaf.va = &args; 61 62 btrfs_crit(fs_info, 63 "corrupt %s: root=%llu block=%llu slot=%d, %pV", 64 btrfs_header_level(eb) == 0 ? "leaf" : "node", 65 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, &vaf); 66 va_end(args); 67} 68 69/* 70 * Customized reporter for extent data item, since its key objectid and 71 * offset has its own meaning. 72 */ 73__printf(3, 4) 74__cold 75static void file_extent_err(const struct extent_buffer *eb, int slot, 76 const char *fmt, ...) 77{ 78 const struct btrfs_fs_info *fs_info = eb->fs_info; 79 struct btrfs_key key; 80 struct va_format vaf; 81 va_list args; 82 83 btrfs_item_key_to_cpu(eb, &key, slot); 84 va_start(args, fmt); 85 86 vaf.fmt = fmt; 87 vaf.va = &args; 88 89 btrfs_crit(fs_info, 90 "corrupt %s: root=%llu block=%llu slot=%d ino=%llu file_offset=%llu, %pV", 91 btrfs_header_level(eb) == 0 ? "leaf" : "node", 92 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, 93 key.objectid, key.offset, &vaf); 94 va_end(args); 95} 96 97/* 98 * Return 0 if the btrfs_file_extent_##name is aligned to @alignment 99 * Else return 1 100 */ 101#define CHECK_FE_ALIGNED(leaf, slot, fi, name, alignment) \ 102({ \ 103 if (!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), (alignment))) \ 104 file_extent_err((leaf), (slot), \ 105 "invalid %s for file extent, have %llu, should be aligned to %u", \ 106 (#name), btrfs_file_extent_##name((leaf), (fi)), \ 107 (alignment)); \ 108 (!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), (alignment))); \ 109}) 110 111static u64 file_extent_end(struct extent_buffer *leaf, 112 struct btrfs_key *key, 113 struct btrfs_file_extent_item *extent) 114{ 115 u64 end; 116 u64 len; 117 118 if (btrfs_file_extent_type(leaf, extent) == BTRFS_FILE_EXTENT_INLINE) { 119 len = btrfs_file_extent_ram_bytes(leaf, extent); 120 end = ALIGN(key->offset + len, leaf->fs_info->sectorsize); 121 } else { 122 len = btrfs_file_extent_num_bytes(leaf, extent); 123 end = key->offset + len; 124 } 125 return end; 126} 127 128/* 129 * Customized report for dir_item, the only new important information is 130 * key->objectid, which represents inode number 131 */ 132__printf(3, 4) 133__cold 134static void dir_item_err(const struct extent_buffer *eb, int slot, 135 const char *fmt, ...) 136{ 137 const struct btrfs_fs_info *fs_info = eb->fs_info; 138 struct btrfs_key key; 139 struct va_format vaf; 140 va_list args; 141 142 btrfs_item_key_to_cpu(eb, &key, slot); 143 va_start(args, fmt); 144 145 vaf.fmt = fmt; 146 vaf.va = &args; 147 148 btrfs_crit(fs_info, 149 "corrupt %s: root=%llu block=%llu slot=%d ino=%llu, %pV", 150 btrfs_header_level(eb) == 0 ? "leaf" : "node", 151 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, 152 key.objectid, &vaf); 153 va_end(args); 154} 155 156/* 157 * This functions checks prev_key->objectid, to ensure current key and prev_key 158 * share the same objectid as inode number. 159 * 160 * This is to detect missing INODE_ITEM in subvolume trees. 161 * 162 * Return true if everything is OK or we don't need to check. 163 * Return false if anything is wrong. 164 */ 165static bool check_prev_ino(struct extent_buffer *leaf, 166 struct btrfs_key *key, int slot, 167 struct btrfs_key *prev_key) 168{ 169 /* No prev key, skip check */ 170 if (slot == 0) 171 return true; 172 173 /* Only these key->types needs to be checked */ 174 ASSERT(key->type == BTRFS_XATTR_ITEM_KEY || 175 key->type == BTRFS_INODE_REF_KEY || 176 key->type == BTRFS_DIR_INDEX_KEY || 177 key->type == BTRFS_DIR_ITEM_KEY || 178 key->type == BTRFS_EXTENT_DATA_KEY); 179 180 /* 181 * Only subvolume trees along with their reloc trees need this check. 182 * Things like log tree doesn't follow this ino requirement. 183 */ 184 if (!is_fstree(btrfs_header_owner(leaf))) 185 return true; 186 187 if (key->objectid == prev_key->objectid) 188 return true; 189 190 /* Error found */ 191 dir_item_err(leaf, slot, 192 "invalid previous key objectid, have %llu expect %llu", 193 prev_key->objectid, key->objectid); 194 return false; 195} 196static int check_extent_data_item(struct extent_buffer *leaf, 197 struct btrfs_key *key, int slot, 198 struct btrfs_key *prev_key) 199{ 200 struct btrfs_fs_info *fs_info = leaf->fs_info; 201 struct btrfs_file_extent_item *fi; 202 u32 sectorsize = fs_info->sectorsize; 203 u32 item_size = btrfs_item_size_nr(leaf, slot); 204 u64 extent_end; 205 206 if (!IS_ALIGNED(key->offset, sectorsize)) { 207 file_extent_err(leaf, slot, 208"unaligned file_offset for file extent, have %llu should be aligned to %u", 209 key->offset, sectorsize); 210 return -EUCLEAN; 211 } 212 213 /* 214 * Previous key must have the same key->objectid (ino). 215 * It can be XATTR_ITEM, INODE_ITEM or just another EXTENT_DATA. 216 * But if objectids mismatch, it means we have a missing 217 * INODE_ITEM. 218 */ 219 if (!check_prev_ino(leaf, key, slot, prev_key)) 220 return -EUCLEAN; 221 222 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); 223 224 /* 225 * Make sure the item contains at least inline header, so the file 226 * extent type is not some garbage. 227 */ 228 if (item_size < BTRFS_FILE_EXTENT_INLINE_DATA_START) { 229 file_extent_err(leaf, slot, 230 "invalid item size, have %u expect [%zu, %u)", 231 item_size, BTRFS_FILE_EXTENT_INLINE_DATA_START, 232 SZ_4K); 233 return -EUCLEAN; 234 } 235 if (btrfs_file_extent_type(leaf, fi) >= BTRFS_NR_FILE_EXTENT_TYPES) { 236 file_extent_err(leaf, slot, 237 "invalid type for file extent, have %u expect range [0, %u]", 238 btrfs_file_extent_type(leaf, fi), 239 BTRFS_NR_FILE_EXTENT_TYPES - 1); 240 return -EUCLEAN; 241 } 242 243 /* 244 * Support for new compression/encryption must introduce incompat flag, 245 * and must be caught in open_ctree(). 246 */ 247 if (btrfs_file_extent_compression(leaf, fi) >= BTRFS_NR_COMPRESS_TYPES) { 248 file_extent_err(leaf, slot, 249 "invalid compression for file extent, have %u expect range [0, %u]", 250 btrfs_file_extent_compression(leaf, fi), 251 BTRFS_NR_COMPRESS_TYPES - 1); 252 return -EUCLEAN; 253 } 254 if (btrfs_file_extent_encryption(leaf, fi)) { 255 file_extent_err(leaf, slot, 256 "invalid encryption for file extent, have %u expect 0", 257 btrfs_file_extent_encryption(leaf, fi)); 258 return -EUCLEAN; 259 } 260 if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) { 261 /* Inline extent must have 0 as key offset */ 262 if (key->offset) { 263 file_extent_err(leaf, slot, 264 "invalid file_offset for inline file extent, have %llu expect 0", 265 key->offset); 266 return -EUCLEAN; 267 } 268 269 /* Compressed inline extent has no on-disk size, skip it */ 270 if (btrfs_file_extent_compression(leaf, fi) != 271 BTRFS_COMPRESS_NONE) 272 return 0; 273 274 /* Uncompressed inline extent size must match item size */ 275 if (item_size != BTRFS_FILE_EXTENT_INLINE_DATA_START + 276 btrfs_file_extent_ram_bytes(leaf, fi)) { 277 file_extent_err(leaf, slot, 278 "invalid ram_bytes for uncompressed inline extent, have %u expect %llu", 279 item_size, BTRFS_FILE_EXTENT_INLINE_DATA_START + 280 btrfs_file_extent_ram_bytes(leaf, fi)); 281 return -EUCLEAN; 282 } 283 return 0; 284 } 285 286 /* Regular or preallocated extent has fixed item size */ 287 if (item_size != sizeof(*fi)) { 288 file_extent_err(leaf, slot, 289 "invalid item size for reg/prealloc file extent, have %u expect %zu", 290 item_size, sizeof(*fi)); 291 return -EUCLEAN; 292 } 293 if (CHECK_FE_ALIGNED(leaf, slot, fi, ram_bytes, sectorsize) || 294 CHECK_FE_ALIGNED(leaf, slot, fi, disk_bytenr, sectorsize) || 295 CHECK_FE_ALIGNED(leaf, slot, fi, disk_num_bytes, sectorsize) || 296 CHECK_FE_ALIGNED(leaf, slot, fi, offset, sectorsize) || 297 CHECK_FE_ALIGNED(leaf, slot, fi, num_bytes, sectorsize)) 298 return -EUCLEAN; 299 300 /* Catch extent end overflow */ 301 if (check_add_overflow(btrfs_file_extent_num_bytes(leaf, fi), 302 key->offset, &extent_end)) { 303 file_extent_err(leaf, slot, 304 "extent end overflow, have file offset %llu extent num bytes %llu", 305 key->offset, 306 btrfs_file_extent_num_bytes(leaf, fi)); 307 return -EUCLEAN; 308 } 309 310 /* 311 * Check that no two consecutive file extent items, in the same leaf, 312 * present ranges that overlap each other. 313 */ 314 if (slot > 0 && 315 prev_key->objectid == key->objectid && 316 prev_key->type == BTRFS_EXTENT_DATA_KEY) { 317 struct btrfs_file_extent_item *prev_fi; 318 u64 prev_end; 319 320 prev_fi = btrfs_item_ptr(leaf, slot - 1, 321 struct btrfs_file_extent_item); 322 prev_end = file_extent_end(leaf, prev_key, prev_fi); 323 if (prev_end > key->offset) { 324 file_extent_err(leaf, slot - 1, 325"file extent end range (%llu) goes beyond start offset (%llu) of the next file extent", 326 prev_end, key->offset); 327 return -EUCLEAN; 328 } 329 } 330 331 return 0; 332} 333 334static int check_csum_item(struct extent_buffer *leaf, struct btrfs_key *key, 335 int slot, struct btrfs_key *prev_key) 336{ 337 struct btrfs_fs_info *fs_info = leaf->fs_info; 338 u32 sectorsize = fs_info->sectorsize; 339 u32 csumsize = btrfs_super_csum_size(fs_info->super_copy); 340 341 if (key->objectid != BTRFS_EXTENT_CSUM_OBJECTID) { 342 generic_err(leaf, slot, 343 "invalid key objectid for csum item, have %llu expect %llu", 344 key->objectid, BTRFS_EXTENT_CSUM_OBJECTID); 345 return -EUCLEAN; 346 } 347 if (!IS_ALIGNED(key->offset, sectorsize)) { 348 generic_err(leaf, slot, 349 "unaligned key offset for csum item, have %llu should be aligned to %u", 350 key->offset, sectorsize); 351 return -EUCLEAN; 352 } 353 if (!IS_ALIGNED(btrfs_item_size_nr(leaf, slot), csumsize)) { 354 generic_err(leaf, slot, 355 "unaligned item size for csum item, have %u should be aligned to %u", 356 btrfs_item_size_nr(leaf, slot), csumsize); 357 return -EUCLEAN; 358 } 359 if (slot > 0 && prev_key->type == BTRFS_EXTENT_CSUM_KEY) { 360 u64 prev_csum_end; 361 u32 prev_item_size; 362 363 prev_item_size = btrfs_item_size_nr(leaf, slot - 1); 364 prev_csum_end = (prev_item_size / csumsize) * sectorsize; 365 prev_csum_end += prev_key->offset; 366 if (prev_csum_end > key->offset) { 367 generic_err(leaf, slot - 1, 368"csum end range (%llu) goes beyond the start range (%llu) of the next csum item", 369 prev_csum_end, key->offset); 370 return -EUCLEAN; 371 } 372 } 373 return 0; 374} 375 376/* Inode item error output has the same format as dir_item_err() */ 377#define inode_item_err(eb, slot, fmt, ...) \ 378 dir_item_err(eb, slot, fmt, __VA_ARGS__) 379 380static int check_inode_key(struct extent_buffer *leaf, struct btrfs_key *key, 381 int slot) 382{ 383 struct btrfs_key item_key; 384 bool is_inode_item; 385 386 btrfs_item_key_to_cpu(leaf, &item_key, slot); 387 is_inode_item = (item_key.type == BTRFS_INODE_ITEM_KEY); 388 389 /* For XATTR_ITEM, location key should be all 0 */ 390 if (item_key.type == BTRFS_XATTR_ITEM_KEY) { 391 if (key->type != 0 || key->objectid != 0 || key->offset != 0) 392 return -EUCLEAN; 393 return 0; 394 } 395 396 if ((key->objectid < BTRFS_FIRST_FREE_OBJECTID || 397 key->objectid > BTRFS_LAST_FREE_OBJECTID) && 398 key->objectid != BTRFS_ROOT_TREE_DIR_OBJECTID && 399 key->objectid != BTRFS_FREE_INO_OBJECTID) { 400 if (is_inode_item) { 401 generic_err(leaf, slot, 402 "invalid key objectid: has %llu expect %llu or [%llu, %llu] or %llu", 403 key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID, 404 BTRFS_FIRST_FREE_OBJECTID, 405 BTRFS_LAST_FREE_OBJECTID, 406 BTRFS_FREE_INO_OBJECTID); 407 } else { 408 dir_item_err(leaf, slot, 409"invalid location key objectid: has %llu expect %llu or [%llu, %llu] or %llu", 410 key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID, 411 BTRFS_FIRST_FREE_OBJECTID, 412 BTRFS_LAST_FREE_OBJECTID, 413 BTRFS_FREE_INO_OBJECTID); 414 } 415 return -EUCLEAN; 416 } 417 if (key->offset != 0) { 418 if (is_inode_item) 419 inode_item_err(leaf, slot, 420 "invalid key offset: has %llu expect 0", 421 key->offset); 422 else 423 dir_item_err(leaf, slot, 424 "invalid location key offset:has %llu expect 0", 425 key->offset); 426 return -EUCLEAN; 427 } 428 return 0; 429} 430 431static int check_root_key(struct extent_buffer *leaf, struct btrfs_key *key, 432 int slot) 433{ 434 struct btrfs_key item_key; 435 bool is_root_item; 436 437 btrfs_item_key_to_cpu(leaf, &item_key, slot); 438 is_root_item = (item_key.type == BTRFS_ROOT_ITEM_KEY); 439 440 /* No such tree id */ 441 if (key->objectid == 0) { 442 if (is_root_item) 443 generic_err(leaf, slot, "invalid root id 0"); 444 else 445 dir_item_err(leaf, slot, 446 "invalid location key root id 0"); 447 return -EUCLEAN; 448 } 449 450 /* DIR_ITEM/INDEX/INODE_REF is not allowed to point to non-fs trees */ 451 if (!is_fstree(key->objectid) && !is_root_item) { 452 dir_item_err(leaf, slot, 453 "invalid location key objectid, have %llu expect [%llu, %llu]", 454 key->objectid, BTRFS_FIRST_FREE_OBJECTID, 455 BTRFS_LAST_FREE_OBJECTID); 456 return -EUCLEAN; 457 } 458 459 /* 460 * ROOT_ITEM with non-zero offset means this is a snapshot, created at 461 * @offset transid. 462 * Furthermore, for location key in DIR_ITEM, its offset is always -1. 463 * 464 * So here we only check offset for reloc tree whose key->offset must 465 * be a valid tree. 466 */ 467 if (key->objectid == BTRFS_TREE_RELOC_OBJECTID && key->offset == 0) { 468 generic_err(leaf, slot, "invalid root id 0 for reloc tree"); 469 return -EUCLEAN; 470 } 471 return 0; 472} 473 474static int check_dir_item(struct extent_buffer *leaf, 475 struct btrfs_key *key, struct btrfs_key *prev_key, 476 int slot) 477{ 478 struct btrfs_fs_info *fs_info = leaf->fs_info; 479 struct btrfs_dir_item *di; 480 u32 item_size = btrfs_item_size_nr(leaf, slot); 481 u32 cur = 0; 482 483 if (!check_prev_ino(leaf, key, slot, prev_key)) 484 return -EUCLEAN; 485 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item); 486 while (cur < item_size) { 487 struct btrfs_key location_key; 488 u32 name_len; 489 u32 data_len; 490 u32 max_name_len; 491 u32 total_size; 492 u32 name_hash; 493 u8 dir_type; 494 int ret; 495 496 /* header itself should not cross item boundary */ 497 if (cur + sizeof(*di) > item_size) { 498 dir_item_err(leaf, slot, 499 "dir item header crosses item boundary, have %zu boundary %u", 500 cur + sizeof(*di), item_size); 501 return -EUCLEAN; 502 } 503 504 /* Location key check */ 505 btrfs_dir_item_key_to_cpu(leaf, di, &location_key); 506 if (location_key.type == BTRFS_ROOT_ITEM_KEY) { 507 ret = check_root_key(leaf, &location_key, slot); 508 if (ret < 0) 509 return ret; 510 } else if (location_key.type == BTRFS_INODE_ITEM_KEY || 511 location_key.type == 0) { 512 ret = check_inode_key(leaf, &location_key, slot); 513 if (ret < 0) 514 return ret; 515 } else { 516 dir_item_err(leaf, slot, 517 "invalid location key type, have %u, expect %u or %u", 518 location_key.type, BTRFS_ROOT_ITEM_KEY, 519 BTRFS_INODE_ITEM_KEY); 520 return -EUCLEAN; 521 } 522 523 /* dir type check */ 524 dir_type = btrfs_dir_type(leaf, di); 525 if (dir_type >= BTRFS_FT_MAX) { 526 dir_item_err(leaf, slot, 527 "invalid dir item type, have %u expect [0, %u)", 528 dir_type, BTRFS_FT_MAX); 529 return -EUCLEAN; 530 } 531 532 if (key->type == BTRFS_XATTR_ITEM_KEY && 533 dir_type != BTRFS_FT_XATTR) { 534 dir_item_err(leaf, slot, 535 "invalid dir item type for XATTR key, have %u expect %u", 536 dir_type, BTRFS_FT_XATTR); 537 return -EUCLEAN; 538 } 539 if (dir_type == BTRFS_FT_XATTR && 540 key->type != BTRFS_XATTR_ITEM_KEY) { 541 dir_item_err(leaf, slot, 542 "xattr dir type found for non-XATTR key"); 543 return -EUCLEAN; 544 } 545 if (dir_type == BTRFS_FT_XATTR) 546 max_name_len = XATTR_NAME_MAX; 547 else 548 max_name_len = BTRFS_NAME_LEN; 549 550 /* Name/data length check */ 551 name_len = btrfs_dir_name_len(leaf, di); 552 data_len = btrfs_dir_data_len(leaf, di); 553 if (name_len > max_name_len) { 554 dir_item_err(leaf, slot, 555 "dir item name len too long, have %u max %u", 556 name_len, max_name_len); 557 return -EUCLEAN; 558 } 559 if (name_len + data_len > BTRFS_MAX_XATTR_SIZE(fs_info)) { 560 dir_item_err(leaf, slot, 561 "dir item name and data len too long, have %u max %u", 562 name_len + data_len, 563 BTRFS_MAX_XATTR_SIZE(fs_info)); 564 return -EUCLEAN; 565 } 566 567 if (data_len && dir_type != BTRFS_FT_XATTR) { 568 dir_item_err(leaf, slot, 569 "dir item with invalid data len, have %u expect 0", 570 data_len); 571 return -EUCLEAN; 572 } 573 574 total_size = sizeof(*di) + name_len + data_len; 575 576 /* header and name/data should not cross item boundary */ 577 if (cur + total_size > item_size) { 578 dir_item_err(leaf, slot, 579 "dir item data crosses item boundary, have %u boundary %u", 580 cur + total_size, item_size); 581 return -EUCLEAN; 582 } 583 584 /* 585 * Special check for XATTR/DIR_ITEM, as key->offset is name 586 * hash, should match its name 587 */ 588 if (key->type == BTRFS_DIR_ITEM_KEY || 589 key->type == BTRFS_XATTR_ITEM_KEY) { 590 char namebuf[max(BTRFS_NAME_LEN, XATTR_NAME_MAX)]; 591 592 read_extent_buffer(leaf, namebuf, 593 (unsigned long)(di + 1), name_len); 594 name_hash = btrfs_name_hash(namebuf, name_len); 595 if (key->offset != name_hash) { 596 dir_item_err(leaf, slot, 597 "name hash mismatch with key, have 0x%016x expect 0x%016llx", 598 name_hash, key->offset); 599 return -EUCLEAN; 600 } 601 } 602 cur += total_size; 603 di = (struct btrfs_dir_item *)((void *)di + total_size); 604 } 605 return 0; 606} 607 608__printf(3, 4) 609__cold 610static void block_group_err(const struct extent_buffer *eb, int slot, 611 const char *fmt, ...) 612{ 613 const struct btrfs_fs_info *fs_info = eb->fs_info; 614 struct btrfs_key key; 615 struct va_format vaf; 616 va_list args; 617 618 btrfs_item_key_to_cpu(eb, &key, slot); 619 va_start(args, fmt); 620 621 vaf.fmt = fmt; 622 vaf.va = &args; 623 624 btrfs_crit(fs_info, 625 "corrupt %s: root=%llu block=%llu slot=%d bg_start=%llu bg_len=%llu, %pV", 626 btrfs_header_level(eb) == 0 ? "leaf" : "node", 627 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, 628 key.objectid, key.offset, &vaf); 629 va_end(args); 630} 631 632static int check_block_group_item(struct extent_buffer *leaf, 633 struct btrfs_key *key, int slot) 634{ 635 struct btrfs_block_group_item bgi; 636 u32 item_size = btrfs_item_size_nr(leaf, slot); 637 u64 flags; 638 u64 type; 639 640 /* 641 * Here we don't really care about alignment since extent allocator can 642 * handle it. We care more about the size. 643 */ 644 if (key->offset == 0) { 645 block_group_err(leaf, slot, 646 "invalid block group size 0"); 647 return -EUCLEAN; 648 } 649 650 if (item_size != sizeof(bgi)) { 651 block_group_err(leaf, slot, 652 "invalid item size, have %u expect %zu", 653 item_size, sizeof(bgi)); 654 return -EUCLEAN; 655 } 656 657 read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot), 658 sizeof(bgi)); 659 if (btrfs_stack_block_group_chunk_objectid(&bgi) != 660 BTRFS_FIRST_CHUNK_TREE_OBJECTID) { 661 block_group_err(leaf, slot, 662 "invalid block group chunk objectid, have %llu expect %llu", 663 btrfs_stack_block_group_chunk_objectid(&bgi), 664 BTRFS_FIRST_CHUNK_TREE_OBJECTID); 665 return -EUCLEAN; 666 } 667 668 if (btrfs_stack_block_group_used(&bgi) > key->offset) { 669 block_group_err(leaf, slot, 670 "invalid block group used, have %llu expect [0, %llu)", 671 btrfs_stack_block_group_used(&bgi), key->offset); 672 return -EUCLEAN; 673 } 674 675 flags = btrfs_stack_block_group_flags(&bgi); 676 if (hweight64(flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) > 1) { 677 block_group_err(leaf, slot, 678"invalid profile flags, have 0x%llx (%lu bits set) expect no more than 1 bit set", 679 flags & BTRFS_BLOCK_GROUP_PROFILE_MASK, 680 hweight64(flags & BTRFS_BLOCK_GROUP_PROFILE_MASK)); 681 return -EUCLEAN; 682 } 683 684 type = flags & BTRFS_BLOCK_GROUP_TYPE_MASK; 685 if (type != BTRFS_BLOCK_GROUP_DATA && 686 type != BTRFS_BLOCK_GROUP_METADATA && 687 type != BTRFS_BLOCK_GROUP_SYSTEM && 688 type != (BTRFS_BLOCK_GROUP_METADATA | 689 BTRFS_BLOCK_GROUP_DATA)) { 690 block_group_err(leaf, slot, 691"invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx or 0x%llx", 692 type, hweight64(type), 693 BTRFS_BLOCK_GROUP_DATA, BTRFS_BLOCK_GROUP_METADATA, 694 BTRFS_BLOCK_GROUP_SYSTEM, 695 BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA); 696 return -EUCLEAN; 697 } 698 return 0; 699} 700 701__printf(4, 5) 702__cold 703static void chunk_err(const struct extent_buffer *leaf, 704 const struct btrfs_chunk *chunk, u64 logical, 705 const char *fmt, ...) 706{ 707 const struct btrfs_fs_info *fs_info = leaf->fs_info; 708 bool is_sb; 709 struct va_format vaf; 710 va_list args; 711 int i; 712 int slot = -1; 713 714 /* Only superblock eb is able to have such small offset */ 715 is_sb = (leaf->start == BTRFS_SUPER_INFO_OFFSET); 716 717 if (!is_sb) { 718 /* 719 * Get the slot number by iterating through all slots, this 720 * would provide better readability. 721 */ 722 for (i = 0; i < btrfs_header_nritems(leaf); i++) { 723 if (btrfs_item_ptr_offset(leaf, i) == 724 (unsigned long)chunk) { 725 slot = i; 726 break; 727 } 728 } 729 } 730 va_start(args, fmt); 731 vaf.fmt = fmt; 732 vaf.va = &args; 733 734 if (is_sb) 735 btrfs_crit(fs_info, 736 "corrupt superblock syschunk array: chunk_start=%llu, %pV", 737 logical, &vaf); 738 else 739 btrfs_crit(fs_info, 740 "corrupt leaf: root=%llu block=%llu slot=%d chunk_start=%llu, %pV", 741 BTRFS_CHUNK_TREE_OBJECTID, leaf->start, slot, 742 logical, &vaf); 743 va_end(args); 744} 745 746/* 747 * The common chunk check which could also work on super block sys chunk array. 748 * 749 * Return -EUCLEAN if anything is corrupted. 750 * Return 0 if everything is OK. 751 */ 752int btrfs_check_chunk_valid(struct extent_buffer *leaf, 753 struct btrfs_chunk *chunk, u64 logical) 754{ 755 struct btrfs_fs_info *fs_info = leaf->fs_info; 756 u64 length; 757 u64 chunk_end; 758 u64 stripe_len; 759 u16 num_stripes; 760 u16 sub_stripes; 761 u64 type; 762 u64 features; 763 bool mixed = false; 764 int raid_index; 765 int nparity; 766 int ncopies; 767 768 length = btrfs_chunk_length(leaf, chunk); 769 stripe_len = btrfs_chunk_stripe_len(leaf, chunk); 770 num_stripes = btrfs_chunk_num_stripes(leaf, chunk); 771 sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk); 772 type = btrfs_chunk_type(leaf, chunk); 773 raid_index = btrfs_bg_flags_to_raid_index(type); 774 ncopies = btrfs_raid_array[raid_index].ncopies; 775 nparity = btrfs_raid_array[raid_index].nparity; 776 777 if (!num_stripes) { 778 chunk_err(leaf, chunk, logical, 779 "invalid chunk num_stripes, have %u", num_stripes); 780 return -EUCLEAN; 781 } 782 if (num_stripes < ncopies) { 783 chunk_err(leaf, chunk, logical, 784 "invalid chunk num_stripes < ncopies, have %u < %d", 785 num_stripes, ncopies); 786 return -EUCLEAN; 787 } 788 if (nparity && num_stripes == nparity) { 789 chunk_err(leaf, chunk, logical, 790 "invalid chunk num_stripes == nparity, have %u == %d", 791 num_stripes, nparity); 792 return -EUCLEAN; 793 } 794 if (!IS_ALIGNED(logical, fs_info->sectorsize)) { 795 chunk_err(leaf, chunk, logical, 796 "invalid chunk logical, have %llu should aligned to %u", 797 logical, fs_info->sectorsize); 798 return -EUCLEAN; 799 } 800 if (btrfs_chunk_sector_size(leaf, chunk) != fs_info->sectorsize) { 801 chunk_err(leaf, chunk, logical, 802 "invalid chunk sectorsize, have %u expect %u", 803 btrfs_chunk_sector_size(leaf, chunk), 804 fs_info->sectorsize); 805 return -EUCLEAN; 806 } 807 if (!length || !IS_ALIGNED(length, fs_info->sectorsize)) { 808 chunk_err(leaf, chunk, logical, 809 "invalid chunk length, have %llu", length); 810 return -EUCLEAN; 811 } 812 if (unlikely(check_add_overflow(logical, length, &chunk_end))) { 813 chunk_err(leaf, chunk, logical, 814"invalid chunk logical start and length, have logical start %llu length %llu", 815 logical, length); 816 return -EUCLEAN; 817 } 818 if (!is_power_of_2(stripe_len) || stripe_len != BTRFS_STRIPE_LEN) { 819 chunk_err(leaf, chunk, logical, 820 "invalid chunk stripe length: %llu", 821 stripe_len); 822 return -EUCLEAN; 823 } 824 if (~(BTRFS_BLOCK_GROUP_TYPE_MASK | BTRFS_BLOCK_GROUP_PROFILE_MASK) & 825 type) { 826 chunk_err(leaf, chunk, logical, 827 "unrecognized chunk type: 0x%llx", 828 ~(BTRFS_BLOCK_GROUP_TYPE_MASK | 829 BTRFS_BLOCK_GROUP_PROFILE_MASK) & 830 btrfs_chunk_type(leaf, chunk)); 831 return -EUCLEAN; 832 } 833 834 if (!has_single_bit_set(type & BTRFS_BLOCK_GROUP_PROFILE_MASK) && 835 (type & BTRFS_BLOCK_GROUP_PROFILE_MASK) != 0) { 836 chunk_err(leaf, chunk, logical, 837 "invalid chunk profile flag: 0x%llx, expect 0 or 1 bit set", 838 type & BTRFS_BLOCK_GROUP_PROFILE_MASK); 839 return -EUCLEAN; 840 } 841 if ((type & BTRFS_BLOCK_GROUP_TYPE_MASK) == 0) { 842 chunk_err(leaf, chunk, logical, 843 "missing chunk type flag, have 0x%llx one bit must be set in 0x%llx", 844 type, BTRFS_BLOCK_GROUP_TYPE_MASK); 845 return -EUCLEAN; 846 } 847 848 if ((type & BTRFS_BLOCK_GROUP_SYSTEM) && 849 (type & (BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA))) { 850 chunk_err(leaf, chunk, logical, 851 "system chunk with data or metadata type: 0x%llx", 852 type); 853 return -EUCLEAN; 854 } 855 856 features = btrfs_super_incompat_flags(fs_info->super_copy); 857 if (features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) 858 mixed = true; 859 860 if (!mixed) { 861 if ((type & BTRFS_BLOCK_GROUP_METADATA) && 862 (type & BTRFS_BLOCK_GROUP_DATA)) { 863 chunk_err(leaf, chunk, logical, 864 "mixed chunk type in non-mixed mode: 0x%llx", type); 865 return -EUCLEAN; 866 } 867 } 868 869 if ((type & BTRFS_BLOCK_GROUP_RAID10 && sub_stripes != 2) || 870 (type & BTRFS_BLOCK_GROUP_RAID1 && num_stripes != 2) || 871 (type & BTRFS_BLOCK_GROUP_RAID5 && num_stripes < 2) || 872 (type & BTRFS_BLOCK_GROUP_RAID6 && num_stripes < 3) || 873 (type & BTRFS_BLOCK_GROUP_DUP && num_stripes != 2) || 874 ((type & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 && num_stripes != 1)) { 875 chunk_err(leaf, chunk, logical, 876 "invalid num_stripes:sub_stripes %u:%u for profile %llu", 877 num_stripes, sub_stripes, 878 type & BTRFS_BLOCK_GROUP_PROFILE_MASK); 879 return -EUCLEAN; 880 } 881 882 return 0; 883} 884 885/* 886 * Enhanced version of chunk item checker. 887 * 888 * The common btrfs_check_chunk_valid() doesn't check item size since it needs 889 * to work on super block sys_chunk_array which doesn't have full item ptr. 890 */ 891static int check_leaf_chunk_item(struct extent_buffer *leaf, 892 struct btrfs_chunk *chunk, 893 struct btrfs_key *key, int slot) 894{ 895 int num_stripes; 896 897 if (btrfs_item_size_nr(leaf, slot) < sizeof(struct btrfs_chunk)) { 898 chunk_err(leaf, chunk, key->offset, 899 "invalid chunk item size: have %u expect [%zu, %u)", 900 btrfs_item_size_nr(leaf, slot), 901 sizeof(struct btrfs_chunk), 902 BTRFS_LEAF_DATA_SIZE(leaf->fs_info)); 903 return -EUCLEAN; 904 } 905 906 num_stripes = btrfs_chunk_num_stripes(leaf, chunk); 907 /* Let btrfs_check_chunk_valid() handle this error type */ 908 if (num_stripes == 0) 909 goto out; 910 911 if (btrfs_chunk_item_size(num_stripes) != 912 btrfs_item_size_nr(leaf, slot)) { 913 chunk_err(leaf, chunk, key->offset, 914 "invalid chunk item size: have %u expect %lu", 915 btrfs_item_size_nr(leaf, slot), 916 btrfs_chunk_item_size(num_stripes)); 917 return -EUCLEAN; 918 } 919out: 920 return btrfs_check_chunk_valid(leaf, chunk, key->offset); 921} 922 923__printf(3, 4) 924__cold 925static void dev_item_err(const struct extent_buffer *eb, int slot, 926 const char *fmt, ...) 927{ 928 struct btrfs_key key; 929 struct va_format vaf; 930 va_list args; 931 932 btrfs_item_key_to_cpu(eb, &key, slot); 933 va_start(args, fmt); 934 935 vaf.fmt = fmt; 936 vaf.va = &args; 937 938 btrfs_crit(eb->fs_info, 939 "corrupt %s: root=%llu block=%llu slot=%d devid=%llu %pV", 940 btrfs_header_level(eb) == 0 ? "leaf" : "node", 941 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, 942 key.objectid, &vaf); 943 va_end(args); 944} 945 946static int check_dev_item(struct extent_buffer *leaf, 947 struct btrfs_key *key, int slot) 948{ 949 struct btrfs_dev_item *ditem; 950 const u32 item_size = btrfs_item_size_nr(leaf, slot); 951 952 if (key->objectid != BTRFS_DEV_ITEMS_OBJECTID) { 953 dev_item_err(leaf, slot, 954 "invalid objectid: has=%llu expect=%llu", 955 key->objectid, BTRFS_DEV_ITEMS_OBJECTID); 956 return -EUCLEAN; 957 } 958 959 if (unlikely(item_size != sizeof(*ditem))) { 960 dev_item_err(leaf, slot, "invalid item size: has %u expect %zu", 961 item_size, sizeof(*ditem)); 962 return -EUCLEAN; 963 } 964 965 ditem = btrfs_item_ptr(leaf, slot, struct btrfs_dev_item); 966 if (btrfs_device_id(leaf, ditem) != key->offset) { 967 dev_item_err(leaf, slot, 968 "devid mismatch: key has=%llu item has=%llu", 969 key->offset, btrfs_device_id(leaf, ditem)); 970 return -EUCLEAN; 971 } 972 973 /* 974 * For device total_bytes, we don't have reliable way to check it, as 975 * it can be 0 for device removal. Device size check can only be done 976 * by dev extents check. 977 */ 978 if (btrfs_device_bytes_used(leaf, ditem) > 979 btrfs_device_total_bytes(leaf, ditem)) { 980 dev_item_err(leaf, slot, 981 "invalid bytes used: have %llu expect [0, %llu]", 982 btrfs_device_bytes_used(leaf, ditem), 983 btrfs_device_total_bytes(leaf, ditem)); 984 return -EUCLEAN; 985 } 986 /* 987 * Remaining members like io_align/type/gen/dev_group aren't really 988 * utilized. Skip them to make later usage of them easier. 989 */ 990 return 0; 991} 992 993static int check_inode_item(struct extent_buffer *leaf, 994 struct btrfs_key *key, int slot) 995{ 996 struct btrfs_fs_info *fs_info = leaf->fs_info; 997 struct btrfs_inode_item *iitem; 998 u64 super_gen = btrfs_super_generation(fs_info->super_copy); 999 u32 valid_mask = (S_IFMT | S_ISUID | S_ISGID | S_ISVTX | 0777); 1000 const u32 item_size = btrfs_item_size_nr(leaf, slot); 1001 u32 mode; 1002 int ret; 1003 1004 ret = check_inode_key(leaf, key, slot); 1005 if (ret < 0) 1006 return ret; 1007 1008 if (unlikely(item_size != sizeof(*iitem))) { 1009 generic_err(leaf, slot, "invalid item size: has %u expect %zu", 1010 item_size, sizeof(*iitem)); 1011 return -EUCLEAN; 1012 } 1013 1014 iitem = btrfs_item_ptr(leaf, slot, struct btrfs_inode_item); 1015 1016 /* Here we use super block generation + 1 to handle log tree */ 1017 if (btrfs_inode_generation(leaf, iitem) > super_gen + 1) { 1018 inode_item_err(leaf, slot, 1019 "invalid inode generation: has %llu expect (0, %llu]", 1020 btrfs_inode_generation(leaf, iitem), 1021 super_gen + 1); 1022 return -EUCLEAN; 1023 } 1024 /* Note for ROOT_TREE_DIR_ITEM, mkfs could set its transid 0 */ 1025 if (btrfs_inode_transid(leaf, iitem) > super_gen + 1) { 1026 inode_item_err(leaf, slot, 1027 "invalid inode transid: has %llu expect [0, %llu]", 1028 btrfs_inode_transid(leaf, iitem), super_gen + 1); 1029 return -EUCLEAN; 1030 } 1031 1032 /* 1033 * For size and nbytes it's better not to be too strict, as for dir 1034 * item its size/nbytes can easily get wrong, but doesn't affect 1035 * anything in the fs. So here we skip the check. 1036 */ 1037 mode = btrfs_inode_mode(leaf, iitem); 1038 if (mode & ~valid_mask) { 1039 inode_item_err(leaf, slot, 1040 "unknown mode bit detected: 0x%x", 1041 mode & ~valid_mask); 1042 return -EUCLEAN; 1043 } 1044 1045 /* 1046 * S_IFMT is not bit mapped so we can't completely rely on 1047 * is_power_of_2/has_single_bit_set, but it can save us from checking 1048 * FIFO/CHR/DIR/REG. Only needs to check BLK, LNK and SOCKS 1049 */ 1050 if (!has_single_bit_set(mode & S_IFMT)) { 1051 if (!S_ISLNK(mode) && !S_ISBLK(mode) && !S_ISSOCK(mode)) { 1052 inode_item_err(leaf, slot, 1053 "invalid mode: has 0%o expect valid S_IF* bit(s)", 1054 mode & S_IFMT); 1055 return -EUCLEAN; 1056 } 1057 } 1058 if (S_ISDIR(mode) && btrfs_inode_nlink(leaf, iitem) > 1) { 1059 inode_item_err(leaf, slot, 1060 "invalid nlink: has %u expect no more than 1 for dir", 1061 btrfs_inode_nlink(leaf, iitem)); 1062 return -EUCLEAN; 1063 } 1064 if (btrfs_inode_flags(leaf, iitem) & ~BTRFS_INODE_FLAG_MASK) { 1065 inode_item_err(leaf, slot, 1066 "unknown flags detected: 0x%llx", 1067 btrfs_inode_flags(leaf, iitem) & 1068 ~BTRFS_INODE_FLAG_MASK); 1069 return -EUCLEAN; 1070 } 1071 return 0; 1072} 1073 1074static int check_root_item(struct extent_buffer *leaf, struct btrfs_key *key, 1075 int slot) 1076{ 1077 struct btrfs_fs_info *fs_info = leaf->fs_info; 1078 struct btrfs_root_item ri = { 0 }; 1079 const u64 valid_root_flags = BTRFS_ROOT_SUBVOL_RDONLY | 1080 BTRFS_ROOT_SUBVOL_DEAD; 1081 int ret; 1082 1083 ret = check_root_key(leaf, key, slot); 1084 if (ret < 0) 1085 return ret; 1086 1087 if (btrfs_item_size_nr(leaf, slot) != sizeof(ri) && 1088 btrfs_item_size_nr(leaf, slot) != btrfs_legacy_root_item_size()) { 1089 generic_err(leaf, slot, 1090 "invalid root item size, have %u expect %zu or %u", 1091 btrfs_item_size_nr(leaf, slot), sizeof(ri), 1092 btrfs_legacy_root_item_size()); 1093 return -EUCLEAN; 1094 } 1095 1096 /* 1097 * For legacy root item, the members starting at generation_v2 will be 1098 * all filled with 0. 1099 * And since we allow geneartion_v2 as 0, it will still pass the check. 1100 */ 1101 read_extent_buffer(leaf, &ri, btrfs_item_ptr_offset(leaf, slot), 1102 btrfs_item_size_nr(leaf, slot)); 1103 1104 /* Generation related */ 1105 if (btrfs_root_generation(&ri) > 1106 btrfs_super_generation(fs_info->super_copy) + 1) { 1107 generic_err(leaf, slot, 1108 "invalid root generation, have %llu expect (0, %llu]", 1109 btrfs_root_generation(&ri), 1110 btrfs_super_generation(fs_info->super_copy) + 1); 1111 return -EUCLEAN; 1112 } 1113 if (btrfs_root_generation_v2(&ri) > 1114 btrfs_super_generation(fs_info->super_copy) + 1) { 1115 generic_err(leaf, slot, 1116 "invalid root v2 generation, have %llu expect (0, %llu]", 1117 btrfs_root_generation_v2(&ri), 1118 btrfs_super_generation(fs_info->super_copy) + 1); 1119 return -EUCLEAN; 1120 } 1121 if (btrfs_root_last_snapshot(&ri) > 1122 btrfs_super_generation(fs_info->super_copy) + 1) { 1123 generic_err(leaf, slot, 1124 "invalid root last_snapshot, have %llu expect (0, %llu]", 1125 btrfs_root_last_snapshot(&ri), 1126 btrfs_super_generation(fs_info->super_copy) + 1); 1127 return -EUCLEAN; 1128 } 1129 1130 /* Alignment and level check */ 1131 if (!IS_ALIGNED(btrfs_root_bytenr(&ri), fs_info->sectorsize)) { 1132 generic_err(leaf, slot, 1133 "invalid root bytenr, have %llu expect to be aligned to %u", 1134 btrfs_root_bytenr(&ri), fs_info->sectorsize); 1135 return -EUCLEAN; 1136 } 1137 if (btrfs_root_level(&ri) >= BTRFS_MAX_LEVEL) { 1138 generic_err(leaf, slot, 1139 "invalid root level, have %u expect [0, %u]", 1140 btrfs_root_level(&ri), BTRFS_MAX_LEVEL - 1); 1141 return -EUCLEAN; 1142 } 1143 if (ri.drop_level >= BTRFS_MAX_LEVEL) { 1144 generic_err(leaf, slot, 1145 "invalid root level, have %u expect [0, %u]", 1146 ri.drop_level, BTRFS_MAX_LEVEL - 1); 1147 return -EUCLEAN; 1148 } 1149 1150 /* Flags check */ 1151 if (btrfs_root_flags(&ri) & ~valid_root_flags) { 1152 generic_err(leaf, slot, 1153 "invalid root flags, have 0x%llx expect mask 0x%llx", 1154 btrfs_root_flags(&ri), valid_root_flags); 1155 return -EUCLEAN; 1156 } 1157 return 0; 1158} 1159 1160__printf(3,4) 1161__cold 1162static void extent_err(const struct extent_buffer *eb, int slot, 1163 const char *fmt, ...) 1164{ 1165 struct btrfs_key key; 1166 struct va_format vaf; 1167 va_list args; 1168 u64 bytenr; 1169 u64 len; 1170 1171 btrfs_item_key_to_cpu(eb, &key, slot); 1172 bytenr = key.objectid; 1173 if (key.type == BTRFS_METADATA_ITEM_KEY || 1174 key.type == BTRFS_TREE_BLOCK_REF_KEY || 1175 key.type == BTRFS_SHARED_BLOCK_REF_KEY) 1176 len = eb->fs_info->nodesize; 1177 else 1178 len = key.offset; 1179 va_start(args, fmt); 1180 1181 vaf.fmt = fmt; 1182 vaf.va = &args; 1183 1184 btrfs_crit(eb->fs_info, 1185 "corrupt %s: block=%llu slot=%d extent bytenr=%llu len=%llu %pV", 1186 btrfs_header_level(eb) == 0 ? "leaf" : "node", 1187 eb->start, slot, bytenr, len, &vaf); 1188 va_end(args); 1189} 1190 1191static int check_extent_item(struct extent_buffer *leaf, 1192 struct btrfs_key *key, int slot) 1193{ 1194 struct btrfs_fs_info *fs_info = leaf->fs_info; 1195 struct btrfs_extent_item *ei; 1196 bool is_tree_block = false; 1197 unsigned long ptr; /* Current pointer inside inline refs */ 1198 unsigned long end; /* Extent item end */ 1199 const u32 item_size = btrfs_item_size_nr(leaf, slot); 1200 u64 flags; 1201 u64 generation; 1202 u64 total_refs; /* Total refs in btrfs_extent_item */ 1203 u64 inline_refs = 0; /* found total inline refs */ 1204 1205 if (key->type == BTRFS_METADATA_ITEM_KEY && 1206 !btrfs_fs_incompat(fs_info, SKINNY_METADATA)) { 1207 generic_err(leaf, slot, 1208"invalid key type, METADATA_ITEM type invalid when SKINNY_METADATA feature disabled"); 1209 return -EUCLEAN; 1210 } 1211 /* key->objectid is the bytenr for both key types */ 1212 if (!IS_ALIGNED(key->objectid, fs_info->sectorsize)) { 1213 generic_err(leaf, slot, 1214 "invalid key objectid, have %llu expect to be aligned to %u", 1215 key->objectid, fs_info->sectorsize); 1216 return -EUCLEAN; 1217 } 1218 1219 /* key->offset is tree level for METADATA_ITEM_KEY */ 1220 if (key->type == BTRFS_METADATA_ITEM_KEY && 1221 key->offset >= BTRFS_MAX_LEVEL) { 1222 extent_err(leaf, slot, 1223 "invalid tree level, have %llu expect [0, %u]", 1224 key->offset, BTRFS_MAX_LEVEL - 1); 1225 return -EUCLEAN; 1226 } 1227 1228 /* 1229 * EXTENT/METADATA_ITEM consists of: 1230 * 1) One btrfs_extent_item 1231 * Records the total refs, type and generation of the extent. 1232 * 1233 * 2) One btrfs_tree_block_info (for EXTENT_ITEM and tree backref only) 1234 * Records the first key and level of the tree block. 1235 * 1236 * 2) Zero or more btrfs_extent_inline_ref(s) 1237 * Each inline ref has one btrfs_extent_inline_ref shows: 1238 * 2.1) The ref type, one of the 4 1239 * TREE_BLOCK_REF Tree block only 1240 * SHARED_BLOCK_REF Tree block only 1241 * EXTENT_DATA_REF Data only 1242 * SHARED_DATA_REF Data only 1243 * 2.2) Ref type specific data 1244 * Either using btrfs_extent_inline_ref::offset, or specific 1245 * data structure. 1246 */ 1247 if (item_size < sizeof(*ei)) { 1248 extent_err(leaf, slot, 1249 "invalid item size, have %u expect [%zu, %u)", 1250 item_size, sizeof(*ei), 1251 BTRFS_LEAF_DATA_SIZE(fs_info)); 1252 return -EUCLEAN; 1253 } 1254 end = item_size + btrfs_item_ptr_offset(leaf, slot); 1255 1256 /* Checks against extent_item */ 1257 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item); 1258 flags = btrfs_extent_flags(leaf, ei); 1259 total_refs = btrfs_extent_refs(leaf, ei); 1260 generation = btrfs_extent_generation(leaf, ei); 1261 if (generation > btrfs_super_generation(fs_info->super_copy) + 1) { 1262 extent_err(leaf, slot, 1263 "invalid generation, have %llu expect (0, %llu]", 1264 generation, 1265 btrfs_super_generation(fs_info->super_copy) + 1); 1266 return -EUCLEAN; 1267 } 1268 if (!has_single_bit_set(flags & (BTRFS_EXTENT_FLAG_DATA | 1269 BTRFS_EXTENT_FLAG_TREE_BLOCK))) { 1270 extent_err(leaf, slot, 1271 "invalid extent flag, have 0x%llx expect 1 bit set in 0x%llx", 1272 flags, BTRFS_EXTENT_FLAG_DATA | 1273 BTRFS_EXTENT_FLAG_TREE_BLOCK); 1274 return -EUCLEAN; 1275 } 1276 is_tree_block = !!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK); 1277 if (is_tree_block) { 1278 if (key->type == BTRFS_EXTENT_ITEM_KEY && 1279 key->offset != fs_info->nodesize) { 1280 extent_err(leaf, slot, 1281 "invalid extent length, have %llu expect %u", 1282 key->offset, fs_info->nodesize); 1283 return -EUCLEAN; 1284 } 1285 } else { 1286 if (key->type != BTRFS_EXTENT_ITEM_KEY) { 1287 extent_err(leaf, slot, 1288 "invalid key type, have %u expect %u for data backref", 1289 key->type, BTRFS_EXTENT_ITEM_KEY); 1290 return -EUCLEAN; 1291 } 1292 if (!IS_ALIGNED(key->offset, fs_info->sectorsize)) { 1293 extent_err(leaf, slot, 1294 "invalid extent length, have %llu expect aligned to %u", 1295 key->offset, fs_info->sectorsize); 1296 return -EUCLEAN; 1297 } 1298 } 1299 ptr = (unsigned long)(struct btrfs_extent_item *)(ei + 1); 1300 1301 /* Check the special case of btrfs_tree_block_info */ 1302 if (is_tree_block && key->type != BTRFS_METADATA_ITEM_KEY) { 1303 struct btrfs_tree_block_info *info; 1304 1305 info = (struct btrfs_tree_block_info *)ptr; 1306 if (btrfs_tree_block_level(leaf, info) >= BTRFS_MAX_LEVEL) { 1307 extent_err(leaf, slot, 1308 "invalid tree block info level, have %u expect [0, %u]", 1309 btrfs_tree_block_level(leaf, info), 1310 BTRFS_MAX_LEVEL - 1); 1311 return -EUCLEAN; 1312 } 1313 ptr = (unsigned long)(struct btrfs_tree_block_info *)(info + 1); 1314 } 1315 1316 /* Check inline refs */ 1317 while (ptr < end) { 1318 struct btrfs_extent_inline_ref *iref; 1319 struct btrfs_extent_data_ref *dref; 1320 struct btrfs_shared_data_ref *sref; 1321 u64 dref_offset; 1322 u64 inline_offset; 1323 u8 inline_type; 1324 1325 if (ptr + sizeof(*iref) > end) { 1326 extent_err(leaf, slot, 1327"inline ref item overflows extent item, ptr %lu iref size %zu end %lu", 1328 ptr, sizeof(*iref), end); 1329 return -EUCLEAN; 1330 } 1331 iref = (struct btrfs_extent_inline_ref *)ptr; 1332 inline_type = btrfs_extent_inline_ref_type(leaf, iref); 1333 inline_offset = btrfs_extent_inline_ref_offset(leaf, iref); 1334 if (ptr + btrfs_extent_inline_ref_size(inline_type) > end) { 1335 extent_err(leaf, slot, 1336"inline ref item overflows extent item, ptr %lu iref size %u end %lu", 1337 ptr, btrfs_extent_inline_ref_size(inline_type), end); 1338 return -EUCLEAN; 1339 } 1340 1341 switch (inline_type) { 1342 /* inline_offset is subvolid of the owner, no need to check */ 1343 case BTRFS_TREE_BLOCK_REF_KEY: 1344 inline_refs++; 1345 break; 1346 /* Contains parent bytenr */ 1347 case BTRFS_SHARED_BLOCK_REF_KEY: 1348 if (!IS_ALIGNED(inline_offset, fs_info->sectorsize)) { 1349 extent_err(leaf, slot, 1350 "invalid tree parent bytenr, have %llu expect aligned to %u", 1351 inline_offset, fs_info->sectorsize); 1352 return -EUCLEAN; 1353 } 1354 inline_refs++; 1355 break; 1356 /* 1357 * Contains owner subvolid, owner key objectid, adjusted offset. 1358 * The only obvious corruption can happen in that offset. 1359 */ 1360 case BTRFS_EXTENT_DATA_REF_KEY: 1361 dref = (struct btrfs_extent_data_ref *)(&iref->offset); 1362 dref_offset = btrfs_extent_data_ref_offset(leaf, dref); 1363 if (!IS_ALIGNED(dref_offset, fs_info->sectorsize)) { 1364 extent_err(leaf, slot, 1365 "invalid data ref offset, have %llu expect aligned to %u", 1366 dref_offset, fs_info->sectorsize); 1367 return -EUCLEAN; 1368 } 1369 inline_refs += btrfs_extent_data_ref_count(leaf, dref); 1370 break; 1371 /* Contains parent bytenr and ref count */ 1372 case BTRFS_SHARED_DATA_REF_KEY: 1373 sref = (struct btrfs_shared_data_ref *)(iref + 1); 1374 if (!IS_ALIGNED(inline_offset, fs_info->sectorsize)) { 1375 extent_err(leaf, slot, 1376 "invalid data parent bytenr, have %llu expect aligned to %u", 1377 inline_offset, fs_info->sectorsize); 1378 return -EUCLEAN; 1379 } 1380 inline_refs += btrfs_shared_data_ref_count(leaf, sref); 1381 break; 1382 default: 1383 extent_err(leaf, slot, "unknown inline ref type: %u", 1384 inline_type); 1385 return -EUCLEAN; 1386 } 1387 ptr += btrfs_extent_inline_ref_size(inline_type); 1388 } 1389 /* No padding is allowed */ 1390 if (ptr != end) { 1391 extent_err(leaf, slot, 1392 "invalid extent item size, padding bytes found"); 1393 return -EUCLEAN; 1394 } 1395 1396 /* Finally, check the inline refs against total refs */ 1397 if (inline_refs > total_refs) { 1398 extent_err(leaf, slot, 1399 "invalid extent refs, have %llu expect >= inline %llu", 1400 total_refs, inline_refs); 1401 return -EUCLEAN; 1402 } 1403 return 0; 1404} 1405 1406static int check_simple_keyed_refs(struct extent_buffer *leaf, 1407 struct btrfs_key *key, int slot) 1408{ 1409 u32 expect_item_size = 0; 1410 1411 if (key->type == BTRFS_SHARED_DATA_REF_KEY) 1412 expect_item_size = sizeof(struct btrfs_shared_data_ref); 1413 1414 if (btrfs_item_size_nr(leaf, slot) != expect_item_size) { 1415 generic_err(leaf, slot, 1416 "invalid item size, have %u expect %u for key type %u", 1417 btrfs_item_size_nr(leaf, slot), 1418 expect_item_size, key->type); 1419 return -EUCLEAN; 1420 } 1421 if (!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize)) { 1422 generic_err(leaf, slot, 1423"invalid key objectid for shared block ref, have %llu expect aligned to %u", 1424 key->objectid, leaf->fs_info->sectorsize); 1425 return -EUCLEAN; 1426 } 1427 if (key->type != BTRFS_TREE_BLOCK_REF_KEY && 1428 !IS_ALIGNED(key->offset, leaf->fs_info->sectorsize)) { 1429 extent_err(leaf, slot, 1430 "invalid tree parent bytenr, have %llu expect aligned to %u", 1431 key->offset, leaf->fs_info->sectorsize); 1432 return -EUCLEAN; 1433 } 1434 return 0; 1435} 1436 1437static int check_extent_data_ref(struct extent_buffer *leaf, 1438 struct btrfs_key *key, int slot) 1439{ 1440 struct btrfs_extent_data_ref *dref; 1441 unsigned long ptr = btrfs_item_ptr_offset(leaf, slot); 1442 const unsigned long end = ptr + btrfs_item_size_nr(leaf, slot); 1443 1444 if (btrfs_item_size_nr(leaf, slot) % sizeof(*dref) != 0) { 1445 generic_err(leaf, slot, 1446 "invalid item size, have %u expect aligned to %zu for key type %u", 1447 btrfs_item_size_nr(leaf, slot), 1448 sizeof(*dref), key->type); 1449 return -EUCLEAN; 1450 } 1451 if (!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize)) { 1452 generic_err(leaf, slot, 1453"invalid key objectid for shared block ref, have %llu expect aligned to %u", 1454 key->objectid, leaf->fs_info->sectorsize); 1455 return -EUCLEAN; 1456 } 1457 for (; ptr < end; ptr += sizeof(*dref)) { 1458 u64 offset; 1459 1460 /* 1461 * We cannot check the extent_data_ref hash due to possible 1462 * overflow from the leaf due to hash collisions. 1463 */ 1464 dref = (struct btrfs_extent_data_ref *)ptr; 1465 offset = btrfs_extent_data_ref_offset(leaf, dref); 1466 if (!IS_ALIGNED(offset, leaf->fs_info->sectorsize)) { 1467 extent_err(leaf, slot, 1468 "invalid extent data backref offset, have %llu expect aligned to %u", 1469 offset, leaf->fs_info->sectorsize); 1470 return -EUCLEAN; 1471 } 1472 } 1473 return 0; 1474} 1475 1476#define inode_ref_err(eb, slot, fmt, args...) \ 1477 inode_item_err(eb, slot, fmt, ##args) 1478static int check_inode_ref(struct extent_buffer *leaf, 1479 struct btrfs_key *key, struct btrfs_key *prev_key, 1480 int slot) 1481{ 1482 struct btrfs_inode_ref *iref; 1483 unsigned long ptr; 1484 unsigned long end; 1485 1486 if (!check_prev_ino(leaf, key, slot, prev_key)) 1487 return -EUCLEAN; 1488 /* namelen can't be 0, so item_size == sizeof() is also invalid */ 1489 if (btrfs_item_size_nr(leaf, slot) <= sizeof(*iref)) { 1490 inode_ref_err(leaf, slot, 1491 "invalid item size, have %u expect (%zu, %u)", 1492 btrfs_item_size_nr(leaf, slot), 1493 sizeof(*iref), BTRFS_LEAF_DATA_SIZE(leaf->fs_info)); 1494 return -EUCLEAN; 1495 } 1496 1497 ptr = btrfs_item_ptr_offset(leaf, slot); 1498 end = ptr + btrfs_item_size_nr(leaf, slot); 1499 while (ptr < end) { 1500 u16 namelen; 1501 1502 if (ptr + sizeof(iref) > end) { 1503 inode_ref_err(leaf, slot, 1504 "inode ref overflow, ptr %lu end %lu inode_ref_size %zu", 1505 ptr, end, sizeof(iref)); 1506 return -EUCLEAN; 1507 } 1508 1509 iref = (struct btrfs_inode_ref *)ptr; 1510 namelen = btrfs_inode_ref_name_len(leaf, iref); 1511 if (ptr + sizeof(*iref) + namelen > end) { 1512 inode_ref_err(leaf, slot, 1513 "inode ref overflow, ptr %lu end %lu namelen %u", 1514 ptr, end, namelen); 1515 return -EUCLEAN; 1516 } 1517 1518 /* 1519 * NOTE: In theory we should record all found index numbers 1520 * to find any duplicated indexes, but that will be too time 1521 * consuming for inodes with too many hard links. 1522 */ 1523 ptr += sizeof(*iref) + namelen; 1524 } 1525 return 0; 1526} 1527 1528/* 1529 * Common point to switch the item-specific validation. 1530 */ 1531static int check_leaf_item(struct extent_buffer *leaf, 1532 struct btrfs_key *key, int slot, 1533 struct btrfs_key *prev_key) 1534{ 1535 int ret = 0; 1536 struct btrfs_chunk *chunk; 1537 1538 switch (key->type) { 1539 case BTRFS_EXTENT_DATA_KEY: 1540 ret = check_extent_data_item(leaf, key, slot, prev_key); 1541 break; 1542 case BTRFS_EXTENT_CSUM_KEY: 1543 ret = check_csum_item(leaf, key, slot, prev_key); 1544 break; 1545 case BTRFS_DIR_ITEM_KEY: 1546 case BTRFS_DIR_INDEX_KEY: 1547 case BTRFS_XATTR_ITEM_KEY: 1548 ret = check_dir_item(leaf, key, prev_key, slot); 1549 break; 1550 case BTRFS_INODE_REF_KEY: 1551 ret = check_inode_ref(leaf, key, prev_key, slot); 1552 break; 1553 case BTRFS_BLOCK_GROUP_ITEM_KEY: 1554 ret = check_block_group_item(leaf, key, slot); 1555 break; 1556 case BTRFS_CHUNK_ITEM_KEY: 1557 chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk); 1558 ret = check_leaf_chunk_item(leaf, chunk, key, slot); 1559 break; 1560 case BTRFS_DEV_ITEM_KEY: 1561 ret = check_dev_item(leaf, key, slot); 1562 break; 1563 case BTRFS_INODE_ITEM_KEY: 1564 ret = check_inode_item(leaf, key, slot); 1565 break; 1566 case BTRFS_ROOT_ITEM_KEY: 1567 ret = check_root_item(leaf, key, slot); 1568 break; 1569 case BTRFS_EXTENT_ITEM_KEY: 1570 case BTRFS_METADATA_ITEM_KEY: 1571 ret = check_extent_item(leaf, key, slot); 1572 break; 1573 case BTRFS_TREE_BLOCK_REF_KEY: 1574 case BTRFS_SHARED_DATA_REF_KEY: 1575 case BTRFS_SHARED_BLOCK_REF_KEY: 1576 ret = check_simple_keyed_refs(leaf, key, slot); 1577 break; 1578 case BTRFS_EXTENT_DATA_REF_KEY: 1579 ret = check_extent_data_ref(leaf, key, slot); 1580 break; 1581 } 1582 return ret; 1583} 1584 1585static int check_leaf(struct extent_buffer *leaf, bool check_item_data) 1586{ 1587 struct btrfs_fs_info *fs_info = leaf->fs_info; 1588 /* No valid key type is 0, so all key should be larger than this key */ 1589 struct btrfs_key prev_key = {0, 0, 0}; 1590 struct btrfs_key key; 1591 u32 nritems = btrfs_header_nritems(leaf); 1592 int slot; 1593 1594 if (btrfs_header_level(leaf) != 0) { 1595 generic_err(leaf, 0, 1596 "invalid level for leaf, have %d expect 0", 1597 btrfs_header_level(leaf)); 1598 return -EUCLEAN; 1599 } 1600 1601 /* 1602 * Extent buffers from a relocation tree have a owner field that 1603 * corresponds to the subvolume tree they are based on. So just from an 1604 * extent buffer alone we can not find out what is the id of the 1605 * corresponding subvolume tree, so we can not figure out if the extent 1606 * buffer corresponds to the root of the relocation tree or not. So 1607 * skip this check for relocation trees. 1608 */ 1609 if (nritems == 0 && !btrfs_header_flag(leaf, BTRFS_HEADER_FLAG_RELOC)) { 1610 u64 owner = btrfs_header_owner(leaf); 1611 1612 /* These trees must never be empty */ 1613 if (owner == BTRFS_ROOT_TREE_OBJECTID || 1614 owner == BTRFS_CHUNK_TREE_OBJECTID || 1615 owner == BTRFS_EXTENT_TREE_OBJECTID || 1616 owner == BTRFS_DEV_TREE_OBJECTID || 1617 owner == BTRFS_FS_TREE_OBJECTID || 1618 owner == BTRFS_DATA_RELOC_TREE_OBJECTID) { 1619 generic_err(leaf, 0, 1620 "invalid root, root %llu must never be empty", 1621 owner); 1622 return -EUCLEAN; 1623 } 1624 /* Unknown tree */ 1625 if (owner == 0) { 1626 generic_err(leaf, 0, 1627 "invalid owner, root 0 is not defined"); 1628 return -EUCLEAN; 1629 } 1630 return 0; 1631 } 1632 1633 if (nritems == 0) 1634 return 0; 1635 1636 /* 1637 * Check the following things to make sure this is a good leaf, and 1638 * leaf users won't need to bother with similar sanity checks: 1639 * 1640 * 1) key ordering 1641 * 2) item offset and size 1642 * No overlap, no hole, all inside the leaf. 1643 * 3) item content 1644 * If possible, do comprehensive sanity check. 1645 * NOTE: All checks must only rely on the item data itself. 1646 */ 1647 for (slot = 0; slot < nritems; slot++) { 1648 u32 item_end_expected; 1649 int ret; 1650 1651 btrfs_item_key_to_cpu(leaf, &key, slot); 1652 1653 /* Make sure the keys are in the right order */ 1654 if (btrfs_comp_cpu_keys(&prev_key, &key) >= 0) { 1655 generic_err(leaf, slot, 1656 "bad key order, prev (%llu %u %llu) current (%llu %u %llu)", 1657 prev_key.objectid, prev_key.type, 1658 prev_key.offset, key.objectid, key.type, 1659 key.offset); 1660 return -EUCLEAN; 1661 } 1662 1663 /* 1664 * Make sure the offset and ends are right, remember that the 1665 * item data starts at the end of the leaf and grows towards the 1666 * front. 1667 */ 1668 if (slot == 0) 1669 item_end_expected = BTRFS_LEAF_DATA_SIZE(fs_info); 1670 else 1671 item_end_expected = btrfs_item_offset_nr(leaf, 1672 slot - 1); 1673 if (btrfs_item_end_nr(leaf, slot) != item_end_expected) { 1674 generic_err(leaf, slot, 1675 "unexpected item end, have %u expect %u", 1676 btrfs_item_end_nr(leaf, slot), 1677 item_end_expected); 1678 return -EUCLEAN; 1679 } 1680 1681 /* 1682 * Check to make sure that we don't point outside of the leaf, 1683 * just in case all the items are consistent to each other, but 1684 * all point outside of the leaf. 1685 */ 1686 if (btrfs_item_end_nr(leaf, slot) > 1687 BTRFS_LEAF_DATA_SIZE(fs_info)) { 1688 generic_err(leaf, slot, 1689 "slot end outside of leaf, have %u expect range [0, %u]", 1690 btrfs_item_end_nr(leaf, slot), 1691 BTRFS_LEAF_DATA_SIZE(fs_info)); 1692 return -EUCLEAN; 1693 } 1694 1695 /* Also check if the item pointer overlaps with btrfs item. */ 1696 if (btrfs_item_nr_offset(slot) + sizeof(struct btrfs_item) > 1697 btrfs_item_ptr_offset(leaf, slot)) { 1698 generic_err(leaf, slot, 1699 "slot overlaps with its data, item end %lu data start %lu", 1700 btrfs_item_nr_offset(slot) + 1701 sizeof(struct btrfs_item), 1702 btrfs_item_ptr_offset(leaf, slot)); 1703 return -EUCLEAN; 1704 } 1705 1706 if (check_item_data) { 1707 /* 1708 * Check if the item size and content meet other 1709 * criteria 1710 */ 1711 ret = check_leaf_item(leaf, &key, slot, &prev_key); 1712 if (ret < 0) 1713 return ret; 1714 } 1715 1716 prev_key.objectid = key.objectid; 1717 prev_key.type = key.type; 1718 prev_key.offset = key.offset; 1719 } 1720 1721 return 0; 1722} 1723 1724int btrfs_check_leaf_full(struct extent_buffer *leaf) 1725{ 1726 return check_leaf(leaf, true); 1727} 1728ALLOW_ERROR_INJECTION(btrfs_check_leaf_full, ERRNO); 1729 1730int btrfs_check_leaf_relaxed(struct extent_buffer *leaf) 1731{ 1732 return check_leaf(leaf, false); 1733} 1734 1735int btrfs_check_node(struct extent_buffer *node) 1736{ 1737 struct btrfs_fs_info *fs_info = node->fs_info; 1738 unsigned long nr = btrfs_header_nritems(node); 1739 struct btrfs_key key, next_key; 1740 int slot; 1741 int level = btrfs_header_level(node); 1742 u64 bytenr; 1743 int ret = 0; 1744 1745 if (level <= 0 || level >= BTRFS_MAX_LEVEL) { 1746 generic_err(node, 0, 1747 "invalid level for node, have %d expect [1, %d]", 1748 level, BTRFS_MAX_LEVEL - 1); 1749 return -EUCLEAN; 1750 } 1751 if (nr == 0 || nr > BTRFS_NODEPTRS_PER_BLOCK(fs_info)) { 1752 btrfs_crit(fs_info, 1753"corrupt node: root=%llu block=%llu, nritems too %s, have %lu expect range [1,%u]", 1754 btrfs_header_owner(node), node->start, 1755 nr == 0 ? "small" : "large", nr, 1756 BTRFS_NODEPTRS_PER_BLOCK(fs_info)); 1757 return -EUCLEAN; 1758 } 1759 1760 for (slot = 0; slot < nr - 1; slot++) { 1761 bytenr = btrfs_node_blockptr(node, slot); 1762 btrfs_node_key_to_cpu(node, &key, slot); 1763 btrfs_node_key_to_cpu(node, &next_key, slot + 1); 1764 1765 if (!bytenr) { 1766 generic_err(node, slot, 1767 "invalid NULL node pointer"); 1768 ret = -EUCLEAN; 1769 goto out; 1770 } 1771 if (!IS_ALIGNED(bytenr, fs_info->sectorsize)) { 1772 generic_err(node, slot, 1773 "unaligned pointer, have %llu should be aligned to %u", 1774 bytenr, fs_info->sectorsize); 1775 ret = -EUCLEAN; 1776 goto out; 1777 } 1778 1779 if (btrfs_comp_cpu_keys(&key, &next_key) >= 0) { 1780 generic_err(node, slot, 1781 "bad key order, current (%llu %u %llu) next (%llu %u %llu)", 1782 key.objectid, key.type, key.offset, 1783 next_key.objectid, next_key.type, 1784 next_key.offset); 1785 ret = -EUCLEAN; 1786 goto out; 1787 } 1788 } 1789out: 1790 return ret; 1791} 1792ALLOW_ERROR_INJECTION(btrfs_check_node, ERRNO); 1793