Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

io_uring: split out filesystem related operations

This splits out renameat, unlinkat, mkdirat, symlinkat, and linkat.

Signed-off-by: Jens Axboe <axboe@kernel.dk>

+316 -283
+1 -1
io_uring/Makefile
··· 2 2 # 3 3 # Makefile for io_uring 4 4 5 - obj-$(CONFIG_IO_URING) += io_uring.o xattr.o nop.o 5 + obj-$(CONFIG_IO_URING) += io_uring.o xattr.o nop.o fs.o 6 6 obj-$(CONFIG_IO_WQ) += io-wq.o
+294
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_types.h" 16 + #include "io_uring.h" 17 + #include "fs.h" 18 + 19 + struct io_rename { 20 + struct file *file; 21 + int old_dfd; 22 + int new_dfd; 23 + struct filename *oldpath; 24 + struct filename *newpath; 25 + int flags; 26 + }; 27 + 28 + struct io_unlink { 29 + struct file *file; 30 + int dfd; 31 + int flags; 32 + struct filename *filename; 33 + }; 34 + 35 + struct io_mkdir { 36 + struct file *file; 37 + int dfd; 38 + umode_t mode; 39 + struct filename *filename; 40 + }; 41 + 42 + struct io_link { 43 + struct file *file; 44 + int old_dfd; 45 + int new_dfd; 46 + struct filename *oldpath; 47 + struct filename *newpath; 48 + int flags; 49 + }; 50 + 51 + int io_renameat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 52 + { 53 + struct io_rename *ren = io_kiocb_to_cmd(req); 54 + const char __user *oldf, *newf; 55 + 56 + if (sqe->buf_index || sqe->splice_fd_in) 57 + return -EINVAL; 58 + if (unlikely(req->flags & REQ_F_FIXED_FILE)) 59 + return -EBADF; 60 + 61 + ren->old_dfd = READ_ONCE(sqe->fd); 62 + oldf = u64_to_user_ptr(READ_ONCE(sqe->addr)); 63 + newf = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 64 + ren->new_dfd = READ_ONCE(sqe->len); 65 + ren->flags = READ_ONCE(sqe->rename_flags); 66 + 67 + ren->oldpath = getname(oldf); 68 + if (IS_ERR(ren->oldpath)) 69 + return PTR_ERR(ren->oldpath); 70 + 71 + ren->newpath = getname(newf); 72 + if (IS_ERR(ren->newpath)) { 73 + putname(ren->oldpath); 74 + return PTR_ERR(ren->newpath); 75 + } 76 + 77 + req->flags |= REQ_F_NEED_CLEANUP; 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); 84 + int ret; 85 + 86 + if (issue_flags & IO_URING_F_NONBLOCK) 87 + return -EAGAIN; 88 + 89 + ret = do_renameat2(ren->old_dfd, ren->oldpath, ren->new_dfd, 90 + ren->newpath, ren->flags); 91 + 92 + req->flags &= ~REQ_F_NEED_CLEANUP; 93 + io_req_set_res(req, ret, 0); 94 + return IOU_OK; 95 + } 96 + 97 + void io_renameat_cleanup(struct io_kiocb *req) 98 + { 99 + struct io_rename *ren = io_kiocb_to_cmd(req); 100 + 101 + putname(ren->oldpath); 102 + putname(ren->newpath); 103 + } 104 + 105 + int io_unlinkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 106 + { 107 + struct io_unlink *un = io_kiocb_to_cmd(req); 108 + const char __user *fname; 109 + 110 + if (sqe->off || sqe->len || sqe->buf_index || sqe->splice_fd_in) 111 + return -EINVAL; 112 + if (unlikely(req->flags & REQ_F_FIXED_FILE)) 113 + return -EBADF; 114 + 115 + un->dfd = READ_ONCE(sqe->fd); 116 + 117 + un->flags = READ_ONCE(sqe->unlink_flags); 118 + if (un->flags & ~AT_REMOVEDIR) 119 + return -EINVAL; 120 + 121 + fname = u64_to_user_ptr(READ_ONCE(sqe->addr)); 122 + un->filename = getname(fname); 123 + if (IS_ERR(un->filename)) 124 + return PTR_ERR(un->filename); 125 + 126 + req->flags |= REQ_F_NEED_CLEANUP; 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); 133 + int ret; 134 + 135 + if (issue_flags & IO_URING_F_NONBLOCK) 136 + return -EAGAIN; 137 + 138 + if (un->flags & AT_REMOVEDIR) 139 + ret = do_rmdir(un->dfd, un->filename); 140 + else 141 + ret = do_unlinkat(un->dfd, un->filename); 142 + 143 + req->flags &= ~REQ_F_NEED_CLEANUP; 144 + io_req_set_res(req, ret, 0); 145 + return IOU_OK; 146 + } 147 + 148 + void io_unlinkat_cleanup(struct io_kiocb *req) 149 + { 150 + struct io_unlink *ul = io_kiocb_to_cmd(req); 151 + 152 + putname(ul->filename); 153 + } 154 + 155 + int io_mkdirat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 156 + { 157 + struct io_mkdir *mkd = io_kiocb_to_cmd(req); 158 + const char __user *fname; 159 + 160 + if (sqe->off || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in) 161 + return -EINVAL; 162 + if (unlikely(req->flags & REQ_F_FIXED_FILE)) 163 + return -EBADF; 164 + 165 + mkd->dfd = READ_ONCE(sqe->fd); 166 + mkd->mode = READ_ONCE(sqe->len); 167 + 168 + fname = u64_to_user_ptr(READ_ONCE(sqe->addr)); 169 + mkd->filename = getname(fname); 170 + if (IS_ERR(mkd->filename)) 171 + return PTR_ERR(mkd->filename); 172 + 173 + req->flags |= REQ_F_NEED_CLEANUP; 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); 180 + int ret; 181 + 182 + if (issue_flags & IO_URING_F_NONBLOCK) 183 + return -EAGAIN; 184 + 185 + ret = do_mkdirat(mkd->dfd, mkd->filename, mkd->mode); 186 + 187 + req->flags &= ~REQ_F_NEED_CLEANUP; 188 + io_req_set_res(req, ret, 0); 189 + return IOU_OK; 190 + } 191 + 192 + void io_mkdirat_cleanup(struct io_kiocb *req) 193 + { 194 + struct io_mkdir *md = io_kiocb_to_cmd(req); 195 + 196 + putname(md->filename); 197 + } 198 + 199 + int io_symlinkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 200 + { 201 + struct io_link *sl = io_kiocb_to_cmd(req); 202 + const char __user *oldpath, *newpath; 203 + 204 + if (sqe->len || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in) 205 + return -EINVAL; 206 + if (unlikely(req->flags & REQ_F_FIXED_FILE)) 207 + return -EBADF; 208 + 209 + sl->new_dfd = READ_ONCE(sqe->fd); 210 + oldpath = u64_to_user_ptr(READ_ONCE(sqe->addr)); 211 + newpath = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 212 + 213 + sl->oldpath = getname(oldpath); 214 + if (IS_ERR(sl->oldpath)) 215 + return PTR_ERR(sl->oldpath); 216 + 217 + sl->newpath = getname(newpath); 218 + if (IS_ERR(sl->newpath)) { 219 + putname(sl->oldpath); 220 + return PTR_ERR(sl->newpath); 221 + } 222 + 223 + req->flags |= REQ_F_NEED_CLEANUP; 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); 230 + int ret; 231 + 232 + if (issue_flags & IO_URING_F_NONBLOCK) 233 + return -EAGAIN; 234 + 235 + ret = do_symlinkat(sl->oldpath, sl->new_dfd, sl->newpath); 236 + 237 + req->flags &= ~REQ_F_NEED_CLEANUP; 238 + io_req_set_res(req, ret, 0); 239 + return IOU_OK; 240 + } 241 + 242 + int io_linkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe) 243 + { 244 + struct io_link *lnk = io_kiocb_to_cmd(req); 245 + const char __user *oldf, *newf; 246 + 247 + if (sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in) 248 + return -EINVAL; 249 + if (unlikely(req->flags & REQ_F_FIXED_FILE)) 250 + return -EBADF; 251 + 252 + lnk->old_dfd = READ_ONCE(sqe->fd); 253 + lnk->new_dfd = READ_ONCE(sqe->len); 254 + oldf = u64_to_user_ptr(READ_ONCE(sqe->addr)); 255 + newf = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 256 + lnk->flags = READ_ONCE(sqe->hardlink_flags); 257 + 258 + lnk->oldpath = getname(oldf); 259 + if (IS_ERR(lnk->oldpath)) 260 + return PTR_ERR(lnk->oldpath); 261 + 262 + lnk->newpath = getname(newf); 263 + if (IS_ERR(lnk->newpath)) { 264 + putname(lnk->oldpath); 265 + return PTR_ERR(lnk->newpath); 266 + } 267 + 268 + req->flags |= REQ_F_NEED_CLEANUP; 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); 275 + int ret; 276 + 277 + if (issue_flags & IO_URING_F_NONBLOCK) 278 + return -EAGAIN; 279 + 280 + ret = do_linkat(lnk->old_dfd, lnk->oldpath, lnk->new_dfd, 281 + lnk->newpath, lnk->flags); 282 + 283 + req->flags &= ~REQ_F_NEED_CLEANUP; 284 + io_req_set_res(req, ret, 0); 285 + return IOU_OK; 286 + } 287 + 288 + void io_link_cleanup(struct io_kiocb *req) 289 + { 290 + struct io_link *sl = io_kiocb_to_cmd(req); 291 + 292 + putname(sl->oldpath); 293 + putname(sl->newpath); 294 + }
+20
io_uring/fs.h
··· 1 + // SPDX-License-Identifier: GPL-2.0 2 + 3 + int io_renameat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe); 4 + int io_renameat(struct io_kiocb *req, unsigned int issue_flags); 5 + void io_renameat_cleanup(struct io_kiocb *req); 6 + 7 + int io_unlinkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe); 8 + int io_unlinkat(struct io_kiocb *req, unsigned int issue_flags); 9 + void io_unlinkat_cleanup(struct io_kiocb *req); 10 + 11 + int io_mkdirat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe); 12 + int io_mkdirat(struct io_kiocb *req, unsigned int issue_flags); 13 + void io_mkdirat_cleanup(struct io_kiocb *req); 14 + 15 + int io_symlinkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe); 16 + int io_symlinkat(struct io_kiocb *req, unsigned int issue_flags); 17 + 18 + int io_linkat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe); 19 + int io_linkat(struct io_kiocb *req, unsigned int issue_flags); 20 + void io_link_cleanup(struct io_kiocb *req);
+1 -282
io_uring/io_uring.c
··· 94 94 95 95 #include "xattr.h" 96 96 #include "nop.h" 97 + #include "fs.h" 97 98 98 99 #define IORING_MAX_ENTRIES 32768 99 100 #define IORING_MAX_CQ_ENTRIES (2 * IORING_MAX_ENTRIES) ··· 466 465 struct io_shutdown { 467 466 struct file *file; 468 467 int how; 469 - }; 470 - 471 - struct io_rename { 472 - struct file *file; 473 - int old_dfd; 474 - int new_dfd; 475 - struct filename *oldpath; 476 - struct filename *newpath; 477 - int flags; 478 - }; 479 - 480 - struct io_unlink { 481 - struct file *file; 482 - int dfd; 483 - int flags; 484 - struct filename *filename; 485 - }; 486 - 487 - struct io_mkdir { 488 - struct file *file; 489 - int dfd; 490 - umode_t mode; 491 - struct filename *filename; 492 - }; 493 - 494 - struct io_link { 495 - struct file *file; 496 - int old_dfd; 497 - int new_dfd; 498 - struct filename *oldpath; 499 - struct filename *newpath; 500 - int flags; 501 468 }; 502 469 503 470 struct io_msg { ··· 3812 3843 if (iovec) 3813 3844 kfree(iovec); 3814 3845 return ret; 3815 - } 3816 - 3817 - static int io_renameat_prep(struct io_kiocb *req, 3818 - const struct io_uring_sqe *sqe) 3819 - { 3820 - struct io_rename *ren = io_kiocb_to_cmd(req); 3821 - const char __user *oldf, *newf; 3822 - 3823 - if (sqe->buf_index || sqe->splice_fd_in) 3824 - return -EINVAL; 3825 - if (unlikely(req->flags & REQ_F_FIXED_FILE)) 3826 - return -EBADF; 3827 - 3828 - ren->old_dfd = READ_ONCE(sqe->fd); 3829 - oldf = u64_to_user_ptr(READ_ONCE(sqe->addr)); 3830 - newf = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 3831 - ren->new_dfd = READ_ONCE(sqe->len); 3832 - ren->flags = READ_ONCE(sqe->rename_flags); 3833 - 3834 - ren->oldpath = getname(oldf); 3835 - if (IS_ERR(ren->oldpath)) 3836 - return PTR_ERR(ren->oldpath); 3837 - 3838 - ren->newpath = getname(newf); 3839 - if (IS_ERR(ren->newpath)) { 3840 - putname(ren->oldpath); 3841 - return PTR_ERR(ren->newpath); 3842 - } 3843 - 3844 - req->flags |= REQ_F_NEED_CLEANUP; 3845 - return 0; 3846 - } 3847 - 3848 - static int io_renameat(struct io_kiocb *req, unsigned int issue_flags) 3849 - { 3850 - struct io_rename *ren = io_kiocb_to_cmd(req); 3851 - int ret; 3852 - 3853 - if (issue_flags & IO_URING_F_NONBLOCK) 3854 - return -EAGAIN; 3855 - 3856 - ret = do_renameat2(ren->old_dfd, ren->oldpath, ren->new_dfd, 3857 - ren->newpath, ren->flags); 3858 - 3859 - req->flags &= ~REQ_F_NEED_CLEANUP; 3860 - io_req_set_res(req, ret, 0); 3861 - return IOU_OK; 3862 - } 3863 - 3864 - static void io_renameat_cleanup(struct io_kiocb *req) 3865 - { 3866 - struct io_rename *ren = io_kiocb_to_cmd(req); 3867 - 3868 - putname(ren->oldpath); 3869 - putname(ren->newpath); 3870 - } 3871 - 3872 - static int io_unlinkat_prep(struct io_kiocb *req, 3873 - const struct io_uring_sqe *sqe) 3874 - { 3875 - struct io_unlink *un = io_kiocb_to_cmd(req); 3876 - const char __user *fname; 3877 - 3878 - if (sqe->off || sqe->len || sqe->buf_index || sqe->splice_fd_in) 3879 - return -EINVAL; 3880 - if (unlikely(req->flags & REQ_F_FIXED_FILE)) 3881 - return -EBADF; 3882 - 3883 - un->dfd = READ_ONCE(sqe->fd); 3884 - 3885 - un->flags = READ_ONCE(sqe->unlink_flags); 3886 - if (un->flags & ~AT_REMOVEDIR) 3887 - return -EINVAL; 3888 - 3889 - fname = u64_to_user_ptr(READ_ONCE(sqe->addr)); 3890 - un->filename = getname(fname); 3891 - if (IS_ERR(un->filename)) 3892 - return PTR_ERR(un->filename); 3893 - 3894 - req->flags |= REQ_F_NEED_CLEANUP; 3895 - return 0; 3896 - } 3897 - 3898 - static int io_unlinkat(struct io_kiocb *req, unsigned int issue_flags) 3899 - { 3900 - struct io_unlink *un = io_kiocb_to_cmd(req); 3901 - int ret; 3902 - 3903 - if (issue_flags & IO_URING_F_NONBLOCK) 3904 - return -EAGAIN; 3905 - 3906 - if (un->flags & AT_REMOVEDIR) 3907 - ret = do_rmdir(un->dfd, un->filename); 3908 - else 3909 - ret = do_unlinkat(un->dfd, un->filename); 3910 - 3911 - req->flags &= ~REQ_F_NEED_CLEANUP; 3912 - io_req_set_res(req, ret, 0); 3913 - return IOU_OK; 3914 - } 3915 - 3916 - static void io_unlinkat_cleanup(struct io_kiocb *req) 3917 - { 3918 - struct io_unlink *ul = io_kiocb_to_cmd(req); 3919 - 3920 - putname(ul->filename); 3921 - } 3922 - 3923 - static int io_mkdirat_prep(struct io_kiocb *req, 3924 - const struct io_uring_sqe *sqe) 3925 - { 3926 - struct io_mkdir *mkd = io_kiocb_to_cmd(req); 3927 - const char __user *fname; 3928 - 3929 - if (sqe->off || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in) 3930 - return -EINVAL; 3931 - if (unlikely(req->flags & REQ_F_FIXED_FILE)) 3932 - return -EBADF; 3933 - 3934 - mkd->dfd = READ_ONCE(sqe->fd); 3935 - mkd->mode = READ_ONCE(sqe->len); 3936 - 3937 - fname = u64_to_user_ptr(READ_ONCE(sqe->addr)); 3938 - mkd->filename = getname(fname); 3939 - if (IS_ERR(mkd->filename)) 3940 - return PTR_ERR(mkd->filename); 3941 - 3942 - req->flags |= REQ_F_NEED_CLEANUP; 3943 - return 0; 3944 - } 3945 - 3946 - static int io_mkdirat(struct io_kiocb *req, unsigned int issue_flags) 3947 - { 3948 - struct io_mkdir *mkd = io_kiocb_to_cmd(req); 3949 - int ret; 3950 - 3951 - if (issue_flags & IO_URING_F_NONBLOCK) 3952 - return -EAGAIN; 3953 - 3954 - ret = do_mkdirat(mkd->dfd, mkd->filename, mkd->mode); 3955 - 3956 - req->flags &= ~REQ_F_NEED_CLEANUP; 3957 - io_req_set_res(req, ret, 0); 3958 - return IOU_OK; 3959 - } 3960 - 3961 - static void io_mkdirat_cleanup(struct io_kiocb *req) 3962 - { 3963 - struct io_mkdir *md = io_kiocb_to_cmd(req); 3964 - 3965 - putname(md->filename); 3966 - } 3967 - 3968 - static int io_symlinkat_prep(struct io_kiocb *req, 3969 - const struct io_uring_sqe *sqe) 3970 - { 3971 - struct io_link *sl = io_kiocb_to_cmd(req); 3972 - const char __user *oldpath, *newpath; 3973 - 3974 - if (sqe->len || sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in) 3975 - return -EINVAL; 3976 - if (unlikely(req->flags & REQ_F_FIXED_FILE)) 3977 - return -EBADF; 3978 - 3979 - sl->new_dfd = READ_ONCE(sqe->fd); 3980 - oldpath = u64_to_user_ptr(READ_ONCE(sqe->addr)); 3981 - newpath = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 3982 - 3983 - sl->oldpath = getname(oldpath); 3984 - if (IS_ERR(sl->oldpath)) 3985 - return PTR_ERR(sl->oldpath); 3986 - 3987 - sl->newpath = getname(newpath); 3988 - if (IS_ERR(sl->newpath)) { 3989 - putname(sl->oldpath); 3990 - return PTR_ERR(sl->newpath); 3991 - } 3992 - 3993 - req->flags |= REQ_F_NEED_CLEANUP; 3994 - return 0; 3995 - } 3996 - 3997 - static int io_symlinkat(struct io_kiocb *req, unsigned int issue_flags) 3998 - { 3999 - struct io_link *sl = io_kiocb_to_cmd(req); 4000 - int ret; 4001 - 4002 - if (issue_flags & IO_URING_F_NONBLOCK) 4003 - return -EAGAIN; 4004 - 4005 - ret = do_symlinkat(sl->oldpath, sl->new_dfd, sl->newpath); 4006 - 4007 - req->flags &= ~REQ_F_NEED_CLEANUP; 4008 - io_req_set_res(req, ret, 0); 4009 - return IOU_OK; 4010 - } 4011 - 4012 - static int io_linkat_prep(struct io_kiocb *req, 4013 - const struct io_uring_sqe *sqe) 4014 - { 4015 - struct io_link *lnk = io_kiocb_to_cmd(req); 4016 - const char __user *oldf, *newf; 4017 - 4018 - if (sqe->rw_flags || sqe->buf_index || sqe->splice_fd_in) 4019 - return -EINVAL; 4020 - if (unlikely(req->flags & REQ_F_FIXED_FILE)) 4021 - return -EBADF; 4022 - 4023 - lnk->old_dfd = READ_ONCE(sqe->fd); 4024 - lnk->new_dfd = READ_ONCE(sqe->len); 4025 - oldf = u64_to_user_ptr(READ_ONCE(sqe->addr)); 4026 - newf = u64_to_user_ptr(READ_ONCE(sqe->addr2)); 4027 - lnk->flags = READ_ONCE(sqe->hardlink_flags); 4028 - 4029 - lnk->oldpath = getname(oldf); 4030 - if (IS_ERR(lnk->oldpath)) 4031 - return PTR_ERR(lnk->oldpath); 4032 - 4033 - lnk->newpath = getname(newf); 4034 - if (IS_ERR(lnk->newpath)) { 4035 - putname(lnk->oldpath); 4036 - return PTR_ERR(lnk->newpath); 4037 - } 4038 - 4039 - req->flags |= REQ_F_NEED_CLEANUP; 4040 - return 0; 4041 - } 4042 - 4043 - static int io_linkat(struct io_kiocb *req, unsigned int issue_flags) 4044 - { 4045 - struct io_link *lnk = io_kiocb_to_cmd(req); 4046 - int ret; 4047 - 4048 - if (issue_flags & IO_URING_F_NONBLOCK) 4049 - return -EAGAIN; 4050 - 4051 - ret = do_linkat(lnk->old_dfd, lnk->oldpath, lnk->new_dfd, 4052 - lnk->newpath, lnk->flags); 4053 - 4054 - req->flags &= ~REQ_F_NEED_CLEANUP; 4055 - io_req_set_res(req, ret, 0); 4056 - return IOU_OK; 4057 - } 4058 - 4059 - static void io_link_cleanup(struct io_kiocb *req) 4060 - { 4061 - struct io_link *sl = io_kiocb_to_cmd(req); 4062 - 4063 - putname(sl->oldpath); 4064 - putname(sl->newpath); 4065 3846 } 4066 3847 4067 3848 static void io_uring_cmd_work(struct io_kiocb *req, bool *locked)