On 7/23/2026 7:13 AM, Lisa Wang wrote:
From: Ackerley Tng <[email protected]>
TDX protected memory needs to be measured and encrypted before it can be
used by the guest. Traverse the VM's memory regions and initialize all
the protected ranges by calling KVM_TDX_INIT_MEM_REGION.
Once all the memory is initialized, the VM can be finalized by calling
KVM_TDX_FINALIZE_VM.
Signed-off-by: Ackerley Tng <[email protected]>
Co-developed-by: Erdem Aktas <[email protected]>
Signed-off-by: Erdem Aktas <[email protected]>
Co-developed-by: Sagi Shahar <[email protected]>
Signed-off-by: Sagi Shahar <[email protected]>
Reviewed-by: Binbin Wu <[email protected]>
Reviewed-by: Ira Weiny <[email protected]>
Co-developed-by: Lisa Wang <[email protected]>
Signed-off-by: Lisa Wang <[email protected]>
---
.../selftests/kvm/include/x86/tdx/tdx_util.h | 2 +
tools/testing/selftests/kvm/lib/x86/tdx/tdx_util.c | 63 ++++++++++++++++++++++
2 files changed, 65 insertions(+)
diff --git a/tools/testing/selftests/kvm/include/x86/tdx/tdx_util.h
b/tools/testing/selftests/kvm/include/x86/tdx/tdx_util.h
index 307e2c0bc9c9..35f0b2b7ac40 100644
--- a/tools/testing/selftests/kvm/include/x86/tdx/tdx_util.h
+++ b/tools/testing/selftests/kvm/include/x86/tdx/tdx_util.h
@@ -72,4 +72,6 @@ void tdx_vm_load_common_boot_parameters(struct kvm_vm *vm);
void tdx_vcpu_load_boot_parameters(struct kvm_vm *vm, struct kvm_vcpu *vcpu);
void tdx_vcpu_set_entry_point(struct kvm_vcpu *vcpu, void *guest_code);
+void tdx_vm_finalize(struct kvm_vm *vm);
+
#endif /* SELFTESTS_TDX_TDX_UTIL_H */
diff --git a/tools/testing/selftests/kvm/lib/x86/tdx/tdx_util.c
b/tools/testing/selftests/kvm/lib/x86/tdx/tdx_util.c
index be63d8652a02..831b0e5160df 100644
--- a/tools/testing/selftests/kvm/lib/x86/tdx/tdx_util.c
+++ b/tools/testing/selftests/kvm/lib/x86/tdx/tdx_util.c
@@ -1,5 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-only
+#include <linux/align.h>
+
#include "processor.h"
#include "tdx/td_boot.h"
#include "tdx/tdx_util.h"
@@ -251,3 +253,64 @@ void tdx_init_vm(struct kvm_vm *vm, u64 attributes)
free(init_vm);
}
+
+static void tdx_init_mem_region(struct kvm_vm *vm, void *source_pages,
+ u64 gpa, u64 size)
+{
+ u32 flags = KVM_TDX_MEASURE_MEMORY_REGION;
+ struct kvm_tdx_init_mem_region mem_region = {
+ .source_addr = (u64)source_pages,
+ .gpa = gpa,
+ .nr_pages = size / PAGE_SIZE,
+ };
+ struct kvm_vcpu *vcpu;
+
+ vcpu = list_first_entry_or_null(&vm->vcpus, struct kvm_vcpu, list);
+
+ TEST_ASSERT(size && IS_ALIGNED(size, PAGE_SIZE),
+ "Cannot add partial pages to the guest memory.\n");
+ TEST_ASSERT(IS_ALIGNED((u64)source_pages, PAGE_SIZE),
+ "Source memory buffer is not page aligned\n");
+ tdx_vcpu_ioctl(vcpu, KVM_TDX_INIT_MEM_REGION, flags, &mem_region);
+}
+
+static void tdx_load_private_memory(struct kvm_vm *vm)
+{
+ struct userspace_mem_region *region;
+ int ctr;
+
+ hash_for_each(vm->regions.slot_hash, ctr, region, slot_node) {
+ const struct sparsebit *protected_pages =
region->protected_phy_pages;
+ const gpa_t gpa_base = region->region.guest_phys_addr;
+ const u64 hva_base = region->region.userspace_addr;
+ const sparsebit_idx_t lowest_page_in_region = gpa_base >>
vm->page_shift;
+ void *source_pages = NULL;
+ sparsebit_idx_t i, j;
+
+ if (!sparsebit_any_set(protected_pages))
sparebit_any_set() doens't check if the input is NULL. So we need to
check it here.
+ continue;
+
+ TEST_ASSERT(region->region.guest_memfd != -1,
+ "TD private memory must be backed by guest_memfd");
+
+ sparsebit_for_each_set_range(protected_pages, i, j) {
+ const u64 size_to_load = (j - i + 1) * vm->page_size;
+ const u64 offset =
+ (i - lowest_page_in_region) * vm->page_size;
+ const u64 hva = hva_base + offset;
+ const u64 gpa = gpa_base + offset;
+
+ if (!kvm_has_gmem_attributes)
+ source_pages = (void *)hva;
+
+ vm_mem_set_private(vm, gpa, size_to_load);
So vm_mem_set_private() has to be called at this late stage when run
with in-place gmem. But for non in-place gmem, we can actually call
vm_mem_set_private() in __vm_phy_pages_alloc().
Calling vm_mem_set_private() here instead of in __vm_phy_pages_alloc()
looks like a trick to me. That is, we cannot set the page as private
when allocating a guest physical page as protected because if doing so,
we cannot write the initial content to it.
This is the topic about how to implement the infras for in-place gmem,
not the issue of this series. Let me go read the selftest patches of
gmem in-place series and we can discuss there.
+ tdx_init_mem_region(vm, source_pages, gpa,
size_to_load);
+ }
+ }
+}
+
+void tdx_vm_finalize(struct kvm_vm *vm)
+{
+ tdx_load_private_memory(vm);
+ tdx_vm_ioctl(vm, KVM_TDX_FINALIZE_VM, 0, NULL);
+}
