Merge tag 'perf-tools-for-v6.6-1-2023-09-05' of git://git.kernel.org/pub/scm/linux...
[platform/kernel/linux-starfive.git] / io_uring / openclose.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/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
19 struct 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
28 struct io_close {
29         struct file                     *file;
30         int                             fd;
31         u32                             file_slot;
32 };
33
34 static 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
45 static 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(open->filename)) {
64                 ret = PTR_ERR(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
80 int 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
90 int 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(&open->how, sizeof(open->how), how, len);
103         if (ret)
104                 return ret;
105
106         return __io_openat_prep(req, sqe);
107 }
108
109 int 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(&open->how, &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(open->how.flags, open->nofile);
131                 if (ret < 0)
132                         goto err;
133         }
134
135         file = do_filp_open(open->dfd, open->filename, &op);
136         if (IS_ERR(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(ret);
144
145                 ret = PTR_ERR(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(ret, file);
158         else
159                 ret = io_fixed_fd_install(req, issue_flags, file,
160                                                 open->file_slot);
161 err:
162         putname(open->filename);
163         req->flags &= ~REQ_F_NEED_CLEANUP;
164         if (ret < 0)
165                 req_set_fail(req);
166         io_req_set_res(req, ret, 0);
167         return IOU_OK;
168 }
169
170 int io_openat(struct io_kiocb *req, unsigned int issue_flags)
171 {
172         return io_openat2(req, issue_flags);
173 }
174
175 void 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(open->filename);
181 }
182
183 int __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
195 static 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(req->ctx, issue_flags, close->file_slot - 1);
200 }
201
202 int 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
219 int 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 fdtable *fdt;
224         struct file *file;
225         int ret = -EBADF;
226
227         if (close->file_slot) {
228                 ret = io_close_fixed(req, issue_flags);
229                 goto err;
230         }
231
232         spin_lock(&files->file_lock);
233         fdt = files_fdtable(files);
234         if (close->fd >= fdt->max_fds) {
235                 spin_unlock(&files->file_lock);
236                 goto err;
237         }
238         file = rcu_dereference_protected(fdt->fd[close->fd],
239                         lockdep_is_held(&files->file_lock));
240         if (!file || io_is_uring_fops(file)) {
241                 spin_unlock(&files->file_lock);
242                 goto err;
243         }
244
245         /* if the file has a flush method, be safe and punt to async */
246         if (file->f_op->flush && (issue_flags & IO_URING_F_NONBLOCK)) {
247                 spin_unlock(&files->file_lock);
248                 return -EAGAIN;
249         }
250
251         file = __close_fd_get_file(close->fd);
252         spin_unlock(&files->file_lock);
253         if (!file)
254                 goto err;
255
256         /* No ->flush() or already async, safely close from here */
257         ret = filp_close(file, current->files);
258 err:
259         if (ret < 0)
260                 req_set_fail(req);
261         io_req_set_res(req, ret, 0);
262         return IOU_OK;
263 }