[kvm-unit-tests RFC 00/10] KVM: arm64: PMUv3 Event Counter Tests

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
14 messages Options
Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 00/10] KVM: arm64: PMUv3 Event Counter Tests

Auger Eric
This series implements tests exercising the PMUv3 event counters.
It tests both the 32-bit and 64-bit versions. Overflow interrupts
also are checked. Those tests only are written for arm64.

It allowed to reveal some issues related to SW_INCR implementation
(esp. related to 64-bit implementation), some problems related to
32-bit <-> 64-bit transitions and consistency of enabled states
of odd and event counters.

Overflow interrupt testing relies of one patch from Andre
("arm: gic: Provide per-IRQ helper functions") to enable the
PPI 23, coming from "arm: gic: Test SPIs and interrupt groups"
(https://patchwork.kernel.org/cover/11234975/). Drew kindly
provided "arm64: Provide read/write_sysreg_s".

All PMU tests can be launched with:
./run_tests.sh -g pmu
Tests also can be launched individually. For example:
./arm-run arm/pmu.flat -append 'chained-sw-incr'

With KVM:
- chain-promotion and chained-sw-incr are known to be failing.
- Problems were reported upstream.
With TCG:
- pmu-event-introspection is failing due to missing required events
  (we may remove this from TCG actually)
- chained-sw-incr also fails. I haven't investigated yet.

Andre Przywara (1):
  arm: gic: Provide per-IRQ helper functions

Andrew Jones (1):
  arm64: Provide read/write_sysreg_s

Eric Auger (8):
  pmu: Let pmu tests take a sub-test parameter
  pmu: Add a pmu struct
  pmu: Check Required Event Support
  pmu: Basic event counter Tests
  pmu: Test chained counter
  arm: pmu: test 32-bit <-> 64-bit transitions
  arm/arm64: gic: Introduce setup_irq() helper
  pmu: Test overflow interrupts

 arm/gic.c              |  24 +-
 arm/pmu.c              | 754 ++++++++++++++++++++++++++++++++++++++++-
 arm/unittests.cfg      |  55 ++-
 lib/arm/asm/gic-v3.h   |   2 +
 lib/arm/asm/gic.h      |  12 +
 lib/arm/gic.c          | 101 ++++++
 lib/arm64/asm/sysreg.h |  11 +
 7 files changed, 922 insertions(+), 37 deletions(-)

--
2.20.1


Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 01/10] arm64: Provide read/write_sysreg_s

Auger Eric
From: Andrew Jones <[hidden email]>

Sometimes we need to test access to system registers which are
missing assembler mnemonics.

Signed-off-by: Andrew Jones <[hidden email]>
---
 lib/arm64/asm/sysreg.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/lib/arm64/asm/sysreg.h b/lib/arm64/asm/sysreg.h
index a03830b..a45eebd 100644
--- a/lib/arm64/asm/sysreg.h
+++ b/lib/arm64/asm/sysreg.h
@@ -38,6 +38,17 @@
  asm volatile("msr " xstr(r) ", %x0" : : "rZ" (__val)); \
 } while (0)
 
+#define read_sysreg_s(r) ({ \
+ u64 __val; \
+ asm volatile("mrs_s %0, " xstr(r) : "=r" (__val)); \
+ __val; \
+})
+
+#define write_sysreg_s(v, r) do { \
+ u64 __val = (u64)v; \
+ asm volatile("msr_s " xstr(r) ", %x0" : : "rZ" (__val));\
+} while (0)
+
 asm(
 " .irp num,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30\n"
 " .equ .L__reg_num_x\\num, \\num\n"
--
2.20.1


Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 02/10] pmu: Let pmu tests take a sub-test parameter

Auger Eric
In reply to this post by Auger Eric
As we intend to introduce more PMU tests, let's add
a sub-test parameter that will allow to categorize
them. Existing tests are in the cycle-counter category.

Signed-off-by: Eric Auger <[hidden email]>
---
 arm/pmu.c         | 22 ++++++++++++++--------
 arm/unittests.cfg |  7 ++++---
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/arm/pmu.c b/arm/pmu.c
index 1de7d77..2ad6469 100644
--- a/arm/pmu.c
+++ b/arm/pmu.c
@@ -287,21 +287,27 @@ int main(int argc, char *argv[])
 {
  int cpi = 0;
 
- if (argc > 1)
- cpi = atol(argv[1]);
-
  if (!pmu_probe()) {
  printf("No PMU found, test skipped...\n");
  return report_summary();
  }
 
+ if (argc < 2)
+ report_abort("no test specified");
+
  report_prefix_push("pmu");
 
- report("Control register", check_pmcr());
- report("Monotonically increasing cycle count", check_cycles_increase());
- report("Cycle/instruction ratio", check_cpi(cpi));
-
- pmccntr64_test();
+ if (strcmp(argv[1], "cycle-counter") == 0) {
+ report_prefix_push(argv[1]);
+ if (argc > 2)
+ cpi = atol(argv[2]);
+ report("Control register", check_pmcr());
+ report("Monotonically increasing cycle count", check_cycles_increase());
+ report("Cycle/instruction ratio", check_cpi(cpi));
+ pmccntr64_test();
+ } else {
+ report_abort("Unknown subtest '%s'", argv[1]);
+ }
 
  return report_summary();
 }
diff --git a/arm/unittests.cfg b/arm/unittests.cfg
index daeb5a0..79f0d7a 100644
--- a/arm/unittests.cfg
+++ b/arm/unittests.cfg
@@ -61,21 +61,22 @@ file = pci-test.flat
 groups = pci
 
 # Test PMU support
-[pmu]
+[pmu-cycle-counter]
 file = pmu.flat
 groups = pmu
+extra_params = -append 'cycle-counter 0'
 
 # Test PMU support (TCG) with -icount IPC=1
 #[pmu-tcg-icount-1]
 #file = pmu.flat
-#extra_params = -icount 0 -append '1'
+#extra_params = -icount 0 -append 'cycle-counter 1'
 #groups = pmu
 #accel = tcg
 
 # Test PMU support (TCG) with -icount IPC=256
 #[pmu-tcg-icount-256]
 #file = pmu.flat
-#extra_params = -icount 8 -append '256'
+#extra_params = -icount 8 -append 'cycle-counter 256'
 #groups = pmu
 #accel = tcg
 
--
2.20.1


Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 03/10] pmu: Add a pmu struct

Auger Eric
In reply to this post by Auger Eric
This struct aims at storing information potentially used by
all tests such as the pmu version, the read-only part of the
PMCR, the number of implemented event counters, ...

Signed-off-by: Eric Auger <[hidden email]>
---
 arm/pmu.c | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/arm/pmu.c b/arm/pmu.c
index 2ad6469..8e95251 100644
--- a/arm/pmu.c
+++ b/arm/pmu.c
@@ -33,7 +33,15 @@
 
 #define NR_SAMPLES 10
 
-static unsigned int pmu_version;
+struct pmu {
+ unsigned int version;
+ unsigned int nb_implemented_counters;
+ uint32_t pmcr_ro;
+};
+
+static struct pmu pmu;
+
+
 #if defined(__arm__)
 #define ID_DFR0_PERFMON_SHIFT 24
 #define ID_DFR0_PERFMON_MASK  0xf
@@ -265,7 +273,7 @@ static bool check_cpi(int cpi)
 static void pmccntr64_test(void)
 {
 #ifdef __arm__
- if (pmu_version == 0x3) {
+ if (pmu.version == 0x3) {
  if (ERRATA(9e3f7a296940)) {
  write_sysreg(0xdead, PMCCNTR64);
  report("pmccntr64", read_sysreg(PMCCNTR64) == 0xdead);
@@ -278,9 +286,20 @@ static void pmccntr64_test(void)
 /* Return FALSE if no PMU found, otherwise return TRUE */
 static bool pmu_probe(void)
 {
- pmu_version = get_pmu_version();
- report_info("PMU version: %d", pmu_version);
- return pmu_version != 0 && pmu_version != 0xf;
+ uint32_t pmcr;
+
+ pmu.version = get_pmu_version();
+ report_info("PMU version: %d", pmu.version);
+
+ if (pmu.version == 0 || pmu.version  == 0xF)
+ return false;
+
+ pmcr = get_pmcr();
+ pmu.pmcr_ro = pmcr & 0xFFFFFF80;
+ pmu.nb_implemented_counters = (pmcr >> PMU_PMCR_N_SHIFT) & PMU_PMCR_N_MASK;
+ report_info("Implements %d event counters", pmu.nb_implemented_counters);
+
+ return true;
 }
 
 int main(int argc, char *argv[])
--
2.20.1


Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 04/10] pmu: Check Required Event Support

Auger Eric
In reply to this post by Auger Eric
If event counters are implemented check the common events
required by the PMUv3 are implemented.

Some are unconditionally required (SW_INCR, CPU_CYCLES,
either INST_RETIRED or INST_SPEC). Some others only are
required if the implementation implements some other features.

Check those wich are unconditionally required.

This test currently fails on TCG as neither INST_RETIRED
or INST_SPEC are supported.

Signed-off-by: Eric Auger <[hidden email]>
---
 arm/pmu.c         | 70 +++++++++++++++++++++++++++++++++++++++++++++++
 arm/unittests.cfg |  6 ++++
 2 files changed, 76 insertions(+)

diff --git a/arm/pmu.c b/arm/pmu.c
index 8e95251..f78c43f 100644
--- a/arm/pmu.c
+++ b/arm/pmu.c
@@ -102,6 +102,10 @@ static inline void precise_instrs_loop(int loop, uint32_t pmcr)
  : [pmcr] "r" (pmcr), [z] "r" (0)
  : "cc");
 }
+
+/* event counter tests only implemented for aarch64 */
+static void test_event_introspection(void) {}
+
 #elif defined(__aarch64__)
 #define ID_AA64DFR0_PERFMON_SHIFT 8
 #define ID_AA64DFR0_PERFMON_MASK  0xf
@@ -140,6 +144,69 @@ static inline void precise_instrs_loop(int loop, uint32_t pmcr)
  : [pmcr] "r" (pmcr)
  : "cc");
 }
