1
2
3
4
5
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 <linux/mman.h>
15#include "linux/kernel.h"
16
17#include "test_util.h"
18
19
20
21
22size_t parse_size(const char *size)
23{
24 size_t base;
25 char *scale;
26 int shift = 0;
27
28 TEST_ASSERT(size && isdigit(size[0]), "Need at least one digit in '%s'", size);
29
30 base = strtoull(size, &scale, 0);
31
32 TEST_ASSERT(base != ULLONG_MAX, "Overflow parsing size!");
33
34 switch (tolower(*scale)) {
35 case 't':
36 shift = 40;
37 break;
38 case 'g':
39 shift = 30;
40 break;
41 case 'm':
42 shift = 20;
43 break;
44 case 'k':
45 shift = 10;
46 break;
47 case 'b':
48 case '\0':
49 shift = 0;
50 break;
51 default:
52 TEST_ASSERT(false, "Unknown size letter %c", *scale);
53 }
54
55 TEST_ASSERT((base << shift) >> shift == base, "Overflow scaling size!");
56
57 return base << shift;
58}
59
60int64_t timespec_to_ns(struct timespec ts)
61{
62 return (int64_t)ts.tv_nsec + 1000000000LL * (int64_t)ts.tv_sec;
63}
64
65struct timespec timespec_add_ns(struct timespec ts, int64_t ns)
66{
67 struct timespec res;
68
69 res.tv_nsec = ts.tv_nsec + ns;
70 res.tv_sec = ts.tv_sec + res.tv_nsec / 1000000000LL;
71 res.tv_nsec %= 1000000000LL;
72
73 return res;
74}
75
76struct timespec timespec_add(struct timespec ts1, struct timespec ts2)
77{
78 int64_t ns1 = timespec_to_ns(ts1);
79 int64_t ns2 = timespec_to_ns(ts2);
80 return timespec_add_ns((struct timespec){0}, ns1 + ns2);
81}
82
83struct timespec timespec_sub(struct timespec ts1, struct timespec ts2)
84{
85 int64_t ns1 = timespec_to_ns(ts1);
86 int64_t ns2 = timespec_to_ns(ts2);
87 return timespec_add_ns((struct timespec){0}, ns1 - ns2);
88}
89
90struct timespec timespec_elapsed(struct timespec start)
91{
92 struct timespec end;
93
94 clock_gettime(CLOCK_MONOTONIC, &end);
95 return timespec_sub(end, start);
96}
97
98struct timespec timespec_div(struct timespec ts, int divisor)
99{
100 int64_t ns = timespec_to_ns(ts) / divisor;
101
102 return timespec_add_ns((struct timespec){0}, ns);
103}
104
105void print_skip(const char *fmt, ...)
106{
107 va_list ap;
108
109 assert(fmt);
110 va_start(ap, fmt);
111 vprintf(fmt, ap);
112 va_end(ap);
113 puts(", skipping test");
114}
115
116bool thp_configured(void)
117{
118 int ret;
119 struct stat statbuf;
120
121 ret = stat("/sys/kernel/mm/transparent_hugepage", &statbuf);
122 TEST_ASSERT(ret == 0 || (ret == -1 && errno == ENOENT),
123 "Error in stating /sys/kernel/mm/transparent_hugepage");
124
125 return ret == 0;
126}
127
128size_t get_trans_hugepagesz(void)
129{
130 size_t size;
131 FILE *f;
132
133 TEST_ASSERT(thp_configured(), "THP is not configured in host kernel");
134
135 f = fopen("/sys/kernel/mm/transparent_hugepage/hpage_pmd_size", "r");
136 TEST_ASSERT(f != NULL, "Error in opening transparent_hugepage/hpage_pmd_size");
137
138 fscanf(f, "%ld", &size);
139 fclose(f);
140
141 return size;
142}
143
144size_t get_def_hugetlb_pagesz(void)
145{
146 char buf[64];
147 const char *tag = "Hugepagesize:";
148 FILE *f;
149
150 f = fopen("/proc/meminfo", "r");
151 TEST_ASSERT(f != NULL, "Error in opening /proc/meminfo");
152
153 while (fgets(buf, sizeof(buf), f) != NULL) {
154 if (strstr(buf, tag) == buf) {
155 fclose(f);
156 return strtoull(buf + strlen(tag), NULL, 10) << 10;
157 }
158 }
159
160 if (feof(f))
161 TEST_FAIL("HUGETLB is not configured in host kernel");
162 else
163 TEST_FAIL("Error in reading /proc/meminfo");
164
165 fclose(f);
166 return 0;
167}
168
169#define ANON_FLAGS (MAP_PRIVATE | MAP_ANONYMOUS)
170#define ANON_HUGE_FLAGS (ANON_FLAGS | MAP_HUGETLB)
171
172const struct vm_mem_backing_src_alias *vm_mem_backing_src_alias(uint32_t i)
173{
174 static const struct vm_mem_backing_src_alias aliases[] = {
175 [VM_MEM_SRC_ANONYMOUS] = {
176 .name = "anonymous",
177 .flag = ANON_FLAGS,
178 },
179 [VM_MEM_SRC_ANONYMOUS_THP] = {
180 .name = "anonymous_thp",
181 .flag = ANON_FLAGS,
182 },
183 [VM_MEM_SRC_ANONYMOUS_HUGETLB] = {
184 .name = "anonymous_hugetlb",
185 .flag = ANON_HUGE_FLAGS,
186 },
187 [VM_MEM_SRC_ANONYMOUS_HUGETLB_16KB] = {
188 .name = "anonymous_hugetlb_16kb",
189 .flag = ANON_HUGE_FLAGS | MAP_HUGE_16KB,
190 },
191 [VM_MEM_SRC_ANONYMOUS_HUGETLB_64KB] = {
192 .name = "anonymous_hugetlb_64kb",
193 .flag = ANON_HUGE_FLAGS | MAP_HUGE_64KB,
194 },
195 [VM_MEM_SRC_ANONYMOUS_HUGETLB_512KB] = {
196 .name = "anonymous_hugetlb_512kb",
197 .flag = ANON_HUGE_FLAGS | MAP_HUGE_512KB,
198 },
199 [VM_MEM_SRC_ANONYMOUS_HUGETLB_1MB] = {
200 .name = "anonymous_hugetlb_1mb",
201 .flag = ANON_HUGE_FLAGS | MAP_HUGE_1MB,
202 },
203 [VM_MEM_SRC_ANONYMOUS_HUGETLB_2MB] = {
204 .name = "anonymous_hugetlb_2mb",
205 .flag = ANON_HUGE_FLAGS | MAP_HUGE_2MB,
206 },
207 [VM_MEM_SRC_ANONYMOUS_HUGETLB_8MB] = {
208 .name = "anonymous_hugetlb_8mb",
209 .flag = ANON_HUGE_FLAGS | MAP_HUGE_8MB,
210 },
211 [VM_MEM_SRC_ANONYMOUS_HUGETLB_16MB] = {
212 .name = "anonymous_hugetlb_16mb",
213 .flag = ANON_HUGE_FLAGS | MAP_HUGE_16MB,
214 },
215 [VM_MEM_SRC_ANONYMOUS_HUGETLB_32MB] = {
216 .name = "anonymous_hugetlb_32mb",
217 .flag = ANON_HUGE_FLAGS | MAP_HUGE_32MB,
218 },
219 [VM_MEM_SRC_ANONYMOUS_HUGETLB_256MB] = {
220 .name = "anonymous_hugetlb_256mb",
221 .flag = ANON_HUGE_FLAGS | MAP_HUGE_256MB,
222 },
223 [VM_MEM_SRC_ANONYMOUS_HUGETLB_512MB] = {
224 .name = "anonymous_hugetlb_512mb",
225 .flag = ANON_HUGE_FLAGS | MAP_HUGE_512MB,
226 },
227 [VM_MEM_SRC_ANONYMOUS_HUGETLB_1GB] = {
228 .name = "anonymous_hugetlb_1gb",
229 .flag = ANON_HUGE_FLAGS | MAP_HUGE_1GB,
230 },
231 [VM_MEM_SRC_ANONYMOUS_HUGETLB_2GB] = {
232 .name = "anonymous_hugetlb_2gb",
233 .flag = ANON_HUGE_FLAGS | MAP_HUGE_2GB,
234 },
235 [VM_MEM_SRC_ANONYMOUS_HUGETLB_16GB] = {
236 .name = "anonymous_hugetlb_16gb",
237 .flag = ANON_HUGE_FLAGS | MAP_HUGE_16GB,
238 },
239 [VM_MEM_SRC_SHMEM] = {
240 .name = "shmem",
241 .flag = MAP_SHARED,
242 },
243 [VM_MEM_SRC_SHARED_HUGETLB] = {
244 .name = "shared_hugetlb",
245
246
247
248
249
250
251 .flag = MAP_SHARED,
252 },
253 };
254 _Static_assert(ARRAY_SIZE(aliases) == NUM_SRC_TYPES,
255 "Missing new backing src types?");
256
257 TEST_ASSERT(i < NUM_SRC_TYPES, "Backing src type ID %d too big", i);
258
259 return &aliases[i];
260}
261
262#define MAP_HUGE_PAGE_SIZE(x) (1ULL << ((x >> MAP_HUGE_SHIFT) & MAP_HUGE_MASK))
263
264size_t get_backing_src_pagesz(uint32_t i)
265{
266 uint32_t flag = vm_mem_backing_src_alias(i)->flag;
267
268 switch (i) {
269 case VM_MEM_SRC_ANONYMOUS:
270 case VM_MEM_SRC_SHMEM:
271 return getpagesize();
272 case VM_MEM_SRC_ANONYMOUS_THP:
273 return get_trans_hugepagesz();
274 case VM_MEM_SRC_ANONYMOUS_HUGETLB:
275 case VM_MEM_SRC_SHARED_HUGETLB:
276 return get_def_hugetlb_pagesz();
277 default:
278 return MAP_HUGE_PAGE_SIZE(flag);
279 }
280}
281
282void backing_src_help(void)
283{
284 int i;
285
286 printf("Available backing src types:\n");
287 for (i = 0; i < NUM_SRC_TYPES; i++)
288 printf("\t%s\n", vm_mem_backing_src_alias(i)->name);
289}
290
291enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name)
292{
293 int i;
294
295 for (i = 0; i < NUM_SRC_TYPES; i++)
296 if (!strcmp(type_name, vm_mem_backing_src_alias(i)->name))
297 return i;
298
299 backing_src_help();
300 TEST_FAIL("Unknown backing src type: %s", type_name);
301 return -1;
302}
303