Skip to contentSkip to conversation

KVM: VMX: Initialize TDX when loading KVM module

PATCH In review Kai Huang 2 participants 7 messages Nov 15, 2024 – Nov 21, 2024

Subsystems (4)
lore
Share & tools
lore

Kai Huang

author
#0 lore raw

v2 cover KVM: VMX: Initialize TDX when loading KVM module

Hi Paolo/Sean,

This series contains patches to initialize TDX when loading KVM module. The main purpose of sending this out is to have a review and for the integration to kvm-coco-queue, but this series can also be applied to kvm/queue cleanly.

v1 -> v2:
- Add KVM_INTEL_TDX to guide KVM TDX code. (Sean)
- Distinguish "TDX cannot be supported" vs "TDX fail to enable due to unexpected failure", and handle them differently. (Sean)
- Update changelog accordingly
- Remove useless comments around tdx_enable() and tdx_cpu_enable() (Sean).
- Add SPDX-License-Identifier tag to vmx/tdx.h

Btw:

I kept the name tdx_bringup(), tdx_cleanup() but didn't change them to tdx_module_init() and tdx_module_exit() cause I feel KVM does more than "module" init/exit. We can change that if needed.

v1: https://lore.kernel.org/kvm/[email protected]/T/

Kai Huang (3):
KVM: VMX: Refactor VMX module init/exit functions
KVM: Export hardware virtualization enabling/disabling functions
KVM: VMX: Initialize TDX during KVM module load

 arch/x86/kvm/Kconfig     |  10 +++
 arch/x86/kvm/Makefile    |   1 +
 arch/x86/kvm/vmx/main.c  |  41 +++++++++++
 arch/x86/kvm/vmx/tdx.c   | 153 +++++++++++++++++++++++++++++++++++++++
 arch/x86/kvm/vmx/tdx.h   |  13 ++++
 arch/x86/kvm/vmx/vmx.c   |  23 +-----
 arch/x86/kvm/vmx/vmx.h   |   3 +
 include/linux/kvm_host.h |   8 ++
 virt/kvm/kvm_main.c      |  18 +----
 9 files changed, 235 insertions(+), 35 deletions(-)
 create mode 100644 arch/x86/kvm/vmx/tdx.c
 create mode 100644 arch/x86/kvm/vmx/tdx.h

base-commit: b1e0320c5a9fe875f56039ea43e183c59974d38a

Signature · 1 line
2.46.2
author
#1 lore raw

PATCH v2 1/3 KVM: VMX: Refactor VMX module init/exit functions

Add vt_init() and vt_exit() as the new module init/exit functions and refactor existing vmx_init()/vmx_exit() as helper to make room for TDX specific initialization and teardown.

To support TDX, KVM will need to enable TDX during KVM module loading time. Enabling TDX requires enabling hardware virtualization first so that all online CPUs (and the new CPU going online) are in post-VMXON state.

Currently, the vmx_init() flow is:

1) hv_init_evmcs(),
2) kvm_x86_vendor_init(),
3) Other VMX specific initialization,
4) kvm_init()

The kvm_x86_vendor_init() invokes kvm_x86_init_ops::hardware_setup() to do VMX specific hardware setup and calls kvm_update_ops() to initialize kvm_x86_ops to VMX's version.

TDX will have its own version for most of kvm_x86_ops callbacks. It would be nice if kvm_x86_init_ops::hardware_setup() could also be used for TDX, but in practice it cannot. The reason is, as mentioned above, TDX initialization requires hardware virtualization having been enabled, which must happen after kvm_update_ops(), but hardware_setup() is done before that.

Also, TDX is based on VMX, and it makes sense to only initialize TDX after VMX has been initialized. If VMX fails to initialize, TDX is likely broken anyway.

So the new flow of KVM module init function will be:

1) Current VMX initialization code in vmx_init() before kvm_init(),
2) TDX initialization,
3) kvm_init()

