Skip to contentSkip to conversation

KVM: arm64: Restore type-checking across the host/hyp hypercall boundary

PATCH Superseded Fuad Tabba 3 participants 20 messages Aug 3 – Aug 4

Subsystems (3)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore

Fuad Tabba

author reviewer
#0 lore raw

v2 cover KVM: arm64: Restore type-checking across the host/hyp hypercall boundary

Hi folks,

Changes since v1 [1]:
- Dropped the explicit argument-count parameter from the hypercall declarations and the handler definitions. The macro ladder derives it from COUNT_ARGS() instead. (Marc, Will)
- Renamed the __hostva address space to __kern. (Vincent)
- Rebased onto 7.2-rc6.

The SMCCC conversion of the host/hyp interface reduced every hypercall to a function number and a pile of registers: kvm_call_hyp_nvhe() never shows the compiler a callable, so the caller's arguments and the handler's DECLARE_REG() casts can disagree in type, count or order without a diagnostic. Reviewing a fix for exactly that class of bug, Marc wrote [2]:

"we lost all form of type-checking when everything was hastily
converted to SMCCC to avoid function pointers. Somehow, I feel that the cure was worse than the disease.

I wish we'd reintroduce some form of compile-time checks, maybe by having generated stubs?"

and sketched the shape he preferred [3]: a generated nvhe_hvc_##f() stub that does the type-checking, driven by "some form of declarative IDL", with "both the caller and callee stubs ... totally generated".

This series implements that, in plain preprocessor macros rather than an external generator, in the mold of the syscall wrappers. Each hypercall's signature is declared once, in kvm_hcall.h:
kvm_call_hyp_nvhe() resolves to a typed nvhe_hvc_##f() stub generated from the declaration, and the hyp-main.c handlers unmarshal their arguments through glue that is type-checked against the same declaration. A mistyped or stale call, or a handler that drifts from its caller, now fails to compile. On top of that shared declaration, host-VA parameters gain a __kern sparse address space, so dereferencing one at EL2 without kern_hyp_va_host() translation is flagged by sparse. The address space is KVM-private and lives with the interface it annotates rather than in compiler_types.h, like x86's __seg_gs in asm/percpu.h. The deeper instances of that bug class, host VAs reached through struct fields after the boundary, are follow-up work.

The declarations do not also generate the function-number enum or the dispatch table. The enum carries the availability-band markers that decide when each hypercall becomes reachable, and its base entry is consumed from assembly, so generating it would hide the banding. The remaining duplication cannot drift silently: a name mismatch between declaration, caller and handler fails to compile, and a missing dispatch-table entry is rejected at run time as SMCCC_RET_NOT_SUPPORTED.

Along the way it turned out "make C=2" has never checked the nVHE objects at all: the custom %.nvhe.o rule reuses rule_cc_o_c, which only hooks the checker for C=1, and that only on a rebuild. Patches 2-5 fix the hook and the handful of pre-existing sparse warnings it flushes out, so the checker lands clean. The libfdt objects under arch/arm64/kernel/pi/ have the same gap through the same rule, so patch 6 gives them the same one-line fix; it touches arm64 core rather than KVM, so it can go through either tree. Patch 1 is
adjacent: trace_remote_event.h is not self-contained (it uses bool without including linux/types.h), which the nVHE include order had been silently working around; it can go through the tracing tree instead if preferred.

The first six patches do not depend on the type-checking work (the tracing-header fix, the sparse cleanups, and the two C=2 hook fixes), so they could be taken on their own, ahead of the rest of the series if that is easier.

The series is structured as follows:

  01:     Make trace_remote_event.h self-contained.
  02-04:  Fix the pre-existing sparse warnings in the nVHE code.
  05:     Run the source checker on nVHE objects under C=2.
  06:     Same for the libfdt objects under arch/arm64/kernel/pi/.
  07:     Pass the host-VA hypercall arguments as pointers at EL2.
  08:     Move the dispatch macros to a new kvm_hcall.h.
  09:     Declare the hypercall signatures, type-check the callers.
  10:     Generate the handler unmarshalling, type-check the handlers.
  11:     Tag host-VA parameters __kern for sparse.

The generated code is unchanged, checked by comparing the disassembly of every KVM object, function by function, against the base: the callers are identical apart from hypercall returns now being tested at their declared width and the stage-2 TLB-flush level argument now being sign-extended as it is loaded (an s8 passed as an int), and the handlers are instruction-for-instruction identical apart from flush_hyp_vcpu()/sync_hyp_vcpu() being inlined into their only caller. The extra argument that prompted the thread, a mistyped or reordered argument, and a handler that disagrees with its declaration all now fail to compile. checkpatch complains about the __KVM_HCALL_MAP() machinery, the (type, name) pair syntax and the generated signature typedefs, as it does about __MAP() in the syscall wrappers; the idiom cannot be parenthesized, and the typedef is what checks the handler against the declaration. Enforcing the __kern tag needs sparse v0.6.5-rc1 or later for __typeof_unqual__, as all sparse checking on current kernels does; no stable sparse release has it yet, so build from sparse.git (checker-valid.sh skips the check, with a warning, on anything older).

Based on Linux 7.2-rc6 (075b74841bd00).

Cheers,
/fuad

[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/[email protected]/
[3] https://lore.kernel.org/all/[email protected]/

Fuad Tabba (11):
tracing: Include linux/types.h in trace_remote_event.h
KVM: arm64: nVHE: Share the stacktrace per-CPU declarations with EL2
KVM: arm64: nVHE: Declare the hyp event IDs before defining them
KVM: arm64: nVHE: Use NULL to reset the trace buffer backing pointer
KVM: arm64: nVHE: Run the source checker under C=2
arm64: pi: Run the source checker on the libfdt objects under C=2
KVM: arm64: nVHE: Pass host VA arguments as pointers
KVM: arm64: Move the host hypercall interface to its own header
KVM: arm64: Type-check hypercall arguments at the caller
KVM: arm64: nVHE: Check hypercall handlers against the declared ABI
KVM: arm64: Tag host-VA hypercall parameters __kern

 arch/arm64/include/asm/kvm_hcall.h       | 258 +++++++++++++
 arch/arm64/include/asm/kvm_host.h        |  48 +--
 arch/arm64/include/asm/kvm_mmu.h         |  10 +
 arch/arm64/include/asm/stacktrace/nvhe.h |  10 +-
 arch/arm64/kernel/pi/Makefile            |   1 +
 arch/arm64/kvm/hyp/include/nvhe/pkvm.h   |   7 +-
 arch/arm64/kvm/hyp/include/nvhe/trace.h  |   5 +-
 arch/arm64/kvm/hyp/nvhe/Makefile         |   1 +
 arch/arm64/kvm/hyp/nvhe/events.c         |   2 +
 arch/arm64/kvm/hyp/nvhe/hyp-main.c       | 444 +++++++++++------------
 arch/arm64/kvm/hyp/nvhe/pkvm.c           |  12 +-
 arch/arm64/kvm/hyp/nvhe/stacktrace.c     |   3 +-
 arch/arm64/kvm/hyp/nvhe/trace.c          |   6 +-
 arch/arm64/kvm/hyp_trace.c               |   2 +-
 arch/arm64/kvm/stacktrace.c              |   3 -
 include/linux/trace_remote_event.h       |   2 +
 16 files changed, 512 insertions(+), 302 deletions(-)
 create mode 100644 arch/arm64/include/asm/kvm_hcall.h

base-commit: 075b74841bd0065a3bda3440873c747938e69b68

Signature · 1 line
2.39.5
author reviewer
#1 lore raw

PATCH v2 1/11 tracing: Include linux/types.h in trace_remote_event.h

trace_remote_event.h uses bool without including linux/types.h, so a translation unit that includes it ahead of anything else that pulls types.h in fails to build, as with nvhe/trace.h at EL2.

Fixes 072529158e60 ("tracing: Add events to trace remotes")
---
 include/linux/trace_remote_event.h | 2 ++
 1 file changed, 2 insertions(+)
include/linux/trace_remote_event.h +2 -0
index c8ae1e1f5e721..e4cc2d4497bcf 100644
@@ -3,6 +3,8 @@
 #ifndef _LINUX_TRACE_REMOTE_EVENTS_H
 #define _LINUX_TRACE_REMOTE_EVENTS_H
 
+#include <linux/types.h>
+
 struct trace_remote;
 struct trace_event_fields;
 struct trace_seq;
Signature · 1 line
2.39.5
author reviewer
#2 lore raw

PATCH v2 2/11 KVM: arm64: nVHE: Share the stacktrace per-CPU declarations with EL2

In reply to Fuad Tabba

The declarations for overflow_stack, kvm_stacktrace_info and pkvm_stacktrace are only visible to the host (the first two sit in the host-only section of stacktrace/nvhe.h, the last is private to kvm/stacktrace.c), so the definitions in nvhe/stacktrace.c compile with no declaration in sight and sparse suggests making them static. DECLARE_KVM_NVHE_PER_CPU() resolves to the right symbol name on both sides of the build: move the declarations where both can see them and include the header from the EL2 side unconditionally.

No functional change intended.

---
 arch/arm64/include/asm/stacktrace/nvhe.h | 10 ++++++++--
 arch/arm64/kvm/hyp/nvhe/stacktrace.c     |  3 +--
 arch/arm64/kvm/stacktrace.c              |  3 ---
 3 files changed, 9 insertions(+), 7 deletions(-)
arch/arm64/include/asm/stacktrace/nvhe.h +8 -2
index 171f9edef49fc..a631a577cbe5d 100644
@@ -37,6 +37,14 @@ static inline void kvm_nvhe_unwind_init(struct unwind_state *state,
 	state->pc = pc;
 }
 
+DECLARE_KVM_NVHE_PER_CPU(unsigned long [OVERFLOW_STACK_SIZE/sizeof(long)], overflow_stack);
+DECLARE_KVM_NVHE_PER_CPU(struct kvm_nvhe_stacktrace_info, kvm_stacktrace_info);
+
+#ifdef CONFIG_PKVM_STACKTRACE
+DECLARE_KVM_NVHE_PER_CPU(unsigned long [NVHE_STACKTRACE_SIZE/sizeof(long)],
+			 pkvm_stacktrace);
+#endif
+
 #ifndef __KVM_NVHE_HYPERVISOR__
 /*
  * Conventional (non-protected) nVHE HYP stack unwinder
@@ -45,8 +53,6 @@ static inline void kvm_nvhe_unwind_init(struct unwind_state *state,
  * (by the host in EL1).
  */
 
-DECLARE_KVM_NVHE_PER_CPU(unsigned long [OVERFLOW_STACK_SIZE/sizeof(long)], overflow_stack);
-DECLARE_KVM_NVHE_PER_CPU(struct kvm_nvhe_stacktrace_info, kvm_stacktrace_info);
 DECLARE_PER_CPU(unsigned long, kvm_arm_hyp_stack_base);
 
 void kvm_nvhe_dump_backtrace(unsigned long hyp_offset);
arch/arm64/kvm/hyp/nvhe/stacktrace.c +1 -2
index 7c832d60d22bb..11fadbebbf1d6 100644
@@ -8,6 +8,7 @@
 #include <asm/kvm_hyp.h>
 #include <asm/memory.h>
 #include <asm/percpu.h>
+#include <asm/stacktrace/nvhe.h>
 
 DEFINE_PER_CPU(unsigned long [OVERFLOW_STACK_SIZE/sizeof(long)], overflow_stack)
 	__aligned(16);
@@ -35,8 +36,6 @@ static void hyp_prepare_backtrace(unsigned long fp, unsigned long pc)
 }
 
 #ifdef CONFIG_PKVM_STACKTRACE
-#include <asm/stacktrace/nvhe.h>
-
 DEFINE_PER_CPU(unsigned long [NVHE_STACKTRACE_SIZE/sizeof(long)], pkvm_stacktrace);
 
 static struct stack_info stackinfo_get_overflow(void)
arch/arm64/kvm/stacktrace.c +0 -3
index 9724c320126b7..69377195e18b7 100644
@@ -198,9 +198,6 @@ static void hyp_dump_backtrace(unsigned long hyp_offset)
 }
 
 #ifdef CONFIG_PKVM_STACKTRACE
