IOMMU user API enhancement
Subsystems (3)
PATCH v3 3/5 iommu/uapi: Use named union for user data
In reply to Jacob PanIOMMU 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
@@ -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,
@@ -5431,20 +5431,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); }/*
@@ -5452,9 +5452,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 ;
@@ -5475,13 +5475,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
@@ -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
@@ -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 · 1 line
2.7.4
PATCH v3 2/5 iommu/uapi: Add argsz for user filled data
In reply to Jacob PanAs 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.
Specific scenarios for user data handling are documented in:Documentation/userspace-api/iommu.rst
--- include/uapi/linux/iommu.h | 6 ++++++ 1 file changed, 6 insertions(+)
include/uapi/linux/iommu.h +6 -0
@@ -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 */
@@ -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,6 +314,7 @@ 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
Signature · 1 line
2.7.4
PATCH v3 1/5 docs: IOMMU user API
In reply to Jacob PanIOMMU 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 mechenics of how future extensions should be achieved are also covered in this documentation.
--- Documentation/userspace-api/iommu.rst | 244 ++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 Documentation/userspace-api/iommu.rst
Documentation/userspace-api/iommu.rst new file +244 -0
@@ -0,0 +1,244 @@ +.. 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 page requests + +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, user such as VFIO +has to 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 is 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 recompile 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 share 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[2]; + 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 and override out-of-range + value. If the exact argsz is based on generic flags, they are checked + here as well. + +- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data + is consumed based on flags + +Once again, use guest TLB invalidation as an example, argsz is based +on generic flags in the invalidation information. IOMMU generic code +shall process the UAPI data as the following: + +:: + + int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev, + void __user *uinfo) + { + /* Current kernel data size is the max to be copied from user */ + maxsz = sizeof(struct iommu_cache_invalidate_info); + memset((void *)&inv_info, 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_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; + /* + * User might be using a newer UAPI header which has a larger data + * size, we shall support the existing flags within the current + * size. + */ + if (inv_info.argsz > maxsz) + inv_info.argsz = maxsz; + + /* Checking the exact argsz based on generic flags */ + if (inv_info.granularity == IOMMU_INV_GRANU_ADDR && + inv_info.argsz != offsetofend(struct iommu_cache_invalidate_info, + granu.addr_info)) + return -EINVAL; + + if (inv_info.granularity == IOMMU_INV_GRANU_PASID && + inv_info.argsz != offsetofend(struct iommu_cache_invalidate_info, + granu.pasid_info)) + return -EINVAL; + + /* Copy the remaining user data _after_ minsz */ + if (copy_from_user((void *)&inv_info + minsz, uinfo + minsz, + inv_info.argsz - minsz)) + return -EFAULT; + + return domain->ops->cache_invalidate(domain, dev, &inv_info); + } + Add a wrapper + __iommu_unbind_( kernel data, same user data, kernel copy) + +Notice that in this example, since union size is determined by generic +flags, all checking to argsz is validated in the generic IOMMU layer, +vendor driver does not need to check argsz. However, if union size is +based on vendor data, such as iommu_sva_bind_gpasid(), it will be +vendor driver's responsibility to validate the exact argsz.
Signature · 6 lines
2.7.4 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
v3 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:
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/uapi: Support both kernel and user unbind guest PASID
Documentation/userspace-api/iommu.rst | 244 ++++++++++++++++++++++++++++++++++ drivers/iommu/intel/iommu.c | 24 ++-- drivers/iommu/intel/svm.c | 5 +- drivers/iommu/iommu.c | 138 +++++++++++++++++-- include/linux/iommu.h | 20 ++- include/uapi/linux/iommu.h | 10 +- 6 files changed, 413 insertions(+), 28 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
PATCH v3 4/5 iommu/uapi: Handle data and argsz filled by users
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. Details are documented in Documentation/userspace-api/iommu.rst
This patch adds sanity checks in both IOMMU layer and vendor code, where VT-d is the only user for now.
--- drivers/iommu/intel/svm.c | 3 ++ drivers/iommu/iommu.c | 96 ++++++++++++++++++++++++++++++++++++++++++++--- include/linux/iommu.h | 7 ++-- 3 files changed, 98 insertions(+), 8 deletions(-)
drivers/iommu/intel/svm.c +3 -0
@@ -244,6 +244,9 @@ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev, data->format != IOMMU_PASID_FORMAT_INTEL_VTD)return -EINVAL ; + if (data->argsz != offsetofend(struct iommu_gpasid_bind_data, vendor.vtd)) +return -EINVAL ; +if (!dev_is_pci (dev))return -ENOTSUPP ;
drivers/iommu/iommu.c +91 -5
113 lines not on this page · raw message
include/linux/iommu.h +4 -3
@@ -432,9 +432,10 @@ 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_sva_unbind_gpasid (struct iommu_domain *domain,struct device *dev,ioasid_t pasid);extern struct iommu_domain *iommu_get_domain_for_dev (struct device *dev);
@@ -1062,7 +1063,7 @@ 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 ; }
Signature · 6 lines
2.7.4 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
PATCH v3 5/5 iommu/uapi: Support both kernel and user unbind guest PASID
In reply to Jacob PanGuest SVA unbind data can come from either kernel and user space, if a user pointer is passed in, IOMMU driver must copy from data from user. If the unbind data is assembled in kernel, data can be trusted and directly used. This patch creates a wrapper for unbind gpasid such that user pointer can be parsed and sanitized before calling into the kernel unbind function. Common user data copy code also consolidated.
--- drivers/iommu/iommu.c | 70 ++++++++++++++++++++++++++++++++++++++------------- include/linux/iommu.h | 13 ++++++++-- 2 files changed, 64 insertions(+), 19 deletions(-)
drivers/iommu/iommu.c +53 -17
@@ -2010,19 +2010,15 @@ int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev, }EXPORT_SYMBOL_GPL (iommu_cache_invalidate); -int iommu_sva_bind_gpasid (struct iommu_domain *domain,struct device *dev, -void __user *udata) -{ -struct iommu_gpasid_bind_data data; +static int iommu_sva_prepare_bind_data (void __user *udata,bool bind, +struct iommu_gpasid_bind_data *data) +{unsigned long minsz, maxsz; -if (unlikely (!domain->ops->sva_bind_gpasid)) -return -ENODEV ; -/* Current kernel data size is the max to be copied from user */ maxsz =sizeof (struct iommu_gpasid_bind_data ); -memset ((void *)&data,0 , maxsz); +memset ((void *)data,0 , maxsz);/* * No new spaces can be added before the variable sized union, the
@@ -2031,11 +2027,11 @@ int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct device *dev, minsz = offsetof(struct iommu_gpasid_bind_data , vendor);/* Copy minsz from user to get flags and argsz */ -if (copy_from_user (&data, udata, minsz)) +if (copy_from_user (data, udata, minsz))return -EFAULT ;/* Fields before variable size union is mandatory */ -if (data.argsz < minsz) +if (data->argsz < minsz)return -EINVAL ;/* * User might be using a newer UAPI header, we shall let IOMMU vendor
@@ -2043,26 +2039,66 @@ int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct device *dev,* can be vendor specific, larger argsz could be the result of extension * for one vendor but it should not affect another vendor. */ -if (data.argsz > maxsz) - data.argsz = maxsz; +if (data->argsz > maxsz) + data->argsz = maxsz; + +/* +* For unbind, we don't need any extra data, host PASID is included in +* the minsz and that is all we need. +*/ +if (!bind) +return 0 ;/* Copy the remaining user data _after_ minsz */ -if (copy_from_user ((void *)&data + minsz, udata + minsz, - data.argsz - minsz)) +if (copy_from_user ((void *)data + minsz, udata + minsz, + data->argsz - minsz))return -EFAULT ; +return 0 ; +} + +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 ; + + ret =iommu_sva_prepare_bind_data (udata, true, &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) +int __iommu_sva_unbind_gpasid (struct iommu_domain *domain,struct device *dev, +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_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, false, &data); +if (ret) +return ret; + +return __iommu_sva_unbind_gpasid (domain, dev, &data); }EXPORT_SYMBOL_GPL (iommu_sva_unbind_gpasid);
include/linux/iommu.h +11 -2
@@ -437,7 +437,9 @@ extern int iommu_cache_invalidate(struct iommu_domain *domain,extern int iommu_sva_bind_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,void __user *udata); +extern int __iommu_sva_unbind_gpasid (struct iommu_domain *domain, +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,
@@ -1069,7 +1071,14 @@ static inline int iommu_sva_bind_gpasid(struct iommu_domain *domain, }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 · 6 lines
2.7.4 _______________________________________________ iommu mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [PATCH v3 3/5] iommu/uapi: Use named union for user data
In reply to Jacob PanHi Jacob,
Quoted 42 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 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.Signed-off-by Jacob Pan <[email protected]>--- 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 +4
-6@@ -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,@@ -5431,20 +5431,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;
drivers/iommu/intel/iommu.c intel_iommu_sva_invalidate(struct iommu_domain *domain, struct device *dev, · line 5445
Quoted 10 lines
drivers/iommu/intel/iommu.c +3
-1+ (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 ))) {
Nit: Keep it aligned. With this tweaked,
Best regards,
baolu
Quoted 62 lines
drivers/iommu/intel/iommu.c +5
-5WARN_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); }/* @@ -5452,9 +5452,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 ;@@ -5475,13 +5475,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@@ -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 +1
-1@@ -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; };/**
include/uapi/linux/iommu.h struct iommu_gpasid_bind_data { · line 335
Quoted 8 lines
include/uapi/linux/iommu.h +1
-1@@ -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 */
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Lu Baolu
maintainerRe: [PATCH v3 4/5] iommu/uapi: Handle data and argsz filled by users
In reply to Jacob PanHi Jacob,
Quoted 25 lines · 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. Details are documented in
Documentation/userspace-api/iommu.rstThis patch adds sanity checks in both IOMMU layer and vendor code, where VT-d is the only user for now.
Signed-off-by Liu Yi L <[email protected]>Signed-off-by Jacob Pan <[email protected]>--- drivers/iommu/intel/svm.c | 3 ++ drivers/iommu/iommu.c | 96 ++++++++++++++++++++++++++++++++++++++++++++--- include/linux/iommu.h | 7 ++-- 3 files changed, 98 insertions(+), 8 deletions(-)drivers/iommu/intel/svm.c +0
-0
drivers/iommu/intel/svm.c int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev, · line 248
Quoted 5 lines
drivers/iommu/intel/svm.c +2
-0@@ -244,6 +244,9 @@ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev, data->format != IOMMU_PASID_FORMAT_INTEL_VTD)return -EINVAL ; + if (data->argsz != offsetofend(struct iommu_gpasid_bind_data, vendor.vtd)) +return -EINVAL ;
Need to do size check in intel_iommu_sva_invalidate() as well?
Quoted 9 lines
drivers/iommu/intel/svm.c +1
-0+if (!dev_is_pci (dev))return -ENOTSUPP ;drivers/iommu/iommu.c +0
-0
drivers/iommu/iommu.c int iommu_attach_device(struct iommu_domain *domain, struct device *dev) · line 1954
Quoted 5 lines
drivers/iommu/iommu.c +1
-1@@ -1951,22 +1951,108 @@ int iommu_attach_device(struct iommu_domain *domain, struct device *dev)EXPORT_SYMBOL_GPL (iommu_attach_device);int iommu_cache_invalidate (struct iommu_domain *domain,struct device *dev, -struct iommu_cache_invalidate_info *inv_info) +void __user *uinfo)
Nit: keep it aligned.
Quoted 127 lines
drivers/iommu/iommu.c +90
-4{ +struct iommu_cache_invalidate_info inv_info; +unsigned long minsz, maxsz; +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 ); +memset ((void *)&inv_info,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_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 ; +/* +* User might be using a newer UAPI header, we shall let IOMMU vendor +* driver decide on what size it needs. Since the UAPI data extension +* can be vendor specific, larger argsz could be the result of extension +* for one vendor but it should not affect another vendor. +*/ +/* +* User might be using a newer UAPI header which has a larger data +* size, we shall support the existing flags within the current +* size. +*/ +if (inv_info.argsz > maxsz) + inv_info.argsz = maxsz; + +/* Checking the exact argsz based on generic flags */ +if (inv_info.granularity ==IOMMU_INV_GRANU_ADDR && + inv_info.argsz != offsetofend(struct iommu_cache_invalidate_info, + granu.addr_info)) +return -EINVAL ; + +if (inv_info.granularity ==IOMMU_INV_GRANU_PASID && + inv_info.argsz != offsetofend(struct iommu_cache_invalidate_info, + granu.pasid_info)) +return -EINVAL ; + +/* Copy the remaining user data _after_ minsz */ +if (copy_from_user ((void *)&inv_info + minsz, uinfo + minsz, + inv_info.argsz - minsz)) +return -EFAULT ; + +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) +int iommu_sva_bind_gpasid (struct iommu_domain *domain,struct device *dev, +void __user *udata) { + +struct iommu_gpasid_bind_data data; +unsigned long minsz, maxsz; +if (unlikely (!domain->ops->sva_bind_gpasid))return -ENODEV ; -return domain->ops->sva_bind_gpasid (domain, dev, data); +/* 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. +*/ +if (data.argsz > maxsz) + data.argsz = maxsz; + +/* Copy the remaining user data _after_ minsz */ +if (copy_from_user ((void *)&data + minsz, udata + minsz, + data.argsz - minsz)) +return -EFAULT ; + + +return domain->ops->sva_bind_gpasid (domain, dev, &data); }EXPORT_SYMBOL_GPL (iommu_sva_bind_gpasid);include/linux/iommu.h +3
-2@@ -432,9 +432,10 @@ 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_sva_unbind_gpasid (struct iommu_domain *domain,struct device *dev,ioasid_t pasid);extern struct iommu_domain *iommu_get_domain_for_dev (struct device *dev);
include/linux/iommu.h iommu_cache_invalidate(struct iommu_domain *domain, · line 1069
Quoted 8 lines
include/linux/iommu.h +1
-1@@ -1062,7 +1063,7 @@ 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 ; }
Best regards,
baolu
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Lu Baolu
maintainerRe: [PATCH v3 5/5] iommu/uapi: Support both kernel and user unbind guest PASID
In reply to Jacob PanHi Jacob,
Quoted 1 line · Jacob Pan
Guest SVA unbind data can come from either kernel and user space, if a
either kernel or user space
Quoted 1 line
user pointer is passed in, IOMMU driver must copy from data from user.
copy data from user
Quoted 98 lines
If the unbind data is assembled in kernel, data can be trusted and directly used. This patch creates a wrapper for unbind gpasid such that user pointer can be parsed and sanitized before calling into the kernel unbind function. Common user data copy code also consolidated.
Signed-off-by Liu Yi L <[email protected]>Signed-off-by Jacob Pan <[email protected]>--- drivers/iommu/iommu.c | 70 ++++++++++++++++++++++++++++++++++++++------------- include/linux/iommu.h | 13 ++++++++-- 2 files changed, 64 insertions(+), 19 deletions(-)drivers/iommu/iommu.c +33
-14@@ -2010,19 +2010,15 @@ int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev, }EXPORT_SYMBOL_GPL (iommu_cache_invalidate); -int iommu_sva_bind_gpasid (struct iommu_domain *domain,struct device *dev, -void __user *udata) -{ -struct iommu_gpasid_bind_data data; +static int iommu_sva_prepare_bind_data (void __user *udata,bool bind, +struct iommu_gpasid_bind_data *data) +{unsigned long minsz, maxsz; -if (unlikely (!domain->ops->sva_bind_gpasid)) -return -ENODEV ; -/* Current kernel data size is the max to be copied from user */ maxsz =sizeof (struct iommu_gpasid_bind_data ); -memset ((void *)&data,0 , maxsz); +memset ((void *)data,0 , maxsz);/* * No new spaces can be added before the variable sized union, the @@ -2031,11 +2027,11 @@ int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct device *dev, minsz = offsetof(struct iommu_gpasid_bind_data , vendor);/* Copy minsz from user to get flags and argsz */ -if (copy_from_user (&data, udata, minsz)) +if (copy_from_user (data, udata, minsz))return -EFAULT ;/* Fields before variable size union is mandatory */ -if (data.argsz < minsz) +if (data->argsz < minsz)return -EINVAL ;/* * User might be using a newer UAPI header, we shall let IOMMU vendor @@ -2043,26 +2039,66 @@ int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct device *dev,* can be vendor specific, larger argsz could be the result of extension * for one vendor but it should not affect another vendor. */ -if (data.argsz > maxsz) - data.argsz = maxsz; +if (data->argsz > maxsz) + data->argsz = maxsz; + +/* +* For unbind, we don't need any extra data, host PASID is included in +* the minsz and that is all we need. +*/ +if (!bind) +return 0 ;/* Copy the remaining user data _after_ minsz */ -if (copy_from_user ((void *)&data + minsz, udata + minsz, - data.argsz - minsz)) +if (copy_from_user ((void *)data + minsz, udata + minsz, + data->argsz - minsz))return -EFAULT ; +return 0 ; +} + +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 ; + + ret =iommu_sva_prepare_bind_data (udata, true, &data); +if (ret) +return ret;return domain->ops->sva_bind_gpasid (domain, dev, &data); }EXPORT_SYMBOL_GPL (iommu_sva_bind_gpasid);
drivers/iommu/iommu.c int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct device *dev, · line 2084
Quoted 10 lines
drivers/iommu/iommu.c +3
-3-int iommu_sva_unbind_gpasid (struct iommu_domain *domain,struct device *dev, -ioasid_t pasid) +int __iommu_sva_unbind_gpasid (struct iommu_domain *domain,struct device *dev, +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);
How about passing @data to the vendor iommu driver as well?
drivers/iommu/iommu.c int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct device *dev, · line 2089
Quoted 5 lines
drivers/iommu/iommu.c +5
-0+} +EXPORT_SYMBOL_GPL (__iommu_sva_unbind_gpasid); + +int iommu_sva_unbind_gpasid (struct iommu_domain *domain,struct device *dev, +void __user *udata)
Keep it aligned.
Quoted 37 lines
drivers/iommu/iommu.c +12
-0+{ +struct iommu_gpasid_bind_data data; +int ret; + +if (unlikely (!domain->ops->sva_bind_gpasid)) +return -ENODEV ; + + ret =iommu_sva_prepare_bind_data (udata, false, &data); +if (ret) +return ret; + +return __iommu_sva_unbind_gpasid (domain, dev, &data); }EXPORT_SYMBOL_GPL (iommu_sva_unbind_gpasid);include/linux/iommu.h +4
-2@@ -437,7 +437,9 @@ extern int iommu_cache_invalidate(struct iommu_domain *domain,extern int iommu_sva_bind_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,void __user *udata); +extern int __iommu_sva_unbind_gpasid (struct iommu_domain *domain, +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,@@ -1069,7 +1071,14 @@ static inline int iommu_sva_bind_gpasid(struct iommu_domain *domain, }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 static inline int iommu_sva_bind_gpasid(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 ; }
Best regards,
baolu
Re: [PATCH v3 3/5] iommu/uapi: Use named union for user data
In reply to Lu BaoluQuoted 11 lines · On Wed, 24 Jun 2020 14:29:57 +0800 Lu Baolu <[email protected]> wrote:
Quoted 8 lines
case
IOMMU_CACHE_INV_TYPE_IOTLB:
/* HW will ignore LSB bits based on
address mask */ if (inv_info->granularity==IOMMU_INV_GRANU_ADDR&&
size &&(quoted diff) +0
-1- (inv_info->addr_info.addr &((
BIT(VTD_PAGE_SHIFT + size)) - 1))) {(quoted diff) +1
-0+ (inv_info->granu.addr_info.addr &((
BIT(VTD_PAGE_SHIFT + size)) - 1))) {Nit: Keep it aligned. With this tweaked,
Quoted 1 line
Reviewed-by Lu Baolu <[email protected]>
will do. Thanks.
Re: [PATCH v3 4/5] iommu/uapi: Handle data and argsz filled by users
In reply to Lu BaoluQuoted 32 lines · On Wed, 24 Jun 2020 14:54:49 +0800 Lu Baolu <[email protected]> wrote:
Hi Jacob,
Quoted 29 lines · 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. Details are documented in
Documentation/userspace-api/iommu.rstThis patch adds sanity checks in both IOMMU layer and vendor code, where VT-d is the only user for now.
Signed-off-by Liu Yi L <[email protected]>Signed-off-by Jacob Pan <[email protected]>--- drivers/iommu/intel/svm.c | 3 ++ drivers/iommu/iommu.c | 96++++++++++++++++++++++++++++++++++++++++++++---
include/linux/iommu.h| 7 ++-- 3 files changed, 98
insertions(+), 8 deletions(-)drivers/iommu/intel/svm.c +0
-0@@ -244,6 +244,9 @@ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev, data->format != IOMMU_PASID_FORMAT_INTEL_VTD) return -EINVAL;
Quoted 6 lines
drivers/iommu/intel/svm.c int intel_svm_bind_gpasid(struct iommu_domain · line 249
Quoted 3 lines
drivers/iommu/intel/svm.c +2
-0+ if (data->argsz != offsetofend(struct iommu_gpasid_bind_data, vendor.vtd)) +return -EINVAL ;Need to do size check in
intel_iommu_sva_invalidate()as well?
No need. The difference is that there is no vendor specific union for intel_iommu_sva_invalidate().
Generic flags are used to process invalidation data inside intel_iommu_sva_invalidate().
Quoted 170 lines
Quoted 9 lines
drivers/iommu/intel/svm.c +1
-0+if (!dev_is_pci (dev))return -ENOTSUPP ;drivers/iommu/iommu.c +0
-0drivers/iommu/iommu.c int iommu_attach_device(struct · line 1956
Quoted 7 lines
drivers/iommu/iommu.c +1
-1@@ -1951,22 +1951,108 @@ int iommu_attach_device(struct iommu_domain *domain, struct device *dev)EXPORT_SYMBOL_GPL (iommu_attach_device ); int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev, -struct iommu_cache_invalidate_info *inv_info) + void __user *uinfo)Nit: keep it aligned.
Quoted 151 lines
drivers/iommu/iommu.c +4
-1{ +struct iommu_cache_invalidate_info inv_info; +unsigned long minsz, maxsz; +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 */
drivers/iommu/iommu.c +5
-0+ maxsz =sizeof (struct iommu_cache_invalidate_info ); +memset ((void *)&inv_info,0 , maxsz); + +/* +* 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 ; +/* +* 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 UAPI data extension
drivers/iommu/iommu.c +1
-0+* can be vendor specific, larger argsz could be the result of extension
drivers/iommu/iommu.c +4
-0+* for one vendor but it should not affect another vendor. +*/ +/* +* 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 +8
-0+* size. +*/ +if (inv_info.argsz > maxsz) + inv_info.argsz = maxsz; + +/* Checking the exact argsz based on generic flags */ +if (inv_info.granularity ==IOMMU_INV_GRANU_ADDR && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,drivers/iommu/iommu.c +5
-0+ granu.addr_info)) +return -EINVAL ; + +if (inv_info.granularity ==IOMMU_INV_GRANU_PASID && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,drivers/iommu/iommu.c +5
-0+ granu.pasid_info)) +return -EINVAL ; + +/* Copy the remaining user data _after_ minsz */ + if (copy_from_user((void *)&inv_info + minsz, uinfo +minsz,
drivers/iommu/iommu.c +4
-0+ inv_info.argsz - minsz)) +return -EFAULT ; + + 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) +int iommu_sva_bind_gpasid(structiommu_domain*domain, struct device *dev,drivers/iommu/iommu.c +6
-1+ void __user *udata) { + +struct iommu_gpasid_bind_data data; +unsigned long minsz, maxsz; +if (unlikely (!domain->ops->sva_bind_gpasid))return -ENODEV ; -return domain->ops->sva_bind_gpasid (domain, dev, data); +/* 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 +12
-0+* for one vendor but it should not affect another vendor. +*/ +if (data.argsz > maxsz) + data.argsz = maxsz; + +/* Copy the remaining user data _after_ minsz */ +if (copy_from_user ((void *)&data + minsz, udata + minsz, + data.argsz - minsz)) +return -EFAULT ; + + +return domain->ops->sva_bind_gpasid (domain, dev, &data); }EXPORT_SYMBOL_GPL (iommu_sva_bind_gpasid);include/linux/iommu.h +3
-2@@ -432,9 +432,10 @@ 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_sva_unbind_gpasid(struct iommu_domain*domain, struct device *dev,
ioasid_tpasid);
extern structiommu_domain*iommu_get_domain_for_dev(struct
device *dev); @@ -1062,7 +1063,7 @@ iommu_cache_invalidate(structiommu_domain*domain, return-ENODEV;
}
static inline int iommu_sva_bind_gpasid(structiommu_domain
*domain,include/linux/iommu.h +0
-1-struct device *dev, struct
iommu_gpasid_bind_data*data)
Quoted 8 lines
Quoted 5 lines
include/linux/iommu.h +1
-0+struct device *dev, void__user *udata) {
return-ENODEV;
}Best regards,
baolu
[Jacob Pan]
Re: [PATCH v3 4/5] iommu/uapi: Handle data and argsz filled by users
Quoted 40 lines · Jacob Pan
Quoted 32 lines · On Wed, 24 Jun 2020 14:54:49 +0800 Lu Baolu<[email protected]> wrote:
Hi Jacob,
Quoted 29 lines · 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. Details are documented in
Documentation/userspace-api/iommu.rstThis patch adds sanity checks in both IOMMU layer and vendor code, where VT-d is the only user for now.
Signed-off-by Liu Yi L<[email protected]>Signed-off-by Jacob Pan<[email protected]>--- drivers/iommu/intel/svm.c | 3 ++ drivers/iommu/iommu.c | 96++++++++++++++++++++++++++++++++++++++++++++---
include/linux/iommu.h| 7 ++-- 3 files changed, 98
insertions(+), 8 deletions(-)drivers/iommu/intel/svm.c +0
-0@@ -244,6 +244,9 @@ int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev, data->format != IOMMU_PASID_FORMAT_INTEL_VTD) return -EINVAL;Quoted 5 lines
drivers/iommu/intel/svm.c int intel_svm_bind_gpasid(struct iommu_domain · line 249
Quoted 3 lines
drivers/iommu/intel/svm.c +2
-0+ if (data->argsz != offsetofend(struct iommu_gpasid_bind_data, vendor.vtd)) +return -EINVAL ;Need to do size check in
intel_iommu_sva_invalidate()as well?
Quoted 5 lines
No need. The difference is that there is no vendor specific union for
intel_iommu_sva_invalidate().Generic flags are used to process invalidation data inside
intel_iommu_sva_invalidate().
Thanks for the explanation. With the nit tweaked,
Best regards,
baolu
Lu Baolu
maintainerRe: [PATCH v3 5/5] iommu/uapi: Support both kernel and user unbind guest PASID
In reply to Jacob PanHi Jacob,
drivers/iommu/iommu.c int iommu_sva_bind_gpasid(struct iommu_domain *domain, struct device *dev, · line 2086
Quoted 10 lines · Jacob Pan
drivers/iommu/iommu.c +5
-1+int __iommu_sva_unbind_gpasid (struct iommu_domain *domain,struct device *dev, +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);
__iommu_sva_unbind_gpasid() looks more like an internal only helper. How about something like iommu_sva_kunbind_gpasid()?
Best regards,
baolu
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [PATCH v3 1/5] docs: IOMMU user API
In reply to Jacob PanQuoted 88 lines · On Tue, 23 Jun 2020 10:03:53 -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 mechenics of how future extensions should be achieved are also covered in this documentation.
Signed-off-by Liu Yi L <[email protected]>Signed-off-by Jacob Pan <[email protected]>--- Documentation/userspace-api/iommu.rst | 244 ++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 Documentation/userspace-api/iommu.rstDocumentation/userspace-api/iommu.rst new file +67
-0@@ -0,0 +1,244 @@ +.. 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 page requests + +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 +----------------------
Documentation/userspace-api/iommu.rst line 77
Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10
-0+When IOMMU UAPI extension results in size increase, user such as VFIO +has to 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.
What exactly does vfio need to do to handle these?
Quoted 135 lines
Documentation/userspace-api/iommu.rst new file +135
-0+ +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 is 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 recompile 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 share 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[2]; + 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 and override out-of-range + value. If the exact argsz is based on generic flags, they are checked + here as well. + +- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data + is consumed based on flags + +Once again, use guest TLB invalidation as an example, argsz is based +on generic flags in the invalidation information. IOMMU generic code +shall process the UAPI data as the following: + +:: + + int iommu_cache_invalidate(struct iommu_domain *domain, struct device *dev, + void __user *uinfo) + { + /* Current kernel data size is the max to be copied from user */ + maxsz = sizeof(struct iommu_cache_invalidate_info); + memset((void *)&inv_info, 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_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; + /* + * User might be using a newer UAPI header which has a larger data
Documentation/userspace-api/iommu.rst line 222
Quoted 10 lines
Documentation/userspace-api/iommu.rst new file +10
-0+ * size, we shall support the existing flags within the current + * size. + */ + if (inv_info.argsz > maxsz) + inv_info.argsz = maxsz; + + /* Checking the exact argsz based on generic flags */ + if (inv_info.granularity == IOMMU_INV_GRANU_ADDR && + inv_info.argsz != offsetofend(struct iommu_cache_invalidate_info, + granu.addr_info))
Is it really reasonable to expect the user to specify argsz to the exact union element for the callback? I'd certainly expect users to simply use sizeof(struct iommu_cache_invalidate_info) and it should therefore be sufficient to test >= here rather than jump through hoops with an exact size. We're already changing inv_info.argsz above to fit our known structure, it's inconsistent to then expect it to be some exact value.
Quoted 19 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ return -EINVAL; + + if (inv_info.granularity == IOMMU_INV_GRANU_PASID && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst new file +14
-0+ granu.pasid_info)) + return -EINVAL; + + /* Copy the remaining user data _after_ minsz */ + if (copy_from_user((void *)&inv_info + minsz, uinfo + minsz, + inv_info.argsz - minsz)) + return -EFAULT; + + return domain->ops->cache_invalidate(domain, dev, &inv_info); + } + Add a wrapper + __iommu_unbind_( kernel data, same user data, kernel copy) + +Notice that in this example, since union size is determined by
Quoted 5 lines
generic +flags, all checking to argsz is validated in the generic IOMMU layer, +vendor driver does not need to check argsz. However, if union size is +based on vendor data, such as
iommu_sva_bind_gpasid(), it will be +vendor driver's responsibility to validate the exact argsz.
struct iommu_cache_invalidate_info is a good example because it explicitly states a table of type vs granularity validity. When the cache_invalidate() callback is used by an internal user we can consider it a bug in the caller if its usage falls outside of these prescribed valid combinations, ie. iommu_ops callbacks may assume a trusted caller that isn't trying to exploit any loophole. But here we've done nothing more than validated the supplied size to pass it through to a non-user hardened callback. We didn't check the version, we didn't check that any of the undefined bits in cache or granularity or padding were set, we don't know what flags might be set in the union elements. For example, if a user is able to set a flag that gets ignored now, that means we can never use that flag without potentially breaking that user in the future. If a user can pass in version 3141592654 now, then we can never use version for validation. I see that intel_iommu_sva_invalidate() does test the version, but has no obvious other hardening. I'm afraid we're being far to lax about accepting a data structure provided by a user, we should not assume good faith. Thanks,
Alex
Re: [PATCH v3 1/5] docs: IOMMU user API
Quoted 98 lines · On Fri, 26 Jun 2020 16:19:23 -0600 Alex Williamson…
Quoted 95 lines · On Tue, 23 Jun 2020 10:03:53 -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 mechenics of how future extensions should be achieved are also covered in this documentation.
Signed-off-by Liu Yi L <[email protected]>Signed-off-by Jacob Pan <[email protected]>--- Documentation/userspace-api/iommu.rst | 244 ++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 Documentation/userspace-api/iommu.rst(quoted diff) +0
-0
b/Documentation/userspace-api/iommu.rstnew file mode 100644 index 000000000000..f9e4ed90a413Documentation/userspace-api/iommu.rst new file +8
-0@@ -0,0 +1,244 @@ +.. SPDX-License-Identifier: GPL-2.0 +.. iommu: + +===================================== +IOMMU Userspace API +===================================== + +IOMMU UAPI is used for virtualization cases where communicationsare +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 page requests + +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 areself-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 sizechange. +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 tovalidate +whether it's correct and sufficient for the requested operation. +
Documentation/userspace-api/iommu.rst new file +3
-0+Compatibility Checking +---------------------- +When IOMMU UAPI extension results in size increase, user such asVFIO +has to 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
Quoted 9 lines
Quoted 6 lines
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 butwithin
+ range. The data may contain garbage.What exactly does vfio need to do to handle these?
VFIO does nothing other than returning the status from IOMMU driver. Based on the return status, users such as QEMU can cause fault conditions within the vIOMMU.
Quoted 156 lines
Quoted 154 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ +Feature Checking +---------------- +While launching a guest with vIOMMU, it is important to ensurethat 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 is expected to import kernel UAPI +headers. Backward compatibility is supported per feature flags. +For example, an older QEMU (with older kernel header) can run onnewer +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 recompile 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 share many key concepts such as device model, group, and +protection domain. Other user driver frameworks can also beextended +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 driveris 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 itsown 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 "__u32argsz" 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[2]; + 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 theninvokes +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 +3
-0+ +- Generic IOMMU layer checks argsz range and override out-of-range + value. If the exact argsz is based on generic flags, they arechecked
Documentation/userspace-api/iommu.rst new file +6
-0+ here as well. + +- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data + is consumed based on flags + +Once again, use guest TLB invalidation as an example, argsz isbased +on generic flags in the invalidation information. IOMMU generic code +shall process the UAPI data as the following:
Documentation/userspace-api/iommu.rst new file +4
-0+ +:: + + int iommu_cache_invalidate(struct iommu_domain *domain, structdevice *dev,
Documentation/userspace-api/iommu.rst new file +3
-0+ void __user *uinfo) + { + /* Current kernel data size is the max to be copied fromuser */
Documentation/userspace-api/iommu.rst new file +5
-0+ maxsz = sizeof(struct iommu_cache_invalidate_info); + memset((void *)&inv_info, 0, maxsz); + + /* + * No new spaces can be added before the variable sizedunion, 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; + /* + * User might be using a newer UAPI header which has alarger data
Documentation/userspace-api/iommu.rst new file +1
-0+ * size, we shall support the existing flags within thecurrent
Documentation/userspace-api/iommu.rst new file +8
-0+ * size. + */ + if (inv_info.argsz > maxsz) + inv_info.argsz = maxsz; + + /* Checking the exact argsz based on generic flags */ + if (inv_info.granularity == IOMMU_INV_GRANU_ADDR && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst line 222
Quoted 1 line
Documentation/userspace-api/iommu.rst new file +1
-0+ granu.addr_info))
Quoted 8 lines
Is it really reasonable to expect the user to specify argsz to the exact union element for the callback? I'd certainly expect users to simply use
sizeof(struct iommu_cache_invalidate_info)and it should therefore be sufficient to test >= here rather than jump through hoops with an exact size. We're already changing inv_info.argsz above to fit our known structure, it's inconsistent to then expect it to be some exact value.
I was thinking argsz doesn't have to be the exact struct size. It should be whatever the sufficient & correct size used by the user for a given call.
For example, current struct iommu_gpasid_bind_data {} only has VT-d data. If it gets extended with SMMU data in the union, VT-d vIOMMU emulation should only fill the union size of vt-d.
Quoted 12 lines
Quoted 12 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ return -EINVAL; + + if (inv_info.granularity == IOMMU_INV_GRANU_PASID && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst new file +5
-0+ granu.pasid_info)) + return -EINVAL; + + /* Copy the remaining user data _after_ minsz */ + if (copy_from_user((void *)&inv_info + minsz, uinfo +minsz,
Documentation/userspace-api/iommu.rst new file +1
-0+ inv_info.argsz - minsz))
Quoted 8 lines
Documentation/userspace-api/iommu.rst line 239
Quoted 8 lines
Documentation/userspace-api/iommu.rst new file +3
-0+ return -EFAULT; + + return domain->ops->cache_invalidate(domain, dev,
&inv_info);
+ }
+ Add a wrapperDocumentation/userspace-api/iommu.rst new file +2
-0+ __iommu_unbind_( kernel data, same user data, kernel copy) +
This should be removed. Sorry about the confusion. The patch does not have two data pointers, just separate APIs for kernel and user.
Quoted 7 lines
Quoted 6 lines
+Notice that in this example, since union size is determined by generic +flags, all checking to argsz is validated in the generic IOMMU layer, +vendor driver does not need to check argsz. However, if union size is +based on vendor data, such as
iommu_sva_bind_gpasid(), it will be +vendor driver's responsibility to validate the exact argsz.
Quoted 6 lines
struct
iommu_cache_invalidate_infois a good example because it explicitly states a table of type vs granularity validity. When thecache_invalidate()callback is used by an internal user we can consider it a bug in the caller if its usage falls outside of these prescribed valid combinations, ie.iommu_opscallbacks may assume a trusted caller that isn't trying to exploit any loophole.
Separate APIs are proposed in the patchset to address UAPIs with both kernel and user callers. Sorry about the last line in the example above. Currently, only unbind_gpasid() and page_response() have both kernel and userspace callers. e.g.
/* userspace caller */
int iommu_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)
We don;t expect in-kernel caller for cache invalidate in that it is implied in unmap, unbind operations.
Quoted 4 lines
But here
we've done nothing more than validated the supplied size to pass it through to a non-user hardened callback. We didn't check the version,
Yes, I should move up the version check from vendor driver.
Quoted 3 lines
we didn't check that any of the undefined bits in cache or granularity or padding were set, we don't know what flags might be set in the union elements.
You are right, we should sanitize reserved bits.
Quoted 3 lines
For example, if a user is able to set a
flag that gets ignored now, that means we can never use that flag without potentially breaking that user in the future.
Good point, all reserved/unused bits should be tested.
Quoted 7 lines
If a user can
pass in version 3141592654 now, then we can never use version for validation. I see thatintel_iommu_sva_invalidate()does test the version, but has no obvious other hardening. I'm afraid we're being far to lax about accepting a data structure provided by a user, we should not assume good faith. Thanks,
Agreed. will add checks in the IOMMU generic layer for reserved bits.
For VT-d vendor driver, we do check all bits in cache types, i.e. in intel/iommu.c
for_each_set_bit(cache_type,
(unsigned long *)&inv_info->cache,
IOMMU_CACHE_INV_TYPE_NR) {one other hardening is to check vendor argsz. This is in the bind_gpasid call.
if (data->argsz != offsetofend(struct iommu_gpasid_bind_data, vendor.vtd)) return -EINVAL;
Quoted 2 lines
Alex
[Jacob Pan]
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
RE: [PATCH v3 1/5] docs: IOMMU user API
Quoted 113 lines
From: Jacob Pan
Sent: Tuesday, June 30, 2020 7:05 AMQuoted 98 lines · On Fri, 26 Jun 2020 16:19:23 -0600 Alex Williamson…
Quoted 95 lines · On Tue, 23 Jun 2020 10:03:53 -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 mechenics of how future extensions should be achieved are also covered in this documentation.
Signed-off-by Liu Yi L <[email protected]>Signed-off-by Jacob Pan <[email protected]>--- Documentation/userspace-api/iommu.rst | 244 ++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 Documentation/userspace-api/iommu.rst(quoted diff) +0
-0
b/Documentation/userspace-api/iommu.rstnew file mode 100644 index 000000000000..f9e4ed90a413Documentation/userspace-api/iommu.rst new file +8
-0@@ -0,0 +1,244 @@ +.. SPDX-License-Identifier: GPL-2.0 +.. iommu: + +===================================== +IOMMU Userspace API +===================================== + +IOMMU UAPI is used for virtualization cases where communicationsare +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 page requests + +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 areself-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 sizechange. +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 tovalidate +whether it's correct and sufficient for the requested operation. +
Documentation/userspace-api/iommu.rst new file +3
-0+Compatibility Checking +---------------------- +When IOMMU UAPI extension results in size increase, user such asVFIO +has to 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 aQuoted 9 lines
Quoted 6 lines
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 butwithin
+ range. The data may contain garbage.What exactly does vfio need to do to handle these?
Quoted 3 lines
VFIO does nothing other than returning the status from IOMMU driver. Based on the return status, users such as QEMU can cause fault conditions within the vIOMMU.
But from above description, "user such as VFIO has to handle the following cases"...
Thanks
Kevin
Quoted 279 lines
Quoted 157 lines
Quoted 155 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ +Feature Checking +---------------- +While launching a guest with vIOMMU, it is important to ensurethat 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 is expected to import kernel UAPI +headers. Backward compatibility is supported per feature flags. +For example, an older QEMU (with older kernel header) can run onnewer +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 recompile 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 share many key concepts such as device model, group, and +protection domain. Other user driver frameworks can also beextended +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 driveris 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 itsown 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 "__u32argsz" 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[2]; + 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 theninvokes +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 +3
-0+ +- Generic IOMMU layer checks argsz range and override out-of-range + value. If the exact argsz is based on generic flags, they arechecked
Documentation/userspace-api/iommu.rst new file +6
-0+ here as well. + +- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data + is consumed based on flags + +Once again, use guest TLB invalidation as an example, argsz isbased +on generic flags in the invalidation information. IOMMU generic code +shall process the UAPI data as the following:
Documentation/userspace-api/iommu.rst new file +4
-0+ +:: + + int iommu_cache_invalidate(struct iommu_domain *domain, structdevice *dev,
Documentation/userspace-api/iommu.rst new file +3
-0+ void __user *uinfo) + { + /* Current kernel data size is the max to be copied fromuser */
Documentation/userspace-api/iommu.rst new file +5
-0+ maxsz = sizeof(struct iommu_cache_invalidate_info); + memset((void *)&inv_info, 0, maxsz); + + /* + * No new spaces can be added before the variable sizedunion, 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; + /* + * User might be using a newer UAPI header which has alarger data
Documentation/userspace-api/iommu.rst new file +1
-0+ * size, we shall support the existing flags within thecurrent
Documentation/userspace-api/iommu.rst new file +8
-0+ * size. + */ + if (inv_info.argsz > maxsz) + inv_info.argsz = maxsz; + + /* Checking the exact argsz based on generic flags */ + if (inv_info.granularity == IOMMU_INV_GRANU_ADDR && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst line 222
Quoted 1 line
Documentation/userspace-api/iommu.rst new file +1
-0+ granu.addr_info))Quoted 8 lines
Is it really reasonable to expect the user to specify argsz to the exact union element for the callback? I'd certainly expect users to simply use
sizeof(struct iommu_cache_invalidate_info)and it should therefore be sufficient to test >= here rather than jump through hoops with an exact size. We're already changing inv_info.argsz above to fit our known structure, it's inconsistent to then expect it to be some exact value.I was thinking argsz doesn't have to be the exact struct size. It should be whatever the sufficient & correct size used by the user for a given call.
For example, current struct
iommu_gpasid_bind_data{} only has VT-d data. If it gets extended with SMMU data in the union, VT-d vIOMMU emulation should only fill the union size of vt-d.Quoted 12 lines
Quoted 12 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ return -EINVAL; + + if (inv_info.granularity == IOMMU_INV_GRANU_PASID && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst new file +5
-0+ granu.pasid_info)) + return -EINVAL; + + /* Copy the remaining user data _after_ minsz */ + if (copy_from_user((void *)&inv_info + minsz, uinfo +minsz,
Documentation/userspace-api/iommu.rst new file +1
-0+ inv_info.argsz - minsz))Quoted 8 lines
Documentation/userspace-api/iommu.rst line 239
Quoted 8 lines
Documentation/userspace-api/iommu.rst new file +3
-0+ return -EFAULT; + + return domain->ops->cache_invalidate(domain, dev,
&inv_info);
+ }
+ Add a wrapperDocumentation/userspace-api/iommu.rst new file +2
-0+ __iommu_unbind_( kernel data, same user data, kernel copy) +This should be removed. Sorry about the confusion. The patch does not have two data pointers, just separate APIs for kernel and user.
Quoted 7 lines
Quoted 6 lines
+Notice that in this example, since union size is determined by generic +flags, all checking to argsz is validated in the generic IOMMU layer, +vendor driver does not need to check argsz. However, if union size is +based on vendor data, such as
iommu_sva_bind_gpasid(), it will be +vendor driver's responsibility to validate the exact argsz.Quoted 6 lines
struct
iommu_cache_invalidate_infois a good example because it explicitly states a table of type vs granularity validity. When thecache_invalidate()callback is used by an internal user we can consider it a bug in the caller if its usage falls outside of these prescribed valid combinations, ie.iommu_opscallbacks may assume a trusted caller that isn't trying to exploit any loophole.Separate APIs are proposed in the patchset to address UAPIs with both kernel and user callers. Sorry about the last line in the example above. Currently, only
unbind_gpasid()andpage_response()have both kernel and userspace callers. e.g./* userspace caller */
int iommu_sva_unbind_gpasid(structiommu_domain*domain, struct
device *dev,
void__user*udata)/* in-kernel caller */
int __iommu_sva_unbind_gpasid(structiommu_domain*domain, struct
device *dev,
structiommu_gpasid_bind_data*data)We don;t expect in-kernel caller for cache invalidate in that it is implied in unmap, unbind operations.
Quoted 4 lines
But here
we've done nothing more than validated the supplied size to pass it through to a non-user hardened callback. We didn't check the version,Yes, I should move up the version check from vendor driver.
Quoted 3 lines
we didn't check that any of the undefined bits in cache or granularity or padding were set, we don't know what flags might be set in the union elements.
You are right, we should sanitize reserved bits.
Quoted 3 lines
For example, if a user is able to set a
flag that gets ignored now, that means we can never use that flag without potentially breaking that user in the future.Good point, all reserved/unused bits should be tested.
Quoted 7 lines
If a user can
pass in version 3141592654 now, then we can never use version for validation. I see thatintel_iommu_sva_invalidate()does test the version, but has no obvious other hardening. I'm afraid we're being far to lax about accepting a data structure provided by a user, we should not assume good faith. Thanks,Agreed. will add checks in the IOMMU generic layer for reserved bits.
For VT-d vendor driver, we do check all bits in cache types, i.e. inintel/iommu.cfor_each_set_bit(cache_type, (unsigned long *)&inv_info->cache, IOMMU_CACHE_INV_TYPE_NR) {one other hardening is to check vendor argsz. This is in the
bind_gpasidcall.if (data->argsz != offsetofend(struct iommu_gpasid_bind_data, vendor.vtd)) return -EINVAL;Quoted 2 lines
Alex
[Jacob Pan]
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [PATCH v3 1/5] docs: IOMMU user API
Quoted 115 lines · Kevin
Quoted 115 lines
From: Jacob Pan
Sent: Tuesday, June 30, 2020 7:05 AMQuoted 109 lines · On Fri, 26 Jun 2020 16:19:23 -0600 Alex Williamson…
Quoted 95 lines · On Tue, 23 Jun 2020 10:03:53 -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 mechenics of how future extensions should be achieved are also covered in this documentation.
Signed-off-by Liu Yi L <[email protected]>Signed-off-by Jacob Pan <[email protected]>--- Documentation/userspace-api/iommu.rst | 244++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644
Documentation/userspace-api/iommu.rst(quoted diff) +0
-0
b/Documentation/userspace-api/iommu.rstnew file mode 100644 index 000000000000..f9e4ed90a413Documentation/userspace-api/iommu.rst new file +8
-0@@ -0,0 +1,244 @@ +.. SPDX-License-Identifier: GPL-2.0 +.. iommu: + +===================================== +IOMMU Userspace API +===================================== + +IOMMU UAPI is used for virtualization cases wherecommunications 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.
Documentation/userspace-api/iommu.rst new file +2
-0+ +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:Documentation/userspace-api/iommu.rst new file +15
-0+ +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 page requests + +Requirements +============ +The IOMMU UAPIs are generic and extensible to meet thefollowing +requirements:
Documentation/userspace-api/iommu.rst new file +8
-0+ +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 areself-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 +3
-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. +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 +3
-0+Compatibility Checking +---------------------- +When IOMMU UAPI extension results in size increase, user suchas VFIO +has to handle the following cases:
+
+1. User and kernel has exact size match
+2. An older user with older kernel header (smaller UAPI size)Quoted 8 lines
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.What exactly does vfio need to do to handle these?
Quoted 7 lines
Quoted 3 lines
VFIO does nothing other than returning the status from IOMMU driver. Based on the return status, users such as QEMU can cause fault conditions within the vIOMMU.
But from above description, "user such as VFIO has to handle the following cases"...
I really meant the whole UAPI framework. How about:
"When IOMMU UAPI extension results in size increase, the following cases must be handled:"
Quoted 286 lines
Thanks
KevinQuoted 283 lines
Quoted 159 lines
Quoted 157 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ +Feature Checking +---------------- +While launching a guest with vIOMMU, it is important to ensurethat 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
Documentation/userspace-api/iommu.rst new file +9
-0+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 is expected to import kernelUAPI +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 recompile 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).Documentation/userspace-api/iommu.rst new file +8
-0+ +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 +6
-0+Documentation/driver-api/vfio.rst. + + +Data Passing Example with VFIO +------------------------------ +As the ubiquitous userspace driver framework, VFIO is alreadyIOMMU +aware and share 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::Documentation/userspace-api/iommu.rst new file +8
-0+ + struct { + __u32 argsz; + __u32 flags; + __u8 data[]; + }; + +Here data[] contains the IOMMU UAPI data structures. VFIO hasthe +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 "__u32argsz" 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[2]; + 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 theninvokes +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 and override out-of-range
+ value. If the exact argsz is based on generic flags, they are checkedDocumentation/userspace-api/iommu.rst new file +3
-0+ here as well. + +- Vendor IOMMU driver checks argsz based on vendor flags, UAPIdata
Documentation/userspace-api/iommu.rst new file +3
-0+ is consumed based on flags + +Once again, use guest TLB invalidation as an example, argsz isbased +on generic flags in the invalidation information. IOMMU generic code +shall process the UAPI data as the following:
Documentation/userspace-api/iommu.rst new file +4
-0+ +:: + + int iommu_cache_invalidate(struct iommu_domain *domain, structdevice *dev,
Documentation/userspace-api/iommu.rst new file +3
-0+ void __user *uinfo) + { + /* Current kernel data size is the max to be copiedfrom user */
Documentation/userspace-api/iommu.rst new file +5
-0+ maxsz = sizeof(struct iommu_cache_invalidate_info); + memset((void *)&inv_info, 0, maxsz); + + /* + * No new spaces can be added before the variable sizedunion, 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; + /* + * User might be using a newer UAPI header which has alarger data
Documentation/userspace-api/iommu.rst new file +1
-0+ * size, we shall support the existing flags within thecurrent
Documentation/userspace-api/iommu.rst new file +8
-0+ * size. + */ + if (inv_info.argsz > maxsz) + inv_info.argsz = maxsz; + + /* Checking the exact argsz based on generic flags */ + if (inv_info.granularity == IOMMU_INV_GRANU_ADDR && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst line 222
Quoted 1 line
Documentation/userspace-api/iommu.rst new file +1
-0+ granu.addr_info))Quoted 8 lines
Is it really reasonable to expect the user to specify argsz to the exact union element for the callback? I'd certainly expect users to simply use
sizeof(struct iommu_cache_invalidate_info)and it should therefore be sufficient to test >= here rather than jump through hoops with an exact size. We're already changing inv_info.argsz above to fit our known structure, it's inconsistent to then expect it to be some exact value.I was thinking argsz doesn't have to be the exact struct size. It should be whatever the sufficient & correct size used by the user for a given call.
For example, current struct
iommu_gpasid_bind_data{} only has VT-d data. If it gets extended with SMMU data in the union, VT-d vIOMMU emulation should only fill the union size of vt-d.Quoted 12 lines
Quoted 12 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ return -EINVAL; + + if (inv_info.granularity == IOMMU_INV_GRANU_PASID && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst new file +5
-0+ granu.pasid_info)) + return -EINVAL; + + /* Copy the remaining user data _after_ minsz */ + if (copy_from_user((void *)&inv_info + minsz, uinfo +minsz,
Documentation/userspace-api/iommu.rst new file +1
-0+ inv_info.argsz - minsz))Quoted 8 lines
Documentation/userspace-api/iommu.rst line 239
Quoted 8 lines
Documentation/userspace-api/iommu.rst new file +3
-0+ return -EFAULT; + + return domain->ops->cache_invalidate(domain, dev,
&inv_info);
+ }
+ Add a wrapperDocumentation/userspace-api/iommu.rst new file +2
-0+ __iommu_unbind_( kernel data, same user data, kernel copy) +This should be removed. Sorry about the confusion. The patch does not have two data pointers, just separate APIs for kernel and user.
Quoted 7 lines
Quoted 6 lines
+Notice that in this example, since union size is determined by generic +flags, all checking to argsz is validated in the generic IOMMU layer, +vendor driver does not need to check argsz. However, if union size is +based on vendor data, such as
iommu_sva_bind_gpasid(), it will be +vendor driver's responsibility to validate the exact argsz.Quoted 7 lines
struct
iommu_cache_invalidate_infois a good example because it explicitly states a table of type vs granularity validity. When thecache_invalidate()callback is used by an internal user we can consider it a bug in the caller if its usage falls outside of these prescribed valid combinations, ie.iommu_opscallbacks may assume a trusted caller that isn't trying to exploit any loophole.Separate APIs are proposed in the patchset to address UAPIs with both kernel and user callers. Sorry about the last line in the example above. Currently, only
unbind_gpasid()andpage_response()have both kernel and userspace callers. e.g./* userspace caller */
int iommu_sva_unbind_gpasid(structiommu_domain*domain, struct
device *dev,
void__user*udata)/* in-kernel caller */
int __iommu_sva_unbind_gpasid(structiommu_domain*domain, struct
device *dev,
structiommu_gpasid_bind_data
*data)We don;t expect in-kernel caller for cache invalidate in that it is implied in unmap, unbind operations.
Quoted 4 lines
But here
we've done nothing more than validated the supplied size to pass it through to a non-user hardened callback. We didn't check the version,Yes, I should move up the version check from vendor driver.
Quoted 3 lines
we didn't check that any of the undefined bits in cache or granularity or padding were set, we don't know what flags might be set in the union elements.
You are right, we should sanitize reserved bits.
Quoted 3 lines
For example, if a user is able to set a
flag that gets ignored now, that means we can never use that flag without potentially breaking that user in the future.Good point, all reserved/unused bits should be tested.
Quoted 7 lines
If a user can
pass in version 3141592654 now, then we can never use version for validation. I see thatintel_iommu_sva_invalidate()does test the version, but has no obvious other hardening. I'm afraid we're being far to lax about accepting a data structure provided by a user, we should not assume good faith. Thanks,Agreed. will add checks in the IOMMU generic layer for reserved bits.
For VT-d vendor driver, we do check all bits in cache types, i.e. inintel/iommu.cfor_each_set_bit(cache_type, (unsigned long *)&inv_info->cache, IOMMU_CACHE_INV_TYPE_NR) {one other hardening is to check vendor argsz. This is in the
bind_gpasidcall.if (data->argsz != offsetofend(struct iommu_gpasid_bind_data, vendor.vtd)) return -EINVAL;Quoted 2 lines
Alex
[Jacob Pan]
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
[Jacob Pan]
_______________________________________________
iommu mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/iommu
Re: [PATCH v3 1/5] docs: IOMMU user API
In reply to Jacob PanQuoted 278 lines · On Mon, 29 Jun 2020 16:05:18 -0700 Jacob Pan <[email protected]>…
Quoted 98 lines · On Fri, 26 Jun 2020 16:19:23 -0600 Alex Williamson…
Quoted 95 lines · On Tue, 23 Jun 2020 10:03:53 -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 mechenics of how future extensions should be achieved are also covered in this documentation.
Signed-off-by Liu Yi L <[email protected]>Signed-off-by Jacob Pan <[email protected]>--- Documentation/userspace-api/iommu.rst | 244 ++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 Documentation/userspace-api/iommu.rst(quoted diff) +0
-0
b/Documentation/userspace-api/iommu.rstnew file mode 100644 index 000000000000..f9e4ed90a413Documentation/userspace-api/iommu.rst new file +8
-0@@ -0,0 +1,244 @@ +.. SPDX-License-Identifier: GPL-2.0 +.. iommu: + +===================================== +IOMMU Userspace API +===================================== + +IOMMU UAPI is used for virtualization cases where communicationsare +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 page requests + +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 areself-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 sizechange. +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 tovalidate +whether it's correct and sufficient for the requested operation. +
Documentation/userspace-api/iommu.rst new file +3
-0+Compatibility Checking +---------------------- +When IOMMU UAPI extension results in size increase, user such asVFIO +has to 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 aQuoted 9 lines
Quoted 6 lines
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 butwithin
+ range. The data may contain garbage.What exactly does vfio need to do to handle these?
VFIO does nothing other than returning the status from IOMMU driver. Based on the return status, users such as QEMU can cause fault conditions within the vIOMMU.
Quoted 156 lines
Quoted 154 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ +Feature Checking +---------------- +While launching a guest with vIOMMU, it is important to ensurethat 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 is expected to import kernel UAPI +headers. Backward compatibility is supported per feature flags. +For example, an older QEMU (with older kernel header) can run onnewer +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 recompile 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 share many key concepts such as device model, group, and +protection domain. Other user driver frameworks can also beextended +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 driveris 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 itsown 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 "__u32argsz" 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[2]; + 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 theninvokes +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 +3
-0+ +- Generic IOMMU layer checks argsz range and override out-of-range + value. If the exact argsz is based on generic flags, they arechecked
Documentation/userspace-api/iommu.rst new file +6
-0+ here as well. + +- Vendor IOMMU driver checks argsz based on vendor flags, UAPI data + is consumed based on flags + +Once again, use guest TLB invalidation as an example, argsz isbased +on generic flags in the invalidation information. IOMMU generic code +shall process the UAPI data as the following:
Documentation/userspace-api/iommu.rst new file +4
-0+ +:: + + int iommu_cache_invalidate(struct iommu_domain *domain, structdevice *dev,
Documentation/userspace-api/iommu.rst new file +3
-0+ void __user *uinfo) + { + /* Current kernel data size is the max to be copied fromuser */
Documentation/userspace-api/iommu.rst new file +5
-0+ maxsz = sizeof(struct iommu_cache_invalidate_info); + memset((void *)&inv_info, 0, maxsz); + + /* + * No new spaces can be added before the variable sizedunion, 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; + /* + * User might be using a newer UAPI header which has alarger data
Documentation/userspace-api/iommu.rst new file +1
-0+ * size, we shall support the existing flags within thecurrent
Documentation/userspace-api/iommu.rst new file +8
-0+ * size. + */ + if (inv_info.argsz > maxsz) + inv_info.argsz = maxsz; + + /* Checking the exact argsz based on generic flags */ + if (inv_info.granularity == IOMMU_INV_GRANU_ADDR && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst line 222
Quoted 1 line
Documentation/userspace-api/iommu.rst new file +1
-0+ granu.addr_info))Quoted 8 lines
Is it really reasonable to expect the user to specify argsz to the exact union element for the callback? I'd certainly expect users to simply use
sizeof(struct iommu_cache_invalidate_info)and it should therefore be sufficient to test >= here rather than jump through hoops with an exact size. We're already changing inv_info.argsz above to fit our known structure, it's inconsistent to then expect it to be some exact value.
Quoted 7 lines
I was thinking argsz doesn't have to be the exact struct size. It should be whatever the sufficient & correct size used by the user for a given call.
For example, current struct
iommu_gpasid_bind_data{} only has VT-d data. If it gets extended with SMMU data in the union, VT-d vIOMMU emulation should only fill the union size of vt-d.
But the user is simply going to have a struct iommu_gpasid_bind_data and set argsz to sizeof that struct. The user is providing that entire struct as the arg, so it doesn't really make sense to pinpoint the last field of the union they chose to use. The fields of the structure define which union is applicable. If you're following the vfio interface as an example, sufficiently sized is all we require, we don't ask for union member level granularity, which I think is confusing and error prone for users.
Quoted 45 lines
Quoted 12 lines
Quoted 12 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ return -EINVAL; + + if (inv_info.granularity == IOMMU_INV_GRANU_PASID && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst new file +5
-0+ granu.pasid_info)) + return -EINVAL; + + /* Copy the remaining user data _after_ minsz */ + if (copy_from_user((void *)&inv_info + minsz, uinfo +minsz,
Documentation/userspace-api/iommu.rst new file +1
-0+ inv_info.argsz - minsz))Quoted 8 lines
Documentation/userspace-api/iommu.rst line 239
Quoted 8 lines
Documentation/userspace-api/iommu.rst new file +3
-0+ return -EFAULT; + + return domain->ops->cache_invalidate(domain, dev,
&inv_info);
+ }
+ Add a wrapperDocumentation/userspace-api/iommu.rst new file +2
-0+ __iommu_unbind_( kernel data, same user data, kernel copy) +This should be removed. Sorry about the confusion. The patch does not have two data pointers, just separate APIs for kernel and user.
Quoted 7 lines
Quoted 6 lines
+Notice that in this example, since union size is determined by generic +flags, all checking to argsz is validated in the generic IOMMU layer, +vendor driver does not need to check argsz. However, if union size is +based on vendor data, such as
iommu_sva_bind_gpasid(), it will be +vendor driver's responsibility to validate the exact argsz.Quoted 6 lines
struct
iommu_cache_invalidate_infois a good example because it explicitly states a table of type vs granularity validity. When thecache_invalidate()callback is used by an internal user we can consider it a bug in the caller if its usage falls outside of these prescribed valid combinations, ie.iommu_opscallbacks may assume a trusted caller that isn't trying to exploit any loophole.Separate APIs are proposed in the patchset to address UAPIs with both kernel and user callers. Sorry about the last line in the example above. Currently, only
unbind_gpasid()andpage_response()have both kernel and userspace callers. e.g./* userspace caller */
int iommu_sva_unbind_gpasid(structiommu_domain*domain, struct device *dev,
void__user*udata)
Quoted 6 lines
/* in-kernel caller */
int __iommu_sva_unbind_gpasid(structiommu_domain*domain, struct device *dev,
structiommu_gpasid_bind_data*data)We don;t expect in-kernel caller for cache invalidate in that it is implied in unmap, unbind operations.
That specific function was only an example of an interface which has invalid combinations where in-kernel it's the caller's responsibility to abide by the rules, but a user interface needs further validation.
Quoted 32 lines
Quoted 4 lines
But here
we've done nothing more than validated the supplied size to pass it through to a non-user hardened callback. We didn't check the version,Yes, I should move up the version check from vendor driver.
Quoted 3 lines
we didn't check that any of the undefined bits in cache or granularity or padding were set, we don't know what flags might be set in the union elements.
You are right, we should sanitize reserved bits.
Quoted 3 lines
For example, if a user is able to set a
flag that gets ignored now, that means we can never use that flag without potentially breaking that user in the future.Good point, all reserved/unused bits should be tested.
Quoted 7 lines
If a user can
pass in version 3141592654 now, then we can never use version for validation. I see thatintel_iommu_sva_invalidate()does test the version, but has no obvious other hardening. I'm afraid we're being far to lax about accepting a data structure provided by a user, we should not assume good faith. Thanks,Agreed. will add checks in the IOMMU generic layer for reserved bits.
For VT-d vendor driver, we do check all bits in cache types, i.e. inintel/iommu.cfor_each_set_bit(cache_type, (unsigned long *)&inv_info->cache, IOMMU_CACHE_INV_TYPE_NR) {
Quoted 5 lines
one other hardening is to check vendor argsz. This is in the
bind_gpasidcall.if (data->argsz != offsetofend(struct iommu_gpasid_bind_data, vendor.vtd)) return -EINVAL;
This is the same issue I raise above whether this is actually too strict. The user is providing a full structure as the arg, the structure defines the valid fields via its content, it shouldn't be necessary to have field level granularity for argsz. Thanks,
Alex
Re: [PATCH v3 1/5] docs: IOMMU user API
Hi Alex,
All points below are taken. I have sent out v4 that addresses these feedbacks. Thanks for the review.
Jacob
Quoted 397 lines · On Tue, 7 Jul 2020 15:40:54 -0600 Alex Williamson <[email protected]>…
Quoted 282 lines · On Mon, 29 Jun 2020 16:05:18 -0700 Jacob Pan <[email protected]>…
Quoted 100 lines · On Fri, 26 Jun 2020 16:19:23 -0600 Alex Williamson…
Quoted 97 lines · On Tue, 23 Jun 2020 10:03:53 -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 mechenics of how future extensions should be achieved are also covered in this documentation.
Signed-off-by Liu Yi L <[email protected]>Signed-off-by Jacob Pan <[email protected]>--- Documentation/userspace-api/iommu.rst | 244++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644
Documentation/userspace-api/iommu.rst(quoted diff) +0
-0
b/Documentation/userspace-api/iommu.rstnew file mode 100644 index 000000000000..f9e4ed90a413Documentation/userspace-api/iommu.rst new file +8
-0@@ -0,0 +1,244 @@ +.. SPDX-License-Identifier: GPL-2.0 +.. iommu: + +===================================== +IOMMU Userspace API +===================================== + +IOMMU UAPI is used for virtualization cases wherecommunications 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.
Documentation/userspace-api/iommu.rst new file +2
-0+ +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:Documentation/userspace-api/iommu.rst new file +15
-0+ +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 page requests + +Requirements +============ +The IOMMU UAPIs are generic and extensible to meet thefollowing +requirements:
Documentation/userspace-api/iommu.rst new file +8
-0+ +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 areself-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 +3
-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. +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 +3
-0+Compatibility Checking +---------------------- +When IOMMU UAPI extension results in size increase, user suchas VFIO +has to 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)Quoted 9 lines
Quoted 6 lines
+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.What exactly does vfio need to do to handle these?
VFIO does nothing other than returning the status from IOMMU driver. Based on the return status, users such as QEMU can cause fault conditions within the vIOMMU.
Quoted 158 lines
Quoted 156 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ +Feature Checking +---------------- +While launching a guest with vIOMMU, it is important to ensurethat 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
Documentation/userspace-api/iommu.rst new file +9
-0+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 is expected to import kernelUAPI +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 recompile 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).Documentation/userspace-api/iommu.rst new file +8
-0+ +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 +6
-0+Documentation/driver-api/vfio.rst. + + +Data Passing Example with VFIO +------------------------------ +As the ubiquitous userspace driver framework, VFIO is alreadyIOMMU +aware and share 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::Documentation/userspace-api/iommu.rst new file +8
-0+ + struct { + __u32 argsz; + __u32 flags; + __u8 data[]; + }; + +Here data[] contains the IOMMU UAPI data structures. VFIO hasthe +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 "__u32argsz" 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[2]; + 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 theninvokes +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 and override out-of-range
+ value. If the exact argsz is based on generic flags, they are checkedDocumentation/userspace-api/iommu.rst new file +3
-0+ here as well. + +- Vendor IOMMU driver checks argsz based on vendor flags, UAPIdata
Documentation/userspace-api/iommu.rst new file +3
-0+ is consumed based on flags + +Once again, use guest TLB invalidation as an example, argsz isbased +on generic flags in the invalidation information. IOMMU generic code +shall process the UAPI data as the following:
Documentation/userspace-api/iommu.rst new file +4
-0+ +:: + + int iommu_cache_invalidate(struct iommu_domain *domain, structdevice *dev,
Documentation/userspace-api/iommu.rst new file +3
-0+ void __user *uinfo) + { + /* Current kernel data size is the max to be copiedfrom user */
Documentation/userspace-api/iommu.rst new file +5
-0+ maxsz = sizeof(struct iommu_cache_invalidate_info); + memset((void *)&inv_info, 0, maxsz); + + /* + * No new spaces can be added before the variable sizedunion, 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; + /* + * User might be using a newer UAPI header which has alarger data
Documentation/userspace-api/iommu.rst new file +1
-0+ * size, we shall support the existing flags within thecurrent
Documentation/userspace-api/iommu.rst new file +8
-0+ * size. + */ + if (inv_info.argsz > maxsz) + inv_info.argsz = maxsz; + + /* Checking the exact argsz based on generic flags */ + if (inv_info.granularity == IOMMU_INV_GRANU_ADDR && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst line 222
Quoted 1 line
Documentation/userspace-api/iommu.rst new file +1
-0+ granu.addr_info))Quoted 8 lines
Is it really reasonable to expect the user to specify argsz to the exact union element for the callback? I'd certainly expect users to simply use
sizeof(struct iommu_cache_invalidate_info)and it should therefore be sufficient to test >= here rather than jump through hoops with an exact size. We're already changing inv_info.argsz above to fit our known structure, it's inconsistent to then expect it to be some exact value.Quoted 7 lines
I was thinking argsz doesn't have to be the exact struct size. It should be whatever the sufficient & correct size used by the user for a given call.
For example, current struct
iommu_gpasid_bind_data{} only has VT-d data. If it gets extended with SMMU data in the union, VT-d vIOMMU emulation should only fill the union size of vt-d.But the user is simply going to have a struct
iommu_gpasid_bind_dataand set argsz to sizeof that struct. The user is providing that entire struct as the arg, so it doesn't really make sense to pinpoint the last field of the union they chose to use. The fields of the structure define which union is applicable. If you're following the vfio interface as an example, sufficiently sized is all we require, we don't ask for union member level granularity, which I think is confusing and error prone for users.Quoted 46 lines
Quoted 12 lines
Quoted 12 lines
Documentation/userspace-api/iommu.rst new file +4
-0+ return -EINVAL; + + if (inv_info.granularity == IOMMU_INV_GRANU_PASID && + inv_info.argsz != offsetofend(struct
iommu_cache_invalidate_info,Documentation/userspace-api/iommu.rst new file +5
-0+ granu.pasid_info)) + return -EINVAL; + + /* Copy the remaining user data _after_ minsz */ + if (copy_from_user((void *)&inv_info + minsz, uinfo +minsz,
Documentation/userspace-api/iommu.rst new file +1
-0+ inv_info.argsz - minsz))Quoted 8 lines
Documentation/userspace-api/iommu.rst line 239
Quoted 8 lines
Documentation/userspace-api/iommu.rst new file +3
-0+ return -EFAULT; + + return domain->ops->cache_invalidate(domain, dev,
&inv_info);
+ }
+ Add a wrapperDocumentation/userspace-api/iommu.rst new file +2
-0+ __iommu_unbind_( kernel data, same user data, kernel copy) +This should be removed. Sorry about the confusion. The patch does not have two data pointers, just separate APIs for kernel and user.
Quoted 7 lines
Quoted 6 lines
+Notice that in this example, since union size is determined by generic +flags, all checking to argsz is validated in the generic IOMMU layer, +vendor driver does not need to check argsz. However, if union size is +based on vendor data, such as
iommu_sva_bind_gpasid(), it will be +vendor driver's responsibility to validate the exact argsz.Quoted 7 lines
struct
iommu_cache_invalidate_infois a good example because it explicitly states a table of type vs granularity validity. When thecache_invalidate()callback is used by an internal user we can consider it a bug in the caller if its usage falls outside of these prescribed valid combinations, ie.iommu_opscallbacks may assume a trusted caller that isn't trying to exploit any loophole.Separate APIs are proposed in the patchset to address UAPIs with both kernel and user callers. Sorry about the last line in the example above. Currently, only
unbind_gpasid()andpage_response()have both kernel and userspace callers. e.g./* userspace caller */
int iommu_sva_unbind_gpasid(structiommu_domain*domain, struct
device *dev, void__user*udata)Quoted 6 lines
/* in-kernel caller */
int __iommu_sva_unbind_gpasid(structiommu_domain*domain,
struct device *dev, structiommu_gpasid_bind_data*data)We don;t expect in-kernel caller for cache invalidate in that it is implied in unmap, unbind operations.
That specific function was only an example of an interface which has invalid combinations where in-kernel it's the caller's responsibility to abide by the rules, but a user interface needs further validation.
Quoted 32 lines
Quoted 4 lines
But here
we've done nothing more than validated the supplied size to pass it through to a non-user hardened callback. We didn't check the version,Yes, I should move up the version check from vendor driver.
Quoted 3 lines
we didn't check that any of the undefined bits in cache or granularity or padding were set, we don't know what flags might be set in the union elements.
You are right, we should sanitize reserved bits.
Quoted 3 lines
For example, if a user is able to set a
flag that gets ignored now, that means we can never use that flag without potentially breaking that user in the future.Good point, all reserved/unused bits should be tested.
Quoted 7 lines
If a user can
pass in version 3141592654 now, then we can never use version for validation. I see thatintel_iommu_sva_invalidate()does test the version, but has no obvious other hardening. I'm afraid we're being far to lax about accepting a data structure provided by a user, we should not assume good faith. Thanks,Agreed. will add checks in the IOMMU generic layer for reserved bits.
For VT-d vendor driver, we do check all bits in cache types, i.e. inintel/iommu.cfor_each_set_bit(cache_type, (unsigned long *)&inv_info->cache, IOMMU_CACHE_INV_TYPE_NR) {Quoted 5 lines
one other hardening is to check vendor argsz. This is in the
bind_gpasidcall.if (data->argsz != offsetofend(struct
iommu_gpasid_bind_data, vendor.vtd)) return-EINVAL;
Quoted 7 lines
This is the same issue I raise above whether this is actually too strict. The user is providing a full structure as the arg, the structure defines the valid fields via its content, it shouldn't be necessary to have field level granularity for argsz. Thanks,
Alex
[Jacob Pan]