mirror of
git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2025-08-05 16:54:27 +00:00
13423063c7
The KVM/arm64 uses SMCCC to detect hypervisor presence. That code is private, and it follows the SMCCC specification. Other existing and emerging hypervisor guest implementations can and should use that standard approach as well. Factor out a common infrastructure that the guests can use, update KVM to employ the new API. The central notion of the SMCCC method is the UUID of the hypervisor, and the new API follows that. No functional changes. Validated with a KVM/arm64 guest. Signed-off-by: Roman Kisel <romank@linux.microsoft.com> Acked-by: Arnd Bergmann <arnd@arndb.de> Reviewed-by: Michael Kelley <mhklinux@outlook.com> Link: https://lore.kernel.org/r/20250428210742.435282-2-romank@linux.microsoft.com Signed-off-by: Wei Liu <wei.liu@kernel.org> Message-ID: <20250428210742.435282-2-romank@linux.microsoft.com>
113 lines
2.8 KiB
C
113 lines
2.8 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
#define pr_fmt(fmt) "smccc: KVM: " fmt
|
|
|
|
#include <linux/arm-smccc.h>
|
|
#include <linux/bitmap.h>
|
|
#include <linux/cache.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/memblock.h>
|
|
#include <linux/string.h>
|
|
|
|
#include <uapi/linux/psci.h>
|
|
|
|
#include <asm/hypervisor.h>
|
|
|
|
static DECLARE_BITMAP(__kvm_arm_hyp_services, ARM_SMCCC_KVM_NUM_FUNCS) __ro_after_init = { };
|
|
|
|
void __init kvm_init_hyp_services(void)
|
|
{
|
|
uuid_t kvm_uuid = ARM_SMCCC_VENDOR_HYP_UID_KVM;
|
|
struct arm_smccc_res res;
|
|
u32 val[4];
|
|
|
|
if (!arm_smccc_hypervisor_has_uuid(&kvm_uuid))
|
|
return;
|
|
|
|
memset(&res, 0, sizeof(res));
|
|
arm_smccc_1_1_invoke(ARM_SMCCC_VENDOR_HYP_KVM_FEATURES_FUNC_ID, &res);
|
|
|
|
val[0] = lower_32_bits(res.a0);
|
|
val[1] = lower_32_bits(res.a1);
|
|
val[2] = lower_32_bits(res.a2);
|
|
val[3] = lower_32_bits(res.a3);
|
|
|
|
bitmap_from_arr32(__kvm_arm_hyp_services, val, ARM_SMCCC_KVM_NUM_FUNCS);
|
|
|
|
pr_info("hypervisor services detected (0x%08lx 0x%08lx 0x%08lx 0x%08lx)\n",
|
|
res.a3, res.a2, res.a1, res.a0);
|
|
|
|
kvm_arch_init_hyp_services();
|
|
}
|
|
|
|
bool kvm_arm_hyp_service_available(u32 func_id)
|
|
{
|
|
if (func_id >= ARM_SMCCC_KVM_NUM_FUNCS)
|
|
return false;
|
|
|
|
return test_bit(func_id, __kvm_arm_hyp_services);
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvm_arm_hyp_service_available);
|
|
|
|
#ifdef CONFIG_ARM64
|
|
void __init kvm_arm_target_impl_cpu_init(void)
|
|
{
|
|
int i;
|
|
u32 ver;
|
|
u64 max_cpus;
|
|
struct arm_smccc_res res;
|
|
struct target_impl_cpu *target;
|
|
|
|
if (!kvm_arm_hyp_service_available(ARM_SMCCC_KVM_FUNC_DISCOVER_IMPL_VER) ||
|
|
!kvm_arm_hyp_service_available(ARM_SMCCC_KVM_FUNC_DISCOVER_IMPL_CPUS))
|
|
return;
|
|
|
|
arm_smccc_1_1_invoke(ARM_SMCCC_VENDOR_HYP_KVM_DISCOVER_IMPL_VER_FUNC_ID,
|
|
0, &res);
|
|
if (res.a0 != SMCCC_RET_SUCCESS)
|
|
return;
|
|
|
|
/* Version info is in lower 32 bits and is in SMMCCC_VERSION format */
|
|
ver = lower_32_bits(res.a1);
|
|
if (PSCI_VERSION_MAJOR(ver) != 1) {
|
|
pr_warn("Unsupported target CPU implementation version v%d.%d\n",
|
|
PSCI_VERSION_MAJOR(ver), PSCI_VERSION_MINOR(ver));
|
|
return;
|
|
}
|
|
|
|
if (!res.a2) {
|
|
pr_warn("No target implementation CPUs specified\n");
|
|
return;
|
|
}
|
|
|
|
max_cpus = res.a2;
|
|
target = memblock_alloc(sizeof(*target) * max_cpus, __alignof__(*target));
|
|
if (!target) {
|
|
pr_warn("Not enough memory for struct target_impl_cpu\n");
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < max_cpus; i++) {
|
|
arm_smccc_1_1_invoke(ARM_SMCCC_VENDOR_HYP_KVM_DISCOVER_IMPL_CPUS_FUNC_ID,
|
|
i, 0, 0, &res);
|
|
if (res.a0 != SMCCC_RET_SUCCESS) {
|
|
pr_warn("Discovering target implementation CPUs failed\n");
|
|
goto mem_free;
|
|
}
|
|
target[i].midr = res.a1;
|
|
target[i].revidr = res.a2;
|
|
target[i].aidr = res.a3;
|
|
}
|
|
|
|
if (!cpu_errata_set_target_impl(max_cpus, target)) {
|
|
pr_warn("Failed to set target implementation CPUs\n");
|
|
goto mem_free;
|
|
}
|
|
|
|
pr_info("Number of target implementation CPUs is %lld\n", max_cpus);
|
|
return;
|
|
|
|
mem_free:
|
|
memblock_free(target, sizeof(*target) * max_cpus);
|
|
}
|
|
#endif
|