Merge tag 'for-7.0-rc4-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux

tjh.dev / kernel

fork

Configure Feed

Issues Pull Requests Commits Tags

Feed URL

Select the types of activity you want to include in your feed.

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

fork

Configure Feed

Issues Pull Requests Commits Tags

Feed URL

Select the types of activity you want to include in your feed.

Merge tag 'for-7.0-rc4-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux

Pull btrfs fixes from David Sterba:
"Another batch of fixes for problems that have been identified by tools
analyzing code or by fuzzing. Most of them are short, two patches fix
the same thing in many places so the diffs are bigger.

- handle potential NULL pointer errors after attempting to read
extent and checksum trees

- prevent ENOSPC when creating many qgroups by ioctls in the same
transaction

- encoded write ioctl fixes (with 64K page and 4K block size):
- fix unexpected bio length
- do not let compressed bios and pages interfere with page cache

- compression fixes on setups with 64K page and 4K block size: fix
folio length assertions (zstd and lzo)

- remap tree fixes:
- make sure to hold block group reference while moving it
- handle early exit when moving block group to unused list

- handle deleted subvolumes with inconsistent state of deletion
progress"

* tag 'for-7.0-rc4-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux:
btrfs: reject root items with drop_progress and zero drop_level
btrfs: check block group before marking it unused in balance_remap_chunks()
btrfs: hold block group reference during entire move_existing_remap()
btrfs: fix an incorrect ASSERT() condition inside lzo_decompress_bio()
btrfs: fix an incorrect ASSERT() condition inside zstd_decompress_bio()
btrfs: do not touch page cache for encoded writes
btrfs: fix a bug that makes encoded write bio larger than expected
btrfs: reserve enough transaction items for qgroup ioctls
btrfs: check for NULL root after calls to btrfs_csum_root()
btrfs: check for NULL root after calls to btrfs_extent_root()

Linus Torvalds 2 months ago 8991448e a0c83177

+341 -40

18 changed files

expand all collapse all

btrfs

backref.c

block-group.c

compression.c

disk-io.c

extent-tree.c

file-item.c

free-space-tree.c

inode.c

ioctl.c

lzo.c

qgroup.c

raid56.c

relocation.c

tree-checker.c

tree-log.c

volumes.c

zoned.c

zstd.c

+28

fs/btrfs/backref.c

reviewed

··· 1393 1393 .indirect_missing_keys = PREFTREE_INIT 1394 1394 }; 1395 1395 1396 1396 + if (unlikely(!root)) { 1397 1397 + btrfs_err(ctx->fs_info, 1398 1398 + "missing extent root for extent at bytenr %llu", 1399 1399 + ctx->bytenr); 1400 1400 + return -EUCLEAN; 1401 1401 + } 1402 1402 + 1396 1403 /* Roots ulist is not needed when using a sharedness check context. */ 1397 1404 if (sc) 1398 1405 ASSERT(ctx->roots == NULL); ··· 2211 2204 struct btrfs_extent_item *ei; 2212 2205 struct btrfs_key key; 2213 2206 2207 2207 + if (unlikely(!extent_root)) { 2208 2208 + btrfs_err(fs_info, 2209 2209 + "missing extent root for extent at bytenr %llu", 2210 2210 + logical); 2211 2211 + return -EUCLEAN; 2212 2212 + } 2213 2213 + 2214 2214 key.objectid = logical; 2215 2215 if (btrfs_fs_incompat(fs_info, SKINNY_METADATA)) 2216 2216 key.type = BTRFS_METADATA_ITEM_KEY; ··· 2865 2851 struct btrfs_key key; 2866 2852 int ret; 2867 2853 2854 2854 + if (unlikely(!extent_root)) { 2855 2855 + btrfs_err(fs_info, 2856 2856 + "missing extent root for extent at bytenr %llu", 2857 2857 + bytenr); 2858 2858 + return -EUCLEAN; 2859 2859 + } 2860 2860 + 2868 2861 key.objectid = bytenr; 2869 2862 key.type = BTRFS_METADATA_ITEM_KEY; 2870 2863 key.offset = (u64)-1; ··· 3008 2987 3009 2988 /* We're at keyed items, there is no inline item, go to the next one */ 3010 2989 extent_root = btrfs_extent_root(iter->fs_info, iter->bytenr); 2990 2990 + if (unlikely(!extent_root)) { 2991 2991 + btrfs_err(iter->fs_info, 2992 2992 + "missing extent root for extent at bytenr %llu", 2993 2993 + iter->bytenr); 2994 2994 + return -EUCLEAN; 2995 2995 + } 2996 2996 + 3011 2997 ret = btrfs_next_item(extent_root, iter->path); 3012 2998 if (ret) 3013 2999 return ret;

+36

fs/btrfs/block-group.c

reviewed

