Lines Matching defs:leaf
10 * The objective is to do leaf/node validation checks when tree block is read
37 * @type: leaf or node
38 * @identifier: the necessary info to locate the leaf/node.
50 * Append generic "corrupt leaf/node root=%llu block=%llu slot=%d: " to @fmt.
69 btrfs_header_level(eb) == 0 ? "leaf" : "node",
96 btrfs_header_level(eb) == 0 ? "leaf" : "node",
106 #define CHECK_FE_ALIGNED(leaf, slot, fi, name, alignment) \
108 if (unlikely(!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), \
110 file_extent_err((leaf), (slot), \
112 (#name), btrfs_file_extent_##name((leaf), (fi)), \
114 (!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), (alignment))); \
117 static u64 file_extent_end(struct extent_buffer *leaf,
124 if (btrfs_file_extent_type(leaf, extent) == BTRFS_FILE_EXTENT_INLINE) {
125 len = btrfs_file_extent_ram_bytes(leaf, extent);
126 end = ALIGN(key->offset + len, leaf->fs_info->sectorsize);
128 len = btrfs_file_extent_num_bytes(leaf, extent);
156 btrfs_header_level(eb) == 0 ? "leaf" : "node",
171 static bool check_prev_ino(struct extent_buffer *leaf,
190 if (!is_fstree(btrfs_header_owner(leaf)))
197 dir_item_err(leaf, slot,
202 static int check_extent_data_item(struct extent_buffer *leaf,
206 struct btrfs_fs_info *fs_info = leaf->fs_info;
209 u32 item_size = btrfs_item_size(leaf, slot);
213 file_extent_err(leaf, slot,
225 if (unlikely(!check_prev_ino(leaf, key, slot, prev_key)))
228 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
235 file_extent_err(leaf, slot,
241 if (unlikely(btrfs_file_extent_type(leaf, fi) >=
243 file_extent_err(leaf, slot,
245 btrfs_file_extent_type(leaf, fi),
254 if (unlikely(btrfs_file_extent_compression(leaf, fi) >=
256 file_extent_err(leaf, slot,
258 btrfs_file_extent_compression(leaf, fi),
262 if (unlikely(btrfs_file_extent_encryption(leaf, fi))) {
263 file_extent_err(leaf, slot,
265 btrfs_file_extent_encryption(leaf, fi));
268 if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) {
271 file_extent_err(leaf, slot,
278 if (btrfs_file_extent_compression(leaf, fi) !=
284 btrfs_file_extent_ram_bytes(leaf, fi))) {
285 file_extent_err(leaf, slot,
288 btrfs_file_extent_ram_bytes(leaf, fi));
296 file_extent_err(leaf, slot,
301 if (unlikely(CHECK_FE_ALIGNED(leaf, slot, fi, ram_bytes, sectorsize) ||
302 CHECK_FE_ALIGNED(leaf, slot, fi, disk_bytenr, sectorsize) ||
303 CHECK_FE_ALIGNED(leaf, slot, fi, disk_num_bytes, sectorsize) ||
304 CHECK_FE_ALIGNED(leaf, slot, fi, offset, sectorsize) ||
305 CHECK_FE_ALIGNED(leaf, slot, fi, num_bytes, sectorsize)))
309 if (unlikely(check_add_overflow(btrfs_file_extent_num_bytes(leaf, fi),
311 file_extent_err(leaf, slot,
314 btrfs_file_extent_num_bytes(leaf, fi));
319 * Check that no two consecutive file extent items, in the same leaf,
328 prev_fi = btrfs_item_ptr(leaf, slot - 1,
330 prev_end = file_extent_end(leaf, prev_key, prev_fi);
332 file_extent_err(leaf, slot - 1,
342 static int check_csum_item(struct extent_buffer *leaf, struct btrfs_key *key,
345 struct btrfs_fs_info *fs_info = leaf->fs_info;
350 generic_err(leaf, slot,
356 generic_err(leaf, slot,
361 if (unlikely(!IS_ALIGNED(btrfs_item_size(leaf, slot), csumsize))) {
362 generic_err(leaf, slot,
364 btrfs_item_size(leaf, slot), csumsize);
371 prev_item_size = btrfs_item_size(leaf, slot - 1);
375 generic_err(leaf, slot - 1,
388 static int check_inode_key(struct extent_buffer *leaf, struct btrfs_key *key,
394 btrfs_item_key_to_cpu(leaf, &item_key, slot);
410 generic_err(leaf, slot,
417 dir_item_err(leaf, slot,
428 inode_item_err(leaf, slot,
432 dir_item_err(leaf, slot,
440 static int check_root_key(struct extent_buffer *leaf, struct btrfs_key *key,
446 btrfs_item_key_to_cpu(leaf, &item_key, slot);
457 generic_err(leaf, slot,
466 generic_err(leaf, slot, "invalid root id 0");
468 dir_item_err(leaf, slot,
475 dir_item_err(leaf, slot,
492 generic_err(leaf, slot, "invalid root id 0 for reloc tree");
498 static int check_dir_item(struct extent_buffer *leaf,
502 struct btrfs_fs_info *fs_info = leaf->fs_info;
504 u32 item_size = btrfs_item_size(leaf, slot);
507 if (unlikely(!check_prev_ino(leaf, key, slot, prev_key)))
510 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
523 dir_item_err(leaf, slot,
530 btrfs_dir_item_key_to_cpu(leaf, di, &location_key);
532 ret = check_root_key(leaf, &location_key, slot);
537 ret = check_inode_key(leaf, &location_key, slot);
541 dir_item_err(leaf, slot,
549 dir_type = btrfs_dir_ftype(leaf, di);
551 dir_item_err(leaf, slot,
559 dir_item_err(leaf, slot,
566 dir_item_err(leaf, slot,
576 name_len = btrfs_dir_name_len(leaf, di);
577 data_len = btrfs_dir_data_len(leaf, di);
579 dir_item_err(leaf, slot,
585 dir_item_err(leaf, slot,
593 dir_item_err(leaf, slot,
603 dir_item_err(leaf, slot,
617 read_extent_buffer(leaf, namebuf,
621 dir_item_err(leaf, slot,
651 btrfs_header_level(eb) == 0 ? "leaf" : "node",
657 static int check_block_group_item(struct extent_buffer *leaf,
660 struct btrfs_fs_info *fs_info = leaf->fs_info;
662 u32 item_size = btrfs_item_size(leaf, slot);
672 block_group_err(leaf, slot,
678 block_group_err(leaf, slot,
684 read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot),
696 block_group_err(leaf, slot,
703 block_group_err(leaf, slot,
711 block_group_err(leaf, slot,
719 block_group_err(leaf, slot,
732 block_group_err(leaf, slot,
745 static void chunk_err(const struct extent_buffer *leaf,
749 const struct btrfs_fs_info *fs_info = leaf->fs_info;
757 is_sb = (leaf->start == BTRFS_SUPER_INFO_OFFSET);
764 for (i = 0; i < btrfs_header_nritems(leaf); i++) {
765 if (btrfs_item_ptr_offset(leaf, i) ==
782 "corrupt leaf: root=%llu block=%llu slot=%d chunk_start=%llu, %pV",
783 BTRFS_CHUNK_TREE_OBJECTID, leaf->start, slot,
794 int btrfs_check_chunk_valid(struct extent_buffer *leaf,
797 struct btrfs_fs_info *fs_info = leaf->fs_info;
810 length = btrfs_chunk_length(leaf, chunk);
811 stripe_len = btrfs_chunk_stripe_len(leaf, chunk);
812 num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
813 sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);
814 type = btrfs_chunk_type(leaf, chunk);
820 chunk_err(leaf, chunk, logical,
825 chunk_err(leaf, chunk, logical,
831 chunk_err(leaf, chunk, logical,
837 chunk_err(leaf, chunk, logical,
842 if (unlikely(btrfs_chunk_sector_size(leaf, chunk) != fs_info->sectorsize)) {
843 chunk_err(leaf, chunk, logical,
845 btrfs_chunk_sector_size(leaf, chunk),
850 chunk_err(leaf, chunk, logical,
855 chunk_err(leaf, chunk, logical,
861 chunk_err(leaf, chunk, logical,
875 chunk_err(leaf, chunk, logical,
882 chunk_err(leaf, chunk, logical,
886 btrfs_chunk_type(leaf, chunk));
892 chunk_err(leaf, chunk, logical,
898 chunk_err(leaf, chunk, logical,
907 chunk_err(leaf, chunk, logical,
920 chunk_err(leaf, chunk, logical,
942 chunk_err(leaf, chunk, logical,
958 static int check_leaf_chunk_item(struct extent_buffer *leaf,
964 if (unlikely(btrfs_item_size(leaf, slot) < sizeof(struct btrfs_chunk))) {
965 chunk_err(leaf, chunk, key->offset,
967 btrfs_item_size(leaf, slot),
969 BTRFS_LEAF_DATA_SIZE(leaf->fs_info));
973 num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
979 btrfs_item_size(leaf, slot))) {
980 chunk_err(leaf, chunk, key->offset,
982 btrfs_item_size(leaf, slot),
987 return btrfs_check_chunk_valid(leaf, chunk, key->offset);
1007 btrfs_header_level(eb) == 0 ? "leaf" : "node",
1013 static int check_dev_item(struct extent_buffer *leaf,
1017 const u32 item_size = btrfs_item_size(leaf, slot);
1020 dev_item_err(leaf, slot,
1027 dev_item_err(leaf, slot, "invalid item size: has %u expect %zu",
1032 ditem = btrfs_item_ptr(leaf, slot, struct btrfs_dev_item);
1033 if (unlikely(btrfs_device_id(leaf, ditem) != key->offset)) {
1034 dev_item_err(leaf, slot,
1036 key->offset, btrfs_device_id(leaf, ditem));
1045 if (unlikely(btrfs_device_bytes_used(leaf, ditem) >
1046 btrfs_device_total_bytes(leaf, ditem))) {
1047 dev_item_err(leaf, slot,
1049 btrfs_device_bytes_used(leaf, ditem),
1050 btrfs_device_total_bytes(leaf, ditem));
1060 static int check_inode_item(struct extent_buffer *leaf,
1063 struct btrfs_fs_info *fs_info = leaf->fs_info;
1067 const u32 item_size = btrfs_item_size(leaf, slot);
1073 ret = check_inode_key(leaf, key, slot);
1078 generic_err(leaf, slot, "invalid item size: has %u expect %zu",
1083 iitem = btrfs_item_ptr(leaf, slot, struct btrfs_inode_item);
1086 if (unlikely(btrfs_inode_generation(leaf, iitem) > super_gen + 1)) {
1087 inode_item_err(leaf, slot,
1089 btrfs_inode_generation(leaf, iitem),
1094 if (unlikely(btrfs_inode_transid(leaf, iitem) > super_gen + 1)) {
1095 inode_item_err(leaf, slot,
1097 btrfs_inode_transid(leaf, iitem), super_gen + 1);
1106 mode = btrfs_inode_mode(leaf, iitem);
1108 inode_item_err(leaf, slot,
1121 inode_item_err(leaf, slot,
1127 if (unlikely(S_ISDIR(mode) && btrfs_inode_nlink(leaf, iitem) > 1)) {
1128 inode_item_err(leaf, slot,
1130 btrfs_inode_nlink(leaf, iitem));
1133 btrfs_inode_split_flags(btrfs_inode_flags(leaf, iitem), &flags, &ro_flags);
1135 inode_item_err(leaf, slot,
1141 inode_item_err(leaf, slot,
1149 static int check_root_item(struct extent_buffer *leaf, struct btrfs_key *key,
1152 struct btrfs_fs_info *fs_info = leaf->fs_info;
1158 ret = check_root_key(leaf, key, slot);
1162 if (unlikely(btrfs_item_size(leaf, slot) != sizeof(ri) &&
1163 btrfs_item_size(leaf, slot) !=
1165 generic_err(leaf, slot,
1167 btrfs_item_size(leaf, slot), sizeof(ri),
1177 read_extent_buffer(leaf, &ri, btrfs_item_ptr_offset(leaf, slot),
1178 btrfs_item_size(leaf, slot));
1183 generic_err(leaf, slot,
1191 generic_err(leaf, slot,
1199 generic_err(leaf, slot,
1208 generic_err(leaf, slot,
1214 generic_err(leaf, slot,
1220 generic_err(leaf, slot,
1228 generic_err(leaf, slot,
1262 btrfs_header_level(eb) == 0 ? "leaf" : "node",
1267 static int check_extent_item(struct extent_buffer *leaf,
1271 struct btrfs_fs_info *fs_info = leaf->fs_info;
1276 const u32 item_size = btrfs_item_size(leaf, slot);
1284 generic_err(leaf, slot,
1290 generic_err(leaf, slot,
1299 extent_err(leaf, slot,
1325 extent_err(leaf, slot,
1331 end = item_size + btrfs_item_ptr_offset(leaf, slot);
1334 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
1335 flags = btrfs_extent_flags(leaf, ei);
1336 total_refs = btrfs_extent_refs(leaf, ei);
1337 generation = btrfs_extent_generation(leaf, ei);
1340 extent_err(leaf, slot,
1348 extent_err(leaf, slot,
1358 extent_err(leaf, slot,
1365 extent_err(leaf, slot,
1371 extent_err(leaf, slot,
1377 extent_err(leaf, slot,
1389 if (unlikely(btrfs_tree_block_level(leaf, info) >= BTRFS_MAX_LEVEL)) {
1390 extent_err(leaf, slot,
1392 btrfs_tree_block_level(leaf, info),
1409 extent_err(leaf, slot,
1415 inline_type = btrfs_extent_inline_ref_type(leaf, iref);
1416 inline_offset = btrfs_extent_inline_ref_offset(leaf, iref);
1418 extent_err(leaf, slot,
1433 extent_err(leaf, slot,
1446 dref_offset = btrfs_extent_data_ref_offset(leaf, dref);
1449 extent_err(leaf, slot,
1454 inline_refs += btrfs_extent_data_ref_count(leaf, dref);
1461 extent_err(leaf, slot,
1466 inline_refs += btrfs_shared_data_ref_count(leaf, sref);
1469 extent_err(leaf, slot, "unknown inline ref type: %u",
1477 extent_err(leaf, slot,
1484 extent_err(leaf, slot,
1500 extent_err(leaf, slot,
1512 static int check_simple_keyed_refs(struct extent_buffer *leaf,
1520 if (unlikely(btrfs_item_size(leaf, slot) != expect_item_size)) {
1521 generic_err(leaf, slot,
1523 btrfs_item_size(leaf, slot),
1527 if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {
1528 generic_err(leaf, slot,
1530 key->objectid, leaf->fs_info->sectorsize);
1534 !IS_ALIGNED(key->offset, leaf->fs_info->sectorsize))) {
1535 extent_err(leaf, slot,
1537 key->offset, leaf->fs_info->sectorsize);
1543 static int check_extent_data_ref(struct extent_buffer *leaf,
1547 unsigned long ptr = btrfs_item_ptr_offset(leaf, slot);
1548 const unsigned long end = ptr + btrfs_item_size(leaf, slot);
1550 if (unlikely(btrfs_item_size(leaf, slot) % sizeof(*dref) != 0)) {
1551 generic_err(leaf, slot,
1553 btrfs_item_size(leaf, slot),
1557 if (unlikely(!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize))) {
1558 generic_err(leaf, slot,
1560 key->objectid, leaf->fs_info->sectorsize);
1568 * overflow from the leaf due to hash collisions.
1571 offset = btrfs_extent_data_ref_offset(leaf, dref);
1572 if (unlikely(!IS_ALIGNED(offset, leaf->fs_info->sectorsize))) {
1573 extent_err(leaf, slot,
1575 offset, leaf->fs_info->sectorsize);
1584 static int check_inode_ref(struct extent_buffer *leaf,
1592 if (unlikely(!check_prev_ino(leaf, key, slot, prev_key)))
1595 if (unlikely(btrfs_item_size(leaf, slot) <= sizeof(*iref))) {
1596 inode_ref_err(leaf, slot,
1598 btrfs_item_size(leaf, slot),
1599 sizeof(*iref), BTRFS_LEAF_DATA_SIZE(leaf->fs_info));
1603 ptr = btrfs_item_ptr_offset(leaf, slot);
1604 end = ptr + btrfs_item_size(leaf, slot);
1609 inode_ref_err(leaf, slot,
1616 namelen = btrfs_inode_ref_name_len(leaf, iref);
1618 inode_ref_err(leaf, slot,
1637 static enum btrfs_tree_block_status check_leaf_item(struct extent_buffer *leaf,
1647 ret = check_extent_data_item(leaf, key, slot, prev_key);
1650 ret = check_csum_item(leaf, key, slot, prev_key);
1655 ret = check_dir_item(leaf, key, prev_key, slot);
1658 ret = check_inode_ref(leaf, key, prev_key, slot);
1661 ret = check_block_group_item(leaf, key, slot);
1664 chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
1665 ret = check_leaf_chunk_item(leaf, chunk, key, slot);
1668 ret = check_dev_item(leaf, key, slot);
1671 ret = check_inode_item(leaf, key, slot);
1674 ret = check_root_item(leaf, key, slot);
1678 ret = check_extent_item(leaf, key, slot, prev_key);
1683 ret = check_simple_keyed_refs(leaf, key, slot);
1686 ret = check_extent_data_ref(leaf, key, slot);
1695 enum btrfs_tree_block_status __btrfs_check_leaf(struct extent_buffer *leaf)
1697 struct btrfs_fs_info *fs_info = leaf->fs_info;
1701 u32 nritems = btrfs_header_nritems(leaf);
1704 if (unlikely(btrfs_header_level(leaf) != 0)) {
1705 generic_err(leaf, 0,
1706 "invalid level for leaf, have %d expect 0",
1707 btrfs_header_level(leaf));
1719 if (nritems == 0 && !btrfs_header_flag(leaf, BTRFS_HEADER_FLAG_RELOC)) {
1720 u64 owner = btrfs_header_owner(leaf);
1728 generic_err(leaf, 0,
1736 generic_err(leaf, 0,
1746 generic_err(leaf, 0,
1759 * Check the following things to make sure this is a good leaf, and
1760 * leaf users won't need to bother with similar sanity checks:
1764 * No overlap, no hole, all inside the leaf.
1773 btrfs_item_key_to_cpu(leaf, &key, slot);
1777 generic_err(leaf, slot,
1785 item_data_end = (u64)btrfs_item_offset(leaf, slot) +
1786 btrfs_item_size(leaf, slot);
1789 * item data starts at the end of the leaf and grows towards the
1795 item_end_expected = btrfs_item_offset(leaf,
1798 generic_err(leaf, slot,
1805 * Check to make sure that we don't point outside of the leaf,
1807 * all point outside of the leaf.
1810 generic_err(leaf, slot,
1811 "slot end outside of leaf, have %llu expect range [0, %u]",
1817 if (unlikely(btrfs_item_ptr_offset(leaf, slot) <
1818 btrfs_item_nr_offset(leaf, slot) + sizeof(struct btrfs_item))) {
1819 generic_err(leaf, slot,
1821 btrfs_item_nr_offset(leaf, slot) +
1823 btrfs_item_ptr_offset(leaf, slot));
1828 * We only want to do this if WRITTEN is set, otherwise the leaf
1831 if (btrfs_header_flag(leaf, BTRFS_HEADER_FLAG_WRITTEN)) {
1838 ret = check_leaf_item(leaf, &key, slot, &prev_key);
1851 int btrfs_check_leaf(struct extent_buffer *leaf)
1855 ret = __btrfs_check_leaf(leaf);
1958 btrfs_header_level(eb) == 0 ? "leaf" : "node",
1973 btrfs_header_level(eb) == 0 ? "leaf" : "node",