[RFC PATCH v2 17/31] KVM: x86: hyperv: Deliver higher-plane SynIC messages through overlays

From: David Woodhouse

Date: Fri Nov 13 2026 - 14:14:37 EST


From: David Woodhouse <dwmw@xxxxxxxxxxxx>

SynIC message delivery reads and writes a plane's SIMP page in guest
RAM. For a higher plane that page is a per-plane overlay, and the RAM
underneath belongs to plane 0: delivering a higher VTL's message there
corrupts memory plane 0 owns, and judging deliverability from
plane-0-writable bytes lets a lower VTL plant a non-HVMSG_NONE type
and swallow a no_retry (periodic stimer) message.

Read and write the message page through the plane's overlay when one
is installed. A higher plane without an overlay fails the delivery
with -EFAULT instead of falling through to kvm_vcpu_write_guest_page(),
and the sender retries once the overlay appears.

With that, a higher plane's SynIC no longer needs hiding from the VMM.
KVM_EXIT_HYPERV_SYNIC is reported for non-zero planes again, and it and
KVM_EXIT_HYPERV_SYNDBG carry the plane, so the VMM can keep its plane-0
device state separate.

Signed-off-by: David Woodhouse <dwmw@xxxxxxxxxxxx>
---
arch/x86/kvm/hyperv.c | 81 +++++++++++++++++++++++++++++++------------
1 file changed, 58 insertions(+), 23 deletions(-)

diff --git a/arch/x86/kvm/hyperv.c b/arch/x86/kvm/hyperv.c
index 5a42d479e936..3494f3b29809 100644
--- a/arch/x86/kvm/hyperv.c
+++ b/arch/x86/kvm/hyperv.c
@@ -253,15 +253,6 @@ static void synic_exit(struct kvm_vcpu_hv_synic *synic, u32 msr)
struct kvm_vcpu *vcpu = hv_synic_to_vcpu(synic);
struct kvm_vcpu_hv *hv_vcpu = to_hv_vcpu(vcpu);

- /*
- * Userspace's SynIC device models plane 0 only; a higher plane's
- * exit would be mistaken for a plane-0 page move and relocate the
- * overlay the VMM keeps for SIMP/SIEFP. Higher-plane SynICs are
- * handled fully in-kernel.
- */
- if (vcpu->plane_level)
- return;
-
hv_vcpu->exit.type = KVM_EXIT_HYPERV_SYNIC;
hv_vcpu->exit.plane = vcpu->plane_level;
hv_vcpu->exit.u.synic.msr = msr;
@@ -795,6 +786,51 @@ static int stimer_get_count(struct kvm_vcpu_hv_stimer *stimer, u64 *pcount)
return 0;
}

+/*
+ * SIMP accessors: a plane overlay page, when installed by userspace,
+ * carries the live message page for this plane; the memslot holds only
+ * the underlay the other planes see.
+ */
+static int synic_msg_page_read(struct kvm_vcpu *vcpu, gfn_t gfn, void *data,
+ int offset, int len)
+{
+ unsigned long uaddr = kvm_plane_overlay_uaddr(vcpu->plane, gfn);
+
+ if (uaddr)
+ return copy_from_user(data, (void __user *)(uaddr + offset),
+ len) ? -EFAULT : 0;
+ /*
+ * Mirror the write side: without an overlay a higher plane's
+ * message page is backed by underlay memory that plane 0 controls.
+ * Deciding deliverability from plane-0-writable bytes would let a
+ * lower VTL plant a non-HVMSG_NONE type and silently swallow a
+ * no_retry (periodic stimer) message; fail so the delivery is
+ * retried once the overlay appears.
+ */
+ if (vcpu->plane_level)
+ return -EFAULT;
+ return kvm_vcpu_read_guest_page(vcpu, gfn, data, offset, len);
+}
+
+static int synic_msg_page_write(struct kvm_vcpu *vcpu, gfn_t gfn,
+ const void *data, int offset, int len)
+{
+ unsigned long uaddr = kvm_plane_overlay_uaddr(vcpu->plane, gfn);
+
+ if (uaddr)
+ return copy_to_user((void __user *)(uaddr + offset), data,
+ len) ? -EFAULT : 0;
+ /*
+ * Never write a higher plane's messages into guest RAM: without an
+ * overlay installed that memory is the underlay every other plane
+ * sees, and silently corrupting plane-0-owned pages is far worse
+ * than retrying the message once the overlay appears.
+ */
+ if (vcpu->plane_level)
+ return -EFAULT;
+ return kvm_vcpu_write_guest_page(vcpu, gfn, data, offset, len);
+}
+
static int synic_deliver_msg(struct kvm_vcpu_hv_synic *synic, u32 sint,
struct hv_message *src_msg, bool no_retry)
{
@@ -815,10 +851,10 @@ static int synic_deliver_msg(struct kvm_vcpu_hv_synic *synic, u32 sint,
* is only called in vcpu context so the entire update is atomic from
* guest POV and thus the exact order here doesn't matter.
*/
- r = kvm_vcpu_read_guest_page(vcpu, msg_page_gfn, &hv_hdr.message_type,
- msg_off + offsetof(struct hv_message,
- header.message_type),
- sizeof(hv_hdr.message_type));
+ r = synic_msg_page_read(vcpu, msg_page_gfn, &hv_hdr.message_type,
+ msg_off + offsetof(struct hv_message,
+ header.message_type),
+ sizeof(hv_hdr.message_type));
if (r < 0)
return r;

@@ -828,21 +864,20 @@ static int synic_deliver_msg(struct kvm_vcpu_hv_synic *synic, u32 sint,

hv_hdr.message_flags.asu8 = 0;
hv_hdr.message_flags.msg_pending = 1;
-
- r = kvm_vcpu_write_guest_page(vcpu, msg_page_gfn,
- &hv_hdr.message_flags,
- msg_off +
- offsetof(struct hv_message,
- header.message_flags),
- sizeof(hv_hdr.message_flags));
+ r = synic_msg_page_write(vcpu, msg_page_gfn,
+ &hv_hdr.message_flags,
+ msg_off +
+ offsetof(struct hv_message,
+ header.message_flags),
+ sizeof(hv_hdr.message_flags));
if (r < 0)
return r;
return -EAGAIN;
}

- r = kvm_vcpu_write_guest_page(vcpu, msg_page_gfn, src_msg, msg_off,
- sizeof(src_msg->header) +
- src_msg->header.payload_size);
+ r = synic_msg_page_write(vcpu, msg_page_gfn, src_msg, msg_off,
+ sizeof(src_msg->header) +
+ src_msg->header.payload_size);
if (r < 0)
return r;

--
2.50.1