[RFC PATCH v2 03/17] KVM: selftest: Adding TDX life cycle test.

From: Sagi Shahar
Date: Tue Aug 30 2022 - 18:20:35 EST

From: Erdem Aktas <erdemaktas@xxxxxxxxxx>

Adding a test to verify TDX lifecycle by creating a TD and running a
dummy TDVMCALL<INSTRUCTION.IO> inside it.

Signed-off-by: Erdem Aktas <erdemaktas@xxxxxxxxxx>
Signed-off-by: Sagi Shahar <sagis@xxxxxxxxxx>
Signed-off-by: Ryan Afranji <afranji@xxxxxxxxxx>
---
tools/testing/selftests/kvm/Makefile | 1 +
tools/testing/selftests/kvm/lib/x86_64/tdx.h | 149 ++++++++++++++++++
.../selftests/kvm/x86_64/tdx_vm_tests.c | 104 ++++++++++++
3 files changed, 254 insertions(+)
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 ad4d60dadc06..208e0cc30048 100644
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -140,6 +140,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/lib/x86_64/tdx.h b/tools/testing/selftests/kvm/lib/x86_64/tdx.h
index 61b997dfc420..d5de52657112 100644
--- a/tools/testing/selftests/kvm/lib/x86_64/tdx.h
+++ b/tools/testing/selftests/kvm/lib/x86_64/tdx.h
@@ -51,6 +51,12 @@
#define _PAGE_RW (1UL<<1) /* writeable */
#define _PAGE_PS (1UL<<7) /* page size bit*/

