// SPDX-License-Identifier: GPL-2.0
/*
 * A test of splitting PMD THPs and PTE-mapped THPs from a specified virtual
 * address range in a process via <debugfs>/split_huge_pages interface.
 */

#define _GNU_SOURCE
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <inttypes.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/mount.h>
#include <sys/param.h>
#include <malloc.h>
#include <stdbool.h>
#include <time.h>
#include "vm_util.h"
#include "kselftest.h"

uint64_t pagesize;
unsigned int pageshift;
uint64_t pmd_pagesize;
unsigned int pmd_order;
int *expected_orders;

#define SPLIT_DEBUGFS "/sys/kernel/debug/split_huge_pages"
#define SMAP_PATH "/proc/self/smaps"
#define INPUT_MAX 80

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

const char *pagemap_proc = "/proc/self/pagemap";
const char *kpageflags_proc = "/proc/kpageflags";
int pagemap_fd;
int kpageflags_fd;

static bool is_backed_by_folio(char *vaddr, int order, int pagemap_fd,
                int kpageflags_fd)
{
        const uint64_t folio_head_flags = KPF_THP | KPF_COMPOUND_HEAD;
        const uint64_t folio_tail_flags = KPF_THP | KPF_COMPOUND_TAIL;
        const unsigned long nr_pages = 1UL << order;
        unsigned long pfn_head;
        uint64_t pfn_flags;
        unsigned long pfn;
        unsigned long i;

        pfn = pagemap_get_pfn(pagemap_fd, vaddr);

        /* non present page */
        if (pfn == -1UL)
                return false;

        if (pageflags_get(pfn, kpageflags_fd, &pfn_flags))
                goto fail;

        /* check for order-0 pages */
        if (!order) {
                if (pfn_flags & (folio_head_flags | folio_tail_flags))
                        return false;
                return true;
        }

        /* non THP folio */
        if (!(pfn_flags & KPF_THP))
                return false;

        pfn_head = pfn & ~(nr_pages - 1);

        if (pageflags_get(pfn_head, kpageflags_fd, &pfn_flags))
                goto fail;

        /* head PFN has no compound_head flag set */
        if ((pfn_flags & folio_head_flags) != folio_head_flags)
                return false;

        /* check all tail PFN flags */
        for (i = 1; i < nr_pages; i++) {
                if (pageflags_get(pfn_head + i, kpageflags_fd, &pfn_flags))
                        goto fail;
                if ((pfn_flags & folio_tail_flags) != folio_tail_flags)
                        return false;
        }

        /*
         * check the PFN after this folio, but if its flags cannot be obtained,
         * assume this folio has the expected order
         */
        if (pageflags_get(pfn_head + nr_pages, kpageflags_fd, &pfn_flags))
                return true;

        /* If we find another tail page, then the folio is larger. */
        return (pfn_flags & folio_tail_flags) != folio_tail_flags;
fail:
        ksft_exit_fail_msg("Failed to get folio info\n");
        return false;
}

static int vaddr_pageflags_get(char *vaddr, int pagemap_fd, int kpageflags_fd,
                uint64_t *flags)
{
        unsigned long pfn;

        pfn = pagemap_get_pfn(pagemap_fd, vaddr);

        /* non-present PFN */
        if (pfn == -1UL)
                return 1;

        if (pageflags_get(pfn, kpageflags_fd, flags))
                return -1;

        return 0;
}

/*
 * gather_after_split_folio_orders - scan through [vaddr_start, len) and record
 * folio orders
 *
 * @vaddr_start: start vaddr
 * @len: range length
 * @pagemap_fd: file descriptor to /proc/<pid>/pagemap
 * @kpageflags_fd: file descriptor to /proc/kpageflags
 * @orders: output folio order array
 * @nr_orders: folio order array size
 *
 * gather_after_split_folio_orders() scan through [vaddr_start, len) and check
 * all folios within the range and record their orders. All order-0 pages will
 * be recorded. Non-present vaddr is skipped.
 *
 * NOTE: the function is used to check folio orders after a split is performed,
 * so it assumes [vaddr_start, len) fully maps to after-split folios within that
 * range.
 *
 * Return: 0 - no error, -1 - unhandled cases
 */
