Commit 5aca2842 authored by Darrick J. Wong's avatar Darrick J. Wong
Browse files

vfs: create a generic checking and prep function for FS_IOC_SETFLAGS 



Create a generic function to check incoming FS_IOC_SETFLAGS flag values
and later prepare the inode for updates so that we can standardize the
implementations that follow ext4's flag values.

Note that the efivarfs implementation no longer fails a no-op SETFLAGS
without CAP_LINUX_IMMUTABLE since that's the behavior in ext*.

Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: default avatarJan Kara <jack@suse.cz>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Acked-by: default avatarDavid Sterba <dsterba@suse.com>
Reviewed-by: default avatarBob Peterson <rpeterso@redhat.com>
parent d1fdb6d8

fs/btrfs/ioctl.c

+5 −8
Original line number Diff line number Diff line
@@ -187,7 +187,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg) 
	struct btrfs_inode *binode = BTRFS_I(inode);

	struct btrfs_root *root = binode->root;

	struct btrfs_trans_handle *trans;

	unsigned int fsflags;

	unsigned int fsflags, old_fsflags;

	int ret;

	const char *comp = NULL;

	u32 binode_flags = binode->flags;
@@ -212,13 +212,10 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg) 
	inode_lock(inode);



	fsflags = btrfs_mask_fsflags_for_type(inode, fsflags);

	if ((fsflags ^ btrfs_inode_flags_to_fsflags(binode->flags)) &

	    (FS_APPEND_FL | FS_IMMUTABLE_FL)) {

		if (!capable(CAP_LINUX_IMMUTABLE)) {

			ret = -EPERM;

	old_fsflags = btrfs_inode_flags_to_fsflags(binode->flags);

	ret = vfs_ioc_setflags_prepare(inode, old_fsflags, fsflags);

	if (ret)

		goto out_unlock;

		}

	}



	if (fsflags & FS_SYNC_FL)

		binode_flags |= BTRFS_INODE_SYNC;

fs/efivarfs/file.c

+17 −9
Original line number Diff line number Diff line
@@ -110,16 +110,22 @@ out_free: 
	return size;

}



static int

efivarfs_ioc_getxflags(struct file *file, void __user *arg)

static inline unsigned int efivarfs_getflags(struct inode *inode)

{

	struct inode *inode = file->f_mapping->host;

	unsigned int i_flags;

	unsigned int flags = 0;



	i_flags = inode->i_flags;

	if (i_flags & S_IMMUTABLE)

		flags |= FS_IMMUTABLE_FL;

	return flags;

}



static int

efivarfs_ioc_getxflags(struct file *file, void __user *arg)

{

	struct inode *inode = file->f_mapping->host;

	unsigned int flags = efivarfs_getflags(inode);



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

		return -EFAULT;
@@ -132,6 +138,7 @@ efivarfs_ioc_setxflags(struct file *file, void __user *arg) 
	struct inode *inode = file->f_mapping->host;

	unsigned int flags;

	unsigned int i_flags = 0;

	unsigned int oldflags = efivarfs_getflags(inode);

	int error;



	if (!inode_owner_or_capable(inode))
@@ -143,9 +150,6 @@ efivarfs_ioc_setxflags(struct file *file, void __user *arg) 
	if (flags & ~FS_IMMUTABLE_FL)

		return -EOPNOTSUPP;



	if (!capable(CAP_LINUX_IMMUTABLE))

		return -EPERM;



	if (flags & FS_IMMUTABLE_FL)

		i_flags |= S_IMMUTABLE;
@@ -155,12 +159,16 @@ efivarfs_ioc_setxflags(struct file *file, void __user *arg) 
		return error;



	inode_lock(inode);



	error = vfs_ioc_setflags_prepare(inode, oldflags, flags);

	if (error)

		goto out;



	inode_set_flags(inode, i_flags, S_IMMUTABLE);

out:

	inode_unlock(inode);



	mnt_drop_write_file(file);



	return 0;

	return error;

}



static long

fs/ext2/ioctl.c