-DECLARE_KVM_NVHE_PER_CPU(unsigned long [NVHE_STACKTRACE_SIZE/sizeof(long)],
-			 pkvm_stacktrace);
-
 /*
  * pkvm_dump_backtrace - Dump the protected nVHE HYP backtrace.
  *
Signature · 1 line
2.39.5
author reviewer
#3 lore raw

PATCH v2 3/11 KVM: arm64: nVHE: Declare the hyp event IDs before defining them

In reply to Fuad Tabba

The defining expansion of HYP_EVENT() in events.c is the first time its translation unit meets hyp_event_id_<name>, so sparse suggests making the symbols static. Include kvm_hypevents.h ahead of define_events.h so the extern declarations come first, as with the tracepoint headers.

No functional change intended.

---
 arch/arm64/kvm/hyp/nvhe/events.c | 2 ++
 1 file changed, 2 insertions(+)
arch/arm64/kvm/hyp/nvhe/events.c +2 -0
index add9383aadb5a..b845be0acd117 100644
@@ -7,6 +7,8 @@
 #include <nvhe/mm.h>
 #include <nvhe/trace.h>
 
+#include <asm/kvm_hypevents.h>
+
 #include <nvhe/define_events.h>
 
 int __tracing_enable_event(unsigned short id, bool enable)
Signature · 1 line
2.39.5
author reviewer
#4 lore raw

PATCH v2 4/11 KVM: arm64: nVHE: Use NULL to reset the trace buffer backing pointer

In reply to Fuad Tabba

bpages_backing_start is a pointer; resetting it to plain 0 triggers a sparse warning.

No functional change intended.

---
 arch/arm64/kvm/hyp/nvhe/trace.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/arm64/kvm/hyp/nvhe/trace.c +1 -1
index e7e150ab265ff..177fe3d8fbb13 100644
@@ -93,7 +93,7 @@ static void hyp_trace_buffer_unload_bpage_backing(struct hyp_trace_buffer *trace
 
 	__release_host_mem(start, size);
 
-	trace_buffer->bpages_backing_start = 0;
+	trace_buffer->bpages_backing_start = NULL;
 	trace_buffer->bpages_backing_size = 0;
 }
 
Signature · 1 line
2.39.5
author reviewer
#5 lore raw

PATCH v2 5/11 KVM: arm64: nVHE: Run the source checker under C=2

In reply to Fuad Tabba

The custom %.nvhe.o rule reuses rule_cc_o_c, which hooks the source checker only for C=1, and that only when the object is rebuilt. The C=2 hook, cmd_force_checksrc, hangs off the standard %.o rule that nVHE objects do not use, so "make C=2" silently skips every nVHE source file. Call cmd_force_checksrc after the compile rule, as the standard rule does.

Fixes 7621712918ad4 ("KVM: arm64: Add build rules for separate VHE/nVHE object files")
---
 arch/arm64/kvm/hyp/nvhe/Makefile | 1 +
 1 file changed, 1 insertion(+)
arch/arm64/kvm/hyp/nvhe/Makefile +1 -0
index f57450ebcb498..ccc1fe8394094 100644
@@ -49,6 +49,7 @@ targets += $(hyp-obj) kvm_nvhe.tmp.o kvm_nvhe.rel.o hyp.lds hyp-reloc.S hyp-relo
 #    avoids file name clashes for files shared with VHE.
 $(obj)/%.nvhe.o: $(src)/%.c FORCE
 	$(call if_changed_rule,cc_o_c)
+	$(call cmd,force_checksrc)
 $(obj)/%.nvhe.o: $(src)/%.S FORCE
 	$(call if_changed_rule,as_o_S)
 
Signature · 1 line
2.39.5
author reviewer
#6 lore raw

PATCH v2 6/11 arm64: pi: Run the source checker on the libfdt objects under C=2

In reply to Fuad Tabba

The custom lib-%.o rule reuses rule_cc_o_c, which hooks the source checker only for C=1, and that only when the object is rebuilt. The C=2 hook, cmd_force_checksrc, hangs off the standard %.o rule, so "make C=2" silently skips the two libfdt objects. Call cmd_force_checksrc after the compile rule, as the standard rule does.

Fixes aacd149b6238 ("arm64: head: avoid relocating the kernel twice for KASLR")
---
 arch/arm64/kernel/pi/Makefile | 1 +
 1 file changed, 1 insertion(+)
arch/arm64/kernel/pi/Makefile +1 -0
index be92d73c25b21..96243c291e39d 100644
@@ -34,6 +34,7 @@ $(obj)/lib-%.pi.o: OBJCOPYFLAGS += --prefix-alloc-sections=.init
 
 $(obj)/lib-%.o: $(srctree)/lib/%.c FORCE
 	$(call if_changed_rule,cc_o_c)
+	$(call cmd,force_checksrc)
 
 obj-y					:= idreg-override.pi.o \
 					   map_kernel.pi.o map_range.pi.o \
Signature · 1 line
2.39.5
author reviewer
#7 lore raw

PATCH v2 7/11 KVM: arm64: nVHE: Pass host VA arguments as pointers

In reply to Fuad Tabba

Four hypercalls take host VAs as unsigned long: the donated vm, pgd and vcpu regions, and the tracing descriptor. Retype the arguments and their EL2 consumers as void *, so that the typed hypercall declarations introduced later in the series can attach a sparse address space to them; an address space attaches only to pointers.

No functional change intended.

---
 arch/arm64/kvm/hyp/include/nvhe/pkvm.h  |  5 ++---
 arch/arm64/kvm/hyp/include/nvhe/trace.h |  4 ++--
 arch/arm64/kvm/hyp/nvhe/hyp-main.c      |  8 ++++----
 arch/arm64/kvm/hyp/nvhe/pkvm.c          | 11 +++++------
 arch/arm64/kvm/hyp/nvhe/trace.c         |  4 ++--
 5 files changed, 15 insertions(+), 17 deletions(-)
arch/arm64/kvm/hyp/include/nvhe/pkvm.h +2 -3
index c904647d2f760..2643a1a819668 100644
@@ -69,10 +69,9 @@ void pkvm_hyp_vm_table_init(void *tbl);
 
 int __pkvm_reserve_vm(void);
 void __pkvm_unreserve_vm(pkvm_handle_t handle);
-int __pkvm_init_vm(struct kvm *host_kvm, unsigned long vm_hva,
-		   unsigned long pgd_hva);
+int __pkvm_init_vm(struct kvm *host_kvm, void *vm_hva, void *pgd_hva);
 int __pkvm_init_vcpu(pkvm_handle_t handle, struct kvm_vcpu *host_vcpu,
-		     unsigned long vcpu_hva);
+		     void *vcpu_hva);
 
 int __pkvm_reclaim_dying_guest_page(pkvm_handle_t handle, u64 gfn);
 int __pkvm_start_teardown_vm(pkvm_handle_t handle);
arch/arm64/kvm/hyp/include/nvhe/trace.h +2 -2
index 8813ff250f8e0..4aa36fd76b9e2 100644
@@ -46,7 +46,7 @@ static inline pid_t __tracing_get_vcpu_pid(struct kvm_cpu_context *host_ctxt)
 void *tracing_reserve_entry(unsigned long length);
 void tracing_commit_entry(void);
 
-int __tracing_load(unsigned long desc_va, size_t desc_size);
+int __tracing_load(void *desc_va, size_t desc_size);
 void __tracing_unload(void);
 int __tracing_enable(bool enable);
 int __tracing_swap_reader(unsigned int cpu);
@@ -59,7 +59,7 @@ static inline void tracing_commit_entry(void) { }
 #define HYP_EVENT(__name, __proto, __struct, __assign, __printk)      \
 	static inline void trace_##__name(__proto) {}
 
-static inline int __tracing_load(unsigned long desc_va, size_t desc_size) { return -ENODEV; }
+static inline int __tracing_load(void *desc_va, size_t desc_size) { return -ENODEV; }
 static inline void __tracing_unload(void) { }
 static inline int __tracing_enable(bool enable) { return -ENODEV; }
 static inline int __tracing_swap_reader(unsigned int cpu) { return -ENODEV; }
arch/arm64/kvm/hyp/nvhe/hyp-main.c +4 -4
index d3df96ed8ba42..23cb4313c60a2 100644
@@ -577,8 +577,8 @@ static void handle___pkvm_unreserve_vm(struct kvm_cpu_context *host_ctxt)
 static void handle___pkvm_init_vm(struct kvm_cpu_context *host_ctxt)
 {
 	DECLARE_REG(struct kvm *, host_kvm, host_ctxt, 1);
-	DECLARE_REG(unsigned long, vm_hva, host_ctxt, 2);
-	DECLARE_REG(unsigned long, pgd_hva, host_ctxt, 3);
+	DECLARE_REG(void *, vm_hva, host_ctxt, 2);
+	DECLARE_REG(void *, pgd_hva, host_ctxt, 3);
 
 	host_kvm = kern_hyp_va(host_kvm);
 	cpu_reg(host_ctxt, 1) = __pkvm_init_vm(host_kvm, vm_hva, pgd_hva);
@@ -588,7 +588,7 @@ static void handle___pkvm_init_vcpu(struct kvm_cpu_context *host_ctxt)
 {
 	DECLARE_REG(pkvm_handle_t, handle, host_ctxt, 1);
 	DECLARE_REG(struct kvm_vcpu *, host_vcpu, host_ctxt, 2);
-	DECLARE_REG(unsigned long, vcpu_hva, host_ctxt, 3);
+	DECLARE_REG(void *, vcpu_hva, host_ctxt, 3);
 
 	host_vcpu = kern_hyp_va(host_vcpu);
 	cpu_reg(host_ctxt, 1) = __pkvm_init_vcpu(handle, host_vcpu, vcpu_hva);
@@ -634,7 +634,7 @@ static void handle___pkvm_finalize_teardown_vm(struct kvm_cpu_context *host_ctxt
 
 static void handle___tracing_load(struct kvm_cpu_context *host_ctxt)
 {
-	DECLARE_REG(unsigned long, desc_hva, host_ctxt, 1);
+	DECLARE_REG(void *, desc_hva, host_ctxt, 1);
 	DECLARE_REG(size_t, desc_size, host_ctxt, 2);
 
 	cpu_reg(host_ctxt, 1) = __tracing_load(desc_hva, desc_size);
arch/arm64/kvm/hyp/nvhe/pkvm.c +5 -6
index 24d6f164129ac..205c52535c887 100644
@@ -644,9 +644,9 @@ static size_t pkvm_get_hyp_vm_size(unsigned int nr_vcpus)
 		size_mul(sizeof(struct pkvm_hyp_vcpu *), nr_vcpus));
 }
 
-static void *map_donated_memory_noclear(unsigned long host_va, size_t size)
+static void *map_donated_memory_noclear(void *host_va, size_t size)
 {
-	void *va = (void *)kern_hyp_va(host_va);
+	void *va = kern_hyp_va(host_va);
 
 	if (!PAGE_ALIGNED(va))
 		return NULL;
@@ -658,7 +658,7 @@ static void *map_donated_memory_noclear(unsigned long host_va, size_t size)
 	return va;
 }
 
-static void *map_donated_memory(unsigned long host_va, size_t size)
+static void *map_donated_memory(void *host_va, size_t size)
 {
 	void *va = map_donated_memory_noclear(host_va, size);
 
@@ -805,8 +805,7 @@ void teardown_selftest_vm(void)
  *
  * Return 0 success, negative error code on failure.
  */
