Skip to contentSkip to conversation

s390x: STFLE nested interpretation

PATCH Superseded Nina Schoetterl-Glausch 3 participants 11 messages Jan 5, 2024 – Jan 31, 2024

Subsystems (4)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v2 cover s390x: STFLE nested interpretation

v1 -> v2 (range-diff below):
* implement SHA-256 based PRNG
* pick up R-b (thanks Claudio)
* change snippet exit API and implementation (thanks Claudio)
* add stfle-sie to unittests.cfg

Add a test case that tests the interpretation of STFLE performed by a nested guest using a snippet.
Also add some functionality to lib/, namely:
* pseudo random number generation (arch independent)
* exit (optionally with return code) from snippet (s390x)

Nina Schoetterl-Glausch (5):
lib: Add pseudo random functions
s390x: lib: Remove double include
s390x: Add library functions for exiting from snippet
s390x: Use library functions for snippet exit
s390x: Add test for STFLE interpretive execution (format-0)

 Makefile                                |   1 +
 s390x/Makefile                          |   3 +
 lib/s390x/asm/arch_def.h                |  13 ++
 lib/s390x/asm/facility.h                |  10 +-
 lib/rand.h                              |  21 +++
 lib/s390x/sie.h                         |   1 +
 lib/s390x/snippet-guest.h               |  26 ++++
 lib/s390x/{snippet.h => snippet-host.h} |  10 +-
 lib/rand.c                              | 177 ++++++++++++++++++++++++
 lib/s390x/sie.c                         |  32 ++++-
 lib/s390x/snippet-host.c                |  42 ++++++
 lib/s390x/uv.c                          |   2 +-
 s390x/mvpg-sie.c                        |   2 +-
 s390x/pv-diags.c                        |   2 +-
 s390x/pv-icptcode.c                     |   2 +-
 s390x/pv-ipl.c                          |   2 +-
 s390x/sie-dat.c                         |  13 +-
 s390x/snippets/c/sie-dat.c              |  19 +--
 s390x/snippets/c/stfle.c                |  26 ++++
 s390x/spec_ex-sie.c                     |   2 +-
 s390x/stfle-sie.c                       | 134 ++++++++++++++++++
 s390x/uv-host.c                         |   2 +-
 s390x/unittests.cfg                     |   3 +
 23 files changed, 506 insertions(+), 39 deletions(-)
 create mode 100644 lib/rand.h
 create mode 100644 lib/s390x/snippet-guest.h
 rename lib/s390x/{snippet.h => snippet-host.h} (92%)
 create mode 100644 lib/rand.c
 create mode 100644 lib/s390x/snippet-host.c
 create mode 100644 s390x/snippets/c/stfle.c
 create mode 100644 s390x/stfle-sie.c

Range-diff against v1:

1:  40d815f3 < -:  -------- lib: Add pseudo random functions
-:  -------- > 1:  6c869961 lib: Add pseudo random functions
2:  f5284941 ! 2:  77319d3e s390x: lib: Remove double include

@@ Commit message

libcflat.h was included twice.

+ Reviewed-by: Claudio Imbrenda <[email protected]>

## lib/s390x/sie.c ##
3: 303cf927 ! 3: e2c2cad8 s390x: Add library functions for exiting from snippet

    @@ Commit message
         Add this functionality, also add helper functions for the host to check
         for an exit and get or check the value.
         Use diag 0x44 and 0x9c for this.
    -    Add a guest specific snippet header file and rename the host's.
    +    Add a guest specific snippet header file and rename snippet.h to reflect
    +    that it is host specific.
     
         Signed-off-by: Nina Schoetterl-Glausch <[email protected]>
     
    @@ lib/s390x/snippet-host.h: static inline void snippet_setup_guest(struct vm *vm,
      	}
      }
      
    -+bool snippet_check_force_exit(struct vm *vm);
    -+bool snippet_get_force_exit_value(struct vm *vm, uint64_t *value);
    ++bool snippet_is_force_exit(struct vm *vm);
    ++bool snippet_is_force_exit_value(struct vm *vm);
    ++uint64_t snippet_get_force_exit_value(struct vm *vm);
     +void snippet_check_force_exit_value(struct vm *vm, uint64_t exit_exp);
      #endif
     
    @@ lib/s390x/sie.c: void sie_check_validity(struct vm *vm, uint16_t vir_exp)
      
     +bool sie_is_diag_icpt(struct vm *vm, unsigned int diag)
     +{
    -+	uint32_t ipb = vm->sblk->ipb;
    ++	union {
    ++		struct {
    ++			uint64_t     : 16;
    ++			uint64_t ipa : 16;
    ++			uint64_t ipb : 32;
    ++		};
    ++		struct {
    ++			uint64_t          : 16;
    ++			uint64_t opcode   :  8;
    ++			uint64_t r_1      :  4;
    ++			uint64_t r_2      :  4;
    ++			uint64_t r_base   :  4;
    ++			uint64_t displace : 12;
    ++			uint64_t zero     : 16;
    ++		};
    ++	} instr = { .ipa = vm->sblk->ipa, .ipb = vm->sblk->ipb };
     +	uint64_t code;
    -+	uint16_t displace;
    -+	uint8_t base;
    -+	bool ret = true;
     +
    -+	ret = ret && vm->sblk->icptcode == ICPT_INST;
    -+	ret = ret && (vm->sblk->ipa & 0xff00) == 0x8300;
    -+	switch (diag) {
    -+	case 0x44:
    -+	case 0x9c:
    -+		ret = ret && !(ipb & 0xffff);
    -+		ipb >>= 16;
    -+		displace = ipb & 0xfff;
    -+		ipb >>= 12;
    -+		base = ipb & 0xf;
    -+		code = base ? vm->save_area.guest.grs[base] + displace : displace;
    -+		code &= 0xffff;
    -+		ret = ret && (code == diag);
    -+		break;
    -+	default:
    -+		abort(); /* not implemented */
    -+	}
    -+	return ret;
    ++	assert(diag == 0x44 || diag == 0x9c);
    ++
    ++	if (vm->sblk->icptcode != ICPT_INST)
    ++		return false;
    ++	if (instr.opcode != 0x83 || instr.zero)
    ++		return false;
    ++	code = instr.r_base ? vm->save_area.guest.grs[instr.r_base] : 0;
    ++	code = (code + instr.displace) & 0xffff;
    ++	return code == diag;
     +}
     +
      void sie_handle_validity(struct vm *vm)
    @@ lib/s390x/snippet-host.c (new)
     +#include <snippet-host.h>
     +#include <sie.h>
     +
    -+bool snippet_check_force_exit(struct vm *vm)
    ++bool snippet_is_force_exit(struct vm *vm)
     +{
    -+	bool r;
    ++	return sie_is_diag_icpt(vm, 0x44);
    ++}
     +
    -+	r = sie_is_diag_icpt(vm, 0x44);
    -+	report(r, "guest forced exit");
    -+	return r;
    ++bool snippet_is_force_exit_value(struct vm *vm)
    ++{
    ++	return sie_is_diag_icpt(vm, 0x9c);
     +}
     +
    -+bool snippet_get_force_exit_value(struct vm *vm, uint64_t *value)
    ++uint64_t snippet_get_force_exit_value(struct vm *vm)
     +{
     +	struct kvm_s390_sie_block *sblk = vm->sblk;
     +
    -+	if (sie_is_diag_icpt(vm, 0x9c)) {
    -+		*value = vm->save_area.guest.grs[(sblk->ipa & 0xf0) >> 4];
    -+		report_pass("guest forced exit with value: 0x%lx", *value);
    -+		return true;
    -+	}
    -+	report_fail("guest forced exit with value");
    -+	return false;
    ++	assert(snippet_is_force_exit_value(vm));
    ++
    ++	return vm->save_area.guest.grs[(sblk->ipa & 0xf0) >> 4];
     +}
     +
     +void snippet_check_force_exit_value(struct vm *vm, uint64_t value_exp)
     +{
     +	uint64_t value;
     +
    -+	if (snippet_get_force_exit_value(vm, &value))
    -+		report(value == value_exp, "guest exit value matches 0x%lx", value_exp);
    ++	if (snippet_is_force_exit_value(vm)) {
    ++		value = snippet_get_force_exit_value(vm);
    ++		report(value == value_exp, "guest forced exit with value (0x%lx == 0x%lx)",
    ++		       value, value_exp);
    ++	} else {
    ++		report_fail("guest forced exit with value");
    ++	}
     +}
     
      ## lib/s390x/uv.c ##