Split vmx_init() into two parts based on above 1) and 3) so that TDX initialization can fit in between. Make part 1) as the new helper vmx_init(). Introduce vt_init() as the new module init function which calls vmx_init() and kvm_init(). TDX initialization will be added later.

Do the same thing for vmx_exit()/vt_exit().

---
 arch/x86/kvm/vmx/main.c | 32 ++++++++++++++++++++++++++++++++
 arch/x86/kvm/vmx/vmx.c  | 23 ++---------------------
 arch/x86/kvm/vmx/vmx.h  |  3 +++
 3 files changed, 37 insertions(+), 21 deletions(-)
arch/x86/kvm/vmx/main.c +32 -0
index 92d35cc6cd15..6772e560ac7b 100644
@@ -167,3 +167,35 @@ struct kvm_x86_init_ops vt_init_ops __initdata = {
 	.runtime_ops = &vt_x86_ops,
 	.pmu_ops = &intel_pmu_ops,
 };
+
+static void vt_exit(void)
+{
+	kvm_exit();
+	vmx_exit();
+}
+module_exit(vt_exit);
+
+static int __init vt_init(void)
+{
+	int r;
+
+	r = vmx_init();
+	if (r)
+		return r;
+
+	/*
+	 * Common KVM initialization _must_ come last, after this, /dev/kvm is
+	 * exposed to userspace!
+	 */
+	r = kvm_init(sizeof(struct vcpu_vmx), __alignof__(struct vcpu_vmx),
+		     THIS_MODULE);
+	if (r)
+		goto err_kvm_init;
+
+	return 0;
+
+err_kvm_init:
+	vmx_exit();
+	return r;
+}
+module_init(vt_init);
arch/x86/kvm/vmx/vmx.c +2 -21
index 0f008f5ef6f0..90d8d86ba355 100644
@@ -8602,23 +8602,16 @@ static void vmx_cleanup_l1d_flush(void)
 	l1tf_vmx_mitigation = VMENTER_L1D_FLUSH_AUTO;
 }
 
-static void __vmx_exit(void)
+void vmx_exit(void)
 {
 	allow_smaller_maxphyaddr = false;
 
 	vmx_cleanup_l1d_flush();
-}
 
-static void vmx_exit(void)
-{
-	kvm_exit();
-	__vmx_exit();
 	kvm_x86_vendor_exit();
-
 }
-module_exit(vmx_exit);
 
-static int __init vmx_init(void)
+int __init vmx_init(void)
 {
 	int r, cpu;
 
@@ -8662,21 +8655,9 @@ static int __init vmx_init(void)
 	if (!enable_ept)
 		allow_smaller_maxphyaddr = true;
 
-	/*
-	 * Common KVM initialization _must_ come last, after this, /dev/kvm is
-	 * exposed to userspace!
-	 */
-	r = kvm_init(sizeof(struct vcpu_vmx), __alignof__(struct vcpu_vmx),
-		     THIS_MODULE);
-	if (r)
-		goto err_kvm_init;
-
 	return 0;
 
-err_kvm_init:
-	__vmx_exit();
 err_l1d_flush:
 	kvm_x86_vendor_exit();
 	return r;
 }
-module_init(vmx_init);
arch/x86/kvm/vmx/vmx.h +3 -0
index 43f573f6ca46..1813caac1cea 100644
@@ -756,4 +756,7 @@ static inline void vmx_segment_cache_clear(struct vcpu_vmx *vmx)
 	vmx->segment_cache.bitmask = 0;
 }
 
+int vmx_init(void);
+void vmx_exit(void);
+
 #endif /* __KVM_X86_VMX_H */
Signature · 1 line
2.46.2
author
#2 lore raw

PATCH v2 2/3 KVM: Export hardware virtualization enabling/disabling functions

In reply to Kai Huang

To support TDX, KVM will need to enable TDX during KVM module loading time. Enabling TDX requires enabling hardware virtualization first so that all online CPUs (and the new CPU going online) are in post-VMXON state.