+#define TDX_INSTRUCTION_IO 30
+
+#define TDX_SUCCESS_PORT 0x30
+#define TDX_IO_READ 0
+#define TDX_IO_WRITE 1
+
#define GDT_ENTRY(flags, base, limit) \
((((base) & 0xff000000ULL) << (56-24)) | \
(((flags) & 0x0000f0ffULL) << 40) | \
@@ -83,4 +89,147 @@ void prepare_source_image(struct kvm_vm *vm, void *guest_code,
size_t guest_code_size,
uint64_t guest_code_signature);

+/*
+ * Generic TDCALL function that can be used to communicate with TDX module or
+ * VMM.
+ * Input operands: rax, rbx, rcx, rdx, r8-r15, rbp, rsi, rdi
+ * Output operands: rax, r8-r15, rbx, rdx, rdi, rsi
+ * rcx is actually a bitmap to tell TDX module which register values will be
+ * exposed to the VMM.
+ * XMM0-XMM15 registers can be used as input operands but the current
+ * implementation does not support it yet.
+ */
+static inline void tdcall(struct kvm_regs *regs)
+{
+ asm volatile (
+ "mov %13, %%rax;\n\t"
+ "mov %14, %%rbx;\n\t"
+ "mov %15, %%rcx;\n\t"
+ "mov %16, %%rdx;\n\t"
+ "mov %17, %%r8;\n\t"
+ "mov %18, %%r9;\n\t"
+ "mov %19, %%r10;\n\t"
+ "mov %20, %%r11;\n\t"
+ "mov %21, %%r12;\n\t"
+ "mov %22, %%r13;\n\t"
+ "mov %23, %%r14;\n\t"
+ "mov %24, %%r15;\n\t"
+ "mov %25, %%rbp;\n\t"
+ "mov %26, %%rsi;\n\t"
+ "mov %27, %%rdi;\n\t"
+ ".byte 0x66, 0x0F, 0x01, 0xCC;\n\t"
+ "mov %%rax, %0;\n\t"
+ "mov %%rbx, %1;\n\t"
+ "mov %%rdx, %2;\n\t"
+ "mov %%r8, %3;\n\t"
+ "mov %%r9, %4;\n\t"
+ "mov %%r10, %5;\n\t"
+ "mov %%r11, %6;\n\t"
+ "mov %%r12, %7;\n\t"
+ "mov %%r13, %8;\n\t"
+ "mov %%r14, %9;\n\t"
+ "mov %%r15, %10;\n\t"
+ "mov %%rsi, %11;\n\t"
+ "mov %%rdi, %12;\n\t"
+ : "=m" (regs->rax), "=m" (regs->rbx), "=m" (regs->rdx),
+ "=m" (regs->r8), "=m" (regs->r9), "=m" (regs->r10),
+ "=m" (regs->r11), "=m" (regs->r12), "=m" (regs->r13),
+ "=m" (regs->r14), "=m" (regs->r15), "=m" (regs->rsi),
+ "=m" (regs->rdi)
+ : "m" (regs->rax), "m" (regs->rbx), "m" (regs->rcx),
+ "m" (regs->rdx), "m" (regs->r8), "m" (regs->r9),
+ "m" (regs->r10), "m" (regs->r11), "m" (regs->r12),
+ "m" (regs->r13), "m" (regs->r14), "m" (regs->r15),
+ "m" (regs->rbp), "m" (regs->rsi), "m" (regs->rdi)
+ : "rax", "rbx", "rcx", "rdx", "r8", "r9", "r10", "r11",
+ "r12", "r13", "r14", "r15", "rbp", "rsi", "rdi");
+}
+
+
+/*
+ * Do a TDVMCALL IO request
+ *
+ * Input Args:
+ * port - IO port to do read/write
+ * size - Number of bytes to read/write. 1=1byte, 2=2bytes, 4=4bytes.
+ * write - 1=IO write 0=IO read
+ * data - pointer for the data to write
+ *
+ * Output Args:
+ * data - pointer for data to be read
+ *
+ * Return:
+ * On success, return 0. For Invalid-IO-Port error, returns -1.
+ *
+ * Does an IO operation using the following tdvmcall interface.
+ *
+ * TDG.VP.VMCALL<Instruction.IO>-Input Operands
+ * R11 30 for IO
+ *
+ * R12 Size of access. 1=1byte, 2=2bytes, 4=4bytes.
+ * R13 Direction. 0=Read, 1=Write.
+ * R14 Port number
+ * R15 Data to write, if R13 is 1.
+ *
+ * TDG.VP.VMCALL<Instruction.IO>-Output Operands
+ * R10 TDG.VP.VMCALL-return code.
+ * R11 Data to read, if R13 is 0.
+ *
+ * TDG.VP.VMCALL<Instruction.IO>-Status Codes
+ * Error Code Value Description
+ * TDG.VP.VMCALL_SUCCESS 0x0 TDG.VP.VMCALL is successful
+ * TDG.VP.VMCALL_INVALID_OPERAND 0x80000000 00000000 Invalid-IO-Port access
+ */
+static inline uint64_t tdvmcall_io(uint64_t port, uint64_t size,
+ uint64_t write, uint64_t *data)
+{
+ struct kvm_regs regs;
+
+ memset(&regs, 0, sizeof(regs));
+ regs.r11 = TDX_INSTRUCTION_IO;
+ regs.r12 = size;
+ regs.r13 = write;
+ regs.r14 = port;
+ if (write) {
+ regs.r15 = *data;
+ regs.rcx = 0xFC00;
+ } else {
+ regs.rcx = 0x7C00;
+ }
+ tdcall(&regs);
+ if (!write)
+ *data = regs.r11;
+ return regs.r10;
+}
+
+/*
+ * Report test success to user space.
+ */
+static inline void tdvmcall_success(void)
+{
+ uint64_t code = 0;
+
+ tdvmcall_io(TDX_SUCCESS_PORT, /*size=*/4, TDX_IO_WRITE, &code);
+}
+
+
+#define TDX_FUNCTION_SIZE(name) ((uint64_t)&__stop_sec_ ## name -\
+ (uint64_t)&__start_sec_ ## name) \
+
+#define TDX_GUEST_FUNCTION__(name, section_name) \
+extern char *__start_sec_ ## name ; \
+extern char *__stop_sec_ ## name ; \
+static void \
+__attribute__((__flatten__, section(section_name))) name(void *arg)
+
+
+#define STRINGIFY2(x) #x
+#define STRINGIFY(x) STRINGIFY2(x)
+#define CONCAT2(a, b) a##b
+#define CONCAT(a, b) CONCAT2(a, b)
+
+
+#define TDX_GUEST_FUNCTION(name) \
+TDX_GUEST_FUNCTION__(name, STRINGIFY(CONCAT(sec_, name)))
+
#endif // KVM_LIB_TDX_H_
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..590e45aa7570
--- /dev/null
+++ b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c
@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include <fcntl.h>
+#include <limits.h>
+#include <kvm_util.h>
+#include "../lib/x86_64/tdx.h"
+#include <linux/kvm.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <test_util.h>
+#include <unistd.h>
+#include <processor.h>
+#include <time.h>
+#include <sys/mman.h>
+#include<sys/wait.h>
+
+#define CHECK_GUEST_COMPLETION(VCPU) \
+ (TEST_ASSERT( \
+ ((VCPU)->run->exit_reason == KVM_EXIT_IO) && \
+ ((VCPU)->run->io.port == TDX_SUCCESS_PORT) && \
+ ((VCPU)->run->io.size == 4) && \
+ ((VCPU)->run->io.direction == TDX_IO_WRITE), \
+ "Unexpected exit values while waiting for test complition: %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))
+
+/*
+ * 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))
+{
+ if (fork() == 0) {
+ func();
+ exit(0);
+ }
+ wait(NULL);
+}
+
+/*
+ * Verify that the TDX is supported by the KVM.
+ */
+bool is_tdx_enabled(void)
+{
+ return !!(kvm_check_cap(KVM_CAP_VM_TYPES) & BIT(KVM_X86_TDX_VM));
+}
+
+/*
+ * Do a dummy io exit to verify that the TD has been initialized correctly and
+ * guest can run some code inside.
+ */
+TDX_GUEST_FUNCTION(guest_dummy_exit)
+{
+ tdvmcall_success();
+}
+
+/*
+ * TD lifecycle test will create a TD which runs a dumy IO exit to verify that
+ * the guest TD has been created correctly.
+ */
+void verify_td_lifecycle(void)
+{
+ struct kvm_vcpu *vcpu;
+ struct kvm_vm *vm;
+
+ printf("Verifying TD lifecycle:\n");
+ /* Create a TD VM with no memory.*/
+ vm = vm_create_tdx();
+
+ /* Allocate TD guest memory and initialize the TD.*/
+ initialize_td(vm);
+
+ /* Initialize the TD vcpu and copy the test code to the guest memory.*/
+ vcpu = vm_vcpu_add_tdx(vm, 0);
+
+ /* Setup and initialize VM memory */
+ prepare_source_image(vm, guest_dummy_exit,
+ TDX_FUNCTION_SIZE(guest_dummy_exit), 0);
+ finalize_td_memory(vm);
+
+ vcpu_run(vcpu);
+ CHECK_GUEST_COMPLETION(vcpu);
+
+ kvm_vm_free(vm);
+ printf("\t ... PASSED\n");
+}
+
+int main(int argc, char **argv)
+{
+ 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;
+}
--
2.37.2.789.g6183377224-goog