[mirror_ubuntu-kernels.git] / tools / testing / selftests / vm / split_huge_page_test.c

// 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 <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 <malloc.h>
#include <stdbool.h>

uint64_t pagesize;
unsigned int pageshift;
uint64_t pmd_pagesize;

#define PMD_SIZE_PATH "/sys/kernel/mm/transparent_hugepage/hpage_pmd_size"
#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"
#define PATH_FMT "%s,0x%lx,0x%lx"

#define PFN_MASK     ((1UL<<55)-1)
#define KPF_THP      (1UL<<22)

int is_backed_by_thp(char *vaddr, int pagemap_file, int kpageflags_file)
{
	uint64_t paddr;
	uint64_t page_flags;

	if (pagemap_file) {
		pread(pagemap_file, &paddr, sizeof(paddr),
			((long)vaddr >> pageshift) * sizeof(paddr));

		if (kpageflags_file) {
			pread(kpageflags_file, &page_flags, sizeof(page_flags),
				(paddr & PFN_MASK) * sizeof(page_flags));

			return !!(page_flags & KPF_THP);
		}
	}
	return 0;
}


static uint64_t read_pmd_pagesize(void)
{
	int fd;
	char buf[20];
	ssize_t num_read;

	fd = open(PMD_SIZE_PATH, O_RDONLY);
	if (fd == -1) {
		perror("Open hpage_pmd_size failed");
		exit(EXIT_FAILURE);
	}
	num_read = read(fd, buf, 19);
	if (num_read < 1) {
		close(fd);
		perror("Read hpage_pmd_size failed");
		exit(EXIT_FAILURE);
	}
	buf[num_read] = '\0';
	close(fd);

	return strtoul(buf, NULL, 10);
}

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(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) {
		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, const 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 * pmd_pagesize;
	uint64_t thp_size;
	size_t i;

	one_page = memalign(pmd_pagesize, len);

	if (!one_page) {
		printf("Fail to allocate memory\n");
		exit(EXIT_FAILURE);
	}

	madvise(one_page, len, MADV_HUGEPAGE);

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

	thp_size = check_huge(one_page);
	if (!thp_size) {
		printf("No THP is allocated\n");
		exit(EXIT_FAILURE);
	}

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

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


	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);
}

void split_pte_mapped_thp(void)
{
	char *one_page, *pte_mapped, *pte_mapped2;
	size_t len = 4 * pmd_pagesize;
	uint64_t thp_size;
	size_t i;
	const char *pagemap_template = "/proc/%d/pagemap";
	const char *kpageflags_proc = "/proc/kpageflags";
	char pagemap_proc[255];
	int pagemap_fd;
	int kpageflags_fd;

	if (snprintf(pagemap_proc, 255, pagemap_template, getpid()) < 0) {
		perror("get pagemap proc error");
		exit(EXIT_FAILURE);
	}
	pagemap_fd = open(pagemap_proc, O_RDONLY);

	if (pagemap_fd == -1) {
		perror("read pagemap:");
		exit(EXIT_FAILURE);
	}

	kpageflags_fd = open(kpageflags_proc, O_RDONLY);

	if (kpageflags_fd == -1) {
		perror("read kpageflags:");
		exit(EXIT_FAILURE);
	}

	one_page = mmap((void *)(1UL << 30), len, PROT_READ | PROT_WRITE,
			MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);

	madvise(one_page, len, MADV_HUGEPAGE);

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

	thp_size = check_huge(one_page);
	if (!thp_size) {
		printf("No THP is allocated\n");
		exit(EXIT_FAILURE);
	}

	/* remap the first pagesize of first THP */
	pte_mapped = mremap(one_page, pagesize, pagesize, MREMAP_MAYMOVE);

	/* remap the Nth pagesize of Nth THP */
	for (i = 1; i < 4; i++) {
		pte_mapped2 = mremap(one_page + pmd_pagesize * i + pagesize * i,
				     pagesize, pagesize,
				     MREMAP_MAYMOVE|MREMAP_FIXED,
				     pte_mapped + pagesize * i);
		if (pte_mapped2 == (char *)-1) {
			perror("mremap failed");
			exit(EXIT_FAILURE);
		}
	}

	/* smap does not show THPs after mremap, use kpageflags instead */
	thp_size = 0;
	for (i = 0; i < pagesize * 4; i++)
		if (i % pagesize == 0 &&
		    is_backed_by_thp(&pte_mapped[i], pagemap_fd, kpageflags_fd))
			thp_size++;

	if (thp_size != 4) {
		printf("Some THPs are missing during mremap\n");
		exit(EXIT_FAILURE);
	}

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

	/* smap does not show THPs after mremap, use kpageflags instead */
	thp_size = 0;
	for (i = 0; i < pagesize * 4; i++) {
		if (pte_mapped[i] != (char)i) {
			printf("%ld byte corrupted\n", i);
			exit(EXIT_FAILURE);
		}
		if (i % pagesize == 0 &&
		    is_backed_by_thp(&pte_mapped[i], pagemap_fd, kpageflags_fd))
			thp_size++;
	}

	if (thp_size) {
		printf("Still %ld THPs not split\n", thp_size);
		exit(EXIT_FAILURE);
	}

	printf("Split PTE-mapped huge pages successful\n");
	munmap(one_page, len);
	close(pagemap_fd);
	close(kpageflags_fd);
}

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

	printf("Please enable pr_debug in split_huge_pages_in_file() if you need more info.\n");

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

	if (status) {
		printf("Unable to create a tmpfs for testing\n");
		exit(EXIT_FAILURE);
	}

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

	fd = open(testfile, O_CREAT|O_WRONLY);
	if (fd == -1) {
		perror("Cannot open testing file\n");
		goto cleanup;
	}

	/* write something to the file, so a file-backed THP can be allocated */
	num_written = write(fd, tmpfs_loc, strlen(tmpfs_loc) + 1);
	close(fd);

	if (num_written < 1) {
		printf("Fail to write data to testing file\n");
		goto cleanup;
	}

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

	status = unlink(testfile);
	if (status)
		perror("Cannot remove testing file\n");

