* [kvm-unit-tests PATCH v5 1/2] s390x: topology: Check the Perform Topology Function
2022-10-24 14:20 [kvm-unit-tests PATCH v5 0/2] S390x: CPU Topology Information Pierre Morel
@ 2022-10-24 14:20 ` Pierre Morel
2022-10-24 14:20 ` [kvm-unit-tests PATCH v5 2/2] s390x: topology: Checking Configuration Topology Information Pierre Morel
1 sibling, 0 replies; 3+ messages in thread
From: Pierre Morel @ 2022-10-24 14:20 UTC (permalink / raw)
To: linux-s390; +Cc: frankja, thuth, kvm, cohuck, imbrenda, david, nrb, scgl
We check the PTF instruction.
- We check polarization only for KVM.
- We do not expect KVM to support vertical polarization.
- We do not expect the Topology Change Report to be pending
or not at the moment the first PTF instruction with
PTF_CHECK function code is done as some code already did run
a polarization change may have occur.
Signed-off-by: Pierre Morel <pmorel@linux.ibm.com>
---
s390x/Makefile | 1 +
s390x/topology.c | 132 ++++++++++++++++++++++++++++++++++++++++++++
s390x/unittests.cfg | 3 +
3 files changed, 136 insertions(+)
create mode 100644 s390x/topology.c
diff --git a/s390x/Makefile b/s390x/Makefile
index bf1504f9..4b9a21a7 100644
--- a/s390x/Makefile
+++ b/s390x/Makefile
@@ -39,6 +39,7 @@ tests += $(TEST_DIR)/panic-loop-extint.elf
tests += $(TEST_DIR)/panic-loop-pgm.elf
tests += $(TEST_DIR)/migration-sck.elf
tests += $(TEST_DIR)/exittime.elf
+tests += $(TEST_DIR)/topology.elf
pv-tests += $(TEST_DIR)/pv-diags.elf
diff --git a/s390x/topology.c b/s390x/topology.c
new file mode 100644
index 00000000..ae146d16
--- /dev/null
+++ b/s390x/topology.c
@@ -0,0 +1,132 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * CPU Topology
+ *
+ * Copyright IBM Corp. 2022
+ *
+ * Authors:
+ * Pierre Morel <pmorel@linux.ibm.com>
+ */
+
+#include <libcflat.h>
+#include <asm/page.h>
+#include <asm/asm-offsets.h>
+#include <asm/interrupt.h>
+#include <asm/facility.h>
+#include <smp.h>
+#include <sclp.h>
+#include <s390x/vm.h>
+
+#define PTF_REQ_HORIZONTAL 0
+#define PTF_REQ_VERTICAL 1
+#define PTF_REQ_CHECK 2
+
+#define PTF_ERR_NO_REASON 0
+#define PTF_ERR_ALRDY_POLARIZED 1
+#define PTF_ERR_IN_PROGRESS 2
+
+static int ptf(unsigned long fc, unsigned long *rc)
+{
+ int cc;
+
+ asm volatile(
+ " .insn rre,0xb9a20000,%1,0\n"
+ " ipm %0\n"
+ " srl %0,28\n"
+ : "=d" (cc), "+d" (fc)
+ :
+ : "cc");
+
+ *rc = fc >> 8;
+ return cc;
+}
+
+static void test_ptf(void)
+{
+ unsigned long rc;
+ int cc;
+
+ /* PTF is a privilege instruction */
+ report_prefix_push("Privilege");
+ enter_pstate();
+ expect_pgm_int();
+ ptf(PTF_REQ_CHECK, &rc);
+ check_pgm_int_code(PGM_INT_CODE_PRIVILEGED_OPERATION);
+ report_prefix_pop();
+
+ report_prefix_push("Wrong fc");
+ expect_pgm_int();
+ ptf(0xff, &rc);
+ check_pgm_int_code(PGM_INT_CODE_SPECIFICATION);
+ report_prefix_pop();
+
+ report_prefix_push("Reserved bits");
+ expect_pgm_int();
+ ptf(0xffffffffffffff00UL, &rc);
+ check_pgm_int_code(PGM_INT_CODE_SPECIFICATION);
+ report_prefix_pop();
+
+ report_prefix_push("Topology Report pending");
+ /*
+ * At this moment the topology may already have changed
+ * since the VM has been started.
+ * However, we can test if a second PTF instruction
+ * reports that the topology did not change since the
+ * preceding PFT instruction.
+ */
+ ptf(PTF_REQ_CHECK, &rc);
+ cc = ptf(PTF_REQ_CHECK, &rc);
+ report(cc == 0, "PTF check should clear topology report");
+ report_prefix_pop();
+
+ report_prefix_push("Topology polarisation check");
+ /*
+ * We can not assume the state of the polarization for
+ * any Virtual Machine but KVM.
+ * Let's skip the polarisation tests for other VMs.
+ */
+ if (!vm_is_kvm()) {
+ report_skip("Topology polarisation check is done for KVM only");
+ goto end;
+ }
+ cc = ptf(PTF_REQ_HORIZONTAL, &rc);
+ report(cc == 2 && rc == PTF_ERR_ALRDY_POLARIZED,
+ "KVM always provides horizontal polarization");
+ cc = ptf(PTF_REQ_VERTICAL, &rc);
+ report(cc == 2 && rc == PTF_ERR_NO_REASON,
+ "KVM doesn't support vertical polarization.");
+end:
+ report_prefix_pop();
+}
+
+static struct {
+ const char *name;
+ void (*func)(void);
+} tests[] = {
+ { "PTF", test_ptf},
+ { NULL, NULL }
+};
+
+int main(int argc, char *argv[])
+{
+ int i;
+
+ report_prefix_push("CPU Topology");
+
+ if (!test_facility(11)) {
+ report_skip("Topology facility not present");
+ goto end;
+ }
+
+ report_info("Machine level %ld", stsi_get_fc());
+
+ for (i = 0; tests[i].name; i++) {
+ report_prefix_push(tests[i].name);
+ tests[i].func();
+ report_prefix_pop();
+ }
+
+end:
+ report_prefix_pop();
+ return report_summary();
+}
diff --git a/s390x/unittests.cfg b/s390x/unittests.cfg
index 3caf81ed..3530cc4c 100644
--- a/s390x/unittests.cfg
+++ b/s390x/unittests.cfg
@@ -208,3 +208,6 @@ groups = migration
[exittime]
file = exittime.elf
smp = 2
+
+[topology]
+file = topology.elf
--
2.31.1
^ permalink raw reply related [flat|nested] 3+ messages in thread* [kvm-unit-tests PATCH v5 2/2] s390x: topology: Checking Configuration Topology Information
2022-10-24 14:20 [kvm-unit-tests PATCH v5 0/2] S390x: CPU Topology Information Pierre Morel
2022-10-24 14:20 ` [kvm-unit-tests PATCH v5 1/2] s390x: topology: Check the Perform Topology Function Pierre Morel
@ 2022-10-24 14:20 ` Pierre Morel
1 sibling, 0 replies; 3+ messages in thread
From: Pierre Morel @ 2022-10-24 14:20 UTC (permalink / raw)
To: linux-s390; +Cc: frankja, thuth, kvm, cohuck, imbrenda, david, nrb, scgl
STSI with function code 15 is used to store the CPU configuration
topology.
We check :
- if the topology stored is coherent between the QEMU -smp
parameters and kernel parameters.
- the number of CPUs
- the maximum number of CPUs
- the number of containers of each levels for every STSI(15.1.x)
instruction allowed by the machine.
Signed-off-by: Pierre Morel <pmorel@linux.ibm.com>
---
lib/s390x/stsi.h | 44 ++++++++
s390x/topology.c | 238 +++++++++++++++++++++++++++++++++++++++++++-
s390x/unittests.cfg | 1 +
3 files changed, 281 insertions(+), 2 deletions(-)
diff --git a/lib/s390x/stsi.h b/lib/s390x/stsi.h
index bebc492d..8dbbfc29 100644
--- a/lib/s390x/stsi.h
+++ b/lib/s390x/stsi.h
@@ -29,4 +29,48 @@ struct sysinfo_3_2_2 {
uint8_t ext_names[8][256];
};
+struct topology_core {
+ uint8_t nl;
+ uint8_t reserved1[3];
+ uint8_t reserved4:5;
+ uint8_t d:1;
+ uint8_t pp:2;
+ uint8_t type;
+ uint16_t origin;
+ uint64_t mask;
+};
+
+struct topology_container {
+ uint8_t nl;
+ uint8_t reserved[6];
+ uint8_t id;
+};
+
+union topology_entry {
+ uint8_t nl;
+ struct topology_core cpu;
+ struct topology_container container;
+};
+
+#define CPU_TOPOLOGY_MAX_LEVEL 6
+struct sysinfo_15_1_x {
+ uint8_t reserved0[2];
+ uint16_t length;
+ uint8_t mag[CPU_TOPOLOGY_MAX_LEVEL];
+ uint8_t reserved0a;
+ uint8_t mnest;
+ uint8_t reserved0c[4];
+ union topology_entry tle[0];
+};
+
+static inline int cpus_in_tle_mask(uint64_t val)
+{
+ int i, n;
+
+ for (i = 0, n = 0; i < 64; i++, val >>= 1)
+ if (val & 0x01)
+ n++;
+ return n;
+}
+
#endif /* _S390X_STSI_H_ */
diff --git a/s390x/topology.c b/s390x/topology.c
index ae146d16..842bf99a 100644
--- a/s390x/topology.c
+++ b/s390x/topology.c
@@ -15,7 +15,16 @@
#include <asm/facility.h>
#include <smp.h>
#include <sclp.h>
-#include <s390x/vm.h>
+#include <s390x/hardware.h>
+#include <s390x/stsi.h>
+
+static uint8_t pagebuf[PAGE_SIZE * 2] __attribute__((aligned(PAGE_SIZE * 2)));
+
+static int max_nested_lvl;
+static int number_of_cpus;
+static int max_cpus = 1;
+static int arch_topo_lvl[CPU_TOPOLOGY_MAX_LEVEL]; /* Topology level defined by architecture */
+static int stsi_nested_lvl[CPU_TOPOLOGY_MAX_LEVEL]; /* Topology nested level reported in STSI */
#define PTF_REQ_HORIZONTAL 0
#define PTF_REQ_VERTICAL 1
@@ -85,7 +94,7 @@ static void test_ptf(void)
* any Virtual Machine but KVM.
* Let's skip the polarisation tests for other VMs.
*/
- if (!vm_is_kvm()) {
+ if (!host_is_kvm()) {
report_skip("Topology polarisation check is done for KVM only");
goto end;
}
@@ -99,11 +108,232 @@ end:
report_prefix_pop();
}
+/*
+ * stsi_check_maxcpus
+ * @info: Pointer to the stsi information
+ *
+ * The product of the numbers of containers per level
+ * is the maximum number of CPU allowed by the machine.
+ */
+static void stsi_check_maxcpus(struct sysinfo_15_1_x *info)
+{
+ int n, i;
+
+ report_prefix_push("maximum cpus");
+
+ for (i = 0, n = 1; i < CPU_TOPOLOGY_MAX_LEVEL; i++) {
+ report_info("Mag%d: %d", CPU_TOPOLOGY_MAX_LEVEL - i, info->mag[i]);
+ n *= info->mag[i] ? info->mag[i] : 1;
+ }
+ report(n == max_cpus, "Maximum CPUs %d expected %d", n, max_cpus);
+
+ report_prefix_pop();
+}
+
+/*
+ * stsi_check_tle_coherency
+ * @info: Pointer to the stsi information
+ * @sel2: Topology level to check.
+ *
+ * We verify that we get the expected number of Topology List Entry
+ * containers for a specific level.
+ */
+static void stsi_check_tle_coherency(struct sysinfo_15_1_x *info, int sel2)
+{
+ struct topology_container *tc, *end;
+ struct topology_core *cpus;
+ int n = 0;
+ int i;
+
+ report_prefix_push("TLE coherency");
+
+ tc = &info->tle[0].container;
+ end = (struct topology_container *)((unsigned long)info + info->length);
+
+ for (i = 0; i < CPU_TOPOLOGY_MAX_LEVEL; i++)
+ stsi_nested_lvl[i] = 0;
+
+ while (tc < end) {
+ if (tc->nl > 5) {
+ report_abort("Unexpected TL Entry: tle->nl: %d", tc->nl);
+ return;
+ }
+ if (tc->nl == 0) {
+ cpus = (struct topology_core *)tc;
+ n += cpus_in_tle_mask(cpus->mask);
+ report_info("cpu type %02x d: %d pp: %d", cpus->type, cpus->d, cpus->pp);
+ report_info("origin : %04x mask %016lx", cpus->origin, cpus->mask);
+ }
+
+ stsi_nested_lvl[tc->nl]++;
+ report_info("level %d: lvl: %d id: %d cnt: %d",
+ tc->nl, tc->nl, tc->id, stsi_nested_lvl[tc->nl]);
+
+ /* trick: CPU TLEs are twice the size of containers TLE */
+ if (tc->nl == 0)
+ tc++;
+ tc++;
+ }
+ report(n == number_of_cpus, "Number of CPUs : %d expect %d", n, number_of_cpus);
+ /*
+ * For KVM we accept
+ * - only 1 type of CPU
+ * - only horizontal topology
+ * - only dedicated CPUs
+ * This leads to expect the number of entries of level 0 CPU
+ * Topology Level Entry (TLE) to be:
+ * 1 + (number_of_cpus - 1) / arch_topo_lvl[0]
+ *
+ * For z/VM or LPAR this number can only be greater if different
+ * polarity, CPU types because there may be a nested level 0 CPU TLE
+ * for each of the CPU/polarity/sharing types in a level 1 container TLE.
+ */
+ n = (number_of_cpus - 1) / arch_topo_lvl[0];
+ report(stsi_nested_lvl[0] >= n + 1,
+ "CPU Type TLE : %d expect %d", stsi_nested_lvl[0], n + 1);
+
+ /* For each level found in STSI */
+ for (i = 1; i < CPU_TOPOLOGY_MAX_LEVEL; i++) {
+ /*
+ * For non QEMU/KVM hypervisor the concatenation of the levels
+ * above level 1 are architecture dependent.
+ * Skip these checks.
+ */
+ if (!host_is_kvm() && sel2 != 2)
+ continue;
+
+ /* For QEMU/KVM we expect a simple calculation */
+ if (sel2 > i) {
+ report(stsi_nested_lvl[i] == n + 1,
+ "Container TLE %d: %d expect %d", i, stsi_nested_lvl[i], n + 1);
+ n /= arch_topo_lvl[i];
+ }
+ }
+
+ report_prefix_pop();
+}
+
+/*
+ * check_sysinfo_15_1_x
+ * @info: pointer to the STSI info structure
+ * @sel2: the selector giving the topology level to check
+ *
+ * Check if the validity of the STSI instruction and then
+ * calls specific checks on the information buffer.
+ */
+static void check_sysinfo_15_1_x(struct sysinfo_15_1_x *info, int sel2)
+{
+ int ret;
+
+ report_prefix_pushf("mnested %d 15_1_%d", max_nested_lvl, sel2);
+
+ ret = stsi(pagebuf, 15, 1, sel2);
+ if (max_nested_lvl >= sel2) {
+ report(!ret, "Valid stsi instruction");
+ } else {
+ report(ret, "Invalid stsi instruction");
+ goto end;
+ }
+
+ stsi_check_maxcpus(info);
+ stsi_check_tle_coherency(info, sel2);
+
+end:
+ report_prefix_pop();
+}
+
+/*
+ * test_stsi
+ *
+ * Retrieves the maximum nested topology level supported by the architecture
+ * and the number of CPUs.
+ * Calls the checking for the STSI instruction in sel2 reverse level order
+ * from 6 (CPU_TOPOLOGY_MAX_LEVEL) to 2 to have the most interesting level,
+ * the one triggering a topology-change-report-pending condition, level 2,
+ * at the end of the report.
+ *
+ */
+static void test_stsi(void)
+{
+ int sel2;
+
+ report_info("SCLP maximum nested level : %d", max_nested_lvl);
+
+ number_of_cpus = sclp_get_cpu_num();
+ report_info("SCLP number of CPU: %d", number_of_cpus);
+
+ /* STSI selector 2 can takes values between 2 and 6 */
+ for (sel2 = 6; sel2 >= 2; sel2--)
+ check_sysinfo_15_1_x((struct sysinfo_15_1_x *)pagebuf, sel2);
+}
+
+/*
+ * parse_topology_args
+ * @argc: number of arguments
+ * @argv: argument array
+ *
+ * This function initialize the architecture topology levels
+ * which should be the same as the one provided by the hypervisor.
+ *
+ * We use the current names found in IBM/Z literature, Linux and QEMU:
+ * cores, sockets/packages, books, drawers and nodes to facilitate the
+ * human machine interface but store the result in a machine abstract
+ * array of architecture topology levels.
+ * Note that when QEMU uses socket as a name for the topology level 1
+ * Linux uses package or physical_package.
+ */
+static void parse_topology_args(int argc, char **argv)
+{
+ int i;
+
+ report_info("%d arguments", argc);
+ for (i = 1; i < argc; i++) {
+ if (!strcmp("-mnest", argv[i])) {
+ i++;
+ if (i >= argc)
+ report_abort("-mnest (maximum nested level) needs a parameter");
+ max_nested_lvl = atol(argv[i]);
+ } else if (!strcmp("-cores", argv[i])) {
+ i++;
+ if (i >= argc)
+ report_abort("-cores needs a parameter");
+ arch_topo_lvl[0] = atol(argv[i]);
+ report_info("cores: %d", arch_topo_lvl[0]);
+ } else if (!strcmp("-sockets", argv[i])) {
+ i++;
+ if (i >= argc)
+ report_abort("-sockets needs a parameter");
+ arch_topo_lvl[1] = atol(argv[i]);
+ report_info("sockets: %d", arch_topo_lvl[1]);
+ }
+ }
+
+ for (i = 0; i < CPU_TOPOLOGY_MAX_LEVEL; i++) {
+ if (!arch_topo_lvl[i])
+ arch_topo_lvl[i] = 1;
+ max_cpus *= arch_topo_lvl[i];
+ }
+}
+
+/*
+ * Heuristic, measures on LPAR shows that the maximum nested
+ * levels value is 4.
+ * QEMU have a maximum nexted level of 2.
+ */
+static void set_default_mnest(void)
+{
+ if (host_is_qemu())
+ max_nested_lvl = 2;
+ else if (host_is_lpar())
+ max_nested_lvl = 4;
+}
+
static struct {
const char *name;
void (*func)(void);
} tests[] = {
{ "PTF", test_ptf},
+ { "STSI", test_stsi},
{ NULL, NULL }
};
@@ -113,6 +343,10 @@ int main(int argc, char *argv[])
report_prefix_push("CPU Topology");
+ set_default_mnest();
+
+ parse_topology_args(argc, argv);
+
if (!test_facility(11)) {
report_skip("Topology facility not present");
goto end;
diff --git a/s390x/unittests.cfg b/s390x/unittests.cfg
index 3530cc4c..6dadf23d 100644
--- a/s390x/unittests.cfg
+++ b/s390x/unittests.cfg
@@ -211,3 +211,4 @@ smp = 2
[topology]
file = topology.elf
+extra_params=-smp 5,sockets=4,cores=4,maxcpus=16 -append '-mnest 2 -sockets 4 -cores 4'
--
2.31.1
^ permalink raw reply related [flat|nested] 3+ messages in thread