sort out the fallocate mode mess
Subsystems (5)
Hi all,
I've recently been looking at the XFS fallocate implementation and got upset about the messing parsing of the mode argument, which mixes modes and an optional flag in a really confusing way.
This series tries to clean this up by better defining what is the operation mode and what is an optional flag, so that both the core code and file systems can use switch statements to switch on the mode.
PATCH 1/6 block: remove checks for FALLOC_FL_NO_HIDE_STALE
While the FALLOC_FL_NO_HIDE_STALE value has been registered, it has always been rejected by vfs_fallocate before making it into blkdev_fallocate because it isn't in the supported mask.
--- block/fops.c | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-)
block/fops.c +1 -9
@@ -771,7 +771,7 @@ static ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to)#define BLKDEV_FALLOC_FL_SUPPORTED \ (FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE | \ - FALLOC_FL_ZERO_RANGE | FALLOC_FL_NO_HIDE_STALE) + FALLOC_FL_ZERO_RANGE)static long blkdev_fallocate (struct file *file,int mode,loff_t start,loff_t len)
@@ -830,14 +830,6 @@ static long blkdev_fallocate(struct file *file, int mode, loff_t start, len >>SECTOR_SHIFT ,GFP_KERNEL , BLKDEV_ZERO_NOFALLBACK);break ; -case FALLOC_FL_PUNCH_HOLE |FALLOC_FL_KEEP_SIZE |FALLOC_FL_NO_HIDE_STALE : - error =truncate_bdev_range (bdev,file_to_blk_mode (file), start, end); -if (error) - goto fail; - - error =blkdev_issue_discard (bdev, start >>SECTOR_SHIFT , - len >>SECTOR_SHIFT ,GFP_KERNEL ); -break ;default : error = -EOPNOTSUPP ; }
Signature · 1 line
2.43.0
PATCH 2/6 ext4: remove tracing for FALLOC_FL_NO_HIDE_STALE
In reply to Christoph HellwigFALLOC_FL_NO_HIDE_STALE can't make it past vfs_fallocate (and if the flag does what the name implies that's a good thing as it would be highly dangerous). Remove the dead tracing code for it.
--- include/trace/events/ext4.h | 1 - 1 file changed, 1 deletion(-)
include/trace/events/ext4.h +0 -1
@@ -91,7 +91,6 @@ TRACE_DEFINE_ENUM(ES_REFERENCED_B);#define show_falloc_mode (mode) __print_flags(mode, "|", \ { FALLOC_FL_KEEP_SIZE, "KEEP_SIZE"}, \ { FALLOC_FL_PUNCH_HOLE, "PUNCH_HOLE"}, \ - { FALLOC_FL_NO_HIDE_STALE, "NO_HIDE_STALE"}, \ { FALLOC_FL_COLLAPSE_RANGE, "COLLAPSE_RANGE"}, \ { FALLOC_FL_ZERO_RANGE, "ZERO_RANGE"})
Signature · 1 line
2.43.0
PATCH 3/6 fs: sort out the fallocate mode vs flag mess
In reply to Christoph HellwigThe fallocate system call takes a mode argument, but that argument contains a wild mix of exclusive modes and an optional flags.
Replace FALLOC_FL_SUPPORTED_MASK with FALLOC_FL_MODE_MASK, which excludes the optional flag bit, so that we can use switch statement on the value to easily enumerate the cases while getting the check for duplicate modes for free.
To make this (and in the future the file system implementations) more readable also add a symbolic name for the 0 mode used to allocate blocks.
--- fs/open.c | 53 ++++++++++++++++++------------------- include/linux/falloc.h | 18 ++++++++----- include/uapi/linux/falloc.h | 1 + 3 files changed, 39 insertions(+), 33 deletions(-)
fs/open.c +26 -27
@@ -252,42 +252,41 @@ int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)if (offset <0 || len <=0 )return -EINVAL ; -/* Return error if mode is not supported */ -if (mode & ~FALLOC_FL_SUPPORTED_MASK ) +if (mode & ~(FALLOC_FL_MODE_MASK |FALLOC_FL_KEEP_SIZE ))return -EOPNOTSUPP ; -/* Punch hole and zero range are mutually exclusive */ -if ((mode & (FALLOC_FL_PUNCH_HOLE |FALLOC_FL_ZERO_RANGE )) == - (FALLOC_FL_PUNCH_HOLE |FALLOC_FL_ZERO_RANGE )) -return -EOPNOTSUPP ; - -/* Punch hole must have keep size set */ -if ((mode &FALLOC_FL_PUNCH_HOLE ) && - !(mode &FALLOC_FL_KEEP_SIZE )) +/* +* Modes are exclusive, even if that is not obvious from the encoding +* as bit masks and the mix with the flag in the same namespace. +* +* To make things even more complicated, FALLOC_FL_ALLOCATE_RANGE is +* encoded as no bit set. +*/ +switch (mode &FALLOC_FL_MODE_MASK ) { +case FALLOC_FL_ALLOCATE_RANGE : +case FALLOC_FL_UNSHARE_RANGE : +case FALLOC_FL_ZERO_RANGE : +break ; +case FALLOC_FL_PUNCH_HOLE : +if (!(mode &FALLOC_FL_KEEP_SIZE )) +return -EOPNOTSUPP ; +break ; +case FALLOC_FL_COLLAPSE_RANGE : +case FALLOC_FL_INSERT_RANGE : +if (mode &FALLOC_FL_KEEP_SIZE ) +return -EOPNOTSUPP ; +break ; +default :return -EOPNOTSUPP ; - -/* Collapse range should only be used exclusively. */ -if ((mode &FALLOC_FL_COLLAPSE_RANGE ) && - (mode & ~FALLOC_FL_COLLAPSE_RANGE )) -return -EINVAL ; - -/* Insert range should only be used exclusively. */ -if ((mode &FALLOC_FL_INSERT_RANGE ) && - (mode & ~FALLOC_FL_INSERT_RANGE )) -return -EINVAL ; - -/* Unshare range should only be used with allocate mode. */ -if ((mode &FALLOC_FL_UNSHARE_RANGE ) && - (mode & ~(FALLOC_FL_UNSHARE_RANGE |FALLOC_FL_KEEP_SIZE ))) -return -EINVAL ; + }if (!(file->f_mode &FMODE_WRITE ))return -EBADF ;/* -* We can only allow pure fallocate on append only files +* We can only allow pure space allocation on append only files. */ -if ((mode & ~FALLOC_FL_KEEP_SIZE ) &&IS_APPEND (inode)) +if (mode !=FALLOC_FL_ALLOCATE_RANGE &&IS_APPEND (inode))return -EPERM ;if (IS_IMMUTABLE (inode))
include/linux/falloc.h +12 -6
@@ -25,12 +25,18 @@ struct space_resv {#define FS_IOC_UNRESVSP64 _IOW('X', 43, struct space_resv)#define FS_IOC_ZERO_RANGE _IOW('X', 57, struct space_resv) -#define FALLOC_FL_SUPPORTED_MASK (FALLOC_FL_KEEP_SIZE | \ - FALLOC_FL_PUNCH_HOLE | \ - FALLOC_FL_COLLAPSE_RANGE | \ - FALLOC_FL_ZERO_RANGE | \ - FALLOC_FL_INSERT_RANGE | \ - FALLOC_FL_UNSHARE_RANGE) +/* +* Mask of all supported fallocate modes. Only one can be set at a time. +* +* In addition to the mode bit, the mode argument can also encode flags. +* FALLOC_FL_KEEP_SIZE is the only supported flag so far. +*/ +#define FALLOC_FL_MODE_MASK (FALLOC_FL_ALLOCATE_RANGE | \ + FALLOC_FL_PUNCH_HOLE | \ + FALLOC_FL_COLLAPSE_RANGE | \ + FALLOC_FL_ZERO_RANGE | \ + FALLOC_FL_INSERT_RANGE | \ + FALLOC_FL_UNSHARE_RANGE)/* on ia32 l_start is on a 32-bit boundary */ #if defined(CONFIG_X86_64 )
include/uapi/linux/falloc.h +1 -0
@@ -2,6 +2,7 @@#ifndef _UAPI_FALLOC_H_#define _UAPI_FALLOC_H_ +#define FALLOC_FL_ALLOCATE_RANGE 0x00/* allocate range */ #define FALLOC_FL_KEEP_SIZE 0x01/* default is extend size */ #define FALLOC_FL_PUNCH_HOLE 0x02/* de-allocates range */ #define FALLOC_FL_NO_HIDE_STALE 0x04/* reserved codepoint */
Signature · 1 line
2.43.0
Re: [PATCH 3/6] fs: sort out the fallocate mode vs flag mess
Quoted 79 lines · Christoph Hellwig
The fallocate system call takes a mode argument, but that argument contains a wild mix of exclusive modes and an optional flags.
Replace
FALLOC_FL_SUPPORTED_MASKwithFALLOC_FL_MODE_MASK, which excludes the optional flag bit, so that we can use switch statement on the value to easily enumerate the cases while getting the check for duplicate modes for free.To make this (and in the future the file system implementations) more readable also add a symbolic name for the 0 mode used to allocate blocks.
Signed-off-by Christoph Hellwig <[email protected]>--- fs/open.c | 53 ++++++++++++++++++------------------- include/linux/falloc.h | 18 ++++++++----- include/uapi/linux/falloc.h | 1 + 3 files changed, 39 insertions(+), 33 deletions(-)fs/open.c +24
-25@@ -252,42 +252,41 @@ int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)if (offset <0 || len <=0 )return -EINVAL ; -/* Return error if mode is not supported */ -if (mode & ~FALLOC_FL_SUPPORTED_MASK ) +if (mode & ~(FALLOC_FL_MODE_MASK |FALLOC_FL_KEEP_SIZE ))return -EOPNOTSUPP ; -/* Punch hole and zero range are mutually exclusive */ -if ((mode & (FALLOC_FL_PUNCH_HOLE |FALLOC_FL_ZERO_RANGE )) == - (FALLOC_FL_PUNCH_HOLE |FALLOC_FL_ZERO_RANGE )) -return -EOPNOTSUPP ; - -/* Punch hole must have keep size set */ -if ((mode &FALLOC_FL_PUNCH_HOLE ) && - !(mode &FALLOC_FL_KEEP_SIZE )) +/* +* Modes are exclusive, even if that is not obvious from the encoding +* as bit masks and the mix with the flag in the same namespace. +* +* To make things even more complicated, FALLOC_FL_ALLOCATE_RANGE is +* encoded as no bit set. +*/ +switch (mode &FALLOC_FL_MODE_MASK ) { +case FALLOC_FL_ALLOCATE_RANGE : +case FALLOC_FL_UNSHARE_RANGE : +case FALLOC_FL_ZERO_RANGE : +break ; +case FALLOC_FL_PUNCH_HOLE : +if (!(mode &FALLOC_FL_KEEP_SIZE )) +return -EOPNOTSUPP ; +break ; +case FALLOC_FL_COLLAPSE_RANGE : +case FALLOC_FL_INSERT_RANGE : +if (mode &FALLOC_FL_KEEP_SIZE ) +return -EOPNOTSUPP ; +break ; +default :return -EOPNOTSUPP ; - -/* Collapse range should only be used exclusively. */ -if ((mode &FALLOC_FL_COLLAPSE_RANGE ) && - (mode & ~FALLOC_FL_COLLAPSE_RANGE )) -return -EINVAL ; - -/* Insert range should only be used exclusively. */ -if ((mode &FALLOC_FL_INSERT_RANGE ) && - (mode & ~FALLOC_FL_INSERT_RANGE )) -return -EINVAL ; - -/* Unshare range should only be used with allocate mode. */ -if ((mode &FALLOC_FL_UNSHARE_RANGE ) && - (mode & ~(FALLOC_FL_UNSHARE_RANGE |FALLOC_FL_KEEP_SIZE ))) -return -EINVAL ; + }
fs/open.c int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len) · line 290
Quoted 10 lines
fs/open.c +2
-2if (!(file->f_mode &FMODE_WRITE ))return -EBADF ;/* -* We can only allow pure fallocate on append only files +* We can only allow pure space allocation on append only files. */ -if ((mode & ~FALLOC_FL_KEEP_SIZE ) &&IS_APPEND (inode)) +if (mode !=FALLOC_FL_ALLOCATE_RANGE &&IS_APPEND (inode))return -EPERM ;
Unless I'm misreading, this changes semantics by enforcing that we cannot use KEEP_SIZE on append only files. That means one can no longer do a post-eof prealloc without actually changing the file size, which on a quick test seems to work today.
That aside, this all looks like a nice cleanup to me.
Brian
Quoted 47 lines
fs/open.c +0
-0if (IS_IMMUTABLE (inode))include/linux/falloc.h +12
-6@@ -25,12 +25,18 @@ struct space_resv {#define FS_IOC_UNRESVSP64 _IOW('X', 43, struct space_resv)#define FS_IOC_ZERO_RANGE _IOW('X', 57, struct space_resv) -#define FALLOC_FL_SUPPORTED_MASK (FALLOC_FL_KEEP_SIZE | \ - FALLOC_FL_PUNCH_HOLE | \ - FALLOC_FL_COLLAPSE_RANGE | \ - FALLOC_FL_ZERO_RANGE | \ - FALLOC_FL_INSERT_RANGE | \ - FALLOC_FL_UNSHARE_RANGE) +/* +* Mask of all supported fallocate modes. Only one can be set at a time. +* +* In addition to the mode bit, the mode argument can also encode flags. +* FALLOC_FL_KEEP_SIZE is the only supported flag so far. +*/ +#define FALLOC_FL_MODE_MASK (FALLOC_FL_ALLOCATE_RANGE | \ + FALLOC_FL_PUNCH_HOLE | \ + FALLOC_FL_COLLAPSE_RANGE | \ + FALLOC_FL_ZERO_RANGE | \ + FALLOC_FL_INSERT_RANGE | \ + FALLOC_FL_UNSHARE_RANGE)/* on ia32 l_start is on a 32-bit boundary */ #if defined(CONFIG_X86_64 )include/uapi/linux/falloc.h +1
-0@@ -2,6 +2,7 @@#ifndef _UAPI_FALLOC_H_#define _UAPI_FALLOC_H_ +#define FALLOC_FL_ALLOCATE_RANGE 0x00/* allocate range */ #define FALLOC_FL_KEEP_SIZE 0x01/* default is extend size */ #define FALLOC_FL_PUNCH_HOLE 0x02/* de-allocates range */ #define FALLOC_FL_NO_HIDE_STALE 0x04/* reserved codepoint */ Signature · 1 line
2.43.0
Re: [PATCH 3/6] fs: sort out the fallocate mode vs flag mess
Quoted 8 lines · Brian Foster
fs/open.c int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len) · line 290
Quoted 3 lines
fs/open.c +1
-1-if ((mode & ~FALLOC_FL_KEEP_SIZE ) &&IS_APPEND (inode)) +if (mode !=FALLOC_FL_ALLOCATE_RANGE &&IS_APPEND (inode))return -EPERM ;Unless I'm misreading, this changes semantics by enforcing that we cannot use
KEEP_SIZEon append only files. That means one can no longer do a post-eof prealloc without actually changing the file size, which on a quick test seems to work today.
No, I think it was me misreading the old code. And I'm a little worried that no test cought it.
PATCH 4/6 xfs: call xfs_flush_unmap_range from xfs_free_file_space
In reply to Christoph HellwigCall xfs_flush_unmap_range from xfs_free_file_space so that xfs_file_fallocate doesn't have to predict which mode will call it.
--- fs/xfs/xfs_bmap_util.c | 8 ++++++++ fs/xfs/xfs_file.c | 21 --------------------- 2 files changed, 8 insertions(+), 21 deletions(-)
fs/xfs/xfs_bmap_util.c +8 -0
@@ -848,6 +848,14 @@ xfs_free_file_space(if (len <=0 )/* if nothing being freed */ return 0 ; +/* +* Now AIO and DIO has drained we flush and (if necessary) invalidate +* the cached range over the first operation we are about to run. +*/ + error =xfs_flush_unmap_range (ip, offset, len); +if (error) +return error; + startoffset_fsb =XFS_B_TO_FSB (mp, offset); endoffset_fsb =XFS_B_TO_FSBT (mp, offset + len);
fs/xfs/xfs_file.c +0 -21
@@ -890,27 +890,6 @@ xfs_file_fallocate(*/ inode_dio_wait (inode); -/* -* Now AIO and DIO has drained we flush and (if necessary) invalidate -* the cached range over the first operation we are about to run. -* -* We care about zero and collapse here because they both run a hole -* punch over the range first. Because that can zero data, and the range -* of invalidation for the shift operations is much larger, we still do -* the required flush for collapse in xfs_prepare_shift(). -* -* Insert has the same range requirements as collapse, and we extend the -* file first which can zero data. Hence insert has the same -* flush/invalidate requirements as collapse and so they are both -* handled at the right time by xfs_prepare_shift(). -*/ -if (mode & (FALLOC_FL_PUNCH_HOLE |FALLOC_FL_ZERO_RANGE | -FALLOC_FL_COLLAPSE_RANGE )) { - error =xfs_flush_unmap_range (ip, offset, len); -if (error) - goto out_unlock; - } - error =file_modified (file);if (error) goto out_unlock;
Signature · 1 line
2.43.0
PATCH 5/6 xfs: move the xfs_is_always_cow_inode check into xfs_alloc_file_space
In reply to Christoph HellwigMove the xfs_is_always_cow_inode check from the caller into xfs_alloc_file_space to prepare for refactoring of xfs_file_fallocate.
--- fs/xfs/xfs_bmap_util.c | 3 +++ fs/xfs/xfs_file.c | 8 +++----- 2 files changed, 6 insertions(+), 5 deletions(-)
fs/xfs/xfs_bmap_util.c +3 -0
@@ -653,6 +653,9 @@ xfs_alloc_file_space(xfs_bmbt_irec_t imaps[1 ], *imapp;int error; +if (xfs_is_always_cow_inode (ip)) +return 0 ; +trace_xfs_alloc_file_space (ip);if (xfs_is_shutdown (mp))
fs/xfs/xfs_file.c +3 -5
@@ -987,11 +987,9 @@ xfs_file_fallocate( } } -if (!xfs_is_always_cow_inode (ip)) { - error =xfs_alloc_file_space (ip, offset, len); -if (error) - goto out_unlock; - } + error =xfs_alloc_file_space (ip, offset, len); +if (error) + goto out_unlock; }/* Change file size if needed */
Signature · 1 line
2.43.0
PATCH 6/6 xfs: refactor xfs_file_fallocate
In reply to Christoph HellwigRefactor xfs_file_fallocate into separate helpers for each mode, two factors for i_size handling and a single switch statement over the supported modes.
--- fs/xfs/xfs_file.c | 327 +++++++++++++++++++++++++++++----------------- 1 file changed, 205 insertions(+), 122 deletions(-)
fs/xfs/xfs_file.c +205 -122
@@ -852,6 +852,189 @@ static inline bool xfs_file_sync_writes(struct file *filp)return false; } +static int +xfs_falloc_newsize ( +struct file *file, +int mode, +loff_t offset, +loff_t len, +loff_t *new_size) +{ +struct inode *inode =file_inode (file); + +if ((mode &FALLOC_FL_KEEP_SIZE ) || offset + len <=i_size_read (inode)) +return 0 ; + *new_size = offset + len; +return inode_newsize_ok (inode, *new_size); +} + +static int +xfs_falloc_setsize ( +struct file *file, +loff_t new_size) +{ +struct iattr iattr = { + .ia_valid =ATTR_SIZE , + .ia_size = new_size, + }; + +if (!new_size) +return 0 ; +return xfs_vn_setattr_size (file_mnt_idmap (file),file_dentry (file), + &iattr); +} + +static int +xfs_falloc_collapse_range ( +struct file *file, +loff_t offset, +loff_t len) +{ +struct inode *inode =file_inode (file); +loff_t new_size =i_size_read (inode) - len; +int error; + +if (!xfs_is_falloc_aligned (XFS_I (inode), offset, len)) +return -EINVAL ; + +/* +* There is no need to overlap collapse range with EOF, in which case it +* is effectively a truncate operation +*/ +if (offset + len >=i_size_read (inode)) +return -EINVAL ; + + error =xfs_collapse_file_space (XFS_I (inode), offset, len); +if (error) +return error; +return xfs_falloc_setsize (file, new_size); +} + +static int +xfs_falloc_insert_range ( +struct file *file, +loff_t offset, +loff_t len) +{ +struct inode *inode =file_inode (file); +loff_t isize =i_size_read (inode); +int error; + +if (!xfs_is_falloc_aligned (XFS_I (inode), offset, len)) +return -EINVAL ; + +/* +* New inode size must not exceed ->s_maxbytes, accounting for +* possible signed overflow. +*/ +if (inode->i_sb->s_maxbytes - isize < len) +return -EFBIG ; + +/* Offset should be less than i_size */ +if (offset >= isize) +return -EINVAL ; + + error =xfs_falloc_setsize (file, isize + len); +if (error) +return error; + +/* +* Perform hole insertion now that the file size has been updated so +* that if we crash during the operation we don't leave shifted extents +* past EOF and hence losing access to the data that is contained within +* them. +*/ +return xfs_insert_file_space (XFS_I (inode), offset, len); +} + +/* +* Punch a hole and prealloc the range. We use a hole punch rather than +* unwritten extent conversion for two reasons: +* +* 1.) Hole punch handles partial block zeroing for us. +* 2.) If prealloc returns ENOSPC, the file range is still zero-valued by +* virtue of the hole punch. +*/ +static int +xfs_falloc_zero_range ( +struct file *file, +int mode, +loff_t offset, +loff_t len) +{ +struct inode *inode =file_inode (file); +unsigned int blksize =i_blocksize (inode); +loff_t new_size =0 ; +int error; + +trace_xfs_zero_file_space (XFS_I (inode)); + + error =xfs_falloc_newsize (file, mode, offset, len, &new_size); +if (error) +return error; + + error =xfs_free_file_space (XFS_I (inode), offset, len); +if (error) +return error; + + len =round_up (offset + len, blksize) -round_down (offset, blksize); + offset =round_down (offset, blksize); + error =xfs_alloc_file_space (XFS_I (inode), offset, len); +if (error) +return error; +return xfs_falloc_setsize (file, new_size); +} + +static int +xfs_falloc_unshare_range ( +struct file *file, +int mode, +loff_t offset, +loff_t len) +{ +struct inode *inode =file_inode (file); +loff_t new_size =0 ; +int error; + + error =xfs_falloc_newsize (file, mode, offset, len, &new_size); +if (error) +return error; + + error =xfs_reflink_unshare (XFS_I (inode), offset, len); +if (error) +return error; + +return xfs_falloc_setsize (file, new_size); +} + +static int +xfs_falloc_allocate_range ( +struct file *file, +int mode, +loff_t offset, +loff_t len) +{ +struct inode *inode =file_inode (file); +loff_t new_size =0 ; +int error; + +/* +* If always_cow mode we can't use preallocations and thus should not +* create them. +*/ +if (xfs_is_always_cow_inode (XFS_I (inode))) +return -EOPNOTSUPP ; + + error =xfs_falloc_newsize (file, mode, offset, len, &new_size); +if (error) +return error; + + error =xfs_alloc_file_space (XFS_I (inode), offset, len); +if (error) +return error; +return xfs_falloc_setsize (file, new_size); +} +#define XFS_FALLOC_FL_SUPPORTED \ (FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE | \ FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE | \
@@ -868,8 +1051,6 @@ xfs_file_fallocate(struct xfs_inode *ip =XFS_I (inode);long error;uint iolock =XFS_IOLOCK_EXCL |XFS_MMAPLOCK_EXCL ; -loff_t new_size =0 ; -bool do_file_insert = false;if (!S_ISREG (inode->i_mode))return -EINVAL ;
@@ -894,129 +1075,31 @@ xfs_file_fallocate(if (error) goto out_unlock; -if (mode &FALLOC_FL_PUNCH_HOLE ) { +switch (mode &FALLOC_FL_MODE_MASK ) { +case FALLOC_FL_PUNCH_HOLE : error =xfs_free_file_space (ip, offset, len); -if (error) - goto out_unlock; - }else if (mode &FALLOC_FL_COLLAPSE_RANGE ) { -if (!xfs_is_falloc_aligned (ip, offset, len)) { - error = -EINVAL ; - goto out_unlock; - } - -/* -* There is no need to overlap collapse range with EOF, -* in which case it is effectively a truncate operation -*/ -if (offset + len >=i_size_read (inode)) { - error = -EINVAL ; - goto out_unlock; - } - - new_size =i_size_read (inode) - len; - - error =xfs_collapse_file_space (ip, offset, len); -if (error) - goto out_unlock; - }else if (mode &FALLOC_FL_INSERT_RANGE ) { -loff_t isize =i_size_read (inode); - -if (!xfs_is_falloc_aligned (ip, offset, len)) { - error = -EINVAL ; - goto out_unlock; - } - -/* -* New inode size must not exceed ->s_maxbytes, accounting for -* possible signed overflow. -*/ -if (inode->i_sb->s_maxbytes - isize < len) { - error = -EFBIG ; - goto out_unlock; - } - new_size = isize + len; - -/* Offset should be less than i_size */ -if (offset >= isize) { - error = -EINVAL ; - goto out_unlock; - } - do_file_insert = true; - }else { -if (!(mode &FALLOC_FL_KEEP_SIZE ) && - offset + len >i_size_read (inode)) { - new_size = offset + len; - error =inode_newsize_ok (inode, new_size); -if (error) - goto out_unlock; - } - -if (mode &FALLOC_FL_ZERO_RANGE ) { -/* -* Punch a hole and prealloc the range. We use a hole -* punch rather than unwritten extent conversion for two -* reasons: -* -* 1.) Hole punch handles partial block zeroing for us. -* 2.) If prealloc returns ENOSPC, the file range is -* still zero-valued by virtue of the hole punch. -*/ -unsigned int blksize =i_blocksize (inode); - -trace_xfs_zero_file_space (ip); - - error =xfs_free_file_space (ip, offset, len); -if (error) - goto out_unlock; - - len =round_up (offset + len, blksize) - -round_down (offset, blksize); - offset =round_down (offset, blksize); - }else if (mode &FALLOC_FL_UNSHARE_RANGE ) { - error =xfs_reflink_unshare (ip, offset, len); -if (error) - goto out_unlock; - }else { -/* -* If always_cow mode we can't use preallocations and -* thus should not create them. -*/ -if (xfs_is_always_cow_inode (ip)) { - error = -EOPNOTSUPP ; - goto out_unlock; - } - } - - error =xfs_alloc_file_space (ip, offset, len); -if (error) - goto out_unlock; - } - -/* Change file size if needed */ -if (new_size) { -struct iattr iattr; - - iattr.ia_valid =ATTR_SIZE ; - iattr.ia_size = new_size; - error =xfs_vn_setattr_size (file_mnt_idmap (file), -file_dentry (file), &iattr); -if (error) - goto out_unlock; - } - -/* -* Perform hole insertion now that the file size has been -* updated so that if we crash during the operation we don't -* leave shifted extents past EOF and hence losing access to -* the data that is contained within them. -*/ -if (do_file_insert) { - error =xfs_insert_file_space (ip, offset, len); -if (error) - goto out_unlock; +break ; +case FALLOC_FL_COLLAPSE_RANGE : + error =xfs_falloc_collapse_range (file, offset, len); +break ; +case FALLOC_FL_INSERT_RANGE : + error =xfs_falloc_insert_range (file, offset, len); +break ; +case FALLOC_FL_ZERO_RANGE : + error =xfs_falloc_zero_range (file, mode, offset, len); +break ; +case FALLOC_FL_UNSHARE_RANGE : + error =xfs_falloc_unshare_range (file, mode, offset, len); +break ; +case FALLOC_FL_ALLOCATE_RANGE : + error =xfs_falloc_allocate_range (file, mode, offset, len); +break ; +default : + error = -EOPNOTSUPP ; +break ; } -if (xfs_file_sync_writes (file)) +if (!error &&xfs_file_sync_writes (file)) error =xfs_log_force_inode (ip); out_unlock:
Signature · 1 line
2.43.0
Re: [PATCH 6/6] xfs: refactor xfs_file_fallocate
Quoted 17 lines · Christoph Hellwig
Refactor
xfs_file_fallocateinto separate helpers for each mode, two factors fori_sizehandling and a single switch statement over the supported modes.Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_file.c | 327 +++++++++++++++++++++++++++++----------------- 1 file changed, 205 insertions(+), 122 deletions(-)fs/xfs/xfs_file.c +0
-0@@ -852,6 +852,189 @@ static inline bool xfs_file_sync_writes(struct file *filp)return false; }
...
Quoted 10 lines
fs/xfs/xfs_file.c +10
-0+ +static int +xfs_falloc_unshare_range ( +struct file *file, +int mode, +loff_t offset, +loff_t len) +{ +struct inode *inode =file_inode (file); +loff_t new_size =0 ;
fs/xfs/xfs_file.c static inline bool xfs_file_sync_writes(struct file *filp) · line 1006
Quoted 10 lines
fs/xfs/xfs_file.c +10
-0+int error; + + error =xfs_falloc_newsize (file, mode, offset, len, &new_size); +if (error) +return error; + + error =xfs_reflink_unshare (XFS_I (inode), offset, len); +if (error) +return error; +
Doesn't unshare imply alloc?
Quoted 3 lines
fs/xfs/xfs_file.c +3
-0+return xfs_falloc_setsize (file, new_size); +} +
...
Quoted 8 lines
fs/xfs/xfs_file.c +2
-1@@ -894,129 +1075,31 @@ xfs_file_fallocate(if (error) goto out_unlock; -if (mode &FALLOC_FL_PUNCH_HOLE ) { +switch (mode &FALLOC_FL_MODE_MASK ) { +case FALLOC_FL_PUNCH_HOLE : error =xfs_free_file_space (ip, offset, len);
...
Quoted 14 lines
fs/xfs/xfs_file.c +14
-0+break ; +case FALLOC_FL_COLLAPSE_RANGE : + error =xfs_falloc_collapse_range (file, offset, len); +break ; +case FALLOC_FL_INSERT_RANGE : + error =xfs_falloc_insert_range (file, offset, len); +break ; +case FALLOC_FL_ZERO_RANGE : + error =xfs_falloc_zero_range (file, mode, offset, len); +break ; +case FALLOC_FL_UNSHARE_RANGE : + error =xfs_falloc_unshare_range (file, mode, offset, len); +break ; +case FALLOC_FL_ALLOCATE_RANGE :
fs/xfs/xfs_file.c xfs_file_fallocate( · line 1103
Quoted 10 lines
fs/xfs/xfs_file.c +6
-1+ error =xfs_falloc_allocate_range (file, mode, offset, len); +break ; +default : + error = -EOPNOTSUPP ; +break ; } -if (xfs_file_sync_writes (file)) +if (!error &&xfs_file_sync_writes (file)) error =xfs_log_force_inode (ip);
I'd think if you hit -ENOSPC or something after doing a partial alloc to a sync inode, you'd still want to flush the changes that were made..?
Brian
Quoted 6 lines
out_unlock:Signature · 1 line
2.43.0
Re: [PATCH 6/6] xfs: refactor xfs_file_fallocate
Quoted 6 lines · Brian Foster
fs/xfs/xfs_file.c static inline bool xfs_file_sync_writes(struct file *filp) · line 1006
Quoted 4 lines
fs/xfs/xfs_file.c +4
-0+ error =xfs_reflink_unshare (XFS_I (inode), offset, len); +if (error) +return error; +Doesn't unshare imply alloc?
Yes, ooks like that got lost and no test noticed it
Quoted 6 lines
fs/xfs/xfs_file.c xfs_file_fallocate( · line 1103
Quoted 3 lines
fs/xfs/xfs_file.c +1
-1-if (xfs_file_sync_writes (file)) +if (!error &&xfs_file_sync_writes (file)) error =xfs_log_force_inode (ip);I'd think if you hit
-ENOSPCor something after doing a partial alloc to a sync inode, you'd still want to flush the changes that were made..?
Persistence behavior on error is always undefined. And that's also what the current code does, as it jumps past the log force from all error exits.
Re: [PATCH 6/6] xfs: refactor xfs_file_fallocate
Quoted 17 lines · Christoph Hellwig
Quoted 6 lines · Brian Foster
fs/xfs/xfs_file.c static inline bool xfs_file_sync_writes(struct file *filp) · line 1006
Quoted 4 lines
fs/xfs/xfs_file.c +4
-0+ error =xfs_reflink_unshare (XFS_I (inode), offset, len); +if (error) +return error; +Doesn't unshare imply alloc?
Yes, ooks like that got lost and no test noticed it
Quoted 6 lines
fs/xfs/xfs_file.c xfs_file_fallocate( · line 1103
Quoted 3 lines
fs/xfs/xfs_file.c +1
-1-if (xfs_file_sync_writes (file)) +if (!error &&xfs_file_sync_writes (file)) error =xfs_log_force_inode (ip);I'd think if you hit
-ENOSPCor something after doing a partial alloc to a sync inode, you'd still want to flush the changes that were made..?
Quoted 4 lines
Persistence behavior on error is always undefined. And that's also what the current code does, as it jumps past the log force from all error exits.
Ok, if this preserves existing behavior then I'm not too worried about it. Thanks.
Brian
Darrick J. Wong
Acked-byQuoted 9 lines · Christoph Hellwig
Hi all,
I've recently been looking at the XFS fallocate implementation and got upset about the messing parsing of the mode argument, which mixes modes and an optional flag in a really confusing way.
This series tries to clean this up by better defining what is the operation mode and what is an optional flag, so that both the core code and file systems can use switch statements to switch on the mode.
For patches 4-6,
(I'm not going to touch the NO_HIDE_STALE pony, I'll let you and tytso mix it up over^W^W^W^Wdiscuss that...)
--D