From 4770f43dab482e4585d3555933a473cf24e796db Mon Sep 17 00:00:00 2001

From: eperezma <eperezma@redhat.com>

Date: Tue, 12 Jan 2021 14:36:30 -0500

Subject: [PATCH 06/17] hw/arm/smmu-common: Manage IOTLB block entries

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

RH-Author: eperezma <eperezma@redhat.com>

Message-id: <20210112143638.374060-6-eperezma@redhat.com>

Patchwork-id: 100598

O-Subject: [RHEL-8.4.0 qemu-kvm PATCH v2 05/13] hw/arm/smmu-common: Manage IOTLB block entries

Bugzilla: 1843852

RH-Acked-by: Xiao Wang <jasowang@redhat.com>

RH-Acked-by: Peter Xu <peterx@redhat.com>

RH-Acked-by: Auger Eric <eric.auger@redhat.com>

From: Eric Auger <eric.auger@redhat.com>

At the moment each entry in the IOTLB corresponds to a page sized

mapping (4K, 16K or 64K), even if the page belongs to a mapped

block. In case of block mapping this unefficiently consumes IOTLB

entries.

Change the value of the entry so that it reflects the actual

mapping it belongs to (block or page start address and size).

Also the level/tg of the entry is encoded in the key. In subsequent

patches we will enable range invalidation. This latter is able

to provide the level/tg of the entry.

Encoding the level/tg directly in the key will allow to invalidate

using g_hash_table_remove() when num_pages equals to 1.

Signed-off-by: Eric Auger <eric.auger@redhat.com>

Reviewed-by: Peter Maydell <peter.maydell@linaro.org>

Message-id: 20200728150815.11446-6-eric.auger@redhat.com

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>

(cherry picked from commit 9e54dee71fcfaae69f87b8e1f51485a832266a39)

Signed-off-by: Eugenio Pérez <eperezma@redhat.com>

Signed-off-by: Danilo C. L. de Paula <ddepaula@redhat.com>

---

 hw/arm/smmu-common.c         | 67 ++++++++++++++++++++++++++----------

 hw/arm/smmu-internal.h       |  7 ++++

 hw/arm/smmuv3.c              |  6 ++--

 hw/arm/trace-events          |  2 +-

 include/hw/arm/smmu-common.h | 10 ++++--

 5 files changed, 67 insertions(+), 25 deletions(-)

diff --git a/hw/arm/smmu-common.c b/hw/arm/smmu-common.c

index 06e9e38b007..8007edeaaa2 100644

--- a/hw/arm/smmu-common.c

+++ b/hw/arm/smmu-common.c

@@ -39,7 +39,7 @@ static guint smmu_iotlb_key_hash(gconstpointer v)

     /* Jenkins hash */

     a = b = c = JHASH_INITVAL + sizeof(*key);

-    a += key->asid;

+    a += key->asid + key->level + key->tg;

     b += extract64(key->iova, 0, 32);

     c += extract64(key->iova, 32, 32);

@@ -51,24 +51,41 @@ static guint smmu_iotlb_key_hash(gconstpointer v)

 static gboolean smmu_iotlb_key_equal(gconstpointer v1, gconstpointer v2)

 {

-    const SMMUIOTLBKey *k1 = v1;

-    const SMMUIOTLBKey *k2 = v2;

+    SMMUIOTLBKey *k1 = (SMMUIOTLBKey *)v1, *k2 = (SMMUIOTLBKey *)v2;

-    return (k1->asid == k2->asid) && (k1->iova == k2->iova);

+    return (k1->asid == k2->asid) && (k1->iova == k2->iova) &&

+           (k1->level == k2->level) && (k1->tg == k2->tg);

 }

-SMMUIOTLBKey smmu_get_iotlb_key(uint16_t asid, uint64_t iova)

+SMMUIOTLBKey smmu_get_iotlb_key(uint16_t asid, uint64_t iova,

+                                uint8_t tg, uint8_t level)

 {

-    SMMUIOTLBKey key = {.asid = asid, .iova = iova};

+    SMMUIOTLBKey key = {.asid = asid, .iova = iova, .tg = tg, .level = level};

     return key;

 }

 SMMUTLBEntry *smmu_iotlb_lookup(SMMUState *bs, SMMUTransCfg *cfg,

-                                hwaddr iova)

