| Message ID | 20231212204647.2170650-19-sagis@google.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | TDX KVM selftests | expand |
On 12/13/2023 4:46 AM, Sagi Shahar wrote: > The test verifies MMIO writes of various sizes from the guest to the host. > > Signed-off-by: Sagi Shahar <sagis@google.com> > Signed-off-by: Ackerley Tng <ackerleytng@google.com> > Signed-off-by: Ryan Afranji <afranji@google.com> Patch 17 and 18 test the part that guest has received the #VE caused by MMIO access, so calls the td vmcall to kvm to do the emulation. Should the generation of #VE due to MMIO access be covered as well? > --- > .../selftests/kvm/include/x86_64/tdx/tdx.h | 2 + > .../selftests/kvm/lib/x86_64/tdx/tdx.c | 14 +++ > .../selftests/kvm/x86_64/tdx_vm_tests.c | 85 +++++++++++++++++++ > 3 files changed, 101 insertions(+) > > 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 13ce60df5684..502b670ea699 100644 > --- a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h > +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h > @@ -25,5 +25,7 @@ uint64_t tdg_vp_vmcall_instruction_wrmsr(uint64_t index, uint64_t value); > uint64_t tdg_vp_vmcall_instruction_hlt(uint64_t interrupt_blocked_flag); > uint64_t tdg_vp_vmcall_ve_request_mmio_read(uint64_t address, uint64_t size, > uint64_t *data_out); > +uint64_t tdg_vp_vmcall_ve_request_mmio_write(uint64_t address, uint64_t size, > + uint64_t data_in); > > #endif // SELFTEST_TDX_TDX_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 b19f07ebc0e7..f4afa09f7e3d 100644 > --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c > +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c > @@ -143,3 +143,17 @@ uint64_t tdg_vp_vmcall_ve_request_mmio_read(uint64_t address, uint64_t size, > > return ret; > } > + > +uint64_t tdg_vp_vmcall_ve_request_mmio_write(uint64_t address, uint64_t size, > + uint64_t data_in) > +{ > + struct tdx_hypercall_args args = { > + .r11 = TDG_VP_VMCALL_VE_REQUEST_MMIO, > + .r12 = size, > + .r13 = TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE, > + .r14 = address, > + .r15 = data_in, > + }; > + > + return __tdx_hypercall(&args, 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 48902b69d13e..5e28ba828a92 100644 > --- a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c > +++ b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c > @@ -885,6 +885,90 @@ void verify_mmio_reads(void) > printf("\t ... PASSED\n"); > } > > +void guest_mmio_writes(void) > +{ > + uint64_t ret; > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 1, 0x12); > + if (ret) > + tdx_test_fatal(ret); > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 2, 0x1234); > + if (ret) > + tdx_test_fatal(ret); > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 4, 0x12345678); > + if (ret) > + tdx_test_fatal(ret); > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 8, 0x1234567890ABCDEF); > + if (ret) > + tdx_test_fatal(ret); > + > + // Write across page boundary. > + ret = tdg_vp_vmcall_ve_request_mmio_write(PAGE_SIZE - 1, 8, 0); > + if (ret) > + tdx_test_fatal(ret); > + > + tdx_test_success(); > +} > + > +/* > + * Varifies guest MMIO writes. > + */ > +void verify_mmio_writes(void) > +{ > + struct kvm_vm *vm; > + struct kvm_vcpu *vcpu; > + > + uint8_t byte_1; > + uint16_t byte_2; > + uint32_t byte_4; > + uint64_t byte_8; > + > + vm = td_create(); > + td_initialize(vm, VM_MEM_SRC_ANONYMOUS, 0); > + vcpu = td_vcpu_add(vm, 0, guest_mmio_writes); > + td_finalize(vm); > + > + printf("Verifying TD MMIO writes:\n"); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 1, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_1 = *(uint8_t *)(vcpu->run->mmio.data); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 2, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_2 = *(uint16_t *)(vcpu->run->mmio.data); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 4, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_4 = *(uint32_t *)(vcpu->run->mmio.data); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 8, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_8 = *(uint64_t *)(vcpu->run->mmio.data); > + > + TEST_ASSERT_EQ(byte_1, 0x12); > + TEST_ASSERT_EQ(byte_2, 0x1234); > + TEST_ASSERT_EQ(byte_4, 0x12345678); > + TEST_ASSERT_EQ(byte_8, 0x1234567890ABCDEF); > + > + td_vcpu_run(vcpu); > + TEST_ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_SYSTEM_EVENT); > + TEST_ASSERT_EQ(vcpu->run->system_event.data[1], TDG_VP_VMCALL_INVALID_OPERAND); > + > + td_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); > @@ -905,6 +989,7 @@ int main(int argc, char **argv) > run_in_new_process(&verify_guest_msr_reads); > run_in_new_process(&verify_guest_hlt); > run_in_new_process(&verify_mmio_reads); > + run_in_new_process(&verify_mmio_writes); > > return 0; > }
On Tue, Dec 12, 2023 at 12:46:33PM -0800, Sagi Shahar wrote: > The test verifies MMIO writes of various sizes from the guest to the host. > > 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 | 2 + > .../selftests/kvm/lib/x86_64/tdx/tdx.c | 14 +++ > .../selftests/kvm/x86_64/tdx_vm_tests.c | 85 +++++++++++++++++++ > 3 files changed, 101 insertions(+) > > 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 13ce60df5684..502b670ea699 100644 > --- a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h > +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h > @@ -25,5 +25,7 @@ uint64_t tdg_vp_vmcall_instruction_wrmsr(uint64_t index, uint64_t value); > uint64_t tdg_vp_vmcall_instruction_hlt(uint64_t interrupt_blocked_flag); > uint64_t tdg_vp_vmcall_ve_request_mmio_read(uint64_t address, uint64_t size, > uint64_t *data_out); > +uint64_t tdg_vp_vmcall_ve_request_mmio_write(uint64_t address, uint64_t size, > + uint64_t data_in); > > #endif // SELFTEST_TDX_TDX_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 b19f07ebc0e7..f4afa09f7e3d 100644 > --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c > +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c > @@ -143,3 +143,17 @@ uint64_t tdg_vp_vmcall_ve_request_mmio_read(uint64_t address, uint64_t size, > > return ret; > } > + > +uint64_t tdg_vp_vmcall_ve_request_mmio_write(uint64_t address, uint64_t size, > + uint64_t data_in) > +{ > + struct tdx_hypercall_args args = { > + .r11 = TDG_VP_VMCALL_VE_REQUEST_MMIO, > + .r12 = size, > + .r13 = TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE, > + .r14 = address, > + .r15 = data_in, > + }; > + > + return __tdx_hypercall(&args, 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 48902b69d13e..5e28ba828a92 100644 > --- a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c > +++ b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c > @@ -885,6 +885,90 @@ void verify_mmio_reads(void) > printf("\t ... PASSED\n"); > } > > +void guest_mmio_writes(void) > +{ > + uint64_t ret; > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 1, 0x12); > + if (ret) > + tdx_test_fatal(ret); > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 2, 0x1234); > + if (ret) > + tdx_test_fatal(ret); > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 4, 0x12345678); > + if (ret) > + tdx_test_fatal(ret); > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 8, 0x1234567890ABCDEF); > + if (ret) > + tdx_test_fatal(ret); > + > + // Write across page boundary. > + ret = tdg_vp_vmcall_ve_request_mmio_write(PAGE_SIZE - 1, 8, 0); > + if (ret) > + tdx_test_fatal(ret); > + > + tdx_test_success(); > +} > + > +/* > + * Varifies guest MMIO writes. > + */ > +void verify_mmio_writes(void) > +{ > + struct kvm_vm *vm; > + struct kvm_vcpu *vcpu; > + > + uint8_t byte_1; > + uint16_t byte_2; > + uint32_t byte_4; > + uint64_t byte_8; > + > + vm = td_create(); > + td_initialize(vm, VM_MEM_SRC_ANONYMOUS, 0); > + vcpu = td_vcpu_add(vm, 0, guest_mmio_writes); > + td_finalize(vm); > + > + printf("Verifying TD MMIO writes:\n"); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 1, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_1 = *(uint8_t *)(vcpu->run->mmio.data); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 2, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_2 = *(uint16_t *)(vcpu->run->mmio.data); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 4, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_4 = *(uint32_t *)(vcpu->run->mmio.data); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 8, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_8 = *(uint64_t *)(vcpu->run->mmio.data); > + > + TEST_ASSERT_EQ(byte_1, 0x12); > + TEST_ASSERT_EQ(byte_2, 0x1234); > + TEST_ASSERT_EQ(byte_4, 0x12345678); > + TEST_ASSERT_EQ(byte_8, 0x1234567890ABCDEF); > + > + td_vcpu_run(vcpu); > + TEST_ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_SYSTEM_EVENT); > + TEST_ASSERT_EQ(vcpu->run->system_event.data[1], TDG_VP_VMCALL_INVALID_OPERAND); Is it possible that this event is caused by an failure of the last 8 byte write? i.e. though MMIO exit to host with correct value 0x1234567890ABCDEF, but guest sees ret as TDG_VP_VMCALL_INVALID_OPERAND. And if, coincidently, guest gets a ret=0 in the next across page boundary write, the selftest will show "PASSED", which is not right. > + td_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); > @@ -905,6 +989,7 @@ int main(int argc, char **argv) > run_in_new_process(&verify_guest_msr_reads); > run_in_new_process(&verify_guest_hlt); > run_in_new_process(&verify_mmio_reads); > + run_in_new_process(&verify_mmio_writes); > > return 0; > } > -- > 2.43.0.472.g3155946c3a-goog > >
On 12/12/2023 12:46 PM, Sagi Shahar wrote: > The test verifies MMIO writes of various sizes from the guest to the host. > > 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 | 2 + > .../selftests/kvm/lib/x86_64/tdx/tdx.c | 14 +++ > .../selftests/kvm/x86_64/tdx_vm_tests.c | 85 +++++++++++++++++++ > 3 files changed, 101 insertions(+) > > 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 13ce60df5684..502b670ea699 100644 > --- a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h > +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h > @@ -25,5 +25,7 @@ uint64_t tdg_vp_vmcall_instruction_wrmsr(uint64_t index, uint64_t value); > uint64_t tdg_vp_vmcall_instruction_hlt(uint64_t interrupt_blocked_flag); > uint64_t tdg_vp_vmcall_ve_request_mmio_read(uint64_t address, uint64_t size, > uint64_t *data_out); > +uint64_t tdg_vp_vmcall_ve_request_mmio_write(uint64_t address, uint64_t size, > + uint64_t data_in); > > #endif // SELFTEST_TDX_TDX_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 b19f07ebc0e7..f4afa09f7e3d 100644 > --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c > +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c > @@ -143,3 +143,17 @@ uint64_t tdg_vp_vmcall_ve_request_mmio_read(uint64_t address, uint64_t size, > > return ret; > } > + > +uint64_t tdg_vp_vmcall_ve_request_mmio_write(uint64_t address, uint64_t size, > + uint64_t data_in) > +{ > + struct tdx_hypercall_args args = { > + .r11 = TDG_VP_VMCALL_VE_REQUEST_MMIO, > + .r12 = size, > + .r13 = TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE, > + .r14 = address, > + .r15 = data_in, > + }; > + > + return __tdx_hypercall(&args, 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 48902b69d13e..5e28ba828a92 100644 > --- a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c > +++ b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c > @@ -885,6 +885,90 @@ void verify_mmio_reads(void) > printf("\t ... PASSED\n"); > } > > +void guest_mmio_writes(void) > +{ > + uint64_t ret; > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 1, 0x12); > + if (ret) > + tdx_test_fatal(ret); > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 2, 0x1234); > + if (ret) > + tdx_test_fatal(ret); > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 4, 0x12345678); > + if (ret) > + tdx_test_fatal(ret); > + > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 8, 0x1234567890ABCDEF); > + if (ret) > + tdx_test_fatal(ret); > + > + // Write across page boundary. > + ret = tdg_vp_vmcall_ve_request_mmio_write(PAGE_SIZE - 1, 8, 0); > + if (ret) > + tdx_test_fatal(ret); > + > + tdx_test_success(); > +} > + > +/* > + * Varifies guest MMIO writes. > + */ Nit: typo? Varifies ==> Verifies > +void verify_mmio_writes(void) > +{ > + struct kvm_vm *vm; > + struct kvm_vcpu *vcpu; > + > + uint8_t byte_1; > + uint16_t byte_2; > + uint32_t byte_4; > + uint64_t byte_8; > + > + vm = td_create(); > + td_initialize(vm, VM_MEM_SRC_ANONYMOUS, 0); > + vcpu = td_vcpu_add(vm, 0, guest_mmio_writes); > + td_finalize(vm); > + > + printf("Verifying TD MMIO writes:\n"); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 1, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_1 = *(uint8_t *)(vcpu->run->mmio.data); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 2, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_2 = *(uint16_t *)(vcpu->run->mmio.data); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 4, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_4 = *(uint32_t *)(vcpu->run->mmio.data); > + > + td_vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 8, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > + byte_8 = *(uint64_t *)(vcpu->run->mmio.data); > + > + TEST_ASSERT_EQ(byte_1, 0x12); > + TEST_ASSERT_EQ(byte_2, 0x1234); > + TEST_ASSERT_EQ(byte_4, 0x12345678); > + TEST_ASSERT_EQ(byte_8, 0x1234567890ABCDEF); > + > + td_vcpu_run(vcpu); > + TEST_ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_SYSTEM_EVENT); > + TEST_ASSERT_EQ(vcpu->run->system_event.data[1], TDG_VP_VMCALL_INVALID_OPERAND); > + > + td_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); > @@ -905,6 +989,7 @@ int main(int argc, char **argv) > run_in_new_process(&verify_guest_msr_reads); > run_in_new_process(&verify_guest_hlt); > run_in_new_process(&verify_mmio_reads); > + run_in_new_process(&verify_mmio_writes); > > return 0; > }
On Tue, Mar 5, 2024 at 3:28 AM Yan Zhao <yan.y.zhao@intel.com> wrote: > > On Tue, Dec 12, 2023 at 12:46:33PM -0800, Sagi Shahar wrote: > > The test verifies MMIO writes of various sizes from the guest to the host. > > > > 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 | 2 + > > .../selftests/kvm/lib/x86_64/tdx/tdx.c | 14 +++ > > .../selftests/kvm/x86_64/tdx_vm_tests.c | 85 +++++++++++++++++++ > > 3 files changed, 101 insertions(+) > > > > 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 13ce60df5684..502b670ea699 100644 > > --- a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h > > +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h > > @@ -25,5 +25,7 @@ uint64_t tdg_vp_vmcall_instruction_wrmsr(uint64_t index, uint64_t value); > > uint64_t tdg_vp_vmcall_instruction_hlt(uint64_t interrupt_blocked_flag); > > uint64_t tdg_vp_vmcall_ve_request_mmio_read(uint64_t address, uint64_t size, > > uint64_t *data_out); > > +uint64_t tdg_vp_vmcall_ve_request_mmio_write(uint64_t address, uint64_t size, > > + uint64_t data_in); > > > > #endif // SELFTEST_TDX_TDX_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 b19f07ebc0e7..f4afa09f7e3d 100644 > > --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c > > +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c > > @@ -143,3 +143,17 @@ uint64_t tdg_vp_vmcall_ve_request_mmio_read(uint64_t address, uint64_t size, > > > > return ret; > > } > > + > > +uint64_t tdg_vp_vmcall_ve_request_mmio_write(uint64_t address, uint64_t size, > > + uint64_t data_in) > > +{ > > + struct tdx_hypercall_args args = { > > + .r11 = TDG_VP_VMCALL_VE_REQUEST_MMIO, > > + .r12 = size, > > + .r13 = TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE, > > + .r14 = address, > > + .r15 = data_in, > > + }; > > + > > + return __tdx_hypercall(&args, 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 48902b69d13e..5e28ba828a92 100644 > > --- a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c > > +++ b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c > > @@ -885,6 +885,90 @@ void verify_mmio_reads(void) > > printf("\t ... PASSED\n"); > > } > > > > +void guest_mmio_writes(void) > > +{ > > + uint64_t ret; > > + > > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 1, 0x12); > > + if (ret) > > + tdx_test_fatal(ret); > > + > > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 2, 0x1234); > > + if (ret) > > + tdx_test_fatal(ret); > > + > > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 4, 0x12345678); > > + if (ret) > > + tdx_test_fatal(ret); > > + > > + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 8, 0x1234567890ABCDEF); > > + if (ret) > > + tdx_test_fatal(ret); > > + > > + // Write across page boundary. > > + ret = tdg_vp_vmcall_ve_request_mmio_write(PAGE_SIZE - 1, 8, 0); > > + if (ret) > > + tdx_test_fatal(ret); > > + > > + tdx_test_success(); > > +} > > + > > +/* > > + * Varifies guest MMIO writes. > > + */ > > +void verify_mmio_writes(void) > > +{ > > + struct kvm_vm *vm; > > + struct kvm_vcpu *vcpu; > > + > > + uint8_t byte_1; > > + uint16_t byte_2; > > + uint32_t byte_4; > > + uint64_t byte_8; > > + > > + vm = td_create(); > > + td_initialize(vm, VM_MEM_SRC_ANONYMOUS, 0); > > + vcpu = td_vcpu_add(vm, 0, guest_mmio_writes); > > + td_finalize(vm); > > + > > + printf("Verifying TD MMIO writes:\n"); > > + > > + td_vcpu_run(vcpu); > > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 1, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > > + byte_1 = *(uint8_t *)(vcpu->run->mmio.data); > > + > > + td_vcpu_run(vcpu); > > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 2, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > > + byte_2 = *(uint16_t *)(vcpu->run->mmio.data); > > + > > + td_vcpu_run(vcpu); > > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 4, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > > + byte_4 = *(uint32_t *)(vcpu->run->mmio.data); > > + > > + td_vcpu_run(vcpu); > > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > > + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 8, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); > > + byte_8 = *(uint64_t *)(vcpu->run->mmio.data); > > + > > + TEST_ASSERT_EQ(byte_1, 0x12); > > + TEST_ASSERT_EQ(byte_2, 0x1234); > > + TEST_ASSERT_EQ(byte_4, 0x12345678); > > + TEST_ASSERT_EQ(byte_8, 0x1234567890ABCDEF); > > + > > + td_vcpu_run(vcpu); > > + TEST_ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_SYSTEM_EVENT); > > + TEST_ASSERT_EQ(vcpu->run->system_event.data[1], TDG_VP_VMCALL_INVALID_OPERAND); > Is it possible that this event is caused by an failure of the last 8 byte write? > i.e. though MMIO exit to host with correct value 0x1234567890ABCDEF, but guest > sees ret as TDG_VP_VMCALL_INVALID_OPERAND. > > And if, coincidently, guest gets a ret=0 in the next across page boundary write, > the selftest will show "PASSED", which is not right. > We can add another tdx_test_report_to_user_space to synchronize between guest and host execution making sure that the guest is done with all the valid writes before testing the negative case. > > > + td_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); > > @@ -905,6 +989,7 @@ int main(int argc, char **argv) > > run_in_new_process(&verify_guest_msr_reads); > > run_in_new_process(&verify_guest_hlt); > > run_in_new_process(&verify_mmio_reads); > > + run_in_new_process(&verify_mmio_writes); > > > > return 0; > > } > > -- > > 2.43.0.472.g3155946c3a-goog > > > >
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 13ce60df5684..502b670ea699 100644 --- a/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h +++ b/tools/testing/selftests/kvm/include/x86_64/tdx/tdx.h @@ -25,5 +25,7 @@ uint64_t tdg_vp_vmcall_instruction_wrmsr(uint64_t index, uint64_t value); uint64_t tdg_vp_vmcall_instruction_hlt(uint64_t interrupt_blocked_flag); uint64_t tdg_vp_vmcall_ve_request_mmio_read(uint64_t address, uint64_t size, uint64_t *data_out); +uint64_t tdg_vp_vmcall_ve_request_mmio_write(uint64_t address, uint64_t size, + uint64_t data_in); #endif // SELFTEST_TDX_TDX_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 b19f07ebc0e7..f4afa09f7e3d 100644 --- a/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c +++ b/tools/testing/selftests/kvm/lib/x86_64/tdx/tdx.c @@ -143,3 +143,17 @@ uint64_t tdg_vp_vmcall_ve_request_mmio_read(uint64_t address, uint64_t size, return ret; } + +uint64_t tdg_vp_vmcall_ve_request_mmio_write(uint64_t address, uint64_t size, + uint64_t data_in) +{ + struct tdx_hypercall_args args = { + .r11 = TDG_VP_VMCALL_VE_REQUEST_MMIO, + .r12 = size, + .r13 = TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE, + .r14 = address, + .r15 = data_in, + }; + + return __tdx_hypercall(&args, 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 48902b69d13e..5e28ba828a92 100644 --- a/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c +++ b/tools/testing/selftests/kvm/x86_64/tdx_vm_tests.c @@ -885,6 +885,90 @@ void verify_mmio_reads(void) printf("\t ... PASSED\n"); } +void guest_mmio_writes(void) +{ + uint64_t ret; + + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 1, 0x12); + if (ret) + tdx_test_fatal(ret); + + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 2, 0x1234); + if (ret) + tdx_test_fatal(ret); + + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 4, 0x12345678); + if (ret) + tdx_test_fatal(ret); + + ret = tdg_vp_vmcall_ve_request_mmio_write(TDX_MMIO_TEST_ADDR, 8, 0x1234567890ABCDEF); + if (ret) + tdx_test_fatal(ret); + + // Write across page boundary. + ret = tdg_vp_vmcall_ve_request_mmio_write(PAGE_SIZE - 1, 8, 0); + if (ret) + tdx_test_fatal(ret); + + tdx_test_success(); +} + +/* + * Varifies guest MMIO writes. + */ +void verify_mmio_writes(void) +{ + struct kvm_vm *vm; + struct kvm_vcpu *vcpu; + + uint8_t byte_1; + uint16_t byte_2; + uint32_t byte_4; + uint64_t byte_8; + + vm = td_create(); + td_initialize(vm, VM_MEM_SRC_ANONYMOUS, 0); + vcpu = td_vcpu_add(vm, 0, guest_mmio_writes); + td_finalize(vm); + + printf("Verifying TD MMIO writes:\n"); + + td_vcpu_run(vcpu); + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 1, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); + byte_1 = *(uint8_t *)(vcpu->run->mmio.data); + + td_vcpu_run(vcpu); + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 2, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); + byte_2 = *(uint16_t *)(vcpu->run->mmio.data); + + td_vcpu_run(vcpu); + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 4, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); + byte_4 = *(uint32_t *)(vcpu->run->mmio.data); + + td_vcpu_run(vcpu); + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); + TDX_TEST_ASSERT_MMIO(vcpu, TDX_MMIO_TEST_ADDR, 8, TDG_VP_VMCALL_VE_REQUEST_MMIO_WRITE); + byte_8 = *(uint64_t *)(vcpu->run->mmio.data); + + TEST_ASSERT_EQ(byte_1, 0x12); + TEST_ASSERT_EQ(byte_2, 0x1234); + TEST_ASSERT_EQ(byte_4, 0x12345678); + TEST_ASSERT_EQ(byte_8, 0x1234567890ABCDEF); + + td_vcpu_run(vcpu); + TEST_ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_SYSTEM_EVENT); + TEST_ASSERT_EQ(vcpu->run->system_event.data[1], TDG_VP_VMCALL_INVALID_OPERAND); + + td_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); @@ -905,6 +989,7 @@ int main(int argc, char **argv) run_in_new_process(&verify_guest_msr_reads); run_in_new_process(&verify_guest_hlt); run_in_new_process(&verify_mmio_reads); + run_in_new_process(&verify_mmio_writes); return 0; }