btrfs: fix fallocate to use file_modified to update permissions consistently
PATCH 1/1 btrfs: fix fallocate to use file_modified to update permissions consistently
From: Darrick J. Wong <[email protected]>
Since the initial introduction of (posix) fallocate back at the turn of the century, it has been possible to use this syscall to change the user-visible contents of files. This can happen by extending the file size during a preallocation, or through any of the newer modes (punch, zero range). Because the call can be used to change file contents, we should treat it like we do any other modification to a file -- update the mtime, and drop set[ug]id privileges/capabilities.
The VFS function file_modified() does all this for us if pass it a locked inode, so let's make fallocate drop permissions correctly.
---
Note: I plan to add fstests to test this behavior, but after the generic/673 mess, I'm holding back on them until I can fix the three major filesystems and clean up the xfs setattr_copy code.
https://lore.kernel.org/linux-ext4/20220310174410.GB8172@magnolia/T/#u
--- fs/btrfs/file.c | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-)
fs/btrfs/file.c +19 -4
@@ -2918,8 +2918,9 @@ int btrfs_replace_file_extents(struct btrfs_inode *inode,return ret; } -static int btrfs_punch_hole (struct inode *inode,loff_t offset,loff_t len) +static int btrfs_punch_hole (struct file *file,loff_t offset,loff_t len) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_root *root =BTRFS_I (inode)->root;struct extent_state *cached_state =NULL ;
@@ -2951,6 +2952,10 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len) goto out_only_mutex; } + ret =file_modified (file); +if (ret) + goto out_only_mutex; + lockstart =round_up (offset,btrfs_inode_sectorsize (BTRFS_I (inode))); lockend =round_down (offset + len,btrfs_inode_sectorsize (BTRFS_I (inode))) -1 ;
@@ -3177,11 +3182,12 @@ static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,return ret; } -static int btrfs_zero_range (struct inode *inode, +static int btrfs_zero_range (struct file *file,loff_t offset,loff_t len,const int mode) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =BTRFS_I (inode)->root->fs_info;struct extent_map *em;struct extent_changeset *data_reserved =NULL ;
@@ -3202,6 +3208,12 @@ static int btrfs_zero_range(struct inode *inode, goto out; } + ret =file_modified (file); +if (ret) { +free_extent_map (em); + goto out; + } +/* * Avoid hole punching and extent allocation for some cases. More cases * could be considered, but these are unlikely common and we keep things
@@ -3391,7 +3403,7 @@ static long btrfs_fallocate(struct file *file, int mode,return -EOPNOTSUPP ;if (mode &FALLOC_FL_PUNCH_HOLE ) -return btrfs_punch_hole (inode, offset, len); +return btrfs_punch_hole (file, offset, len);/* * Only trigger disk allocation, don't trigger qgroup reserve
@@ -3446,7 +3458,7 @@ static long btrfs_fallocate(struct file *file, int mode, goto out;if (mode &FALLOC_FL_ZERO_RANGE ) { - ret =btrfs_zero_range (inode, offset, len, mode); + ret =btrfs_zero_range (file, offset, len, mode);btrfs_inode_unlock (inode,BTRFS_ILOCK_MMAP );return ret; }
@@ -3528,6 +3540,9 @@ static long btrfs_fallocate(struct file *file, int mode, cur_offset = last_byte; } +if (!ret) + ret =file_modified (file); +/* * If ret is still 0, means we're OK to fallocate. * Or just cleanup the list and exit.
Quoted 65 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Since the initial introduction of (posix) fallocate back at the turn of the century, it has been possible to use this syscall to change the user-visible contents of files. This can happen by extending the file size during a preallocation, or through any of the newer modes (punch, zero range). Because the call can be used to change file contents, we should treat it like we do any other modification to a file -- update the mtime, and drop set[ug]id privileges/capabilities.
The VFS function
file_modified()does all this for us if pass it a locked inode, so let's make fallocate drop permissions correctly.Signed-off-by Darrick J. Wong <[email protected]>---
Note: I plan to add fstests to test this behavior, but after the generic/673 mess, I'm holding back on them until I can fix the three major filesystems and clean up the xfssetattr_copycode.https://lore.kernel.org/linux-ext4/20220310174410.GB8172@magnolia/T/#u
--- fs/btrfs/file.c | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-)fs/btrfs/file.c +8
-2@@ -2918,8 +2918,9 @@ int btrfs_replace_file_extents(struct btrfs_inode *inode,return ret; } -static int btrfs_punch_hole (struct inode *inode,loff_t offset,loff_t len) +static int btrfs_punch_hole (struct file *file,loff_t offset,loff_t len) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_root *root =BTRFS_I (inode)->root;struct extent_state *cached_state =NULL ;@@ -2951,6 +2952,10 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len) goto out_only_mutex; } + ret =file_modified (file); +if (ret) + goto out_only_mutex; + lockstart =round_up (offset,btrfs_inode_sectorsize (BTRFS_I (inode))); lockend =round_down (offset + len,btrfs_inode_sectorsize (BTRFS_I (inode))) -1 ;@@ -3177,11 +3182,12 @@ static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,return ret; } -static int btrfs_zero_range (struct inode *inode, +static int btrfs_zero_range (struct file *file,loff_t offset,loff_t len,const int mode) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =BTRFS_I (inode)->root->fs_info;struct extent_map *em;struct extent_changeset *data_reserved =NULL ;
fs/btrfs/file.c static int btrfs_zero_range(struct inode *inode, · line 3216
Quoted 9 lines
fs/btrfs/file.c +6
-0@@ -3202,6 +3208,12 @@ static int btrfs_zero_range(struct inode *inode, goto out; } + ret =file_modified (file); +if (ret) { +free_extent_map (em); + goto out; + } +
Could be done before getting the extent map, to make the code a bit shorter, or see the comment below.
Quoted 22 lines
fs/btrfs/file.c +2
-2/* * Avoid hole punching and extent allocation for some cases. More cases * could be considered, but these are unlikely common and we keep things @@ -3391,7 +3403,7 @@ static long btrfs_fallocate(struct file *file, int mode,return -EOPNOTSUPP ;if (mode &FALLOC_FL_PUNCH_HOLE ) -return btrfs_punch_hole (inode, offset, len); +return btrfs_punch_hole (file, offset, len);/* * Only trigger disk allocation, don't trigger qgroup reserve @@ -3446,7 +3458,7 @@ static long btrfs_fallocate(struct file *file, int mode, goto out;if (mode &FALLOC_FL_ZERO_RANGE ) { - ret =btrfs_zero_range (inode, offset, len, mode); + ret =btrfs_zero_range (file, offset, len, mode);btrfs_inode_unlock (inode,BTRFS_ILOCK_MMAP );return ret; }
fs/btrfs/file.c static long btrfs_fallocate(struct file *file, int mode, · line 3544
Quoted 5 lines
fs/btrfs/file.c +2
-0@@ -3528,6 +3540,9 @@ static long btrfs_fallocate(struct file *file, int mode, cur_offset = last_byte; } +if (!ret) + ret =file_modified (file);
If call file_modified() before the if that checks for the zero range case, then we avoid having to call file_modified() at btrfs_zero_range() too, and get the behaviour for both plain fallocate and zero range.
Otherwise, it looks good.
Thanks for doing this, I had it on my todo list since I noticed the generic/673 failure with reflinks and the suid/sgid bits.
Quoted 4 lines
fs/btrfs/file.c +1
-0+/* * If ret is still 0, means we're OK to fallocate. * Or just cleanup the list and exit.
Quoted 69 lines · Filipe Manana
Quoted 68 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Since the initial introduction of (posix) fallocate back at the turn of the century, it has been possible to use this syscall to change the user-visible contents of files. This can happen by extending the file size during a preallocation, or through any of the newer modes (punch, zero range). Because the call can be used to change file contents, we should treat it like we do any other modification to a file -- update the mtime, and drop set[ug]id privileges/capabilities.
The VFS function
file_modified()does all this for us if pass it a locked inode, so let's make fallocate drop permissions correctly.Signed-off-by Darrick J. Wong <[email protected]>---
Note: I plan to add fstests to test this behavior, but after the generic/673 mess, I'm holding back on them until I can fix the three major filesystems and clean up the xfssetattr_copycode.https://lore.kernel.org/linux-ext4/20220310174410.GB8172@magnolia/T/#u
--- fs/btrfs/file.c | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-)fs/btrfs/file.c +8
-2@@ -2918,8 +2918,9 @@ int btrfs_replace_file_extents(struct btrfs_inode *inode,return ret; } -static int btrfs_punch_hole (struct inode *inode,loff_t offset,loff_t len) +static int btrfs_punch_hole (struct file *file,loff_t offset,loff_t len) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_root *root =BTRFS_I (inode)->root;struct extent_state *cached_state =NULL ;@@ -2951,6 +2952,10 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len) goto out_only_mutex; } + ret =file_modified (file); +if (ret) + goto out_only_mutex; + lockstart =round_up (offset,btrfs_inode_sectorsize (BTRFS_I (inode))); lockend =round_down (offset + len,btrfs_inode_sectorsize (BTRFS_I (inode))) -1 ;@@ -3177,11 +3182,12 @@ static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,return ret; } -static int btrfs_zero_range (struct inode *inode, +static int btrfs_zero_range (struct file *file,loff_t offset,loff_t len,const int mode) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =BTRFS_I (inode)->root->fs_info;struct extent_map *em;struct extent_changeset *data_reserved =NULL ;@@ -3202,6 +3208,12 @@ static int btrfs_zero_range(struct inode *inode, goto out; }
Quoted 9 lines
fs/btrfs/file.c static int btrfs_zero_range(struct inode *inode, · line 3216
Quoted 6 lines
fs/btrfs/file.c +6
-0+ ret =file_modified (file); +if (ret) { +free_extent_map (em); + goto out; + } +Could be done before getting the extent map, to make the code a bit shorter, or see the comment below.
The trouble is, if getting the extent map fails, we didn't change the file, so there's no reason to bump the timestamps and whatnot...
Quoted 26 lines
Quoted 26 lines
fs/btrfs/file.c +2
-2/* * Avoid hole punching and extent allocation for some cases. More cases * could be considered, but these are unlikely common and we keep things @@ -3391,7 +3403,7 @@ static long btrfs_fallocate(struct file *file, int mode,return -EOPNOTSUPP ;if (mode &FALLOC_FL_PUNCH_HOLE ) -return btrfs_punch_hole (inode, offset, len); +return btrfs_punch_hole (file, offset, len);/* * Only trigger disk allocation, don't trigger qgroup reserve @@ -3446,7 +3458,7 @@ static long btrfs_fallocate(struct file *file, int mode, goto out;if (mode &FALLOC_FL_ZERO_RANGE ) { - ret =btrfs_zero_range (inode, offset, len, mode); + ret =btrfs_zero_range (file, offset, len, mode);btrfs_inode_unlock (inode,BTRFS_ILOCK_MMAP );return ret; }@@ -3528,6 +3540,9 @@ static long btrfs_fallocate(struct file *file, int mode, cur_offset = last_byte; }
Quoted 6 lines
fs/btrfs/file.c static long btrfs_fallocate(struct file *file, int mode, · line 3544
Quoted 2 lines
fs/btrfs/file.c +2
-0+if (!ret) + ret =file_modified (file);If call
file_modified()before the if that checks for the zero range case, then we avoid having to callfile_modified()atbtrfs_zero_range()too, and get the behaviour for both plain fallocate and zero range.
...and the reason I put it here is to make sure the ordered IO finishes ok and that we pass the quota limit checks before we start modifying things.
That said -- you all know btrfs far better than I do, so if you'd rather I put these calls further up (probably right after the inode_newsize_ok check?) then I'm happy to do that. :)
--D
Quoted 10 lines
Otherwise, it looks good.
Thanks for doing this, I had it on my todo list since I noticed the generic/673 failure with reflinks and the suid/sgid bits.
Quoted 4 lines
fs/btrfs/file.c +1
-0+/* * If ret is still 0, means we're OK to fallocate. * Or just cleanup the list and exit.
Quoted 80 lines · Darrick J. Wong
Quoted 69 lines · Filipe Manana
Quoted 68 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Since the initial introduction of (posix) fallocate back at the turn of the century, it has been possible to use this syscall to change the user-visible contents of files. This can happen by extending the file size during a preallocation, or through any of the newer modes (punch, zero range). Because the call can be used to change file contents, we should treat it like we do any other modification to a file -- update the mtime, and drop set[ug]id privileges/capabilities.
The VFS function
file_modified()does all this for us if pass it a locked inode, so let's make fallocate drop permissions correctly.Signed-off-by Darrick J. Wong <[email protected]>---
Note: I plan to add fstests to test this behavior, but after the generic/673 mess, I'm holding back on them until I can fix the three major filesystems and clean up the xfssetattr_copycode.https://lore.kernel.org/linux-ext4/20220310174410.GB8172@magnolia/T/#u
--- fs/btrfs/file.c | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-)fs/btrfs/file.c +8
-2@@ -2918,8 +2918,9 @@ int btrfs_replace_file_extents(struct btrfs_inode *inode,return ret; } -static int btrfs_punch_hole (struct inode *inode,loff_t offset,loff_t len) +static int btrfs_punch_hole (struct file *file,loff_t offset,loff_t len) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_root *root =BTRFS_I (inode)->root;struct extent_state *cached_state =NULL ;@@ -2951,6 +2952,10 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len) goto out_only_mutex; } + ret =file_modified (file); +if (ret) + goto out_only_mutex; + lockstart =round_up (offset,btrfs_inode_sectorsize (BTRFS_I (inode))); lockend =round_down (offset + len,btrfs_inode_sectorsize (BTRFS_I (inode))) -1 ;@@ -3177,11 +3182,12 @@ static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,return ret; } -static int btrfs_zero_range (struct inode *inode, +static int btrfs_zero_range (struct file *file,loff_t offset,loff_t len,const int mode) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =BTRFS_I (inode)->root->fs_info;struct extent_map *em;struct extent_changeset *data_reserved =NULL ;@@ -3202,6 +3208,12 @@ static int btrfs_zero_range(struct inode *inode, goto out; }Quoted 9 lines
fs/btrfs/file.c static int btrfs_zero_range(struct inode *inode, · line 3216
Quoted 6 lines
fs/btrfs/file.c +6
-0+ ret =file_modified (file); +if (ret) { +free_extent_map (em); + goto out; + } +Could be done before getting the extent map, to make the code a bit shorter, or see the comment below.
Quoted 2 lines
The trouble is, if getting the extent map fails, we didn't change the file, so there's no reason to bump the timestamps and whatnot...
Right, I figured you had that sort of intention.
However after the call to file_modified(), we may actually have not change the file at all, like when trying to zero a range that is already fully covered by a preallocated extent.
Quoted 34 lines
Quoted 27 lines
Quoted 27 lines
fs/btrfs/file.c +2
-2/* * Avoid hole punching and extent allocation for some cases. More cases * could be considered, but these are unlikely common and we keep things @@ -3391,7 +3403,7 @@ static long btrfs_fallocate(struct file *file, int mode,return -EOPNOTSUPP ;if (mode &FALLOC_FL_PUNCH_HOLE ) -return btrfs_punch_hole (inode, offset, len); +return btrfs_punch_hole (file, offset, len);/* * Only trigger disk allocation, don't trigger qgroup reserve @@ -3446,7 +3458,7 @@ static long btrfs_fallocate(struct file *file, int mode, goto out;if (mode &FALLOC_FL_ZERO_RANGE ) { - ret =btrfs_zero_range (inode, offset, len, mode); + ret =btrfs_zero_range (file, offset, len, mode);btrfs_inode_unlock (inode,BTRFS_ILOCK_MMAP );return ret; }@@ -3528,6 +3540,9 @@ static long btrfs_fallocate(struct file *file, int mode, cur_offset = last_byte; }Quoted 6 lines
fs/btrfs/file.c static long btrfs_fallocate(struct file *file, int mode, · line 3544
Quoted 2 lines
fs/btrfs/file.c +2
-0+if (!ret) + ret =file_modified (file);If call
file_modified()before the if that checks for the zero range case, then we avoid having to callfile_modified()atbtrfs_zero_range()too, and get the behaviour for both plain fallocate and zero range.
Quoted 3 lines
...and the reason I put it here is to make sure the ordered IO finishes ok and that we pass the quota limit checks before we start modifying things.
Ok, but before that point we may already have modified the file, through a call to either btrfs_cont_expand() or btrfs_truncate_block() above, to zero out part of the content of a page.
So if we did that, and we got an error when waiting for ordered extents or from the qgroup reservation, we end up leaving fallocate without calling file_modified(), despite having modified the file.
Quoted 4 lines
That said -- you all know btrfs far better than I do, so if you'd rather I put these calls further up (probably right after the
inode_newsize_okcheck?) then I'm happy to do that. :)
Technically I suppose we should only call file_modified() if we actually change anything in the file, but as it is, we are calling it even when we don't end up modifying it or in some cases not calling it when we modify it.
How does xfs behaves in this respect? Does it call file_modified() only if something in the file actually changed?
Thanks.
Quoted 13 lines
--D
Quoted 10 lines
Otherwise, it looks good.
Thanks for doing this, I had it on my todo list since I noticed the generic/673 failure with reflinks and the suid/sgid bits.
Quoted 4 lines
fs/btrfs/file.c +1
-0+/* * If ret is still 0, means we're OK to fallocate. * Or just cleanup the list and exit.
Quoted 81 lines · Filipe Manana
Quoted 80 lines · Darrick J. Wong
Quoted 78 lines · Filipe Manana
Quoted 65 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Since the initial introduction of (posix) fallocate back at the turn of the century, it has been possible to use this syscall to change the user-visible contents of files. This can happen by extending the file size during a preallocation, or through any of the newer modes (punch, zero range). Because the call can be used to change file contents, we should treat it like we do any other modification to a file -- update the mtime, and drop set[ug]id privileges/capabilities.
The VFS function
file_modified()does all this for us if pass it a locked inode, so let's make fallocate drop permissions correctly.Signed-off-by Darrick J. Wong <[email protected]>---
Note: I plan to add fstests to test this behavior, but after the generic/673 mess, I'm holding back on them until I can fix the three major filesystems and clean up the xfssetattr_copycode.https://lore.kernel.org/linux-ext4/20220310174410.GB8172@magnolia/T/#u
--- fs/btrfs/file.c | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-)fs/btrfs/file.c +8
-2@@ -2918,8 +2918,9 @@ int btrfs_replace_file_extents(struct btrfs_inode *inode,return ret; } -static int btrfs_punch_hole (struct inode *inode,loff_t offset,loff_t len) +static int btrfs_punch_hole (struct file *file,loff_t offset,loff_t len) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_root *root =BTRFS_I (inode)->root;struct extent_state *cached_state =NULL ;@@ -2951,6 +2952,10 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len) goto out_only_mutex; } + ret =file_modified (file); +if (ret) + goto out_only_mutex; + lockstart =round_up (offset,btrfs_inode_sectorsize (BTRFS_I (inode))); lockend =round_down (offset + len,btrfs_inode_sectorsize (BTRFS_I (inode))) -1 ;@@ -3177,11 +3182,12 @@ static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,return ret; } -static int btrfs_zero_range (struct inode *inode, +static int btrfs_zero_range (struct file *file,loff_t offset,loff_t len,const int mode) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =BTRFS_I (inode)->root->fs_info;struct extent_map *em;struct extent_changeset *data_reserved =NULL ;fs/btrfs/file.c static int btrfs_zero_range(struct inode *inode, · line 3216
Quoted 9 lines
fs/btrfs/file.c +6
-0@@ -3202,6 +3208,12 @@ static int btrfs_zero_range(struct inode *inode, goto out; } + ret =file_modified (file); +if (ret) { +free_extent_map (em); + goto out; + } +Could be done before getting the extent map, to make the code a bit shorter, or see the comment below.
Quoted 8 lines
Quoted 2 lines
The trouble is, if getting the extent map fails, we didn't change the file, so there's no reason to bump the timestamps and whatnot...
Right, I figured you had that sort of intention.
However after the call to
file_modified(), we may actually have not change the file at all, like when trying to zero a range that is already fully covered by a preallocated extent.
<nod> At least in XFSland, there's no good way to check for a pre-existing prealloc extent without holding the ILOCK, which makes things complicated as I'll explain below. :)
Quoted 34 lines
Quoted 34 lines
Quoted 33 lines
Quoted 24 lines
fs/btrfs/file.c +2
-2/* * Avoid hole punching and extent allocation for some cases. More cases * could be considered, but these are unlikely common and we keep things @@ -3391,7 +3403,7 @@ static long btrfs_fallocate(struct file *file, int mode,return -EOPNOTSUPP ;if (mode &FALLOC_FL_PUNCH_HOLE ) -return btrfs_punch_hole (inode, offset, len); +return btrfs_punch_hole (file, offset, len);/* * Only trigger disk allocation, don't trigger qgroup reserve @@ -3446,7 +3458,7 @@ static long btrfs_fallocate(struct file *file, int mode, goto out;if (mode &FALLOC_FL_ZERO_RANGE ) { - ret =btrfs_zero_range (inode, offset, len, mode); + ret =btrfs_zero_range (file, offset, len, mode);btrfs_inode_unlock (inode,BTRFS_ILOCK_MMAP );return ret; }fs/btrfs/file.c static long btrfs_fallocate(struct file *file, int mode, · line 3544
Quoted 5 lines
fs/btrfs/file.c +2
-0@@ -3528,6 +3540,9 @@ static long btrfs_fallocate(struct file *file, int mode, cur_offset = last_byte; } +if (!ret) + ret =file_modified (file);If call
file_modified()before the if that checks for the zero range case, then we avoid having to callfile_modified()atbtrfs_zero_range()too, and get the behaviour for both plain fallocate and zero range.
Quoted 7 lines
Quoted 3 lines
...and the reason I put it here is to make sure the ordered IO finishes ok and that we pass the quota limit checks before we start modifying things.
Ok, but before that point we may already have modified the file, through a call to either
btrfs_cont_expand()orbtrfs_truncate_block()above, to zero out part of the content of a page.
Ahh, ok. My goal was to eliminate the places where we don't call file_modified, even if that comes at the cost of occasionally doing it when it wasn't strictly necessary.
Quoted 5 lines
So if we did that, and we got an error when waiting for ordered extents or from the qgroup reservation, we end up leaving fallocate without calling
file_modified(), despite having modified the file.Quoted 1 line
Quoted 8 lines
Quoted 3 lines
That said -- you all know btrfs far better than I do, so if you'd rather I put these calls further up (probably right after the
inode_newsize_okcheck?) then I'm happy to do that. :)Technically I suppose we should only call
file_modified()if we actually change anything in the file, but as it is, we are calling it even when we don't end up modifying it or in some cases not calling it when we modify it.
Yep.
Quoted 2 lines
How does xfs behaves in this respect? Does it call
file_modified()only if something in the file actually changed?
file_modified calls back into the filesystem to run transactions to update metadata, which means that XFS can't call it if it's already gotten a transaction and an inode ILOCK. Unfortunately, we also can't check to see if the file actually requires modifications (zeroing contents, extending i_size) until we've taken the ILOCK.
If we really wanted to be strict about only stripping permissions if the file *actually* changed, we'd either have to re-design our setattr implementation to notice a running transaction and use it; or do a weird little dance where we lock the inode, check it, undo all that to call file_modified if we decide it's necessary, and then create a new transaction and re-lock it. We'd also have to keep doing that until the file stabilizes, which seemed like a lot of work to handle something that's mostly a corner case, so XFS always calls file_modified after successfully flushing data to disk.
At that point XFS haven't even gotten to checking quota yet, so technically that's also a gap where we could drop privs but then fail the fallocate with EDQUOT.
--D
Quoted 16 lines
Thanks.
Quoted 13 lines
--D
Quoted 10 lines
Otherwise, it looks good.
Thanks for doing this, I had it on my todo list since I noticed the generic/673 failure with reflinks and the suid/sgid bits.
Quoted 4 lines
fs/btrfs/file.c +1
-0+/* * If ret is still 0, means we're OK to fallocate. * Or just cleanup the list and exit.
Quoted 166 lines · Darrick J. Wong
Quoted 81 lines · Filipe Manana
Quoted 80 lines · Darrick J. Wong
Quoted 78 lines · Filipe Manana
Quoted 65 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Since the initial introduction of (posix) fallocate back at the turn of the century, it has been possible to use this syscall to change the user-visible contents of files. This can happen by extending the file size during a preallocation, or through any of the newer modes (punch, zero range). Because the call can be used to change file contents, we should treat it like we do any other modification to a file -- update the mtime, and drop set[ug]id privileges/capabilities.
The VFS function
file_modified()does all this for us if pass it a locked inode, so let's make fallocate drop permissions correctly.Signed-off-by Darrick J. Wong <[email protected]>---
Note: I plan to add fstests to test this behavior, but after the generic/673 mess, I'm holding back on them until I can fix the three major filesystems and clean up the xfssetattr_copycode.https://lore.kernel.org/linux-ext4/20220310174410.GB8172@magnolia/T/#u
--- fs/btrfs/file.c | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-)fs/btrfs/file.c +8
-2@@ -2918,8 +2918,9 @@ int btrfs_replace_file_extents(struct btrfs_inode *inode,return ret; } -static int btrfs_punch_hole (struct inode *inode,loff_t offset,loff_t len) +static int btrfs_punch_hole (struct file *file,loff_t offset,loff_t len) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_root *root =BTRFS_I (inode)->root;struct extent_state *cached_state =NULL ;@@ -2951,6 +2952,10 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len) goto out_only_mutex; } + ret =file_modified (file); +if (ret) + goto out_only_mutex; + lockstart =round_up (offset,btrfs_inode_sectorsize (BTRFS_I (inode))); lockend =round_down (offset + len,btrfs_inode_sectorsize (BTRFS_I (inode))) -1 ;@@ -3177,11 +3182,12 @@ static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,return ret; } -static int btrfs_zero_range (struct inode *inode, +static int btrfs_zero_range (struct file *file,loff_t offset,loff_t len,const int mode) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =BTRFS_I (inode)->root->fs_info;struct extent_map *em;struct extent_changeset *data_reserved =NULL ;fs/btrfs/file.c static int btrfs_zero_range(struct inode *inode, · line 3216
Quoted 9 lines
fs/btrfs/file.c +6
-0@@ -3202,6 +3208,12 @@ static int btrfs_zero_range(struct inode *inode, goto out; } + ret =file_modified (file); +if (ret) { +free_extent_map (em); + goto out; + } +Could be done before getting the extent map, to make the code a bit shorter, or see the comment below.
Quoted 8 lines
Quoted 2 lines
The trouble is, if getting the extent map fails, we didn't change the file, so there's no reason to bump the timestamps and whatnot...
Right, I figured you had that sort of intention.
However after the call to
file_modified(), we may actually have not change the file at all, like when trying to zero a range that is already fully covered by a preallocated extent.<nod> At least in XFSland, there's no good way to check for a pre-existing prealloc extent without holding the ILOCK, which makes things complicated as I'll explain below. :)
Quoted 34 lines
Quoted 34 lines
Quoted 33 lines
Quoted 24 lines
fs/btrfs/file.c +2
-2/* * Avoid hole punching and extent allocation for some cases. More cases * could be considered, but these are unlikely common and we keep things @@ -3391,7 +3403,7 @@ static long btrfs_fallocate(struct file *file, int mode,return -EOPNOTSUPP ;if (mode &FALLOC_FL_PUNCH_HOLE ) -return btrfs_punch_hole (inode, offset, len); +return btrfs_punch_hole (file, offset, len);/* * Only trigger disk allocation, don't trigger qgroup reserve @@ -3446,7 +3458,7 @@ static long btrfs_fallocate(struct file *file, int mode, goto out;if (mode &FALLOC_FL_ZERO_RANGE ) { - ret =btrfs_zero_range (inode, offset, len, mode); + ret =btrfs_zero_range (file, offset, len, mode);btrfs_inode_unlock (inode,BTRFS_ILOCK_MMAP );return ret; }fs/btrfs/file.c static long btrfs_fallocate(struct file *file, int mode, · line 3544
Quoted 5 lines
fs/btrfs/file.c +2
-0@@ -3528,6 +3540,9 @@ static long btrfs_fallocate(struct file *file, int mode, cur_offset = last_byte; } +if (!ret) + ret =file_modified (file);If call
file_modified()before the if that checks for the zero range case, then we avoid having to callfile_modified()atbtrfs_zero_range()too, and get the behaviour for both plain fallocate and zero range.Quoted 7 lines
Quoted 3 lines
...and the reason I put it here is to make sure the ordered IO finishes ok and that we pass the quota limit checks before we start modifying things.
Ok, but before that point we may already have modified the file, through a call to either
btrfs_cont_expand()orbtrfs_truncate_block()above, to zero out part of the content of a page.Ahh, ok. My goal was to eliminate the places where we don't call
file_modified, even if that comes at the cost of occasionally doing it when it wasn't strictly necessary.Quoted 5 lines
So if we did that, and we got an error when waiting for ordered extents or from the qgroup reservation, we end up leaving fallocate without calling
file_modified(), despite having modified the file.Quoted 1 line
Quoted 8 lines
Quoted 3 lines
That said -- you all know btrfs far better than I do, so if you'd rather I put these calls further up (probably right after the
inode_newsize_okcheck?) then I'm happy to do that. :)Technically I suppose we should only call
file_modified()if we actually change anything in the file, but as it is, we are calling it even when we don't end up modifying it or in some cases not calling it when we modify it.Yep.
Quoted 2 lines
How does xfs behaves in this respect? Does it call
file_modified()only if something in the file actually changed?
file_modifiedcalls back into the filesystem to run transactions to update metadata, which means that XFS can't call it if it's already gotten a transaction and an inode ILOCK. Unfortunately, we also can't check to see if the file actually requires modifications (zeroing contents, extendingi_size) until we've taken the ILOCK.
Quoted 9 lines
If we really wanted to be strict about only stripping permissions if the file *actually* changed, we'd either have to re-design our setattr implementation to notice a running transaction and use it; or do a weird little dance where we lock the inode, check it, undo all that to call
file_modifiedif we decide it's necessary, and then create a new transaction and re-lock it. We'd also have to keep doing that until the file stabilizes, which seemed like a lot of work to handle something that's mostly a corner case, so XFS always callsfile_modifiedafter successfully flushing data to disk.
Ah, I see.
So that also explains why XFS fails for this test:
#!/bin/bash
DEV=/dev/sdj
MNT=/mnt/sdj
umount $DEV &> /dev/null
#mkfs.btrfs -f -b 1g $DEV
#mkfs.ext4 -F -b 4096 $DEV $(((1024 * 1024 * 1024) / 4096))
#mkfs.f2fs -f -w 4096 $DEV $(((1024 * 1024 * 1024) / 4096))
mkfs.xfs -f -d size=1g $DEV
mount $DEV $MNT
# Create a file with a size of 600M and two holes, one at [200M, 201M[
# and another at [401M, 402M[
xfs_io -f -c "pwrite -S 0xab 0 200M" \
-c "pwrite -S 0xcd 201M 200M" \
-c "pwrite -S 0xef 402M 198M" \
$MNT/foobar# Now call fallocate against the whole file range, see if it fails
# with -ENOSPC or not - it shouldn't since we only need to allocate # 2M of data space. echo -e "\nCalling fallocate..." xfs_io -c "falloc 0 600M" $MNT/foobar
umount $MNT
The fallocate fails with -ENOSPC, as it seems XFS tries to allocate 600M of space. So it seems that happens before taking the ILOCK, but it can only know for sure how much space it needs to allocate after taking that lock - I assume the space allocation can't happen after taking the ILOCK, due to some possible deadlock maybe?
That test currently fails on btrfs as well, but I had just sent a patch to fix it:
We actually had at least one report about systemd using fallocate against a file range that has already allocated extents, so it could unnecessarily fail with -ENOSPC if the fs free space is low (it's reported somewhere in the middle of the thread in the Link tag of the patch).
Ext4 and f2fs pass the test.
I was turning the test case into a generic test for fstests, but then noticied XFS failing. Is this something you would consider fixing for XFS? Should I submit it as a generic test case, or as a btrfs specific test case?
Thanks for the explanation and the patch.
Quoted 23 lines
At that point XFS haven't even gotten to checking quota yet, so technically that's also a gap where we could drop privs but then fail the fallocate with EDQUOT.
--D
Quoted 16 lines
Thanks.
Quoted 13 lines
--D
Quoted 10 lines
Otherwise, it looks good.
Thanks for doing this, I had it on my todo list since I noticed the generic/673 failure with reflinks and the suid/sgid bits.
Quoted 4 lines
fs/btrfs/file.c +1
-0+/* * If ret is still 0, means we're OK to fallocate. * Or just cleanup the list and exit.
[add xfs list]
Quoted 207 lines · Filipe Manana
Quoted 166 lines · Darrick J. Wong
Quoted 81 lines · Filipe Manana
Quoted 80 lines · Darrick J. Wong
Quoted 78 lines · Filipe Manana
Quoted 65 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Since the initial introduction of (posix) fallocate back at the turn of the century, it has been possible to use this syscall to change the user-visible contents of files. This can happen by extending the file size during a preallocation, or through any of the newer modes (punch, zero range). Because the call can be used to change file contents, we should treat it like we do any other modification to a file -- update the mtime, and drop set[ug]id privileges/capabilities.
The VFS function
file_modified()does all this for us if pass it a locked inode, so let's make fallocate drop permissions correctly.Signed-off-by Darrick J. Wong <[email protected]>---
Note: I plan to add fstests to test this behavior, but after the generic/673 mess, I'm holding back on them until I can fix the three major filesystems and clean up the xfssetattr_copycode.https://lore.kernel.org/linux-ext4/20220310174410.GB8172@magnolia/T/#u
--- fs/btrfs/file.c | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-)fs/btrfs/file.c +8
-2@@ -2918,8 +2918,9 @@ int btrfs_replace_file_extents(struct btrfs_inode *inode,return ret; } -static int btrfs_punch_hole (struct inode *inode,loff_t offset,loff_t len) +static int btrfs_punch_hole (struct file *file,loff_t offset,loff_t len) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_root *root =BTRFS_I (inode)->root;struct extent_state *cached_state =NULL ;@@ -2951,6 +2952,10 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len) goto out_only_mutex; } + ret =file_modified (file); +if (ret) + goto out_only_mutex; + lockstart =round_up (offset,btrfs_inode_sectorsize (BTRFS_I (inode))); lockend =round_down (offset + len,btrfs_inode_sectorsize (BTRFS_I (inode))) -1 ;@@ -3177,11 +3182,12 @@ static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,return ret; } -static int btrfs_zero_range (struct inode *inode, +static int btrfs_zero_range (struct file *file,loff_t offset,loff_t len,const int mode) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =BTRFS_I (inode)->root->fs_info;struct extent_map *em;struct extent_changeset *data_reserved =NULL ;fs/btrfs/file.c static int btrfs_zero_range(struct inode *inode, · line 3216
Quoted 9 lines
fs/btrfs/file.c +6
-0@@ -3202,6 +3208,12 @@ static int btrfs_zero_range(struct inode *inode, goto out; } + ret =file_modified (file); +if (ret) { +free_extent_map (em); + goto out; + } +Could be done before getting the extent map, to make the code a bit shorter, or see the comment below.
Quoted 8 lines
Quoted 2 lines
The trouble is, if getting the extent map fails, we didn't change the file, so there's no reason to bump the timestamps and whatnot...
Right, I figured you had that sort of intention.
However after the call to
file_modified(), we may actually have not change the file at all, like when trying to zero a range that is already fully covered by a preallocated extent.<nod> At least in XFSland, there's no good way to check for a pre-existing prealloc extent without holding the ILOCK, which makes things complicated as I'll explain below. :)
Quoted 34 lines
Quoted 34 lines
Quoted 33 lines
Quoted 24 lines
fs/btrfs/file.c +2
-2/* * Avoid hole punching and extent allocation for some cases. More cases * could be considered, but these are unlikely common and we keep things @@ -3391,7 +3403,7 @@ static long btrfs_fallocate(struct file *file, int mode,return -EOPNOTSUPP ;if (mode &FALLOC_FL_PUNCH_HOLE ) -return btrfs_punch_hole (inode, offset, len); +return btrfs_punch_hole (file, offset, len);/* * Only trigger disk allocation, don't trigger qgroup reserve @@ -3446,7 +3458,7 @@ static long btrfs_fallocate(struct file *file, int mode, goto out;if (mode &FALLOC_FL_ZERO_RANGE ) { - ret =btrfs_zero_range (inode, offset, len, mode); + ret =btrfs_zero_range (file, offset, len, mode);btrfs_inode_unlock (inode,BTRFS_ILOCK_MMAP );return ret; }fs/btrfs/file.c static long btrfs_fallocate(struct file *file, int mode, · line 3544
Quoted 5 lines
fs/btrfs/file.c +2
-0@@ -3528,6 +3540,9 @@ static long btrfs_fallocate(struct file *file, int mode, cur_offset = last_byte; } +if (!ret) + ret =file_modified (file);If call
file_modified()before the if that checks for the zero range case, then we avoid having to callfile_modified()atbtrfs_zero_range()too, and get the behaviour for both plain fallocate and zero range.Quoted 7 lines
Quoted 3 lines
...and the reason I put it here is to make sure the ordered IO finishes ok and that we pass the quota limit checks before we start modifying things.
Ok, but before that point we may already have modified the file, through a call to either
btrfs_cont_expand()orbtrfs_truncate_block()above, to zero out part of the content of a page.Ahh, ok. My goal was to eliminate the places where we don't call
file_modified, even if that comes at the cost of occasionally doing it when it wasn't strictly necessary.Quoted 5 lines
So if we did that, and we got an error when waiting for ordered extents or from the qgroup reservation, we end up leaving fallocate without calling
file_modified(), despite having modified the file.Quoted 1 line
Quoted 8 lines
Quoted 3 lines
That said -- you all know btrfs far better than I do, so if you'd rather I put these calls further up (probably right after the
inode_newsize_okcheck?) then I'm happy to do that. :)Technically I suppose we should only call
file_modified()if we actually change anything in the file, but as it is, we are calling it even when we don't end up modifying it or in some cases not calling it when we modify it.Yep.
Quoted 2 lines
How does xfs behaves in this respect? Does it call
file_modified()only if something in the file actually changed?
file_modifiedcalls back into the filesystem to run transactions to update metadata, which means that XFS can't call it if it's already gotten a transaction and an inode ILOCK. Unfortunately, we also can't check to see if the file actually requires modifications (zeroing contents, extendingi_size) until we've taken the ILOCK.Quoted 9 lines
If we really wanted to be strict about only stripping permissions if the file *actually* changed, we'd either have to re-design our setattr implementation to notice a running transaction and use it; or do a weird little dance where we lock the inode, check it, undo all that to call
file_modifiedif we decide it's necessary, and then create a new transaction and re-lock it. We'd also have to keep doing that until the file stabilizes, which seemed like a lot of work to handle something that's mostly a corner case, so XFS always callsfile_modifiedafter successfully flushing data to disk.Ah, I see.
So that also explains why XFS fails for this test:
#!/bin/bash
DEV=/dev/sdj
MNT=/mnt/sdjumount $DEV &>
/dev/null#mkfs.btrfs -f -b 1g $DEV #mkfs.ext4 -F -b 4096 $DEV $(((1024 * 1024 * 1024) / 4096)) #mkfs.f2fs -f -w 4096 $DEV $(((1024 * 1024 * 1024) / 4096)) mkfs.xfs -f -d size=1g $DEV mount $DEV $MNT # Create a file with a size of 600M and two holes, one at [200M, 201M[ # and another at [401M, 402M[ xfs_io -f -c "pwrite -S 0xab 0 200M" \ -c "pwrite -S 0xcd 201M 200M" \ -c "pwrite -S 0xef 402M 198M" \ $MNT/foobar# Now call fallocate against the whole file range, see if it fails
# with -ENOSPC or not - it shouldn't since we only need to allocate # 2M of data space. echo -e "\nCalling fallocate..." xfs_io -c "falloc 0 600M" $MNT/foobar
Quoted 7 lines
umount $MNT
The fallocate fails with
-ENOSPC, as it seems XFS tries to allocate 600M of space. So it seems that happens before taking the ILOCK, but it can only know for sure how much space it needs to allocate after taking that lock - I assume the space allocation can't happen after taking the ILOCK, due to some possible deadlock maybe?
Space *allocation* can only happen after taking the ILOCK, because that's the only way to stabilize the inode metadata. However, space *reservation* has to take place before taking the ILOCK, which creates an unfortunate chicken-egg problem.
fallocate /could/ operate in a more incremental fashion -- all we'd have to do is walk the specified range looking for holes in the mapping, and when we find one, we'd reserve space to fill that hole, lock everything, reread the mapping to see if it's still a hole, and if so, actually fill it. You'd race with someone punching holes, but fmeh to that usecase. :)
However, Dave has opined that fallocate shouldn't fail with ENOSPC halfway through the operation after consuming all of the free space in the filesystem:
https://lore.kernel.org/linux-xfs/[email protected]/
...and that's why it's better to try to reserve the entire amount requested and ENOSPC immediately, even if it were the case that the file isn't sparse at all.
I feel like this is one of those instances where the original model of what fallocate did was "preallocate space in this empty file range" whereas now it's shifted to include "(p)reallocate space in this heavily fragmented sparse VM image that someone called FITRIM on".
Either that or "preallocate space, but my cloud provider charges me by the gigabyte so I'm financially incentivized to fill the fs to 99% before leasing even one more megabyte and running growfs, and I don't understand why everything is freakishly slow and fragmented". :(
(I don't think that's your usecase, but <cough> I keep hearing things like that from the growing t****fire of customer escalations...)
--D
Quoted 42 lines
That test currently fails on btrfs as well, but I had just sent a patch to fix it:
We actually had at least one report about systemd using fallocate against a file range that has already allocated extents, so it could unnecessarily fail with
-ENOSPCif the fs free space is low (it's reported somewhere in the middle of the thread in the Link tag of the patch).Ext4 and f2fs pass the test.
I was turning the test case into a generic test for fstests, but then noticied XFS failing. Is this something you would consider fixing for XFS? Should I submit it as a generic test case, or as a btrfs specific test case?
Thanks for the explanation and the patch.
Quoted 23 lines
At that point XFS haven't even gotten to checking quota yet, so technically that's also a gap where we could drop privs but then fail the fallocate with EDQUOT.
--D
Quoted 16 lines
Thanks.
Quoted 13 lines
--D
Quoted 10 lines
Otherwise, it looks good.
Thanks for doing this, I had it on my todo list since I noticed the generic/673 failure with reflinks and the suid/sgid bits.
Quoted 4 lines
fs/btrfs/file.c +1
-0+/* * If ret is still 0, means we're OK to fallocate. * Or just cleanup the list and exit.
Quoted 218 lines · Darrick J. Wong
[add xfs list]
Quoted 207 lines · Filipe Manana
Quoted 166 lines · Darrick J. Wong
Quoted 81 lines · Filipe Manana
Quoted 80 lines · Darrick J. Wong
Quoted 78 lines · Filipe Manana
Quoted 65 lines · Darrick J. Wong
From: Darrick J. Wong <[email protected]>
Since the initial introduction of (posix) fallocate back at the turn of the century, it has been possible to use this syscall to change the user-visible contents of files. This can happen by extending the file size during a preallocation, or through any of the newer modes (punch, zero range). Because the call can be used to change file contents, we should treat it like we do any other modification to a file -- update the mtime, and drop set[ug]id privileges/capabilities.
The VFS function
file_modified()does all this for us if pass it a locked inode, so let's make fallocate drop permissions correctly.Signed-off-by Darrick J. Wong <[email protected]>---
Note: I plan to add fstests to test this behavior, but after the generic/673 mess, I'm holding back on them until I can fix the three major filesystems and clean up the xfssetattr_copycode.https://lore.kernel.org/linux-ext4/20220310174410.GB8172@magnolia/T/#u
--- fs/btrfs/file.c | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-)fs/btrfs/file.c +8
-2@@ -2918,8 +2918,9 @@ int btrfs_replace_file_extents(struct btrfs_inode *inode,return ret; } -static int btrfs_punch_hole (struct inode *inode,loff_t offset,loff_t len) +static int btrfs_punch_hole (struct file *file,loff_t offset,loff_t len) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =btrfs_sb (inode->i_sb);struct btrfs_root *root =BTRFS_I (inode)->root;struct extent_state *cached_state =NULL ;@@ -2951,6 +2952,10 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len) goto out_only_mutex; } + ret =file_modified (file); +if (ret) + goto out_only_mutex; + lockstart =round_up (offset,btrfs_inode_sectorsize (BTRFS_I (inode))); lockend =round_down (offset + len,btrfs_inode_sectorsize (BTRFS_I (inode))) -1 ;@@ -3177,11 +3182,12 @@ static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,return ret; } -static int btrfs_zero_range (struct inode *inode, +static int btrfs_zero_range (struct file *file,loff_t offset,loff_t len,const int mode) { +struct inode *inode =file_inode (file);struct btrfs_fs_info *fs_info =BTRFS_I (inode)->root->fs_info;struct extent_map *em;struct extent_changeset *data_reserved =NULL ;fs/btrfs/file.c static int btrfs_zero_range(struct inode *inode, · line 3216
Quoted 9 lines
fs/btrfs/file.c +6
-0@@ -3202,6 +3208,12 @@ static int btrfs_zero_range(struct inode *inode, goto out; } + ret =file_modified (file); +if (ret) { +free_extent_map (em); + goto out; + } +Could be done before getting the extent map, to make the code a bit shorter, or see the comment below.
Quoted 8 lines
Quoted 2 lines
The trouble is, if getting the extent map fails, we didn't change the file, so there's no reason to bump the timestamps and whatnot...
Right, I figured you had that sort of intention.
However after the call to
file_modified(), we may actually have not change the file at all, like when trying to zero a range that is already fully covered by a preallocated extent.<nod> At least in XFSland, there's no good way to check for a pre-existing prealloc extent without holding the ILOCK, which makes things complicated as I'll explain below. :)
Quoted 34 lines
Quoted 34 lines
Quoted 33 lines
Quoted 24 lines
fs/btrfs/file.c +2
-2/* * Avoid hole punching and extent allocation for some cases. More cases * could be considered, but these are unlikely common and we keep things @@ -3391,7 +3403,7 @@ static long btrfs_fallocate(struct file *file, int mode,return -EOPNOTSUPP ;if (mode &FALLOC_FL_PUNCH_HOLE ) -return btrfs_punch_hole (inode, offset, len); +return btrfs_punch_hole (file, offset, len);/* * Only trigger disk allocation, don't trigger qgroup reserve @@ -3446,7 +3458,7 @@ static long btrfs_fallocate(struct file *file, int mode, goto out;if (mode &FALLOC_FL_ZERO_RANGE ) { - ret =btrfs_zero_range (inode, offset, len, mode); + ret =btrfs_zero_range (file, offset, len, mode);btrfs_inode_unlock (inode,BTRFS_ILOCK_MMAP );return ret; }fs/btrfs/file.c static long btrfs_fallocate(struct file *file, int mode, · line 3544
Quoted 5 lines
fs/btrfs/file.c +2
-0@@ -3528,6 +3540,9 @@ static long btrfs_fallocate(struct file *file, int mode, cur_offset = last_byte; } +if (!ret) + ret =file_modified (file);If call
file_modified()before the if that checks for the zero range case, then we avoid having to callfile_modified()atbtrfs_zero_range()too, and get the behaviour for both plain fallocate and zero range.Quoted 7 lines
Quoted 3 lines
...and the reason I put it here is to make sure the ordered IO finishes ok and that we pass the quota limit checks before we start modifying things.
Ok, but before that point we may already have modified the file, through a call to either
btrfs_cont_expand()orbtrfs_truncate_block()above, to zero out part of the content of a page.Ahh, ok. My goal was to eliminate the places where we don't call
file_modified, even if that comes at the cost of occasionally doing it when it wasn't strictly necessary.Quoted 5 lines
So if we did that, and we got an error when waiting for ordered extents or from the qgroup reservation, we end up leaving fallocate without calling
file_modified(), despite having modified the file.Quoted 1 line
Quoted 8 lines
Quoted 3 lines
That said -- you all know btrfs far better than I do, so if you'd rather I put these calls further up (probably right after the
inode_newsize_okcheck?) then I'm happy to do that. :)Technically I suppose we should only call
file_modified()if we actually change anything in the file, but as it is, we are calling it even when we don't end up modifying it or in some cases not calling it when we modify it.Yep.
Quoted 2 lines
How does xfs behaves in this respect? Does it call
file_modified()only if something in the file actually changed?
file_modifiedcalls back into the filesystem to run transactions to update metadata, which means that XFS can't call it if it's already gotten a transaction and an inode ILOCK. Unfortunately, we also can't check to see if the file actually requires modifications (zeroing contents, extendingi_size) until we've taken the ILOCK.Quoted 9 lines
If we really wanted to be strict about only stripping permissions if the file *actually* changed, we'd either have to re-design our setattr implementation to notice a running transaction and use it; or do a weird little dance where we lock the inode, check it, undo all that to call
file_modifiedif we decide it's necessary, and then create a new transaction and re-lock it. We'd also have to keep doing that until the file stabilizes, which seemed like a lot of work to handle something that's mostly a corner case, so XFS always callsfile_modifiedafter successfully flushing data to disk.Ah, I see.
So that also explains why XFS fails for this test:
#!/bin/bash
DEV=/dev/sdj
MNT=/mnt/sdjumount $DEV &>
/dev/null#mkfs.btrfs -f -b 1g $DEV #mkfs.ext4 -F -b 4096 $DEV $(((1024 * 1024 * 1024) / 4096)) #mkfs.f2fs -f -w 4096 $DEV $(((1024 * 1024 * 1024) / 4096)) mkfs.xfs -f -d size=1g $DEV mount $DEV $MNT # Create a file with a size of 600M and two holes, one at [200M, 201M[ # and another at [401M, 402M[ xfs_io -f -c "pwrite -S 0xab 0 200M" \ -c "pwrite -S 0xcd 201M 200M" \ -c "pwrite -S 0xef 402M 198M" \ $MNT/foobar# Now call fallocate against the whole file range, see if it fails
# with -ENOSPC or not - it shouldn't since we only need to allocate # 2M of data space. echo -e "\nCalling fallocate..." xfs_io -c "falloc 0 600M" $MNT/foobarQuoted 7 lines
umount $MNT
The fallocate fails with
-ENOSPC, as it seems XFS tries to allocate 600M of space. So it seems that happens before taking the ILOCK, but it can only know for sure how much space it needs to allocate after taking that lock - I assume the space allocation can't happen after taking the ILOCK, due to some possible deadlock maybe?
Quoted 4 lines
Space *allocation* can only happen after taking the ILOCK, because that's the only way to stabilize the inode metadata. However, space *reservation* has to take place before taking the ILOCK, which creates an unfortunate chicken-egg problem.
I see. On btrfs we currently reserve space for the entire range before we do all the necessary locking, because in the past we could deadlock if we reserved the space after doing all the necessary locking - this was due to races with mmap writes and direct IO writes within the EOF boundary - but we don't have those races anymore, which enables us now to do that change.
Then after doing all the locking, we iterate over the file range to find out where we have holes and then allocate an extent for each hole. This should never fail with -ENOSPC because we have previously reserved an amount of space that covers the worst possible case (the entire range is a hole).
If the sum of the size of the allocated extents ends up being less than what we reserved upfront, we then release the excess space.
During this phase where we iterate over the list of extents in the file range, we are protected from concurrent operations that can change the extent layout (other fallocates, hole punching, truncate, all types of writes, etc).
Quoted 12 lines
fallocate /could/ operate in a more incremental fashion -- all we'd have to do is walk the specified range looking for holes in the mapping, and when we find one, we'd reserve space to fill that hole, lock everything, reread the mapping to see if it's still a hole, and if so, actually fill it. You'd race with someone punching holes, but fmeh to that usecase. :)
However, Dave has opined that fallocate shouldn't fail with ENOSPC halfway through the operation after consuming all of the free space in the filesystem:
Quoted 5 lines
https://lore.kernel.org/linux-xfs/[email protected]/
...and that's why it's better to try to reserve the entire amount requested and ENOSPC immediately, even if it were the case that the file isn't sparse at all.
I see.
So this seems to be a bit controversial. Avoiding the "false -ENOSPC from a user's perspective" may not be easy to implement depending on the specific filesystem implementation.
So I suppose for now I should make the test btrfs specific.
Thanks, that was useful and interesting.
Quoted 58 lines
I feel like this is one of those instances where the original model of what fallocate did was "preallocate space in this empty file range" whereas now it's shifted to include "(p)reallocate space in this heavily fragmented sparse VM image that someone called FITRIM on".
Either that or "preallocate space, but my cloud provider charges me by the gigabyte so I'm financially incentivized to fill the fs to 99% before leasing even one more megabyte and running growfs, and I don't understand why everything is freakishly slow and fragmented". :(
(I don't think that's your usecase, but <cough> I keep hearing things like that from the growing t****fire of customer escalations...)
--D
Quoted 42 lines
That test currently fails on btrfs as well, but I had just sent a patch to fix it:
We actually had at least one report about systemd using fallocate against a file range that has already allocated extents, so it could unnecessarily fail with
-ENOSPCif the fs free space is low (it's reported somewhere in the middle of the thread in the Link tag of the patch).Ext4 and f2fs pass the test.
I was turning the test case into a generic test for fstests, but then noticied XFS failing. Is this something you would consider fixing for XFS? Should I submit it as a generic test case, or as a btrfs specific test case?
Thanks for the explanation and the patch.
Quoted 23 lines
At that point XFS haven't even gotten to checking quota yet, so technically that's also a gap where we could drop privs but then fail the fallocate with EDQUOT.
--D
Quoted 16 lines
Thanks.
Quoted 13 lines
--D
Quoted 10 lines
Otherwise, it looks good.
Thanks for doing this, I had it on my todo list since I noticed the generic/673 failure with reflinks and the suid/sgid bits.
Quoted 4 lines
fs/btrfs/file.c +1
-0+/* * If ret is still 0, means we're OK to fallocate. * Or just cleanup the list and exit.