@@ -85,10 +85,12 @@ static inline long tdx_kvm_hypercall(unsigned int nr, unsigned long p1,
void tdx_detect_cpu(struct cpuinfo_x86 *c);
int tdx_detect(void);
int tdx_init(void);
+bool platform_has_tdx(void);
#else
static inline void tdx_detect_cpu(struct cpuinfo_x86 *c) { }
static inline int tdx_detect(void) { return -ENODEV; }
static inline int tdx_init(void) { return -ENODEV; }
+static inline bool platform_has_tdx(void) { return false; }
#endif /* CONFIG_INTEL_TDX_HOST */
#endif /* !__ASSEMBLY__ */
@@ -766,8 +766,32 @@ void stop_this_cpu(void *dummy)
* without the encryption bit, they don't race each other when flushed
* and potentially end up with the wrong entry being committed to
* memory.
+ *
+ * In case of kexec, similar to SME, if TDX is ever enabled, the
+ * cachelines of TDX private memory (including PAMTs) used by TDX
+ * module need to be flushed before transiting to the new kernel,
+ * otherwise they may silently corrupt the new kernel.
+ *
+ * Note TDX is enabled on demand at runtime, and enabling TDX has a
+ * state machine protected with a mutex to prevent concurrent calls
+ * from multiple callers. Holding the mutex is required to get the
+ * TDX enabling status, but this function runs in interrupt context.
+ * So to make it simple, always flush cache when platform supports
+ * TDX (detected at boot time), regardless whether TDX is truly
+ * enabled by kernel.
+ *
+ * TDX module can only be initialized once during its lifetime. So
+ * if TDX is enabled in old kernel, the new kernel won't be able to
+ * use TDX again, because when new kernel go through the TDX module
+ * initialization process, it will fail immediately at the first
+ * SEAMCALL. Ideally, it's better to shut down TDX module, but this
+ * requires SEAMCALL, which requires CPU already being in VMX
+ * operation. It's not trival to do VMXON here so to keep it simple
+ * just leave the module open. And leaving TDX module open is OK.
+ * The new kernel cannot use TDX anyway. The TDX module won't run
+ * at all in the new kernel.
*/
- if (boot_cpu_has(X86_FEATURE_SME))
+ if (boot_cpu_has(X86_FEATURE_SME) || platform_has_tdx())
native_wbinvd();
for (;;) {
/*
@@ -1602,3 +1602,17 @@ int tdx_init(void)
return ret;
}
EXPORT_SYMBOL_GPL(tdx_init);
+
+/**
+ * platform_has_tdx - Whether platform supports TDX
+ *
+ * Check whether platform supports TDX (i.e. TDX is enabled in BIOS),
+ * regardless whether TDX is truly enabled by kernel.
+ *
+ * Return true if SEAMRR is enabled, and there are sufficient TDX private
+ * KeyIDs to run TD guests.
+ */
+bool platform_has_tdx(void)
+{
+ return seamrr_enabled() && tdx_keyid_sufficient();
+}
If TDX is ever enabled and/or used to run any TD guests, the cachelines of TDX private memory, including PAMTs, used by TDX module need to be flushed before transiting to the new kernel otherwise they may silently corrupt the new kernel. TDX module can only be initialized once during its lifetime. TDX does not have interface to reset TDX module to an uninitialized state so it could be initialized again. If the old kernel has enabled TDX, the new kernel won't be able to use TDX again. Therefore, ideally the old kernel should shut down the TDX module if it is ever initialized so that no SEAMCALLs can be made to it again. However, SEAMCALL requires cpu being in VMX operation (VMXON has been done). Currently, only KVM handles VMXON and when KVM is unloaded, all cpus leave VMX operation. Theoretically, during kexec() there's no guarantee all cpus are in VMX operation. Adding VMXON handling to the core kernel isn't trivial so this implementation depends on the caller of TDX to guarantee that. This means it's not easy to shut down TDX module during kexec(). Therefore, this implementation doesn't shut down TDX module, but only does cache flush and just leave TDX module open. And it's fine to leave the module open. If the new kernel wants to use TDX, it needs to go through the initialization process which will fail at the first SEAMCALL due to TDX module is not in uninitialized state. If the new kernel doesn't want to use TDX, then TDX module won't run at all. Following the implementation of SME support, use wbinvd() to flush cache in stop_this_cpu(). Introduce a new function platform_has_tdx() to only check whether the platform is TDX-capable and do wbinvd() when it is true. platform_has_tdx() returns true when SEAMRR is enabled and there are enough TDX private KeyIDs to run at least one TD guest (both of which are detected at boot time). TDX is enabled on demand at runtime and it has a state machine with mutex to protect multiple callers to initialize TDX in parallel. Getting TDX module state needs to hold the mutex but stop_this_cpu() runs in interrupt context, so just check whether platform supports TDX and flush cache. Signed-off-by: Kai Huang <kai.huang@intel.com> --- arch/x86/include/asm/tdx.h | 2 ++ arch/x86/kernel/process.c | 26 +++++++++++++++++++++++++- arch/x86/virt/vmx/tdx.c | 14 ++++++++++++++ 3 files changed, 41 insertions(+), 1 deletion(-)