Skip to contentSkip to conversation

s390x/mmu: Storage key reference and change bit handling

PATCH Superseded David Hildenbrand 3 participants 21 messages Aug 12, 2019 – Aug 14, 2019

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

cover s390x/mmu: Storage key reference and change bit handling

The first two patches are modified patches from:

    [PATCH-for-4.2 v1 0/9] s390x: MMU changes and extensions

This series primarily fixes minor things in the storage key handling code in the MMU and implements fairly reliable reference and change bit handling for TCG. To track the reference and change bit, we have to invalidate TLB entries whenever the storage key is changed by the guest and make sure not TLB entry is writable in case the storage key does not indicate a change already.

With this series, the kvm-unit-test "skey" now passes. \o/

David Hildenbrand (6):
s390x/mmu: ASC selection in s390_cpu_get_phys_page_debug() s390x/tcg: Rework MMU selection for instruction fetches s390x/tcg: Flush the TLB of all CPUs on SSKE and RRBE s390x/mmu: Trace the right value if setting/getting the storage key
fails
s390x/mmu: Better storage key reference and change bit handling s390x/mmu: Factor out storage key handling

 target/s390x/cpu.h        |   7 ++
 target/s390x/helper.c     |   5 ++
 target/s390x/mem_helper.c |   4 ++
 target/s390x/mmu_helper.c | 131 ++++++++++++++++++++++++--------------
 4 files changed, 98 insertions(+), 49 deletions(-)
Signature · 1 line
2.21.0
#1 lore raw

PATCH 1/6 s390x/mmu: ASC selection in s390_cpu_get_phys_page_debug()

Let's select the ASC before calling the function. This is a prepararion to remove the ASC magic depending on the access mode from mmu_translate.

There is currently no way to distinguish if we have code or data access. For now, we were using code access, because especially when debugging with the gdbstub, we want to read and disassemble what we single-step.

---
 target/s390x/helper.c | 5 +++++
 1 file changed, 5 insertions(+)
target/s390x/helper.c +5 -0
index 13ae9909ad..c5fb8966b6 100644
@@ -58,6 +58,11 @@ hwaddr s390_cpu_get_phys_page_debug(CPUState *cs, vaddr vaddr)
         vaddr &= 0x7fffffff;
     }
 
+    /* We want to read the code (e.g., see what we are single-stepping).*/
+    if (asc != PSW_ASC_HOME) {
+        asc = PSW_ASC_PRIMARY;
+    }
+
     if (mmu_translate(env, vaddr, MMU_INST_FETCH, asc, &raddr, &prot, false)) {
         return -1;
     }
Signature · 1 line
2.21.0
Reviewed-by on v1 1/6
#2 lore raw

Re: [Qemu-devel] [qemu-s390x] [PATCH-for-4.2 v1 1/6] s390x/mmu: ASC selection in s390_cpu_get_phys_page_debug()

Quoted 6 lines · David Hildenbrand

Let's select the ASC before calling the function. This is a prepararion to remove the ASC magic depending on the access mode from mmu_translate.

There is currently no way to distinguish if we have code or data access. For now, we were using code access, because especially when debugging with the gdbstub, we want to read and disassemble what we single-step.

IMHO we should add a "instruction" bit to MemTxAttrs and then use the ...page_attrs_debug() interface instead. But ok, that's likely really something for a separate clean-up, so for the time being:

Quoted 22 lines
---
 target/s390x/helper.c | 5 +++++
 1 file changed, 5 insertions(+)
target/s390x/helper.c +5 -0
index 13ae9909ad..c5fb8966b6 100644
@@ -58,6 +58,11 @@ hwaddr s390_cpu_get_phys_page_debug(CPUState *cs, vaddr vaddr)
         vaddr &= 0x7fffffff;
     }
 
+    /* We want to read the code (e.g., see what we are single-stepping).*/
+    if (asc != PSW_ASC_HOME) {
+        asc = PSW_ASC_PRIMARY;
+    }
+
     if (mmu_translate(env, vaddr, MMU_INST_FETCH, asc, &raddr, &prot, false)) {
         return -1;
     }
#3 lore raw

Re: [Qemu-devel] [qemu-s390x] [PATCH-for-4.2 v1 1/6] s390x/mmu: ASC selection in s390_cpu_get_phys_page_debug()

Quoted 4 lines · Thomas Huth
Quoted 3 lines · David Hildenbrand

Let's select the ASC before calling the function. This is a prepararion to remove the ASC magic depending on the access mode from mmu_translate.

Quoted 8 lines
Quoted 3 lines

There is currently no way to distinguish if we have code or data access. For now, we were using code access, because especially when debugging with the gdbstub, we want to read and disassemble what we single-step.

