KVM: selftests: List all hugetlb src types specified with page sizes

With VM_MEM_SRC_ANONYMOUS_HUGETLB, we currently can only use system
default hugetlb pages to back the testing guest memory. In order to
add flexibility, now list all the known hugetlb backing src types with
different page sizes, so that we can specify use of hugetlb pages of the
exact granularity that we want. And as all the known hugetlb page sizes
are listed, it's appropriate for all architectures.

Besides, the helper get_backing_src_pagesz() is added to get the
granularity of different backing src types(anonumous, thp, hugetlb).

Suggested-by: Ben Gardon <bgardon@google.com>
Signed-off-by: Yanan Wang <wangyanan55@huawei.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Message-Id: <20210330080856.14940-9-wangyanan55@huawei.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/tools/testing/selftests/kvm/include/test_util.h b/tools/testing/selftests/kvm/include/test_util.h
index e087174..fade313 100644 (file)
--- a/tools/testing/selftests/kvm/include/test_util.h
+++ b/tools/testing/selftests/kvm/include/test_util.h
@@ -71,16 +71,32 @@ enum vm_mem_backing_src_type {
        VM_MEM_SRC_ANONYMOUS,
        VM_MEM_SRC_ANONYMOUS_THP,
        VM_MEM_SRC_ANONYMOUS_HUGETLB,
        VM_MEM_SRC_ANONYMOUS,
        VM_MEM_SRC_ANONYMOUS_THP,
        VM_MEM_SRC_ANONYMOUS_HUGETLB,

+       VM_MEM_SRC_ANONYMOUS_HUGETLB_16KB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_64KB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_512KB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_1MB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_2MB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_8MB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_16MB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_32MB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_256MB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_512MB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_1GB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_2GB,
+       VM_MEM_SRC_ANONYMOUS_HUGETLB_16GB,
+       NUM_SRC_TYPES,

 };
 
 struct vm_mem_backing_src_alias {
        const char *name;
 };
 
 struct vm_mem_backing_src_alias {
        const char *name;

-       enum vm_mem_backing_src_type type;
+       uint32_t flag;

 };
 
 bool thp_configured(void);
 size_t get_trans_hugepagesz(void);
 size_t get_def_hugetlb_pagesz(void);
 };
 
 bool thp_configured(void);
 size_t get_trans_hugepagesz(void);
 size_t get_def_hugetlb_pagesz(void);

+const struct vm_mem_backing_src_alias *vm_mem_backing_src_alias(uint32_t i);
+size_t get_backing_src_pagesz(uint32_t i);

 void backing_src_help(void);
 enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name);
 
 void backing_src_help(void);
 enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name);
 

diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c
index 2ea837f..3506174 100644 (file)
--- a/tools/testing/selftests/kvm/lib/kvm_util.c
+++ b/tools/testing/selftests/kvm/lib/kvm_util.c
@@ -759,7 +759,7 @@ void vm_userspace_mem_region_add(struct kvm_vm *vm,
        region->mmap_start = mmap(NULL, region->mmap_size,
                                  PROT_READ | PROT_WRITE,
                                  MAP_PRIVATE | MAP_ANONYMOUS
        region->mmap_start = mmap(NULL, region->mmap_size,
                                  PROT_READ | PROT_WRITE,
                                  MAP_PRIVATE | MAP_ANONYMOUS

-                                 | (src_type == VM_MEM_SRC_ANONYMOUS_HUGETLB ? MAP_HUGETLB : 0),
+                                 | vm_mem_backing_src_alias(src_type)->flag,

                                  -1, 0);
        TEST_ASSERT(region->mmap_start != MAP_FAILED,
                    "test_malloc failed, mmap_start: %p errno: %i",
                                  -1, 0);
        TEST_ASSERT(region->mmap_start != MAP_FAILED,
                    "test_malloc failed, mmap_start: %p errno: %i",

diff --git a/tools/testing/selftests/kvm/lib/test_util.c b/tools/testing/selftests/kvm/lib/test_util.c
index bd718c9..63d2bc7 100644 (file)
--- a/tools/testing/selftests/kvm/lib/test_util.c
+++ b/tools/testing/selftests/kvm/lib/test_util.c
@@ -11,6 +11,7 @@
 #include <stdlib.h>
 #include <time.h>
 #include <sys/stat.h>
 #include <stdlib.h>
 #include <time.h>
 #include <sys/stat.h>

+#include <linux/mman.h>

 #include "linux/kernel.h"
 
 #include "test_util.h"
 #include "linux/kernel.h"
 
 #include "test_util.h"


@@ -112,12 +113,6 @@ void print_skip(const char *fmt, ...)
        puts(", skipping test");
 }
 
        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,},
-};
-

 bool thp_configured(void)
 {
        int ret;
 bool thp_configured(void)
 {
        int ret;


@@ -171,22 +166,116 @@ size_t get_def_hugetlb_pagesz(void)
        return 0;
 }
 
        return 0;
 }
 

