[ceph.git] / ceph / src / seastar / dpdk / lib / librte_eal / linuxapp / eal / eal_vfio.h

/*-
 *   BSD LICENSE
 *
 *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Intel Corporation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef EAL_VFIO_H_
#define EAL_VFIO_H_

/*
 * determine if VFIO is present on the system
 */
#ifdef RTE_EAL_VFIO
#include <linux/version.h>
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0)
#include <linux/vfio.h>

#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0)
#define RTE_PCI_MSIX_TABLE_BIR    0x7
#define RTE_PCI_MSIX_TABLE_OFFSET 0xfffffff8
#define RTE_PCI_MSIX_FLAGS_QSIZE  0x07ff
#else
#define RTE_PCI_MSIX_TABLE_BIR    PCI_MSIX_TABLE_BIR
#define RTE_PCI_MSIX_TABLE_OFFSET PCI_MSIX_TABLE_OFFSET
#define RTE_PCI_MSIX_FLAGS_QSIZE  PCI_MSIX_FLAGS_QSIZE
#endif

#define RTE_VFIO_TYPE1 VFIO_TYPE1_IOMMU

#ifndef VFIO_SPAPR_TCE_v2_IOMMU
#define RTE_VFIO_SPAPR 7
#define VFIO_IOMMU_SPAPR_REGISTER_MEMORY _IO(VFIO_TYPE, VFIO_BASE + 17)
#define VFIO_IOMMU_SPAPR_TCE_CREATE _IO(VFIO_TYPE, VFIO_BASE + 19)
#define VFIO_IOMMU_SPAPR_TCE_REMOVE _IO(VFIO_TYPE, VFIO_BASE + 20)

struct vfio_iommu_spapr_register_memory {
	uint32_t argsz;
	uint32_t flags;
	uint64_t vaddr;
	uint64_t size;
};

struct vfio_iommu_spapr_tce_create {
	uint32_t argsz;
	uint32_t flags;
	/* in */
	uint32_t page_shift;
	uint32_t __resv1;
	uint64_t window_size;
	uint32_t levels;
	uint32_t __resv2;
	/* out */
	uint64_t start_addr;
};

struct vfio_iommu_spapr_tce_remove {
	uint32_t argsz;
	uint32_t flags;
	/* in */
	uint64_t start_addr;
};

struct vfio_iommu_spapr_tce_ddw_info {
	uint64_t pgsizes;
	uint32_t max_dynamic_windows_supported;
	uint32_t levels;
};

/* SPAPR_v2 is not present, but SPAPR might be */
#ifndef VFIO_SPAPR_TCE_IOMMU
#define VFIO_IOMMU_SPAPR_TCE_GET_INFO _IO(VFIO_TYPE, VFIO_BASE + 12)

struct vfio_iommu_spapr_tce_info {
	uint32_t argsz;
	uint32_t flags;
	uint32_t dma32_window_start;
	uint32_t dma32_window_size;
	struct vfio_iommu_spapr_tce_ddw_info ddw;
};
#endif /* VFIO_SPAPR_TCE_IOMMU */

#else /* VFIO_SPAPR_TCE_v2_IOMMU */
#define RTE_VFIO_SPAPR VFIO_SPAPR_TCE_v2_IOMMU
#endif

#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0)
#define RTE_VFIO_NOIOMMU 8
#else
#define RTE_VFIO_NOIOMMU VFIO_NOIOMMU_IOMMU
#endif

#define VFIO_MAX_GROUPS 64

/*
 * Function prototypes for VFIO multiprocess sync functions
 */
int vfio_mp_sync_send_request(int socket, int req);
int vfio_mp_sync_receive_request(int socket);
int vfio_mp_sync_send_fd(int socket, int fd);
int vfio_mp_sync_receive_fd(int socket);
int vfio_mp_sync_connect_to_primary(void);

/*
 * we don't need to store device fd's anywhere since they can be obtained from
 * the group fd via an ioctl() call.
 */
