|
@@ -51,6 +51,10 @@ enum {
|
|
IOMMUFD_CMD_HWPT_GET_DIRTY_BITMAP = 0x8c,
|
|
IOMMUFD_CMD_HWPT_GET_DIRTY_BITMAP = 0x8c,
|
|
IOMMUFD_CMD_HWPT_INVALIDATE = 0x8d,
|
|
IOMMUFD_CMD_HWPT_INVALIDATE = 0x8d,
|
|
IOMMUFD_CMD_FAULT_QUEUE_ALLOC = 0x8e,
|
|
IOMMUFD_CMD_FAULT_QUEUE_ALLOC = 0x8e,
|
|
|
|
+ IOMMUFD_CMD_IOAS_MAP_FILE = 0x8f,
|
|
|
|
+ IOMMUFD_CMD_VIOMMU_ALLOC = 0x90,
|
|
|
|
+ IOMMUFD_CMD_VDEVICE_ALLOC = 0x91,
|
|
|
|
+ IOMMUFD_CMD_IOAS_CHANGE_PROCESS = 0x92,
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
/**
|
|
@@ -213,6 +217,30 @@ struct iommu_ioas_map {
|
|
};
|
|
};
|
|
#define IOMMU_IOAS_MAP _IO(IOMMUFD_TYPE, IOMMUFD_CMD_IOAS_MAP)
|
|
#define IOMMU_IOAS_MAP _IO(IOMMUFD_TYPE, IOMMUFD_CMD_IOAS_MAP)
|
|
|
|
|
|
|
|
+/**
|
|
|
|
+ * struct iommu_ioas_map_file - ioctl(IOMMU_IOAS_MAP_FILE)
|
|
|
|
+ * @size: sizeof(struct iommu_ioas_map_file)
|
|
|
|
+ * @flags: same as for iommu_ioas_map
|
|
|
|
+ * @ioas_id: same as for iommu_ioas_map
|
|
|
|
+ * @fd: the memfd to map
|
|
|
|
+ * @start: byte offset from start of file to map from
|
|
|
|
+ * @length: same as for iommu_ioas_map
|
|
|
|
+ * @iova: same as for iommu_ioas_map
|
|
|
|
+ *
|
|
|
|
+ * Set an IOVA mapping from a memfd file. All other arguments and semantics
|
|
|
|
+ * match those of IOMMU_IOAS_MAP.
|
|
|
|
+ */
|
|
|
|
+struct iommu_ioas_map_file {
|
|
|
|
+ __u32 size;
|
|
|
|
+ __u32 flags;
|
|
|
|
+ __u32 ioas_id;
|
|
|
|
+ __s32 fd;
|
|
|
|
+ __aligned_u64 start;
|
|
|
|
+ __aligned_u64 length;
|
|
|
|
+ __aligned_u64 iova;
|
|
|
|
+};
|
|
|
|
+#define IOMMU_IOAS_MAP_FILE _IO(IOMMUFD_TYPE, IOMMUFD_CMD_IOAS_MAP_FILE)
|
|
|
|
+
|
|
/**
|
|
/**
|
|
* struct iommu_ioas_copy - ioctl(IOMMU_IOAS_COPY)
|
|
* struct iommu_ioas_copy - ioctl(IOMMU_IOAS_COPY)
|
|
* @size: sizeof(struct iommu_ioas_copy)
|
|
* @size: sizeof(struct iommu_ioas_copy)
|
|
@@ -359,11 +387,19 @@ struct iommu_vfio_ioas {
|
|
* enforced on device attachment
|
|
* enforced on device attachment
|
|
* @IOMMU_HWPT_FAULT_ID_VALID: The fault_id field of hwpt allocation data is
|
|
* @IOMMU_HWPT_FAULT_ID_VALID: The fault_id field of hwpt allocation data is
|
|
* valid.
|
|
* valid.
|
|
|
|
+ * @IOMMU_HWPT_ALLOC_PASID: Requests a domain that can be used with PASID. The
|
|
|
|
+ * domain can be attached to any PASID on the device.
|
|
|
|
+ * Any domain attached to the non-PASID part of the
|
|
|
|
+ * device must also be flaged, otherwise attaching a
|
|
|
|
+ * PASID will blocked.
|
|
|
|
+ * If IOMMU does not support PASID it will return
|
|
|
|
+ * error (-EOPNOTSUPP).
|
|
*/
|
|
*/
|
|
enum iommufd_hwpt_alloc_flags {
|
|
enum iommufd_hwpt_alloc_flags {
|
|
IOMMU_HWPT_ALLOC_NEST_PARENT = 1 << 0,
|
|
IOMMU_HWPT_ALLOC_NEST_PARENT = 1 << 0,
|
|
IOMMU_HWPT_ALLOC_DIRTY_TRACKING = 1 << 1,
|
|
IOMMU_HWPT_ALLOC_DIRTY_TRACKING = 1 << 1,
|
|
IOMMU_HWPT_FAULT_ID_VALID = 1 << 2,
|
|
IOMMU_HWPT_FAULT_ID_VALID = 1 << 2,
|
|
|
|
+ IOMMU_HWPT_ALLOC_PASID = 1 << 3,
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
/**
|
|
@@ -394,14 +430,36 @@ struct iommu_hwpt_vtd_s1 {
|
|
__u32 __reserved;
|
|
__u32 __reserved;
|
|
};
|
|
};
|
|
|
|
|
|
|
|
+/**
|
|
|
|
+ * struct iommu_hwpt_arm_smmuv3 - ARM SMMUv3 nested STE
|
|
|
|
+ * (IOMMU_HWPT_DATA_ARM_SMMUV3)
|
|
|
|
+ *
|
|
|
|
+ * @ste: The first two double words of the user space Stream Table Entry for
|
|
|
|
+ * the translation. Must be little-endian.
|
|
|
|
+ * Allowed fields: (Refer to "5.2 Stream Table Entry" in SMMUv3 HW Spec)
|
|
|
|
+ * - word-0: V, Cfg, S1Fmt, S1ContextPtr, S1CDMax
|
|
|
|
+ * - word-1: EATS, S1DSS, S1CIR, S1COR, S1CSH, S1STALLD
|
|
|
|
+ *
|
|
|
|
+ * -EIO will be returned if @ste is not legal or contains any non-allowed field.
|
|
|
|
+ * Cfg can be used to select a S1, Bypass or Abort configuration. A Bypass
|
|
|
|
+ * nested domain will translate the same as the nesting parent. The S1 will
|
|
|
|
+ * install a Context Descriptor Table pointing at userspace memory translated
|
|
|
|
+ * by the nesting parent.
|
|
|
|
+ */
|
|
|
|
+struct iommu_hwpt_arm_smmuv3 {
|
|
|
|
+ __aligned_le64 ste[2];
|
|
|
|
+};
|
|
|
|
+
|
|
/**
|
|
/**
|
|
* enum iommu_hwpt_data_type - IOMMU HWPT Data Type
|
|
* enum iommu_hwpt_data_type - IOMMU HWPT Data Type
|
|
* @IOMMU_HWPT_DATA_NONE: no data
|
|
* @IOMMU_HWPT_DATA_NONE: no data
|
|
* @IOMMU_HWPT_DATA_VTD_S1: Intel VT-d stage-1 page table
|
|
* @IOMMU_HWPT_DATA_VTD_S1: Intel VT-d stage-1 page table
|
|
|
|
+ * @IOMMU_HWPT_DATA_ARM_SMMUV3: ARM SMMUv3 Context Descriptor Table
|
|
*/
|
|
*/
|
|
enum iommu_hwpt_data_type {
|
|
enum iommu_hwpt_data_type {
|
|
IOMMU_HWPT_DATA_NONE = 0,
|
|
IOMMU_HWPT_DATA_NONE = 0,
|
|
IOMMU_HWPT_DATA_VTD_S1 = 1,
|
|
IOMMU_HWPT_DATA_VTD_S1 = 1,
|
|
|
|
+ IOMMU_HWPT_DATA_ARM_SMMUV3 = 2,
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
/**
|
|
@@ -409,7 +467,7 @@ enum iommu_hwpt_data_type {
|
|
* @size: sizeof(struct iommu_hwpt_alloc)
|
|
* @size: sizeof(struct iommu_hwpt_alloc)
|
|
* @flags: Combination of enum iommufd_hwpt_alloc_flags
|
|
* @flags: Combination of enum iommufd_hwpt_alloc_flags
|
|
* @dev_id: The device to allocate this HWPT for
|
|
* @dev_id: The device to allocate this HWPT for
|
|
- * @pt_id: The IOAS or HWPT to connect this HWPT to
|
|
|
|
|
|
+ * @pt_id: The IOAS or HWPT or vIOMMU to connect this HWPT to
|
|
* @out_hwpt_id: The ID of the new HWPT
|
|
* @out_hwpt_id: The ID of the new HWPT
|
|
* @__reserved: Must be 0
|
|
* @__reserved: Must be 0
|
|
* @data_type: One of enum iommu_hwpt_data_type
|
|
* @data_type: One of enum iommu_hwpt_data_type
|
|
@@ -428,11 +486,13 @@ enum iommu_hwpt_data_type {
|
|
* IOMMU_HWPT_DATA_NONE. The HWPT can be allocated as a parent HWPT for a
|
|
* IOMMU_HWPT_DATA_NONE. The HWPT can be allocated as a parent HWPT for a
|
|
* nesting configuration by passing IOMMU_HWPT_ALLOC_NEST_PARENT via @flags.
|
|
* nesting configuration by passing IOMMU_HWPT_ALLOC_NEST_PARENT via @flags.
|
|
*
|
|
*
|
|
- * A user-managed nested HWPT will be created from a given parent HWPT via
|
|
|
|
- * @pt_id, in which the parent HWPT must be allocated previously via the
|
|
|
|
- * same ioctl from a given IOAS (@pt_id). In this case, the @data_type
|
|
|
|
- * must be set to a pre-defined type corresponding to an I/O page table
|
|
|
|
- * type supported by the underlying IOMMU hardware.
|
|
|
|
|
|
+ * A user-managed nested HWPT will be created from a given vIOMMU (wrapping a
|
|
|
|
+ * parent HWPT) or a parent HWPT via @pt_id, in which the parent HWPT must be
|
|
|
|
+ * allocated previously via the same ioctl from a given IOAS (@pt_id). In this
|
|
|
|
+ * case, the @data_type must be set to a pre-defined type corresponding to an
|
|
|
|
+ * I/O page table type supported by the underlying IOMMU hardware. The device
|
|
|
|
+ * via @dev_id and the vIOMMU via @pt_id must be associated to the same IOMMU
|
|
|
|
+ * instance.
|
|
*
|
|
*
|
|
* If the @data_type is set to IOMMU_HWPT_DATA_NONE, @data_len and
|
|
* If the @data_type is set to IOMMU_HWPT_DATA_NONE, @data_len and
|
|
* @data_uptr should be zero. Otherwise, both @data_len and @data_uptr
|
|
* @data_uptr should be zero. Otherwise, both @data_len and @data_uptr
|
|
@@ -484,15 +544,50 @@ struct iommu_hw_info_vtd {
|
|
__aligned_u64 ecap_reg;
|
|
__aligned_u64 ecap_reg;
|
|
};
|
|
};
|
|
|
|
|
|
|
|
+/**
|
|
|
|
+ * struct iommu_hw_info_arm_smmuv3 - ARM SMMUv3 hardware information
|
|
|
|
+ * (IOMMU_HW_INFO_TYPE_ARM_SMMUV3)
|
|
|
|
+ *
|
|
|
|
+ * @flags: Must be set to 0
|
|
|
|
+ * @__reserved: Must be 0
|
|
|
|
+ * @idr: Implemented features for ARM SMMU Non-secure programming interface
|
|
|
|
+ * @iidr: Information about the implementation and implementer of ARM SMMU,
|
|
|
|
+ * and architecture version supported
|
|
|
|
+ * @aidr: ARM SMMU architecture version
|
|
|
|
+ *
|
|
|
|
+ * For the details of @idr, @iidr and @aidr, please refer to the chapters
|
|
|
|
+ * from 6.3.1 to 6.3.6 in the SMMUv3 Spec.
|
|
|
|
+ *
|
|
|
|
+ * User space should read the underlying ARM SMMUv3 hardware information for
|
|
|
|
+ * the list of supported features.
|
|
|
|
+ *
|
|
|
|
+ * Note that these values reflect the raw HW capability, without any insight if
|
|
|
|
+ * any required kernel driver support is present. Bits may be set indicating the
|
|
|
|
+ * HW has functionality that is lacking kernel software support, such as BTM. If
|
|
|
|
+ * a VMM is using this information to construct emulated copies of these
|
|
|
|
+ * registers it should only forward bits that it knows it can support.
|
|
|
|
+ *
|
|
|
|
+ * In future, presence of required kernel support will be indicated in flags.
|
|
|
|
+ */
|
|
|
|
+struct iommu_hw_info_arm_smmuv3 {
|
|
|
|
+ __u32 flags;
|
|
|
|
+ __u32 __reserved;
|
|
|
|
+ __u32 idr[6];
|
|
|
|
+ __u32 iidr;
|
|
|
|
+ __u32 aidr;
|
|
|
|
+};
|
|
|
|
+
|
|
/**
|
|
/**
|
|
* enum iommu_hw_info_type - IOMMU Hardware Info Types
|
|
* enum iommu_hw_info_type - IOMMU Hardware Info Types
|
|
* @IOMMU_HW_INFO_TYPE_NONE: Used by the drivers that do not report hardware
|
|
* @IOMMU_HW_INFO_TYPE_NONE: Used by the drivers that do not report hardware
|
|
* info
|
|
* info
|
|
* @IOMMU_HW_INFO_TYPE_INTEL_VTD: Intel VT-d iommu info type
|
|
* @IOMMU_HW_INFO_TYPE_INTEL_VTD: Intel VT-d iommu info type
|
|
|
|
+ * @IOMMU_HW_INFO_TYPE_ARM_SMMUV3: ARM SMMUv3 iommu info type
|
|
*/
|
|
*/
|
|
enum iommu_hw_info_type {
|
|
enum iommu_hw_info_type {
|
|
IOMMU_HW_INFO_TYPE_NONE = 0,
|
|
IOMMU_HW_INFO_TYPE_NONE = 0,
|
|
IOMMU_HW_INFO_TYPE_INTEL_VTD = 1,
|
|
IOMMU_HW_INFO_TYPE_INTEL_VTD = 1,
|
|
|
|
+ IOMMU_HW_INFO_TYPE_ARM_SMMUV3 = 2,
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
/**
|
|
@@ -627,9 +722,11 @@ struct iommu_hwpt_get_dirty_bitmap {
|
|
* enum iommu_hwpt_invalidate_data_type - IOMMU HWPT Cache Invalidation
|
|
* enum iommu_hwpt_invalidate_data_type - IOMMU HWPT Cache Invalidation
|
|
* Data Type
|
|
* Data Type
|
|
* @IOMMU_HWPT_INVALIDATE_DATA_VTD_S1: Invalidation data for VTD_S1
|
|
* @IOMMU_HWPT_INVALIDATE_DATA_VTD_S1: Invalidation data for VTD_S1
|
|
|
|
+ * @IOMMU_VIOMMU_INVALIDATE_DATA_ARM_SMMUV3: Invalidation data for ARM SMMUv3
|
|
*/
|
|
*/
|
|
enum iommu_hwpt_invalidate_data_type {
|
|
enum iommu_hwpt_invalidate_data_type {
|
|
IOMMU_HWPT_INVALIDATE_DATA_VTD_S1 = 0,
|
|
IOMMU_HWPT_INVALIDATE_DATA_VTD_S1 = 0,
|
|
|
|
+ IOMMU_VIOMMU_INVALIDATE_DATA_ARM_SMMUV3 = 1,
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
/**
|
|
@@ -668,10 +765,32 @@ struct iommu_hwpt_vtd_s1_invalidate {
|
|
__u32 __reserved;
|
|
__u32 __reserved;
|
|
};
|
|
};
|
|
|
|
|
|
|
|
+/**
|
|
|
|
+ * struct iommu_viommu_arm_smmuv3_invalidate - ARM SMMUv3 cahce invalidation
|
|
|
|
+ * (IOMMU_VIOMMU_INVALIDATE_DATA_ARM_SMMUV3)
|
|
|
|
+ * @cmd: 128-bit cache invalidation command that runs in SMMU CMDQ.
|
|
|
|
+ * Must be little-endian.
|
|
|
|
+ *
|
|
|
|
+ * Supported command list only when passing in a vIOMMU via @hwpt_id:
|
|
|
|
+ * CMDQ_OP_TLBI_NSNH_ALL
|
|
|
|
+ * CMDQ_OP_TLBI_NH_VA
|
|
|
|
+ * CMDQ_OP_TLBI_NH_VAA
|
|
|
|
+ * CMDQ_OP_TLBI_NH_ALL
|
|
|
|
+ * CMDQ_OP_TLBI_NH_ASID
|
|
|
|
+ * CMDQ_OP_ATC_INV
|
|
|
|
+ * CMDQ_OP_CFGI_CD
|
|
|
|
+ * CMDQ_OP_CFGI_CD_ALL
|
|
|
|
+ *
|
|
|
|
+ * -EIO will be returned if the command is not supported.
|
|
|
|
+ */
|
|
|
|
+struct iommu_viommu_arm_smmuv3_invalidate {
|
|
|
|
+ __aligned_le64 cmd[2];
|
|
|
|
+};
|
|
|
|
+
|
|
/**
|
|
/**
|
|
* struct iommu_hwpt_invalidate - ioctl(IOMMU_HWPT_INVALIDATE)
|
|
* struct iommu_hwpt_invalidate - ioctl(IOMMU_HWPT_INVALIDATE)
|
|
* @size: sizeof(struct iommu_hwpt_invalidate)
|
|
* @size: sizeof(struct iommu_hwpt_invalidate)
|
|
- * @hwpt_id: ID of a nested HWPT for cache invalidation
|
|
|
|
|
|
+ * @hwpt_id: ID of a nested HWPT or a vIOMMU, for cache invalidation
|
|
* @data_uptr: User pointer to an array of driver-specific cache invalidation
|
|
* @data_uptr: User pointer to an array of driver-specific cache invalidation
|
|
* data.
|
|
* data.
|
|
* @data_type: One of enum iommu_hwpt_invalidate_data_type, defining the data
|
|
* @data_type: One of enum iommu_hwpt_invalidate_data_type, defining the data
|
|
@@ -682,8 +801,11 @@ struct iommu_hwpt_vtd_s1_invalidate {
|
|
* Output the number of requests successfully handled by kernel.
|
|
* Output the number of requests successfully handled by kernel.
|
|
* @__reserved: Must be 0.
|
|
* @__reserved: Must be 0.
|
|
*
|
|
*
|
|
- * Invalidate the iommu cache for user-managed page table. Modifications on a
|
|
|
|
- * user-managed page table should be followed by this operation to sync cache.
|
|
|
|
|
|
+ * Invalidate iommu cache for user-managed page table or vIOMMU. Modifications
|
|
|
|
+ * on a user-managed page table should be followed by this operation, if a HWPT
|
|
|
|
+ * is passed in via @hwpt_id. Other caches, such as device cache or descriptor
|
|
|
|
+ * cache can be flushed if a vIOMMU is passed in via the @hwpt_id field.
|
|
|
|
+ *
|
|
* Each ioctl can support one or more cache invalidation requests in the array
|
|
* Each ioctl can support one or more cache invalidation requests in the array
|
|
* that has a total size of @entry_len * @entry_num.
|
|
* that has a total size of @entry_len * @entry_num.
|
|
*
|
|
*
|
|
@@ -797,4 +919,88 @@ struct iommu_fault_alloc {
|
|
__u32 out_fault_fd;
|
|
__u32 out_fault_fd;
|
|
};
|
|
};
|
|
#define IOMMU_FAULT_QUEUE_ALLOC _IO(IOMMUFD_TYPE, IOMMUFD_CMD_FAULT_QUEUE_ALLOC)
|
|
#define IOMMU_FAULT_QUEUE_ALLOC _IO(IOMMUFD_TYPE, IOMMUFD_CMD_FAULT_QUEUE_ALLOC)
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * enum iommu_viommu_type - Virtual IOMMU Type
|
|
|
|
+ * @IOMMU_VIOMMU_TYPE_DEFAULT: Reserved for future use
|
|
|
|
+ * @IOMMU_VIOMMU_TYPE_ARM_SMMUV3: ARM SMMUv3 driver specific type
|
|
|
|
+ */
|
|
|
|
+enum iommu_viommu_type {
|
|
|
|
+ IOMMU_VIOMMU_TYPE_DEFAULT = 0,
|
|
|
|
+ IOMMU_VIOMMU_TYPE_ARM_SMMUV3 = 1,
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * struct iommu_viommu_alloc - ioctl(IOMMU_VIOMMU_ALLOC)
|
|
|
|
+ * @size: sizeof(struct iommu_viommu_alloc)
|
|
|
|
+ * @flags: Must be 0
|
|
|
|
+ * @type: Type of the virtual IOMMU. Must be defined in enum iommu_viommu_type
|
|
|
|
+ * @dev_id: The device's physical IOMMU will be used to back the virtual IOMMU
|
|
|
|
+ * @hwpt_id: ID of a nesting parent HWPT to associate to
|
|
|
|
+ * @out_viommu_id: Output virtual IOMMU ID for the allocated object
|
|
|
|
+ *
|
|
|
|
+ * Allocate a virtual IOMMU object, representing the underlying physical IOMMU's
|
|
|
|
+ * virtualization support that is a security-isolated slice of the real IOMMU HW
|
|
|
|
+ * that is unique to a specific VM. Operations global to the IOMMU are connected
|
|
|
|
+ * to the vIOMMU, such as:
|
|
|
|
+ * - Security namespace for guest owned ID, e.g. guest-controlled cache tags
|
|
|
|
+ * - Non-device-affiliated event reporting, e.g. invalidation queue errors
|
|
|
|
+ * - Access to a sharable nesting parent pagetable across physical IOMMUs
|
|
|
|
+ * - Virtualization of various platforms IDs, e.g. RIDs and others
|
|
|
|
+ * - Delivery of paravirtualized invalidation
|
|
|
|
+ * - Direct assigned invalidation queues
|
|
|
|
+ * - Direct assigned interrupts
|
|
|
|
+ */
|
|
|
|
+struct iommu_viommu_alloc {
|
|
|
|
+ __u32 size;
|
|
|
|
+ __u32 flags;
|
|
|
|
+ __u32 type;
|
|
|
|
+ __u32 dev_id;
|
|
|
|
+ __u32 hwpt_id;
|
|
|
|
+ __u32 out_viommu_id;
|
|
|
|
+};
|
|
|
|
+#define IOMMU_VIOMMU_ALLOC _IO(IOMMUFD_TYPE, IOMMUFD_CMD_VIOMMU_ALLOC)
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * struct iommu_vdevice_alloc - ioctl(IOMMU_VDEVICE_ALLOC)
|
|
|
|
+ * @size: sizeof(struct iommu_vdevice_alloc)
|
|
|
|
+ * @viommu_id: vIOMMU ID to associate with the virtual device
|
|
|
|
+ * @dev_id: The physical device to allocate a virtual instance on the vIOMMU
|
|
|
|
+ * @out_vdevice_id: Object handle for the vDevice. Pass to IOMMU_DESTORY
|
|
|
|
+ * @virt_id: Virtual device ID per vIOMMU, e.g. vSID of ARM SMMUv3, vDeviceID
|
|
|
|
+ * of AMD IOMMU, and vRID of a nested Intel VT-d to a Context Table
|
|
|
|
+ *
|
|
|
|
+ * Allocate a virtual device instance (for a physical device) against a vIOMMU.
|
|
|
|
+ * This instance holds the device's information (related to its vIOMMU) in a VM.
|
|
|
|
+ */
|
|
|
|
+struct iommu_vdevice_alloc {
|
|
|
|
+ __u32 size;
|
|
|
|
+ __u32 viommu_id;
|
|
|
|
+ __u32 dev_id;
|
|
|
|
+ __u32 out_vdevice_id;
|
|
|
|
+ __aligned_u64 virt_id;
|
|
|
|
+};
|
|
|
|
+#define IOMMU_VDEVICE_ALLOC _IO(IOMMUFD_TYPE, IOMMUFD_CMD_VDEVICE_ALLOC)
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * struct iommu_ioas_change_process - ioctl(VFIO_IOAS_CHANGE_PROCESS)
|
|
|
|
+ * @size: sizeof(struct iommu_ioas_change_process)
|
|
|
|
+ * @__reserved: Must be 0
|
|
|
|
+ *
|
|
|
|
+ * This transfers pinned memory counts for every memory map in every IOAS
|
|
|
|
+ * in the context to the current process. This only supports maps created
|
|
|
|
+ * with IOMMU_IOAS_MAP_FILE, and returns EINVAL if other maps are present.
|
|
|
|
+ * If the ioctl returns a failure status, then nothing is changed.
|
|
|
|
+ *
|
|
|
|
+ * This API is useful for transferring operation of a device from one process
|
|
|
|
+ * to another, such as during userland live update.
|
|
|
|
+ */
|
|
|
|
+struct iommu_ioas_change_process {
|
|
|
|
+ __u32 size;
|
|
|
|
+ __u32 __reserved;
|
|
|
|
+};
|
|
|
|
+
|
|
|
|
+#define IOMMU_IOAS_CHANGE_PROCESS \
|
|
|
|
+ _IO(IOMMUFD_TYPE, IOMMUFD_CMD_IOAS_CHANGE_PROCESS)
|
|
|
|
+
|
|
#endif
|
|
#endif
|