Skip to contentSkip to conversation

IOMMU user API enhancement

PATCH Superseded Jacob Pan 4 participants 19 messages Jul 16, 2020 – Jul 21, 2020

Subsystems (3)

v5 of 7 Superseded Latest is v7 →

lore
Share & tools
lore

Jacob Pan

author
#0 lore raw

v5 cover IOMMU user API enhancement

IOMMU user API header was introduced to support nested DMA translation and related fault handling. The current UAPI data structures consist of three areas that cover the interactions between host kernel and guest:
- fault handling
- cache invalidation
- bind guest page tables, i.e. guest PASID

Future extensions are likely to support more architectures and vIOMMU features.

In the previous discussion, using user-filled data size and feature flags is made a preferred approach over a unified version number.
https://lkml.org/lkml/2020/1/29/45

In addition to introduce argsz field to data structures, this patchset is also trying to document the UAPI design, usage, and extension rules. VT-d driver changes to utilize the new argsz field is included, VFIO usage is to follow.

Thanks,

Jacob

Changeog:
v5
- Addjusted paddings in UAPI data to be 8 byte aligned
- Do not clobber argsz in IOMMU core before passing on to vendor driver
- Removed pr_warn_ for invalid UAPI data check, just return -EINVAL
- Clarified VFIO responsibility in UAPI data handling
- Use iommu_uapi prefix to differentiate APIs has in-kernel caller
- Added comment for unchecked flags of invalidation granularity
- Added example in doc to show vendor data checking

v4
- Added checks of UAPI data for reserved fields, version, and flags.
- Removed version check from vendor driver (vt-d)
- Relaxed argsz check to match the UAPI struct size instead of variable union size
- Updated documentation

v3:
- Rewrote backward compatibility rule to support existing code re-compiled with newer kernel UAPI header that runs on older kernel. Based on review comment from Alex W.
https://lore.kernel.org/linux-iommu/[email protected]/
- Take user pointer directly in UAPI functions. Perform argsz check and copy_from_user() in IOMMU driver. Eliminate the need for VFIO or other upper layer to parse IOMMU data.
- Create wrapper function for in-kernel users of UAPI functions
v2:
- Removed unified API version and helper
- Introduced argsz for each UAPI data
- Introduced UAPI doc

Jacob Pan (5):
docs: IOMMU user API
iommu/uapi: Add argsz for user filled data iommu/uapi: Use named union for user data iommu/uapi: Handle data and argsz filled by users iommu/vt-d: Check UAPI data processed by IOMMU core

 Documentation/userspace-api/iommu.rst | 338 ++++++++++++++++++++++++++++++++++
 drivers/iommu/intel/iommu.c           |  27 ++-
 drivers/iommu/intel/svm.c             |   9 +-
 drivers/iommu/iommu.c                 | 192 ++++++++++++++++++-
 include/linux/iommu.h                 |  20 +-
 include/uapi/linux/iommu.h            |  16 +-
 6 files changed, 568 insertions(+), 34 deletions(-)
 create mode 100644 Documentation/userspace-api/iommu.rst
Signature · 6 lines
2.7.4

_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
author
#6 lore raw

PATCH v5 2/5 iommu/uapi: Add argsz for user filled data

As IOMMU UAPI gets extended, user data size may increase. To support backward compatibiliy, this patch introduces a size field to each UAPI data structures. It is *always* the responsibility for the user to fill in the correct size. Padding fields are adjusted to ensure 8 byte alignment.

Specific scenarios for user data handling are documented in:
Documentation/userspace-api/iommu.rst

---
 include/uapi/linux/iommu.h | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)
include/uapi/linux/iommu.h +9 -3
index e907b7091a46..d5e9014f690e 100644
@@ -135,6 +135,7 @@ enum iommu_page_response_code {
 
 /**
  * struct iommu_page_response - Generic page response information
+ * @argsz: User filled size of this data
  * @version: API version of this structure
  * @flags: encodes whether the corresponding fields are valid
  *         (IOMMU_FAULT_PAGE_RESPONSE_* values)
@@ -143,6 +144,7 @@ enum iommu_page_response_code {
  * @code: response code from &enum iommu_page_response_code
  */
 struct iommu_page_response {
+	__u32	argsz;
 #define IOMMU_PAGE_RESP_VERSION_1	1
 	__u32	version;
 #define IOMMU_PAGE_RESP_PASID_VALID	(1 << 0)
@@ -218,6 +220,7 @@ struct iommu_inv_pasid_info {
 /**
  * struct iommu_cache_invalidate_info - First level/stage invalidation
  *     information
+ * @argsz: User filled size of this data
  * @version: API version of this structure
  * @cache: bitfield that allows to select which caches to invalidate
  * @granularity: defines the lowest granularity used for the invalidation:
@@ -246,6 +249,7 @@ struct iommu_inv_pasid_info {
  * must support the used granularity.
  */
 struct iommu_cache_invalidate_info {
+	__u32	argsz;
 #define IOMMU_CACHE_INVALIDATE_INFO_VERSION_1 1
 	__u32	version;
 /* IOMMU paging structure cache */
@@ -255,7 +259,7 @@ struct iommu_cache_invalidate_info {
 #define IOMMU_CACHE_INV_TYPE_NR		(3)
 	__u8	cache;
 	__u8	granularity;
-	__u8	padding[2];
+	__u8	padding[6];
 	union {
 		struct iommu_inv_pasid_info pasid_info;
 		struct iommu_inv_addr_info addr_info;
@@ -292,6 +296,7 @@ struct iommu_gpasid_bind_data_vtd {
 
 /**
  * struct iommu_gpasid_bind_data - Information about device and guest PASID binding
+ * @argsz:	User filled size of this data
  * @version:	Version of this data structure
  * @format:	PASID table entry format
  * @flags:	Additional information on guest bind request
@@ -309,17 +314,18 @@ struct iommu_gpasid_bind_data_vtd {
  * PASID to host PASID based on this bind data.
  */
 struct iommu_gpasid_bind_data {
+	__u32 argsz;
 #define IOMMU_GPASID_BIND_VERSION_1	1
 	__u32 version;
 #define IOMMU_PASID_FORMAT_INTEL_VTD	1
 	__u32 format;
+	__u32 addr_width;
 #define IOMMU_SVA_GPASID_VAL	(1 << 0) /* guest PASID valid */
 	__u64 flags;
 	__u64 gpgd;
 	__u64 hpasid;
 	__u64 gpasid;
-	__u32 addr_width;
-	__u8  padding[12];
+	__u8  padding[8];
 	/* Vendor specific data */
 	union {
 		struct iommu_gpasid_bind_data_vtd vtd;
Signature · 6 lines
2.7.4

_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
author
#1 lore raw

PATCH v5 1/5 docs: IOMMU user API

In reply to Jacob Pan

IOMMU UAPI is newly introduced to support communications between guest virtual IOMMU and host IOMMU. There has been lots of discussions on how it should work with VFIO UAPI and userspace in general.

This document is indended to clarify the UAPI design and usage. The mechanics of how future extensions should be achieved are also covered in this documentation.

---
 Documentation/userspace-api/iommu.rst | 339 ++++++++++++++++++++++++++++++++++
 1 file changed, 339 insertions(+)
 create mode 100644 Documentation/userspace-api/iommu.rst
Documentation/userspace-api/iommu.rst new file +339 -0
new file mode 100644
index 000000000000..efc3e1838235
@@ -0,0 +1,339 @@
+.. SPDX-License-Identifier: GPL-2.0
+.. iommu:
+
+=====================================
+IOMMU Userspace API
+=====================================
+
+IOMMU UAPI is used for virtualization cases where communications are
+needed between physical and virtual IOMMU drivers. For native
+usage, IOMMU is a system device which does not need to communicate
+with user space directly.
+
+The primary use cases are guest Shared Virtual Address (SVA) and
+guest IO virtual address (IOVA), wherein a virtual IOMMU (vIOMMU) is
+required to communicate with the physical IOMMU in the host.
+
+.. contents:: :local:
+
+Functionalities
+===============
+Communications of user and kernel involve both directions. The
+supported user-kernel APIs are as follows:
+
+1. Alloc/Free PASID
+2. Bind/unbind guest PASID (e.g. Intel VT-d)
+3. Bind/unbind guest PASID table (e.g. ARM sMMU)
+4. Invalidate IOMMU caches
+5. Service IO page faults (page request and response)
+
+Requirements
+============
+The IOMMU UAPIs are generic and extensible to meet the following
+requirements:
+
+1. Emulated and para-virtualised vIOMMUs
+2. Multiple vendors (Intel VT-d, ARM sMMU, etc.)
+3. Extensions to the UAPI shall not break existing user space
+
+Interfaces
+==========
+Although the data structures defined in IOMMU UAPI are self-contained,
+there is no user API functions introduced. Instead, IOMMU UAPI is
+designed to work with existing user driver frameworks such as VFIO.
+
+Extension Rules & Precautions
+-----------------------------
+When IOMMU UAPI gets extended, the data structures can *only* be
+modified in two ways:
+
+1. Adding new fields by re-purposing the padding[] field. No size change.
+2. Adding new union members at the end. May increase in size.
+
+No new fields can be added *after* the variable sized union in that it
+will break backward compatibility when offset moves. In both cases, a
+new flag must be accompanied with a new field such that the IOMMU
+driver can process the data based on the new flag. Version field is
+only reserved for the unlikely event of UAPI upgrade at its entirety.
+
+It's *always* the caller's responsibility to indicate the size of the
+structure passed by setting argsz appropriately.
+Though at the same time, argsz is user provided data which is not
+trusted. The argsz field allows the user to indicate how much data
+they're providing, it's still the kernel's responsibility to validate
+whether it's correct and sufficient for the requested operation.
+
+Compatibility Checking
+----------------------
+When IOMMU UAPI extension results in size increase, IOMMU UAPI core
+and vendor driver shall handle the following cases:
+
+1. User and kernel has exact size match
+2. An older user with older kernel header (smaller UAPI size) running on a
+   newer kernel (larger UAPI size)
+3. A newer user with newer kernel header (larger UAPI size) running
+   on an older kernel.
+4. A malicious/misbehaving user pass illegal/invalid size but within
+   range. The data may contain garbage.
+
+Feature Checking
+----------------
+While launching a guest with vIOMMU, it is important to ensure that host
+can support the UAPI data structures to be used for vIOMMU-pIOMMU
+communications. Without upfront compatibility checking, future faults
+are difficult to report even in normal conditions. For example, TLB
+invalidations should always succeed. There is no architectural way to
+report back to the vIOMMU if the UAPI data is incompatible. If that
+happens, in order to protect IOMMU iosolation guarantee, we have to
+resort to not giving completion status in vIOMMU. This may result in
+VM hang.
+
+For this reason the following IOMMU UAPIs cannot fail:
+
+1. Free PASID
+2. Unbind guest PASID
+3. Unbind guest PASID table (SMMU)
+4. Cache invalidate
+
+User applications such as QEMU are expected to import kernel UAPI
+headers. Backward compatibility is supported per feature flags.
+For example, an older QEMU (with older kernel header) can run on newer
+kernel. Newer QEMU (with new kernel header) may refuse to initialize
+on an older kernel if new feature flags are not supported by older
+kernel. Simply recompiling existing code with newer kernel header should
+not be an issue in that only existing flags are used.
+
+IOMMU vendor driver should report the below features to IOMMU UAPI
+consumers (e.g. via VFIO).
+
+1. IOMMU_NESTING_FEAT_SYSWIDE_PASID
+2. IOMMU_NESTING_FEAT_BIND_PGTBL
+3. IOMMU_NESTING_FEAT_BIND_PASID_TABLE
+4. IOMMU_NESTING_FEAT_CACHE_INVLD
+5. IOMMU_NESTING_FEAT_PAGE_REQUEST
+
+Take VFIO as example, upon request from VFIO user space (e.g. QEMU),
+VFIO kernel code shall query IOMMU vendor driver for the support of
+the above features. Query result can then be reported back to the
+user-space caller. Details can be found in
+Documentation/driver-api/vfio.rst.
+
+
+Data Passing Example with VFIO
+------------------------------
+As the ubiquitous userspace driver framework, VFIO is already IOMMU
+aware and shares many key concepts such as device model, group, and
+protection domain. Other user driver frameworks can also be extended
+to support IOMMU UAPI but it is outside the scope of this document.
+
+In this tight-knit VFIO-IOMMU interface, the ultimate consumer of the
+IOMMU UAPI data is the host IOMMU driver. VFIO facilitates user-kernel
+transport, capability checking, security, and life cycle management of
+process address space ID (PASID).
+
+Unlike normal user data passed via VFIO UAPI IOTCL, IOMMU driver is the
+ultimate consumer of its UAPI data. At VFIO layer, the IOMMU UAPI data
+is wrapped in a VFIO UAPI data. It follows the
+pattern below::
+
+   struct {
+	__u32 argsz;
+	__u32 flags;
+	__u8  data[];
+   };
+
+Here data[] contains the IOMMU UAPI data structures. VFIO has the
+freedom to bundle the data as well as parse data size based on its own flags.
+
+In order to determine the size and feature set of the user data, argsz
+and flags are also embedded in the IOMMU UAPI data structures.
+A "__u32 argsz" field is *always* at the beginning of each structure.
+
+For example:
+::
+
+   struct iommu_cache_invalidate_info {
+	__u32	argsz;
+	#define IOMMU_CACHE_INVALIDATE_INFO_VERSION_1 1
+	__u32	version;
+	/* IOMMU paging structure cache */
+	#define IOMMU_CACHE_INV_TYPE_IOTLB	(1 << 0) /* IOMMU IOTLB */
+	#define IOMMU_CACHE_INV_TYPE_DEV_IOTLB	(1 << 1) /* Device IOTLB */
+	#define IOMMU_CACHE_INV_TYPE_PASID	(1 << 2) /* PASID cache */
+	#define IOMMU_CACHE_INV_TYPE_NR		(3)
+	__u8	cache;
+	__u8	granularity;
+	__u8	padding[6];
+	union {
+		struct iommu_inv_pasid_info pasid_info;
+		struct iommu_inv_addr_info addr_info;
+	} granu;
+   };
+
+VFIO is responsible for checking its own argsz and flags then invokes
+appropriate IOMMU UAPI functions. User pointer is passed to IOMMU
+layer for further processing. The responsibilities are divided as
+follows:
+
+- Generic IOMMU layer checks argsz range based on UAPI data in the
+  current kernel version
+
+- Generic IOMMU layer checks content of the UAPI data for non-zero
+  reserved bits in flags, padding fields, and unsupported version.
+  This is to ensure not breaking userspace in the future when these
+  fields or flags are used.
+
+- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data
+  is consumed based on flags. Vendor driver has access to
+  unadulterated argsz value in case of vendor specific future
+  extensions.
+
+To illustrate the two cases with and without vendor data, cache
+invalidation and bind guest PASID are given as examples respectively.
+
+Example 1: Guest issues IOTLB invalidation, all guest provided data
+are generic. Vendor driver does not need to check argsz.
+
+::
+
+ static int iommu_check_cache_invl_data(struct iommu_cache_invalidate_info *info)
+ {
+	u32 mask;
+
+	if (info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+		return -EINVAL;
+
+	mask = (1 << IOMMU_CACHE_INV_TYPE_NR) - 1;
+	if (info->cache & ~mask)
+		return -EINVAL;
+
+	if (info->granularity >= IOMMU_INV_GRANU_NR)
+		return -EINVAL;
+
+	switch (info->granularity) {
+	case IOMMU_INV_GRANU_ADDR:
+		mask = IOMMU_INV_ADDR_FLAGS_PASID |
+			IOMMU_INV_ADDR_FLAGS_ARCHID |
+			IOMMU_INV_ADDR_FLAGS_LEAF;
+
+		if (info->granu.addr_info.flags & ~mask)
+			return -EINVAL;
+		break;
+	case IOMMU_INV_GRANU_PASID:
+		mask = IOMMU_INV_PASID_FLAGS_PASID |
+			IOMMU_INV_PASID_FLAGS_ARCHID;
+		if (info->granu.pasid_info.flags & ~mask)
+			return -EINVAL;
+
+		break;
+	case IOMMU_INV_GRANU_DOMAIN:
+		/* No flags to check */
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (info->padding[0] || info->padding[1])
+		return -EINVAL;
+
+	return 0;
+ }
+
+ int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev,
+			   void __user *uinfo)
+ {
+	struct iommu_cache_invalidate_info inv_info = { 0 };
+	u32 minsz, maxsz;
+	int ret = 0;
+
+	if (unlikely(!domain->ops->cache_invalidate))
+		return -ENODEV;
+
+	/* Current kernel data size is the max to be copied from user */
+	maxsz = sizeof(struct iommu_cache_invalidate_info);
+
+	/*
+	 * No new spaces can be added before the variable sized union, the
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_cache_invalidate_info, granu);
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(&inv_info, uinfo, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (inv_info.argsz < minsz)
+		return -EINVAL;
+
+	/* PASID and address granu requires additional info beyond minsz */
+	if (inv_info.argsz == minsz &&
+		((inv_info.granularity == IOMMU_INV_GRANU_PASID) ||
+			(inv_info.granularity == IOMMU_INV_GRANU_ADDR)))
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header which has a larger data
+	 * size, we shall support the existing flags within the current
+	 * size. Copy the remaining user data _after_ minsz but not more
+	 * than the current kernel supported size.
+	 */
+	if (copy_from_user((void *)&inv_info + minsz, uinfo + minsz,
+				min(inv_info.argsz, maxsz) - minsz))
+		return -EFAULT;
+
+	/* Now the argsz is validated, check the content */
+	ret = iommu_check_cache_invl_data(&inv_info);
+	if (ret)
+		return ret;
+
+	return domain->ops->cache_invalidate(domain, dev, &inv_info);
+ }
+ EXPORT_SYMBOL_GPL(iommu_cache_invalidate);
+
+
+Example 2: Bind guest PASID which includes vendor specific data.
+The IOMMU core processing of UAPI data follows the same flow as
+Example 1. Vendor driver handles the additional vendor specific flags
+as in VT-d driver below:
+
+::
+
+ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev,
+			  struct iommu_gpasid_bind_data *data)
+ {
+	struct intel_iommu *iommu = intel_svm_device_to_iommu(dev);
+	struct dmar_domain *dmar_domain;
+	struct intel_svm_dev *sdev;
+	struct intel_svm *svm;
+	int ret = 0;
+
+	if (WARN_ON(!iommu) || !data)
+		return -EINVAL;
+
+	if (data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+		return -EINVAL;
+
+	/* IOMMU core ensures argsz is more than the start of the union */
+	if (data->argsz < offsetofend(struct iommu_gpasid_bind_data,
+            vendor.vtd))
+		return -EINVAL;
+   ...
+ }
+
+
+Sharing UAPI with in-kernel users
+---------------------------------
+For UAPIs that are shared with in-kernel users, a wrapper function is
+provided to distinguish the callers. For example,
+
+Userspace caller ::
+
+  int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,
+                                   struct device *dev,
+                                   void __user *udata)
+
+In-kernel caller ::
+
+  int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
+                                   struct device *dev,
+                                   struct iommu_gpasid_bind_data *data)
Signature · 6 lines
2.7.4

_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
author
#16 lore raw

PATCH v5 5/5 iommu/vt-d: Check UAPI data processed by IOMMU core

In reply to Jacob Pan

IOMMU generic layer already does sanity checks UAPI data for version match and argsz range under generic information.
Remove the redundant version check from VT-d driver and check for vendor specific data size.

---
 drivers/iommu/intel/iommu.c | 3 +--
 drivers/iommu/intel/svm.c   | 7 +++++--
 2 files changed, 6 insertions(+), 4 deletions(-)
drivers/iommu/intel/iommu.c +1 -2
index f3a6ca88cf95..5e80484f0537 100644
@@ -5383,8 +5383,7 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
 	int ret = 0;
 	u64 size = 0;
 
-	if (!inv_info || !dmar_domain ||
-	    inv_info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+	if (!inv_info || !dmar_domain)
 		return -EINVAL;
 
 	if (!dev || !dev_is_pci(dev))
drivers/iommu/intel/svm.c +5 -2
index 713b3a218483..55ea11e9c0f5 100644
@@ -240,8 +240,11 @@ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev,
 	if (WARN_ON(!iommu) || !data)
 		return -EINVAL;
 
-	if (data->version != IOMMU_GPASID_BIND_VERSION_1 ||
-	    data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+	if (data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+		return -EINVAL;
+
+	/* IOMMU core ensures argsz is more than the start of the union */
+	if (data->argsz < offsetofend(struct iommu_gpasid_bind_data, vendor.vtd))
 		return -EINVAL;
 
 	if (!dev_is_pci(dev))
Signature · 6 lines
2.7.4

_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
author
#9 lore raw

PATCH v5 3/5 iommu/uapi: Use named union for user data

In reply to Jacob Pan

IOMMU UAPI data size is filled by the user space which must be validated by ther kernel. To ensure backward compatibility, user data can only be extended by either re-purpose padding bytes or extend the variable sized union at the end. No size change is allowed before the union. Therefore, the minimum size is the offset of the union.

To use offsetof() on the union, we must make it named.

---
 drivers/iommu/intel/iommu.c | 24 ++++++++++++------------
 drivers/iommu/intel/svm.c   |  2 +-
 include/uapi/linux/iommu.h  |  4 ++--
 3 files changed, 15 insertions(+), 15 deletions(-)
drivers/iommu/intel/iommu.c +12 -12
index 6ad8b6f20235..f3a6ca88cf95 100644
@@ -5409,8 +5409,8 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
 
 	/* Size is only valid in address selective invalidation */
 	if (inv_info->granularity == IOMMU_INV_GRANU_ADDR)
-		size = to_vtd_size(inv_info->addr_info.granule_size,
-				   inv_info->addr_info.nb_granules);
+		size = to_vtd_size(inv_info->granu.addr_info.granule_size,
+				   inv_info->granu.addr_info.nb_granules);
 
 	for_each_set_bit(cache_type,
 			 (unsigned long *)&inv_info->cache,
@@ -5432,20 +5432,20 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
 		 * granularity.
 		 */
 		if (inv_info->granularity == IOMMU_INV_GRANU_PASID &&
-		    (inv_info->pasid_info.flags & IOMMU_INV_PASID_FLAGS_PASID))
-			pasid = inv_info->pasid_info.pasid;
+		    (inv_info->granu.pasid_info.flags & IOMMU_INV_PASID_FLAGS_PASID))
+			pasid = inv_info->granu.pasid_info.pasid;
 		else if (inv_info->granularity == IOMMU_INV_GRANU_ADDR &&
-			 (inv_info->addr_info.flags & IOMMU_INV_ADDR_FLAGS_PASID))
-			pasid = inv_info->addr_info.pasid;
+			 (inv_info->granu.addr_info.flags & IOMMU_INV_ADDR_FLAGS_PASID))
+			pasid = inv_info->granu.addr_info.pasid;
 
 		switch (BIT(cache_type)) {
 		case IOMMU_CACHE_INV_TYPE_IOTLB:
 			/* HW will ignore LSB bits based on address mask */
 			if (inv_info->granularity == IOMMU_INV_GRANU_ADDR &&
 			    size &&
-			    (inv_info->addr_info.addr & ((BIT(VTD_PAGE_SHIFT + size)) - 1))) {
+			    (inv_info->granu.addr_info.addr & ((BIT(VTD_PAGE_SHIFT + size)) - 1))) {
 				WARN_ONCE(1, "Address out of range, 0x%llx, size order %llu\n",
-					  inv_info->addr_info.addr, size);
+					  inv_info->granu.addr_info.addr, size);
 			}
 
 			/*
@@ -5453,9 +5453,9 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
 			 * We use npages = -1 to indicate that.
 			 */
 			qi_flush_piotlb(iommu, did, pasid,
-					mm_to_dma_pfn(inv_info->addr_info.addr),
+					mm_to_dma_pfn(inv_info->granu.addr_info.addr),
 					(granu == QI_GRAN_NONG_PASID) ? -1 : 1 << size,
-					inv_info->addr_info.flags & IOMMU_INV_ADDR_FLAGS_LEAF);
+					inv_info->granu.addr_info.flags & IOMMU_INV_ADDR_FLAGS_LEAF);
 
 			if (!info->ats_enabled)
 				break;
@@ -5476,13 +5476,13 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
 				size = 64 - VTD_PAGE_SHIFT;
 				addr = 0;
 			} else if (inv_info->granularity == IOMMU_INV_GRANU_ADDR)
-				addr = inv_info->addr_info.addr;
+				addr = inv_info->granu.addr_info.addr;
 
 			if (info->ats_enabled)
 				qi_flush_dev_iotlb_pasid(iommu, sid,
 						info->pfsid, pasid,
 						info->ats_qdep,
-						inv_info->addr_info.addr,
+						inv_info->granu.addr_info.addr,
 						size);
 			else
 				pr_warn_ratelimited("Passdown device IOTLB flush w/o ATS!\n");
drivers/iommu/intel/svm.c +1 -1
index d386853121a2..713b3a218483 100644
@@ -338,7 +338,7 @@ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev,
 	spin_lock(&iommu->lock);
 	ret = intel_pasid_setup_nested(iommu, dev,
 				       (pgd_t *)(uintptr_t)data->gpgd,
-				       data->hpasid, &data->vtd, dmar_domain,
+				       data->hpasid, &data->vendor.vtd, dmar_domain,
 				       data->addr_width);
 	spin_unlock(&iommu->lock);
 	if (ret) {
include/uapi/linux/iommu.h +2 -2
index d5e9014f690e..7c8e075c2b29 100644
@@ -263,7 +263,7 @@ struct iommu_cache_invalidate_info {
 	union {
 		struct iommu_inv_pasid_info pasid_info;
 		struct iommu_inv_addr_info addr_info;
-	};
+	} granu;
 };
 
 /**
@@ -329,7 +329,7 @@ struct iommu_gpasid_bind_data {
 	/* Vendor specific data */
 	union {
 		struct iommu_gpasid_bind_data_vtd vtd;
-	};
+	} vendor;
 };
 
 #endif /* _UAPI_IOMMU_H */
Signature · 6 lines
2.7.4

_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
author
#11 lore raw

PATCH v5 4/5 iommu/uapi: Handle data and argsz filled by users

In reply to Jacob Pan

IOMMU UAPI data has a user filled argsz field which indicates the data length comes with the API call. User data is not trusted, argsz must be validated based on the current kernel data size, mandatory data size, and feature flags.

User data may also be extended, results in possible argsz increase. Backward compatibility is ensured based on size and flags checking.

This patch adds sanity checks in the IOMMU layer. In addition to argsz, reserved/unused fields in padding, flags, and version are also checked. Details are documented in Documentation/userspace-api/iommu.rst

---
 drivers/iommu/iommu.c | 192 ++++++++++++++++++++++++++++++++++++++++++++++++--
 include/linux/iommu.h |  20 ++++--
 2 files changed, 200 insertions(+), 12 deletions(-)
drivers/iommu/iommu.c +185 -7
index d43120eb1dc5..fe30a940d19e 100644
@@ -1950,36 +1950,214 @@ int iommu_attach_device(struct iommu_domain *domain, struct device *dev)
 }
 EXPORT_SYMBOL_GPL(iommu_attach_device);
 
+/*
+ * Check flags and other user privided data for valid combinations. We also
+ * make sure no reserved fields or unused flags are not set. This is to ensure
+ * not breaking userspace in the future when these fields or flags are used.
+ */
+static int iommu_check_cache_invl_data(struct iommu_cache_invalidate_info *info)
+{
+	u32 mask;
+
+	if (info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+		return -EINVAL;
+
+	mask = (1 << IOMMU_CACHE_INV_TYPE_NR) - 1;
+	if (info->cache & ~mask)
+		return -EINVAL;
+
+	if (info->granularity >= IOMMU_INV_GRANU_NR)
+		return -EINVAL;
+
+	switch (info->granularity) {
+	case IOMMU_INV_GRANU_ADDR:
+		mask = IOMMU_INV_ADDR_FLAGS_PASID |
+			IOMMU_INV_ADDR_FLAGS_ARCHID |
+			IOMMU_INV_ADDR_FLAGS_LEAF;
+
+		if (info->granu.addr_info.flags & ~mask)
+			return -EINVAL;
+		break;
+	case IOMMU_INV_GRANU_PASID:
+		mask = IOMMU_INV_PASID_FLAGS_PASID |
+			IOMMU_INV_PASID_FLAGS_ARCHID;
+		if (info->granu.pasid_info.flags & ~mask)
+			return -EINVAL;
+
+		break;
+	case IOMMU_INV_GRANU_DOMAIN:
+		/* No flags to check */
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (info->padding[0] || info->padding[1])
+		return -EINVAL;
+
+	return 0;
+}
+
 int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev,
-			   struct iommu_cache_invalidate_info *inv_info)
+			   void __user *uinfo)
 {
+	struct iommu_cache_invalidate_info inv_info = { 0 };
+	u32 minsz, maxsz;
+	int ret = 0;
+
 	if (unlikely(!domain->ops->cache_invalidate))
 		return -ENODEV;
 
-	return domain->ops->cache_invalidate(domain, dev, inv_info);
+	/* Current kernel data size is the max to be copied from user */
+	maxsz = sizeof(struct iommu_cache_invalidate_info);
+
+	/*
+	 * No new spaces can be added before the variable sized union, the
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_cache_invalidate_info, granu);
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(&inv_info, uinfo, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (inv_info.argsz < minsz)
+		return -EINVAL;
+
+	/* PASID and address granu requires additional info beyond minsz */
+	if (inv_info.argsz == minsz &&
+		((inv_info.granularity == IOMMU_INV_GRANU_PASID) ||
+			(inv_info.granularity == IOMMU_INV_GRANU_ADDR)))
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header which has a larger data
+	 * size, we shall support the existing flags within the current
+	 * size. Copy the remaining user data _after_ minsz but not more
+	 * than the current kernel supported size.
+	 */
+	if (copy_from_user((void *)&inv_info + minsz, uinfo + minsz,
+				min(inv_info.argsz, maxsz) - minsz))
+		return -EFAULT;
+
+	/* Now the argsz is validated, check the content */
+	ret = iommu_check_cache_invl_data(&inv_info);
+	if (ret)
+		return ret;
+
+	return domain->ops->cache_invalidate(domain, dev, &inv_info);
 }
 EXPORT_SYMBOL_GPL(iommu_cache_invalidate);
 
-int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-			   struct device *dev, struct iommu_gpasid_bind_data *data)
+
+static int iommu_check_bind_data(struct iommu_gpasid_bind_data *data)
 {
+	u32 mask;
+	int i;
+
+	if (data->version != IOMMU_GPASID_BIND_VERSION_1)
+		return -EINVAL;
+
+	/* Check all supported format, for now just VT-d */
+	mask = IOMMU_PASID_FORMAT_INTEL_VTD;
+	if (data->format & ~mask)
+		return -EINVAL;
+
+	/* Check all flags */
+	mask = IOMMU_SVA_GPASID_VAL;
+	if (data->flags & ~mask)
+		return -EINVAL;
+
+	/* Check reserved padding fields */
+	for (i = 0; i < 12; i++) {
+		if (data->padding[i])
+			return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int iommu_sva_prepare_bind_data(void __user *udata,
+				       struct iommu_gpasid_bind_data *data)
+{
+	u32 minsz, maxsz;
+
+	/* Current kernel data size is the max to be copied from user */
+	maxsz = sizeof(struct iommu_gpasid_bind_data);
+	memset((void *)data, 0, maxsz);
+
+	/*
+	 * No new spaces can be added before the variable sized union, the
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_gpasid_bind_data, vendor);
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(data, udata, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (data->argsz < minsz)
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header, we shall let IOMMU vendor
+	 * driver decide on what size it needs. Since the guest PASID bind data
+	 * can be vendor specific, larger argsz could be the result of extension
+	 * for one vendor but it should not affect another vendor.
+	 * Copy the remaining user data _after_ minsz
+	 */
+	if (copy_from_user((void *)data + minsz, udata + minsz,
+				min(data->argsz, maxsz) - minsz))
+		return -EFAULT;
+
+	return iommu_check_bind_data(data);
+}
+
+int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct device *dev,
+						void __user *udata)
+{
+
+	struct iommu_gpasid_bind_data data;
+	int ret;
+
 	if (unlikely(!domain->ops->sva_bind_gpasid))
 		return -ENODEV;
 
-	return domain->ops->sva_bind_gpasid(domain, dev, data);
+	ret = iommu_sva_prepare_bind_data(udata, &data);
+	if (ret)
+		return ret;
+
+	return domain->ops->sva_bind_gpasid(domain, dev, &data);
 }
 EXPORT_SYMBOL_GPL(iommu_sva_bind_gpasid);
 
 int iommu_sva_unbind_gpasid(struct iommu_domain *domain, struct device *dev,
-			     ioasid_t pasid)
+			struct iommu_gpasid_bind_data *data)
 {
 	if (unlikely(!domain->ops->sva_unbind_gpasid))
 		return -ENODEV;
 
-	return domain->ops->sva_unbind_gpasid(dev, pasid);
+	return domain->ops->sva_unbind_gpasid(dev, data->hpasid);
 }
 EXPORT_SYMBOL_GPL(iommu_sva_unbind_gpasid);
 
+int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain, struct device *dev,
+			void __user *udata)
+{
+	struct iommu_gpasid_bind_data data;
+	int ret;
+
+	if (unlikely(!domain->ops->sva_bind_gpasid))
+		return -ENODEV;
+
+	ret = iommu_sva_prepare_bind_data(udata, &data);
+	if (ret)
+		return ret;
+
+	return iommu_sva_unbind_gpasid(domain, dev, &data);
+}
+EXPORT_SYMBOL_GPL(iommu_uapi_sva_unbind_gpasid);
+
 static void __iommu_detach_device(struct iommu_domain *domain,
 				  struct device *dev)
 {
include/linux/iommu.h +15 -5
index 5f0b7859d2eb..439f34a7b5b2 100644
@@ -432,11 +432,14 @@ extern void iommu_detach_device(struct iommu_domain *domain,
 				struct device *dev);
 extern int iommu_cache_invalidate(struct iommu_domain *domain,
 				  struct device *dev,
-				  struct iommu_cache_invalidate_info *inv_info);
+				  void __user *uinfo);
+
 extern int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-		struct device *dev, struct iommu_gpasid_bind_data *data);
+				struct device *dev, void __user *udata);
+extern int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,
+				        struct device *dev, void __user *udata);
 extern int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