+4 −12
Original line number Diff line number Diff line
@@ -60,19 +60,11 @@ long ext2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 
		}

		oldflags = ei->i_flags;



		/*

		 * The IMMUTABLE and APPEND_ONLY flags can only be changed by

		 * the relevant capability.

		 *

		 * This test looks nicer. Thanks to Pauline Middelink

		 */

		if ((flags ^ oldflags) & (EXT2_APPEND_FL | EXT2_IMMUTABLE_FL)) {

			if (!capable(CAP_LINUX_IMMUTABLE)) {

		ret = vfs_ioc_setflags_prepare(inode, oldflags, flags);

		if (ret) {

			inode_unlock(inode);

				ret = -EPERM;

			goto setflags_out;

		}

		}



		flags = flags & EXT2_FL_USER_MODIFIABLE;

		flags |= oldflags & ~EXT2_FL_USER_MODIFIABLE;

fs/ext4/ioctl.c

+3 −10
Original line number Diff line number Diff line
@@ -289,16 +289,9 @@ static int ext4_ioctl_setflags(struct inode *inode, 
	/* The JOURNAL_DATA flag is modifiable only by root */

	jflag = flags & EXT4_JOURNAL_DATA_FL;



	/*

	 * The IMMUTABLE and APPEND_ONLY flags can only be changed by

	 * the relevant capability.

	 *

	 * This test looks nicer. Thanks to Pauline Middelink

	 */

	if ((flags ^ oldflags) & (EXT4_APPEND_FL | EXT4_IMMUTABLE_FL)) {

		if (!capable(CAP_LINUX_IMMUTABLE))

	err = vfs_ioc_setflags_prepare(inode, oldflags, flags);

	if (err)

		goto flags_out;

	}



	/*

	 * The JOURNAL_DATA flag can only be changed by

fs/gfs2/file.c

+29 −13
Original line number Diff line number Diff line
@@ -136,27 +136,36 @@ static struct { 
	{FS_JOURNAL_DATA_FL, GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA},

};



static inline u32 gfs2_gfsflags_to_fsflags(struct inode *inode, u32 gfsflags)

{

	int i;

	u32 fsflags = 0;



	if (S_ISDIR(inode->i_mode))

		gfsflags &= ~GFS2_DIF_JDATA;

	else

		gfsflags &= ~GFS2_DIF_INHERIT_JDATA;



	for (i = 0; i < ARRAY_SIZE(fsflag_gfs2flag); i++)

		if (gfsflags & fsflag_gfs2flag[i].gfsflag)

			fsflags |= fsflag_gfs2flag[i].fsflag;

	return fsflags;

}



static int gfs2_get_flags(struct file *filp, u32 __user *ptr)

{

	struct inode *inode = file_inode(filp);

	struct gfs2_inode *ip = GFS2_I(inode);

	struct gfs2_holder gh;

	int i, error;

	u32 gfsflags, fsflags = 0;

	int error;

	u32 fsflags;



	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);

	error = gfs2_glock_nq(&gh);

	if (error)

		goto out_uninit;



	gfsflags = ip->i_diskflags;

	if (S_ISDIR(inode->i_mode))

		gfsflags &= ~GFS2_DIF_JDATA;

	else

		gfsflags &= ~GFS2_DIF_INHERIT_JDATA;

	for (i = 0; i < ARRAY_SIZE(fsflag_gfs2flag); i++)

		if (gfsflags & fsflag_gfs2flag[i].gfsflag)

			fsflags |= fsflag_gfs2flag[i].fsflag;

	fsflags = gfs2_gfsflags_to_fsflags(inode, ip->i_diskflags);



	if (put_user(fsflags, ptr))

		error = -EFAULT;
@@ -200,9 +209,11 @@ void gfs2_set_inode_flags(struct inode *inode) 
 * @filp: file pointer

 * @reqflags: The flags to set

 * @mask: Indicates which flags are valid

 * @fsflags: The FS_* inode flags passed in

 *

 */

static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)

static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask,

			     const u32 fsflags)

{

	struct inode *inode = file_inode(filp);

	struct gfs2_inode *ip = GFS2_I(inode);
@@ -210,7 +221,7 @@ static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask) 
	struct buffer_head *bh;

	struct gfs2_holder gh;

	int error;

	u32 new_flags, flags;

	u32 new_flags, flags, oldflags;



	error = mnt_want_write_file(filp);

	if (error)
@@ -220,6 +231,11 @@ static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask) 
	if (error)

		goto out_drop_write;



	oldflags = gfs2_gfsflags_to_fsflags(inode, ip->i_diskflags);

	error = vfs_ioc_setflags_prepare(inode, oldflags, fsflags);

	if (error)

		goto out;



	error = -EACCES;

	if (!inode_owner_or_capable(inode))

		goto out;
@@ -308,7 +324,7 @@ static int gfs2_set_flags(struct file *filp, u32 __user *ptr) 
		mask &= ~(GFS2_DIF_TOPDIR | GFS2_DIF_INHERIT_JDATA);

	}



	return do_gfs2_set_flags(filp, gfsflags, mask);

	return do_gfs2_set_flags(filp, gfsflags, mask, fsflags);

}



static int gfs2_getlabel(struct file *filp, char __user *label)

CRA Git | Maintained and supported by SUSTech CRA and CCSE