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