-				struct device *dev, ioasid_t pasid);
+				   struct device *dev, struct iommu_gpasid_bind_data *data);
 extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
 extern struct iommu_domain *iommu_get_dma_domain(struct device *dev);
 extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
@@ -1062,13 +1065,20 @@ iommu_cache_invalidate(struct iommu_domain *domain,
 	return -ENODEV;
 }
 static inline int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-				struct device *dev, struct iommu_gpasid_bind_data *data)
+				struct device *dev, void __user *udata)
 {
 	return -ENODEV;
 }
 
 static inline int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
-					   struct device *dev, int pasid)
+					   struct device *dev, void __user *udata)
+{
+	return -ENODEV;
+}
+
+static inline int __iommu_sva_unbind_gpasid(struct iommu_domain *domain,
+					struct device *dev,
+					struct iommu_gpasid_bind_data *data)
 {
 	return -ENODEV;
 }
Signature · 1 line
2.7.4
maintainer Reviewed-by on v5 5/5
#17 lore raw

Re: [PATCH v5 5/5] iommu/vt-d: Check UAPI data processed by IOMMU core

In reply to Jacob Pan
Quoted 6 lines · Jacob Pan

IOMMU generic layer already does sanity checks UAPI data for version match and argsz range under generic information.
Remove the redundant version check from VT-d driver and check for vendor specific data size.

Best regards,
baolu

Quoted 38 lines
---
  drivers/iommu/intel/iommu.c | 3 +--
  drivers/iommu/intel/svm.c   | 7 +++++--
  2 files changed, 6 insertions(+), 4 deletions(-)
drivers/iommu/intel/iommu.c +1 -2
index f3a6ca88cf95..5e80484f0537 100644
@@ -5383,8 +5383,7 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
  	int ret = 0;
  	u64 size = 0;
 