+
+#define PMCEID1_EL0 sys_reg(11, 3, 9, 12, 7)
+
+static bool is_event_supported(uint32_t n, bool warn)
+{
+ uint64_t pmceid0 = read_sysreg(pmceid0_el0);
+ uint64_t pmceid1 = read_sysreg_s(PMCEID1_EL0);
+ bool supported;
+ uint32_t reg;
+
+ if (n >= 0x0  && n <= 0x1F) {
+ reg = pmceid0 & 0xFFFFFFFF;
+ } else if  (n >= 0x4000 && n <= 0x401F) {
+ reg = pmceid0 >> 32;
+ } else if (n >= 0x20  && n <= 0x3F) {
+ reg = pmceid1 & 0xFFFFFFFF;
+ } else if (n >= 0x4020 && n <= 0x403F) {
+ reg = pmceid1 >> 32;
+ } else {
+ abort();
+ }
+ supported =  reg & (1 << n);
+ if (!supported && warn)
+ report_info("event %d is not supported", n);
+ return supported;
+}
+
+static void test_event_introspection(void)
+{
+ bool required_events;
+
+ if (!pmu.nb_implemented_counters) {
+ report_skip("No event counter, skip ...");
+ return;
+ }
+ if (pmu.nb_implemented_counters < 2)
+ report_info("%d event counters are implemented. "
+                            "ARM recommends to implement at least 2",
+                            pmu.nb_implemented_counters);
+
+ /* PMUv3 requires an implementation includes some common events */
+ required_events = is_event_supported(0x0, true) /* SW_INCR */ &&
+  is_event_supported(0x11, true) /* CPU_CYCLES */ &&
+  (is_event_supported(0x8, true) /* INST_RETIRED */ ||
+   is_event_supported(0x1B, true) /* INST_PREC */);
+ if (!is_event_supported(0x8, false))
+ report_info("ARM strongly recomments INST_RETIRED (0x8) event "
+    "to be implemented");
+
+ if (pmu.version == 0x4) {
+ /* ARMv8.1 PMU: STALL_FRONTEND and STALL_BACKEND are required */
+ required_events = required_events ||
+  is_event_supported(0x23, true) ||
+  is_event_supported(0x24, true);
+ }
+
+ /* L1D_CACHE_REFILL(0x3) and L1D_CACHE(0x4) are only required if
+   L1 data / unified cache. BR_MIS_PRED(0x10), BR_PRED(0x12) are only
+   required if program-flow prediction is implemented. */
+
+ report("Check required events are implemented", required_events);
+}
+
 #endif
 
 /*
@@ -324,6 +391,9 @@ int main(int argc, char *argv[])
  report("Monotonically increasing cycle count", check_cycles_increase());
  report("Cycle/instruction ratio", check_cpi(cpi));
  pmccntr64_test();
+ } else if (strcmp(argv[1], "event-introspection") == 0) {
+ report_prefix_push(argv[1]);
+ test_event_introspection();
  } else {
  report_abort("Unknown subtest '%s'", argv[1]);
  }
diff --git a/arm/unittests.cfg b/arm/unittests.cfg
index 79f0d7a..4433ef3 100644
--- a/arm/unittests.cfg
+++ b/arm/unittests.cfg
@@ -66,6 +66,12 @@ file = pmu.flat
 groups = pmu
 extra_params = -append 'cycle-counter 0'
 
+[pmu-event-introspection]
+file = pmu.flat
+groups = pmu
+arch = arm64
+extra_params = -append 'event-introspection'
+
 # Test PMU support (TCG) with -icount IPC=1
 #[pmu-tcg-icount-1]
 #file = pmu.flat
--
2.20.1


Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 05/10] pmu: Basic event counter Tests

Auger Eric
In reply to this post by Auger Eric
Adds the following tests:
- event-counter-config: test event counter configuration
- basic-event-count:
  - programs counters #0 and #1 to count 2 required events
  (resp. CPU_CYCLES and INST_RETIRED). Counter #0 is preset
  to a value close enough to the 32b
  overflow limit so that we check the overflow bit is set
  after the execution of the asm loop.
- mem-access: counts MEM_ACCESS event on counters #0 and #1
  with and without 32-bit overflow.

Signed-off-by: Eric Auger <[hidden email]>
---
 arm/pmu.c         | 254 ++++++++++++++++++++++++++++++++++++++++++++++
 arm/unittests.cfg |  18 ++++
 2 files changed, 272 insertions(+)

diff --git a/arm/pmu.c b/arm/pmu.c
index f78c43f..8ffeb93 100644
--- a/arm/pmu.c
+++ b/arm/pmu.c
@@ -18,9 +18,15 @@
 #include "asm/barrier.h"
 #include "asm/sysreg.h"
 #include "asm/processor.h"
+#include <bitops.h>
+#include <asm/gic.h>
 
 #define PMU_PMCR_E         (1 << 0)
+#define PMU_PMCR_P         (1 << 1)
 #define PMU_PMCR_C         (1 << 2)
+#define PMU_PMCR_D         (1 << 3)
+#define PMU_PMCR_X         (1 << 4)
+#define PMU_PMCR_DP        (1 << 5)
 #define PMU_PMCR_LC        (1 << 6)
 #define PMU_PMCR_N_SHIFT   11
 #define PMU_PMCR_N_MASK    0x1f
@@ -105,6 +111,9 @@ static inline void precise_instrs_loop(int loop, uint32_t pmcr)
 
 /* event counter tests only implemented for aarch64 */
 static void test_event_introspection(void) {}
+static void test_event_counter_config(void) {}
+static void test_basic_event_count(void) {}
+static void test_mem_access(void) {}
 
 #elif defined(__aarch64__)
 #define ID_AA64DFR0_PERFMON_SHIFT 8
@@ -146,6 +155,32 @@ static inline void precise_instrs_loop(int loop, uint32_t pmcr)
 }
 
 #define PMCEID1_EL0 sys_reg(11, 3, 9, 12, 7)