-int __pkvm_init_vm(struct kvm *host_kvm, unsigned long vm_hva,
-		   unsigned long pgd_hva)
+int __pkvm_init_vm(struct kvm *host_kvm, void *vm_hva, void *pgd_hva)
 {
 	struct pkvm_hyp_vm *hyp_vm = NULL;
 	size_t vm_size, pgd_size;
@@ -897,7 +896,7 @@ static int register_hyp_vcpu(struct pkvm_hyp_vm *hyp_vm,
 }
 
 int __pkvm_init_vcpu(pkvm_handle_t handle, struct kvm_vcpu *host_vcpu,
-		     unsigned long vcpu_hva)
+		     void *vcpu_hva)
 {
 	struct pkvm_hyp_vcpu *hyp_vcpu;
 	struct pkvm_hyp_vm *hyp_vm;
arch/arm64/kvm/hyp/nvhe/trace.c +2 -2
index 177fe3d8fbb13..97203ddd3cf45 100644
@@ -206,9 +206,9 @@ static bool hyp_trace_desc_is_valid(struct hyp_trace_desc *desc, size_t desc_siz
 	return true;
 }
 
-int __tracing_load(unsigned long desc_hva, size_t desc_size)
+int __tracing_load(void *desc_hva, size_t desc_size)
 {
-	struct hyp_trace_desc *desc = (struct hyp_trace_desc *)kern_hyp_va(desc_hva);
+	struct hyp_trace_desc *desc = kern_hyp_va(desc_hva);
 	int ret;
 
 	ret = __admit_host_mem(desc, desc_size);
Signature · 1 line
2.39.5
author reviewer
#8 lore raw

PATCH v2 8/11 KVM: arm64: Move the host hypercall interface to its own header

In reply to Fuad Tabba

Move the kvm_call_hyp() dispatch macros and pkvm_handle_t out of kvm_host.h into a new kvm_hcall.h, giving the host<->hyp hypercall interface a single home that subsequent patches build on to restore type-checking across the boundary. The only adjustment to the moved code is the checkpatch-mandated space in "while (0)".

No functional change intended.

---
 arch/arm64/include/asm/kvm_hcall.h | 68 ++++++++++++++++++++++++++++++
 arch/arm64/include/asm/kvm_host.h  | 48 +--------------------
 2 files changed, 69 insertions(+), 47 deletions(-)
 create mode 100644 arch/arm64/include/asm/kvm_hcall.h
arch/arm64/include/asm/kvm_hcall.h new file +68 -0
new file mode 100644
index 0000000000000..d925b2c28a3d8
@@ -0,0 +1,68 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * The host<->hyp hypercall interface.
+ *
+ * Copyright (C) 2026 Google LLC
+ * Author: Fuad Tabba <[email protected]>
+ */
+
+#ifndef __ARM64_KVM_HCALL_H__
+#define __ARM64_KVM_HCALL_H__
+
+#include <linux/arm-smccc.h>
+#include <linux/bug.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+
+#include <asm/barrier.h>
+#include <asm/kvm_asm.h>
+#include <asm/virt.h>
+
+typedef u16 pkvm_handle_t;
+
+#ifndef __KVM_NVHE_HYPERVISOR__
+#define kvm_call_hyp_nvhe(f, ...)					\
+	({								\
+		struct arm_smccc_res res;				\
+									\
+		arm_smccc_1_1_hvc(KVM_HOST_SMCCC_FUNC(f),		\
+				  ##__VA_ARGS__, &res);			\
+		if (WARN_ON(res.a0 != SMCCC_RET_SUCCESS))		\
+			res.a1 = -EOPNOTSUPP;				\
+									\
+		res.a1;							\
+	})
+
+/*
+ * The isb() below is there to guarantee the same behaviour on VHE as on !VHE,
+ * where the eret to EL1 acts as a context synchronization event.
+ */
+#define kvm_call_hyp(f, ...)						\
+	do {								\
+		if (has_vhe()) {					\
+			f(__VA_ARGS__);					\
+			isb();						\
+		} else {						\
+			kvm_call_hyp_nvhe(f, ##__VA_ARGS__);		\
+		}							\
+	} while (0)
+
+#define kvm_call_hyp_ret(f, ...)					\
+	({								\
+		typeof(f(__VA_ARGS__)) ret;				\
+									\
+		if (has_vhe()) {					\
+			ret = f(__VA_ARGS__);				\
+		} else {						\
+			ret = kvm_call_hyp_nvhe(f, ##__VA_ARGS__);	\
+		}							\
+									\
+		ret;							\
+	})
+#else /* __KVM_NVHE_HYPERVISOR__ */
+#define kvm_call_hyp(f, ...) f(__VA_ARGS__)
+#define kvm_call_hyp_ret(f, ...) f(__VA_ARGS__)
+#define kvm_call_hyp_nvhe(f, ...) f(__VA_ARGS__)
+#endif /* __KVM_NVHE_HYPERVISOR__ */
+
+#endif /* __ARM64_KVM_HCALL_H__ */
arch/arm64/include/asm/kvm_host.h +1 -47

66 lines not on this page · raw message

Signature · 1 line
2.39.5
author reviewer
#9 lore raw

PATCH v2 9/11 KVM: arm64: Type-check hypercall arguments at the caller

In reply to Fuad Tabba

kvm_call_hyp_nvhe() reduces its target to an SMCCC function number, so the compiler never sees a callable: arguments that are wrong in number, type or order are silently marshalled into registers. The kvm_call_hyp() wrappers only catch this on the VHE branch, and the pKVM-only hypercalls have no such branch.

Declare each hypercall's signature once in kvm_hcall.h and generate a typed stub from it, in the mold of the syscall wrappers. Make kvm_call_hyp_nvhe() resolve to the stub so every caller is checked against the declared signature; a stale or mistyped call now fails to compile. The stubs inline to the same SMCCC call the untyped macro used to make: the compiled callers are unchanged, apart from hypercall returns now being tested at their declared width.

The stage-2 protection arguments are declared u64 rather than enum kvm_pgtable_prot, as kvm_pgtable.h includes linux/kvm_host.h and the enum cannot be completed here.

Assisted-by Antigravity:gemini-3.1-pro
---
 arch/arm64/include/asm/kvm_hcall.h | 168 ++++++++++++++++++++++++++++-
 arch/arm64/kvm/hyp_trace.c         |   2 +-
 2 files changed, 168 insertions(+), 2 deletions(-)
arch/arm64/include/asm/kvm_hcall.h +167 -1
index d925b2c28a3d8..1c9c182ddcd1b 100644
@@ -9,6 +9,7 @@
 #ifndef __ARM64_KVM_HCALL_H__
 #define __ARM64_KVM_HCALL_H__
 
+#include <linux/args.h>
 #include <linux/arm-smccc.h>
 #include <linux/bug.h>
 #include <linux/errno.h>
@@ -16,12 +17,37 @@
 
 #include <asm/barrier.h>
 #include <asm/kvm_asm.h>
+#include <asm/spectre.h>
 #include <asm/virt.h>
 
 typedef u16 pkvm_handle_t;
 
+struct kvm;
+struct kvm_s2_mmu;
+struct kvm_vcpu;
+struct vgic_v3_cpu_if;
+struct vgic_v5_cpu_if;
+
+/*
+ * Hypercall signatures are declared as (type, name) argument pairs.
+ * __KVM_HCALL_MAP() applies a macro to each pair, in the mold of __MAP()
+ * in <linux/syscalls.h>. The ladder is indexed by list entries, two per
+ * argument; __KVM_HCALL_MAP_N() takes that count explicitly.
+ */
+#define __KVM_HCALL_MAP2(m, t, a, ...) m(t, a)
+#define __KVM_HCALL_MAP4(m, t, a, ...) m(t, a), __KVM_HCALL_MAP2(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP6(m, t, a, ...) m(t, a), __KVM_HCALL_MAP4(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP8(m, t, a, ...) m(t, a), __KVM_HCALL_MAP6(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP10(m, t, a, ...) m(t, a), __KVM_HCALL_MAP8(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP12(m, t, a, ...) m(t, a), __KVM_HCALL_MAP10(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP_N(n, m, ...) CONCATENATE(__KVM_HCALL_MAP, n)(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP(m, ...) __KVM_HCALL_MAP_N(COUNT_ARGS(__VA_ARGS__), m, __VA_ARGS__)
+
+#define __KVM_HCALL_DECL(t, a)	t a
+#define __KVM_HCALL_ARGS(t, a)	a
+
 #ifndef __KVM_NVHE_HYPERVISOR__
-#define kvm_call_hyp_nvhe(f, ...)					\
+#define __kvm_call_hyp_nvhe(f, ...)					\
 	({								\
 		struct arm_smccc_res res;				\
 									\
@@ -33,6 +59,43 @@ typedef u16 pkvm_handle_t;
 		res.a1;							\
 	})
 
+/*
+ * Generate a typed stub for each declared hypercall. kvm_call_hyp_nvhe()
+ * resolves to the stub, so a call with the wrong argument count or types
+ * fails to compile instead of being silently truncated to an SMCCC function
+ * number and a pile of registers. The stub inlines to the same SMCCC call
+ * the untyped macro used to make.
+ */
+#define DECLARE_KVM_HOST_HCALL(ret, name, ...)				\
+	static __always_inline						\
+	ret nvhe_hvc_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__)) \
+	{								\
+		return (ret)__kvm_call_hyp_nvhe(name,			\
+			__KVM_HCALL_MAP(__KVM_HCALL_ARGS, __VA_ARGS__));\
+	}
+
+#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)				\
+	static __always_inline						\
+	void nvhe_hvc_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__)) \
+	{								\
+		__kvm_call_hyp_nvhe(name,				\
+			__KVM_HCALL_MAP(__KVM_HCALL_ARGS, __VA_ARGS__));\
+	}
+
+#define DECLARE_KVM_HOST_HCALL0(ret, name)				\
+	static __always_inline ret nvhe_hvc_##name(void)		\
+	{								\
+		return (ret)__kvm_call_hyp_nvhe(name);			\
+	}
+
+#define DECLARE_KVM_HOST_HCALL0_VOID(name)				\
+	static __always_inline void nvhe_hvc_##name(void)		\
+	{								\
+		__kvm_call_hyp_nvhe(name);				\
+	}
+
+#define kvm_call_hyp_nvhe(f, ...)	nvhe_hvc_##f(__VA_ARGS__)
+
 /*
  * The isb() below is there to guarantee the same behaviour on VHE as on !VHE,
  * where the eret to EL1 acts as a context synchronization event.
@@ -63,6 +126,109 @@ typedef u16 pkvm_handle_t;
 #define kvm_call_hyp(f, ...) f(__VA_ARGS__)
 #define kvm_call_hyp_ret(f, ...) f(__VA_ARGS__)
 #define kvm_call_hyp_nvhe(f, ...) f(__VA_ARGS__)
+
+#define DECLARE_KVM_HOST_HCALL(ret, name, ...)
+#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)
+#define DECLARE_KVM_HOST_HCALL0(ret, name)
+#define DECLARE_KVM_HOST_HCALL0_VOID(name)
 #endif /* __KVM_NVHE_HYPERVISOR__ */
 
+/* Hypercalls that are unavailable once pKVM has finalised. */
+DECLARE_KVM_HOST_HCALL(int, __pkvm_init,
+	phys_addr_t, phys, unsigned long, size,
+	unsigned long *, per_cpu_base, u32, hyp_va_bits)
+DECLARE_KVM_HOST_HCALL(unsigned long, __pkvm_create_private_mapping,
+	phys_addr_t, phys, size_t, size, u64, prot)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_cpu_set_vector,
+	enum arm64_hyp_spectre_vector, slot)
+DECLARE_KVM_HOST_HCALL0_VOID(__kvm_enable_ssbs)
+DECLARE_KVM_HOST_HCALL0_VOID(__vgic_v3_init_lrs)
+DECLARE_KVM_HOST_HCALL0(u64, __vgic_v3_get_gic_config)
+
+DECLARE_KVM_HOST_HCALL0(int, __pkvm_prot_finalize)
+
+/* Hypercalls that are always available and common to [nh]VHE/pKVM. */
+DECLARE_KVM_HOST_HCALL_VOID(__kvm_adjust_pc,
+	struct kvm_vcpu *, vcpu)
+DECLARE_KVM_HOST_HCALL(int, __kvm_vcpu_run,
+	struct kvm_vcpu *, vcpu)
+DECLARE_KVM_HOST_HCALL0_VOID(__kvm_flush_vm_context)
+DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa,
+	struct kvm_s2_mmu *, mmu, phys_addr_t, ipa, int, level)
+DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa_nsh,
+	struct kvm_s2_mmu *, mmu, phys_addr_t, ipa, int, level)
+DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid,
+	struct kvm_s2_mmu *, mmu)
+DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_range,
+	struct kvm_s2_mmu *, mmu, phys_addr_t, start, unsigned long, pages)
+DECLARE_KVM_HOST_HCALL_VOID(__kvm_flush_cpu_context,
+	struct kvm_s2_mmu *, mmu)
+DECLARE_KVM_HOST_HCALL_VOID(__kvm_timer_set_cntvoff,
+	u64, cntvoff)
+DECLARE_KVM_HOST_HCALL(int, __tracing_load,
+	void *, desc_hva, size_t, desc_size)
+DECLARE_KVM_HOST_HCALL0_VOID(__tracing_unload)
+DECLARE_KVM_HOST_HCALL(int, __tracing_enable,
+	bool, enable)
+DECLARE_KVM_HOST_HCALL(int, __tracing_swap_reader,
+	unsigned int, cpu)
+DECLARE_KVM_HOST_HCALL_VOID(__tracing_update_clock,
+	u32, mult, u32, shift, u64, epoch_ns, u64, epoch_cyc)
+DECLARE_KVM_HOST_HCALL(int, __tracing_reset,
+	unsigned int, cpu)
+DECLARE_KVM_HOST_HCALL(int, __tracing_enable_event,
+	unsigned short, id, bool, enable)
+DECLARE_KVM_HOST_HCALL_VOID(__tracing_write_event,
+	u64, id)
+DECLARE_KVM_HOST_HCALL_VOID(__vgic_v3_save_aprs,
+	struct vgic_v3_cpu_if *, cpu_if)
+DECLARE_KVM_HOST_HCALL_VOID(__vgic_v3_restore_vmcr_aprs,
+	struct vgic_v3_cpu_if *, cpu_if)
+DECLARE_KVM_HOST_HCALL_VOID(__vgic_v5_save_apr,
+	struct vgic_v5_cpu_if *, cpu_if)
+DECLARE_KVM_HOST_HCALL_VOID(__vgic_v5_restore_vmcr_apr,
+	struct vgic_v5_cpu_if *, cpu_if)
+
+/* Hypercalls that are available only when pKVM has finalised. */
+DECLARE_KVM_HOST_HCALL(int, __pkvm_host_share_hyp,
+	u64, pfn)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_host_unshare_hyp,
+	u64, pfn)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_host_donate_guest,
+	u64, pfn, u64, gfn)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_host_share_guest,
+	u64, pfn, u64, gfn, u64, nr_pages, u64, prot)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_host_unshare_guest,
+	pkvm_handle_t, handle, u64, gfn, u64, nr_pages)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_host_relax_perms_guest,
+	u64, gfn, u64, prot)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_host_wrprotect_guest,
+	pkvm_handle_t, handle, u64, gfn, u64, nr_pages)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_host_test_clear_young_guest,
+	pkvm_handle_t, handle, u64, gfn, u64, nr_pages, bool, mkold)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_host_mkyoung_guest,
+	u64, gfn)
+DECLARE_KVM_HOST_HCALL0(int, __pkvm_reserve_vm)
+DECLARE_KVM_HOST_HCALL_VOID(__pkvm_unreserve_vm,
+	pkvm_handle_t, handle)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_init_vm,
+	struct kvm *, host_kvm, void *, vm_hva, void *, pgd_hva)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_init_vcpu,
+	pkvm_handle_t, handle, struct kvm_vcpu *, host_vcpu,
+	void *, vcpu_hva)
+DECLARE_KVM_HOST_HCALL0(int, __pkvm_vcpu_in_poison_fault)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_force_reclaim_guest_page,
+	phys_addr_t, phys)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_reclaim_dying_guest_page,
+	pkvm_handle_t, handle, u64, gfn)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_start_teardown_vm,
+	pkvm_handle_t, handle)
+DECLARE_KVM_HOST_HCALL(int, __pkvm_finalize_teardown_vm,
+	pkvm_handle_t, handle)
+DECLARE_KVM_HOST_HCALL_VOID(__pkvm_vcpu_load,
+	pkvm_handle_t, handle, unsigned int, vcpu_idx, u64, hcr_el2)
+DECLARE_KVM_HOST_HCALL0_VOID(__pkvm_vcpu_put)
+DECLARE_KVM_HOST_HCALL_VOID(__pkvm_tlb_flush_vmid,
+	pkvm_handle_t, handle)
+
 #endif /* __ARM64_KVM_HCALL_H__ */
arch/arm64/kvm/hyp_trace.c +1 -1
index 9644c424819b7..44937e257375a 100644
@@ -269,7 +269,7 @@ static struct trace_buffer_desc *hyp_trace_load(unsigned long size, void *priv)
 	if (ret)
 		goto err_free_buffer;
 
-	ret = kvm_call_hyp_nvhe(__tracing_load, (unsigned long)desc, desc_size);
+	ret = kvm_call_hyp_nvhe(__tracing_load, desc, desc_size);
 	if (ret)
 		goto err_unload_pages;
 
Signature · 1 line
2.39.5
maintainer
#10 lore raw

Re: [PATCH v2 09/11] KVM: arm64: Type-check hypercall arguments at the caller

Quoted 93 lines · Fuad Tabba

kvm_call_hyp_nvhe() reduces its target to an SMCCC function number, so the compiler never sees a callable: arguments that are wrong in number, type or order are silently marshalled into registers. The kvm_call_hyp() wrappers only catch this on the VHE branch, and the pKVM-only hypercalls have no such branch.

Declare each hypercall's signature once in kvm_hcall.h and generate a typed stub from it, in the mold of the syscall wrappers. Make kvm_call_hyp_nvhe() resolve to the stub so every caller is checked against the declared signature; a stale or mistyped call now fails to compile. The stubs inline to the same SMCCC call the untyped macro used to make: the compiled callers are unchanged, apart from hypercall returns now being tested at their declared width.

The stage-2 protection arguments are declared u64 rather than enum kvm_pgtable_prot, as kvm_pgtable.h includes linux/kvm_host.h and the enum cannot be completed here.

Assisted-by Antigravity:gemini-3.1-pro
---
 arch/arm64/include/asm/kvm_hcall.h | 168 ++++++++++++++++++++++++++++-
 arch/arm64/kvm/hyp_trace.c         |   2 +-
 2 files changed, 168 insertions(+), 2 deletions(-)
arch/arm64/include/asm/kvm_hcall.h +39 -1
index d925b2c28a3d8..1c9c182ddcd1b 100644
@@ -9,6 +9,7 @@
 #ifndef __ARM64_KVM_HCALL_H__
 #define __ARM64_KVM_HCALL_H__
 
+#include <linux/args.h>
 #include <linux/arm-smccc.h>
 #include <linux/bug.h>
 #include <linux/errno.h>
@@ -16,12 +17,37 @@
 
 #include <asm/barrier.h>
 #include <asm/kvm_asm.h>
+#include <asm/spectre.h>
 #include <asm/virt.h>
 
 typedef u16 pkvm_handle_t;
 
+struct kvm;
+struct kvm_s2_mmu;
+struct kvm_vcpu;
+struct vgic_v3_cpu_if;
+struct vgic_v5_cpu_if;
+
+/*
+ * Hypercall signatures are declared as (type, name) argument pairs.
+ * __KVM_HCALL_MAP() applies a macro to each pair, in the mold of __MAP()
+ * in <linux/syscalls.h>. The ladder is indexed by list entries, two per
+ * argument; __KVM_HCALL_MAP_N() takes that count explicitly.
+ */
+#define __KVM_HCALL_MAP2(m, t, a, ...) m(t, a)
+#define __KVM_HCALL_MAP4(m, t, a, ...) m(t, a), __KVM_HCALL_MAP2(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP6(m, t, a, ...) m(t, a), __KVM_HCALL_MAP4(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP8(m, t, a, ...) m(t, a), __KVM_HCALL_MAP6(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP10(m, t, a, ...) m(t, a), __KVM_HCALL_MAP8(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP12(m, t, a, ...) m(t, a), __KVM_HCALL_MAP10(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP_N(n, m, ...) CONCATENATE(__KVM_HCALL_MAP, n)(m, __VA_ARGS__)
+#define __KVM_HCALL_MAP(m, ...) __KVM_HCALL_MAP_N(COUNT_ARGS(__VA_ARGS__), m, __VA_ARGS__)
+
+#define __KVM_HCALL_DECL(t, a)	t a
+#define __KVM_HCALL_ARGS(t, a)	a
+
 #ifndef __KVM_NVHE_HYPERVISOR__
-#define kvm_call_hyp_nvhe(f, ...)					\
+#define __kvm_call_hyp_nvhe(f, ...)					\
 	({								\
 		struct arm_smccc_res res;				\
 									\
@@ -33,6 +59,43 @@ typedef u16 pkvm_handle_t;
 		res.a1;							\
 	})
 
+/*
+ * Generate a typed stub for each declared hypercall. kvm_call_hyp_nvhe()
+ * resolves to the stub, so a call with the wrong argument count or types
+ * fails to compile instead of being silently truncated to an SMCCC function
+ * number and a pile of registers. The stub inlines to the same SMCCC call
+ * the untyped macro used to make.
+ */
+#define DECLARE_KVM_HOST_HCALL(ret, name, ...)				\
+	static __always_inline						\
+	ret nvhe_hvc_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__)) \
+	{								\
+		return (ret)__kvm_call_hyp_nvhe(name,			\

arch/arm64/include/asm/kvm_hcall.h typedef u16 pkvm_handle_t; · line 83

Quoted 10 lines
arch/arm64/include/asm/kvm_hcall.h +10 -0
+			__KVM_HCALL_MAP(__KVM_HCALL_ARGS, __VA_ARGS__));\
+	}
+
+#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)				\
+	static __always_inline						\
+	void nvhe_hvc_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__)) \
+	{								\
+		__kvm_call_hyp_nvhe(name,				\
+			__KVM_HCALL_MAP(__KVM_HCALL_ARGS, __VA_ARGS__));\
+	}

I'll bite! ;-) void is a type, not the absence of a type. And returning void is perfectly valid.

So with this in mind, I got rid of the *_VOID() helpers altogether, see below.

Thanks,

	M.
