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

Commit e81cea2a authored by Daniel Rosenberg's avatar Daniel Rosenberg Committed by Alistair Strachan
Browse files

ANDROID: vfs: Add permission2 for filesystems with per mount permissions 



This allows filesystems to use their mount private data to
influence the permssions they return in permission2. It has
been separated into a new call to avoid disrupting current
permission users.

Bug: 35848445
Bug: 120446149
Change-Id: I9d416e3b8b6eca84ef3e336bd2af89ddd51df6ca
Signed-off-by: default avatarDaniel Rosenberg <drosen@google.com>
[AmitP: Minor refactoring of original patch to align with
        changes from the following upstream commit
        4bfd054a ("fs: fold __inode_permission() into inode_permission()").
        Also introduce vfs_mkobj2(), because do_create()
        moved from using vfs_create() to vfs_mkobj()
        eecec19d ("mqueue: switch to vfs_mkobj(), quit abusing ->d_fsdata")
        do_create() is dropped/cleaned-up upstream so a
        minor refactoring there as well.
        066cc813 ("do_mq_open(): move all work prior to dentry_open() into a helper")]
Signed-off-by: default avatarAmit Pundir <amit.pundir@linaro.org>
[astrachan: Folded the following changes into this patch:
            f46c9d62dd81 ("ANDROID: fs: Export vfs_rmdir2")
            9992eb8b9a1e ("ANDROID: xattr: Pass EOPNOTSUPP to permission2")]
Signed-off-by: default avatarAlistair Strachan <astrachan@google.com>
parent 74cca90e

fs/attr.c

