| Message ID | 20201111204008.21332-2-zi.yan@sent.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | Split huge pages to any lower order pages. | expand |
On 11/11/20 12:40 PM, Zi Yan wrote: > From: Zi Yan <ziy@nvidia.com> > > Huge pages in the process with the given pid and virtual address range > are split. It is used to test split huge page function. In addition, > a testing program is added to tools/testing/selftests/vm to utilize the > interface by splitting PMD THPs. > > Signed-off-by: Zi Yan <ziy@nvidia.com> > --- > mm/huge_memory.c | 98 +++++++++++ > mm/internal.h | 1 + > mm/migrate.c | 2 +- > tools/testing/selftests/vm/Makefile | 1 + > .../selftests/vm/split_huge_page_test.c | 161 ++++++++++++++++++ > 5 files changed, 262 insertions(+), 1 deletion(-) > create mode 100644 tools/testing/selftests/vm/split_huge_page_test.c Don't forget to update ".gitignore" to include "split_huge_page_test".
On 12 Nov 2020, at 17:22, Ralph Campbell wrote: > On 11/11/20 12:40 PM, Zi Yan wrote: >> From: Zi Yan <ziy@nvidia.com> >> >> Huge pages in the process with the given pid and virtual address range >> are split. It is used to test split huge page function. In addition, >> a testing program is added to tools/testing/selftests/vm to utilize the >> interface by splitting PMD THPs. >> >> Signed-off-by: Zi Yan <ziy@nvidia.com> >> --- >> mm/huge_memory.c | 98 +++++++++++ >> mm/internal.h | 1 + >> mm/migrate.c | 2 +- >> tools/testing/selftests/vm/Makefile | 1 + >> .../selftests/vm/split_huge_page_test.c | 161 ++++++++++++++++++ >> 5 files changed, 262 insertions(+), 1 deletion(-) >> create mode 100644 tools/testing/selftests/vm/split_huge_page_test.c > > Don't forget to update ".gitignore" to include "split_huge_page_test". Sure. Thanks for pointing this out. — Best Regards, Yan Zi
On Wed, Nov 11, 2020 at 03:40:03PM -0500, Zi Yan wrote: > From: Zi Yan <ziy@nvidia.com> > > Huge pages in the process with the given pid and virtual address range > are split. It is used to test split huge page function. In addition, > a testing program is added to tools/testing/selftests/vm to utilize the > interface by splitting PMD THPs. > > Signed-off-by: Zi Yan <ziy@nvidia.com> > --- > mm/huge_memory.c | 98 +++++++++++ > mm/internal.h | 1 + > mm/migrate.c | 2 +- > tools/testing/selftests/vm/Makefile | 1 + > .../selftests/vm/split_huge_page_test.c | 161 ++++++++++++++++++ > 5 files changed, 262 insertions(+), 1 deletion(-) > create mode 100644 tools/testing/selftests/vm/split_huge_page_test.c > > diff --git a/mm/huge_memory.c b/mm/huge_memory.c > index 207ebca8c654..c4fead5ead31 100644 > --- a/mm/huge_memory.c > +++ b/mm/huge_memory.c > @@ -7,6 +7,7 @@ > > #include <linux/mm.h> > #include <linux/sched.h> > +#include <linux/sched/mm.h> > #include <linux/sched/coredump.h> > #include <linux/sched/numa_balancing.h> > #include <linux/highmem.h> > @@ -2935,10 +2936,107 @@ static int split_huge_pages_set(void *data, u64 val) > DEFINE_DEBUGFS_ATTRIBUTE(split_huge_pages_fops, NULL, split_huge_pages_set, > "%llu\n"); > > +static ssize_t split_huge_pages_in_range_pid_write(struct file *file, > + const char __user *buf, size_t count, loff_t *ppops) > +{ > + static DEFINE_MUTEX(mutex); > + ssize_t ret; > + char input_buf[80]; /* hold pid, start_vaddr, end_vaddr */ > + int pid; > + unsigned long vaddr_start, vaddr_end, addr; > + nodemask_t task_nodes; > + struct mm_struct *mm; > + > + ret = mutex_lock_interruptible(&mutex); > + if (ret) > + return ret; > + > + ret = -EFAULT; > + > + memset(input_buf, 0, 80); > + if (copy_from_user(input_buf, buf, min_t(size_t, count, 80))) > + goto out; > + > + input_buf[80] = '\0'; Hm. Out-of-buffer access? > + ret = sscanf(input_buf, "%d,%lx,%lx", &pid, &vaddr_start, &vaddr_end); Why hex without 0x prefix? > + if (ret != 3) { > + ret = -EINVAL; > + goto out; > + } > + vaddr_start &= PAGE_MASK; > + vaddr_end &= PAGE_MASK; > + > + ret = strlen(input_buf); > + pr_debug("split huge pages in pid: %d, vaddr: [%lx - %lx]\n", > + pid, vaddr_start, vaddr_end); > + > + mm = find_mm_struct(pid, &task_nodes); I don't follow why you need nodemask. > + if (IS_ERR(mm)) { > + ret = -EINVAL; > + goto out; > + } > + > + mmap_read_lock(mm); > + for (addr = vaddr_start; addr < vaddr_end;) { > + struct vm_area_struct *vma = find_vma(mm, addr); > + unsigned int follflags; > + struct page *page; > + > + if (!vma || addr < vma->vm_start || !vma_migratable(vma)) > + break; > + > + /* FOLL_DUMP to ignore special (like zero) pages */ > + follflags = FOLL_GET | FOLL_DUMP; > + page = follow_page(vma, addr, follflags); > + > + if (IS_ERR(page)) > + break; > + if (!page) > + break; > + > + if (!is_transparent_hugepage(page)) > + goto next; > + > + if (!can_split_huge_page(page, NULL)) > + goto next; > + > + if (!trylock_page(page)) > + goto next; > + > + addr += page_size(page) - PAGE_SIZE; Who said it was mapped as huge? mremap() allows to construct an PTE page table that filled with PTE-mapped THPs, each of them distinct. > + > + /* reset addr if split fails */ > + if (split_huge_page(page)) > + addr -= (page_size(page) - PAGE_SIZE); > + > + unlock_page(page); > +next: > + /* next page */ > + addr += page_size(page); Isn't it the second time if split_huge_page() succeed. > + put_page(page); > + } > + mmap_read_unlock(mm); > + > + > + mmput(mm); > +out: > + mutex_unlock(&mutex); > + return ret; > + > +} > + > +static const struct file_operations split_huge_pages_in_range_pid_fops = { > + .owner = THIS_MODULE, > + .write = split_huge_pages_in_range_pid_write, > + .llseek = no_llseek, > +}; > + > static int __init split_huge_pages_debugfs(void) > { > debugfs_create_file("split_huge_pages", 0200, NULL, NULL, > &split_huge_pages_fops); > + debugfs_create_file("split_huge_pages_in_range_pid", 0200, NULL, NULL, > + &split_huge_pages_in_range_pid_fops); > return 0; > } > late_initcall(split_huge_pages_debugfs); > diff --git a/mm/internal.h b/mm/internal.h > index 3ea43642b99d..fd841a38830f 100644 > --- a/mm/internal.h > +++ b/mm/internal.h > @@ -624,4 +624,5 @@ struct migration_target_control { > > bool truncate_inode_partial_page(struct page *page, loff_t start, loff_t end); > void page_cache_free_page(struct address_space *mapping, struct page *page); > +struct mm_struct *find_mm_struct(pid_t pid, nodemask_t *mem_nodes); > #endif /* __MM_INTERNAL_H */ > diff --git a/mm/migrate.c b/mm/migrate.c > index a50bbb0e029b..e35654d1087d 100644 > --- a/mm/migrate.c > +++ b/mm/migrate.c > @@ -1851,7 +1851,7 @@ static int do_pages_stat(struct mm_struct *mm, unsigned long nr_pages, > return nr_pages ? -EFAULT : 0; > } > > -static struct mm_struct *find_mm_struct(pid_t pid, nodemask_t *mem_nodes) > +struct mm_struct *find_mm_struct(pid_t pid, nodemask_t *mem_nodes) > { > struct task_struct *task; > struct mm_struct *mm; > diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/vm/Makefile > index 62fb15f286ee..d9ead0cdd3e9 100644 > --- a/tools/testing/selftests/vm/Makefile > +++ b/tools/testing/selftests/vm/Makefile > @@ -42,6 +42,7 @@ TEST_GEN_FILES += on-fault-limit > TEST_GEN_FILES += thuge-gen > TEST_GEN_FILES += transhuge-stress > TEST_GEN_FILES += userfaultfd > +TEST_GEN_FILES += split_huge_page_test > > ifeq ($(ARCH),x86_64) > CAN_BUILD_I386 := $(shell ./../x86/check_cc.sh $(CC) ../x86/trivial_32bit_program.c -m32) > diff --git a/tools/testing/selftests/vm/split_huge_page_test.c b/tools/testing/selftests/vm/split_huge_page_test.c > new file mode 100644 > index 000000000000..c8a32ae9e13a > --- /dev/null > +++ b/tools/testing/selftests/vm/split_huge_page_test.c > @@ -0,0 +1,161 @@ > +// SPDX-License-Identifier: GPL-2.0 > + > +#define _GNU_SOURCE > +#include <stdio.h> > +#include <stdlib.h> > +#include "numa.h" > +#include <unistd.h> > +#include <errno.h> > +#include <inttypes.h> > +#include <string.h> > +#include <sys/types.h> > +#include <sys/stat.h> > +#include <fcntl.h> > +#include <sys/mman.h> > +#include <sys/time.h> > +#include <sys/wait.h> > +#include <malloc.h> > +#include <stdbool.h> > + > +#define PAGE_4KB (4096UL) > +#define PAGE_2MB (512UL*PAGE_4KB) > +#define PAGE_1GB (512UL*PAGE_2MB) > + > +#define PRESENT_MASK (1UL<<63) > +#define SWAPPED_MASK (1UL<<62) > +#define PAGE_TYPE_MASK (1UL<<61) > +#define PFN_MASK ((1UL<<55)-1) > + > +#define KPF_THP (1UL<<22) > +#define KPF_PUD_THP (1UL<<27) > + > +#define SPLIT_DEBUGFS "/sys/kernel/debug/split_huge_pages_in_range_pid" > +#define SMAP_PATH "/proc/self/smaps" > +#define INPUT_MAX 80 > + > +static int write_file(const char *path, const char *buf, size_t buflen) > +{ > + int fd; > + ssize_t numwritten; > + > + fd = open(path, O_WRONLY); > + if (fd == -1) > + return 0; > + > + numwritten = write(fd, buf, buflen - 1); > + close(fd); > + if (numwritten < 1) > + return 0; > + > + return (unsigned int) numwritten; > +} > + > +static void write_debugfs(int pid, uint64_t vaddr_start, uint64_t vaddr_end) > +{ > + char input[INPUT_MAX]; > + int ret; > + > + ret = snprintf(input, INPUT_MAX, "%d,%lx,%lx", pid, vaddr_start, > + vaddr_end); > + if (ret >= INPUT_MAX) { > + printf("%s: Debugfs input is too long\n", __func__); > + exit(EXIT_FAILURE); > + } > + > + if (!write_file(SPLIT_DEBUGFS, input, ret + 1)) { > + perror(SPLIT_DEBUGFS); > + exit(EXIT_FAILURE); > + } > +} > + > +#define MAX_LINE_LENGTH 500 > + > +static bool check_for_pattern(FILE *fp, char *pattern, char *buf) > +{ > + while (fgets(buf, MAX_LINE_LENGTH, fp) != NULL) { > + if (!strncmp(buf, pattern, strlen(pattern))) > + return true; > + } > + return false; > +} > + > +static uint64_t check_huge(void *addr) > +{ > + uint64_t thp = 0; > + int ret; > + FILE *fp; > + char buffer[MAX_LINE_LENGTH]; > + char addr_pattern[MAX_LINE_LENGTH]; > + > + ret = snprintf(addr_pattern, MAX_LINE_LENGTH, "%08lx-", > + (unsigned long) addr); > + if (ret >= MAX_LINE_LENGTH) { > + printf("%s: Pattern is too long\n", __func__); > + exit(EXIT_FAILURE); > + } > + > + > + fp = fopen(SMAP_PATH, "r"); > + if (!fp) { > + printf("%s: Failed to open file %s\n", __func__, SMAP_PATH); > + exit(EXIT_FAILURE); > + } > + if (!check_for_pattern(fp, addr_pattern, buffer)) > + goto err_out; > + > + /* > + * Fetch the AnonHugePages: in the same block and check the number of > + * hugepages. > + */ > + if (!check_for_pattern(fp, "AnonHugePages:", buffer)) > + goto err_out; > + > + if (sscanf(buffer, "AnonHugePages:%10ld kB", &thp) != 1) { > + printf("Reading smap error\n"); > + exit(EXIT_FAILURE); > + } > + > +err_out: > + fclose(fp); > + return thp; > +} > + > +void split_pmd_thp(void) > +{ > + char *one_page; > + size_t len = 4 * PAGE_2MB; > + uint64_t thp_size; > + > + one_page = memalign(PAGE_1GB, len); > + > + madvise(one_page, len, MADV_HUGEPAGE); > + > + memset(one_page, 1, len); > + > + thp_size = check_huge(one_page); > + if (!thp_size) { > + printf("No THP is allocatd"); > + exit(EXIT_FAILURE); > + } > + > + /* split all possible huge pages */ > + write_debugfs(getpid(), (uint64_t)one_page, (uint64_t)one_page + len); > + > + *one_page = 0; > + > + thp_size = check_huge(one_page); > + if (thp_size) { > + printf("Still %ld kB AnonHugePages not split\n", thp_size); > + exit(EXIT_FAILURE); > + } > + > + printf("Split huge pages successful\n"); > + free(one_page); > +} > + > +int main(int argc, char **argv) > +{ > + split_pmd_thp(); > + > + return 0; > +} > -- > 2.28.0 > >
On 16 Nov 2020, at 11:06, Kirill A. Shutemov wrote: > On Wed, Nov 11, 2020 at 03:40:03PM -0500, Zi Yan wrote: >> From: Zi Yan <ziy@nvidia.com> >> >> Huge pages in the process with the given pid and virtual address range >> are split. It is used to test split huge page function. In addition, >> a testing program is added to tools/testing/selftests/vm to utilize the >> interface by splitting PMD THPs. >> >> Signed-off-by: Zi Yan <ziy@nvidia.com> >> --- >> mm/huge_memory.c | 98 +++++++++++ >> mm/internal.h | 1 + >> mm/migrate.c | 2 +- >> tools/testing/selftests/vm/Makefile | 1 + >> .../selftests/vm/split_huge_page_test.c | 161 ++++++++++++++++++ >> 5 files changed, 262 insertions(+), 1 deletion(-) >> create mode 100644 tools/testing/selftests/vm/split_huge_page_test.c >> >> diff --git a/mm/huge_memory.c b/mm/huge_memory.c >> index 207ebca8c654..c4fead5ead31 100644 >> --- a/mm/huge_memory.c >> +++ b/mm/huge_memory.c >> @@ -7,6 +7,7 @@ >> >> #include <linux/mm.h> >> #include <linux/sched.h> >> +#include <linux/sched/mm.h> >> #include <linux/sched/coredump.h> >> #include <linux/sched/numa_balancing.h> >> #include <linux/highmem.h> >> @@ -2935,10 +2936,107 @@ static int split_huge_pages_set(void *data, u64 val) >> DEFINE_DEBUGFS_ATTRIBUTE(split_huge_pages_fops, NULL, split_huge_pages_set, >> "%llu\n"); >> >> +static ssize_t split_huge_pages_in_range_pid_write(struct file *file, >> + const char __user *buf, size_t count, loff_t *ppops) >> +{ >> + static DEFINE_MUTEX(mutex); >> + ssize_t ret; >> + char input_buf[80]; /* hold pid, start_vaddr, end_vaddr */ >> + int pid; >> + unsigned long vaddr_start, vaddr_end, addr; >> + nodemask_t task_nodes; >> + struct mm_struct *mm; >> + >> + ret = mutex_lock_interruptible(&mutex); >> + if (ret) >> + return ret; >> + >> + ret = -EFAULT; >> + >> + memset(input_buf, 0, 80); >> + if (copy_from_user(input_buf, buf, min_t(size_t, count, 80))) >> + goto out; >> + >> + input_buf[80] = '\0'; > > Hm. Out-of-buffer access? Sorry. Will fix it. > >> + ret = sscanf(input_buf, "%d,%lx,%lx", &pid, &vaddr_start, &vaddr_end); > > Why hex without 0x prefix? No particular reason. Let me add the prefix. > >> + if (ret != 3) { >> + ret = -EINVAL; >> + goto out; >> + } >> + vaddr_start &= PAGE_MASK; >> + vaddr_end &= PAGE_MASK; >> + >> + ret = strlen(input_buf); >> + pr_debug("split huge pages in pid: %d, vaddr: [%lx - %lx]\n", >> + pid, vaddr_start, vaddr_end); >> + >> + mm = find_mm_struct(pid, &task_nodes); > > I don't follow why you need nodemask. I don’t need it. I just reuse the find_mm_struct function from mm/migrate.c. > >> + if (IS_ERR(mm)) { >> + ret = -EINVAL; >> + goto out; >> + } >> + >> + mmap_read_lock(mm); >> + for (addr = vaddr_start; addr < vaddr_end;) { >> + struct vm_area_struct *vma = find_vma(mm, addr); >> + unsigned int follflags; >> + struct page *page; >> + >> + if (!vma || addr < vma->vm_start || !vma_migratable(vma)) >> + break; >> + >> + /* FOLL_DUMP to ignore special (like zero) pages */ >> + follflags = FOLL_GET | FOLL_DUMP; >> + page = follow_page(vma, addr, follflags); >> + >> + if (IS_ERR(page)) >> + break; >> + if (!page) >> + break; >> + >> + if (!is_transparent_hugepage(page)) >> + goto next; >> + >> + if (!can_split_huge_page(page, NULL)) >> + goto next; >> + >> + if (!trylock_page(page)) >> + goto next; >> + >> + addr += page_size(page) - PAGE_SIZE; > > Who said it was mapped as huge? mremap() allows to construct an PTE page > table that filled with PTE-mapped THPs, each of them distinct. I forgot about this. I was trying to be smart to skip the rest of subpages if we split a THP. I will increase addr always by PAGE_SIZE to handle this situation. >> + >> + /* reset addr if split fails */ >> + if (split_huge_page(page)) >> + addr -= (page_size(page) - PAGE_SIZE); >> + >> + unlock_page(page); >> +next: >> + /* next page */ >> + addr += page_size(page); > > Isn't it the second time if split_huge_page() succeed. If split_huge_page() succeeds, page_size(page) would be PAGE_SIZE and addr was increased by THP size - PAGE_SIZE above, so addr now should be at the end of the original THP. Anyway, I will change the code to something like: /* * always increase addr by PAGE_SIZE, since we could have a PTE page * table filled with PTE-mapped THPs, each of which is distinct. */ for (addr = vaddr_start; addr < vaddr_end; addr += PAGE_SIZE) { ... if (!trylock_page(page)) continue; split_huge_page(page); unlock_page(page); put_page(page); } mmap_read_unlock(mm); Thanks for reviewing the patch. — Best Regards, Yan Zi
diff --git a/mm/huge_memory.c b/mm/huge_memory.c index 207ebca8c654..c4fead5ead31 100644 --- a/mm/huge_memory.c +++ b/mm/huge_memory.c @@ -7,6 +7,7 @@ #include <linux/mm.h> #include <linux/sched.h> +#include <linux/sched/mm.h> #include <linux/sched/coredump.h> #include <linux/sched/numa_balancing.h> #include <linux/highmem.h> @@ -2935,10 +2936,107 @@ static int split_huge_pages_set(void *data, u64 val) DEFINE_DEBUGFS_ATTRIBUTE(split_huge_pages_fops, NULL, split_huge_pages_set, "%llu\n"); +static ssize_t split_huge_pages_in_range_pid_write(struct file *file, + const char __user *buf, size_t count, loff_t *ppops) +{ + static DEFINE_MUTEX(mutex); + ssize_t ret; + char input_buf[80]; /* hold pid, start_vaddr, end_vaddr */ + int pid; + unsigned long vaddr_start, vaddr_end, addr; + nodemask_t task_nodes; + struct mm_struct *mm; + + ret = mutex_lock_interruptible(&mutex); + if (ret) + return ret; + + ret = -EFAULT; + + memset(input_buf, 0, 80); + if (copy_from_user(input_buf, buf, min_t(size_t, count, 80))) + goto out; + + input_buf[80] = '\0'; + ret = sscanf(input_buf, "%d,%lx,%lx", &pid, &vaddr_start, &vaddr_end); + if (ret != 3) { + ret = -EINVAL; + goto out; + } + vaddr_start &= PAGE_MASK; + vaddr_end &= PAGE_MASK; + + ret = strlen(input_buf); + pr_debug("split huge pages in pid: %d, vaddr: [%lx - %lx]\n", + pid, vaddr_start, vaddr_end); + + mm = find_mm_struct(pid, &task_nodes); + if (IS_ERR(mm)) { + ret = -EINVAL; + goto out; + } + + mmap_read_lock(mm); + for (addr = vaddr_start; addr < vaddr_end;) { + struct vm_area_struct *vma = find_vma(mm, addr); + unsigned int follflags; + struct page *page; + + if (!vma || addr < vma->vm_start || !vma_migratable(vma)) + break; + + /* FOLL_DUMP to ignore special (like zero) pages */ + follflags = FOLL_GET | FOLL_DUMP; + page = follow_page(vma, addr, follflags); + + if (IS_ERR(page)) + break; + if (!page) + break; + + if (!is_transparent_hugepage(page)) + goto next; + + if (!can_split_huge_page(page, NULL)) + goto next; + + if (!trylock_page(page)) + goto next; + + addr += page_size(page) - PAGE_SIZE; + + /* reset addr if split fails */ + if (split_huge_page(page)) + addr -= (page_size(page) - PAGE_SIZE); + + unlock_page(page); +next: + /* next page */ + addr += page_size(page); + put_page(page); + } + mmap_read_unlock(mm); + + + mmput(mm); +out: + mutex_unlock(&mutex); + return ret; + +} + +static const struct file_operations split_huge_pages_in_range_pid_fops = { + .owner = THIS_MODULE, + .write = split_huge_pages_in_range_pid_write, + .llseek = no_llseek, +}; + static int __init split_huge_pages_debugfs(void) { debugfs_create_file("split_huge_pages", 0200, NULL, NULL, &split_huge_pages_fops); + debugfs_create_file("split_huge_pages_in_range_pid", 0200, NULL, NULL, + &split_huge_pages_in_range_pid_fops); return 0; } late_initcall(split_huge_pages_debugfs); diff --git a/mm/internal.h b/mm/internal.h index 3ea43642b99d..fd841a38830f 100644 --- a/mm/internal.h +++ b/mm/internal.h @@ -624,4 +624,5 @@ struct migration_target_control { bool truncate_inode_partial_page(struct page *page, loff_t start, loff_t end); void page_cache_free_page(struct address_space *mapping, struct page *page); +struct mm_struct *find_mm_struct(pid_t pid, nodemask_t *mem_nodes); #endif /* __MM_INTERNAL_H */ diff --git a/mm/migrate.c b/mm/migrate.c index a50bbb0e029b..e35654d1087d 100644 --- a/mm/migrate.c +++ b/mm/migrate.c @@ -1851,7 +1851,7 @@ static int do_pages_stat(struct mm_struct *mm, unsigned long nr_pages, return nr_pages ? -EFAULT : 0; } -static struct mm_struct *find_mm_struct(pid_t pid, nodemask_t *mem_nodes) +struct mm_struct *find_mm_struct(pid_t pid, nodemask_t *mem_nodes) { struct task_struct *task; struct mm_struct *mm; diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/vm/Makefile index 62fb15f286ee..d9ead0cdd3e9 100644 --- a/tools/testing/selftests/vm/Makefile +++ b/tools/testing/selftests/vm/Makefile @@ -42,6 +42,7 @@ TEST_GEN_FILES += on-fault-limit TEST_GEN_FILES += thuge-gen TEST_GEN_FILES += transhuge-stress TEST_GEN_FILES += userfaultfd +TEST_GEN_FILES += split_huge_page_test ifeq ($(ARCH),x86_64) CAN_BUILD_I386 := $(shell ./../x86/check_cc.sh $(CC) ../x86/trivial_32bit_program.c -m32) diff --git a/tools/testing/selftests/vm/split_huge_page_test.c b/tools/testing/selftests/vm/split_huge_page_test.c new file mode 100644 index 000000000000..c8a32ae9e13a --- /dev/null +++ b/tools/testing/selftests/vm/split_huge_page_test.c @@ -0,0 +1,161 @@ +// SPDX-License-Identifier: GPL-2.0 + +#define _GNU_SOURCE +#include <stdio.h> +#include <stdlib.h> +#include "numa.h" +#include <unistd.h> +#include <errno.h> +#include <inttypes.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <sys/mman.h> +#include <sys/time.h> +#include <sys/wait.h> +#include <malloc.h> +#include <stdbool.h> + +#define PAGE_4KB (4096UL) +#define PAGE_2MB (512UL*PAGE_4KB) +#define PAGE_1GB (512UL*PAGE_2MB) + +#define PRESENT_MASK (1UL<<63) +#define SWAPPED_MASK (1UL<<62) +#define PAGE_TYPE_MASK (1UL<<61) +#define PFN_MASK ((1UL<<55)-1) + +#define KPF_THP (1UL<<22) +#define KPF_PUD_THP (1UL<<27) + +#define SPLIT_DEBUGFS "/sys/kernel/debug/split_huge_pages_in_range_pid" +#define SMAP_PATH "/proc/self/smaps" +#define INPUT_MAX 80 + +static int write_file(const char *path, const char *buf, size_t buflen) +{ + int fd; + ssize_t numwritten; + + fd = open(path, O_WRONLY); + if (fd == -1) + return 0; + + numwritten = write(fd, buf, buflen - 1); + close(fd); + if (numwritten < 1) + return 0; + + return (unsigned int) numwritten; +} + +static void write_debugfs(int pid, uint64_t vaddr_start, uint64_t vaddr_end) +{ + char input[INPUT_MAX]; + int ret; + + ret = snprintf(input, INPUT_MAX, "%d,%lx,%lx", pid, vaddr_start, + vaddr_end); + if (ret >= INPUT_MAX) { + printf("%s: Debugfs input is too long\n", __func__); + exit(EXIT_FAILURE); + } + + if (!write_file(SPLIT_DEBUGFS, input, ret + 1)) { + perror(SPLIT_DEBUGFS); + exit(EXIT_FAILURE); + } +} + +#define MAX_LINE_LENGTH 500 + +static bool check_for_pattern(FILE *fp, char *pattern, char *buf) +{ + while (fgets(buf, MAX_LINE_LENGTH, fp) != NULL) { + if (!strncmp(buf, pattern, strlen(pattern))) + return true; + } + return false; +} + +static uint64_t check_huge(void *addr) +{ + uint64_t thp = 0; + int ret; + FILE *fp; + char buffer[MAX_LINE_LENGTH]; + char addr_pattern[MAX_LINE_LENGTH]; + + ret = snprintf(addr_pattern, MAX_LINE_LENGTH, "%08lx-", + (unsigned long) addr); + if (ret >= MAX_LINE_LENGTH) { + printf("%s: Pattern is too long\n", __func__); + exit(EXIT_FAILURE); + } + + + fp = fopen(SMAP_PATH, "r"); + if (!fp) { + printf("%s: Failed to open file %s\n", __func__, SMAP_PATH); + exit(EXIT_FAILURE); + } + if (!check_for_pattern(fp, addr_pattern, buffer)) + goto err_out; + + /* + * Fetch the AnonHugePages: in the same block and check the number of + * hugepages. + */ + if (!check_for_pattern(fp, "AnonHugePages:", buffer)) + goto err_out; + + if (sscanf(buffer, "AnonHugePages:%10ld kB", &thp) != 1) { + printf("Reading smap error\n"); + exit(EXIT_FAILURE); + } + +err_out: + fclose(fp); + return thp; +} + +void split_pmd_thp(void) +{ + char *one_page; + size_t len = 4 * PAGE_2MB; + uint64_t thp_size; + + one_page = memalign(PAGE_1GB, len); + + madvise(one_page, len, MADV_HUGEPAGE); + + memset(one_page, 1, len); + + thp_size = check_huge(one_page); + if (!thp_size) { + printf("No THP is allocatd"); + exit(EXIT_FAILURE); + } + + /* split all possible huge pages */ + write_debugfs(getpid(), (uint64_t)one_page, (uint64_t)one_page + len); + + *one_page = 0; + + thp_size = check_huge(one_page); + if (thp_size) { + printf("Still %ld kB AnonHugePages not split\n", thp_size); + exit(EXIT_FAILURE); + } + + printf("Split huge pages successful\n"); + free(one_page); +} + +int main(int argc, char **argv) +{ + split_pmd_thp(); + + return 0; +}