IMHO we should add a "instruction" bit to MemTxAttrs and then use the ...page_attrs_debug() interface instead. But ok, that's likely really something for a separate clean-up, so for the time being:

That sounds like a good idea, and then switching over to cc->get_phys_page_attrs()

Thanks!

Quoted 2 lines
Signature · 3 lines
Thanks,

David / dhildenb
#4 lore raw

Re: [Qemu-devel] [qemu-s390x] [PATCH-for-4.2 v1 1/6] s390x/mmu: ASC selection in s390_cpu_get_phys_page_debug()

Quoted 9 lines · David Hildenbrand
Quoted 8 lines · Thomas Huth
Quoted 6 lines · David Hildenbrand

Let's select the ASC before calling the function. This is a prepararion to remove the ASC magic depending on the access mode from mmu_translate.

There is currently no way to distinguish if we have code or data access. For now, we were using code access, because especially when debugging with the gdbstub, we want to read and disassemble what we single-step.

Quoted 7 lines
Quoted 4 lines

IMHO we should add a "instruction" bit to MemTxAttrs and then use the ...page_attrs_debug() interface instead. But ok, that's likely really something for a separate clean-up, so for the time being:

That sounds like a good idea, and then switching over to cc->get_phys_page_attrs()

But looking at get_phys_page_attrs_debug() again, "MemTxAttrs *attrs" is an output value not an input value. So there wouldn't be a way to specify "what you want" from the caller. At least unless I am missing something :)

Quoted 7 lines

Thanks!

Quoted 2 lines
Signature · 3 lines
Thanks,

David / dhildenb
#5 lore raw

Re: [Qemu-devel] [qemu-s390x] [PATCH-for-4.2 v1 1/6] s390x/mmu: ASC selection in s390_cpu_get_phys_page_debug()

Quoted 15 lines · David Hildenbrand
Quoted 14 lines · David Hildenbrand
Quoted 12 lines · Thomas Huth
Quoted 6 lines · David Hildenbrand

Let's select the ASC before calling the function. This is a prepararion to remove the ASC magic depending on the access mode from mmu_translate.

There is currently no way to distinguish if we have code or data access. For now, we were using code access, because especially when debugging with the gdbstub, we want to read and disassemble what we single-step.

IMHO we should add a "instruction" bit to MemTxAttrs and then use the ...page_attrs_debug() interface instead. But ok, that's likely really something for a separate clean-up, so for the time being:

Quoted 7 lines
Quoted 2 lines

That sounds like a good idea, and then switching over to cc->get_phys_page_attrs()

But looking at get_phys_page_attrs_debug() again, "MemTxAttrs *attrs" is an output value not an input value. So there wouldn't be a way to specify "what you want" from the caller. At least unless I am missing something :)

Oops, you're right. Too bad :-(

So never mind that idea ... your patch is certainly the best you can do here right now.

Thomas

Reviewed-by on v1 1/6
#6 lore raw

Re: [Qemu-devel] [PATCH-for-4.2 v1 1/6] s390x/mmu: ASC selection in s390_cpu_get_phys_page_debug()

In reply to David Hildenbrand
Quoted 12 lines · On Mon, 12 Aug 2019 13:27:32 +0200 David Hildenbrand <[email protected]> wrote:

Let's select the ASC before calling the function. This is a prepararion to remove the ASC magic depending on the access mode from mmu_translate.

There is currently no way to distinguish if we have code or data access. For now, we were using code access, because especially when debugging with the gdbstub, we want to read and disassemble what we single-step.

---
 target/s390x/helper.c | 5 +++++
 1 file changed, 5 insertions(+)

Let's go with that for now.

#7 lore raw

PATCH 2/6 s390x/tcg: Rework MMU selection for instruction fetches

In reply to David Hildenbrand

Instructions are always fetched from primary address space, except when in home address mode. Perform the selection directly in cpu_mmu_index().

get_mem_index() is only used to perform data access, instructions are fetched via cpu_lduw_code(), which translates to cpu_mmu_index(env, true).

We don't care about restricting the access permissions of the TLB entries anymore, as we no longer enter PRIMARY entries into the SECONDARY MMU. Cleanup related code a bit.

---
 target/s390x/cpu.h        |  7 +++++++
 target/s390x/mmu_helper.c | 35 ++++++++++++++---------------------
 2 files changed, 21 insertions(+), 21 deletions(-)
target/s390x/cpu.h +7 -0
index a606547b4d..c34992bb2e 100644
@@ -332,6 +332,13 @@ static inline int cpu_mmu_index(CPUS390XState *env, bool ifetch)
         return MMU_REAL_IDX;
     }
 
