Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'for-6.12-rc3-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux
Pull btrfs fixes from David Sterba:
- regression fix: dirty extents tracked in xarray for qgroups must be
adjusted for 32bit platforms
- fix potentially freeing uninitialized name in fscrypt structure
- fix warning about unneeded variable in a send callback
* tag 'for-6.12-rc3-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux:
btrfs: fix uninitialized pointer free on read_alloc_one_name() error
btrfs: send: cleanup unneeded return variable in changed_verity()
btrfs: fix uninitialized pointer free in add_inode_ref()
btrfs: use sector numbers as keys for the dirty extents xarray
+37
-19
+8
-7
fs/btrfs/delayed-ref.c
+8
-7
fs/btrfs/delayed-ref.c
···
849
849
struct btrfs_qgroup_extent_record *qrecord,
850
850
int action, bool *qrecord_inserted_ret)
851
851
{
852
+
struct btrfs_fs_info *fs_info = trans->fs_info;
852
853
struct btrfs_delayed_ref_head *existing;
853
854
struct btrfs_delayed_ref_root *delayed_refs;
854
855
bool qrecord_inserted = false;
···
860
859
if (qrecord) {
861
860
int ret;
862
861
863
-
ret = btrfs_qgroup_trace_extent_nolock(trans->fs_info,
864
-
delayed_refs, qrecord);
862
+
ret = btrfs_qgroup_trace_extent_nolock(fs_info, delayed_refs, qrecord);
865
863
if (ret) {
866
864
/* Clean up if insertion fails or item exists. */
867
-
xa_release(&delayed_refs->dirty_extents, qrecord->bytenr);
865
+
xa_release(&delayed_refs->dirty_extents,
866
+
qrecord->bytenr >> fs_info->sectorsize_bits);
868
867
/* Caller responsible for freeing qrecord on error. */
869
868
if (ret < 0)
870
869
return ERR_PTR(ret);
···
874
873
}
875
874
}
876
875
877
-
trace_add_delayed_ref_head(trans->fs_info, head_ref, action);
876
+
trace_add_delayed_ref_head(fs_info, head_ref, action);
878
877
879
878
existing = htree_insert(&delayed_refs->href_root,
880
879
&head_ref->href_node);
···
896
895
if (head_ref->is_data && head_ref->ref_mod < 0) {
897
896
delayed_refs->pending_csums += head_ref->num_bytes;
898
897
trans->delayed_ref_csum_deletions +=
899
-
btrfs_csum_bytes_to_leaves(trans->fs_info,
900
-
head_ref->num_bytes);
898
+
btrfs_csum_bytes_to_leaves(fs_info, head_ref->num_bytes);
901
899
}
902
900
delayed_refs->num_heads++;
903
901
delayed_refs->num_heads_ready++;
···
1030
1030
goto free_head_ref;
1031
1031
}
1032
1032
if (xa_reserve(&trans->transaction->delayed_refs.dirty_extents,
1033
-
generic_ref->bytenr, GFP_NOFS)) {
1033
+
generic_ref->bytenr >> fs_info->sectorsize_bits,
1034
+
GFP_NOFS)) {
1034
1035
ret = -ENOMEM;
1035
1036
goto free_record;
1036
1037
}
+9
-1
fs/btrfs/delayed-ref.h
+9
-1
fs/btrfs/delayed-ref.h
···
202
202
/* head ref rbtree */
203
203
struct rb_root_cached href_root;
204
204
205
-
/* Track dirty extent records. */
205
+
/*
206
+
* Track dirty extent records.
207
+
* The keys correspond to the logical address of the extent ("bytenr")
208
+
* right shifted by fs_info->sectorsize_bits. This is both to get a more
209
+
* dense index space (optimizes xarray structure) and because indexes in
210
+
* xarrays are of "unsigned long" type, meaning they are 32 bits wide on
211
+
* 32 bits platforms, limiting the extent range to 4G which is too low
212
+
* and makes it unusable (truncated index values) on 32 bits platforms.
213
+
*/
206
214
struct xarray dirty_extents;
207
215
208
216
/* this spin lock protects the rbtree and the entries inside */
+16
-5
fs/btrfs/qgroup.c
+16
-5
fs/btrfs/qgroup.c
···
2005
2005
struct btrfs_qgroup_extent_record *record)
2006
2006
{
2007
2007
struct btrfs_qgroup_extent_record *existing, *ret;
2008
-
unsigned long bytenr = record->bytenr;
2008
+
const unsigned long index = (record->bytenr >> fs_info->sectorsize_bits);
2009
2009
2010
2010
if (!btrfs_qgroup_full_accounting(fs_info))
2011
2011
return 1;
2012
+
2013
+
#if BITS_PER_LONG == 32
2014
+
if (record->bytenr >= MAX_LFS_FILESIZE) {
2015
+
btrfs_err_rl(fs_info,
2016
+
"qgroup record for extent at %llu is beyond 32bit page cache and xarray index limit",
2017
+
record->bytenr);
2018
+
btrfs_err_32bit_limit(fs_info);
2019
+
return -EOVERFLOW;
2020
+
}
2021
+
#endif
2012
2022
2013
2023
lockdep_assert_held(&delayed_refs->lock);
2014
2024
trace_btrfs_qgroup_trace_extent(fs_info, record);
2015
2025
2016
2026
xa_lock(&delayed_refs->dirty_extents);
2017
-
existing = xa_load(&delayed_refs->dirty_extents, bytenr);
2027
+
existing = xa_load(&delayed_refs->dirty_extents, index);
2018
2028
if (existing) {
2019
2029
if (record->data_rsv && !existing->data_rsv) {
2020
2030
existing->data_rsv = record->data_rsv;
···
2034
2024
return 1;
2035
2025
}
2036
2026
2037
-
ret = __xa_store(&delayed_refs->dirty_extents, record->bytenr, record, GFP_ATOMIC);
2027
+
ret = __xa_store(&delayed_refs->dirty_extents, index, record, GFP_ATOMIC);
2038
2028
xa_unlock(&delayed_refs->dirty_extents);
2039
2029
if (xa_is_err(ret)) {
2040
2030
qgroup_mark_inconsistent(fs_info);
···
2139
2129
struct btrfs_fs_info *fs_info = trans->fs_info;
2140
2130
struct btrfs_qgroup_extent_record *record;
2141
2131
struct btrfs_delayed_ref_root *delayed_refs;
2132
+
const unsigned long index = (bytenr >> fs_info->sectorsize_bits);
2142
2133
int ret;
2143
2134
2144
2135
if (!btrfs_qgroup_full_accounting(fs_info) || bytenr == 0 || num_bytes == 0)
···
2148
2137
if (!record)
2149
2138
return -ENOMEM;
2150
2139
2151
-
if (xa_reserve(&trans->transaction->delayed_refs.dirty_extents, bytenr, GFP_NOFS)) {
2140
+
if (xa_reserve(&trans->transaction->delayed_refs.dirty_extents, index, GFP_NOFS)) {
2152
2141
kfree(record);
2153
2142
return -ENOMEM;
2154
2143
}
···
2163
2152
spin_unlock(&delayed_refs->lock);
2164
2153
if (ret) {
2165
2154
/* Clean up if insertion fails or item exists. */
2166
-
xa_release(&delayed_refs->dirty_extents, record->bytenr);
2155
+
xa_release(&delayed_refs->dirty_extents, index);
2167
2156
kfree(record);
2168
2157
return 0;
2169
2158
}
+1
-3
fs/btrfs/send.c
+1
-3
fs/btrfs/send.c
···
7190
7190
7191
7191
static int changed_verity(struct send_ctx *sctx, enum btrfs_compare_tree_result result)
7192
7192
{
7193
-
int ret = 0;
7194
-
7195
7193
if (!sctx->cur_inode_new_gen && !sctx->cur_inode_deleted) {
7196
7194
if (result == BTRFS_COMPARE_TREE_NEW)
7197
7195
sctx->cur_inode_needs_verity = true;
7198
7196
}
7199
-
return ret;
7197
+
return 0;
7200
7198
}
7201
7199
7202
7200
static int dir_changed(struct send_ctx *sctx, u64 dir)
+3
-3
fs/btrfs/tree-log.c
+3
-3
fs/btrfs/tree-log.c
···
1374
1374
struct inode *inode = NULL;
1375
1375
unsigned long ref_ptr;
1376
1376
unsigned long ref_end;
1377
-
struct fscrypt_str name;
1377
+
struct fscrypt_str name = { 0 };
1378
1378
int ret;
1379
1379
int log_ref_ver = 0;
1380
1380
u64 parent_objectid;
···
1845
1845
struct btrfs_dir_item *di,
1846
1846
struct btrfs_key *key)
1847
1847
{
1848
-
struct fscrypt_str name;
1848
+
struct fscrypt_str name = { 0 };
1849
1849
struct btrfs_dir_item *dir_dst_di;
1850
1850
struct btrfs_dir_item *index_dst_di;
1851
1851
bool dir_dst_matches = false;
···
2125
2125
struct extent_buffer *eb;
2126
2126
int slot;
2127
2127
struct btrfs_dir_item *di;
2128
-
struct fscrypt_str name;
2128
+
struct fscrypt_str name = { 0 };
2129
2129
struct inode *inode = NULL;
2130
2130
struct btrfs_key location;
2131
2131