+#define PMCNTENSET_EL0 sys_reg(11, 3, 9, 12, 1)
+#define PMCNTENCLR_EL0 sys_reg(11, 3, 9, 12, 2)
+
+#define PMEVTYPER_EXCLUDE_EL1 (1 << 31)
+#define PMEVTYPER_EXCLUDE_EL0 (1 << 30)
+
+#define regn_el0(__reg, __n) __reg ## __n  ## _el0
+#define write_regn(__reg, __n, __val) \
+ write_sysreg((__val), __reg ## __n ## _el0)
+
+#define read_regn(__reg, __n) \
+ read_sysreg(__reg ## __n ## _el0)
+
+#define print_pmevtyper(__s , __n) do { \
+ uint32_t val; \
+ val = read_regn(pmevtyper, __n);\
+ report_info("%s pmevtyper%d=0x%x, eventcount=0x%x (p=%ld, u=%ld nsk=%ld, nsu=%ld, nsh=%ld m=%ld, mt=%ld)", \
+ (__s), (__n), val, val & 0xFFFF,  \
+ (BIT_MASK(31) & val) >> 31, \
+ (BIT_MASK(30) & val) >> 30, \
+ (BIT_MASK(29) & val) >> 29, \
+ (BIT_MASK(28) & val) >> 28, \
+ (BIT_MASK(27) & val) >> 27, \
+ (BIT_MASK(26) & val) >> 26, \
+ (BIT_MASK(25) & val) >> 25); \
+ } while (0)
 
 static bool is_event_supported(uint32_t n, bool warn)
 {
@@ -207,6 +242,216 @@ static void test_event_introspection(void)
  report("Check required events are implemented", required_events);
 }
 
+static inline void mem_access_loop(void *addr, int loop, uint32_t pmcr)
+{
+asm volatile(
+ "       msr     pmcr_el0, %[pmcr]\n"
+ "       isb\n"
+ "       mov     x10, %[loop]\n"
+ "1:     sub     x10, x10, #1\n"
+ "       mov x8, %[addr]\n"
+ "       ldr x9, [x8]\n"
+ "       cmp     x10, #0x0\n"
+ "       b.gt    1b\n"
+ "       msr     pmcr_el0, xzr\n"
+ "       isb\n"
+ :
+ : [addr] "r" (addr), [pmcr] "r" (pmcr), [loop] "r" (loop)
+ : );
+}
+
+
+static void pmu_reset(void)
+{
+ /* reset all counters, counting disabled at PMCR level*/
+ set_pmcr(pmu.pmcr_ro | PMU_PMCR_LC | PMU_PMCR_C | PMU_PMCR_P);
+ /* Disable all counters */
+ write_sysreg_s(0xFFFFFFFF, PMCNTENCLR_EL0);
+ /* clear overflow reg */
+ write_sysreg(0xFFFFFFFF, pmovsclr_el0);
+ /* disable overflow interrupts on all counters */
+ write_sysreg(0xFFFFFFFF, pmintenclr_el1);
+ isb();
+}
+
+static void test_event_counter_config(void) {
+ int i;
+
+ if (!pmu.nb_implemented_counters) {
+ report_skip("No event counter, skip ...");
+ return;
+ }
+
+ pmu_reset();
+
+ /* Test setting through PMESELR/PMXEVTYPER and PMEVTYPERn read */
+        /* select counter 0 */
+        write_sysreg(1, PMSELR_EL0);
+        /* program this counter to count unsupported event */
+        write_sysreg(0xEA, PMXEVTYPER_EL0);
+        write_sysreg(0xdeadbeef, PMXEVCNTR_EL0);
+ report("PMESELR/PMXEVTYPER/PMEVTYPERn",
+ (read_regn(pmevtyper, 1) & 0xFFF) == 0xEA);
+ report("PMESELR/PMXEVCNTR/PMEVCNTRn",
+ (read_regn(pmevcntr, 1) == 0xdeadbeef));
+
+ /* try configure an unsupported event within the range [0x0, 0x3F] */
+ for (i = 0; i <= 0x3F; i++) {
+ if (!is_event_supported(i, false))
+ goto test_unsupported;
+ }
+ report_skip("pmevtyper: all events within [0x0, 0x3F] are supported");
+
+test_unsupported:
+ /* select counter 0 */
+ write_sysreg(0, PMSELR_EL0);
+ /* program this counter to count unsupported event */
+ write_sysreg(i, PMXEVCNTR_EL0);
+ /* read the counter value */
+ read_sysreg(PMXEVCNTR_EL0);
+ report("read of a counter programmed with unsupported event", read_sysreg(PMXEVCNTR_EL0) == i);
+
+}
+
+static bool satisfy_prerequisites(uint32_t *events, unsigned int nb_events)
+{
+ int i;
+
+ if (pmu.nb_implemented_counters < nb_events) {
+ report_skip("Skip test as number of counters is too small (%d)",
+    pmu.nb_implemented_counters);
+ return false;
+ }
+
+ for (i = 0; i < nb_events; i++) {
+ if (!is_event_supported(events[i], false)) {
+ report_skip("Skip test as event %d is not supported",
+    events[i]);
+ return false;
+ }
+ }
+ return true;
+}
+
+static void test_basic_event_count(void)
+{
+ uint32_t implemented_counter_mask, non_implemented_counter_mask;
+ uint32_t counter_mask;
+ uint32_t events[] = {
+ 0x11, /* CPU_CYCLES */
+ 0x8, /* INST_RETIRED */
+ };
+
+ if (!satisfy_prerequisites(events, ARRAY_SIZE(events)))
+ return;
+
+ implemented_counter_mask = (1 << pmu.nb_implemented_counters) - 1;
+ non_implemented_counter_mask = ~((1 << 31) | implemented_counter_mask);
+ counter_mask = implemented_counter_mask | non_implemented_counter_mask;
+
+        write_regn(pmevtyper, 0, events[0] | PMEVTYPER_EXCLUDE_EL0);
+        write_regn(pmevtyper, 1, events[1] | PMEVTYPER_EXCLUDE_EL0);
+
+ /* disable all counters */
+ write_sysreg_s(0xFFFFFFFF, PMCNTENCLR_EL0);
+ report("pmcntenclr: disable all counters",
+       !read_sysreg_s(PMCNTENCLR_EL0) && !read_sysreg_s(PMCNTENSET_EL0));
+
+ /*
+ * clear cycle and all event counters and allow counter enablement
+ * through PMCNTENSET. LC is RES1.
+ */
+ set_pmcr(pmu.pmcr_ro | PMU_PMCR_LC | PMU_PMCR_C | PMU_PMCR_P);
+ isb();
+ report("pmcr: reset counters", get_pmcr() == (pmu.pmcr_ro | PMU_PMCR_LC));
+
+ /* Preset counter #0 to 0xFFFFFFF0 to trigger an overflow interrupt */
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ report("counter #0 preset to 0xFFFFFFF0",
+ read_regn(pmevcntr, 0) == 0xFFFFFFF0);
+ report("counter #1 is 0", !read_regn(pmevcntr, 1));
+
+ /*
+ * Enable all implemented counters and also attempt to enable
+ * not supported counters. Counting still is disabled by !PMCR.E
+ */
+ write_sysreg_s(counter_mask, PMCNTENSET_EL0);
+
+ /* check only those implemented are enabled */
+ report("pmcntenset: enabled implemented_counters",
+       (read_sysreg_s(PMCNTENSET_EL0) == read_sysreg_s(PMCNTENCLR_EL0)) &&
+ (read_sysreg_s(PMCNTENSET_EL0) == implemented_counter_mask));
+
+ /* Disable all counters but counters #0 and #1 */
+ write_sysreg_s(~0x3, PMCNTENCLR_EL0);
+ report("pmcntenset: just enabled #0 and #1",
+       (read_sysreg_s(PMCNTENSET_EL0) == read_sysreg_s(PMCNTENCLR_EL0)) &&
+ (read_sysreg_s(PMCNTENSET_EL0) == 0x3));
+
+ /* clear overflow register */
+ write_sysreg(0xFFFFFFFF, pmovsclr_el0);
+ report("check overflow reg is 0", !read_sysreg(pmovsclr_el0));
+
+ /* disable overflow interrupts on all counters*/
+ write_sysreg(0xFFFFFFFF, pmintenclr_el1);
+ report("pmintenclr_el1=0, all interrupts disabled",
+ !read_sysreg(pmintenclr_el1));
+
+ /* enable overflow interrupts on all event counters */
+ write_sysreg(implemented_counter_mask | non_implemented_counter_mask,
+     pmintenset_el1);
+ report("overflow interrupts enabled on all implemented counters",
+ read_sysreg(pmintenset_el1) == implemented_counter_mask);
+
+ /* Set PMCR.E, execute asm code and unset PMCR.E */
+ precise_instrs_loop(20, pmu.pmcr_ro | PMU_PMCR_E);
+
+ report_info("counter #0 is 0x%lx (CPU_CYCLES)", read_regn(pmevcntr, 0));
+ report_info("counter #1 is 0x%lx (INST_RETIRED)", read_regn(pmevcntr, 1));
+
+ report_info("overflow reg = 0x%lx", read_sysreg(pmovsclr_el0) );
+ report("check overflow happened on #0 only", read_sysreg(pmovsclr_el0) & 0x1);
+}
+
+static void test_mem_access(void)
+{
+ void *addr = malloc(PAGE_SIZE);
+ uint32_t events[] = {
+                0x13,   /* MEM_ACCESS */
+                0x13,   /* MEM_ACCESS */
+        };
+
+ if (!satisfy_prerequisites(events, ARRAY_SIZE(events)))
+ return;
+
+ pmu_reset();
+
+        write_regn(pmevtyper, 0, events[0] | PMEVTYPER_EXCLUDE_EL0);
+        write_regn(pmevtyper, 1, events[1] | PMEVTYPER_EXCLUDE_EL0);
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+ isb();
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report_info("counter #0 is %ld (MEM_ACCESS)", read_regn(pmevcntr, 0));
+ report_info("counter #1 is %ld (MEM_ACCESS)", read_regn(pmevcntr, 1));
+ /* We may not measure exactly 20 mem access, this depends on the platform */
+ report("Ran 20 mem accesses",
+       (read_regn(pmevcntr, 0) == read_regn(pmevcntr, 1)) &&
+       (read_regn(pmevcntr, 0) >= 20) && !read_sysreg(pmovsclr_el0));
+
+ pmu_reset();
+
+ write_regn(pmevcntr, 0, 0xFFFFFFFA);
+ write_regn(pmevcntr, 1, 0xFFFFFFF0);
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+ isb();
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report("Ran 20 mem accesses with expected overflows on both counters",
+       read_sysreg(pmovsclr_el0) == 0x3);
+ report_info("cnt#0 = %ld cnt#1=%ld overflow=0x%lx",
+ read_regn(pmevcntr, 0), read_regn(pmevcntr, 1),
+ read_sysreg(pmovsclr_el0));
+}
+
 #endif
 
 /*
@@ -394,6 +639,15 @@ int main(int argc, char *argv[])
  } else if (strcmp(argv[1], "event-introspection") == 0) {
  report_prefix_push(argv[1]);
  test_event_introspection();
+        } else if (strcmp(argv[1], "event-counter-config") == 0) {
+                report_prefix_push(argv[1]);
+ test_event_counter_config();
+ } else if (strcmp(argv[1], "basic-event-count") == 0) {
+ report_prefix_push(argv[1]);
+ test_basic_event_count();
+ } else if (strcmp(argv[1], "mem-access") == 0) {
+ report_prefix_push(argv[1]);
+ test_mem_access();
  } else {
  report_abort("Unknown subtest '%s'", argv[1]);
  }
diff --git a/arm/unittests.cfg b/arm/unittests.cfg
index 4433ef3..7a59403 100644
--- a/arm/unittests.cfg
+++ b/arm/unittests.cfg
@@ -72,6 +72,24 @@ groups = pmu
 arch = arm64
 extra_params = -append 'event-introspection'
 
+[pmu-event-counter-config]
+file = pmu.flat
+groups = pmu
+arch = arm64
+extra_params = -append 'event-counter-config'
+
+[pmu-basic-event-count]
+file = pmu.flat
+groups = pmu
+arch = arm64
+extra_params = -append 'basic-event-count'
+
+[pmu-mem-access]
+file = pmu.flat
+groups = pmu
+arch = arm64
+extra_params = -append 'mem-access'
+
 # Test PMU support (TCG) with -icount IPC=1
 #[pmu-tcg-icount-1]
 #file = pmu.flat
--
2.20.1


Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 06/10] pmu: Test chained counter

Auger Eric
In reply to this post by Auger Eric
Add 2 tests exercising chained counters. The first one uses
CPU_CYCLES and the second one uses SW_INCR.

Signed-off-by: Eric Auger <[hidden email]>
---
 arm/pmu.c         | 125 ++++++++++++++++++++++++++++++++++++++++++++++
 arm/unittests.cfg |  12 +++++
 2 files changed, 137 insertions(+)

diff --git a/arm/pmu.c b/arm/pmu.c
index 8ffeb93..e185809 100644
--- a/arm/pmu.c
+++ b/arm/pmu.c
@@ -114,6 +114,8 @@ static void test_event_introspection(void) {}
 static void test_event_counter_config(void) {}
 static void test_basic_event_count(void) {}
 static void test_mem_access(void) {}
+static void test_chained_counters(void) {}
+static void test_chained_sw_incr(void) {}
 
 #elif defined(__aarch64__)
 #define ID_AA64DFR0_PERFMON_SHIFT 8
@@ -452,6 +454,123 @@ static void test_mem_access(void)
  read_sysreg(pmovsclr_el0));
 }
 
+static void test_chained_counters(void)
+{
+ uint32_t events[] = { 0x11 /* CPU_CYCLES */, 0x1E /* CHAIN */};
+
+ if (!satisfy_prerequisites(events, ARRAY_SIZE(events)))
+ return;
+
+ pmu_reset();
+
+        write_regn(pmevtyper, 0, events[0] | PMEVTYPER_EXCLUDE_EL0);
+        write_regn(pmevtyper, 1, events[1] | PMEVTYPER_EXCLUDE_EL0);
+ /* enable counters #0 and #1 */
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+ /* preset counter #0 at 0xFFFFFFF0 */
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+
+ precise_instrs_loop(22, pmu.pmcr_ro | PMU_PMCR_E);
+
+ report("CHAIN counter #1 incremented", read_regn(pmevcntr, 1) == 1);
+ report("check no overflow is recorded", !read_sysreg(pmovsclr_el0));
+
+ /* test 64b overflow */
+
+ pmu_reset();
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ write_regn(pmevcntr, 1, 0x1);
+ precise_instrs_loop(22, pmu.pmcr_ro | PMU_PMCR_E);
+ report_info("overflow reg = 0x%lx", read_sysreg(pmovsclr_el0));
+ report("CHAIN counter #1 incremented", read_regn(pmevcntr, 1) == 2);
+ report("check no overflow is recorded", !read_sysreg(pmovsclr_el0));
+
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ write_regn(pmevcntr, 1, 0xFFFFFFFF);
+
+ precise_instrs_loop(22, pmu.pmcr_ro | PMU_PMCR_E);
+ report_info("overflow reg = 0x%lx", read_sysreg(pmovsclr_el0));
+ report("CHAIN counter #1 wrapped", !read_regn(pmevcntr, 1));
+ report("check no overflow is recorded", read_sysreg(pmovsclr_el0) == 0x2);
+}
+
+static void test_chained_sw_incr(void)
+{
+ uint32_t events[] = { 0x0 /* SW_INCR */, 0x0 /* SW_INCR */};
+ int i;
+
+ if (!satisfy_prerequisites(events, ARRAY_SIZE(events)))
+ return;
+
+ pmu_reset();
+
+        write_regn(pmevtyper, 0, events[0] | PMEVTYPER_EXCLUDE_EL0);
+        write_regn(pmevtyper, 1, events[1] | PMEVTYPER_EXCLUDE_EL0);
+ /* enable counters #0 and #1 */
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+
+ /* preset counter #0 at 0xFFFFFFF0 */
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+
+ for (i = 0; i < 100; i++) {
+ write_sysreg(0x1, pmswinc_el0);
+ }
+ report_info("SW_INCR counter #0 has value %ld", read_regn(pmevcntr, 0));
+ report("PWSYNC does not increment if PMCR.E is unset",
+ read_regn(pmevcntr, 0) == 0xFFFFFFF0);
+
+ pmu_reset();
+
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+ set_pmcr(pmu.pmcr_ro | PMU_PMCR_E);
+
+ for (i = 0; i < 100; i++) {
+ write_sysreg(0x3, pmswinc_el0);
+ }
+ report("counter #1 after + 100 SW_INCR", read_regn(pmevcntr, 0)  == 84);
+ report("counter #0 after + 100 SW_INCR", read_regn(pmevcntr, 1)  == 100);
+ report_info(" counter values after 100 SW_INCR #0=%ld #1=%ld",
+ read_regn(pmevcntr, 0), read_regn(pmevcntr, 1));
+ report("overflow reg after 100 SW_INCR", read_sysreg(pmovsclr_el0) == 0x1);
+
+ /* 64b SW_INCR */
+ pmu_reset();
+
+ events[1] = 0x1E /* CHAIN */;
+        write_regn(pmevtyper, 1, events[1] | PMEVTYPER_EXCLUDE_EL0);
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+ set_pmcr(pmu.pmcr_ro | PMU_PMCR_E);
+ for (i = 0; i < 100; i++) {
+ write_sysreg(0x3, pmswinc_el0);
+ }
+ report("overflow reg after 100 SW_INCR/CHAIN",
+ !read_sysreg(pmovsclr_el0) && (read_regn(pmevcntr, 1) == 1));
+ report_info("overflow=0x%lx, #0=%ld #1=%ld", read_sysreg(pmovsclr_el0),
+    read_regn(pmevcntr, 0), read_regn(pmevcntr, 1));
+
+ /* 64b SW_INCR and overflow on CHAIN counter*/
+ pmu_reset();
+
+        write_regn(pmevtyper, 1, events[1] | PMEVTYPER_EXCLUDE_EL0);
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ write_regn(pmevcntr, 1, 0xFFFFFFFF);
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+ set_pmcr(pmu.pmcr_ro | PMU_PMCR_E);
+ for (i = 0; i < 100; i++) {
+ write_sysreg(0x3, pmswinc_el0);
+ }
+ report("overflow reg after 100 SW_INCR/CHAIN",
+ (read_sysreg(pmovsclr_el0) == 0x2) &&
+ (read_regn(pmevcntr, 1) == 0) &&
+ (read_regn(pmevcntr, 0) == 84));
+ report_info("overflow=0x%lx, #0=%ld #1=%ld", read_sysreg(pmovsclr_el0),
+    read_regn(pmevcntr, 0), read_regn(pmevcntr, 1));
+}
+
 #endif
 
 /*
@@ -648,6 +767,12 @@ int main(int argc, char *argv[])
  } else if (strcmp(argv[1], "mem-access") == 0) {
  report_prefix_push(argv[1]);
  test_mem_access();
+ } else if (strcmp(argv[1], "chained-counters") == 0) {
+ report_prefix_push(argv[1]);
+ test_chained_counters();
+ } else if (strcmp(argv[1], "chained-sw-incr") == 0) {
+ report_prefix_push(argv[1]);
+ test_chained_sw_incr();
  } else {
  report_abort("Unknown subtest '%s'", argv[1]);
  }
diff --git a/arm/unittests.cfg b/arm/unittests.cfg
index 7a59403..1bd4319 100644
--- a/arm/unittests.cfg
+++ b/arm/unittests.cfg
@@ -90,6 +90,18 @@ groups = pmu
 arch = arm64
 extra_params = -append 'mem-access'
 
+[pmu-chained-counters]
+file = pmu.flat
+groups = pmu
+arch = arm64
+extra_params = -append 'chained-counters'
+
+[pmu-chained-sw-incr]
+file = pmu.flat
+groups = pmu
+arch = arm64
+extra_params = -append 'chained-sw-incr'
+
 # Test PMU support (TCG) with -icount IPC=1
 #[pmu-tcg-icount-1]
 #file = pmu.flat
--
2.20.1


Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 07/10] arm: pmu: test 32-bit <-> 64-bit transitions

Auger Eric
In reply to this post by Auger Eric
---
 arm/pmu.c         | 125 +++++++++++++++++++++++++++++++++++++++++++++-
 arm/unittests.cfg |   6 +++
 2 files changed, 130 insertions(+), 1 deletion(-)

diff --git a/arm/pmu.c b/arm/pmu.c
index e185809..47d46a2 100644
--- a/arm/pmu.c
+++ b/arm/pmu.c
@@ -116,6 +116,7 @@ static void test_basic_event_count(void) {}
 static void test_mem_access(void) {}
 static void test_chained_counters(void) {}
 static void test_chained_sw_incr(void) {}
+static void test_chain_promotion(void) {}
 
 #elif defined(__aarch64__)
 #define ID_AA64DFR0_PERFMON_SHIFT 8
@@ -262,7 +263,6 @@ asm volatile(
  : );
 }
 
-
 static void pmu_reset(void)
 {
  /* reset all counters, counting disabled at PMCR level*/
