From: Nicolas Saenz Julienne <nsaenz@amazon.com>
To: <kvm@vger.kernel.org>
Cc: <linux-kernel@vger.kernel.org>, <linux-hyperv@vger.kernel.org>,
<pbonzini@redhat.com>, <seanjc@google.com>, <vkuznets@redhat.com>,
<anelkz@amazon.com>, <graf@amazon.com>, <dwmw@amazon.co.uk>,
<jgowans@amazon.com>, <corbert@lwn.net>, <kys@microsoft.com>,
<haiyangz@microsoft.com>, <decui@microsoft.com>, <x86@kernel.org>,
<linux-doc@vger.kernel.org>,
Nicolas Saenz Julienne <nsaenz@amazon.com>
Subject: [RFC 30/33] KVM: x86: hyper-v: Introduce KVM_REQ_HV_INJECT_INTERCEPT request
Date: Wed, 8 Nov 2023 11:18:03 +0000 [thread overview]
Message-ID: <20231108111806.92604-31-nsaenz@amazon.com> (raw)
In-Reply-To: <20231108111806.92604-1-nsaenz@amazon.com>
Introduce a new request type, KVM_REQ_HV_INJECT_INTERCEPT which allows
injecting out-of-band Hyper-V secure intercepts. For now only memory
access intercepts are supported. These are triggered when access a GPA
protected by a higher VTL. The memory intercept metadata is filled based
on the GPA provided through struct kvm_vcpu_hv_intercept_info, and
injected into the guest through SynIC message.
Signed-off-by: Nicolas Saenz Julienne <nsaenz@amazon.com>
---
arch/x86/include/asm/kvm_host.h | 10 +++
arch/x86/kvm/hyperv.c | 114 ++++++++++++++++++++++++++++++++
arch/x86/kvm/hyperv.h | 2 +
arch/x86/kvm/x86.c | 3 +
4 files changed, 129 insertions(+)
diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h
index 1a854776d91e..39671e075555 100644
--- a/arch/x86/include/asm/kvm_host.h
+++ b/arch/x86/include/asm/kvm_host.h
@@ -113,6 +113,7 @@
KVM_ARCH_REQ_FLAGS(31, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
#define KVM_REQ_HV_TLB_FLUSH \
KVM_ARCH_REQ_FLAGS(32, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
+#define KVM_REQ_HV_INJECT_INTERCEPT KVM_ARCH_REQ(33)
#define CR0_RESERVED_BITS \
(~(unsigned long)(X86_CR0_PE | X86_CR0_MP | X86_CR0_EM | X86_CR0_TS \
@@ -639,6 +640,13 @@ struct kvm_vcpu_hv_tlb_flush_fifo {
DECLARE_KFIFO(entries, u64, KVM_HV_TLB_FLUSH_FIFO_SIZE);
};
+struct kvm_vcpu_hv_intercept_info {
+ struct kvm_vcpu *vcpu;
+ int type;
+ u64 gpa;
+ u8 access;
+};
+
/* Hyper-V per vcpu emulation context */
struct kvm_vcpu_hv {
struct kvm_vcpu *vcpu;
@@ -673,6 +681,8 @@ struct kvm_vcpu_hv {
u64 vm_id;
u32 vp_id;
} nested;
+
+ struct kvm_vcpu_hv_intercept_info intercept_info;
};
struct kvm_hypervisor_cpuid {
diff --git a/arch/x86/kvm/hyperv.c b/arch/x86/kvm/hyperv.c
index eb6a4848e306..38ee3abdef9c 100644
--- a/arch/x86/kvm/hyperv.c
+++ b/arch/x86/kvm/hyperv.c
@@ -2789,6 +2789,120 @@ int kvm_hv_hypercall(struct kvm_vcpu *vcpu)
return 0;
}
+static void store_kvm_segment(const struct kvm_segment *kvmseg,
+ struct hv_x64_segment_register *reg)
+{
+ reg->base = kvmseg->base;
+ reg->limit = kvmseg->limit;
+ reg->selector = kvmseg->selector;
+ reg->segment_type = kvmseg->type;
+ reg->present = kvmseg->present;
+ reg->descriptor_privilege_level = kvmseg->dpl;
+ reg->_default = kvmseg->db;
+ reg->non_system_segment = kvmseg->s;
+ reg->_long = kvmseg->l;
+ reg->granularity = kvmseg->g;
+ reg->available = kvmseg->avl;
+}
+
+static void deliver_gpa_intercept(struct kvm_vcpu *target_vcpu,
+ struct kvm_vcpu *intercepted_vcpu, u64 gpa,
+ u64 gva, u8 access_type_mask)
+{
+ ulong cr0;
+ struct hv_message msg = { 0 };
+ struct hv_memory_intercept_message *intercept = (struct hv_memory_intercept_message *)msg.u.payload;
+ struct kvm_vcpu_hv *hv_vcpu = to_hv_vcpu(target_vcpu);
+ struct x86_exception e;
+ struct kvm_segment kvmseg;
+
+ msg.header.message_type = HVMSG_GPA_INTERCEPT;
+ msg.header.payload_size = sizeof(*intercept);
+
+ intercept->header.vp_index = to_hv_vcpu(intercepted_vcpu)->vp_index;
+ intercept->header.instruction_length = intercepted_vcpu->arch.exit_instruction_len;
+ intercept->header.access_type_mask = access_type_mask;
+ kvm_x86_ops.get_segment(intercepted_vcpu, &kvmseg, VCPU_SREG_CS);
+ store_kvm_segment(&kvmseg, &intercept->header.cs);
+
+ cr0 = kvm_read_cr0(intercepted_vcpu);
+ intercept->header.exec_state.cr0_pe = (cr0 & X86_CR0_PE);
+ intercept->header.exec_state.cr0_am = (cr0 & X86_CR0_AM);
+ intercept->header.exec_state.cpl = kvm_x86_ops.get_cpl(intercepted_vcpu);
+ intercept->header.exec_state.efer_lma = is_long_mode(intercepted_vcpu);
+ intercept->header.exec_state.debug_active = 0;
+ intercept->header.exec_state.interruption_pending = 0;
+ intercept->header.rip = kvm_rip_read(intercepted_vcpu);
+ intercept->header.rflags = kvm_get_rflags(intercepted_vcpu);
+
+ /*
+ * For exec violations we don't have a way to decode an instruction that issued a fetch
+ * to a non-X page because CPU points RIP and GPA to the fetch destination in the faulted page.
+ * Instruction length though is the length of the fetch source.
+ * Seems like Hyper-V is aware of that and is not trying to access those fields.
+ */
+ if (access_type_mask == HV_INTERCEPT_ACCESS_EXECUTE) {
+ intercept->instruction_byte_count = 0;
+ } else {
+ intercept->instruction_byte_count = intercepted_vcpu->arch.exit_instruction_len;
+ if (intercept->instruction_byte_count > sizeof(intercept->instruction_bytes))
+ intercept->instruction_byte_count = sizeof(intercept->instruction_bytes);
+ if (kvm_read_guest_virt(intercepted_vcpu,
+ kvm_rip_read(intercepted_vcpu),
+ intercept->instruction_bytes,
+ intercept->instruction_byte_count, &e))
+ goto inject_ud;
+ }
+
+ intercept->memory_access_info.gva_valid = (gva != 0);
+ intercept->gva = gva;
+ intercept->gpa = gpa;
+ intercept->cache_type = HV_X64_CACHE_TYPE_WRITEBACK;
+ kvm_x86_ops.get_segment(intercepted_vcpu, &kvmseg, VCPU_SREG_DS);
+ store_kvm_segment(&kvmseg, &intercept->ds);
+ kvm_x86_ops.get_segment(intercepted_vcpu, &kvmseg, VCPU_SREG_SS);
+ store_kvm_segment(&kvmseg, &intercept->ss);
+ intercept->rax = kvm_rax_read(intercepted_vcpu);
+ intercept->rcx = kvm_rcx_read(intercepted_vcpu);
+ intercept->rdx = kvm_rdx_read(intercepted_vcpu);
+ intercept->rbx = kvm_rbx_read(intercepted_vcpu);
+ intercept->rsp = kvm_rsp_read(intercepted_vcpu);
+ intercept->rbp = kvm_rbp_read(intercepted_vcpu);
+ intercept->rsi = kvm_rsi_read(intercepted_vcpu);
+ intercept->rdi = kvm_rdi_read(intercepted_vcpu);
+ intercept->r8 = kvm_r8_read(intercepted_vcpu);
+ intercept->r9 = kvm_r9_read(intercepted_vcpu);
+ intercept->r10 = kvm_r10_read(intercepted_vcpu);
+ intercept->r11 = kvm_r11_read(intercepted_vcpu);
+ intercept->r12 = kvm_r12_read(intercepted_vcpu);
+ intercept->r13 = kvm_r13_read(intercepted_vcpu);
+ intercept->r14 = kvm_r14_read(intercepted_vcpu);
+ intercept->r15 = kvm_r15_read(intercepted_vcpu);
+
+ if (synic_deliver_msg(&hv_vcpu->synic, 0, &msg, true))
+ goto inject_ud;
+
+ return;
+
+inject_ud:
+ kvm_queue_exception(target_vcpu, UD_VECTOR);
+}
+
+void kvm_hv_deliver_intercept(struct kvm_vcpu *vcpu)
+{
+ struct kvm_vcpu_hv_intercept_info *info = &to_hv_vcpu(vcpu)->intercept_info;
+
+ switch (info->type) {
+ case HVMSG_GPA_INTERCEPT:
+ deliver_gpa_intercept(vcpu, info->vcpu, info->gpa, 0,
+ info->access);
+ break;
+ default:
+ pr_warn("Unknown exception\n");
+ }
+}
+EXPORT_SYMBOL_GPL(kvm_hv_deliver_intercept);
+
void kvm_hv_init_vm(struct kvm *kvm)
{
struct kvm_hv *hv = to_kvm_hv(kvm);
diff --git a/arch/x86/kvm/hyperv.h b/arch/x86/kvm/hyperv.h
index ae781b4d4669..8efc4916e0cb 100644
--- a/arch/x86/kvm/hyperv.h
+++ b/arch/x86/kvm/hyperv.h
@@ -273,4 +273,6 @@ int kvm_hv_vtl_dev_register(void);
void kvm_hv_vtl_dev_unregister(void);
int kvm_hv_faultin_pfn(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault);
+void kvm_hv_deliver_intercept(struct kvm_vcpu *vcpu);
+
#endif
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 82d3b86d9c93..f2581eec39a9 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -10707,6 +10707,9 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)
if (kvm_check_request(KVM_REQ_UPDATE_CPU_DIRTY_LOGGING, vcpu))
static_call(kvm_x86_update_cpu_dirty_logging)(vcpu);
+
+ if (kvm_check_request(KVM_REQ_HV_INJECT_INTERCEPT, vcpu))
+ kvm_hv_deliver_intercept(vcpu);
}
if (kvm_check_request(KVM_REQ_EVENT, vcpu) || req_int_win ||
--
2.40.1
next prev parent reply other threads:[~2023-11-08 11:25 UTC|newest]
Thread overview: 108+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-11-08 11:17 [RFC 0/33] KVM: x86: hyperv: Introduce VSM support Nicolas Saenz Julienne
2023-11-08 11:17 ` [RFC 01/33] KVM: x86: Decouple lapic.h from hyperv.h Nicolas Saenz Julienne
2023-11-08 16:11 ` Sean Christopherson
2023-11-08 11:17 ` [RFC 02/33] KVM: x86: Introduce KVM_CAP_APIC_ID_GROUPS Nicolas Saenz Julienne
2023-11-08 12:11 ` Alexander Graf
2023-11-08 17:47 ` Sean Christopherson
2023-11-10 18:46 ` Nicolas Saenz Julienne
2023-11-28 6:56 ` Maxim Levitsky
2023-12-01 15:25 ` Nicolas Saenz Julienne
2023-11-08 11:17 ` [RFC 03/33] KVM: x86: hyper-v: Introduce XMM output support Nicolas Saenz Julienne
2023-11-08 11:44 ` Alexander Graf
2023-11-08 12:11 ` Vitaly Kuznetsov
2023-11-08 12:16 ` Alexander Graf
2023-11-28 6:57 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 04/33] KVM: x86: hyper-v: Move hypercall page handling into separate function Nicolas Saenz Julienne
2023-11-28 7:01 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 05/33] KVM: x86: hyper-v: Introduce VTL call/return prologues in hypercall page Nicolas Saenz Julienne
2023-11-08 11:53 ` Alexander Graf
2023-11-08 14:10 ` Nicolas Saenz Julienne
2023-11-28 7:08 ` Maxim Levitsky
2023-11-28 16:33 ` Sean Christopherson
2023-12-01 16:19 ` Nicolas Saenz Julienne
2023-12-01 16:32 ` Sean Christopherson
2023-12-01 16:50 ` Nicolas Saenz Julienne
2023-12-01 17:47 ` Sean Christopherson
2023-12-01 18:15 ` Nicolas Saenz Julienne
2023-12-05 19:21 ` Sean Christopherson
2023-12-05 20:04 ` Maxim Levitsky
2023-12-06 0:07 ` Sean Christopherson
2023-12-06 16:19 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 06/33] KVM: x86: hyper-v: Introduce VTL awareness to Hyper-V's PV-IPIs Nicolas Saenz Julienne
2023-11-28 7:14 ` Maxim Levitsky
2023-12-01 16:31 ` Nicolas Saenz Julienne
2023-12-05 15:02 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 07/33] KVM: x86: hyper-v: Introduce KVM_CAP_HYPERV_VSM Nicolas Saenz Julienne
2023-11-28 7:16 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 08/33] KVM: x86: Don't use hv_timer if CAP_HYPERV_VSM enabled Nicolas Saenz Julienne
2023-11-28 7:21 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 09/33] KVM: x86: hyper-v: Introduce per-VTL vcpu helpers Nicolas Saenz Julienne
2023-11-08 12:21 ` Alexander Graf
2023-11-08 14:04 ` Nicolas Saenz Julienne
2023-11-28 7:25 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 10/33] KVM: x86: hyper-v: Introduce KVM_HV_GET_VSM_STATE Nicolas Saenz Julienne
2023-11-28 7:26 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 11/33] KVM: x86: hyper-v: Handle GET/SET_VP_REGISTER hcall in user-space Nicolas Saenz Julienne
2023-11-08 12:14 ` Alexander Graf
2023-11-28 7:26 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 12/33] KVM: x86: hyper-v: Handle VSM hcalls " Nicolas Saenz Julienne
2023-11-28 7:28 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 13/33] KVM: Allow polling vCPUs for events Nicolas Saenz Julienne
2023-11-28 7:30 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 14/33] KVM: x86: Add VTL to the MMU role Nicolas Saenz Julienne
2023-11-08 17:26 ` Sean Christopherson
2023-11-10 18:52 ` Nicolas Saenz Julienne
2023-11-28 7:34 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 15/33] KVM: x86/mmu: Introduce infrastructure to handle non-executable faults Nicolas Saenz Julienne
2023-11-28 7:34 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 16/33] KVM: x86/mmu: Expose R/W/X flags during memory fault exits Nicolas Saenz Julienne
2023-11-28 7:36 ` Maxim Levitsky
2023-11-28 16:31 ` Sean Christopherson
2023-11-08 11:17 ` [RFC 17/33] KVM: x86/mmu: Allow setting memory attributes if VSM enabled Nicolas Saenz Julienne
2023-11-28 7:39 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 18/33] KVM: x86: Decouple kvm_get_memory_attributes() from struct kvm's mem_attr_array Nicolas Saenz Julienne
2023-11-08 16:59 ` Sean Christopherson
2023-11-28 7:41 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 19/33] KVM: x86: Decouple kvm_range_has_memory_attributes() " Nicolas Saenz Julienne
2023-11-28 7:42 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 20/33] KVM: x86/mmu: Decouple hugepage_has_attrs() " Nicolas Saenz Julienne
2023-11-28 7:43 ` Maxim Levitsky
2023-11-08 11:17 ` [RFC 21/33] KVM: Pass memory attribute array as a MMU notifier argument Nicolas Saenz Julienne
2023-11-08 17:08 ` Sean Christopherson
2023-11-08 11:17 ` [RFC 22/33] KVM: Decouple kvm_ioctl_set_mem_attributes() from kvm's mem_attr_array Nicolas Saenz Julienne
2023-11-08 11:17 ` [RFC 23/33] KVM: Expose memory attribute helper functions unanimously Nicolas Saenz Julienne
2023-11-08 11:17 ` [RFC 24/33] KVM: x86: hyper-v: Introduce KVM VTL device Nicolas Saenz Julienne
2023-11-08 11:17 ` [RFC 25/33] KVM: Introduce a set of new memory attributes Nicolas Saenz Julienne
2023-11-08 12:30 ` Alexander Graf
2023-11-08 16:43 ` Sean Christopherson
2023-11-08 11:17 ` [RFC 26/33] KVM: x86: hyper-vsm: Allow setting per-VTL " Nicolas Saenz Julienne
2023-11-28 7:44 ` Maxim Levitsky
2023-11-08 11:18 ` [RFC 27/33] KVM: x86/mmu/hyper-v: Validate memory faults against per-VTL memprots Nicolas Saenz Julienne
2023-11-28 7:46 ` Maxim Levitsky
2023-11-08 11:18 ` [RFC 28/33] x86/hyper-v: Introduce memory intercept message structure Nicolas Saenz Julienne
2023-11-28 7:53 ` Maxim Levitsky
2023-11-08 11:18 ` [RFC 29/33] KVM: VMX: Save instruction length on EPT violation Nicolas Saenz Julienne
2023-11-08 12:40 ` Alexander Graf
2023-11-08 16:15 ` Sean Christopherson
2023-11-08 17:11 ` Alexander Graf
2023-11-08 17:20 ` Sean Christopherson
2023-11-08 17:27 ` Alexander Graf
2023-11-08 18:19 ` Jim Mattson
2023-11-08 11:18 ` Nicolas Saenz Julienne [this message]
2023-11-08 12:45 ` [RFC 30/33] KVM: x86: hyper-v: Introduce KVM_REQ_HV_INJECT_INTERCEPT request Alexander Graf
2023-11-08 13:38 ` Nicolas Saenz Julienne
2023-11-28 8:19 ` Maxim Levitsky
2023-11-08 11:18 ` [RFC 31/33] KVM: x86: hyper-v: Inject intercept on VTL memory protection fault Nicolas Saenz Julienne
2023-11-08 11:18 ` [RFC 32/33] KVM: x86: hyper-v: Implement HVCALL_TRANSLATE_VIRTUAL_ADDRESS Nicolas Saenz Julienne
2023-11-08 12:49 ` Alexander Graf
2023-11-08 13:44 ` Nicolas Saenz Julienne
2023-11-08 11:18 ` [RFC 33/33] Documentation: KVM: Introduce "Emulating Hyper-V VSM with KVM" Nicolas Saenz Julienne
2023-11-28 8:19 ` Maxim Levitsky
2023-11-08 11:40 ` [RFC 0/33] KVM: x86: hyperv: Introduce VSM support Alexander Graf
2023-11-08 14:41 ` Nicolas Saenz Julienne
2023-11-08 16:55 ` Sean Christopherson
2023-11-08 18:33 ` Sean Christopherson
2023-11-10 17:56 ` Nicolas Saenz Julienne
2023-11-10 19:32 ` Sean Christopherson
2023-11-11 11:55 ` Nicolas Saenz Julienne
2023-11-10 19:04 ` Nicolas Saenz Julienne
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20231108111806.92604-31-nsaenz@amazon.com \
--to=nsaenz@amazon.com \
--cc=anelkz@amazon.com \
--cc=corbert@lwn.net \
--cc=decui@microsoft.com \
--cc=dwmw@amazon.co.uk \
--cc=graf@amazon.com \
--cc=haiyangz@microsoft.com \
--cc=jgowans@amazon.com \
--cc=kvm@vger.kernel.org \
--cc=kys@microsoft.com \
--cc=linux-doc@vger.kernel.org \
--cc=linux-hyperv@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=pbonzini@redhat.com \
--cc=seanjc@google.com \
--cc=vkuznets@redhat.com \
--cc=x86@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).