KVM: arm64: Bootstrap PSCI SMC handler in nVHE EL2

Add a handler of PSCI SMCs in nVHE hyp code. The handler is initialized
with the version used by the host's PSCI driver and the function IDs it
was configured with. If the SMC function ID matches one of the
configured PSCI calls (for v0.1) or falls into the PSCI function ID
range (for v0.2+), the SMC is handled by the PSCI handler. For now, all
SMCs return PSCI_RET_NOT_SUPPORTED.

Signed-off-by: David Brazdil <dbrazdil@google.com>
Signed-off-by: Marc Zyngier <maz@kernel.org>
Link: https://lore.kernel.org/r/20201202184122.26046-17-dbrazdil@google.com

diff --git a/arch/arm64/include/asm/kvm_hyp.h b/arch/arm64/include/asm/kvm_hyp.h
index cb25c15e3d8d3be6e586e8590647fcf53258ee1a..c0450828378b528280f4dcc2f472e5694fc462c2 100644 (file)
--- a/arch/arm64/include/asm/kvm_hyp.h
+++ b/arch/arm64/include/asm/kvm_hyp.h
@@ -93,6 +93,8 @@ void deactivate_traps_vhe_put(void);
 
 u64 __guest_enter(struct kvm_vcpu *vcpu);
 
+bool kvm_host_psci_handler(struct kvm_cpu_context *host_ctxt);
+
 void __noreturn hyp_panic(void);
 #ifdef __KVM_NVHE_HYPERVISOR__
 void __noreturn __hyp_do_panic(bool restore_host, u64 spsr, u64 elr, u64 par);

diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
index bcd6e5d3c89a6464b555ab5a753a6198a83843f3..aa40bef09dfce5d3313b43219d76851f0c62fbfa 100644 (file)
--- a/arch/arm64/kvm/arm.c
+++ b/arch/arm64/kvm/arm.c
@@ -19,6 +19,7 @@
 #include <linux/kvm_irqfd.h>
 #include <linux/irqbypass.h>
 #include <linux/sched/stat.h>
+#include <linux/psci.h>
 #include <trace/events/kvm.h>
 
 #define CREATE_TRACE_POINTS
@@ -65,6 +66,8 @@ static DEFINE_PER_CPU(unsigned char, kvm_arm_hardware_enabled);
 DEFINE_STATIC_KEY_FALSE(userspace_irqchip_in_use);
 
 extern u64 kvm_nvhe_sym(__cpu_logical_map)[NR_CPUS];
+extern u32 kvm_nvhe_sym(kvm_host_psci_version);
+extern struct psci_0_1_function_ids kvm_nvhe_sym(kvm_host_psci_0_1_function_ids);
 
 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
 {
@@ -1522,6 +1525,22 @@ static void init_cpu_logical_map(void)
                kvm_nvhe_sym(__cpu_logical_map)[cpu] = cpu_logical_map(cpu);
 }
 
+static bool init_psci_relay(void)
+{
+       /*
+        * If PSCI has not been initialized, protected KVM cannot install
+        * itself on newly booted CPUs.
+        */
+       if (!psci_ops.get_version) {
+               kvm_err("Cannot initialize protected mode without PSCI\n");
+               return false;
+       }
+
+       kvm_nvhe_sym(kvm_host_psci_version) = psci_ops.get_version();
+       kvm_nvhe_sym(kvm_host_psci_0_1_function_ids) = get_psci_0_1_function_ids();
+       return true;
+}
+
 static int init_common_resources(void)
 {
        return kvm_set_ipa_limit();
@@ -1700,9 +1719,13 @@ static int init_hyp_mode(void)
                }
        }
 
-       if (is_protected_kvm_enabled())
+       if (is_protected_kvm_enabled()) {
                init_cpu_logical_map();
 
+               if (!init_psci_relay())
+                       goto out_err;
+       }
+
        return 0;
 
 out_err:

diff --git a/arch/arm64/kvm/hyp/include/nvhe/trap_handler.h b/arch/arm64/kvm/hyp/include/nvhe/trap_handler.h
new file mode 100644 (file)
index 0000000..1e6d995
--- /dev/null
+++ b/arch/arm64/kvm/hyp/include/nvhe/trap_handler.h
@@ -0,0 +1,18 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Trap handler helpers.
+ *
+ * Copyright (C) 2020 - Google LLC
+ * Author: Marc Zyngier <maz@kernel.org>
+ */
+
+#ifndef __ARM64_KVM_NVHE_TRAP_HANDLER_H__
+#define __ARM64_KVM_NVHE_TRAP_HANDLER_H__
+
+#include <asm/kvm_host.h>
+
+#define cpu_reg(ctxt, r)       (ctxt)->regs.regs[r]
+#define DECLARE_REG(type, name, ctxt, reg)     \
+                               type name = (type)cpu_reg(ctxt, (reg))
+
+#endif /* __ARM64_KVM_NVHE_TRAP_HANDLER_H__ */

diff --git a/arch/arm64/kvm/hyp/nvhe/Makefile b/arch/arm64/kvm/hyp/nvhe/Makefile
index 2d842e009a403a893ee83234a19cd0bbc195757d..bf62c8e42ab23d3d447ef72336a0cdca6327315c 100644 (file)
--- a/arch/arm64/kvm/hyp/nvhe/Makefile
+++ b/arch/arm64/kvm/hyp/nvhe/Makefile
@@ -7,7 +7,7 @@ asflags-y := -D__KVM_NVHE_HYPERVISOR__
 ccflags-y := -D__KVM_NVHE_HYPERVISOR__
 
 obj-y := timer-sr.o sysreg-sr.o debug-sr.o switch.o tlb.o hyp-init.o host.o \