+                                SMMUTransTableInfo *tt, hwaddr iova)

 {

-    SMMUIOTLBKey key = smmu_get_iotlb_key(cfg->asid, iova);

-    SMMUTLBEntry *entry = g_hash_table_lookup(bs->iotlb, &key);

+    uint8_t tg = (tt->granule_sz - 10) / 2;

+    uint8_t inputsize = 64 - tt->tsz;

+    uint8_t stride = tt->granule_sz - 3;

+    uint8_t level = 4 - (inputsize - 4) / stride;

+    SMMUTLBEntry *entry = NULL;

+

+    while (level <= 3) {

+        uint64_t subpage_size = 1ULL << level_shift(level, tt->granule_sz);

+        uint64_t mask = subpage_size - 1;

+        SMMUIOTLBKey key;

+

+        key = smmu_get_iotlb_key(cfg->asid, iova & ~mask, tg, level);

+        entry = g_hash_table_lookup(bs->iotlb, &key);

+        if (entry) {

+            break;

+        }

+        level++;

+    }

     if (entry) {

         cfg->iotlb_hits++;

@@ -89,13 +106,14 @@ SMMUTLBEntry *smmu_iotlb_lookup(SMMUState *bs, SMMUTransCfg *cfg,

 void smmu_iotlb_insert(SMMUState *bs, SMMUTransCfg *cfg, SMMUTLBEntry *new)

 {

     SMMUIOTLBKey *key = g_new0(SMMUIOTLBKey, 1);

+    uint8_t tg = (new->granule - 10) / 2;

     if (g_hash_table_size(bs->iotlb) >= SMMU_IOTLB_MAX_SIZE) {

         smmu_iotlb_inv_all(bs);

     }

-    *key = smmu_get_iotlb_key(cfg->asid, new->entry.iova);

-    trace_smmu_iotlb_insert(cfg->asid, new->entry.iova);

+    *key = smmu_get_iotlb_key(cfg->asid, new->entry.iova, tg, new->level);

+    trace_smmu_iotlb_insert(cfg->asid, new->entry.iova, tg, new->level);

     g_hash_table_insert(bs->iotlb, key, new);

 }

@@ -114,12 +132,26 @@ static gboolean smmu_hash_remove_by_asid(gpointer key, gpointer value,

     return SMMU_IOTLB_ASID(*iotlb_key) == asid;

 }

-inline void smmu_iotlb_inv_iova(SMMUState *s, uint16_t asid, dma_addr_t iova)

+static gboolean smmu_hash_remove_by_asid_iova(gpointer key, gpointer value,

+                                              gpointer user_data)

 {

-    SMMUIOTLBKey key = smmu_get_iotlb_key(asid, iova);

+    SMMUTLBEntry *iter = (SMMUTLBEntry *)value;

+    IOMMUTLBEntry *entry = &iter->entry;

+    SMMUIOTLBPageInvInfo *info = (SMMUIOTLBPageInvInfo *)user_data;

+    SMMUIOTLBKey iotlb_key = *(SMMUIOTLBKey *)key;

+

+    if (info->asid >= 0 && info->asid != SMMU_IOTLB_ASID(iotlb_key)) {

+        return false;

+    }

+    return (info->iova & ~entry->addr_mask) == entry->iova;

+}

+

+inline void smmu_iotlb_inv_iova(SMMUState *s, int asid, dma_addr_t iova)

+{

+    SMMUIOTLBPageInvInfo info = {.asid = asid, .iova = iova};

     trace_smmu_iotlb_inv_iova(asid, iova);

-    g_hash_table_remove(s->iotlb, &key);

+    g_hash_table_foreach_remove(s->iotlb, smmu_hash_remove_by_asid_iova, &info;;

 }

 inline void smmu_iotlb_inv_asid(SMMUState *s, uint16_t asid)

@@ -247,9 +279,6 @@ static int smmu_ptw_64(SMMUTransCfg *cfg,

     baseaddr = extract64(tt->ttb, 0, 48);

     baseaddr &= ~indexmask;

-    tlbe->entry.iova = iova;

-    tlbe->entry.addr_mask = (1 << granule_sz) - 1;

-

     while (level <= 3) {

         uint64_t subpage_size = 1ULL << level_shift(level, granule_sz);

         uint64_t mask = subpage_size - 1;

@@ -299,7 +328,9 @@ static int smmu_ptw_64(SMMUTransCfg *cfg,

             goto error;

         }

-        tlbe->entry.translated_addr = gpa + (iova & mask);

+        tlbe->entry.translated_addr = gpa;

+        tlbe->entry.iova = iova & ~mask;

+        tlbe->entry.addr_mask = mask;

         tlbe->entry.perm = PTE_AP_TO_PERM(ap);

         tlbe->level = level;

         tlbe->granule = granule_sz;

diff --git a/hw/arm/smmu-internal.h b/hw/arm/smmu-internal.h

index 3104f768cd2..55147f29be4 100644

--- a/hw/arm/smmu-internal.h

+++ b/hw/arm/smmu-internal.h

@@ -97,4 +97,11 @@ uint64_t iova_level_offset(uint64_t iova, int inputsize,

 }

 #define SMMU_IOTLB_ASID(key) ((key).asid)

+

+typedef struct SMMUIOTLBPageInvInfo {

+    int asid;

+    uint64_t iova;

+    uint64_t mask;

+} SMMUIOTLBPageInvInfo;

+

 #endif

diff --git a/hw/arm/smmuv3.c b/hw/arm/smmuv3.c

index ad8212779d3..067c9480a03 100644

--- a/hw/arm/smmuv3.c

+++ b/hw/arm/smmuv3.c

@@ -662,7 +662,7 @@ static IOMMUTLBEntry smmuv3_translate(IOMMUMemoryRegion *mr, hwaddr addr,

     page_mask = (1ULL << (tt->granule_sz)) - 1;

     aligned_addr = addr & ~page_mask;

-    cached_entry = smmu_iotlb_lookup(bs, cfg, aligned_addr);

+    cached_entry = smmu_iotlb_lookup(bs, cfg, tt, aligned_addr);

     if (cached_entry) {

         if ((flag & IOMMU_WO) && !(cached_entry->entry.perm & IOMMU_WO)) {

             status = SMMU_TRANS_ERROR;

@@ -732,7 +732,7 @@ epilogue:

     case SMMU_TRANS_SUCCESS:

         entry.perm = flag;

         entry.translated_addr = cached_entry->entry.translated_addr +

-                                    (addr & page_mask);

+                                    (addr & cached_entry->entry.addr_mask);

         entry.addr_mask = cached_entry->entry.addr_mask;

         trace_smmuv3_translate_success(mr->parent_obj.name, sid, addr,

                                        entry.translated_addr, entry.perm);

@@ -960,7 +960,7 @@ static int smmuv3_cmdq_consume(SMMUv3State *s)

             trace_smmuv3_cmdq_tlbi_nh_vaa(vmid, addr);

             smmuv3_inv_notifiers_iova(bs, -1, addr);

-            smmu_iotlb_inv_all(bs);

+            smmu_iotlb_inv_iova(bs, -1, addr);

             break;

         }

         case SMMU_CMD_TLBI_NH_VA:

diff --git a/hw/arm/trace-events b/hw/arm/trace-events

index b808a1bfc19..f74d3e920f1 100644

--- a/hw/arm/trace-events

+++ b/hw/arm/trace-events

@@ -16,7 +16,7 @@ smmu_iotlb_inv_iova(uint16_t asid, uint64_t addr) "IOTLB invalidate asid=%d addr

 smmu_inv_notifiers_mr(const char *name) "iommu mr=%s"

 smmu_iotlb_lookup_hit(uint16_t asid, uint64_t addr, uint32_t hit, uint32_t miss, uint32_t p) "IOTLB cache HIT asid=%d addr=0x%"PRIx64" hit=%d miss=%d hit rate=%d"

 smmu_iotlb_lookup_miss(uint16_t asid, uint64_t addr, uint32_t hit, uint32_t miss, uint32_t p) "IOTLB cache MISS asid=%d addr=0x%"PRIx64" hit=%d miss=%d hit rate=%d"

-smmu_iotlb_insert(uint16_t asid, uint64_t addr) "IOTLB ++ asid=%d addr=0x%"PRIx64

+smmu_iotlb_insert(uint16_t asid, uint64_t addr, uint8_t tg, uint8_t level) "IOTLB ++ asid=%d addr=0x%"PRIx64" tg=%d level=%d"

 # smmuv3.c

 smmuv3_read_mmio(uint64_t addr, uint64_t val, unsigned size, uint32_t r) "addr: 0x%"PRIx64" val:0x%"PRIx64" size: 0x%x(%d)"

diff --git a/include/hw/arm/smmu-common.h b/include/hw/arm/smmu-common.h

index 277923bdc0a..bbf3abc41fd 100644

--- a/include/hw/arm/smmu-common.h

+++ b/include/hw/arm/smmu-common.h

@@ -97,6 +97,8 @@ typedef struct SMMUPciBus {

 typedef struct SMMUIOTLBKey {

     uint64_t iova;

     uint16_t asid;

+    uint8_t tg;

+    uint8_t level;

 } SMMUIOTLBKey;

 typedef struct SMMUState {

@@ -159,12 +161,14 @@ IOMMUMemoryRegion *smmu_iommu_mr(SMMUState *s, uint32_t sid);

 #define SMMU_IOTLB_MAX_SIZE 256

-SMMUTLBEntry *smmu_iotlb_lookup(SMMUState *bs, SMMUTransCfg *cfg, hwaddr iova);

+SMMUTLBEntry *smmu_iotlb_lookup(SMMUState *bs, SMMUTransCfg *cfg,

+                                SMMUTransTableInfo *tt, hwaddr iova);

 void smmu_iotlb_insert(SMMUState *bs, SMMUTransCfg *cfg, SMMUTLBEntry *entry);

-SMMUIOTLBKey smmu_get_iotlb_key(uint16_t asid, uint64_t iova);

+SMMUIOTLBKey smmu_get_iotlb_key(uint16_t asid, uint64_t iova,

+                                uint8_t tg, uint8_t level);

 void smmu_iotlb_inv_all(SMMUState *s);

 void smmu_iotlb_inv_asid(SMMUState *s, uint16_t asid);

-void smmu_iotlb_inv_iova(SMMUState *s, uint16_t asid, dma_addr_t iova);

+void smmu_iotlb_inv_iova(SMMUState *s, int asid, dma_addr_t iova);

 /* Unmap the range of all the notifiers registered to any IOMMU mr */

 void smmu_inv_notifiers_all(SMMUState *s);

-- 

2.27.0