xref: /linux/tools/testing/selftests/kvm/lib/test_util.c (revision 1f20a5769446a1acae67ac9e63d07a594829a789)
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 	TEST_ASSERT(vasprintf(&str, fmt, ap) >= 0, "vasprintf() failed");
391 	va_end(ap);
392 
393 	return str;
394 }
395 
396 #define CLOCKSOURCE_PATH "/sys/devices/system/clocksource/clocksource0/current_clocksource"
397 
398 char *sys_get_cur_clocksource(void)
399 {
400 	char *clk_name;
401 	struct stat st;
402 	FILE *fp;
403 
404 	fp = fopen(CLOCKSOURCE_PATH, "r");
405 	TEST_ASSERT(fp, "failed to open clocksource file, errno: %d", errno);
406 
407 	TEST_ASSERT(!fstat(fileno(fp), &st), "failed to stat clocksource file, errno: %d",
408 		    errno);
409 
410 	clk_name = malloc(st.st_size);
411 	TEST_ASSERT(clk_name, "failed to allocate buffer to read file");
412 
413 	TEST_ASSERT(fgets(clk_name, st.st_size, fp), "failed to read clocksource file: %d",
414 		    ferror(fp));
415 
416 	fclose(fp);
417 
418 	return clk_name;
419 }
420