Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
+1
-1
io_uring/Makefile
+294
io_uring/fs.c
+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
+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
+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)