-	if (!inv_info || !dmar_domain ||
-	    inv_info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+	if (!inv_info || !dmar_domain)
  		return -EINVAL;
 
  	if (!dev || !dev_is_pci(dev))
drivers/iommu/intel/svm.c +5 -2
index 713b3a218483..55ea11e9c0f5 100644
@@ -240,8 +240,11 @@ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev,
  	if (WARN_ON(!iommu) || !data)
  		return -EINVAL;
 
-	if (data->version != IOMMU_GPASID_BIND_VERSION_1 ||
-	    data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+	if (data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+		return -EINVAL;
+
+	/* IOMMU core ensures argsz is more than the start of the union */
+	if (data->argsz < offsetofend(struct iommu_gpasid_bind_data, vendor.vtd))
  		return -EINVAL;
 
  	if (!dev_is_pci(dev))
#2 lore raw

Re: [PATCH v5 1/5] docs: IOMMU user API

In reply to Jacob Pan

Hi Jacob,

Quoted 5 lines · Jacob Pan

IOMMU UAPI is newly introduced to support communications between guest virtual IOMMU and host IOMMU. There has been lots of discussions on how it should work with VFIO UAPI and userspace in general.

This document is indended to clarify the UAPI design and usage. The

intended

Quoted 16 lines

mechanics of how future extensions should be achieved are also covered in this documentation.

---
 Documentation/userspace-api/iommu.rst | 339 ++++++++++++++++++++++++++++++++++
 1 file changed, 339 insertions(+)
 create mode 100644 Documentation/userspace-api/iommu.rst
Documentation/userspace-api/iommu.rst new file +0 -0
new file mode 100644
index 000000000000..efc3e1838235

Documentation/userspace-api/iommu.rst line 9

Quoted 9 lines
Documentation/userspace-api/iommu.rst new file +9 -0
@@ -0,0 +1,339 @@
+.. SPDX-License-Identifier: GPL-2.0
+.. iommu:
+
+=====================================
+IOMMU Userspace API
+=====================================
+
+IOMMU UAPI is used for virtualization cases where communications are
+needed between physical and virtual IOMMU drivers. For native

s/native/baremetal?

Documentation/userspace-api/iommu.rst line 10

Quoted 1 line
Documentation/userspace-api/iommu.rst new file +1 -0
+usage, IOMMU is a system device which does not need to communicate

the IOMMU?

Documentation/userspace-api/iommu.rst line 15

Quoted 5 lines
Documentation/userspace-api/iommu.rst new file +5 -0
+with user space directly.
+
+The primary use cases are guest Shared Virtual Address (SVA) and
+guest IO virtual address (IOVA), wherein a virtual IOMMU (vIOMMU) is
+required to communicate with the physical IOMMU in the host.

wherin the vIOMMU implementation relies on the physical IOMMU and for this reason requires interactions with the host driver.

Documentation/userspace-api/iommu.rst line 26

Quoted 11 lines
Documentation/userspace-api/iommu.rst new file +11 -0
+
+.. contents:: :local:
+
+Functionalities
+===============
+Communications of user and kernel involve both directions. The
+supported user-kernel APIs are as follows:
+
+1. Alloc/Free PASID
+2. Bind/unbind guest PASID (e.g. Intel VT-d)
+3. Bind/unbind guest PASID table (e.g. ARM sMMU)

s/sMMU/SMMU

Documentation/userspace-api/iommu.rst line 28

Quoted 2 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+4. Invalidate IOMMU caches
+5. Service IO page faults (page request and response)

Report errors to the guest and serve page requests?

Documentation/userspace-api/iommu.rst line 36

Quoted 8 lines
Documentation/userspace-api/iommu.rst new file +8 -0
+
+Requirements
+============
+The IOMMU UAPIs are generic and extensible to meet the following
+requirements:
+
+1. Emulated and para-virtualised vIOMMUs
+2. Multiple vendors (Intel VT-d, ARM sMMU, etc.)

SMMU

Quoted 5 lines
Documentation/userspace-api/iommu.rst new file +5 -0
+3. Extensions to the UAPI shall not break existing user space
+
+Interfaces
+==========
+Although the data structures defined in IOMMU UAPI are self-contained,

Documentation/userspace-api/iommu.rst line 51

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+there is no user API functions introduced. Instead, IOMMU UAPI is
+designed to work with existing user driver frameworks such as VFIO.
+
+Extension Rules & Precautions
+-----------------------------
+When IOMMU UAPI gets extended, the data structures can *only* be
+modified in two ways:
+
+1. Adding new fields by re-purposing the padding[] field. No size change.
+2. Adding new union members at the end. May increase in size.

May increase the structure sizes

Documentation/userspace-api/iommu.rst line 55

Quoted 4 lines
Documentation/userspace-api/iommu.rst new file +4 -0
+
+No new fields can be added *after* the variable sized union in that it
+will break backward compatibility when offset moves. In both cases, a
+new flag must be accompanied with a new field such that the IOMMU

a new flag must be introduced whenever a change affects the structure using either method?

Documentation/userspace-api/iommu.rst line 63

Quoted 8 lines
Documentation/userspace-api/iommu.rst new file +8 -0
+driver can process the data based on the new flag. Version field is
+only reserved for the unlikely event of UAPI upgrade at its entirety.
+
+It's *always* the caller's responsibility to indicate the size of the
+structure passed by setting argsz appropriately.
+Though at the same time, argsz is user provided data which is not
+trusted. The argsz field allows the user to indicate how much data
+they're providing, it's still the kernel's responsibility to validate

he is providing

Documentation/userspace-api/iommu.rst line 68

Quoted 5 lines
Documentation/userspace-api/iommu.rst new file +5 -0
+whether it's correct and sufficient for the requested operation.
+
+Compatibility Checking
+----------------------
+When IOMMU UAPI extension results in size increase, IOMMU UAPI core

in some structure size increase, the IOMMU UAPI code

Quoted 4 lines
Documentation/userspace-api/iommu.rst new file +4 -0
+and vendor driver shall handle the following cases:
+
+1. User and kernel has exact size match
+2. An older user with older kernel header (smaller UAPI size) running on a

Documentation/userspace-api/iommu.rst line 83

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+   newer kernel (larger UAPI size)
+3. A newer user with newer kernel header (larger UAPI size) running
+   on an older kernel.
+4. A malicious/misbehaving user pass illegal/invalid size but within
+   range. The data may contain garbage.> +
+Feature Checking
+----------------
+While launching a guest with vIOMMU, it is important to ensure that host
+can support the UAPI data structures to be used for vIOMMU-pIOMMU
+communications. Without upfront compatibility checking, future faults

s/faults/failures?

Documentation/userspace-api/iommu.rst line 87

Quoted 4 lines
Documentation/userspace-api/iommu.rst new file +4 -0
+are difficult to report even in normal conditions. For example, TLB
+invalidations should always succeed. There is no architectural way to
+report back to the vIOMMU if the UAPI data is incompatible. If that
+happens, in order to protect IOMMU iosolation guarantee, we have to

in order to guarantee IOMMU isOlation

Documentation/userspace-api/iommu.rst line 89

Quoted 2 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+resort to not giving completion status in vIOMMU. This may result in
+VM hang.

Why not simply saying a capability getter is offered to discover the feature support and potential API incompatibility support at an early stage. Detecting this later, when performing the actual cache/descriptor handling operations appears to be tricky and difficult to escalate to the guest.

Documentation/userspace-api/iommu.rst line 96

Quoted 7 lines
Documentation/userspace-api/iommu.rst new file +7 -0
+
+For this reason the following IOMMU UAPIs cannot fail:
+
+1. Free PASID
+2. Unbind guest PASID
+3. Unbind guest PASID table (SMMU)
+4. Cache invalidate

hum practically iommu_uapi_sva_unbind_gpasid return an int though (see below). So it sounds a bit misleading. What cannot fail?

Quoted 29 lines
Documentation/userspace-api/iommu.rst new file +29 -0
+
+User applications such as QEMU are expected to import kernel UAPI
+headers. Backward compatibility is supported per feature flags.
+For example, an older QEMU (with older kernel header) can run on newer
+kernel. Newer QEMU (with new kernel header) may refuse to initialize
+on an older kernel if new feature flags are not supported by older
+kernel. Simply recompiling existing code with newer kernel header should
+not be an issue in that only existing flags are used.
+
+IOMMU vendor driver should report the below features to IOMMU UAPI
+consumers (e.g. via VFIO).
+
+1. IOMMU_NESTING_FEAT_SYSWIDE_PASID
+2. IOMMU_NESTING_FEAT_BIND_PGTBL
+3. IOMMU_NESTING_FEAT_BIND_PASID_TABLE
+4. IOMMU_NESTING_FEAT_CACHE_INVLD
+5. IOMMU_NESTING_FEAT_PAGE_REQUEST
+
+Take VFIO as example, upon request from VFIO user space (e.g. QEMU),
+VFIO kernel code shall query IOMMU vendor driver for the support of
+the above features. Query result can then be reported back to the
+user-space caller. Details can be found in
+Documentation/driver-api/vfio.rst.
+
+
+Data Passing Example with VFIO
+------------------------------
+As the ubiquitous userspace driver framework, VFIO is already IOMMU
+aware and shares many key concepts such as device model, group, and

Documentation/userspace-api/iommu.rst

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+protection domain. Other user driver frameworks can also be extended
+to support IOMMU UAPI but it is outside the scope of this document.
+
+In this tight-knit VFIO-IOMMU interface, the ultimate consumer of the
+IOMMU UAPI data is the host IOMMU driver. VFIO facilitates user-kernel
+transport, capability checking, security, and life cycle management of
+process address space ID (PASID).
+
+Unlike normal user data passed via VFIO UAPI IOTCL, IOMMU driver is the
+ultimate consumer of its UAPI data.

I don't really get this. Part of the VFIO API already mediates info towards the IOMMU driver, no?

At VFIO layer, the IOMMU UAPI data

Quoted 13 lines
Documentation/userspace-api/iommu.rst new file +13 -0
+is wrapped in a VFIO UAPI data. It follows the
+pattern below::
+
+   struct {
+	__u32 argsz;
+	__u32 flags;
+	__u8  data[];
+   };
+
+Here data[] contains the IOMMU UAPI data structures. VFIO has the
+freedom to bundle the data as well as parse data size based on its own flags.
+
+In order to determine the size and feature set of the user data, argsz

Documentation/userspace-api/iommu.rst line 158

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+and flags are also embedded in the IOMMU UAPI data structures.
+A "__u32 argsz" field is *always* at the beginning of each structure.
+
+For example:
+::
+
+   struct iommu_cache_invalidate_info {
+	__u32	argsz;
+	#define IOMMU_CACHE_INVALIDATE_INFO_VERSION_1 1
+	__u32	version;

there is no flags field in this struct, as opposed to what I can understand from "argsz and flags are also embedded in the IOMMU UAPI data structures"

Quoted 5 lines
Documentation/userspace-api/iommu.rst new file +5 -0
+	/* IOMMU paging structure cache */
+	#define IOMMU_CACHE_INV_TYPE_IOTLB	(1 << 0) /* IOMMU IOTLB */
+	#define IOMMU_CACHE_INV_TYPE_DEV_IOTLB	(1 << 1) /* Device IOTLB */
+	#define IOMMU_CACHE_INV_TYPE_PASID	(1 << 2) /* PASID cache */
+	#define IOMMU_CACHE_INV_TYPE_NR		(3)

Documentation/userspace-api/iommu.rst line 173

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+	__u8	cache;
+	__u8	granularity;
+	__u8	padding[6];
+	union {
+		struct iommu_inv_pasid_info pasid_info;
+		struct iommu_inv_addr_info addr_info;
+	} granu;
+   };
+
+VFIO is responsible for checking its own argsz and flags then invokes

s/flags then invokes/flags. It then invokes

Documentation/userspace-api/iommu.rst line 174

Quoted 1 line
Documentation/userspace-api/iommu.rst new file +1 -0
+appropriate IOMMU UAPI functions. User pointer is passed to IOMMU

the appropriate... I would say *The* user pointer is passed to *the* IOMMU, here and at many places in the doc. But I would prefer a native english speaker confirms.

Quoted 8 lines
Documentation/userspace-api/iommu.rst new file +8 -0
+layer for further processing. The responsibilities are divided as
+follows:
+
+- Generic IOMMU layer checks argsz range based on UAPI data in the
+  current kernel version
+
+- Generic IOMMU layer checks content of the UAPI data for non-zero
+  reserved bits in flags, padding fields, and unsupported version.

Documentation/userspace-api/iommu.rst line 192

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+  This is to ensure not breaking userspace in the future when these
+  fields or flags are used.
+
+- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data
+  is consumed based on flags. Vendor driver has access to
+  unadulterated argsz value in case of vendor specific future
+  extensions.
+
+To illustrate the two cases with and without vendor data, cache
+invalidation and bind guest PASID are given as examples respectively.

I am not sure duplicating the code here is necessary. I think when the code gets upstream, it becomes the example to follow. The above description can help in understanding why such checks are there and I would stop here, personally.

Quoted 147 lines
Documentation/userspace-api/iommu.rst new file +147 -0
+
+Example 1: Guest issues IOTLB invalidation, all guest provided data
+are generic. Vendor driver does not need to check argsz.
+
+::
+
+ static int iommu_check_cache_invl_data(struct iommu_cache_invalidate_info *info)
+ {
+	u32 mask;
+
+	if (info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+		return -EINVAL;
+
+	mask = (1 << IOMMU_CACHE_INV_TYPE_NR) - 1;
+	if (info->cache & ~mask)
+		return -EINVAL;
+
+	if (info->granularity >= IOMMU_INV_GRANU_NR)
+		return -EINVAL;
+
+	switch (info->granularity) {
+	case IOMMU_INV_GRANU_ADDR:
+		mask = IOMMU_INV_ADDR_FLAGS_PASID |
+			IOMMU_INV_ADDR_FLAGS_ARCHID |
+			IOMMU_INV_ADDR_FLAGS_LEAF;
+
+		if (info->granu.addr_info.flags & ~mask)
+			return -EINVAL;
+		break;
+	case IOMMU_INV_GRANU_PASID:
+		mask = IOMMU_INV_PASID_FLAGS_PASID |
+			IOMMU_INV_PASID_FLAGS_ARCHID;
+		if (info->granu.pasid_info.flags & ~mask)
+			return -EINVAL;
+
+		break;
+	case IOMMU_INV_GRANU_DOMAIN:
+		/* No flags to check */
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (info->padding[0] || info->padding[1])
+		return -EINVAL;
+
+	return 0;
+ }
+
+ int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev,
+			   void __user *uinfo)
+ {
+	struct iommu_cache_invalidate_info inv_info = { 0 };
+	u32 minsz, maxsz;
+	int ret = 0;
+
+	if (unlikely(!domain->ops->cache_invalidate))
+		return -ENODEV;
+
+	/* Current kernel data size is the max to be copied from user */
+	maxsz = sizeof(struct iommu_cache_invalidate_info);
+
+	/*
+	 * No new spaces can be added before the variable sized union, the
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_cache_invalidate_info, granu);
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(&inv_info, uinfo, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (inv_info.argsz < minsz)
+		return -EINVAL;
+
+	/* PASID and address granu requires additional info beyond minsz */
+	if (inv_info.argsz == minsz &&
+		((inv_info.granularity == IOMMU_INV_GRANU_PASID) ||
+			(inv_info.granularity == IOMMU_INV_GRANU_ADDR)))
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header which has a larger data
+	 * size, we shall support the existing flags within the current
+	 * size. Copy the remaining user data _after_ minsz but not more
+	 * than the current kernel supported size.
+	 */
+	if (copy_from_user((void *)&inv_info + minsz, uinfo + minsz,
+				min(inv_info.argsz, maxsz) - minsz))
+		return -EFAULT;
+
+	/* Now the argsz is validated, check the content */
+	ret = iommu_check_cache_invl_data(&inv_info);
+	if (ret)
+		return ret;
+
+	return domain->ops->cache_invalidate(domain, dev, &inv_info);
+ }
+ EXPORT_SYMBOL_GPL(iommu_cache_invalidate);
+
+
+Example 2: Bind guest PASID which includes vendor specific data.
+The IOMMU core processing of UAPI data follows the same flow as
+Example 1. Vendor driver handles the additional vendor specific flags
+as in VT-d driver below:
+
+::
+
+ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev,
+			  struct iommu_gpasid_bind_data *data)
+ {
+	struct intel_iommu *iommu = intel_svm_device_to_iommu(dev);
+	struct dmar_domain *dmar_domain;
+	struct intel_svm_dev *sdev;
+	struct intel_svm *svm;
+	int ret = 0;
+
+	if (WARN_ON(!iommu) || !data)
+		return -EINVAL;
+
+	if (data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+		return -EINVAL;
+
+	/* IOMMU core ensures argsz is more than the start of the union */
+	if (data->argsz < offsetofend(struct iommu_gpasid_bind_data,
+            vendor.vtd))
+		return -EINVAL;
+   ...
+ }
+
+
+Sharing UAPI with in-kernel users
+---------------------------------
+For UAPIs that are shared with in-kernel users, a wrapper function is
+provided to distinguish the callers. For example,
+
+Userspace caller ::
+
+  int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,
+                                   struct device *dev,
+                                   void __user *udata)
+
+In-kernel caller ::
+
+  int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
+                                   struct device *dev,
+                                   struct iommu_gpasid_bind_data *data)
Quoted 1 line

Hope this helps. If some of my comments drive you in an opposite

direction of what was said earlier, please feel free to ignore them ;-)

Thanks

Eric

#7 lore raw

Re: [PATCH v5 2/5] iommu/uapi: Add argsz for user filled data

In reply to Jacob Pan

Hi Jacob,

Quoted 27 lines · Jacob Pan

As IOMMU UAPI gets extended, user data size may increase. To support backward compatibiliy, this patch introduces a size field to each UAPI data structures. It is *always* the responsibility for the user to fill in the correct size. Padding fields are adjusted to ensure 8 byte alignment.

Specific scenarios for user data handling are documented in:
Documentation/userspace-api/iommu.rst

---
 include/uapi/linux/iommu.h | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)
include/uapi/linux/iommu.h +1 -0
index e907b7091a46..d5e9014f690e 100644
@@ -135,6 +135,7 @@ enum iommu_page_response_code {
 
 /**
  * struct iommu_page_response - Generic page response information
+ * @argsz: User filled size of this data
  * @version: API version of this structure
  * @flags: encodes whether the corresponding fields are valid
  *         (IOMMU_FAULT_PAGE_RESPONSE_* values)

include/uapi/linux/iommu.h enum iommu_page_response_code { · line 148

Quoted 5 lines
include/uapi/linux/iommu.h +1 -0
@@ -143,6 +144,7 @@ enum iommu_page_response_code {
  * @code: response code from &enum iommu_page_response_code
  */
 struct iommu_page_response {
+	__u32	argsz;
 #define IOMMU_PAGE_RESP_VERSION_1	1

Don't you need to incr the version for all the modified structs?

Quoted 11 lines
include/uapi/linux/iommu.h +1 -0
 	__u32	version;
 #define IOMMU_PAGE_RESP_PASID_VALID	(1 << 0)
@@ -218,6 +220,7 @@ struct iommu_inv_pasid_info {
 /**
  * struct iommu_cache_invalidate_info - First level/stage invalidation
  *     information
+ * @argsz: User filled size of this data
  * @version: API version of this structure
  * @cache: bitfield that allows to select which caches to invalidate
  * @granularity: defines the lowest granularity used for the invalidation:

include/uapi/linux/iommu.h struct iommu_inv_pasid_info { · line 254

Quoted 6 lines
include/uapi/linux/iommu.h +1 -0
@@ -246,6 +249,7 @@ struct iommu_inv_pasid_info {
  * must support the used granularity.
  */
 struct iommu_cache_invalidate_info {
+	__u32	argsz;
 #define IOMMU_CACHE_INVALIDATE_INFO_VERSION_1 1
 	__u32	version;

so there is no "flags" field in this struct. Is it OK?

Quoted 30 lines
include/uapi/linux/iommu.h +4 -1
 /* IOMMU paging structure cache */
@@ -255,7 +259,7 @@ struct iommu_cache_invalidate_info {
 #define IOMMU_CACHE_INV_TYPE_NR		(3)
 	__u8	cache;
 	__u8	granularity;
-	__u8	padding[2];
+	__u8	padding[6];
 	union {
 		struct iommu_inv_pasid_info pasid_info;
 		struct iommu_inv_addr_info addr_info;
@@ -292,6 +296,7 @@ struct iommu_gpasid_bind_data_vtd {
 
 /**
  * struct iommu_gpasid_bind_data - Information about device and guest PASID binding
+ * @argsz:	User filled size of this data
  * @version:	Version of this data structure
  * @format:	PASID table entry format
  * @flags:	Additional information on guest bind request
@@ -309,17 +314,18 @@ struct iommu_gpasid_bind_data_vtd {
  * PASID to host PASID based on this bind data.
  */
 struct iommu_gpasid_bind_data {
+	__u32 argsz;
 #define IOMMU_GPASID_BIND_VERSION_1	1
 	__u32 version;
 #define IOMMU_PASID_FORMAT_INTEL_VTD	1
 	__u32 format;
+	__u32 addr_width;
 #define IOMMU_SVA_GPASID_VAL	(1 << 0) /* guest PASID valid */

include/uapi/linux/iommu.h struct iommu_gpasid_bind_data_vtd { · line 331

Quoted 10 lines
include/uapi/linux/iommu.h +1 -2
 	__u64 flags;
 	__u64 gpgd;
 	__u64 hpasid;
 	__u64 gpasid;
-	__u32 addr_width;
-	__u8  padding[12];
+	__u8  padding[8];
 	/* Vendor specific data */
 	union {
 		struct iommu_gpasid_bind_data_vtd vtd;

Thanks

Eric

Reviewed-by on v5 3/5
#10 lore raw

Re: [PATCH v5 3/5] iommu/uapi: Use named union for user data

In reply to Jacob Pan

Hi Jacob,

Quoted 2 lines · Jacob Pan

IOMMU UAPI data size is filled by the user space which must be validated by ther kernel. To ensure backward compatibility, user data can only be

s/ther/the

Quoted 9 lines

extended by either re-purpose padding bytes or extend the variable sized union at the end. No size change is allowed before the union. Therefore, the minimum size is the offset of the union.

To use offsetof() on the union, we must make it named.

Thanks

Eric

Quoted 112 lines
---
 drivers/iommu/intel/iommu.c | 24 ++++++++++++------------
 drivers/iommu/intel/svm.c   |  2 +-
 include/uapi/linux/iommu.h  |  4 ++--
 3 files changed, 15 insertions(+), 15 deletions(-)
drivers/iommu/intel/iommu.c +12 -12
index 6ad8b6f20235..f3a6ca88cf95 100644
@@ -5409,8 +5409,8 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
 
 	/* Size is only valid in address selective invalidation */
 	if (inv_info->granularity == IOMMU_INV_GRANU_ADDR)
-		size = to_vtd_size(inv_info->addr_info.granule_size,
-				   inv_info->addr_info.nb_granules);
+		size = to_vtd_size(inv_info->granu.addr_info.granule_size,
+				   inv_info->granu.addr_info.nb_granules);
 
 	for_each_set_bit(cache_type,
 			 (unsigned long *)&inv_info->cache,
@@ -5432,20 +5432,20 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
 		 * granularity.
 		 */
 		if (inv_info->granularity == IOMMU_INV_GRANU_PASID &&
-		    (inv_info->pasid_info.flags & IOMMU_INV_PASID_FLAGS_PASID))
-			pasid = inv_info->pasid_info.pasid;
+		    (inv_info->granu.pasid_info.flags & IOMMU_INV_PASID_FLAGS_PASID))
+			pasid = inv_info->granu.pasid_info.pasid;
 		else if (inv_info->granularity == IOMMU_INV_GRANU_ADDR &&
-			 (inv_info->addr_info.flags & IOMMU_INV_ADDR_FLAGS_PASID))
-			pasid = inv_info->addr_info.pasid;
+			 (inv_info->granu.addr_info.flags & IOMMU_INV_ADDR_FLAGS_PASID))
+			pasid = inv_info->granu.addr_info.pasid;
 
 		switch (BIT(cache_type)) {
 		case IOMMU_CACHE_INV_TYPE_IOTLB:
 			/* HW will ignore LSB bits based on address mask */
 			if (inv_info->granularity == IOMMU_INV_GRANU_ADDR &&
 			    size &&
-			    (inv_info->addr_info.addr & ((BIT(VTD_PAGE_SHIFT + size)) - 1))) {
+			    (inv_info->granu.addr_info.addr & ((BIT(VTD_PAGE_SHIFT + size)) - 1))) {
 				WARN_ONCE(1, "Address out of range, 0x%llx, size order %llu\n",
-					  inv_info->addr_info.addr, size);
+					  inv_info->granu.addr_info.addr, size);
 			}
 
 			/*
@@ -5453,9 +5453,9 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
 			 * We use npages = -1 to indicate that.
 			 */
 			qi_flush_piotlb(iommu, did, pasid,
-					mm_to_dma_pfn(inv_info->addr_info.addr),
+					mm_to_dma_pfn(inv_info->granu.addr_info.addr),
 					(granu == QI_GRAN_NONG_PASID) ? -1 : 1 << size,
-					inv_info->addr_info.flags & IOMMU_INV_ADDR_FLAGS_LEAF);
+					inv_info->granu.addr_info.flags & IOMMU_INV_ADDR_FLAGS_LEAF);
 
 			if (!info->ats_enabled)
 				break;
@@ -5476,13 +5476,13 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
 				size = 64 - VTD_PAGE_SHIFT;
 				addr = 0;
 			} else if (inv_info->granularity == IOMMU_INV_GRANU_ADDR)
-				addr = inv_info->addr_info.addr;
+				addr = inv_info->granu.addr_info.addr;
 
 			if (info->ats_enabled)
 				qi_flush_dev_iotlb_pasid(iommu, sid,
 						info->pfsid, pasid,
 						info->ats_qdep,
-						inv_info->addr_info.addr,
+						inv_info->granu.addr_info.addr,
 						size);
 			else
 				pr_warn_ratelimited("Passdown device IOTLB flush w/o ATS!\n");
drivers/iommu/intel/svm.c +1 -1
index d386853121a2..713b3a218483 100644
@@ -338,7 +338,7 @@ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev,
 	spin_lock(&iommu->lock);
 	ret = intel_pasid_setup_nested(iommu, dev,
 				       (pgd_t *)(uintptr_t)data->gpgd,
-				       data->hpasid, &data->vtd, dmar_domain,
+				       data->hpasid, &data->vendor.vtd, dmar_domain,
 				       data->addr_width);
 	spin_unlock(&iommu->lock);
 	if (ret) {
include/uapi/linux/iommu.h +2 -2
index d5e9014f690e..7c8e075c2b29 100644
@@ -263,7 +263,7 @@ struct iommu_cache_invalidate_info {
 	union {
 		struct iommu_inv_pasid_info pasid_info;
 		struct iommu_inv_addr_info addr_info;
-	};
+	} granu;
 };
 
 /**
@@ -329,7 +329,7 @@ struct iommu_gpasid_bind_data {
 	/* Vendor specific data */
 	union {
 		struct iommu_gpasid_bind_data_vtd vtd;
-	};
+	} vendor;
 };
 
 #endif /* _UAPI_IOMMU_H */
#12 lore raw

Re: [PATCH v5 4/5] iommu/uapi: Handle data and argsz filled by users

In reply to Jacob Pan

Hi Jacob,
On 7/16/20 8:45 PM, Jacob Pan wrote:

Could you share a branch? I was not able to apply this on either iommu/next or master?

Quoted 2 lines

IOMMU UAPI data has a user filled argsz field which indicates the data length comes with the API call.

s/ comes with the API call/ of the structure
User data is not trusted, argsz must be

Quoted 4 lines

validated based on the current kernel data size, mandatory data size, and feature flags.

User data may also be extended, results in possible argsz increase.

s/results/resulting

Quoted 1 line

Backward compatibility is ensured based on size and flags checking.

flags is missing in iommu_cache_invalidate_info.

Quoted 17 lines

This patch adds sanity checks in the IOMMU layer. In addition to argsz, reserved/unused fields in padding, flags, and version are also checked. Details are documented in Documentation/userspace-api/iommu.rst

---
 drivers/iommu/iommu.c | 192 ++++++++++++++++++++++++++++++++++++++++++++++++--
 include/linux/iommu.h |  20 ++++--
 2 files changed, 200 insertions(+), 12 deletions(-)
drivers/iommu/iommu.c +0 -0
index d43120eb1dc5..fe30a940d19e 100644

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 1954

Quoted 5 lines
drivers/iommu/iommu.c +2 -0
@@ -1950,36 +1950,214 @@ int iommu_attach_device(struct iommu_domain *domain, struct device *dev)
 }
 EXPORT_SYMBOL_GPL(iommu_attach_device);
 
+/*
+ * Check flags and other user privided data for valid combinations. We also

s/privided/provided

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 1955

Quoted 1 line
drivers/iommu/iommu.c +1 -0
+ * make sure no reserved fields or unused flags are not set. This is to ensure

s/not// ?

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 1962

Quoted 7 lines
drivers/iommu/iommu.c +7 -0
+ * not breaking userspace in the future when these fields or flags are used.
+ */
+static int iommu_check_cache_invl_data(struct iommu_cache_invalidate_info *info)
+{
+	u32 mask;
+
+	if (info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)

increased version number?

Quoted 23 lines
drivers/iommu/iommu.c +23 -0
+		return -EINVAL;
+
+	mask = (1 << IOMMU_CACHE_INV_TYPE_NR) - 1;
+	if (info->cache & ~mask)
+		return -EINVAL;
+
+	if (info->granularity >= IOMMU_INV_GRANU_NR)
+		return -EINVAL;
+
+	switch (info->granularity) {
+	case IOMMU_INV_GRANU_ADDR:
+		mask = IOMMU_INV_ADDR_FLAGS_PASID |
+			IOMMU_INV_ADDR_FLAGS_ARCHID |
+			IOMMU_INV_ADDR_FLAGS_LEAF;
+
+		if (info->granu.addr_info.flags & ~mask)
+			return -EINVAL;
+		break;
+	case IOMMU_INV_GRANU_PASID:
+		mask = IOMMU_INV_PASID_FLAGS_PASID |
+			IOMMU_INV_PASID_FLAGS_ARCHID;
+		if (info->granu.pasid_info.flags & ~mask)
+			return -EINVAL;

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 1995

Quoted 10 lines
drivers/iommu/iommu.c +10 -0
+
+		break;
+	case IOMMU_INV_GRANU_DOMAIN:
+		/* No flags to check */
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (info->padding[0] || info->padding[1])

padding has become "__u8 padding[6];" in 2/5

Quoted 25 lines
drivers/iommu/iommu.c +18 -2
+		return -EINVAL;
+
+	return 0;
+}
+
 int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev,
-			   struct iommu_cache_invalidate_info *inv_info)
+			   void __user *uinfo)
 {
+	struct iommu_cache_invalidate_info inv_info = { 0 };
+	u32 minsz, maxsz;
+	int ret = 0;
+
 	if (unlikely(!domain->ops->cache_invalidate))
 		return -ENODEV;
 
-	return domain->ops->cache_invalidate(domain, dev, inv_info);
+	/* Current kernel data size is the max to be copied from user */
+	maxsz = sizeof(struct iommu_cache_invalidate_info);
+
+	/*
+	 * No new spaces can be added before the variable sized union, the
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_cache_invalidate_info, granu);

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2028

Quoted 10 lines
drivers/iommu/iommu.c +10 -0
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(&inv_info, uinfo, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (inv_info.argsz < minsz)
+		return -EINVAL;
+
+	/* PASID and address granu requires additional info beyond minsz */

s/requires/require

Quoted 36 lines
drivers/iommu/iommu.c +30 -2
+	if (inv_info.argsz == minsz &&
+		((inv_info.granularity == IOMMU_INV_GRANU_PASID) ||
+			(inv_info.granularity == IOMMU_INV_GRANU_ADDR)))
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header which has a larger data
+	 * size, we shall support the existing flags within the current
+	 * size. Copy the remaining user data _after_ minsz but not more
+	 * than the current kernel supported size.
+	 */
+	if (copy_from_user((void *)&inv_info + minsz, uinfo + minsz,
+				min(inv_info.argsz, maxsz) - minsz))
+		return -EFAULT;
+
+	/* Now the argsz is validated, check the content */
+	ret = iommu_check_cache_invl_data(&inv_info);
+	if (ret)
+		return ret;
+
+	return domain->ops->cache_invalidate(domain, dev, &inv_info);
 }
 EXPORT_SYMBOL_GPL(iommu_cache_invalidate);
 
-int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-			   struct device *dev, struct iommu_gpasid_bind_data *data)
+
+static int iommu_check_bind_data(struct iommu_gpasid_bind_data *data)
 {
+	u32 mask;
+	int i;
+
+	if (data->version != IOMMU_GPASID_BIND_VERSION_1)
+		return -EINVAL;
+
+	/* Check all supported format, for now just VT-d */
+	mask = IOMMU_PASID_FORMAT_INTEL_VTD;

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2072

Quoted 10 lines
drivers/iommu/iommu.c +10 -0
+	if (data->format & ~mask)
+		return -EINVAL;
+
+	/* Check all flags */
+	mask = IOMMU_SVA_GPASID_VAL;
+	if (data->flags & ~mask)
+		return -EINVAL;
+
+	/* Check reserved padding fields */
+	for (i = 0; i < 12; i++) {

now 8

Quoted 35 lines
drivers/iommu/iommu.c +35 -0
+		if (data->padding[i])
+			return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int iommu_sva_prepare_bind_data(void __user *udata,
+				       struct iommu_gpasid_bind_data *data)
+{
+	u32 minsz, maxsz;
+
+	/* Current kernel data size is the max to be copied from user */
+	maxsz = sizeof(struct iommu_gpasid_bind_data);
+	memset((void *)data, 0, maxsz);
+
+	/*
+	 * No new spaces can be added before the variable sized union, the
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_gpasid_bind_data, vendor);
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(data, udata, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (data->argsz < minsz)
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header, we shall let IOMMU vendor
+	 * driver decide on what size it needs. Since the guest PASID bind data
+	 * can be vendor specific, larger argsz could be the result of extension
+	 * for one vendor but it should not affect another vendor.
+	 * Copy the remaining user data _after_ minsz

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2117

Quoted 10 lines
drivers/iommu/iommu.c +10 -0
+	 */
+	if (copy_from_user((void *)data + minsz, udata + minsz,
+				min(data->argsz, maxsz) - minsz))
+		return -EFAULT;
+
+	return iommu_check_bind_data(data);
+}
+
+int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct device *dev,
+						void __user *udata)

change of proto not described in the commit msg

Quoted 10 lines
drivers/iommu/iommu.c +6 -1
+{
+
+	struct iommu_gpasid_bind_data data;
+	int ret;
+
 	if (unlikely(!domain->ops->sva_bind_gpasid))
 		return -ENODEV;
 
-	return domain->ops->sva_bind_gpasid(domain, dev, data);
+	ret = iommu_sva_prepare_bind_data(udata, &data);

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2135

Quoted 10 lines
drivers/iommu/iommu.c +5 -1
+	if (ret)
+		return ret;
+
+	return domain->ops->sva_bind_gpasid(domain, dev, &data);
 }
 EXPORT_SYMBOL_GPL(iommu_sva_bind_gpasid);
 
 int iommu_sva_unbind_gpasid(struct iommu_domain *domain, struct device *dev,
-			     ioasid_t pasid)
+			struct iommu_gpasid_bind_data *data)

This change and the introduction of iommu_uapi_sva_unbind_gpasid look unrelated to this patch, at least not described in the commit msg.

Quoted 35 lines
drivers/iommu/iommu.c +18 -1
 {
 	if (unlikely(!domain->ops->sva_unbind_gpasid))
 		return -ENODEV;
 
-	return domain->ops->sva_unbind_gpasid(dev, pasid);
+	return domain->ops->sva_unbind_gpasid(dev, data->hpasid);
 }
 EXPORT_SYMBOL_GPL(iommu_sva_unbind_gpasid);
 
+int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain, struct device *dev,
+			void __user *udata)
+{
+	struct iommu_gpasid_bind_data data;
+	int ret;
+
+	if (unlikely(!domain->ops->sva_bind_gpasid))
+		return -ENODEV;
+
+	ret = iommu_sva_prepare_bind_data(udata, &data);
+	if (ret)
+		return ret;
+
+	return iommu_sva_unbind_gpasid(domain, dev, &data);
+}
+EXPORT_SYMBOL_GPL(iommu_uapi_sva_unbind_gpasid);
+
 static void __iommu_detach_device(struct iommu_domain *domain,
 				  struct device *dev)
 {
include/linux/iommu.h +0 -0
index 5f0b7859d2eb..439f34a7b5b2 100644
@@ -432,11 +432,14 @@ extern void iommu_detach_device(struct iommu_domain *domain,
 				struct device *dev);

include/linux/iommu.h extern void iommu_detach_device(struct iommu_domain *domain, · line 440

Quoted 10 lines
include/linux/iommu.h +5 -2
 extern int iommu_cache_invalidate(struct iommu_domain *domain,
 				  struct device *dev,
-				  struct iommu_cache_invalidate_info *inv_info);
+				  void __user *uinfo);
+
 extern int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-		struct device *dev, struct iommu_gpasid_bind_data *data);
+				struct device *dev, void __user *udata);
+extern int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,
+				        struct device *dev, void __user *udata);

