On 12/12/2023 12:46 PM, Sagi Shahar wrote:

From: Ackerley Tng ackerleytng@google.com

One-to-one GVA to GPA mappings can be used in the guest to set up boot sequences during which paging is enabled, hence requiring a transition from using physical to virtual addresses in consecutive instructions.

Signed-off-by: Ackerley Tng ackerleytng@google.com Signed-off-by: Ryan Afranji afranji@google.com Signed-off-by: Sagi Shahar sagis@google.com

---

.../selftests/kvm/include/kvm_util_base.h | 2 + tools/testing/selftests/kvm/lib/kvm_util.c | 63 ++++++++++++++++--- 2 files changed, 55 insertions(+), 10 deletions(-)

diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/testing/selftests/kvm/include/kvm_util_base.h index 1426e88ebdc7..c2e5c5f25dfc 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -564,6 +564,8 @@ vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min); vm_vaddr_t __vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min, enum kvm_mem_region_type type); vm_vaddr_t vm_vaddr_alloc_shared(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min); +vm_vaddr_t vm_vaddr_alloc_1to1(struct kvm_vm *vm, size_t sz,

• 	       vm_vaddr_t vaddr_min, uint32_t data_memslot);
  

vm_vaddr_t vm_vaddr_alloc_pages(struct kvm_vm *vm, int nr_pages); vm_vaddr_t __vm_vaddr_alloc_page(struct kvm_vm *vm, enum kvm_mem_region_type type); diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c index febc63d7a46b..4f1ae0f1eef0 100644 --- a/tools/testing/selftests/kvm/lib/kvm_util.c +++ b/tools/testing/selftests/kvm/lib/kvm_util.c @@ -1388,17 +1388,37 @@ vm_vaddr_t vm_vaddr_unused_gap(struct kvm_vm *vm, size_t sz, return pgidx_start * vm->page_size; } +/*

• • VM Virtual Address Allocate Shared/Encrypted
• • Input Args:
• • vm - Virtual Machine
• • sz - Size in bytes
• • vaddr_min - Minimum starting virtual address
• • paddr_min - Minimum starting physical address
• • data_memslot - memslot number to allocate in
• • encrypt - Whether the region should be handled as encrypted
• • Output Args: None
• • Return:
• • Starting guest virtual address
• • Allocates at least sz bytes within the virtual address space of the vm
• • given by vm. The allocated bytes are mapped to a virtual address >=
• • the address given by vaddr_min. Note that each allocation uses a
• • a unique set of pages, with the minimum real allocation being at least
• • a page.
• */

static vm_vaddr_t ____vm_vaddr_alloc(struct kvm_vm *vm, size_t sz,

• 		     vm_vaddr_t vaddr_min,
  

• 		     enum kvm_mem_region_type type,
  

• 		     bool encrypt)
  

• 		     vm_vaddr_t vaddr_min, vm_paddr_t paddr_min,
  

• 		     uint32_t data_memslot, bool encrypt)
  

{ uint64_t pages = (sz >> vm->page_shift) + ((sz % vm->page_size) != 0); virt_pgd_alloc(vm);

• vm_paddr_t paddr = _vm_phy_pages_alloc(vm, pages,

• 			      KVM_UTIL_MIN_PFN * vm->page_size,
  

• 			      vm->memslots[type], encrypt);
  

• vm_paddr_t paddr = _vm_phy_pages_alloc(vm, pages, paddr_min,

• 			       data_memslot, encrypt);
  

/* * Find an unused range of virtual page addresses of at least @@ -1408,8 +1428,7 @@ static vm_vaddr_t ____vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, /* Map the virtual pages. */ for (vm_vaddr_t vaddr = vaddr_start; pages > 0;

• pages--, vaddr += vm->page_size, paddr += vm->page_size) {
  

•     pages--, vaddr += vm->page_size, paddr += vm->page_size) {
  

  virt_pg_map(vm, vaddr, paddr);

sparsebit_set(vm->vpages_mapped, vaddr >> vm->page_shift); @@ -1421,12 +1440,16 @@ static vm_vaddr_t ____vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t __vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min, enum kvm_mem_region_type type) {

• return ____vm_vaddr_alloc(vm, sz, vaddr_min, type, vm->protected);

• return ____vm_vaddr_alloc(vm, sz, vaddr_min,

• 		  KVM_UTIL_MIN_PFN * vm->page_size,
  

• 		  vm->memslots[type], vm->protected);
  

} vm_vaddr_t vm_vaddr_alloc_shared(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min) {

• return ____vm_vaddr_alloc(vm, sz, vaddr_min, MEM_REGION_TEST_DATA, false);

• return ____vm_vaddr_alloc(vm, sz, vaddr_min,

• 		  KVM_UTIL_MIN_PFN * vm->page_size,
  

• 		  vm->memslots[MEM_REGION_TEST_DATA], false);
  

} /* @@ -1453,6 +1476,26 @@ vm_vaddr_t vm_vaddr_alloc(struct kvm_vm *vm, size_t sz, vm_vaddr_t vaddr_min) return __vm_vaddr_alloc(vm, sz, vaddr_min, MEM_REGION_TEST_DATA); } +/**

• • Allocate memory in @vm of size @sz in memslot with id @data_memslot,
• • beginning with the desired address of @vaddr_min.
• • If there isn't enough memory at @vaddr_min, find the next possible address
• • that can meet the requested size in the given memslot.
• • Return the address where the memory is allocated.
• */

+vm_vaddr_t vm_vaddr_alloc_1to1(struct kvm_vm *vm, size_t sz,

• 	       vm_vaddr_t vaddr_min, uint32_t data_memslot)
  

+{

• vm_vaddr_t gva = ____vm_vaddr_alloc(vm, sz, vaddr_min,

• 			    (vm_paddr_t)vaddr_min, data_memslot,
  

• 			    vm->protected);
  

• TEST_ASSERT_EQ(gva, addr_gva2gpa(vm, gva));

By 1to1, do you mean virtual address=physical address?, community tends to call this identity mapping. Examples (function name): create_identity_mapping_pagetables() hellcreek_setup_tc_identity_mapping() identity_mapping_add()

• return gva;

+}

/*

• VM Virtual Address Allocate Pages

On 12/13/2023 4:46 AM, Sagi Shahar wrote:

From: Ackerley Tng ackerleytng@google.com

This allows initializing sregs without setting vCPU registers in KVM.

No functional change intended.

Reviewed-by: Binbin Wu binbin.wu@linux.intel.com

Signed-off-by: Ackerley Tng ackerleytng@google.com Signed-off-by: Ryan Afranji afranji@google.com Signed-off-by: Sagi Shahar sagis@google.com

---

.../selftests/kvm/include/x86_64/processor.h | 2 + .../selftests/kvm/lib/x86_64/processor.c | 39 ++++++++++--------- 2 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/tools/testing/selftests/kvm/include/x86_64/processor.h b/tools/testing/selftests/kvm/include/x86_64/processor.h index 35fcf4d78dfa..0b8855d68744 100644 --- a/tools/testing/selftests/kvm/include/x86_64/processor.h +++ b/tools/testing/selftests/kvm/include/x86_64/processor.h @@ -958,6 +958,8 @@ static inline struct kvm_cpuid2 *allocate_kvm_cpuid2(int nr_entries) void vcpu_init_cpuid(struct kvm_vcpu *vcpu, const struct kvm_cpuid2 *cpuid); void vcpu_set_hv_cpuid(struct kvm_vcpu *vcpu); +void vcpu_setup_mode_sregs(struct kvm_vm *vm, struct kvm_sregs *sregs);

• static inline struct kvm_cpuid_entry2 *__vcpu_get_cpuid_entry(struct kvm_vcpu *vcpu, uint32_t function, uint32_t index)

diff --git a/tools/testing/selftests/kvm/lib/x86_64/processor.c b/tools/testing/selftests/kvm/lib/x86_64/processor.c index aef1c021c4bb..f130f78a4974 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/processor.c +++ b/tools/testing/selftests/kvm/lib/x86_64/processor.c @@ -543,36 +543,39 @@ static void kvm_setup_tss_64bit(struct kvm_vm *vm, struct kvm_segment *segp, kvm_seg_fill_gdt_64bit(vm, segp); } -static void vcpu_setup(struct kvm_vm *vm, struct kvm_vcpu *vcpu) +void vcpu_setup_mode_sregs(struct kvm_vm *vm, struct kvm_sregs *sregs) {

• struct kvm_sregs sregs;
• /* Set mode specific system register values. */
• vcpu_sregs_get(vcpu, &sregs);
• sregs.idt.limit = 0;

• sregs->idt.limit = 0;

• kvm_setup_gdt(vm, &sregs.gdt);

• kvm_setup_gdt(vm, &sregs->gdt);

switch (vm->mode) { case VM_MODE_PXXV48_4K_SEV: case VM_MODE_PXXV48_4K:

• sregs.cr0 = X86_CR0_PE | X86_CR0_NE | X86_CR0_PG;
  

• sregs.cr4 |= X86_CR4_PAE | X86_CR4_OSFXSR;
  

• sregs.efer |= (EFER_LME | EFER_LMA | EFER_NX);
  

• kvm_seg_set_unusable(&sregs.ldt);
  

• kvm_seg_set_kernel_code_64bit(vm, DEFAULT_CODE_SELECTOR, &sregs.cs);
  

• kvm_seg_set_kernel_data_64bit(vm, DEFAULT_DATA_SELECTOR, &sregs.ds);
  

• kvm_seg_set_kernel_data_64bit(vm, DEFAULT_DATA_SELECTOR, &sregs.es);
  

• kvm_setup_tss_64bit(vm, &sregs.tr, 0x18);
  

• sregs->cr0 = X86_CR0_PE | X86_CR0_NE | X86_CR0_PG;
  

• sregs->cr4 |= X86_CR4_PAE | X86_CR4_OSFXSR;
  

• sregs->efer |= (EFER_LME | EFER_LMA | EFER_NX);
  

• kvm_seg_set_unusable(&sregs->ldt);
  

• kvm_seg_set_kernel_code_64bit(vm, DEFAULT_CODE_SELECTOR, &sregs->cs);
  

• kvm_seg_set_kernel_data_64bit(vm, DEFAULT_DATA_SELECTOR, &sregs->ds);
  

• kvm_seg_set_kernel_data_64bit(vm, DEFAULT_DATA_SELECTOR, &sregs->es);
  

• kvm_setup_tss_64bit(vm, &sregs->tr, 0x18);
  

  break;

default: TEST_FAIL("Unknown guest mode, mode: 0x%x", vm->mode); }

• sregs.cr3 = vm->pgd;

• sregs->cr3 = vm->pgd;

+}

+static void vcpu_setup(struct kvm_vm *vm, struct kvm_vcpu *vcpu) +{

• struct kvm_sregs sregs;
• vcpu_sregs_get(vcpu, &sregs);
• vcpu_setup_mode_sregs(vm, &sregs); vcpu_sregs_set(vcpu, &sregs); }

On 12/13/2023 4:46 AM, Sagi Shahar wrote:

From: Ackerley Tng ackerleytng@google.com

TDX guests' registers cannot be initialized directly using vcpu_regs_set(), hence the stack pointer needs to be initialized by the guest itself, running boot code beginning at the reset vector.

We store the stack address as part of struct kvm_vcpu so that it can be accessible later to be passed to the boot code for rsp initialization.

Signed-off-by: Ackerley Tng ackerleytng@google.com Signed-off-by: Ryan Afranji afranji@google.com Signed-off-by: Sagi Shahar sagis@google.com

---

