[RFC PATCH v2 20/31] KVM: x86: hyperv: Honour in_vtl in synthetic cluster IPIs
From: David Woodhouse
Date: Fri Nov 13 2026 - 14:19:09 EST
From: David Woodhouse <dwmw@xxxxxxxxxxxx>
A guest using VSM names the target VTL of HvCallSendSyntheticClusterIpi
and HvCallSendSyntheticClusterIpiEx in the input's in_vtl field (TLFS
hv_input_vtl, the byte after the vector). KVM treats that byte as
reserved: the fast form of HvCallSendSyntheticClusterIpi fails any
input with bits above 31 set with HV_STATUS_INVALID_HYPERCALL_INPUT,
and the other forms ignore it.
Decode in_vtl in both the memory and the fast forms and deliver the IPI
into that plane's twin of each targeted VP, or into the sender's own
plane when use_target_vtl is clear. A VP with no twin in the target
plane is skipped. Reserved bits 7:5 of in_vtl are rejected with
HV_STATUS_INVALID_HYPERCALL_INPUT before anything is delivered.
A target VTL above the caller's is refused with HV_STATUS_ACCESS_DENIED,
also for an empty EX set.
Under the VTL privilege model a VTL may interrupt its own level and
lower ones, but never a more privileged one (TLFS §15.9). The target
plane is therefore always at or below the caller's, and so below
KVM_MAX_PLANES.
struct hv_send_ipi and struct hv_send_ipi_ex are shared with the Linux
guest code, which now clears in_vtl and the remaining reserved bytes
separately.
The target twin is looked up without the locks that serialise twin
creation, so read the slot with READ_ONCE() to pair with its
publication.
Signed-off-by: David Woodhouse <dwmw@xxxxxxxxxxxx>
---
arch/x86/hyperv/hv_apic.c | 3 +-
arch/x86/kvm/hyperv.c | 69 ++++++++++++++++++++++++++++++++++---
include/hyperv/hvgdk_mini.h | 3 +-
include/hyperv/hvhdk_mini.h | 3 +-
4 files changed, 70 insertions(+), 8 deletions(-)
diff --git a/arch/x86/hyperv/hv_apic.c b/arch/x86/hyperv/hv_apic.c
index 95f1782d1e17..3655b744395d 100644
--- a/arch/x86/hyperv/hv_apic.c
+++ b/arch/x86/hyperv/hv_apic.c
@@ -125,7 +125,8 @@ static bool __send_ipi_mask_ex(const struct cpumask *mask, int vector,
goto ipi_mask_ex_done;
ipi_arg->vector = vector;
- ipi_arg->reserved = 0;
+ ipi_arg->in_vtl.as_uint8 = 0;
+ memset(ipi_arg->reserved, 0, sizeof(ipi_arg->reserved));
ipi_arg->vp_set.valid_bank_mask = 0;
/*
diff --git a/arch/x86/kvm/hyperv.c b/arch/x86/kvm/hyperv.c
index 3494f3b29809..8a33127169fa 100644
--- a/arch/x86/kvm/hyperv.c
+++ b/arch/x86/kvm/hyperv.c
@@ -2683,7 +2683,8 @@ static s64 kvm_hv_flush_tlb(struct kvm_vcpu *vcpu, struct kvm_hv_hcall *hc)
}
static void kvm_hv_send_ipi_to_many(struct kvm *kvm, u32 vector,
- u64 *sparse_banks, u64 valid_bank_mask)
+ u64 *sparse_banks, u64 valid_bank_mask,
+ int target_plane)
{
struct kvm_lapic_irq irq = {
.delivery_mode = APIC_DM_FIXED,
@@ -2693,16 +2694,44 @@ static void kvm_hv_send_ipi_to_many(struct kvm *kvm, u32 vector,
unsigned long i;
kvm_for_each_vcpu(i, vcpu, kvm) {
+ struct kvm_vcpu *target = vcpu;
+
if (sparse_banks &&
!hv_is_vp_in_sparse_set(kvm_hv_get_vpindex(vcpu),
valid_bank_mask, sparse_banks))
continue;
+ /*
+ * TLFS: the IPI targets the VPs' in_vtl (or the sender's
+ * VTL): deliver into that plane's APIC.
+ */
+ if (target_plane) {
+ target = READ_ONCE(vcpu->common->vcpus[target_plane]);
+ if (!target)
+ continue;
+ }
+
/* We fail only when APIC is disabled */
- kvm_apic_set_irq(vcpu, &irq, NULL);
+ kvm_apic_set_irq(target, &irq, NULL);
}
}
+/*
+ * TLFS: in_vtl bit 4 selects an explicit target VTL. A VTL may interrupt
+ * its own level and lower ones, never a higher one (TLFS 15.9, "VTL
+ * Interrupt Management": each VTL sends and receives interrupts without
+ * interference from a less secure VTL). Returns the target plane, or -1
+ * for a target above the caller's.
+ */
+static int hv_send_ipi_target_plane(struct kvm_vcpu *vcpu, u8 in_vtl)
+{
+ if (!(in_vtl & 0x10))
+ return vcpu->plane_level;
+ if ((in_vtl & 0xf) > vcpu->plane_level)
+ return -1;
+ return in_vtl & 0xf;
+}
+
static int kvm_hv_send_ipi(struct kvm_vcpu *vcpu, struct kvm_hv_hcall *hc)
{
struct kvm_vcpu_hv *hv_vcpu = to_hv_vcpu(vcpu);
@@ -2712,6 +2741,8 @@ static int kvm_hv_send_ipi(struct kvm_vcpu *vcpu, struct kvm_hv_hcall *hc)
struct hv_send_ipi send_ipi;
u64 valid_bank_mask;
u32 vector;
+ u8 in_vtl = 0;
+ int target_plane;
bool all_cpus;
int r;
@@ -2729,13 +2760,28 @@ static int kvm_hv_send_ipi(struct kvm_vcpu *vcpu, struct kvm_hv_hcall *hc)
return HV_STATUS_INVALID_HYPERCALL_INPUT;
sparse_banks[0] = send_ipi.cpu_mask;
vector = send_ipi.vector;
+ in_vtl = send_ipi.in_vtl.as_uint8;
} else {
/* 'reserved' part of hv_send_ipi should be 0 */
- if (unlikely(hc->ingpa >> 32 != 0))
+ if (unlikely(hc->ingpa >> 40 != 0))
return HV_STATUS_INVALID_HYPERCALL_INPUT;
sparse_banks[0] = hc->outgpa;
vector = (u32)hc->ingpa;
+ in_vtl = (hc->ingpa >> 32) & 0xff;
}
+
+ /*
+ * Only hv_input_vtl.target_vtl (bits 3:0) and
+ * use_target_vtl (bit 4) are defined; reserved_z (7:5)
+ * must be zero in every form of the hypercall, before
+ * anything is delivered.
+ */
+ if (unlikely(in_vtl & 0xe0))
+ return HV_STATUS_INVALID_HYPERCALL_INPUT;
+ target_plane = hv_send_ipi_target_plane(vcpu, in_vtl);
+ if (target_plane < 0)
+ return HV_STATUS_ACCESS_DENIED;
+
all_cpus = false;
valid_bank_mask = BIT_ULL(0);
@@ -2745,12 +2791,24 @@ static int kvm_hv_send_ipi(struct kvm_vcpu *vcpu, struct kvm_hv_hcall *hc)
if (unlikely(kvm_vcpu_read_guest(vcpu, hc->ingpa, &send_ipi_ex,
sizeof(send_ipi_ex))))
return HV_STATUS_INVALID_HYPERCALL_INPUT;
+ in_vtl = send_ipi_ex.in_vtl.as_uint8;
} else {
send_ipi_ex.vector = (u32)hc->ingpa;
send_ipi_ex.vp_set.format = hc->outgpa;
send_ipi_ex.vp_set.valid_bank_mask = sse128_lo(hc->xmm[0]);
+ in_vtl = (hc->ingpa >> 32) & 0xff;
}
+ /*
+ * As above: hv_input_vtl bits 7:5 are reserved, and a target
+ * VTL above the caller's is refused even for an empty set.
+ */
+ if (unlikely(in_vtl & 0xe0))
+ return HV_STATUS_INVALID_HYPERCALL_INPUT;
+ target_plane = hv_send_ipi_target_plane(vcpu, in_vtl);
+ if (target_plane < 0)
+ return HV_STATUS_ACCESS_DENIED;
+
trace_kvm_hv_send_ipi_ex(send_ipi_ex.vector,
send_ipi_ex.vp_set.format,
send_ipi_ex.vp_set.valid_bank_mask);
@@ -2783,9 +2841,10 @@ static int kvm_hv_send_ipi(struct kvm_vcpu *vcpu, struct kvm_hv_hcall *hc)
return HV_STATUS_INVALID_HYPERCALL_INPUT;
if (all_cpus)
- kvm_hv_send_ipi_to_many(kvm, vector, NULL, 0);
+ kvm_hv_send_ipi_to_many(kvm, vector, NULL, 0, target_plane);
else
- kvm_hv_send_ipi_to_many(kvm, vector, sparse_banks, valid_bank_mask);
+ kvm_hv_send_ipi_to_many(kvm, vector, sparse_banks,
+ valid_bank_mask, target_plane);
ret_success:
return HV_STATUS_SUCCESS;
diff --git a/include/hyperv/hvgdk_mini.h b/include/hyperv/hvgdk_mini.h
index 8346b2212c8c..21fcdd085a9b 100644
--- a/include/hyperv/hvgdk_mini.h
+++ b/include/hyperv/hvgdk_mini.h
@@ -1356,7 +1356,8 @@ struct hv_input_set_vp_registers {
/* HvCallSendSyntheticClusterIpi hypercall */
struct hv_send_ipi { /* HV_INPUT_SEND_SYNTHETIC_CLUSTER_IPI */
u32 vector;
- u32 reserved;
+ union hv_input_vtl in_vtl;
+ u8 reserved[3];
u64 cpu_mask;
} __packed;
diff --git a/include/hyperv/hvhdk_mini.h b/include/hyperv/hvhdk_mini.h
index 57b70efe60d4..6ded425453df 100644
--- a/include/hyperv/hvhdk_mini.h
+++ b/include/hyperv/hvhdk_mini.h
@@ -465,7 +465,8 @@ struct hv_input_unmap_device_interrupt {
struct hv_send_ipi_ex { /* HV_INPUT_SEND_SYNTHETIC_CLUSTER_IPI_EX */
u32 vector;
- u32 reserved;
+ union hv_input_vtl in_vtl;
+ u8 reserved[3];
struct hv_vpset vp_set;
} __packed;
--
2.50.1