KVM by default enables hardware virtualization but that is done in kvm_init(), which must be the last step after all initialization is done thus is too late for enabling TDX.

Export functions to enable/disable hardware virtualization so that TDX code can use them to handle hardware virtualization enabling before kvm_init().

---
 include/linux/kvm_host.h |  8 ++++++++
 virt/kvm/kvm_main.c      | 18 ++++--------------
 2 files changed, 12 insertions(+), 14 deletions(-)
include/linux/kvm_host.h +8 -0
index 401439bb21e3..6bb564c976e8 100644
@@ -2553,4 +2553,12 @@ long kvm_arch_vcpu_pre_fault_memory(struct kvm_vcpu *vcpu,
 				    struct kvm_pre_fault_memory *range);
 #endif
 
+#ifdef CONFIG_KVM_GENERIC_HARDWARE_ENABLING
+int kvm_enable_virtualization(void);
+void kvm_disable_virtualization(void);
+#else
+static inline int kvm_enable_virtualization(void) { return 0; }
+static inline void kvm_disable_virtualization(void) { }
+#endif
+
 #endif
virt/kvm/kvm_main.c +4 -14
index 22c145a99efe..e625e43c15c9 100644
@@ -143,8 +143,6 @@ static int kvm_no_compat_open(struct inode *inode, struct file *file)
 #define KVM_COMPAT(c)	.compat_ioctl	= kvm_no_compat_ioctl,	\
 			.open		= kvm_no_compat_open
 #endif
-static int kvm_enable_virtualization(void);
-static void kvm_disable_virtualization(void);
 
 static void kvm_io_bus_destroy(struct kvm_io_bus *bus);
 
@@ -5538,7 +5536,7 @@ static struct syscore_ops kvm_syscore_ops = {
 	.shutdown = kvm_shutdown,
 };
 
-static int kvm_enable_virtualization(void)
+int kvm_enable_virtualization(void)
 {
 	int r;
 
@@ -5583,8 +5581,9 @@ static int kvm_enable_virtualization(void)
 	--kvm_usage_count;
 	return r;
 }
+EXPORT_SYMBOL_GPL(kvm_enable_virtualization);
 
-static void kvm_disable_virtualization(void)
+void kvm_disable_virtualization(void)
 {
 	guard(mutex)(&kvm_usage_lock);
 
@@ -5595,6 +5594,7 @@ static void kvm_disable_virtualization(void)
 	cpuhp_remove_state(CPUHP_AP_KVM_ONLINE);
 	kvm_arch_disable_virtualization();
 }
+EXPORT_SYMBOL_GPL(kvm_disable_virtualization);
 
 static int kvm_init_virtualization(void)
 {
@@ -5610,21 +5610,11 @@ static void kvm_uninit_virtualization(void)
 		kvm_disable_virtualization();
 }
 #else /* CONFIG_KVM_GENERIC_HARDWARE_ENABLING */
-static int kvm_enable_virtualization(void)
-{
-	return 0;
-}
-
 static int kvm_init_virtualization(void)
 {
 	return 0;
 }
 
-static void kvm_disable_virtualization(void)
-{
-
-}
-
 static void kvm_uninit_virtualization(void)
 {
 
Signature · 1 line
2.46.2
author
#3 lore raw

PATCH v2 3/3 KVM: VMX: Initialize TDX during KVM module load

In reply to Kai Huang

Before KVM can use TDX to create and run TDX guests, TDX needs to be initialized from two perspectives: 1) TDX module must be initialized properly to a working state; 2) A per-cpu TDX initialization, a.k.a the TDH.SYS.LP.INIT SEAMCALL must be done on any logical cpu before it can run any other TDX SEAMCALLs.

The TDX host core-kernel provides two functions to do the above two
respectively: tdx_enable() and tdx_cpu_enable().

There are two options in terms of when to initialize TDX: initialize TDX at KVM module loading time, or when creating the first TDX guest.

Choose to initialize TDX during KVM module loading time:

Initializing TDX module is both memory and CPU time consuming: 1) the kernel needs to allocate a non-trivial size(~1/256) of system memory as metadata used by TDX module to track each TDX-usable memory page's status; 2) the TDX module needs to initialize this metadata, one entry for each TDX-usable memory page.

Also, the kernel uses alloc_contig_pages() to allocate those metadata chunks, because they are large and need to be physically contiguous. alloc_contig_pages() can fail. If initializing TDX when creating the first TDX guest, then there's chance that KVM won't be able to run any TDX guests albeit KVM _declares_ to be able to support TDX.

This isn't good for the user.

On the other hand, initializing TDX at KVM module loading time can make sure KVM is providing a consistent view of whether KVM can support TDX to the user.

Always only try to initialize TDX after VMX has been initialized. TDX is based on VMX, and if VMX fails to initialize then TDX is likely to be broken anyway. Also, in practice, supporting TDX will require part of VMX and common x86 infrastructure in working order, so TDX cannot be enabled alone w/o VMX support.

There are two cases that can result in failure to initialize TDX: 1) TDX cannot be supported (e.g., because of TDX is not supported or enabled by hardware, or module is not loaded, or missing some dependency in KVM's configuration); 2) Any unexpected error during TDX bring-up. For the first case only mark TDX is disabled but still allow KVM module to be loaded. For the second case just fail to load the KVM module so that the user can be aware.

Because TDX costs additional memory, don't enable TDX by default. Add a new module parameter 'enable_tdx' to allow the user to opt-in.

Note, the name tdx_init() has already been taken by the early boot code. Use tdx_bringup() for initializing TDX (and tdx_cleanup() since KVM doesn't actually teardown TDX). They don't match vt_init()/vt_exit(), vmx_init()/vmx_exit() etc but it's not end of the world.

Also, once initialized, the TDX module cannot be disabled and enabled again w/o the TDX module runtime update, which isn't supported by the kernel. After TDX is enabled, nothing needs to be done when KVM disables hardware virtualization, e.g., when offlining CPU, or during suspend/resume. TDX host core-kernel code internally tracks TDX status and can handle "multiple enabling" scenario.

Similar to KVM_AMD_SEV, add a new KVM_INTEL_TDX Kconfig to guide KVM TDX code. Make it depend on INTEL_TDX_HOST but not replace INTEL_TDX_HOST because in the longer term there's a use case that requires making SEAMCALLs w/o KVM as mentioned by Dan [1].

---
 arch/x86/kvm/Kconfig    |  10 +++
 arch/x86/kvm/Makefile   |   1 +
 arch/x86/kvm/vmx/main.c |   9 +++
 arch/x86/kvm/vmx/tdx.c  | 153 ++++++++++++++++++++++++++++++++++++++++
 arch/x86/kvm/vmx/tdx.h  |  13 ++++
 5 files changed, 186 insertions(+)
 create mode 100644 arch/x86/kvm/vmx/tdx.c
 create mode 100644 arch/x86/kvm/vmx/tdx.h
arch/x86/kvm/Kconfig +10 -0
index d93af5390341..e6da1b4ff3d2 100644
@@ -128,6 +128,16 @@ config X86_SGX_KVM
 
 	  If unsure, say N.
 
+config KVM_INTEL_TDX
+	bool "Intel Trust Domain Extensions (TDX) support"
+	default y
+	depends on INTEL_TDX_HOST
+	help
+	  Provides support for launching Intel Trust Domain Extensions (TDX)
+	  confidential VMs on Intel processors.
+
+	  If unsure, say N.
+
 config KVM_AMD
 	tristate "KVM for AMD processors support"
 	depends on KVM && (CPU_SUP_AMD || CPU_SUP_HYGON)
arch/x86/kvm/Makefile +1 -0
index f9dddb8cb466..a5d362c7b504 100644
@@ -20,6 +20,7 @@ kvm-intel-y		+= vmx/vmx.o vmx/vmenter.o vmx/pmu_intel.o vmx/vmcs12.o \
 
 kvm-intel-$(CONFIG_X86_SGX_KVM)	+= vmx/sgx.o
 kvm-intel-$(CONFIG_KVM_HYPERV)	+= vmx/hyperv.o vmx/hyperv_evmcs.o
+kvm-intel-$(CONFIG_KVM_INTEL_TDX)	+= vmx/tdx.o
 
 kvm-amd-y		+= svm/svm.o svm/vmenter.o svm/pmu.o svm/nested.o svm/avic.o
 
arch/x86/kvm/vmx/main.c +9 -0
index 6772e560ac7b..bc690c63e511 100644
@@ -6,6 +6,7 @@
 #include "nested.h"
 #include "pmu.h"
 #include "posted_intr.h"
+#include "tdx.h"
 
 #define VMX_REQUIRED_APICV_INHIBITS				\
 	(BIT(APICV_INHIBIT_REASON_DISABLED) |			\
@@ -171,6 +172,7 @@ struct kvm_x86_init_ops vt_init_ops __initdata = {
 static void vt_exit(void)
 {
 	kvm_exit();
+	tdx_cleanup();
 	vmx_exit();
 }
 module_exit(vt_exit);
@@ -183,6 +185,11 @@ static int __init vt_init(void)
 	if (r)
 		return r;
 
+	/* tdx_init() has been taken */
+	r = tdx_bringup();
+	if (r)
+		goto err_tdx_bringup;
+
 	/*
 	 * Common KVM initialization _must_ come last, after this, /dev/kvm is
 	 * exposed to userspace!
@@ -195,6 +202,8 @@ static int __init vt_init(void)
 	return 0;
 
 err_kvm_init:
+	tdx_cleanup();
+err_tdx_bringup:
 	vmx_exit();
 	return r;
 }
arch/x86/kvm/vmx/tdx.c new file +153 -0

153 lines not on this page · raw message

arch/x86/kvm/vmx/tdx.h new file +13 -0
new file mode 100644
index 000000000000..8aee938a968f
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef __KVM_X86_VMX_TDX_H
+#define __KVM_X86_VMX_TDX_H
+
+#ifdef CONFIG_INTEL_TDX_HOST
+int tdx_bringup(void);
+void tdx_cleanup(void);
+#else
+static inline int tdx_bringup(void) { return 0; }
+static inline void tdx_cleanup(void) {}
+#endif
+
+#endif
Signature · 1 line
2.46.2
#4 lore raw

Re: [PATCH v2 3/3] KVM: VMX: Initialize TDX during KVM module load

arch/x86/kvm/vmx/tdx.c line 26

Quoted 11 lines
arch/x86/kvm/vmx/tdx.c new file +11 -0
+static int tdx_online_cpu(unsigned int cpu)
+{
+	unsigned long flags;
+	int r;
+
+	/* Sanity check CPU is already in post-VMXON */
+	WARN_ON_ONCE(!(cr4_read_shadow() & X86_CR4_VMXE));
+
+	local_irq_save(flags);
+	r = tdx_cpu_enable();
+	local_irq_restore(flags);

The comment above tdx_cpu_enable() is outdated because now it may be called from CPU hotplug rather than IPI function calls only.

Can we relax the assertion lockdep_assert_irqs_disabled() in tdx_cpu_enable()? looks the requirement is just the enabling work won't be migrated and done to another CPU.

Quoted 15 lines
arch/x86/kvm/vmx/tdx.c new file +15 -0
+
+	return r;
+}
+
+static void __do_tdx_cleanup(void)
+{
+	/*
+	 * Once TDX module is initialized, it cannot be disabled and
+	 * re-initialized again w/o runtime update (which isn't
+	 * supported by kernel).  Only need to remove the cpuhp here.
+	 * The TDX host core code tracks TDX status and can handle
+	 * 'multiple enabling' scenario.
+	 */
+	WARN_ON_ONCE(!tdx_cpuhp_state);
+	cpuhp_remove_state_nocalls(tdx_cpuhp_state);

...

Quoted 13 lines
arch/x86/kvm/vmx/tdx.c new file +13 -0
+	tdx_cpuhp_state = 0;
+}
+
+static int __init __do_tdx_bringup(void)
+{
+	int r;
+
+	/*
+	 * TDX-specific cpuhp callback to call tdx_cpu_enable() on all
+	 * online CPUs before calling tdx_enable(), and on any new
+	 * going-online CPU to make sure it is ready for TDX guest.
+	 */
+	r = cpuhp_setup_state_cpuslocked(CPUHP_AP_ONLINE_DYN,

arch/x86/kvm/vmx/tdx.c line 64

Quoted 10 lines
arch/x86/kvm/vmx/tdx.c new file +10 -0
+					 "kvm/cpu/tdx:online",
+					 tdx_online_cpu, NULL);
+	if (r < 0)
+		return r;
+
+	tdx_cpuhp_state = r;
+
+	r = tdx_enable();
+	if (r)
+		__do_tdx_cleanup();

this calls cpuhp_remove_state_nocalls(), which acquires cpu locks again, causing a potential deadlock IIUC.

arch/x86/kvm/vmx/tdx.c line 69

Quoted 5 lines
arch/x86/kvm/vmx/tdx.c new file +5 -0
+
+	return r;
+}
+
+static bool __init kvm_can_support_tdx(void)

I think "static __init bool" is the preferred order. see

https://www.kernel.org/doc/html/latest/process/coding-style.html#function-prototypes

Quoted 17 lines
arch/x86/kvm/vmx/tdx.c new file +17 -0
+{
+	return cpu_feature_enabled(X86_FEATURE_TDX_HOST_PLATFORM);
+}
+
+static int __init __tdx_bringup(void)
+{
+	int r;
+
+	/*
+	 * Enabling TDX requires enabling hardware virtualization first,
+	 * as making SEAMCALLs requires CPU being in post-VMXON state.
+	 */
+	r = kvm_enable_virtualization();
+	if (r)
+		return r;
+
+	cpus_read_lock();

arch/x86/kvm/vmx/tdx.c line 96

Quoted 10 lines
arch/x86/kvm/vmx/tdx.c new file +10 -0
+	r = __do_tdx_bringup();
+	cpus_read_unlock();
+
+	if (r)
+		goto tdx_bringup_err;
+
+	/*
+	 * Leave hardware virtualization enabled after TDX is enabled
+	 * successfully.  TDX CPU hotplug depends on this.
+	 */

Shouldn't we make enable_tdx dependent on enable_virt_at_load? Otherwise, if someone sets enable_tdx=1 and enable_virt_at_load=0, they will get hardware virtualization enabled at load time while enable_virt_at_load still shows 0. This behavior is a bit confusing to me.

I think a check against enable_virt_at_load in kvm_can_support_tdx() will work.

The call of kvm_enable_virtualization() here effectively moves kvm_init_virtualization() out of kvm_init() when enable_tdx=1. I wonder if it makes more sense to refactor out kvm_init_virtualization() for non-TDX cases as well, i.e.,

  vmx_init();
  kvm_init_virtualization();
  tdx_init();
  kvm_init();

I'm not sure if this was ever discussed. To me, this approach is better because TDX code needn't handle virtualization enabling stuff. It can simply check that enable_virt_at_load=1, assume virtualization is enabled and needn't disable virtualization on errors.

A bonus is that on non-TDX-capable systems, hardware virtualization won't be toggled twice at KVM load time for no good reason.

Quoted 5 lines
arch/x86/kvm/vmx/tdx.c new file +5 -0
+	return 0;
+tdx_bringup_err:
+	kvm_disable_virtualization();
+	return r;
+}
author
#5 lore raw

Re: [PATCH v2 3/3] KVM: VMX: Initialize TDX during KVM module load

Quoted 15 lines · Chao Gao

arch/x86/kvm/vmx/tdx.c line 26

Quoted 11 lines
arch/x86/kvm/vmx/tdx.c new file +11 -0
+static int tdx_online_cpu(unsigned int cpu)
+{
+	unsigned long flags;
+	int r;
+
+	/* Sanity check CPU is already in post-VMXON */
+	WARN_ON_ONCE(!(cr4_read_shadow() & X86_CR4_VMXE));
+
+	local_irq_save(flags);
+	r = tdx_cpu_enable();
+	local_irq_restore(flags);

The comment above tdx_cpu_enable() is outdated because now it may be called from CPU hotplug rather than IPI function calls only.

Quoted 3 lines

Can we relax the assertion lockdep_assert_irqs_disabled() in tdx_cpu_enable()? looks the requirement is just the enabling work won't be migrated and done to another CPU.

We can but I don't want to do it now. We will need to revist both tdx_cpu_enable() and tdx_enable() when we move VMXON out of KVM anyway. I would like to focus on bringing KVM TDX support first and then to revisit them together at that timeframe.

Quoted 37 lines
Quoted 16 lines
arch/x86/kvm/vmx/tdx.c new file +15 -0
+
+	return r;
+}
+
+static void __do_tdx_cleanup(void)
+{
+	/*
+	 * Once TDX module is initialized, it cannot be disabled and
+	 * re-initialized again w/o runtime update (which isn't
+	 * supported by kernel).  Only need to remove the cpuhp here.
+	 * The TDX host core code tracks TDX status and can handle
+	 * 'multiple enabling' scenario.
+	 */
+	WARN_ON_ONCE(!tdx_cpuhp_state);
+	cpuhp_remove_state_nocalls(tdx_cpuhp_state);

...

Quoted 18 lines
arch/x86/kvm/vmx/tdx.c new file +18 -0
+	tdx_cpuhp_state = 0;
+}
+
+static int __init __do_tdx_bringup(void)
+{
+	int r;
+
+	/*
+	 * TDX-specific cpuhp callback to call tdx_cpu_enable() on all
+	 * online CPUs before calling tdx_enable(), and on any new
+	 * going-online CPU to make sure it is ready for TDX guest.
+	 */
+	r = cpuhp_setup_state_cpuslocked(CPUHP_AP_ONLINE_DYN,
+					 "kvm/cpu/tdx:online",
+					 tdx_online_cpu, NULL);
+	if (r < 0)
+		return r;
+
Quoted 8 lines

arch/x86/kvm/vmx/tdx.c line 64

Quoted 5 lines
arch/x86/kvm/vmx/tdx.c new file +5 -0
+	tdx_cpuhp_state = r;
+
+	r = tdx_enable();
+	if (r)
+		__do_tdx_cleanup();

this calls cpuhp_remove_state_nocalls(), which acquires cpu locks again, causing a potential deadlock IIUC.

Dam.. I'll fix. Thanks for catching.

Quoted 10 lines

arch/x86/kvm/vmx/tdx.c line 69

Quoted 6 lines
arch/x86/kvm/vmx/tdx.c new file +5 -0
+
+	return r;
+}
+
+static bool __init kvm_can_support_tdx(void)

I think "static __init bool" is the preferred order. see

https://www.kernel.org/doc/html/latest/process/coding-style.html#function-prototypes

I think you are right, but IIUC we'd better to change all the existing 'static <ret_type> __init' to 'static __init <ret_type>' in KVM code. I'd rather to keep the current way to make them aligned and we can change them at once if needed in the future.

Quoted 46 lines
Quoted 18 lines
arch/x86/kvm/vmx/tdx.c new file +17 -0
+{
+	return cpu_feature_enabled(X86_FEATURE_TDX_HOST_PLATFORM);
+}
+
+static int __init __tdx_bringup(void)
+{
+	int r;
+
+	/*
+	 * Enabling TDX requires enabling hardware virtualization first,
+	 * as making SEAMCALLs requires CPU being in post-VMXON state.
+	 */
+	r = kvm_enable_virtualization();
+	if (r)
+		return r;
+
+	cpus_read_lock();

arch/x86/kvm/vmx/tdx.c line 96

Quoted 10 lines
arch/x86/kvm/vmx/tdx.c new file +10 -0
+	r = __do_tdx_bringup();
+	cpus_read_unlock();
+
+	if (r)
+		goto tdx_bringup_err;
+
+	/*
+	 * Leave hardware virtualization enabled after TDX is enabled
+	 * successfully.  TDX CPU hotplug depends on this.
+	 */

Shouldn't we make enable_tdx dependent on enable_virt_at_load? Otherwise, if someone sets enable_tdx=1 and enable_virt_at_load=0, they will get hardware virtualization enabled at load time while enable_virt_at_load still shows 0. This behavior is a bit confusing to me.

I think a check against enable_virt_at_load in kvm_can_support_tdx() will work.

The call of kvm_enable_virtualization() here effectively moves kvm_init_virtualization() out of kvm_init() when enable_tdx=1. I wonder if it makes more sense to refactor out kvm_init_virtualization() for non-TDX cases as well, i.e.,

   vmx_init();
   kvm_init_virtualization();
   tdx_init();
   kvm_init();
Quoted 4 lines

I'm not sure if this was ever discussed. To me, this approach is better because TDX code needn't handle virtualization enabling stuff. It can simply check that enable_virt_at_load=1, assume virtualization is enabled and needn't disable virtualization on errors.

I think this was briefly discussed here:

https://lore.kernel.org/all/[email protected]/

The disadvantage of splitting out kvm_init_virtualization() is all other ARCHs (all non-TDX cases actually) will need to explicitly call kvm_init_virtualization() separately.

Quoted 3 lines

A bonus is that on non-TDX-capable systems, hardware virtualization won't be toggled twice at KVM load time for no good reason.

I am fine with either way.

Sean, do you have any comments?

author
#6 lore raw

Re: [PATCH v2 3/3] KVM: VMX: Initialize TDX during KVM module load

Quoted 5 lines
Quoted 5 lines

Shouldn't we make enable_tdx dependent on enable_virt_at_load? Otherwise, if someone sets enable_tdx=1 and enable_virt_at_load=0, they will get hardware virtualization enabled at load time while enable_virt_at_load still shows 0. This behavior is a bit confusing to me.

Forgot to reply this ...

Quoted 25 lines
Quoted 13 lines

I think a check against enable_virt_at_load in kvm_can_support_tdx() will work.

The call of kvm_enable_virtualization() here effectively moves kvm_init_virtualization() out of kvm_init() when enable_tdx=1. I wonder if it makes more sense to refactor out kvm_init_virtualization() for non-TDX cases as well, i.e.,

   vmx_init();
   kvm_init_virtualization();
   tdx_init();
   kvm_init();

Quoted 4 lines

I'm not sure if this was ever discussed. To me, this approach is better because TDX code needn't handle virtualization enabling stuff. It can simply check that enable_virt_at_load=1, assume virtualization is enabled and needn't disable virtualization on errors.

I think this was briefly discussed here:

https://lore.kernel.org/all/[email protected]/

The disadvantage of splitting out kvm_init_virtualization() is all other ARCHs (all non-TDX cases actually) will need to explicitly call kvm_init_virtualization() separately.

Quoted 1 line
Quoted 7 lines
Quoted 2 lines

A bonus is that on non-TDX-capable systems, hardware virtualization won't be toggled twice at KVM load time for no good reason.

I am fine with either way.

Sean, do you have any comments?

... and yes I think we should make TDX depend on 'enable_virt_at_load'.

And by doing this, I think we can still do kvm_init_virtualization() inside kvm_init():

'enable_virt_at_load' still reflects its behaviour -- TDX just enables virt earlier than other cases, but it is still "enable virt at load".

It's perhaps not perfect, but it saves unneeded separate call of kvm_init_virtualization() for other ARCHs.