iommu: Rename ops->domain_alloc_user() to domain_alloc_paging_flags()

Now that the main domain allocating path is calling this function it
doesn't make sense to leave it named _user. Change the name to
alloc_paging_flags() to mirror the new iommu_paging_domain_alloc_flags()
function.

A driver should implement only one of ops->domain_alloc_paging() or
ops->domain_alloc_paging_flags(). The former is a simpler interface with
less boiler plate that the majority of drivers use. The latter is for
drivers with a greater feature set (PASID, multiple page table support,
advanced iommufd support, nesting, etc). Additional patches will be needed
to achieve this.

Link: https://patch.msgid.link/r/2-v1-c252ebdeb57b+329-iommu_paging_flags_jgg@nvidia.com
Reviewed-by: Lu Baolu <baolu.lu@linux.intel.com>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>

diff --git a/drivers/iommu/amd/iommu.c b/drivers/iommu/amd/iommu.c
index 5ce8e6504ba7ee63a1867d652294304ef11e8a37..3f691e1fd22ce4bb5433d852512c7dbf90233e8e 100644 (file)
--- a/drivers/iommu/amd/iommu.c
+++ b/drivers/iommu/amd/iommu.c
@@ -2407,9 +2407,8 @@ static struct iommu_domain *amd_iommu_domain_alloc(unsigned int type)
 }
 
 static struct iommu_domain *
