iommu/arm-smmu-v3: Add update_safe bits to fix STE update sequence

C_BAD_STE was observed when updating nested STE from an S1-bypass mode to
an S1DSS-bypass mode. As both modes enabled S2, the used bit is slightly
different than the normal S1-bypass and S1DSS-bypass modes. As a result,
fields like MEV and EATS in S2's used list marked the word1 as a critical
word that requested a STE.V=0. This breaks a hitless update.

However, both MEV and EATS aren't critical in terms of STE update. One
controls the merge of the events and the other controls the ATS that is
managed by the driver at the same time via pci_enable_ats().

Add an arm_smmu_get_ste_update_safe() to allow STE update algorithm to
relax those fields, avoiding the STE update breakages.

After this change, entry_set has no caller checking its return value, so
change it to void.

Note that this change is required by both MEV and EATS fields, which were
introduced in different kernel versions. So add get_update_safe() first.
MEV and EATS will be added to arm_smmu_get_ste_update_safe() separately.

Fixes: 1e8be08d1c91 ("iommu/arm-smmu-v3: Support IOMMU_DOMAIN_NESTED")
Cc: stable@vger.kernel.org
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
Reviewed-by: Shuai Xue <xueshuai@linux.alibaba.com>
Reviewed-by: Mostafa Saleh <smostafa@google.com>
Reviewed-by: Pranjal Shrivastava <praan@google.com>
Signed-off-by: Nicolin Chen <nicolinc@nvidia.com>
Signed-off-by: Will Deacon <will@kernel.org>

diff --git a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-test.c b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-test.c
index d2671bfd37981b363bafd50a2ddc811b7f7d6187..b254a94b2003da55e27a9536c5d7651a36727212 100644 (file)
--- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-test.c
+++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3-test.c
@@ -38,13 +38,16 @@ enum arm_smmu_test_master_feat {
 static bool arm_smmu_entry_differs_in_used_bits(const __le64 *entry,
                                                const __le64 *used_bits,
                                                const __le64 *target,
+                                               const __le64 *safe,
                                                unsigned int length)
 {
        bool differs = false;
        unsigned int i;
 
        for (i = 0; i < length; i++) {
-               if ((entry[i] & used_bits[i]) != target[i])
+               __le64 used = used_bits[i] & ~safe[i];
+
+               if ((entry[i] & used) != (target[i] & used))
                        differs = true;
        }
        return differs;
@@ -56,12 +59,24 @@ arm_smmu_test_writer_record_syncs(struct arm_smmu_entry_writer *writer)
        struct arm_smmu_test_writer *test_writer =
                container_of(writer, struct arm_smmu_test_writer, writer);
        __le64 *entry_used_bits;
+       __le64 *safe_target;
+       __le64 *safe_init;
 
        entry_used_bits = kunit_kzalloc(
                test_writer->test, sizeof(*entry_used_bits) * NUM_ENTRY_QWORDS,
                GFP_KERNEL);
        KUNIT_ASSERT_NOT_NULL(test_writer->test, entry_used_bits);
 
+       safe_target = kunit_kzalloc(test_writer->test,
+                                   sizeof(*safe_target) * NUM_ENTRY_QWORDS,
+                                   GFP_KERNEL);
+       KUNIT_ASSERT_NOT_NULL(test_writer->test, safe_target);
+
+       safe_init = kunit_kzalloc(test_writer->test,
+                                 sizeof(*safe_init) * NUM_ENTRY_QWORDS,
+                                 GFP_KERNEL);
+       KUNIT_ASSERT_NOT_NULL(test_writer->test, safe_init);
+
        pr_debug("STE value is now set to: ");
        print_hex_dump_debug("    ", DUMP_PREFIX_NONE, 16, 8,
                             test_writer->entry,
@@ -79,14 +94,23 @@ arm_smmu_test_writer_record_syncs(struct arm_smmu_entry_writer *writer)
                 * configuration.
                 */
                writer->ops->get_used(test_writer->entry, entry_used_bits);
+               if (writer->ops->get_update_safe)
+                       writer->ops->get_update_safe(test_writer->entry,
+                                                    test_writer->init_entry,
+                                                    safe_init);
+               if (writer->ops->get_update_safe)
+                       writer->ops->get_update_safe(test_writer->entry,
+                                                    test_writer->target_entry,
+                                                    safe_target);
                KUNIT_EXPECT_FALSE(
                        test_writer->test,
                        arm_smmu_entry_differs_in_used_bits(
                                test_writer->entry, entry_used_bits,
-                               test_writer->init_entry, NUM_ENTRY_QWORDS) &&
+                               test_writer->init_entry, safe_init,
+                               NUM_ENTRY_QWORDS) &&
                                arm_smmu_entry_differs_in_used_bits(
                                        test_writer->entry, entry_used_bits,
-                                       test_writer->target_entry,
+                                       test_writer->target_entry, safe_target,
                                        NUM_ENTRY_QWORDS));
        }
 }
