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
34struct io_fixed_install {
35	struct file			*file;
36	unsigned int			o_flags;
37};
38
39static 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,
43	 * 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.
46	 */
47	return open->how.flags & (O_TRUNC | O_CREAT | __O_TMPFILE);
48}
49
50static int __io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
51{
52	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
53	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;
80	if (io_openat_force_async(open))
81		req->flags |= REQ_F_FORCE_ASYNC;
82	return 0;
83}
84
85int io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
86{
87	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
88	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{
97	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
98	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{
116	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
117	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) {
129		WARN_ON_ONCE(io_openat_force_async(open));
130		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;
160
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{
182	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
183
184	if (open->filename)
185		putname(open->filename);
186}
187
188int __io_close_fixed(struct io_ring_ctx *ctx, unsigned int issue_flags,
189		     unsigned int offset)
190{
191	int ret;
192
193	io_ring_submit_lock(ctx, issue_flags);
194	ret = io_fixed_fd_remove(ctx, offset);
195	io_ring_submit_unlock(ctx, issue_flags);
196
197	return ret;
198}
199
200static inline int io_close_fixed(struct io_kiocb *req, unsigned int issue_flags)
201{
202	struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
203
204	return __io_close_fixed(req->ctx, issue_flags, close->file_slot - 1);
205}
206
207int io_close_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
208{
209	struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
210
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;
227	struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
228	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);
237	file = files_lookup_fd_locked(files, close->fd);
238	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
249	file = file_close_fd_locked(files, close->fd);
250	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}
262
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
280	/* ensure the task's creds are used when installing/receiving fds */
281	if (req->flags & REQ_F_CREDS)
282		return -EPERM;
283
284	/* 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}
305