Lines Matching +full:slot +full:- +full:size
1 // SPDX-License-Identifier: GPL-2.0
20 #include <linux/error-injection.h>
23 #include "tree-checker.h"
24 #include "disk-io.h"
30 #include "file-item.h"
31 #include "inode-item.h"
50 * Append generic "corrupt leaf/node root=%llu block=%llu slot=%d: " to @fmt.
55 static void generic_err(const struct extent_buffer *eb, int slot, in generic_err() argument
58 const struct btrfs_fs_info *fs_info = eb->fs_info; in generic_err()
68 "corrupt %s: root=%llu block=%llu slot=%d, %pV", in generic_err()
70 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, &vaf); in generic_err()
80 static void file_extent_err(const struct extent_buffer *eb, int slot, in file_extent_err() argument
83 const struct btrfs_fs_info *fs_info = eb->fs_info; in file_extent_err()
88 btrfs_item_key_to_cpu(eb, &key, slot); in file_extent_err()
95 "corrupt %s: root=%llu block=%llu slot=%d ino=%llu file_offset=%llu, %pV", in file_extent_err()
97 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, in file_extent_err()
106 #define CHECK_FE_ALIGNED(leaf, slot, fi, name, alignment) \ argument
110 file_extent_err((leaf), (slot), \
126 end = ALIGN(key->offset + len, leaf->fs_info->sectorsize); in file_extent_end()
129 end = key->offset + len; in file_extent_end()
136 * key->objectid, which represents inode number
140 static void dir_item_err(const struct extent_buffer *eb, int slot, in dir_item_err() argument
143 const struct btrfs_fs_info *fs_info = eb->fs_info; in dir_item_err()
148 btrfs_item_key_to_cpu(eb, &key, slot); in dir_item_err()
155 "corrupt %s: root=%llu block=%llu slot=%d ino=%llu, %pV", in dir_item_err()
157 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, in dir_item_err()
163 * This functions checks prev_key->objectid, to ensure current key and prev_key
172 struct btrfs_key *key, int slot, in check_prev_ino() argument
176 if (slot == 0) in check_prev_ino()
179 /* Only these key->types needs to be checked */ in check_prev_ino()
180 ASSERT(key->type == BTRFS_XATTR_ITEM_KEY || in check_prev_ino()
181 key->type == BTRFS_INODE_REF_KEY || in check_prev_ino()
182 key->type == BTRFS_DIR_INDEX_KEY || in check_prev_ino()
183 key->type == BTRFS_DIR_ITEM_KEY || in check_prev_ino()
184 key->type == BTRFS_EXTENT_DATA_KEY); in check_prev_ino()
193 if (key->objectid == prev_key->objectid) in check_prev_ino()
197 dir_item_err(leaf, slot, in check_prev_ino()
199 prev_key->objectid, key->objectid); in check_prev_ino()
203 struct btrfs_key *key, int slot, in check_extent_data_item() argument
206 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_extent_data_item()
208 u32 sectorsize = fs_info->sectorsize; in check_extent_data_item()
209 u32 item_size = btrfs_item_size(leaf, slot); in check_extent_data_item()
212 if (unlikely(!IS_ALIGNED(key->offset, sectorsize))) { in check_extent_data_item()
213 file_extent_err(leaf, slot, in check_extent_data_item()
215 key->offset, sectorsize); in check_extent_data_item()
216 return -EUCLEAN; in check_extent_data_item()
220 * Previous key must have the same key->objectid (ino). in check_extent_data_item()
225 if (unlikely(!check_prev_ino(leaf, key, slot, prev_key))) in check_extent_data_item()
226 return -EUCLEAN; in check_extent_data_item()
228 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); in check_extent_data_item()
235 file_extent_err(leaf, slot, in check_extent_data_item()
236 "invalid item size, have %u expect [%zu, %u)", in check_extent_data_item()
239 return -EUCLEAN; in check_extent_data_item()
243 file_extent_err(leaf, slot, in check_extent_data_item()
246 BTRFS_NR_FILE_EXTENT_TYPES - 1); in check_extent_data_item()
247 return -EUCLEAN; in check_extent_data_item()
256 file_extent_err(leaf, slot, in check_extent_data_item()
259 BTRFS_NR_COMPRESS_TYPES - 1); in check_extent_data_item()
260 return -EUCLEAN; in check_extent_data_item()
263 file_extent_err(leaf, slot, in check_extent_data_item()
266 return -EUCLEAN; in check_extent_data_item()
270 if (unlikely(key->offset)) { in check_extent_data_item()
271 file_extent_err(leaf, slot, in check_extent_data_item()
273 key->offset); in check_extent_data_item()
274 return -EUCLEAN; in check_extent_data_item()
277 /* Compressed inline extent has no on-disk size, skip it */ in check_extent_data_item()
282 /* Uncompressed inline extent size must match item size */ in check_extent_data_item()
285 file_extent_err(leaf, slot, in check_extent_data_item()
289 return -EUCLEAN; in check_extent_data_item()
294 /* Regular or preallocated extent has fixed item size */ in check_extent_data_item()
296 file_extent_err(leaf, slot, in check_extent_data_item()
297 "invalid item size for reg/prealloc file extent, have %u expect %zu", in check_extent_data_item()
299 return -EUCLEAN; in check_extent_data_item()
301 if (unlikely(CHECK_FE_ALIGNED(leaf, slot, fi, ram_bytes, sectorsize) || in check_extent_data_item()
302 CHECK_FE_ALIGNED(leaf, slot, fi, disk_bytenr, sectorsize) || in check_extent_data_item()
303 CHECK_FE_ALIGNED(leaf, slot, fi, disk_num_bytes, sectorsize) || in check_extent_data_item()
304 CHECK_FE_ALIGNED(leaf, slot, fi, offset, sectorsize) || in check_extent_data_item()
305 CHECK_FE_ALIGNED(leaf, slot, fi, num_bytes, sectorsize))) in check_extent_data_item()
306 return -EUCLEAN; in check_extent_data_item()
310 key->offset, &extent_end))) { in check_extent_data_item()
311 file_extent_err(leaf, slot, in check_extent_data_item()
313 key->offset, in check_extent_data_item()
315 return -EUCLEAN; in check_extent_data_item()
322 if (slot > 0 && in check_extent_data_item()
323 prev_key->objectid == key->objectid && in check_extent_data_item()
324 prev_key->type == BTRFS_EXTENT_DATA_KEY) { in check_extent_data_item()
328 prev_fi = btrfs_item_ptr(leaf, slot - 1, in check_extent_data_item()
331 if (unlikely(prev_end > key->offset)) { in check_extent_data_item()
332 file_extent_err(leaf, slot - 1, in check_extent_data_item()
334 prev_end, key->offset); in check_extent_data_item()
335 return -EUCLEAN; in check_extent_data_item()
343 int slot, struct btrfs_key *prev_key) in check_csum_item() argument
345 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_csum_item()
346 u32 sectorsize = fs_info->sectorsize; in check_csum_item()
347 const u32 csumsize = fs_info->csum_size; in check_csum_item()
349 if (unlikely(key->objectid != BTRFS_EXTENT_CSUM_OBJECTID)) { in check_csum_item()
350 generic_err(leaf, slot, in check_csum_item()
352 key->objectid, BTRFS_EXTENT_CSUM_OBJECTID); in check_csum_item()
353 return -EUCLEAN; in check_csum_item()
355 if (unlikely(!IS_ALIGNED(key->offset, sectorsize))) { in check_csum_item()
356 generic_err(leaf, slot, in check_csum_item()
358 key->offset, sectorsize); in check_csum_item()
359 return -EUCLEAN; in check_csum_item()
361 if (unlikely(!IS_ALIGNED(btrfs_item_size(leaf, slot), csumsize))) { in check_csum_item()
362 generic_err(leaf, slot, in check_csum_item()
363 "unaligned item size for csum item, have %u should be aligned to %u", in check_csum_item()
364 btrfs_item_size(leaf, slot), csumsize); in check_csum_item()
365 return -EUCLEAN; in check_csum_item()
367 if (slot > 0 && prev_key->type == BTRFS_EXTENT_CSUM_KEY) { in check_csum_item()
371 prev_item_size = btrfs_item_size(leaf, slot - 1); in check_csum_item()
373 prev_csum_end += prev_key->offset; in check_csum_item()
374 if (unlikely(prev_csum_end > key->offset)) { in check_csum_item()
375 generic_err(leaf, slot - 1, in check_csum_item()
377 prev_csum_end, key->offset); in check_csum_item()
378 return -EUCLEAN; in check_csum_item()
385 #define inode_item_err(eb, slot, fmt, ...) \ argument
386 dir_item_err(eb, slot, fmt, __VA_ARGS__)
389 int slot) in check_inode_key() argument
394 btrfs_item_key_to_cpu(leaf, &item_key, slot); in check_inode_key()
399 if (unlikely(key->objectid != 0 || key->type != 0 || in check_inode_key()
400 key->offset != 0)) in check_inode_key()
401 return -EUCLEAN; in check_inode_key()
405 if (unlikely((key->objectid < BTRFS_FIRST_FREE_OBJECTID || in check_inode_key()
406 key->objectid > BTRFS_LAST_FREE_OBJECTID) && in check_inode_key()
407 key->objectid != BTRFS_ROOT_TREE_DIR_OBJECTID && in check_inode_key()
408 key->objectid != BTRFS_FREE_INO_OBJECTID)) { in check_inode_key()
410 generic_err(leaf, slot, in check_inode_key()
412 key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID, in check_inode_key()
417 dir_item_err(leaf, slot, in check_inode_key()
419 key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID, in check_inode_key()
424 return -EUCLEAN; in check_inode_key()
426 if (unlikely(key->offset != 0)) { in check_inode_key()
428 inode_item_err(leaf, slot, in check_inode_key()
430 key->offset); in check_inode_key()
432 dir_item_err(leaf, slot, in check_inode_key()
434 key->offset); in check_inode_key()
435 return -EUCLEAN; in check_inode_key()
441 int slot) in check_root_key() argument
446 btrfs_item_key_to_cpu(leaf, &item_key, slot); in check_root_key()
455 if (unlikely(is_root_item && key->objectid == BTRFS_TREE_RELOC_OBJECTID && in check_root_key()
456 !is_fstree(key->offset))) { in check_root_key()
457 generic_err(leaf, slot, in check_root_key()
459 key->offset); in check_root_key()
460 return -EUCLEAN; in check_root_key()
464 if (unlikely(key->objectid == 0)) { in check_root_key()
466 generic_err(leaf, slot, "invalid root id 0"); in check_root_key()
468 dir_item_err(leaf, slot, in check_root_key()
470 return -EUCLEAN; in check_root_key()
473 /* DIR_ITEM/INDEX/INODE_REF is not allowed to point to non-fs trees */ in check_root_key()
474 if (unlikely(!is_fstree(key->objectid) && !is_root_item)) { in check_root_key()
475 dir_item_err(leaf, slot, in check_root_key()
477 key->objectid, BTRFS_FIRST_FREE_OBJECTID, in check_root_key()
479 return -EUCLEAN; in check_root_key()
483 * ROOT_ITEM with non-zero offset means this is a snapshot, created at in check_root_key()
485 * Furthermore, for location key in DIR_ITEM, its offset is always -1. in check_root_key()
487 * So here we only check offset for reloc tree whose key->offset must in check_root_key()
490 if (unlikely(key->objectid == BTRFS_TREE_RELOC_OBJECTID && in check_root_key()
491 key->offset == 0)) { in check_root_key()
492 generic_err(leaf, slot, "invalid root id 0 for reloc tree"); in check_root_key()
493 return -EUCLEAN; in check_root_key()
500 int slot) in check_dir_item() argument
502 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_dir_item()
504 u32 item_size = btrfs_item_size(leaf, slot); in check_dir_item()
507 if (unlikely(!check_prev_ino(leaf, key, slot, prev_key))) in check_dir_item()
508 return -EUCLEAN; in check_dir_item()
510 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item); in check_dir_item()
523 dir_item_err(leaf, slot, in check_dir_item()
526 return -EUCLEAN; in check_dir_item()
532 ret = check_root_key(leaf, &location_key, slot); in check_dir_item()
537 ret = check_inode_key(leaf, &location_key, slot); in check_dir_item()
541 dir_item_err(leaf, slot, in check_dir_item()
545 return -EUCLEAN; in check_dir_item()
551 dir_item_err(leaf, slot, in check_dir_item()
554 return -EUCLEAN; in check_dir_item()
557 if (unlikely(key->type == BTRFS_XATTR_ITEM_KEY && in check_dir_item()
559 dir_item_err(leaf, slot, in check_dir_item()
562 return -EUCLEAN; in check_dir_item()
565 key->type != BTRFS_XATTR_ITEM_KEY)) { in check_dir_item()
566 dir_item_err(leaf, slot, in check_dir_item()
567 "xattr dir type found for non-XATTR key"); in check_dir_item()
568 return -EUCLEAN; in check_dir_item()
579 dir_item_err(leaf, slot, in check_dir_item()
582 return -EUCLEAN; in check_dir_item()
585 dir_item_err(leaf, slot, in check_dir_item()
589 return -EUCLEAN; in check_dir_item()
593 dir_item_err(leaf, slot, in check_dir_item()
596 return -EUCLEAN; in check_dir_item()
603 dir_item_err(leaf, slot, in check_dir_item()
606 return -EUCLEAN; in check_dir_item()
610 * Special check for XATTR/DIR_ITEM, as key->offset is name in check_dir_item()
613 if (key->type == BTRFS_DIR_ITEM_KEY || in check_dir_item()
614 key->type == BTRFS_XATTR_ITEM_KEY) { in check_dir_item()
620 if (unlikely(key->offset != name_hash)) { in check_dir_item()
621 dir_item_err(leaf, slot, in check_dir_item()
623 name_hash, key->offset); in check_dir_item()
624 return -EUCLEAN; in check_dir_item()
635 static void block_group_err(const struct extent_buffer *eb, int slot, in block_group_err() argument
638 const struct btrfs_fs_info *fs_info = eb->fs_info; in block_group_err()
643 btrfs_item_key_to_cpu(eb, &key, slot); in block_group_err()
650 "corrupt %s: root=%llu block=%llu slot=%d bg_start=%llu bg_len=%llu, %pV", in block_group_err()
652 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, in block_group_err()
658 struct btrfs_key *key, int slot) in check_block_group_item() argument
660 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_block_group_item()
662 u32 item_size = btrfs_item_size(leaf, slot); in check_block_group_item()
669 * handle it. We care more about the size. in check_block_group_item()
671 if (unlikely(key->offset == 0)) { in check_block_group_item()
672 block_group_err(leaf, slot, in check_block_group_item()
673 "invalid block group size 0"); in check_block_group_item()
674 return -EUCLEAN; in check_block_group_item()
678 block_group_err(leaf, slot, in check_block_group_item()
679 "invalid item size, have %u expect %zu", in check_block_group_item()
681 return -EUCLEAN; in check_block_group_item()
684 read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot), in check_block_group_item()
694 if (unlikely(fs_info->nr_global_roots && in check_block_group_item()
695 chunk_objectid >= fs_info->nr_global_roots)) { in check_block_group_item()
696 block_group_err(leaf, slot, in check_block_group_item()
699 fs_info->nr_global_roots); in check_block_group_item()
700 return -EUCLEAN; in check_block_group_item()
703 block_group_err(leaf, slot, in check_block_group_item()
707 return -EUCLEAN; in check_block_group_item()
710 if (unlikely(btrfs_stack_block_group_used(&bgi) > key->offset)) { in check_block_group_item()
711 block_group_err(leaf, slot, in check_block_group_item()
713 btrfs_stack_block_group_used(&bgi), key->offset); in check_block_group_item()
714 return -EUCLEAN; in check_block_group_item()
719 block_group_err(leaf, slot, in check_block_group_item()
723 return -EUCLEAN; in check_block_group_item()
732 block_group_err(leaf, slot, in check_block_group_item()
738 return -EUCLEAN; in check_block_group_item()
749 const struct btrfs_fs_info *fs_info = leaf->fs_info; in chunk_err()
754 int slot = -1; in chunk_err() local
757 is_sb = (leaf->start == BTRFS_SUPER_INFO_OFFSET); in chunk_err()
761 * Get the slot number by iterating through all slots, this in chunk_err()
767 slot = i; in chunk_err()
782 "corrupt leaf: root=%llu block=%llu slot=%d chunk_start=%llu, %pV", in chunk_err()
783 BTRFS_CHUNK_TREE_OBJECTID, leaf->start, slot, in chunk_err()
791 * Return -EUCLEAN if anything is corrupted.
797 struct btrfs_fs_info *fs_info = leaf->fs_info; in btrfs_check_chunk_valid()
822 return -EUCLEAN; in btrfs_check_chunk_valid()
828 return -EUCLEAN; in btrfs_check_chunk_valid()
834 return -EUCLEAN; in btrfs_check_chunk_valid()
836 if (unlikely(!IS_ALIGNED(logical, fs_info->sectorsize))) { in btrfs_check_chunk_valid()
839 logical, fs_info->sectorsize); in btrfs_check_chunk_valid()
840 return -EUCLEAN; in btrfs_check_chunk_valid()
842 if (unlikely(btrfs_chunk_sector_size(leaf, chunk) != fs_info->sectorsize)) { in btrfs_check_chunk_valid()
846 fs_info->sectorsize); in btrfs_check_chunk_valid()
847 return -EUCLEAN; in btrfs_check_chunk_valid()
849 if (unlikely(!length || !IS_ALIGNED(length, fs_info->sectorsize))) { in btrfs_check_chunk_valid()
852 return -EUCLEAN; in btrfs_check_chunk_valid()
858 return -EUCLEAN; in btrfs_check_chunk_valid()
864 return -EUCLEAN; in btrfs_check_chunk_valid()
867 * We artificially limit the chunk size, so that the number of stripes in btrfs_check_chunk_valid()
878 return -EUCLEAN; in btrfs_check_chunk_valid()
887 return -EUCLEAN; in btrfs_check_chunk_valid()
895 return -EUCLEAN; in btrfs_check_chunk_valid()
901 return -EUCLEAN; in btrfs_check_chunk_valid()
910 return -EUCLEAN; in btrfs_check_chunk_valid()
913 features = btrfs_super_incompat_flags(fs_info->super_copy); in btrfs_check_chunk_valid()
921 "mixed chunk type in non-mixed mode: 0x%llx", type); in btrfs_check_chunk_valid()
922 return -EUCLEAN; in btrfs_check_chunk_valid()
946 return -EUCLEAN; in btrfs_check_chunk_valid()
955 * The common btrfs_check_chunk_valid() doesn't check item size since it needs
960 struct btrfs_key *key, int slot) in check_leaf_chunk_item() argument
964 if (unlikely(btrfs_item_size(leaf, slot) < sizeof(struct btrfs_chunk))) { in check_leaf_chunk_item()
965 chunk_err(leaf, chunk, key->offset, in check_leaf_chunk_item()
966 "invalid chunk item size: have %u expect [%zu, %u)", in check_leaf_chunk_item()
967 btrfs_item_size(leaf, slot), in check_leaf_chunk_item()
969 BTRFS_LEAF_DATA_SIZE(leaf->fs_info)); in check_leaf_chunk_item()
970 return -EUCLEAN; in check_leaf_chunk_item()
979 btrfs_item_size(leaf, slot))) { in check_leaf_chunk_item()
980 chunk_err(leaf, chunk, key->offset, in check_leaf_chunk_item()
981 "invalid chunk item size: have %u expect %lu", in check_leaf_chunk_item()
982 btrfs_item_size(leaf, slot), in check_leaf_chunk_item()
984 return -EUCLEAN; in check_leaf_chunk_item()
987 return btrfs_check_chunk_valid(leaf, chunk, key->offset); in check_leaf_chunk_item()
992 static void dev_item_err(const struct extent_buffer *eb, int slot, in dev_item_err() argument
999 btrfs_item_key_to_cpu(eb, &key, slot); in dev_item_err()
1005 btrfs_crit(eb->fs_info, in dev_item_err()
1006 "corrupt %s: root=%llu block=%llu slot=%d devid=%llu %pV", in dev_item_err()
1008 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, in dev_item_err()
1014 struct btrfs_key *key, int slot) in check_dev_item() argument
1017 const u32 item_size = btrfs_item_size(leaf, slot); in check_dev_item()
1019 if (unlikely(key->objectid != BTRFS_DEV_ITEMS_OBJECTID)) { in check_dev_item()
1020 dev_item_err(leaf, slot, in check_dev_item()
1022 key->objectid, BTRFS_DEV_ITEMS_OBJECTID); in check_dev_item()
1023 return -EUCLEAN; in check_dev_item()
1027 dev_item_err(leaf, slot, "invalid item size: has %u expect %zu", in check_dev_item()
1029 return -EUCLEAN; in check_dev_item()
1032 ditem = btrfs_item_ptr(leaf, slot, struct btrfs_dev_item); in check_dev_item()
1033 if (unlikely(btrfs_device_id(leaf, ditem) != key->offset)) { in check_dev_item()
1034 dev_item_err(leaf, slot, in check_dev_item()
1036 key->offset, btrfs_device_id(leaf, ditem)); in check_dev_item()
1037 return -EUCLEAN; in check_dev_item()
1042 * it can be 0 for device removal. Device size check can only be done in check_dev_item()
1047 dev_item_err(leaf, slot, in check_dev_item()
1051 return -EUCLEAN; in check_dev_item()
1061 struct btrfs_key *key, int slot) in check_inode_item() argument
1063 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_inode_item()
1065 u64 super_gen = btrfs_super_generation(fs_info->super_copy); in check_inode_item()
1067 const u32 item_size = btrfs_item_size(leaf, slot); in check_inode_item()
1073 ret = check_inode_key(leaf, key, slot); in check_inode_item()
1078 generic_err(leaf, slot, "invalid item size: has %u expect %zu", in check_inode_item()
1080 return -EUCLEAN; in check_inode_item()
1083 iitem = btrfs_item_ptr(leaf, slot, struct btrfs_inode_item); in check_inode_item()
1087 inode_item_err(leaf, slot, in check_inode_item()
1091 return -EUCLEAN; in check_inode_item()
1095 inode_item_err(leaf, slot, in check_inode_item()
1098 return -EUCLEAN; in check_inode_item()
1102 * For size and nbytes it's better not to be too strict, as for dir in check_inode_item()
1103 * item its size/nbytes can easily get wrong, but doesn't affect in check_inode_item()
1108 inode_item_err(leaf, slot, in check_inode_item()
1111 return -EUCLEAN; in check_inode_item()
1121 inode_item_err(leaf, slot, in check_inode_item()
1124 return -EUCLEAN; in check_inode_item()
1128 inode_item_err(leaf, slot, in check_inode_item()
1131 return -EUCLEAN; in check_inode_item()
1135 inode_item_err(leaf, slot, in check_inode_item()
1137 return -EUCLEAN; in check_inode_item()
1139 if (unlikely(!sb_rdonly(fs_info->sb) && in check_inode_item()
1141 inode_item_err(leaf, slot, in check_inode_item()
1142 "unknown ro-compat flags detected on writeable mount: 0x%x", in check_inode_item()
1144 return -EUCLEAN; in check_inode_item()
1150 int slot) in check_root_item() argument
1152 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_root_item()
1158 ret = check_root_key(leaf, key, slot); in check_root_item()
1162 if (unlikely(btrfs_item_size(leaf, slot) != sizeof(ri) && in check_root_item()
1163 btrfs_item_size(leaf, slot) != in check_root_item()
1165 generic_err(leaf, slot, in check_root_item()
1166 "invalid root item size, have %u expect %zu or %u", in check_root_item()
1167 btrfs_item_size(leaf, slot), sizeof(ri), in check_root_item()
1169 return -EUCLEAN; in check_root_item()
1177 read_extent_buffer(leaf, &ri, btrfs_item_ptr_offset(leaf, slot), in check_root_item()
1178 btrfs_item_size(leaf, slot)); in check_root_item()
1182 btrfs_super_generation(fs_info->super_copy) + 1)) { in check_root_item()
1183 generic_err(leaf, slot, in check_root_item()
1186 btrfs_super_generation(fs_info->super_copy) + 1); in check_root_item()
1187 return -EUCLEAN; in check_root_item()
1190 btrfs_super_generation(fs_info->super_copy) + 1)) { in check_root_item()
1191 generic_err(leaf, slot, in check_root_item()
1194 btrfs_super_generation(fs_info->super_copy) + 1); in check_root_item()
1195 return -EUCLEAN; in check_root_item()
1198 btrfs_super_generation(fs_info->super_copy) + 1)) { in check_root_item()
1199 generic_err(leaf, slot, in check_root_item()
1202 btrfs_super_generation(fs_info->super_copy) + 1); in check_root_item()
1203 return -EUCLEAN; in check_root_item()
1207 if (unlikely(!IS_ALIGNED(btrfs_root_bytenr(&ri), fs_info->sectorsize))) { in check_root_item()
1208 generic_err(leaf, slot, in check_root_item()
1210 btrfs_root_bytenr(&ri), fs_info->sectorsize); in check_root_item()
1211 return -EUCLEAN; in check_root_item()
1214 generic_err(leaf, slot, in check_root_item()
1216 btrfs_root_level(&ri), BTRFS_MAX_LEVEL - 1); in check_root_item()
1217 return -EUCLEAN; in check_root_item()
1220 generic_err(leaf, slot, in check_root_item()
1222 btrfs_root_drop_level(&ri), BTRFS_MAX_LEVEL - 1); in check_root_item()
1223 return -EUCLEAN; in check_root_item()
1228 generic_err(leaf, slot, in check_root_item()
1231 return -EUCLEAN; in check_root_item()
1238 static void extent_err(const struct extent_buffer *eb, int slot, in extent_err() argument
1247 btrfs_item_key_to_cpu(eb, &key, slot); in extent_err()
1252 len = eb->fs_info->nodesize; in extent_err()
1260 btrfs_crit(eb->fs_info, in extent_err()
1261 "corrupt %s: block=%llu slot=%d extent bytenr=%llu len=%llu %pV", in extent_err()
1263 eb->start, slot, bytenr, len, &vaf); in extent_err()
1268 struct btrfs_key *key, int slot, in check_extent_item() argument
1271 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_extent_item()
1276 const u32 item_size = btrfs_item_size(leaf, slot); in check_extent_item()
1282 if (unlikely(key->type == BTRFS_METADATA_ITEM_KEY && in check_extent_item()
1284 generic_err(leaf, slot, in check_extent_item()
1286 return -EUCLEAN; in check_extent_item()
1288 /* key->objectid is the bytenr for both key types */ in check_extent_item()
1289 if (unlikely(!IS_ALIGNED(key->objectid, fs_info->sectorsize))) { in check_extent_item()
1290 generic_err(leaf, slot, in check_extent_item()
1292 key->objectid, fs_info->sectorsize); in check_extent_item()
1293 return -EUCLEAN; in check_extent_item()
1296 /* key->offset is tree level for METADATA_ITEM_KEY */ in check_extent_item()
1297 if (unlikely(key->type == BTRFS_METADATA_ITEM_KEY && in check_extent_item()
1298 key->offset >= BTRFS_MAX_LEVEL)) { in check_extent_item()
1299 extent_err(leaf, slot, in check_extent_item()
1301 key->offset, BTRFS_MAX_LEVEL - 1); in check_extent_item()
1302 return -EUCLEAN; in check_extent_item()
1325 extent_err(leaf, slot, in check_extent_item()
1326 "invalid item size, have %u expect [%zu, %u)", in check_extent_item()
1329 return -EUCLEAN; in check_extent_item()
1331 end = item_size + btrfs_item_ptr_offset(leaf, slot); in check_extent_item()
1334 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item); in check_extent_item()
1339 btrfs_super_generation(fs_info->super_copy) + 1)) { in check_extent_item()
1340 extent_err(leaf, slot, in check_extent_item()
1343 btrfs_super_generation(fs_info->super_copy) + 1); in check_extent_item()
1344 return -EUCLEAN; in check_extent_item()
1348 extent_err(leaf, slot, in check_extent_item()
1352 return -EUCLEAN; in check_extent_item()
1356 if (unlikely(key->type == BTRFS_EXTENT_ITEM_KEY && in check_extent_item()
1357 key->offset != fs_info->nodesize)) { in check_extent_item()
1358 extent_err(leaf, slot, in check_extent_item()
1360 key->offset, fs_info->nodesize); in check_extent_item()
1361 return -EUCLEAN; in check_extent_item()
1364 if (unlikely(key->type != BTRFS_EXTENT_ITEM_KEY)) { in check_extent_item()
1365 extent_err(leaf, slot, in check_extent_item()
1367 key->type, BTRFS_EXTENT_ITEM_KEY); in check_extent_item()
1368 return -EUCLEAN; in check_extent_item()
1370 if (unlikely(!IS_ALIGNED(key->offset, fs_info->sectorsize))) { in check_extent_item()
1371 extent_err(leaf, slot, in check_extent_item()
1373 key->offset, fs_info->sectorsize); in check_extent_item()
1374 return -EUCLEAN; in check_extent_item()
1377 extent_err(leaf, slot, in check_extent_item()
1379 return -EUCLEAN; in check_extent_item()
1385 if (is_tree_block && key->type != BTRFS_METADATA_ITEM_KEY) { in check_extent_item()
1390 extent_err(leaf, slot, in check_extent_item()
1393 BTRFS_MAX_LEVEL - 1); in check_extent_item()
1394 return -EUCLEAN; in check_extent_item()
1409 extent_err(leaf, slot, in check_extent_item()
1410 "inline ref item overflows extent item, ptr %lu iref size %zu end %lu", in check_extent_item()
1412 return -EUCLEAN; in check_extent_item()
1418 extent_err(leaf, slot, in check_extent_item()
1419 "inline ref item overflows extent item, ptr %lu iref size %u end %lu", in check_extent_item()
1421 return -EUCLEAN; in check_extent_item()
1432 fs_info->sectorsize))) { in check_extent_item()
1433 extent_err(leaf, slot, in check_extent_item()
1435 inline_offset, fs_info->sectorsize); in check_extent_item()
1436 return -EUCLEAN; in check_extent_item()
1445 dref = (struct btrfs_extent_data_ref *)(&iref->offset); in check_extent_item()
1448 fs_info->sectorsize))) { in check_extent_item()
1449 extent_err(leaf, slot, in check_extent_item()
1451 dref_offset, fs_info->sectorsize); in check_extent_item()
1452 return -EUCLEAN; in check_extent_item()
1460 fs_info->sectorsize))) { in check_extent_item()
1461 extent_err(leaf, slot, in check_extent_item()
1463 inline_offset, fs_info->sectorsize); in check_extent_item()
1464 return -EUCLEAN; in check_extent_item()
1469 extent_err(leaf, slot, "unknown inline ref type: %u", in check_extent_item()
1471 return -EUCLEAN; in check_extent_item()
1477 extent_err(leaf, slot, in check_extent_item()
1478 "invalid extent item size, padding bytes found"); in check_extent_item()
1479 return -EUCLEAN; in check_extent_item()
1484 extent_err(leaf, slot, in check_extent_item()
1487 return -EUCLEAN; in check_extent_item()
1490 if ((prev_key->type == BTRFS_EXTENT_ITEM_KEY) || in check_extent_item()
1491 (prev_key->type == BTRFS_METADATA_ITEM_KEY)) { in check_extent_item()
1492 u64 prev_end = prev_key->objectid; in check_extent_item()
1494 if (prev_key->type == BTRFS_METADATA_ITEM_KEY) in check_extent_item()
1495 prev_end += fs_info->nodesize; in check_extent_item()
1497 prev_end += prev_key->offset; in check_extent_item()
1499 if (unlikely(prev_end > key->objectid)) { in check_extent_item()
1500 extent_err(leaf, slot, in check_extent_item()
1502 prev_key->objectid, prev_key->type, in check_extent_item()
1503 prev_key->offset, key->objectid, key->type, in check_extent_item()
1504 key->offset); in check_extent_item()
1505 return -EUCLEAN; in check_extent_item()
1513 struct btrfs_key *key, int slot) in check_simple_keyed_refs() argument
1517 if (key->type == BTRFS_SHARED_DATA_REF_KEY) in check_simple_keyed_refs()
1520 if (unlikely(btrfs_item_size(leaf, slot) != expect_item_size)) { in check_simple_keyed_refs()
1521 generic_err(leaf, slot, in check_simple_keyed_refs()
1522 "invalid item size, have %u expect %u for key type %u", in check_simple_keyed_refs()
1523 btrfs_item_size(leaf, slot), in check_simple_keyed_refs()
1524 expect_item_size, key->type); in check_simple_keyed_refs()
1525 return -EUCLEAN; in check_simple_keyed_refs()
1527 if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) { in check_simple_keyed_refs()
1528 generic_err(leaf, slot, in check_simple_keyed_refs()
1530 key->objectid, leaf->fs_info->sectorsize); in check_simple_keyed_refs()
1531 return -EUCLEAN; in check_simple_keyed_refs()
1533 if (unlikely(key->type != BTRFS_TREE_BLOCK_REF_KEY && in check_simple_keyed_refs()
1534 !IS_ALIGNED(key->offset, leaf->fs_info->sectorsize))) { in check_simple_keyed_refs()
1535 extent_err(leaf, slot, in check_simple_keyed_refs()
1537 key->offset, leaf->fs_info->sectorsize); in check_simple_keyed_refs()
1538 return -EUCLEAN; in check_simple_keyed_refs()
1544 struct btrfs_key *key, int slot) in check_extent_data_ref() argument
1547 unsigned long ptr = btrfs_item_ptr_offset(leaf, slot); in check_extent_data_ref()
1548 const unsigned long end = ptr + btrfs_item_size(leaf, slot); in check_extent_data_ref()
1550 if (unlikely(btrfs_item_size(leaf, slot) % sizeof(*dref) != 0)) { in check_extent_data_ref()
1551 generic_err(leaf, slot, in check_extent_data_ref()
1552 "invalid item size, have %u expect aligned to %zu for key type %u", in check_extent_data_ref()
1553 btrfs_item_size(leaf, slot), in check_extent_data_ref()
1554 sizeof(*dref), key->type); in check_extent_data_ref()
1555 return -EUCLEAN; in check_extent_data_ref()
1557 if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) { in check_extent_data_ref()
1558 generic_err(leaf, slot, in check_extent_data_ref()
1560 key->objectid, leaf->fs_info->sectorsize); in check_extent_data_ref()
1561 return -EUCLEAN; in check_extent_data_ref()
1572 if (unlikely(!IS_ALIGNED(offset, leaf->fs_info->sectorsize))) { in check_extent_data_ref()
1573 extent_err(leaf, slot, in check_extent_data_ref()
1575 offset, leaf->fs_info->sectorsize); in check_extent_data_ref()
1576 return -EUCLEAN; in check_extent_data_ref()
1582 #define inode_ref_err(eb, slot, fmt, args...) \ argument
1583 inode_item_err(eb, slot, fmt, ##args)
1586 int slot) in check_inode_ref() argument
1592 if (unlikely(!check_prev_ino(leaf, key, slot, prev_key))) in check_inode_ref()
1593 return -EUCLEAN; in check_inode_ref()
1595 if (unlikely(btrfs_item_size(leaf, slot) <= sizeof(*iref))) { in check_inode_ref()
1596 inode_ref_err(leaf, slot, in check_inode_ref()
1597 "invalid item size, have %u expect (%zu, %u)", in check_inode_ref()
1598 btrfs_item_size(leaf, slot), in check_inode_ref()
1599 sizeof(*iref), BTRFS_LEAF_DATA_SIZE(leaf->fs_info)); in check_inode_ref()
1600 return -EUCLEAN; in check_inode_ref()
1603 ptr = btrfs_item_ptr_offset(leaf, slot); in check_inode_ref()
1604 end = ptr + btrfs_item_size(leaf, slot); in check_inode_ref()
1609 inode_ref_err(leaf, slot, in check_inode_ref()
1612 return -EUCLEAN; in check_inode_ref()
1618 inode_ref_err(leaf, slot, in check_inode_ref()
1621 return -EUCLEAN; in check_inode_ref()
1635 * Common point to switch the item-specific validation.
1639 int slot, in check_leaf_item() argument
1645 switch (key->type) { in check_leaf_item()
1647 ret = check_extent_data_item(leaf, key, slot, prev_key); in check_leaf_item()
1650 ret = check_csum_item(leaf, key, slot, prev_key); in check_leaf_item()
1655 ret = check_dir_item(leaf, key, prev_key, slot); in check_leaf_item()
1658 ret = check_inode_ref(leaf, key, prev_key, slot); in check_leaf_item()
1661 ret = check_block_group_item(leaf, key, slot); in check_leaf_item()
1664 chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk); in check_leaf_item()
1665 ret = check_leaf_chunk_item(leaf, chunk, key, slot); in check_leaf_item()
1668 ret = check_dev_item(leaf, key, slot); in check_leaf_item()
1671 ret = check_inode_item(leaf, key, slot); in check_leaf_item()
1674 ret = check_root_item(leaf, key, slot); in check_leaf_item()
1678 ret = check_extent_item(leaf, key, slot, prev_key); in check_leaf_item()
1683 ret = check_simple_keyed_refs(leaf, key, slot); in check_leaf_item()
1686 ret = check_extent_data_ref(leaf, key, slot); in check_leaf_item()
1697 struct btrfs_fs_info *fs_info = leaf->fs_info; in __btrfs_check_leaf()
1702 int slot; in __btrfs_check_leaf() local
1763 * 2) item offset and size in __btrfs_check_leaf()
1769 for (slot = 0; slot < nritems; slot++) { in __btrfs_check_leaf()
1773 btrfs_item_key_to_cpu(leaf, &key, slot); in __btrfs_check_leaf()
1777 generic_err(leaf, slot, in __btrfs_check_leaf()
1785 item_data_end = (u64)btrfs_item_offset(leaf, slot) + in __btrfs_check_leaf()
1786 btrfs_item_size(leaf, slot); in __btrfs_check_leaf()
1792 if (slot == 0) in __btrfs_check_leaf()
1796 slot - 1); in __btrfs_check_leaf()
1798 generic_err(leaf, slot, in __btrfs_check_leaf()
1810 generic_err(leaf, slot, in __btrfs_check_leaf()
1811 "slot end outside of leaf, have %llu expect range [0, %u]", in __btrfs_check_leaf()
1817 if (unlikely(btrfs_item_ptr_offset(leaf, slot) < in __btrfs_check_leaf()
1818 btrfs_item_nr_offset(leaf, slot) + sizeof(struct btrfs_item))) { in __btrfs_check_leaf()
1819 generic_err(leaf, slot, in __btrfs_check_leaf()
1820 "slot overlaps with its data, item end %lu data start %lu", in __btrfs_check_leaf()
1821 btrfs_item_nr_offset(leaf, slot) + in __btrfs_check_leaf()
1823 btrfs_item_ptr_offset(leaf, slot)); in __btrfs_check_leaf()
1835 * Check if the item size and content meet other in __btrfs_check_leaf()
1838 ret = check_leaf_item(leaf, &key, slot, &prev_key); in __btrfs_check_leaf()
1857 return -EUCLEAN; in btrfs_check_leaf()
1864 struct btrfs_fs_info *fs_info = node->fs_info; in __btrfs_check_node()
1867 int slot; in __btrfs_check_node() local
1874 level, BTRFS_MAX_LEVEL - 1); in __btrfs_check_node()
1880 btrfs_header_owner(node), node->start, in __btrfs_check_node()
1886 for (slot = 0; slot < nr - 1; slot++) { in __btrfs_check_node()
1887 bytenr = btrfs_node_blockptr(node, slot); in __btrfs_check_node()
1888 btrfs_node_key_to_cpu(node, &key, slot); in __btrfs_check_node()
1889 btrfs_node_key_to_cpu(node, &next_key, slot + 1); in __btrfs_check_node()
1892 generic_err(node, slot, in __btrfs_check_node()
1896 if (unlikely(!IS_ALIGNED(bytenr, fs_info->sectorsize))) { in __btrfs_check_node()
1897 generic_err(node, slot, in __btrfs_check_node()
1899 bytenr, fs_info->sectorsize); in __btrfs_check_node()
1904 generic_err(node, slot, in __btrfs_check_node()
1921 return -EUCLEAN; in btrfs_check_node()
1935 if (test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &eb->fs_info->fs_state)) in btrfs_check_eb_owner()
1954 /* For non-subvolume trees, the eb owner should match root owner */ in btrfs_check_eb_owner()
1956 btrfs_crit(eb->fs_info, in btrfs_check_eb_owner()
1961 return -EUCLEAN; in btrfs_check_eb_owner()
1971 btrfs_crit(eb->fs_info, in btrfs_check_eb_owner()
1976 return -EUCLEAN; in btrfs_check_eb_owner()
1984 struct btrfs_fs_info *fs_info = eb->fs_info; in btrfs_verify_level_key()
1995 eb->start, level, found_level); in btrfs_verify_level_key()
1996 return -EIO; in btrfs_verify_level_key()
2006 * generation <= fs_info->last_trans_committed. in btrfs_verify_level_key()
2008 if (btrfs_header_generation(eb) > fs_info->last_trans_committed) in btrfs_verify_level_key()
2015 eb->start); in btrfs_verify_level_key()
2017 return -EUCLEAN; in btrfs_verify_level_key()
2031 eb->start, parent_transid, first_key->objectid, in btrfs_verify_level_key()
2032 first_key->type, first_key->offset, in btrfs_verify_level_key()