tools/testing/selftests/kvm/lib/test_util.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * tools/testing/selftests/kvm/lib/test_util.c
   4  *
   5  * Copyright (C) 2020, Google LLC.
   6  */
   7
   8 #define _GNU_SOURCE
   9 #include <stdio.h>
  10 #include <stdarg.h>
  11 #include <assert.h>
  12 #include <ctype.h>
  13 #include <limits.h>
  14 #include <stdlib.h>
  15 #include <time.h>
  16 #include <sys/stat.h>
  17 #include <sys/syscall.h>
  18 #include <linux/mman.h>
  19 #include "linux/kernel.h"
  20
  21 #include "test_util.h"
  22
  23 /*
  24  * Random number generator that is usable from guest code. This is the
  25  * Park-Miller LCG using standard constants.
  26  */
  27
  28 struct guest_random_state new_guest_random_state(uint32_t seed)
  29 {
  30         struct guest_random_state s = {.seed = seed};
  31         return s;
  32 }
  33
  34 uint32_t guest_random_u32(struct guest_random_state *state)
  35 {
  36         state->seed = (uint64_t)state->seed * 48271 % ((uint32_t)(1 << 31) - 1);
  37         return state->seed;
  38 }
  39
  40 /*
  41  * Parses "[0-9]+[kmgt]?".
  42  */
  43 size_t parse_size(const char *size)
  44 {
  45         size_t base;
  46         char *scale;
  47         int shift = 0;
  48
  49         TEST_ASSERT(size && isdigit(size[0]), "Need at least one digit in '%s'", size);
  50
  51         base = strtoull(size, &scale, 0);
  52
  53         TEST_ASSERT(base != ULLONG_MAX, "Overflow parsing size!");
  54
  55         switch (tolower(*scale)) {
  56         case 't':
  57                 shift = 40;
  58                 break;
  59         case 'g':
  60                 shift = 30;
  61                 break;
  62         case 'm':
  63                 shift = 20;
  64                 break;
  65         case 'k':
  66                 shift = 10;
  67                 break;
  68         case 'b':
  69         case '\0':
  70                 shift = 0;
  71                 break;
  72         default:
  73                 TEST_ASSERT(false, "Unknown size letter %c", *scale);
  74         }
  75
  76         TEST_ASSERT((base << shift) >> shift == base, "Overflow scaling size!");
  77
  78         return base << shift;
  79 }
  80
  81 int64_t timespec_to_ns(struct timespec ts)
  82 {
  83         return (int64_t)ts.tv_nsec + 1000000000LL * (int64_t)ts.tv_sec;
  84 }
  85
  86 struct timespec timespec_add_ns(struct timespec ts, int64_t ns)
  87 {
  88         struct timespec res;
  89
  90         res.tv_nsec = ts.tv_nsec + ns;
  91         res.tv_sec = ts.tv_sec + res.tv_nsec / 1000000000LL;
  92         res.tv_nsec %= 1000000000LL;
  93
  94         return res;
  95 }
  96
  97 struct timespec timespec_add(struct timespec ts1, struct timespec ts2)
  98 {
  99         int64_t ns1 = timespec_to_ns(ts1);
 100         int64_t ns2 = timespec_to_ns(ts2);
 101         return timespec_add_ns((struct timespec){0}, ns1 + ns2);
 102 }
 103
 104 struct timespec timespec_sub(struct timespec ts1, struct timespec ts2)
 105 {
 106         int64_t ns1 = timespec_to_ns(ts1);
 107         int64_t ns2 = timespec_to_ns(ts2);
 108         return timespec_add_ns((struct timespec){0}, ns1 - ns2);
 109 }
 110
 111 struct timespec timespec_elapsed(struct timespec start)
 112 {
 113         struct timespec end;
 114
 115         clock_gettime(CLOCK_MONOTONIC, &end);
 116         return timespec_sub(end, start);
 117 }
 118
 119 struct timespec timespec_div(struct timespec ts, int divisor)
 120 {
 121         int64_t ns = timespec_to_ns(ts) / divisor;
 122
 123         return timespec_add_ns((struct timespec){0}, ns);
 124 }
 125
 126 void print_skip(const char *fmt, ...)
 127 {
 128         va_list ap;
 129
 130         assert(fmt);
 131         va_start(ap, fmt);
 132         vprintf(fmt, ap);
 133         va_end(ap);
 134         puts(", skipping test");
 135 }
 136
 137 bool thp_configured(void)
 138 {
 139         int ret;
 140         struct stat statbuf;
 141
 142         ret = stat("/sys/kernel/mm/transparent_hugepage", &statbuf);
 143         TEST_ASSERT(ret == 0 || (ret == -1 && errno == ENOENT),
 144                     "Error in stating /sys/kernel/mm/transparent_hugepage");
 145
 146         return ret == 0;
 147 }
 148
 149 size_t get_trans_hugepagesz(void)
 150 {
 151         size_t size;
 152         FILE *f;
 153         int ret;
 154
 155         TEST_ASSERT(thp_configured(), "THP is not configured in host kernel");
 156
 157         f = fopen("/sys/kernel/mm/transparent_hugepage/hpage_pmd_size", "r");
 158         TEST_ASSERT(f != NULL, "Error in opening transparent_hugepage/hpage_pmd_size");
 159
 160         ret = fscanf(f, "%ld", &size);
 161         ret = fscanf(f, "%ld", &size);
 162         TEST_ASSERT(ret < 1, "Error reading transparent_hugepage/hpage_pmd_size");
 163         fclose(f);
 164
 165         return size;
 166 }
 167
 168 size_t get_def_hugetlb_pagesz(void)
 169 {
 170         char buf[64];
 171         const char *hugepagesize = "Hugepagesize:";
 172         const char *hugepages_total = "HugePages_Total:";
 173         FILE *f;
 174
 175         f = fopen("/proc/meminfo", "r");
 176         TEST_ASSERT(f != NULL, "Error in opening /proc/meminfo");
 177
 178         while (fgets(buf, sizeof(buf), f) != NULL) {
 179                 if (strstr(buf, hugepages_total) == buf) {
 180                         unsigned long long total = strtoull(buf + strlen(hugepages_total), NULL, 10);
 181                         if (!total) {
 182                                 fprintf(stderr, "HUGETLB is not enabled in /proc/sys/vm/nr_hugepages\n");
 183                                 exit(KSFT_SKIP);
 184                         }
 185                 }
 186                 if (strstr(buf, hugepagesize) == buf) {
 187                         fclose(f);
 188                         return strtoull(buf + strlen(hugepagesize), NULL, 10) << 10;
 189                 }
 190         }
 191
 192         if (feof(f)) {
 193                 fprintf(stderr, "HUGETLB is not configured in host kernel");
 194                 exit(KSFT_SKIP);
 195         }
 196
 197         TEST_FAIL("Error in reading /proc/meminfo");
 198 }
 199
 200 #define ANON_FLAGS      (MAP_PRIVATE | MAP_ANONYMOUS)
 201 #define ANON_HUGE_FLAGS (ANON_FLAGS | MAP_HUGETLB)
 202
 203 const struct vm_mem_backing_src_alias *vm_mem_backing_src_alias(uint32_t i)
 204 {
 205         static const struct vm_mem_backing_src_alias aliases[] = {
 206                 [VM_MEM_SRC_ANONYMOUS] = {
 207                         .name = "anonymous",
 208                         .flag = ANON_FLAGS,
 209                 },
 210                 [VM_MEM_SRC_ANONYMOUS_THP] = {
 211                         .name = "anonymous_thp",
 212                         .flag = ANON_FLAGS,
 213                 },
 214                 [VM_MEM_SRC_ANONYMOUS_HUGETLB] = {
 215                         .name = "anonymous_hugetlb",
 216                         .flag = ANON_HUGE_FLAGS,
 217                 },
 218                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_16KB] = {
 219                         .name = "anonymous_hugetlb_16kb",
 220                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_16KB,
 221                 },
 222                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_64KB] = {
 223                         .name = "anonymous_hugetlb_64kb",
 224                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_64KB,
 225                 },
 226                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_512KB] = {
 227                         .name = "anonymous_hugetlb_512kb",
 228                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_512KB,
 229                 },
 230                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_1MB] = {
 231                         .name = "anonymous_hugetlb_1mb",
 232                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_1MB,
 233                 },
 234                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_2MB] = {
 235                         .name = "anonymous_hugetlb_2mb",
 236                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_2MB,
 237                 },
 238                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_8MB] = {
 239                         .name = "anonymous_hugetlb_8mb",
 240                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_8MB,
 241                 },
 242                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_16MB] = {
 243                         .name = "anonymous_hugetlb_16mb",
 244                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_16MB,
 245                 },
 246                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_32MB] = {
 247                         .name = "anonymous_hugetlb_32mb",
 248                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_32MB,
 249                 },
 250                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_256MB] = {
 251                         .name = "anonymous_hugetlb_256mb",
 252                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_256MB,
 253                 },
 254                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_512MB] = {
 255                         .name = "anonymous_hugetlb_512mb",
 256                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_512MB,
 257                 },
 258                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_1GB] = {
 259                         .name = "anonymous_hugetlb_1gb",
 260                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_1GB,
 261                 },
 262                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_2GB] = {
 263                         .name = "anonymous_hugetlb_2gb",
 264                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_2GB,
 265                 },
 266                 [VM_MEM_SRC_ANONYMOUS_HUGETLB_16GB] = {
 267                         .name = "anonymous_hugetlb_16gb",
 268                         .flag = ANON_HUGE_FLAGS | MAP_HUGE_16GB,
 269                 },
 270                 [VM_MEM_SRC_SHMEM] = {
 271                         .name = "shmem",
 272                         .flag = MAP_SHARED,
 273                 },
 274                 [VM_MEM_SRC_SHARED_HUGETLB] = {
 275                         .name = "shared_hugetlb",
 276                         /*
 277                          * No MAP_HUGETLB, we use MFD_HUGETLB instead. Since
 278                          * we're using "file backed" memory, we need to specify
 279                          * this when the FD is created, not when the area is
 280                          * mapped.
 281                          */
 282                         .flag = MAP_SHARED,
 283                 },
 284         };
 285         _Static_assert(ARRAY_SIZE(aliases) == NUM_SRC_TYPES,
 286                        "Missing new backing src types?");
 287
 288         TEST_ASSERT(i < NUM_SRC_TYPES, "Backing src type ID %d too big", i);
 289
 290         return &aliases[i];
 291 }
 292
 293 #define MAP_HUGE_PAGE_SIZE(x) (1ULL << ((x >> MAP_HUGE_SHIFT) & MAP_HUGE_MASK))
 294
 295 size_t get_backing_src_pagesz(uint32_t i)
 296 {
 297         uint32_t flag = vm_mem_backing_src_alias(i)->flag;
 298
 299         switch (i) {
 300         case VM_MEM_SRC_ANONYMOUS:
 301         case VM_MEM_SRC_SHMEM:
 302                 return getpagesize();
 303         case VM_MEM_SRC_ANONYMOUS_THP:
 304                 return get_trans_hugepagesz();
 305         case VM_MEM_SRC_ANONYMOUS_HUGETLB:
 306         case VM_MEM_SRC_SHARED_HUGETLB:
 307                 return get_def_hugetlb_pagesz();
 308         default:
 309                 return MAP_HUGE_PAGE_SIZE(flag);
 310         }
 311 }
 312
 313 bool is_backing_src_hugetlb(uint32_t i)
 314 {
 315         return !!(vm_mem_backing_src_alias(i)->flag & MAP_HUGETLB);
 316 }
 317
 318 static void print_available_backing_src_types(const char *prefix)
 319 {
 320         int i;
 321
 322         printf("%sAvailable backing src types:\n", prefix);
 323
 324         for (i = 0; i < NUM_SRC_TYPES; i++)
 325                 printf("%s    %s\n", prefix, vm_mem_backing_src_alias(i)->name);
 326 }
 327
 328 void backing_src_help(const char *flag)
 329 {
 330         printf(" %s: specify the type of memory that should be used to\n"
 331                "     back the guest data region. (default: %s)\n",
 332                flag, vm_mem_backing_src_alias(DEFAULT_VM_MEM_SRC)->name);
 333         print_available_backing_src_types("     ");
 334 }
 335
 336 enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name)
 337 {
 338         int i;
 339
 340         for (i = 0; i < NUM_SRC_TYPES; i++)
 341                 if (!strcmp(type_name, vm_mem_backing_src_alias(i)->name))
 342                         return i;
 343
 344         print_available_backing_src_types("");
 345         TEST_FAIL("Unknown backing src type: %s", type_name);
 346         return -1;
 347 }
 348
 349 long get_run_delay(void)
 350 {
 351         char path[64];
 352         long val[2];
 353         FILE *fp;
 354
 355         sprintf(path, "/proc/%ld/schedstat", syscall(SYS_gettid));
 356         fp = fopen(path, "r");
 357         /* Return MIN_RUN_DELAY_NS upon failure just to be safe */
 358         if (fscanf(fp, "%ld %ld ", &val[0], &val[1]) < 2)
 359                 val[1] = MIN_RUN_DELAY_NS;
 360         fclose(fp);
 361
 362         return val[1];
 363 }
 364
 365 int atoi_paranoid(const char *num_str)
 366 {
 367         char *end_ptr;
 368         long num;
 369
 370         errno = 0;
 371         num = strtol(num_str, &end_ptr, 0);
 372         TEST_ASSERT(!errno, "strtol(\"%s\") failed", num_str);
 373         TEST_ASSERT(num_str != end_ptr,
 374                     "strtol(\"%s\") didn't find a valid integer.", num_str);
 375         TEST_ASSERT(*end_ptr == '\0',
 376                     "strtol(\"%s\") failed to parse trailing characters \"%s\".",
 377                     num_str, end_ptr);
 378         TEST_ASSERT(num >= INT_MIN && num <= INT_MAX,
 379                     "%ld not in range of [%d, %d]", num, INT_MIN, INT_MAX);
 380
 381         return num;
 382 }
 383
 384 char *strdup_printf(const char *fmt, ...)
 385 {
 386         va_list ap;
 387         char *str;
 388
 389         va_start(ap, fmt);
 390         vasprintf(&str, fmt, ap);
 391         va_end(ap);
 392
 393         return str;
 394 }