x86/sev: KEXEC/KDUMP support for SEV-ES guests
Subsystems (7)
v2 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 VMGEXIT, 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.
These patches need a fix I sent out earlier today to work reliably:
https://lore.kernel.org/lkml/[email protected]/
Please review.
Thanks,
Joerg
Changes v1->v2:
- Rebased to v5.15-rc1
- Fixed occasional triple-faults when parking APs, see separate fix
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 | 1 + kernel/kexec.c | 14 + kernel/kexec_file.c | 9 + 21 files changed, 1764 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: 6880fa6c56601bb8ed59df6c30fd390cc5f6dd8f
Signature · 1 line
2.33.0
PATCH v2 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 | 1 + kernel/kexec.c | 14 ++++++++++++++ kernel/kexec_file.c | 9 +++++++++ 3 files changed, 24 insertions(+)
include/linux/kexec.h +1 -0
@@ -201,6 +201,7 @@ int arch_kexec_kernel_verify_sig(struct kimage *image, void *buf, unsigned long buf_len);#endif int arch_kexec_locate_mem_hole (struct kexec_buf *kbuf); +bool arch_kexec_supported (void );extern int kexec_add_buffer (struct kexec_buf *kbuf);int kexec_locate_mem_hole (struct kexec_buf *kbuf);
kernel/kexec.c +14 -0
@@ -190,11 +190,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 · 1 line
2.33.0
Borislav Petkov
maintainerRe: [PATCH v2 01/12] kexec: Allow architecture code to opt-out at runtime
Quoted 11 lines · Joerg Roedel
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.
Quoted 7 lines
Cc [email protected] # v5.10+Signed-off-by Joerg Roedel <[email protected]>--- include/linux/kexec.h | 1 + kernel/kexec.c | 14 ++++++++++++++ kernel/kexec_file.c | 9 +++++++++ 3 files changed, 24 insertions(+)
I guess I can take this through the tip tree along with the next one.
Eric?
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v2 01/12] kexec: Allow architecture code to opt-out at runtime
Quoted 20 lines · Borislav Petkov
Quoted 11 lines · Joerg Roedel
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.
Quoted 7 lines
Cc [email protected] # v5.10+Signed-off-by Joerg Roedel <[email protected]>--- include/linux/kexec.h | 1 + kernel/kexec.c | 14 ++++++++++++++ kernel/kexec_file.c | 9 +++++++++ 3 files changed, 24 insertions(+)
Quoted 1 line
I guess I can take this through the tip tree along with the next one.
I seem to remember the consensus when this was reviewed that it was unnecessary and there is already support for doing something like this at a more fine grained level so we don't need a new kexec hook.
Eric
Re: [PATCH v2 01/12] kexec: Allow architecture code to opt-out at runtime
Quoted 3 lines · Eric W. Biederman
I seem to remember the consensus when this was reviewed that it was unnecessary and there is already support for doing something like this at a more fine grained level so we don't need a new kexec hook.
It was a discussion, no consenus :)
I still think it is better to solve this in generic code for everybody to re-use than with an hack in the architecture hooks.
More and more platforms which enable confidential computing features may need this hook in the future.
Regards,
Signature · 10 lines
Jörg Rödel [email protected] SUSE Software Solutions Germany GmbH Maxfeldstr. 5 90409 Nürnberg Germany (HRB 36809, AG Nürnberg) Geschäftsführer: Ivo Totev
Re: [PATCH v2 01/12] kexec: Allow architecture code to opt-out at runtime
In reply to Eric W. BiedermanHi again,
Quoted 3 lines · Eric W. Biederman
I seem to remember the consensus when this was reviewed that it was unnecessary and there is already support for doing something like this at a more fine grained level so we don't need a new kexec hook.
Forgot to state to problem again which these patches solve:
Currently a Linux kernel running as an SEV-ES guest has no way to successfully kexec into a new kernel. The normal SIPI sequence to reset the non-boot VCPUs does not work in SEV-ES guests and special code is needed in Linux to safely hand over the VCPUs from one kernel to the next. What happens currently is that the kexec'ed kernel will just hang.
The code which implements the VCPU hand-over is also included in this patch-set, but it requires a certain level of Hypervisor support which is not available everywhere.
To make it clear to the user that kexec will not work in their environment, it is best to disable the respected syscalls. This is what the hook is needed for.
Regards,
Signature · 10 lines
Jörg Rödel [email protected] SUSE Software Solutions Germany GmbH Maxfeldstr. 5 90409 Nürnberg Germany (HRB 36809, AG Nürnberg) Geschäftsführer: Ivo Totev
Re: [PATCH v2 01/12] kexec: Allow architecture code to opt-out at runtime
Quoted 15 lines · Joerg Roedel
Hi again,
Quoted 3 lines · Eric W. Biederman
I seem to remember the consensus when this was reviewed that it was unnecessary and there is already support for doing something like this at a more fine grained level so we don't need a new kexec hook.
Forgot to state to problem again which these patches solve:
Currently a Linux kernel running as an SEV-ES guest has no way to successfully kexec into a new kernel. The normal SIPI sequence to reset the non-boot VCPUs does not work in SEV-ES guests and special code is needed in Linux to safely hand over the VCPUs from one kernel to the next. What happens currently is that the kexec'ed kernel will just hang.
Quoted 7 lines
The code which implements the VCPU hand-over is also included in this patch-set, but it requires a certain level of Hypervisor support which is not available everywhere.
To make it clear to the user that kexec will not work in their environment, it is best to disable the respected syscalls. This is what the hook is needed for.
Note this is environmental. This is the equivalent of a driver for a device without some feature.
The kernel already has machine_kexec_prepare, which is perfectly capable of detecting this is a problem and causing kexec_load to fail. Which is all that is required.
We don't need a new hook and a new code path to test for one architecture.
So when we can reliably cause the system call to fail with a specific error code I don't think it makes sense to make clutter up generic code because of one architecture's design mistakes.
My honest preference would be to go farther and have a firmware/hypervisor/platform independent rendezvous for the cpus so we don't have to worry about what bugs the code under has implemented for this special case. Because frankly there when there are layers of software if a bug can slip through it always seems to and causes problems.
But definitely there is no reason to add another generic hook when the existing hook is quite good enough.
Eric
Borislav Petkov
maintainerRe: [PATCH v2 01/12] kexec: Allow architecture code to opt-out at runtime
In reply to Eric W. BiedermanQuoted 3 lines · Eric W. Biederman
I seem to remember the consensus when this was reviewed that it was unnecessary and there is already support for doing something like this at a more fine grained level so we don't need a new kexec hook.
Well, the executive summary is that you have a guest whose memory *and* registers are encrypted so the hypervisor cannot have a poke inside and reset the vCPU like it would normally do. So you need to do that dance differently, i.e, the patchset.
If you try to kexec such a guest now, it'll init only the BSP, as Joerg said. So I guess a single-threaded kdump.
And yes, one of the prominent use cases is kdumping from such a guest, as distros love doing kdump for debugging.
I hope that explains it better.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquettePATCH v2 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
@@ -591,3 +591,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 · 1 line
2.33.0
PATCH v2 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 · 1 line
2.33.0
Borislav Petkov
maintainerRe: [PATCH v2 03/12] x86/sev: Save and print negotiated GHCB protocol version
Quoted 5 lines · Joerg Roedel
From: 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.
Which is useful for?
arch/x86/kernel/sev-shared.c line 25
Quoted 9 lines
arch/x86/kernel/sev-shared.c +9
-0+/* +* 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 {
Too long a name - ghcb_info is perfectly fine.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v2 03/12] x86/sev: Save and print negotiated GHCB protocol version
Quoted 8 lines · Borislav Petkov
Quoted 5 lines · Joerg Roedel
From: 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.
Which is useful for?
For easier debugging, I added a sentence about that to the changelog.
Quoted 3 lines
Quoted 1 line
+struct
sev_ghcb_protocol_info{Too long a name -
ghcb_infois perfectly fine.
Changed, thanks.
Signature · 10 lines
J?rg R?del jroedel at suse.de SUSE Software Solutions Germany GmbH Maxfeldstr. 5 90409 N?rnberg Germany (HRB 36809, AG N?rnberg) Gesch?ftsf?hrer: Ivo Totev
PATCH v2 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 · 1 line
2.33.0
PATCH v2 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 · 6 lines
2.33.0 _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
Borislav Petkov
maintainerRe: [PATCH v2 05/12] x86/sev: Use GHCB protocol version 2 if supported
Quoted 17 lines · Joerg Roedel
From: Joerg Roedel <[email protected]>
Check whether the hypervisor supports GHCB version 2 and use it if available.
Signed-off-by Joerg Roedel <[email protected]>--- 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 +0
-0
arch/x86/boot/compressed/sev.c static enum es_result vc_read_mem(struct es_em_ctxt *ctxt, · line 122
Quoted 4 lines
arch/x86/boot/compressed/sev.c +1
-0@@ -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;
I guess you need to sync up with Brijesh on what to use:
https://lore.kernel.org/r/[email protected]
And if ghcb_version there is __ro_after_init I think that's perfectly fine and doesn't need an accessor...
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquettePATCH v2 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 · 6 lines
2.33.0 _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
Borislav Petkov
maintainerRe: [PATCH v2 06/12] x86/sev: Cache AP Jump Table Address
Quoted 15 lines · Joerg Roedel
From: 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.
Signed-off-by Joerg Roedel <[email protected]>--- arch/x86/kernel/sev.c | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-)arch/x86/kernel/sev.c +0
-0
arch/x86/kernel/sev.c static struct ghcb boot_ghcb_page __bss_decrypted __aligned(PAGE_SIZE); · line 46
Quoted 5 lines
arch/x86/kernel/sev.c +2
-0@@ -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;
This is static, so "jump_table_pa" should be enough.
Also, to the prefixes, everything which is not SEV-ES only, should be simply prefixed with "sev_" if externally visible.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquettePATCH v2 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
@@ -11,12 +11,19 @@ KASAN_SANITIZE := n KCSAN_SANITIZE := n +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.33.0
Borislav Petkov
maintainerRe: [PATCH v2 07/12] x86/sev: Setup code to park APs in the AP Jump Table
Quoted 12 lines · Joerg Roedel
From: 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.
Quoted 5 lines
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.
"The AP jump table must be 4K in size, in encrypted memory and it must be 4K (page) aligned. There can only be one AP jump table and it should reside in memory that has been marked as reserved by UEFI."
I think we need to state in the spec that some of that space can be used by the OS so that future changes to the spec do not cause trouble.
arch/x86/include/asm/sev-ap-jumptable.h
Quoted 38 lines
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.
Signed-off-by Joerg Roedel <[email protected]>--- 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.ldsarch/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 +0
-0
Why a separate header? arch/x86/include/asm/sev.h looks small enough.
Quoted 11 lines
arch/x86/include/asm/sev-ap-jumptable.h new file +10
-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
arch/x86/include/asm/sev-ap-jumptable.h line 20
Quoted 10 lines
arch/x86/include/asm/sev-ap-jumptable.h new file +10
-0+#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;
I guess you should state that the first two members are as the spec mandates and cannot be moved around or changed or so.
Also, this gdt_offset thing looks like it wants to be ap_jumptable_gdt, no?
Quoted 28 lines
arch/x86/include/asm/sev-ap-jumptable.h new file +5
-0+}; + +#endif /* !__ASSEMBLY__ */ + +#endif /* __ASM_SEV_AP_JUMPTABLE_H */ arch/x86/kernel/sev.c +4
-0@@ -19,6 +19,7 @@#include <linux/kernel.h> #include <linux/mm.h> +#include <asm/sev-ap-jumptable.h> #include <asm/cpu_entry_area.h> #include <asm/stacktrace.h> #include <asm/sev.h> @@ -45,6 +46,9 @@ static struct ghcb __initdata *boot_ghcb;/* Cached AP Jump Table Address */ static phys_addr_t sev_es_jump_table_pa; +/* Whether the AP Jump Table blob was successfully installed */ +static bool sev_ap_jumptable_blob_installed__ro_after_init ; +/* #VC handler runtime per-CPU data */ struct sev_es_runtime_data {struct ghcb ghcb_page;
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 757
Quoted 5 lines
arch/x86/kernel/sev.c +2
-0@@ -749,6 +753,107 @@ static void __init sev_es_setup_play_dead(void)static inline void sev_es_setup_play_dead (void ) { }#endif +/* +* This function make the necessary runtime changes to the AP Jump Table blob.
s/This function make/Make/
Ditto for the other "This function" below.
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 762
Quoted 5 lines
arch/x86/kernel/sev.c +5
-0+* For now this only sets up the GDT used while the code executes. The GDT needs +* to contain 16-bit code and data segments with a base that points to AP Jump +* Table page. +*/ +void __init sev_es_setup_ap_jump_table_data (void *base,u32 pa)
Why is this a separate function?
It is all part of the jump table setup.
Quoted 19 lines
arch/x86/kernel/sev.c +19
-0+struct sev_ap_jump_table_header *header; +struct desc_ptr *gdt_descr; +u64 *ap_jumptable_gdt; + + header = base; + +/* +* Setup 16-bit protected mode code and data segments for AP Jumptable. +* Set the segment limits to 0xffff to already be compatible with +* real-mode. +*/ + ap_jumptable_gdt = (u64 *)(base + header->gdt_offset); + ap_jumptable_gdt[SEV_APJT_CS16 /8 ] =GDT_ENTRY (0x9b , pa,0xffff ); + ap_jumptable_gdt[SEV_APJT_DS16 /8 ] =GDT_ENTRY (0x93 , pa,0xffff ); + +/* Write correct GDT base address into GDT descriptor */ + gdt_descr = (struct desc_ptr *)(base + header->gdt_offset); + gdt_descr->address += pa; +}
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 792
Quoted 10 lines
arch/x86/kernel/sev.c +10
-0+ +/* +* This function sets up the AP Jump Table blob which contains code which runs +* in 16-bit protected mode to park an AP. After the AP is woken up again the +* code will disable protected mode and jump to the reset vector which is also +* stored in the AP Jump Table. +* +* The Jump Table is a safe place to park an AP, because it is owned by the +* BIOS and writable by the OS. Putting the code in kernel memory would break +* with kexec, because by the time th APs wake up the memory is owned by
the
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 795
Quoted 3 lines
arch/x86/kernel/sev.c +3
-0+* the new kernel, and possibly already overwritten. +* +* Kexec is also the reason this function is called as an init-call after SMP
s/called as //
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 799
Quoted 4 lines
arch/x86/kernel/sev.c +4
-0+* bringup. Only after all CPUs are up there is a guarantee that no AP is still +* parked in AP jump-table code. +*/ +static int __init sev_es_setup_ap_jump_table_blob (void )
Everywhere: use prefix sev_ pls. IOW:
sev_setup_ap_jump_table()
plain and simple.
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 806
Quoted 7 lines
arch/x86/kernel/sev.c +7
-0+{ +size_t blob_size = rm_ap_jump_table_blob_end - rm_ap_jump_table_blob; +u16 startup_cs, startup_ip; +u16 __iomem *jump_table; +phys_addr_t pa; + +if (!sev_es_active ())
if (!cc_platform_has(CC_ATTR_GUEST_STATE_ENCRYPT))
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 810
Quoted 4 lines
arch/x86/kernel/sev.c +4
-0+return 0 ; + +if (sev_get_ghcb_proto_ver () <2 ) { +pr_info ("AP Jump Table parking requires at least GHCB protocol version 2\n" );
Not pr_warn?
Also, can we drop everywhere this first-letter capitalized spelling?
AP jump table parking...
is ok already.
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 810
Quoted 1 line
arch/x86/kernel/sev.c +1
-0+return 0 ;
Why are you returning 0 here and below?
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 816
Quoted 5 lines
arch/x86/kernel/sev.c +5
-0+ } + + pa =get_jump_table_addr (); + +/* Overflow and size checks for untrusted Jump Table address */
/* Check overflow and size...
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 818
Quoted 2 lines
arch/x86/kernel/sev.c +2
-0+if (pa +PAGE_SIZE < pa || pa +PAGE_SIZE >SZ_4G ) { +pr_info ("AP Jump Table is above 4GB - not enabling AP Jump Table parking\n" );
That error message needs to say about the overflow too.
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 824
Quoted 6 lines
arch/x86/kernel/sev.c +6
-0+return 0 ; + } + +/* On UP guests there is no jump table so this is not a failure */ +if (!pa) +return 0 ;
So this check needs to happen right after the get_ call.
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 831
Quoted 8 lines
arch/x86/kernel/sev.c +7
-0+ + jump_table =ioremap_encrypted (pa,PAGE_SIZE ); +if (WARN_ON (!jump_table)) +return -EINVAL ; + +/* +* Safe reset vector to restore it later because the blob will
Save...
Quoted 10 lines
arch/x86/kernel/sev.c +10
-0+* overwrite it. +*/ + startup_ip = jump_table[0 ]; + startup_cs = jump_table[1 ]; + +/* Install AP Jump Table Blob with real mode AP parking code */ +memcpy_toio (jump_table, rm_ap_jump_table_blob, blob_size); + +/* Setup AP Jumptable GDT */ +sev_es_setup_ap_jump_table_data (jump_table, (u32 )pa);
arch/x86/kernel/sev.c static void __init sev_es_setup_play_dead(void) · line 851
Quoted 10 lines
arch/x86/kernel/sev.c +10
-0+ +writew (startup_ip, &jump_table[0 ]); +writew (startup_cs, &jump_table[1 ]); + +iounmap (jump_table); + +pr_info ("AP Jump Table Blob successfully set up\n" ); + +/* Mark AP Jump Table blob as available */ + sev_ap_jumptable_blob_installed = true;
I don't like those random boolean variables all over the place but at least it is static.
arch/x86/realmode/sev/Makefile
Quoted 53 lines
arch/x86/kernel/sev.c +5
-0+ +return 0 ; +} +core_initcall (sev_es_setup_ap_jump_table_blob); +static void __init alloc_runtime_data (int cpu) {struct sev_es_runtime_data *data;arch/x86/realmode/Makefile +8
-1@@ -11,12 +11,19 @@ KASAN_SANITIZE := n KCSAN_SANITIZE := n +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) +#endifarch/x86/realmode/sev/Makefile new file +0
-0@@ -0,0 +1,41 @@
<--- # SPDX-License-Identifier: GPL-2.0
We don't do that GPL text anymore.
Quoted 9 lines
arch/x86/realmode/sev/Makefile new file +9
-0+# +# arch/x86/sev/Makefile +# +# This file is subject to the terms and conditions of the GNU General Public +# License. See the file "COPYING" in the main directory of this archive +# for more details. +# + +# Sanitizer runtimes are unavailable and cannot be linked here.
arch/x86/realmode/sev/Makefile line 19
Quoted 10 lines
arch/x86/realmode/sev/Makefile new file +10
-0+KASAN_SANITIZE := n +KCSAN_SANITIZE := n +OBJECT_FILES_NON_STANDARD := y + +# Prevents link failures: __sanitizer_cov_trace_pc() is not linked in. +KCOV_INSTRUMENT := n + +always-y := ap_jump_table.bin + +ap_jump_table-y += ap_jump_table.o
The vertical alignment of those is kinda random. Please unify.
Quoted 28 lines
arch/x86/realmode/sev/Makefile new file +22
-0+ +targets += $(ap_jump_table-y) + +APJUMPTABLE_OBJS = $(addprefix $(obj)/,$(ap_jump_table-y)) + +LDFLAGS_ap_jump_table.elf := -m elf_i386 -T + +targets += ap_jump_table.elf +$(obj)/ap_jump_table.elf: $(obj)/ap_jump_table.lds $(APJUMPTABLE_OBJS) FORCE + $(call if_changed,ld) + +OBJCOPYFLAGS_ap_jump_table.bin := -O binary + +targets += ap_jump_table.bin +$(obj)/ap_jump_table.bin: $(obj)/ap_jump_table.elf FORCE + $(call if_changed,objcopy) + +# --------------------------------------------------------------------------- + +KBUILD_AFLAGS := $(REALMODE_CFLAGS) -D__ASSEMBLY__ +GCOV_PROFILE := n +UBSAN_SANITIZE := narch/x86/realmode/sev/ap_jump_table.S new file +0
-0
arch/x86/realmode/sev/ap_jump_table.S line 8
Quoted 8 lines
arch/x86/realmode/sev/ap_jump_table.S new file +8
-0@@ -0,0 +1,130 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#include <linux/linkage.h> +#include <asm/sev-ap-jumptable.h> + +/* + * This file contains the source code for the binary blob which gets copied to + * the SEV-ES AP Jumptable to park APs while offlining CPUs or booting a new
I've seen "Jumptable", "Jump Table" and "jump table" at least. I'd say, do the last one everywhere pls.
Quoted 16 lines
arch/x86/realmode/sev/ap_jump_table.S new file +16
-0+ * kernel via KEXEC. + * + * The AP Jumptable is the only safe place to put this code, as any memory the + * kernel allocates will be owned (and possibly overwritten) by the new kernel + * once the APs are woken up. + * + * This code runs in 16-bit protected mode, the CS, DS, and SS segment bases are + * set to the beginning of the AP Jumptable page. + * + * Since the GDT will also be gone when the AP wakes up, this blob contains its + * own GDT, which is set up by the AP Jumptable setup code with the correct + * offsets. + * + * Author: Joerg Roedel <[email protected]> + */ +
arch/x86/realmode/sev/ap_jump_table.S line 34
Quoted 10 lines
arch/x86/realmode/sev/ap_jump_table.S new file +10
-0+ .text + .org 0x0 + .code16 +SYM_DATA_START(ap_jumptable_header) + .word 0 /* reset IP */ + .word 0 /* reset CS */ + .word ap_jumptable_gdt /* GDT Offset */ +SYM_DATA_END(ap_jumptable_header) + + .org SEV_APJT_ENTRY
So this hardcodes the fact that the first 16 bytes are header and the rest is free game. I think the spec needs to play along here...
arch/x86/realmode/sev/ap_jump_table.S line 35
Quoted 1 line
arch/x86/realmode/sev/ap_jump_table.S new file +1
-0+SYM_CODE_START(ap_park_asm)
This whole file is asm. I guess simply "ap_park" is enough.
Quoted 6 lines
arch/x86/realmode/sev/ap_jump_table.S new file +6
-0+ + /* Switch to AP Jumptable GDT first */ + lgdtl ap_jumptable_gdt + + /* Reload CS */ + ljmpw $SEV_APJT_CS16, $1f
arch/x86/realmode/sev/ap_jump_table.S line 51
Quoted 10 lines
arch/x86/realmode/sev/ap_jump_table.S new file +10
-0+1: + + /* Reload DS and SS */ + movl $SEV_APJT_DS16, %ecx + movl %ecx, %ds + movl %ecx, %ss + + /* + * Setup a stack pointing to the end of the AP Jumptable page. + * The stack is needed ot reset EFLAGS after wakeup.
s/ot/to/
arch/x86/realmode/sev/ap_jump_table.S line 58
Quoted 7 lines
arch/x86/realmode/sev/ap_jump_table.S new file +7
-0+ */ + movl $0x1000, %esp + + /* Execute AP reset hold VMGEXIT */ +2: xorl %edx, %edx + movl $0x6, %eax + movl $0xc0010130, %ecx
MSR_AMD64_SEV_ES_GHCB
arch/x86/realmode/sev/ap_jump_table.S line 70
Quoted 12 lines
arch/x86/realmode/sev/ap_jump_table.S new file +12
-0+ wrmsr + rep; vmmcall + rdmsr + movl %eax, %ecx + andl $0xfff, %ecx + cmpl $0x7, %ecx + jne 2b + shrl $12, %eax + jnz 3f + testl %edx, %edx + jnz 3f + jmp 2b
You usually document your asm pretty nicely but those after the RDMSR are a bit lacking...
arch/x86/realmode/sev/ap_jump_table.S line 73
Quoted 3 lines
arch/x86/realmode/sev/ap_jump_table.S new file +3
-0+3: + /* + * Successfully woken up - Patch the correct target into the far jump at
patch
arch/x86/realmode/sev/ap_jump_table.S line 84
Quoted 11 lines
arch/x86/realmode/sev/ap_jump_table.S new file +11
-0+ * the end. An indirect far jump does not work here, because at the time + * the jump is executed DS is already loaded with real-mode values. + */ + + /* Jump target is at address 0x0 - copy it to the far jump instruction */ + movl $0, %ecx + movl (%ecx), %eax + movl %eax, jump_target + + /* Reset EFLAGS */ + pushl $2
I'm assuming that two is bit 1 in rFLAGS which is always 1? Comment pls.
arch/x86/realmode/sev/ap_jump_table.S line 96
Quoted 12 lines
arch/x86/realmode/sev/ap_jump_table.S new file +12
-0+ popfl + + /* Setup DS and SS for real-mode */ + movl $0x18, %ecx + movl %ecx, %ds + movl %ecx, %ss + + /* Reset remaining registers */ + movl $0, %esp + movl $0, %eax + movl $0, %ebx + movl $0, %edx
All 4: use xor
arch/x86/realmode/sev/ap_jump_table.S line 99
Quoted 3 lines
arch/x86/realmode/sev/ap_jump_table.S new file +3
-0+ + /* Reset CR0 to get out of protected mode */ + movl $0x60000010, %ecx
Another magic naked number.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v2 07/12] x86/sev: Setup code to park APs in the AP Jump Table
Quoted 9 lines · Borislav Petkov
arch/x86/include/asm/sev-ap-jumptable.h
Quoted 6 lines · Joerg Roedel
extern unsigned char real_mode_blob[];
arch/x86/include/asm/sev-ap-jumptable.h new file +0
-0Why a separate header?
arch/x86/include/asm/sev.hlooks small enough.
The header is included in assembly, so I made a separate one.
Quoted 5 lines
Quoted 1 line
+void
__initsev_es_setup_ap_jump_table_data(void *base, u32 pa)Why is this a separate function?
It is all part of the jump table setup.
Right, but the sev_es_setup_ap_jump_table_blob() function is already pretty big and I wanted to keep things readable.
Quoted 4 lines
arch/x86/include/asm/sev-ap-jumptable.h
Quoted 2 lines
arch/x86/include/asm/sev-ap-jumptable.h new file +1
-0+return 0 ;Why are you returning 0 here and below?
This is in an initcall and it returns just 0 when the environment is not ready to setup the ap jump table. Returning non-zero would create a warning message in the caller for something that is not a bug in the kernel.
Quoted 5 lines
Quoted 2 lines
+ * This file contains the source code for the binary blob which gets copied to
+ * the SEV-ES AP Jumptable to park APs while offlining CPUs or booting a newI've seen "Jumptable", "Jump Table" and "jump table" at least. I'd say, do the last one everywhere pls.
Fair, sorry for my english being too german :) I changed everything to 'jump table'.
Quoted 7 lines
arch/x86/include/asm/sev-ap-jumptable.h
Quoted 5 lines
arch/x86/include/asm/sev-ap-jumptable.h new file +5
-0+/* Reset remaining registers */ + movl $0, %esp + movl $0, %eax + movl $0, %ebx + movl $0, %edxAll 4: use xor
XOR changes EFLAGS, can not use them here.
Quoted 5 lines
arch/x86/include/asm/sev-ap-jumptable.h
Quoted 3 lines
arch/x86/include/asm/sev-ap-jumptable.h new file +3
-0+ +/* Reset CR0 to get out of protected mode */ + movl $0x60000010, %ecxAnother magic naked number.
This is the CR0 reset value. I have updated the comment to make this more clear.
Thanks,
Signature · 10 lines
J?rg R?del jroedel at suse.de SUSE Software Solutions Germany GmbH Maxfeldstr. 5 90409 N?rnberg Germany (HRB 36809, AG N?rnberg) Gesch?ftsf?hrer: Ivo Totev
PATCH v2 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.33.0
Borislav Petkov
maintainerRe: [PATCH v2 08/12] x86/sev: Park APs on AP Jump Table with GHCB protocol version 2
Quoted 21 lines · Joerg Roedel
From: 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.
Signed-off-by Joerg Roedel <[email protected]>--- 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.Sarch/x86/include/asm/realmode.h +0
-0
arch/x86/include/asm/realmode.h struct real_mode_header { · line 26
Quoted 4 lines
arch/x86/include/asm/realmode.h +1
-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;
sev_ap_park;
arch/x86/include/asm/realmode.h struct real_mode_header { · line 27
Quoted 1 line
arch/x86/include/asm/realmode.h +1
-0+u32 sev_real_ap_park_seg;
sev_ap_park_seg;
arch/x86/include/asm/realmode.h struct real_mode_header { · line 28
Quoted 1 line
arch/x86/include/asm/realmode.h +1
-0+u32 sev_ap_park_gdt;
Yap, like thist one.
Quoted 17 lines
arch/x86/include/asm/realmode.h +0
-0#endif #ifdef CONFIG_X86_64 u32 trampoline_pgd;arch/x86/kernel/sev.c +1
-0@@ -27,6 +27,7 @@#include <asm/fpu/internal.h> #include <asm/processor.h> #include <asm/realmode.h> +#include <asm/tlbflush.h> #include <asm/traps.h> #include <asm/svm.h> #include <asm/smp.h> @@ -695,6 +696,35 @@ static bool __init sev_es_setup_ghcb(void) }
arch/x86/kernel/sev.c static bool __init sev_es_setup_ghcb(void) · line 706
Quoted 10 lines
arch/x86/kernel/sev.c +8
-0#ifdef CONFIG_HOTPLUG_CPU +void __noreturn sev_jumptable_ap_park (void ) +{ +local_irq_disable (); + +write_cr3 (real_mode_header->trampoline_pgd); + +/* Exiting long mode will fail if CR4.PCIDE is set. */ +if (boot_cpu_has (X86_FEATURE_PCID ))
cpu_feature_enabled() is what we use everywhere now.
Quoted 4 lines
arch/x86/kernel/sev.c +4
-0+cr4_clear_bits (X86_CR4_PCIDE ); + + asmvolatile ("xorq %%r15, %%r15\n" + "xorq %%r14, %%r14\n"
arch/x86/kernel/sev.c static bool __init sev_es_setup_ghcb(void) · line 720
Quoted 10 lines
arch/x86/kernel/sev.c +10
-0+"xorq %%r13, %%r13\n" +"xorq %%r12, %%r12\n" +"xorq %%r11, %%r11\n" +"xorq %%r10, %%r10\n" +"xorq %%r9, %%r9\n" +"xorq %%r8, %%r8\n" +"xorq %%rsi, %%rsi\n" +"xorq %%rdi, %%rdi\n" +"xorq %%rsp, %%rsp\n" +"xorq %%rbp, %%rbp\n"
Use xorl and the 32-bit regs is enough - zero extension.
arch/x86/kernel/sev.c static bool __init sev_es_setup_ghcb(void) · line 723
Quoted 3 lines
arch/x86/kernel/sev.c +3
-0+ "ljmpl *%0" : : +"m" (real_mode_header->sev_real_ap_park_asm), + "b" (sev_es_jump_table_pa >> 4));
In any case, this asm needs comments: why those regs, why sev_es_jump_table_pa >> 4 in rbx (I found later in the patch why) and so on.
arch/x86/realmode/rm/sev_ap_park.S
Quoted 15 lines
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 +0
-0
arch/x86/realmode/rm/sev.S
is perfectly fine I guess.
Quoted 7 lines
new file mode 100644
index 000000000000..0b63d0569d4darch/x86/realmode/rm/sev_ap_park.S new file +2
-0@@ -0,0 +1,89 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#include <linux/linkage.h>
arch/x86/realmode/rm/sev_ap_park.S line 12
Quoted 10 lines
arch/x86/realmode/rm/sev_ap_park.S new file +10
-0+#include <asm/segment.h> +#include <asm/page_types.h> +#include <asm/processor-flags.h> +#include <asm/msr-index.h> +#include <asm/sev-ap-jumptable.h> +#include "realmode.h" + + .section ".text32", "ax" + .code32 +/*
"This is executed by ... when ... "
arch/x86/realmode/rm/sev_ap_park.S
Quoted 6 lines
arch/x86/realmode/rm/sev_ap_park.S new file +6
-0+ * The following code switches to 16-bit protected mode and sets up the + * execution environment for the AP Jump Table blob. Then it jumps to the AP + * Jump Table to park the AP. + * + * The code was copied from reboot.S and modified to fit the SEV-ES requirements + * for AP parking.
That sentence belongs at most in the commit message.
Quoted 1 line
When this code is entered, all registers except %EAX-%EDX are
%eax, etc. Lowercase pls.
Quoted 8 lines
+ * in reset state.
+ *
+ * The AP Jump Table physical base address is in %EBX upon entry.
+ *
+ * %EAX, %ECX, %EDX and EFLAGS are undefined. Only use registers %EAX-%EDX and
+ * %ESP in this code.
+ */
+SYM_CODE_START(sev_ap_park_asm)
sev_ap_park
arch/x86/realmode/rm/sev_ap_park.S line 37
Quoted 11 lines
arch/x86/realmode/rm/sev_ap_park.S new file +11
-0+ + /* Switch to trampoline GDT as it is guaranteed < 4 GiB */ + movl $__KERNEL_DS, %eax + movl %eax, %ds + lgdt pa_tr_gdt + + /* Disable paging to drop us out of long mode */ + movl %cr0, %eax + btcl $X86_CR0_PG_BIT, %eax + movl %eax, %cr0 +
/* Start executing from 32-bit addresses or so, I guess...
arch/x86/realmode/rm/sev_ap_park.S line 38
Quoted 1 line
arch/x86/realmode/rm/sev_ap_park.S new file +1
-0+ ljmpl $__KERNEL32_CS, $pa_sev_ap_park_paging_off
Please add a comment also about those pa_ things because they look like magic but they're sed-generated into arch/x86/realmode/rm/pasyms.h by the Makefile in that same dir.
Quoted 1 line
+SYM_INNER_LABEL(sev_ap_park_paging_off,
SYM_L_GLOBAL)
Global symbol but used only in this file. .L-prefix then?
arch/x86/realmode/rm/sev_ap_park.S line 43
Quoted 3 lines
arch/x86/realmode/rm/sev_ap_park.S new file +3
-0+ /* Clear EFER */ + movl $0, %eax + movl $0, %edx
both: xorl
arch/x86/realmode/rm/sev_ap_park.S line 48
Quoted 5 lines
arch/x86/realmode/rm/sev_ap_park.S new file +5
-0+ movl $MSR_EFER, %ecx + wrmsr + + /* Clear CR3 */ + movl $0, %ecx
ditto
arch/x86/realmode/rm/sev_ap_park.S line 56
Quoted 8 lines
arch/x86/realmode/rm/sev_ap_park.S new file +8
-0+ movl %ecx, %cr3 + + /* Set up the IDT for real mode. */ + lidtl pa_machine_real_restart_idt + + /* + * Load the GDT with the 16-bit segments for the AP Jump Table + */
/* Load the GDT with the 16-bit segments for the AP Jump Table */
works too.
arch/x86/realmode/rm/sev_ap_park.S line 59
Quoted 3 lines
arch/x86/realmode/rm/sev_ap_park.S new file +3
-0+ lgdtl pa_sev_ap_park_gdt + + /* Setup Code and Data segments for AP Jump Table */
... code and data segments ...
you have been reading too much vendor text where they love to capitalize everything.
Quoted 33 lines
arch/x86/realmode/rm/sev_ap_park.S new file +30
-0+ movw $SEV_APJT_DS16, %ax + movw %ax, %ds + movw %ax, %ss + + /* Jump to the AP Jump Table into 16 bit protected mode */ + ljmpw $SEV_APJT_CS16, $SEV_APJT_ENTRY +SYM_CODE_END(sev_ap_park_asm) + + .data + .balign 16 +SYM_DATA_START(sev_ap_park_gdt) + /* Self-pointer */ + .word sev_ap_park_gdt_end - sev_ap_park_gdt - 1 + .long pa_sev_ap_park_gdt + .word 0 + + /* + * Offset 0x8 + * 32 bit code segment descriptor pointing to AP Jump table base + * Setup at runtime in sev_es_setup_ap_jump_table_data(). + */ + .quad 0 + + /* + * Offset 0x10 + * 32 bit data segment descriptor pointing to AP Jump table base + * Setup at runtime in sev_es_setup_ap_jump_table_data(). + */ + .quad 0 +SYM_DATA_END_LABEL(sev_ap_park_gdt, SYM_L_GLOBAL, sev_ap_park_gdt_end)Signature · 1 line
2.33.0
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v2 08/12] x86/sev: Park APs on AP Jump Table with GHCB protocol version 2
Quoted 8 lines · Borislav Petkov
arch/x86/kernel/sev.c static bool __init sev_es_setup_ghcb(void) · line 723
Quoted 3 lines · Joerg Roedel
arch/x86/kernel/sev.c +3
-0+ "ljmpl *%0" : : +"m" (real_mode_header->sev_real_ap_park_asm), + "b" (sev_es_jump_table_pa >> 4));In any case, this asm needs comments: why those regs, why
sev_es_jump_table_pa>> 4 in rbx (I found later in the patch why) and so on.
Turned out the jump_table_pa is not used in asm code anymore. It was a left-over from a previous version of the patch, it is removed now.
Quoted 3 lines
Quoted 1 line
+SYM_INNER_LABEL(sev_ap_park_paging_off,
SYM_L_GLOBAL)Global symbol but used only in this file. .L-prefix then?
It needs to be a global symbol so the pa_ variant can be generated.
Regards,
Signature · 10 lines
J?rg R?del jroedel at suse.de SUSE Software Solutions Germany GmbH Maxfeldstr. 5 90409 N?rnberg Germany (HRB 36809, AG N?rnberg) Gesch?ftsf?hrer: Ivo Totev
PATCH v2 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"
@@ -752,6 +753,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 void __noreturn sev_jumptable_ap_park (void ) {local_irq_disable ();
@@ -725,6 +724,16 @@ 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.33.0
Borislav Petkov
maintainerRe: [PATCH v2 09/12] x86/sev: Use AP Jump Table blob to stop CPU
arch/x86/include/asm/sev.h static __always_inline void sev_es_nmi_complete(void) · line 85
Quoted 10 lines · Joerg Roedel
arch/x86/include/asm/sev.h +2
-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)
What's that for?
IOW, the below seems to build too:
---
arch/x86/include/asm/sev.h +1 -6
@@ -87,12 +87,7 @@ extern enum es_result sev_es_ghcb_hv_call(struct ghcb *ghcb,struct es_em_ctxt *ctxt, u64 exit_code, u64 exit_info_1, u64 exit_info_2); -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 (); -} +void sev_es_stop_this_cpu (void );#else static inline void sev_es_ist_enter (struct pt_regs *regs) { }static inline void sev_es_ist_exit (void ) { }
arch/x86/kernel/sev.c +4 -1
@@ -694,8 +694,11 @@ void __noreturn sev_jumptable_ap_park(void) }STACK_FRAME_NON_STANDARD (sev_jumptable_ap_park); -void __sev_es_stop_this_cpu (void ) +void sev_es_stop_this_cpu (void ) { +if (!static_branch_unlikely (&sev_es_enable_key)) +return ; +/* Only park in the AP Jump Table when the code has been installed */ if (!sev_ap_jumptable_blob_installed)return ;
---
And as previously mentioned s/sev_es/sev/ if those are going to be used on SNP guests too.
Signature · 9 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquette
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexecPATCH v2 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.33.0
PATCH v2 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.33.0
PATCH v2 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 /*
@@ -597,5 +598,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.33.0
Quoted 5 lines · Joerg Roedel
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.
How does this end up looking to an end user that tries to kexec() from a an SEV-ES kernel? Does it just hang?
Quoted 9 lines · Dave Hansen
Quoted 5 lines · Joerg Roedel
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.
How does this end up looking to an end user that tries to
kexec()from a an SEV-ES kernel? Does it just hang?
Yes, the kexec will just hang. This patch-set contains code to disable the kexec syscalls in situations where it would not work for that reason.
Actually with the changes to the decompressor in this patch-set the kexec'ed kernel could boot, but would fail to bring up all the APs.
Regards,
Joerg
Quoted 7 lines · Joerg Roedel
Quoted 6 lines · Dave Hansen
Quoted 5 lines · Joerg Roedel
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.
Quoted 5 lines
Quoted 2 lines
How does this end up looking to an end user that tries to
kexec()from a an SEV-ES kernel? Does it just hang?Yes, the kexec will just hang. This patch-set contains code to disable the kexec syscalls in situations where it would not work for that reason.
Got it. The end-user-visible symptom just wasn't obvious. If you revise these, it might be nice to add that so that folks who cherry-pick stable patches or update to new stable kernels have an idea what this might fix.