lkml.org 
[lkml]   [2024]   [Feb]   [26]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v5 8/8] mm: huge_memory: enable debugfs to split huge pages to any order.
    Date
    From: Zi Yan <ziy@nvidia.com>

    It is used to test split_huge_page_to_list_to_order for pagecache THPs.
    Also add test cases for split_huge_page_to_list_to_order via both
    debugfs.

    Signed-off-by: Zi Yan <ziy@nvidia.com>
    ---
    mm/huge_memory.c | 34 ++++--
    .../selftests/mm/split_huge_page_test.c | 115 +++++++++++++++++-
    2 files changed, 131 insertions(+), 18 deletions(-)

    diff --git a/mm/huge_memory.c b/mm/huge_memory.c
    index 8b47a96a28f9..50d146eb248f 100644
    --- a/mm/huge_memory.c
    +++ b/mm/huge_memory.c
    @@ -3422,7 +3422,7 @@ static inline bool vma_not_suitable_for_thp_split(struct vm_area_struct *vma)
    }

    static int split_huge_pages_pid(int pid, unsigned long vaddr_start,
    - unsigned long vaddr_end)
    + unsigned long vaddr_end, unsigned int new_order)
    {
    int ret = 0;
    struct task_struct *task;
    @@ -3486,13 +3486,19 @@ static int split_huge_pages_pid(int pid, unsigned long vaddr_start,
    goto next;

    total++;
    - if (!can_split_folio(folio, NULL))
    + /*
    + * For folios with private, split_huge_page_to_list_to_order()
    + * will try to drop it before split and then check if the folio
    + * can be split or not. So skip the check here.
    + */
    + if (!folio_test_private(folio) &&
    + !can_split_folio(folio, NULL))
    goto next;

    if (!folio_trylock(folio))
    goto next;

    - if (!split_folio(folio))
    + if (!split_folio_to_order(folio, new_order))
    split++;

    folio_unlock(folio);
    @@ -3510,7 +3516,7 @@ static int split_huge_pages_pid(int pid, unsigned long vaddr_start,
    }

    static int split_huge_pages_in_file(const char *file_path, pgoff_t off_start,
    - pgoff_t off_end)
    + pgoff_t off_end, unsigned int new_order)
    {
    struct filename *file;
    struct file *candidate;
    @@ -3549,7 +3555,7 @@ static int split_huge_pages_in_file(const char *file_path, pgoff_t off_start,
    if (!folio_trylock(folio))
    goto next;

    - if (!split_folio(folio))
    + if (!split_folio_to_order(folio, new_order))
    split++;

    folio_unlock(folio);
    @@ -3574,10 +3580,14 @@ static ssize_t split_huge_pages_write(struct file *file, const char __user *buf,
    {
    static DEFINE_MUTEX(split_debug_mutex);
    ssize_t ret;
    - /* hold pid, start_vaddr, end_vaddr or file_path, off_start, off_end */
    + /*
    + * hold pid, start_vaddr, end_vaddr, new_order or
    + * file_path, off_start, off_end, new_order
    + */
    char input_buf[MAX_INPUT_BUF_SZ];
    int pid;
    unsigned long vaddr_start, vaddr_end;
    + unsigned int new_order = 0;

    ret = mutex_lock_interruptible(&split_debug_mutex);
    if (ret)
    @@ -3606,29 +3616,29 @@ static ssize_t split_huge_pages_write(struct file *file, const char __user *buf,
    goto out;
    }

    - ret = sscanf(buf, "0x%lx,0x%lx", &off_start, &off_end);
    - if (ret != 2) {
    + ret = sscanf(buf, "0x%lx,0x%lx,%d", &off_start, &off_end, &new_order);
    + if (ret != 2 && ret != 3) {
    ret = -EINVAL;
    goto out;
    }
    - ret = split_huge_pages_in_file(file_path, off_start, off_end);
    + ret = split_huge_pages_in_file(file_path, off_start, off_end, new_order);
    if (!ret)
    ret = input_len;

    goto out;
    }

    - ret = sscanf(input_buf, "%d,0x%lx,0x%lx", &pid, &vaddr_start, &vaddr_end);
    + ret = sscanf(input_buf, "%d,0x%lx,0x%lx,%d", &pid, &vaddr_start, &vaddr_end, &new_order);
    if (ret == 1 && pid == 1) {
    split_huge_pages_all();
    ret = strlen(input_buf);
    goto out;
    - } else if (ret != 3) {
    + } else if (ret != 3 && ret != 4) {
    ret = -EINVAL;
    goto out;
    }

    - ret = split_huge_pages_pid(pid, vaddr_start, vaddr_end);
    + ret = split_huge_pages_pid(pid, vaddr_start, vaddr_end, new_order);
    if (!ret)
    ret = strlen(input_buf);
    out:
    diff --git a/tools/testing/selftests/mm/split_huge_page_test.c b/tools/testing/selftests/mm/split_huge_page_test.c
    index 7b698a848bab..cf09fdc9ef22 100644
    --- a/tools/testing/selftests/mm/split_huge_page_test.c
    +++ b/tools/testing/selftests/mm/split_huge_page_test.c
    @@ -16,6 +16,7 @@
    #include <sys/mount.h>
    #include <malloc.h>
    #include <stdbool.h>
    +#include <time.h>
    #include "vm_util.h"
    #include "../kselftest.h"

    @@ -24,10 +25,12 @@ unsigned int pageshift;
    uint64_t pmd_pagesize;

    #define SPLIT_DEBUGFS "/sys/kernel/debug/split_huge_pages"
    +#define SMAP_PATH "/proc/self/smaps"
    +#define THP_FS_PATH "/mnt/thp_fs"
    #define INPUT_MAX 80

    -#define PID_FMT "%d,0x%lx,0x%lx"
    -#define PATH_FMT "%s,0x%lx,0x%lx"
    +#define PID_FMT "%d,0x%lx,0x%lx,%d"
    +#define PATH_FMT "%s,0x%lx,0x%lx,%d"

    #define PFN_MASK ((1UL<<55)-1)
    #define KPF_THP (1UL<<22)
    @@ -102,7 +105,7 @@ void split_pmd_thp(void)

    /* split all THPs */
    write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
    - (uint64_t)one_page + len);
    + (uint64_t)one_page + len, 0);

    for (i = 0; i < len; i++)
    if (one_page[i] != (char)i)
    @@ -177,7 +180,7 @@ void split_pte_mapped_thp(void)

    /* split all remapped THPs */
    write_debugfs(PID_FMT, getpid(), (uint64_t)pte_mapped,
    - (uint64_t)pte_mapped + pagesize * 4);
    + (uint64_t)pte_mapped + pagesize * 4, 0);

    /* smap does not show THPs after mremap, use kpageflags instead */
    thp_size = 0;
    @@ -237,7 +240,7 @@ void split_file_backed_thp(void)
    }

    /* split the file-backed THP */
    - write_debugfs(PATH_FMT, testfile, pgoff_start, pgoff_end);
    + write_debugfs(PATH_FMT, testfile, pgoff_start, pgoff_end, 0);

    status = unlink(testfile);
    if (status) {
    @@ -265,8 +268,101 @@ void split_file_backed_thp(void)
    ksft_exit_fail_msg("Error occurred\n");
    }

    +void create_pagecache_thp_and_fd(const char *testfile, size_t fd_size, int *fd, char **addr)
    +{
    + size_t i;
    + int dummy;
    +
    + srand(time(NULL));
    +
    + *fd = open(testfile, O_CREAT | O_RDWR, 0664);
    + if (*fd == -1)
    + ksft_exit_fail_msg("Failed to create a file at "THP_FS_PATH);
    +
    + for (i = 0; i < fd_size; i++) {
    + unsigned char byte = (unsigned char)i;
    +
    + write(*fd, &byte, sizeof(byte));
    + }
    + close(*fd);
    + sync();
    + *fd = open("/proc/sys/vm/drop_caches", O_WRONLY);
    + if (*fd == -1) {
    + ksft_perror("open drop_caches");
    + goto err_out_unlink;
    + }
    + if (write(*fd, "3", 1) != 1) {
    + ksft_perror("write to drop_caches");
    + goto err_out_unlink;
    + }
    + close(*fd);
    +
    + *fd = open(testfile, O_RDWR);
    + if (*fd == -1) {
    + ksft_perror("Failed to open a file at "THP_FS_PATH);
    + goto err_out_unlink;
    + }
    +
    + *addr = mmap(NULL, fd_size, PROT_READ|PROT_WRITE, MAP_SHARED, *fd, 0);
    + if (*addr == (char *)-1) {
    + ksft_perror("cannot mmap");
    + goto err_out_close;
    + }
    + madvise(*addr, fd_size, MADV_HUGEPAGE);
    +
    + for (size_t i = 0; i < fd_size; i++)
    + dummy += *(*addr + i);
    +
    + if (!check_huge_file(*addr, fd_size / pmd_pagesize, pmd_pagesize)) {
    + ksft_print_msg("No large pagecache folio generated, please mount a filesystem supporting large folio at "THP_FS_PATH"\n");
    + goto err_out_close;
    + }
    + return;
    +err_out_close:
    + close(*fd);
    +err_out_unlink:
    + unlink(testfile);
    + ksft_exit_fail_msg("Failed to create large pagecache folios\n");
    +}
    +
    +void split_thp_in_pagecache_to_order(size_t fd_size, int order)
    +{
    + int fd;
    + char *addr;
    + size_t i;
    + const char testfile[] = THP_FS_PATH "/test";
    + int err = 0;
    +
    + create_pagecache_thp_and_fd(testfile, fd_size, &fd, &addr);
    +
    + write_debugfs(PID_FMT, getpid(), (uint64_t)addr, (uint64_t)addr + fd_size, order);
    +
    + for (i = 0; i < fd_size; i++)
    + if (*(addr + i) != (char)i) {
    + ksft_print_msg("%lu byte corrupted in the file\n", i);
    + err = EXIT_FAILURE;
    + goto out;
    + }
    +
    + if (!check_huge_file(addr, 0, pmd_pagesize)) {
    + ksft_print_msg("Still FilePmdMapped not split\n");
    + err = EXIT_FAILURE;
    + goto out;
    + }
    +
    +out:
    + close(fd);
    + unlink(testfile);
    + if (err)
    + ksft_exit_fail_msg("Split PMD-mapped pagecache folio to order %d failed\n", order);
    + ksft_test_result_pass("Split PMD-mapped pagecache folio to order %d passed\n", order);
    +}
    +
    int main(int argc, char **argv)
    {
    + int i;
    + size_t fd_size;
    +
    ksft_print_header();

    if (geteuid() != 0) {
    @@ -274,7 +370,7 @@ int main(int argc, char **argv)
    ksft_finished();
    }

    - ksft_set_plan(3);
    + ksft_set_plan(3+9);

    pagesize = getpagesize();
    pageshift = ffs(pagesize) - 1;
    @@ -282,9 +378,16 @@ int main(int argc, char **argv)
    if (!pmd_pagesize)
    ksft_exit_fail_msg("Reading PMD pagesize failed\n");

    + fd_size = 2 * pmd_pagesize;
    +
    split_pmd_thp();
    split_pte_mapped_thp();
    split_file_backed_thp();

    + for (i = 8; i >= 0; i--)
    + split_thp_in_pagecache_to_order(fd_size, i);
    +
    ksft_finished();
    +
    + return 0;
    }
    --
    2.43.0

    \
     
     \ /
      Last update: 2024-05-27 15:22    [W:4.085 / U:0.184 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site