iommu/arm-smmu-v3: Refactor write_ctx_desc

Update arm_smmu_write_ctx_desc and downstream functions to operate on
a master instead of an smmu domain. We expect arm_smmu_write_ctx_desc()
to only be called to write a CD entry into a CD table owned by the
master. Under the hood, arm_smmu_write_ctx_desc still fetches the CD
table from the domain that is attached to the master, but a subsequent
commit will move that table's ownership to the master.

Note that this change isn't a nop refactor since SVA will call
arm_smmu_write_ctx_desc in a loop for every master the domain is
attached to despite the fact that they all share the same CD table. This
loop may look weird but becomes necessary when the CD table becomes
per-master in a subsequent commit.

Reviewed-by: Jason Gunthorpe <jgg@nvidia.com>
Reviewed-by: Nicolin Chen <nicolinc@nvidia.com>
Signed-off-by: Michael Shavit <mshavit@google.com>
Tested-by: Nicolin Chen <nicolinc@nvidia.com>
Link: https://lore.kernel.org/r/20230915211705.v8.5.I219054a6cf538df5bb22f4ada2d9933155d6058c@changeid
Signed-off-by: Will Deacon <will@kernel.org>

diff --git a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c
index 9b27fffe2ab95973e044fa614086b225dbd27d9e..df66fe43a9853fd8695b1a69ca0c4e92ae6db972 100644 (file)
--- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c
+++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-sva.c
@@ -37,6 +37,25 @@ struct arm_smmu_bond {
 
 static DEFINE_MUTEX(sva_lock);
 
+/*
+ * Write the CD to the CD tables for all masters that this domain is attached
+ * to. Note that this is only used to update existing CD entries in the target
+ * CD table, for which it's assumed that arm_smmu_write_ctx_desc can't fail.
+ */
+static void arm_smmu_update_ctx_desc_devices(struct arm_smmu_domain *smmu_domain,
+                                          int ssid,
+                                          struct arm_smmu_ctx_desc *cd)
+{
+       struct arm_smmu_master *master;
+       unsigned long flags;
+
+       spin_lock_irqsave(&smmu_domain->devices_lock, flags);
+       list_for_each_entry(master, &smmu_domain->devices, domain_head) {
+               arm_smmu_write_ctx_desc(master, ssid, cd);
+       }
+       spin_unlock_irqrestore(&smmu_domain->devices_lock, flags);
+}
+
 /*
  * Check if the CPU ASID is available on the SMMU side. If a private context
  * descriptor is using it, try to replace it.
@@ -80,7 +99,7 @@ arm_smmu_share_asid(struct mm_struct *mm, u16 asid)
         * be some overlap between use of both ASIDs, until we invalidate the
         * TLB.
         */
-       arm_smmu_write_ctx_desc(smmu_domain, IOMMU_NO_PASID, cd);
+       arm_smmu_update_ctx_desc_devices(smmu_domain, IOMMU_NO_PASID, cd);
 
        /* Invalidate TLB entries previously associated with that context */
        arm_smmu_tlb_inv_asid(smmu, asid);
@@ -247,7 +266,7 @@ static void arm_smmu_mm_release(struct mmu_notifier *mn, struct mm_struct *mm)
         * DMA may still be running. Keep the cd valid to avoid C_BAD_CD events,
         * but disable translation.
         */
-       arm_smmu_write_ctx_desc(smmu_domain, mm->pasid, &quiet_cd);
+       arm_smmu_update_ctx_desc_devices(smmu_domain, mm->pasid, &quiet_cd);
 
        arm_smmu_tlb_inv_asid(smmu_domain->smmu, smmu_mn->cd->asid);
        arm_smmu_atc_inv_domain(smmu_domain, mm->pasid, 0, 0);
@@ -273,8 +292,10 @@ arm_smmu_mmu_notifier_get(struct arm_smmu_domain *smmu_domain,
                          struct mm_struct *mm)
 {
        int ret;
+       unsigned long flags;
        struct arm_smmu_ctx_desc *cd;
        struct arm_smmu_mmu_notifier *smmu_mn;
+       struct arm_smmu_master *master;
 
        list_for_each_entry(smmu_mn, &smmu_domain->mmu_notifiers, list) {
                if (smmu_mn->mn.mm == mm) {
@@ -304,7 +325,16 @@ arm_smmu_mmu_notifier_get(struct arm_smmu_domain *smmu_domain,
                goto err_free_cd;
        }
 
-       ret = arm_smmu_write_ctx_desc(smmu_domain, mm->pasid, cd);
+       spin_lock_irqsave(&smmu_domain->devices_lock, flags);
+       list_for_each_entry(master, &smmu_domain->devices, domain_head) {
+               ret = arm_smmu_write_ctx_desc(master, mm->pasid, cd);
+               if (ret) {
+                       list_for_each_entry_from_reverse(master, &smmu_domain->devices, domain_head)
+                               arm_smmu_write_ctx_desc(master, mm->pasid, NULL);
+                       break;
+               }
+       }
+       spin_unlock_irqrestore(&smmu_domain->devices_lock, flags);
        if (ret)
                goto err_put_notifier;
 
@@ -329,7 +359,8 @@ static void arm_smmu_mmu_notifier_put(struct arm_smmu_mmu_notifier *smmu_mn)
                return;
 
        list_del(&smmu_mn->list);
-       arm_smmu_write_ctx_desc(smmu_domain, mm->pasid, NULL);
+
+       arm_smmu_update_ctx_desc_devices(smmu_domain, mm->pasid, NULL);
 
        /*
         * If we went through clear(), we've already invalidated, and no

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 39c2b0c451f30eb607473f4936ae0109863f0abe..eacfa82b921ada4df2dd55ca96ea2d6c3826aa78 100644 (file)
--- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c
+++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c
@@ -971,14 +971,12 @@ void arm_smmu_tlb_inv_asid(struct arm_smmu_device *smmu, u16 asid)
        arm_smmu_cmdq_issue_cmd_with_sync(smmu, &cmd);
 }
 
-static void arm_smmu_sync_cd(struct arm_smmu_domain *smmu_domain,
+static void arm_smmu_sync_cd(struct arm_smmu_master *master,
                             int ssid, bool leaf)
 {
        size_t i;
-       unsigned long flags;
-       struct arm_smmu_master *master;
        struct arm_smmu_cmdq_batch cmds;
-       struct arm_smmu_device *smmu = smmu_domain->smmu;
+       struct arm_smmu_device *smmu = master->smmu;
        struct arm_smmu_cmdq_ent cmd = {
                .opcode = CMDQ_OP_CFGI_CD,
                .cfgi   = {
@@ -988,15 +986,10 @@ static void arm_smmu_sync_cd(struct arm_smmu_domain *smmu_domain,
        };
 
        cmds.num = 0;
-
-       spin_lock_irqsave(&smmu_domain->devices_lock, flags);
-       list_for_each_entry(master, &smmu_domain->devices, domain_head) {
-               for (i = 0; i < master->num_streams; i++) {
-                       cmd.cfgi.sid = master->streams[i].id;
-                       arm_smmu_cmdq_batch_add(smmu, &cmds, &cmd);
-               }
+       for (i = 0; i < master->num_streams; i++) {
+               cmd.cfgi.sid = master->streams[i].id;
+               arm_smmu_cmdq_batch_add(smmu, &cmds, &cmd);
        }
-       spin_unlock_irqrestore(&smmu_domain->devices_lock, flags);
 
        arm_smmu_cmdq_batch_submit(smmu, &cmds);
 }
@@ -1026,14 +1019,13 @@ static void arm_smmu_write_cd_l1_desc(__le64 *dst,
        WRITE_ONCE(*dst, cpu_to_le64(val));
 }
 
-static __le64 *arm_smmu_get_cd_ptr(struct arm_smmu_domain *smmu_domain,
-                                  u32 ssid)
+static __le64 *arm_smmu_get_cd_ptr(struct arm_smmu_master *master, u32 ssid)
 {
        __le64 *l1ptr;
        unsigned int idx;
        struct arm_smmu_l1_ctx_desc *l1_desc;
-       struct arm_smmu_device *smmu = smmu_domain->smmu;
-       struct arm_smmu_ctx_desc_cfg *cdcfg = &smmu_domain->cd_table;
+       struct arm_smmu_device *smmu = master->smmu;
+       struct arm_smmu_ctx_desc_cfg *cdcfg = &master->domain->cd_table;
 
        if (cdcfg->s1fmt == STRTAB_STE_0_S1FMT_LINEAR)
                return cdcfg->cdtab + ssid * CTXDESC_CD_DWORDS;
@@ -1047,13 +1039,13 @@ static __le64 *arm_smmu_get_cd_ptr(struct arm_smmu_domain *smmu_domain,
                l1ptr = cdcfg->cdtab + idx * CTXDESC_L1_DESC_DWORDS;
                arm_smmu_write_cd_l1_desc(l1ptr, l1_desc);
                /* An invalid L1CD can be cached */
-               arm_smmu_sync_cd(smmu_domain, ssid, false);
+               arm_smmu_sync_cd(master, ssid, false);
        }
        idx = ssid & (CTXDESC_L2_ENTRIES - 1);
        return l1_desc->l2ptr + idx * CTXDESC_CD_DWORDS;
 }
 
-int arm_smmu_write_ctx_desc(struct arm_smmu_domain *smmu_domain, int ssid,
+int arm_smmu_write_ctx_desc(struct arm_smmu_master *master, int ssid,
                            struct arm_smmu_ctx_desc *cd)
 {
        /*
@@ -1070,11 +1062,12 @@ int arm_smmu_write_ctx_desc(struct arm_smmu_domain *smmu_domain, int ssid,
        u64 val;
        bool cd_live;
        __le64 *cdptr;
+       struct arm_smmu_ctx_desc_cfg *cd_table = &master->domain->cd_table;
 
-       if (WARN_ON(ssid >= (1 << smmu_domain->cd_table.s1cdmax)))
+       if (WARN_ON(ssid >= (1 << cd_table->s1cdmax)))
                return -E2BIG;
 
-       cdptr = arm_smmu_get_cd_ptr(smmu_domain, ssid);
+       cdptr = arm_smmu_get_cd_ptr(master, ssid);
        if (!cdptr)
                return -ENOMEM;
 
@@ -1102,7 +1095,7 @@ int arm_smmu_write_ctx_desc(struct arm_smmu_domain *smmu_domain, int ssid,
                 * order. Ensure that it observes valid values before reading
                 * V=1.
                 */
-               arm_smmu_sync_cd(smmu_domain, ssid, true);
+               arm_smmu_sync_cd(master, ssid, true);
 
                val = cd->tcr |
 #ifdef __BIG_ENDIAN
@@ -1114,7 +1107,7 @@ int arm_smmu_write_ctx_desc(struct arm_smmu_domain *smmu_domain, int ssid,
                        FIELD_PREP(CTXDESC_CD_0_ASID, cd->asid) |
                        CTXDESC_CD_0_V;
 
-               if (smmu_domain->cd_table.stall_enabled)
+               if (cd_table->stall_enabled)
                        val |= CTXDESC_CD_0_S;
        }
 
@@ -1128,7 +1121,7 @@ int arm_smmu_write_ctx_desc(struct arm_smmu_domain *smmu_domain, int ssid,
         *   without first making the structure invalid.
         */
        WRITE_ONCE(cdptr[0], cpu_to_le64(val));
-       arm_smmu_sync_cd(smmu_domain, ssid, true);
+       arm_smmu_sync_cd(master, ssid, true);
        return 0;
 }
 
@@ -1138,7 +1131,7 @@ static int arm_smmu_alloc_cd_tables(struct arm_smmu_domain *smmu_domain,
        int ret;
        size_t l1size;
        size_t max_contexts;
-       struct arm_smmu_device *smmu = smmu_domain->smmu;
+       struct arm_smmu_device *smmu = master->smmu;
        struct arm_smmu_ctx_desc_cfg *cdcfg = &smmu_domain->cd_table;
 
        cdcfg->stall_enabled = master->stall_enabled;
@@ -2122,12 +2115,7 @@ static int arm_smmu_domain_finalise_s1(struct arm_smmu_domain *smmu_domain,
                          CTXDESC_CD_0_TCR_EPD1 | CTXDESC_CD_0_AA64;
        cd->mair        = pgtbl_cfg->arm_lpae_s1_cfg.mair;
 
-       /*
-        * Note that this will end up calling arm_smmu_sync_cd() before
-        * the master has been added to the devices list for this domain.
-        * This isn't an issue because the STE hasn't been installed yet.
-        */
-       ret = arm_smmu_write_ctx_desc(smmu_domain, IOMMU_NO_PASID, cd);
+       ret = arm_smmu_write_ctx_desc(master, IOMMU_NO_PASID, cd);
        if (ret)
                goto out_free_cd_tables;
 

diff --git a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h
index 287bef2d16aaee6c794ec534913dea3e58cf52c3..d2fc0a9793e5424ecae8e8b0292ac17655588d91 100644 (file)
--- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h
+++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h
@@ -745,7 +745,7 @@ extern struct xarray arm_smmu_asid_xa;
 extern struct mutex arm_smmu_asid_lock;
 extern struct arm_smmu_ctx_desc quiet_cd;
 
-int arm_smmu_write_ctx_desc(struct arm_smmu_domain *smmu_domain, int ssid,
+int arm_smmu_write_ctx_desc(struct arm_smmu_master *smmu_master, int ssid,
                            struct arm_smmu_ctx_desc *cd);
 void arm_smmu_tlb_inv_asid(struct arm_smmu_device *smmu, u16 asid);
 void arm_smmu_tlb_inv_range_asid(unsigned long iova, size_t size, int asid,