Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2fe17c10 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Al Viro
Browse files

fallocate should be a file operation 



Currently all filesystems except XFS implement fallocate asynchronously,
while XFS forced a commit.  Both of these are suboptimal - in case of O_SYNC
I/O we really want our allocation on disk, especially for the !KEEP_SIZE
case where we actually grow the file with user-visible zeroes.  On the
other hand always commiting the transaction is a bad idea for fast-path
uses of fallocate like for example in recent Samba versions.   Given
that block allocation is a data plane operation anyway change it from
an inode operation to a file operation so that we have the file structure
available that lets us check for O_SYNC.

This also includes moving the code around for a few of the filesystems,
and remove the already unnedded S_ISDIR checks given that we only wire
up fallocate for regular files.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
parent 64c23e86

Documentation/filesystems/Locking

+1 −2
Original line number Diff line number Diff line
@@ -60,7 +60,6 @@ ata *); 
	ssize_t (*listxattr) (struct dentry *, char *, size_t);

	int (*removexattr) (struct dentry *, const char *);

	void (*truncate_range)(struct inode *, loff_t, loff_t);

	long (*fallocate)(struct inode *inode, int mode, loff_t offset, loff_t len);

	int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, u64 len);



locking rules:
@@ -88,7 +87,6 @@ getxattr: no 
listxattr:	no

removexattr:	yes

truncate_range:	yes

fallocate:	no

fiemap:		no

	Additionally, ->rmdir(), ->unlink() and ->rename() have ->i_mutex on

victim.
@@ -437,6 +435,7 @@ prototypes: 
	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *,

			size_t, unsigned int);

	int (*setlease)(struct file *, long, struct file_lock **);

	long (*fallocate)(struct file *, int, loff_t, loff_t);

};



locking rules:

fs/btrfs/file.c

+113 −0
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <linux/string.h>

#include <linux/backing-dev.h>

#include <linux/mpage.h>

#include <linux/falloc.h>

#include <linux/swap.h>

#include <linux/writeback.h>

#include <linux/statfs.h>
@@ -1237,6 +1238,117 @@ static int btrfs_file_mmap(struct file *filp, struct vm_area_struct *vma) 
	return 0;

}



static long btrfs_fallocate(struct file *file, int mode,

			    loff_t offset, loff_t len)

{

	struct inode *inode = file->f_path.dentry->d_inode;

	struct extent_state *cached_state = NULL;

	u64 cur_offset;

	u64 last_byte;

	u64 alloc_start;

	u64 alloc_end;

	u64 alloc_hint = 0;

	u64 locked_end;

	u64 mask = BTRFS_I(inode)->root->sectorsize - 1;

	struct extent_map *em;

	int ret;



	alloc_start = offset & ~mask;

	alloc_end =  (offset + len + mask) & ~mask;



	/* We only support the FALLOC_FL_KEEP_SIZE mode */

	if (mode & ~FALLOC_FL_KEEP_SIZE)

		return -EOPNOTSUPP;



	/*

	 * wait for ordered IO before we have any locks.  We'll loop again

	 * below with the locks held.

	 */

	btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start);



	mutex_lock(&inode->i_mutex);

	ret = inode_newsize_ok(inode, alloc_end);

	if (ret)

		goto out;



	if (alloc_start > inode->i_size) {

		ret = btrfs_cont_expand(inode, alloc_start);

		if (ret)

			goto out;

	}



	ret = btrfs_check_data_free_space(inode, alloc_end - alloc_start);

	if (ret)

		goto out;



	locked_end = alloc_end - 1;

	while (1) {

		struct btrfs_ordered_extent *ordered;



		/* the extent lock is ordered inside the running

		 * transaction

		 */

		lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start,

				 locked_end, 0, &cached_state, GFP_NOFS);

		ordered = btrfs_lookup_first_ordered_extent(inode,

							    alloc_end - 1);

		if (ordered &&

		    ordered->file_offset + ordered->len > alloc_start &&

		    ordered->file_offset < alloc_end) {

			btrfs_put_ordered_extent(ordered);

			unlock_extent_cached(&BTRFS_I(inode)->io_tree,

					     alloc_start, locked_end,

					     &cached_state, GFP_NOFS);

			/*

			 * we can't wait on the range with the transaction

			 * running or with the extent lock held

			 */

			btrfs_wait_ordered_range(inode, alloc_start,

						 alloc_end - alloc_start);

		} else {

			if (ordered)

				btrfs_put_ordered_extent(ordered);

			break;

		}

	}



	cur_offset = alloc_start;

	while (1) {

		em = btrfs_get_extent(inode, NULL, 0, cur_offset,

				      alloc_end - cur_offset, 0);

		BUG_ON(IS_ERR(em) || !em);

		last_byte = min(extent_map_end(em), alloc_end);

		last_byte = (last_byte + mask) & ~mask;

		if (em->block_start == EXTENT_MAP_HOLE ||

		    (cur_offset >= inode->i_size &&

		     !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {

			ret = btrfs_prealloc_file_range(inode, mode, cur_offset,

							last_byte - cur_offset,

							1 << inode->i_blkbits,

							offset + len,

							&alloc_hint);

			if (ret < 0) {

				free_extent_map(em);

				break;

			}

		}

		free_extent_map(em);



		cur_offset = last_byte;

		if (cur_offset >= alloc_end) {

			ret = 0;

			break;

		}

	}

	unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,

			     &cached_state, GFP_NOFS);



	btrfs_free_reserved_data_space(inode, alloc_end - alloc_start);

out:

	mutex_unlock(&inode->i_mutex);

	return ret;

}



