io_uring/fs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/kernel.h>
   3 #include <linux/errno.h>
   4 #include <linux/fs.h>
   5 #include <linux/file.h>
   6 #include <linux/mm.h>
   7 #include <linux/slab.h>
   8 #include <linux/namei.h>
   9 #include <linux/io_uring.h>
  10
  11 #include <uapi/linux/io_uring.h>
  12
  13 #include "../fs/internal.h"
  14
  15 #include "io_uring.h"
  16 #include "fs.h"
  17
  18 struct io_rename {
  19         struct file                     *file;
  20         int                             old_dfd;
  21         int                             new_dfd;
  22         struct filename                 *oldpath;
  23         struct filename                 *newpath;
  24         int                             flags;
  25 };
  26
  27 struct io_unlink {
  28         struct file                     *file;
  29         int                             dfd;
  30         int                             flags;
  31         struct filename                 *filename;
  32 };
  33
  34 struct io_mkdir {
  35         struct file                     *file;
  36         int                             dfd;
  37         umode_t                         mode;
  38         struct filename                 *filename;
  39 };
  40
  41 struct io_link {
  42         struct file                     *file;
  43         int                             old_dfd;
  44         int                             new_dfd;
  45         struct filename                 *oldpath;
  46         struct filename                 *newpath;
  47         int                             flags;
  48 };
  49
  50 int io_renameat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
  51 {
  52         struct io_rename *ren = io_kiocb_to_cmd(req, struct io_rename);
  53         const char __user *oldf, *newf;
  54
  55         if (sqe->buf_index || sqe->splice_fd_in)
  56                 return -EINVAL;
  57         if (unlikely(req->flags & REQ_F_FIXED_FILE))
  58                 return -EBADF;
  59
  60         ren->old_dfd = READ_ONCE(sqe->fd);
  61         oldf = u64_to_user_ptr(READ_ONCE(sqe->addr));
  62         newf = u64_to_user_ptr(READ_ONCE(sqe->addr2));
  63         ren->new_dfd = READ_ONCE(sqe->len);
  64         ren->flags = READ_ONCE(sqe->rename_flags);
  65
  66         ren->oldpath = getname(oldf);
  67         if (IS_ERR(ren->oldpath))
  68                 return PTR_ERR(ren->oldpath);
  69
  70         ren->newpath = getname(newf);
  71         if (IS_ERR(ren->newpath)) {
  72                 putname(ren->oldpath);
  73                 return PTR_ERR(ren->newpath);
  74         }
  75
  76         req->flags |= REQ_F_NEED_CLEANUP;
  77         req->flags |= REQ_F_FORCE_ASYNC;
  78         return 0;
  79 }
  80
  81 int io_renameat(struct io_kiocb *req, unsigned int issue_flags)
  82 {
  83         struct io_rename *ren = io_kiocb_to_cmd(req, struct io_rename);
  84         int ret;
  85
  86         WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
  87
  88         ret = do_renameat2(ren->old_dfd, ren->oldpath, ren->new_dfd,
  89                                 ren->newpath, ren->flags);
  90
  91         req->flags &= ~REQ_F_NEED_CLEANUP;
  92         io_req_set_res(req, ret, 0);
  93         return IOU_OK;
  94 }
  95
  96 void io_renameat_cleanup(struct io_kiocb *req)
  97 {
  98         struct io_rename *ren = io_kiocb_to_cmd(req, struct io_rename);
  99
 100         putname(ren->oldpath);
 101         putname(ren->newpath);
 102 }
 103
 104 int io_unlinkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 105 {
 106         struct io_unlink *un = io_kiocb_to_cmd(req, struct io_unlink);
 107         const char __user *fname;
 108
 109         if (sqe->off || sqe->len || sqe->buf_index || sqe->splice_fd_in)
 110                 return -EINVAL;
 111         if (unlikely(req->flags & REQ_F_FIXED_FILE))
 112                 return -EBADF;
 113
 114         un->dfd = READ_ONCE(sqe->fd);
 115
 116         un->flags = READ_ONCE(sqe->unlink_flags);
 117         if (un->flags & ~AT_REMOVEDIR)
 118                 return -EINVAL;
 119
 120         fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
 121         un->filename = getname(fname);
 122         if (IS_ERR(un->filename))
 123                 return PTR_ERR(un->filename);
 124
 125         req->flags |= REQ_F_NEED_CLEANUP;
 126         req->flags |= REQ_F_FORCE_ASYNC;
 127         return 0;
 128 }
 129
 130 int io_unlinkat(struct io_kiocb *req, unsigned int issue_flags)
 131 {
 132         struct io_unlink *un = io_kiocb_to_cmd(req, struct io_unlink);
 133         int ret;
 134
 135         WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
 136
 137         if (un->flags & AT_REMOVEDIR)
 138                 ret = do_rmdir(un->dfd, un->filename);
 139         else
 140                 ret = do_unlinkat(un->dfd, un->filename);
 141
 142         req->flags &= ~REQ_F_NEED_CLEANUP;
 143         io_req_set_res(req, ret, 0);
 144         return IOU_OK;
 145 }
 146
 147 void io_unlinkat_cleanup(struct io_kiocb *req)
 148 {
 149         struct io_unlink *ul = io_kiocb_to_cmd(req, struct io_unlink);
 150
 151         putname(ul->filename);
 152 }
 153
 154 int io_mkdirat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 155 {
 156         struct io_mkdir *mkd = io_kiocb_to_cmd(req, struct io_mkdir);
 157         const char __user *fname;
 158
 159         if (sqe->off || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in)
 160                 return -EINVAL;
 161         if (unlikely(req->flags & REQ_F_FIXED_FILE))
 162                 return -EBADF;
 163
 164         mkd->dfd = READ_ONCE(sqe->fd);
 165         mkd->mode = READ_ONCE(sqe->len);
 166
 167         fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
 168         mkd->filename = getname(fname);
 169         if (IS_ERR(mkd->filename))
 170                 return PTR_ERR(mkd->filename);
 171
 172         req->flags |= REQ_F_NEED_CLEANUP;
 173         req->flags |= REQ_F_FORCE_ASYNC;
 174         return 0;
 175 }
 176
 177 int io_mkdirat(struct io_kiocb *req, unsigned int issue_flags)
 178 {
 179         struct io_mkdir *mkd = io_kiocb_to_cmd(req, struct io_mkdir);
 180         int ret;
 181
 182         WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
 183
 184         ret = do_mkdirat(mkd->dfd, mkd->filename, mkd->mode);
 185
 186         req->flags &= ~REQ_F_NEED_CLEANUP;
 187         io_req_set_res(req, ret, 0);
 188         return IOU_OK;
 189 }
 190
 191 void io_mkdirat_cleanup(struct io_kiocb *req)
 192 {
 193         struct io_mkdir *md = io_kiocb_to_cmd(req, struct io_mkdir);
 194
 195         putname(md->filename);
 196 }
 197
 198 int io_symlinkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 199 {
 200         struct io_link *sl = io_kiocb_to_cmd(req, struct io_link);
 201         const char __user *oldpath, *newpath;
 202
 203         if (sqe->len || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in)
 204                 return -EINVAL;
 205         if (unlikely(req->flags & REQ_F_FIXED_FILE))
 206                 return -EBADF;
 207
 208         sl->new_dfd = READ_ONCE(sqe->fd);
 209         oldpath = u64_to_user_ptr(READ_ONCE(sqe->addr));
 210         newpath = u64_to_user_ptr(READ_ONCE(sqe->addr2));
 211
 212         sl->oldpath = getname(oldpath);
 213         if (IS_ERR(sl->oldpath))
 214                 return PTR_ERR(sl->oldpath);
 215
 216         sl->newpath = getname(newpath);
 217         if (IS_ERR(sl->newpath)) {
 218                 putname(sl->oldpath);
 219                 return PTR_ERR(sl->newpath);
 220         }
 221
 222         req->flags |= REQ_F_NEED_CLEANUP;
 223         req->flags |= REQ_F_FORCE_ASYNC;
 224         return 0;
 225 }
 226
 227 int io_symlinkat(struct io_kiocb *req, unsigned int issue_flags)
 228 {
 229         struct io_link *sl = io_kiocb_to_cmd(req, struct io_link);
 230         int ret;
 231
 232         WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
 233
 234         ret = do_symlinkat(sl->oldpath, sl->new_dfd, sl->newpath);
 235
 236         req->flags &= ~REQ_F_NEED_CLEANUP;
 237         io_req_set_res(req, ret, 0);
 238         return IOU_OK;
 239 }
 240
 241 int io_linkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 242 {
 243         struct io_link *lnk = io_kiocb_to_cmd(req, struct io_link);
 244         const char __user *oldf, *newf;
 245
 246         if (sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in)
 247                 return -EINVAL;
 248         if (unlikely(req->flags & REQ_F_FIXED_FILE))
 249                 return -EBADF;
 250
 251         lnk->old_dfd = READ_ONCE(sqe->fd);
 252         lnk->new_dfd = READ_ONCE(sqe->len);
 253         oldf = u64_to_user_ptr(READ_ONCE(sqe->addr));
 254         newf = u64_to_user_ptr(READ_ONCE(sqe->addr2));
 255         lnk->flags = READ_ONCE(sqe->hardlink_flags);
 256
 257         lnk->oldpath = getname(oldf);
 258         if (IS_ERR(lnk->oldpath))
 259                 return PTR_ERR(lnk->oldpath);
 260
 261         lnk->newpath = getname(newf);
 262         if (IS_ERR(lnk->newpath)) {
 263                 putname(lnk->oldpath);
 264                 return PTR_ERR(lnk->newpath);
 265         }
 266
 267         req->flags |= REQ_F_NEED_CLEANUP;
 268         req->flags |= REQ_F_FORCE_ASYNC;
 269         return 0;
 270 }
 271
 272 int io_linkat(struct io_kiocb *req, unsigned int issue_flags)
 273 {
 274         struct io_link *lnk = io_kiocb_to_cmd(req, struct io_link);
 275         int ret;
 276
 277         WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
 278
 279         ret = do_linkat(lnk->old_dfd, lnk->oldpath, lnk->new_dfd,
 280                                 lnk->newpath, lnk->flags);
 281
 282         req->flags &= ~REQ_F_NEED_CLEANUP;
 283         io_req_set_res(req, ret, 0);
 284         return IOU_OK;
 285 }
 286
 287 void io_link_cleanup(struct io_kiocb *req)
 288 {
 289         struct io_link *sl = io_kiocb_to_cmd(req, struct io_link);
 290
 291         putname(sl->oldpath);
 292         putname(sl->newpath);
 293 }