* [kvm-unit-tests PATCH v2 0/5] s390x: STFLE nested interpretation
@ 2024-01-05 22:54 Nina Schoetterl-Glausch
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 1/5] lib: Add pseudo random functions Nina Schoetterl-Glausch
` (4 more replies)
0 siblings, 5 replies; 11+ messages in thread
From: Nina Schoetterl-Glausch @ 2024-01-05 22:54 UTC (permalink / raw
To: Nina Schoetterl-Glausch, Thomas Huth, Janosch Frank, Andrew Jones,
Nico Boehr, Claudio Imbrenda
Cc: kvm, linux-s390, David Hildenbrand
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 <imbrenda@linux.ibm.com>
Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
## 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 <nsg@linux.ibm.com>
@@ 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
--
2.43.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [kvm-unit-tests PATCH v2 1/5] lib: Add pseudo random functions
2024-01-05 22:54 [kvm-unit-tests PATCH v2 0/5] s390x: STFLE nested interpretation Nina Schoetterl-Glausch
@ 2024-01-05 22:54 ` Nina Schoetterl-Glausch
2024-01-08 9:02 ` Andrew Jones
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 2/5] s390x: lib: Remove double include Nina Schoetterl-Glausch
` (3 subsequent siblings)
4 siblings, 1 reply; 11+ messages in thread
From: Nina Schoetterl-Glausch @ 2024-01-05 22:54 UTC (permalink / raw
To: Andrew Jones, Thomas Huth, Nico Boehr, Nina Schoetterl-Glausch
Cc: David Hildenbrand, Janosch Frank, Claudio Imbrenda, kvm,
linux-s390
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")
Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
---
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
diff --git a/Makefile b/Makefile
index 602910dd..7997e035 100644
--- a/Makefile
+++ b/Makefile
@@ -28,6 +28,7 @@ cflatobjs := \
lib/printf.o \
lib/string.o \
lib/abort.o \
+ lib/rand.o \
lib/report.o \
lib/stack.o
diff --git a/lib/rand.h b/lib/rand.h
new file mode 100644
index 00000000..cdce8bd7
--- /dev/null
+++ b/lib/rand.h
@@ -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_ */
diff --git a/lib/rand.c b/lib/rand.c
new file mode 100644
index 00000000..c5b3d53c
--- /dev/null
+++ b/lib/rand.c
@@ -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);
+}
--
2.43.0
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [kvm-unit-tests PATCH v2 2/5] s390x: lib: Remove double include
2024-01-05 22:54 [kvm-unit-tests PATCH v2 0/5] s390x: STFLE nested interpretation Nina Schoetterl-Glausch
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 1/5] lib: Add pseudo random functions Nina Schoetterl-Glausch
@ 2024-01-05 22:54 ` Nina Schoetterl-Glausch
2024-01-31 9:04 ` Janosch Frank
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet Nina Schoetterl-Glausch
` (2 subsequent siblings)
4 siblings, 1 reply; 11+ messages in thread
From: Nina Schoetterl-Glausch @ 2024-01-05 22:54 UTC (permalink / raw
To: Claudio Imbrenda, Nico Boehr, Janosch Frank
Cc: Nina Schoetterl-Glausch, linux-s390, David Hildenbrand,
Andrew Jones, kvm, Thomas Huth
libcflat.h was included twice.
Reviewed-by: Claudio Imbrenda <imbrenda@linux.ibm.com>
Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
---
lib/s390x/sie.c | 1 -
1 file changed, 1 deletion(-)
diff --git a/lib/s390x/sie.c b/lib/s390x/sie.c
index 28fbf146..40936bd2 100644
--- a/lib/s390x/sie.c
+++ b/lib/s390x/sie.c
@@ -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>
--
2.43.0
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet
2024-01-05 22:54 [kvm-unit-tests PATCH v2 0/5] s390x: STFLE nested interpretation Nina Schoetterl-Glausch
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 1/5] lib: Add pseudo random functions Nina Schoetterl-Glausch
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 2/5] s390x: lib: Remove double include Nina Schoetterl-Glausch
@ 2024-01-05 22:54 ` Nina Schoetterl-Glausch
2024-01-08 12:47 ` Janosch Frank
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 4/5] s390x: Use library functions for snippet exit Nina Schoetterl-Glausch
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 5/5] s390x: Add test for STFLE interpretive execution (format-0) Nina Schoetterl-Glausch
4 siblings, 1 reply; 11+ messages in thread
From: Nina Schoetterl-Glausch @ 2024-01-05 22:54 UTC (permalink / raw
To: Claudio Imbrenda, Thomas Huth, Nina Schoetterl-Glausch,
Nico Boehr, Janosch Frank
Cc: Andrew Jones, linux-s390, David Hildenbrand, kvm
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.
Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
---
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
diff --git a/s390x/Makefile b/s390x/Makefile
index f79fd009..a10695a2 100644
--- a/s390x/Makefile
+++ b/s390x/Makefile
@@ -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
diff --git a/lib/s390x/asm/arch_def.h b/lib/s390x/asm/arch_def.h
index 745a3387..db04deca 100644
--- a/lib/s390x/asm/arch_def.h
+++ b/lib/s390x/asm/arch_def.h
@@ -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
diff --git a/lib/s390x/sie.h b/lib/s390x/sie.h
index c1724cf2..18fdd72e 100644
--- a/lib/s390x/sie.h
+++ b/lib/s390x/sie.h
@@ -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);
diff --git a/lib/s390x/snippet-guest.h b/lib/s390x/snippet-guest.h
new file mode 100644
index 00000000..e82e8e29
--- /dev/null
+++ b/lib/s390x/snippet-guest.h
@@ -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
diff --git a/lib/s390x/snippet.h b/lib/s390x/snippet-host.h
similarity index 92%
rename from lib/s390x/snippet.h
rename to lib/s390x/snippet-host.h
index 910849aa..230b25b0 100644
--- a/lib/s390x/snippet.h
+++ b/lib/s390x/snippet-host.h
@@ -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 <frankja@linux.ibm.com>
*/
-#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
diff --git a/lib/s390x/sie.c b/lib/s390x/sie.c
index 40936bd2..6bda493d 100644
--- a/lib/s390x/sie.c
+++ b/lib/s390x/sie.c
@@ -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)
diff --git a/lib/s390x/snippet-host.c b/lib/s390x/snippet-host.c
new file mode 100644
index 00000000..44a60bb9
--- /dev/null
+++ b/lib/s390x/snippet-host.c
@@ -0,0 +1,42 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Snippet functionality for the host.
+ *
+ * Copyright IBM Corp. 2023
+ */
+
+#include <libcflat.h>
+#include <snippet-host.h>
+#include <sie.h>
+
+bool snippet_is_force_exit(struct vm *vm)
+{
+ return sie_is_diag_icpt(vm, 0x44);
+}
+
+bool snippet_is_force_exit_value(struct vm *vm)
+{
+ return sie_is_diag_icpt(vm, 0x9c);
+}
+
+uint64_t snippet_get_force_exit_value(struct vm *vm)
+{
+ struct kvm_s390_sie_block *sblk = vm->sblk;
+
+ 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_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");
+ }
+}
diff --git a/lib/s390x/uv.c b/lib/s390x/uv.c
index 23a86179..81e9a71e 100644
--- a/lib/s390x/uv.c
+++ b/lib/s390x/uv.c
@@ -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,
diff --git a/s390x/mvpg-sie.c b/s390x/mvpg-sie.c
index d182b49a..3aec9d71 100644
--- a/s390x/mvpg-sie.c
+++ b/s390x/mvpg-sie.c
@@ -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;
diff --git a/s390x/pv-diags.c b/s390x/pv-diags.c
index 3193ad99..7fb7f091 100644
--- a/s390x/pv-diags.c
+++ b/s390x/pv-diags.c
@@ -8,7 +8,7 @@
* Janosch Frank <frankja@linux.ibm.com>
*/
#include <libcflat.h>
-#include <snippet.h>
+#include <snippet-host.h>
#include <pv_icptdata.h>
#include <sie.h>
#include <sclp.h>
diff --git a/s390x/pv-icptcode.c b/s390x/pv-icptcode.c
index d7c47d6f..9a9c7357 100644
--- a/s390x/pv-icptcode.c
+++ b/s390x/pv-icptcode.c
@@ -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>
diff --git a/s390x/pv-ipl.c b/s390x/pv-ipl.c
index cc46e7f7..7d654b84 100644
--- a/s390x/pv-ipl.c
+++ b/s390x/pv-ipl.c
@@ -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>
diff --git a/s390x/sie-dat.c b/s390x/sie-dat.c
index f0257770..9e60f26e 100644
--- a/s390x/sie-dat.c
+++ b/s390x/sie-dat.c
@@ -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;
diff --git a/s390x/spec_ex-sie.c b/s390x/spec_ex-sie.c
index fe2f23ee..0ad7ec08 100644
--- a/s390x/spec_ex-sie.c
+++ b/s390x/spec_ex-sie.c
@@ -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;
diff --git a/s390x/uv-host.c b/s390x/uv-host.c
index 55b46446..87d108b6 100644
--- a/s390x/uv-host.c
+++ b/s390x/uv-host.c
@@ -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>
--
2.43.0
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [kvm-unit-tests PATCH v2 4/5] s390x: Use library functions for snippet exit
2024-01-05 22:54 [kvm-unit-tests PATCH v2 0/5] s390x: STFLE nested interpretation Nina Schoetterl-Glausch
` (2 preceding siblings ...)
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet Nina Schoetterl-Glausch
@ 2024-01-05 22:54 ` Nina Schoetterl-Glausch
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 5/5] s390x: Add test for STFLE interpretive execution (format-0) Nina Schoetterl-Glausch
4 siblings, 0 replies; 11+ messages in thread
From: Nina Schoetterl-Glausch @ 2024-01-05 22:54 UTC (permalink / raw
To: Claudio Imbrenda, Nico Boehr, Thomas Huth, Janosch Frank,
Nina Schoetterl-Glausch
Cc: Andrew Jones, kvm, linux-s390, David Hildenbrand
Replace the existing code for exiting from snippets with the newly
introduced library functionality.
Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
---
s390x/sie-dat.c | 11 +++--------
s390x/snippets/c/sie-dat.c | 19 +------------------
2 files changed, 4 insertions(+), 26 deletions(-)
diff --git a/s390x/sie-dat.c b/s390x/sie-dat.c
index 9e60f26e..c8f38220 100644
--- a/s390x/sie-dat.c
+++ b/s390x/sie-dat.c
@@ -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++) {
diff --git a/s390x/snippets/c/sie-dat.c b/s390x/snippets/c/sie-dat.c
index ecfcb60e..414afd42 100644
--- a/s390x/snippets/c/sie-dat.c
+++ b/s390x/snippets/c/sie-dat.c
@@ -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;
--
2.43.0
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [kvm-unit-tests PATCH v2 5/5] s390x: Add test for STFLE interpretive execution (format-0)
2024-01-05 22:54 [kvm-unit-tests PATCH v2 0/5] s390x: STFLE nested interpretation Nina Schoetterl-Glausch
` (3 preceding siblings ...)
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 4/5] s390x: Use library functions for snippet exit Nina Schoetterl-Glausch
@ 2024-01-05 22:54 ` Nina Schoetterl-Glausch
4 siblings, 0 replies; 11+ messages in thread
From: Nina Schoetterl-Glausch @ 2024-01-05 22:54 UTC (permalink / raw
To: Janosch Frank, Nico Boehr, Claudio Imbrenda,
Nina Schoetterl-Glausch
Cc: David Hildenbrand, Andrew Jones, kvm, Thomas Huth, linux-s390
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.
Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
---
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
diff --git a/s390x/Makefile b/s390x/Makefile
index a10695a2..12eb3053 100644
--- a/s390x/Makefile
+++ b/s390x/Makefile
@@ -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
diff --git a/lib/s390x/asm/facility.h b/lib/s390x/asm/facility.h
index a66fe56a..2bad05c5 100644
--- a/lib/s390x/asm/facility.h
+++ b/lib/s390x/asm/facility.h
@@ -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)
diff --git a/s390x/snippets/c/stfle.c b/s390x/snippets/c/stfle.c
new file mode 100644
index 00000000..eb024a6a
--- /dev/null
+++ b/s390x/snippets/c/stfle.c
@@ -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;
+}
diff --git a/s390x/stfle-sie.c b/s390x/stfle-sie.c
new file mode 100644
index 00000000..a3e7f1c9
--- /dev/null
+++ b/s390x/stfle-sie.c
@@ -0,0 +1,134 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright IBM Corp. 2023
+ *
+ * SIE with STLFE interpretive execution facilities test.
+ */
+#include <libcflat.h>
+#include <stdlib.h>
+#include <asm/facility.h>
+#include <asm/time.h>
+#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 prng_state prng_s;
+
+static void setup_guest(void)
+{
+ extern const char SNIPPET_NAME_START(c, stfle)[];
+ extern const char SNIPPET_NAME_END(c, stfle)[];
+
+ setup_vm();
+ fac = alloc_pages_flags(0, AREA_DMA31);
+
+ snippet_setup_guest(&vm, false);
+ snippet_init(&vm, SNIPPET_NAME_START(c, stfle),
+ SNIPPET_LEN(c, stfle), SNIPPET_UNPACK_OFF);
+}
+
+struct guest_stfle_res {
+ uint16_t len;
+ uint64_t reg;
+ unsigned char *mem;
+};
+
+static struct guest_stfle_res run_guest(void)
+{
+ struct guest_stfle_res res;
+ uint64_t guest_stfle_addr;
+
+ sie(&vm);
+ 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;
+ res.mem += sizeof(res.reg);
+ return res;
+}
+
+static void test_stfle_format_0(void)
+{
+ struct guest_stfle_res res;
+
+ report_prefix_push("format-0");
+ for (int j = 0; j < stfle_size(); j++)
+ 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");
+ report(!memcmp(*fac, res.mem, res.len * sizeof(uint64_t)),
+ "Guest facility list as specified");
+ report_prefix_pop();
+}
+
+struct args {
+ uint64_t seed;
+};
+
+static bool parse_uint64_t(const char *arg, uint64_t *out)
+{
+ char *end;
+ uint64_t num;
+
+ if (arg[0] == '\0')
+ return false;
+ num = strtoul(arg, &end, 0);
+ if (end[0] != '\0')
+ return false;
+ *out = num;
+ return true;
+}
+
+static struct args parse_args(int argc, char **argv)
+{
+ struct args args;
+ const char *flag;
+ unsigned int i;
+ uint64_t arg;
+ bool has_arg;
+
+ stck(&args.seed);
+
+ for (i = 1; i < argc; i++) {
+ if (i + 1 < argc)
+ has_arg = parse_uint64_t(argv[i + 1], &arg);
+ else
+ has_arg = false;
+
+ flag = "--seed";
+ if (!strcmp(flag, argv[i])) {
+ if (!has_arg)
+ report_abort("%s needs an uint64_t parameter", flag);
+ args.seed = arg;
+ ++i;
+ continue;
+ }
+ report_abort("Unsupported parameter '%s'",
+ argv[i]);
+ }
+
+ return args;
+}
+
+int main(int argc, char **argv)
+{
+ struct args args = parse_args(argc, argv);
+
+ if (!sclp_facilities.has_sief2) {
+ report_skip("SIEF2 facility unavailable");
+ goto out;
+ }
+
+ 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();
+}
diff --git a/s390x/unittests.cfg b/s390x/unittests.cfg
index f5024b6e..118ffa3c 100644
--- a/s390x/unittests.cfg
+++ b/s390x/unittests.cfg
@@ -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
--
2.43.0
^ permalink raw reply related [flat|nested] 11+ messages in thread
* Re: [kvm-unit-tests PATCH v2 1/5] lib: Add pseudo random functions
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 1/5] lib: Add pseudo random functions Nina Schoetterl-Glausch
@ 2024-01-08 9:02 ` Andrew Jones
0 siblings, 0 replies; 11+ messages in thread
From: Andrew Jones @ 2024-01-08 9:02 UTC (permalink / raw
To: Nina Schoetterl-Glausch
Cc: Thomas Huth, Nico Boehr, David Hildenbrand, Janosch Frank,
Claudio Imbrenda, kvm, linux-s390
On Fri, Jan 05, 2024 at 11:54:15PM +0100, Nina Schoetterl-Glausch wrote:
> 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")
>
> Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
> ---
>
> 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
>
> diff --git a/Makefile b/Makefile
> index 602910dd..7997e035 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -28,6 +28,7 @@ cflatobjs := \
> lib/printf.o \
> lib/string.o \
> lib/abort.o \
> + lib/rand.o \
> lib/report.o \
> lib/stack.o
>
> diff --git a/lib/rand.h b/lib/rand.h
> new file mode 100644
> index 00000000..cdce8bd7
> --- /dev/null
> +++ b/lib/rand.h
> @@ -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_ */
> diff --git a/lib/rand.c b/lib/rand.c
> new file mode 100644
> index 00000000..c5b3d53c
> --- /dev/null
> +++ b/lib/rand.c
> @@ -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);
> +}
> --
> 2.43.0
>
LGTM,
Acked-by: Andrew Jones <andrew.jones@linux.dev>
Thanks,
drew
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet Nina Schoetterl-Glausch
@ 2024-01-08 12:47 ` Janosch Frank
2024-01-08 12:58 ` Nina Schoetterl-Glausch
0 siblings, 1 reply; 11+ messages in thread
From: Janosch Frank @ 2024-01-08 12:47 UTC (permalink / raw
To: Nina Schoetterl-Glausch, Claudio Imbrenda, Thomas Huth,
Nico Boehr
Cc: Andrew Jones, linux-s390, David Hildenbrand, kvm
On 1/5/24 23:54, Nina Schoetterl-Glausch wrote:
> 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.
>
> Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
> ---
> 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
>
> diff --git a/s390x/Makefile b/s390x/Makefile
> index f79fd009..a10695a2 100644
> --- a/s390x/Makefile
> +++ b/s390x/Makefile
> @@ -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
> diff --git a/lib/s390x/asm/arch_def.h b/lib/s390x/asm/arch_def.h
> index 745a3387..db04deca 100644
> --- a/lib/s390x/asm/arch_def.h
> +++ b/lib/s390x/asm/arch_def.h
> @@ -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
> diff --git a/lib/s390x/sie.h b/lib/s390x/sie.h
> index c1724cf2..18fdd72e 100644
> --- a/lib/s390x/sie.h
> +++ b/lib/s390x/sie.h
> @@ -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);
> diff --git a/lib/s390x/snippet-guest.h b/lib/s390x/snippet-guest.h
> new file mode 100644
> index 00000000..e82e8e29
> --- /dev/null
> +++ b/lib/s390x/snippet-guest.h
> @@ -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
> diff --git a/lib/s390x/snippet.h b/lib/s390x/snippet-host.h
> similarity index 92%
> rename from lib/s390x/snippet.h
> rename to lib/s390x/snippet-host.h
> index 910849aa..230b25b0 100644
> --- a/lib/s390x/snippet.h
> +++ b/lib/s390x/snippet-host.h
> @@ -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 <frankja@linux.ibm.com>
> */
>
> -#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
> diff --git a/lib/s390x/sie.c b/lib/s390x/sie.c
> index 40936bd2..6bda493d 100644
> --- a/lib/s390x/sie.c
> +++ b/lib/s390x/sie.c
> @@ -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);
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.
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet
2024-01-08 12:47 ` Janosch Frank
@ 2024-01-08 12:58 ` Nina Schoetterl-Glausch
2024-01-08 13:33 ` Janosch Frank
0 siblings, 1 reply; 11+ messages in thread
From: Nina Schoetterl-Glausch @ 2024-01-08 12:58 UTC (permalink / raw
To: Janosch Frank, Claudio Imbrenda, Thomas Huth, Nico Boehr
Cc: Andrew Jones, linux-s390, David Hildenbrand, kvm
On Mon, 2024-01-08 at 13:47 +0100, Janosch Frank wrote:
> On 1/5/24 23:54, Nina Schoetterl-Glausch wrote:
> > 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.
> >
> > Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
> > ---
> > 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
[..]
> > +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);
>
> 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.
>
> I was considering consolidating pv_icptdata_check_diag() into this.
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet
2024-01-08 12:58 ` Nina Schoetterl-Glausch
@ 2024-01-08 13:33 ` Janosch Frank
0 siblings, 0 replies; 11+ messages in thread
From: Janosch Frank @ 2024-01-08 13:33 UTC (permalink / raw
To: Nina Schoetterl-Glausch, Claudio Imbrenda, Thomas Huth,
Nico Boehr
Cc: Andrew Jones, linux-s390, David Hildenbrand, kvm
On 1/8/24 13:58, Nina Schoetterl-Glausch wrote:
> On Mon, 2024-01-08 at 13:47 +0100, Janosch Frank wrote:
>> On 1/5/24 23:54, Nina Schoetterl-Glausch wrote:
>>> 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.
>>>
>>> Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
>>> ---
>>> 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
>
> [..]
>
>>> +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);
>>
>> 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.
>>
Right, but 288, 308 and 500 are being used in the PV sie tests and could
be integrated.
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [kvm-unit-tests PATCH v2 2/5] s390x: lib: Remove double include
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 2/5] s390x: lib: Remove double include Nina Schoetterl-Glausch
@ 2024-01-31 9:04 ` Janosch Frank
0 siblings, 0 replies; 11+ messages in thread
From: Janosch Frank @ 2024-01-31 9:04 UTC (permalink / raw
To: Nina Schoetterl-Glausch, Claudio Imbrenda, Nico Boehr
Cc: linux-s390, David Hildenbrand, Andrew Jones, kvm, Thomas Huth
On 1/5/24 23:54, Nina Schoetterl-Glausch wrote:
> libcflat.h was included twice.
>
> Reviewed-by: Claudio Imbrenda <imbrenda@linux.ibm.com>
> Signed-off-by: Nina Schoetterl-Glausch <nsg@linux.ibm.com>
Reviewed-by: Janosch Frank <frankja@linux.ibm.com>
^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2024-01-31 9:04 UTC | newest]
Thread overview: 11+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2024-01-05 22:54 [kvm-unit-tests PATCH v2 0/5] s390x: STFLE nested interpretation Nina Schoetterl-Glausch
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 1/5] lib: Add pseudo random functions Nina Schoetterl-Glausch
2024-01-08 9:02 ` Andrew Jones
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 2/5] s390x: lib: Remove double include Nina Schoetterl-Glausch
2024-01-31 9:04 ` Janosch Frank
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 3/5] s390x: Add library functions for exiting from snippet Nina Schoetterl-Glausch
2024-01-08 12:47 ` Janosch Frank
2024-01-08 12:58 ` Nina Schoetterl-Glausch
2024-01-08 13:33 ` Janosch Frank
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 4/5] s390x: Use library functions for snippet exit Nina Schoetterl-Glausch
2024-01-05 22:54 ` [kvm-unit-tests PATCH v2 5/5] s390x: Add test for STFLE interpretive execution (format-0) Nina Schoetterl-Glausch
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.