Commit a4f7fae1 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'miklos.fileattr' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs 

Pull fileattr conversion updates from Miklos Szeredi via Al Viro:
 "This splits the handling of FS_IOC_[GS]ETFLAGS from ->ioctl() into a
  separate method.

  The interface is reasonably uniform across the filesystems that
  support it and gives nice boilerplate removal"

* 'miklos.fileattr' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: (23 commits)
  ovl: remove unneeded ioctls
  fuse: convert to fileattr
  fuse: add internal open/release helpers
  fuse: unsigned open flags
  fuse: move ioctl to separate source file
  vfs: remove unused ioctl helpers
  ubifs: convert to fileattr
  reiserfs: convert to fileattr
  ocfs2: convert to fileattr
  nilfs2: convert to fileattr
  jfs: convert to fileattr
  hfsplus: convert to fileattr
  efivars: convert to fileattr
  xfs: convert to fileattr
  orangefs: convert to fileattr
  gfs2: convert to fileattr
  f2fs: convert to fileattr
  ext4: convert to fileattr
  ext2: convert to fileattr
  btrfs: convert to fileattr
  ...
parents 5e672088 c4fe8aef

Documentation/filesystems/locking.rst

+8 −3
Original line number Diff line number Diff line
@@ -80,13 +80,16 @@ prototypes:: 
				struct file *, unsigned open_flag,

				umode_t create_mode);

	int (*tmpfile) (struct inode *, struct dentry *, umode_t);

	int (*fileattr_set)(struct user_namespace *mnt_userns,

			    struct dentry *dentry, struct fileattr *fa);

	int (*fileattr_get)(struct dentry *dentry, struct fileattr *fa);



locking rules:

	all may block



============	=============================================

=============	=============================================

ops		i_rwsem(inode)

============	=============================================

=============	=============================================

lookup:		shared

create:		exclusive

link:		exclusive (both)
@@ -107,7 +110,9 @@ fiemap: no 
update_time:	no

atomic_open:	shared (exclusive if O_CREAT is set in open flags)

tmpfile:	no

============	=============================================

fileattr_get:	no or exclusive

fileattr_set:	exclusive

=============	=============================================





	Additionally, ->rmdir(), ->unlink() and ->rename() have ->i_rwsem

Documentation/filesystems/vfs.rst

+15 −0
Original line number Diff line number Diff line
@@ -441,6 +441,9 @@ As of kernel 2.6.22, the following members are defined: 
				   unsigned open_flag, umode_t create_mode);

		int (*tmpfile) (struct user_namespace *, struct inode *, struct dentry *, umode_t);

	        int (*set_acl)(struct user_namespace *, struct inode *, struct posix_acl *, int);

		int (*fileattr_set)(struct user_namespace *mnt_userns,

				    struct dentry *dentry, struct fileattr *fa);

		int (*fileattr_get)(struct dentry *dentry, struct fileattr *fa);

	};



Again, all methods are called without any locks being held, unless
@@ -588,6 +591,18 @@ otherwise noted. 
	atomically creating, opening and unlinking a file in given

	directory.



``fileattr_get``

	called on ioctl(FS_IOC_GETFLAGS) and ioctl(FS_IOC_FSGETXATTR) to

	retrieve miscellaneous file flags and attributes.  Also called

	before the relevant SET operation to check what is being changed

	(in this case with i_rwsem locked exclusive).  If unset, then

	fall back to f_op->ioctl().



``fileattr_set``

	called on ioctl(FS_IOC_SETFLAGS) and ioctl(FS_IOC_FSSETXATTR) to

	change miscellaneous file flags and attributes.  Callers hold

	i_rwsem exclusive.  If unset, then fall back to f_op->ioctl().





The Address Space Object

========================

fs/btrfs/ctree.h

