iommu: remove DOMAIN_ATTR_NESTING

Use an explicit enable_nesting method instead.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Acked-by: Will Deacon <will@kernel.org>
Acked-by: Li Yang <leoyang.li@nxp.com>
Link: https://lore.kernel.org/r/20210401155256.298656-17-hch@lst.de
Signed-off-by: Joerg Roedel <jroedel@suse.de>

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 1c7721b89fec58d8b05c99cddc5ebd67c09cb8b8..7f3a122e6b5fc36beb307dca51890fcb02871366 100644 (file)
--- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c
+++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c
@@ -2555,15 +2555,6 @@ static int arm_smmu_domain_get_attr(struct iommu_domain *domain,
        struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain);
 
        switch (domain->type) {
-       case IOMMU_DOMAIN_UNMANAGED:
-               switch (attr) {
-               case DOMAIN_ATTR_NESTING:
-                       *(int *)data = (smmu_domain->stage == ARM_SMMU_DOMAIN_NESTED);
-                       return 0;
-               default:
-                       return -ENODEV;
-               }
-               break;
        case IOMMU_DOMAIN_DMA:
                switch (attr) {
                case DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE:
@@ -2587,23 +2578,6 @@ static int arm_smmu_domain_set_attr(struct iommu_domain *domain,
        mutex_lock(&smmu_domain->init_mutex);
 
        switch (domain->type) {
-       case IOMMU_DOMAIN_UNMANAGED:
-               switch (attr) {
-               case DOMAIN_ATTR_NESTING:
-                       if (smmu_domain->smmu) {
-                               ret = -EPERM;
-                               goto out_unlock;
-                       }
-
-                       if (*(int *)data)
-                               smmu_domain->stage = ARM_SMMU_DOMAIN_NESTED;
-                       else
-                               smmu_domain->stage = ARM_SMMU_DOMAIN_S1;
-                       break;
-               default:
-                       ret = -ENODEV;
-               }
-               break;
        case IOMMU_DOMAIN_DMA:
                switch(attr) {
                case DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE:
@@ -2617,11 +2591,25 @@ static int arm_smmu_domain_set_attr(struct iommu_domain *domain,
                ret = -EINVAL;
        }
 
-out_unlock:
        mutex_unlock(&smmu_domain->init_mutex);
        return ret;
 }
 
+static int arm_smmu_enable_nesting(struct iommu_domain *domain)
+{
+       struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain);
+       int ret = 0;
+
+       mutex_lock(&smmu_domain->init_mutex);
+       if (smmu_domain->smmu)
+               ret = -EPERM;
+       else
+               smmu_domain->stage = ARM_SMMU_DOMAIN_NESTED;
+       mutex_unlock(&smmu_domain->init_mutex);
+
+       return ret;
+}
+
 static int arm_smmu_of_xlate(struct device *dev, struct of_phandle_args *args)
 {
        return iommu_fwspec_add_ids(dev, args->args, 1);
@@ -2721,6 +2709,7 @@ static struct iommu_ops arm_smmu_ops = {
        .device_group           = arm_smmu_device_group,
        .domain_get_attr        = arm_smmu_domain_get_attr,
        .domain_set_attr        = arm_smmu_domain_set_attr,
+       .enable_nesting         = arm_smmu_enable_nesting,
        .of_xlate               = arm_smmu_of_xlate,
        .get_resv_regions       = arm_smmu_get_resv_regions,
        .put_resv_regions       = generic_iommu_put_resv_regions,

diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c
index d8c6bfde6a61587864092c3df89789c0c7671f34..0aa6d667274970a941e1b1403302bc0b7e190478 100644 (file)
--- a/drivers/iommu/arm/arm-smmu/arm-smmu.c
+++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c
@@ -1489,9 +1489,6 @@ static int arm_smmu_domain_get_attr(struct iommu_domain *domain,
        switch(domain->type) {
        case IOMMU_DOMAIN_UNMANAGED:
                switch (attr) {
-               case DOMAIN_ATTR_NESTING:
-                       *(int *)data = (smmu_domain->stage == ARM_SMMU_DOMAIN_NESTED);
-                       return 0;
                case DOMAIN_ATTR_IO_PGTABLE_CFG: {
                        struct io_pgtable_domain_attr *pgtbl_cfg = data;
                        *pgtbl_cfg = smmu_domain->pgtbl_cfg;
@@ -1519,6 +1516,21 @@ static int arm_smmu_domain_get_attr(struct iommu_domain *domain,
        }
 }
 
+static int arm_smmu_enable_nesting(struct iommu_domain *domain)
+{
+       struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain);
+       int ret = 0;
+
+       mutex_lock(&smmu_domain->init_mutex);
+       if (smmu_domain->smmu)
+               ret = -EPERM;
+       else
+               smmu_domain->stage = ARM_SMMU_DOMAIN_NESTED;
+       mutex_unlock(&smmu_domain->init_mutex);
+
+       return ret;
+}
+
 static int arm_smmu_domain_set_attr(struct iommu_domain *domain,
                                    enum iommu_attr attr, void *data)
 {
@@ -1530,17 +1542,6 @@ static int arm_smmu_domain_set_attr(struct iommu_domain *domain,
        switch(domain->type) {
        case IOMMU_DOMAIN_UNMANAGED:
                switch (attr) {
-               case DOMAIN_ATTR_NESTING:
-                       if (smmu_domain->smmu) {
-                               ret = -EPERM;
-                               goto out_unlock;
-                       }
-
-                       if (*(int *)data)
-                               smmu_domain->stage = ARM_SMMU_DOMAIN_NESTED;
-                       else
-                               smmu_domain->stage = ARM_SMMU_DOMAIN_S1;
-                       break;
                case DOMAIN_ATTR_IO_PGTABLE_CFG: {
                        struct io_pgtable_domain_attr *pgtbl_cfg = data;
 
@@ -1633,6 +1634,7 @@ static struct iommu_ops arm_smmu_ops = {
        .device_group           = arm_smmu_device_group,
        .domain_get_attr        = arm_smmu_domain_get_attr,
        .domain_set_attr        = arm_smmu_domain_set_attr,
+       .enable_nesting         = arm_smmu_enable_nesting,
        .of_xlate               = arm_smmu_of_xlate,
        .get_resv_regions       = arm_smmu_get_resv_regions,
        .put_resv_regions       = generic_iommu_put_resv_regions,

diff --git a/drivers/iommu/intel/iommu.c b/drivers/iommu/intel/iommu.c
index 1ea0f0bd69736fab4dc03ba0f44464f5fa5a128f..761feac91767bbb47bd5313915d36214e1729797 100644 (file)
--- a/drivers/iommu/intel/iommu.c
+++ b/drivers/iommu/intel/iommu.c
@@ -5396,32 +5396,19 @@ static bool intel_iommu_is_attach_deferred(struct iommu_domain *domain,
 }
 
 static int
-intel_iommu_domain_set_attr(struct iommu_domain *domain,
-                           enum iommu_attr attr, void *data)
+intel_iommu_enable_nesting(struct iommu_domain *domain)
 {
        struct dmar_domain *dmar_domain = to_dmar_domain(domain);
        unsigned long flags;
-       int ret = 0;
-
-       if (domain->type != IOMMU_DOMAIN_UNMANAGED)
-               return -EINVAL;
+       int ret = -ENODEV;
 
-       switch (attr) {
-       case DOMAIN_ATTR_NESTING:
-               spin_lock_irqsave(&device_domain_lock, flags);
-               if (nested_mode_support() &&
-                   list_empty(&dmar_domain->devices)) {
-                       dmar_domain->flags |= DOMAIN_FLAG_NESTING_MODE;
-                       dmar_domain->flags &= ~DOMAIN_FLAG_USE_FIRST_LEVEL;
-               } else {
-                       ret = -ENODEV;
-               }
-               spin_unlock_irqrestore(&device_domain_lock, flags);
-               break;
-       default:
-               ret = -EINVAL;
-               break;
+       spin_lock_irqsave(&device_domain_lock, flags);
+       if (nested_mode_support() && list_empty(&dmar_domain->devices)) {
+               dmar_domain->flags |= DOMAIN_FLAG_NESTING_MODE;
+               dmar_domain->flags &= ~DOMAIN_FLAG_USE_FIRST_LEVEL;
+               ret = 0;
        }
+       spin_unlock_irqrestore(&device_domain_lock, flags);
 
        return ret;
 }
@@ -5550,7 +5537,7 @@ const struct iommu_ops intel_iommu_ops = {
        .domain_alloc           = intel_iommu_domain_alloc,
        .domain_free            = intel_iommu_domain_free,
        .domain_get_attr        = intel_iommu_domain_get_attr,
-       .domain_set_attr        = intel_iommu_domain_set_attr,
+       .enable_nesting         = intel_iommu_enable_nesting,
        .attach_dev             = intel_iommu_attach_device,
        .detach_dev             = intel_iommu_detach_device,
        .aux_attach_dev         = intel_iommu_aux_attach_device,

diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
index 703e67d8cb04dc0a5cffb2e4ac645a53183d9376..4738bc0242402274aecc35e7bb2fce99f0610701 100644 (file)
--- a/drivers/iommu/iommu.c
+++ b/drivers/iommu/iommu.c
@@ -2690,6 +2690,16 @@ int iommu_domain_set_attr(struct iommu_domain *domain,
 }
 EXPORT_SYMBOL_GPL(iommu_domain_set_attr);
 
+int iommu_enable_nesting(struct iommu_domain *domain)
+{
+       if (domain->type != IOMMU_DOMAIN_UNMANAGED)
+               return -EINVAL;
+       if (!domain->ops->enable_nesting)
+               return -EINVAL;
+       return domain->ops->enable_nesting(domain);
+}
+EXPORT_SYMBOL_GPL(iommu_enable_nesting);
+
 void iommu_get_resv_regions(struct device *dev, struct list_head *list)
 {
        const struct iommu_ops *ops = dev->bus->iommu_ops;

diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c
index c8e57f22f421c5d475104238c3efda04b2e89ca3..1201482e6eec6f685dc301ec7eb5c39885bb0030 100644 (file)
--- a/drivers/vfio/vfio_iommu_type1.c
+++ b/drivers/vfio/vfio_iommu_type1.c
@@ -2320,10 +2320,7 @@ static int vfio_iommu_type1_attach_group(void *iommu_data,
        }
 
        if (iommu->nesting) {
-               int attr = 1;
-
-               ret = iommu_domain_set_attr(domain->domain, DOMAIN_ATTR_NESTING,
-                                           &attr);
+               ret = iommu_enable_nesting(domain->domain);
                if (ret)
                        goto out_domain;
        }

diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 207446cc6d3f3136c3a1a761c0c75edfd8c47542..d7d76b5e1192497bcd76d2d0cc743d31f4c00777 100644 (file)
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -107,7 +107,6 @@ enum iommu_cap {
  */
 
 enum iommu_attr {
-       DOMAIN_ATTR_NESTING,    /* two stages of translation */
        DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE,
        DOMAIN_ATTR_IO_PGTABLE_CFG,
        DOMAIN_ATTR_MAX,
@@ -210,6 +209,7 @@ struct iommu_iotlb_gather {
  * @device_group: find iommu group for a particular device
  * @domain_get_attr: Query domain attributes
  * @domain_set_attr: Change domain attributes
+ * @enable_nesting: Enable nesting
  * @get_resv_regions: Request list of reserved regions for a device
  * @put_resv_regions: Free list of reserved regions for a device
  * @apply_resv_region: Temporary helper call-back for iova reserved ranges
@@ -262,6 +262,7 @@ struct iommu_ops {
                               enum iommu_attr attr, void *data);
        int (*domain_set_attr)(struct iommu_domain *domain,
                               enum iommu_attr attr, void *data);
+       int (*enable_nesting)(struct iommu_domain *domain);
 
        /* Request/Free a list of reserved regions for a device */
        void (*get_resv_regions)(struct device *dev, struct list_head *list);
@@ -511,6 +512,7 @@ extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
                                 void *data);
 extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
                                 void *data);
+int iommu_enable_nesting(struct iommu_domain *domain);
 
 extern int report_iommu_fault(struct iommu_domain *domain, struct device *dev,
                              unsigned long iova, int flags);