static int gather_after_split_folio_orders(char *vaddr_start, size_t len,
                int pagemap_fd, int kpageflags_fd, int orders[], int nr_orders)
{
        uint64_t page_flags = 0;
        int cur_order = -1;
        char *vaddr;

        if (pagemap_fd == -1 || kpageflags_fd == -1)
                return -1;
        if (!orders)
                return -1;
        if (nr_orders <= 0)
                return -1;

        for (vaddr = vaddr_start; vaddr < vaddr_start + len;) {
                char *next_folio_vaddr;
                int status;

                status = vaddr_pageflags_get(vaddr, pagemap_fd, kpageflags_fd,
                                        &page_flags);
                if (status < 0)
                        return -1;

                /* skip non present vaddr */
                if (status == 1) {
                        vaddr += psize();
                        continue;
                }

                /* all order-0 pages with possible false postive (non folio) */
                if (!(page_flags & (KPF_COMPOUND_HEAD | KPF_COMPOUND_TAIL))) {
                        orders[0]++;
                        vaddr += psize();
                        continue;
                }

                /* skip non thp compound pages */
                if (!(page_flags & KPF_THP)) {
                        vaddr += psize();
                        continue;
                }

                /* vpn points to part of a THP at this point */
                if (page_flags & KPF_COMPOUND_HEAD)
                        cur_order = 1;
                else {
                        vaddr += psize();
                        continue;
                }

                next_folio_vaddr = vaddr + (1UL << (cur_order + pshift()));

                if (next_folio_vaddr >= vaddr_start + len)
                        break;

                while ((status = vaddr_pageflags_get(next_folio_vaddr,
                                                     pagemap_fd, kpageflags_fd,
                                                     &page_flags)) >= 0) {
                        /*
                         * non present vaddr, next compound head page, or
                         * order-0 page
                         */
                        if (status == 1 ||
                            (page_flags & KPF_COMPOUND_HEAD) ||
                            !(page_flags & (KPF_COMPOUND_HEAD | KPF_COMPOUND_TAIL))) {
                                if (cur_order < nr_orders) {
                                        orders[cur_order]++;
                                        cur_order = -1;
                                        vaddr = next_folio_vaddr;
                                }
                                break;
                        }

                        cur_order++;
                        next_folio_vaddr = vaddr + (1UL << (cur_order + pshift()));
                }

                if (status < 0)
                        return status;
        }
        if (cur_order > 0 && cur_order < nr_orders)
                orders[cur_order]++;
        return 0;
}

static int check_after_split_folio_orders(char *vaddr_start, size_t len,
                int pagemap_fd, int kpageflags_fd, int orders[], int nr_orders)
{
        int *vaddr_orders;
        int status;
        int i;

        vaddr_orders = (int *)malloc(sizeof(int) * nr_orders);

        if (!vaddr_orders)
                ksft_exit_fail_msg("Cannot allocate memory for vaddr_orders");

        memset(vaddr_orders, 0, sizeof(int) * nr_orders);
        status = gather_after_split_folio_orders(vaddr_start, len, pagemap_fd,
                                     kpageflags_fd, vaddr_orders, nr_orders);
        if (status)
                ksft_exit_fail_msg("gather folio info failed\n");

        for (i = 0; i < nr_orders; i++)
                if (vaddr_orders[i] != orders[i]) {
                        ksft_print_msg("order %d: expected: %d got %d\n", i,
                                       orders[i], vaddr_orders[i]);
                        status = -1;
                }

        free(vaddr_orders);
        return status;
}

static void write_file(const char *path, const char *buf, size_t buflen)
{
        int fd;
        ssize_t numwritten;

        fd = open(path, O_WRONLY);
        if (fd == -1)
                ksft_exit_fail_msg("%s open failed: %s\n", path, strerror(errno));

        numwritten = write(fd, buf, buflen - 1);
        close(fd);
        if (numwritten < 1)
                ksft_exit_fail_msg("Write failed\n");
}

static void write_debugfs(const char *fmt, ...)
{
        char input[INPUT_MAX];
        int ret;
        va_list argp;

        va_start(argp, fmt);
        ret = vsnprintf(input, INPUT_MAX, fmt, argp);
        va_end(argp);

        if (ret >= INPUT_MAX)
                ksft_exit_fail_msg("%s: Debugfs input is too long\n", __func__);

        write_file(SPLIT_DEBUGFS, input, ret + 1);
}

