Commit 235646a4 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6:
  fs: fix address space warnings in ioctl_fiemap()
  aio: check return value of create_workqueue()
  hpfs_setattr error case avoids unlock_kernel
  compat: copy missing fields in compat_statfs64 to user
  compat: update comment of compat statfs syscalls
  compat: remove unnecessary assignment in compat_rw_copy_check_uvector()
  fs: FS_POSIX_ACL does not depend on BLOCK
  fs: Remove unlikely() from fget_light()
  fs: Remove unlikely() from fput_light()
  fallocate should be a file operation
  make the feature checks in ->fallocate future proof
  staging: smbfs building fix
  tidy up around finish_automount()
  don't drop newmnt on error in do_add_mount()
  Take the completion of automount into new helper
parents af575e2d ecf5632d

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:

drivers/staging/smbfs/dir.c

+2 −2
Original line number Diff line number Diff line
@@ -283,7 +283,7 @@ static int smb_compare_dentry(const struct dentry *, 
		unsigned int, const char *, const struct qstr *);

static int smb_delete_dentry(const struct dentry *);



static const struct dentry_operations smbfs_dentry_operations =

const struct dentry_operations smbfs_dentry_operations =

{

	.d_revalidate	= smb_lookup_validate,

	.d_hash		= smb_hash_dentry,
@@ -291,7 +291,7 @@ static const struct dentry_operations smbfs_dentry_operations = 
	.d_delete	= smb_delete_dentry,

};



static const struct dentry_operations smbfs_dentry_operations_case =

const struct dentry_operations smbfs_dentry_operations_case =

{

	.d_revalidate	= smb_lookup_validate,

	.d_delete	= smb_delete_dentry,

fs/Kconfig

+8 −9
Original line number Diff line number Diff line
@@ -30,15 +30,6 @@ config FS_MBCACHE 
source "fs/reiserfs/Kconfig"

source "fs/jfs/Kconfig"



config FS_POSIX_ACL

# Posix ACL utility routines (for now, only ext2/ext3/jfs/reiserfs/nfs4)

#

# NOTE: you can implement Posix ACLs without these helpers (XFS does).

# 	Never use this symbol for ifdefs.

#

	bool

	default n



source "fs/xfs/Kconfig"

source "fs/gfs2/Kconfig"

source "fs/ocfs2/Kconfig"
@@ -47,6 +38,14 @@ source "fs/nilfs2/Kconfig" 


endif # BLOCK



# Posix ACL utility routines

#

# Note: Posix ACLs can be implemented without these helpers.  Never use

# this symbol for ifdefs in core code.

#

config FS_POSIX_ACL

	def_bool n



config EXPORTFS

	tristate

fs/aio.c

+1 −1
Original line number Diff line number Diff line
@@ -87,7 +87,7 @@ static int __init aio_setup(void) 


	aio_wq = create_workqueue("aio");

	abe_pool = mempool_create_kmalloc_pool(1, sizeof(struct aio_batch_entry));

	BUG_ON(!abe_pool);

	BUG_ON(!aio_wq || !abe_pool);



	pr_debug("aio_setup: sizeof(struct page) = %d\n", (int)sizeof(struct page));

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,

CRA Git | Maintained and supported by SUSTech CRA and CCSE