| /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ |
| #ifndef _UAPI_VDUSE_H_ |
| #define _UAPI_VDUSE_H_ |
| |
| #include <linux/types.h> |
| |
| #define VDUSE_BASE 0x81 |
| |
| /* The ioctls for control device (/dev/vduse/control) */ |
| |
| #define VDUSE_API_VERSION 0 |
| |
| /* |
| * Get the version of VDUSE API that kernel supported (VDUSE_API_VERSION). |
| * This is used for future extension. |
| */ |
| #define VDUSE_GET_API_VERSION _IOR(VDUSE_BASE, 0x00, __u64) |
| |
| /* Set the version of VDUSE API that userspace supported. */ |
| #define VDUSE_SET_API_VERSION _IOW(VDUSE_BASE, 0x01, __u64) |
| |
| /** |
| * struct vduse_dev_config - basic configuration of a VDUSE device |
| * @name: VDUSE device name, needs to be NUL terminated |
| * @vendor_id: virtio vendor id |
| * @device_id: virtio device id |
| * @features: virtio features |
| * @vq_num: the number of virtqueues |
| * @vq_align: the allocation alignment of virtqueue's metadata |
| * @reserved: for future use, needs to be initialized to zero |
| * @config_size: the size of the configuration space |
| * @config: the buffer of the configuration space |
| * |
| * Structure used by VDUSE_CREATE_DEV ioctl to create VDUSE device. |
| */ |
| struct vduse_dev_config { |
| #define VDUSE_NAME_MAX 256 |
| char name[VDUSE_NAME_MAX]; |
| __u32 vendor_id; |
| __u32 device_id; |
| __u64 features; |
| __u32 vq_num; |
| __u32 vq_align; |
| __u32 reserved[13]; |
| __u32 config_size; |
| __u8 config[]; |
| }; |
| |
| /* Create a VDUSE device which is represented by a char device (/dev/vduse/$NAME) */ |
| #define VDUSE_CREATE_DEV _IOW(VDUSE_BASE, 0x02, struct vduse_dev_config) |
| |
| /* |
| * Destroy a VDUSE device. Make sure there are no more references |
| * to the char device (/dev/vduse/$NAME). |
| */ |
| #define VDUSE_DESTROY_DEV _IOW(VDUSE_BASE, 0x03, char[VDUSE_NAME_MAX]) |
| |
| /* The ioctls for VDUSE device (/dev/vduse/$NAME) */ |
| |
| /** |
| * struct vduse_iotlb_entry - entry of IOTLB to describe one IOVA region [start, last] |
| * @offset: the mmap offset on returned file descriptor |
| * @start: start of the IOVA region |
| * @last: last of the IOVA region |
| * @perm: access permission of the IOVA region |
| * |
| * Structure used by VDUSE_IOTLB_GET_FD ioctl to find an overlapped IOVA region. |
| */ |
| struct vduse_iotlb_entry { |
| __u64 offset; |
| __u64 start; |
| __u64 last; |
| #define VDUSE_ACCESS_RO 0x1 |
| #define VDUSE_ACCESS_WO 0x2 |
| #define VDUSE_ACCESS_RW 0x3 |
| __u8 perm; |
| }; |
| |
| /* |
| * Find the first IOVA region that overlaps with the range [start, last] |
| * and return the corresponding file descriptor. Return -EINVAL means the |
| * IOVA region doesn't exist. Caller should set start and last fields. |
| */ |
| #define VDUSE_IOTLB_GET_FD _IOWR(VDUSE_BASE, 0x10, struct vduse_iotlb_entry) |
| |
| /* |
| * Get the negotiated virtio features. It's a subset of the features in |
| * struct vduse_dev_config which can be accepted by virtio driver. It's |
| * only valid after FEATURES_OK status bit is set. |
| */ |
| #define VDUSE_DEV_GET_FEATURES _IOR(VDUSE_BASE, 0x11, __u64) |
| |
| /** |
| * struct vduse_config_data - data used to update configuration space |
| * @offset: the offset from the beginning of configuration space |
| * @length: the length to write to configuration space |
| * @buffer: the buffer used to write from |
| * |
| * Structure used by VDUSE_DEV_SET_CONFIG ioctl to update device |
| * configuration space. |
| */ |
| struct vduse_config_data { |
| __u32 offset; |
| __u32 length; |
| __u8 buffer[]; |
| }; |
| |
| /* Set device configuration space */ |
| #define VDUSE_DEV_SET_CONFIG _IOW(VDUSE_BASE, 0x12, struct vduse_config_data) |
| |
| /* |
| * Inject a config interrupt. It's usually used to notify virtio driver |
| * that device configuration space has changed. |
| */ |
| #define VDUSE_DEV_INJECT_CONFIG_IRQ _IO(VDUSE_BASE, 0x13) |
| |
| /** |
| * struct vduse_vq_config - basic configuration of a virtqueue |
| * @index: virtqueue index |
| * @max_size: the max size of virtqueue |
| * @reserved: for future use, needs to be initialized to zero |
| * |
| * Structure used by VDUSE_VQ_SETUP ioctl to setup a virtqueue. |
| */ |
| struct vduse_vq_config { |
| __u32 index; |
| __u16 max_size; |
| __u16 reserved[13]; |
| }; |
| |
| /* |
| * Setup the specified virtqueue. Make sure all virtqueues have been |
| * configured before the device is attached to vDPA bus. |
| */ |
| #define VDUSE_VQ_SETUP _IOW(VDUSE_BASE, 0x14, struct vduse_vq_config) |
| |
| /** |
| * struct vduse_vq_state_split - split virtqueue state |
| * @avail_index: available index |
| */ |
| struct vduse_vq_state_split { |
| __u16 avail_index; |
| }; |
| |
| /** |
| * struct vduse_vq_state_packed - packed virtqueue state |
| * @last_avail_counter: last driver ring wrap counter observed by device |
| * @last_avail_idx: device available index |
| * @last_used_counter: device ring wrap counter |
| * @last_used_idx: used index |
| */ |
| struct vduse_vq_state_packed { |
| __u16 last_avail_counter; |
| __u16 last_avail_idx; |
| __u16 last_used_counter; |
| __u16 last_used_idx; |
| }; |
| |
| /** |
| * struct vduse_vq_info - information of a virtqueue |
| * @index: virtqueue index |
| * @num: the size of virtqueue |
| * @desc_addr: address of desc area |
| * @driver_addr: address of driver area |
| * @device_addr: address of device area |
| * @split: split virtqueue state |
| * @packed: packed virtqueue state |
| * @ready: ready status of virtqueue |
| * |
| * Structure used by VDUSE_VQ_GET_INFO ioctl to get virtqueue's information. |
| */ |
| struct vduse_vq_info { |
| __u32 index; |
| __u32 num; |
| __u64 desc_addr; |
| __u64 driver_addr; |
| __u64 device_addr; |
| union { |
| struct vduse_vq_state_split split; |
| struct vduse_vq_state_packed packed; |
| }; |
| __u8 ready; |
| }; |
| |
| /* Get the specified virtqueue's information. Caller should set index field. */ |
| #define VDUSE_VQ_GET_INFO _IOWR(VDUSE_BASE, 0x15, struct vduse_vq_info) |
| |
| /** |
| * struct vduse_vq_eventfd - eventfd configuration for a virtqueue |
| * @index: virtqueue index |
| * @fd: eventfd, -1 means de-assigning the eventfd |
| * |
| * Structure used by VDUSE_VQ_SETUP_KICKFD ioctl to setup kick eventfd. |
| */ |
| struct vduse_vq_eventfd { |
| __u32 index; |
| #define VDUSE_EVENTFD_DEASSIGN -1 |
| int fd; |
| }; |
| |
| /* |
| * Setup kick eventfd for specified virtqueue. The kick eventfd is used |
| * by VDUSE kernel module to notify userspace to consume the avail vring. |
| */ |
| #define VDUSE_VQ_SETUP_KICKFD _IOW(VDUSE_BASE, 0x16, struct vduse_vq_eventfd) |
| |
| /* |
| * Inject an interrupt for specific virtqueue. It's used to notify virtio driver |
| * to consume the used vring. |
| */ |
| #define VDUSE_VQ_INJECT_IRQ _IOW(VDUSE_BASE, 0x17, __u32) |
| |
| /** |
| * struct vduse_iova_umem - userspace memory configuration for one IOVA region |
| * @uaddr: start address of userspace memory, it must be aligned to page size |
| * @iova: start of the IOVA region |
| * @size: size of the IOVA region |
| * @reserved: for future use, needs to be initialized to zero |
| * |
| * Structure used by VDUSE_IOTLB_REG_UMEM and VDUSE_IOTLB_DEREG_UMEM |
| * ioctls to register/de-register userspace memory for IOVA regions |
| */ |
| struct vduse_iova_umem { |
| __u64 uaddr; |
| __u64 iova; |
| __u64 size; |
| __u64 reserved[3]; |
| }; |
| |
| /* Register userspace memory for IOVA regions */ |
| #define VDUSE_IOTLB_REG_UMEM _IOW(VDUSE_BASE, 0x18, struct vduse_iova_umem) |
| |
| /* De-register the userspace memory. Caller should set iova and size field. */ |
| #define VDUSE_IOTLB_DEREG_UMEM _IOW(VDUSE_BASE, 0x19, struct vduse_iova_umem) |
| |
| /** |
| * struct vduse_iova_info - information of one IOVA region |
| * @start: start of the IOVA region |
| * @last: last of the IOVA region |
| * @capability: capability of the IOVA regsion |
| * @reserved: for future use, needs to be initialized to zero |
| * |
| * Structure used by VDUSE_IOTLB_GET_INFO ioctl to get information of |
| * one IOVA region. |
| */ |
| struct vduse_iova_info { |
| __u64 start; |
| __u64 last; |
| #define VDUSE_IOVA_CAP_UMEM (1 << 0) |
| __u64 capability; |
| __u64 reserved[3]; |
| }; |
| |
| /* |
| * Find the first IOVA region that overlaps with the range [start, last] |
| * and return some information on it. Caller should set start and last fields. |
| */ |
| #define VDUSE_IOTLB_GET_INFO _IOWR(VDUSE_BASE, 0x1a, struct vduse_iova_info) |
| |
| /* The control messages definition for read(2)/write(2) on /dev/vduse/$NAME */ |
| |
| /** |
| * enum vduse_req_type - request type |
| * @VDUSE_GET_VQ_STATE: get the state for specified virtqueue from userspace |
| * @VDUSE_SET_STATUS: set the device status |
| * @VDUSE_UPDATE_IOTLB: Notify userspace to update the memory mapping for |
| * specified IOVA range via VDUSE_IOTLB_GET_FD ioctl |
| */ |
| enum vduse_req_type { |
| VDUSE_GET_VQ_STATE, |
| VDUSE_SET_STATUS, |
| VDUSE_UPDATE_IOTLB, |
| }; |
| |
| /** |
| * struct vduse_vq_state - virtqueue state |
| * @index: virtqueue index |
| * @split: split virtqueue state |
| * @packed: packed virtqueue state |
| */ |
| struct vduse_vq_state { |
| __u32 index; |
| union { |
| struct vduse_vq_state_split split; |
| struct vduse_vq_state_packed packed; |
| }; |
| }; |
| |
| /** |
| * struct vduse_dev_status - device status |
| * @status: device status |
| */ |
| struct vduse_dev_status { |
| __u8 status; |
| }; |
| |
| /** |
| * struct vduse_iova_range - IOVA range [start, last] |
| * @start: start of the IOVA range |
| * @last: last of the IOVA range |
| */ |
| struct vduse_iova_range { |
| __u64 start; |
| __u64 last; |
| }; |
| |
| /** |
| * struct vduse_dev_request - control request |
| * @type: request type |
| * @request_id: request id |
| * @reserved: for future use |
| * @vq_state: virtqueue state, only index field is available |
| * @s: device status |
| * @iova: IOVA range for updating |
| * @padding: padding |
| * |
| * Structure used by read(2) on /dev/vduse/$NAME. |
| */ |
| struct vduse_dev_request { |
| __u32 type; |
| __u32 request_id; |
| __u32 reserved[4]; |
| union { |
| struct vduse_vq_state vq_state; |
| struct vduse_dev_status s; |
| struct vduse_iova_range iova; |
| __u32 padding[32]; |
| }; |
| }; |
| |
| /** |
| * struct vduse_dev_response - response to control request |
| * @request_id: corresponding request id |
| * @result: the result of request |
| * @reserved: for future use, needs to be initialized to zero |
| * @vq_state: virtqueue state |
| * @padding: padding |
| * |
| * Structure used by write(2) on /dev/vduse/$NAME. |
| */ |
| struct vduse_dev_response { |
| __u32 request_id; |
| #define VDUSE_REQ_RESULT_OK 0x00 |
| #define VDUSE_REQ_RESULT_FAILED 0x01 |
| __u32 result; |
| __u32 reserved[4]; |
| union { |
| struct vduse_vq_state vq_state; |
| __u32 padding[32]; |
| }; |
| }; |
| |
| #endif /* _UAPI_VDUSE_H_ */ |