1 // SPDX-License-Identifier: GPL-2.0
15 #include "../kselftest.h"
16 #include <include/vdso/time64.h>
19 #define KSM_SYSFS_PATH "/sys/kernel/mm/ksm/"
20 #define KSM_FP(s) (KSM_SYSFS_PATH s)
21 #define KSM_SCAN_LIMIT_SEC_DEFAULT 120
22 #define KSM_PAGE_COUNT_DEFAULT 10l
23 #define KSM_PROT_STR_DEFAULT "rw"
24 #define KSM_USE_ZERO_PAGES_DEFAULT false
25 #define KSM_MERGE_ACROSS_NODES_DEFAULT true
26 #define KSM_MERGE_TYPE_DEFAULT 0
27 #define MB (1ul << 20)
30 unsigned long max_page_sharing;
31 unsigned long merge_across_nodes;
32 unsigned long pages_to_scan;
34 unsigned long sleep_millisecs;
35 unsigned long stable_node_chains_prune_millisecs;
36 unsigned long use_zero_pages;
42 KSM_MERGE_LAST = KSM_MERGE_PRCTL
48 CHECK_KSM_GET_MERGE_TYPE,
49 CHECK_KSM_ZERO_PAGE_MERGE,
52 KSM_MERGE_TIME_HUGE_PAGES,
59 static int ksm_write_sysfs(const char *file_path, unsigned long val)
61 FILE *f = fopen(file_path, "w");
64 fprintf(stderr, "f %s\n", file_path);
68 if (fprintf(f, "%lu", val) < 0) {
78 static int ksm_read_sysfs(const char *file_path, unsigned long *val)
80 FILE *f = fopen(file_path, "r");
83 fprintf(stderr, "f %s\n", file_path);
87 if (fscanf(f, "%lu", val) != 1) {
97 static void ksm_print_sysfs(void)
99 unsigned long max_page_sharing, pages_sharing, pages_shared;
100 unsigned long full_scans, pages_unshared, pages_volatile;
101 unsigned long stable_node_chains, stable_node_dups;
104 if (ksm_read_sysfs(KSM_FP("pages_shared"), &pages_shared) ||
105 ksm_read_sysfs(KSM_FP("pages_sharing"), &pages_sharing) ||
106 ksm_read_sysfs(KSM_FP("max_page_sharing"), &max_page_sharing) ||
107 ksm_read_sysfs(KSM_FP("full_scans"), &full_scans) ||
108 ksm_read_sysfs(KSM_FP("pages_unshared"), &pages_unshared) ||
109 ksm_read_sysfs(KSM_FP("pages_volatile"), &pages_volatile) ||
110 ksm_read_sysfs(KSM_FP("stable_node_chains"), &stable_node_chains) ||
111 ksm_read_sysfs(KSM_FP("stable_node_dups"), &stable_node_dups) ||
112 ksm_read_sysfs(KSM_FP("general_profit"), (unsigned long *)&general_profit))
115 printf("pages_shared : %lu\n", pages_shared);
116 printf("pages_sharing : %lu\n", pages_sharing);
117 printf("max_page_sharing : %lu\n", max_page_sharing);
118 printf("full_scans : %lu\n", full_scans);
119 printf("pages_unshared : %lu\n", pages_unshared);
120 printf("pages_volatile : %lu\n", pages_volatile);
121 printf("stable_node_chains: %lu\n", stable_node_chains);
122 printf("stable_node_dups : %lu\n", stable_node_dups);
123 printf("general_profit : %ld\n", general_profit);
126 static void ksm_print_procfs(void)
128 const char *file_name = "/proc/self/ksm_stat";
130 FILE *f = fopen(file_name, "r");
133 fprintf(stderr, "f %s\n", file_name);
138 while (fgets(buffer, sizeof(buffer), f))
139 printf("%s", buffer);
144 static int str_to_prot(char *prot_str)
148 if ((strchr(prot_str, 'r')) != NULL)
150 if ((strchr(prot_str, 'w')) != NULL)
152 if ((strchr(prot_str, 'x')) != NULL)
158 static void print_help(void)
160 printf("usage: ksm_tests [-h] <test type> [-a prot] [-p page_count] [-l timeout]\n"
161 "[-z use_zero_pages] [-m merge_across_nodes] [-s size]\n");
163 printf("Supported <test type>:\n"
164 " -M (page merging)\n"
165 " -Z (zero pages merging)\n"
166 " -N (merging of pages in different NUMA nodes)\n"
167 " -U (page unmerging)\n"
168 " -P evaluate merging time and speed.\n"
169 " For this test, the size of duplicated memory area (in MiB)\n"
170 " must be provided using -s option\n"
171 " -H evaluate merging time and speed of area allocated mostly with huge pages\n"
172 " For this test, the size of duplicated memory area (in MiB)\n"
173 " must be provided using -s option\n"
174 " -D evaluate unmerging time and speed when disabling KSM.\n"
175 " For this test, the size of duplicated memory area (in MiB)\n"
176 " must be provided using -s option\n"
177 " -C evaluate the time required to break COW of merged pages.\n\n");
179 printf(" -a: specify the access protections of pages.\n"
180 " <prot> must be of the form [rwx].\n"
181 " Default: %s\n", KSM_PROT_STR_DEFAULT);
182 printf(" -p: specify the number of pages to test.\n"
183 " Default: %ld\n", KSM_PAGE_COUNT_DEFAULT);
184 printf(" -l: limit the maximum running time (in seconds) for a test.\n"
185 " Default: %d seconds\n", KSM_SCAN_LIMIT_SEC_DEFAULT);
186 printf(" -z: change use_zero_pages tunable\n"
187 " Default: %d\n", KSM_USE_ZERO_PAGES_DEFAULT);
188 printf(" -m: change merge_across_nodes tunable\n"
189 " Default: %d\n", KSM_MERGE_ACROSS_NODES_DEFAULT);
190 printf(" -d: turn debugging output on\n");
191 printf(" -s: the size of duplicated memory area (in MiB)\n");
192 printf(" -t: KSM merge type\n"
194 " 0: madvise merging\n"
195 " 1: prctl merging\n");
200 static void *allocate_memory(void *ptr, int prot, int mapping, char data, size_t map_size)
202 void *map_ptr = mmap(ptr, map_size, PROT_WRITE, mapping, -1, 0);
208 memset(map_ptr, data, map_size);
209 if (mprotect(map_ptr, map_size, prot)) {
211 munmap(map_ptr, map_size);
218 static int ksm_do_scan(int scan_count, struct timespec start_time, int timeout)
220 struct timespec cur_time;
221 unsigned long cur_scan, init_scan;
223 if (ksm_read_sysfs(KSM_FP("full_scans"), &init_scan))
225 cur_scan = init_scan;
227 while (cur_scan < init_scan + scan_count) {
228 if (ksm_read_sysfs(KSM_FP("full_scans"), &cur_scan))
230 if (clock_gettime(CLOCK_MONOTONIC_RAW, &cur_time)) {
231 perror("clock_gettime");
234 if ((cur_time.tv_sec - start_time.tv_sec) > timeout) {
235 printf("Scan time limit exceeded\n");
243 static int ksm_merge_pages(int merge_type, void *addr, size_t size,
244 struct timespec start_time, int timeout)
246 if (merge_type == KSM_MERGE_MADVISE) {
247 if (madvise(addr, size, MADV_MERGEABLE)) {
251 } else if (merge_type == KSM_MERGE_PRCTL) {
252 if (prctl(PR_SET_MEMORY_MERGE, 1, 0, 0, 0)) {
258 if (ksm_write_sysfs(KSM_FP("run"), 1))
261 /* Since merging occurs only after 2 scans, make sure to get at least 2 full scans */
262 if (ksm_do_scan(2, start_time, timeout))
268 static int ksm_unmerge_pages(void *addr, size_t size,
269 struct timespec start_time, int timeout)
271 if (madvise(addr, size, MADV_UNMERGEABLE)) {
278 static bool assert_ksm_pages_count(long dupl_page_count)
280 unsigned long max_page_sharing, pages_sharing, pages_shared;
282 if (ksm_read_sysfs(KSM_FP("pages_shared"), &pages_shared) ||
283 ksm_read_sysfs(KSM_FP("pages_sharing"), &pages_sharing) ||
284 ksm_read_sysfs(KSM_FP("max_page_sharing"), &max_page_sharing))
293 * Since there must be at least 2 pages for merging and 1 page can be
294 * shared with the limited number of pages (max_page_sharing), sometimes
295 * there are 'leftover' pages that cannot be merged. For example, if there
296 * are 11 pages and max_page_sharing = 10, then only 10 pages will be
297 * merged and the 11th page won't be affected. As a result, when the number
298 * of duplicate pages is divided by max_page_sharing and the remainder is 1,
299 * pages_shared and pages_sharing values will be equal between dupl_page_count
300 * and dupl_page_count - 1.
302 if (dupl_page_count % max_page_sharing == 1 || dupl_page_count % max_page_sharing == 0) {
303 if (pages_shared == dupl_page_count / max_page_sharing &&
304 pages_sharing == pages_shared * (max_page_sharing - 1))
307 if (pages_shared == (dupl_page_count / max_page_sharing + 1) &&
308 pages_sharing == dupl_page_count - pages_shared)
315 static int ksm_save_def(struct ksm_sysfs *ksm_sysfs)
317 if (ksm_read_sysfs(KSM_FP("max_page_sharing"), &ksm_sysfs->max_page_sharing) ||
318 numa_available() ? 0 :
319 ksm_read_sysfs(KSM_FP("merge_across_nodes"), &ksm_sysfs->merge_across_nodes) ||
320 ksm_read_sysfs(KSM_FP("sleep_millisecs"), &ksm_sysfs->sleep_millisecs) ||
321 ksm_read_sysfs(KSM_FP("pages_to_scan"), &ksm_sysfs->pages_to_scan) ||
322 ksm_read_sysfs(KSM_FP("run"), &ksm_sysfs->run) ||
323 ksm_read_sysfs(KSM_FP("stable_node_chains_prune_millisecs"),
324 &ksm_sysfs->stable_node_chains_prune_millisecs) ||
325 ksm_read_sysfs(KSM_FP("use_zero_pages"), &ksm_sysfs->use_zero_pages))
331 static int ksm_restore(struct ksm_sysfs *ksm_sysfs)
333 if (ksm_write_sysfs(KSM_FP("max_page_sharing"), ksm_sysfs->max_page_sharing) ||
334 numa_available() ? 0 :
335 ksm_write_sysfs(KSM_FP("merge_across_nodes"), ksm_sysfs->merge_across_nodes) ||
336 ksm_write_sysfs(KSM_FP("pages_to_scan"), ksm_sysfs->pages_to_scan) ||
337 ksm_write_sysfs(KSM_FP("run"), ksm_sysfs->run) ||
338 ksm_write_sysfs(KSM_FP("sleep_millisecs"), ksm_sysfs->sleep_millisecs) ||
339 ksm_write_sysfs(KSM_FP("stable_node_chains_prune_millisecs"),
340 ksm_sysfs->stable_node_chains_prune_millisecs) ||
341 ksm_write_sysfs(KSM_FP("use_zero_pages"), ksm_sysfs->use_zero_pages))
347 static int check_ksm_merge(int merge_type, int mapping, int prot,
348 long page_count, int timeout, size_t page_size)
351 struct timespec start_time;
353 if (clock_gettime(CLOCK_MONOTONIC_RAW, &start_time)) {
354 perror("clock_gettime");
358 /* fill pages with the same data and merge them */
359 map_ptr = allocate_memory(NULL, prot, mapping, '*', page_size * page_count);
363 if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))
366 /* verify that the right number of pages are merged */
367 if (assert_ksm_pages_count(page_count)) {
369 munmap(map_ptr, page_size * page_count);
370 if (merge_type == KSM_MERGE_PRCTL)
371 prctl(PR_SET_MEMORY_MERGE, 0, 0, 0, 0);
377 munmap(map_ptr, page_size * page_count);
381 static int check_ksm_unmerge(int merge_type, int mapping, int prot, int timeout, size_t page_size)
384 struct timespec start_time;
387 if (clock_gettime(CLOCK_MONOTONIC_RAW, &start_time)) {
388 perror("clock_gettime");
392 /* fill pages with the same data and merge them */
393 map_ptr = allocate_memory(NULL, prot, mapping, '*', page_size * page_count);
397 if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))
400 /* change 1 byte in each of the 2 pages -- KSM must automatically unmerge them */
401 memset(map_ptr, '-', 1);
402 memset(map_ptr + page_size, '+', 1);
404 /* get at least 1 scan, so KSM can detect that the pages were modified */
405 if (ksm_do_scan(1, start_time, timeout))
408 /* check that unmerging was successful and 0 pages are currently merged */
409 if (assert_ksm_pages_count(0)) {
411 munmap(map_ptr, page_size * page_count);
417 munmap(map_ptr, page_size * page_count);
421 static int check_ksm_zero_page_merge(int merge_type, int mapping, int prot, long page_count,
422 int timeout, bool use_zero_pages, size_t page_size)
425 struct timespec start_time;
427 if (clock_gettime(CLOCK_MONOTONIC_RAW, &start_time)) {
428 perror("clock_gettime");
432 if (ksm_write_sysfs(KSM_FP("use_zero_pages"), use_zero_pages))
435 /* fill pages with zero and try to merge them */
436 map_ptr = allocate_memory(NULL, prot, mapping, 0, page_size * page_count);
440 if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))
444 * verify that the right number of pages are merged:
445 * 1) if use_zero_pages is set to 1, empty pages are merged
446 * with the kernel zero page instead of with each other;
447 * 2) if use_zero_pages is set to 0, empty pages are not treated specially
448 * and merged as usual.
450 if (use_zero_pages && !assert_ksm_pages_count(0))
452 else if (!use_zero_pages && !assert_ksm_pages_count(page_count))
456 munmap(map_ptr, page_size * page_count);
461 munmap(map_ptr, page_size * page_count);
465 static int get_next_mem_node(int node)
470 int i, max_node = numa_max_node();
472 for (i = node + 1; i <= max_node + node; i++) {
473 mem_node = i % (max_node + 1);
474 node_size = numa_node_size(mem_node, NULL);
481 static int get_first_mem_node(void)
483 return get_next_mem_node(numa_max_node());
486 static int check_ksm_numa_merge(int merge_type, int mapping, int prot, int timeout,
487 bool merge_across_nodes, size_t page_size)
489 void *numa1_map_ptr, *numa2_map_ptr;
490 struct timespec start_time;
494 if (clock_gettime(CLOCK_MONOTONIC_RAW, &start_time)) {
495 perror("clock_gettime");
499 if (numa_available() < 0) {
500 perror("NUMA support not enabled");
503 if (numa_num_configured_nodes() <= 1) {
504 printf("At least 2 NUMA nodes must be available\n");
507 if (ksm_write_sysfs(KSM_FP("merge_across_nodes"), merge_across_nodes))
510 /* allocate 2 pages in 2 different NUMA nodes and fill them with the same data */
511 first_node = get_first_mem_node();
512 numa1_map_ptr = numa_alloc_onnode(page_size, first_node);
513 numa2_map_ptr = numa_alloc_onnode(page_size, get_next_mem_node(first_node));
514 if (!numa1_map_ptr || !numa2_map_ptr) {
515 perror("numa_alloc_onnode");
519 memset(numa1_map_ptr, '*', page_size);
520 memset(numa2_map_ptr, '*', page_size);
522 /* try to merge the pages */
523 if (ksm_merge_pages(merge_type, numa1_map_ptr, page_size, start_time, timeout) ||
524 ksm_merge_pages(merge_type, numa2_map_ptr, page_size, start_time, timeout))
528 * verify that the right number of pages are merged:
529 * 1) if merge_across_nodes was enabled, 2 duplicate pages will be merged;
530 * 2) if merge_across_nodes = 0, there must be 0 merged pages, since there is
531 * only 1 unique page in each node and they can't be shared.
533 if (merge_across_nodes && !assert_ksm_pages_count(page_count))
535 else if (!merge_across_nodes && !assert_ksm_pages_count(0))
538 numa_free(numa1_map_ptr, page_size);
539 numa_free(numa2_map_ptr, page_size);
544 numa_free(numa1_map_ptr, page_size);
545 numa_free(numa2_map_ptr, page_size);
550 static int ksm_merge_hugepages_time(int merge_type, int mapping, int prot,
551 int timeout, size_t map_size)
553 void *map_ptr, *map_ptr_orig;
554 struct timespec start_time, end_time;
555 unsigned long scan_time_ns;
556 int pagemap_fd, n_normal_pages, n_huge_pages;
559 size_t len = map_size;
561 len -= len % HPAGE_SIZE;
562 map_ptr_orig = mmap(NULL, len + HPAGE_SIZE, PROT_READ | PROT_WRITE,
563 MAP_ANONYMOUS | MAP_NORESERVE | MAP_PRIVATE, -1, 0);
564 map_ptr = map_ptr_orig + HPAGE_SIZE - (uintptr_t)map_ptr_orig % HPAGE_SIZE;
566 if (map_ptr_orig == MAP_FAILED)
567 err(2, "initial mmap");
569 if (madvise(map_ptr, len + HPAGE_SIZE, MADV_HUGEPAGE))
570 err(2, "MADV_HUGEPAGE");
572 pagemap_fd = open("/proc/self/pagemap", O_RDONLY);
574 err(2, "open pagemap");
578 for (void *p = map_ptr; p < map_ptr + len; p += HPAGE_SIZE) {
579 if (allocate_transhuge(p, pagemap_fd) < 0)
584 printf("Number of normal pages: %d\n", n_normal_pages);
585 printf("Number of huge pages: %d\n", n_huge_pages);
587 memset(map_ptr, '*', len);
589 if (clock_gettime(CLOCK_MONOTONIC_RAW, &start_time)) {
590 perror("clock_gettime");
593 if (ksm_merge_pages(merge_type, map_ptr, map_size, start_time, timeout))
595 if (clock_gettime(CLOCK_MONOTONIC_RAW, &end_time)) {
596 perror("clock_gettime");
600 scan_time_ns = (end_time.tv_sec - start_time.tv_sec) * NSEC_PER_SEC +
601 (end_time.tv_nsec - start_time.tv_nsec);
603 printf("Total size: %lu MiB\n", map_size / MB);
604 printf("Total time: %ld.%09ld s\n", scan_time_ns / NSEC_PER_SEC,
605 scan_time_ns % NSEC_PER_SEC);
606 printf("Average speed: %.3f MiB/s\n", (map_size / MB) /
607 ((double)scan_time_ns / NSEC_PER_SEC));
609 munmap(map_ptr_orig, len + HPAGE_SIZE);
614 munmap(map_ptr_orig, len + HPAGE_SIZE);
618 static int ksm_merge_time(int merge_type, int mapping, int prot, int timeout, size_t map_size)
621 struct timespec start_time, end_time;
622 unsigned long scan_time_ns;
626 map_ptr = allocate_memory(NULL, prot, mapping, '*', map_size);
630 if (clock_gettime(CLOCK_MONOTONIC_RAW, &start_time)) {
631 perror("clock_gettime");
634 if (ksm_merge_pages(merge_type, map_ptr, map_size, start_time, timeout))
636 if (clock_gettime(CLOCK_MONOTONIC_RAW, &end_time)) {
637 perror("clock_gettime");
641 scan_time_ns = (end_time.tv_sec - start_time.tv_sec) * NSEC_PER_SEC +
642 (end_time.tv_nsec - start_time.tv_nsec);
644 printf("Total size: %lu MiB\n", map_size / MB);
645 printf("Total time: %ld.%09ld s\n", scan_time_ns / NSEC_PER_SEC,
646 scan_time_ns % NSEC_PER_SEC);
647 printf("Average speed: %.3f MiB/s\n", (map_size / MB) /
648 ((double)scan_time_ns / NSEC_PER_SEC));
650 munmap(map_ptr, map_size);
655 munmap(map_ptr, map_size);
659 static int ksm_unmerge_time(int merge_type, int mapping, int prot, int timeout, size_t map_size)
662 struct timespec start_time, end_time;
663 unsigned long scan_time_ns;
667 map_ptr = allocate_memory(NULL, prot, mapping, '*', map_size);
670 if (clock_gettime(CLOCK_MONOTONIC_RAW, &start_time)) {
671 perror("clock_gettime");
674 if (ksm_merge_pages(merge_type, map_ptr, map_size, start_time, timeout))
677 if (clock_gettime(CLOCK_MONOTONIC_RAW, &start_time)) {
678 perror("clock_gettime");
681 if (ksm_unmerge_pages(map_ptr, map_size, start_time, timeout))
683 if (clock_gettime(CLOCK_MONOTONIC_RAW, &end_time)) {
684 perror("clock_gettime");
688 scan_time_ns = (end_time.tv_sec - start_time.tv_sec) * NSEC_PER_SEC +
689 (end_time.tv_nsec - start_time.tv_nsec);
691 printf("Total size: %lu MiB\n", map_size / MB);
692 printf("Total time: %ld.%09ld s\n", scan_time_ns / NSEC_PER_SEC,
693 scan_time_ns % NSEC_PER_SEC);
694 printf("Average speed: %.3f MiB/s\n", (map_size / MB) /
695 ((double)scan_time_ns / NSEC_PER_SEC));
697 munmap(map_ptr, map_size);
702 munmap(map_ptr, map_size);
706 static int ksm_cow_time(int merge_type, int mapping, int prot, int timeout, size_t page_size)
709 struct timespec start_time, end_time;
710 unsigned long cow_time_ns;
712 /* page_count must be less than 2*page_size */
713 size_t page_count = 4000;
715 map_ptr = allocate_memory(NULL, prot, mapping, '*', page_size * page_count);
719 if (clock_gettime(CLOCK_MONOTONIC_RAW, &start_time)) {
720 perror("clock_gettime");
723 for (size_t i = 0; i < page_count - 1; i = i + 2)
724 memset(map_ptr + page_size * i, '-', 1);
725 if (clock_gettime(CLOCK_MONOTONIC_RAW, &end_time)) {
726 perror("clock_gettime");
730 cow_time_ns = (end_time.tv_sec - start_time.tv_sec) * NSEC_PER_SEC +
731 (end_time.tv_nsec - start_time.tv_nsec);
733 printf("Total size: %lu MiB\n\n", (page_size * page_count) / MB);
734 printf("Not merged pages:\n");
735 printf("Total time: %ld.%09ld s\n", cow_time_ns / NSEC_PER_SEC,
736 cow_time_ns % NSEC_PER_SEC);
737 printf("Average speed: %.3f MiB/s\n\n", ((page_size * (page_count / 2)) / MB) /
738 ((double)cow_time_ns / NSEC_PER_SEC));
740 /* Create 2000 pairs of duplicate pages */
741 for (size_t i = 0; i < page_count - 1; i = i + 2) {
742 memset(map_ptr + page_size * i, '+', i / 2 + 1);
743 memset(map_ptr + page_size * (i + 1), '+', i / 2 + 1);
745 if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))
748 if (clock_gettime(CLOCK_MONOTONIC_RAW, &start_time)) {
749 perror("clock_gettime");
752 for (size_t i = 0; i < page_count - 1; i = i + 2)
753 memset(map_ptr + page_size * i, '-', 1);
754 if (clock_gettime(CLOCK_MONOTONIC_RAW, &end_time)) {
755 perror("clock_gettime");
759 cow_time_ns = (end_time.tv_sec - start_time.tv_sec) * NSEC_PER_SEC +
760 (end_time.tv_nsec - start_time.tv_nsec);
762 printf("Merged pages:\n");
763 printf("Total time: %ld.%09ld s\n", cow_time_ns / NSEC_PER_SEC,
764 cow_time_ns % NSEC_PER_SEC);
765 printf("Average speed: %.3f MiB/s\n", ((page_size * (page_count / 2)) / MB) /
766 ((double)cow_time_ns / NSEC_PER_SEC));
768 munmap(map_ptr, page_size * page_count);
773 munmap(map_ptr, page_size * page_count);
777 int main(int argc, char *argv[])
781 int ksm_scan_limit_sec = KSM_SCAN_LIMIT_SEC_DEFAULT;
782 int merge_type = KSM_MERGE_TYPE_DEFAULT;
783 long page_count = KSM_PAGE_COUNT_DEFAULT;
784 size_t page_size = sysconf(_SC_PAGESIZE);
785 struct ksm_sysfs ksm_sysfs_old;
786 int test_name = CHECK_KSM_MERGE;
787 bool use_zero_pages = KSM_USE_ZERO_PAGES_DEFAULT;
788 bool merge_across_nodes = KSM_MERGE_ACROSS_NODES_DEFAULT;
791 while ((opt = getopt(argc, argv, "dha:p:l:z:m:s:t:MUZNPCHD")) != -1) {
794 prot = str_to_prot(optarg);
797 page_count = atol(optarg);
798 if (page_count <= 0) {
799 printf("The number of pages must be greater than 0\n");
804 ksm_scan_limit_sec = atoi(optarg);
805 if (ksm_scan_limit_sec <= 0) {
806 printf("Timeout value must be greater than 0\n");
814 if (strcmp(optarg, "0") == 0)
820 if (strcmp(optarg, "0") == 0)
821 merge_across_nodes = 0;
823 merge_across_nodes = 1;
829 size_MB = atoi(optarg);
831 printf("Size must be greater than 0\n");
837 int tmp = atoi(optarg);
839 if (tmp < 0 || tmp > KSM_MERGE_LAST) {
840 printf("Invalid merge type\n");
849 test_name = CHECK_KSM_UNMERGE;
852 test_name = CHECK_KSM_ZERO_PAGE_MERGE;
855 test_name = CHECK_KSM_NUMA_MERGE;
858 test_name = KSM_MERGE_TIME;
861 test_name = KSM_MERGE_TIME_HUGE_PAGES;
864 test_name = KSM_UNMERGE_TIME;
867 test_name = KSM_COW_TIME;
875 prot = str_to_prot(KSM_PROT_STR_DEFAULT);
877 if (access(KSM_SYSFS_PATH, F_OK)) {
878 printf("Config KSM not enabled\n");
882 if (ksm_save_def(&ksm_sysfs_old)) {
883 printf("Cannot save default tunables\n");
887 if (ksm_write_sysfs(KSM_FP("run"), 2) ||
888 ksm_write_sysfs(KSM_FP("sleep_millisecs"), 0) ||
889 numa_available() ? 0 :
890 ksm_write_sysfs(KSM_FP("merge_across_nodes"), 1) ||
891 ksm_write_sysfs(KSM_FP("pages_to_scan"), page_count))
895 case CHECK_KSM_MERGE:
896 ret = check_ksm_merge(merge_type, MAP_PRIVATE | MAP_ANONYMOUS, prot, page_count,
897 ksm_scan_limit_sec, page_size);
899 case CHECK_KSM_UNMERGE:
900 ret = check_ksm_unmerge(merge_type, MAP_PRIVATE | MAP_ANONYMOUS, prot,
901 ksm_scan_limit_sec, page_size);
903 case CHECK_KSM_ZERO_PAGE_MERGE:
904 ret = check_ksm_zero_page_merge(merge_type, MAP_PRIVATE | MAP_ANONYMOUS, prot,
905 page_count, ksm_scan_limit_sec, use_zero_pages,
908 case CHECK_KSM_NUMA_MERGE:
909 ret = check_ksm_numa_merge(merge_type, MAP_PRIVATE | MAP_ANONYMOUS, prot,
910 ksm_scan_limit_sec, merge_across_nodes, page_size);
914 printf("Option '-s' is required.\n");
917 ret = ksm_merge_time(merge_type, MAP_PRIVATE | MAP_ANONYMOUS, prot,
918 ksm_scan_limit_sec, size_MB);
920 case KSM_MERGE_TIME_HUGE_PAGES:
922 printf("Option '-s' is required.\n");
925 ret = ksm_merge_hugepages_time(merge_type, MAP_PRIVATE | MAP_ANONYMOUS, prot,
926 ksm_scan_limit_sec, size_MB);
928 case KSM_UNMERGE_TIME:
930 printf("Option '-s' is required.\n");
933 ret = ksm_unmerge_time(merge_type, MAP_PRIVATE | MAP_ANONYMOUS, prot,
934 ksm_scan_limit_sec, size_MB);
937 ret = ksm_cow_time(merge_type, MAP_PRIVATE | MAP_ANONYMOUS, prot,
938 ksm_scan_limit_sec, page_size);
942 if (ksm_restore(&ksm_sysfs_old)) {
943 printf("Cannot restore default tunables\n");