tools/testing/selftests/kvm/include/kvm_util_base.h | 1 + tools/testing/selftests/kvm/lib/x86_64/processor.c | 4 +++- 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/testing/selftests/kvm/include/kvm_util_base.h index c2e5c5f25dfc..b353617fcdd1 100644 --- a/tools/testing/selftests/kvm/include/kvm_util_base.h +++ b/tools/testing/selftests/kvm/include/kvm_util_base.h @@ -68,6 +68,7 @@ struct kvm_vcpu { int fd; struct kvm_vm *vm; struct kvm_run *run;

• vm_vaddr_t initial_stack_addr; #ifdef __x86_64__ struct kvm_cpuid2 *cpuid; #endif

diff --git a/tools/testing/selftests/kvm/lib/x86_64/processor.c b/tools/testing/selftests/kvm/lib/x86_64/processor.c index f130f78a4974..b6b9438e0a33 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/processor.c +++ b/tools/testing/selftests/kvm/lib/x86_64/processor.c @@ -621,10 +621,12 @@ struct kvm_vcpu *vm_arch_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, vcpu_init_cpuid(vcpu, kvm_get_supported_cpuid()); vcpu_setup(vm, vcpu);

• vcpu->initial_stack_addr = stack_vaddr;
• /* Setup guest general purpose registers */ vcpu_regs_get(vcpu, &regs); regs.rflags = regs.rflags | 0x2;

• regs.rsp = stack_vaddr;

• regs.rsp = vcpu->initial_stack_addr;

Nit: No need to do this change.

Reviewed-by: Binbin Wu binbin.wu@linux.intel.com

regs.rip = (unsigned long) guest_code; vcpu_regs_set(vcpu, &regs);

On 12/13/2023 4:46 AM, Sagi Shahar wrote:

From: Ackerley Tng ackerleytng@google.com

Split the vCPU descriptor table initialization process into a few steps and expose them:

• Setting up the IDT
• Syncing exception handlers into the guest

In kvm_setup_idt(), we conditionally allocate guest memory for vm->idt to avoid double allocation when kvm_setup_idt() is used after vm_init_descriptor_tables().

Signed-off-by: Ackerley Tng ackerleytng@google.com Signed-off-by: Ryan Afranji afranji@google.com Signed-off-by: Sagi Shahar sagis@google.com

---

.../selftests/kvm/include/x86_64/processor.h | 2 ++ .../selftests/kvm/lib/x86_64/processor.c | 19 ++++++++++++++++--- 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/tools/testing/selftests/kvm/include/x86_64/processor.h b/tools/testing/selftests/kvm/include/x86_64/processor.h index 0b8855d68744..5c4e9a27d9e2 100644 --- a/tools/testing/selftests/kvm/include/x86_64/processor.h +++ b/tools/testing/selftests/kvm/include/x86_64/processor.h @@ -1089,6 +1089,8 @@ struct idt_entry { uint32_t offset2; uint32_t reserved; }; +void kvm_setup_idt(struct kvm_vm *vm, struct kvm_dtable *dt); +void sync_exception_handlers_to_guest(struct kvm_vm *vm); void vm_init_descriptor_tables(struct kvm_vm *vm); void vcpu_init_descriptor_tables(struct kvm_vcpu *vcpu); void vm_install_exception_handler(struct kvm_vm *vm, int vector, diff --git a/tools/testing/selftests/kvm/lib/x86_64/processor.c b/tools/testing/selftests/kvm/lib/x86_64/processor.c index b6b9438e0a33..566d82829da4 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/processor.c +++ b/tools/testing/selftests/kvm/lib/x86_64/processor.c @@ -1155,19 +1155,32 @@ void vm_init_descriptor_tables(struct kvm_vm *vm) DEFAULT_CODE_SELECTOR); } +void kvm_setup_idt(struct kvm_vm *vm, struct kvm_dtable *dt) +{

• if (!vm->idt)

• vm->idt = vm_vaddr_alloc_page(vm);
  

IDT is allocated in DATA memslot in current code, but here, when using vm_vaddr_alloc_page(), it will be allocated in TEST_DATA memslot.

Do we need to follow the current code to use __vm_vaddr_alloc_page(vm, MEM_REGION_DATA) instead?

• dt->base = vm->idt;
• dt->limit = NUM_INTERRUPTS * sizeof(struct idt_entry) - 1;

+}

+void sync_exception_handlers_to_guest(struct kvm_vm *vm) +{

• *(vm_vaddr_t *)addr_gva2hva(vm, (vm_vaddr_t)(&exception_handlers)) = vm->handlers;

+}

• void vcpu_init_descriptor_tables(struct kvm_vcpu *vcpu) { struct kvm_vm *vm = vcpu->vm; struct kvm_sregs sregs;

vcpu_sregs_get(vcpu, &sregs);

• sregs.idt.base = vm->idt;
• sregs.idt.limit = NUM_INTERRUPTS * sizeof(struct idt_entry) - 1;

• kvm_setup_idt(vcpu->vm, &sregs.idt); sregs.gdt.base = vm->gdt; sregs.gdt.limit = getpagesize() - 1; kvm_seg_set_kernel_data_64bit(NULL, DEFAULT_DATA_SELECTOR, &sregs.gs); vcpu_sregs_set(vcpu, &sregs);

• *(vm_vaddr_t *)addr_gva2hva(vm, (vm_vaddr_t)(&exception_handlers)) = vm->handlers;

• sync_exception_handlers_to_guest(vm); }

void vm_install_exception_handler(struct kvm_vm *vm, int vector,

On 12/12/2023 12:46 PM, Sagi Shahar wrote:

From: Erdem Aktas erdemaktas@google.com

TDX requires additional IOCTLs to initialize VM and vCPUs to add private memory and to finalize the VM memory. Also additional utility functions are provided to manipulate a TD, similar to those that manipulate a VM in the current selftest framework.

A TD's initial register state cannot be manipulated directly by setting the VM's memory, hence boot code is provided at the TD's reset vector. This boot code takes boot parameters loaded in the TD's memory and sets up the TD for the selftest.

Signed-off-by: Erdem Aktas erdemaktas@google.com Signed-off-by: Ryan Afranji afranji@google.com Signed-off-by: Sagi Shahar sagis@google.com Co-developed-by: Ackerley Tng ackerleytng@google.com Signed-off-by: Ackerley Tng ackerleytng@google.com

---

tools/testing/selftests/kvm/Makefile | 2 + .../kvm/include/x86_64/tdx/td_boot.h | 82 ++++ .../kvm/include/x86_64/tdx/td_boot_asm.h | 16 + .../kvm/include/x86_64/tdx/tdx_util.h | 16 + .../selftests/kvm/lib/x86_64/tdx/td_boot.S | 101 ++++ .../selftests/kvm/lib/x86_64/tdx/tdx_util.c | 434 ++++++++++++++++++ 6 files changed, 651 insertions(+) create mode 100644 tools/testing/selftests/kvm/include/x86_64/tdx/td_boot.h create mode 100644 tools/testing/selftests/kvm/include/x86_64/tdx/td_boot_asm.h create mode 100644 tools/testing/selftests/kvm/include/x86_64/tdx/tdx_util.h create mode 100644 tools/testing/selftests/kvm/lib/x86_64/tdx/td_boot.S create mode 100644 tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c

diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile index b11ac221aba4..a35150ab855f 100644 --- a/tools/testing/selftests/kvm/Makefile +++ b/tools/testing/selftests/kvm/Makefile @@ -50,6 +50,8 @@ LIBKVM_x86_64 += lib/x86_64/svm.c LIBKVM_x86_64 += lib/x86_64/ucall.c LIBKVM_x86_64 += lib/x86_64/vmx.c LIBKVM_x86_64 += lib/x86_64/sev.c +LIBKVM_x86_64 += lib/x86_64/tdx/tdx_util.c +LIBKVM_x86_64 += lib/x86_64/tdx/td_boot.S LIBKVM_aarch64 += lib/aarch64/gic.c LIBKVM_aarch64 += lib/aarch64/gic_v3.c diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/td_boot.h b/tools/testing/selftests/kvm/include/x86_64/tdx/td_boot.h new file mode 100644 index 000000000000..148057e569d6 --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/td_boot.h @@ -0,0 +1,82 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef SELFTEST_TDX_TD_BOOT_H +#define SELFTEST_TDX_TD_BOOT_H

+#include <stdint.h> +#include "tdx/td_boot_asm.h"

+/*

• • Layout for boot section (not to scale)

• •                              GPA
    

• • ┌─────────────────────────────┬──0x1_0000_0000 (4GB)
• • │ Boot code trampoline │
• • ├─────────────────────────────┼──0x0_ffff_fff0: Reset vector (16B below 4GB)
• • │ Boot code │
• • ├─────────────────────────────┼──td_boot will be copied here, so that the
• • │ │ jmp to td_boot is exactly at the reset vector
• • │ Empty space │
• • │ │
• • ├─────────────────────────────┤
• • │ │
• • │ │
• • │ Boot parameters │
• • │ │
• • │ │
• • └─────────────────────────────┴──0x0_ffff_0000: TD_BOOT_PARAMETERS_GPA
• */

+#define FOUR_GIGABYTES_GPA (4ULL << 30)

+/**

• • The exact memory layout for LGDT or LIDT instructions.
• */

+struct __packed td_boot_parameters_dtr {

• uint16_t limit;
• uint32_t base;

+};

+/**

• • The exact layout in memory required for a ljmp, including the selector for
• • changing code segment.
• */

+struct __packed td_boot_parameters_ljmp_target {

• uint32_t eip_gva;
• uint16_t code64_sel;

+};

+/**

• • Allows each vCPU to be initialized with different eip and esp.
• */

+struct __packed td_per_vcpu_parameters {

• uint32_t esp_gva;
• struct td_boot_parameters_ljmp_target ljmp_target;

+};

+/**

• • Boot parameters for the TD.
• • Unlike a regular VM, we can't ask KVM to set registers such as esp, eip, etc
• • before boot, so to run selftests, these registers' values have to be
• • initialized by the TD.
• • This struct is loaded in TD private memory at TD_BOOT_PARAMETERS_GPA.
• • The TD boot code will read off parameters from this struct and set up the
• • vcpu for executing selftests.
• */

+struct __packed td_boot_parameters {

• uint32_t cr0;
• uint32_t cr3;
• uint32_t cr4;
• struct td_boot_parameters_dtr gdtr;
• struct td_boot_parameters_dtr idtr;
• struct td_per_vcpu_parameters per_vcpu[];

+};

+extern void td_boot(void); +extern void reset_vector(void); +extern void td_boot_code_end(void);

+#define TD_BOOT_CODE_SIZE (td_boot_code_end - td_boot)

+#endif /* SELFTEST_TDX_TD_BOOT_H */ diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/td_boot_asm.h b/tools/testing/selftests/kvm/include/x86_64/tdx/td_boot_asm.h new file mode 100644 index 000000000000..0a07104f7deb --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/td_boot_asm.h @@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef SELFTEST_TDX_TD_BOOT_ASM_H +#define SELFTEST_TDX_TD_BOOT_ASM_H

+/*

• • GPA where TD boot parameters wil lbe loaded.

Typo: "wil lbe" ==> "will be"

• • TD_BOOT_PARAMETERS_GPA is arbitrarily chosen to
• • • be within the 4GB address space
• • • provide enough contiguous memory for the struct td_boot_parameters such
• • that there is one struct td_per_vcpu_parameters for KVM_MAX_VCPUS
• */

+#define TD_BOOT_PARAMETERS_GPA 0xffff0000

+#endif // SELFTEST_TDX_TD_BOOT_ASM_H diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx_util.h b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx_util.h new file mode 100644 index 000000000000..274b245f200b --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx_util.h @@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef SELFTESTS_TDX_KVM_UTIL_H +#define SELFTESTS_TDX_KVM_UTIL_H

+#include <stdint.h>

+#include "kvm_util_base.h"

+struct kvm_vcpu *td_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, void *guest_code);

+struct kvm_vm *td_create(void); +void td_initialize(struct kvm_vm *vm, enum vm_mem_backing_src_type src_type,

•    uint64_t attributes);
  

+void td_finalize(struct kvm_vm *vm);

+#endif // SELFTESTS_TDX_KVM_UTIL_H diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/td_boot.S b/tools/testing/selftests/kvm/lib/x86_64/tdx/td_boot.S new file mode 100644 index 000000000000..800e09264d4e --- /dev/null +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/td_boot.S @@ -0,0 +1,101 @@ +/* SPDX-License-Identifier: GPL-2.0-only */

+#include "tdx/td_boot_asm.h"

+/* Offsets for reading struct td_boot_parameters */ +#define TD_BOOT_PARAMETERS_CR0 0 +#define TD_BOOT_PARAMETERS_CR3 4 +#define TD_BOOT_PARAMETERS_CR4 8 +#define TD_BOOT_PARAMETERS_GDT 12 +#define TD_BOOT_PARAMETERS_IDT 18 +#define TD_BOOT_PARAMETERS_PER_VCPU 24

+/* Offsets for reading struct td_per_vcpu_parameters */ +#define TD_PER_VCPU_PARAMETERS_ESP_GVA 0 +#define TD_PER_VCPU_PARAMETERS_LJMP_TARGET 4

+#define SIZEOF_TD_PER_VCPU_PARAMETERS 10

+.code32

+.globl td_boot +td_boot:

• /* In this procedure, edi is used as a temporary register */
• cli
• /* Paging is off */
• movl $TD_BOOT_PARAMETERS_GPA, %ebx
• /*

• * Find the address of struct td_per_vcpu_parameters for this
  

• * vCPU based on esi (TDX spec: initialized with vcpu id). Put
  

• * struct address into register for indirect addressing
  

• */
  

• movl $SIZEOF_TD_PER_VCPU_PARAMETERS, %eax
• mul %esi
• leal TD_BOOT_PARAMETERS_PER_VCPU(%ebx), %edi
• addl %edi, %eax
• /* Setup stack */
• movl TD_PER_VCPU_PARAMETERS_ESP_GVA(%eax), %esp
• /* Setup GDT */
• leal TD_BOOT_PARAMETERS_GDT(%ebx), %edi
• lgdt (%edi)
• /* Setup IDT */
• leal TD_BOOT_PARAMETERS_IDT(%ebx), %edi
• lidt (%edi)
• /*

• * Set up control registers (There are no instructions to
  

• * mov from memory to control registers, hence we need to use ebx
  

• * as a scratch register)
  

• */
  

• movl TD_BOOT_PARAMETERS_CR4(%ebx), %edi
• movl %edi, %cr4
• movl TD_BOOT_PARAMETERS_CR3(%ebx), %edi
• movl %edi, %cr3
• movl TD_BOOT_PARAMETERS_CR0(%ebx), %edi
• movl %edi, %cr0
• /* Paging is on after setting the most significant bit on cr0 */
• /*

• * Jump to selftest guest code. Far jumps read <segment
  

• * selector:new eip> from <addr+4:addr>. This location has
  

• * already been set up in boot parameters, and we can read boot
  

• * parameters because boot code and boot parameters are loaded so
  

• * that GVA and GPA are mapped 1:1.
  

• */
  