+const struct vm_mem_backing_src_alias *vm_mem_backing_src_alias(uint32_t i)
+{
+       static const struct vm_mem_backing_src_alias aliases[] = {
+               [VM_MEM_SRC_ANONYMOUS] = {
+                       .name = "anonymous",
+                       .flag = 0,
+               },
+               [VM_MEM_SRC_ANONYMOUS_THP] = {
+                       .name = "anonymous_thp",
+                       .flag = 0,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB] = {
+                       .name = "anonymous_hugetlb",
+                       .flag = MAP_HUGETLB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_16KB] = {
+                       .name = "anonymous_hugetlb_16kb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_16KB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_64KB] = {
+                       .name = "anonymous_hugetlb_64kb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_64KB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_512KB] = {
+                       .name = "anonymous_hugetlb_512kb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_512KB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_1MB] = {
+                       .name = "anonymous_hugetlb_1mb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_1MB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_2MB] = {
+                       .name = "anonymous_hugetlb_2mb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_2MB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_8MB] = {
+                       .name = "anonymous_hugetlb_8mb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_8MB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_16MB] = {
+                       .name = "anonymous_hugetlb_16mb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_16MB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_32MB] = {
+                       .name = "anonymous_hugetlb_32mb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_32MB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_256MB] = {
+                       .name = "anonymous_hugetlb_256mb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_256MB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_512MB] = {
+                       .name = "anonymous_hugetlb_512mb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_512MB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_1GB] = {
+                       .name = "anonymous_hugetlb_1gb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_1GB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_2GB] = {
+                       .name = "anonymous_hugetlb_2gb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_2GB,
+               },
+               [VM_MEM_SRC_ANONYMOUS_HUGETLB_16GB] = {
+                       .name = "anonymous_hugetlb_16gb",
+                       .flag = MAP_HUGETLB | MAP_HUGE_16GB,
+               },
+       };
+       _Static_assert(ARRAY_SIZE(aliases) == NUM_SRC_TYPES,
+                      "Missing new backing src types?");
+
+       TEST_ASSERT(i < NUM_SRC_TYPES, "Backing src type ID %d too big", i);
+
+       return &aliases[i];
+}
+
+#define MAP_HUGE_PAGE_SIZE(x) (1ULL << ((x >> MAP_HUGE_SHIFT) & MAP_HUGE_MASK))
+
+size_t get_backing_src_pagesz(uint32_t i)
+{
+       uint32_t flag = vm_mem_backing_src_alias(i)->flag;
+
+       switch (i) {
+       case VM_MEM_SRC_ANONYMOUS:
+               return getpagesize();
+       case VM_MEM_SRC_ANONYMOUS_THP:
+               return get_trans_hugepagesz();
+       case VM_MEM_SRC_ANONYMOUS_HUGETLB:
+               return get_def_hugetlb_pagesz();
+       default:
+               return MAP_HUGE_PAGE_SIZE(flag);
+       }
+}
+

 void backing_src_help(void)
 {
        int i;
 
        printf("Available backing src types:\n");
 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);
+       for (i = 0; i < NUM_SRC_TYPES; i++)
+               printf("\t%s\n", vm_mem_backing_src_alias(i)->name);

 }
 
 enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name)
 {
        int i;
 
 }
 
 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;
+       for (i = 0; i < NUM_SRC_TYPES; i++)
+               if (!strcmp(type_name, vm_mem_backing_src_alias(i)->name))
+                       return i;

 
        backing_src_help();
        TEST_FAIL("Unknown backing src type: %s", type_name);
 
        backing_src_help();
        TEST_FAIL("Unknown backing src type: %s", type_name);