[lkml]   [2022]   [Nov]   [20]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
Messages in this thread
    Patch in this message
    Subject[PATCH v7 20/20] Documentation/x86: Add documentation for TDX host support
    Add documentation for TDX host kernel support.  There is already one
    file Documentation/x86/tdx.rst containing documentation for TDX guest
    internals. Also reuse it for TDX host kernel support.

    Introduce a new level menu "TDX Guest Support" and move existing
    materials under it, and add a new menu for TDX host kernel support.

    Signed-off-by: Kai Huang <>

    v6 -> v7:
    - Changed "TDX Memory Policy" and "Kexec()" sections.

    Documentation/x86/tdx.rst | 181 +++++++++++++++++++++++++++++++++++---
    1 file changed, 170 insertions(+), 11 deletions(-)

    diff --git a/Documentation/x86/tdx.rst b/Documentation/x86/tdx.rst
    index dc8d9fd2c3f7..35092e7c60f7 100644
    --- a/Documentation/x86/tdx.rst
    +++ b/Documentation/x86/tdx.rst
    @@ -10,6 +10,165 @@ encrypting the guest memory. In TDX, a special module running in a special
    mode sits between the host and the guest and manages the guest/host

    +TDX Host Kernel Support
    +TDX introduces a new CPU mode called Secure Arbitration Mode (SEAM) and
    +a new isolated range pointed by the SEAM Ranger Register (SEAMRR). A
    +CPU-attested software module called 'the TDX module' runs inside the new
    +isolated range to provide the functionalities to manage and run protected
    +TDX also leverages Intel Multi-Key Total Memory Encryption (MKTME) to
    +provide crypto-protection to the VMs. TDX reserves part of MKTME KeyIDs
    +as TDX private KeyIDs, which are only accessible within the SEAM mode.
    +BIOS is responsible for partitioning legacy MKTME KeyIDs and TDX KeyIDs.
    +Before the TDX module can be used to create and run protected VMs, it
    +must be loaded into the isolated range and properly initialized. The TDX
    +architecture doesn't require the BIOS to load the TDX module, but the
    +kernel assumes it is loaded by the BIOS.
    +TDX boot-time detection
    +The kernel detects TDX by detecting TDX private KeyIDs during kernel
    +boot. Below dmesg shows when TDX is enabled by BIOS::
    + [..] tdx: TDX enabled by BIOS. TDX private KeyID range: [16, 64).
    +TDX module detection and initialization
    +There is no CPUID or MSR to detect the TDX module. The kernel detects it
    +by initializing it.
    +The kernel talks to the TDX module via the new SEAMCALL instruction. The
    +TDX module implements SEAMCALL leaf functions to allow the kernel to
    +initialize it.
    +Initializing the TDX module consumes roughly ~1/256th system RAM size to
    +use it as 'metadata' for the TDX memory. It also takes additional CPU
    +time to initialize those metadata along with the TDX module itself. Both
    +are not trivial. The kernel initializes the TDX module at runtime on
    +demand. The caller to call tdx_enable() to initialize the TDX module::
    + ret = tdx_enable();
    + if (ret)
    + goto no_tdx;
    + // TDX is ready to use
    +Initializing the TDX module requires all logical CPUs being online.
    +tdx_enable() internally temporarily disables CPU hotplug to prevent any
    +CPU from going offline, but the caller still needs to guarantee all
    +present CPUs are online before calling tdx_enable().
    +Also, tdx_enable() requires all CPUs are already in VMX operation
    +(requirement of making SEAMCALL). Currently, tdx_enable() doesn't handle
    +VMXON internally, but depends on the caller to guarantee that. So far
    +KVM is the only user of TDX and KVM already handles VMXON.
    +User can consult dmesg to see the presence of the TDX module, and whether
    +it has been initialized.
    +If the TDX module is not loaded, dmesg shows below::
    + [..] tdx: TDX module is not loaded.
    +If the TDX module is initialized successfully, dmesg shows something
    +like below::
    + [..] tdx: TDX module: attributes 0x0, vendor_id 0x8086, major_version 1, minor_version 0, build_date 20211209, build_num 160
    + [..] tdx: 65667 pages allocated for PAMT.
    + [..] tdx: TDX module initialized.
    +If the TDX module failed to initialize, dmesg shows below::
    + [..] tdx: Failed to initialize TDX module. Shut it down.
    +TDX Interaction to Other Kernel Components
    +TDX Memory Policy
    +TDX reports a list of "Convertible Memory Region" (CMR) to indicate all
    +memory regions that can possibly be used by the TDX module, but they are
    +not automatically usable to the TDX module. As a step of initializing
    +the TDX module, the kernel needs to choose a list of memory regions (out
    +from convertible memory regions) that the TDX module can use and pass
    +those regions to the TDX module. Once this is done, those "TDX-usable"
    +memory regions are fixed during module's lifetime. No more TDX-usable
    +memory can be added to the TDX module after that.
    +To keep things simple, currently the kernel simply guarantees all pages
    +in the page allocator are TDX memory. Specifically, the kernel uses all
    +system memory in the core-mm at the time of initializing the TDX module
    +as TDX memory, and at the meantime, refuses to add any non-TDX-memory in
    +the memory hotplug.
    +This can be enhanced in the future, i.e. by allowing adding non-TDX
    +memory to a separate NUMA node. In this case, the "TDX-capable" nodes
    +and the "non-TDX-capable" nodes can co-exist, but the kernel/userspace
    +needs to guarantee memory pages for TDX guests are always allocated from
    +the "TDX-capable" nodes.
    +Note TDX assumes convertible memory is always physically present during
    +machine's runtime. A non-buggy BIOS should never support hot-removal of
    +any convertible memory. This implementation doesn't handle ACPI memory
    +removal but depends on the BIOS to behave correctly.
    +CPU Hotplug
    +TDX doesn't support physical (ACPI) CPU hotplug. During machine boot,
    +TDX verifies all boot-time present logical CPUs are TDX compatible before
    +enabling TDX. A non-buggy BIOS should never support hot-add/removal of
    +physical CPU. Currently the kernel doesn't handle physical CPU hotplug,
    +but depends on the BIOS to behave correctly.
    +Note TDX works with CPU logical online/offline, thus the kernel still
    +allows to offline logical CPU and online it again.
    +There are two problems in terms of using kexec() to boot to a new kernel
    +when the old kernel has enabled TDX: 1) Part of the memory pages are
    +still TDX private pages (i.e. metadata used by the TDX module, and any
    +TDX guest memory if kexec() is executed when there's live TDX guests).
    +2) There might be dirty cachelines associated with TDX private pages.
    +Because the hardware doesn't guarantee cache coherency among different
    +KeyIDs, the old kernel needs to flush cache (of TDX private pages)
    +before booting to the new kernel. Also, the kernel doesn't convert all
    +TDX private pages back to normal because of below considerations:
    +1) The kernel doesn't have existing infrastructure to track which pages
    + are TDX private page.
    +2) The number of TDX private pages can be large, and converting all of
    + them (cache flush + using MOVDIR64B to clear the page) can be time
    + consuming.
    +3) The new kernel will almost only use KeyID 0 to access memory. KeyID
    + 0 doesn't support integrity-check, so it's OK.
    +4) The kernel doesn't (and may never) support MKTME. If any 3rd party
    + kernel ever supports MKTME, it should do MOVDIR64B to clear the page
    + with the new MKTME KeyID (just like TDX does) before using it.
    +The current TDX module architecture doesn't play nicely with kexec().
    +The TDX module can only be initialized once during its lifetime, and
    +there is no SEAMCALL to reset the module to give a new clean slate to
    +the new kernel. Therefore, ideally, if the module is ever initialized,
    +it's better to shut down the module. The new kernel won't be able to
    +use TDX anyway (as it needs to go through the TDX module initialization
    +process which will fail immediately at the first step).
    +However, there's no guarantee CPU is in VMX operation during kexec(), so
    +it's impractical to shut down the module. Currently, the kernel just
    +leaves the module in open state.
    +TDX Guest Support
    Since the host cannot directly access guest registers or memory, much
    normal functionality of a hypervisor must be moved into the guest. This is
    implemented using a Virtualization Exception (#VE) that is handled by the
    @@ -20,7 +179,7 @@ TDX includes new hypercall-like mechanisms for communicating from the
    guest to the hypervisor or the TDX module.

    New TDX Exceptions

    TDX guests behave differently from bare-metal and traditional VMX guests.
    In TDX guests, otherwise normal instructions or memory accesses can cause
    @@ -30,7 +189,7 @@ Instructions marked with an '*' conditionally cause exceptions. The
    details for these instructions are discussed below.

    Instruction-based #VE

    - Port I/O (INS, OUTS, IN, OUT)
    - HLT
    @@ -41,7 +200,7 @@ Instruction-based #VE
    - CPUID*

    Instruction-based #GP

    @@ -52,7 +211,7 @@ Instruction-based #GP

    RDMSR/WRMSR Behavior

    MSR access behavior falls into three categories:

    @@ -73,7 +232,7 @@ trapping and handling in the TDX module. Other than possibly being slow,
    these MSRs appear to function just as they would on bare metal.

    CPUID Behavior

    For some CPUID leaves and sub-leaves, the virtualized bit fields of CPUID
    return values (in guest EAX/EBX/ECX/EDX) are configurable by the
    @@ -93,7 +252,7 @@ not know how to handle. The guest kernel may ask the hypervisor for the
    value with a hypercall.

    #VE on Memory Accesses

    There are essentially two classes of TDX memory: private and shared.
    Private memory receives full TDX protections. Its content is protected
    @@ -107,7 +266,7 @@ entries. This helps ensure that a guest does not place sensitive
    information in shared memory, exposing it to the untrusted hypervisor.

    #VE on Shared Memory

    Access to shared mappings can cause a #VE. The hypervisor ultimately
    controls whether a shared memory access causes a #VE, so the guest must be
    @@ -127,7 +286,7 @@ be careful not to access device MMIO regions unless it is also prepared to
    handle a #VE.

    #VE on Private Pages

    An access to private mappings can also cause a #VE. Since all kernel
    memory is also private memory, the kernel might theoretically need to
    @@ -145,7 +304,7 @@ The hypervisor is permitted to unilaterally move accepted pages to a
    to handle the exception.

    Linux #VE handler

    Just like page faults or #GP's, #VE exceptions can be either handled or be
    fatal. Typically, an unhandled userspace #VE results in a SIGSEGV.
    @@ -167,7 +326,7 @@ While the block is in place, any #VE is elevated to a double fault (#DF)
    which is not recoverable.

    MMIO handling

    In non-TDX VMs, MMIO is usually implemented by giving a guest access to a
    mapping which will cause a VMEXIT on access, and then the hypervisor
    @@ -189,7 +348,7 @@ MMIO access via other means (like structure overlays) may result in an

    Shared Memory Conversions

    All TDX guest memory starts out as private at boot. This memory can not
    be accessed by the hypervisor. However, some kernel users like device
     \ /
      Last update: 2022-11-21 01:32    [W:20.739 / U:10.972 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site