@@ -106,6 +130,7 @@ arm_smmu_v3_test_debug_print_used_bits(struct arm_smmu_entry_writer *writer,
 static const struct arm_smmu_entry_writer_ops test_ste_ops = {
        .sync = arm_smmu_test_writer_record_syncs,
        .get_used = arm_smmu_get_ste_used,
+       .get_update_safe = arm_smmu_get_ste_update_safe,
 };
 
 static const struct arm_smmu_entry_writer_ops test_cd_ops = {

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 504d7880ce5a41723d5586e5040794cf29668fea..361246c6e6841c9a229c45be2afb55fe315c5dfe 100644 (file)
--- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c
+++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c
@@ -1093,6 +1093,13 @@ void arm_smmu_get_ste_used(const __le64 *ent, __le64 *used_bits)
 }
 EXPORT_SYMBOL_IF_KUNIT(arm_smmu_get_ste_used);
 
+VISIBLE_IF_KUNIT
+void arm_smmu_get_ste_update_safe(const __le64 *cur, const __le64 *target,
+                                 __le64 *safe_bits)
+{
+}
+EXPORT_SYMBOL_IF_KUNIT(arm_smmu_get_ste_update_safe);
+
 /*
  * Figure out if we can do a hitless update of entry to become target. Returns a
  * bit mask where 1 indicates that qword needs to be set disruptively.
@@ -1105,13 +1112,22 @@ static u8 arm_smmu_entry_qword_diff(struct arm_smmu_entry_writer *writer,
 {
        __le64 target_used[NUM_ENTRY_QWORDS] = {};
        __le64 cur_used[NUM_ENTRY_QWORDS] = {};
+       __le64 safe[NUM_ENTRY_QWORDS] = {};
        u8 used_qword_diff = 0;
        unsigned int i;
 
        writer->ops->get_used(entry, cur_used);
        writer->ops->get_used(target, target_used);
+       if (writer->ops->get_update_safe)
+               writer->ops->get_update_safe(entry, target, safe);
 
        for (i = 0; i != NUM_ENTRY_QWORDS; i++) {
+               /*
+                * Safe is only used for bits that are used by both entries,
+                * otherwise it is sequenced according to the unused entry.
+                */
+               safe[i] &= target_used[i] & cur_used[i];
+
                /*
                 * Check that masks are up to date, the make functions are not
                 * allowed to set a bit to 1 if the used function doesn't say it
@@ -1120,6 +1136,7 @@ static u8 arm_smmu_entry_qword_diff(struct arm_smmu_entry_writer *writer,
                WARN_ON_ONCE(target[i] & ~target_used[i]);
 
                /* Bits can change because they are not currently being used */
+               cur_used[i] &= ~safe[i];
                unused_update[i] = (entry[i] & cur_used[i]) |
                                   (target[i] & ~cur_used[i]);
                /*
@@ -1132,7 +1149,7 @@ static u8 arm_smmu_entry_qword_diff(struct arm_smmu_entry_writer *writer,
        return used_qword_diff;
 }
 
-static bool entry_set(struct arm_smmu_entry_writer *writer, __le64 *entry,
+static void entry_set(struct arm_smmu_entry_writer *writer, __le64 *entry,
                      const __le64 *target, unsigned int start,
                      unsigned int len)
 {
@@ -1148,7 +1165,6 @@ static bool entry_set(struct arm_smmu_entry_writer *writer, __le64 *entry,
 
        if (changed)
                writer->ops->sync(writer);
-       return changed;
 }
 
 /*
@@ -1218,12 +1234,9 @@ void arm_smmu_write_entry(struct arm_smmu_entry_writer *writer, __le64 *entry,
                entry_set(writer, entry, target, 0, 1);
        } else {
                /*
-                * No inuse bit changed. Sanity check that all unused bits are 0
-                * in the entry. The target was already sanity checked by
-                * compute_qword_diff().
+                * No inuse bit changed, though safe bits may have changed.
                 */
-               WARN_ON_ONCE(
-                       entry_set(writer, entry, target, 0, NUM_ENTRY_QWORDS));
+               entry_set(writer, entry, target, 0, NUM_ENTRY_QWORDS);
        }
 }
 EXPORT_SYMBOL_IF_KUNIT(arm_smmu_write_entry);
@@ -1554,6 +1567,7 @@ static void arm_smmu_ste_writer_sync_entry(struct arm_smmu_entry_writer *writer)
 static const struct arm_smmu_entry_writer_ops arm_smmu_ste_writer_ops = {
        .sync = arm_smmu_ste_writer_sync_entry,
        .get_used = arm_smmu_get_ste_used,
+       .get_update_safe = arm_smmu_get_ste_update_safe,
 };
 
 static void arm_smmu_write_ste(struct arm_smmu_master *master, u32 sid,

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 0a5bb57dbdfede8d71d98cb6c8640d7278986d1f..3c6d65d36164f67d6212066fde8abd0918690259 100644 (file)
--- a/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h
+++ b/drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.h
@@ -898,6 +898,8 @@ struct arm_smmu_entry_writer {
 
 struct arm_smmu_entry_writer_ops {
        void (*get_used)(const __le64 *entry, __le64 *used);
+       void (*get_update_safe)(const __le64 *cur, const __le64 *target,
+                               __le64 *safe_bits);
        void (*sync)(struct arm_smmu_entry_writer *writer);
 };
 
@@ -909,6 +911,8 @@ void arm_smmu_make_s2_domain_ste(struct arm_smmu_ste *target,
 
 #if IS_ENABLED(CONFIG_KUNIT)
 void arm_smmu_get_ste_used(const __le64 *ent, __le64 *used_bits);
+void arm_smmu_get_ste_update_safe(const __le64 *cur, const __le64 *target,
+                                 __le64 *safe_bits);
 void arm_smmu_write_entry(struct arm_smmu_entry_writer *writer, __le64 *cur,
                          const __le64 *target);
 void arm_smmu_get_cd_used(const __le64 *ent, __le64 *used_bits);