-amd_iommu_domain_alloc_user(struct device *dev, u32 flags,
-                           struct iommu_domain *parent,
-                           const struct iommu_user_data *user_data)
+amd_iommu_domain_alloc_paging_flags(struct device *dev, u32 flags,
+                                   const struct iommu_user_data *user_data)
 
 {
        unsigned int type = IOMMU_DOMAIN_UNMANAGED;
@@ -2420,7 +2419,7 @@ amd_iommu_domain_alloc_user(struct device *dev, u32 flags,
        if (dev)
                iommu = get_amd_iommu_from_dev(dev);
 
-       if ((flags & ~supported_flags) || parent || user_data)
+       if ((flags & ~supported_flags) || user_data)
                return ERR_PTR(-EOPNOTSUPP);
 
        /* Allocate domain with v2 page table if IOMMU supports PASID. */
@@ -2884,7 +2883,7 @@ const struct iommu_ops amd_iommu_ops = {
        .release_domain = &release_domain,
        .identity_domain = &identity_domain.domain,
        .domain_alloc = amd_iommu_domain_alloc,
-       .domain_alloc_user = amd_iommu_domain_alloc_user,
+       .domain_alloc_paging_flags = amd_iommu_domain_alloc_paging_flags,
        .domain_alloc_sva = amd_iommu_domain_alloc_sva,
        .probe_device = amd_iommu_probe_device,
        .release_device = amd_iommu_release_device,

diff --git a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c
index 04630dbfedd92ab748dd64091532fd4174e974b4..e4ebd9e12ad468f132ed3646128c6b9ba2c98561 100644 (file)
--- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c
+++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c
@@ -3132,9 +3132,8 @@ static struct iommu_domain arm_smmu_blocked_domain = {
 };
 
 static struct iommu_domain *
-arm_smmu_domain_alloc_user(struct device *dev, u32 flags,
-                          struct iommu_domain *parent,
-                          const struct iommu_user_data *user_data)
+arm_smmu_domain_alloc_paging_flags(struct device *dev, u32 flags,
+                                  const struct iommu_user_data *user_data)
 {
        struct arm_smmu_master *master = dev_iommu_priv_get(dev);
        const u32 PAGING_FLAGS = IOMMU_HWPT_ALLOC_DIRTY_TRACKING |
@@ -3145,7 +3144,7 @@ arm_smmu_domain_alloc_user(struct device *dev, u32 flags,
 
        if (flags & ~PAGING_FLAGS)
                return ERR_PTR(-EOPNOTSUPP);
-       if (parent || user_data)
+       if (user_data)
                return ERR_PTR(-EOPNOTSUPP);
 
        if (flags & IOMMU_HWPT_ALLOC_PASID)
@@ -3546,7 +3545,7 @@ static struct iommu_ops arm_smmu_ops = {
        .hw_info                = arm_smmu_hw_info,
        .domain_alloc_paging    = arm_smmu_domain_alloc_paging,
        .domain_alloc_sva       = arm_smmu_sva_domain_alloc,
-       .domain_alloc_user      = arm_smmu_domain_alloc_user,
+       .domain_alloc_paging_flags = arm_smmu_domain_alloc_paging_flags,
        .probe_device           = arm_smmu_probe_device,
        .release_device         = arm_smmu_release_device,
        .device_group           = arm_smmu_device_group,

diff --git a/drivers/iommu/intel/iommu.c b/drivers/iommu/intel/iommu.c
index 6f11a075114f7a72a351b6a1ff462ad46429c504..7d0acb74d5a54386194d4df1ec01f6f69150fb02 100644 (file)
--- a/drivers/iommu/intel/iommu.c
+++ b/drivers/iommu/intel/iommu.c
@@ -3328,9 +3328,8 @@ static struct dmar_domain *paging_domain_alloc(struct device *dev, bool first_st
 }
 
 static struct iommu_domain *
-intel_iommu_domain_alloc_user(struct device *dev, u32 flags,
-                             struct iommu_domain *parent,
-                             const struct iommu_user_data *user_data)
+intel_iommu_domain_alloc_paging_flags(struct device *dev, u32 flags,
+                                     const struct iommu_user_data *user_data)
 {
        struct device_domain_info *info = dev_iommu_priv_get(dev);
        bool dirty_tracking = flags & IOMMU_HWPT_ALLOC_DIRTY_TRACKING;
@@ -3340,9 +3339,6 @@ intel_iommu_domain_alloc_user(struct device *dev, u32 flags,
        struct iommu_domain *domain;
        bool first_stage;
 
-       if (parent)
-               return ERR_PTR(-EOPNOTSUPP);
-
        if (flags &
            (~(IOMMU_HWPT_ALLOC_NEST_PARENT | IOMMU_HWPT_ALLOC_DIRTY_TRACKING
               | IOMMU_HWPT_FAULT_ID_VALID)))
@@ -4468,7 +4464,7 @@ const struct iommu_ops intel_iommu_ops = {
        .identity_domain        = &identity_domain,
        .capable                = intel_iommu_capable,
        .hw_info                = intel_iommu_hw_info,
-       .domain_alloc_user      = intel_iommu_domain_alloc_user,
+       .domain_alloc_paging_flags = intel_iommu_domain_alloc_paging_flags,
        .domain_alloc_sva       = intel_svm_domain_alloc,
        .domain_alloc_paging    = intel_iommu_domain_alloc_paging,
        .domain_alloc_nested    = intel_iommu_domain_alloc_nested,

diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
index 7618e9c65d3fa8c7c6753a0999def021548a6d8d..9bc0c74cca3c7e8f93b8ab2a27f164384e104a77 100644 (file)
--- a/drivers/iommu/iommu.c
+++ b/drivers/iommu/iommu.c
@@ -1987,8 +1987,8 @@ __iommu_paging_domain_alloc_flags(struct device *dev, unsigned int type,
 
        if (ops->domain_alloc_paging && !flags)
                domain = ops->domain_alloc_paging(dev);
-       else if (ops->domain_alloc_user)
-               domain = ops->domain_alloc_user(dev, flags, NULL, NULL);
+       else if (ops->domain_alloc_paging_flags)
+               domain = ops->domain_alloc_paging_flags(dev, flags, NULL);
        else if (ops->domain_alloc && !flags)
                domain = ops->domain_alloc(IOMMU_DOMAIN_UNMANAGED);
        else

diff --git a/drivers/iommu/iommufd/hw_pagetable.c b/drivers/iommu/iommufd/hw_pagetable.c
index ec3c64a8c79633952f601aa9e6bd08926a982d30..ce03c380465154a4db1af4232989587c91d17c75 100644 (file)
--- a/drivers/iommu/iommufd/hw_pagetable.c
+++ b/drivers/iommu/iommufd/hw_pagetable.c
@@ -119,7 +119,7 @@ iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas,
 
        lockdep_assert_held(&ioas->mutex);
 
-       if ((flags || user_data) && !ops->domain_alloc_user)
+       if ((flags || user_data) && !ops->domain_alloc_paging_flags)
                return ERR_PTR(-EOPNOTSUPP);
        if (flags & ~valid_flags)
                return ERR_PTR(-EOPNOTSUPP);
@@ -139,9 +139,9 @@ iommufd_hwpt_paging_alloc(struct iommufd_ctx *ictx, struct iommufd_ioas *ioas,
        hwpt_paging->ioas = ioas;
        hwpt_paging->nest_parent = flags & IOMMU_HWPT_ALLOC_NEST_PARENT;
 
-       if (ops->domain_alloc_user) {
-               hwpt->domain = ops->domain_alloc_user(idev->dev, flags, NULL,
-                                                     user_data);
+       if (ops->domain_alloc_paging_flags) {
+               hwpt->domain = ops->domain_alloc_paging_flags(idev->dev, flags,
+                                                             user_data);
                if (IS_ERR(hwpt->domain)) {
                        rc = PTR_ERR(hwpt->domain);
                        hwpt->domain = NULL;

diff --git a/drivers/iommu/iommufd/selftest.c b/drivers/iommu/iommufd/selftest.c
index c58083c3660aee47a92705aad70fa8e1ff0d1888..a0de6d6d4e689ceeb6c3a7e80075e2edd05ce5b0 100644 (file)
--- a/drivers/iommu/iommufd/selftest.c
+++ b/drivers/iommu/iommufd/selftest.c
@@ -379,9 +379,8 @@ mock_domain_alloc_nested(struct device *dev, struct iommu_domain *parent,
 }
 
 static struct iommu_domain *
-mock_domain_alloc_user(struct device *dev, u32 flags,
-                      struct iommu_domain *parent,
-                      const struct iommu_user_data *user_data)
+mock_domain_alloc_paging_flags(struct device *dev, u32 flags,
+                              const struct iommu_user_data *user_data)
 {
        bool has_dirty_flag = flags & IOMMU_HWPT_ALLOC_DIRTY_TRACKING;
        const u32 PAGING_FLAGS = IOMMU_HWPT_ALLOC_DIRTY_TRACKING |
@@ -390,9 +389,6 @@ mock_domain_alloc_user(struct device *dev, u32 flags,
                            MOCK_FLAGS_DEVICE_NO_DIRTY;
        struct iommu_domain *domain;
 
-       if (parent)
-               return ERR_PTR(-EOPNOTSUPP);
-
        if (user_data)
                return ERR_PTR(-EOPNOTSUPP);
        if ((flags & ~PAGING_FLAGS) || (has_dirty_flag && no_dirty_ops))
@@ -718,7 +714,7 @@ static const struct iommu_ops mock_ops = {
        .pgsize_bitmap = MOCK_IO_PAGE_SIZE,
        .hw_info = mock_domain_hw_info,
        .domain_alloc_paging = mock_domain_alloc_paging,
-       .domain_alloc_user = mock_domain_alloc_user,
+       .domain_alloc_paging_flags = mock_domain_alloc_paging_flags,
        .domain_alloc_nested = mock_domain_alloc_nested,
        .capable = mock_domain_capable,
        .device_group = generic_device_group,

diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 0472cc1245192dbfec55c1ec9f69eb88fb51e5d0..1e3308e899969d14872c8f1fe0577003709dd25d 100644 (file)
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -557,13 +557,17 @@ iommu_copy_struct_from_full_user_array(void *kdst, size_t kdst_entry_size,
  * @domain_alloc: allocate and return an iommu domain if success. Otherwise
  *                NULL is returned. The domain is not fully initialized until
  *                the caller iommu_domain_alloc() returns.
- * @domain_alloc_user: Allocate an iommu domain corresponding to the input
- *                     parameters as defined in include/uapi/linux/iommufd.h.
- *                     The @user_data can be optionally provided, the
- *                     new domain must support __IOMMU_DOMAIN_PAGING.
- *                     Upon failure, ERR_PTR must be returned.
+ * @domain_alloc_paging_flags: Allocate an iommu domain corresponding to the
+ *                     input parameters as defined in
+ *                     include/uapi/linux/iommufd.h. The @user_data can be
+ *                     optionally provided, the new domain must support
+ *                     __IOMMU_DOMAIN_PAGING. Upon failure, ERR_PTR must be
+ *                     returned.
  * @domain_alloc_paging: Allocate an iommu_domain that can be used for
- *                       UNMANAGED, DMA, and DMA_FQ domain types.
+ *                       UNMANAGED, DMA, and DMA_FQ domain types. This is the
+ *                       same as invoking domain_alloc_paging_flags() with
+ *                       @flags=0, @user_data=NULL. A driver should implement
+ *                       only one of the two ops.
  * @domain_alloc_sva: Allocate an iommu_domain for Shared Virtual Addressing.
  * @domain_alloc_nested: Allocate an iommu_domain for nested translation.
  * @probe_device: Add device to iommu driver handling
@@ -614,8 +618,8 @@ struct iommu_ops {
 
        /* Domain allocation and freeing by the iommu driver */
        struct iommu_domain *(*domain_alloc)(unsigned iommu_domain_type);
-       struct iommu_domain *(*domain_alloc_user)(
-               struct device *dev, u32 flags, struct iommu_domain *parent,
+       struct iommu_domain *(*domain_alloc_paging_flags)(
+               struct device *dev, u32 flags,
                const struct iommu_user_data *user_data);
        struct iommu_domain *(*domain_alloc_paging)(struct device *dev);
        struct iommu_domain *(*domain_alloc_sva)(struct device *dev,