@@ -571,6 +571,126 @@ static void test_chained_sw_incr(void)
     read_regn(pmevcntr, 0), read_regn(pmevcntr, 1));
 }
 
+static void test_chain_promotion(void)
+{
+ uint32_t events[] = { 0x13 /* MEM_ACCESS */, 0x1E /* CHAIN */};
+ void *addr = malloc(PAGE_SIZE);
+
+ if (!satisfy_prerequisites(events, ARRAY_SIZE(events)))
+ return;
+
+ /* Only enable CHAIN counter */
+ pmu_reset();
+        write_regn(pmevtyper, 0, events[0] | PMEVTYPER_EXCLUDE_EL0);
+        write_regn(pmevtyper, 1, events[1] | PMEVTYPER_EXCLUDE_EL0);
+ write_sysreg_s(0x2, PMCNTENSET_EL0);
+ isb();
+
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report("chain counter not counting if even counter is disabled",
+ !read_regn(pmevcntr, 0));
+
+ /* Only enable even counter */
+ pmu_reset();
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ write_sysreg_s(0x1, PMCNTENSET_EL0);
+ isb();
+
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report("odd counter did not increment on overflow if disabled",
+ !read_regn(pmevcntr, 1) && (read_sysreg(pmovsclr_el0) == 0x1));
+ report_info("MEM_ACCESS counter #0 has value %ld", read_regn(pmevcntr, 0));
+ report_info("CHAIN counter #1 has value %ld", read_regn(pmevcntr, 1));
+ report_info("overflow counter %ld", read_sysreg(pmovsclr_el0));
+
+ /* start at 0xFFFFFFDC, +20 with CHAIN enabled, +20 with CHAIN disabled */
+ pmu_reset();
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+ write_regn(pmevcntr, 0, 0xFFFFFFDC);
+ isb();
+
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report_info("MEM_ACCESS counter #0 has value 0x%lx", read_regn(pmevcntr, 0));
+
+ /* disable the CHAIN event */
+ write_sysreg_s(0x2, PMCNTENCLR_EL0);
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report_info("MEM_ACCESS counter #0 has value 0x%lx", read_regn(pmevcntr, 0));
+ report("should have triggered an overflow on #0", read_sysreg(pmovsclr_el0) == 0x1);
+ report("CHAIN counter #1 shouldn't have incremented", !read_regn(pmevcntr, 1));
+
+ /* start at 0xFFFFFFDC, +20 with CHAIN disabled, +20 with CHAIN enabled */
+
+ pmu_reset();
+ write_sysreg_s(0x1, PMCNTENSET_EL0);
+ write_regn(pmevcntr, 0, 0xFFFFFFDC);
+ isb();
+ report_info("counter #0 = 0x%lx, counter #1 = 0x%lx overflow=0x%lx",
+    read_regn(pmevcntr, 0), read_regn(pmevcntr, 1),
+    read_sysreg(pmovsclr_el0));
+
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report_info("MEM_ACCESS counter #0 has value 0x%lx", read_regn(pmevcntr, 0));
+
+ /* enable the CHAIN event */
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+ isb();
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report_info("MEM_ACCESS counter #0 has value 0x%lx", read_regn(pmevcntr, 0));
+
+ report("CHAIN counter #1 should have incremented and no overflow expected",
+ (read_regn(pmevcntr, 1) == 1) && !read_sysreg(pmovsclr_el0));
+
+ report_info("CHAIN counter #1 = 0x%lx, overflow=0x%lx",
+ read_regn(pmevcntr, 1), read_sysreg(pmovsclr_el0));
+
+ /* start as MEM_ACCESS/CPU_CYCLES and move to CHAIN/MEM_ACCESS */
+ pmu_reset();
+        write_regn(pmevtyper, 0, 0x13 /* MEM_ACCESS */ | PMEVTYPER_EXCLUDE_EL0);
+        write_regn(pmevtyper, 1, 0x11 /* CPU_CYCLES */ | PMEVTYPER_EXCLUDE_EL0);
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+ write_regn(pmevcntr, 0, 0xFFFFFFDC);
+ isb();
+
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report_info("MEM_ACCESS counter #0 has value 0x%lx", read_regn(pmevcntr, 0));
+
+ /* 0 becomes CHAINED */
+ write_sysreg_s(0x0, PMCNTENSET_EL0);
+        write_regn(pmevtyper, 1, 0x1E /* CHAIN */ | PMEVTYPER_EXCLUDE_EL0);
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report_info("MEM_ACCESS counter #0 has value 0x%lx", read_regn(pmevcntr, 0));
+
+ report("CHAIN counter #1 should have incremented and no overflow expected",
+ (read_regn(pmevcntr, 1) == 1) && !read_sysreg(pmovsclr_el0));
+
+ report_info("CHAIN counter #1 = 0x%lx, overflow=0x%lx",
+ read_regn(pmevcntr, 1), read_sysreg(pmovsclr_el0));
+
+ /* start as CHAIN/MEM_ACCESS and move to MEM_ACCESS/CPU_CYCLES */
+ pmu_reset();
+        write_regn(pmevtyper, 0, 0x13 /* MEM_ACCESS */ | PMEVTYPER_EXCLUDE_EL0);
+        write_regn(pmevtyper, 1, 0x1E /* CHAIN */ | PMEVTYPER_EXCLUDE_EL0);
+ write_regn(pmevcntr, 0, 0xFFFFFFDC);
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report_info("counter #0=0x%lx, counter #1=0x%lx",
+ read_regn(pmevcntr, 0), read_regn(pmevcntr, 1));
+
+ write_sysreg_s(0x0, PMCNTENSET_EL0);
+        write_regn(pmevtyper, 1, 0x11 /* CPU_CYCLES */ | PMEVTYPER_EXCLUDE_EL0);
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+
+ mem_access_loop(addr, 20, pmu.pmcr_ro | PMU_PMCR_E);
+ report("overflow is expected on counter 0", read_sysreg(pmovsclr_el0) == 1);
+ report_info("counter #0=0x%lx, counter #1=0x%lx overflow=0x%lx",
+ read_regn(pmevcntr, 0), read_regn(pmevcntr, 1),
+ read_sysreg(pmovsclr_el0));
+}
+
 #endif
 
 /*
@@ -773,6 +893,9 @@ int main(int argc, char *argv[])
  } else if (strcmp(argv[1], "chained-sw-incr") == 0) {
  report_prefix_push(argv[1]);
  test_chained_sw_incr();
+ } else if (strcmp(argv[1], "chain-promotion") == 0) {
+ report_prefix_push(argv[1]);
+ test_chain_promotion();
  } else {
  report_abort("Unknown subtest '%s'", argv[1]);
  }
diff --git a/arm/unittests.cfg b/arm/unittests.cfg
index 1bd4319..eb6e87e 100644
--- a/arm/unittests.cfg
+++ b/arm/unittests.cfg
@@ -102,6 +102,12 @@ groups = pmu
 arch = arm64
 extra_params = -append 'chained-sw-incr'
 
+[pmu-chain-promotion]
+file = pmu.flat
+groups = pmu
+arch = arm64
+extra_params = -append 'chain-promotion'
+
 # Test PMU support (TCG) with -icount IPC=1
 #[pmu-tcg-icount-1]
 #file = pmu.flat
--
2.20.1


Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 08/10] arm: gic: Provide per-IRQ helper functions

Auger Eric
In reply to this post by Auger Eric
From: Andre Przywara <[hidden email]>

A common theme when accessing per-IRQ parameters in the GIC distributor
is to set fields of a certain bit width in a range of MMIO registers.
Examples are the enabled status (one bit per IRQ), the level/edge
configuration (2 bits per IRQ) or the priority (8 bits per IRQ).

Add a generic helper function which is able to mask and set the
respective number of bits, given the IRQ number and the MMIO offset.
Provide wrappers using this function to easily allow configuring an IRQ.

For now assume that private IRQ numbers always refer to the current CPU.
In a GICv2 accessing the "other" private IRQs is not easily doable (the
registers are banked per CPU on the same MMIO address), so we impose the
same limitation on GICv3, even though those registers are not banked
there anymore.

Signed-off-by: Andre Przywara <[hidden email]>

---

initialize reg
---
 lib/arm/asm/gic-v3.h |  2 +
 lib/arm/asm/gic.h    |  9 +++++
 lib/arm/gic.c        | 90 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 101 insertions(+)

diff --git a/lib/arm/asm/gic-v3.h b/lib/arm/asm/gic-v3.h
index 347be2f..4a445a5 100644
--- a/lib/arm/asm/gic-v3.h
+++ b/lib/arm/asm/gic-v3.h
@@ -23,6 +23,8 @@
 #define GICD_CTLR_ENABLE_G1A (1U << 1)
 #define GICD_CTLR_ENABLE_G1 (1U << 0)
 
+#define GICD_IROUTER 0x6000
+
 /* Re-Distributor registers, offsets from RD_base */
 #define GICR_TYPER 0x0008
 