+    if (ifetch) {
+        if ((env->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME) {
+            return MMU_HOME_IDX;
+        }
+        return MMU_PRIMARY_IDX;
+    }
+
     switch (env->psw.mask & PSW_MASK_ASC) {
     case PSW_ASC_PRIMARY:
         return MMU_PRIMARY_IDX;
target/s390x/mmu_helper.c +14 -21
index 6e9c4d6151..2c9bb3acc0 100644
@@ -349,6 +349,7 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
 {
     static S390SKeysState *ss;
     static S390SKeysClass *skeyclass;
+    uint64_t asce;
     int r = -1;
     uint8_t key;
 
@@ -381,35 +382,21 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
     if (!(env->psw.mask & PSW_MASK_DAT)) {
         *raddr = vaddr;
         r = 0;
-        goto out;
+        goto nodat;
     }
 
     switch (asc) {
     case PSW_ASC_PRIMARY:
         PTE_DPRINTF("%s: asc=primary\n", __func__);
-        r = mmu_translate_asce(env, vaddr, asc, env->cregs[1], raddr, flags,
-                               rw, exc);
+        asce = env->cregs[1];
         break;
     case PSW_ASC_HOME:
         PTE_DPRINTF("%s: asc=home\n", __func__);
-        r = mmu_translate_asce(env, vaddr, asc, env->cregs[13], raddr, flags,
-                               rw, exc);
+        asce = env->cregs[13];
         break;
     case PSW_ASC_SECONDARY:
         PTE_DPRINTF("%s: asc=secondary\n", __func__);
-        /*
-         * Instruction: Primary
-         * Data: Secondary
-         */
-        if (rw == MMU_INST_FETCH) {
-            r = mmu_translate_asce(env, vaddr, PSW_ASC_PRIMARY, env->cregs[1],
-                                   raddr, flags, rw, exc);
-            *flags &= ~(PAGE_READ | PAGE_WRITE);
-        } else {
-            r = mmu_translate_asce(env, vaddr, PSW_ASC_SECONDARY, env->cregs[7],
-                                   raddr, flags, rw, exc);
-            *flags &= ~(PAGE_EXEC);
-        }
+        asce = env->cregs[7];
         break;
     case PSW_ASC_ACCREG:
     default:
@@ -417,11 +404,17 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
         break;
     }
 
- out:
+    /* perform the DAT translation */
+    r = mmu_translate_asce(env, vaddr, asc, asce, raddr, flags, rw, exc);
+    if (r) {
+        return r;
+    }
+
+nodat:
     /* Convert real address -> absolute address */
     *raddr = mmu_real2abs(env, *raddr);
 
-    if (r == 0 && *raddr < ram_size) {
+    if (*raddr < ram_size) {
         if (skeyclass->get_skeys(ss, *raddr / TARGET_PAGE_SIZE, 1, &key)) {
             trace_get_skeys_nonzero(r);
             return 0;
@@ -441,7 +434,7 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
         }
     }
 
-    return r;
+    return 0;
 }
 
 /**
Signature · 1 line
2.21.0
#8 lore raw

Re: [Qemu-devel] [PATCH-for-4.2 v1 2/6] s390x/tcg: Rework MMU selection for instruction fetches

Quoted 39 lines · David Hildenbrand

Instructions are always fetched from primary address space, except when in home address mode. Perform the selection directly in cpu_mmu_index().

get_mem_index() is only used to perform data access, instructions are fetched via cpu_lduw_code(), which translates to cpu_mmu_index(env, true).

We don't care about restricting the access permissions of the TLB entries anymore, as we no longer enter PRIMARY entries into the SECONDARY MMU. Cleanup related code a bit.

---
 target/s390x/cpu.h        |  7 +++++++
 target/s390x/mmu_helper.c | 35 ++++++++++++++---------------------
 2 files changed, 21 insertions(+), 21 deletions(-)
target/s390x/cpu.h +7 -0
index a606547b4d..c34992bb2e 100644
@@ -332,6 +332,13 @@ static inline int cpu_mmu_index(CPUS390XState *env, bool ifetch)
         return MMU_REAL_IDX;
     }
 
+    if (ifetch) {
+        if ((env->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME) {
+            return MMU_HOME_IDX;
+        }
+        return MMU_PRIMARY_IDX;
+    }
+
     switch (env->psw.mask & PSW_MASK_ASC) {
     case PSW_ASC_PRIMARY:
         return MMU_PRIMARY_IDX;
target/s390x/mmu_helper.c +0 -0
index 6e9c4d6151..2c9bb3acc0 100644

target/s390x/mmu_helper.c int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc, · line 353

Quoted 5 lines
target/s390x/mmu_helper.c +1 -0
@@ -349,6 +349,7 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
 {
     static S390SKeysState *ss;
     static S390SKeysClass *skeyclass;
+    uint64_t asce;
     int r = -1;

I can now stop initializing r.

target/s390x/mmu_helper.c int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc, · line 384

Quoted 6 lines
target/s390x/mmu_helper.c +0 -0
     uint8_t key;
 
@@ -381,35 +382,21 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
     if (!(env->psw.mask & PSW_MASK_DAT)) {
         *raddr = vaddr;
         r = 0;

and this can go as well.

Quoted 4 lines
target/s390x/mmu_helper.c +1 -1
-        goto out;
+        goto nodat;
     }
 
Signature · 3 lines
Thanks,

David / dhildenb
#9 lore raw

Re: [Qemu-devel] [PATCH-for-4.2 v1 2/6] s390x/tcg: Rework MMU selection for instruction fetches

Quoted 48 lines · On Mon, 12 Aug 2019 15:37:39 +0200 David Hildenbrand <[email protected]> wrote:
Quoted 39 lines · David Hildenbrand

Instructions are always fetched from primary address space, except when in home address mode. Perform the selection directly in cpu_mmu_index().

get_mem_index() is only used to perform data access, instructions are fetched via cpu_lduw_code(), which translates to cpu_mmu_index(env, true).

We don't care about restricting the access permissions of the TLB entries anymore, as we no longer enter PRIMARY entries into the SECONDARY MMU. Cleanup related code a bit.

---
 target/s390x/cpu.h        |  7 +++++++
 target/s390x/mmu_helper.c | 35 ++++++++++++++---------------------
 2 files changed, 21 insertions(+), 21 deletions(-)
target/s390x/cpu.h +7 -0
index a606547b4d..c34992bb2e 100644
@@ -332,6 +332,13 @@ static inline int cpu_mmu_index(CPUS390XState *env, bool ifetch)
         return MMU_REAL_IDX;
     }
 
+    if (ifetch) {
+        if ((env->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME) {
+            return MMU_HOME_IDX;
+        }
+        return MMU_PRIMARY_IDX;
+    }
+
     switch (env->psw.mask & PSW_MASK_ASC) {
     case PSW_ASC_PRIMARY:
         return MMU_PRIMARY_IDX;
target/s390x/mmu_helper.c +0 -0
index 6e9c4d6151..2c9bb3acc0 100644

target/s390x/mmu_helper.c int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc, · line 353

Quoted 5 lines
target/s390x/mmu_helper.c +1 -0
@@ -349,6 +349,7 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
 {
     static S390SKeysState *ss;
     static S390SKeysClass *skeyclass;
+    uint64_t asce;
     int r = -1;  

I can now stop initializing r.

Quoted 15 lines

target/s390x/mmu_helper.c int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc, · line 384

Quoted 6 lines
target/s390x/mmu_helper.c +0 -0
     uint8_t key;
 
@@ -381,35 +382,21 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
     if (!(env->psw.mask & PSW_MASK_DAT)) {
         *raddr = vaddr;
         r = 0;  

and this can go as well.

Quoted 4 lines
target/s390x/mmu_helper.c +1 -1
-        goto out;
+        goto nodat;
     }
 

So, there will be a v2?

#10 lore raw

Re: [Qemu-devel] [PATCH-for-4.2 v1 2/6] s390x/tcg: Rework MMU selection for instruction fetches

Quoted 60 lines · Cornelia Huck
Quoted 57 lines · On Mon, 12 Aug 2019 15:37:39 +0200 David Hildenbrand <[email protected]> wrote:
Quoted 39 lines · David Hildenbrand

Instructions are always fetched from primary address space, except when in home address mode. Perform the selection directly in cpu_mmu_index().

get_mem_index() is only used to perform data access, instructions are fetched via cpu_lduw_code(), which translates to cpu_mmu_index(env, true).

We don't care about restricting the access permissions of the TLB entries anymore, as we no longer enter PRIMARY entries into the SECONDARY MMU. Cleanup related code a bit.

---
 target/s390x/cpu.h        |  7 +++++++
 target/s390x/mmu_helper.c | 35 ++++++++++++++---------------------
 2 files changed, 21 insertions(+), 21 deletions(-)
target/s390x/cpu.h +7 -0
index a606547b4d..c34992bb2e 100644
@@ -332,6 +332,13 @@ static inline int cpu_mmu_index(CPUS390XState *env, bool ifetch)
         return MMU_REAL_IDX;
     }
 
+    if (ifetch) {
+        if ((env->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME) {
+            return MMU_HOME_IDX;
+        }
+        return MMU_PRIMARY_IDX;
+    }
+
     switch (env->psw.mask & PSW_MASK_ASC) {
     case PSW_ASC_PRIMARY:
         return MMU_PRIMARY_IDX;
target/s390x/mmu_helper.c +0 -0
index 6e9c4d6151..2c9bb3acc0 100644

target/s390x/mmu_helper.c int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc, · line 353

Quoted 5 lines
target/s390x/mmu_helper.c +1 -0
@@ -349,6 +349,7 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
 {
     static S390SKeysState *ss;
     static S390SKeysClass *skeyclass;
+    uint64_t asce;
     int r = -1;  

I can now stop initializing r.

target/s390x/mmu_helper.c int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc, · line 384

Quoted 6 lines
target/s390x/mmu_helper.c +0 -0
     uint8_t key;
 
@@ -381,35 +382,21 @@ int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
     if (!(env->psw.mask & PSW_MASK_DAT)) {
         *raddr = vaddr;
         r = 0;  

and this can go as well.

Quoted 8 lines
Quoted 6 lines

target/s390x/mmu_helper.c int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc, · line 387

Quoted 4 lines
target/s390x/mmu_helper.c +1 -1
-        goto out;
+        goto nodat;
     }
 

So, there will be a v2?

Yes, but waiting for more feedback.

Signature · 3 lines
Thanks,

David / dhildenb
#11 lore raw

Re: [Qemu-devel] [PATCH-for-4.2 v1 2/6] s390x/tcg: Rework MMU selection for instruction fetches

In reply to David Hildenbrand
Quoted 10 lines · On Mon, 12 Aug 2019 13:27:33 +0200 David Hildenbrand <[email protected]> wrote:

Instructions are always fetched from primary address space, except when in home address mode. Perform the selection directly in cpu_mmu_index().

get_mem_index() is only used to perform data access, instructions are fetched via cpu_lduw_code(), which translates to cpu_mmu_index(env, true).

We don't care about restricting the access permissions of the TLB entries anymore, as we no longer enter PRIMARY entries into the SECONDARY MMU. Cleanup related code a bit.

Quoted 5 lines
---
 target/s390x/cpu.h        |  7 +++++++
 target/s390x/mmu_helper.c | 35 ++++++++++++++---------------------
 2 files changed, 21 insertions(+), 21 deletions(-)

Looks sane to me; will wait for v2 to give a tag.

#12 lore raw

PATCH 3/6 s390x/tcg: Flush the TLB of all CPUs on SSKE and RRBE

In reply to David Hildenbrand

Whenever we modify a storage key, we shuld flush the TLBs of all CPUs, so the MMU fault handling code can properly consider the changed storage key (to e.g., properly set the reference and change bit on the next accesses).

These functions are barely used in modern Linux guests, so the performance implications are neglectable for now.

This is a preparation for better reference and change bit handling for TCG, which will require more MMU changes.

---
 target/s390x/mem_helper.c | 4 ++++
 1 file changed, 4 insertions(+)
target/s390x/mem_helper.c +4 -0
index 29d9eaa5b7..ed54265e03 100644
@@ -1815,6 +1815,8 @@ void HELPER(sske)(CPUS390XState *env, uint64_t r1, uint64_t r2)
 
     key = (uint8_t) r1;
     skeyclass->set_skeys(ss, addr / TARGET_PAGE_SIZE, 1, &key);
+    /* TODO: Flush only entries with this target address */
+    tlb_flush_all_cpus_synced(env_cpu(env));
 }
 
 /* reset reference bit extended */
@@ -1843,6 +1845,8 @@ uint32_t HELPER(rrbe)(CPUS390XState *env, uint64_t r2)
     if (skeyclass->set_skeys(ss, r2 / TARGET_PAGE_SIZE, 1, &key)) {
         return 0;
     }
+    /* TODO: Flush only entries with this target address */
+    tlb_flush_all_cpus_synced(env_cpu(env));
 
     /*
      * cc
Signature · 1 line
2.21.0
Reviewed-by on v1 3/6
#13 lore raw

Re: [Qemu-devel] [PATCH-for-4.2 v1 3/6] s390x/tcg: Flush the TLB of all CPUs on SSKE and RRBE

Quoted 30 lines · On Mon, 12 Aug 2019 13:27:34 +0200 David Hildenbrand <[email protected]> wrote:

Whenever we modify a storage key, we shuld flush the TLBs of all CPUs, so the MMU fault handling code can properly consider the changed storage key (to e.g., properly set the reference and change bit on the next accesses).

These functions are barely used in modern Linux guests, so the performance implications are neglectable for now.

This is a preparation for better reference and change bit handling for TCG, which will require more MMU changes.

---
 target/s390x/mem_helper.c | 4 ++++
 1 file changed, 4 insertions(+)
target/s390x/mem_helper.c +2 -0
index 29d9eaa5b7..ed54265e03 100644
@@ -1815,6 +1815,8 @@ void HELPER(sske)(CPUS390XState *env, uint64_t r1, uint64_t r2)
 
     key = (uint8_t) r1;
     skeyclass->set_skeys(ss, addr / TARGET_PAGE_SIZE, 1, &key);
+    /* TODO: Flush only entries with this target address */
+    tlb_flush_all_cpus_synced(env_cpu(env));
 }
 
 /* reset reference bit extended */

target/s390x/mem_helper.c uint32_t HELPER(rrbe)(CPUS390XState *env, uint64_t r2) · line 1852

Quoted 8 lines
target/s390x/mem_helper.c +2 -0
@@ -1843,6 +1845,8 @@ uint32_t HELPER(rrbe)(CPUS390XState *env, uint64_t r2)
     if (skeyclass->set_skeys(ss, r2 / TARGET_PAGE_SIZE, 1, &key)) {
         return 0;
     }
+    /* TODO: Flush only entries with this target address */
+    tlb_flush_all_cpus_synced(env_cpu(env));
 
     /*
      * cc

Seems reasonable.

#14 lore raw

PATCH 4/6 s390x/mmu: Trace the right value if setting/getting the storage key fails

In reply to David Hildenbrand

We want to trace the actual return value, not "0".

---
 target/s390x/mmu_helper.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)
target/s390x/mmu_helper.c +4 -2
index 2c9bb3acc0..227a822e42 100644
@@ -415,7 +415,8 @@ nodat:
     *raddr = mmu_real2abs(env, *raddr);
 
     if (*raddr < ram_size) {
-        if (skeyclass->get_skeys(ss, *raddr / TARGET_PAGE_SIZE, 1, &key)) {
+        r = skeyclass->get_skeys(ss, *raddr / TARGET_PAGE_SIZE, 1, &key);
+        if (r) {
             trace_get_skeys_nonzero(r);
             return 0;
         }
@@ -428,7 +429,8 @@ nodat:
             key |= SK_C;
         }
 
-        if (skeyclass->set_skeys(ss, *raddr / TARGET_PAGE_SIZE, 1, &key)) {
+        r = skeyclass->set_skeys(ss, *raddr / TARGET_PAGE_SIZE, 1, &key);
+        if (r) {
             trace_set_skeys_nonzero(r);
             return 0;
         }
Signature · 1 line
2.21.0
Reviewed-by on v1 4/6
#15 lore raw

Re: [Qemu-devel] [PATCH-for-4.2 v1 4/6] s390x/mmu: Trace the right value if setting/getting the storage key fails

Quoted 1 line · On Mon, 12 Aug 2019 13:27:35 +0200 David Hildenbrand <[email protected]> wrote:

We want to trace the actual return value, not "0".

:) Nice find.

Quoted 5 lines
---
 target/s390x/mmu_helper.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)
#16 lore raw

PATCH 5/6 s390x/mmu: Better storage key reference and change bit handling

In reply to David Hildenbrand

Any access sets the reference bit. In case we have a read-fault, we should not allow writes to the TLB entry if the change bit was not already set.

This is a preparation for proper storage-key reference/change bit handling in TCG and a fix for KVM whereby read accesses would set the change bit (old KVM versions without the ioctl to carry out the translation).

---
 target/s390x/mmu_helper.c | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)
target/s390x/mmu_helper.c +19 -5
index 227a822e42..ba4b460ac6 100644
@@ -421,14 +421,28 @@ nodat:
             return 0;
         }
 
-        if (*flags & PAGE_READ) {
-            key |= SK_R;
-        }
-
-        if (*flags & PAGE_WRITE) {
+        switch (rw) {
+        case MMU_DATA_LOAD:
+        case MMU_INST_FETCH:
+            /*
+             * The TLB entry has to remain write-protected on read-faults if
+             * the storage key does not indicate a change already. Otherwise
+             * we might miss setting the change bit on write accesses.
+             */
+            if (!(key & SK_C)) {
+                *flags &= ~PAGE_WRITE;
+            }
+            break;
+        case MMU_DATA_STORE:
             key |= SK_C;
+            break;
+        default:
+            g_assert_not_reached();
         }
 
