[Qemu-devel] [PULL 00/34] s390x update

[Qemu-devel] [PULL 00/34] s390x update

[Cornelia Huck]

The following changes since commit f8c3db33a5e863291182f8862ddf81618a7c6194:

  target/sparc: Switch to do_transaction_failed() hook (2019-09-17 12:01:00 +0100)

are available in the Git repository at:

  https://github.com/cohuck/qemu tags/s390x-20190919

for you to fetch changes up to 37105adebeb28e60da3cb1ef82231d7ed8d23589:

  Merge tag 'tags/s390-ccw-bios-2019-09-18' into s390-next-staging (2019-09-19 12:04:01 +0200)

----------------------------------------------------------------
- bugfixes in tcg and the ccw bios
- gen15a is called z15
- officially require a 3.15 kernel or later for kvm

----------------------------------------------------------------

Christian Borntraeger (1):
  s390x/cpumodel: Add the z15 name to the description of gen15a

David Hildenbrand (29):
  s390x/tcg: Reset exception_index to -1 instead of 0
  s390x/tcg: MVCL: Zero out unused bits of address
  s390x/tcg: MVCL: Detect destructive overlaps
  s390x/tcg: MVCL: Process max 4k bytes at a time
  s390x/tcg: MVC: Increment the length once
  s390x/tcg: MVC: Use is_destructive_overlap()
  s390x/tcg: MVPG: Check for specification exceptions
  s390x/tcg: MVPG: Properly wrap the addresses
  s390x/tcg: MVCLU/MVCLE: Process max 4k bytes at a time
  s390x/tcg: MVCS/MVCP: Check for special operation exceptions
  s390x/tcg: MVCOS: Lengths are 32 bit in 24/31-bit mode
  s390x/tcg: MVCS/MVCP: Properly wrap the length
  s390x/tcg: MVST: Check for specification exceptions
  s390x/tcg: MVST: Fix storing back the addresses to registers
  s390x/tcg: Always use MMU_USER_IDX for CONFIG_USER_ONLY
  s390x/tcg: Fault-safe memset
  s390x/tcg: Fault-safe memmove
  s390x/tcg: MVCS/MVCP: Use access_memmove()
  s390x/tcg: MVC: Fault-safe handling on destructive overlaps
  s390x/tcg: MVCLU: Fault-safe handling
  s390x/tcg: OC: Fault-safe handling
  s390x/tcg: XC: Fault-safe handling
  s390x/tcg: NC: Fault-safe handling
  s390x/tcg: MVCIN: Fault-safe handling
  s390x/tcg: MVN: Fault-safe handling
  s390x/tcg: MVZ: Fault-safe handling
  s390x/tcg: MVST: Fault-safe handling
  s390x/tcg: MVO: Fault-safe handling
  tests/tcg: target/s390x: Test MVO

Thomas Huth (3):
  pc-bios/s390-ccw: Do not pre-initialize empty array
  pc-bios/s390-ccw: Rebuild the s390-netboot.img firmware image
  s390x/kvm: Officially require at least kernel 3.15

Yifan Luo (1):
  pc-bios/s390-ccw/net: fix a possible memory leak in get_uuid()

 hw/intc/s390_flic_kvm.c   | 6 ------
 hw/intc/trace-events      | 1 -
 target/s390x/cpu_models.c | 2 +-
 target/s390x/kvm.c        | 7 +++++++
 4 files changed, 8 insertions(+), 8 deletions(-)

-- 
2.20.1

[Qemu-devel] [PULL 01/34] s390x/tcg: Reset exception_index to -1 instead of 0

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

We use the marker "-1" for "no exception". s390_cpu_do_interrupt() might
get confused by that.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 29fcce426e35..39ee9b3175ca 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -1747,7 +1747,7 @@ uint32_t HELPER(tprot)(CPUS390XState *env, uint64_t a1, uint64_t a2)
 
     if (env->int_pgm_code == PGM_PROTECTION) {
         /* retry if reading is possible */
-        cs->exception_index = 0;
+        cs->exception_index = -1;
         if (!s390_cpu_virt_mem_check_read(cpu, a1, 0, 1)) {
             /* Fetching permitted; storing not permitted */
             return 1;
@@ -1757,7 +1757,7 @@ uint32_t HELPER(tprot)(CPUS390XState *env, uint64_t a1, uint64_t a2)
     switch (env->int_pgm_code) {
     case PGM_PROTECTION:
         /* Fetching not permitted; storing not permitted */
-        cs->exception_index = 0;
+        cs->exception_index = -1;
         return 2;
     case PGM_ADDRESSING:
     case PGM_TRANS_SPEC:
@@ -1767,7 +1767,7 @@ uint32_t HELPER(tprot)(CPUS390XState *env, uint64_t a1, uint64_t a2)
     }
 
     /* Translation not available */
-    cs->exception_index = 0;
+    cs->exception_index = -1;
     return 3;
 }
 
-- 
2.20.1

[Qemu-devel] [PULL 02/34] s390x/tcg: MVCL: Zero out unused bits of address

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

We have to zero out unused bits in 24 and 31-bit addressing mode.
Provide a new helper.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 39ee9b3175ca..b02ad148e55b 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -469,6 +469,25 @@ static inline uint64_t get_address(CPUS390XState *env, int reg)
     return wrap_address(env, env->regs[reg]);
 }
 
+/*
+ * Store the address to the given register, zeroing out unused leftmost
+ * bits in bit positions 32-63 (24-bit and 31-bit mode only).
+ */
+static inline void set_address_zero(CPUS390XState *env, int reg,
+                                    uint64_t address)
+{
+    if (env->psw.mask & PSW_MASK_64) {
+        env->regs[reg] = address;
+    } else {
+        if (!(env->psw.mask & PSW_MASK_32)) {
+            address &= 0x00ffffff;
+        } else {
+            address &= 0x7fffffff;
+        }
+        env->regs[reg] = deposit64(env->regs[reg], 0, 32, address);
+    }
+}
+
 static inline void set_address(CPUS390XState *env, int reg, uint64_t address)
 {
     if (env->psw.mask & PSW_MASK_64) {
@@ -772,8 +791,8 @@ uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
 
     env->regs[r1 + 1] = deposit64(env->regs[r1 + 1], 0, 24, destlen);
     env->regs[r2 + 1] = deposit64(env->regs[r2 + 1], 0, 24, srclen);
-    set_address(env, r1, dest);
-    set_address(env, r2, src);
+    set_address_zero(env, r1, dest);
+    set_address_zero(env, r2, src);
 
     return cc;
 }
-- 
2.20.1

[Qemu-devel] [PULL 03/34] s390x/tcg: MVCL: Detect destructive overlaps

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

We'll have to zero-out unused bit positions, so make sure to write the
addresses back.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index b02ad148e55b..223312a4b194 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -52,6 +52,19 @@ static inline bool psw_key_valid(CPUS390XState *env, uint8_t psw_key)
     return true;
 }
 
+static bool is_destructive_overlap(CPUS390XState *env, uint64_t dest,
+                                   uint64_t src, uint32_t len)
+{
+    if (!len || src == dest) {
+        return false;
+    }
+    /* Take care of wrapping at the end of address space. */
+    if (unlikely(wrap_address(env, src + len - 1) < src)) {
+        return dest > src || dest <= wrap_address(env, src + len - 1);
+    }
+    return dest > src && dest <= src + len - 1;
+}
+
 /* Reduce the length so that addr + len doesn't cross a page boundary.  */
 static inline uint32_t adj_len_to_page(uint32_t len, uint64_t addr)
 {
@@ -787,7 +800,11 @@ uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
     uint8_t pad = env->regs[r2 + 1] >> 24;
     uint32_t cc;
 
-    cc = do_mvcl(env, &dest, &destlen, &src, &srclen, pad, 1, ra);
+    if (is_destructive_overlap(env, dest, src, MIN(srclen, destlen))) {
+        cc = 3;
+    } else {
+        cc = do_mvcl(env, &dest, &destlen, &src, &srclen, pad, 1, ra);
+    }
 
     env->regs[r1 + 1] = deposit64(env->regs[r1 + 1], 0, 24, destlen);
     env->regs[r2 + 1] = deposit64(env->regs[r2 + 1], 0, 24, srclen);
-- 
2.20.1

[Qemu-devel] [PULL 04/34] s390x/tcg: MVCL: Process max 4k bytes at a time

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Process max 4k bytes at a time, writing back registers between the
accesses. The instruction is interruptible.
    "For operands longer than 2K bytes, access exceptions are not
    recognized for locations more than 2K bytes beyond the current location
    being processed."
Note that on z/Architecture, 2k vs. 4k access cannot get differentiated as
long as pages are not crossed. This seems to be a leftover from ESA/390.
Simply stay within single pages.

MVCL handling is quite different than MVCLE/MVCLU handling, so split up
the handlers.

Defer interrupt handling, as that will require more thought, add a TODO
for that.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 44 +++++++++++++++++++++++++++++++++------
 1 file changed, 38 insertions(+), 6 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 223312a4b194..58ab2e48e341 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -798,19 +798,51 @@ uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
     uint64_t srclen = env->regs[r2 + 1] & 0xffffff;
     uint64_t src = get_address(env, r2);
     uint8_t pad = env->regs[r2 + 1] >> 24;
-    uint32_t cc;
+    uint32_t cc, cur_len;
 
     if (is_destructive_overlap(env, dest, src, MIN(srclen, destlen))) {
         cc = 3;
+    } else if (srclen == destlen) {
+        cc = 0;
+    } else if (destlen < srclen) {
+        cc = 1;
     } else {
-        cc = do_mvcl(env, &dest, &destlen, &src, &srclen, pad, 1, ra);
+        cc = 2;
     }
 
-    env->regs[r1 + 1] = deposit64(env->regs[r1 + 1], 0, 24, destlen);
-    env->regs[r2 + 1] = deposit64(env->regs[r2 + 1], 0, 24, srclen);
-    set_address_zero(env, r1, dest);
-    set_address_zero(env, r2, src);
+    /* We might have to zero-out some bits even if there was no action. */
+    if (unlikely(!destlen || cc == 3)) {
+        set_address_zero(env, r2, src);
+        set_address_zero(env, r1, dest);
+        return cc;
+    } else if (!srclen) {
+        set_address_zero(env, r2, src);
+    }
 
+    /*
+     * Only perform one type of type of operation (move/pad) in one step.
+     * Stay within single pages.
+     */
+    while (destlen) {
+        cur_len = MIN(destlen, -(dest | TARGET_PAGE_MASK));
+        if (!srclen) {
+            fast_memset(env, dest, pad, cur_len, ra);
+        } else {
+            cur_len = MIN(MIN(srclen, -(src | TARGET_PAGE_MASK)), cur_len);
+
+            fast_memmove(env, dest, src, cur_len, ra);
+            src = wrap_address(env, src + cur_len);
+            srclen -= cur_len;
+            env->regs[r2 + 1] = deposit64(env->regs[r2 + 1], 0, 24, srclen);
+            set_address_zero(env, r2, src);
+        }
+        dest = wrap_address(env, dest + cur_len);
+        destlen -= cur_len;
+        env->regs[r1 + 1] = deposit64(env->regs[r1 + 1], 0, 24, destlen);
+        set_address_zero(env, r1, dest);
+
+        /* TODO: Deliver interrupts. */
+    }
     return cc;
 }
 
-- 
2.20.1

[Qemu-devel] [PULL 05/34] s390x/tcg: MVC: Increment the length once

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Let's increment the length once.

While at it, cleanup the comment. The memset() example is given as a
programming note in the PoP, so drop the description.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 58ab2e48e341..013e8d6045e7 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -320,16 +320,20 @@ static uint32_t do_helper_mvc(CPUS390XState *env, uint32_t l, uint64_t dest,
     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",
                __func__, l, dest, src);
 