• ljmp *TD_PER_VCPU_PARAMETERS_LJMP_TARGET(%eax)

+.globl reset_vector +reset_vector:

• jmp td_boot
• /*

• * Pad reset_vector to its full size of 16 bytes so that this
  

• * can be loaded with the end of reset_vector aligned to GPA=4G
  

• */
  

• int3
• int3
• int3
• int3
• int3
• int3
• int3
• int3
• int3
• int3
• int3
• int3
• int3
• int3

+/* Leave marker so size of td_boot code can be computed */ +.globl td_boot_code_end +td_boot_code_end:

+/* Disable executable stack */ +.section .note.GNU-stack,"",%progbits diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c new file mode 100644 index 000000000000..9b69c733ce01 --- /dev/null +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c @@ -0,0 +1,434 @@ +// SPDX-License-Identifier: GPL-2.0-only

+#define _GNU_SOURCE +#include <asm/kvm.h> +#include <asm/kvm_host.h> +#include <errno.h> +#include <linux/kvm.h> +#include <stdint.h> +#include <sys/ioctl.h>

+#include "kvm_util.h" +#include "test_util.h" +#include "tdx/td_boot.h" +#include "kvm_util_base.h" +#include "processor.h"

+/*

• • TDX ioctls
• */

+static char *tdx_cmd_str[] = {

• "KVM_TDX_CAPABILITIES",
• "KVM_TDX_INIT_VM",
• "KVM_TDX_INIT_VCPU",
• "KVM_TDX_INIT_MEM_REGION",
• "KVM_TDX_FINALIZE_VM"

+}; +#define TDX_MAX_CMD_STR (ARRAY_SIZE(tdx_cmd_str))

+static void tdx_ioctl(int fd, int ioctl_no, uint32_t flags, void *data) +{

• struct kvm_tdx_cmd tdx_cmd;
• int r;
• TEST_ASSERT(ioctl_no < TDX_MAX_CMD_STR, "Unknown TDX CMD : %d\n",

•     ioctl_no);
  

• memset(&tdx_cmd, 0x0, sizeof(tdx_cmd));
• tdx_cmd.id = ioctl_no;
• tdx_cmd.flags = flags;
• tdx_cmd.data = (uint64_t)data;
• r = ioctl(fd, KVM_MEMORY_ENCRYPT_OP, &tdx_cmd);
• TEST_ASSERT(r == 0, "%s failed: %d %d", tdx_cmd_str[ioctl_no], r,

•     errno);
  

+}

+#define XFEATURE_MASK_CET (XFEATURE_MASK_CET_USER | XFEATURE_MASK_CET_KERNEL)

+static void tdx_apply_cpuid_restrictions(struct kvm_cpuid2 *cpuid_data) +{

• for (int i = 0; i < cpuid_data->nent; i++) {

• struct kvm_cpuid_entry2 *e = &cpuid_data->entries[i];
  

• if (e->function == 0xd && e->index == 0) {
  

• 	/*
  

• 	 * TDX module requires both XTILE_{CFG, DATA} to be set.
  

• 	 * Both bits are required for AMX to be functional.
  

• 	 */
  

• 	if ((e->eax & XFEATURE_MASK_XTILE) !=
  

• 	    XFEATURE_MASK_XTILE) {
  

• 		e->eax &= ~XFEATURE_MASK_XTILE;
  

• 	}
  

• }
  

• if (e->function == 0xd && e->index == 1) {
  

• 	/*
  

• 	 * TDX doesn't support LBR yet.
  

• 	 * Disable bits from the XCR0 register.
  

• 	 */
  

• 	e->ecx &= ~XFEATURE_MASK_LBR;
  

• 	/*
  

• 	 * TDX modules requires both CET_{U, S} to be set even
  

• 	 * if only one is supported.
  

• 	 */
  

• 	if (e->ecx & XFEATURE_MASK_CET)
  

• 		e->ecx |= XFEATURE_MASK_CET;
  

• }
  

• }

+}

+static void tdx_td_init(struct kvm_vm *vm, uint64_t attributes) +{

• const struct kvm_cpuid2 *cpuid;
• struct kvm_tdx_init_vm *init_vm;
• cpuid = kvm_get_supported_cpuid();
• init_vm = malloc(sizeof(*init_vm) +

• 	 sizeof(init_vm->cpuid.entries[0]) * cpuid->nent);
  

Can add a sanity checking for init_vm here like the following: TEST_ASSERT(init_vm, "vm allocation failed");

• memset(init_vm, 0, sizeof(*init_vm));

Can use calloc instead: init_vm = calloc(1, sizeof(*init_vm));

• memcpy(&init_vm->cpuid, cpuid, kvm_cpuid2_size(cpuid->nent));
• init_vm->attributes = attributes;
• tdx_apply_cpuid_restrictions(&init_vm->cpuid);
• tdx_ioctl(vm->fd, KVM_TDX_INIT_VM, 0, init_vm);

+}

+static void tdx_td_vcpu_init(struct kvm_vcpu *vcpu) +{

• const struct kvm_cpuid2 *cpuid = kvm_get_supported_cpuid();
• vcpu_init_cpuid(vcpu, cpuid);
• tdx_ioctl(vcpu->fd, KVM_TDX_INIT_VCPU, 0, NULL);

+}

+static void tdx_init_mem_region(struct kvm_vm *vm, void *source_pages,

• 		uint64_t gpa, uint64_t size)
  

+{

• struct kvm_tdx_init_mem_region mem_region = {

• .source_addr = (uint64_t)source_pages,
  

• .gpa = gpa,
  

• .nr_pages = size / PAGE_SIZE,
  

• };
• uint32_t metadata = KVM_TDX_MEASURE_MEMORY_REGION;
• TEST_ASSERT((mem_region.nr_pages > 0) &&

• 	    ((mem_region.nr_pages * PAGE_SIZE) == size),
  

•     "Cannot add partial pages to the guest memory.\n");
  

• TEST_ASSERT(((uint64_t)source_pages & (PAGE_SIZE - 1)) == 0,

•     "Source memory buffer is not page aligned\n");
  

• tdx_ioctl(vm->fd, KVM_TDX_INIT_MEM_REGION, metadata, &mem_region);

+}

+static void tdx_td_finalizemr(struct kvm_vm *vm) +{

• tdx_ioctl(vm->fd, KVM_TDX_FINALIZE_VM, 0, NULL);

+}

Nit: tdx_td_finalizemr ==> tdx_td_finalize_mr

+/*

• • TD creation/setup/finalization
• */

+static void tdx_enable_capabilities(struct kvm_vm *vm) +{

• int rc;
• rc = kvm_check_cap(KVM_CAP_X2APIC_API);
• TEST_ASSERT(rc, "TDX: KVM_CAP_X2APIC_API is not supported!");
• rc = kvm_check_cap(KVM_CAP_SPLIT_IRQCHIP);
• TEST_ASSERT(rc, "TDX: KVM_CAP_SPLIT_IRQCHIP is not supported!");
• vm_enable_cap(vm, KVM_CAP_X2APIC_API,

•       KVM_X2APIC_API_USE_32BIT_IDS |
  

• 	      KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK);
  

• vm_enable_cap(vm, KVM_CAP_SPLIT_IRQCHIP, 24);

+}

+static void tdx_configure_memory_encryption(struct kvm_vm *vm) +{

• /* Configure shared/enCrypted bit for this VM according to TDX spec */
• vm->arch.s_bit = 1ULL << (vm->pa_bits - 1);
• vm->arch.c_bit = 0;
• /* Set gpa_protected_mask so that tagging/untagging of GPAs works */
• vm->gpa_protected_mask = vm->arch.s_bit;
• /* This VM is protected (has memory encryption) */
• vm->protected = true;

+}

+static void tdx_apply_cr4_restrictions(struct kvm_sregs *sregs) +{

• /* TDX spec 11.6.2: CR4 bit MCE is fixed to 1 */
• sregs->cr4 |= X86_CR4_MCE;
• /* Set this because UEFI also sets this up, to handle XMM exceptions */
• sregs->cr4 |= X86_CR4_OSXMMEXCPT;
• /* TDX spec 11.6.2: CR4 bit VMXE and SMXE are fixed to 0 */
• sregs->cr4 &= ~(X86_CR4_VMXE | X86_CR4_SMXE);

+}

+static void load_td_boot_code(struct kvm_vm *vm) +{

• void *boot_code_hva = addr_gpa2hva(vm, FOUR_GIGABYTES_GPA - TD_BOOT_CODE_SIZE);
• TEST_ASSERT(td_boot_code_end - reset_vector == 16,

• "The reset vector must be 16 bytes in size.");
  

• memcpy(boot_code_hva, td_boot, TD_BOOT_CODE_SIZE);

+}

+static void load_td_per_vcpu_parameters(struct td_boot_parameters *params,

• 			struct kvm_sregs *sregs,
  

• 			struct kvm_vcpu *vcpu,
  

• 			void *guest_code)
  

+{

• /* Store vcpu_index to match what the TDX module would store internally */
• static uint32_t vcpu_index;
• struct td_per_vcpu_parameters *vcpu_params = &params->per_vcpu[vcpu_index];

I think we can use vcpu->id in place of vcpu_index in this function, thus removing vcpu_index

• TEST_ASSERT(vcpu->initial_stack_addr != 0,

• "initial stack address should not be 0");
  

• TEST_ASSERT(vcpu->initial_stack_addr <= 0xffffffff,

• "initial stack address must fit in 32 bits");
  

• TEST_ASSERT((uint64_t)guest_code <= 0xffffffff,

• "guest_code must fit in 32 bits");
  

• TEST_ASSERT(sregs->cs.selector != 0, "cs.selector should not be 0");
• vcpu_params->esp_gva = (uint32_t)(uint64_t)vcpu->initial_stack_addr;
• vcpu_params->ljmp_target.eip_gva = (uint32_t)(uint64_t)guest_code;
• vcpu_params->ljmp_target.code64_sel = sregs->cs.selector;
• vcpu_index++;

+}

+static void load_td_common_parameters(struct td_boot_parameters *params,

• 		struct kvm_sregs *sregs)
  

+{

• /* Set parameters! */
• params->cr0 = sregs->cr0;
• params->cr3 = sregs->cr3;
• params->cr4 = sregs->cr4;
• params->gdtr.limit = sregs->gdt.limit;
• params->gdtr.base = sregs->gdt.base;
• params->idtr.limit = sregs->idt.limit;
• params->idtr.base = sregs->idt.base;
• TEST_ASSERT(params->cr0 != 0, "cr0 should not be 0");
• TEST_ASSERT(params->cr3 != 0, "cr3 should not be 0");
• TEST_ASSERT(params->cr4 != 0, "cr4 should not be 0");
• TEST_ASSERT(params->gdtr.base != 0, "gdt base address should not be 0");

+}

+static void load_td_boot_parameters(struct td_boot_parameters *params,

• 		struct kvm_vcpu *vcpu, void *guest_code)
  

+{

• struct kvm_sregs sregs;
• /* Assemble parameters in sregs */
• memset(&sregs, 0, sizeof(struct kvm_sregs));
• vcpu_setup_mode_sregs(vcpu->vm, &sregs);
• tdx_apply_cr4_restrictions(&sregs);
• kvm_setup_idt(vcpu->vm, &sregs.idt);
• if (!params->cr0)

• load_td_common_parameters(params, &sregs);
  

• load_td_per_vcpu_parameters(params, &sregs, vcpu, guest_code);

+}

+/**

• • Adds a vCPU to a TD (Trusted Domain) with minimum defaults. It will not set
• • up any general purpose registers as they will be initialized by the TDX. In
• • TDX, vCPUs RIP is set to 0xFFFFFFF0. See Intel TDX EAS Section "Initial State
• • of Guest GPRs" for more information on vCPUs initial register values when
• • entering the TD first time.
• • Input Args:
• • vm - Virtual Machine
• • vcpuid - The id of the VCPU to add to the VM.
• */

+struct kvm_vcpu *td_vcpu_add(struct kvm_vm *vm, uint32_t vcpu_id, void *guest_code) +{

• struct kvm_vcpu *vcpu;
• /*

• * TD setup will not use the value of rip set in vm_vcpu_add anyway, so
  

• * NULL can be used for guest_code.
  

• */
  

• vcpu = vm_vcpu_add(vm, vcpu_id, NULL);
• tdx_td_vcpu_init(vcpu);
• load_td_boot_parameters(addr_gpa2hva(vm, TD_BOOT_PARAMETERS_GPA),

• 		vcpu, guest_code);
  

• return vcpu;

+}

+/**

• • Iterate over set ranges within sparsebit @s. In each iteration,
• • @range_begin and @range_end will take the beginning and end of the set range,
• • which are of type sparsebit_idx_t.
• • For example, if the range [3, 7] (inclusive) is set, within the iteration,
• • @range_begin will take the value 3 and @range_end will take the value 7.
• • Ensure that there is at least one bit set before using this macro with
• • sparsebit_any_set(), because sparsebit_first_set() will abort if none are
• • set.
• */

