Commit 4acaddf5 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Christian Brauner
Browse files

xfs: refactor xfs_file_fallocate 



Refactor xfs_file_fallocate into separate helpers for each mode,
two factors for i_size handling and a single switch statement over the
supported modes.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Link: https://lore.kernel.org/r/20240827065123.1762168-7-hch@lst.de


Reviewed-by: default avatarDarrick J. Wong <djwong@kernel.org>
Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent 72f4d525

fs/xfs/xfs_file.c

+208 −122
Original line number Diff line number Diff line
@@ -852,171 +852,257 @@ static inline bool xfs_file_sync_writes(struct file *filp) 
	return false;

}



#define	XFS_FALLOC_FL_SUPPORTED						\

		(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |		\

		 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |	\

		 FALLOC_FL_INSERT_RANGE | FALLOC_FL_UNSHARE_RANGE)



STATIC long

xfs_file_fallocate(

static int

xfs_falloc_newsize(

	struct file		*file,

	int			mode,

	loff_t			offset,

	loff_t			len)

	loff_t			len,

	loff_t			*new_size)

{

	struct inode		*inode = file_inode(file);

	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;

	if (mode & ~XFS_FALLOC_FL_SUPPORTED)

		return -EOPNOTSUPP;

	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);

}



	xfs_ilock(ip, iolock);

	error = xfs_break_layouts(inode, &iolock, BREAK_UNMAP);

	if (error)

		goto out_unlock;

static int

xfs_falloc_setsize(

	struct file		*file,

	loff_t			new_size)

{

	struct iattr iattr = {

		.ia_valid	= ATTR_SIZE,

		.ia_size	= new_size,

	};



	/*

	 * Must wait for all AIO to complete before we continue as AIO can

	 * change the file size on completion without holding any locks we

	 * currently hold. We must do this first because AIO can update both

	 * the on disk and in memory inode sizes, and the operations that follow

	 * require the in-memory size to be fully up-to-date.

	 */

	inode_dio_wait(inode);

	if (!new_size)

		return 0;

	return xfs_vn_setattr_size(file_mnt_idmap(file), file_dentry(file),

			&iattr);

}



	error = file_modified(file);

	if (error)

		goto out_unlock;

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 (mode & 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;

		}

	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

	 * 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;

	if (offset + len >= i_size_read(inode))

		return -EINVAL;



		error = xfs_collapse_file_space(ip, offset, len);

	error = xfs_collapse_file_space(XFS_I(inode), offset, len);

	if (error)

			goto out_unlock;

	} else if (mode & FALLOC_FL_INSERT_RANGE) {

		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(ip, offset, len)) {

			error = -EINVAL;

			goto out_unlock;

		}

	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) {

			error = -EFBIG;

			goto out_unlock;

		}

		new_size = isize + len;

	if (inode->i_sb->s_maxbytes - isize < len)

		return -EFBIG;



	/* 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 (offset >= isize)

		return -EINVAL;



	error = xfs_falloc_setsize(file, isize + len);

	if (error)

				goto out_unlock;

		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);

}



		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:

 * 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.

 *   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(ip);

	trace_xfs_zero_file_space(XFS_I(inode));



			error = xfs_free_file_space(ip, offset, len);

	error = xfs_falloc_newsize(file, mode, offset, len, &new_size);

	if (error)

				goto out_unlock;

		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);

	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);

	error = xfs_alloc_file_space(XFS_I(inode), 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;

		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;



	error = xfs_alloc_file_space(XFS_I(inode), offset, len);

	if (error)

		return error;

	return xfs_falloc_setsize(file, new_size);

}



		error = xfs_alloc_file_space(ip, offset, len);

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)

			goto out_unlock;

		return error;



	error = xfs_alloc_file_space(XFS_I(inode), offset, len);

	if (error)

		return error;

	return xfs_falloc_setsize(file, new_size);

}



	/* Change file size if needed */

	if (new_size) {

		struct iattr iattr;

#define	XFS_FALLOC_FL_SUPPORTED						\

		(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |		\

		 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE |	\

		 FALLOC_FL_INSERT_RANGE | FALLOC_FL_UNSHARE_RANGE)



STATIC long

xfs_file_fallocate(

	struct file		*file,

	int			mode,

	loff_t			offset,

	loff_t			len)

{

	struct inode		*inode = file_inode(file);

	struct xfs_inode	*ip = XFS_I(inode);

	long			error;

	uint			iolock = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;



	if (!S_ISREG(inode->i_mode))

		return -EINVAL;

	if (mode & ~XFS_FALLOC_FL_SUPPORTED)

		return -EOPNOTSUPP;



		iattr.ia_valid = ATTR_SIZE;

		iattr.ia_size = new_size;

		error = xfs_vn_setattr_size(file_mnt_idmap(file),

					    file_dentry(file), &iattr);

	xfs_ilock(ip, iolock);

	error = xfs_break_layouts(inode, &iolock, BREAK_UNMAP);

	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.

	 * Must wait for all AIO to complete before we continue as AIO can

	 * change the file size on completion without holding any locks we

	 * currently hold. We must do this first because AIO can update both

	 * the on disk and in memory inode sizes, and the operations that follow

	 * require the in-memory size to be fully up-to-date.

	 */

	if (do_file_insert) {

		error = xfs_insert_file_space(ip, offset, len);

	inode_dio_wait(inode);



	error = file_modified(file);

	if (error)

		goto out_unlock;



	switch (mode & FALLOC_FL_MODE_MASK) {

	case FALLOC_FL_PUNCH_HOLE:

		error = xfs_free_file_space(ip, offset, len);

		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: