Skip to contentSkip to conversation

IOMMU: avoid double flushing in shared page table case

PATCH In review Jan Beulich 3 participants 5 messages Oct 20, 2020 – Oct 23, 2020

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 IOMMU: avoid double flushing in shared page table case

While the flush coalescing optimization has been helping the non-shared case, it has actually lead to double flushes in the shared case (which ought to be the more common one nowadays at least): Once from *_set_entry() and a second time up the call tree from wherever the overriding flag gets played with. In alignment with XSA-346 suppress flushing in this case.

Similarly avoid excessive setting of IOMMU_FLUSHF_added on the batched
flushes: "idx" hasn't been added a new mapping for.

---
TBD: The Arm part really is just for completeness (and hence could also
be dropped) - the affected mapping spaces aren't currently supported there.

xen/arch/arm/p2m.c +1 -1
@@ -1045,7 +1045,7 @@ static int __p2m_set_entry(struct p2m_do
         p2m->lowest_mapped_gfn = gfn_min(p2m->lowest_mapped_gfn, sgfn);
     }
 
-    if ( is_iommu_enabled(p2m->domain) &&
+    if ( is_iommu_enabled(p2m->domain) && !this_cpu(iommu_dont_flush_iotlb) &&
          (lpae_is_valid(orig_pte) || lpae_is_valid(*entry)) )
     {
         unsigned int flush_flags = 0;
xen/arch/x86/mm/p2m-ept.c +1 -1
@@ -842,7 +842,7 @@ out:
     if ( rc == 0 && p2m_is_hostp2m(p2m) &&
          need_modify_vtd_table )
     {
-        if ( iommu_use_hap_pt(d) )
+        if ( iommu_use_hap_pt(d) && !this_cpu(iommu_dont_flush_iotlb) )
             rc = iommu_iotlb_flush(d, _dfn(gfn), 1ul << order,
                                    (iommu_flags ? IOMMU_FLUSHF_added : 0) |
                                    (vtd_pte_present ? IOMMU_FLUSHF_modified
xen/common/memory.c +1 -1
@@ -870,7 +870,7 @@ int xenmem_add_to_physmap(struct domain
         this_cpu(iommu_dont_flush_iotlb) = 0;
 
         ret = iommu_iotlb_flush(d, _dfn(xatp->idx - done), done,
-                                IOMMU_FLUSHF_added | IOMMU_FLUSHF_modified);
+                                IOMMU_FLUSHF_modified);
         if ( unlikely(ret) && rc >= 0 )
             rc = ret;
 
#1 lore raw

Hi Jan,

Quoted 7 lines · Jan Beulich

While the flush coalescing optimization has been helping the non-shared case, it has actually lead to double flushes in the shared case (which ought to be the more common one nowadays at least): Once from *_set_entry() and a second time up the call tree from wherever the overriding flag gets played with. In alignment with XSA-346 suppress flushing in this case.

Quoted 8 lines

Similarly avoid excessive setting of IOMMU_FLUSHF_added on the batched
flushes: "idx" hasn't been added a new mapping for.

---
TBD: The Arm part really is just for completeness (and hence could also
be dropped) - the affected mapping spaces aren't currently supported there.

As I may I have pointed out in the past, there are many ways to screw things up when using iommu_dont_flush_iotlb.

So I would rather not introduce any usage on Arm until we see a use-case.

Cheers,

Signature · 1 line
Julien Grall
#2 lore raw
Quoted 17 lines · Julien Grall
Quoted 7 lines · Jan Beulich

While the flush coalescing optimization has been helping the non-shared case, it has actually lead to double flushes in the shared case (which ought to be the more common one nowadays at least): Once from *_set_entry() and a second time up the call tree from wherever the overriding flag gets played with. In alignment with XSA-346 suppress flushing in this case.

Quoted 8 lines

Similarly avoid excessive setting of IOMMU_FLUSHF_added on the batched
flushes: "idx" hasn't been added a new mapping for.

---
TBD: The Arm part really is just for completeness (and hence could also
be dropped) - the affected mapping spaces aren't currently supported there.

Quoted 4 lines

As I may I have pointed out in the past, there are many ways to screw things up when using iommu_dont_flush_iotlb.

So I would rather not introduce any usage on Arm until we see a use-case.

"Usage" to me would mean a path actually setting the flag. What I'm adding here, basically as a precautionary measure, is a check of the flag. Does your use of "usage" imply you don't want that either? Just to be sure; I'm okay to drop the Arm part.

Jan

#3 lore raw

Hi Jan,

Quoted 18 lines · Jan Beulich
Quoted 17 lines · Julien Grall
Quoted 15 lines · Jan Beulich

While the flush coalescing optimization has been helping the non-shared case, it has actually lead to double flushes in the shared case (which ought to be the more common one nowadays at least): Once from *_set_entry() and a second time up the call tree from wherever the overriding flag gets played with. In alignment with XSA-346 suppress flushing in this case.

Similarly avoid excessive setting of IOMMU_FLUSHF_added on the batched
flushes: "idx" hasn't been added a new mapping for.

---
TBD: The Arm part really is just for completeness (and hence could also
be dropped) - the affected mapping spaces aren't currently supported there.

Quoted 8 lines
Quoted 4 lines

As I may I have pointed out in the past, there are many ways to screw things up when using iommu_dont_flush_iotlb.

So I would rather not introduce any usage on Arm until we see a use-case.

"Usage" to me would mean a path actually setting the flag. What I'm adding here, basically as a precautionary measure, is a check of the flag.

The code would always be safe without checking the safe (albeit doing pointless flush). I wouldn't say the same if we check the flag because it is not correct to set it everywhere.

Quoted 3 lines

Does your use of "usage" imply you
don't want that either? Just to be sure; I'm okay to drop the Arm part.

That's correct, I don't want this check to be present until there is a user. Only then, we can assess whether this is the right approach for Arm.

Cheers,

Signature · 1 line
Julien Grall
Reviewed-by on v1 1/1
#4 lore raw
In reply to Jan Beulich
Quoted 10 lines

From: Jan Beulich <[email protected]>
Sent: Tuesday, October 20, 2020 9:53 PM

While the flush coalescing optimization has been helping the non-shared case, it has actually lead to double flushes in the shared case (which ought to be the more common one nowadays at least): Once from *_set_entry() and a second time up the call tree from wherever the overriding flag gets played with. In alignment with XSA-346 suppress flushing in this case.

Quoted 4 lines

Similarly avoid excessive setting of IOMMU_FLUSHF_added on the batched
flushes: "idx" hasn't been added a new mapping for.

Quoted 39 lines

---
TBD: The Arm part really is just for completeness (and hence could also
be dropped) - the affected mapping spaces aren't currently supported there.

xen/arch/arm/p2m.c +1 -1
@@ -1045,7 +1045,7 @@ static int __p2m_set_entry(struct p2m_do
         p2m->lowest_mapped_gfn = gfn_min(p2m->lowest_mapped_gfn, sgfn);
     }
 
-    if ( is_iommu_enabled(p2m->domain) &&
+    if ( is_iommu_enabled(p2m->domain)

&& !this_cpu(iommu_dont_flush_iotlb) &&

          (lpae_is_valid(orig_pte) || lpae_is_valid(*entry)) )
     {
         unsigned int flush_flags = 0;
xen/arch/x86/mm/p2m-ept.c +1 -1
@@ -842,7 +842,7 @@ out:
     if ( rc == 0 && p2m_is_hostp2m(p2m) &&
          need_modify_vtd_table )
     {
-        if ( iommu_use_hap_pt(d) )
+        if ( iommu_use_hap_pt(d) && !this_cpu(iommu_dont_flush_iotlb) )
             rc = iommu_iotlb_flush(d, _dfn(gfn), 1ul << order,
                                    (iommu_flags ? IOMMU_FLUSHF_added : 0) |
                                    (vtd_pte_present ? IOMMU_FLUSHF_modified
xen/common/memory.c +1 -1
@@ -870,7 +870,7 @@ int xenmem_add_to_physmap(struct domain
         this_cpu(iommu_dont_flush_iotlb) = 0;
 
         ret = iommu_iotlb_flush(d, _dfn(xatp->idx - done), done,
-                                IOMMU_FLUSHF_added | IOMMU_FLUSHF_modified);
+                                IOMMU_FLUSHF_modified);
         if ( unlikely(ret) && rc >= 0 )
             rc = ret;