From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id A2452C54798 for ; Tue, 5 Mar 2024 04:58:01 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 06CA16B0082; Mon, 4 Mar 2024 23:58:01 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 01D636B0085; Mon, 4 Mar 2024 23:58:00 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id DD9016B0089; Mon, 4 Mar 2024 23:58:00 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0012.hostedemail.com [216.40.44.12]) by kanga.kvack.org (Postfix) with ESMTP id C68EE6B0083 for ; Mon, 4 Mar 2024 23:58:00 -0500 (EST) Received: from smtpin17.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay10.hostedemail.com (Postfix) with ESMTP id 7A78AC0631 for ; Tue, 5 Mar 2024 04:58:00 +0000 (UTC) X-FDA: 81861778320.17.50E7239 Received: from mgamail.intel.com (mgamail.intel.com [192.198.163.12]) by imf21.hostedemail.com (Postfix) with ESMTP id 12FAB1C0006 for ; Tue, 5 Mar 2024 04:57:57 +0000 (UTC) Authentication-Results: imf21.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=iJ+Ra+hq; dmarc=pass (policy=none) header.from=intel.com; spf=none (imf21.hostedemail.com: domain of binbin.wu@linux.intel.com has no SPF policy when checking 192.198.163.12) smtp.mailfrom=binbin.wu@linux.intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1709614678; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=DP/UbAGBjF/lLTDiUwcs88lCaBLKpL79xP6ngBWOW6w=; b=ggUDiyMpc+F6HSpVShBwGGw4zmPrUGkBiTarsjLZjRUsPosPK6x0MWi/OCvHfTpF3DXho2 uX9X3sPEb2tTDP+4LcbRiC9Kph9AVWQglVoWEP4YARO3dMQLcw4dM7nzT/+zLiU5ElOonE WqJJSWCsNB67g6nZamvzBKldATioZ5Q= ARC-Authentication-Results: i=1; imf21.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=iJ+Ra+hq; dmarc=pass (policy=none) header.from=intel.com; spf=none (imf21.hostedemail.com: domain of binbin.wu@linux.intel.com has no SPF policy when checking 192.198.163.12) smtp.mailfrom=binbin.wu@linux.intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1709614678; a=rsa-sha256; cv=none; b=4+ekzDQ7A7KhrihdrdxFGW+L/tuYQW/AObZGkVq5HRJ4aPQfIbF2A1cM22+D5YjAxiEzn8 2PJh/kEwcaVzphFnAWkYmyYeS4WlR6BSObq37Svc1r2VFUneBqSP2SfVMEKGwgaqczG4jG Ao8roTYFk6DSIG3WF/zxaY/7b1LEA5U= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1709614678; x=1741150678; h=message-id:date:mime-version:subject:to:cc:references: from:in-reply-to:content-transfer-encoding; bh=p9A8AKNT5bWayq85gBPsGYGBp5rt1p2gcZJAx2F3Kio=; b=iJ+Ra+hq85nqREJjPIgD0f9ZqWYSb5ZikHjixmJhikijiNWVj/ioEv+V JD1w0UhKEHrkolINgnMACk86M0lUGwlzYS2A2SWqpIzzNa4+aLIoHafaR xkStbW3t/Iug7CMlxeZcCHmQ2h4BYYa8t5Qwjz0gxKs77URdjZvdoRRLB b6bvGEA19G/3zwNVKxPiAgJm43iHOkydYxg4YT05HpYKvzR0s6F4XwsI9 joHUIE+rtvFaL8/dTXyL8j/ARSScWCl6gexIpYzt5s/mqoCsZcE/1EysF qfTyOpk0S+31jVYXYe8Q9jClPaQ8MnCvTgBtlsOavcGWtNZfjmX1BQKkf g==; X-IronPort-AV: E=McAfee;i="6600,9927,11003"; a="7913229" X-IronPort-AV: E=Sophos;i="6.06,205,1705392000"; d="scan'208";a="7913229" Received: from orviesa001.jf.intel.com ([10.64.159.141]) by fmvoesa106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 04 Mar 2024 20:57:57 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.06,205,1705392000"; d="scan'208";a="46775541" Received: from binbinwu-mobl.ccr.corp.intel.com (HELO [10.238.8.218]) ([10.238.8.218]) by smtpauth.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 04 Mar 2024 20:57:51 -0800 Message-ID: Date: Tue, 5 Mar 2024 12:57:49 +0800 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [RFC PATCH v5 28/29] KVM: selftests: TDX: Add TDX UPM selftest To: Sagi Shahar Cc: linux-kselftest@vger.kernel.org, Ackerley Tng , Ryan Afranji , Erdem Aktas , Isaku Yamahata , Sean Christopherson , Paolo Bonzini , Shuah Khan , Peter Gonda , Haibo Xu , Chao Peng , Vishal Annapurve , Roger Wang , Vipin Sharma , jmattson@google.com, dmatlack@google.com, linux-kernel@vger.kernel.org, kvm@vger.kernel.org, linux-mm@kvack.org References: <20231212204647.2170650-1-sagis@google.com> <20231212204647.2170650-29-sagis@google.com> From: Binbin Wu In-Reply-To: <20231212204647.2170650-29-sagis@google.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit X-Rspam-User: X-Rspamd-Server: rspam12 X-Rspamd-Queue-Id: 12FAB1C0006 X-Stat-Signature: ig1wbwgugzup6yu1rcprfk331ggznuit X-HE-Tag: 1709614677-393108 X-HE-Meta: U2FsdGVkX18NsFBZ9Md1JpHO4rof6IKnDtSbP5h2QECsVHIvgfFtSQtPL2AwT+dDdwoHk9bQOcuNEgHAslt+4FOEnUvoJGwP85egffe9cuQpuo/NXOppWNR2LtVXxX6mP6FVP5EjJS1+4uRd4Yf/Kniqt87veZiz5riCIue0jJBLvOuApik4ehfy81HHLv5OlVGE9sIlTUtbhjEZuGZSuh0yPBLDJDbfev6rmaY+hymFkP0/xRANIh9SNUgpMHhBahVKxbSTNeT/XymhbXvlazuLGFaK6s6LbffxsqBhZa5Q7AxGapRF8sF3jGVWZoclKl0KOPux8IJf/bdcJf8bVswmRiYBTDHqCOwuCNBhzdqmzO3Uv6+IJV6+Q9OTwin76QHjO8DTs/+5TwoA8/nquTYVzyEY75SO+g/FoAkwQpmTBRW8UyVOmCkCNY1M/KJNEOYVk/0vRqiQ67N99BchZdd7ximz4qaACDoRAQW1EljRhp6weI7VhCrIFv+EflEjzLKe87swa66tNY/f6rlWmdWVdUcZLl7J1SUKXvh3kwAVicyj/7h9/TwdrD28YJ7I+ggqEx3pOfLQOsLprmUlq/KBxb7aboP61xZKlyn6EgkN+k1X7S3k2unOVgCYrIbsq/aPXQe0QaDl9ykJBRaA8wa4G//bk2FE9IVwWHJPEg2VJ/j/Sevkkk6OGfCUD1OwY9309dzgr/nFBOJ+tdUgfXBIbJp0gBIP4ntu2L+ecq+q7C62JkzIayk6Y3g5HjTKcy2i73FGrSRtoGDFmOqwu4UlM39gTU6wV9dHxJS7Ir/MXMITaa0rqzK4agfPuIsYxuiEhAYza3V49XEzIIx32AC1lB57g01/wAQoOOY1u3wUYaOIJAe5+Q== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: On 12/13/2023 4:46 AM, Sagi Shahar wrote: > From: Ackerley Tng > > This tests the use of guest memory with explicit MapGPA calls. > > Signed-off-by: Ackerley Tng > Signed-off-by: Ryan Afranji > Signed-off-by: Sagi Shahar > --- > tools/testing/selftests/kvm/Makefile | 1 + > .../selftests/kvm/x86_64/tdx_upm_test.c | 401 ++++++++++++++++++ > 2 files changed, 402 insertions(+) > create mode 100644 tools/testing/selftests/kvm/x86_64/tdx_upm_test.c > > diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile > index 8c0a6b395ee5..2f2669af15d6 100644 > --- a/tools/testing/selftests/kvm/Makefile > +++ b/tools/testing/selftests/kvm/Makefile > @@ -157,6 +157,7 @@ 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 > TEST_GEN_PROGS_x86_64 += x86_64/tdx_shared_mem_test > +TEST_GEN_PROGS_x86_64 += x86_64/tdx_upm_test > > # 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/x86_64/tdx_upm_test.c b/tools/testing/selftests/kvm/x86_64/tdx_upm_test.c > new file mode 100644 > index 000000000000..44671874a4f1 > --- /dev/null > +++ b/tools/testing/selftests/kvm/x86_64/tdx_upm_test.c > @@ -0,0 +1,401 @@ > +// SPDX-License-Identifier: GPL-2.0-only > + > +#include > +#include > +#include > +#include > +#include > + > +#include "kvm_util_base.h" > +#include "processor.h" > +#include "tdx/tdcall.h" > +#include "tdx/tdx.h" > +#include "tdx/tdx_util.h" > +#include "tdx/test_util.h" > +#include "test_util.h" > + > +/* TDX UPM test patterns */ > +#define PATTERN_CONFIDENCE_CHECK (0x11) > +#define PATTERN_HOST_FOCUS (0x22) > +#define PATTERN_GUEST_GENERAL (0x33) > +#define PATTERN_GUEST_FOCUS (0x44) > + > +/* > + * 0x80000000 is arbitrarily selected. The selected address need not be the same > + * as TDX_UPM_TEST_AREA_GVA_PRIVATE, but it should not overlap with selftest > + * code or boot page. > + */ > +#define TDX_UPM_TEST_AREA_GPA (0x80000000) > +/* Test area GPA is arbitrarily selected */ > +#define TDX_UPM_TEST_AREA_GVA_PRIVATE (0x90000000) > +/* Select any bit that can be used as a flag */ > +#define TDX_UPM_TEST_AREA_GVA_SHARED_BIT (32) > +/* > + * TDX_UPM_TEST_AREA_GVA_SHARED is used to map the same GPA twice into the > + * guest, once as shared and once as private > + */ > +#define TDX_UPM_TEST_AREA_GVA_SHARED \ > + (TDX_UPM_TEST_AREA_GVA_PRIVATE | \ > + BIT_ULL(TDX_UPM_TEST_AREA_GVA_SHARED_BIT)) > + > +/* The test area is 2MB in size */ > +#define TDX_UPM_TEST_AREA_SIZE (2 << 20) > +/* 0th general area is 1MB in size */ > +#define TDX_UPM_GENERAL_AREA_0_SIZE (1 << 20) > +/* Focus area is 40KB in size */ > +#define TDX_UPM_FOCUS_AREA_SIZE (40 << 10) > +/* 1st general area is the rest of the space in the test area */ > +#define TDX_UPM_GENERAL_AREA_1_SIZE \ > + (TDX_UPM_TEST_AREA_SIZE - TDX_UPM_GENERAL_AREA_0_SIZE - \ > + TDX_UPM_FOCUS_AREA_SIZE) > + > +/* > + * The test memory area is set up as two general areas, sandwiching a focus > + * area. The general areas act as control areas. After they are filled, they > + * are not expected to change throughout the tests. The focus area is memory > + * permissions change from private to shared and vice-versa. > + * > + * The focus area is intentionally small, and sandwiched to test that when the > + * focus area's permissions change, the other areas' permissions are not > + * affected. > + */ > +struct __packed tdx_upm_test_area { > + uint8_t general_area_0[TDX_UPM_GENERAL_AREA_0_SIZE]; > + uint8_t focus_area[TDX_UPM_FOCUS_AREA_SIZE]; > + uint8_t general_area_1[TDX_UPM_GENERAL_AREA_1_SIZE]; > +}; > + > +static void fill_test_area(struct tdx_upm_test_area *test_area_base, > + uint8_t pattern) > +{ > + memset(test_area_base, pattern, sizeof(*test_area_base)); > +} > + > +static void fill_focus_area(struct tdx_upm_test_area *test_area_base, > + uint8_t pattern) > +{ > + memset(test_area_base->focus_area, pattern, > + sizeof(test_area_base->focus_area)); > +} > + > +static bool check_area(uint8_t *base, uint64_t size, uint8_t expected_pattern) > +{ > + size_t i; > + > + for (i = 0; i < size; i++) { > + if (base[i] != expected_pattern) > + return false; > + } > + > + return true; > +} > + > +static bool check_general_areas(struct tdx_upm_test_area *test_area_base, > + uint8_t expected_pattern) > +{ > + return (check_area(test_area_base->general_area_0, > + sizeof(test_area_base->general_area_0), > + expected_pattern) && > + check_area(test_area_base->general_area_1, > + sizeof(test_area_base->general_area_1), > + expected_pattern)); > +} > + > +static bool check_focus_area(struct tdx_upm_test_area *test_area_base, > + uint8_t expected_pattern) > +{ > + return check_area(test_area_base->focus_area, > + sizeof(test_area_base->focus_area), expected_pattern); > +} > + > +static bool check_test_area(struct tdx_upm_test_area *test_area_base, > + uint8_t expected_pattern) > +{ > + return (check_general_areas(test_area_base, expected_pattern) && > + check_focus_area(test_area_base, expected_pattern)); > +} > + > +static bool fill_and_check(struct tdx_upm_test_area *test_area_base, uint8_t pattern) > +{ > + fill_test_area(test_area_base, pattern); > + > + return check_test_area(test_area_base, pattern); > +} > + > +#define TDX_UPM_TEST_ASSERT(x) \ > + do { \ > + if (!(x)) \ > + tdx_test_fatal(__LINE__); \ > + } while (0) > + > +/* > + * Shared variables between guest and host > + */ > +static struct tdx_upm_test_area *test_area_gpa_private; > +static struct tdx_upm_test_area *test_area_gpa_shared; > + > +/* > + * Test stages for syncing with host > + */ > +enum { > + SYNC_CHECK_READ_PRIVATE_MEMORY_FROM_HOST = 1, > + SYNC_CHECK_READ_SHARED_MEMORY_FROM_HOST, > + SYNC_CHECK_READ_PRIVATE_MEMORY_FROM_HOST_AGAIN, > +}; > + > +#define TDX_UPM_TEST_ACCEPT_PRINT_PORT 0x87 > + > +/** > + * Does vcpu_run, and also manages memory conversions if requested by the TD. > + */ > +void vcpu_run_and_manage_memory_conversions(struct kvm_vm *vm, > + struct kvm_vcpu *vcpu) > +{ > + for (;;) { > + vcpu_run(vcpu); > + if (vcpu->run->exit_reason == KVM_EXIT_TDX && > + vcpu->run->tdx.type == KVM_EXIT_TDX_VMCALL && > + vcpu->run->tdx.u.vmcall.subfunction == TDG_VP_VMCALL_MAP_GPA) { > + struct kvm_tdx_vmcall *vmcall_info = &vcpu->run->tdx.u.vmcall; > + uint64_t gpa = vmcall_info->in_r12 & ~vm->arch.s_bit; > + > + handle_memory_conversion(vm, gpa, vmcall_info->in_r13, > + !(vm->arch.s_bit & vmcall_info->in_r12)); > + vmcall_info->status_code = 0; > + continue; > + } else if ( > + vcpu->run->exit_reason == KVM_EXIT_IO && > + vcpu->run->io.port == TDX_UPM_TEST_ACCEPT_PRINT_PORT) { > + uint64_t gpa = tdx_test_read_64bit( > + vcpu, TDX_UPM_TEST_ACCEPT_PRINT_PORT); > + printf("\t ... guest accepting 1 page at GPA: 0x%lx\n", gpa); > + continue; > + } > + > + break; > + } > +} > + > +static void guest_upm_explicit(void) > +{ > + uint64_t ret = 0; > + uint64_t failed_gpa; > + > + struct tdx_upm_test_area *test_area_gva_private = > + (struct tdx_upm_test_area *)TDX_UPM_TEST_AREA_GVA_PRIVATE; > + struct tdx_upm_test_area *test_area_gva_shared = > + (struct tdx_upm_test_area *)TDX_UPM_TEST_AREA_GVA_SHARED; > + > + /* Check: host reading private memory does not modify guest's view */ > + fill_test_area(test_area_gva_private, PATTERN_GUEST_GENERAL); > + > + tdx_test_report_to_user_space(SYNC_CHECK_READ_PRIVATE_MEMORY_FROM_HOST); > + > + TDX_UPM_TEST_ASSERT( > + check_test_area(test_area_gva_private, PATTERN_GUEST_GENERAL)); > + > + /* Remap focus area as shared */ > + ret = tdg_vp_vmcall_map_gpa((uint64_t)test_area_gpa_shared->focus_area, > + sizeof(test_area_gpa_shared->focus_area), > + &failed_gpa); > + TDX_UPM_TEST_ASSERT(!ret); > + > + /* General areas should be unaffected by remapping */ > + TDX_UPM_TEST_ASSERT( > + check_general_areas(test_area_gva_private, PATTERN_GUEST_GENERAL)); > + > + /* > + * Use memory contents to confirm that the memory allocated using mmap > + * is used as backing memory for shared memory - PATTERN_CONFIDENCE_CHECK > + * was written by the VMM at the beginning of this test. > + */ > + TDX_UPM_TEST_ASSERT( > + check_focus_area(test_area_gva_shared, PATTERN_CONFIDENCE_CHECK)); > + > + /* Guest can use focus area after remapping as shared */ > + fill_focus_area(test_area_gva_shared, PATTERN_GUEST_FOCUS); > + > + tdx_test_report_to_user_space(SYNC_CHECK_READ_SHARED_MEMORY_FROM_HOST); > + > + /* Check that guest has the same view of shared memory */ > + TDX_UPM_TEST_ASSERT( > + check_focus_area(test_area_gva_shared, PATTERN_HOST_FOCUS)); > + > + /* Remap focus area back to private */ > + ret = tdg_vp_vmcall_map_gpa((uint64_t)test_area_gpa_private->focus_area, > + sizeof(test_area_gpa_private->focus_area), > + &failed_gpa); > + TDX_UPM_TEST_ASSERT(!ret); > + > + /* General areas should be unaffected by remapping */ > + TDX_UPM_TEST_ASSERT( > + check_general_areas(test_area_gva_private, PATTERN_GUEST_GENERAL)); > + > + /* Focus area should be zeroed after remapping */ > + TDX_UPM_TEST_ASSERT(check_focus_area(test_area_gva_private, 0)); > + > + tdx_test_report_to_user_space(SYNC_CHECK_READ_PRIVATE_MEMORY_FROM_HOST_AGAIN); > + > + /* Check that guest can use private memory after focus area is remapped as private */ > + TDX_UPM_TEST_ASSERT( > + fill_and_check(test_area_gva_private, PATTERN_GUEST_GENERAL)); > + > + tdx_test_success(); > +} > + > +static void run_selftest(struct kvm_vm *vm, struct kvm_vcpu *vcpu, > + struct tdx_upm_test_area *test_area_base_hva) > +{ > + vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); This check seems to be a vain. > + TDX_TEST_ASSERT_IO(vcpu, TDX_TEST_REPORT_PORT, TDX_TEST_REPORT_SIZE, > + TDG_VP_VMCALL_INSTRUCTION_IO_WRITE); > + TEST_ASSERT_EQ(*(uint32_t *)((void *)vcpu->run + vcpu->run->io.data_offset), > + SYNC_CHECK_READ_PRIVATE_MEMORY_FROM_HOST); > + > + /* > + * Check that host should read PATTERN_CONFIDENCE_CHECK from guest's > + * private memory. I think this description is confusing. It's not actually accessing guest's private memory. > This confirms that regular memory (userspace_addr in > + * struct kvm_userspace_memory_region) is used to back the host's view > + * of private memory, since PATTERN_CONFIDENCE_CHECK was written to that > + * memory before starting the guest. > + */ > + TEST_ASSERT(check_test_area(test_area_base_hva, PATTERN_CONFIDENCE_CHECK), > + "Host should read PATTERN_CONFIDENCE_CHECK from guest's private memory."); > + > + vcpu_run_and_manage_memory_conversions(vm, vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_IO(vcpu, TDX_TEST_REPORT_PORT, TDX_TEST_REPORT_SIZE, > + TDG_VP_VMCALL_INSTRUCTION_IO_WRITE); > + TEST_ASSERT_EQ(*(uint32_t *)((void *)vcpu->run + vcpu->run->io.data_offset), > + SYNC_CHECK_READ_SHARED_MEMORY_FROM_HOST); > + > + TEST_ASSERT(check_focus_area(test_area_base_hva, PATTERN_GUEST_FOCUS), > + "Host should have the same view of shared memory as guest."); > + TEST_ASSERT(check_general_areas(test_area_base_hva, PATTERN_CONFIDENCE_CHECK), > + "Host's view of private memory should still be backed by regular memory."); > + > + /* Check that host can use shared memory */ > + fill_focus_area(test_area_base_hva, PATTERN_HOST_FOCUS); > + TEST_ASSERT(check_focus_area(test_area_base_hva, PATTERN_HOST_FOCUS), > + "Host should be able to use shared memory."); > + > + vcpu_run_and_manage_memory_conversions(vm, vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_IO(vcpu, TDX_TEST_REPORT_PORT, TDX_TEST_REPORT_SIZE, > + TDG_VP_VMCALL_INSTRUCTION_IO_WRITE); > + TEST_ASSERT_EQ(*(uint32_t *)((void *)vcpu->run + vcpu->run->io.data_offset), > + SYNC_CHECK_READ_PRIVATE_MEMORY_FROM_HOST_AGAIN); > + > + TEST_ASSERT(check_general_areas(test_area_base_hva, PATTERN_CONFIDENCE_CHECK), > + "Host's view of private memory should be backed by regular memory."); > + TEST_ASSERT(check_focus_area(test_area_base_hva, PATTERN_HOST_FOCUS), > + "Host's view of private memory should be backed by regular memory."); > + > + vcpu_run(vcpu); > + TDX_TEST_CHECK_GUEST_FAILURE(vcpu); > + TDX_TEST_ASSERT_SUCCESS(vcpu); > + > + printf("\t ... PASSED\n"); > +} > + > +static bool address_between(uint64_t addr, void *lo, void *hi) > +{ > + return (uint64_t)lo <= addr && addr < (uint64_t)hi; > +} > + > +static void guest_ve_handler(struct ex_regs *regs) > +{ > + uint64_t ret; > + struct ve_info ve; > + > + ret = tdg_vp_veinfo_get(&ve); > + TDX_UPM_TEST_ASSERT(!ret); > + > + /* For this test, we will only handle EXIT_REASON_EPT_VIOLATION */ > + TDX_UPM_TEST_ASSERT(ve.exit_reason == EXIT_REASON_EPT_VIOLATION); > + > + /* Validate GPA in fault */ > + TDX_UPM_TEST_ASSERT( > + address_between(ve.gpa, > + test_area_gpa_private->focus_area, > + test_area_gpa_private->general_area_1)); > + > + tdx_test_send_64bit(TDX_UPM_TEST_ACCEPT_PRINT_PORT, ve.gpa); > + > +#define MEM_PAGE_ACCEPT_LEVEL_4K 0 > +#define MEM_PAGE_ACCEPT_LEVEL_2M 1 > + ret = tdg_mem_page_accept(ve.gpa, MEM_PAGE_ACCEPT_LEVEL_4K); > + TDX_UPM_TEST_ASSERT(!ret); > +} > + > +static void verify_upm_test(void) > +{ > + struct kvm_vm *vm; > + struct kvm_vcpu *vcpu; > + > + vm_vaddr_t test_area_gva_private; > + struct tdx_upm_test_area *test_area_base_hva; > + uint64_t test_area_npages; > + > + vm = td_create(); > + td_initialize(vm, VM_MEM_SRC_ANONYMOUS, 0); > + vcpu = td_vcpu_add(vm, 0, guest_upm_explicit); > + > + vm_install_exception_handler(vm, VE_VECTOR, guest_ve_handler); > + > + /* > + * Set up shared memory page for testing by first allocating as private > + * and then mapping the same GPA again as shared. This way, the TD does > + * not have to remap its page tables at runtime. > + */ > + test_area_npages = TDX_UPM_TEST_AREA_SIZE / vm->page_size; > + vm_userspace_mem_region_add(vm, > + VM_MEM_SRC_ANONYMOUS, TDX_UPM_TEST_AREA_GPA, > + 3, test_area_npages, KVM_MEM_PRIVATE); > + > + test_area_gva_private = ____vm_vaddr_alloc( > + vm, TDX_UPM_TEST_AREA_SIZE, TDX_UPM_TEST_AREA_GVA_PRIVATE, > + TDX_UPM_TEST_AREA_GPA, 3, true); > + TEST_ASSERT_EQ(test_area_gva_private, TDX_UPM_TEST_AREA_GVA_PRIVATE); > + > + test_area_gpa_private = (struct tdx_upm_test_area *) > + addr_gva2gpa(vm, test_area_gva_private); > + virt_map_shared(vm, TDX_UPM_TEST_AREA_GVA_SHARED, > + (uint64_t)test_area_gpa_private, > + test_area_npages); > + TEST_ASSERT_EQ(addr_gva2gpa(vm, TDX_UPM_TEST_AREA_GVA_SHARED), > + (vm_paddr_t)test_area_gpa_private); > + > + test_area_base_hva = addr_gva2hva(vm, TDX_UPM_TEST_AREA_GVA_PRIVATE); > + > + TEST_ASSERT(fill_and_check(test_area_base_hva, PATTERN_CONFIDENCE_CHECK), > + "Failed to mark memory intended as backing memory for TD shared memory"); > + > + sync_global_to_guest(vm, test_area_gpa_private); > + test_area_gpa_shared = (struct tdx_upm_test_area *) > + ((uint64_t)test_area_gpa_private | BIT_ULL(vm->pa_bits - 1)); > + sync_global_to_guest(vm, test_area_gpa_shared); > + > + td_finalize(vm); > + > + printf("Verifying UPM functionality: explicit MapGPA\n"); > + > + run_selftest(vm, vcpu, test_area_base_hva); > + > + kvm_vm_free(vm); > +} > + > +int main(int argc, char **argv) > +{ > + /* Disable stdout buffering */ > + setbuf(stdout, NULL); > + > + if (!is_tdx_enabled()) { > + printf("TDX is not supported by the KVM\n" > + "Skipping the TDX tests.\n"); > + return 0; > + } > + > + run_in_new_process(&verify_upm_test); > +}