+3 −0
Original line number Diff line number Diff line
@@ -3207,6 +3207,9 @@ void btrfs_update_inode_bytes(struct btrfs_inode *inode, 
/* ioctl.c */

long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

int btrfs_fileattr_get(struct dentry *dentry, struct fileattr *fa);

int btrfs_fileattr_set(struct user_namespace *mnt_userns,

		       struct dentry *dentry, struct fileattr *fa);

int btrfs_ioctl_get_supported_features(void __user *arg);

void btrfs_sync_inode_flags_to_i_flags(struct inode *inode);

int __pure btrfs_is_empty_uuid(u8 *uuid);

fs/btrfs/inode.c

+4 −0
Original line number Diff line number Diff line
@@ -10620,6 +10620,8 @@ static const struct inode_operations btrfs_dir_inode_operations = { 
	.set_acl	= btrfs_set_acl,

	.update_time	= btrfs_update_time,

	.tmpfile        = btrfs_tmpfile,

	.fileattr_get	= btrfs_fileattr_get,

	.fileattr_set	= btrfs_fileattr_set,

};



static const struct file_operations btrfs_dir_file_operations = {
@@ -10673,6 +10675,8 @@ static const struct inode_operations btrfs_file_inode_operations = { 
	.get_acl	= btrfs_get_acl,

	.set_acl	= btrfs_set_acl,

	.update_time	= btrfs_update_time,

	.fileattr_get	= btrfs_fileattr_get,

	.fileattr_set	= btrfs_fileattr_set,

};

static const struct inode_operations btrfs_special_inode_operations = {

	.getattr	= btrfs_getattr,

fs/btrfs/ioctl.c

+34 −192
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include <linux/btrfs.h>

#include <linux/uaccess.h>

#include <linux/iversion.h>

#include <linux/fileattr.h>

#include "ctree.h"

#include "disk-io.h"

#include "export.h"
@@ -153,16 +154,6 @@ void btrfs_sync_inode_flags_to_i_flags(struct inode *inode) 
		      new_fl);

}



static int btrfs_ioctl_getflags(struct file *file, void __user *arg)

{

	struct btrfs_inode *binode = BTRFS_I(file_inode(file));

	unsigned int flags = btrfs_inode_flags_to_fsflags(binode->flags);



	if (copy_to_user(arg, &flags, sizeof(flags)))

		return -EFAULT;

	return 0;

}



/*

 * Check if @flags are a supported and valid set of FS_*_FL flags and that

 * the old and new flags are not conflicting
@@ -201,9 +192,22 @@ static int check_fsflags_compatible(struct btrfs_fs_info *fs_info, 
	return 0;

}



static int btrfs_ioctl_setflags(struct file *file, void __user *arg)

/*

 * Set flags/xflags from the internal inode flags. The remaining items of

 * fsxattr are zeroed.

 */

int btrfs_fileattr_get(struct dentry *dentry, struct fileattr *fa)

{

	struct btrfs_inode *binode = BTRFS_I(d_inode(dentry));



	fileattr_fill_flags(fa, btrfs_inode_flags_to_fsflags(binode->flags));

	return 0;

}



int btrfs_fileattr_set(struct user_namespace *mnt_userns,

		       struct dentry *dentry, struct fileattr *fa)

{

	struct inode *inode = file_inode(file);

	struct inode *inode = d_inode(dentry);

	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);

	struct btrfs_inode *binode = BTRFS_I(inode);

	struct btrfs_root *root = binode->root;
@@ -213,34 +217,21 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg) 
	const char *comp = NULL;

	u32 binode_flags;



	if (!inode_owner_or_capable(&init_user_ns, inode))

		return -EPERM;



	if (btrfs_root_readonly(root))

		return -EROFS;



	if (copy_from_user(&fsflags, arg, sizeof(fsflags)))

		return -EFAULT;



	ret = mnt_want_write_file(file);

	if (ret)

		return ret;

	if (fileattr_has_fsx(fa))

		return -EOPNOTSUPP;



	btrfs_inode_lock(inode, 0);

	fsflags = btrfs_mask_fsflags_for_type(inode, fsflags);

	fsflags = btrfs_mask_fsflags_for_type(inode, fa->flags);

	old_fsflags = btrfs_inode_flags_to_fsflags(binode->flags);



	ret = vfs_ioc_setflags_prepare(inode, old_fsflags, fsflags);

	if (ret)

		goto out_unlock;



	ret = check_fsflags(old_fsflags, fsflags);

	if (ret)

		goto out_unlock;

		return ret;



	ret = check_fsflags_compatible(fs_info, fsflags);

	if (ret)

		goto out_unlock;

		return ret;



	binode_flags = binode->flags;

	if (fsflags & FS_SYNC_FL)
