io_uring/mock: add basic infra for test mock files
v3 cover io_uring/mock: add basic infra for test mock files
io_uring commands provide an ioctl style interface for files to implement file specific operations. io_uring provides many features and advanced api to commands, and it's getting hard to test as it requires specific files/devices.
Add basic infrastucture for creating special mock files that will be implementing the cmd api and using various io_uring features we want to test. It'll also be useful to test some more obscure read/write/polling edge cases in the future, which was initially suggested by Chase.
v3: fix memleak, + release fop callback
v2: add rw support with basic options
implement features not as bitmask but sequence number
Pavel Begunkov (6):
io_uring/mock: add basic infra for test mock files io_uring/mock: add cmd using vectored regbufs io_uring/mock: add sync read/write io_uring/mock: allow to choose FMODE_NOWAIT io_uring/mock: support for async read/write
io_uring: add trivial poll handler
init/Kconfig | 11 ++ io_uring/Makefile | 1 + io_uring/mock_file.c | 354 +++++++++++++++++++++++++++++++++++++++++++ io_uring/mock_file.h | 47 ++++++ 4 files changed, 413 insertions(+) create mode 100644 io_uring/mock_file.c create mode 100644 io_uring/mock_file.h
Signature · 1 line
2.49.0
PATCH v3 1/6 io_uring/mock: add basic infra for test mock files
io_uring commands provide an ioctl style interface for files to implement file specific operations. io_uring provides many features and advanced api to commands, and it's getting hard to test as it requires specific files/devices.
Add basic infrastucture for creating special mock files that will be implementing the cmd api and using various io_uring features we want to test. It'll also be useful to test some more obscure read/write/polling edge cases in the future.
--- init/Kconfig | 11 ++++ io_uring/Makefile | 1 + io_uring/mock_file.c | 139 +++++++++++++++++++++++++++++++++++++++++++ io_uring/mock_file.h | 22 +++++++ 4 files changed, 173 insertions(+) create mode 100644 io_uring/mock_file.c create mode 100644 io_uring/mock_file.h
init/Kconfig +11 -0
@@ -1774,6 +1774,17 @@ config GCOV_PROFILE_URING the io_uring subsystem, hence this should only be enabled for specific test purposes. +config IO_URING_MOCK_FILE + tristate "Enable io_uring mock files (Experimental)" if EXPERT + default n + depends on IO_URING + help + Enable mock files for io_uring subststem testing. The ABI might + still change, so it's still experimental and should only be enabled + for specific test purposes. + + If unsure, say N. + config ADVISE_SYSCALLS bool "Enable madvise/fadvise syscalls" if EXPERT default y
io_uring/Makefile +1 -0
@@ -21,3 +21,4 @@ obj-$(CONFIG_EPOLL) += epoll.o obj-$(CONFIG_NET_RX_BUSY_POLL) += napi.o obj-$(CONFIG_NET) += net.o cmd_net.o obj-$(CONFIG_PROC_FS) += fdinfo.o +obj-$(CONFIG_IO_URING_MOCK_FILE) += mock_file.o
io_uring/mock_file.c new file +139 -0
139 lines not on this page · raw message
io_uring/mock_file.h new file +22 -0
@@ -0,0 +1,22 @@ +#ifndef IOU_MOCK_H +#define IOU_MOCK_H + +#include <linux/types.h> + +struct io_uring_mock_probe { +__u64 features; +__u64 __resv[9 ]; +}; + +struct io_uring_mock_create { +__u32 out_fd; +__u32 flags; +__u64 __resv[15 ]; +}; + +enum { +IORING_MOCK_MGR_CMD_PROBE , +IORING_MOCK_MGR_CMD_CREATE , +}; + +#endif
Signature · 1 line
2.49.0
Jens Axboe
maintainerQuoted 9 lines · Pavel Begunkov
io_uringcommands provide an ioctl style interface for files to implement file specific operations.io_uringprovides many features and advanced api to commands, and it's getting hard to test as it requires specific files/devices.Add basic infrastucture for creating special mock files that will be implementing the cmd api and using various
io_uringfeatures we want to test. It'll also be useful to test some more obscure read/write/polling edge cases in the future.
Do we want to have the creation of a mock file be a privileged operation?
Signature · 1 line
Jens Axboe
Quoted 6 lines · Jens Axboe
Quoted 5 lines · Pavel Begunkov
io_uringcommands provide an ioctl style interface for files to implement file specific operations.io_uringprovides many features and advanced api to commands, and it's getting hard to test as it requires specific files/devices.
Quoted 7 lines
Quoted 4 lines
Add basic infrastucture for creating special mock files that will be implementing the cmd api and using various
io_uringfeatures we want to test. It'll also be useful to test some more obscure read/write/polling edge cases in the future.Do we want to have the creation of a mock file be a privileged operation?
It doesn't do anything that would warrant that, maybe just yet. Do you mean from the security perspective? i.e. making sure a user can't exploit it if there is anything to be exploited. I'd really hope nobody would compile this thing for non-test kernels. Maybe I should make it dependent on lockdep to enforce it.
Signature · 1 line
Pavel Begunkov
Jens Axboe
maintainerQuoted 15 lines · Pavel Begunkov
Quoted 6 lines · Jens Axboe
Quoted 5 lines · Pavel Begunkov
io_uringcommands provide an ioctl style interface for files to implement file specific operations.io_uringprovides many features and advanced api to commands, and it's getting hard to test as it requires specific files/devices.Quoted 7 lines
Quoted 4 lines
Add basic infrastucture for creating special mock files that will be implementing the cmd api and using various
io_uringfeatures we want to test. It'll also be useful to test some more obscure read/write/polling edge cases in the future.Do we want to have the creation of a mock file be a privileged operation?
Quoted 6 lines
It doesn't do anything that would warrant that, maybe just yet. Do you mean from the security perspective? i.e. making sure a user can't exploit it if there is anything to be exploited. I'd really hope nobody would compile this thing for non-test kernels. Maybe I should make it dependent on lockdep to enforce it.
People do all sorts of weird stuff. I know it doesn't do anything that warrants making it root only, but at least as root only, any side effects will be limited to that. I think that'd be better than making it forcibly depend on something unrelated (but debug'y) like lockdep.
Signature · 1 line
Jens Axboe
Quoted 23 lines · Jens Axboe
Quoted 15 lines · Pavel Begunkov
Quoted 6 lines · Jens Axboe
Quoted 5 lines · Pavel Begunkov
io_uringcommands provide an ioctl style interface for files to implement file specific operations.io_uringprovides many features and advanced api to commands, and it's getting hard to test as it requires specific files/devices.Quoted 7 lines
Quoted 4 lines
Add basic infrastucture for creating special mock files that will be implementing the cmd api and using various
io_uringfeatures we want to test. It'll also be useful to test some more obscure read/write/polling edge cases in the future.Do we want to have the creation of a mock file be a privileged operation?
Quoted 6 lines
It doesn't do anything that would warrant that, maybe just yet. Do you mean from the security perspective? i.e. making sure a user can't exploit it if there is anything to be exploited. I'd really hope nobody would compile this thing for non-test kernels. Maybe I should make it dependent on lockdep to enforce it.
Quoted 5 lines
People do all sorts of weird stuff. I know it doesn't do anything that warrants making it root only, but at least as root only, any side effects will be limited to that. I think that'd be better than making it forcibly depend on something unrelated (but debug'y) like lockdep.
I don't hate the CAP_ADMIN idea, I'll add it, but making it dependent on something incompatible with production kernels is the only way to ensure it's used in the intended way.
Signature · 1 line
Pavel Begunkov
Jens Axboe
maintainerQuoted 30 lines · Pavel Begunkov
Quoted 23 lines · Jens Axboe
Quoted 15 lines · Pavel Begunkov
Quoted 6 lines · Jens Axboe
Quoted 5 lines · Pavel Begunkov
io_uringcommands provide an ioctl style interface for files to implement file specific operations.io_uringprovides many features and advanced api to commands, and it's getting hard to test as it requires specific files/devices.Quoted 7 lines
Quoted 4 lines
Add basic infrastucture for creating special mock files that will be implementing the cmd api and using various
io_uringfeatures we want to test. It'll also be useful to test some more obscure read/write/polling edge cases in the future.Do we want to have the creation of a mock file be a privileged operation?
Quoted 6 lines
It doesn't do anything that would warrant that, maybe just yet. Do you mean from the security perspective? i.e. making sure a user can't exploit it if there is anything to be exploited. I'd really hope nobody would compile this thing for non-test kernels. Maybe I should make it dependent on lockdep to enforce it.
Quoted 5 lines
People do all sorts of weird stuff. I know it doesn't do anything that warrants making it root only, but at least as root only, any side effects will be limited to that. I think that'd be better than making it forcibly depend on something unrelated (but debug'y) like lockdep.
Quoted 3 lines
I don't hate the
CAP_ADMINidea, I'll add it, but making it dependent on something incompatible with production kernels is the only way to ensure it's used in the intended way.
But any kind of dependency like lockdep will mean that I cannot run testing without lockdep, or whatever else the dependency might be. I think that'd be rather unfortunate, I tend to test with both a "stock" kind of config, and a KASAN && PROVE_LOCKING setup.
So I really don't think we should limit ourselves that way, attempting to stop a weird use case by adding artificial dependencies.
Signature · 1 line
Jens Axboe
PATCH v3 2/6 io_uring/mock: add cmd using vectored regbufs
In reply to Pavel BegunkovThere is a command api allowing to import vectored registered buffers, add a new mock command that uses the feature and simply copies the specified registered buffer into user space or vice versa.
--- io_uring/mock_file.c | 70 +++++++++++++++++++++++++++++++++++++++++++- io_uring/mock_file.h | 14 +++++++++ 2 files changed, 83 insertions(+), 1 deletion(-)
io_uring/mock_file.c +69 -1
@@ -9,8 +9,76 @@#include <linux/io_uring_types.h> #include "mock_file.h" +#define IO_VALID_COPY_CMD_FLAGS IORING_MOCK_COPY_FROM + +static int io_copy_regbuf (struct iov_iter *reg_iter,void __user *ubuf) +{ +size_t ret, copied =0 ; +size_t buflen =PAGE_SIZE ; +void *tmp_buf; + + tmp_buf =kzalloc (buflen,GFP_KERNEL ); +if (!tmp_buf) +return -ENOMEM ; + +while (iov_iter_count (reg_iter)) { +size_t len =min (iov_iter_count (reg_iter), buflen); + +if (iov_iter_rw (reg_iter) ==ITER_SOURCE ) { + ret =copy_from_iter (tmp_buf, len, reg_iter); +if (ret <=0 ) +break ; +if (copy_to_user (ubuf, tmp_buf, ret)) +break ; + }else { +if (copy_from_user (tmp_buf, ubuf, len)) +break ; + ret =copy_to_iter (tmp_buf, len, reg_iter); +if (ret <=0 ) +break ; + } + ubuf += ret; + copied += ret; + } + +kfree (tmp_buf); +return copied; +} + +static int io_cmd_copy_regbuf (struct io_uring_cmd *cmd,unsigned int issue_flags) +{ +const struct io_uring_sqe *sqe = cmd->sqe; +const struct iovec __user *iovec; +unsigned flags, iovec_len; +struct iov_iter iter; +void __user *ubuf; +int dir, ret; + + ubuf =u64_to_user_ptr (READ_ONCE (sqe->addr3)); + iovec =u64_to_user_ptr (READ_ONCE (sqe->addr)); + iovec_len =READ_ONCE (sqe->len); + flags =READ_ONCE (sqe->file_index); + +if (unlikely (sqe->ioprio || sqe->__pad1)) +return -EINVAL ; +if (flags & ~IO_VALID_COPY_CMD_FLAGS ) +return -EINVAL ; + + dir = (flags &IORING_MOCK_COPY_FROM ) ?ITER_SOURCE :ITER_DEST ; + ret =io_uring_cmd_import_fixed_vec (cmd, iovec, iovec_len, dir, &iter, + issue_flags); +if (ret) +return ret; + ret =io_copy_regbuf (&iter, ubuf); +return ret ? ret : -EFAULT ; +} +static int io_mock_cmd (struct io_uring_cmd *cmd,unsigned int issue_flags) { +switch (cmd->cmd_op) { +case IORING_MOCK_CMD_COPY_REGBUF : +return io_cmd_copy_regbuf (cmd, issue_flags); + }return -ENOTSUPP ; }
@@ -85,7 +153,7 @@ static int io_probe_mock(struct io_uring_cmd *cmd)if (!mem_is_zero (&mp,sizeof (mp)))return -EINVAL ; - mp.features =0 ; + mp.features =IORING_MOCK_FEAT_END ;if (copy_to_user (uarg, &mp, uarg_size))return -EFAULT ;
io_uring/mock_file.h +14 -0
@@ -3,6 +3,12 @@#include <linux/types.h> +enum { +IORING_MOCK_FEAT_CMD_COPY , + +IORING_MOCK_FEAT_END , +}; +struct io_uring_mock_probe {__u64 features;__u64 __resv[9 ];
@@ -19,4 +25,12 @@ enum { IORING_MOCK_MGR_CMD_CREATE, }; +enum { +IORING_MOCK_CMD_COPY_REGBUF , +}; + +enum { +IORING_MOCK_COPY_FROM =1 , +}; +#endif
Signature · 1 line
2.49.0
PATCH v3 3/6 io_uring/mock: add sync read/write
In reply to Pavel BegunkovAdd support for synchronous zero read/write for mock files.
--- io_uring/mock_file.c | 67 ++++++++++++++++++++++++++++++++++++++++---- io_uring/mock_file.h | 4 ++- 2 files changed, 65 insertions(+), 6 deletions(-)
io_uring/mock_file.c +62 -5
@@ -9,6 +9,10 @@#include <linux/io_uring_types.h> #include "mock_file.h" +struct io_mock_file { +size_t size; +}; +#define IO_VALID_COPY_CMD_FLAGS IORING_MOCK_COPY_FROMstatic int io_copy_regbuf (struct iov_iter *reg_iter,void __user *ubuf)
@@ -82,18 +86,59 @@ static int io_mock_cmd(struct io_uring_cmd *cmd, unsigned int issue_flags)return -ENOTSUPP ; } +static ssize_t io_mock_read_iter (struct kiocb *iocb,struct iov_iter *to) +{ +struct io_mock_file *mf = iocb->ki_filp->private_data; +size_t len =iov_iter_count (to); + +if (iocb->ki_pos + len > mf->size) +return -EINVAL ; +return iov_iter_zero (len, to); +} + +static ssize_t io_mock_write_iter (struct kiocb *iocb,struct iov_iter *from) +{ +struct io_mock_file *mf = iocb->ki_filp->private_data; +size_t len =iov_iter_count (from); + +if (iocb->ki_pos + len > mf->size) +return -EINVAL ; +iov_iter_advance (from, len); +return len; +} + +static loff_t io_mock_llseek (struct file *file,loff_t offset,int whence) +{ +struct io_mock_file *mf = file->private_data; + +return fixed_size_llseek (file, offset, whence, mf->size); +} + +static int io_mock_release (struct inode *inode,struct file *file) +{ +struct io_mock_file *mf = file->private_data; + +kfree (mf); +return 0 ; +} +static const struct file_operations io_mock_fops = { .owner =THIS_MODULE , + .release = io_mock_release, .uring_cmd = io_mock_cmd, + .read_iter = io_mock_read_iter, + .write_iter = io_mock_write_iter, + .llseek = io_mock_llseek, };static int io_create_mock_file (struct io_uring_cmd *cmd,unsigned int issue_flags) {const struct io_uring_sqe *sqe = cmd->sqe;struct io_uring_mock_create mc,__user *uarg; +struct io_mock_file *mf =NULL ;struct file *file =NULL ;size_t uarg_size; -int fd, ret; +int fd =-1 , ret; uarg =u64_to_user_ptr (READ_ONCE (sqe->addr)); uarg_size =READ_ONCE (sqe->len);
@@ -108,18 +153,28 @@ static int io_create_mock_file(struct io_uring_cmd *cmd, unsigned int issue_flagreturn -EFAULT ;if (!mem_is_zero (mc.__resv,sizeof (mc.__resv)) || mc.flags)return -EINVAL ; +if (mc.file_size >SZ_1G ) +return -EINVAL ; + mf =kzalloc (sizeof (*mf),GFP_KERNEL_ACCOUNT ); +if (!mf) +return -ENOMEM ; - fd =get_unused_fd_flags (O_RDWR |O_CLOEXEC ); + ret = fd =get_unused_fd_flags (O_RDWR |O_CLOEXEC );if (fd <0 ) -return fd; + goto fail; + mf->size = mc.file_size; file =anon_inode_create_getfile ("[io_uring_mock]" , &io_mock_fops, -NULL ,O_RDWR |O_CLOEXEC ,NULL ); + mf,O_RDWR |O_CLOEXEC ,NULL );if (IS_ERR (file)) { ret =PTR_ERR (file); goto fail; } + file->f_mode |=FMODE_READ |FMODE_CAN_READ | +FMODE_WRITE |FMODE_CAN_WRITE | +FMODE_LSEEK ; + mc.out_fd = fd;if (copy_to_user (uarg, &mc, uarg_size)) {fput (file);
@@ -130,7 +185,9 @@ static int io_create_mock_file(struct io_uring_cmd *cmd, unsigned int issue_flagfd_install (fd, file);return 0 ; fail: -put_unused_fd (fd); +if (fd >=0 ) +put_unused_fd (fd); +kfree (mf);return ret; }
io_uring/mock_file.h +3 -1
@@ -5,6 +5,7 @@enum {IORING_MOCK_FEAT_CMD_COPY , +IORING_MOCK_FEAT_RW_ZERO ,IORING_MOCK_FEAT_END , };
@@ -17,7 +18,8 @@ struct io_uring_mock_probe {struct io_uring_mock_create {__u32 out_fd;__u32 flags; -__u64 __resv[15 ]; +__u64 file_size; +__u64 __resv[14 ]; };enum {
Signature · 1 line
2.49.0
PATCH v3 4/6 io_uring/mock: allow to choose FMODE_NOWAIT
In reply to Pavel BegunkovAdd an option to choose whether the file supports FMODE_NOWAIT, that changes the execution path io_uring request takes.
--- io_uring/mock_file.c | 8 +++++++- io_uring/mock_file.h | 5 +++++ 2 files changed, 12 insertions(+), 1 deletion(-)
io_uring/mock_file.c +7 -1
@@ -131,6 +131,8 @@ static const struct file_operations io_mock_fops = { .llseek = io_mock_llseek, }; +#define IO_VALID_CREATE_FLAGS (IORING_MOCK_CREATE_F_SUPPORT_NOWAIT) +static int io_create_mock_file (struct io_uring_cmd *cmd,unsigned int issue_flags) {const struct io_uring_sqe *sqe = cmd->sqe;
@@ -151,7 +153,9 @@ static int io_create_mock_file(struct io_uring_cmd *cmd, unsigned int issue_flagmemset (&mc,0 ,sizeof (mc));if (copy_from_user (&mc, uarg, uarg_size))return -EFAULT ; -if (!mem_is_zero (mc.__resv,sizeof (mc.__resv)) || mc.flags) +if (!mem_is_zero (mc.__resv,sizeof (mc.__resv))) +return -EINVAL ; +if (mc.flags & ~IO_VALID_CREATE_FLAGS )return -EINVAL ;if (mc.file_size >SZ_1G )return -EINVAL ;
@@ -174,6 +178,8 @@ static int io_create_mock_file(struct io_uring_cmd *cmd, unsigned int issue_flag file->f_mode |=FMODE_READ |FMODE_CAN_READ |FMODE_WRITE |FMODE_CAN_WRITE |FMODE_LSEEK ; +if (mc.flags &IORING_MOCK_CREATE_F_SUPPORT_NOWAIT ) + file->f_mode |=FMODE_NOWAIT ; mc.out_fd = fd;if (copy_to_user (uarg, &mc, uarg_size)) {
io_uring/mock_file.h +5 -0
@@ -6,6 +6,7 @@enum {IORING_MOCK_FEAT_CMD_COPY ,IORING_MOCK_FEAT_RW_ZERO , +IORING_MOCK_FEAT_RW_NOWAIT ,IORING_MOCK_FEAT_END , };
@@ -15,6 +16,10 @@ struct io_uring_mock_probe {__u64 __resv[9 ]; }; +enum { +IORING_MOCK_CREATE_F_SUPPORT_NOWAIT =1 , +}; +struct io_uring_mock_create {__u32 out_fd;__u32 flags;
Signature · 1 line
2.49.0
PATCH v3 5/6 io_uring/mock: support for async read/write
In reply to Pavel BegunkovLet the user to specify a delay to read/write request. io_uring will start a timer, return -EIOCBQUEUED and complete the request asynchronously after the delay pass.
--- io_uring/mock_file.c | 59 +++++++++++++++++++++++++++++++++++++++++--- io_uring/mock_file.h | 4 ++- 2 files changed, 58 insertions(+), 5 deletions(-)
io_uring/mock_file.c +55 -4
@@ -4,13 +4,22 @@#include <linux/miscdevice.h> #include <linux/module.h> #include <linux/anon_inodes.h> +#include <linux/ktime.h> +#include <linux/hrtimer.h> #include <linux/io_uring/cmd.h> #include <linux/io_uring_types.h> #include "mock_file.h" +struct io_mock_iocb { +struct kiocb *iocb; +struct hrtimer timer; +int res; +}; +struct io_mock_file { -size_t size; +size_t size; +u64 rw_delay_ns; };#define IO_VALID_COPY_CMD_FLAGS IORING_MOCK_COPY_FROM
@@ -86,14 +95,48 @@ static int io_mock_cmd(struct io_uring_cmd *cmd, unsigned int issue_flags)return -ENOTSUPP ; } +static enum hrtimer_restart io_mock_rw_timer_expired (struct hrtimer *timer) +{ + struct io_mock_iocb *mio = container_of(timer, struct io_mock_iocb, timer); +struct kiocb *iocb = mio->iocb; + +WRITE_ONCE (iocb->private,NULL ); + iocb->ki_complete (iocb, mio->res); +kfree (mio); +return HRTIMER_NORESTART ; +} + +static ssize_t io_mock_delay_rw (struct kiocb *iocb,size_t len) +{ +struct io_mock_file *mf = iocb->ki_filp->private_data; +struct io_mock_iocb *mio; + + mio =kzalloc (sizeof (*mio),GFP_KERNEL ); +if (!mio) +return -ENOMEM ; + + mio->iocb = iocb; + mio->res = len; +hrtimer_setup (&mio->timer, io_mock_rw_timer_expired, +CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); +hrtimer_start (&mio->timer,ns_to_ktime (mf->rw_delay_ns), +HRTIMER_MODE_REL ); +return -EIOCBQUEUED ; +} +static ssize_t io_mock_read_iter (struct kiocb *iocb,struct iov_iter *to) {struct io_mock_file *mf = iocb->ki_filp->private_data;size_t len =iov_iter_count (to); +size_t nr_zeroed;if (iocb->ki_pos + len > mf->size)return -EINVAL ; -return iov_iter_zero (len, to); + nr_zeroed =iov_iter_zero (len, to); +if (!mf->rw_delay_ns || nr_zeroed != len) +return nr_zeroed; + +return io_mock_delay_rw (iocb, len); }static ssize_t io_mock_write_iter (struct kiocb *iocb,struct iov_iter *from)
@@ -103,8 +146,12 @@ static ssize_t io_mock_write_iter(struct kiocb *iocb, struct iov_iter *from)if (iocb->ki_pos + len > mf->size)return -EINVAL ; -iov_iter_advance (from, len); -return len; +if (!mf->rw_delay_ns) { +iov_iter_advance (from, len); +return len; + } + +return io_mock_delay_rw (iocb, len); }static loff_t io_mock_llseek (struct file *file,loff_t offset,int whence)
@@ -159,6 +206,9 @@ static int io_create_mock_file(struct io_uring_cmd *cmd, unsigned int issue_flagreturn -EINVAL ;if (mc.file_size >SZ_1G )return -EINVAL ; +if (mc.rw_delay_ns >NSEC_PER_SEC ) +return -EINVAL ; + mf =kzalloc (sizeof (*mf),GFP_KERNEL_ACCOUNT );if (!mf)return -ENOMEM ;
@@ -168,6 +218,7 @@ static int io_create_mock_file(struct io_uring_cmd *cmd, unsigned int issue_flag goto fail; mf->size = mc.file_size; + mf->rw_delay_ns = mc.rw_delay_ns; file =anon_inode_create_getfile ("[io_uring_mock]" , &io_mock_fops, mf,O_RDWR |O_CLOEXEC ,NULL );if (IS_ERR (file)) {
io_uring/mock_file.h +3 -1
@@ -7,6 +7,7 @@ enum {IORING_MOCK_FEAT_CMD_COPY ,IORING_MOCK_FEAT_RW_ZERO ,IORING_MOCK_FEAT_RW_NOWAIT , +IORING_MOCK_FEAT_RW_ASYNC , IORING_MOCK_FEAT_END, };
@@ -24,7 +25,8 @@ struct io_uring_mock_create {__u32 out_fd;__u32 flags;__u64 file_size; -__u64 __resv[14 ]; +__u64 rw_delay_ns; +__u64 __resv[13 ]; };enum {
Signature · 1 line
2.49.0
PATCH v3 6/6 io_uring: add trivial poll handler
In reply to Pavel BegunkovAdd a flag that enables polling on the mock file. For now it's trivially says that there is always data available, it'll be extended in the future.
--- io_uring/mock_file.c | 37 +++++++++++++++++++++++++++++++++++-- io_uring/mock_file.h | 2 ++ 2 files changed, 37 insertions(+), 2 deletions(-)
io_uring/mock_file.c +35 -2
@@ -6,6 +6,7 @@#include <linux/anon_inodes.h> #include <linux/ktime.h> #include <linux/hrtimer.h> +#include <linux/poll.h> #include <linux/io_uring/cmd.h> #include <linux/io_uring_types.h>
@@ -20,6 +21,8 @@ struct io_mock_iocb {struct io_mock_file {size_t size;u64 rw_delay_ns; +bool pollable; +struct wait_queue_head poll_wq; };#define IO_VALID_COPY_CMD_FLAGS IORING_MOCK_COPY_FROM
@@ -161,6 +164,18 @@ static loff_t io_mock_llseek(struct file *file, loff_t offset, int whence)return fixed_size_llseek (file, offset, whence, mf->size); } +static __poll_t io_mock_poll (struct file *file,struct poll_table_struct *pt) +{ +struct io_mock_file *mf = file->private_data; +__poll_t mask =0 ; + +poll_wait (file, &mf->poll_wq, pt); + + mask |=EPOLLOUT |EPOLLWRNORM ; + mask |=EPOLLIN |EPOLLRDNORM ; +return mask; +} +static int io_mock_release (struct inode *inode,struct file *file) {struct io_mock_file *mf = file->private_data;
@@ -178,10 +193,22 @@ static const struct file_operations io_mock_fops = { .llseek = io_mock_llseek, }; -#define IO_VALID_CREATE_FLAGS (IORING_MOCK_CREATE_F_SUPPORT_NOWAIT) +static const struct file_operations io_mock_poll_fops = { + .owner =THIS_MODULE , + .release = io_mock_release, + .uring_cmd = io_mock_cmd, + .read_iter = io_mock_read_iter, + .write_iter = io_mock_write_iter, + .llseek = io_mock_llseek, + .poll = io_mock_poll, +}; + +#define IO_VALID_CREATE_FLAGS (IORING_MOCK_CREATE_F_SUPPORT_NOWAIT | \ + IORING_MOCK_CREATE_F_POLL)static int io_create_mock_file (struct io_uring_cmd *cmd,unsigned int issue_flags) { +const struct file_operations *fops = &io_mock_fops;const struct io_uring_sqe *sqe = cmd->sqe;struct io_uring_mock_create mc,__user *uarg;struct io_mock_file *mf =NULL ;
@@ -217,9 +244,15 @@ static int io_create_mock_file(struct io_uring_cmd *cmd, unsigned int issue_flagif (fd <0 ) goto fail; +init_waitqueue_head (&mf->poll_wq); mf->size = mc.file_size; mf->rw_delay_ns = mc.rw_delay_ns; - file =anon_inode_create_getfile ("[io_uring_mock]" , &io_mock_fops, +if (mc.flags &IORING_MOCK_CREATE_F_POLL ) { + fops = &io_mock_poll_fops; + mf->pollable = true; + } + + file =anon_inode_create_getfile ("[io_uring_mock]" , fops, mf,O_RDWR |O_CLOEXEC ,NULL );if (IS_ERR (file)) { ret =PTR_ERR (file);
io_uring/mock_file.h +2 -0
@@ -8,6 +8,7 @@ enum {IORING_MOCK_FEAT_RW_ZERO ,IORING_MOCK_FEAT_RW_NOWAIT ,IORING_MOCK_FEAT_RW_ASYNC , +IORING_MOCK_FEAT_POLL , IORING_MOCK_FEAT_END, };
@@ -19,6 +20,7 @@ struct io_uring_mock_probe {enum {IORING_MOCK_CREATE_F_SUPPORT_NOWAIT =1 , +IORING_MOCK_CREATE_F_POLL =2 , };struct io_uring_mock_create {
Signature · 1 line
2.49.0