[linux-block.git] / io_uring / openclose.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/fdtable.h>
#include <linux/fsnotify.h>
#include <linux/namei.h>
#include <linux/io_uring.h>

#include <uapi/linux/io_uring.h>

#include "../fs/internal.h"

#include "io_uring.h"
#include "rsrc.h"
#include "openclose.h"

struct io_open {
	struct file			*file;
	int				dfd;
	u32				file_slot;
	struct filename			*filename;
	struct open_how			how;
	unsigned long			nofile;
};

struct io_close {
	struct file			*file;
	int				fd;
	u32				file_slot;
};

struct io_fixed_install {
	struct file			*file;
	unsigned int			o_flags;
};

static bool io_openat_force_async(struct io_open *open)
{
	/*
	 * Don't bother trying for O_TRUNC, O_CREAT, or O_TMPFILE open,
	 * it'll always -EAGAIN. Note that we test for __O_TMPFILE because
	 * O_TMPFILE includes O_DIRECTORY, which isn't a flag we need to force
	 * async for.
	 */
	return open->how.flags & (O_TRUNC | O_CREAT | __O_TMPFILE);
}

static int __io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
	const char __user *fname;
	int ret;

	if (unlikely(sqe->buf_index))
		return -EINVAL;
	if (unlikely(req->flags & REQ_F_FIXED_FILE))
		return -EBADF;

	/* open.how should be already initialised */
	if (!(open->how.flags & O_PATH) && force_o_largefile())
		open->how.flags |= O_LARGEFILE;

	open->dfd = READ_ONCE(sqe->fd);
	fname = u64_to_user_ptr(READ_ONCE(sqe->addr));
	open->filename = getname(fname);
	if (IS_ERR(open->filename)) {
		ret = PTR_ERR(open->filename);
		open->filename = NULL;
		return ret;
	}

	open->file_slot = READ_ONCE(sqe->file_index);
	if (open->file_slot && (open->how.flags & O_CLOEXEC))
		return -EINVAL;

	open->nofile = rlimit(RLIMIT_NOFILE);
	req->flags |= REQ_F_NEED_CLEANUP;
	if (io_openat_force_async(open))
		req->flags |= REQ_F_FORCE_ASYNC;
	return 0;
}

int io_openat_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
	u64 mode = READ_ONCE(sqe->len);
	u64 flags = READ_ONCE(sqe->open_flags);

	open->how = build_open_how(flags, mode);
	return __io_openat_prep(req, sqe);
}

int io_openat2_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
	struct open_how __user *how;
	size_t len;
	int ret;

	how = u64_to_user_ptr(READ_ONCE(sqe->addr2));
	len = READ_ONCE(sqe->len);
	if (len < OPEN_HOW_SIZE_VER0)
		return -EINVAL;

	ret = copy_struct_from_user(&open->how, sizeof(open->how), how, len);
	if (ret)
		return ret;

	return __io_openat_prep(req, sqe);
}

int io_openat2(struct io_kiocb *req, unsigned int issue_flags)
{
	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
	struct open_flags op;
	struct file *file;
	bool resolve_nonblock, nonblock_set;
	bool fixed = !!open->file_slot;
	int ret;

	ret = build_open_flags(&open->how, &op);
	if (ret)
		goto err;
	nonblock_set = op.open_flag & O_NONBLOCK;
	resolve_nonblock = open->how.resolve & RESOLVE_CACHED;
	if (issue_flags & IO_URING_F_NONBLOCK) {
		WARN_ON_ONCE(io_openat_force_async(open));
		op.lookup_flags |= LOOKUP_CACHED;
		op.open_flag |= O_NONBLOCK;
	}

	if (!fixed) {
		ret = __get_unused_fd_flags(open->how.flags, open->nofile);
		if (ret < 0)
			goto err;
	}

	file = do_filp_open(open->dfd, open->filename, &op);
	if (IS_ERR(file)) {
		/*
		 * We could hang on to this 'fd' on retrying, but seems like
		 * marginal gain for something that is now known to be a slower
		 * path. So just put it, and we'll get a new one when we retry.
		 */
		if (!fixed)
			put_unused_fd(ret);

		ret = PTR_ERR(file);
		/* only retry if RESOLVE_CACHED wasn't already set by application */
		if (ret == -EAGAIN &&
		    (!resolve_nonblock && (issue_flags & IO_URING_F_NONBLOCK)))
			return -EAGAIN;
		goto err;
	}

	if ((issue_flags & IO_URING_F_NONBLOCK) && !nonblock_set)
		file->f_flags &= ~O_NONBLOCK;

	if (!fixed)
		fd_install(ret, file);
	else
		ret = io_fixed_fd_install(req, issue_flags, file,
						open->file_slot);
err:
	putname(open->filename);
	req->flags &= ~REQ_F_NEED_CLEANUP;
	if (ret < 0)
		req_set_fail(req);
	io_req_set_res(req, ret, 0);
	return IOU_OK;
}

