On Tue, Feb 20, 2024 at 7:43 PM Binbin Wu binbin.wu@linux.intel.com wrote:

On 12/13/2023 4:46 AM, 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));
  

How can this be guaranteed? For ____vm_vaddr_alloc(), generically there is no enforcement about the identity of virtual and physical address.

The problem is that if the allocation won't be 1-to-1 the tests won't work. So we figured it's better to fail early. The way this is used in practice generally guarantees that the mapping can be 1-to-1 since we create these mappings at an early stage.

...

• return gva;
  

+}

• /*
  • VM Virtual Address Allocate Pages

On Thu, Mar 21, 2024 at 5:29 PM Zhang, Dongsheng X dongsheng.x.zhang@intel.com wrote:

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()

Thanks for the input. Will switch to vm_vaddr_identity_alloc()

...

• 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/13/2023 4:46 AM, 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.
• • 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);
  

• memset(init_vm, 0, 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);

+}

+/*

• • 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];
• 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");

Do we also need to check idtr.base?

+}

+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.
• */

Since both sev and tdx need sparsebit_for_each_set_range(), can it be moved to a header file to avoid code duplication?

+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);

+}

+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);

+}

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

From: Ackerley Tng ackerleytng@google.com

This also exercises the KVM_TDX_CAPABILITIES ioctl.

Suggested-by: Isaku Yamahata isaku.yamahata@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/lib/x86_64/tdx/tdx_util.c | 69 ++++++++++++++++++- 1 file changed, 66 insertions(+), 3 deletions(-)

Nit: Can also dump 'supported_gpaw' in tdx_read_capabilities().

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

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 9b69c733ce01..6b995c3f6153 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 @@ -27,10 +27,9 @@ static char *tdx_cmd_str[] = { }; #define TDX_MAX_CMD_STR (ARRAY_SIZE(tdx_cmd_str)) -static void tdx_ioctl(int fd, int ioctl_no, uint32_t flags, void *data) +static int _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); @@ -40,11 +39,58 @@ static void tdx_ioctl(int fd, int ioctl_no, uint32_t flags, void *data) tdx_cmd.flags = flags; tdx_cmd.data = (uint64_t)data;

• r = ioctl(fd, KVM_MEMORY_ENCRYPT_OP, &tdx_cmd);

• return ioctl(fd, KVM_MEMORY_ENCRYPT_OP, &tdx_cmd);

+}

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

• int r;
• r = _tdx_ioctl(fd, ioctl_no, flags, data); TEST_ASSERT(r == 0, "%s failed: %d %d", tdx_cmd_str[ioctl_no], r, errno); }

+static struct kvm_tdx_capabilities *tdx_read_capabilities(struct kvm_vm *vm) +{

• int i;
• int rc = -1;
• int nr_cpuid_configs = 4;
• struct kvm_tdx_capabilities *tdx_cap = NULL;
• do {

• nr_cpuid_configs *= 2;
  

• tdx_cap = realloc(
  

• 	tdx_cap, sizeof(*tdx_cap) +
  

• 	nr_cpuid_configs * sizeof(*tdx_cap->cpuid_configs));
  

• TEST_ASSERT(tdx_cap != NULL,
  

• 	    "Could not allocate memory for tdx capability nr_cpuid_configs %d\n",
  

• 	    nr_cpuid_configs);
  

• tdx_cap->nr_cpuid_configs = nr_cpuid_configs;
  

• rc = _tdx_ioctl(vm->fd, KVM_TDX_CAPABILITIES, 0, tdx_cap);
  

• } while (rc < 0 && errno == E2BIG);
• TEST_ASSERT(rc == 0, "KVM_TDX_CAPABILITIES failed: %d %d",

•     rc, errno);
  

• pr_debug("tdx_cap: attrs: fixed0 0x%016llx fixed1 0x%016llx\n"

•  "tdx_cap: xfam fixed0 0x%016llx fixed1 0x%016llx\n",
  

•  tdx_cap->attrs_fixed0, tdx_cap->attrs_fixed1,
  

•  tdx_cap->xfam_fixed0, tdx_cap->xfam_fixed1);
  

• for (i = 0; i < tdx_cap->nr_cpuid_configs; i++) {

• const struct kvm_tdx_cpuid_config *config =
  

• 	&tdx_cap->cpuid_configs[i];
  

• pr_debug("cpuid config[%d]: leaf 0x%x sub_leaf 0x%x eax 0x%08x ebx 0x%08x ecx 0x%08x edx 0x%08x\n",
  

• 	 i, config->leaf, config->sub_leaf,
  

• 	 config->eax, config->ebx, config->ecx, config->edx);
  

• }
• return tdx_cap;

+}

