R0dn3yS/android_kernel_xiaomi_sm7250
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
This reverts commit e81cea2a6f as it is
longer needed because sdcardfs is gone.

Bug: 157700134
Cc: Daniel Rosenberg <drosen@google.com>
Cc: Amit Pundir <amit.pundir@linaro.org>
Cc: Alistair Strachan <astrachan@google.com>
Cc: Yongqin Liu <yongqin.liu@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
Change-Id: Ic7f303d4353c9f03e8e7a5aad07d0a5aa5289412
This commit is contained in:
Greg Kroah-Hartman 2020-06-27 15:11:32 +02:00
parent d60170f975
commit 633920f372
11 changed files with 72 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/attr.c
View File

@ -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_permission2(mnt, inode, MAY_WRITE);
error = inode_permission(inode, MAY_WRITE);
if (error)
return error;
}

2
fs/exec.c
View File

@ -1310,7 +1310,7 @@ EXPORT_SYMBOL(flush_old_exec);
void would_dump(struct linux_binprm *bprm, struct file *file)
{
struct inode *inode = file_inode(file);
if (inode_permission2(file->f_path.mnt, inode, MAY_READ) < 0) {
if (inode_permission(inode, MAY_READ) < 0) {
struct user_namespace *old, *user_ns;
bprm->interp_flags |= BINPRM_FLAGS_ENFORCE_NONDUMP;

187
fs/namei.c
View File

@ -382,11 +382,9 @@ 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 vfsmount *mnt, struct inode *inode, int mask)
static inline int do_inode_permission(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);
@ -419,8 +417,7 @@ static int sb_permission(struct super_block *sb, struct inode *inode, int mask)
}
/**
* inode_permission2 - Check for access rights to a given inode
* @mnt:
* inode_permission - Check for access rights to a given inode
* @inode: Inode to check permission on
* @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
*
@ -430,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_permission2(struct vfsmount *mnt, struct inode *inode, int mask)
int inode_permission(struct inode *inode, int mask)
{
int retval;
@ -454,7 +451,7 @@ int inode_permission2(struct vfsmount *mnt, struct inode *inode, int mask)
return -EACCES;
}
retval = do_inode_permission(mnt, inode, mask);
retval = do_inode_permission(inode, mask);
if (retval)
return retval;
@ -462,14 +459,7 @@ int inode_permission2(struct vfsmount *mnt, struct inode *inode, int mask)
if (retval)
return retval;
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);
return security_inode_permission(inode, mask);
}
EXPORT_SYMBOL(inode_permission);
@ -1788,13 +1778,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_permission2(nd->path.mnt, nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
if (err != -ECHILD)
return err;
if (unlazy_walk(nd))
return -ECHILD;
}
return inode_permission2(nd->path.mnt, nd->inode, MAY_EXEC);
return inode_permission(nd->inode, MAY_EXEC);
}
static inline int handle_dots(struct nameidata *nd, int type)
@ -2550,8 +2540,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 vfsmount *mnt,
struct dentry *base, int len, struct qstr *this)
static int lookup_one_len_common(const char *name, struct dentry *base,
int len, struct qstr *this)
{
this->name = name;
this->len = len;
@ -2579,7 +2569,7 @@ static int lookup_one_len_common(const char *name, struct vfsmount *mnt,
return err;
}
return inode_permission2(mnt, base->d_inode, MAY_EXEC);
return inode_permission(base->d_inode, MAY_EXEC);
}
/**
@ -2603,7 +2593,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, NULL, base, len, &this);
err = lookup_one_len_common(name, base, len, &this);
if (err)
return ERR_PTR(err);
@ -2622,7 +2612,7 @@ EXPORT_SYMBOL(try_lookup_one_len);
*
* The caller must hold base->i_mutex.
*/
struct dentry *lookup_one_len2(const char *name, struct vfsmount *mnt, struct dentry *base, int len)
struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
{
struct dentry *dentry;
struct qstr this;
@ -2630,19 +2620,13 @@ struct dentry *lookup_one_len2(const char *name, struct vfsmount *mnt, struct de
WARN_ON_ONCE(!inode_is_locked(base->d_inode));
err = lookup_one_len_common(name, mnt, base, len, &this);
err = lookup_one_len_common(name, 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);
/**
@ -2664,7 +2648,7 @@ struct dentry *lookup_one_len_unlocked(const char *name,
int err;
struct dentry *ret;
err = lookup_one_len_common(name, NULL, base, len, &this);
err = lookup_one_len_common(name, base, len, &this);
if (err)
return ERR_PTR(err);
@ -2888,7 +2872,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 vfsmount *mnt, struct inode *dir, struct dentry *victim, bool isdir)
static int may_delete(struct inode *dir, struct dentry *victim, bool isdir)
{
struct inode *inode = d_backing_inode(victim);
int error;
@ -2905,7 +2889,7 @@ static int may_delete(struct vfsmount *mnt, struct inode *dir, struct dentry *vi
audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
error = inode_permission2(mnt, dir, MAY_WRITE | MAY_EXEC);
error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
if (error)
return error;
if (IS_APPEND(dir))
@ -2937,7 +2921,7 @@ static int may_delete(struct vfsmount *mnt, struct inode *dir, struct dentry *vi
* 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 vfsmount *mnt, struct inode *dir, struct dentry *child)
static inline int may_create(struct inode *dir, struct dentry *child)
{
struct user_namespace *s_user_ns;
audit_inode_child(dir, child, AUDIT_TYPE_CHILD_CREATE);
@ -2949,7 +2933,7 @@ static inline int may_create(struct vfsmount *mnt, struct inode *dir, struct den
if (!kuid_has_mapping(s_user_ns, current_fsuid()) ||
!kgid_has_mapping(s_user_ns, current_fsgid()))
return -EOVERFLOW;
return inode_permission2(mnt, dir, MAY_WRITE | MAY_EXEC);
return inode_permission(dir, MAY_WRITE | MAY_EXEC);
}
/*
@ -2996,10 +2980,10 @@ void unlock_rename(struct dentry *p1, struct dentry *p2)
}
EXPORT_SYMBOL(unlock_rename);
int vfs_create2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry,
umode_t mode, bool want_excl)
int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
bool want_excl)
{
int error = may_create(mnt, dir, dentry);
int error = may_create(dir, dentry);
if (error)
return error;
@ -3015,21 +2999,14 @@ int vfs_create2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry,
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_mkobj2(struct vfsmount *mnt, struct dentry *dentry, umode_t mode,
int vfs_mkobj(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(mnt, dir, dentry);
int error = may_create(dir, dentry);
if (error)
return error;
@ -3043,15 +3020,6 @@ int vfs_mkobj2(struct vfsmount *mnt, 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)
@ -3063,7 +3031,6 @@ 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;
@ -3088,7 +3055,7 @@ static int may_open(const struct path *path, int acc_mode, int flag)
break;
}
error = inode_permission2(mnt, inode, MAY_OPEN | acc_mode);
error = inode_permission(inode, MAY_OPEN | acc_mode);
if (error)
return error;
@ -3150,7 +3117,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_permission2(dir->mnt, dir->dentry->d_inode, MAY_WRITE | MAY_EXEC);
error = inode_permission(dir->dentry->d_inode, MAY_WRITE | MAY_EXEC);
if (error)
return error;
@ -3560,8 +3527,7 @@ struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode, int open_flag)
int error;
/* we want directory to be writable */
error = inode_permission2(ERR_PTR(-EOPNOTSUPP), dir,
MAY_WRITE | MAY_EXEC);
error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
if (error)
goto out_err;
error = -EOPNOTSUPP;
@ -3815,9 +3781,9 @@ inline struct dentry *user_path_create(int dfd, const char __user *pathname,
}
EXPORT_SYMBOL(user_path_create);
int vfs_mknod2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
int vfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
{
int error = may_create(mnt, dir, dentry);
int error = may_create(dir, dentry);
if (error)
return error;
@ -3841,12 +3807,6 @@ int vfs_mknod2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry, u
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)
@ -3889,12 +3849,12 @@ retry:
goto out;
switch (mode & S_IFMT) {
case 0: case S_IFREG:
error = vfs_create2(path.mnt, path.dentry->d_inode,dentry,mode,true);
error = vfs_create(path.dentry->d_inode,dentry,mode,true);
if (!error)
ima_post_path_mknod(dentry);
break;
case S_IFCHR: case S_IFBLK:
error = vfs_mknod2(path.mnt, path.dentry->d_inode,dentry,mode,
error = vfs_mknod(path.dentry->d_inode,dentry,mode,
new_decode_dev(dev));
break;
case S_IFIFO: case S_IFSOCK:
@ -3921,9 +3881,9 @@ SYSCALL_DEFINE3(mknod, const char __user *, filename, umode_t, mode, unsigned, d
return do_mknodat(AT_FDCWD, filename, mode, dev);
}
int vfs_mkdir2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry, umode_t mode)
int vfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
{
int error = may_create(mnt, dir, dentry);
int error = may_create(dir, dentry);
unsigned max_links = dir->i_sb->s_max_links;
if (error)
@ -3945,12 +3905,6 @@ int vfs_mkdir2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry, u
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)
@ -3969,7 +3923,7 @@ retry:
mode &= ~current_umask();
error = security_path_mkdir(&path, dentry, mode);
if (!error)
error = vfs_mkdir2(path.mnt, path.dentry->d_inode, dentry, mode);
error = vfs_mkdir(path.dentry->d_inode, dentry, mode);
done_path_create(&path, dentry);
if (retry_estale(error, lookup_flags)) {
lookup_flags |= LOOKUP_REVAL;
@ -3988,9 +3942,9 @@ SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode)
return do_mkdirat(AT_FDCWD, pathname, mode);
}
int vfs_rmdir2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry)
int vfs_rmdir(struct inode *dir, struct dentry *dentry)
{
int error = may_delete(mnt, dir, dentry, 1);
int error = may_delete(dir, dentry, 1);
if (error)
return error;
@ -4025,12 +3979,6 @@ out:
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)
@ -4076,7 +4024,7 @@ retry:
error = security_path_rmdir(&path, dentry);
if (error)
goto exit3;
error = vfs_rmdir2(path.mnt, path.dentry->d_inode, dentry);
error = vfs_rmdir(path.dentry->d_inode, dentry);
exit3:
dput(dentry);
exit2:
@ -4115,10 +4063,10 @@ SYSCALL_DEFINE1(rmdir, const char __user *, pathname)
* be appropriate for callers that expect the underlying filesystem not
* to be NFS exported.
*/
int vfs_unlink2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry, struct inode **delegated_inode)
int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegated_inode)
{
struct inode *target = dentry->d_inode;
int error = may_delete(mnt, dir, dentry, 0);
int error = may_delete(dir, dentry, 0);
if (error)
return error;
@ -4153,12 +4101,6 @@ out:
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);
/*
@ -4204,7 +4146,7 @@ retry_deleg:
error = security_path_unlink(&path, dentry);
if (error)
goto exit2;
error = vfs_unlink2(path.mnt, path.dentry->d_inode, dentry, &delegated_inode);
error = vfs_unlink(path.dentry->d_inode, dentry, &delegated_inode);
exit2:
dput(dentry);
}
@ -4254,9 +4196,9 @@ SYSCALL_DEFINE1(unlink, const char __user *, pathname)
return do_unlinkat(AT_FDCWD, getname(pathname));
}
int vfs_symlink2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry, const char *oldname)
int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
{
int error = may_create(mnt, dir, dentry);
int error = may_create(dir, dentry);
if (error)
return error;
@ -4273,12 +4215,6 @@ int vfs_symlink2(struct vfsmount *mnt, struct inode *dir, struct dentry *dentry,
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,
@ -4301,7 +4237,7 @@ retry:
error = security_path_symlink(&path, dentry, from->name);
if (!error)
error = vfs_symlink2(path.mnt, path.dentry->d_inode, dentry, from->name);
error = vfs_symlink(path.dentry->d_inode, dentry, from->name);
done_path_create(&path, dentry);
if (retry_estale(error, lookup_flags)) {
lookup_flags |= LOOKUP_REVAL;
@ -4342,7 +4278,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_link2(struct vfsmount *mnt, struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry, struct inode **delegated_inode)
int vfs_link(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;
@ -4351,7 +4287,7 @@ int vfs_link2(struct vfsmount *mnt, struct dentry *old_dentry, struct inode *dir
if (!inode)
return -ENOENT;
error = may_create(mnt, dir, new_dentry);
error = may_create(dir, new_dentry);
if (error)
return error;
@ -4401,12 +4337,6 @@ int vfs_link2(struct vfsmount *mnt, struct dentry *old_dentry, struct inode *dir
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);
/*
@ -4462,7 +4392,7 @@ retry:
error = security_path_link(old_path.dentry, &new_path, new_dentry);
if (error)
goto out_dput;
error = vfs_link2(old_path.mnt, old_path.dentry, new_path.dentry->d_inode, new_dentry, &delegated_inode);
error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry, &delegated_inode);
out_dput:
done_path_create(&new_path, new_dentry);
if (delegated_inode) {
@ -4544,8 +4474,7 @@ 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_rename2(struct vfsmount *mnt,
struct inode *old_dir, struct dentry *old_dentry,
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)
{
@ -4560,19 +4489,19 @@ int vfs_rename2(struct vfsmount *mnt,
if (source == target)
return 0;
error = may_delete(mnt, old_dir, old_dentry, is_dir);
error = may_delete(old_dir, old_dentry, is_dir);
if (error)
return error;
if (!target) {
error = may_create(mnt, new_dir, new_dentry);
error = may_create(new_dir, new_dentry);
} else {
new_is_dir = d_is_dir(new_dentry);
if (!(flags & RENAME_EXCHANGE))
error = may_delete(mnt, new_dir, new_dentry, is_dir);
error = may_delete(new_dir, new_dentry, is_dir);
else
error = may_delete(mnt, new_dir, new_dentry, new_is_dir);
error = may_delete(new_dir, new_dentry, new_is_dir);
}
if (error)
return error;
@ -4586,12 +4515,12 @@ int vfs_rename2(struct vfsmount *mnt,
*/
if (new_dir != old_dir) {
if (is_dir) {
error = inode_permission2(mnt, source, MAY_WRITE);
error = inode_permission(source, MAY_WRITE);
if (error)
return error;
}
if ((flags & RENAME_EXCHANGE) && new_is_dir) {
error = inode_permission2(mnt, target, MAY_WRITE);
error = inode_permission(target, MAY_WRITE);
if (error)
return error;
}
@ -4668,14 +4597,6 @@ out:
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,
@ -4789,7 +4710,7 @@ retry_deleg:
&new_path, new_dentry, flags);
if (error)
goto exit5;
error = vfs_rename2(old_path.mnt, old_path.dentry->d_inode, old_dentry,
error = vfs_rename(old_path.dentry->d_inode, old_dentry,
new_path.dentry->d_inode, new_dentry,
&delegated_inode, flags);
exit5:
@ -4840,7 +4761,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(NULL, dir, dentry);
int error = may_create(dir, dentry);
if (error)
return error;

2
fs/notify/fanotify/fanotify_user.c
View File

@ -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_permission2(path->mnt, path->dentry->d_inode, MAY_READ);
ret = inode_permission(path->dentry->d_inode, MAY_READ);
if (ret)
path_put(path);
out:

2
fs/notify/inotify/inotify_user.c
View File

@ -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_permission2(path->mnt, path->dentry->d_inode, MAY_READ);
error = inode_permission(path->dentry->d_inode, MAY_READ);
if (error)
path_put(path);
return error;

13
fs/open.c
View File

@ -89,7 +89,7 @@ long vfs_truncate(const struct path *path, loff_t length)
if (error)
goto out;
error = inode_permission2(mnt, inode, MAY_WRITE);
error = inode_permission(inode, MAY_WRITE);
if (error)
goto mnt_drop_write_and_out;
@ -359,7 +359,6 @@ long do_faccessat(int dfd, const char __user *filename, int mode)
struct cred *override_cred;
struct path path;
struct inode *inode;
struct vfsmount *mnt;
int res;
unsigned int lookup_flags = LOOKUP_FOLLOW;
@ -409,7 +408,6 @@ retry:
goto out;
inode = d_backing_inode(path.dentry);
mnt = path.mnt;
if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
/*
@ -421,7 +419,7 @@ retry:
goto out_path_release;
}
res = inode_permission2(mnt, inode, mode | MAY_ACCESS);
res = inode_permission(inode, mode | MAY_ACCESS);
/* SuS v2 requires we report a read only fs too */
if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
goto out_path_release;
@ -470,7 +468,7 @@ retry:
if (error)
goto out;
error = inode_permission2(path.mnt, path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
if (error)
goto dput_and_out;
@ -504,8 +502,7 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
if (!d_can_lookup(f.file->f_path.dentry))
goto out_putf;
error = inode_permission2(f.file->f_path.mnt, file_inode(f.file),
MAY_EXEC | MAY_CHDIR);
error = inode_permission(file_inode(f.file), MAY_EXEC | MAY_CHDIR);
if (!error)
set_fs_pwd(current->fs, &f.file->f_path);
out_putf:
@ -524,7 +521,7 @@ retry:
if (error)
goto out;
error = inode_permission2(path.mnt, path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_CHDIR);
if (error)
goto dput_and_out;

2
fs/xattr.c
View File

@ -130,7 +130,7 @@ xattr_permission(struct inode *inode, const char *name, int mask)
return -EPERM;
}
return inode_permission2(ERR_PTR(-EOPNOTSUPP), inode, mask);
return inode_permission(inode, mask);
}
int