int io_openat(struct io_kiocb *req, unsigned int issue_flags)
{
	return io_openat2(req, issue_flags);
}

void io_open_cleanup(struct io_kiocb *req)
{
	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);

	if (open->filename)
		putname(open->filename);
}

int __io_close_fixed(struct io_ring_ctx *ctx, unsigned int issue_flags,
		     unsigned int offset)
{
	int ret;

	io_ring_submit_lock(ctx, issue_flags);
	ret = io_fixed_fd_remove(ctx, offset);
	io_ring_submit_unlock(ctx, issue_flags);

	return ret;
}

static inline int io_close_fixed(struct io_kiocb *req, unsigned int issue_flags)
{
	struct io_close *close = io_kiocb_to_cmd(req, struct io_close);

	return __io_close_fixed(req->ctx, issue_flags, close->file_slot - 1);
}

int io_close_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_close *close = io_kiocb_to_cmd(req, struct io_close);

	if (sqe->off || sqe->addr || sqe->len || sqe->rw_flags || sqe->buf_index)
		return -EINVAL;
	if (req->flags & REQ_F_FIXED_FILE)
		return -EBADF;

	close->fd = READ_ONCE(sqe->fd);
	close->file_slot = READ_ONCE(sqe->file_index);
	if (close->file_slot && close->fd)
		return -EINVAL;

	return 0;
}

int io_close(struct io_kiocb *req, unsigned int issue_flags)
{
	struct files_struct *files = current->files;
	struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
	struct file *file;
	int ret = -EBADF;

	if (close->file_slot) {
		ret = io_close_fixed(req, issue_flags);
		goto err;
	}

	spin_lock(&files->file_lock);
	file = files_lookup_fd_locked(files, close->fd);
	if (!file || io_is_uring_fops(file)) {
		spin_unlock(&files->file_lock);
		goto err;
	}

	/* if the file has a flush method, be safe and punt to async */
	if (file->f_op->flush && (issue_flags & IO_URING_F_NONBLOCK)) {
		spin_unlock(&files->file_lock);
		return -EAGAIN;
	}

	file = file_close_fd_locked(files, close->fd);
	spin_unlock(&files->file_lock);
	if (!file)
		goto err;

	/* No ->flush() or already async, safely close from here */
	ret = filp_close(file, current->files);
err:
	if (ret < 0)
		req_set_fail(req);
	io_req_set_res(req, ret, 0);
	return IOU_OK;
}

int io_install_fixed_fd_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_fixed_install *ifi;
	unsigned int flags;

	if (sqe->off || sqe->addr || sqe->len || sqe->buf_index ||
	    sqe->splice_fd_in || sqe->addr3)
		return -EINVAL;

	/* must be a fixed file */
	if (!(req->flags & REQ_F_FIXED_FILE))
		return -EBADF;

	flags = READ_ONCE(sqe->install_fd_flags);
	if (flags & ~IORING_FIXED_FD_NO_CLOEXEC)
		return -EINVAL;

	/* ensure the task's creds are used when installing/receiving fds */
	if (req->flags & REQ_F_CREDS)
		return -EPERM;

	/* default to O_CLOEXEC, disable if IORING_FIXED_FD_NO_CLOEXEC is set */
	ifi = io_kiocb_to_cmd(req, struct io_fixed_install);
	ifi->o_flags = O_CLOEXEC;
	if (flags & IORING_FIXED_FD_NO_CLOEXEC)
		ifi->o_flags = 0;

	return 0;
}