diff --git a/lib/arm/asm/gic.h b/lib/arm/asm/gic.h
index 1fc10a0..21cdb58 100644
--- a/lib/arm/asm/gic.h
+++ b/lib/arm/asm/gic.h
@@ -15,6 +15,7 @@
 #define GICD_IIDR 0x0008
 #define GICD_IGROUPR 0x0080
 #define GICD_ISENABLER 0x0100
+#define GICD_ICENABLER 0x0180
 #define GICD_ISPENDR 0x0200
 #define GICD_ICPENDR 0x0280
 #define GICD_ISACTIVER 0x0300
@@ -73,5 +74,13 @@ extern void gic_write_eoir(u32 irqstat);
 extern void gic_ipi_send_single(int irq, int cpu);
 extern void gic_ipi_send_mask(int irq, const cpumask_t *dest);
 
+void gic_set_irq_bit(int irq, int offset);
+void gic_enable_irq(int irq);
+void gic_disable_irq(int irq);
+void gic_set_irq_priority(int irq, u8 prio);
+void gic_set_irq_target(int irq, int cpu);
+void gic_set_irq_group(int irq, int group);
+int gic_get_irq_group(int irq);
+
 #endif /* !__ASSEMBLY__ */
 #endif /* _ASMARM_GIC_H_ */
