1 #define TST_NO_DEFAULT_MAIN
2
3 #include "config.h"
4 #include <sys/types.h>
5 #include <sys/mman.h>
6 #include <sys/mount.h>
7 #include <sys/stat.h>
8 #include <sys/wait.h>
9 #include <sys/param.h>
10 #include <errno.h>
11 #include <fcntl.h>
12 #if HAVE_NUMA_H
13 #include <numa.h>
14 #endif
15 #if HAVE_NUMAIF_H
16 #include <numaif.h>
17 #endif
18 #include <pthread.h>
19 #include <stdarg.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <stdlib.h>
23 #include <unistd.h>
24
25 #include "mem.h"
26 #include "numa_helper.h"
27
28 /* OOM */
29
30 long overcommit = -1;
31
alloc_mem(long int length,int testcase)32 static int alloc_mem(long int length, int testcase)
33 {
34 char *s;
35 long i, pagesz = getpagesize();
36 int loop = 10;
37
38 tst_res(TINFO, "thread (%lx), allocating %ld bytes.",
39 (unsigned long) pthread_self(), length);
40
41 s = mmap(NULL, length, PROT_READ | PROT_WRITE,
42 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
43 if (s == MAP_FAILED)
44 return errno;
45
46 if (testcase == MLOCK) {
47 while (mlock(s, length) == -1 && loop > 0) {
48 if (EAGAIN != errno)
49 return errno;
50 usleep(300000);
51 loop--;
52 }
53 }
54
55 #ifdef HAVE_DECL_MADV_MERGEABLE
56 if (testcase == KSM && madvise(s, length, MADV_MERGEABLE) == -1)
57 return errno;
58 #endif
59 for (i = 0; i < length; i += pagesz)
60 s[i] = '\a';
61
62 return 0;
63 }
64
child_alloc_thread(void * args)65 static void *child_alloc_thread(void *args)
66 {
67 int ret = 0;
68
69 /* keep allocating until there's an error */
70 while (!ret)
71 ret = alloc_mem(LENGTH, (long)args);
72 exit(ret);
73 }
74
child_alloc(int testcase,int lite,int threads)75 static void child_alloc(int testcase, int lite, int threads)
76 {
77 int i;
78 pthread_t *th;
79
80 if (lite) {
81 int ret = alloc_mem(TESTMEM + MB, testcase);
82 exit(ret);
83 }
84
85 th = malloc(sizeof(pthread_t) * threads);
86 if (!th) {
87 tst_res(TINFO | TERRNO, "malloc");
88 goto out;
89 }
90
91 for (i = 0; i < threads; i++) {
92 TEST(pthread_create(&th[i], NULL, child_alloc_thread,
93 (void *)((long)testcase)));
94 if (TST_RET) {
95 tst_res(TINFO | TRERRNO, "pthread_create");
96 /*
97 * Keep going if thread other than first fails to
98 * spawn due to lack of resources.
99 */
100 if (i == 0 || TST_RET != EAGAIN)
101 goto out;
102 }
103 }
104
105 /* wait for one of threads to exit whole process */
106 while (1)
107 sleep(1);
108 out:
109 exit(1);
110 }
111
112 /*
113 * oom - allocates memory according to specified testcase and checks
114 * desired outcome (e.g. child killed, operation failed with ENOMEM)
115 * @testcase: selects how child allocates memory
116 * valid choices are: NORMAL, MLOCK and KSM
117 * @lite: if non-zero, child makes only single TESTMEM+MB allocation
118 * if zero, child keeps allocating memory until it gets killed
119 * or some operation fails
120 * @retcode: expected return code of child process
121 * if matches child ret code, this function reports PASS,
122 * otherwise it reports FAIL
123 * @allow_sigkill: if zero and child is killed, this function reports FAIL
124 * if non-zero, then if child is killed by SIGKILL
125 * it is considered as PASS
126 */
oom(int testcase,int lite,int retcode,int allow_sigkill)127 void oom(int testcase, int lite, int retcode, int allow_sigkill)
128 {
129 pid_t pid;
130 int status, threads;
131
132 switch (pid = SAFE_FORK()) {
133 case 0:
134 threads = MAX(1, tst_ncpus() - 1);
135 child_alloc(testcase, lite, threads);
136 default:
137 break;
138 }
139
140 tst_res(TINFO, "expected victim is %d.", pid);
141 SAFE_WAITPID(-1, &status, 0);
142
143 if (WIFSIGNALED(status)) {
144 if (allow_sigkill && WTERMSIG(status) == SIGKILL) {
145 tst_res(TPASS, "victim signalled: (%d) %s",
146 SIGKILL,
147 tst_strsig(SIGKILL));
148 } else {
149 tst_res(TFAIL, "victim signalled: (%d) %s",
150 WTERMSIG(status),
151 tst_strsig(WTERMSIG(status)));
152 }
153 } else if (WIFEXITED(status)) {
154 if (WEXITSTATUS(status) == retcode) {
155 tst_res(TPASS, "victim retcode: (%d) %s",
156 retcode, strerror(retcode));
157 } else {
158 tst_res(TFAIL, "victim unexpectedly ended with "
159 "retcode: %d, expected: %d",
160 WEXITSTATUS(status), retcode);
161 }
162 } else {
163 tst_res(TFAIL, "victim unexpectedly ended");
164 }
165 }
166
167 #ifdef HAVE_NUMA_V2
set_global_mempolicy(int mempolicy)168 static void set_global_mempolicy(int mempolicy)
169 {
170 unsigned long nmask[MAXNODES / BITS_PER_LONG] = { 0 };
171 int num_nodes, *nodes;
172 int ret;
173
174 if (mempolicy) {
175 ret = get_allowed_nodes_arr(NH_MEMS|NH_CPUS, &num_nodes, &nodes);
176 if (ret != 0)
177 tst_brk(TBROK|TERRNO, "get_allowed_nodes_arr");
178 if (num_nodes < 2) {
179 tst_res(TINFO, "mempolicy need NUMA system support");
180 free(nodes);
181 return;
182 }
183 switch(mempolicy) {
184 case MPOL_BIND:
185 /* bind the second node */
186 set_node(nmask, nodes[1]);
187 break;
188 case MPOL_INTERLEAVE:
189 case MPOL_PREFERRED:
190 if (num_nodes == 2) {
191 tst_res(TINFO, "The mempolicy need "
192 "more than 2 numa nodes");
193 free(nodes);
194 return;
195 } else {
196 /* Using the 2nd,3rd node */
197 set_node(nmask, nodes[1]);
198 set_node(nmask, nodes[2]);
199 }
200 break;
201 default:
202 tst_brk(TBROK|TERRNO, "Bad mempolicy mode");
203 }
204 if (set_mempolicy(mempolicy, nmask, MAXNODES) == -1)
205 tst_brk(TBROK|TERRNO, "set_mempolicy");
206 }
207 }
208 #else
set_global_mempolicy(int mempolicy LTP_ATTRIBUTE_UNUSED)209 static void set_global_mempolicy(int mempolicy LTP_ATTRIBUTE_UNUSED) { }
210 #endif
211
testoom(int mempolicy,int lite,int retcode,int allow_sigkill)212 void testoom(int mempolicy, int lite, int retcode, int allow_sigkill)
213 {
214 int ksm_run_orig;
215
216 set_global_mempolicy(mempolicy);
217
218 tst_res(TINFO, "start normal OOM testing.");
219 oom(NORMAL, lite, retcode, allow_sigkill);
220
221 tst_res(TINFO, "start OOM testing for mlocked pages.");
222 oom(MLOCK, lite, retcode, allow_sigkill);
223
224 /*
225 * Skip oom(KSM) if lite == 1, since limit_in_bytes may vary from
226 * run to run, which isn't reliable for oom03 cgroup test.
227 */
228 if (access(PATH_KSM, F_OK) == -1 || lite == 1) {
229 tst_res(TINFO, "KSM is not configed or lite == 1, "
230 "skip OOM test for KSM pags");
231 } else {
232 tst_res(TINFO, "start OOM testing for KSM pages.");
233 SAFE_FILE_SCANF(PATH_KSM "run", "%d", &ksm_run_orig);
234 SAFE_FILE_PRINTF(PATH_KSM "run", "1");
235 oom(KSM, lite, retcode, allow_sigkill);
236 SAFE_FILE_PRINTF(PATH_KSM "run", "%d", ksm_run_orig);
237 }
238 }
239
240 /* KSM */
241
check(char * path,long int value)242 static void check(char *path, long int value)
243 {
244 char fullpath[BUFSIZ];
245 long actual_val;
246
247 snprintf(fullpath, BUFSIZ, PATH_KSM "%s", path);
248 SAFE_FILE_SCANF(fullpath, "%ld", &actual_val);
249
250 if (actual_val != value)
251 tst_res(TFAIL, "%s is not %ld but %ld.", path, value,
252 actual_val);
253 else
254 tst_res(TPASS, "%s is %ld.", path, actual_val);
255 }
256
final_group_check(int run,int pages_shared,int pages_sharing,int pages_volatile,int pages_unshared,int sleep_millisecs,int pages_to_scan)257 static void final_group_check(int run, int pages_shared, int pages_sharing,
258 int pages_volatile, int pages_unshared,
259 int sleep_millisecs, int pages_to_scan)
260 {
261 tst_res(TINFO, "check!");
262 check("run", run);
263 check("pages_shared", pages_shared);
264 check("pages_sharing", pages_sharing);
265 check("pages_volatile", pages_volatile);
266 check("pages_unshared", pages_unshared);
267 check("sleep_millisecs", sleep_millisecs);
268 check("pages_to_scan", pages_to_scan);
269 }
270
group_check(int run,int pages_shared,int pages_sharing,int pages_volatile,int pages_unshared,int sleep_millisecs,int pages_to_scan)271 static void group_check(int run, int pages_shared, int pages_sharing,
272 int pages_volatile, int pages_unshared,
273 int sleep_millisecs, int pages_to_scan)
274 {
275 if (run != 1) {
276 tst_res(TFAIL, "group_check run is not 1, %d.", run);
277 } else {
278 /* wait for ksm daemon to scan all mergeable pages. */
279 wait_ksmd_full_scan();
280 }
281
282 final_group_check(run, pages_shared, pages_sharing,
283 pages_volatile, pages_unshared,
284 sleep_millisecs, pages_to_scan);
285 }
286
verify(char ** memory,char value,int proc,int start,int end,int start2,int end2)287 static void verify(char **memory, char value, int proc,
288 int start, int end, int start2, int end2)
289 {
290 int i, j;
291 void *s = NULL;
292
293 s = SAFE_MALLOC((end - start) * (end2 - start2));
294
295 tst_res(TINFO, "child %d verifies memory content.", proc);
296 memset(s, value, (end - start) * (end2 - start2));
297 if (memcmp(memory[start], s, (end - start) * (end2 - start2))
298 != 0)
299 for (j = start; j < end; j++)
300 for (i = start2; i < end2; i++)
301 if (memory[j][i] != value)
302 tst_res(TFAIL, "child %d has %c at "
303 "%d,%d,%d.",
304 proc, memory[j][i], proc,
305 j, i);
306 free(s);
307 }
308
check_hugepage(void)309 void check_hugepage(void)
310 {
311 if (access(PATH_HUGEPAGES, F_OK))
312 tst_brk(TCONF, "Huge page is not supported.");
313 }
314
315 struct ksm_merge_data {
316 char data;
317 unsigned int mergeable_size;
318 };
319
ksm_child_memset(int child_num,int size,int total_unit,struct ksm_merge_data ksm_merge_data,char ** memory)320 static void ksm_child_memset(int child_num, int size, int total_unit,
321 struct ksm_merge_data ksm_merge_data, char **memory)
322 {
323 int i = 0, j;
324 int unit = size / total_unit;
325
326 tst_res(TINFO, "child %d continues...", child_num);
327
328 if (ksm_merge_data.mergeable_size == size * MB) {
329 tst_res(TINFO, "child %d allocates %d MB filled with '%c'",
330 child_num, size, ksm_merge_data.data);
331
332 } else {
333 tst_res(TINFO, "child %d allocates %d MB filled with '%c'"
334 " except one page with 'e'",
335 child_num, size, ksm_merge_data.data);
336 }
337
338 for (j = 0; j < total_unit; j++) {
339 for (i = 0; (unsigned int)i < unit * MB; i++)
340 memory[j][i] = ksm_merge_data.data;
341 }
342
343 /* if it contains unshared page, then set 'e' char
344 * at the end of the last page
345 */
346 if (ksm_merge_data.mergeable_size < size * MB)
347 memory[j-1][i-1] = 'e';
348 }
349
create_ksm_child(int child_num,int size,int unit,struct ksm_merge_data * ksm_merge_data)350 static void create_ksm_child(int child_num, int size, int unit,
351 struct ksm_merge_data *ksm_merge_data)
352 {
353 int j, total_unit;
354 char **memory;
355
356 /* The total units in all */
357 total_unit = size / unit;
358
359 /* Apply for the space for memory */
360 memory = SAFE_MALLOC(total_unit * sizeof(char *));
361 for (j = 0; j < total_unit; j++) {
362 memory[j] = SAFE_MMAP(NULL, unit * MB, PROT_READ|PROT_WRITE,
363 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
364 #ifdef HAVE_DECL_MADV_MERGEABLE
365 if (madvise(memory[j], unit * MB, MADV_MERGEABLE) == -1)
366 tst_brk(TBROK|TERRNO, "madvise");
367 #endif
368 }
369
370 tst_res(TINFO, "child %d stops.", child_num);
371 if (raise(SIGSTOP) == -1)
372 tst_brk(TBROK|TERRNO, "kill");
373 fflush(stdout);
374
375 for (j = 0; j < 4; j++) {
376
377 ksm_child_memset(child_num, size, total_unit,
378 ksm_merge_data[j], memory);
379
380 fflush(stdout);
381
382 tst_res(TINFO, "child %d stops.", child_num);
383 if (raise(SIGSTOP) == -1)
384 tst_brk(TBROK|TERRNO, "kill");
385
386 if (ksm_merge_data[j].mergeable_size < size * MB) {
387 verify(memory, 'e', child_num, total_unit - 1,
388 total_unit, unit * MB - 1, unit * MB);
389 verify(memory, ksm_merge_data[j].data, child_num,
390 0, total_unit, 0, unit * MB - 1);
391 } else {
392 verify(memory, ksm_merge_data[j].data, child_num,
393 0, total_unit, 0, unit * MB);
394 }
395 }
396
397 tst_res(TINFO, "child %d finished.", child_num);
398 }
399
stop_ksm_children(int * child,int num)400 static void stop_ksm_children(int *child, int num)
401 {
402 int k, status;
403
404 tst_res(TINFO, "wait for all children to stop.");
405 for (k = 0; k < num; k++) {
406 SAFE_WAITPID(child[k], &status, WUNTRACED);
407 if (!WIFSTOPPED(status))
408 tst_brk(TBROK, "child %d was not stopped", k);
409 }
410 }
411
resume_ksm_children(int * child,int num)412 static void resume_ksm_children(int *child, int num)
413 {
414 int k;
415
416 tst_res(TINFO, "resume all children.");
417 for (k = 0; k < num; k++)
418 SAFE_KILL(child[k], SIGCONT);
419
420 fflush(stdout);
421 }
422
create_same_memory(int size,int num,int unit)423 void create_same_memory(int size, int num, int unit)
424 {
425 int i, j, status, *child;
426 unsigned long ps, pages;
427 struct ksm_merge_data **ksm_data;
428
429 struct ksm_merge_data ksm_data0[] = {
430 {'c', size*MB}, {'c', size*MB}, {'d', size*MB}, {'d', size*MB},
431 };
432 struct ksm_merge_data ksm_data1[] = {
433 {'a', size*MB}, {'b', size*MB}, {'d', size*MB}, {'d', size*MB-1},
434 };
435 struct ksm_merge_data ksm_data2[] = {
436 {'a', size*MB}, {'a', size*MB}, {'d', size*MB}, {'d', size*MB},
437 };
438
439 ps = sysconf(_SC_PAGE_SIZE);
440 pages = MB / ps;
441
442 ksm_data = malloc((num - 3) * sizeof(struct ksm_merge_data *));
443 /* Since from third child, the data is same with the first child's */
444 for (i = 0; i < num - 3; i++) {
445 ksm_data[i] = malloc(4 * sizeof(struct ksm_merge_data));
446 for (j = 0; j < 4; j++) {
447 ksm_data[i][j].data = ksm_data0[j].data;
448 ksm_data[i][j].mergeable_size =
449 ksm_data0[j].mergeable_size;
450 }
451 }
452
453 child = SAFE_MALLOC(num * sizeof(int));
454
455 for (i = 0; i < num; i++) {
456 fflush(stdout);
457 switch (child[i] = SAFE_FORK()) {
458 case 0:
459 if (i == 0) {
460 create_ksm_child(i, size, unit, ksm_data0);
461 exit(0);
462 } else if (i == 1) {
463 create_ksm_child(i, size, unit, ksm_data1);
464 exit(0);
465 } else if (i == 2) {
466 create_ksm_child(i, size, unit, ksm_data2);
467 exit(0);
468 } else {
469 create_ksm_child(i, size, unit, ksm_data[i-3]);
470 exit(0);
471 }
472 }
473 }
474
475 stop_ksm_children(child, num);
476
477 tst_res(TINFO, "KSM merging...");
478 if (access(PATH_KSM "max_page_sharing", F_OK) == 0) {
479 SAFE_FILE_PRINTF(PATH_KSM "run", "2");
480 SAFE_FILE_PRINTF(PATH_KSM "max_page_sharing", "%ld", size * pages * num);
481 }
482
483 SAFE_FILE_PRINTF(PATH_KSM "run", "1");
484 SAFE_FILE_PRINTF(PATH_KSM "pages_to_scan", "%ld", size * pages * num);
485 SAFE_FILE_PRINTF(PATH_KSM "sleep_millisecs", "0");
486
487 resume_ksm_children(child, num);
488 stop_ksm_children(child, num);
489 group_check(1, 2, size * num * pages - 2, 0, 0, 0, size * pages * num);
490
491 resume_ksm_children(child, num);
492 stop_ksm_children(child, num);
493 group_check(1, 3, size * num * pages - 3, 0, 0, 0, size * pages * num);
494
495 resume_ksm_children(child, num);
496 stop_ksm_children(child, num);
497 group_check(1, 1, size * num * pages - 1, 0, 0, 0, size * pages * num);
498
499 resume_ksm_children(child, num);
500 stop_ksm_children(child, num);
501 group_check(1, 1, size * num * pages - 2, 0, 1, 0, size * pages * num);
502
503 tst_res(TINFO, "KSM unmerging...");
504 SAFE_FILE_PRINTF(PATH_KSM "run", "2");
505
506 resume_ksm_children(child, num);
507 final_group_check(2, 0, 0, 0, 0, 0, size * pages * num);
508
509 tst_res(TINFO, "stop KSM.");
510 SAFE_FILE_PRINTF(PATH_KSM "run", "0");
511 final_group_check(0, 0, 0, 0, 0, 0, size * pages * num);
512
513 while (waitpid(-1, &status, 0) > 0)
514 if (WEXITSTATUS(status) != 0)
515 tst_res(TFAIL, "child exit status is %d",
516 WEXITSTATUS(status));
517 }
518
test_ksm_merge_across_nodes(unsigned long nr_pages)519 void test_ksm_merge_across_nodes(unsigned long nr_pages)
520 {
521 char **memory;
522 int i, ret;
523 int num_nodes, *nodes;
524 unsigned long length;
525 unsigned long pagesize;
526
527 #ifdef HAVE_NUMA_V2
528 unsigned long nmask[MAXNODES / BITS_PER_LONG] = { 0 };
529 #endif
530
531 ret = get_allowed_nodes_arr(NH_MEMS, &num_nodes, &nodes);
532 if (ret != 0)
533 tst_brk(TBROK|TERRNO, "get_allowed_nodes_arr");
534 if (num_nodes < 2) {
535 tst_res(TINFO, "need NUMA system support");
536 free(nodes);
537 return;
538 }
539
540 pagesize = sysconf(_SC_PAGE_SIZE);
541 length = nr_pages * pagesize;
542
543 memory = SAFE_MALLOC(num_nodes * sizeof(char *));
544 for (i = 0; i < num_nodes; i++) {
545 memory[i] = SAFE_MMAP(NULL, length, PROT_READ|PROT_WRITE,
546 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
547 #ifdef HAVE_DECL_MADV_MERGEABLE
548 if (madvise(memory[i], length, MADV_MERGEABLE) == -1)
549 tst_brk(TBROK|TERRNO, "madvise");
550 #endif
551
552 #ifdef HAVE_NUMA_V2
553 clean_node(nmask);
554 set_node(nmask, nodes[i]);
555 /*
556 * Use mbind() to make sure each node contains
557 * length size memory.
558 */
559 ret = mbind(memory[i], length, MPOL_BIND, nmask, MAXNODES, 0);
560 if (ret == -1)
561 tst_brk(TBROK|TERRNO, "mbind");
562 #endif
563
564 memset(memory[i], 10, length);
565 }
566
567 SAFE_FILE_PRINTF(PATH_KSM "sleep_millisecs", "0");
568 SAFE_FILE_PRINTF(PATH_KSM "pages_to_scan", "%ld",
569 nr_pages * num_nodes);
570 /*
571 * merge_across_nodes and max_page_sharing setting can be changed
572 * only when there are no ksm shared pages in system, so set run 2
573 * to unmerge pages first, then to 1 after changing merge_across_nodes,
574 * to remerge according to the new setting.
575 */
576 SAFE_FILE_PRINTF(PATH_KSM "run", "2");
577 if (access(PATH_KSM "max_page_sharing", F_OK) == 0)
578 SAFE_FILE_PRINTF(PATH_KSM "max_page_sharing",
579 "%ld", nr_pages * num_nodes);
580 tst_res(TINFO, "Start to test KSM with merge_across_nodes=1");
581 SAFE_FILE_PRINTF(PATH_KSM "merge_across_nodes", "1");
582 SAFE_FILE_PRINTF(PATH_KSM "run", "1");
583 group_check(1, 1, nr_pages * num_nodes - 1, 0, 0, 0,
584 nr_pages * num_nodes);
585
586 SAFE_FILE_PRINTF(PATH_KSM "run", "2");
587 tst_res(TINFO, "Start to test KSM with merge_across_nodes=0");
588 SAFE_FILE_PRINTF(PATH_KSM "merge_across_nodes", "0");
589 SAFE_FILE_PRINTF(PATH_KSM "run", "1");
590 group_check(1, num_nodes, nr_pages * num_nodes - num_nodes,
591 0, 0, 0, nr_pages * num_nodes);
592
593 SAFE_FILE_PRINTF(PATH_KSM "run", "2");
594 }
595
596 /* THP */
597
598 /* cpuset/memcg */
gather_node_cpus(char * cpus,long nd)599 static void gather_node_cpus(char *cpus, long nd)
600 {
601 int ncpus = 0;
602 int i;
603 long online;
604 char buf[BUFSIZ];
605 char path[BUFSIZ], path1[BUFSIZ];
606
607 while (path_exist(PATH_SYS_SYSTEM "/cpu/cpu%d", ncpus))
608 ncpus++;
609
610 for (i = 0; i < ncpus; i++) {
611 snprintf(path, BUFSIZ,
612 PATH_SYS_SYSTEM "/node/node%ld/cpu%d", nd, i);
613 if (path_exist(path)) {
614 snprintf(path1, BUFSIZ, "%s/online", path);
615 /*
616 * if there is no online knob, then the cpu cannot
617 * be taken offline
618 */
619 if (path_exist(path1)) {
620 SAFE_FILE_SCANF(path1, "%ld", &online);
621 if (online == 0)
622 continue;
623 }
624 sprintf(buf, "%d,", i);
625 strcat(cpus, buf);
626 }
627 }
628 /* Remove the trailing comma. */
629 cpus[strlen(cpus) - 1] = '\0';
630 }
631
write_cpusets(const struct tst_cgroup_group * cg,long nd)632 void write_cpusets(const struct tst_cgroup_group *cg, long nd)
633 {
634 char cpus[BUFSIZ] = "";
635
636 SAFE_CGROUP_PRINTF(cg, "cpuset.mems", "%ld", nd);
637
638 gather_node_cpus(cpus, nd);
639 /*
640 * If the 'nd' node doesn't contain any CPUs,
641 * the first ID of CPU '0' will be used as
642 * the value of cpuset.cpus.
643 */
644 if (strlen(cpus) != 0) {
645 SAFE_CGROUP_PRINT(cg, "cpuset.cpus", cpus);
646 } else {
647 tst_res(TINFO, "No CPUs in the node%ld; "
648 "using only CPU0", nd);
649 SAFE_CGROUP_PRINT(cg, "cpuset.cpus", "0");
650 }
651 }
652
653 /* shared */
654
655 /* Warning: *DO NOT* use this function in child */
get_a_numa_node(void)656 unsigned int get_a_numa_node(void)
657 {
658 unsigned int nd1, nd2;
659 int ret;
660
661 ret = get_allowed_nodes(0, 2, &nd1, &nd2);
662 switch (ret) {
663 case 0:
664 break;
665 case -3:
666 tst_brk(TCONF, "requires a NUMA system.");
667 default:
668 tst_brk(TBROK | TERRNO, "1st get_allowed_nodes");
669 }
670
671 ret = get_allowed_nodes(NH_MEMS | NH_CPUS, 1, &nd1);
672 switch (ret) {
673 case 0:
674 tst_res(TINFO, "get node%u.", nd1);
675 return nd1;
676 case -3:
677 tst_brk(TCONF, "requires a NUMA system that has "
678 "at least one node with both memory and CPU "
679 "available.");
680 default:
681 tst_brk(TBROK | TERRNO, "2nd get_allowed_nodes");
682 }
683
684 /* not reached */
685 abort();
686 }
687
path_exist(const char * path,...)688 int path_exist(const char *path, ...)
689 {
690 va_list ap;
691 char pathbuf[PATH_MAX];
692
693 va_start(ap, path);
694 vsnprintf(pathbuf, sizeof(pathbuf), path, ap);
695 va_end(ap);
696
697 return access(pathbuf, F_OK) == 0;
698 }
699
set_sys_tune(char * sys_file,long tune,int check)700 void set_sys_tune(char *sys_file, long tune, int check)
701 {
702 long val;
703 char path[BUFSIZ];
704
705 tst_res(TINFO, "set %s to %ld", sys_file, tune);
706
707 snprintf(path, BUFSIZ, PATH_SYSVM "%s", sys_file);
708 SAFE_FILE_PRINTF(path, "%ld", tune);
709
710 if (check) {
711 val = get_sys_tune(sys_file);
712 if (val != tune)
713 tst_brk(TBROK, "%s = %ld, but expect %ld",
714 sys_file, val, tune);
715 }
716 }
717
get_sys_tune(char * sys_file)718 long get_sys_tune(char *sys_file)
719 {
720 char path[BUFSIZ];
721 long tune;
722
723 snprintf(path, BUFSIZ, PATH_SYSVM "%s", sys_file);
724 SAFE_FILE_SCANF(path, "%ld", &tune);
725
726 return tune;
727 }
728
update_shm_size(size_t * shm_size)729 void update_shm_size(size_t * shm_size)
730 {
731 size_t shmmax;
732
733 SAFE_FILE_SCANF(PATH_SHMMAX, "%zu", &shmmax);
734 if (*shm_size > shmmax) {
735 tst_res(TINFO, "Set shm_size to shmmax: %zu", shmmax);
736 *shm_size = shmmax;
737 }
738 }
739
range_is_mapped(unsigned long low,unsigned long high)740 int range_is_mapped(unsigned long low, unsigned long high)
741 {
742 FILE *fp;
743
744 fp = fopen("/proc/self/maps", "r");
745 if (fp == NULL)
746 tst_brk(TBROK | TERRNO, "Failed to open /proc/self/maps.");
747
748 while (!feof(fp)) {
749 unsigned long start, end;
750 int ret;
751
752 ret = fscanf(fp, "%lx-%lx %*[^\n]\n", &start, &end);
753 if (ret != 2) {
754 fclose(fp);
755 tst_brk(TBROK | TERRNO, "Couldn't parse /proc/self/maps line.");
756 }
757
758 if ((start >= low) && (start < high)) {
759 fclose(fp);
760 return 1;
761 }
762 if ((end >= low) && (end < high)) {
763 fclose(fp);
764 return 1;
765 }
766 }
767
768 fclose(fp);
769 return 0;
770 }
771