arm64: Stolen time support
Subsystems (8)
v2 cover arm64: Stolen time support
This series add support for paravirtualized time for arm64 guests and KVM hosts following the specification in Arm's document DEN 0057A:
https://developer.arm.com/docs/den0057/a
It implements support for stolen time, allowing the guest to identify time when it is forcibly not executing.
It doesn't implement support for Live Physical Time (LPT) as there are some concerns about the overheads and approach in the above specification, and I expect an updated version of the specification to be released soon with just the stolen time parts.
NOTE: Patches 7 and 8 will conflict with Mark Rutland's series[1] cleaning up the SMCCC conduit. I do feel that the addition of an _invoke() call makes a number of call sites cleaner and it should be possible to integrate both this and Mark's other cleanups.
[1] https://lore.kernel.org/linux-arm-kernel/[email protected]/
Changes from v1:
https://lore.kernel.org/lkml/[email protected]/
* Host kernel no longer allocates the stolen time structure, instead it is allocated by user space. This means the save/restore functionality can be removed.
* Refactored the code so arm has stub implementations and to avoid initcall
* Rebased to pick up Documentation/{virt->virtual} change
* Bunch of typo fixes
Christoffer Dall (1):
KVM: arm/arm64: Factor out hypercall handling from PSCI code
Steven Price (8):
KVM: arm64: Document PV-time interface
KVM: arm64: Implement PV_FEATURES call
KVM: arm64: Support stolen time reporting via shared structure
KVM: Allow kvm_device_ops to be const
KVM: arm64: Provide a PV_TIME device to user space arm/arm64: Provide a wrapper for SMCCC 1.1 calls arm/arm64: Make use of the SMCCC 1.1 wrapper
arm64: Retrieve stolen time as paravirtualized guest
Documentation/virt/kvm/arm/pvtime.txt | 100 +++++++++++++ arch/arm/include/asm/kvm_host.h | 21 +++ arch/arm/kvm/Makefile | 2 +- arch/arm/kvm/handle_exit.c | 2 +- arch/arm/mm/proc-v7-bugs.c | 13 +- arch/arm64/include/asm/kvm_host.h | 19 ++- arch/arm64/include/asm/paravirt.h | 9 +- arch/arm64/include/asm/pvclock-abi.h | 17 +++ arch/arm64/include/uapi/asm/kvm.h | 8 ++ arch/arm64/kernel/cpu_errata.c | 80 ++++------- arch/arm64/kernel/paravirt.c | 147 +++++++++++++++++++ arch/arm64/kernel/time.c | 3 + arch/arm64/kvm/Kconfig | 1 + arch/arm64/kvm/Makefile | 2 + arch/arm64/kvm/handle_exit.c | 4 +- include/kvm/arm_hypercalls.h | 43 ++++++ include/kvm/arm_psci.h | 2 +- include/linux/arm-smccc.h | 58 ++++++++ include/linux/cpuhotplug.h | 1 + include/linux/kvm_host.h | 4 +- include/linux/kvm_types.h | 2 + include/uapi/linux/kvm.h | 2 + virt/kvm/arm/arm.c | 20 +++ virt/kvm/arm/hypercalls.c | 68 +++++++++ virt/kvm/arm/psci.c | 84 +---------- virt/kvm/arm/pvtime.c | 194 ++++++++++++++++++++++++++ virt/kvm/kvm_main.c | 6 +- 27 files changed, 758 insertions(+), 154 deletions(-) create mode 100644 Documentation/virt/kvm/arm/pvtime.txt create mode 100644 arch/arm64/include/asm/pvclock-abi.h create mode 100644 include/kvm/arm_hypercalls.h create mode 100644 virt/kvm/arm/hypercalls.c create mode 100644 virt/kvm/arm/pvtime.c
Signature · 1 line
2.20.1
PATCH v2 1/9 KVM: arm64: Document PV-time interface
Introduce a paravirtualization interface for KVM/arm64 based on the "Arm Paravirtualized Time for Arm-Base Systems" specification DEN 0057A.
This only adds the details about "Stolen Time" as the details of "Live Physical Time" have not been fully agreed.
User space can specify a reserved area of memory for the guest and inform KVM to populate the memory with information on time that the host kernel has stolen from the guest.
A hypercall interface is provided for the guest to interrogate the hypervisor's support for this interface and the location of the shared memory structures.
--- Documentation/virt/kvm/arm/pvtime.txt | 100 ++++++++++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 Documentation/virt/kvm/arm/pvtime.txt
Documentation/virt/kvm/arm/pvtime.txt new file +100 -0
@@ -0,0 +1,100 @@ +Paravirtualized time support for arm64 +====================================== + +Arm specification DEN0057/A defined a standard for paravirtualised time +support for AArch64 guests: + +https://developer.arm.com/docs/den0057/a + +KVM/arm64 implements the stolen time part of this specification by providing +some hypervisor service calls to support a paravirtualized guest obtaining a +view of the amount of time stolen from its execution. + +Two new SMCCC compatible hypercalls are defined: + +PV_FEATURES 0xC5000020 +PV_TIME_ST 0xC5000022 + +These are only available in the SMC64/HVC64 calling convention as +paravirtualized time is not available to 32 bit Arm guests. The existence of +the PV_FEATURES hypercall should be probed using the SMCCC 1.1 ARCH_FEATURES +mechanism before calling it. + +PV_FEATURES + Function ID: (uint32) : 0xC5000020 + PV_func_id: (uint32) : Either PV_TIME_LPT or PV_TIME_ST + Return value: (int32) : NOT_SUPPORTED (-1) or SUCCESS (0) if the relevant + PV-time feature is supported by the hypervisor. + +PV_TIME_ST + Function ID: (uint32) : 0xC5000022 + Return value: (int64) : IPA of the stolen time data structure for this + (V)CPU. On failure: + NOT_SUPPORTED (-1) + +The IPA returned by PV_TIME_ST should be mapped by the guest as normal memory +with inner and outer write back caching attributes, in the inner shareable +domain. A total of 16 bytes from the IPA returned are guaranteed to be +meaningfully filled by the hypervisor (see structure below). + +PV_TIME_ST returns the structure for the calling VCPU. + +Stolen Time +----------- + +The structure pointed to by the PV_TIME_ST hypercall is as follows: + + Field | Byte Length | Byte Offset | Description + ----------- | ----------- | ----------- | -------------------------- + Revision | 4 | 0 | Must be 0 for version 0.1 + Attributes | 4 | 4 | Must be 0 + Stolen time | 8 | 8 | Stolen time in unsigned + | | | nanoseconds indicating how + | | | much time this VCPU thread + | | | was involuntarily not + | | | running on a physical CPU. + +The structure will be updated by the hypervisor prior to scheduling a VCPU. It +will be present within a reserved region of the normal memory given to the +guest. The guest should not attempt to write into this memory. There is a +structure per VCPU of the guest. + +User space interface +==================== + +User space can request that KVM provide the paravirtualized time interface to +a guest by creating a KVM_DEV_TYPE_ARM_PV_TIME device, for example: + + struct kvm_create_device pvtime_device = { + .type = KVM_DEV_TYPE_ARM_PV_TIME, + .attr = 0, + .flags = 0, + }; + + pvtime_fd = ioctl(vm_fd, KVM_CREATE_DEVICE, &pvtime_device); + +Creation of the device should be done after creating the vCPUs of the virtual +machine. + +The IPA of the structures must be given to KVM. This is the base address +of an array of stolen time structures (one for each VCPU). The base address +must be page aligned. The size must be at least 64 * number of VCPUs and be a +multiple of PAGE_SIZE. + +The memory for these structures should be added to the guest in the usual +manner (e.g. using KVM_SET_USER_MEMORY_REGION). + +For example: + + struct kvm_dev_arm_st_region region = { + .gpa = <IPA of guest base address>, + .size = <size in bytes> + }; + + struct kvm_device_attr st_base = { + .group = KVM_DEV_ARM_PV_TIME_PADDR, + .attr = KVM_DEV_ARM_PV_TIME_ST, + .addr = (u64)®ion + }; + + ioctl(pvtime_fd, KVM_SET_DEVICE_ATTR, &st_base);
Signature · 1 line
2.20.1
PATCH v2 2/9 KVM: arm/arm64: Factor out hypercall handling from PSCI code
In reply to Steven PriceFrom: Christoffer Dall <[email protected]>
We currently intertwine the KVM PSCI implementation with the general dispatch of hypercall handling, which makes perfect sense because PSCI is the only category of hypercalls we support.
However, as we are about to support additional hypercalls, factor out this functionality into a separate hypercall handler file.
--- arch/arm/kvm/Makefile | 2 +- arch/arm/kvm/handle_exit.c | 2 +- arch/arm64/kvm/Makefile | 1 + arch/arm64/kvm/handle_exit.c | 4 +- include/kvm/arm_hypercalls.h | 43 ++++++++++++++++++ include/kvm/arm_psci.h | 2 +- virt/kvm/arm/hypercalls.c | 59 +++++++++++++++++++++++++ virt/kvm/arm/psci.c | 84 +----------------------------------- 8 files changed, 110 insertions(+), 87 deletions(-) create mode 100644 include/kvm/arm_hypercalls.h create mode 100644 virt/kvm/arm/hypercalls.c
arch/arm/kvm/Makefile +1 -1
@@ -23,7 +23,7 @@ obj-y += kvm-arm.o init.o interrupts.o obj-y += handle_exit.o guest.o emulate.o reset.o obj-y += coproc.o coproc_a15.o coproc_a7.o vgic-v3-coproc.o obj-y += $(KVM)/arm/arm.o $(KVM)/arm/mmu.o $(KVM)/arm/mmio.o -obj-y += $(KVM)/arm/psci.o $(KVM)/arm/perf.o +obj-y += $(KVM)/arm/psci.o $(KVM)/arm/perf.o $(KVM)/arm/hypercalls.o obj-y += $(KVM)/arm/aarch32.o obj-y += $(KVM)/arm/vgic/vgic.o
arch/arm/kvm/handle_exit.c +1 -1
@@ -9,7 +9,7 @@#include <asm/kvm_emulate.h> #include <asm/kvm_coproc.h> #include <asm/kvm_mmu.h> -#include <kvm/arm_psci.h> +#include <kvm/arm_hypercalls.h> #include <trace/events/kvm.h> #include "trace.h"
arch/arm64/kvm/Makefile +1 -0
@@ -13,6 +13,7 @@ obj-$(CONFIG_KVM_ARM_HOST) += hyp/ kvm-$(CONFIG_KVM_ARM_HOST) += $(KVM)/kvm_main.o $(KVM)/coalesced_mmio.o $(KVM)/eventfd.o $(KVM)/vfio.o kvm-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/arm.o $(KVM)/arm/mmu.o $(KVM)/arm/mmio.o kvm-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/psci.o $(KVM)/arm/perf.o +kvm-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/hypercalls.o kvm-$(CONFIG_KVM_ARM_HOST) += inject_fault.o regmap.o va_layout.o kvm-$(CONFIG_KVM_ARM_HOST) += hyp.o hyp-init.o handle_exit.o
arch/arm64/kvm/handle_exit.c +2 -2
@@ -11,8 +11,6 @@#include <linux/kvm.h> #include <linux/kvm_host.h> -#include <kvm/arm_psci.h> -#include <asm/esr.h> #include <asm/exception.h> #include <asm/kvm_asm.h>
@@ -22,6 +20,8 @@#include <asm/debug-monitors.h> #include <asm/traps.h> +#include <kvm/arm_hypercalls.h> +#define CREATE_TRACE_POINTS #include "trace.h"
include/kvm/arm_hypercalls.h new file +43 -0
43 lines not on this page · raw message
include/kvm/arm_psci.h +1 -1
@@ -40,7 +40,7 @@ static inline int kvm_psci_version(struct kvm_vcpu *vcpu, struct kvm *kvm) } -int kvm_hvc_call_handler (struct kvm_vcpu *vcpu); +int kvm_psci_call (struct kvm_vcpu *vcpu);struct kvm_one_reg ;
virt/kvm/arm/hypercalls.c new file +59 -0
59 lines not on this page · raw message
virt/kvm/arm/psci.c +2 -82
108 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH v2 3/9 KVM: arm64: Implement PV_FEATURES call
In reply to Steven PriceThis provides a mechanism for querying which paravirtualized features are available in this hypervisor.
Also add the header file which defines the ABI for the paravirtualized clock features we're about to add.
--- arch/arm/include/asm/kvm_host.h | 6 ++++++ arch/arm64/include/asm/kvm_host.h | 2 ++ arch/arm64/include/asm/pvclock-abi.h | 17 +++++++++++++++++ arch/arm64/kvm/Makefile | 1 + include/linux/arm-smccc.h | 14 ++++++++++++++ virt/kvm/arm/hypercalls.c | 6 ++++++ virt/kvm/arm/pvtime.c | 21 +++++++++++++++++++++ 7 files changed, 67 insertions(+) create mode 100644 arch/arm64/include/asm/pvclock-abi.h create mode 100644 virt/kvm/arm/pvtime.c
arch/arm/include/asm/kvm_host.h +6 -0
@@ -7,6 +7,7 @@#ifndef __ARM_KVM_HOST_H__#define __ARM_KVM_HOST_H__ +#include <linux/arm-smccc.h> #include <linux/errno.h> #include <linux/types.h> #include <linux/kvm_types.h>
@@ -323,6 +324,11 @@ static inline int kvm_arch_vm_ioctl_check_extension(struct kvm *kvm, long ext)int kvm_perf_init (void );int kvm_perf_teardown (void ); +static inline int kvm_hypercall_pv_features (struct kvm_vcpu *vcpu) +{ +return SMCCC_RET_NOT_SUPPORTED ; +} +void kvm_mmu_wp_memory_region (struct kvm *kvm,int slot);struct kvm_vcpu *kvm_mpidr_to_vcpu (struct kvm *kvm,unsigned long mpidr);
arch/arm64/include/asm/kvm_host.h +2 -0
@@ -478,6 +478,8 @@ void handle_exit_early(struct kvm_vcpu *vcpu, struct kvm_run *run,int kvm_perf_init (void );int kvm_perf_teardown (void ); +int kvm_hypercall_pv_features (struct kvm_vcpu *vcpu); +void kvm_set_sei_esr (struct kvm_vcpu *vcpu,u64 syndrome);struct kvm_vcpu *kvm_mpidr_to_vcpu (struct kvm *kvm,unsigned long mpidr);
arch/arm64/include/asm/pvclock-abi.h new file +17 -0
@@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Copyright (C) 2019 Arm Ltd. */ + +#ifndef __ASM_PVCLOCK_ABI_H +#define __ASM_PVCLOCK_ABI_H + +/* The below structure is defined in ARM DEN0057A */ + +struct pvclock_vcpu_stolen_time { +__le32 revision; +__le32 attributes; +__le64 stolen_time; +/* Structure must be 64 byte aligned, pad to that size */ +u8 padding[48 ]; +} __packed; + +#endif
arch/arm64/kvm/Makefile +1 -0
@@ -14,6 +14,7 @@ kvm-$(CONFIG_KVM_ARM_HOST) += $(KVM)/kvm_main.o $(KVM)/coalesced_mmio.o $(KVM)/e kvm-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/arm.o $(KVM)/arm/mmu.o $(KVM)/arm/mmio.o kvm-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/psci.o $(KVM)/arm/perf.o kvm-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/hypercalls.o +kvm-$(CONFIG_KVM_ARM_HOST) += $(KVM)/arm/pvtime.o kvm-$(CONFIG_KVM_ARM_HOST) += inject_fault.o regmap.o va_layout.o kvm-$(CONFIG_KVM_ARM_HOST) += hyp.o hyp-init.o handle_exit.o
include/linux/arm-smccc.h +14 -0
@@ -45,6 +45,7 @@#define ARM_SMCCC_OWNER_SIP 2#define ARM_SMCCC_OWNER_OEM 3#define ARM_SMCCC_OWNER_STANDARD 4 +#define ARM_SMCCC_OWNER_STANDARD_HYP 5#define ARM_SMCCC_OWNER_TRUSTED_APP 48#define ARM_SMCCC_OWNER_TRUSTED_APP_END 49#define ARM_SMCCC_OWNER_TRUSTED_OS 50
@@ -302,5 +303,18 @@ asmlinkage void __arm_smccc_hvc(unsigned long a0, unsigned long a1,#define SMCCC_RET_NOT_SUPPORTED -1#define SMCCC_RET_NOT_REQUIRED -2 +/* Paravirtualised time calls (defined by ARM DEN0057A) */ +#define ARM_SMCCC_HV_PV_FEATURES \ + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ + ARM_SMCCC_SMC_64, \ + ARM_SMCCC_OWNER_STANDARD_HYP, \ + 0x20) + +#define ARM_SMCCC_HV_PV_TIME_ST \ + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ + ARM_SMCCC_SMC_64, \ + ARM_SMCCC_OWNER_STANDARD_HYP, \ + 0x22) +#endif /*__ASSEMBLY__*/ #endif /*__LINUX_ARM_SMCCC_H*/
virt/kvm/arm/hypercalls.c +6 -0
@@ -48,8 +48,14 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)break ; }break ; +case ARM_SMCCC_HV_PV_FEATURES : + val =SMCCC_RET_SUCCESS ; +break ; }break ; +case ARM_SMCCC_HV_PV_FEATURES : + val =kvm_hypercall_pv_features (vcpu); +break ;default :return kvm_psci_call (vcpu); }
virt/kvm/arm/pvtime.c new file +21 -0
@@ -0,0 +1,21 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (C) 2019 Arm Ltd. + +#include <linux/arm-smccc.h> + +#include <kvm/arm_hypercalls.h> + +int kvm_hypercall_pv_features (struct kvm_vcpu *vcpu) +{ +u32 feature =smccc_get_arg1 (vcpu); +u32 val =SMCCC_RET_NOT_SUPPORTED ; + +switch (feature) { +case ARM_SMCCC_HV_PV_FEATURES : + val =SMCCC_RET_SUCCESS ; +break ; + } + +return val; +} +
Signature · 1 line
2.20.1
PATCH v2 4/9 KVM: arm64: Support stolen time reporting via shared structure
In reply to Steven PriceImplement the service call for configuring a shared structure between a VCPU and the hypervisor in which the hypervisor can write the time stolen from the VCPU's execution time by other tasks on the host.
The hypervisor allocates memory which is placed at an IPA chosen by user space. The hypervisor then uses WRITE_ONCE() to update the shared structure ensuring single copy atomicity of the 64-bit unsigned value that reports stolen time in nanoseconds.
Whenever stolen time is enabled by the guest, the stolen time counter is reset.
The stolen time itself is retrieved from the sched_info structure maintained by the Linux scheduler code. We enable SCHEDSTATS when selecting KVM Kconfig to ensure this value is meaningful.
--- arch/arm/include/asm/kvm_host.h | 15 +++++++ arch/arm64/include/asm/kvm_host.h | 16 ++++++- arch/arm64/kvm/Kconfig | 1 + include/linux/kvm_types.h | 2 + virt/kvm/arm/arm.c | 19 +++++++++ virt/kvm/arm/hypercalls.c | 3 ++ virt/kvm/arm/pvtime.c | 71 +++++++++++++++++++++++++++++++ 7 files changed, 126 insertions(+), 1 deletion(-)
arch/arm/include/asm/kvm_host.h +15 -0
@@ -39,6 +39,7 @@ KVM_ARCH_REQ_FLAGS(0, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)#define KVM_REQ_IRQ_PENDING KVM_ARCH_REQ(1)#define KVM_REQ_VCPU_RESET KVM_ARCH_REQ(2) +#define KVM_REQ_RECORD_STEAL KVM_ARCH_REQ(3)DECLARE_STATIC_KEY_FALSE (userspace_irqchip_in_use);
@@ -77,6 +78,12 @@ struct kvm_arch {/* Mandated version of PSCI */ u32 psci_version; + +struct kvm_arch_pvtime { +struct gfn_to_hva_cache st_ghc; +gpa_t st_base; +u64 st_size; + } pvtime; };#define KVM_NR_MEM_OBJS 40
@@ -328,6 +335,14 @@ static inline int kvm_hypercall_pv_features(struct kvm_vcpu *vcpu) {return SMCCC_RET_NOT_SUPPORTED ; } +static inline int kvm_hypercall_stolen_time (struct kvm_vcpu *vcpu) +{ +return SMCCC_RET_NOT_SUPPORTED ; +} +static inline int kvm_update_stolen_time (struct kvm_vcpu *vcpu,bool init) +{ +return -ENOTSUPP ; +}void kvm_mmu_wp_memory_region (struct kvm *kvm,int slot);
arch/arm64/include/asm/kvm_host.h +15 -1
@@ -44,6 +44,7 @@ KVM_ARCH_REQ_FLAGS(0, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)#define KVM_REQ_IRQ_PENDING KVM_ARCH_REQ(1)#define KVM_REQ_VCPU_RESET KVM_ARCH_REQ(2) +#define KVM_REQ_RECORD_STEAL KVM_ARCH_REQ(3)DECLARE_STATIC_KEY_FALSE (userspace_irqchip_in_use);
@@ -83,6 +84,12 @@ struct kvm_arch {/* Mandated version of PSCI */ u32 psci_version; + +struct kvm_arch_pvtime { +struct gfn_to_hva_cache st_ghc; +gpa_t st_base; +u64 st_size; + } pvtime; };#define KVM_NR_MEM_OBJS 40
@@ -338,8 +345,13 @@ struct kvm_vcpu_arch {/* True when deferrable sysregs are loaded on the physical CPU, * see kvm_vcpu_load_sysregs and kvm_vcpu_put_sysregs. */ bool sysregs_loaded_on_cpu; -}; +/* Guest PV state */ +struct { +u64 steal; +u64 last_steal; + } steal; +};/* Pointer to the vcpu's SVE FFR for sve_{save,load}_state() */ #define vcpu_sve_pffr (vcpu) ((void *)((char *)((vcpu)->arch.sve_state) + \ sve_ffr_offset((vcpu)->arch.sve_max_vl)))
@@ -479,6 +491,8 @@ int kvm_perf_init(void);int kvm_perf_teardown (void );int kvm_hypercall_pv_features (struct kvm_vcpu *vcpu); +int kvm_hypercall_stolen_time (struct kvm_vcpu *vcpu); +int kvm_update_stolen_time (struct kvm_vcpu *vcpu,bool init);void kvm_set_sei_esr (struct kvm_vcpu *vcpu,u64 syndrome);
arch/arm64/kvm/Kconfig +1 -0
@@ -39,6 +39,7 @@ config KVM select IRQ_BYPASS_MANAGER select HAVE_KVM_IRQ_BYPASS select HAVE_KVM_VCPU_RUN_PID_CHANGE + select SCHEDSTATS ---help--- Support hosting virtualized guest machines. We don't support KVM with 16K page tables yet, due to the multiple
include/linux/kvm_types.h +2 -0
@@ -35,6 +35,8 @@ typedef unsigned long gva_t;typedef u64 gpa_t ;typedef u64 gfn_t ; +#define GPA_INVALID (~(gpa_t)0) +typedef unsigned long hva_t ;typedef u64 hpa_t ;typedef u64 hfn_t ;
virt/kvm/arm/arm.c +19 -0
@@ -40,6 +40,10 @@#include <asm/kvm_coproc.h> #include <asm/sections.h> +#include <kvm/arm_hypercalls.h> +#include <kvm/arm_pmu.h> +#include <kvm/arm_psci.h> +#ifdef REQUIRES_VIRT __asm__(".arch_extension virt" );#endif
@@ -135,6 +139,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) kvm->arch.max_vcpus = vgic_present ?kvm_vgic_get_max_vcpus () :KVM_MAX_VCPUS ; + kvm->arch.pvtime.st_base =GPA_INVALID ;return ret; out_free_stage2_pgd:kvm_free_stage2_pgd (kvm);
@@ -379,6 +384,8 @@ void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)kvm_vcpu_load_sysregs (vcpu);kvm_arch_vcpu_load_fp (vcpu);kvm_vcpu_pmu_restore_guest (vcpu); +if (vcpu->kvm->arch.pvtime.st_base !=GPA_INVALID ) +kvm_make_request (KVM_REQ_RECORD_STEAL , vcpu);if (single_task_running ())vcpu_clear_wfe_traps (vcpu);
@@ -625,6 +632,15 @@ static void vcpu_req_sleep(struct kvm_vcpu *vcpu)smp_rmb (); } +static void vcpu_req_record_steal (struct kvm_vcpu *vcpu) +{ +int idx; + + idx =srcu_read_lock (&vcpu->kvm->srcu); +kvm_update_stolen_time (vcpu, false); +srcu_read_unlock (&vcpu->kvm->srcu, idx); +} +static int kvm_vcpu_initialized (struct kvm_vcpu *vcpu) {return vcpu->arch.target >=0 ;
@@ -644,6 +660,9 @@ static void check_vcpu_requests(struct kvm_vcpu *vcpu)* that a VCPU sees new virtual interrupts. */ kvm_check_request (KVM_REQ_IRQ_PENDING , vcpu); + +if (kvm_check_request (KVM_REQ_RECORD_STEAL , vcpu)) +vcpu_req_record_steal (vcpu); } }
virt/kvm/arm/hypercalls.c +3 -0
@@ -56,6 +56,9 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)case ARM_SMCCC_HV_PV_FEATURES : val =kvm_hypercall_pv_features (vcpu);break ; +case ARM_SMCCC_HV_PV_TIME_ST : + val =kvm_hypercall_stolen_time (vcpu); +break ;default :return kvm_psci_call (vcpu); }
virt/kvm/arm/pvtime.c +71 -0
88 lines not on this page · raw message
Signature · 1 line
2.20.1
Marc Zyngier
maintainerRe: [PATCH v2 4/9] KVM: arm64: Support stolen time reporting via shared structure
Hi Steven,
Quoted 40 lines · Steven Price
Implement the service call for configuring a shared structure between a VCPU and the hypervisor in which the hypervisor can write the time stolen from the VCPU's execution time by other tasks on the host.
The hypervisor allocates memory which is placed at an IPA chosen by user space. The hypervisor then uses
WRITE_ONCE()to update the shared structure ensuring single copy atomicity of the 64-bit unsigned value that reports stolen time in nanoseconds.Whenever stolen time is enabled by the guest, the stolen time counter is reset.
The stolen time itself is retrieved from the
sched_infostructure maintained by the Linux scheduler code. We enable SCHEDSTATS when selecting KVMKconfigto ensure this value is meaningful.Signed-off-by Steven Price <[email protected]>--- arch/arm/include/asm/kvm_host.h | 15 +++++++ arch/arm64/include/asm/kvm_host.h | 16 ++++++- arch/arm64/kvm/Kconfig | 1 + include/linux/kvm_types.h | 2 + virt/kvm/arm/arm.c | 19 +++++++++ virt/kvm/arm/hypercalls.c | 3 ++ virt/kvm/arm/pvtime.c | 71 +++++++++++++++++++++++++++++++ 7 files changed, 126 insertions(+), 1 deletion(-)arch/arm/include/asm/kvm_host.h +1
-0@@ -39,6 +39,7 @@ KVM_ARCH_REQ_FLAGS(0, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)#define KVM_REQ_IRQ_PENDING KVM_ARCH_REQ(1)#define KVM_REQ_VCPU_RESET KVM_ARCH_REQ(2) +#define KVM_REQ_RECORD_STEAL KVM_ARCH_REQ(3)DECLARE_STATIC_KEY_FALSE (userspace_irqchip_in_use);
arch/arm/include/asm/kvm_host.h struct kvm_arch { · line 86
Quoted 9 lines
arch/arm/include/asm/kvm_host.h +6
-0@@ -77,6 +78,12 @@ struct kvm_arch {/* Mandated version of PSCI */ u32 psci_version; + +struct kvm_arch_pvtime { +struct gfn_to_hva_cache st_ghc; +gpa_t st_base; +u64 st_size; + } pvtime;
It'd be good if we could avoid having this in the 32bit vcpu structure, given that it serves no real purpose (other than being able to compile things).
Quoted 192 lines
arch/arm/include/asm/kvm_host.h +8
-0};#define KVM_NR_MEM_OBJS 40@@ -328,6 +335,14 @@ static inline int kvm_hypercall_pv_features(struct kvm_vcpu *vcpu) {return SMCCC_RET_NOT_SUPPORTED ; } +static inline int kvm_hypercall_stolen_time (struct kvm_vcpu *vcpu) +{ +return SMCCC_RET_NOT_SUPPORTED ; +} +static inline int kvm_update_stolen_time (struct kvm_vcpu *vcpu,bool init) +{ +return -ENOTSUPP ; +}void kvm_mmu_wp_memory_region (struct kvm *kvm,int slot);arch/arm64/include/asm/kvm_host.h +15
-1@@ -44,6 +44,7 @@ KVM_ARCH_REQ_FLAGS(0, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)#define KVM_REQ_IRQ_PENDING KVM_ARCH_REQ(1)#define KVM_REQ_VCPU_RESET KVM_ARCH_REQ(2) +#define KVM_REQ_RECORD_STEAL KVM_ARCH_REQ(3)DECLARE_STATIC_KEY_FALSE (userspace_irqchip_in_use);@@ -83,6 +84,12 @@ struct kvm_arch {/* Mandated version of PSCI */ u32 psci_version; + +struct kvm_arch_pvtime { +struct gfn_to_hva_cache st_ghc; +gpa_t st_base; +u64 st_size; + } pvtime; };#define KVM_NR_MEM_OBJS 40@@ -338,8 +345,13 @@ struct kvm_vcpu_arch {/* True when deferrable sysregs are loaded on the physical CPU, * see kvm_vcpu_load_sysregs and kvm_vcpu_put_sysregs. */ bool sysregs_loaded_on_cpu; -}; +/* Guest PV state */ +struct { +u64 steal; +u64 last_steal; + } steal; +};/* Pointer to the vcpu's SVE FFR for sve_{save,load}_state() */ #define vcpu_sve_pffr (vcpu) ((void *)((char *)((vcpu)->arch.sve_state) + \ sve_ffr_offset((vcpu)->arch.sve_max_vl)))@@ -479,6 +491,8 @@ int kvm_perf_init(void);int kvm_perf_teardown (void );int kvm_hypercall_pv_features (struct kvm_vcpu *vcpu); +int kvm_hypercall_stolen_time (struct kvm_vcpu *vcpu); +int kvm_update_stolen_time (struct kvm_vcpu *vcpu,bool init);void kvm_set_sei_esr (struct kvm_vcpu *vcpu,u64 syndrome);arch/arm64/kvm/Kconfig +1
-0@@ -39,6 +39,7 @@ config KVM select IRQ_BYPASS_MANAGER select HAVE_KVM_IRQ_BYPASS select HAVE_KVM_VCPU_RUN_PID_CHANGE + select SCHEDSTATS ---help--- Support hosting virtualized guest machines. We don't support KVM with 16K page tables yet, due to the multipleinclude/linux/kvm_types.h +2
-0@@ -35,6 +35,8 @@ typedef unsigned long gva_t;typedef u64 gpa_t ;typedef u64 gfn_t ; +#define GPA_INVALID (~(gpa_t)0) +typedef unsigned long hva_t ;typedef u64 hpa_t ;typedef u64 hfn_t ;virt/kvm/arm/arm.c +19
-0@@ -40,6 +40,10 @@#include <asm/kvm_coproc.h> #include <asm/sections.h> +#include <kvm/arm_hypercalls.h> +#include <kvm/arm_pmu.h> +#include <kvm/arm_psci.h> +#ifdef REQUIRES_VIRT __asm__(".arch_extension virt" );#endif @@ -135,6 +139,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type) kvm->arch.max_vcpus = vgic_present ?kvm_vgic_get_max_vcpus () :KVM_MAX_VCPUS ; + kvm->arch.pvtime.st_base =GPA_INVALID ;return ret; out_free_stage2_pgd:kvm_free_stage2_pgd (kvm);@@ -379,6 +384,8 @@ void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)kvm_vcpu_load_sysregs (vcpu);kvm_arch_vcpu_load_fp (vcpu);kvm_vcpu_pmu_restore_guest (vcpu); +if (vcpu->kvm->arch.pvtime.st_base !=GPA_INVALID ) +kvm_make_request (KVM_REQ_RECORD_STEAL , vcpu);if (single_task_running ())vcpu_clear_wfe_traps (vcpu);@@ -625,6 +632,15 @@ static void vcpu_req_sleep(struct kvm_vcpu *vcpu)smp_rmb (); } +static void vcpu_req_record_steal (struct kvm_vcpu *vcpu) +{ +int idx; + + idx =srcu_read_lock (&vcpu->kvm->srcu); +kvm_update_stolen_time (vcpu, false); +srcu_read_unlock (&vcpu->kvm->srcu, idx); +} +static int kvm_vcpu_initialized (struct kvm_vcpu *vcpu) {return vcpu->arch.target >=0 ;@@ -644,6 +660,9 @@ static void check_vcpu_requests(struct kvm_vcpu *vcpu)* that a VCPU sees new virtual interrupts. */ kvm_check_request (KVM_REQ_IRQ_PENDING , vcpu); + +if (kvm_check_request (KVM_REQ_RECORD_STEAL , vcpu)) +vcpu_req_record_steal (vcpu); } }virt/kvm/arm/hypercalls.c +3
-0@@ -56,6 +56,9 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)case ARM_SMCCC_HV_PV_FEATURES : val =kvm_hypercall_pv_features (vcpu);break ; +case ARM_SMCCC_HV_PV_TIME_ST : + val =kvm_hypercall_stolen_time (vcpu); +break ;default :return kvm_psci_call (vcpu); }virt/kvm/arm/pvtime.c +18
-0@@ -3,8 +3,55 @@#include <linux/arm-smccc.h> +#include <asm/pvclock-abi.h> +#include <kvm/arm_hypercalls.h> +int kvm_update_stolen_time (struct kvm_vcpu *vcpu,bool init) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_arch_pvtime *pvtime = &kvm->arch.pvtime; +u64 steal; +u64 steal_le; +u64 offset; +int idx; +const int stride =sizeof (struct pvclock_vcpu_stolen_time ); + +if (pvtime->st_base ==GPA_INVALID ) +return -ENOTSUPP ; + +/* Let's do the local bookkeeping */ + steal = vcpu->arch.steal.steal; + steal += current->sched_info.run_delay - vcpu->arch.steal.last_steal;
virt/kvm/arm/pvtime.c line 35
Quoted 10 lines
virt/kvm/arm/pvtime.c +10
-0+ vcpu->arch.steal.last_steal = current->sched_info.run_delay; + vcpu->arch.steal.steal = steal; + + offset = stride *kvm_vcpu_get_idx (vcpu); + +if (unlikely (offset + stride > pvtime->st_size)) +return -EINVAL ; + + steal_le =cpu_to_le64 (steal); +pagefault_disable ();
What's the reason for doing a pagefault_disable()? What I'd expect is for the userspace page to be faulted in and written to, and doing a pagefault_disable() seems to be going against this idea.
Quoted 48 lines
virt/kvm/arm/pvtime.c +33
-0+ idx =srcu_read_lock (&kvm->srcu); +if (init) { +struct pvclock_vcpu_stolen_time init_values = { + .revision =0 , + .attributes =0 + }; +kvm_write_guest_offset_cached (kvm, + &pvtime->st_ghc, + &init_values, offset,sizeof (init_values)); + } + offset += offsetof(struct pvclock_vcpu_stolen_time , stolen_time); +kvm_write_guest_offset_cached (kvm, &pvtime->st_ghc, + &steal_le, offset,sizeof (steal_le)); +srcu_read_unlock (&kvm->srcu, idx); +pagefault_enable (); + +return 0 ; +} +int kvm_hypercall_pv_features (struct kvm_vcpu *vcpu) {u32 feature =smccc_get_arg1 (vcpu);@@ -12,6 +59,7 @@ int kvm_hypercall_pv_features(struct kvm_vcpu *vcpu)switch (feature) {case ARM_SMCCC_HV_PV_FEATURES : +case ARM_SMCCC_HV_PV_TIME_ST : val =SMCCC_RET_SUCCESS ;break ; }@@ -19,3 +67,26 @@ int kvm_hypercall_pv_features(struct kvm_vcpu *vcpu)return val; } +int kvm_hypercall_stolen_time (struct kvm_vcpu *vcpu) +{ +u64 ret; +int err; + +/* +* Start counting stolen time from the time the guest requests +* the feature enabled. +*/ + vcpu->arch.steal.steal =0 ; + vcpu->arch.steal.last_steal = current->sched_info.run_delay; + + err =kvm_update_stolen_time (vcpu, true);
virt/kvm/arm/pvtime.c int kvm_hypercall_pv_features(struct kvm_vcpu *vcpu) · line 92
Quoted 10 lines
virt/kvm/arm/pvtime.c +10
-0+ +if (err) + ret =SMCCC_RET_NOT_SUPPORTED ; +else + ret = vcpu->kvm->arch.pvtime.st_base + + (sizeof (struct pvclock_vcpu_stolen_time ) * +kvm_vcpu_get_idx (vcpu)); + +return ret; +}
Thanks,
M.
Signature · 1 line
Jazz is not dead, it just smells funny...
Re: [PATCH v2 4/9] KVM: arm64: Support stolen time reporting via shared structure
Quoted 44 lines · Marc Zyngier
Hi Steven,
Quoted 41 lines · Steven Price
Implement the service call for configuring a shared structure between a VCPU and the hypervisor in which the hypervisor can write the time stolen from the VCPU's execution time by other tasks on the host.
The hypervisor allocates memory which is placed at an IPA chosen by user space. The hypervisor then uses
WRITE_ONCE()to update the shared structure ensuring single copy atomicity of the 64-bit unsigned value that reports stolen time in nanoseconds.Whenever stolen time is enabled by the guest, the stolen time counter is reset.
The stolen time itself is retrieved from the
sched_infostructure maintained by the Linux scheduler code. We enable SCHEDSTATS when selecting KVMKconfigto ensure this value is meaningful.Signed-off-by Steven Price <[email protected]>--- arch/arm/include/asm/kvm_host.h | 15 +++++++ arch/arm64/include/asm/kvm_host.h | 16 ++++++- arch/arm64/kvm/Kconfig | 1 + include/linux/kvm_types.h | 2 + virt/kvm/arm/arm.c | 19 +++++++++ virt/kvm/arm/hypercalls.c | 3 ++ virt/kvm/arm/pvtime.c | 71 +++++++++++++++++++++++++++++++ 7 files changed, 126 insertions(+), 1 deletion(-)arch/arm/include/asm/kvm_host.h +1
-0@@ -39,6 +39,7 @@ KVM_ARCH_REQ_FLAGS(0, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)#define KVM_REQ_IRQ_PENDING KVM_ARCH_REQ(1)#define KVM_REQ_VCPU_RESET KVM_ARCH_REQ(2) +#define KVM_REQ_RECORD_STEAL KVM_ARCH_REQ(3)DECLARE_STATIC_KEY_FALSE (userspace_irqchip_in_use);@@ -77,6 +78,12 @@ struct kvm_arch {
Quoted 12 lines
arch/arm/include/asm/kvm_host.h struct kvm_arch { · line 86
Quoted 8 lines
arch/arm/include/asm/kvm_host.h +6
-0/* Mandated version of PSCI */ u32 psci_version; + +struct kvm_arch_pvtime { +struct gfn_to_hva_cache st_ghc; +gpa_t st_base; +u64 st_size; + } pvtime;It'd be good if we could avoid having this in the 32bit vcpu structure, given that it serves no real purpose (other than being able to compile things).
Good point - I think I can fix that with a couple more static inline functions... It's a little tricky due to header file include order, but I think I can make it work.
[...]
Quoted 22 lines
Quoted 22 lines
arch/arm/include/asm/kvm_host.h +22
-0+int kvm_update_stolen_time (struct kvm_vcpu *vcpu,bool init) +{ +struct kvm *kvm = vcpu->kvm; +struct kvm_arch_pvtime *pvtime = &kvm->arch.pvtime; +u64 steal; +u64 steal_le; +u64 offset; +int idx; +const int stride =sizeof (struct pvclock_vcpu_stolen_time ); + +if (pvtime->st_base ==GPA_INVALID ) +return -ENOTSUPP ; + +/* Let's do the local bookkeeping */ + steal = vcpu->arch.steal.steal; + steal += current->sched_info.run_delay - vcpu->arch.steal.last_steal; + vcpu->arch.steal.last_steal = current->sched_info.run_delay; + vcpu->arch.steal.steal = steal; + + offset = stride *kvm_vcpu_get_idx (vcpu); + +if (unlikely (offset + stride > pvtime->st_size))
Quoted 8 lines
arch/arm/include/asm/kvm_host.h
Quoted 4 lines
arch/arm/include/asm/kvm_host.h +4
-0+return -EINVAL ; + + steal_le =cpu_to_le64 (steal); +pagefault_disable ();What's the reason for doing a
pagefault_disable()? What I'd expect is for the userspace page to be faulted in and written to, and doing apagefault_disable()seems to be going against this idea.
Umm... this is me screwing up the locking...
The current code is very confused about which locks should/can be held when kvm_update_stolen_time() is called. vcpu_req_record_steal() explicitly takes the kvm->srcu read lock - which is then taken again here. But kvm_hypercall_stolen_time doesn't hold any lock. And obviously at some point in time I expected this to be called in atomic context...
In general the page is likely to be faulted in (as a guest which is using stolen time is surely looking at the numbers there). But there's no need for the pagefault_disable(). It also shouldn't be the callers responsibility to hold kvm->srcu.
Steve
PATCH v2 5/9 KVM: Allow kvm_device_ops to be const
In reply to Steven PriceCurrently a kvm_device_ops structure cannot be const without triggering compiler warnings. However the structure doesn't need to be written to and, by marking it const, it can be read-only in memory. Add some more const keywords to allow this.
--- include/linux/kvm_host.h | 4 ++-- virt/kvm/kvm_main.c | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-)
include/linux/kvm_host.h +2 -2
@@ -1238,7 +1238,7 @@ extern unsigned int halt_poll_ns_grow_start;extern unsigned int halt_poll_ns_shrink;struct kvm_device { -struct kvm_device_ops *ops; +const struct kvm_device_ops *ops;struct kvm *kvm;void *private;struct list_head vm_node;
@@ -1291,7 +1291,7 @@ struct kvm_device_ops {void kvm_device_get (struct kvm_device *dev);void kvm_device_put (struct kvm_device *dev);struct kvm_device *kvm_device_from_filp (struct file *filp); -int kvm_register_device_ops (struct kvm_device_ops *ops,u32 type); +int kvm_register_device_ops (const struct kvm_device_ops *ops,u32 type);void kvm_unregister_device_ops (u32 type);extern struct kvm_device_ops kvm_mpic_ops;
virt/kvm/kvm_main.c +3 -3
@@ -3046,14 +3046,14 @@ struct kvm_device *kvm_device_from_filp(struct file *filp)return filp->private_data; } -static struct kvm_device_ops *kvm_device_ops_table[KVM_DEV_TYPE_MAX ] = { +static const struct kvm_device_ops *kvm_device_ops_table[KVM_DEV_TYPE_MAX ] = { #ifdef CONFIG_KVM_MPIC [KVM_DEV_TYPE_FSL_MPIC_20 ] = &kvm_mpic_ops, [KVM_DEV_TYPE_FSL_MPIC_42 ] = &kvm_mpic_ops, #endif }; -int kvm_register_device_ops (struct kvm_device_ops *ops,u32 type) +int kvm_register_device_ops (const struct kvm_device_ops *ops,u32 type) {if (type >=ARRAY_SIZE (kvm_device_ops_table))return -ENOSPC ;
@@ -3074,7 +3074,7 @@ void kvm_unregister_device_ops(u32 type)static int kvm_ioctl_create_device (struct kvm *kvm,struct kvm_create_device *cd) { -struct kvm_device_ops *ops =NULL ; +const struct kvm_device_ops *ops =NULL ;struct kvm_device *dev;bool test = cd->flags &KVM_CREATE_DEVICE_TEST ;int type;
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v2 6/9 KVM: arm64: Provide a PV_TIME device to user space
In reply to Steven PriceAllow user space to inform the KVM host where in the physical memory map the paravirtualized time structures should be located.
A device is created which provides the base address of an array of Stolen Time (ST) structures, one for each VCPU. There must be (64 * total number of VCPUs) bytes of memory available at this location.
The address is given in terms of the physical address visible to the guest and must be page aligned. The guest will discover the address via a hypercall.
--- arch/arm64/include/asm/kvm_host.h | 1 + arch/arm64/include/uapi/asm/kvm.h | 8 +++ include/uapi/linux/kvm.h | 2 + virt/kvm/arm/arm.c | 1 + virt/kvm/arm/pvtime.c | 102 ++++++++++++++++++++++++++++++ 5 files changed, 114 insertions(+)
arch/arm64/include/asm/kvm_host.h +1 -0
@@ -490,6 +490,7 @@ void handle_exit_early(struct kvm_vcpu *vcpu, struct kvm_run *run,int kvm_perf_init (void );int kvm_perf_teardown (void ); +void kvm_pvtime_init (void );int kvm_hypercall_pv_features (struct kvm_vcpu *vcpu);int kvm_hypercall_stolen_time (struct kvm_vcpu *vcpu);int kvm_update_stolen_time (struct kvm_vcpu *vcpu,bool init);
arch/arm64/include/uapi/asm/kvm.h +8 -0
@@ -367,6 +367,14 @@ struct kvm_vcpu_events {#define KVM_PSCI_RET_INVAL PSCI_RET_INVALID_PARAMS#define KVM_PSCI_RET_DENIED PSCI_RET_DENIED +/* Device Control API: PV_TIME */ +#define KVM_DEV_ARM_PV_TIME_REGION 0 +#define KVM_DEV_ARM_PV_TIME_ST 0 +struct kvm_dev_arm_st_region { +__u64 gpa; +__u64 size; +}; +#endif #endif /* __ARM_KVM_H__ */
include/uapi/linux/kvm.h +2 -0
@@ -1222,6 +1222,8 @@ enum kvm_device_type {#define KVM_DEV_TYPE_ARM_VGIC_ITS KVM_DEV_TYPE_ARM_VGIC_ITS KVM_DEV_TYPE_XIVE,#define KVM_DEV_TYPE_XIVE KVM_DEV_TYPE_XIVE + KVM_DEV_TYPE_ARM_PV_TIME, +#define KVM_DEV_TYPE_ARM_PV_TIME KVM_DEV_TYPE_ARM_PV_TIME KVM_DEV_TYPE_MAX, };
virt/kvm/arm/arm.c +1 -0
@@ -1503,6 +1503,7 @@ static int init_subsystems(void)kvm_perf_init ();kvm_coproc_table_init (); +kvm_pvtime_init (); out:on_each_cpu (_kvm_arch_hardware_disable,NULL ,1 );
virt/kvm/arm/pvtime.c +102 -0
112 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH v2 7/9 arm/arm64: Provide a wrapper for SMCCC 1.1 calls
In reply to Steven PriceSMCCC 1.1 calls may use either HVC or SMC depending on the PSCI conduit. Rather than coding this in every call site provide a macro which uses the correct instruction. The macro also handles the case where no PSCI conduit is configured returning a not supported error in res, along with returning the conduit used for the call.
This allow us to remove some duplicated code and will be useful later when adding paravirtualized time hypervisor calls.
--- include/linux/arm-smccc.h | 44 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+)
include/linux/arm-smccc.h +44 -0
@@ -303,6 +303,50 @@ asmlinkage void __arm_smccc_hvc(unsigned long a0, unsigned long a1,#define SMCCC_RET_NOT_SUPPORTED -1#define SMCCC_RET_NOT_REQUIRED -2 +/* Like arm_smccc_1_1* but always returns SMCCC_RET_NOT_SUPPORTED. +* Used when the PSCI conduit is not defined. The empty asm statement +* avoids compiler warnings about unused variables. +*/ +#define __fail_smccc_1_1 (...) \ + do { \ + __declare_args(__count_args(__VA_ARGS__), __VA_ARGS__); \ + asm ("" __constraints(__count_args(__VA_ARGS__))); \ + if (___res) \ + ___res->a0 = SMCCC_RET_NOT_SUPPORTED; \ + } while (0) + +/* +* arm_smccc_1_1_invoke() - make an SMCCC v1.1 compliant call +* +* This is a variadic macro taking one to eight source arguments, and +* an optional return structure. +* +* @a0-a7: arguments passed in registers 0 to 7 +* @res: result values from registers 0 to 3 +* +* This macro will make either an HVC call or an SMC call depending on the +* current PSCI conduit. If no valid conduit is available then -1 +* (SMCCC_RET_NOT_SUPPORTED) is returned in @res.a0 (if supplied). +* +* The return value also provides the conduit that was used. +*/ +#define arm_smccc_1_1_invoke (...) ({ \ + int method = psci_ops.conduit; \ + switch (method) { \ + case PSCI_CONDUIT_HVC: \ + arm_smccc_1_1_hvc(__VA_ARGS__); \ + break; \ + case PSCI_CONDUIT_SMC: \ + arm_smccc_1_1_smc(__VA_ARGS__); \ + break; \ + default: \ + __fail_smccc_1_1(__VA_ARGS__); \ + method = PSCI_CONDUIT_NONE; \ + break; \ + } \ + method; \ + }) +/* Paravirtualised time calls (defined by ARM DEN0057A) */ #define ARM_SMCCC_HV_PV_FEATURES \ ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v2 8/9 arm/arm64: Make use of the SMCCC 1.1 wrapper
In reply to Steven PriceRather than directly choosing which function to use based on psci_ops.conduit, use the new arm_smccc_1_1 wrapper instead.
In some cases we still need to do some operations based on the conduit, but the code duplication is removed.
No functional change.
--- arch/arm/mm/proc-v7-bugs.c | 13 +++--- arch/arm64/kernel/cpu_errata.c | 80 ++++++++++++---------------------- 2 files changed, 33 insertions(+), 60 deletions(-)
arch/arm/mm/proc-v7-bugs.c +5 -8
@@ -78,12 +78,13 @@ static void cpu_v7_spectre_init(void)if (psci_ops.smccc_version ==SMCCC_VERSION_1_0 )break ; +arm_smccc_1_1_invoke (ARM_SMCCC_ARCH_FEATURES_FUNC_ID , +ARM_SMCCC_ARCH_WORKAROUND_1 , &res); +if ((int )res.a0 !=0 ) +return ; +switch (psci_ops.conduit) {case PSCI_CONDUIT_HVC : -arm_smccc_1_1_hvc (ARM_SMCCC_ARCH_FEATURES_FUNC_ID , -ARM_SMCCC_ARCH_WORKAROUND_1 , &res); -if ((int )res.a0 !=0 ) -break ;per_cpu (harden_branch_predictor_fn, cpu) = call_hvc_arch_workaround_1; cpu_do_switch_mm = cpu_v7_hvc_switch_mm;
@@ -91,10 +92,6 @@ static void cpu_v7_spectre_init(void)break ;case PSCI_CONDUIT_SMC : -arm_smccc_1_1_smc (ARM_SMCCC_ARCH_FEATURES_FUNC_ID , -ARM_SMCCC_ARCH_WORKAROUND_1 , &res); -if ((int )res.a0 !=0 ) -break ;per_cpu (harden_branch_predictor_fn, cpu) = call_smc_arch_workaround_1; cpu_do_switch_mm = cpu_v7_smc_switch_mm;
arch/arm64/kernel/cpu_errata.c +28 -52
117 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH v2 9/9 arm64: Retrieve stolen time as paravirtualized guest
In reply to Steven PriceEnable paravirtualization features when running under a hypervisor supporting the PV_TIME_ST hypercall.
For each (v)CPU, we ask the hypervisor for the location of a shared page which the hypervisor will use to report stolen time to us. We set pv_time_ops to the stolen time function which simply reads the stolen value from the shared page for a VCPU. We guarantee single-copy atomicity using READ_ONCE which means we can also read the stolen time for another VCPU than the currently running one while it is potentially being updated by the hypervisor.
--- arch/arm64/include/asm/paravirt.h | 9 +- arch/arm64/kernel/paravirt.c | 147 ++++++++++++++++++++++++++++++ arch/arm64/kernel/time.c | 3 + include/linux/cpuhotplug.h | 1 + 4 files changed, 159 insertions(+), 1 deletion(-)
arch/arm64/include/asm/paravirt.h +8 -1
@@ -21,6 +21,13 @@ static inline u64 paravirt_steal_clock(int cpu) {return pv_ops.time.steal_clock (cpu); } -#endif + +int __init kvm_guest_init (void ); + +#else + +#define kvm_guest_init () + +#endif // CONFIG_PARAVIRT #endif
arch/arm64/kernel/paravirt.c +147 -0
160 lines not on this page · raw message
arch/arm64/kernel/time.c +3 -0
@@ -30,6 +30,7 @@#include <asm/thread_info.h> #include <asm/stacktrace.h> +#include <asm/paravirt.h> unsigned long profile_pc (struct pt_regs *regs) {
@@ -65,4 +66,6 @@ void __init time_init(void)/* Calibrate the delay loop directly */ lpj_fine = arch_timer_rate /HZ ; + +kvm_guest_init (); }
include/linux/cpuhotplug.h +1 -0
@@ -136,6 +136,7 @@ enum cpuhp_state {/* Must be the last timer callback */ CPUHP_AP_DUMMY_TIMER_STARTING ,CPUHP_AP_ARM_XEN_STARTING , +CPUHP_AP_ARM_KVMPV_STARTING ,CPUHP_AP_ARM_CORESIGHT_STARTING ,CPUHP_AP_ARM64_ISNDEP_STARTING , CPUHP_AP_SMPCFD_DYING,
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm