for-5.15/io_uring-vfs-2021-08-30
-----BEGIN PGP SIGNATURE----- iQJEBAABCAAuFiEEwPw5LcreJtl1+l5K99NY+ylx4KYFAmEs8fUQHGF4Ym9lQGtl cm5lbC5kawAKCRD301j7KXHgpio4D/9cGrHIbbZsuDIHzhaK2JIUrSG7G4GkcaG/ NAqbOp7KvF+1elMY08DWLT0nnFqHM7REHIS4Lv55KCNtktTFfdYmxso4lPrRu67o MNbMJcEAglgIDw0xP4MfP/vZ0ftXJv8+OXSfL51pD4U40nWIZVpqn8WbWKRqjhGf nQhiANbl2mO2Ec7I/UgAIqwczQnF5HveCkX5106dAppma8yEH+v2TkvZyZp/TCU3 h0ec26hLi+4QRBFm4O0yrVWj1gMS7yfHuEFSGw+jhp/WNTpH9A5pXFQjn7pIyJNi uqrwM7knrod9ZH2pE1825w0TrbqkOdcZCo+/NvJHOAy03LUBJ/9qDc+JJUWsEmLZ cpd8auaCfuAFx6ForHmKd+Pw1bANebWBMsClyQSh38+fsJ9myci3c3tkkzmO+dSW G+rZZochiG4nFSl+CvlUoFfztuu8rdbOLKI/9usPMHNcDiY4yAAmz80B9uQdtQp7 tRLqegplsDODefLNvl0/Uj7WFJl6w5furchTXPmc+GSPFc+mpW08Olh7ScaCyD8c a8YXaQi5hwuUR1N7uW65Df/HGMbIDvxOStcurIakP0mOSvRKrojZgQhbJ8zuCG4y cRCwRUzvreNIoKK2ZxEvhLjhE5POaWgy6AtN/UI9k9BeVGQdboKVBGvub5Mv+ZKE HpchbANk8Q== =T7Zv -----END PGP SIGNATURE----- Merge tag 'for-5.15/io_uring-vfs-2021-08-30' of git://git.kernel.dk/linux-block Pull io_uring mkdirat/symlinkat/linkat support from Jens Axboe: "This adds io_uring support for mkdirat, symlinkat, and linkat" * tag 'for-5.15/io_uring-vfs-2021-08-30' of git://git.kernel.dk/linux-block: io_uring: add support for IORING_OP_LINKAT io_uring: add support for IORING_OP_SYMLINKAT io_uring: add support for IORING_OP_MKDIRAT namei: update do_*() helpers to return ints namei: make do_linkat() take struct filename namei: add getname_uflags() namei: make do_symlinkat() take struct filename namei: make do_mknodat() take struct filename namei: make do_mkdirat() take struct filename namei: change filename_parentat() calling conventions namei: ignore ERR/NULL names in putname()
This commit is contained in:
Linus Torvalds
commit
b91db6a0b5
@ -2070,10 +2070,8 @@ SYSCALL_DEFINE5(execveat,
|
||||
const char __user *const __user *, envp,
|
||||
int, flags)
|
||||
{
|
||||
int lookup_flags = (flags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;
|
||||
|
||||
return do_execveat(fd,
|
||||
getname_flags(filename, lookup_flags, NULL),
|
||||
getname_uflags(filename, flags),
|
||||
argv, envp, flags);
|
||||
}
|
||||
|
||||
@ -2091,10 +2089,8 @@ COMPAT_SYSCALL_DEFINE5(execveat, int, fd,
|
||||
const compat_uptr_t __user *, envp,
|
||||
int, flags)
|
||||
{
|
||||
int lookup_flags = (flags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;
|
||||
|
||||
return compat_do_execveat(fd,
|
||||
getname_flags(filename, lookup_flags, NULL),
|
||||
getname_uflags(filename, flags),
|
||||
argv, envp, flags);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -71,11 +71,15 @@ extern int filename_lookup(int dfd, struct filename *name, unsigned flags,
|
||||
struct path *path, struct path *root);
|
||||
extern int vfs_path_lookup(struct dentry *, struct vfsmount *,
|
||||
const char *, unsigned int, struct path *);
|
||||
long do_rmdir(int dfd, struct filename *name);
|
||||
long do_unlinkat(int dfd, struct filename *name);
|
||||
int do_rmdir(int dfd, struct filename *name);
|
||||
int do_unlinkat(int dfd, struct filename *name);
|
||||
int may_linkat(struct user_namespace *mnt_userns, struct path *link);
|
||||
int do_renameat2(int olddfd, struct filename *oldname, int newdfd,
|
||||
struct filename *newname, unsigned int flags);
|
||||
int do_mkdirat(int dfd, struct filename *name, umode_t mode);
|
||||
int do_symlinkat(struct filename *from, int newdfd, struct filename *to);
|
||||
int do_linkat(int olddfd, struct filename *old, int newdfd,
|
||||
struct filename *new, int flags);
|
||||
|
||||
/*
|
||||
* namespace.c
|
||||
|
||||
198
fs/io_uring.c
198
fs/io_uring.c
@ -667,6 +667,29 @@ struct io_unlink {
|
||||
struct filename *filename;
|
||||
};
|
||||
|
||||
struct io_mkdir {
|
||||
struct file *file;
|
||||
int dfd;
|
||||
umode_t mode;
|
||||
struct filename *filename;
|
||||
};
|
||||
|
||||
struct io_symlink {
|
||||
struct file *file;
|
||||
int new_dfd;
|
||||
struct filename *oldpath;
|
||||
struct filename *newpath;
|
||||
};
|
||||
|
||||
struct io_hardlink {
|
||||
struct file *file;
|
||||
int old_dfd;
|
||||
int new_dfd;
|
||||
struct filename *oldpath;
|
||||
struct filename *newpath;
|
||||
int flags;
|
||||
};
|
||||
|
||||
struct io_completion {
|
||||
struct file *file;
|
||||
u32 cflags;
|
||||
@ -826,6 +849,9 @@ struct io_kiocb {
|
||||
struct io_shutdown shutdown;
|
||||
struct io_rename rename;
|
||||
struct io_unlink unlink;
|
||||
struct io_mkdir mkdir;
|
||||
struct io_symlink symlink;
|
||||
struct io_hardlink hardlink;
|
||||
/* use only after cleaning per-op data, see io_clean_op() */
|
||||
struct io_completion compl;
|
||||
};
|
||||
@ -1037,6 +1063,9 @@ static const struct io_op_def io_op_defs[] = {
|
||||
},
|
||||
[IORING_OP_RENAMEAT] = {},
|
||||
[IORING_OP_UNLINKAT] = {},
|
||||
[IORING_OP_MKDIRAT] = {},
|
||||
[IORING_OP_SYMLINKAT] = {},
|
||||
[IORING_OP_LINKAT] = {},
|
||||
};
|
||||
|
||||
/* requests with any of those set should undergo io_disarm_next() */
|
||||
@ -3680,6 +3709,149 @@ static int io_unlinkat(struct io_kiocb *req, unsigned int issue_flags)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int io_mkdirat_prep(struct io_kiocb *req,
|
||||
const struct io_uring_sqe *sqe)
|
||||
{
|
||||
struct io_mkdir *mkd = &req->mkdir;
|
||||
const char __user *fname;
|
||||
|
||||
if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
|
||||
return -EINVAL;
|
||||
if (sqe->ioprio || sqe->off || sqe->rw_flags || sqe->buf_index ||
|
||||
sqe->splice_fd_in)
|
||||
return -EINVAL;
|
||||
if (unlikely(req->flags & REQ_F_FIXED_FILE))
|
||||
return -EBADF;
|
||||
|
||||
mkd->dfd = READ_ONCE(sqe->fd);
|
||||
mkd->mode = READ_ONCE(sqe->len);
|
||||
|
||||
fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
|
||||
mkd->filename = getname(fname);
|
||||
if (IS_ERR(mkd->filename))
|
||||
return PTR_ERR(mkd->filename);
|
||||
|
||||
req->flags |= REQ_F_NEED_CLEANUP;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int io_mkdirat(struct io_kiocb *req, int issue_flags)
|
||||
{
|
||||
struct io_mkdir *mkd = &req->mkdir;
|
||||
int ret;
|
||||
|
||||
if (issue_flags & IO_URING_F_NONBLOCK)
|
||||
return -EAGAIN;
|
||||
|
||||
ret = do_mkdirat(mkd->dfd, mkd->filename, mkd->mode);
|
||||
|
||||
req->flags &= ~REQ_F_NEED_CLEANUP;
|
||||
if (ret < 0)
|
||||
req_set_fail(req);
|
||||
io_req_complete(req, ret);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int io_symlinkat_prep(struct io_kiocb *req,
|
||||
const struct io_uring_sqe *sqe)
|
||||
{
|
||||
struct io_symlink *sl = &req->symlink;
|
||||
const char __user *oldpath, *newpath;
|
||||
|
||||
if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
|
||||
return -EINVAL;
|
||||
if (sqe->ioprio || sqe->len || sqe->rw_flags || sqe->buf_index ||
|
||||
sqe->splice_fd_in)
|
||||
return -EINVAL;
|
||||
if (unlikely(req->flags & REQ_F_FIXED_FILE))
|
||||
return -EBADF;
|
||||
|
||||
sl->new_dfd = READ_ONCE(sqe->fd);
|
||||
oldpath = u64_to_user_ptr(READ_ONCE(sqe->addr));
|
||||
newpath = u64_to_user_ptr(READ_ONCE(sqe->addr2));
|
||||
|
||||
sl->oldpath = getname(oldpath);
|
||||
if (IS_ERR(sl->oldpath))
|
||||
return PTR_ERR(sl->oldpath);
|
||||
|
||||
sl->newpath = getname(newpath);
|
||||
if (IS_ERR(sl->newpath)) {
|
||||
putname(sl->oldpath);
|
||||
return PTR_ERR(sl->newpath);
|
||||
}
|
||||
|
||||
req->flags |= REQ_F_NEED_CLEANUP;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int io_symlinkat(struct io_kiocb *req, int issue_flags)
|
||||
{
|
||||
struct io_symlink *sl = &req->symlink;
|
||||
int ret;
|
||||
|
||||
if (issue_flags & IO_URING_F_NONBLOCK)
|
||||
return -EAGAIN;
|
||||
|
||||
ret = do_symlinkat(sl->oldpath, sl->new_dfd, sl->newpath);
|
||||
|
||||
req->flags &= ~REQ_F_NEED_CLEANUP;
|
||||
if (ret < 0)
|
||||
req_set_fail(req);
|
||||
io_req_complete(req, ret);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int io_linkat_prep(struct io_kiocb *req,
|
||||
const struct io_uring_sqe *sqe)
|
||||
{
|
||||
struct io_hardlink *lnk = &req->hardlink;
|
||||
const char __user *oldf, *newf;
|
||||
|
||||
if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
|
||||
return -EINVAL;
|
||||
if (sqe->ioprio || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in)
|
||||
return -EINVAL;
|
||||
if (unlikely(req->flags & REQ_F_FIXED_FILE))
|
||||
return -EBADF;
|
||||
|
||||
lnk->old_dfd = READ_ONCE(sqe->fd);
|
||||
lnk->new_dfd = READ_ONCE(sqe->len);
|
||||
oldf = u64_to_user_ptr(READ_ONCE(sqe->addr));
|
||||
newf = u64_to_user_ptr(READ_ONCE(sqe->addr2));
|
||||
lnk->flags = READ_ONCE(sqe->hardlink_flags);
|
||||
|
||||
lnk->oldpath = getname(oldf);
|
||||
if (IS_ERR(lnk->oldpath))
|
||||
return PTR_ERR(lnk->oldpath);
|
||||
|
||||
lnk->newpath = getname(newf);
|
||||
if (IS_ERR(lnk->newpath)) {
|
||||
putname(lnk->oldpath);
|
||||
return PTR_ERR(lnk->newpath);
|
||||
}
|
||||
|
||||
req->flags |= REQ_F_NEED_CLEANUP;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int io_linkat(struct io_kiocb *req, int issue_flags)
|
||||
{
|
||||
struct io_hardlink *lnk = &req->hardlink;
|
||||
int ret;
|
||||
|
||||
if (issue_flags & IO_URING_F_NONBLOCK)
|
||||
return -EAGAIN;
|
||||
|
||||
ret = do_linkat(lnk->old_dfd, lnk->oldpath, lnk->new_dfd,
|
||||
lnk->newpath, lnk->flags);
|
||||
|
||||
req->flags &= ~REQ_F_NEED_CLEANUP;
|
||||
if (ret < 0)
|
||||
req_set_fail(req);
|
||||
io_req_complete(req, ret);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int io_shutdown_prep(struct io_kiocb *req,
|
||||
const struct io_uring_sqe *sqe)
|
||||
{
|
||||
@ -6169,6 +6341,12 @@ static int io_req_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
|
||||
return io_renameat_prep(req, sqe);
|
||||
case IORING_OP_UNLINKAT:
|
||||
return io_unlinkat_prep(req, sqe);
|
||||
case IORING_OP_MKDIRAT:
|
||||
return io_mkdirat_prep(req, sqe);
|
||||
case IORING_OP_SYMLINKAT:
|
||||
return io_symlinkat_prep(req, sqe);
|
||||
case IORING_OP_LINKAT:
|
||||
return io_linkat_prep(req, sqe);
|
||||
}
|
||||
|
||||
printk_once(KERN_WARNING "io_uring: unhandled opcode %d\n",
|
||||
@ -6332,6 +6510,17 @@ static void io_clean_op(struct io_kiocb *req)
|
||||
case IORING_OP_UNLINKAT:
|
||||
putname(req->unlink.filename);
|
||||
break;
|
||||
case IORING_OP_MKDIRAT:
|
||||
putname(req->mkdir.filename);
|
||||
break;
|
||||
case IORING_OP_SYMLINKAT:
|
||||
putname(req->symlink.oldpath);
|
||||
putname(req->symlink.newpath);
|
||||
break;
|
||||
case IORING_OP_LINKAT:
|
||||
putname(req->hardlink.oldpath);
|
||||
putname(req->hardlink.newpath);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ((req->flags & REQ_F_POLLED) && req->apoll) {
|
||||
@ -6460,6 +6649,15 @@ static int io_issue_sqe(struct io_kiocb *req, unsigned int issue_flags)
|
||||
case IORING_OP_UNLINKAT:
|
||||
ret = io_unlinkat(req, issue_flags);
|
||||
break;
|
||||
case IORING_OP_MKDIRAT:
|
||||
ret = io_mkdirat(req, issue_flags);
|
||||
break;
|
||||
case IORING_OP_SYMLINKAT:
|
||||
ret = io_symlinkat(req, issue_flags);
|
||||
break;
|
||||
case IORING_OP_LINKAT:
|
||||
ret = io_linkat(req, issue_flags);
|
||||
break;
|
||||
default:
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
|
||||
239
fs/namei.c
239
fs/namei.c
@ -203,6 +203,14 @@ getname_flags(const char __user *filename, int flags, int *empty)
|
||||
return result;
|
||||
}
|
||||
|
||||
struct filename *
|
||||
getname_uflags(const char __user *filename, int uflags)
|
||||
{
|
||||
int flags = (uflags & AT_EMPTY_PATH) ? LOOKUP_EMPTY : 0;
|
||||
|
||||
return getname_flags(filename, flags, NULL);
|
||||
}
|
||||
|
||||
struct filename *
|
||||
getname(const char __user * filename)
|
||||
{
|
||||
@ -247,6 +255,9 @@ getname_kernel(const char * filename)
|
||||
|
||||
void putname(struct filename *name)
|
||||
{
|
||||
if (IS_ERR_OR_NULL(name))
|
||||
return;
|
||||
|
||||
BUG_ON(name->refcnt <= 0);
|
||||
|
||||
if (--name->refcnt > 0)
|
||||
@ -2456,7 +2467,7 @@ static int path_lookupat(struct nameidata *nd, unsigned flags, struct path *path
|
||||
return err;
|
||||
}
|
||||
|
||||
int filename_lookup(int dfd, struct filename *name, unsigned flags,
|
||||
static int __filename_lookup(int dfd, struct filename *name, unsigned flags,
|
||||
struct path *path, struct path *root)
|
||||
{
|
||||
int retval;
|
||||
@ -2474,6 +2485,14 @@ int filename_lookup(int dfd, struct filename *name, unsigned flags,
|
||||
audit_inode(name, path->dentry,
|
||||
flags & LOOKUP_MOUNTPOINT ? AUDIT_INODE_NOEVAL : 0);
|
||||
restore_nameidata();
|
||||
return retval;
|
||||
}
|
||||
|
||||
int filename_lookup(int dfd, struct filename *name, unsigned flags,
|
||||
struct path *path, struct path *root)
|
||||
{
|
||||
int retval = __filename_lookup(dfd, name, flags, path, root);
|
||||
|
||||
putname(name);
|
||||
return retval;
|
||||
}
|
||||
@ -2495,7 +2514,7 @@ static int path_parentat(struct nameidata *nd, unsigned flags,
|
||||
return err;
|
||||
}
|
||||
|
||||
static struct filename *filename_parentat(int dfd, struct filename *name,
|
||||
static int __filename_parentat(int dfd, struct filename *name,
|
||||
unsigned int flags, struct path *parent,
|
||||
struct qstr *last, int *type)
|
||||
{
|
||||
@ -2503,7 +2522,7 @@ static struct filename *filename_parentat(int dfd, struct filename *name,
|
||||
struct nameidata nd;
|
||||
|
||||
if (IS_ERR(name))
|
||||
return name;
|
||||
return PTR_ERR(name);
|
||||
set_nameidata(&nd, dfd, name, NULL);
|
||||
retval = path_parentat(&nd, flags | LOOKUP_RCU, parent);
|
||||
if (unlikely(retval == -ECHILD))
|
||||
@ -2514,29 +2533,34 @@ static struct filename *filename_parentat(int dfd, struct filename *name,
|
||||
*last = nd.last;
|
||||
*type = nd.last_type;
|
||||
audit_inode(name, parent->dentry, AUDIT_INODE_PARENT);
|
||||
} else {
|
||||
putname(name);
|
||||
name = ERR_PTR(retval);
|
||||
}
|
||||
restore_nameidata();
|
||||
return name;
|
||||
return retval;
|
||||
}
|
||||
|
||||
static int filename_parentat(int dfd, struct filename *name,
|
||||
unsigned int flags, struct path *parent,
|
||||
struct qstr *last, int *type)
|
||||
{
|
||||
int retval = __filename_parentat(dfd, name, flags, parent, last, type);
|
||||
|
||||
putname(name);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* does lookup, returns the object with parent locked */
|
||||
struct dentry *kern_path_locked(const char *name, struct path *path)
|
||||
{
|
||||
struct filename *filename;
|
||||
struct dentry *d;
|
||||
struct qstr last;
|
||||
int type;
|
||||
int type, error;
|
||||
|
||||
filename = filename_parentat(AT_FDCWD, getname_kernel(name), 0, path,
|
||||
error = filename_parentat(AT_FDCWD, getname_kernel(name), 0, path,
|
||||
&last, &type);
|
||||
if (IS_ERR(filename))
|
||||
return ERR_CAST(filename);
|
||||
if (error)
|
||||
return ERR_PTR(error);
|
||||
if (unlikely(type != LAST_NORM)) {
|
||||
path_put(path);
|
||||
putname(filename);
|
||||
return ERR_PTR(-EINVAL);
|
||||
}
|
||||
inode_lock_nested(path->dentry->d_inode, I_MUTEX_PARENT);
|
||||
@ -2545,7 +2569,6 @@ struct dentry *kern_path_locked(const char *name, struct path *path)
|
||||
inode_unlock(path->dentry->d_inode);
|
||||
path_put(path);
|
||||
}
|
||||
putname(filename);
|
||||
return d;
|
||||
}
|
||||
|
||||
@ -3564,7 +3587,7 @@ struct file *do_file_open_root(const struct path *root,
|
||||
return file;
|
||||
}
|
||||
|
||||
static struct dentry *filename_create(int dfd, struct filename *name,
|
||||
static struct dentry *__filename_create(int dfd, struct filename *name,
|
||||
struct path *path, unsigned int lookup_flags)
|
||||
{
|
||||
struct dentry *dentry = ERR_PTR(-EEXIST);
|
||||
@ -3580,9 +3603,9 @@ static struct dentry *filename_create(int dfd, struct filename *name,
|
||||
*/
|
||||
lookup_flags &= LOOKUP_REVAL;
|
||||
|
||||
name = filename_parentat(dfd, name, lookup_flags, path, &last, &type);
|
||||
if (IS_ERR(name))
|
||||
return ERR_CAST(name);
|
||||
error = __filename_parentat(dfd, name, lookup_flags, path, &last, &type);
|
||||
if (error)
|
||||
return ERR_PTR(error);
|
||||
|
||||
/*
|
||||
* Yucky last component or no last component at all?
|
||||
@ -3620,7 +3643,6 @@ static struct dentry *filename_create(int dfd, struct filename *name,
|
||||
error = err2;
|
||||
goto fail;
|
||||
}
|
||||
putname(name);
|
||||
return dentry;
|
||||
fail:
|
||||
dput(dentry);
|
||||
@ -3631,10 +3653,18 @@ unlock:
|
||||
mnt_drop_write(path->mnt);
|
||||
out:
|
||||
path_put(path);
|
||||
putname(name);
|
||||
return dentry;
|
||||
}
|
||||
|
||||
static inline struct dentry *filename_create(int dfd, struct filename *name,
|
||||
struct path *path, unsigned int lookup_flags)
|
||||
{
|
||||
struct dentry *res = __filename_create(dfd, name, path, lookup_flags);
|
||||
|
||||
putname(name);
|
||||
return res;
|
||||
}
|
||||
|
||||
struct dentry *kern_path_create(int dfd, const char *pathname,
|
||||
struct path *path, unsigned int lookup_flags)
|
||||
{
|
||||
@ -3723,7 +3753,7 @@ static int may_mknod(umode_t mode)
|
||||
}
|
||||
}
|
||||
|
||||
static long do_mknodat(int dfd, const char __user *filename, umode_t mode,
|
||||
static int do_mknodat(int dfd, struct filename *name, umode_t mode,
|
||||
unsigned int dev)
|
||||
{
|
||||
struct user_namespace *mnt_userns;
|
||||
@ -3734,17 +3764,18 @@ static long do_mknodat(int dfd, const char __user *filename, umode_t mode,
|
||||
|
||||
error = may_mknod(mode);
|
||||
if (error)
|
||||
return error;
|
||||
goto out1;
|
||||
retry:
|
||||
dentry = user_path_create(dfd, filename, &path, lookup_flags);
|
||||
dentry = __filename_create(dfd, name, &path, lookup_flags);
|
||||
error = PTR_ERR(dentry);
|
||||
if (IS_ERR(dentry))
|
||||
return PTR_ERR(dentry);
|
||||
goto out1;
|
||||
|
||||
if (!IS_POSIXACL(path.dentry->d_inode))
|
||||
mode &= ~current_umask();
|
||||
error = security_path_mknod(&path, dentry, mode, dev);
|
||||
if (error)
|
||||
goto out;
|
||||
goto out2;
|
||||
|
||||
mnt_userns = mnt_user_ns(path.mnt);
|
||||
switch (mode & S_IFMT) {
|
||||
@ -3763,24 +3794,26 @@ retry:
|
||||
dentry, mode, 0);
|
||||
break;
|
||||
}
|
||||
out:
|
||||
out2:
|
||||
done_path_create(&path, dentry);
|
||||
if (retry_estale(error, lookup_flags)) {
|
||||
lookup_flags |= LOOKUP_REVAL;
|
||||
goto retry;
|
||||
}
|
||||
out1:
|
||||
putname(name);
|
||||
return error;
|
||||
}
|
||||
|
||||
SYSCALL_DEFINE4(mknodat, int, dfd, const char __user *, filename, umode_t, mode,
|
||||
unsigned int, dev)
|
||||
{
|
||||
return do_mknodat(dfd, filename, mode, dev);
|
||||
return do_mknodat(dfd, getname(filename), mode, dev);
|
||||
}
|
||||
|
||||
SYSCALL_DEFINE3(mknod, const char __user *, filename, umode_t, mode, unsigned, dev)
|
||||
{
|
||||
return do_mknodat(AT_FDCWD, filename, mode, dev);
|
||||
return do_mknodat(AT_FDCWD, getname(filename), mode, dev);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -3825,7 +3858,7 @@ int vfs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
|
||||
}
|
||||
EXPORT_SYMBOL(vfs_mkdir);
|
||||
|
||||
static long do_mkdirat(int dfd, const char __user *pathname, umode_t mode)
|
||||
int do_mkdirat(int dfd, struct filename *name, umode_t mode)
|
||||
{
|
||||
struct dentry *dentry;
|
||||
struct path path;
|
||||
@ -3833,9 +3866,10 @@ static long do_mkdirat(int dfd, const char __user *pathname, umode_t mode)
|
||||
unsigned int lookup_flags = LOOKUP_DIRECTORY;
|
||||
|
||||
retry:
|
||||
dentry = user_path_create(dfd, pathname, &path, lookup_flags);
|
||||
dentry = __filename_create(dfd, name, &path, lookup_flags);
|
||||
error = PTR_ERR(dentry);
|
||||
if (IS_ERR(dentry))
|
||||
return PTR_ERR(dentry);
|
||||
goto out_putname;
|
||||
|
||||
if (!IS_POSIXACL(path.dentry->d_inode))
|
||||
mode &= ~current_umask();
|
||||
@ -3851,17 +3885,19 @@ retry:
|
||||
lookup_flags |= LOOKUP_REVAL;
|
||||
goto retry;
|
||||
}
|
||||
out_putname:
|
||||
putname(name);
|
||||
return error;
|
||||
}
|
||||
|
||||
SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user *, pathname, umode_t, mode)
|
||||
{
|
||||
return do_mkdirat(dfd, pathname, mode);
|
||||
return do_mkdirat(dfd, getname(pathname), mode);
|
||||
}
|
||||
|
||||
SYSCALL_DEFINE2(mkdir, const char __user *, pathname, umode_t, mode)
|
||||
{
|
||||
return do_mkdirat(AT_FDCWD, pathname, mode);
|
||||
return do_mkdirat(AT_FDCWD, getname(pathname), mode);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -3919,62 +3955,62 @@ out:
|
||||
}
|
||||
EXPORT_SYMBOL(vfs_rmdir);
|
||||
|
||||
long do_rmdir(int dfd, struct filename *name)
|
||||
int do_rmdir(int dfd, struct filename *name)
|
||||
{
|
||||
struct user_namespace *mnt_userns;
|
||||
int error = 0;
|
||||
int error;
|
||||
struct dentry *dentry;
|
||||
struct path path;
|
||||
struct qstr last;
|
||||
int type;
|
||||
unsigned int lookup_flags = 0;
|
||||
retry:
|
||||
name = filename_parentat(dfd, name, lookup_flags,
|
||||
&path, &last, &type);
|
||||
if (IS_ERR(name))
|
||||
return PTR_ERR(name);
|
||||
error = __filename_parentat(dfd, name, lookup_flags, &path, &last, &type);
|
||||
if (error)
|
||||
goto exit1;
|
||||
|
||||
switch (type) {
|
||||
case LAST_DOTDOT:
|
||||
error = -ENOTEMPTY;
|
||||
goto exit1;
|
||||
goto exit2;
|
||||
case LAST_DOT:
|
||||
error = -EINVAL;
|
||||
goto exit1;
|
||||
goto exit2;
|
||||
case LAST_ROOT:
|
||||
error = -EBUSY;
|
||||
goto exit1;
|
||||
goto exit2;
|
||||
}
|
||||
|
||||
error = mnt_want_write(path.mnt);
|
||||
if (error)
|
||||
goto exit1;
|
||||
goto exit2;
|
||||
|
||||
inode_lock_nested(path.dentry->d_inode, I_MUTEX_PARENT);
|
||||
dentry = __lookup_hash(&last, path.dentry, lookup_flags);
|
||||
error = PTR_ERR(dentry);
|
||||
if (IS_ERR(dentry))
|
||||
goto exit2;
|
||||
goto exit3;
|
||||
if (!dentry->d_inode) {
|
||||
error = -ENOENT;
|
||||
goto exit3;
|
||||
goto exit4;
|
||||
}
|
||||
error = security_path_rmdir(&path, dentry);
|
||||
if (error)
|
||||
goto exit3;
|
||||
goto exit4;
|
||||
mnt_userns = mnt_user_ns(path.mnt);
|
||||
error = vfs_rmdir(mnt_userns, path.dentry->d_inode, dentry);
|
||||
exit3:
|
||||
exit4:
|
||||
dput(dentry);
|
||||
exit2:
|
||||
exit3:
|
||||
inode_unlock(path.dentry->d_inode);
|
||||
mnt_drop_write(path.mnt);
|
||||
exit1:
|
||||
exit2:
|
||||
path_put(&path);
|
||||
if (retry_estale(error, lookup_flags)) {
|
||||
lookup_flags |= LOOKUP_REVAL;
|
||||
goto retry;
|
||||
}
|
||||
exit1:
|
||||
putname(name);
|
||||
return error;
|
||||
}
|
||||
@ -4057,7 +4093,7 @@ EXPORT_SYMBOL(vfs_unlink);
|
||||
* writeout happening, and we don't want to prevent access to the directory
|
||||
* while waiting on the I/O.
|
||||
*/
|
||||
long do_unlinkat(int dfd, struct filename *name)
|
||||
int do_unlinkat(int dfd, struct filename *name)
|
||||
{
|
||||
int error;
|
||||
struct dentry *dentry;
|
||||
@ -4068,17 +4104,17 @@ long do_unlinkat(int dfd, struct filename *name)
|
||||
struct inode *delegated_inode = NULL;
|
||||
unsigned int lookup_flags = 0;
|
||||
retry:
|
||||
name = filename_parentat(dfd, name, lookup_flags, &path, &last, &type);
|
||||
if (IS_ERR(name))
|
||||
return PTR_ERR(name);
|
||||
error = __filename_parentat(dfd, name, lookup_flags, &path, &last, &type);
|
||||
if (error)
|
||||
goto exit1;
|
||||
|
||||
error = -EISDIR;
|
||||
if (type != LAST_NORM)
|
||||
goto exit1;
|
||||
goto exit2;
|
||||
|
||||
error = mnt_want_write(path.mnt);
|
||||
if (error)
|
||||
goto exit1;
|
||||
goto exit2;
|
||||
retry_deleg:
|
||||
inode_lock_nested(path.dentry->d_inode, I_MUTEX_PARENT);
|
||||
dentry = __lookup_hash(&last, path.dentry, lookup_flags);
|
||||
@ -4095,11 +4131,11 @@ retry_deleg:
|
||||
ihold(inode);
|
||||
error = security_path_unlink(&path, dentry);
|
||||
if (error)
|
||||
goto exit2;
|
||||
goto exit3;
|
||||
mnt_userns = mnt_user_ns(path.mnt);
|
||||
error = vfs_unlink(mnt_userns, path.dentry->d_inode, dentry,
|
||||
&delegated_inode);
|
||||
exit2:
|
||||
exit3:
|
||||
dput(dentry);
|
||||
}
|
||||
inode_unlock(path.dentry->d_inode);
|
||||
@ -4112,13 +4148,14 @@ exit2:
|
||||
goto retry_deleg;
|
||||
}
|
||||
mnt_drop_write(path.mnt);
|
||||
exit1:
|
||||
exit2:
|
||||
path_put(&path);
|
||||
if (retry_estale(error, lookup_flags)) {
|
||||
lookup_flags |= LOOKUP_REVAL;
|
||||
inode = NULL;
|
||||
goto retry;
|
||||
}
|
||||
exit1:
|
||||
putname(name);
|
||||
return error;
|
||||
|
||||
@ -4129,7 +4166,7 @@ slashes:
|
||||
error = -EISDIR;
|
||||
else
|
||||
error = -ENOTDIR;
|
||||
goto exit2;
|
||||
goto exit3;
|
||||
}
|
||||
|
||||
SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user *, pathname, int, flag)
|
||||
@ -4184,23 +4221,22 @@ int vfs_symlink(struct user_namespace *mnt_userns, struct inode *dir,
|
||||
}
|
||||
EXPORT_SYMBOL(vfs_symlink);
|
||||
|
||||
static long do_symlinkat(const char __user *oldname, int newdfd,
|
||||
const char __user *newname)
|
||||
int do_symlinkat(struct filename *from, int newdfd, struct filename *to)
|
||||
{
|
||||
int error;
|
||||
struct filename *from;
|
||||
struct dentry *dentry;
|
||||
struct path path;
|
||||
unsigned int lookup_flags = 0;
|
||||
|
||||
from = getname(oldname);
|
||||
if (IS_ERR(from))
|
||||
return PTR_ERR(from);
|
||||
if (IS_ERR(from)) {
|
||||
error = PTR_ERR(from);
|
||||
goto out_putnames;
|
||||
}
|
||||
retry:
|
||||
dentry = user_path_create(newdfd, newname, &path, lookup_flags);
|
||||
dentry = __filename_create(newdfd, to, &path, lookup_flags);
|
||||
error = PTR_ERR(dentry);
|
||||
if (IS_ERR(dentry))
|
||||
goto out_putname;
|
||||
goto out_putnames;
|
||||
|
||||
error = security_path_symlink(&path, dentry, from->name);
|
||||
if (!error) {
|
||||
@ -4215,7 +4251,8 @@ retry:
|
||||
lookup_flags |= LOOKUP_REVAL;
|
||||
goto retry;
|
||||
}
|
||||
out_putname:
|
||||
out_putnames:
|
||||
putname(to);
|
||||
putname(from);
|
||||
return error;
|
||||
}
|
||||
@ -4223,12 +4260,12 @@ out_putname:
|
||||
SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
|
||||
int, newdfd, const char __user *, newname)
|
||||
{
|
||||
return do_symlinkat(oldname, newdfd, newname);
|
||||
return do_symlinkat(getname(oldname), newdfd, getname(newname));
|
||||
}
|
||||
|
||||
SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
|
||||
{
|
||||
return do_symlinkat(oldname, AT_FDCWD, newname);
|
||||
return do_symlinkat(getname(oldname), AT_FDCWD, getname(newname));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -4329,8 +4366,8 @@ EXPORT_SYMBOL(vfs_link);
|
||||
* with linux 2.0, and to avoid hard-linking to directories
|
||||
* and other special files. --ADM
|
||||
*/
|
||||
static int do_linkat(int olddfd, const char __user *oldname, int newdfd,
|
||||
const char __user *newname, int flags)
|
||||
int do_linkat(int olddfd, struct filename *old, int newdfd,
|
||||
struct filename *new, int flags)
|
||||
{
|
||||
struct user_namespace *mnt_userns;
|
||||
struct dentry *new_dentry;
|
||||
@ -4339,31 +4376,32 @@ static int do_linkat(int olddfd, const char __user *oldname, int newdfd,
|
||||
int how = 0;
|
||||
int error;
|
||||
|
||||
if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0)
|
||||
return -EINVAL;
|
||||
if ((flags & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0) {
|
||||
error = -EINVAL;
|
||||
goto out_putnames;
|
||||
}
|
||||
/*
|
||||
* To use null names we require CAP_DAC_READ_SEARCH
|
||||
* This ensures that not everyone will be able to create
|
||||
* handlink using the passed filedescriptor.
|
||||
*/
|
||||
if (flags & AT_EMPTY_PATH) {
|
||||
if (!capable(CAP_DAC_READ_SEARCH))
|
||||
return -ENOENT;
|
||||
how = LOOKUP_EMPTY;
|
||||
if (flags & AT_EMPTY_PATH && !capable(CAP_DAC_READ_SEARCH)) {
|
||||
error = -ENOENT;
|
||||
goto out_putnames;
|
||||
}
|
||||
|
||||
if (flags & AT_SYMLINK_FOLLOW)
|
||||
how |= LOOKUP_FOLLOW;
|
||||
retry:
|
||||
error = user_path_at(olddfd, oldname, how, &old_path);
|
||||
error = __filename_lookup(olddfd, old, how, &old_path, NULL);
|
||||
if (error)
|
||||
return error;
|
||||
goto out_putnames;
|
||||
|
||||
new_dentry = user_path_create(newdfd, newname, &new_path,
|
||||
new_dentry = __filename_create(newdfd, new, &new_path,
|
||||
(how & LOOKUP_REVAL));
|
||||
error = PTR_ERR(new_dentry);
|
||||
if (IS_ERR(new_dentry))
|
||||
goto out;
|
||||
goto out_putpath;
|
||||
|
||||
error = -EXDEV;
|
||||
if (old_path.mnt != new_path.mnt)
|
||||
@ -4391,8 +4429,11 @@ out_dput:
|
||||
how |= LOOKUP_REVAL;
|
||||
goto retry;
|
||||
}
|
||||
out:
|
||||
out_putpath:
|
||||
path_put(&old_path);
|
||||
out_putnames:
|
||||
putname(old);
|
||||
putname(new);
|
||||
|
||||
return error;
|
||||
}
|
||||
@ -4400,12 +4441,13 @@ out:
|
||||
SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
|
||||
int, newdfd, const char __user *, newname, int, flags)
|
||||
{
|
||||
return do_linkat(olddfd, oldname, newdfd, newname, flags);
|
||||
return do_linkat(olddfd, getname_uflags(oldname, flags),
|
||||
newdfd, getname(newname), flags);
|
||||
}
|
||||
|
||||
SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
|
||||
{
|
||||
return do_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
|
||||
return do_linkat(AT_FDCWD, getname(oldname), AT_FDCWD, getname(newname), 0);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -4600,29 +4642,25 @@ int do_renameat2(int olddfd, struct filename *from, int newdfd,
|
||||
int error = -EINVAL;
|
||||
|
||||
if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
|
||||
goto put_both;
|
||||
goto put_names;
|
||||
|
||||
if ((flags & (RENAME_NOREPLACE | RENAME_WHITEOUT)) &&
|
||||
(flags & RENAME_EXCHANGE))
|
||||
goto put_both;
|
||||
goto put_names;
|
||||
|
||||
if (flags & RENAME_EXCHANGE)
|
||||
target_flags = 0;
|
||||
|
||||
retry:
|
||||
from = filename_parentat(olddfd, from, lookup_flags, &old_path,
|
||||
error = __filename_parentat(olddfd, from, lookup_flags, &old_path,
|
||||
&old_last, &old_type);
|
||||
if (IS_ERR(from)) {
|
||||
error = PTR_ERR(from);
|
||||
goto put_new;
|
||||
}
|
||||
if (error)
|
||||
goto put_names;
|
||||
|
||||
to = filename_parentat(newdfd, to, lookup_flags, &new_path, &new_last,
|
||||
error = __filename_parentat(newdfd, to, lookup_flags, &new_path, &new_last,
|
||||
&new_type);
|
||||
if (IS_ERR(to)) {
|
||||
error = PTR_ERR(to);
|
||||
if (error)
|
||||
goto exit1;
|
||||
}
|
||||
|
||||
error = -EXDEV;
|
||||
if (old_path.mnt != new_path.mnt)
|
||||
@ -4725,12 +4763,9 @@ exit1:
|
||||
lookup_flags |= LOOKUP_REVAL;
|
||||
goto retry;
|
||||
}
|
||||
put_both:
|
||||
if (!IS_ERR(from))
|
||||
putname(from);
|
||||
put_new:
|
||||
if (!IS_ERR(to))
|
||||
putname(to);
|
||||
put_names:
|
||||
putname(from);
|
||||
putname(to);
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
@ -2746,6 +2746,7 @@ static inline struct file *file_clone_open(struct file *file)
|
||||
extern int filp_close(struct file *, fl_owner_t id);
|
||||
|
||||
extern struct filename *getname_flags(const char __user *, int, int *);
|
||||
extern struct filename *getname_uflags(const char __user *, int);
|
||||
extern struct filename *getname(const char __user *);
|
||||
extern struct filename *getname_kernel(const char *);
|
||||
extern void putname(struct filename *name);
|
||||
|
||||
@ -44,6 +44,7 @@ struct io_uring_sqe {
|
||||
__u32 splice_flags;
|
||||
__u32 rename_flags;
|
||||
__u32 unlink_flags;
|
||||
__u32 hardlink_flags;
|
||||
};
|
||||
__u64 user_data; /* data to be passed back at completion time */
|
||||
/* pack this to avoid bogus arm OABI complaints */
|
||||
@ -136,6 +137,9 @@ enum {
|
||||
IORING_OP_SHUTDOWN,
|
||||
IORING_OP_RENAMEAT,
|
||||
IORING_OP_UNLINKAT,
|
||||
IORING_OP_MKDIRAT,
|
||||
IORING_OP_SYMLINKAT,
|
||||
IORING_OP_LINKAT,
|
||||
|
||||
/* this goes last, obviously */
|
||||
IORING_OP_LAST,
|
||||
|
||||
Loading…
Reference in New Issue
Block a user