+#define sparsebit_for_each_set_range(s, range_begin, range_end) \

• for (range_begin = sparsebit_first_set(s), \

•      range_end = sparsebit_next_clear(s, range_begin) - 1; \
  

•     range_begin && range_end;					\
  

•     range_begin = sparsebit_next_set(s, range_end),		\
  

•      range_end = sparsebit_next_clear(s, range_begin) - 1)
  

+/*

• • sparsebit_next_clear() can return 0 if [x, 2**64-1] are all set, and the -1
• • would then cause an underflow back to 2**64 - 1. This is expected and
• • correct.
• • If the last range in the sparsebit is [x, y] and we try to iterate,
• • sparsebit_next_set() will return 0, and sparsebit_next_clear() will try and
• • find the first range, but that's correct because the condition expression
• • would cause us to quit the loop.
• */

+static void load_td_memory_region(struct kvm_vm *vm,

• 		  struct userspace_mem_region *region)
  

+{

• const struct sparsebit *pages = region->protected_phy_pages;
• const uint64_t hva_base = region->region.userspace_addr;
• const vm_paddr_t gpa_base = region->region.guest_phys_addr;
• const sparsebit_idx_t lowest_page_in_region = gpa_base >>

• 				      vm->page_shift;
  

• sparsebit_idx_t i;
• sparsebit_idx_t j;
• if (!sparsebit_any_set(pages))

• return;
  

• sparsebit_for_each_set_range(pages, i, j) {

• const uint64_t size_to_load = (j - i + 1) * vm->page_size;
  

• const uint64_t offset =
  

• 	(i - lowest_page_in_region) * vm->page_size;
  

• const uint64_t hva = hva_base + offset;
  

• const uint64_t gpa = gpa_base + offset;
  

• void *source_addr;
  

• /*
  

•  * KVM_TDX_INIT_MEM_REGION ioctl cannot encrypt memory in place,
  

•  * hence we have to make a copy if there's only one backing
  

•  * memory source
  

•  */
  

• source_addr = mmap(NULL, size_to_load, PROT_READ | PROT_WRITE,
  

• 		   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
  

• TEST_ASSERT(
  

• 	source_addr,
  

• 	"Could not allocate memory for loading memory region");
  

• memcpy(source_addr, (void *)hva, size_to_load);
  

• tdx_init_mem_region(vm, source_addr, gpa, size_to_load);
  

• munmap(source_addr, size_to_load);
  

• }

+}

+static void load_td_private_memory(struct kvm_vm *vm) +{

• int ctr;
• struct userspace_mem_region *region;
• hash_for_each(vm->regions.slot_hash, ctr, region, slot_node) {

• load_td_memory_region(vm, region);
  

• }

+}

+struct kvm_vm *td_create(void) +{

• struct vm_shape shape;
• shape.mode = VM_MODE_DEFAULT;
• shape.type = KVM_X86_TDX_VM;
• return ____vm_create(shape);

Nit: init shape to 0s: struct vm_shape shape = {};

Pass pointer of share to ____vm_create() instead: ____vm_create(&shape)

+}

+static void td_setup_boot_code(struct kvm_vm *vm, enum vm_mem_backing_src_type src_type) +{

• vm_vaddr_t addr;
• size_t boot_code_allocation = round_up(TD_BOOT_CODE_SIZE, PAGE_SIZE);
• vm_paddr_t boot_code_base_gpa = FOUR_GIGABYTES_GPA - boot_code_allocation;
• size_t npages = DIV_ROUND_UP(boot_code_allocation, PAGE_SIZE);
• vm_userspace_mem_region_add(vm, src_type, boot_code_base_gpa, 1, npages,

• 		    KVM_MEM_PRIVATE);
  

• addr = vm_vaddr_alloc_1to1(vm, boot_code_allocation, boot_code_base_gpa, 1);
• TEST_ASSERT_EQ(addr, boot_code_base_gpa);
• load_td_boot_code(vm);

+}

+static size_t td_boot_parameters_size(void) +{

• int max_vcpus = kvm_check_cap(KVM_CAP_MAX_VCPUS);
• size_t total_per_vcpu_parameters_size =

• max_vcpus * sizeof(struct td_per_vcpu_parameters);
  

• return sizeof(struct td_boot_parameters) + total_per_vcpu_parameters_size;

+}

+static void td_setup_boot_parameters(struct kvm_vm *vm, enum vm_mem_backing_src_type src_type) +{

• vm_vaddr_t addr;
• size_t boot_params_size = td_boot_parameters_size();
• int npages = DIV_ROUND_UP(boot_params_size, PAGE_SIZE);
• size_t total_size = npages * PAGE_SIZE;
• vm_userspace_mem_region_add(vm, src_type, TD_BOOT_PARAMETERS_GPA, 2,

• 		    npages, KVM_MEM_PRIVATE);
  

• addr = vm_vaddr_alloc_1to1(vm, total_size, TD_BOOT_PARAMETERS_GPA, 2);
• TEST_ASSERT_EQ(addr, TD_BOOT_PARAMETERS_GPA);

+}

+void td_initialize(struct kvm_vm *vm, enum vm_mem_backing_src_type src_type,

•    uint64_t attributes)
  

+{

• uint64_t nr_pages_required;
• tdx_enable_capabilities(vm);
• tdx_configure_memory_encryption(vm);
• tdx_td_init(vm, attributes);
• nr_pages_required = vm_nr_pages_required(VM_MODE_DEFAULT, 1, 0);
• /*

• * Add memory (add 0th memslot) for TD. This will be used to setup the
  

• * CPU (provide stack space for the CPU) and to load the elf file.
  

• */
  

• vm_userspace_mem_region_add(vm, src_type, 0, 0, nr_pages_required,

• 		    KVM_MEM_PRIVATE);
  

• kvm_vm_elf_load(vm, program_invocation_name);
• vm_init_descriptor_tables(vm);
• td_setup_boot_code(vm, src_type);
• td_setup_boot_parameters(vm, src_type);

+}

+void td_finalize(struct kvm_vm *vm) +{

• sync_exception_handlers_to_guest(vm);
• load_td_private_memory(vm);
• tdx_td_finalizemr(vm);

+}

diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S new file mode 100644 index 000000000000..df9c1ed4bb2d --- /dev/null +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S @@ -0,0 +1,90 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* Adapted from arch/x86/coco/tdx/tdcall.S */

+#define TDX_HYPERCALL_r10 0 /* offsetof(struct tdx_hypercall_args, r10) */ +#define TDX_HYPERCALL_r11 8 /* offsetof(struct tdx_hypercall_args, r11) */ +#define TDX_HYPERCALL_r12 16 /* offsetof(struct tdx_hypercall_args, r12) */ +#define TDX_HYPERCALL_r13 24 /* offsetof(struct tdx_hypercall_args, r13) */ +#define TDX_HYPERCALL_r14 32 /* offsetof(struct tdx_hypercall_args, r14) */ +#define TDX_HYPERCALL_r15 40 /* offsetof(struct tdx_hypercall_args, r15) */

+/*

• • Bitmasks of exposed registers (with VMM).
• */

+#define TDX_R10 0x400 +#define TDX_R11 0x800 +#define TDX_R12 0x1000 +#define TDX_R13 0x2000 +#define TDX_R14 0x4000 +#define TDX_R15 0x8000

+#define TDX_HCALL_HAS_OUTPUT 0x1

+/*

• • These registers are clobbered to hold arguments for each
• • TDVMCALL. They are safe to expose to the VMM.
• • Each bit in this mask represents a register ID. Bit field
• • details can be found in TDX GHCI specification, section
• • titled "TDCALL [TDG.VP.VMCALL] leaf".
• */

+#define TDVMCALL_EXPOSE_REGS_MASK ( TDX_R10 | TDX_R11 | \

• 			  TDX_R12 | TDX_R13 | \
  

• 			  TDX_R14 | TDX_R15 )
  

+.code64 +.section .text

+.globl __tdx_hypercall +.type __tdx_hypercall, @function +__tdx_hypercall:

• /* Set up stack frame */
• push %rbp
• movq %rsp, %rbp
• /* Save callee-saved GPRs as mandated by the x86_64 ABI */
• push %r15
• push %r14
• push %r13
• push %r12
• /* Mangle function call ABI into TDCALL ABI: */
• /* Set TDCALL leaf ID (TDVMCALL (0)) in RAX */
• xor %eax, %eax
• /* Copy hypercall registers from arg struct: */
• movq TDX_HYPERCALL_r10(%rdi), %r10
• movq TDX_HYPERCALL_r11(%rdi), %r11
• movq TDX_HYPERCALL_r12(%rdi), %r12
• movq TDX_HYPERCALL_r13(%rdi), %r13
• movq TDX_HYPERCALL_r14(%rdi), %r14
• movq TDX_HYPERCALL_r15(%rdi), %r15
• movl $TDVMCALL_EXPOSE_REGS_MASK, %ecx
• tdcall

Looks there's a missing of definition for tdcall, and will produce below error: lib/x86_64/tdx/tdcall.S:65: Error: no such instruction: `tdcall'

I pulled the code https://github.com/googleprodkernel/linux-cc.git with branch tdx-selftests-rfc-v5.

Fixed by adding a line in tdcall.S in my side. #define tdcall .byte 0x66,0x0f,0x01,0xcc

• /* TDVMCALL leaf return code is in R10 */
• movq %r10, %rax
• /* Copy hypercall result registers to arg struct if needed */
• testq $TDX_HCALL_HAS_OUTPUT, %rsi
• jz .Lout
• movq %r10, TDX_HYPERCALL_r10(%rdi)
• movq %r11, TDX_HYPERCALL_r11(%rdi)
• movq %r12, TDX_HYPERCALL_r12(%rdi)
• movq %r13, TDX_HYPERCALL_r13(%rdi)
• movq %r14, TDX_HYPERCALL_r14(%rdi)
• movq %r15, TDX_HYPERCALL_r15(%rdi)

+.Lout:

• /* Restore callee-saved GPRs as mandated by the x86_64 ABI */
• pop %r12
• pop %r13
• pop %r14
• pop %r15
• pop %rbp
• ret

+/* Disable executable stack */

On 12/12/2023 12:46 PM, Sagi Shahar wrote:

From: Erdem Aktas erdemaktas@google.com

Adding a test to verify TDX lifecycle by creating a TD and running a dummy TDG.VP.VMCALL <Instruction.IO> inside it.

Signed-off-by: Erdem Aktas erdemaktas@google.com Signed-off-by: Ryan Afranji afranji@google.com Signed-off-by: Sagi Shahar sagis@google.com Co-developed-by: Ackerley Tng ackerleytng@google.com Signed-off-by: Ackerley Tng ackerleytng@google.com

---

tools/testing/selftests/kvm/Makefile | 4 + .../selftests/kvm/include/x86_64/tdx/tdcall.h | 35 ++++++++ .../selftests/kvm/include/x86_64/tdx/tdx.h | 12 +++ .../kvm/include/x86_64/tdx/test_util.h | 52 +++++++++++ .../selftests/kvm/lib/x86_64/tdx/tdcall.S | 90 +++++++++++++++++++ .../selftests/kvm/lib/x86_64/tdx/tdx.c | 27 ++++++ .../selftests/kvm/lib/x86_64/tdx/tdx_util.c | 1 + .../selftests/kvm/lib/x86_64/tdx/test_util.c | 34 +++++++ .../selftests/kvm/x86_64/tdx_vm_tests.c | 45 ++++++++++ 9 files changed, 300 insertions(+) create mode 100644 tools/testing/selftests/kvm/include/x86_64/tdx/tdcall.h create mode 100644 tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h create mode 100644 tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h create mode 100644 tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S create mode 100644 tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c create mode 100644 tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c create mode 100644 tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c

diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile index a35150ab855f..80d4a50eeb9f 100644 --- a/tools/testing/selftests/kvm/Makefile +++ b/tools/testing/selftests/kvm/Makefile @@ -52,6 +52,9 @@ LIBKVM_x86_64 += lib/x86_64/vmx.c LIBKVM_x86_64 += lib/x86_64/sev.c LIBKVM_x86_64 += lib/x86_64/tdx/tdx_util.c LIBKVM_x86_64 += lib/x86_64/tdx/td_boot.S +LIBKVM_x86_64 += lib/x86_64/tdx/tdcall.S +LIBKVM_x86_64 += lib/x86_64/tdx/tdx.c +LIBKVM_x86_64 += lib/x86_64/tdx/test_util.c LIBKVM_aarch64 += lib/aarch64/gic.c LIBKVM_aarch64 += lib/aarch64/gic_v3.c @@ -152,6 +155,7 @@ TEST_GEN_PROGS_x86_64 += set_memory_region_test TEST_GEN_PROGS_x86_64 += steal_time TEST_GEN_PROGS_x86_64 += kvm_binary_stats_test TEST_GEN_PROGS_x86_64 += system_counter_offset_test +TEST_GEN_PROGS_x86_64 += x86_64/tdx_vm_tests # Compiled outputs used by test targets TEST_GEN_PROGS_EXTENDED_x86_64 += x86_64/nx_huge_pages_test diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/tdcall.h b/tools/testing/selftests/kvm/include/x86_64/tdx/tdcall.h new file mode 100644 index 000000000000..78001bfec9c8 --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdcall.h @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* Adapted from arch/x86/include/asm/shared/tdx.h */