@@ -263,6 +254,14 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg) 
		binode_flags |= BTRFS_INODE_NOATIME;

	else

		binode_flags &= ~BTRFS_INODE_NOATIME;



	/* If coming from FS_IOC_FSSETXATTR then skip unconverted flags */

	if (!fa->flags_valid) {

		/* 1 item for the inode */

		trans = btrfs_start_transaction(root, 1);

		goto update_flags;

	}



	if (fsflags & FS_DIRSYNC_FL)

		binode_flags |= BTRFS_INODE_DIRSYNC;

	else
@@ -303,10 +302,8 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg) 
		binode_flags |= BTRFS_INODE_NOCOMPRESS;

	} else if (fsflags & FS_COMPR_FL) {



		if (IS_SWAPFILE(inode)) {

			ret = -ETXTBSY;

			goto out_unlock;

		}

		if (IS_SWAPFILE(inode))

			return -ETXTBSY;



		binode_flags |= BTRFS_INODE_COMPRESS;

		binode_flags &= ~BTRFS_INODE_NOCOMPRESS;
@@ -323,10 +320,8 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg) 
	 * 2 for properties

	 */

	trans = btrfs_start_transaction(root, 3);

	if (IS_ERR(trans)) {

		ret = PTR_ERR(trans);

		goto out_unlock;

	}

	if (IS_ERR(trans))

		return PTR_ERR(trans);



	if (comp) {

		ret = btrfs_set_prop(trans, inode, "btrfs.compression", comp,
@@ -344,6 +339,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg) 
		}

	}



update_flags:

	binode->flags = binode_flags;

	btrfs_sync_inode_flags_to_i_flags(inode);

	inode_inc_iversion(inode);
@@ -352,44 +348,9 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg) 


 out_end_trans:

	btrfs_end_transaction(trans);

 out_unlock:

	btrfs_inode_unlock(inode, 0);

	mnt_drop_write_file(file);

	return ret;

}



/*

 * Translate btrfs internal inode flags to xflags as expected by the

 * FS_IOC_FSGETXATT ioctl. Filter only the supported ones, unknown flags are

 * silently dropped.

 */

static unsigned int btrfs_inode_flags_to_xflags(unsigned int flags)

{

	unsigned int xflags = 0;



	if (flags & BTRFS_INODE_APPEND)

		xflags |= FS_XFLAG_APPEND;

	if (flags & BTRFS_INODE_IMMUTABLE)

		xflags |= FS_XFLAG_IMMUTABLE;

	if (flags & BTRFS_INODE_NOATIME)

		xflags |= FS_XFLAG_NOATIME;

	if (flags & BTRFS_INODE_NODUMP)

		xflags |= FS_XFLAG_NODUMP;

	if (flags & BTRFS_INODE_SYNC)

		xflags |= FS_XFLAG_SYNC;



	return xflags;

}



/* Check if @flags are a supported and valid set of FS_XFLAGS_* flags */

static int check_xflags(unsigned int flags)

{

	if (flags & ~(FS_XFLAG_APPEND | FS_XFLAG_IMMUTABLE | FS_XFLAG_NOATIME |

		      FS_XFLAG_NODUMP | FS_XFLAG_SYNC))

		return -EOPNOTSUPP;

	return 0;

}



bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,

			enum btrfs_exclusive_operation type)

{
@@ -402,111 +363,6 @@ void btrfs_exclop_finish(struct btrfs_fs_info *fs_info) 
	sysfs_notify(&fs_info->fs_devices->fsid_kobj, NULL, "exclusive_operation");

}



/*

 * Set the xflags from the internal inode flags. The remaining items of fsxattr

 * are zeroed.

 */

static int btrfs_ioctl_fsgetxattr(struct file *file, void __user *arg)

{

	struct btrfs_inode *binode = BTRFS_I(file_inode(file));

	struct fsxattr fa;



	simple_fill_fsxattr(&fa, btrfs_inode_flags_to_xflags(binode->flags));

	if (copy_to_user(arg, &fa, sizeof(fa)))

		return -EFAULT;



	return 0;

}



static int btrfs_ioctl_fssetxattr(struct file *file, void __user *arg)

