Loading...
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
28struct guest_random_state new_guest_random_state(uint32_t seed)
29{
30 struct guest_random_state s = {.seed = seed};
31 return s;
32}
33
34uint32_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 */
43size_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
81int64_t timespec_to_ns(struct timespec ts)
82{
83 return (int64_t)ts.tv_nsec + 1000000000LL * (int64_t)ts.tv_sec;
84}
85
86struct 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
97struct 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
104struct 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
111struct 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
119struct 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
126void 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
137bool 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
149size_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
168size_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
203const 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
295size_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
313bool is_backing_src_hugetlb(uint32_t i)
314{
315 return !!(vm_mem_backing_src_alias(i)->flag & MAP_HUGETLB);
316}
317
318static 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
328void 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
336enum 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
349long 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
365int 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
384char *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
398char *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}
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
25struct guest_random_state new_guest_random_state(uint32_t seed)
26{
27 struct guest_random_state s = {.seed = seed};
28 return s;
29}
30
31uint32_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 */
40size_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
78int64_t timespec_to_ns(struct timespec ts)
79{
80 return (int64_t)ts.tv_nsec + 1000000000LL * (int64_t)ts.tv_sec;
81}
82
83struct 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
94struct 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
101struct 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
108struct 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
116struct 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
123void 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
134bool 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
146size_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
165size_t get_def_hugetlb_pagesz(void)
166{
167 char buf[64];
168 const char *tag = "Hugepagesize:";
169 FILE *f;
170
171 f = fopen("/proc/meminfo", "r");
172 TEST_ASSERT(f != NULL, "Error in opening /proc/meminfo");
173
174 while (fgets(buf, sizeof(buf), f) != NULL) {
175 if (strstr(buf, tag) == buf) {
176 fclose(f);
177 return strtoull(buf + strlen(tag), NULL, 10) << 10;
178 }
179 }
180
181 if (feof(f))
182 TEST_FAIL("HUGETLB is not configured in host kernel");
183 else
184 TEST_FAIL("Error in reading /proc/meminfo");
185
186 fclose(f);
187 return 0;
188}
189
190#define ANON_FLAGS (MAP_PRIVATE | MAP_ANONYMOUS)
191#define ANON_HUGE_FLAGS (ANON_FLAGS | MAP_HUGETLB)
192
193const struct vm_mem_backing_src_alias *vm_mem_backing_src_alias(uint32_t i)
194{
195 static const struct vm_mem_backing_src_alias aliases[] = {
196 [VM_MEM_SRC_ANONYMOUS] = {
197 .name = "anonymous",
198 .flag = ANON_FLAGS,
199 },
200 [VM_MEM_SRC_ANONYMOUS_THP] = {
201 .name = "anonymous_thp",
202 .flag = ANON_FLAGS,
203 },
204 [VM_MEM_SRC_ANONYMOUS_HUGETLB] = {
205 .name = "anonymous_hugetlb",
206 .flag = ANON_HUGE_FLAGS,
207 },
208 [VM_MEM_SRC_ANONYMOUS_HUGETLB_16KB] = {
209 .name = "anonymous_hugetlb_16kb",
210 .flag = ANON_HUGE_FLAGS | MAP_HUGE_16KB,
211 },
212 [VM_MEM_SRC_ANONYMOUS_HUGETLB_64KB] = {
213 .name = "anonymous_hugetlb_64kb",
214 .flag = ANON_HUGE_FLAGS | MAP_HUGE_64KB,
215 },
216 [VM_MEM_SRC_ANONYMOUS_HUGETLB_512KB] = {
217 .name = "anonymous_hugetlb_512kb",
218 .flag = ANON_HUGE_FLAGS | MAP_HUGE_512KB,
219 },
220 [VM_MEM_SRC_ANONYMOUS_HUGETLB_1MB] = {
221 .name = "anonymous_hugetlb_1mb",
222 .flag = ANON_HUGE_FLAGS | MAP_HUGE_1MB,
223 },
224 [VM_MEM_SRC_ANONYMOUS_HUGETLB_2MB] = {
225 .name = "anonymous_hugetlb_2mb",
226 .flag = ANON_HUGE_FLAGS | MAP_HUGE_2MB,
227 },
228 [VM_MEM_SRC_ANONYMOUS_HUGETLB_8MB] = {
229 .name = "anonymous_hugetlb_8mb",
230 .flag = ANON_HUGE_FLAGS | MAP_HUGE_8MB,
231 },
232 [VM_MEM_SRC_ANONYMOUS_HUGETLB_16MB] = {
233 .name = "anonymous_hugetlb_16mb",
234 .flag = ANON_HUGE_FLAGS | MAP_HUGE_16MB,
235 },
236 [VM_MEM_SRC_ANONYMOUS_HUGETLB_32MB] = {
237 .name = "anonymous_hugetlb_32mb",
238 .flag = ANON_HUGE_FLAGS | MAP_HUGE_32MB,
239 },
240 [VM_MEM_SRC_ANONYMOUS_HUGETLB_256MB] = {
241 .name = "anonymous_hugetlb_256mb",
242 .flag = ANON_HUGE_FLAGS | MAP_HUGE_256MB,
243 },
244 [VM_MEM_SRC_ANONYMOUS_HUGETLB_512MB] = {
245 .name = "anonymous_hugetlb_512mb",
246 .flag = ANON_HUGE_FLAGS | MAP_HUGE_512MB,
247 },
248 [VM_MEM_SRC_ANONYMOUS_HUGETLB_1GB] = {
249 .name = "anonymous_hugetlb_1gb",
250 .flag = ANON_HUGE_FLAGS | MAP_HUGE_1GB,
251 },
252 [VM_MEM_SRC_ANONYMOUS_HUGETLB_2GB] = {
253 .name = "anonymous_hugetlb_2gb",
254 .flag = ANON_HUGE_FLAGS | MAP_HUGE_2GB,
255 },
256 [VM_MEM_SRC_ANONYMOUS_HUGETLB_16GB] = {
257 .name = "anonymous_hugetlb_16gb",
258 .flag = ANON_HUGE_FLAGS | MAP_HUGE_16GB,
259 },
260 [VM_MEM_SRC_SHMEM] = {
261 .name = "shmem",
262 .flag = MAP_SHARED,
263 },
264 [VM_MEM_SRC_SHARED_HUGETLB] = {
265 .name = "shared_hugetlb",
266 /*
267 * No MAP_HUGETLB, we use MFD_HUGETLB instead. Since
268 * we're using "file backed" memory, we need to specify
269 * this when the FD is created, not when the area is
270 * mapped.
271 */
272 .flag = MAP_SHARED,
273 },
274 };
275 _Static_assert(ARRAY_SIZE(aliases) == NUM_SRC_TYPES,
276 "Missing new backing src types?");
277
278 TEST_ASSERT(i < NUM_SRC_TYPES, "Backing src type ID %d too big", i);
279
280 return &aliases[i];
281}
282
283#define MAP_HUGE_PAGE_SIZE(x) (1ULL << ((x >> MAP_HUGE_SHIFT) & MAP_HUGE_MASK))
284
285size_t get_backing_src_pagesz(uint32_t i)
286{
287 uint32_t flag = vm_mem_backing_src_alias(i)->flag;
288
289 switch (i) {
290 case VM_MEM_SRC_ANONYMOUS:
291 case VM_MEM_SRC_SHMEM:
292 return getpagesize();
293 case VM_MEM_SRC_ANONYMOUS_THP:
294 return get_trans_hugepagesz();
295 case VM_MEM_SRC_ANONYMOUS_HUGETLB:
296 case VM_MEM_SRC_SHARED_HUGETLB:
297 return get_def_hugetlb_pagesz();
298 default:
299 return MAP_HUGE_PAGE_SIZE(flag);
300 }
301}
302
303bool is_backing_src_hugetlb(uint32_t i)
304{
305 return !!(vm_mem_backing_src_alias(i)->flag & MAP_HUGETLB);
306}
307
308static void print_available_backing_src_types(const char *prefix)
309{
310 int i;
311
312 printf("%sAvailable backing src types:\n", prefix);
313
314 for (i = 0; i < NUM_SRC_TYPES; i++)
315 printf("%s %s\n", prefix, vm_mem_backing_src_alias(i)->name);
316}
317
318void backing_src_help(const char *flag)
319{
320 printf(" %s: specify the type of memory that should be used to\n"
321 " back the guest data region. (default: %s)\n",
322 flag, vm_mem_backing_src_alias(DEFAULT_VM_MEM_SRC)->name);
323 print_available_backing_src_types(" ");
324}
325
326enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name)
327{
328 int i;
329
330 for (i = 0; i < NUM_SRC_TYPES; i++)
331 if (!strcmp(type_name, vm_mem_backing_src_alias(i)->name))
332 return i;
333
334 print_available_backing_src_types("");
335 TEST_FAIL("Unknown backing src type: %s", type_name);
336 return -1;
337}
338
339long get_run_delay(void)
340{
341 char path[64];
342 long val[2];
343 FILE *fp;
344
345 sprintf(path, "/proc/%ld/schedstat", syscall(SYS_gettid));
346 fp = fopen(path, "r");
347 /* Return MIN_RUN_DELAY_NS upon failure just to be safe */
348 if (fscanf(fp, "%ld %ld ", &val[0], &val[1]) < 2)
349 val[1] = MIN_RUN_DELAY_NS;
350 fclose(fp);
351
352 return val[1];
353}
354
355int atoi_paranoid(const char *num_str)
356{
357 char *end_ptr;
358 long num;
359
360 errno = 0;
361 num = strtol(num_str, &end_ptr, 0);
362 TEST_ASSERT(!errno, "strtol(\"%s\") failed", num_str);
363 TEST_ASSERT(num_str != end_ptr,
364 "strtol(\"%s\") didn't find a valid integer.", num_str);
365 TEST_ASSERT(*end_ptr == '\0',
366 "strtol(\"%s\") failed to parse trailing characters \"%s\".",
367 num_str, end_ptr);
368 TEST_ASSERT(num >= INT_MIN && num <= INT_MAX,
369 "%ld not in range of [%d, %d]", num, INT_MIN, INT_MAX);
370
371 return num;
372}