* [PATCH v8 0/9] selftests: KVM: Test offset-based counter controls
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
This series implements new tests for the x86 and arm64 counter migration
changes that I've mailed out. These are sent separately as a dependent
change since there are cross-arch dependencies here.
Patch 1 yanks the pvclock headers into the tools/ directory so we can
make use of them within a KVM selftest guest.
Patch 2 tests the new capabilities of the KVM_*_CLOCK ioctls, ensuring
that the kernel accounts for elapsed time when restoring the KVM clock.
Patches 3-4 add some device attribute helpers and clean up some mistakes
in the assertions thereof.
Patch 5 implements a test for the KVM_VCPU_TSC_OFFSET attribute,
asserting that manipulation of the offset results in correct TSC values
within the guest.
Patch 6 adds basic arm64 support to the counter offset test, checking
that the virtual counter-timer offset works correctly. Patch 7 does the
same for the physical counter-timer offset.
Patch 8 adds a benchmark for physical counter offsetting, since most
implementations available right now will rely on emulation.
Lastly, patch 9 extends the get-reg-list test to check for
KVM_REG_ARM_TIMER_OFFSET if userspace opts-in to the kernel capability.
This series applies cleanly to 5.15-rc1
Tests were ran against the respective architecture changes on the
following systems:
- Haswell (x86)
- Ampere Mt. Jade (non-ECV, nVHE and VHE)
v7: https://lore.kernel.org/r/20210816001246.3067312-1-oupton@google.com
v7 -> v8:
- Rebased to 5.15-rc1
- Dropped helper for checking if reg exists in reg list (no longer
necessary)
- Test and enable KVM_CAP_ARM_VTIMER_OFFSET
- Add get-reg-list changes
Oliver Upton (9):
tools: arch: x86: pull in pvclock headers
selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
selftests: KVM: Fix kvm device helper ioctl assertions
selftests: KVM: Add helpers for vCPU device attributes
selftests: KVM: Introduce system counter offset test
selftests: KVM: Add support for aarch64 to system_counter_offset_test
selftests: KVM: Test physical counter offsetting
selftests: KVM: Add counter emulation benchmark
selftests: KVM: Test vtimer offset reg in get-reg-list
tools/arch/x86/include/asm/pvclock-abi.h | 48 ++++
tools/arch/x86/include/asm/pvclock.h | 103 ++++++++
tools/testing/selftests/kvm/.gitignore | 3 +
tools/testing/selftests/kvm/Makefile | 4 +
.../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++
.../selftests/kvm/aarch64/get-reg-list.c | 42 ++++
.../selftests/kvm/include/aarch64/processor.h | 24 ++
.../testing/selftests/kvm/include/kvm_util.h | 11 +
tools/testing/selftests/kvm/lib/kvm_util.c | 44 +++-
.../kvm/system_counter_offset_test.c | 220 ++++++++++++++++++
.../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++
11 files changed, 907 insertions(+), 3 deletions(-)
create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
create mode 100644 tools/arch/x86/include/asm/pvclock.h
create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
--
2.33.0.464.g1972c5931b-goog
^ permalink raw reply [flat|nested] 42+ messages in thread* [PATCH v8 0/9] selftests: KVM: Test offset-based counter controls
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
This series implements new tests for the x86 and arm64 counter migration
changes that I've mailed out. These are sent separately as a dependent
change since there are cross-arch dependencies here.
Patch 1 yanks the pvclock headers into the tools/ directory so we can
make use of them within a KVM selftest guest.
Patch 2 tests the new capabilities of the KVM_*_CLOCK ioctls, ensuring
that the kernel accounts for elapsed time when restoring the KVM clock.
Patches 3-4 add some device attribute helpers and clean up some mistakes
in the assertions thereof.
Patch 5 implements a test for the KVM_VCPU_TSC_OFFSET attribute,
asserting that manipulation of the offset results in correct TSC values
within the guest.
Patch 6 adds basic arm64 support to the counter offset test, checking
that the virtual counter-timer offset works correctly. Patch 7 does the
same for the physical counter-timer offset.
Patch 8 adds a benchmark for physical counter offsetting, since most
implementations available right now will rely on emulation.
Lastly, patch 9 extends the get-reg-list test to check for
KVM_REG_ARM_TIMER_OFFSET if userspace opts-in to the kernel capability.
This series applies cleanly to 5.15-rc1
Tests were ran against the respective architecture changes on the
following systems:
- Haswell (x86)
- Ampere Mt. Jade (non-ECV, nVHE and VHE)
v7: https://lore.kernel.org/r/20210816001246.3067312-1-oupton@google.com
v7 -> v8:
- Rebased to 5.15-rc1
- Dropped helper for checking if reg exists in reg list (no longer
necessary)
- Test and enable KVM_CAP_ARM_VTIMER_OFFSET
- Add get-reg-list changes
Oliver Upton (9):
tools: arch: x86: pull in pvclock headers
selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
selftests: KVM: Fix kvm device helper ioctl assertions
selftests: KVM: Add helpers for vCPU device attributes
selftests: KVM: Introduce system counter offset test
selftests: KVM: Add support for aarch64 to system_counter_offset_test
selftests: KVM: Test physical counter offsetting
selftests: KVM: Add counter emulation benchmark
selftests: KVM: Test vtimer offset reg in get-reg-list
tools/arch/x86/include/asm/pvclock-abi.h | 48 ++++
tools/arch/x86/include/asm/pvclock.h | 103 ++++++++
tools/testing/selftests/kvm/.gitignore | 3 +
tools/testing/selftests/kvm/Makefile | 4 +
.../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++
.../selftests/kvm/aarch64/get-reg-list.c | 42 ++++
.../selftests/kvm/include/aarch64/processor.h | 24 ++
.../testing/selftests/kvm/include/kvm_util.h | 11 +
tools/testing/selftests/kvm/lib/kvm_util.c | 44 +++-
.../kvm/system_counter_offset_test.c | 220 ++++++++++++++++++
.../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++
11 files changed, 907 insertions(+), 3 deletions(-)
create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
create mode 100644 tools/arch/x86/include/asm/pvclock.h
create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 42+ messages in thread* [PATCH v8 1/9] tools: arch: x86: pull in pvclock headers
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-16 18:15 ` Oliver Upton
-1 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Marc Zyngier, Peter Shier,
Sean Christopherson, David Matlack, Paolo Bonzini,
linux-arm-kernel, Jim Mattson
Copy over approximately clean versions of the pvclock headers into
tools. Reconcile headers/symbols missing in tools that are unneeded.
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/arch/x86/include/asm/pvclock-abi.h | 48 +++++++++++
tools/arch/x86/include/asm/pvclock.h | 103 +++++++++++++++++++++++
2 files changed, 151 insertions(+)
create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
create mode 100644 tools/arch/x86/include/asm/pvclock.h
diff --git a/tools/arch/x86/include/asm/pvclock-abi.h b/tools/arch/x86/include/asm/pvclock-abi.h
new file mode 100644
index 000000000000..1436226efe3e
--- /dev/null
+++ b/tools/arch/x86/include/asm/pvclock-abi.h
@@ -0,0 +1,48 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _ASM_X86_PVCLOCK_ABI_H
+#define _ASM_X86_PVCLOCK_ABI_H
+#ifndef __ASSEMBLY__
+
+/*
+ * These structs MUST NOT be changed.
+ * They are the ABI between hypervisor and guest OS.
+ * Both Xen and KVM are using this.
+ *
+ * pvclock_vcpu_time_info holds the system time and the tsc timestamp
+ * of the last update. So the guest can use the tsc delta to get a
+ * more precise system time. There is one per virtual cpu.
+ *
+ * pvclock_wall_clock references the point in time when the system
+ * time was zero (usually boot time), thus the guest calculates the
+ * current wall clock by adding the system time.
+ *
+ * Protocol for the "version" fields is: hypervisor raises it (making
+ * it uneven) before it starts updating the fields and raises it again
+ * (making it even) when it is done. Thus the guest can make sure the
+ * time values it got are consistent by checking the version before
+ * and after reading them.
+ */
+
+struct pvclock_vcpu_time_info {
+ u32 version;
+ u32 pad0;
+ u64 tsc_timestamp;
+ u64 system_time;
+ u32 tsc_to_system_mul;
+ s8 tsc_shift;
+ u8 flags;
+ u8 pad[2];
+} __attribute__((__packed__)); /* 32 bytes */
+
+struct pvclock_wall_clock {
+ u32 version;
+ u32 sec;
+ u32 nsec;
+} __attribute__((__packed__));
+
+#define PVCLOCK_TSC_STABLE_BIT (1 << 0)
+#define PVCLOCK_GUEST_STOPPED (1 << 1)
+/* PVCLOCK_COUNTS_FROM_ZERO broke ABI and can't be used anymore. */
+#define PVCLOCK_COUNTS_FROM_ZERO (1 << 2)
+#endif /* __ASSEMBLY__ */
+#endif /* _ASM_X86_PVCLOCK_ABI_H */
diff --git a/tools/arch/x86/include/asm/pvclock.h b/tools/arch/x86/include/asm/pvclock.h
new file mode 100644
index 000000000000..2628f9a6330b
--- /dev/null
+++ b/tools/arch/x86/include/asm/pvclock.h
@@ -0,0 +1,103 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _ASM_X86_PVCLOCK_H
+#define _ASM_X86_PVCLOCK_H
+
+#include <asm/barrier.h>
+#include <asm/pvclock-abi.h>
+
+/* some helper functions for xen and kvm pv clock sources */
+u64 pvclock_clocksource_read(struct pvclock_vcpu_time_info *src);
+u8 pvclock_read_flags(struct pvclock_vcpu_time_info *src);
+void pvclock_set_flags(u8 flags);
+unsigned long pvclock_tsc_khz(struct pvclock_vcpu_time_info *src);
+void pvclock_resume(void);
+
+void pvclock_touch_watchdogs(void);
+
+static __always_inline
+unsigned pvclock_read_begin(const struct pvclock_vcpu_time_info *src)
+{
+ unsigned version = src->version & ~1;
+ /* Make sure that the version is read before the data. */
+ rmb();
+ return version;
+}
+
+static __always_inline
+bool pvclock_read_retry(const struct pvclock_vcpu_time_info *src,
+ unsigned version)
+{
+ /* Make sure that the version is re-read after the data. */
+ rmb();
+ return version != src->version;
+}
+
+/*
+ * Scale a 64-bit delta by scaling and multiplying by a 32-bit fraction,
+ * yielding a 64-bit result.
+ */
+static inline u64 pvclock_scale_delta(u64 delta, u32 mul_frac, int shift)
+{
+ u64 product;
+#ifdef __i386__
+ u32 tmp1, tmp2;
+#else
+ unsigned long tmp;
+#endif
+
+ if (shift < 0)
+ delta >>= -shift;
+ else
+ delta <<= shift;
+
+#ifdef __i386__
+ __asm__ (
+ "mul %5 ; "
+ "mov %4,%%eax ; "
+ "mov %%edx,%4 ; "
+ "mul %5 ; "
+ "xor %5,%5 ; "
+ "add %4,%%eax ; "
+ "adc %5,%%edx ; "
+ : "=A" (product), "=r" (tmp1), "=r" (tmp2)
+ : "a" ((u32)delta), "1" ((u32)(delta >> 32)), "2" (mul_frac) );
+#elif defined(__x86_64__)
+ __asm__ (
+ "mulq %[mul_frac] ; shrd $32, %[hi], %[lo]"
+ : [lo]"=a"(product),
+ [hi]"=d"(tmp)
+ : "0"(delta),
+ [mul_frac]"rm"((u64)mul_frac));
+#else
+#error implement me!
+#endif
+
+ return product;
+}
+
+static __always_inline
+u64 __pvclock_read_cycles(const struct pvclock_vcpu_time_info *src, u64 tsc)
+{
+ u64 delta = tsc - src->tsc_timestamp;
+ u64 offset = pvclock_scale_delta(delta, src->tsc_to_system_mul,
+ src->tsc_shift);
+ return src->system_time + offset;
+}
+
+struct pvclock_vsyscall_time_info {
+ struct pvclock_vcpu_time_info pvti;
+} __attribute__((__aligned__(64)));
+
+#define PVTI_SIZE sizeof(struct pvclock_vsyscall_time_info)
+
+#ifdef CONFIG_PARAVIRT_CLOCK
+void pvclock_set_pvti_cpu0_va(struct pvclock_vsyscall_time_info *pvti);
+struct pvclock_vsyscall_time_info *pvclock_get_pvti_cpu0_va(void);
+#else
+static inline struct pvclock_vsyscall_time_info *pvclock_get_pvti_cpu0_va(void)
+{
+ return NULL;
+}
+#endif
+
+#endif /* _ASM_X86_PVCLOCK_H */
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 1/9] tools: arch: x86: pull in pvclock headers
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Copy over approximately clean versions of the pvclock headers into
tools. Reconcile headers/symbols missing in tools that are unneeded.
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/arch/x86/include/asm/pvclock-abi.h | 48 +++++++++++
tools/arch/x86/include/asm/pvclock.h | 103 +++++++++++++++++++++++
2 files changed, 151 insertions(+)
create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
create mode 100644 tools/arch/x86/include/asm/pvclock.h
diff --git a/tools/arch/x86/include/asm/pvclock-abi.h b/tools/arch/x86/include/asm/pvclock-abi.h
new file mode 100644
index 000000000000..1436226efe3e
--- /dev/null
+++ b/tools/arch/x86/include/asm/pvclock-abi.h
@@ -0,0 +1,48 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _ASM_X86_PVCLOCK_ABI_H
+#define _ASM_X86_PVCLOCK_ABI_H
+#ifndef __ASSEMBLY__
+
+/*
+ * These structs MUST NOT be changed.
+ * They are the ABI between hypervisor and guest OS.
+ * Both Xen and KVM are using this.
+ *
+ * pvclock_vcpu_time_info holds the system time and the tsc timestamp
+ * of the last update. So the guest can use the tsc delta to get a
+ * more precise system time. There is one per virtual cpu.
+ *
+ * pvclock_wall_clock references the point in time when the system
+ * time was zero (usually boot time), thus the guest calculates the
+ * current wall clock by adding the system time.
+ *
+ * Protocol for the "version" fields is: hypervisor raises it (making
+ * it uneven) before it starts updating the fields and raises it again
+ * (making it even) when it is done. Thus the guest can make sure the
+ * time values it got are consistent by checking the version before
+ * and after reading them.
+ */
+
+struct pvclock_vcpu_time_info {
+ u32 version;
+ u32 pad0;
+ u64 tsc_timestamp;
+ u64 system_time;
+ u32 tsc_to_system_mul;
+ s8 tsc_shift;
+ u8 flags;
+ u8 pad[2];
+} __attribute__((__packed__)); /* 32 bytes */
+
+struct pvclock_wall_clock {
+ u32 version;
+ u32 sec;
+ u32 nsec;
+} __attribute__((__packed__));
+
+#define PVCLOCK_TSC_STABLE_BIT (1 << 0)
+#define PVCLOCK_GUEST_STOPPED (1 << 1)
+/* PVCLOCK_COUNTS_FROM_ZERO broke ABI and can't be used anymore. */
+#define PVCLOCK_COUNTS_FROM_ZERO (1 << 2)
+#endif /* __ASSEMBLY__ */
+#endif /* _ASM_X86_PVCLOCK_ABI_H */
diff --git a/tools/arch/x86/include/asm/pvclock.h b/tools/arch/x86/include/asm/pvclock.h
new file mode 100644
index 000000000000..2628f9a6330b
--- /dev/null
+++ b/tools/arch/x86/include/asm/pvclock.h
@@ -0,0 +1,103 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _ASM_X86_PVCLOCK_H
+#define _ASM_X86_PVCLOCK_H
+
+#include <asm/barrier.h>
+#include <asm/pvclock-abi.h>
+
+/* some helper functions for xen and kvm pv clock sources */
+u64 pvclock_clocksource_read(struct pvclock_vcpu_time_info *src);
+u8 pvclock_read_flags(struct pvclock_vcpu_time_info *src);
+void pvclock_set_flags(u8 flags);
+unsigned long pvclock_tsc_khz(struct pvclock_vcpu_time_info *src);
+void pvclock_resume(void);
+
+void pvclock_touch_watchdogs(void);
+
+static __always_inline
+unsigned pvclock_read_begin(const struct pvclock_vcpu_time_info *src)
+{
+ unsigned version = src->version & ~1;
+ /* Make sure that the version is read before the data. */
+ rmb();
+ return version;
+}
+
+static __always_inline
+bool pvclock_read_retry(const struct pvclock_vcpu_time_info *src,
+ unsigned version)
+{
+ /* Make sure that the version is re-read after the data. */
+ rmb();
+ return version != src->version;
+}
+
+/*
+ * Scale a 64-bit delta by scaling and multiplying by a 32-bit fraction,
+ * yielding a 64-bit result.
+ */
+static inline u64 pvclock_scale_delta(u64 delta, u32 mul_frac, int shift)
+{
+ u64 product;
+#ifdef __i386__
+ u32 tmp1, tmp2;
+#else
+ unsigned long tmp;
+#endif
+
+ if (shift < 0)
+ delta >>= -shift;
+ else
+ delta <<= shift;
+
+#ifdef __i386__
+ __asm__ (
+ "mul %5 ; "
+ "mov %4,%%eax ; "
+ "mov %%edx,%4 ; "
+ "mul %5 ; "
+ "xor %5,%5 ; "
+ "add %4,%%eax ; "
+ "adc %5,%%edx ; "
+ : "=A" (product), "=r" (tmp1), "=r" (tmp2)
+ : "a" ((u32)delta), "1" ((u32)(delta >> 32)), "2" (mul_frac) );
+#elif defined(__x86_64__)
+ __asm__ (
+ "mulq %[mul_frac] ; shrd $32, %[hi], %[lo]"
+ : [lo]"=a"(product),
+ [hi]"=d"(tmp)
+ : "0"(delta),
+ [mul_frac]"rm"((u64)mul_frac));
+#else
+#error implement me!
+#endif
+
+ return product;
+}
+
+static __always_inline
+u64 __pvclock_read_cycles(const struct pvclock_vcpu_time_info *src, u64 tsc)
+{
+ u64 delta = tsc - src->tsc_timestamp;
+ u64 offset = pvclock_scale_delta(delta, src->tsc_to_system_mul,
+ src->tsc_shift);
+ return src->system_time + offset;
+}
+
+struct pvclock_vsyscall_time_info {
+ struct pvclock_vcpu_time_info pvti;
+} __attribute__((__aligned__(64)));
+
+#define PVTI_SIZE sizeof(struct pvclock_vsyscall_time_info)
+
+#ifdef CONFIG_PARAVIRT_CLOCK
+void pvclock_set_pvti_cpu0_va(struct pvclock_vsyscall_time_info *pvti);
+struct pvclock_vsyscall_time_info *pvclock_get_pvti_cpu0_va(void);
+#else
+static inline struct pvclock_vsyscall_time_info *pvclock_get_pvti_cpu0_va(void)
+{
+ return NULL;
+}
+#endif
+
+#endif /* _ASM_X86_PVCLOCK_H */
--
2.33.0.464.g1972c5931b-goog
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 1/9] tools: arch: x86: pull in pvclock headers
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Copy over approximately clean versions of the pvclock headers into
tools. Reconcile headers/symbols missing in tools that are unneeded.
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/arch/x86/include/asm/pvclock-abi.h | 48 +++++++++++
tools/arch/x86/include/asm/pvclock.h | 103 +++++++++++++++++++++++
2 files changed, 151 insertions(+)
create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
create mode 100644 tools/arch/x86/include/asm/pvclock.h
diff --git a/tools/arch/x86/include/asm/pvclock-abi.h b/tools/arch/x86/include/asm/pvclock-abi.h
new file mode 100644
index 000000000000..1436226efe3e
--- /dev/null
+++ b/tools/arch/x86/include/asm/pvclock-abi.h
@@ -0,0 +1,48 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _ASM_X86_PVCLOCK_ABI_H
+#define _ASM_X86_PVCLOCK_ABI_H
+#ifndef __ASSEMBLY__
+
+/*
+ * These structs MUST NOT be changed.
+ * They are the ABI between hypervisor and guest OS.
+ * Both Xen and KVM are using this.
+ *
+ * pvclock_vcpu_time_info holds the system time and the tsc timestamp
+ * of the last update. So the guest can use the tsc delta to get a
+ * more precise system time. There is one per virtual cpu.
+ *
+ * pvclock_wall_clock references the point in time when the system
+ * time was zero (usually boot time), thus the guest calculates the
+ * current wall clock by adding the system time.
+ *
+ * Protocol for the "version" fields is: hypervisor raises it (making
+ * it uneven) before it starts updating the fields and raises it again
+ * (making it even) when it is done. Thus the guest can make sure the
+ * time values it got are consistent by checking the version before
+ * and after reading them.
+ */
+
+struct pvclock_vcpu_time_info {
+ u32 version;
+ u32 pad0;
+ u64 tsc_timestamp;
+ u64 system_time;
+ u32 tsc_to_system_mul;
+ s8 tsc_shift;
+ u8 flags;
+ u8 pad[2];
+} __attribute__((__packed__)); /* 32 bytes */
+
+struct pvclock_wall_clock {
+ u32 version;
+ u32 sec;
+ u32 nsec;
+} __attribute__((__packed__));
+
+#define PVCLOCK_TSC_STABLE_BIT (1 << 0)
+#define PVCLOCK_GUEST_STOPPED (1 << 1)
+/* PVCLOCK_COUNTS_FROM_ZERO broke ABI and can't be used anymore. */
+#define PVCLOCK_COUNTS_FROM_ZERO (1 << 2)
+#endif /* __ASSEMBLY__ */
+#endif /* _ASM_X86_PVCLOCK_ABI_H */
diff --git a/tools/arch/x86/include/asm/pvclock.h b/tools/arch/x86/include/asm/pvclock.h
new file mode 100644
index 000000000000..2628f9a6330b
--- /dev/null
+++ b/tools/arch/x86/include/asm/pvclock.h
@@ -0,0 +1,103 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _ASM_X86_PVCLOCK_H
+#define _ASM_X86_PVCLOCK_H
+
+#include <asm/barrier.h>
+#include <asm/pvclock-abi.h>
+
+/* some helper functions for xen and kvm pv clock sources */
+u64 pvclock_clocksource_read(struct pvclock_vcpu_time_info *src);
+u8 pvclock_read_flags(struct pvclock_vcpu_time_info *src);
+void pvclock_set_flags(u8 flags);
+unsigned long pvclock_tsc_khz(struct pvclock_vcpu_time_info *src);
+void pvclock_resume(void);
+
+void pvclock_touch_watchdogs(void);
+
+static __always_inline
+unsigned pvclock_read_begin(const struct pvclock_vcpu_time_info *src)
+{
+ unsigned version = src->version & ~1;
+ /* Make sure that the version is read before the data. */
+ rmb();
+ return version;
+}
+
+static __always_inline
+bool pvclock_read_retry(const struct pvclock_vcpu_time_info *src,
+ unsigned version)
+{
+ /* Make sure that the version is re-read after the data. */
+ rmb();
+ return version != src->version;
+}
+
+/*
+ * Scale a 64-bit delta by scaling and multiplying by a 32-bit fraction,
+ * yielding a 64-bit result.
+ */
+static inline u64 pvclock_scale_delta(u64 delta, u32 mul_frac, int shift)
+{
+ u64 product;
+#ifdef __i386__
+ u32 tmp1, tmp2;
+#else
+ unsigned long tmp;
+#endif
+
+ if (shift < 0)
+ delta >>= -shift;
+ else
+ delta <<= shift;
+
+#ifdef __i386__
+ __asm__ (
+ "mul %5 ; "
+ "mov %4,%%eax ; "
+ "mov %%edx,%4 ; "
+ "mul %5 ; "
+ "xor %5,%5 ; "
+ "add %4,%%eax ; "
+ "adc %5,%%edx ; "
+ : "=A" (product), "=r" (tmp1), "=r" (tmp2)
+ : "a" ((u32)delta), "1" ((u32)(delta >> 32)), "2" (mul_frac) );
+#elif defined(__x86_64__)
+ __asm__ (
+ "mulq %[mul_frac] ; shrd $32, %[hi], %[lo]"
+ : [lo]"=a"(product),
+ [hi]"=d"(tmp)
+ : "0"(delta),
+ [mul_frac]"rm"((u64)mul_frac));
+#else
+#error implement me!
+#endif
+
+ return product;
+}
+
+static __always_inline
+u64 __pvclock_read_cycles(const struct pvclock_vcpu_time_info *src, u64 tsc)
+{
+ u64 delta = tsc - src->tsc_timestamp;
+ u64 offset = pvclock_scale_delta(delta, src->tsc_to_system_mul,
+ src->tsc_shift);
+ return src->system_time + offset;
+}
+
+struct pvclock_vsyscall_time_info {
+ struct pvclock_vcpu_time_info pvti;
+} __attribute__((__aligned__(64)));
+
+#define PVTI_SIZE sizeof(struct pvclock_vsyscall_time_info)
+
+#ifdef CONFIG_PARAVIRT_CLOCK
+void pvclock_set_pvti_cpu0_va(struct pvclock_vsyscall_time_info *pvti);
+struct pvclock_vsyscall_time_info *pvclock_get_pvti_cpu0_va(void);
+#else
+static inline struct pvclock_vsyscall_time_info *pvclock_get_pvti_cpu0_va(void)
+{
+ return NULL;
+}
+#endif
+
+#endif /* _ASM_X86_PVCLOCK_H */
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 42+ messages in thread
* [PATCH v8 2/9] selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-16 18:15 ` Oliver Upton
-1 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Marc Zyngier, Peter Shier,
Sean Christopherson, David Matlack, Paolo Bonzini,
linux-arm-kernel, Jim Mattson
Add a selftest for the new KVM clock UAPI that was introduced. Ensure
that the KVM clock is consistent between userspace and the guest, and
that the difference in realtime will only ever cause the KVM clock to
advance forward.
Cc: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/.gitignore | 1 +
tools/testing/selftests/kvm/Makefile | 1 +
.../testing/selftests/kvm/include/kvm_util.h | 2 +
.../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++++
4 files changed, 208 insertions(+)
create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
index 98053d3afbda..86a063d1cd3e 100644
--- a/tools/testing/selftests/kvm/.gitignore
+++ b/tools/testing/selftests/kvm/.gitignore
@@ -12,6 +12,7 @@
/x86_64/emulator_error_test
/x86_64/get_cpuid_test
/x86_64/get_msr_index_features
+/x86_64/kvm_clock_test
/x86_64/kvm_pv_test
/x86_64/hyperv_clock
/x86_64/hyperv_cpuid
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index 5d05801ab816..1f969b0192f6 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -46,6 +46,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/get_cpuid_test
TEST_GEN_PROGS_x86_64 += x86_64/hyperv_clock
TEST_GEN_PROGS_x86_64 += x86_64/hyperv_cpuid
TEST_GEN_PROGS_x86_64 += x86_64/hyperv_features
+TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test
TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test
TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test
TEST_GEN_PROGS_x86_64 += x86_64/mmu_role_test
diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h
index 010b59b13917..a8ac5d52e17b 100644
--- a/tools/testing/selftests/kvm/include/kvm_util.h
+++ b/tools/testing/selftests/kvm/include/kvm_util.h
@@ -19,6 +19,8 @@
#define KVM_DEV_PATH "/dev/kvm"
#define KVM_MAX_VCPUS 512
+#define NSEC_PER_SEC 1000000000L
+
/*
* Callers of kvm_util only have an incomplete/opaque description of the
* structure kvm_util is using to maintain the state of a VM.
diff --git a/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
new file mode 100644
index 000000000000..e0dcc27ae9f1
--- /dev/null
+++ b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2021, Google LLC.
+ *
+ * Tests for adjusting the KVM clock from userspace
+ */
+#include <asm/kvm_para.h>
+#include <asm/pvclock.h>
+#include <asm/pvclock-abi.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+
+#include "test_util.h"
+#include "kvm_util.h"
+#include "processor.h"
+
+#define VCPU_ID 0
+
+struct test_case {
+ uint64_t kvmclock_base;
+ int64_t realtime_offset;
+};
+
+static struct test_case test_cases[] = {
+ { .kvmclock_base = 0 },
+ { .kvmclock_base = 180 * NSEC_PER_SEC },
+ { .kvmclock_base = 0, .realtime_offset = -180 * NSEC_PER_SEC },
+ { .kvmclock_base = 0, .realtime_offset = 180 * NSEC_PER_SEC },
+};
+
+#define GUEST_SYNC_CLOCK(__stage, __val) \
+ GUEST_SYNC_ARGS(__stage, __val, 0, 0, 0)
+
+static void guest_main(vm_paddr_t pvti_pa, struct pvclock_vcpu_time_info *pvti)
+{
+ int i;
+
+ wrmsr(MSR_KVM_SYSTEM_TIME_NEW, pvti_pa | KVM_MSR_ENABLED);
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++)
+ GUEST_SYNC_CLOCK(i, __pvclock_read_cycles(pvti, rdtsc()));
+}
+
+#define EXPECTED_FLAGS (KVM_CLOCK_REALTIME | KVM_CLOCK_HOST_TSC)
+
+static inline void assert_flags(struct kvm_clock_data *data)
+{
+ TEST_ASSERT((data->flags & EXPECTED_FLAGS) == EXPECTED_FLAGS,
+ "unexpected clock data flags: %x (want set: %x)",
+ data->flags, EXPECTED_FLAGS);
+}
+
+static void handle_sync(struct ucall *uc, struct kvm_clock_data *start,
+ struct kvm_clock_data *end)
+{
+ uint64_t obs, exp_lo, exp_hi;
+
+ obs = uc->args[2];
+ exp_lo = start->clock;
+ exp_hi = end->clock;
+
+ assert_flags(start);
+ assert_flags(end);
+
+ TEST_ASSERT(exp_lo <= obs && obs <= exp_hi,
+ "unexpected kvm-clock value: %"PRIu64" expected range: [%"PRIu64", %"PRIu64"]",
+ obs, exp_lo, exp_hi);
+
+ pr_info("kvm-clock value: %"PRIu64" expected range [%"PRIu64", %"PRIu64"]\n",
+ obs, exp_lo, exp_hi);
+}
+
+static void handle_abort(struct ucall *uc)
+{
+ TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0],
+ __FILE__, uc->args[1]);
+}
+
+static void setup_clock(struct kvm_vm *vm, struct test_case *test_case)
+{
+ struct kvm_clock_data data;
+
+ memset(&data, 0, sizeof(data));
+
+ data.clock = test_case->kvmclock_base;
+ if (test_case->realtime_offset) {
+ struct timespec ts;
+ int r;
+
+ data.flags |= KVM_CLOCK_REALTIME;
+ do {
+ r = clock_gettime(CLOCK_REALTIME, &ts);
+ if (!r)
+ break;
+ } while (errno == EINTR);
+
+ TEST_ASSERT(!r, "clock_gettime() failed: %d\n", r);
+
+ data.realtime = ts.tv_sec * NSEC_PER_SEC;
+ data.realtime += ts.tv_nsec;
+ data.realtime += test_case->realtime_offset;
+ }
+
+ vm_ioctl(vm, KVM_SET_CLOCK, &data);
+}
+
+static void enter_guest(struct kvm_vm *vm)
+{
+ struct kvm_clock_data start, end;
+ struct kvm_run *run;
+ struct ucall uc;
+ int i, r;
+
+ run = vcpu_state(vm, VCPU_ID);
+
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
+ setup_clock(vm, &test_cases[i]);
+
+ vm_ioctl(vm, KVM_GET_CLOCK, &start);
+
+ r = _vcpu_run(vm, VCPU_ID);
+ vm_ioctl(vm, KVM_GET_CLOCK, &end);
+
+ TEST_ASSERT(!r, "vcpu_run failed: %d\n", r);
+ TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
+ "unexpected exit reason: %u (%s)",
+ run->exit_reason, exit_reason_str(run->exit_reason));
+
+ switch (get_ucall(vm, VCPU_ID, &uc)) {
+ case UCALL_SYNC:
+ handle_sync(&uc, &start, &end);
+ break;
+ case UCALL_ABORT:
+ handle_abort(&uc);
+ return;
+ default:
+ TEST_ASSERT(0, "unhandled ucall: %ld\n",
+ get_ucall(vm, VCPU_ID, &uc));
+ }
+ }
+}
+
+#define CLOCKSOURCE_PATH "/sys/devices/system/clocksource/clocksource0/current_clocksource"
+
+static void check_clocksource(void)
+{
+ char *clk_name;
+ struct stat st;
+ FILE *fp;
+
+ fp = fopen(CLOCKSOURCE_PATH, "r");
+ if (!fp) {
+ pr_info("failed to open clocksource file: %d; assuming TSC.\n",
+ errno);
+ return;
+ }
+
+ if (fstat(fileno(fp), &st)) {
+ pr_info("failed to stat clocksource file: %d; assuming TSC.\n",
+ errno);
+ goto out;
+ }
+
+ clk_name = malloc(st.st_size);
+ TEST_ASSERT(clk_name, "failed to allocate buffer to read file\n");
+
+ if (!fgets(clk_name, st.st_size, fp)) {
+ pr_info("failed to read clocksource file: %d; assuming TSC.\n",
+ ferror(fp));
+ goto out;
+ }
+
+ TEST_ASSERT(!strncmp(clk_name, "tsc\n", st.st_size),
+ "clocksource not supported: %s", clk_name);
+out:
+ fclose(fp);
+}
+
+int main(void)
+{
+ vm_vaddr_t pvti_gva;
+ vm_paddr_t pvti_gpa;
+ struct kvm_vm *vm;
+ int flags;
+
+ flags = kvm_check_cap(KVM_CAP_ADJUST_CLOCK);
+ if (!(flags & KVM_CLOCK_REALTIME)) {
+ print_skip("KVM_CLOCK_REALTIME not supported; flags: %x",
+ flags);
+ exit(KSFT_SKIP);
+ }
+
+ check_clocksource();
+
+ vm = vm_create_default(VCPU_ID, 0, guest_main);
+
+ pvti_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000);
+ pvti_gpa = addr_gva2gpa(vm, pvti_gva);
+ vcpu_args_set(vm, VCPU_ID, 2, pvti_gpa, pvti_gva);
+
+ enter_guest(vm);
+ kvm_vm_free(vm);
+}
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 2/9] selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Add a selftest for the new KVM clock UAPI that was introduced. Ensure
that the KVM clock is consistent between userspace and the guest, and
that the difference in realtime will only ever cause the KVM clock to
advance forward.
Cc: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/.gitignore | 1 +
tools/testing/selftests/kvm/Makefile | 1 +
.../testing/selftests/kvm/include/kvm_util.h | 2 +
.../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++++
4 files changed, 208 insertions(+)
create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
index 98053d3afbda..86a063d1cd3e 100644
--- a/tools/testing/selftests/kvm/.gitignore
+++ b/tools/testing/selftests/kvm/.gitignore
@@ -12,6 +12,7 @@
/x86_64/emulator_error_test
/x86_64/get_cpuid_test
/x86_64/get_msr_index_features
+/x86_64/kvm_clock_test
/x86_64/kvm_pv_test
/x86_64/hyperv_clock
/x86_64/hyperv_cpuid
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index 5d05801ab816..1f969b0192f6 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -46,6 +46,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/get_cpuid_test
TEST_GEN_PROGS_x86_64 += x86_64/hyperv_clock
TEST_GEN_PROGS_x86_64 += x86_64/hyperv_cpuid
TEST_GEN_PROGS_x86_64 += x86_64/hyperv_features
+TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test
TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test
TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test
TEST_GEN_PROGS_x86_64 += x86_64/mmu_role_test
diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h
index 010b59b13917..a8ac5d52e17b 100644
--- a/tools/testing/selftests/kvm/include/kvm_util.h
+++ b/tools/testing/selftests/kvm/include/kvm_util.h
@@ -19,6 +19,8 @@
#define KVM_DEV_PATH "/dev/kvm"
#define KVM_MAX_VCPUS 512
+#define NSEC_PER_SEC 1000000000L
+
/*
* Callers of kvm_util only have an incomplete/opaque description of the
* structure kvm_util is using to maintain the state of a VM.
diff --git a/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
new file mode 100644
index 000000000000..e0dcc27ae9f1
--- /dev/null
+++ b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2021, Google LLC.
+ *
+ * Tests for adjusting the KVM clock from userspace
+ */
+#include <asm/kvm_para.h>
+#include <asm/pvclock.h>
+#include <asm/pvclock-abi.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+
+#include "test_util.h"
+#include "kvm_util.h"
+#include "processor.h"
+
+#define VCPU_ID 0
+
+struct test_case {
+ uint64_t kvmclock_base;
+ int64_t realtime_offset;
+};
+
+static struct test_case test_cases[] = {
+ { .kvmclock_base = 0 },
+ { .kvmclock_base = 180 * NSEC_PER_SEC },
+ { .kvmclock_base = 0, .realtime_offset = -180 * NSEC_PER_SEC },
+ { .kvmclock_base = 0, .realtime_offset = 180 * NSEC_PER_SEC },
+};
+
+#define GUEST_SYNC_CLOCK(__stage, __val) \
+ GUEST_SYNC_ARGS(__stage, __val, 0, 0, 0)
+
+static void guest_main(vm_paddr_t pvti_pa, struct pvclock_vcpu_time_info *pvti)
+{
+ int i;
+
+ wrmsr(MSR_KVM_SYSTEM_TIME_NEW, pvti_pa | KVM_MSR_ENABLED);
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++)
+ GUEST_SYNC_CLOCK(i, __pvclock_read_cycles(pvti, rdtsc()));
+}
+
+#define EXPECTED_FLAGS (KVM_CLOCK_REALTIME | KVM_CLOCK_HOST_TSC)
+
+static inline void assert_flags(struct kvm_clock_data *data)
+{
+ TEST_ASSERT((data->flags & EXPECTED_FLAGS) == EXPECTED_FLAGS,
+ "unexpected clock data flags: %x (want set: %x)",
+ data->flags, EXPECTED_FLAGS);
+}
+
+static void handle_sync(struct ucall *uc, struct kvm_clock_data *start,
+ struct kvm_clock_data *end)
+{
+ uint64_t obs, exp_lo, exp_hi;
+
+ obs = uc->args[2];
+ exp_lo = start->clock;
+ exp_hi = end->clock;
+
+ assert_flags(start);
+ assert_flags(end);
+
+ TEST_ASSERT(exp_lo <= obs && obs <= exp_hi,
+ "unexpected kvm-clock value: %"PRIu64" expected range: [%"PRIu64", %"PRIu64"]",
+ obs, exp_lo, exp_hi);
+
+ pr_info("kvm-clock value: %"PRIu64" expected range [%"PRIu64", %"PRIu64"]\n",
+ obs, exp_lo, exp_hi);
+}
+
+static void handle_abort(struct ucall *uc)
+{
+ TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0],
+ __FILE__, uc->args[1]);
+}
+
+static void setup_clock(struct kvm_vm *vm, struct test_case *test_case)
+{
+ struct kvm_clock_data data;
+
+ memset(&data, 0, sizeof(data));
+
+ data.clock = test_case->kvmclock_base;
+ if (test_case->realtime_offset) {
+ struct timespec ts;
+ int r;
+
+ data.flags |= KVM_CLOCK_REALTIME;
+ do {
+ r = clock_gettime(CLOCK_REALTIME, &ts);
+ if (!r)
+ break;
+ } while (errno == EINTR);
+
+ TEST_ASSERT(!r, "clock_gettime() failed: %d\n", r);
+
+ data.realtime = ts.tv_sec * NSEC_PER_SEC;
+ data.realtime += ts.tv_nsec;
+ data.realtime += test_case->realtime_offset;
+ }
+
+ vm_ioctl(vm, KVM_SET_CLOCK, &data);
+}
+
+static void enter_guest(struct kvm_vm *vm)
+{
+ struct kvm_clock_data start, end;
+ struct kvm_run *run;
+ struct ucall uc;
+ int i, r;
+
+ run = vcpu_state(vm, VCPU_ID);
+
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
+ setup_clock(vm, &test_cases[i]);
+
+ vm_ioctl(vm, KVM_GET_CLOCK, &start);
+
+ r = _vcpu_run(vm, VCPU_ID);
+ vm_ioctl(vm, KVM_GET_CLOCK, &end);
+
+ TEST_ASSERT(!r, "vcpu_run failed: %d\n", r);
+ TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
+ "unexpected exit reason: %u (%s)",
+ run->exit_reason, exit_reason_str(run->exit_reason));
+
+ switch (get_ucall(vm, VCPU_ID, &uc)) {
+ case UCALL_SYNC:
+ handle_sync(&uc, &start, &end);
+ break;
+ case UCALL_ABORT:
+ handle_abort(&uc);
+ return;
+ default:
+ TEST_ASSERT(0, "unhandled ucall: %ld\n",
+ get_ucall(vm, VCPU_ID, &uc));
+ }
+ }
+}
+
+#define CLOCKSOURCE_PATH "/sys/devices/system/clocksource/clocksource0/current_clocksource"
+
+static void check_clocksource(void)
+{
+ char *clk_name;
+ struct stat st;
+ FILE *fp;
+
+ fp = fopen(CLOCKSOURCE_PATH, "r");
+ if (!fp) {
+ pr_info("failed to open clocksource file: %d; assuming TSC.\n",
+ errno);
+ return;
+ }
+
+ if (fstat(fileno(fp), &st)) {
+ pr_info("failed to stat clocksource file: %d; assuming TSC.\n",
+ errno);
+ goto out;
+ }
+
+ clk_name = malloc(st.st_size);
+ TEST_ASSERT(clk_name, "failed to allocate buffer to read file\n");
+
+ if (!fgets(clk_name, st.st_size, fp)) {
+ pr_info("failed to read clocksource file: %d; assuming TSC.\n",
+ ferror(fp));
+ goto out;
+ }
+
+ TEST_ASSERT(!strncmp(clk_name, "tsc\n", st.st_size),
+ "clocksource not supported: %s", clk_name);
+out:
+ fclose(fp);
+}
+
+int main(void)
+{
+ vm_vaddr_t pvti_gva;
+ vm_paddr_t pvti_gpa;
+ struct kvm_vm *vm;
+ int flags;
+
+ flags = kvm_check_cap(KVM_CAP_ADJUST_CLOCK);
+ if (!(flags & KVM_CLOCK_REALTIME)) {
+ print_skip("KVM_CLOCK_REALTIME not supported; flags: %x",
+ flags);
+ exit(KSFT_SKIP);
+ }
+
+ check_clocksource();
+
+ vm = vm_create_default(VCPU_ID, 0, guest_main);
+
+ pvti_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000);
+ pvti_gpa = addr_gva2gpa(vm, pvti_gva);
+ vcpu_args_set(vm, VCPU_ID, 2, pvti_gpa, pvti_gva);
+
+ enter_guest(vm);
+ kvm_vm_free(vm);
+}
--
2.33.0.464.g1972c5931b-goog
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 2/9] selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Add a selftest for the new KVM clock UAPI that was introduced. Ensure
that the KVM clock is consistent between userspace and the guest, and
that the difference in realtime will only ever cause the KVM clock to
advance forward.
Cc: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/.gitignore | 1 +
tools/testing/selftests/kvm/Makefile | 1 +
.../testing/selftests/kvm/include/kvm_util.h | 2 +
.../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++++
4 files changed, 208 insertions(+)
create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
index 98053d3afbda..86a063d1cd3e 100644
--- a/tools/testing/selftests/kvm/.gitignore
+++ b/tools/testing/selftests/kvm/.gitignore
@@ -12,6 +12,7 @@
/x86_64/emulator_error_test
/x86_64/get_cpuid_test
/x86_64/get_msr_index_features
+/x86_64/kvm_clock_test
/x86_64/kvm_pv_test
/x86_64/hyperv_clock
/x86_64/hyperv_cpuid
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index 5d05801ab816..1f969b0192f6 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -46,6 +46,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/get_cpuid_test
TEST_GEN_PROGS_x86_64 += x86_64/hyperv_clock
TEST_GEN_PROGS_x86_64 += x86_64/hyperv_cpuid
TEST_GEN_PROGS_x86_64 += x86_64/hyperv_features
+TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test
TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test
TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test
TEST_GEN_PROGS_x86_64 += x86_64/mmu_role_test
diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h
index 010b59b13917..a8ac5d52e17b 100644
--- a/tools/testing/selftests/kvm/include/kvm_util.h
+++ b/tools/testing/selftests/kvm/include/kvm_util.h
@@ -19,6 +19,8 @@
#define KVM_DEV_PATH "/dev/kvm"
#define KVM_MAX_VCPUS 512
+#define NSEC_PER_SEC 1000000000L
+
/*
* Callers of kvm_util only have an incomplete/opaque description of the
* structure kvm_util is using to maintain the state of a VM.
diff --git a/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
new file mode 100644
index 000000000000..e0dcc27ae9f1
--- /dev/null
+++ b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2021, Google LLC.
+ *
+ * Tests for adjusting the KVM clock from userspace
+ */
+#include <asm/kvm_para.h>
+#include <asm/pvclock.h>
+#include <asm/pvclock-abi.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+
+#include "test_util.h"
+#include "kvm_util.h"
+#include "processor.h"
+
+#define VCPU_ID 0
+
+struct test_case {
+ uint64_t kvmclock_base;
+ int64_t realtime_offset;
+};
+
+static struct test_case test_cases[] = {
+ { .kvmclock_base = 0 },
+ { .kvmclock_base = 180 * NSEC_PER_SEC },
+ { .kvmclock_base = 0, .realtime_offset = -180 * NSEC_PER_SEC },
+ { .kvmclock_base = 0, .realtime_offset = 180 * NSEC_PER_SEC },
+};
+
+#define GUEST_SYNC_CLOCK(__stage, __val) \
+ GUEST_SYNC_ARGS(__stage, __val, 0, 0, 0)
+
+static void guest_main(vm_paddr_t pvti_pa, struct pvclock_vcpu_time_info *pvti)
+{
+ int i;
+
+ wrmsr(MSR_KVM_SYSTEM_TIME_NEW, pvti_pa | KVM_MSR_ENABLED);
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++)
+ GUEST_SYNC_CLOCK(i, __pvclock_read_cycles(pvti, rdtsc()));
+}
+
+#define EXPECTED_FLAGS (KVM_CLOCK_REALTIME | KVM_CLOCK_HOST_TSC)
+
+static inline void assert_flags(struct kvm_clock_data *data)
+{
+ TEST_ASSERT((data->flags & EXPECTED_FLAGS) == EXPECTED_FLAGS,
+ "unexpected clock data flags: %x (want set: %x)",
+ data->flags, EXPECTED_FLAGS);
+}
+
+static void handle_sync(struct ucall *uc, struct kvm_clock_data *start,
+ struct kvm_clock_data *end)
+{
+ uint64_t obs, exp_lo, exp_hi;
+
+ obs = uc->args[2];
+ exp_lo = start->clock;
+ exp_hi = end->clock;
+
+ assert_flags(start);
+ assert_flags(end);
+
+ TEST_ASSERT(exp_lo <= obs && obs <= exp_hi,
+ "unexpected kvm-clock value: %"PRIu64" expected range: [%"PRIu64", %"PRIu64"]",
+ obs, exp_lo, exp_hi);
+
+ pr_info("kvm-clock value: %"PRIu64" expected range [%"PRIu64", %"PRIu64"]\n",
+ obs, exp_lo, exp_hi);
+}
+
+static void handle_abort(struct ucall *uc)
+{
+ TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0],
+ __FILE__, uc->args[1]);
+}
+
+static void setup_clock(struct kvm_vm *vm, struct test_case *test_case)
+{
+ struct kvm_clock_data data;
+
+ memset(&data, 0, sizeof(data));
+
+ data.clock = test_case->kvmclock_base;
+ if (test_case->realtime_offset) {
+ struct timespec ts;
+ int r;
+
+ data.flags |= KVM_CLOCK_REALTIME;
+ do {
+ r = clock_gettime(CLOCK_REALTIME, &ts);
+ if (!r)
+ break;
+ } while (errno == EINTR);
+
+ TEST_ASSERT(!r, "clock_gettime() failed: %d\n", r);
+
+ data.realtime = ts.tv_sec * NSEC_PER_SEC;
+ data.realtime += ts.tv_nsec;
+ data.realtime += test_case->realtime_offset;
+ }
+
+ vm_ioctl(vm, KVM_SET_CLOCK, &data);
+}
+
+static void enter_guest(struct kvm_vm *vm)
+{
+ struct kvm_clock_data start, end;
+ struct kvm_run *run;
+ struct ucall uc;
+ int i, r;
+
+ run = vcpu_state(vm, VCPU_ID);
+
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
+ setup_clock(vm, &test_cases[i]);
+
+ vm_ioctl(vm, KVM_GET_CLOCK, &start);
+
+ r = _vcpu_run(vm, VCPU_ID);
+ vm_ioctl(vm, KVM_GET_CLOCK, &end);
+
+ TEST_ASSERT(!r, "vcpu_run failed: %d\n", r);
+ TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
+ "unexpected exit reason: %u (%s)",
+ run->exit_reason, exit_reason_str(run->exit_reason));
+
+ switch (get_ucall(vm, VCPU_ID, &uc)) {
+ case UCALL_SYNC:
+ handle_sync(&uc, &start, &end);
+ break;
+ case UCALL_ABORT:
+ handle_abort(&uc);
+ return;
+ default:
+ TEST_ASSERT(0, "unhandled ucall: %ld\n",
+ get_ucall(vm, VCPU_ID, &uc));
+ }
+ }
+}
+
+#define CLOCKSOURCE_PATH "/sys/devices/system/clocksource/clocksource0/current_clocksource"
+
+static void check_clocksource(void)
+{
+ char *clk_name;
+ struct stat st;
+ FILE *fp;
+
+ fp = fopen(CLOCKSOURCE_PATH, "r");
+ if (!fp) {
+ pr_info("failed to open clocksource file: %d; assuming TSC.\n",
+ errno);
+ return;
+ }
+
+ if (fstat(fileno(fp), &st)) {
+ pr_info("failed to stat clocksource file: %d; assuming TSC.\n",
+ errno);
+ goto out;
+ }
+
+ clk_name = malloc(st.st_size);
+ TEST_ASSERT(clk_name, "failed to allocate buffer to read file\n");
+
+ if (!fgets(clk_name, st.st_size, fp)) {
+ pr_info("failed to read clocksource file: %d; assuming TSC.\n",
+ ferror(fp));
+ goto out;
+ }
+
+ TEST_ASSERT(!strncmp(clk_name, "tsc\n", st.st_size),
+ "clocksource not supported: %s", clk_name);
+out:
+ fclose(fp);
+}
+
+int main(void)
+{
+ vm_vaddr_t pvti_gva;
+ vm_paddr_t pvti_gpa;
+ struct kvm_vm *vm;
+ int flags;
+
+ flags = kvm_check_cap(KVM_CAP_ADJUST_CLOCK);
+ if (!(flags & KVM_CLOCK_REALTIME)) {
+ print_skip("KVM_CLOCK_REALTIME not supported; flags: %x",
+ flags);
+ exit(KSFT_SKIP);
+ }
+
+ check_clocksource();
+
+ vm = vm_create_default(VCPU_ID, 0, guest_main);
+
+ pvti_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000);
+ pvti_gpa = addr_gva2gpa(vm, pvti_gva);
+ vcpu_args_set(vm, VCPU_ID, 2, pvti_gpa, pvti_gva);
+
+ enter_guest(vm);
+ kvm_vm_free(vm);
+}
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 42+ messages in thread* Re: [PATCH v8 2/9] selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-10-05 6:51 ` Andrew Jones
-1 siblings, 0 replies; 42+ messages in thread
From: Andrew Jones @ 2021-10-05 6:51 UTC (permalink / raw)
To: Oliver Upton
Cc: kvm, kvmarm, Paolo Bonzini, Sean Christopherson, Marc Zyngier,
Peter Shier, Jim Mattson, David Matlack, Ricardo Koller,
Jing Zhang, Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Will Deacon, Catalin Marinas
On Thu, Sep 16, 2021 at 06:15:48PM +0000, Oliver Upton wrote:
> Add a selftest for the new KVM clock UAPI that was introduced. Ensure
> that the KVM clock is consistent between userspace and the guest, and
> that the difference in realtime will only ever cause the KVM clock to
> advance forward.
>
> Cc: Andrew Jones <drjones@redhat.com>
> Signed-off-by: Oliver Upton <oupton@google.com>
> ---
> tools/testing/selftests/kvm/.gitignore | 1 +
> tools/testing/selftests/kvm/Makefile | 1 +
> .../testing/selftests/kvm/include/kvm_util.h | 2 +
> .../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++++
> 4 files changed, 208 insertions(+)
> create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
>
> diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
> index 98053d3afbda..86a063d1cd3e 100644
> --- a/tools/testing/selftests/kvm/.gitignore
> +++ b/tools/testing/selftests/kvm/.gitignore
> @@ -12,6 +12,7 @@
> /x86_64/emulator_error_test
> /x86_64/get_cpuid_test
> /x86_64/get_msr_index_features
> +/x86_64/kvm_clock_test
> /x86_64/kvm_pv_test
> /x86_64/hyperv_clock
> /x86_64/hyperv_cpuid
> diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
> index 5d05801ab816..1f969b0192f6 100644
> --- a/tools/testing/selftests/kvm/Makefile
> +++ b/tools/testing/selftests/kvm/Makefile
> @@ -46,6 +46,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/get_cpuid_test
> TEST_GEN_PROGS_x86_64 += x86_64/hyperv_clock
> TEST_GEN_PROGS_x86_64 += x86_64/hyperv_cpuid
> TEST_GEN_PROGS_x86_64 += x86_64/hyperv_features
> +TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test
> TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test
> TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test
> TEST_GEN_PROGS_x86_64 += x86_64/mmu_role_test
> diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h
> index 010b59b13917..a8ac5d52e17b 100644
> --- a/tools/testing/selftests/kvm/include/kvm_util.h
> +++ b/tools/testing/selftests/kvm/include/kvm_util.h
> @@ -19,6 +19,8 @@
> #define KVM_DEV_PATH "/dev/kvm"
> #define KVM_MAX_VCPUS 512
>
> +#define NSEC_PER_SEC 1000000000L
> +
> /*
> * Callers of kvm_util only have an incomplete/opaque description of the
> * structure kvm_util is using to maintain the state of a VM.
> diff --git a/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
> new file mode 100644
> index 000000000000..e0dcc27ae9f1
> --- /dev/null
> +++ b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
> @@ -0,0 +1,204 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2021, Google LLC.
> + *
> + * Tests for adjusting the KVM clock from userspace
> + */
> +#include <asm/kvm_para.h>
> +#include <asm/pvclock.h>
> +#include <asm/pvclock-abi.h>
> +#include <stdint.h>
> +#include <string.h>
> +#include <sys/stat.h>
> +#include <time.h>
> +
> +#include "test_util.h"
> +#include "kvm_util.h"
> +#include "processor.h"
> +
> +#define VCPU_ID 0
> +
> +struct test_case {
> + uint64_t kvmclock_base;
> + int64_t realtime_offset;
> +};
> +
> +static struct test_case test_cases[] = {
> + { .kvmclock_base = 0 },
> + { .kvmclock_base = 180 * NSEC_PER_SEC },
> + { .kvmclock_base = 0, .realtime_offset = -180 * NSEC_PER_SEC },
> + { .kvmclock_base = 0, .realtime_offset = 180 * NSEC_PER_SEC },
> +};
> +
> +#define GUEST_SYNC_CLOCK(__stage, __val) \
> + GUEST_SYNC_ARGS(__stage, __val, 0, 0, 0)
> +
> +static void guest_main(vm_paddr_t pvti_pa, struct pvclock_vcpu_time_info *pvti)
> +{
> + int i;
> +
> + wrmsr(MSR_KVM_SYSTEM_TIME_NEW, pvti_pa | KVM_MSR_ENABLED);
> + for (i = 0; i < ARRAY_SIZE(test_cases); i++)
> + GUEST_SYNC_CLOCK(i, __pvclock_read_cycles(pvti, rdtsc()));
> +}
> +
> +#define EXPECTED_FLAGS (KVM_CLOCK_REALTIME | KVM_CLOCK_HOST_TSC)
> +
> +static inline void assert_flags(struct kvm_clock_data *data)
> +{
> + TEST_ASSERT((data->flags & EXPECTED_FLAGS) == EXPECTED_FLAGS,
> + "unexpected clock data flags: %x (want set: %x)",
> + data->flags, EXPECTED_FLAGS);
> +}
> +
> +static void handle_sync(struct ucall *uc, struct kvm_clock_data *start,
> + struct kvm_clock_data *end)
> +{
> + uint64_t obs, exp_lo, exp_hi;
> +
> + obs = uc->args[2];
> + exp_lo = start->clock;
> + exp_hi = end->clock;
> +
> + assert_flags(start);
> + assert_flags(end);
> +
> + TEST_ASSERT(exp_lo <= obs && obs <= exp_hi,
> + "unexpected kvm-clock value: %"PRIu64" expected range: [%"PRIu64", %"PRIu64"]",
> + obs, exp_lo, exp_hi);
> +
> + pr_info("kvm-clock value: %"PRIu64" expected range [%"PRIu64", %"PRIu64"]\n",
> + obs, exp_lo, exp_hi);
> +}
> +
> +static void handle_abort(struct ucall *uc)
> +{
> + TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0],
> + __FILE__, uc->args[1]);
> +}
> +
> +static void setup_clock(struct kvm_vm *vm, struct test_case *test_case)
> +{
> + struct kvm_clock_data data;
> +
> + memset(&data, 0, sizeof(data));
> +
> + data.clock = test_case->kvmclock_base;
> + if (test_case->realtime_offset) {
> + struct timespec ts;
> + int r;
> +
> + data.flags |= KVM_CLOCK_REALTIME;
> + do {
> + r = clock_gettime(CLOCK_REALTIME, &ts);
> + if (!r)
> + break;
> + } while (errno == EINTR);
> +
> + TEST_ASSERT(!r, "clock_gettime() failed: %d\n", r);
> +
> + data.realtime = ts.tv_sec * NSEC_PER_SEC;
> + data.realtime += ts.tv_nsec;
> + data.realtime += test_case->realtime_offset;
> + }
> +
> + vm_ioctl(vm, KVM_SET_CLOCK, &data);
> +}
> +
> +static void enter_guest(struct kvm_vm *vm)
> +{
> + struct kvm_clock_data start, end;
> + struct kvm_run *run;
> + struct ucall uc;
> + int i, r;
> +
> + run = vcpu_state(vm, VCPU_ID);
> +
> + for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
> + setup_clock(vm, &test_cases[i]);
> +
> + vm_ioctl(vm, KVM_GET_CLOCK, &start);
> +
> + r = _vcpu_run(vm, VCPU_ID);
> + vm_ioctl(vm, KVM_GET_CLOCK, &end);
> +
> + TEST_ASSERT(!r, "vcpu_run failed: %d\n", r);
_vcpu_run doesn't return until success, so I don't think this assert is
necessary.
> + TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
> + "unexpected exit reason: %u (%s)",
> + run->exit_reason, exit_reason_str(run->exit_reason));
You can leave this to the ucall switch, since if
exit_reason != KVM_EXIT_IO, then you'll get UCALL_NONE
> +
> + switch (get_ucall(vm, VCPU_ID, &uc)) {
> + case UCALL_SYNC:
> + handle_sync(&uc, &start, &end);
> + break;
> + case UCALL_ABORT:
> + handle_abort(&uc);
> + return;
guest_main() doesn't call GUEST_ASSERT, so this case can't be used, but
maybe it's fine to leave it if there's a chance somebody will add a
GUEST_ASSERT later.
> + default:
> + TEST_ASSERT(0, "unhandled ucall: %ld\n",
> + get_ucall(vm, VCPU_ID, &uc));
This can be a TEST_FAIL and no need to refetch uc, can just print uc.cmd.
> + }
> + }
> +}
> +
> +#define CLOCKSOURCE_PATH "/sys/devices/system/clocksource/clocksource0/current_clocksource"
> +
> +static void check_clocksource(void)
> +{
> + char *clk_name;
> + struct stat st;
> + FILE *fp;
> +
> + fp = fopen(CLOCKSOURCE_PATH, "r");
> + if (!fp) {
> + pr_info("failed to open clocksource file: %d; assuming TSC.\n",
> + errno);
> + return;
> + }
> +
> + if (fstat(fileno(fp), &st)) {
> + pr_info("failed to stat clocksource file: %d; assuming TSC.\n",
> + errno);
> + goto out;
> + }
> +
> + clk_name = malloc(st.st_size);
> + TEST_ASSERT(clk_name, "failed to allocate buffer to read file\n");
> +
> + if (!fgets(clk_name, st.st_size, fp)) {
> + pr_info("failed to read clocksource file: %d; assuming TSC.\n",
> + ferror(fp));
> + goto out;
> + }
> +
> + TEST_ASSERT(!strncmp(clk_name, "tsc\n", st.st_size),
> + "clocksource not supported: %s", clk_name);
> +out:
> + fclose(fp);
> +}
> +
> +int main(void)
> +{
> + vm_vaddr_t pvti_gva;
> + vm_paddr_t pvti_gpa;
> + struct kvm_vm *vm;
> + int flags;
> +
> + flags = kvm_check_cap(KVM_CAP_ADJUST_CLOCK);
> + if (!(flags & KVM_CLOCK_REALTIME)) {
> + print_skip("KVM_CLOCK_REALTIME not supported; flags: %x",
> + flags);
> + exit(KSFT_SKIP);
> + }
> +
> + check_clocksource();
> +
> + vm = vm_create_default(VCPU_ID, 0, guest_main);
> +
> + pvti_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000);
> + pvti_gpa = addr_gva2gpa(vm, pvti_gva);
> + vcpu_args_set(vm, VCPU_ID, 2, pvti_gpa, pvti_gva);
> +
> + enter_guest(vm);
> + kvm_vm_free(vm);
> +}
> --
> 2.33.0.464.g1972c5931b-goog
>
All I did was a drive-by review wrt framework APIs, but, besides the ucall
nits, the test looks good to me.
Thanks,
drew
^ permalink raw reply [flat|nested] 42+ messages in thread* Re: [PATCH v8 2/9] selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
@ 2021-10-05 6:51 ` Andrew Jones
0 siblings, 0 replies; 42+ messages in thread
From: Andrew Jones @ 2021-10-05 6:51 UTC (permalink / raw)
To: Oliver Upton
Cc: kvm, kvmarm, Paolo Bonzini, Sean Christopherson, Marc Zyngier,
Peter Shier, Jim Mattson, David Matlack, Ricardo Koller,
Jing Zhang, Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Will Deacon, Catalin Marinas
On Thu, Sep 16, 2021 at 06:15:48PM +0000, Oliver Upton wrote:
> Add a selftest for the new KVM clock UAPI that was introduced. Ensure
> that the KVM clock is consistent between userspace and the guest, and
> that the difference in realtime will only ever cause the KVM clock to
> advance forward.
>
> Cc: Andrew Jones <drjones@redhat.com>
> Signed-off-by: Oliver Upton <oupton@google.com>
> ---
> tools/testing/selftests/kvm/.gitignore | 1 +
> tools/testing/selftests/kvm/Makefile | 1 +
> .../testing/selftests/kvm/include/kvm_util.h | 2 +
> .../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++++
> 4 files changed, 208 insertions(+)
> create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
>
> diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
> index 98053d3afbda..86a063d1cd3e 100644
> --- a/tools/testing/selftests/kvm/.gitignore
> +++ b/tools/testing/selftests/kvm/.gitignore
> @@ -12,6 +12,7 @@
> /x86_64/emulator_error_test
> /x86_64/get_cpuid_test
> /x86_64/get_msr_index_features
> +/x86_64/kvm_clock_test
> /x86_64/kvm_pv_test
> /x86_64/hyperv_clock
> /x86_64/hyperv_cpuid
> diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
> index 5d05801ab816..1f969b0192f6 100644
> --- a/tools/testing/selftests/kvm/Makefile
> +++ b/tools/testing/selftests/kvm/Makefile
> @@ -46,6 +46,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/get_cpuid_test
> TEST_GEN_PROGS_x86_64 += x86_64/hyperv_clock
> TEST_GEN_PROGS_x86_64 += x86_64/hyperv_cpuid
> TEST_GEN_PROGS_x86_64 += x86_64/hyperv_features
> +TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test
> TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test
> TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test
> TEST_GEN_PROGS_x86_64 += x86_64/mmu_role_test
> diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h
> index 010b59b13917..a8ac5d52e17b 100644
> --- a/tools/testing/selftests/kvm/include/kvm_util.h
> +++ b/tools/testing/selftests/kvm/include/kvm_util.h
> @@ -19,6 +19,8 @@
> #define KVM_DEV_PATH "/dev/kvm"
> #define KVM_MAX_VCPUS 512
>
> +#define NSEC_PER_SEC 1000000000L
> +
> /*
> * Callers of kvm_util only have an incomplete/opaque description of the
> * structure kvm_util is using to maintain the state of a VM.
> diff --git a/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
> new file mode 100644
> index 000000000000..e0dcc27ae9f1
> --- /dev/null
> +++ b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
> @@ -0,0 +1,204 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2021, Google LLC.
> + *
> + * Tests for adjusting the KVM clock from userspace
> + */
> +#include <asm/kvm_para.h>
> +#include <asm/pvclock.h>
> +#include <asm/pvclock-abi.h>
> +#include <stdint.h>
> +#include <string.h>
> +#include <sys/stat.h>
> +#include <time.h>
> +
> +#include "test_util.h"
> +#include "kvm_util.h"
> +#include "processor.h"
> +
> +#define VCPU_ID 0
> +
> +struct test_case {
> + uint64_t kvmclock_base;
> + int64_t realtime_offset;
> +};
> +
> +static struct test_case test_cases[] = {
> + { .kvmclock_base = 0 },
> + { .kvmclock_base = 180 * NSEC_PER_SEC },
> + { .kvmclock_base = 0, .realtime_offset = -180 * NSEC_PER_SEC },
> + { .kvmclock_base = 0, .realtime_offset = 180 * NSEC_PER_SEC },
> +};
> +
> +#define GUEST_SYNC_CLOCK(__stage, __val) \
> + GUEST_SYNC_ARGS(__stage, __val, 0, 0, 0)
> +
> +static void guest_main(vm_paddr_t pvti_pa, struct pvclock_vcpu_time_info *pvti)
> +{
> + int i;
> +
> + wrmsr(MSR_KVM_SYSTEM_TIME_NEW, pvti_pa | KVM_MSR_ENABLED);
> + for (i = 0; i < ARRAY_SIZE(test_cases); i++)
> + GUEST_SYNC_CLOCK(i, __pvclock_read_cycles(pvti, rdtsc()));
> +}
> +
> +#define EXPECTED_FLAGS (KVM_CLOCK_REALTIME | KVM_CLOCK_HOST_TSC)
> +
> +static inline void assert_flags(struct kvm_clock_data *data)
> +{
> + TEST_ASSERT((data->flags & EXPECTED_FLAGS) == EXPECTED_FLAGS,
> + "unexpected clock data flags: %x (want set: %x)",
> + data->flags, EXPECTED_FLAGS);
> +}
> +
> +static void handle_sync(struct ucall *uc, struct kvm_clock_data *start,
> + struct kvm_clock_data *end)
> +{
> + uint64_t obs, exp_lo, exp_hi;
> +
> + obs = uc->args[2];
> + exp_lo = start->clock;
> + exp_hi = end->clock;
> +
> + assert_flags(start);
> + assert_flags(end);
> +
> + TEST_ASSERT(exp_lo <= obs && obs <= exp_hi,
> + "unexpected kvm-clock value: %"PRIu64" expected range: [%"PRIu64", %"PRIu64"]",
> + obs, exp_lo, exp_hi);
> +
> + pr_info("kvm-clock value: %"PRIu64" expected range [%"PRIu64", %"PRIu64"]\n",
> + obs, exp_lo, exp_hi);
> +}
> +
> +static void handle_abort(struct ucall *uc)
> +{
> + TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0],
> + __FILE__, uc->args[1]);
> +}
> +
> +static void setup_clock(struct kvm_vm *vm, struct test_case *test_case)
> +{
> + struct kvm_clock_data data;
> +
> + memset(&data, 0, sizeof(data));
> +
> + data.clock = test_case->kvmclock_base;
> + if (test_case->realtime_offset) {
> + struct timespec ts;
> + int r;
> +
> + data.flags |= KVM_CLOCK_REALTIME;
> + do {
> + r = clock_gettime(CLOCK_REALTIME, &ts);
> + if (!r)
> + break;
> + } while (errno == EINTR);
> +
> + TEST_ASSERT(!r, "clock_gettime() failed: %d\n", r);
> +
> + data.realtime = ts.tv_sec * NSEC_PER_SEC;
> + data.realtime += ts.tv_nsec;
> + data.realtime += test_case->realtime_offset;
> + }
> +
> + vm_ioctl(vm, KVM_SET_CLOCK, &data);
> +}
> +
> +static void enter_guest(struct kvm_vm *vm)
> +{
> + struct kvm_clock_data start, end;
> + struct kvm_run *run;
> + struct ucall uc;
> + int i, r;
> +
> + run = vcpu_state(vm, VCPU_ID);
> +
> + for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
> + setup_clock(vm, &test_cases[i]);
> +
> + vm_ioctl(vm, KVM_GET_CLOCK, &start);
> +
> + r = _vcpu_run(vm, VCPU_ID);
> + vm_ioctl(vm, KVM_GET_CLOCK, &end);
> +
> + TEST_ASSERT(!r, "vcpu_run failed: %d\n", r);
_vcpu_run doesn't return until success, so I don't think this assert is
necessary.
> + TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
> + "unexpected exit reason: %u (%s)",
> + run->exit_reason, exit_reason_str(run->exit_reason));
You can leave this to the ucall switch, since if
exit_reason != KVM_EXIT_IO, then you'll get UCALL_NONE
> +
> + switch (get_ucall(vm, VCPU_ID, &uc)) {
> + case UCALL_SYNC:
> + handle_sync(&uc, &start, &end);
> + break;
> + case UCALL_ABORT:
> + handle_abort(&uc);
> + return;
guest_main() doesn't call GUEST_ASSERT, so this case can't be used, but
maybe it's fine to leave it if there's a chance somebody will add a
GUEST_ASSERT later.
> + default:
> + TEST_ASSERT(0, "unhandled ucall: %ld\n",
> + get_ucall(vm, VCPU_ID, &uc));
This can be a TEST_FAIL and no need to refetch uc, can just print uc.cmd.
> + }
> + }
> +}
> +
> +#define CLOCKSOURCE_PATH "/sys/devices/system/clocksource/clocksource0/current_clocksource"
> +
> +static void check_clocksource(void)
> +{
> + char *clk_name;
> + struct stat st;
> + FILE *fp;
> +
> + fp = fopen(CLOCKSOURCE_PATH, "r");
> + if (!fp) {
> + pr_info("failed to open clocksource file: %d; assuming TSC.\n",
> + errno);
> + return;
> + }
> +
> + if (fstat(fileno(fp), &st)) {
> + pr_info("failed to stat clocksource file: %d; assuming TSC.\n",
> + errno);
> + goto out;
> + }
> +
> + clk_name = malloc(st.st_size);
> + TEST_ASSERT(clk_name, "failed to allocate buffer to read file\n");
> +
> + if (!fgets(clk_name, st.st_size, fp)) {
> + pr_info("failed to read clocksource file: %d; assuming TSC.\n",
> + ferror(fp));
> + goto out;
> + }
> +
> + TEST_ASSERT(!strncmp(clk_name, "tsc\n", st.st_size),
> + "clocksource not supported: %s", clk_name);
> +out:
> + fclose(fp);
> +}
> +
> +int main(void)
> +{
> + vm_vaddr_t pvti_gva;
> + vm_paddr_t pvti_gpa;
> + struct kvm_vm *vm;
> + int flags;
> +
> + flags = kvm_check_cap(KVM_CAP_ADJUST_CLOCK);
> + if (!(flags & KVM_CLOCK_REALTIME)) {
> + print_skip("KVM_CLOCK_REALTIME not supported; flags: %x",
> + flags);
> + exit(KSFT_SKIP);
> + }
> +
> + check_clocksource();
> +
> + vm = vm_create_default(VCPU_ID, 0, guest_main);
> +
> + pvti_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000);
> + pvti_gpa = addr_gva2gpa(vm, pvti_gva);
> + vcpu_args_set(vm, VCPU_ID, 2, pvti_gpa, pvti_gva);
> +
> + enter_guest(vm);
> + kvm_vm_free(vm);
> +}
> --
> 2.33.0.464.g1972c5931b-goog
>
All I did was a drive-by review wrt framework APIs, but, besides the ucall
nits, the test looks good to me.
Thanks,
drew
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 42+ messages in thread* Re: [PATCH v8 2/9] selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
@ 2021-10-05 6:51 ` Andrew Jones
0 siblings, 0 replies; 42+ messages in thread
From: Andrew Jones @ 2021-10-05 6:51 UTC (permalink / raw)
To: Oliver Upton
Cc: Catalin Marinas, kvm, Will Deacon, Marc Zyngier, Peter Shier,
David Matlack, Paolo Bonzini, kvmarm, linux-arm-kernel,
Jim Mattson
On Thu, Sep 16, 2021 at 06:15:48PM +0000, Oliver Upton wrote:
> Add a selftest for the new KVM clock UAPI that was introduced. Ensure
> that the KVM clock is consistent between userspace and the guest, and
> that the difference in realtime will only ever cause the KVM clock to
> advance forward.
>
> Cc: Andrew Jones <drjones@redhat.com>
> Signed-off-by: Oliver Upton <oupton@google.com>
> ---
> tools/testing/selftests/kvm/.gitignore | 1 +
> tools/testing/selftests/kvm/Makefile | 1 +
> .../testing/selftests/kvm/include/kvm_util.h | 2 +
> .../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++++
> 4 files changed, 208 insertions(+)
> create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
>
> diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
> index 98053d3afbda..86a063d1cd3e 100644
> --- a/tools/testing/selftests/kvm/.gitignore
> +++ b/tools/testing/selftests/kvm/.gitignore
> @@ -12,6 +12,7 @@
> /x86_64/emulator_error_test
> /x86_64/get_cpuid_test
> /x86_64/get_msr_index_features
> +/x86_64/kvm_clock_test
> /x86_64/kvm_pv_test
> /x86_64/hyperv_clock
> /x86_64/hyperv_cpuid
> diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
> index 5d05801ab816..1f969b0192f6 100644
> --- a/tools/testing/selftests/kvm/Makefile
> +++ b/tools/testing/selftests/kvm/Makefile
> @@ -46,6 +46,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/get_cpuid_test
> TEST_GEN_PROGS_x86_64 += x86_64/hyperv_clock
> TEST_GEN_PROGS_x86_64 += x86_64/hyperv_cpuid
> TEST_GEN_PROGS_x86_64 += x86_64/hyperv_features
> +TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test
> TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test
> TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test
> TEST_GEN_PROGS_x86_64 += x86_64/mmu_role_test
> diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h
> index 010b59b13917..a8ac5d52e17b 100644
> --- a/tools/testing/selftests/kvm/include/kvm_util.h
> +++ b/tools/testing/selftests/kvm/include/kvm_util.h
> @@ -19,6 +19,8 @@
> #define KVM_DEV_PATH "/dev/kvm"
> #define KVM_MAX_VCPUS 512
>
> +#define NSEC_PER_SEC 1000000000L
> +
> /*
> * Callers of kvm_util only have an incomplete/opaque description of the
> * structure kvm_util is using to maintain the state of a VM.
> diff --git a/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
> new file mode 100644
> index 000000000000..e0dcc27ae9f1
> --- /dev/null
> +++ b/tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
> @@ -0,0 +1,204 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2021, Google LLC.
> + *
> + * Tests for adjusting the KVM clock from userspace
> + */
> +#include <asm/kvm_para.h>
> +#include <asm/pvclock.h>
> +#include <asm/pvclock-abi.h>
> +#include <stdint.h>
> +#include <string.h>
> +#include <sys/stat.h>
> +#include <time.h>
> +
> +#include "test_util.h"
> +#include "kvm_util.h"
> +#include "processor.h"
> +
> +#define VCPU_ID 0
> +
> +struct test_case {
> + uint64_t kvmclock_base;
> + int64_t realtime_offset;
> +};
> +
> +static struct test_case test_cases[] = {
> + { .kvmclock_base = 0 },
> + { .kvmclock_base = 180 * NSEC_PER_SEC },
> + { .kvmclock_base = 0, .realtime_offset = -180 * NSEC_PER_SEC },
> + { .kvmclock_base = 0, .realtime_offset = 180 * NSEC_PER_SEC },
> +};
> +
> +#define GUEST_SYNC_CLOCK(__stage, __val) \
> + GUEST_SYNC_ARGS(__stage, __val, 0, 0, 0)
> +
> +static void guest_main(vm_paddr_t pvti_pa, struct pvclock_vcpu_time_info *pvti)
> +{
> + int i;
> +
> + wrmsr(MSR_KVM_SYSTEM_TIME_NEW, pvti_pa | KVM_MSR_ENABLED);
> + for (i = 0; i < ARRAY_SIZE(test_cases); i++)
> + GUEST_SYNC_CLOCK(i, __pvclock_read_cycles(pvti, rdtsc()));
> +}
> +
> +#define EXPECTED_FLAGS (KVM_CLOCK_REALTIME | KVM_CLOCK_HOST_TSC)
> +
> +static inline void assert_flags(struct kvm_clock_data *data)
> +{
> + TEST_ASSERT((data->flags & EXPECTED_FLAGS) == EXPECTED_FLAGS,
> + "unexpected clock data flags: %x (want set: %x)",
> + data->flags, EXPECTED_FLAGS);
> +}
> +
> +static void handle_sync(struct ucall *uc, struct kvm_clock_data *start,
> + struct kvm_clock_data *end)
> +{
> + uint64_t obs, exp_lo, exp_hi;
> +
> + obs = uc->args[2];
> + exp_lo = start->clock;
> + exp_hi = end->clock;
> +
> + assert_flags(start);
> + assert_flags(end);
> +
> + TEST_ASSERT(exp_lo <= obs && obs <= exp_hi,
> + "unexpected kvm-clock value: %"PRIu64" expected range: [%"PRIu64", %"PRIu64"]",
> + obs, exp_lo, exp_hi);
> +
> + pr_info("kvm-clock value: %"PRIu64" expected range [%"PRIu64", %"PRIu64"]\n",
> + obs, exp_lo, exp_hi);
> +}
> +
> +static void handle_abort(struct ucall *uc)
> +{
> + TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0],
> + __FILE__, uc->args[1]);
> +}
> +
> +static void setup_clock(struct kvm_vm *vm, struct test_case *test_case)
> +{
> + struct kvm_clock_data data;
> +
> + memset(&data, 0, sizeof(data));
> +
> + data.clock = test_case->kvmclock_base;
> + if (test_case->realtime_offset) {
> + struct timespec ts;
> + int r;
> +
> + data.flags |= KVM_CLOCK_REALTIME;
> + do {
> + r = clock_gettime(CLOCK_REALTIME, &ts);
> + if (!r)
> + break;
> + } while (errno == EINTR);
> +
> + TEST_ASSERT(!r, "clock_gettime() failed: %d\n", r);
> +
> + data.realtime = ts.tv_sec * NSEC_PER_SEC;
> + data.realtime += ts.tv_nsec;
> + data.realtime += test_case->realtime_offset;
> + }
> +
> + vm_ioctl(vm, KVM_SET_CLOCK, &data);
> +}
> +
> +static void enter_guest(struct kvm_vm *vm)
> +{
> + struct kvm_clock_data start, end;
> + struct kvm_run *run;
> + struct ucall uc;
> + int i, r;
> +
> + run = vcpu_state(vm, VCPU_ID);
> +
> + for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
> + setup_clock(vm, &test_cases[i]);
> +
> + vm_ioctl(vm, KVM_GET_CLOCK, &start);
> +
> + r = _vcpu_run(vm, VCPU_ID);
> + vm_ioctl(vm, KVM_GET_CLOCK, &end);
> +
> + TEST_ASSERT(!r, "vcpu_run failed: %d\n", r);
_vcpu_run doesn't return until success, so I don't think this assert is
necessary.
> + TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
> + "unexpected exit reason: %u (%s)",
> + run->exit_reason, exit_reason_str(run->exit_reason));
You can leave this to the ucall switch, since if
exit_reason != KVM_EXIT_IO, then you'll get UCALL_NONE
> +
> + switch (get_ucall(vm, VCPU_ID, &uc)) {
> + case UCALL_SYNC:
> + handle_sync(&uc, &start, &end);
> + break;
> + case UCALL_ABORT:
> + handle_abort(&uc);
> + return;
guest_main() doesn't call GUEST_ASSERT, so this case can't be used, but
maybe it's fine to leave it if there's a chance somebody will add a
GUEST_ASSERT later.
> + default:
> + TEST_ASSERT(0, "unhandled ucall: %ld\n",
> + get_ucall(vm, VCPU_ID, &uc));
This can be a TEST_FAIL and no need to refetch uc, can just print uc.cmd.
> + }
> + }
> +}
> +
> +#define CLOCKSOURCE_PATH "/sys/devices/system/clocksource/clocksource0/current_clocksource"
> +
> +static void check_clocksource(void)
> +{
> + char *clk_name;
> + struct stat st;
> + FILE *fp;
> +
> + fp = fopen(CLOCKSOURCE_PATH, "r");
> + if (!fp) {
> + pr_info("failed to open clocksource file: %d; assuming TSC.\n",
> + errno);
> + return;
> + }
> +
> + if (fstat(fileno(fp), &st)) {
> + pr_info("failed to stat clocksource file: %d; assuming TSC.\n",
> + errno);
> + goto out;
> + }
> +
> + clk_name = malloc(st.st_size);
> + TEST_ASSERT(clk_name, "failed to allocate buffer to read file\n");
> +
> + if (!fgets(clk_name, st.st_size, fp)) {
> + pr_info("failed to read clocksource file: %d; assuming TSC.\n",
> + ferror(fp));
> + goto out;
> + }
> +
> + TEST_ASSERT(!strncmp(clk_name, "tsc\n", st.st_size),
> + "clocksource not supported: %s", clk_name);
> +out:
> + fclose(fp);
> +}
> +
> +int main(void)
> +{
> + vm_vaddr_t pvti_gva;
> + vm_paddr_t pvti_gpa;
> + struct kvm_vm *vm;
> + int flags;
> +
> + flags = kvm_check_cap(KVM_CAP_ADJUST_CLOCK);
> + if (!(flags & KVM_CLOCK_REALTIME)) {
> + print_skip("KVM_CLOCK_REALTIME not supported; flags: %x",
> + flags);
> + exit(KSFT_SKIP);
> + }
> +
> + check_clocksource();
> +
> + vm = vm_create_default(VCPU_ID, 0, guest_main);
> +
> + pvti_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000);
> + pvti_gpa = addr_gva2gpa(vm, pvti_gva);
> + vcpu_args_set(vm, VCPU_ID, 2, pvti_gpa, pvti_gva);
> +
> + enter_guest(vm);
> + kvm_vm_free(vm);
> +}
> --
> 2.33.0.464.g1972c5931b-goog
>
All I did was a drive-by review wrt framework APIs, but, besides the ucall
nits, the test looks good to me.
Thanks,
drew
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply [flat|nested] 42+ messages in thread
* [PATCH v8 3/9] selftests: KVM: Fix kvm device helper ioctl assertions
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-16 18:15 ` Oliver Upton
-1 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Marc Zyngier, Peter Shier,
Sean Christopherson, David Matlack, Paolo Bonzini,
linux-arm-kernel, Jim Mattson
The KVM_CREATE_DEVICE and KVM_{GET,SET}_DEVICE_ATTR ioctls are defined
to return a value of zero on success. As such, tighten the assertions in
the helper functions to only pass if the return code is zero.
Suggested-by: Andrew Jones <drjones@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/lib/kvm_util.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c
index 10a8ed691c66..0ffc2d39c80d 100644
--- a/tools/testing/selftests/kvm/lib/kvm_util.c
+++ b/tools/testing/selftests/kvm/lib/kvm_util.c
@@ -1984,7 +1984,7 @@ int kvm_device_check_attr(int dev_fd, uint32_t group, uint64_t attr)
{
int ret = _kvm_device_check_attr(dev_fd, group, attr);
- TEST_ASSERT(ret >= 0, "KVM_HAS_DEVICE_ATTR failed, rc: %i errno: %i", ret, errno);
+ TEST_ASSERT(!ret, "KVM_HAS_DEVICE_ATTR failed, rc: %i errno: %i", ret, errno);
return ret;
}
@@ -2008,7 +2008,7 @@ int kvm_create_device(struct kvm_vm *vm, uint64_t type, bool test)
ret = _kvm_create_device(vm, type, test, &fd);
if (!test) {
- TEST_ASSERT(ret >= 0,
+ TEST_ASSERT(!ret,
"KVM_CREATE_DEVICE IOCTL failed, rc: %i errno: %i", ret, errno);
return fd;
}
@@ -2036,7 +2036,7 @@ int kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
{
int ret = _kvm_device_access(dev_fd, group, attr, val, write);
- TEST_ASSERT(ret >= 0, "KVM_SET|GET_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
+ TEST_ASSERT(!ret, "KVM_SET|GET_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
return ret;
}
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 3/9] selftests: KVM: Fix kvm device helper ioctl assertions
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
The KVM_CREATE_DEVICE and KVM_{GET,SET}_DEVICE_ATTR ioctls are defined
to return a value of zero on success. As such, tighten the assertions in
the helper functions to only pass if the return code is zero.
Suggested-by: Andrew Jones <drjones@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/lib/kvm_util.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c
index 10a8ed691c66..0ffc2d39c80d 100644
--- a/tools/testing/selftests/kvm/lib/kvm_util.c
+++ b/tools/testing/selftests/kvm/lib/kvm_util.c
@@ -1984,7 +1984,7 @@ int kvm_device_check_attr(int dev_fd, uint32_t group, uint64_t attr)
{
int ret = _kvm_device_check_attr(dev_fd, group, attr);
- TEST_ASSERT(ret >= 0, "KVM_HAS_DEVICE_ATTR failed, rc: %i errno: %i", ret, errno);
+ TEST_ASSERT(!ret, "KVM_HAS_DEVICE_ATTR failed, rc: %i errno: %i", ret, errno);
return ret;
}
@@ -2008,7 +2008,7 @@ int kvm_create_device(struct kvm_vm *vm, uint64_t type, bool test)
ret = _kvm_create_device(vm, type, test, &fd);
if (!test) {
- TEST_ASSERT(ret >= 0,
+ TEST_ASSERT(!ret,
"KVM_CREATE_DEVICE IOCTL failed, rc: %i errno: %i", ret, errno);
return fd;
}
@@ -2036,7 +2036,7 @@ int kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
{
int ret = _kvm_device_access(dev_fd, group, attr, val, write);
- TEST_ASSERT(ret >= 0, "KVM_SET|GET_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
+ TEST_ASSERT(!ret, "KVM_SET|GET_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
return ret;
}
--
2.33.0.464.g1972c5931b-goog
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 3/9] selftests: KVM: Fix kvm device helper ioctl assertions
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
The KVM_CREATE_DEVICE and KVM_{GET,SET}_DEVICE_ATTR ioctls are defined
to return a value of zero on success. As such, tighten the assertions in
the helper functions to only pass if the return code is zero.
Suggested-by: Andrew Jones <drjones@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/lib/kvm_util.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c
index 10a8ed691c66..0ffc2d39c80d 100644
--- a/tools/testing/selftests/kvm/lib/kvm_util.c
+++ b/tools/testing/selftests/kvm/lib/kvm_util.c
@@ -1984,7 +1984,7 @@ int kvm_device_check_attr(int dev_fd, uint32_t group, uint64_t attr)
{
int ret = _kvm_device_check_attr(dev_fd, group, attr);
- TEST_ASSERT(ret >= 0, "KVM_HAS_DEVICE_ATTR failed, rc: %i errno: %i", ret, errno);
+ TEST_ASSERT(!ret, "KVM_HAS_DEVICE_ATTR failed, rc: %i errno: %i", ret, errno);
return ret;
}
@@ -2008,7 +2008,7 @@ int kvm_create_device(struct kvm_vm *vm, uint64_t type, bool test)
ret = _kvm_create_device(vm, type, test, &fd);
if (!test) {
- TEST_ASSERT(ret >= 0,
+ TEST_ASSERT(!ret,
"KVM_CREATE_DEVICE IOCTL failed, rc: %i errno: %i", ret, errno);
return fd;
}
@@ -2036,7 +2036,7 @@ int kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
{
int ret = _kvm_device_access(dev_fd, group, attr, val, write);
- TEST_ASSERT(ret >= 0, "KVM_SET|GET_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
+ TEST_ASSERT(!ret, "KVM_SET|GET_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
return ret;
}
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 42+ messages in thread
* [PATCH v8 4/9] selftests: KVM: Add helpers for vCPU device attributes
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-16 18:15 ` Oliver Upton
-1 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Marc Zyngier, Peter Shier,
Sean Christopherson, David Matlack, Paolo Bonzini,
linux-arm-kernel, Jim Mattson
vCPU file descriptors are abstracted away from test code in KVM
selftests, meaning that tests cannot directly access a vCPU's device
attributes. Add helpers that tests can use to get at vCPU device
attributes.
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
.../testing/selftests/kvm/include/kvm_util.h | 9 +++++
tools/testing/selftests/kvm/lib/kvm_util.c | 38 +++++++++++++++++++
2 files changed, 47 insertions(+)
diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h
index a8ac5d52e17b..1b3ef5757819 100644
--- a/tools/testing/selftests/kvm/include/kvm_util.h
+++ b/tools/testing/selftests/kvm/include/kvm_util.h
@@ -240,6 +240,15 @@ int _kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
int kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
void *val, bool write);
+int _vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr);
+int vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr);
+int _vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write);
+int vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write);
+
const char *exit_reason_str(unsigned int exit_reason);
void virt_pgd_alloc(struct kvm_vm *vm);
diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c
index 0ffc2d39c80d..0fe66ca6139a 100644
--- a/tools/testing/selftests/kvm/lib/kvm_util.c
+++ b/tools/testing/selftests/kvm/lib/kvm_util.c
@@ -2040,6 +2040,44 @@ int kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
return ret;
}
+int _vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr)
+{
+ struct vcpu *vcpu = vcpu_find(vm, vcpuid);
+
+ TEST_ASSERT(vcpu, "nonexistent vcpu id: %d", vcpuid);
+
+ return _kvm_device_check_attr(vcpu->fd, group, attr);
+}
+
+int vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr)
+{
+ int ret = _vcpu_has_device_attr(vm, vcpuid, group, attr);
+
+ TEST_ASSERT(!ret, "KVM_HAS_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
+ return ret;
+}
+
+int _vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write)
+{
+ struct vcpu *vcpu = vcpu_find(vm, vcpuid);
+
+ TEST_ASSERT(vcpu, "nonexistent vcpu id: %d", vcpuid);
+
+ return _kvm_device_access(vcpu->fd, group, attr, val, write);
+}
+
+int vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write)
+{
+ int ret = _vcpu_access_device_attr(vm, vcpuid, group, attr, val, write);
+
+ TEST_ASSERT(!ret, "KVM_SET|GET_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
+ return ret;
+}
+
/*
* VM Dump
*
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 4/9] selftests: KVM: Add helpers for vCPU device attributes
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
vCPU file descriptors are abstracted away from test code in KVM
selftests, meaning that tests cannot directly access a vCPU's device
attributes. Add helpers that tests can use to get at vCPU device
attributes.
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
.../testing/selftests/kvm/include/kvm_util.h | 9 +++++
tools/testing/selftests/kvm/lib/kvm_util.c | 38 +++++++++++++++++++
2 files changed, 47 insertions(+)
diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h
index a8ac5d52e17b..1b3ef5757819 100644
--- a/tools/testing/selftests/kvm/include/kvm_util.h
+++ b/tools/testing/selftests/kvm/include/kvm_util.h
@@ -240,6 +240,15 @@ int _kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
int kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
void *val, bool write);
+int _vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr);
+int vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr);
+int _vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write);
+int vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write);
+
const char *exit_reason_str(unsigned int exit_reason);
void virt_pgd_alloc(struct kvm_vm *vm);
diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c
index 0ffc2d39c80d..0fe66ca6139a 100644
--- a/tools/testing/selftests/kvm/lib/kvm_util.c
+++ b/tools/testing/selftests/kvm/lib/kvm_util.c
@@ -2040,6 +2040,44 @@ int kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
return ret;
}
+int _vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr)
+{
+ struct vcpu *vcpu = vcpu_find(vm, vcpuid);
+
+ TEST_ASSERT(vcpu, "nonexistent vcpu id: %d", vcpuid);
+
+ return _kvm_device_check_attr(vcpu->fd, group, attr);
+}
+
+int vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr)
+{
+ int ret = _vcpu_has_device_attr(vm, vcpuid, group, attr);
+
+ TEST_ASSERT(!ret, "KVM_HAS_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
+ return ret;
+}
+
+int _vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write)
+{
+ struct vcpu *vcpu = vcpu_find(vm, vcpuid);
+
+ TEST_ASSERT(vcpu, "nonexistent vcpu id: %d", vcpuid);
+
+ return _kvm_device_access(vcpu->fd, group, attr, val, write);
+}
+
+int vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write)
+{
+ int ret = _vcpu_access_device_attr(vm, vcpuid, group, attr, val, write);
+
+ TEST_ASSERT(!ret, "KVM_SET|GET_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
+ return ret;
+}
+
/*
* VM Dump
*
--
2.33.0.464.g1972c5931b-goog
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 4/9] selftests: KVM: Add helpers for vCPU device attributes
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
vCPU file descriptors are abstracted away from test code in KVM
selftests, meaning that tests cannot directly access a vCPU's device
attributes. Add helpers that tests can use to get at vCPU device
attributes.
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
.../testing/selftests/kvm/include/kvm_util.h | 9 +++++
tools/testing/selftests/kvm/lib/kvm_util.c | 38 +++++++++++++++++++
2 files changed, 47 insertions(+)
diff --git a/tools/testing/selftests/kvm/include/kvm_util.h b/tools/testing/selftests/kvm/include/kvm_util.h
index a8ac5d52e17b..1b3ef5757819 100644
--- a/tools/testing/selftests/kvm/include/kvm_util.h
+++ b/tools/testing/selftests/kvm/include/kvm_util.h
@@ -240,6 +240,15 @@ int _kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
int kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
void *val, bool write);
+int _vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr);
+int vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr);
+int _vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write);
+int vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write);
+
const char *exit_reason_str(unsigned int exit_reason);
void virt_pgd_alloc(struct kvm_vm *vm);
diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c
index 0ffc2d39c80d..0fe66ca6139a 100644
--- a/tools/testing/selftests/kvm/lib/kvm_util.c
+++ b/tools/testing/selftests/kvm/lib/kvm_util.c
@@ -2040,6 +2040,44 @@ int kvm_device_access(int dev_fd, uint32_t group, uint64_t attr,
return ret;
}
+int _vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr)
+{
+ struct vcpu *vcpu = vcpu_find(vm, vcpuid);
+
+ TEST_ASSERT(vcpu, "nonexistent vcpu id: %d", vcpuid);
+
+ return _kvm_device_check_attr(vcpu->fd, group, attr);
+}
+
+int vcpu_has_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr)
+{
+ int ret = _vcpu_has_device_attr(vm, vcpuid, group, attr);
+
+ TEST_ASSERT(!ret, "KVM_HAS_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
+ return ret;
+}
+
+int _vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write)
+{
+ struct vcpu *vcpu = vcpu_find(vm, vcpuid);
+
+ TEST_ASSERT(vcpu, "nonexistent vcpu id: %d", vcpuid);
+
+ return _kvm_device_access(vcpu->fd, group, attr, val, write);
+}
+
+int vcpu_access_device_attr(struct kvm_vm *vm, uint32_t vcpuid, uint32_t group,
+ uint64_t attr, void *val, bool write)
+{
+ int ret = _vcpu_access_device_attr(vm, vcpuid, group, attr, val, write);
+
+ TEST_ASSERT(!ret, "KVM_SET|GET_DEVICE_ATTR IOCTL failed, rc: %i errno: %i", ret, errno);
+ return ret;
+}
+
/*
* VM Dump
*
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 42+ messages in thread
* [PATCH v8 5/9] selftests: KVM: Introduce system counter offset test
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-16 18:15 ` Oliver Upton
-1 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Marc Zyngier, Peter Shier,
Sean Christopherson, David Matlack, Paolo Bonzini,
linux-arm-kernel, Jim Mattson
Introduce a KVM selftest to verify that userspace manipulation of the
TSC (via the new vCPU attribute) results in the correct behavior within
the guest.
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/.gitignore | 1 +
tools/testing/selftests/kvm/Makefile | 1 +
.../kvm/system_counter_offset_test.c | 132 ++++++++++++++++++
3 files changed, 134 insertions(+)
create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
index 86a063d1cd3e..aa5a5197716e 100644
--- a/tools/testing/selftests/kvm/.gitignore
+++ b/tools/testing/selftests/kvm/.gitignore
@@ -52,3 +52,4 @@
/set_memory_region_test
/steal_time
/kvm_binary_stats_test
+/system_counter_offset_test
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index 1f969b0192f6..225803ac95bb 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -84,6 +84,7 @@ TEST_GEN_PROGS_x86_64 += memslot_perf_test
TEST_GEN_PROGS_x86_64 += set_memory_region_test
TEST_GEN_PROGS_x86_64 += steal_time
TEST_GEN_PROGS_x86_64 += kvm_binary_stats_test
+TEST_GEN_PROGS_x86_64 += system_counter_offset_test
TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions
TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list
diff --git a/tools/testing/selftests/kvm/system_counter_offset_test.c b/tools/testing/selftests/kvm/system_counter_offset_test.c
new file mode 100644
index 000000000000..b337bbbfa41f
--- /dev/null
+++ b/tools/testing/selftests/kvm/system_counter_offset_test.c
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2021, Google LLC.
+ *
+ * Tests for adjusting the system counter from userspace
+ */
+#include <asm/kvm_para.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+
+#include "test_util.h"
+#include "kvm_util.h"
+#include "processor.h"
+
+#define VCPU_ID 0
+
+#ifdef __x86_64__
+
+struct test_case {
+ uint64_t tsc_offset;
+};
+
+static struct test_case test_cases[] = {
+ { 0 },
+ { 180 * NSEC_PER_SEC },
+ { -180 * NSEC_PER_SEC },
+};
+
+static void check_preconditions(struct kvm_vm *vm)
+{
+ if (!_vcpu_has_device_attr(vm, VCPU_ID, KVM_VCPU_TSC_CTRL, KVM_VCPU_TSC_OFFSET))
+ return;
+
+ print_skip("KVM_VCPU_TSC_OFFSET not supported; skipping test");
+ exit(KSFT_SKIP);
+}
+
+static void setup_system_counter(struct kvm_vm *vm, struct test_case *test)
+{
+ vcpu_access_device_attr(vm, VCPU_ID, KVM_VCPU_TSC_CTRL,
+ KVM_VCPU_TSC_OFFSET, &test->tsc_offset, true);
+}
+
+static uint64_t guest_read_system_counter(struct test_case *test)
+{
+ return rdtsc();
+}
+
+static uint64_t host_read_guest_system_counter(struct test_case *test)
+{
+ return rdtsc() + test->tsc_offset;
+}
+
+#else /* __x86_64__ */
+
+#error test not implemented for this architecture!
+
+#endif
+
+#define GUEST_SYNC_CLOCK(__stage, __val) \
+ GUEST_SYNC_ARGS(__stage, __val, 0, 0, 0)
+
+static void guest_main(void)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
+ struct test_case *test = &test_cases[i];
+
+ GUEST_SYNC_CLOCK(i, guest_read_system_counter(test));
+ }
+}
+
+static void handle_sync(struct ucall *uc, uint64_t start, uint64_t end)
+{
+ uint64_t obs = uc->args[2];
+
+ TEST_ASSERT(start <= obs && obs <= end,
+ "unexpected system counter value: %"PRIu64" expected range: [%"PRIu64", %"PRIu64"]",
+ obs, start, end);
+
+ pr_info("system counter value: %"PRIu64" expected range [%"PRIu64", %"PRIu64"]\n",
+ obs, start, end);
+}
+
+static void handle_abort(struct ucall *uc)
+{
+ TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0],
+ __FILE__, uc->args[1]);
+}
+
+static void enter_guest(struct kvm_vm *vm)
+{
+ uint64_t start, end;
+ struct ucall uc;
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
+ struct test_case *test = &test_cases[i];
+
+ setup_system_counter(vm, test);
+ start = host_read_guest_system_counter(test);
+ vcpu_run(vm, VCPU_ID);
+ end = host_read_guest_system_counter(test);
+
+ switch (get_ucall(vm, VCPU_ID, &uc)) {
+ case UCALL_SYNC:
+ handle_sync(&uc, start, end);
+ break;
+ case UCALL_ABORT:
+ handle_abort(&uc);
+ return;
+ default:
+ TEST_ASSERT(0, "unhandled ucall %ld\n",
+ get_ucall(vm, VCPU_ID, &uc));
+ }
+ }
+}
+
+int main(void)
+{
+ struct kvm_vm *vm;
+
+ vm = vm_create_default(VCPU_ID, 0, guest_main);
+ check_preconditions(vm);
+ ucall_init(vm, NULL);
+
+ enter_guest(vm);
+ kvm_vm_free(vm);
+}
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 5/9] selftests: KVM: Introduce system counter offset test
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Introduce a KVM selftest to verify that userspace manipulation of the
TSC (via the new vCPU attribute) results in the correct behavior within
the guest.
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/.gitignore | 1 +
tools/testing/selftests/kvm/Makefile | 1 +
.../kvm/system_counter_offset_test.c | 132 ++++++++++++++++++
3 files changed, 134 insertions(+)
create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
index 86a063d1cd3e..aa5a5197716e 100644
--- a/tools/testing/selftests/kvm/.gitignore
+++ b/tools/testing/selftests/kvm/.gitignore
@@ -52,3 +52,4 @@
/set_memory_region_test
/steal_time
/kvm_binary_stats_test
+/system_counter_offset_test
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index 1f969b0192f6..225803ac95bb 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -84,6 +84,7 @@ TEST_GEN_PROGS_x86_64 += memslot_perf_test
TEST_GEN_PROGS_x86_64 += set_memory_region_test
TEST_GEN_PROGS_x86_64 += steal_time
TEST_GEN_PROGS_x86_64 += kvm_binary_stats_test
+TEST_GEN_PROGS_x86_64 += system_counter_offset_test
TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions
TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list
diff --git a/tools/testing/selftests/kvm/system_counter_offset_test.c b/tools/testing/selftests/kvm/system_counter_offset_test.c
new file mode 100644
index 000000000000..b337bbbfa41f
--- /dev/null
+++ b/tools/testing/selftests/kvm/system_counter_offset_test.c
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2021, Google LLC.
+ *
+ * Tests for adjusting the system counter from userspace
+ */
+#include <asm/kvm_para.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+
+#include "test_util.h"
+#include "kvm_util.h"
+#include "processor.h"
+
+#define VCPU_ID 0
+
+#ifdef __x86_64__
+
+struct test_case {
+ uint64_t tsc_offset;
+};
+
+static struct test_case test_cases[] = {
+ { 0 },
+ { 180 * NSEC_PER_SEC },
+ { -180 * NSEC_PER_SEC },
+};
+
+static void check_preconditions(struct kvm_vm *vm)
+{
+ if (!_vcpu_has_device_attr(vm, VCPU_ID, KVM_VCPU_TSC_CTRL, KVM_VCPU_TSC_OFFSET))
+ return;
+
+ print_skip("KVM_VCPU_TSC_OFFSET not supported; skipping test");
+ exit(KSFT_SKIP);
+}
+
+static void setup_system_counter(struct kvm_vm *vm, struct test_case *test)
+{
+ vcpu_access_device_attr(vm, VCPU_ID, KVM_VCPU_TSC_CTRL,
+ KVM_VCPU_TSC_OFFSET, &test->tsc_offset, true);
+}
+
+static uint64_t guest_read_system_counter(struct test_case *test)
+{
+ return rdtsc();
+}
+
+static uint64_t host_read_guest_system_counter(struct test_case *test)
+{
+ return rdtsc() + test->tsc_offset;
+}
+
+#else /* __x86_64__ */
+
+#error test not implemented for this architecture!
+
+#endif
+
+#define GUEST_SYNC_CLOCK(__stage, __val) \
+ GUEST_SYNC_ARGS(__stage, __val, 0, 0, 0)
+
+static void guest_main(void)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
+ struct test_case *test = &test_cases[i];
+
+ GUEST_SYNC_CLOCK(i, guest_read_system_counter(test));
+ }
+}
+
+static void handle_sync(struct ucall *uc, uint64_t start, uint64_t end)
+{
+ uint64_t obs = uc->args[2];
+
+ TEST_ASSERT(start <= obs && obs <= end,
+ "unexpected system counter value: %"PRIu64" expected range: [%"PRIu64", %"PRIu64"]",
+ obs, start, end);
+
+ pr_info("system counter value: %"PRIu64" expected range [%"PRIu64", %"PRIu64"]\n",
+ obs, start, end);
+}
+
+static void handle_abort(struct ucall *uc)
+{
+ TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0],
+ __FILE__, uc->args[1]);
+}
+
+static void enter_guest(struct kvm_vm *vm)
+{
+ uint64_t start, end;
+ struct ucall uc;
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
+ struct test_case *test = &test_cases[i];
+
+ setup_system_counter(vm, test);
+ start = host_read_guest_system_counter(test);
+ vcpu_run(vm, VCPU_ID);
+ end = host_read_guest_system_counter(test);
+
+ switch (get_ucall(vm, VCPU_ID, &uc)) {
+ case UCALL_SYNC:
+ handle_sync(&uc, start, end);
+ break;
+ case UCALL_ABORT:
+ handle_abort(&uc);
+ return;
+ default:
+ TEST_ASSERT(0, "unhandled ucall %ld\n",
+ get_ucall(vm, VCPU_ID, &uc));
+ }
+ }
+}
+
+int main(void)
+{
+ struct kvm_vm *vm;
+
+ vm = vm_create_default(VCPU_ID, 0, guest_main);
+ check_preconditions(vm);
+ ucall_init(vm, NULL);
+
+ enter_guest(vm);
+ kvm_vm_free(vm);
+}
--
2.33.0.464.g1972c5931b-goog
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 5/9] selftests: KVM: Introduce system counter offset test
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Introduce a KVM selftest to verify that userspace manipulation of the
TSC (via the new vCPU attribute) results in the correct behavior within
the guest.
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/.gitignore | 1 +
tools/testing/selftests/kvm/Makefile | 1 +
.../kvm/system_counter_offset_test.c | 132 ++++++++++++++++++
3 files changed, 134 insertions(+)
create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
index 86a063d1cd3e..aa5a5197716e 100644
--- a/tools/testing/selftests/kvm/.gitignore
+++ b/tools/testing/selftests/kvm/.gitignore
@@ -52,3 +52,4 @@
/set_memory_region_test
/steal_time
/kvm_binary_stats_test
+/system_counter_offset_test
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index 1f969b0192f6..225803ac95bb 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -84,6 +84,7 @@ TEST_GEN_PROGS_x86_64 += memslot_perf_test
TEST_GEN_PROGS_x86_64 += set_memory_region_test
TEST_GEN_PROGS_x86_64 += steal_time
TEST_GEN_PROGS_x86_64 += kvm_binary_stats_test
+TEST_GEN_PROGS_x86_64 += system_counter_offset_test
TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions
TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list
diff --git a/tools/testing/selftests/kvm/system_counter_offset_test.c b/tools/testing/selftests/kvm/system_counter_offset_test.c
new file mode 100644
index 000000000000..b337bbbfa41f
--- /dev/null
+++ b/tools/testing/selftests/kvm/system_counter_offset_test.c
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2021, Google LLC.
+ *
+ * Tests for adjusting the system counter from userspace
+ */
+#include <asm/kvm_para.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+
+#include "test_util.h"
+#include "kvm_util.h"
+#include "processor.h"
+
+#define VCPU_ID 0
+
+#ifdef __x86_64__
+
+struct test_case {
+ uint64_t tsc_offset;
+};
+
+static struct test_case test_cases[] = {
+ { 0 },
+ { 180 * NSEC_PER_SEC },
+ { -180 * NSEC_PER_SEC },
+};
+
+static void check_preconditions(struct kvm_vm *vm)
+{
+ if (!_vcpu_has_device_attr(vm, VCPU_ID, KVM_VCPU_TSC_CTRL, KVM_VCPU_TSC_OFFSET))
+ return;
+
+ print_skip("KVM_VCPU_TSC_OFFSET not supported; skipping test");
+ exit(KSFT_SKIP);
+}
+
+static void setup_system_counter(struct kvm_vm *vm, struct test_case *test)
+{
+ vcpu_access_device_attr(vm, VCPU_ID, KVM_VCPU_TSC_CTRL,
+ KVM_VCPU_TSC_OFFSET, &test->tsc_offset, true);
+}
+
+static uint64_t guest_read_system_counter(struct test_case *test)
+{
+ return rdtsc();
+}
+
+static uint64_t host_read_guest_system_counter(struct test_case *test)
+{
+ return rdtsc() + test->tsc_offset;
+}
+
+#else /* __x86_64__ */
+
+#error test not implemented for this architecture!
+
+#endif
+
+#define GUEST_SYNC_CLOCK(__stage, __val) \
+ GUEST_SYNC_ARGS(__stage, __val, 0, 0, 0)
+
+static void guest_main(void)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
+ struct test_case *test = &test_cases[i];
+
+ GUEST_SYNC_CLOCK(i, guest_read_system_counter(test));
+ }
+}
+
+static void handle_sync(struct ucall *uc, uint64_t start, uint64_t end)
+{
+ uint64_t obs = uc->args[2];
+
+ TEST_ASSERT(start <= obs && obs <= end,
+ "unexpected system counter value: %"PRIu64" expected range: [%"PRIu64", %"PRIu64"]",
+ obs, start, end);
+
+ pr_info("system counter value: %"PRIu64" expected range [%"PRIu64", %"PRIu64"]\n",
+ obs, start, end);
+}
+
+static void handle_abort(struct ucall *uc)
+{
+ TEST_FAIL("%s at %s:%ld", (const char *)uc->args[0],
+ __FILE__, uc->args[1]);
+}
+
+static void enter_guest(struct kvm_vm *vm)
+{
+ uint64_t start, end;
+ struct ucall uc;
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
+ struct test_case *test = &test_cases[i];
+
+ setup_system_counter(vm, test);
+ start = host_read_guest_system_counter(test);
+ vcpu_run(vm, VCPU_ID);
+ end = host_read_guest_system_counter(test);
+
+ switch (get_ucall(vm, VCPU_ID, &uc)) {
+ case UCALL_SYNC:
+ handle_sync(&uc, start, end);
+ break;
+ case UCALL_ABORT:
+ handle_abort(&uc);
+ return;
+ default:
+ TEST_ASSERT(0, "unhandled ucall %ld\n",
+ get_ucall(vm, VCPU_ID, &uc));
+ }
+ }
+}
+
+int main(void)
+{
+ struct kvm_vm *vm;
+
+ vm = vm_create_default(VCPU_ID, 0, guest_main);
+ check_preconditions(vm);
+ ucall_init(vm, NULL);
+
+ enter_guest(vm);
+ kvm_vm_free(vm);
+}
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 42+ messages in thread
* [PATCH v8 6/9] selftests: KVM: Add support for aarch64 to system_counter_offset_test
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-16 18:15 ` Oliver Upton
-1 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Marc Zyngier, Peter Shier,
Sean Christopherson, David Matlack, Paolo Bonzini,
linux-arm-kernel, Jim Mattson
KVM/arm64 now allows userspace to adjust the guest virtual counter-timer
via a vCPU register. Test that changes to the virtual counter-timer
offset result in the correct view being presented to the guest.
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/Makefile | 1 +
.../selftests/kvm/include/aarch64/processor.h | 12 ++++
.../kvm/system_counter_offset_test.c | 64 ++++++++++++++++++-
3 files changed, 76 insertions(+), 1 deletion(-)
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index 225803ac95bb..fd61d0063c50 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -98,6 +98,7 @@ TEST_GEN_PROGS_aarch64 += kvm_page_table_test
TEST_GEN_PROGS_aarch64 += set_memory_region_test
TEST_GEN_PROGS_aarch64 += steal_time
TEST_GEN_PROGS_aarch64 += kvm_binary_stats_test
+TEST_GEN_PROGS_aarch64 += system_counter_offset_test
TEST_GEN_PROGS_s390x = s390x/memop
TEST_GEN_PROGS_s390x += s390x/resets
diff --git a/tools/testing/selftests/kvm/include/aarch64/processor.h b/tools/testing/selftests/kvm/include/aarch64/processor.h
index c0273aefa63d..4c7472823df3 100644
--- a/tools/testing/selftests/kvm/include/aarch64/processor.h
+++ b/tools/testing/selftests/kvm/include/aarch64/processor.h
@@ -132,4 +132,16 @@ void vm_install_sync_handler(struct kvm_vm *vm,
#define isb() asm volatile("isb" : : : "memory")
+static inline uint64_t read_cntvct_ordered(void)
+{
+ uint64_t r;
+
+ __asm__ __volatile__("isb\n\t"
+ "mrs %0, cntvct_el0\n\t"
+ "isb\n\t"
+ : "=r"(r));
+
+ return r;
+}
+
#endif /* SELFTEST_KVM_PROCESSOR_H */
diff --git a/tools/testing/selftests/kvm/system_counter_offset_test.c b/tools/testing/selftests/kvm/system_counter_offset_test.c
index b337bbbfa41f..7ea406fdd56f 100644
--- a/tools/testing/selftests/kvm/system_counter_offset_test.c
+++ b/tools/testing/selftests/kvm/system_counter_offset_test.c
@@ -53,7 +53,69 @@ static uint64_t host_read_guest_system_counter(struct test_case *test)
return rdtsc() + test->tsc_offset;
}
-#else /* __x86_64__ */
+#elif __aarch64__ /* __x86_64__ */
+
+enum arch_counter {
+ VIRTUAL,
+};
+
+struct test_case {
+ enum arch_counter counter;
+ uint64_t offset;
+};
+
+static struct test_case test_cases[] = {
+ { .counter = VIRTUAL, .offset = 0 },
+ { .counter = VIRTUAL, .offset = 180 * NSEC_PER_SEC },
+ { .counter = VIRTUAL, .offset = -180 * NSEC_PER_SEC },
+};
+
+static void check_preconditions(struct kvm_vm *vm)
+{
+ struct kvm_enable_cap cap = {
+ .cap = KVM_CAP_ARM_VTIMER_OFFSET,
+ };
+
+ if (vcpu_has_reg(vm, VCPU_ID, KVM_REG_ARM_TIMER_OFFSET))
+ return;
+
+ if (!kvm_check_cap(KVM_CAP_ARM_VTIMER_OFFSET)) {
+ print_skip("KVM_REG_ARM_TIMER_OFFSET not supported");
+ exit(KSFT_SKIP);
+ }
+
+ vm_enable_cap(vm, &cap);
+}
+
+static void setup_system_counter(struct kvm_vm *vm, struct test_case *test)
+{
+ struct kvm_one_reg reg = {
+ .id = KVM_REG_ARM_TIMER_OFFSET,
+ .addr = (__u64)&test->offset,
+ };
+
+ vcpu_set_reg(vm, VCPU_ID, ®);
+}
+
+static uint64_t guest_read_system_counter(struct test_case *test)
+{
+ switch (test->counter) {
+ case VIRTUAL:
+ return read_cntvct_ordered();
+ default:
+ GUEST_ASSERT(0);
+ }
+
+ /* unreachable */
+ return 0;
+}
+
+static uint64_t host_read_guest_system_counter(struct test_case *test)
+{
+ return read_cntvct_ordered() - test->offset;
+}
+
+#else /* __aarch64__ */
#error test not implemented for this architecture!
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 6/9] selftests: KVM: Add support for aarch64 to system_counter_offset_test
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
KVM/arm64 now allows userspace to adjust the guest virtual counter-timer
via a vCPU register. Test that changes to the virtual counter-timer
offset result in the correct view being presented to the guest.
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/Makefile | 1 +
.../selftests/kvm/include/aarch64/processor.h | 12 ++++
.../kvm/system_counter_offset_test.c | 64 ++++++++++++++++++-
3 files changed, 76 insertions(+), 1 deletion(-)
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index 225803ac95bb..fd61d0063c50 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -98,6 +98,7 @@ TEST_GEN_PROGS_aarch64 += kvm_page_table_test
TEST_GEN_PROGS_aarch64 += set_memory_region_test
TEST_GEN_PROGS_aarch64 += steal_time
TEST_GEN_PROGS_aarch64 += kvm_binary_stats_test
+TEST_GEN_PROGS_aarch64 += system_counter_offset_test
TEST_GEN_PROGS_s390x = s390x/memop
TEST_GEN_PROGS_s390x += s390x/resets
diff --git a/tools/testing/selftests/kvm/include/aarch64/processor.h b/tools/testing/selftests/kvm/include/aarch64/processor.h
index c0273aefa63d..4c7472823df3 100644
--- a/tools/testing/selftests/kvm/include/aarch64/processor.h
+++ b/tools/testing/selftests/kvm/include/aarch64/processor.h
@@ -132,4 +132,16 @@ void vm_install_sync_handler(struct kvm_vm *vm,
#define isb() asm volatile("isb" : : : "memory")
+static inline uint64_t read_cntvct_ordered(void)
+{
+ uint64_t r;
+
+ __asm__ __volatile__("isb\n\t"
+ "mrs %0, cntvct_el0\n\t"
+ "isb\n\t"
+ : "=r"(r));
+
+ return r;
+}
+
#endif /* SELFTEST_KVM_PROCESSOR_H */
diff --git a/tools/testing/selftests/kvm/system_counter_offset_test.c b/tools/testing/selftests/kvm/system_counter_offset_test.c
index b337bbbfa41f..7ea406fdd56f 100644
--- a/tools/testing/selftests/kvm/system_counter_offset_test.c
+++ b/tools/testing/selftests/kvm/system_counter_offset_test.c
@@ -53,7 +53,69 @@ static uint64_t host_read_guest_system_counter(struct test_case *test)
return rdtsc() + test->tsc_offset;
}
-#else /* __x86_64__ */
+#elif __aarch64__ /* __x86_64__ */
+
+enum arch_counter {
+ VIRTUAL,
+};
+
+struct test_case {
+ enum arch_counter counter;
+ uint64_t offset;
+};
+
+static struct test_case test_cases[] = {
+ { .counter = VIRTUAL, .offset = 0 },
+ { .counter = VIRTUAL, .offset = 180 * NSEC_PER_SEC },
+ { .counter = VIRTUAL, .offset = -180 * NSEC_PER_SEC },
+};
+
+static void check_preconditions(struct kvm_vm *vm)
+{
+ struct kvm_enable_cap cap = {
+ .cap = KVM_CAP_ARM_VTIMER_OFFSET,
+ };
+
+ if (vcpu_has_reg(vm, VCPU_ID, KVM_REG_ARM_TIMER_OFFSET))
+ return;
+
+ if (!kvm_check_cap(KVM_CAP_ARM_VTIMER_OFFSET)) {
+ print_skip("KVM_REG_ARM_TIMER_OFFSET not supported");
+ exit(KSFT_SKIP);
+ }
+
+ vm_enable_cap(vm, &cap);
+}
+
+static void setup_system_counter(struct kvm_vm *vm, struct test_case *test)
+{
+ struct kvm_one_reg reg = {
+ .id = KVM_REG_ARM_TIMER_OFFSET,
+ .addr = (__u64)&test->offset,
+ };
+
+ vcpu_set_reg(vm, VCPU_ID, ®);
+}
+
+static uint64_t guest_read_system_counter(struct test_case *test)
+{
+ switch (test->counter) {
+ case VIRTUAL:
+ return read_cntvct_ordered();
+ default:
+ GUEST_ASSERT(0);
+ }
+
+ /* unreachable */
+ return 0;
+}
+
+static uint64_t host_read_guest_system_counter(struct test_case *test)
+{
+ return read_cntvct_ordered() - test->offset;
+}
+
+#else /* __aarch64__ */
#error test not implemented for this architecture!
--
2.33.0.464.g1972c5931b-goog
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 6/9] selftests: KVM: Add support for aarch64 to system_counter_offset_test
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
KVM/arm64 now allows userspace to adjust the guest virtual counter-timer
via a vCPU register. Test that changes to the virtual counter-timer
offset result in the correct view being presented to the guest.
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
---
tools/testing/selftests/kvm/Makefile | 1 +
.../selftests/kvm/include/aarch64/processor.h | 12 ++++
.../kvm/system_counter_offset_test.c | 64 ++++++++++++++++++-
3 files changed, 76 insertions(+), 1 deletion(-)
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index 225803ac95bb..fd61d0063c50 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -98,6 +98,7 @@ TEST_GEN_PROGS_aarch64 += kvm_page_table_test
TEST_GEN_PROGS_aarch64 += set_memory_region_test
TEST_GEN_PROGS_aarch64 += steal_time
TEST_GEN_PROGS_aarch64 += kvm_binary_stats_test
+TEST_GEN_PROGS_aarch64 += system_counter_offset_test
TEST_GEN_PROGS_s390x = s390x/memop
TEST_GEN_PROGS_s390x += s390x/resets
diff --git a/tools/testing/selftests/kvm/include/aarch64/processor.h b/tools/testing/selftests/kvm/include/aarch64/processor.h
index c0273aefa63d..4c7472823df3 100644
--- a/tools/testing/selftests/kvm/include/aarch64/processor.h
+++ b/tools/testing/selftests/kvm/include/aarch64/processor.h
@@ -132,4 +132,16 @@ void vm_install_sync_handler(struct kvm_vm *vm,
#define isb() asm volatile("isb" : : : "memory")
+static inline uint64_t read_cntvct_ordered(void)
+{
+ uint64_t r;
+
+ __asm__ __volatile__("isb\n\t"
+ "mrs %0, cntvct_el0\n\t"
+ "isb\n\t"
+ : "=r"(r));
+
+ return r;
+}
+
#endif /* SELFTEST_KVM_PROCESSOR_H */
diff --git a/tools/testing/selftests/kvm/system_counter_offset_test.c b/tools/testing/selftests/kvm/system_counter_offset_test.c
index b337bbbfa41f..7ea406fdd56f 100644
--- a/tools/testing/selftests/kvm/system_counter_offset_test.c
+++ b/tools/testing/selftests/kvm/system_counter_offset_test.c
@@ -53,7 +53,69 @@ static uint64_t host_read_guest_system_counter(struct test_case *test)
return rdtsc() + test->tsc_offset;
}
-#else /* __x86_64__ */
+#elif __aarch64__ /* __x86_64__ */
+
+enum arch_counter {
+ VIRTUAL,
+};
+
+struct test_case {
+ enum arch_counter counter;
+ uint64_t offset;
+};
+
+static struct test_case test_cases[] = {
+ { .counter = VIRTUAL, .offset = 0 },
+ { .counter = VIRTUAL, .offset = 180 * NSEC_PER_SEC },
+ { .counter = VIRTUAL, .offset = -180 * NSEC_PER_SEC },
+};
+
+static void check_preconditions(struct kvm_vm *vm)
+{
+ struct kvm_enable_cap cap = {
+ .cap = KVM_CAP_ARM_VTIMER_OFFSET,
+ };
+
+ if (vcpu_has_reg(vm, VCPU_ID, KVM_REG_ARM_TIMER_OFFSET))
+ return;
+
+ if (!kvm_check_cap(KVM_CAP_ARM_VTIMER_OFFSET)) {
+ print_skip("KVM_REG_ARM_TIMER_OFFSET not supported");
+ exit(KSFT_SKIP);
+ }
+
+ vm_enable_cap(vm, &cap);
+}
+
+static void setup_system_counter(struct kvm_vm *vm, struct test_case *test)
+{
+ struct kvm_one_reg reg = {
+ .id = KVM_REG_ARM_TIMER_OFFSET,
+ .addr = (__u64)&test->offset,
+ };
+
+ vcpu_set_reg(vm, VCPU_ID, ®);
+}
+
+static uint64_t guest_read_system_counter(struct test_case *test)
+{
+ switch (test->counter) {
+ case VIRTUAL:
+ return read_cntvct_ordered();
+ default:
+ GUEST_ASSERT(0);
+ }
+
+ /* unreachable */
+ return 0;
+}
+
+static uint64_t host_read_guest_system_counter(struct test_case *test)
+{
+ return read_cntvct_ordered() - test->offset;
+}
+
+#else /* __aarch64__ */
#error test not implemented for this architecture!
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 42+ messages in thread
* [PATCH v8 7/9] selftests: KVM: Test physical counter offsetting
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-16 18:15 ` Oliver Upton
-1 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Marc Zyngier, Peter Shier,
Sean Christopherson, David Matlack, Paolo Bonzini,
linux-arm-kernel, Jim Mattson
Test that userspace adjustment of the guest physical counter-timer
results in the correct view within the guest.
Cc: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
---
.../selftests/kvm/include/aarch64/processor.h | 12 +++++++
.../kvm/system_counter_offset_test.c | 34 ++++++++++++++++---
2 files changed, 42 insertions(+), 4 deletions(-)
diff --git a/tools/testing/selftests/kvm/include/aarch64/processor.h b/tools/testing/selftests/kvm/include/aarch64/processor.h
index 4c7472823df3..57b7802cf9e2 100644
--- a/tools/testing/selftests/kvm/include/aarch64/processor.h
+++ b/tools/testing/selftests/kvm/include/aarch64/processor.h
@@ -144,4 +144,16 @@ static inline uint64_t read_cntvct_ordered(void)
return r;
}
+static inline uint64_t read_cntpct_ordered(void)
+{
+ uint64_t r;
+
+ __asm__ __volatile__("isb\n\t"
+ "mrs %0, cntpct_el0\n\t"
+ "isb\n\t"
+ : "=r"(r));
+
+ return r;
+}
+
#endif /* SELFTEST_KVM_PROCESSOR_H */
diff --git a/tools/testing/selftests/kvm/system_counter_offset_test.c b/tools/testing/selftests/kvm/system_counter_offset_test.c
index 7ea406fdd56f..757b5b2e960e 100644
--- a/tools/testing/selftests/kvm/system_counter_offset_test.c
+++ b/tools/testing/selftests/kvm/system_counter_offset_test.c
@@ -57,6 +57,9 @@ static uint64_t host_read_guest_system_counter(struct test_case *test)
enum arch_counter {
VIRTUAL,
+ PHYSICAL,
+ /* offset physical, read virtual */
+ PHYSICAL_READ_VIRTUAL,
};
struct test_case {
@@ -68,6 +71,12 @@ static struct test_case test_cases[] = {
{ .counter = VIRTUAL, .offset = 0 },
{ .counter = VIRTUAL, .offset = 180 * NSEC_PER_SEC },
{ .counter = VIRTUAL, .offset = -180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL, .offset = 0 },
+ { .counter = PHYSICAL, .offset = 180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL, .offset = -180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL_READ_VIRTUAL, .offset = 0 },
+ { .counter = PHYSICAL_READ_VIRTUAL, .offset = 180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL_READ_VIRTUAL, .offset = -180 * NSEC_PER_SEC },
};
static void check_preconditions(struct kvm_vm *vm)
@@ -76,32 +85,49 @@ static void check_preconditions(struct kvm_vm *vm)
.cap = KVM_CAP_ARM_VTIMER_OFFSET,
};
- if (vcpu_has_reg(vm, VCPU_ID, KVM_REG_ARM_TIMER_OFFSET))
- return;
-
if (!kvm_check_cap(KVM_CAP_ARM_VTIMER_OFFSET)) {
print_skip("KVM_REG_ARM_TIMER_OFFSET not supported");
exit(KSFT_SKIP);
}
vm_enable_cap(vm, &cap);
+
+ if (_vcpu_has_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET)) {
+ print_skip("KVM_ARM_VCPU_TIMER_PHYS_OFFSET not supported");
+ exit(KSFT_SKIP);
+ }
}
static void setup_system_counter(struct kvm_vm *vm, struct test_case *test)
{
+ uint64_t cntvoff, cntpoff;
struct kvm_one_reg reg = {
.id = KVM_REG_ARM_TIMER_OFFSET,
- .addr = (__u64)&test->offset,
+ .addr = (__u64)&cntvoff,
};
+ if (test->counter == VIRTUAL) {
+ cntvoff = test->offset;
+ cntpoff = 0;
+ } else {
+ cntvoff = 0;
+ cntpoff = test->offset;
+ }
+
vcpu_set_reg(vm, VCPU_ID, ®);
+ vcpu_access_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET, &cntpoff, true);
}
static uint64_t guest_read_system_counter(struct test_case *test)
{
switch (test->counter) {
case VIRTUAL:
+ case PHYSICAL_READ_VIRTUAL:
return read_cntvct_ordered();
+ case PHYSICAL:
+ return read_cntpct_ordered();
default:
GUEST_ASSERT(0);
}
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 7/9] selftests: KVM: Test physical counter offsetting
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Test that userspace adjustment of the guest physical counter-timer
results in the correct view within the guest.
Cc: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
---
.../selftests/kvm/include/aarch64/processor.h | 12 +++++++
.../kvm/system_counter_offset_test.c | 34 ++++++++++++++++---
2 files changed, 42 insertions(+), 4 deletions(-)
diff --git a/tools/testing/selftests/kvm/include/aarch64/processor.h b/tools/testing/selftests/kvm/include/aarch64/processor.h
index 4c7472823df3..57b7802cf9e2 100644
--- a/tools/testing/selftests/kvm/include/aarch64/processor.h
+++ b/tools/testing/selftests/kvm/include/aarch64/processor.h
@@ -144,4 +144,16 @@ static inline uint64_t read_cntvct_ordered(void)
return r;
}
+static inline uint64_t read_cntpct_ordered(void)
+{
+ uint64_t r;
+
+ __asm__ __volatile__("isb\n\t"
+ "mrs %0, cntpct_el0\n\t"
+ "isb\n\t"
+ : "=r"(r));
+
+ return r;
+}
+
#endif /* SELFTEST_KVM_PROCESSOR_H */
diff --git a/tools/testing/selftests/kvm/system_counter_offset_test.c b/tools/testing/selftests/kvm/system_counter_offset_test.c
index 7ea406fdd56f..757b5b2e960e 100644
--- a/tools/testing/selftests/kvm/system_counter_offset_test.c
+++ b/tools/testing/selftests/kvm/system_counter_offset_test.c
@@ -57,6 +57,9 @@ static uint64_t host_read_guest_system_counter(struct test_case *test)
enum arch_counter {
VIRTUAL,
+ PHYSICAL,
+ /* offset physical, read virtual */
+ PHYSICAL_READ_VIRTUAL,
};
struct test_case {
@@ -68,6 +71,12 @@ static struct test_case test_cases[] = {
{ .counter = VIRTUAL, .offset = 0 },
{ .counter = VIRTUAL, .offset = 180 * NSEC_PER_SEC },
{ .counter = VIRTUAL, .offset = -180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL, .offset = 0 },
+ { .counter = PHYSICAL, .offset = 180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL, .offset = -180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL_READ_VIRTUAL, .offset = 0 },
+ { .counter = PHYSICAL_READ_VIRTUAL, .offset = 180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL_READ_VIRTUAL, .offset = -180 * NSEC_PER_SEC },
};
static void check_preconditions(struct kvm_vm *vm)
@@ -76,32 +85,49 @@ static void check_preconditions(struct kvm_vm *vm)
.cap = KVM_CAP_ARM_VTIMER_OFFSET,
};
- if (vcpu_has_reg(vm, VCPU_ID, KVM_REG_ARM_TIMER_OFFSET))
- return;
-
if (!kvm_check_cap(KVM_CAP_ARM_VTIMER_OFFSET)) {
print_skip("KVM_REG_ARM_TIMER_OFFSET not supported");
exit(KSFT_SKIP);
}
vm_enable_cap(vm, &cap);
+
+ if (_vcpu_has_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET)) {
+ print_skip("KVM_ARM_VCPU_TIMER_PHYS_OFFSET not supported");
+ exit(KSFT_SKIP);
+ }
}
static void setup_system_counter(struct kvm_vm *vm, struct test_case *test)
{
+ uint64_t cntvoff, cntpoff;
struct kvm_one_reg reg = {
.id = KVM_REG_ARM_TIMER_OFFSET,
- .addr = (__u64)&test->offset,
+ .addr = (__u64)&cntvoff,
};
+ if (test->counter == VIRTUAL) {
+ cntvoff = test->offset;
+ cntpoff = 0;
+ } else {
+ cntvoff = 0;
+ cntpoff = test->offset;
+ }
+
vcpu_set_reg(vm, VCPU_ID, ®);
+ vcpu_access_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET, &cntpoff, true);
}
static uint64_t guest_read_system_counter(struct test_case *test)
{
switch (test->counter) {
case VIRTUAL:
+ case PHYSICAL_READ_VIRTUAL:
return read_cntvct_ordered();
+ case PHYSICAL:
+ return read_cntpct_ordered();
default:
GUEST_ASSERT(0);
}
--
2.33.0.464.g1972c5931b-goog
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 7/9] selftests: KVM: Test physical counter offsetting
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Test that userspace adjustment of the guest physical counter-timer
results in the correct view within the guest.
Cc: Andrew Jones <drjones@redhat.com>
Signed-off-by: Oliver Upton <oupton@google.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
---
.../selftests/kvm/include/aarch64/processor.h | 12 +++++++
.../kvm/system_counter_offset_test.c | 34 ++++++++++++++++---
2 files changed, 42 insertions(+), 4 deletions(-)
diff --git a/tools/testing/selftests/kvm/include/aarch64/processor.h b/tools/testing/selftests/kvm/include/aarch64/processor.h
index 4c7472823df3..57b7802cf9e2 100644
--- a/tools/testing/selftests/kvm/include/aarch64/processor.h
+++ b/tools/testing/selftests/kvm/include/aarch64/processor.h
@@ -144,4 +144,16 @@ static inline uint64_t read_cntvct_ordered(void)
return r;
}
+static inline uint64_t read_cntpct_ordered(void)
+{
+ uint64_t r;
+
+ __asm__ __volatile__("isb\n\t"
+ "mrs %0, cntpct_el0\n\t"
+ "isb\n\t"
+ : "=r"(r));
+
+ return r;
+}
+
#endif /* SELFTEST_KVM_PROCESSOR_H */
diff --git a/tools/testing/selftests/kvm/system_counter_offset_test.c b/tools/testing/selftests/kvm/system_counter_offset_test.c
index 7ea406fdd56f..757b5b2e960e 100644
--- a/tools/testing/selftests/kvm/system_counter_offset_test.c
+++ b/tools/testing/selftests/kvm/system_counter_offset_test.c
@@ -57,6 +57,9 @@ static uint64_t host_read_guest_system_counter(struct test_case *test)
enum arch_counter {
VIRTUAL,
+ PHYSICAL,
+ /* offset physical, read virtual */
+ PHYSICAL_READ_VIRTUAL,
};
struct test_case {
@@ -68,6 +71,12 @@ static struct test_case test_cases[] = {
{ .counter = VIRTUAL, .offset = 0 },
{ .counter = VIRTUAL, .offset = 180 * NSEC_PER_SEC },
{ .counter = VIRTUAL, .offset = -180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL, .offset = 0 },
+ { .counter = PHYSICAL, .offset = 180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL, .offset = -180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL_READ_VIRTUAL, .offset = 0 },
+ { .counter = PHYSICAL_READ_VIRTUAL, .offset = 180 * NSEC_PER_SEC },
+ { .counter = PHYSICAL_READ_VIRTUAL, .offset = -180 * NSEC_PER_SEC },
};
static void check_preconditions(struct kvm_vm *vm)
@@ -76,32 +85,49 @@ static void check_preconditions(struct kvm_vm *vm)
.cap = KVM_CAP_ARM_VTIMER_OFFSET,
};
- if (vcpu_has_reg(vm, VCPU_ID, KVM_REG_ARM_TIMER_OFFSET))
- return;
-
if (!kvm_check_cap(KVM_CAP_ARM_VTIMER_OFFSET)) {
print_skip("KVM_REG_ARM_TIMER_OFFSET not supported");
exit(KSFT_SKIP);
}
vm_enable_cap(vm, &cap);
+
+ if (_vcpu_has_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET)) {
+ print_skip("KVM_ARM_VCPU_TIMER_PHYS_OFFSET not supported");
+ exit(KSFT_SKIP);
+ }
}
static void setup_system_counter(struct kvm_vm *vm, struct test_case *test)
{
+ uint64_t cntvoff, cntpoff;
struct kvm_one_reg reg = {
.id = KVM_REG_ARM_TIMER_OFFSET,
- .addr = (__u64)&test->offset,
+ .addr = (__u64)&cntvoff,
};
+ if (test->counter == VIRTUAL) {
+ cntvoff = test->offset;
+ cntpoff = 0;
+ } else {
+ cntvoff = 0;
+ cntpoff = test->offset;
+ }
+
vcpu_set_reg(vm, VCPU_ID, ®);
+ vcpu_access_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET, &cntpoff, true);
}
static uint64_t guest_read_system_counter(struct test_case *test)
{
switch (test->counter) {
case VIRTUAL:
+ case PHYSICAL_READ_VIRTUAL:
return read_cntvct_ordered();
+ case PHYSICAL:
+ return read_cntpct_ordered();
default:
GUEST_ASSERT(0);
}
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 42+ messages in thread
* [PATCH v8 8/9] selftests: KVM: Add counter emulation benchmark
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-16 18:15 ` Oliver Upton
-1 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Marc Zyngier, Peter Shier,
Sean Christopherson, David Matlack, Paolo Bonzini,
linux-arm-kernel, Jim Mattson
Add a test case for counter emulation on arm64. A side effect of how KVM
handles physical counter offsetting on non-ECV systems is that the
virtual counter will always hit hardware and the physical could be
emulated. Force emulation by writing a nonzero offset to the physical
counter and compare the elapsed cycles to a direct read of the hardware
register.
Reviewed-by: Ricardo Koller <ricarkol@google.com>
Signed-off-by: Oliver Upton <oupton@google.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
---
tools/testing/selftests/kvm/.gitignore | 1 +
tools/testing/selftests/kvm/Makefile | 1 +
.../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++++
3 files changed, 209 insertions(+)
create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
index aa5a5197716e..ae2564b27af0 100644
--- a/tools/testing/selftests/kvm/.gitignore
+++ b/tools/testing/selftests/kvm/.gitignore
@@ -1,4 +1,5 @@
# SPDX-License-Identifier: GPL-2.0-only
+/aarch64/counter_emulation_benchmark
/aarch64/debug-exceptions
/aarch64/get-reg-list
/aarch64/psci_cpu_on_test
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index fd61d0063c50..3c80899b40ee 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -86,6 +86,7 @@ TEST_GEN_PROGS_x86_64 += steal_time
TEST_GEN_PROGS_x86_64 += kvm_binary_stats_test
TEST_GEN_PROGS_x86_64 += system_counter_offset_test
+TEST_GEN_PROGS_aarch64 += aarch64/counter_emulation_benchmark
TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions
TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list
TEST_GEN_PROGS_aarch64 += aarch64/psci_cpu_on_test
diff --git a/tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c b/tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
new file mode 100644
index 000000000000..48dbd9459102
--- /dev/null
+++ b/tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * counter_emulation_benchmark.c -- test to measure the effects of counter
+ * emulation on guest reads of the physical counter.
+ *
+ * Copyright (c) 2021, Google LLC.
+ */
+
+#define _GNU_SOURCE
+#include <asm/kvm.h>
+#include <linux/kvm.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "kvm_util.h"
+#include "processor.h"
+#include "test_util.h"
+
+#define VCPU_ID 0
+
+static struct counter_values {
+ uint64_t cntvct_start;
+ uint64_t cntpct;
+ uint64_t cntvct_end;
+} counter_values;
+
+static uint64_t nr_iterations = 1000;
+
+static void do_test(void)
+{
+ /*
+ * Open-coded approach instead of using helper methods to keep a tight
+ * interval around the physical counter read.
+ */
+ asm volatile("isb\n\t"
+ "mrs %[cntvct_start], cntvct_el0\n\t"
+ "isb\n\t"
+ "mrs %[cntpct], cntpct_el0\n\t"
+ "isb\n\t"
+ "mrs %[cntvct_end], cntvct_el0\n\t"
+ "isb\n\t"
+ : [cntvct_start] "=r"(counter_values.cntvct_start),
+ [cntpct] "=r"(counter_values.cntpct),
+ [cntvct_end] "=r"(counter_values.cntvct_end));
+}
+
+static void guest_main(void)
+{
+ int i;
+
+ for (i = 0; i < nr_iterations; i++) {
+ do_test();
+ GUEST_SYNC(i);
+ }
+
+ for (i = 0; i < nr_iterations; i++) {
+ do_test();
+ GUEST_SYNC(i);
+ }
+}
+
+static void enter_guest(struct kvm_vm *vm)
+{
+ struct ucall uc;
+
+ vcpu_ioctl(vm, VCPU_ID, KVM_RUN, NULL);
+
+ switch (get_ucall(vm, VCPU_ID, &uc)) {
+ case UCALL_SYNC:
+ break;
+ case UCALL_ABORT:
+ TEST_ASSERT(false, "%s at %s:%ld", (const char *)uc.args[0],
+ __FILE__, uc.args[1]);
+ break;
+ default:
+ TEST_ASSERT(false, "unexpected exit: %s",
+ exit_reason_str(vcpu_state(vm, VCPU_ID)->exit_reason));
+ break;
+ }
+}
+
+static double counter_frequency(void)
+{
+ uint32_t freq;
+
+ asm volatile("mrs %0, cntfrq_el0"
+ : "=r" (freq));
+
+ return freq / 1000000.0;
+}
+
+static void log_csv(FILE *csv, bool trapped)
+{
+ double freq = counter_frequency();
+
+ fprintf(csv, "%s,%.02f,%lu,%lu,%lu\n",
+ trapped ? "true" : "false", freq,
+ counter_values.cntvct_start,
+ counter_values.cntpct,
+ counter_values.cntvct_end);
+}
+
+static double run_loop(struct kvm_vm *vm, FILE *csv, bool trapped)
+{
+ double avg = 0;
+ int i;
+
+ for (i = 0; i < nr_iterations; i++) {
+ uint64_t delta;
+
+ enter_guest(vm);
+ sync_global_from_guest(vm, counter_values);
+
+ if (csv)
+ log_csv(csv, trapped);
+
+ delta = counter_values.cntvct_end - counter_values.cntvct_start;
+ avg = ((avg * i) + delta) / (i + 1);
+ }
+
+ return avg;
+}
+
+static void setup_counter(struct kvm_vm *vm, uint64_t offset)
+{
+ vcpu_access_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET, &offset,
+ true);
+}
+
+static void run_tests(struct kvm_vm *vm, FILE *csv)
+{
+ double avg_trapped, avg_native, freq;
+
+ freq = counter_frequency();
+
+ if (csv)
+ fputs("trapped,freq_mhz,cntvct_start,cntpct,cntvct_end\n", csv);
+
+ /* no physical offsetting; kvm allows reads of cntpct_el0 */
+ setup_counter(vm, 0);
+ avg_native = run_loop(vm, csv, false);
+
+ /* force emulation of the physical counter */
+ setup_counter(vm, 1);
+ avg_trapped = run_loop(vm, csv, true);
+
+ pr_info("%lu iterations: average cycles (@%.02fMHz) native: %.02f, trapped: %.02f\n",
+ nr_iterations, freq, avg_native, avg_trapped);
+}
+
+static void usage(const char *program_name)
+{
+ fprintf(stderr,
+ "Usage: %s [-h] [-o csv_file] [-n iterations]\n"
+ " -h prints this message\n"
+ " -n number of test iterations (default: %lu)\n"
+ " -o csv file to write data\n",
+ program_name, nr_iterations);
+}
+
+int main(int argc, char **argv)
+{
+ struct kvm_vm *vm;
+ FILE *csv = NULL;
+ int opt;
+
+ while ((opt = getopt(argc, argv, "hn:o:")) != -1) {
+ switch (opt) {
+ case 'o':
+ csv = fopen(optarg, "w");
+ if (!csv) {
+ fprintf(stderr, "failed to open file '%s': %d\n",
+ optarg, errno);
+ exit(1);
+ }
+ break;
+ case 'n':
+ nr_iterations = strtoul(optarg, NULL, 0);
+ break;
+ default:
+ fprintf(stderr, "unrecognized option: '-%c'\n", opt);
+ /* fallthrough */
+ case 'h':
+ usage(argv[0]);
+ exit(1);
+ }
+ }
+
+ vm = vm_create_default(VCPU_ID, 0, guest_main);
+ sync_global_to_guest(vm, nr_iterations);
+ ucall_init(vm, NULL);
+
+ if (_vcpu_has_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET)) {
+ print_skip("KVM_ARM_VCPU_TIMER_PHYS_OFFSET not supported.");
+ exit(KSFT_SKIP);
+ }
+
+ run_tests(vm, csv);
+ kvm_vm_free(vm);
+
+ if (csv)
+ fclose(csv);
+}
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 8/9] selftests: KVM: Add counter emulation benchmark
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Add a test case for counter emulation on arm64. A side effect of how KVM
handles physical counter offsetting on non-ECV systems is that the
virtual counter will always hit hardware and the physical could be
emulated. Force emulation by writing a nonzero offset to the physical
counter and compare the elapsed cycles to a direct read of the hardware
register.
Reviewed-by: Ricardo Koller <ricarkol@google.com>
Signed-off-by: Oliver Upton <oupton@google.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
---
tools/testing/selftests/kvm/.gitignore | 1 +
tools/testing/selftests/kvm/Makefile | 1 +
.../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++++
3 files changed, 209 insertions(+)
create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
index aa5a5197716e..ae2564b27af0 100644
--- a/tools/testing/selftests/kvm/.gitignore
+++ b/tools/testing/selftests/kvm/.gitignore
@@ -1,4 +1,5 @@
# SPDX-License-Identifier: GPL-2.0-only
+/aarch64/counter_emulation_benchmark
/aarch64/debug-exceptions
/aarch64/get-reg-list
/aarch64/psci_cpu_on_test
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index fd61d0063c50..3c80899b40ee 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -86,6 +86,7 @@ TEST_GEN_PROGS_x86_64 += steal_time
TEST_GEN_PROGS_x86_64 += kvm_binary_stats_test
TEST_GEN_PROGS_x86_64 += system_counter_offset_test
+TEST_GEN_PROGS_aarch64 += aarch64/counter_emulation_benchmark
TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions
TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list
TEST_GEN_PROGS_aarch64 += aarch64/psci_cpu_on_test
diff --git a/tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c b/tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
new file mode 100644
index 000000000000..48dbd9459102
--- /dev/null
+++ b/tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * counter_emulation_benchmark.c -- test to measure the effects of counter
+ * emulation on guest reads of the physical counter.
+ *
+ * Copyright (c) 2021, Google LLC.
+ */
+
+#define _GNU_SOURCE
+#include <asm/kvm.h>
+#include <linux/kvm.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "kvm_util.h"
+#include "processor.h"
+#include "test_util.h"
+
+#define VCPU_ID 0
+
+static struct counter_values {
+ uint64_t cntvct_start;
+ uint64_t cntpct;
+ uint64_t cntvct_end;
+} counter_values;
+
+static uint64_t nr_iterations = 1000;
+
+static void do_test(void)
+{
+ /*
+ * Open-coded approach instead of using helper methods to keep a tight
+ * interval around the physical counter read.
+ */
+ asm volatile("isb\n\t"
+ "mrs %[cntvct_start], cntvct_el0\n\t"
+ "isb\n\t"
+ "mrs %[cntpct], cntpct_el0\n\t"
+ "isb\n\t"
+ "mrs %[cntvct_end], cntvct_el0\n\t"
+ "isb\n\t"
+ : [cntvct_start] "=r"(counter_values.cntvct_start),
+ [cntpct] "=r"(counter_values.cntpct),
+ [cntvct_end] "=r"(counter_values.cntvct_end));
+}
+
+static void guest_main(void)
+{
+ int i;
+
+ for (i = 0; i < nr_iterations; i++) {
+ do_test();
+ GUEST_SYNC(i);
+ }
+
+ for (i = 0; i < nr_iterations; i++) {
+ do_test();
+ GUEST_SYNC(i);
+ }
+}
+
+static void enter_guest(struct kvm_vm *vm)
+{
+ struct ucall uc;
+
+ vcpu_ioctl(vm, VCPU_ID, KVM_RUN, NULL);
+
+ switch (get_ucall(vm, VCPU_ID, &uc)) {
+ case UCALL_SYNC:
+ break;
+ case UCALL_ABORT:
+ TEST_ASSERT(false, "%s at %s:%ld", (const char *)uc.args[0],
+ __FILE__, uc.args[1]);
+ break;
+ default:
+ TEST_ASSERT(false, "unexpected exit: %s",
+ exit_reason_str(vcpu_state(vm, VCPU_ID)->exit_reason));
+ break;
+ }
+}
+
+static double counter_frequency(void)
+{
+ uint32_t freq;
+
+ asm volatile("mrs %0, cntfrq_el0"
+ : "=r" (freq));
+
+ return freq / 1000000.0;
+}
+
+static void log_csv(FILE *csv, bool trapped)
+{
+ double freq = counter_frequency();
+
+ fprintf(csv, "%s,%.02f,%lu,%lu,%lu\n",
+ trapped ? "true" : "false", freq,
+ counter_values.cntvct_start,
+ counter_values.cntpct,
+ counter_values.cntvct_end);
+}
+
+static double run_loop(struct kvm_vm *vm, FILE *csv, bool trapped)
+{
+ double avg = 0;
+ int i;
+
+ for (i = 0; i < nr_iterations; i++) {
+ uint64_t delta;
+
+ enter_guest(vm);
+ sync_global_from_guest(vm, counter_values);
+
+ if (csv)
+ log_csv(csv, trapped);
+
+ delta = counter_values.cntvct_end - counter_values.cntvct_start;
+ avg = ((avg * i) + delta) / (i + 1);
+ }
+
+ return avg;
+}
+
+static void setup_counter(struct kvm_vm *vm, uint64_t offset)
+{
+ vcpu_access_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET, &offset,
+ true);
+}
+
+static void run_tests(struct kvm_vm *vm, FILE *csv)
+{
+ double avg_trapped, avg_native, freq;
+
+ freq = counter_frequency();
+
+ if (csv)
+ fputs("trapped,freq_mhz,cntvct_start,cntpct,cntvct_end\n", csv);
+
+ /* no physical offsetting; kvm allows reads of cntpct_el0 */
+ setup_counter(vm, 0);
+ avg_native = run_loop(vm, csv, false);
+
+ /* force emulation of the physical counter */
+ setup_counter(vm, 1);
+ avg_trapped = run_loop(vm, csv, true);
+
+ pr_info("%lu iterations: average cycles (@%.02fMHz) native: %.02f, trapped: %.02f\n",
+ nr_iterations, freq, avg_native, avg_trapped);
+}
+
+static void usage(const char *program_name)
+{
+ fprintf(stderr,
+ "Usage: %s [-h] [-o csv_file] [-n iterations]\n"
+ " -h prints this message\n"
+ " -n number of test iterations (default: %lu)\n"
+ " -o csv file to write data\n",
+ program_name, nr_iterations);
+}
+
+int main(int argc, char **argv)
+{
+ struct kvm_vm *vm;
+ FILE *csv = NULL;
+ int opt;
+
+ while ((opt = getopt(argc, argv, "hn:o:")) != -1) {
+ switch (opt) {
+ case 'o':
+ csv = fopen(optarg, "w");
+ if (!csv) {
+ fprintf(stderr, "failed to open file '%s': %d\n",
+ optarg, errno);
+ exit(1);
+ }
+ break;
+ case 'n':
+ nr_iterations = strtoul(optarg, NULL, 0);
+ break;
+ default:
+ fprintf(stderr, "unrecognized option: '-%c'\n", opt);
+ /* fallthrough */
+ case 'h':
+ usage(argv[0]);
+ exit(1);
+ }
+ }
+
+ vm = vm_create_default(VCPU_ID, 0, guest_main);
+ sync_global_to_guest(vm, nr_iterations);
+ ucall_init(vm, NULL);
+
+ if (_vcpu_has_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET)) {
+ print_skip("KVM_ARM_VCPU_TIMER_PHYS_OFFSET not supported.");
+ exit(KSFT_SKIP);
+ }
+
+ run_tests(vm, csv);
+ kvm_vm_free(vm);
+
+ if (csv)
+ fclose(csv);
+}
--
2.33.0.464.g1972c5931b-goog
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 8/9] selftests: KVM: Add counter emulation benchmark
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Add a test case for counter emulation on arm64. A side effect of how KVM
handles physical counter offsetting on non-ECV systems is that the
virtual counter will always hit hardware and the physical could be
emulated. Force emulation by writing a nonzero offset to the physical
counter and compare the elapsed cycles to a direct read of the hardware
register.
Reviewed-by: Ricardo Koller <ricarkol@google.com>
Signed-off-by: Oliver Upton <oupton@google.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
---
tools/testing/selftests/kvm/.gitignore | 1 +
tools/testing/selftests/kvm/Makefile | 1 +
.../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++++
3 files changed, 209 insertions(+)
create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
index aa5a5197716e..ae2564b27af0 100644
--- a/tools/testing/selftests/kvm/.gitignore
+++ b/tools/testing/selftests/kvm/.gitignore
@@ -1,4 +1,5 @@
# SPDX-License-Identifier: GPL-2.0-only
+/aarch64/counter_emulation_benchmark
/aarch64/debug-exceptions
/aarch64/get-reg-list
/aarch64/psci_cpu_on_test
diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index fd61d0063c50..3c80899b40ee 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -86,6 +86,7 @@ TEST_GEN_PROGS_x86_64 += steal_time
TEST_GEN_PROGS_x86_64 += kvm_binary_stats_test
TEST_GEN_PROGS_x86_64 += system_counter_offset_test
+TEST_GEN_PROGS_aarch64 += aarch64/counter_emulation_benchmark
TEST_GEN_PROGS_aarch64 += aarch64/debug-exceptions
TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list
TEST_GEN_PROGS_aarch64 += aarch64/psci_cpu_on_test
diff --git a/tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c b/tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
new file mode 100644
index 000000000000..48dbd9459102
--- /dev/null
+++ b/tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * counter_emulation_benchmark.c -- test to measure the effects of counter
+ * emulation on guest reads of the physical counter.
+ *
+ * Copyright (c) 2021, Google LLC.
+ */
+
+#define _GNU_SOURCE
+#include <asm/kvm.h>
+#include <linux/kvm.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "kvm_util.h"
+#include "processor.h"
+#include "test_util.h"
+
+#define VCPU_ID 0
+
+static struct counter_values {
+ uint64_t cntvct_start;
+ uint64_t cntpct;
+ uint64_t cntvct_end;
+} counter_values;
+
+static uint64_t nr_iterations = 1000;
+
+static void do_test(void)
+{
+ /*
+ * Open-coded approach instead of using helper methods to keep a tight
+ * interval around the physical counter read.
+ */
+ asm volatile("isb\n\t"
+ "mrs %[cntvct_start], cntvct_el0\n\t"
+ "isb\n\t"
+ "mrs %[cntpct], cntpct_el0\n\t"
+ "isb\n\t"
+ "mrs %[cntvct_end], cntvct_el0\n\t"
+ "isb\n\t"
+ : [cntvct_start] "=r"(counter_values.cntvct_start),
+ [cntpct] "=r"(counter_values.cntpct),
+ [cntvct_end] "=r"(counter_values.cntvct_end));
+}
+
+static void guest_main(void)
+{
+ int i;
+
+ for (i = 0; i < nr_iterations; i++) {
+ do_test();
+ GUEST_SYNC(i);
+ }
+
+ for (i = 0; i < nr_iterations; i++) {
+ do_test();
+ GUEST_SYNC(i);
+ }
+}
+
+static void enter_guest(struct kvm_vm *vm)
+{
+ struct ucall uc;
+
+ vcpu_ioctl(vm, VCPU_ID, KVM_RUN, NULL);
+
+ switch (get_ucall(vm, VCPU_ID, &uc)) {
+ case UCALL_SYNC:
+ break;
+ case UCALL_ABORT:
+ TEST_ASSERT(false, "%s at %s:%ld", (const char *)uc.args[0],
+ __FILE__, uc.args[1]);
+ break;
+ default:
+ TEST_ASSERT(false, "unexpected exit: %s",
+ exit_reason_str(vcpu_state(vm, VCPU_ID)->exit_reason));
+ break;
+ }
+}
+
+static double counter_frequency(void)
+{
+ uint32_t freq;
+
+ asm volatile("mrs %0, cntfrq_el0"
+ : "=r" (freq));
+
+ return freq / 1000000.0;
+}
+
+static void log_csv(FILE *csv, bool trapped)
+{
+ double freq = counter_frequency();
+
+ fprintf(csv, "%s,%.02f,%lu,%lu,%lu\n",
+ trapped ? "true" : "false", freq,
+ counter_values.cntvct_start,
+ counter_values.cntpct,
+ counter_values.cntvct_end);
+}
+
+static double run_loop(struct kvm_vm *vm, FILE *csv, bool trapped)
+{
+ double avg = 0;
+ int i;
+
+ for (i = 0; i < nr_iterations; i++) {
+ uint64_t delta;
+
+ enter_guest(vm);
+ sync_global_from_guest(vm, counter_values);
+
+ if (csv)
+ log_csv(csv, trapped);
+
+ delta = counter_values.cntvct_end - counter_values.cntvct_start;
+ avg = ((avg * i) + delta) / (i + 1);
+ }
+
+ return avg;
+}
+
+static void setup_counter(struct kvm_vm *vm, uint64_t offset)
+{
+ vcpu_access_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET, &offset,
+ true);
+}
+
+static void run_tests(struct kvm_vm *vm, FILE *csv)
+{
+ double avg_trapped, avg_native, freq;
+
+ freq = counter_frequency();
+
+ if (csv)
+ fputs("trapped,freq_mhz,cntvct_start,cntpct,cntvct_end\n", csv);
+
+ /* no physical offsetting; kvm allows reads of cntpct_el0 */
+ setup_counter(vm, 0);
+ avg_native = run_loop(vm, csv, false);
+
+ /* force emulation of the physical counter */
+ setup_counter(vm, 1);
+ avg_trapped = run_loop(vm, csv, true);
+
+ pr_info("%lu iterations: average cycles (@%.02fMHz) native: %.02f, trapped: %.02f\n",
+ nr_iterations, freq, avg_native, avg_trapped);
+}
+
+static void usage(const char *program_name)
+{
+ fprintf(stderr,
+ "Usage: %s [-h] [-o csv_file] [-n iterations]\n"
+ " -h prints this message\n"
+ " -n number of test iterations (default: %lu)\n"
+ " -o csv file to write data\n",
+ program_name, nr_iterations);
+}
+
+int main(int argc, char **argv)
+{
+ struct kvm_vm *vm;
+ FILE *csv = NULL;
+ int opt;
+
+ while ((opt = getopt(argc, argv, "hn:o:")) != -1) {
+ switch (opt) {
+ case 'o':
+ csv = fopen(optarg, "w");
+ if (!csv) {
+ fprintf(stderr, "failed to open file '%s': %d\n",
+ optarg, errno);
+ exit(1);
+ }
+ break;
+ case 'n':
+ nr_iterations = strtoul(optarg, NULL, 0);
+ break;
+ default:
+ fprintf(stderr, "unrecognized option: '-%c'\n", opt);
+ /* fallthrough */
+ case 'h':
+ usage(argv[0]);
+ exit(1);
+ }
+ }
+
+ vm = vm_create_default(VCPU_ID, 0, guest_main);
+ sync_global_to_guest(vm, nr_iterations);
+ ucall_init(vm, NULL);
+
+ if (_vcpu_has_device_attr(vm, VCPU_ID, KVM_ARM_VCPU_TIMER_CTRL,
+ KVM_ARM_VCPU_TIMER_PHYS_OFFSET)) {
+ print_skip("KVM_ARM_VCPU_TIMER_PHYS_OFFSET not supported.");
+ exit(KSFT_SKIP);
+ }
+
+ run_tests(vm, csv);
+ kvm_vm_free(vm);
+
+ if (csv)
+ fclose(csv);
+}
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 42+ messages in thread
* [PATCH v8 9/9] selftests: KVM: Test vtimer offset reg in get-reg-list
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-16 18:15 ` Oliver Upton
-1 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Marc Zyngier, Peter Shier,
Sean Christopherson, David Matlack, Paolo Bonzini,
linux-arm-kernel, Jim Mattson
Assert that KVM exposes KVM_REG_ARM_TIMER_OFFSET in the KVM_GET_REG_LIST
ioctl when userspace buys in to the new behavior.
Signed-off-by: Oliver Upton <oupton@google.com>
---
.../selftests/kvm/aarch64/get-reg-list.c | 42 +++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/tools/testing/selftests/kvm/aarch64/get-reg-list.c b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
index cc898181faab..4f337d8b793a 100644
--- a/tools/testing/selftests/kvm/aarch64/get-reg-list.c
+++ b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
@@ -40,6 +40,7 @@ static __u64 *blessed_reg, blessed_n;
struct reg_sublist {
const char *name;
long capability;
+ long enable_capability;
int feature;
bool finalize;
__u64 *regs;
@@ -397,6 +398,19 @@ static void check_supported(struct vcpu_config *c)
}
}
+static void enable_caps(struct kvm_vm *vm, struct vcpu_config *c)
+{
+ struct kvm_enable_cap cap = {0};
+ struct reg_sublist *s;
+
+ for_each_sublist(c, s) {
+ if (s->enable_capability) {
+ cap.cap = s->enable_capability;
+ vm_enable_cap(vm, &cap);
+ }
+ }
+}
+
static bool print_list;
static bool print_filtered;
static bool fixup_core_regs;
@@ -412,6 +426,8 @@ static void run_test(struct vcpu_config *c)
check_supported(c);
vm = vm_create(VM_MODE_DEFAULT, DEFAULT_GUEST_PHY_PAGES, O_RDWR);
+ enable_caps(vm, c);
+
prepare_vcpu_init(c, &init);
aarch64_vcpu_add_default(vm, 0, &init, NULL);
finalize_vcpu(vm, 0, c);
@@ -1014,6 +1030,10 @@ static __u64 sve_rejects_set[] = {
KVM_REG_ARM64_SVE_VLS,
};
+static __u64 vtimer_offset_regs[] = {
+ KVM_REG_ARM_TIMER_OFFSET,
+};
+
#define BASE_SUBLIST \
{ "base", .regs = base_regs, .regs_n = ARRAY_SIZE(base_regs), }
#define VREGS_SUBLIST \
@@ -1025,6 +1045,10 @@ static __u64 sve_rejects_set[] = {
{ "sve", .capability = KVM_CAP_ARM_SVE, .feature = KVM_ARM_VCPU_SVE, .finalize = true, \
.regs = sve_regs, .regs_n = ARRAY_SIZE(sve_regs), \
.rejects_set = sve_rejects_set, .rejects_set_n = ARRAY_SIZE(sve_rejects_set), }
+#define VTIMER_OFFSET_SUBLIST \
+ { "vtimer_offset", .capability = KVM_CAP_ARM_VTIMER_OFFSET, \
+ .enable_capability = KVM_CAP_ARM_VTIMER_OFFSET, .regs = vtimer_offset_regs, \
+ .regs_n = ARRAY_SIZE(vtimer_offset_regs), }
static struct vcpu_config vregs_config = {
.sublists = {
@@ -1041,6 +1065,14 @@ static struct vcpu_config vregs_pmu_config = {
{0},
},
};
+static struct vcpu_config vregs_vtimer_config = {
+ .sublists = {
+ BASE_SUBLIST,
+ VREGS_SUBLIST,
+ VTIMER_OFFSET_SUBLIST,
+ {0},
+ },
+};
static struct vcpu_config sve_config = {
.sublists = {
BASE_SUBLIST,
@@ -1056,11 +1088,21 @@ static struct vcpu_config sve_pmu_config = {
{0},
},
};
+static struct vcpu_config sve_vtimer_config = {
+ .sublists = {
+ BASE_SUBLIST,
+ SVE_SUBLIST,
+ VTIMER_OFFSET_SUBLIST,
+ {0},
+ },
+};
static struct vcpu_config *vcpu_configs[] = {
&vregs_config,
&vregs_pmu_config,
+ &vregs_vtimer_config,
&sve_config,
&sve_pmu_config,
+ &sve_vtimer_config,
};
static int vcpu_configs_n = ARRAY_SIZE(vcpu_configs);
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 9/9] selftests: KVM: Test vtimer offset reg in get-reg-list
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Assert that KVM exposes KVM_REG_ARM_TIMER_OFFSET in the KVM_GET_REG_LIST
ioctl when userspace buys in to the new behavior.
Signed-off-by: Oliver Upton <oupton@google.com>
---
.../selftests/kvm/aarch64/get-reg-list.c | 42 +++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/tools/testing/selftests/kvm/aarch64/get-reg-list.c b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
index cc898181faab..4f337d8b793a 100644
--- a/tools/testing/selftests/kvm/aarch64/get-reg-list.c
+++ b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
@@ -40,6 +40,7 @@ static __u64 *blessed_reg, blessed_n;
struct reg_sublist {
const char *name;
long capability;
+ long enable_capability;
int feature;
bool finalize;
__u64 *regs;
@@ -397,6 +398,19 @@ static void check_supported(struct vcpu_config *c)
}
}
+static void enable_caps(struct kvm_vm *vm, struct vcpu_config *c)
+{
+ struct kvm_enable_cap cap = {0};
+ struct reg_sublist *s;
+
+ for_each_sublist(c, s) {
+ if (s->enable_capability) {
+ cap.cap = s->enable_capability;
+ vm_enable_cap(vm, &cap);
+ }
+ }
+}
+
static bool print_list;
static bool print_filtered;
static bool fixup_core_regs;
@@ -412,6 +426,8 @@ static void run_test(struct vcpu_config *c)
check_supported(c);
vm = vm_create(VM_MODE_DEFAULT, DEFAULT_GUEST_PHY_PAGES, O_RDWR);
+ enable_caps(vm, c);
+
prepare_vcpu_init(c, &init);
aarch64_vcpu_add_default(vm, 0, &init, NULL);
finalize_vcpu(vm, 0, c);
@@ -1014,6 +1030,10 @@ static __u64 sve_rejects_set[] = {
KVM_REG_ARM64_SVE_VLS,
};
+static __u64 vtimer_offset_regs[] = {
+ KVM_REG_ARM_TIMER_OFFSET,
+};
+
#define BASE_SUBLIST \
{ "base", .regs = base_regs, .regs_n = ARRAY_SIZE(base_regs), }
#define VREGS_SUBLIST \
@@ -1025,6 +1045,10 @@ static __u64 sve_rejects_set[] = {
{ "sve", .capability = KVM_CAP_ARM_SVE, .feature = KVM_ARM_VCPU_SVE, .finalize = true, \
.regs = sve_regs, .regs_n = ARRAY_SIZE(sve_regs), \
.rejects_set = sve_rejects_set, .rejects_set_n = ARRAY_SIZE(sve_rejects_set), }
+#define VTIMER_OFFSET_SUBLIST \
+ { "vtimer_offset", .capability = KVM_CAP_ARM_VTIMER_OFFSET, \
+ .enable_capability = KVM_CAP_ARM_VTIMER_OFFSET, .regs = vtimer_offset_regs, \
+ .regs_n = ARRAY_SIZE(vtimer_offset_regs), }
static struct vcpu_config vregs_config = {
.sublists = {
@@ -1041,6 +1065,14 @@ static struct vcpu_config vregs_pmu_config = {
{0},
},
};
+static struct vcpu_config vregs_vtimer_config = {
+ .sublists = {
+ BASE_SUBLIST,
+ VREGS_SUBLIST,
+ VTIMER_OFFSET_SUBLIST,
+ {0},
+ },
+};
static struct vcpu_config sve_config = {
.sublists = {
BASE_SUBLIST,
@@ -1056,11 +1088,21 @@ static struct vcpu_config sve_pmu_config = {
{0},
},
};
+static struct vcpu_config sve_vtimer_config = {
+ .sublists = {
+ BASE_SUBLIST,
+ SVE_SUBLIST,
+ VTIMER_OFFSET_SUBLIST,
+ {0},
+ },
+};
static struct vcpu_config *vcpu_configs[] = {
&vregs_config,
&vregs_pmu_config,
+ &vregs_vtimer_config,
&sve_config,
&sve_pmu_config,
+ &sve_vtimer_config,
};
static int vcpu_configs_n = ARRAY_SIZE(vcpu_configs);
--
2.33.0.464.g1972c5931b-goog
^ permalink raw reply related [flat|nested] 42+ messages in thread* [PATCH v8 9/9] selftests: KVM: Test vtimer offset reg in get-reg-list
@ 2021-09-16 18:15 ` Oliver Upton
0 siblings, 0 replies; 42+ messages in thread
From: Oliver Upton @ 2021-09-16 18:15 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Paolo Bonzini, Sean Christopherson, Marc Zyngier, Peter Shier,
Jim Mattson, David Matlack, Ricardo Koller, Jing Zhang,
Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Andrew Jones, Will Deacon,
Catalin Marinas, Oliver Upton
Assert that KVM exposes KVM_REG_ARM_TIMER_OFFSET in the KVM_GET_REG_LIST
ioctl when userspace buys in to the new behavior.
Signed-off-by: Oliver Upton <oupton@google.com>
---
.../selftests/kvm/aarch64/get-reg-list.c | 42 +++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/tools/testing/selftests/kvm/aarch64/get-reg-list.c b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
index cc898181faab..4f337d8b793a 100644
--- a/tools/testing/selftests/kvm/aarch64/get-reg-list.c
+++ b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
@@ -40,6 +40,7 @@ static __u64 *blessed_reg, blessed_n;
struct reg_sublist {
const char *name;
long capability;
+ long enable_capability;
int feature;
bool finalize;
__u64 *regs;
@@ -397,6 +398,19 @@ static void check_supported(struct vcpu_config *c)
}
}
+static void enable_caps(struct kvm_vm *vm, struct vcpu_config *c)
+{
+ struct kvm_enable_cap cap = {0};
+ struct reg_sublist *s;
+
+ for_each_sublist(c, s) {
+ if (s->enable_capability) {
+ cap.cap = s->enable_capability;
+ vm_enable_cap(vm, &cap);
+ }
+ }
+}
+
static bool print_list;
static bool print_filtered;
static bool fixup_core_regs;
@@ -412,6 +426,8 @@ static void run_test(struct vcpu_config *c)
check_supported(c);
vm = vm_create(VM_MODE_DEFAULT, DEFAULT_GUEST_PHY_PAGES, O_RDWR);
+ enable_caps(vm, c);
+
prepare_vcpu_init(c, &init);
aarch64_vcpu_add_default(vm, 0, &init, NULL);
finalize_vcpu(vm, 0, c);
@@ -1014,6 +1030,10 @@ static __u64 sve_rejects_set[] = {
KVM_REG_ARM64_SVE_VLS,
};
+static __u64 vtimer_offset_regs[] = {
+ KVM_REG_ARM_TIMER_OFFSET,
+};
+
#define BASE_SUBLIST \
{ "base", .regs = base_regs, .regs_n = ARRAY_SIZE(base_regs), }
#define VREGS_SUBLIST \
@@ -1025,6 +1045,10 @@ static __u64 sve_rejects_set[] = {
{ "sve", .capability = KVM_CAP_ARM_SVE, .feature = KVM_ARM_VCPU_SVE, .finalize = true, \
.regs = sve_regs, .regs_n = ARRAY_SIZE(sve_regs), \
.rejects_set = sve_rejects_set, .rejects_set_n = ARRAY_SIZE(sve_rejects_set), }
+#define VTIMER_OFFSET_SUBLIST \
+ { "vtimer_offset", .capability = KVM_CAP_ARM_VTIMER_OFFSET, \
+ .enable_capability = KVM_CAP_ARM_VTIMER_OFFSET, .regs = vtimer_offset_regs, \
+ .regs_n = ARRAY_SIZE(vtimer_offset_regs), }
static struct vcpu_config vregs_config = {
.sublists = {
@@ -1041,6 +1065,14 @@ static struct vcpu_config vregs_pmu_config = {
{0},
},
};
+static struct vcpu_config vregs_vtimer_config = {
+ .sublists = {
+ BASE_SUBLIST,
+ VREGS_SUBLIST,
+ VTIMER_OFFSET_SUBLIST,
+ {0},
+ },
+};
static struct vcpu_config sve_config = {
.sublists = {
BASE_SUBLIST,
@@ -1056,11 +1088,21 @@ static struct vcpu_config sve_pmu_config = {
{0},
},
};
+static struct vcpu_config sve_vtimer_config = {
+ .sublists = {
+ BASE_SUBLIST,
+ SVE_SUBLIST,
+ VTIMER_OFFSET_SUBLIST,
+ {0},
+ },
+};
static struct vcpu_config *vcpu_configs[] = {
&vregs_config,
&vregs_pmu_config,
+ &vregs_vtimer_config,
&sve_config,
&sve_pmu_config,
+ &sve_vtimer_config,
};
static int vcpu_configs_n = ARRAY_SIZE(vcpu_configs);
--
2.33.0.464.g1972c5931b-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 42+ messages in thread* Re: [PATCH v8 9/9] selftests: KVM: Test vtimer offset reg in get-reg-list
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-20 12:28 ` Andrew Jones
-1 siblings, 0 replies; 42+ messages in thread
From: Andrew Jones @ 2021-09-20 12:28 UTC (permalink / raw)
To: Oliver Upton
Cc: kvm, kvmarm, Paolo Bonzini, Sean Christopherson, Marc Zyngier,
Peter Shier, Jim Mattson, David Matlack, Ricardo Koller,
Jing Zhang, Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Will Deacon, Catalin Marinas
On Thu, Sep 16, 2021 at 06:15:55PM +0000, Oliver Upton wrote:
> Assert that KVM exposes KVM_REG_ARM_TIMER_OFFSET in the KVM_GET_REG_LIST
> ioctl when userspace buys in to the new behavior.
>
> Signed-off-by: Oliver Upton <oupton@google.com>
> ---
> .../selftests/kvm/aarch64/get-reg-list.c | 42 +++++++++++++++++++
> 1 file changed, 42 insertions(+)
>
> diff --git a/tools/testing/selftests/kvm/aarch64/get-reg-list.c b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
> index cc898181faab..4f337d8b793a 100644
> --- a/tools/testing/selftests/kvm/aarch64/get-reg-list.c
> +++ b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
> @@ -40,6 +40,7 @@ static __u64 *blessed_reg, blessed_n;
> struct reg_sublist {
> const char *name;
> long capability;
> + long enable_capability;
cap.cap is a __u32
> int feature;
> bool finalize;
> __u64 *regs;
> @@ -397,6 +398,19 @@ static void check_supported(struct vcpu_config *c)
> }
> }
>
> +static void enable_caps(struct kvm_vm *vm, struct vcpu_config *c)
> +{
> + struct kvm_enable_cap cap = {0};
> + struct reg_sublist *s;
> +
> + for_each_sublist(c, s) {
> + if (s->enable_capability) {
> + cap.cap = s->enable_capability;
> + vm_enable_cap(vm, &cap);
> + }
> + }
> +}
> +
> static bool print_list;
> static bool print_filtered;
> static bool fixup_core_regs;
> @@ -412,6 +426,8 @@ static void run_test(struct vcpu_config *c)
> check_supported(c);
>
> vm = vm_create(VM_MODE_DEFAULT, DEFAULT_GUEST_PHY_PAGES, O_RDWR);
> + enable_caps(vm, c);
> +
> prepare_vcpu_init(c, &init);
> aarch64_vcpu_add_default(vm, 0, &init, NULL);
> finalize_vcpu(vm, 0, c);
> @@ -1014,6 +1030,10 @@ static __u64 sve_rejects_set[] = {
> KVM_REG_ARM64_SVE_VLS,
> };
>
> +static __u64 vtimer_offset_regs[] = {
> + KVM_REG_ARM_TIMER_OFFSET,
> +};
> +
> #define BASE_SUBLIST \
> { "base", .regs = base_regs, .regs_n = ARRAY_SIZE(base_regs), }
> #define VREGS_SUBLIST \
> @@ -1025,6 +1045,10 @@ static __u64 sve_rejects_set[] = {
> { "sve", .capability = KVM_CAP_ARM_SVE, .feature = KVM_ARM_VCPU_SVE, .finalize = true, \
> .regs = sve_regs, .regs_n = ARRAY_SIZE(sve_regs), \
> .rejects_set = sve_rejects_set, .rejects_set_n = ARRAY_SIZE(sve_rejects_set), }
> +#define VTIMER_OFFSET_SUBLIST \
> + { "vtimer_offset", .capability = KVM_CAP_ARM_VTIMER_OFFSET, \
> + .enable_capability = KVM_CAP_ARM_VTIMER_OFFSET, .regs = vtimer_offset_regs, \
> + .regs_n = ARRAY_SIZE(vtimer_offset_regs), }
>
> static struct vcpu_config vregs_config = {
> .sublists = {
> @@ -1041,6 +1065,14 @@ static struct vcpu_config vregs_pmu_config = {
> {0},
> },
> };
> +static struct vcpu_config vregs_vtimer_config = {
> + .sublists = {
> + BASE_SUBLIST,
> + VREGS_SUBLIST,
> + VTIMER_OFFSET_SUBLIST,
> + {0},
> + },
> +};
> static struct vcpu_config sve_config = {
> .sublists = {
> BASE_SUBLIST,
> @@ -1056,11 +1088,21 @@ static struct vcpu_config sve_pmu_config = {
> {0},
> },
> };
> +static struct vcpu_config sve_vtimer_config = {
> + .sublists = {
> + BASE_SUBLIST,
> + SVE_SUBLIST,
> + VTIMER_OFFSET_SUBLIST,
> + {0},
> + },
> +};
>
> static struct vcpu_config *vcpu_configs[] = {
> &vregs_config,
> &vregs_pmu_config,
> + &vregs_vtimer_config,
> &sve_config,
> &sve_pmu_config,
> + &sve_vtimer_config,
> };
> static int vcpu_configs_n = ARRAY_SIZE(vcpu_configs);
> --
> 2.33.0.464.g1972c5931b-goog
>
Other than the enable_capability type nit
Reviewed-by: Andrew Jones <drjones@redhat.com>
^ permalink raw reply [flat|nested] 42+ messages in thread* Re: [PATCH v8 9/9] selftests: KVM: Test vtimer offset reg in get-reg-list
@ 2021-09-20 12:28 ` Andrew Jones
0 siblings, 0 replies; 42+ messages in thread
From: Andrew Jones @ 2021-09-20 12:28 UTC (permalink / raw)
To: Oliver Upton
Cc: kvm, kvmarm, Paolo Bonzini, Sean Christopherson, Marc Zyngier,
Peter Shier, Jim Mattson, David Matlack, Ricardo Koller,
Jing Zhang, Raghavendra Rao Anata, James Morse, Alexandru Elisei,
Suzuki K Poulose, linux-arm-kernel, Will Deacon, Catalin Marinas
On Thu, Sep 16, 2021 at 06:15:55PM +0000, Oliver Upton wrote:
> Assert that KVM exposes KVM_REG_ARM_TIMER_OFFSET in the KVM_GET_REG_LIST
> ioctl when userspace buys in to the new behavior.
>
> Signed-off-by: Oliver Upton <oupton@google.com>
> ---
> .../selftests/kvm/aarch64/get-reg-list.c | 42 +++++++++++++++++++
> 1 file changed, 42 insertions(+)
>
> diff --git a/tools/testing/selftests/kvm/aarch64/get-reg-list.c b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
> index cc898181faab..4f337d8b793a 100644
> --- a/tools/testing/selftests/kvm/aarch64/get-reg-list.c
> +++ b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
> @@ -40,6 +40,7 @@ static __u64 *blessed_reg, blessed_n;
> struct reg_sublist {
> const char *name;
> long capability;
> + long enable_capability;
cap.cap is a __u32
> int feature;
> bool finalize;
> __u64 *regs;
> @@ -397,6 +398,19 @@ static void check_supported(struct vcpu_config *c)
> }
> }
>
> +static void enable_caps(struct kvm_vm *vm, struct vcpu_config *c)
> +{
> + struct kvm_enable_cap cap = {0};
> + struct reg_sublist *s;
> +
> + for_each_sublist(c, s) {
> + if (s->enable_capability) {
> + cap.cap = s->enable_capability;
> + vm_enable_cap(vm, &cap);
> + }
> + }
> +}
> +
> static bool print_list;
> static bool print_filtered;
> static bool fixup_core_regs;
> @@ -412,6 +426,8 @@ static void run_test(struct vcpu_config *c)
> check_supported(c);
>
> vm = vm_create(VM_MODE_DEFAULT, DEFAULT_GUEST_PHY_PAGES, O_RDWR);
> + enable_caps(vm, c);
> +
> prepare_vcpu_init(c, &init);
> aarch64_vcpu_add_default(vm, 0, &init, NULL);
> finalize_vcpu(vm, 0, c);
> @@ -1014,6 +1030,10 @@ static __u64 sve_rejects_set[] = {
> KVM_REG_ARM64_SVE_VLS,
> };
>
> +static __u64 vtimer_offset_regs[] = {
> + KVM_REG_ARM_TIMER_OFFSET,
> +};
> +
> #define BASE_SUBLIST \
> { "base", .regs = base_regs, .regs_n = ARRAY_SIZE(base_regs), }
> #define VREGS_SUBLIST \
> @@ -1025,6 +1045,10 @@ static __u64 sve_rejects_set[] = {
> { "sve", .capability = KVM_CAP_ARM_SVE, .feature = KVM_ARM_VCPU_SVE, .finalize = true, \
> .regs = sve_regs, .regs_n = ARRAY_SIZE(sve_regs), \
> .rejects_set = sve_rejects_set, .rejects_set_n = ARRAY_SIZE(sve_rejects_set), }
> +#define VTIMER_OFFSET_SUBLIST \
> + { "vtimer_offset", .capability = KVM_CAP_ARM_VTIMER_OFFSET, \
> + .enable_capability = KVM_CAP_ARM_VTIMER_OFFSET, .regs = vtimer_offset_regs, \
> + .regs_n = ARRAY_SIZE(vtimer_offset_regs), }
>
> static struct vcpu_config vregs_config = {
> .sublists = {
> @@ -1041,6 +1065,14 @@ static struct vcpu_config vregs_pmu_config = {
> {0},
> },
> };
> +static struct vcpu_config vregs_vtimer_config = {
> + .sublists = {
> + BASE_SUBLIST,
> + VREGS_SUBLIST,
> + VTIMER_OFFSET_SUBLIST,
> + {0},
> + },
> +};
> static struct vcpu_config sve_config = {
> .sublists = {
> BASE_SUBLIST,
> @@ -1056,11 +1088,21 @@ static struct vcpu_config sve_pmu_config = {
> {0},
> },
> };
> +static struct vcpu_config sve_vtimer_config = {
> + .sublists = {
> + BASE_SUBLIST,
> + SVE_SUBLIST,
> + VTIMER_OFFSET_SUBLIST,
> + {0},
> + },
> +};
>
> static struct vcpu_config *vcpu_configs[] = {
> &vregs_config,
> &vregs_pmu_config,
> + &vregs_vtimer_config,
> &sve_config,
> &sve_pmu_config,
> + &sve_vtimer_config,
> };
> static int vcpu_configs_n = ARRAY_SIZE(vcpu_configs);
> --
> 2.33.0.464.g1972c5931b-goog
>
Other than the enable_capability type nit
Reviewed-by: Andrew Jones <drjones@redhat.com>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 42+ messages in thread* Re: [PATCH v8 9/9] selftests: KVM: Test vtimer offset reg in get-reg-list
@ 2021-09-20 12:28 ` Andrew Jones
0 siblings, 0 replies; 42+ messages in thread
From: Andrew Jones @ 2021-09-20 12:28 UTC (permalink / raw)
To: Oliver Upton
Cc: Catalin Marinas, kvm, Will Deacon, Marc Zyngier, Peter Shier,
Sean Christopherson, David Matlack, Paolo Bonzini, kvmarm,
linux-arm-kernel, Jim Mattson
On Thu, Sep 16, 2021 at 06:15:55PM +0000, Oliver Upton wrote:
> Assert that KVM exposes KVM_REG_ARM_TIMER_OFFSET in the KVM_GET_REG_LIST
> ioctl when userspace buys in to the new behavior.
>
> Signed-off-by: Oliver Upton <oupton@google.com>
> ---
> .../selftests/kvm/aarch64/get-reg-list.c | 42 +++++++++++++++++++
> 1 file changed, 42 insertions(+)
>
> diff --git a/tools/testing/selftests/kvm/aarch64/get-reg-list.c b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
> index cc898181faab..4f337d8b793a 100644
> --- a/tools/testing/selftests/kvm/aarch64/get-reg-list.c
> +++ b/tools/testing/selftests/kvm/aarch64/get-reg-list.c
> @@ -40,6 +40,7 @@ static __u64 *blessed_reg, blessed_n;
> struct reg_sublist {
> const char *name;
> long capability;
> + long enable_capability;
cap.cap is a __u32
> int feature;
> bool finalize;
> __u64 *regs;
> @@ -397,6 +398,19 @@ static void check_supported(struct vcpu_config *c)
> }
> }
>
> +static void enable_caps(struct kvm_vm *vm, struct vcpu_config *c)
> +{
> + struct kvm_enable_cap cap = {0};
> + struct reg_sublist *s;
> +
> + for_each_sublist(c, s) {
> + if (s->enable_capability) {
> + cap.cap = s->enable_capability;
> + vm_enable_cap(vm, &cap);
> + }
> + }
> +}
> +
> static bool print_list;
> static bool print_filtered;
> static bool fixup_core_regs;
> @@ -412,6 +426,8 @@ static void run_test(struct vcpu_config *c)
> check_supported(c);
>
> vm = vm_create(VM_MODE_DEFAULT, DEFAULT_GUEST_PHY_PAGES, O_RDWR);
> + enable_caps(vm, c);
> +
> prepare_vcpu_init(c, &init);
> aarch64_vcpu_add_default(vm, 0, &init, NULL);
> finalize_vcpu(vm, 0, c);
> @@ -1014,6 +1030,10 @@ static __u64 sve_rejects_set[] = {
> KVM_REG_ARM64_SVE_VLS,
> };
>
> +static __u64 vtimer_offset_regs[] = {
> + KVM_REG_ARM_TIMER_OFFSET,
> +};
> +
> #define BASE_SUBLIST \
> { "base", .regs = base_regs, .regs_n = ARRAY_SIZE(base_regs), }
> #define VREGS_SUBLIST \
> @@ -1025,6 +1045,10 @@ static __u64 sve_rejects_set[] = {
> { "sve", .capability = KVM_CAP_ARM_SVE, .feature = KVM_ARM_VCPU_SVE, .finalize = true, \
> .regs = sve_regs, .regs_n = ARRAY_SIZE(sve_regs), \
> .rejects_set = sve_rejects_set, .rejects_set_n = ARRAY_SIZE(sve_rejects_set), }
> +#define VTIMER_OFFSET_SUBLIST \
> + { "vtimer_offset", .capability = KVM_CAP_ARM_VTIMER_OFFSET, \
> + .enable_capability = KVM_CAP_ARM_VTIMER_OFFSET, .regs = vtimer_offset_regs, \
> + .regs_n = ARRAY_SIZE(vtimer_offset_regs), }
>
> static struct vcpu_config vregs_config = {
> .sublists = {
> @@ -1041,6 +1065,14 @@ static struct vcpu_config vregs_pmu_config = {
> {0},
> },
> };
> +static struct vcpu_config vregs_vtimer_config = {
> + .sublists = {
> + BASE_SUBLIST,
> + VREGS_SUBLIST,
> + VTIMER_OFFSET_SUBLIST,
> + {0},
> + },
> +};
> static struct vcpu_config sve_config = {
> .sublists = {
> BASE_SUBLIST,
> @@ -1056,11 +1088,21 @@ static struct vcpu_config sve_pmu_config = {
> {0},
> },
> };
> +static struct vcpu_config sve_vtimer_config = {
> + .sublists = {
> + BASE_SUBLIST,
> + SVE_SUBLIST,
> + VTIMER_OFFSET_SUBLIST,
> + {0},
> + },
> +};
>
> static struct vcpu_config *vcpu_configs[] = {
> &vregs_config,
> &vregs_pmu_config,
> + &vregs_vtimer_config,
> &sve_config,
> &sve_pmu_config,
> + &sve_vtimer_config,
> };
> static int vcpu_configs_n = ARRAY_SIZE(vcpu_configs);
> --
> 2.33.0.464.g1972c5931b-goog
>
Other than the enable_capability type nit
Reviewed-by: Andrew Jones <drjones@redhat.com>
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: [PATCH v8 0/9] selftests: KVM: Test offset-based counter controls
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-09-24 16:43 ` Paolo Bonzini
-1 siblings, 0 replies; 42+ messages in thread
From: Paolo Bonzini @ 2021-09-24 16:43 UTC (permalink / raw)
To: Oliver Upton, kvm, kvmarm
Cc: Sean Christopherson, Marc Zyngier, Peter Shier, Jim Mattson,
David Matlack, Ricardo Koller, Jing Zhang, Raghavendra Rao Anata,
James Morse, Alexandru Elisei, Suzuki K Poulose,
linux-arm-kernel, Andrew Jones, Will Deacon, Catalin Marinas
On 16/09/21 20:15, Oliver Upton wrote:
> This series implements new tests for the x86 and arm64 counter migration
> changes that I've mailed out. These are sent separately as a dependent
> change since there are cross-arch dependencies here.
>
> Patch 1 yanks the pvclock headers into the tools/ directory so we can
> make use of them within a KVM selftest guest.
>
> Patch 2 tests the new capabilities of the KVM_*_CLOCK ioctls, ensuring
> that the kernel accounts for elapsed time when restoring the KVM clock.
>
> Patches 3-4 add some device attribute helpers and clean up some mistakes
> in the assertions thereof.
>
> Patch 5 implements a test for the KVM_VCPU_TSC_OFFSET attribute,
> asserting that manipulation of the offset results in correct TSC values
> within the guest.
>
> Patch 6 adds basic arm64 support to the counter offset test, checking
> that the virtual counter-timer offset works correctly. Patch 7 does the
> same for the physical counter-timer offset.
>
> Patch 8 adds a benchmark for physical counter offsetting, since most
> implementations available right now will rely on emulation.
>
> Lastly, patch 9 extends the get-reg-list test to check for
> KVM_REG_ARM_TIMER_OFFSET if userspace opts-in to the kernel capability.
>
> This series applies cleanly to 5.15-rc1
>
> Tests were ran against the respective architecture changes on the
> following systems:
>
> - Haswell (x86)
> - Ampere Mt. Jade (non-ECV, nVHE and VHE)
Queued patches 1-5, thanks.
Paolo
> v7: https://lore.kernel.org/r/20210816001246.3067312-1-oupton@google.com
>
> v7 -> v8:
> - Rebased to 5.15-rc1
> - Dropped helper for checking if reg exists in reg list (no longer
> necessary)
> - Test and enable KVM_CAP_ARM_VTIMER_OFFSET
> - Add get-reg-list changes
>
> Oliver Upton (9):
> tools: arch: x86: pull in pvclock headers
> selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
> selftests: KVM: Fix kvm device helper ioctl assertions
> selftests: KVM: Add helpers for vCPU device attributes
> selftests: KVM: Introduce system counter offset test
> selftests: KVM: Add support for aarch64 to system_counter_offset_test
> selftests: KVM: Test physical counter offsetting
> selftests: KVM: Add counter emulation benchmark
> selftests: KVM: Test vtimer offset reg in get-reg-list
>
> tools/arch/x86/include/asm/pvclock-abi.h | 48 ++++
> tools/arch/x86/include/asm/pvclock.h | 103 ++++++++
> tools/testing/selftests/kvm/.gitignore | 3 +
> tools/testing/selftests/kvm/Makefile | 4 +
> .../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++
> .../selftests/kvm/aarch64/get-reg-list.c | 42 ++++
> .../selftests/kvm/include/aarch64/processor.h | 24 ++
> .../testing/selftests/kvm/include/kvm_util.h | 11 +
> tools/testing/selftests/kvm/lib/kvm_util.c | 44 +++-
> .../kvm/system_counter_offset_test.c | 220 ++++++++++++++++++
> .../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++
> 11 files changed, 907 insertions(+), 3 deletions(-)
> create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
> create mode 100644 tools/arch/x86/include/asm/pvclock.h
> create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
> create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
> create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
>
^ permalink raw reply [flat|nested] 42+ messages in thread* Re: [PATCH v8 0/9] selftests: KVM: Test offset-based counter controls
@ 2021-09-24 16:43 ` Paolo Bonzini
0 siblings, 0 replies; 42+ messages in thread
From: Paolo Bonzini @ 2021-09-24 16:43 UTC (permalink / raw)
To: Oliver Upton, kvm, kvmarm
Cc: Sean Christopherson, Marc Zyngier, Peter Shier, Jim Mattson,
David Matlack, Ricardo Koller, Jing Zhang, Raghavendra Rao Anata,
James Morse, Alexandru Elisei, Suzuki K Poulose,
linux-arm-kernel, Andrew Jones, Will Deacon, Catalin Marinas
On 16/09/21 20:15, Oliver Upton wrote:
> This series implements new tests for the x86 and arm64 counter migration
> changes that I've mailed out. These are sent separately as a dependent
> change since there are cross-arch dependencies here.
>
> Patch 1 yanks the pvclock headers into the tools/ directory so we can
> make use of them within a KVM selftest guest.
>
> Patch 2 tests the new capabilities of the KVM_*_CLOCK ioctls, ensuring
> that the kernel accounts for elapsed time when restoring the KVM clock.
>
> Patches 3-4 add some device attribute helpers and clean up some mistakes
> in the assertions thereof.
>
> Patch 5 implements a test for the KVM_VCPU_TSC_OFFSET attribute,
> asserting that manipulation of the offset results in correct TSC values
> within the guest.
>
> Patch 6 adds basic arm64 support to the counter offset test, checking
> that the virtual counter-timer offset works correctly. Patch 7 does the
> same for the physical counter-timer offset.
>
> Patch 8 adds a benchmark for physical counter offsetting, since most
> implementations available right now will rely on emulation.
>
> Lastly, patch 9 extends the get-reg-list test to check for
> KVM_REG_ARM_TIMER_OFFSET if userspace opts-in to the kernel capability.
>
> This series applies cleanly to 5.15-rc1
>
> Tests were ran against the respective architecture changes on the
> following systems:
>
> - Haswell (x86)
> - Ampere Mt. Jade (non-ECV, nVHE and VHE)
Queued patches 1-5, thanks.
Paolo
> v7: https://lore.kernel.org/r/20210816001246.3067312-1-oupton@google.com
>
> v7 -> v8:
> - Rebased to 5.15-rc1
> - Dropped helper for checking if reg exists in reg list (no longer
> necessary)
> - Test and enable KVM_CAP_ARM_VTIMER_OFFSET
> - Add get-reg-list changes
>
> Oliver Upton (9):
> tools: arch: x86: pull in pvclock headers
> selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
> selftests: KVM: Fix kvm device helper ioctl assertions
> selftests: KVM: Add helpers for vCPU device attributes
> selftests: KVM: Introduce system counter offset test
> selftests: KVM: Add support for aarch64 to system_counter_offset_test
> selftests: KVM: Test physical counter offsetting
> selftests: KVM: Add counter emulation benchmark
> selftests: KVM: Test vtimer offset reg in get-reg-list
>
> tools/arch/x86/include/asm/pvclock-abi.h | 48 ++++
> tools/arch/x86/include/asm/pvclock.h | 103 ++++++++
> tools/testing/selftests/kvm/.gitignore | 3 +
> tools/testing/selftests/kvm/Makefile | 4 +
> .../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++
> .../selftests/kvm/aarch64/get-reg-list.c | 42 ++++
> .../selftests/kvm/include/aarch64/processor.h | 24 ++
> .../testing/selftests/kvm/include/kvm_util.h | 11 +
> tools/testing/selftests/kvm/lib/kvm_util.c | 44 +++-
> .../kvm/system_counter_offset_test.c | 220 ++++++++++++++++++
> .../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++
> 11 files changed, 907 insertions(+), 3 deletions(-)
> create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
> create mode 100644 tools/arch/x86/include/asm/pvclock.h
> create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
> create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
> create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 42+ messages in thread* Re: [PATCH v8 0/9] selftests: KVM: Test offset-based counter controls
@ 2021-09-24 16:43 ` Paolo Bonzini
0 siblings, 0 replies; 42+ messages in thread
From: Paolo Bonzini @ 2021-09-24 16:43 UTC (permalink / raw)
To: Oliver Upton, kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Peter Shier, Marc Zyngier,
David Matlack, linux-arm-kernel, Jim Mattson
On 16/09/21 20:15, Oliver Upton wrote:
> This series implements new tests for the x86 and arm64 counter migration
> changes that I've mailed out. These are sent separately as a dependent
> change since there are cross-arch dependencies here.
>
> Patch 1 yanks the pvclock headers into the tools/ directory so we can
> make use of them within a KVM selftest guest.
>
> Patch 2 tests the new capabilities of the KVM_*_CLOCK ioctls, ensuring
> that the kernel accounts for elapsed time when restoring the KVM clock.
>
> Patches 3-4 add some device attribute helpers and clean up some mistakes
> in the assertions thereof.
>
> Patch 5 implements a test for the KVM_VCPU_TSC_OFFSET attribute,
> asserting that manipulation of the offset results in correct TSC values
> within the guest.
>
> Patch 6 adds basic arm64 support to the counter offset test, checking
> that the virtual counter-timer offset works correctly. Patch 7 does the
> same for the physical counter-timer offset.
>
> Patch 8 adds a benchmark for physical counter offsetting, since most
> implementations available right now will rely on emulation.
>
> Lastly, patch 9 extends the get-reg-list test to check for
> KVM_REG_ARM_TIMER_OFFSET if userspace opts-in to the kernel capability.
>
> This series applies cleanly to 5.15-rc1
>
> Tests were ran against the respective architecture changes on the
> following systems:
>
> - Haswell (x86)
> - Ampere Mt. Jade (non-ECV, nVHE and VHE)
Queued patches 1-5, thanks.
Paolo
> v7: https://lore.kernel.org/r/20210816001246.3067312-1-oupton@google.com
>
> v7 -> v8:
> - Rebased to 5.15-rc1
> - Dropped helper for checking if reg exists in reg list (no longer
> necessary)
> - Test and enable KVM_CAP_ARM_VTIMER_OFFSET
> - Add get-reg-list changes
>
> Oliver Upton (9):
> tools: arch: x86: pull in pvclock headers
> selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
> selftests: KVM: Fix kvm device helper ioctl assertions
> selftests: KVM: Add helpers for vCPU device attributes
> selftests: KVM: Introduce system counter offset test
> selftests: KVM: Add support for aarch64 to system_counter_offset_test
> selftests: KVM: Test physical counter offsetting
> selftests: KVM: Add counter emulation benchmark
> selftests: KVM: Test vtimer offset reg in get-reg-list
>
> tools/arch/x86/include/asm/pvclock-abi.h | 48 ++++
> tools/arch/x86/include/asm/pvclock.h | 103 ++++++++
> tools/testing/selftests/kvm/.gitignore | 3 +
> tools/testing/selftests/kvm/Makefile | 4 +
> .../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++
> .../selftests/kvm/aarch64/get-reg-list.c | 42 ++++
> .../selftests/kvm/include/aarch64/processor.h | 24 ++
> .../testing/selftests/kvm/include/kvm_util.h | 11 +
> tools/testing/selftests/kvm/lib/kvm_util.c | 44 +++-
> .../kvm/system_counter_offset_test.c | 220 ++++++++++++++++++
> .../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++
> 11 files changed, 907 insertions(+), 3 deletions(-)
> create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
> create mode 100644 tools/arch/x86/include/asm/pvclock.h
> create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
> create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
> create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
>
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: [PATCH v8 0/9] selftests: KVM: Test offset-based counter controls
2021-09-16 18:15 ` Oliver Upton
(?)
@ 2021-10-05 8:58 ` Paolo Bonzini
-1 siblings, 0 replies; 42+ messages in thread
From: Paolo Bonzini @ 2021-10-05 8:58 UTC (permalink / raw)
To: Oliver Upton, kvm, kvmarm
Cc: Sean Christopherson, Marc Zyngier, Peter Shier, Jim Mattson,
David Matlack, Ricardo Koller, Jing Zhang, Raghavendra Rao Anata,
James Morse, Alexandru Elisei, Suzuki K Poulose,
linux-arm-kernel, Andrew Jones, Will Deacon, Catalin Marinas
On 16/09/21 20:15, Oliver Upton wrote:
> This series implements new tests for the x86 and arm64 counter migration
> changes that I've mailed out. These are sent separately as a dependent
> change since there are cross-arch dependencies here.
>
> Patch 1 yanks the pvclock headers into the tools/ directory so we can
> make use of them within a KVM selftest guest.
>
> Patch 2 tests the new capabilities of the KVM_*_CLOCK ioctls, ensuring
> that the kernel accounts for elapsed time when restoring the KVM clock.
>
> Patches 3-4 add some device attribute helpers and clean up some mistakes
> in the assertions thereof.
>
> Patch 5 implements a test for the KVM_VCPU_TSC_OFFSET attribute,
> asserting that manipulation of the offset results in correct TSC values
> within the guest.
>
> Patch 6 adds basic arm64 support to the counter offset test, checking
> that the virtual counter-timer offset works correctly. Patch 7 does the
> same for the physical counter-timer offset.
>
> Patch 8 adds a benchmark for physical counter offsetting, since most
> implementations available right now will rely on emulation.
>
> Lastly, patch 9 extends the get-reg-list test to check for
> KVM_REG_ARM_TIMER_OFFSET if userspace opts-in to the kernel capability.
>
> This series applies cleanly to 5.15-rc1
>
> Tests were ran against the respective architecture changes on the
> following systems:
>
> - Haswell (x86)
> - Ampere Mt. Jade (non-ECV, nVHE and VHE)
>
> v7: https://lore.kernel.org/r/20210816001246.3067312-1-oupton@google.com
>
> v7 -> v8:
> - Rebased to 5.15-rc1
> - Dropped helper for checking if reg exists in reg list (no longer
> necessary)
> - Test and enable KVM_CAP_ARM_VTIMER_OFFSET
> - Add get-reg-list changes
>
> Oliver Upton (9):
> tools: arch: x86: pull in pvclock headers
> selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
> selftests: KVM: Fix kvm device helper ioctl assertions
> selftests: KVM: Add helpers for vCPU device attributes
> selftests: KVM: Introduce system counter offset test
> selftests: KVM: Add support for aarch64 to system_counter_offset_test
> selftests: KVM: Test physical counter offsetting
> selftests: KVM: Add counter emulation benchmark
> selftests: KVM: Test vtimer offset reg in get-reg-list
>
> tools/arch/x86/include/asm/pvclock-abi.h | 48 ++++
> tools/arch/x86/include/asm/pvclock.h | 103 ++++++++
> tools/testing/selftests/kvm/.gitignore | 3 +
> tools/testing/selftests/kvm/Makefile | 4 +
> .../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++
> .../selftests/kvm/aarch64/get-reg-list.c | 42 ++++
> .../selftests/kvm/include/aarch64/processor.h | 24 ++
> .../testing/selftests/kvm/include/kvm_util.h | 11 +
> tools/testing/selftests/kvm/lib/kvm_util.c | 44 +++-
> .../kvm/system_counter_offset_test.c | 220 ++++++++++++++++++
> .../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++
> 11 files changed, 907 insertions(+), 3 deletions(-)
> create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
> create mode 100644 tools/arch/x86/include/asm/pvclock.h
> create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
> create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
> create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
>
Queued patches 1-5, thanks.
Paolo
^ permalink raw reply [flat|nested] 42+ messages in thread* Re: [PATCH v8 0/9] selftests: KVM: Test offset-based counter controls
@ 2021-10-05 8:58 ` Paolo Bonzini
0 siblings, 0 replies; 42+ messages in thread
From: Paolo Bonzini @ 2021-10-05 8:58 UTC (permalink / raw)
To: Oliver Upton, kvm, kvmarm
Cc: Sean Christopherson, Marc Zyngier, Peter Shier, Jim Mattson,
David Matlack, Ricardo Koller, Jing Zhang, Raghavendra Rao Anata,
James Morse, Alexandru Elisei, Suzuki K Poulose,
linux-arm-kernel, Andrew Jones, Will Deacon, Catalin Marinas
On 16/09/21 20:15, Oliver Upton wrote:
> This series implements new tests for the x86 and arm64 counter migration
> changes that I've mailed out. These are sent separately as a dependent
> change since there are cross-arch dependencies here.
>
> Patch 1 yanks the pvclock headers into the tools/ directory so we can
> make use of them within a KVM selftest guest.
>
> Patch 2 tests the new capabilities of the KVM_*_CLOCK ioctls, ensuring
> that the kernel accounts for elapsed time when restoring the KVM clock.
>
> Patches 3-4 add some device attribute helpers and clean up some mistakes
> in the assertions thereof.
>
> Patch 5 implements a test for the KVM_VCPU_TSC_OFFSET attribute,
> asserting that manipulation of the offset results in correct TSC values
> within the guest.
>
> Patch 6 adds basic arm64 support to the counter offset test, checking
> that the virtual counter-timer offset works correctly. Patch 7 does the
> same for the physical counter-timer offset.
>
> Patch 8 adds a benchmark for physical counter offsetting, since most
> implementations available right now will rely on emulation.
>
> Lastly, patch 9 extends the get-reg-list test to check for
> KVM_REG_ARM_TIMER_OFFSET if userspace opts-in to the kernel capability.
>
> This series applies cleanly to 5.15-rc1
>
> Tests were ran against the respective architecture changes on the
> following systems:
>
> - Haswell (x86)
> - Ampere Mt. Jade (non-ECV, nVHE and VHE)
>
> v7: https://lore.kernel.org/r/20210816001246.3067312-1-oupton@google.com
>
> v7 -> v8:
> - Rebased to 5.15-rc1
> - Dropped helper for checking if reg exists in reg list (no longer
> necessary)
> - Test and enable KVM_CAP_ARM_VTIMER_OFFSET
> - Add get-reg-list changes
>
> Oliver Upton (9):
> tools: arch: x86: pull in pvclock headers
> selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
> selftests: KVM: Fix kvm device helper ioctl assertions
> selftests: KVM: Add helpers for vCPU device attributes
> selftests: KVM: Introduce system counter offset test
> selftests: KVM: Add support for aarch64 to system_counter_offset_test
> selftests: KVM: Test physical counter offsetting
> selftests: KVM: Add counter emulation benchmark
> selftests: KVM: Test vtimer offset reg in get-reg-list
>
> tools/arch/x86/include/asm/pvclock-abi.h | 48 ++++
> tools/arch/x86/include/asm/pvclock.h | 103 ++++++++
> tools/testing/selftests/kvm/.gitignore | 3 +
> tools/testing/selftests/kvm/Makefile | 4 +
> .../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++
> .../selftests/kvm/aarch64/get-reg-list.c | 42 ++++
> .../selftests/kvm/include/aarch64/processor.h | 24 ++
> .../testing/selftests/kvm/include/kvm_util.h | 11 +
> tools/testing/selftests/kvm/lib/kvm_util.c | 44 +++-
> .../kvm/system_counter_offset_test.c | 220 ++++++++++++++++++
> .../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++
> 11 files changed, 907 insertions(+), 3 deletions(-)
> create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
> create mode 100644 tools/arch/x86/include/asm/pvclock.h
> create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
> create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
> create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
>
Queued patches 1-5, thanks.
Paolo
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 42+ messages in thread* Re: [PATCH v8 0/9] selftests: KVM: Test offset-based counter controls
@ 2021-10-05 8:58 ` Paolo Bonzini
0 siblings, 0 replies; 42+ messages in thread
From: Paolo Bonzini @ 2021-10-05 8:58 UTC (permalink / raw)
To: Oliver Upton, kvm, kvmarm
Cc: Catalin Marinas, Will Deacon, Peter Shier, Marc Zyngier,
David Matlack, linux-arm-kernel, Jim Mattson
On 16/09/21 20:15, Oliver Upton wrote:
> This series implements new tests for the x86 and arm64 counter migration
> changes that I've mailed out. These are sent separately as a dependent
> change since there are cross-arch dependencies here.
>
> Patch 1 yanks the pvclock headers into the tools/ directory so we can
> make use of them within a KVM selftest guest.
>
> Patch 2 tests the new capabilities of the KVM_*_CLOCK ioctls, ensuring
> that the kernel accounts for elapsed time when restoring the KVM clock.
>
> Patches 3-4 add some device attribute helpers and clean up some mistakes
> in the assertions thereof.
>
> Patch 5 implements a test for the KVM_VCPU_TSC_OFFSET attribute,
> asserting that manipulation of the offset results in correct TSC values
> within the guest.
>
> Patch 6 adds basic arm64 support to the counter offset test, checking
> that the virtual counter-timer offset works correctly. Patch 7 does the
> same for the physical counter-timer offset.
>
> Patch 8 adds a benchmark for physical counter offsetting, since most
> implementations available right now will rely on emulation.
>
> Lastly, patch 9 extends the get-reg-list test to check for
> KVM_REG_ARM_TIMER_OFFSET if userspace opts-in to the kernel capability.
>
> This series applies cleanly to 5.15-rc1
>
> Tests were ran against the respective architecture changes on the
> following systems:
>
> - Haswell (x86)
> - Ampere Mt. Jade (non-ECV, nVHE and VHE)
>
> v7: https://lore.kernel.org/r/20210816001246.3067312-1-oupton@google.com
>
> v7 -> v8:
> - Rebased to 5.15-rc1
> - Dropped helper for checking if reg exists in reg list (no longer
> necessary)
> - Test and enable KVM_CAP_ARM_VTIMER_OFFSET
> - Add get-reg-list changes
>
> Oliver Upton (9):
> tools: arch: x86: pull in pvclock headers
> selftests: KVM: Add test for KVM_{GET,SET}_CLOCK
> selftests: KVM: Fix kvm device helper ioctl assertions
> selftests: KVM: Add helpers for vCPU device attributes
> selftests: KVM: Introduce system counter offset test
> selftests: KVM: Add support for aarch64 to system_counter_offset_test
> selftests: KVM: Test physical counter offsetting
> selftests: KVM: Add counter emulation benchmark
> selftests: KVM: Test vtimer offset reg in get-reg-list
>
> tools/arch/x86/include/asm/pvclock-abi.h | 48 ++++
> tools/arch/x86/include/asm/pvclock.h | 103 ++++++++
> tools/testing/selftests/kvm/.gitignore | 3 +
> tools/testing/selftests/kvm/Makefile | 4 +
> .../kvm/aarch64/counter_emulation_benchmark.c | 207 ++++++++++++++++
> .../selftests/kvm/aarch64/get-reg-list.c | 42 ++++
> .../selftests/kvm/include/aarch64/processor.h | 24 ++
> .../testing/selftests/kvm/include/kvm_util.h | 11 +
> tools/testing/selftests/kvm/lib/kvm_util.c | 44 +++-
> .../kvm/system_counter_offset_test.c | 220 ++++++++++++++++++
> .../selftests/kvm/x86_64/kvm_clock_test.c | 204 ++++++++++++++++
> 11 files changed, 907 insertions(+), 3 deletions(-)
> create mode 100644 tools/arch/x86/include/asm/pvclock-abi.h
> create mode 100644 tools/arch/x86/include/asm/pvclock.h
> create mode 100644 tools/testing/selftests/kvm/aarch64/counter_emulation_benchmark.c
> create mode 100644 tools/testing/selftests/kvm/system_counter_offset_test.c
> create mode 100644 tools/testing/selftests/kvm/x86_64/kvm_clock_test.c
>
Queued patches 1-5, thanks.
Paolo
_______________________________________________
kvmarm mailing list
kvmarm@lists.cs.columbia.edu
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
^ permalink raw reply [flat|nested] 42+ messages in thread