const struct file_operations btrfs_file_operations = {

	.llseek		= generic_file_llseek,

	.read		= do_sync_read,
@@ -1248,6 +1360,7 @@ const struct file_operations btrfs_file_operations = { 
	.open		= generic_file_open,

	.release	= btrfs_release_file,

	.fsync		= btrfs_sync_file,

	.fallocate	= btrfs_fallocate,

	.unlocked_ioctl	= btrfs_ioctl,

#ifdef CONFIG_COMPAT

	.compat_ioctl	= btrfs_ioctl,

fs/btrfs/inode.c

+0 −111
Original line number Diff line number Diff line
@@ -7098,116 +7098,6 @@ int btrfs_prealloc_file_range_trans(struct inode *inode, 
					   min_size, actual_len, alloc_hint, trans);

}



static long btrfs_fallocate(struct inode *inode, int mode,

			    loff_t offset, loff_t len)

{

	struct extent_state *cached_state = NULL;

	u64 cur_offset;

	u64 last_byte;

	u64 alloc_start;

	u64 alloc_end;

	u64 alloc_hint = 0;

	u64 locked_end;

	u64 mask = BTRFS_I(inode)->root->sectorsize - 1;

	struct extent_map *em;

	int ret;



	alloc_start = offset & ~mask;

	alloc_end =  (offset + len + mask) & ~mask;



	/* We only support the FALLOC_FL_KEEP_SIZE mode */

	if (mode & ~FALLOC_FL_KEEP_SIZE)

		return -EOPNOTSUPP;



	/*

	 * wait for ordered IO before we have any locks.  We'll loop again

	 * below with the locks held.

	 */

	btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start);



	mutex_lock(&inode->i_mutex);

	ret = inode_newsize_ok(inode, alloc_end);

	if (ret)

		goto out;



	if (alloc_start > inode->i_size) {

		ret = btrfs_cont_expand(inode, alloc_start);

		if (ret)

			goto out;

	}



	ret = btrfs_check_data_free_space(inode, alloc_end - alloc_start);

	if (ret)

		goto out;



	locked_end = alloc_end - 1;

	while (1) {

		struct btrfs_ordered_extent *ordered;



		/* the extent lock is ordered inside the running

		 * transaction

		 */

		lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start,

				 locked_end, 0, &cached_state, GFP_NOFS);

		ordered = btrfs_lookup_first_ordered_extent(inode,

							    alloc_end - 1);

		if (ordered &&

		    ordered->file_offset + ordered->len > alloc_start &&

		    ordered->file_offset < alloc_end) {

			btrfs_put_ordered_extent(ordered);

			unlock_extent_cached(&BTRFS_I(inode)->io_tree,

					     alloc_start, locked_end,

					     &cached_state, GFP_NOFS);

			/*

			 * we can't wait on the range with the transaction

			 * running or with the extent lock held

			 */

			btrfs_wait_ordered_range(inode, alloc_start,

						 alloc_end - alloc_start);

		} else {

			if (ordered)

				btrfs_put_ordered_extent(ordered);

			break;

		}

	}



	cur_offset = alloc_start;

	while (1) {

		em = btrfs_get_extent(inode, NULL, 0, cur_offset,

				      alloc_end - cur_offset, 0);

		BUG_ON(IS_ERR(em) || !em);

		last_byte = min(extent_map_end(em), alloc_end);

		last_byte = (last_byte + mask) & ~mask;

		if (em->block_start == EXTENT_MAP_HOLE ||

		    (cur_offset >= inode->i_size &&

		     !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {

			ret = btrfs_prealloc_file_range(inode, mode, cur_offset,

							last_byte - cur_offset,

							1 << inode->i_blkbits,

							offset + len,

							&alloc_hint);

			if (ret < 0) {

				free_extent_map(em);

				break;

			}

		}

		free_extent_map(em);



		cur_offset = last_byte;

		if (cur_offset >= alloc_end) {

			ret = 0;

			break;

		}

	}

	unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,

			     &cached_state, GFP_NOFS);



	btrfs_free_reserved_data_space(inode, alloc_end - alloc_start);

out:

	mutex_unlock(&inode->i_mutex);

	return ret;

}



