1 // SPDX-License-Identifier: GPL-2.0 2 /* 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. 5 */ 6 7 #define _GNU_SOURCE 8 #include <stdio.h> 9 #include <stdlib.h> 10 #include <stdarg.h> 11 #include <unistd.h> 12 #include <inttypes.h> 13 #include <string.h> 14 #include <fcntl.h> 15 #include <sys/mman.h> 16 #include <sys/mount.h> 17 #include <malloc.h> 18 #include <stdbool.h> 19 #include <time.h> 20 #include "vm_util.h" 21 #include "../kselftest.h" 22 23 uint64_t pagesize; 24 unsigned int pageshift; 25 uint64_t pmd_pagesize; 26 27 #define SPLIT_DEBUGFS "/sys/kernel/debug/split_huge_pages" 28 #define SMAP_PATH "/proc/self/smaps" 29 #define INPUT_MAX 80 30 31 #define PID_FMT "%d,0x%lx,0x%lx,%d" 32 #define PATH_FMT "%s,0x%lx,0x%lx,%d" 33 34 #define PFN_MASK ((1UL<<55)-1) 35 #define KPF_THP (1UL<<22) 36 37 int is_backed_by_thp(char *vaddr, int pagemap_file, int kpageflags_file) 38 { 39 uint64_t paddr; 40 uint64_t page_flags; 41 42 if (pagemap_file) { 43 pread(pagemap_file, &paddr, sizeof(paddr), 44 ((long)vaddr >> pageshift) * sizeof(paddr)); 45 46 if (kpageflags_file) { 47 pread(kpageflags_file, &page_flags, sizeof(page_flags), 48 (paddr & PFN_MASK) * sizeof(page_flags)); 49 50 return !!(page_flags & KPF_THP); 51 } 52 } 53 return 0; 54 } 55 56 static void write_file(const char *path, const char *buf, size_t buflen) 57 { 58 int fd; 59 ssize_t numwritten; 60 61 fd = open(path, O_WRONLY); 62 if (fd == -1) 63 ksft_exit_fail_msg("%s open failed: %s\n", path, strerror(errno)); 64 65 numwritten = write(fd, buf, buflen - 1); 66 close(fd); 67 if (numwritten < 1) 68 ksft_exit_fail_msg("Write failed\n"); 69 } 70 71 static void write_debugfs(const char *fmt, ...) 72 { 73 char input[INPUT_MAX]; 74 int ret; 75 va_list argp; 76 77 va_start(argp, fmt); 78 ret = vsnprintf(input, INPUT_MAX, fmt, argp); 79 va_end(argp); 80 81 if (ret >= INPUT_MAX) 82 ksft_exit_fail_msg("%s: Debugfs input is too long\n", __func__); 83 84 write_file(SPLIT_DEBUGFS, input, ret + 1); 85 } 86 87 void split_pmd_thp(void) 88 { 89 char *one_page; 90 size_t len = 4 * pmd_pagesize; 91 size_t i; 92 93 one_page = memalign(pmd_pagesize, len); 94 if (!one_page) 95 ksft_exit_fail_msg("Fail to allocate memory: %s\n", strerror(errno)); 96 97 madvise(one_page, len, MADV_HUGEPAGE); 98 99 for (i = 0; i < len; i++) 100 one_page[i] = (char)i; 101 102 if (!check_huge_anon(one_page, 4, pmd_pagesize)) 103 ksft_exit_fail_msg("No THP is allocated\n"); 104 105 /* split all THPs */ 106 write_debugfs(PID_FMT, getpid(), (uint64_t)one_page, 107 (uint64_t)one_page + len, 0); 108 109 for (i = 0; i < len; i++) 110 if (one_page[i] != (char)i) 111 ksft_exit_fail_msg("%ld byte corrupted\n", i); 112 113 114 if (!check_huge_anon(one_page, 0, pmd_pagesize)) 115 ksft_exit_fail_msg("Still AnonHugePages not split\n"); 116 117 ksft_test_result_pass("Split huge pages successful\n"); 118 free(one_page); 119 } 120 121 void split_pte_mapped_thp(void) 122 { 123 char *one_page, *pte_mapped, *pte_mapped2; 124 size_t len = 4 * pmd_pagesize; 125 uint64_t thp_size; 126 size_t i; 127 const char *pagemap_template = "/proc/%d/pagemap"; 128 const char *kpageflags_proc = "/proc/kpageflags"; 129 char pagemap_proc[255]; 130 int pagemap_fd; 131 int kpageflags_fd; 132 133 if (snprintf(pagemap_proc, 255, pagemap_template, getpid()) < 0) 134 ksft_exit_fail_msg("get pagemap proc error: %s\n", strerror(errno)); 135 136 pagemap_fd = open(pagemap_proc, O_RDONLY); 137 if (pagemap_fd == -1) 138 ksft_exit_fail_msg("read pagemap: %s\n", strerror(errno)); 139 140 kpageflags_fd = open(kpageflags_proc, O_RDONLY); 141 if (kpageflags_fd == -1) 142 ksft_exit_fail_msg("read kpageflags: %s\n", strerror(errno)); 143 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)); 148 149 madvise(one_page, len, MADV_HUGEPAGE); 150 151 for (i = 0; i < len; i++) 152 one_page[i] = (char)i; 153 154 if (!check_huge_anon(one_page, 4, pmd_pagesize)) 155 ksft_exit_fail_msg("No THP is allocated\n"); 156 157 /* remap the first pagesize of first THP */ 158 pte_mapped = mremap(one_page, pagesize, pagesize, MREMAP_MAYMOVE); 159 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, 163 pagesize, pagesize, 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)); 168 } 169 170 /* smap does not show THPs after mremap, use kpageflags instead */ 171 thp_size = 0; 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)) 175 thp_size++; 176 177 if (thp_size != 4) 178 ksft_exit_fail_msg("Some THPs are missing during mremap\n"); 179 180 /* split all remapped THPs */ 181 write_debugfs(PID_FMT, getpid(), (uint64_t)pte_mapped, 182 (uint64_t)pte_mapped + pagesize * 4, 0); 183 184 /* smap does not show THPs after mremap, use kpageflags instead */ 185 thp_size = 0; 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); 189 190 if (i % pagesize == 0 && 191 is_backed_by_thp(&pte_mapped[i], pagemap_fd, kpageflags_fd)) 192 thp_size++; 193 } 194 195 if (thp_size) 196 ksft_exit_fail_msg("Still %ld THPs not split\n", thp_size); 197 198 ksft_test_result_pass("Split PTE-mapped huge pages successful\n"); 199 munmap(one_page, len); 200 close(pagemap_fd); 201 close(kpageflags_fd); 202 } 203 204 void split_file_backed_thp(void) 205 { 206 int status; 207 int fd; 208 ssize_t num_written; 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; 213 214 ksft_print_msg("Please enable pr_debug in split_huge_pages_in_file() for more info.\n"); 215 216 status = mount("tmpfs", tmpfs_loc, "tmpfs", 0, "huge=always,size=4m"); 217 218 if (status) 219 ksft_exit_fail_msg("Unable to create a tmpfs for testing\n"); 220 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"); 224 } 225 226 fd = open(testfile, O_CREAT|O_WRONLY, 0664); 227 if (fd == -1) { 228 ksft_perror("Cannot open testing file"); 229 goto cleanup; 230 } 231 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); 234 close(fd); 235 236 if (num_written < 1) { 237 ksft_perror("Fail to write data to testing file"); 238 goto cleanup; 239 } 240 241 /* split the file-backed THP */ 242 write_debugfs(PATH_FMT, testfile, pgoff_start, pgoff_end, 0); 243 244 status = unlink(testfile); 245 if (status) { 246 ksft_perror("Cannot remove testing file"); 247 goto cleanup; 248 } 249 250 status = umount(tmpfs_loc); 251 if (status) { 252 rmdir(tmpfs_loc); 253 ksft_exit_fail_msg("Unable to umount %s\n", tmpfs_loc); 254 } 255 256 status = rmdir(tmpfs_loc); 257 if (status) 258 ksft_exit_fail_msg("cannot remove tmp dir: %s\n", strerror(errno)); 259 260 ksft_print_msg("Please check dmesg for more information\n"); 261 ksft_test_result_pass("File-backed THP split test done\n"); 262 return; 263 264 cleanup: 265 umount(tmpfs_loc); 266 rmdir(tmpfs_loc); 267 ksft_exit_fail_msg("Error occurred\n"); 268 } 269 270 bool prepare_thp_fs(const char *xfs_path, char *thp_fs_template, 271 const char **thp_fs_loc) 272 { 273 if (xfs_path) { 274 *thp_fs_loc = xfs_path; 275 return false; 276 } 277 278 *thp_fs_loc = mkdtemp(thp_fs_template); 279 280 if (!*thp_fs_loc) 281 ksft_exit_fail_msg("cannot create temp folder\n"); 282 283 return true; 284 } 285 286 void cleanup_thp_fs(const char *thp_fs_loc, bool created_tmp) 287 { 288 int status; 289 290 if (!created_tmp) 291 return; 292 293 status = rmdir(thp_fs_loc); 294 if (status) 295 ksft_exit_fail_msg("cannot remove tmp dir: %s\n", 296 strerror(errno)); 297 } 298 299 int create_pagecache_thp_and_fd(const char *testfile, size_t fd_size, int *fd, 300 char **addr) 301 { 302 size_t i; 303 int dummy = 0; 304 305 srand(time(NULL)); 306 307 *fd = open(testfile, O_CREAT | O_RDWR, 0664); 308 if (*fd == -1) 309 ksft_exit_fail_msg("Failed to create a file at %s\n", testfile); 310 311 for (i = 0; i < fd_size; i++) { 312 unsigned char byte = (unsigned char)i; 313 314 write(*fd, &byte, sizeof(byte)); 315 } 316 close(*fd); 317 sync(); 318 *fd = open("/proc/sys/vm/drop_caches", O_WRONLY); 319 if (*fd == -1) { 320 ksft_perror("open drop_caches"); 321 goto err_out_unlink; 322 } 323 if (write(*fd, "3", 1) != 1) { 324 ksft_perror("write to drop_caches"); 325 goto err_out_unlink; 326 } 327 close(*fd); 328 329 *fd = open(testfile, O_RDWR); 330 if (*fd == -1) { 331 ksft_perror("Failed to open testfile\n"); 332 goto err_out_unlink; 333 } 334 335 *addr = mmap(NULL, fd_size, PROT_READ|PROT_WRITE, MAP_SHARED, *fd, 0); 336 if (*addr == (char *)-1) { 337 ksft_perror("cannot mmap"); 338 goto err_out_close; 339 } 340 madvise(*addr, fd_size, MADV_HUGEPAGE); 341 342 for (size_t i = 0; i < fd_size; i++) 343 dummy += *(*addr + i); 344 asm volatile("" : "+r" (dummy)); 345 346 if (!check_huge_file(*addr, fd_size / pmd_pagesize, pmd_pagesize)) { 347 ksft_print_msg("No large pagecache folio generated, please provide a filesystem supporting large folio\n"); 348 munmap(*addr, fd_size); 349 close(*fd); 350 unlink(testfile); 351 ksft_test_result_skip("Pagecache folio split skipped\n"); 352 return -2; 353 } 354 return 0; 355 err_out_close: 356 close(*fd); 357 err_out_unlink: 358 unlink(testfile); 359 ksft_exit_fail_msg("Failed to create large pagecache folios\n"); 360 return -1; 361 } 362 363 void split_thp_in_pagecache_to_order(size_t fd_size, int order, const char *fs_loc) 364 { 365 int fd; 366 char *addr; 367 size_t i; 368 char testfile[INPUT_MAX]; 369 int err = 0; 370 371 err = snprintf(testfile, INPUT_MAX, "%s/test", fs_loc); 372 373 if (err < 0) 374 ksft_exit_fail_msg("cannot generate right test file name\n"); 375 376 err = create_pagecache_thp_and_fd(testfile, fd_size, &fd, &addr); 377 if (err) 378 return; 379 err = 0; 380 381 write_debugfs(PID_FMT, getpid(), (uint64_t)addr, (uint64_t)addr + fd_size, order); 382 383 for (i = 0; i < fd_size; i++) 384 if (*(addr + i) != (char)i) { 385 ksft_print_msg("%lu byte corrupted in the file\n", i); 386 err = EXIT_FAILURE; 387 goto out; 388 } 389 390 if (!check_huge_file(addr, 0, pmd_pagesize)) { 391 ksft_print_msg("Still FilePmdMapped not split\n"); 392 err = EXIT_FAILURE; 393 goto out; 394 } 395 396 out: 397 munmap(addr, fd_size); 398 close(fd); 399 unlink(testfile); 400 if (err) 401 ksft_exit_fail_msg("Split PMD-mapped pagecache folio to order %d failed\n", order); 402 ksft_test_result_pass("Split PMD-mapped pagecache folio to order %d passed\n", order); 403 } 404 405 int main(int argc, char **argv) 406 { 407 int i; 408 size_t fd_size; 409 char *optional_xfs_path = NULL; 410 char fs_loc_template[] = "/tmp/thp_fs_XXXXXX"; 411 const char *fs_loc; 412 bool created_tmp; 413 414 ksft_print_header(); 415 416 if (geteuid() != 0) { 417 ksft_print_msg("Please run the benchmark as root\n"); 418 ksft_finished(); 419 } 420 421 if (argc > 1) 422 optional_xfs_path = argv[1]; 423 424 ksft_set_plan(3+9); 425 426 pagesize = getpagesize(); 427 pageshift = ffs(pagesize) - 1; 428 pmd_pagesize = read_pmd_pagesize(); 429 if (!pmd_pagesize) 430 ksft_exit_fail_msg("Reading PMD pagesize failed\n"); 431 432 fd_size = 2 * pmd_pagesize; 433 434 split_pmd_thp(); 435 split_pte_mapped_thp(); 436 split_file_backed_thp(); 437 438 created_tmp = prepare_thp_fs(optional_xfs_path, fs_loc_template, 439 &fs_loc); 440 for (i = 8; i >= 0; i--) 441 split_thp_in_pagecache_to_order(fd_size, i, fs_loc); 442 cleanup_thp_fs(fs_loc, created_tmp); 443 444 ksft_finished(); 445 446 return 0; 447 } 448