From: Nina Schoetterl-Glausch Extract reset_guest from spec_ex-sie into the lib. After reset_guest() the snippet can be executed again. Signed-off-by: Nina Schoetterl-Glausch Signed-off-by: Christoph Schlameuss --- lib/s390x/snippet.h | 6 ++++++ s390x/spec_ex-sie.c | 10 ++-------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/lib/s390x/snippet.h b/lib/s390x/snippet.h index 910849aa186ce2f94c64ac1f40f8d6d7cdc36a1f..6f611de510d832f23384739606da13e71de3d6fd 100644 --- a/lib/s390x/snippet.h +++ b/lib/s390x/snippet.h @@ -83,6 +83,12 @@ static inline void snippet_init(struct vm *vm, const char *gbin, vm->sblk->ictl = ICTL_OPEREXC | ICTL_PINT; } +static inline void reset_guest(struct vm *vm) +{ + vm->sblk->gpsw = snippet_psw; + vm->sblk->icptcode = 0; +} + /* * Sets up a snippet UV/PV guest on top of an existing and initialized * SIE vm struct. diff --git a/s390x/spec_ex-sie.c b/s390x/spec_ex-sie.c index fe2f23ee3d84fa144416808cb4b353627fe87f3d..75625ecffc4a5a09ff7ef6136b7f1120a831a8c5 100644 --- a/s390x/spec_ex-sie.c +++ b/s390x/spec_ex-sie.c @@ -31,12 +31,6 @@ static void setup_guest(void) SNIPPET_LEN(c, spec_ex), SNIPPET_UNPACK_OFF); } -static void reset_guest(void) -{ - vm.sblk->gpsw = snippet_psw; - vm.sblk->icptcode = 0; -} - static void test_spec_ex_sie(void) { const char *msg; @@ -45,7 +39,7 @@ static void test_spec_ex_sie(void) report_prefix_push("SIE spec ex interpretation"); report_prefix_push("off"); - reset_guest(); + reset_guest(&vm); sie(&vm); /* interpretation off -> initial exception must cause interception */ report(vm.sblk->icptcode == ICPT_PROGI @@ -56,7 +50,7 @@ static void test_spec_ex_sie(void) report_prefix_push("on"); vm.sblk->ecb |= ECB_SPECI; - reset_guest(); + reset_guest(&vm); sie(&vm); /* interpretation on -> configuration dependent if initial exception causes * interception, but invalid new program PSW must -- 2.53.0 From: Nina Schoetterl-Glausch Detect availability of alternate STFLE interpretive execution facilities 1 and 2. Also fix number of unassigned bits in sclp_facilities which wasn't adjusted in a prior commit adding entries to sclp_facilities. Signed-off-by: Nina Schoetterl-Glausch Signed-off-by: Christoph Schlameuss --- lib/s390x/sclp.c | 2 ++ lib/s390x/sclp.h | 6 +++++- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/lib/s390x/sclp.c b/lib/s390x/sclp.c index 2f902e39e785ff4e139a39be2ffe11b5fa01edc0..7408b813b6396d572d740c19c15175e173fed596 100644 --- a/lib/s390x/sclp.c +++ b/lib/s390x/sclp.c @@ -163,8 +163,10 @@ void sclp_facilities_setup(void) sclp_facilities.has_cmma = sclp_feat_check(116, SCLP_FEAT_116_BIT_CMMA); sclp_facilities.has_64bscao = sclp_feat_check(116, SCLP_FEAT_116_BIT_64BSCAO); sclp_facilities.has_esca = sclp_feat_check(116, SCLP_FEAT_116_BIT_ESCA); + sclp_facilities.has_astfleie1 = sclp_feat_check(116, SCLP_FEAT_116_BIT_ASTFLEIE1); sclp_facilities.has_ibs = sclp_feat_check(117, SCLP_FEAT_117_BIT_IBS); sclp_facilities.has_pfmfi = sclp_feat_check(117, SCLP_FEAT_117_BIT_PFMFI); + sclp_facilities.has_astfleie2 = sclp_feat_check(139, SCLP_FEAT_139_BIT_ASTFLEIE2); for (i = 0; i < read_info->entries_cpu; i++, cpu++) { /* diff --git a/lib/s390x/sclp.h b/lib/s390x/sclp.h index 22f120d1b7ea7d1c3fe822385d0c689e5b3459fe..91a81c902eaa8ee6b999184aeb8a33633efd1065 100644 --- a/lib/s390x/sclp.h +++ b/lib/s390x/sclp.h @@ -129,10 +129,12 @@ struct sclp_facilities { uint64_t has_cmma : 1; uint64_t has_64bscao : 1; uint64_t has_esca : 1; + uint64_t has_astfleie1 : 1; uint64_t has_kss : 1; uint64_t has_pfmfi : 1; uint64_t has_ibs : 1; - uint64_t : 64 - 15; + uint64_t has_astfleie2 : 1; + uint64_t : 64 - 19; }; /* bit number within a certain byte */ @@ -143,8 +145,10 @@ struct sclp_facilities { #define SCLP_FEAT_116_BIT_64BSCAO 0 #define SCLP_FEAT_116_BIT_CMMA 1 #define SCLP_FEAT_116_BIT_ESCA 4 +#define SCLP_FEAT_116_BIT_ASTFLEIE1 7 #define SCLP_FEAT_117_BIT_PFMFI 1 #define SCLP_FEAT_117_BIT_IBS 2 +#define SCLP_FEAT_139_BIT_ASTFLEIE2 1 typedef struct ReadInfo { SCCBHeader h; -- 2.53.0 From: Nina Schoetterl-Glausch The STFLE instruction indicates installed facilities. SIE has facilities for the interpretive execution of STFLE. There are multiple possible formats for the control block. Use a snippet guest executing STFLE to get the result of interpretive execution and check the result. With the addition of the format-2 control block invalid format specifiers are now possible. Test for the occurrence of optional validity intercepts. Signed-off-by: Nina Schoetterl-Glausch Co-developed-by: Christoph Schlameuss Signed-off-by: Christoph Schlameuss --- lib/s390x/sie.c | 11 +++++++ lib/s390x/sie.h | 1 + s390x/stfle-sie.c | 91 ++++++++++++++++++++++++++++++++++++++++++++++++------- 3 files changed, 92 insertions(+), 11 deletions(-) diff --git a/lib/s390x/sie.c b/lib/s390x/sie.c index 0fa915cf028a1b35a76aa316dfd97308094a4682..17f0ef7eff427002dd6d74d98f58ed493457a7ce 100644 --- a/lib/s390x/sie.c +++ b/lib/s390x/sie.c @@ -42,6 +42,17 @@ void sie_check_validity(struct vm *vm, uint16_t vir_exp) report(vir_exp == vir, "VALIDITY: %x", vir); } +void sie_check_optional_validity(struct vm *vm, uint16_t vir_exp) +{ + uint16_t vir = sie_get_validity(vm); + + if (vir == 0xffff) + report_pass("optional VALIDITY: no"); + else + report(vir_exp == vir, "optional VALIDITY: %x", vir); + vm->validity_expected = false; +} + void sie_handle_validity(struct vm *vm) { if (vm->sblk->icptcode != ICPT_VALIDITY) diff --git a/lib/s390x/sie.h b/lib/s390x/sie.h index 3ec49ed0da6459a70689ce5a1a8a027a4113f2a4..8bea0b10b0a6894096ee83933a8bda11711a1949 100644 --- a/lib/s390x/sie.h +++ b/lib/s390x/sie.h @@ -51,6 +51,7 @@ void sie(struct vm *vm); 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_check_optional_validity(struct vm *vm, uint16_t vir_exp); void sie_handle_validity(struct vm *vm); static inline bool sie_is_pv(struct vm *vm) diff --git a/s390x/stfle-sie.c b/s390x/stfle-sie.c index 21cf8ff8b6f6e9d61ee304c5748c36f718da65ab..5b642d9e8c3d775e078c1f09b87ad6822cd28a32 100644 --- a/s390x/stfle-sie.c +++ b/s390x/stfle-sie.c @@ -42,6 +42,7 @@ static struct guest_stfle_res run_guest(void) uint64_t guest_stfle_addr; uint64_t reg; + reset_guest(&vm); sie(&vm); assert(snippet_is_force_exit_value(&vm)); guest_stfle_addr = snippet_get_force_exit_value(&vm); @@ -55,18 +56,73 @@ static struct guest_stfle_res run_guest(void) static void test_stfle_format_0(void) { struct guest_stfle_res res; + int format_mask; 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"); + /* + * There are multiple valid two bit format control values depending on + * the available facilities. + * The facility introduced last defines the validity of control bits. + */ + format_mask = sclp_facilities.has_astfleie2 ? 3 : sclp_facilities.has_astfleie1; + for (int i = 0; i < 4; i++) { + if (i & format_mask) + continue; + report_prefix_pushf("format control %d", i); + for (int j = 0; j < stfle_size(); j++) + WRITE_ONCE((*fac)[j], prng64(&prng_s)); + vm.sblk->fac = (uint32_t)(uint64_t)fac | i; + 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(); + } report_prefix_pop(); } +static void test_stfle_format_2(void) +{ + const int max_stfle_len = 8; + int guest_max_stfle_len = 0; + struct guest_stfle_res res; + bool saturated = false; + + report_prefix_push("format-2"); + for (int i = 1; i <= max_stfle_len; i++) { + report_prefix_pushf("max STFLE len %d", i); + + WRITE_ONCE((*fac)[0], i - 1); + for (int j = 0; j < i; j++) + WRITE_ONCE((*fac)[j + 1], prng64(&prng_s)); + vm.sblk->fac = (uint32_t)(uint64_t)fac | 2; + res = run_guest(); + /* len increases up to maximum (machine specific) */ + if (res.len < i) + saturated = true; + if (saturated) { + report(res.len == guest_max_stfle_len, "stfle len correct"); + } else { + report(res.len == i, "stfle len correct"); + guest_max_stfle_len = i; + } + report(!memcmp(&(*fac)[1], res.mem, guest_max_stfle_len * sizeof(uint64_t)), + "Guest facility list as specified"); + + report_prefix_pop(); + } + report_prefix_pop(); +} + +static void test_no_stfle_format(int format) +{ + reset_guest(&vm); + vm.sblk->fac = (uint32_t)(uint64_t)fac | format; + sie_expect_validity(&vm); + sie(&vm); + sie_check_optional_validity(&vm, 0x1330); +} + struct args { uint64_t seed; }; @@ -119,20 +175,33 @@ static struct args parse_args(int argc, char **argv) int main(int argc, char **argv) { struct args args = parse_args(argc, argv); - bool run_format_0 = test_facility(7); if (!sclp_facilities.has_sief2) { report_skip("SIEF2 facility unavailable"); goto out; } - if (!run_format_0) + if (!test_facility(7)) { report_skip("STFLE facility not available"); + goto out; + } report_info("PRNG seed: 0x%lx", args.seed); prng_s = prng_init(args.seed); setup_guest(); - if (run_format_0) - test_stfle_format_0(); + test_stfle_format_0(); + + if (!sclp_facilities.has_astfleie1) + test_no_stfle_format(1); + + if (!sclp_facilities.has_astfleie2) { + test_no_stfle_format(2); + report_skip("alternate STFLE interpretive-execution facility 2 not available"); + } else { + test_stfle_format_2(); + } + + test_no_stfle_format(3); + out: return report_summary(); } -- 2.53.0