13
include/linux/fs.h
View File

@ -1692,21 +1692,13 @@ extern bool inode_owner_or_capable(const struct inode *inode);
* VFS helper functions..
*/
extern int vfs_create(struct inode *, struct dentry *, umode_t, bool);
extern int vfs_create2(struct vfsmount *, struct inode *, struct dentry *, umode_t, bool);
extern int vfs_mkdir(struct inode *, struct dentry *, umode_t);
extern int vfs_mkdir2(struct vfsmount *, struct inode *, struct dentry *, umode_t);
extern int vfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
extern int vfs_mknod2(struct vfsmount *, struct inode *, struct dentry *, umode_t, dev_t);
extern int vfs_symlink(struct inode *, struct dentry *, const char *);
extern int vfs_symlink2(struct vfsmount *, struct inode *, struct dentry *, const char *);
extern int vfs_link(struct dentry *, struct inode *, struct dentry *, struct inode **);
extern int vfs_link2(struct vfsmount *, struct dentry *, struct inode *, struct dentry *, struct inode **);
extern int vfs_rmdir(struct inode *, struct dentry *);
extern int vfs_rmdir2(struct vfsmount *, struct inode *, struct dentry *);
extern int vfs_unlink(struct inode *, struct dentry *, struct inode **);
extern int vfs_unlink2(struct vfsmount *, struct inode *, struct dentry *, struct inode **);
extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **, unsigned int);
extern int vfs_rename2(struct vfsmount *, struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **, unsigned int);
extern int vfs_whiteout(struct inode *, struct dentry *);
extern struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode,
@ -1715,9 +1707,6 @@ extern struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode,
int vfs_mkobj(struct dentry *, umode_t,
int (*f)(struct dentry *, umode_t, void *),
void *);
int vfs_mkobj2(struct vfsmount *, struct dentry *, umode_t,
int (*f)(struct dentry *, umode_t, void *),
void *);
extern long vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
@ -1853,7 +1842,6 @@ struct inode_operations {
struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
const char * (*get_link) (struct dentry *, struct inode *, struct delayed_call *);
int (*permission) (struct inode *, int);
int (*permission2) (struct vfsmount *, struct inode *, int);
struct posix_acl * (*get_acl)(struct inode *, int);
int (*readlink) (struct dentry *, char __user *,int);
@ -2866,7 +2854,6 @@ extern sector_t bmap(struct inode *, sector_t);
extern int notify_change(struct dentry *, struct iattr *, struct inode **);
extern int notify_change2(struct vfsmount *, struct dentry *, struct iattr *, struct inode **);
extern int inode_permission(struct inode *, int);
extern int inode_permission2(struct vfsmount *, struct inode *, int);
extern int generic_permission(struct inode *, int);
extern int __check_sticky(struct inode *dir, struct inode *inode);

1
include/linux/namei.h
View File

@ -83,7 +83,6 @@ extern int kern_path_mountpoint(int, const char *, struct path *, unsigned int);
extern struct dentry *try_lookup_one_len(const char *, struct dentry *, int);
extern struct dentry *lookup_one_len(const char *, struct dentry *, int);
extern struct dentry *lookup_one_len2(const char *, struct vfsmount *mnt, struct dentry *, int);
extern struct dentry *lookup_one_len_unlocked(const char *, struct dentry *, int);
extern int follow_down_one(struct path *);

14
ipc/mqueue.c
View File

@ -738,7 +738,7 @@ static void remove_notification(struct mqueue_inode_info *info)
info->notify_user_ns = NULL;
}
static int prepare_open(struct vfsmount *mnt, struct dentry *dentry, int oflag, int ro,
static int prepare_open(struct dentry *dentry, int oflag, int ro,
umode_t mode, struct filename *name,
struct mq_attr *attr)
{
@ -752,7 +752,7 @@ static int prepare_open(struct vfsmount *mnt, struct dentry *dentry, int oflag,
if (ro)
return ro;
audit_inode_parent_hidden(name, dentry->d_parent);
return vfs_mkobj2(mnt, dentry, mode & ~current_umask(),
return vfs_mkobj(dentry, mode & ~current_umask(),
mqueue_create_attr, attr);
}
/* it already existed */
@ -762,7 +762,7 @@ static int prepare_open(struct vfsmount *mnt, struct dentry *dentry, int oflag,
if ((oflag & O_ACCMODE) == (O_RDWR | O_WRONLY))
return -EINVAL;
acc = oflag2acc[oflag & O_ACCMODE];
return inode_permission2(mnt, d_inode(dentry), acc);
return inode_permission(d_inode(dentry), acc);
}
static int do_mq_open(const char __user *u_name, int oflag, umode_t mode,
@ -786,13 +786,13 @@ static int do_mq_open(const char __user *u_name, int oflag, umode_t mode,
ro = mnt_want_write(mnt); /* we'll drop it in any case */
inode_lock(d_inode(root));
path.dentry = lookup_one_len2(name->name, mnt, root, strlen(name->name));
path.dentry = lookup_one_len(name->name, root, strlen(name->name));
if (IS_ERR(path.dentry)) {
error = PTR_ERR(path.dentry);
goto out_putfd;
}
path.mnt = mntget(mnt);
error = prepare_open(path.mnt, path.dentry, oflag, ro, mode, name, attr);
error = prepare_open(path.dentry, oflag, ro, mode, name, attr);
if (!error) {
struct file *file = dentry_open(&path, oflag, current_cred());
if (!IS_ERR(file))
@ -842,7 +842,7 @@ SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name)
if (err)
goto out_name;
inode_lock_nested(d_inode(mnt->mnt_root), I_MUTEX_PARENT);
dentry = lookup_one_len2(name->name, mnt, mnt->mnt_root,
dentry = lookup_one_len(name->name, mnt->mnt_root,
strlen(name->name));
if (IS_ERR(dentry)) {
err = PTR_ERR(dentry);
@ -854,7 +854,7 @@ SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name)
err = -ENOENT;
} else {
ihold(inode);
err = vfs_unlink2(mnt, d_inode(dentry->d_parent), dentry, NULL);
err = vfs_unlink(d_inode(dentry->d_parent), dentry, NULL);
}
dput(dentry);

2
security/inode.c
View File

@ -127,7 +127,7 @@ static struct dentry *securityfs_create_dentry(const char *name, umode_t mode,
dir = d_inode(parent);
inode_lock(dir);
dentry = lookup_one_len2(name, mount, parent, strlen(name));
dentry = lookup_one_len(name, parent, strlen(name));
if (IS_ERR(dentry))
goto out;