cleanup:
	status = umount(tmpfs_loc);
	if (status) {
		printf("Unable to umount %s\n", tmpfs_loc);
		exit(EXIT_FAILURE);
	}
	status = rmdir(tmpfs_loc);
	if (status) {
		perror("cannot remove tmp dir");
		exit(EXIT_FAILURE);
	}

	printf("file-backed THP split test done, please check dmesg for more information\n");
}

int main(int argc, char **argv)
{
	if (geteuid() != 0) {
		printf("Please run the benchmark as root\n");
		exit(EXIT_FAILURE);
	}

	pagesize = getpagesize();
	pageshift = ffs(pagesize) - 1;
	pmd_pagesize = read_pmd_pagesize();

	split_pmd_thp();
	split_pte_mapped_thp();
	split_file_backed_thp();

	return 0;
}
Commit	Line	Data
fa6c0231 ZY	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>
fbe37501	10	#include <stdarg.h>
fa6c0231 ZY	11	#include <unistd.h>
	12	#include <inttypes.h>
	13	#include <string.h>
	14	#include <fcntl.h>
	15	#include <sys/mman.h>
fbe37501	16	#include <sys/mount.h>
fa6c0231 ZY	17	#include <malloc.h>
	18	#include <stdbool.h>
	19
	20	uint64_t pagesize;
	21	unsigned int pageshift;
	22	uint64_t pmd_pagesize;
	23
	24	#define PMD_SIZE_PATH "/sys/kernel/mm/transparent_hugepage/hpage_pmd_size"
	25	#define SPLIT_DEBUGFS "/sys/kernel/debug/split_huge_pages"
	26	#define SMAP_PATH "/proc/self/smaps"
	27	#define INPUT_MAX 80
	28
fbe37501 ZY	29	#define PID_FMT "%d,0x%lx,0x%lx"
	30	#define PATH_FMT "%s,0x%lx,0x%lx"
	31
