x86/sev: KEXEC/KDUMP support for SEV-ES guests
Subsystems (5)
cover x86/sev: KEXEC/KDUMP support for SEV-ES guests
From: Joerg Roedel <[email protected]>
Hi,
here are changes to enable kexec/kdump in SEV-ES guests. The biggest problem for supporting kexec/kdump under SEV-ES is to find a way to hand the non-boot CPUs (APs) from one kernel to another.
Without SEV-ES the first kernel parks the CPUs in a HLT loop until they get reset by the kexec'ed kernel via an INIT-SIPI-SIPI sequence. For virtual machines the CPU reset is emulated by the hypervisor, which sets the vCPU registers back to reset state.
This does not work under SEV-ES, because the hypervisor has no access to the vCPU registers and can't make modifications to them. So an SEV-ES guest needs to reset the vCPU itself and park it using the AP-reset-hold protocol. Upon wakeup the guest needs to jump to real-mode and to the reset-vector configured in the AP-Jump-Table.
The code to do this is the main part of this patch-set. It works by placing code on the AP Jump-Table page itself to park the vCPU and for jumping to the reset vector upon wakeup. The code on the AP Jump Table runs in 16-bit protected mode with segment base set to the beginning of the page. The AP Jump-Table is usually not within the first 1MB of memory, so the code can't run in real-mode.
The AP Jump-Table is the best place to put the parking code, because the memory is owned, but read-only by the firmware and writeable by the OS. Only the first 4 bytes are used for the reset-vector, leaving the rest of the page for code/data/stack to park a vCPU. The code can't be in kernel memory because by the time the vCPU wakes up the memory will be owned by the new kernel, which might have overwritten it already.
The other patches add initial GHCB Version 2 protocol support, because kexec/kdump need the MSR-based (without a GHCB) AP-reset-hold VMGEXT, which is a GHCB protocol version 2 feature.
The kexec'ed kernel is also entered via the decompressor and needs MMIO support there, so this patch-set also adds MMIO #VC support to the decompressor and support for handling CLFLUSH instructions.
Finally there is also code to disable kexec/kdump support at runtime when the environment does not support it (e.g. no GHCB protocol version 2 support or AP Jump Table over 4GB).
The diffstat looks big, but most of it is moving code for MMIO #VC support around to make it available to the decompressor.
There is also a video showing the code in action:
https://www.youtube.com/watch?v=j1AUJANP7Mk
Please review.
Thanks,
Joerg
Joerg Roedel (12):
kexec: Allow architecture code to opt-out at runtime x86/kexec/64: Forbid kexec when running as an SEV-ES guest x86/sev: Save and print negotiated GHCB protocol version x86/sev: Do not hardcode GHCB protocol version x86/sev: Use GHCB protocol version 2 if supported x86/sev: Cache AP Jump Table Address
x86/sev: Setup code to park APs in the AP Jump Table x86/sev: Park APs on AP Jump Table with GHCB protocol version 2 x86/sev: Use AP Jump Table blob to stop CPU
x86/sev: Add MMIO handling support to boot/compressed/ code x86/sev: Handle CLFLUSH MMIO events
x86/sev: Support kexec under SEV-ES with AP Jump Table blob
arch/x86/boot/compressed/sev.c | 56 +- arch/x86/include/asm/realmode.h | 5 + arch/x86/include/asm/sev-ap-jumptable.h | 25 + arch/x86/include/asm/sev.h | 13 +- arch/x86/kernel/machine_kexec_64.c | 12 + arch/x86/kernel/process.c | 8 + arch/x86/kernel/sev-shared.c | 333 +++++++++- arch/x86/kernel/sev.c | 494 ++++++--------- arch/x86/lib/insn-eval-shared.c | 805 ++++++++++++++++++++++++ arch/x86/lib/insn-eval.c | 802 +---------------------- arch/x86/realmode/Makefile | 9 +- arch/x86/realmode/rm/Makefile | 11 +- arch/x86/realmode/rm/header.S | 3 + arch/x86/realmode/rm/sev_ap_park.S | 89 +++ arch/x86/realmode/rmpiggy.S | 6 + arch/x86/realmode/sev/Makefile | 41 ++ arch/x86/realmode/sev/ap_jump_table.S | 130 ++++ arch/x86/realmode/sev/ap_jump_table.lds | 24 + include/linux/kexec.h | 2 + kernel/kexec.c | 14 + kernel/kexec_file.c | 9 + 21 files changed, 1765 insertions(+), 1126 deletions(-) create mode 100644 arch/x86/include/asm/sev-ap-jumptable.h create mode 100644 arch/x86/lib/insn-eval-shared.c create mode 100644 arch/x86/realmode/rm/sev_ap_park.S create mode 100644 arch/x86/realmode/sev/Makefile create mode 100644 arch/x86/realmode/sev/ap_jump_table.S create mode 100644 arch/x86/realmode/sev/ap_jump_table.lds
base-commit: 8d9d46bbf3b6b7ff8edcac33603ab45c29e0e07f
Signature · 1 line
2.31.1
RFC PATCH 1/12 kexec: Allow architecture code to opt-out at runtime
From: Joerg Roedel <[email protected]>
Allow a runtime opt-out of kexec support for architecture code in case the kernel is running in an environment where kexec is not properly supported yet.
This will be used on x86 when the kernel is running as an SEV-ES guest. SEV-ES guests need special handling for kexec to hand over all CPUs to the new kernel. This requires special hypervisor support and handling code in the guest which is not yet implemented.
--- include/linux/kexec.h | 2 ++ kernel/kexec.c | 14 ++++++++++++++ kernel/kexec_file.c | 9 +++++++++ 3 files changed, 25 insertions(+)
include/linux/kexec.h +2 -0
@@ -422,6 +422,8 @@ static inline int kexec_crash_loaded(void) { return 0; }#define kexec_in_progress false#endif /* CONFIG_KEXEC_CORE */ +bool arch_kexec_supported (void ); +#endif /* !defined(__ASSEBMLY__) */ #endif /* LINUX_KEXEC_H */
kernel/kexec.c +14 -0
@@ -195,11 +195,25 @@ static int do_kexec_load(unsigned long entry, unsigned long nr_segments,* that to happen you need to do that yourself. */ +bool __weak arch_kexec_supported (void ) +{ +return true; +} +static inline int kexec_load_check (unsigned long nr_segments,unsigned long flags) {int result; +/* +* The architecture may support kexec in general, but the kernel could +* run in an environment where it is not (yet) possible to execute a new +* kernel. Allow the architecture code to opt-out of kexec support when +* it is running in such an environment. +*/ +if (!arch_kexec_supported ()) +return -ENOSYS ; +/* We only trust the superuser with rebooting the system. */ if (!capable (CAP_SYS_BOOT ) || kexec_load_disabled)return -EPERM ;
kernel/kexec_file.c +9 -0
@@ -358,6 +358,15 @@ SYSCALL_DEFINE5(kexec_file_load, int, kernel_fd, int, initrd_fd,int ret =0 , i;struct kimage **dest_image, *image; +/* +* The architecture may support kexec in general, but the kernel could +* run in an environment where it is not (yet) possible to execute a new +* kernel. Allow the architecture code to opt-out of kexec support when +* it is running in such an environment. +*/ +if (!arch_kexec_supported ()) +return -ENOSYS ; +/* We only trust the superuser with rebooting the system. */ if (!capable (CAP_SYS_BOOT ) || kexec_load_disabled)return -EPERM ;
Signature · 6 lines
2.31.1 _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
RFC PATCH 2/12 x86/kexec/64: Forbid kexec when running as an SEV-ES guest
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
For now, kexec is not supported when running as an SEV-ES guest. Doing so requires additional hypervisor support and special code to hand over the CPUs to the new kernel in a safe way.
Until this is implemented, do not support kexec in SEV-ES guests.
--- arch/x86/kernel/machine_kexec_64.c | 8 ++++++++ 1 file changed, 8 insertions(+)
arch/x86/kernel/machine_kexec_64.c +8 -0
@@ -620,3 +620,11 @@ void arch_kexec_pre_free_pages(void *vaddr, unsigned int pages)*/ set_memory_encrypted ((unsigned long )vaddr, pages); } + +/* +* Kexec is not supported in SEV-ES guests yet +*/ +bool arch_kexec_supported (void ) +{ +return !sev_es_active (); +}
Signature · 6 lines
2.31.1 _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
RFC PATCH 3/12 x86/sev: Save and print negotiated GHCB protocol version
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
Save the results of the GHCB protocol negotiation into a data structure and print information about versions supported and used to the kernel log.
--- arch/x86/boot/compressed/sev.c | 2 +- arch/x86/kernel/sev-shared.c | 22 +++++++++++++++++++++- arch/x86/kernel/sev.c | 13 ++++++++++++- 3 files changed, 34 insertions(+), 3 deletions(-)
arch/x86/boot/compressed/sev.c +1 -1
@@ -121,7 +121,7 @@ static enum es_result vc_read_mem(struct es_em_ctxt *ctxt,static bool early_setup_sev_es (void ) { -if (!sev_es_negotiate_protocol ()) +if (!sev_es_negotiate_protocol (NULL ))sev_es_terminate (GHCB_SEV_ES_REASON_PROTOCOL_UNSUPPORTED );if (set_page_decrypted ((unsigned long )&boot_ghcb_page))
arch/x86/kernel/sev-shared.c +21 -1
@@ -14,6 +14,20 @@#define has_cpuflag (f) boot_cpu_has(f)#endif +/* +* struct sev_ghcb_protocol_info - Used to return GHCB protocol +* negotiation details. +* +* @hv_proto_min: Minimum GHCB protocol version supported by Hypervisor +* @hv_proto_max: Maximum GHCB protocol version supported by Hypervisor +* @vm_proto: Protocol version the VM (this kernel) will use +*/ +struct sev_ghcb_protocol_info { +unsigned int hv_proto_min; +unsigned int hv_proto_max; +unsigned int vm_proto; +}; +static bool __init sev_es_check_cpu_features (void ) {if (!has_cpuflag (X86_FEATURE_RDRAND )) {
@@ -42,7 +56,7 @@ static void __noreturn sev_es_terminate(unsigned int reason) asmvolatile ("hlt\n" : : :"memory" ); } -static bool sev_es_negotiate_protocol (void ) +static bool sev_es_negotiate_protocol (struct sev_ghcb_protocol_info *info) {u64 val;
@@ -58,6 +72,12 @@ static bool sev_es_negotiate_protocol(void) GHCB_MSR_PROTO_MIN(val) > GHCB_PROTO_OUR)return false; +if (info) { + info->hv_proto_min =GHCB_MSR_PROTO_MIN (val); + info->hv_proto_max =GHCB_MSR_PROTO_MAX (val); + info->vm_proto =GHCB_PROTO_OUR ; + } +return true; }
arch/x86/kernel/sev.c +12 -1
@@ -495,6 +495,9 @@ static enum es_result vc_slow_virt_to_phys(struct ghcb *ghcb, struct es_em_ctxt/* Include code shared with pre-decompression boot stage */ #include "sev-shared.c" +/* Negotiated GHCB protocol version */ +static struct sev_ghcb_protocol_info ghcb_protocol_info__ro_after_init ; + static noinstr void __sev_put_ghcb(struct ghcb_state *state) {struct sev_es_runtime_data *data;
@@ -665,7 +668,7 @@ static enum es_result vc_handle_msr(struct ghcb *ghcb, struct es_em_ctxt *ctxt)static bool __init sev_es_setup_ghcb (void ) {/* First make sure the hypervisor talks a supported protocol. */ -if (!sev_es_negotiate_protocol ()) +if (!sev_es_negotiate_protocol (&ghcb_protocol_info))return false;/*
@@ -794,6 +797,14 @@ void __init sev_es_init_vc_handling(void)/* Secondary CPUs use the runtime #VC handler */ initial_vc_handler = (unsigned long )kernel_exc_vmm_communication; + +/* +* Print information about supported and negotiated GHCB protocol +* versions. +*/ +pr_info ("Hypervisor GHCB protocol version support: min=%u max=%u\n" , + ghcb_protocol_info.hv_proto_min, ghcb_protocol_info.hv_proto_max); +pr_info ("Using GHCB protocol version %u\n" , ghcb_protocol_info.vm_proto); }static void __init vc_early_forward_exception (struct es_em_ctxt *ctxt)
Signature · 6 lines
2.31.1 _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
RFC PATCH 4/12 x86/sev: Do not hardcode GHCB protocol version
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
Introduce the sev_get_ghcb_proto_ver() which will return the negotiated GHCB protocol version and use it to set the version field in the GHCB.
--- arch/x86/boot/compressed/sev.c | 5 +++++ arch/x86/kernel/sev-shared.c | 5 ++++- arch/x86/kernel/sev.c | 5 +++++ 3 files changed, 14 insertions(+), 1 deletion(-)
arch/x86/boot/compressed/sev.c +5 -0
@@ -119,6 +119,11 @@ static enum es_result vc_read_mem(struct es_em_ctxt *ctxt,/* Include code for early handlers */ #include "../../kernel/sev-shared.c" +static u64 sev_get_ghcb_proto_ver (void ) +{ +return GHCB_PROTOCOL_MAX ; +} +static bool early_setup_sev_es (void ) {if (!sev_es_negotiate_protocol (NULL ))
arch/x86/kernel/sev-shared.c +4 -1
@@ -28,6 +28,9 @@ struct sev_ghcb_protocol_info {unsigned int vm_proto; }; +/* Returns the negotiated GHCB Protocol version */ +static u64 sev_get_ghcb_proto_ver (void ); +static bool __init sev_es_check_cpu_features (void ) {if (!has_cpuflag (X86_FEATURE_RDRAND )) {
@@ -122,7 +125,7 @@ static enum es_result sev_es_ghcb_hv_call(struct ghcb *ghcb,enum es_result ret;/* Fill in protocol and format specifiers */ - ghcb->protocol_version =GHCB_PROTOCOL_MAX ; + ghcb->protocol_version =sev_get_ghcb_proto_ver (); ghcb->ghcb_usage =GHCB_DEFAULT_USAGE ;ghcb_set_sw_exit_code (ghcb, exit_code);
arch/x86/kernel/sev.c +5 -0
@@ -498,6 +498,11 @@ static enum es_result vc_slow_virt_to_phys(struct ghcb *ghcb, struct es_em_ctxt/* Negotiated GHCB protocol version */ static struct sev_ghcb_protocol_info ghcb_protocol_info__ro_after_init ; +static u64 sev_get_ghcb_proto_ver (void ) +{ +return ghcb_protocol_info.vm_proto; +} + static noinstr void __sev_put_ghcb(struct ghcb_state *state) {struct sev_es_runtime_data *data;
Signature · 6 lines
2.31.1 _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
RFC PATCH 5/12 x86/sev: Use GHCB protocol version 2 if supported
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
Check whether the hypervisor supports GHCB version 2 and use it if available.
--- arch/x86/boot/compressed/sev.c | 10 ++++++++-- arch/x86/include/asm/sev.h | 4 ++-- arch/x86/kernel/sev-shared.c | 17 ++++++++++++++--- 3 files changed, 24 insertions(+), 7 deletions(-)
arch/x86/boot/compressed/sev.c +8 -2
@@ -119,16 +119,22 @@ static enum es_result vc_read_mem(struct es_em_ctxt *ctxt,/* Include code for early handlers */ #include "../../kernel/sev-shared.c" +static unsigned int ghcb_protocol; +static u64 sev_get_ghcb_proto_ver (void ) { -return GHCB_PROTOCOL_MAX ; +return ghcb_protocol; }static bool early_setup_sev_es (void ) { -if (!sev_es_negotiate_protocol (NULL )) +struct sev_ghcb_protocol_info info; + +if (!sev_es_negotiate_protocol (&info))sev_es_terminate (GHCB_SEV_ES_REASON_PROTOCOL_UNSUPPORTED ); + ghcb_protocol = info.vm_proto; +if (set_page_decrypted ((unsigned long )&boot_ghcb_page))return false;
arch/x86/include/asm/sev.h +2 -2
@@ -12,8 +12,8 @@#include <asm/insn.h> #include <asm/sev-common.h> -#define GHCB_PROTO_OUR 0x0001UL -#define GHCB_PROTOCOL_MAX 1ULL +#define GHCB_PROTOCOL_MIN 1ULL +#define GHCB_PROTOCOL_MAX 2ULL#define GHCB_DEFAULT_USAGE 0ULL#define VMGEXIT () { asm volatile("rep; vmmcall\n\r"); }
arch/x86/kernel/sev-shared.c +14 -3
@@ -61,6 +61,7 @@ static void __noreturn sev_es_terminate(unsigned int reason)static bool sev_es_negotiate_protocol (struct sev_ghcb_protocol_info *info) { +unsigned int protocol;u64 val;/* Do the GHCB protocol version negotiation */
@@ -71,14 +72,24 @@ static bool sev_es_negotiate_protocol(struct sev_ghcb_protocol_info *info)if (GHCB_MSR_INFO (val) !=GHCB_MSR_SEV_INFO_RESP )return false; -if (GHCB_MSR_PROTO_MAX (val) <GHCB_PROTO_OUR || -GHCB_MSR_PROTO_MIN (val) >GHCB_PROTO_OUR ) +/* Sanity check untrusted input */ +if (GHCB_MSR_PROTO_MIN (val) >GHCB_MSR_PROTO_MAX (val)) +return false; + +/* Use maximum supported protocol version */ + protocol = min_t(unsigned int, GHCB_MSR_PROTO_MAX(val), GHCB_PROTOCOL_MAX); + +/* +* Hypervisor does not support any protocol version required for this +* kernel. +*/ +if (protocol <GHCB_MSR_PROTO_MIN (val))return false;if (info) { info->hv_proto_min =GHCB_MSR_PROTO_MIN (val); info->hv_proto_max =GHCB_MSR_PROTO_MAX (val); - info->vm_proto =GHCB_PROTO_OUR ; + info->vm_proto = protocol; }return true;
Signature · 1 line
2.31.1
RFC PATCH 6/12 x86/sev: Cache AP Jump Table Address
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
Store the physical address of the AP Jump Table in kernel memory so that it does not need to be fetched from the Hypervisor again.
--- arch/x86/kernel/sev.c | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-)
arch/x86/kernel/sev.c +14 -12
@@ -42,6 +42,9 @@ static struct ghcb boot_ghcb_page __bss_decrypted __aligned(PAGE_SIZE);*/ static struct ghcb __initdata *boot_ghcb; +/* Cached AP Jump Table Address */ +static phys_addr_t sev_es_jump_table_pa; +/* #VC handler runtime per-CPU data */ struct sev_es_runtime_data {struct ghcb ghcb_page;
@@ -546,12 +549,14 @@ void noinstr __sev_es_nmi_complete(void)__sev_put_ghcb (&state); } -static u64 get_jump_table_addr (void ) +static phys_addr_t get_jump_table_addr (void ) {struct ghcb_state state;unsigned long flags;struct ghcb *ghcb; -u64 ret =0 ; + +if (sev_es_jump_table_pa) +return sev_es_jump_table_pa;local_irq_save (flags);
@@ -567,39 +572,36 @@ static u64 get_jump_table_addr(void)if (ghcb_sw_exit_info_1_is_valid (ghcb) &&ghcb_sw_exit_info_2_is_valid (ghcb)) - ret = ghcb->save.sw_exit_info_2; + sev_es_jump_table_pa = (phys_addr_t )ghcb->save.sw_exit_info_2;__sev_put_ghcb (&state);local_irq_restore (flags); -return ret; +return sev_es_jump_table_pa; }int sev_es_setup_ap_jump_table (struct real_mode_header *rmh) {u16 startup_cs, startup_ip; -phys_addr_t jump_table_pa; -u64 jump_table_addr;u16 __iomem *jump_table; +phys_addr_t pa; - jump_table_addr =get_jump_table_addr (); + pa =get_jump_table_addr ();/* On UP guests there is no jump table so this is not a failure */ -if (!jump_table_addr) +if (!pa)return 0 ;/* Check if AP Jump Table is page-aligned */ -if (jump_table_addr & ~PAGE_MASK ) +if (pa & ~PAGE_MASK )return -EINVAL ; - jump_table_pa = jump_table_addr &PAGE_MASK ; - startup_cs = (u16)(rmh->trampoline_start >>4 ); startup_ip = (u16)(rmh->sev_es_trampoline_start - rmh->trampoline_start); - jump_table =ioremap_encrypted (jump_table_pa,PAGE_SIZE ); + jump_table =ioremap_encrypted (pa,PAGE_SIZE );if (!jump_table)return -EIO ;
Signature · 1 line
2.31.1
RFC PATCH 7/12 x86/sev: Setup code to park APs in the AP Jump Table
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
The AP Jump Table under SEV-ES contains the reset vector where non-boot CPUs start executing when coming out of reset. This means that a CPU coming out of the AP-reset-hold VMGEXIT also needs to start executing at the reset vector stored in the AP Jump Table.
The problem is to find a safe place to put the real-mode code which executes the VMGEXIT and jumps to the reset vector. The code can not be in kernel memory, because after kexec that memory is owned by the new kernel and the code might have been overwritten.
Fortunately the AP Jump Table itself is a safe place, because the memory is not owned by the OS and will not be overwritten by a new kernel started through kexec. The table is 4k in size and only the first 4 bytes are used for the reset vector. This leaves enough space for some 16-bit code to do the job and even a small stack.
Install 16-bit code into the AP Jump Table under SEV-ES after the APs have been brought up. The code will do an AP-reset-hold VMGEXIT and jump to the reset vector after being woken up.
--- arch/x86/include/asm/realmode.h | 2 + arch/x86/include/asm/sev-ap-jumptable.h | 25 +++++ arch/x86/kernel/sev.c | 105 +++++++++++++++++++ arch/x86/realmode/Makefile | 9 +- arch/x86/realmode/rmpiggy.S | 6 ++ arch/x86/realmode/sev/Makefile | 41 ++++++++ arch/x86/realmode/sev/ap_jump_table.S | 130 ++++++++++++++++++++++++ arch/x86/realmode/sev/ap_jump_table.lds | 24 +++++ 8 files changed, 341 insertions(+), 1 deletion(-) create mode 100644 arch/x86/include/asm/sev-ap-jumptable.h create mode 100644 arch/x86/realmode/sev/Makefile create mode 100644 arch/x86/realmode/sev/ap_jump_table.S create mode 100644 arch/x86/realmode/sev/ap_jump_table.lds
arch/x86/include/asm/realmode.h +2 -0
@@ -62,6 +62,8 @@ extern unsigned long initial_gs;extern unsigned long initial_stack;#ifdef CONFIG_AMD_MEM_ENCRYPT extern unsigned long initial_vc_handler; +extern unsigned char rm_ap_jump_table_blob[]; +extern unsigned char rm_ap_jump_table_blob_end[];#endif extern unsigned char real_mode_blob[];
arch/x86/include/asm/sev-ap-jumptable.h new file +25 -0
@@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* AMD Encrypted Register State Support +* +* Author: Joerg Roedel <[email protected]> +*/ +#ifndef __ASM_SEV_AP_JUMPTABLE_H +#define __ASM_SEV_AP_JUMPTABLE_H + +#define SEV_APJT_CS16 0x8 +#define SEV_APJT_DS16 0x10 + +#define SEV_APJT_ENTRY 0x10 + +#ifndef __ASSEMBLY__ + +struct sev_ap_jump_table_header { +u16 reset_ip; +u16 reset_cs; +u16 gdt_offset; +}; + +#endif /* !__ASSEMBLY__ */ + +#endif /* __ASM_SEV_AP_JUMPTABLE_H */
arch/x86/kernel/sev.c +105 -0
123 lines not on this page · raw message
arch/x86/realmode/Makefile +8 -1
@@ -12,12 +12,19 @@ KASAN_SANITIZE := n KCSAN_SANITIZE := n OBJECT_FILES_NON_STANDARD := y +RMPIGGY-y = $(obj)/rm/realmode.bin +RMPIGGY-$(CONFIG_AMD_MEM_ENCRYPT) += $(obj)/sev/ap_jump_table.bin + subdir- := rm +subdir- := sev obj-y += init.o obj-y += rmpiggy.o -$(obj)/rmpiggy.o: $(obj)/rm/realmode.bin +$(obj)/rmpiggy.o: $(RMPIGGY-y) $(obj)/rm/realmode.bin: FORCE $(Q)$(MAKE) $(build)=$(obj)/rm $@ + +$(obj)/sev/ap_jump_table.bin: FORCE + $(Q)$(MAKE) $(build)=$(obj)/sev $@
arch/x86/realmode/rmpiggy.S +6 -0
@@ -17,3 +17,9 @@ SYM_DATA_END_LABEL(real_mode_blob, SYM_L_GLOBAL, real_mode_blob_end) SYM_DATA_START(real_mode_relocs) .incbin "arch/x86/realmode/rm/realmode.relocs" SYM_DATA_END(real_mode_relocs) + +#ifdef CONFIG_AMD_MEM_ENCRYPT +SYM_DATA_START(rm_ap_jump_table_blob) + .incbin "arch/x86/realmode/sev/ap_jump_table.bin" +SYM_DATA_END_LABEL(rm_ap_jump_table_blob, SYM_L_GLOBAL, rm_ap_jump_table_blob_end) +#endif
arch/x86/realmode/sev/Makefile new file +41 -0
41 lines not on this page · raw message
arch/x86/realmode/sev/ap_jump_table.S new file +130 -0
130 lines not on this page · raw message
arch/x86/realmode/sev/ap_jump_table.lds new file +24 -0
@@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * ap_jump_table.lds + * + * Linker script for the SEV-ES AP Jump Table Code + */ + +OUTPUT_FORMAT("elf32-i386") +OUTPUT_ARCH(i386) +ENTRY(ap_park_asm) + +SECTIONS +{ + . = 0; + .text : { + *(.text) + *(.text.*) + } + + /DISCARD/ : { + *(.note*) + *(.debug*) + } +}
Signature · 1 line
2.31.1
RFC PATCH 8/12 x86/sev: Park APs on AP Jump Table with GHCB protocol version 2
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
GHCB protocol version 2 adds the MSR-based AP-reset-hold VMGEXIT which does not need a GHCB. Use that to park APs in 16-bit protected mode on the AP Jump Table.
--- arch/x86/include/asm/realmode.h | 3 + arch/x86/kernel/sev.c | 48 ++++++++++++++-- arch/x86/realmode/rm/Makefile | 11 ++-- arch/x86/realmode/rm/header.S | 3 + arch/x86/realmode/rm/sev_ap_park.S | 89 ++++++++++++++++++++++++++++++ 5 files changed, 144 insertions(+), 10 deletions(-) create mode 100644 arch/x86/realmode/rm/sev_ap_park.S
arch/x86/include/asm/realmode.h +3 -0
@@ -23,6 +23,9 @@ struct real_mode_header {u32 trampoline_header;#ifdef CONFIG_AMD_MEM_ENCRYPT u32 sev_es_trampoline_start; +u32 sev_real_ap_park_asm; +u32 sev_real_ap_park_seg; +u32 sev_ap_park_gdt;#endif #ifdef CONFIG_X86_64 u32 trampoline_pgd;
arch/x86/kernel/sev.c +43 -5
79 lines not on this page · raw message
arch/x86/realmode/rm/Makefile +6 -5
@@ -27,11 +27,12 @@ wakeup-objs += video-vga.o wakeup-objs += video-vesa.o wakeup-objs += video-bios.o -realmode-y += header.o -realmode-y += trampoline_$(BITS).o -realmode-y += stack.o -realmode-y += reboot.o -realmode-$(CONFIG_ACPI_SLEEP) += $(wakeup-objs) +realmode-y += header.o +realmode-y += trampoline_$(BITS).o +realmode-y += stack.o +realmode-y += reboot.o +realmode-$(CONFIG_ACPI_SLEEP) += $(wakeup-objs) +realmode-$(CONFIG_AMD_MEM_ENCRYPT) += sev_ap_park.o targets += $(realmode-y)
arch/x86/realmode/rm/header.S +3 -0
@@ -22,6 +22,9 @@ SYM_DATA_START(real_mode_header) .long pa_trampoline_header #ifdef CONFIG_AMD_MEM_ENCRYPT .long pa_sev_es_trampoline_start + .long pa_sev_ap_park_asm + .long __KERNEL32_CS + .long pa_sev_ap_park_gdt; #endif #ifdef CONFIG_X86_64 .long pa_trampoline_pgd;
arch/x86/realmode/rm/sev_ap_park.S new file +89 -0
89 lines not on this page · raw message
Signature · 1 line
2.31.1
RFC PATCH 9/12 x86/sev: Use AP Jump Table blob to stop CPU
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
To support kexec under SEV-ES the APs can't be parked with HLT. Upon wakeup the AP needs to find its way to execute at the reset vector set by the new kernel and in real-mode.
This is what the AP Jump Table blob provides, so stop the APs the SEV-ES way by calling the AP-reset-hold VMGEXIT from the AP Jump Table.
--- arch/x86/include/asm/sev.h | 7 +++++++ arch/x86/kernel/process.c | 8 ++++++++ arch/x86/kernel/sev.c | 11 ++++++++++- 3 files changed, 25 insertions(+), 1 deletion(-)
arch/x86/include/asm/sev.h +7 -0
@@ -81,12 +81,19 @@ static __always_inline void sev_es_nmi_complete(void)__sev_es_nmi_complete (); }extern int __init sev_es_efi_map_ghcbs (pgd_t *pgd); +void __sev_es_stop_this_cpu (void ); +static __always_inline void sev_es_stop_this_cpu(void) +{ +if (static_branch_unlikely (&sev_es_enable_key)) +__sev_es_stop_this_cpu (); +}#else static inline void sev_es_ist_enter (struct pt_regs *regs) { }static inline void sev_es_ist_exit (void ) { }static inline int sev_es_setup_ap_jump_table (struct real_mode_header *rmh) {return 0 ; }static inline void sev_es_nmi_complete (void ) { }static inline int sev_es_efi_map_ghcbs (pgd_t *pgd) {return 0 ; } +static inline void sev_es_stop_this_cpu (void ) { }#endif #endif
arch/x86/kernel/process.c +8 -0
@@ -43,6 +43,7 @@#include <asm/io_bitmap.h> #include <asm/proto.h> #include <asm/frame.h> +#include <asm/sev.h> #include "process.h"
@@ -736,6 +737,13 @@ void stop_this_cpu(void *dummy)if (boot_cpu_has (X86_FEATURE_SME ))native_wbinvd ();for (;;) { +/* +* SEV-ES guests need a special stop routine to support +* kexec. Try this first, if it fails the function will +* return and native_halt() is used. +*/ +sev_es_stop_this_cpu (); +/* * Use native_halt() so that memory contents don't change * (stack usage and variables) after possibly issuing the
arch/x86/kernel/sev.c +10 -1
@@ -695,7 +695,6 @@ static bool __init sev_es_setup_ghcb(void)return true; } -#ifdef CONFIG_HOTPLUG_CPU static void __noreturn sev_jumptable_ap_park (void ) {local_irq_disable ();
@@ -725,6 +724,16 @@ static void __noreturn sev_jumptable_ap_park(void) }STACK_FRAME_NON_STANDARD (sev_jumptable_ap_park); +void __sev_es_stop_this_cpu (void ) +{ +/* Only park in the AP Jump Table when the code has been installed */ +if (!sev_ap_jumptable_blob_installed) +return ; + +sev_jumptable_ap_park (); +} + +#ifdef CONFIG_HOTPLUG_CPU static void sev_es_ap_hlt_loop (void ) {struct ghcb_state state;
Signature · 1 line
2.31.1
RFC PATCH 10/12 x86/sev: Add MMIO handling support to boot/compressed/ code
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
Move the code for MMIO handling in the #VC handler to sev-shared.c so that it can be used in the decompressor code. The decompressor needs to handle MMIO events for writing to the VGA framebuffer.
When the kernel is booted via UEFI the VGA console is not enabled that early, but a kexec boot will enable it and the decompressor needs MMIO support to write to the frame buffer.
This also requires to share some code from lib/insn-eval.c. Since insn-eval.c can't be included into the decompressor code directly, move the relevant parts into lib/insn-eval-shared.c and include that file.
--- arch/x86/boot/compressed/sev.c | 43 +- arch/x86/kernel/sev-shared.c | 282 +++++++++++ arch/x86/kernel/sev.c | 282 ----------- arch/x86/lib/insn-eval-shared.c | 805 ++++++++++++++++++++++++++++++++ arch/x86/lib/insn-eval.c | 802 +------------------------------ 5 files changed, 1116 insertions(+), 1098 deletions(-) create mode 100644 arch/x86/lib/insn-eval-shared.c
arch/x86/boot/compressed/sev.c +25 -18
@@ -26,24 +26,8 @@struct ghcb boot_ghcb_page__aligned(PAGE_SIZE) ;struct ghcb *boot_ghcb; -/* -* Copy a version of this function here - insn-eval.c can't be used in -* pre-decompression code. -*/ -static bool insn_has_rep_prefix (struct insn *insn) -{ -insn_byte_t p; -int i; - -insn_get_prefixes (insn); - -for_each_insn_prefix (insn, i, p) { -if (p ==0xf2 || p ==0xf3 ) -return true; - } - -return false; -} +#undef WARN_ONCE +#define WARN_ONCE(condition, format...)/* * Only a dummy for insn_get_seg_base() - Early boot-code is 64bit only and
@@ -54,6 +38,17 @@ static unsigned long insn_get_seg_base(struct pt_regs *regs, int seg_reg_idx)return 0UL ; } +/* The decompressor only uses flat segments */ +static int get_seg_base_limit (struct insn *insn,struct pt_regs *regs, +int regoff,unsigned long *base, +unsigned long *limit) +{ +if (base) + *base =0L ; +if (limit) + *limit = ~0L ; +} +static inline u64 sev_es_rd_ghcb_msr (void ) {unsigned long low, high;
@@ -105,6 +100,14 @@ static enum es_result vc_read_mem(struct es_em_ctxt *ctxt,return ES_OK ; } +static enum es_result vc_slow_virt_to_phys (struct ghcb *ghcb,struct es_em_ctxt *ctxt, +unsigned long vaddr,phys_addr_t *paddr) +{ + *paddr = (phys_addr_t )vaddr; + +return ES_OK ; +} +#undef __init#undef __pa#define __init
@@ -115,6 +118,7 @@ static enum es_result vc_read_mem(struct es_em_ctxt *ctxt,/* Basic instruction decoding support needed */ #include "../../lib/inat.c" #include "../../lib/insn.c" +#include "../../lib/insn-eval-shared.c" /* Include code for early handlers */ #include "../../kernel/sev-shared.c"
@@ -204,6 +208,9 @@ void do_boot_stage2_vc(struct pt_regs *regs, unsigned long exit_code)case SVM_EXIT_CPUID : result =vc_handle_cpuid (boot_ghcb, &ctxt);break ; +case SVM_EXIT_NPF : + result =vc_handle_mmio (boot_ghcb, &ctxt); +break ;default : result =ES_UNSUPPORTED ;break ;
arch/x86/kernel/sev-shared.c +282 -0
285 lines not on this page · raw message
arch/x86/kernel/sev.c +0 -282
288 lines not on this page · raw message
arch/x86/lib/insn-eval-shared.c new file +805 -0
805 lines not on this page · raw message
arch/x86/lib/insn-eval.c +4 -798
827 lines not on this page · raw message
Signature · 1 line
2.31.1
RFC PATCH 11/12 x86/sev: Handle CLFLUSH MMIO events
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
Handle CLFLUSH instruction to MMIO memory in the #VC handler. The instruction is ignored by the handler, as the Hypervisor is responsible for cache management of emulated MMIO memory.
--- arch/x86/kernel/sev-shared.c | 9 +++++++++ 1 file changed, 9 insertions(+)
arch/x86/kernel/sev-shared.c +9 -0
@@ -632,6 +632,15 @@ static enum es_result vc_handle_mmio_twobyte_ops(struct ghcb *ghcb,long *reg_data;switch (insn->opcode.bytes[1 ]) { +/* CLFLUSH */ +case 0xae : +/* +* Ignore CLFLUSHes - those go to emulated MMIO anyway and the +* hypervisor is responsible for cache management. +*/ + ret =ES_OK ; +break ; +/* MMIO Read w/ zero-extension */ case 0xb6 : bytes =1 ;
Signature · 1 line
2.31.1
RFC PATCH 12/12 x86/sev: Support kexec under SEV-ES with AP Jump Table blob
In reply to Joerg RoedelFrom: Joerg Roedel <[email protected]>
When the AP Jump Table blob is installed the kernel can hand over the APs from the old to the new kernel. Enable kexec when the AP Jump Table blob has been installed.
--- arch/x86/include/asm/sev.h | 2 ++ arch/x86/kernel/machine_kexec_64.c | 6 +++++- arch/x86/kernel/sev.c | 12 ++++++++++++ 3 files changed, 19 insertions(+), 1 deletion(-)
arch/x86/include/asm/sev.h +2 -0
@@ -87,6 +87,7 @@ static __always_inline void sev_es_stop_this_cpu(void)if (static_branch_unlikely (&sev_es_enable_key)) __sev_es_stop_this_cpu(); } +bool sev_kexec_supported (void );#else static inline void sev_es_ist_enter (struct pt_regs *regs) { }static inline void sev_es_ist_exit (void ) { }
@@ -94,6 +95,7 @@ static inline int sev_es_setup_ap_jump_table(struct real_mode_header *rmh) { retstatic inline void sev_es_nmi_complete (void ) { }static inline int sev_es_efi_map_ghcbs (pgd_t *pgd) {return 0 ; }static inline void sev_es_stop_this_cpu (void ) { } +static bool sev_kexec_supported (void ) {return true; }#endif #endif
arch/x86/kernel/machine_kexec_64.c +5 -1
@@ -26,6 +26,7 @@#include <asm/kexec-bzimage64.h> #include <asm/setup.h> #include <asm/set_memory.h> +#include <asm/sev.h> #ifdef CONFIG_ACPI /*
@@ -626,5 +627,8 @@ void arch_kexec_pre_free_pages(void *vaddr, unsigned int pages)*/ bool arch_kexec_supported (void ) { -return !sev_es_active (); +if (!sev_kexec_supported ()) +return false; + +return true; }
arch/x86/kernel/sev.c +12 -0
@@ -901,6 +901,18 @@ static int __init sev_es_setup_ap_jump_table_blob(void) }core_initcall (sev_es_setup_ap_jump_table_blob); +bool sev_kexec_supported (void ) +{ +/* +* KEXEC with SEV-ES and more than one CPU is only supported +* when the AP Jump Table is installed. +*/ +if (num_possible_cpus () >1 ) +return !sev_es_active () || sev_ap_jumptable_blob_installed; +else +return true; +} +static void __init alloc_runtime_data (int cpu) {struct sev_es_runtime_data *data;
Signature · 1 line
2.31.1