arch/arm64/include/asm/kvm_hcall.h +21 -39
index 3958396a83345..0b1b10d4212da 100644
@@ -88,26 +88,12 @@ struct vgic_v5_cpu_if;
 			__KVM_HCALL_MAP(__KVM_HCALL_ARGS, __VA_ARGS__));\
 	}
 
-#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)				\
-	static __always_inline						\
-	void nvhe_hvc_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__)) \
-	{								\
-		__kvm_call_hyp_nvhe(name,				\
-			__KVM_HCALL_MAP(__KVM_HCALL_ARGS, __VA_ARGS__));\
-	}
-
 #define DECLARE_KVM_HOST_HCALL0(ret, name)				\
 	static __always_inline ret nvhe_hvc_##name(void)		\
 	{								\
 		return (ret)__kvm_call_hyp_nvhe(name);			\
 	}
 
-#define DECLARE_KVM_HOST_HCALL0_VOID(name)				\
-	static __always_inline void nvhe_hvc_##name(void)		\
-	{								\
-		__kvm_call_hyp_nvhe(name);				\
-	}
-
 #define kvm_call_hyp_nvhe(f, ...)	nvhe_hvc_##f(__VA_ARGS__)
 
 /*
@@ -148,12 +134,8 @@ struct vgic_v5_cpu_if;
  */
 #define DECLARE_KVM_HOST_HCALL(ret, name, ...)				\
 	typedef ret kvm_host_hcall_sig_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__));
-#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)				\
-	typedef void kvm_host_hcall_sig_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__));
 #define DECLARE_KVM_HOST_HCALL0(ret, name)				\
 	typedef ret kvm_host_hcall_sig_##name(void);
-#define DECLARE_KVM_HOST_HCALL0_VOID(name)				\
-	typedef void kvm_host_hcall_sig_##name(void);
 #endif /* __KVM_NVHE_HYPERVISOR__ */
 
 /* Hypercalls that are unavailable once pKVM has finalised. */
@@ -164,52 +146,52 @@ DECLARE_KVM_HOST_HCALL(unsigned long, __pkvm_create_private_mapping,
 	phys_addr_t, phys, size_t, size, u64, prot)
 DECLARE_KVM_HOST_HCALL(int, __pkvm_cpu_set_vector,
 	enum arm64_hyp_spectre_vector, slot)
-DECLARE_KVM_HOST_HCALL0_VOID(__kvm_enable_ssbs)
-DECLARE_KVM_HOST_HCALL0_VOID(__vgic_v3_init_lrs)
+DECLARE_KVM_HOST_HCALL0(void, __kvm_enable_ssbs)
+DECLARE_KVM_HOST_HCALL0(void, __vgic_v3_init_lrs)
 DECLARE_KVM_HOST_HCALL0(u64, __vgic_v3_get_gic_config)
 
 DECLARE_KVM_HOST_HCALL0(int, __pkvm_prot_finalize)
 
 /* Hypercalls that are always available and common to [nh]VHE/pKVM. */
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_adjust_pc,
+DECLARE_KVM_HOST_HCALL(void, __kvm_adjust_pc,
 	struct kvm_vcpu __kern *, vcpu)
 DECLARE_KVM_HOST_HCALL(int, __kvm_vcpu_run,
 	struct kvm_vcpu __kern *, vcpu)
-DECLARE_KVM_HOST_HCALL0_VOID(__kvm_flush_vm_context)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa,
+DECLARE_KVM_HOST_HCALL0(void, __kvm_flush_vm_context)
+DECLARE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_ipa,
 	struct kvm_s2_mmu __kern *, mmu, phys_addr_t, ipa, int, level)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa_nsh,
+DECLARE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_ipa_nsh,
 	struct kvm_s2_mmu __kern *, mmu, phys_addr_t, ipa, int, level)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid,
+DECLARE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid,
 	struct kvm_s2_mmu __kern *, mmu)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_range,
+DECLARE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_range,
 	struct kvm_s2_mmu __kern *, mmu, phys_addr_t, start, unsigned long, pages)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_flush_cpu_context,
+DECLARE_KVM_HOST_HCALL(void, __kvm_flush_cpu_context,
 	struct kvm_s2_mmu __kern *, mmu)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_timer_set_cntvoff,
+DECLARE_KVM_HOST_HCALL(void, __kvm_timer_set_cntvoff,
 	u64, cntvoff)
 DECLARE_KVM_HOST_HCALL(int, __tracing_load,
 	void __kern *, desc_hva, size_t, desc_size)
-DECLARE_KVM_HOST_HCALL0_VOID(__tracing_unload)
+DECLARE_KVM_HOST_HCALL0(void, __tracing_unload)
 DECLARE_KVM_HOST_HCALL(int, __tracing_enable,
 	bool, enable)
 DECLARE_KVM_HOST_HCALL(int, __tracing_swap_reader,
 	unsigned int, cpu)
-DECLARE_KVM_HOST_HCALL_VOID(__tracing_update_clock,
+DECLARE_KVM_HOST_HCALL(void, __tracing_update_clock,
 	u32, mult, u32, shift, u64, epoch_ns, u64, epoch_cyc)
 DECLARE_KVM_HOST_HCALL(int, __tracing_reset,
 	unsigned int, cpu)
 DECLARE_KVM_HOST_HCALL(int, __tracing_enable_event,
 	unsigned short, id, bool, enable)
-DECLARE_KVM_HOST_HCALL_VOID(__tracing_write_event,
+DECLARE_KVM_HOST_HCALL(void, __tracing_write_event,
 	u64, id)
-DECLARE_KVM_HOST_HCALL_VOID(__vgic_v3_save_aprs,
+DECLARE_KVM_HOST_HCALL(void, __vgic_v3_save_aprs,
 	struct vgic_v3_cpu_if __kern *, cpu_if)
-DECLARE_KVM_HOST_HCALL_VOID(__vgic_v3_restore_vmcr_aprs,
+DECLARE_KVM_HOST_HCALL(void, __vgic_v3_restore_vmcr_aprs,
 	struct vgic_v3_cpu_if __kern *, cpu_if)
-DECLARE_KVM_HOST_HCALL_VOID(__vgic_v5_save_apr,
+DECLARE_KVM_HOST_HCALL(void, __vgic_v5_save_apr,
 	struct vgic_v5_cpu_if __kern *, cpu_if)
-DECLARE_KVM_HOST_HCALL_VOID(__vgic_v5_restore_vmcr_apr,
+DECLARE_KVM_HOST_HCALL(void, __vgic_v5_restore_vmcr_apr,
 	struct vgic_v5_cpu_if __kern *, cpu_if)
 
 /* Hypercalls that are available only when pKVM has finalised. */
@@ -232,7 +214,7 @@ DECLARE_KVM_HOST_HCALL(int, __pkvm_host_test_clear_young_guest,
 DECLARE_KVM_HOST_HCALL(int, __pkvm_host_mkyoung_guest,
 	u64, gfn)
 DECLARE_KVM_HOST_HCALL0(int, __pkvm_reserve_vm)
-DECLARE_KVM_HOST_HCALL_VOID(__pkvm_unreserve_vm,
+DECLARE_KVM_HOST_HCALL(void, __pkvm_unreserve_vm,
 	pkvm_handle_t, handle)
 DECLARE_KVM_HOST_HCALL(int, __pkvm_init_vm,
 	struct kvm __kern *, host_kvm, void __kern *, vm_hva,
@@ -249,10 +231,10 @@ DECLARE_KVM_HOST_HCALL(int, __pkvm_start_teardown_vm,
 	pkvm_handle_t, handle)
 DECLARE_KVM_HOST_HCALL(int, __pkvm_finalize_teardown_vm,
 	pkvm_handle_t, handle)
-DECLARE_KVM_HOST_HCALL_VOID(__pkvm_vcpu_load,
+DECLARE_KVM_HOST_HCALL(void, __pkvm_vcpu_load,
 	pkvm_handle_t, handle, unsigned int, vcpu_idx, u64, hcr_el2)
-DECLARE_KVM_HOST_HCALL0_VOID(__pkvm_vcpu_put)
-DECLARE_KVM_HOST_HCALL_VOID(__pkvm_tlb_flush_vmid,
+DECLARE_KVM_HOST_HCALL0(void, __pkvm_vcpu_put)
+DECLARE_KVM_HOST_HCALL(void, __pkvm_tlb_flush_vmid,
 	pkvm_handle_t, handle)
 
 #endif /* __ARM64_KVM_HCALL_H__ */
Signature · 1 line
Without deviation from the norm, progress is not possible.
author reviewer
#11 lore raw

Re: [PATCH v2 09/11] KVM: arm64: Type-check hypercall arguments at the caller

On Mon, 3 Aug 2026 at 18:59, Marc Zyngier <[email protected]> wrote:
...

Quoted 26 lines
Quoted 12 lines
(quoted diff) +12 -0
+/*
+ * Generate a typed stub for each declared hypercall. kvm_call_hyp_nvhe()
+ * resolves to the stub, so a call with the wrong argument count or types
+ * fails to compile instead of being silently truncated to an SMCCC function
+ * number and a pile of registers. The stub inlines to the same SMCCC call
+ * the untyped macro used to make.
+ */
+#define DECLARE_KVM_HOST_HCALL(ret, name, ...)                               \
+     static __always_inline                                          \
+     ret nvhe_hvc_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__)) \
+     {                                                               \
+             return (ret)__kvm_call_hyp_nvhe(name,                   \

Review

Quoted 10 lines
(quoted diff) +10 -0
+                     __KVM_HCALL_MAP(__KVM_HCALL_ARGS, __VA_ARGS__));\
+     }
+
+#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)                               \
+     static __always_inline                                          \
+     void nvhe_hvc_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__)) \
+     {                                                               \
+             __kvm_call_hyp_nvhe(name,                               \
+                     __KVM_HCALL_MAP(__KVM_HCALL_ARGS, __VA_ARGS__));\
+     }

I'll bite! ;-) void is a type, not the absence of a type. And returning void is perfectly valid.

Quoted 2 lines

So with this in mind, I got rid of the *_VOID() helpers altogether, see below.

This looks better. I've built and boot tested it, and the generated code is identical.

I noticed is that gcc and clang complain about "return (void)expr" under -Wpedantic, since ISO C only allows it from C23. We never build with that, right? So it doesn't bite ;)

Cheers,
/fuad

Quoted 145 lines

Thanks,

        M.
arch/arm64/include/asm/kvm_hcall.h +21 -40
index 3958396a83345..0b1b10d4212da 100644
@@ -88,26 +88,12 @@ struct vgic_v5_cpu_if;
                        __KVM_HCALL_MAP(__KVM_HCALL_ARGS, __VA_ARGS__));\
        }
 
-#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)                         \
-       static __always_inline                                          \
-       void nvhe_hvc_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__)) \
-       {                                                               \
-               __kvm_call_hyp_nvhe(name,                               \
-                       __KVM_HCALL_MAP(__KVM_HCALL_ARGS, __VA_ARGS__));\
-       }
-
 #define DECLARE_KVM_HOST_HCALL0(ret, name)                             \
        static __always_inline ret nvhe_hvc_##name(void)                \
        {                                                               \
                return (ret)__kvm_call_hyp_nvhe(name);                  \
        }
 
-#define DECLARE_KVM_HOST_HCALL0_VOID(name)                             \
-       static __always_inline void nvhe_hvc_##name(void)               \
-       {                                                               \
-               __kvm_call_hyp_nvhe(name);                              \
-       }
-
 #define kvm_call_hyp_nvhe(f, ...)      nvhe_hvc_##f(__VA_ARGS__)
 
 /*
@@ -148,12 +134,8 @@ struct vgic_v5_cpu_if;
  */
 #define DECLARE_KVM_HOST_HCALL(ret, name, ...)                         \
        typedef ret kvm_host_hcall_sig_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__));
-#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)                         \
-       typedef void kvm_host_hcall_sig_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__));
 #define DECLARE_KVM_HOST_HCALL0(ret, name)                             \
        typedef ret kvm_host_hcall_sig_##name(void);
-#define DECLARE_KVM_HOST_HCALL0_VOID(name)                             \
-       typedef void kvm_host_hcall_sig_##name(void);
 #endif /* __KVM_NVHE_HYPERVISOR__ */
 
 /* Hypercalls that are unavailable once pKVM has finalised. */
@@ -164,52 +146,52 @@ DECLARE_KVM_HOST_HCALL(unsigned long, __pkvm_create_private_mapping,
        phys_addr_t, phys, size_t, size, u64, prot)
 DECLARE_KVM_HOST_HCALL(int, __pkvm_cpu_set_vector,
        enum arm64_hyp_spectre_vector, slot)
-DECLARE_KVM_HOST_HCALL0_VOID(__kvm_enable_ssbs)
-DECLARE_KVM_HOST_HCALL0_VOID(__vgic_v3_init_lrs)
+DECLARE_KVM_HOST_HCALL0(void, __kvm_enable_ssbs)
+DECLARE_KVM_HOST_HCALL0(void, __vgic_v3_init_lrs)
 DECLARE_KVM_HOST_HCALL0(u64, __vgic_v3_get_gic_config)
 
 DECLARE_KVM_HOST_HCALL0(int, __pkvm_prot_finalize)
 
 /* Hypercalls that are always available and common to [nh]VHE/pKVM. */
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_adjust_pc,
+DECLARE_KVM_HOST_HCALL(void, __kvm_adjust_pc,
        struct kvm_vcpu __kern *, vcpu)
 DECLARE_KVM_HOST_HCALL(int, __kvm_vcpu_run,
        struct kvm_vcpu __kern *, vcpu)
-DECLARE_KVM_HOST_HCALL0_VOID(__kvm_flush_vm_context)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa,
+DECLARE_KVM_HOST_HCALL0(void, __kvm_flush_vm_context)
+DECLARE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_ipa,
        struct kvm_s2_mmu __kern *, mmu, phys_addr_t, ipa, int, level)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa_nsh,
+DECLARE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_ipa_nsh,
        struct kvm_s2_mmu __kern *, mmu, phys_addr_t, ipa, int, level)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid,
+DECLARE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid,
        struct kvm_s2_mmu __kern *, mmu)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_range,
+DECLARE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_range,
        struct kvm_s2_mmu __kern *, mmu, phys_addr_t, start, unsigned long, pages)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_flush_cpu_context,
+DECLARE_KVM_HOST_HCALL(void, __kvm_flush_cpu_context,
        struct kvm_s2_mmu __kern *, mmu)
