From: Mihai Donțu <mdo...@bitdefender.com>
Using the KVMI_VCPU_CONTROL_CR command, the introspection tool subscribes
to KVMI_VCPU_EVENT_CR events that will be sent when a control register
(CR0, CR3 or CR4) is going to be changed.
Signed-off-by: Mihai Donțu <mdo...@bitdefender.com>
Co-developed-by: Adalbert Lazăr <ala...@bitdefender.com>
Signed-off-by: Adalbert Lazăr <ala...@bitdefender.com>
---
Documentation/virt/kvm/kvmi.rst | 73 +++++++++++++
arch/x86/include/asm/kvmi_host.h | 12 +++
arch/x86/include/uapi/asm/kvmi.h | 18 ++++
arch/x86/kvm/kvmi.c | 78 ++++++++++++++
arch/x86/kvm/kvmi.h | 4 +
arch/x86/kvm/kvmi_msg.c | 44 ++++++++
arch/x86/kvm/vmx/vmx.c | 6 +-
arch/x86/kvm/x86.c | 12 ++-
include/uapi/linux/kvmi.h | 2 +
.../testing/selftests/kvm/x86_64/kvmi_test.c | 100 ++++++++++++++++++
virt/kvm/introspection/kvmi_int.h | 2 +
11 files changed, 348 insertions(+), 3 deletions(-)
diff --git a/Documentation/virt/kvm/kvmi.rst b/Documentation/virt/kvm/kvmi.rst
index f9c10d27ce14..85e14b82aa2f 100644
--- a/Documentation/virt/kvm/kvmi.rst
+++ b/Documentation/virt/kvm/kvmi.rst
@@ -539,6 +539,7 @@ Enables/disables vCPU introspection events. This command
can be used with
the following events::
KVMI_VCPU_EVENT_BREAKPOINT
+ KVMI_VCPU_EVENT_CR
KVMI_VCPU_EVENT_HYPERCALL
When an event is enabled, the introspection tool is notified and
@@ -701,6 +702,40 @@ interceptions). By default it is enabled.
* -KVM_EINVAL - the padding is not zero
* -KVM_EINVAL - ``enable`` is not 1 or 0
+15. KVMI_VCPU_CONTROL_CR
+------------------------
+
+:Architectures: x86
+:Versions: >= 1
+:Parameters:
+
+::
+
+ struct kvmi_vcpu_hdr;
+ struct kvmi_vcpu_control_cr {
+ __u8 cr;
+ __u8 enable;
+ __u16 padding1;
+ __u32 padding2;
+ };
+
+:Returns:
+
+::
+
+ struct kvmi_error_code
+
+Enables/disables introspection for a specific control register and must
+be used in addition to *KVMI_VCPU_CONTROL_EVENTS* with the *KVMI_VCPU_EVENT_CR*
+ID set.
+
+:Errors:
+
+* -KVM_EINVAL - the selected vCPU is invalid
+* -KVM_EINVAL - the specified control register is not CR0, CR3 or CR4
+* -KVM_EINVAL - the padding is not zero
+* -KVM_EAGAIN - the selected vCPU can't be introspected yet
+
Events
======
@@ -893,3 +928,41 @@ before returning this action.
The *CONTINUE* action will cause the breakpoint exception to be reinjected
(the OS will handle it).
+
+5. KVMI_VCPU_EVENT_CR
+---------------------
+
+:Architectures: x86
+:Versions: >= 1
+:Actions: CONTINUE, CRASH
+:Parameters:
+
+::
+
+ struct kvmi_event_hdr;
+ struct kvmi_vcpu_event;
+ struct kvmi_vcpu_event_cr {
+ __u8 cr;
+ __u8 padding[7];
+ __u64 old_value;
+ __u64 new_value;
+ };
+
+:Returns:
+
+::
+
+ struct kvmi_vcpu_hdr;
+ struct kvmi_vcpu_event_reply;
+ struct kvmi_vcpu_event_cr_reply {
+ __u64 new_val;
+ };
+
+This event is sent when a control register is going to be changed and the
+introspection has been enabled for this event and for this specific
+register (see **KVMI_VCPU_CONTROL_EVENTS**).
+
+``kvmi_vcpu_event`` (with the vCPU state), the control register number
+(``cr``), the old value (``old_value``) and the new value (``new_value``)
+are sent to the introspection tool. The *CONTINUE* action will set the
+``new_val``.
diff --git a/arch/x86/include/asm/kvmi_host.h b/arch/x86/include/asm/kvmi_host.h
index 161d1ae5a7cf..7613088d0ae2 100644
--- a/arch/x86/include/asm/kvmi_host.h
+++ b/arch/x86/include/asm/kvmi_host.h
@@ -4,6 +4,8 @@
#include <asm/kvmi.h>
+#define KVMI_NUM_CR 5
+
struct kvmi_monitor_interception {
bool kvmi_intercepted;
bool kvm_intercepted;
@@ -19,6 +21,8 @@ struct kvmi_interception {
struct kvm_vcpu_arch_introspection {
struct kvm_regs delayed_regs;
bool have_delayed_regs;
+
+ DECLARE_BITMAP(cr_mask, KVMI_NUM_CR);
};
struct kvm_arch_introspection {
@@ -27,11 +31,19 @@ struct kvm_arch_introspection {
#ifdef CONFIG_KVM_INTROSPECTION
bool kvmi_monitor_bp_intercept(struct kvm_vcpu *vcpu, u32 dbg);
+bool kvmi_cr_event(struct kvm_vcpu *vcpu, unsigned int cr,
+ unsigned long old_value, unsigned long *new_value);
+bool kvmi_cr3_intercepted(struct kvm_vcpu *vcpu);
#else /* CONFIG_KVM_INTROSPECTION */
static inline bool kvmi_monitor_bp_intercept(struct kvm_vcpu *vcpu, u32 dbg)
{ return false; }
+static inline bool kvmi_cr_event(struct kvm_vcpu *vcpu, unsigned int cr,
+ unsigned long old_value,
+ unsigned long *new_value)
+ { return true; }
+static inline bool kvmi_cr3_intercepted(struct kvm_vcpu *vcpu) { return false;
}
#endif /* CONFIG_KVM_INTROSPECTION */
diff --git a/arch/x86/include/uapi/asm/kvmi.h b/arch/x86/include/uapi/asm/kvmi.h
index a442ba4d2190..32cd17488058 100644
--- a/arch/x86/include/uapi/asm/kvmi.h
+++ b/arch/x86/include/uapi/asm/kvmi.h
@@ -61,4 +61,22 @@ struct kvmi_vcpu_get_cpuid_reply {
__u32 edx;
};
+struct kvmi_vcpu_control_cr {
+ __u8 cr;
+ __u8 enable;
+ __u16 padding1;
+ __u32 padding2;
+};
+
+struct kvmi_vcpu_event_cr {
+ __u8 cr;
+ __u8 padding[7];
+ __u64 old_value;
+ __u64 new_value;
+};
+
+struct kvmi_vcpu_event_cr_reply {
+ __u64 new_val;
+};
+
#endif /* _UAPI_ASM_X86_KVMI_H */
diff --git a/arch/x86/kvm/kvmi.c b/arch/x86/kvm/kvmi.c
index e7a4ef48ed61..2bb6b4bb932b 100644
--- a/arch/x86/kvm/kvmi.c
+++ b/arch/x86/kvm/kvmi.c
@@ -8,10 +8,12 @@
#include "linux/kvm_host.h"
#include "x86.h"
#include "../../../virt/kvm/introspection/kvmi_int.h"
+#include "kvmi.h"
void kvmi_arch_init_vcpu_events_mask(unsigned long *supported)
{
set_bit(KVMI_VCPU_EVENT_BREAKPOINT, supported);
+ set_bit(KVMI_VCPU_EVENT_CR, supported);
set_bit(KVMI_VCPU_EVENT_HYPERCALL, supported);
}
@@ -320,3 +322,79 @@ void kvmi_arch_request_interception_cleanup(struct
kvm_vcpu *vcpu,
arch_vcpui->cleanup = true;
}
}
+
+int kvmi_arch_cmd_vcpu_control_cr(struct kvm_vcpu *vcpu, int cr, bool enable)
+{
+ if (cr == 3)
+ kvm_x86_ops.control_cr3_intercept(vcpu, CR_TYPE_W, enable);
+
+ if (enable)
+ set_bit(cr, VCPUI(vcpu)->arch.cr_mask);
+ else
+ clear_bit(cr, VCPUI(vcpu)->arch.cr_mask);
+
+ return 0;
+}
+
+static bool __kvmi_cr_event(struct kvm_vcpu *vcpu, unsigned int cr,
+ u64 old_value, unsigned long *new_value)
+{
+ u64 reply_value;
+ u32 action;
+ bool ret;
+
+ if (!test_bit(cr, VCPUI(vcpu)->arch.cr_mask))
+ return true;
+
+ action = kvmi_msg_send_cr(vcpu, cr, old_value, *new_value,
+ &reply_value);
+ switch (action) {
+ case KVMI_EVENT_ACTION_CONTINUE:
+ *new_value = reply_value;
+ ret = true;
+ break;
+ default:
+ kvmi_handle_common_event_actions(vcpu, action);
+ ret = false;
+ }
+
+ return ret;
+}
+
+bool kvmi_cr_event(struct kvm_vcpu *vcpu, unsigned int cr,
+ unsigned long old_value, unsigned long *new_value)
+{
+ struct kvm_introspection *kvmi;
+ bool ret = true;
+
+ if (old_value == *new_value)
+ return true;
+
+ kvmi = kvmi_get(vcpu->kvm);
+ if (!kvmi)
+ return true;
+
+ if (is_vcpu_event_enabled(vcpu, KVMI_VCPU_EVENT_CR))
+ ret = __kvmi_cr_event(vcpu, cr, old_value, new_value);
+
+ kvmi_put(vcpu->kvm);
+
+ return ret;
+}
+
+bool kvmi_cr3_intercepted(struct kvm_vcpu *vcpu)
+{
+ struct kvm_introspection *kvmi;
+ bool ret;
+
+ kvmi = kvmi_get(vcpu->kvm);
+ if (!kvmi)
+ return false;
+
+ ret = test_bit(3, VCPUI(vcpu)->arch.cr_mask);
+
+ kvmi_put(vcpu->kvm);
+
+ return ret;
+}
+EXPORT_SYMBOL(kvmi_cr3_intercepted);
diff --git a/arch/x86/kvm/kvmi.h b/arch/x86/kvm/kvmi.h
index 4eeb0c900083..6f4aaebb67f9 100644
--- a/arch/x86/kvm/kvmi.h
+++ b/arch/x86/kvm/kvmi.h
@@ -7,5 +7,9 @@ int kvmi_arch_cmd_vcpu_get_registers(struct kvm_vcpu *vcpu,
struct kvmi_vcpu_get_registers_reply *rpl);
void kvmi_arch_cmd_vcpu_set_registers(struct kvm_vcpu *vcpu,
const struct kvm_regs *regs);
+int kvmi_arch_cmd_vcpu_control_cr(struct kvm_vcpu *vcpu, int cr, bool enable);
+
+u32 kvmi_msg_send_cr(struct kvm_vcpu *vcpu, u32 cr, u64 old_value,
+ u64 new_value, u64 *ret_value);
#endif
diff --git a/arch/x86/kvm/kvmi_msg.c b/arch/x86/kvm/kvmi_msg.c
index 1651ef877e3e..1682bb27105f 100644
--- a/arch/x86/kvm/kvmi_msg.c
+++ b/arch/x86/kvm/kvmi_msg.c
@@ -132,7 +132,26 @@ static int handle_vcpu_get_cpuid(const struct
kvmi_vcpu_msg_job *job,
return kvmi_msg_vcpu_reply(job, msg, ec, &rpl, sizeof(rpl));
}
+static int handle_vcpu_control_cr(const struct kvmi_vcpu_msg_job *job,
+ const struct kvmi_msg_hdr *msg,
+ const void *_req)
+{
+ const struct kvmi_vcpu_control_cr *req = _req;
+ int ec;
+
+ if (req->padding1 || req->padding2 || req->enable > 1)
+ ec = -KVM_EINVAL;
+ else if (req->cr != 0 && req->cr != 3 && req->cr != 4)
+ ec = -KVM_EINVAL;
+ else
+ ec = kvmi_arch_cmd_vcpu_control_cr(job->vcpu, req->cr,
+ req->enable == 1);
+
+ return kvmi_msg_vcpu_reply(job, msg, ec, NULL, 0);
+}
+
static kvmi_vcpu_msg_job_fct const msg_vcpu[] = {
+ [KVMI_VCPU_CONTROL_CR] = handle_vcpu_control_cr,
[KVMI_VCPU_GET_CPUID] = handle_vcpu_get_cpuid,
[KVMI_VCPU_GET_INFO] = handle_vcpu_get_info,
[KVMI_VCPU_GET_REGISTERS] = handle_vcpu_get_registers,
@@ -143,3 +162,28 @@ kvmi_vcpu_msg_job_fct kvmi_arch_vcpu_msg_handler(u16 id)
{
return id < ARRAY_SIZE(msg_vcpu) ? msg_vcpu[id] : NULL;
}
+
+u32 kvmi_msg_send_cr(struct kvm_vcpu *vcpu, u32 cr, u64 old_value,
+ u64 new_value, u64 *ret_value)
+{
+ struct kvmi_vcpu_event_cr e;
+ struct kvmi_vcpu_event_cr_reply r;
+ u32 action;
+ int err;
+
+ memset(&e, 0, sizeof(e));
+ e.cr = cr;
+ e.old_value = old_value;
+ e.new_value = new_value;
+
+ err = kvmi_send_vcpu_event(vcpu, KVMI_VCPU_EVENT_CR, &e, sizeof(e),
+ &r, sizeof(r), &action);
+ if (err) {
+ action = KVMI_EVENT_ACTION_CONTINUE;
+ *ret_value = new_value;
+ } else {
+ *ret_value = r.new_val;
+ }
+
+ return action;
+}
diff --git a/arch/x86/kvm/vmx/vmx.c b/arch/x86/kvm/vmx/vmx.c
index 9bfa2e9f8161..723e78529146 100644
--- a/arch/x86/kvm/vmx/vmx.c
+++ b/arch/x86/kvm/vmx/vmx.c
@@ -5062,7 +5062,8 @@ static int handle_cr(struct kvm_vcpu *vcpu)
err = handle_set_cr0(vcpu, val);
return kvm_complete_insn_gp(vcpu, err);
case 3:
- WARN_ON_ONCE(enable_unrestricted_guest);
+ WARN_ON_ONCE(enable_unrestricted_guest &&
+ !kvmi_cr3_intercepted(vcpu));
err = kvm_set_cr3(vcpu, val);
return kvm_complete_insn_gp(vcpu, err);
case 4:
@@ -5095,7 +5096,8 @@ static int handle_cr(struct kvm_vcpu *vcpu)
case 1: /*mov from cr*/
switch (cr) {
case 3:
- WARN_ON_ONCE(enable_unrestricted_guest);
+ WARN_ON_ONCE(enable_unrestricted_guest &&
+ !kvmi_cr3_intercepted(vcpu));
val = kvm_read_cr3(vcpu);
kvm_register_write(vcpu, reg, val);
trace_kvm_cr_read(cr, val);
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 824d9d20a6ea..9a4ec0b4714c 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -849,6 +849,9 @@ int kvm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
if (!(cr0 & X86_CR0_PG) && kvm_read_cr4_bits(vcpu, X86_CR4_PCIDE))
return 1;
+ if (!kvmi_cr_event(vcpu, 0, old_cr0, &cr0))
+ return 1;
+
kvm_x86_ops.set_cr0(vcpu, cr0);
if ((cr0 ^ old_cr0) & X86_CR0_PG) {
@@ -1010,6 +1013,9 @@ int kvm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
return 1;
}
+ if (!kvmi_cr_event(vcpu, 4, old_cr4, &cr4))
+ return 1;
+
kvm_x86_ops.set_cr4(vcpu, cr4);
if (((cr4 ^ old_cr4) & mmu_role_bits) ||
@@ -1022,6 +1028,7 @@ EXPORT_SYMBOL_GPL(kvm_set_cr4);
int kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
{
+ unsigned long old_cr3 = kvm_read_cr3(vcpu);
bool skip_tlb_flush = false;
#ifdef CONFIG_X86_64
bool pcid_enabled = kvm_read_cr4_bits(vcpu, X86_CR4_PCIDE);
@@ -1032,7 +1039,7 @@ int kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
}
#endif
- if (cr3 == kvm_read_cr3(vcpu) && !pdptrs_changed(vcpu)) {
+ if (cr3 == old_cr3 && !pdptrs_changed(vcpu)) {
if (!skip_tlb_flush) {
kvm_mmu_sync_roots(vcpu);
kvm_make_request(KVM_REQ_TLB_FLUSH_CURRENT, vcpu);
@@ -1047,6 +1054,9 @@ int kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
!load_pdptrs(vcpu, vcpu->arch.walk_mmu, cr3))
return 1;
+ if (!kvmi_cr_event(vcpu, 3, old_cr3, &cr3))
+ return 1;
+
kvm_mmu_new_pgd(vcpu, cr3, skip_tlb_flush, skip_tlb_flush);
vcpu->arch.cr3 = cr3;
kvm_register_mark_available(vcpu, VCPU_EXREG_CR3);
diff --git a/include/uapi/linux/kvmi.h b/include/uapi/linux/kvmi.h
index 9e28961a8387..c1d8cf02018b 100644
--- a/include/uapi/linux/kvmi.h
+++ b/include/uapi/linux/kvmi.h
@@ -41,6 +41,7 @@ enum {
KVMI_VCPU_GET_REGISTERS = KVMI_VCPU_MESSAGE_ID(3),
KVMI_VCPU_SET_REGISTERS = KVMI_VCPU_MESSAGE_ID(4),
KVMI_VCPU_GET_CPUID = KVMI_VCPU_MESSAGE_ID(5),
+ KVMI_VCPU_CONTROL_CR = KVMI_VCPU_MESSAGE_ID(6),
KVMI_NEXT_VCPU_MESSAGE
};
@@ -58,6 +59,7 @@ enum {
KVMI_VCPU_EVENT_PAUSE = KVMI_VCPU_EVENT_ID(0),
KVMI_VCPU_EVENT_HYPERCALL = KVMI_VCPU_EVENT_ID(1),
KVMI_VCPU_EVENT_BREAKPOINT = KVMI_VCPU_EVENT_ID(2),
+ KVMI_VCPU_EVENT_CR = KVMI_VCPU_EVENT_ID(3),
KVMI_NEXT_VCPU_EVENT
};
diff --git a/tools/testing/selftests/kvm/x86_64/kvmi_test.c
b/tools/testing/selftests/kvm/x86_64/kvmi_test.c
index f95f2771a123..6a1103eab77a 100644
--- a/tools/testing/selftests/kvm/x86_64/kvmi_test.c
+++ b/tools/testing/selftests/kvm/x86_64/kvmi_test.c
@@ -54,6 +54,7 @@ struct vcpu_worker_data {
enum {
GUEST_TEST_NOOP = 0,
GUEST_TEST_BP,
+ GUEST_TEST_CR,
GUEST_TEST_HYPERCALL,
};
@@ -77,6 +78,11 @@ static void guest_bp_test(void)
asm volatile("int3");
}
+static void guest_cr_test(void)
+{
+ set_cr4(get_cr4() | X86_CR4_OSXSAVE);
+}
+
static void guest_hypercall_test(void)
{
asm volatile("mov $34, %rax");
@@ -94,6 +100,9 @@ static void guest_code(void)
case GUEST_TEST_BP:
guest_bp_test();
break;
+ case GUEST_TEST_CR:
+ guest_cr_test();
+ break;
case GUEST_TEST_HYPERCALL:
guest_hypercall_test();
break;
@@ -1100,6 +1109,96 @@ static void test_cmd_vm_control_cleanup(struct kvm_vm
*vm)
cmd_vm_control_cleanup(disable, 0);
}
+static void cmd_vcpu_control_cr(struct kvm_vm *vm, __u8 cr, __u8 enable,
+ int expected_err)
+{
+ struct {
+ struct kvmi_msg_hdr hdr;
+ struct kvmi_vcpu_hdr vcpu_hdr;
+ struct kvmi_vcpu_control_cr cmd;
+ } req = {};
+
+ req.cmd.cr = cr;
+ req.cmd.enable = enable;
+
+ test_vcpu0_command(vm, KVMI_VCPU_CONTROL_CR, &req.hdr, sizeof(req),
+ NULL, 0, expected_err);
+}
+
+static void enable_cr_events(struct kvm_vm *vm, __u8 cr)
+{
+ enable_vcpu_event(vm, KVMI_VCPU_EVENT_CR);
+
+ cmd_vcpu_control_cr(vm, cr, 1, 0);
+}
+
+static void disable_cr_events(struct kvm_vm *vm, __u8 cr)
+{
+ cmd_vcpu_control_cr(vm, cr, 0, 0);
+
+ disable_vcpu_event(vm, KVMI_VCPU_EVENT_CR);
+}
+
+static void test_invalid_vcpu_control_cr(struct kvm_vm *vm)
+{
+ __u8 enable = 1, enable_inval = 2;
+ __u8 cr_inval = 99, cr = 0;
+
+ cmd_vcpu_control_cr(vm, cr, enable_inval, -KVM_EINVAL);
+ cmd_vcpu_control_cr(vm, cr_inval, enable, -KVM_EINVAL);
+}
+
+static void test_cmd_vcpu_control_cr(struct kvm_vm *vm)
+{
+ struct vcpu_worker_data data = {
+ .vm = vm,
+ .vcpu_id = VCPU_ID,
+ .test_id = GUEST_TEST_CR,
+ };
+ struct kvmi_msg_hdr hdr;
+ struct {
+ struct vcpu_event vcpu_ev;
+ struct kvmi_vcpu_event_cr cr;
+ } ev;
+ struct {
+ struct vcpu_reply common;
+ struct kvmi_vcpu_event_cr_reply cr;
+ } rpl = {};
+ __u16 event_id = KVMI_VCPU_EVENT_CR;
+ __u8 cr_no = 4;
+ struct kvm_sregs sregs;
+ pthread_t vcpu_thread;
+
+ enable_cr_events(vm, cr_no);
+
+ vcpu_thread = start_vcpu_worker(&data);
+
+ receive_vcpu_event(&hdr, &ev.vcpu_ev, sizeof(ev), event_id);
+
+ pr_debug("CR%u, old 0x%llx, new 0x%llx\n",
+ ev.cr.cr, ev.cr.old_value, ev.cr.new_value);
+
+ TEST_ASSERT(ev.cr.cr == cr_no,
+ "Unexpected CR event, received CR%u, expected CR%u",
+ ev.cr.cr, cr_no);
+
+ rpl.cr.new_val = ev.cr.old_value;
+
+ reply_to_event(&hdr, &ev.vcpu_ev, KVMI_EVENT_ACTION_CONTINUE,
+ &rpl.common, sizeof(rpl));
+
+ wait_vcpu_worker(vcpu_thread);
+
+ disable_cr_events(vm, cr_no);
+
+ vcpu_sregs_get(vm, VCPU_ID, &sregs);
+ TEST_ASSERT(sregs.cr4 == ev.cr.old_value,
+ "Failed to block CR4 update, CR4 0x%llx, expected 0x%llx",
+ sregs.cr4, ev.cr.old_value);
+
+ test_invalid_vcpu_control_cr(vm);
+}
+
static void test_introspection(struct kvm_vm *vm)
{
srandom(time(0));
@@ -1123,6 +1222,7 @@ static void test_introspection(struct kvm_vm *vm)
test_event_hypercall(vm);
test_event_breakpoint(vm);
test_cmd_vm_control_cleanup(vm);
+ test_cmd_vcpu_control_cr(vm);
unhook_introspection(vm);
}
diff --git a/virt/kvm/introspection/kvmi_int.h
b/virt/kvm/introspection/kvmi_int.h
index 8a266b058155..b1877a770fcb 100644
--- a/virt/kvm/introspection/kvmi_int.h
+++ b/virt/kvm/introspection/kvmi_int.h
@@ -69,6 +69,8 @@ int kvmi_add_job(struct kvm_vcpu *vcpu,
void kvmi_run_jobs(struct kvm_vcpu *vcpu);
void kvmi_handle_common_event_actions(struct kvm_vcpu *vcpu, u32 action);
void kvmi_cmd_vm_control_cleanup(struct kvm_introspection *kvmi, bool enable);
+struct kvm_introspection * __must_check kvmi_get(struct kvm *kvm);
+void kvmi_put(struct kvm *kvm);
int kvmi_cmd_vm_control_events(struct kvm_introspection *kvmi,
u16 event_id, bool enable);
int kvmi_cmd_vcpu_control_events(struct kvm_vcpu *vcpu,
_______________________________________________
Virtualization mailing list
Virtualization@lists.linux-foundation.org
https://lists.linuxfoundation.org/mailman/listinfo/virtualization