struct vfio_group {
	int group_no;
	int fd;
	int devices;
};

struct vfio_config {
	int vfio_enabled;
	int vfio_container_fd;
	int vfio_active_groups;
	struct vfio_group vfio_groups[VFIO_MAX_GROUPS];
};

#define VFIO_DIR "/dev/vfio"
#define VFIO_CONTAINER_PATH "/dev/vfio/vfio"
#define VFIO_GROUP_FMT "/dev/vfio/%u"
#define VFIO_NOIOMMU_GROUP_FMT "/dev/vfio/noiommu-%u"
#define VFIO_GET_REGION_ADDR(x) ((uint64_t) x << 40ULL)
#define VFIO_GET_REGION_IDX(x) (x >> 40)

/* DMA mapping function prototype.
 * Takes VFIO container fd as a parameter.
 * Returns 0 on success, -1 on error.
 * */
typedef int (*vfio_dma_func_t)(int);

struct vfio_iommu_type {
	int type_id;
	const char *name;
	vfio_dma_func_t dma_map_func;
};

/* pick IOMMU type. returns a pointer to vfio_iommu_type or NULL for error */
const struct vfio_iommu_type *
vfio_set_iommu_type(int vfio_container_fd);

/* check if we have any supported extensions */
int
vfio_has_supported_extensions(int vfio_container_fd);

/* open container fd or get an existing one */
int
vfio_get_container_fd(void);

/* parse IOMMU group number for a device
 * returns 1 on success, -1 for errors, 0 for non-existent group
 */
int
vfio_get_group_no(const char *sysfs_base,
		const char *dev_addr, int *iommu_group_no);

/* open group fd or get an existing one */
int
vfio_get_group_fd(int iommu_group_no);

/* remove group fd from internal VFIO group fd array */
int
clear_group(int vfio_group_fd);

/**
 * Setup vfio_cfg for the device identified by its address. It discovers
 * the configured I/O MMU groups or sets a new one for the device. If a new
 * groups is assigned, the DMA mapping is performed.
 * Returns 0 on success, a negative value on failure and a positive value in
 * case the given device cannot be managed this way.
 */
int vfio_setup_device(const char *sysfs_base, const char *dev_addr,
		int *vfio_dev_fd, struct vfio_device_info *device_info);

int vfio_release_device(const char *sysfs_base, const char *dev_addr, int fd);

int vfio_enable(const char *modname);
int vfio_is_enabled(const char *modname);

int pci_vfio_enable(void);
int pci_vfio_is_enabled(void);

int vfio_mp_sync_setup(void);

#define SOCKET_REQ_CONTAINER 0x100
#define SOCKET_REQ_GROUP 0x200
#define SOCKET_CLR_GROUP 0x300
#define SOCKET_OK 0x0
#define SOCKET_NO_FD 0x1
#define SOCKET_ERR 0xFF

#define VFIO_PRESENT
#endif /* kernel version */
#endif /* RTE_EAL_VFIO */

#endif /* EAL_VFIO_H_ */
Commit	Line	Data
7c673cae FG	1	/*-
	2	* BSD LICENSE
	3	*
	4	* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
	5	* All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	*
	11	* * Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* * Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in
	15	* the documentation and/or other materials provided with the
	16	* distribution.
	17	* * Neither the name of Intel Corporation nor the names of its
	18	* contributors may be used to endorse or promote products derived
	19	* from this software without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	22	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	23	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	24	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	25	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	26	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	27	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	28	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	29	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	30	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	31	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	32	*/
	33
	34	#ifndef EAL_VFIO_H_
	35	#define EAL_VFIO_H_
	36
	37	/*
	38	* determine if VFIO is present on the system
	39	*/
	40	#ifdef RTE_EAL_VFIO
	41	#include <linux/version.h>
	42	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 6, 0)
	43	#include <linux/vfio.h>
	44
	45	#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0)
	46	#define RTE_PCI_MSIX_TABLE_BIR 0x7
	47	#define RTE_PCI_MSIX_TABLE_OFFSET 0xfffffff8
	48	#define RTE_PCI_MSIX_FLAGS_QSIZE 0x07ff
	49	#else
	50	#define RTE_PCI_MSIX_TABLE_BIR PCI_MSIX_TABLE_BIR
	51	#define RTE_PCI_MSIX_TABLE_OFFSET PCI_MSIX_TABLE_OFFSET
	52	#define RTE_PCI_MSIX_FLAGS_QSIZE PCI_MSIX_FLAGS_QSIZE
	53	#endif
	54
	55	#define RTE_VFIO_TYPE1 VFIO_TYPE1_IOMMU
	56