• #define XFEATURE_MASK_CET (XFEATURE_MASK_CET_USER | XFEATURE_MASK_CET_KERNEL)

static void tdx_apply_cpuid_restrictions(struct kvm_cpuid2 *cpuid_data) @@ -78,6 +124,21 @@ static void tdx_apply_cpuid_restrictions(struct kvm_cpuid2 *cpuid_data) } } +static void tdx_check_attributes(struct kvm_vm *vm, uint64_t attributes) +{

• struct kvm_tdx_capabilities *tdx_cap;
• tdx_cap = tdx_read_capabilities(vm);
• /* TDX spec: any bits 0 in attrs_fixed0 must be 0 in attributes */
• TEST_ASSERT_EQ(attributes & ~tdx_cap->attrs_fixed0, 0);
• /* TDX spec: any bits 1 in attrs_fixed1 must be 1 in attributes */
• TEST_ASSERT_EQ(attributes & tdx_cap->attrs_fixed1, tdx_cap->attrs_fixed1);
• free(tdx_cap);

+}

• static void tdx_td_init(struct kvm_vm *vm, uint64_t attributes) { const struct kvm_cpuid2 *cpuid;

@@ -91,6 +152,8 @@ static void tdx_td_init(struct kvm_vm *vm, uint64_t attributes) memset(init_vm, 0, sizeof(*init_vm)); memcpy(&init_vm->cpuid, cpuid, kvm_cpuid2_size(cpuid->nent));

• tdx_check_attributes(vm, attributes);
• init_vm->attributes = attributes;

tdx_apply_cpuid_restrictions(&init_vm->cpuid);

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

From: Ackerley Tng ackerleytng@google.com

If guest memory is backed by restricted memfd

• UPM is being used, hence encrypted memory region has to be registered
• Can avoid making a copy of guest memory before getting TDX to initialize the memory region

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/lib/x86_64/tdx/tdx_util.c | 41 +++++++++++++++---- 1 file changed, 32 insertions(+), 9 deletions(-)

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 6b995c3f6153..063ff486fb86 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 @@ -192,6 +192,21 @@ static void tdx_td_finalizemr(struct kvm_vm *vm) tdx_ioctl(vm->fd, KVM_TDX_FINALIZE_VM, 0, NULL); } +/*

• • Other ioctls
• */

+/**

• • Register a memory region that may contain encrypted data in KVM.
• */

+static void register_encrypted_memory_region(

• struct kvm_vm *vm, struct userspace_mem_region *region)

+{

• vm_set_memory_attributes(vm, region->region.guest_phys_addr,

• 		 region->region.memory_size,
  

• 		 KVM_MEMORY_ATTRIBUTE_PRIVATE);
  

+}