+1 −1
Original line number Diff line number Diff line
@@ -247,7 +247,7 @@ int notify_change2(struct vfsmount *mnt, struct dentry * dentry, struct iattr * 
			return -EPERM;



		if (!inode_owner_or_capable(inode)) {

			error = inode_permission(inode, MAY_WRITE);

			error = inode_permission2(mnt, inode, MAY_WRITE);

			if (error)

				return error;

		}

fs/exec.c

+1 −1
Original line number Diff line number Diff line
@@ -1308,7 +1308,7 @@ EXPORT_SYMBOL(flush_old_exec); 
void would_dump(struct linux_binprm *bprm, struct file *file)

{

	struct inode *inode = file_inode(file);

	if (inode_permission(inode, MAY_READ) < 0) {

	if (inode_permission2(file->f_path.mnt, inode, MAY_READ) < 0) {

		struct user_namespace *old, *user_ns;

		bprm->interp_flags |= BINPRM_FLAGS_ENFORCE_NONDUMP;

fs/namei.c

+133 −54
Original line number Diff line number Diff line
@@ -379,9 +379,11 @@ EXPORT_SYMBOL(generic_permission); 
 * flag in inode->i_opflags, that says "this has not special

 * permission function, use the fast case".

 */

static inline int do_inode_permission(struct inode *inode, int mask)

static inline int do_inode_permission(struct vfsmount *mnt, struct inode *inode, int mask)

{

	if (unlikely(!(inode->i_opflags & IOP_FASTPERM))) {

		if (likely(mnt && inode->i_op->permission2))

			return inode->i_op->permission2(mnt, inode, mask);

		if (likely(inode->i_op->permission))

			return inode->i_op->permission(inode, mask);
@@ -414,7 +416,8 @@ static int sb_permission(struct super_block *sb, struct inode *inode, int mask) 
}



/**

 * inode_permission - Check for access rights to a given inode

 * inode_permission2 - Check for access rights to a given inode

 * @mnt:

 * @inode: Inode to check permission on

 * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)

 *
@@ -424,7 +427,7 @@ static int sb_permission(struct super_block *sb, struct inode *inode, int mask) 
 *

 * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask.

 */

int inode_permission(struct inode *inode, int mask)

int inode_permission2(struct vfsmount *mnt, struct inode *inode, int mask)

{

	int retval;
@@ -448,7 +451,7 @@ int inode_permission(struct inode *inode, int mask) 
			return -EACCES;

	}



	retval = do_inode_permission(inode, mask);

	retval = do_inode_permission(mnt, inode, mask);

	if (retval)

		return retval;
@@ -456,7 +459,14 @@ int inode_permission(struct inode *inode, int mask) 
	if (retval)

		return retval;



	return security_inode_permission(inode, mask);

	retval = security_inode_permission(inode, mask);

	return retval;

}

EXPORT_SYMBOL(inode_permission2);



int inode_permission(struct inode *inode, int mask)

{

	return inode_permission2(NULL, inode, mask);

}

EXPORT_SYMBOL(inode_permission);
@@ -1693,13 +1703,13 @@ static struct dentry *lookup_slow(const struct qstr *name, 
static inline int may_lookup(struct nameidata *nd)

{

	if (nd->flags & LOOKUP_RCU) {

		int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);

		int err = inode_permission2(nd->path.mnt, nd->inode, MAY_EXEC|MAY_NOT_BLOCK);

		if (err != -ECHILD)

			return err;

		if (unlazy_walk(nd))

			return -ECHILD;

	}

	return inode_permission(nd->inode, MAY_EXEC);

	return inode_permission2(nd->path.mnt, nd->inode, MAY_EXEC);

}



static inline int handle_dots(struct nameidata *nd, int type)
@@ -2455,8 +2465,8 @@ int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt, 
}

EXPORT_SYMBOL(vfs_path_lookup);



static int lookup_one_len_common(const char *name, struct dentry *base,

				 int len, struct qstr *this)

static int lookup_one_len_common(const char *name, struct vfsmount *mnt,

				 struct dentry *base, int len, struct qstr *this)

{

	this->name = name;

	this->len = len;
@@ -2484,7 +2494,7 @@ static int lookup_one_len_common(const char *name, struct dentry *base, 
			return err;

	}



	return inode_permission(base->d_inode, MAY_EXEC);

	return inode_permission2(mnt, base->d_inode, MAY_EXEC);

}



/**
@@ -2508,7 +2518,7 @@ struct dentry *try_lookup_one_len(const char *name, struct dentry *base, int len 


	WARN_ON_ONCE(!inode_is_locked(base->d_inode));



	err = lookup_one_len_common(name, base, len, &this);

	err = lookup_one_len_common(name, NULL, base, len, &this);

	if (err)

		return ERR_PTR(err);
@@ -2527,7 +2537,7 @@ EXPORT_SYMBOL(try_lookup_one_len); 
 *

 * The caller must hold base->i_mutex.

 */

struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)

struct dentry *lookup_one_len2(const char *name, struct vfsmount *mnt, struct dentry *base, int len)

{

	struct dentry *dentry;

	struct qstr this;
@@ -2535,13 +2545,19 @@ struct dentry *lookup_one_len(const char *name, struct dentry *base, int len) 


	WARN_ON_ONCE(!inode_is_locked(base->d_inode));



	err = lookup_one_len_common(name, base, len, &this);

	err = lookup_one_len_common(name, mnt, base, len, &this);

	if (err)

		return ERR_PTR(err);



	dentry = lookup_dcache(&this, base, 0);

	return dentry ? dentry : __lookup_slow(&this, base, 0);

}

EXPORT_SYMBOL(lookup_one_len2);



struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)

{

	return lookup_one_len2(name, NULL, base, len);

}

EXPORT_SYMBOL(lookup_one_len);



/**
@@ -2563,7 +2579,7 @@ struct dentry *lookup_one_len_unlocked(const char *name, 
	int err;

	struct dentry *ret;



	err = lookup_one_len_common(name, base, len, &this);

	err = lookup_one_len_common(name, NULL, base, len, &this);

	if (err)

		return ERR_PTR(err);
@@ -2787,7 +2803,7 @@ EXPORT_SYMBOL(__check_sticky); 
 * 11. We don't allow removal of NFS sillyrenamed files; it's handled by

 *     nfs_async_unlink().

 */

static int may_delete(struct inode *dir, struct dentry *victim, bool isdir)

static int may_delete(struct vfsmount *mnt, struct inode *dir, struct dentry *victim, bool isdir)

{

	struct inode *inode = d_backing_inode(victim);

	int error;
@@ -2804,7 +2820,7 @@ static int may_delete(struct inode *dir, struct dentry *victim, bool isdir) 


	audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);



	error = inode_permission(dir, MAY_WRITE | MAY_EXEC);

	error = inode_permission2(mnt, dir, MAY_WRITE | MAY_EXEC);

	if (error)

		return error;

	if (IS_APPEND(dir))
@@ -2836,7 +2852,7 @@ static int may_delete(struct inode *dir, struct dentry *victim, bool isdir) 
 *  4. We should have write and exec permissions on dir

 *  5. We can't do it if dir is immutable (done in permission())

 */

static inline int may_create(struct inode *dir, struct dentry *child)

static inline int may_create(struct vfsmount *mnt, struct inode *dir, struct dentry *child)

{

	struct user_namespace *s_user_ns;

	audit_inode_child(dir, child, AUDIT_TYPE_CHILD_CREATE);
@@ -2848,7 +2864,7 @@ static inline int may_create(struct inode *dir, struct dentry *child) 
	if (!kuid_has_mapping(s_user_ns, current_fsuid()) ||

	    !kgid_has_mapping(s_user_ns, current_fsgid()))

		return -EOVERFLOW;

	return inode_permission(dir, MAY_WRITE | MAY_EXEC);

	return inode_permission2(mnt, dir, MAY_WRITE | MAY_EXEC);

}



/*
@@ -2895,10 +2911,10 @@ void unlock_rename(struct dentry *p1, struct dentry *p2) 
}

EXPORT_SYMBOL(unlock_rename);



int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,

		bool want_excl)

int vfs_create2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry,

		umode_t mode, bool want_excl)

{

	int error = may_create(dir, dentry);

	int error = may_create(mnt, dir, dentry);

	if (error)

		return error;
@@ -2914,14 +2930,21 @@ int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, 
		fsnotify_create(dir, dentry);

	return error;

}

EXPORT_SYMBOL(vfs_create2);



int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,

		bool want_excl)

{

	return vfs_create2(NULL, dir, dentry, mode, want_excl);

}

EXPORT_SYMBOL(vfs_create);



int vfs_mkobj(struct dentry *dentry, umode_t mode,

int vfs_mkobj2(struct vfsmount *mnt, struct dentry *dentry, umode_t mode,

		int (*f)(struct dentry *, umode_t, void *),

		void *arg)

{

	struct inode *dir = dentry->d_parent->d_inode;

	int error = may_create(dir, dentry);

	int error = may_create(mnt, dir, dentry);

	if (error)

		return error;
@@ -2935,6 +2958,15 @@ int vfs_mkobj(struct dentry *dentry, umode_t mode, 
		fsnotify_create(dir, dentry);

	return error;

}

EXPORT_SYMBOL(vfs_mkobj2);





int vfs_mkobj(struct dentry *dentry, umode_t mode,

		int (*f)(struct dentry *, umode_t, void *),

		void *arg)

{

	return vfs_mkobj2(NULL, dentry, mode, f, arg);

}

EXPORT_SYMBOL(vfs_mkobj);



bool may_open_dev(const struct path *path)
@@ -2946,6 +2978,7 @@ bool may_open_dev(const struct path *path) 
static int may_open(const struct path *path, int acc_mode, int flag)

{

	struct dentry *dentry = path->dentry;

	struct vfsmount *mnt = path->mnt;

	struct inode *inode = dentry->d_inode;

	int error;
@@ -2970,7 +3003,7 @@ static int may_open(const struct path *path, int acc_mode, int flag) 
		break;

	}



	error = inode_permission(inode, MAY_OPEN | acc_mode);

	error = inode_permission2(mnt, inode, MAY_OPEN | acc_mode);

	if (error)

		return error;
@@ -3032,7 +3065,7 @@ static int may_o_create(const struct path *dir, struct dentry *dentry, umode_t m 
	    !kgid_has_mapping(s_user_ns, current_fsgid()))

		return -EOVERFLOW;



	error = inode_permission(dir->dentry->d_inode, MAY_WRITE | MAY_EXEC);

	error = inode_permission2(dir->mnt, dir->dentry->d_inode, MAY_WRITE | MAY_EXEC);

	if (error)

		return error;
@@ -3440,7 +3473,8 @@ struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode, int open_flag) 
	int error;



	/* we want directory to be writable */

	error = inode_permission(dir, MAY_WRITE | MAY_EXEC);

	error = inode_permission2(ERR_PTR(-EOPNOTSUPP), dir,

					MAY_WRITE | MAY_EXEC);

	if (error)

		goto out_err;

	error = -EOPNOTSUPP;
@@ -3694,9 +3728,9 @@ inline struct dentry *user_path_create(int dfd, const char __user *pathname, 
}

EXPORT_SYMBOL(user_path_create);



int vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)