static char *allocate_zero_filled_hugepage(size_t len)
{
        char *result;
        size_t i;

        result = memalign(pmd_pagesize, len);
        if (!result) {
                printf("Fail to allocate memory\n");
                exit(EXIT_FAILURE);
        }

        madvise(result, len, MADV_HUGEPAGE);

        for (i = 0; i < len; i++)
                result[i] = (char)0;

        return result;
}

static void verify_rss_anon_split_huge_page_all_zeroes(char *one_page, int nr_hpages, size_t len)
{
        unsigned long rss_anon_before, rss_anon_after;
        size_t i;

        if (!check_huge_anon(one_page, nr_hpages, pmd_pagesize))
                ksft_exit_fail_msg("No THP is allocated\n");

        rss_anon_before = rss_anon();
        if (!rss_anon_before)
                ksft_exit_fail_msg("No RssAnon is allocated before split\n");

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

        for (i = 0; i < len; i++)
                if (one_page[i] != (char)0)
                        ksft_exit_fail_msg("%ld byte corrupted\n", i);

        if (!check_huge_anon(one_page, 0, pmd_pagesize))
                ksft_exit_fail_msg("Still AnonHugePages not split\n");

        rss_anon_after = rss_anon();
        if (rss_anon_after >= rss_anon_before)
                ksft_exit_fail_msg("Incorrect RssAnon value. Before: %ld After: %ld\n",
                       rss_anon_before, rss_anon_after);
}

static void split_pmd_zero_pages(void)
{
        char *one_page;
        int nr_hpages = 4;
        size_t len = nr_hpages * pmd_pagesize;

        one_page = allocate_zero_filled_hugepage(len);
        verify_rss_anon_split_huge_page_all_zeroes(one_page, nr_hpages, len);
        ksft_test_result_pass("Split zero filled huge pages successful\n");
        free(one_page);
}

static void split_pmd_thp_to_order(int order)
{
        char *one_page;
        size_t len = 4 * pmd_pagesize;
        size_t i;

        one_page = memalign(pmd_pagesize, len);
        if (!one_page)
                ksft_exit_fail_msg("Fail to allocate memory: %s\n", strerror(errno));

        madvise(one_page, len, MADV_HUGEPAGE);

        for (i = 0; i < len; i++)
                one_page[i] = (char)i;

        if (!check_huge_anon(one_page, 4, pmd_pagesize))
                ksft_exit_fail_msg("No THP is allocated\n");

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

        for (i = 0; i < len; i++)
                if (one_page[i] != (char)i)
                        ksft_exit_fail_msg("%ld byte corrupted\n", i);

        memset(expected_orders, 0, sizeof(int) * (pmd_order + 1));
        expected_orders[order] = 4 << (pmd_order - order);

        if (check_after_split_folio_orders(one_page, len, pagemap_fd,
                                           kpageflags_fd, expected_orders,
                                           (pmd_order + 1)))
                ksft_exit_fail_msg("Unexpected THP split\n");

        if (!check_huge_anon(one_page, 0, pmd_pagesize))
                ksft_exit_fail_msg("Still AnonHugePages not split\n");

        ksft_test_result_pass("Split huge pages to order %d successful\n", order);
        free(one_page);
}