fa6c0231 ZY	32	#define PFN_MASK ((1UL<<55)-1)
	33	#define KPF_THP (1UL<<22)
	34
	35	int is_backed_by_thp(char *vaddr, int pagemap_file, int kpageflags_file)
	36	{
	37	uint64_t paddr;
	38	uint64_t page_flags;
	39
	40	if (pagemap_file) {
	41	pread(pagemap_file, &paddr, sizeof(paddr),
	42	((long)vaddr >> pageshift) * sizeof(paddr));
	43
	44	if (kpageflags_file) {
	45	pread(kpageflags_file, &page_flags, sizeof(page_flags),
	46	(paddr & PFN_MASK) * sizeof(page_flags));
	47
	48	return !!(page_flags & KPF_THP);
	49	}
	50	}
	51	return 0;
	52	}
	53
	54
	55	static uint64_t read_pmd_pagesize(void)
	56	{
	57	int fd;
	58	char buf[20];
	59	ssize_t num_read;
	60
	61	fd = open(PMD_SIZE_PATH, O_RDONLY);
	62	if (fd == -1) {
	63	perror("Open hpage_pmd_size failed");
	64	exit(EXIT_FAILURE);
	65	}
	66	num_read = read(fd, buf, 19);
	67	if (num_read < 1) {
	68	close(fd);
	69	perror("Read hpage_pmd_size failed");
	70	exit(EXIT_FAILURE);
	71	}
	72	buf[num_read] = '\0';
	73	close(fd);
	74
	75	return strtoul(buf, NULL, 10);
	76	}
	77
	78	static int write_file(const char path, const char buf, size_t buflen)
	79	{
	80	int fd;
	81	ssize_t numwritten;
	82
	83	fd = open(path, O_WRONLY);
	84	if (fd == -1)
	85	return 0;
	86
	87	numwritten = write(fd, buf, buflen - 1);
	88	close(fd);
	89	if (numwritten < 1)
	90	return 0;
	91
	92	return (unsigned int) numwritten;
	93	}
	94
fbe37501	95	static void write_debugfs(const char *fmt, ...)
fa6c0231 ZY	96	{
	97	char input[INPUT_MAX];
	98	int ret;
fbe37501 ZY	99	va_list argp;
	100
	101	va_start(argp, fmt);
	102	ret = vsnprintf(input, INPUT_MAX, fmt, argp);
	103	va_end(argp);
fa6c0231	104
fa6c0231 ZY	105	if (ret >= INPUT_MAX) {
	106	printf("%s: Debugfs input is too long\n", __func__);
	107	exit(EXIT_FAILURE);
	108	}
	109
	110	if (!write_file(SPLIT_DEBUGFS, input, ret + 1)) {
	111	perror(SPLIT_DEBUGFS);
	112	exit(EXIT_FAILURE);
	113	}
	114	}
	115
	116	#define MAX_LINE_LENGTH 500
	117
	118	static bool check_for_pattern(FILE fp, const char pattern, char *buf)
	119	{
	120	while (fgets(buf, MAX_LINE_LENGTH, fp) != NULL) {
	121	if (!strncmp(buf, pattern, strlen(pattern)))
	122	return true;
	123	}
	124	return false;
	125	}
	126
	127	static uint64_t check_huge(void *addr)
	128	{
	129	uint64_t thp = 0;
	130	int ret;
	131	FILE *fp;
	132	char buffer[MAX_LINE_LENGTH];
	133	char addr_pattern[MAX_LINE_LENGTH];
	134
	135	ret = snprintf(addr_pattern, MAX_LINE_LENGTH, "%08lx-",
	136	(unsigned long) addr);
	137	if (ret >= MAX_LINE_LENGTH) {
	138	printf("%s: Pattern is too long\n", __func__);
	139	exit(EXIT_FAILURE);
	140	}
	141
	142
	143	fp = fopen(SMAP_PATH, "r");
	144	if (!fp) {
	145	printf("%s: Failed to open file %s\n", __func__, SMAP_PATH);
	146	exit(EXIT_FAILURE);
	147	}
	148	if (!check_for_pattern(fp, addr_pattern, buffer))
	149	goto err_out;
	150
	151	/*
	152	* Fetch the AnonHugePages: in the same block and check the number of
	153	* hugepages.
	154	*/
	155	if (!check_for_pattern(fp, "AnonHugePages:", buffer))
	156	goto err_out;
	157
	158	if (sscanf(buffer, "AnonHugePages:%10ld kB", &thp) != 1) {
	159	printf("Reading smap error\n");
	160	exit(EXIT_FAILURE);
	161	}
	162
	163	err_out:
	164	fclose(fp);
	165	return thp;
	166	}
	167
	168	void split_pmd_thp(void)
