TDX Guest: TDX core support
Subsystems (8)
v6 cover TDX Guest: TDX core support
Hi All,
Intel's Trust Domain Extensions (TDX) protects confidential guest VMs from the host and physical attacks by isolating the guest register state and by encrypting the guest memory. In TDX, a special TDX module sits between the host and the guest, and runs in a special mode and manages the guest/host separation.
Please review and consider applying.
More details of TDX guests can be found in Documentation/x86/tdx.rst.
Dependencies:
-------------
The patchset depends on:
- changes in x86/cc branch of the current TIP tree[1]
- changes in swiotlb-init-cleanup branch of the Christoph's misc tree[2]
I'm not sure how to approach applying patches for such cases.
[1] git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git
[2] git://git.infradead.org/users/hch/misc
SEV/TDX comparison:
-------------------
TDX has a lot of similarities to SEV. It enhances confidentiality of guest memory and state (like registers) and includes a new exception (#VE) for the same basic reasons as SEV-ES. Like SEV-SNP (not merged yet), TDX limits the host's ability to make changes in the guest physical address space.
TDX/VM comparison:
------------------
Some of the key differences between TD and regular VM is,
1. Multi CPU bring-up is done using the ACPI MADT wake-up table.
2. A new #VE exception handler is added. The TDX module injects #VE exception to the guest TD in cases of instructions that need to be emulated, disallowed MSR accesses, etc.
3. By default memory is marked as private, and TD will selectively share it with VMM based on need.
You can find TDX related documents in the following link.
https://software.intel.com/content/www/br/pt/develop/articles/intel-trust-domain-extensions.html
Git tree:
https://github.com/intel/tdx.git guest-upstream
Previous version:
https://lore.kernel.org/r/[email protected]
Changes from v5:
- Drop paranoid check against TDX_IDENT;
- Move files around;
- Clarify why TDX_SEAMCALL_VMFAILINVALID has the value it has;
- Better diagnostics for TDVMCALL failure;
- WARN() instead of BUG() for confused instruction decoder for MMIO;
- Rework port I/O in decompression code to avoid "pio_ops." at all call sites
of I/O helpers;
- Refactor code around tdx_enc_status_changed()
- Utilize updated swiotlb code to initialize it for TDX (swiotlb-init-cleanup branch)
- io_apic_set_fixmap_nocache() -> io_apic_set_fixmap();
- Updates to comments and commit messages;
Changes from v4:
- Update comments for TDX_MODULE_CALL()
- Clarify how TDX_SEAMCALL_VMFAILINVALID is defined
- Updated comments in __tdx_hypercall()
- Get rid of td_info
- Move exc_general_protection() refactoring into a separate patch
- Updates comments around #VE handling
- Add hcall_func() to differenciate exit reason from hypercalls
- Only allow hypervisor CPUID leaves to be handled with #VE
- Update MMIO handling comments and commit message
- Update commit messages from port I/O related pateches
- Rename init_io_ops() to init_default_io_ops()
- Refactor handle_io()
- Fold warning fix from a stand along patch to patch that make the warning triggerable
- Do not flush cache on entering sleep state for any virtual machine, not only TDX
- Documentation is updated
Changes from v3:
- Rebased on top of merged x86/coco patches
- Sanity build-time check for TDX detection (Cyrill Gorcunov)
- Correction in the documentation regarding #VE for CPUID
Changes from v2:
- Move TDX-Guest-specific code under arch/x86/coco/
- Code shared between host and guest is under arch/x86/virt/
- Fix handling CR4.MCE for !CONFIG_X86_MCE
- A separate patch to clarify CR0.NE situation
- Use u8/u16/u32 for port I/O handler
- Rework TDCALL helpers:
+ consolidation between guest and host
+ clearer interface
+ A new tdx_module_call() panic() if TDCALL fails
- Rework MMIO handling to imporove readability
- New generic API to deal encryption masks
- Move tdx_early_init() before copy_bootdata() (again)
- Rework #VE handing to share more code with #GP handler
- Rework __set_memory_enc_pgtable() to provide proper abstruction for both SME/SEV and TDX cases.
- Fix warning on build with X86_MEM_ENCRYPT=y
- ... and more
Changes from v1:
- Rebased to tip/master (94985da003a4).
- Address feedback from Borislav and Josh.
- Wire up KVM hypercalls. Needed to send IPI.
Andi Kleen (1):
x86/tdx: Port I/O: add early boot support
Isaku Yamahata (1):
x86/tdx: ioapic: Add shared bit for IOAPIC base address
Kirill A. Shutemov (18):
x86/tdx: Provide common base for SEAMCALL and TDCALL C wrappers x86/tdx: Extend the confidential computing API to support TDX guests x86/tdx: Exclude shared bit from __PHYSICAL_MASK x86/traps: Refactor exc_general_protection()
x86/traps: Add #VE support for TDX guest
x86/tdx: Add HLT support for TDX guests
x86/tdx: Add MSR support for TDX guests
x86/tdx: Handle CPUID via #VE
x86/tdx: Handle in-kernel MMIO
x86: Adjust types used in port I/O helpers
x86: Consolidate port I/O helpers
x86/boot: Port I/O: allow to hook up alternative helpers x86/boot: Port I/O: add decompression-time support for TDX x86/boot: Set CR0.NE early and keep it set during the boot x86/tdx: Make pages shared in ioremap()
x86/mm/cpa: Add support for TDX shared memory
x86/kvm: Make SWIOTLB buffer shared for TD guest
ACPICA: Avoid cache flush inside virtual machines
Kuppuswamy Sathyanarayanan (8):
x86/tdx: Detect running as a TDX guest in early boot x86/tdx: Add __tdx_module_call() and __tdx_hypercall() helper
functions
x86/tdx: Detect TDX at early kernel decompression time x86/tdx: Port I/O: add runtime hypercalls
x86/tdx: Wire up KVM hypercalls
x86/acpi, x86/boot: Add multiprocessor wake-up support x86/topology: Disable CPU online/offline control for TDX guests Documentation/x86: Document TDX kernel architecture
Sean Christopherson (2):
x86/boot: Add a trampoline for booting APs via firmware handoff x86/boot: Avoid #VE during boot for TDX platforms
Documentation/x86/index.rst | 1 + Documentation/x86/tdx.rst | 214 +++++++ arch/x86/Kconfig | 15 + arch/x86/boot/boot.h | 37 +- arch/x86/boot/compressed/Makefile | 1 + arch/x86/boot/compressed/head_64.S | 27 +- arch/x86/boot/compressed/misc.c | 12 + arch/x86/boot/compressed/misc.h | 4 +- arch/x86/boot/compressed/pgtable.h | 2 +- arch/x86/boot/compressed/tdcall.S | 3 + arch/x86/boot/compressed/tdx.c | 105 ++++ arch/x86/boot/compressed/tdx.h | 15 + arch/x86/boot/cpuflags.c | 3 +- arch/x86/boot/cpuflags.h | 1 + arch/x86/boot/io.h | 50 ++ arch/x86/boot/main.c | 4 + arch/x86/coco/Makefile | 2 + arch/x86/coco/core.c | 22 +- arch/x86/coco/tdx/Makefile | 3 + arch/x86/coco/tdx/tdcall.S | 204 +++++++ arch/x86/coco/tdx/tdx.c | 702 +++++++++++++++++++++++ arch/x86/include/asm/acenv.h | 14 +- arch/x86/include/asm/apic.h | 7 + arch/x86/include/asm/cpufeatures.h | 1 + arch/x86/include/asm/disabled-features.h | 8 +- arch/x86/include/asm/idtentry.h | 4 + arch/x86/include/asm/io.h | 42 +- arch/x86/include/asm/kvm_para.h | 22 + arch/x86/include/asm/mem_encrypt.h | 6 +- arch/x86/include/asm/realmode.h | 1 + arch/x86/include/asm/shared/io.h | 34 ++ arch/x86/include/asm/shared/tdx.h | 37 ++ arch/x86/include/asm/tdx.h | 90 +++ arch/x86/kernel/acpi/boot.c | 118 ++++ arch/x86/kernel/apic/apic.c | 10 + arch/x86/kernel/apic/io_apic.c | 18 +- arch/x86/kernel/asm-offsets.c | 17 + arch/x86/kernel/head64.c | 7 + arch/x86/kernel/head_64.S | 28 +- arch/x86/kernel/idt.c | 3 + arch/x86/kernel/process.c | 4 + arch/x86/kernel/smpboot.c | 12 +- arch/x86/kernel/traps.c | 141 ++++- arch/x86/mm/ioremap.c | 5 + arch/x86/mm/mem_encrypt.c | 9 +- arch/x86/realmode/rm/header.S | 1 + arch/x86/realmode/rm/trampoline_64.S | 57 +- arch/x86/realmode/rm/trampoline_common.S | 12 +- arch/x86/realmode/rm/wakemain.c | 4 + arch/x86/virt/vmx/tdx/tdxcall.S | 94 +++ include/linux/cc_platform.h | 10 + kernel/cpu.c | 7 + 52 files changed, 2132 insertions(+), 118 deletions(-) create mode 100644 Documentation/x86/tdx.rst create mode 100644 arch/x86/boot/compressed/tdcall.S create mode 100644 arch/x86/boot/compressed/tdx.c create mode 100644 arch/x86/boot/compressed/tdx.h create mode 100644 arch/x86/boot/io.h create mode 100644 arch/x86/coco/tdx/Makefile create mode 100644 arch/x86/coco/tdx/tdcall.S create mode 100644 arch/x86/coco/tdx/tdx.c create mode 100644 arch/x86/include/asm/shared/io.h create mode 100644 arch/x86/include/asm/shared/tdx.h create mode 100644 arch/x86/include/asm/tdx.h create mode 100644 arch/x86/virt/vmx/tdx/tdxcall.S
Signature · 1 line
2.34.1
PATCH v6 1/30 x86/tdx: Detect running as a TDX guest in early boot
From: Kuppuswamy Sathyanarayanan <[email protected]>
In preparation of extending cc_platform_has() API to support TDX guest, use CPUID instruction to detect support for TDX guests in the early boot code (via tdx_early_init()). Since copy_bootdata() is the first user of cc_platform_has() API, detect the TDX guest status before it.
Define a synthetic feature flag (X86_FEATURE_TDX_GUEST) and set this bit in a valid TDX guest platform.
--- arch/x86/Kconfig | 12 ++++++++++++ arch/x86/coco/Makefile | 2 ++ arch/x86/coco/tdx/Makefile | 3 +++ arch/x86/coco/tdx/tdx.c | 22 ++++++++++++++++++++++ arch/x86/include/asm/cpufeatures.h | 1 + arch/x86/include/asm/disabled-features.h | 8 +++++++- arch/x86/include/asm/tdx.h | 21 +++++++++++++++++++++ arch/x86/kernel/head64.c | 4 ++++ 8 files changed, 72 insertions(+), 1 deletion(-) create mode 100644 arch/x86/coco/tdx/Makefile create mode 100644 arch/x86/coco/tdx/tdx.c create mode 100644 arch/x86/include/asm/tdx.h
arch/x86/Kconfig +12 -0
@@ -880,6 +880,18 @@ config ACRN_GUEST IOT with small footprint and real-time features. More details can be found in https://projectacrn.org/. +config INTEL_TDX_GUEST + bool "Intel TDX (Trust Domain Extensions) - Guest Support" + depends on X86_64 && CPU_SUP_INTEL + depends on X86_X2APIC + help + Support running as a guest under Intel TDX. Without this support, + the guest kernel can not boot or run under TDX. + TDX includes memory encryption and integrity capabilities + which protect the confidentiality and integrity of guest + memory contents and CPU state. TDX guests are protected from + some attacks from the VMM. + endif #HYPERVISOR_GUEST source "arch/x86/Kconfig.cpu"
arch/x86/coco/Makefile +2 -0
@@ -4,3 +4,5 @@ KASAN_SANITIZE_core.o := n CFLAGS_core.o += -fno-stack-protector obj-y += core.o + +obj-$(CONFIG_INTEL_TDX_GUEST) += tdx/
arch/x86/coco/tdx/Makefile new file +3 -0
@@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-y += tdx.o
arch/x86/coco/tdx/tdx.c new file +22 -0
@@ -0,0 +1,22 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (C) 2021-2022 Intel Corporation */ + +#undef pr_fmt +#define pr_fmt (fmt) "tdx: " fmt + +#include <linux/cpufeature.h> +#include <asm/tdx.h> + +void __init tdx_early_init (void ) +{ +u32 eax, sig[3 ]; + +cpuid_count (TDX_CPUID_LEAF_ID ,0 , &eax, &sig[0 ], &sig[2 ], &sig[1 ]); + +if (memcmp (TDX_IDENT , sig,sizeof (sig))) +return ; + +setup_force_cpu_cap (X86_FEATURE_TDX_GUEST ); + +pr_info ("Guest detected\n" ); +}
arch/x86/include/asm/cpufeatures.h +1 -0
@@ -238,6 +238,7 @@#define X86_FEATURE_VMW_VMMCALL ( 8*32+19)/* "" VMware prefers VMMCALL hypercall instruction */ #define X86_FEATURE_PVUNLOCK ( 8*32+20)/* "" PV unlock function */ #define X86_FEATURE_VCPUPREEMPT ( 8*32+21)/* "" PV vcpu_is_preempted function */ +#define X86_FEATURE_TDX_GUEST ( 8*32+22)/* Intel Trust Domain Extensions Guest */ /* Intel-defined CPU features, CPUID level 0x00000007:0 (EBX), word 9 */ #define X86_FEATURE_FSGSBASE ( 9*32+ 0)/* RDFSBASE, WRFSBASE, RDGSBASE, WRGSBASE instructions*/
arch/x86/include/asm/disabled-features.h +7 -1
@@ -68,6 +68,12 @@# define DISABLE_SGX (1 << (X86_FEATURE_SGX & 31))#endif +#ifdef CONFIG_INTEL_TDX_GUEST +# define DISABLE_TDX_GUEST 0 +#else +# define DISABLE_TDX_GUEST (1 << (X86_FEATURE_TDX_GUEST & 31)) +#endif +/* * Make sure to add features to the correct mask */
@@ -79,7 +85,7 @@#define DISABLED_MASK5 0#define DISABLED_MASK6 0#define DISABLED_MASK7 (DISABLE_PTI) -#define DISABLED_MASK8 0 +#define DISABLED_MASK8 (DISABLE_TDX_GUEST)#define DISABLED_MASK9 (DISABLE_SMAP|DISABLE_SGX)#define DISABLED_MASK10 0#define DISABLED_MASK11 0
arch/x86/include/asm/tdx.h new file +21 -0
@@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Copyright (C) 2021-2022 Intel Corporation */ +#ifndef _ASM_X86_TDX_H +#define _ASM_X86_TDX_H + +#include <linux/init.h> + +#define TDX_CPUID_LEAF_ID 0x21 +#define TDX_IDENT "IntelTDX " + +#ifdef CONFIG_INTEL_TDX_GUEST + +void __init tdx_early_init (void ); + +#else + +static inline void tdx_early_init (void ) { }; + +#endif /* CONFIG_INTEL_TDX_GUEST */ + +#endif /* _ASM_X86_TDX_H */
arch/x86/kernel/head64.c +4 -0
@@ -40,6 +40,7 @@#include <asm/extable.h> #include <asm/trapnr.h> #include <asm/sev.h> +#include <asm/tdx.h> /* * Manage page tables very early on.
@@ -514,6 +515,9 @@ asmlinkage __visible void __init x86_64_start_kernel(char * real_mode_data)idt_setup_early_handler (); +/* Needed before cc_platform_has() can be used for TDX */ +tdx_early_init (); +copy_bootdata (__va (real_mode_data));/*
Signature · 1 line
2.34.1
Re: [PATCHv6 01/30] x86/tdx: Detect running as a TDX guest in early boot
Quoted 10 lines · Kirill A. Shutemov
From: Kuppuswamy Sathyanarayanan <[email protected]>
In preparation of extending
cc_platform_has()API to support TDX guest, use CPUID instruction to detect support for TDX guests in the early boot code (viatdx_early_init()). Sincecopy_bootdata()is the first user ofcc_platform_has()API, detect the TDX guest status before it.Define a synthetic feature flag (
X86_FEATURE_TDX_GUEST) and set this bit in a valid TDX guest platform.
Quoted 6 lines
Signed-off-by Kuppuswamy Sathyanarayanan <[email protected]>Reviewed-by Andi Kleen <[email protected]>Reviewed-by Tony Luck <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>Reviewed-by Dave Hansen <[email protected]>Reviewed-by Borislav Petkov <[email protected]>
PATCH v6 2/30 x86/tdx: Provide common base for SEAMCALL and TDCALL C wrappers
In reply to Kirill A. ShutemovSecure Arbitration Mode (SEAM) is an extension of VMX architecture. It defines a new VMX root operation (SEAM VMX root) and a new VMX non-root operation (SEAM VMX non-root) which are both isolated from the legacy VMX operation where the host kernel runs.
A CPU-attested software module (called 'TDX module') runs in SEAM VMX root to manage and protect VMs running in SEAM VMX non-root. SEAM VMX root is also used to host another CPU-attested software module (called 'P-SEAMLDR') to load and update the TDX module.
Host kernel transits to either P-SEAMLDR or TDX module via the new SEAMCALL instruction, which is essentially a VMExit from VMX root mode to SEAM VMX root mode. SEAMCALLs are leaf functions defined by P-SEAMLDR and TDX module around the new SEAMCALL instruction.
A guest kernel can also communicate with TDX module via TDCALL instruction.
TDCALLs and SEAMCALLs use an ABI different from the x86-64 system-v ABI. RAX is used to carry both the SEAMCALL leaf function number (input) and the completion status (output). Additional GPRs (RCX, RDX, R8-R11) may be further used as both input and output operands in individual leaf.
TDCALL and SEAMCALL share the same ABI and require the largely same code to pass down arguments and retrieve results.
Define an assembly macro that can be used to implement C wrapper for both TDCALL and SEAMCALL.
TDCALL wrapper will be implemented using the macro later in the series. SEAMCALL wrapper is out-of-scope for the series and will be implemented as part of TDX host enabling.
--- arch/x86/include/asm/tdx.h | 28 ++++++++++ arch/x86/kernel/asm-offsets.c | 9 ++++ arch/x86/virt/vmx/tdx/tdxcall.S | 94 +++++++++++++++++++++++++++++++++ 3 files changed, 131 insertions(+) create mode 100644 arch/x86/virt/vmx/tdx/tdxcall.S
arch/x86/include/asm/tdx.h +28 -0
@@ -8,6 +8,33 @@#define TDX_CPUID_LEAF_ID 0x21#define TDX_IDENT "IntelTDX " +/* +* SW-defined error codes. +* +* Bits 47:40 == 0xFF indicate Reserved status code class that never used by +* TDX module. +*/ +#define TDX_ERROR _BITUL(63) +#define TDX_SW_ERROR (TDX_ERROR | GENMASK_ULL(40, 47)) +#define TDX_SEAMCALL_VMFAILINVALID (TDX_SW_ERROR | _UL(0xFFFF0000)) + +#ifndef __ASSEMBLY__ + +/* +* Used to gather the output registers values of the TDCALL and SEAMCALL +* instructions when requesting services from the TDX module. +* +* This is a software only structure and not part of the TDX module/VMM ABI. +*/ +struct tdx_module_output { +u64 rcx; +u64 rdx; +u64 r8; +u64 r9; +u64 r10; +u64 r11; +}; +#ifdef CONFIG_INTEL_TDX_GUEST void __init tdx_early_init (void );
@@ -18,4 +45,5 @@ static inline void tdx_early_init(void) { };#endif /* CONFIG_INTEL_TDX_GUEST */ +#endif /* !__ASSEMBLY__ */ #endif /* _ASM_X86_TDX_H */
arch/x86/kernel/asm-offsets.c +9 -0
@@ -18,6 +18,7 @@#include <asm/bootparam.h> #include <asm/suspend.h> #include <asm/tlbflush.h> +#include <asm/tdx.h> #ifdef CONFIG_XEN #include <xen/interface/xen.h>
@@ -65,6 +66,14 @@ static void __used common(void)OFFSET (XEN_vcpu_info_arch_cr2, vcpu_info, arch.cr2);#endif +BLANK (); +OFFSET (TDX_MODULE_rcx, tdx_module_output, rcx); +OFFSET (TDX_MODULE_rdx, tdx_module_output, rdx); +OFFSET (TDX_MODULE_r8, tdx_module_output, r8); +OFFSET (TDX_MODULE_r9, tdx_module_output, r9); +OFFSET (TDX_MODULE_r10, tdx_module_output, r10); +OFFSET (TDX_MODULE_r11, tdx_module_output, r11); +BLANK ();OFFSET (BP_scratch, boot_params, scratch);OFFSET (BP_secure_boot, boot_params, secure_boot);
arch/x86/virt/vmx/tdx/tdxcall.S new file +94 -0
94 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCHv6 02/30] x86/tdx: Provide common base for SEAMCALL and TDCALL C wrappers
Kirrill,
Quoted 7 lines · Kirill A. Shutemov
Define an assembly macro that can be used to implement C wrapper for both TDCALL and SEAMCALL.
TDCALL wrapper will be implemented using the macro later in the series. SEAMCALL wrapper is out-of-scope for the series and will be implemented as part of TDX host enabling.
This paragraph makes no sense in the changelog once it's merged. That's a reviewer/maintainer info which wants to be below the ---
arch/x86/virt/vmx/tdx/tdxcall.S line 17
Quoted 13 lines
arch/x86/virt/vmx/tdx/tdxcall.S new file +13
-0+/* + * TDX_MODULE_CALL - common helper macro for both + * TDCALL and SEAMCALL instructions. + * + * TDCALL - used by TDX guests to make requests to the + * TDX module and hypercalls to the VMM. + * SEAMCALL - used by TDX hosts to make requests to the + * TDX module. + * + * Both instruction are supported in Binutils >= 2.36. + */ +#define tdcall .byte 0x66,0x0f,0x01,0xcc +#define seamcall .byte 0x66,0x0f,0x01,0xcf
Bah. I really hate this #define glue. The comment documents TDX_MODULE_CALL. The defines for the instructions are a seperate problem. So please move them above the whole thing with their own comment.
Quoted 33 lines
+.macro
TDX_MODULE_CALLhost:reqarch/x86/virt/vmx/tdx/tdxcall.S new file +32
-0+ /* + * R12 will be used as temporary storage for struct tdx_module_output + * pointer. Since R12-R15 registers are not used by TDCALL/SEAMCALL + * services supported by this function, it can be reused. + */ + + /* Callee saved, so preserve it */ + push %r12 + + /* + * Push output pointer to stack. + * After the operation, it will be fetched into R12 register. + */ + push %r9 + + /* Mangle function call ABI into TDCALL/SEAMCALL ABI: */ + /* Move Leaf ID to RAX */ + mov %rdi, %rax + /* Move input 4 to R9 */ + mov %r8, %r9 + /* Move input 3 to R8 */ + mov %rcx, %r8 + /* Move input 1 to RCX */ + mov %rsi, %rcx + /* Leave input param 2 in RDX */ + + .if \host + seamcall + /* + * SEAMCALL instruction is essentially a VMExit from VMX root + * mode to SEAM VMX root mode. VMfailInvalid (CF=1) indicates + * that the targeted SEAM firmware is not loaded or disabled,
arch/x86/virt/vmx/tdx/tdxcall.S line 61
Quoted 10 lines
arch/x86/virt/vmx/tdx/tdxcall.S new file +10
-0+ * or P-SEAMLDR is busy with another SEAMCALL. %rax is not + * changed in this case. + * + * Set %rax to TDX_SEAMCALL_VMFAILINVALID for VMfailInvalid. + * This value will never be used as actual SEAMCALL error code as + * it is from the Reserved status code class. + */ + jnc .Lno_vmfailinvalid + mov $TDX_SEAMCALL_VMFAILINVALID, %rax +.Lno_vmfailinvalid:
Please add a new line between the label and the .else for readability sake.
Quoted 4 lines
arch/x86/virt/vmx/tdx/tdxcall.S new file +4
-0+ .else + tdcall + .endif +
arch/x86/virt/vmx/tdx/tdxcall.S line 75
Quoted 10 lines
arch/x86/virt/vmx/tdx/tdxcall.S new file +10
-0+ /* + * Fetch output pointer from stack to R12 (It is used + * as temporary storage) + */ + pop %r12 + + /* + * Since this function can be initiated without an output pointer, + * check if caller provided an output struct before storing output + * registers.
The function is a macro. It's not initiated, it's invoked. It always has an output pointer in R12, but that can be NULL.
With those nitpicks addressed:
PATCH v6 3/30 x86/tdx: Add __tdx_module_call() and __tdx_hypercall() helper functions
In reply to Kirill A. ShutemovFrom: Kuppuswamy Sathyanarayanan <[email protected]>
Guests communicate with VMMs with hypercalls. Historically, these are implemented using instructions that are known to cause VMEXITs like VMCALL, VMLAUNCH, etc. However, with TDX, VMEXITs no longer expose the guest state to the host. This prevents the old hypercall mechanisms from working. So, to communicate with VMM, TDX specification defines a new instruction called TDCALL.
In a TDX based VM, since the VMM is an untrusted entity, an intermediary layer -- TDX module -- facilitates secure communication between the host and the guest. TDX module is loaded like a firmware into a special CPU mode called SEAM. TDX guests communicate with the TDX module using the TDCALL instruction.
A guest uses TDCALL to communicate with both the TDX module and VMM. The value of the RAX register when executing the TDCALL instruction is used to determine the TDCALL type. A leaf of TDCALL used to communicate with the VMM is called TDVMCALL.
Add generic interfaces to communicate with the TDX module and VMM (using the TDCALL instruction).
__tdx_module_call() - Used to communicate with the TDX module (via
TDCALL instruction).__tdx_hypercall() - Used by the guest to request services from
the VMM (via TDVMCALL leaf of TDCALL).
Also define an additional wrapper _tdx_hypercall(), which adds error handling support for the TDCALL failure.
The __tdx_module_call() and __tdx_hypercall() helper functions are implemented in assembly in a .S file. The TDCALL ABI requires shuffling arguments in and out of registers, which proved to be awkward with inline assembly.
Just like syscalls, not all TDVMCALL use cases need to use the same number of argument registers. The implementation here picks the current worst-case scenario for TDCALL (4 registers). For TDCALLs with fewer than 4 arguments, there will end up being a few superfluous (cheap) instructions. But, this approach maximizes code reuse.
For registers used by the TDCALL instruction, please check TDX GHCI specification, the section titled "TDCALL instruction" and "TDG.VP.VMCALL Interface".
Based on previous patch by Sean Christopherson.
--- arch/x86/coco/tdx/Makefile | 2 +- arch/x86/coco/tdx/tdcall.S | 191 ++++++++++++++++++++++++++++++++++ arch/x86/coco/tdx/tdx.c | 23 ++++ arch/x86/include/asm/tdx.h | 27 +++++ arch/x86/kernel/asm-offsets.c | 8 ++ 5 files changed, 250 insertions(+), 1 deletion(-) create mode 100644 arch/x86/coco/tdx/tdcall.S
arch/x86/coco/tdx/Makefile +1 -1
@@ -1,3 +1,3 @@ # SPDX-License-Identifier: GPL-2.0 -obj-y += tdx.o +obj-y += tdx.o tdcall.o
arch/x86/coco/tdx/tdcall.S new file +191 -0
191 lines not on this page · raw message
arch/x86/coco/tdx/tdx.c +23 -0
@@ -7,6 +7,29 @@#include <linux/cpufeature.h> #include <asm/tdx.h> +/* +* Wrapper for standard use of __tdx_hypercall with no output aside from +* return code. +*/ +static inline u64 _tdx_hypercall (u64 fn,u64 r12,u64 r13,u64 r14,u64 r15) +{ +struct tdx_hypercall_args args = { + .r10 =TDX_HYPERCALL_STANDARD , + .r11 = fn, + .r12 = r12, + .r13 = r13, + .r14 = r14, + .r15 = r15, + }; + +return __tdx_hypercall (&args,0 ); +} + +/* Called from __tdx_hypercall() for unrecoverable failure */ +void __tdx_hypercall_failed (void ) +{ +panic ("TDVMCALL failed. TDX module bug?" ); +}void __init tdx_early_init (void ) {u32 eax, sig[3 ];
arch/x86/include/asm/tdx.h +27 -0
@@ -3,11 +3,16 @@#ifndef _ASM_X86_TDX_H#define _ASM_X86_TDX_H +#include <linux/bits.h> #include <linux/init.h> #define TDX_CPUID_LEAF_ID 0x21#define TDX_IDENT "IntelTDX " +#define TDX_HYPERCALL_STANDARD 0 + +#define TDX_HCALL_HAS_OUTPUT BIT(0) +/* * SW-defined error codes. *
@@ -35,10 +40,32 @@ struct tdx_module_output {u64 r11; }; +/* +* Used in __tdx_hypercall() to pass down and get back registers' values of +* the TDCALL instruction when requesting services from the VMM. +* +* This is a software only structure and not part of the TDX module/VMM ABI. +*/ +struct tdx_hypercall_args { +u64 r10; +u64 r11; +u64 r12; +u64 r13; +u64 r14; +u64 r15; +}; +#ifdef CONFIG_INTEL_TDX_GUEST void __init tdx_early_init (void ); +/* Used to communicate with the TDX module */ +u64 __tdx_module_call (u64 fn,u64 rcx,u64 rdx,u64 r8,u64 r9, +struct tdx_module_output *out); + +/* Used to request services from the VMM */ +u64 __tdx_hypercall (struct tdx_hypercall_args *args,unsigned long flags); +#else static inline void tdx_early_init (void ) { };
arch/x86/kernel/asm-offsets.c +8 -0
@@ -74,6 +74,14 @@ static void __used common(void)OFFSET (TDX_MODULE_r10, tdx_module_output, r10);OFFSET (TDX_MODULE_r11, tdx_module_output, r11); +BLANK (); +OFFSET (TDX_HYPERCALL_r10, tdx_hypercall_args, r10); +OFFSET (TDX_HYPERCALL_r11, tdx_hypercall_args, r11); +OFFSET (TDX_HYPERCALL_r12, tdx_hypercall_args, r12); +OFFSET (TDX_HYPERCALL_r13, tdx_hypercall_args, r13); +OFFSET (TDX_HYPERCALL_r14, tdx_hypercall_args, r14); +OFFSET (TDX_HYPERCALL_r15, tdx_hypercall_args, r15); +BLANK ();OFFSET (BP_scratch, boot_params, scratch);OFFSET (BP_secure_boot, boot_params, secure_boot);
Signature · 1 line
2.34.1
Re: [PATCHv6 03/30] x86/tdx: Add __tdx_module_call() and __tdx_hypercall() helper functions
Quoted 14 lines · Kirill A. Shutemov
arch/x86/coco/tdx/tdx.c +14
-0+/* +* Wrapper for standard use of __tdx_hypercall with no output aside from +* return code. +*/ +static inline u64 _tdx_hypercall (u64 fn,u64 r12,u64 r13,u64 r14,u64 r15) +{ +struct tdx_hypercall_args args = { + .r10 =TDX_HYPERCALL_STANDARD , + .r11 = fn, + .r12 = r12, + .r13 = r13, + .r14 = r14, + .r15 = r15, + };
arch/x86/coco/tdx/tdx.c line 33
Quoted 10 lines
arch/x86/coco/tdx/tdx.c +9
-0+ +return __tdx_hypercall (&args,0 ); +} + +/* Called from __tdx_hypercall() for unrecoverable failure */ +void __tdx_hypercall_failed (void ) +{ +panic ("TDVMCALL failed. TDX module bug?" ); +}void __init tdx_early_init (void )
Lacks a new line before tdx_early_init().
Other than that:
Re: [PATCHv6 03/30] x86/tdx: Add __tdx_module_call() and __tdx_hypercall() helper functions
In reply to Kirill A. ShutemovQuoted 8 lines · Kirill A. Shutemov
From: Kuppuswamy Sathyanarayanan <[email protected]>
Guests communicate with VMMs with hypercalls. Historically, these are implemented using instructions that are known to cause VMEXITs like VMCALL, VMLAUNCH, etc. However, with TDX, VMEXITs no longer expose the guest state to the host. This prevents the old hypercall mechanisms from working. So, to communicate with VMM, TDX specification defines a new instruction called TDCALL.
...
Quoted 10 lines
For registers used by the TDCALL instruction, please check TDX GHCI specification, the section titled "TDCALL instruction" and "TDG.VP.VMCALL Interface".
Based on previous patch by Sean Christopherson.
Reviewed-by Tony Luck <[email protected]>Signed-off-by Kuppuswamy Sathyanarayanan <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>Reviewed-by Dave Hansen <[email protected]>
Quoted 8 lines
--- arch/x86/coco/tdx/Makefile | 2 +- arch/x86/coco/tdx/tdcall.S | 191 ++++++++++++++++++++++++++++++++++ arch/x86/coco/tdx/tdx.c | 23 ++++ arch/x86/include/asm/tdx.h | 27 +++++ arch/x86/kernel/asm-offsets.c | 8 ++ 5 files changed, 250 insertions(+), 1 deletion(-) create mode 100644 arch/x86/coco/tdx/tdcall.S
With tglx's comment fixed:
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquettePATCH v6 4/30 x86/tdx: Extend the confidential computing API to support TDX guests
In reply to Kirill A. ShutemovConfidential Computing (CC) features (like string I/O unroll support, memory encryption/decryption support, etc) are conditionally enabled in the kernel using cc_platform_has() API. Since TDX guests also need to use these CC features, extend cc_platform_has() API and add TDX guest-specific CC attributes support.
CC API also provides an interface to deal with encryption mask. Extend it to cover TDX.
Details about which bit in the page table entry to be used to indicate shared/private state is determined by using the TDINFO TDCALL.
--- arch/x86/Kconfig | 1 + arch/x86/coco/core.c | 12 +++++++++++ arch/x86/coco/tdx/tdx.c | 47 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 60 insertions(+)
arch/x86/Kconfig +1 -0
@@ -884,6 +884,7 @@ config INTEL_TDX_GUEST bool "Intel TDX (Trust Domain Extensions) - Guest Support" depends on X86_64 && CPU_SUP_INTEL depends on X86_X2APIC + select ARCH_HAS_CC_PLATFORM help Support running as a guest under Intel TDX. Without this support, the guest kernel can not boot or run under TDX.
arch/x86/coco/core.c +12 -0
@@ -87,9 +87,18 @@ EXPORT_SYMBOL_GPL(cc_platform_has);u64 cc_mkenc (u64 val) { +/* +* Both AMD and Intel use a bit in the page table to indicate +* encryption status of the page. +* +* - for AMD, bit *set* means the page is encrypted +* - for Intel *clear* means encrypted. +*/ switch (vendor) {case CC_VENDOR_AMD :return val | cc_mask; +case CC_VENDOR_INTEL : +return val & ~cc_mask;default :return val; }
@@ -97,9 +106,12 @@ u64 cc_mkenc(u64 val)u64 cc_mkdec (u64 val) { +/* See comment in cc_mkenc() */ switch (vendor) {case CC_VENDOR_AMD :return val & ~cc_mask; +case CC_VENDOR_INTEL : +return val | cc_mask;default :return val; }
arch/x86/coco/tdx/tdx.c +47 -0
68 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCHv6 04/30] x86/tdx: Extend the confidential computing API to support TDX guests
Review
Quoted 2 lines · Kirill A. Shutemov
(quoted diff) +2
-0+ +static void get_info(unsigned int *gpa_width)
get_info() is really not a descriptive function name. Also why does this need a pointer and does not return gpa_width?
arch/x86/coco/tdx/tdx.c void __init tdx_early_init(void) · line 89
Quoted 12 lines
arch/x86/coco/tdx/tdx.c +9
-0setup_force_cpu_cap (X86_FEATURE_TDX_GUEST ); +get_info (&gpa_width); + +cc_set_vendor (CC_VENDOR_INTEL ); + +/* +* The highest bit of a guest physical address is the "sharing" bit. +* Set it for shared pages and clear it for private pages. +*/ +cc_set_mask (BIT_ULL (gpa_width -1 ));
The code ordering here is silly:
1) Retrieve gpa width
2) Set CC vendor
3) Use gpa width
static u64 get_cc_mask(void)
{
gpa_width = magic();
/*
* Comment explaining the return value
*/
return BIT_ULL(gpa_width - 1);
}and
cc_set_vendor(CC_VENDOR_INTEL);
cc_set_mask(get_cc_mask());would be too intuitive, right?
Thanks,
tglx
---
“My tastes are simple: I am easily satisfied with the best.”
― Winston S. Churchill
PATCH v6 5/30 x86/tdx: Exclude shared bit from __PHYSICAL_MASK
In reply to Kirill A. ShutemovIn TDX guests, by default memory is protected from host access. If a guest needs to communicate with the VMM (like the I/O use case), it uses a single bit in the physical address to communicate the protected/shared attribute of the given page.
In the x86 ARCH code, __PHYSICAL_MASK macro represents the width of the physical address in the given architecture. It is used in creating physical PAGE_MASK for address bits in the kernel. Since in TDX guest, a single bit is used as metadata, it needs to be excluded from valid physical address bits to avoid using incorrect addresses bits in the kernel.
Enable DYNAMIC_PHYSICAL_MASK to support updating the __PHYSICAL_MASK.
--- arch/x86/Kconfig | 1 + arch/x86/coco/tdx/tdx.c | 8 ++++++++ 2 files changed, 9 insertions(+)
arch/x86/Kconfig +1 -0
@@ -885,6 +885,7 @@ config INTEL_TDX_GUEST depends on X86_64 && CPU_SUP_INTEL depends on X86_X2APIC select ARCH_HAS_CC_PLATFORM + select DYNAMIC_PHYSICAL_MASK help Support running as a guest under Intel TDX. Without this support, the guest kernel can not boot or run under TDX.
arch/x86/coco/tdx/tdx.c +8 -0
@@ -82,6 +82,14 @@ void __init tdx_early_init(void)cc_set_vendor (CC_VENDOR_INTEL ); +/* +* All bits above GPA width are reserved and kernel treats shared bit +* as flag, not as part of physical address. +* +* Adjust physical mask to only cover valid GPA bits. +*/ + physical_mask &=GENMASK_ULL (gpa_width -2 ,0 ); +/* * The highest bit of a guest physical address is the "sharing" bit. * Set it for shared pages and clear it for private pages.
Signature · 1 line
2.34.1
Re: [PATCHv6 05/30] x86/tdx: Exclude shared bit from __PHYSICAL_MASK
arch/x86/coco/tdx/tdx.c void __init tdx_early_init(void) · line 92
Quoted 12 lines · Kirill A. Shutemov
arch/x86/coco/tdx/tdx.c +8
-0@@ -82,6 +82,14 @@ void __init tdx_early_init(void)cc_set_vendor (CC_VENDOR_INTEL ); +/* +* All bits above GPA width are reserved and kernel treats shared bit +* as flag, not as part of physical address. +* +* Adjust physical mask to only cover valid GPA bits. +*/ + physical_mask &=GENMASK_ULL (gpa_width -2 ,0 ); +
Hrm. I forgot about the second use case for gpa_width, but my comment about ordering still stands. OTOH:
GENMASK_ULL(gpa_width - 2, 0) == BIT_UL(gpa_width - 1) - 1
right? So you really can consolidate on the fact that cc_mask is a single bit which is above the guests physical address space boundary.
I.e. make the code tell the story instead of adding lengthy comments explaining the obfuscation.
Thanks,
tglx
Re: [PATCHv6 05/30] x86/tdx: Exclude shared bit from __PHYSICAL_MASK
Quoted 17 lines · Thomas Gleixner
arch/x86/coco/tdx/tdx.c void __init tdx_early_init(void) · line 92
Quoted 12 lines · Kirill A. Shutemov
arch/x86/coco/tdx/tdx.c +8
-0@@ -82,6 +82,14 @@ void __init tdx_early_init(void)cc_set_vendor (CC_VENDOR_INTEL ); +/* +* All bits above GPA width are reserved and kernel treats shared bit +* as flag, not as part of physical address. +* +* Adjust physical mask to only cover valid GPA bits. +*/ + physical_mask &=GENMASK_ULL (gpa_width -2 ,0 ); +Hrm. I forgot about the second use case for
gpa_width, but my comment about ordering still stands. OTOH:
Quoted 7 lines
GENMASK_ULL(gpa_width - 2, 0) == BIT_UL(gpa_width - 1) - 1right? So you really can consolidate on the fact that
cc_maskis a single bit which is above the guests physical address space boundary.I.e. make the code tell the story instead of adding lengthy comments explaining the obfuscation.
So it will looks something like this:
cc_set_vendor(CC_VENDOR_INTEL); cc_mask = get_cc_mask(); cc_set_mask(cc_mask); /* * All bits above GPA width are reserved and kernel treats shared bit * as flag, not as part of physical address. * * Adjust physical mask to only cover valid GPA bits. */ physical_mask &= cc_mask - 1;
I still think these comments are useful. I hided comment for cc_mask calclulation inside get_cc_mask().
Does it look fine to you?
Signature · 1 line
Kirill A. Shutemov
Re: [PATCHv6 05/30] x86/tdx: Exclude shared bit from __PHYSICAL_MASK
Quoted 41 lines · Kirill A. Shutemov
Quoted 17 lines · Thomas Gleixner
arch/x86/coco/tdx/tdx.c void __init tdx_early_init(void) · line 92
Quoted 12 lines · Kirill A. Shutemov
arch/x86/coco/tdx/tdx.c +8
-0@@ -82,6 +82,14 @@ void __init tdx_early_init(void)cc_set_vendor (CC_VENDOR_INTEL ); +/* +* All bits above GPA width are reserved and kernel treats shared bit +* as flag, not as part of physical address. +* +* Adjust physical mask to only cover valid GPA bits. +*/ + physical_mask &=GENMASK_ULL (gpa_width -2 ,0 ); +Hrm. I forgot about the second use case for
gpa_width, but my comment about ordering still stands. OTOH:Quoted 7 lines
GENMASK_ULL(gpa_width - 2, 0) == BIT_UL(gpa_width - 1) - 1right? So you really can consolidate on the fact that
cc_maskis a single bit which is above the guests physical address space boundary.I.e. make the code tell the story instead of adding lengthy comments explaining the obfuscation.
So it will looks something like this:
cc_set_vendor(CC_VENDOR_INTEL); cc_mask = get_cc_mask(); cc_set_mask(cc_mask); /* * All bits above GPA width are reserved and kernel treats shared bit * as flag, not as part of physical address. * * Adjust physical mask to only cover valid GPA bits. */ physical_mask &= cc_mask - 1;
Quoted 4 lines
I still think these comments are useful. I hided comment for
cc_maskcalclulation insideget_cc_mask().Does it look fine to you?
Yes.
PATCH v6 6/30 x86/traps: Refactor exc_general_protection()
In reply to Kirill A. ShutemovTDX brings a new exception -- Virtualization Exception (#VE). Handling of #VE structurally very similar to handling #GP.
Extract two helpers from exc_general_protection() that can be reused for handling #VE.
No functional changes.
--- arch/x86/kernel/traps.c | 60 +++++++++++++++++++++++------------------ 1 file changed, 34 insertions(+), 26 deletions(-)
arch/x86/kernel/traps.c +34 -26
@@ -611,13 +611,43 @@ static bool try_fixup_enqcmd_gp(void)#endif } +static bool gp_try_fixup_and_notify (struct pt_regs *regs,int trapnr, +unsigned long error_code,const char *str) +{ +int ret; + +if (fixup_exception (regs, trapnr, error_code,0 )) +return true; + + current->thread.error_code = error_code; + current->thread.trap_nr = trapnr; + +/* +* To be potentially processing a kprobe fault and to trust the result +* from kprobe_running(), we have to be non-preemptible. +*/ +if (!preemptible () &&kprobe_running () && +kprobe_fault_handler (regs, trapnr)) +return true; + + ret =notify_die (DIE_GPF , str, regs, error_code, trapnr,SIGSEGV ); +return ret ==NOTIFY_STOP ; +} + +static void gp_user_force_sig_segv (struct pt_regs *regs,int trapnr, +unsigned long error_code,const char *str) +{ + current->thread.error_code = error_code; + current->thread.trap_nr = trapnr; +show_signal (current,SIGSEGV ,"" , str, regs, error_code); +force_sig (SIGSEGV ); +} +DEFINE_IDTENTRY_ERRORCODE (exc_general_protection) {char desc[sizeof (GPFSTR ) +50 +2 *sizeof (unsigned long ) +1 ] =GPFSTR ;enum kernel_gp_hint hint =GP_NO_HINT ; -struct task_struct *tsk;unsigned long gp_addr; -int ret;if (user_mode (regs) &&try_fixup_enqcmd_gp ())return ;
@@ -636,40 +666,18 @@ DEFINE_IDTENTRY_ERRORCODE(exc_general_protection)return ; } - tsk = current; -if (user_mode (regs)) {if (fixup_iopl_exception (regs)) goto exit; - tsk->thread.error_code = error_code; - tsk->thread.trap_nr =X86_TRAP_GP ; -if (fixup_vdso_exception (regs,X86_TRAP_GP , error_code,0 )) goto exit; -show_signal (tsk,SIGSEGV ,"" , desc, regs, error_code); -force_sig (SIGSEGV ); +gp_user_force_sig_segv (regs,X86_TRAP_GP , error_code, desc); goto exit; } -if (fixup_exception (regs,X86_TRAP_GP , error_code,0 )) - goto exit; - - tsk->thread.error_code = error_code; - tsk->thread.trap_nr =X86_TRAP_GP ; - -/* -* To be potentially processing a kprobe fault and to trust the result -* from kprobe_running(), we have to be non-preemptible. -*/ -if (!preemptible () && -kprobe_running () && -kprobe_fault_handler (regs,X86_TRAP_GP )) - goto exit; - - ret =notify_die (DIE_GPF , desc, regs, error_code,X86_TRAP_GP ,SIGSEGV ); -if (ret ==NOTIFY_STOP ) +if (gp_try_fixup_and_notify (regs,X86_TRAP_GP , error_code, desc)) goto exit;if (error_code)
Signature · 1 line
2.34.1
Re: [PATCHv6 06/30] x86/traps: Refactor exc_general_protection()
Quoted 10 lines · Kirill A. Shutemov
TDX brings a new exception -- Virtualization Exception (#VE). Handling of #VE structurally very similar to handling #GP.
Extract two helpers from
exc_general_protection()that can be reused for handling #VE.No functional changes.
Signed-off-by Kirill A. Shutemov <[email protected]>Reviewed-by Dave Hansen <[email protected]>
Not that I care much, but this is the second instance of something I suggested. We have tags for that...
arch/x86/kernel/traps.c static bool try_fixup_enqcmd_gp(void) · line 617
Quoted 4 lines
arch/x86/kernel/traps.c +4
-0+static bool gp_try_fixup_and_notify (struct pt_regs *regs,int trapnr, +unsigned long error_code,const char *str) +{ +int ret;
Adding this to make my suggestion compile is the easy way out, but...
Quoted 7 lines
arch/x86/kernel/traps.c +7
-0+ +if (fixup_exception (regs, trapnr, error_code,0 )) +return true; + + current->thread.error_code = error_code; + current->thread.trap_nr = trapnr; +
arch/x86/kernel/traps.c static bool try_fixup_enqcmd_gp(void) · line 634
Quoted 10 lines
arch/x86/kernel/traps.c +10
-0+/* +* To be potentially processing a kprobe fault and to trust the result +* from kprobe_running(), we have to be non-preemptible. +*/ +if (!preemptible () &&kprobe_running () && +kprobe_fault_handler (regs, trapnr)) +return true; + + ret =notify_die (DIE_GPF , str, regs, error_code, trapnr,SIGSEGV ); +return ret ==NOTIFY_STOP ;
Why not doing the obvious:
return notify_die(DIE_GPF, str, regs, error_code, trapnr, SIGSEGV) == NOTIFY_STOP;
Hmm?
Thanks,
tglx
Re: [PATCHv6 06/30] x86/traps: Refactor exc_general_protection()
Quoted 7 lines · Thomas Gleixner
Quoted 6 lines · Kirill A. Shutemov
TDX brings a new exception -- Virtualization Exception (#VE). Handling of #VE structurally very similar to handling #GP.
Extract two helpers from
exc_general_protection()that can be reused for handling #VE.
Quoted 7 lines
Quoted 4 lines
No functional changes.
Signed-off-by Kirill A. Shutemov <[email protected]>Reviewed-by Dave Hansen <[email protected]>Not that I care much, but this is the second instance of something I suggested. We have tags for that...
Sorry, will add the tag.
By the other instance you meant common base for SEAMCALL and TDCALL C wrappers, right? Will fix too.
Quoted 27 lines
arch/x86/kernel/traps.c static bool try_fixup_enqcmd_gp(void) · line 617
Quoted 4 lines
arch/x86/kernel/traps.c +4
-0+static bool gp_try_fixup_and_notify (struct pt_regs *regs,int trapnr, +unsigned long error_code,const char *str) +{ +int ret;Adding this to make my suggestion compile is the easy way out, but...
Quoted 7 lines
arch/x86/kernel/traps.c +7
-0+ +if (fixup_exception (regs, trapnr, error_code,0 )) +return true; + + current->thread.error_code = error_code; + current->thread.trap_nr = trapnr; +arch/x86/kernel/traps.c static bool try_fixup_enqcmd_gp(void) · line 634
Quoted 10 lines
arch/x86/kernel/traps.c +10
-0+/* +* To be potentially processing a kprobe fault and to trust the result +* from kprobe_running(), we have to be non-preemptible. +*/ +if (!preemptible () &&kprobe_running () && +kprobe_fault_handler (regs, trapnr)) +return true; + + ret =notify_die (DIE_GPF , str, regs, error_code, trapnr,SIGSEGV ); +return ret ==NOTIFY_STOP ;Why not doing the obvious:
Quoted 3 lines
return notify_die(DIE_GPF, str, regs, error_code, trapnr, SIGSEGV) == NOTIFY_STOP;Hmm?
I don't like lines this long (although my variant doesn't look good too).
Will do your way.
Signature · 1 line
Kirill A. Shutemov
PATCH v6 7/30 x86/traps: Add #VE support for TDX guest
In reply to Kirill A. ShutemovVirtualization Exceptions (#VE) are delivered to TDX guests due to specific guest actions which may happen in either user space or the kernel:
* Specific instructions (WBINVD, for example)
* Specific MSR accesses
* Specific CPUID leaf accesses
* Access to specific guest physical addresses
Syscall entry code has a critical window where the kernel stack is not yet set up. Any exception in this window leads to hard to debug issues and can be exploited for privilege escalation. Exceptions in the NMI entry code also cause issues. Returning from the exception handler with IRET will re-enable NMIs and nested NMI will corrupt the NMI stack.
For these reasons, the kernel avoids #VEs during the syscall gap and the NMI entry code. Entry code paths do not access TD-shared memory, MMIO regions, use #VE triggering MSRs, instructions, or CPUID leaves that might generate #VE. VMM can remove memory from TD at any point, but access to unaccepted (or missing) private memory leads to VM termination, not to #VE.
Similarly to page faults and breakpoints, #VEs are allowed in NMI handlers once the kernel is ready to deal with nested NMIs.
During #VE delivery, all interrupts, including NMIs, are blocked until TDGETVEINFO is called. It prevents #VE nesting until the kernel reads the VE info.
TDGETVEINFO retrieves the #VE info from the TDX module, which also clears the "#VE valid" flag. This must be done before anything else as any #VE that occurs while the valid flag is set escalates to #DF by TDX module. It will result in an oops.
Virtual NMIs are inhibited if the #VE valid flag is set. NMI will not be delivered until TDGETVEINFO is called.
For now, convert unhandled #VE's (everything, until later in this series) so that they appear just like a #GP by calling the ve_raise_fault() directly. The ve_raise_fault() function is similar to #GP handler and is responsible for sending SIGSEGV to userspace and CPU die and notifying debuggers and other die chain users.
--- arch/x86/coco/tdx/tdx.c | 31 +++++++++++++ arch/x86/include/asm/idtentry.h | 4 ++ arch/x86/include/asm/tdx.h | 21 +++++++++ arch/x86/kernel/idt.c | 3 ++ arch/x86/kernel/traps.c | 81 +++++++++++++++++++++++++++++++++ 5 files changed, 140 insertions(+)
arch/x86/coco/tdx/tdx.c +31 -0
@@ -10,6 +10,7 @@/* TDX module Call Leaf IDs */ #define TDX_GET_INFO 1 +#define TDX_GET_VEINFO 3/* * Wrapper for standard use of __tdx_hypercall with no output aside from
@@ -66,6 +67,36 @@ static void get_info(unsigned int *gpa_width) *gpa_width = out.rcx &GENMASK (5 ,0 ); } +void tdx_get_ve_info (struct ve_info *ve) +{ +struct tdx_module_output out; + +/* +* Called during #VE handling to retrieve the #VE info from the +* TDX module. +* +* This should called done early in #VE handling. A "nested" +* #VE which occurs before this will raise a #DF and is not +* recoverable. +*/ +tdx_module_call (TDX_GET_VEINFO ,0 ,0 ,0 ,0 , &out); + +/* Interrupts and NMIs can be delivered again. */ + ve->exit_reason = out.rcx; + ve->exit_qual = out.rdx; + ve->gla = out.r8; + ve->gpa = out.r9; + ve->instr_len =lower_32_bits (out.r10); + ve->instr_info =upper_32_bits (out.r10); +} + +bool tdx_handle_virt_exception (struct pt_regs *regs,struct ve_info *ve) +{ +pr_warn ("Unexpected #VE: %lld\n" , ve->exit_reason); + +return false; +} +void __init tdx_early_init (void ) {unsigned int gpa_width;
arch/x86/include/asm/idtentry.h +4 -0
@@ -625,6 +625,10 @@ DECLARE_IDTENTRY_XENCB(X86_TRAP_OTHER, exc_xen_hypervisor_callback);DECLARE_IDTENTRY_RAW (X86_TRAP_OTHER , exc_xen_unknown_trap);#endif +#ifdef CONFIG_INTEL_TDX_GUEST +DECLARE_IDTENTRY (X86_TRAP_VE , exc_virtualization_exception); +#endif +/* Device interrupts common/spurious */ DECLARE_IDTENTRY_IRQ (X86_TRAP_OTHER , common_interrupt);#ifdef CONFIG_X86_LOCAL_APIC
arch/x86/include/asm/tdx.h +21 -0
@@ -5,6 +5,7 @@#include <linux/bits.h> #include <linux/init.h> +#include <asm/ptrace.h> #define TDX_CPUID_LEAF_ID 0x21#define TDX_IDENT "IntelTDX "
@@ -55,6 +56,22 @@ struct tdx_hypercall_args {u64 r15; }; +/* +* Used by the #VE exception handler to gather the #VE exception +* info from the TDX module. This is a software only structure +* and not part of the TDX module/VMM ABI. +*/ +struct ve_info { +u64 exit_reason; +u64 exit_qual; +/* Guest Linear (virtual) Address */ +u64 gla; +/* Guest Physical Address */ +u64 gpa; +u32 instr_len; +u32 instr_info; +}; +#ifdef CONFIG_INTEL_TDX_GUEST void __init tdx_early_init (void );
@@ -66,6 +83,10 @@ u64 __tdx_module_call(u64 fn, u64 rcx, u64 rdx, u64 r8, u64 r9,/* Used to request services from the VMM */ u64 __tdx_hypercall (struct tdx_hypercall_args *args,unsigned long flags); +void tdx_get_ve_info (struct ve_info *ve); + +bool tdx_handle_virt_exception (struct pt_regs *regs,struct ve_info *ve); +#else static inline void tdx_early_init (void ) { };
arch/x86/kernel/idt.c +3 -0
@@ -68,6 +68,9 @@ static const __initconst struct idt_data early_idts[] = {*/ INTG(X86_TRAP_PF, asm_exc_page_fault),#endif +#ifdef CONFIG_INTEL_TDX_GUEST + INTG(X86_TRAP_VE, asm_exc_virtualization_exception), +#endif };/*
arch/x86/kernel/traps.c +81 -0
93 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCHv6 07/30] x86/traps: Add #VE support for TDX guest
arch/x86/coco/tdx/tdx.c static void get_info(unsigned int *gpa_width) · line 78
Quoted 9 lines · Kirill A. Shutemov
arch/x86/coco/tdx/tdx.c +9
-0+void tdx_get_ve_info (struct ve_info *ve) +{ +struct tdx_module_output out; + +/* +* Called during #VE handling to retrieve the #VE info from the +* TDX module. +* +* This should called done early in #VE handling. A "nested"
... has to be called early ..
arch/x86/coco/tdx/tdx.c static void get_info(unsigned int *gpa_width) · line 84
Quoted 6 lines
arch/x86/coco/tdx/tdx.c +6
-0+* #VE which occurs before this will raise a #DF and is not +* recoverable. +*/ +tdx_module_call (TDX_GET_VEINFO ,0 ,0 ,0 ,0 , &out); + +/* Interrupts and NMIs can be delivered again. */
Please put a new line between this comment and the code below because they are completely unrelated. Also interrupts cannot be delivered here because this code runs with interrupts disabled ...
And I rather have this comment above the tdx_module_call() invocation:
* recoverable.
*
* <Useful comment about VE info and NMIs>
When I reviewed this last time, Sean provided a very concise comment for this.
*/
tdx_module_call(...);
/* Transfer the output parameters */arch/x86/coco/tdx/tdx.c static void get_info(unsigned int *gpa_width) · line 85
Quoted 1 line
arch/x86/coco/tdx/tdx.c +1
-0+ ve->exit_reason = out.rcx;
....
Hmm?
Quoted 9 lines
+/*
+ * Virtualization Exceptions (#VE) are delivered to TDX guests due to
+ * specific guest actions which may happen in either user space or the
+ * kernel:
+ *+ * * Specific instructions (WBINVD, for example) + * * Specific MSR accesses + * * Specific CPUID leaf accesses + * * Access to specific guest physical addresses
Quoted 15 lines
+ *
+ * In the settings that Linux will run in, virtualization exceptions are
+ * never generated on accesses to normal, TD-private memory that has been
+ * accepted.
+ *
+ * Syscall entry code has a critical window where the kernel stack is not
+ * yet set up. Any exception in this window leads to hard to debug issues
+ * and can be exploited for privilege escalation. Exceptions in the NMI
+ * entry code also cause issues. Returning from the exception handler with
+ * IRET will re-enable NMIs and nested NMI will corrupt the NMI stack.
+ *
+ * For these reasons, the kernel avoids #VEs during the syscall gap and
+ * the NMI entry code. Entry code paths do not access TD-shared memory,
+ * MMIO regions, use #VE triggering MSRs, instructions, or CPUID leaves
+ * that might generate #VE.
I asked that before:
"How is that enforced or validated? What checks for a violation of that
assumption?"
This is still exactly the same comment which is based on testing which did not yet explode in your face, right?
So what's the point of this blurb? Create expectations which are not accountable?
The point is that any #VE in such a code path is fatal and you better come up with some reasonable explanation why this is not the case in those code pathes and how a potential violation of that assumption might be detected especially in rarely used corner cases. If such a violation is not detectable by audit, CI, static code analysis or whatever then document the consequences instead of pretending that the problem does not exist and the kernel is perfect today and forever.
Thanks,
tglx
Re: [PATCHv6 07/30] x86/traps: Add #VE support for TDX guest
Quoted 2 lines · Thomas Gleixner
On Wed, Mar 16 2022 at 05:08, Kirill A. Shutemov wrote:
Hmm?
Does the changed version below address your concerns?
void tdx_get_ve_info(struct ve_info *ve)
{
struct tdx_module_output out;
/*
* Called during #VE handling to retrieve the #VE info from the
* TDX module.
*
* This has to be called early in #VE handling. A "nested" #VE which
* occurs before this will raise a #DF and is not recoverable.
*
* The call retrieves the #VE info from the TDX module, which also
* clears the "#VE valid" flag. This must be done before anything else
* because any #VE that occurs while the valid flag is set will lead to
* #DF.
*
* Note, the TDX module treats virtual NMIs as inhibited if the #VE
* valid flag is set. It means that NMI=>#VE will not result in a #DF.
*/
tdx_module_call(TDX_GET_VEINFO, 0, 0, 0, 0, &out);
/* Transfer the output parameters */
ve->exit_reason = out.rcx;
ve->exit_qual = out.rdx;
ve->gla = out.r8;
ve->gpa = out.r9;
ve->instr_len = lower_32_bits(out.r10);
ve->instr_info = upper_32_bits(out.r10);
}Quoted 25 lines
Quoted 9 lines
+/*
+ * Virtualization Exceptions (#VE) are delivered to TDX guests due to
+ * specific guest actions which may happen in either user space or the
+ * kernel:
+ *+ * * Specific instructions (WBINVD, for example) + * * Specific MSR accesses + * * Specific CPUID leaf accesses + * * Access to specific guest physical addressesQuoted 15 lines
+ *
+ * In the settings that Linux will run in, virtualization exceptions are
+ * never generated on accesses to normal, TD-private memory that has been
+ * accepted.
+ *
+ * Syscall entry code has a critical window where the kernel stack is not
+ * yet set up. Any exception in this window leads to hard to debug issues
+ * and can be exploited for privilege escalation. Exceptions in the NMI
+ * entry code also cause issues. Returning from the exception handler with
+ * IRET will re-enable NMIs and nested NMI will corrupt the NMI stack.
+ *
+ * For these reasons, the kernel avoids #VEs during the syscall gap and
+ * the NMI entry code. Entry code paths do not access TD-shared memory,
+ * MMIO regions, use #VE triggering MSRs, instructions, or CPUID leaves
+ * that might generate #VE.
Quoted 7 lines
I asked that before:
"How is that enforced or validated? What checks for a violation of that
assumption?"This is still exactly the same comment which is based on testing which did not yet explode in your face, right?
[ Disclaimer: I have limited understanding of the entry code complexity
and may miss some crucial details. But I try my best. ]
Yes, it is the same comment, but it is based on code audit, not only on testing.
I claim that kernel does not do anything that can possibly trigger #VE where kernel cannot deal with it:
- on syscall entry code before kernel stack is set up (few instructions in the beginning of entry_SYSCALL_64())
- in NMI entry code (asm_exc_nmi()) before NMI nesting is safe:
+ for NMI from user mode, before switched to thread stack
+ for NMI from kernel, up to end_repead_nmi
After that points #VE is safe.
Quoted 2 lines
So what's the point of this blurb? Create expectations which are not accountable?
I don't have such intentions.
Quoted 7 lines
The point is that any #VE in such a code path is fatal and you better come up with some reasonable explanation why this is not the case in those code pathes and how a potential violation of that assumption might be detected especially in rarely used corner cases. If such a violation is not detectable by audit, CI, static code analysis or whatever then document the consequences instead of pretending that the problem does not exist and the kernel is perfect today and forever.
It is detectable by audit. The critical windows very limited and located in the highly scrutinized entry code. But, yes, I cannot guarantee that this code will be perfect forever.
Consequences of #VE in these critical windows are mentioned in the comment:
Any exception in this window leads to hard to debug issues and can be exploited for privilege escalation.
I have hard time understanding what I has to change here. Do you want details of audit to be documented? Make consequences of #VE at the wrong point to be more prominent in the comment?
Signature · 1 line
Kirill A. Shutemov
Re: [PATCHv6 07/30] x86/traps: Add #VE support for TDX guest
Quoted 27 lines · Kirill A. Shutemov
Quoted 2 lines · Thomas Gleixner
On Wed, Mar 16 2022 at 05:08, Kirill A. Shutemov wrote:
Hmm?Does the changed version below address your concerns?
void tdx_get_ve_info(struct ve_info *ve) { struct tdx_module_output out; /* * Called during #VE handling to retrieve the #VE info from the * TDX module. * * This has to be called early in #VE handling. A "nested" #VE which * occurs before this will raise a #DF and is not recoverable. * * The call retrieves the #VE info from the TDX module, which also * clears the "#VE valid" flag. This must be done before anything else * because any #VE that occurs while the valid flag is set will lead to * #DF. * * Note, the TDX module treats virtual NMIs as inhibited if the #VE * valid flag is set. It means that NMI=>#VE will not result in a #DF. */ tdx_module_call(TDX_GET_VEINFO, 0, 0, 0, 0, &out);
Quoted 8 lines
/* Transfer the output parameters */ ve->exit_reason = out.rcx; ve->exit_qual = out.rdx; ve->gla = out.r8; ve->gpa = out.r9; ve->instr_len = lower_32_bits(out.r10); ve->instr_info = upper_32_bits(out.r10); }
Nice.
Quoted 11 lines
Quoted 7 lines
The point is that any #VE in such a code path is fatal and you better come up with some reasonable explanation why this is not the case in those code pathes and how a potential violation of that assumption might be detected especially in rarely used corner cases. If such a violation is not detectable by audit, CI, static code analysis or whatever then document the consequences instead of pretending that the problem does not exist and the kernel is perfect today and forever.
It is detectable by audit. The critical windows very limited and located in the highly scrutinized entry code. But, yes, I cannot guarantee that this code will be perfect forever.
Fair enough.
Quoted 9 lines
Consequences of #VE in these critical windows are mentioned in the comment:
Any exception in this window leads to hard to debug issues and can be exploited for privilege escalation.
I have hard time understanding what I has to change here. Do you want details of audit to be documented? Make consequences of #VE at the wrong point to be more prominent in the comment?
So having something like this in the comment would be helpful:
*
* The entry code has been audited carefuly for following these
* expectations. Changes in the entry code have to be audited for
* correctness vs. this aspect. #VE in these places will cause
* [an instant kernel panic | whatever | fill the blanks ] *
Thanks,
tglx
Peter Zijlstra
maintainerRe: [PATCHv6 07/30] x86/traps: Add #VE support for TDX guest
In reply to Kirill A. ShutemovQuoted 9 lines · Kirill A. Shutemov
[ Disclaimer: I have limited understanding of the entry code complexity
and may miss some crucial details. But I try my best. ]Yes, it is the same comment, but it is based on code audit, not only on testing.
I claim that kernel does not do anything that can possibly trigger #VE where kernel cannot deal with it:
Quoted 8 lines
- on syscall entry code before kernel stack is set up (few instructions in the beginning of
entry_SYSCALL_64())- in NMI entry code (
asm_exc_nmi()) before NMI nesting is safe:
+ for NMI from user mode, before switched to thread stack
+ for NMI from kernel, up toend_repead_nmiAfter that points #VE is safe.
In what way is it guaranteed that #VE isn't raised in those places? What does an auditor / future coder looking to changes things, need to consider to keep this so.
From vague memories #VE can be raised on any memop, loading the stack address in the syscall-gap is a memop. What makes that special? Can we get a comment _there_ to explain how this is safe such that we can keep it so?
Same for the NMI path I suppose.
Re: [PATCHv6 07/30] x86/traps: Add #VE support for TDX guest
Quoted 4 lines · Peter Zijlstra
From vague memories #VE can be raised on any memop, loading the stack address in the syscall-gap is a memop. What makes that special? Can we get a comment _there_ to explain how this is safe such that we can keep it so?
#GP and #PF can be raised from any memop too. But, we know that if we only touch normal, valid kernel mappings, we don't have to worry about them.
The memop rules to avoid #VE are basically the same, except they also include "TD-shared" memory. But, "normal" kernel memory isn't ever shared because it's under the control of the untrusted hypervisor. The kernel trusts shared memory like it trusts userspace-mapped memory.
The kernel would be insane to, for instance, put its stack in userspace-writable memory. The same goes for TD-shared memory.
In the end, I'm asserting that we don't really have to be any more careful to avoid a #VE on a memory access than we are to avoid #GP and #PF.
The TDX rules are *much* nicer than SEV. They're also a lot nicer on TDX _now_ than they used to be. There are a few stubborn people at Intel who managed to add some drops of sanity to the architecture.
Peter Zijlstra
maintainerRe: [PATCHv6 07/30] x86/traps: Add #VE support for TDX guest
Quoted 3 lines · Dave Hansen
The TDX rules are *much* nicer than SEV. They're also a lot nicer on TDX _now_ than they used to be. There are a few stubborn people at Intel who managed to add some drops of sanity to the architecture.
Right; that is saner than it used to be. I have definite memories that pages could be taken back by the TDX thing and would need re-authentication. A pool of 'fixed' pages was talked about. I'm glad to hear all that is gone.
Re: [PATCHv6 07/30] x86/traps: Add #VE support for TDX guest
Quoted 10 lines · Peter Zijlstra
Quoted 3 lines · Dave Hansen
The TDX rules are *much* nicer than SEV. They're also a lot nicer on TDX _now_ than they used to be. There are a few stubborn people at Intel who managed to add some drops of sanity to the architecture.
Right; that is saner than it used to be. I have definite memories that pages could be taken back by the TDX thing and would need re-authentication. A pool of 'fixed' pages was talked about. I'm glad to hear all that is gone.
Right, VMM can still pull memory form the guest at any point, but reference of such memory from the guest would lead not to #VE as before, but to TD termination.
Signature · 1 line
Kirill A. Shutemov
Re: [PATCHv6 07/30] x86/traps: Add #VE support for TDX guest
In reply to Peter ZijlstraQuoted 11 lines · Peter Zijlstra
Quoted 5 lines · Kirill A. Shutemov
- in NMI entry code (
asm_exc_nmi()) before NMI nesting is safe:
+ for NMI from user mode, before switched to thread stack
+ for NMI from kernel, up toend_repead_nmiAfter that points #VE is safe.
In what way is it guaranteed that #VE isn't raised in those places? What does an auditor / future coder looking to changes things, need to consider to keep this so.
Quoted 6 lines
From vague memories #VE can be raised on any memop, loading the stack address in the syscall-gap is a memop. What makes that special? Can we get a comment _there_ to explain how this is safe such that we can keep it so?
Same for the NMI path I suppose.
#VE is raised by HLT, CPUID, I/O-Port access, MSR read/write, EPT violations
So in the hairy places:
- HLT: No business
- I/O Ports: That would be outright stupid to use
- CPUID: Should never be used - Emphasis on should :)
- MSRs: Same as CPUID
- EPT: Well....
Thanks,
Thomas
Re: [PATCHv6 07/30] x86/traps: Add #VE support for TDX guest
Quoted 23 lines · Thomas Gleixner
Quoted 11 lines · Peter Zijlstra
Quoted 5 lines · Kirill A. Shutemov
- in NMI entry code (
asm_exc_nmi()) before NMI nesting is safe:
+ for NMI from user mode, before switched to thread stack
+ for NMI from kernel, up toend_repead_nmiAfter that points #VE is safe.
In what way is it guaranteed that #VE isn't raised in those places? What does an auditor / future coder looking to changes things, need to consider to keep this so.
Quoted 6 lines
From vague memories #VE can be raised on any memop, loading the stack address in the syscall-gap is a memop. What makes that special? Can we get a comment _there_ to explain how this is safe such that we can keep it so?
Same for the NMI path I suppose.
#VE is raised by HLT, CPUID, I/O-Port access, MSR read/write, EPT violations
So in the hairy places:
Quoted 7 lines
- HLT: No business
- I/O Ports: That would be outright stupid to use- CPUID: Should never be used - Emphasis on should :)
- MSRs: Same as CPUID- EPT: Well....
EPT violation may result in #VE only on shared memory. If entry code touches shared memory we have a bigger problem than syscall gap.
Signature · 1 line
Kirill A. Shutemov
PATCH v6 8/30 x86/tdx: Add HLT support for TDX guests
In reply to Kirill A. ShutemovThe HLT instruction is a privileged instruction, executing it stops instruction execution and places the processor in a HALT state. It is used in kernel for cases like reboot, idle loop and exception fixup handlers. For the idle case, interrupts will be enabled (using STI) before the HLT instruction (this is also called safe_halt()).
To support the HLT instruction in TDX guests, it needs to be emulated using TDVMCALL (hypercall to VMM). More details about it can be found in Intel Trust Domain Extensions (Intel TDX) Guest-Host-Communication Interface (GHCI) specification, section TDVMCALL[Instruction.HLT].
In TDX guests, executing HLT instruction will generate a #VE, which is used to emulate the HLT instruction. But #VE based emulation will not work for the safe_halt() flavor, because it requires STI instruction to be executed just before the TDCALL. Since idle loop is the only user of safe_halt() variant, handle it as a special case.
To avoid *safe_halt() call in the idle function, define the tdx_guest_idle() and use it to override the "x86_idle" function pointer for a valid TDX guest.
Alternative choices like PV ops have been considered for adding safe_halt() support. But it was rejected because HLT paravirt calls only exist under PARAVIRT_XXL, and enabling it in TDX guest just for safe_halt() use case is not worth the cost.
--- arch/x86/coco/tdx/tdcall.S | 13 ++++++ arch/x86/coco/tdx/tdx.c | 93 +++++++++++++++++++++++++++++++++++++- arch/x86/include/asm/tdx.h | 4 ++ arch/x86/kernel/process.c | 4 ++ 4 files changed, 112 insertions(+), 2 deletions(-)
arch/x86/coco/tdx/tdcall.S +13 -0
@@ -139,6 +139,19 @@ SYM_FUNC_START(__tdx_hypercall) movl $TDVMCALL_EXPOSE_REGS_MASK, %ecx + /* + * For the idle loop STI needs to be called directly before the TDCALL + * that enters idle (EXIT_REASON_HLT case). STI instruction enables + * interrupts only one instruction later. If there is a window between + * STI and the instruction that emulates the HALT state, there is a + * chance for interrupts to happen in this window, which can delay the + * HLT operation indefinitely. Since this is the not the desired + * result, conditionally call STI before TDCALL. + */ + testq $TDX_HCALL_ISSUE_STI, %rsi + jz .Lskip_sti + sti +.Lskip_sti: tdcall /*
arch/x86/coco/tdx/tdx.c +91 -2
120 lines not on this page · raw message
arch/x86/include/asm/tdx.h +4 -0
@@ -13,6 +13,7 @@#define TDX_HYPERCALL_STANDARD 0#define TDX_HCALL_HAS_OUTPUT BIT(0) +#define TDX_HCALL_ISSUE_STI BIT(1)/* * SW-defined error codes.
@@ -87,9 +88,12 @@ void tdx_get_ve_info(struct ve_info *ve);bool tdx_handle_virt_exception (struct pt_regs *regs,struct ve_info *ve); +void tdx_safe_halt (void ); +#else static inline void tdx_early_init (void ) { }; +static inline void tdx_safe_halt (void ) { };#endif /* CONFIG_INTEL_TDX_GUEST */
arch/x86/kernel/process.c +4 -0
@@ -46,6 +46,7 @@#include <asm/proto.h> #include <asm/frame.h> #include <asm/unwind.h> +#include <asm/tdx.h> #include "process.h"
@@ -873,6 +874,9 @@ void select_idle_routine(const struct cpuinfo_x86 *c) }else if (prefer_mwait_c1_over_halt (c)) {pr_info ("using mwait in idle threads\n" ); x86_idle = mwait_idle; + }else if (cpu_feature_enabled (X86_FEATURE_TDX_GUEST )) { +pr_info ("using TDX aware idle routine\n" ); + x86_idle = tdx_safe_halt; }else x86_idle = default_idle; }
Signature · 1 line
2.34.1
PATCH v6 9/30 x86/tdx: Add MSR support for TDX guests
In reply to Kirill A. ShutemovUse hypercall to emulate MSR read/write for the TDX platform.
There are two viable approaches for doing MSRs in a TD guest:
1. Execute the RDMSR/WRMSR instructions like most VMs and bare metal do. Some will succeed, others will cause a #VE. All of those that cause a #VE will be handled with a TDCALL.
2. Use paravirt infrastructure. The paravirt hook has to keep a list of which MSRs would cause a #VE and use a TDCALL. All other MSRs execute RDMSR/WRMSR instructions directly.
The second option can be ruled out because the list of MSRs was challenging to maintain. That leaves option #1 as the only viable solution for the minimal TDX support.
Kernel relies on the exception fixup machinery to handle MSR access errors. #VE handler uses the same exception fixup code as #GP. It covers MSR accesses along with other types of fixups.
For performance-critical MSR writes (like TSC_DEADLINE), future patches will replace the WRMSR/#VE sequence with the direct TDCALL.
RDMSR and WRMSR specification details can be found in Guest-Host-Communication Interface (GHCI) for Intel Trust Domain Extensions (Intel TDX) specification, sec titled "TDG.VP. VMCALL<Instruction.RDMSR>" and "TDG.VP.VMCALL<Instruction.WRMSR>".
--- arch/x86/coco/tdx/tdx.c | 42 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+)
arch/x86/coco/tdx/tdx.c +42 -0
@@ -135,6 +135,44 @@ void __cpuidle tdx_safe_halt(void)WARN_ONCE (1 ,"HLT instruction emulation failed\n" ); } +static bool read_msr (struct pt_regs *regs) +{ +struct tdx_hypercall_args args = { + .r10 =TDX_HYPERCALL_STANDARD , + .r11 =hcall_func (EXIT_REASON_MSR_READ ), + .r12 = regs->cx, + }; + +/* +* Emulate the MSR read via hypercall. More info about ABI +* can be found in TDX Guest-Host-Communication Interface +* (GHCI), section titled "TDG.VP.VMCALL<Instruction.RDMSR>". +*/ +if (__tdx_hypercall (&args,TDX_HCALL_HAS_OUTPUT )) +return false; + + regs->ax =lower_32_bits (args.r11); + regs->dx =upper_32_bits (args.r11); +return true; +} + +static bool write_msr (struct pt_regs *regs) +{ +struct tdx_hypercall_args args = { + .r10 =TDX_HYPERCALL_STANDARD , + .r11 =hcall_func (EXIT_REASON_MSR_WRITE ), + .r12 = regs->cx, + .r13 = (u64 )regs->dx <<32 | regs->ax, + }; + +/* +* Emulate the MSR write via hypercall. More info about ABI +* can be found in TDX Guest-Host-Communication Interface +* (GHCI) section titled "TDG.VP.VMCALL<Instruction.WRMSR>". +*/ +return !__tdx_hypercall (&args,0 ); +} +void tdx_get_ve_info (struct ve_info *ve) {struct tdx_module_output out;
@@ -164,6 +202,10 @@ static bool virt_exception_kernel(struct pt_regs *regs, struct ve_info *ve)switch (ve->exit_reason) {case EXIT_REASON_HLT :return handle_halt (); +case EXIT_REASON_MSR_READ : +return read_msr (regs); +case EXIT_REASON_MSR_WRITE : +return write_msr (regs);default :pr_warn ("Unexpected #VE: %lld\n" , ve->exit_reason);return false;
Signature · 1 line
2.34.1
Re: [PATCHv6 09/30] x86/tdx: Add MSR support for TDX guests
Quoted 7 lines · Kirill A. Shutemov
Co-developed-by Kuppuswamy Sathyanarayanan <[email protected]>Signed-off-by Kuppuswamy Sathyanarayanan <[email protected]>Reviewed-by Andi Kleen <[email protected]>Reviewed-by Tony Luck <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>Reviewed-by Dave Hansen <[email protected]>
PATCH v6 10/30 x86/tdx: Handle CPUID via #VE
In reply to Kirill A. ShutemovIn TDX guests, most CPUID leaf/sub-leaf combinations are virtualized by the TDX module while some trigger #VE.
Implement the #VE handling for EXIT_REASON_CPUID by handing it through the hypercall, which in turn lets the TDX module handle it by invoking the host VMM.
More details on CPUID Virtualization can be found in the TDX module specification, the section titled "CPUID Virtualization".
Note that VMM that handles the hypercall is not trusted. It can return data that may steer the guest kernel in wrong direct. Only allow VMM to control range reserved for hypervisor communication.
Return all-zeros for any CPUID outside the hypervisor range. It matches CPU behaviour for non-supported leaf.
--- arch/x86/coco/tdx/tdx.c | 58 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 57 insertions(+), 1 deletion(-)
arch/x86/coco/tdx/tdx.c +57 -1
@@ -173,6 +173,48 @@ static bool write_msr(struct pt_regs *regs)return !__tdx_hypercall (&args,0 ); } +static bool handle_cpuid (struct pt_regs *regs) +{ +struct tdx_hypercall_args args = { + .r10 =TDX_HYPERCALL_STANDARD , + .r11 =hcall_func (EXIT_REASON_CPUID ), + .r12 = regs->ax, + .r13 = regs->cx, + }; + +/* +* Only allow VMM to control range reserved for hypervisor +* communication. +* +* Return all-zeros for any CPUID outside the range. It matches CPU +* behaviour for non-supported leaf. +*/ +if (regs->ax <0x40000000 || regs->ax >0x4FFFFFFF ) { + regs->ax = regs->bx = regs->cx = regs->dx =0 ; +return true; + } + +/* +* Emulate the CPUID instruction via a hypercall. More info about +* ABI can be found in TDX Guest-Host-Communication Interface +* (GHCI), section titled "VP.VMCALL<Instruction.CPUID>". +*/ +if (__tdx_hypercall (&args,TDX_HCALL_HAS_OUTPUT )) +return false; + +/* +* As per TDX GHCI CPUID ABI, r12-r15 registers contain contents of +* EAX, EBX, ECX, EDX registers after the CPUID instruction execution. +* So copy the register contents back to pt_regs. +*/ + regs->ax = args.r12; + regs->bx = args.r13; + regs->cx = args.r14; + regs->dx = args.r15; + +return true; +} +void tdx_get_ve_info (struct ve_info *ve) {struct tdx_module_output out;
@@ -196,6 +238,18 @@ void tdx_get_ve_info(struct ve_info *ve) ve->instr_info =upper_32_bits (out.r10); } +/* Handle the user initiated #VE */ +static bool virt_exception_user (struct pt_regs *regs,struct ve_info *ve) +{ +switch (ve->exit_reason) { +case EXIT_REASON_CPUID : +return handle_cpuid (regs); +default : +pr_warn ("Unexpected #VE: %lld\n" , ve->exit_reason); +return false; + } +} +/* Handle the kernel #VE */ static bool virt_exception_kernel (struct pt_regs *regs,struct ve_info *ve) {
@@ -206,6 +260,8 @@ static bool virt_exception_kernel(struct pt_regs *regs, struct ve_info *ve)return read_msr (regs);case EXIT_REASON_MSR_WRITE :return write_msr (regs); +case EXIT_REASON_CPUID : +return handle_cpuid (regs);default :pr_warn ("Unexpected #VE: %lld\n" , ve->exit_reason);return false;
@@ -217,7 +273,7 @@ bool tdx_handle_virt_exception(struct pt_regs *regs, struct ve_info *ve)bool ret;if (user_mode (regs)) - ret = false; + ret =virt_exception_user (regs, ve);else ret =virt_exception_kernel (regs, ve);
Signature · 1 line
2.34.1
Re: [PATCHv6 10/30] x86/tdx: Handle CPUID via #VE
Quoted 17 lines · Kirill A. Shutemov
In TDX guests, most CPUID leaf/sub-leaf combinations are virtualized by the TDX module while some trigger #VE.
Implement the #VE handling for
EXIT_REASON_CPUIDby handing it through the hypercall, which in turn lets the TDX module handle it by invoking the host VMM.More details on CPUID Virtualization can be found in the TDX module specification, the section titled "CPUID Virtualization".
Note that VMM that handles the hypercall is not trusted. It can return data that may steer the guest kernel in wrong direct. Only allow VMM to control range reserved for hypervisor communication.
Return all-zeros for any CPUID outside the hypervisor range. It matches CPU behaviour for non-supported leaf.
Quoted 6 lines
Co-developed-by Kuppuswamy Sathyanarayanan <[email protected]>Signed-off-by Kuppuswamy Sathyanarayanan <[email protected]>Reviewed-by Andi Kleen <[email protected]>Reviewed-by Tony Luck <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>Reviewed-by Dave Hansen <[email protected]>
PATCH v6 11/30 x86/tdx: Handle in-kernel MMIO
In reply to Kirill A. ShutemovIn non-TDX VMs, MMIO is implemented by providing the guest a mapping which will cause a VMEXIT on access and then the VMM emulating the instruction that caused the VMEXIT. That's not possible for TDX VM.
To emulate an instruction an emulator needs two things:
- R/W access to the register file to read/modify instruction arguments and see RIP of the faulted instruction.
- Read access to memory where instruction is placed to see what to emulate. In this case it is guest kernel text.
Both of them are not available to VMM in TDX environment:
- Register file is never exposed to VMM. When a TD exits to the module, it saves registers into the state-save area allocated for that TD. The module then scrubs these registers before returning execution control to the VMM, to help prevent leakage of TD state.
- TDX does not allow guests to execute from shared memory. All executed instructions are in TD-private memory. Being private to the TD, VMMs have no way to access TD-private memory and no way to read the instruction to decode and emulate it.
In TDX the MMIO regions are instead configured by VMM to trigger a #VE exception in the guest.
Add #VE handling that emulates the MMIO instruction inside the guest and converts it into a controlled hypercall to the host.
This approach is bad for performance. But, it has (virtually) no impact on the size of the kernel image and will work for a wide variety of drivers. This allows TDX deployments to use arbitrary devices and device drivers, including virtio. TDX customers have asked for the capability to use random devices in their deployments.
In other words, even if all of the work was done to paravirtualize all x86 MMIO users and virtio, this approach would still be needed. There is essentially no way to get rid of this code.
This approach is functional for all in-kernel MMIO users current and future and does so with a minimal amount of code and kernel image bloat.
MMIO addresses can be used with any CPU instruction that accesses memory. Address only MMIO accesses done via io.h helpers, such as 'readl()' or 'writeq()'.
Any CPU instruction that accesses memory can also be used to access MMIO. However, by convention, MMIO access are typically performed via io.h helpers such as 'readl()' or 'writeq()'.
The io.h helpers intentionally use a limited set of instructions when accessing MMIO. This known, limited set of instructions makes MMIO instruction decoding and emulation feasible in KVM hosts and SEV guests today.
MMIO accesses performed without the io.h helpers are at the mercy of the compiler. Compilers can and will generate a much more broad set of instructions which can not practically be decoded and emulated. TDX guests will oops if they encounter one of these decoding failures.
This means that TDX guests *must* use the io.h helpers to access MMIO.
This requirement is not new. Both KVM hosts and AMD SEV guests have the same limitations on MMIO access.
=== Potential alternative approaches ===
== Paravirtualizing all MMIO ==
An alternative to letting MMIO induce a #VE exception is to avoid the #VE in the first place. Similar to the port I/O case, it is theoretically possible to paravirtualize MMIO accesses.
Like the exception-based approach offered here, a fully paravirtualized approach would be limited to MMIO users that leverage common infrastructure like the io.h macros.
However, any paravirtual approach would be patching approximately 120k call sites. Any paravirtual approach would need to replace a bare memory access instruction with (at least) a function call. With a conservative overhead estimation of 5 bytes per call site (CALL instruction), it leads to bloating code by 600k.
Many drivers will never be used in the TDX environment and the bloat cannot be justified.
== Patching TDX drivers ==
Rather than touching the entire kernel, it might also be possible to just go after drivers that use MMIO in TDX guests *and* are performance critical to justify the effrort. Right now, that's limited only to virtio.
All virtio MMIO appears to be done through a single function, which makes virtio eminently easy to patch.
This approach will be adopted in the future, removing the bulk of MMIO #VEs. The #VE-based MMIO will remain serving non-virtio use cases.
--- arch/x86/coco/tdx/tdx.c | 121 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 121 insertions(+)
arch/x86/coco/tdx/tdx.c +121 -0
@@ -8,11 +8,17 @@#include <asm/coco.h> #include <asm/tdx.h> #include <asm/vmx.h> +#include <asm/insn.h> +#include <asm/insn-eval.h> /* TDX module Call Leaf IDs */ #define TDX_GET_INFO 1#define TDX_GET_VEINFO 3 +/* MMIO direction */ +#define EPT_READ 0 +#define EPT_WRITE 1 +/* * Wrapper for standard use of __tdx_hypercall with no output aside from * return code.
@@ -215,6 +221,119 @@ static bool handle_cpuid(struct pt_regs *regs)return true; } +static bool mmio_read (int size,unsigned long addr,unsigned long *val) +{ +struct tdx_hypercall_args args = { + .r10 =TDX_HYPERCALL_STANDARD , + .r11 =hcall_func (EXIT_REASON_EPT_VIOLATION ), + .r12 = size, + .r13 =EPT_READ , + .r14 = addr, + .r15 = *val, + }; + +if (__tdx_hypercall (&args,TDX_HCALL_HAS_OUTPUT )) +return false; + *val = args.r11; +return true; +} + +static bool mmio_write (int size,unsigned long addr,unsigned long val) +{ +return !_tdx_hypercall (hcall_func (EXIT_REASON_EPT_VIOLATION ), size, +EPT_WRITE , addr, val); +} + +static bool handle_mmio (struct pt_regs *regs,struct ve_info *ve) +{ +char buffer[MAX_INSN_SIZE ]; +unsigned long *reg, val; +struct insn insn = {}; +enum mmio_type mmio; +int size, extend_size; +u8 extend_val =0 ; + +/* Only in-kernel MMIO is supported */ +if (WARN_ON_ONCE (user_mode (regs))) +return false; + +if (copy_from_kernel_nofault (buffer, (void *)regs->ip,MAX_INSN_SIZE )) +return false; + +if (insn_decode (&insn, buffer,MAX_INSN_SIZE ,INSN_MODE_64 )) +return false; + + mmio =insn_decode_mmio (&insn, &size); +if (WARN_ON_ONCE (mmio ==MMIO_DECODE_FAILED )) +return false; + +if (mmio !=MMIO_WRITE_IMM && mmio !=MMIO_MOVS ) { + reg =insn_get_modrm_reg_ptr (&insn, regs); +if (!reg) +return false; + } + + ve->instr_len = insn.length; + +/* Handle writes first */ +switch (mmio) { +case MMIO_WRITE : +memcpy (&val, reg, size); +return mmio_write (size, ve->gpa, val); +case MMIO_WRITE_IMM : + val = insn.immediate.value; +return mmio_write (size, ve->gpa, val); +case MMIO_READ : +case MMIO_READ_ZERO_EXTEND : +case MMIO_READ_SIGN_EXTEND : +/* Reads are handled below */ +break ; +case MMIO_MOVS : +case MMIO_DECODE_FAILED : +/* +* MMIO was accessed with an instruction that could not be +* decoded or handled properly. It was likely not using io.h +* helpers or accessed MMIO accidentally. +*/ +return false; +default : +WARN_ONCE (1 ,"Unknown insn_decode_mmio() decode value?" ); +return false; + } + +/* Handle reads */ +if (!mmio_read (size, ve->gpa, &val)) +return false; + +switch (mmio) { +case MMIO_READ : +/* Zero-extend for 32-bit operation */ + extend_size = size ==4 ?sizeof (*reg) :0 ; +break ; +case MMIO_READ_ZERO_EXTEND : +/* Zero extend based on operand size */ + extend_size = insn.opnd_bytes; +break ; +case MMIO_READ_SIGN_EXTEND : +/* Sign extend based on operand size */ + extend_size = insn.opnd_bytes; +if (size ==1 && val &BIT (7 )) + extend_val =0xFF ; +else if (size >1 && val &BIT (15 )) + extend_val =0xFF ; +break ; +default : +/* All other cases has to be covered with the first switch() */ +WARN_ON_ONCE (1 ); +return false; + } + +if (extend_size) +memset (reg, extend_val, extend_size); +memcpy (reg, &val, size); +return true; +} +void tdx_get_ve_info (struct ve_info *ve) {struct tdx_module_output out;
@@ -262,6 +381,8 @@ static bool virt_exception_kernel(struct pt_regs *regs, struct ve_info *ve)return write_msr (regs);case EXIT_REASON_CPUID :return handle_cpuid (regs); +case EXIT_REASON_EPT_VIOLATION : +return handle_mmio (regs, ve);default :pr_warn ("Unexpected #VE: %lld\n" , ve->exit_reason);return false;
Signature · 1 line
2.34.1
Re: [PATCHv6 11/30] x86/tdx: Handle in-kernel MMIO
Quoted 3 lines · Kirill A. Shutemov
In other words, even if all of the work was done to paravirtualize all x86 MMIO users and virtio, this approach would still be needed. There is essentially no way to get rid of this code.
...
Quoted 1 line
== Patching TDX drivers ==
...> This approach will be adopted in the future, removing the bulk of
Quoted 1 line
MMIO #VEs. The #VE-based MMIO will remain serving non-virtio use cases.
I still don't like this very much, but I can't argue with my own logic. :)
BTW, TDX folks... I expect you to, today, start coming up with a comprehensive list of the MMIO-induced #VE's and the reasoning why they should or should not be paravirtualized. You're going to get grumpy maintainers if this is done haphazardly as one-offs when users hit performance issues.
Re: [PATCHv6 11/30] x86/tdx: Handle in-kernel MMIO
Quoted 9 lines · Dave Hansen
Quoted 3 lines · Kirill A. Shutemov
In other words, even if all of the work was done to paravirtualize all x86 MMIO users and virtio, this approach would still be needed. There is essentially no way to get rid of this code.
...
Quoted 1 line
== Patching TDX drivers ==
...> This approach will be adopted in the future, removing the bulk of
Quoted 1 line
MMIO #VEs. The #VE-based MMIO will remain serving non-virtio use cases.
Quoted 7 lines
I still don't like this very much, but I can't argue with my own logic. :)
BTW, TDX folks... I expect you to, today, start coming up with a comprehensive list of the MMIO-induced #VE's and the reasoning why they should or should not be paravirtualized. You're going to get grumpy maintainers if this is done haphazardly as one-offs when users hit performance issues.
Grumpy maintainers? That's a meme. I've never seen that happen. :)
Re: [PATCHv6 11/30] x86/tdx: Handle in-kernel MMIO
In reply to Kirill A. ShutemovQuoted 8 lines · Kirill A. Shutemov
This approach will be adopted in the future, removing the bulk of MMIO #VEs. The #VE-based MMIO will remain serving non-virtio use cases.
Co-developed-by Kuppuswamy Sathyanarayanan <[email protected]>Signed-off-by Kuppuswamy Sathyanarayanan <[email protected]>Reviewed-by Andi Kleen <[email protected]>Reviewed-by Tony Luck <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>
PATCH v6 12/30 x86/tdx: Detect TDX at early kernel decompression time
In reply to Kirill A. ShutemovFrom: Kuppuswamy Sathyanarayanan <[email protected]>
The early decompression code does port I/O for its console output. But, handling the decompression-time port I/O demands a different approach from normal runtime because the IDT required to support #VE based port I/O emulation is not yet set up. Paravirtualizing I/O calls during the decompression step is acceptable because the decompression code doesn't have a lot of call sites to IO instruction.
To support port I/O in decompression code, TDX must be detected before the decompression code might do port I/O. Detect whether the kernel runs in a TDX guest.
Add an early_is_tdx_guest() interface to query the cached TDX guest status in the decompression code.
TDX is detected with CPUID. Make cpuid_count() accessible outside boot/cpuflags.c.
TDX detection in the main kernel is very similar. Move common bits into <asm/shared/tdx.h>.
The actual port I/O paravirtualization will come later in the series.
--- arch/x86/boot/compressed/Makefile | 1 + arch/x86/boot/compressed/misc.c | 8 ++++++++ arch/x86/boot/compressed/misc.h | 2 ++ arch/x86/boot/compressed/tdx.c | 26 ++++++++++++++++++++++++++ arch/x86/boot/compressed/tdx.h | 15 +++++++++++++++ arch/x86/boot/cpuflags.c | 3 +-- arch/x86/boot/cpuflags.h | 1 + arch/x86/include/asm/shared/tdx.h | 8 ++++++++ arch/x86/include/asm/tdx.h | 4 +--- 9 files changed, 63 insertions(+), 5 deletions(-) create mode 100644 arch/x86/boot/compressed/tdx.c create mode 100644 arch/x86/boot/compressed/tdx.h create mode 100644 arch/x86/include/asm/shared/tdx.h
arch/x86/boot/compressed/Makefile +1 -0
@@ -101,6 +101,7 @@ ifdef CONFIG_X86_64 endif vmlinux-objs-$(CONFIG_ACPI) += $(obj)/acpi.o +vmlinux-objs-$(CONFIG_INTEL_TDX_GUEST) += $(obj)/tdx.o vmlinux-objs-$(CONFIG_EFI_MIXED) += $(obj)/efi_thunk_$(BITS).o efi-obj-$(CONFIG_EFI_STUB) = $(objtree)/drivers/firmware/efi/libstub/lib.a
arch/x86/boot/compressed/misc.c +8 -0
@@ -370,6 +370,14 @@ asmlinkage __visible void *extract_kernel(void *rmode, memptr heap, lines = boot_params->screen_info.orig_video_lines; cols = boot_params->screen_info.orig_video_cols; +/* +* Detect TDX guest environment. +* +* It has to be done before console_init() in order to use +* paravirtualized port I/O operations if needed. +*/ +early_tdx_detect (); +console_init ();/*
arch/x86/boot/compressed/misc.h +2 -0
@@ -28,6 +28,8 @@#include <asm/bootparam.h> #include <asm/desc_defs.h> +#include "tdx.h" +#define BOOT_CTYPE_H #include <linux/acpi.h>
arch/x86/boot/compressed/tdx.c new file +26 -0
@@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#include "../cpuflags.h" +#include "../string.h" + +#include <asm/shared/tdx.h> + +static bool tdx_guest_detected; + +bool early_is_tdx_guest (void ) +{ +return tdx_guest_detected; +} + +void early_tdx_detect (void ) +{ +u32 eax, sig[3 ]; + +cpuid_count (TDX_CPUID_LEAF_ID ,0 , &eax, &sig[0 ], &sig[2 ], &sig[1 ]); + +if (memcmp (TDX_IDENT , sig,sizeof (sig))) +return ; + +/* Cache TDX guest feature status */ + tdx_guest_detected = true; +}
arch/x86/boot/compressed/tdx.h new file +15 -0
@@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef BOOT_COMPRESSED_TDX_H +#define BOOT_COMPRESSED_TDX_H + +#include <linux/types.h> + +#ifdef CONFIG_INTEL_TDX_GUEST +void early_tdx_detect (void ); +bool early_is_tdx_guest (void ); +#else +static inline void early_tdx_detect (void ) { }; +static inline bool early_is_tdx_guest (void ) {return false; } +#endif + +#endif /* BOOT_COMPRESSED_TDX_H */
arch/x86/boot/cpuflags.c +1 -2
@@ -71,8 +71,7 @@ int has_eflag(unsigned long mask)# define EBX_REG "=b"#endif -static inline void cpuid_count (u32 id,u32 count, -u32 *a,u32 *b,u32 *c,u32 *d) +void cpuid_count (u32 id,u32 count,u32 *a,u32 *b,u32 *c,u32 *d) { asmvolatile (".ifnc %%ebx,%3 ; movl %%ebx,%3 ; .endif \n\t" "cpuid \n\t"
arch/x86/boot/cpuflags.h +1 -0
@@ -17,5 +17,6 @@ extern u32 cpu_vendor[3];int has_eflag (unsigned long mask);void get_cpuflags (void ); +void cpuid_count (u32 id,u32 count,u32 *a,u32 *b,u32 *c,u32 *d);#endif
arch/x86/include/asm/shared/tdx.h new file +8 -0
@@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_X86_SHARED_TDX_H +#define _ASM_X86_SHARED_TDX_H + +#define TDX_CPUID_LEAF_ID 0x21 +#define TDX_IDENT "IntelTDX " + +#endif /* _ASM_X86_SHARED_TDX_H */
arch/x86/include/asm/tdx.h +1 -3
@@ -6,9 +6,7 @@#include <linux/bits.h> #include <linux/init.h> #include <asm/ptrace.h> - -#define TDX_CPUID_LEAF_ID 0x21 -#define TDX_IDENT "IntelTDX " +#include <asm/shared/tdx.h> #define TDX_HYPERCALL_STANDARD 0
Signature · 1 line
2.34.1
Re: [PATCHv6 12/30] x86/tdx: Detect TDX at early kernel decompression time
arch/x86/boot/compressed/tdx.c line 13
Quoted 9 lines · Kirill A. Shutemov
arch/x86/boot/compressed/tdx.c new file +9
-0+ +#include <asm/shared/tdx.h> + +static bool tdx_guest_detected; + +bool early_is_tdx_guest (void ) +{ +return tdx_guest_detected; +}
Neither tdx_guest_detected nor early_is_tdx_guest() is used anywhere.
Thanks,
tglx
Re: [PATCHv6 12/30] x86/tdx: Detect TDX at early kernel decompression time
Quoted 12 lines · Thomas Gleixner
arch/x86/boot/compressed/tdx.c line 13
Quoted 9 lines · Kirill A. Shutemov
arch/x86/boot/compressed/tdx.c new file +9
-0+ +#include <asm/shared/tdx.h> + +static bool tdx_guest_detected; + +bool early_is_tdx_guest (void ) +{ +return tdx_guest_detected; +}Neither
tdx_guest_detectednorearly_is_tdx_guest()is used anywhere.
Oh. Leftovers. Will drop.
Signature · 1 line
Kirill A. Shutemov
PATCH v6 13/30 x86: Adjust types used in port I/O helpers
In reply to Kirill A. ShutemovChange port I/O helpers to use u8/u16/u32 instead of unsigned char/short/int for values. Use u16 instead of int for port number.
It aligns the helpers with implementation in boot stub in preparation for consolidation.
--- arch/x86/include/asm/io.h | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-)
arch/x86/include/asm/io.h +13 -13
@@ -258,37 +258,37 @@ static inline void slow_down_io(void)#endif #define BUILDIO (bwl, bw, type) \ -static inline void out##bwl(unsigned type value, int port) \ +static inline void out##bwl(type value, u16 port) \ { \ asm volatile("out" #bwl " %" #bw "0, %w1" \ : : "a"(value), "Nd"(port)); \ } \ \ -static inline unsigned type in##bwl(int port) \ +static inline type in##bwl(u16 port) \ { \ - unsigned type value; \ + type value; \ asm volatile("in" #bwl " %w1, %" #bw "0" \ : "=a"(value) : "Nd"(port)); \ return value; \ } \ \ -static inline void out##bwl##_p(unsigned type value, int port) \ +static inline void out##bwl##_p(type value, u16 port) \ { \ out##bwl(value, port); \ slow_down_io(); \ } \ \ -static inline unsigned type in##bwl##_p(int port) \ +static inline type in##bwl##_p(u16 port) \ { \ - unsigned type value = in##bwl(port); \ + type value = in##bwl(port); \ slow_down_io(); \ return value; \ } \ \ -static inline void outs##bwl(int port, const void *addr, unsigned long count) \ +static inline void outs##bwl(u16 port, const void *addr, unsigned long count) \ { \ if (cc_platform_has(CC_ATTR_GUEST_UNROLL_STRING_IO)) { \ - unsigned type *value = (unsigned type *)addr; \ + type *value = (type *)addr; \ while (count) { \ out##bwl(*value, port); \ value++; \
@@ -301,10 +301,10 @@ static inline void outs##bwl(int port, const void *addr, unsigned long count) \ } \ } \ \ -static inline void ins##bwl(int port, void *addr, unsigned long count) \ +static inline void ins##bwl(u16 port, void *addr, unsigned long count) \ { \ if (cc_platform_has(CC_ATTR_GUEST_UNROLL_STRING_IO)) { \ - unsigned type *value = (unsigned type *)addr; \ + type *value = (type *)addr; \ while (count) { \ *value = in##bwl(port); \ value++; \
@@ -317,9 +317,9 @@ static inline void ins##bwl(int port, void *addr, unsigned long count) \ } \ } -BUILDIO(b, b, char) -BUILDIO(w, w, short) -BUILDIO(l, , int) +BUILDIO(b, b, u8) +BUILDIO(w, w, u16) +BUILDIO(l, , u32)#define inb inb#define inw inw
Signature · 1 line
2.34.1
Re: [PATCHv6 13/30] x86: Adjust types used in port I/O helpers
Quoted 8 lines · Kirill A. Shutemov
Change port I/O helpers to use u8/u16/u32 instead of unsigned char/short/int for values. Use u16 instead of int for port number.
It aligns the helpers with implementation in boot stub in preparation for consolidation.
Signed-off-by Kirill A. Shutemov <[email protected]>Reviewed-by Dave Hansen <[email protected]>
PATCH v6 14/30 x86: Consolidate port I/O helpers
In reply to Kirill A. ShutemovThere are two implementations of port I/O helpers: one in the kernel and one in the boot stub.
Move the helpers required for both to <asm/shared/io.h> and use the one implementation everywhere.
--- arch/x86/boot/boot.h | 35 +------------------------------- arch/x86/boot/compressed/misc.h | 2 +- arch/x86/include/asm/io.h | 22 ++------------------ arch/x86/include/asm/shared/io.h | 34 +++++++++++++++++++++++++++++++ 4 files changed, 38 insertions(+), 55 deletions(-) create mode 100644 arch/x86/include/asm/shared/io.h
arch/x86/boot/boot.h +1 -34
@@ -23,6 +23,7 @@#include <linux/edd.h> #include <asm/setup.h> #include <asm/asm.h> +#include <asm/shared/io.h> #include "bitops.h" #include "ctype.h" #include "cpuflags.h"
@@ -35,40 +36,6 @@ extern struct boot_params boot_params;#define cpu_relax () asm volatile("rep; nop") -/* Basic port I/O */ -static inline void outb (u8 v,u16 port) -{ - asmvolatile ("outb %0,%1" : :"a" (v),"dN" (port)); -} -static inline u8 inb (u16 port) -{ -u8 v; - asmvolatile ("inb %1,%0" :"=a" (v) :"dN" (port)); -return v; -} - -static inline void outw (u16 v,u16 port) -{ - asmvolatile ("outw %0,%1" : :"a" (v),"dN" (port)); -} -static inline u16 inw (u16 port) -{ -u16 v; - asmvolatile ("inw %1,%0" :"=a" (v) :"dN" (port)); -return v; -} - -static inline void outl (u32 v,u16 port) -{ - asmvolatile ("outl %0,%1" : :"a" (v),"dN" (port)); -} -static inline u32 inl (u16 port) -{ -u32 v; - asmvolatile ("inl %1,%0" :"=a" (v) :"dN" (port)); -return v; -} -static inline void io_delay (void ) {const u16 DELAY_PORT =0x80 ;
arch/x86/boot/compressed/misc.h +1 -1
@@ -22,11 +22,11 @@#include <linux/linkage.h> #include <linux/screen_info.h> #include <linux/elf.h> -#include <linux/io.h> #include <asm/page.h> #include <asm/boot.h> #include <asm/bootparam.h> #include <asm/desc_defs.h> +#include <asm/shared/io.h> #include "tdx.h"
arch/x86/include/asm/io.h +2 -20
@@ -44,6 +44,7 @@#include <asm/page.h> #include <asm/early_ioremap.h> #include <asm/pgtable_types.h> +#include <asm/shared/io.h> #define build_mmio_read (name, size, type, reg, barrier) \ static inline type name(const volatile void __iomem *addr) \
@@ -258,20 +259,6 @@ static inline void slow_down_io(void)#endif #define BUILDIO (bwl, bw, type) \ -static inline void out##bwl(type value, u16 port) \ -{ \ - asm volatile("out" #bwl " %" #bw "0, %w1" \ - : : "a"(value), "Nd"(port)); \ -} \ - \ -static inline type in##bwl(u16 port) \ -{ \ - type value; \ - asm volatile("in" #bwl " %w1, %" #bw "0" \ - : "=a"(value) : "Nd"(port)); \ - return value; \ -} \ - \ static inline void out##bwl##_p(type value, u16 port) \ { \ out##bwl(value, port); \
@@ -320,10 +307,8 @@ static inline void ins##bwl(u16 port, void *addr, unsigned long count) \ BUILDIO(b, b, u8) BUILDIO(w, w, u16) BUILDIO(l, , u32) +#undef BUILDIO -#define inb inb -#define inw inw -#define inl inl#define inb_p inb_p#define inw_p inw_p#define inl_p inl_p
@@ -331,9 +316,6 @@ BUILDIO(l, , u32)#define insw insw#define insl insl -#define outb outb -#define outw outw -#define outl outl#define outb_p outb_p#define outw_p outw_p#define outl_p outl_p
arch/x86/include/asm/shared/io.h new file +34 -0
@@ -0,0 +1,34 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_X86_SHARED_IO_H +#define _ASM_X86_SHARED_IO_H + +#include <linux/types.h> + +#define BUILDIO (bwl, bw, type) \ +static inline void __out##bwl(type value, u16 port) \ +{ \ + asm volatile("out" #bwl " %" #bw "0, %w1" \ + : : "a"(value), "Nd"(port)); \ +} \ + \ +static inline type __in##bwl(u16 port) \ +{ \ + type value; \ + asm volatile("in" #bwl " %w1, %" #bw "0" \ + : "=a"(value) : "Nd"(port)); \ + return value; \ +} + +BUILDIO(b, b, u8) +BUILDIO(w, w, u16) +BUILDIO(l, , u32) +#undef BUILDIO + +#define inb __inb +#define inw __inw +#define inl __inl +#define outb __outb +#define outw __outw +#define outl __outl + +#endif
Signature · 1 line
2.34.1
PATCH v6 15/30 x86/boot: Port I/O: allow to hook up alternative helpers
In reply to Kirill A. ShutemovPort I/O instructions trigger #VE in the TDX environment. In response to the exception, kernel emulates these instructions using hypercalls.
But during early boot, on the decompression stage, it is cumbersome to deal with #VE. It is cleaner to go to hypercalls directly, bypassing #VE handling.
Add a way to hook up alternative port I/O helpers in the boot stub with a new pio_ops structure. For now, set the ops structure to just call the normal I/O operation functions.
out*()/in*() macros redefined to use pio_ops callbacks. It eliminates need in changing call sites. io_delay() changed to use port I/O helper instead of inline assembly.
--- arch/x86/boot/boot.h | 4 +-- arch/x86/boot/compressed/misc.c | 4 +++ arch/x86/boot/compressed/misc.h | 2 +- arch/x86/boot/io.h | 50 +++++++++++++++++++++++++++++++++ arch/x86/boot/main.c | 4 +++ arch/x86/realmode/rm/wakemain.c | 4 +++ 6 files changed, 65 insertions(+), 3 deletions(-) create mode 100644 arch/x86/boot/io.h
arch/x86/boot/boot.h +2 -2
@@ -23,10 +23,10 @@#include <linux/edd.h> #include <asm/setup.h> #include <asm/asm.h> -#include <asm/shared/io.h> #include "bitops.h" #include "ctype.h" #include "cpuflags.h" +#include "io.h" /* Useful macros */ #define ARRAY_SIZE (x) (sizeof(x) / sizeof(*(x)))
@@ -39,7 +39,7 @@ extern struct boot_params boot_params;static inline void io_delay (void ) {const u16 DELAY_PORT =0x80 ; - asmvolatile ("outb %%al,%0" : :"dN" (DELAY_PORT )); +outb (0 ,DELAY_PORT ); }/* These functions are used to reference data in other segments. */
arch/x86/boot/compressed/misc.c +4 -0
@@ -47,6 +47,8 @@ void *memmove(void *dest, const void *src, size_t n);*/ struct boot_params *boot_params; +struct port_io_ops pio_ops; +memptr free_mem_ptr;memptr free_mem_end_ptr;
@@ -370,6 +372,8 @@ asmlinkage __visible void *extract_kernel(void *rmode, memptr heap, lines = boot_params->screen_info.orig_video_lines; cols = boot_params->screen_info.orig_video_cols; +init_default_io_ops (); +/* * Detect TDX guest environment. *
arch/x86/boot/compressed/misc.h +1 -1
@@ -26,7 +26,6 @@#include <asm/boot.h> #include <asm/bootparam.h> #include <asm/desc_defs.h> -#include <asm/shared/io.h> #include "tdx.h"
@@ -35,6 +34,7 @@#define BOOT_BOOT_H #include "../ctype.h" +#include "../io.h" #ifdef CONFIG_X86_64 #define memptr long
arch/x86/boot/io.h new file +50 -0
50 lines not on this page · raw message
arch/x86/boot/main.c +4 -0
@@ -17,6 +17,8 @@ struct boot_params boot_params __attribute__((aligned(16))); +struct port_io_ops pio_ops; +char *HEAP = _end;char *heap_end = _end;/* Default end of heap = no heap */
@@ -133,6 +135,8 @@ static void init_heap(void)void main (void ) { +init_default_io_ops (); +/* First, copy the boot header into the "zeropage" */ copy_boot_params ();
arch/x86/realmode/rm/wakemain.c +4 -0
@@ -62,8 +62,12 @@ static void send_morse(const char *pattern) } } +struct port_io_ops pio_ops; +void main (void ) { +init_default_io_ops (); +/* Kill machine if structures are wrong */ if (wakeup_header.real_magic !=0x12345678 )while (1 )
Signature · 1 line
2.34.1
Re: [PATCHv6 15/30] x86/boot: Port I/O: allow to hook up alternative helpers
Quoted 14 lines · Kirill A. Shutemov
+++
b/arch/x86/boot/io.harch/x86/boot/io.h new file +12
-0@@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef BOOT_IO_H +#define BOOT_IO_H + +#include <asm/shared/io.h> + +#undef inb +#undef inw +#undef inl +#undef outb +#undef outw +#undef outl
arch/x86/boot/io.h line 22
Quoted 10 lines
arch/x86/boot/io.h new file +10
-0+ +struct port_io_ops { +u8 (*inb)(u16 port); +u16 (*inw)(u16 port); +u32 (*inl)(u16 port); +void (*outb)(u8 v,u16 port); +void (*outw)(u16 v,u16 port); +void (*outl)(u32 v,u16 port); +}; +
This is ugly, but I don't have any better ideas considering all the other review feedback. It's also the boot code, so the ugliness is much more limited in scope.
Re: [PATCHv6 15/30] x86/boot: Port I/O: allow to hook up alternative helpers
In reply to Kirill A. ShutemovQuoted 4 lines · Kirill A. Shutemov
arch/x86/boot/io.h new file +4
-0+#undef inb +#undef inw +#undef inl +#undef outb
arch/x86/boot/io.h line 20
Quoted 10 lines
arch/x86/boot/io.h new file +10
-0+#undef outw +#undef outl + +struct port_io_ops { +u8 (*inb)(u16 port); +u16 (*inw)(u16 port); +u32 (*inl)(u16 port); +void (*outb)(u8 v,u16 port); +void (*outw)(u16 v,u16 port); +void (*outl)(u32 v,u16 port);
u8 (*inb)(u16 port); void (*outb)(u8 v, u16 port); void (*outw)(u16 v, u16 port);
is all what's used AFAICT.
Quoted 7 lines
arch/x86/boot/io.h new file +7
-0+}; + +extern struct port_io_ops pio_ops; + +/* +* Use the normal I/O instructions by default. +* TDX guests override these to use hypercalls.
arch/x86/boot/io.h line 37
Quoted 10 lines
arch/x86/boot/io.h new file +10
-0+*/ +static inline void init_default_io_ops (void ) +{ + pio_ops.inb = __inb; + pio_ops.inw = __inw; + pio_ops.inl = __inl; + pio_ops.outb = __outb; + pio_ops.outw = __outw; + pio_ops.outl = __outl; +}
#define DEFINE_PORT_IO_OPS() \
struct port_io_ops pio_ops = { \
.inb = __inb, \
.outb = __outb, \
.outw = __outw, }Hmm?
Thanks,
tglx
Re: [PATCHv6 15/30] x86/boot: Port I/O: allow to hook up alternative helpers
Quoted 20 lines · Thomas Gleixner
Quoted 4 lines · Kirill A. Shutemov
arch/x86/boot/io.h new file +4
-0+#undef inb +#undef inw +#undef inl +#undef outbarch/x86/boot/io.h line 20
Quoted 10 lines
arch/x86/boot/io.h new file +10
-0+#undef outw +#undef outl + +struct port_io_ops { +u8 (*inb)(u16 port); +u16 (*inw)(u16 port); +u32 (*inl)(u16 port); +void (*outb)(u8 v,u16 port); +void (*outw)(u16 v,u16 port); +void (*outl)(u32 v,u16 port);u8 (*inb)(u16 port); void (*outb)(u8 v, u16 port); void (*outw)(u16 v, u16 port);
Quoted 1 line
is all what's used AFAICT.
Hm. Okay. I will drop the rest.
Quoted 24 lines
Quoted 7 lines
arch/x86/boot/io.h new file +7
-0+}; + +extern struct port_io_ops pio_ops; + +/* +* Use the normal I/O instructions by default. +* TDX guests override these to use hypercalls. arch/x86/boot/io.h line 37
Quoted 10 lines
arch/x86/boot/io.h new file +10
-0+*/ +static inline void init_default_io_ops (void ) +{ + pio_ops.inb = __inb; + pio_ops.inw = __inw; + pio_ops.inl = __inl; + pio_ops.outb = __outb; + pio_ops.outw = __outw; + pio_ops.outl = __outl; +}#define DEFINE_PORT_IO_OPS() \ struct port_io_ops pio_ops = { \ .inb = __inb, \ .outb = __outb, \ .outw = __outw, }
Quoted 1 line
Hmm?
This kind of initializations are problematic. They generate run-time relacations that kernel cannot handle in the boot stub. Linker complains about this:
ld.lld: error: Unexpected run-time relocations (.rela) detected!
I will leave it as is, unless you have better ideas.
Signature · 1 line
Kirill A. Shutemov
Re: [PATCHv6 15/30] x86/boot: Port I/O: allow to hook up alternative helpers
Quoted 8 lines · Kirill A. Shutemov
Quoted 1 line
Hmm?
This kind of initializations are problematic. They generate run-time relacations that kernel cannot handle in the boot stub. Linker complains about this:
ld.lld: error: Unexpected run-time relocations (.rela) detected!
I will leave it as is, unless you have better ideas.
Right now you've got:
#define inb pio_ops.inb
You keep the preprocessor away from things like
foo.inb = bar;
with:
#define inb(x) pio_ops.inb(x)
Re: [PATCHv6 15/30] x86/boot: Port I/O: allow to hook up alternative helpers
Quoted 7 lines · Dave Hansen
You keep the preprocessor away from things like
foo.inb = bar;with:
#define inb(x) pio_ops.inb(x)
... and I spotted my nonsense just as I hit send.
You could do that ^^. But you'd need to rename the 'inb' op like:
struct port_io_ops {
u8 (*f_inb)(u16 port);
...
};so that you do:
#define inb(x) pio_ops.f_inb(x)
But, remember when I said I hate playing #define tricks? ;) This is one reason why.
Re: [PATCHv6 15/30] x86/boot: Port I/O: allow to hook up alternative helpers
Quoted 18 lines · Dave Hansen
Quoted 7 lines · Dave Hansen
You keep the preprocessor away from things like
foo.inb = bar;with:
#define inb(x) pio_ops.inb(x)... and I spotted my nonsense just as I hit send.
You could do that ^^. But you'd need to rename the 'inb' op like:
struct port_io_ops { u8 (*f_inb)(u16 port); ... };
Quoted 6 lines
so that you do:
#define inb(x) pio_ops.f_inb(x)But, remember when I said I hate playing #define tricks? ;) This is one reason why.
But the define tricks are unrelated to the linker issue. The issue pops up after you get past the preprocessor tricks.
Signature · 1 line
Kirill A. Shutemov
Re: [PATCHv6 15/30] x86/boot: Port I/O: allow to hook up alternative helpers
In reply to Kirill A. ShutemovQuoted 9 lines · Kirill A. Shutemov
Quoted 7 lines · Thomas Gleixner
#define DEFINE_PORT_IO_OPS() \ struct port_io_ops pio_ops = { \ .inb = __inb, \ .outb = __outb, \ .outw = __outw, }Hmm?
Quoted 7 lines
This kind of initializations are problematic. They generate run-time relacations that kernel cannot handle in the boot stub. Linker complains about this:
ld.lld: error: Unexpected run-time relocations (.rela) detected!
I will leave it as is, unless you have better ideas.
Bah, did not think about that.
Thanks,
tglx
PATCH v6 16/30 x86/boot: Port I/O: add decompression-time support for TDX
In reply to Kirill A. ShutemovPort I/O instructions trigger #VE in the TDX environment. In response to the exception, kernel emulates these instructions using hypercalls.
But during early boot, on the decompression stage, it is cumbersome to deal with #VE. It is cleaner to go to hypercalls directly, bypassing #VE handling.
Hook up TDX-specific port I/O helpers if booting in TDX environment.
--- arch/x86/boot/compressed/Makefile | 2 +- arch/x86/boot/compressed/tdcall.S | 3 ++ arch/x86/boot/compressed/tdx.c | 79 +++++++++++++++++++++++++++++++ arch/x86/include/asm/shared/tdx.h | 29 ++++++++++++ arch/x86/include/asm/tdx.h | 24 ---------- 5 files changed, 112 insertions(+), 25 deletions(-) create mode 100644 arch/x86/boot/compressed/tdcall.S
arch/x86/boot/compressed/Makefile +1 -1
@@ -101,7 +101,7 @@ ifdef CONFIG_X86_64 endif vmlinux-objs-$(CONFIG_ACPI) += $(obj)/acpi.o -vmlinux-objs-$(CONFIG_INTEL_TDX_GUEST) += $(obj)/tdx.o +vmlinux-objs-$(CONFIG_INTEL_TDX_GUEST) += $(obj)/tdx.o $(obj)/tdcall.o vmlinux-objs-$(CONFIG_EFI_MIXED) += $(obj)/efi_thunk_$(BITS).o efi-obj-$(CONFIG_EFI_STUB) = $(objtree)/drivers/firmware/efi/libstub/lib.a
arch/x86/boot/compressed/tdcall.S new file +3 -0
@@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#include "../../coco/tdx/tdcall.S"
arch/x86/boot/compressed/tdx.c +79 -0
95 lines not on this page · raw message
arch/x86/include/asm/shared/tdx.h +29 -0
@@ -2,7 +2,36 @@#ifndef _ASM_X86_SHARED_TDX_H#define _ASM_X86_SHARED_TDX_H +#include <linux/bits.h> +#include <linux/types.h> + +#define TDX_HYPERCALL_STANDARD 0 + +#define TDX_HCALL_HAS_OUTPUT BIT(0) +#define TDX_HCALL_ISSUE_STI BIT(1) +#define TDX_CPUID_LEAF_ID 0x21#define TDX_IDENT "IntelTDX " +#ifndef __ASSEMBLY__ + +/* +* Used in __tdx_hypercall() to pass down and get back registers' values of +* the TDCALL instruction when requesting services from the VMM. +* +* This is a software only structure and not part of the TDX module/VMM ABI. +*/ +struct tdx_hypercall_args { +u64 r10; +u64 r11; +u64 r12; +u64 r13; +u64 r14; +u64 r15; +}; + +/* Used to request services from the VMM */ +u64 __tdx_hypercall (struct tdx_hypercall_args *args,unsigned long flags); + +#endif /* !__ASSEMBLY__ */ #endif /* _ASM_X86_SHARED_TDX_H */
arch/x86/include/asm/tdx.h +0 -24
@@ -3,16 +3,10 @@#ifndef _ASM_X86_TDX_H#define _ASM_X86_TDX_H -#include <linux/bits.h> #include <linux/init.h> #include <asm/ptrace.h> #include <asm/shared/tdx.h> -#define TDX_HYPERCALL_STANDARD 0 - -#define TDX_HCALL_HAS_OUTPUT BIT(0) -#define TDX_HCALL_ISSUE_STI BIT(1) -/* * SW-defined error codes. *
@@ -40,21 +34,6 @@ struct tdx_module_output {u64 r11; }; -/* -* Used in __tdx_hypercall() to pass down and get back registers' values of -* the TDCALL instruction when requesting services from the VMM. -* -* This is a software only structure and not part of the TDX module/VMM ABI. -*/ -struct tdx_hypercall_args { -u64 r10; -u64 r11; -u64 r12; -u64 r13; -u64 r14; -u64 r15; -}; -/* * Used by the #VE exception handler to gather the #VE exception * info from the TDX module. This is a software only structure
@@ -79,9 +58,6 @@ void __init tdx_early_init(void);u64 __tdx_module_call (u64 fn,u64 rcx,u64 rdx,u64 r8,u64 r9,struct tdx_module_output *out); -/* Used to request services from the VMM */ -u64 __tdx_hypercall (struct tdx_hypercall_args *args,unsigned long flags); -void tdx_get_ve_info (struct ve_info *ve);bool tdx_handle_virt_exception (struct pt_regs *regs,struct ve_info *ve);
Signature · 1 line
2.34.1
Re: [PATCHv6 16/30] x86/boot: Port I/O: add decompression-time support for TDX
arch/x86/boot/compressed/tdx.c void early_tdx_detect(void) · line 99
Quoted 10 lines · Kirill A. Shutemov
void
early_tdx_detect(void)
{arch/x86/boot/compressed/tdx.c +3
-0u32 eax, sig[3 ];@@ -23,4 +94,12 @@ void early_tdx_detect(void)/* Cache TDX guest feature status */ tdx_guest_detected = true; + +/* Use hypercalls instead of I/O instructions */ + inb = tdx_inb;
Eeew. What's wrong with writing this out?
pio_ops.inb = tdx_inb;
So it becomes obvious what this is about?
Thanks,
tglx
Re: [PATCHv6 16/30] x86/boot: Port I/O: add decompression-time support for TDX
Quoted 14 lines · Thomas Gleixner
arch/x86/boot/compressed/tdx.c void early_tdx_detect(void) · line 99
Quoted 10 lines · Kirill A. Shutemov
void
early_tdx_detect(void)
{arch/x86/boot/compressed/tdx.c +3
-0u32 eax, sig[3 ];@@ -23,4 +94,12 @@ void early_tdx_detect(void)/* Cache TDX guest feature status */ tdx_guest_detected = true; + +/* Use hypercalls instead of I/O instructions */ + inb = tdx_inb;Eeew. What's wrong with writing this out?
Quoted 3 lines
pio_ops.inb = tdx_inb;So it becomes obvious what this is about?
This leads to preprocessor hell: "pio_ops.inb" is expanded to "pio_ops.pio_ops.inb" :/
I can rename fields in struct port_io_ops to avoid conflicts, I donno.
Signature · 1 line
Kirill A. Shutemov
Re: [PATCHv6 16/30] x86/boot: Port I/O: add decompression-time support for TDX
Quoted 15 lines · Kirill A. Shutemov
Quoted 14 lines · Thomas Gleixner
arch/x86/boot/compressed/tdx.c void early_tdx_detect(void) · line 99
Quoted 10 lines · Kirill A. Shutemov
void
early_tdx_detect(void)
{arch/x86/boot/compressed/tdx.c +3
-0u32 eax, sig[3 ];@@ -23,4 +94,12 @@ void early_tdx_detect(void)/* Cache TDX guest feature status */ tdx_guest_detected = true; + +/* Use hypercalls instead of I/O instructions */ + inb = tdx_inb;Eeew. What's wrong with writing this out?
Quoted 8 lines
Quoted 3 lines
pio_ops.inb = tdx_inb;So it becomes obvious what this is about?
This leads to preprocessor hell: "pio_ops.inb" is expanded to "pio_ops.pio_ops.inb" :/
I can rename fields in struct
port_io_opsto avoid conflicts, I donno.
Yes, please rename them.
Thanks,
tglx
Re: [PATCHv6 16/30] x86/boot: Port I/O: add decompression-time support for TDX
Quoted 18 lines · Thomas Gleixner
Quoted 17 lines · Kirill A. Shutemov
Quoted 16 lines · Thomas Gleixner
arch/x86/boot/compressed/tdx.c void early_tdx_detect(void) · line 99
Quoted 10 lines · Kirill A. Shutemov
void
early_tdx_detect(void)
{arch/x86/boot/compressed/tdx.c +3
-0u32 eax, sig[3 ];@@ -23,4 +94,12 @@ void early_tdx_detect(void)/* Cache TDX guest feature status */ tdx_guest_detected = true; + +/* Use hypercalls instead of I/O instructions */ + inb = tdx_inb;Eeew. What's wrong with writing this out?
pio_ops.inb = tdx_inb;
Quoted 8 lines
Quoted 6 lines
Quoted 1 line
So it becomes obvious what this is about?
This leads to preprocessor hell: "pio_ops.inb" is expanded to "pio_ops.pio_ops.inb" :/
I can rename fields in struct
port_io_opsto avoid conflicts, I donno.Yes, please rename them.
Oops, I've sent v7, before I read the reply. I will sent updates to relevant patches.
Signature · 1 line
Kirill A. Shutemov
PATCH v6 17/30 x86/tdx: Port I/O: add runtime hypercalls
In reply to Kirill A. ShutemovFrom: Kuppuswamy Sathyanarayanan <[email protected]>
TDX hypervisors cannot emulate instructions directly. This includes port I/O which is normally emulated in the hypervisor. All port I/O instructions inside TDX trigger the #VE exception in the guest and would be normally emulated there.
Use a hypercall to emulate port I/O. Extend the tdx_handle_virt_exception() and add support to handle the #VE due to port I/O instructions.
String I/O operations are not supported in TDX. Unroll them by declaring CC_ATTR_GUEST_UNROLL_STRING_IO confidential computing attribute.
== Userspace Implications ==
The ioperm() facility allows userspace access to I/O instructions like inb/outb. Among other things, this allows writing userspace device drivers.
This series has no special handling for ioperm(). Users will be able to successfully request I/O permissions but will induce a #VE on their first I/O instruction which leads SIGSEGV. If this is undesirable users can enable kernel lockdown feature with 'lockdown=integrity' kernel command line option. It makes ioperm() fail.
More robust handling of this situation (denying ioperm() in all TDX guests) will be addressed in follow-on work.
--- arch/x86/coco/core.c | 7 +++- arch/x86/coco/tdx/tdx.c | 79 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 85 insertions(+), 1 deletion(-)
arch/x86/coco/core.c +6 -1
@@ -18,7 +18,12 @@ static u64 cc_mask __ro_after_init;static bool intel_cc_platform_has (enum cc_attr attr) { -return false; +switch (attr) { +case CC_ATTR_GUEST_UNROLL_STRING_IO : +return true; +default : +return false; + } }/*
arch/x86/coco/tdx/tdx.c +79 -0
97 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCHv6 17/30] x86/tdx: Port I/O: add runtime hypercalls
arch/x86/coco/tdx/tdx.c static bool handle_mmio(struct pt_regs *regs, struct ve_info *ve) · line 357
Quoted 11 lines · Kirill A. Shutemov
arch/x86/coco/tdx/tdx.c +11
-0+static bool handle_in (struct pt_regs *regs,int size,int port) +{ +struct tdx_hypercall_args args = { + .r10 =TDX_HYPERCALL_STANDARD , + .r11 =hcall_func (EXIT_REASON_IO_INSTRUCTION ), + .r12 = size, + .r13 =PORT_READ , + .r14 = port, + }; +bool success; +u64 mask =GENMASK (BITS_PER_BYTE * size,0 );
Reverse fir tree ordering please:
u64 mask = GENMASK(BITS_PER_BYTE * size, 0); bool success;
arch/x86/coco/tdx/tdx.c static bool handle_mmio(struct pt_regs *regs, struct ve_info *ve) · line 398
Quoted 12 lines
arch/x86/coco/tdx/tdx.c +12
-0+/* +* Emulate I/O using hypercall. +* +* Assumes the IO instruction was using ax, which is enforced +* by the standard io.h macros. +* +* Return True on success or False on failure. +*/ +static bool handle_io (struct pt_regs *regs,u32 exit_qual) +{ +bool in; +int size, port;
Ditto.
Other than that:
PATCH v6 18/30 x86/tdx: Port I/O: add early boot support
In reply to Kirill A. ShutemovFrom: Andi Kleen <[email protected]>
TDX guests cannot do port I/O directly. The TDX module triggers a #VE exception to let the guest kernel emulate port I/O by converting them into TDCALLs to call the host.
But before IDT handlers are set up, port I/O cannot be emulated using normal kernel #VE handlers. To support the #VE-based emulation during this boot window, add a minimal early #VE handler support in early exception handlers. This is similar to what AMD SEV does. This is mainly to support earlyprintk's serial driver, as well as potentially the VGA driver.
The early handler only supports I/O-related #VE exceptions. Unhandled or failed exceptions will be handled via early_fixup_exceptions() (like normal exception failures). At runtime I/O-related #VE exceptions (along with other types) handled by virt_exception_kernel().
--- arch/x86/coco/tdx/tdx.c | 16 ++++++++++++++++ arch/x86/include/asm/tdx.h | 4 ++++ arch/x86/kernel/head64.c | 3 +++ 3 files changed, 23 insertions(+)
arch/x86/coco/tdx/tdx.c +16 -0
@@ -411,6 +411,22 @@ static bool handle_io(struct pt_regs *regs, u32 exit_qual)return handle_out (regs, size, port); } +/* +* Early #VE exception handler. Only handles a subset of port I/O. +* Intended only for earlyprintk. If failed, return false. +*/ +__init bool tdx_early_handle_ve (struct pt_regs *regs) +{ +struct ve_info ve; + +tdx_get_ve_info (&ve); + +if (ve.exit_reason !=EXIT_REASON_IO_INSTRUCTION ) +return false; + +return handle_io (regs, ve.exit_qual); +} +void tdx_get_ve_info (struct ve_info *ve) {struct tdx_module_output out;
arch/x86/include/asm/tdx.h +4 -0
@@ -64,11 +64,15 @@ bool tdx_handle_virt_exception(struct pt_regs *regs, struct ve_info *ve);void tdx_safe_halt (void ); +bool tdx_early_handle_ve (struct pt_regs *regs); +#else static inline void tdx_early_init (void ) { };static inline void tdx_safe_halt (void ) { }; +static inline bool tdx_early_handle_ve (struct pt_regs *regs) {return false; } +#endif /* CONFIG_INTEL_TDX_GUEST */ #endif /* !__ASSEMBLY__ */
arch/x86/kernel/head64.c +3 -0
@@ -417,6 +417,9 @@ void __init do_early_exception(struct pt_regs *regs, int trapnr) trapnr == X86_TRAP_VC && handle_vc_boot_ghcb(regs)) return; +if (trapnr ==X86_TRAP_VE &&tdx_early_handle_ve (regs)) +return ; +early_fixup_exception (regs, trapnr); }
Signature · 1 line
2.34.1
PATCH v6 19/30 x86/tdx: Wire up KVM hypercalls
In reply to Kirill A. ShutemovFrom: Kuppuswamy Sathyanarayanan <[email protected]>
KVM hypercalls use the VMCALL or VMMCALL instructions. Although the ABI is similar, those instructions no longer function for TDX guests.
Make vendor-specific TDVMCALLs instead of VMCALL. This enables TDX guests to run with KVM acting as the hypervisor.
Among other things, KVM hypercall is used to send IPIs.
Since the KVM driver can be built as a kernel module, export tdx_kvm_hypercall() to make the symbols visible to kvm.ko.
--- arch/x86/coco/tdx/tdx.c | 17 +++++++++++++++++ arch/x86/include/asm/kvm_para.h | 22 ++++++++++++++++++++++ arch/x86/include/asm/tdx.h | 11 +++++++++++ 3 files changed, 50 insertions(+)
arch/x86/coco/tdx/tdx.c +17 -0
@@ -64,6 +64,23 @@ static u64 hcall_func(u64 exit_reason)return exit_reason; } +#ifdef CONFIG_KVM_GUEST +long tdx_kvm_hypercall (unsigned int nr,unsigned long p1,unsigned long p2, +unsigned long p3,unsigned long p4) +{ +struct tdx_hypercall_args args = { + .r10 = nr, + .r11 = p1, + .r12 = p2, + .r13 = p3, + .r14 = p4, + }; + +return __tdx_hypercall (&args,0 ); +} +EXPORT_SYMBOL_GPL (tdx_kvm_hypercall); +#endif +/* * Used for TDX guests to make calls directly to the TD module. This * should only be used for calls that have no legitimate reason to fail
arch/x86/include/asm/kvm_para.h +22 -0
@@ -7,6 +7,8 @@#include <linux/interrupt.h> #include <uapi/asm/kvm_para.h> +#include <asm/tdx.h> +#ifdef CONFIG_KVM_GUEST bool kvm_check_and_clear_guest_paused (void );#else
@@ -32,6 +34,10 @@ static inline bool kvm_check_and_clear_guest_paused(void)static inline long kvm_hypercall0 (unsigned int nr) {long ret; + +if (cpu_feature_enabled (X86_FEATURE_TDX_GUEST )) +return tdx_kvm_hypercall (nr,0 ,0 ,0 ,0 ); + asm volatile(KVM_HYPERCALL : "=a"(ret) : "a"(nr)
@@ -42,6 +48,10 @@ static inline long kvm_hypercall0(unsigned int nr)static inline long kvm_hypercall1 (unsigned int nr,unsigned long p1) {long ret; + +if (cpu_feature_enabled (X86_FEATURE_TDX_GUEST )) +return tdx_kvm_hypercall (nr, p1,0 ,0 ,0 ); + asm volatile(KVM_HYPERCALL : "=a"(ret) : "a"(nr), "b"(p1)
@@ -53,6 +63,10 @@ static inline long kvm_hypercall2(unsigned int nr, unsigned long p1, unsigned long p2) {long ret; + +if (cpu_feature_enabled (X86_FEATURE_TDX_GUEST )) +return tdx_kvm_hypercall (nr, p1, p2,0 ,0 ); + asm volatile(KVM_HYPERCALL : "=a"(ret) : "a"(nr), "b"(p1), "c"(p2)
@@ -64,6 +78,10 @@ static inline long kvm_hypercall3(unsigned int nr, unsigned long p1, unsigned long p2, unsigned long p3) { long ret; + +if (cpu_feature_enabled (X86_FEATURE_TDX_GUEST )) +return tdx_kvm_hypercall (nr, p1, p2, p3,0 ); + asm volatile(KVM_HYPERCALL : "=a"(ret) : "a"(nr), "b"(p1), "c"(p2), "d"(p3)
@@ -76,6 +94,10 @@ static inline long kvm_hypercall4(unsigned int nr, unsigned long p1, unsigned long p4) {long ret; + +if (cpu_feature_enabled (X86_FEATURE_TDX_GUEST )) +return tdx_kvm_hypercall (nr, p1, p2, p3, p4); + asm volatile(KVM_HYPERCALL : "=a"(ret) : "a"(nr), "b"(p1), "c"(p2), "d"(p3), "S"(p4)
arch/x86/include/asm/tdx.h +11 -0
@@ -75,5 +75,16 @@ static inline bool tdx_early_handle_ve(struct pt_regs *regs) { return false; }#endif /* CONFIG_INTEL_TDX_GUEST */ +#if defined(CONFIG_KVM_GUEST ) && defined(CONFIG_INTEL_TDX_GUEST ) +long tdx_kvm_hypercall (unsigned int nr,unsigned long p1,unsigned long p2, +unsigned long p3,unsigned long p4); +#else +static inline long tdx_kvm_hypercall (unsigned int nr,unsigned long p1, +unsigned long p2,unsigned long p3, +unsigned long p4) +{ +return -ENODEV ; +} +#endif /* CONFIG_INTEL_TDX_GUEST && CONFIG_KVM_GUEST */ #endif /* !__ASSEMBLY__ */ #endif /* _ASM_X86_TDX_H */
Signature · 1 line
2.34.1
PATCH v6 20/30 x86/boot: Add a trampoline for booting APs via firmware handoff
In reply to Kirill A. ShutemovFrom: Sean Christopherson <[email protected]>
Historically, x86 platforms have booted secondary processors (APs) using INIT followed by the start up IPI (SIPI) messages. In regular VMs, this boot sequence is supported by the VMM emulation. But such a wakeup model is fatal for secure VMs like TDX in which VMM is an untrusted entity. To address this issue, a new wakeup model was added in ACPI v6.4, in which firmware (like TDX virtual BIOS) will help boot the APs. More details about this wakeup model can be found in ACPI specification v6.4, the section titled "Multiprocessor Wakeup Structure".
Since the existing trampoline code requires processors to boot in real mode with 16-bit addressing, it will not work for this wakeup model (because it boots the AP in 64-bit mode). To handle it, extend the trampoline code to support 64-bit mode firmware handoff. Also, extend IDT and GDT pointers to support 64-bit mode hand off.
There is no TDX-specific detection for this new boot method. The kernel will rely on it as the sole boot method whenever the new ACPI structure is present.
The ACPI table parser for the MADT multiprocessor wake up structure and the wakeup method that uses this structure will be added by the following patch in this series.
--- arch/x86/include/asm/apic.h | 2 ++ arch/x86/include/asm/realmode.h | 1 + arch/x86/kernel/smpboot.c | 12 ++++++-- arch/x86/realmode/rm/header.S | 1 + arch/x86/realmode/rm/trampoline_64.S | 38 ++++++++++++++++++++++++ arch/x86/realmode/rm/trampoline_common.S | 12 +++++++- 6 files changed, 63 insertions(+), 3 deletions(-)
arch/x86/include/asm/apic.h +2 -0
@@ -328,6 +328,8 @@ struct apic {/* wakeup_secondary_cpu */ int (*wakeup_secondary_cpu)(int apicid,unsigned long start_eip); +/* wakeup secondary CPU using 64-bit wakeup point */ +int (*wakeup_secondary_cpu_64)(int apicid,unsigned long start_eip);void (*inquire_remote_apic)(int apicid);
arch/x86/include/asm/realmode.h +1 -0
@@ -25,6 +25,7 @@ struct real_mode_header {u32 sev_es_trampoline_start;#endif #ifdef CONFIG_X86_64 +u32 trampoline_start64;u32 trampoline_pgd;#endif /* ACPI S3 wakeup */
arch/x86/kernel/smpboot.c +10 -2
@@ -1088,6 +1088,11 @@ static int do_boot_cpu(int apicid, int cpu, struct task_struct *idle,unsigned long boot_error =0 ;unsigned long timeout; +#ifdef CONFIG_X86_64 +/* If 64-bit wakeup method exists, use the 64-bit mode trampoline IP */ +if (apic->wakeup_secondary_cpu_64) + start_ip = real_mode_header->trampoline_start64; +#endif idle->thread.sp = (unsigned long )task_pt_regs (idle); early_gdt_descr.address = (unsigned long )get_cpu_gdt_rw (cpu); initial_code = (unsigned long )start_secondary;
@@ -1129,11 +1134,14 @@ static int do_boot_cpu(int apicid, int cpu, struct task_struct *idle,/* * Wake up a CPU in difference cases: -* - Use the method in the APIC driver if it's defined +* - Use a method from the APIC driver if one defined, with wakeup +* straight to 64-bit mode preferred over wakeup to RM. * Otherwise, * - Use an INIT boot APIC message for APs or NMI for BSP. */ -if (apic->wakeup_secondary_cpu) +if (apic->wakeup_secondary_cpu_64) + boot_error = apic->wakeup_secondary_cpu_64 (apicid, start_ip); +else if (apic->wakeup_secondary_cpu) boot_error = apic->wakeup_secondary_cpu (apicid, start_ip);else boot_error = wakeup_cpu_via_init_nmi(cpu, start_ip, apicid,
arch/x86/realmode/rm/header.S +1 -0
@@ -24,6 +24,7 @@ SYM_DATA_START(real_mode_header) .long pa_sev_es_trampoline_start #endif #ifdef CONFIG_X86_64 + .long pa_trampoline_start64 .long pa_trampoline_pgd; #endif /* ACPI S3 wakeup */
arch/x86/realmode/rm/trampoline_64.S +38 -0
@@ -161,6 +161,19 @@ SYM_CODE_START(startup_32) ljmpl $__KERNEL_CS, $pa_startup_64 SYM_CODE_END(startup_32) +SYM_CODE_START(pa_trampoline_compat) + /* + * In compatibility mode. Prep ESP and DX for startup_32, then disable + * paging and complete the switch to legacy 32-bit mode. + */ + movl $rm_stack_end, %esp + movw $__KERNEL_DS, %dx + + movl $X86_CR0_PE, %eax + movl %eax, %cr0 + ljmpl $__KERNEL32_CS, $pa_startup_32 +SYM_CODE_END(pa_trampoline_compat) + .section ".text64","ax" .code64 .balign 4
@@ -169,6 +182,20 @@ SYM_CODE_START(startup_64) jmpq *tr_start(%rip) SYM_CODE_END(startup_64) +SYM_CODE_START(trampoline_start64) + /* + * APs start here on a direct transfer from 64-bit BIOS with identity + * mapped page tables. Load the kernel's GDT in order to gear down to + * 32-bit mode (to handle 4-level vs. 5-level paging), and to (re)load + * segment registers. Load the zero IDT so any fault triggers a + * shutdown instead of jumping back into BIOS. + */ + lidt tr_idt(%rip) + lgdt tr_gdt64(%rip) + + ljmpl *tr_compat(%rip) +SYM_CODE_END(trampoline_start64) + .section ".rodata","a" # Duplicate the global descriptor table # so the kernel can live anywhere
@@ -182,6 +209,17 @@ SYM_DATA_START(tr_gdt) .quad 0x00cf93000000ffff # __KERNEL_DS SYM_DATA_END_LABEL(tr_gdt, SYM_L_LOCAL, tr_gdt_end) +SYM_DATA_START(tr_gdt64) + .short tr_gdt_end - tr_gdt - 1 # gdt limit + .long pa_tr_gdt + .long 0 +SYM_DATA_END(tr_gdt64) + +SYM_DATA_START(tr_compat) + .long pa_trampoline_compat + .short __KERNEL32_CS +SYM_DATA_END(tr_compat) + .bss .balign PAGE_SIZE SYM_DATA(trampoline_pgd, .space PAGE_SIZE)
arch/x86/realmode/rm/trampoline_common.S +11 -1
@@ -1,4 +1,14 @@ /* SPDX-License-Identifier: GPL-2.0 */ .section ".rodata","a" .balign 16 -SYM_DATA_LOCAL(tr_idt, .fill 1, 6, 0) + +/* + * When a bootloader hands off to the kernel in 32-bit mode an + * IDT with a 2-byte limit and 4-byte base is needed. When a boot + * loader hands off to a kernel 64-bit mode the base address + * extends to 8-bytes. Reserve enough space for either scenario. + */ +SYM_DATA_START_LOCAL(tr_idt) + .short 0 + .quad 0 +SYM_DATA_END(tr_idt)
Signature · 1 line
2.34.1
Re: [PATCHv6 20/30] x86/boot: Add a trampoline for booting APs via firmware handoff
Quoted 8 lines · Kirill A. Shutemov
There is no TDX-specific detection for this new boot method. The kernel will rely on it as the sole boot method whenever the new ACPI structure is present.
The ACPI table parser for the MADT multiprocessor wake up structure and the wakeup method that uses this structure will be added by the following patch in this series.
Quoted 5 lines
Signed-off-by Sean Christopherson <[email protected]>Reviewed-by Andi Kleen <[email protected]>Reviewed-by Dan Williams <[email protected]>Signed-off-by Kuppuswamy Sathyanarayanan <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>
Boris Petkov
maintainerRe: [PATCHv6 20/30] x86/boot: Add a trampoline for booting APs via firmware handoff
In reply to Kirill A. ShutemovQuoted 18 lines · Kirill A. Shutemov
arch/x86/include/asm/apic.h +2
-0@@ -328,6 +328,8 @@ struct apic {/* wakeup_secondary_cpu */ int (*wakeup_secondary_cpu)(int apicid,unsigned long start_eip); +/* wakeup secondary CPU using 64-bit wakeup point */ +int (*wakeup_secondary_cpu_64)(int apicid,unsigned long start_eip);void (*inquire_remote_apic)(int apicid);arch/x86/include/asm/realmode.h +0
-0
arch/x86/include/asm/realmode.h struct real_mode_header { · line 28
Quoted 4 lines
arch/x86/include/asm/realmode.h +1
-0@@ -25,6 +25,7 @@ struct real_mode_header {u32 sev_es_trampoline_start;#endif #ifdef CONFIG_X86_64 +u32 trampoline_start64;
I had already asked about those here: why do you need to add a new u32 here and can't use trampoline_start?
Ditto for the new function pointer too.
And yes, sev_es_trampoline_start is superfluous too.
Signature · 1 line
Sent from a small device: formatting sux and brevity is inevitable.
Re: [PATCHv6 20/30] x86/boot: Add a trampoline for booting APs via firmware handoff
Quoted 26 lines · Boris Petkov
Quoted 18 lines · Kirill A. Shutemov
arch/x86/include/asm/apic.h +2
-0@@ -328,6 +328,8 @@ struct apic {/* wakeup_secondary_cpu */ int (*wakeup_secondary_cpu)(int apicid,unsigned long start_eip); +/* wakeup secondary CPU using 64-bit wakeup point */ +int (*wakeup_secondary_cpu_64)(int apicid,unsigned long start_eip);void (*inquire_remote_apic)(int apicid);arch/x86/include/asm/realmode.h +0
-0arch/x86/include/asm/realmode.h struct real_mode_header { · line 28
Quoted 4 lines
arch/x86/include/asm/realmode.h +1
-0@@ -25,6 +25,7 @@ struct real_mode_header {u32 sev_es_trampoline_start;#endif #ifdef CONFIG_X86_64 +u32 trampoline_start64;I had already asked about those here: why do you need to add a new u32 here and can't use
trampoline_start?
Quoted 3 lines
Ditto for the new function pointer too.
And yes,
sev_es_trampoline_startis superfluous too.
As I said[1], I'm confused by the request. These field initialized at build time. I don't see how a single field would work.
[1] https://lore.kernel.org/all/[email protected]/
Signature · 1 line
Kirill A. Shutemov
Borislav Petkov
maintainerRe: [PATCHv6 20/30] x86/boot: Add a trampoline for booting APs via firmware handoff
Quoted 1 line · Kirill A. Shutemov
As I said[1],
Whoops, I've missed that in the mail flood, sorry.
Quoted 2 lines
I'm confused by the request. These field initialized at build time. I don't see how a single field would work.
So I did take a deeper look last night, trying to see whether the SEV one - sev_es_trampoline_start - could be assigned at build time already to pa_trampoline_start so that it is already in the header.
However, you need to have this info available dynamically, during boot also, so that you can prepare the AP jump table for SEV guests, see sev_es_setup_ap_jump_table().
Which means, I need a way of communicating the sev_es_trampoline_start physical address to kernel proper *but*, *also*, I need to not touch the default trampoline_start for normal booting. And this header is that communicating.
So yeah, I kinda convinced myself that we cannot assign the proper trampoline_start at boot time - which we can do with trickery to modify that arch/x86/realmode/rm/pasyms.h generated addition to the linker script. We need to be able to assign it at *boot* time so we need both addresses.
Oh well, forget what I said initially.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquettePATCH v6 21/30 x86/acpi, x86/boot: Add multiprocessor wake-up support
In reply to Kirill A. ShutemovFrom: Kuppuswamy Sathyanarayanan <[email protected]>
TDX cannot use INIT/SIPI protocol to bring up secondary CPUs because it requires assistance from untrusted VMM.
For platforms that do not support SIPI/INIT, ACPI defines a wakeup model (using mailbox) via MADT multiprocessor wakeup structure. More details about it can be found in ACPI specification v6.4, the section titled "Multiprocessor Wakeup Structure". If a platform firmware produces the multiprocessor wakeup structure, then OS may use this new mailbox-based mechanism to wake up the APs.
Add ACPI MADT wake structure parsing support for x86 platform and if MADT wake table is present, update apic->wakeup_secondary_cpu_64 with new API which uses MADT wake mailbox to wake-up CPU.
--- arch/x86/include/asm/apic.h | 5 ++ arch/x86/kernel/acpi/boot.c | 118 ++++++++++++++++++++++++++++++++++++ arch/x86/kernel/apic/apic.c | 10 +++ 3 files changed, 133 insertions(+)
arch/x86/include/asm/apic.h +5 -0
@@ -490,6 +490,11 @@ static inline unsigned int read_apic_id(void)return apic->get_apic_id (reg); } +#ifdef CONFIG_X86_64 +typedef int (*wakeup_cpu_handler )(int apicid,unsigned long start_eip); +extern void acpi_wake_cpu_handler_update (wakeup_cpu_handler handler); +#endif +extern int default_apic_id_valid (u32 apicid);extern int default_acpi_madt_oem_check (char *,char *);extern void default_setup_apic_routing (void );
arch/x86/kernel/acpi/boot.c +118 -0
142 lines not on this page · raw message
arch/x86/kernel/apic/apic.c +10 -0
@@ -2551,6 +2551,16 @@ u32 x86_msi_msg_get_destid(struct msi_msg *msg, bool extid) }EXPORT_SYMBOL_GPL (x86_msi_msg_get_destid); +#ifdef CONFIG_X86_64 +void __init acpi_wake_cpu_handler_update (wakeup_cpu_handler handler) +{ +struct apic **drv; + +for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) + (*drv)->wakeup_secondary_cpu_64 = handler; +} +#endif +/* * Override the generic EOI implementation with an optimized version. * Only called during early boot when only one CPU is active and with
Signature · 1 line
2.34.1
Re: [PATCHv6 21/30] x86/acpi, x86/boot: Add multiprocessor wake-up support
arch/x86/kernel/acpi/boot.c acpi_parse_lapic_nmi(union acpi_subtable_headers * header, const unsigned long e · line 384
Quoted 4 lines · Kirill A. Shutemov
arch/x86/kernel/acpi/boot.c +4
-0+* The value of apic_id and wakeup_vector has to be set before updating +* the wakeup command. To let compiler preserve order of writes, use +* smp_store_release. +*/
Yeah, but that's not what's written:
arch/x86/kernel/acpi/boot.c acpi_parse_lapic_nmi(union acpi_subtable_headers * header, const unsigned long e · line 388
Quoted 4 lines
arch/x86/kernel/acpi/boot.c +4
-0+smp_store_release (&acpi_mp_wake_mailbox->apic_id, apicid); +smp_store_release (&acpi_mp_wake_mailbox->wakeup_vector, start_ip); +smp_store_release (&acpi_mp_wake_mailbox->command, +ACPI_MP_WAKE_COMMAND_WAKEUP );
That says that the write to ->apic_id has to happen before the write to ->wakeup_vector which has to happen before the write to ->command. What you have here *works*, but it doesn't match the comment.
If the problem were the compiler alone, I think three WRITE_ONCE()'s would also suffice. (Hint: WRITE_ONCE() is insufficient).
I _think_ this will do:
acpi_mp_wake_mailbox->apic_id = apicid; acpi_mp_wake_mailbox->wakeup_vector = start_ip; smp_wmb(); WRITE_ONCE(acpi_mp_wake_mailbox->command, ACPI_MP_WAKE_CO...);
But it's the end of the day and I'm sending this out under duress, so please double-check my logic.
Also, in all practicality, the WRITE_ONCE() isn't going to do much. ->command is 2 bytes and even the stupidest compiler isn't going to break that up. The compiler also fundamentally understands the ordering between this ->command write and the below:
READ_ONCE(acpi_mp_wake_mailbox->command).
The READ_ONCE() will also ensure that *it* goes out to memory. *But*, the WRITE_ONCE() does make it very clear what is supposed to happen.
Re: [PATCHv6 21/30] x86/acpi, x86/boot: Add multiprocessor wake-up support
In reply to Kirill A. Shutemovarch/x86/kernel/acpi/boot.c acpi_parse_lapic_nmi(union acpi_subtable_headers * header, const unsigned long e · line 356
Quoted 9 lines · Kirill A. Shutemov
arch/x86/kernel/acpi/boot.c +9
-0+#ifdef CONFIG_X86_64 +/* Virtual address of the Multiprocessor Wakeup Structure mailbox */ +static int acpi_wakeup_cpu (int apicid,unsigned long start_ip) +{ +static physid_mask_t apic_id_wakemap =PHYSID_MASK_NONE ; +u8 timeout; + +/* Remap mailbox memory only for the first call to acpi_wakeup_cpu() */ +if (physids_empty (apic_id_wakemap)) {
I had to read this condition twice.
Why not checking (!acpi_mp_wake_mailbox)? Too obvious, right?
Quoted 8 lines
arch/x86/kernel/acpi/boot.c +8
-0+ acpi_mp_wake_mailbox =memremap (acpi_mp_wake_mailbox_paddr, +sizeof (*acpi_mp_wake_mailbox), +MEMREMAP_WB ); + } + +/* +* According to the ACPI specification r6.4, section titled +* "Multiprocessor Wakeup Structure" the mailbox-based wakeup
arch/x86/kernel/acpi/boot.c acpi_parse_lapic_nmi(union acpi_subtable_headers * header, const unsigned long e · line 374
Quoted 10 lines
arch/x86/kernel/acpi/boot.c +10
-0+* mechanism cannot be used more than once for the same CPU. +* Skip wakeups if they are attempted more than once. +*/ +if (physid_isset (apicid, apic_id_wakemap)) { +pr_err ("CPU already awake (APIC ID %x), skipping wakeup\n" , + apicid); +return -EINVAL ; + } + +spin_lock (&mailbox_lock);
What is this lock actually protecting? Wakeup of secondary CPUs is fully serialized in the core code already.
Thanks,
tglx
PATCH v6 22/30 x86/boot: Set CR0.NE early and keep it set during the boot
In reply to Kirill A. ShutemovTDX guest requires CR0.NE to be set. Clearing the bit triggers #GP(0).
If CR0.NE is 0, the MS-DOS compatibility mode for handling floating-point exceptions is selected. In this mode, the software exception handler for floating-point exceptions is invoked externally using the processor’s FERR#, INTR, and IGNNE# pins.
Using FERR# and IGNNE# to handle floating-point exception is deprecated. CR0.NE=0 also limits newer processors to operate with one logical processor active.
Kernel uses CR0_STATE constant to initialize CR0. It has NE bit set. But during early boot kernel has more ad-hoc approach to setting bit in the register. During some of this ad-hoc manipulation, CR0.NE is cleared. This causes a #GP in TDX guests and makes it die in early boot.
Make CR0 initialization consistent, deriving the initial value of CR0 from CR0_STATE. Since CR0_STATE always has CR0.NE=1, this ensures that CR0.NE is never 0 and avoids the #GP.
--- arch/x86/boot/compressed/head_64.S | 7 ++++--- arch/x86/realmode/rm/trampoline_64.S | 8 ++++---- 2 files changed, 8 insertions(+), 7 deletions(-)
arch/x86/boot/compressed/head_64.S +4 -3
@@ -289,7 +289,7 @@ SYM_FUNC_START(startup_32) pushl %eax /* Enter paged protected Mode, activating Long Mode */ - movl $(X86_CR0_PG | X86_CR0_PE), %eax /* Enable Paging and Protected mode */ + movl $CR0_STATE, %eax movl %eax, %cr0 /* Jump from 32bit compatibility mode into 64bit mode. */
@@ -662,8 +662,9 @@ SYM_CODE_START(trampoline_32bit_src) pushl $__KERNEL_CS pushl %eax - /* Enable paging again */ - movl $(X86_CR0_PG | X86_CR0_PE), %eax + /* Enable paging again. */ + movl %cr0, %eax + btsl $X86_CR0_PG_BIT, %eax movl %eax, %cr0 lret
arch/x86/realmode/rm/trampoline_64.S +4 -4
@@ -70,7 +70,7 @@ SYM_CODE_START(trampoline_start) movw $__KERNEL_DS, %dx # Data segment descriptor # Enable protected mode - movl $X86_CR0_PE, %eax # protected mode (PE) bit + movl $(CR0_STATE & ~X86_CR0_PG), %eax movl %eax, %cr0 # into protected mode # flush prefetch and jump to startup_32
@@ -148,8 +148,8 @@ SYM_CODE_START(startup_32) movl $MSR_EFER, %ecx wrmsr - # Enable paging and in turn activate Long Mode - movl $(X86_CR0_PG | X86_CR0_WP | X86_CR0_PE), %eax + # Enable paging and in turn activate Long Mode. + movl $CR0_STATE, %eax movl %eax, %cr0 /*
@@ -169,7 +169,7 @@ SYM_CODE_START(pa_trampoline_compat) movl $rm_stack_end, %esp movw $__KERNEL_DS, %dx - movl $X86_CR0_PE, %eax + movl $(CR0_STATE & ~X86_CR0_PG), %eax movl %eax, %cr0 ljmpl $__KERNEL32_CS, $pa_startup_32 SYM_CODE_END(pa_trampoline_compat)
Signature · 1 line
2.34.1
Re: [PATCHv6 22/30] x86/boot: Set CR0.NE early and keep it set during the boot
Quoted 6 lines · Kirill A. Shutemov
Make CR0 initialization consistent, deriving the initial value of CR0 from
CR0_STATE. SinceCR0_STATEalways has CR0.NE=1, this ensures that CR0.NE is never 0 and avoids the #GP.Signed-off-by Kirill A. Shutemov <[email protected]>Reviewed-by Dave Hansen <[email protected]>
PATCH v6 23/30 x86/boot: Avoid #VE during boot for TDX platforms
In reply to Kirill A. ShutemovFrom: Sean Christopherson <[email protected]>
There are a few MSRs and control register bits that the kernel normally needs to modify during boot. But, TDX disallows modification of these registers to help provide consistent security guarantees. Fortunately, TDX ensures that these are all in the correct state before the kernel loads, which means the kernel does not need to modify them.
The conditions to avoid are:
* Any writes to the EFER MSR
* Clearing CR4.MCE
This theoretically makes the guest boot more fragile. If, for instance, EFER was set up incorrectly and a WRMSR was performed, it will trigger early exception panic or a triple fault, if it's before early exceptions are set up. However, this is likely to trip up the guest BIOS long before control reaches the kernel. In any case, these kinds of problems are unlikely to occur in production environments, and developers have good debug tools to fix them quickly.
Change the common boot code to work on TDX and non-TDX systems. This should have no functional effect on non-TDX systems.
--- arch/x86/Kconfig | 1 + arch/x86/boot/compressed/head_64.S | 20 ++++++++++++++++++-- arch/x86/boot/compressed/pgtable.h | 2 +- arch/x86/kernel/head_64.S | 28 ++++++++++++++++++++++++++-- arch/x86/realmode/rm/trampoline_64.S | 13 ++++++++++++- 5 files changed, 58 insertions(+), 6 deletions(-)
arch/x86/Kconfig +1 -0
@@ -886,6 +886,7 @@ config INTEL_TDX_GUEST depends on X86_X2APIC select ARCH_HAS_CC_PLATFORM select DYNAMIC_PHYSICAL_MASK + select X86_MCE help Support running as a guest under Intel TDX. Without this support, the guest kernel can not boot or run under TDX.
arch/x86/boot/compressed/head_64.S +18 -2
@@ -643,12 +643,28 @@ SYM_CODE_START(trampoline_32bit_src) movl $MSR_EFER, %ecx rdmsr btsl $_EFER_LME, %eax + /* Avoid writing EFER if no change was made (for TDX guest) */ + jc 1f wrmsr - popl %edx +1: popl %edx popl %ecx +#ifdef CONFIG_X86_MCE + /* + * Preserve CR4.MCE if the kernel will enable #MC support. + * Clearing MCE may fault in some environments (that also force #MC + * support). Any machine check that occurs before #MC support is fully + * configured will crash the system regardless of the CR4.MCE value set + * here. + */ + movl %cr4, %eax + andl $X86_CR4_MCE, %eax +#else + movl $0, %eax +#endif + /* Enable PAE and LA57 (if required) paging modes */ - movl $X86_CR4_PAE, %eax + orl $X86_CR4_PAE, %eax testl %edx, %edx jz 1f orl $X86_CR4_LA57, %eax
arch/x86/boot/compressed/pgtable.h +1 -1
@@ -6,7 +6,7 @@#define TRAMPOLINE_32BIT_PGTABLE_OFFSET 0#define TRAMPOLINE_32BIT_CODE_OFFSET PAGE_SIZE -#define TRAMPOLINE_32BIT_CODE_SIZE 0x70 +#define TRAMPOLINE_32BIT_CODE_SIZE 0x80#define TRAMPOLINE_32BIT_STACK_END TRAMPOLINE_32BIT_SIZE
arch/x86/kernel/head_64.S +26 -2
@@ -140,8 +140,22 @@ SYM_INNER_LABEL(secondary_startup_64_no_verify, SYM_L_GLOBAL) addq $(init_top_pgt - __START_KERNEL_map), %rax 1: +#ifdef CONFIG_X86_MCE + /* + * Preserve CR4.MCE if the kernel will enable #MC support. + * Clearing MCE may fault in some environments (that also force #MC + * support). Any machine check that occurs before #MC support is fully + * configured will crash the system regardless of the CR4.MCE value set + * here. + */ + movq %cr4, %rcx + andl $X86_CR4_MCE, %ecx +#else + movl $0, %ecx +#endif + /* Enable PAE mode, PGE and LA57 */ - movl $(X86_CR4_PAE | X86_CR4_PGE), %ecx + orl $(X86_CR4_PAE | X86_CR4_PGE), %ecx #ifdef CONFIG_X86_5LEVEL testl $1, __pgtable_l5_enabled(%rip) jz 1f
@@ -246,13 +260,23 @@ SYM_INNER_LABEL(secondary_startup_64_no_verify, SYM_L_GLOBAL) /* Setup EFER (Extended Feature Enable Register) */ movl $MSR_EFER, %ecx rdmsr + /* + * Preserve current value of EFER for comparison and to skip + * EFER writes if no change was made (for TDX guest) + */ + movl %eax, %edx btsl $_EFER_SCE, %eax /* Enable System Call */ btl $20,%edi /* No Execute supported? */ jnc 1f btsl $_EFER_NX, %eax btsq $_PAGE_BIT_NX,early_pmd_flags(%rip) -1: wrmsr /* Make changes effective */ + /* Avoid writing EFER if no change was made (for TDX guest) */ +1: cmpl %edx, %eax + je 1f + xor %edx, %edx + wrmsr /* Make changes effective */ +1: /* Setup cr0 */ movl $CR0_STATE, %eax /* Make changes effective */
arch/x86/realmode/rm/trampoline_64.S +12 -1
@@ -143,11 +143,22 @@ SYM_CODE_START(startup_32) movl %eax, %cr3 # Set up EFER + movl $MSR_EFER, %ecx + rdmsr + /* + * Skip writing to EFER if the register already has desired + * value (to avoid #VE for the TDX guest). + */ + cmp pa_tr_efer, %eax + jne .Lwrite_efer + cmp pa_tr_efer + 4, %edx + je .Ldone_efer +.Lwrite_efer: movl pa_tr_efer, %eax movl pa_tr_efer + 4, %edx - movl $MSR_EFER, %ecx wrmsr +.Ldone_efer: # Enable paging and in turn activate Long Mode. movl $CR0_STATE, %eax movl %eax, %cr0
Signature · 1 line
2.34.1
Re: [PATCHv6 23/30] x86/boot: Avoid #VE during boot for TDX platforms
Quoted 8 lines · Kirill A. Shutemov
This theoretically makes the guest boot more fragile. If, for instance, EFER was set up incorrectly and a WRMSR was performed, it will trigger early exception panic or a triple fault, if it's before early exceptions are set up. However, this is likely to trip up the guest BIOS long before control reaches the kernel. In any case, these kinds of problems are unlikely to occur in production environments, and developers have good debug tools to fix them quickly.
Quoted 8 lines
Change the common boot code to work on TDX and non-TDX systems. This should have no functional effect on non-TDX systems.
Signed-off-by Sean Christopherson <[email protected]>Reviewed-by Andi Kleen <[email protected]>Reviewed-by Dan Williams <[email protected]>Signed-off-by Kuppuswamy Sathyanarayanan <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>
PATCH v6 24/30 x86/topology: Disable CPU online/offline control for TDX guests
In reply to Kirill A. ShutemovFrom: Kuppuswamy Sathyanarayanan <[email protected]>
Unlike regular VMs, TDX guests use the firmware hand-off wakeup method to wake up the APs during the boot process. This wakeup model uses a mailbox to communicate with firmware to bring up the APs. As per the design, this mailbox can only be used once for the given AP, which means after the APs are booted, the same mailbox cannot be used to offline/online the given AP. More details about this requirement can be found in Intel TDX Virtual Firmware Design Guide, sec titled "AP initialization in OS" and in sec titled "Hotplug Device".
Since the architecture does not support any method of offlining the CPUs, disable CPU hotplug support in the kernel.
Since this hotplug disable feature can be re-used by other VM guests, add a new CC attribute CC_ATTR_HOTPLUG_DISABLED and use it to disable the hotplug support.
With hotplug disabled, /sys/devices/system/cpu/cpuX/online sysfs option will not exist for TDX guests.
--- arch/x86/coco/core.c | 1 + include/linux/cc_platform.h | 10 ++++++++++ kernel/cpu.c | 7 +++++++ 3 files changed, 18 insertions(+)
arch/x86/coco/core.c +1 -0
@@ -20,6 +20,7 @@ static bool intel_cc_platform_has(enum cc_attr attr) {switch (attr) {case CC_ATTR_GUEST_UNROLL_STRING_IO : +case CC_ATTR_HOTPLUG_DISABLED :return true;default :return false;
include/linux/cc_platform.h +10 -0
@@ -72,6 +72,16 @@ enum cc_attr {* Examples include TDX guest & SEV. */ CC_ATTR_GUEST_UNROLL_STRING_IO , + +/** +* @CC_ATTR_HOTPLUG_DISABLED: Hotplug is not supported or disabled. +* +* The platform/OS is running as a guest/virtual machine does not +* support CPU hotplug feature. +* +* Examples include TDX Guest. +*/ + CC_ATTR_HOTPLUG_DISABLED, };#ifdef CONFIG_ARCH_HAS_CC_PLATFORM
kernel/cpu.c +7 -0
@@ -34,6 +34,7 @@#include <linux/scs.h> #include <linux/percpu-rwsem.h> #include <linux/cpuset.h> +#include <linux/cc_platform.h> #include <trace/events/power.h> #define CREATE_TRACE_POINTS
@@ -1185,6 +1186,12 @@ static int __ref _cpu_down(unsigned int cpu, int tasks_frozen,static int cpu_down_maps_locked (unsigned int cpu,enum cpuhp_state target) { +/* +* If the platform does not support hotplug, report it explicitly to +* differentiate it from a transient offlining failure. +*/ +if (cc_platform_has (CC_ATTR_HOTPLUG_DISABLED )) +return -EOPNOTSUPP ;if (cpu_hotplug_disabled)return -EBUSY ;return _cpu_down (cpu,0 , target);
Signature · 1 line
2.34.1
Re: [PATCHv6 24/30] x86/topology: Disable CPU online/offline control for TDX guests
Quoted 14 lines · Kirill A. Shutemov
From: Kuppuswamy Sathyanarayanan <[email protected]>
Unlike regular VMs, TDX guests use the firmware hand-off wakeup method to wake up the APs during the boot process. This wakeup model uses a mailbox to communicate with firmware to bring up the APs. As per the design, this mailbox can only be used once for the given AP, which means after the APs are booted, the same mailbox cannot be used to offline/online the given AP. More details about this requirement can be found in Intel TDX Virtual Firmware Design Guide, sec titled "AP initialization in OS" and in sec titled "Hotplug Device".
Since the architecture does not support any method of offlining the CPUs, disable CPU hotplug support in the kernel.
Quoted 6 lines
Since this hotplug disable feature can be re-used by other VM guests, add a new CC attribute
CC_ATTR_HOTPLUG_DISABLEDand use it to disable the hotplug support.With hotplug disabled,
/sys/devices/system/cpu/cpuX/onlinesysfs option will not exist for TDX guests.
I can't find any code which removes the online file. The write will fail with -EOPNOTSUPP, right?
Quoted 4 lines
Signed-off-by Kuppuswamy Sathyanarayanan <[email protected]>Reviewed-by Andi Kleen <[email protected]>Reviewed-by Tony Luck <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>
Other than that:
Re: [PATCHv6 24/30] x86/topology: Disable CPU online/offline control for TDX guests
Quoted 19 lines · Thomas Gleixner
Quoted 18 lines · Kirill A. Shutemov
From: Kuppuswamy Sathyanarayanan <[email protected]>
Unlike regular VMs, TDX guests use the firmware hand-off wakeup method to wake up the APs during the boot process. This wakeup model uses a mailbox to communicate with firmware to bring up the APs. As per the design, this mailbox can only be used once for the given AP, which means after the APs are booted, the same mailbox cannot be used to offline/online the given AP. More details about this requirement can be found in Intel TDX Virtual Firmware Design Guide, sec titled "AP initialization in OS" and in sec titled "Hotplug Device".
Since the architecture does not support any method of offlining the CPUs, disable CPU hotplug support in the kernel.
Since this hotplug disable feature can be re-used by other VM guests, add a new CC attribute
CC_ATTR_HOTPLUG_DISABLEDand use it to disable the hotplug support.
Quoted 5 lines
Quoted 2 lines
With hotplug disabled,
/sys/devices/system/cpu/cpuX/onlinesysfs option will not exist for TDX guests.I can't find any code which removes the online file. The write will fail with
-EOPNOTSUPP, right?
Right. Will fix the commit message.
Signature · 1 line
Kirill A. Shutemov
PATCH v6 25/30 x86/tdx: Make pages shared in ioremap()
In reply to Kirill A. ShutemovIn TDX guests, guest memory is protected from host access. If a guest performs I/O, it needs to explicitly share the I/O memory with the host.
Make all ioremap()ed pages that are not backed by normal memory (IORES_DESC_NONE or IORES_DESC_RESERVED) mapped as shared.
The permissions in PAGE_KERNEL_IO already work for "decrypted" memory on AMD SEV/SME systems. That means that they have no need to make a pgprot_decrypted() call.
TDX guests, on the other hand, _need_ change to PAGE_KERNEL_IO for "decrypted" mappings. Add a pgprot_decrypted() for TDX.
--- arch/x86/mm/ioremap.c | 5 +++++ 1 file changed, 5 insertions(+)
arch/x86/mm/ioremap.c +5 -0
@@ -242,10 +242,15 @@ __ioremap_caller(resource_size_t phys_addr, unsigned long size,* If the page being mapped is in memory and SEV is active then * make sure the memory encryption attribute is enabled in the * resulting mapping. +* In TDX guests, memory is marked private by default. If encryption +* is not requested (using encrypted), explicitly set decrypt +* attribute in all IOREMAPPED memory. */ prot =PAGE_KERNEL_IO ;if ((io_desc.flags &IORES_MAP_ENCRYPTED ) || encrypted) prot =pgprot_encrypted (prot); +else + prot =pgprot_decrypted (prot);switch (pcm) {case _PAGE_CACHE_MODE_UC:
Signature · 1 line
2.34.1
Re: [PATCHv6 25/30] x86/tdx: Make pages shared in ioremap()
Quoted 6 lines · Kirill A. Shutemov
In TDX guests, guest memory is protected from host access. If a guest performs I/O, it needs to explicitly share the I/O memory with the host.
Make all ioremap()ed pages that are not backed by normal memory (
IORES_DESC_NONEorIORES_DESC_RESERVED) mapped as shared.
Quoted 6 lines
The permissions in
PAGE_KERNEL_IOalready work for "decrypted" memory on AMD SEV/SME systems. That means that they have no need to make apgprot_decrypted()call.TDX guests, on the other hand, _need_ change to
PAGE_KERNEL_IOfor "decrypted" mappings. Add apgprot_decrypted()for TDX.
Re: [PATCHv6 25/30] x86/tdx: Make pages shared in ioremap()
In reply to Kirill A. ShutemovQuoted 10 lines · Kirill A. Shutemov
In TDX guests, guest memory is protected from host access. If a guest performs I/O, it needs to explicitly share the I/O memory with the host.
Make all ioremap()ed pages that are not backed by normal memory (
IORES_DESC_NONEorIORES_DESC_RESERVED) mapped as shared.The permissions in
PAGE_KERNEL_IOalready work for "decrypted" memory on AMD SEV/SME systems. That means that they have no need to make apgprot_decrypted()call.
Quoted 8 lines
TDX guests, on the other hand, _need_ change to
PAGE_KERNEL_IOfor "decrypted" mappings. Add apgprot_decrypted()for TDX.Co-developed-by Kuppuswamy Sathyanarayanan <[email protected]>Signed-off-by Kuppuswamy Sathyanarayanan <[email protected]>Reviewed-by Andi Kleen <[email protected]>Reviewed-by Tony Luck <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>
PATCH v6 26/30 x86/mm/cpa: Add support for TDX shared memory
In reply to Kirill A. ShutemovIntel TDX protects guest memory from VMM access. Any memory that is required for communication with the VMM must be explicitly shared.
It is a two-step process: the guest sets the shared bit in the page table entry and notifies VMM about the change. The notification happens using MapGPA hypercall.
Conversion back to private memory requires clearing the shared bit, notifying VMM with MapGPA hypercall following with accepting the memory with AcceptPage hypercall.
Provide a TDX version of x86_platform.guest.* callbacks. It makes __set_memory_enc_pgtable() work right in TDX guest.
--- arch/x86/coco/core.c | 1 + arch/x86/coco/tdx/tdx.c | 151 ++++++++++++++++++++++++++++++++++++++++ arch/x86/kernel/traps.c | 2 +- 3 files changed, 153 insertions(+), 1 deletion(-)
arch/x86/coco/core.c +1 -0
@@ -21,6 +21,7 @@ static bool intel_cc_platform_has(enum cc_attr attr)switch (attr) {case CC_ATTR_GUEST_UNROLL_STRING_IO :case CC_ATTR_HOTPLUG_DISABLED : +case CC_ATTR_GUEST_MEM_ENCRYPT :return true;default :return false;
arch/x86/coco/tdx/tdx.c +151 -0
172 lines not on this page · raw message
arch/x86/kernel/traps.c +1 -1
@@ -1305,7 +1305,7 @@ static void ve_raise_fault(struct pt_regs *regs, long error_code)* * In the settings that Linux will run in, virtualization exceptions are * never generated on accesses to normal, TD-private memory that has been -* accepted. +* accepted (by BIOS or with tdx_enc_status_changed()). * * Syscall entry code has a critical window where the kernel stack is not * yet set up. Any exception in this window leads to hard to debug issues
Signature · 1 line
2.34.1
Re: [PATCHv6 26/30] x86/mm/cpa: Add support for TDX shared memory
Quoted 7 lines · Kirill A. Shutemov
Intel TDX protects guest memory from VMM access. Any memory that is required for communication with the VMM must be explicitly shared.
It is a two-step process: the guest sets the shared bit in the page table entry and notifies VMM about the change. The notification happens using MapGPA hypercall.
Quoted 8 lines
Conversion back to private memory requires clearing the shared bit, notifying VMM with MapGPA hypercall following with accepting the memory with AcceptPage hypercall.
Provide a TDX version of x86_platform.guest.* callbacks. It makes
__set_memory_enc_pgtable()work right in TDX guest.Signed-off-by Kirill A. Shutemov <[email protected]>
PATCH v6 27/30 x86/kvm: Make SWIOTLB buffer shared for TD guest
In reply to Kirill A. ShutemovIntel TDX doesn't allow VMM to directly access guest private memory. Any memory that is required for communication with the VMM must be shared explicitly. The same rule applies for any DMA to and from the TDX guest. All DMA pages have to be marked as shared pages. A generic way to achieve this without any changes to device drivers is to use the SWIOTLB framework.
Make SWIOTLB buffer shared by generalizing mem_encrypt_init() to cover TDX.
--- arch/x86/Kconfig | 2 +- arch/x86/coco/core.c | 1 + arch/x86/include/asm/mem_encrypt.h | 6 +++--- arch/x86/mm/mem_encrypt.c | 9 ++++++++- 4 files changed, 13 insertions(+), 5 deletions(-)
arch/x86/Kconfig +1 -1
@@ -885,7 +885,7 @@ config INTEL_TDX_GUEST depends on X86_64 && CPU_SUP_INTEL depends on X86_X2APIC select ARCH_HAS_CC_PLATFORM - select DYNAMIC_PHYSICAL_MASK + select X86_MEM_ENCRYPT select X86_MCE help Support running as a guest under Intel TDX. Without this support,
arch/x86/coco/core.c +1 -0
@@ -22,6 +22,7 @@ static bool intel_cc_platform_has(enum cc_attr attr)case CC_ATTR_GUEST_UNROLL_STRING_IO :case CC_ATTR_HOTPLUG_DISABLED :case CC_ATTR_GUEST_MEM_ENCRYPT : +case CC_ATTR_MEM_ENCRYPT :return true;default :return false;
arch/x86/include/asm/mem_encrypt.h +3 -3
@@ -49,9 +49,6 @@ void __init early_set_mem_enc_dec_hypercall(unsigned long vaddr, int npages,void __init mem_encrypt_free_decrypted_mem (void ); -/* Architecture __weak replacement functions */ -void __init mem_encrypt_init (void ); -void __init sev_es_init_vc_handling (void );#define __bss_decrypted __section(".bss..decrypted")
@@ -89,6 +86,9 @@ static inline void mem_encrypt_free_decrypted_mem(void) { }#endif /* CONFIG_AMD_MEM_ENCRYPT */ +/* Architecture __weak replacement functions */ +void __init mem_encrypt_init (void ); +/* * The __sme_pa() and __sme_pa_nodebug() macros are meant for use when * writing to or comparing values from the cr3 register. Having the
arch/x86/mm/mem_encrypt.c +8 -1
@@ -42,7 +42,14 @@ bool force_dma_unencrypted(struct device *dev)static void print_mem_encrypt_feature_info (void ) { -pr_info ("AMD Memory Encryption Features active:" ); +pr_info ("Memory Encryption Features active:" ); + +if (cpu_feature_enabled (X86_FEATURE_TDX_GUEST )) { +pr_cont (" Intel TDX\n" ); +return ; + } + +pr_cont ("AMD " );/* Secure Memory Encryption */ if (cc_platform_has (CC_ATTR_HOST_MEM_ENCRYPT )) {
Signature · 1 line
2.34.1
Re: [PATCHv6 27/30] x86/kvm: Make SWIOTLB buffer shared for TD guest
Quoted 9 lines · Kirill A. Shutemov
Intel TDX doesn't allow VMM to directly access guest private memory. Any memory that is required for communication with the VMM must be shared explicitly. The same rule applies for any DMA to and from the TDX guest. All DMA pages have to be marked as shared pages. A generic way to achieve this without any changes to device drivers is to use the SWIOTLB framework.
Make SWIOTLB buffer shared by generalizing
mem_encrypt_init()to cover TDX.
This could have saved me a trip to the console if it would have also said:
Stop selecting DYNAMIC_PHYSICAL_MASK directly. It will get set indirectly by selcting X86_MEM_ENCRYPT.
It's probably also worth noting:
mem_encrypt_init() is currently under an AMD-specific #ifdef. Move it to a more generic area of the header.
The other adorable thing about this patch:
Quoted 5 lines
arch/x86/Kconfig | 2 +- arch/x86/coco/core.c | 1 + arch/x86/include/asm/mem_encrypt.h | 6 +++--- arch/x86/mm/mem_encrypt.c | 9 ++++++++- 4 files changed, 13 insertions(+), 5 deletions(-)
Is that it superficially has *zero* to do with SWIOTLB, also known as the declared Subject. It almost looks like this patch found a smaller and weaker patch, beat it up, and stole its Subject.
I'd be fine with an "x86/mm" tag on this too. I'm not sure what makes it truly KVM-specific.
Can you send a revision with something a bit more descriptive, please?
PATCH v6 28/30 x86/tdx: ioapic: Add shared bit for IOAPIC base address
In reply to Kirill A. ShutemovFrom: Isaku Yamahata <[email protected]>
The kernel interacts with each bare-metal IOAPIC with a special MMIO page. When running under KVM, the guest's IOAPICs are emulated by KVM.
When running as a TDX guest, the guest needs to mark each IOAPIC mapping as "shared" with the host. This ensures that TDX private protections are not applied to the page, which allows the TDX host emulation to work.
ioremap()-created mappings such as virtio will be marked as shared by default. However, the IOAPIC code does not use ioremap() and instead uses the fixmap mechanism.
Introduce a special fixmap helper just for the IOAPIC code. Ensure that it marks IOAPIC pages as "shared". This replaces set_fixmap_nocache() with __set_fixmap() since __set_fixmap() allows custom 'prot' values.
AMD SEV gets IOAPIC pages shared because FIXMAP_PAGE_NOCACHE has _ENC bit clear. TDX has to set bit to share the page with the host.
--- arch/x86/kernel/apic/io_apic.c | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-)
arch/x86/kernel/apic/io_apic.c +16 -2
@@ -65,6 +65,7 @@#include <asm/irq_remapping.h> #include <asm/hw_irq.h> #include <asm/apic.h> +#include <asm/pgtable.h> #define for_each_ioapic (idx) \ for ((idx) = 0; (idx) < nr_ioapics; (idx)++)
@@ -2677,6 +2678,19 @@ static struct resource * __init ioapic_setup_resources(void)return res; } +static void io_apic_set_fixmap (enum fixed_addresses idx,phys_addr_t phys) +{ +pgprot_t flags =FIXMAP_PAGE_NOCACHE ; + +/* +* Ensure fixmaps for IOAPIC MMIO respect memory encryption pgprot +* bits, just like normal ioremap(): +*/ + flags =pgprot_decrypted (flags); + +__set_fixmap (idx, phys, flags); +} +void __init io_apic_init_mappings (void ) {unsigned long ioapic_phys, idx =FIX_IO_APIC_BASE_0 ;
@@ -2709,7 +2723,7 @@ void __init io_apic_init_mappings(void) __func__, PAGE_SIZE, PAGE_SIZE); ioapic_phys =__pa (ioapic_phys); } -set_fixmap_nocache (idx, ioapic_phys); +io_apic_set_fixmap (idx, ioapic_phys);apic_printk (APIC_VERBOSE ,"mapped IOAPIC to %08lx (%08lx)\n" ,__fix_to_virt (idx) + (ioapic_phys & ~PAGE_MASK ), ioapic_phys);
@@ -2838,7 +2852,7 @@ int mp_register_ioapic(int id, u32 address, u32 gsi_base, ioapics[idx].mp_config.flags =MPC_APIC_USABLE ; ioapics[idx].mp_config.apicaddr = address; -set_fixmap_nocache (FIX_IO_APIC_BASE_0 + idx, address); +io_apic_set_fixmap (FIX_IO_APIC_BASE_0 + idx, address);if (bad_ioapic_register (idx)) {clear_fixmap (FIX_IO_APIC_BASE_0 + idx);return -ENODEV ;
Signature · 1 line
2.34.1
Re: [PATCHv6 28/30] x86/tdx: ioapic: Add shared bit for IOAPIC base address
Quoted 5 lines · Kirill A. Shutemov
Introduce a special fixmap helper just for the IOAPIC code. Ensure that it marks IOAPIC pages as "shared". This replaces
set_fixmap_nocache()with__set_fixmap()since__set_fixmap()allows custom 'prot' values.
Quoted 8 lines
AMD SEV gets IOAPIC pages shared because
FIXMAP_PAGE_NOCACHEhas_ENCbit clear. TDX has to set bit to share the page with the host.Signed-off-by Isaku Yamahata <[email protected]>Reviewed-by Andi Kleen <[email protected]>Reviewed-by Tony Luck <[email protected]>Signed-off-by Kuppuswamy Sathyanarayanan <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>
PATCH v6 29/30 ACPICA: Avoid cache flush inside virtual machines
In reply to Kirill A. ShutemovWhile running inside virtual machine, the kernel can bypass cache flushing. Changing sleep state in a virtual machine doesn't affect the host system sleep state and cannot lead to data loss.
Before entering sleep states, the ACPI code flushes caches to prevent data loss using the WBINVD instruction. This mechanism is required on bare metal.
But, any use WBINVD inside of a guest is worthless. Changing sleep state in a virtual machine doesn't affect the host system sleep state and cannot lead to data loss, so most hypervisors simply ignore it. Despite this, the ACPI code calls WBINVD unconditionally anyway. It's useless, but also normally harmless.
In TDX guests, though, WBINVD stops being harmless; it triggers a virtualization exception (#VE). If the ACPI cache-flushing WBINVD were left in place, TDX guests would need handling to recover from the exception.
Avoid using WBINVD whenever running under a hypervisor. This both removes the useless WBINVDs and saves TDX from implementing WBINVD handling.
--- arch/x86/include/asm/acenv.h | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)
arch/x86/include/asm/acenv.h +13 -1
@@ -13,7 +13,19 @@/* Asm macros */ -#define ACPI_FLUSH_CPU_CACHE () wbinvd() +/* +* ACPI_FLUSH_CPU_CACHE() flushes caches on entering sleep states. +* It is required to prevent data loss. +* +* While running inside virtual machine, the kernel can bypass cache flushing. +* Changing sleep state in a virtual machine doesn't affect the host system +* sleep state and cannot lead to data loss. +*/ +#define ACPI_FLUSH_CPU_CACHE () \ +do { \ + if (!cpu_feature_enabled(X86_FEATURE_HYPERVISOR)) \ + wbinvd(); \ +} while (0)int __acpi_acquire_global_lock (unsigned int *lock);int __acpi_release_global_lock (unsigned int *lock);
Signature · 1 line
2.34.1
Re: [PATCHv6 29/30] ACPICA: Avoid cache flush inside virtual machines
Quoted 14 lines · Kirill A. Shutemov
While running inside virtual machine, the kernel can bypass cache flushing. Changing sleep state in a virtual machine doesn't affect the host system sleep state and cannot lead to data loss.
Before entering sleep states, the ACPI code flushes caches to prevent data loss using the WBINVD instruction. This mechanism is required on bare metal.
But, any use WBINVD inside of a guest is worthless. Changing sleep state in a virtual machine doesn't affect the host system sleep state and cannot lead to data loss, so most hypervisors simply ignore it. Despite this, the ACPI code calls WBINVD unconditionally anyway. It's useless, but also normally harmless.
Quoted 8 lines
In TDX guests, though, WBINVD stops being harmless; it triggers a virtualization exception (#VE). If the ACPI cache-flushing WBINVD were left in place, TDX guests would need handling to recover from the exception.
Avoid using WBINVD whenever running under a hypervisor. This both removes the useless WBINVDs and saves TDX from implementing WBINVD handling.
Looks good. Did you have more acks on this earlier that got removed? I thought I remembered more acks on earlier versions.
Dan Williams
Reviewed-byRe: [PATCHv6 29/30] ACPICA: Avoid cache flush inside virtual machines
Quoted 21 lines · Dave Hansen
Quoted 19 lines · Kirill A. Shutemov
While running inside virtual machine, the kernel can bypass cache flushing. Changing sleep state in a virtual machine doesn't affect the host system sleep state and cannot lead to data loss.
Before entering sleep states, the ACPI code flushes caches to prevent data loss using the WBINVD instruction. This mechanism is required on bare metal.
But, any use WBINVD inside of a guest is worthless. Changing sleep state in a virtual machine doesn't affect the host system sleep state and cannot lead to data loss, so most hypervisors simply ignore it. Despite this, the ACPI code calls WBINVD unconditionally anyway. It's useless, but also normally harmless.
In TDX guests, though, WBINVD stops being harmless; it triggers a virtualization exception (#VE). If the ACPI cache-flushing WBINVD were left in place, TDX guests would need handling to recover from the exception.
Quoted 8 lines
Quoted 3 lines
Avoid using WBINVD whenever running under a hypervisor. This both removes the useless WBINVDs and saves TDX from implementing WBINVD handling.
Looks good. Did you have more acks on this earlier that got removed? I thought I remembered more acks on earlier versions.
Reviewed-by Dave Hansen <[email protected]>
Yeah, my previous reviewed-by still stands:
Re: [PATCHv6 29/30] ACPICA: Avoid cache flush inside virtual machines
In reply to Dave HansenQuoted 20 lines · Dave Hansen
Quoted 19 lines · Kirill A. Shutemov
While running inside virtual machine, the kernel can bypass cache flushing. Changing sleep state in a virtual machine doesn't affect the host system sleep state and cannot lead to data loss.
Before entering sleep states, the ACPI code flushes caches to prevent data loss using the WBINVD instruction. This mechanism is required on bare metal.
But, any use WBINVD inside of a guest is worthless. Changing sleep state in a virtual machine doesn't affect the host system sleep state and cannot lead to data loss, so most hypervisors simply ignore it. Despite this, the ACPI code calls WBINVD unconditionally anyway. It's useless, but also normally harmless.
In TDX guests, though, WBINVD stops being harmless; it triggers a virtualization exception (#VE). If the ACPI cache-flushing WBINVD were left in place, TDX guests would need handling to recover from the exception.
Quoted 6 lines
Quoted 3 lines
Avoid using WBINVD whenever running under a hypervisor. This both removes the useless WBINVDs and saves TDX from implementing WBINVD handling.
Looks good. Did you have more acks on this earlier that got removed? I thought I remembered more acks on earlier versions.
I missed Dan's Reviewed-by, but it was the only one that got to my inbox.
We had few (actually few too many) different approaches to address WBINVD and some of them got acks. Dan was the only one who acked this version, before current submission.
Signature · 1 line
Kirill A. Shutemov
Re: [PATCHv6 29/30] ACPICA: Avoid cache flush inside virtual machines
In reply to Kirill A. ShutemovQuoted 19 lines · Kirill A. Shutemov
While running inside virtual machine, the kernel can bypass cache flushing. Changing sleep state in a virtual machine doesn't affect the host system sleep state and cannot lead to data loss.
Before entering sleep states, the ACPI code flushes caches to prevent data loss using the WBINVD instruction. This mechanism is required on bare metal.
But, any use WBINVD inside of a guest is worthless. Changing sleep state in a virtual machine doesn't affect the host system sleep state and cannot lead to data loss, so most hypervisors simply ignore it. Despite this, the ACPI code calls WBINVD unconditionally anyway. It's useless, but also normally harmless.
In TDX guests, though, WBINVD stops being harmless; it triggers a virtualization exception (#VE). If the ACPI cache-flushing WBINVD were left in place, TDX guests would need handling to recover from the exception.
Quoted 5 lines
Avoid using WBINVD whenever running under a hypervisor. This both removes the useless WBINVDs and saves TDX from implementing WBINVD handling.
Signed-off-by Kirill A. Shutemov <[email protected]>
PATCH v6 30/30 Documentation/x86: Document TDX kernel architecture
In reply to Kirill A. ShutemovFrom: Kuppuswamy Sathyanarayanan <[email protected]>
Document the TDX guest architecture details like #VE support, shared memory, etc.
--- Documentation/x86/index.rst | 1 + Documentation/x86/tdx.rst | 214 ++++++++++++++++++++++++++++++++++++ 2 files changed, 215 insertions(+) create mode 100644 Documentation/x86/tdx.rst
Documentation/x86/index.rst +1 -0
@@ -24,6 +24,7 @@ x86-specific Documentation intel-iommu intel_txt amd-memory-encryption + tdx pti mds microcode
Documentation/x86/tdx.rst new file +214 -0
214 lines not on this page · raw message
Signature · 1 line
2.34.1