Lines Matching +full:slot +full:- +full:size
1 // SPDX-License-Identifier: GPL-2.0
20 #include <linux/error-injection.h>
22 #include "tree-checker.h"
23 #include "disk-io.h"
45 * Append generic "corrupt leaf/node root=%llu block=%llu slot=%d: " to @fmt.
50 static void generic_err(const struct extent_buffer *eb, int slot, in generic_err() argument
53 const struct btrfs_fs_info *fs_info = eb->fs_info; in generic_err()
63 "corrupt %s: root=%llu block=%llu slot=%d, %pV", in generic_err()
65 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, &vaf); in generic_err()
75 static void file_extent_err(const struct extent_buffer *eb, int slot, in file_extent_err() argument
78 const struct btrfs_fs_info *fs_info = eb->fs_info; in file_extent_err()
83 btrfs_item_key_to_cpu(eb, &key, slot); in file_extent_err()
90 "corrupt %s: root=%llu block=%llu slot=%d ino=%llu file_offset=%llu, %pV", in file_extent_err()
92 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, in file_extent_err()
101 #define CHECK_FE_ALIGNED(leaf, slot, fi, name, alignment) \ argument
104 file_extent_err((leaf), (slot), \
120 end = ALIGN(key->offset + len, leaf->fs_info->sectorsize); in file_extent_end()
123 end = key->offset + len; in file_extent_end()
130 * key->objectid, which represents inode number
134 static void dir_item_err(const struct extent_buffer *eb, int slot, in dir_item_err() argument
137 const struct btrfs_fs_info *fs_info = eb->fs_info; in dir_item_err()
142 btrfs_item_key_to_cpu(eb, &key, slot); in dir_item_err()
149 "corrupt %s: root=%llu block=%llu slot=%d ino=%llu, %pV", in dir_item_err()
151 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, in dir_item_err()
157 * This functions checks prev_key->objectid, to ensure current key and prev_key
166 struct btrfs_key *key, int slot, in check_prev_ino() argument
170 if (slot == 0) in check_prev_ino()
173 /* Only these key->types needs to be checked */ in check_prev_ino()
174 ASSERT(key->type == BTRFS_XATTR_ITEM_KEY || in check_prev_ino()
175 key->type == BTRFS_INODE_REF_KEY || in check_prev_ino()
176 key->type == BTRFS_DIR_INDEX_KEY || in check_prev_ino()
177 key->type == BTRFS_DIR_ITEM_KEY || in check_prev_ino()
178 key->type == BTRFS_EXTENT_DATA_KEY); in check_prev_ino()
187 if (key->objectid == prev_key->objectid) in check_prev_ino()
191 dir_item_err(leaf, slot, in check_prev_ino()
193 prev_key->objectid, key->objectid); in check_prev_ino()
197 struct btrfs_key *key, int slot, in check_extent_data_item() argument
200 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_extent_data_item()
202 u32 sectorsize = fs_info->sectorsize; in check_extent_data_item()
203 u32 item_size = btrfs_item_size_nr(leaf, slot); in check_extent_data_item()
206 if (!IS_ALIGNED(key->offset, sectorsize)) { in check_extent_data_item()
207 file_extent_err(leaf, slot, in check_extent_data_item()
209 key->offset, sectorsize); in check_extent_data_item()
210 return -EUCLEAN; in check_extent_data_item()
214 * Previous key must have the same key->objectid (ino). in check_extent_data_item()
219 if (!check_prev_ino(leaf, key, slot, prev_key)) in check_extent_data_item()
220 return -EUCLEAN; in check_extent_data_item()
222 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); in check_extent_data_item()
229 file_extent_err(leaf, slot, in check_extent_data_item()
230 "invalid item size, have %u expect [%zu, %u)", in check_extent_data_item()
233 return -EUCLEAN; in check_extent_data_item()
236 file_extent_err(leaf, slot, in check_extent_data_item()
239 BTRFS_NR_FILE_EXTENT_TYPES - 1); in check_extent_data_item()
240 return -EUCLEAN; in check_extent_data_item()
248 file_extent_err(leaf, slot, in check_extent_data_item()
251 BTRFS_NR_COMPRESS_TYPES - 1); in check_extent_data_item()
252 return -EUCLEAN; in check_extent_data_item()
255 file_extent_err(leaf, slot, in check_extent_data_item()
258 return -EUCLEAN; in check_extent_data_item()
262 if (key->offset) { in check_extent_data_item()
263 file_extent_err(leaf, slot, in check_extent_data_item()
265 key->offset); in check_extent_data_item()
266 return -EUCLEAN; in check_extent_data_item()
269 /* Compressed inline extent has no on-disk size, skip it */ in check_extent_data_item()
274 /* Uncompressed inline extent size must match item size */ in check_extent_data_item()
277 file_extent_err(leaf, slot, in check_extent_data_item()
281 return -EUCLEAN; in check_extent_data_item()
286 /* Regular or preallocated extent has fixed item size */ in check_extent_data_item()
288 file_extent_err(leaf, slot, in check_extent_data_item()
289 "invalid item size for reg/prealloc file extent, have %u expect %zu", in check_extent_data_item()
291 return -EUCLEAN; in check_extent_data_item()
293 if (CHECK_FE_ALIGNED(leaf, slot, fi, ram_bytes, sectorsize) || in check_extent_data_item()
294 CHECK_FE_ALIGNED(leaf, slot, fi, disk_bytenr, sectorsize) || in check_extent_data_item()
295 CHECK_FE_ALIGNED(leaf, slot, fi, disk_num_bytes, sectorsize) || in check_extent_data_item()
296 CHECK_FE_ALIGNED(leaf, slot, fi, offset, sectorsize) || in check_extent_data_item()
297 CHECK_FE_ALIGNED(leaf, slot, fi, num_bytes, sectorsize)) in check_extent_data_item()
298 return -EUCLEAN; in check_extent_data_item()
302 key->offset, &extent_end)) { in check_extent_data_item()
303 file_extent_err(leaf, slot, in check_extent_data_item()
305 key->offset, in check_extent_data_item()
307 return -EUCLEAN; in check_extent_data_item()
314 if (slot > 0 && in check_extent_data_item()
315 prev_key->objectid == key->objectid && in check_extent_data_item()
316 prev_key->type == BTRFS_EXTENT_DATA_KEY) { in check_extent_data_item()
320 prev_fi = btrfs_item_ptr(leaf, slot - 1, in check_extent_data_item()
323 if (prev_end > key->offset) { in check_extent_data_item()
324 file_extent_err(leaf, slot - 1, in check_extent_data_item()
326 prev_end, key->offset); in check_extent_data_item()
327 return -EUCLEAN; in check_extent_data_item()
335 int slot, struct btrfs_key *prev_key) in check_csum_item() argument
337 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_csum_item()
338 u32 sectorsize = fs_info->sectorsize; in check_csum_item()
339 u32 csumsize = btrfs_super_csum_size(fs_info->super_copy); in check_csum_item()
341 if (key->objectid != BTRFS_EXTENT_CSUM_OBJECTID) { in check_csum_item()
342 generic_err(leaf, slot, in check_csum_item()
344 key->objectid, BTRFS_EXTENT_CSUM_OBJECTID); in check_csum_item()
345 return -EUCLEAN; in check_csum_item()
347 if (!IS_ALIGNED(key->offset, sectorsize)) { in check_csum_item()
348 generic_err(leaf, slot, in check_csum_item()
350 key->offset, sectorsize); in check_csum_item()
351 return -EUCLEAN; in check_csum_item()
353 if (!IS_ALIGNED(btrfs_item_size_nr(leaf, slot), csumsize)) { in check_csum_item()
354 generic_err(leaf, slot, in check_csum_item()
355 "unaligned item size for csum item, have %u should be aligned to %u", in check_csum_item()
356 btrfs_item_size_nr(leaf, slot), csumsize); in check_csum_item()
357 return -EUCLEAN; in check_csum_item()
359 if (slot > 0 && prev_key->type == BTRFS_EXTENT_CSUM_KEY) { in check_csum_item()
363 prev_item_size = btrfs_item_size_nr(leaf, slot - 1); in check_csum_item()
365 prev_csum_end += prev_key->offset; in check_csum_item()
366 if (prev_csum_end > key->offset) { in check_csum_item()
367 generic_err(leaf, slot - 1, in check_csum_item()
369 prev_csum_end, key->offset); in check_csum_item()
370 return -EUCLEAN; in check_csum_item()
377 #define inode_item_err(eb, slot, fmt, ...) \ argument
378 dir_item_err(eb, slot, fmt, __VA_ARGS__)
381 int slot) in check_inode_key() argument
386 btrfs_item_key_to_cpu(leaf, &item_key, slot); in check_inode_key()
391 if (key->type != 0 || key->objectid != 0 || key->offset != 0) in check_inode_key()
392 return -EUCLEAN; in check_inode_key()
396 if ((key->objectid < BTRFS_FIRST_FREE_OBJECTID || in check_inode_key()
397 key->objectid > BTRFS_LAST_FREE_OBJECTID) && in check_inode_key()
398 key->objectid != BTRFS_ROOT_TREE_DIR_OBJECTID && in check_inode_key()
399 key->objectid != BTRFS_FREE_INO_OBJECTID) { in check_inode_key()
401 generic_err(leaf, slot, in check_inode_key()
403 key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID, in check_inode_key()
408 dir_item_err(leaf, slot, in check_inode_key()
410 key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID, in check_inode_key()
415 return -EUCLEAN; in check_inode_key()
417 if (key->offset != 0) { in check_inode_key()
419 inode_item_err(leaf, slot, in check_inode_key()
421 key->offset); in check_inode_key()
423 dir_item_err(leaf, slot, in check_inode_key()
425 key->offset); in check_inode_key()
426 return -EUCLEAN; in check_inode_key()
432 int slot) in check_root_key() argument
437 btrfs_item_key_to_cpu(leaf, &item_key, slot); in check_root_key()
441 if (key->objectid == 0) { in check_root_key()
443 generic_err(leaf, slot, "invalid root id 0"); in check_root_key()
445 dir_item_err(leaf, slot, in check_root_key()
447 return -EUCLEAN; in check_root_key()
450 /* DIR_ITEM/INDEX/INODE_REF is not allowed to point to non-fs trees */ in check_root_key()
451 if (!is_fstree(key->objectid) && !is_root_item) { in check_root_key()
452 dir_item_err(leaf, slot, in check_root_key()
454 key->objectid, BTRFS_FIRST_FREE_OBJECTID, in check_root_key()
456 return -EUCLEAN; in check_root_key()
460 * ROOT_ITEM with non-zero offset means this is a snapshot, created at in check_root_key()
462 * Furthermore, for location key in DIR_ITEM, its offset is always -1. in check_root_key()
464 * So here we only check offset for reloc tree whose key->offset must in check_root_key()
467 if (key->objectid == BTRFS_TREE_RELOC_OBJECTID && key->offset == 0) { in check_root_key()
468 generic_err(leaf, slot, "invalid root id 0 for reloc tree"); in check_root_key()
469 return -EUCLEAN; in check_root_key()
476 int slot) in check_dir_item() argument
478 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_dir_item()
480 u32 item_size = btrfs_item_size_nr(leaf, slot); in check_dir_item()
483 if (!check_prev_ino(leaf, key, slot, prev_key)) in check_dir_item()
484 return -EUCLEAN; in check_dir_item()
485 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item); in check_dir_item()
498 dir_item_err(leaf, slot, in check_dir_item()
501 return -EUCLEAN; in check_dir_item()
507 ret = check_root_key(leaf, &location_key, slot); in check_dir_item()
512 ret = check_inode_key(leaf, &location_key, slot); in check_dir_item()
516 dir_item_err(leaf, slot, in check_dir_item()
520 return -EUCLEAN; in check_dir_item()
526 dir_item_err(leaf, slot, in check_dir_item()
529 return -EUCLEAN; in check_dir_item()
532 if (key->type == BTRFS_XATTR_ITEM_KEY && in check_dir_item()
534 dir_item_err(leaf, slot, in check_dir_item()
537 return -EUCLEAN; in check_dir_item()
540 key->type != BTRFS_XATTR_ITEM_KEY) { in check_dir_item()
541 dir_item_err(leaf, slot, in check_dir_item()
542 "xattr dir type found for non-XATTR key"); in check_dir_item()
543 return -EUCLEAN; in check_dir_item()
554 dir_item_err(leaf, slot, in check_dir_item()
557 return -EUCLEAN; in check_dir_item()
560 dir_item_err(leaf, slot, in check_dir_item()
564 return -EUCLEAN; in check_dir_item()
568 dir_item_err(leaf, slot, in check_dir_item()
571 return -EUCLEAN; in check_dir_item()
578 dir_item_err(leaf, slot, in check_dir_item()
581 return -EUCLEAN; in check_dir_item()
585 * Special check for XATTR/DIR_ITEM, as key->offset is name in check_dir_item()
588 if (key->type == BTRFS_DIR_ITEM_KEY || in check_dir_item()
589 key->type == BTRFS_XATTR_ITEM_KEY) { in check_dir_item()
595 if (key->offset != name_hash) { in check_dir_item()
596 dir_item_err(leaf, slot, in check_dir_item()
598 name_hash, key->offset); in check_dir_item()
599 return -EUCLEAN; in check_dir_item()
610 static void block_group_err(const struct extent_buffer *eb, int slot, in block_group_err() argument
613 const struct btrfs_fs_info *fs_info = eb->fs_info; in block_group_err()
618 btrfs_item_key_to_cpu(eb, &key, slot); in block_group_err()
625 "corrupt %s: root=%llu block=%llu slot=%d bg_start=%llu bg_len=%llu, %pV", in block_group_err()
627 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, in block_group_err()
633 struct btrfs_key *key, int slot) in check_block_group_item() argument
636 u32 item_size = btrfs_item_size_nr(leaf, slot); in check_block_group_item()
642 * handle it. We care more about the size. in check_block_group_item()
644 if (key->offset == 0) { in check_block_group_item()
645 block_group_err(leaf, slot, in check_block_group_item()
646 "invalid block group size 0"); in check_block_group_item()
647 return -EUCLEAN; in check_block_group_item()
651 block_group_err(leaf, slot, in check_block_group_item()
652 "invalid item size, have %u expect %zu", in check_block_group_item()
654 return -EUCLEAN; in check_block_group_item()
657 read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot), in check_block_group_item()
661 block_group_err(leaf, slot, in check_block_group_item()
665 return -EUCLEAN; in check_block_group_item()
668 if (btrfs_stack_block_group_used(&bgi) > key->offset) { in check_block_group_item()
669 block_group_err(leaf, slot, in check_block_group_item()
671 btrfs_stack_block_group_used(&bgi), key->offset); in check_block_group_item()
672 return -EUCLEAN; in check_block_group_item()
677 block_group_err(leaf, slot, in check_block_group_item()
681 return -EUCLEAN; in check_block_group_item()
690 block_group_err(leaf, slot, in check_block_group_item()
696 return -EUCLEAN; in check_block_group_item()
707 const struct btrfs_fs_info *fs_info = leaf->fs_info; in chunk_err()
712 int slot = -1; in chunk_err() local
715 is_sb = (leaf->start == BTRFS_SUPER_INFO_OFFSET); in chunk_err()
719 * Get the slot number by iterating through all slots, this in chunk_err()
725 slot = i; in chunk_err()
740 "corrupt leaf: root=%llu block=%llu slot=%d chunk_start=%llu, %pV", in chunk_err()
741 BTRFS_CHUNK_TREE_OBJECTID, leaf->start, slot, in chunk_err()
749 * Return -EUCLEAN if anything is corrupted.
755 struct btrfs_fs_info *fs_info = leaf->fs_info; in btrfs_check_chunk_valid()
780 return -EUCLEAN; in btrfs_check_chunk_valid()
786 return -EUCLEAN; in btrfs_check_chunk_valid()
792 return -EUCLEAN; in btrfs_check_chunk_valid()
794 if (!IS_ALIGNED(logical, fs_info->sectorsize)) { in btrfs_check_chunk_valid()
797 logical, fs_info->sectorsize); in btrfs_check_chunk_valid()
798 return -EUCLEAN; in btrfs_check_chunk_valid()
800 if (btrfs_chunk_sector_size(leaf, chunk) != fs_info->sectorsize) { in btrfs_check_chunk_valid()
804 fs_info->sectorsize); in btrfs_check_chunk_valid()
805 return -EUCLEAN; in btrfs_check_chunk_valid()
807 if (!length || !IS_ALIGNED(length, fs_info->sectorsize)) { in btrfs_check_chunk_valid()
810 return -EUCLEAN; in btrfs_check_chunk_valid()
816 return -EUCLEAN; in btrfs_check_chunk_valid()
822 return -EUCLEAN; in btrfs_check_chunk_valid()
831 return -EUCLEAN; in btrfs_check_chunk_valid()
839 return -EUCLEAN; in btrfs_check_chunk_valid()
845 return -EUCLEAN; in btrfs_check_chunk_valid()
853 return -EUCLEAN; in btrfs_check_chunk_valid()
856 features = btrfs_super_incompat_flags(fs_info->super_copy); in btrfs_check_chunk_valid()
864 "mixed chunk type in non-mixed mode: 0x%llx", type); in btrfs_check_chunk_valid()
865 return -EUCLEAN; in btrfs_check_chunk_valid()
879 return -EUCLEAN; in btrfs_check_chunk_valid()
888 * The common btrfs_check_chunk_valid() doesn't check item size since it needs
893 struct btrfs_key *key, int slot) in check_leaf_chunk_item() argument
897 if (btrfs_item_size_nr(leaf, slot) < sizeof(struct btrfs_chunk)) { in check_leaf_chunk_item()
898 chunk_err(leaf, chunk, key->offset, in check_leaf_chunk_item()
899 "invalid chunk item size: have %u expect [%zu, %u)", in check_leaf_chunk_item()
900 btrfs_item_size_nr(leaf, slot), in check_leaf_chunk_item()
902 BTRFS_LEAF_DATA_SIZE(leaf->fs_info)); in check_leaf_chunk_item()
903 return -EUCLEAN; in check_leaf_chunk_item()
912 btrfs_item_size_nr(leaf, slot)) { in check_leaf_chunk_item()
913 chunk_err(leaf, chunk, key->offset, in check_leaf_chunk_item()
914 "invalid chunk item size: have %u expect %lu", in check_leaf_chunk_item()
915 btrfs_item_size_nr(leaf, slot), in check_leaf_chunk_item()
917 return -EUCLEAN; in check_leaf_chunk_item()
920 return btrfs_check_chunk_valid(leaf, chunk, key->offset); in check_leaf_chunk_item()
925 static void dev_item_err(const struct extent_buffer *eb, int slot, in dev_item_err() argument
932 btrfs_item_key_to_cpu(eb, &key, slot); in dev_item_err()
938 btrfs_crit(eb->fs_info, in dev_item_err()
939 "corrupt %s: root=%llu block=%llu slot=%d devid=%llu %pV", in dev_item_err()
941 btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot, in dev_item_err()
947 struct btrfs_key *key, int slot) in check_dev_item() argument
950 const u32 item_size = btrfs_item_size_nr(leaf, slot); in check_dev_item()
952 if (key->objectid != BTRFS_DEV_ITEMS_OBJECTID) { in check_dev_item()
953 dev_item_err(leaf, slot, in check_dev_item()
955 key->objectid, BTRFS_DEV_ITEMS_OBJECTID); in check_dev_item()
956 return -EUCLEAN; in check_dev_item()
960 dev_item_err(leaf, slot, "invalid item size: has %u expect %zu", in check_dev_item()
962 return -EUCLEAN; in check_dev_item()
965 ditem = btrfs_item_ptr(leaf, slot, struct btrfs_dev_item); in check_dev_item()
966 if (btrfs_device_id(leaf, ditem) != key->offset) { in check_dev_item()
967 dev_item_err(leaf, slot, in check_dev_item()
969 key->offset, btrfs_device_id(leaf, ditem)); in check_dev_item()
970 return -EUCLEAN; in check_dev_item()
975 * it can be 0 for device removal. Device size check can only be done in check_dev_item()
980 dev_item_err(leaf, slot, in check_dev_item()
984 return -EUCLEAN; in check_dev_item()
994 struct btrfs_key *key, int slot) in check_inode_item() argument
996 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_inode_item()
998 u64 super_gen = btrfs_super_generation(fs_info->super_copy); in check_inode_item()
1000 const u32 item_size = btrfs_item_size_nr(leaf, slot); in check_inode_item()
1004 ret = check_inode_key(leaf, key, slot); in check_inode_item()
1009 generic_err(leaf, slot, "invalid item size: has %u expect %zu", in check_inode_item()
1011 return -EUCLEAN; in check_inode_item()
1014 iitem = btrfs_item_ptr(leaf, slot, struct btrfs_inode_item); in check_inode_item()
1018 inode_item_err(leaf, slot, in check_inode_item()
1022 return -EUCLEAN; in check_inode_item()
1026 inode_item_err(leaf, slot, in check_inode_item()
1029 return -EUCLEAN; in check_inode_item()
1033 * For size and nbytes it's better not to be too strict, as for dir in check_inode_item()
1034 * item its size/nbytes can easily get wrong, but doesn't affect in check_inode_item()
1039 inode_item_err(leaf, slot, in check_inode_item()
1042 return -EUCLEAN; in check_inode_item()
1052 inode_item_err(leaf, slot, in check_inode_item()
1055 return -EUCLEAN; in check_inode_item()
1059 inode_item_err(leaf, slot, in check_inode_item()
1062 return -EUCLEAN; in check_inode_item()
1065 inode_item_err(leaf, slot, in check_inode_item()
1069 return -EUCLEAN; in check_inode_item()
1075 int slot) in check_root_item() argument
1077 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_root_item()
1083 ret = check_root_key(leaf, key, slot); in check_root_item()
1087 if (btrfs_item_size_nr(leaf, slot) != sizeof(ri) && in check_root_item()
1088 btrfs_item_size_nr(leaf, slot) != btrfs_legacy_root_item_size()) { in check_root_item()
1089 generic_err(leaf, slot, in check_root_item()
1090 "invalid root item size, have %u expect %zu or %u", in check_root_item()
1091 btrfs_item_size_nr(leaf, slot), sizeof(ri), in check_root_item()
1093 return -EUCLEAN; in check_root_item()
1101 read_extent_buffer(leaf, &ri, btrfs_item_ptr_offset(leaf, slot), in check_root_item()
1102 btrfs_item_size_nr(leaf, slot)); in check_root_item()
1106 btrfs_super_generation(fs_info->super_copy) + 1) { in check_root_item()
1107 generic_err(leaf, slot, in check_root_item()
1110 btrfs_super_generation(fs_info->super_copy) + 1); in check_root_item()
1111 return -EUCLEAN; in check_root_item()
1114 btrfs_super_generation(fs_info->super_copy) + 1) { in check_root_item()
1115 generic_err(leaf, slot, in check_root_item()
1118 btrfs_super_generation(fs_info->super_copy) + 1); in check_root_item()
1119 return -EUCLEAN; in check_root_item()
1122 btrfs_super_generation(fs_info->super_copy) + 1) { in check_root_item()
1123 generic_err(leaf, slot, in check_root_item()
1126 btrfs_super_generation(fs_info->super_copy) + 1); in check_root_item()
1127 return -EUCLEAN; in check_root_item()
1131 if (!IS_ALIGNED(btrfs_root_bytenr(&ri), fs_info->sectorsize)) { in check_root_item()
1132 generic_err(leaf, slot, in check_root_item()
1134 btrfs_root_bytenr(&ri), fs_info->sectorsize); in check_root_item()
1135 return -EUCLEAN; in check_root_item()
1138 generic_err(leaf, slot, in check_root_item()
1140 btrfs_root_level(&ri), BTRFS_MAX_LEVEL - 1); in check_root_item()
1141 return -EUCLEAN; in check_root_item()
1144 generic_err(leaf, slot, in check_root_item()
1146 ri.drop_level, BTRFS_MAX_LEVEL - 1); in check_root_item()
1147 return -EUCLEAN; in check_root_item()
1152 generic_err(leaf, slot, in check_root_item()
1155 return -EUCLEAN; in check_root_item()
1162 static void extent_err(const struct extent_buffer *eb, int slot, in extent_err() argument
1171 btrfs_item_key_to_cpu(eb, &key, slot); in extent_err()
1176 len = eb->fs_info->nodesize; in extent_err()
1184 btrfs_crit(eb->fs_info, in extent_err()
1185 "corrupt %s: block=%llu slot=%d extent bytenr=%llu len=%llu %pV", in extent_err()
1187 eb->start, slot, bytenr, len, &vaf); in extent_err()
1192 struct btrfs_key *key, int slot) in check_extent_item() argument
1194 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_extent_item()
1199 const u32 item_size = btrfs_item_size_nr(leaf, slot); in check_extent_item()
1205 if (key->type == BTRFS_METADATA_ITEM_KEY && in check_extent_item()
1207 generic_err(leaf, slot, in check_extent_item()
1209 return -EUCLEAN; in check_extent_item()
1211 /* key->objectid is the bytenr for both key types */ in check_extent_item()
1212 if (!IS_ALIGNED(key->objectid, fs_info->sectorsize)) { in check_extent_item()
1213 generic_err(leaf, slot, in check_extent_item()
1215 key->objectid, fs_info->sectorsize); in check_extent_item()
1216 return -EUCLEAN; in check_extent_item()
1219 /* key->offset is tree level for METADATA_ITEM_KEY */ in check_extent_item()
1220 if (key->type == BTRFS_METADATA_ITEM_KEY && in check_extent_item()
1221 key->offset >= BTRFS_MAX_LEVEL) { in check_extent_item()
1222 extent_err(leaf, slot, in check_extent_item()
1224 key->offset, BTRFS_MAX_LEVEL - 1); in check_extent_item()
1225 return -EUCLEAN; in check_extent_item()
1248 extent_err(leaf, slot, in check_extent_item()
1249 "invalid item size, have %u expect [%zu, %u)", in check_extent_item()
1252 return -EUCLEAN; in check_extent_item()
1254 end = item_size + btrfs_item_ptr_offset(leaf, slot); in check_extent_item()
1257 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item); in check_extent_item()
1261 if (generation > btrfs_super_generation(fs_info->super_copy) + 1) { in check_extent_item()
1262 extent_err(leaf, slot, in check_extent_item()
1265 btrfs_super_generation(fs_info->super_copy) + 1); in check_extent_item()
1266 return -EUCLEAN; in check_extent_item()
1270 extent_err(leaf, slot, in check_extent_item()
1274 return -EUCLEAN; in check_extent_item()
1278 if (key->type == BTRFS_EXTENT_ITEM_KEY && in check_extent_item()
1279 key->offset != fs_info->nodesize) { in check_extent_item()
1280 extent_err(leaf, slot, in check_extent_item()
1282 key->offset, fs_info->nodesize); in check_extent_item()
1283 return -EUCLEAN; in check_extent_item()
1286 if (key->type != BTRFS_EXTENT_ITEM_KEY) { in check_extent_item()
1287 extent_err(leaf, slot, in check_extent_item()
1289 key->type, BTRFS_EXTENT_ITEM_KEY); in check_extent_item()
1290 return -EUCLEAN; in check_extent_item()
1292 if (!IS_ALIGNED(key->offset, fs_info->sectorsize)) { in check_extent_item()
1293 extent_err(leaf, slot, in check_extent_item()
1295 key->offset, fs_info->sectorsize); in check_extent_item()
1296 return -EUCLEAN; in check_extent_item()
1302 if (is_tree_block && key->type != BTRFS_METADATA_ITEM_KEY) { in check_extent_item()
1307 extent_err(leaf, slot, in check_extent_item()
1310 BTRFS_MAX_LEVEL - 1); in check_extent_item()
1311 return -EUCLEAN; in check_extent_item()
1326 extent_err(leaf, slot, in check_extent_item()
1327 "inline ref item overflows extent item, ptr %lu iref size %zu end %lu", in check_extent_item()
1329 return -EUCLEAN; in check_extent_item()
1335 extent_err(leaf, slot, in check_extent_item()
1336 "inline ref item overflows extent item, ptr %lu iref size %u end %lu", in check_extent_item()
1338 return -EUCLEAN; in check_extent_item()
1348 if (!IS_ALIGNED(inline_offset, fs_info->sectorsize)) { in check_extent_item()
1349 extent_err(leaf, slot, in check_extent_item()
1351 inline_offset, fs_info->sectorsize); in check_extent_item()
1352 return -EUCLEAN; in check_extent_item()
1361 dref = (struct btrfs_extent_data_ref *)(&iref->offset); in check_extent_item()
1363 if (!IS_ALIGNED(dref_offset, fs_info->sectorsize)) { in check_extent_item()
1364 extent_err(leaf, slot, in check_extent_item()
1366 dref_offset, fs_info->sectorsize); in check_extent_item()
1367 return -EUCLEAN; in check_extent_item()
1374 if (!IS_ALIGNED(inline_offset, fs_info->sectorsize)) { in check_extent_item()
1375 extent_err(leaf, slot, in check_extent_item()
1377 inline_offset, fs_info->sectorsize); in check_extent_item()
1378 return -EUCLEAN; in check_extent_item()
1383 extent_err(leaf, slot, "unknown inline ref type: %u", in check_extent_item()
1385 return -EUCLEAN; in check_extent_item()
1391 extent_err(leaf, slot, in check_extent_item()
1392 "invalid extent item size, padding bytes found"); in check_extent_item()
1393 return -EUCLEAN; in check_extent_item()
1398 extent_err(leaf, slot, in check_extent_item()
1401 return -EUCLEAN; in check_extent_item()
1407 struct btrfs_key *key, int slot) in check_simple_keyed_refs() argument
1411 if (key->type == BTRFS_SHARED_DATA_REF_KEY) in check_simple_keyed_refs()
1414 if (btrfs_item_size_nr(leaf, slot) != expect_item_size) { in check_simple_keyed_refs()
1415 generic_err(leaf, slot, in check_simple_keyed_refs()
1416 "invalid item size, have %u expect %u for key type %u", in check_simple_keyed_refs()
1417 btrfs_item_size_nr(leaf, slot), in check_simple_keyed_refs()
1418 expect_item_size, key->type); in check_simple_keyed_refs()
1419 return -EUCLEAN; in check_simple_keyed_refs()
1421 if (!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize)) { in check_simple_keyed_refs()
1422 generic_err(leaf, slot, in check_simple_keyed_refs()
1424 key->objectid, leaf->fs_info->sectorsize); in check_simple_keyed_refs()
1425 return -EUCLEAN; in check_simple_keyed_refs()
1427 if (key->type != BTRFS_TREE_BLOCK_REF_KEY && in check_simple_keyed_refs()
1428 !IS_ALIGNED(key->offset, leaf->fs_info->sectorsize)) { in check_simple_keyed_refs()
1429 extent_err(leaf, slot, in check_simple_keyed_refs()
1431 key->offset, leaf->fs_info->sectorsize); in check_simple_keyed_refs()
1432 return -EUCLEAN; in check_simple_keyed_refs()
1438 struct btrfs_key *key, int slot) in check_extent_data_ref() argument
1441 unsigned long ptr = btrfs_item_ptr_offset(leaf, slot); in check_extent_data_ref()
1442 const unsigned long end = ptr + btrfs_item_size_nr(leaf, slot); in check_extent_data_ref()
1444 if (btrfs_item_size_nr(leaf, slot) % sizeof(*dref) != 0) { in check_extent_data_ref()
1445 generic_err(leaf, slot, in check_extent_data_ref()
1446 "invalid item size, have %u expect aligned to %zu for key type %u", in check_extent_data_ref()
1447 btrfs_item_size_nr(leaf, slot), in check_extent_data_ref()
1448 sizeof(*dref), key->type); in check_extent_data_ref()
1449 return -EUCLEAN; in check_extent_data_ref()
1451 if (!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize)) { in check_extent_data_ref()
1452 generic_err(leaf, slot, in check_extent_data_ref()
1454 key->objectid, leaf->fs_info->sectorsize); in check_extent_data_ref()
1455 return -EUCLEAN; in check_extent_data_ref()
1466 if (!IS_ALIGNED(offset, leaf->fs_info->sectorsize)) { in check_extent_data_ref()
1467 extent_err(leaf, slot, in check_extent_data_ref()
1469 offset, leaf->fs_info->sectorsize); in check_extent_data_ref()
1470 return -EUCLEAN; in check_extent_data_ref()
1476 #define inode_ref_err(eb, slot, fmt, args...) \ argument
1477 inode_item_err(eb, slot, fmt, ##args)
1480 int slot) in check_inode_ref() argument
1486 if (!check_prev_ino(leaf, key, slot, prev_key)) in check_inode_ref()
1487 return -EUCLEAN; in check_inode_ref()
1489 if (btrfs_item_size_nr(leaf, slot) <= sizeof(*iref)) { in check_inode_ref()
1490 inode_ref_err(leaf, slot, in check_inode_ref()
1491 "invalid item size, have %u expect (%zu, %u)", in check_inode_ref()
1492 btrfs_item_size_nr(leaf, slot), in check_inode_ref()
1493 sizeof(*iref), BTRFS_LEAF_DATA_SIZE(leaf->fs_info)); in check_inode_ref()
1494 return -EUCLEAN; in check_inode_ref()
1497 ptr = btrfs_item_ptr_offset(leaf, slot); in check_inode_ref()
1498 end = ptr + btrfs_item_size_nr(leaf, slot); in check_inode_ref()
1503 inode_ref_err(leaf, slot, in check_inode_ref()
1506 return -EUCLEAN; in check_inode_ref()
1512 inode_ref_err(leaf, slot, in check_inode_ref()
1515 return -EUCLEAN; in check_inode_ref()
1529 * Common point to switch the item-specific validation.
1532 struct btrfs_key *key, int slot, in check_leaf_item() argument
1538 switch (key->type) { in check_leaf_item()
1540 ret = check_extent_data_item(leaf, key, slot, prev_key); in check_leaf_item()
1543 ret = check_csum_item(leaf, key, slot, prev_key); in check_leaf_item()
1548 ret = check_dir_item(leaf, key, prev_key, slot); in check_leaf_item()
1551 ret = check_inode_ref(leaf, key, prev_key, slot); in check_leaf_item()
1554 ret = check_block_group_item(leaf, key, slot); in check_leaf_item()
1557 chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk); in check_leaf_item()
1558 ret = check_leaf_chunk_item(leaf, chunk, key, slot); in check_leaf_item()
1561 ret = check_dev_item(leaf, key, slot); in check_leaf_item()
1564 ret = check_inode_item(leaf, key, slot); in check_leaf_item()
1567 ret = check_root_item(leaf, key, slot); in check_leaf_item()
1571 ret = check_extent_item(leaf, key, slot); in check_leaf_item()
1576 ret = check_simple_keyed_refs(leaf, key, slot); in check_leaf_item()
1579 ret = check_extent_data_ref(leaf, key, slot); in check_leaf_item()
1587 struct btrfs_fs_info *fs_info = leaf->fs_info; in check_leaf()
1592 int slot; in check_leaf() local
1598 return -EUCLEAN; in check_leaf()
1622 return -EUCLEAN; in check_leaf()
1628 return -EUCLEAN; in check_leaf()
1641 * 2) item offset and size in check_leaf()
1647 for (slot = 0; slot < nritems; slot++) { in check_leaf()
1651 btrfs_item_key_to_cpu(leaf, &key, slot); in check_leaf()
1655 generic_err(leaf, slot, in check_leaf()
1660 return -EUCLEAN; in check_leaf()
1668 if (slot == 0) in check_leaf()
1672 slot - 1); in check_leaf()
1673 if (btrfs_item_end_nr(leaf, slot) != item_end_expected) { in check_leaf()
1674 generic_err(leaf, slot, in check_leaf()
1676 btrfs_item_end_nr(leaf, slot), in check_leaf()
1678 return -EUCLEAN; in check_leaf()
1686 if (btrfs_item_end_nr(leaf, slot) > in check_leaf()
1688 generic_err(leaf, slot, in check_leaf()
1689 "slot end outside of leaf, have %u expect range [0, %u]", in check_leaf()
1690 btrfs_item_end_nr(leaf, slot), in check_leaf()
1692 return -EUCLEAN; in check_leaf()
1696 if (btrfs_item_nr_offset(slot) + sizeof(struct btrfs_item) > in check_leaf()
1697 btrfs_item_ptr_offset(leaf, slot)) { in check_leaf()
1698 generic_err(leaf, slot, in check_leaf()
1699 "slot overlaps with its data, item end %lu data start %lu", in check_leaf()
1700 btrfs_item_nr_offset(slot) + in check_leaf()
1702 btrfs_item_ptr_offset(leaf, slot)); in check_leaf()
1703 return -EUCLEAN; in check_leaf()
1708 * Check if the item size and content meet other in check_leaf()
1711 ret = check_leaf_item(leaf, &key, slot, &prev_key); in check_leaf()
1737 struct btrfs_fs_info *fs_info = node->fs_info; in btrfs_check_node()
1740 int slot; in btrfs_check_node() local
1748 level, BTRFS_MAX_LEVEL - 1); in btrfs_check_node()
1749 return -EUCLEAN; in btrfs_check_node()
1754 btrfs_header_owner(node), node->start, in btrfs_check_node()
1757 return -EUCLEAN; in btrfs_check_node()
1760 for (slot = 0; slot < nr - 1; slot++) { in btrfs_check_node()
1761 bytenr = btrfs_node_blockptr(node, slot); in btrfs_check_node()
1762 btrfs_node_key_to_cpu(node, &key, slot); in btrfs_check_node()
1763 btrfs_node_key_to_cpu(node, &next_key, slot + 1); in btrfs_check_node()
1766 generic_err(node, slot, in btrfs_check_node()
1768 ret = -EUCLEAN; in btrfs_check_node()
1771 if (!IS_ALIGNED(bytenr, fs_info->sectorsize)) { in btrfs_check_node()
1772 generic_err(node, slot, in btrfs_check_node()
1774 bytenr, fs_info->sectorsize); in btrfs_check_node()
1775 ret = -EUCLEAN; in btrfs_check_node()
1780 generic_err(node, slot, in btrfs_check_node()
1785 ret = -EUCLEAN; in btrfs_check_node()