169	{
170	char *one_page;
171	size_t len = 4 * pmd_pagesize;
172	uint64_t thp_size;
173	size_t i;
174
175	one_page = memalign(pmd_pagesize, len);
176
177	if (!one_page) {
178	printf("Fail to allocate memory\n");
179	exit(EXIT_FAILURE);
180	}
181
182	madvise(one_page, len, MADV_HUGEPAGE);
183
184	for (i = 0; i < len; i++)
185	one_page[i] = (char)i;
186
187	thp_size = check_huge(one_page);
188	if (!thp_size) {
189	printf("No THP is allocated\n");
190	exit(EXIT_FAILURE);
191	}
192
193	/* split all THPs */
fbe37501 ZY	194	write_debugfs(PID_FMT, getpid(), (uint64_t)one_page,
fbe37501 ZY	195	(uint64_t)one_page + len);
fa6c0231 ZY	196
	197	for (i = 0; i < len; i++)
	198	if (one_page[i] != (char)i) {
	199	printf("%ld byte corrupted\n", i);
	200	exit(EXIT_FAILURE);
	201	}
	202
	203
	204	thp_size = check_huge(one_page);
	205	if (thp_size) {
	206	printf("Still %ld kB AnonHugePages not split\n", thp_size);
	207	exit(EXIT_FAILURE);
	208	}
	209
	210	printf("Split huge pages successful\n");
	211	free(one_page);
	212	}
	213
	214	void split_pte_mapped_thp(void)
	215	{
	216	char one_page, pte_mapped, *pte_mapped2;
	217	size_t len = 4 * pmd_pagesize;
	218	uint64_t thp_size;
	219	size_t i;
	220	const char *pagemap_template = "/proc/%d/pagemap";
	221	const char *kpageflags_proc = "/proc/kpageflags";
	222	char pagemap_proc[255];
	223	int pagemap_fd;
	224	int kpageflags_fd;
	225
	226	if (snprintf(pagemap_proc, 255, pagemap_template, getpid()) < 0) {
	227	perror("get pagemap proc error");
	228	exit(EXIT_FAILURE);
	229	}
	230	pagemap_fd = open(pagemap_proc, O_RDONLY);
	231
	232	if (pagemap_fd == -1) {
	233	perror("read pagemap:");
	234	exit(EXIT_FAILURE);
	235	}
	236
	237	kpageflags_fd = open(kpageflags_proc, O_RDONLY);
	238
	239	if (kpageflags_fd == -1) {
	240	perror("read kpageflags:");
	241	exit(EXIT_FAILURE);
	242	}
	243
	244	one_page = mmap((void *)(1UL << 30), len, PROT_READ \| PROT_WRITE,
	245	MAP_ANONYMOUS \| MAP_PRIVATE, -1, 0);
	246
	247	madvise(one_page, len, MADV_HUGEPAGE);
	248
	249	for (i = 0; i < len; i++)
	250	one_page[i] = (char)i;
	251
	252	thp_size = check_huge(one_page);
	253	if (!thp_size) {
	254	printf("No THP is allocated\n");
	255	exit(EXIT_FAILURE);
	256	}
	257
	258	/* remap the first pagesize of first THP */
	259	pte_mapped = mremap(one_page, pagesize, pagesize, MREMAP_MAYMOVE);
260
261	/* remap the Nth pagesize of Nth THP */
262	for (i = 1; i < 4; i++) {
263	pte_mapped2 = mremap(one_page + pmd_pagesize * i + pagesize * i,
264	pagesize, pagesize,
265	MREMAP_MAYMOVE\|MREMAP_FIXED,
266	pte_mapped + pagesize * i);
267	if (pte_mapped2 == (char *)-1) {
268	perror("mremap failed");
269	exit(EXIT_FAILURE);
270	}
271	}
272
273	/* smap does not show THPs after mremap, use kpageflags instead */
274	thp_size = 0;
275	for (i = 0; i < pagesize * 4; i++)
276	if (i % pagesize == 0 &&
277	is_backed_by_thp(&pte_mapped[i], pagemap_fd, kpageflags_fd))
278	thp_size++;
279
280	if (thp_size != 4) {
281	printf("Some THPs are missing during mremap\n");
282	exit(EXIT_FAILURE);
283	}
284
285	/* split all remapped THPs */
fbe37501	286	write_debugfs(PID_FMT, getpid(), (uint64_t)pte_mapped,
fa6c0231 ZY	287	(uint64_t)pte_mapped + pagesize * 4);
	288
	289	/* smap does not show THPs after mremap, use kpageflags instead */
	290	thp_size = 0;
	291	for (i = 0; i < pagesize * 4; i++) {
	292	if (pte_mapped[i] != (char)i) {
	293	printf("%ld byte corrupted\n", i);
	294	exit(EXIT_FAILURE);
	295	}
	296	if (i % pagesize == 0 &&
	297	is_backed_by_thp(&pte_mapped[i], pagemap_fd, kpageflags_fd))
	298	thp_size++;
	299	}
	300
	301	if (thp_size) {
	302	printf("Still %ld THPs not split\n", thp_size);
	303	exit(EXIT_FAILURE);
	304	}
	305
	306	printf("Split PTE-mapped huge pages successful\n");
	307	munmap(one_page, len);
	308	close(pagemap_fd);
	309	close(kpageflags_fd);
	310	}
	311
