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
new_guest_random_state(uint32_t seed)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
guest_random_u32(struct guest_random_state * state)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 */
parse_size(const char * size)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
timespec_to_ns(struct timespec ts)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
timespec_add_ns(struct timespec ts,int64_t ns)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
timespec_add(struct timespec ts1,struct timespec ts2)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
timespec_sub(struct timespec ts1,struct timespec ts2)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
timespec_elapsed(struct timespec start)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
timespec_div(struct timespec ts,int divisor)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
print_skip(const char * fmt,...)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
test_sysfs_path(const char * path)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
thp_configured(void)147 bool thp_configured(void)
148 {
149 return test_sysfs_path("/sys/kernel/mm/transparent_hugepage");
150 }
151
get_sysfs_val(const char * path)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
get_trans_hugepagesz(void)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
is_numa_balancing_enabled(void)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
get_def_hugetlb_pagesz(void)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
vm_mem_backing_src_alias(uint32_t i)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
get_backing_src_pagesz(uint32_t i)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
is_backing_src_hugetlb(uint32_t i)331 bool is_backing_src_hugetlb(uint32_t i)
332 {
333 return !!(vm_mem_backing_src_alias(i)->flag & MAP_HUGETLB);
334 }
335
print_available_backing_src_types(const char * prefix)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
backing_src_help(const char * flag)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
parse_backing_src_type(const char * type_name)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
get_run_delay(void)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
atoi_paranoid(const char * num_str)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
strdup_printf(const char * fmt,...)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
sys_get_cur_clocksource(void)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