-DECLARE_KVM_HOST_HCALL_VOID(__kvm_timer_set_cntvoff,
+DECLARE_KVM_HOST_HCALL(void, __kvm_timer_set_cntvoff,
        u64, cntvoff)
 DECLARE_KVM_HOST_HCALL(int, __tracing_load,
        void __kern *, desc_hva, size_t, desc_size)
-DECLARE_KVM_HOST_HCALL0_VOID(__tracing_unload)
+DECLARE_KVM_HOST_HCALL0(void, __tracing_unload)
 DECLARE_KVM_HOST_HCALL(int, __tracing_enable,
        bool, enable)
 DECLARE_KVM_HOST_HCALL(int, __tracing_swap_reader,
        unsigned int, cpu)
-DECLARE_KVM_HOST_HCALL_VOID(__tracing_update_clock,
+DECLARE_KVM_HOST_HCALL(void, __tracing_update_clock,
        u32, mult, u32, shift, u64, epoch_ns, u64, epoch_cyc)
 DECLARE_KVM_HOST_HCALL(int, __tracing_reset,
        unsigned int, cpu)
 DECLARE_KVM_HOST_HCALL(int, __tracing_enable_event,
        unsigned short, id, bool, enable)
-DECLARE_KVM_HOST_HCALL_VOID(__tracing_write_event,
+DECLARE_KVM_HOST_HCALL(void, __tracing_write_event,
        u64, id)
-DECLARE_KVM_HOST_HCALL_VOID(__vgic_v3_save_aprs,
+DECLARE_KVM_HOST_HCALL(void, __vgic_v3_save_aprs,
        struct vgic_v3_cpu_if __kern *, cpu_if)
-DECLARE_KVM_HOST_HCALL_VOID(__vgic_v3_restore_vmcr_aprs,
+DECLARE_KVM_HOST_HCALL(void, __vgic_v3_restore_vmcr_aprs,
        struct vgic_v3_cpu_if __kern *, cpu_if)
-DECLARE_KVM_HOST_HCALL_VOID(__vgic_v5_save_apr,
+DECLARE_KVM_HOST_HCALL(void, __vgic_v5_save_apr,
        struct vgic_v5_cpu_if __kern *, cpu_if)
-DECLARE_KVM_HOST_HCALL_VOID(__vgic_v5_restore_vmcr_apr,
+DECLARE_KVM_HOST_HCALL(void, __vgic_v5_restore_vmcr_apr,
        struct vgic_v5_cpu_if __kern *, cpu_if)
 
 /* Hypercalls that are available only when pKVM has finalised. */
@@ -232,7 +214,7 @@ DECLARE_KVM_HOST_HCALL(int, __pkvm_host_test_clear_young_guest,
 DECLARE_KVM_HOST_HCALL(int, __pkvm_host_mkyoung_guest,
        u64, gfn)
 DECLARE_KVM_HOST_HCALL0(int, __pkvm_reserve_vm)
-DECLARE_KVM_HOST_HCALL_VOID(__pkvm_unreserve_vm,
+DECLARE_KVM_HOST_HCALL(void, __pkvm_unreserve_vm,
        pkvm_handle_t, handle)
 DECLARE_KVM_HOST_HCALL(int, __pkvm_init_vm,
        struct kvm __kern *, host_kvm, void __kern *, vm_hva,
@@ -249,10 +231,10 @@ DECLARE_KVM_HOST_HCALL(int, __pkvm_start_teardown_vm,
        pkvm_handle_t, handle)
 DECLARE_KVM_HOST_HCALL(int, __pkvm_finalize_teardown_vm,
        pkvm_handle_t, handle)
-DECLARE_KVM_HOST_HCALL_VOID(__pkvm_vcpu_load,
+DECLARE_KVM_HOST_HCALL(void, __pkvm_vcpu_load,
        pkvm_handle_t, handle, unsigned int, vcpu_idx, u64, hcr_el2)
-DECLARE_KVM_HOST_HCALL0_VOID(__pkvm_vcpu_put)
-DECLARE_KVM_HOST_HCALL_VOID(__pkvm_tlb_flush_vmid,
+DECLARE_KVM_HOST_HCALL0(void, __pkvm_vcpu_put)
+DECLARE_KVM_HOST_HCALL(void, __pkvm_tlb_flush_vmid,
        pkvm_handle_t, handle)
 
 #endif /* __ARM64_KVM_HCALL_H__ */
 
--

Without deviation from the norm, progress is not possible.

author reviewer
#12 lore raw

PATCH v2 10/11 KVM: arm64: nVHE: Check hypercall handlers against the declared ABI

In reply to Fuad Tabba

Each hypercall handler unmarshals its arguments from the host context with hand-written DECLARE_REG() casts that nothing ties to what the caller passed: a handler can disagree with its caller in argument type, count or register index without a diagnostic.

Generate the unmarshalling instead. DEFINE_KVM_HOST_HCALL() expands to the handle_<name>() glue, modelled on the syscall wrappers, and checks the handler's parameter list against the signature declared in kvm_hcall.h, so both ends of every hypercall are now compiled against the same declaration. Handler bodies keep their logic and lose the DECLARE_REG() and return-register boilerplate. The compiled handlers are instruction-for-instruction identical, apart from flush_hyp_vcpu() and sync_hyp_vcpu() now being inlined into their only caller.

Assisted-by Antigravity:gemini-3.1-pro
---
 arch/arm64/include/asm/kvm_hcall.h |  19 +-
 arch/arm64/kvm/hyp/nvhe/hyp-main.c | 421 ++++++++++++++---------------
 2 files changed, 214 insertions(+), 226 deletions(-)
arch/arm64/include/asm/kvm_hcall.h +15 -4
index 1c9c182ddcd1b..39374bae4bea4 100644
@@ -44,6 +44,8 @@ struct vgic_v5_cpu_if;
 #define __KVM_HCALL_MAP(m, ...) __KVM_HCALL_MAP_N(COUNT_ARGS(__VA_ARGS__), m, __VA_ARGS__)
 
 #define __KVM_HCALL_DECL(t, a)	t a
+#define __KVM_HCALL_LONG(t, a)	unsigned long a
+#define __KVM_HCALL_CAST(t, a)	(__force t) a
 #define __KVM_HCALL_ARGS(t, a)	a
 
 #ifndef __KVM_NVHE_HYPERVISOR__
@@ -127,10 +129,19 @@ struct vgic_v5_cpu_if;
 #define kvm_call_hyp_ret(f, ...) f(__VA_ARGS__)
 #define kvm_call_hyp_nvhe(f, ...) f(__VA_ARGS__)
 
-#define DECLARE_KVM_HOST_HCALL(ret, name, ...)
-#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)
-#define DECLARE_KVM_HOST_HCALL0(ret, name)
-#define DECLARE_KVM_HOST_HCALL0_VOID(name)
+/*
+ * At EL2 each declaration emits the canonical signature of the hypercall,
+ * which DEFINE_KVM_HOST_HCALL() in hyp-main.c checks the handler
+ * definition against.
+ */
+#define DECLARE_KVM_HOST_HCALL(ret, name, ...)				\
+	typedef ret kvm_host_hcall_sig_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__));
+#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)				\
+	typedef void kvm_host_hcall_sig_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__));
+#define DECLARE_KVM_HOST_HCALL0(ret, name)				\
+	typedef ret kvm_host_hcall_sig_##name(void);
+#define DECLARE_KVM_HOST_HCALL0_VOID(name)				\
+	typedef void kvm_host_hcall_sig_##name(void);
 #endif /* __KVM_NVHE_HYPERVISOR__ */
 
 /* Hypercalls that are unavailable once pKVM has finalised. */
arch/arm64/kvm/hyp/nvhe/hyp-main.c +199 -222

684 lines not on this page · raw message

Signature · 1 line
2.39.5
maintainer
#13 lore raw

Re: [PATCH v2 10/11] KVM: arm64: nVHE: Check hypercall handlers against the declared ABI

Quoted 98 lines · Fuad Tabba

Each hypercall handler unmarshals its arguments from the host context with hand-written DECLARE_REG() casts that nothing ties to what the caller passed: a handler can disagree with its caller in argument type, count or register index without a diagnostic.

Generate the unmarshalling instead. DEFINE_KVM_HOST_HCALL() expands to the handle_<name>() glue, modelled on the syscall wrappers, and checks the handler's parameter list against the signature declared in kvm_hcall.h, so both ends of every hypercall are now compiled against the same declaration. Handler bodies keep their logic and lose the DECLARE_REG() and return-register boilerplate. The compiled handlers are instruction-for-instruction identical, apart from flush_hyp_vcpu() and sync_hyp_vcpu() now being inlined into their only caller.

Assisted-by Antigravity:gemini-3.1-pro
---
 arch/arm64/include/asm/kvm_hcall.h |  19 +-
 arch/arm64/kvm/hyp/nvhe/hyp-main.c | 421 ++++++++++++++---------------
 2 files changed, 214 insertions(+), 226 deletions(-)
arch/arm64/include/asm/kvm_hcall.h +15 -4
index 1c9c182ddcd1b..39374bae4bea4 100644
@@ -44,6 +44,8 @@ struct vgic_v5_cpu_if;
 #define __KVM_HCALL_MAP(m, ...) __KVM_HCALL_MAP_N(COUNT_ARGS(__VA_ARGS__), m, __VA_ARGS__)
 
 #define __KVM_HCALL_DECL(t, a)	t a
+#define __KVM_HCALL_LONG(t, a)	unsigned long a
+#define __KVM_HCALL_CAST(t, a)	(__force t) a
 #define __KVM_HCALL_ARGS(t, a)	a
 
 #ifndef __KVM_NVHE_HYPERVISOR__
@@ -127,10 +129,19 @@ struct vgic_v5_cpu_if;
 #define kvm_call_hyp_ret(f, ...) f(__VA_ARGS__)
 #define kvm_call_hyp_nvhe(f, ...) f(__VA_ARGS__)
 
-#define DECLARE_KVM_HOST_HCALL(ret, name, ...)
-#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)
-#define DECLARE_KVM_HOST_HCALL0(ret, name)
-#define DECLARE_KVM_HOST_HCALL0_VOID(name)
+/*
+ * At EL2 each declaration emits the canonical signature of the hypercall,
+ * which DEFINE_KVM_HOST_HCALL() in hyp-main.c checks the handler
+ * definition against.
+ */
+#define DECLARE_KVM_HOST_HCALL(ret, name, ...)				\
+	typedef ret kvm_host_hcall_sig_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__));
+#define DECLARE_KVM_HOST_HCALL_VOID(name, ...)				\
+	typedef void kvm_host_hcall_sig_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__));
+#define DECLARE_KVM_HOST_HCALL0(ret, name)				\
+	typedef ret kvm_host_hcall_sig_##name(void);
+#define DECLARE_KVM_HOST_HCALL0_VOID(name)				\
+	typedef void kvm_host_hcall_sig_##name(void);
 #endif /* __KVM_NVHE_HYPERVISOR__ */
 
 /* Hypercalls that are unavailable once pKVM has finalised. */
arch/arm64/kvm/hyp/nvhe/hyp-main.c +31 -0
index 23cb4313c60a2..6986ce55fd9ef 100644
@@ -24,6 +24,63 @@
 
 DEFINE_PER_CPU(struct kvm_nvhe_init_params, kvm_init_params);
 
+/*
+ * Define a hypercall handler: handle_<name> unmarshals the arguments from
+ * the host context and hands them, correctly typed, to the body that
+ * follows the macro. The parameter list is type-checked against the
+ * signature declared in <asm/kvm_hcall.h>, so the handler cannot drift
+ * from what the typed caller stubs marshal in. Modelled on the syscall
+ * wrappers.
+ */
+/* Truncate the fixed list of argument registers to the declared signature. */
+#define KVM_HOST_HCALL_REGS(...)					\
+	__KVM_HCALL_MAP_N(COUNT_ARGS(__VA_ARGS__), __KVM_HCALL_ARGS	\
+		,, cpu_reg(host_ctxt, 1),, cpu_reg(host_ctxt, 2)	\
+		,, cpu_reg(host_ctxt, 3),, cpu_reg(host_ctxt, 4)	\
+		,, cpu_reg(host_ctxt, 5),, cpu_reg(host_ctxt, 6))
+
+#define DEFINE_KVM_HOST_HCALL(ret, name, ...)				\
+	static kvm_host_hcall_sig_##name __do_##name;			\
+	static __always_inline						\
+	ret __se_##name(__KVM_HCALL_MAP(__KVM_HCALL_LONG, __VA_ARGS__))	\
+	{								\
+		return __do_##name(__KVM_HCALL_MAP(__KVM_HCALL_CAST, __VA_ARGS__)); \
+	}								\
+	static void handle_##name(struct kvm_cpu_context *host_ctxt)	\
+	{								\
+		cpu_reg(host_ctxt, 1) = __se_##name(KVM_HOST_HCALL_REGS(__VA_ARGS__)); \
+	}								\
+	static ret __do_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__))
+
+#define DEFINE_KVM_HOST_HCALL_VOID(name, ...)				\
+	static kvm_host_hcall_sig_##name __do_##name;			\
+	static __always_inline						\

arch/arm64/kvm/hyp/nvhe/hyp-main.c line 67

Quoted 10 lines
arch/arm64/kvm/hyp/nvhe/hyp-main.c +10 -0
+	void __se_##name(__KVM_HCALL_MAP(__KVM_HCALL_LONG, __VA_ARGS__)) \
+	{								\
+		__do_##name(__KVM_HCALL_MAP(__KVM_HCALL_CAST, __VA_ARGS__)); \
+	}								\
+	static void handle_##name(struct kvm_cpu_context *host_ctxt)	\
+	{								\
+		__se_##name(KVM_HOST_HCALL_REGS(__VA_ARGS__));		\
+	}								\
+	static void __do_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__))
+

I've also dropped this with the following hacks. The set_cpu_reg() stuff isn't brilliant, and requires a single word type. But I find the overall scheme less invasive.

WDYT?

	M.
arch/arm64/kvm/hyp/nvhe/hyp-main.c +31 -46
index f8ea1661b3166..0d5fa6432461d 100644
@@ -39,6 +39,12 @@ DEFINE_PER_CPU(struct kvm_nvhe_init_params, kvm_init_params);
 		,, cpu_reg(host_ctxt, 3),, cpu_reg(host_ctxt, 4)	\
 		,, cpu_reg(host_ctxt, 5),, cpu_reg(host_ctxt, 6))
 
+#define set_cpu_reg_ulong(ctxt, r, v)	{ cpu_reg(ctxt, r) = v; }
+#define set_cpu_reg_u64(ctxt, r, v)	{ cpu_reg(ctxt, r) = v; }
+#define set_cpu_reg_int(ctxt, r, v)	{ cpu_reg(ctxt, r) = v; }
+#define set_cpu_reg_void(ctxt, r, v)	{ v; }
+#define set_cpu_reg(ctxt, r, t, v)	set_cpu_reg_##t(ctxt, r, v)
+
 #define DEFINE_KVM_HOST_HCALL(ret, name, ...)				\
 	static kvm_host_hcall_sig_##name __do_##name;			\
 	static __always_inline						\
@@ -48,39 +54,18 @@ DEFINE_PER_CPU(struct kvm_nvhe_init_params, kvm_init_params);
 	}								\
 	static void handle_##name(struct kvm_cpu_context *host_ctxt)	\
 	{								\
-		cpu_reg(host_ctxt, 1) = __se_##name(KVM_HOST_HCALL_REGS(__VA_ARGS__)); \
+		set_cpu_reg(host_ctxt, 1, ret, __se_##name(KVM_HOST_HCALL_REGS(__VA_ARGS__))); \
 	}								\
 	static ret __do_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__))
 