··· 739 739 740 740 last = max_t(u64, block_group->start, BTRFS_SUPER_INFO_OFFSET); 741 741 extent_root = btrfs_extent_root(fs_info, last); 742 742 + if (unlikely(!extent_root)) { 743 743 + btrfs_err(fs_info, 744 744 + "missing extent root for block group at offset %llu", 745 745 + block_group->start); 746 746 + return -EUCLEAN; 747 747 + } 742 748 743 749 #ifdef CONFIG_BTRFS_DEBUG 744 750 /* ··· 1067 1061 int ret; 1068 1062 1069 1063 root = btrfs_block_group_root(fs_info); 1064 1064 + if (unlikely(!root)) { 1065 1065 + btrfs_err(fs_info, "missing block group root"); 1066 1066 + return -EUCLEAN; 1067 1067 + } 1068 1068 + 1070 1069 key.objectid = block_group->start; 1071 1070 key.type = BTRFS_BLOCK_GROUP_ITEM_KEY; 1072 1071 key.offset = block_group->length; ··· 1359 1348 struct btrfs_root *root = btrfs_block_group_root(fs_info); 1360 1349 struct btrfs_chunk_map *map; 1361 1350 unsigned int num_items; 1351 1351 + 1352 1352 + if (unlikely(!root)) { 1353 1353 + btrfs_err(fs_info, "missing block group root"); 1354 1354 + return ERR_PTR(-EUCLEAN); 1355 1355 + } 1362 1356 1363 1357 map = btrfs_find_chunk_map(fs_info, chunk_offset, 1); 1364 1358 ASSERT(map != NULL); ··· 2156 2140 int ret; 2157 2141 struct btrfs_key found_key; 2158 2142 2143 2143 + if (unlikely(!root)) { 2144 2144 + btrfs_err(fs_info, "missing block group root"); 2145 2145 + return -EUCLEAN; 2146 2146 + } 2147 2147 + 2159 2148 btrfs_for_each_slot(root, key, &found_key, path, ret) { 2160 2149 if (found_key.objectid >= key->objectid && 2161 2150 found_key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) { ··· 2734 2713 size_t size; 2735 2714 int ret; 2736 2715 2716 2716 + if (unlikely(!root)) { 2717 2717 + btrfs_err(fs_info, "missing block group root"); 2718 2718 + return -EUCLEAN; 2719 2719 + } 2720 2720 + 2737 2721 spin_lock(&block_group->lock); 2738 2722 btrfs_set_stack_block_group_v2_used(&bgi, block_group->used); 2739 2723 btrfs_set_stack_block_group_v2_chunk_objectid(&bgi, block_group->global_root_id); ··· 3074 3048 int ret; 3075 3049 bool dirty_bg_running; 3076 3050 3051 3051 + if (unlikely(!root)) { 3052 3052 + btrfs_err(fs_info, "missing block group root"); 3053 3053 + return -EUCLEAN; 3054 3054 + } 3055 3055 + 3077 3056 /* 3078 3057 * This can only happen when we are doing read-only scrub on read-only 3079 3058 * mount. ··· 3222 3191 u32 old_last_identity_remap_count; 3223 3192 u64 used, remap_bytes; 3224 3193 u32 identity_remap_count; 3194 3194 + 3195 3195 + if (unlikely(!root)) { 3196 3196 + btrfs_err(fs_info, "missing block group root"); 3197 3197 + return -EUCLEAN; 3198 3198 + } 3225 3199 3226 3200 /* 3227 3201 * Block group items update can be triggered out of commit transaction

+8 -3

fs/btrfs/compression.c

reviewed

··· 320 320 321 321 ASSERT(IS_ALIGNED(ordered->file_offset, fs_info->sectorsize)); 322 322 ASSERT(IS_ALIGNED(ordered->num_bytes, fs_info->sectorsize)); 323 323 - ASSERT(cb->writeback); 323 323 + /* 324 324 + * This flag determines if we should clear the writeback flag from the 325 325 + * page cache. But this function is only utilized by encoded writes, it 326 326 + * never goes through the page cache. 327 327 + */ 328 328 + ASSERT(!cb->writeback); 324 329 325 330 cb->start = ordered->file_offset; 326 331 cb->len = ordered->num_bytes; 332 332 + ASSERT(cb->bbio.bio.bi_iter.bi_size == ordered->disk_num_bytes); 327 333 cb->compressed_len = ordered->disk_num_bytes; 328 334 cb->bbio.bio.bi_iter.bi_sector = ordered->disk_bytenr >> SECTOR_SHIFT; 329 335 cb->bbio.ordered = ordered; ··· 351 345 cb = alloc_compressed_bio(inode, start, REQ_OP_WRITE, end_bbio_compressed_write); 352 346 cb->start = start; 353 347 cb->len = len; 354 354 - cb->writeback = true; 355 355 - 348 348 + cb->writeback = false; 356 349 return cb; 357 350 } 358 351

+17 -3

fs/btrfs/disk-io.c

reviewed