not motivated in the commit msg. I think change of proto and addition of iommu_sva_unbind_gpasid would deserve a separate patch.

Quoted 20 lines
include/linux/iommu.h +3 -3
 extern int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
-				struct device *dev, ioasid_t pasid);
+				   struct device *dev, struct iommu_gpasid_bind_data *data);
 extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
 extern struct iommu_domain *iommu_get_dma_domain(struct device *dev);
 extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
@@ -1062,13 +1065,20 @@ iommu_cache_invalidate(struct iommu_domain *domain,
 	return -ENODEV;
 }
 static inline int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-				struct device *dev, struct iommu_gpasid_bind_data *data)
+				struct device *dev, void __user *udata)
 {
 	return -ENODEV;
 }
 
 static inline int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
-					   struct device *dev, int pasid)
+					   struct device *dev, void __user *udata)

include/linux/iommu.h iommu_cache_invalidate(struct iommu_domain *domain, · line 1084

Quoted 10 lines
include/linux/iommu.h +7 -0
+{
+	return -ENODEV;
+}
+
+static inline int __iommu_sva_unbind_gpasid(struct iommu_domain *domain,
+					struct device *dev,
+					struct iommu_gpasid_bind_data *data)
 {
 	return -ENODEV;
 }

Thanks

Eric

Reviewed-by on v5 5/5
#18 lore raw

Re: [PATCH v5 5/5] iommu/vt-d: Check UAPI data processed by IOMMU core

In reply to Jacob Pan

Hi Jacob,

Quoted 6 lines · Jacob Pan

IOMMU generic layer already does sanity checks UAPI data for version match and argsz range under generic information.
Remove the redundant version check from VT-d driver and check for vendor specific data size.

Thanks

Eric

Quoted 38 lines
---
 drivers/iommu/intel/iommu.c | 3 +--
 drivers/iommu/intel/svm.c   | 7 +++++--
 2 files changed, 6 insertions(+), 4 deletions(-)
drivers/iommu/intel/iommu.c +1 -2
index f3a6ca88cf95..5e80484f0537 100644
@@ -5383,8 +5383,7 @@ intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev,
 	int ret = 0;
 	u64 size = 0;
 
-	if (!inv_info || !dmar_domain ||
-	    inv_info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+	if (!inv_info || !dmar_domain)
 		return -EINVAL;
 
 	if (!dev || !dev_is_pci(dev))
drivers/iommu/intel/svm.c +5 -2
index 713b3a218483..55ea11e9c0f5 100644
@@ -240,8 +240,11 @@ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev,
 	if (WARN_ON(!iommu) || !data)
 		return -EINVAL;
 
-	if (data->version != IOMMU_GPASID_BIND_VERSION_1 ||
-	    data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+	if (data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+		return -EINVAL;
+
+	/* IOMMU core ensures argsz is more than the start of the union */
+	if (data->argsz < offsetofend(struct iommu_gpasid_bind_data, vendor.vtd))
 		return -EINVAL;
 
 	if (!dev_is_pci(dev))
#4 lore raw

Re: [PATCH v5 1/5] docs: IOMMU user API

In reply to Jacob Pan
Quoted 223 lines · On Thu, 16 Jul 2020 11:45:13 -0700 Jacob Pan <[email protected]>…

IOMMU UAPI is newly introduced to support communications between guest virtual IOMMU and host IOMMU. There has been lots of discussions on how it should work with VFIO UAPI and userspace in general.

This document is indended to clarify the UAPI design and usage. The mechanics of how future extensions should be achieved are also covered in this documentation.

---
 Documentation/userspace-api/iommu.rst | 339 ++++++++++++++++++++++++++++++++++
 1 file changed, 339 insertions(+)
 create mode 100644 Documentation/userspace-api/iommu.rst
Documentation/userspace-api/iommu.rst new file +202 -0
new file mode 100644
index 000000000000..efc3e1838235
@@ -0,0 +1,339 @@
+.. SPDX-License-Identifier: GPL-2.0
+.. iommu:
+
+=====================================
+IOMMU Userspace API
+=====================================
+
+IOMMU UAPI is used for virtualization cases where communications are
+needed between physical and virtual IOMMU drivers. For native
+usage, IOMMU is a system device which does not need to communicate
+with user space directly.
+
+The primary use cases are guest Shared Virtual Address (SVA) and
+guest IO virtual address (IOVA), wherein a virtual IOMMU (vIOMMU) is
+required to communicate with the physical IOMMU in the host.
+
+.. contents:: :local:
+
+Functionalities
+===============
+Communications of user and kernel involve both directions. The
+supported user-kernel APIs are as follows:
+
+1. Alloc/Free PASID
+2. Bind/unbind guest PASID (e.g. Intel VT-d)
+3. Bind/unbind guest PASID table (e.g. ARM sMMU)
+4. Invalidate IOMMU caches
+5. Service IO page faults (page request and response)
+
+Requirements
+============
+The IOMMU UAPIs are generic and extensible to meet the following
+requirements:
+
+1. Emulated and para-virtualised vIOMMUs
+2. Multiple vendors (Intel VT-d, ARM sMMU, etc.)
+3. Extensions to the UAPI shall not break existing user space
+
+Interfaces
+==========
+Although the data structures defined in IOMMU UAPI are self-contained,
+there is no user API functions introduced. Instead, IOMMU UAPI is
+designed to work with existing user driver frameworks such as VFIO.
+
+Extension Rules & Precautions
+-----------------------------
+When IOMMU UAPI gets extended, the data structures can *only* be
+modified in two ways:
+
+1. Adding new fields by re-purposing the padding[] field. No size change.
+2. Adding new union members at the end. May increase in size.
+
+No new fields can be added *after* the variable sized union in that it
+will break backward compatibility when offset moves. In both cases, a
+new flag must be accompanied with a new field such that the IOMMU
+driver can process the data based on the new flag. Version field is
+only reserved for the unlikely event of UAPI upgrade at its entirety.
+
+It's *always* the caller's responsibility to indicate the size of the
+structure passed by setting argsz appropriately.
+Though at the same time, argsz is user provided data which is not
+trusted. The argsz field allows the user to indicate how much data
+they're providing, it's still the kernel's responsibility to validate
+whether it's correct and sufficient for the requested operation.
+
+Compatibility Checking
+----------------------
+When IOMMU UAPI extension results in size increase, IOMMU UAPI core
+and vendor driver shall handle the following cases:
+
+1. User and kernel has exact size match
+2. An older user with older kernel header (smaller UAPI size) running on a
+   newer kernel (larger UAPI size)
+3. A newer user with newer kernel header (larger UAPI size) running
+   on an older kernel.
+4. A malicious/misbehaving user pass illegal/invalid size but within
+   range. The data may contain garbage.
+
+Feature Checking
+----------------
+While launching a guest with vIOMMU, it is important to ensure that host
+can support the UAPI data structures to be used for vIOMMU-pIOMMU
+communications. Without upfront compatibility checking, future faults
+are difficult to report even in normal conditions. For example, TLB
+invalidations should always succeed. There is no architectural way to
+report back to the vIOMMU if the UAPI data is incompatible. If that
+happens, in order to protect IOMMU iosolation guarantee, we have to
+resort to not giving completion status in vIOMMU. This may result in
+VM hang.
+
+For this reason the following IOMMU UAPIs cannot fail:
+
+1. Free PASID
+2. Unbind guest PASID
+3. Unbind guest PASID table (SMMU)
+4. Cache invalidate
+
+User applications such as QEMU are expected to import kernel UAPI
+headers. Backward compatibility is supported per feature flags.
+For example, an older QEMU (with older kernel header) can run on newer
+kernel. Newer QEMU (with new kernel header) may refuse to initialize
+on an older kernel if new feature flags are not supported by older
+kernel. Simply recompiling existing code with newer kernel header should
+not be an issue in that only existing flags are used.
+
+IOMMU vendor driver should report the below features to IOMMU UAPI
+consumers (e.g. via VFIO).
+
+1. IOMMU_NESTING_FEAT_SYSWIDE_PASID
+2. IOMMU_NESTING_FEAT_BIND_PGTBL
+3. IOMMU_NESTING_FEAT_BIND_PASID_TABLE
+4. IOMMU_NESTING_FEAT_CACHE_INVLD
+5. IOMMU_NESTING_FEAT_PAGE_REQUEST
+
+Take VFIO as example, upon request from VFIO user space (e.g. QEMU),
+VFIO kernel code shall query IOMMU vendor driver for the support of
+the above features. Query result can then be reported back to the
+user-space caller. Details can be found in
+Documentation/driver-api/vfio.rst.
+
+
+Data Passing Example with VFIO
+------------------------------
+As the ubiquitous userspace driver framework, VFIO is already IOMMU
+aware and shares many key concepts such as device model, group, and
+protection domain. Other user driver frameworks can also be extended
+to support IOMMU UAPI but it is outside the scope of this document.
+
+In this tight-knit VFIO-IOMMU interface, the ultimate consumer of the
+IOMMU UAPI data is the host IOMMU driver. VFIO facilitates user-kernel
+transport, capability checking, security, and life cycle management of
+process address space ID (PASID).
+
+Unlike normal user data passed via VFIO UAPI IOTCL, IOMMU driver is the
+ultimate consumer of its UAPI data. At VFIO layer, the IOMMU UAPI data
+is wrapped in a VFIO UAPI data. It follows the
+pattern below::
+
+   struct {
+	__u32 argsz;
+	__u32 flags;
+	__u8  data[];
+   };
+
+Here data[] contains the IOMMU UAPI data structures. VFIO has the
+freedom to bundle the data as well as parse data size based on its own flags.
+
+In order to determine the size and feature set of the user data, argsz
+and flags are also embedded in the IOMMU UAPI data structures.
+A "__u32 argsz" field is *always* at the beginning of each structure.
+
+For example:
+::
+
+   struct iommu_cache_invalidate_info {
+	__u32	argsz;
+	#define IOMMU_CACHE_INVALIDATE_INFO_VERSION_1 1
+	__u32	version;
+	/* IOMMU paging structure cache */
+	#define IOMMU_CACHE_INV_TYPE_IOTLB	(1 << 0) /* IOMMU IOTLB */
+	#define IOMMU_CACHE_INV_TYPE_DEV_IOTLB	(1 << 1) /* Device IOTLB */
+	#define IOMMU_CACHE_INV_TYPE_PASID	(1 << 2) /* PASID cache */
+	#define IOMMU_CACHE_INV_TYPE_NR		(3)
+	__u8	cache;
+	__u8	granularity;
+	__u8	padding[6];
+	union {
+		struct iommu_inv_pasid_info pasid_info;
+		struct iommu_inv_addr_info addr_info;
+	} granu;
+   };
+
+VFIO is responsible for checking its own argsz and flags then invokes
+appropriate IOMMU UAPI functions. User pointer is passed to IOMMU
+layer for further processing. The responsibilities are divided as
+follows:
+
+- Generic IOMMU layer checks argsz range based on UAPI data in the
+  current kernel version
+
+- Generic IOMMU layer checks content of the UAPI data for non-zero
+  reserved bits in flags, padding fields, and unsupported version.
+  This is to ensure not breaking userspace in the future when these
+  fields or flags are used.
+
+- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data
+  is consumed based on flags. Vendor driver has access to
+  unadulterated argsz value in case of vendor specific future
+  extensions.
+
+To illustrate the two cases with and without vendor data, cache
+invalidation and bind guest PASID are given as examples respectively.
+
+Example 1: Guest issues IOTLB invalidation, all guest provided data
+are generic. Vendor driver does not need to check argsz.
+
+::
+
+ static int iommu_check_cache_invl_data(struct iommu_cache_invalidate_info *info)
+ {
+	u32 mask;
+

Documentation/userspace-api/iommu.rst line 212

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+	if (info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+		return -EINVAL;
+
+	mask = (1 << IOMMU_CACHE_INV_TYPE_NR) - 1;
+	if (info->cache & ~mask)
+		return -EINVAL;
+
+	if (info->granularity >= IOMMU_INV_GRANU_NR)
+		return -EINVAL;
+

The table defining valid cache/granularity combinations specifically indicates the following are not available:

IOMMU_INV_GRANU_DOMAIN + IOMMU_CACHE_INV_TYPE_DEV_IOTLB IOMMU_INV_GRANU_ADDR + IOMMU_CACHE_INV_TYPE_PASID

So shouldn't we also have the following rejected?

Documentation/userspace-api/iommu.rst line 214

Quoted 2 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+	switch (info->granularity) {
+	case IOMMU_INV_GRANU_ADDR:
		if (info->cache & IOMMU_CACHE_INV_TYPE_PASID)
			return -EINVAL;
Quoted 6 lines
Documentation/userspace-api/iommu.rst new file +6 -0
+		mask = IOMMU_INV_ADDR_FLAGS_PASID |
+			IOMMU_INV_ADDR_FLAGS_ARCHID |
+			IOMMU_INV_ADDR_FLAGS_LEAF;
+
+		if (info->granu.addr_info.flags & ~mask)
+			return -EINVAL;

Documentation/userspace-api/iommu.rst line 230

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+		break;
+	case IOMMU_INV_GRANU_PASID:
+		mask = IOMMU_INV_PASID_FLAGS_PASID |
+			IOMMU_INV_PASID_FLAGS_ARCHID;
+		if (info->granu.pasid_info.flags & ~mask)
+			return -EINVAL;
+
+		break;
+	case IOMMU_INV_GRANU_DOMAIN:
+		/* No flags to check */
		if (info->cache & IOMMU_CACHE_INV_TYPE_DEV_IOTLB)
			return -EINVAL;

Documentation/userspace-api/iommu.rst line 236

Quoted 6 lines
Documentation/userspace-api/iommu.rst new file +6 -0
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (info->padding[0] || info->padding[1])

More padding bytes to test now.

Quoted 27 lines
Documentation/userspace-api/iommu.rst new file +27 -0
+		return -EINVAL;
+
+	return 0;
+ }
+
+ int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev,
+			   void __user *uinfo)
+ {
+	struct iommu_cache_invalidate_info inv_info = { 0 };
+	u32 minsz, maxsz;
+	int ret = 0;
+
+	if (unlikely(!domain->ops->cache_invalidate))
+		return -ENODEV;
+
+	/* Current kernel data size is the max to be copied from user */
+	maxsz = sizeof(struct iommu_cache_invalidate_info);
+
+	/*
+	 * No new spaces can be added before the variable sized union, the
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_cache_invalidate_info, granu);
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(&inv_info, uinfo, minsz))
+		return -EFAULT;

Documentation/userspace-api/iommu.rst line 273

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+
+	/* Fields before variable size union is mandatory */
+	if (inv_info.argsz < minsz)
+		return -EINVAL;
+
+	/* PASID and address granu requires additional info beyond minsz */
+	if (inv_info.argsz == minsz &&
+		((inv_info.granularity == IOMMU_INV_GRANU_PASID) ||
+			(inv_info.granularity == IOMMU_INV_GRANU_ADDR)))
+		return -EINVAL;

We only validated that argsz is at least (minsz + 1).

Documentation/userspace-api/iommu.rst line 284

Quoted 11 lines
Documentation/userspace-api/iommu.rst new file +11 -0
+	/*
+	 * User might be using a newer UAPI header which has a larger data
+	 * size, we shall support the existing flags within the current
+	 * size. Copy the remaining user data _after_ minsz but not more
+	 * than the current kernel supported size.
+	 */
+	if (copy_from_user((void *)&inv_info + minsz, uinfo + minsz,
+				min(inv_info.argsz, maxsz) - minsz))
+		return -EFAULT;
+
+	/* Now the argsz is validated, check the content */

If we want to assert that IOMMU_INV_GRANU_PASID requires a struct iommu_inv_pasid_info and IOMMU_INV_GRANU_ADDR requires a struct iommu_inv_addr_info, then we've done a pretty poor job of validating argsz against that. Do you want the switch in iommu_check_cache_invl_data() to also check info->argsz in the pasid and addr cases? If so, we could always copy min(argsz, sizeof) and remove the previous check.

Quoted 25 lines
Documentation/userspace-api/iommu.rst new file +25 -0
+	ret = iommu_check_cache_invl_data(&inv_info);
+	if (ret)
+		return ret;
+
+	return domain->ops->cache_invalidate(domain, dev, &inv_info);
+ }
+ EXPORT_SYMBOL_GPL(iommu_cache_invalidate);
+
+
+Example 2: Bind guest PASID which includes vendor specific data.
+The IOMMU core processing of UAPI data follows the same flow as
+Example 1. Vendor driver handles the additional vendor specific flags
+as in VT-d driver below:
+
+::
+
+ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev,
+			  struct iommu_gpasid_bind_data *data)
+ {
+	struct intel_iommu *iommu = intel_svm_device_to_iommu(dev);
+	struct dmar_domain *dmar_domain;
+	struct intel_svm_dev *sdev;
+	struct intel_svm *svm;
+	int ret = 0;
+

Documentation/userspace-api/iommu.rst line 319

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+	if (WARN_ON(!iommu) || !data)
+		return -EINVAL;
+
+	if (data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+		return -EINVAL;
+
+	/* IOMMU core ensures argsz is more than the start of the union */
+	if (data->argsz < offsetofend(struct iommu_gpasid_bind_data,
+            vendor.vtd))
+		return -EINVAL;

So at this point the vendor driver assumes the core has copied min(argsz, sizeof(uapi struct)) and it only needs to validate, not perform the copy itself (until we get to some future scenario where there's vendor data outside of the structure definition and we'll need to provide a __user pointer for the vendor driver to fetch it).

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+   ...
+ }
+
+
+Sharing UAPI with in-kernel users
+---------------------------------
+For UAPIs that are shared with in-kernel users, a wrapper function is
+provided to distinguish the callers. For example,
+
+Userspace caller ::

Documentation/userspace-api/iommu.rst line 339

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+
+  int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,
+                                   struct device *dev,
+                                   void __user *udata)
+
+In-kernel caller ::
+
+  int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
+                                   struct device *dev,
+                                   struct iommu_gpasid_bind_data *data)

Shouldn't we start that precedent with the iommu_cache_invalidate() example above? The "that are shared with in-kernel users" qualifier doesn't really make sense to me, then we'll have uapi functions named as if they're in-kernel just because there isn't an in-kernel user yet. That's inconsistency that'll get us into trouble. Thanks,

Alex

#14 lore raw

Re: [PATCH v5 4/5] iommu/uapi: Handle data and argsz filled by users

In reply to Jacob Pan
Quoted 108 lines · On Thu, 16 Jul 2020 11:45:16 -0700 Jacob Pan <[email protected]>…

IOMMU UAPI data has a user filled argsz field which indicates the data length comes with the API call. User data is not trusted, argsz must be validated based on the current kernel data size, mandatory data size, and feature flags.

User data may also be extended, results in possible argsz increase. Backward compatibility is ensured based on size and flags checking.

This patch adds sanity checks in the IOMMU layer. In addition to argsz, reserved/unused fields in padding, flags, and version are also checked. Details are documented in Documentation/userspace-api/iommu.rst

---
 drivers/iommu/iommu.c | 192 ++++++++++++++++++++++++++++++++++++++++++++++++--
 include/linux/iommu.h |  20 ++++--
 2 files changed, 200 insertions(+), 12 deletions(-)
drivers/iommu/iommu.c +74 -2
index d43120eb1dc5..fe30a940d19e 100644
@@ -1950,36 +1950,214 @@ int iommu_attach_device(struct iommu_domain *domain, struct device *dev)
 }
 EXPORT_SYMBOL_GPL(iommu_attach_device);
 
+/*
+ * Check flags and other user privided data for valid combinations. We also
+ * make sure no reserved fields or unused flags are not set. This is to ensure
+ * not breaking userspace in the future when these fields or flags are used.
+ */
+static int iommu_check_cache_invl_data(struct iommu_cache_invalidate_info *info)
+{
+	u32 mask;
+
+	if (info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+		return -EINVAL;
+
+	mask = (1 << IOMMU_CACHE_INV_TYPE_NR) - 1;
+	if (info->cache & ~mask)
+		return -EINVAL;
+
+	if (info->granularity >= IOMMU_INV_GRANU_NR)
+		return -EINVAL;
+
+	switch (info->granularity) {
+	case IOMMU_INV_GRANU_ADDR:
+		mask = IOMMU_INV_ADDR_FLAGS_PASID |
+			IOMMU_INV_ADDR_FLAGS_ARCHID |
+			IOMMU_INV_ADDR_FLAGS_LEAF;
+
+		if (info->granu.addr_info.flags & ~mask)
+			return -EINVAL;
+		break;
+	case IOMMU_INV_GRANU_PASID:
+		mask = IOMMU_INV_PASID_FLAGS_PASID |
+			IOMMU_INV_PASID_FLAGS_ARCHID;
+		if (info->granu.pasid_info.flags & ~mask)
+			return -EINVAL;
+
+		break;
+	case IOMMU_INV_GRANU_DOMAIN:
+		/* No flags to check */
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (info->padding[0] || info->padding[1])
+		return -EINVAL;
+
+	return 0;
+}
+
 int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev,
-			   struct iommu_cache_invalidate_info *inv_info)
+			   void __user *uinfo)
 {
+	struct iommu_cache_invalidate_info inv_info = { 0 };
+	u32 minsz, maxsz;
+	int ret = 0;
+
 	if (unlikely(!domain->ops->cache_invalidate))
 		return -ENODEV;
 
-	return domain->ops->cache_invalidate(domain, dev, inv_info);
+	/* Current kernel data size is the max to be copied from user */
+	maxsz = sizeof(struct iommu_cache_invalidate_info);
+
+	/*
+	 * No new spaces can be added before the variable sized union, the
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_cache_invalidate_info, granu);
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(&inv_info, uinfo, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (inv_info.argsz < minsz)
+		return -EINVAL;
+
+	/* PASID and address granu requires additional info beyond minsz */
+	if (inv_info.argsz == minsz &&
+		((inv_info.granularity == IOMMU_INV_GRANU_PASID) ||
+			(inv_info.granularity == IOMMU_INV_GRANU_ADDR)))

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2041

Quoted 10 lines
drivers/iommu/iommu.c +10 -0
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header which has a larger data
+	 * size, we shall support the existing flags within the current
+	 * size. Copy the remaining user data _after_ minsz but not more
+	 * than the current kernel supported size.
+	 */
+	if (copy_from_user((void *)&inv_info + minsz, uinfo + minsz,
+				min(inv_info.argsz, maxsz) - minsz))
+		return -EFAULT;

To further clarify previous comments about maxsz usage:

s/maxsz/sizeof(inv_info)/

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2050

Quoted 9 lines
drivers/iommu/iommu.c +7 -0
+
+	/* Now the argsz is validated, check the content */
+	ret = iommu_check_cache_invl_data(&inv_info);
+	if (ret)
+		return ret;
+
+	return domain->ops->cache_invalidate(domain, dev, &inv_info);
 }
 EXPORT_SYMBOL_GPL(iommu_cache_invalidate);

Remainder of comments for above provided in 1/5.

Quoted 29 lines
drivers/iommu/iommu.c +25 -2
-int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-			   struct device *dev, struct iommu_gpasid_bind_data *data)
+
+static int iommu_check_bind_data(struct iommu_gpasid_bind_data *data)
 {
+	u32 mask;
+	int i;
+
+	if (data->version != IOMMU_GPASID_BIND_VERSION_1)
+		return -EINVAL;
+
+	/* Check all supported format, for now just VT-d */
+	mask = IOMMU_PASID_FORMAT_INTEL_VTD;
+	if (data->format & ~mask)
+		return -EINVAL;
+
+	/* Check all flags */
+	mask = IOMMU_SVA_GPASID_VAL;
+	if (data->flags & ~mask)
+		return -EINVAL;
+
+	/* Check reserved padding fields */
+	for (i = 0; i < 12; i++) {
+		if (data->padding[i])
+			return -EINVAL;
+	}
+
+	return 0;

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2087

Quoted 10 lines
drivers/iommu/iommu.c +10 -0
+}
+
+static int iommu_sva_prepare_bind_data(void __user *udata,
+				       struct iommu_gpasid_bind_data *data)
+{
+	u32 minsz, maxsz;
+
+	/* Current kernel data size is the max to be copied from user */
+	maxsz = sizeof(struct iommu_gpasid_bind_data);
+	memset((void *)data, 0, maxsz);

Let the caller pass a zero'd structure.

Quoted 13 lines
drivers/iommu/iommu.c +13 -0
+
+	/*
+	 * No new spaces can be added before the variable sized union, the
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_gpasid_bind_data, vendor);
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(data, udata, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (data->argsz < minsz)

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2110

Quoted 10 lines
drivers/iommu/iommu.c +10 -0
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header, we shall let IOMMU vendor
+	 * driver decide on what size it needs. Since the guest PASID bind data
+	 * can be vendor specific, larger argsz could be the result of extension
+	 * for one vendor but it should not affect another vendor.
+	 * Copy the remaining user data _after_ minsz
+	 */
+	if (copy_from_user((void *)data + minsz, udata + minsz,
+				min(data->argsz, maxsz) - minsz))

We could replace maxsz entirely with sizeof(*data)

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2117

Quoted 7 lines
drivers/iommu/iommu.c +7 -0
+		return -EFAULT;
+
+	return iommu_check_bind_data(data);
+}
+
+int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct device *dev,
+						void __user *udata)

