[RFC PATCH v1 33/42] drivers/virt: rename VBS park loop to secure_monitor
Sriram Nambakam <[email protected]>
| Newsgroups | org.kernel.vger.kvm,org.kernel.vger.linux-kernel |
|---|---|
| Message-ID | <[email protected]> |
Replace the secure-plane park loop (drivers/virt/vbs_park.c, CONFIG_VBS_PARK)
with drivers/virt/secure_monitor.c (CONFIG_VBS_SECURE_MONITOR), activated by
the "secure_monitor" kernel command-line option. Behaviour is unchanged: a
late_initcall spawns the "vbs-secmon" kthread which hands control back to the
normal plane via KVM_HC_VBS_VTL_RETURN and acknowledges VTL calls as no-ops;
real per-call handlers are plumbed in incrementally.
Also drop the unused security/vbs/secure_monitor.c, which was never wired into
the running secure-plane path (it keyed off "vbs_secure_plane" under
CONFIG_VBS_KVM_PLANES but was never activated).
---
drivers/virt/Kconfig | 16 +-
drivers/virt/Makefile | 2 +-
drivers/virt/{vbs_park.c => secure_monitor.c} | 77 ++---
security/vbs/Makefile | 1 -
security/vbs/secure_monitor.c | 266 ------------------
5 files changed, 52 insertions(+), 310 deletions(-)
rename drivers/virt/{vbs_park.c => secure_monitor.c} (50%)
delete mode 100644 security/vbs/secure_monitor.c
diff --git a/drivers/virt/Kconfig b/drivers/virt/Kconfig
index 88e40eaba1c2..5d964f124afe 100644
--- a/drivers/virt/Kconfig
+++ b/drivers/virt/Kconfig
@@ -13,20 +13,20 @@ menuconfig VIRT_DRIVERS
if VIRT_DRIVERS
-config VBS_PARK
- bool "KVM VM-planes secure-plane park loop"
+config VBS_SECURE_MONITOR
+ bool "KVM VM-planes secure-plane monitor"
depends on X86 && KVM_GUEST
help
- Minimal in-kernel handler for the secure plane (plane >0) of a KVM
- VM-planes guest. When enabled and the "vbs_park" kernel command-line
+ In-kernel monitor for the secure plane (plane >0) of a KVM VM-planes
+ guest. When enabled and the "secure_monitor" kernel command-line
option is present, a kernel thread hands control back to the normal
plane via the KVM_HC_VBS_VTL_RETURN hypercall and then services VTL
calls from a shared calling area.
- This is independent of the full VBS/HEKI stack (CONFIG_VBS): it
- implements only the park/dispatch handshake so that any secure kernel
- can act as plane 1. Calls are acknowledged as no-ops. Say N unless
- this kernel is used as a VM-planes secure plane.
+ This is independent of the full VBS/HEKI stack (CONFIG_VBS) so that
+ any secure kernel can act as plane 1. Per-call handlers are plumbed
+ in incrementally; until then calls are acknowledged as no-ops. Say N
+ unless this kernel is used as a VM-planes secure plane.
config VMGENID
tristate "Virtual Machine Generation ID driver"
diff --git a/drivers/virt/Makefile b/drivers/virt/Makefile
index fa91899a356d..22d1121ba5bd 100644
--- a/drivers/virt/Makefile
+++ b/drivers/virt/Makefile
@@ -5,7 +5,7 @@
obj-$(CONFIG_FSL_HV_MANAGER) += fsl_hypervisor.o
obj-$(CONFIG_VMGENID) += vmgenid.o
-obj-$(CONFIG_VBS_PARK) += vbs_park.o
+obj-$(CONFIG_VBS_SECURE_MONITOR) += secure_monitor.o
obj-y += vboxguest/
obj-$(CONFIG_NITRO_ENCLAVES) += nitro_enclaves/
diff --git a/drivers/virt/vbs_park.c b/drivers/virt/secure_monitor.c
similarity index 50%
rename from drivers/virt/vbs_park.c
rename to drivers/virt/secure_monitor.c
index fabb6beeea7b..2d181c32c439 100644
--- a/drivers/virt/vbs_park.c
+++ b/drivers/virt/secure_monitor.c
@@ -1,31 +1,41 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
- * vbs_park - minimal KVM VM-planes secure-plane park loop
+ * secure_monitor - KVM VM-planes secure-plane monitor
*
- * This provides only the secure-plane (plane >0) side of the VM-planes
- * park/dispatch handshake so that an otherwise ordinary kernel can act as
- * plane 1. It is deliberately independent of the full VBS/HEKI stack
- * (CONFIG_VBS): it implements no security policy. Its single job is to hand
- * control back to the normal plane (plane 0) via the KVM_HC_VBS_VTL_RETURN
- * hypercall and then service VTL calls from the shared calling area.
+ * This is the secure-plane (plane >0) side of the VM-planes park/dispatch
+ * handshake. It lets an otherwise ordinary kernel act as the secure plane
+ * (conventionally plane 1 / VTL1 / VMPL0, though the index is not hard-coded)
+ * without pulling in the full VBS/HEKI stack (CONFIG_VBS). Its single job is
+ * to hand control back to the normal plane (plane 0) via the
+ * KVM_HC_VBS_VTL_RETURN hypercall and then service VTL calls from the shared
+ * calling area.
*
* Control flow (all within plane 0's single KVM_RUN; see
* arch/x86/kvm/x86.c __kvm_emulate_hypercall):
*
- * plane 0 KVM plane 1 (here)
- * ------- --- --------------
+ * normal plane KVM secure plane
+ * ------------ --- ------------
* fill calling area
* HC_VBS_VTL_CALL(ca_gpa) ─────▶ switch_plane ───────────▶ resume in
- * (RAX := ca_gpa) vtl_return()
- * handle call_id
+ * (RAX := ca_gpa) secmon_vtl_return()
+ * dispatch(call_id)
* write ca->status
* resume after VTL_CALL ◀─────── switch_plane ◀─────────── HC_VBS_VTL_RETURN
*
- * Activated by the "vbs_park" kernel command-line option; without it this
- * kernel boots normally and never parks.
+ * Because all planes of a VM share the same memslots (struct kvm_plane has no
+ * memslots of its own; they live in struct kvm), the secure plane sees the
+ * same guest-physical address space as the normal plane and can read the
+ * calling area and the GPAs referenced by each request directly.
+ *
+ * For now every VTL call is acknowledged as a no-op so the normal plane can
+ * make progress; the real per-call handlers (self-protection, HEKI memory
+ * protection, kernel sealing, …) are plumbed in incrementally.
+ *
+ * Activated by the "secure_monitor" kernel command-line option; without it
+ * this kernel boots normally and never parks.
*/
-#define pr_fmt(fmt) "vbs-park: " fmt
+#define pr_fmt(fmt) "vbs-secmon: " fmt
#include <linux/kernel.h>
#include <linux/init.h>
@@ -44,7 +54,7 @@
*
* [ call_pending | call_id | status | arg_size | resp_size | buffer ]
*/
-struct vtl_ca {
+struct vbs_kvm_ca {
__u8 call_pending; /* 1 while call is in flight */
__u8 rsvd[3];
__u32 call_id; /* request id (set by caller) */
@@ -54,15 +64,15 @@ struct vtl_ca {
__u8 buffer[]; /* request data in, response data out */
} __packed;
-/* Set from the "vbs_park" kernel command-line option. */
-static bool vbs_park_active __ro_after_init;
+/* Set from the "secure_monitor" kernel command-line option. */
+static bool secmon_active __ro_after_init;
-static int __init vbs_park_setup(char *str)
+static int __init secmon_setup(char *str)
{
- vbs_park_active = true;
+ secmon_active = true;
return 1;
}
-__setup("vbs_park", vbs_park_setup);
+__setup("secure_monitor", secmon_setup);
/*
* Park the secure plane and hand control back to the normal plane. On the
@@ -70,23 +80,23 @@ __setup("vbs_park", vbs_park_setup);
* hypercall return value (RAX). @status is carried for tracing only; the
* real result is already in the calling area.
*/
-static u64 vtl_return(long status)
+static u64 secmon_vtl_return(long status)
{
return kvm_hypercall1(KVM_HC_VBS_VTL_RETURN, (unsigned long)status);
}
-static int vbs_park_fn(void *unused)
+static int secmon_monitor_fn(void *unused)
{
long status = 0;
- pr_info("secure-plane park loop started\n");
+ pr_info("secure monitor started\n");
for (;;) {
- struct vtl_ca *ca;
+ struct vbs_kvm_ca *ca;
u64 ca_gpa;
/* Park; resume with the next request's calling-area GPA. */
- ca_gpa = vtl_return(status);
+ ca_gpa = secmon_vtl_return(status);
if (!ca_gpa) {
status = -EINVAL;
continue;
@@ -101,10 +111,9 @@ static int vbs_park_fn(void *unused)
}
/*
- * No security policy lives here: acknowledge the call as a
- * no-op so the normal plane can make progress. Replace this
- * with real handlers (or move plane 1 to a dedicated SVSM) to
- * enforce actual VBS semantics.
+ * No handlers are plumbed in yet: acknowledge the call as a
+ * no-op so the normal plane can make progress. Real per-call
+ * dispatch is added incrementally.
*/
pr_info_ratelimited("VTL call id=0x%x arg_size=%u (no-op)\n",
ca->call_id, ca->arg_size);
@@ -118,19 +127,19 @@ static int vbs_park_fn(void *unused)
return 0;
}
-static int __init vbs_park_init(void)
+static int __init secmon_init(void)
{
struct task_struct *t;
- if (!vbs_park_active)
+ if (!secmon_active)
return 0;
- t = kthread_run(vbs_park_fn, NULL, "vbs-park");
+ t = kthread_run(secmon_monitor_fn, NULL, "vbs-secmon");
if (IS_ERR(t)) {
- pr_err("failed to start park loop: %ld\n", PTR_ERR(t));
+ pr_err("failed to start secure monitor: %ld\n", PTR_ERR(t));
return PTR_ERR(t);
}
return 0;
}
-late_initcall(vbs_park_init);
+late_initcall(secmon_init);
diff --git a/security/vbs/Makefile b/security/vbs/Makefile
index f24f31727a65..01e831e28ac7 100644
--- a/security/vbs/Makefile
+++ b/security/vbs/Makefile
@@ -7,7 +7,6 @@ vbs-y := probe.o core.o
vbs-$(CONFIG_VBS_HEKI) += heki.o
obj-$(CONFIG_VBS_KVM_PLANES) += kvm_planes.o
-obj-$(CONFIG_VBS_KVM_PLANES) += secure_monitor.o
obj-$(CONFIG_VBS_SEV_SNP) += sev_snp.o
obj-$(CONFIG_VBS_TDX) += tdx.o
obj-$(CONFIG_VBS_HV_VSM) += hv_vsm.o
diff --git a/security/vbs/secure_monitor.c b/security/vbs/secure_monitor.c
deleted file mode 100644
index c1221ad5019b..000000000000
--- a/security/vbs/secure_monitor.c
+++ /dev/null
@@ -1,266 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * VBS secure-plane monitor — in-guest VTL dispatcher
- *
- * This is the secure-plane counterpart of the normal-plane kvm_planes
- * backend. The SAME kernel image boots as both the normal plane and the
- * secure plane; when booted as the secure plane (selected via the
- * "vbs_secure_plane" kernel command-line option) this monitor takes over
- * and services VTL calls issued by the normal plane.
- *
- * "Secure plane" is the highest-privilege plane of the VM (conventionally
- * plane 1 / VTL1 / VMPL0, but a VM may have up to KVM_MAX_PLANES planes and
- * the index is not hard-coded here). "Normal plane" is the requesting,
- * lower-privilege plane (conventionally plane 0).
- *
- * Control flow (all within the normal plane's single KVM_RUN, see
- * arch/x86/kvm/x86.c ____kvm_emulate_hypercall):
- *
- * normal plane KVM secure plane
- * ------------ --- ------------
- * fill calling area
- * HC_VBS_VTL_CALL(ca_gpa) ─────▶ switch_plane ───────────▶ resume in
- * (RAX := ca_gpa) secmon_vtl_return()
- * dispatch(call_id)
- * write ca->status
- * resume after VTL_CALL ◀─────── switch_plane ◀─────────── HC_VBS_VTL_RETURN(status)
- * read ca->status
- *
- * Because all planes of a VM share the same memslots (struct kvm_plane has
- * no memslots of its own; they live in struct kvm), the secure plane sees
- * the same guest-physical address space as the normal plane and can read
- * the calling area and the GPAs referenced by each request directly.
- */
-
-#define pr_fmt(fmt) "vbs-secmon: " fmt
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/kthread.h>
-#include <linux/io.h>
-#include <linux/mm.h>
-#include <linux/types.h>
-#include <linux/errno.h>
-#include <linux/vbs.h>
-#include <linux/kvm_para.h>
-#include <asm/kvm_para.h>
-
-#include "heki.h"
-
-/*
- * Shared-memory calling area — must match struct vbs_kvm_ca in kvm_planes.c
- * (this is the normal-plane <-> secure-plane wire ABI).
- *
- * [ call_pending | call_id | status | arg_size | resp_size | buffer ]
- */
-struct vbs_kvm_ca {
- __u8 call_pending; /* 1 while call is in flight */
- __u8 rsvd[3];
- __u32 call_id; /* enum vbs_call_id (set by caller) */
- __s32 status; /* return code (set by responder) */
- __u32 arg_size; /* request payload size */
- __u32 resp_size; /* response payload size */
- __u8 buffer[]; /* request data in, response data out */
-} __packed;
-
-/* Set from the "vbs_secure_plane" kernel command-line option. */
-static bool secmon_active __ro_after_init;
-
-static int __init secmon_setup(char *str)
-{
- secmon_active = true;
- return 1;
-}
-__setup("vbs_secure_plane", secmon_setup);
-
-/*
- * Park the secure plane and hand control back to the normal plane. On the
- * next VTL call, KVM resumes us here with the calling-area GPA in the
- * hypercall return value (RAX). @status is carried for tracing only; the
- * real result is already in the calling area.
- */
-static u64 secmon_vtl_return(long status)
-{
- return kvm_hypercall1(KVM_HC_VBS_VTL_RETURN, (unsigned long)status);
-}
-
-/*
- * Apply EPT permissions on a normal-plane GPA range from the secure plane.
- *
- * The secure plane cannot issue the host KVM_SET_MEMORY_ATTRIBUTES ioctl,
- * so it asks KVM to do it via the KVM_HC_VBS_SET_MEM_ATTRS hypercall, which
- * KVM honours only for a higher-privilege plane. @perms carries the access
- * bits the normal plane should retain (VBS_MEM_*); KVM translates a cleared
- * write/exec bit into NO_WRITE / NO_EXEC memory attributes.
- */
-static int secmon_apply_attrs(u64 gpa, u64 size, u32 perms)
-{
- long ret;
-
- pr_debug("apply_attrs gpa=0x%llx size=0x%llx perms=%c%c%c\n",
- gpa, size,
- (perms & VBS_MEM_READ) ? 'r' : '-',
- (perms & VBS_MEM_WRITE) ? 'w' : '-',
- (perms & VBS_MEM_EXEC) ? 'x' : '-');
-
- ret = kvm_hypercall3(KVM_HC_VBS_SET_MEM_ATTRS, gpa, size, perms);
- if (ret)
- return (int)ret;
-
- return 0;
-}
-
-/* ── per-call handlers ────────────────────────────────────────────────── */
-
-static int secmon_do_protect_memory(const void *arg, u32 arg_size)
-{
- const struct vbs_protect_memory_req *r = arg;
-
- if (arg_size < sizeof(*r))
- return -EINVAL;
-
- return secmon_apply_attrs(r->gpa, r->size, r->perms);
-}
-
-static int secmon_do_seal_kernel(const void *arg, u32 arg_size)
-{
- const struct vbs_seal_kernel_req *r = arg;
- int ret;
-
- if (arg_size < sizeof(*r))
- return -EINVAL;
-
- /* Kernel text: read + execute, no write. */
- ret = secmon_apply_attrs(r->text_gpa, r->text_size,
- VBS_MEM_READ | VBS_MEM_EXEC);
- if (ret)
- return ret;
-
- /* Kernel rodata: read only, no write, no execute. */
- return secmon_apply_attrs(r->rodata_gpa, r->rodata_size,
- VBS_MEM_READ);
-}
-
-static int secmon_do_set_module_perms(const void *arg, u32 arg_size)
-{
- const struct vbs_set_module_perms_req *hdr = arg;
- const struct vbs_module_section *sec;
- u32 i, n;
-
- if (arg_size < sizeof(*hdr))
- return -EINVAL;
-
- n = hdr->nr_sections;
- if (arg_size < sizeof(*hdr) + n * sizeof(*sec))
- return -EINVAL;
-
- sec = (const struct vbs_module_section *)(hdr + 1);
- for (i = 0; i < n; i++) {
- int ret = secmon_apply_attrs(sec[i].gpa, sec[i].size,
- sec[i].perms);
- if (ret)
- return ret;
- }
-
- return 0;
-}
-
-static long secmon_dispatch(u32 call_id, const void *arg, u32 arg_size,
- u32 *resp_size)
-{
- *resp_size = 0;
-
- switch (call_id) {
- case VBS_CALL_INIT:
- case VBS_CALL_SHUTDOWN:
- return 0;
-
- case VBS_CALL_PROTECT_MEMORY:
- return secmon_do_protect_memory(arg, arg_size);
- case VBS_CALL_SEAL_KERNEL:
- return secmon_do_seal_kernel(arg, arg_size);
-
- case VBS_CALL_SET_MODULE_PERMS:
- return secmon_do_set_module_perms(arg, arg_size);
-
- /*
- * Module/kexec validation and key management are acknowledged for
- * now (mirroring the previous userspace dispatcher); real signature
- * verification runs here in a later stage.
- */
- case VBS_CALL_VALIDATE_MODULE:
- case VBS_CALL_UNLOAD_MODULE:
- case VBS_CALL_ADD_KEY:
- case VBS_CALL_REVOKE_KEY:
- case VBS_CALL_SEND_CERTS:
- case VBS_CALL_KEXEC_VALIDATE:
- case VBS_CALL_KEXEC_INVALIDATE:
- return 0;
-
- default:
- pr_warn_ratelimited("unknown call_id 0x%x\n", call_id);
- return -ENOSYS;
- }
-}
-
-/* ── monitor loop ─────────────────────────────────────────────────────── */
-
-static int secmon_monitor_fn(void *unused)
-{
- long status = 0;
-
- pr_info("secure monitor started\n");
-
- for (;;) {
- struct vbs_kvm_ca *ca;
- u64 ca_gpa;
- u32 call_id, arg_size, resp_size = 0;
-
- /* Park; resume with the next request's calling-area GPA. */
- ca_gpa = secmon_vtl_return(status);
- if (!ca_gpa) {
- status = -EINVAL;
- continue;
- }
-
- ca = memremap(ca_gpa, PAGE_SIZE, MEMREMAP_WB);
- if (!ca) {
- pr_err_ratelimited("failed to map calling area 0x%llx\n",
- ca_gpa);
- status = -EFAULT;
- continue;
- }
-
- call_id = ca->call_id;
- arg_size = ca->arg_size;
- if (arg_size > PAGE_SIZE - sizeof(*ca))
- arg_size = PAGE_SIZE - sizeof(*ca);
-
- status = secmon_dispatch(call_id, ca->buffer, arg_size,
- &resp_size);
-
- ca->status = (s32)status;
- ca->resp_size = resp_size;
-
- memunmap(ca);
- }
-
- return 0;
-}
-
-static int __init secmon_init(void)
-{
- struct task_struct *t;
-
- if (!secmon_active)
- return 0;
-
- t = kthread_run(secmon_monitor_fn, NULL, "vbs-secmon");
- if (IS_ERR(t)) {
- pr_err("failed to start secure monitor: %ld\n", PTR_ERR(t));
- return PTR_ERR(t);
- }
-
- return 0;
-}
-late_initcall(secmon_init);
--
2.55.0