tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

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

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

Pull btrfs fixes from David Sterba:
"More regression fixes and stabilization.

Regressions:

- zoned mode
- count zone sizes in wider int types
- fix space accounting for read-only block groups

- subpage: fix page tail zeroing

Fixes:

- fix spurious warning when remounting with free space tree

- fix warning when creating a directory with smack enabled

- ioctl checks for qgroup inheritance when creating a snapshot

- qgroup
- fix missing unlock on error path in zero range
- fix amount of released reservation on error
- fix flushing from unsafe context with open transaction,
potentially deadlocking

- minor build warning fixes"

* tag 'for-5.12-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux:
btrfs: zoned: do not account freed region of read-only block group as zone_unusable
btrfs: zoned: use sector_t for zone sectors
btrfs: subpage: fix the false data csum mismatch error
btrfs: fix warning when creating a directory with smack enabled
btrfs: don't flush from btrfs_delayed_inode_reserve_metadata
btrfs: export and rename qgroup_reserve_meta
btrfs: free correct amount of space in btrfs_delayed_inode_reserve_metadata
btrfs: fix spurious free_space_tree remount warning
btrfs: validate qgroup inherit for SNAP_CREATE_V2 ioctl
btrfs: unlock extents in btrfs_zero_range in case of quota reservation errors
btrfs: ref-verify: use 'inline void' keyword ordering

Linus Torvalds f09b04cc 6bf331d5