static int btrfs_set_page_dirty(struct page *page)

{

	return __set_page_dirty_nobuffers(page);
@@ -7310,7 +7200,6 @@ static const struct inode_operations btrfs_file_inode_operations = { 
	.listxattr      = btrfs_listxattr,

	.removexattr	= btrfs_removexattr,

	.permission	= btrfs_permission,

	.fallocate	= btrfs_fallocate,

	.fiemap		= btrfs_fiemap,

};

static const struct inode_operations btrfs_special_inode_operations = {

fs/ext4/ext4.h

+1 −1
Original line number Diff line number Diff line
@@ -2065,7 +2065,7 @@ extern int ext4_ext_map_blocks(handle_t *handle, struct inode *inode, 
extern void ext4_ext_truncate(struct inode *);

extern void ext4_ext_init(struct super_block *);

extern void ext4_ext_release(struct super_block *);

extern long ext4_fallocate(struct inode *inode, int mode, loff_t offset,

extern long ext4_fallocate(struct file *file, int mode, loff_t offset,

			  loff_t len);

extern int ext4_convert_unwritten_extents(struct inode *inode, loff_t offset,

			  ssize_t len);

fs/ext4/extents.c

+3 −6
Original line number Diff line number Diff line
@@ -3627,14 +3627,15 @@ static void ext4_falloc_update_inode(struct inode *inode, 
}



/*

 * preallocate space for a file. This implements ext4's fallocate inode

 * preallocate space for a file. This implements ext4's fallocate file

 * operation, which gets called from sys_fallocate system call.

 * For block-mapped files, posix_fallocate should fall back to the method

 * of writing zeroes to the required new blocks (the same behavior which is

 * expected for file systems which do not support fallocate() system call).

 */

long ext4_fallocate(struct inode *inode, int mode, loff_t offset, loff_t len)

long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)

{

	struct inode *inode = file->f_path.dentry->d_inode;

	handle_t *handle;

	loff_t new_size;

	unsigned int max_blocks;
@@ -3655,10 +3656,6 @@ long ext4_fallocate(struct inode *inode, int mode, loff_t offset, loff_t len) 
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))

		return -EOPNOTSUPP;



	/* preallocation to directories is currently not supported */

	if (S_ISDIR(inode->i_mode))

		return -ENODEV;



	map.m_lblk = offset >> blkbits;

	/*

	 * We can't just convert len to max_blocks because