int vfs_mknod2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)

{

	int error = may_create(dir, dentry);

	int error = may_create(mnt, dir, dentry);



	if (error)

		return error;
@@ -3721,6 +3755,12 @@ int vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev) 
		fsnotify_create(dir, dentry);

	return error;

}

EXPORT_SYMBOL(vfs_mknod2);



int vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)

{

	return vfs_mknod2(NULL, dir, dentry, mode, dev);

}

EXPORT_SYMBOL(vfs_mknod);



static int may_mknod(umode_t mode)
@@ -3763,12 +3803,12 @@ long do_mknodat(int dfd, const char __user *filename, umode_t mode, 
		goto out;

	switch (mode & S_IFMT) {

		case 0: case S_IFREG:

			error = vfs_create(path.dentry->d_inode,dentry,mode,true);

			error = vfs_create2(path.mnt, path.dentry->d_inode,dentry,mode,true);

			if (!error)

				ima_post_path_mknod(dentry);

			break;

		case S_IFCHR: case S_IFBLK:

			error = vfs_mknod(path.dentry->d_inode,dentry,mode,

			error = vfs_mknod2(path.mnt, path.dentry->d_inode,dentry,mode,

					new_decode_dev(dev));

			break;

		case S_IFIFO: case S_IFSOCK:
@@ -3795,9 +3835,9 @@ SYSCALL_DEFINE3(mknod, const char __user *, filename, umode_t, mode, unsigned, d 
	return do_mknodat(AT_FDCWD, filename, mode, dev);

}



int vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)

int vfs_mkdir2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry, umode_t mode)

{

	int error = may_create(dir, dentry);

	int error = may_create(mnt, dir, dentry);

	unsigned max_links = dir->i_sb->s_max_links;



	if (error)
@@ -3819,6 +3859,12 @@ int vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 
		fsnotify_mkdir(dir, dentry);

	return error;

}

EXPORT_SYMBOL(vfs_mkdir2);



int vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)