/*

• TD creation/setup/finalization

*/ @@ -376,30 +391,38 @@ static void load_td_memory_region(struct kvm_vm *vm, if (!sparsebit_any_set(pages)) return;

• if (region->region.guest_memfd != -1)

• register_encrypted_memory_region(vm, region);
  

• 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;
  

• void *source_addr = (void *)hva;
  

/* * 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);
  

• if (region->region.guest_memfd == -1) {
  

• 	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);
  

• 	memset((void *)hva, 0, size_to_load);
  

• }
  

tdx_init_mem_region(vm, source_addr, gpa, size_to_load);

• munmap(source_addr, size_to_load);
  

• if (region->region.guest_memfd == -1)
  

• 	munmap(source_addr, size_to_load);
  

  }

For memslot 0, 1, 2, when guest_memfd != -1, is it possible to also munmap(mmap_start, mmap_size) after finish loading?

} -- 2.43.0.472.g3155946c3a-goog

Hi Sagi,

On 2023-12-12 at 12:46:23 -0800, 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);

} 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);

From a user point of view, this lifecycle test is very useful to me for vm creation/destruction time test, and I believe you have an enhanced version to specify the memory size. May I know if there is any plan to add that part too? And maybe allow the user to customize the memory size rather than a fixed size.

thanks, Chenyu

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);

This is not a must for TD life cycle? Though I know, currently, the selftest will fail without setting this line, due to TD's default max vcpu count is -1. But I guess it's an error. https://lore.kernel.org/all/ZeGC64sAzg4EN3G5@yzhao56-desk.sh.intel.com/

"Zhang, Dongsheng X" dongsheng.x.zhang@intel.com writes:

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

I was actually thinking to align all the macro definitions with the definitions in the Intel GHCI Spec, so

3.9 TDG.VP.VMCALL<Instruction.IO>

becomes TDG_VP_VMCALL_INSTRUCTION_IO and then add suffixes READ and WRITE for the directions.

PORT_READ and PORT_WRITE seem a little too unspecific, but I agree that TDG_VP_VMCALL_INSTRUCTION_IO_READ/TDG_VP_VMCALL_INSTRUCTION_IO_WRITE are 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

I think aligning macro definitions with the spec is better in this case.

It seems odd to be calling an EXIT_REASON_* when making a hypercall.

Later on in this patch series this macro is added

#define TDG_VP_VMCALL_VE_REQUEST_MMIO 48

which matches

3.7 TDG.VP.VMCALL<#VE.RequestMMIO>

in the Intel GHCI Spec.

The equivalent EXIT_REASON is EXIT_REASON_EPT_VIOLATION, which I feel doesn't carry the same meaning as an explicit request for MMIO, as in TDG_VP_VMCALL_VE_REQUEST_MMIO.

So I think even though the numbers are the same, they don't carry the same meaning and it's probably better to have different macro definitions.

Or we could define one in terms of the other?

Later on in this patch series other macros are also added, specific to TDX

#define TDG_VP_VMCALL_GET_TD_VM_CALL_INFO 0x10000 #define TDG_VP_VMCALL_MAP_GPA 0x10001 #define TDG_VP_VMCALL_REPORT_FATAL_ERROR 0x10003

which matches

3.1 TDG.VP.VMCALL<GetTdVmCallInfo> 3.2 TDG.VP.VMCALL<MapGPA> 3.4 TDG.VP.VMCALL<ReportFatalError>

in the Intel GHCI Spec.

It's nice to have the naming convention for all the VMCALLs line up. :)

...

+uint64_t tdg_vp_vmcall_instruction_io(uint64_t port, uint64_t size,

• 		      uint64_t write, uint64_t *data);
  

...

<snip>

...

+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)

Will fix this, thanks!

...

+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 Fri, Mar 22, 2024 at 4:33 PM Chen, Zide zide.chen@intel.com wrote:

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);

See Yan Zhao's comment above. This was needed in the previous implementation of TDX and without it the tests would fail. With the new fix I'm going to remove this from the common code.

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; }

On Fri, Mar 1, 2024 at 12:52 AM Binbin Wu binbin.wu@linux.intel.com wrote:

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);
  

I find tdx_test_fatal() is called a lot and each call site checks the err before calling it. Is it simpler to move the check of err inside of tdx_test_fatal() so that the callers just call it without check it every time?