iommu_uapi_sva_bind_gpasid(...

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2120

Quoted 3 lines
drivers/iommu/iommu.c +3 -0
+{
+
+	struct iommu_gpasid_bind_data data;
	= { 0 }
Quoted 20 lines
drivers/iommu/iommu.c +8 -2
+	int ret;
+
 	if (unlikely(!domain->ops->sva_bind_gpasid))
 		return -ENODEV;
 
-	return domain->ops->sva_bind_gpasid(domain, dev, data);
+	ret = iommu_sva_prepare_bind_data(udata, &data);
+	if (ret)
+		return ret;
+
+	return domain->ops->sva_bind_gpasid(domain, dev, &data);
 }
 EXPORT_SYMBOL_GPL(iommu_sva_bind_gpasid);
 
 int iommu_sva_unbind_gpasid(struct iommu_domain *domain, struct device *dev,
-			     ioasid_t pasid)
+			struct iommu_gpasid_bind_data *data)
 {
 	if (unlikely(!domain->ops->sva_unbind_gpasid))
 		return -ENODEV;

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2147

Quoted 10 lines
drivers/iommu/iommu.c +5 -1
 
-	return domain->ops->sva_unbind_gpasid(dev, pasid);
+	return domain->ops->sva_unbind_gpasid(dev, data->hpasid);
 }
 EXPORT_SYMBOL_GPL(iommu_sva_unbind_gpasid);
 
+int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain, struct device *dev,
+			void __user *udata)
+{
+	struct iommu_gpasid_bind_data data;
	= { 0 };
Quoted 21 lines
drivers/iommu/iommu.c +13 -0
+	int ret;
+
+	if (unlikely(!domain->ops->sva_bind_gpasid))
+		return -ENODEV;
+
+	ret = iommu_sva_prepare_bind_data(udata, &data);
+	if (ret)
+		return ret;
+
+	return iommu_sva_unbind_gpasid(domain, dev, &data);
+}
+EXPORT_SYMBOL_GPL(iommu_uapi_sva_unbind_gpasid);
+
 static void __iommu_detach_device(struct iommu_domain *domain,
 				  struct device *dev)
 {
include/linux/iommu.h +0 -0
index 5f0b7859d2eb..439f34a7b5b2 100644

include/linux/iommu.h extern void iommu_detach_device(struct iommu_domain *domain, · line 433

Quoted 2 lines
include/linux/iommu.h +0 -0
@@ -432,11 +432,14 @@ extern void iommu_detach_device(struct iommu_domain *domain,
 				struct device *dev);
 extern int iommu_cache_invalidate(struct iommu_domain *domain,

uapi

include/linux/iommu.h extern void iommu_detach_device(struct iommu_domain *domain, · line 437

Quoted 5 lines
include/linux/iommu.h +2 -1
 				  struct device *dev,
-				  struct iommu_cache_invalidate_info *inv_info);
+				  void __user *uinfo);
+
 extern int iommu_sva_bind_gpasid(struct iommu_domain *domain,

uapi

Quoted 18 lines
include/linux/iommu.h +5 -3
-		struct device *dev, struct iommu_gpasid_bind_data *data);
+				struct device *dev, void __user *udata);
+extern int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,
+				        struct device *dev, void __user *udata);
 extern int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
-				struct device *dev, ioasid_t pasid);
+				   struct device *dev, struct iommu_gpasid_bind_data *data);
 extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
 extern struct iommu_domain *iommu_get_dma_domain(struct device *dev);
 extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
@@ -1062,13 +1065,20 @@ iommu_cache_invalidate(struct iommu_domain *domain,
 	return -ENODEV;
 }
 static inline int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-				struct device *dev, struct iommu_gpasid_bind_data *data)
+				struct device *dev, void __user *udata)
 {
 	return -ENODEV;

include/linux/iommu.h iommu_cache_invalidate(struct iommu_domain *domain, · line 1079

Quoted 10 lines
include/linux/iommu.h +6 -1
 }
 
 static inline int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
-					   struct device *dev, int pasid)
+					   struct device *dev, void __user *udata)
+{
+	return -ENODEV;
+}
+
+static inline int __iommu_sva_unbind_gpasid(struct iommu_domain *domain,

These don't match the previous semantics. Thanks,

Alex

Quoted 5 lines
include/linux/iommu.h +2 -0
+					struct device *dev,
+					struct iommu_gpasid_bind_data *data)
 {
 	return -ENODEV;
 }
author
#3 lore raw

Re: [PATCH v5 1/5] docs: IOMMU user API

In reply to Auger Eric

Hi Eric,

Quoted 11 lines · On Fri, 17 Jul 2020 15:32:58 +0200 Auger Eric <[email protected]> wrote:

Hi Jacob,

Quoted 7 lines · Jacob Pan

IOMMU UAPI is newly introduced to support communications between guest virtual IOMMU and host IOMMU. There has been lots of discussions on how it should work with VFIO UAPI and userspace in general.

This document is indended to clarify the UAPI design and usage. The

intended

will fix.

Quoted 10 lines
Quoted 10 lines

mechanics of how future extensions should be achieved are also covered in this documentation.

---
 Documentation/userspace-api/iommu.rst | 339
++++++++++++++++++++++++++++++++++ 1 file changed, 339 insertions(+)
 create mode 100644 Documentation/userspace-api/iommu.rst
Quoted 16 lines
Quoted 14 lines
(quoted diff) +0 -0

b/Documentation/userspace-api/iommu.rst new file mode 100644 index 000000000000..efc3e1838235

Documentation/userspace-api/iommu.rst new file +8 -0
@@ -0,0 +1,339 @@
+.. SPDX-License-Identifier: GPL-2.0
+.. iommu:
+
+=====================================
+IOMMU Userspace API
+=====================================
+
+IOMMU UAPI is used for virtualization cases where communications
Quoted 1 line

are +needed between physical and virtual IOMMU drivers. For native

s/native/baremetal?

Sounds good.

Quoted 3 lines
Quoted 2 lines

+usage, IOMMU is a system device which does not need to communicate

the IOMMU?

Sounds good.

Quoted 8 lines
Quoted 5 lines
Documentation/userspace-api/iommu.rst new file +4 -0
+with user space directly.
+
+The primary use cases are guest Shared Virtual Address (SVA) and
+guest IO virtual address (IOVA), wherein a virtual IOMMU (vIOMMU)

is +required to communicate with the physical IOMMU in the host.

wherin the vIOMMU implementation relies on the physical IOMMU and for this reason requires interactions with the host driver.

Will do, it is more complete.

Quoted 4 lines
Quoted 4 lines
Documentation/userspace-api/iommu.rst new file +4 -0
+
+.. contents:: :local:
+
+Functionalities
Quoted 8 lines

Documentation/userspace-api/iommu.rst line 26

Quoted 7 lines

+===============

Documentation/userspace-api/iommu.rst new file +6 -0
+Communications of user and kernel involve both directions. The
+supported user-kernel APIs are as follows:
+
+1. Alloc/Free PASID
+2. Bind/unbind guest PASID (e.g. Intel VT-d)
+3. Bind/unbind guest PASID table (e.g. ARM sMMU)  

s/sMMU/SMMU

Sounds good and all below.

Quoted 3 lines
Quoted 2 lines

+4. Invalidate IOMMU caches
+5. Service IO page faults (page request and response)

Report errors to the guest and serve page requests?

Yes, the UAPI does cover faults beyond PRS.

Quoted 9 lines

Documentation/userspace-api/iommu.rst line 36

Quoted 8 lines
Documentation/userspace-api/iommu.rst new file +8 -0
+
+Requirements
+============
+The IOMMU UAPIs are generic and extensible to meet the following
+requirements:
+
+1. Emulated and para-virtualised vIOMMUs
+2. Multiple vendors (Intel VT-d, ARM sMMU, etc.)  

SMMU

Ditto.

Quoted 9 lines
Quoted 9 lines

+3. Extensions to the UAPI shall not break existing user space

Documentation/userspace-api/iommu.rst new file +4 -0
+
+Interfaces
+==========
+Although the data structures defined in IOMMU UAPI are

self-contained, +there is no user API functions introduced. Instead, IOMMU UAPI is +designed to work with existing user driver frameworks such as VFIO. +
+Extension Rules & Precautions

Quoted 8 lines
Quoted 7 lines

+-----------------------------

Documentation/userspace-api/iommu.rst new file +4 -0
+When IOMMU UAPI gets extended, the data structures can *only* be
+modified in two ways:
+
+1. Adding new fields by re-purposing the padding[] field. No size

change. +2. Adding new union members at the end. May increase in size.

May increase the structure sizes

Sounds good.

Quoted 7 lines
Quoted 5 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+
+No new fields can be added *after* the variable sized union in

that it +will break backward compatibility when offset moves. In both cases, a +new flag must be accompanied with a new field such that the IOMMU

a new flag must be introduced whenever a change affects the structure using either method?

Yours is more clear, will change to:

A new flag must be introduced whenever a change affects the structure using either method. The IOMMU driver processes the data based on flags which ensures backward compatibility.

Quoted 10 lines
Quoted 9 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+driver can process the data based on the new flag. Version field is
+only reserved for the unlikely event of UAPI upgrade at its

entirety. +
+It's *always* the caller's responsibility to indicate the size of the +structure passed by setting argsz appropriately.

Documentation/userspace-api/iommu.rst new file +3 -0
+Though at the same time, argsz is user provided data which is not
+trusted. The argsz field allows the user to indicate how much data
+they're providing, it's still the kernel's responsibility to

validate

he is providing

Sounds good.

Quoted 7 lines
Quoted 6 lines
Documentation/userspace-api/iommu.rst new file +5 -0
+whether it's correct and sufficient for the requested operation.
+
+Compatibility Checking
+----------------------
+When IOMMU UAPI extension results in size increase, IOMMU UAPI

core

in some structure size increase, the IOMMU UAPI code

Better

Quoted 10 lines
Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +4 -0
+and vendor driver shall handle the following cases:
+
+1. User and kernel has exact size match
+2. An older user with older kernel header (smaller UAPI size)

running on a

Documentation/userspace-api/iommu.rst new file +4 -0
+   newer kernel (larger UAPI size)
+3. A newer user with newer kernel header (larger UAPI size) running
+   on an older kernel.
+4. A malicious/misbehaving user pass illegal/invalid size but

within

Quoted 8 lines
Quoted 7 lines
Documentation/userspace-api/iommu.rst new file +4 -0
+   range. The data may contain garbage.> +
+Feature Checking
+----------------
+While launching a guest with vIOMMU, it is important to ensure

that host +can support the UAPI data structures to be used for vIOMMU-pIOMMU +communications. Without upfront compatibility checking, future faults

s/faults/failures?

Indeed, failure means "External behavior is incorrect" according to IEEE. VMM and user app are external to kernel.