-#define DEFINE_KVM_HOST_HCALL_VOID(name, ...)				\
-	static kvm_host_hcall_sig_##name __do_##name;			\
-	static __always_inline						\
-	void __se_##name(__KVM_HCALL_MAP(__KVM_HCALL_LONG, __VA_ARGS__)) \
-	{								\
-		__do_##name(__KVM_HCALL_MAP(__KVM_HCALL_CAST, __VA_ARGS__)); \
-	}								\
-	static void handle_##name(struct kvm_cpu_context *host_ctxt)	\
-	{								\
-		__se_##name(KVM_HOST_HCALL_REGS(__VA_ARGS__));		\
-	}								\
-	static void __do_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__))
-
 #define DEFINE_KVM_HOST_HCALL0(ret, name)				\
 	static kvm_host_hcall_sig_##name __do_##name;			\
 	static void handle_##name(struct kvm_cpu_context *host_ctxt)	\
 	{								\
-		cpu_reg(host_ctxt, 1) = __do_##name();			\
+		set_cpu_reg(host_ctxt, 1, ret, __do_##name());		\
 	}								\
 	static ret __do_##name(void)
 
-#define DEFINE_KVM_HOST_HCALL0_VOID(name)				\
-	static kvm_host_hcall_sig_##name __do_##name;			\
-	static void handle_##name(struct kvm_cpu_context *host_ctxt)	\
-	{								\
-		__do_##name();						\
-	}								\
-	static void __do_##name(void)
-
 /* Number of implemented GICv3 LRs. Used by flush_hyp_vcpu(). */
 unsigned int hyp_gicv3_nr_lr;
 
@@ -242,7 +227,7 @@ static void sync_hyp_vcpu(struct pkvm_hyp_vcpu *hyp_vcpu)
 		host_cpu_if->vgic_lr[i] = hyp_cpu_if->vgic_lr[i];
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__pkvm_vcpu_load,
+DEFINE_KVM_HOST_HCALL(void, __pkvm_vcpu_load,
 	pkvm_handle_t, handle, unsigned int, vcpu_idx, u64, hcr_el2)
 {
 	struct pkvm_hyp_vcpu *hyp_vcpu;
@@ -261,7 +246,7 @@ DEFINE_KVM_HOST_HCALL_VOID(__pkvm_vcpu_load,
 	}
 }
 
-DEFINE_KVM_HOST_HCALL0_VOID(__pkvm_vcpu_put)
+DEFINE_KVM_HOST_HCALL0(void, __pkvm_vcpu_put)
 {
 	struct pkvm_hyp_vcpu *hyp_vcpu = pkvm_get_loaded_hyp_vcpu();
 
@@ -421,42 +406,42 @@ DEFINE_KVM_HOST_HCALL(int, __pkvm_host_mkyoung_guest,
 	return __pkvm_host_mkyoung_guest(gfn, hyp_vcpu);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_adjust_pc,
+DEFINE_KVM_HOST_HCALL(void, __kvm_adjust_pc,
 	struct kvm_vcpu __kern *, vcpu)
 {
 	__kvm_adjust_pc(kern_hyp_va_host(vcpu));
 }
 
-DEFINE_KVM_HOST_HCALL0_VOID(__kvm_flush_vm_context)
+DEFINE_KVM_HOST_HCALL0(void, __kvm_flush_vm_context)
 {
 	__kvm_flush_vm_context();
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa,
+DEFINE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_ipa,
 	struct kvm_s2_mmu __kern *, mmu, phys_addr_t, ipa, int, level)
 {
 	__kvm_tlb_flush_vmid_ipa(kern_hyp_va_host(mmu), ipa, level);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa_nsh,
+DEFINE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_ipa_nsh,
 	struct kvm_s2_mmu __kern *, mmu, phys_addr_t, ipa, int, level)
 {
 	__kvm_tlb_flush_vmid_ipa_nsh(kern_hyp_va_host(mmu), ipa, level);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_range,
+DEFINE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_range,
 	struct kvm_s2_mmu __kern *, mmu, phys_addr_t, start, unsigned long, pages)
 {
 	__kvm_tlb_flush_vmid_range(kern_hyp_va_host(mmu), start, pages);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid,
+DEFINE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid,
 	struct kvm_s2_mmu __kern *, mmu)
 {
 	__kvm_tlb_flush_vmid(kern_hyp_va_host(mmu));
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__pkvm_tlb_flush_vmid,
+DEFINE_KVM_HOST_HCALL(void, __pkvm_tlb_flush_vmid,
 	pkvm_handle_t, handle)
 {
 	struct pkvm_hyp_vm *hyp_vm = get_np_pkvm_hyp_vm(handle);
@@ -468,19 +453,19 @@ DEFINE_KVM_HOST_HCALL_VOID(__pkvm_tlb_flush_vmid,
 	put_pkvm_hyp_vm(hyp_vm);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_flush_cpu_context,
+DEFINE_KVM_HOST_HCALL(void, __kvm_flush_cpu_context,
 	struct kvm_s2_mmu __kern *, mmu)
 {
 	__kvm_flush_cpu_context(kern_hyp_va_host(mmu));
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_timer_set_cntvoff,
+DEFINE_KVM_HOST_HCALL(void, __kvm_timer_set_cntvoff,
 	u64, cntvoff)
 {
 	__kvm_timer_set_cntvoff(cntvoff);
 }
 
-DEFINE_KVM_HOST_HCALL0_VOID(__kvm_enable_ssbs)
+DEFINE_KVM_HOST_HCALL0(void, __kvm_enable_ssbs)
 {
 	u64 tmp;
 
@@ -494,18 +479,18 @@ DEFINE_KVM_HOST_HCALL0(u64, __vgic_v3_get_gic_config)
 	return __vgic_v3_get_gic_config();
 }
 
-DEFINE_KVM_HOST_HCALL0_VOID(__vgic_v3_init_lrs)
+DEFINE_KVM_HOST_HCALL0(void, __vgic_v3_init_lrs)
 {
 	__vgic_v3_init_lrs();
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__vgic_v3_save_aprs,
+DEFINE_KVM_HOST_HCALL(void, __vgic_v3_save_aprs,
 	struct vgic_v3_cpu_if __kern *, cpu_if)
 {
 	__vgic_v3_save_aprs(kern_hyp_va_host(cpu_if));
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__vgic_v3_restore_vmcr_aprs,
+DEFINE_KVM_HOST_HCALL(void, __vgic_v3_restore_vmcr_aprs,
 	struct vgic_v3_cpu_if __kern *, cpu_if)
 {
 	__vgic_v3_restore_vmcr_aprs(kern_hyp_va_host(cpu_if));
@@ -541,7 +526,7 @@ DEFINE_KVM_HOST_HCALL(int, __pkvm_host_unshare_hyp,
 	return __pkvm_host_unshare_hyp(pfn);
 }
 
-DEFINE_KVM_HOST_HCALL(unsigned long, __pkvm_create_private_mapping,
+DEFINE_KVM_HOST_HCALL(ulong, __pkvm_create_private_mapping,
 	phys_addr_t, phys, size_t, size, u64, prot)
 {
 	/*
@@ -554,7 +539,7 @@ DEFINE_KVM_HOST_HCALL(unsigned long, __pkvm_create_private_mapping,
 	 * Instead pass the allocation address as the return value (or return
 	 * ERR_PTR() on failure).
 	 */
-	unsigned long haddr;
+	ulong haddr;
 	int err = __pkvm_create_private_mapping(phys, size, prot, &haddr);
 
 	if (err)
@@ -573,7 +558,7 @@ DEFINE_KVM_HOST_HCALL0(int, __pkvm_reserve_vm)
 	return __pkvm_reserve_vm();
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__pkvm_unreserve_vm,
+DEFINE_KVM_HOST_HCALL(void, __pkvm_unreserve_vm,
 	pkvm_handle_t, handle)
 {
 	__pkvm_unreserve_vm(handle);
@@ -630,7 +615,7 @@ DEFINE_KVM_HOST_HCALL(int, __tracing_load,
 	return __tracing_load(desc_hva, desc_size);
 }
 
-DEFINE_KVM_HOST_HCALL0_VOID(__tracing_unload)
+DEFINE_KVM_HOST_HCALL0(void, __tracing_unload)
 {
 	__tracing_unload();
 }
@@ -647,7 +632,7 @@ DEFINE_KVM_HOST_HCALL(int, __tracing_swap_reader,
 	return __tracing_swap_reader(cpu);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__tracing_update_clock,
+DEFINE_KVM_HOST_HCALL(void, __tracing_update_clock,
 	u32, mult, u32, shift, u64, epoch_ns, u64, epoch_cyc)
 {
 	__tracing_update_clock(mult, shift, epoch_ns, epoch_cyc);
@@ -665,19 +650,19 @@ DEFINE_KVM_HOST_HCALL(int, __tracing_enable_event,
 	return __tracing_enable_event(id, enable);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__tracing_write_event,
+DEFINE_KVM_HOST_HCALL(void, __tracing_write_event,
 	u64, id)
 {
 	trace_selftest(id);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__vgic_v5_save_apr,
+DEFINE_KVM_HOST_HCALL(void, __vgic_v5_save_apr,
 	struct vgic_v5_cpu_if __kern *, cpu_if)
 {
 	__vgic_v5_save_apr(kern_hyp_va_host(cpu_if));
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__vgic_v5_restore_vmcr_apr,
+DEFINE_KVM_HOST_HCALL(void, __vgic_v5_restore_vmcr_apr,
 	struct vgic_v5_cpu_if __kern *, cpu_if)
 {
 	__vgic_v5_restore_vmcr_apr(kern_hyp_va_host(cpu_if));
Signature · 1 line
Without deviation from the norm, progress is not possible.
author reviewer
#14 lore raw

Re: [PATCH v2 10/11] KVM: arm64: nVHE: Check hypercall handlers against the declared ABI

On Mon, 3 Aug 2026 at 19:03, Marc Zyngier <[email protected]> wrote:
...

Quoted 6 lines

I've also dropped this with the following hacks. The set_cpu_reg() stuff isn't brilliant, and requires a single word type. But I find the overall scheme less invasive.

WDYT?

Works, and hyp-main.nvhe.o comes out byte identical. I did look for a way to dispatch on void without the type table, but _Generic doesn't take an incomplete type and __builtin_choose_expr type-checks both arms on gcc and clang, so I don't think there's a better option.

One nit: the declaration in kvm_hcall.h still says "unsigned long" while the definition now says "ulong". Could we make both ulong?

I'm happy to respin with both of these, or would you like to fold them in?

Cheers,
/fuad

Quoted 246 lines
        M.
arch/arm64/kvm/hyp/nvhe/hyp-main.c +31 -47
index f8ea1661b3166..0d5fa6432461d 100644
@@ -39,6 +39,12 @@ DEFINE_PER_CPU(struct kvm_nvhe_init_params, kvm_init_params);
                ,, cpu_reg(host_ctxt, 3),, cpu_reg(host_ctxt, 4)        \
                ,, cpu_reg(host_ctxt, 5),, cpu_reg(host_ctxt, 6))
 
+#define set_cpu_reg_ulong(ctxt, r, v)  { cpu_reg(ctxt, r) = v; }
+#define set_cpu_reg_u64(ctxt, r, v)    { cpu_reg(ctxt, r) = v; }
+#define set_cpu_reg_int(ctxt, r, v)    { cpu_reg(ctxt, r) = v; }
+#define set_cpu_reg_void(ctxt, r, v)   { v; }
+#define set_cpu_reg(ctxt, r, t, v)     set_cpu_reg_##t(ctxt, r, v)
+
 #define DEFINE_KVM_HOST_HCALL(ret, name, ...)                          \
        static kvm_host_hcall_sig_##name __do_##name;                   \
        static __always_inline                                          \
@@ -48,39 +54,18 @@ DEFINE_PER_CPU(struct kvm_nvhe_init_params, kvm_init_params);
        }                                                               \
        static void handle_##name(struct kvm_cpu_context *host_ctxt)    \
        {                                                               \
-               cpu_reg(host_ctxt, 1) = __se_##name(KVM_HOST_HCALL_REGS(__VA_ARGS__)); \
+               set_cpu_reg(host_ctxt, 1, ret, __se_##name(KVM_HOST_HCALL_REGS(__VA_ARGS__))); \
        }                                                               \
        static ret __do_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__))
 
-#define DEFINE_KVM_HOST_HCALL_VOID(name, ...)                          \
-       static kvm_host_hcall_sig_##name __do_##name;                   \
-       static __always_inline                                          \
-       void __se_##name(__KVM_HCALL_MAP(__KVM_HCALL_LONG, __VA_ARGS__)) \
-       {                                                               \
-               __do_##name(__KVM_HCALL_MAP(__KVM_HCALL_CAST, __VA_ARGS__)); \
-       }                                                               \
-       static void handle_##name(struct kvm_cpu_context *host_ctxt)    \
-       {                                                               \
-               __se_##name(KVM_HOST_HCALL_REGS(__VA_ARGS__));          \
-       }                                                               \
-       static void __do_##name(__KVM_HCALL_MAP(__KVM_HCALL_DECL, __VA_ARGS__))
-
 #define DEFINE_KVM_HOST_HCALL0(ret, name)                              \
        static kvm_host_hcall_sig_##name __do_##name;                   \
        static void handle_##name(struct kvm_cpu_context *host_ctxt)    \
        {                                                               \
-               cpu_reg(host_ctxt, 1) = __do_##name();                  \
+               set_cpu_reg(host_ctxt, 1, ret, __do_##name());          \
        }                                                               \
        static ret __do_##name(void)
 
-#define DEFINE_KVM_HOST_HCALL0_VOID(name)                              \
-       static kvm_host_hcall_sig_##name __do_##name;                   \
-       static void handle_##name(struct kvm_cpu_context *host_ctxt)    \
-       {                                                               \
-               __do_##name();                                          \
-       }                                                               \
-       static void __do_##name(void)
-
 /* Number of implemented GICv3 LRs. Used by flush_hyp_vcpu(). */
 unsigned int hyp_gicv3_nr_lr;
 
@@ -242,7 +227,7 @@ static void sync_hyp_vcpu(struct pkvm_hyp_vcpu *hyp_vcpu)
                host_cpu_if->vgic_lr[i] = hyp_cpu_if->vgic_lr[i];
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__pkvm_vcpu_load,
+DEFINE_KVM_HOST_HCALL(void, __pkvm_vcpu_load,
        pkvm_handle_t, handle, unsigned int, vcpu_idx, u64, hcr_el2)
 {
        struct pkvm_hyp_vcpu *hyp_vcpu;
@@ -261,7 +246,7 @@ DEFINE_KVM_HOST_HCALL_VOID(__pkvm_vcpu_load,
        }
 }
 
-DEFINE_KVM_HOST_HCALL0_VOID(__pkvm_vcpu_put)
+DEFINE_KVM_HOST_HCALL0(void, __pkvm_vcpu_put)
 {
        struct pkvm_hyp_vcpu *hyp_vcpu = pkvm_get_loaded_hyp_vcpu();
 
@@ -421,42 +406,42 @@ DEFINE_KVM_HOST_HCALL(int, __pkvm_host_mkyoung_guest,
        return __pkvm_host_mkyoung_guest(gfn, hyp_vcpu);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_adjust_pc,
+DEFINE_KVM_HOST_HCALL(void, __kvm_adjust_pc,
        struct kvm_vcpu __kern *, vcpu)
 {
        __kvm_adjust_pc(kern_hyp_va_host(vcpu));
 }
 
-DEFINE_KVM_HOST_HCALL0_VOID(__kvm_flush_vm_context)
+DEFINE_KVM_HOST_HCALL0(void, __kvm_flush_vm_context)
 {
        __kvm_flush_vm_context();
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa,
+DEFINE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_ipa,
        struct kvm_s2_mmu __kern *, mmu, phys_addr_t, ipa, int, level)
 {
        __kvm_tlb_flush_vmid_ipa(kern_hyp_va_host(mmu), ipa, level);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa_nsh,
+DEFINE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_ipa_nsh,
        struct kvm_s2_mmu __kern *, mmu, phys_addr_t, ipa, int, level)
 {
        __kvm_tlb_flush_vmid_ipa_nsh(kern_hyp_va_host(mmu), ipa, level);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_range,
+DEFINE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid_range,
        struct kvm_s2_mmu __kern *, mmu, phys_addr_t, start, unsigned long, pages)
 {
        __kvm_tlb_flush_vmid_range(kern_hyp_va_host(mmu), start, pages);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid,
+DEFINE_KVM_HOST_HCALL(void, __kvm_tlb_flush_vmid,
        struct kvm_s2_mmu __kern *, mmu)
 {
        __kvm_tlb_flush_vmid(kern_hyp_va_host(mmu));
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__pkvm_tlb_flush_vmid,
+DEFINE_KVM_HOST_HCALL(void, __pkvm_tlb_flush_vmid,
        pkvm_handle_t, handle)
 {
        struct pkvm_hyp_vm *hyp_vm = get_np_pkvm_hyp_vm(handle);
@@ -468,19 +453,19 @@ DEFINE_KVM_HOST_HCALL_VOID(__pkvm_tlb_flush_vmid,
        put_pkvm_hyp_vm(hyp_vm);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_flush_cpu_context,
+DEFINE_KVM_HOST_HCALL(void, __kvm_flush_cpu_context,
        struct kvm_s2_mmu __kern *, mmu)
 {
        __kvm_flush_cpu_context(kern_hyp_va_host(mmu));
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__kvm_timer_set_cntvoff,
+DEFINE_KVM_HOST_HCALL(void, __kvm_timer_set_cntvoff,
        u64, cntvoff)
 {
        __kvm_timer_set_cntvoff(cntvoff);
 }
 
-DEFINE_KVM_HOST_HCALL0_VOID(__kvm_enable_ssbs)
+DEFINE_KVM_HOST_HCALL0(void, __kvm_enable_ssbs)
 {
        u64 tmp;
 
@@ -494,18 +479,18 @@ DEFINE_KVM_HOST_HCALL0(u64, __vgic_v3_get_gic_config)
        return __vgic_v3_get_gic_config();
 }
 
-DEFINE_KVM_HOST_HCALL0_VOID(__vgic_v3_init_lrs)
+DEFINE_KVM_HOST_HCALL0(void, __vgic_v3_init_lrs)
 {
        __vgic_v3_init_lrs();
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__vgic_v3_save_aprs,
+DEFINE_KVM_HOST_HCALL(void, __vgic_v3_save_aprs,
        struct vgic_v3_cpu_if __kern *, cpu_if)
 {
        __vgic_v3_save_aprs(kern_hyp_va_host(cpu_if));
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__vgic_v3_restore_vmcr_aprs,
+DEFINE_KVM_HOST_HCALL(void, __vgic_v3_restore_vmcr_aprs,
        struct vgic_v3_cpu_if __kern *, cpu_if)
 {
        __vgic_v3_restore_vmcr_aprs(kern_hyp_va_host(cpu_if));
@@ -541,7 +526,7 @@ DEFINE_KVM_HOST_HCALL(int, __pkvm_host_unshare_hyp,
        return __pkvm_host_unshare_hyp(pfn);
 }
 
-DEFINE_KVM_HOST_HCALL(unsigned long, __pkvm_create_private_mapping,
+DEFINE_KVM_HOST_HCALL(ulong, __pkvm_create_private_mapping,
        phys_addr_t, phys, size_t, size, u64, prot)
 {
        /*
@@ -554,7 +539,7 @@ DEFINE_KVM_HOST_HCALL(unsigned long, __pkvm_create_private_mapping,
         * Instead pass the allocation address as the return value (or return
         * ERR_PTR() on failure).
         */
-       unsigned long haddr;
+       ulong haddr;
        int err = __pkvm_create_private_mapping(phys, size, prot, &haddr);
 
        if (err)
@@ -573,7 +558,7 @@ DEFINE_KVM_HOST_HCALL0(int, __pkvm_reserve_vm)
        return __pkvm_reserve_vm();
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__pkvm_unreserve_vm,
+DEFINE_KVM_HOST_HCALL(void, __pkvm_unreserve_vm,
        pkvm_handle_t, handle)
 {
        __pkvm_unreserve_vm(handle);
@@ -630,7 +615,7 @@ DEFINE_KVM_HOST_HCALL(int, __tracing_load,
        return __tracing_load(desc_hva, desc_size);
 }
 
-DEFINE_KVM_HOST_HCALL0_VOID(__tracing_unload)
+DEFINE_KVM_HOST_HCALL0(void, __tracing_unload)
 {
        __tracing_unload();
 }
@@ -647,7 +632,7 @@ DEFINE_KVM_HOST_HCALL(int, __tracing_swap_reader,
        return __tracing_swap_reader(cpu);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__tracing_update_clock,
+DEFINE_KVM_HOST_HCALL(void, __tracing_update_clock,
        u32, mult, u32, shift, u64, epoch_ns, u64, epoch_cyc)
 {
        __tracing_update_clock(mult, shift, epoch_ns, epoch_cyc);
@@ -665,19 +650,19 @@ DEFINE_KVM_HOST_HCALL(int, __tracing_enable_event,
        return __tracing_enable_event(id, enable);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__tracing_write_event,
+DEFINE_KVM_HOST_HCALL(void, __tracing_write_event,
        u64, id)
 {
        trace_selftest(id);
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__vgic_v5_save_apr,
+DEFINE_KVM_HOST_HCALL(void, __vgic_v5_save_apr,
        struct vgic_v5_cpu_if __kern *, cpu_if)
 {
        __vgic_v5_save_apr(kern_hyp_va_host(cpu_if));
 }
 
-DEFINE_KVM_HOST_HCALL_VOID(__vgic_v5_restore_vmcr_apr,
+DEFINE_KVM_HOST_HCALL(void, __vgic_v5_restore_vmcr_apr,
        struct vgic_v5_cpu_if __kern *, cpu_if)
 {
        __vgic_v5_restore_vmcr_apr(kern_hyp_va_host(cpu_if));
 
--

Without deviation from the norm, progress is not possible.

maintainer
#15 lore raw

Re: [PATCH v2 10/11] KVM: arm64: nVHE: Check hypercall handlers against the declared ABI

Quoted 10 lines · Fuad Tabba

On Mon, 3 Aug 2026 at 19:03, Marc Zyngier <[email protected]> wrote:
...

Quoted 6 lines

I've also dropped this with the following hacks. The set_cpu_reg() stuff isn't brilliant, and requires a single word type. But I find the overall scheme less invasive.

WDYT?

Quoted 7 lines

Works, and hyp-main.nvhe.o comes out byte identical. I did look for a way to dispatch on void without the type table, but _Generic doesn't take an incomplete type and __builtin_choose_expr type-checks both arms on gcc and clang, so I don't think there's a better option.

One nit: the declaration in kvm_hcall.h still says "unsigned long" while the definition now says "ulong". Could we make both ulong?

Yeah, that's an oversight. I don't like the ulong stuff at all, but I don't see how to do this without it.

Quoted 2 lines

I'm happy to respin with both of these, or would you like to fold them in?

Oliver is in charge of 7.3, so I'll let him reply on this.

Thanks,

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
author reviewer
#16 lore raw

Re: [PATCH v2 10/11] KVM: arm64: nVHE: Check hypercall handlers against the declared ABI

Hi Marc,

Quoted 3 lines · Marc Zyngier
Quoted 1 line

I'm happy to respin with both of these, or would you like to fold them in?

Oliver is in charge of 7.3, so I'll let him reply on this.

I'll respin in that case, make life easier for Oliver, since he doesn't have them applied and they do conflict slightly with patch 11.

Cheers,
/fuad

Quoted 6 lines

Thanks,

        M.

--
Without deviation from the norm, progress is not possible.

author reviewer
#17 lore raw

PATCH v2 11/11 KVM: arm64: Tag host-VA hypercall parameters __kern

In reply to Fuad Tabba

The nVHE hypervisor takes host virtual addresses as hypercall arguments and translates each with kern_hyp_va() before use. Nothing marks them as host-owned, so dereferencing one untranslated at EL2 - a recurring bug class - is invisible to the compiler.

Add a __kern sparse address space, active only for EL2 code, and tag the host-VA parameters in the hypercall declarations. kern_hyp_va_host() is the only sanctioned unwrap: it translates the address, preserves the pointee type (stripped of qualifiers, as with the percpu accessors) and drops the tag with a __force cast, so an untranslated host VA fails sparse. The tag flows from the shared declaration into the generated handler and on into the donated-memory and tracing-descriptor helpers, so a handler cannot extract a host VA without it. Host code sees plain pointers, and the tag is checker-only: no code is generated.

---
 arch/arm64/include/asm/kvm_hcall.h      | 43 ++++++++++++-------
 arch/arm64/include/asm/kvm_mmu.h        | 10 +++++
 arch/arm64/kvm/hyp/include/nvhe/pkvm.h  |  6 ++-
 arch/arm64/kvm/hyp/include/nvhe/trace.h |  5 ++-
 arch/arm64/kvm/hyp/nvhe/hyp-main.c      | 57 +++++++++++++------------
 arch/arm64/kvm/hyp/nvhe/pkvm.c          | 11 ++---
 arch/arm64/kvm/hyp/nvhe/trace.c         |  4 +-
 7 files changed, 82 insertions(+), 54 deletions(-)
arch/arm64/include/asm/kvm_hcall.h +28 -15
index 39374bae4bea4..3958396a83345 100644
@@ -28,6 +28,18 @@ struct kvm_vcpu;
 struct vgic_v3_cpu_if;
 struct vgic_v5_cpu_if;
 
+/*
+ * A host VA carried by a hypercall argument. At EL2 such a pointer must not
+ * be dereferenced until it is translated with kern_hyp_va_host(); sparse
+ * flags any use that skips the translation. The tag describes the EL2 view
+ * only: the host dereferences its own VAs freely.
+ */
+#if defined(__KVM_NVHE_HYPERVISOR__) && defined(__CHECKER__)
+#define __kern	__attribute__((noderef, address_space(__kern)))
+#else
+#define __kern
+#endif
+
 /*
  * Hypercall signatures are declared as (type, name) argument pairs.
  * __KVM_HCALL_MAP() applies a macro to each pair, in the mold of __MAP()
@@ -160,24 +172,24 @@ DECLARE_KVM_HOST_HCALL0(int, __pkvm_prot_finalize)
 
 /* Hypercalls that are always available and common to [nh]VHE/pKVM. */
 DECLARE_KVM_HOST_HCALL_VOID(__kvm_adjust_pc,
-	struct kvm_vcpu *, vcpu)
+	struct kvm_vcpu __kern *, vcpu)
 DECLARE_KVM_HOST_HCALL(int, __kvm_vcpu_run,
-	struct kvm_vcpu *, vcpu)
+	struct kvm_vcpu __kern *, vcpu)
 DECLARE_KVM_HOST_HCALL0_VOID(__kvm_flush_vm_context)
 DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa,
-	struct kvm_s2_mmu *, mmu, phys_addr_t, ipa, int, level)
+	struct kvm_s2_mmu __kern *, mmu, phys_addr_t, ipa, int, level)
 DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_ipa_nsh,
-	struct kvm_s2_mmu *, mmu, phys_addr_t, ipa, int, level)
+	struct kvm_s2_mmu __kern *, mmu, phys_addr_t, ipa, int, level)
 DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid,
-	struct kvm_s2_mmu *, mmu)
+	struct kvm_s2_mmu __kern *, mmu)
 DECLARE_KVM_HOST_HCALL_VOID(__kvm_tlb_flush_vmid_range,
-	struct kvm_s2_mmu *, mmu, phys_addr_t, start, unsigned long, pages)
+	struct kvm_s2_mmu __kern *, mmu, phys_addr_t, start, unsigned long, pages)
 DECLARE_KVM_HOST_HCALL_VOID(__kvm_flush_cpu_context,
-	struct kvm_s2_mmu *, mmu)
+	struct kvm_s2_mmu __kern *, mmu)
 DECLARE_KVM_HOST_HCALL_VOID(__kvm_timer_set_cntvoff,
 	u64, cntvoff)
 DECLARE_KVM_HOST_HCALL(int, __tracing_load,
-	void *, desc_hva, size_t, desc_size)
+	void __kern *, desc_hva, size_t, desc_size)
 DECLARE_KVM_HOST_HCALL0_VOID(__tracing_unload)
 DECLARE_KVM_HOST_HCALL(int, __tracing_enable,
 	bool, enable)
@@ -192,13 +204,13 @@ DECLARE_KVM_HOST_HCALL(int, __tracing_enable_event,
 DECLARE_KVM_HOST_HCALL_VOID(__tracing_write_event,
 	u64, id)
 DECLARE_KVM_HOST_HCALL_VOID(__vgic_v3_save_aprs,
-	struct vgic_v3_cpu_if *, cpu_if)
+	struct vgic_v3_cpu_if __kern *, cpu_if)
 DECLARE_KVM_HOST_HCALL_VOID(__vgic_v3_restore_vmcr_aprs,
-	struct vgic_v3_cpu_if *, cpu_if)
+	struct vgic_v3_cpu_if __kern *, cpu_if)
 DECLARE_KVM_HOST_HCALL_VOID(__vgic_v5_save_apr,
-	struct vgic_v5_cpu_if *, cpu_if)
+	struct vgic_v5_cpu_if __kern *, cpu_if)
 DECLARE_KVM_HOST_HCALL_VOID(__vgic_v5_restore_vmcr_apr,
-	struct vgic_v5_cpu_if *, cpu_if)
+	struct vgic_v5_cpu_if __kern *, cpu_if)
 
 /* Hypercalls that are available only when pKVM has finalised. */
 DECLARE_KVM_HOST_HCALL(int, __pkvm_host_share_hyp,
@@ -223,10 +235,11 @@ DECLARE_KVM_HOST_HCALL0(int, __pkvm_reserve_vm)
 DECLARE_KVM_HOST_HCALL_VOID(__pkvm_unreserve_vm,
 	pkvm_handle_t, handle)
 DECLARE_KVM_HOST_HCALL(int, __pkvm_init_vm,
-	struct kvm *, host_kvm, void *, vm_hva, void *, pgd_hva)
+	struct kvm __kern *, host_kvm, void __kern *, vm_hva,
+	void __kern *, pgd_hva)
 DECLARE_KVM_HOST_HCALL(int, __pkvm_init_vcpu,
-	pkvm_handle_t, handle, struct kvm_vcpu *, host_vcpu,
-	void *, vcpu_hva)
+	pkvm_handle_t, handle, struct kvm_vcpu __kern *, host_vcpu,
+	void __kern *, vcpu_hva)
 DECLARE_KVM_HOST_HCALL0(int, __pkvm_vcpu_in_poison_fault)
 DECLARE_KVM_HOST_HCALL(int, __pkvm_force_reclaim_guest_page,
 	phys_addr_t, phys)
arch/arm64/include/asm/kvm_mmu.h +10 -0
index 6eae7e7e2a684..57f65257bb56d 100644
@@ -7,6 +7,8 @@
 #ifndef __ARM64_KVM_MMU_H__
 #define __ARM64_KVM_MMU_H__
 
+#include <linux/compiler.h>
+
 #include <asm/page.h>
 #include <asm/memory.h>
 #include <asm/mmu.h>
@@ -140,6 +142,14 @@ static __always_inline unsigned long __kern_hyp_va(unsigned long v)
 
 #define kern_hyp_va(v) 	((typeof(v))(__kern_hyp_va((unsigned long)(v))))
 
+/*
+ * Translate a __kern-tagged host VA, dropping the tag: the only sanctioned
+ * unwrap. Translation only, no ownership or bounds validation; the result
+ * carries the pointee type stripped of the tag and of any cv-qualifiers.
+ */
+#define kern_hyp_va_host(v)						\
+	((TYPEOF_UNQUAL(*(v)) *)__kern_hyp_va((unsigned long)(__force void *)(v)))
+
 extern u32 __hyp_va_bits;
 
 /*
arch/arm64/kvm/hyp/include/nvhe/pkvm.h +4 -2
index 2643a1a819668..c1171451e1be7 100644
@@ -7,6 +7,7 @@
 #ifndef __ARM64_KVM_NVHE_PKVM_H__
 #define __ARM64_KVM_NVHE_PKVM_H__
 
+#include <asm/kvm_hcall.h>
 #include <asm/kvm_pkvm.h>
 
 #include <nvhe/gfp.h>
@@ -69,9 +70,10 @@ void pkvm_hyp_vm_table_init(void *tbl);
 
 int __pkvm_reserve_vm(void);
 void __pkvm_unreserve_vm(pkvm_handle_t handle);
-int __pkvm_init_vm(struct kvm *host_kvm, void *vm_hva, void *pgd_hva);
+int __pkvm_init_vm(struct kvm *host_kvm, void __kern *vm_hva,
+		   void __kern *pgd_hva);
 int __pkvm_init_vcpu(pkvm_handle_t handle, struct kvm_vcpu *host_vcpu,
-		     void *vcpu_hva);
+		     void __kern *vcpu_hva);
 
 int __pkvm_reclaim_dying_guest_page(pkvm_handle_t handle, u64 gfn);
 int __pkvm_start_teardown_vm(pkvm_handle_t handle);
arch/arm64/kvm/hyp/include/nvhe/trace.h +3 -2
index 4aa36fd76b9e2..c2db9f70ea265 100644
@@ -4,6 +4,7 @@
 
 #include <linux/trace_remote_event.h>
 
+#include <asm/kvm_hcall.h>
 #include <asm/kvm_hyptrace.h>
 
 static inline pid_t __tracing_get_vcpu_pid(struct kvm_cpu_context *host_ctxt)
@@ -46,7 +47,7 @@ static inline pid_t __tracing_get_vcpu_pid(struct kvm_cpu_context *host_ctxt)
 void *tracing_reserve_entry(unsigned long length);
 void tracing_commit_entry(void);
 
-int __tracing_load(void *desc_va, size_t desc_size);
+int __tracing_load(void __kern *desc_va, size_t desc_size);
 void __tracing_unload(void);
 int __tracing_enable(bool enable);
 int __tracing_swap_reader(unsigned int cpu);
@@ -59,7 +60,7 @@ static inline void tracing_commit_entry(void) { }
 #define HYP_EVENT(__name, __proto, __struct, __assign, __printk)      \
 	static inline void trace_##__name(__proto) {}
 
-static inline int __tracing_load(void *desc_va, size_t desc_size) { return -ENODEV; }
+static inline int __tracing_load(void __kern *desc_va, size_t desc_size) { return -ENODEV; }
 static inline void __tracing_unload(void) { }
 static inline int __tracing_enable(bool enable) { return -ENODEV; }
 static inline int __tracing_swap_reader(unsigned int cpu) { return -ENODEV; }
arch/arm64/kvm/hyp/nvhe/hyp-main.c +29 -28

141 lines not on this page · raw message

arch/arm64/kvm/hyp/nvhe/pkvm.c +6 -5
index 205c52535c887..9c33d983058a3 100644
@@ -644,9 +644,9 @@ static size_t pkvm_get_hyp_vm_size(unsigned int nr_vcpus)
 		size_mul(sizeof(struct pkvm_hyp_vcpu *), nr_vcpus));
 }
 
-static void *map_donated_memory_noclear(void *host_va, size_t size)
+static void *map_donated_memory_noclear(void __kern *host_va, size_t size)
 {
-	void *va = kern_hyp_va(host_va);
+	void *va = kern_hyp_va_host(host_va);
 
 	if (!PAGE_ALIGNED(va))
 		return NULL;
@@ -658,7 +658,7 @@ static void *map_donated_memory_noclear(void *host_va, size_t size)
 	return va;
 }
 
-static void *map_donated_memory(void *host_va, size_t size)
+static void *map_donated_memory(void __kern *host_va, size_t size)
 {
 	void *va = map_donated_memory_noclear(host_va, size);
 
@@ -805,7 +805,8 @@ void teardown_selftest_vm(void)
  *
  * Return 0 success, negative error code on failure.
  */
-int __pkvm_init_vm(struct kvm *host_kvm, void *vm_hva, void *pgd_hva)
+int __pkvm_init_vm(struct kvm *host_kvm, void __kern *vm_hva,
+		   void __kern *pgd_hva)
 {
 	struct pkvm_hyp_vm *hyp_vm = NULL;
 	size_t vm_size, pgd_size;
@@ -896,7 +897,7 @@ static int register_hyp_vcpu(struct pkvm_hyp_vm *hyp_vm,
 }
 
 int __pkvm_init_vcpu(pkvm_handle_t handle, struct kvm_vcpu *host_vcpu,
-		     void *vcpu_hva)
+		     void __kern *vcpu_hva)
 {
 	struct pkvm_hyp_vcpu *hyp_vcpu;
 	struct pkvm_hyp_vm *hyp_vm;
arch/arm64/kvm/hyp/nvhe/trace.c +2 -2
index 97203ddd3cf45..4410006321a99 100644
@@ -206,9 +206,9 @@ static bool hyp_trace_desc_is_valid(struct hyp_trace_desc *desc, size_t desc_siz
 	return true;
 }
 
-int __tracing_load(void *desc_hva, size_t desc_size)
+int __tracing_load(void __kern *desc_hva, size_t desc_size)
 {
-	struct hyp_trace_desc *desc = kern_hyp_va(desc_hva);
+	struct hyp_trace_desc *desc = kern_hyp_va_host(desc_hva);
 	int ret;
 
 	ret = __admit_host_mem(desc, desc_size);
Signature · 1 line
2.39.5
#18 lore raw

Re: [PATCH v2 11/11] KVM: arm64: Tag host-VA hypercall parameters __kern

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:

New issues:
- [Medium] The kern_hyp_va_host() macro strips the __kern tag using (__force void *) and returns a plain pointer, undermining the static analysis guarantees for both misapplied unwraps and subsequent TOCTOU bugs.

Pre-existing issues:
- [Critical] Always-on hypercalls (e.g., __vgic_v3_save_aprs, __kvm_adjust_pc) accept host VAs, translate them via kern_hyp_va_host(), and read/write to them without validating physical page ownership, enabling a Confused Deputy arbitrary memory corruption attack. --

--- Patch [11]: [PATCH v2 11/11] KVM: arm64: Tag host-VA hypercall parameters __kern --- commit 0acf480afb506d5122464f1024574511fad649b3
Author: Fuad Tabba <[email protected]>

KVM: arm64: Tag host-VA hypercall parameters __kern

The nVHE hypervisor takes host virtual addresses as hypercall arguments and translates each with kern_hyp_va() before use. This patch adds a __kern sparse address space for EL2 code to tag host-VA parameters and introduces kern_hyp_va_host() to unwrap them.

Quoted 4 lines
arch/arm64/include/asm/kvm_mmu.h +0 -0
index 6eae7e7e2a684..57f65257bb56d 100644

[ ... ]

arch/arm64/include/asm/kvm_mmu.h static __always_inline unsigned long __kern_hyp_va(unsigned long v) · line 151

Quoted 11 lines
arch/arm64/include/asm/kvm_mmu.h +7 -0
@@ -140,6 +142,14 @@ static __always_inline unsigned long __kern_hyp_va(unsigned long v)
 
 #define kern_hyp_va(v) 	((typeof(v))(__kern_hyp_va((unsigned long)(v))))
 
+/*
+ * Translate a __kern-tagged host VA, dropping the tag: the only sanctioned
+ * unwrap. Translation only, no ownership or bounds validation; the result
+ * carries the pointee type stripped of the tag and of any cv-qualifiers.
+ */
+#define kern_hyp_va_host(v)						\
+	((TYPEOF_UNQUAL(*(v)) *)__kern_hyp_va((unsigned long)(__force void *)(v)))

[Severity: Medium]
Since the __force void * cast unconditionally strips all sparse address space information, does this suppress warnings if the macro is accidentally applied to an untagged EL2 private-VA-range pointer?

Additionally, because the returned pointer has no address space tag, doesn't this prevent sparse from warning if a developer directly double-fetches or acts on the translated untrusted host memory instead of copying it first?

For example, in __pkvm_init_vm(), host_kvm is passed as a plain pointer and loses its sparse static analysis protection despite still aliasing untrusted memory.

[ ... ]

Quoted 4 lines
arch/arm64/kvm/hyp/nvhe/hyp-main.c +0 -0
index 6986ce55fd9ef..f8ea1661b3166 100644

[ ... ]

arch/arm64/kvm/hyp/nvhe/hyp-main.c DEFINE_KVM_HOST_HCALL0_VOID(__vgic_v3_init_lrs) · line 506

Quoted 10 lines
arch/arm64/kvm/hyp/nvhe/hyp-main.c +2 -2
@@ -500,15 +500,15 @@ DEFINE_KVM_HOST_HCALL0_VOID(__vgic_v3_init_lrs)
 }
 
 DEFINE_KVM_HOST_HCALL_VOID(__vgic_v3_save_aprs,
-	struct vgic_v3_cpu_if *, cpu_if)
+	struct vgic_v3_cpu_if __kern *, cpu_if)
 {
-	__vgic_v3_save_aprs(kern_hyp_va(cpu_if));
+	__vgic_v3_save_aprs(kern_hyp_va_host(cpu_if));
 }

[Severity: Critical]
This is a pre-existing issue, but by retaining the lack of bounds validation through kern_hyp_va_host(), can the host EL1 trigger an arbitrary memory corruption in the hypervisor?

Since kern_hyp_va_host() explicitly performs no ownership or bounds validation, it appears the host kernel could provide a forged pointer that translates to a physical page owned by EL2.

The hypervisor then passes this pointer directly to __vgic_v3_save_aprs() after unvalidated translation:

arch/arm64/kvm/hyp/vgic-v3-sr.c:__vgic_v3_save_aprs() {
    ...
    cpu_if->vgic_ap0r[3] = __vgic_v3_read_ap0rn(3);
    ...
}

which directly writes to the untrusted pointer, potentially allowing the host to corrupt EL2 private memory and bypass isolation.

[ ... ]

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=11
author reviewer
#19 lore raw

Re: [PATCH v2 11/11] KVM: arm64: Tag host-VA hypercall parameters __kern

Quoted 5 lines · On Mon, 3 Aug 2026 at 14:44, <[email protected]> wrote:

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:

New issues:
- [Medium] The kern_hyp_va_host() macro strips the __kern tag using (__force void *) and returns a plain pointer, undermining the static analysis guarantees for both misapplied unwraps and subsequent TOCTOU bugs.

https://lore.kernel.org/all/[email protected]/

Quoted 3 lines

Pre-existing issues:
- [Critical] Always-on hypercalls (e.g., __vgic_v3_save_aprs, __kvm_adjust_pc) accept host VAs, translate them via kern_hyp_va_host(), and read/write to them without validating physical page ownership, enabling a Confused Deputy arbitrary memory corruption attack.

We're working on that, coming soon!

/fuad

Quoted 85 lines

--

--- Patch [11]: [PATCH v2 11/11] KVM: arm64: Tag host-VA hypercall parameters __kern --- commit 0acf480afb506d5122464f1024574511fad649b3
Author: Fuad Tabba <[email protected]>

KVM: arm64: Tag host-VA hypercall parameters __kern

The nVHE hypervisor takes host virtual addresses as hypercall arguments and translates each with kern_hyp_va() before use. This patch adds a __kern sparse address space for EL2 code to tag host-VA parameters and introduces kern_hyp_va_host() to unwrap them.

Quoted 4 lines
arch/arm64/include/asm/kvm_mmu.h +0 -0
index 6eae7e7e2a684..57f65257bb56d 100644

[ ... ]

arch/arm64/include/asm/kvm_mmu.h static __always_inline unsigned long __kern_hyp_va(unsigned long v) · line 151

Quoted 11 lines
arch/arm64/include/asm/kvm_mmu.h +7 -0
@@ -140,6 +142,14 @@ static __always_inline unsigned long __kern_hyp_va(unsigned long v)
 
 #define kern_hyp_va(v)       ((typeof(v))(__kern_hyp_va((unsigned long)(v))))
 
+/*
+ * Translate a __kern-tagged host VA, dropping the tag: the only sanctioned
+ * unwrap. Translation only, no ownership or bounds validation; the result
+ * carries the pointee type stripped of the tag and of any cv-qualifiers.
+ */
+#define kern_hyp_va_host(v)                                          \
+     ((TYPEOF_UNQUAL(*(v)) *)__kern_hyp_va((unsigned long)(__force void *)(v)))

[Severity: Medium]
Since the __force void * cast unconditionally strips all sparse address space information, does this suppress warnings if the macro is accidentally applied to an untagged EL2 private-VA-range pointer?

Additionally, because the returned pointer has no address space tag, doesn't this prevent sparse from warning if a developer directly double-fetches or acts on the translated untrusted host memory instead of copying it first?

For example, in __pkvm_init_vm(), host_kvm is passed as a plain pointer and loses its sparse static analysis protection despite still aliasing untrusted memory.

[ ... ]

Quoted 4 lines
arch/arm64/kvm/hyp/nvhe/hyp-main.c +0 -0
index 6986ce55fd9ef..f8ea1661b3166 100644

[ ... ]

arch/arm64/kvm/hyp/nvhe/hyp-main.c DEFINE_KVM_HOST_HCALL0_VOID(__vgic_v3_init_lrs) · line 506

Quoted 10 lines
arch/arm64/kvm/hyp/nvhe/hyp-main.c +2 -2
@@ -500,15 +500,15 @@ DEFINE_KVM_HOST_HCALL0_VOID(__vgic_v3_init_lrs)
 }
 
 DEFINE_KVM_HOST_HCALL_VOID(__vgic_v3_save_aprs,
-     struct vgic_v3_cpu_if *, cpu_if)
+     struct vgic_v3_cpu_if __kern *, cpu_if)
 {
-     __vgic_v3_save_aprs(kern_hyp_va(cpu_if));
+     __vgic_v3_save_aprs(kern_hyp_va_host(cpu_if));
 }

[Severity: Critical]
This is a pre-existing issue, but by retaining the lack of bounds validation through kern_hyp_va_host(), can the host EL1 trigger an arbitrary memory corruption in the hypervisor?

Since kern_hyp_va_host() explicitly performs no ownership or bounds validation, it appears the host kernel could provide a forged pointer that translates to a physical page owned by EL2.

The hypervisor then passes this pointer directly to __vgic_v3_save_aprs() after unvalidated translation:

arch/arm64/kvm/hyp/vgic-v3-sr.c:__vgic_v3_save_aprs() {
    ...
    cpu_if->vgic_ap0r[3] = __vgic_v3_read_ap0rn(3);
    ...
}

which directly writes to the untrusted pointer, potentially allowing the host to corrupt EL2 private memory and bypass isolation.

[ ... ]

--
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=11