diff --git a/lib/arm/gic.c b/lib/arm/gic.c
index 9430116..aa9cb86 100644
--- a/lib/arm/gic.c
+++ b/lib/arm/gic.c
@@ -146,3 +146,93 @@ void gic_ipi_send_mask(int irq, const cpumask_t *dest)
  assert(gic_common_ops && gic_common_ops->ipi_send_mask);
  gic_common_ops->ipi_send_mask(irq, dest);
 }
+
+enum gic_bit_access {
+ ACCESS_READ,
+ ACCESS_SET,
+ ACCESS_RMW
+};
+
+static u8 gic_masked_irq_bits(int irq, int offset, int bits, u8 value,
+      enum gic_bit_access access)
+{
+ void *base;
+ int split = 32 / bits;
+ int shift = (irq % split) * bits;
+ u32 reg = 0, mask = ((1U << bits) - 1) << shift;
+
+ switch (gic_version()) {
+ case 2:
+ base = gicv2_dist_base();
+ break;
+ case 3:
+ if (irq < 32)
+ base = gicv3_sgi_base();
+ else
+ base = gicv3_dist_base();
+ break;
+ default:
+ return 0;
+ }
+ base += offset + (irq / split) * 4;
+
+ switch (access) {
+ case ACCESS_READ:
+ return (readl(base) & mask) >> shift;
+ case ACCESS_SET:
+ reg = 0;
+ break;
+ case ACCESS_RMW:
+ reg = readl(base) & ~mask;
+ break;
+ }
+
+ writel(reg | ((u32)value << shift), base);
+
+ return 0;
+}
+
+void gic_set_irq_bit(int irq, int offset)
+{
+ gic_masked_irq_bits(irq, offset, 1, 1, ACCESS_SET);
+}
+
+void gic_enable_irq(int irq)
+{
+ gic_set_irq_bit(irq, GICD_ISENABLER);
+}
+
+void gic_disable_irq(int irq)
+{
+ gic_set_irq_bit(irq, GICD_ICENABLER);
+}
+
+void gic_set_irq_priority(int irq, u8 prio)
+{
+ gic_masked_irq_bits(irq, GICD_IPRIORITYR, 8, prio, ACCESS_RMW);
+}
+
+void gic_set_irq_target(int irq, int cpu)
+{
+ if (irq < 32)
+ return;
+
+ if (gic_version() == 2) {
+ gic_masked_irq_bits(irq, GICD_ITARGETSR, 8, 1U << cpu,
+    ACCESS_RMW);
+
+ return;
+ }
+
+ writeq(cpus[cpu], gicv3_dist_base() + GICD_IROUTER + irq * 8);
+}
+
+void gic_set_irq_group(int irq, int group)
+{
+ gic_masked_irq_bits(irq, GICD_IGROUPR, 1, group, ACCESS_RMW);
+}
+
+int gic_get_irq_group(int irq)
+{
+ return gic_masked_irq_bits(irq, GICD_IGROUPR, 1, 0, ACCESS_READ);
+}
--
2.20.1


Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 09/10] arm/arm64: gic: Introduce setup_irq() helper

Auger Eric
In reply to this post by Auger Eric
ipi_enable() code would be reusable for other interrupts
than IPI. Let's rename it setup_irq() and pass an interrupt
handler pointer. We also export it to use it in other tests
such as the PMU's one.

Signed-off-by: Eric Auger <[hidden email]>
---
 arm/gic.c         | 24 +++---------------------
 lib/arm/asm/gic.h |  3 +++
 lib/arm/gic.c     | 11 +++++++++++
 3 files changed, 17 insertions(+), 21 deletions(-)

diff --git a/arm/gic.c b/arm/gic.c
index adb6aa4..04919ae 100644
--- a/arm/gic.c
+++ b/arm/gic.c
@@ -215,20 +215,9 @@ static void ipi_test_smp(void)
  report_prefix_pop();
 }
 