11fdf7f2 TL	57	#ifndef VFIO_SPAPR_TCE_v2_IOMMU
	58	#define RTE_VFIO_SPAPR 7
	59	#define VFIO_IOMMU_SPAPR_REGISTER_MEMORY _IO(VFIO_TYPE, VFIO_BASE + 17)
	60	#define VFIO_IOMMU_SPAPR_TCE_CREATE _IO(VFIO_TYPE, VFIO_BASE + 19)
	61	#define VFIO_IOMMU_SPAPR_TCE_REMOVE _IO(VFIO_TYPE, VFIO_BASE + 20)
	62
	63	struct vfio_iommu_spapr_register_memory {
	64	uint32_t argsz;
	65	uint32_t flags;
	66	uint64_t vaddr;
	67	uint64_t size;
	68	};
	69
	70	struct vfio_iommu_spapr_tce_create {
	71	uint32_t argsz;
	72	uint32_t flags;
	73	/* in */
	74	uint32_t page_shift;
	75	uint32_t __resv1;
	76	uint64_t window_size;
	77	uint32_t levels;
	78	uint32_t __resv2;
	79	/* out */
	80	uint64_t start_addr;
	81	};
	82
	83	struct vfio_iommu_spapr_tce_remove {
	84	uint32_t argsz;
	85	uint32_t flags;
	86	/* in */
	87	uint64_t start_addr;
	88	};
	89
	90	struct vfio_iommu_spapr_tce_ddw_info {
	91	uint64_t pgsizes;
	92	uint32_t max_dynamic_windows_supported;
	93	uint32_t levels;
	94	};
	95
	96	/* SPAPR_v2 is not present, but SPAPR might be */
	97	#ifndef VFIO_SPAPR_TCE_IOMMU
	98	#define VFIO_IOMMU_SPAPR_TCE_GET_INFO _IO(VFIO_TYPE, VFIO_BASE + 12)
	99
	100	struct vfio_iommu_spapr_tce_info {
	101	uint32_t argsz;
	102	uint32_t flags;
	103	uint32_t dma32_window_start;
	104	uint32_t dma32_window_size;
	105	struct vfio_iommu_spapr_tce_ddw_info ddw;
	106	};
	107	#endif /* VFIO_SPAPR_TCE_IOMMU */
	108
	109	#else /* VFIO_SPAPR_TCE_v2_IOMMU */
	110	#define RTE_VFIO_SPAPR VFIO_SPAPR_TCE_v2_IOMMU
	111	#endif
	112
