// SPDX-License-Identifier: GPL-2.0 #include "linux/io_uring/query.h" #include "query.h"#include "io_uring.h"#include "zcrx.h" union io_query_data {	struct io_uring_query_opcode opcodes;	struct io_uring_query_zcrx zcrx;	struct io_uring_query_scq scq;}; #define IO_MAX_QUERY_SIZE		sizeof(union io_query_data)#define IO_MAX_QUERY_ENTRIES		1000 static ssize_t io_query_ops(union io_query_data *data){	struct io_uring_query_opcode *e = &data->opcodes; 	e->nr_request_opcodes = IORING_OP_LAST;	e->nr_register_opcodes = IORING_REGISTER_LAST;	e->feature_flags = IORING_FEAT_FLAGS;	e->ring_setup_flags = IORING_SETUP_FLAGS;	e->enter_flags = IORING_ENTER_FLAGS;	e->sqe_flags = SQE_VALID_FLAGS;	e->nr_query_opcodes = __IO_URING_QUERY_MAX;	e->__pad = 0;	return sizeof(*e);} static ssize_t io_query_zcrx(union io_query_data *data){	struct io_uring_query_zcrx *e = &data->zcrx; 	e->register_flags = ZCRX_REG_IMPORT;	e->area_flags = IORING_ZCRX_AREA_DMABUF;	e->nr_ctrl_opcodes = __ZCRX_CTRL_LAST;	e->rq_hdr_size = sizeof(struct io_uring);	e->rq_hdr_alignment = L1_CACHE_BYTES;	e->features = ZCRX_FEATURE_RX_PAGE_SIZE;	e->__resv2 = 0;	return sizeof(*e);} static ssize_t io_query_scq(union io_query_data *data){	struct io_uring_query_scq *e = &data->scq; 	e->hdr_size = sizeof(struct io_rings);	e->hdr_alignment = SMP_CACHE_BYTES;	return sizeof(*e);} static int io_handle_query_entry(union io_query_data *data, void __user *uhdr,				 u64 *next_entry){	struct io_uring_query_hdr hdr;	size_t usize, res_size = 0;	ssize_t ret = -EINVAL;	void __user *udata; 	if (copy_from_user(&hdr, uhdr, sizeof(hdr)))		return -EFAULT;	usize = hdr.size;	hdr.size = min(hdr.size, IO_MAX_QUERY_SIZE);	udata = u64_to_user_ptr(hdr.query_data); 	if (hdr.query_op >= __IO_URING_QUERY_MAX) {		ret = -EOPNOTSUPP;		goto out;	}	if (!mem_is_zero(hdr.__resv, sizeof(hdr.__resv)) || hdr.result || !hdr.size)		goto out;	if (copy_from_user(data, udata, hdr.size))		return -EFAULT; 	switch (hdr.query_op) {	case IO_URING_QUERY_OPCODES:		ret = io_query_ops(data);		break;	case IO_URING_QUERY_ZCRX:		ret = io_query_zcrx(data);		break;	case IO_URING_QUERY_SCQ:		ret = io_query_scq(data);		break;	} 	if (ret >= 0) {		if (WARN_ON_ONCE(ret > IO_MAX_QUERY_SIZE))			return -EFAULT;		res_size = ret;		ret = 0;	}out:	hdr.result = ret;	hdr.size = min_t(size_t, usize, res_size); 	if (copy_struct_to_user(udata, usize, data, hdr.size, NULL))		return -EFAULT;	if (copy_to_user(uhdr, &hdr, sizeof(hdr)))		return -EFAULT;	*next_entry = hdr.next_entry;	return 0;} int io_query(void __user *arg, unsigned nr_args){	union io_query_data entry_buffer;	void __user *uhdr = arg;	int ret, nr = 0; 	memset(&entry_buffer, 0, sizeof(entry_buffer)); 	if (nr_args)		return -EINVAL; 	while (uhdr) {		u64 next_hdr; 		ret = io_handle_query_entry(&entry_buffer, uhdr, &next_hdr);		if (ret)			return ret;		uhdr = u64_to_user_ptr(next_hdr); 		/* Have some limit to avoid a potential cycle */		if (++nr >= IO_MAX_QUERY_ENTRIES)			return -ERANGE;		if (fatal_signal_pending(current))			return -EINTR;		cond_resched();	}	return 0;}