+#ifndef SELFTESTS_TDX_TDCALL_H +#define SELFTESTS_TDX_TDCALL_H

+#include <linux/bits.h> +#include <linux/types.h>

+#define TDG_VP_VMCALL_INSTRUCTION_IO_READ 0 +#define TDG_VP_VMCALL_INSTRUCTION_IO_WRITE 1

Nit: Probably we can define the following instead in test_util.c? /* Port I/O direction */ #define PORT_READ 0 #define PORT_WRITE 1

Then use them in place of TDG_VP_VMCALL_INSTRUCTION_IO_READ/TDG_VP_VMCALL_INSTRUCTION_IO_WRITE? which are too long

+#define TDX_HCALL_HAS_OUTPUT BIT(0)

+#define TDX_HYPERCALL_STANDARD 0

+/*

• • 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 // SELFTESTS_TDX_TDCALL_H diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h new file mode 100644 index 000000000000..a7161efe4ee2 --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef SELFTEST_TDX_TDX_H +#define SELFTEST_TDX_TDX_H

+#include <stdint.h>

+#define TDG_VP_VMCALL_INSTRUCTION_IO 30

Nit: arch/x86/include/uapi/asm/vmx.h already exports the following define: #define EXIT_REASON_IO_INSTRUCTION 30

Linux kernel example (arch/x86/coco/tdx/tdx.c): static bool handle_in(struct pt_regs *regs, int size, int port) { struct tdx_module_args args = { .r10 = TDX_HYPERCALL_STANDARD, .r11 = hcall_func(EXIT_REASON_IO_INSTRUCTION), .r12 = size, .r13 = PORT_READ, .r14 = port, };

So just like the kernel, here we can also use EXIT_REASON_IO_INSTRUCTION in place of TDG_VP_VMCALL_INSTRUCTION_IO, just need to do a '#include "vmx.h"' or '#include <asm/vmx.h>' to bring in the define

+uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size,

• 		      uint64_t write, uint64_t *data);
  

+#endif // SELFTEST_TDX_TDX_H diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h new file mode 100644 index 000000000000..b570b6d978ff --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef SELFTEST_TDX_TEST_UTIL_H +#define SELFTEST_TDX_TEST_UTIL_H

+#include <stdbool.h>

+#include "tdcall.h"

+#define TDX_TEST_SUCCESS_PORT 0x30 +#define TDX_TEST_SUCCESS_SIZE 4

+/**

• • Assert that tdx_test_success() was called in the guest.
• */

+#define TDX_TEST_ASSERT_SUCCESS(VCPU) \

• (TEST_ASSERT( \

• ((VCPU)->run->exit_reason == KVM_EXIT_IO) &&		\
  

• ((VCPU)->run->io.port == TDX_TEST_SUCCESS_PORT) &&	\
  

• ((VCPU)->run->io.size == TDX_TEST_SUCCESS_SIZE) &&	\
  

• ((VCPU)->run->io.direction ==				\
  

• 	TDG_VP_VMCALL_INSTRUCTION_IO_WRITE),		\
  

• "Unexpected exit values while waiting for test completion: %u (%s) %d %d %d\n", \
  

• (VCPU)->run->exit_reason,				\
  

• exit_reason_str((VCPU)->run->exit_reason),		\
  

• (VCPU)->run->io.port, (VCPU)->run->io.size,		\
  

• (VCPU)->run->io.direction))
  

+/**

• • Run a test in a new process.
• • There might be multiple tests we are running and if one test fails, it will
• • prevent the subsequent tests to run due to how tests are failing with
• • TEST_ASSERT function. The run_in_new_process function will run a test in a
• • new process context and wait for it to finish or fail to prevent TEST_ASSERT
• • to kill the main testing process.
• */

+void run_in_new_process(void (*func)(void));

+/**

• • Verify that the TDX is supported by KVM.
• */

+bool is_tdx_enabled(void);

+/**

• • Report test success to userspace.
• • Use TDX_TEST_ASSERT_SUCCESS() to assert that this function was called in the
• • guest.
• */

+void tdx_test_success(void);

+#endif // SELFTEST_TDX_TEST_UTIL_H diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S new file mode 100644 index 000000000000..df9c1ed4bb2d --- /dev/null +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S @@ -0,0 +1,90 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* Adapted from arch/x86/coco/tdx/tdcall.S */

+#define TDX_HYPERCALL_r10 0 /* offsetof(struct tdx_hypercall_args, r10) */ +#define TDX_HYPERCALL_r11 8 /* offsetof(struct tdx_hypercall_args, r11) */ +#define TDX_HYPERCALL_r12 16 /* offsetof(struct tdx_hypercall_args, r12) */ +#define TDX_HYPERCALL_r13 24 /* offsetof(struct tdx_hypercall_args, r13) */ +#define TDX_HYPERCALL_r14 32 /* offsetof(struct tdx_hypercall_args, r14) */ +#define TDX_HYPERCALL_r15 40 /* offsetof(struct tdx_hypercall_args, r15) */

+/*

• • Bitmasks of exposed registers (with VMM).
• */

+#define TDX_R10 0x400 +#define TDX_R11 0x800 +#define TDX_R12 0x1000 +#define TDX_R13 0x2000 +#define TDX_R14 0x4000 +#define TDX_R15 0x8000

+#define TDX_HCALL_HAS_OUTPUT 0x1

+/*

• • These registers are clobbered to hold arguments for each
• • TDVMCALL. They are safe to expose to the VMM.
• • Each bit in this mask represents a register ID. Bit field
• • details can be found in TDX GHCI specification, section
• • titled "TDCALL [TDG.VP.VMCALL] leaf".
• */

+#define TDVMCALL_EXPOSE_REGS_MASK ( TDX_R10 | TDX_R11 | \

• 			  TDX_R12 | TDX_R13 | \
  

• 			  TDX_R14 | TDX_R15 )
  

+.code64 +.section .text

+.globl __tdx_hypercall +.type __tdx_hypercall, @function +__tdx_hypercall:

• /* Set up stack frame */
• push %rbp
• movq %rsp, %rbp
• /* Save callee-saved GPRs as mandated by the x86_64 ABI */
• push %r15
• push %r14
• push %r13
• push %r12
• /* Mangle function call ABI into TDCALL ABI: */
• /* Set TDCALL leaf ID (TDVMCALL (0)) in RAX */
• xor %eax, %eax
• /* Copy hypercall registers from arg struct: */
• movq TDX_HYPERCALL_r10(%rdi), %r10
• movq TDX_HYPERCALL_r11(%rdi), %r11
• movq TDX_HYPERCALL_r12(%rdi), %r12
• movq TDX_HYPERCALL_r13(%rdi), %r13
• movq TDX_HYPERCALL_r14(%rdi), %r14
• movq TDX_HYPERCALL_r15(%rdi), %r15
• movl $TDVMCALL_EXPOSE_REGS_MASK, %ecx
• tdcall
• /* TDVMCALL leaf return code is in R10 */
• movq %r10, %rax
• /* Copy hypercall result registers to arg struct if needed */
• testq $TDX_HCALL_HAS_OUTPUT, %rsi
• jz .Lout
• movq %r10, TDX_HYPERCALL_r10(%rdi)
• movq %r11, TDX_HYPERCALL_r11(%rdi)
• movq %r12, TDX_HYPERCALL_r12(%rdi)
• movq %r13, TDX_HYPERCALL_r13(%rdi)
• movq %r14, TDX_HYPERCALL_r14(%rdi)
• movq %r15, TDX_HYPERCALL_r15(%rdi)

+.Lout:

• /* Restore callee-saved GPRs as mandated by the x86_64 ABI */
• pop %r12
• pop %r13
• pop %r14
• pop %r15
• pop %rbp
• ret

+/* Disable executable stack */ +.section .note.GNU-stack,"",%progbits diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c new file mode 100644 index 000000000000..c2414523487a --- /dev/null +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: GPL-2.0-only

+#include "tdx/tdcall.h" +#include "tdx/tdx.h"

+uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size,

• 		      uint64_t write, uint64_t *data)
  

+{

• uint64_t ret;
• struct tdx_hypercall_args args = {

• .r10 = TDX_HYPERCALL_STANDARD,
  

• .r11 = TDG_VP_VMCALL_INSTRUCTION_IO,
  

• .r12 = size,
  

• .r13 = write,
  

• .r14 = port,
  

• };
• if (write)

• args.r15 = *data;
  

• ret = __tdx_hypercall(&args, write ? 0 : TDX_HCALL_HAS_OUTPUT);
• if (!write)

• *data = args.r11;
  

• return ret;

+} diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c index 063ff486fb86..b302060049d5 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c @@ -224,6 +224,7 @@ static void tdx_enable_capabilities(struct kvm_vm *vm) KVM_X2APIC_API_USE_32BIT_IDS | KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK); vm_enable_cap(vm, KVM_CAP_SPLIT_IRQCHIP, 24);

• vm_enable_cap(vm, KVM_CAP_MAX_VCPUS, 512);

} static void tdx_configure_memory_encryption(struct kvm_vm *vm) diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c new file mode 100644 index 000000000000..6905d0ca3877 --- /dev/null +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c @@ -0,0 +1,34 @@ +// SPDX-License-Identifier: GPL-2.0-only

+#include <stdbool.h> +#include <stdint.h> +#include <stdlib.h> +#include <sys/wait.h> +#include <unistd.h>

+#include "kvm_util_base.h" +#include "tdx/tdx.h" +#include "tdx/test_util.h"

+void run_in_new_process(void (*func)(void)) +{

• if (fork() == 0) {

• func();
  

• exit(0);
  

• }
• wait(NULL);

+}

+bool is_tdx_enabled(void) +{

• return !!(kvm_check_cap(KVM_CAP_VM_TYPES) & BIT(KVM_X86_TDX_VM));

+}

+void tdx_test_success(void) +{

• uint64_t code = 0;
• tdg_vp_vmcall_instruction_io(TDX_TEST_SUCCESS_PORT,

• 		     TDX_TEST_SUCCESS_SIZE,
  

• 		     TDG_VP_VMCALL_INSTRUCTION_IO_WRITE, &code);
  

+} diff --git a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c new file mode 100644 index 000000000000..a18d1c9d6026 --- /dev/null +++ b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c @@ -0,0 +1,45 @@ +// SPDX-License-Identifier: GPL-2.0-only

+#include <signal.h> +#include "kvm_util_base.h" +#include "tdx/tdx_util.h" +#include "tdx/test_util.h" +#include "test_util.h"

+void guest_code_lifecycle(void) +{

• tdx_test_success();

+}

+void verify_td_lifecycle(void) +{

• struct kvm_vm *vm;
• struct kvm_vcpu *vcpu;
• vm = td_create();
• td_initialize(vm, VM_MEM_SRC_ANONYMOUS, 0);
• vcpu = td_vcpu_add(vm, 0, guest_code_lifecycle);
• td_finalize(vm);
• printf("Verifying TD lifecycle:\n");
• vcpu_run(vcpu);
• TDX_TEST_ASSERT_SUCCESS(vcpu);
• kvm_vm_free(vm);
• printf("\t ... PASSED\n");

+}

Nit: All the functions used locally inside tdx_vm_tests.c can be declared static: static void guest_code_lifecycle(void) static void verify_td_lifecycle(void)

+int main(int argc, char **argv) +{

• setbuf(stdout, NULL);
• if (!is_tdx_enabled()) {

• print_skip("TDX is not supported by the KVM");
  

• exit(KSFT_SKIP);
  

• }
• run_in_new_process(&verify_td_lifecycle);
• return 0;

+}

On 12/12/2023 12:46 PM, Sagi Shahar wrote:

From: Erdem Aktas erdemaktas@google.com

Adding a test to verify TDX lifecycle by creating a TD and running a dummy TDG.VP.VMCALL <Instruction.IO> inside it.

Signed-off-by: Erdem Aktas erdemaktas@google.com Signed-off-by: Ryan Afranji afranji@google.com Signed-off-by: Sagi Shahar sagis@google.com Co-developed-by: Ackerley Tng ackerleytng@google.com Signed-off-by: Ackerley Tng ackerleytng@google.com

---

tools/testing/selftests/kvm/Makefile | 4 + .../selftests/kvm/include/x86_64/tdx/tdcall.h | 35 ++++++++ .../selftests/kvm/include/x86_64/tdx/tdx.h | 12 +++ .../kvm/include/x86_64/tdx/test_util.h | 52 +++++++++++ .../selftests/kvm/lib/x86_64/tdx/tdcall.S | 90 +++++++++++++++++++ .../selftests/kvm/lib/x86_64/tdx/tdx.c | 27 ++++++ .../selftests/kvm/lib/x86_64/tdx/tdx_util.c | 1 + .../selftests/kvm/lib/x86_64/tdx/test_util.c | 34 +++++++ .../selftests/kvm/x86_64/tdx_vm_tests.c | 45 ++++++++++ 9 files changed, 300 insertions(+) create mode 100644 tools/testing/selftests/kvm/include/x86_64/tdx/tdcall.h create mode 100644 tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h create mode 100644 tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h create mode 100644 tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S create mode 100644 tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c create mode 100644 tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c create mode 100644 tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c

diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile index a35150ab855f..80d4a50eeb9f 100644 --- a/tools/testing/selftests/kvm/Makefile +++ b/tools/testing/selftests/kvm/Makefile @@ -52,6 +52,9 @@ LIBKVM_x86_64 += lib/x86_64/vmx.c LIBKVM_x86_64 += lib/x86_64/sev.c LIBKVM_x86_64 += lib/x86_64/tdx/tdx_util.c LIBKVM_x86_64 += lib/x86_64/tdx/td_boot.S +LIBKVM_x86_64 += lib/x86_64/tdx/tdcall.S +LIBKVM_x86_64 += lib/x86_64/tdx/tdx.c +LIBKVM_x86_64 += lib/x86_64/tdx/test_util.c LIBKVM_aarch64 += lib/aarch64/gic.c LIBKVM_aarch64 += lib/aarch64/gic_v3.c @@ -152,6 +155,7 @@ TEST_GEN_PROGS_x86_64 += set_memory_region_test TEST_GEN_PROGS_x86_64 += steal_time TEST_GEN_PROGS_x86_64 += kvm_binary_stats_test TEST_GEN_PROGS_x86_64 += system_counter_offset_test +TEST_GEN_PROGS_x86_64 += x86_64/tdx_vm_tests # Compiled outputs used by test targets TEST_GEN_PROGS_EXTENDED_x86_64 += x86_64/nx_huge_pages_test diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/tdcall.h b/tools/testing/selftests/kvm/include/x86_64/tdx/tdcall.h new file mode 100644 index 000000000000..78001bfec9c8 --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdcall.h @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* Adapted from arch/x86/include/asm/shared/tdx.h */

+#ifndef SELFTESTS_TDX_TDCALL_H +#define SELFTESTS_TDX_TDCALL_H

+#include <linux/bits.h> +#include <linux/types.h>

+#define TDG_VP_VMCALL_INSTRUCTION_IO_READ 0 +#define TDG_VP_VMCALL_INSTRUCTION_IO_WRITE 1

+#define TDX_HCALL_HAS_OUTPUT BIT(0)

+#define TDX_HYPERCALL_STANDARD 0

+/*

• • 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 // SELFTESTS_TDX_TDCALL_H diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h new file mode 100644 index 000000000000..a7161efe4ee2 --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef SELFTEST_TDX_TDX_H +#define SELFTEST_TDX_TDX_H

+#include <stdint.h>

+#define TDG_VP_VMCALL_INSTRUCTION_IO 30

+uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size,

• 		      uint64_t write, uint64_t *data);
  

+#endif // SELFTEST_TDX_TDX_H diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h new file mode 100644 index 000000000000..b570b6d978ff --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef SELFTEST_TDX_TEST_UTIL_H +#define SELFTEST_TDX_TEST_UTIL_H

+#include <stdbool.h>

+#include "tdcall.h"

+#define TDX_TEST_SUCCESS_PORT 0x30 +#define TDX_TEST_SUCCESS_SIZE 4

+/**

• • Assert that tdx_test_success() was called in the guest.
• */

+#define TDX_TEST_ASSERT_SUCCESS(VCPU) \

• (TEST_ASSERT( \

• ((VCPU)->run->exit_reason == KVM_EXIT_IO) &&		\
  

• ((VCPU)->run->io.port == TDX_TEST_SUCCESS_PORT) &&	\
  

• ((VCPU)->run->io.size == TDX_TEST_SUCCESS_SIZE) &&	\
  

• ((VCPU)->run->io.direction ==				\
  

• 	TDG_VP_VMCALL_INSTRUCTION_IO_WRITE),		\
  

• "Unexpected exit values while waiting for test completion: %u (%s) %d %d %d\n", \
  

• (VCPU)->run->exit_reason,				\
  

• exit_reason_str((VCPU)->run->exit_reason),		\
  

• (VCPU)->run->io.port, (VCPU)->run->io.size,		\
  

• (VCPU)->run->io.direction))
  

+/**

• • Run a test in a new process.
• • There might be multiple tests we are running and if one test fails, it will
• • prevent the subsequent tests to run due to how tests are failing with
• • TEST_ASSERT function. The run_in_new_process function will run a test in a
• • new process context and wait for it to finish or fail to prevent TEST_ASSERT
• • to kill the main testing process.
• */

+void run_in_new_process(void (*func)(void));

+/**

• • Verify that the TDX is supported by KVM.
• */

+bool is_tdx_enabled(void);

+/**

• • Report test success to userspace.
• • Use TDX_TEST_ASSERT_SUCCESS() to assert that this function was called in the
• • guest.
• */

+void tdx_test_success(void);

+#endif // SELFTEST_TDX_TEST_UTIL_H diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S new file mode 100644 index 000000000000..df9c1ed4bb2d --- /dev/null +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdcall.S @@ -0,0 +1,90 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* Adapted from arch/x86/coco/tdx/tdcall.S */

+#define TDX_HYPERCALL_r10 0 /* offsetof(struct tdx_hypercall_args, r10) */ +#define TDX_HYPERCALL_r11 8 /* offsetof(struct tdx_hypercall_args, r11) */ +#define TDX_HYPERCALL_r12 16 /* offsetof(struct tdx_hypercall_args, r12) */ +#define TDX_HYPERCALL_r13 24 /* offsetof(struct tdx_hypercall_args, r13) */ +#define TDX_HYPERCALL_r14 32 /* offsetof(struct tdx_hypercall_args, r14) */ +#define TDX_HYPERCALL_r15 40 /* offsetof(struct tdx_hypercall_args, r15) */

+/*

• • Bitmasks of exposed registers (with VMM).
• */

+#define TDX_R10 0x400 +#define TDX_R11 0x800 +#define TDX_R12 0x1000 +#define TDX_R13 0x2000 +#define TDX_R14 0x4000 +#define TDX_R15 0x8000

+#define TDX_HCALL_HAS_OUTPUT 0x1

+/*

• • These registers are clobbered to hold arguments for each
• • TDVMCALL. They are safe to expose to the VMM.
• • Each bit in this mask represents a register ID. Bit field
• • details can be found in TDX GHCI specification, section
• • titled "TDCALL [TDG.VP.VMCALL] leaf".
• */

+#define TDVMCALL_EXPOSE_REGS_MASK ( TDX_R10 | TDX_R11 | \

• 			  TDX_R12 | TDX_R13 | \
  

• 			  TDX_R14 | TDX_R15 )
  

+.code64 +.section .text

+.globl __tdx_hypercall +.type __tdx_hypercall, @function +__tdx_hypercall:

• /* Set up stack frame */
• push %rbp
• movq %rsp, %rbp
• /* Save callee-saved GPRs as mandated by the x86_64 ABI */
• push %r15
• push %r14
• push %r13
• push %r12
• /* Mangle function call ABI into TDCALL ABI: */
• /* Set TDCALL leaf ID (TDVMCALL (0)) in RAX */
• xor %eax, %eax
• /* Copy hypercall registers from arg struct: */
• movq TDX_HYPERCALL_r10(%rdi), %r10
• movq TDX_HYPERCALL_r11(%rdi), %r11
• movq TDX_HYPERCALL_r12(%rdi), %r12
• movq TDX_HYPERCALL_r13(%rdi), %r13
• movq TDX_HYPERCALL_r14(%rdi), %r14
• movq TDX_HYPERCALL_r15(%rdi), %r15
• movl $TDVMCALL_EXPOSE_REGS_MASK, %ecx
• tdcall
• /* TDVMCALL leaf return code is in R10 */
• movq %r10, %rax
• /* Copy hypercall result registers to arg struct if needed */
• testq $TDX_HCALL_HAS_OUTPUT, %rsi
• jz .Lout
• movq %r10, TDX_HYPERCALL_r10(%rdi)
• movq %r11, TDX_HYPERCALL_r11(%rdi)
• movq %r12, TDX_HYPERCALL_r12(%rdi)
• movq %r13, TDX_HYPERCALL_r13(%rdi)
• movq %r14, TDX_HYPERCALL_r14(%rdi)
• movq %r15, TDX_HYPERCALL_r15(%rdi)

+.Lout:

• /* Restore callee-saved GPRs as mandated by the x86_64 ABI */
• pop %r12
• pop %r13
• pop %r14
• pop %r15
• pop %rbp
• ret

+/* Disable executable stack */ +.section .note.GNU-stack,"",%progbits diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c new file mode 100644 index 000000000000..c2414523487a --- /dev/null +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: GPL-2.0-only

+#include "tdx/tdcall.h" +#include "tdx/tdx.h"

+uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size,

• 		      uint64_t write, uint64_t *data)
  

+{

• uint64_t ret;
• struct tdx_hypercall_args args = {

• .r10 = TDX_HYPERCALL_STANDARD,
  

• .r11 = TDG_VP_VMCALL_INSTRUCTION_IO,
  

• .r12 = size,
  

• .r13 = write,
  

• .r14 = port,
  

• };
• if (write)

• args.r15 = *data;
  

• ret = __tdx_hypercall(&args, write ? 0 : TDX_HCALL_HAS_OUTPUT);
• if (!write)

• *data = args.r11;
  

• return ret;

+} diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c index 063ff486fb86..b302060049d5 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c @@ -224,6 +224,7 @@ static void tdx_enable_capabilities(struct kvm_vm *vm) KVM_X2APIC_API_USE_32BIT_IDS | KVM_X2APIC_API_DISABLE_BROADCAST_QUIRK); vm_enable_cap(vm, KVM_CAP_SPLIT_IRQCHIP, 24);

• vm_enable_cap(vm, KVM_CAP_MAX_VCPUS, 512);

Since TDX spec doesn't define max vCPUs, is it a good idea to fix it to 512 in this common code?

How about to move this line to the specific test case where you are actually verifying this capability?

For example, move it to PATCH v5 21/29] KVM: selftests: TDX: Add TDG.VP.INFO test

+ vm_enable_cap(vm, KVM_CAP_MAX_VCPUS, 512); ...

TEST_ASSERT_EQ(ret_max_vcpus, 512);

On 12/13/2023 4:46 AM, Sagi Shahar wrote:

The test checks report_fatal_error functionality.

Signed-off-by: Sagi Shahar sagis@google.com Signed-off-by: Ackerley Tng ackerleytng@google.com Signed-off-by: Ryan Afranji afranji@google.com

---

.../selftests/kvm/include/x86_64/tdx/tdx.h | 6 ++- .../kvm/include/x86_64/tdx/tdx_util.h | 1 + .../kvm/include/x86_64/tdx/test_util.h | 19 ++++++++ .../selftests/kvm/lib/x86_64/tdx/tdx.c | 39 ++++++++++++++++ .../selftests/kvm/lib/x86_64/tdx/tdx_util.c | 12 +++++ .../selftests/kvm/lib/x86_64/tdx/test_util.c | 10 +++++ .../selftests/kvm/x86_64/tdx_vm_tests.c | 45 +++++++++++++++++++ 7 files changed, 131 insertions(+), 1 deletion(-)

diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h index a7161efe4ee2..1340c1070002 100644 --- a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h @@ -3,10 +3,14 @@ #define SELFTEST_TDX_TDX_H #include <stdint.h> +#include "kvm_util_base.h" -#define TDG_VP_VMCALL_INSTRUCTION_IO 30 +#define TDG_VP_VMCALL_REPORT_FATAL_ERROR 0x10003 +#define TDG_VP_VMCALL_INSTRUCTION_IO 30 +void handle_userspace_tdg_vp_vmcall_exit(struct kvm_vcpu *vcpu); uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size, uint64_t write, uint64_t *data); +void tdg_vp_vmcall_report_fatal_error(uint64_t error_code, uint64_t data_gpa); #endif // SELFTEST_TDX_TDX_H diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx_util.h b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx_util.h index 274b245f200b..32dd6b8fda46 100644 --- a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx_util.h +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx_util.h @@ -12,5 +12,6 @@ struct kvm_vm *td_create(void); void td_initialize(struct kvm_vm *vm, enum vm_mem_backing_src_type src_type, uint64_t attributes); void td_finalize(struct kvm_vm *vm); +void td_vcpu_run(struct kvm_vcpu *vcpu); #endif // SELFTESTS_TDX_KVM_UTIL_H diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h index b570b6d978ff..6d69921136bd 100644 --- a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h @@ -49,4 +49,23 @@ bool is_tdx_enabled(void); */ void tdx_test_success(void); +/**

• • Report an error with @error_code to userspace.
• • Return value from tdg_vp_vmcall_report_fatal_error is ignored since execution
• • is not expected to continue beyond this point.
• */

+void tdx_test_fatal(uint64_t error_code);

+/**

• • Report an error with @error_code to userspace.
• • @data_gpa may point to an optional shared guest memory holding the error
• • string.
• • Return value from tdg_vp_vmcall_report_fatal_error is ignored since execution
• • is not expected to continue beyond this point.
• */

+void tdx_test_fatal_with_data(uint64_t error_code, uint64_t data_gpa);

• #endif // SELFTEST_TDX_TEST_UTIL_H

diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c index c2414523487a..b854c3aa34ff 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c @@ -1,8 +1,31 @@ // SPDX-License-Identifier: GPL-2.0-only +#include <string.h>

• #include "tdx/tdcall.h" #include "tdx/tdx.h"

+void handle_userspace_tdg_vp_vmcall_exit(struct kvm_vcpu *vcpu) +{

• struct kvm_tdx_vmcall *vmcall_info = &vcpu->run->tdx.u.vmcall;
• uint64_t vmcall_subfunction = vmcall_info->subfunction;
• switch (vmcall_subfunction) {
• case TDG_VP_VMCALL_REPORT_FATAL_ERROR:

• vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;
  

• vcpu->run->system_event.ndata = 3;
  

• vcpu->run->system_event.data[0] =
  

• 	TDG_VP_VMCALL_REPORT_FATAL_ERROR;
  

• vcpu->run->system_event.data[1] = vmcall_info->in_r12;
  

• vcpu->run->system_event.data[2] = vmcall_info->in_r13;
  

• vmcall_info->status_code = 0;
  

• break;
  

• default:

• TEST_FAIL("TD VMCALL subfunction %lu is unsupported.\n",
  

• 	  vmcall_subfunction);
  

• }

+}

• uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size, uint64_t write, uint64_t *data) {

@@ -25,3 +48,19 @@ uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size, return ret; }

+void tdg_vp_vmcall_report_fatal_error(uint64_t error_code, uint64_t data_gpa) +{

• struct tdx_hypercall_args args;
• memset(&args, 0, sizeof(struct tdx_hypercall_args));
• if (data_gpa)

• error_code |= 0x8000000000000000;
  

• args.r11 = TDG_VP_VMCALL_REPORT_FATAL_ERROR;
• args.r12 = error_code;
• args.r13 = data_gpa;
• __tdx_hypercall(&args, 0);

+} diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c index b302060049d5..d745bb6287c1 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c @@ -10,6 +10,7 @@ #include "kvm_util.h" #include "test_util.h" +#include "tdx/tdx.h" #include "tdx/td_boot.h" #include "kvm_util_base.h" #include "processor.h" @@ -519,3 +520,14 @@ void td_finalize(struct kvm_vm *vm) tdx_td_finalizemr(vm); }

+void td_vcpu_run(struct kvm_vcpu *vcpu) +{

• vcpu_run(vcpu);
• /* Handle TD VMCALLs that require userspace handling. */
• if (vcpu->run->exit_reason == KVM_EXIT_TDX &&

•    vcpu->run->tdx.type == KVM_EXIT_TDX_VMCALL) {
  

• handle_userspace_tdg_vp_vmcall_exit(vcpu);
  

• }

+} diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c index 6905d0ca3877..7f3cd8089cea 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c @@ -32,3 +32,13 @@ void tdx_test_success(void) TDX_TEST_SUCCESS_SIZE, TDG_VP_VMCALL_INSTRUCTION_IO_WRITE, &code); }

+void tdx_test_fatal_with_data(uint64_t error_code, uint64_t data_gpa) +{

• tdg_vp_vmcall_report_fatal_error(error_code, data_gpa);

+}

+void tdx_test_fatal(uint64_t error_code) +{

• tdx_test_fatal_with_data(error_code, 0);

+} diff --git a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c index a18d1c9d6026..8638c7bbedaa 100644 --- a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c +++ b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c @@ -2,6 +2,7 @@ #include <signal.h> #include "kvm_util_base.h" +#include "tdx/tdx.h" #include "tdx/tdx_util.h" #include "tdx/test_util.h" #include "test_util.h" @@ -30,6 +31,49 @@ void verify_td_lifecycle(void) printf("\t ... PASSED\n"); } +void guest_code_report_fatal_error(void) +{

• uint64_t err;
• /*

• * Note: err should follow the GHCI spec definition:
  

• * bits 31:0 should be set to 0.
  

• * bits 62:32 are used for TD-specific extended error code.
  

• * bit 63 is used to mark additional information in shared memory.
  

• */
  

• err = 0x0BAAAAAD00000000;
• if (err)

• tdx_test_fatal(err);
  

Nit: Since the error code is a constant, no need to use if statement. Or even save the variable?

• tdx_test_success();

+} +void verify_report_fatal_error(void) +{

• struct kvm_vm *vm;
• struct kvm_vcpu *vcpu;
• vm = td_create();
• td_initialize(vm, VM_MEM_SRC_ANONYMOUS, 0);
• vcpu = td_vcpu_add(vm, 0, guest_code_report_fatal_error);
• td_finalize(vm);
• printf("Verifying report_fatal_error:\n");
• td_vcpu_run(vcpu);
• TEST_ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_SYSTEM_EVENT);
• TEST_ASSERT_EQ(vcpu->run->system_event.ndata, 3);
• TEST_ASSERT_EQ(vcpu->run->system_event.data[0], TDG_VP_VMCALL_REPORT_FATAL_ERROR);
• TEST_ASSERT_EQ(vcpu->run->system_event.data[1], 0x0BAAAAAD00000000);
• TEST_ASSERT_EQ(vcpu->run->system_event.data[2], 0);
• vcpu_run(vcpu);
• TDX_TEST_ASSERT_SUCCESS(vcpu);
• kvm_vm_free(vm);
• printf("\t ... PASSED\n");

+}

• int main(int argc, char **argv) { setbuf(stdout, NULL);

@@ -40,6 +84,7 @@ int main(int argc, char **argv) } run_in_new_process(&verify_td_lifecycle);

• run_in_new_process(&verify_report_fatal_error);

return 0; }

...

diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h index b570b6d978ff..6d69921136bd 100644 --- a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h @@ -49,4 +49,23 @@ bool is_tdx_enabled(void); */ void tdx_test_success(void); +/**

• • Report an error with @error_code to userspace.
• • Return value from tdg_vp_vmcall_report_fatal_error is ignored since execution
• • is not expected to continue beyond this point.
• */

+void tdx_test_fatal(uint64_t error_code);

+/**

• • Report an error with @error_code to userspace.
• • @data_gpa may point to an optional shared guest memory holding the error
• • string.
• • Return value from tdg_vp_vmcall_report_fatal_error is ignored since execution
• • is not expected to continue beyond this point.
• */

+void tdx_test_fatal_with_data(uint64_t error_code, uint64_t data_gpa);

I found nowhere is using "data_gpa" as a gpa, even in patch 23, it's usage is to pass a line number ("tdx_test_fatal_with_data(ret, __LINE__)").

#endif // SELFTEST_TDX_TEST_UTIL_H diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c index c2414523487a..b854c3aa34ff 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c @@ -1,8 +1,31 @@ // SPDX-License-Identifier: GPL-2.0-only +#include <string.h>

#include "tdx/tdcall.h" #include "tdx/tdx.h" +void handle_userspace_tdg_vp_vmcall_exit(struct kvm_vcpu *vcpu) +{

• struct kvm_tdx_vmcall *vmcall_info = &vcpu->run->tdx.u.vmcall;
• uint64_t vmcall_subfunction = vmcall_info->subfunction;
• switch (vmcall_subfunction) {
• case TDG_VP_VMCALL_REPORT_FATAL_ERROR:

• vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;
  

• vcpu->run->system_event.ndata = 3;
  

• vcpu->run->system_event.data[0] =
  

• 	TDG_VP_VMCALL_REPORT_FATAL_ERROR;
  

• vcpu->run->system_event.data[1] = vmcall_info->in_r12;
  

• vcpu->run->system_event.data[2] = vmcall_info->in_r13;
  

• vmcall_info->status_code = 0;
  

• break;
  

• default:

• TEST_FAIL("TD VMCALL subfunction %lu is unsupported.\n",
  

• 	  vmcall_subfunction);
  

• }

+}

uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size, uint64_t write, uint64_t *data) { @@ -25,3 +48,19 @@ uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size, return ret; }

+void tdg_vp_vmcall_report_fatal_error(uint64_t error_code, uint64_t data_gpa) +{

• struct tdx_hypercall_args args;
• memset(&args, 0, sizeof(struct tdx_hypercall_args));
• if (data_gpa)

• error_code |= 0x8000000000000000;
  
  

So, why this error_code needs to set bit 63?

• args.r11 = TDG_VP_VMCALL_REPORT_FATAL_ERROR;
• args.r12 = error_code;
• args.r13 = data_gpa;
• __tdx_hypercall(&args, 0);

+} diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c index b302060049d5..d745bb6287c1 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx_util.c @@ -10,6 +10,7 @@ #include "kvm_util.h" #include "test_util.h" +#include "tdx/tdx.h" #include "tdx/td_boot.h" #include "kvm_util_base.h" #include "processor.h" @@ -519,3 +520,14 @@ void td_finalize(struct kvm_vm *vm) tdx_td_finalizemr(vm); }

+void td_vcpu_run(struct kvm_vcpu *vcpu) +{

• vcpu_run(vcpu);
• /* Handle TD VMCALLs that require userspace handling. */
• if (vcpu->run->exit_reason == KVM_EXIT_TDX &&

•    vcpu->run->tdx.type == KVM_EXIT_TDX_VMCALL) {
  

• handle_userspace_tdg_vp_vmcall_exit(vcpu);
  

• }

+} diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c index 6905d0ca3877..7f3cd8089cea 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/test_util.c @@ -32,3 +32,13 @@ void tdx_test_success(void) TDX_TEST_SUCCESS_SIZE, TDG_VP_VMCALL_INSTRUCTION_IO_WRITE, &code); }

+void tdx_test_fatal_with_data(uint64_t error_code, uint64_t data_gpa) +{

• tdg_vp_vmcall_report_fatal_error(error_code, data_gpa);

+}

+void tdx_test_fatal(uint64_t error_code) +{

• tdx_test_fatal_with_data(error_code, 0);

+} diff --git a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c index a18d1c9d6026..8638c7bbedaa 100644 --- a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c +++ b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c @@ -2,6 +2,7 @@ #include <signal.h> #include "kvm_util_base.h" +#include "tdx/tdx.h" #include "tdx/tdx_util.h" #include "tdx/test_util.h" #include "test_util.h" @@ -30,6 +31,49 @@ void verify_td_lifecycle(void) printf("\t ... PASSED\n"); } +void guest_code_report_fatal_error(void) +{

• uint64_t err;
• /*

• * Note: err should follow the GHCI spec definition:
  

• * bits 31:0 should be set to 0.
  

• * bits 62:32 are used for TD-specific extended error code.
  

• * bit 63 is used to mark additional information in shared memory.
  

• */
  

• err = 0x0BAAAAAD00000000;
• if (err)

• tdx_test_fatal(err);
  

• tdx_test_success();

+} +void verify_report_fatal_error(void) +{

• struct kvm_vm *vm;
• struct kvm_vcpu *vcpu;
• vm = td_create();
• td_initialize(vm, VM_MEM_SRC_ANONYMOUS, 0);
• vcpu = td_vcpu_add(vm, 0, guest_code_report_fatal_error);
• td_finalize(vm);
• printf("Verifying report_fatal_error:\n");
• td_vcpu_run(vcpu);
• TEST_ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_SYSTEM_EVENT);
• TEST_ASSERT_EQ(vcpu->run->system_event.ndata, 3);
• TEST_ASSERT_EQ(vcpu->run->system_event.data[0], TDG_VP_VMCALL_REPORT_FATAL_ERROR);
• TEST_ASSERT_EQ(vcpu->run->system_event.data[1], 0x0BAAAAAD00000000);
• TEST_ASSERT_EQ(vcpu->run->system_event.data[2], 0);
• vcpu_run(vcpu);
• TDX_TEST_ASSERT_SUCCESS(vcpu);
• kvm_vm_free(vm);
• printf("\t ... PASSED\n");

+}

int main(int argc, char **argv) { setbuf(stdout, NULL); @@ -40,6 +84,7 @@ int main(int argc, char **argv) } run_in_new_process(&verify_td_lifecycle);

• run_in_new_process(&verify_report_fatal_error);

return 0; } -- 2.43.0.472.g3155946c3a-goog

On Fri, Apr 12, 2024 at 04:56:36AM +0000, Ackerley Tng wrote:

Yan Zhao yan.y.zhao@intel.com writes:

...

...

...

diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h index b570b6d978ff..6d69921136bd 100644 --- a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h @@ -49,4 +49,23 @@ bool is_tdx_enabled(void); */ void tdx_test_success(void); +/**

• • Report an error with @error_code to userspace.
• • Return value from tdg_vp_vmcall_report_fatal_error is ignored since execution
• • is not expected to continue beyond this point.
• */

+void tdx_test_fatal(uint64_t error_code);

+/**

• • Report an error with @error_code to userspace.
• • @data_gpa may point to an optional shared guest memory holding the error
• • string.
• • Return value from tdg_vp_vmcall_report_fatal_error is ignored since execution
• • is not expected to continue beyond this point.
• */

+void tdx_test_fatal_with_data(uint64_t error_code, uint64_t data_gpa);

I found nowhere is using "data_gpa" as a gpa, even in patch 23, it's usage is to pass a line number ("tdx_test_fatal_with_data(ret, __LINE__)").