Quoted 6 lines
Quoted 5 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+are difficult to report even in normal conditions. For example, TLB
+invalidations should always succeed. There is no architectural way

to +report back to the vIOMMU if the UAPI data is incompatible. If that +happens, in order to protect IOMMU iosolation guarantee, we have to

in order to guarantee IOMMU isOlation

Sounds good.

Quoted 8 lines
Quoted 2 lines

+resort to not giving completion status in vIOMMU. This may result in +VM hang.

Why not simply saying a capability getter is offered to discover the feature support and potential API incompatibility support at an early stage. Detecting this later, when performing the actual cache/descriptor handling operations appears to be tricky and difficult to escalate to the guest.

I just wanted to give a specific scenario that could result in hang. I will add this as a general statement.

Quoted 11 lines

Documentation/userspace-api/iommu.rst line 96

Quoted 7 lines
Documentation/userspace-api/iommu.rst new file +7 -0
+
+For this reason the following IOMMU UAPIs cannot fail:
+
+1. Free PASID
+2. Unbind guest PASID
+3. Unbind guest PASID table (SMMU)
+4. Cache invalidate  

hum practically iommu_uapi_sva_unbind_gpasid return an int though (see below). So it sounds a bit misleading. What cannot fail?

Perhaps I should say it cannot fail w/o catastrophic effect. If unbind_gpasid fail, the PASID cache invalidation cannot complete.

Quoted 33 lines
Quoted 33 lines
Documentation/userspace-api/iommu.rst new file +4 -0
+
+User applications such as QEMU are expected to import kernel UAPI
+headers. Backward compatibility is supported per feature flags.
+For example, an older QEMU (with older kernel header) can run on

newer +kernel. Newer QEMU (with new kernel header) may refuse to initialize +on an older kernel if new feature flags are not supported by older +kernel. Simply recompiling existing code with newer kernel header should +not be an issue in that only existing flags are used. +

Documentation/userspace-api/iommu.rst new file +10 -0
+IOMMU vendor driver should report the below features to IOMMU UAPI
+consumers (e.g. via VFIO).
+
+1. IOMMU_NESTING_FEAT_SYSWIDE_PASID
+2. IOMMU_NESTING_FEAT_BIND_PGTBL
+3. IOMMU_NESTING_FEAT_BIND_PASID_TABLE
+4. IOMMU_NESTING_FEAT_CACHE_INVLD
+5. IOMMU_NESTING_FEAT_PAGE_REQUEST
+
+Take VFIO as example, upon request from VFIO user space (e.g.

QEMU), +VFIO kernel code shall query IOMMU vendor driver for the support of +the above features. Query result can then be reported back to the +user-space caller. Details can be found in

Documentation/userspace-api/iommu.rst new file +8 -0
+Documentation/driver-api/vfio.rst.
+
+
+Data Passing Example with VFIO
+------------------------------
+As the ubiquitous userspace driver framework, VFIO is already IOMMU
+aware and shares many key concepts such as device model, group, and
+protection domain. Other user driver frameworks can also be

extended +to support IOMMU UAPI but it is outside the scope of this document. +
+In this tight-knit VFIO-IOMMU interface, the ultimate consumer of

Quoted 9 lines
Quoted 6 lines

the +IOMMU UAPI data is the host IOMMU driver. VFIO facilitates user-kernel +transport, capability checking, security, and life cycle management of +process address space ID (PASID).

Documentation/userspace-api/iommu.rst new file +2 -0
+
+Unlike normal user data passed via VFIO UAPI IOTCL, IOMMU driver

is the +ultimate consumer of its UAPI data.

I don't really get this. Part of the VFIO API already mediates info towards the IOMMU driver, no?

Here is the first time VFIO passes user pointer to IOMMU, AFAIK. I just wanted to call out the two layers.

Quoted 19 lines

At VFIO layer, the IOMMU UAPI data

Quoted 18 lines
Documentation/userspace-api/iommu.rst new file +11 -0
+is wrapped in a VFIO UAPI data. It follows the
+pattern below::
+
+   struct {
+	__u32 argsz;
+	__u32 flags;
+	__u8  data[];
+   };
+
+Here data[] contains the IOMMU UAPI data structures. VFIO has the
+freedom to bundle the data as well as parse data size based on its

own flags. +
+In order to determine the size and feature set of the user data, argsz +and flags are also embedded in the IOMMU UAPI data structures. +A "__u32 argsz" field is *always* at the beginning of each structure. +
+For example:
+::

Quoted 8 lines

Documentation/userspace-api/iommu.rst line 158

Quoted 5 lines
Documentation/userspace-api/iommu.rst new file +5 -0
+
+   struct iommu_cache_invalidate_info {
+	__u32	argsz;
+	#define IOMMU_CACHE_INVALIDATE_INFO_VERSION_1 1
+	__u32	version;  

there is no flags field in this struct, as opposed to what I can understand from "argsz and flags are also embedded in the IOMMU UAPI data structures"

Good point, I didn't mean literal "flags", cache and granu are flags in reality. Let me clarify as "flags or the equivalent"

Quoted 12 lines
Quoted 12 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+	/* IOMMU paging structure cache */
+	#define IOMMU_CACHE_INV_TYPE_IOTLB	(1 << 0) /*

IOMMU IOTLB */

Documentation/userspace-api/iommu.rst new file +1 -0
+	#define IOMMU_CACHE_INV_TYPE_DEV_IOTLB	(1 << 1) /*

Device IOTLB */

Documentation/userspace-api/iommu.rst new file +1 -0
+	#define IOMMU_CACHE_INV_TYPE_PASID	(1 << 2) /*

PASID cache */

Documentation/userspace-api/iommu.rst new file +5 -0
+	#define IOMMU_CACHE_INV_TYPE_NR		(3)
+	__u8	cache;
+	__u8	granularity;
+	__u8	padding[6];
+	union {
Quoted 8 lines
Quoted 7 lines
Documentation/userspace-api/iommu.rst new file +6 -0
+		struct iommu_inv_pasid_info pasid_info;
+		struct iommu_inv_addr_info addr_info;
+	} granu;
+   };
+
+VFIO is responsible for checking its own argsz and flags then

invokes

s/flags then invokes/flags. It then invokes

Sounds good.

Quoted 4 lines
Quoted 1 line

+appropriate IOMMU UAPI functions. User pointer is passed to IOMMU

the appropriate... I would say *The* user pointer is passed to *the* IOMMU, here and at many places in the doc. But I would prefer a native english speaker confirms.

I agree. These are the specific user pointers in the VFIO structures.

Quoted 16 lines
Quoted 16 lines
Documentation/userspace-api/iommu.rst new file +16 -0
+layer for further processing. The responsibilities are divided as
+follows:
+
+- Generic IOMMU layer checks argsz range based on UAPI data in the
+  current kernel version
+
+- Generic IOMMU layer checks content of the UAPI data for non-zero
+  reserved bits in flags, padding fields, and unsupported version.
+  This is to ensure not breaking userspace in the future when these
+  fields or flags are used.
+
+- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data
+  is consumed based on flags. Vendor driver has access to
+  unadulterated argsz value in case of vendor specific future
+  extensions.
+
Quoted 8 lines
Quoted 3 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+To illustrate the two cases with and without vendor data, cache
+invalidation and bind guest PASID are given as examples

respectively.

I am not sure duplicating the code here is necessary. I think when the code gets upstream, it becomes the example to follow. The above description can help in understanding why such checks are there and I would stop here, personally.

I am torn between the choices here also. Having examples also helps. I am OK to stop here also.

Anyone else has an opinion?

Quoted 158 lines
Quoted 158 lines
Documentation/userspace-api/iommu.rst new file +7 -0
+
+Example 1: Guest issues IOTLB invalidation, all guest provided data
+are generic. Vendor driver does not need to check argsz.
+
+::
+
+ static int iommu_check_cache_invl_data(struct

iommu_cache_invalidate_info *info)
+ {

Documentation/userspace-api/iommu.rst new file +42 -0
+	u32 mask;
+
+	if (info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+		return -EINVAL;
+
+	mask = (1 << IOMMU_CACHE_INV_TYPE_NR) - 1;
+	if (info->cache & ~mask)
+		return -EINVAL;
+
+	if (info->granularity >= IOMMU_INV_GRANU_NR)
+		return -EINVAL;
+
+	switch (info->granularity) {
+	case IOMMU_INV_GRANU_ADDR:
+		mask = IOMMU_INV_ADDR_FLAGS_PASID |
+			IOMMU_INV_ADDR_FLAGS_ARCHID |
+			IOMMU_INV_ADDR_FLAGS_LEAF;
+
+		if (info->granu.addr_info.flags & ~mask)
+			return -EINVAL;
+		break;
+	case IOMMU_INV_GRANU_PASID:
+		mask = IOMMU_INV_PASID_FLAGS_PASID |
+			IOMMU_INV_PASID_FLAGS_ARCHID;
+		if (info->granu.pasid_info.flags & ~mask)
+			return -EINVAL;
+
+		break;
+	case IOMMU_INV_GRANU_DOMAIN:
+		/* No flags to check */
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (info->padding[0] || info->padding[1])
+		return -EINVAL;
+
+	return 0;
+ }
+
+ int iommu_cache_invalidate(struct iommu_domain *domain, struct

device *dev,

Documentation/userspace-api/iommu.rst new file +10 -0
+			   void __user *uinfo)
+ {
+	struct iommu_cache_invalidate_info inv_info = { 0 };
+	u32 minsz, maxsz;
+	int ret = 0;
+
+	if (unlikely(!domain->ops->cache_invalidate))
+		return -ENODEV;
+
+	/* Current kernel data size is the max to be copied from

user */

Documentation/userspace-api/iommu.rst new file +4 -0
+	maxsz = sizeof(struct iommu_cache_invalidate_info);
+
+	/*
+	 * No new spaces can be added before the variable sized

union, the

Documentation/userspace-api/iommu.rst new file +3 -0
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_cache_invalidate_info,

granu); +

Documentation/userspace-api/iommu.rst new file +9 -0
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(&inv_info, uinfo, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (inv_info.argsz < minsz)
+		return -EINVAL;
+
+	/* PASID and address granu requires additional info beyond

minsz */

Documentation/userspace-api/iommu.rst new file +3 -0
+	if (inv_info.argsz == minsz &&
+		((inv_info.granularity == IOMMU_INV_GRANU_PASID) ||
+			(inv_info.granularity ==

IOMMU_INV_GRANU_ADDR)))

Documentation/userspace-api/iommu.rst new file +3 -0
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header which has a

larger data

Documentation/userspace-api/iommu.rst new file +1 -0
+	 * size, we shall support the existing flags within the

current

Documentation/userspace-api/iommu.rst new file +1 -0
+	 * size. Copy the remaining user data _after_ minsz but

not more

Documentation/userspace-api/iommu.rst new file +3 -0
+	 * than the current kernel supported size.
+	 */
+	if (copy_from_user((void *)&inv_info + minsz, uinfo +

minsz,

Documentation/userspace-api/iommu.rst new file +1 -0
+				min(inv_info.argsz, maxsz) -

minsz))

Documentation/userspace-api/iommu.rst new file +8 -0
+		return -EFAULT;
+
+	/* Now the argsz is validated, check the content */
+	ret = iommu_check_cache_invl_data(&inv_info);
+	if (ret)
+		return ret;
+
+	return domain->ops->cache_invalidate(domain, dev,

&inv_info);
+ }
+ EXPORT_SYMBOL_GPL(iommu_cache_invalidate);

Documentation/userspace-api/iommu.rst new file +5 -0
+
+
+Example 2: Bind guest PASID which includes vendor specific data.
+The IOMMU core processing of UAPI data follows the same flow as
+Example 1. Vendor driver handles the additional vendor specific

flags +as in VT-d driver below:

Documentation/userspace-api/iommu.rst new file +4 -0
+
+::
+
+ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct

device *dev,

Documentation/userspace-api/iommu.rst new file +15 -0
+			  struct iommu_gpasid_bind_data *data)
+ {
+	struct intel_iommu *iommu = intel_svm_device_to_iommu(dev);
+	struct dmar_domain *dmar_domain;
+	struct intel_svm_dev *sdev;
+	struct intel_svm *svm;
+	int ret = 0;
+
+	if (WARN_ON(!iommu) || !data)
+		return -EINVAL;
+
+	if (data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+		return -EINVAL;
+
+	/* IOMMU core ensures argsz is more than the start of the

union */

Documentation/userspace-api/iommu.rst new file +1 -0
+	if (data->argsz < offsetofend(struct

iommu_gpasid_bind_data,

Documentation/userspace-api/iommu.rst new file +9 -0
+            vendor.vtd))
+		return -EINVAL;
+   ...
+ }
+
+
+Sharing UAPI with in-kernel users
+---------------------------------
+For UAPIs that are shared with in-kernel users, a wrapper function

is +provided to distinguish the callers. For example,

Documentation/userspace-api/iommu.rst new file +8 -0
+
+Userspace caller ::
+
+  int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,
+                                   struct device *dev,
+                                   void __user *udata)
+
+In-kernel caller ::
Quoted 9 lines
Quoted 6 lines
Documentation/userspace-api/iommu.rst new file +4 -0
+
+  int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
+                                   struct device *dev,
+                                   struct iommu_gpasid_bind_data

*data)
Hope this helps. If some of my comments drive you in an opposite

direction of what was said earlier, please feel free to ignore them ;-)

Yes, thanks a lot for your review.

Quoted 4 lines

Thanks

Eric

[Jacob Pan]
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu

author
#5 lore raw

Re: [PATCH v5 1/5] docs: IOMMU user API

In reply to Alex Williamson
Quoted 248 lines · On Fri, 17 Jul 2020 13:37:25 -0600 Alex Williamson…
Quoted 230 lines · On Thu, 16 Jul 2020 11:45:13 -0700 Jacob Pan <[email protected]>…

IOMMU UAPI is newly introduced to support communications between guest virtual IOMMU and host IOMMU. There has been lots of discussions on how it should work with VFIO UAPI and userspace in general.

This document is indended to clarify the UAPI design and usage. The mechanics of how future extensions should be achieved are also covered in this documentation.

---
 Documentation/userspace-api/iommu.rst | 339
++++++++++++++++++++++++++++++++++ 1 file changed, 339 insertions(+)
 create mode 100644 Documentation/userspace-api/iommu.rst
(quoted diff) +0 -0

b/Documentation/userspace-api/iommu.rst new file mode 100644 index 000000000000..efc3e1838235

Documentation/userspace-api/iommu.rst new file +8 -0
@@ -0,0 +1,339 @@
+.. SPDX-License-Identifier: GPL-2.0
+.. iommu:
+
+=====================================
+IOMMU Userspace API
+=====================================
+
+IOMMU UAPI is used for virtualization cases where communications

are +needed between physical and virtual IOMMU drivers. For native

Documentation/userspace-api/iommu.rst new file +5 -0
+usage, IOMMU is a system device which does not need to communicate
+with user space directly.
+
+The primary use cases are guest Shared Virtual Address (SVA) and
+guest IO virtual address (IOVA), wherein a virtual IOMMU (vIOMMU)

is +required to communicate with the physical IOMMU in the host.

Documentation/userspace-api/iommu.rst new file +26 -0
+
+.. contents:: :local:
+
+Functionalities
+===============
+Communications of user and kernel involve both directions. The
+supported user-kernel APIs are as follows:
+
+1. Alloc/Free PASID
+2. Bind/unbind guest PASID (e.g. Intel VT-d)
+3. Bind/unbind guest PASID table (e.g. ARM sMMU)
+4. Invalidate IOMMU caches
+5. Service IO page faults (page request and response)
+
+Requirements
+============
+The IOMMU UAPIs are generic and extensible to meet the following
+requirements:
+
+1. Emulated and para-virtualised vIOMMUs
+2. Multiple vendors (Intel VT-d, ARM sMMU, etc.)
+3. Extensions to the UAPI shall not break existing user space
+
+Interfaces
+==========
+Although the data structures defined in IOMMU UAPI are

self-contained, +there is no user API functions introduced. Instead, IOMMU UAPI is +designed to work with existing user driver frameworks such as VFIO. +

Documentation/userspace-api/iommu.rst new file +6 -0
+Extension Rules & Precautions
+-----------------------------
+When IOMMU UAPI gets extended, the data structures can *only* be
+modified in two ways:
+
+1. Adding new fields by re-purposing the padding[] field. No size

change. +2. Adding new union members at the end. May increase in size. +
+No new fields can be added *after* the variable sized union in that it +will break backward compatibility when offset moves. In both cases, a +new flag must be accompanied with a new field such that the IOMMU +driver can process the data based on the new flag. Version field is +only reserved for the unlikely event of UAPI upgrade at its entirety. +
+It's *always* the caller's responsibility to indicate the size of the +structure passed by setting argsz appropriately.

Documentation/userspace-api/iommu.rst new file +3 -0
+Though at the same time, argsz is user provided data which is not
+trusted. The argsz field allows the user to indicate how much data
+they're providing, it's still the kernel's responsibility to

validate +whether it's correct and sufficient for the requested operation. +

Documentation/userspace-api/iommu.rst new file +7 -0
+Compatibility Checking
+----------------------
+When IOMMU UAPI extension results in size increase, IOMMU UAPI core
+and vendor driver shall handle the following cases:
+
+1. User and kernel has exact size match
+2. An older user with older kernel header (smaller UAPI size)

running on a

Documentation/userspace-api/iommu.rst new file +4 -0
+   newer kernel (larger UAPI size)
+3. A newer user with newer kernel header (larger UAPI size) running
+   on an older kernel.
+4. A malicious/misbehaving user pass illegal/invalid size but

within

Documentation/userspace-api/iommu.rst new file +5 -0
+   range. The data may contain garbage.
+
+Feature Checking
+----------------
+While launching a guest with vIOMMU, it is important to ensure

that host +can support the UAPI data structures to be used for vIOMMU-pIOMMU +communications. Without upfront compatibility checking, future faults +are difficult to report even in normal conditions. For example, TLB +invalidations should always succeed. There is no architectural way to +report back to the vIOMMU if the UAPI data is incompatible. If that +happens, in order to protect IOMMU iosolation guarantee, we have to +resort to not giving completion status in vIOMMU. This may result in +VM hang.

Documentation/userspace-api/iommu.rst new file +11 -0
+
+For this reason the following IOMMU UAPIs cannot fail:
+
+1. Free PASID
+2. Unbind guest PASID
+3. Unbind guest PASID table (SMMU)
+4. Cache invalidate
+
+User applications such as QEMU are expected to import kernel UAPI
+headers. Backward compatibility is supported per feature flags.
+For example, an older QEMU (with older kernel header) can run on

newer +kernel. Newer QEMU (with new kernel header) may refuse to initialize +on an older kernel if new feature flags are not supported by older +kernel. Simply recompiling existing code with newer kernel header should +not be an issue in that only existing flags are used. +

Documentation/userspace-api/iommu.rst new file +10 -0
+IOMMU vendor driver should report the below features to IOMMU UAPI
+consumers (e.g. via VFIO).
+
+1. IOMMU_NESTING_FEAT_SYSWIDE_PASID
+2. IOMMU_NESTING_FEAT_BIND_PGTBL
+3. IOMMU_NESTING_FEAT_BIND_PASID_TABLE
+4. IOMMU_NESTING_FEAT_CACHE_INVLD
+5. IOMMU_NESTING_FEAT_PAGE_REQUEST
+
+Take VFIO as example, upon request from VFIO user space (e.g.

QEMU), +VFIO kernel code shall query IOMMU vendor driver for the support of +the above features. Query result can then be reported back to the +user-space caller. Details can be found in

Documentation/userspace-api/iommu.rst new file +8 -0
+Documentation/driver-api/vfio.rst.
+
+
+Data Passing Example with VFIO
+------------------------------
+As the ubiquitous userspace driver framework, VFIO is already IOMMU
+aware and shares many key concepts such as device model, group, and
+protection domain. Other user driver frameworks can also be

extended +to support IOMMU UAPI but it is outside the scope of this document. +
+In this tight-knit VFIO-IOMMU interface, the ultimate consumer of the +IOMMU UAPI data is the host IOMMU driver. VFIO facilitates user-kernel +transport, capability checking, security, and life cycle management of +process address space ID (PASID).

Documentation/userspace-api/iommu.rst new file +2 -0
+
+Unlike normal user data passed via VFIO UAPI IOTCL, IOMMU driver

is the +ultimate consumer of its UAPI data. At VFIO layer, the IOMMU UAPI data +is wrapped in a VFIO UAPI data. It follows the

Documentation/userspace-api/iommu.rst new file +10 -0
+pattern below::
+
+   struct {
+	__u32 argsz;
+	__u32 flags;
+	__u8  data[];
+   };
+
+Here data[] contains the IOMMU UAPI data structures. VFIO has the
+freedom to bundle the data as well as parse data size based on its

own flags. +
+In order to determine the size and feature set of the user data, argsz +and flags are also embedded in the IOMMU UAPI data structures. +A "__u32 argsz" field is *always* at the beginning of each structure. +

Documentation/userspace-api/iommu.rst new file +9 -0
+For example:
+::
+
+   struct iommu_cache_invalidate_info {
+	__u32	argsz;
+	#define IOMMU_CACHE_INVALIDATE_INFO_VERSION_1 1
+	__u32	version;
+	/* IOMMU paging structure cache */
+	#define IOMMU_CACHE_INV_TYPE_IOTLB	(1 << 0) /*

IOMMU IOTLB */

Documentation/userspace-api/iommu.rst new file +1 -0
+	#define IOMMU_CACHE_INV_TYPE_DEV_IOTLB	(1 << 1) /*

Device IOTLB */

Documentation/userspace-api/iommu.rst new file +1 -0
+	#define IOMMU_CACHE_INV_TYPE_PASID	(1 << 2) /*

PASID cache */

Documentation/userspace-api/iommu.rst new file +11 -0
+	#define IOMMU_CACHE_INV_TYPE_NR		(3)
+	__u8	cache;
+	__u8	granularity;
+	__u8	padding[6];
+	union {
+		struct iommu_inv_pasid_info pasid_info;
+		struct iommu_inv_addr_info addr_info;
+	} granu;
+   };
+
+VFIO is responsible for checking its own argsz and flags then

