blob: e3357dfa14ca42dd5b25e6cf9ce4a4be8b7ee0f4 [file] [log] [blame]
Jens Axboecd40cae2022-05-24 21:54:43 -06001// 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/fdtable.h>
7#include <linux/fsnotify.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
Jens Axboecd40cae2022-05-24 21:54:43 -060015#include "io_uring.h"
Jens Axboe73572982022-06-13 07:12:45 -060016#include "rsrc.h"
Jens Axboecd40cae2022-05-24 21:54:43 -060017#include "openclose.h"
18
19struct io_open {
20 struct file *file;
21 int dfd;
22 u32 file_slot;
23 struct filename *filename;
24 struct open_how how;
25 unsigned long nofile;
26};
27
28struct io_close {
29 struct file *file;
30 int fd;
31 u32 file_slot;
32};
33
Jens Axboedc18b892023-12-07 20:06:02 -070034struct io_fixed_install {
35 struct file *file;
36 unsigned int o_flags;
37};
38
Dylan Yudaken0ffae642023-01-27 05:52:27 -080039static bool io_openat_force_async(struct io_open *open)
40{
41 /*
42 * Don't bother trying for O_TRUNC, O_CREAT, or O_TMPFILE open,
Aleksa Sarai72dbde02023-08-07 12:24:15 +100043 * it'll always -EAGAIN. Note that we test for __O_TMPFILE because
44 * O_TMPFILE includes O_DIRECTORY, which isn't a flag we need to force
45 * async for.
Dylan Yudaken0ffae642023-01-27 05:52:27 -080046 */
Aleksa Sarai72dbde02023-08-07 12:24:15 +100047 return open->how.flags & (O_TRUNC | O_CREAT | __O_TMPFILE);
Dylan Yudaken0ffae642023-01-27 05:52:27 -080048}
49
Jens Axboecd40cae2022-05-24 21:54:43 -060050static int __io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
51{
Stefan Metzmacherf2ccb5a2022-08-11 09:11:15 +020052 struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
Jens Axboecd40cae2022-05-24 21:54:43 -060053 const char __user *fname;
54 int ret;
55
56 if (unlikely(sqe->buf_index))
57 return -EINVAL;
58 if (unlikely(req->flags & REQ_F_FIXED_FILE))
59 return -EBADF;
60
61 /* open.how should be already initialised */
62 if (!(open->how.flags & O_PATH) && force_o_largefile())
63 open->how.flags |= O_LARGEFILE;
64
65 open->dfd = READ_ONCE(sqe->fd);
66 fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
67 open->filename = getname(fname);
68 if (IS_ERR(open->filename)) {
69 ret = PTR_ERR(open->filename);
70 open->filename = NULL;
71 return ret;
72 }
73
74 open->file_slot = READ_ONCE(sqe->file_index);
75 if (open->file_slot && (open->how.flags & O_CLOEXEC))
76 return -EINVAL;
77
78 open->nofile = rlimit(RLIMIT_NOFILE);
79 req->flags |= REQ_F_NEED_CLEANUP;
Dylan Yudaken0ffae642023-01-27 05:52:27 -080080 if (io_openat_force_async(open))
81 req->flags |= REQ_F_FORCE_ASYNC;
Jens Axboecd40cae2022-05-24 21:54:43 -060082 return 0;
83}
84
85int io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
86{
Stefan Metzmacherf2ccb5a2022-08-11 09:11:15 +020087 struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
Jens Axboecd40cae2022-05-24 21:54:43 -060088 u64 mode = READ_ONCE(sqe->len);
89 u64 flags = READ_ONCE(sqe->open_flags);
90
91 open->how = build_open_how(flags, mode);
92 return __io_openat_prep(req, sqe);
93}
94
95int io_openat2_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
96{
Stefan Metzmacherf2ccb5a2022-08-11 09:11:15 +020097 struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
Jens Axboecd40cae2022-05-24 21:54:43 -060098 struct open_how __user *how;
99 size_t len;
100 int ret;
101
102 how = u64_to_user_ptr(READ_ONCE(sqe->addr2));
103 len = READ_ONCE(sqe->len);
104 if (len < OPEN_HOW_SIZE_VER0)
105 return -EINVAL;
106
107 ret = copy_struct_from_user(&open->how, sizeof(open->how), how, len);
108 if (ret)
109 return ret;
110
111 return __io_openat_prep(req, sqe);
112}
113
114int io_openat2(struct io_kiocb *req, unsigned int issue_flags)
115{
Stefan Metzmacherf2ccb5a2022-08-11 09:11:15 +0200116 struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
Jens Axboecd40cae2022-05-24 21:54:43 -0600117 struct open_flags op;
118 struct file *file;
119 bool resolve_nonblock, nonblock_set;
120 bool fixed = !!open->file_slot;
121 int ret;
122
123 ret = build_open_flags(&open->how, &op);
124 if (ret)
125 goto err;
126 nonblock_set = op.open_flag & O_NONBLOCK;
127 resolve_nonblock = open->how.resolve & RESOLVE_CACHED;
128 if (issue_flags & IO_URING_F_NONBLOCK) {
Dylan Yudaken0ffae642023-01-27 05:52:27 -0800129 WARN_ON_ONCE(io_openat_force_async(open));
Jens Axboecd40cae2022-05-24 21:54:43 -0600130 op.lookup_flags |= LOOKUP_CACHED;
131 op.open_flag |= O_NONBLOCK;
132 }
133
134 if (!fixed) {
135 ret = __get_unused_fd_flags(open->how.flags, open->nofile);
136 if (ret < 0)
137 goto err;
138 }
139
140 file = do_filp_open(open->dfd, open->filename, &op);
141 if (IS_ERR(file)) {
142 /*
143 * We could hang on to this 'fd' on retrying, but seems like
144 * marginal gain for something that is now known to be a slower
145 * path. So just put it, and we'll get a new one when we retry.
146 */
147 if (!fixed)
148 put_unused_fd(ret);
149
150 ret = PTR_ERR(file);
151 /* only retry if RESOLVE_CACHED wasn't already set by application */
152 if (ret == -EAGAIN &&
153 (!resolve_nonblock && (issue_flags & IO_URING_F_NONBLOCK)))
154 return -EAGAIN;
155 goto err;
156 }
157
158 if ((issue_flags & IO_URING_F_NONBLOCK) && !nonblock_set)
159 file->f_flags &= ~O_NONBLOCK;
Jens Axboecd40cae2022-05-24 21:54:43 -0600160
161 if (!fixed)
162 fd_install(ret, file);
163 else
164 ret = io_fixed_fd_install(req, issue_flags, file,
165 open->file_slot);
166err:
167 putname(open->filename);
168 req->flags &= ~REQ_F_NEED_CLEANUP;
169 if (ret < 0)
170 req_set_fail(req);
171 io_req_set_res(req, ret, 0);
172 return IOU_OK;
173}
174
175int io_openat(struct io_kiocb *req, unsigned int issue_flags)
176{
177 return io_openat2(req, issue_flags);
178}
179
180void io_open_cleanup(struct io_kiocb *req)
181{
Stefan Metzmacherf2ccb5a2022-08-11 09:11:15 +0200182 struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
Jens Axboecd40cae2022-05-24 21:54:43 -0600183
184 if (open->filename)
185 putname(open->filename);
186}
187
Jens Axboef110ed82022-06-13 04:42:56 -0600188int __io_close_fixed(struct io_ring_ctx *ctx, unsigned int issue_flags,
Jens Axboecd40cae2022-05-24 21:54:43 -0600189 unsigned int offset)
190{
Jens Axboecd40cae2022-05-24 21:54:43 -0600191 int ret;
192
193 io_ring_submit_lock(ctx, issue_flags);
Jens Axboef110ed82022-06-13 04:42:56 -0600194 ret = io_fixed_fd_remove(ctx, offset);
Jens Axboecd40cae2022-05-24 21:54:43 -0600195 io_ring_submit_unlock(ctx, issue_flags);
Jens Axboef110ed82022-06-13 04:42:56 -0600196
Jens Axboecd40cae2022-05-24 21:54:43 -0600197 return ret;
198}
199
200static inline int io_close_fixed(struct io_kiocb *req, unsigned int issue_flags)
201{
Stefan Metzmacherf2ccb5a2022-08-11 09:11:15 +0200202 struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
Jens Axboecd40cae2022-05-24 21:54:43 -0600203
Jens Axboef110ed82022-06-13 04:42:56 -0600204 return __io_close_fixed(req->ctx, issue_flags, close->file_slot - 1);
Jens Axboecd40cae2022-05-24 21:54:43 -0600205}
206
207int io_close_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
208{
Stefan Metzmacherf2ccb5a2022-08-11 09:11:15 +0200209 struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
Jens Axboecd40cae2022-05-24 21:54:43 -0600210
211 if (sqe->off || sqe->addr || sqe->len || sqe->rw_flags || sqe->buf_index)
212 return -EINVAL;
213 if (req->flags & REQ_F_FIXED_FILE)
214 return -EBADF;
215
216 close->fd = READ_ONCE(sqe->fd);
217 close->file_slot = READ_ONCE(sqe->file_index);
218 if (close->file_slot && close->fd)
219 return -EINVAL;
220
221 return 0;
222}
223
224int io_close(struct io_kiocb *req, unsigned int issue_flags)
225{
226 struct files_struct *files = current->files;
Stefan Metzmacherf2ccb5a2022-08-11 09:11:15 +0200227 struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
Jens Axboecd40cae2022-05-24 21:54:43 -0600228 struct file *file;
229 int ret = -EBADF;
230
231 if (close->file_slot) {
232 ret = io_close_fixed(req, issue_flags);
233 goto err;
234 }
235
236 spin_lock(&files->file_lock);
Christian Brauner50d910d2023-10-10 10:23:26 +0200237 file = files_lookup_fd_locked(files, close->fd);
Jens Axboecd40cae2022-05-24 21:54:43 -0600238 if (!file || io_is_uring_fops(file)) {
239 spin_unlock(&files->file_lock);
240 goto err;
241 }
242
243 /* if the file has a flush method, be safe and punt to async */
244 if (file->f_op->flush && (issue_flags & IO_URING_F_NONBLOCK)) {
245 spin_unlock(&files->file_lock);
246 return -EAGAIN;
247 }
248
Christian Brauner24fa3ae2023-11-30 13:49:08 +0100249 file = file_close_fd_locked(files, close->fd);
Jens Axboecd40cae2022-05-24 21:54:43 -0600250 spin_unlock(&files->file_lock);
251 if (!file)
252 goto err;
253
254 /* No ->flush() or already async, safely close from here */
255 ret = filp_close(file, current->files);
256err:
257 if (ret < 0)
258 req_set_fail(req);
259 io_req_set_res(req, ret, 0);
260 return IOU_OK;
261}
Jens Axboedc18b892023-12-07 20:06:02 -0700262
263int io_install_fixed_fd_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
264{
265 struct io_fixed_install *ifi;
266 unsigned int flags;
267
268 if (sqe->off || sqe->addr || sqe->len || sqe->buf_index ||
269 sqe->splice_fd_in || sqe->addr3)
270 return -EINVAL;
271
272 /* must be a fixed file */
273 if (!(req->flags & REQ_F_FIXED_FILE))
274 return -EBADF;
275
276 flags = READ_ONCE(sqe->install_fd_flags);
277 if (flags & ~IORING_FIXED_FD_NO_CLOEXEC)
278 return -EINVAL;
279
Paul Moore16bae3e2024-01-23 16:55:02 -0500280 /* ensure the task's creds are used when installing/receiving fds */
281 if (req->flags & REQ_F_CREDS)
282 return -EPERM;
283
Jens Axboedc18b892023-12-07 20:06:02 -0700284 /* default to O_CLOEXEC, disable if IORING_FIXED_FD_NO_CLOEXEC is set */
285 ifi = io_kiocb_to_cmd(req, struct io_fixed_install);
286 ifi->o_flags = O_CLOEXEC;
287 if (flags & IORING_FIXED_FD_NO_CLOEXEC)
288 ifi->o_flags = 0;
289
290 return 0;
291}
292
293int io_install_fixed_fd(struct io_kiocb *req, unsigned int issue_flags)
294{
295 struct io_fixed_install *ifi;
296 int ret;
297
298 ifi = io_kiocb_to_cmd(req, struct io_fixed_install);
299 ret = receive_fd(req->file, NULL, ifi->o_flags);
300 if (ret < 0)
301 req_set_fail(req);
302 io_req_set_res(req, ret, 0);
303 return IOU_OK;
304}