KVM/arm updates for 5.5
Subsystems (11)
Marc Zyngier
maintainerPaolo, Radim,
Here's the bulk of KVM/arm updates for 5.5. On the menu, two new features:
- Stolen time is finally exposed to guests. Yay!
- We can report (and potentially emulate) instructions that KVM cannot handle in kernel space to userspace. Yay again!
Apart from that, a fairly mundane bag of perf optimization, cleanup and bug fixes.
Note that this series is based on a shared branch with the arm64 tree, avoiding a potential delicate merge.
Please pull,
M.
The following changes since commit e6ea46511b1ae8c4491904c79411fcd29139af14:
firmware: arm_sdei: use common SMCCC_CONDUIT_* (2019-10-14 10:55:14 +0100)
are available in the Git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/kvmarm/kvmarm.git tags/kvmarm-5.5
for you to fetch changes up to cd7056ae34af0e9424da97bbc7d2b38246ba8a2c:
Merge remote-tracking branch 'kvmarm/misc-5.5' into kvmarm/next (2019-11-08 11:27:29 +0000)
----------------------------------------------------------------
KVM/arm updates for Linux 5.5:
- Allow non-ISV data aborts to be reported to userspace
- Allow injection of data aborts from userspace
- Expose stolen time to guests
- GICv4 performance improvements
- vgic ITS emulation fixes
- Simplify FWB handling
- Enable halt pool counters
- Make the emulated timer PREEMPT_RT compliant
----------------------------------------------------------------
Christian Borntraeger (1):
KVM: arm/arm64: Show halt poll counters in debugfs
Christoffer Dall (4):
KVM: arm/arm64: Allow reporting non-ISV data aborts to userspace
KVM: arm/arm64: Allow user injection of external data aborts
KVM: arm/arm64: Factor out hypercall handling from PSCI code
KVM: arm64: Don't set HCR_EL2.TVM when S2FWB is supported
Marc Zyngier (6):
Merge remote-tracking branch 'arm64/for-next/smccc-conduit-cleanup' into kvm-arm64/stolen-time Merge remote-tracking branch 'kvmarm/kvm-arm64/stolen-time' into kvmarm-master/next
KVM: arm64: vgic-v4: Move the GICv4 residency flow to be driven by vcpu_load/put
KVM: vgic-v4: Track the number of VLPIs per vcpu
KVM: arm64: Opportunistically turn off WFI trapping when using direct LPI injection Merge remote-tracking branch 'kvmarm/misc-5.5' into kvmarm/next
Steven Price (10):
KVM: arm64: Document PV-time interface
KVM: arm64: Implement PV_TIME_FEATURES call
KVM: Implement kvm_put_guest()
KVM: arm64: Support stolen time reporting via shared structure
KVM: Allow kvm_device_ops to be const
KVM: arm64: Provide VCPU attributes for stolen time 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
KVM: arm64: Select TASK_DELAY_ACCT+TASKSTATS rather than SCHEDSTATS
Thomas Gleixner (1):
KVM: arm/arm64: Let the timer expire in hardirq context on RT
Zenghui Yu (3):
KVM: arm/arm64: vgic: Remove the declaration of kvm_send_userspace_msi()
KVM: arm/arm64: vgic: Fix some comments typo
KVM: arm/arm64: vgic: Don't rely on the wrong pending table
Documentation/admin-guide/kernel-parameters.txt | 6 +- Documentation/virt/kvm/api.txt | 55 +++++++++- Documentation/virt/kvm/arm/pvtime.rst | 80 ++++++++++++++ Documentation/virt/kvm/devices/vcpu.txt | 14 +++ arch/arm/include/asm/kvm_arm.h | 1 + arch/arm/include/asm/kvm_emulate.h | 9 +- arch/arm/include/asm/kvm_host.h | 33 ++++++ arch/arm/include/uapi/asm/kvm.h | 3 +- arch/arm/kvm/Makefile | 2 +- arch/arm/kvm/guest.c | 14 +++ arch/arm/kvm/handle_exit.c | 2 +- arch/arm/mm/proc-v7-bugs.c | 13 +-- arch/arm64/include/asm/kvm_arm.h | 3 +- arch/arm64/include/asm/kvm_emulate.h | 26 ++++- arch/arm64/include/asm/kvm_host.h | 37 +++++++ arch/arm64/include/asm/paravirt.h | 9 +- arch/arm64/include/asm/pvclock-abi.h | 17 +++ arch/arm64/include/uapi/asm/kvm.h | 5 +- arch/arm64/kernel/cpu_errata.c | 81 +++++--------- arch/arm64/kernel/paravirt.c | 140 ++++++++++++++++++++++++ arch/arm64/kernel/time.c | 3 + arch/arm64/kvm/Kconfig | 4 + arch/arm64/kvm/Makefile | 2 + arch/arm64/kvm/guest.c | 23 ++++ arch/arm64/kvm/handle_exit.c | 4 +- arch/arm64/kvm/inject_fault.c | 4 +- drivers/irqchip/irq-gic-v4.c | 7 +- include/Kbuild | 2 + include/kvm/arm_hypercalls.h | 43 ++++++++ include/kvm/arm_psci.h | 2 +- include/kvm/arm_vgic.h | 8 +- include/linux/arm-smccc.h | 59 ++++++++++ include/linux/cpuhotplug.h | 1 + include/linux/irqchip/arm-gic-v4.h | 4 + include/linux/kvm_host.h | 26 ++++- include/linux/kvm_types.h | 2 + include/uapi/linux/kvm.h | 10 ++ virt/kvm/arm/arch_timer.c | 8 +- virt/kvm/arm/arm.c | 49 ++++++++- virt/kvm/arm/hypercalls.c | 71 ++++++++++++ virt/kvm/arm/mmio.c | 9 +- virt/kvm/arm/psci.c | 84 +------------- virt/kvm/arm/pvtime.c | 131 ++++++++++++++++++++++ virt/kvm/arm/vgic/vgic-init.c | 1 + virt/kvm/arm/vgic/vgic-its.c | 3 + virt/kvm/arm/vgic/vgic-v3.c | 12 +- virt/kvm/arm/vgic/vgic-v4.c | 59 +++++----- virt/kvm/arm/vgic/vgic.c | 4 - virt/kvm/arm/vgic/vgic.h | 2 - virt/kvm/kvm_main.c | 6 +- 50 files changed, 968 insertions(+), 225 deletions(-) create mode 100644 Documentation/virt/kvm/arm/pvtime.rst 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
Marc Zyngier
maintainerPATCH 1/22 KVM: arm/arm64: Allow reporting non-ISV data aborts to userspace
From: Christoffer Dall <[email protected]>
For a long time, if a guest accessed memory outside of a memslot using any of the load/store instructions in the architecture which doesn't supply decoding information in the ESR_EL2 (the ISV bit is not set), the kernel would print the following message and terminate the VM as a result of returning -ENOSYS to userspace:
load/store instruction decoding not implemented
The reason behind this message is that KVM assumes that all accesses outside a memslot is an MMIO access which should be handled by userspace, and we originally expected to eventually implement some sort of decoding of load/store instructions where the ISV bit was not set.
However, it turns out that many of the instructions which don't provide decoding information on abort are not safe to use for MMIO accesses, and the remaining few that would potentially make sense to use on MMIO accesses, such as those with register writeback, are not used in practice. It also turns out that fetching an instruction from guest memory can be a pretty horrible affair, involving stopping all CPUs on SMP systems, handling multiple corner cases of address translation in software, and more. It doesn't appear likely that we'll ever implement this in the kernel.
What is much more common is that a user has misconfigured his/her guest and is actually not accessing an MMIO region, but just hitting some random hole in the IPA space. In this scenario, the error message above is almost misleading and has led to a great deal of confusion over the years.
It is, nevertheless, ABI to userspace, and we therefore need to introduce a new capability that userspace explicitly enables to change behavior.
This patch introduces KVM_CAP_ARM_NISV_TO_USER (NISV meaning Non-ISV) which does exactly that, and introduces a new exit reason to report the event to userspace. User space can then emulate an exception to the guest, restart the guest, suspend the guest, or take any other appropriate action as per the policy of the running system.
--- Documentation/virt/kvm/api.txt | 33 ++++++++++++++++++++++++++++ arch/arm/include/asm/kvm_arm.h | 1 + arch/arm/include/asm/kvm_emulate.h | 5 +++++ arch/arm/include/asm/kvm_host.h | 8 +++++++ arch/arm64/include/asm/kvm_emulate.h | 5 +++++ arch/arm64/include/asm/kvm_host.h | 8 +++++++ include/uapi/linux/kvm.h | 7 ++++++ virt/kvm/arm/arm.c | 21 ++++++++++++++++++ virt/kvm/arm/mmio.c | 9 +++++++- 9 files changed, 96 insertions(+), 1 deletion(-)
Documentation/virt/kvm/api.txt +33 -0
@@ -4468,6 +4468,39 @@ Hyper-V SynIC state change. Notification is used to remap SynIC event/message pages and to enable/disable SynIC messages/events processing in userspace. + /* KVM_EXIT_ARM_NISV */ + struct { + __u64 esr_iss; + __u64 fault_ipa; + } arm_nisv; + +Used on arm and arm64 systems. If a guest accesses memory not in a memslot, +KVM will typically return to userspace and ask it to do MMIO emulation on its +behalf. However, for certain classes of instructions, no instruction decode +(direction, length of memory access) is provided, and fetching and decoding +the instruction from the VM is overly complicated to live in the kernel. + +Historically, when this situation occurred, KVM would print a warning and kill +the VM. KVM assumed that if the guest accessed non-memslot memory, it was +trying to do I/O, which just couldn't be emulated, and the warning message was +phrased accordingly. However, what happened more often was that a guest bug +caused access outside the guest memory areas which should lead to a more +meaningful warning message and an external abort in the guest, if the access +did not fall within an I/O window. + +Userspace implementations can query for KVM_CAP_ARM_NISV_TO_USER, and enable +this capability at VM creation. Once this is done, these types of errors will +instead return to userspace with KVM_EXIT_ARM_NISV, with the valid bits from +the HSR (arm) and ESR_EL2 (arm64) in the esr_iss field, and the faulting IPA +in the fault_ipa field. Userspace can either fix up the access if it's +actually an I/O access by decoding the instruction from guest memory (if it's +very brave) and continue executing the guest, or it can decide to suspend, +dump, or restart the guest. + +Note that KVM does not skip the faulting instruction as it does for +KVM_EXIT_MMIO, but userspace has to emulate any change to the processing state +if it decides to decode and emulate the instruction. + /* Fix the size of the union. */ char padding[256]; };
arch/arm/include/asm/kvm_arm.h +1 -0
@@ -162,6 +162,7 @@#define HSR_ISV (_AC(1, UL) << HSR_ISV_SHIFT)#define HSR_SRT_SHIFT (16)#define HSR_SRT_MASK (0xf << HSR_SRT_SHIFT) +#define HSR_CM (1 << 8)#define HSR_FSC (0x3f)#define HSR_FSC_TYPE (0x3c)#define HSR_SSE (1 << 21)
arch/arm/include/asm/kvm_emulate.h +5 -0
@@ -167,6 +167,11 @@ static inline bool kvm_vcpu_dabt_isvalid(struct kvm_vcpu *vcpu)return kvm_vcpu_get_hsr (vcpu) &HSR_ISV ; } +static inline unsigned long kvm_vcpu_dabt_iss_nisv_sanitized (const struct kvm_vcpu *vcpu) +{ +return kvm_vcpu_get_hsr (vcpu) & (HSR_CM |HSR_WNR |HSR_FSC ); +} +static inline bool kvm_vcpu_dabt_iswrite (struct kvm_vcpu *vcpu) {return kvm_vcpu_get_hsr (vcpu) &HSR_WNR ;
arch/arm/include/asm/kvm_host.h +8 -0
@@ -76,6 +76,14 @@ struct kvm_arch {/* Mandated version of PSCI */ u32 psci_version; + +/* +* If we encounter a data abort without valid instruction syndrome +* information, report this to user space. User space can (and +* should) opt in to this feature if KVM_CAP_ARM_NISV_TO_USER is +* supported. +*/ +bool return_nisv_io_abort_to_user; };#define KVM_NR_MEM_OBJS 40
arch/arm64/include/asm/kvm_emulate.h +5 -0
@@ -258,6 +258,11 @@ static inline bool kvm_vcpu_dabt_isvalid(const struct kvm_vcpu *vcpu)return !!(kvm_vcpu_get_hsr (vcpu) & ESR_ELx_ISV); } +static inline unsigned long kvm_vcpu_dabt_iss_nisv_sanitized (const struct kvm_vcpu *vcpu) +{ +return kvm_vcpu_get_hsr (vcpu) & (ESR_ELx_CM | ESR_ELx_WNR | ESR_ELx_FSC); +} +static inline bool kvm_vcpu_dabt_issext (const struct kvm_vcpu *vcpu) {return !!(kvm_vcpu_get_hsr (vcpu) & ESR_ELx_SSE);
arch/arm64/include/asm/kvm_host.h +8 -0
@@ -83,6 +83,14 @@ struct kvm_arch {/* Mandated version of PSCI */ u32 psci_version; + +/* +* If we encounter a data abort without valid instruction syndrome +* information, report this to user space. User space can (and +* should) opt in to this feature if KVM_CAP_ARM_NISV_TO_USER is +* supported. +*/ +bool return_nisv_io_abort_to_user; };#define KVM_NR_MEM_OBJS 40
include/uapi/linux/kvm.h +7 -0
@@ -235,6 +235,7 @@ struct kvm_hyperv_exit {#define KVM_EXIT_S390_STSI 25#define KVM_EXIT_IOAPIC_EOI 26#define KVM_EXIT_HYPERV 27 +#define KVM_EXIT_ARM_NISV 28/* For KVM_EXIT_INTERNAL_ERROR */ /* Emulate instruction failed. */
@@ -394,6 +395,11 @@ struct kvm_run { } eoi;/* KVM_EXIT_HYPERV */ struct kvm_hyperv_exit hyperv; +/* KVM_EXIT_ARM_NISV */ +struct { +__u64 esr_iss; +__u64 fault_ipa; + } arm_nisv;/* Fix the size of the union. */ char padding[256 ]; };
@@ -1000,6 +1006,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_PMU_EVENT_FILTER 173#define KVM_CAP_ARM_IRQ_LINE_LAYOUT_2 174#define KVM_CAP_HYPERV_DIRECT_TLBFLUSH 175 +#define KVM_CAP_ARM_NISV_TO_USER 176#ifdef KVM_CAP_IRQ_ROUTING
virt/kvm/arm/arm.c +21 -0
@@ -98,6 +98,26 @@ int kvm_arch_check_processor_compat(void)return 0 ; } +int kvm_vm_ioctl_enable_cap (struct kvm *kvm, +struct kvm_enable_cap *cap) +{ +int r; + +if (cap->flags) +return -EINVAL ; + +switch (cap->cap) { +case KVM_CAP_ARM_NISV_TO_USER : + r =0 ; + kvm->arch.return_nisv_io_abort_to_user = true; +break ; +default : + r = -EINVAL ; +break ; + } + +return r; +}/** * kvm_arch_init_vm - initializes a VM data structure
@@ -197,6 +217,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_IMMEDIATE_EXIT :case KVM_CAP_VCPU_EVENTS :case KVM_CAP_ARM_IRQ_LINE_LAYOUT_2 : +case KVM_CAP_ARM_NISV_TO_USER : r =1 ;break ;case KVM_CAP_ARM_SET_DEVICE_ADDR :
virt/kvm/arm/mmio.c +8 -1
@@ -167,7 +167,14 @@ int io_mem_abort(struct kvm_vcpu *vcpu, struct kvm_run *run,if (ret)return ret; }else { -kvm_err ("load/store instruction decoding not implemented\n" ); +if (vcpu->kvm->arch.return_nisv_io_abort_to_user) { + run->exit_reason =KVM_EXIT_ARM_NISV ; + run->arm_nisv.esr_iss =kvm_vcpu_dabt_iss_nisv_sanitized (vcpu); + run->arm_nisv.fault_ipa = fault_ipa; +return 0 ; + } + +kvm_pr_unimpl ("Data abort outside memslots with no valid syndrome info\n" );return -ENOSYS ; }
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 2/22 KVM: arm/arm64: Allow user injection of external data aborts
In reply to Marc ZyngierFrom: Christoffer Dall <[email protected]>
In some scenarios, such as buggy guest or incorrect configuration of the VMM and firmware description data, userspace will detect a memory access to a portion of the IPA, which is not mapped to any MMIO region.
For this purpose, the appropriate action is to inject an external abort to the guest. The kernel already has functionality to inject an external abort, but we need to wire up a signal from user space that lets user space tell the kernel to do this.
It turns out, we already have the set event functionality which we can perfectly reuse for this.
--- Documentation/virt/kvm/api.txt | 22 +++++++++++++++++++++- arch/arm/include/uapi/asm/kvm.h | 3 ++- arch/arm/kvm/guest.c | 10 ++++++++++ arch/arm64/include/uapi/asm/kvm.h | 3 ++- arch/arm64/kvm/guest.c | 10 ++++++++++ arch/arm64/kvm/inject_fault.c | 4 ++-- include/uapi/linux/kvm.h | 1 + virt/kvm/arm/arm.c | 1 + 8 files changed, 49 insertions(+), 5 deletions(-)
Documentation/virt/kvm/api.txt +21 -1
@@ -1002,12 +1002,18 @@ Specifying exception.has_esr on a system that does not support it will return -EINVAL. Setting anything other than the lower 24bits of exception.serror_esr will return -EINVAL. +It is not possible to read back a pending external abort (injected via +KVM_SET_VCPU_EVENTS or otherwise) because such an exception is always delivered +directly to the virtual CPU). + + struct kvm_vcpu_events { struct { __u8 serror_pending; __u8 serror_has_esr; + __u8 ext_dabt_pending; /* Align it to 8 bytes */ - __u8 pad[6]; + __u8 pad[5]; __u64 serror_esr; } exception; __u32 reserved[12];
@@ -1051,9 +1057,23 @@ contain a valid state and shall be written into the VCPU. ARM/ARM64: +User space may need to inject several types of events to the guest. + Set the pending SError exception state for this VCPU. It is not possible to 'cancel' an Serror that has been made pending. +If the guest performed an access to I/O memory which could not be handled by +userspace, for example because of missing instruction syndrome decode +information or because there is no device mapped at the accessed IPA, then +userspace can ask the kernel to inject an external abort using the address +from the exiting fault on the VCPU. It is a programming error to set +ext_dabt_pending after an exit which was not either KVM_EXIT_MMIO or +KVM_EXIT_ARM_NISV. This feature is only available if the system supports +KVM_CAP_ARM_INJECT_EXT_DABT. This is a helper which provides commonality in +how userspace reports accesses for the above cases to guests, across different +userspace implementations. Nevertheless, userspace can still emulate all Arm +exceptions by manipulating individual registers using the KVM_SET_ONE_REG API. + See KVM_GET_VCPU_EVENTS for the data structure.
arch/arm/include/uapi/asm/kvm.h +2 -1
@@ -131,8 +131,9 @@ struct kvm_vcpu_events {struct {__u8 serror_pending;__u8 serror_has_esr; +__u8 ext_dabt_pending;/* Align it to 8 bytes */ -__u8 pad[6 ]; +__u8 pad[5 ];__u64 serror_esr; } exception;__u32 reserved[12 ];
arch/arm/kvm/guest.c +10 -0
@@ -255,6 +255,12 @@ int __kvm_arm_vcpu_get_events(struct kvm_vcpu *vcpu, { events->exception.serror_pending = !!(*vcpu_hcr (vcpu) &HCR_VA ); +/* +* We never return a pending ext_dabt here because we deliver it to +* the virtual CPU directly when setting the event and it's no longer +* 'pending' at this point. +*/ +return 0 ; }
@@ -263,12 +269,16 @@ int __kvm_arm_vcpu_set_events(struct kvm_vcpu *vcpu, {bool serror_pending = events->exception.serror_pending;bool has_esr = events->exception.serror_has_esr; +bool ext_dabt_pending = events->exception.ext_dabt_pending;if (serror_pending && has_esr)return -EINVAL ;else if (serror_pending)kvm_inject_vabt (vcpu); +if (ext_dabt_pending) +kvm_inject_dabt (vcpu,kvm_vcpu_get_hfar (vcpu)); +return 0 ; }
arch/arm64/include/uapi/asm/kvm.h +2 -1
@@ -164,8 +164,9 @@ struct kvm_vcpu_events {struct {__u8 serror_pending;__u8 serror_has_esr; +__u8 ext_dabt_pending;/* Align it to 8 bytes */ -__u8 pad[6 ]; +__u8 pad[5 ];__u64 serror_esr; } exception;__u32 reserved[12 ];
arch/arm64/kvm/guest.c +10 -0
@@ -712,6 +712,12 @@ int __kvm_arm_vcpu_get_events(struct kvm_vcpu *vcpu,if (events->exception.serror_pending && events->exception.serror_has_esr) events->exception.serror_esr =vcpu_get_vsesr (vcpu); +/* +* We never return a pending ext_dabt here because we deliver it to +* the virtual CPU directly when setting the event and it's no longer +* 'pending' at this point. +*/ +return 0 ; }
@@ -720,6 +726,7 @@ int __kvm_arm_vcpu_set_events(struct kvm_vcpu *vcpu, {bool serror_pending = events->exception.serror_pending;bool has_esr = events->exception.serror_has_esr; +bool ext_dabt_pending = events->exception.ext_dabt_pending;if (serror_pending && has_esr) {if (!cpus_have_const_cap (ARM64_HAS_RAS_EXTN ))
@@ -733,6 +740,9 @@ int __kvm_arm_vcpu_set_events(struct kvm_vcpu *vcpu,kvm_inject_vabt (vcpu); } +if (ext_dabt_pending) +kvm_inject_dabt (vcpu,kvm_vcpu_get_hfar (vcpu)); +return 0 ; }
arch/arm64/kvm/inject_fault.c +2 -2
@@ -109,7 +109,7 @@ static void inject_undef64(struct kvm_vcpu *vcpu)/** * kvm_inject_dabt - inject a data abort into the guest -* @vcpu: The VCPU to receive the undefined exception +* @vcpu: The VCPU to receive the data abort * @addr: The address to report in the DFAR * * It is assumed that this code is called from the VCPU thread and that the
@@ -125,7 +125,7 @@ void kvm_inject_dabt(struct kvm_vcpu *vcpu, unsigned long addr)/** * kvm_inject_pabt - inject a prefetch abort into the guest -* @vcpu: The VCPU to receive the undefined exception +* @vcpu: The VCPU to receive the prefetch abort * @addr: The address to report in the DFAR * * It is assumed that this code is called from the VCPU thread and that the
include/uapi/linux/kvm.h +1 -0
@@ -1007,6 +1007,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_ARM_IRQ_LINE_LAYOUT_2 174#define KVM_CAP_HYPERV_DIRECT_TLBFLUSH 175#define KVM_CAP_ARM_NISV_TO_USER 176 +#define KVM_CAP_ARM_INJECT_EXT_DABT 177#ifdef KVM_CAP_IRQ_ROUTING
virt/kvm/arm/arm.c +1 -0
@@ -218,6 +218,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_VCPU_EVENTS :case KVM_CAP_ARM_IRQ_LINE_LAYOUT_2 :case KVM_CAP_ARM_NISV_TO_USER : +case KVM_CAP_ARM_INJECT_EXT_DABT : r =1 ;break ;case KVM_CAP_ARM_SET_DEVICE_ADDR :
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 3/22 KVM: arm64: Document PV-time interface
In reply to Marc ZyngierFrom: Steven Price <[email protected]>
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.rst | 80 +++++++++++++++++++++++++ Documentation/virt/kvm/devices/vcpu.txt | 14 +++++ 2 files changed, 94 insertions(+) create mode 100644 Documentation/virt/kvm/arm/pvtime.rst
Documentation/virt/kvm/arm/pvtime.rst new file +80 -0
@@ -0,0 +1,80 @@ +.. SPDX-License-Identifier: GPL-2.0 + +Paravirtualized time support for arm64 +====================================== + +Arm specification DEN0057/A defines 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_TIME_FEATURES: 0xC5000020 +* PV_TIME_ST: 0xC5000021 + +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_TIME_FEATURES + ============= ======== ========== + Function ID: (uint32) 0xC5000020 + PV_call_id: (uint32) The function to query for support. + Currently only PV_TIME_ST is supported. + Return value: (int64) NOT_SUPPORTED (-1) or SUCCESS (0) if the relevant + PV-time feature is supported by the hypervisor. + ============= ======== ========== + +PV_TIME_ST + ============= ======== ========== + Function ID: (uint32) 0xC5000021 + Return value: (int64) IPA of the stolen time data structure for this + VCPU. 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 1.0 | ++-------------+-------------+-------------+----------------------------+ +| 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. | ++-------------+-------------+-------------+----------------------------+ + +All values in the structure are stored little-endian. + +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. + +It is advisable that one or more 64k pages are set aside for the purpose of +these structures and not used for other purposes, this enables the guest to map +the region using 64k pages and avoids conflicting attributes with other memory. + +For the user space interface see Documentation/virt/kvm/devices/vcpu.txt +section "3. GROUP: KVM_ARM_VCPU_PVTIME_CTRL".
Documentation/virt/kvm/devices/vcpu.txt +14 -0
@@ -60,3 +60,17 @@ time to use the number provided for a given timer, overwriting any previously configured values on other VCPUs. Userspace should configure the interrupt numbers on at least one VCPU after creating all VCPUs and before running any VCPUs. + +3. GROUP: KVM_ARM_VCPU_PVTIME_CTRL +Architectures: ARM64 + +3.1 ATTRIBUTE: KVM_ARM_VCPU_PVTIME_IPA +Parameters: 64-bit base address +Returns: -ENXIO: Stolen time not implemented + -EEXIST: Base address already set for this VCPU + -EINVAL: Base address not 64 byte aligned + +Specifies the base address of the stolen time structure for this VCPU. The +base address must be 64 byte aligned and exist within a valid guest memory +region. See Documentation/virt/kvm/arm/pvtime.txt for more information +including the layout of the stolen time structure.
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH 4/22 KVM: arm/arm64: Factor out hypercall handling from PSCI code
In reply to Marc ZyngierFrom: 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/Kbuild | 2 + include/kvm/arm_hypercalls.h | 43 ++++++++++++++++++ include/kvm/arm_psci.h | 2 +- virt/kvm/arm/hypercalls.c | 59 +++++++++++++++++++++++++ virt/kvm/arm/psci.c | 84 +----------------------------------- 9 files changed, 112 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
@@ -24,7 +24,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/Kbuild +2 -0
@@ -67,6 +67,8 @@ header-test- += keys/big_key-type.h header-test- += keys/request_key_auth-type.h header-test- += keys/trusted.h header-test- += kvm/arm_arch_timer.h +header-test-$(CONFIG_ARM) += kvm/arm_hypercalls.h +header-test-$(CONFIG_ARM64) += kvm/arm_hypercalls.h header-test- += kvm/arm_pmu.h header-test-$(CONFIG_ARM) += kvm/arm_psci.h header-test-$(CONFIG_ARM64) += kvm/arm_psci.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 · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH 5/22 KVM: arm64: Implement PV_TIME_FEATURES call
In reply to Marc ZyngierFrom: Steven Price <[email protected]>
This provides a mechanism for querying which paravirtualized time features are available in this hypervisor.
Also add the header file which defines the ABI for the paravirtualized time 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 | 8 +++++++- virt/kvm/arm/pvtime.c | 20 ++++++++++++++++++++ 7 files changed, 67 insertions(+), 1 deletion(-) 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 long 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 ); +long 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
@@ -318,5 +319,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_TIME_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, \ + 0x21) +#endif /*__ASSEMBLY__*/ #endif /*__LINUX_ARM_SMCCC_H*/
virt/kvm/arm/hypercalls.c +7 -1
@@ -12,7 +12,7 @@int kvm_hvc_call_handler (struct kvm_vcpu *vcpu) {u32 func_id =smccc_get_function (vcpu); -u32 val =SMCCC_RET_NOT_SUPPORTED ; +long val =SMCCC_RET_NOT_SUPPORTED ;u32 feature;switch (func_id) {
@@ -48,8 +48,14 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)break ; }break ; +case ARM_SMCCC_HV_PV_TIME_FEATURES : + val =SMCCC_RET_SUCCESS ; +break ; }break ; +case ARM_SMCCC_HV_PV_TIME_FEATURES : + val =kvm_hypercall_pv_features (vcpu); +break ;default :return kvm_psci_call (vcpu); }
virt/kvm/arm/pvtime.c new file +20 -0
@@ -0,0 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (C) 2019 Arm Ltd. + +#include <linux/arm-smccc.h> + +#include <kvm/arm_hypercalls.h> + +long kvm_hypercall_pv_features (struct kvm_vcpu *vcpu) +{ +u32 feature =smccc_get_arg1 (vcpu); +long val =SMCCC_RET_NOT_SUPPORTED ; + +switch (feature) { +case ARM_SMCCC_HV_PV_TIME_FEATURES : + val =SMCCC_RET_SUCCESS ; +break ; + } + +return val; +}
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 6/22 KVM: Implement kvm_put_guest()
In reply to Marc ZyngierFrom: Steven Price <[email protected]>
kvm_put_guest() is analogous to put_user() - it writes a single value to the guest physical address. The implementation is built upon put_user() and so it has the same single copy atomic properties.
--- include/linux/kvm_host.h | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)
include/linux/kvm_host.h +22 -0
@@ -746,6 +746,28 @@ int kvm_write_guest_offset_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc, unsigned long len);int kvm_gfn_to_hva_cache_init (struct kvm *kvm,struct gfn_to_hva_cache *ghc,gpa_t gpa,unsigned long len); + +#define __kvm_put_guest (kvm, gfn, offset, value, type) \ +({ \ + unsigned long __addr = gfn_to_hva(kvm, gfn); \ + type __user *__uaddr = (type __user *)(__addr + offset); \ + int __ret = -EFAULT; \ + \ + if (!kvm_is_error_hva(__addr)) \ + __ret = put_user(value, __uaddr); \ + if (!__ret) \ + mark_page_dirty(kvm, gfn); \ + __ret; \ +}) + +#define kvm_put_guest (kvm, gpa, value, type) \ +({ \ + gpa_t __gpa = gpa; \ + struct kvm *__kvm = kvm; \ + __kvm_put_guest(__kvm, __gpa >> PAGE_SHIFT, \ + offset_in_page(__gpa), (value), type); \ +}) +int kvm_clear_guest_page (struct kvm *kvm,gfn_t gfn,int offset,int len);int kvm_clear_guest (struct kvm *kvm,gpa_t gpa,unsigned long len);struct kvm_memory_slot *gfn_to_memslot (struct kvm *kvm,gfn_t gfn);
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerPATCH 7/22 KVM: arm64: Support stolen time reporting via shared structure
In reply to Marc ZyngierFrom: Steven Price <[email protected]>
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.
User space allocates memory which is placed at an IPA also chosen by user space. The hypervisor then updates the shared structure using kvm_put_guest() to ensure single copy atomicity of the 64-bit value reporting the 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 | 19 +++++++++++ arch/arm64/include/asm/kvm_host.h | 20 ++++++++++++ arch/arm64/kvm/Kconfig | 1 + include/linux/kvm_types.h | 2 ++ virt/kvm/arm/arm.c | 11 +++++++ virt/kvm/arm/hypercalls.c | 6 ++++ virt/kvm/arm/pvtime.c | 52 +++++++++++++++++++++++++++++++ 7 files changed, 111 insertions(+)
arch/arm/include/asm/kvm_host.h +19 -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);
@@ -329,6 +330,24 @@ static inline long kvm_hypercall_pv_features(struct kvm_vcpu *vcpu)return SMCCC_RET_NOT_SUPPORTED ; } +static inline gpa_t kvm_init_stolen_time (struct kvm_vcpu *vcpu) +{ +return GPA_INVALID ; +} + +static inline void kvm_update_stolen_time (struct kvm_vcpu *vcpu) +{ +} + +static inline void kvm_arm_pvtime_vcpu_init (struct kvm_vcpu_arch *vcpu_arch) +{ +} + +static inline bool kvm_arm_is_pvtime_enabled (struct kvm_vcpu_arch *vcpu_arch) +{ +return false; +} +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 +20 -0
@@ -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);
@@ -338,6 +339,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; +gpa_t base; + } steal; };/* Pointer to the vcpu's SVE FFR for sve_{save,load}_state() */
@@ -479,6 +487,18 @@ int kvm_perf_init(void);int kvm_perf_teardown (void );long kvm_hypercall_pv_features (struct kvm_vcpu *vcpu); +gpa_t kvm_init_stolen_time (struct kvm_vcpu *vcpu); +void kvm_update_stolen_time (struct kvm_vcpu *vcpu); + +static inline void kvm_arm_pvtime_vcpu_init (struct kvm_vcpu_arch *vcpu_arch) +{ + vcpu_arch->steal.base =GPA_INVALID ; +} + +static inline bool kvm_arm_is_pvtime_enabled (struct kvm_vcpu_arch *vcpu_arch) +{ +return (vcpu_arch->steal.base !=GPA_INVALID ); +}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 +11 -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
@@ -351,6 +355,8 @@ int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)kvm_arm_reset_debug_ptr (vcpu); +kvm_arm_pvtime_vcpu_init (&vcpu->arch); +return kvm_vgic_vcpu_init (vcpu); }
@@ -380,6 +386,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 (kvm_arm_is_pvtime_enabled (&vcpu->arch)) +kvm_make_request (KVM_REQ_RECORD_STEAL , vcpu);if (single_task_running ())vcpu_clear_wfe_traps (vcpu);
@@ -645,6 +653,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)) +kvm_update_stolen_time (vcpu); } }
virt/kvm/arm/hypercalls.c +6 -0
@@ -14,6 +14,7 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)u32 func_id =smccc_get_function (vcpu);long val =SMCCC_RET_NOT_SUPPORTED ;u32 feature; +gpa_t gpa;switch (func_id) {case ARM_SMCCC_VERSION_FUNC_ID :
@@ -56,6 +57,11 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)case ARM_SMCCC_HV_PV_TIME_FEATURES : val =kvm_hypercall_pv_features (vcpu);break ; +case ARM_SMCCC_HV_PV_TIME_ST : + gpa =kvm_init_stolen_time (vcpu); +if (gpa !=GPA_INVALID ) + val = gpa; +break ;default :return kvm_psci_call (vcpu); }
virt/kvm/arm/pvtime.c +52 -0
69 lines not on this page · raw message
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 8/22 KVM: Allow kvm_device_ops to be const
In reply to Marc ZyngierFrom: Steven Price <[email protected]>
Currently 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
@@ -1262,7 +1262,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;
@@ -1315,7 +1315,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 · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 9/22 KVM: arm64: Provide VCPU attributes for stolen time
In reply to Marc ZyngierFrom: Steven Price <[email protected]>
Allow user space to inform the KVM host where in the physical memory map the paravirtualized time structures should be located.
User space can set an attribute on the VCPU providing the IPA base address of the stolen time structure for that VCPU. This must be repeated for every VCPU in the VM.
The address is given in terms of the physical address visible to the guest and must be 64 byte aligned. The guest will discover the address via a hypercall.
--- arch/arm64/include/asm/kvm_host.h | 7 ++++ arch/arm64/include/uapi/asm/kvm.h | 2 ++ arch/arm64/kvm/guest.c | 9 +++++ include/uapi/linux/kvm.h | 2 ++ virt/kvm/arm/pvtime.c | 59 +++++++++++++++++++++++++++++++ 5 files changed, 79 insertions(+)
arch/arm64/include/asm/kvm_host.h +7 -0
@@ -490,6 +490,13 @@ long kvm_hypercall_pv_features(struct kvm_vcpu *vcpu);gpa_t kvm_init_stolen_time (struct kvm_vcpu *vcpu);void kvm_update_stolen_time (struct kvm_vcpu *vcpu); +int kvm_arm_pvtime_set_attr (struct kvm_vcpu *vcpu, +struct kvm_device_attr *attr); +int kvm_arm_pvtime_get_attr (struct kvm_vcpu *vcpu, +struct kvm_device_attr *attr); +int kvm_arm_pvtime_has_attr (struct kvm_vcpu *vcpu, +struct kvm_device_attr *attr); +static inline void kvm_arm_pvtime_vcpu_init (struct kvm_vcpu_arch *vcpu_arch) { vcpu_arch->steal.base =GPA_INVALID ;
arch/arm64/include/uapi/asm/kvm.h +2 -0
@@ -323,6 +323,8 @@ struct kvm_vcpu_events {#define KVM_ARM_VCPU_TIMER_CTRL 1#define KVM_ARM_VCPU_TIMER_IRQ_VTIMER 0#define KVM_ARM_VCPU_TIMER_IRQ_PTIMER 1 +#define KVM_ARM_VCPU_PVTIME_CTRL 2 +#define KVM_ARM_VCPU_PVTIME_IPA 0/* KVM_IRQ_LINE irq field index values */ #define KVM_ARM_IRQ_VCPU2_SHIFT 28
arch/arm64/kvm/guest.c +9 -0
@@ -858,6 +858,9 @@ int kvm_arm_vcpu_arch_set_attr(struct kvm_vcpu *vcpu,case KVM_ARM_VCPU_TIMER_CTRL : ret =kvm_arm_timer_set_attr (vcpu, attr);break ; +case KVM_ARM_VCPU_PVTIME_CTRL : + ret =kvm_arm_pvtime_set_attr (vcpu, attr); +break ;default : ret = -ENXIO ;break ;
@@ -878,6 +881,9 @@ int kvm_arm_vcpu_arch_get_attr(struct kvm_vcpu *vcpu,case KVM_ARM_VCPU_TIMER_CTRL : ret =kvm_arm_timer_get_attr (vcpu, attr);break ; +case KVM_ARM_VCPU_PVTIME_CTRL : + ret =kvm_arm_pvtime_get_attr (vcpu, attr); +break ;default : ret = -ENXIO ;break ;
@@ -898,6 +904,9 @@ int kvm_arm_vcpu_arch_has_attr(struct kvm_vcpu *vcpu,case KVM_ARM_VCPU_TIMER_CTRL : ret =kvm_arm_timer_has_attr (vcpu, attr);break ; +case KVM_ARM_VCPU_PVTIME_CTRL : + ret =kvm_arm_pvtime_has_attr (vcpu, attr); +break ;default : ret = -ENXIO ;break ;
include/uapi/linux/kvm.h +2 -0
@@ -1227,6 +1227,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/pvtime.c +59 -0
69 lines not on this page · raw message
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 10/22 arm/arm64: Provide a wrapper for SMCCC 1.1 calls
In reply to Marc ZyngierFrom: Steven Price <[email protected]>
SMCCC 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 conduit is configured/available 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 | 45 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+)
include/linux/arm-smccc.h +45 -0
@@ -319,6 +319,51 @@ 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 SMCCC 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 SMCCC 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 = arm_smccc_1_1_get_conduit(); \ + switch (method) { \ + case SMCCC_CONDUIT_HVC: \ + arm_smccc_1_1_hvc(__VA_ARGS__); \ + break; \ + case SMCCC_CONDUIT_SMC: \ + arm_smccc_1_1_smc(__VA_ARGS__); \ + break; \ + default: \ + __fail_smccc_1_1(__VA_ARGS__); \ + method = SMCCC_CONDUIT_NONE; \ + break; \ + } \ + method; \ + }) +/* Paravirtualised time calls (defined by ARM DEN0057A) */ #define ARM_SMCCC_HV_PV_TIME_FEATURES \ ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 11/22 arm/arm64: Make use of the SMCCC 1.1 wrapper
In reply to Marc ZyngierFrom: Steven Price <[email protected]>
Rather 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 | 81 ++++++++++++---------------------- 2 files changed, 34 insertions(+), 60 deletions(-)
arch/arm/mm/proc-v7-bugs.c +5 -8
@@ -74,12 +74,13 @@ static void cpu_v7_spectre_init(void)case ARM_CPU_PART_CORTEX_A72 : {struct arm_smccc_res res; +arm_smccc_1_1_invoke (ARM_SMCCC_ARCH_FEATURES_FUNC_ID , +ARM_SMCCC_ARCH_WORKAROUND_1 , &res); +if ((int )res.a0 !=0 ) +return ; +switch (arm_smccc_1_1_get_conduit ()) {case SMCCC_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;
@@ -87,10 +88,6 @@ static void cpu_v7_spectre_init(void)break ;case SMCCC_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 +29 -52
118 lines not on this page · raw message
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 12/22 arm64: Retrieve stolen time as paravirtualized guest
In reply to Marc ZyngierFrom: Steven Price <[email protected]>
Enable 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.
--- .../admin-guide/kernel-parameters.txt | 6 +- arch/arm64/include/asm/paravirt.h | 9 +- arch/arm64/kernel/paravirt.c | 140 ++++++++++++++++++ arch/arm64/kernel/time.c | 3 + include/linux/cpuhotplug.h | 1 + 5 files changed, 155 insertions(+), 4 deletions(-)
Documentation/admin-guide/kernel-parameters.txt +3 -3
@@ -3083,9 +3083,9 @@ [X86,PV_OPS] Disable paravirtualized VMware scheduler clock and use the default one. - no-steal-acc [X86,KVM] Disable paravirtualized steal time accounting. - steal time is computed, but won't influence scheduler - behaviour + no-steal-acc [X86,KVM,ARM64] Disable paravirtualized steal time + accounting. steal time is computed, but won't + influence scheduler behaviour nolapic [X86-32,APIC] Do not enable or use the local APIC.
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 pv_time_init (void ); + +#else + +#define pv_time_init () do {} while (0) + +#endif // CONFIG_PARAVIRT #endif
arch/arm64/kernel/paravirt.c +140 -0
153 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 ; + +pv_time_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 · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 13/22 KVM: arm64: Select TASK_DELAY_ACCT+TASKSTATS rather than SCHEDSTATS
In reply to Marc ZyngierFrom: Steven Price <[email protected]>
SCHEDSTATS requires DEBUG_KERNEL (and PROC_FS) and therefore isn't a good choice for enabling the scheduling statistics required for stolen time.
Instead match the x86 configuration and select TASK_DELAY_ACCT and TASKSTATS. This adds the dependencies of NET && MULTIUSER for arm64 KVM.
--- arch/arm64/kvm/Kconfig | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
arch/arm64/kvm/Kconfig +4 -1
@@ -21,6 +21,8 @@ if VIRTUALIZATION config KVM bool "Kernel-based Virtual Machine (KVM) support" depends on OF + # for TASKSTATS/TASK_DELAY_ACCT: + depends on NET && MULTIUSER select MMU_NOTIFIER select PREEMPT_NOTIFIERS select HAVE_KVM_CPU_RELAX_INTERCEPT
@@ -39,7 +41,8 @@ config KVM select IRQ_BYPASS_MANAGER select HAVE_KVM_IRQ_BYPASS select HAVE_KVM_VCPU_RUN_PID_CHANGE - select SCHEDSTATS + select TASKSTATS + select TASK_DELAY_ACCT ---help--- Support hosting virtualized guest machines. We don't support KVM with 16K page tables yet, due to the multiple
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 14/22 KVM: arm/arm64: Show halt poll counters in debugfs
In reply to Marc ZyngierFrom: Christian Borntraeger <[email protected]>
ARM/ARM64 has counters halt_successful_poll, halt_attempted_poll, halt_poll_invalid, and halt_wakeup but never exposed those in debugfs.
--- arch/arm/kvm/guest.c | 4 ++++ arch/arm64/kvm/guest.c | 4 ++++ 2 files changed, 8 insertions(+)
arch/arm/kvm/guest.c +4 -0
@@ -21,6 +21,10 @@#define VCPU_STAT (x) { #x, offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU }struct kvm_stats_debugfs_item debugfs_entries[] = { +VCPU_STAT (halt_successful_poll), +VCPU_STAT (halt_attempted_poll), +VCPU_STAT (halt_poll_invalid), +VCPU_STAT (halt_wakeup),VCPU_STAT (hvc_exit_stat),VCPU_STAT (wfe_exit_stat),VCPU_STAT (wfi_exit_stat),
arch/arm64/kvm/guest.c +4 -0
@@ -34,6 +34,10 @@#define VCPU_STAT (x) { #x, offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU }struct kvm_stats_debugfs_item debugfs_entries[] = { +VCPU_STAT (halt_successful_poll), +VCPU_STAT (halt_attempted_poll), +VCPU_STAT (halt_poll_invalid), +VCPU_STAT (halt_wakeup),VCPU_STAT (hvc_exit_stat),VCPU_STAT (wfe_exit_stat),VCPU_STAT (wfi_exit_stat),
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 15/22 KVM: arm64: Don't set HCR_EL2.TVM when S2FWB is supported
In reply to Marc ZyngierFrom: Christoffer Dall <[email protected]>
On CPUs that support S2FWB (Armv8.4+), KVM configures the stage 2 page tables to override the memory attributes of memory accesses, regardless of the stage 1 page table configurations, and also when the stage 1 MMU is turned off. This results in all memory accesses to RAM being cacheable, including during early boot of the guest.
On CPUs without this feature, memory accesses were non-cacheable during boot until the guest turned on the stage 1 MMU, and we had to detect when the guest turned on the MMU, such that we could invalidate all cache entries and ensure a consistent view of memory with the MMU turned on. When the guest turned on the caches, we would call stage2_flush_vm() from kvm_toggle_cache().
However, stage2_flush_vm() walks all the stage 2 tables, and calls __kvm_flush-dcache_pte, which on a system with S2FWB does ... absolutely nothing.
We can avoid that whole song and dance, and simply not set TVM when creating a VM on a system that has S2FWB.
--- arch/arm64/include/asm/kvm_arm.h | 3 +-- arch/arm64/include/asm/kvm_emulate.h | 12 +++++++++++- 2 files changed, 12 insertions(+), 3 deletions(-)
arch/arm64/include/asm/kvm_arm.h +1 -2
@@ -61,7 +61,6 @@* RW: 64bit by default, can be overridden for 32bit VMs * TAC: Trap ACTLR * TSC: Trap SMC -* TVM: Trap VM ops (until M+C set in SCTLR_EL1) * TSW: Trap cache operations by set/way * TWE: Trap WFE * TWI: Trap WFI
@@ -74,7 +73,7 @@* SWIO: Turn set/way invalidates into set/way clean+invalidate */ #define HCR_GUEST_FLAGS (HCR_TSC | HCR_TSW | HCR_TWE | HCR_TWI | HCR_VM | \ - HCR_TVM | HCR_BSU_IS | HCR_FB | HCR_TAC | \ + HCR_BSU_IS | HCR_FB | HCR_TAC | \ HCR_AMO | HCR_SWIO | HCR_TIDCP | HCR_RW | HCR_TLOR | \ HCR_FMO | HCR_IMO)#define HCR_VIRT_EXCP_MASK (HCR_VSE | HCR_VI | HCR_VF)
arch/arm64/include/asm/kvm_emulate.h +11 -1
@@ -53,8 +53,18 @@ static inline void vcpu_reset_hcr(struct kvm_vcpu *vcpu)/* trap error record accesses */ vcpu->arch.hcr_el2 |=HCR_TERR ; } -if (cpus_have_const_cap (ARM64_HAS_STAGE2_FWB )) + +if (cpus_have_const_cap (ARM64_HAS_STAGE2_FWB )) { vcpu->arch.hcr_el2 |=HCR_FWB ; + }else { +/* +* For non-FWB CPUs, we trap VM ops (HCR_EL2.TVM) until M+C +* get set in SCTLR_EL1 such that we can detect when the guest +* MMU gets turned on and do the necessary cache maintenance +* then. +*/ + vcpu->arch.hcr_el2 |=HCR_TVM ; + }if (test_bit (KVM_ARM_VCPU_EL1_32BIT , vcpu->arch.features)) vcpu->arch.hcr_el2 &= ~HCR_RW ;
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 16/22 KVM: arm64: vgic-v4: Move the GICv4 residency flow to be driven by vcpu_load/put
In reply to Marc ZyngierWhen the VHE code was reworked, a lot of the vgic stuff was moved around, but the GICv4 residency code did stay untouched, meaning that we come in and out of residency on each flush/sync, which is obviously suboptimal.
To address this, let's move things around a bit:
- Residency entry (flush) moves to vcpu_load
- Residency exit (sync) moves to vcpu_put
- On blocking (entry to WFI), we "put"
- On unblocking (exit from WFI), we "load"
Because these can nest (load/block/put/load/unblock/put, for example), we now have per-VPE tracking of the residency state.
Additionally, vgic_v4_put gains a "need doorbell" parameter, which only gets set to true when blocking because of a WFI. This allows a finer control of the doorbell, which now also gets disabled as soon as it gets signaled.
--- drivers/irqchip/irq-gic-v4.c | 7 +++- include/kvm/arm_vgic.h | 4 +-- include/linux/irqchip/arm-gic-v4.h | 2 ++ virt/kvm/arm/arm.c | 12 ++++--- virt/kvm/arm/vgic/vgic-v3.c | 4 +++ virt/kvm/arm/vgic/vgic-v4.c | 55 ++++++++++++++---------------- virt/kvm/arm/vgic/vgic.c | 4 --- virt/kvm/arm/vgic/vgic.h | 2 -- 8 files changed, 48 insertions(+), 42 deletions(-)
drivers/irqchip/irq-gic-v4.c +6 -1
@@ -141,12 +141,17 @@ static int its_send_vpe_cmd(struct its_vpe *vpe, struct its_cmd_info *info)int its_schedule_vpe (struct its_vpe *vpe,bool on) {struct its_cmd_info info; +int ret;WARN_ON (preemptible ()); info.cmd_type = on ?SCHEDULE_VPE :DESCHEDULE_VPE ; -return its_send_vpe_cmd (vpe, &info); + ret =its_send_vpe_cmd (vpe, &info); +if (!ret) + vpe->resident = on; + +return ret; }int its_invall_vpe (struct its_vpe *vpe)
include/kvm/arm_vgic.h +2 -2
@@ -396,7 +396,7 @@ int kvm_vgic_v4_set_forwarding(struct kvm *kvm, int irq,int kvm_vgic_v4_unset_forwarding (struct kvm *kvm,int irq,struct kvm_kernel_irq_routing_entry *irq_entry); -void kvm_vgic_v4_enable_doorbell (struct kvm_vcpu *vcpu); -void kvm_vgic_v4_disable_doorbell (struct kvm_vcpu *vcpu); +int vgic_v4_load (struct kvm_vcpu *vcpu); +int vgic_v4_put (struct kvm_vcpu *vcpu,bool need_db);#endif /* __KVM_ARM_VGIC_H */
include/linux/irqchip/arm-gic-v4.h +2 -0
@@ -35,6 +35,8 @@ struct its_vpe {/* Doorbell interrupt */ int irq;irq_hw_number_t vpe_db_lpi; +/* VPE resident */ +bool resident;/* VPE proxy mapping */ int vpe_proxy_event;/*
virt/kvm/arm/arm.c +8 -4
@@ -322,20 +322,24 @@ void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu)/* * If we're about to block (most likely because we've just hit a * WFI), we need to sync back the state of the GIC CPU interface -* so that we have the lastest PMR and group enables. This ensures +* so that we have the latest PMR and group enables. This ensures * that kvm_arch_vcpu_runnable has up-to-date data to decide * whether we have pending interrupts. +* +* For the same reason, we want to tell GICv4 that we need +* doorbells to be signalled, should an interrupt become pending. */ preempt_disable ();kvm_vgic_vmcr_sync (vcpu); +vgic_v4_put (vcpu, true);preempt_enable (); - -kvm_vgic_v4_enable_doorbell (vcpu); }void kvm_arch_vcpu_unblocking (struct kvm_vcpu *vcpu) { -kvm_vgic_v4_disable_doorbell (vcpu); +preempt_disable (); +vgic_v4_load (vcpu); +preempt_enable (); }int kvm_arch_vcpu_init (struct kvm_vcpu *vcpu)
virt/kvm/arm/vgic/vgic-v3.c +4 -0
@@ -664,6 +664,8 @@ void vgic_v3_load(struct kvm_vcpu *vcpu)if (has_vhe ())__vgic_v3_activate_traps (vcpu); + +WARN_ON (vgic_v4_load (vcpu)); }void vgic_v3_vmcr_sync (struct kvm_vcpu *vcpu)
@@ -676,6 +678,8 @@ void vgic_v3_vmcr_sync(struct kvm_vcpu *vcpu)void vgic_v3_put (struct kvm_vcpu *vcpu) { +WARN_ON (vgic_v4_put (vcpu, false)); +vgic_v3_vmcr_sync (vcpu);kvm_call_hyp (__vgic_v3_save_aprs, vcpu);
virt/kvm/arm/vgic/vgic-v4.c +26 -29
93 lines not on this page · raw message
virt/kvm/arm/vgic/vgic.c +0 -4
@@ -857,8 +857,6 @@ void kvm_vgic_sync_hwstate(struct kvm_vcpu *vcpu) {struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu; -WARN_ON (vgic_v4_sync_hwstate (vcpu)); -/* An empty ap_list_head implies used_lrs == 0 */ if (list_empty (&vcpu->arch.vgic_cpu.ap_list_head))return ;
@@ -882,8 +880,6 @@ static inline void vgic_restore_state(struct kvm_vcpu *vcpu)/* Flush our emulation state into the GIC hardware before entering the guest. */ void kvm_vgic_flush_hwstate (struct kvm_vcpu *vcpu) { -WARN_ON (vgic_v4_flush_hwstate (vcpu)); -/* * If there are no virtual interrupts active or pending for this * VCPU, then there is no work to do and we can bail out without
virt/kvm/arm/vgic/vgic.h +0 -2
@@ -316,7 +316,5 @@ void vgic_its_invalidate_cache(struct kvm *kvm);bool vgic_supports_direct_msis (struct kvm *kvm);int vgic_v4_init (struct kvm *kvm);void vgic_v4_teardown (struct kvm *kvm); -int vgic_v4_sync_hwstate (struct kvm_vcpu *vcpu); -int vgic_v4_flush_hwstate (struct kvm_vcpu *vcpu);#endif
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 17/22 KVM: arm/arm64: vgic: Remove the declaration of kvm_send_userspace_msi()
In reply to Marc ZyngierFrom: Zenghui Yu <[email protected]>
The callsite of kvm_send_userspace_msi() is currently arch agnostic. There seems no reason to keep an extra declaration of it in arm_vgic.h (we already have one in include/linux/kvm_host.h).
Remove it.
--- include/kvm/arm_vgic.h | 2 -- 1 file changed, 2 deletions(-)
include/kvm/arm_vgic.h +0 -2
@@ -378,8 +378,6 @@ static inline int kvm_vgic_get_max_vcpus(void)return kvm_vgic_global_state.max_gic_vcpus; } -int kvm_send_userspace_msi (struct kvm *kvm,struct kvm_msi *msi); -/** * kvm_vgic_setup_default_irq_routing: * Setup a default flat gsi routing table mapping all SPIs
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 18/22 KVM: arm/arm64: vgic: Fix some comments typo
In reply to Marc ZyngierFrom: Zenghui Yu <[email protected]>
Fix various comments, including wrong function names, grammar mistakes and specification references.
--- include/kvm/arm_vgic.h | 2 +- virt/kvm/arm/vgic/vgic-v3.c | 2 +- virt/kvm/arm/vgic/vgic-v4.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-)
include/kvm/arm_vgic.h +1 -1
@@ -240,7 +240,7 @@ struct vgic_dist {* Contains the attributes and gpa of the LPI configuration table. * Since we report GICR_TYPER.CommonLPIAff as 0b00, we can share * one address across all redistributors. -* GICv3 spec: 6.1.2 "LPI Configuration tables" +* GICv3 spec: IHI 0069E 6.1.1 "LPI Configuration tables" */ u64 propbaser;
virt/kvm/arm/vgic/vgic-v3.c +1 -1
@@ -357,7 +357,7 @@ int vgic_v3_lpi_sync_pending_status(struct kvm *kvm, struct vgic_irq *irq) }/** -* vgic_its_save_pending_tables - Save the pending tables into guest RAM +* vgic_v3_save_pending_tables - Save the pending tables into guest RAM * kvm lock and all vcpu lock must be held */ int vgic_v3_save_pending_tables (struct kvm *kvm)
virt/kvm/arm/vgic/vgic-v4.c +1 -1
@@ -281,7 +281,7 @@ int kvm_vgic_v4_set_forwarding(struct kvm *kvm, int virq,mutex_lock (&its->its_lock); -/* Perform then actual DevID/EventID -> LPI translation. */ +/* Perform the actual DevID/EventID -> LPI translation. */ ret =vgic_its_resolve_lpi (kvm, its, irq_entry->msi.devid, irq_entry->msi.data, &irq);if (ret)
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 19/22 KVM: arm/arm64: vgic: Don't rely on the wrong pending table
In reply to Marc ZyngierFrom: Zenghui Yu <[email protected]>
It's possible that two LPIs locate in the same "byte_offset" but target two different vcpus, where their pending status are indicated by two different pending tables. In such a scenario, using last_byte_offset optimization will lead KVM relying on the wrong pending table entry. Let us use last_ptr instead, which can be treated as a byte index into a pending table and also, can be vcpu specific.
--- virt/kvm/arm/vgic/vgic-v3.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
virt/kvm/arm/vgic/vgic-v3.c +3 -3
@@ -363,8 +363,8 @@ int vgic_v3_lpi_sync_pending_status(struct kvm *kvm, struct vgic_irq *irq)int vgic_v3_save_pending_tables (struct kvm *kvm) {struct vgic_dist *dist = &kvm->arch.vgic; -int last_byte_offset =-1 ;struct vgic_irq *irq; +gpa_t last_ptr = ~(gpa_t )0 ;int ret;u8 val;
@@ -384,11 +384,11 @@ int vgic_v3_save_pending_tables(struct kvm *kvm) bit_nr = irq->intid %BITS_PER_BYTE ; ptr = pendbase + byte_offset; -if (byte_offset != last_byte_offset) { +if (ptr != last_ptr) { ret =kvm_read_guest_lock (kvm, ptr, &val,1 );if (ret)return ret; - last_byte_offset = byte_offset; + last_ptr = ptr; } stored = val & (1U << bit_nr);
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 20/22 KVM: arm/arm64: Let the timer expire in hardirq context on RT
In reply to Marc ZyngierFrom: Thomas Gleixner <[email protected]>
The timers are canceled from an preempt-notifier which is invoked with disabled preemption which is not allowed on PREEMPT_RT.
The timer callback is short so in could be invoked in hard-IRQ context on -RT.
Let the timer expire on hard-IRQ context even on -RT.
--- virt/kvm/arm/arch_timer.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
virt/kvm/arm/arch_timer.c +4 -4
@@ -80,7 +80,7 @@ static inline bool userspace_irqchip(struct kvm *kvm)static void soft_timer_start (struct hrtimer *hrt,u64 ns) {hrtimer_start (hrt,ktime_add_ns (ktime_get (), ns), -HRTIMER_MODE_ABS ); +HRTIMER_MODE_ABS_HARD ); }static void soft_timer_cancel (struct hrtimer *hrt)
@@ -697,11 +697,11 @@ void kvm_timer_vcpu_init(struct kvm_vcpu *vcpu)update_vtimer_cntvoff (vcpu,kvm_phys_timer_read ()); ptimer->cntvoff =0 ; -hrtimer_init (&timer->bg_timer,CLOCK_MONOTONIC ,HRTIMER_MODE_ABS ); +hrtimer_init (&timer->bg_timer,CLOCK_MONOTONIC ,HRTIMER_MODE_ABS_HARD ); timer->bg_timer.function = kvm_bg_timer_expire; -hrtimer_init (&vtimer->hrtimer,CLOCK_MONOTONIC ,HRTIMER_MODE_ABS ); -hrtimer_init (&ptimer->hrtimer,CLOCK_MONOTONIC ,HRTIMER_MODE_ABS ); +hrtimer_init (&vtimer->hrtimer,CLOCK_MONOTONIC ,HRTIMER_MODE_ABS_HARD ); +hrtimer_init (&ptimer->hrtimer,CLOCK_MONOTONIC ,HRTIMER_MODE_ABS_HARD ); vtimer->hrtimer.function = kvm_hrtimer_expire; ptimer->hrtimer.function = kvm_hrtimer_expire;
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 21/22 KVM: vgic-v4: Track the number of VLPIs per vcpu
In reply to Marc ZyngierIn order to find out whether a vcpu is likely to be the target of VLPIs (and to further optimize the way we deal with those), let's track the number of VLPIs a vcpu can receive.
This gets implemented with an atomic variable that gets incremented or decremented on map, unmap and move of a VLPI.
--- include/linux/irqchip/arm-gic-v4.h | 2 ++ virt/kvm/arm/vgic/vgic-init.c | 1 + virt/kvm/arm/vgic/vgic-its.c | 3 +++ virt/kvm/arm/vgic/vgic-v4.c | 2 ++ 4 files changed, 8 insertions(+)
include/linux/irqchip/arm-gic-v4.h +2 -0
@@ -32,6 +32,8 @@ struct its_vm {struct its_vpe {struct page *vpt_page;struct its_vm *its_vm; +/* per-vPE VLPI tracking */ +atomic_t vlpi_count;/* Doorbell interrupt */ int irq;irq_hw_number_t vpe_db_lpi;
virt/kvm/arm/vgic/vgic-init.c +1 -0
@@ -203,6 +203,7 @@ int kvm_vgic_vcpu_init(struct kvm_vcpu *vcpu)INIT_LIST_HEAD (&vgic_cpu->ap_list_head);raw_spin_lock_init (&vgic_cpu->ap_list_lock); +atomic_set (&vgic_cpu->vgic_v3.its_vpe.vlpi_count,0 );/* * Enable and configure all SGIs to be edge-triggered and
virt/kvm/arm/vgic/vgic-its.c +3 -0
@@ -360,7 +360,10 @@ static int update_affinity(struct vgic_irq *irq, struct kvm_vcpu *vcpu)if (ret)return ret; +if (map.vpe) +atomic_dec (&map.vpe->vlpi_count); map.vpe = &vcpu->arch.vgic_cpu.vgic_v3.its_vpe; +atomic_inc (&map.vpe->vlpi_count); ret =its_map_vlpi (irq->host_irq, &map); }
virt/kvm/arm/vgic/vgic-v4.c +2 -0
@@ -309,6 +309,7 @@ int kvm_vgic_v4_set_forwarding(struct kvm *kvm, int virq, irq->hw = true; irq->host_irq = virq; +atomic_inc (&map.vpe->vlpi_count); out:mutex_unlock (&its->its_lock);
@@ -342,6 +343,7 @@ int kvm_vgic_v4_unset_forwarding(struct kvm *kvm, int virq,WARN_ON (!(irq->hw && irq->host_irq == virq));if (irq->hw) { +atomic_dec (&irq->target_vcpu->arch.vgic_cpu.vgic_v3.its_vpe.vlpi_count); irq->hw = false; ret =its_unmap_vlpi (virq); }
Signature · 1 line
2.20.1
Marc Zyngier
maintainerPATCH 22/22 KVM: arm64: Opportunistically turn off WFI trapping when using direct LPI injection
In reply to Marc ZyngierJust like we do for WFE trapping, it can be useful to turn off WFI trapping when the physical CPU is not oversubscribed (that is, the vcpu is the only runnable process on this CPU) *and* that we're using direct injection of interrupts.
The conditions are reevaluated on each vcpu_load(), ensuring that we don't switch to this mode on a busy system.
On a GICv4 system, this has the effect of reducing the generation of doorbell interrupts to zero when the right conditions are met, which is a huge improvement over the current situation (where the doorbells are screaming if the CPU ever hits a blocking WFI).
--- arch/arm/include/asm/kvm_emulate.h | 4 ++-- arch/arm64/include/asm/kvm_emulate.h | 9 +++++++-- virt/kvm/arm/arm.c | 4 ++-- 3 files changed, 11 insertions(+), 6 deletions(-)
arch/arm/include/asm/kvm_emulate.h +2 -2
@@ -95,12 +95,12 @@ static inline unsigned long *vcpu_hcr(const struct kvm_vcpu *vcpu)return (unsigned long *)&vcpu->arch.hcr; } -static inline void vcpu_clear_wfe_traps (struct kvm_vcpu *vcpu) +static inline void vcpu_clear_wfx_traps (struct kvm_vcpu *vcpu) { vcpu->arch.hcr &= ~HCR_TWE ; } -static inline void vcpu_set_wfe_traps (struct kvm_vcpu *vcpu) +static inline void vcpu_set_wfx_traps (struct kvm_vcpu *vcpu) { vcpu->arch.hcr |=HCR_TWE ; }
arch/arm64/include/asm/kvm_emulate.h +7 -2
@@ -87,14 +87,19 @@ static inline unsigned long *vcpu_hcr(struct kvm_vcpu *vcpu)return (unsigned long *)&vcpu->arch.hcr_el2; } -static inline void vcpu_clear_wfe_traps (struct kvm_vcpu *vcpu) +static inline void vcpu_clear_wfx_traps (struct kvm_vcpu *vcpu) { vcpu->arch.hcr_el2 &= ~HCR_TWE ; +if (atomic_read (&vcpu->arch.vgic_cpu.vgic_v3.its_vpe.vlpi_count)) + vcpu->arch.hcr_el2 &= ~HCR_TWI ; +else + vcpu->arch.hcr_el2 |=HCR_TWI ; } -static inline void vcpu_set_wfe_traps (struct kvm_vcpu *vcpu) +static inline void vcpu_set_wfx_traps (struct kvm_vcpu *vcpu) { vcpu->arch.hcr_el2 |=HCR_TWE ; + vcpu->arch.hcr_el2 |=HCR_TWI ; }static inline void vcpu_ptrauth_enable (struct kvm_vcpu *vcpu)
virt/kvm/arm/arm.c +2 -2
@@ -386,9 +386,9 @@ void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)kvm_vcpu_pmu_restore_guest (vcpu);if (single_task_running ()) -vcpu_clear_wfe_traps (vcpu); +vcpu_clear_wfx_traps (vcpu);else -vcpu_set_wfe_traps (vcpu); +vcpu_set_wfx_traps (vcpu);vcpu_ptrauth_setup_lazy (vcpu); }
Signature · 1 line
2.20.1
Paolo Bonzini
maintainerQuoted 7 lines · Marc Zyngier
Paolo, Radim,
Here's the bulk of KVM/arm updates for 5.5. On the menu, two new features:
- Stolen time is finally exposed to guests. Yay!
- We can report (and potentially emulate) instructions that KVM cannot handle in kernel space to userspace. Yay again!
Quoted 7 lines
Apart from that, a fairly mundane bag of perf optimization, cleanup and bug fixes.
Note that this series is based on a shared branch with the arm64 tree, avoiding a potential delicate merge.
Please pull,
Pulled, thanks. Note that the new capabilities had a conflict and were bumped by one.
Paolo
_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Marc Zyngier
maintainerQuoted 12 lines · Paolo Bonzini
Quoted 11 lines · Marc Zyngier
Paolo, Radim,
Here's the bulk of KVM/arm updates for 5.5. On the menu, two new features:
- Stolen time is finally exposed to guests. Yay!
- We can report (and potentially emulate) instructions that KVM cannot
handle in kernel space to userspace. Yay again!Apart from that, a fairly mundane bag of perf optimization, cleanup and bug fixes.
Quoted 7 lines
Quoted 4 lines
Note that this series is based on a shared branch with the arm64 tree, avoiding a potential delicate merge.
Please pull,
Pulled, thanks. Note that the new capabilities had a conflict and were bumped by one.
Not a problem, nothing has been merged into any userspace so far.
Thanks,
M.
Signature · 1 line
Jazz is not dead. It just smells funny...