··· 1591 1591 * this will bump the backup pointer by one when it is 1592 1592 * done 1593 1593 */ 1594 1594 - static void backup_super_roots(struct btrfs_fs_info *info) 1594 1594 + static int backup_super_roots(struct btrfs_fs_info *info) 1595 1595 { 1596 1596 const int next_backup = info->backup_root_index; 1597 1597 struct btrfs_root_backup *root_backup; ··· 1622 1622 if (!btrfs_fs_incompat(info, EXTENT_TREE_V2)) { 1623 1623 struct btrfs_root *extent_root = btrfs_extent_root(info, 0); 1624 1624 struct btrfs_root *csum_root = btrfs_csum_root(info, 0); 1625 1625 + 1626 1626 + if (unlikely(!extent_root)) { 1627 1627 + btrfs_err(info, "missing extent root for extent at bytenr 0"); 1628 1628 + return -EUCLEAN; 1629 1629 + } 1630 1630 + if (unlikely(!csum_root)) { 1631 1631 + btrfs_err(info, "missing csum root for extent at bytenr 0"); 1632 1632 + return -EUCLEAN; 1633 1633 + } 1625 1634 1626 1635 btrfs_set_backup_extent_root(root_backup, 1627 1636 extent_root->node->start); ··· 1679 1670 memcpy(&info->super_copy->super_roots, 1680 1671 &info->super_for_commit->super_roots, 1681 1672 sizeof(*root_backup) * BTRFS_NUM_BACKUP_ROOTS); 1673 1673 + 1674 1674 + return 0; 1682 1675 } 1683 1676 1684 1677 /* ··· 4062 4051 * not from fsync where the tree roots in fs_info have not 4063 4052 * been consistent on disk. 4064 4053 */ 4065 4065 - if (max_mirrors == 0) 4066 4066 - backup_super_roots(fs_info); 4054 4054 + if (max_mirrors == 0) { 4055 4055 + ret = backup_super_roots(fs_info); 4056 4056 + if (ret < 0) 4057 4057 + return ret; 4058 4058 + } 4067 4059 4068 4060 sb = fs_info->super_for_commit; 4069 4061 dev_item = &sb->dev_item;

+93 -5

fs/btrfs/extent-tree.c

reviewed

··· 75 75 struct btrfs_key key; 76 76 BTRFS_PATH_AUTO_FREE(path); 77 77 78 78 + if (unlikely(!root)) { 79 79 + btrfs_err(fs_info, 80 80 + "missing extent root for extent at bytenr %llu", start); 81 81 + return -EUCLEAN; 82 82 + } 83 83 + 78 84 path = btrfs_alloc_path(); 79 85 if (!path) 80 86 return -ENOMEM; ··· 137 131 key.offset = offset; 138 132 139 133 extent_root = btrfs_extent_root(fs_info, bytenr); 134 134 + if (unlikely(!extent_root)) { 135 135 + btrfs_err(fs_info, 136 136 + "missing extent root for extent at bytenr %llu", bytenr); 137 137 + return -EUCLEAN; 138 138 + } 139 139 + 140 140 ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0); 141 141 if (ret < 0) 142 142 return ret; ··· 448 436 int recow; 449 437 int ret; 450 438 439 439 + if (unlikely(!root)) { 440 440 + btrfs_err(trans->fs_info, 441 441 + "missing extent root for extent at bytenr %llu", bytenr); 442 442 + return -EUCLEAN; 443 443 + } 444 444 + 451 445 key.objectid = bytenr; 452 446 if (parent) { 453 447 key.type = BTRFS_SHARED_DATA_REF_KEY; ··· 527 509 u32 size; 528 510 u32 num_refs; 529 511 int ret; 512 512 + 513 513 + if (unlikely(!root)) { 514 514 + btrfs_err(trans->fs_info, 515 515 + "missing extent root for extent at bytenr %llu", bytenr); 516 516 + return -EUCLEAN; 517 517 + } 530 518 531 519 key.objectid = bytenr; 532 520 if (node->parent) { ··· 692 668 struct btrfs_key key; 693 669 int ret; 694 670 671 671 + if (unlikely(!root)) { 672 672 + btrfs_err(trans->fs_info, 673 673 + "missing extent root for extent at bytenr %llu", bytenr); 674 674 + return -EUCLEAN; 675 675 + } 676 676 + 695 677 key.objectid = bytenr; 696 678 if (parent) { 697 679 key.type = BTRFS_SHARED_BLOCK_REF_KEY; ··· 721 691 struct btrfs_root *root = btrfs_extent_root(trans->fs_info, bytenr); 722 692 struct btrfs_key key; 723 693 int ret; 694 694 + 695 695 + if (unlikely(!root)) { 696 696 + btrfs_err(trans->fs_info, 697 697 + "missing extent root for extent at bytenr %llu", bytenr); 698 698 + return -EUCLEAN; 699 699 + } 724 700 725 701 key.objectid = bytenr; 726 702 if (node->parent) { ··· 817 781 int ret; 818 782 bool skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA); 819 783 int needed; 784 784 + 785 785 + if (unlikely(!root)) { 786 786 + btrfs_err(fs_info, 787 787 + "missing extent root for extent at bytenr %llu", bytenr); 788 788 + return -EUCLEAN; 789 789 + } 820 790 821 791 key.objectid = bytenr; 822 792 key.type = BTRFS_EXTENT_ITEM_KEY; ··· 1722 1680 } 1723 1681 1724 1682 root = btrfs_extent_root(fs_info, key.objectid); 1683 1683 + if (unlikely(!root)) { 1684 1684 + btrfs_err(fs_info, 1685 1685 + "missing extent root for extent at bytenr %llu", 1686 1686 + key.objectid); 1687 1687 + return -EUCLEAN; 1688 1688 + } 1725 1689 again: 1726 1690 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); 1727 1691 if (ret < 0) { ··· 1974 1926 struct btrfs_root *csum_root; 1975 1927 1976 1928 csum_root = btrfs_csum_root(fs_info, head->bytenr); 1977 1977 - ret = btrfs_del_csums(trans, csum_root, head->bytenr, 1978 1978 - head->num_bytes); 1929 1929 + if (unlikely(!csum_root)) { 1930 1930 + btrfs_err(fs_info, 1931 1931 + "missing csum root for extent at bytenr %llu", 1932 1932 + head->bytenr); 1933 1933 + ret = -EUCLEAN; 1934 1934 + } else { 1935 1935 + ret = btrfs_del_csums(trans, csum_root, head->bytenr, 1936 1936 + head->num_bytes); 1937 1937 + } 1979 1938 } 1980 1939 } 1981 1940 ··· 2433 2378 u32 expected_size; 2434 2379 int type; 2435 2380 int ret; 2381 2381 + 2382 2382 + if (unlikely(!extent_root)) { 2383 2383 + btrfs_err(fs_info, 2384 2384 + "missing extent root for extent at bytenr %llu", bytenr); 2385 2385 + return -EUCLEAN; 2386 2386 + } 2436 2387 2437 2388 key.objectid = bytenr; 2438 2389 key.type = BTRFS_EXTENT_ITEM_KEY; ··· 3154 3093 struct btrfs_root *csum_root; 3155 3094 3156 3095 csum_root = btrfs_csum_root(trans->fs_info, bytenr); 3096 3096 + if (unlikely(!csum_root)) { 3097 3097 + ret = -EUCLEAN; 3098 3098 + btrfs_abort_transaction(trans, ret); 3099 3099 + btrfs_err(trans->fs_info, 3100 3100 + "missing csum root for extent at bytenr %llu", 3101 3101 + bytenr); 3102 3102 + return ret; 3103 3103 + } 3104 3104 + 3157 3105 ret = btrfs_del_csums(trans, csum_root, bytenr, num_bytes); 3158 3106 if (unlikely(ret)) { 3159 3107 btrfs_abort_transaction(trans, ret); ··· 3292 3222 u64 delayed_ref_root = href->owning_root; 3293 3223 3294 3224 extent_root = btrfs_extent_root(info, bytenr); 3295 3295 - ASSERT(extent_root); 3225 3225 + if (unlikely(!extent_root)) { 3226 3226 + btrfs_err(info, 3227 3227 + "missing extent root for extent at bytenr %llu", bytenr); 3228 3228 + return -EUCLEAN; 3229 3229 + } 3296 3230 3297 3231 path = btrfs_alloc_path(); 3298 3232 if (!path) ··· 5013 4939 size += btrfs_extent_inline_ref_size(BTRFS_EXTENT_OWNER_REF_KEY); 5014 4940 size += btrfs_extent_inline_ref_size(type); 5015 4941 4942 4942 + extent_root = btrfs_extent_root(fs_info, ins->objectid); 4943 4943 + if (unlikely(!extent_root)) { 4944 4944 + btrfs_err(fs_info, 4945 4945 + "missing extent root for extent at bytenr %llu", 4946 4946 + ins->objectid); 4947 4947 + return -EUCLEAN; 4948 4948 + } 4949 4949 + 5016 4950 path = btrfs_alloc_path(); 5017 4951 if (!path) 5018 4952 return -ENOMEM; 5019 4953 5020 5020 - extent_root = btrfs_extent_root(fs_info, ins->objectid); 5021 4954 ret = btrfs_insert_empty_item(trans, extent_root, path, ins, size); 5022 4955 if (ret) { 5023 4956 btrfs_free_path(path); ··· 5100 5019 size += sizeof(*block_info); 5101 5020 } 5102 5021 5022 5022 + extent_root = btrfs_extent_root(fs_info, extent_key.objectid); 5023 5023 + if (unlikely(!extent_root)) { 5024 5024 + btrfs_err(fs_info, 5025 5025 + "missing extent root for extent at bytenr %llu", 5026 5026 + extent_key.objectid); 5027 5027 + return -EUCLEAN; 5028 5028 + } 5029 5029 + 5103 5030 path = btrfs_alloc_path(); 5104 5031 if (!path) 5105 5032 return -ENOMEM; 5106 5033 5107 5107 - extent_root = btrfs_extent_root(fs_info, extent_key.objectid); 5108 5034 ret = btrfs_insert_empty_item(trans, extent_root, path, &extent_key, 5109 5035 size); 5110 5036 if (ret) {

fs/btrfs/file-item.c

reviewed

··· 308 308 /* Current item doesn't contain the desired range, search again */ 309 309 btrfs_release_path(path); 310 310 csum_root = btrfs_csum_root(fs_info, disk_bytenr); 311 311 + if (unlikely(!csum_root)) { 312 312 + btrfs_err(fs_info, 313 313 + "missing csum root for extent at bytenr %llu", 314 314 + disk_bytenr); 315 315 + return -EUCLEAN; 316 316 + } 317 317 + 311 318 item = btrfs_lookup_csum(NULL, csum_root, path, disk_bytenr, 0); 312 319 if (IS_ERR(item)) { 313 320 ret = PTR_ERR(item);

+8 -1

fs/btrfs/free-space-tree.c

reviewed

··· 1073 1073 if (ret) 1074 1074 return ret; 1075 1075 1076 1076 + extent_root = btrfs_extent_root(trans->fs_info, block_group->start); 1077 1077 + if (unlikely(!extent_root)) { 1078 1078 + btrfs_err(trans->fs_info, 1079 1079 + "missing extent root for block group at offset %llu", 1080 1080 + block_group->start); 1081 1081 + return -EUCLEAN; 1082 1082 + } 1083 1083 + 1076 1084 mutex_lock(&block_group->free_space_lock); 1077 1085 1078 1086 /* ··· 1094 1086 key.type = BTRFS_EXTENT_ITEM_KEY; 1095 1087 key.offset = 0; 1096 1088 1097 1097 - extent_root = btrfs_extent_root(trans->fs_info, key.objectid); 1098 1089 ret = btrfs_search_slot_for_read(extent_root, &key, path, 1, 0); 1099 1090 if (ret < 0) 1100 1091 goto out_locked;

+20 -5

fs/btrfs/inode.c

reviewed

··· 2012 2012 */ 2013 2013 2014 2014 csum_root = btrfs_csum_root(root->fs_info, io_start); 2015 2015 + if (unlikely(!csum_root)) { 2016 2016 + btrfs_err(root->fs_info, 2017 2017 + "missing csum root for extent at bytenr %llu", io_start); 2018 2018 + ret = -EUCLEAN; 2019 2019 + goto out; 2020 2020 + } 2021 2021 + 2015 2022 ret = btrfs_lookup_csums_list(csum_root, io_start, 2016 2023 io_start + args->file_extent.num_bytes - 1, 2017 2024 NULL, nowait); ··· 2756 2749 int ret; 2757 2750 2758 2751 list_for_each_entry(sum, list, list) { 2759 2759 - trans->adding_csums = true; 2760 2760 - if (!csum_root) 2752 2752 + if (!csum_root) { 2761 2753 csum_root = btrfs_csum_root(trans->fs_info, 2762 2754 sum->logical); 2755 2755 + if (unlikely(!csum_root)) { 2756 2756 + btrfs_err(trans->fs_info, 2757 2757 + "missing csum root for extent at bytenr %llu", 2758 2758 + sum->logical); 2759 2759 + return -EUCLEAN; 2760 2760 + } 2761 2761 + } 2762 2762 + trans->adding_csums = true; 2763 2763 ret = btrfs_csum_file_blocks(trans, csum_root, sum); 2764 2764 trans->adding_csums = false; 2765 2765 if (ret) ··· 9888 9874 int compression; 9889 9875 size_t orig_count; 9890 9876 const u32 min_folio_size = btrfs_min_folio_size(fs_info); 9877 9877 + const u32 blocksize = fs_info->sectorsize; 9891 9878 u64 start, end; 9892 9879 u64 num_bytes, ram_bytes, disk_num_bytes; 9893 9880 struct btrfs_key ins; ··· 9999 9984 ret = -EFAULT; 10000 9985 goto out_cb; 10001 9986 } 10002 10002 - if (bytes < min_folio_size) 10003 10003 - folio_zero_range(folio, bytes, min_folio_size - bytes); 10004 10004 - ret = bio_add_folio(&cb->bbio.bio, folio, folio_size(folio), 0); 9987 9987 + if (!IS_ALIGNED(bytes, blocksize)) 9988 9988 + folio_zero_range(folio, bytes, round_up(bytes, blocksize) - bytes); 9989 9989 + ret = bio_add_folio(&cb->bbio.bio, folio, round_up(bytes, blocksize), 0); 10005 9990 if (unlikely(!ret)) { 10006 9991 folio_put(folio); 10007 9992 ret = -EINVAL;

+9 -3

fs/btrfs/ioctl.c

reviewed

··· 3617 3617 } 3618 3618 } 3619 3619 3620 3620 - trans = btrfs_join_transaction(root); 3620 3620 + /* 2 BTRFS_QGROUP_RELATION_KEY items. */ 3621 3621 + trans = btrfs_start_transaction(root, 2); 3621 3622 if (IS_ERR(trans)) { 3622 3623 ret = PTR_ERR(trans); 3623 3624 goto out; ··· 3690 3689 goto out; 3691 3690 } 3692 3691 3693 3693 - trans = btrfs_join_transaction(root); 3692 3692 + /* 3693 3693 + * 1 BTRFS_QGROUP_INFO_KEY item. 3694 3694 + * 1 BTRFS_QGROUP_LIMIT_KEY item. 3695 3695 + */ 3696 3696 + trans = btrfs_start_transaction(root, 2); 3694 3697 if (IS_ERR(trans)) { 3695 3698 ret = PTR_ERR(trans); 3696 3699 goto out; ··· 3743 3738 goto drop_write; 3744 3739 } 3745 3740 3746 3746 - trans = btrfs_join_transaction(root); 3741 3741 + /* 1 BTRFS_QGROUP_LIMIT_KEY item. */ 3742 3742 + trans = btrfs_start_transaction(root, 1); 3747 3743 if (IS_ERR(trans)) { 3748 3744 ret = PTR_ERR(trans); 3749 3745 goto out;

+2 -2

fs/btrfs/lzo.c

reviewed

··· 429 429 int lzo_decompress_bio(struct list_head *ws, struct compressed_bio *cb) 430 430 { 431 431 struct workspace *workspace = list_entry(ws, struct workspace, list); 432 432 - const struct btrfs_fs_info *fs_info = cb->bbio.inode->root->fs_info; 432 432 + struct btrfs_fs_info *fs_info = cb->bbio.inode->root->fs_info; 433 433 const u32 sectorsize = fs_info->sectorsize; 434 434 struct folio_iter fi; 435 435 char *kaddr; ··· 447 447 /* There must be a compressed folio and matches the sectorsize. */ 448 448 if (unlikely(!fi.folio)) 449 449 return -EINVAL; 450 450 - ASSERT(folio_size(fi.folio) == sectorsize); 450 450 + ASSERT(folio_size(fi.folio) == btrfs_min_folio_size(fs_info)); 451 451 kaddr = kmap_local_folio(fi.folio, 0); 452 452 len_in = read_compress_length(kaddr); 453 453 kunmap_local(kaddr);

fs/btrfs/qgroup.c

reviewed

··· 3739 3739 mutex_lock(&fs_info->qgroup_rescan_lock); 3740 3740 extent_root = btrfs_extent_root(fs_info, 3741 3741 fs_info->qgroup_rescan_progress.objectid); 3742 3742 + if (unlikely(!extent_root)) { 3743 3743 + btrfs_err(fs_info, 3744 3744 + "missing extent root for extent at bytenr %llu", 3745 3745 + fs_info->qgroup_rescan_progress.objectid); 3746 3746 + mutex_unlock(&fs_info->qgroup_rescan_lock); 3747 3747 + return -EUCLEAN; 3748 3748 + } 3749 3749 + 3742 3750 ret = btrfs_search_slot_for_read(extent_root, 3743 3751 &fs_info->qgroup_rescan_progress, 3744 3752 path, 1, 0);

+10 -2

fs/btrfs/raid56.c

reviewed

··· 2297 2297 static void fill_data_csums(struct btrfs_raid_bio *rbio) 2298 2298 { 2299 2299 struct btrfs_fs_info *fs_info = rbio->bioc->fs_info; 2300 2300 - struct btrfs_root *csum_root = btrfs_csum_root(fs_info, 2301 2301 - rbio->bioc->full_stripe_logical); 2300 2300 + struct btrfs_root *csum_root; 2302 2301 const u64 start = rbio->bioc->full_stripe_logical; 2303 2302 const u32 len = (rbio->nr_data * rbio->stripe_nsectors) << 2304 2303 fs_info->sectorsize_bits; ··· 2327 2328 GFP_NOFS); 2328 2329 if (!rbio->csum_buf || !rbio->csum_bitmap) { 2329 2330 ret = -ENOMEM; 2331 2331 + goto error; 2332 2332 + } 2333 2333 + 2334 2334 + csum_root = btrfs_csum_root(fs_info, rbio->bioc->full_stripe_logical); 2335 2335 + if (unlikely(!csum_root)) { 2336 2336 + btrfs_err(fs_info, 2337 2337 + "missing csum root for extent at bytenr %llu", 2338 2338 + rbio->bioc->full_stripe_logical); 2339 2339 + ret = -EUCLEAN; 2330 2340 goto error; 2331 2341 } 2332 2342

+32 -7

fs/btrfs/relocation.c

reviewed

··· 4185 4185 dest_addr = ins.objectid; 4186 4186 dest_length = ins.offset; 4187 4187 4188 4188 + dest_bg = btrfs_lookup_block_group(fs_info, dest_addr); 4189 4189 + 4188 4190 if (!is_data && !IS_ALIGNED(dest_length, fs_info->nodesize)) { 4189 4191 u64 new_length = ALIGN_DOWN(dest_length, fs_info->nodesize); 4190 4192 ··· 4297 4295 if (unlikely(ret)) 4298 4296 goto end; 4299 4297 4300 4300 - dest_bg = btrfs_lookup_block_group(fs_info, dest_addr); 4301 4301 - 4302 4298 adjust_block_group_remap_bytes(trans, dest_bg, dest_length); 4303 4299 4304 4300 mutex_lock(&dest_bg->free_space_lock); 4305 4301 bg_needs_free_space = test_bit(BLOCK_GROUP_FLAG_NEEDS_FREE_SPACE, 4306 4302 &dest_bg->runtime_flags); 4307 4303 mutex_unlock(&dest_bg->free_space_lock); 4308 4308 - btrfs_put_block_group(dest_bg); 4309 4304 4310 4305 if (bg_needs_free_space) { 4311 4306 ret = btrfs_add_block_group_free_space(trans, dest_bg); ··· 4332 4333 btrfs_end_transaction(trans); 4333 4334 } 4334 4335 } else { 4335 4335 - dest_bg = btrfs_lookup_block_group(fs_info, dest_addr); 4336 4336 btrfs_free_reserved_bytes(dest_bg, dest_length, 0); 4337 4337 - btrfs_put_block_group(dest_bg); 4338 4337 4339 4338 ret = btrfs_commit_transaction(trans); 4340 4339 } 4340 4340 + 4341 4341 + btrfs_put_block_group(dest_bg); 4341 4342 4342 4343 return ret; 4343 4344 } ··· 4953 4954 struct btrfs_space_info *sinfo = src_bg->space_info; 4954 4955 4955 4956 extent_root = btrfs_extent_root(fs_info, src_bg->start); 4957 4957 + if (unlikely(!extent_root)) { 4958 4958 + btrfs_err(fs_info, 4959 4959 + "missing extent root for block group at offset %llu", 4960 4960 + src_bg->start); 4961 4961 + return -EUCLEAN; 4962 4962 + } 4956 4963 4957 4964 trans = btrfs_start_transaction(extent_root, 0); 4958 4965 if (IS_ERR(trans)) ··· 5311 5306 int ret; 5312 5307 bool bg_is_ro = false; 5313 5308 5309 5309 + if (unlikely(!extent_root)) { 5310 5310 + btrfs_err(fs_info, 5311 5311 + "missing extent root for block group at offset %llu", 5312 5312 + group_start); 5313 5313 + return -EUCLEAN; 5314 5314 + } 5315 5315 + 5314 5316 /* 5315 5317 * This only gets set if we had a half-deleted snapshot on mount. We 5316 5318 * cannot allow relocation to start while we're still trying to clean up ··· 5548 5536 goto out; 5549 5537 } 5550 5538 5539 5539 + rc->extent_root = btrfs_extent_root(fs_info, 0); 5540 5540 + if (unlikely(!rc->extent_root)) { 5541 5541 + btrfs_err(fs_info, "missing extent root for extent at bytenr 0"); 5542 5542 + ret = -EUCLEAN; 5543 5543 + goto out; 5544 5544 + } 5545 5545 + 5551 5546 ret = reloc_chunk_start(fs_info); 5552 5547 if (ret < 0) 5553 5548 goto out_end; 5554 5554 - 5555 5555 - rc->extent_root = btrfs_extent_root(fs_info, 0); 5556 5549 5557 5550 set_reloc_control(rc); 5558 5551 ··· 5652 5635 struct btrfs_root *csum_root = btrfs_csum_root(fs_info, disk_bytenr); 5653 5636 LIST_HEAD(list); 5654 5637 int ret; 5638 5638 + 5639 5639 + if (unlikely(!csum_root)) { 5640 5640 + btrfs_mark_ordered_extent_error(ordered); 5641 5641 + btrfs_err(fs_info, 5642 5642 + "missing csum root for extent at bytenr %llu", 5643 5643 + disk_bytenr); 5644 5644 + return -EUCLEAN; 5645 5645 + } 5655 5646 5656 5647 ret = btrfs_lookup_csums_list(csum_root, disk_bytenr, 5657 5648 disk_bytenr + ordered->num_bytes - 1,

+17

fs/btrfs/tree-checker.c

reviewed

··· 1288 1288 btrfs_root_drop_level(&ri), BTRFS_MAX_LEVEL - 1); 1289 1289 return -EUCLEAN; 1290 1290 } 1291 1291 + /* 1292 1292 + * If drop_progress.objectid is non-zero, a btrfs_drop_snapshot() was 1293 1293 + * interrupted and the resume point was recorded in drop_progress and 1294 1294 + * drop_level. In that case drop_level must be >= 1: level 0 is the 1295 1295 + * leaf level and drop_snapshot never saves a checkpoint there (it 1296 1296 + * only records checkpoints at internal node levels in DROP_REFERENCE 1297 1297 + * stage). A zero drop_level combined with a non-zero drop_progress 1298 1298 + * objectid indicates on-disk corruption and would cause a BUG_ON in 1299 1299 + * merge_reloc_root() and btrfs_drop_snapshot() at mount time. 1300 1300 + */ 1301 1301 + if (unlikely(btrfs_disk_key_objectid(&ri.drop_progress) != 0 && 1302 1302 + btrfs_root_drop_level(&ri) == 0)) { 1303 1303 + generic_err(leaf, slot, 1304 1304 + "invalid root drop_level 0 with non-zero drop_progress objectid %llu", 1305 1305 + btrfs_disk_key_objectid(&ri.drop_progress)); 1306 1306 + return -EUCLEAN; 1307 1307 + } 1291 1308 1292 1309 /* Flags check */ 1293 1310 if (unlikely(btrfs_root_flags(&ri) & ~valid_root_flags)) {

+21

fs/btrfs/tree-log.c

reviewed

··· 984 984 985 985 sums = list_first_entry(&ordered_sums, struct btrfs_ordered_sum, list); 986 986 csum_root = btrfs_csum_root(fs_info, sums->logical); 987 987 + if (unlikely(!csum_root)) { 988 988 + btrfs_err(fs_info, 989 989 + "missing csum root for extent at bytenr %llu", 990 990 + sums->logical); 991 991 + ret = -EUCLEAN; 992 992 + } 993 993 + 987 994 if (!ret) { 988 995 ret = btrfs_del_csums(trans, csum_root, sums->logical, 989 996 sums->len); ··· 4897 4890 } 4898 4891 4899 4892 csum_root = btrfs_csum_root(trans->fs_info, disk_bytenr); 4893 4893 + if (unlikely(!csum_root)) { 4894 4894 + btrfs_err(trans->fs_info, 4895 4895 + "missing csum root for extent at bytenr %llu", 4896 4896 + disk_bytenr); 4897 4897 + return -EUCLEAN; 4898 4898 + } 4899 4899 + 4900 4900 disk_bytenr += extent_offset; 4901 4901 ret = btrfs_lookup_csums_list(csum_root, disk_bytenr, 4902 4902 disk_bytenr + extent_num_bytes - 1, ··· 5100 5086 /* block start is already adjusted for the file extent offset. */ 5101 5087 block_start = btrfs_extent_map_block_start(em); 5102 5088 csum_root = btrfs_csum_root(trans->fs_info, block_start); 5089 5089 + if (unlikely(!csum_root)) { 5090 5090 + btrfs_err(trans->fs_info, 5091 5091 + "missing csum root for extent at bytenr %llu", 5092 5092 + block_start); 5093 5093 + return -EUCLEAN; 5094 5094 + } 5095 5095 + 5103 5096 ret = btrfs_lookup_csums_list(csum_root, block_start + csum_offset, 5104 5097 block_start + csum_offset + csum_len - 1, 5105 5098 &ordered_sums, false);

+17 -8

fs/btrfs/volumes.c

reviewed

··· 4277 4277 end: 4278 4278 while (!list_empty(chunks)) { 4279 4279 bool is_unused; 4280 4280 + struct btrfs_block_group *bg; 4280 4281 4281 4282 rci = list_first_entry(chunks, struct remap_chunk_info, list); 4282 4283 4283 4283 - spin_lock(&rci->bg->lock); 4284 4284 - is_unused = !btrfs_is_block_group_used(rci->bg); 4285 4285 - spin_unlock(&rci->bg->lock); 4284 4284 + bg = rci->bg; 4285 4285 + if (bg) { 4286 4286 + /* 4287 4287 + * This is a bit racy and the 'used' status can change 4288 4288 + * but this is not a problem as later functions will 4289 4289 + * verify it again. 4290 4290 + */ 4291 4291 + spin_lock(&bg->lock); 4292 4292 + is_unused = !btrfs_is_block_group_used(bg); 4293 4293 + spin_unlock(&bg->lock); 4286 4294 4287 4287 - if (is_unused) 4288 4288 - btrfs_mark_bg_unused(rci->bg); 4295 4295 + if (is_unused) 4296 4296 + btrfs_mark_bg_unused(bg); 4289 4297 4290 4290 - if (rci->made_ro) 4291 4291 - btrfs_dec_block_group_ro(rci->bg); 4298 4298 + if (rci->made_ro) 4299 4299 + btrfs_dec_block_group_ro(bg); 4292 4300 4293 4293 - btrfs_put_block_group(rci->bg); 4301 4301 + btrfs_put_block_group(bg); 4302 4302 + } 4294 4303 4295 4304 list_del(&rci->list); 4296 4305 kfree(rci);

fs/btrfs/zoned.c

reviewed

··· 1261 1261 key.offset = 0; 1262 1262 1263 1263 root = btrfs_extent_root(fs_info, key.objectid); 1264 1264 + if (unlikely(!root)) { 1265 1265 + btrfs_err(fs_info, 1266 1266 + "missing extent root for extent at bytenr %llu", 1267 1267 + key.objectid); 1268 1268 + return -EUCLEAN; 1269 1269 + } 1270 1270 + 1264 1271 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 1265 1272 /* We should not find the exact match */ 1266 1273 if (unlikely(!ret))

+1 -1

fs/btrfs/zstd.c

reviewed

··· 600 600 bio_first_folio(&fi, &cb->bbio.bio, 0); 601 601 if (unlikely(!fi.folio)) 602 602 return -EINVAL; 603 603 - ASSERT(folio_size(fi.folio) == blocksize); 603 603 + ASSERT(folio_size(fi.folio) == min_folio_size); 604 604 605 605 stream = zstd_init_dstream( 606 606 ZSTD_BTRFS_MAX_INPUT, workspace->mem, workspace->size);