Support SDEI Virtualization
v3 cover Support SDEI Virtualization
This series intends to virtualize Software Delegated Exception Interface (SDEI), which is defined by DEN0054A. It allows the hypervisor to deliver NMI-alike event to guest and it's needed by asynchronous page fault to deliver page-not-present notification from hypervisor to guest. The code and the required qemu changes can be found from:
https://github.com/gwshan/linux ("kvm/arm64_sdei")
https://github.com/gwshan/qemu ("kvm/arm64_sdei")
The SDEI event is identified by a 32-bits number. Bits[31:24] are used to indicate the SDEI event properties while bits[23:0] are identifying the unique number. The implementation takes bits[23:22] to indicate the owner of the SDEI event. For example, those SDEI events owned by KVM should have these two bits set to 0b01. Besides, the implementation supports SDEI events owned by KVM only.
The design is pretty straightforward and the implementation is just following the SDEI specification, to support the defined SMCCC intefaces, except the IRQ binding stuff. There are several data structures introduced. Some of the objects have to be migrated by VMM. So their definitions are split up so that VMM can include their states for migration.
struct kvm_sdei_kvm
Associated with VM and used to track the KVM exposed SDEI events and those registered by guest.
struct kvm_sdei_vcpu
Associated with vCPU and used to track SDEI event delivery. The preempted context is saved prior to the delivery and restored after that.
struct kvm_sdei_event
SDEI events exposed by KVM so that guest can register and enable.
struct kvm_sdei_kvm_event
SDEI events that have been registered by guest.
struct kvm_sdei_vcpu_event
SDEI events that have been queued to specific vCPU for delivery.
The series is organized as below:
PATCH[01] Introduces template for smccc_get_argx()
PATCH[02] Introduces the data structures and infrastructure
PATCH[03-14] Supports various SDEI related hypercalls
PATCH[15] Supports SDEI event notification
PATCH[16-17] Introduces ioctl command for migration PATCH[18-19] Supports SDEI event injection and cancellation
PATCH[20] Exports SDEI capability
PATCH[21] Adds self-test case for SDEI virtualization
Testing
=======
There are additional patches in the following repositories to create procfs files, allowing inject SDEI event and test driver in the guest to handle the SDEI event. Besides, the additional QEMU changes are needed so that guest can detects the SDEI service through ACPI table.
https://github.com/gwshan/linux ("kvm/arm64_sdei") https://github.com/gwshan/qemu ("kvm/arm64_sdei")
The SDEI event is received and handled in the guest after it's injected through the procfs files from host side.
host# /home/gavin/sandbox/qemu.main/build/qemu-system-aarch64 \
-accel kvm -machine virt,gic-version=host \
-cpu host -smp 8,sockets=2,cores=4,threads=1 -m 1024M,maxmem=64G \
-object memory-backend-ram,id=mem0,size=512M \
-object memory-backend-ram,id=mem1,size=512M \
-numa node,nodeid=0,cpus=0-3,memdev=mem0 \
-numa node,nodeid=1,cpus=4-7,memdev=mem1 \
-L /home/gavin/sandbox/qemu.main/build/pc-bios \
-monitor none -serial mon:stdio -nographic -gdb tcp::1234 \
-bios /home/gavin/sandbox/qemu.main/build/pc-bios/edk2-aarch64-code.fd \
-kernel /home/gavin/sandbox/linux.guest/arch/arm64/boot/Image \
-initrd /home/gavin/sandbox/images/rootfs.cpio.xz \
-append 'earlycon=pl011,mmio,0x9000000' \
-device virtio-net-pci,netdev=unet,mac=52:54:00:f1:26:a0 \
-netdev user,id=unet,hostfwd=tcp::50959-:22
host# echo > /proc/kvm/kvm-10842/vcpu-0
guest# =========== SDEI Event (CPU#0) ===========
num=0x40400000, arg=0xdabfdabf
SP: 0xffff800011613e90 PC: 0x0 pState: 0x0
Regs:
000000000002ac4 ffff00001ff947a0 0000000000002ac2 ffff00001ff976c0
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 ffff80001121a000
ffff8000116199e0 ffff800011619ad8 ffff80001122d8b8 ffff800011619afc
0000000000000000 0000000000000000 ffff800011622140 ffff800011150108
00000000582c0018 ffff800011613e90 ffff800010bd0248
Query context:
x[00]: 0000000000002ac4 errno: 0
x[01]: ffff00001ff947a0 errno: 0
:
x[18]: ffff800010bd01d8 errno: 0
x[19]: fffffffffffffffe errno: -22
x[20]: fffffffffffffffe errno: -22
:
x[30]: fffffffffffffffe errno: -22
host# echo > /proc/kvm/kvm-10842/vcpu-7
guest# =========== SDEI Event (CPU#7) ===========
num=0x40400000, arg=0xdabfdabf
SP: 0xffff800011b73f20 PC: 0x0 pState: 0x0
Regs:
00000000000010d0 ffff00003fde07a0 00000000000010ce 7fffffff1999999a
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 ffff80001121a000
ffff8000116199e0 ffff800011619ad8 ffff80001122d8b8 ffff800011619afc
0000000000000000 0000000000000000 ffff000020032ac0 0000000000000000
0000000000000000 ffff800011b73f20 ffff800010bd0248
Query context:
x[00]: 00000000000010d0 errno: 0
x[01]: ffff00003fde07a0 errno: 0
:
x[18]: ffff800010bd01d8 errno: 0
x[19]: fffffffffffffffe errno: -22
:
x[30]: fffffffffffffffe errno: -22Changelog
=========
v3:
* Rebased to 5.13.rc1 (Gavin)
* Use linux data types in kvm_sdei.h (Gavin)
v2:
* Rebased to 5.11.rc6
* Dropped changes related to SDEI client driver (Gavin) * Removed support for passthrou SDEI events (Gavin) * Redesigned data structures (Gavin)
* Implementation is almost rewritten as the data structures
are totally changed (Gavin)
* Added ioctl commands to support migration (Gavin)
Gavin Shan (21):
KVM: arm64: Introduce template for inline functions
KVM: arm64: Add SDEI virtualization infrastructure
KVM: arm64: Support SDEI_VERSION hypercall
KVM: arm64: Support SDEI_EVENT_REGISTER hypercall
KVM: arm64: Support SDEI_EVENT_{ENABLE, DISABLE} hypercall
KVM: arm64: Support SDEI_EVENT_CONTEXT hypercall
KVM: arm64: Support SDEI_EVENT_UNREGISTER hypercall
KVM: arm64: Support SDEI_EVENT_STATUS hypercall
KVM: arm64: Support SDEI_EVENT_GET_INFO hypercall
KVM: arm64: Support SDEI_EVENT_ROUTING_SET hypercall
KVM: arm64: Support SDEI_PE_{MASK, UNMASK} hypercall
KVM: arm64: Support SDEI_{PRIVATE, SHARED}_RESET hypercall
KVM: arm64: Impment SDEI event delivery
KVM: arm64: Support SDEI_EVENT_{COMPLETE, COMPLETE_AND_RESUME}
hypercall
KVM: arm64: Support SDEI event notifier
KVM: arm64: Support SDEI ioctl commands on VM
KVM: arm64: Support SDEI ioctl commands on vCPU
KVM: arm64: Support SDEI event injection
KVM: arm64: Support SDEI event cancellation
KVM: arm64: Export SDEI capability
KVM: selftests: Add SDEI test case
arch/arm64/include/asm/kvm_emulate.h | 1 + arch/arm64/include/asm/kvm_host.h | 6 + arch/arm64/include/asm/kvm_sdei.h | 136 ++ arch/arm64/include/uapi/asm/kvm.h | 1 + arch/arm64/include/uapi/asm/kvm_sdei.h | 86 ++ arch/arm64/kvm/Makefile | 2 +- arch/arm64/kvm/arm.c | 19 + arch/arm64/kvm/hyp/exception.c | 7 + arch/arm64/kvm/hypercalls.c | 18 + arch/arm64/kvm/inject_fault.c | 27 + arch/arm64/kvm/sdei.c | 1519 ++++++++++++++++++++ include/kvm/arm_hypercalls.h | 34 +- include/uapi/linux/kvm.h | 4 + tools/testing/selftests/kvm/Makefile | 1 + tools/testing/selftests/kvm/aarch64/sdei.c | 172 +++ 15 files changed, 2013 insertions(+), 20 deletions(-) create mode 100644 arch/arm64/include/asm/kvm_sdei.h create mode 100644 arch/arm64/include/uapi/asm/kvm_sdei.h create mode 100644 arch/arm64/kvm/sdei.c create mode 100644 tools/testing/selftests/kvm/aarch64/sdei.c
Signature · 1 line
2.23.0
PATCH v3 1/21 KVM: arm64: Introduce template for inline functions
The inline functions used to get the SMCCC parameters have same layout. It means the logical functionality can be presented by a template, to make the code simplified. Besides, this adds more similar inline functions like smccc_get_arg{4,5,6,7,8}() to visit more SMCCC arguments, which are required by SDEI virtualization support.
--- include/kvm/arm_hypercalls.h | 34 +++++++++++++++------------------- 1 file changed, 15 insertions(+), 19 deletions(-)
include/kvm/arm_hypercalls.h +15 -19
@@ -6,27 +6,21 @@#include <asm/kvm_emulate.h> -int kvm_hvc_call_handler (struct kvm_vcpu *vcpu); - -static inline u32 smccc_get_function (struct kvm_vcpu *vcpu) -{ -return vcpu_get_reg (vcpu,0 ); +#define SMCCC_DECLARE_GET_FUNCTION (type, name, reg) \ +static inline type smccc_get_##name(struct kvm_vcpu *vcpu) \ +{ \ + return vcpu_get_reg(vcpu, (reg)); \ } -static inline unsigned long smccc_get_arg1 (struct kvm_vcpu *vcpu) -{ -return vcpu_get_reg (vcpu,1 ); -} - -static inline unsigned long smccc_get_arg2 (struct kvm_vcpu *vcpu) -{ -return vcpu_get_reg (vcpu,2 ); -} - -static inline unsigned long smccc_get_arg3 (struct kvm_vcpu *vcpu) -{ -return vcpu_get_reg (vcpu,3 ); -} +SMCCC_DECLARE_GET_FUNCTION(u32, function, 0) +SMCCC_DECLARE_GET_FUNCTION(unsigned long, arg1, 1) +SMCCC_DECLARE_GET_FUNCTION(unsigned long, arg2, 2) +SMCCC_DECLARE_GET_FUNCTION(unsigned long, arg3, 3) +SMCCC_DECLARE_GET_FUNCTION(unsigned long, arg4, 4) +SMCCC_DECLARE_GET_FUNCTION(unsigned long, arg5, 5) +SMCCC_DECLARE_GET_FUNCTION(unsigned long, arg6, 6) +SMCCC_DECLARE_GET_FUNCTION(unsigned long, arg7, 7) +SMCCC_DECLARE_GET_FUNCTION(unsigned long, arg8, 8) static inline void smccc_set_retval(struct kvm_vcpu *vcpu, unsigned long a0,
@@ -40,4 +34,6 @@ static inline void smccc_set_retval(struct kvm_vcpu *vcpu, vcpu_set_reg(vcpu, 3, a3); } +int kvm_hvc_call_handler (struct kvm_vcpu *vcpu); +#endif
Signature · 1 line
2.23.0
PATCH v3 2/21 KVM: arm64: Add SDEI virtualization infrastructure
In reply to Gavin ShanSoftware Delegated Exception Interface (SDEI) provides a mechanism for registering and servicing system events. Those system events are high priority events, which must be serviced immediately. It's going to be used by Asynchronous Page Fault (APF) to deliver notification from KVM to guest. It's noted that SDEI is defined by ARM DEN0054A specification.
This introduces SDEI virtualization infrastructure where the SDEI events are registered and manuplated by the guest through hypercall. The SDEI event is delivered to one specific vCPU by KVM once it's raised. This introduces data structures to represent the needed objects to implement the feature, which is highlighted as below. As those objects could be migrated between VMs, these data structures are partially exported to user space.
* kvm_sdei_event
SDEI events are exported from KVM so that guest is able to register and manuplate.
* kvm_sdei_kvm_event
SDEI event that has been registered by guest.
* kvm_sdei_kvm_vcpu
SDEI event that has been delivered to the target vCPU.
* kvm_sdei_kvm
Place holder of exported and registered SDEI events.
* kvm_sdei_vcpu
Auxiliary object to save the preempted context during SDEI event delivery.
The error is returned for all SDEI hypercalls for now. They will be implemented by the subsequent patches.
--- arch/arm64/include/asm/kvm_host.h | 4 + arch/arm64/include/asm/kvm_sdei.h | 118 +++++++++++++++ arch/arm64/include/uapi/asm/kvm.h | 1 + arch/arm64/include/uapi/asm/kvm_sdei.h | 60 ++++++++ arch/arm64/kvm/Makefile | 2 +- arch/arm64/kvm/arm.c | 7 + arch/arm64/kvm/hypercalls.c | 18 +++ arch/arm64/kvm/sdei.c | 198 +++++++++++++++++++++++++ 8 files changed, 407 insertions(+), 1 deletion(-) create mode 100644 arch/arm64/include/asm/kvm_sdei.h create mode 100644 arch/arm64/include/uapi/asm/kvm_sdei.h create mode 100644 arch/arm64/kvm/sdei.c
arch/arm64/include/asm/kvm_host.h +4 -0
@@ -132,6 +132,8 @@ struct kvm_arch {u8 pfr0_csv2;u8 pfr0_csv3; + +struct kvm_sdei_kvm *sdei; };struct kvm_vcpu_fault_info {
@@ -371,6 +373,8 @@ struct kvm_vcpu_arch {u64 last_steal;gpa_t base; } steal; + +struct kvm_sdei_vcpu *sdei; };/* Pointer to the vcpu's SVE FFR for sve_{save,load}_state() */
arch/arm64/include/asm/kvm_sdei.h new file +118 -0
118 lines not on this page · raw message
arch/arm64/include/uapi/asm/kvm.h +1 -0
@@ -36,6 +36,7 @@#include <linux/types.h> #include <asm/ptrace.h> #include <asm/sve_context.h> +#include <asm/kvm_sdei.h> #define __KVM_HAVE_GUEST_DEBUG#define __KVM_HAVE_IRQ_LINE
arch/arm64/include/uapi/asm/kvm_sdei.h new file +60 -0
60 lines not on this page · raw message
arch/arm64/kvm/Makefile +1 -1
@@ -16,7 +16,7 @@ kvm-y := $(KVM)/kvm_main.o $(KVM)/coalesced_mmio.o $(KVM)/eventfd.o \ inject_fault.o va_layout.o handle_exit.o \ guest.o debug.o reset.o sys_regs.o \ vgic-sys-reg-v3.o fpsimd.o pmu.o \ - arch_timer.o trng.o\ + arch_timer.o trng.o sdei.o \ vgic/vgic.o vgic/vgic-init.o \ vgic/vgic-irqfd.o vgic/vgic-v2.o \ vgic/vgic-v3.o vgic/vgic-v4.o \
arch/arm64/kvm/arm.c +7 -0
@@ -144,6 +144,8 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)kvm_vgic_early_init (kvm); +kvm_sdei_init_vm (kvm); +/* The maximum number of VCPUs is limited by the host's GIC model */ kvm->arch.max_vcpus =kvm_arm_default_max_vcpus ();
@@ -173,6 +175,8 @@ void kvm_arch_destroy_vm(struct kvm *kvm)kvm_vgic_destroy (kvm); +kvm_sdei_destroy_vm (kvm); +for (i =0 ; i <KVM_MAX_VCPUS ; ++i) {if (kvm->vcpus[i]) {kvm_vcpu_destroy (kvm->vcpus[i]);
@@ -324,6 +328,8 @@ int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu)kvm_arm_pvtime_vcpu_init (&vcpu->arch); +kvm_sdei_create_vcpu (vcpu); + vcpu->arch.hw_mmu = &vcpu->kvm->arch.mmu; err =kvm_vgic_vcpu_init (vcpu);
@@ -345,6 +351,7 @@ void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)kvm_mmu_free_memory_cache (&vcpu->arch.mmu_page_cache);kvm_timer_vcpu_terminate (vcpu);kvm_pmu_vcpu_destroy (vcpu); +kvm_sdei_destroy_vcpu (vcpu);kvm_arm_vcpu_destroy (vcpu); }
arch/arm64/kvm/hypercalls.c +18 -0
@@ -139,6 +139,24 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)case ARM_SMCCC_TRNG_RND32 :case ARM_SMCCC_TRNG_RND64 :return kvm_trng_call (vcpu); +case SDEI_1_0_FN_SDEI_VERSION : +case SDEI_1_0_FN_SDEI_EVENT_REGISTER : +case SDEI_1_0_FN_SDEI_EVENT_ENABLE : +case SDEI_1_0_FN_SDEI_EVENT_DISABLE : +case SDEI_1_0_FN_SDEI_EVENT_CONTEXT : +case SDEI_1_0_FN_SDEI_EVENT_COMPLETE : +case SDEI_1_0_FN_SDEI_EVENT_COMPLETE_AND_RESUME : +case SDEI_1_0_FN_SDEI_EVENT_UNREGISTER : +case SDEI_1_0_FN_SDEI_EVENT_STATUS : +case SDEI_1_0_FN_SDEI_EVENT_GET_INFO : +case SDEI_1_0_FN_SDEI_EVENT_ROUTING_SET : +case SDEI_1_0_FN_SDEI_PE_MASK : +case SDEI_1_0_FN_SDEI_PE_UNMASK : +case SDEI_1_0_FN_SDEI_INTERRUPT_BIND : +case SDEI_1_0_FN_SDEI_INTERRUPT_RELEASE : +case SDEI_1_0_FN_SDEI_PRIVATE_RESET : +case SDEI_1_0_FN_SDEI_SHARED_RESET : +return kvm_sdei_hypercall (vcpu);default :return kvm_psci_call (vcpu); }
arch/arm64/kvm/sdei.c new file +198 -0
198 lines not on this page · raw message
Signature · 1 line
2.23.0
PATCH v3 3/21 KVM: arm64: Support SDEI_VERSION hypercall
In reply to Gavin ShanThis supports SDEI_VERSION hypercall by returning v1.0.0 simply when the functionality is supported on the VM and vCPU.
--- arch/arm64/kvm/sdei.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)
arch/arm64/kvm/sdei.c +18 -0
@@ -70,6 +70,22 @@ static void kvm_sdei_remove_vcpu_events(struct kvm_vcpu *vcpu) } } +static unsigned long kvm_sdei_hypercall_version (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_vcpu *vsdei = vcpu->arch.sdei; +unsigned long ret =SDEI_NOT_SUPPORTED ; + +if (!(ksdei && vsdei)) +return ret; + +/* v1.0.0 */ + ret = (1UL <<SDEI_VERSION_MAJOR_SHIFT ); + +return ret; +} +int kvm_sdei_hypercall (struct kvm_vcpu *vcpu) {u32 func =smccc_get_function (vcpu);
@@ -78,6 +94,8 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu)switch (func) {case SDEI_1_0_FN_SDEI_VERSION : + ret =kvm_sdei_hypercall_version (vcpu); +break ;case SDEI_1_0_FN_SDEI_EVENT_REGISTER :case SDEI_1_0_FN_SDEI_EVENT_ENABLE :case SDEI_1_0_FN_SDEI_EVENT_DISABLE :
Signature · 1 line
2.23.0
PATCH v3 4/21 KVM: arm64: Support SDEI_EVENT_REGISTER hypercall
In reply to Gavin ShanThis supports SDEI_EVENT_REGISTER hypercall, which is used by guest to register SDEI events. The SDEI event won't be raised to the guest or specific vCPU until it's registered and enabled explicitly.
Only those events that have been exported by KVM can be registered. After the event is registered successfully, the KVM SDEI event (object) is created or updated because the same KVM SDEI event is shared by multiple vCPUs if it's a private event.
--- arch/arm64/kvm/sdei.c | 122 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+)
arch/arm64/kvm/sdei.c +122 -0
@@ -21,6 +21,20 @@ static struct kvm_sdei_event_state defined_kse[] = { }, }; +static struct kvm_sdei_event *kvm_sdei_find_event (struct kvm *kvm, +unsigned long num) +{ +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_event *kse; + +list_for_each_entry (kse, &ksdei->events, link) { +if (kse->state.num == num) +return kse; + } + +return NULL ; +} +static void kvm_sdei_remove_events (struct kvm *kvm) {struct kvm_sdei_kvm *ksdei = kvm->arch.sdei;
@@ -32,6 +46,20 @@ static void kvm_sdei_remove_events(struct kvm *kvm) } } +static struct kvm_sdei_kvm_event *kvm_sdei_find_kvm_event (struct kvm *kvm, +unsigned long num) +{ +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_kvm_event *kske; + +list_for_each_entry (kske, &ksdei->kvm_events, link) { +if (kske->state.num == num) +return kske; + } + +return NULL ; +} +static void kvm_sdei_remove_kvm_events (struct kvm *kvm,unsigned int mask,bool force)
@@ -86,6 +114,98 @@ static unsigned long kvm_sdei_hypercall_version(struct kvm_vcpu *vcpu)return ret; } +static unsigned long kvm_sdei_hypercall_register (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_vcpu *vsdei = vcpu->arch.sdei; +struct kvm_sdei_event *kse =NULL ; +struct kvm_sdei_kvm_event *kske =NULL ; +unsigned long event_num =smccc_get_arg1 (vcpu); +unsigned long event_entry =smccc_get_arg2 (vcpu); +unsigned long event_param =smccc_get_arg3 (vcpu); +unsigned long route_mode =smccc_get_arg4 (vcpu); +unsigned long route_affinity =smccc_get_arg5 (vcpu); +int index = vcpu->vcpu_idx; +unsigned long ret =SDEI_SUCCESS ; + +/* Sanity check */ +if (!(ksdei && vsdei)) { + ret =SDEI_NOT_SUPPORTED ; + goto out; + } + +if (!kvm_sdei_is_valid_event_num (event_num)) { + ret =SDEI_INVALID_PARAMETERS ; + goto out; + } + +if (!(route_mode ==SDEI_EVENT_REGISTER_RM_ANY || + route_mode ==SDEI_EVENT_REGISTER_RM_PE )) { + ret =SDEI_INVALID_PARAMETERS ; + goto out; + } + +/* +* The KVM event could have been created if it's a private event. +* We needn't create a KVM event in this case. +*/ +spin_lock (&ksdei->lock); + kske =kvm_sdei_find_kvm_event (kvm, event_num); +if (kske) { + kse = kske->kse; + index = (kse->state.type ==SDEI_EVENT_TYPE_PRIVATE ) ? + vcpu->vcpu_idx :0 ; + +if (kvm_sdei_is_registered (kske, index)) { + ret =SDEI_DENIED ; + goto unlock; + } + + kske->state.route_mode = route_mode; + kske->state.route_affinity = route_affinity; + kske->state.entries[index] = event_entry; + kske->state.params[index] = event_param; +kvm_sdei_set_registered (kske, index); + goto unlock; + } + +/* Check if the event number has been registered */ + kse =kvm_sdei_find_event (kvm, event_num); +if (!kse) { + ret =SDEI_INVALID_PARAMETERS ; + goto unlock; + } + +/* Create KVM event */ + kske =kzalloc (sizeof (*kske),GFP_KERNEL ); +if (!kske) { + ret =SDEI_OUT_OF_RESOURCE ; + goto unlock; + } + +/* Initialize KVM event state */ + index = (kse->state.type ==SDEI_EVENT_TYPE_PRIVATE ) ? + vcpu->vcpu_idx :0 ; + kske->state.num = event_num; + kske->state.refcount =0 ; + kske->state.route_mode = route_affinity; + kske->state.route_affinity = route_affinity; + kske->state.entries[index] = event_entry; + kske->state.params[index] = event_param; +kvm_sdei_set_registered (kske, index); + +/* Initialize KVM event */ + kske->kse = kse; + kske->kvm = kvm; +list_add_tail (&kske->link, &ksdei->kvm_events); + +unlock: +spin_unlock (&ksdei->lock); +out: +return ret; +} +int kvm_sdei_hypercall (struct kvm_vcpu *vcpu) {u32 func =smccc_get_function (vcpu);
@@ -97,6 +217,8 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu) ret =kvm_sdei_hypercall_version (vcpu);break ;case SDEI_1_0_FN_SDEI_EVENT_REGISTER : + ret =kvm_sdei_hypercall_register (vcpu); +break ;case SDEI_1_0_FN_SDEI_EVENT_ENABLE :case SDEI_1_0_FN_SDEI_EVENT_DISABLE :case SDEI_1_0_FN_SDEI_EVENT_CONTEXT :
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 5/21 KVM: arm64: Support SDEI_EVENT_{ENABLE, DISABLE} hypercall
In reply to Gavin ShanThis supports SDEI_EVENT_{ENABLE, DISABLE} hypercall. After SDEI event is registered by guest, it won't be delivered to the guest until it's enabled. On the other hand, the SDEI event won't be raised to the guest or specific vCPU if it's has been disabled on the guest or specific vCPU.
--- arch/arm64/kvm/sdei.c | 68 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+)
arch/arm64/kvm/sdei.c +68 -0
@@ -206,6 +206,70 @@ static unsigned long kvm_sdei_hypercall_register(struct kvm_vcpu *vcpu)return ret; } +static unsigned long kvm_sdei_hypercall_enable (struct kvm_vcpu *vcpu, +bool enable) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_vcpu *vsdei = vcpu->arch.sdei; +struct kvm_sdei_event *kse =NULL ; +struct kvm_sdei_kvm_event *kske =NULL ; +unsigned long event_num =smccc_get_arg1 (vcpu); +int index =0 ; +unsigned long ret =SDEI_SUCCESS ; + +/* Sanity check */ +if (!(ksdei && vsdei)) { + ret =SDEI_NOT_SUPPORTED ; + goto out; + } + +if (!kvm_sdei_is_valid_event_num (event_num)) { + ret =SDEI_INVALID_PARAMETERS ; + goto out; + } + +/* Check if the KVM event exists */ +spin_lock (&ksdei->lock); + kske =kvm_sdei_find_kvm_event (kvm, event_num); +if (!kske) { + ret =SDEI_INVALID_PARAMETERS ; + goto unlock; + } + +/* Check if there is pending events */ +if (kske->state.refcount) { + ret =SDEI_PENDING ; + goto unlock; + } + +/* Check if it has been registered */ + kse = kske->kse; + index = (kse->state.type ==SDEI_EVENT_TYPE_PRIVATE ) ? + vcpu->vcpu_idx :0 ; +if (!kvm_sdei_is_registered (kske, index)) { + ret =SDEI_DENIED ; + goto unlock; + } + +/* Verify its enablement state */ +if (enable ==kvm_sdei_is_enabled (kske, index)) { + ret =SDEI_DENIED ; + goto unlock; + } + +/* Update enablement state */ +if (enable) +kvm_sdei_set_enabled (kske, index); +else +kvm_sdei_clear_enabled (kske, index); + +unlock: +spin_unlock (&ksdei->lock); +out: +return ret; +} +int kvm_sdei_hypercall (struct kvm_vcpu *vcpu) {u32 func =smccc_get_function (vcpu);
@@ -220,7 +284,11 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu) ret =kvm_sdei_hypercall_register (vcpu);break ;case SDEI_1_0_FN_SDEI_EVENT_ENABLE : + ret =kvm_sdei_hypercall_enable (vcpu, true); +break ;case SDEI_1_0_FN_SDEI_EVENT_DISABLE : + ret =kvm_sdei_hypercall_enable (vcpu, false); +break ;case SDEI_1_0_FN_SDEI_EVENT_CONTEXT :case SDEI_1_0_FN_SDEI_EVENT_COMPLETE :case SDEI_1_0_FN_SDEI_EVENT_COMPLETE_AND_RESUME :
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 6/21 KVM: arm64: Support SDEI_EVENT_CONTEXT hypercall
In reply to Gavin ShanThis supports SDEI_EVENT_CONTEXT hypercall. It's used by the guest to retrieved the original registers (R0 - R17) in its SDEI event handler. Those registers can be corrupted during the SDEI event delivery.
--- arch/arm64/kvm/sdei.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+)
arch/arm64/kvm/sdei.c +40 -0
@@ -270,6 +270,44 @@ static unsigned long kvm_sdei_hypercall_enable(struct kvm_vcpu *vcpu,return ret; } +static unsigned long kvm_sdei_hypercall_context (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_vcpu *vsdei = vcpu->arch.sdei; +struct kvm_sdei_vcpu_regs *regs; +unsigned long index =smccc_get_arg1 (vcpu); +unsigned long ret =SDEI_SUCCESS ; + +/* Sanity check */ +if (!(ksdei && vsdei)) { + ret =SDEI_NOT_SUPPORTED ; + goto out; + } + +if (index >ARRAY_SIZE (vsdei->state.critical_regs.regs)) { + ret =SDEI_INVALID_PARAMETERS ; + goto out; + } + +/* Check if the pending event exists */ +spin_lock (&vsdei->lock); +if (!(vsdei->critical_event || vsdei->normal_event)) { + ret =SDEI_DENIED ; + goto unlock; + } + +/* Fetch the requested register */ + regs = vsdei->critical_event ? &vsdei->state.critical_regs : + &vsdei->state.normal_regs; + ret = regs->regs[index]; + +unlock: +spin_unlock (&vsdei->lock); +out: +return ret; +} +int kvm_sdei_hypercall (struct kvm_vcpu *vcpu) {u32 func =smccc_get_function (vcpu);
@@ -290,6 +328,8 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu) ret =kvm_sdei_hypercall_enable (vcpu, false);break ;case SDEI_1_0_FN_SDEI_EVENT_CONTEXT : + ret =kvm_sdei_hypercall_context (vcpu); +break ;case SDEI_1_0_FN_SDEI_EVENT_COMPLETE :case SDEI_1_0_FN_SDEI_EVENT_COMPLETE_AND_RESUME :case SDEI_1_0_FN_SDEI_EVENT_UNREGISTER :
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 7/21 KVM: arm64: Support SDEI_EVENT_UNREGISTER hypercall
In reply to Gavin ShanThis supports SDEI_EVENT_UNREGISTER hypercall. It's used by the guest to unregister SDEI event. The SDEI event won't be raised to the guest or specific vCPU after it's unregistered successfully. It's notable the SDEI event is disabled automatically on the guest or specific vCPU once it's unregistered successfully.
--- arch/arm64/kvm/sdei.c | 61 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+)
arch/arm64/kvm/sdei.c +61 -0
@@ -308,6 +308,65 @@ static unsigned long kvm_sdei_hypercall_context(struct kvm_vcpu *vcpu)return ret; } +static unsigned long kvm_sdei_hypercall_unregister (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_vcpu *vsdei = vcpu->arch.sdei; +struct kvm_sdei_event *kse =NULL ; +struct kvm_sdei_kvm_event *kske =NULL ; +unsigned long event_num =smccc_get_arg1 (vcpu); +int index =0 ; +unsigned long ret =SDEI_SUCCESS ; + +/* Sanity check */ +if (!(ksdei && vsdei)) { + ret =SDEI_NOT_SUPPORTED ; + goto out; + } + +if (!kvm_sdei_is_valid_event_num (event_num)) { + ret =SDEI_INVALID_PARAMETERS ; + goto out; + } + +/* Check if the KVM event exists */ +spin_lock (&ksdei->lock); + kske =kvm_sdei_find_kvm_event (kvm, event_num); +if (!kske) { + ret =SDEI_INVALID_PARAMETERS ; + goto unlock; + } + +/* Check if there is pending events */ +if (kske->state.refcount) { + ret =SDEI_PENDING ; + goto unlock; + } + +/* Check if it has been registered */ + kse = kske->kse; + index = (kse->state.type ==SDEI_EVENT_TYPE_PRIVATE ) ? + vcpu->vcpu_idx :0 ; +if (!kvm_sdei_is_registered (kske, index)) { + ret =SDEI_DENIED ; + goto unlock; + } + +/* The event is disabled when it's unregistered */ +kvm_sdei_clear_enabled (kske, index); +kvm_sdei_clear_registered (kske, index); +if (kvm_sdei_empty_registered (kske)) { +list_del (&kske->link); +kfree (kske); + } + +unlock: +spin_unlock (&ksdei->lock); +out: +return ret; +} +int kvm_sdei_hypercall (struct kvm_vcpu *vcpu) {u32 func =smccc_get_function (vcpu);
@@ -333,6 +392,8 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu)case SDEI_1_0_FN_SDEI_EVENT_COMPLETE :case SDEI_1_0_FN_SDEI_EVENT_COMPLETE_AND_RESUME :case SDEI_1_0_FN_SDEI_EVENT_UNREGISTER : + ret =kvm_sdei_hypercall_unregister (vcpu); +break ;case SDEI_1_0_FN_SDEI_EVENT_STATUS :case SDEI_1_0_FN_SDEI_EVENT_GET_INFO :case SDEI_1_0_FN_SDEI_EVENT_ROUTING_SET :
Signature · 1 line
2.23.0
PATCH v3 8/21 KVM: arm64: Support SDEI_EVENT_STATUS hypercall
In reply to Gavin ShanThis supports SDEI_EVENT_STATUS hypercall. It's used by the guest to retrieve a bitmap to indicate the SDEI event states, including registration, enablement and delivery state.
--- arch/arm64/kvm/sdei.c | 50 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+)
arch/arm64/kvm/sdei.c +50 -0
@@ -367,6 +367,54 @@ static unsigned long kvm_sdei_hypercall_unregister(struct kvm_vcpu *vcpu)return ret; } +static unsigned long kvm_sdei_hypercall_status (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_vcpu *vsdei = vcpu->arch.sdei; +struct kvm_sdei_event *kse =NULL ; +struct kvm_sdei_kvm_event *kske =NULL ; +unsigned long event_num =smccc_get_arg1 (vcpu); +int index =0 ; +unsigned long ret =SDEI_SUCCESS ; + +/* Sanity check */ +if (!(ksdei && vsdei)) { + ret =SDEI_NOT_SUPPORTED ; + goto out; + } + +if (!kvm_sdei_is_valid_event_num (event_num)) { + ret =SDEI_INVALID_PARAMETERS ; + goto out; + } + +/* +* Check if the KVM event exists. None of the flags +* will be set if it doesn't exist. +*/ +spin_lock (&ksdei->lock); + kske =kvm_sdei_find_kvm_event (kvm, event_num); +if (!kske) { + ret =0 ; + goto unlock; + } + + index = (kse->state.type ==SDEI_EVENT_TYPE_PRIVATE ) ? + vcpu->vcpu_idx :0 ; +if (kvm_sdei_is_registered (kske, index)) + ret |= (1UL <<SDEI_EVENT_STATUS_REGISTERED ); +if (kvm_sdei_is_enabled (kske, index)) + ret |= (1UL <<SDEI_EVENT_STATUS_ENABLED ); +if (kske->state.refcount) + ret |= (1UL <<SDEI_EVENT_STATUS_RUNNING ); + +unlock: +spin_unlock (&ksdei->lock); +out: +return ret; +} +int kvm_sdei_hypercall (struct kvm_vcpu *vcpu) {u32 func =smccc_get_function (vcpu);
@@ -395,6 +443,8 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu) ret =kvm_sdei_hypercall_unregister (vcpu);break ;case SDEI_1_0_FN_SDEI_EVENT_STATUS : + ret =kvm_sdei_hypercall_status (vcpu); +break ;case SDEI_1_0_FN_SDEI_EVENT_GET_INFO :case SDEI_1_0_FN_SDEI_EVENT_ROUTING_SET :case SDEI_1_0_FN_SDEI_PE_MASK :
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 9/21 KVM: arm64: Support SDEI_EVENT_GET_INFO hypercall
In reply to Gavin ShanThis supports SDEI_EVENT_GET_INFO hypercall. It's used by the guest to retrieve various information about the supported (exported) events, including type, signaled, route mode and affinity for the shared events.
--- arch/arm64/kvm/sdei.c | 76 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+)
arch/arm64/kvm/sdei.c +76 -0
@@ -415,6 +415,80 @@ static unsigned long kvm_sdei_hypercall_status(struct kvm_vcpu *vcpu)return ret; } +static unsigned long kvm_sdei_hypercall_info (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_vcpu *vsdei = vcpu->arch.sdei; +struct kvm_sdei_event *kse =NULL ; +struct kvm_sdei_kvm_event *kske =NULL ; +unsigned long event_num =smccc_get_arg1 (vcpu); +unsigned long event_info =smccc_get_arg2 (vcpu); +unsigned long ret =SDEI_SUCCESS ; + +/* Sanity check */ +if (!(ksdei && vsdei)) { + ret =SDEI_NOT_SUPPORTED ; + goto out; + } + +if (!kvm_sdei_is_valid_event_num (event_num)) { + ret =SDEI_INVALID_PARAMETERS ; + goto out; + } + +/* +* Check if the KVM event exists. The event might have been +* registered, we need fetch the information from the registered +* event in that case. +*/ +spin_lock (&ksdei->lock); + kske =kvm_sdei_find_kvm_event (kvm, event_num); + kse = kske ? kske->kse :NULL ; +if (!kse) { + kse =kvm_sdei_find_event (kvm, event_num); +if (!kse) { + ret =SDEI_INVALID_PARAMETERS ; + goto unlock; + } + } + +/* Retrieve the requested information */ +switch (event_info) { +case SDEI_EVENT_INFO_EV_TYPE : + ret = kse->state.type; +break ; +case SDEI_EVENT_INFO_EV_SIGNALED : + ret = kse->state.signaled; +break ; +case SDEI_EVENT_INFO_EV_PRIORITY : + ret = kse->state.priority; +break ; +case SDEI_EVENT_INFO_EV_ROUTING_MODE : +case SDEI_EVENT_INFO_EV_ROUTING_AFF : +if (kse->state.type !=SDEI_EVENT_TYPE_SHARED ) { + ret =SDEI_INVALID_PARAMETERS ; +break ; + } + +if (event_info ==SDEI_EVENT_INFO_EV_ROUTING_MODE ) { + ret = kske ? kske->state.route_mode : +SDEI_EVENT_REGISTER_RM_ANY ; + }else { + ret = kske ? kske->state.route_affinity :0 ; + } + +break ; +default : + ret =SDEI_INVALID_PARAMETERS ; + } + +unlock: +spin_unlock (&ksdei->lock); +out: +return ret; +} +int kvm_sdei_hypercall (struct kvm_vcpu *vcpu) {u32 func =smccc_get_function (vcpu);
@@ -446,6 +520,8 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu) ret =kvm_sdei_hypercall_status (vcpu);break ;case SDEI_1_0_FN_SDEI_EVENT_GET_INFO : + ret =kvm_sdei_hypercall_info (vcpu); +break ;case SDEI_1_0_FN_SDEI_EVENT_ROUTING_SET :case SDEI_1_0_FN_SDEI_PE_MASK :case SDEI_1_0_FN_SDEI_PE_UNMASK :
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 10/21 KVM: arm64: Support SDEI_EVENT_ROUTING_SET hypercall
In reply to Gavin ShanThis supports SDEI_EVENT_ROUTING_SET hypercall. It's used by the guest to set route mode and affinity for the registered KVM event. It's only valid for the shared events. It's not allowed to do so when the corresponding event has been raised to the guest.
--- arch/arm64/kvm/sdei.c | 64 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+)
arch/arm64/kvm/sdei.c +64 -0
@@ -489,6 +489,68 @@ static unsigned long kvm_sdei_hypercall_info(struct kvm_vcpu *vcpu)return ret; } +static unsigned long kvm_sdei_hypercall_route (struct kvm_vcpu *vcpu) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_vcpu *vsdei = vcpu->arch.sdei; +struct kvm_sdei_event *kse =NULL ; +struct kvm_sdei_kvm_event *kske =NULL ; +unsigned long event_num =smccc_get_arg1 (vcpu); +unsigned long route_mode =smccc_get_arg2 (vcpu); +unsigned long route_affinity =smccc_get_arg3 (vcpu); +int index =0 ; +unsigned long ret =SDEI_SUCCESS ; + +/* Sanity check */ +if (!(ksdei && vsdei)) { + ret =SDEI_NOT_SUPPORTED ; + goto out; + } + +if (!kvm_sdei_is_valid_event_num (event_num)) { + ret =SDEI_INVALID_PARAMETERS ; + goto out; + } + +if (!(route_mode ==SDEI_EVENT_REGISTER_RM_ANY || + route_mode ==SDEI_EVENT_REGISTER_RM_PE )) { + ret =SDEI_INVALID_PARAMETERS ; + goto out; + } + +/* Check if the KVM event has been registered */ +spin_lock (&ksdei->lock); + kske =kvm_sdei_find_kvm_event (kvm, event_num); +if (!kske) { + ret =SDEI_INVALID_PARAMETERS ; + goto unlock; + } + +/* Validate KVM event state */ + kse = kske->kse; +if (kse->state.type !=SDEI_EVENT_TYPE_SHARED ) { + ret =SDEI_INVALID_PARAMETERS ; + goto unlock; + } + +if (!kvm_sdei_is_registered (kske, index) || +kvm_sdei_is_enabled (kske, index) || + kske->state.refcount) { + ret =SDEI_DENIED ; + goto unlock; + } + +/* Update state */ + kske->state.route_mode = route_mode; + kske->state.route_affinity = route_affinity; + +unlock: +spin_unlock (&ksdei->lock); +out: +return ret; +} +int kvm_sdei_hypercall (struct kvm_vcpu *vcpu) {u32 func =smccc_get_function (vcpu);
@@ -523,6 +585,8 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu) ret =kvm_sdei_hypercall_info (vcpu);break ;case SDEI_1_0_FN_SDEI_EVENT_ROUTING_SET : + ret =kvm_sdei_hypercall_route (vcpu); +break ;case SDEI_1_0_FN_SDEI_PE_MASK :case SDEI_1_0_FN_SDEI_PE_UNMASK :case SDEI_1_0_FN_SDEI_INTERRUPT_BIND :
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 11/21 KVM: arm64: Support SDEI_PE_{MASK, UNMASK} hypercall
In reply to Gavin ShanThis supports SDEI_PE_{MASK, UNMASK} hypercall. They are used by the guest to stop the specific vCPU from receiving SDEI events.
--- arch/arm64/kvm/sdei.c | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+)
arch/arm64/kvm/sdei.c +35 -0
@@ -551,6 +551,37 @@ static unsigned long kvm_sdei_hypercall_route(struct kvm_vcpu *vcpu)return ret; } +static unsigned long kvm_sdei_hypercall_mask (struct kvm_vcpu *vcpu, +bool mask) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_vcpu *vsdei = vcpu->arch.sdei; +unsigned long ret =SDEI_SUCCESS ; + +/* Sanity check */ +if (!(ksdei && vsdei)) { + ret =SDEI_NOT_SUPPORTED ; + goto out; + } + +spin_lock (&vsdei->lock); + +/* Check the state */ +if (mask == vsdei->state.masked) { + ret =SDEI_DENIED ; + goto unlock; + } + +/* Update the state */ + vsdei->state.masked = mask ?1 :0 ; + +unlock: +spin_unlock (&vsdei->lock); +out: +return ret; +} +int kvm_sdei_hypercall (struct kvm_vcpu *vcpu) {u32 func =smccc_get_function (vcpu);
@@ -588,7 +619,11 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu) ret =kvm_sdei_hypercall_route (vcpu);break ;case SDEI_1_0_FN_SDEI_PE_MASK : + ret =kvm_sdei_hypercall_mask (vcpu, true); +break ;case SDEI_1_0_FN_SDEI_PE_UNMASK : + ret =kvm_sdei_hypercall_mask (vcpu, false); +break ;case SDEI_1_0_FN_SDEI_INTERRUPT_BIND :case SDEI_1_0_FN_SDEI_INTERRUPT_RELEASE :case SDEI_1_0_FN_SDEI_PRIVATE_RESET :
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 12/21 KVM: arm64: Support SDEI_{PRIVATE, SHARED}_RESET hypercall
In reply to Gavin ShanThis supports SDEI_{PRIVATE, SHARED}_RESET. They are used by the guest to purge the private or shared SDEI events, which are registered previously.
--- arch/arm64/kvm/sdei.c | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)
arch/arm64/kvm/sdei.c +29 -0
@@ -582,6 +582,29 @@ static unsigned long kvm_sdei_hypercall_mask(struct kvm_vcpu *vcpu,return ret; } +static unsigned long kvm_sdei_hypercall_reset (struct kvm_vcpu *vcpu, +bool private) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_sdei_kvm *ksdei = kvm->arch.sdei; +struct kvm_sdei_vcpu *vsdei = vcpu->arch.sdei; +unsigned int mask = private ? (1 <<SDEI_EVENT_TYPE_PRIVATE ) : + (1 <<SDEI_EVENT_TYPE_SHARED ); +unsigned long ret =SDEI_SUCCESS ; + +/* Sanity check */ +if (!(ksdei && vsdei)) { + ret =SDEI_NOT_SUPPORTED ; + goto out; + } + +spin_lock (&ksdei->lock); +kvm_sdei_remove_kvm_events (kvm, mask, false); +spin_unlock (&ksdei->lock); +out: +return ret; +} +int kvm_sdei_hypercall (struct kvm_vcpu *vcpu) {u32 func =smccc_get_function (vcpu);
@@ -626,8 +649,14 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu)break ;case SDEI_1_0_FN_SDEI_INTERRUPT_BIND :case SDEI_1_0_FN_SDEI_INTERRUPT_RELEASE : + ret =SDEI_NOT_SUPPORTED ; +break ;case SDEI_1_0_FN_SDEI_PRIVATE_RESET : + ret =kvm_sdei_hypercall_reset (vcpu, true); +break ;case SDEI_1_0_FN_SDEI_SHARED_RESET : + ret =kvm_sdei_hypercall_reset (vcpu, false); +break ;default : ret =SDEI_NOT_SUPPORTED ; }
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 13/21 KVM: arm64: Impment SDEI event delivery
In reply to Gavin ShanThis implement kvm_sdei_deliver() to support SDEI event delivery. The function is called when the request (KVM_REQ_SDEI) is raised. The following rules are taken according to the SDEI specification:
* x0 - x17 are saved. All of them are cleared except the following registered:
x0: number SDEI event to be delivered
x1: parameter associated with the SDEI event
x2: PC of the interrupted context
x3: PState of the interrupted context
* PC is set to the handler of the SDEI event, which was provided during its registration. PState is modified accordingly.
* SDEI event with critical priority can preempt those with normal priority.
--- arch/arm64/include/asm/kvm_host.h | 1 + arch/arm64/include/asm/kvm_sdei.h | 1 + arch/arm64/kvm/arm.c | 3 ++ arch/arm64/kvm/sdei.c | 84 +++++++++++++++++++++++++++++++ 4 files changed, 89 insertions(+)
arch/arm64/include/asm/kvm_host.h +1 -0
@@ -46,6 +46,7 @@#define KVM_REQ_VCPU_RESET KVM_ARCH_REQ(2)#define KVM_REQ_RECORD_STEAL KVM_ARCH_REQ(3)#define KVM_REQ_RELOAD_GICv4 KVM_ARCH_REQ(4) +#define KVM_REQ_SDEI KVM_ARCH_REQ(5)#define KVM_DIRTY_LOG_MANUAL_CAPS (KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE | \ KVM_DIRTY_LOG_INITIALLY_SET)
arch/arm64/include/asm/kvm_sdei.h +1 -0
@@ -112,6 +112,7 @@ KVM_SDEI_FLAG_FUNC(enabled)void kvm_sdei_init_vm (struct kvm *kvm);void kvm_sdei_create_vcpu (struct kvm_vcpu *vcpu);int kvm_sdei_hypercall (struct kvm_vcpu *vcpu); +void kvm_sdei_deliver (struct kvm_vcpu *vcpu);void kvm_sdei_destroy_vcpu (struct kvm_vcpu *vcpu);void kvm_sdei_destroy_vm (struct kvm *kvm);
arch/arm64/kvm/arm.c +3 -0
@@ -680,6 +680,9 @@ static void check_vcpu_requests(struct kvm_vcpu *vcpu)if (kvm_check_request (KVM_REQ_VCPU_RESET , vcpu))kvm_reset_vcpu (vcpu); +if (kvm_check_request (KVM_REQ_SDEI , vcpu)) +kvm_sdei_deliver (vcpu); +/* * Clear IRQ_PENDING requests that were made to guarantee * that a VCPU sees new virtual interrupts.
arch/arm64/kvm/sdei.c +84 -0
90 lines not on this page · raw message
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 14/21 KVM: arm64: Support SDEI_EVENT_{COMPLETE, COMPLETE_AND_RESUME} hypercall
In reply to Gavin ShanThis supports SDEI_EVENT_{COMPLETE, COMPLETE_AND_RESUME} hypercall. They are used by the guest to notify the completion of the SDEI event in the handler. The registers are changed according to the SDEI specification as below:
* x0 - x17, PC and PState are restored to what values we had in the interrupted context.
* If it's SDEI_EVENT_COMPLETE_AND_RESUME hypercall, IRQ exception is injected.
--- arch/arm64/include/asm/kvm_emulate.h | 1 + arch/arm64/include/asm/kvm_host.h | 1 + arch/arm64/kvm/hyp/exception.c | 7 +++ arch/arm64/kvm/inject_fault.c | 27 ++++++++++ arch/arm64/kvm/sdei.c | 75 ++++++++++++++++++++++++++++ 5 files changed, 111 insertions(+)
arch/arm64/include/asm/kvm_emulate.h +1 -0
@@ -37,6 +37,7 @@ bool kvm_condition_valid32(const struct kvm_vcpu *vcpu);void kvm_skip_instr32 (struct kvm_vcpu *vcpu);void kvm_inject_undefined (struct kvm_vcpu *vcpu); +void kvm_inject_irq (struct kvm_vcpu *vcpu);void kvm_inject_vabt (struct kvm_vcpu *vcpu);void kvm_inject_dabt (struct kvm_vcpu *vcpu,unsigned long addr);void kvm_inject_pabt (struct kvm_vcpu *vcpu,unsigned long addr);
arch/arm64/include/asm/kvm_host.h +1 -0
@@ -425,6 +425,7 @@ struct kvm_vcpu_arch {#define KVM_ARM64_EXCEPT_AA32_UND (0 << 9)#define KVM_ARM64_EXCEPT_AA32_IABT (1 << 9)#define KVM_ARM64_EXCEPT_AA32_DABT (2 << 9) +#define KVM_ARM64_EXCEPT_AA32_IRQ (3 << 9)/* For AArch64: */ #define KVM_ARM64_EXCEPT_AA64_ELx_SYNC (0 << 9)#define KVM_ARM64_EXCEPT_AA64_ELx_IRQ (1 << 9)
arch/arm64/kvm/hyp/exception.c +7 -0
@@ -309,6 +309,9 @@ void kvm_inject_exception(struct kvm_vcpu *vcpu)case KVM_ARM64_EXCEPT_AA32_DABT :enter_exception32 (vcpu,PSR_AA32_MODE_ABT ,16 );break ; +case KVM_ARM64_EXCEPT_AA32_IRQ : +enter_exception32 (vcpu,PSR_AA32_MODE_IRQ ,4 ); +break ;default :/* Err... */ break ;
@@ -319,6 +322,10 @@ void kvm_inject_exception(struct kvm_vcpu *vcpu) KVM_ARM64_EXCEPT_AA64_EL1):enter_exception64 (vcpu, PSR_MODE_EL1h, except_type_sync);break ; +case (KVM_ARM64_EXCEPT_AA64_ELx_IRQ | +KVM_ARM64_EXCEPT_AA64_EL1 ): +enter_exception64 (vcpu, PSR_MODE_EL1h, except_type_irq); +break ;default :/* * Only EL1_SYNC makes sense so far, EL2_{SYNC,IRQ}
arch/arm64/kvm/inject_fault.c +27 -0
@@ -66,6 +66,13 @@ static void inject_undef64(struct kvm_vcpu *vcpu)vcpu_write_sys_reg (vcpu, esr,ESR_EL1 ); } +static void inject_irq64 (struct kvm_vcpu *vcpu) +{ + vcpu->arch.flags |= (KVM_ARM64_EXCEPT_AA64_EL1 | + KVM_ARM64_EXCEPT_AA64_ELx_IRQ | +KVM_ARM64_PENDING_EXCEPTION ); +} +#define DFSR_FSC_EXTABT_LPAE 0x10#define DFSR_FSC_EXTABT_nLPAE 0x08#define DFSR_LPAE BIT(9)
@@ -77,6 +84,12 @@ static void inject_undef32(struct kvm_vcpu *vcpu) KVM_ARM64_PENDING_EXCEPTION); } +static void inject_irq32 (struct kvm_vcpu *vcpu) +{ + vcpu->arch.flags |= (KVM_ARM64_EXCEPT_AA32_IRQ | +KVM_ARM64_PENDING_EXCEPTION ); +} +/* * Modelled after TakeDataAbortException() and TakePrefetchAbortException * pseudocode.
@@ -160,6 +173,20 @@ void kvm_inject_undefined(struct kvm_vcpu *vcpu)inject_undef64 (vcpu); } +/** +* kvm_inject_irq - inject an IRQ into the guest +* +* It is assumed that this code is called from the VCPU thread and that the +* VCPU therefore is not currently executing guest code. +*/ +void kvm_inject_irq (struct kvm_vcpu *vcpu) +{ +if (vcpu_el1_is_32bit (vcpu)) +inject_irq32 (vcpu); +else +inject_irq64 (vcpu); +} +void kvm_set_sei_esr (struct kvm_vcpu *vcpu,u64 esr) {vcpu_set_vsesr (vcpu, esr & ESR_ELx_ISS_MASK);
arch/arm64/kvm/sdei.c +75 -0
88 lines not on this page · raw message
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 15/21 KVM: arm64: Support SDEI event notifier
In reply to Gavin ShanThe owner of the SDEI event, like asynchronous page fault, need know the state of injected SDEI event. This supports SDEI event state updating by introducing notifier mechanism. It's notable the notifier (handler) should be capable of migration.
--- arch/arm64/include/asm/kvm_sdei.h | 12 +++++++ arch/arm64/include/uapi/asm/kvm_sdei.h | 1 + arch/arm64/kvm/sdei.c | 45 +++++++++++++++++++++++++- 3 files changed, 57 insertions(+), 1 deletion(-)
arch/arm64/include/asm/kvm_sdei.h +12 -0
@@ -16,6 +16,16 @@#include <linux/list.h> #include <linux/spinlock.h> +struct kvm_vcpu ; + +typedef void (*kvm_sdei_notifier )(struct kvm_vcpu *vcpu, +unsigned long num, +unsigned int state); +enum { +KVM_SDEI_NOTIFY_DELIVERED , +KVM_SDEI_NOTIFY_COMPLETED , +}; +struct kvm_sdei_event {struct kvm_sdei_event_state state;struct kvm *kvm;
@@ -112,6 +122,8 @@ KVM_SDEI_FLAG_FUNC(enabled)void kvm_sdei_init_vm (struct kvm *kvm);void kvm_sdei_create_vcpu (struct kvm_vcpu *vcpu);int kvm_sdei_hypercall (struct kvm_vcpu *vcpu); +int kvm_sdei_register_notifier (struct kvm *kvm,unsigned long num, +kvm_sdei_notifier notifier);void kvm_sdei_deliver (struct kvm_vcpu *vcpu);void kvm_sdei_destroy_vcpu (struct kvm_vcpu *vcpu);void kvm_sdei_destroy_vm (struct kvm *kvm);
arch/arm64/include/uapi/asm/kvm_sdei.h +1 -0
@@ -23,6 +23,7 @@ struct kvm_sdei_event_state {__u8 type;__u8 signaled;__u8 priority; +__u64 notifier; };struct kvm_sdei_kvm_event_state {
arch/arm64/kvm/sdei.c +44 -1
84 lines not on this page · raw message
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 16/21 KVM: arm64: Support SDEI ioctl commands on VM
In reply to Gavin ShanThis supports ioctl commands on VM to manage the various objects. It's primarily used by VMM to accomplish live migration. The ioctl commands introduced by this are highlighted as blow:
* KVM_SDEI_CMD_GET_VERSION
Retrieve the version of current implementation
* KVM_SDEI_CMD_SET_EVENT
Add event to be exported from KVM so that guest can register against it afterwards
* KVM_SDEI_CMD_GET_KEVENT_COUNT
Retrieve number of registered SDEI events
* KVM_SDEI_CMD_GET_KEVENT
Retrieve the state of the registered SDEI event
* KVM_SDEI_CMD_SET_KEVENT
Populate the registered SDEI event
--- arch/arm64/include/asm/kvm_sdei.h | 1 + arch/arm64/include/uapi/asm/kvm_sdei.h | 17 +++ arch/arm64/kvm/arm.c | 3 + arch/arm64/kvm/sdei.c | 171 +++++++++++++++++++++++++ include/uapi/linux/kvm.h | 3 + 5 files changed, 195 insertions(+)
arch/arm64/include/asm/kvm_sdei.h +1 -0
@@ -125,6 +125,7 @@ int kvm_sdei_hypercall(struct kvm_vcpu *vcpu);int kvm_sdei_register_notifier (struct kvm *kvm,unsigned long num,kvm_sdei_notifier notifier);void kvm_sdei_deliver (struct kvm_vcpu *vcpu); +long kvm_sdei_vm_ioctl (struct kvm *kvm,unsigned long arg);void kvm_sdei_destroy_vcpu (struct kvm_vcpu *vcpu);void kvm_sdei_destroy_vm (struct kvm *kvm);
arch/arm64/include/uapi/asm/kvm_sdei.h +17 -0
@@ -57,5 +57,22 @@ struct kvm_sdei_vcpu_state {struct kvm_sdei_vcpu_regs normal_regs; }; +#define KVM_SDEI_CMD_GET_VERSION 0 +#define KVM_SDEI_CMD_SET_EVENT 1 +#define KVM_SDEI_CMD_GET_KEVENT_COUNT 2 +#define KVM_SDEI_CMD_GET_KEVENT 3 +#define KVM_SDEI_CMD_SET_KEVENT 4 + +struct kvm_sdei_cmd { +__u32 cmd; +union { +__u32 version; +__u32 count; +__u64 num; +struct kvm_sdei_event_state kse_state; +struct kvm_sdei_kvm_event_state kske_state; + }; +}; +#endif /* !__ASSEMBLY__ */ #endif /* _UAPI__ASM_KVM_SDEI_H */
arch/arm64/kvm/arm.c +3 -0
@@ -1346,6 +1346,9 @@ long kvm_arch_vm_ioctl(struct file *filp,return 0 ; } +case KVM_ARM_SDEI_COMMAND : { +return kvm_sdei_vm_ioctl (kvm, arg); + }default :return -EINVAL ; }
arch/arm64/kvm/sdei.c +171 -0
177 lines not on this page · raw message
include/uapi/linux/kvm.h +3 -0
@@ -1645,6 +1645,9 @@ struct kvm_xen_vcpu_attr {#define KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_DATA 0x4#define KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADJUST 0x5 +/* Available with KVM_CAP_ARM_SDEI */ +#define KVM_ARM_SDEI_COMMAND _IOWR(KVMIO, 0xcc, struct kvm_sdei_cmd) +/* Secure Encrypted Virtualization command */ enum sev_cmd_id {/* Guest initialization commands */
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 17/21 KVM: arm64: Support SDEI ioctl commands on vCPU
In reply to Gavin ShanThis supports ioctl commands on vCPU to manage the various object. It's primarily used by VMM to accomplish live migration. The ioctl commands introduced by this are highlighted as below:
* KVM_SDEI_CMD_GET_VEVENT_COUNT
Retrieve number of SDEI events that pend for handling on the vCPU
* KVM_SDEI_CMD_GET_VEVENT
Retrieve the state of SDEI event, which has been delivered to the vCPU for handling
* KVM_SDEI_CMD_SET_VEVENT
Populate the SDEI event, which has been delivered to the vCPU for handling
* KVM_SDEI_CMD_GET_VCPU_STATE
Retrieve vCPU state related to SDEI handling
* KVM_SDEI_CMD_SET_VCPU_STATE
Populate vCPU state related to SDEI handling
--- arch/arm64/include/asm/kvm_sdei.h | 1 + arch/arm64/include/uapi/asm/kvm_sdei.h | 7 + arch/arm64/kvm/arm.c | 3 + arch/arm64/kvm/sdei.c | 228 +++++++++++++++++++++++++ 4 files changed, 239 insertions(+)
arch/arm64/include/asm/kvm_sdei.h +1 -0
@@ -126,6 +126,7 @@ int kvm_sdei_register_notifier(struct kvm *kvm, unsigned long num, kvm_sdei_notifier notifier);void kvm_sdei_deliver (struct kvm_vcpu *vcpu);long kvm_sdei_vm_ioctl (struct kvm *kvm,unsigned long arg); +long kvm_sdei_vcpu_ioctl (struct kvm_vcpu *vcpu,unsigned long arg);void kvm_sdei_destroy_vcpu (struct kvm_vcpu *vcpu);void kvm_sdei_destroy_vm (struct kvm *kvm);
arch/arm64/include/uapi/asm/kvm_sdei.h +7 -0
@@ -62,6 +62,11 @@ struct kvm_sdei_vcpu_state {#define KVM_SDEI_CMD_GET_KEVENT_COUNT 2#define KVM_SDEI_CMD_GET_KEVENT 3#define KVM_SDEI_CMD_SET_KEVENT 4 +#define KVM_SDEI_CMD_GET_VEVENT_COUNT 5 +#define KVM_SDEI_CMD_GET_VEVENT 6 +#define KVM_SDEI_CMD_SET_VEVENT 7 +#define KVM_SDEI_CMD_GET_VCPU_STATE 8 +#define KVM_SDEI_CMD_SET_VCPU_STATE 9struct kvm_sdei_cmd {__u32 cmd;
@@ -71,6 +76,8 @@ struct kvm_sdei_cmd {__u64 num;struct kvm_sdei_event_state kse_state;struct kvm_sdei_kvm_event_state kske_state; +struct kvm_sdei_vcpu_event_state ksve_state; +struct kvm_sdei_vcpu_state ksv_state; }; };
arch/arm64/kvm/arm.c +3 -0
@@ -1272,6 +1272,9 @@ long kvm_arch_vcpu_ioctl(struct file *filp,return kvm_arm_vcpu_finalize (vcpu, what); } +case KVM_ARM_SDEI_COMMAND : { +return kvm_sdei_vcpu_ioctl (vcpu, arg); + }default : r = -EINVAL ; }
arch/arm64/kvm/sdei.c +228 -0
240 lines not on this page · raw message
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 18/21 KVM: arm64: Support SDEI event injection
In reply to Gavin ShanThis supports SDEI event injection by implementing kvm_sdei_inject(). It's called by kernel directly or VMM through ioctl command to inject SDEI event to the specific vCPU.
--- arch/arm64/include/asm/kvm_sdei.h | 2 + arch/arm64/include/uapi/asm/kvm_sdei.h | 1 + arch/arm64/kvm/sdei.c | 108 +++++++++++++++++++++++++ 3 files changed, 111 insertions(+)
arch/arm64/include/asm/kvm_sdei.h +2 -0
@@ -124,6 +124,8 @@ void kvm_sdei_create_vcpu(struct kvm_vcpu *vcpu);int kvm_sdei_hypercall (struct kvm_vcpu *vcpu);int kvm_sdei_register_notifier (struct kvm *kvm,unsigned long num,kvm_sdei_notifier notifier); +int kvm_sdei_inject (struct kvm_vcpu *vcpu, +unsigned long num,bool immediate);void kvm_sdei_deliver (struct kvm_vcpu *vcpu);long kvm_sdei_vm_ioctl (struct kvm *kvm,unsigned long arg);long kvm_sdei_vcpu_ioctl (struct kvm_vcpu *vcpu,unsigned long arg);
arch/arm64/include/uapi/asm/kvm_sdei.h +1 -0
@@ -67,6 +67,7 @@ struct kvm_sdei_vcpu_state {#define KVM_SDEI_CMD_SET_VEVENT 7#define KVM_SDEI_CMD_GET_VCPU_STATE 8#define KVM_SDEI_CMD_SET_VCPU_STATE 9 +#define KVM_SDEI_CMD_INJECT_EVENT 10struct kvm_sdei_cmd {__u32 cmd;
arch/arm64/kvm/sdei.c +108 -0
120 lines not on this page · raw message
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 19/21 KVM: arm64: Support SDEI event cancellation
In reply to Gavin ShanThe injected SDEI event is to send notification to guest. The SDEI event might not be needed after it's injected. This introduces API to support cancellation on the injected SDEI event if it's not fired to the guest yet.
This mechanism will be needed when we're going to support asynchronous page fault.
--- arch/arm64/include/asm/kvm_sdei.h | 1 + arch/arm64/kvm/sdei.c | 49 +++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+)
arch/arm64/include/asm/kvm_sdei.h +1 -0
@@ -126,6 +126,7 @@ int kvm_sdei_register_notifier(struct kvm *kvm, unsigned long num, kvm_sdei_notifier notifier);int kvm_sdei_inject (struct kvm_vcpu *vcpu,unsigned long num,bool immediate); +int kvm_sdei_cancel (struct kvm_vcpu *vcpu,unsigned long num);void kvm_sdei_deliver (struct kvm_vcpu *vcpu);long kvm_sdei_vm_ioctl (struct kvm *kvm,unsigned long arg);long kvm_sdei_vcpu_ioctl (struct kvm_vcpu *vcpu,unsigned long arg);
arch/arm64/kvm/sdei.c +49 -0
55 lines not on this page · raw message
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 20/21 KVM: arm64: Export SDEI capability
In reply to Gavin ShanThe SDEI functionality is ready to be exported so far. This adds new capability (KVM_CAP_ARM_SDEI) and exports it.
--- arch/arm64/kvm/arm.c | 3 +++ include/uapi/linux/kvm.h | 1 + 2 files changed, 4 insertions(+)
arch/arm64/kvm/arm.c +3 -0
@@ -269,6 +269,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_ARM_PTRAUTH_GENERIC : r =system_has_full_ptr_auth ();break ; +case KVM_CAP_ARM_SDEI : + r =1 ; +break ;default : r =0 ; }
include/uapi/linux/kvm.h +1 -0
@@ -1082,6 +1082,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_SGX_ATTRIBUTE 196#define KVM_CAP_VM_COPY_ENC_CONTEXT_FROM 197#define KVM_CAP_PTP_KVM 198 +#define KVM_CAP_ARM_SDEI 199#ifdef KVM_CAP_IRQ_ROUTING
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v3 21/21 KVM: selftests: Add SDEI test case
In reply to Gavin ShanThis adds SDEI test case into selftests where the various hypercalls are issued to kvm private event (0x40200000) and then ensure that's completed without error. Note that two vCPUs are started up by default to run same consequence. Actually, it's simulating what SDEI client driver does and the following hypercalls are issued in sequence:
SDEI_1_0_FN_SDEI_VERSION (probing SDEI capability) SDEI_1_0_FN_SDEI_PE_UNMASK (CPU online) SDEI_1_0_FN_SDEI_PRIVATE_RESET (restart SDEI) SDEI_1_0_FN_SDEI_SHARED_RESET SDEI_1_0_FN_SDEI_EVENT_GET_INFO (register event) SDEI_1_0_FN_SDEI_EVENT_GET_INFO SDEI_1_0_FN_SDEI_EVENT_GET_INFO SDEI_1_0_FN_SDEI_EVENT_REGISTER SDEI_1_0_FN_SDEI_EVENT_ENABLE (enable event) SDEI_1_0_FN_SDEI_EVENT_DISABLE (disable event) SDEI_1_0_FN_SDEI_EVENT_UNREGISTER (unregister event) SDEI_1_0_FN_SDEI_PE_MASK (CPU offline)
--- tools/testing/selftests/kvm/Makefile | 1 + tools/testing/selftests/kvm/aarch64/sdei.c | 172 +++++++++++++++++++++ 2 files changed, 173 insertions(+) create mode 100644 tools/testing/selftests/kvm/aarch64/sdei.c
tools/testing/selftests/kvm/Makefile +1 -0
@@ -79,6 +79,7 @@ TEST_GEN_PROGS_x86_64 += steal_time TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list TEST_GEN_PROGS_aarch64 += aarch64/get-reg-list-sve +TEST_GEN_PROGS_aarch64 += aarch64/sdei TEST_GEN_PROGS_aarch64 += aarch64/vgic_init TEST_GEN_PROGS_aarch64 += demand_paging_test TEST_GEN_PROGS_aarch64 += dirty_log_test
tools/testing/selftests/kvm/aarch64/sdei.c new file +172 -0
172 lines not on this page · raw message
Signature · 6 lines
2.23.0 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm