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/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
15#include "io_uring.h"
16#include "rsrc.h"
17#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
34static bool io_openat_force_async(struct io_open *open)
35{
36 /*
37 * Don't bother trying for O_TRUNC, O_CREAT, or O_TMPFILE open,
38 * it'll always -EAGAIN. Note that we test for __O_TMPFILE because
39 * O_TMPFILE includes O_DIRECTORY, which isn't a flag we need to force
40 * async for.
41 */
42 return open->how.flags & (O_TRUNC | O_CREAT | __O_TMPFILE);
43}
44
45static int __io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
46{
47 struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
48 const char __user *fname;
49 int ret;
50
51 if (unlikely(sqe->buf_index))
52 return -EINVAL;
53 if (unlikely(req->flags & REQ_F_FIXED_FILE))
54 return -EBADF;
55
56 /* open.how should be already initialised */
57 if (!(open->how.flags & O_PATH) && force_o_largefile())
58 open->how.flags |= O_LARGEFILE;
59
60 open->dfd = READ_ONCE(sqe->fd);
61 fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
62 open->filename = getname(fname);
63 if (IS_ERR(ptr: open->filename)) {
64 ret = PTR_ERR(ptr: open->filename);
65 open->filename = NULL;
66 return ret;
67 }
68
69 open->file_slot = READ_ONCE(sqe->file_index);
70 if (open->file_slot && (open->how.flags & O_CLOEXEC))
71 return -EINVAL;
72
73 open->nofile = rlimit(RLIMIT_NOFILE);
74 req->flags |= REQ_F_NEED_CLEANUP;
75 if (io_openat_force_async(open))
76 req->flags |= REQ_F_FORCE_ASYNC;
77 return 0;
78}
79
80int io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
81{
82 struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
83 u64 mode = READ_ONCE(sqe->len);
84 u64 flags = READ_ONCE(sqe->open_flags);
85
86 open->how = build_open_how(flags, mode);
87 return __io_openat_prep(req, sqe);
88}
89
90int io_openat2_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
91{
92 struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
93 struct open_how __user *how;
94 size_t len;
95 int ret;
96
97 how = u64_to_user_ptr(READ_ONCE(sqe->addr2));
98 len = READ_ONCE(sqe->len);
99 if (len < OPEN_HOW_SIZE_VER0)
100 return -EINVAL;
101
102 ret = copy_struct_from_user(dst: &open->how, ksize: sizeof(open->how), src: how, usize: len);
103 if (ret)
104 return ret;
105
106 return __io_openat_prep(req, sqe);
107}
108
109int io_openat2(struct io_kiocb *req, unsigned int issue_flags)
110{
111 struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
112 struct open_flags op;
113 struct file *file;
114 bool resolve_nonblock, nonblock_set;
115 bool fixed = !!open->file_slot;
116 int ret;
117
118 ret = build_open_flags(how: &open->how, op: &op);
119 if (ret)
120 goto err;
121 nonblock_set = op.open_flag & O_NONBLOCK;
122 resolve_nonblock = open->how.resolve & RESOLVE_CACHED;
123 if (issue_flags & IO_URING_F_NONBLOCK) {
124 WARN_ON_ONCE(io_openat_force_async(open));
125 op.lookup_flags |= LOOKUP_CACHED;
126 op.open_flag |= O_NONBLOCK;
127 }
128
129 if (!fixed) {
130 ret = __get_unused_fd_flags(flags: open->how.flags, nofile: open->nofile);
131 if (ret < 0)
132 goto err;
133 }
134
135 file = do_filp_open(dfd: open->dfd, pathname: open->filename, op: &op);
136 if (IS_ERR(ptr: file)) {
137 /*
138 * We could hang on to this 'fd' on retrying, but seems like
139 * marginal gain for something that is now known to be a slower
140 * path. So just put it, and we'll get a new one when we retry.
141 */
142 if (!fixed)
143 put_unused_fd(fd: ret);
144
145 ret = PTR_ERR(ptr: file);
146 /* only retry if RESOLVE_CACHED wasn't already set by application */
147 if (ret == -EAGAIN &&
148 (!resolve_nonblock && (issue_flags & IO_URING_F_NONBLOCK)))
149 return -EAGAIN;
150 goto err;
151 }
152
153 if ((issue_flags & IO_URING_F_NONBLOCK) && !nonblock_set)
154 file->f_flags &= ~O_NONBLOCK;
155
156 if (!fixed)
157 fd_install(fd: ret, file);
158 else
159 ret = io_fixed_fd_install(req, issue_flags, file,
160 file_slot: open->file_slot);
161err:
162 putname(name: open->filename);
163 req->flags &= ~REQ_F_NEED_CLEANUP;
164 if (ret < 0)
165 req_set_fail(req);
166 io_req_set_res(req, res: ret, cflags: 0);
167 return IOU_OK;
168}
169
170int io_openat(struct io_kiocb *req, unsigned int issue_flags)
171{
172 return io_openat2(req, issue_flags);
173}
174
175void io_open_cleanup(struct io_kiocb *req)
176{
177 struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
178
179 if (open->filename)
180 putname(name: open->filename);
181}
182
183int __io_close_fixed(struct io_ring_ctx *ctx, unsigned int issue_flags,
184 unsigned int offset)
185{
186 int ret;
187
188 io_ring_submit_lock(ctx, issue_flags);
189 ret = io_fixed_fd_remove(ctx, offset);
190 io_ring_submit_unlock(ctx, issue_flags);
191
192 return ret;
193}
194
195static inline int io_close_fixed(struct io_kiocb *req, unsigned int issue_flags)
196{
197 struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
198
199 return __io_close_fixed(ctx: req->ctx, issue_flags, offset: close->file_slot - 1);
200}
201
202int io_close_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
203{
204 struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
205
206 if (sqe->off || sqe->addr || sqe->len || sqe->rw_flags || sqe->buf_index)
207 return -EINVAL;
208 if (req->flags & REQ_F_FIXED_FILE)
209 return -EBADF;
210
211 close->fd = READ_ONCE(sqe->fd);
212 close->file_slot = READ_ONCE(sqe->file_index);
213 if (close->file_slot && close->fd)
214 return -EINVAL;
215
216 return 0;
217}
218
219int io_close(struct io_kiocb *req, unsigned int issue_flags)
220{
221 struct files_struct *files = current->files;
222 struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
223 struct file *file;
224 int ret = -EBADF;
225
226 if (close->file_slot) {
227 ret = io_close_fixed(req, issue_flags);
228 goto err;
229 }
230
231 spin_lock(lock: &files->file_lock);
232 file = files_lookup_fd_locked(files, fd: close->fd);
233 if (!file || io_is_uring_fops(file)) {
234 spin_unlock(lock: &files->file_lock);
235 goto err;
236 }
237
238 /* if the file has a flush method, be safe and punt to async */
239 if (file->f_op->flush && (issue_flags & IO_URING_F_NONBLOCK)) {
240 spin_unlock(lock: &files->file_lock);
241 return -EAGAIN;
242 }
243
244 file = __close_fd_get_file(fd: close->fd);
245 spin_unlock(lock: &files->file_lock);
246 if (!file)
247 goto err;
248
249 /* No ->flush() or already async, safely close from here */
250 ret = filp_close(file, current->files);
251err:
252 if (ret < 0)
253 req_set_fail(req);
254 io_req_set_res(req, res: ret, cflags: 0);
255 return IOU_OK;
256}
257

source code of linux/io_uring/openclose.c