Commit 3a0ae385 authored by Pavel Begunkov's avatar Pavel Begunkov Committed by Jens Axboe
Browse files

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.

Suggested-by: default avatarchase xd <sl1589472800@gmail.com>
Signed-off-by: default avatarPavel Begunkov <asml.silence@gmail.com>
Link: https://lore.kernel.org/r/93f21b0af58c1367a2b22635d5a7d694ad0272fc.1750599274.git.asml.silence@gmail.com


Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent 94b20309

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -12679,6 +12679,7 @@ F: include/linux/io_uring.h 
F:	include/linux/io_uring_types.h

F:	include/trace/events/io_uring.h

F:	include/uapi/linux/io_uring.h

F:	include/uapi/linux/io_uring/

F:	io_uring/









IPMI SUBSYSTEM
































include/uapi/linux/io_uring/mock_file.h
0 → 100644



+22
−0






























Original line number
Diff line number
Diff line









#ifndef LINUX_IO_URING_MOCK_FILE_H









#define LINUX_IO_URING_MOCK_FILE_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
























init/Kconfig



+11
−0






























Original line number
Diff line number
Diff line







@@ -1801,6 +1801,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






























Original line number
Diff line number
Diff line







@@ -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
0 → 100644



+148
−0






























Original line number
Diff line number
Diff line









#include <linux/device.h>









#include <linux/init.h>









#include <linux/kernel.h>









#include <linux/miscdevice.h>









#include <linux/module.h>









#include <linux/anon_inodes.h>



















#include <linux/io_uring/cmd.h>









#include <linux/io_uring_types.h>









#include <uapi/linux/io_uring/mock_file.h>



















static int io_mock_cmd(struct io_uring_cmd *cmd, unsigned int issue_flags)









{









	return -ENOTSUPP;









}



















static const struct file_operations io_mock_fops = {









	.owner		= THIS_MODULE,









	.uring_cmd	= io_mock_cmd,









};



















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 file *file = NULL;









	size_t uarg_size;









	int fd, ret;



















	/*









	 * It's a testing only driver that allows exercising edge cases









	 * that wouldn't be possible to hit otherwise.









	 */









	add_taint(TAINT_TEST, LOCKDEP_STILL_OK);



















	uarg = u64_to_user_ptr(READ_ONCE(sqe->addr));









	uarg_size = READ_ONCE(sqe->len);



















	if (sqe->ioprio || sqe->__pad1 || sqe->addr3 || sqe->file_index)









		return -EINVAL;









	if (uarg_size != sizeof(mc))









		return -EINVAL;



















	memset(&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)









		return -EINVAL;



















	fd = get_unused_fd_flags(O_RDWR | O_CLOEXEC);









	if (fd < 0)









		return fd;



















	file = anon_inode_create_getfile("[io_uring_mock]", &io_mock_fops,









					 NULL, O_RDWR | O_CLOEXEC, NULL);









	if (IS_ERR(file)) {









		ret = PTR_ERR(file);









		goto fail;









	}



















	mc.out_fd = fd;









	if (copy_to_user(uarg, &mc, uarg_size)) {









		fput(file);









		ret = -EFAULT;









		goto fail;









	}



















	fd_install(fd, file);









	return 0;









fail:









	put_unused_fd(fd);









	return ret;









}



















static int io_probe_mock(struct io_uring_cmd *cmd)









{









	const struct io_uring_sqe *sqe = cmd->sqe;









	struct io_uring_mock_probe mp, __user *uarg;









	size_t uarg_size;



















	uarg = u64_to_user_ptr(READ_ONCE(sqe->addr));









	uarg_size = READ_ONCE(sqe->len);



















	if (sqe->ioprio || sqe->__pad1 || sqe->addr3 || sqe->file_index ||









	    uarg_size != sizeof(mp))









		return -EINVAL;



















	memset(&mp, 0, sizeof(mp));









	if (copy_from_user(&mp, uarg, uarg_size))









		return -EFAULT;









	if (!mem_is_zero(&mp, sizeof(mp)))









		return -EINVAL;



















	mp.features = 0;



















	if (copy_to_user(uarg, &mp, uarg_size))









		return -EFAULT;









	return 0;









}



















static int iou_mock_mgr_cmd(struct io_uring_cmd *cmd, unsigned int issue_flags)









{









	if (!capable(CAP_SYS_ADMIN))









		return -EPERM;



















	switch (cmd->cmd_op) {









	case IORING_MOCK_MGR_CMD_PROBE:









		return io_probe_mock(cmd);









	case IORING_MOCK_MGR_CMD_CREATE:









		return io_create_mock_file(cmd, issue_flags);









	}









	return -EOPNOTSUPP;









}



















static const struct file_operations iou_mock_dev_fops = {









	.owner		= THIS_MODULE,









	.uring_cmd	= iou_mock_mgr_cmd,









};



















static struct miscdevice iou_mock_miscdev = {









	.minor			= MISC_DYNAMIC_MINOR,









	.name			= "io_uring_mock",









	.fops			= &iou_mock_dev_fops,









};



















static int __init io_mock_init(void)









{









	int ret;



















	ret = misc_register(&iou_mock_miscdev);









	if (ret < 0) {









		pr_err("Could not initialize io_uring mock device\n");









		return ret;









	}









	return 0;









}



















static void __exit io_mock_exit(void)









{









	misc_deregister(&iou_mock_miscdev);









}



















module_init(io_mock_init)









module_exit(io_mock_exit)



















MODULE_AUTHOR("Pavel Begunkov <asml.silence@gmail.com>");









MODULE_DESCRIPTION("io_uring mock file");









MODULE_LICENSE("GPL");