-        hyp-main.o hyp-smp.o
+        hyp-main.o hyp-smp.o psci-relay.o
 obj-y += ../vgic-v3-sr.o ../aarch32.o ../vgic-v2-cpuif-proxy.o ../entry.o \
         ../fpsimd.o ../hyp-entry.o
 

diff --git a/arch/arm64/kvm/hyp/nvhe/hyp-main.c b/arch/arm64/kvm/hyp/nvhe/hyp-main.c
index f25680ede080f642e6cdd32a69bb371268968d9d..bde658d51404b46a64f6406e250f7713b191e622 100644 (file)
--- a/arch/arm64/kvm/hyp/nvhe/hyp-main.c
+++ b/arch/arm64/kvm/hyp/nvhe/hyp-main.c
@@ -12,9 +12,7 @@
 #include <asm/kvm_hyp.h>
 #include <asm/kvm_mmu.h>
 
-#define cpu_reg(ctxt, r)       (ctxt)->regs.regs[r]
-#define DECLARE_REG(type, name, ctxt, reg)     \
-                               type name = (type)cpu_reg(ctxt, (reg))
+#include <nvhe/trap_handler.h>
 
 DEFINE_PER_CPU(struct kvm_nvhe_init_params, kvm_init_params);
 
@@ -166,7 +164,11 @@ static void skip_host_instruction(void)
 
 static void handle_host_smc(struct kvm_cpu_context *host_ctxt)
 {
-       default_host_smc_handler(host_ctxt);
+       bool handled;
+
+       handled = kvm_host_psci_handler(host_ctxt);
+       if (!handled)
+               default_host_smc_handler(host_ctxt);
 
        /*
         * Unlike HVC, the return address of an SMC is the instruction's PC.

diff --git a/arch/arm64/kvm/hyp/nvhe/psci-relay.c b/arch/arm64/kvm/hyp/nvhe/psci-relay.c
new file mode 100644 (file)
index 0000000..61375d4
--- /dev/null
+++ b/arch/arm64/kvm/hyp/nvhe/psci-relay.c
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2020 - Google LLC
+ * Author: David Brazdil <dbrazdil@google.com>
+ */
+
+#include <asm/kvm_asm.h>
+#include <asm/kvm_hyp.h>
+#include <asm/kvm_mmu.h>
+#include <kvm/arm_hypercalls.h>
+#include <linux/arm-smccc.h>
+#include <linux/psci.h>
+#include <kvm/arm_psci.h>
+#include <uapi/linux/psci.h>
+
+#include <nvhe/trap_handler.h>
+
+/* Config options set by the host. */
+__ro_after_init u32 kvm_host_psci_version;
+__ro_after_init struct psci_0_1_function_ids kvm_host_psci_0_1_function_ids;
+
+static u64 get_psci_func_id(struct kvm_cpu_context *host_ctxt)
+{
+       DECLARE_REG(u64, func_id, host_ctxt, 0);
+
+       return func_id;
+}
+
+static bool is_psci_0_1_call(u64 func_id)
+{
+       return (func_id == kvm_host_psci_0_1_function_ids.cpu_suspend) ||
+              (func_id == kvm_host_psci_0_1_function_ids.cpu_on) ||
+              (func_id == kvm_host_psci_0_1_function_ids.cpu_off) ||
+              (func_id == kvm_host_psci_0_1_function_ids.migrate);
+}
+
+static bool is_psci_0_2_call(u64 func_id)
+{
+       /* SMCCC reserves IDs 0x00-1F with the given 32/64-bit base for PSCI. */
+       return (PSCI_0_2_FN(0) <= func_id && func_id <= PSCI_0_2_FN(31)) ||
+              (PSCI_0_2_FN64(0) <= func_id && func_id <= PSCI_0_2_FN64(31));
+}
+
+static bool is_psci_call(u64 func_id)
+{
+       switch (kvm_host_psci_version) {
+       case PSCI_VERSION(0, 1):
+               return is_psci_0_1_call(func_id);
+       default:
+               return is_psci_0_2_call(func_id);
+       }
+}
+
+static unsigned long psci_0_1_handler(u64 func_id, struct kvm_cpu_context *host_ctxt)
+{
+       return PSCI_RET_NOT_SUPPORTED;
+}
+
+static unsigned long psci_0_2_handler(u64 func_id, struct kvm_cpu_context *host_ctxt)
+{
+       switch (func_id) {
+       default:
+               return PSCI_RET_NOT_SUPPORTED;
+       }
+}
+
+static unsigned long psci_1_0_handler(u64 func_id, struct kvm_cpu_context *host_ctxt)
+{
+       switch (func_id) {
+       default:
+               return psci_0_2_handler(func_id, host_ctxt);
+       }
+}
+
+bool kvm_host_psci_handler(struct kvm_cpu_context *host_ctxt)
+{
+       u64 func_id = get_psci_func_id(host_ctxt);
+       unsigned long ret;
+
+       if (!is_psci_call(func_id))
+               return false;
+
+       switch (kvm_host_psci_version) {
+       case PSCI_VERSION(0, 1):
+               ret = psci_0_1_handler(func_id, host_ctxt);
+               break;
+       case PSCI_VERSION(0, 2):
+               ret = psci_0_2_handler(func_id, host_ctxt);
+               break;
+       default:
+               ret = psci_1_0_handler(func_id, host_ctxt);
+               break;
+       }
+
+       cpu_reg(host_ctxt, 0) = ret;
+       cpu_reg(host_ctxt, 1) = 0;
+       cpu_reg(host_ctxt, 2) = 0;
+       cpu_reg(host_ctxt, 3) = 0;
+       return true;
+}