This function tdx_test_fatal_with_data() is meant to provide a generic interface for TDX tests to use TDG.VP.VMCALL<ReportFatalError>, and so the parameters of tdx_test_fatal_with_data() generically allow error_code and data_gpa to be specified.

The tests just happen to use the data_gpa parameter to pass __LINE__ to the host VMM, but other tests in future that use the tdx_test_fatal_with_data() function in the TDX testing library could actually pass a GPA through using data_gpa.

...

...

#endif // SELFTEST_TDX_TEST_UTIL_H diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c index c2414523487a..b854c3aa34ff 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c @@ -1,8 +1,31 @@ // SPDX-License-Identifier: GPL-2.0-only +#include <string.h>

#include "tdx/tdcall.h" #include "tdx/tdx.h" +void handle_userspace_tdg_vp_vmcall_exit(struct kvm_vcpu *vcpu) +{

• struct kvm_tdx_vmcall *vmcall_info = &vcpu->run->tdx.u.vmcall;
• uint64_t vmcall_subfunction = vmcall_info->subfunction;
• switch (vmcall_subfunction) {
• case TDG_VP_VMCALL_REPORT_FATAL_ERROR:

• vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;
  

• vcpu->run->system_event.ndata = 3;
  

• vcpu->run->system_event.data[0] =
  

• 	TDG_VP_VMCALL_REPORT_FATAL_ERROR;
  

• vcpu->run->system_event.data[1] = vmcall_info->in_r12;
  

• vcpu->run->system_event.data[2] = vmcall_info->in_r13;
  

• vmcall_info->status_code = 0;
  

• break;
  

• default:

• TEST_FAIL("TD VMCALL subfunction %lu is unsupported.\n",
  

• 	  vmcall_subfunction);
  

• }

+}

uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size, uint64_t write, uint64_t *data) { @@ -25,3 +48,19 @@ uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size, return ret; }

+void tdg_vp_vmcall_report_fatal_error(uint64_t error_code, uint64_t data_gpa) +{

• struct tdx_hypercall_args args;
• memset(&args, 0, sizeof(struct tdx_hypercall_args));
• if (data_gpa)

• error_code |= 0x8000000000000000;
  
  

So, why this error_code needs to set bit 63?

The Intel GHCI Spec says in R12, bit 63 is set if the GPA is valid. As a

But above "__LINE__" is obviously not a valid GPA.

Do you think it's better to check "data_gpa" is with shared bit on and aligned in 4K before setting bit 63?

generic TDX testing library function, this check allows the user to use tdg_vp_vmcall_report_fatal_error() with error_code and data_gpa and not worry about setting bit 63 before calling tdg_vp_vmcall_report_fatal_error(), though if the user set bit 63 before that, there is no issue.

...

...

• args.r11 = TDG_VP_VMCALL_REPORT_FATAL_ERROR;
• args.r12 = error_code;
• args.r13 = data_gpa;
• __tdx_hypercall(&args, 0);

+}

...

...

<snip>

On Mon, Apr 15, 2024 at 08:05:49AM +0000, Ackerley Tng wrote:

Yan Zhao yan.y.zhao@intel.com writes:

...

On Fri, Apr 12, 2024 at 04:56:36AM +0000, Ackerley Tng wrote:

...

Yan Zhao yan.y.zhao@intel.com writes:

...

...

...

diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h index b570b6d978ff..6d69921136bd 100644 --- a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h @@ -49,4 +49,23 @@ bool is_tdx_enabled(void); */ void tdx_test_success(void); +/**

• • Report an error with @error_code to userspace.
• • Return value from tdg_vp_vmcall_report_fatal_error is ignored since execution
• • is not expected to continue beyond this point.
• */

+void tdx_test_fatal(uint64_t error_code);

+/**

• • Report an error with @error_code to userspace.
• • @data_gpa may point to an optional shared guest memory holding the error
• • string.
• • Return value from tdg_vp_vmcall_report_fatal_error is ignored since execution
• • is not expected to continue beyond this point.
• */

+void tdx_test_fatal_with_data(uint64_t error_code, uint64_t data_gpa);

I found nowhere is using "data_gpa" as a gpa, even in patch 23, it's usage is to pass a line number ("tdx_test_fatal_with_data(ret, __LINE__)").

This function tdx_test_fatal_with_data() is meant to provide a generic interface for TDX tests to use TDG.VP.VMCALL<ReportFatalError>, and so the parameters of tdx_test_fatal_with_data() generically allow error_code and data_gpa to be specified.

The tests just happen to use the data_gpa parameter to pass __LINE__ to the host VMM, but other tests in future that use the tdx_test_fatal_with_data() function in the TDX testing library could actually pass a GPA through using data_gpa.

...

...

#endif // SELFTEST_TDX_TEST_UTIL_H diff --git a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c index c2414523487a..b854c3aa34ff 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c @@ -1,8 +1,31 @@ // SPDX-License-Identifier: GPL-2.0-only +#include <string.h>

#include "tdx/tdcall.h" #include "tdx/tdx.h" +void handle_userspace_tdg_vp_vmcall_exit(struct kvm_vcpu *vcpu) +{

• struct kvm_tdx_vmcall *vmcall_info = &vcpu->run->tdx.u.vmcall;
• uint64_t vmcall_subfunction = vmcall_info->subfunction;
• switch (vmcall_subfunction) {
• case TDG_VP_VMCALL_REPORT_FATAL_ERROR:

• vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;
  

• vcpu->run->system_event.ndata = 3;
  

• vcpu->run->system_event.data[0] =
  

• 	TDG_VP_VMCALL_REPORT_FATAL_ERROR;
  

• vcpu->run->system_event.data[1] = vmcall_info->in_r12;
  

• vcpu->run->system_event.data[2] = vmcall_info->in_r13;
  

• vmcall_info->status_code = 0;
  

• break;
  

• default:

• TEST_FAIL("TD VMCALL subfunction %lu is unsupported.\n",
  

• 	  vmcall_subfunction);
  

• }

+}

uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size, uint64_t write, uint64_t *data) { @@ -25,3 +48,19 @@ uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size, return ret; }

+void tdg_vp_vmcall_report_fatal_error(uint64_t error_code, uint64_t data_gpa) +{

• struct tdx_hypercall_args args;
• memset(&args, 0, sizeof(struct tdx_hypercall_args));
• if (data_gpa)

• error_code |= 0x8000000000000000;
  
  

So, why this error_code needs to set bit 63?

The Intel GHCI Spec says in R12, bit 63 is set if the GPA is valid. As a

But above "__LINE__" is obviously not a valid GPA.

Do you think it's better to check "data_gpa" is with shared bit on and aligned in 4K before setting bit 63?

I read "valid" in the spec to mean that the value in R13 "should be considered as useful" or "should be passed on to the host VMM via the TDX module", and not so much as in "validated".

We could validate the data_gpa as you suggested to check alignment and shared bit, but perhaps that could be a higher-level function that calls tdg_vp_vmcall_report_fatal_error()?

If it helps, shall we rename "data_gpa" to "data" for this lower-level, generic helper function and remove these two lines

if (data_gpa) error_code |= 0x8000000000000000;

A higher-level function could perhaps do the validation as you suggested and then set bit 63.

This could be all right. But I'm not sure if it would be a burden for higher-level function to set bit 63 which is of GHCI details.

What about adding another "data_gpa_valid" parameter and then test "data_gpa_valid" rather than test "data_gpa" to set bit 63?

Are you objecting to the use of R13 to hold extra test information, such as __LINE__?

I feel that R13 is just another register that could be used to hold error information, and in the case of this test, we can use it to send __LINE__ to aid in debugging selftests. On the host side of the selftest we can printf() :).

Hmm, I just feel it's confusing to use R13 as error code holder and set gpa_valid bit on at the same time. As it looks complicated to convert __LINE__ to a string in a shared GPA, maybe it's ok to pass it in R13 :)

...

...

generic TDX testing library function, this check allows the user to use tdg_vp_vmcall_report_fatal_error() with error_code and data_gpa and not worry about setting bit 63 before calling tdg_vp_vmcall_report_fatal_error(), though if the user set bit 63 before that, there is no issue.

...

...

• args.r11 = TDG_VP_VMCALL_REPORT_FATAL_ERROR;
• args.r12 = error_code;
• args.r13 = data_gpa;
• __tdx_hypercall(&args, 0);

+}

...

...

<snip>

On Tue, Dec 12, 2023 at 12:46:25PM -0800, Sagi Shahar wrote:

From: Erdem Aktas erdemaktas@google.com

Verifies TDVMCALL<INSTRUCTION.IO> READ and WRITE operations.

Signed-off-by: Erdem Aktas erdemaktas@google.com Signed-off-by: Sagi Shahar sagis@google.com Signed-off-by: Ackerley Tng ackerleytng@google.com Signed-off-by: Ryan Afranji afranji@google.com

---

.../kvm/include/x86_64/tdx/test_util.h | 34 ++++++++ .../selftests/kvm/x86_64/tdx_vm_tests.c | 82 +++++++++++++++++++ 2 files changed, 116 insertions(+)

diff --git a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h index 6d69921136bd..95a5d5be7f0b 100644 --- a/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/test_util.h @@ -9,6 +9,40 @@ #define TDX_TEST_SUCCESS_PORT 0x30 #define TDX_TEST_SUCCESS_SIZE 4 +/**

• • Assert that some IO operation involving tdg_vp_vmcall_instruction_io() was
• • called in the guest.
• */

+#define TDX_TEST_ASSERT_IO(VCPU, PORT, SIZE, DIR) \

• do { \

• TEST_ASSERT((VCPU)->run->exit_reason == KVM_EXIT_IO,	\
  

• 	"Got exit_reason other than KVM_EXIT_IO: %u (%s)\n", \
  

• 	(VCPU)->run->exit_reason,			\
  

• 	exit_reason_str((VCPU)->run->exit_reason));	\
  

• 							\
  

• TEST_ASSERT(((VCPU)->run->exit_reason == KVM_EXIT_IO) && \
  

• 	((VCPU)->run->io.port == (PORT)) &&		\
  

• 	((VCPU)->run->io.size == (SIZE)) &&		\
  

• 	((VCPU)->run->io.direction == (DIR)),		\
  

• 	"Got unexpected IO exit values: %u (%s) %d %d %d\n", \
  

• 	(VCPU)->run->exit_reason,			\
  

• 	exit_reason_str((VCPU)->run->exit_reason),	\
  

• 	(VCPU)->run->io.port, (VCPU)->run->io.size,	\
  

• 	(VCPU)->run->io.direction);			\
  

• } while (0)

+/**

• • Check and report if there was some failure in the guest, either an exception
• • like a triple fault, or if a tdx_test_fatal() was hit.
• */

+#define TDX_TEST_CHECK_GUEST_FAILURE(VCPU) \

• do { \

• if ((VCPU)->run->exit_reason == KVM_EXIT_SYSTEM_EVENT)	\
  

• 	TEST_FAIL("Guest reported error. error code: %lld (0x%llx)\n", \
  

• 		(VCPU)->run->system_event.data[1],	\
  

• 		(VCPU)->run->system_event.data[1]);	\
  

• } while (0)

/**

• Assert that tdx_test_success() was called in the guest.

*/ diff --git a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c index 8638c7bbedaa..75467c407ca7 100644 --- a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c +++ b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c @@ -2,6 +2,7 @@ #include <signal.h> #include "kvm_util_base.h" +#include "tdx/tdcall.h" #include "tdx/tdx.h" #include "tdx/tdx_util.h" #include "tdx/test_util.h" @@ -74,6 +75,86 @@ void verify_report_fatal_error(void) printf("\t ... PASSED\n"); } +#define TDX_IOEXIT_TEST_PORT 0x50

+/*

• • Verifies IO functionality by writing a |value| to a predefined port.
• • Verifies that the read value is |value| + 1 from the same port.
• • If all the tests are passed then write a value to port TDX_TEST_PORT
• */

+void guest_ioexit(void) +{

• uint64_t data_out, data_in, delta;
• uint64_t ret;
• data_out = 0xAB;
• ret = tdg_vp_vmcall_instruction_io(TDX_IOEXIT_TEST_PORT, 1,

• 			TDG_VP_VMCALL_INSTRUCTION_IO_WRITE,
  

• 			&data_out);
  

• if (ret)

• tdx_test_fatal(ret);
  

• ret = tdg_vp_vmcall_instruction_io(TDX_IOEXIT_TEST_PORT, 1,

• 			TDG_VP_VMCALL_INSTRUCTION_IO_READ,
  

• 			&data_in);
  

• if (ret)

• tdx_test_fatal(ret);
  

• delta = data_in - data_out;
• if (delta != 1)

• tdx_test_fatal(ret);
  

• tdx_test_success();

+}

+void verify_td_ioexit(void) +{

• struct kvm_vm *vm;
• struct kvm_vcpu *vcpu;
• uint32_t port_data;
• vm = td_create();
• td_initialize(vm, VM_MEM_SRC_ANONYMOUS, 0);
• vcpu = td_vcpu_add(vm, 0, guest_ioexit);
• td_finalize(vm);
• printf("Verifying TD IO Exit:\n");
• /* Wait for guest to do a IO write */
• td_vcpu_run(vcpu);
• TDX_TEST_CHECK_GUEST_FAILURE(vcpu);