{

	return vfs_mkdir2(NULL, dir, dentry, mode);

}

EXPORT_SYMBOL(vfs_mkdir);



long do_mkdirat(int dfd, const char __user *pathname, umode_t mode)
@@ -3837,7 +3883,7 @@ long do_mkdirat(int dfd, const char __user *pathname, umode_t mode) 
		mode &= ~current_umask();

	error = security_path_mkdir(&path, dentry, mode);

	if (!error)

		error = vfs_mkdir(path.dentry->d_inode, dentry, mode);

		error = vfs_mkdir2(path.mnt, path.dentry->d_inode, dentry, mode);

	done_path_create(&path, dentry);

	if (retry_estale(error, lookup_flags)) {

		lookup_flags |= LOOKUP_REVAL;
@@ -3856,9 +3902,9 @@ SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode) 
	return do_mkdirat(AT_FDCWD, pathname, mode);

}



int vfs_rmdir(struct inode *dir, struct dentry *dentry)

int vfs_rmdir2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry)

{

	int error = may_delete(dir, dentry, 1);

	int error = may_delete(mnt, dir, dentry, 1);



	if (error)

		return error;
@@ -3893,6 +3939,12 @@ int vfs_rmdir(struct inode *dir, struct dentry *dentry) 
		d_delete(dentry);

	return error;

}

EXPORT_SYMBOL(vfs_rmdir2);



int vfs_rmdir(struct inode *dir, struct dentry *dentry)

{

	return vfs_rmdir2(NULL, dir, dentry);

}

EXPORT_SYMBOL(vfs_rmdir);



