kvm/lib/test_util.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * tools/testing/selftests/kvm/lib/test_util.c
0004  *
0005  * Copyright (C) 2020, Google LLC.
0006  */
0007
0008 #include <assert.h>
0009 #include <ctype.h>
0010 #include <limits.h>
0011 #include <stdlib.h>
0012 #include <time.h>
0013 #include <sys/stat.h>
0014 #include <sys/syscall.h>
0015 #include <linux/mman.h>
0016 #include "linux/kernel.h"
0017
0018 #include "test_util.h"
0019
0020 /*
0021  * Parses "[0-9]+[kmgt]?".
0022  */
0023 size_t parse_size(const char *size)
0024 {
0025     size_t base;
0026     char *scale;
0027     int shift = 0;
0028
0029     TEST_ASSERT(size && isdigit(size[0]), "Need at least one digit in '%s'", size);
0030
0031     base = strtoull(size, &scale, 0);
0032
0033     TEST_ASSERT(base != ULLONG_MAX, "Overflow parsing size!");
0034
0035     switch (tolower(*scale)) {
0036     case 't':
0037         shift = 40;
0038         break;
0039     case 'g':
0040         shift = 30;
0041         break;
0042     case 'm':
0043         shift = 20;
0044         break;
0045     case 'k':
0046         shift = 10;
0047         break;
0048     case 'b':
0049     case '\0':
0050         shift = 0;
0051         break;
0052     default:
0053         TEST_ASSERT(false, "Unknown size letter %c", *scale);
0054     }
0055
0056     TEST_ASSERT((base << shift) >> shift == base, "Overflow scaling size!");
0057
0058     return base << shift;
0059 }
0060
0061 int64_t timespec_to_ns(struct timespec ts)
0062 {
0063     return (int64_t)ts.tv_nsec + 1000000000LL * (int64_t)ts.tv_sec;
0064 }
0065
0066 struct timespec timespec_add_ns(struct timespec ts, int64_t ns)
0067 {
0068     struct timespec res;
0069
0070     res.tv_nsec = ts.tv_nsec + ns;
0071     res.tv_sec = ts.tv_sec + res.tv_nsec / 1000000000LL;
0072     res.tv_nsec %= 1000000000LL;
0073
0074     return res;
0075 }
0076
0077 struct timespec timespec_add(struct timespec ts1, struct timespec ts2)
0078 {
0079     int64_t ns1 = timespec_to_ns(ts1);
0080     int64_t ns2 = timespec_to_ns(ts2);
0081     return timespec_add_ns((struct timespec){0}, ns1 + ns2);
0082 }
0083
0084 struct timespec timespec_sub(struct timespec ts1, struct timespec ts2)
0085 {
0086     int64_t ns1 = timespec_to_ns(ts1);
0087     int64_t ns2 = timespec_to_ns(ts2);
0088     return timespec_add_ns((struct timespec){0}, ns1 - ns2);
0089 }
0090
0091 struct timespec timespec_elapsed(struct timespec start)
0092 {
0093     struct timespec end;
0094
0095     clock_gettime(CLOCK_MONOTONIC, &end);
0096     return timespec_sub(end, start);
0097 }
0098
0099 struct timespec timespec_div(struct timespec ts, int divisor)
0100 {
0101     int64_t ns = timespec_to_ns(ts) / divisor;
0102
0103     return timespec_add_ns((struct timespec){0}, ns);
0104 }
0105
0106 void print_skip(const char *fmt, ...)
0107 {
0108     va_list ap;
0109
0110     assert(fmt);
0111     va_start(ap, fmt);
0112     vprintf(fmt, ap);
0113     va_end(ap);
0114     puts(", skipping test");
0115 }
0116
0117 bool thp_configured(void)
0118 {
0119     int ret;
0120     struct stat statbuf;
0121
0122     ret = stat("/sys/kernel/mm/transparent_hugepage", &statbuf);
0123     TEST_ASSERT(ret == 0 || (ret == -1 && errno == ENOENT),
0124             "Error in stating /sys/kernel/mm/transparent_hugepage");
0125
0126     return ret == 0;
0127 }
0128
0129 size_t get_trans_hugepagesz(void)
0130 {
0131     size_t size;
0132     FILE *f;
0133     int ret;
0134
0135     TEST_ASSERT(thp_configured(), "THP is not configured in host kernel");
0136
0137     f = fopen("/sys/kernel/mm/transparent_hugepage/hpage_pmd_size", "r");
0138     TEST_ASSERT(f != NULL, "Error in opening transparent_hugepage/hpage_pmd_size");
0139
0140     ret = fscanf(f, "%ld", &size);
0141     ret = fscanf(f, "%ld", &size);
0142     TEST_ASSERT(ret < 1, "Error reading transparent_hugepage/hpage_pmd_size");
0143     fclose(f);
0144
0145     return size;
0146 }
0147
0148 size_t get_def_hugetlb_pagesz(void)
0149 {
0150     char buf[64];
0151     const char *tag = "Hugepagesize:";
0152     FILE *f;
0153
0154     f = fopen("/proc/meminfo", "r");
0155     TEST_ASSERT(f != NULL, "Error in opening /proc/meminfo");
0156
0157     while (fgets(buf, sizeof(buf), f) != NULL) {
0158         if (strstr(buf, tag) == buf) {
0159             fclose(f);
0160             return strtoull(buf + strlen(tag), NULL, 10) << 10;
0161         }
0162     }
0163
0164     if (feof(f))
0165         TEST_FAIL("HUGETLB is not configured in host kernel");
0166     else
0167         TEST_FAIL("Error in reading /proc/meminfo");
0168
0169     fclose(f);
0170     return 0;
0171 }
0172
0173 #define ANON_FLAGS  (MAP_PRIVATE | MAP_ANONYMOUS)
0174 #define ANON_HUGE_FLAGS (ANON_FLAGS | MAP_HUGETLB)
0175
0176 const struct vm_mem_backing_src_alias *vm_mem_backing_src_alias(uint32_t i)
0177 {
0178     static const struct vm_mem_backing_src_alias aliases[] = {
0179         [VM_MEM_SRC_ANONYMOUS] = {
0180             .name = "anonymous",
0181             .flag = ANON_FLAGS,
0182         },
0183         [VM_MEM_SRC_ANONYMOUS_THP] = {
0184             .name = "anonymous_thp",
0185             .flag = ANON_FLAGS,
0186         },
0187         [VM_MEM_SRC_ANONYMOUS_HUGETLB] = {
0188             .name = "anonymous_hugetlb",
0189             .flag = ANON_HUGE_FLAGS,
0190         },
0191         [VM_MEM_SRC_ANONYMOUS_HUGETLB_16KB] = {
0192             .name = "anonymous_hugetlb_16kb",
0193             .flag = ANON_HUGE_FLAGS | MAP_HUGE_16KB,
0194         },
0195         [VM_MEM_SRC_ANONYMOUS_HUGETLB_64KB] = {
0196             .name = "anonymous_hugetlb_64kb",
0197             .flag = ANON_HUGE_FLAGS | MAP_HUGE_64KB,
0198         },
0199         [VM_MEM_SRC_ANONYMOUS_HUGETLB_512KB] = {
0200             .name = "anonymous_hugetlb_512kb",
0201             .flag = ANON_HUGE_FLAGS | MAP_HUGE_512KB,
0202         },
0203         [VM_MEM_SRC_ANONYMOUS_HUGETLB_1MB] = {
0204             .name = "anonymous_hugetlb_1mb",
0205             .flag = ANON_HUGE_FLAGS | MAP_HUGE_1MB,
0206         },
0207         [VM_MEM_SRC_ANONYMOUS_HUGETLB_2MB] = {
0208             .name = "anonymous_hugetlb_2mb",
0209             .flag = ANON_HUGE_FLAGS | MAP_HUGE_2MB,
0210         },
0211         [VM_MEM_SRC_ANONYMOUS_HUGETLB_8MB] = {
0212             .name = "anonymous_hugetlb_8mb",
0213             .flag = ANON_HUGE_FLAGS | MAP_HUGE_8MB,
0214         },
0215         [VM_MEM_SRC_ANONYMOUS_HUGETLB_16MB] = {
0216             .name = "anonymous_hugetlb_16mb",
0217             .flag = ANON_HUGE_FLAGS | MAP_HUGE_16MB,
0218         },
0219         [VM_MEM_SRC_ANONYMOUS_HUGETLB_32MB] = {
0220             .name = "anonymous_hugetlb_32mb",
0221             .flag = ANON_HUGE_FLAGS | MAP_HUGE_32MB,
0222         },
0223         [VM_MEM_SRC_ANONYMOUS_HUGETLB_256MB] = {
0224             .name = "anonymous_hugetlb_256mb",
0225             .flag = ANON_HUGE_FLAGS | MAP_HUGE_256MB,
0226         },
0227         [VM_MEM_SRC_ANONYMOUS_HUGETLB_512MB] = {
0228             .name = "anonymous_hugetlb_512mb",
0229             .flag = ANON_HUGE_FLAGS | MAP_HUGE_512MB,
0230         },
0231         [VM_MEM_SRC_ANONYMOUS_HUGETLB_1GB] = {
0232             .name = "anonymous_hugetlb_1gb",
0233             .flag = ANON_HUGE_FLAGS | MAP_HUGE_1GB,
0234         },
0235         [VM_MEM_SRC_ANONYMOUS_HUGETLB_2GB] = {
0236             .name = "anonymous_hugetlb_2gb",
0237             .flag = ANON_HUGE_FLAGS | MAP_HUGE_2GB,
0238         },
0239         [VM_MEM_SRC_ANONYMOUS_HUGETLB_16GB] = {
0240             .name = "anonymous_hugetlb_16gb",
0241             .flag = ANON_HUGE_FLAGS | MAP_HUGE_16GB,
0242         },
0243         [VM_MEM_SRC_SHMEM] = {
0244             .name = "shmem",
0245             .flag = MAP_SHARED,
0246         },
0247         [VM_MEM_SRC_SHARED_HUGETLB] = {
0248             .name = "shared_hugetlb",
0249             /*
0250              * No MAP_HUGETLB, we use MFD_HUGETLB instead. Since
0251              * we're using "file backed" memory, we need to specify
0252              * this when the FD is created, not when the area is
0253              * mapped.
0254              */
0255             .flag = MAP_SHARED,
0256         },
0257     };
0258     _Static_assert(ARRAY_SIZE(aliases) == NUM_SRC_TYPES,
0259                "Missing new backing src types?");
0260
0261     TEST_ASSERT(i < NUM_SRC_TYPES, "Backing src type ID %d too big", i);
0262
0263     return &aliases[i];
0264 }
0265
0266 #define MAP_HUGE_PAGE_SIZE(x) (1ULL << ((x >> MAP_HUGE_SHIFT) & MAP_HUGE_MASK))
0267
0268 size_t get_backing_src_pagesz(uint32_t i)
0269 {
0270     uint32_t flag = vm_mem_backing_src_alias(i)->flag;
0271
0272     switch (i) {
0273     case VM_MEM_SRC_ANONYMOUS:
0274     case VM_MEM_SRC_SHMEM:
0275         return getpagesize();
0276     case VM_MEM_SRC_ANONYMOUS_THP:
0277         return get_trans_hugepagesz();
0278     case VM_MEM_SRC_ANONYMOUS_HUGETLB:
0279     case VM_MEM_SRC_SHARED_HUGETLB:
0280         return get_def_hugetlb_pagesz();
0281     default:
0282         return MAP_HUGE_PAGE_SIZE(flag);
0283     }
0284 }
0285
0286 bool is_backing_src_hugetlb(uint32_t i)
0287 {
0288     return !!(vm_mem_backing_src_alias(i)->flag & MAP_HUGETLB);
0289 }
0290
0291 static void print_available_backing_src_types(const char *prefix)
0292 {
0293     int i;
0294
0295     printf("%sAvailable backing src types:\n", prefix);
0296
0297     for (i = 0; i < NUM_SRC_TYPES; i++)
0298         printf("%s    %s\n", prefix, vm_mem_backing_src_alias(i)->name);
0299 }
0300
0301 void backing_src_help(const char *flag)
0302 {
0303     printf(" %s: specify the type of memory that should be used to\n"
0304            "     back the guest data region. (default: %s)\n",
0305            flag, vm_mem_backing_src_alias(DEFAULT_VM_MEM_SRC)->name);
0306     print_available_backing_src_types("     ");
0307 }
0308
0309 enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name)
0310 {
0311     int i;
0312
0313     for (i = 0; i < NUM_SRC_TYPES; i++)
0314         if (!strcmp(type_name, vm_mem_backing_src_alias(i)->name))
0315             return i;
0316
0317     print_available_backing_src_types("");
0318     TEST_FAIL("Unknown backing src type: %s", type_name);
0319     return -1;
0320 }
0321
0322 long get_run_delay(void)
0323 {
0324     char path[64];
0325     long val[2];
0326     FILE *fp;
0327
0328     sprintf(path, "/proc/%ld/schedstat", syscall(SYS_gettid));
0329     fp = fopen(path, "r");
0330     /* Return MIN_RUN_DELAY_NS upon failure just to be safe */
0331     if (fscanf(fp, "%ld %ld ", &val[0], &val[1]) < 2)
0332         val[1] = MIN_RUN_DELAY_NS;
0333     fclose(fp);
0334
0335     return val[1];
0336 }