{

	struct inode *inode = file_inode(file);

	struct btrfs_inode *binode = BTRFS_I(inode);

	struct btrfs_root *root = binode->root;

	struct btrfs_trans_handle *trans;

	struct fsxattr fa, old_fa;

	unsigned old_flags;

	unsigned old_i_flags;

	int ret = 0;



	if (!inode_owner_or_capable(&init_user_ns, inode))

		return -EPERM;



	if (btrfs_root_readonly(root))

		return -EROFS;



	if (copy_from_user(&fa, arg, sizeof(fa)))

		return -EFAULT;



	ret = check_xflags(fa.fsx_xflags);

	if (ret)

		return ret;



	if (fa.fsx_extsize != 0 || fa.fsx_projid != 0 || fa.fsx_cowextsize != 0)

		return -EOPNOTSUPP;



	ret = mnt_want_write_file(file);

	if (ret)

		return ret;



	btrfs_inode_lock(inode, 0);



	old_flags = binode->flags;

	old_i_flags = inode->i_flags;



	simple_fill_fsxattr(&old_fa,

			    btrfs_inode_flags_to_xflags(binode->flags));

	ret = vfs_ioc_fssetxattr_check(inode, &old_fa, &fa);

	if (ret)

		goto out_unlock;



	if (fa.fsx_xflags & FS_XFLAG_SYNC)

		binode->flags |= BTRFS_INODE_SYNC;

	else

		binode->flags &= ~BTRFS_INODE_SYNC;

	if (fa.fsx_xflags & FS_XFLAG_IMMUTABLE)

		binode->flags |= BTRFS_INODE_IMMUTABLE;

	else

		binode->flags &= ~BTRFS_INODE_IMMUTABLE;

	if (fa.fsx_xflags & FS_XFLAG_APPEND)

		binode->flags |= BTRFS_INODE_APPEND;

	else

		binode->flags &= ~BTRFS_INODE_APPEND;

	if (fa.fsx_xflags & FS_XFLAG_NODUMP)

		binode->flags |= BTRFS_INODE_NODUMP;

	else

		binode->flags &= ~BTRFS_INODE_NODUMP;

	if (fa.fsx_xflags & FS_XFLAG_NOATIME)

		binode->flags |= BTRFS_INODE_NOATIME;

	else

		binode->flags &= ~BTRFS_INODE_NOATIME;



	/* 1 item for the inode */

	trans = btrfs_start_transaction(root, 1);

	if (IS_ERR(trans)) {

		ret = PTR_ERR(trans);

		goto out_unlock;

	}



	btrfs_sync_inode_flags_to_i_flags(inode);

	inode_inc_iversion(inode);

	inode->i_ctime = current_time(inode);

	ret = btrfs_update_inode(trans, root, BTRFS_I(inode));



	btrfs_end_transaction(trans);



out_unlock:

	if (ret) {

		binode->flags = old_flags;

		inode->i_flags = old_i_flags;

	}



	btrfs_inode_unlock(inode, 0);

	mnt_drop_write_file(file);



	return ret;

}



static int btrfs_ioctl_getversion(struct file *file, int __user *arg)

{

	struct inode *inode = file_inode(file);
@@ -4932,10 +4788,6 @@ long btrfs_ioctl(struct file *file, unsigned int 
	void __user *argp = (void __user *)arg;



	switch (cmd) {

	case FS_IOC_GETFLAGS:

		return btrfs_ioctl_getflags(file, argp);

	case FS_IOC_SETFLAGS:

		return btrfs_ioctl_setflags(file, argp);

	case FS_IOC_GETVERSION:

		return btrfs_ioctl_getversion(file, argp);

	case FS_IOC_GETFSLABEL:
@@ -5061,10 +4913,6 @@ long btrfs_ioctl(struct file *file, unsigned int 
		return btrfs_ioctl_get_features(fs_info, argp);

	case BTRFS_IOC_SET_FEATURES:

		return btrfs_ioctl_set_features(file, argp);

	case FS_IOC_FSGETXATTR:

		return btrfs_ioctl_fsgetxattr(file, argp);

	case FS_IOC_FSSETXATTR:

		return btrfs_ioctl_fssetxattr(file, argp);

	case BTRFS_IOC_GET_SUBVOL_INFO:

		return btrfs_ioctl_get_subvol_info(file, argp);

	case BTRFS_IOC_GET_SUBVOL_ROOTREF:
@@ -5084,12 +4932,6 @@ long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
	 * handling is necessary.

	 */

	switch (cmd) {

	case FS_IOC32_GETFLAGS:

		cmd = FS_IOC_GETFLAGS;

		break;

	case FS_IOC32_SETFLAGS:

		cmd = FS_IOC_SETFLAGS;

		break;

	case FS_IOC32_GETVERSION:

		cmd = FS_IOC_GETVERSION;

		break;