-static void ipi_enable(void)
-{
- gic_enable_defaults();
-#ifdef __arm__
- install_exception_handler(EXCPTN_IRQ, ipi_handler);
-#else
- install_irq_handler(EL1H_IRQ, ipi_handler);
-#endif
- local_irq_enable();
-}
-
 static void ipi_send(void)
 {
- ipi_enable();
+ setup_irq(ipi_handler);
  wait_on_ready();
  ipi_test_self();
  ipi_test_smp();
@@ -238,7 +227,7 @@ static void ipi_send(void)
 
 static void ipi_recv(void)
 {
- ipi_enable();
+ setup_irq(ipi_handler);
  cpumask_set_cpu(smp_processor_id(), &ready);
  while (1)
  wfi();
@@ -295,14 +284,7 @@ static void ipi_clear_active_handler(struct pt_regs *regs __unused)
 static void run_active_clear_test(void)
 {
  report_prefix_push("active");
- gic_enable_defaults();
-#ifdef __arm__
- install_exception_handler(EXCPTN_IRQ, ipi_clear_active_handler);
-#else
- install_irq_handler(EL1H_IRQ, ipi_clear_active_handler);
-#endif
- local_irq_enable();
-
+ setup_irq(ipi_clear_active_handler);
  ipi_test_self();
  report_prefix_pop();
 }
diff --git a/lib/arm/asm/gic.h b/lib/arm/asm/gic.h
index 21cdb58..55dd84b 100644
--- a/lib/arm/asm/gic.h
+++ b/lib/arm/asm/gic.h
@@ -82,5 +82,8 @@ void gic_set_irq_target(int irq, int cpu);
 void gic_set_irq_group(int irq, int group);
 int gic_get_irq_group(int irq);
 
+typedef void (*handler_t)(struct pt_regs *regs __unused);
+extern void setup_irq(handler_t handler);
+
 #endif /* !__ASSEMBLY__ */
 #endif /* _ASMARM_GIC_H_ */
diff --git a/lib/arm/gic.c b/lib/arm/gic.c
index aa9cb86..0c5511f 100644
--- a/lib/arm/gic.c
+++ b/lib/arm/gic.c
@@ -236,3 +236,14 @@ int gic_get_irq_group(int irq)
 {
  return gic_masked_irq_bits(irq, GICD_IGROUPR, 1, 0, ACCESS_READ);
 }
+
+void setup_irq(handler_t handler)
+{
+        gic_enable_defaults();
+#ifdef __arm__
+        install_exception_handler(EXCPTN_IRQ, handler);
+#else
+        install_irq_handler(EL1H_IRQ, handler);
+#endif
+        local_irq_enable();
+}
--
2.20.1


Reply | Threaded
Open this post in threaded view
|

[kvm-unit-tests RFC 10/10] pmu: Test overflow interrupts

Auger Eric
In reply to this post by Auger Eric
Test overflows for MEM_ACESS and SW_INCR events. Also tests
overflows with 64-bit events.

Signed-off-by: Eric Auger <[hidden email]>
---
 arm/pmu.c         | 133 +++++++++++++++++++++++++++++++++++++++++++++-
 arm/unittests.cfg |   6 +++
 2 files changed, 138 insertions(+), 1 deletion(-)

diff --git a/arm/pmu.c b/arm/pmu.c
index 47d46a2..a63b93e 100644
--- a/arm/pmu.c
+++ b/arm/pmu.c
@@ -45,8 +45,12 @@ struct pmu {
  uint32_t pmcr_ro;
 };
 
-static struct pmu pmu;
+struct pmu_stats {
+ unsigned long bitmap;
+ uint32_t interrupts[32];
+};
 
+static struct pmu pmu;
 
 #if defined(__arm__)
 #define ID_DFR0_PERFMON_SHIFT 24
@@ -117,6 +121,7 @@ static void test_mem_access(void) {}
 static void test_chained_counters(void) {}
 static void test_chained_sw_incr(void) {}
 static void test_chain_promotion(void) {}
+static void test_overflow_interrupt(void) {}
 
 #elif defined(__aarch64__)
 #define ID_AA64DFR0_PERFMON_SHIFT 8
@@ -263,6 +268,43 @@ asm volatile(
  : );
 }
 
+static struct pmu_stats pmu_stats;
+
+static void irq_handler(struct pt_regs *regs)
+{
+        uint32_t irqstat, irqnr;
+
+        irqstat = gic_read_iar();
+        irqnr = gic_iar_irqnr(irqstat);
+        gic_write_eoir(irqstat);
+
+        if (irqnr == 23) {
+                unsigned long overflows = read_sysreg(pmovsclr_el0);
+ int i;
+
+                report_info("--> PMU overflow interrupt %d (counter bitmask 0x%lx)", irqnr, overflows);
+ for (i = 0; i < 32; i++) {
+ if (test_and_clear_bit(i, &overflows)) {
+ pmu_stats.interrupts[i]++;
+ pmu_stats.bitmap |= 1 << i;
+ }
+ }
+                write_sysreg(0xFFFFFFFF, pmovsclr_el0);
+        } else {
+                report_info("Unexpected interrupt: %d\n", irqnr);
+        }
+}
+
+static void pmu_reset_stats(void)
+{
+ int i;
+
+ for (i = 0; i < 32; i++) {
+ pmu_stats.interrupts[i] = 0;
+ }
+ pmu_stats.bitmap = 0;
+}
+
 static void pmu_reset(void)
 {
  /* reset all counters, counting disabled at PMCR level*/
@@ -273,6 +315,7 @@ static void pmu_reset(void)
  write_sysreg(0xFFFFFFFF, pmovsclr_el0);
  /* disable overflow interrupts on all counters */
  write_sysreg(0xFFFFFFFF, pmintenclr_el1);
+ pmu_reset_stats();
  isb();
 }
 
@@ -691,8 +734,93 @@ static void test_chain_promotion(void)
  read_sysreg(pmovsclr_el0));
 }
 
+static bool expect_interrupts(uint32_t bitmap)
+{
+ int i;
+
+ if (pmu_stats.bitmap ^ bitmap)
+ return false;
+
+ for (i = 0; i < 32; i++) {
+ if (test_and_clear_bit(i, &pmu_stats.bitmap))
+ if (pmu_stats.interrupts[i] != 1)
+ return false;
+ }
+ return true;
+}
+
+static void test_overflow_interrupt(void)
+{
+ uint32_t events[] = { 0x13 /* MEM_ACCESS */, 0x00 /* SW_INCR */};
+ void *addr = malloc(PAGE_SIZE);
+ int i;
+
+ if (!satisfy_prerequisites(events, ARRAY_SIZE(events)))
+ return;
+
+ setup_irq(irq_handler);
+ gic_enable_irq(23);
+
+ pmu_reset();
+
+        write_regn(pmevtyper, 0, events[0] | PMEVTYPER_EXCLUDE_EL0);
+        write_regn(pmevtyper, 1, events[1] | PMEVTYPER_EXCLUDE_EL0);
+ write_sysreg_s(0x3, PMCNTENSET_EL0);
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ write_regn(pmevcntr, 1, 0xFFFFFFF0);
+ isb();
+
+ /* interrupts are disabled */
+
+ mem_access_loop(addr, 200, pmu.pmcr_ro | PMU_PMCR_E);
+ report("no overflow interrupt received", expect_interrupts(0));
+
+ set_pmcr(pmu.pmcr_ro | PMU_PMCR_E);
+ for (i = 0; i < 100; i++) {
+ write_sysreg(0x2, pmswinc_el0);
+ }
+ set_pmcr(pmu.pmcr_ro);
+ report("no overflow interrupt received", expect_interrupts(0));
+
+ /* enable interrupts */
+
+ pmu_reset_stats();
+
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ write_regn(pmevcntr, 1, 0xFFFFFFF0);
+ write_sysreg(0xFFFFFFFF, pmintenset_el1);
+ isb();
+
+ mem_access_loop(addr, 200, pmu.pmcr_ro | PMU_PMCR_E);
+ for (i = 0; i < 100; i++) {
+ write_sysreg(0x3, pmswinc_el0);
+ }
+ mem_access_loop(addr, 200, pmu.pmcr_ro);
+ report_info("overflow=0x%lx", read_sysreg(pmovsclr_el0));
+ report("overflow interrupts expected on #0 and #1", expect_interrupts(0x3));
+
+ /* promote to 64-b */
+
+ pmu_reset_stats();
+
+ events[1] = 0x1E /* CHAIN */;
+        write_regn(pmevtyper, 1, events[1] | PMEVTYPER_EXCLUDE_EL0);
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ isb();
+ mem_access_loop(addr, 200, pmu.pmcr_ro | PMU_PMCR_E);
+ report("no overflow interrupt expected on 32b boundary", expect_interrupts(0));
+
+ /* overflow on odd counter */
+ pmu_reset_stats();
+ write_regn(pmevcntr, 0, 0xFFFFFFF0);
+ write_regn(pmevcntr, 1, 0xFFFFFFFF);
+ isb();
+ mem_access_loop(addr, 200, pmu.pmcr_ro | PMU_PMCR_E);
+ report("expect overflow interrupt on odd counter", expect_interrupts(0x2));
+}
 #endif
 