7c673cae FG	113	#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0)
	114	#define RTE_VFIO_NOIOMMU 8
	115	#else
	116	#define RTE_VFIO_NOIOMMU VFIO_NOIOMMU_IOMMU
	117	#endif
	118
	119	#define VFIO_MAX_GROUPS 64
	120
	121	/*
	122	* Function prototypes for VFIO multiprocess sync functions
	123	*/
	124	int vfio_mp_sync_send_request(int socket, int req);
	125	int vfio_mp_sync_receive_request(int socket);
	126	int vfio_mp_sync_send_fd(int socket, int fd);
	127	int vfio_mp_sync_receive_fd(int socket);
	128	int vfio_mp_sync_connect_to_primary(void);
	129
	130	/*
	131	* we don't need to store device fd's anywhere since they can be obtained from
	132	* the group fd via an ioctl() call.
	133	*/
	134	struct vfio_group {
	135	int group_no;
	136	int fd;
11fdf7f2	137	int devices;
7c673cae FG	138	};
	139
	140	struct vfio_config {
	141	int vfio_enabled;
	142	int vfio_container_fd;
11fdf7f2	143	int vfio_active_groups;
7c673cae FG	144	struct vfio_group vfio_groups[VFIO_MAX_GROUPS];
	145	};
	146
	147	#define VFIO_DIR "/dev/vfio"
	148	#define VFIO_CONTAINER_PATH "/dev/vfio/vfio"
	149	#define VFIO_GROUP_FMT "/dev/vfio/%u"
	150	#define VFIO_NOIOMMU_GROUP_FMT "/dev/vfio/noiommu-%u"
	151	#define VFIO_GET_REGION_ADDR(x) ((uint64_t) x << 40ULL)
	152	#define VFIO_GET_REGION_IDX(x) (x >> 40)
	153
	154	/* DMA mapping function prototype.
	155	* Takes VFIO container fd as a parameter.
	156	* Returns 0 on success, -1 on error.
	157	* */
	158	typedef int (*vfio_dma_func_t)(int);
	159
	160	struct vfio_iommu_type {
	161	int type_id;
	162	const char *name;
	163	vfio_dma_func_t dma_map_func;
	164	};
	165
	166	/* pick IOMMU type. returns a pointer to vfio_iommu_type or NULL for error */
	167	const struct vfio_iommu_type *
	168	vfio_set_iommu_type(int vfio_container_fd);
	169
	170	/* check if we have any supported extensions */
	171	int
	172	vfio_has_supported_extensions(int vfio_container_fd);
	173
	174	/* open container fd or get an existing one */
	175	int
	176	vfio_get_container_fd(void);
	177
	178	/* parse IOMMU group number for a device
	179	* returns 1 on success, -1 for errors, 0 for non-existent group
	180	*/
	181	int
	182	vfio_get_group_no(const char *sysfs_base,
	183	const char dev_addr, int iommu_group_no);
	184
	185	/* open group fd or get an existing one */
	186	int
	187	vfio_get_group_fd(int iommu_group_no);
	188
11fdf7f2 TL	189	/* remove group fd from internal VFIO group fd array */
	190	int
	191	clear_group(int vfio_group_fd);
	192
7c673cae FG	193	/**
	194	* Setup vfio_cfg for the device identified by its address. It discovers
	195	* the configured I/O MMU groups or sets a new one for the device. If a new
	196	* groups is assigned, the DMA mapping is performed.
	197	* Returns 0 on success, a negative value on failure and a positive value in
	198	* case the given device cannot be managed this way.
	199	*/
	200	int vfio_setup_device(const char sysfs_base, const char dev_addr,
	201	int vfio_dev_fd, struct vfio_device_info device_info);
	202
11fdf7f2 TL	203	int vfio_release_device(const char sysfs_base, const char dev_addr, int fd);
11fdf7f2 TL	204
7c673cae FG	205	int vfio_enable(const char *modname);
	206	int vfio_is_enabled(const char *modname);
	207
	208	int pci_vfio_enable(void);
	209	int pci_vfio_is_enabled(void);
	210
	211	int vfio_mp_sync_setup(void);
	212
	213	#define SOCKET_REQ_CONTAINER 0x100
	214	#define SOCKET_REQ_GROUP 0x200
11fdf7f2	215	#define SOCKET_CLR_GROUP 0x300
7c673cae FG	216	#define SOCKET_OK 0x0
	217	#define SOCKET_NO_FD 0x1
	218	#define SOCKET_ERR 0xFF
	219
	220	#define VFIO_PRESENT
	221	#endif /* kernel version */
	222	#endif /* RTE_EAL_VFIO */
	223
	224	#endif /* EAL_VFIO_H_ */