1 // SPDX-License-Identifier: GPL-2.0
3 * A test of splitting PMD THPs and PTE-mapped THPs from a specified virtual
4 * address range in a process via <debugfs>/split_huge_pages interface.
16 #include <sys/mount.h>
21 #include "../kselftest.h"
24 unsigned int pageshift;
25 uint64_t pmd_pagesize;
27 #define SPLIT_DEBUGFS "/sys/kernel/debug/split_huge_pages"
28 #define SMAP_PATH "/proc/self/smaps"
31 #define PID_FMT "%d,0x%lx,0x%lx,%d"
32 #define PATH_FMT "%s,0x%lx,0x%lx,%d"
34 #define PFN_MASK ((1UL<<55)-1)
35 #define KPF_THP (1UL<<22)
37 int is_backed_by_thp(char *vaddr, int pagemap_file, int kpageflags_file)
43 pread(pagemap_file, &paddr, sizeof(paddr),
44 ((long)vaddr >> pageshift) * sizeof(paddr));
46 if (kpageflags_file) {
47 pread(kpageflags_file, &page_flags, sizeof(page_flags),
48 (paddr & PFN_MASK) * sizeof(page_flags));
50 return !!(page_flags & KPF_THP);
56 static void write_file(const char *path, const char *buf, size_t buflen)
61 fd = open(path, O_WRONLY);
63 ksft_exit_fail_msg("%s open failed: %s\n", path, strerror(errno));
65 numwritten = write(fd, buf, buflen - 1);
68 ksft_exit_fail_msg("Write failed\n");
71 static void write_debugfs(const char *fmt, ...)
73 char input[INPUT_MAX];
78 ret = vsnprintf(input, INPUT_MAX, fmt, argp);
82 ksft_exit_fail_msg("%s: Debugfs input is too long\n", __func__);
84 write_file(SPLIT_DEBUGFS, input, ret + 1);
87 void split_pmd_thp(void)
90 size_t len = 4 * pmd_pagesize;
93 one_page = memalign(pmd_pagesize, len);
95 ksft_exit_fail_msg("Fail to allocate memory: %s\n", strerror(errno));
97 madvise(one_page, len, MADV_HUGEPAGE);
99 for (i = 0; i < len; i++)
100 one_page[i] = (char)i;
102 if (!check_huge_anon(one_page, 4, pmd_pagesize))
103 ksft_exit_fail_msg("No THP is allocated\n");
106 write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
107 (uint64_t)one_page + len, 0);
109 for (i = 0; i < len; i++)
110 if (one_page[i] != (char)i)
111 ksft_exit_fail_msg("%ld byte corrupted\n", i);
114 if (!check_huge_anon(one_page, 0, pmd_pagesize))
115 ksft_exit_fail_msg("Still AnonHugePages not split\n");
117 ksft_test_result_pass("Split huge pages successful\n");
121 void split_pte_mapped_thp(void)
123 char *one_page, *pte_mapped, *pte_mapped2;
124 size_t len = 4 * pmd_pagesize;
127 const char *pagemap_template = "/proc/%d/pagemap";
128 const char *kpageflags_proc = "/proc/kpageflags";
129 char pagemap_proc[255];
133 if (snprintf(pagemap_proc, 255, pagemap_template, getpid()) < 0)
134 ksft_exit_fail_msg("get pagemap proc error: %s\n", strerror(errno));
136 pagemap_fd = open(pagemap_proc, O_RDONLY);
137 if (pagemap_fd == -1)
138 ksft_exit_fail_msg("read pagemap: %s\n", strerror(errno));
140 kpageflags_fd = open(kpageflags_proc, O_RDONLY);
141 if (kpageflags_fd == -1)
142 ksft_exit_fail_msg("read kpageflags: %s\n", strerror(errno));
144 one_page = mmap((void *)(1UL << 30), len, PROT_READ | PROT_WRITE,
145 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
146 if (one_page == MAP_FAILED)
147 ksft_exit_fail_msg("Fail to allocate memory: %s\n", strerror(errno));
149 madvise(one_page, len, MADV_HUGEPAGE);
151 for (i = 0; i < len; i++)
152 one_page[i] = (char)i;
154 if (!check_huge_anon(one_page, 4, pmd_pagesize))
155 ksft_exit_fail_msg("No THP is allocated\n");
157 /* remap the first pagesize of first THP */
158 pte_mapped = mremap(one_page, pagesize, pagesize, MREMAP_MAYMOVE);
160 /* remap the Nth pagesize of Nth THP */
161 for (i = 1; i < 4; i++) {
162 pte_mapped2 = mremap(one_page + pmd_pagesize * i + pagesize * i,
164 MREMAP_MAYMOVE|MREMAP_FIXED,
165 pte_mapped + pagesize * i);
166 if (pte_mapped2 == MAP_FAILED)
167 ksft_exit_fail_msg("mremap failed: %s\n", strerror(errno));
170 /* smap does not show THPs after mremap, use kpageflags instead */
172 for (i = 0; i < pagesize * 4; i++)
173 if (i % pagesize == 0 &&
174 is_backed_by_thp(&pte_mapped[i], pagemap_fd, kpageflags_fd))
178 ksft_exit_fail_msg("Some THPs are missing during mremap\n");
180 /* split all remapped THPs */
181 write_debugfs(PID_FMT, getpid(), (uint64_t)pte_mapped,
182 (uint64_t)pte_mapped + pagesize * 4, 0);
184 /* smap does not show THPs after mremap, use kpageflags instead */
186 for (i = 0; i < pagesize * 4; i++) {
187 if (pte_mapped[i] != (char)i)
188 ksft_exit_fail_msg("%ld byte corrupted\n", i);
190 if (i % pagesize == 0 &&
191 is_backed_by_thp(&pte_mapped[i], pagemap_fd, kpageflags_fd))
196 ksft_exit_fail_msg("Still %ld THPs not split\n", thp_size);
198 ksft_test_result_pass("Split PTE-mapped huge pages successful\n");
199 munmap(one_page, len);
201 close(kpageflags_fd);
204 void split_file_backed_thp(void)
209 char tmpfs_template[] = "/tmp/thp_split_XXXXXX";
210 const char *tmpfs_loc = mkdtemp(tmpfs_template);
211 char testfile[INPUT_MAX];
212 uint64_t pgoff_start = 0, pgoff_end = 1024;
214 ksft_print_msg("Please enable pr_debug in split_huge_pages_in_file() for more info.\n");
216 status = mount("tmpfs", tmpfs_loc, "tmpfs", 0, "huge=always,size=4m");
219 ksft_exit_fail_msg("Unable to create a tmpfs for testing\n");
221 status = snprintf(testfile, INPUT_MAX, "%s/thp_file", tmpfs_loc);
222 if (status >= INPUT_MAX) {
223 ksft_exit_fail_msg("Fail to create file-backed THP split testing file\n");
226 fd = open(testfile, O_CREAT|O_WRONLY, 0664);
228 ksft_perror("Cannot open testing file");
232 /* write something to the file, so a file-backed THP can be allocated */
233 num_written = write(fd, tmpfs_loc, strlen(tmpfs_loc) + 1);
236 if (num_written < 1) {
237 ksft_perror("Fail to write data to testing file");
241 /* split the file-backed THP */
242 write_debugfs(PATH_FMT, testfile, pgoff_start, pgoff_end, 0);
244 status = unlink(testfile);
246 ksft_perror("Cannot remove testing file");
250 status = umount(tmpfs_loc);
253 ksft_exit_fail_msg("Unable to umount %s\n", tmpfs_loc);
256 status = rmdir(tmpfs_loc);
258 ksft_exit_fail_msg("cannot remove tmp dir: %s\n", strerror(errno));
260 ksft_print_msg("Please check dmesg for more information\n");
261 ksft_test_result_pass("File-backed THP split test done\n");
267 ksft_exit_fail_msg("Error occurred\n");
270 bool prepare_thp_fs(const char *xfs_path, char *thp_fs_template,
271 const char **thp_fs_loc)
274 *thp_fs_loc = xfs_path;
278 *thp_fs_loc = mkdtemp(thp_fs_template);
281 ksft_exit_fail_msg("cannot create temp folder\n");
286 void cleanup_thp_fs(const char *thp_fs_loc, bool created_tmp)
293 status = rmdir(thp_fs_loc);
295 ksft_exit_fail_msg("cannot remove tmp dir: %s\n",
299 int create_pagecache_thp_and_fd(const char *testfile, size_t fd_size, int *fd,
303 int __attribute__((unused)) dummy = 0;
307 *fd = open(testfile, O_CREAT | O_RDWR, 0664);
309 ksft_exit_fail_msg("Failed to create a file at %s\n", testfile);
311 for (i = 0; i < fd_size; i++) {
312 unsigned char byte = (unsigned char)i;
314 write(*fd, &byte, sizeof(byte));
318 *fd = open("/proc/sys/vm/drop_caches", O_WRONLY);
320 ksft_perror("open drop_caches");
323 if (write(*fd, "3", 1) != 1) {
324 ksft_perror("write to drop_caches");
329 *fd = open(testfile, O_RDWR);
331 ksft_perror("Failed to open testfile\n");
335 *addr = mmap(NULL, fd_size, PROT_READ|PROT_WRITE, MAP_SHARED, *fd, 0);
336 if (*addr == (char *)-1) {
337 ksft_perror("cannot mmap");
340 madvise(*addr, fd_size, MADV_HUGEPAGE);
342 for (size_t i = 0; i < fd_size; i++)
343 dummy += *(*addr + i);
345 if (!check_huge_file(*addr, fd_size / pmd_pagesize, pmd_pagesize)) {
346 ksft_print_msg("No large pagecache folio generated, please provide a filesystem supporting large folio\n");
347 munmap(*addr, fd_size);
350 ksft_test_result_skip("Pagecache folio split skipped\n");
358 ksft_exit_fail_msg("Failed to create large pagecache folios\n");
362 void split_thp_in_pagecache_to_order(size_t fd_size, int order, const char *fs_loc)
367 char testfile[INPUT_MAX];
370 err = snprintf(testfile, INPUT_MAX, "%s/test", fs_loc);
373 ksft_exit_fail_msg("cannot generate right test file name\n");
375 err = create_pagecache_thp_and_fd(testfile, fd_size, &fd, &addr);
380 write_debugfs(PID_FMT, getpid(), (uint64_t)addr, (uint64_t)addr + fd_size, order);
382 for (i = 0; i < fd_size; i++)
383 if (*(addr + i) != (char)i) {
384 ksft_print_msg("%lu byte corrupted in the file\n", i);
389 if (!check_huge_file(addr, 0, pmd_pagesize)) {
390 ksft_print_msg("Still FilePmdMapped not split\n");
396 munmap(addr, fd_size);
400 ksft_exit_fail_msg("Split PMD-mapped pagecache folio to order %d failed\n", order);
401 ksft_test_result_pass("Split PMD-mapped pagecache folio to order %d passed\n", order);
404 int main(int argc, char **argv)
408 char *optional_xfs_path = NULL;
409 char fs_loc_template[] = "/tmp/thp_fs_XXXXXX";
415 if (geteuid() != 0) {
416 ksft_print_msg("Please run the benchmark as root\n");
421 optional_xfs_path = argv[1];
425 pagesize = getpagesize();
426 pageshift = ffs(pagesize) - 1;
427 pmd_pagesize = read_pmd_pagesize();
429 ksft_exit_fail_msg("Reading PMD pagesize failed\n");
431 fd_size = 2 * pmd_pagesize;
434 split_pte_mapped_thp();
435 split_file_backed_thp();
437 created_tmp = prepare_thp_fs(optional_xfs_path, fs_loc_template,
439 for (i = 8; i >= 0; i--)
440 split_thp_in_pagecache_to_order(fd_size, i, fs_loc);
441 cleanup_thp_fs(fs_loc, created_tmp);