static void split_pte_mapped_thp(void)
{
        const size_t nr_thps = 4;
        const size_t thp_area_size = nr_thps * pmd_pagesize;
        const size_t page_area_size = nr_thps * pagesize;
        char *thp_area, *tmp, *page_area = MAP_FAILED;
        size_t i;

        thp_area = mmap((void *)(1UL << 30), thp_area_size, PROT_READ | PROT_WRITE,
                        MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        if (thp_area == MAP_FAILED) {
                ksft_test_result_fail("Fail to allocate memory: %s\n", strerror(errno));
                return;
        }

        madvise(thp_area, thp_area_size, MADV_HUGEPAGE);

        for (i = 0; i < thp_area_size; i++)
                thp_area[i] = (char)i;

        if (!check_huge_anon(thp_area, nr_thps, pmd_pagesize)) {
                ksft_test_result_skip("Not all THPs allocated\n");
                goto out;
        }

        /*
         * To challenge spitting code, we will mremap a single page of each
         * THP (page[i] of thp[i]) in the thp_area into page_area. This will
         * replace the PMD mappings in the thp_area by PTE mappings first,
         * but leaving the THP unsplit, to then create a page-sized hole in
         * the thp_area.
         * We will then manually trigger splitting of all THPs through the
         * single mremap'ed pages of each THP in the page_area.
         */
        page_area = mmap(NULL, page_area_size, PROT_READ | PROT_WRITE,
                        MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
        if (page_area == MAP_FAILED) {
                ksft_test_result_fail("Fail to allocate memory: %s\n", strerror(errno));
                goto out;
        }

        for (i = 0; i < nr_thps; i++) {
                tmp = mremap(thp_area + pmd_pagesize * i + pagesize * i,
                             pagesize, pagesize, MREMAP_MAYMOVE|MREMAP_FIXED,
                             page_area + pagesize * i);
                if (tmp != MAP_FAILED)
                        continue;
                ksft_test_result_fail("mremap failed: %s\n", strerror(errno));
                goto out;
        }

        /*
         * Verify that our THPs were not split yet. Note that
         * check_huge_anon() cannot be used as it checks for PMD mappings.
         */
        for (i = 0; i < nr_thps; i++) {
                if (is_backed_by_folio(page_area + i * pagesize, pmd_order,
                                       pagemap_fd, kpageflags_fd))
                        continue;
                ksft_test_result_fail("THP %zu missing after mremap\n", i);
                goto out;
        }

        /* Split all THPs through the remapped pages. */
        write_debugfs(PID_FMT, getpid(), (uint64_t)page_area,
                      (uint64_t)page_area + page_area_size, 0);

        /* Corruption during mremap or split? */
        for (i = 0; i < page_area_size; i++) {
                if (page_area[i] == (char)i)
                        continue;
                ksft_test_result_fail("%zu byte corrupted\n", i);
                goto out;
        }

        /* Split failed? */
        for (i = 0; i < nr_thps; i++) {
                if (is_backed_by_folio(page_area + i * pagesize, 0,
                                       pagemap_fd, kpageflags_fd))
                        continue;
                ksft_test_result_fail("THP %zu not split\n", i);
        }

        ksft_test_result_pass("Split PTE-mapped huge pages successful\n");
out:
        munmap(thp_area, thp_area_size);
        if (page_area != MAP_FAILED)
                munmap(page_area, page_area_size);
}

static void split_file_backed_thp(int order)
{
        int status;
        int fd;
        char tmpfs_template[] = "/tmp/thp_split_XXXXXX";
        const char *tmpfs_loc = mkdtemp(tmpfs_template);
        char testfile[INPUT_MAX];
        ssize_t num_written, num_read;
        char *file_buf1, *file_buf2;
        uint64_t pgoff_start = 0, pgoff_end = 1024;
        int i;

        ksft_print_msg("Please enable pr_debug in split_huge_pages_in_file() for more info.\n");

        file_buf1 = (char *)malloc(pmd_pagesize);
        file_buf2 = (char *)malloc(pmd_pagesize);

        if (!file_buf1 || !file_buf2) {
                ksft_print_msg("cannot allocate file buffers\n");
                goto out;
        }

        for (i = 0; i < pmd_pagesize; i++)
                file_buf1[i] = (char)i;
        memset(file_buf2, 0, pmd_pagesize);

        status = mount("tmpfs", tmpfs_loc, "tmpfs", 0, "huge=always,size=4m");

        if (status)
                ksft_exit_fail_msg("Unable to create a tmpfs for testing\n");

        status = snprintf(testfile, INPUT_MAX, "%s/thp_file", tmpfs_loc);
        if (status >= INPUT_MAX) {
                ksft_print_msg("Fail to create file-backed THP split testing file\n");
                goto cleanup;
        }

        fd = open(testfile, O_CREAT|O_RDWR, 0664);
        if (fd == -1) {
                ksft_perror("Cannot open testing file");
                goto cleanup;
        }

        /* write pmd size data to the file, so a file-backed THP can be allocated */
        num_written = write(fd, file_buf1, pmd_pagesize);

        if (num_written == -1 || num_written != pmd_pagesize) {
                ksft_perror("Failed to write data to testing file");
                goto close_file;
        }

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

        /* check file content after split */
        status = lseek(fd, 0, SEEK_SET);
        if (status == -1) {
                ksft_perror("Cannot lseek file");
                goto close_file;
        }

        num_read = read(fd, file_buf2, num_written);
        if (num_read == -1 || num_read != num_written) {
                ksft_perror("Cannot read file content back");
                goto close_file;
        }

        if (strncmp(file_buf1, file_buf2, pmd_pagesize) != 0) {
                ksft_print_msg("File content changed\n");
                goto close_file;
        }

        close(fd);
        status = unlink(testfile);
        if (status) {
                ksft_perror("Cannot remove testing file");
                goto cleanup;
        }

        status = umount(tmpfs_loc);
        if (status) {
                rmdir(tmpfs_loc);
                ksft_exit_fail_msg("Unable to umount %s\n", tmpfs_loc);
        }

        status = rmdir(tmpfs_loc);
        if (status)
                ksft_exit_fail_msg("cannot remove tmp dir: %s\n", strerror(errno));

        ksft_print_msg("Please check dmesg for more information\n");
        ksft_test_result_pass("File-backed THP split to order %d test done\n", order);
        return;

close_file:
        close(fd);
cleanup:
        umount(tmpfs_loc);
        rmdir(tmpfs_loc);
out:
        ksft_exit_fail_msg("Error occurred\n");
}

static bool prepare_thp_fs(const char *xfs_path, char *thp_fs_template,
                const char **thp_fs_loc)
{
        if (xfs_path) {
                *thp_fs_loc = xfs_path;
                return false;
        }

        *thp_fs_loc = mkdtemp(thp_fs_template);

        if (!*thp_fs_loc)
                ksft_exit_fail_msg("cannot create temp folder\n");

        return true;
}

static void cleanup_thp_fs(const char *thp_fs_loc, bool created_tmp)
{
        int status;

        if (!created_tmp)
                return;

        status = rmdir(thp_fs_loc);
        if (status)
                ksft_exit_fail_msg("cannot remove tmp dir: %s\n",
                                   strerror(errno));
}

static int create_pagecache_thp_and_fd(const char *testfile, size_t fd_size,
                int *fd, char **addr)
{
        size_t i;
        unsigned char buf[1024];

        srand(time(NULL));

        *fd = open(testfile, O_CREAT | O_RDWR, 0664);
        if (*fd == -1)
                ksft_exit_fail_msg("Failed to create a file at %s\n", testfile);

        assert(fd_size % sizeof(buf) == 0);
        for (i = 0; i < sizeof(buf); i++)
                buf[i] = (unsigned char)i;
        for (i = 0; i < fd_size; i += sizeof(buf))
                write(*fd, buf, sizeof(buf));

        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 testfile\n");
                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);

        force_read_pages(*addr, fd_size / pmd_pagesize, pmd_pagesize);

        if (!check_huge_file(*addr, fd_size / pmd_pagesize, pmd_pagesize)) {
                ksft_print_msg("No large pagecache folio generated, please provide a filesystem supporting large folio\n");
                munmap(*addr, fd_size);
                close(*fd);
                unlink(testfile);
                ksft_test_result_skip("Pagecache folio split skipped\n");
                return -2;
        }
        return 0;
err_out_close:
        close(*fd);
err_out_unlink:
        unlink(testfile);
        ksft_exit_fail_msg("Failed to create large pagecache folios\n");
        return -1;
}

static void split_thp_in_pagecache_to_order_at(size_t fd_size,
                const char *fs_loc, int order, int offset)
{
        int fd;
        char *split_addr;
        char *addr;
        size_t i;
        char testfile[INPUT_MAX];
        int err = 0;

        err = snprintf(testfile, INPUT_MAX, "%s/test", fs_loc);

        if (err < 0)
                ksft_exit_fail_msg("cannot generate right test file name\n");

        err = create_pagecache_thp_and_fd(testfile, fd_size, &fd, &addr);
        if (err)
                return;

        err = 0;

        memset(expected_orders, 0, sizeof(int) * (pmd_order + 1));
        /*
         * use [split_addr, split_addr + pagesize) range to split THPs, since
         * the debugfs function always split a range with pagesize step and
         * providing a full [addr, addr + fd_size) range can trigger multiple
         * splits, complicating after-split result checking.
         */
        if (offset == -1) {
                for (split_addr = addr; split_addr < addr + fd_size; split_addr += pmd_pagesize)
                        write_debugfs(PID_FMT, getpid(), (uint64_t)split_addr,
                                      (uint64_t)split_addr + pagesize, order);

                expected_orders[order] = fd_size / (pagesize << order);
        } else {
                int times = fd_size / pmd_pagesize;

                for (split_addr = addr; split_addr < addr + fd_size; split_addr += pmd_pagesize)
                        write_debugfs(PID_FMT_OFFSET, getpid(), (uint64_t)split_addr,
                                      (uint64_t)split_addr + pagesize, order, offset);

                for (i = order + 1; i < pmd_order; i++)
                        expected_orders[i] = times;
                expected_orders[order] = 2 * times;
        }

        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_after_split_folio_orders(addr, fd_size, pagemap_fd,
                                           kpageflags_fd, expected_orders,
                                           (pmd_order + 1))) {
                ksft_print_msg("Unexpected THP split\n");
                err = 1;
                goto out;
        }

        if (!check_huge_file(addr, 0, pmd_pagesize)) {
                ksft_print_msg("Still FilePmdMapped not split\n");
                err = EXIT_FAILURE;
                goto out;
        }

out:
        munmap(addr, fd_size);
        close(fd);
        unlink(testfile);
        if (offset == -1) {
                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);
        } else {
                if (err)
                        ksft_exit_fail_msg("Split PMD-mapped pagecache folio to order %d at in-folio offset %d failed\n", order, offset);
                ksft_test_result_pass("Split PMD-mapped pagecache folio to order %d at in-folio offset %d passed\n", order, offset);
        }
}

