int vcpu_id;
        int r;
 
-       vm = perf_test_create_vm(mode, nr_vcpus, guest_percpu_mem_size);
+       vm = perf_test_create_vm(mode, nr_vcpus, guest_percpu_mem_size,
+                                VM_MEM_SRC_ANONYMOUS);
 
        perf_test_args.wr_fract = 1;
 
 
        uint64_t phys_offset;
        int wr_fract;
        bool partition_vcpu_memory_access;
+       enum vm_mem_backing_src_type backing_src;
 };
 
 static void run_test(enum vm_guest_mode mode, void *arg)
        struct kvm_enable_cap cap = {};
        struct timespec clear_dirty_log_total = (struct timespec){0};
 
-       vm = perf_test_create_vm(mode, nr_vcpus, guest_percpu_mem_size);
+       vm = perf_test_create_vm(mode, nr_vcpus, guest_percpu_mem_size,
+                                p->backing_src);
 
        perf_test_args.wr_fract = p->wr_fract;
 
 {
        puts("");
        printf("usage: %s [-h] [-i iterations] [-p offset] "
-              "[-m mode] [-b vcpu bytes] [-v vcpus] [-o]\n", name);
+              "[-m mode] [-b vcpu bytes] [-v vcpus] [-o] [-s mem type]\n", name);
        puts("");
        printf(" -i: specify iteration counts (default: %"PRIu64")\n",
               TEST_HOST_LOOP_N);
        printf(" -v: specify the number of vCPUs to run.\n");
        printf(" -o: Overlap guest memory accesses instead of partitioning\n"
               "     them into a separate region of memory for each vCPU.\n");
+       printf(" -s: specify the type of memory that should be used to\n"
+              "     back the guest data region.\n\n");
+       backing_src_help();
        puts("");
        exit(0);
 }
                .iterations = TEST_HOST_LOOP_N,
                .wr_fract = 1,
                .partition_vcpu_memory_access = true,
+               .backing_src = VM_MEM_SRC_ANONYMOUS,
        };
        int opt;
 
 
        guest_modes_append_default();
 
-       while ((opt = getopt(argc, argv, "hi:p:m:b:f:v:o")) != -1) {
+       while ((opt = getopt(argc, argv, "hi:p:m:b:f:v:os:")) != -1) {
                switch (opt) {
                case 'i':
                        p.iterations = atoi(optarg);
                        break;
                case 'o':
                        p.partition_vcpu_memory_access = false;
+               case 's':
+                       p.backing_src = parse_backing_src_type(optarg);
                        break;
                case 'h':
                default:
 
 };
 extern const struct vm_guest_mode_params vm_guest_mode_params[];
 
-enum vm_mem_backing_src_type {
-       VM_MEM_SRC_ANONYMOUS,
-       VM_MEM_SRC_ANONYMOUS_THP,
-       VM_MEM_SRC_ANONYMOUS_HUGETLB,
-};
-
 int kvm_check_cap(long cap);
 int vm_enable_cap(struct kvm_vm *vm, struct kvm_enable_cap *cap);
 int vcpu_enable_cap(struct kvm_vm *vm, uint32_t vcpu_id,
 
 extern uint64_t guest_test_phys_mem;
 
 struct kvm_vm *perf_test_create_vm(enum vm_guest_mode mode, int vcpus,
-                               uint64_t vcpu_memory_bytes);
+                                  uint64_t vcpu_memory_bytes,
+                                  enum vm_mem_backing_src_type backing_src);
 void perf_test_destroy_vm(struct kvm_vm *vm);
 void perf_test_setup_vcpus(struct kvm_vm *vm, int vcpus,
                           uint64_t vcpu_memory_bytes,
 
 struct timespec timespec_elapsed(struct timespec start);
 struct timespec timespec_div(struct timespec ts, int divisor);
 
+enum vm_mem_backing_src_type {
+       VM_MEM_SRC_ANONYMOUS,
+       VM_MEM_SRC_ANONYMOUS_THP,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB,
+};
+
+struct vm_mem_backing_src_alias {
+       const char *name;
+       enum vm_mem_backing_src_type type;
+};
+
+void backing_src_help(void);
+enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name);
+
 #endif /* SELFTEST_KVM_TEST_UTIL_H */
 
 }
 
 struct kvm_vm *perf_test_create_vm(enum vm_guest_mode mode, int vcpus,
-                                  uint64_t vcpu_memory_bytes)
+                                  uint64_t vcpu_memory_bytes,
+                                  enum vm_mem_backing_src_type backing_src)
 {
        struct kvm_vm *vm;
        uint64_t guest_num_pages;
        pr_info("guest physical test memory offset: 0x%lx\n", guest_test_phys_mem);
 
        /* Add an extra memory slot for testing */
-       vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
-                                   guest_test_phys_mem,
+       vm_userspace_mem_region_add(vm, backing_src, guest_test_phys_mem,
                                    PERF_TEST_MEM_SLOT_INDEX,
                                    guest_num_pages, 0);
 
 
 #include <limits.h>
 #include <stdlib.h>
 #include <time.h>
+#include "linux/kernel.h"
 
 #include "test_util.h"
 
        va_end(ap);
        puts(", skipping test");
 }
+
+const struct vm_mem_backing_src_alias backing_src_aliases[] = {
+       {"anonymous", VM_MEM_SRC_ANONYMOUS,},
+       {"anonymous_thp", VM_MEM_SRC_ANONYMOUS_THP,},
+       {"anonymous_hugetlb", VM_MEM_SRC_ANONYMOUS_HUGETLB,},
+};
+
+void backing_src_help(void)
+{
+       int i;
+
+       printf("Available backing src types:\n");
+       for (i = 0; i < ARRAY_SIZE(backing_src_aliases); i++)
+               printf("\t%s\n", backing_src_aliases[i].name);
+}
+
+enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name)
+{
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(backing_src_aliases); i++)
+               if (!strcmp(type_name, backing_src_aliases[i].name))
+                       return backing_src_aliases[i].type;
+
+       backing_src_help();
+       TEST_FAIL("Unknown backing src type: %s", type_name);
+       return -1;
+}
 
        struct kvm_vm *vm;
        int vcpu_id;
 
-       vm = perf_test_create_vm(mode, nr_vcpus, guest_percpu_mem_size);
+       vm = perf_test_create_vm(mode, nr_vcpus, guest_percpu_mem_size,
+                                VM_MEM_SRC_ANONYMOUS);
 
        perf_test_args.wr_fract = 1;