+87 -25
+3 -2
fs/btrfs/delayed-inode.c
··· 627 627 */ 628 628 if (!src_rsv || (!trans->bytes_reserved && 629 629 src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) { 630 - ret = btrfs_qgroup_reserve_meta_prealloc(root, num_bytes, true); 630 + ret = btrfs_qgroup_reserve_meta(root, num_bytes, 631 + BTRFS_QGROUP_RSV_META_PREALLOC, true); 631 632 if (ret < 0) 632 633 return ret; 633 634 ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes, ··· 650 649 btrfs_ino(inode), 651 650 num_bytes, 1); 652 651 } else { 653 - btrfs_qgroup_free_meta_prealloc(root, fs_info->nodesize); 652 + btrfs_qgroup_free_meta_prealloc(root, num_bytes); 654 653 } 655 654 return ret; 656 655 }
+16 -5
fs/btrfs/extent_io.c
··· 3008 3008 if (likely(uptodate)) { 3009 3009 loff_t i_size = i_size_read(inode); 3010 3010 pgoff_t end_index = i_size >> PAGE_SHIFT; 3011 - unsigned off; 3012 3011 3013 - /* Zero out the end if this page straddles i_size */ 3014 - off = offset_in_page(i_size); 3015 - if (page->index == end_index && off) 3016 - zero_user_segment(page, off, PAGE_SIZE); 3012 + /* 3013 + * Zero out the remaining part if this range straddles 3014 + * i_size. 3015 + * 3016 + * Here we should only zero the range inside the bvec, 3017 + * not touch anything else. 3018 + * 3019 + * NOTE: i_size is exclusive while end is inclusive. 3020 + */ 3021 + if (page->index == end_index && i_size <= end) { 3022 + u32 zero_start = max(offset_in_page(i_size), 3023 + offset_in_page(end)); 3024 + 3025 + zero_user_segment(page, zero_start, 3026 + offset_in_page(end) + 1); 3027 + } 3017 3028 } 3018 3029 ASSERT(bio_offset + len > bio_offset); 3019 3030 bio_offset += len;
+4 -1
fs/btrfs/file.c
··· 3260 3260 goto out; 3261 3261 ret = btrfs_qgroup_reserve_data(BTRFS_I(inode), &data_reserved, 3262 3262 alloc_start, bytes_to_reserve); 3263 - if (ret) 3263 + if (ret) { 3264 + unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, 3265 + lockend, &cached_state); 3264 3266 goto out; 3267 + } 3265 3268 ret = btrfs_prealloc_file_range(inode, mode, alloc_start, 3266 3269 alloc_end - alloc_start, 3267 3270 i_blocksize(inode),
+6 -1
fs/btrfs/free-space-cache.c
··· 2555 2555 to_unusable = size - to_free; 2556 2556 2557 2557 ctl->free_space += to_free; 2558 - block_group->zone_unusable += to_unusable; 2558 + /* 2559 + * If the block group is read-only, we should account freed space into 2560 + * bytes_readonly. 2561 + */ 2562 + if (!block_group->ro) 2563 + block_group->zone_unusable += to_unusable; 2559 2564 spin_unlock(&ctl->tree_lock); 2560 2565 if (!used) { 2561 2566 spin_lock(&block_group->lock);
+1 -1
fs/btrfs/inode.c
··· 6083 6083 return PTR_ERR(trans); 6084 6084 6085 6085 ret = btrfs_update_inode(trans, root, BTRFS_I(inode)); 6086 - if (ret && ret == -ENOSPC) { 6086 + if (ret && (ret == -ENOSPC || ret == -EDQUOT)) { 6087 6087 /* whoops, lets try again with the full transaction */ 6088 6088 btrfs_end_transaction(trans); 6089 6089 trans = btrfs_start_transaction(root, 1);
+18 -1
fs/btrfs/ioctl.c
··· 1936 1936 if (vol_args->flags & BTRFS_SUBVOL_RDONLY) 1937 1937 readonly = true; 1938 1938 if (vol_args->flags & BTRFS_SUBVOL_QGROUP_INHERIT) { 1939 - if (vol_args->size > PAGE_SIZE) { 1939 + u64 nums; 1940 + 1941 + if (vol_args->size < sizeof(*inherit) || 1942 + vol_args->size > PAGE_SIZE) { 1940 1943 ret = -EINVAL; 1941 1944 goto free_args; 1942 1945 } ··· 1947 1944 if (IS_ERR(inherit)) { 1948 1945 ret = PTR_ERR(inherit); 1949 1946 goto free_args; 1947 + } 1948 + 1949 + if (inherit->num_qgroups > PAGE_SIZE || 1950 + inherit->num_ref_copies > PAGE_SIZE || 1951 + inherit->num_excl_copies > PAGE_SIZE) { 1952 + ret = -EINVAL; 1953 + goto free_inherit; 1954 + } 1955 + 1956 + nums = inherit->num_qgroups + 2 * inherit->num_ref_copies + 1957 + 2 * inherit->num_excl_copies; 1958 + if (vol_args->size != struct_size(inherit, qgroups, nums)) { 1959 + ret = -EINVAL; 1960 + goto free_inherit; 1950 1961 } 1951 1962 } 1952 1963
+4 -4
fs/btrfs/qgroup.c
··· 3841 3841 return num_bytes; 3842 3842 } 3843 3843 3844 - static int qgroup_reserve_meta(struct btrfs_root *root, int num_bytes, 3845 - enum btrfs_qgroup_rsv_type type, bool enforce) 3844 + int btrfs_qgroup_reserve_meta(struct btrfs_root *root, int num_bytes, 3845 + enum btrfs_qgroup_rsv_type type, bool enforce) 3846 3846 { 3847 3847 struct btrfs_fs_info *fs_info = root->fs_info; 3848 3848 int ret; ··· 3873 3873 { 3874 3874 int ret; 3875 3875 3876 - ret = qgroup_reserve_meta(root, num_bytes, type, enforce); 3876 + ret = btrfs_qgroup_reserve_meta(root, num_bytes, type, enforce); 3877 3877 if (ret <= 0 && ret != -EDQUOT) 3878 3878 return ret; 3879 3879 3880 3880 ret = try_flush_qgroup(root); 3881 3881 if (ret < 0) 3882 3882 return ret; 3883 - return qgroup_reserve_meta(root, num_bytes, type, enforce); 3883 + return btrfs_qgroup_reserve_meta(root, num_bytes, type, enforce); 3884 3884 } 3885 3885 3886 3886 void btrfs_qgroup_free_meta_all_pertrans(struct btrfs_root *root)
+2
fs/btrfs/qgroup.h
··· 361 361 int btrfs_qgroup_free_data(struct btrfs_inode *inode, 362 362 struct extent_changeset *reserved, u64 start, 363 363 u64 len); 364 + int btrfs_qgroup_reserve_meta(struct btrfs_root *root, int num_bytes, 365 + enum btrfs_qgroup_rsv_type type, bool enforce); 364 366 int __btrfs_qgroup_reserve_meta(struct btrfs_root *root, int num_bytes, 365 367 enum btrfs_qgroup_rsv_type type, bool enforce); 366 368 /* Reserve metadata space for pertrans and prealloc type */
+2 -2
fs/btrfs/ref-verify.c
··· 218 218 stack_trace_print(ra->trace, ra->trace_len, 2); 219 219 } 220 220 #else 221 - static void inline __save_stack_trace(struct ref_action *ra) 221 + static inline void __save_stack_trace(struct ref_action *ra) 222 222 { 223 223 } 224 224 225 - static void inline __print_stack_trace(struct btrfs_fs_info *fs_info, 225 + static inline void __print_stack_trace(struct btrfs_fs_info *fs_info, 226 226 struct ref_action *ra) 227 227 { 228 228 btrfs_err(fs_info, " ref-verify: no stacktrace support");
+2 -2
fs/btrfs/super.c
··· 1918 1918 btrfs_resize_thread_pool(fs_info, 1919 1919 fs_info->thread_pool_size, old_thread_pool_size); 1920 1920 1921 - if (btrfs_test_opt(fs_info, FREE_SPACE_TREE) != 1922 - btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) && 1921 + if ((bool)btrfs_test_opt(fs_info, FREE_SPACE_TREE) != 1922 + (bool)btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) && 1923 1923 (!sb_rdonly(sb) || (*flags & SB_RDONLY))) { 1924 1924 btrfs_warn(fs_info, 1925 1925 "remount supports changing free space tree only from ro to rw");
+27 -4
fs/btrfs/xattr.c
··· 229 229 { 230 230 struct btrfs_root *root = BTRFS_I(inode)->root; 231 231 struct btrfs_trans_handle *trans; 232 + const bool start_trans = (current->journal_info == NULL); 232 233 int ret; 233 234 234 - trans = btrfs_start_transaction(root, 2); 235 - if (IS_ERR(trans)) 236 - return PTR_ERR(trans); 235 + if (start_trans) { 236 + /* 237 + * 1 unit for inserting/updating/deleting the xattr 238 + * 1 unit for the inode item update 239 + */ 240 + trans = btrfs_start_transaction(root, 2); 241 + if (IS_ERR(trans)) 242 + return PTR_ERR(trans); 243 + } else { 244 + /* 245 + * This can happen when smack is enabled and a directory is being 246 + * created. It happens through d_instantiate_new(), which calls 247 + * smack_d_instantiate(), which in turn calls __vfs_setxattr() to 248 + * set the transmute xattr (XATTR_NAME_SMACKTRANSMUTE) on the 249 + * inode. We have already reserved space for the xattr and inode 250 + * update at btrfs_mkdir(), so just use the transaction handle. 251 + * We don't join or start a transaction, as that will reset the 252 + * block_rsv of the handle and trigger a warning for the start 253 + * case. 254 + */ 255 + ASSERT(strncmp(name, XATTR_SECURITY_PREFIX, 256 + XATTR_SECURITY_PREFIX_LEN) == 0); 257 + trans = current->journal_info; 258 + } 237 259 238 260 ret = btrfs_setxattr(trans, inode, name, value, size, flags); 239 261 if (ret) ··· 266 244 ret = btrfs_update_inode(trans, root, BTRFS_I(inode)); 267 245 BUG_ON(ret); 268 246 out: 269 - btrfs_end_transaction(trans); 247 + if (start_trans) 248 + btrfs_end_transaction(trans); 270 249 return ret; 271 250 } 272 251
+2 -2
fs/btrfs/zoned.c
··· 269 269 sector_t sector = 0; 270 270 struct blk_zone *zones = NULL; 271 271 unsigned int i, nreported = 0, nr_zones; 272 - unsigned int zone_sectors; 272 + sector_t zone_sectors; 273 273 char *model, *emulated; 274 274 int ret; 275 275 ··· 658 658 u64 *bytenr_ret) 659 659 { 660 660 struct blk_zone zones[BTRFS_NR_SB_LOG_ZONES]; 661 - unsigned int zone_sectors; 661 + sector_t zone_sectors; 662 662 u32 sb_zone; 663 663 int ret; 664 664 u8 zone_sectors_shift;