int main(int argc, char **argv)
{
        int i;
        size_t fd_size;
        char *optional_xfs_path = NULL;
        char fs_loc_template[] = "/tmp/thp_fs_XXXXXX";
        const char *fs_loc;
        bool created_tmp;
        int offset;
        unsigned int nr_pages;
        unsigned int tests;

        ksft_print_header();

        if (geteuid() != 0) {
                ksft_print_msg("Please run the benchmark as root\n");
                ksft_finished();
        }

        if (argc > 1)
                optional_xfs_path = argv[1];

        pagesize = getpagesize();
        pageshift = ffs(pagesize) - 1;
        pmd_pagesize = read_pmd_pagesize();
        if (!pmd_pagesize)
                ksft_exit_fail_msg("Reading PMD pagesize failed\n");

        nr_pages = pmd_pagesize / pagesize;
        pmd_order = sz2ord(pmd_pagesize, pagesize);

        expected_orders = (int *)malloc(sizeof(int) * (pmd_order + 1));
        if (!expected_orders)
                ksft_exit_fail_msg("Fail to allocate memory: %s\n", strerror(errno));

        tests = 2 + (pmd_order - 1) + (2 * pmd_order) + (pmd_order - 1) * 4 + 2;
        ksft_set_plan(tests);

        pagemap_fd = open(pagemap_proc, O_RDONLY);
        if (pagemap_fd == -1)
                ksft_exit_fail_msg("read pagemap: %s\n", strerror(errno));

        kpageflags_fd = open(kpageflags_proc, O_RDONLY);
        if (kpageflags_fd == -1)
                ksft_exit_fail_msg("read kpageflags: %s\n", strerror(errno));

        fd_size = 2 * pmd_pagesize;

        split_pmd_zero_pages();

        for (i = 0; i < pmd_order; i++)
                if (i != 1)
                        split_pmd_thp_to_order(i);

        split_pte_mapped_thp();
        for (i = 0; i < pmd_order; i++)
                split_file_backed_thp(i);

        created_tmp = prepare_thp_fs(optional_xfs_path, fs_loc_template,
                        &fs_loc);
        for (i = pmd_order - 1; i >= 0; i--)
                split_thp_in_pagecache_to_order_at(fd_size, fs_loc, i, -1);

        for (i = 0; i < pmd_order; i++)
                for (offset = 0;
                     offset < nr_pages;
                     offset += MAX(nr_pages / 4, 1 << i))
                        split_thp_in_pagecache_to_order_at(fd_size, fs_loc, i, offset);
        cleanup_thp_fs(fs_loc, created_tmp);

        close(pagemap_fd);
        close(kpageflags_fd);
        free(expected_orders);

        ksft_finished();

        return 0;
}