+
 /*
  * As a simple sanity check on the PMCR_EL0, ensure the implementer field isn't
  * null. Also print out a couple other interesting fields for diagnostic
@@ -896,6 +1024,9 @@ int main(int argc, char *argv[])
  } else if (strcmp(argv[1], "chain-promotion") == 0) {
  report_prefix_push(argv[1]);
  test_chain_promotion();
+ } else if (strcmp(argv[1], "overflow-interrupt") == 0) {
+ report_prefix_push(argv[1]);
+ test_overflow_interrupt();
  } else {
  report_abort("Unknown subtest '%s'", argv[1]);
  }
diff --git a/arm/unittests.cfg b/arm/unittests.cfg
index eb6e87e..31b4c7a 100644
--- a/arm/unittests.cfg
+++ b/arm/unittests.cfg
@@ -108,6 +108,12 @@ groups = pmu
 arch = arm64
 extra_params = -append 'chain-promotion'
 
+[pmu-chain-promotion]
+file = pmu.flat
+groups = pmu
+arch = arm64
+extra_params = -append 'overflow-interrupt'
+
 # Test PMU support (TCG) with -icount IPC=1
 #[pmu-tcg-icount-1]
 #file = pmu.flat
--
2.20.1


Reply | Threaded
Open this post in threaded view
|

Re: [kvm-unit-tests RFC 01/10] arm64: Provide read/write_sysreg_s

Alexandru Elisei
In reply to this post by Auger Eric
Hi,

On 12/6/19 5:27 PM, Eric Auger wrote:

> From: Andrew Jones <[hidden email]>
>
> Sometimes we need to test access to system registers which are
> missing assembler mnemonics.
>
> Signed-off-by: Andrew Jones <[hidden email]>
> ---
>  lib/arm64/asm/sysreg.h | 11 +++++++++++
>  1 file changed, 11 insertions(+)
>
> diff --git a/lib/arm64/asm/sysreg.h b/lib/arm64/asm/sysreg.h
> index a03830b..a45eebd 100644
> --- a/lib/arm64/asm/sysreg.h
> +++ b/lib/arm64/asm/sysreg.h
> @@ -38,6 +38,17 @@
>   asm volatile("msr " xstr(r) ", %x0" : : "rZ" (__val)); \
>  } while (0)
>  
> +#define read_sysreg_s(r) ({ \
> + u64 __val; \
> + asm volatile("mrs_s %0, " xstr(r) : "=r" (__val)); \
> + __val; \
> +})
> +
> +#define write_sysreg_s(v, r) do { \
> + u64 __val = (u64)v; \
> + asm volatile("msr_s " xstr(r) ", %x0" : : "rZ" (__val));\
> +} while (0)
> +
>  asm(
>  " .irp num,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30\n"
>  " .equ .L__reg_num_x\\num, \\num\n"

That's exactly the code that I wrote for my EL2 series :)

Reviewed-by: Alexandru Elisei <[hidden email]>

Thanks,
Alex

Reply | Threaded
Open this post in threaded view
|

Re: [kvm-unit-tests RFC 03/10] pmu: Add a pmu struct

Andrew Jones-15
In reply to this post by Auger Eric
On Fri, Dec 06, 2019 at 06:27:17PM +0100, Eric Auger wrote:

> This struct aims at storing information potentially used by
> all tests such as the pmu version, the read-only part of the
> PMCR, the number of implemented event counters, ...
>
> Signed-off-by: Eric Auger <[hidden email]>
> ---
>  arm/pmu.c | 29 ++++++++++++++++++++++++-----
>  1 file changed, 24 insertions(+), 5 deletions(-)
>
> diff --git a/arm/pmu.c b/arm/pmu.c
> index 2ad6469..8e95251 100644
> --- a/arm/pmu.c
> +++ b/arm/pmu.c
> @@ -33,7 +33,15 @@
>  
>  #define NR_SAMPLES 10
>  
> -static unsigned int pmu_version;
> +struct pmu {
> + unsigned int version;
> + unsigned int nb_implemented_counters;
> + uint32_t pmcr_ro;
> +};
> +
> +static struct pmu pmu;
> +
> +
>  #if defined(__arm__)
>  #define ID_DFR0_PERFMON_SHIFT 24
>  #define ID_DFR0_PERFMON_MASK  0xf
> @@ -265,7 +273,7 @@ static bool check_cpi(int cpi)
>  static void pmccntr64_test(void)
>  {
>  #ifdef __arm__
> - if (pmu_version == 0x3) {
> + if (pmu.version == 0x3) {
>   if (ERRATA(9e3f7a296940)) {
>   write_sysreg(0xdead, PMCCNTR64);
>   report("pmccntr64", read_sysreg(PMCCNTR64) == 0xdead);
> @@ -278,9 +286,20 @@ static void pmccntr64_test(void)
>  /* Return FALSE if no PMU found, otherwise return TRUE */
>  static bool pmu_probe(void)
>  {
> - pmu_version = get_pmu_version();
> - report_info("PMU version: %d", pmu_version);
> - return pmu_version != 0 && pmu_version != 0xf;
> + uint32_t pmcr;
> +
> + pmu.version = get_pmu_version();
> + report_info("PMU version: %d", pmu.version);
> +
> + if (pmu.version == 0 || pmu.version  == 0xF)
                                            ^ stray space

> + return false;
> +
> + pmcr = get_pmcr();
> + pmu.pmcr_ro = pmcr & 0xFFFFFF80;
> + pmu.nb_implemented_counters = (pmcr >> PMU_PMCR_N_SHIFT) & PMU_PMCR_N_MASK;
> + report_info("Implements %d event counters", pmu.nb_implemented_counters);
> +
> + return true;
>  }
>  
>  int main(int argc, char *argv[])
> --
> 2.20.1
>


Reply | Threaded
Open this post in threaded view
|

Re: [kvm-unit-tests RFC 04/10] pmu: Check Required Event Support

Andrew Jones-15
In reply to this post by Auger Eric
On Fri, Dec 06, 2019 at 06:27:18PM +0100, Eric Auger wrote:

> If event counters are implemented check the common events
> required by the PMUv3 are implemented.
>
> Some are unconditionally required (SW_INCR, CPU_CYCLES,
> either INST_RETIRED or INST_SPEC). Some others only are
> required if the implementation implements some other features.
>
> Check those wich are unconditionally required.
>
> This test currently fails on TCG as neither INST_RETIRED
> or INST_SPEC are supported.
>
> Signed-off-by: Eric Auger <[hidden email]>
> ---
>  arm/pmu.c         | 70 +++++++++++++++++++++++++++++++++++++++++++++++
>  arm/unittests.cfg |  6 ++++
>  2 files changed, 76 insertions(+)
>
> diff --git a/arm/pmu.c b/arm/pmu.c
> index 8e95251..f78c43f 100644
> --- a/arm/pmu.c
> +++ b/arm/pmu.c
> @@ -102,6 +102,10 @@ static inline void precise_instrs_loop(int loop, uint32_t pmcr)
>   : [pmcr] "r" (pmcr), [z] "r" (0)
>   : "cc");
>  }
> +
> +/* event counter tests only implemented for aarch64 */
> +static void test_event_introspection(void) {}
> +
>  #elif defined(__aarch64__)
>  #define ID_AA64DFR0_PERFMON_SHIFT 8
>  #define ID_AA64DFR0_PERFMON_MASK  0xf
> @@ -140,6 +144,69 @@ static inline void precise_instrs_loop(int loop, uint32_t pmcr)
>   : [pmcr] "r" (pmcr)
>   : "cc");
>  }
> +
> +#define PMCEID1_EL0 sys_reg(11, 3, 9, 12, 7)
> +
> +static bool is_event_supported(uint32_t n, bool warn)
> +{
> + uint64_t pmceid0 = read_sysreg(pmceid0_el0);
> + uint64_t pmceid1 = read_sysreg_s(PMCEID1_EL0);
> + bool supported;
> + uint32_t reg;
> +
> + if (n >= 0x0  && n <= 0x1F) {
> + reg = pmceid0 & 0xFFFFFFFF;
> + } else if  (n >= 0x4000 && n <= 0x401F) {
> + reg = pmceid0 >> 32;
> + } else if (n >= 0x20  && n <= 0x3F) {
> + reg = pmceid1 & 0xFFFFFFFF;
> + } else if (n >= 0x4020 && n <= 0x403F) {
> + reg = pmceid1 >> 32;


Lot's of stray spaces in there. Also the 0x4000 should probably get a
define, and maybe another for the size 0x20.

> + } else {
> + abort();
> + }
> + supported =  reg & (1 << n);
> + if (!supported && warn)
> + report_info("event %d is not supported", n);
> + return supported;
> +}
> +
> +static void test_event_introspection(void)
> +{
> + bool required_events;
> +
> + if (!pmu.nb_implemented_counters) {
> + report_skip("No event counter, skip ...");
> + return;
> + }
> + if (pmu.nb_implemented_counters < 2)
> + report_info("%d event counters are implemented. "
> +                            "ARM recommends to implement at least 2",
> +                            pmu.nb_implemented_counters);

nit: I'd use {} on these multi-line if's (even if they're just one line)

> +
> + /* PMUv3 requires an implementation includes some common events */
> + required_events = is_event_supported(0x0, true) /* SW_INCR */ &&
> +  is_event_supported(0x11, true) /* CPU_CYCLES */ &&
> +  (is_event_supported(0x8, true) /* INST_RETIRED */ ||
> +   is_event_supported(0x1B, true) /* INST_PREC */);
> + if (!is_event_supported(0x8, false))
> + report_info("ARM strongly recomments INST_RETIRED (0x8) event "
                                          ^ recommends
> +    "to be implemented");

Do we need to report Arm's recommendation?

> +
> + if (pmu.version == 0x4) {
> + /* ARMv8.1 PMU: STALL_FRONTEND and STALL_BACKEND are required */
> + required_events = required_events ||
> +  is_event_supported(0x23, true) ||
> +  is_event_supported(0x24, true);
> + }
> +
> + /* L1D_CACHE_REFILL(0x3) and L1D_CACHE(0x4) are only required if
> +   L1 data / unified cache. BR_MIS_PRED(0x10), BR_PRED(0x12) are only
> +   required if program-flow prediction is implemented. */
> +
> + report("Check required events are implemented", required_events);
> +}
> +
>  #endif
>  
>  /*
> @@ -324,6 +391,9 @@ int main(int argc, char *argv[])
>   report("Monotonically increasing cycle count", check_cycles_increase());
>   report("Cycle/instruction ratio", check_cpi(cpi));
>   pmccntr64_test();
> + } else if (strcmp(argv[1], "event-introspection") == 0) {
> + report_prefix_push(argv[1]);
> + test_event_introspection();
>   } else {
>   report_abort("Unknown subtest '%s'", argv[1]);
>   }
> diff --git a/arm/unittests.cfg b/arm/unittests.cfg
> index 79f0d7a..4433ef3 100644
> --- a/arm/unittests.cfg
> +++ b/arm/unittests.cfg
> @@ -66,6 +66,12 @@ file = pmu.flat
>  groups = pmu
>  extra_params = -append 'cycle-counter 0'
>  
> +[pmu-event-introspection]
> +file = pmu.flat
> +groups = pmu
> +arch = arm64
> +extra_params = -append 'event-introspection'
> +
>  # Test PMU support (TCG) with -icount IPC=1
>  #[pmu-tcg-icount-1]
>  #file = pmu.flat
> --
> 2.20.1
>

Thanks,
drew