int io_install_fixed_fd(struct io_kiocb *req, unsigned int issue_flags)
{
	struct io_fixed_install *ifi;
	int ret;

	ifi = io_kiocb_to_cmd(req, struct io_fixed_install);
	ret = receive_fd(req->file, NULL, ifi->o_flags);
	if (ret < 0)
		req_set_fail(req);
	io_req_set_res(req, ret, 0);
	return IOU_OK;
}
Commit	Line	Data
cd40cae2 JA	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
cd40cae2	15	#include "io_uring.h"
73572984	16	#include "rsrc.h"
cd40cae2 JA	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
dc18b89a JA	34	struct io_fixed_install {
	35	struct file *file;
	36	unsigned int o_flags;
	37	};
	38
0ffae640 DY	39	static 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,
72dbde0f AS	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.
0ffae640	46	*/
72dbde0f	47	return open->how.flags & (O_TRUNC \| O_CREAT \| __O_TMPFILE);
0ffae640 DY	48	}
0ffae640 DY	49
cd40cae2 JA	50	static int __io_openat_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
cd40cae2 JA	51	{
f2ccb5ae	52	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
cd40cae2 JA	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;
0ffae640 DY	80	if (io_openat_force_async(open))
0ffae640 DY	81	req->flags \|= REQ_F_FORCE_ASYNC;
cd40cae2 JA	82	return 0;
	83	}
	84
	85	int io_openat_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
	86	{
f2ccb5ae	87	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
cd40cae2 JA	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
	95	int io_openat2_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
	96	{
f2ccb5ae	97	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
cd40cae2 JA	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
	114	int io_openat2(struct io_kiocb *req, unsigned int issue_flags)
	115	{
f2ccb5ae	116	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
cd40cae2 JA	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) {
0ffae640	129	WARN_ON_ONCE(io_openat_force_async(open));
cd40cae2 JA	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;
cd40cae2 JA	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);
	166	err:
	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
	175	int io_openat(struct io_kiocb *req, unsigned int issue_flags)
	176	{
	177	return io_openat2(req, issue_flags);
	178	}
	179
	180	void io_open_cleanup(struct io_kiocb *req)
	181	{
f2ccb5ae	182	struct io_open *open = io_kiocb_to_cmd(req, struct io_open);
cd40cae2 JA	183
	184	if (open->filename)
	185	putname(open->filename);
	186	}
	187
f110ed84	188	int __io_close_fixed(struct io_ring_ctx *ctx, unsigned int issue_flags,
cd40cae2 JA	189	unsigned int offset)
cd40cae2 JA	190	{
cd40cae2 JA	191	int ret;
	192
	193	io_ring_submit_lock(ctx, issue_flags);
f110ed84	194	ret = io_fixed_fd_remove(ctx, offset);
cd40cae2	195	io_ring_submit_unlock(ctx, issue_flags);
f110ed84	196
cd40cae2 JA	197	return ret;
	198	}
	199
	200	static inline int io_close_fixed(struct io_kiocb *req, unsigned int issue_flags)
	201	{
f2ccb5ae	202	struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
cd40cae2	203
f110ed84	204	return __io_close_fixed(req->ctx, issue_flags, close->file_slot - 1);
cd40cae2 JA	205	}
	206
	207	int io_close_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
	208	{
f2ccb5ae	209	struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
cd40cae2 JA	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
	224	int io_close(struct io_kiocb *req, unsigned int issue_flags)
	225	{
	226	struct files_struct *files = current->files;
f2ccb5ae	227	struct io_close *close = io_kiocb_to_cmd(req, struct io_close);
cd40cae2 JA	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);
50d910d2	237	file = files_lookup_fd_locked(files, close->fd);
cd40cae2 JA	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
24fa3ae9	249	file = file_close_fd_locked(files, close->fd);
cd40cae2 JA	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);
	256	err:
	257	if (ret < 0)
	258	req_set_fail(req);
	259	io_req_set_res(req, ret, 0);
	260	return IOU_OK;
	261	}
dc18b89a JA	262
	263	int 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
16bae3e1 PM	280	/* ensure the task's creds are used when installing/receiving fds */
	281	if (req->flags & REQ_F_CREDS)
	282	return -EPERM;
	283
dc18b89a JA	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
	293	int 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	}