long do_rmdir(int dfd, const char __user *pathname)
@@ -3938,7 +3990,7 @@ long do_rmdir(int dfd, const char __user *pathname) 
	error = security_path_rmdir(&path, dentry);

	if (error)

		goto exit3;

	error = vfs_rmdir(path.dentry->d_inode, dentry);

	error = vfs_rmdir2(path.mnt, path.dentry->d_inode, dentry);

exit3:

	dput(dentry);

exit2:
@@ -3977,10 +4029,10 @@ SYSCALL_DEFINE1(rmdir, const char __user *, pathname) 
 * be appropriate for callers that expect the underlying filesystem not

 * to be NFS exported.

 */

int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegated_inode)

int vfs_unlink2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry, struct inode **delegated_inode)

{

	struct inode *target = dentry->d_inode;

	int error = may_delete(dir, dentry, 0);

	int error = may_delete(mnt, dir, dentry, 0);



	if (error)

		return error;
@@ -4015,6 +4067,12 @@ int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegate 


	return error;

}

EXPORT_SYMBOL(vfs_unlink2);



int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegated_inode)

{

	return vfs_unlink2(NULL, dir, dentry, delegated_inode);

}

EXPORT_SYMBOL(vfs_unlink);



/*
@@ -4060,7 +4118,7 @@ long do_unlinkat(int dfd, struct filename *name) 
		error = security_path_unlink(&path, dentry);

		if (error)

			goto exit2;

		error = vfs_unlink(path.dentry->d_inode, dentry, &delegated_inode);

		error = vfs_unlink2(path.mnt, path.dentry->d_inode, dentry, &delegated_inode);

exit2:

		dput(dentry);

	}
@@ -4110,9 +4168,9 @@ SYSCALL_DEFINE1(unlink, const char __user *, pathname) 
	return do_unlinkat(AT_FDCWD, getname(pathname));

}



int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)

int vfs_symlink2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry, const char *oldname)

{

	int error = may_create(dir, dentry);

	int error = may_create(mnt, dir, dentry);



	if (error)

		return error;
@@ -4129,6 +4187,12 @@ int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname) 
		fsnotify_create(dir, dentry);

	return error;

}

EXPORT_SYMBOL(vfs_symlink2);



int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)

{

	return vfs_symlink2(NULL, dir, dentry, oldname);

}

EXPORT_SYMBOL(vfs_symlink);



long do_symlinkat(const char __user *oldname, int newdfd,
@@ -4151,7 +4215,7 @@ long do_symlinkat(const char __user *oldname, int newdfd, 


	error = security_path_symlink(&path, dentry, from->name);

	if (!error)

		error = vfs_symlink(path.dentry->d_inode, dentry, from->name);

		error = vfs_symlink2(path.mnt, path.dentry->d_inode, dentry, from->name);

	done_path_create(&path, dentry);

	if (retry_estale(error, lookup_flags)) {

		lookup_flags |= LOOKUP_REVAL;
@@ -4192,7 +4256,7 @@ SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newn 
 * be appropriate for callers that expect the underlying filesystem not

 * to be NFS exported.

 */

int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry, struct inode **delegated_inode)

int vfs_link2(struct vfsmount *mnt, struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry, struct inode **delegated_inode)

{

	struct inode *inode = old_dentry->d_inode;

	unsigned max_links = dir->i_sb->s_max_links;
@@ -4201,7 +4265,7 @@ int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_de 
	if (!inode)

		return -ENOENT;



	error = may_create(dir, new_dentry);

	error = may_create(mnt, dir, new_dentry);

	if (error)

		return error;
@@ -4251,6 +4315,12 @@ int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_de 
		fsnotify_link(dir, inode, new_dentry);

	return error;

}

EXPORT_SYMBOL(vfs_link2);



int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry, struct inode **delegated_inode)

{

	return vfs_link2(NULL, old_dentry, dir, new_dentry, delegated_inode);

}

EXPORT_SYMBOL(vfs_link);



