[linux-block.git] / io_uring / sync.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/mm.h>
#include <linux/slab.h>
#include <linux/namei.h>
#include <linux/io_uring.h>
#include <linux/fsnotify.h>

#include <uapi/linux/io_uring.h>

#include "io_uring.h"
#include "sync.h"

struct io_sync {
	struct file			*file;
	loff_t				len;
	loff_t				off;
	int				flags;
	int				mode;
};

int io_sfr_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);

	if (unlikely(sqe->addr || sqe->buf_index || sqe->splice_fd_in))
		return -EINVAL;

	sync->off = READ_ONCE(sqe->off);
	sync->len = READ_ONCE(sqe->len);
	sync->flags = READ_ONCE(sqe->sync_range_flags);
	req->flags |= REQ_F_FORCE_ASYNC;

	return 0;
}

int io_sync_file_range(struct io_kiocb *req, unsigned int issue_flags)
{
	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);
	int ret;

	/* sync_file_range always requires a blocking context */
	WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);

	ret = sync_file_range(req->file, sync->off, sync->len, sync->flags);
	io_req_set_res(req, ret, 0);
	return IOU_OK;
}

int io_fsync_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);

	if (unlikely(sqe->addr || sqe->buf_index || sqe->splice_fd_in))
		return -EINVAL;

	sync->flags = READ_ONCE(sqe->fsync_flags);
	if (unlikely(sync->flags & ~IORING_FSYNC_DATASYNC))
		return -EINVAL;

	sync->off = READ_ONCE(sqe->off);
	sync->len = READ_ONCE(sqe->len);
	req->flags |= REQ_F_FORCE_ASYNC;
	return 0;
}

int io_fsync(struct io_kiocb *req, unsigned int issue_flags)
{
	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);
	loff_t end = sync->off + sync->len;
	int ret;

	/* fsync always requires a blocking context */
	WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);

	ret = vfs_fsync_range(req->file, sync->off, end > 0 ? end : LLONG_MAX,
				sync->flags & IORING_FSYNC_DATASYNC);
	io_req_set_res(req, ret, 0);
	return IOU_OK;
}

int io_fallocate_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);

	if (sqe->buf_index || sqe->rw_flags || sqe->splice_fd_in)
		return -EINVAL;

	sync->off = READ_ONCE(sqe->off);
	sync->len = READ_ONCE(sqe->addr);
	sync->mode = READ_ONCE(sqe->len);
	req->flags |= REQ_F_FORCE_ASYNC;
	return 0;
}

int io_fallocate(struct io_kiocb *req, unsigned int issue_flags)
{
	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);
	int ret;

	/* fallocate always requiring blocking context */
	WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);

	ret = vfs_fallocate(req->file, sync->mode, sync->off, sync->len);
	if (ret >= 0)
		fsnotify_modify(req->file);
	io_req_set_res(req, ret, 0);
	return IOU_OK;
}
Commit	Line	Data
0d584727 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/mm.h>
	7	#include <linux/slab.h>
	8	#include <linux/namei.h>
	9	#include <linux/io_uring.h>
	10	#include <linux/fsnotify.h>
	11
	12	#include <uapi/linux/io_uring.h>
	13
0d584727 JA	14	#include "io_uring.h"
	15	#include "sync.h"
	16
	17	struct io_sync {
	18	struct file *file;
	19	loff_t len;
	20	loff_t off;
	21	int flags;
	22	int mode;
	23	};
	24
	25	int io_sfr_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
	26	{
f2ccb5ae	27	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);
0d584727 JA	28
	29	if (unlikely(sqe->addr \|\| sqe->buf_index \|\| sqe->splice_fd_in))
	30	return -EINVAL;
	31
	32	sync->off = READ_ONCE(sqe->off);
	33	sync->len = READ_ONCE(sqe->len);
	34	sync->flags = READ_ONCE(sqe->sync_range_flags);
aebb224f DY	35	req->flags \|= REQ_F_FORCE_ASYNC;
aebb224f DY	36
0d584727 JA	37	return 0;
	38	}
	39
	40	int io_sync_file_range(struct io_kiocb *req, unsigned int issue_flags)
	41	{
f2ccb5ae	42	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);
0d584727 JA	43	int ret;
	44
	45	/* sync_file_range always requires a blocking context */
aebb224f	46	WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
0d584727 JA	47
	48	ret = sync_file_range(req->file, sync->off, sync->len, sync->flags);
	49	io_req_set_res(req, ret, 0);
	50	return IOU_OK;
	51	}
	52
	53	int io_fsync_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
	54	{
f2ccb5ae	55	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);
0d584727 JA	56
	57	if (unlikely(sqe->addr \|\| sqe->buf_index \|\| sqe->splice_fd_in))
	58	return -EINVAL;
	59
	60	sync->flags = READ_ONCE(sqe->fsync_flags);
	61	if (unlikely(sync->flags & ~IORING_FSYNC_DATASYNC))
	62	return -EINVAL;
	63
	64	sync->off = READ_ONCE(sqe->off);
	65	sync->len = READ_ONCE(sqe->len);
aebb224f	66	req->flags \|= REQ_F_FORCE_ASYNC;
0d584727 JA	67	return 0;
	68	}
	69
	70	int io_fsync(struct io_kiocb *req, unsigned int issue_flags)
	71	{
f2ccb5ae	72	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);
0d584727 JA	73	loff_t end = sync->off + sync->len;
	74	int ret;
	75
	76	/* fsync always requires a blocking context */
aebb224f	77	WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
0d584727 JA	78
	79	ret = vfs_fsync_range(req->file, sync->off, end > 0 ? end : LLONG_MAX,
	80	sync->flags & IORING_FSYNC_DATASYNC);
	81	io_req_set_res(req, ret, 0);
	82	return IOU_OK;
	83	}
	84
	85	int io_fallocate_prep(struct io_kiocb req, const struct io_uring_sqe sqe)
	86	{
f2ccb5ae	87	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);
0d584727 JA	88
	89	if (sqe->buf_index \|\| sqe->rw_flags \|\| sqe->splice_fd_in)
	90	return -EINVAL;
	91
	92	sync->off = READ_ONCE(sqe->off);
	93	sync->len = READ_ONCE(sqe->addr);
	94	sync->mode = READ_ONCE(sqe->len);
aebb224f	95	req->flags \|= REQ_F_FORCE_ASYNC;
0d584727 JA	96	return 0;
	97	}
	98
	99	int io_fallocate(struct io_kiocb *req, unsigned int issue_flags)
	100	{
f2ccb5ae	101	struct io_sync *sync = io_kiocb_to_cmd(req, struct io_sync);
0d584727 JA	102	int ret;
	103
	104	/* fallocate always requiring blocking context */
aebb224f DY	105	WARN_ON_ONCE(issue_flags & IO_URING_F_NONBLOCK);
aebb224f DY	106
0d584727 JA	107	ret = vfs_fallocate(req->file, sync->mode, sync->off, sync->len);
	108	if (ret >= 0)
	109	fsnotify_modify(req->file);
	110	io_req_set_res(req, ret, 0);
	111	return IOU_OK;
	112	}