On Tue, Nov 22, 2022, Chao Peng wrote:

...

diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c index 10017a9f26ee..b3118d00b284 100644 --- a/arch/x86/kvm/mmu/mmu.c +++ b/arch/x86/kvm/mmu/mmu.c @@ -4280,6 +4280,10 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault fault->gfn = fault->addr >> PAGE_SHIFT; fault->slot = kvm_vcpu_gfn_to_memslot(vcpu, fault->gfn); +#ifdef CONFIG_HAVE_KVM_PRIVATE_MEM_TESTING

• fault->is_private = kvm_slot_can_be_private(fault->slot) &&

• 	kvm_mem_is_private(vcpu->kvm, fault->gfn);
  

+#endif if (page_fault_handle_page_track(vcpu, fault)) return RET_PF_EMULATE; diff --git a/arch/x86/kvm/mmu/mmu_internal.h b/arch/x86/kvm/mmu/mmu_internal.h index 5cdff5ca546c..2e759f39c2c5 100644 --- a/arch/x86/kvm/mmu/mmu_internal.h +++ b/arch/x86/kvm/mmu/mmu_internal.h @@ -188,7 +188,6 @@ struct kvm_page_fault { /* Derived from mmu and global state. */ const bool is_tdp;

• const bool is_private; const bool nx_huge_page_workaround_enabled;

/* @@ -221,6 +220,9 @@ struct kvm_page_fault { /* The memslot containing gfn. May be NULL. */ struct kvm_memory_slot *slot;

• /* Derived from encryption bits of the faulting GPA for CVMs. */
• bool is_private;

Either we can wrap it with the CONFIG_HAVE_KVM_PRIVATE_MEM_TESTING or if it looks ugly I can remove the "const" in my code.

Hmm, I think we can keep the const. Similar to the bug in kvm_faultin_pfn()[*], the kvm_slot_can_be_private() is bogus. A fault should be considered private if it's marked as private, whether or not userspace has configured the slot to be private is irrelevant. I.e. the xarray is the single source of truth, memslots are just plumbing.

Then kvm_mmu_do_page_fault() can do something like:

diff --git a/arch/x86/kvm/mmu/mmu_internal.h b/arch/x86/kvm/mmu/mmu_internal.h index dbaf6755c5a7..456a9daa36e5 100644 --- a/arch/x86/kvm/mmu/mmu_internal.h +++ b/arch/x86/kvm/mmu/mmu_internal.h @@ -260,6 +260,8 @@ enum { static inline int kvm_mmu_do_page_fault(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, u32 err, bool prefetch) { + bool is_tdp = likely(vcpu->arch.mmu->page_fault == kvm_tdp_page_fault); + struct kvm_page_fault fault = { .addr = cr2_or_gpa, .error_code = err, @@ -269,13 +271,15 @@ static inline int kvm_mmu_do_page_fault(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, .rsvd = err & PFERR_RSVD_MASK, .user = err & PFERR_USER_MASK, .prefetch = prefetch, - .is_tdp = likely(vcpu->arch.mmu->page_fault == kvm_tdp_page_fault), + .is_tdp = is_tdp, .nx_huge_page_workaround_enabled = is_nx_huge_page_enabled(vcpu->kvm),

.max_level = KVM_MAX_HUGEPAGE_LEVEL, .req_level = PG_LEVEL_4K, .goal_level = PG_LEVEL_4K, + .private = IS_ENABLED(CONFIG_HAVE_KVM_PRIVATE_MEM_TESTING) && is_tdp && + kvm_mem_is_private(vcpu->kvm, cr2_or_gpa >> PAGE_SHIFT), }; int r;

[*] https://lore.kernel.org/all/Y3Vgc5KrNRA8r6vh@google.com

On Wed, Nov 23, 2022, Marc Orr wrote:

On Tue, Nov 22, 2022 at 12:06 PM Sean Christopherson seanjc@google.com wrote:

...

...

...

@@ -221,6 +220,9 @@ struct kvm_page_fault { /* The memslot containing gfn. May be NULL. */ struct kvm_memory_slot *slot;

• /* Derived from encryption bits of the faulting GPA for CVMs. */
• bool is_private;

Either we can wrap it with the CONFIG_HAVE_KVM_PRIVATE_MEM_TESTING or if it looks ugly I can remove the "const" in my code.

Hmm, I think we can keep the const. Similar to the bug in kvm_faultin_pfn()[*], the kvm_slot_can_be_private() is bogus. A fault should be considered private if it's marked as private, whether or not userspace has configured the slot to be private is irrelevant. I.e. the xarray is the single source of truth, memslots are just plumbing.

If we incorporate Sean's suggestion and use xarray as the single source of truth, then can we get rid of the HAVE_KVM_PRIVATE_MEM_TESTING config?

No, we still want the opt-in config.

Specifically, the self test can call the KVM_MEMORY_ENCRYPT_REG_REGION ioctl which will set the bits for the private FD within KVM's xarray.

Yes, but that should be disallowed for regular VMs without HAVE_KVM_PRIVATE_MEM_TESTING=y.

(Maybe this was part of the point that Sean was making; but his feedback seemed focused on the discussion about keeping `is_private` const, whereas I've been staring at this trying to figure out if we can run the UPM selftests on a non-TDX/SNP VM WITHOUT a special test-only config. And Sean's idea seems to eliminate the need for the awkward CONFIG.)

"need" was always relative. It's obviously possible to enable any code without a Kconfig, the question is whether or not it's a good idea to do so. In this case, the answer is "no", because allowing private memory opens up a number a of code paths and thus potential bugs. And we need something for kvm_arch_has_private_mem() because returning "true" unconditionally is not correct for regular VMs.

On Tue, Nov 22, 2022 at 08:06:01PM +0000, Sean Christopherson wrote:

On Tue, Nov 22, 2022, Chao Peng wrote:

...

...

diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c index 10017a9f26ee..b3118d00b284 100644 --- a/arch/x86/kvm/mmu/mmu.c +++ b/arch/x86/kvm/mmu/mmu.c @@ -4280,6 +4280,10 @@ static int direct_page_fault(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault fault->gfn = fault->addr >> PAGE_SHIFT; fault->slot = kvm_vcpu_gfn_to_memslot(vcpu, fault->gfn); +#ifdef CONFIG_HAVE_KVM_PRIVATE_MEM_TESTING

• fault->is_private = kvm_slot_can_be_private(fault->slot) &&

• 	kvm_mem_is_private(vcpu->kvm, fault->gfn);
  

+#endif if (page_fault_handle_page_track(vcpu, fault)) return RET_PF_EMULATE; diff --git a/arch/x86/kvm/mmu/mmu_internal.h b/arch/x86/kvm/mmu/mmu_internal.h index 5cdff5ca546c..2e759f39c2c5 100644 --- a/arch/x86/kvm/mmu/mmu_internal.h +++ b/arch/x86/kvm/mmu/mmu_internal.h @@ -188,7 +188,6 @@ struct kvm_page_fault { /* Derived from mmu and global state. */ const bool is_tdp;

• const bool is_private; const bool nx_huge_page_workaround_enabled;

/* @@ -221,6 +220,9 @@ struct kvm_page_fault { /* The memslot containing gfn. May be NULL. */ struct kvm_memory_slot *slot;

• /* Derived from encryption bits of the faulting GPA for CVMs. */
• bool is_private;

Either we can wrap it with the CONFIG_HAVE_KVM_PRIVATE_MEM_TESTING or if it looks ugly I can remove the "const" in my code.

Hmm, I think we can keep the const. Similar to the bug in kvm_faultin_pfn()[*], the kvm_slot_can_be_private() is bogus. A fault should be considered private if it's marked as private, whether or not userspace has configured the slot to be private is irrelevant. I.e. the xarray is the single source of truth, memslots are just plumbing.

I've been looking at pulling this series into our SNP+UPM patchset (and replacing the UPM selftests that were including with UPMv9). We ended up with something similar to what you've suggested, but instead of calling kvm_mem_is_private() directly we added a wrapper in mmu_internal.h that's called via:

kvm_mmu_do_page_fault(): struct kvm_page_fault fault = { ... .is_private = kvm_mmu_fault_is_private()

where kvm_mmu_fault_is_private() is defined something like:

static bool kvm_mmu_fault_is_private(struct kvm *kvm, gpa_t gpa, u64 err) { struct kvm_memory_slot *slot; gfn_t gfn = gpa_to_gfn(gpa); bool private_fault = false;

slot = gfn_to_memslot(kvm, gpa_to_gfn(gpa)); if (!slot) goto out;

if (!kvm_slot_can_be_private(slot)) goto out;

/* If platform hook returns 1 then use it's determination of private_fault */ if (static_call(kvm_x86_fault_is_private)(kvm, gpa, err, &private_fault) == 1) goto out;

/* * Handling below is for guests that rely on the VMM to control when a fault * should be treated as private or not via KVM_MEM_ENCRYPT_{REG,UNREG}_REGION. * This is mainly for the KVM self-tests for restricted memory. */ #ifdef CONFIG_HAVE_KVM_PRIVATE_MEM_TESTING private_fault = kvm_mem_is_private(vcpu->kvm, cr2_or_gpa); #endif

out: return private_fault; }

I tried removing kvm_slot_can_be_private() based on your comments, but we ended up hitting a crash in restrictedmem_get_page(). I think this is because the xarray currently defaults to 'private', so when KVM MMU relies only on xarray it can hit cases where it thinks a GPA should be backed by a restricted page, but when it calls kvm_restrictedmem_get_pfn() a null slot->restricted_file gets passed to restricted_get_page() and it blows up.

I know Chao mentioned they were considering switching to 'shared' as the default xarray value, which might fix this issue, but until then we've left these checks in place.

Just figured I'd mention this in case Vishal hits similar issues.

-Mike

Then kvm_mmu_do_page_fault() can do something like:

diff --git a/arch/x86/kvm/mmu/mmu_internal.h b/arch/x86/kvm/mmu/mmu_internal.h index dbaf6755c5a7..456a9daa36e5 100644 --- a/arch/x86/kvm/mmu/mmu_internal.h +++ b/arch/x86/kvm/mmu/mmu_internal.h @@ -260,6 +260,8 @@ enum { static inline int kvm_mmu_do_page_fault(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, u32 err, bool prefetch) {

•   bool is_tdp = likely(vcpu->arch.mmu->page_fault == kvm_tdp_page_fault);
  

•   struct kvm_page_fault fault = {
            .addr = cr2_or_gpa,
            .error_code = err,
  

@@ -269,13 +271,15 @@ static inline int kvm_mmu_do_page_fault(struct kvm_vcpu *vcpu, gpa_t cr2_or_gpa, .rsvd = err & PFERR_RSVD_MASK, .user = err & PFERR_USER_MASK, .prefetch = prefetch,

•           .is_tdp = likely(vcpu->arch.mmu->page_fault == kvm_tdp_page_fault),
  

•           .is_tdp = is_tdp,
            .nx_huge_page_workaround_enabled =
                    is_nx_huge_page_enabled(vcpu->kvm),
  

.max_level = KVM_MAX_HUGEPAGE_LEVEL, .req_level = PG_LEVEL_4K, .goal_level = PG_LEVEL_4K,

•           .private = IS_ENABLED(CONFIG_HAVE_KVM_PRIVATE_MEM_TESTING) && is_tdp &&
  

•                      kvm_mem_is_private(vcpu->kvm, cr2_or_gpa >> PAGE_SHIFT),
    };
    int r;
  
  

[*] https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Flore.kerne...

On Thu, Nov 10, 2022 at 6:43 PM Vishal Annapurve vannapurve@google.com wrote:

Introduce a set of APIs to execute VM with private memslots.

Host userspace APIs for:

1. Setting up and executing VM having private memslots
2. Backing/unbacking guest private memory

Guest APIs for:

1. Changing memory mapping type

Signed-off-by: Vishal Annapurve vannapurve@google.com

tools/testing/selftests/kvm/Makefile | 1 + .../kvm/include/x86_64/private_mem.h | 37 +++ .../selftests/kvm/lib/x86_64/private_mem.c | 211 ++++++++++++++++++ 3 files changed, 249 insertions(+) create mode 100644 tools/testing/selftests/kvm/include/x86_64/private_mem.h create mode 100644 tools/testing/selftests/kvm/lib/x86_64/private_mem.c

diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile index 0172eb6cb6ee..57385ad58527 100644 --- a/tools/testing/selftests/kvm/Makefile +++ b/tools/testing/selftests/kvm/Makefile @@ -53,6 +53,7 @@ LIBKVM_STRING += lib/string_override.c LIBKVM_x86_64 += lib/x86_64/apic.c LIBKVM_x86_64 += lib/x86_64/handlers.S LIBKVM_x86_64 += lib/x86_64/perf_test_util.c +LIBKVM_x86_64 += lib/x86_64/private_mem.c LIBKVM_x86_64 += lib/x86_64/processor.c LIBKVM_x86_64 += lib/x86_64/svm.c LIBKVM_x86_64 += lib/x86_64/ucall.c diff --git a/tools/testing/selftests/kvm/include/x86_64/private_mem.h b/tools/testing/selftests/kvm/include/x86_64/private_mem.h new file mode 100644 index 000000000000..e556ded971fd --- /dev/null +++ b/tools/testing/selftests/kvm/include/x86_64/private_mem.h @@ -0,0 +1,37 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/*

• • Copyright (C) 2022, Google LLC.
• */

+#ifndef SELFTEST_KVM_PRIVATE_MEM_H +#define SELFTEST_KVM_PRIVATE_MEM_H

+#include <stdint.h> +#include <kvm_util.h>

+void kvm_hypercall_map_shared(uint64_t gpa, uint64_t size); +void kvm_hypercall_map_private(uint64_t gpa, uint64_t size);

+void vm_unback_private_mem(struct kvm_vm *vm, uint64_t gpa, uint64_t size);

+void vm_allocate_private_mem(struct kvm_vm *vm, uint64_t gpa, uint64_t size);

+typedef void (*guest_code_fn)(void); +typedef void (*io_exit_handler)(struct kvm_vm *vm, uint32_t uc_arg1);

+struct test_setup_info {

•   uint64_t test_area_gpa;
  

•   uint64_t test_area_size;
  

•   uint32_t test_area_slot;
  

+};

+struct vm_setup_info {

•   enum vm_mem_backing_src_type test_mem_src;
  

•   struct test_setup_info test_info;
  

•   guest_code_fn guest_fn;
  

•   io_exit_handler ioexit_cb;
  

+};

+void execute_vm_with_private_test_mem(struct vm_setup_info *info);

+#endif /* SELFTEST_KVM_PRIVATE_MEM_H */ diff --git a/tools/testing/selftests/kvm/lib/x86_64/private_mem.c b/tools/testing/selftests/kvm/lib/x86_64/private_mem.c new file mode 100644 index 000000000000..3076cae81804 --- /dev/null +++ b/tools/testing/selftests/kvm/lib/x86_64/private_mem.c @@ -0,0 +1,211 @@ +// SPDX-License-Identifier: GPL-2.0 +/*

• • tools/testing/selftests/kvm/lib/kvm_util.c
• • Copyright (C) 2022, Google LLC.
• */

+#define _GNU_SOURCE /* for program_invocation_name */ +#include <fcntl.h> +#include <limits.h> +#include <sched.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/ioctl.h>

+#include <linux/compiler.h> +#include <linux/kernel.h> +#include <linux/kvm_para.h>

+#include <test_util.h> +#include <kvm_util.h> +#include <private_mem.h> +#include <processor.h>

+static inline uint64_t __kvm_hypercall_map_gpa_range(uint64_t gpa, uint64_t size,

•   uint64_t flags)
  

+{

•   return kvm_hypercall(KVM_HC_MAP_GPA_RANGE, gpa, size >> PAGE_SHIFT, flags, 0);
  

+}

+static inline void kvm_hypercall_map_gpa_range(uint64_t gpa, uint64_t size,

•   uint64_t flags)
  

+{

•   uint64_t ret;
  

•   GUEST_ASSERT_2(IS_PAGE_ALIGNED(gpa) && IS_PAGE_ALIGNED(size), gpa, size);
  

•   ret = __kvm_hypercall_map_gpa_range(gpa, size, flags);
  

•   GUEST_ASSERT_1(!ret, ret);
  

+}

+void kvm_hypercall_map_shared(uint64_t gpa, uint64_t size) +{

•   kvm_hypercall_map_gpa_range(gpa, size, KVM_MAP_GPA_RANGE_DECRYPTED);
  

+}

+void kvm_hypercall_map_private(uint64_t gpa, uint64_t size) +{

•   kvm_hypercall_map_gpa_range(gpa, size, KVM_MAP_GPA_RANGE_ENCRYPTED);
  

+}

+static void vm_update_private_mem(struct kvm_vm *vm, uint64_t gpa, uint64_t size,

•   bool unback_mem)
  

+{

•   int restricted_fd;
  

•   uint64_t restricted_fd_offset, guest_phys_base, fd_offset;
  

•   struct kvm_enc_region enc_region;
  

•   struct kvm_userspace_memory_region_ext *region_ext;
  

•   struct kvm_userspace_memory_region *region;
  

•   int fallocate_mode = 0;
  

•   int ret;
  

•   region_ext = kvm_userspace_memory_region_ext_find(vm, gpa, gpa + size);
  

•   TEST_ASSERT(region_ext != NULL, "Region not found");
  

•   region = &region_ext->region;
  

•   TEST_ASSERT(region->flags & KVM_MEM_PRIVATE,
  

•           "Can not update private memfd for non-private memslot\n");
  

•   restricted_fd = region_ext->restricted_fd;
  

•   restricted_fd_offset = region_ext->restricted_offset;
  

•   guest_phys_base = region->guest_phys_addr;
  

•   fd_offset = restricted_fd_offset + (gpa - guest_phys_base);
  

•   if (unback_mem)
  

•           fallocate_mode = (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE);
  

•   printf("restricted_fd %d fallocate_mode 0x%x for offset 0x%lx size 0x%lx\n",
  

•           restricted_fd, fallocate_mode, fd_offset, size);
  

•   ret = fallocate(restricted_fd, fallocate_mode, fd_offset, size);
  

•   TEST_ASSERT(ret == 0, "fallocate failed\n");
  

•   enc_region.addr = gpa;
  

•   enc_region.size = size;
  

•   if (unback_mem) {
  

•           printf("undoing encryption for gpa 0x%lx size 0x%lx\n", gpa, size);
  

•           vm_ioctl(vm, KVM_MEMORY_ENCRYPT_UNREG_REGION, &enc_region);
  

•   } else {
  

•           printf("doing encryption for gpa 0x%lx size 0x%lx\n", gpa, size);
  

•           vm_ioctl(vm, KVM_MEMORY_ENCRYPT_REG_REGION, &enc_region);
  

•   }
  

+}

+void vm_unback_private_mem(struct kvm_vm *vm, uint64_t gpa, uint64_t size) +{

•   vm_update_private_mem(vm, gpa, size, true);
  

+}

+void vm_allocate_private_mem(struct kvm_vm *vm, uint64_t gpa, uint64_t size) +{

•   vm_update_private_mem(vm, gpa, size, false);
  

+}

+static void handle_vm_exit_map_gpa_hypercall(struct kvm_vm *vm,

•                           struct kvm_vcpu *vcpu)
  

+{

•   uint64_t gpa, npages, attrs, size;
  

•   TEST_ASSERT(vcpu->run->hypercall.nr == KVM_HC_MAP_GPA_RANGE,
  

•           "Unhandled Hypercall %lld\n", vcpu->run->hypercall.nr);
  

•   gpa = vcpu->run->hypercall.args[0];
  

•   npages = vcpu->run->hypercall.args[1];
  

•   size = npages << MIN_PAGE_SHIFT;
  

•   attrs = vcpu->run->hypercall.args[2];
  

•   pr_info("Explicit conversion off 0x%lx size 0x%lx to %s\n", gpa, size,
  

•           (attrs & KVM_MAP_GPA_RANGE_ENCRYPTED) ? "private" : "shared");
  

•   if (attrs & KVM_MAP_GPA_RANGE_ENCRYPTED)
  

•           vm_allocate_private_mem(vm, gpa, size);
  

•   else
  

•           vm_unback_private_mem(vm, gpa, size);
  

•   vcpu->run->hypercall.ret = 0;
  

+}

+static void vcpu_work(struct kvm_vm *vm, struct kvm_vcpu *vcpu,

•   struct vm_setup_info *info)
  

+{

•   struct ucall uc;
  

•   uint64_t cmd;
  

•   /*
  

•    * Loop until the guest is done.
  

•    */
  

•   while (true) {
  

•           vcpu_run(vcpu);
  

•           if (vcpu->run->exit_reason == KVM_EXIT_IO) {
  

•                   cmd = get_ucall(vcpu, &uc);
  

•                   if (cmd != UCALL_SYNC)
  

•                           break;
  

•                   TEST_ASSERT(info->ioexit_cb, "ioexit cb not present");
  

•                   info->ioexit_cb(vm, uc.args[1]);
  

•                   continue;
  

•           }
  

Should this be integrated into the ucall library directly somehow? That way users of VMs with private memory do not need special handling?

After Sean's series: https://lore.kernel.org/linux-arm-kernel/20220825232522.3997340-3-seanjc@goo... we have a common get_ucall() that this check could be integrated into?

•           if (vcpu->run->exit_reason == KVM_EXIT_HYPERCALL) {
  

•                   handle_vm_exit_map_gpa_hypercall(vm, vcpu);
  

•                   continue;
  

•           }
  

•           TEST_FAIL("Unhandled VCPU exit reason %d\n",
  

•                   vcpu->run->exit_reason);
  

•           break;
  

•   }
  

•   if (vcpu->run->exit_reason == KVM_EXIT_IO && cmd == UCALL_ABORT)
  

•           TEST_FAIL("%s at %s:%ld, val = %lu", (const char *)uc.args[0],
  

•                     __FILE__, uc.args[1], uc.args[2]);
  

+}

+/*

• • Execute guest vm with private memory memslots.
• • Input Args:
• • info - pointer to a structure containing information about setting up a VM

• • with private memslots
    

• • Output Args: None
• • Return: None
• • Function called by host userspace logic in selftests to execute guest vm
• • logic. It will install test_mem_slot : containing the region of memory that
• • would be used to test private/shared memory accesses to a memory backed by
• • private memslots
• */

+void execute_vm_with_private_test_mem(struct vm_setup_info *info) +{

•   struct kvm_vm *vm;
  

•   struct kvm_enable_cap cap;
  

•   struct kvm_vcpu *vcpu;
  

•   uint64_t test_area_gpa, test_area_size;
  

•   struct test_setup_info *test_info = &info->test_info;
  

•   TEST_ASSERT(info->guest_fn, "guest_fn not present");
  

•   vm = vm_create_with_one_vcpu(&vcpu, info->guest_fn);
  

I am a little confused with how this library is going to work for SEV VMs that want to have UPM private memory eventually.

Why should users of UPM be forced to use this very specific VM creation and vCPU run loop. In the patch https://lore.kernel.org/lkml/20220829171021.701198-1-pgonda@google.com/T/#m0... SEV VMs need to be created specially vm_sev_create_with_one_vcpu() but then callers can run the VM's vCPUs like other selftests.

How do you see this working with SEV VMs?

•   vm_check_cap(vm, KVM_CAP_EXIT_HYPERCALL);
  

•   cap.cap = KVM_CAP_EXIT_HYPERCALL;
  

•   cap.flags = 0;
  

•   cap.args[0] = (1 << KVM_HC_MAP_GPA_RANGE);
  

•   vm_ioctl(vm, KVM_ENABLE_CAP, &cap);
  

•   TEST_ASSERT(test_info->test_area_size, "Test mem size not present");
  

•   test_area_size = test_info->test_area_size;
  

•   test_area_gpa = test_info->test_area_gpa;
  

•   vm_userspace_mem_region_add(vm, info->test_mem_src, test_area_gpa,
  

•           test_info->test_area_slot, test_area_size / vm->page_size,
  

•           KVM_MEM_PRIVATE);
  

•   vm_allocate_private_mem(vm, test_area_gpa, test_area_size);
  

•   pr_info("Mapping test memory pages 0x%zx page_size 0x%x\n",
  

•           test_area_size/vm->page_size, vm->page_size);
  

•   virt_map(vm, test_area_gpa, test_area_gpa, test_area_size/vm->page_size);
  

•   vcpu_work(vm, vcpu, info);
  

•   kvm_vm_free(vm);
  

+}

2.38.1.431.g37b22c650d-goog