/*
@@ -4306,7 +4376,7 @@ int do_linkat(int olddfd, const char __user *oldname, int newdfd, 
	error = security_path_link(old_path.dentry, &new_path, new_dentry);

	if (error)

		goto out_dput;

	error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry, &delegated_inode);

	error = vfs_link2(old_path.mnt, old_path.dentry, new_path.dentry->d_inode, new_dentry, &delegated_inode);

out_dput:

	done_path_create(&new_path, new_dentry);

	if (delegated_inode) {
@@ -4388,7 +4458,8 @@ SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname 
 *	   ->i_mutex on parents, which works but leads to some truly excessive

 *	   locking].

 */

int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,

int vfs_rename2(struct vfsmount *mnt,

	       struct inode *old_dir, struct dentry *old_dentry,

	       struct inode *new_dir, struct dentry *new_dentry,

	       struct inode **delegated_inode, unsigned int flags)

{
@@ -4403,19 +4474,19 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry, 
	if (source == target)

		return 0;



	error = may_delete(old_dir, old_dentry, is_dir);

	error = may_delete(mnt, old_dir, old_dentry, is_dir);

	if (error)

		return error;



	if (!target) {

		error = may_create(new_dir, new_dentry);

		error = may_create(mnt, new_dir, new_dentry);

	} else {

		new_is_dir = d_is_dir(new_dentry);



		if (!(flags & RENAME_EXCHANGE))

			error = may_delete(new_dir, new_dentry, is_dir);

			error = may_delete(mnt, new_dir, new_dentry, is_dir);

		else

			error = may_delete(new_dir, new_dentry, new_is_dir);

			error = may_delete(mnt, new_dir, new_dentry, new_is_dir);

	}

	if (error)

		return error;
@@ -4429,12 +4500,12 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry, 
	 */

	if (new_dir != old_dir) {

		if (is_dir) {

			error = inode_permission(source, MAY_WRITE);

			error = inode_permission2(mnt, source, MAY_WRITE);

			if (error)

				return error;

		}

		if ((flags & RENAME_EXCHANGE) && new_is_dir) {

			error = inode_permission(target, MAY_WRITE);

			error = inode_permission2(mnt, target, MAY_WRITE);

			if (error)

				return error;

		}
@@ -4511,6 +4582,14 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry, 


	return error;

}

EXPORT_SYMBOL(vfs_rename2);



int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,

	       struct inode *new_dir, struct dentry *new_dentry,

	       struct inode **delegated_inode, unsigned int flags)

{

	return vfs_rename2(NULL, old_dir, old_dentry, new_dir, new_dentry, delegated_inode, flags);

}

EXPORT_SYMBOL(vfs_rename);



static int do_renameat2(int olddfd, const char __user *oldname, int newdfd,
@@ -4624,7 +4703,7 @@ static int do_renameat2(int olddfd, const char __user *oldname, int newdfd, 
				     &new_path, new_dentry, flags);

	if (error)

		goto exit5;

	error = vfs_rename(old_path.dentry->d_inode, old_dentry,

	error = vfs_rename2(old_path.mnt, old_path.dentry->d_inode, old_dentry,

			   new_path.dentry->d_inode, new_dentry,

			   &delegated_inode, flags);

exit5:
@@ -4675,7 +4754,7 @@ SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newna 


int vfs_whiteout(struct inode *dir, struct dentry *dentry)

{

	int error = may_create(dir, dentry);

	int error = may_create(NULL, dir, dentry);

	if (error)

		return error;

fs/notify/fanotify/fanotify_user.c

+1 −1
Original line number Diff line number Diff line
@@ -490,7 +490,7 @@ static int fanotify_find_path(int dfd, const char __user *filename, 
	}



	/* you can only watch an inode if you have read permissions on it */

	ret = inode_permission(path->dentry->d_inode, MAY_READ);

	ret = inode_permission2(path->mnt, path->dentry->d_inode, MAY_READ);

	if (ret)

		path_put(path);

out:

fs/notify/inotify/inotify_user.c

+1 −1
Original line number Diff line number Diff line
@@ -350,7 +350,7 @@ static int inotify_find_inode(const char __user *dirname, struct path *path, uns 
	if (error)

		return error;

	/* you can only watch an inode if you have read permissions on it */

	error = inode_permission(path->dentry->d_inode, MAY_READ);

	error = inode_permission2(path->mnt, path->dentry->d_inode, MAY_READ);

	if (error)

		path_put(path);

	return error;