fbe37501 ZY	312	void split_file_backed_thp(void)
	313	{
	314	int status;
	315	int fd;
	316	ssize_t num_written;
	317	char tmpfs_template[] = "/tmp/thp_split_XXXXXX";
	318	const char *tmpfs_loc = mkdtemp(tmpfs_template);
	319	char testfile[INPUT_MAX];
	320	uint64_t pgoff_start = 0, pgoff_end = 1024;
	321
	322	printf("Please enable pr_debug in split_huge_pages_in_file() if you need more info.\n");
	323
	324	status = mount("tmpfs", tmpfs_loc, "tmpfs", 0, "huge=always,size=4m");
	325
	326	if (status) {
	327	printf("Unable to create a tmpfs for testing\n");
	328	exit(EXIT_FAILURE);
	329	}
	330
	331	status = snprintf(testfile, INPUT_MAX, "%s/thp_file", tmpfs_loc);
	332	if (status >= INPUT_MAX) {
	333	printf("Fail to create file-backed THP split testing file\n");
	334	goto cleanup;
	335	}
	336
	337	fd = open(testfile, O_CREAT\|O_WRONLY);
	338	if (fd == -1) {
	339	perror("Cannot open testing file\n");
	340	goto cleanup;
	341	}
	342
	343	/* write something to the file, so a file-backed THP can be allocated */
9c7516d6	344	num_written = write(fd, tmpfs_loc, strlen(tmpfs_loc) + 1);
fbe37501 ZY	345	close(fd);
	346
	347	if (num_written < 1) {
	348	printf("Fail to write data to testing file\n");
	349	goto cleanup;
	350	}
	351
	352	/* split the file-backed THP */
	353	write_debugfs(PATH_FMT, testfile, pgoff_start, pgoff_end);
	354
	355	status = unlink(testfile);
	356	if (status)
	357	perror("Cannot remove testing file\n");
	358
	359	cleanup:
	360	status = umount(tmpfs_loc);
	361	if (status) {
	362	printf("Unable to umount %s\n", tmpfs_loc);
	363	exit(EXIT_FAILURE);
	364	}
	365	status = rmdir(tmpfs_loc);
	366	if (status) {
	367	perror("cannot remove tmp dir");
	368	exit(EXIT_FAILURE);
	369	}
	370
	371	printf("file-backed THP split test done, please check dmesg for more information\n");
	372	}
	373
fa6c0231 ZY	374	int main(int argc, char **argv)
	375	{
	376	if (geteuid() != 0) {
	377	printf("Please run the benchmark as root\n");
	378	exit(EXIT_FAILURE);
	379	}
	380
	381	pagesize = getpagesize();
	382	pageshift = ffs(pagesize) - 1;
	383	pmd_pagesize = read_pmd_pagesize();
	384
	385	split_pmd_thp();
	386	split_pte_mapped_thp();
fbe37501	387	split_file_backed_thp();
fa6c0231 ZY	388
	389	return 0;
	390	}