+        /* Any store/fetch sets the reference bit */
+        key |= SK_R;
+
         r = skeyclass->set_skeys(ss, *raddr / TARGET_PAGE_SIZE, 1, &key);
         if (r) {
             trace_set_skeys_nonzero(r);
Signature · 1 line
2.21.0
Reviewed-by on v1 5/6
#17 lore raw

Re: [Qemu-devel] [PATCH-for-4.2 v1 5/6] s390x/mmu: Better storage key reference and change bit handling

Quoted 7 lines · On Mon, 12 Aug 2019 13:27:36 +0200 David Hildenbrand <[email protected]> wrote:

Any access sets the reference bit. In case we have a read-fault, we should not allow writes to the TLB entry if the change bit was not already set.

This is a preparation for proper storage-key reference/change bit handling in TCG and a fix for KVM whereby read accesses would set the change bit (old KVM versions without the ioctl to carry out the translation).

That would be really old kvm versions, right? So no real need to e.g. cc:stable?

Quoted 34 lines
---
 target/s390x/mmu_helper.c | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)
target/s390x/mmu_helper.c +14 -5
index 227a822e42..ba4b460ac6 100644
@@ -421,14 +421,28 @@ nodat:
             return 0;
         }
 
-        if (*flags & PAGE_READ) {
-            key |= SK_R;
-        }
-
-        if (*flags & PAGE_WRITE) {
+        switch (rw) {
+        case MMU_DATA_LOAD:
+        case MMU_INST_FETCH:
+            /*
+             * The TLB entry has to remain write-protected on read-faults if
+             * the storage key does not indicate a change already. Otherwise
+             * we might miss setting the change bit on write accesses.
+             */
+            if (!(key & SK_C)) {
+                *flags &= ~PAGE_WRITE;
+            }
+            break;
+        case MMU_DATA_STORE:
             key |= SK_C;
+            break;

target/s390x/mmu_helper.c nodat: · line 448

Quoted 10 lines
target/s390x/mmu_helper.c +5 -0
+        default:
+            g_assert_not_reached();
         }
 
+        /* Any store/fetch sets the reference bit */
+        key |= SK_R;
+
         r = skeyclass->set_skeys(ss, *raddr / TARGET_PAGE_SIZE, 1, &key);
         if (r) {
             trace_set_skeys_nonzero(r);

I've stared at this for quite some time now and have convinced myself that it looks sane.

#18 lore raw

Re: [Qemu-devel] [qemu-s390x] [PATCH-for-4.2 v1 5/6] s390x/mmu: Better storage key reference and change bit handling

Quoted 7 lines · Cornelia Huck
Quoted 4 lines · On Mon, 12 Aug 2019 13:27:36 +0200 David Hildenbrand <[email protected]> wrote:

Any access sets the reference bit. In case we have a read-fault, we should not allow writes to the TLB entry if the change bit was not already set.

Quoted 6 lines
Quoted 3 lines

This is a preparation for proper storage-key reference/change bit handling in TCG and a fix for KVM whereby read accesses would set the change bit (old KVM versions without the ioctl to carry out the translation).

That would be really old kvm versions, right? So no real need to e.g. cc:stable?

Yes - nothing a distribution ever supported AFAIK.

Signature · 3 lines
Thanks,

David / dhildenb
#19 lore raw

PATCH 6/6 s390x/mmu: Factor out storage key handling

In reply to David Hildenbrand

Factor it out, add a comment how it all works, and also use it in the REAL MMU.

---
 target/s390x/mmu_helper.c | 114 +++++++++++++++++++++++---------------
 1 file changed, 69 insertions(+), 45 deletions(-)
target/s390x/mmu_helper.c +69 -45
index ba4b460ac6..d2c9285d0a 100644
@@ -334,6 +334,73 @@ static int mmu_translate_asce(CPUS390XState *env, target_ulong vaddr,
     return r;
 }
 
+static void mmu_handle_skey(target_ulong addr, int rw, int *flags)
+{
+    static S390SKeysClass *skeyclass;
+    static S390SKeysState *ss;
+    uint8_t key;
+    int rc;
+
+    if (unlikely(!ss)) {
+        ss = s390_get_skeys_device();
+        skeyclass = S390_SKEYS_GET_CLASS(ss);
+    }
+
+    /*
+     * Whenever we create a new TLB entry, we set the storage key reference
+     * bit. In case we allow write accesses, we set the storage key change
+     * bit. Whenever the guest changes the storage key, we have to flush the
+     * TLBs of all CPUs (the whole TLB or all affected entries), so that the
+     * next reference/change will result in an MMU fault and make us properly
+     * update the storage key here.
+     *
+     * Note 1: "record of references ... is not necessarily accurate",
+     *         "change bit may be set in case no storing has occurred".
+     *         -> We can set reference/change bits even on exceptions.
+     * Note 2: certain accesses seem to ignore storage keys. For example,
+     *         DAT translation does not set reference bits for table accesses.
+     *
+     * TODO: key-controlled protection. Only CPU accesses make use of the
+     *       PSW key. CSS accesses are different - we have to pass in the key.
+     *
+     * TODO: we have races between getting and setting the key.
+     */
+    if (addr < ram_size) {
+        rc = skeyclass->get_skeys(ss, addr / TARGET_PAGE_SIZE, 1, &key);
+        if (rc) {
+            trace_get_skeys_nonzero(rc);
+            return;
+        }
+
+        switch (rw) {
+        case MMU_DATA_LOAD:
+        case MMU_INST_FETCH:
+            /*
+             * The TLB entry has to remain write-protected on read-faults if
+             * the storage key does not indicate a change already. Otherwise
+             * we might miss setting the change bit on write accesses.
+             */
+            if (!(key & SK_C)) {
+                *flags &= ~PAGE_WRITE;
+            }
+            break;
+        case MMU_DATA_STORE:
+            key |= SK_C;
+            break;
+        default:
+            g_assert_not_reached();
+        }
+
+        /* Any store/fetch sets the reference bit */
+        key |= SK_R;
+
+        rc = skeyclass->set_skeys(ss, addr / TARGET_PAGE_SIZE, 1, &key);
+        if (rc) {
+            trace_set_skeys_nonzero(rc);
+        }
+    }
+}
+
 /**
  * Translate a virtual (logical) address into a physical (absolute) address.
  * @param vaddr  the virtual address
@@ -347,16 +414,8 @@ static int mmu_translate_asce(CPUS390XState *env, target_ulong vaddr,
 int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
                   target_ulong *raddr, int *flags, bool exc)
 {
-    static S390SKeysState *ss;
-    static S390SKeysClass *skeyclass;
     uint64_t asce;
     int r = -1;
-    uint8_t key;
-
-    if (unlikely(!ss)) {
-        ss = s390_get_skeys_device();
-        skeyclass = S390_SKEYS_GET_CLASS(ss);
-    }
 
     *flags = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
     if (is_low_address(vaddr & TARGET_PAGE_MASK) && lowprot_enabled(env, asc)) {
@@ -414,42 +473,7 @@ nodat:
     /* Convert real address -> absolute address */
     *raddr = mmu_real2abs(env, *raddr);
 
-    if (*raddr < ram_size) {
-        r = skeyclass->get_skeys(ss, *raddr / TARGET_PAGE_SIZE, 1, &key);
-        if (r) {
-            trace_get_skeys_nonzero(r);
-            return 0;
-        }
-
-        switch (rw) {
-        case MMU_DATA_LOAD:
-        case MMU_INST_FETCH:
-            /*
-             * The TLB entry has to remain write-protected on read-faults if
-             * the storage key does not indicate a change already. Otherwise
-             * we might miss setting the change bit on write accesses.
-             */
-            if (!(key & SK_C)) {
-                *flags &= ~PAGE_WRITE;
-            }
-            break;
-        case MMU_DATA_STORE:
-            key |= SK_C;
-            break;
-        default:
-            g_assert_not_reached();
-        }
-
-        /* Any store/fetch sets the reference bit */
-        key |= SK_R;
-
-        r = skeyclass->set_skeys(ss, *raddr / TARGET_PAGE_SIZE, 1, &key);
-        if (r) {
-            trace_set_skeys_nonzero(r);
-            return 0;
-        }
-    }
-
+    mmu_handle_skey(*raddr, rw, flags);
     return 0;
 }
 
@@ -567,6 +591,6 @@ int mmu_translate_real(CPUS390XState *env, target_ulong raddr, int rw,
 
     *addr = mmu_real2abs(env, raddr & TARGET_PAGE_MASK);
 
-    /* TODO: storage key handling */
+    mmu_handle_skey(*addr, rw, flags);
     return 0;
 }
Signature · 1 line
2.21.0
Reviewed-by on v1 6/6
#20 lore raw

Re: [Qemu-devel] [PATCH-for-4.2 v1 6/6] s390x/mmu: Factor out storage key handling

Quoted 7 lines · On Mon, 12 Aug 2019 13:27:37 +0200 David Hildenbrand <[email protected]> wrote:

Factor it out, add a comment how it all works, and also use it in the REAL MMU.

---
 target/s390x/mmu_helper.c | 114 +++++++++++++++++++++++---------------
 1 file changed, 69 insertions(+), 45 deletions(-)

Looks good to me.