-    /* mvc and memmove do not behave the same when areas overlap! */
-    /* mvc with source pointing to the byte after the destination is the
-       same as memset with the first source byte */
+    /* MVC always copies one more byte than specified - maximum is 256 */
+    l++;
+
+    /*
+     * "When the operands overlap, the result is obtained as if the operands
+     * were processed one byte at a time". Only non-destructive overlaps
+     * behave like memmove().
+     */
     if (dest == src + 1) {
-        fast_memset(env, dest, cpu_ldub_data_ra(env, src, ra), l + 1, ra);
-    } else if (dest < src || src + l < dest) {
-        fast_memmove(env, dest, src, l + 1, ra);
+        fast_memset(env, dest, cpu_ldub_data_ra(env, src, ra), l, ra);
+    } else if (dest < src || src + l <= dest) {
+        fast_memmove(env, dest, src, l, ra);
     } else {
-        /* slow version with byte accesses which always work */
-        for (i = 0; i <= l; i++) {
+        for (i = 0; i < l; i++) {
             uint8_t x = cpu_ldub_data_ra(env, src + i, ra);
             cpu_stb_data_ra(env, dest + i, x, ra);
         }
-- 
2.20.1

[Qemu-devel] [PULL 06/34] s390x/tcg: MVC: Use is_destructive_overlap()

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Let's use the new helper, that also detects destructive overlaps when
wrapping.

We'll make the remaining code (e.g., fast_memmove()) aware of wrapping
later.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 013e8d6045e7..c31cf4959358 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -330,7 +330,7 @@ static uint32_t do_helper_mvc(CPUS390XState *env, uint32_t l, uint64_t dest,
      */
     if (dest == src + 1) {
         fast_memset(env, dest, cpu_ldub_data_ra(env, src, ra), l, ra);
-    } else if (dest < src || src + l <= dest) {
+    } else if (!is_destructive_overlap(env, dest, src, l)) {
         fast_memmove(env, dest, src, l, ra);
     } else {
         for (i = 0; i < l; i++) {
-- 
2.20.1

[Qemu-devel] [PULL 07/34] s390x/tcg: MVPG: Check for specification exceptions

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Perform the checks documented in the PoP.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index c31cf4959358..7dfa848744a6 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -672,6 +672,13 @@ uint64_t HELPER(clst)(CPUS390XState *env, uint64_t c, uint64_t s1, uint64_t s2)
 /* move page */
 uint32_t HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint64_t r1, uint64_t r2)
 {
+    const bool f = extract64(r0, 11, 1);
+    const bool s = extract64(r0, 10, 1);
+
+    if ((f && s) || extract64(r0, 12, 4)) {
+        s390_program_interrupt(env, PGM_SPECIFICATION, ILEN_AUTO, GETPC());
+    }
+
     /* ??? missing r0 handling, which includes access keys, but more
        importantly optional suppression of the exception!  */
     fast_memmove(env, r1, r2, TARGET_PAGE_SIZE, GETPC());
-- 
2.20.1

[Qemu-devel] [PULL 08/34] s390x/tcg: MVPG: Properly wrap the addresses

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

We have to mask of any unused bits. While at it, document what exactly is
missing.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 7dfa848744a6..746f64730302 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -679,8 +679,15 @@ uint32_t HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint64_t r1, uint64_t r2)
         s390_program_interrupt(env, PGM_SPECIFICATION, ILEN_AUTO, GETPC());
     }
 
-    /* ??? missing r0 handling, which includes access keys, but more
-       importantly optional suppression of the exception!  */
+    r1 = wrap_address(env, r1 & TARGET_PAGE_MASK);
+    r2 = wrap_address(env, r2 & TARGET_PAGE_MASK);
+
+    /*
+     * TODO:
+     * - Access key handling
+     * - CC-option with surpression of page-translation exceptions
+     * - Store r1/r2 register identifiers at real location 162
+     */
     fast_memmove(env, r1, r2, TARGET_PAGE_SIZE, GETPC());
     return 0; /* data moved */
 }
-- 
2.20.1

[Qemu-devel] [PULL 09/34] s390x/tcg: MVCLU/MVCLE: Process max 4k bytes at a time

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Let's stay within single pages.

... and indicate cc=3 in case there is work remaining. Keep unicode
padding simple.

While reworking, properly wrap the addresses.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 54 ++++++++++++++++++++++-----------------
 1 file changed, 31 insertions(+), 23 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 746f64730302..86238e0163c8 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -768,8 +768,8 @@ static inline uint32_t do_mvcl(CPUS390XState *env,
                                uint64_t *src, uint64_t *srclen,
                                uint16_t pad, int wordsize, uintptr_t ra)
 {
-    uint64_t len = MIN(*srclen, *destlen);
-    uint32_t cc;
+    int len = MIN(*destlen, -(*dest | TARGET_PAGE_MASK));
+    int i, cc;
 
     if (*destlen == *srclen) {
         cc = 0;
@@ -779,32 +779,40 @@ static inline uint32_t do_mvcl(CPUS390XState *env,
         cc = 2;
     }
 
-    /* Copy the src array */
-    fast_memmove(env, *dest, *src, len, ra);
-    *src += len;
-    *srclen -= len;
-    *dest += len;
-    *destlen -= len;
+    if (!*destlen) {
+        return cc;
+    }
 
-    /* Pad the remaining area */
-    if (wordsize == 1) {
-        fast_memset(env, *dest, pad, *destlen, ra);
-        *dest += *destlen;
-        *destlen = 0;
+    /*
+     * Only perform one type of type of operation (move/pad) at a time.
+     * Stay within single pages.
+     */
+    if (*srclen) {
+        /* Copy the src array */
+        len = MIN(MIN(*srclen, -(*src | TARGET_PAGE_MASK)), len);
+        *destlen -= len;
+        *srclen -= len;
+        fast_memmove(env, *dest, *src, len, ra);
+        *src = wrap_address(env, *src + len);
+        *dest = wrap_address(env, *dest + len);
+    } else if (wordsize == 1) {
+        /* Pad the remaining area */
+        *destlen -= len;
+        fast_memset(env, *dest, pad, len, ra);
+        *dest = wrap_address(env, *dest + len);
     } else {
-        /* If remaining length is odd, pad with odd byte first.  */
-        if (*destlen & 1) {
-            cpu_stb_data_ra(env, *dest, pad & 0xff, ra);
-            *dest += 1;
-            *destlen -= 1;
-        }
-        /* The remaining length is even, pad using words.  */
-        for (; *destlen; *dest += 2, *destlen -= 2) {
-            cpu_stw_data_ra(env, *dest, pad, ra);
+        /* The remaining length selects the padding byte. */
+        for (i = 0; i < len; (*destlen)--, i++) {
+            if (*destlen & 1) {
+                cpu_stb_data_ra(env, *dest, pad, ra);
+            } else {
+                cpu_stb_data_ra(env, *dest, pad >> 8, ra);
+            }
+            *dest = wrap_address(env, *dest + 1);
         }
     }
 
-    return cc;
+    return *destlen ? 3 : cc;
 }
 
 /* move long */
-- 
2.20.1

[Qemu-devel] [PULL 10/34] s390x/tcg: MVCS/MVCP: Check for special operation exceptions

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Let's perform the documented checks.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 86238e0163c8..20e1ac0ea9cd 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -1960,12 +1960,18 @@ uint32_t HELPER(rrbe)(CPUS390XState *env, uint64_t r2)
 
 uint32_t HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
 {
+    const uint8_t psw_as = (env->psw.mask & PSW_MASK_ASC) >> PSW_SHIFT_ASC;
     uintptr_t ra = GETPC();
     int cc = 0, i;
 
     HELPER_LOG("%s: %16" PRIx64 " %16" PRIx64 " %16" PRIx64 "\n",
                __func__, l, a1, a2);
 
+    if (!(env->psw.mask & PSW_MASK_DAT) || !(env->cregs[0] & CR0_SECONDARY) ||
+        psw_as == AS_HOME || psw_as == AS_ACCREG) {
+        s390_program_interrupt(env, PGM_SPECIAL_OP, ILEN_AUTO, ra);
+    }
+
     if (l > 256) {
         /* max 256 */
         l = 256;
@@ -1983,12 +1989,18 @@ uint32_t HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
 
 uint32_t HELPER(mvcp)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
 {
+    const uint8_t psw_as = (env->psw.mask & PSW_MASK_ASC) >> PSW_SHIFT_ASC;
     uintptr_t ra = GETPC();
     int cc = 0, i;
 
     HELPER_LOG("%s: %16" PRIx64 " %16" PRIx64 " %16" PRIx64 "\n",
                __func__, l, a1, a2);
 
+    if (!(env->psw.mask & PSW_MASK_DAT) || !(env->cregs[0] & CR0_SECONDARY) ||
+        psw_as == AS_HOME || psw_as == AS_ACCREG) {
+        s390_program_interrupt(env, PGM_SPECIAL_OP, ILEN_AUTO, ra);
+    }
+
     if (l > 256) {
         /* max 256 */
         l = 256;
-- 
2.20.1

[Qemu-devel] [PULL 11/34] s390x/tcg: MVCOS: Lengths are 32 bit in 24/31-bit mode

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Triggered by a review comment from Richard, also MVCOS has a 32-bit
length in 24/31-bit addressing mode. Add a new helper.

Rename wrap_length() to wrap_length31().

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 20e1ac0ea9cd..320e9ee65c88 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -528,7 +528,15 @@ static inline void set_address(CPUS390XState *env, int reg, uint64_t address)
     }
 }
 
-static inline uint64_t wrap_length(CPUS390XState *env, uint64_t length)
+static inline uint64_t wrap_length32(CPUS390XState *env, uint64_t length)
+{
+    if (!(env->psw.mask & PSW_MASK_64)) {
+        return (uint32_t)length;
+    }
+    return length;
+}
+
+static inline uint64_t wrap_length31(CPUS390XState *env, uint64_t length)
 {
     if (!(env->psw.mask & PSW_MASK_64)) {
         /* 24-Bit and 31-Bit mode */
@@ -539,7 +547,7 @@ static inline uint64_t wrap_length(CPUS390XState *env, uint64_t length)
 
 static inline uint64_t get_length(CPUS390XState *env, int reg)
 {
-    return wrap_length(env, env->regs[reg]);
+    return wrap_length31(env, env->regs[reg]);
 }
 
 static inline void set_length(CPUS390XState *env, int reg, uint64_t length)
@@ -2378,7 +2386,7 @@ uint32_t HELPER(mvcos)(CPUS390XState *env, uint64_t dest, uint64_t src,
         s390_program_interrupt(env, PGM_PRIVILEGED, 6, ra);
     }
 
-    len = wrap_length(env, len);
+    len = wrap_length32(env, len);
     if (len > 4096) {
         cc = 3;
         len = 4096;
-- 
2.20.1

[Qemu-devel] [PULL 12/34] s390x/tcg: MVCS/MVCP: Properly wrap the length

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

... and don't perform any move in case the length is zero.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 320e9ee65c88..41d7336a1a7a 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -1980,10 +1980,13 @@ uint32_t HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
         s390_program_interrupt(env, PGM_SPECIAL_OP, ILEN_AUTO, ra);
     }
 
+    l = wrap_length32(env, l);
     if (l > 256) {
         /* max 256 */
         l = 256;
         cc = 3;
+    } else if (!l) {
+        return cc;
     }
 
     /* XXX replace w/ memcpy */
@@ -2009,10 +2012,13 @@ uint32_t HELPER(mvcp)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
         s390_program_interrupt(env, PGM_SPECIAL_OP, ILEN_AUTO, ra);
     }
 
+    l = wrap_length32(env, l);
     if (l > 256) {
         /* max 256 */
         l = 256;
         cc = 3;
+    } else if (!l) {
+        return cc;
     }
 
     /* XXX replace w/ memcpy */
-- 
2.20.1

[Qemu-devel] [PULL 13/34] s390x/tcg: MVST: Check for specification exceptions

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Bit position 32-55 of general register 0 must be zero.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 41d7336a1a7a..ec27be174b20 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -706,6 +706,9 @@ uint64_t HELPER(mvst)(CPUS390XState *env, uint64_t c, uint64_t d, uint64_t s)
     uintptr_t ra = GETPC();
     uint32_t len;
 
+    if (c & 0xffffff00ull) {
+        s390_program_interrupt(env, PGM_SPECIFICATION, ILEN_AUTO, ra);
+    }
     c = c & 0xff;
     d = wrap_address(env, d);
     s = wrap_address(env, s);
-- 
2.20.1

[Qemu-devel] [PULL 14/34] s390x/tcg: MVST: Fix storing back the addresses to registers

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

24 and 31-bit address space handling is wrong when it comes to storing
back the addresses to the register.

While at it, read gprs 0 implicitly.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/helper.h      |  2 +-
 target/s390x/insn-data.def |  2 +-
 target/s390x/mem_helper.c  | 26 +++++++++++---------------
 target/s390x/translate.c   |  8 ++++++--
 4 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/target/s390x/helper.h b/target/s390x/helper.h
index e9aff83b05d3..56e8149866f4 100644
--- a/target/s390x/helper.h
+++ b/target/s390x/helper.h
@@ -20,7 +20,7 @@ DEF_HELPER_FLAGS_4(mvn, TCG_CALL_NO_WG, void, env, i32, i64, i64)
 DEF_HELPER_FLAGS_4(mvo, TCG_CALL_NO_WG, void, env, i32, i64, i64)
 DEF_HELPER_FLAGS_4(mvpg, TCG_CALL_NO_WG, i32, env, i64, i64, i64)
 DEF_HELPER_FLAGS_4(mvz, TCG_CALL_NO_WG, void, env, i32, i64, i64)
-DEF_HELPER_4(mvst, i64, env, i64, i64, i64)
+DEF_HELPER_3(mvst, i32, env, i32, i32)
 DEF_HELPER_4(ex, void, env, i32, i64, i64)
 DEF_HELPER_FLAGS_4(stam, TCG_CALL_NO_WG, void, env, i32, i64, i32)
 DEF_HELPER_FLAGS_4(lam, TCG_CALL_NO_WG, void, env, i32, i64, i32)
diff --git a/target/s390x/insn-data.def b/target/s390x/insn-data.def
index f421184fcd53..449eee1662d0 100644
--- a/target/s390x/insn-data.def
+++ b/target/s390x/insn-data.def
@@ -637,7 +637,7 @@
 /* MOVE PAGE */
     C(0xb254, MVPG,    RRE,   Z,   r1_o, r2_o, 0, 0, mvpg, 0)
 /* MOVE STRING */
-    C(0xb255, MVST,    RRE,   Z,   r1_o, r2_o, 0, 0, mvst, 0)
+    C(0xb255, MVST,    RRE,   Z,   0, 0, 0, 0, mvst, 0)
 /* MOVE WITH OPTIONAL SPECIFICATION */
     C(0xc800, MVCOS,   SSF,   MVCOS, la1, a2, 0, 0, mvcos, 0)
 /* MOVE WITH OFFSET */
diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index ec27be174b20..a24506676b8d 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -700,18 +700,18 @@ uint32_t HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint64_t r1, uint64_t r2)
     return 0; /* data moved */
 }
 
-/* string copy (c is string terminator) */
-uint64_t HELPER(mvst)(CPUS390XState *env, uint64_t c, uint64_t d, uint64_t s)
+/* string copy */
+uint32_t HELPER(mvst)(CPUS390XState *env, uint32_t r1, uint32_t r2)
 {
+    const uint64_t d = get_address(env, r1);
+    const uint64_t s = get_address(env, r2);
+    const uint8_t c = env->regs[0];
     uintptr_t ra = GETPC();
     uint32_t len;
 
-    if (c & 0xffffff00ull) {
+    if (env->regs[0] & 0xffffff00ull) {
         s390_program_interrupt(env, PGM_SPECIFICATION, ILEN_AUTO, ra);
     }
-    c = c & 0xff;
-    d = wrap_address(env, d);
-    s = wrap_address(env, s);
 
     /* Lest we fail to service interrupts in a timely manner, limit the
        amount of work we're willing to do.  For now, let's cap at 8k.  */
@@ -719,17 +719,13 @@ uint64_t HELPER(mvst)(CPUS390XState *env, uint64_t c, uint64_t d, uint64_t s)
         uint8_t v = cpu_ldub_data_ra(env, s + len, ra);
         cpu_stb_data_ra(env, d + len, v, ra);
         if (v == c) {
-            /* Complete.  Set CC=1 and advance R1.  */
-            env->cc_op = 1;
-            env->retxl = s;
-            return d + len;
+            set_address_zero(env, r1, d + len);
+            return 1;
         }
     }
-
-    /* Incomplete.  Set CC=3 and signal to advance R1 and R2.  */
-    env->cc_op = 3;
-    env->retxl = s + len;
-    return d + len;
+    set_address_zero(env, r1, d + len);
+    set_address_zero(env, r2, s + len);
+    return 3;
 }
 
 /* load access registers r1 to r3 from memory at a2 */
diff --git a/target/s390x/translate.c b/target/s390x/translate.c
index 2927247c82f5..b0a2500e5f36 100644
--- a/target/s390x/translate.c
+++ b/target/s390x/translate.c
@@ -3488,9 +3488,13 @@ static DisasJumpType op_mvpg(DisasContext *s, DisasOps *o)
 
 static DisasJumpType op_mvst(DisasContext *s, DisasOps *o)
 {
-    gen_helper_mvst(o->in1, cpu_env, regs[0], o->in1, o->in2);
+    TCGv_i32 t1 = tcg_const_i32(get_field(s->fields, r1));
+    TCGv_i32 t2 = tcg_const_i32(get_field(s->fields, r2));
+
+    gen_helper_mvst(cc_op, cpu_env, t1, t2);
+    tcg_temp_free_i32(t1);
+    tcg_temp_free_i32(t2);
     set_cc_static(s);
-    return_low128(o->in2);
     return DISAS_NEXT;
 }
 
-- 
2.20.1

[Qemu-devel] [PULL 15/34] s390x/tcg: Always use MMU_USER_IDX for CONFIG_USER_ONLY

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Although we basically ignore the index all the time for CONFIG_USER_ONLY,
let's simply skip all the checks and always return MMU_USER_IDX in
cpu_mmu_index() and get_mem_index().

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/cpu.h       | 4 ++++
 target/s390x/translate.c | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/target/s390x/cpu.h b/target/s390x/cpu.h
index 79202c098096..163dae13d710 100644
--- a/target/s390x/cpu.h
+++ b/target/s390x/cpu.h
@@ -328,6 +328,9 @@ extern const VMStateDescription vmstate_s390_cpu;
 
 static inline int cpu_mmu_index(CPUS390XState *env, bool ifetch)
 {
+#ifdef CONFIG_USER_ONLY
+    return MMU_USER_IDX;
+#else
     if (!(env->psw.mask & PSW_MASK_DAT)) {
         return MMU_REAL_IDX;
     }
@@ -351,6 +354,7 @@ static inline int cpu_mmu_index(CPUS390XState *env, bool ifetch)
     default:
         abort();
     }
+#endif
 }
 
 static inline void cpu_get_tb_cpu_state(CPUS390XState* env, target_ulong *pc,
diff --git a/target/s390x/translate.c b/target/s390x/translate.c
index b0a2500e5f36..a3e43ff9ec0c 100644
--- a/target/s390x/translate.c
+++ b/target/s390x/translate.c
@@ -318,6 +318,9 @@ static inline uint64_t ld_code4(CPUS390XState *env, uint64_t pc)
 
 static int get_mem_index(DisasContext *s)
 {
+#ifdef CONFIG_USER_ONLY
+    return MMU_USER_IDX;
+#else
     if (!(s->base.tb->flags & FLAG_MASK_DAT)) {
         return MMU_REAL_IDX;
     }
@@ -333,6 +336,7 @@ static int get_mem_index(DisasContext *s)
         tcg_abort();
         break;
     }
+#endif
 }
 
 static void gen_exception(int excp)
-- 
2.20.1

[Qemu-devel] [PULL 16/34] s390x/tcg: Fault-safe memset

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Replace fast_memset() by access_memset(), that first tries to probe
access to all affected pages (maximum is two). We'll use the same
mechanism for other types of accesses soon.

Only in very rare cases (especially TLB_NOTDIRTY), we'll have to
fallback to ld/st helpers. Try to speed up that case as suggested by
Richard.

We'll rework most involved handlers soon to do all accesses via new
fault-safe helpers, especially MVC.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 123 +++++++++++++++++++++++++++++++-------
 1 file changed, 103 insertions(+), 20 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index a24506676b8d..dd5da7074610 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -117,27 +117,95 @@ static inline void cpu_stsize_data_ra(CPUS390XState *env, uint64_t addr,
     }
 }
 
-static void fast_memset(CPUS390XState *env, uint64_t dest, uint8_t byte,
-                        uint32_t l, uintptr_t ra)
+/* An access covers at most 4096 bytes and therefore at most two pages. */
+typedef struct S390Access {
+    target_ulong vaddr1;
+    target_ulong vaddr2;
+    char *haddr1;
+    char *haddr2;
+    uint16_t size1;
+    uint16_t size2;
+    /*
+     * If we can't access the host page directly, we'll have to do I/O access
+     * via ld/st helpers. These are internal details, so we store the
+     * mmu idx to do the access here instead of passing it around in the
+     * helpers. Maybe, one day we can get rid of ld/st access - once we can
+     * handle TLB_NOTDIRTY differently. We don't expect these special accesses
+     * to trigger exceptions - only if we would have TLB_NOTDIRTY on LAP
+     * pages, we might trigger a new MMU translation - very unlikely that
+     * the mapping changes in between and we would trigger a fault.
+     */
+    int mmu_idx;
+} S390Access;
+
+static S390Access access_prepare(CPUS390XState *env, vaddr vaddr, int size,
+                                 MMUAccessType access_type, int mmu_idx,
+                                 uintptr_t ra)
 {
-    int mmu_idx = cpu_mmu_index(env, false);
+    S390Access access = {
+        .vaddr1 = vaddr,
+        .size1 = MIN(size, -(vaddr | TARGET_PAGE_MASK)),
+        .mmu_idx = mmu_idx,
+    };
 
-    while (l > 0) {
-        void *p = tlb_vaddr_to_host(env, dest, MMU_DATA_STORE, mmu_idx);
-        if (p) {
-            /* Access to the whole page in write mode granted.  */
-            uint32_t l_adj = adj_len_to_page(l, dest);
-            memset(p, byte, l_adj);
-            dest += l_adj;
-            l -= l_adj;
+    g_assert(size > 0 && size <= 4096);
+    access.haddr1 = probe_access(env, access.vaddr1, access.size1, access_type,
+                                 mmu_idx, ra);
+
+    if (unlikely(access.size1 != size)) {
+        /* The access crosses page boundaries. */
+        access.vaddr2 = wrap_address(env, vaddr + access.size1);
+        access.size2 = size - access.size1;
+        access.haddr2 = probe_access(env, access.vaddr2, access.size2,
+                                     access_type, mmu_idx, ra);
+    }
+    return access;
+}
+
+/* Helper to handle memset on a single page. */
+static void do_access_memset(CPUS390XState *env, vaddr vaddr, char *haddr,
+                             uint8_t byte, uint16_t size, int mmu_idx,
+                             uintptr_t ra)
+{
+#ifdef CONFIG_USER_ONLY
+    g_assert(haddr);
+    memset(haddr, byte, size);
+#else
+    TCGMemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
+    int i;
+
+    if (likely(haddr)) {
+        memset(haddr, byte, size);
+    } else {
+        /*
+         * Do a single access and test if we can then get access to the
+         * page. This is especially relevant to speed up TLB_NOTDIRTY.
+         */
+        g_assert(size > 0);
+        helper_ret_stb_mmu(env, vaddr, byte, oi, ra);
+        haddr = tlb_vaddr_to_host(env, vaddr, MMU_DATA_STORE, mmu_idx);
+        if (likely(haddr)) {
+            memset(haddr + 1, byte, size - 1);
         } else {
-            /* We failed to get access to the whole page. The next write
-               access will likely fill the QEMU TLB for the next iteration.  */
-            cpu_stb_data_ra(env, dest, byte, ra);
-            dest++;
-            l--;
+            for (i = 1; i < size; i++) {
+                helper_ret_stb_mmu(env, vaddr + i, byte, oi, ra);
+            }
         }
     }
+#endif
+}
+
+static void access_memset(CPUS390XState *env, S390Access *desta,
+                          uint8_t byte, uintptr_t ra)
+{
+
+    do_access_memset(env, desta->vaddr1, desta->haddr1, byte, desta->size1,
+                     desta->mmu_idx, ra);
+    if (likely(!desta->size2)) {
+        return;
+    }
+    do_access_memset(env, desta->vaddr2, desta->haddr2, byte, desta->size2,
+                     desta->mmu_idx, ra);
 }
 
 #ifndef CONFIG_USER_ONLY
@@ -259,15 +327,19 @@ uint32_t HELPER(nc)(CPUS390XState *env, uint32_t l, uint64_t dest,
 static uint32_t do_helper_xc(CPUS390XState *env, uint32_t l, uint64_t dest,
                              uint64_t src, uintptr_t ra)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
+    S390Access desta;
     uint32_t i;
     uint8_t c = 0;
 
     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",
                __func__, l, dest, src);
 
+    desta = access_prepare(env, dest, l + 1, MMU_DATA_STORE, mmu_idx, ra);
+
     /* xor with itself is the same as memset(0) */
     if (src == dest) {
-        fast_memset(env, dest, 0, l + 1, ra);
+        access_memset(env, &desta, 0, ra);
         return 0;
     }
 
@@ -315,6 +387,8 @@ uint32_t HELPER(oc)(CPUS390XState *env, uint32_t l, uint64_t dest,
 static uint32_t do_helper_mvc(CPUS390XState *env, uint32_t l, uint64_t dest,
                               uint64_t src, uintptr_t ra)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
+    S390Access desta;
     uint32_t i;
 
     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",
@@ -323,13 +397,15 @@ static uint32_t do_helper_mvc(CPUS390XState *env, uint32_t l, uint64_t dest,
     /* MVC always copies one more byte than specified - maximum is 256 */
     l++;
 
+    desta = access_prepare(env, dest, l, MMU_DATA_STORE, mmu_idx, ra);
+
     /*
      * "When the operands overlap, the result is obtained as if the operands
      * were processed one byte at a time". Only non-destructive overlaps
      * behave like memmove().
      */
     if (dest == src + 1) {
-        fast_memset(env, dest, cpu_ldub_data_ra(env, src, ra), l, ra);
+        access_memset(env, &desta, cpu_ldub_data_ra(env, src, ra), ra);
     } else if (!is_destructive_overlap(env, dest, src, l)) {
         fast_memmove(env, dest, src, l, ra);
     } else {
@@ -775,7 +851,9 @@ static inline uint32_t do_mvcl(CPUS390XState *env,
                                uint64_t *src, uint64_t *srclen,
                                uint16_t pad, int wordsize, uintptr_t ra)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
     int len = MIN(*destlen, -(*dest | TARGET_PAGE_MASK));
+    S390Access desta;
     int i, cc;
 
     if (*destlen == *srclen) {
@@ -805,7 +883,8 @@ static inline uint32_t do_mvcl(CPUS390XState *env,
     } else if (wordsize == 1) {
         /* Pad the remaining area */
         *destlen -= len;
-        fast_memset(env, *dest, pad, len, ra);
+        desta = access_prepare(env, *dest, len, MMU_DATA_STORE, mmu_idx, ra);
+        access_memset(env, &desta, pad, ra);
         *dest = wrap_address(env, *dest + len);
     } else {
         /* The remaining length selects the padding byte. */
@@ -825,6 +904,7 @@ static inline uint32_t do_mvcl(CPUS390XState *env,
 /* move long */
 uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
     uintptr_t ra = GETPC();
     uint64_t destlen = env->regs[r1 + 1] & 0xffffff;
     uint64_t dest = get_address(env, r1);
@@ -832,6 +912,7 @@ uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
     uint64_t src = get_address(env, r2);
     uint8_t pad = env->regs[r2 + 1] >> 24;
     uint32_t cc, cur_len;
+    S390Access desta;
 
     if (is_destructive_overlap(env, dest, src, MIN(srclen, destlen))) {
         cc = 3;
@@ -859,7 +940,9 @@ uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
     while (destlen) {
         cur_len = MIN(destlen, -(dest | TARGET_PAGE_MASK));
         if (!srclen) {
-            fast_memset(env, dest, pad, cur_len, ra);
+            desta = access_prepare(env, dest, cur_len, MMU_DATA_STORE, mmu_idx,
+                                   ra);
+            access_memset(env, &desta, pad, ra);
         } else {
             cur_len = MIN(MIN(srclen, -(src | TARGET_PAGE_MASK)), cur_len);
 
-- 
2.20.1

[Qemu-devel] [PULL 17/34] s390x/tcg: Fault-safe memmove

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Replace fast_memmove() variants by access_memmove() variants, that
first try to probe access to all affected pages (maximum is two pages).

Introduce access_get_byte()/access_set_byte(). We might be able to speed
up memmove in special cases even further (do single-byte access, use
memmove() for remaining bytes in page), however, we'll skip that for now.

In MVCOS, simply always call access_memmove_as() and drop the TODO
about LAP. LAP is already handled in the MMU.

Get rid of adj_len_to_page(), which is now unused.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 232 ++++++++++++++++++++++----------------
 1 file changed, 133 insertions(+), 99 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index dd5da7074610..e50cec9263c2 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -65,17 +65,6 @@ static bool is_destructive_overlap(CPUS390XState *env, uint64_t dest,
     return dest > src && dest <= src + len - 1;
 }
 
-/* Reduce the length so that addr + len doesn't cross a page boundary.  */
-static inline uint32_t adj_len_to_page(uint32_t len, uint64_t addr)
-{
-#ifndef CONFIG_USER_ONLY
-    if ((addr & ~TARGET_PAGE_MASK) + len - 1 >= TARGET_PAGE_SIZE) {
-        return -(addr | TARGET_PAGE_MASK);
-    }
-#endif
-    return len;
-}
-
 /* Trigger a SPECIFICATION exception if an address or a length is not
    naturally aligned.  */
 static inline void check_alignment(CPUS390XState *env, uint64_t v,
@@ -208,39 +197,110 @@ static void access_memset(CPUS390XState *env, S390Access *desta,
                      desta->mmu_idx, ra);
 }
 
-#ifndef CONFIG_USER_ONLY
-static void fast_memmove_idx(CPUS390XState *env, uint64_t dest, uint64_t src,
-                             uint32_t len, int dest_idx, int src_idx,
-                             uintptr_t ra)
+static uint8_t do_access_get_byte(CPUS390XState *env, vaddr vaddr, char **haddr,
+                                  int offset, int mmu_idx, uintptr_t ra)
 {
-    TCGMemOpIdx oi_dest = make_memop_idx(MO_UB, dest_idx);
-    TCGMemOpIdx oi_src = make_memop_idx(MO_UB, src_idx);
-    uint32_t len_adj;
-    void *src_p;
-    void *dest_p;
-    uint8_t x;
-
-    while (len > 0) {
-        src = wrap_address(env, src);
-        dest = wrap_address(env, dest);
-        src_p = tlb_vaddr_to_host(env, src, MMU_DATA_LOAD, src_idx);
-        dest_p = tlb_vaddr_to_host(env, dest, MMU_DATA_STORE, dest_idx);
-
-        if (src_p && dest_p) {
-            /* Access to both whole pages granted.  */
-            len_adj = adj_len_to_page(adj_len_to_page(len, src), dest);
-            memmove(dest_p, src_p, len_adj);
-        } else {
-            /* We failed to get access to one or both whole pages. The next
-               read or write access will likely fill the QEMU TLB for the
-               next iteration.  */
-            len_adj = 1;
-            x = helper_ret_ldub_mmu(env, src, oi_src, ra);
-            helper_ret_stb_mmu(env, dest, x, oi_dest, ra);
+#ifdef CONFIG_USER_ONLY
+    return ldub_p(*haddr + offset);
+#else
+    TCGMemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
+    uint8_t byte;
+
+    if (likely(*haddr)) {
+        return ldub_p(*haddr + offset);
+    }
+    /*
+     * Do a single access and test if we can then get access to the
+     * page. This is especially relevant to speed up TLB_NOTDIRTY.
+     */
+    byte = helper_ret_ldub_mmu(env, vaddr + offset, oi, ra);
+    *haddr = tlb_vaddr_to_host(env, vaddr, MMU_DATA_LOAD, mmu_idx);
+    return byte;
+#endif
+}
+
+static uint8_t access_get_byte(CPUS390XState *env, S390Access *access,
+                               int offset, uintptr_t ra)
+{
+    if (offset < access->size1) {
+        return do_access_get_byte(env, access->vaddr1, &access->haddr1,
+                                  offset, access->mmu_idx, ra);
+    }
+    return do_access_get_byte(env, access->vaddr2, &access->haddr2,
+                              offset - access->size1, access->mmu_idx, ra);
+}
+
+static void do_access_set_byte(CPUS390XState *env, vaddr vaddr, char **haddr,
+                               int offset, uint8_t byte, int mmu_idx,
+                               uintptr_t ra)
+{
+#ifdef CONFIG_USER_ONLY
+    stb_p(*haddr + offset, byte);
+#else
+    TCGMemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
+
+    if (likely(*haddr)) {
+        stb_p(*haddr + offset, byte);
+        return;
+    }
+    /*
+     * Do a single access and test if we can then get access to the
+     * page. This is especially relevant to speed up TLB_NOTDIRTY.
+     */
+    helper_ret_stb_mmu(env, vaddr + offset, byte, oi, ra);
+    *haddr = tlb_vaddr_to_host(env, vaddr, MMU_DATA_STORE, mmu_idx);
+#endif
+}
+
+static void access_set_byte(CPUS390XState *env, S390Access *access,
+                            int offset, uint8_t byte, uintptr_t ra)
+{
+    if (offset < access->size1) {
+        do_access_set_byte(env, access->vaddr1, &access->haddr1, offset, byte,
+                           access->mmu_idx, ra);
+    } else {
+        do_access_set_byte(env, access->vaddr2, &access->haddr2,
+                           offset - access->size1, byte, access->mmu_idx, ra);
+    }
+}
+
+/*
+ * Move data with the same semantics as memmove() in case ranges don't overlap
+ * or src > dest. Undefined behavior on destructive overlaps.
+ */
+static void access_memmove(CPUS390XState *env, S390Access *desta,
+                           S390Access *srca, uintptr_t ra)
+{
+    int diff;
+
+    g_assert(desta->size1 + desta->size2 == srca->size1 + srca->size2);
+
+    /* Fallback to slow access in case we don't have access to all host pages */
+    if (unlikely(!desta->haddr1 || (desta->size2 && !desta->haddr2) ||
+                 !srca->haddr1 || (srca->size2 && !srca->haddr2))) {
+        int i;
+
+        for (i = 0; i < desta->size1 + desta->size2; i++) {
+            uint8_t byte = access_get_byte(env, srca, i, ra);
+
+            access_set_byte(env, desta, i, byte, ra);
         }
-        src += len_adj;
-        dest += len_adj;
-        len -= len_adj;
+        return;
+    }
+
+    if (srca->size1 == desta->size1) {
+        memmove(desta->haddr1, srca->haddr1, srca->size1);
+        memmove(desta->haddr2, srca->haddr2, srca->size2);
+    } else if (srca->size1 < desta->size1) {
+        diff = desta->size1 - srca->size1;
+        memmove(desta->haddr1, srca->haddr1, srca->size1);
+        memmove(desta->haddr1 + srca->size1, srca->haddr2, diff);
+        memmove(desta->haddr2, srca->haddr2 + diff, desta->size2);
+    } else {
+        diff = srca->size1 - desta->size1;
+        memmove(desta->haddr1, srca->haddr1, desta->size1);
+        memmove(desta->haddr2, srca->haddr1 + desta->size1, diff);
+        memmove(desta->haddr2 + diff, srca->haddr2, srca->size2);
     }
 }
 
@@ -259,45 +319,6 @@ static int mmu_idx_from_as(uint8_t as)
     }
 }
 
-static void fast_memmove_as(CPUS390XState *env, uint64_t dest, uint64_t src,
-                            uint32_t len, uint8_t dest_as, uint8_t src_as,
-                            uintptr_t ra)
-{
-    int src_idx = mmu_idx_from_as(src_as);
-    int dest_idx = mmu_idx_from_as(dest_as);
-
-    fast_memmove_idx(env, dest, src, len, dest_idx, src_idx, ra);
-}
-#endif
-
-static void fast_memmove(CPUS390XState *env, uint64_t dest, uint64_t src,
-                         uint32_t l, uintptr_t ra)
-{
-    int mmu_idx = cpu_mmu_index(env, false);
-
-    while (l > 0) {
-        void *src_p = tlb_vaddr_to_host(env, src, MMU_DATA_LOAD, mmu_idx);
-        void *dest_p = tlb_vaddr_to_host(env, dest, MMU_DATA_STORE, mmu_idx);
-        if (src_p && dest_p) {
-            /* Access to both whole pages granted.  */
-            uint32_t l_adj = adj_len_to_page(l, src);
-            l_adj = adj_len_to_page(l_adj, dest);
-            memmove(dest_p, src_p, l_adj);
-            src += l_adj;
-            dest += l_adj;
-            l -= l_adj;
-        } else {
-            /* We failed to get access to one or both whole pages. The next
-               read or write access will likely fill the QEMU TLB for the
-               next iteration.  */
-            cpu_stb_data_ra(env, dest, cpu_ldub_data_ra(env, src, ra), ra);
-            src++;
-            dest++;
-            l--;
-        }
-    }
-}
-
 /* and on array */
 static uint32_t do_helper_nc(CPUS390XState *env, uint32_t l, uint64_t dest,
                              uint64_t src, uintptr_t ra)
@@ -388,7 +409,7 @@ static uint32_t do_helper_mvc(CPUS390XState *env, uint32_t l, uint64_t dest,
                               uint64_t src, uintptr_t ra)
 {
     const int mmu_idx = cpu_mmu_index(env, false);
-    S390Access desta;
+    S390Access srca, desta;
     uint32_t i;
 
     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",
@@ -397,6 +418,7 @@ static uint32_t do_helper_mvc(CPUS390XState *env, uint32_t l, uint64_t dest,
     /* MVC always copies one more byte than specified - maximum is 256 */
     l++;
 
+    srca = access_prepare(env, src, l, MMU_DATA_LOAD, mmu_idx, ra);
     desta = access_prepare(env, dest, l, MMU_DATA_STORE, mmu_idx, ra);
 
     /*
@@ -405,9 +427,9 @@ static uint32_t do_helper_mvc(CPUS390XState *env, uint32_t l, uint64_t dest,
      * behave like memmove().
      */
     if (dest == src + 1) {
-        access_memset(env, &desta, cpu_ldub_data_ra(env, src, ra), ra);
+        access_memset(env, &desta, access_get_byte(env, &srca, 0, ra), ra);
     } else if (!is_destructive_overlap(env, dest, src, l)) {
-        fast_memmove(env, dest, src, l, ra);
+        access_memmove(env, &desta, &srca, ra);
     } else {
         for (i = 0; i < l; i++) {
             uint8_t x = cpu_ldub_data_ra(env, src + i, ra);
@@ -756,8 +778,11 @@ uint64_t HELPER(clst)(CPUS390XState *env, uint64_t c, uint64_t s1, uint64_t s2)
 /* move page */
 uint32_t HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint64_t r1, uint64_t r2)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
     const bool f = extract64(r0, 11, 1);
     const bool s = extract64(r0, 10, 1);
+    uintptr_t ra = GETPC();
+    S390Access srca, desta;
 
     if ((f && s) || extract64(r0, 12, 4)) {
         s390_program_interrupt(env, PGM_SPECIFICATION, ILEN_AUTO, GETPC());
@@ -772,7 +797,11 @@ uint32_t HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint64_t r1, uint64_t r2)
      * - CC-option with surpression of page-translation exceptions
      * - Store r1/r2 register identifiers at real location 162
      */
-    fast_memmove(env, r1, r2, TARGET_PAGE_SIZE, GETPC());
+    srca = access_prepare(env, r2, TARGET_PAGE_SIZE, MMU_DATA_LOAD, mmu_idx,
+                          ra);
+    desta = access_prepare(env, r1, TARGET_PAGE_SIZE, MMU_DATA_STORE, mmu_idx,
+                           ra);
+    access_memmove(env, &desta, &srca, ra);
     return 0; /* data moved */
 }
 
@@ -853,7 +882,7 @@ static inline uint32_t do_mvcl(CPUS390XState *env,
 {
     const int mmu_idx = cpu_mmu_index(env, false);
     int len = MIN(*destlen, -(*dest | TARGET_PAGE_MASK));
-    S390Access desta;
+    S390Access srca, desta;
     int i, cc;
 
     if (*destlen == *srclen) {
@@ -877,7 +906,9 @@ static inline uint32_t do_mvcl(CPUS390XState *env,
         len = MIN(MIN(*srclen, -(*src | TARGET_PAGE_MASK)), len);
         *destlen -= len;
         *srclen -= len;
-        fast_memmove(env, *dest, *src, len, ra);
+        srca = access_prepare(env, *src, len, MMU_DATA_LOAD, mmu_idx, ra);
+        desta = access_prepare(env, *dest, len, MMU_DATA_STORE, mmu_idx, ra);
+        access_memmove(env, &desta, &srca, ra);
         *src = wrap_address(env, *src + len);
         *dest = wrap_address(env, *dest + len);
     } else if (wordsize == 1) {
@@ -911,8 +942,8 @@ uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
     uint64_t srclen = env->regs[r2 + 1] & 0xffffff;
     uint64_t src = get_address(env, r2);
     uint8_t pad = env->regs[r2 + 1] >> 24;
+    S390Access srca, desta;
     uint32_t cc, cur_len;
-    S390Access desta;
 
     if (is_destructive_overlap(env, dest, src, MIN(srclen, destlen))) {
         cc = 3;
@@ -946,7 +977,11 @@ uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
         } else {
             cur_len = MIN(MIN(srclen, -(src | TARGET_PAGE_MASK)), cur_len);
 
-            fast_memmove(env, dest, src, cur_len, ra);
+            srca = access_prepare(env, src, cur_len, MMU_DATA_LOAD, mmu_idx,
+                                  ra);
+            desta = access_prepare(env, dest, cur_len, MMU_DATA_STORE, mmu_idx,
+                                   ra);
+            access_memmove(env, &desta, &srca, ra);
             src = wrap_address(env, src + cur_len);
             srclen -= cur_len;
             env->regs[r2 + 1] = deposit64(env->regs[r2 + 1], 0, 24, srclen);
@@ -2488,16 +2523,15 @@ uint32_t HELPER(mvcos)(CPUS390XState *env, uint64_t dest, uint64_t src,
         s390_program_interrupt(env, PGM_ADDRESSING, 6, ra);
     }
 
-    /* FIXME: a) LAP
-     *        b) Access using correct keys
-     *        c) AR-mode
-     */
-#ifdef CONFIG_USER_ONLY
-    /* psw keys are never valid in user mode, we will never reach this */
-    g_assert_not_reached();
-#else
-    fast_memmove_as(env, dest, src, len, dest_as, src_as, ra);
-#endif
+    /* FIXME: Access using correct keys and AR-mode */
+    if (len) {
+        S390Access srca = access_prepare(env, src, len, MMU_DATA_LOAD,
+                                         mmu_idx_from_as(src_as), ra);
+        S390Access desta = access_prepare(env, dest, len, MMU_DATA_STORE,
+                                          mmu_idx_from_as(dest_as), ra);
+
+        access_memmove(env, &desta, &srca, ra);
+    }
 
     return cc;
 }
-- 
2.20.1

[Qemu-devel] [PULL 18/34] s390x/tcg: MVCS/MVCP: Use access_memmove()

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

As we are moving between address spaces, we can use access_memmove()
without checking for destructive overlaps (especially of real storage
locations):
    "Each storage operand is processed left to right. The
    storage-operand-consistency rules are the same as
    for MOVE (MVC), except that when the operands
    overlap in real storage, the use of the common real-
    storage locations is not necessarily recognized."

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index e50cec9263c2..6b85f44e2251 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -2086,8 +2086,9 @@ uint32_t HELPER(rrbe)(CPUS390XState *env, uint64_t r2)
 uint32_t HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
 {
     const uint8_t psw_as = (env->psw.mask & PSW_MASK_ASC) >> PSW_SHIFT_ASC;
+    S390Access srca, desta;
     uintptr_t ra = GETPC();
-    int cc = 0, i;
+    int cc = 0;
 
     HELPER_LOG("%s: %16" PRIx64 " %16" PRIx64 " %16" PRIx64 "\n",
                __func__, l, a1, a2);
@@ -2106,20 +2107,19 @@ uint32_t HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
         return cc;
     }
 
-    /* XXX replace w/ memcpy */
-    for (i = 0; i < l; i++) {
-        uint8_t x = cpu_ldub_primary_ra(env, a2 + i, ra);
-        cpu_stb_secondary_ra(env, a1 + i, x, ra);
-    }
-
+    /* TODO: Access key handling */
+    srca = access_prepare(env, a2, l, MMU_DATA_LOAD, MMU_PRIMARY_IDX, ra);
+    desta = access_prepare(env, a1, l, MMU_DATA_STORE, MMU_SECONDARY_IDX, ra);
+    access_memmove(env, &desta, &srca, ra);
     return cc;
 }
 
 uint32_t HELPER(mvcp)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
 {
     const uint8_t psw_as = (env->psw.mask & PSW_MASK_ASC) >> PSW_SHIFT_ASC;
+    S390Access srca, desta;
     uintptr_t ra = GETPC();
-    int cc = 0, i;
+    int cc = 0;
 
     HELPER_LOG("%s: %16" PRIx64 " %16" PRIx64 " %16" PRIx64 "\n",
                __func__, l, a1, a2);
@@ -2138,12 +2138,10 @@ uint32_t HELPER(mvcp)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
         return cc;
     }
 
-    /* XXX replace w/ memcpy */
-    for (i = 0; i < l; i++) {
-        uint8_t x = cpu_ldub_secondary_ra(env, a2 + i, ra);
-        cpu_stb_primary_ra(env, a1 + i, x, ra);
-    }
-
+    /* TODO: Access key handling */
+    srca = access_prepare(env, a2, l, MMU_DATA_LOAD, MMU_SECONDARY_IDX, ra);
+    desta = access_prepare(env, a1, l, MMU_DATA_STORE, MMU_PRIMARY_IDX, ra);
+    access_memmove(env, &desta, &srca, ra);
     return cc;
 }
 
-- 
2.20.1

[Qemu-devel] [PULL 19/34] s390x/tcg: MVC: Fault-safe handling on destructive overlaps

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

The last remaining bit for MVC is handling destructive overlaps in a
fault-safe way.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 6b85f44e2251..abb9d4d70c58 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -432,8 +432,9 @@ static uint32_t do_helper_mvc(CPUS390XState *env, uint32_t l, uint64_t dest,
         access_memmove(env, &desta, &srca, ra);
     } else {
         for (i = 0; i < l; i++) {
-            uint8_t x = cpu_ldub_data_ra(env, src + i, ra);
-            cpu_stb_data_ra(env, dest + i, x, ra);
+            uint8_t byte = access_get_byte(env, &srca, i, ra);
+
+            access_set_byte(env, &desta, i, byte, ra);
         }
     }
 
-- 
2.20.1

[Qemu-devel] [PULL 20/34] s390x/tcg: MVCLU: Fault-safe handling

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

The last remaining bit is padding with two bytes.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index abb9d4d70c58..853b9557cf26 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -919,15 +919,17 @@ static inline uint32_t do_mvcl(CPUS390XState *env,
         access_memset(env, &desta, pad, ra);
         *dest = wrap_address(env, *dest + len);
     } else {
+        desta = access_prepare(env, *dest, len, MMU_DATA_STORE, mmu_idx, ra);
+
         /* The remaining length selects the padding byte. */
         for (i = 0; i < len; (*destlen)--, i++) {
             if (*destlen & 1) {
-                cpu_stb_data_ra(env, *dest, pad, ra);
+                access_set_byte(env, &desta, i, pad, ra);
             } else {
-                cpu_stb_data_ra(env, *dest, pad >> 8, ra);
+                access_set_byte(env, &desta, i, pad >> 8, ra);
             }
-            *dest = wrap_address(env, *dest + 1);
         }
+        *dest = wrap_address(env, *dest + len);
     }
 
     return *destlen ? 3 : cc;
-- 
2.20.1

[Qemu-devel] [PULL 21/34] s390x/tcg: OC: Fault-safe handling

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

We can process a maximum of 256 bytes, crossing two pages.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 853b9557cf26..0574c31d9a03 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -383,17 +383,26 @@ uint32_t HELPER(xc)(CPUS390XState *env, uint32_t l, uint64_t dest,
 static uint32_t do_helper_oc(CPUS390XState *env, uint32_t l, uint64_t dest,
                              uint64_t src, uintptr_t ra)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
+    S390Access srca1, srca2, desta;
     uint32_t i;
     uint8_t c = 0;
 
     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",
                __func__, l, dest, src);
 
-    for (i = 0; i <= l; i++) {
-        uint8_t x = cpu_ldub_data_ra(env, src + i, ra);
-        x |= cpu_ldub_data_ra(env, dest + i, ra);
+    /* OC always processes one more byte than specified - maximum is 256 */
+    l++;
+
+    srca1 = access_prepare(env, src, l, MMU_DATA_LOAD, mmu_idx, ra);
+    srca2 = access_prepare(env, dest, l, MMU_DATA_LOAD, mmu_idx, ra);
+    desta = access_prepare(env, dest, l, MMU_DATA_STORE, mmu_idx, ra);
+    for (i = 0; i < l; i++) {
+        const uint8_t x = access_get_byte(env, &srca1, i, ra) |
+                          access_get_byte(env, &srca2, i, ra);
+
         c |= x;
-        cpu_stb_data_ra(env, dest + i, x, ra);
+        access_set_byte(env, &desta, i, x, ra);
     }
     return c != 0;
 }
-- 
2.20.1

[Qemu-devel] [PULL 22/34] s390x/tcg: XC: Fault-safe handling

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

We can process a maximum of 256 bytes, crossing two pages. While at it,
increment the length once.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 0574c31d9a03..a2118a82e3ca 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -349,14 +349,19 @@ static uint32_t do_helper_xc(CPUS390XState *env, uint32_t l, uint64_t dest,
                              uint64_t src, uintptr_t ra)
 {
     const int mmu_idx = cpu_mmu_index(env, false);
-    S390Access desta;
+    S390Access srca1, srca2, desta;
     uint32_t i;
     uint8_t c = 0;
 
     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",
                __func__, l, dest, src);
 
-    desta = access_prepare(env, dest, l + 1, MMU_DATA_STORE, mmu_idx, ra);
+    /* XC always processes one more byte than specified - maximum is 256 */
+    l++;
+
+    srca1 = access_prepare(env, src, l, MMU_DATA_LOAD, mmu_idx, ra);
+    srca2 = access_prepare(env, dest, l, MMU_DATA_LOAD, mmu_idx, ra);
+    desta = access_prepare(env, dest, l, MMU_DATA_STORE, mmu_idx, ra);
 
     /* xor with itself is the same as memset(0) */
     if (src == dest) {
@@ -364,11 +369,12 @@ static uint32_t do_helper_xc(CPUS390XState *env, uint32_t l, uint64_t dest,
         return 0;
     }
 
-    for (i = 0; i <= l; i++) {
-        uint8_t x = cpu_ldub_data_ra(env, src + i, ra);
-        x ^= cpu_ldub_data_ra(env, dest + i, ra);
+    for (i = 0; i < l; i++) {
+        const uint8_t x = access_get_byte(env, &srca1, i, ra) ^
+                          access_get_byte(env, &srca2, i, ra);
+
         c |= x;
-        cpu_stb_data_ra(env, dest + i, x, ra);
+        access_set_byte(env, &desta, i, x, ra);
     }
     return c != 0;
 }
-- 
2.20.1

[Qemu-devel] [PULL 23/34] s390x/tcg: NC: Fault-safe handling

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

We can process a maximum of 256 bytes, crossing two pages.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index a2118a82e3ca..20fc17d44de0 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -323,17 +323,26 @@ static int mmu_idx_from_as(uint8_t as)
 static uint32_t do_helper_nc(CPUS390XState *env, uint32_t l, uint64_t dest,
                              uint64_t src, uintptr_t ra)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
+    S390Access srca1, srca2, desta;
     uint32_t i;
     uint8_t c = 0;
 
     HELPER_LOG("%s l %d dest %" PRIx64 " src %" PRIx64 "\n",
                __func__, l, dest, src);
 
-    for (i = 0; i <= l; i++) {
-        uint8_t x = cpu_ldub_data_ra(env, src + i, ra);
-        x &= cpu_ldub_data_ra(env, dest + i, ra);
+    /* NC always processes one more byte than specified - maximum is 256 */
+    l++;
+
+    srca1 = access_prepare(env, src, l, MMU_DATA_LOAD, mmu_idx, ra);
+    srca2 = access_prepare(env, dest, l, MMU_DATA_LOAD, mmu_idx, ra);
+    desta = access_prepare(env, dest, l, MMU_DATA_STORE, mmu_idx, ra);
+    for (i = 0; i < l; i++) {
+        const uint8_t x = access_get_byte(env, &srca1, i, ra) &
+                          access_get_byte(env, &srca2, i, ra);
+
         c |= x;
-        cpu_stb_data_ra(env, dest + i, x, ra);
+        access_set_byte(env, &desta, i, x, ra);
     }
     return c != 0;
 }
-- 
2.20.1

[Qemu-devel] [PULL 24/34] s390x/tcg: MVCIN: Fault-safe handling

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

We can process a maximum of 256 bytes, crossing two pages. Calculate the
accessed range upfront - src is accessed right-to-left.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 20fc17d44de0..4f46d0be90b3 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -473,12 +473,21 @@ void HELPER(mvc)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
 /* move inverse  */
 void HELPER(mvcin)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
+    S390Access srca, desta;
     uintptr_t ra = GETPC();
     int i;
 
-    for (i = 0; i <= l; i++) {
-        uint8_t v = cpu_ldub_data_ra(env, src - i, ra);
-        cpu_stb_data_ra(env, dest + i, v, ra);
+    /* MVCIN always copies one more byte than specified - maximum is 256 */
+    l++;
+
+    src = wrap_address(env, src - l + 1);
+    srca = access_prepare(env, src, l, MMU_DATA_LOAD, mmu_idx, ra);
+    desta = access_prepare(env, dest, l, MMU_DATA_STORE, mmu_idx, ra);
+    for (i = 0; i < l; i++) {
+        const uint8_t x = access_get_byte(env, &srca, l - i - 1, ra);
+
+        access_set_byte(env, &desta, i, x, ra);
     }
 }
 
-- 
2.20.1

[Qemu-devel] [PULL 25/34] s390x/tcg: MVN: Fault-safe handling

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

We can process a maximum of 256 bytes, crossing two pages.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 4f46d0be90b3..fbf65ac42bd2 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -494,13 +494,22 @@ void HELPER(mvcin)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
 /* move numerics  */
 void HELPER(mvn)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
+    S390Access srca1, srca2, desta;
     uintptr_t ra = GETPC();
     int i;
 
-    for (i = 0; i <= l; i++) {
-        uint8_t v = cpu_ldub_data_ra(env, dest + i, ra) & 0xf0;
-        v |= cpu_ldub_data_ra(env, src + i, ra) & 0x0f;
-        cpu_stb_data_ra(env, dest + i, v, ra);
+    /* MVN always copies one more byte than specified - maximum is 256 */
+    l++;
+
+    srca1 = access_prepare(env, src, l, MMU_DATA_LOAD, mmu_idx, ra);
+    srca2 = access_prepare(env, dest, l, MMU_DATA_LOAD, mmu_idx, ra);
+    desta = access_prepare(env, dest, l, MMU_DATA_STORE, mmu_idx, ra);
+    for (i = 0; i < l; i++) {
+        const uint8_t x = (access_get_byte(env, &srca1, i, ra) & 0x0f) |
+                          (access_get_byte(env, &srca2, i, ra) & 0xf0);
+
+        access_set_byte(env, &desta, i, x, ra);
     }
 }
 
-- 
2.20.1

[Qemu-devel] [PULL 26/34] s390x/tcg: MVZ: Fault-safe handling

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

We can process a maximum of 256 bytes, crossing two pages.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index fbf65ac42bd2..c836b69fcc12 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -547,13 +547,22 @@ void HELPER(mvo)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
 /* move zones  */
 void HELPER(mvz)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
+    S390Access srca1, srca2, desta;
     uintptr_t ra = GETPC();
     int i;
 
-    for (i = 0; i <= l; i++) {
-        uint8_t b = cpu_ldub_data_ra(env, dest + i, ra) & 0x0f;
-        b |= cpu_ldub_data_ra(env, src + i, ra) & 0xf0;
-        cpu_stb_data_ra(env, dest + i, b, ra);
+    /* MVZ always copies one more byte than specified - maximum is 256 */
+    l++;
+
+    srca1 = access_prepare(env, src, l, MMU_DATA_LOAD, mmu_idx, ra);
+    srca2 = access_prepare(env, dest, l, MMU_DATA_LOAD, mmu_idx, ra);
+    desta = access_prepare(env, dest, l, MMU_DATA_STORE, mmu_idx, ra);
+    for (i = 0; i < l; i++) {
+        const uint8_t x = (access_get_byte(env, &srca1, i, ra) & 0xf0) |
+                          (access_get_byte(env, &srca2, i, ra) & 0x0f);
+
+        access_set_byte(env, &desta, i, x, ra);
     }
 }
 
-- 
2.20.1

[Qemu-devel] [PULL 27/34] s390x/tcg: MVST: Fault-safe handling

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Access at most single pages and document why. Using the access helpers
might over-indicate watchpoints within the same page, I guess we can
live with that.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index c836b69fcc12..671e917dc1f8 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -860,23 +860,33 @@ uint32_t HELPER(mvpg)(CPUS390XState *env, uint64_t r0, uint64_t r1, uint64_t r2)
 /* string copy */
 uint32_t HELPER(mvst)(CPUS390XState *env, uint32_t r1, uint32_t r2)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
     const uint64_t d = get_address(env, r1);
     const uint64_t s = get_address(env, r2);
     const uint8_t c = env->regs[0];
+    const int len = MIN(-(d | TARGET_PAGE_MASK), -(s | TARGET_PAGE_MASK));
+    S390Access srca, desta;
     uintptr_t ra = GETPC();
-    uint32_t len;
+    int i;
 
     if (env->regs[0] & 0xffffff00ull) {
         s390_program_interrupt(env, PGM_SPECIFICATION, ILEN_AUTO, ra);
     }
 
-    /* Lest we fail to service interrupts in a timely manner, limit the
-       amount of work we're willing to do.  For now, let's cap at 8k.  */
-    for (len = 0; len < 0x2000; ++len) {
-        uint8_t v = cpu_ldub_data_ra(env, s + len, ra);
-        cpu_stb_data_ra(env, d + len, v, ra);
+    /*
+     * Our access should not exceed single pages, as we must not report access
+     * exceptions exceeding the actually copied range (which we don't know at
+     * this point). We might over-indicate watchpoints within the pages
+     * (if we ever care, we have to limit processing to a single byte).
+     */
+    srca = access_prepare(env, s, len, MMU_DATA_LOAD, mmu_idx, ra);
+    desta = access_prepare(env, d, len, MMU_DATA_STORE, mmu_idx, ra);
+    for (i = 0; i < len; i++) {
+        const uint8_t v = access_get_byte(env, &srca, i, ra);
+
+        access_set_byte(env, &desta, i, v, ra);
         if (v == c) {
-            set_address_zero(env, r1, d + len);
+            set_address_zero(env, r1, d + i);
             return 1;
         }
     }
-- 
2.20.1

[Qemu-devel] [PULL 28/34] s390x/tcg: MVO: Fault-safe handling

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Each operand can have a maximum length of 16. Make sure to prepare all
reads/writes before writing.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 target/s390x/mem_helper.c | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index 671e917dc1f8..504542002033 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -516,31 +516,34 @@ void HELPER(mvn)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
 /* move with offset  */
 void HELPER(mvo)(CPUS390XState *env, uint32_t l, uint64_t dest, uint64_t src)
 {
+    const int mmu_idx = cpu_mmu_index(env, false);
+    /* MVO always processes one more byte than specified - maximum is 16 */
+    const int len_dest = (l >> 4) + 1;
+    const int len_src = (l & 0xf) + 1;
     uintptr_t ra = GETPC();
-    int len_dest = l >> 4;
-    int len_src = l & 0xf;
     uint8_t byte_dest, byte_src;
-    int i;
+    S390Access srca, desta;
+    int i, j;
 
-    src += len_src;
-    dest += len_dest;
+    srca = access_prepare(env, src, len_src, MMU_DATA_LOAD, mmu_idx, ra);
+    desta = access_prepare(env, dest, len_dest, MMU_DATA_STORE, mmu_idx, ra);
 
     /* Handle rightmost byte */
-    byte_src = cpu_ldub_data_ra(env, src, ra);
-    byte_dest = cpu_ldub_data_ra(env, dest, ra);
+    byte_dest = cpu_ldub_data_ra(env, dest + len_dest - 1, ra);
+    byte_src = access_get_byte(env, &srca, len_src - 1, ra);
     byte_dest = (byte_dest & 0x0f) | (byte_src << 4);
-    cpu_stb_data_ra(env, dest, byte_dest, ra);
+    access_set_byte(env, &desta, len_dest - 1, byte_dest, ra);
 
     /* Process remaining bytes from right to left */
-    for (i = 1; i <= len_dest; i++) {
+    for (i = len_dest - 2, j = len_src - 2; i >= 0; i--, j--) {
         byte_dest = byte_src >> 4;
-        if (len_src - i >= 0) {
-            byte_src = cpu_ldub_data_ra(env, src - i, ra);
+        if (j >= 0) {
+            byte_src = access_get_byte(env, &srca, j, ra);
         } else {
             byte_src = 0;
         }
         byte_dest |= byte_src << 4;
-        cpu_stb_data_ra(env, dest - i, byte_dest, ra);
+        access_set_byte(env, &desta, i, byte_dest, ra);
     }
 }
 
-- 
2.20.1

[Qemu-devel] [PULL 29/34] tests/tcg: target/s390x: Test MVO

[Cornelia Huck]

From: David Hildenbrand <david@redhat.com>

Let's add the simple test based on the example from the PoP.

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 tests/tcg/s390x/Makefile.target |  1 +
 tests/tcg/s390x/mvo.c           | 25 +++++++++++++++++++++++++
 2 files changed, 26 insertions(+)
 create mode 100644 tests/tcg/s390x/mvo.c

diff --git a/tests/tcg/s390x/Makefile.target b/tests/tcg/s390x/Makefile.target
index 151dc075aa78..6a3bfa8b29f0 100644
--- a/tests/tcg/s390x/Makefile.target
+++ b/tests/tcg/s390x/Makefile.target
@@ -6,3 +6,4 @@ TESTS+=ipm
 TESTS+=exrl-trt
 TESTS+=exrl-trtr
 TESTS+=pack
+TESTS+=mvo
diff --git a/tests/tcg/s390x/mvo.c b/tests/tcg/s390x/mvo.c
new file mode 100644
index 000000000000..5546fe2a9767
--- /dev/null
+++ b/tests/tcg/s390x/mvo.c
@@ -0,0 +1,25 @@
+#include <stdint.h>
+#include <stdio.h>
+
+int main(void)
+{
+    uint8_t dest[6] = {0xff, 0x77, 0x88, 0x99, 0x0c, 0xff};
+    uint8_t src[5] = {0xee, 0x12, 0x34, 0x56, 0xee};
+    uint8_t expected[6] = {0xff, 0x01, 0x23, 0x45, 0x6c, 0xff};
+    int i;
+
+    asm volatile (
+        "    mvo 0(4,%[dest]),0(3,%[src])\n"
+        :
+        : [dest] "d" (dest + 1),
+          [src] "d" (src + 1)
+        : "memory");
+
+    for (i = 0; i < sizeof(expected); i++) {
+        if (dest[i] != expected[i]) {
+            fprintf(stderr, "bad data\n");
+            return 1;
+        }
+    }
+    return 0;
+}
-- 
2.20.1

[Qemu-devel] [PULL 30/34] pc-bios/s390-ccw: Do not pre-initialize empty array

[Cornelia Huck]

From: Thomas Huth <thuth@redhat.com>

Since commit 339686a358b11a231aa5b6d1424e7a1460d7f277 ("pc-bios/s390-ccw:
zero out bss section"), we are clearing now the BSS in start.S, so there
is no need to pre-initialize the loadparm_str array with zeroes anymore.

Reviewed-by: Cornelia Huck <cohuck@redhat.com>
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
 pc-bios/s390-ccw/main.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pc-bios/s390-ccw/main.c b/pc-bios/s390-ccw/main.c
index a69c73349e8f..a21b38628075 100644
--- a/pc-bios/s390-ccw/main.c
+++ b/pc-bios/s390-ccw/main.c
@@ -17,7 +17,7 @@
 
 char stack[PAGE_SIZE * 8] __attribute__((__aligned__(PAGE_SIZE)));
 static SubChannelId blk_schid = { .one = 1 };
-static char loadparm_str[LOADPARM_LEN + 1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+static char loadparm_str[LOADPARM_LEN + 1];
 QemuIplParameters qipl;
 IplParameterBlock iplb __attribute__((__aligned__(PAGE_SIZE)));
 static bool have_iplb;
-- 
2.20.1

[Qemu-devel] [PULL 31/34] pc-bios/s390-ccw/net: fix a possible memory leak in get_uuid()

[Cornelia Huck]

From: Yifan Luo <luoyifan@cmss.chinamobile.com>

There is a possible memory leak in get_uuid(). Should free allocated mem
before
return NULL.

Signed-off-by: Yifan Luo <luoyifan@cmss.chinamobile.com>
Message-Id: <02cf01d55267$86cf2850$946d78f0$@cmss.chinamobile.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Reviewed-by: Cornelia Huck <cohuck@redhat.com>
Signed-off-by: Thomas Huth <thuth@redhat.com>
---
 pc-bios/s390-ccw/netmain.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pc-bios/s390-ccw/netmain.c b/pc-bios/s390-ccw/netmain.c
index f3542cb2cf11..f2dcc01e2725 100644
--- a/pc-bios/s390-ccw/netmain.c
+++ b/pc-bios/s390-ccw/netmain.c
@@ -269,6 +269,7 @@ static const char *get_uuid(void)
                  : "d" (r0), "d" (r1), [addr] "a" (buf)
                  : "cc", "memory");
     if (cc) {
+        free(mem);
         return NULL;
     }
 
-- 
2.20.1

[Qemu-devel] [PULL 32/34] pc-bios/s390-ccw: Rebuild the s390-netboot.img firmware image

[Cornelia Huck]

From: Thomas Huth <thuth@redhat.com>

The new image now contains the "pc-bios/s390-ccw/net: fix a possible
memory leak in get_uuid()" patch.

Signed-off-by: Thomas Huth <thuth@redhat.com>
---
 pc-bios/s390-netboot.img | Bin 67232 -> 67232 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/pc-bios/s390-netboot.img b/pc-bios/s390-netboot.img
index aa90fbccb142470924ad5f0de5a4c6337916c63a..b984ad0da08f1401978b173d44e935d5563dde70 100644
GIT binary patch
literal 67232
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

literal 67232
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
SpP4OG<GYBD&P*uR=lvf*Csc(1

-- 
2.20.1

[Qemu-devel] [PULL 33/34] s390x/kvm: Officially require at least kernel 3.15

[Cornelia Huck]

From: Thomas Huth <thuth@redhat.com>

Since QEMU v2.10, the KVM acceleration does not work on older kernels
anymore since the code accidentally requires the KVM_CAP_DEVICE_CTRL
capability now - it should have been optional instead.
Instead of fixing the bug, we asked in the ChangeLog of QEMU 2.11 - 3.0
that people should speak up if they still need support of QEMU running
with KVM on older kernels, but seems like nobody really complained.
Thus let's make this official now and turn it into a proper error
message, telling the users to use at least kernel 3.15 now.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-Id: <20190913091443.27565-1-thuth@redhat.com>
Reviewed-by: David Hildenbrand <david@redhat.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
---
 hw/intc/s390_flic_kvm.c | 6 ------
 hw/intc/trace-events    | 1 -
 target/s390x/kvm.c      | 7 +++++++
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/hw/intc/s390_flic_kvm.c b/hw/intc/s390_flic_kvm.c
index 819aa5e198b7..cedccba8a9c7 100644
--- a/hw/intc/s390_flic_kvm.c
+++ b/hw/intc/s390_flic_kvm.c
@@ -589,12 +589,6 @@ static void kvm_s390_flic_realize(DeviceState *dev, Error **errp)
         goto fail;
     }
     flic_state->fd = -1;
-    if (!kvm_check_extension(kvm_state, KVM_CAP_DEVICE_CTRL)) {
-        error_setg_errno(&errp_local, errno, "KVM is missing capability"
-                         " KVM_CAP_DEVICE_CTRL");
-        trace_flic_no_device_api(errno);
-        goto fail;
-    }
 
     cd.type = KVM_DEV_TYPE_FLIC;
     ret = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &cd);
diff --git a/hw/intc/trace-events b/hw/intc/trace-events
index 90c9d07c1a66..719f46b51628 100644
--- a/hw/intc/trace-events
+++ b/hw/intc/trace-events
@@ -75,7 +75,6 @@ xics_ics_simple_eoi(int nr) "ics_eoi: irq 0x%x"
 
 # s390_flic_kvm.c
 flic_create_device(int err) "flic: create device failed %d"
-flic_no_device_api(int err) "flic: no Device Contral API support %d"
 flic_reset_failed(int err) "flic: reset failed %d"
 
 # s390_flic.c
diff --git a/target/s390x/kvm.c b/target/s390x/kvm.c
index cea71ac7c3dd..97a662ad0ebf 100644
--- a/target/s390x/kvm.c
+++ b/target/s390x/kvm.c
@@ -316,6 +316,13 @@ int kvm_arch_init(MachineState *ms, KVMState *s)
     MachineClass *mc = MACHINE_GET_CLASS(ms);
 
     mc->default_cpu_type = S390_CPU_TYPE_NAME("host");
+
+    if (!kvm_check_extension(kvm_state, KVM_CAP_DEVICE_CTRL)) {
+        error_report("KVM is missing capability KVM_CAP_DEVICE_CTRL - "
+                     "please use kernel 3.15 or newer");
+        return -1;
+    }
+
     cap_sync_regs = kvm_check_extension(s, KVM_CAP_SYNC_REGS);
     cap_async_pf = kvm_check_extension(s, KVM_CAP_ASYNC_PF);
     cap_mem_op = kvm_check_extension(s, KVM_CAP_S390_MEM_OP);
-- 
2.20.1

[Qemu-devel] [PULL 34/34] s390x/cpumodel: Add the z15 name to the description of gen15a

[Cornelia Huck]

From: Christian Borntraeger <borntraeger@de.ibm.com>

We now know that gen15a is called z15.

Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Message-Id: <20190918144214.229936-1-borntraeger@de.ibm.com>
Reviewed-by: David Hildenbrand <david@redhat.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>
---
 target/s390x/cpu_models.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/target/s390x/cpu_models.c b/target/s390x/cpu_models.c
index 1d16d7d5e794..009afc38b92d 100644
--- a/target/s390x/cpu_models.c
+++ b/target/s390x/cpu_models.c
@@ -84,7 +84,7 @@ static S390CPUDef s390_cpu_defs[] = {
     CPUDEF_INIT(0x3906, 14, 1, 47, 0x08000000U, "z14", "IBM z14 GA1"),
     CPUDEF_INIT(0x3906, 14, 2, 47, 0x08000000U, "z14.2", "IBM z14 GA2"),
     CPUDEF_INIT(0x3907, 14, 1, 47, 0x08000000U, "z14ZR1", "IBM z14 Model ZR1 GA1"),
-    CPUDEF_INIT(0x8561, 15, 1, 47, 0x08000000U, "gen15a", "IBM 8561 GA1"),
+    CPUDEF_INIT(0x8561, 15, 1, 47, 0x08000000U, "gen15a", "IBM z15 GA1"),
     CPUDEF_INIT(0x8562, 15, 1, 47, 0x08000000U, "gen15b", "IBM 8562 GA1"),
 };
 
-- 
2.20.1

Re: [PULL 00/34] s390x update

[Peter Maydell]

On Thu, 19 Sep 2019 at 13:41, Cornelia Huck <cohuck@redhat.com> wrote:
>
> The following changes since commit f8c3db33a5e863291182f8862ddf81618a7c6194:
>
>   target/sparc: Switch to do_transaction_failed() hook (2019-09-17 12:01:00 +0100)
>
> are available in the Git repository at:
>
>   https://github.com/cohuck/qemu tags/s390x-20190919
>
> for you to fetch changes up to 37105adebeb28e60da3cb1ef82231d7ed8d23589:
>
>   Merge tag 'tags/s390-ccw-bios-2019-09-18' into s390-next-staging (2019-09-19 12:04:01 +0200)
>
> ----------------------------------------------------------------
> - bugfixes in tcg and the ccw bios
> - gen15a is called z15
> - officially require a 3.15 kernel or later for kvm
>
> ----------------------------------------------------------------

Hi -- I'm afraid this pullreq results in new warnings from
the runtime-sanitizer build when 'make check' is run:
MALLOC_PERTURB_=${MALLOC_PERTURB_:-$(( ${RANDOM:-0} % 255 + 1))}
QTEST_QEMU_BINARY=s390x-softmmu/qemu-system-s390x
QTEST_QEMU_IMG=qemu-img tests
/boot-serial-test -m=quick -k --tap < /dev/null |
./scripts/tap-driver.pl --test-name="boot-serial-test"
/home/petmay01/linaro/qemu-for-merges/target/s390x/mem_helper.c:293:17:
runtime error: null pointer passed as argument 1, which is declared to
never be null
/usr/include/string.h:47:14: note: nonnull attribute specified here
/home/petmay01/linaro/qemu-for-merges/target/s390x/mem_helper.c:293:32:
runtime error: null pointer passed as argument 2, which is declared to
never be null

(and the same warnings for a few other tests).

Looks like you sometimes can pass NULL pointers to the source
and destination of memmove(). This isn't permitted by the
standard even in the case where the size argument is zero.

thanks
-- PMM

Re: [PULL 00/34] s390x update

[Cornelia Huck]

On Fri, 20 Sep 2019 11:45:18 +0100
Peter Maydell <peter.maydell@linaro.org> wrote:

> On Thu, 19 Sep 2019 at 13:41, Cornelia Huck <cohuck@redhat.com> wrote:
> >
> > The following changes since commit f8c3db33a5e863291182f8862ddf81618a7c6194:
> >
> >   target/sparc: Switch to do_transaction_failed() hook (2019-09-17 12:01:00 +0100)
> >
> > are available in the Git repository at:
> >
> >   https://github.com/cohuck/qemu tags/s390x-20190919
> >
> > for you to fetch changes up to 37105adebeb28e60da3cb1ef82231d7ed8d23589:
> >
> >   Merge tag 'tags/s390-ccw-bios-2019-09-18' into s390-next-staging (2019-09-19 12:04:01 +0200)
> >
> > ----------------------------------------------------------------
> > - bugfixes in tcg and the ccw bios
> > - gen15a is called z15
> > - officially require a 3.15 kernel or later for kvm
> >
> > ----------------------------------------------------------------  
> 
> Hi -- I'm afraid this pullreq results in new warnings from
> the runtime-sanitizer build when 'make check' is run:
> MALLOC_PERTURB_=${MALLOC_PERTURB_:-$(( ${RANDOM:-0} % 255 + 1))}
> QTEST_QEMU_BINARY=s390x-softmmu/qemu-system-s390x
> QTEST_QEMU_IMG=qemu-img tests
> /boot-serial-test -m=quick -k --tap < /dev/null |
> ./scripts/tap-driver.pl --test-name="boot-serial-test"
> /home/petmay01/linaro/qemu-for-merges/target/s390x/mem_helper.c:293:17:
> runtime error: null pointer passed as argument 1, which is declared to
> never be null
> /usr/include/string.h:47:14: note: nonnull attribute specified here
> /home/petmay01/linaro/qemu-for-merges/target/s390x/mem_helper.c:293:32:
> runtime error: null pointer passed as argument 2, which is declared to
> never be null
> 
> (and the same warnings for a few other tests).
> 
> Looks like you sometimes can pass NULL pointers to the source
> and destination of memmove(). This isn't permitted by the
> standard even in the case where the size argument is zero.
> 
> thanks
> -- PMM

David, can you take a look?

Re: [PULL 00/34] s390x update

[David Hildenbrand]

On 20.09.19 13:00, Cornelia Huck wrote:
> On Fri, 20 Sep 2019 11:45:18 +0100
> Peter Maydell <peter.maydell@linaro.org> wrote:
> 
>> On Thu, 19 Sep 2019 at 13:41, Cornelia Huck <cohuck@redhat.com> wrote:
>>>
>>> The following changes since commit f8c3db33a5e863291182f8862ddf81618a7c6194:
>>>
>>>   target/sparc: Switch to do_transaction_failed() hook (2019-09-17 12:01:00 +0100)
>>>
>>> are available in the Git repository at:
>>>
>>>   https://github.com/cohuck/qemu tags/s390x-20190919
>>>
>>> for you to fetch changes up to 37105adebeb28e60da3cb1ef82231d7ed8d23589:
>>>
>>>   Merge tag 'tags/s390-ccw-bios-2019-09-18' into s390-next-staging (2019-09-19 12:04:01 +0200)
>>>
>>> ----------------------------------------------------------------
>>> - bugfixes in tcg and the ccw bios
>>> - gen15a is called z15
>>> - officially require a 3.15 kernel or later for kvm
>>>
>>> ----------------------------------------------------------------  
>>
>> Hi -- I'm afraid this pullreq results in new warnings from
>> the runtime-sanitizer build when 'make check' is run:
>> MALLOC_PERTURB_=${MALLOC_PERTURB_:-$(( ${RANDOM:-0} % 255 + 1))}
>> QTEST_QEMU_BINARY=s390x-softmmu/qemu-system-s390x
>> QTEST_QEMU_IMG=qemu-img tests
>> /boot-serial-test -m=quick -k --tap < /dev/null |
>> ./scripts/tap-driver.pl --test-name="boot-serial-test"
>> /home/petmay01/linaro/qemu-for-merges/target/s390x/mem_helper.c:293:17:
>> runtime error: null pointer passed as argument 1, which is declared to
>> never be null
>> /usr/include/string.h:47:14: note: nonnull attribute specified here
>> /home/petmay01/linaro/qemu-for-merges/target/s390x/mem_helper.c:293:32:
>> runtime error: null pointer passed as argument 2, which is declared to
>> never be null
>>
>> (and the same warnings for a few other tests).
>>
>> Looks like you sometimes can pass NULL pointers to the source
>> and destination of memmove(). This isn't permitted by the
>> standard even in the case where the size argument is zero.
>>
>> thanks
>> -- PMM
> 
> David, can you take a look?
> 

I would have assumed these pointers are ignored in case the length is
zero, too (the only way this can happen). Easy to fix.

-- 

Thanks,

David / dhildenb

Re: [PULL 00/34] s390x update

[David Hildenbrand]

On 20.09.19 13:51, David Hildenbrand wrote:
> On 20.09.19 13:00, Cornelia Huck wrote:
>> On Fri, 20 Sep 2019 11:45:18 +0100
>> Peter Maydell <peter.maydell@linaro.org> wrote:
>>
>>> On Thu, 19 Sep 2019 at 13:41, Cornelia Huck <cohuck@redhat.com> wrote:
>>>>
>>>> The following changes since commit f8c3db33a5e863291182f8862ddf81618a7c6194:
>>>>
>>>>   target/sparc: Switch to do_transaction_failed() hook (2019-09-17 12:01:00 +0100)
>>>>
>>>> are available in the Git repository at:
>>>>
>>>>   https://github.com/cohuck/qemu tags/s390x-20190919
>>>>
>>>> for you to fetch changes up to 37105adebeb28e60da3cb1ef82231d7ed8d23589:
>>>>
>>>>   Merge tag 'tags/s390-ccw-bios-2019-09-18' into s390-next-staging (2019-09-19 12:04:01 +0200)
>>>>
>>>> ----------------------------------------------------------------
>>>> - bugfixes in tcg and the ccw bios
>>>> - gen15a is called z15
>>>> - officially require a 3.15 kernel or later for kvm
>>>>
>>>> ----------------------------------------------------------------  
>>>
>>> Hi -- I'm afraid this pullreq results in new warnings from
>>> the runtime-sanitizer build when 'make check' is run:
>>> MALLOC_PERTURB_=${MALLOC_PERTURB_:-$(( ${RANDOM:-0} % 255 + 1))}
>>> QTEST_QEMU_BINARY=s390x-softmmu/qemu-system-s390x
>>> QTEST_QEMU_IMG=qemu-img tests
>>> /boot-serial-test -m=quick -k --tap < /dev/null |
>>> ./scripts/tap-driver.pl --test-name="boot-serial-test"
>>> /home/petmay01/linaro/qemu-for-merges/target/s390x/mem_helper.c:293:17:
>>> runtime error: null pointer passed as argument 1, which is declared to
>>> never be null
>>> /usr/include/string.h:47:14: note: nonnull attribute specified here
>>> /home/petmay01/linaro/qemu-for-merges/target/s390x/mem_helper.c:293:32:
>>> runtime error: null pointer passed as argument 2, which is declared to
>>> never be null
>>>
>>> (and the same warnings for a few other tests).
>>>
>>> Looks like you sometimes can pass NULL pointers to the source
>>> and destination of memmove(). This isn't permitted by the
>>> standard even in the case where the size argument is zero.
>>>
>>> thanks
>>> -- PMM
>>
>> David, can you take a look?
>>
> 
> I would have assumed these pointers are ignored in case the length is
> zero, too (the only way this can happen). Easy to fix.
> 


diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
index e50cec9263..ef8e0c20a7 100644
--- a/target/s390x/mem_helper.c
+++ b/target/s390x/mem_helper.c
@@ -290,17 +290,23 @@ static void access_memmove(CPUS390XState *env, S390Access *desta,
 
     if (srca->size1 == desta->size1) {
         memmove(desta->haddr1, srca->haddr1, srca->size1);
-        memmove(desta->haddr2, srca->haddr2, srca->size2);
+        if (likely(srca->size2)) {
+            memmove(desta->haddr2, srca->haddr2, srca->size2);
+        }
     } else if (srca->size1 < desta->size1) {
         diff = desta->size1 - srca->size1;
         memmove(desta->haddr1, srca->haddr1, srca->size1);
         memmove(desta->haddr1 + srca->size1, srca->haddr2, diff);
-        memmove(desta->haddr2, srca->haddr2 + diff, desta->size2);
+        if (likely(desta->size2)) {
+            memmove(desta->haddr2, srca->haddr2 + diff, desta->size2);
+        }
     } else {
         diff = srca->size1 - desta->size1;
         memmove(desta->haddr1, srca->haddr1, desta->size1);
         memmove(desta->haddr2, srca->haddr1 + desta->size1, diff);
-        memmove(desta->haddr2 + diff, srca->haddr2, srca->size2);
+        if (likely(srca->size2)) {
+            memmove(desta->haddr2 + diff, srca->haddr2, srca->size2);
+        }
     }
 }

For "s390x/tcg: Fault-safe memmove" should do the trick. Will test.

-- 

Thanks,

David / dhildenb

Re: [PULL 00/34] s390x update

[Cornelia Huck]

On Fri, 20 Sep 2019 13:59:12 +0200
David Hildenbrand <david@redhat.com> wrote:

> On 20.09.19 13:51, David Hildenbrand wrote:
> > On 20.09.19 13:00, Cornelia Huck wrote:  
> >> On Fri, 20 Sep 2019 11:45:18 +0100
> >> Peter Maydell <peter.maydell@linaro.org> wrote:
> >>  
> >>> On Thu, 19 Sep 2019 at 13:41, Cornelia Huck <cohuck@redhat.com> wrote:  
> >>>>
> >>>> The following changes since commit f8c3db33a5e863291182f8862ddf81618a7c6194:
> >>>>
> >>>>   target/sparc: Switch to do_transaction_failed() hook (2019-09-17 12:01:00 +0100)
> >>>>
> >>>> are available in the Git repository at:
> >>>>
> >>>>   https://github.com/cohuck/qemu tags/s390x-20190919
> >>>>
> >>>> for you to fetch changes up to 37105adebeb28e60da3cb1ef82231d7ed8d23589:
> >>>>
> >>>>   Merge tag 'tags/s390-ccw-bios-2019-09-18' into s390-next-staging (2019-09-19 12:04:01 +0200)
> >>>>
> >>>> ----------------------------------------------------------------
> >>>> - bugfixes in tcg and the ccw bios
> >>>> - gen15a is called z15
> >>>> - officially require a 3.15 kernel or later for kvm
> >>>>
> >>>> ----------------------------------------------------------------    
> >>>
> >>> Hi -- I'm afraid this pullreq results in new warnings from
> >>> the runtime-sanitizer build when 'make check' is run:
> >>> MALLOC_PERTURB_=${MALLOC_PERTURB_:-$(( ${RANDOM:-0} % 255 + 1))}
> >>> QTEST_QEMU_BINARY=s390x-softmmu/qemu-system-s390x
> >>> QTEST_QEMU_IMG=qemu-img tests
> >>> /boot-serial-test -m=quick -k --tap < /dev/null |
> >>> ./scripts/tap-driver.pl --test-name="boot-serial-test"
> >>> /home/petmay01/linaro/qemu-for-merges/target/s390x/mem_helper.c:293:17:
> >>> runtime error: null pointer passed as argument 1, which is declared to
> >>> never be null
> >>> /usr/include/string.h:47:14: note: nonnull attribute specified here
> >>> /home/petmay01/linaro/qemu-for-merges/target/s390x/mem_helper.c:293:32:
> >>> runtime error: null pointer passed as argument 2, which is declared to
> >>> never be null
> >>>
> >>> (and the same warnings for a few other tests).
> >>>
> >>> Looks like you sometimes can pass NULL pointers to the source
> >>> and destination of memmove(). This isn't permitted by the
> >>> standard even in the case where the size argument is zero.
> >>>
> >>> thanks
> >>> -- PMM  
> >>
> >> David, can you take a look?
> >>  
> > 
> > I would have assumed these pointers are ignored in case the length is
> > zero, too (the only way this can happen). Easy to fix.
> >   
> 
> 
> diff --git a/target/s390x/mem_helper.c b/target/s390x/mem_helper.c
> index e50cec9263..ef8e0c20a7 100644
> --- a/target/s390x/mem_helper.c
> +++ b/target/s390x/mem_helper.c
> @@ -290,17 +290,23 @@ static void access_memmove(CPUS390XState *env, S390Access *desta,
>  
>      if (srca->size1 == desta->size1) {
>          memmove(desta->haddr1, srca->haddr1, srca->size1);
> -        memmove(desta->haddr2, srca->haddr2, srca->size2);
> +        if (likely(srca->size2)) {
> +            memmove(desta->haddr2, srca->haddr2, srca->size2);
> +        }
>      } else if (srca->size1 < desta->size1) {
>          diff = desta->size1 - srca->size1;
>          memmove(desta->haddr1, srca->haddr1, srca->size1);
>          memmove(desta->haddr1 + srca->size1, srca->haddr2, diff);
> -        memmove(desta->haddr2, srca->haddr2 + diff, desta->size2);
> +        if (likely(desta->size2)) {
> +            memmove(desta->haddr2, srca->haddr2 + diff, desta->size2);
> +        }
>      } else {
>          diff = srca->size1 - desta->size1;
>          memmove(desta->haddr1, srca->haddr1, desta->size1);
>          memmove(desta->haddr2, srca->haddr1 + desta->size1, diff);
> -        memmove(desta->haddr2 + diff, srca->haddr2, srca->size2);
> +        if (likely(srca->size2)) {
> +            memmove(desta->haddr2 + diff, srca->haddr2, srca->size2);
> +        }
>      }
>  }
> 
> For "s390x/tcg: Fault-safe memmove" should do the trick. Will test.

Ok, great.

Peter, FYI: I'll be on vacation for two weeks (starting later today),
so David/Thomas/Christian will probably handle any s390x-related things
including pull requests for that time (I don't think I want to put a v2
together in a hurry...)

Re: [PULL 00/34] s390x update

[Peter Maydell]

On Fri, 20 Sep 2019 at 14:33, Cornelia Huck <cohuck@redhat.com> wrote:
> Peter, FYI: I'll be on vacation for two weeks (starting later today),
> so David/Thomas/Christian will probably handle any s390x-related things
> including pull requests for that time (I don't think I want to put a v2
> together in a hurry...)

No worries; have a good holiday!

-- PMM

Re: [PULL 00/34] s390x update

[David Hildenbrand]

On 20.09.19 15:41, Peter Maydell wrote:
> On Fri, 20 Sep 2019 at 14:33, Cornelia Huck <cohuck@redhat.com> wrote:
>> Peter, FYI: I'll be on vacation for two weeks (starting later today),
>> so David/Thomas/Christian will probably handle any s390x-related things
>> including pull requests for that time (I don't think I want to put a v2
>> together in a hurry...)
> 
> No worries; have a good holiday!
> 
> -- PMM
> 

Peter, I'll send the s390x/tcg bits as a separate pull request directly
to you this time.

Cheers!

-- 

Thanks,

David / dhildenb