invokes +appropriate IOMMU UAPI functions. User pointer is passed to IOMMU +layer for further processing. The responsibilities are divided as +follows:

Documentation/userspace-api/iommu.rst new file +16 -0
+
+- Generic IOMMU layer checks argsz range based on UAPI data in the
+  current kernel version
+
+- Generic IOMMU layer checks content of the UAPI data for non-zero
+  reserved bits in flags, padding fields, and unsupported version.
+  This is to ensure not breaking userspace in the future when these
+  fields or flags are used.
+
+- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data
+  is consumed based on flags. Vendor driver has access to
+  unadulterated argsz value in case of vendor specific future
+  extensions.
+
+To illustrate the two cases with and without vendor data, cache
+invalidation and bind guest PASID are given as examples

respectively. +

Documentation/userspace-api/iommu.rst new file +6 -0
+Example 1: Guest issues IOTLB invalidation, all guest provided data
+are generic. Vendor driver does not need to check argsz.
+
+::
+
+ static int iommu_check_cache_invl_data(struct

iommu_cache_invalidate_info *info)
+ {

Documentation/userspace-api/iommu.rst new file +2 -0
+	u32 mask;
+

Documentation/userspace-api/iommu.rst line 212

Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10 -0
+	if (info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+		return -EINVAL;
+
+	mask = (1 << IOMMU_CACHE_INV_TYPE_NR) - 1;
+	if (info->cache & ~mask)
+		return -EINVAL;
+
+	if (info->granularity >= IOMMU_INV_GRANU_NR)
+		return -EINVAL;
+  

The table defining valid cache/granularity combinations specifically indicates the following are not available:

Quoted 5 lines

IOMMU_INV_GRANU_DOMAIN + IOMMU_CACHE_INV_TYPE_DEV_IOTLB IOMMU_INV_GRANU_ADDR + IOMMU_CACHE_INV_TYPE_PASID

So shouldn't we also have the following rejected?

Yes, we should reject in the IOMMU core since it will be true for all vendors. Currently it is rejected in the VT-d driver when it does generic to vendor conversion. I am assuming the similar for others.

Quoted 6 lines

Documentation/userspace-api/iommu.rst line 214

Quoted 2 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+	switch (info->granularity) {
+	case IOMMU_INV_GRANU_ADDR:  
		if (info->cache & IOMMU_CACHE_INV_TYPE_PASID)
			return -EINVAL;

got it.

Quoted 11 lines
Quoted 11 lines
Documentation/userspace-api/iommu.rst new file +11 -0
+		mask = IOMMU_INV_ADDR_FLAGS_PASID |
+			IOMMU_INV_ADDR_FLAGS_ARCHID |
+			IOMMU_INV_ADDR_FLAGS_LEAF;
+
+		if (info->granu.addr_info.flags & ~mask)
+			return -EINVAL;
+		break;
+	case IOMMU_INV_GRANU_PASID:
+		mask = IOMMU_INV_PASID_FLAGS_PASID |
+			IOMMU_INV_PASID_FLAGS_ARCHID;
+		if (info->granu.pasid_info.flags & ~mask)
Quoted 9 lines

Documentation/userspace-api/iommu.rst line 230

Quoted 5 lines
Documentation/userspace-api/iommu.rst new file +5 -0
+			return -EINVAL;
+
+		break;
+	case IOMMU_INV_GRANU_DOMAIN:
+		/* No flags to check */  
		if (info->cache & IOMMU_CACHE_INV_TYPE_DEV_IOTLB)
			return -EINVAL;

got it.

Quoted 8 lines

Documentation/userspace-api/iommu.rst line 236

Quoted 6 lines
Documentation/userspace-api/iommu.rst new file +6 -0
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (info->padding[0] || info->padding[1])  

More padding bytes to test now.

Good catch! I missed the bind data also.

Quoted 37 lines
Quoted 37 lines
Documentation/userspace-api/iommu.rst new file +6 -0
+		return -EINVAL;
+
+	return 0;
+ }
+
+ int iommu_cache_invalidate(struct iommu_domain *domain, struct

device *dev,

Documentation/userspace-api/iommu.rst new file +10 -0
+			   void __user *uinfo)
+ {
+	struct iommu_cache_invalidate_info inv_info = { 0 };
+	u32 minsz, maxsz;
+	int ret = 0;
+
+	if (unlikely(!domain->ops->cache_invalidate))
+		return -ENODEV;
+
+	/* Current kernel data size is the max to be copied from

user */

Documentation/userspace-api/iommu.rst new file +4 -0
+	maxsz = sizeof(struct iommu_cache_invalidate_info);
+
+	/*
+	 * No new spaces can be added before the variable sized

union, the

Documentation/userspace-api/iommu.rst new file +3 -0
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_cache_invalidate_info,

granu); +

Documentation/userspace-api/iommu.rst new file +9 -0
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(&inv_info, uinfo, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (inv_info.argsz < minsz)
+		return -EINVAL;
+
+	/* PASID and address granu requires additional info beyond
Quoted 8 lines

Documentation/userspace-api/iommu.rst

Quoted 6 lines

minsz */

Documentation/userspace-api/iommu.rst new file +3 -0
+	if (inv_info.argsz == minsz &&
+		((inv_info.granularity == IOMMU_INV_GRANU_PASID) ||
+			(inv_info.granularity ==

IOMMU_INV_GRANU_ADDR)))

Documentation/userspace-api/iommu.rst new file +1 -0
+		return -EINVAL;  

We only validated that argsz is at least (minsz + 1).

Yes, I think we can check if argsz is sufficient for each granu. i.e. replace the above check with:

	if ((inv_info.granularity == IOMMU_INV_GRANU_PASID) &&
		inv_info.argsz < offsetofend(struct iommu_cache_invalidate_info, granu.pasid_info))
		return -EINVAL;

	if ((inv_info.granularity == IOMMU_INV_GRANU_ADDR) &&
		inv_info.argsz < offsetofend(struct iommu_cache_invalidate_info, granu.addr_info))
		return -EINVAL;
Quoted 18 lines
Quoted 14 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+	/*
+	 * User might be using a newer UAPI header which has a

larger data

Documentation/userspace-api/iommu.rst new file +1 -0
+	 * size, we shall support the existing flags within the

current

Documentation/userspace-api/iommu.rst new file +1 -0
+	 * size. Copy the remaining user data _after_ minsz but

not more

Documentation/userspace-api/iommu.rst new file +3 -0
+	 * than the current kernel supported size.
+	 */
+	if (copy_from_user((void *)&inv_info + minsz, uinfo +

minsz,

Documentation/userspace-api/iommu.rst new file +1 -0
+				min(inv_info.argsz, maxsz) -

minsz))

Documentation/userspace-api/iommu.rst line 284

Quoted 3 lines
Documentation/userspace-api/iommu.rst new file +3 -0
+		return -EFAULT;
+
+	/* Now the argsz is validated, check the content */  
Quoted 8 lines

If we want to assert that IOMMU_INV_GRANU_PASID requires a struct iommu_inv_pasid_info and IOMMU_INV_GRANU_ADDR requires a struct iommu_inv_addr_info, then we've done a pretty poor job of validating argsz against that. Do you want the switch in iommu_check_cache_invl_data() to also check info->argsz in the pasid and addr cases? If so, we could always copy min(argsz, sizeof) and remove the previous check.

Yes, make sense. I think my reply in the previous comment addresses this idea. Right?

Quoted 37 lines
Quoted 37 lines
Documentation/userspace-api/iommu.rst new file +5 -0
+	ret = iommu_check_cache_invl_data(&inv_info);
+	if (ret)
+		return ret;
+
+	return domain->ops->cache_invalidate(domain, dev,

&inv_info);
+ }
+ EXPORT_SYMBOL_GPL(iommu_cache_invalidate);

Documentation/userspace-api/iommu.rst new file +5 -0
+
+
+Example 2: Bind guest PASID which includes vendor specific data.
+The IOMMU core processing of UAPI data follows the same flow as
+Example 1. Vendor driver handles the additional vendor specific

flags +as in VT-d driver below:

Documentation/userspace-api/iommu.rst new file +4 -0
+
+::
+
+ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct

device *dev,

Documentation/userspace-api/iommu.rst new file +15 -0
+			  struct iommu_gpasid_bind_data *data)
+ {
+	struct intel_iommu *iommu = intel_svm_device_to_iommu(dev);
+	struct dmar_domain *dmar_domain;
+	struct intel_svm_dev *sdev;
+	struct intel_svm *svm;
+	int ret = 0;
+
+	if (WARN_ON(!iommu) || !data)
+		return -EINVAL;
+
+	if (data->format != IOMMU_PASID_FORMAT_INTEL_VTD)
+		return -EINVAL;
+
+	/* IOMMU core ensures argsz is more than the start of the

union */

Documentation/userspace-api/iommu.rst new file +1 -0
+	if (data->argsz < offsetofend(struct

iommu_gpasid_bind_data,

Quoted 9 lines

Documentation/userspace-api/iommu.rst line 319

Quoted 2 lines
Documentation/userspace-api/iommu.rst new file +2 -0
+            vendor.vtd))
+		return -EINVAL;  

So at this point the vendor driver assumes the core has copied min(argsz, sizeof(uapi struct)) and it only needs to validate, not perform the copy itself (until we get to some future scenario where there's vendor data outside of the structure definition and we'll need to provide a __user pointer for the vendor driver to fetch it).

Yes, that is my understanding as well. I will add this statement in the doc where vendor driver's responsibility is laid out. How about the following?

"- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data
is consumed based on flags. Vendor driver has access to unadulterated argsz value in case of vendor specific future extensions. Currently, it does not perform the copy_from_user() itself. A __user pointer can be provided in some future scenarios where there's vendor data outside of the structure definition."

Quoted 19 lines
Quoted 19 lines
Documentation/userspace-api/iommu.rst new file +7 -0
+   ...
+ }
+
+
+Sharing UAPI with in-kernel users
+---------------------------------
+For UAPIs that are shared with in-kernel users, a wrapper function

is +provided to distinguish the callers. For example,

Documentation/userspace-api/iommu.rst new file +11 -0
+
+Userspace caller ::
+
+  int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,
+                                   struct device *dev,
+                                   void __user *udata)
+
+In-kernel caller ::
+
+  int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
+                                   struct device *dev,
Quoted 9 lines
Quoted 2 lines

+ struct iommu_gpasid_bind_data
*data)

Shouldn't we start that precedent with the iommu_cache_invalidate() example above? The "that are shared with in-kernel users" qualifier doesn't really make sense to me, then we'll have uapi functions named as if they're in-kernel just because there isn't an in-kernel user yet. That's inconsistency that'll get us into trouble. Thanks,

If understand correctly, you are suggesting we name all UAPI functions with iommu_uapi_ prefix regardless there are any in-kernel counterpart. Right? I agree. This will name naming consistent.

i.e.
iommu_uapi_cache_invalidate()
iommu_uapi_page_response()

Thanks a lot,

Jacob

Quoted 2 lines

Alex

[Jacob Pan]

author
#8 lore raw

Re: [PATCH v5 2/5] iommu/uapi: Add argsz for user filled data

In reply to Auger Eric
Quoted 24 lines · On Fri, 17 Jul 2020 15:44:23 +0200 Auger Eric <[email protected]> wrote:

Hi Jacob,

Quoted 21 lines · Jacob Pan

As IOMMU UAPI gets extended, user data size may increase. To support backward compatibiliy, this patch introduces a size field to each UAPI data structures. It is *always* the responsibility for the user to fill in the correct size. Padding fields are adjusted to ensure 8 byte alignment.

Specific scenarios for user data handling are documented in:
Documentation/userspace-api/iommu.rst

---
 include/uapi/linux/iommu.h | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)