4:  efe8449a ! 4:  67fbf0bb s390x: Use library functions for snippet exit
    @@ s390x/sie-dat.c: static void test_sie_dat(void)
     -
     -	r1 = (vm.sblk->ipa & 0xf0) >> 4;
     -	test_page_gpa = vm.save_area.guest.grs[r1];
    -+	assert(snippet_get_force_exit_value(&vm, &test_page_gpa));
    ++	assert(snippet_is_force_exit_value(&vm));
    ++	test_page_gpa = snippet_get_force_exit_value(&vm);
      	test_page_hpa = virt_to_pte_phys(guest_root, (void*)test_page_gpa);
      	test_page_hva = __va(test_page_hpa);
      	report_info("test buffer gpa=0x%lx hva=%p", test_page_gpa, test_page_hva);
    @@ s390x/sie-dat.c: static void test_sie_dat(void)
      	sie(&vm);
     -	assert(vm.sblk->icptcode == ICPT_INST &&
     -	       vm.sblk->ipa == 0x8300 && vm.sblk->ipb == 0x440000);
    -+	assert(snippet_check_force_exit(&vm));
    ++	assert(snippet_is_force_exit(&vm));
      
      	contents_match = true;
      	for (unsigned int i = 0; i < GUEST_TEST_PAGE_COUNT; i++) {
5:  f0eaac68 ! 5:  157079f2 s390x: Add test for STFLE interpretive execution (format-0)
    @@ s390x/stfle-sie.c (new)
     +#include <snippet-host.h>
     +#include <alloc_page.h>
     +#include <sclp.h>
    ++#include <rand.h>
     +
     +static struct vm vm;
     +static uint64_t (*fac)[PAGE_SIZE / sizeof(uint64_t)];
    -+static rand_state rand_s;
    ++static prng_state prng_s;
     +
     +static void setup_guest(void)
     +{
    @@ s390x/stfle-sie.c (new)
     +	uint64_t guest_stfle_addr;
     +
     +	sie(&vm);
    -+	assert(snippet_get_force_exit_value(&vm, &guest_stfle_addr));
    ++	assert(snippet_is_force_exit_value(&vm));
    ++	guest_stfle_addr = snippet_get_force_exit_value(&vm);
     +	res.mem = &vm.guest_mem[guest_stfle_addr];
     +	memcpy(&res.reg, res.mem, sizeof(res.reg));
     +	res.len = (res.reg & 0xff) + 1;
    @@ s390x/stfle-sie.c (new)
     +
     +	report_prefix_push("format-0");
     +	for (int j = 0; j < stfle_size(); j++)
    -+		WRITE_ONCE((*fac)[j], rand64(&rand_s));
    ++		WRITE_ONCE((*fac)[j], prng64(&prng_s));
     +	vm.sblk->fac = (uint32_t)(uint64_t)fac;
     +	res = run_guest();
     +	report(res.len == stfle_size(), "stfle len correct");
    @@ s390x/stfle-sie.c (new)
     +		goto out;
     +	}
     +
    -+	report_info("pseudo rand seed: 0x%lx", args.seed);
    -+	rand_s = RAND_STATE_INIT(args.seed);
    ++	report_info("PRNG seed: 0x%lx", args.seed);
    ++	prng_s = prng_init(args.seed);
     +	setup_guest();
     +	if (test_facility(7))
     +		test_stfle_format_0();
     +out:
     +	return report_summary();
     +}
    +
    + ## s390x/unittests.cfg ##
    +@@ s390x/unittests.cfg: extra_params = """-cpu max,ctop=on -smp cpus=1,drawers=2,books=2,sockets=2,cores
    + 
    + [sie-dat]
    + file = sie-dat.elf
    ++
    ++[stfle-sie]
    ++file = stfle-sie.elf

base-commit: 3c1736b1344b9831f17fbd64f95ea89c279564c6

Signature · 1 line
2.43.0
#1 lore raw

PATCH v2 1/5 lib: Add pseudo random functions

Add functions for generating pseudo random 32 and 64 bit values. The implementation uses SHA-256 and so the randomness should have good quality.
Implement the necessary subset of SHA-256.
The PRNG algorithm is equivalent to the following python snippet:

def prng32(seed):
from hashlib import sha256
state = seed.to_bytes(8, byteorder="big")
while True:
state = sha256(state).digest()
for i in range(8):
yield int.from_bytes(state[i*4:(i+1)*4], byteorder="big")

---

Notes:

    Since a PRNG with better quality was asked for I decided to use SHA-256
    because:
     * it is a standard, commonly used algorithm
     * high quality randomness is assured
     * the implementation can be checked against the spec
     * the implementation can be easily checked via comparison
    
    I tested the implementation in the following way:
    
    cat <<'EOF' > rand.py
    #!/usr/bin/python3
    
    def prng32(seed):
        from hashlib import sha256
        state = seed.to_bytes(8, byteorder="big")
        while True:
            state = sha256(state).digest()
            for i in range(8):
                yield int.from_bytes(state[i*4:(i+1)*4], byteorder="big")
    
    r = prng32(0)
    for i in range(100):
        print(f"{next(r):08x}")
    
    EOF
    
    cat <<'EOF' > rand.c
    #include <stdio.h>
    #include "rand.h"
    
    void main(void)
    {
    	prng_state state = prng_init(0);
    	for (int i = 0; i < 100; i++) {
    		printf("%08x\n", prng32(&state));
    	}
    }
    EOF
    cat <<'EOF' > libcflat.h
    #define ARRAY_SIZE(_a) (sizeof(_a)/sizeof((_a)[0]))
    EOF
    chmod +x rand.py
    ln -s lib/rand.c librand.c
    gcc -Ilib librand.c rand.c
    diff <(./a.out) <(./rand.py)
 Makefile   |   1 +
 lib/rand.h |  21 +++++++
 lib/rand.c | 177 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 199 insertions(+)
 create mode 100644 lib/rand.h
 create mode 100644 lib/rand.c
Makefile +1 -0
index 602910dd..7997e035 100644
@@ -28,6 +28,7 @@ cflatobjs := \
 	lib/printf.o \
 	lib/string.o \
 	lib/abort.o \
+	lib/rand.o \
 	lib/report.o \
 	lib/stack.o
 
lib/rand.h new file +21 -0
new file mode 100644
index 00000000..cdce8bd7
@@ -0,0 +1,21 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * (pseudo) random functions
+ *
+ * Copyright IBM Corp. 2024
+ */
+#ifndef _RAND_H_
+#define _RAND_H_
+
+#include <stdint.h>
+
+/* Non cryptographically secure PRNG */
+typedef struct {
+	uint32_t hash[8];
+	uint8_t next_word;
+} prng_state;
+prng_state prng_init(uint64_t seed);
+uint32_t prng32(prng_state *state);
+uint64_t prng64(prng_state *state);
+
+#endif /* _RAND_H_ */
lib/rand.c new file +177 -0

177 lines not on this page · raw message

Signature · 1 line
2.43.0
Acked-by on v2 1/5
#2 lore raw

Re: [kvm-unit-tests PATCH v2 1/5] lib: Add pseudo random functions

Quoted 296 lines · Nina Schoetterl-Glausch

Add functions for generating pseudo random 32 and 64 bit values. The implementation uses SHA-256 and so the randomness should have good quality.
Implement the necessary subset of SHA-256.
The PRNG algorithm is equivalent to the following python snippet:

def prng32(seed):
from hashlib import sha256
state = seed.to_bytes(8, byteorder="big")
while True:
state = sha256(state).digest()
for i in range(8):
yield int.from_bytes(state[i*4:(i+1)*4], byteorder="big")

---

Notes:

    Since a PRNG with better quality was asked for I decided to use SHA-256
    because:
     * it is a standard, commonly used algorithm
     * high quality randomness is assured
     * the implementation can be checked against the spec
     * the implementation can be easily checked via comparison
    
    I tested the implementation in the following way:
    
    cat <<'EOF' > rand.py
    #!/usr/bin/python3
    
    def prng32(seed):
        from hashlib import sha256
        state = seed.to_bytes(8, byteorder="big")
        while True:
            state = sha256(state).digest()
            for i in range(8):
                yield int.from_bytes(state[i*4:(i+1)*4], byteorder="big")
    
    r = prng32(0)
    for i in range(100):
        print(f"{next(r):08x}")
    
    EOF
    
    cat <<'EOF' > rand.c
    #include <stdio.h>
    #include "rand.h"
    
    void main(void)
    {
    	prng_state state = prng_init(0);
    	for (int i = 0; i < 100; i++) {
    		printf("%08x\n", prng32(&state));
    	}
    }
    EOF
    cat <<'EOF' > libcflat.h
    #define ARRAY_SIZE(_a) (sizeof(_a)/sizeof((_a)[0]))
    EOF
    chmod +x rand.py
    ln -s lib/rand.c librand.c
    gcc -Ilib librand.c rand.c
    diff <(./a.out) <(./rand.py)
 Makefile   |   1 +
 lib/rand.h |  21 +++++++
 lib/rand.c | 177 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 199 insertions(+)
 create mode 100644 lib/rand.h
 create mode 100644 lib/rand.c
Makefile +1 -0
index 602910dd..7997e035 100644
@@ -28,6 +28,7 @@ cflatobjs := \
 	lib/printf.o \
 	lib/string.o \
 	lib/abort.o \
+	lib/rand.o \
 	lib/report.o \
 	lib/stack.o
 
lib/rand.h new file +21 -0
new file mode 100644
index 00000000..cdce8bd7
@@ -0,0 +1,21 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * (pseudo) random functions
+ *
+ * Copyright IBM Corp. 2024
+ */
+#ifndef _RAND_H_
+#define _RAND_H_
+
+#include <stdint.h>
+
+/* Non cryptographically secure PRNG */
+typedef struct {
+	uint32_t hash[8];
+	uint8_t next_word;
+} prng_state;
+prng_state prng_init(uint64_t seed);
+uint32_t prng32(prng_state *state);
+uint64_t prng64(prng_state *state);
+
+#endif /* _RAND_H_ */
lib/rand.c new file +177 -0
new file mode 100644
index 00000000..c5b3d53c
@@ -0,0 +1,177 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * (pseudo) random functions
+ * Currently uses SHA-256 to scramble the PRNG state.
+ *
+ * Copyright IBM Corp. 2024
+ */
+
+#include "libcflat.h"
+#include "rand.h"
+#include <string.h>
+
+/* Begin SHA-256 related definitions */
+
+#define INITAL_HASH { \
+	0x6a09e667, \
+	0xbb67ae85, \
+	0x3c6ef372, \
+	0xa54ff53a, \
+	0x510e527f, \
+	0x9b05688c, \
+	0x1f83d9ab, \
+	0x5be0cd19, \
+}
+
+static const uint32_t K[] = {
+	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+	0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+	0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+	0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+	0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+	0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+	0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+	0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+};
+
+static inline uint32_t ch(uint32_t x, uint32_t y, uint32_t z)
+{
+	return (x & y) ^ ((~x) & z);
+}
+
+static inline uint32_t maj(uint32_t x, uint32_t y, uint32_t z)
+{
+	return (x & y) ^ (x & z) ^ (y & z);
+}
+
+static inline uint32_t rot(uint32_t value, unsigned int count)
+{
+	return value >> count | value << (32 - count);
+}
+
+static inline uint32_t upper_sig0(uint32_t x)
+{
+	return rot(x, 2) ^ rot(x, 13) ^ rot(x, 22);
+}
+
+static inline uint32_t upper_sig1(uint32_t x)
+{
+	return rot(x, 6) ^ rot(x, 11) ^ rot(x, 25);
+}
+
+static inline uint32_t lower_sig0(uint32_t x)
+{
+	return rot(x, 7) ^ rot(x, 18) ^ (x >> 3);
+}
+
+static inline uint32_t lower_sig1(uint32_t x)
+{
+	return rot(x, 17) ^ rot(x, 19) ^ (x >> 10);
+}
+
+enum alphabet { a, b, c, d, e, f, g, h, };
+
+static void sha256_chunk(const uint32_t (*chunk)[16], uint32_t (*hash)[8])
+{
+	uint32_t w[64];
+	uint32_t w_hash[8];
+
+	memcpy(w, chunk, sizeof(*chunk));
+
+	for (int i = 16; i < 64; i++)
+		w[i] = lower_sig1(w[i - 2]) + w[i - 7] + lower_sig0(w[i - 15]) + w[i - 16];
+
+	memcpy(w_hash, hash, sizeof(*hash));
+
+	for (int i = 0; i < 64; i++) {
+		uint32_t t1, t2;
+
+		t1 = w_hash[h] +
+		     upper_sig1(w_hash[e]) +
+		     ch(w_hash[e], w_hash[f], w_hash[g]) +
+		     K[i] +
+		     w[i];
+
+		t2 = upper_sig0(w_hash[a]) + maj(w_hash[a], w_hash[b], w_hash[c]);
+
+		w_hash[h] = w_hash[g];
+		w_hash[g] = w_hash[f];
+		w_hash[f] = w_hash[e];
+		w_hash[e] = w_hash[d] + t1;
+		w_hash[d] = w_hash[c];
+		w_hash[c] = w_hash[b];
+		w_hash[b] = w_hash[a];
+		w_hash[a] = t1 + t2;
+	}
+
+	for (int i = 0; i < 8; i++)
+		(*hash)[i] += w_hash[i];
+}
+
+/**
+ * sha256_hash - Calculate SHA-256 of input. Only a limited subset of inputs supported.
+ * @n: Number of words to hash, must be <= 13
+ * @input: Input data to hash
+ * @hash: Output hash as a word array, ordered such that the first word contains
+ *        the first/leftmost bits of the 256 bit hash
+ *
+ * Calculate the SHA-256 hash of the input where the input must be a multiple of
+ * 4 bytes and at most 52 long. The input is used without any adjustment, so,
+ * should the caller want to hash bytes it needs to interpret the bytes in the
+ * ordering as defined by the specification, that is big endian.
+ * The same applies to interpreting the output array as bytes.
+ * The function computes the same as: printf "%08x" ${input[@]} | xxd -r -p | sha256sum .
+ */
+static void sha256_hash(unsigned int n, const uint32_t (*input)[n], uint32_t (*hash)[8])
+{
+	/*
+	 * Pad according to SHA-2 specification.
+	 * First set up length in bits.
+	 */
+	uint32_t chunk[16] = {
+		[15] = sizeof(*input) * 8,
+	};
+
+	memcpy(chunk, input, sizeof(*input));
+	/* Then add separator */
+	chunk[n] = 1 << 31;
+	memcpy(hash, (uint32_t[])INITAL_HASH, sizeof(*hash));
+	sha256_chunk(&chunk, hash);
+}
+
+/* End SHA-256 related definitions */
+
+prng_state prng_init(uint64_t seed)
+{
+	prng_state state = { .next_word = 0 };
+	uint32_t seed_arr[2] = { seed >> 32, seed };
+
+	sha256_hash(ARRAY_SIZE(seed_arr), &seed_arr, &state.hash);
+	return state;
+}
+
+static void prng_scramble(prng_state *state)
+{
+	uint32_t input[8];
+
+	memcpy(input, state->hash, sizeof(state->hash));
+	sha256_hash(ARRAY_SIZE(input), &input, &state->hash);
+	state->next_word = 0;
+}
+
+uint32_t prng32(prng_state *state)
+{
+	if (state->next_word < ARRAY_SIZE(state->hash))
+		return state->hash[state->next_word++];
+
+	prng_scramble(state);
+	return prng32(state);
+}
+
+uint64_t prng64(prng_state *state)
+{
+	/* explicitly evaluate the high word first */
+	uint64_t high = prng32(state);
+
+	return high << 32 | prng32(state);
+}
Signature · 1 line
2.43.0

LGTM,

Thanks,
drew

#3 lore raw

PATCH v2 2/5 s390x: lib: Remove double include

In reply to Nina Schoetterl-Glausch

libcflat.h was included twice.

---
 lib/s390x/sie.c | 1 -
 1 file changed, 1 deletion(-)
lib/s390x/sie.c +0 -1
index 28fbf146..40936bd2 100644
@@ -14,7 +14,6 @@
 #include <sie.h>
 #include <asm/page.h>
 #include <asm/interrupt.h>
-#include <libcflat.h>
 #include <alloc_page.h>
 #include <vmalloc.h>
 #include <sclp.h>
Signature · 1 line
2.43.0
#5 lore raw

PATCH v2 3/5 s390x: Add library functions for exiting from snippet

In reply to Nina Schoetterl-Glausch

It is useful to be able to force an exit to the host from the snippet, as well as do so while returning a value.
Add this functionality, also add helper functions for the host to check for an exit and get or check the value.
Use diag 0x44 and 0x9c for this.
Add a guest specific snippet header file and rename snippet.h to reflect that it is host specific.

---
 s390x/Makefile                          |  1 +
 lib/s390x/asm/arch_def.h                | 13 ++++++++
 lib/s390x/sie.h                         |  1 +
 lib/s390x/snippet-guest.h               | 26 +++++++++++++++
 lib/s390x/{snippet.h => snippet-host.h} | 10 ++++--
 lib/s390x/sie.c                         | 31 ++++++++++++++++++
 lib/s390x/snippet-host.c                | 42 +++++++++++++++++++++++++
 lib/s390x/uv.c                          |  2 +-
 s390x/mvpg-sie.c                        |  2 +-
 s390x/pv-diags.c                        |  2 +-
 s390x/pv-icptcode.c                     |  2 +-
 s390x/pv-ipl.c                          |  2 +-
 s390x/sie-dat.c                         |  2 +-
 s390x/spec_ex-sie.c                     |  2 +-
 s390x/uv-host.c                         |  2 +-
 15 files changed, 129 insertions(+), 11 deletions(-)
 create mode 100644 lib/s390x/snippet-guest.h
 rename lib/s390x/{snippet.h => snippet-host.h} (92%)
 create mode 100644 lib/s390x/snippet-host.c
s390x/Makefile +1 -0
index f79fd009..a10695a2 100644
@@ -109,6 +109,7 @@ cflatobjs += lib/s390x/css_lib.o
 cflatobjs += lib/s390x/malloc_io.o
 cflatobjs += lib/s390x/uv.o
 cflatobjs += lib/s390x/sie.o
+cflatobjs += lib/s390x/snippet-host.o
 cflatobjs += lib/s390x/fault.o
 
 OBJDIRS += lib/s390x
lib/s390x/asm/arch_def.h +13 -0
index 745a3387..db04deca 100644
@@ -504,4 +504,17 @@ static inline uint32_t get_prefix(void)
 	return current_prefix;
 }
 
+static inline void diag44(void)
+{
+	asm volatile("diag	0,0,0x44\n");
+}
+
+static inline void diag9c(uint64_t val)
+{
+	asm volatile("diag	%[val],0,0x9c\n"
+		:
+		: [val] "d"(val)
+	);
+}
+
 #endif
lib/s390x/sie.h +1 -0
index c1724cf2..18fdd72e 100644
@@ -281,6 +281,7 @@ void sie_expect_validity(struct vm *vm);
 uint16_t sie_get_validity(struct vm *vm);
 void sie_check_validity(struct vm *vm, uint16_t vir_exp);
 void sie_handle_validity(struct vm *vm);
+bool sie_is_diag_icpt(struct vm *vm, unsigned int diag);
 void sie_guest_sca_create(struct vm *vm);
 void sie_guest_create(struct vm *vm, uint64_t guest_mem, uint64_t guest_mem_len);
 void sie_guest_destroy(struct vm *vm);
lib/s390x/snippet-guest.h new file +26 -0
new file mode 100644
index 00000000..e82e8e29
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Snippet functionality for the guest.
+ *
+ * Copyright IBM Corp. 2023
+ */
+
+#ifndef _S390X_SNIPPET_GUEST_H_
+#define _S390X_SNIPPET_GUEST_H_
+
+#include <asm/arch_def.h>
+#include <asm/barrier.h>
+
+static inline void force_exit(void)
+{
+	diag44();
+	mb(); /* allow host to modify guest memory */
+}
+
+static inline void force_exit_value(uint64_t val)
+{
+	diag9c(val);
+	mb(); /* allow host to modify guest memory */
+}
+
+#endif
lib/s390x/snippet-host.h renamed from lib/s390x/snippet.h +7 -3
similarity index 92%
rename from lib/s390x/snippet.h
rename to lib/s390x/snippet-host.h
index 910849aa..230b25b0 100644
@@ -1,13 +1,13 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Snippet definitions
+ * Snippet functionality for the host.
  *
  * Copyright IBM Corp. 2021
  * Author: Janosch Frank <[email protected]>
  */
 
-#ifndef _S390X_SNIPPET_H_
-#define _S390X_SNIPPET_H_
+#ifndef _S390X_SNIPPET_HOST_H_
+#define _S390X_SNIPPET_HOST_H_
 
 #include <sie.h>
 #include <uv.h>
@@ -144,4 +144,8 @@ static inline void snippet_setup_guest(struct vm *vm, bool is_pv)
 	}
 }
 
+bool snippet_is_force_exit(struct vm *vm);
+bool snippet_is_force_exit_value(struct vm *vm);
+uint64_t snippet_get_force_exit_value(struct vm *vm);
+void snippet_check_force_exit_value(struct vm *vm, uint64_t exit_exp);
 #endif
lib/s390x/sie.c +31 -0
index 40936bd2..6bda493d 100644
@@ -42,6 +42,37 @@ void sie_check_validity(struct vm *vm, uint16_t vir_exp)
 	report(vir_exp == vir, "VALIDITY: %x", vir);
 }
 
+bool sie_is_diag_icpt(struct vm *vm, unsigned int diag)
+{
+	union {
+		struct {
+			uint64_t     : 16;
+			uint64_t ipa : 16;
+			uint64_t ipb : 32;
+		};
+		struct {
+			uint64_t          : 16;
+			uint64_t opcode   :  8;
+			uint64_t r_1      :  4;
+			uint64_t r_2      :  4;
+			uint64_t r_base   :  4;
+			uint64_t displace : 12;
+			uint64_t zero     : 16;
+		};
+	} instr = { .ipa = vm->sblk->ipa, .ipb = vm->sblk->ipb };
+	uint64_t code;
+
+	assert(diag == 0x44 || diag == 0x9c);
+
+	if (vm->sblk->icptcode != ICPT_INST)
+		return false;
+	if (instr.opcode != 0x83 || instr.zero)
+		return false;
+	code = instr.r_base ? vm->save_area.guest.grs[instr.r_base] : 0;
+	code = (code + instr.displace) & 0xffff;
+	return code == diag;
+}
+
 void sie_handle_validity(struct vm *vm)
 {
 	if (vm->sblk->icptcode != ICPT_VALIDITY)
lib/s390x/snippet-host.c new file +42 -0

42 lines not on this page · raw message

lib/s390x/uv.c +1 -1
index 23a86179..81e9a71e 100644
@@ -18,7 +18,7 @@
 #include <asm/uv.h>
 #include <uv.h>
 #include <sie.h>
-#include <snippet.h>
+#include <snippet-host.h>
 
 static struct uv_cb_qui uvcb_qui = {
 	.header.cmd = UVC_CMD_QUI,
s390x/mvpg-sie.c +1 -1
index d182b49a..3aec9d71 100644
@@ -19,7 +19,7 @@
 #include <alloc_page.h>
 #include <sclp.h>
 #include <sie.h>
-#include <snippet.h>
+#include <snippet-host.h>
 
 static struct vm vm;
 
s390x/pv-diags.c +1 -1
index 3193ad99..7fb7f091 100644
@@ -8,7 +8,7 @@
  *  Janosch Frank <[email protected]>
  */
 #include <libcflat.h>
-#include <snippet.h>
+#include <snippet-host.h>
 #include <pv_icptdata.h>
 #include <sie.h>
 #include <sclp.h>
s390x/pv-icptcode.c +1 -1
index d7c47d6f..9a9c7357 100644
@@ -12,7 +12,7 @@
 #include <sie.h>
 #include <smp.h>
 #include <sclp.h>
-#include <snippet.h>
+#include <snippet-host.h>
 #include <pv_icptdata.h>
 #include <asm/facility.h>
 #include <asm/barrier.h>
s390x/pv-ipl.c +1 -1
index cc46e7f7..7d654b84 100644
@@ -10,7 +10,7 @@
 #include <libcflat.h>
 #include <sie.h>
 #include <sclp.h>
-#include <snippet.h>
+#include <snippet-host.h>
 #include <pv_icptdata.h>
 #include <asm/facility.h>
 #include <asm/uv.h>
s390x/sie-dat.c +1 -1
index f0257770..9e60f26e 100644
@@ -16,7 +16,7 @@
 #include <alloc_page.h>
 #include <sclp.h>
 #include <sie.h>
-#include <snippet.h>
+#include <snippet-host.h>
 #include "snippets/c/sie-dat.h"
 
 static struct vm vm;
s390x/spec_ex-sie.c +1 -1
index fe2f23ee..0ad7ec08 100644
@@ -13,7 +13,7 @@
 #include <asm/arch_def.h>
 #include <alloc_page.h>
 #include <sie.h>
-#include <snippet.h>
+#include <snippet-host.h>
 #include <hardware.h>
 
 static struct vm vm;
s390x/uv-host.c +1 -1
index 55b46446..87d108b6 100644
@@ -15,7 +15,7 @@
 #include <sclp.h>
 #include <smp.h>
 #include <uv.h>
-#include <snippet.h>
+#include <snippet-host.h>
 #include <mmu.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
Signature · 1 line
2.43.0
#6 lore raw

Re: [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet

Quoted 160 lines · Nina Schoetterl-Glausch

It is useful to be able to force an exit to the host from the snippet, as well as do so while returning a value.
Add this functionality, also add helper functions for the host to check for an exit and get or check the value.
Use diag 0x44 and 0x9c for this.
Add a guest specific snippet header file and rename snippet.h to reflect that it is host specific.

---
  s390x/Makefile                          |  1 +
  lib/s390x/asm/arch_def.h                | 13 ++++++++
  lib/s390x/sie.h                         |  1 +
  lib/s390x/snippet-guest.h               | 26 +++++++++++++++
  lib/s390x/{snippet.h => snippet-host.h} | 10 ++++--
  lib/s390x/sie.c                         | 31 ++++++++++++++++++
  lib/s390x/snippet-host.c                | 42 +++++++++++++++++++++++++
  lib/s390x/uv.c                          |  2 +-
  s390x/mvpg-sie.c                        |  2 +-
  s390x/pv-diags.c                        |  2 +-
  s390x/pv-icptcode.c                     |  2 +-
  s390x/pv-ipl.c                          |  2 +-
  s390x/sie-dat.c                         |  2 +-
  s390x/spec_ex-sie.c                     |  2 +-
  s390x/uv-host.c                         |  2 +-
  15 files changed, 129 insertions(+), 11 deletions(-)

create mode 100644 lib/s390x/snippet-guest.h rename lib/s390x/{snippet.h => snippet-host.h} (92%) create mode 100644 lib/s390x/snippet-host.c

s390x/Makefile +1 -0
index f79fd009..a10695a2 100644
@@ -109,6 +109,7 @@ cflatobjs += lib/s390x/css_lib.o
  cflatobjs += lib/s390x/malloc_io.o
  cflatobjs += lib/s390x/uv.o
  cflatobjs += lib/s390x/sie.o
+cflatobjs += lib/s390x/snippet-host.o
  cflatobjs += lib/s390x/fault.o
 
  OBJDIRS += lib/s390x
lib/s390x/asm/arch_def.h +13 -0
index 745a3387..db04deca 100644
@@ -504,4 +504,17 @@ static inline uint32_t get_prefix(void)
  	return current_prefix;
  }
 
+static inline void diag44(void)
+{
+	asm volatile("diag	0,0,0x44\n");
+}
+
+static inline void diag9c(uint64_t val)
+{
+	asm volatile("diag	%[val],0,0x9c\n"
+		:
+		: [val] "d"(val)
+	);
+}
+
  #endif
lib/s390x/sie.h +1 -0
index c1724cf2..18fdd72e 100644
@@ -281,6 +281,7 @@ void sie_expect_validity(struct vm *vm);
  uint16_t sie_get_validity(struct vm *vm);
  void sie_check_validity(struct vm *vm, uint16_t vir_exp);
  void sie_handle_validity(struct vm *vm);
+bool sie_is_diag_icpt(struct vm *vm, unsigned int diag);
  void sie_guest_sca_create(struct vm *vm);
  void sie_guest_create(struct vm *vm, uint64_t guest_mem, uint64_t guest_mem_len);
  void sie_guest_destroy(struct vm *vm);
lib/s390x/snippet-guest.h new file +26 -0
new file mode 100644
index 00000000..e82e8e29
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Snippet functionality for the guest.
+ *
+ * Copyright IBM Corp. 2023
+ */
+
+#ifndef _S390X_SNIPPET_GUEST_H_
+#define _S390X_SNIPPET_GUEST_H_
+
+#include <asm/arch_def.h>
+#include <asm/barrier.h>
+
+static inline void force_exit(void)
+{
+	diag44();
+	mb(); /* allow host to modify guest memory */
+}
+
+static inline void force_exit_value(uint64_t val)
+{
+	diag9c(val);
+	mb(); /* allow host to modify guest memory */
+}
+
+#endif
lib/s390x/snippet-host.h renamed from lib/s390x/snippet.h +7 -3
similarity index 92%
rename from lib/s390x/snippet.h
rename to lib/s390x/snippet-host.h
index 910849aa..230b25b0 100644
@@ -1,13 +1,13 @@
  /* SPDX-License-Identifier: GPL-2.0-only */
  /*
- * Snippet definitions
+ * Snippet functionality for the host.
   *
   * Copyright IBM Corp. 2021
   * Author: Janosch Frank <[email protected]>
   */
 
-#ifndef _S390X_SNIPPET_H_
-#define _S390X_SNIPPET_H_
+#ifndef _S390X_SNIPPET_HOST_H_
+#define _S390X_SNIPPET_HOST_H_
 
  #include <sie.h>
  #include <uv.h>
@@ -144,4 +144,8 @@ static inline void snippet_setup_guest(struct vm *vm, bool is_pv)
  	}
  }
 
+bool snippet_is_force_exit(struct vm *vm);
+bool snippet_is_force_exit_value(struct vm *vm);
+uint64_t snippet_get_force_exit_value(struct vm *vm);
+void snippet_check_force_exit_value(struct vm *vm, uint64_t exit_exp);
  #endif
lib/s390x/sie.c +11 -0
index 40936bd2..6bda493d 100644
@@ -42,6 +42,37 @@ void sie_check_validity(struct vm *vm, uint16_t vir_exp)
  	report(vir_exp == vir, "VALIDITY: %x", vir);
  }
 
+bool sie_is_diag_icpt(struct vm *vm, unsigned int diag)
+{
+	union {
+		struct {
+			uint64_t     : 16;
+			uint64_t ipa : 16;
+			uint64_t ipb : 32;
+		};
+		struct {
+			uint64_t          : 16;
+			uint64_t opcode   :  8;

lib/s390x/sie.c void sie_check_validity(struct vm *vm, uint16_t vir_exp) · line 65

Quoted 10 lines
lib/s390x/sie.c +10 -0
+			uint64_t r_1      :  4;
+			uint64_t r_2      :  4;
+			uint64_t r_base   :  4;
+			uint64_t displace : 12;
+			uint64_t zero     : 16;
+		};
+	} instr = { .ipa = vm->sblk->ipa, .ipb = vm->sblk->ipb };
+	uint64_t code;
+
+	assert(diag == 0x44 || diag == 0x9c);

You're calling it is_diag_icpt and only allow two. Do you have a reason for clamping this down?

I was considering consolidating pv_icptdata_check_diag() into this.

#7 lore raw

Re: [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet

Quoted 30 lines · Janosch Frank
Quoted 29 lines · Nina Schoetterl-Glausch

It is useful to be able to force an exit to the host from the snippet, as well as do so while returning a value.
Add this functionality, also add helper functions for the host to check for an exit and get or check the value.
Use diag 0x44 and 0x9c for this.
Add a guest specific snippet header file and rename snippet.h to reflect that it is host specific.

---
  s390x/Makefile                          |  1 +
  lib/s390x/asm/arch_def.h                | 13 ++++++++
  lib/s390x/sie.h                         |  1 +
  lib/s390x/snippet-guest.h               | 26 +++++++++++++++
  lib/s390x/{snippet.h => snippet-host.h} | 10 ++++--
  lib/s390x/sie.c                         | 31 ++++++++++++++++++
  lib/s390x/snippet-host.c                | 42 +++++++++++++++++++++++++
  lib/s390x/uv.c                          |  2 +-
  s390x/mvpg-sie.c                        |  2 +-
  s390x/pv-diags.c                        |  2 +-
  s390x/pv-icptcode.c                     |  2 +-
  s390x/pv-ipl.c                          |  2 +-
  s390x/sie-dat.c                         |  2 +-
  s390x/spec_ex-sie.c                     |  2 +-
  s390x/uv-host.c                         |  2 +-
  15 files changed, 129 insertions(+), 11 deletions(-)

create mode 100644 lib/s390x/snippet-guest.h rename lib/s390x/{snippet.h => snippet-host.h} (92%) create mode 100644 lib/s390x/snippet-host.c

[..]

Quoted 16 lines
Quoted 16 lines
lib/s390x/sie.c +16 -0
+bool sie_is_diag_icpt(struct vm *vm, unsigned int diag)
+{
+	union {
+		struct {
+			uint64_t     : 16;
+			uint64_t ipa : 16;
+			uint64_t ipb : 32;
+		};
+		struct {
+			uint64_t          : 16;
+			uint64_t opcode   :  8;
+			uint64_t r_1      :  4;
+			uint64_t r_2      :  4;
+			uint64_t r_base   :  4;
+			uint64_t displace : 12;
+			uint64_t zero     : 16;
Quoted 8 lines

lib/s390x/sie.c void sie_check_validity(struct vm *vm, uint16_t vir_exp) · line 65

Quoted 5 lines
lib/s390x/sie.c +5 -0
+		};
+	} instr = { .ipa = vm->sblk->ipa, .ipb = vm->sblk->ipb };
+	uint64_t code;
+
+	assert(diag == 0x44 || diag == 0x9c);

You're calling it is_diag_icpt and only allow two. Do you have a reason for clamping this down?

I should have left the comment.
They're just "not implemented".
The PoP doesn't specify how diags are generally interpreted, so I intended that if any other diags are needed whoever needs them just checks if the existing logic works or if changes are required.

Quoted 2 lines

I was considering consolidating pv_icptdata_check_diag() into this.

#8 lore raw

Re: [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet

Quoted 59 lines · Nina Schoetterl-Glausch
Quoted 30 lines · Janosch Frank
Quoted 29 lines · Nina Schoetterl-Glausch

It is useful to be able to force an exit to the host from the snippet, as well as do so while returning a value.
Add this functionality, also add helper functions for the host to check for an exit and get or check the value.
Use diag 0x44 and 0x9c for this.
Add a guest specific snippet header file and rename snippet.h to reflect that it is host specific.

---
   s390x/Makefile                          |  1 +
   lib/s390x/asm/arch_def.h                | 13 ++++++++
   lib/s390x/sie.h                         |  1 +
   lib/s390x/snippet-guest.h               | 26 +++++++++++++++
   lib/s390x/{snippet.h => snippet-host.h} | 10 ++++--
   lib/s390x/sie.c                         | 31 ++++++++++++++++++
   lib/s390x/snippet-host.c                | 42 +++++++++++++++++++++++++
   lib/s390x/uv.c                          |  2 +-
   s390x/mvpg-sie.c                        |  2 +-
   s390x/pv-diags.c                        |  2 +-
   s390x/pv-icptcode.c                     |  2 +-
   s390x/pv-ipl.c                          |  2 +-
   s390x/sie-dat.c                         |  2 +-
   s390x/spec_ex-sie.c                     |  2 +-
   s390x/uv-host.c                         |  2 +-
   15 files changed, 129 insertions(+), 11 deletions(-)

create mode 100644 lib/s390x/snippet-guest.h rename lib/s390x/{snippet.h => snippet-host.h} (92%) create mode 100644 lib/s390x/snippet-host.c

[..]

Quoted 16 lines
Quoted 16 lines
lib/s390x/sie.c +16 -0
+bool sie_is_diag_icpt(struct vm *vm, unsigned int diag)
+{
+	union {
+		struct {
+			uint64_t     : 16;
+			uint64_t ipa : 16;
+			uint64_t ipb : 32;
+		};
+		struct {
+			uint64_t          : 16;
+			uint64_t opcode   :  8;
+			uint64_t r_1      :  4;
+			uint64_t r_2      :  4;
+			uint64_t r_base   :  4;
+			uint64_t displace : 12;
+			uint64_t zero     : 16;
Quoted 8 lines

lib/s390x/sie.c void sie_check_validity(struct vm *vm, uint16_t vir_exp) · line 65

Quoted 5 lines
lib/s390x/sie.c +5 -0
+		};
+	} instr = { .ipa = vm->sblk->ipa, .ipb = vm->sblk->ipb };
+	uint64_t code;
+
+	assert(diag == 0x44 || diag == 0x9c);

You're calling it is_diag_icpt and only allow two. Do you have a reason for clamping this down?

Quoted 6 lines

I should have left the comment.
They're just "not implemented".
The PoP doesn't specify how diags are generally interpreted, so I intended that if any other diags are needed whoever needs them just checks if the existing logic works or if changes are required.

Quoted 1 line

Right, but 288, 308 and 500 are being used in the PV sie tests and could be integrated.

#9 lore raw

PATCH v2 4/5 s390x: Use library functions for snippet exit

In reply to Nina Schoetterl-Glausch

Replace the existing code for exiting from snippets with the newly introduced library functionality.

---
 s390x/sie-dat.c            | 11 +++--------
 s390x/snippets/c/sie-dat.c | 19 +------------------
 2 files changed, 4 insertions(+), 26 deletions(-)
s390x/sie-dat.c +3 -8
index 9e60f26e..c8f38220 100644
@@ -27,23 +27,18 @@ static void test_sie_dat(void)
 	uint64_t test_page_gpa, test_page_hpa;
 	uint8_t *test_page_hva, expected_val;
 	bool contents_match;
-	uint8_t r1;
 
 	/* guest will tell us the guest physical address of the test buffer */
 	sie(&vm);
-	assert(vm.sblk->icptcode == ICPT_INST &&
-	       (vm.sblk->ipa & 0xff00) == 0x8300 && vm.sblk->ipb == 0x9c0000);
-
-	r1 = (vm.sblk->ipa & 0xf0) >> 4;
-	test_page_gpa = vm.save_area.guest.grs[r1];
+	assert(snippet_is_force_exit_value(&vm));
+	test_page_gpa = snippet_get_force_exit_value(&vm);
 	test_page_hpa = virt_to_pte_phys(guest_root, (void*)test_page_gpa);
 	test_page_hva = __va(test_page_hpa);
 	report_info("test buffer gpa=0x%lx hva=%p", test_page_gpa, test_page_hva);
 
 	/* guest will now write to the test buffer and we verify the contents */
 	sie(&vm);
-	assert(vm.sblk->icptcode == ICPT_INST &&
-	       vm.sblk->ipa == 0x8300 && vm.sblk->ipb == 0x440000);
+	assert(snippet_is_force_exit(&vm));
 
 	contents_match = true;
 	for (unsigned int i = 0; i < GUEST_TEST_PAGE_COUNT; i++) {
s390x/snippets/c/sie-dat.c +1 -18
index ecfcb60e..414afd42 100644
@@ -9,28 +9,11 @@
  */
 #include <libcflat.h>
 #include <asm-generic/page.h>
+#include <snippet-guest.h>
 #include "sie-dat.h"
 
 static uint8_t test_pages[GUEST_TEST_PAGE_COUNT * PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
 
-static inline void force_exit(void)
-{
-	asm volatile("diag	0,0,0x44\n"
-		     :
-		     :
-		     : "memory"
-	);
-}
-
-static inline void force_exit_value(uint64_t val)
-{
-	asm volatile("diag	%[val],0,0x9c\n"
-		     :
-		     : [val] "d"(val)
-		     : "memory"
-	);
-}
-
 int main(void)
 {
 	uint8_t *invalid_ptr;
Signature · 1 line
2.43.0
#10 lore raw

PATCH v2 5/5 s390x: Add test for STFLE interpretive execution (format-0)

In reply to Nina Schoetterl-Glausch

The STFLE instruction indicates installed facilities. SIE can interpretively execute STFLE.
Use a snippet guest executing STFLE to get the result of interpretive execution and check the result.

---
 s390x/Makefile           |   2 +
 lib/s390x/asm/facility.h |  10 ++-
 s390x/snippets/c/stfle.c |  26 ++++++++
 s390x/stfle-sie.c        | 134 +++++++++++++++++++++++++++++++++++++++
 s390x/unittests.cfg      |   3 +
 5 files changed, 174 insertions(+), 1 deletion(-)
 create mode 100644 s390x/snippets/c/stfle.c
 create mode 100644 s390x/stfle-sie.c
s390x/Makefile +2 -0
index a10695a2..12eb3053 100644
@@ -42,6 +42,7 @@ tests += $(TEST_DIR)/exittime.elf
 tests += $(TEST_DIR)/ex.elf
 tests += $(TEST_DIR)/topology.elf
 tests += $(TEST_DIR)/sie-dat.elf
+tests += $(TEST_DIR)/stfle-sie.elf
 
 pv-tests += $(TEST_DIR)/pv-diags.elf
 pv-tests += $(TEST_DIR)/pv-icptcode.elf
@@ -127,6 +128,7 @@ snippet_lib = $(snippet_asmlib) lib/auxinfo.o
 $(TEST_DIR)/mvpg-sie.elf: snippets = $(SNIPPET_DIR)/c/mvpg-snippet.gbin
 $(TEST_DIR)/sie-dat.elf: snippets = $(SNIPPET_DIR)/c/sie-dat.gbin
 $(TEST_DIR)/spec_ex-sie.elf: snippets = $(SNIPPET_DIR)/c/spec_ex.gbin
+$(TEST_DIR)/stfle-sie.elf: snippets = $(SNIPPET_DIR)/c/stfle.gbin
 
 $(TEST_DIR)/pv-diags.elf: pv-snippets += $(SNIPPET_DIR)/asm/pv-diag-yield.gbin
 $(TEST_DIR)/pv-diags.elf: pv-snippets += $(SNIPPET_DIR)/asm/pv-diag-288.gbin
lib/s390x/asm/facility.h +9 -1
index a66fe56a..2bad05c5 100644
@@ -27,12 +27,20 @@ static inline void stfl(void)
 	asm volatile("	stfl	0(0)\n" : : : "memory");
 }
 
-static inline void stfle(uint64_t *fac, unsigned int nb_doublewords)
+static inline unsigned int stfle(uint64_t *fac, unsigned int nb_doublewords)
 {
 	register unsigned long r0 asm("0") = nb_doublewords - 1;
 
 	asm volatile("	.insn	s,0xb2b00000,0(%1)\n"
 		     : "+d" (r0) : "a" (fac) : "memory", "cc");
+	return r0 + 1;
+}
+
+static inline unsigned long stfle_size(void)
+{
+	uint64_t dummy;
+
+	return stfle(&dummy, 1);
 }
 
 static inline void setup_facilities(void)
s390x/snippets/c/stfle.c new file +26 -0
new file mode 100644
index 00000000..eb024a6a
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright IBM Corp. 2023
+ *
+ * Snippet used by the STLFE interpretive execution facilities test.
+ */
+#include <libcflat.h>
+#include <snippet-guest.h>
+
+int main(void)
+{
+	const unsigned int max_fac_len = 8;
+	uint64_t res[max_fac_len + 1];
+
+	res[0] = max_fac_len - 1;
+	asm volatile ( "lg	0,%[len]\n"
+		"	stfle	%[fac]\n"
+		"	stg	0,%[len]\n"
+		: [fac] "=QS"(*(uint64_t(*)[max_fac_len])&res[1]),
+		  [len] "+RT"(res[0])
+		:
+		: "%r0", "cc"
+	);
+	force_exit_value((uint64_t)&res);
+	return 0;
+}
s390x/stfle-sie.c new file +134 -0

134 lines not on this page · raw message

s390x/unittests.cfg +3 -0
index f5024b6e..118ffa3c 100644
@@ -383,3 +383,6 @@ extra_params = """-cpu max,ctop=on -smp cpus=1,drawers=2,books=2,sockets=2,cores
 
 [sie-dat]
 file = sie-dat.elf
+
+[stfle-sie]
+file = stfle-sie.elf
Signature · 1 line
2.43.0