Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'for-5.2-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux
Pull btrfs fixes from David Sterba:
"Notable highlights:
- fixes for some long-standing bugs in fsync that were quite hard to
catch but now finaly fixed
- some fixups to error handling paths that did not properly clean up
(locking, memory)
- fix to space reservation for inheriting properties"
* tag 'for-5.2-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux:
Btrfs: tree-checker: detect file extent items with overlapping ranges
Btrfs: fix race between ranged fsync and writeback of adjacent ranges
Btrfs: avoid fallback to transaction commit during fsync of files with holes
btrfs: extent-tree: Fix a bug that btrfs is unable to add pinned bytes
btrfs: sysfs: don't leak memory when failing add fsid
btrfs: sysfs: Fix error path kobject memory leak
Btrfs: do not abort transaction at btrfs_update_root() after failure to COW path
btrfs: use the existing reserved items for our first prop for inheritance
btrfs: don't double unlock on error in btrfs_punch_hole
btrfs: Check the compression level before getting a workspace
+97
-26
+1
fs/btrfs/compression.c
+1
fs/btrfs/compression.c
+8
-7
fs/btrfs/extent-tree.c
+8
-7
fs/btrfs/extent-tree.c
···
757
757
}
758
758
759
759
static void add_pinned_bytes(struct btrfs_fs_info *fs_info,
760
-
struct btrfs_ref *ref)
760
+
struct btrfs_ref *ref, int sign)
761
761
{
762
762
struct btrfs_space_info *space_info;
763
-
s64 num_bytes = -ref->len;
763
+
s64 num_bytes;
764
764
u64 flags;
765
765
766
+
ASSERT(sign == 1 || sign == -1);
767
+
num_bytes = sign * ref->len;
766
768
if (ref->type == BTRFS_REF_METADATA) {
767
769
if (ref->tree_ref.root == BTRFS_CHUNK_TREE_OBJECTID)
768
770
flags = BTRFS_BLOCK_GROUP_SYSTEM;
···
2065
2063
btrfs_ref_tree_mod(fs_info, generic_ref);
2066
2064
2067
2065
if (ret == 0 && old_ref_mod < 0 && new_ref_mod >= 0)
2068
-
add_pinned_bytes(fs_info, generic_ref);
2066
+
add_pinned_bytes(fs_info, generic_ref, -1);
2069
2067
2070
2068
return ret;
2071
2069
}
···
3884
3882
info->space_info_kobj, "%s",
3885
3883
alloc_name(space_info->flags));
3886
3884
if (ret) {
3887
-
percpu_counter_destroy(&space_info->total_bytes_pinned);
3888
-
kfree(space_info);
3885
+
kobject_put(&space_info->kobj);
3889
3886
return ret;
3890
3887
}
3891
3888
···
7191
7190
}
7192
7191
out:
7193
7192
if (pin)
7194
-
add_pinned_bytes(fs_info, &generic_ref);
7193
+
add_pinned_bytes(fs_info, &generic_ref, 1);
7195
7194
7196
7195
if (last_ref) {
7197
7196
/*
···
7239
7238
btrfs_ref_tree_mod(fs_info, ref);
7240
7239
7241
7240
if (ret == 0 && old_ref_mod >= 0 && new_ref_mod < 0)
7242
-
add_pinned_bytes(fs_info, ref);
7241
+
add_pinned_bytes(fs_info, ref, 1);
7243
7242
7244
7243
return ret;
7245
7244
}
+13
-3
fs/btrfs/file.c
+13
-3
fs/btrfs/file.c
···
2068
2068
u64 len;
2069
2069
2070
2070
/*
2071
+
* If the inode needs a full sync, make sure we use a full range to
2072
+
* avoid log tree corruption, due to hole detection racing with ordered
2073
+
* extent completion for adjacent ranges, and assertion failures during
2074
+
* hole detection.
2075
+
*/
2076
+
if (test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2077
+
&BTRFS_I(inode)->runtime_flags)) {
2078
+
start = 0;
2079
+
end = LLONG_MAX;
2080
+
}
2081
+
2082
+
/*
2071
2083
* The range length can be represented by u64, we have to do the typecasts
2072
2084
* to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
2073
2085
*/
···
2566
2554
2567
2555
ret = btrfs_punch_hole_lock_range(inode, lockstart, lockend,
2568
2556
&cached_state);
2569
-
if (ret) {
2570
-
inode_unlock(inode);
2557
+
if (ret)
2571
2558
goto out_only_mutex;
2572
-
}
2573
2559
2574
2560
path = btrfs_alloc_path();
2575
2561
if (!path) {
+22
-8
fs/btrfs/props.c
+22
-8
fs/btrfs/props.c
···
332
332
struct btrfs_fs_info *fs_info = root->fs_info;
333
333
int ret;
334
334
int i;
335
+
bool need_reserve = false;
335
336
336
337
if (!test_bit(BTRFS_INODE_HAS_PROPS,
337
338
&BTRFS_I(parent)->runtime_flags))
···
358
357
if (ret)
359
358
continue;
360
359
361
-
num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
362
-
ret = btrfs_block_rsv_add(root, trans->block_rsv,
363
-
num_bytes, BTRFS_RESERVE_NO_FLUSH);
364
-
if (ret)
365
-
return ret;
360
+
/*
361
+
* Currently callers should be reserving 1 item for properties,
362
+
* since we only have 1 property that we currently support. If
363
+
* we add more in the future we need to try and reserve more
364
+
* space for them. But we should also revisit how we do space
365
+
* reservations if we do add more properties in the future.
366
+
*/
367
+
if (need_reserve) {
368
+
num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
369
+
ret = btrfs_block_rsv_add(root, trans->block_rsv,
370
+
num_bytes, BTRFS_RESERVE_NO_FLUSH);
371
+
if (ret)
372
+
return ret;
373
+
}
366
374
367
375
ret = btrfs_setxattr(trans, inode, h->xattr_name, value,
368
376
strlen(value), 0);
···
385
375
&BTRFS_I(inode)->runtime_flags);
386
376
}
387
377
388
-
btrfs_block_rsv_release(fs_info, trans->block_rsv, num_bytes);
389
-
if (ret)
390
-
return ret;
378
+
if (need_reserve) {
379
+
btrfs_block_rsv_release(fs_info, trans->block_rsv,
380
+
num_bytes);
381
+
if (ret)
382
+
return ret;
383
+
}
384
+
need_reserve = true;
391
385
}
392
386
393
387
return 0;
+1
-3
fs/btrfs/root-tree.c
+1
-3
fs/btrfs/root-tree.c
+6
-1
fs/btrfs/sysfs.c
+6
-1
fs/btrfs/sysfs.c
···
825
825
fs_devs->fsid_kobj.kset = btrfs_kset;
826
826
error = kobject_init_and_add(&fs_devs->fsid_kobj,
827
827
&btrfs_ktype, parent, "%pU", fs_devs->fsid);
828
-
return error;
828
+
if (error) {
829
+
kobject_put(&fs_devs->fsid_kobj);
830
+
return error;
831
+
}
832
+
833
+
return 0;
829
834
}
830
835
831
836
int btrfs_sysfs_add_mounted(struct btrfs_fs_info *fs_info)
+45
-4
fs/btrfs/tree-checker.c
+45
-4
fs/btrfs/tree-checker.c
···
107
107
(!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), (alignment))); \
108
108
})
109
109
110
+
static u64 file_extent_end(struct extent_buffer *leaf,
111
+
struct btrfs_key *key,
112
+
struct btrfs_file_extent_item *extent)
113
+
{
114
+
u64 end;
115
+
u64 len;
116
+
117
+
if (btrfs_file_extent_type(leaf, extent) == BTRFS_FILE_EXTENT_INLINE) {
118
+
len = btrfs_file_extent_ram_bytes(leaf, extent);
119
+
end = ALIGN(key->offset + len, leaf->fs_info->sectorsize);
120
+
} else {
121
+
len = btrfs_file_extent_num_bytes(leaf, extent);
122
+
end = key->offset + len;
123
+
}
124
+
return end;
125
+
}
126
+
110
127
static int check_extent_data_item(struct extent_buffer *leaf,
111
-
struct btrfs_key *key, int slot)
128
+
struct btrfs_key *key, int slot,
129
+
struct btrfs_key *prev_key)
112
130
{
113
131
struct btrfs_fs_info *fs_info = leaf->fs_info;
114
132
struct btrfs_file_extent_item *fi;
···
206
188
CHECK_FE_ALIGNED(leaf, slot, fi, offset, sectorsize) ||
207
189
CHECK_FE_ALIGNED(leaf, slot, fi, num_bytes, sectorsize))
208
190
return -EUCLEAN;
191
+
192
+
/*
193
+
* Check that no two consecutive file extent items, in the same leaf,
194
+
* present ranges that overlap each other.
195
+
*/
196
+
if (slot > 0 &&
197
+
prev_key->objectid == key->objectid &&
198
+
prev_key->type == BTRFS_EXTENT_DATA_KEY) {
199
+
struct btrfs_file_extent_item *prev_fi;
200
+
u64 prev_end;
201
+
202
+
prev_fi = btrfs_item_ptr(leaf, slot - 1,
203
+
struct btrfs_file_extent_item);
204
+
prev_end = file_extent_end(leaf, prev_key, prev_fi);
205
+
if (prev_end > key->offset) {
206
+
file_extent_err(leaf, slot - 1,
207
+
"file extent end range (%llu) goes beyond start offset (%llu) of the next file extent",
208
+
prev_end, key->offset);
209
+
return -EUCLEAN;
210
+
}
211
+
}
212
+
209
213
return 0;
210
214
}
211
215
···
814
774
* Common point to switch the item-specific validation.
815
775
*/
816
776
static int check_leaf_item(struct extent_buffer *leaf,
817
-
struct btrfs_key *key, int slot)
777
+
struct btrfs_key *key, int slot,
778
+
struct btrfs_key *prev_key)
818
779
{
819
780
int ret = 0;
820
781
struct btrfs_chunk *chunk;
821
782
822
783
switch (key->type) {
823
784
case BTRFS_EXTENT_DATA_KEY:
824
-
ret = check_extent_data_item(leaf, key, slot);
785
+
ret = check_extent_data_item(leaf, key, slot, prev_key);
825
786
break;
826
787
case BTRFS_EXTENT_CSUM_KEY:
827
788
ret = check_csum_item(leaf, key, slot);
···
969
928
* Check if the item size and content meet other
970
929
* criteria
971
930
*/
972
-
ret = check_leaf_item(leaf, &key, slot);
931
+
ret = check_leaf_item(leaf, &key, slot, &prev_key);
973
932
if (ret < 0)
974
933
return ret;
975
934
}