include/uapi/linux/iommu.h +0 -0
index e907b7091a46..d5e9014f690e 100644
@@ -135,6 +135,7 @@ enum iommu_page_response_code {
 
Quoted 13 lines

include/uapi/linux/iommu.h enum iommu_page_response_code { · line 148

Quoted 12 lines
include/uapi/linux/iommu.h +2 -0
 /**
  * struct iommu_page_response - Generic page response information
+ * @argsz: User filled size of this data
  * @version: API version of this structure
  * @flags: encodes whether the corresponding fields are valid
  *         (IOMMU_FAULT_PAGE_RESPONSE_* values)
@@ -143,6 +144,7 @@ enum iommu_page_response_code {
  * @code: response code from &enum iommu_page_response_code
  */
 struct iommu_page_response {
+	__u32	argsz;
 #define IOMMU_PAGE_RESP_VERSION_1	1  

Don't you need to incr the version for all the modified structs?

not literal "flags" but @cache and @granularity are flags in reality. I think that is OK. I also updated document to say "flags or equivalent".

Quoted 63 lines
Quoted 16 lines
include/uapi/linux/iommu.h +0 -0
 	__u32	version;
 #define IOMMU_PAGE_RESP_PASID_VALID	(1 << 0)
@@ -218,6 +220,7 @@ struct iommu_inv_pasid_info {
 /**
  * struct iommu_cache_invalidate_info - First level/stage

invalidation
* information
+ * @argsz: User filled size of this data
* @version: API version of this structure
* @cache: bitfield that allows to select which caches to
invalidate
* @granularity: defines the lowest granularity used for the
invalidation: @@ -246,6 +249,7 @@ struct iommu_inv_pasid_info {
* must support the used granularity.
*/
struct iommu_cache_invalidate_info {

include/uapi/linux/iommu.h struct iommu_inv_pasid_info { · line 254

Quoted 3 lines
include/uapi/linux/iommu.h +1 -0
+	__u32	argsz;
 #define IOMMU_CACHE_INVALIDATE_INFO_VERSION_1 1
 	__u32	version;  

so there is no "flags" field in this struct. Is it OK?

Quoted 31 lines

/* IOMMU paging structure cache */

include/uapi/linux/iommu.h +1 -1
@@ -255,7 +259,7 @@ struct iommu_cache_invalidate_info {
 #define IOMMU_CACHE_INV_TYPE_NR		(3)
 	__u8	cache;
 	__u8	granularity;
-	__u8	padding[2];
+	__u8	padding[6];
 	union {
 		struct iommu_inv_pasid_info pasid_info;
 		struct iommu_inv_addr_info addr_info;
@@ -292,6 +296,7 @@ struct iommu_gpasid_bind_data_vtd {
 
 /**
  * struct iommu_gpasid_bind_data - Information about device and

guest PASID binding
+ * @argsz: User filled size of this data
* @version: Version of this data structure
* @format: PASID table entry format
* @flags: Additional information on guest bind request

include/uapi/linux/iommu.h +2 -0
@@ -309,17 +314,18 @@ struct iommu_gpasid_bind_data_vtd {
  * PASID to host PASID based on this bind data.
  */
 struct iommu_gpasid_bind_data {
+	__u32 argsz;
 #define IOMMU_GPASID_BIND_VERSION_1	1
 	__u32 version;
 #define IOMMU_PASID_FORMAT_INTEL_VTD	1
 	__u32 format;
+	__u32 addr_width;
 #define IOMMU_SVA_GPASID_VAL	(1 << 0) /* guest PASID valid

include/uapi/linux/iommu.h struct iommu_gpasid_bind_data_vtd { · line 331

Quoted 10 lines
include/uapi/linux/iommu.h +1 -2
 */ __u64 flags;
 	__u64 gpgd;
 	__u64 hpasid;
 	__u64 gpasid;
-	__u32 addr_width;
-	__u8  padding[12];
+	__u8  padding[8];
 	/* Vendor specific data */
 	union {
 		struct iommu_gpasid_bind_data_vtd vtd;

Thanks

Quoted 2 lines

Eric

[Jacob Pan]

author
#13 lore raw

Re: [PATCH v5 4/5] iommu/uapi: Handle data and argsz filled by users

In reply to Auger Eric
Quoted 6 lines · On Fri, 17 Jul 2020 17:58:04 +0200 Auger Eric <[email protected]> wrote:

Hi Jacob,
On 7/16/20 8:45 PM, Jacob Pan wrote:

Could you share a branch? I was not able to apply this on either iommu/next or master?

Will push it to github for the next version. This set is based on v5.8-rc1 and my fixes for devTLB.

Quoted 4 lines
Quoted 2 lines

IOMMU UAPI data has a user filled argsz field which indicates the data length comes with the API call.

s/ comes with the API call/ of the structure
User data is not trusted, argsz must be

Sounds good.

Quoted 6 lines
Quoted 5 lines

validated based on the current kernel data size, mandatory data size, and feature flags.

User data may also be extended, results in possible argsz increase.

s/results/resulting

got it.

Quoted 3 lines
Quoted 2 lines

Backward compatibility is ensured based on size and flags checking.

flags is missing in iommu_cache_invalidate_info.

Right, I will rephrase as "flags or the functional equivalent fields"

Quoted 22 lines
Quoted 22 lines

This patch adds sanity checks in the IOMMU layer. In addition to argsz, reserved/unused fields in padding, flags, and version are also checked. Details are documented in Documentation/userspace-api/iommu.rst

---
 drivers/iommu/iommu.c | 192

++++++++++++++++++++++++++++++++++++++++++++++++--
include/linux/iommu.h | 20 ++++-- 2 files changed, 200 insertions(+), 12 deletions(-)

drivers/iommu/iommu.c +0 -0
index d43120eb1dc5..fe30a940d19e 100644
@@ -1950,36 +1950,214 @@ int iommu_attach_device(struct
 iommu_domain *domain, struct device *dev) }
 EXPORT_SYMBOL_GPL(iommu_attach_device);
 
Quoted 4 lines
Quoted 3 lines
drivers/iommu/iommu.c +2 -0
+/*
+ * Check flags and other user privided data for valid

combinations. We also

s/privided/provided

will fix

Quoted 3 lines
Quoted 2 lines

+ * make sure no reserved fields or unused flags are not set. This is to ensure

s/not// ?

right,

Quoted 10 lines
Quoted 9 lines

+ * not breaking userspace in the future when these fields or flags are used.
+ */
+static int iommu_check_cache_invl_data(struct iommu_cache_invalidate_info *info) +{

drivers/iommu/iommu.c +3 -0
+	u32 mask;
+
+	if (info->version !=

IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)

increased version number?

Right now we just support version 1. if we increase the version number in the future, we need to check the current kernel version is newer than the user provided version.
Does it sounds right to you?

Quoted 26 lines
Quoted 26 lines
drivers/iommu/iommu.c +26 -0
+		return -EINVAL;
+
+	mask = (1 << IOMMU_CACHE_INV_TYPE_NR) - 1;
+	if (info->cache & ~mask)
+		return -EINVAL;
+
+	if (info->granularity >= IOMMU_INV_GRANU_NR)
+		return -EINVAL;
+
+	switch (info->granularity) {
+	case IOMMU_INV_GRANU_ADDR:
+		mask = IOMMU_INV_ADDR_FLAGS_PASID |
+			IOMMU_INV_ADDR_FLAGS_ARCHID |
+			IOMMU_INV_ADDR_FLAGS_LEAF;
+
+		if (info->granu.addr_info.flags & ~mask)
+			return -EINVAL;
+		break;
+	case IOMMU_INV_GRANU_PASID:
+		mask = IOMMU_INV_PASID_FLAGS_PASID |
+			IOMMU_INV_PASID_FLAGS_ARCHID;
+		if (info->granu.pasid_info.flags & ~mask)
+			return -EINVAL;
+
+		break;
+	case IOMMU_INV_GRANU_DOMAIN:
Quoted 8 lines

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 1995

Quoted 7 lines
drivers/iommu/iommu.c +7 -0
+		/* No flags to check */
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (info->padding[0] || info->padding[1])  

padding has become "__u8 padding[6];" in 2/5

Good point, will fix

Quoted 35 lines
Quoted 35 lines
drivers/iommu/iommu.c +5 -0
+		return -EINVAL;
+
+	return 0;
+}
+
 int iommu_cache_invalidate(struct iommu_domain *domain, struct

device *dev,

drivers/iommu/iommu.c +0 -1
-			   struct iommu_cache_invalidate_info

*inv_info)

drivers/iommu/iommu.c +5 -1
+			   void __user *uinfo)
 {
+	struct iommu_cache_invalidate_info inv_info = { 0 };
+	u32 minsz, maxsz;
+	int ret = 0;
+
 	if (unlikely(!domain->ops->cache_invalidate))
 		return -ENODEV;
 
-	return domain->ops->cache_invalidate(domain, dev,

inv_info);

drivers/iommu/iommu.c +1 -0
+	/* Current kernel data size is the max to be copied from

user */

drivers/iommu/iommu.c +4 -0
+	maxsz = sizeof(struct iommu_cache_invalidate_info);
+
+	/*
+	 * No new spaces can be added before the variable sized

union, the

drivers/iommu/iommu.c +3 -0
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_cache_invalidate_info,

granu); +

drivers/iommu/iommu.c +3 -0
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(&inv_info, uinfo, minsz))
+		return -EFAULT;
Quoted 8 lines
Quoted 7 lines
drivers/iommu/iommu.c +6 -0
+
+	/* Fields before variable size union is mandatory */
+	if (inv_info.argsz < minsz)
+		return -EINVAL;
+
+	/* PASID and address granu requires additional info beyond

minsz */

s/requires/require

got it.

Quoted 45 lines
Quoted 45 lines
drivers/iommu/iommu.c +3 -0
+	if (inv_info.argsz == minsz &&
+		((inv_info.granularity == IOMMU_INV_GRANU_PASID) ||
+			(inv_info.granularity ==

IOMMU_INV_GRANU_ADDR)))

drivers/iommu/iommu.c +3 -0
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header which has a

larger data

drivers/iommu/iommu.c +1 -0
+	 * size, we shall support the existing flags within the

current

drivers/iommu/iommu.c +1 -0
+	 * size. Copy the remaining user data _after_ minsz but

not more

drivers/iommu/iommu.c +3 -0
+	 * than the current kernel supported size.
+	 */
+	if (copy_from_user((void *)&inv_info + minsz, uinfo +

minsz,

drivers/iommu/iommu.c +1 -0
+				min(inv_info.argsz, maxsz) -

minsz))

drivers/iommu/iommu.c +8 -0
+		return -EFAULT;
+
+	/* Now the argsz is validated, check the content */
+	ret = iommu_check_cache_invl_data(&inv_info);
+	if (ret)
+		return ret;
+
+	return domain->ops->cache_invalidate(domain, dev,

&inv_info); }
EXPORT_SYMBOL_GPL(iommu_cache_invalidate);

drivers/iommu/iommu.c +0 -2
-int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-			   struct device *dev, struct

iommu_gpasid_bind_data *data) +
+static int iommu_check_bind_data(struct iommu_gpasid_bind_data *data) {

drivers/iommu/iommu.c +11 -0
+	u32 mask;
+	int i;
+
+	if (data->version != IOMMU_GPASID_BIND_VERSION_1)
+		return -EINVAL;
+
+	/* Check all supported format, for now just VT-d */
+	mask = IOMMU_PASID_FORMAT_INTEL_VTD;
+	if (data->format & ~mask)
+		return -EINVAL;
+
Quoted 8 lines

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2072

Quoted 7 lines
drivers/iommu/iommu.c +7 -0
+	/* Check all flags */
+	mask = IOMMU_SVA_GPASID_VAL;
+	if (data->flags & ~mask)
+		return -EINVAL;
+
+	/* Check reserved padding fields */
+	for (i = 0; i < 12; i++) {  

now 8

yes, will fix.

Quoted 45 lines
Quoted 45 lines
drivers/iommu/iommu.c +9 -0
+		if (data->padding[i])
+			return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int iommu_sva_prepare_bind_data(void __user *udata,
+				       struct

iommu_gpasid_bind_data *data) +{

drivers/iommu/iommu.c +3 -0
+	u32 minsz, maxsz;
+
+	/* Current kernel data size is the max to be copied from

user */

drivers/iommu/iommu.c +5 -0
+	maxsz = sizeof(struct iommu_gpasid_bind_data);
+	memset((void *)data, 0, maxsz);
+
+	/*
+	 * No new spaces can be added before the variable sized

union, the

drivers/iommu/iommu.c +13 -0
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_gpasid_bind_data, vendor);
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(data, udata, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (data->argsz < minsz)
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header, we shall let

IOMMU vendor

drivers/iommu/iommu.c +1 -0
+	 * driver decide on what size it needs. Since the guest

PASID bind data

drivers/iommu/iommu.c +1 -0
+	 * can be vendor specific, larger argsz could be the

result of extension

drivers/iommu/iommu.c +7 -0
+	 * for one vendor but it should not affect another vendor.
+	 * Copy the remaining user data _after_ minsz
+	 */
+	if (copy_from_user((void *)data + minsz, udata + minsz,
+				min(data->argsz, maxsz) - minsz))
+		return -EFAULT;
+
Quoted 8 lines
Quoted 7 lines
drivers/iommu/iommu.c +4 -0
+	return iommu_check_bind_data(data);
+}
+
+int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct

device *dev,

drivers/iommu/iommu.c +1 -0
+						void __user

*udata)

change of proto not described in the commit msg

Good point, will add that to the commit msg.

Quoted 17 lines
Quoted 17 lines
drivers/iommu/iommu.c +10 -1
+{
+
+	struct iommu_gpasid_bind_data data;
+	int ret;
+
 	if (unlikely(!domain->ops->sva_bind_gpasid))
 		return -ENODEV;
 
-	return domain->ops->sva_bind_gpasid(domain, dev, data);
+	ret = iommu_sva_prepare_bind_data(udata, &data);
+	if (ret)
+		return ret;
+
+	return domain->ops->sva_bind_gpasid(domain, dev, &data);
 }
 EXPORT_SYMBOL_GPL(iommu_sva_bind_gpasid);
Quoted 6 lines

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2135

Quoted 4 lines

int iommu_sva_unbind_gpasid(struct iommu_domain *domain, struct
device *dev,

drivers/iommu/iommu.c +1 -1
-			     ioasid_t pasid)
+			struct iommu_gpasid_bind_data *data)  

This change and the introduction of iommu_uapi_sva_unbind_gpasid look unrelated to this patch, at least not described in the commit msg.

I will move the rename into a separate patch, adding iommu_uapi_ prefix to all UAPI functions.

Quoted 44 lines
Quoted 44 lines

{

drivers/iommu/iommu.c +2 -1
 	if (unlikely(!domain->ops->sva_unbind_gpasid))
 		return -ENODEV;
 
-	return domain->ops->sva_unbind_gpasid(dev, pasid);
+	return domain->ops->sva_unbind_gpasid(dev, data->hpasid);
 }
 EXPORT_SYMBOL_GPL(iommu_sva_unbind_gpasid);
 
+int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,

struct device *dev,

drivers/iommu/iommu.c +16 -0
+			void __user *udata)
+{
+	struct iommu_gpasid_bind_data data;
+	int ret;
+
+	if (unlikely(!domain->ops->sva_bind_gpasid))
+		return -ENODEV;
+
+	ret = iommu_sva_prepare_bind_data(udata, &data);
+	if (ret)
+		return ret;
+
+	return iommu_sva_unbind_gpasid(domain, dev, &data);
+}
+EXPORT_SYMBOL_GPL(iommu_uapi_sva_unbind_gpasid);
+
 static void __iommu_detach_device(struct iommu_domain *domain,
 				  struct device *dev)
 {
include/linux/iommu.h +2 -2
index 5f0b7859d2eb..439f34a7b5b2 100644
@@ -432,11 +432,14 @@ extern void iommu_detach_device(struct
 iommu_domain *domain, struct device *dev);
 extern int iommu_cache_invalidate(struct iommu_domain *domain,
 				  struct device *dev,
-				  struct
 iommu_cache_invalidate_info *inv_info);
+				  void __user *uinfo);
+
 extern int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-		struct device *dev, struct iommu_gpasid_bind_data
Quoted 8 lines

include/linux/iommu.h extern void iommu_detach_device(struct · line 444

Quoted 6 lines
include/linux/iommu.h +2 -0
 *data);
+				struct device *dev, void __user
 *udata); +extern int iommu_uapi_sva_unbind_gpasid(struct
 iommu_domain *domain,
+				        struct device *dev, void
 __user *udata);  

not motivated in the commit msg. I think change of proto and addition of iommu_sva_unbind_gpasid would deserve a separate patch.

Will do.

Quoted 39 lines
Quoted 32 lines
include/linux/iommu.h +0 -1
 extern int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
-				struct device *dev, ioasid_t

pasid);

include/linux/iommu.h +1 -0
+				   struct device *dev, struct

iommu_gpasid_bind_data *data); extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev); extern struct iommu_domain *iommu_get_dma_domain(struct device *dev); extern int iommu_map(struct iommu_domain *domain, unsigned long iova, @@ -1062,13 +1065,20 @@ iommu_cache_invalidate(struct iommu_domain *domain, return -ENODEV; }
static inline int iommu_sva_bind_gpasid(struct iommu_domain
*domain,

include/linux/iommu.h +0 -1
-				struct device *dev, struct

iommu_gpasid_bind_data *data)

include/linux/iommu.h +1 -0
+				struct device *dev, void __user

*udata) {
return -ENODEV;
}

static inline int iommu_sva_unbind_gpasid(struct iommu_domain
*domain,

include/linux/iommu.h +0 -1
-					   struct device *dev, int

pasid)

include/linux/iommu.h +1 -0
+					   struct device *dev,

void __user *udata) +{

include/linux/iommu.h +4 -0
+	return -ENODEV;
+}
+
+static inline int __iommu_sva_unbind_gpasid(struct iommu_domain

*domain,

include/linux/iommu.h +2 -0
+					struct device *dev,
+					struct
Quoted 4 lines

iommu_gpasid_bind_data *data) {
return -ENODEV;
}

Thanks

Quoted 2 lines

Eric

[Jacob Pan]
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu

author
#15 lore raw

Re: [PATCH v5 4/5] iommu/uapi: Handle data and argsz filled by users

In reply to Alex Williamson
Quoted 141 lines · On Fri, 17 Jul 2020 13:59:54 -0600 Alex Williamson…
Quoted 134 lines · On Thu, 16 Jul 2020 11:45:16 -0700 Jacob Pan <[email protected]>…

IOMMU UAPI data has a user filled argsz field which indicates the data length comes with the API call. User data is not trusted, argsz must be validated based on the current kernel data size, mandatory data size, and feature flags.

User data may also be extended, results in possible argsz increase. Backward compatibility is ensured based on size and flags checking.

This patch adds sanity checks in the IOMMU layer. In addition to argsz, reserved/unused fields in padding, flags, and version are also checked. Details are documented in Documentation/userspace-api/iommu.rst

---
 drivers/iommu/iommu.c | 192

++++++++++++++++++++++++++++++++++++++++++++++++--
include/linux/iommu.h | 20 ++++-- 2 files changed, 200 insertions(+), 12 deletions(-)

drivers/iommu/iommu.c +2 -0
index d43120eb1dc5..fe30a940d19e 100644
@@ -1950,36 +1950,214 @@ int iommu_attach_device(struct
 iommu_domain *domain, struct device *dev) }
 EXPORT_SYMBOL_GPL(iommu_attach_device);
 
+/*
+ * Check flags and other user privided data for valid

combinations. We also
+ * make sure no reserved fields or unused flags are not set. This is to ensure
+ * not breaking userspace in the future when these fields or flags are used.
+ */
+static int iommu_check_cache_invl_data(struct iommu_cache_invalidate_info *info) +{

drivers/iommu/iommu.c +41 -0
+	u32 mask;
+
+	if (info->version != IOMMU_CACHE_INVALIDATE_INFO_VERSION_1)
+		return -EINVAL;
+
+	mask = (1 << IOMMU_CACHE_INV_TYPE_NR) - 1;
+	if (info->cache & ~mask)
+		return -EINVAL;
+
+	if (info->granularity >= IOMMU_INV_GRANU_NR)
+		return -EINVAL;
+
+	switch (info->granularity) {
+	case IOMMU_INV_GRANU_ADDR:
+		mask = IOMMU_INV_ADDR_FLAGS_PASID |
+			IOMMU_INV_ADDR_FLAGS_ARCHID |
+			IOMMU_INV_ADDR_FLAGS_LEAF;
+
+		if (info->granu.addr_info.flags & ~mask)
+			return -EINVAL;
+		break;
+	case IOMMU_INV_GRANU_PASID:
+		mask = IOMMU_INV_PASID_FLAGS_PASID |
+			IOMMU_INV_PASID_FLAGS_ARCHID;
+		if (info->granu.pasid_info.flags & ~mask)
+			return -EINVAL;
+
+		break;
+	case IOMMU_INV_GRANU_DOMAIN:
+		/* No flags to check */
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (info->padding[0] || info->padding[1])
+		return -EINVAL;
+
+	return 0;
+}
+
 int iommu_cache_invalidate(struct iommu_domain *domain, struct

device *dev,

drivers/iommu/iommu.c +0 -1
-			   struct iommu_cache_invalidate_info

*inv_info)

drivers/iommu/iommu.c +5 -1
+			   void __user *uinfo)
 {
+	struct iommu_cache_invalidate_info inv_info = { 0 };
+	u32 minsz, maxsz;
+	int ret = 0;
+
 	if (unlikely(!domain->ops->cache_invalidate))
 		return -ENODEV;
 
-	return domain->ops->cache_invalidate(domain, dev,

inv_info);

drivers/iommu/iommu.c +1 -0
+	/* Current kernel data size is the max to be copied from

user */

drivers/iommu/iommu.c +4 -0
+	maxsz = sizeof(struct iommu_cache_invalidate_info);
+
+	/*
+	 * No new spaces can be added before the variable sized

union, the

drivers/iommu/iommu.c +3 -0
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_cache_invalidate_info,

granu); +

drivers/iommu/iommu.c +9 -0
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(&inv_info, uinfo, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (inv_info.argsz < minsz)
+		return -EINVAL;
+
+	/* PASID and address granu requires additional info beyond

minsz */

drivers/iommu/iommu.c +3 -0
+	if (inv_info.argsz == minsz &&
+		((inv_info.granularity == IOMMU_INV_GRANU_PASID) ||
+			(inv_info.granularity ==

IOMMU_INV_GRANU_ADDR)))

drivers/iommu/iommu.c +3 -0
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header which has a

larger data

drivers/iommu/iommu.c +1 -0
+	 * size, we shall support the existing flags within the

current

drivers/iommu/iommu.c +1 -0
+	 * size. Copy the remaining user data _after_ minsz but

not more

drivers/iommu/iommu.c +3 -0
+	 * than the current kernel supported size.
+	 */
+	if (copy_from_user((void *)&inv_info + minsz, uinfo +

minsz,

drivers/iommu/iommu.c +1 -0
+				min(inv_info.argsz, maxsz) -

minsz))

drivers/iommu/iommu.c

Quoted 1 line
drivers/iommu/iommu.c +1 -0
+		return -EFAULT;  

To further clarify previous comments about maxsz usage:

Quoted 2 lines

s/maxsz/sizeof(inv_info)/

Yes, will remove maxsz.

Quoted 4 lines
Quoted 4 lines
drivers/iommu/iommu.c +4 -0
+
+	/* Now the argsz is validated, check the content */
+	ret = iommu_check_cache_invl_data(&inv_info);
+	if (ret)
Quoted 9 lines
Quoted 5 lines
drivers/iommu/iommu.c +3 -0
+		return ret;
+
+	return domain->ops->cache_invalidate(domain, dev,

&inv_info); }
EXPORT_SYMBOL_GPL(iommu_cache_invalidate);

Remainder of comments for above provided in 1/5.

Got it.

Quoted 34 lines
Quoted 34 lines
drivers/iommu/iommu.c +0 -2
-int iommu_sva_bind_gpasid(struct iommu_domain *domain,
-			   struct device *dev, struct

iommu_gpasid_bind_data *data) +
+static int iommu_check_bind_data(struct iommu_gpasid_bind_data *data) {

drivers/iommu/iommu.c +27 -0
+	u32 mask;
+	int i;
+
+	if (data->version != IOMMU_GPASID_BIND_VERSION_1)
+		return -EINVAL;
+
+	/* Check all supported format, for now just VT-d */
+	mask = IOMMU_PASID_FORMAT_INTEL_VTD;
+	if (data->format & ~mask)
+		return -EINVAL;
+
+	/* Check all flags */
+	mask = IOMMU_SVA_GPASID_VAL;
+	if (data->flags & ~mask)
+		return -EINVAL;
+
+	/* Check reserved padding fields */
+	for (i = 0; i < 12; i++) {
+		if (data->padding[i])
+			return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int iommu_sva_prepare_bind_data(void __user *udata,
+				       struct

iommu_gpasid_bind_data *data) +{

Quoted 9 lines

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2087

Quoted 6 lines
drivers/iommu/iommu.c +3 -0
+	u32 minsz, maxsz;
+
+	/* Current kernel data size is the max to be copied from

user */

drivers/iommu/iommu.c +2 -0
+	maxsz = sizeof(struct iommu_gpasid_bind_data);
+	memset((void *)data, 0, maxsz);  

Let the caller pass a zero'd structure.

Sounds good.

Quoted 22 lines
Quoted 22 lines
drivers/iommu/iommu.c +3 -0
+
+	/*
+	 * No new spaces can be added before the variable sized

union, the

drivers/iommu/iommu.c +13 -0
+	 * minimum size is the offset to the union.
+	 */
+	minsz = offsetof(struct iommu_gpasid_bind_data, vendor);
+
+	/* Copy minsz from user to get flags and argsz */
+	if (copy_from_user(data, udata, minsz))
+		return -EFAULT;
+
+	/* Fields before variable size union is mandatory */
+	if (data->argsz < minsz)
+		return -EINVAL;
+	/*
+	 * User might be using a newer UAPI header, we shall let

IOMMU vendor

drivers/iommu/iommu.c +1 -0
+	 * driver decide on what size it needs. Since the guest

PASID bind data

drivers/iommu/iommu.c +1 -0
+	 * can be vendor specific, larger argsz could be the

result of extension

Quoted 8 lines

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2110

Quoted 5 lines
drivers/iommu/iommu.c +5 -0
+	 * for one vendor but it should not affect another vendor.
+	 * Copy the remaining user data _after_ minsz
+	 */
+	if (copy_from_user((void *)data + minsz, udata + minsz,
+				min(data->argsz, maxsz) - minsz))  

We could replace maxsz entirely with sizeof(*data)

will do.

Quoted 13 lines
Quoted 10 lines
drivers/iommu/iommu.c +6 -0
+		return -EFAULT;
+
+	return iommu_check_bind_data(data);
+}
+
+int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct

device *dev,

drivers/iommu/iommu.c +1 -0
+						void __user

*udata)

iommu_uapi_sva_bind_gpasid(...

will do. make naming consistent for all UAPIs.

Quoted 6 lines

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2120

Quoted 3 lines
drivers/iommu/iommu.c +3 -0
+{
+
+	struct iommu_gpasid_bind_data data;  
	= { 0 }

yes, callee does not need to zero out the data.

Quoted 27 lines
Quoted 27 lines
drivers/iommu/iommu.c +7 -1
+	int ret;
+
 	if (unlikely(!domain->ops->sva_bind_gpasid))
 		return -ENODEV;
 
-	return domain->ops->sva_bind_gpasid(domain, dev, data);
+	ret = iommu_sva_prepare_bind_data(udata, &data);
+	if (ret)
+		return ret;
+
+	return domain->ops->sva_bind_gpasid(domain, dev, &data);
 }
 EXPORT_SYMBOL_GPL(iommu_sva_bind_gpasid);
 
 int iommu_sva_unbind_gpasid(struct iommu_domain *domain, struct

device *dev,

drivers/iommu/iommu.c +2 -2
-			     ioasid_t pasid)
+			struct iommu_gpasid_bind_data *data)
 {
 	if (unlikely(!domain->ops->sva_unbind_gpasid))
 		return -ENODEV;
 
-	return domain->ops->sva_unbind_gpasid(dev, pasid);
+	return domain->ops->sva_unbind_gpasid(dev, data->hpasid);
 }
 EXPORT_SYMBOL_GPL(iommu_sva_unbind_gpasid);
Quoted 7 lines

drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 2120

Quoted 5 lines

+int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain, struct device *dev,

drivers/iommu/iommu.c +3 -0
+			void __user *udata)
+{
+	struct iommu_gpasid_bind_data data;  
	= { 0 };

Ditto

Quoted 18 lines
Quoted 18 lines
drivers/iommu/iommu.c +13 -0
+	int ret;
+
+	if (unlikely(!domain->ops->sva_bind_gpasid))
+		return -ENODEV;
+
+	ret = iommu_sva_prepare_bind_data(udata, &data);
+	if (ret)
+		return ret;
+
+	return iommu_sva_unbind_gpasid(domain, dev, &data);
+}
+EXPORT_SYMBOL_GPL(iommu_uapi_sva_unbind_gpasid);
+
 static void __iommu_detach_device(struct iommu_domain *domain,
 				  struct device *dev)
 {
include/linux/iommu.h +0 -0
Quoted 8 lines

include/linux/iommu.h extern void iommu_detach_device(struct · line 433

Quoted 6 lines

index 5f0b7859d2eb..439f34a7b5b2 100644

include/linux/iommu.h +0 -0
@@ -432,11 +432,14 @@ extern void iommu_detach_device(struct
 iommu_domain *domain, struct device *dev);
 extern int iommu_cache_invalidate(struct iommu_domain *domain,  

uapi

got it.

Quoted 10 lines

include/linux/iommu.h extern void iommu_detach_device(struct iommu_domain *domain, · line 437

Quoted 7 lines
include/linux/iommu.h +2 -1
 				  struct device *dev,
-				  struct
 iommu_cache_invalidate_info *inv_info);
+				  void __user *uinfo);
+
 extern int iommu_sva_bind_gpasid(struct iommu_domain *domain,  

uapi

got it.

Quoted 26 lines
Quoted 26 lines
include/linux/iommu.h +2 -1
-		struct device *dev, struct iommu_gpasid_bind_data
 *data);
+				struct device *dev, void __user
 *udata); +extern int iommu_uapi_sva_unbind_gpasid(struct
 iommu_domain *domain,
+				        struct device *dev, void

__user *udata); extern int iommu_sva_unbind_gpasid(struct iommu_domain *domain,

include/linux/iommu.h +0 -1
-				struct device *dev, ioasid_t

pasid);

include/linux/iommu.h +1 -0
+				   struct device *dev, struct

iommu_gpasid_bind_data *data); extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev); extern struct iommu_domain *iommu_get_dma_domain(struct device *dev); extern int iommu_map(struct iommu_domain *domain, unsigned long iova, @@ -1062,13 +1065,20 @@ iommu_cache_invalidate(struct iommu_domain *domain, return -ENODEV; }
static inline int iommu_sva_bind_gpasid(struct iommu_domain
*domain,

include/linux/iommu.h +0 -1
-				struct device *dev, struct

iommu_gpasid_bind_data *data)

include/linux/iommu.h +1 -0
+				struct device *dev, void __user

*udata) {
return -ENODEV;
}

Quoted 15 lines
Quoted 11 lines

static inline int iommu_sva_unbind_gpasid(struct iommu_domain
*domain,

include/linux/iommu.h +0 -1
-					   struct device *dev, int

pasid)

include/linux/iommu.h +1 -0
+					   struct device *dev,

void __user *udata) +{

include/linux/iommu.h +4 -0
+	return -ENODEV;
+}
+
+static inline int __iommu_sva_unbind_gpasid(struct iommu_domain

*domain,

These don't match the previous semantics. Thanks,

My mistake, will fix.

Thanks

Quoted 8 lines

Alex

Quoted 5 lines
include/linux/iommu.h +2 -0
+					struct device *dev,
+					struct

iommu_gpasid_bind_data *data) {
return -ENODEV;
}

[Jacob Pan]
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu