1c1d7c514SDavid Sterba // SPDX-License-Identifier: GPL-2.0 2557ea5ddSQu Wenruo /* 3557ea5ddSQu Wenruo * Copyright (C) Qu Wenruo 2017. All rights reserved. 4557ea5ddSQu Wenruo */ 5557ea5ddSQu Wenruo 6557ea5ddSQu Wenruo /* 7557ea5ddSQu Wenruo * The module is used to catch unexpected/corrupted tree block data. 8557ea5ddSQu Wenruo * Such behavior can be caused either by a fuzzed image or bugs. 9557ea5ddSQu Wenruo * 10557ea5ddSQu Wenruo * The objective is to do leaf/node validation checks when tree block is read 11557ea5ddSQu Wenruo * from disk, and check *every* possible member, so other code won't 12557ea5ddSQu Wenruo * need to checking them again. 13557ea5ddSQu Wenruo * 14557ea5ddSQu Wenruo * Due to the potential and unwanted damage, every checker needs to be 15557ea5ddSQu Wenruo * carefully reviewed otherwise so it does not prevent mount of valid images. 16557ea5ddSQu Wenruo */ 17557ea5ddSQu Wenruo 1802529d7aSQu Wenruo #include <linux/types.h> 1902529d7aSQu Wenruo #include <linux/stddef.h> 2002529d7aSQu Wenruo #include <linux/error-injection.h> 21557ea5ddSQu Wenruo #include "ctree.h" 22557ea5ddSQu Wenruo #include "tree-checker.h" 23557ea5ddSQu Wenruo #include "disk-io.h" 24557ea5ddSQu Wenruo #include "compression.h" 25fce466eaSQu Wenruo #include "volumes.h" 26c1499166SDavid Sterba #include "misc.h" 27557ea5ddSQu Wenruo 28bba4f298SQu Wenruo /* 29bba4f298SQu Wenruo * Error message should follow the following format: 30bba4f298SQu Wenruo * corrupt <type>: <identifier>, <reason>[, <bad_value>] 31bba4f298SQu Wenruo * 32bba4f298SQu Wenruo * @type: leaf or node 33bba4f298SQu Wenruo * @identifier: the necessary info to locate the leaf/node. 3452042d8eSAndrea Gelmini * It's recommended to decode key.objecitd/offset if it's 35bba4f298SQu Wenruo * meaningful. 36bba4f298SQu Wenruo * @reason: describe the error 3752042d8eSAndrea Gelmini * @bad_value: optional, it's recommended to output bad value and its 38bba4f298SQu Wenruo * expected value (range). 39bba4f298SQu Wenruo * 40bba4f298SQu Wenruo * Since comma is used to separate the components, only space is allowed 41bba4f298SQu Wenruo * inside each component. 42bba4f298SQu Wenruo */ 43bba4f298SQu Wenruo 44bba4f298SQu Wenruo /* 45bba4f298SQu Wenruo * Append generic "corrupt leaf/node root=%llu block=%llu slot=%d: " to @fmt. 46bba4f298SQu Wenruo * Allows callers to customize the output. 47bba4f298SQu Wenruo */ 4886a6be3aSDavid Sterba __printf(3, 4) 49e67c718bSDavid Sterba __cold 5086a6be3aSDavid Sterba static void generic_err(const struct extent_buffer *eb, int slot, 51bba4f298SQu Wenruo const char *fmt, ...) 52bba4f298SQu Wenruo { 5386a6be3aSDavid Sterba const struct btrfs_fs_info *fs_info = eb->fs_info; 54bba4f298SQu Wenruo struct va_format vaf; 55bba4f298SQu Wenruo va_list args; 56bba4f298SQu Wenruo 57bba4f298SQu Wenruo va_start(args, fmt); 58bba4f298SQu Wenruo 59bba4f298SQu Wenruo vaf.fmt = fmt; 60bba4f298SQu Wenruo vaf.va = &args; 61bba4f298SQu Wenruo 622f659546SQu Wenruo btrfs_crit(fs_info, 63bba4f298SQu Wenruo "corrupt %s: root=%llu block=%llu slot=%d, %pV", 64bba4f298SQu Wenruo btrfs_header_level(eb) == 0 ? "leaf" : "node", 652f659546SQu Wenruo btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, &vaf); 66bba4f298SQu Wenruo va_end(args); 67bba4f298SQu Wenruo } 68bba4f298SQu Wenruo 698806d718SQu Wenruo /* 708806d718SQu Wenruo * Customized reporter for extent data item, since its key objectid and 718806d718SQu Wenruo * offset has its own meaning. 728806d718SQu Wenruo */ 731fd715ffSDavid Sterba __printf(3, 4) 74e67c718bSDavid Sterba __cold 751fd715ffSDavid Sterba static void file_extent_err(const struct extent_buffer *eb, int slot, 768806d718SQu Wenruo const char *fmt, ...) 778806d718SQu Wenruo { 781fd715ffSDavid Sterba const struct btrfs_fs_info *fs_info = eb->fs_info; 798806d718SQu Wenruo struct btrfs_key key; 808806d718SQu Wenruo struct va_format vaf; 818806d718SQu Wenruo va_list args; 828806d718SQu Wenruo 838806d718SQu Wenruo btrfs_item_key_to_cpu(eb, &key, slot); 848806d718SQu Wenruo va_start(args, fmt); 858806d718SQu Wenruo 868806d718SQu Wenruo vaf.fmt = fmt; 878806d718SQu Wenruo vaf.va = &args; 888806d718SQu Wenruo 892f659546SQu Wenruo btrfs_crit(fs_info, 908806d718SQu Wenruo "corrupt %s: root=%llu block=%llu slot=%d ino=%llu file_offset=%llu, %pV", 912f659546SQu Wenruo btrfs_header_level(eb) == 0 ? "leaf" : "node", 922f659546SQu Wenruo btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, 932f659546SQu Wenruo key.objectid, key.offset, &vaf); 948806d718SQu Wenruo va_end(args); 958806d718SQu Wenruo } 968806d718SQu Wenruo 978806d718SQu Wenruo /* 988806d718SQu Wenruo * Return 0 if the btrfs_file_extent_##name is aligned to @alignment 998806d718SQu Wenruo * Else return 1 1008806d718SQu Wenruo */ 101033774dcSDavid Sterba #define CHECK_FE_ALIGNED(leaf, slot, fi, name, alignment) \ 1028806d718SQu Wenruo ({ \ 103*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), \ 104*c7c01a4aSDavid Sterba (alignment)))) \ 1051fd715ffSDavid Sterba file_extent_err((leaf), (slot), \ 1068806d718SQu Wenruo "invalid %s for file extent, have %llu, should be aligned to %u", \ 1078806d718SQu Wenruo (#name), btrfs_file_extent_##name((leaf), (fi)), \ 1088806d718SQu Wenruo (alignment)); \ 1098806d718SQu Wenruo (!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), (alignment))); \ 1108806d718SQu Wenruo }) 1118806d718SQu Wenruo 1124e9845efSFilipe Manana static u64 file_extent_end(struct extent_buffer *leaf, 1134e9845efSFilipe Manana struct btrfs_key *key, 1144e9845efSFilipe Manana struct btrfs_file_extent_item *extent) 1154e9845efSFilipe Manana { 1164e9845efSFilipe Manana u64 end; 1174e9845efSFilipe Manana u64 len; 1184e9845efSFilipe Manana 1194e9845efSFilipe Manana if (btrfs_file_extent_type(leaf, extent) == BTRFS_FILE_EXTENT_INLINE) { 1204e9845efSFilipe Manana len = btrfs_file_extent_ram_bytes(leaf, extent); 1214e9845efSFilipe Manana end = ALIGN(key->offset + len, leaf->fs_info->sectorsize); 1224e9845efSFilipe Manana } else { 1234e9845efSFilipe Manana len = btrfs_file_extent_num_bytes(leaf, extent); 1244e9845efSFilipe Manana end = key->offset + len; 1254e9845efSFilipe Manana } 1264e9845efSFilipe Manana return end; 1274e9845efSFilipe Manana } 1284e9845efSFilipe Manana 12980d7fd1eSQu Wenruo /* 13080d7fd1eSQu Wenruo * Customized report for dir_item, the only new important information is 13180d7fd1eSQu Wenruo * key->objectid, which represents inode number 13280d7fd1eSQu Wenruo */ 13380d7fd1eSQu Wenruo __printf(3, 4) 13480d7fd1eSQu Wenruo __cold 13580d7fd1eSQu Wenruo static void dir_item_err(const struct extent_buffer *eb, int slot, 13680d7fd1eSQu Wenruo const char *fmt, ...) 13780d7fd1eSQu Wenruo { 13880d7fd1eSQu Wenruo const struct btrfs_fs_info *fs_info = eb->fs_info; 13980d7fd1eSQu Wenruo struct btrfs_key key; 14080d7fd1eSQu Wenruo struct va_format vaf; 14180d7fd1eSQu Wenruo va_list args; 14280d7fd1eSQu Wenruo 14380d7fd1eSQu Wenruo btrfs_item_key_to_cpu(eb, &key, slot); 14480d7fd1eSQu Wenruo va_start(args, fmt); 14580d7fd1eSQu Wenruo 14680d7fd1eSQu Wenruo vaf.fmt = fmt; 14780d7fd1eSQu Wenruo vaf.va = &args; 14880d7fd1eSQu Wenruo 14980d7fd1eSQu Wenruo btrfs_crit(fs_info, 15080d7fd1eSQu Wenruo "corrupt %s: root=%llu block=%llu slot=%d ino=%llu, %pV", 15180d7fd1eSQu Wenruo btrfs_header_level(eb) == 0 ? "leaf" : "node", 15280d7fd1eSQu Wenruo btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, 15380d7fd1eSQu Wenruo key.objectid, &vaf); 15480d7fd1eSQu Wenruo va_end(args); 15580d7fd1eSQu Wenruo } 15680d7fd1eSQu Wenruo 15780d7fd1eSQu Wenruo /* 15880d7fd1eSQu Wenruo * This functions checks prev_key->objectid, to ensure current key and prev_key 15980d7fd1eSQu Wenruo * share the same objectid as inode number. 16080d7fd1eSQu Wenruo * 16180d7fd1eSQu Wenruo * This is to detect missing INODE_ITEM in subvolume trees. 16280d7fd1eSQu Wenruo * 16380d7fd1eSQu Wenruo * Return true if everything is OK or we don't need to check. 16480d7fd1eSQu Wenruo * Return false if anything is wrong. 16580d7fd1eSQu Wenruo */ 16680d7fd1eSQu Wenruo static bool check_prev_ino(struct extent_buffer *leaf, 16780d7fd1eSQu Wenruo struct btrfs_key *key, int slot, 16880d7fd1eSQu Wenruo struct btrfs_key *prev_key) 16980d7fd1eSQu Wenruo { 17080d7fd1eSQu Wenruo /* No prev key, skip check */ 17180d7fd1eSQu Wenruo if (slot == 0) 17280d7fd1eSQu Wenruo return true; 17380d7fd1eSQu Wenruo 17480d7fd1eSQu Wenruo /* Only these key->types needs to be checked */ 17580d7fd1eSQu Wenruo ASSERT(key->type == BTRFS_XATTR_ITEM_KEY || 17680d7fd1eSQu Wenruo key->type == BTRFS_INODE_REF_KEY || 17780d7fd1eSQu Wenruo key->type == BTRFS_DIR_INDEX_KEY || 17880d7fd1eSQu Wenruo key->type == BTRFS_DIR_ITEM_KEY || 17980d7fd1eSQu Wenruo key->type == BTRFS_EXTENT_DATA_KEY); 18080d7fd1eSQu Wenruo 18180d7fd1eSQu Wenruo /* 18280d7fd1eSQu Wenruo * Only subvolume trees along with their reloc trees need this check. 18380d7fd1eSQu Wenruo * Things like log tree doesn't follow this ino requirement. 18480d7fd1eSQu Wenruo */ 18580d7fd1eSQu Wenruo if (!is_fstree(btrfs_header_owner(leaf))) 18680d7fd1eSQu Wenruo return true; 18780d7fd1eSQu Wenruo 18880d7fd1eSQu Wenruo if (key->objectid == prev_key->objectid) 18980d7fd1eSQu Wenruo return true; 19080d7fd1eSQu Wenruo 19180d7fd1eSQu Wenruo /* Error found */ 19280d7fd1eSQu Wenruo dir_item_err(leaf, slot, 19380d7fd1eSQu Wenruo "invalid previous key objectid, have %llu expect %llu", 19480d7fd1eSQu Wenruo prev_key->objectid, key->objectid); 19580d7fd1eSQu Wenruo return false; 19680d7fd1eSQu Wenruo } 197ae2a19d8SDavid Sterba static int check_extent_data_item(struct extent_buffer *leaf, 1984e9845efSFilipe Manana struct btrfs_key *key, int slot, 1994e9845efSFilipe Manana struct btrfs_key *prev_key) 200557ea5ddSQu Wenruo { 201ae2a19d8SDavid Sterba struct btrfs_fs_info *fs_info = leaf->fs_info; 202557ea5ddSQu Wenruo struct btrfs_file_extent_item *fi; 2032f659546SQu Wenruo u32 sectorsize = fs_info->sectorsize; 204557ea5ddSQu Wenruo u32 item_size = btrfs_item_size_nr(leaf, slot); 2054c094c33SQu Wenruo u64 extent_end; 206557ea5ddSQu Wenruo 207*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(key->offset, sectorsize))) { 2081fd715ffSDavid Sterba file_extent_err(leaf, slot, 2098806d718SQu Wenruo "unaligned file_offset for file extent, have %llu should be aligned to %u", 2108806d718SQu Wenruo key->offset, sectorsize); 211557ea5ddSQu Wenruo return -EUCLEAN; 212557ea5ddSQu Wenruo } 213557ea5ddSQu Wenruo 214c18679ebSQu Wenruo /* 215c18679ebSQu Wenruo * Previous key must have the same key->objectid (ino). 216c18679ebSQu Wenruo * It can be XATTR_ITEM, INODE_ITEM or just another EXTENT_DATA. 217c18679ebSQu Wenruo * But if objectids mismatch, it means we have a missing 218c18679ebSQu Wenruo * INODE_ITEM. 219c18679ebSQu Wenruo */ 220*c7c01a4aSDavid Sterba if (unlikely(!check_prev_ino(leaf, key, slot, prev_key))) 221c18679ebSQu Wenruo return -EUCLEAN; 222c18679ebSQu Wenruo 223557ea5ddSQu Wenruo fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); 224557ea5ddSQu Wenruo 225153a6d29SQu Wenruo /* 226153a6d29SQu Wenruo * Make sure the item contains at least inline header, so the file 227153a6d29SQu Wenruo * extent type is not some garbage. 228153a6d29SQu Wenruo */ 229*c7c01a4aSDavid Sterba if (unlikely(item_size < BTRFS_FILE_EXTENT_INLINE_DATA_START)) { 230153a6d29SQu Wenruo file_extent_err(leaf, slot, 231994bf9cdSAndreas Färber "invalid item size, have %u expect [%zu, %u)", 232153a6d29SQu Wenruo item_size, BTRFS_FILE_EXTENT_INLINE_DATA_START, 233153a6d29SQu Wenruo SZ_4K); 234153a6d29SQu Wenruo return -EUCLEAN; 235153a6d29SQu Wenruo } 236*c7c01a4aSDavid Sterba if (unlikely(btrfs_file_extent_type(leaf, fi) >= 237*c7c01a4aSDavid Sterba BTRFS_NR_FILE_EXTENT_TYPES)) { 2381fd715ffSDavid Sterba file_extent_err(leaf, slot, 2398806d718SQu Wenruo "invalid type for file extent, have %u expect range [0, %u]", 2408806d718SQu Wenruo btrfs_file_extent_type(leaf, fi), 241b9b1a53eSChengguang Xu BTRFS_NR_FILE_EXTENT_TYPES - 1); 242557ea5ddSQu Wenruo return -EUCLEAN; 243557ea5ddSQu Wenruo } 244557ea5ddSQu Wenruo 245557ea5ddSQu Wenruo /* 24652042d8eSAndrea Gelmini * Support for new compression/encryption must introduce incompat flag, 247557ea5ddSQu Wenruo * and must be caught in open_ctree(). 248557ea5ddSQu Wenruo */ 249*c7c01a4aSDavid Sterba if (unlikely(btrfs_file_extent_compression(leaf, fi) >= 250*c7c01a4aSDavid Sterba BTRFS_NR_COMPRESS_TYPES)) { 2511fd715ffSDavid Sterba file_extent_err(leaf, slot, 2528806d718SQu Wenruo "invalid compression for file extent, have %u expect range [0, %u]", 2538806d718SQu Wenruo btrfs_file_extent_compression(leaf, fi), 254ce96b7ffSChengguang Xu BTRFS_NR_COMPRESS_TYPES - 1); 255557ea5ddSQu Wenruo return -EUCLEAN; 256557ea5ddSQu Wenruo } 257*c7c01a4aSDavid Sterba if (unlikely(btrfs_file_extent_encryption(leaf, fi))) { 2581fd715ffSDavid Sterba file_extent_err(leaf, slot, 2598806d718SQu Wenruo "invalid encryption for file extent, have %u expect 0", 2608806d718SQu Wenruo btrfs_file_extent_encryption(leaf, fi)); 261557ea5ddSQu Wenruo return -EUCLEAN; 262557ea5ddSQu Wenruo } 263557ea5ddSQu Wenruo if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) { 264557ea5ddSQu Wenruo /* Inline extent must have 0 as key offset */ 265*c7c01a4aSDavid Sterba if (unlikely(key->offset)) { 2661fd715ffSDavid Sterba file_extent_err(leaf, slot, 2678806d718SQu Wenruo "invalid file_offset for inline file extent, have %llu expect 0", 2688806d718SQu Wenruo key->offset); 269557ea5ddSQu Wenruo return -EUCLEAN; 270557ea5ddSQu Wenruo } 271557ea5ddSQu Wenruo 272557ea5ddSQu Wenruo /* Compressed inline extent has no on-disk size, skip it */ 273557ea5ddSQu Wenruo if (btrfs_file_extent_compression(leaf, fi) != 274557ea5ddSQu Wenruo BTRFS_COMPRESS_NONE) 275557ea5ddSQu Wenruo return 0; 276557ea5ddSQu Wenruo 277557ea5ddSQu Wenruo /* Uncompressed inline extent size must match item size */ 278*c7c01a4aSDavid Sterba if (unlikely(item_size != BTRFS_FILE_EXTENT_INLINE_DATA_START + 279*c7c01a4aSDavid Sterba btrfs_file_extent_ram_bytes(leaf, fi))) { 2801fd715ffSDavid Sterba file_extent_err(leaf, slot, 2818806d718SQu Wenruo "invalid ram_bytes for uncompressed inline extent, have %u expect %llu", 2828806d718SQu Wenruo item_size, BTRFS_FILE_EXTENT_INLINE_DATA_START + 2838806d718SQu Wenruo btrfs_file_extent_ram_bytes(leaf, fi)); 284557ea5ddSQu Wenruo return -EUCLEAN; 285557ea5ddSQu Wenruo } 286557ea5ddSQu Wenruo return 0; 287557ea5ddSQu Wenruo } 288557ea5ddSQu Wenruo 289557ea5ddSQu Wenruo /* Regular or preallocated extent has fixed item size */ 290*c7c01a4aSDavid Sterba if (unlikely(item_size != sizeof(*fi))) { 2911fd715ffSDavid Sterba file_extent_err(leaf, slot, 292709a95c3SArnd Bergmann "invalid item size for reg/prealloc file extent, have %u expect %zu", 2938806d718SQu Wenruo item_size, sizeof(*fi)); 294557ea5ddSQu Wenruo return -EUCLEAN; 295557ea5ddSQu Wenruo } 296*c7c01a4aSDavid Sterba if (unlikely(CHECK_FE_ALIGNED(leaf, slot, fi, ram_bytes, sectorsize) || 297033774dcSDavid Sterba CHECK_FE_ALIGNED(leaf, slot, fi, disk_bytenr, sectorsize) || 298033774dcSDavid Sterba CHECK_FE_ALIGNED(leaf, slot, fi, disk_num_bytes, sectorsize) || 299033774dcSDavid Sterba CHECK_FE_ALIGNED(leaf, slot, fi, offset, sectorsize) || 300*c7c01a4aSDavid Sterba CHECK_FE_ALIGNED(leaf, slot, fi, num_bytes, sectorsize))) 301557ea5ddSQu Wenruo return -EUCLEAN; 3024e9845efSFilipe Manana 3034c094c33SQu Wenruo /* Catch extent end overflow */ 304*c7c01a4aSDavid Sterba if (unlikely(check_add_overflow(btrfs_file_extent_num_bytes(leaf, fi), 305*c7c01a4aSDavid Sterba key->offset, &extent_end))) { 3064c094c33SQu Wenruo file_extent_err(leaf, slot, 3074c094c33SQu Wenruo "extent end overflow, have file offset %llu extent num bytes %llu", 3084c094c33SQu Wenruo key->offset, 3094c094c33SQu Wenruo btrfs_file_extent_num_bytes(leaf, fi)); 3104c094c33SQu Wenruo return -EUCLEAN; 3114c094c33SQu Wenruo } 3124c094c33SQu Wenruo 3134e9845efSFilipe Manana /* 3144e9845efSFilipe Manana * Check that no two consecutive file extent items, in the same leaf, 3154e9845efSFilipe Manana * present ranges that overlap each other. 3164e9845efSFilipe Manana */ 3174e9845efSFilipe Manana if (slot > 0 && 3184e9845efSFilipe Manana prev_key->objectid == key->objectid && 3194e9845efSFilipe Manana prev_key->type == BTRFS_EXTENT_DATA_KEY) { 3204e9845efSFilipe Manana struct btrfs_file_extent_item *prev_fi; 3214e9845efSFilipe Manana u64 prev_end; 3224e9845efSFilipe Manana 3234e9845efSFilipe Manana prev_fi = btrfs_item_ptr(leaf, slot - 1, 3244e9845efSFilipe Manana struct btrfs_file_extent_item); 3254e9845efSFilipe Manana prev_end = file_extent_end(leaf, prev_key, prev_fi); 326*c7c01a4aSDavid Sterba if (unlikely(prev_end > key->offset)) { 3274e9845efSFilipe Manana file_extent_err(leaf, slot - 1, 3284e9845efSFilipe Manana "file extent end range (%llu) goes beyond start offset (%llu) of the next file extent", 3294e9845efSFilipe Manana prev_end, key->offset); 3304e9845efSFilipe Manana return -EUCLEAN; 3314e9845efSFilipe Manana } 3324e9845efSFilipe Manana } 3334e9845efSFilipe Manana 334557ea5ddSQu Wenruo return 0; 335557ea5ddSQu Wenruo } 336557ea5ddSQu Wenruo 33768128ce7SDavid Sterba static int check_csum_item(struct extent_buffer *leaf, struct btrfs_key *key, 338ad1d8c43SFilipe Manana int slot, struct btrfs_key *prev_key) 339557ea5ddSQu Wenruo { 34068128ce7SDavid Sterba struct btrfs_fs_info *fs_info = leaf->fs_info; 3412f659546SQu Wenruo u32 sectorsize = fs_info->sectorsize; 342223486c2SDavid Sterba const u32 csumsize = fs_info->csum_size; 343557ea5ddSQu Wenruo 344*c7c01a4aSDavid Sterba if (unlikely(key->objectid != BTRFS_EXTENT_CSUM_OBJECTID)) { 34586a6be3aSDavid Sterba generic_err(leaf, slot, 346d508c5f0SQu Wenruo "invalid key objectid for csum item, have %llu expect %llu", 347d508c5f0SQu Wenruo key->objectid, BTRFS_EXTENT_CSUM_OBJECTID); 348557ea5ddSQu Wenruo return -EUCLEAN; 349557ea5ddSQu Wenruo } 350*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(key->offset, sectorsize))) { 35186a6be3aSDavid Sterba generic_err(leaf, slot, 352d508c5f0SQu Wenruo "unaligned key offset for csum item, have %llu should be aligned to %u", 353d508c5f0SQu Wenruo key->offset, sectorsize); 354557ea5ddSQu Wenruo return -EUCLEAN; 355557ea5ddSQu Wenruo } 356*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(btrfs_item_size_nr(leaf, slot), csumsize))) { 35786a6be3aSDavid Sterba generic_err(leaf, slot, 358d508c5f0SQu Wenruo "unaligned item size for csum item, have %u should be aligned to %u", 359d508c5f0SQu Wenruo btrfs_item_size_nr(leaf, slot), csumsize); 360557ea5ddSQu Wenruo return -EUCLEAN; 361557ea5ddSQu Wenruo } 362ad1d8c43SFilipe Manana if (slot > 0 && prev_key->type == BTRFS_EXTENT_CSUM_KEY) { 363ad1d8c43SFilipe Manana u64 prev_csum_end; 364ad1d8c43SFilipe Manana u32 prev_item_size; 365ad1d8c43SFilipe Manana 366ad1d8c43SFilipe Manana prev_item_size = btrfs_item_size_nr(leaf, slot - 1); 367ad1d8c43SFilipe Manana prev_csum_end = (prev_item_size / csumsize) * sectorsize; 368ad1d8c43SFilipe Manana prev_csum_end += prev_key->offset; 369*c7c01a4aSDavid Sterba if (unlikely(prev_csum_end > key->offset)) { 370ad1d8c43SFilipe Manana generic_err(leaf, slot - 1, 371ad1d8c43SFilipe Manana "csum end range (%llu) goes beyond the start range (%llu) of the next csum item", 372ad1d8c43SFilipe Manana prev_csum_end, key->offset); 373ad1d8c43SFilipe Manana return -EUCLEAN; 374ad1d8c43SFilipe Manana } 375ad1d8c43SFilipe Manana } 376557ea5ddSQu Wenruo return 0; 377557ea5ddSQu Wenruo } 378557ea5ddSQu Wenruo 379c23c77b0SQu Wenruo /* Inode item error output has the same format as dir_item_err() */ 380c23c77b0SQu Wenruo #define inode_item_err(eb, slot, fmt, ...) \ 381c23c77b0SQu Wenruo dir_item_err(eb, slot, fmt, __VA_ARGS__) 382c23c77b0SQu Wenruo 383c23c77b0SQu Wenruo static int check_inode_key(struct extent_buffer *leaf, struct btrfs_key *key, 384c23c77b0SQu Wenruo int slot) 385c23c77b0SQu Wenruo { 386c23c77b0SQu Wenruo struct btrfs_key item_key; 387c23c77b0SQu Wenruo bool is_inode_item; 388c23c77b0SQu Wenruo 389c23c77b0SQu Wenruo btrfs_item_key_to_cpu(leaf, &item_key, slot); 390c23c77b0SQu Wenruo is_inode_item = (item_key.type == BTRFS_INODE_ITEM_KEY); 391c23c77b0SQu Wenruo 392c23c77b0SQu Wenruo /* For XATTR_ITEM, location key should be all 0 */ 393c23c77b0SQu Wenruo if (item_key.type == BTRFS_XATTR_ITEM_KEY) { 394*c7c01a4aSDavid Sterba if (unlikely(key->objectid != 0 || key->type != 0 || 395*c7c01a4aSDavid Sterba key->offset != 0)) 396c23c77b0SQu Wenruo return -EUCLEAN; 397c23c77b0SQu Wenruo return 0; 398c23c77b0SQu Wenruo } 399c23c77b0SQu Wenruo 400*c7c01a4aSDavid Sterba if (unlikely((key->objectid < BTRFS_FIRST_FREE_OBJECTID || 401c23c77b0SQu Wenruo key->objectid > BTRFS_LAST_FREE_OBJECTID) && 402c23c77b0SQu Wenruo key->objectid != BTRFS_ROOT_TREE_DIR_OBJECTID && 403*c7c01a4aSDavid Sterba key->objectid != BTRFS_FREE_INO_OBJECTID)) { 404c23c77b0SQu Wenruo if (is_inode_item) { 405c23c77b0SQu Wenruo generic_err(leaf, slot, 406c23c77b0SQu Wenruo "invalid key objectid: has %llu expect %llu or [%llu, %llu] or %llu", 407c23c77b0SQu Wenruo key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID, 408c23c77b0SQu Wenruo BTRFS_FIRST_FREE_OBJECTID, 409c23c77b0SQu Wenruo BTRFS_LAST_FREE_OBJECTID, 410c23c77b0SQu Wenruo BTRFS_FREE_INO_OBJECTID); 411c23c77b0SQu Wenruo } else { 412c23c77b0SQu Wenruo dir_item_err(leaf, slot, 413c23c77b0SQu Wenruo "invalid location key objectid: has %llu expect %llu or [%llu, %llu] or %llu", 414c23c77b0SQu Wenruo key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID, 415c23c77b0SQu Wenruo BTRFS_FIRST_FREE_OBJECTID, 416c23c77b0SQu Wenruo BTRFS_LAST_FREE_OBJECTID, 417c23c77b0SQu Wenruo BTRFS_FREE_INO_OBJECTID); 418c23c77b0SQu Wenruo } 419c23c77b0SQu Wenruo return -EUCLEAN; 420c23c77b0SQu Wenruo } 421*c7c01a4aSDavid Sterba if (unlikely(key->offset != 0)) { 422c23c77b0SQu Wenruo if (is_inode_item) 423c23c77b0SQu Wenruo inode_item_err(leaf, slot, 424c23c77b0SQu Wenruo "invalid key offset: has %llu expect 0", 425c23c77b0SQu Wenruo key->offset); 426c23c77b0SQu Wenruo else 427c23c77b0SQu Wenruo dir_item_err(leaf, slot, 428c23c77b0SQu Wenruo "invalid location key offset:has %llu expect 0", 429c23c77b0SQu Wenruo key->offset); 430c23c77b0SQu Wenruo return -EUCLEAN; 431c23c77b0SQu Wenruo } 432c23c77b0SQu Wenruo return 0; 433c23c77b0SQu Wenruo } 434c23c77b0SQu Wenruo 43557a0e674SQu Wenruo static int check_root_key(struct extent_buffer *leaf, struct btrfs_key *key, 43657a0e674SQu Wenruo int slot) 43757a0e674SQu Wenruo { 43857a0e674SQu Wenruo struct btrfs_key item_key; 43957a0e674SQu Wenruo bool is_root_item; 44057a0e674SQu Wenruo 44157a0e674SQu Wenruo btrfs_item_key_to_cpu(leaf, &item_key, slot); 44257a0e674SQu Wenruo is_root_item = (item_key.type == BTRFS_ROOT_ITEM_KEY); 44357a0e674SQu Wenruo 44457a0e674SQu Wenruo /* No such tree id */ 445*c7c01a4aSDavid Sterba if (unlikely(key->objectid == 0)) { 44657a0e674SQu Wenruo if (is_root_item) 44757a0e674SQu Wenruo generic_err(leaf, slot, "invalid root id 0"); 44857a0e674SQu Wenruo else 44957a0e674SQu Wenruo dir_item_err(leaf, slot, 45057a0e674SQu Wenruo "invalid location key root id 0"); 45157a0e674SQu Wenruo return -EUCLEAN; 45257a0e674SQu Wenruo } 45357a0e674SQu Wenruo 45457a0e674SQu Wenruo /* DIR_ITEM/INDEX/INODE_REF is not allowed to point to non-fs trees */ 455*c7c01a4aSDavid Sterba if (unlikely(!is_fstree(key->objectid) && !is_root_item)) { 45657a0e674SQu Wenruo dir_item_err(leaf, slot, 45757a0e674SQu Wenruo "invalid location key objectid, have %llu expect [%llu, %llu]", 45857a0e674SQu Wenruo key->objectid, BTRFS_FIRST_FREE_OBJECTID, 45957a0e674SQu Wenruo BTRFS_LAST_FREE_OBJECTID); 46057a0e674SQu Wenruo return -EUCLEAN; 46157a0e674SQu Wenruo } 46257a0e674SQu Wenruo 46357a0e674SQu Wenruo /* 46457a0e674SQu Wenruo * ROOT_ITEM with non-zero offset means this is a snapshot, created at 46557a0e674SQu Wenruo * @offset transid. 46657a0e674SQu Wenruo * Furthermore, for location key in DIR_ITEM, its offset is always -1. 46757a0e674SQu Wenruo * 46857a0e674SQu Wenruo * So here we only check offset for reloc tree whose key->offset must 46957a0e674SQu Wenruo * be a valid tree. 47057a0e674SQu Wenruo */ 471*c7c01a4aSDavid Sterba if (unlikely(key->objectid == BTRFS_TREE_RELOC_OBJECTID && 472*c7c01a4aSDavid Sterba key->offset == 0)) { 47357a0e674SQu Wenruo generic_err(leaf, slot, "invalid root id 0 for reloc tree"); 47457a0e674SQu Wenruo return -EUCLEAN; 47557a0e674SQu Wenruo } 47657a0e674SQu Wenruo return 0; 47757a0e674SQu Wenruo } 47857a0e674SQu Wenruo 479ce4252c0SDavid Sterba static int check_dir_item(struct extent_buffer *leaf, 480c18679ebSQu Wenruo struct btrfs_key *key, struct btrfs_key *prev_key, 481c18679ebSQu Wenruo int slot) 482ad7b0368SQu Wenruo { 483ce4252c0SDavid Sterba struct btrfs_fs_info *fs_info = leaf->fs_info; 484ad7b0368SQu Wenruo struct btrfs_dir_item *di; 485ad7b0368SQu Wenruo u32 item_size = btrfs_item_size_nr(leaf, slot); 486ad7b0368SQu Wenruo u32 cur = 0; 487ad7b0368SQu Wenruo 488*c7c01a4aSDavid Sterba if (unlikely(!check_prev_ino(leaf, key, slot, prev_key))) 489c18679ebSQu Wenruo return -EUCLEAN; 490*c7c01a4aSDavid Sterba 491ad7b0368SQu Wenruo di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item); 492ad7b0368SQu Wenruo while (cur < item_size) { 493147a097cSQu Wenruo struct btrfs_key location_key; 494ad7b0368SQu Wenruo u32 name_len; 495ad7b0368SQu Wenruo u32 data_len; 496ad7b0368SQu Wenruo u32 max_name_len; 497ad7b0368SQu Wenruo u32 total_size; 498ad7b0368SQu Wenruo u32 name_hash; 499ad7b0368SQu Wenruo u8 dir_type; 500147a097cSQu Wenruo int ret; 501ad7b0368SQu Wenruo 502ad7b0368SQu Wenruo /* header itself should not cross item boundary */ 503*c7c01a4aSDavid Sterba if (unlikely(cur + sizeof(*di) > item_size)) { 504d98ced68SDavid Sterba dir_item_err(leaf, slot, 5057cfad652SArnd Bergmann "dir item header crosses item boundary, have %zu boundary %u", 506ad7b0368SQu Wenruo cur + sizeof(*di), item_size); 507ad7b0368SQu Wenruo return -EUCLEAN; 508ad7b0368SQu Wenruo } 509ad7b0368SQu Wenruo 510147a097cSQu Wenruo /* Location key check */ 511147a097cSQu Wenruo btrfs_dir_item_key_to_cpu(leaf, di, &location_key); 512147a097cSQu Wenruo if (location_key.type == BTRFS_ROOT_ITEM_KEY) { 513147a097cSQu Wenruo ret = check_root_key(leaf, &location_key, slot); 514*c7c01a4aSDavid Sterba if (unlikely(ret < 0)) 515147a097cSQu Wenruo return ret; 516147a097cSQu Wenruo } else if (location_key.type == BTRFS_INODE_ITEM_KEY || 517147a097cSQu Wenruo location_key.type == 0) { 518147a097cSQu Wenruo ret = check_inode_key(leaf, &location_key, slot); 519*c7c01a4aSDavid Sterba if (unlikely(ret < 0)) 520147a097cSQu Wenruo return ret; 521147a097cSQu Wenruo } else { 522147a097cSQu Wenruo dir_item_err(leaf, slot, 523147a097cSQu Wenruo "invalid location key type, have %u, expect %u or %u", 524147a097cSQu Wenruo location_key.type, BTRFS_ROOT_ITEM_KEY, 525147a097cSQu Wenruo BTRFS_INODE_ITEM_KEY); 526147a097cSQu Wenruo return -EUCLEAN; 527147a097cSQu Wenruo } 528147a097cSQu Wenruo 529ad7b0368SQu Wenruo /* dir type check */ 530ad7b0368SQu Wenruo dir_type = btrfs_dir_type(leaf, di); 531*c7c01a4aSDavid Sterba if (unlikely(dir_type >= BTRFS_FT_MAX)) { 532d98ced68SDavid Sterba dir_item_err(leaf, slot, 533ad7b0368SQu Wenruo "invalid dir item type, have %u expect [0, %u)", 534ad7b0368SQu Wenruo dir_type, BTRFS_FT_MAX); 535ad7b0368SQu Wenruo return -EUCLEAN; 536ad7b0368SQu Wenruo } 537ad7b0368SQu Wenruo 538*c7c01a4aSDavid Sterba if (unlikely(key->type == BTRFS_XATTR_ITEM_KEY && 539*c7c01a4aSDavid Sterba dir_type != BTRFS_FT_XATTR)) { 540d98ced68SDavid Sterba dir_item_err(leaf, slot, 541ad7b0368SQu Wenruo "invalid dir item type for XATTR key, have %u expect %u", 542ad7b0368SQu Wenruo dir_type, BTRFS_FT_XATTR); 543ad7b0368SQu Wenruo return -EUCLEAN; 544ad7b0368SQu Wenruo } 545*c7c01a4aSDavid Sterba if (unlikely(dir_type == BTRFS_FT_XATTR && 546*c7c01a4aSDavid Sterba key->type != BTRFS_XATTR_ITEM_KEY)) { 547d98ced68SDavid Sterba dir_item_err(leaf, slot, 548ad7b0368SQu Wenruo "xattr dir type found for non-XATTR key"); 549ad7b0368SQu Wenruo return -EUCLEAN; 550ad7b0368SQu Wenruo } 551ad7b0368SQu Wenruo if (dir_type == BTRFS_FT_XATTR) 552ad7b0368SQu Wenruo max_name_len = XATTR_NAME_MAX; 553ad7b0368SQu Wenruo else 554ad7b0368SQu Wenruo max_name_len = BTRFS_NAME_LEN; 555ad7b0368SQu Wenruo 556ad7b0368SQu Wenruo /* Name/data length check */ 557ad7b0368SQu Wenruo name_len = btrfs_dir_name_len(leaf, di); 558ad7b0368SQu Wenruo data_len = btrfs_dir_data_len(leaf, di); 559*c7c01a4aSDavid Sterba if (unlikely(name_len > max_name_len)) { 560d98ced68SDavid Sterba dir_item_err(leaf, slot, 561ad7b0368SQu Wenruo "dir item name len too long, have %u max %u", 562ad7b0368SQu Wenruo name_len, max_name_len); 563ad7b0368SQu Wenruo return -EUCLEAN; 564ad7b0368SQu Wenruo } 565*c7c01a4aSDavid Sterba if (unlikely(name_len + data_len > BTRFS_MAX_XATTR_SIZE(fs_info))) { 566d98ced68SDavid Sterba dir_item_err(leaf, slot, 567ad7b0368SQu Wenruo "dir item name and data len too long, have %u max %u", 568ad7b0368SQu Wenruo name_len + data_len, 5692f659546SQu Wenruo BTRFS_MAX_XATTR_SIZE(fs_info)); 570ad7b0368SQu Wenruo return -EUCLEAN; 571ad7b0368SQu Wenruo } 572ad7b0368SQu Wenruo 573*c7c01a4aSDavid Sterba if (unlikely(data_len && dir_type != BTRFS_FT_XATTR)) { 574d98ced68SDavid Sterba dir_item_err(leaf, slot, 575ad7b0368SQu Wenruo "dir item with invalid data len, have %u expect 0", 576ad7b0368SQu Wenruo data_len); 577ad7b0368SQu Wenruo return -EUCLEAN; 578ad7b0368SQu Wenruo } 579ad7b0368SQu Wenruo 580ad7b0368SQu Wenruo total_size = sizeof(*di) + name_len + data_len; 581ad7b0368SQu Wenruo 582ad7b0368SQu Wenruo /* header and name/data should not cross item boundary */ 583*c7c01a4aSDavid Sterba if (unlikely(cur + total_size > item_size)) { 584d98ced68SDavid Sterba dir_item_err(leaf, slot, 585ad7b0368SQu Wenruo "dir item data crosses item boundary, have %u boundary %u", 586ad7b0368SQu Wenruo cur + total_size, item_size); 587ad7b0368SQu Wenruo return -EUCLEAN; 588ad7b0368SQu Wenruo } 589ad7b0368SQu Wenruo 590ad7b0368SQu Wenruo /* 591ad7b0368SQu Wenruo * Special check for XATTR/DIR_ITEM, as key->offset is name 592ad7b0368SQu Wenruo * hash, should match its name 593ad7b0368SQu Wenruo */ 594ad7b0368SQu Wenruo if (key->type == BTRFS_DIR_ITEM_KEY || 595ad7b0368SQu Wenruo key->type == BTRFS_XATTR_ITEM_KEY) { 596e2683fc9SDavid Sterba char namebuf[max(BTRFS_NAME_LEN, XATTR_NAME_MAX)]; 597e2683fc9SDavid Sterba 598ad7b0368SQu Wenruo read_extent_buffer(leaf, namebuf, 599ad7b0368SQu Wenruo (unsigned long)(di + 1), name_len); 600ad7b0368SQu Wenruo name_hash = btrfs_name_hash(namebuf, name_len); 601*c7c01a4aSDavid Sterba if (unlikely(key->offset != name_hash)) { 602d98ced68SDavid Sterba dir_item_err(leaf, slot, 603ad7b0368SQu Wenruo "name hash mismatch with key, have 0x%016x expect 0x%016llx", 604ad7b0368SQu Wenruo name_hash, key->offset); 605ad7b0368SQu Wenruo return -EUCLEAN; 606ad7b0368SQu Wenruo } 607ad7b0368SQu Wenruo } 608ad7b0368SQu Wenruo cur += total_size; 609ad7b0368SQu Wenruo di = (struct btrfs_dir_item *)((void *)di + total_size); 610ad7b0368SQu Wenruo } 611ad7b0368SQu Wenruo return 0; 612ad7b0368SQu Wenruo } 613ad7b0368SQu Wenruo 6144806bd88SDavid Sterba __printf(3, 4) 615fce466eaSQu Wenruo __cold 6164806bd88SDavid Sterba static void block_group_err(const struct extent_buffer *eb, int slot, 617fce466eaSQu Wenruo const char *fmt, ...) 618fce466eaSQu Wenruo { 6194806bd88SDavid Sterba const struct btrfs_fs_info *fs_info = eb->fs_info; 620fce466eaSQu Wenruo struct btrfs_key key; 621fce466eaSQu Wenruo struct va_format vaf; 622fce466eaSQu Wenruo va_list args; 623fce466eaSQu Wenruo 624fce466eaSQu Wenruo btrfs_item_key_to_cpu(eb, &key, slot); 625fce466eaSQu Wenruo va_start(args, fmt); 626fce466eaSQu Wenruo 627fce466eaSQu Wenruo vaf.fmt = fmt; 628fce466eaSQu Wenruo vaf.va = &args; 629fce466eaSQu Wenruo 630fce466eaSQu Wenruo btrfs_crit(fs_info, 631fce466eaSQu Wenruo "corrupt %s: root=%llu block=%llu slot=%d bg_start=%llu bg_len=%llu, %pV", 632fce466eaSQu Wenruo btrfs_header_level(eb) == 0 ? "leaf" : "node", 633fce466eaSQu Wenruo btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, 634fce466eaSQu Wenruo key.objectid, key.offset, &vaf); 635fce466eaSQu Wenruo va_end(args); 636fce466eaSQu Wenruo } 637fce466eaSQu Wenruo 638af60ce2bSDavid Sterba static int check_block_group_item(struct extent_buffer *leaf, 639fce466eaSQu Wenruo struct btrfs_key *key, int slot) 640fce466eaSQu Wenruo { 641fce466eaSQu Wenruo struct btrfs_block_group_item bgi; 642fce466eaSQu Wenruo u32 item_size = btrfs_item_size_nr(leaf, slot); 643fce466eaSQu Wenruo u64 flags; 644fce466eaSQu Wenruo u64 type; 645fce466eaSQu Wenruo 646fce466eaSQu Wenruo /* 647fce466eaSQu Wenruo * Here we don't really care about alignment since extent allocator can 64810950929SQu Wenruo * handle it. We care more about the size. 649fce466eaSQu Wenruo */ 650*c7c01a4aSDavid Sterba if (unlikely(key->offset == 0)) { 6514806bd88SDavid Sterba block_group_err(leaf, slot, 65210950929SQu Wenruo "invalid block group size 0"); 653fce466eaSQu Wenruo return -EUCLEAN; 654fce466eaSQu Wenruo } 655fce466eaSQu Wenruo 656*c7c01a4aSDavid Sterba if (unlikely(item_size != sizeof(bgi))) { 6574806bd88SDavid Sterba block_group_err(leaf, slot, 658fce466eaSQu Wenruo "invalid item size, have %u expect %zu", 659fce466eaSQu Wenruo item_size, sizeof(bgi)); 660fce466eaSQu Wenruo return -EUCLEAN; 661fce466eaSQu Wenruo } 662fce466eaSQu Wenruo 663fce466eaSQu Wenruo read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot), 664fce466eaSQu Wenruo sizeof(bgi)); 665*c7c01a4aSDavid Sterba if (unlikely(btrfs_stack_block_group_chunk_objectid(&bgi) != 666*c7c01a4aSDavid Sterba BTRFS_FIRST_CHUNK_TREE_OBJECTID)) { 6674806bd88SDavid Sterba block_group_err(leaf, slot, 668fce466eaSQu Wenruo "invalid block group chunk objectid, have %llu expect %llu", 669de0dc456SDavid Sterba btrfs_stack_block_group_chunk_objectid(&bgi), 670fce466eaSQu Wenruo BTRFS_FIRST_CHUNK_TREE_OBJECTID); 671fce466eaSQu Wenruo return -EUCLEAN; 672fce466eaSQu Wenruo } 673fce466eaSQu Wenruo 674*c7c01a4aSDavid Sterba if (unlikely(btrfs_stack_block_group_used(&bgi) > key->offset)) { 6754806bd88SDavid Sterba block_group_err(leaf, slot, 676fce466eaSQu Wenruo "invalid block group used, have %llu expect [0, %llu)", 677de0dc456SDavid Sterba btrfs_stack_block_group_used(&bgi), key->offset); 678fce466eaSQu Wenruo return -EUCLEAN; 679fce466eaSQu Wenruo } 680fce466eaSQu Wenruo 681de0dc456SDavid Sterba flags = btrfs_stack_block_group_flags(&bgi); 682*c7c01a4aSDavid Sterba if (unlikely(hweight64(flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) > 1)) { 6834806bd88SDavid Sterba block_group_err(leaf, slot, 684fce466eaSQu Wenruo "invalid profile flags, have 0x%llx (%lu bits set) expect no more than 1 bit set", 685fce466eaSQu Wenruo flags & BTRFS_BLOCK_GROUP_PROFILE_MASK, 686fce466eaSQu Wenruo hweight64(flags & BTRFS_BLOCK_GROUP_PROFILE_MASK)); 687fce466eaSQu Wenruo return -EUCLEAN; 688fce466eaSQu Wenruo } 689fce466eaSQu Wenruo 690fce466eaSQu Wenruo type = flags & BTRFS_BLOCK_GROUP_TYPE_MASK; 691*c7c01a4aSDavid Sterba if (unlikely(type != BTRFS_BLOCK_GROUP_DATA && 692fce466eaSQu Wenruo type != BTRFS_BLOCK_GROUP_METADATA && 693fce466eaSQu Wenruo type != BTRFS_BLOCK_GROUP_SYSTEM && 694fce466eaSQu Wenruo type != (BTRFS_BLOCK_GROUP_METADATA | 695*c7c01a4aSDavid Sterba BTRFS_BLOCK_GROUP_DATA))) { 6964806bd88SDavid Sterba block_group_err(leaf, slot, 697761333f2SShaokun Zhang "invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx or 0x%llx", 698fce466eaSQu Wenruo type, hweight64(type), 699fce466eaSQu Wenruo BTRFS_BLOCK_GROUP_DATA, BTRFS_BLOCK_GROUP_METADATA, 700fce466eaSQu Wenruo BTRFS_BLOCK_GROUP_SYSTEM, 701fce466eaSQu Wenruo BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA); 702fce466eaSQu Wenruo return -EUCLEAN; 703fce466eaSQu Wenruo } 704fce466eaSQu Wenruo return 0; 705fce466eaSQu Wenruo } 706fce466eaSQu Wenruo 707d001e4a3SDavid Sterba __printf(4, 5) 708f1140243SQu Wenruo __cold 709d001e4a3SDavid Sterba static void chunk_err(const struct extent_buffer *leaf, 710f1140243SQu Wenruo const struct btrfs_chunk *chunk, u64 logical, 711f1140243SQu Wenruo const char *fmt, ...) 712f1140243SQu Wenruo { 713d001e4a3SDavid Sterba const struct btrfs_fs_info *fs_info = leaf->fs_info; 714f1140243SQu Wenruo bool is_sb; 715f1140243SQu Wenruo struct va_format vaf; 716f1140243SQu Wenruo va_list args; 717f1140243SQu Wenruo int i; 718f1140243SQu Wenruo int slot = -1; 719f1140243SQu Wenruo 720f1140243SQu Wenruo /* Only superblock eb is able to have such small offset */ 721f1140243SQu Wenruo is_sb = (leaf->start == BTRFS_SUPER_INFO_OFFSET); 722f1140243SQu Wenruo 723f1140243SQu Wenruo if (!is_sb) { 724f1140243SQu Wenruo /* 725f1140243SQu Wenruo * Get the slot number by iterating through all slots, this 726f1140243SQu Wenruo * would provide better readability. 727f1140243SQu Wenruo */ 728f1140243SQu Wenruo for (i = 0; i < btrfs_header_nritems(leaf); i++) { 729f1140243SQu Wenruo if (btrfs_item_ptr_offset(leaf, i) == 730f1140243SQu Wenruo (unsigned long)chunk) { 731f1140243SQu Wenruo slot = i; 732f1140243SQu Wenruo break; 733f1140243SQu Wenruo } 734f1140243SQu Wenruo } 735f1140243SQu Wenruo } 736f1140243SQu Wenruo va_start(args, fmt); 737f1140243SQu Wenruo vaf.fmt = fmt; 738f1140243SQu Wenruo vaf.va = &args; 739f1140243SQu Wenruo 740f1140243SQu Wenruo if (is_sb) 741f1140243SQu Wenruo btrfs_crit(fs_info, 742f1140243SQu Wenruo "corrupt superblock syschunk array: chunk_start=%llu, %pV", 743f1140243SQu Wenruo logical, &vaf); 744f1140243SQu Wenruo else 745f1140243SQu Wenruo btrfs_crit(fs_info, 746f1140243SQu Wenruo "corrupt leaf: root=%llu block=%llu slot=%d chunk_start=%llu, %pV", 747f1140243SQu Wenruo BTRFS_CHUNK_TREE_OBJECTID, leaf->start, slot, 748f1140243SQu Wenruo logical, &vaf); 749f1140243SQu Wenruo va_end(args); 750f1140243SQu Wenruo } 751f1140243SQu Wenruo 752ad7b0368SQu Wenruo /* 75382fc28fbSQu Wenruo * The common chunk check which could also work on super block sys chunk array. 75482fc28fbSQu Wenruo * 755bf871c3bSQu Wenruo * Return -EUCLEAN if anything is corrupted. 75682fc28fbSQu Wenruo * Return 0 if everything is OK. 75782fc28fbSQu Wenruo */ 758ddaf1d5aSDavid Sterba int btrfs_check_chunk_valid(struct extent_buffer *leaf, 75982fc28fbSQu Wenruo struct btrfs_chunk *chunk, u64 logical) 76082fc28fbSQu Wenruo { 761ddaf1d5aSDavid Sterba struct btrfs_fs_info *fs_info = leaf->fs_info; 76282fc28fbSQu Wenruo u64 length; 76382fc28fbSQu Wenruo u64 stripe_len; 76482fc28fbSQu Wenruo u16 num_stripes; 76582fc28fbSQu Wenruo u16 sub_stripes; 76682fc28fbSQu Wenruo u64 type; 76782fc28fbSQu Wenruo u64 features; 76882fc28fbSQu Wenruo bool mixed = false; 76985d07fbeSDaniel Xu int raid_index; 77085d07fbeSDaniel Xu int nparity; 77185d07fbeSDaniel Xu int ncopies; 77282fc28fbSQu Wenruo 77382fc28fbSQu Wenruo length = btrfs_chunk_length(leaf, chunk); 77482fc28fbSQu Wenruo stripe_len = btrfs_chunk_stripe_len(leaf, chunk); 77582fc28fbSQu Wenruo num_stripes = btrfs_chunk_num_stripes(leaf, chunk); 77682fc28fbSQu Wenruo sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk); 77782fc28fbSQu Wenruo type = btrfs_chunk_type(leaf, chunk); 77885d07fbeSDaniel Xu raid_index = btrfs_bg_flags_to_raid_index(type); 77985d07fbeSDaniel Xu ncopies = btrfs_raid_array[raid_index].ncopies; 78085d07fbeSDaniel Xu nparity = btrfs_raid_array[raid_index].nparity; 78182fc28fbSQu Wenruo 782*c7c01a4aSDavid Sterba if (unlikely(!num_stripes)) { 783d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 784f1140243SQu Wenruo "invalid chunk num_stripes, have %u", num_stripes); 785bf871c3bSQu Wenruo return -EUCLEAN; 78682fc28fbSQu Wenruo } 787*c7c01a4aSDavid Sterba if (unlikely(num_stripes < ncopies)) { 78885d07fbeSDaniel Xu chunk_err(leaf, chunk, logical, 78985d07fbeSDaniel Xu "invalid chunk num_stripes < ncopies, have %u < %d", 79085d07fbeSDaniel Xu num_stripes, ncopies); 79185d07fbeSDaniel Xu return -EUCLEAN; 79285d07fbeSDaniel Xu } 793*c7c01a4aSDavid Sterba if (unlikely(nparity && num_stripes == nparity)) { 79485d07fbeSDaniel Xu chunk_err(leaf, chunk, logical, 79585d07fbeSDaniel Xu "invalid chunk num_stripes == nparity, have %u == %d", 79685d07fbeSDaniel Xu num_stripes, nparity); 79785d07fbeSDaniel Xu return -EUCLEAN; 79885d07fbeSDaniel Xu } 799*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(logical, fs_info->sectorsize))) { 800d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 801f1140243SQu Wenruo "invalid chunk logical, have %llu should aligned to %u", 802f1140243SQu Wenruo logical, fs_info->sectorsize); 803bf871c3bSQu Wenruo return -EUCLEAN; 80482fc28fbSQu Wenruo } 805*c7c01a4aSDavid Sterba if (unlikely(btrfs_chunk_sector_size(leaf, chunk) != fs_info->sectorsize)) { 806d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 807f1140243SQu Wenruo "invalid chunk sectorsize, have %u expect %u", 808f1140243SQu Wenruo btrfs_chunk_sector_size(leaf, chunk), 809f1140243SQu Wenruo fs_info->sectorsize); 810bf871c3bSQu Wenruo return -EUCLEAN; 81182fc28fbSQu Wenruo } 812*c7c01a4aSDavid Sterba if (unlikely(!length || !IS_ALIGNED(length, fs_info->sectorsize))) { 813d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 814f1140243SQu Wenruo "invalid chunk length, have %llu", length); 815bf871c3bSQu Wenruo return -EUCLEAN; 81682fc28fbSQu Wenruo } 817*c7c01a4aSDavid Sterba if (unlikely(!is_power_of_2(stripe_len) || stripe_len != BTRFS_STRIPE_LEN)) { 818d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 819f1140243SQu Wenruo "invalid chunk stripe length: %llu", 82082fc28fbSQu Wenruo stripe_len); 821bf871c3bSQu Wenruo return -EUCLEAN; 82282fc28fbSQu Wenruo } 823*c7c01a4aSDavid Sterba if (unlikely(type & ~(BTRFS_BLOCK_GROUP_TYPE_MASK | 824*c7c01a4aSDavid Sterba BTRFS_BLOCK_GROUP_PROFILE_MASK))) { 825d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 826f1140243SQu Wenruo "unrecognized chunk type: 0x%llx", 82782fc28fbSQu Wenruo ~(BTRFS_BLOCK_GROUP_TYPE_MASK | 82882fc28fbSQu Wenruo BTRFS_BLOCK_GROUP_PROFILE_MASK) & 82982fc28fbSQu Wenruo btrfs_chunk_type(leaf, chunk)); 830bf871c3bSQu Wenruo return -EUCLEAN; 83182fc28fbSQu Wenruo } 83282fc28fbSQu Wenruo 833*c7c01a4aSDavid Sterba if (unlikely(!has_single_bit_set(type & BTRFS_BLOCK_GROUP_PROFILE_MASK) && 834*c7c01a4aSDavid Sterba (type & BTRFS_BLOCK_GROUP_PROFILE_MASK) != 0)) { 835d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 83680e46cf2SQu Wenruo "invalid chunk profile flag: 0x%llx, expect 0 or 1 bit set", 83780e46cf2SQu Wenruo type & BTRFS_BLOCK_GROUP_PROFILE_MASK); 83880e46cf2SQu Wenruo return -EUCLEAN; 83980e46cf2SQu Wenruo } 840*c7c01a4aSDavid Sterba if (unlikely((type & BTRFS_BLOCK_GROUP_TYPE_MASK) == 0)) { 841d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 842f1140243SQu Wenruo "missing chunk type flag, have 0x%llx one bit must be set in 0x%llx", 843f1140243SQu Wenruo type, BTRFS_BLOCK_GROUP_TYPE_MASK); 844bf871c3bSQu Wenruo return -EUCLEAN; 84582fc28fbSQu Wenruo } 84682fc28fbSQu Wenruo 847*c7c01a4aSDavid Sterba if (unlikely((type & BTRFS_BLOCK_GROUP_SYSTEM) && 848*c7c01a4aSDavid Sterba (type & (BTRFS_BLOCK_GROUP_METADATA | 849*c7c01a4aSDavid Sterba BTRFS_BLOCK_GROUP_DATA)))) { 850d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 851f1140243SQu Wenruo "system chunk with data or metadata type: 0x%llx", 852f1140243SQu Wenruo type); 853bf871c3bSQu Wenruo return -EUCLEAN; 85482fc28fbSQu Wenruo } 85582fc28fbSQu Wenruo 85682fc28fbSQu Wenruo features = btrfs_super_incompat_flags(fs_info->super_copy); 85782fc28fbSQu Wenruo if (features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) 85882fc28fbSQu Wenruo mixed = true; 85982fc28fbSQu Wenruo 86082fc28fbSQu Wenruo if (!mixed) { 861*c7c01a4aSDavid Sterba if (unlikely((type & BTRFS_BLOCK_GROUP_METADATA) && 862*c7c01a4aSDavid Sterba (type & BTRFS_BLOCK_GROUP_DATA))) { 863d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 86482fc28fbSQu Wenruo "mixed chunk type in non-mixed mode: 0x%llx", type); 865bf871c3bSQu Wenruo return -EUCLEAN; 86682fc28fbSQu Wenruo } 86782fc28fbSQu Wenruo } 86882fc28fbSQu Wenruo 869*c7c01a4aSDavid Sterba if (unlikely((type & BTRFS_BLOCK_GROUP_RAID10 && sub_stripes != 2) || 87082fc28fbSQu Wenruo (type & BTRFS_BLOCK_GROUP_RAID1 && num_stripes != 2) || 87182fc28fbSQu Wenruo (type & BTRFS_BLOCK_GROUP_RAID5 && num_stripes < 2) || 87282fc28fbSQu Wenruo (type & BTRFS_BLOCK_GROUP_RAID6 && num_stripes < 3) || 87382fc28fbSQu Wenruo (type & BTRFS_BLOCK_GROUP_DUP && num_stripes != 2) || 874*c7c01a4aSDavid Sterba ((type & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 && 875*c7c01a4aSDavid Sterba num_stripes != 1))) { 876d001e4a3SDavid Sterba chunk_err(leaf, chunk, logical, 87782fc28fbSQu Wenruo "invalid num_stripes:sub_stripes %u:%u for profile %llu", 87882fc28fbSQu Wenruo num_stripes, sub_stripes, 87982fc28fbSQu Wenruo type & BTRFS_BLOCK_GROUP_PROFILE_MASK); 880bf871c3bSQu Wenruo return -EUCLEAN; 88182fc28fbSQu Wenruo } 88282fc28fbSQu Wenruo 88382fc28fbSQu Wenruo return 0; 88482fc28fbSQu Wenruo } 88582fc28fbSQu Wenruo 886f6d2a5c2SQu Wenruo /* 887f6d2a5c2SQu Wenruo * Enhanced version of chunk item checker. 888f6d2a5c2SQu Wenruo * 889f6d2a5c2SQu Wenruo * The common btrfs_check_chunk_valid() doesn't check item size since it needs 890f6d2a5c2SQu Wenruo * to work on super block sys_chunk_array which doesn't have full item ptr. 891f6d2a5c2SQu Wenruo */ 892f6d2a5c2SQu Wenruo static int check_leaf_chunk_item(struct extent_buffer *leaf, 893f6d2a5c2SQu Wenruo struct btrfs_chunk *chunk, 894f6d2a5c2SQu Wenruo struct btrfs_key *key, int slot) 895f6d2a5c2SQu Wenruo { 896f6d2a5c2SQu Wenruo int num_stripes; 897f6d2a5c2SQu Wenruo 898*c7c01a4aSDavid Sterba if (unlikely(btrfs_item_size_nr(leaf, slot) < sizeof(struct btrfs_chunk))) { 899f6d2a5c2SQu Wenruo chunk_err(leaf, chunk, key->offset, 900f6d2a5c2SQu Wenruo "invalid chunk item size: have %u expect [%zu, %u)", 901f6d2a5c2SQu Wenruo btrfs_item_size_nr(leaf, slot), 902f6d2a5c2SQu Wenruo sizeof(struct btrfs_chunk), 903f6d2a5c2SQu Wenruo BTRFS_LEAF_DATA_SIZE(leaf->fs_info)); 904f6d2a5c2SQu Wenruo return -EUCLEAN; 905f6d2a5c2SQu Wenruo } 906f6d2a5c2SQu Wenruo 907f6d2a5c2SQu Wenruo num_stripes = btrfs_chunk_num_stripes(leaf, chunk); 908f6d2a5c2SQu Wenruo /* Let btrfs_check_chunk_valid() handle this error type */ 909f6d2a5c2SQu Wenruo if (num_stripes == 0) 910f6d2a5c2SQu Wenruo goto out; 911f6d2a5c2SQu Wenruo 912*c7c01a4aSDavid Sterba if (unlikely(btrfs_chunk_item_size(num_stripes) != 913*c7c01a4aSDavid Sterba btrfs_item_size_nr(leaf, slot))) { 914f6d2a5c2SQu Wenruo chunk_err(leaf, chunk, key->offset, 915f6d2a5c2SQu Wenruo "invalid chunk item size: have %u expect %lu", 916f6d2a5c2SQu Wenruo btrfs_item_size_nr(leaf, slot), 917f6d2a5c2SQu Wenruo btrfs_chunk_item_size(num_stripes)); 918f6d2a5c2SQu Wenruo return -EUCLEAN; 919f6d2a5c2SQu Wenruo } 920f6d2a5c2SQu Wenruo out: 921f6d2a5c2SQu Wenruo return btrfs_check_chunk_valid(leaf, chunk, key->offset); 922f6d2a5c2SQu Wenruo } 923f6d2a5c2SQu Wenruo 9245617ed80SDavid Sterba __printf(3, 4) 925ab4ba2e1SQu Wenruo __cold 9265617ed80SDavid Sterba static void dev_item_err(const struct extent_buffer *eb, int slot, 927ab4ba2e1SQu Wenruo const char *fmt, ...) 928ab4ba2e1SQu Wenruo { 929ab4ba2e1SQu Wenruo struct btrfs_key key; 930ab4ba2e1SQu Wenruo struct va_format vaf; 931ab4ba2e1SQu Wenruo va_list args; 932ab4ba2e1SQu Wenruo 933ab4ba2e1SQu Wenruo btrfs_item_key_to_cpu(eb, &key, slot); 934ab4ba2e1SQu Wenruo va_start(args, fmt); 935ab4ba2e1SQu Wenruo 936ab4ba2e1SQu Wenruo vaf.fmt = fmt; 937ab4ba2e1SQu Wenruo vaf.va = &args; 938ab4ba2e1SQu Wenruo 9395617ed80SDavid Sterba btrfs_crit(eb->fs_info, 940ab4ba2e1SQu Wenruo "corrupt %s: root=%llu block=%llu slot=%d devid=%llu %pV", 941ab4ba2e1SQu Wenruo btrfs_header_level(eb) == 0 ? "leaf" : "node", 942ab4ba2e1SQu Wenruo btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, 943ab4ba2e1SQu Wenruo key.objectid, &vaf); 944ab4ba2e1SQu Wenruo va_end(args); 945ab4ba2e1SQu Wenruo } 946ab4ba2e1SQu Wenruo 947412a2312SDavid Sterba static int check_dev_item(struct extent_buffer *leaf, 948ab4ba2e1SQu Wenruo struct btrfs_key *key, int slot) 949ab4ba2e1SQu Wenruo { 950ab4ba2e1SQu Wenruo struct btrfs_dev_item *ditem; 951ab4ba2e1SQu Wenruo 952*c7c01a4aSDavid Sterba if (unlikely(key->objectid != BTRFS_DEV_ITEMS_OBJECTID)) { 9535617ed80SDavid Sterba dev_item_err(leaf, slot, 954ab4ba2e1SQu Wenruo "invalid objectid: has=%llu expect=%llu", 955ab4ba2e1SQu Wenruo key->objectid, BTRFS_DEV_ITEMS_OBJECTID); 956ab4ba2e1SQu Wenruo return -EUCLEAN; 957ab4ba2e1SQu Wenruo } 958ab4ba2e1SQu Wenruo ditem = btrfs_item_ptr(leaf, slot, struct btrfs_dev_item); 959*c7c01a4aSDavid Sterba if (unlikely(btrfs_device_id(leaf, ditem) != key->offset)) { 9605617ed80SDavid Sterba dev_item_err(leaf, slot, 961ab4ba2e1SQu Wenruo "devid mismatch: key has=%llu item has=%llu", 962ab4ba2e1SQu Wenruo key->offset, btrfs_device_id(leaf, ditem)); 963ab4ba2e1SQu Wenruo return -EUCLEAN; 964ab4ba2e1SQu Wenruo } 965ab4ba2e1SQu Wenruo 966ab4ba2e1SQu Wenruo /* 967ab4ba2e1SQu Wenruo * For device total_bytes, we don't have reliable way to check it, as 968ab4ba2e1SQu Wenruo * it can be 0 for device removal. Device size check can only be done 969ab4ba2e1SQu Wenruo * by dev extents check. 970ab4ba2e1SQu Wenruo */ 971*c7c01a4aSDavid Sterba if (unlikely(btrfs_device_bytes_used(leaf, ditem) > 972*c7c01a4aSDavid Sterba btrfs_device_total_bytes(leaf, ditem))) { 9735617ed80SDavid Sterba dev_item_err(leaf, slot, 974ab4ba2e1SQu Wenruo "invalid bytes used: have %llu expect [0, %llu]", 975ab4ba2e1SQu Wenruo btrfs_device_bytes_used(leaf, ditem), 976ab4ba2e1SQu Wenruo btrfs_device_total_bytes(leaf, ditem)); 977ab4ba2e1SQu Wenruo return -EUCLEAN; 978ab4ba2e1SQu Wenruo } 979ab4ba2e1SQu Wenruo /* 980ab4ba2e1SQu Wenruo * Remaining members like io_align/type/gen/dev_group aren't really 981ab4ba2e1SQu Wenruo * utilized. Skip them to make later usage of them easier. 982ab4ba2e1SQu Wenruo */ 983ab4ba2e1SQu Wenruo return 0; 984ab4ba2e1SQu Wenruo } 985ab4ba2e1SQu Wenruo 98639e57f49SDavid Sterba static int check_inode_item(struct extent_buffer *leaf, 987496245caSQu Wenruo struct btrfs_key *key, int slot) 988496245caSQu Wenruo { 98939e57f49SDavid Sterba struct btrfs_fs_info *fs_info = leaf->fs_info; 990496245caSQu Wenruo struct btrfs_inode_item *iitem; 991496245caSQu Wenruo u64 super_gen = btrfs_super_generation(fs_info->super_copy); 992496245caSQu Wenruo u32 valid_mask = (S_IFMT | S_ISUID | S_ISGID | S_ISVTX | 0777); 993496245caSQu Wenruo u32 mode; 994c23c77b0SQu Wenruo int ret; 995496245caSQu Wenruo 996c23c77b0SQu Wenruo ret = check_inode_key(leaf, key, slot); 997*c7c01a4aSDavid Sterba if (unlikely(ret < 0)) 998c23c77b0SQu Wenruo return ret; 999c23c77b0SQu Wenruo 1000496245caSQu Wenruo iitem = btrfs_item_ptr(leaf, slot, struct btrfs_inode_item); 1001496245caSQu Wenruo 1002496245caSQu Wenruo /* Here we use super block generation + 1 to handle log tree */ 1003*c7c01a4aSDavid Sterba if (unlikely(btrfs_inode_generation(leaf, iitem) > super_gen + 1)) { 1004c3053ebbSQu Wenruo inode_item_err(leaf, slot, 1005496245caSQu Wenruo "invalid inode generation: has %llu expect (0, %llu]", 1006496245caSQu Wenruo btrfs_inode_generation(leaf, iitem), 1007496245caSQu Wenruo super_gen + 1); 1008496245caSQu Wenruo return -EUCLEAN; 1009496245caSQu Wenruo } 1010496245caSQu Wenruo /* Note for ROOT_TREE_DIR_ITEM, mkfs could set its transid 0 */ 1011*c7c01a4aSDavid Sterba if (unlikely(btrfs_inode_transid(leaf, iitem) > super_gen + 1)) { 1012c3053ebbSQu Wenruo inode_item_err(leaf, slot, 1013f96d6960SQu Wenruo "invalid inode transid: has %llu expect [0, %llu]", 1014496245caSQu Wenruo btrfs_inode_transid(leaf, iitem), super_gen + 1); 1015496245caSQu Wenruo return -EUCLEAN; 1016496245caSQu Wenruo } 1017496245caSQu Wenruo 1018496245caSQu Wenruo /* 1019496245caSQu Wenruo * For size and nbytes it's better not to be too strict, as for dir 1020496245caSQu Wenruo * item its size/nbytes can easily get wrong, but doesn't affect 1021496245caSQu Wenruo * anything in the fs. So here we skip the check. 1022496245caSQu Wenruo */ 1023496245caSQu Wenruo mode = btrfs_inode_mode(leaf, iitem); 1024*c7c01a4aSDavid Sterba if (unlikely(mode & ~valid_mask)) { 1025c3053ebbSQu Wenruo inode_item_err(leaf, slot, 1026496245caSQu Wenruo "unknown mode bit detected: 0x%x", 1027496245caSQu Wenruo mode & ~valid_mask); 1028496245caSQu Wenruo return -EUCLEAN; 1029496245caSQu Wenruo } 1030496245caSQu Wenruo 1031496245caSQu Wenruo /* 1032c1499166SDavid Sterba * S_IFMT is not bit mapped so we can't completely rely on 1033c1499166SDavid Sterba * is_power_of_2/has_single_bit_set, but it can save us from checking 1034c1499166SDavid Sterba * FIFO/CHR/DIR/REG. Only needs to check BLK, LNK and SOCKS 1035496245caSQu Wenruo */ 1036c1499166SDavid Sterba if (!has_single_bit_set(mode & S_IFMT)) { 1037*c7c01a4aSDavid Sterba if (unlikely(!S_ISLNK(mode) && !S_ISBLK(mode) && !S_ISSOCK(mode))) { 1038c3053ebbSQu Wenruo inode_item_err(leaf, slot, 1039496245caSQu Wenruo "invalid mode: has 0%o expect valid S_IF* bit(s)", 1040496245caSQu Wenruo mode & S_IFMT); 1041496245caSQu Wenruo return -EUCLEAN; 1042496245caSQu Wenruo } 1043496245caSQu Wenruo } 1044*c7c01a4aSDavid Sterba if (unlikely(S_ISDIR(mode) && btrfs_inode_nlink(leaf, iitem) > 1)) { 1045c3053ebbSQu Wenruo inode_item_err(leaf, slot, 1046496245caSQu Wenruo "invalid nlink: has %u expect no more than 1 for dir", 1047496245caSQu Wenruo btrfs_inode_nlink(leaf, iitem)); 1048496245caSQu Wenruo return -EUCLEAN; 1049496245caSQu Wenruo } 1050*c7c01a4aSDavid Sterba if (unlikely(btrfs_inode_flags(leaf, iitem) & ~BTRFS_INODE_FLAG_MASK)) { 1051c3053ebbSQu Wenruo inode_item_err(leaf, slot, 1052496245caSQu Wenruo "unknown flags detected: 0x%llx", 1053496245caSQu Wenruo btrfs_inode_flags(leaf, iitem) & 1054496245caSQu Wenruo ~BTRFS_INODE_FLAG_MASK); 1055496245caSQu Wenruo return -EUCLEAN; 1056496245caSQu Wenruo } 1057496245caSQu Wenruo return 0; 1058496245caSQu Wenruo } 1059496245caSQu Wenruo 1060259ee775SQu Wenruo static int check_root_item(struct extent_buffer *leaf, struct btrfs_key *key, 1061259ee775SQu Wenruo int slot) 1062259ee775SQu Wenruo { 1063259ee775SQu Wenruo struct btrfs_fs_info *fs_info = leaf->fs_info; 10641465af12SQu Wenruo struct btrfs_root_item ri = { 0 }; 1065259ee775SQu Wenruo const u64 valid_root_flags = BTRFS_ROOT_SUBVOL_RDONLY | 1066259ee775SQu Wenruo BTRFS_ROOT_SUBVOL_DEAD; 106757a0e674SQu Wenruo int ret; 1068259ee775SQu Wenruo 106957a0e674SQu Wenruo ret = check_root_key(leaf, key, slot); 1070*c7c01a4aSDavid Sterba if (unlikely(ret < 0)) 107157a0e674SQu Wenruo return ret; 1072259ee775SQu Wenruo 1073*c7c01a4aSDavid Sterba if (unlikely(btrfs_item_size_nr(leaf, slot) != sizeof(ri) && 1074*c7c01a4aSDavid Sterba btrfs_item_size_nr(leaf, slot) != 1075*c7c01a4aSDavid Sterba btrfs_legacy_root_item_size())) { 1076259ee775SQu Wenruo generic_err(leaf, slot, 10771465af12SQu Wenruo "invalid root item size, have %u expect %zu or %u", 10781465af12SQu Wenruo btrfs_item_size_nr(leaf, slot), sizeof(ri), 10791465af12SQu Wenruo btrfs_legacy_root_item_size()); 10801a49a97dSDaniel Xu return -EUCLEAN; 1081259ee775SQu Wenruo } 1082259ee775SQu Wenruo 10831465af12SQu Wenruo /* 10841465af12SQu Wenruo * For legacy root item, the members starting at generation_v2 will be 10851465af12SQu Wenruo * all filled with 0. 10861465af12SQu Wenruo * And since we allow geneartion_v2 as 0, it will still pass the check. 10871465af12SQu Wenruo */ 1088259ee775SQu Wenruo read_extent_buffer(leaf, &ri, btrfs_item_ptr_offset(leaf, slot), 10891465af12SQu Wenruo btrfs_item_size_nr(leaf, slot)); 1090259ee775SQu Wenruo 1091259ee775SQu Wenruo /* Generation related */ 1092*c7c01a4aSDavid Sterba if (unlikely(btrfs_root_generation(&ri) > 1093*c7c01a4aSDavid Sterba btrfs_super_generation(fs_info->super_copy) + 1)) { 1094259ee775SQu Wenruo generic_err(leaf, slot, 1095259ee775SQu Wenruo "invalid root generation, have %llu expect (0, %llu]", 1096259ee775SQu Wenruo btrfs_root_generation(&ri), 1097259ee775SQu Wenruo btrfs_super_generation(fs_info->super_copy) + 1); 1098259ee775SQu Wenruo return -EUCLEAN; 1099259ee775SQu Wenruo } 1100*c7c01a4aSDavid Sterba if (unlikely(btrfs_root_generation_v2(&ri) > 1101*c7c01a4aSDavid Sterba btrfs_super_generation(fs_info->super_copy) + 1)) { 1102259ee775SQu Wenruo generic_err(leaf, slot, 1103259ee775SQu Wenruo "invalid root v2 generation, have %llu expect (0, %llu]", 1104259ee775SQu Wenruo btrfs_root_generation_v2(&ri), 1105259ee775SQu Wenruo btrfs_super_generation(fs_info->super_copy) + 1); 1106259ee775SQu Wenruo return -EUCLEAN; 1107259ee775SQu Wenruo } 1108*c7c01a4aSDavid Sterba if (unlikely(btrfs_root_last_snapshot(&ri) > 1109*c7c01a4aSDavid Sterba btrfs_super_generation(fs_info->super_copy) + 1)) { 1110259ee775SQu Wenruo generic_err(leaf, slot, 1111259ee775SQu Wenruo "invalid root last_snapshot, have %llu expect (0, %llu]", 1112259ee775SQu Wenruo btrfs_root_last_snapshot(&ri), 1113259ee775SQu Wenruo btrfs_super_generation(fs_info->super_copy) + 1); 1114259ee775SQu Wenruo return -EUCLEAN; 1115259ee775SQu Wenruo } 1116259ee775SQu Wenruo 1117259ee775SQu Wenruo /* Alignment and level check */ 1118*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(btrfs_root_bytenr(&ri), fs_info->sectorsize))) { 1119259ee775SQu Wenruo generic_err(leaf, slot, 1120259ee775SQu Wenruo "invalid root bytenr, have %llu expect to be aligned to %u", 1121259ee775SQu Wenruo btrfs_root_bytenr(&ri), fs_info->sectorsize); 1122259ee775SQu Wenruo return -EUCLEAN; 1123259ee775SQu Wenruo } 1124*c7c01a4aSDavid Sterba if (unlikely(btrfs_root_level(&ri) >= BTRFS_MAX_LEVEL)) { 1125259ee775SQu Wenruo generic_err(leaf, slot, 1126259ee775SQu Wenruo "invalid root level, have %u expect [0, %u]", 1127259ee775SQu Wenruo btrfs_root_level(&ri), BTRFS_MAX_LEVEL - 1); 1128259ee775SQu Wenruo return -EUCLEAN; 1129259ee775SQu Wenruo } 1130*c7c01a4aSDavid Sterba if (unlikely(btrfs_root_drop_level(&ri) >= BTRFS_MAX_LEVEL)) { 1131259ee775SQu Wenruo generic_err(leaf, slot, 1132259ee775SQu Wenruo "invalid root level, have %u expect [0, %u]", 1133c8422684SDavid Sterba btrfs_root_drop_level(&ri), BTRFS_MAX_LEVEL - 1); 1134259ee775SQu Wenruo return -EUCLEAN; 1135259ee775SQu Wenruo } 1136259ee775SQu Wenruo 1137259ee775SQu Wenruo /* Flags check */ 1138*c7c01a4aSDavid Sterba if (unlikely(btrfs_root_flags(&ri) & ~valid_root_flags)) { 1139259ee775SQu Wenruo generic_err(leaf, slot, 1140259ee775SQu Wenruo "invalid root flags, have 0x%llx expect mask 0x%llx", 1141259ee775SQu Wenruo btrfs_root_flags(&ri), valid_root_flags); 1142259ee775SQu Wenruo return -EUCLEAN; 1143259ee775SQu Wenruo } 1144259ee775SQu Wenruo return 0; 1145259ee775SQu Wenruo } 1146259ee775SQu Wenruo 1147f82d1c7cSQu Wenruo __printf(3,4) 1148f82d1c7cSQu Wenruo __cold 1149f82d1c7cSQu Wenruo static void extent_err(const struct extent_buffer *eb, int slot, 1150f82d1c7cSQu Wenruo const char *fmt, ...) 1151f82d1c7cSQu Wenruo { 1152f82d1c7cSQu Wenruo struct btrfs_key key; 1153f82d1c7cSQu Wenruo struct va_format vaf; 1154f82d1c7cSQu Wenruo va_list args; 1155f82d1c7cSQu Wenruo u64 bytenr; 1156f82d1c7cSQu Wenruo u64 len; 1157f82d1c7cSQu Wenruo 1158f82d1c7cSQu Wenruo btrfs_item_key_to_cpu(eb, &key, slot); 1159f82d1c7cSQu Wenruo bytenr = key.objectid; 1160e2406a6fSQu Wenruo if (key.type == BTRFS_METADATA_ITEM_KEY || 1161e2406a6fSQu Wenruo key.type == BTRFS_TREE_BLOCK_REF_KEY || 1162e2406a6fSQu Wenruo key.type == BTRFS_SHARED_BLOCK_REF_KEY) 1163f82d1c7cSQu Wenruo len = eb->fs_info->nodesize; 1164f82d1c7cSQu Wenruo else 1165f82d1c7cSQu Wenruo len = key.offset; 1166f82d1c7cSQu Wenruo va_start(args, fmt); 1167f82d1c7cSQu Wenruo 1168f82d1c7cSQu Wenruo vaf.fmt = fmt; 1169f82d1c7cSQu Wenruo vaf.va = &args; 1170f82d1c7cSQu Wenruo 1171f82d1c7cSQu Wenruo btrfs_crit(eb->fs_info, 1172f82d1c7cSQu Wenruo "corrupt %s: block=%llu slot=%d extent bytenr=%llu len=%llu %pV", 1173f82d1c7cSQu Wenruo btrfs_header_level(eb) == 0 ? "leaf" : "node", 1174f82d1c7cSQu Wenruo eb->start, slot, bytenr, len, &vaf); 1175f82d1c7cSQu Wenruo va_end(args); 1176f82d1c7cSQu Wenruo } 1177f82d1c7cSQu Wenruo 1178f82d1c7cSQu Wenruo static int check_extent_item(struct extent_buffer *leaf, 1179f82d1c7cSQu Wenruo struct btrfs_key *key, int slot) 1180f82d1c7cSQu Wenruo { 1181f82d1c7cSQu Wenruo struct btrfs_fs_info *fs_info = leaf->fs_info; 1182f82d1c7cSQu Wenruo struct btrfs_extent_item *ei; 1183f82d1c7cSQu Wenruo bool is_tree_block = false; 1184f82d1c7cSQu Wenruo unsigned long ptr; /* Current pointer inside inline refs */ 1185f82d1c7cSQu Wenruo unsigned long end; /* Extent item end */ 1186f82d1c7cSQu Wenruo const u32 item_size = btrfs_item_size_nr(leaf, slot); 1187f82d1c7cSQu Wenruo u64 flags; 1188f82d1c7cSQu Wenruo u64 generation; 1189f82d1c7cSQu Wenruo u64 total_refs; /* Total refs in btrfs_extent_item */ 1190f82d1c7cSQu Wenruo u64 inline_refs = 0; /* found total inline refs */ 1191f82d1c7cSQu Wenruo 1192*c7c01a4aSDavid Sterba if (unlikely(key->type == BTRFS_METADATA_ITEM_KEY && 1193*c7c01a4aSDavid Sterba !btrfs_fs_incompat(fs_info, SKINNY_METADATA))) { 1194f82d1c7cSQu Wenruo generic_err(leaf, slot, 1195f82d1c7cSQu Wenruo "invalid key type, METADATA_ITEM type invalid when SKINNY_METADATA feature disabled"); 1196f82d1c7cSQu Wenruo return -EUCLEAN; 1197f82d1c7cSQu Wenruo } 1198f82d1c7cSQu Wenruo /* key->objectid is the bytenr for both key types */ 1199*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(key->objectid, fs_info->sectorsize))) { 1200f82d1c7cSQu Wenruo generic_err(leaf, slot, 1201f82d1c7cSQu Wenruo "invalid key objectid, have %llu expect to be aligned to %u", 1202f82d1c7cSQu Wenruo key->objectid, fs_info->sectorsize); 1203f82d1c7cSQu Wenruo return -EUCLEAN; 1204f82d1c7cSQu Wenruo } 1205f82d1c7cSQu Wenruo 1206f82d1c7cSQu Wenruo /* key->offset is tree level for METADATA_ITEM_KEY */ 1207*c7c01a4aSDavid Sterba if (unlikely(key->type == BTRFS_METADATA_ITEM_KEY && 1208*c7c01a4aSDavid Sterba key->offset >= BTRFS_MAX_LEVEL)) { 1209f82d1c7cSQu Wenruo extent_err(leaf, slot, 1210f82d1c7cSQu Wenruo "invalid tree level, have %llu expect [0, %u]", 1211f82d1c7cSQu Wenruo key->offset, BTRFS_MAX_LEVEL - 1); 1212f82d1c7cSQu Wenruo return -EUCLEAN; 1213f82d1c7cSQu Wenruo } 1214f82d1c7cSQu Wenruo 1215f82d1c7cSQu Wenruo /* 1216f82d1c7cSQu Wenruo * EXTENT/METADATA_ITEM consists of: 1217f82d1c7cSQu Wenruo * 1) One btrfs_extent_item 1218f82d1c7cSQu Wenruo * Records the total refs, type and generation of the extent. 1219f82d1c7cSQu Wenruo * 1220f82d1c7cSQu Wenruo * 2) One btrfs_tree_block_info (for EXTENT_ITEM and tree backref only) 1221f82d1c7cSQu Wenruo * Records the first key and level of the tree block. 1222f82d1c7cSQu Wenruo * 1223f82d1c7cSQu Wenruo * 2) Zero or more btrfs_extent_inline_ref(s) 1224f82d1c7cSQu Wenruo * Each inline ref has one btrfs_extent_inline_ref shows: 1225f82d1c7cSQu Wenruo * 2.1) The ref type, one of the 4 1226f82d1c7cSQu Wenruo * TREE_BLOCK_REF Tree block only 1227f82d1c7cSQu Wenruo * SHARED_BLOCK_REF Tree block only 1228f82d1c7cSQu Wenruo * EXTENT_DATA_REF Data only 1229f82d1c7cSQu Wenruo * SHARED_DATA_REF Data only 1230f82d1c7cSQu Wenruo * 2.2) Ref type specific data 1231f82d1c7cSQu Wenruo * Either using btrfs_extent_inline_ref::offset, or specific 1232f82d1c7cSQu Wenruo * data structure. 1233f82d1c7cSQu Wenruo */ 1234*c7c01a4aSDavid Sterba if (unlikely(item_size < sizeof(*ei))) { 1235f82d1c7cSQu Wenruo extent_err(leaf, slot, 1236f82d1c7cSQu Wenruo "invalid item size, have %u expect [%zu, %u)", 1237f82d1c7cSQu Wenruo item_size, sizeof(*ei), 1238f82d1c7cSQu Wenruo BTRFS_LEAF_DATA_SIZE(fs_info)); 1239f82d1c7cSQu Wenruo return -EUCLEAN; 1240f82d1c7cSQu Wenruo } 1241f82d1c7cSQu Wenruo end = item_size + btrfs_item_ptr_offset(leaf, slot); 1242f82d1c7cSQu Wenruo 1243f82d1c7cSQu Wenruo /* Checks against extent_item */ 1244f82d1c7cSQu Wenruo ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item); 1245f82d1c7cSQu Wenruo flags = btrfs_extent_flags(leaf, ei); 1246f82d1c7cSQu Wenruo total_refs = btrfs_extent_refs(leaf, ei); 1247f82d1c7cSQu Wenruo generation = btrfs_extent_generation(leaf, ei); 1248*c7c01a4aSDavid Sterba if (unlikely(generation > 1249*c7c01a4aSDavid Sterba btrfs_super_generation(fs_info->super_copy) + 1)) { 1250f82d1c7cSQu Wenruo extent_err(leaf, slot, 1251f82d1c7cSQu Wenruo "invalid generation, have %llu expect (0, %llu]", 1252f82d1c7cSQu Wenruo generation, 1253f82d1c7cSQu Wenruo btrfs_super_generation(fs_info->super_copy) + 1); 1254f82d1c7cSQu Wenruo return -EUCLEAN; 1255f82d1c7cSQu Wenruo } 1256*c7c01a4aSDavid Sterba if (unlikely(!has_single_bit_set(flags & (BTRFS_EXTENT_FLAG_DATA | 1257*c7c01a4aSDavid Sterba BTRFS_EXTENT_FLAG_TREE_BLOCK)))) { 1258f82d1c7cSQu Wenruo extent_err(leaf, slot, 1259f82d1c7cSQu Wenruo "invalid extent flag, have 0x%llx expect 1 bit set in 0x%llx", 1260f82d1c7cSQu Wenruo flags, BTRFS_EXTENT_FLAG_DATA | 1261f82d1c7cSQu Wenruo BTRFS_EXTENT_FLAG_TREE_BLOCK); 1262f82d1c7cSQu Wenruo return -EUCLEAN; 1263f82d1c7cSQu Wenruo } 1264f82d1c7cSQu Wenruo is_tree_block = !!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK); 1265f82d1c7cSQu Wenruo if (is_tree_block) { 1266*c7c01a4aSDavid Sterba if (unlikely(key->type == BTRFS_EXTENT_ITEM_KEY && 1267*c7c01a4aSDavid Sterba key->offset != fs_info->nodesize)) { 1268f82d1c7cSQu Wenruo extent_err(leaf, slot, 1269f82d1c7cSQu Wenruo "invalid extent length, have %llu expect %u", 1270f82d1c7cSQu Wenruo key->offset, fs_info->nodesize); 1271f82d1c7cSQu Wenruo return -EUCLEAN; 1272f82d1c7cSQu Wenruo } 1273f82d1c7cSQu Wenruo } else { 1274*c7c01a4aSDavid Sterba if (unlikely(key->type != BTRFS_EXTENT_ITEM_KEY)) { 1275f82d1c7cSQu Wenruo extent_err(leaf, slot, 1276f82d1c7cSQu Wenruo "invalid key type, have %u expect %u for data backref", 1277f82d1c7cSQu Wenruo key->type, BTRFS_EXTENT_ITEM_KEY); 1278f82d1c7cSQu Wenruo return -EUCLEAN; 1279f82d1c7cSQu Wenruo } 1280*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(key->offset, fs_info->sectorsize))) { 1281f82d1c7cSQu Wenruo extent_err(leaf, slot, 1282f82d1c7cSQu Wenruo "invalid extent length, have %llu expect aligned to %u", 1283f82d1c7cSQu Wenruo key->offset, fs_info->sectorsize); 1284f82d1c7cSQu Wenruo return -EUCLEAN; 1285f82d1c7cSQu Wenruo } 1286f82d1c7cSQu Wenruo } 1287f82d1c7cSQu Wenruo ptr = (unsigned long)(struct btrfs_extent_item *)(ei + 1); 1288f82d1c7cSQu Wenruo 1289f82d1c7cSQu Wenruo /* Check the special case of btrfs_tree_block_info */ 1290f82d1c7cSQu Wenruo if (is_tree_block && key->type != BTRFS_METADATA_ITEM_KEY) { 1291f82d1c7cSQu Wenruo struct btrfs_tree_block_info *info; 1292f82d1c7cSQu Wenruo 1293f82d1c7cSQu Wenruo info = (struct btrfs_tree_block_info *)ptr; 1294*c7c01a4aSDavid Sterba if (unlikely(btrfs_tree_block_level(leaf, info) >= BTRFS_MAX_LEVEL)) { 1295f82d1c7cSQu Wenruo extent_err(leaf, slot, 1296f82d1c7cSQu Wenruo "invalid tree block info level, have %u expect [0, %u]", 1297f82d1c7cSQu Wenruo btrfs_tree_block_level(leaf, info), 1298f82d1c7cSQu Wenruo BTRFS_MAX_LEVEL - 1); 1299f82d1c7cSQu Wenruo return -EUCLEAN; 1300f82d1c7cSQu Wenruo } 1301f82d1c7cSQu Wenruo ptr = (unsigned long)(struct btrfs_tree_block_info *)(info + 1); 1302f82d1c7cSQu Wenruo } 1303f82d1c7cSQu Wenruo 1304f82d1c7cSQu Wenruo /* Check inline refs */ 1305f82d1c7cSQu Wenruo while (ptr < end) { 1306f82d1c7cSQu Wenruo struct btrfs_extent_inline_ref *iref; 1307f82d1c7cSQu Wenruo struct btrfs_extent_data_ref *dref; 1308f82d1c7cSQu Wenruo struct btrfs_shared_data_ref *sref; 1309f82d1c7cSQu Wenruo u64 dref_offset; 1310f82d1c7cSQu Wenruo u64 inline_offset; 1311f82d1c7cSQu Wenruo u8 inline_type; 1312f82d1c7cSQu Wenruo 1313*c7c01a4aSDavid Sterba if (unlikely(ptr + sizeof(*iref) > end)) { 1314f82d1c7cSQu Wenruo extent_err(leaf, slot, 1315f82d1c7cSQu Wenruo "inline ref item overflows extent item, ptr %lu iref size %zu end %lu", 1316f82d1c7cSQu Wenruo ptr, sizeof(*iref), end); 1317f82d1c7cSQu Wenruo return -EUCLEAN; 1318f82d1c7cSQu Wenruo } 1319f82d1c7cSQu Wenruo iref = (struct btrfs_extent_inline_ref *)ptr; 1320f82d1c7cSQu Wenruo inline_type = btrfs_extent_inline_ref_type(leaf, iref); 1321f82d1c7cSQu Wenruo inline_offset = btrfs_extent_inline_ref_offset(leaf, iref); 1322*c7c01a4aSDavid Sterba if (unlikely(ptr + btrfs_extent_inline_ref_size(inline_type) > end)) { 1323f82d1c7cSQu Wenruo extent_err(leaf, slot, 1324f82d1c7cSQu Wenruo "inline ref item overflows extent item, ptr %lu iref size %u end %lu", 1325f82d1c7cSQu Wenruo ptr, inline_type, end); 1326f82d1c7cSQu Wenruo return -EUCLEAN; 1327f82d1c7cSQu Wenruo } 1328f82d1c7cSQu Wenruo 1329f82d1c7cSQu Wenruo switch (inline_type) { 1330f82d1c7cSQu Wenruo /* inline_offset is subvolid of the owner, no need to check */ 1331f82d1c7cSQu Wenruo case BTRFS_TREE_BLOCK_REF_KEY: 1332f82d1c7cSQu Wenruo inline_refs++; 1333f82d1c7cSQu Wenruo break; 1334f82d1c7cSQu Wenruo /* Contains parent bytenr */ 1335f82d1c7cSQu Wenruo case BTRFS_SHARED_BLOCK_REF_KEY: 1336*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(inline_offset, 1337*c7c01a4aSDavid Sterba fs_info->sectorsize))) { 1338f82d1c7cSQu Wenruo extent_err(leaf, slot, 1339f82d1c7cSQu Wenruo "invalid tree parent bytenr, have %llu expect aligned to %u", 1340f82d1c7cSQu Wenruo inline_offset, fs_info->sectorsize); 1341f82d1c7cSQu Wenruo return -EUCLEAN; 1342f82d1c7cSQu Wenruo } 1343f82d1c7cSQu Wenruo inline_refs++; 1344f82d1c7cSQu Wenruo break; 1345f82d1c7cSQu Wenruo /* 1346f82d1c7cSQu Wenruo * Contains owner subvolid, owner key objectid, adjusted offset. 1347f82d1c7cSQu Wenruo * The only obvious corruption can happen in that offset. 1348f82d1c7cSQu Wenruo */ 1349f82d1c7cSQu Wenruo case BTRFS_EXTENT_DATA_REF_KEY: 1350f82d1c7cSQu Wenruo dref = (struct btrfs_extent_data_ref *)(&iref->offset); 1351f82d1c7cSQu Wenruo dref_offset = btrfs_extent_data_ref_offset(leaf, dref); 1352*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(dref_offset, 1353*c7c01a4aSDavid Sterba fs_info->sectorsize))) { 1354f82d1c7cSQu Wenruo extent_err(leaf, slot, 1355f82d1c7cSQu Wenruo "invalid data ref offset, have %llu expect aligned to %u", 1356f82d1c7cSQu Wenruo dref_offset, fs_info->sectorsize); 1357f82d1c7cSQu Wenruo return -EUCLEAN; 1358f82d1c7cSQu Wenruo } 1359f82d1c7cSQu Wenruo inline_refs += btrfs_extent_data_ref_count(leaf, dref); 1360f82d1c7cSQu Wenruo break; 1361f82d1c7cSQu Wenruo /* Contains parent bytenr and ref count */ 1362f82d1c7cSQu Wenruo case BTRFS_SHARED_DATA_REF_KEY: 1363f82d1c7cSQu Wenruo sref = (struct btrfs_shared_data_ref *)(iref + 1); 1364*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(inline_offset, 1365*c7c01a4aSDavid Sterba fs_info->sectorsize))) { 1366f82d1c7cSQu Wenruo extent_err(leaf, slot, 1367f82d1c7cSQu Wenruo "invalid data parent bytenr, have %llu expect aligned to %u", 1368f82d1c7cSQu Wenruo inline_offset, fs_info->sectorsize); 1369f82d1c7cSQu Wenruo return -EUCLEAN; 1370f82d1c7cSQu Wenruo } 1371f82d1c7cSQu Wenruo inline_refs += btrfs_shared_data_ref_count(leaf, sref); 1372f82d1c7cSQu Wenruo break; 1373f82d1c7cSQu Wenruo default: 1374f82d1c7cSQu Wenruo extent_err(leaf, slot, "unknown inline ref type: %u", 1375f82d1c7cSQu Wenruo inline_type); 1376f82d1c7cSQu Wenruo return -EUCLEAN; 1377f82d1c7cSQu Wenruo } 1378f82d1c7cSQu Wenruo ptr += btrfs_extent_inline_ref_size(inline_type); 1379f82d1c7cSQu Wenruo } 1380f82d1c7cSQu Wenruo /* No padding is allowed */ 1381*c7c01a4aSDavid Sterba if (unlikely(ptr != end)) { 1382f82d1c7cSQu Wenruo extent_err(leaf, slot, 1383f82d1c7cSQu Wenruo "invalid extent item size, padding bytes found"); 1384f82d1c7cSQu Wenruo return -EUCLEAN; 1385f82d1c7cSQu Wenruo } 1386f82d1c7cSQu Wenruo 1387f82d1c7cSQu Wenruo /* Finally, check the inline refs against total refs */ 1388*c7c01a4aSDavid Sterba if (unlikely(inline_refs > total_refs)) { 1389f82d1c7cSQu Wenruo extent_err(leaf, slot, 1390f82d1c7cSQu Wenruo "invalid extent refs, have %llu expect >= inline %llu", 1391f82d1c7cSQu Wenruo total_refs, inline_refs); 1392f82d1c7cSQu Wenruo return -EUCLEAN; 1393f82d1c7cSQu Wenruo } 1394f82d1c7cSQu Wenruo return 0; 1395f82d1c7cSQu Wenruo } 1396f82d1c7cSQu Wenruo 1397e2406a6fSQu Wenruo static int check_simple_keyed_refs(struct extent_buffer *leaf, 1398e2406a6fSQu Wenruo struct btrfs_key *key, int slot) 1399e2406a6fSQu Wenruo { 1400e2406a6fSQu Wenruo u32 expect_item_size = 0; 1401e2406a6fSQu Wenruo 1402e2406a6fSQu Wenruo if (key->type == BTRFS_SHARED_DATA_REF_KEY) 1403e2406a6fSQu Wenruo expect_item_size = sizeof(struct btrfs_shared_data_ref); 1404e2406a6fSQu Wenruo 1405*c7c01a4aSDavid Sterba if (unlikely(btrfs_item_size_nr(leaf, slot) != expect_item_size)) { 1406e2406a6fSQu Wenruo generic_err(leaf, slot, 1407e2406a6fSQu Wenruo "invalid item size, have %u expect %u for key type %u", 1408e2406a6fSQu Wenruo btrfs_item_size_nr(leaf, slot), 1409e2406a6fSQu Wenruo expect_item_size, key->type); 1410e2406a6fSQu Wenruo return -EUCLEAN; 1411e2406a6fSQu Wenruo } 1412*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) { 1413e2406a6fSQu Wenruo generic_err(leaf, slot, 1414e2406a6fSQu Wenruo "invalid key objectid for shared block ref, have %llu expect aligned to %u", 1415e2406a6fSQu Wenruo key->objectid, leaf->fs_info->sectorsize); 1416e2406a6fSQu Wenruo return -EUCLEAN; 1417e2406a6fSQu Wenruo } 1418*c7c01a4aSDavid Sterba if (unlikely(key->type != BTRFS_TREE_BLOCK_REF_KEY && 1419*c7c01a4aSDavid Sterba !IS_ALIGNED(key->offset, leaf->fs_info->sectorsize))) { 1420e2406a6fSQu Wenruo extent_err(leaf, slot, 1421e2406a6fSQu Wenruo "invalid tree parent bytenr, have %llu expect aligned to %u", 1422e2406a6fSQu Wenruo key->offset, leaf->fs_info->sectorsize); 1423e2406a6fSQu Wenruo return -EUCLEAN; 1424e2406a6fSQu Wenruo } 1425e2406a6fSQu Wenruo return 0; 1426e2406a6fSQu Wenruo } 1427e2406a6fSQu Wenruo 14280785a9aaSQu Wenruo static int check_extent_data_ref(struct extent_buffer *leaf, 14290785a9aaSQu Wenruo struct btrfs_key *key, int slot) 14300785a9aaSQu Wenruo { 14310785a9aaSQu Wenruo struct btrfs_extent_data_ref *dref; 14320785a9aaSQu Wenruo unsigned long ptr = btrfs_item_ptr_offset(leaf, slot); 14330785a9aaSQu Wenruo const unsigned long end = ptr + btrfs_item_size_nr(leaf, slot); 14340785a9aaSQu Wenruo 1435*c7c01a4aSDavid Sterba if (unlikely(btrfs_item_size_nr(leaf, slot) % sizeof(*dref) != 0)) { 14360785a9aaSQu Wenruo generic_err(leaf, slot, 14370785a9aaSQu Wenruo "invalid item size, have %u expect aligned to %zu for key type %u", 14380785a9aaSQu Wenruo btrfs_item_size_nr(leaf, slot), 14390785a9aaSQu Wenruo sizeof(*dref), key->type); 14406d06b0adSDavid Sterba return -EUCLEAN; 14410785a9aaSQu Wenruo } 1442*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) { 14430785a9aaSQu Wenruo generic_err(leaf, slot, 14440785a9aaSQu Wenruo "invalid key objectid for shared block ref, have %llu expect aligned to %u", 14450785a9aaSQu Wenruo key->objectid, leaf->fs_info->sectorsize); 14460785a9aaSQu Wenruo return -EUCLEAN; 14470785a9aaSQu Wenruo } 14480785a9aaSQu Wenruo for (; ptr < end; ptr += sizeof(*dref)) { 14490785a9aaSQu Wenruo u64 root_objectid; 14500785a9aaSQu Wenruo u64 owner; 14510785a9aaSQu Wenruo u64 offset; 14520785a9aaSQu Wenruo u64 hash; 14530785a9aaSQu Wenruo 14540785a9aaSQu Wenruo dref = (struct btrfs_extent_data_ref *)ptr; 14550785a9aaSQu Wenruo root_objectid = btrfs_extent_data_ref_root(leaf, dref); 14560785a9aaSQu Wenruo owner = btrfs_extent_data_ref_objectid(leaf, dref); 14570785a9aaSQu Wenruo offset = btrfs_extent_data_ref_offset(leaf, dref); 14580785a9aaSQu Wenruo hash = hash_extent_data_ref(root_objectid, owner, offset); 1459*c7c01a4aSDavid Sterba if (unlikely(hash != key->offset)) { 14600785a9aaSQu Wenruo extent_err(leaf, slot, 14610785a9aaSQu Wenruo "invalid extent data ref hash, item has 0x%016llx key has 0x%016llx", 14620785a9aaSQu Wenruo hash, key->offset); 14630785a9aaSQu Wenruo return -EUCLEAN; 14640785a9aaSQu Wenruo } 1465*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(offset, leaf->fs_info->sectorsize))) { 14660785a9aaSQu Wenruo extent_err(leaf, slot, 14670785a9aaSQu Wenruo "invalid extent data backref offset, have %llu expect aligned to %u", 14680785a9aaSQu Wenruo offset, leaf->fs_info->sectorsize); 14696d06b0adSDavid Sterba return -EUCLEAN; 14700785a9aaSQu Wenruo } 14710785a9aaSQu Wenruo } 14720785a9aaSQu Wenruo return 0; 14730785a9aaSQu Wenruo } 14740785a9aaSQu Wenruo 1475c3053ebbSQu Wenruo #define inode_ref_err(eb, slot, fmt, args...) \ 1476c3053ebbSQu Wenruo inode_item_err(eb, slot, fmt, ##args) 147771bf92a9SQu Wenruo static int check_inode_ref(struct extent_buffer *leaf, 147871bf92a9SQu Wenruo struct btrfs_key *key, struct btrfs_key *prev_key, 147971bf92a9SQu Wenruo int slot) 148071bf92a9SQu Wenruo { 148171bf92a9SQu Wenruo struct btrfs_inode_ref *iref; 148271bf92a9SQu Wenruo unsigned long ptr; 148371bf92a9SQu Wenruo unsigned long end; 148471bf92a9SQu Wenruo 1485*c7c01a4aSDavid Sterba if (unlikely(!check_prev_ino(leaf, key, slot, prev_key))) 148680d7fd1eSQu Wenruo return -EUCLEAN; 148771bf92a9SQu Wenruo /* namelen can't be 0, so item_size == sizeof() is also invalid */ 1488*c7c01a4aSDavid Sterba if (unlikely(btrfs_item_size_nr(leaf, slot) <= sizeof(*iref))) { 1489c3053ebbSQu Wenruo inode_ref_err(leaf, slot, 149071bf92a9SQu Wenruo "invalid item size, have %u expect (%zu, %u)", 149171bf92a9SQu Wenruo btrfs_item_size_nr(leaf, slot), 149271bf92a9SQu Wenruo sizeof(*iref), BTRFS_LEAF_DATA_SIZE(leaf->fs_info)); 149371bf92a9SQu Wenruo return -EUCLEAN; 149471bf92a9SQu Wenruo } 149571bf92a9SQu Wenruo 149671bf92a9SQu Wenruo ptr = btrfs_item_ptr_offset(leaf, slot); 149771bf92a9SQu Wenruo end = ptr + btrfs_item_size_nr(leaf, slot); 149871bf92a9SQu Wenruo while (ptr < end) { 149971bf92a9SQu Wenruo u16 namelen; 150071bf92a9SQu Wenruo 1501*c7c01a4aSDavid Sterba if (unlikely(ptr + sizeof(iref) > end)) { 1502c3053ebbSQu Wenruo inode_ref_err(leaf, slot, 150371bf92a9SQu Wenruo "inode ref overflow, ptr %lu end %lu inode_ref_size %zu", 150471bf92a9SQu Wenruo ptr, end, sizeof(iref)); 150571bf92a9SQu Wenruo return -EUCLEAN; 150671bf92a9SQu Wenruo } 150771bf92a9SQu Wenruo 150871bf92a9SQu Wenruo iref = (struct btrfs_inode_ref *)ptr; 150971bf92a9SQu Wenruo namelen = btrfs_inode_ref_name_len(leaf, iref); 1510*c7c01a4aSDavid Sterba if (unlikely(ptr + sizeof(*iref) + namelen > end)) { 1511c3053ebbSQu Wenruo inode_ref_err(leaf, slot, 151271bf92a9SQu Wenruo "inode ref overflow, ptr %lu end %lu namelen %u", 151371bf92a9SQu Wenruo ptr, end, namelen); 151471bf92a9SQu Wenruo return -EUCLEAN; 151571bf92a9SQu Wenruo } 151671bf92a9SQu Wenruo 151771bf92a9SQu Wenruo /* 151871bf92a9SQu Wenruo * NOTE: In theory we should record all found index numbers 151971bf92a9SQu Wenruo * to find any duplicated indexes, but that will be too time 152071bf92a9SQu Wenruo * consuming for inodes with too many hard links. 152171bf92a9SQu Wenruo */ 152271bf92a9SQu Wenruo ptr += sizeof(*iref) + namelen; 152371bf92a9SQu Wenruo } 152471bf92a9SQu Wenruo return 0; 152571bf92a9SQu Wenruo } 152671bf92a9SQu Wenruo 152782fc28fbSQu Wenruo /* 1528557ea5ddSQu Wenruo * Common point to switch the item-specific validation. 1529557ea5ddSQu Wenruo */ 15300076bc89SDavid Sterba static int check_leaf_item(struct extent_buffer *leaf, 15314e9845efSFilipe Manana struct btrfs_key *key, int slot, 15324e9845efSFilipe Manana struct btrfs_key *prev_key) 1533557ea5ddSQu Wenruo { 1534557ea5ddSQu Wenruo int ret = 0; 1535075cb3c7SQu Wenruo struct btrfs_chunk *chunk; 1536557ea5ddSQu Wenruo 1537557ea5ddSQu Wenruo switch (key->type) { 1538557ea5ddSQu Wenruo case BTRFS_EXTENT_DATA_KEY: 15394e9845efSFilipe Manana ret = check_extent_data_item(leaf, key, slot, prev_key); 1540557ea5ddSQu Wenruo break; 1541557ea5ddSQu Wenruo case BTRFS_EXTENT_CSUM_KEY: 1542ad1d8c43SFilipe Manana ret = check_csum_item(leaf, key, slot, prev_key); 1543557ea5ddSQu Wenruo break; 1544ad7b0368SQu Wenruo case BTRFS_DIR_ITEM_KEY: 1545ad7b0368SQu Wenruo case BTRFS_DIR_INDEX_KEY: 1546ad7b0368SQu Wenruo case BTRFS_XATTR_ITEM_KEY: 1547c18679ebSQu Wenruo ret = check_dir_item(leaf, key, prev_key, slot); 1548ad7b0368SQu Wenruo break; 154971bf92a9SQu Wenruo case BTRFS_INODE_REF_KEY: 155071bf92a9SQu Wenruo ret = check_inode_ref(leaf, key, prev_key, slot); 155171bf92a9SQu Wenruo break; 1552fce466eaSQu Wenruo case BTRFS_BLOCK_GROUP_ITEM_KEY: 1553af60ce2bSDavid Sterba ret = check_block_group_item(leaf, key, slot); 1554fce466eaSQu Wenruo break; 1555075cb3c7SQu Wenruo case BTRFS_CHUNK_ITEM_KEY: 1556075cb3c7SQu Wenruo chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk); 1557f6d2a5c2SQu Wenruo ret = check_leaf_chunk_item(leaf, chunk, key, slot); 1558075cb3c7SQu Wenruo break; 1559ab4ba2e1SQu Wenruo case BTRFS_DEV_ITEM_KEY: 1560412a2312SDavid Sterba ret = check_dev_item(leaf, key, slot); 1561ab4ba2e1SQu Wenruo break; 1562496245caSQu Wenruo case BTRFS_INODE_ITEM_KEY: 156339e57f49SDavid Sterba ret = check_inode_item(leaf, key, slot); 1564496245caSQu Wenruo break; 1565259ee775SQu Wenruo case BTRFS_ROOT_ITEM_KEY: 1566259ee775SQu Wenruo ret = check_root_item(leaf, key, slot); 1567259ee775SQu Wenruo break; 1568f82d1c7cSQu Wenruo case BTRFS_EXTENT_ITEM_KEY: 1569f82d1c7cSQu Wenruo case BTRFS_METADATA_ITEM_KEY: 1570f82d1c7cSQu Wenruo ret = check_extent_item(leaf, key, slot); 1571f82d1c7cSQu Wenruo break; 1572e2406a6fSQu Wenruo case BTRFS_TREE_BLOCK_REF_KEY: 1573e2406a6fSQu Wenruo case BTRFS_SHARED_DATA_REF_KEY: 1574e2406a6fSQu Wenruo case BTRFS_SHARED_BLOCK_REF_KEY: 1575e2406a6fSQu Wenruo ret = check_simple_keyed_refs(leaf, key, slot); 1576e2406a6fSQu Wenruo break; 15770785a9aaSQu Wenruo case BTRFS_EXTENT_DATA_REF_KEY: 15780785a9aaSQu Wenruo ret = check_extent_data_ref(leaf, key, slot); 15790785a9aaSQu Wenruo break; 1580557ea5ddSQu Wenruo } 1581557ea5ddSQu Wenruo return ret; 1582557ea5ddSQu Wenruo } 1583557ea5ddSQu Wenruo 1584e2ccd361SDavid Sterba static int check_leaf(struct extent_buffer *leaf, bool check_item_data) 1585557ea5ddSQu Wenruo { 1586e2ccd361SDavid Sterba struct btrfs_fs_info *fs_info = leaf->fs_info; 1587557ea5ddSQu Wenruo /* No valid key type is 0, so all key should be larger than this key */ 1588557ea5ddSQu Wenruo struct btrfs_key prev_key = {0, 0, 0}; 1589557ea5ddSQu Wenruo struct btrfs_key key; 1590557ea5ddSQu Wenruo u32 nritems = btrfs_header_nritems(leaf); 1591557ea5ddSQu Wenruo int slot; 1592557ea5ddSQu Wenruo 1593*c7c01a4aSDavid Sterba if (unlikely(btrfs_header_level(leaf) != 0)) { 159486a6be3aSDavid Sterba generic_err(leaf, 0, 1595f556faa4SQu Wenruo "invalid level for leaf, have %d expect 0", 1596f556faa4SQu Wenruo btrfs_header_level(leaf)); 1597f556faa4SQu Wenruo return -EUCLEAN; 1598f556faa4SQu Wenruo } 1599f556faa4SQu Wenruo 1600557ea5ddSQu Wenruo /* 1601557ea5ddSQu Wenruo * Extent buffers from a relocation tree have a owner field that 1602557ea5ddSQu Wenruo * corresponds to the subvolume tree they are based on. So just from an 1603557ea5ddSQu Wenruo * extent buffer alone we can not find out what is the id of the 1604557ea5ddSQu Wenruo * corresponding subvolume tree, so we can not figure out if the extent 1605557ea5ddSQu Wenruo * buffer corresponds to the root of the relocation tree or not. So 1606557ea5ddSQu Wenruo * skip this check for relocation trees. 1607557ea5ddSQu Wenruo */ 1608557ea5ddSQu Wenruo if (nritems == 0 && !btrfs_header_flag(leaf, BTRFS_HEADER_FLAG_RELOC)) { 1609ba480dd4SQu Wenruo u64 owner = btrfs_header_owner(leaf); 1610557ea5ddSQu Wenruo 1611ba480dd4SQu Wenruo /* These trees must never be empty */ 1612*c7c01a4aSDavid Sterba if (unlikely(owner == BTRFS_ROOT_TREE_OBJECTID || 1613ba480dd4SQu Wenruo owner == BTRFS_CHUNK_TREE_OBJECTID || 1614ba480dd4SQu Wenruo owner == BTRFS_EXTENT_TREE_OBJECTID || 1615ba480dd4SQu Wenruo owner == BTRFS_DEV_TREE_OBJECTID || 1616ba480dd4SQu Wenruo owner == BTRFS_FS_TREE_OBJECTID || 1617*c7c01a4aSDavid Sterba owner == BTRFS_DATA_RELOC_TREE_OBJECTID)) { 161886a6be3aSDavid Sterba generic_err(leaf, 0, 1619ba480dd4SQu Wenruo "invalid root, root %llu must never be empty", 1620ba480dd4SQu Wenruo owner); 1621ba480dd4SQu Wenruo return -EUCLEAN; 1622ba480dd4SQu Wenruo } 162362fdaa52SQu Wenruo /* Unknown tree */ 1624*c7c01a4aSDavid Sterba if (unlikely(owner == 0)) { 162562fdaa52SQu Wenruo generic_err(leaf, 0, 162662fdaa52SQu Wenruo "invalid owner, root 0 is not defined"); 162762fdaa52SQu Wenruo return -EUCLEAN; 162862fdaa52SQu Wenruo } 1629557ea5ddSQu Wenruo return 0; 1630557ea5ddSQu Wenruo } 1631557ea5ddSQu Wenruo 1632*c7c01a4aSDavid Sterba if (unlikely(nritems == 0)) 1633557ea5ddSQu Wenruo return 0; 1634557ea5ddSQu Wenruo 1635557ea5ddSQu Wenruo /* 1636557ea5ddSQu Wenruo * Check the following things to make sure this is a good leaf, and 1637557ea5ddSQu Wenruo * leaf users won't need to bother with similar sanity checks: 1638557ea5ddSQu Wenruo * 1639557ea5ddSQu Wenruo * 1) key ordering 1640557ea5ddSQu Wenruo * 2) item offset and size 1641557ea5ddSQu Wenruo * No overlap, no hole, all inside the leaf. 1642557ea5ddSQu Wenruo * 3) item content 1643557ea5ddSQu Wenruo * If possible, do comprehensive sanity check. 1644557ea5ddSQu Wenruo * NOTE: All checks must only rely on the item data itself. 1645557ea5ddSQu Wenruo */ 1646557ea5ddSQu Wenruo for (slot = 0; slot < nritems; slot++) { 1647557ea5ddSQu Wenruo u32 item_end_expected; 1648557ea5ddSQu Wenruo int ret; 1649557ea5ddSQu Wenruo 1650557ea5ddSQu Wenruo btrfs_item_key_to_cpu(leaf, &key, slot); 1651557ea5ddSQu Wenruo 1652557ea5ddSQu Wenruo /* Make sure the keys are in the right order */ 1653*c7c01a4aSDavid Sterba if (unlikely(btrfs_comp_cpu_keys(&prev_key, &key) >= 0)) { 165486a6be3aSDavid Sterba generic_err(leaf, slot, 1655478d01b3SQu Wenruo "bad key order, prev (%llu %u %llu) current (%llu %u %llu)", 1656478d01b3SQu Wenruo prev_key.objectid, prev_key.type, 1657478d01b3SQu Wenruo prev_key.offset, key.objectid, key.type, 1658478d01b3SQu Wenruo key.offset); 1659557ea5ddSQu Wenruo return -EUCLEAN; 1660557ea5ddSQu Wenruo } 1661557ea5ddSQu Wenruo 1662557ea5ddSQu Wenruo /* 1663557ea5ddSQu Wenruo * Make sure the offset and ends are right, remember that the 1664557ea5ddSQu Wenruo * item data starts at the end of the leaf and grows towards the 1665557ea5ddSQu Wenruo * front. 1666557ea5ddSQu Wenruo */ 1667557ea5ddSQu Wenruo if (slot == 0) 1668557ea5ddSQu Wenruo item_end_expected = BTRFS_LEAF_DATA_SIZE(fs_info); 1669557ea5ddSQu Wenruo else 1670557ea5ddSQu Wenruo item_end_expected = btrfs_item_offset_nr(leaf, 1671557ea5ddSQu Wenruo slot - 1); 1672*c7c01a4aSDavid Sterba if (unlikely(btrfs_item_end_nr(leaf, slot) != item_end_expected)) { 167386a6be3aSDavid Sterba generic_err(leaf, slot, 1674478d01b3SQu Wenruo "unexpected item end, have %u expect %u", 1675478d01b3SQu Wenruo btrfs_item_end_nr(leaf, slot), 1676478d01b3SQu Wenruo item_end_expected); 1677557ea5ddSQu Wenruo return -EUCLEAN; 1678557ea5ddSQu Wenruo } 1679557ea5ddSQu Wenruo 1680557ea5ddSQu Wenruo /* 1681557ea5ddSQu Wenruo * Check to make sure that we don't point outside of the leaf, 1682557ea5ddSQu Wenruo * just in case all the items are consistent to each other, but 1683557ea5ddSQu Wenruo * all point outside of the leaf. 1684557ea5ddSQu Wenruo */ 1685*c7c01a4aSDavid Sterba if (unlikely(btrfs_item_end_nr(leaf, slot) > 1686*c7c01a4aSDavid Sterba BTRFS_LEAF_DATA_SIZE(fs_info))) { 168786a6be3aSDavid Sterba generic_err(leaf, slot, 1688478d01b3SQu Wenruo "slot end outside of leaf, have %u expect range [0, %u]", 1689478d01b3SQu Wenruo btrfs_item_end_nr(leaf, slot), 1690478d01b3SQu Wenruo BTRFS_LEAF_DATA_SIZE(fs_info)); 1691557ea5ddSQu Wenruo return -EUCLEAN; 1692557ea5ddSQu Wenruo } 1693557ea5ddSQu Wenruo 1694557ea5ddSQu Wenruo /* Also check if the item pointer overlaps with btrfs item. */ 1695*c7c01a4aSDavid Sterba if (unlikely(btrfs_item_ptr_offset(leaf, slot) < 1696*c7c01a4aSDavid Sterba btrfs_item_nr_offset(slot) + sizeof(struct btrfs_item))) { 169786a6be3aSDavid Sterba generic_err(leaf, slot, 1698478d01b3SQu Wenruo "slot overlaps with its data, item end %lu data start %lu", 1699478d01b3SQu Wenruo btrfs_item_nr_offset(slot) + 1700478d01b3SQu Wenruo sizeof(struct btrfs_item), 1701478d01b3SQu Wenruo btrfs_item_ptr_offset(leaf, slot)); 1702557ea5ddSQu Wenruo return -EUCLEAN; 1703557ea5ddSQu Wenruo } 1704557ea5ddSQu Wenruo 170569fc6cbbSQu Wenruo if (check_item_data) { 170669fc6cbbSQu Wenruo /* 170769fc6cbbSQu Wenruo * Check if the item size and content meet other 170869fc6cbbSQu Wenruo * criteria 170969fc6cbbSQu Wenruo */ 17104e9845efSFilipe Manana ret = check_leaf_item(leaf, &key, slot, &prev_key); 1711*c7c01a4aSDavid Sterba if (unlikely(ret < 0)) 1712557ea5ddSQu Wenruo return ret; 171369fc6cbbSQu Wenruo } 1714557ea5ddSQu Wenruo 1715557ea5ddSQu Wenruo prev_key.objectid = key.objectid; 1716557ea5ddSQu Wenruo prev_key.type = key.type; 1717557ea5ddSQu Wenruo prev_key.offset = key.offset; 1718557ea5ddSQu Wenruo } 1719557ea5ddSQu Wenruo 1720557ea5ddSQu Wenruo return 0; 1721557ea5ddSQu Wenruo } 1722557ea5ddSQu Wenruo 17231c4360eeSDavid Sterba int btrfs_check_leaf_full(struct extent_buffer *leaf) 172469fc6cbbSQu Wenruo { 1725e2ccd361SDavid Sterba return check_leaf(leaf, true); 172669fc6cbbSQu Wenruo } 172702529d7aSQu Wenruo ALLOW_ERROR_INJECTION(btrfs_check_leaf_full, ERRNO); 172869fc6cbbSQu Wenruo 1729cfdaad5eSDavid Sterba int btrfs_check_leaf_relaxed(struct extent_buffer *leaf) 17302f659546SQu Wenruo { 1731e2ccd361SDavid Sterba return check_leaf(leaf, false); 17322f659546SQu Wenruo } 17332f659546SQu Wenruo 1734813fd1dcSDavid Sterba int btrfs_check_node(struct extent_buffer *node) 1735557ea5ddSQu Wenruo { 1736813fd1dcSDavid Sterba struct btrfs_fs_info *fs_info = node->fs_info; 1737557ea5ddSQu Wenruo unsigned long nr = btrfs_header_nritems(node); 1738557ea5ddSQu Wenruo struct btrfs_key key, next_key; 1739557ea5ddSQu Wenruo int slot; 1740f556faa4SQu Wenruo int level = btrfs_header_level(node); 1741557ea5ddSQu Wenruo u64 bytenr; 1742557ea5ddSQu Wenruo int ret = 0; 1743557ea5ddSQu Wenruo 1744*c7c01a4aSDavid Sterba if (unlikely(level <= 0 || level >= BTRFS_MAX_LEVEL)) { 174586a6be3aSDavid Sterba generic_err(node, 0, 1746f556faa4SQu Wenruo "invalid level for node, have %d expect [1, %d]", 1747f556faa4SQu Wenruo level, BTRFS_MAX_LEVEL - 1); 1748f556faa4SQu Wenruo return -EUCLEAN; 1749f556faa4SQu Wenruo } 1750*c7c01a4aSDavid Sterba if (unlikely(nr == 0 || nr > BTRFS_NODEPTRS_PER_BLOCK(fs_info))) { 17512f659546SQu Wenruo btrfs_crit(fs_info, 1752bba4f298SQu Wenruo "corrupt node: root=%llu block=%llu, nritems too %s, have %lu expect range [1,%u]", 17532f659546SQu Wenruo btrfs_header_owner(node), node->start, 1754bba4f298SQu Wenruo nr == 0 ? "small" : "large", nr, 17552f659546SQu Wenruo BTRFS_NODEPTRS_PER_BLOCK(fs_info)); 1756bba4f298SQu Wenruo return -EUCLEAN; 1757557ea5ddSQu Wenruo } 1758557ea5ddSQu Wenruo 1759557ea5ddSQu Wenruo for (slot = 0; slot < nr - 1; slot++) { 1760557ea5ddSQu Wenruo bytenr = btrfs_node_blockptr(node, slot); 1761557ea5ddSQu Wenruo btrfs_node_key_to_cpu(node, &key, slot); 1762557ea5ddSQu Wenruo btrfs_node_key_to_cpu(node, &next_key, slot + 1); 1763557ea5ddSQu Wenruo 1764*c7c01a4aSDavid Sterba if (unlikely(!bytenr)) { 176586a6be3aSDavid Sterba generic_err(node, slot, 1766bba4f298SQu Wenruo "invalid NULL node pointer"); 1767bba4f298SQu Wenruo ret = -EUCLEAN; 1768bba4f298SQu Wenruo goto out; 1769bba4f298SQu Wenruo } 1770*c7c01a4aSDavid Sterba if (unlikely(!IS_ALIGNED(bytenr, fs_info->sectorsize))) { 177186a6be3aSDavid Sterba generic_err(node, slot, 1772bba4f298SQu Wenruo "unaligned pointer, have %llu should be aligned to %u", 17732f659546SQu Wenruo bytenr, fs_info->sectorsize); 1774bba4f298SQu Wenruo ret = -EUCLEAN; 1775557ea5ddSQu Wenruo goto out; 1776557ea5ddSQu Wenruo } 1777557ea5ddSQu Wenruo 1778*c7c01a4aSDavid Sterba if (unlikely(btrfs_comp_cpu_keys(&key, &next_key) >= 0)) { 177986a6be3aSDavid Sterba generic_err(node, slot, 1780bba4f298SQu Wenruo "bad key order, current (%llu %u %llu) next (%llu %u %llu)", 1781bba4f298SQu Wenruo key.objectid, key.type, key.offset, 1782bba4f298SQu Wenruo next_key.objectid, next_key.type, 1783bba4f298SQu Wenruo next_key.offset); 1784bba4f298SQu Wenruo ret = -EUCLEAN; 1785557ea5ddSQu Wenruo goto out; 1786557ea5ddSQu Wenruo } 1787557ea5ddSQu Wenruo } 1788557ea5ddSQu Wenruo out: 1789557ea5ddSQu Wenruo return ret; 1790557ea5ddSQu Wenruo } 179102529d7aSQu Wenruo ALLOW_ERROR_INJECTION(btrfs_check_node, ERRNO); 1792