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