[linux-2.6-block.git] / tools / testing / selftests / x86 / 5lvl.c

#include <stdio.h>
#include <sys/mman.h>

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

#define PAGE_SIZE	4096
#define LOW_ADDR	((void *) (1UL << 30))
#define HIGH_ADDR	((void *) (1UL << 50))

struct testcase {
	void *addr;
	unsigned long size;
	unsigned long flags;
	const char *msg;
	unsigned int low_addr_required:1;
	unsigned int keep_mapped:1;
};

static struct testcase testcases[] = {
	{
		.addr = NULL,
		.size = 2 * PAGE_SIZE,
		.flags = MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(NULL)",
		.low_addr_required = 1,
	},
	{
		.addr = LOW_ADDR,
		.size = 2 * PAGE_SIZE,
		.flags = MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(LOW_ADDR)",
		.low_addr_required = 1,
	},
	{
		.addr = HIGH_ADDR,
		.size = 2 * PAGE_SIZE,
		.flags = MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(HIGH_ADDR)",
		.keep_mapped = 1,
	},
	{
		.addr = HIGH_ADDR,
		.size = 2 * PAGE_SIZE,
		.flags = MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(HIGH_ADDR) again",
		.keep_mapped = 1,
	},
	{
		.addr = HIGH_ADDR,
		.size = 2 * PAGE_SIZE,
		.flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
		.msg = "mmap(HIGH_ADDR, MAP_FIXED)",
	},
	{
		.addr = (void*) -1,
		.size = 2 * PAGE_SIZE,
		.flags = MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(-1)",
		.keep_mapped = 1,
	},
	{
		.addr = (void*) -1,
		.size = 2 * PAGE_SIZE,
		.flags = MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(-1) again",
	},
	{
		.addr = (void *)((1UL << 47) - PAGE_SIZE),
		.size = 2 * PAGE_SIZE,
		.flags = MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap((1UL << 47), 2 * PAGE_SIZE)",
		.low_addr_required = 1,
		.keep_mapped = 1,
	},
	{
		.addr = (void *)((1UL << 47) - PAGE_SIZE / 2),
		.size = 2 * PAGE_SIZE,
		.flags = MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap((1UL << 47), 2 * PAGE_SIZE / 2)",
		.low_addr_required = 1,
		.keep_mapped = 1,
	},
	{
		.addr = (void *)((1UL << 47) - PAGE_SIZE),
		.size = 2 * PAGE_SIZE,
		.flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
		.msg = "mmap((1UL << 47) - PAGE_SIZE, 2 * PAGE_SIZE, MAP_FIXED)",
	},
	{
		.addr = NULL,
		.size = 2UL << 20,
		.flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(NULL, MAP_HUGETLB)",
		.low_addr_required = 1,
	},
	{
		.addr = LOW_ADDR,
		.size = 2UL << 20,
		.flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(LOW_ADDR, MAP_HUGETLB)",
		.low_addr_required = 1,
	},
	{
		.addr = HIGH_ADDR,
		.size = 2UL << 20,
		.flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(HIGH_ADDR, MAP_HUGETLB)",
		.keep_mapped = 1,
	},
	{
		.addr = HIGH_ADDR,
		.size = 2UL << 20,
		.flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(HIGH_ADDR, MAP_HUGETLB) again",
		.keep_mapped = 1,
	},
	{
		.addr = HIGH_ADDR,
		.size = 2UL << 20,
		.flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
		.msg = "mmap(HIGH_ADDR, MAP_FIXED | MAP_HUGETLB)",
	},
	{
		.addr = (void*) -1,
		.size = 2UL << 20,
		.flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(-1, MAP_HUGETLB)",
		.keep_mapped = 1,
	},
	{
		.addr = (void*) -1,
		.size = 2UL << 20,
		.flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap(-1, MAP_HUGETLB) again",
	},
	{
		.addr = (void *)((1UL << 47) - PAGE_SIZE),
		.size = 4UL << 20,
		.flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS,
		.msg = "mmap((1UL << 47), 4UL << 20, MAP_HUGETLB)",
		.low_addr_required = 1,
		.keep_mapped = 1,
	},
	{
		.addr = (void *)((1UL << 47) - (2UL << 20)),
		.size = 4UL << 20,
		.flags = MAP_HUGETLB | MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
		.msg = "mmap((1UL << 47) - (2UL << 20), 4UL << 20, MAP_FIXED | MAP_HUGETLB)",
	},
};

int main(int argc, char **argv)
{
	int i;
	void *p;

	for (i = 0; i < ARRAY_SIZE(testcases); i++) {
		struct testcase *t = testcases + i;

		p = mmap(t->addr, t->size, PROT_NONE, t->flags, -1, 0);

		printf("%s: %p - ", t->msg, p);

		if (p == MAP_FAILED) {
			printf("FAILED\n");
			continue;
		}

		if (t->low_addr_required && p >= (void *)(1UL << 47))
			printf("FAILED\n");
		else
			printf("OK\n");
		if (!t->keep_mapped)
			munmap(p, t->size);
	}
	return 0;
}
Commit	Line	Data
97f404ad KS	1	#include <stdio.h>
	2	#include <sys/mman.h>
	3
	4	#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
	5
	6	#define PAGE_SIZE 4096
	7	#define LOW_ADDR ((void *) (1UL << 30))
	8	#define HIGH_ADDR ((void *) (1UL << 50))
	9
	10	struct testcase {
	11	void *addr;
	12	unsigned long size;
	13	unsigned long flags;
	14	const char *msg;
	15	unsigned int low_addr_required:1;
	16	unsigned int keep_mapped:1;
	17	};
	18
	19	static struct testcase testcases[] = {
	20	{
	21	.addr = NULL,
	22	.size = 2 * PAGE_SIZE,
	23	.flags = MAP_PRIVATE \| MAP_ANONYMOUS,
	24	.msg = "mmap(NULL)",
	25	.low_addr_required = 1,
	26	},
	27	{
	28	.addr = LOW_ADDR,
	29	.size = 2 * PAGE_SIZE,
	30	.flags = MAP_PRIVATE \| MAP_ANONYMOUS,
	31	.msg = "mmap(LOW_ADDR)",
	32	.low_addr_required = 1,
	33	},
	34	{
	35	.addr = HIGH_ADDR,
	36	.size = 2 * PAGE_SIZE,
	37	.flags = MAP_PRIVATE \| MAP_ANONYMOUS,
	38	.msg = "mmap(HIGH_ADDR)",
	39	.keep_mapped = 1,
	40	},
	41	{
	42	.addr = HIGH_ADDR,
	43	.size = 2 * PAGE_SIZE,
	44	.flags = MAP_PRIVATE \| MAP_ANONYMOUS,
	45	.msg = "mmap(HIGH_ADDR) again",
	46	.keep_mapped = 1,
	47	},
	48	{
	49	.addr = HIGH_ADDR,
	50	.size = 2 * PAGE_SIZE,
	51	.flags = MAP_PRIVATE \| MAP_ANONYMOUS \| MAP_FIXED,
	52	.msg = "mmap(HIGH_ADDR, MAP_FIXED)",
	53	},
	54	{
	55	.addr = (void*) -1,
	56	.size = 2 * PAGE_SIZE,
	57	.flags = MAP_PRIVATE \| MAP_ANONYMOUS,
	58	.msg = "mmap(-1)",
	59	.keep_mapped = 1,
	60	},
	61	{
	62	.addr = (void*) -1,
	63	.size = 2 * PAGE_SIZE,
	64	.flags = MAP_PRIVATE \| MAP_ANONYMOUS,
65	.msg = "mmap(-1) again",
66	},
67	{
68	.addr = (void *)((1UL << 47) - PAGE_SIZE),
69	.size = 2 * PAGE_SIZE,
70	.flags = MAP_PRIVATE \| MAP_ANONYMOUS,
71	.msg = "mmap((1UL << 47), 2 * PAGE_SIZE)",
72	.low_addr_required = 1,
73	.keep_mapped = 1,
74	},
75	{
76	.addr = (void *)((1UL << 47) - PAGE_SIZE / 2),
77	.size = 2 * PAGE_SIZE,
78	.flags = MAP_PRIVATE \| MAP_ANONYMOUS,
79	.msg = "mmap((1UL << 47), 2 * PAGE_SIZE / 2)",
80	.low_addr_required = 1,
81	.keep_mapped = 1,
82	},
83	{
84	.addr = (void *)((1UL << 47) - PAGE_SIZE),
85	.size = 2 * PAGE_SIZE,
86	.flags = MAP_PRIVATE \| MAP_ANONYMOUS \| MAP_FIXED,
87	.msg = "mmap((1UL << 47) - PAGE_SIZE, 2 * PAGE_SIZE, MAP_FIXED)",
88	},
89	{
90	.addr = NULL,
91	.size = 2UL << 20,
92	.flags = MAP_HUGETLB \| MAP_PRIVATE \| MAP_ANONYMOUS,
93	.msg = "mmap(NULL, MAP_HUGETLB)",
94	.low_addr_required = 1,
95	},
96	{
97	.addr = LOW_ADDR,
98	.size = 2UL << 20,
99	.flags = MAP_HUGETLB \| MAP_PRIVATE \| MAP_ANONYMOUS,
100	.msg = "mmap(LOW_ADDR, MAP_HUGETLB)",
101	.low_addr_required = 1,
102	},
103	{
104	.addr = HIGH_ADDR,
105	.size = 2UL << 20,
106	.flags = MAP_HUGETLB \| MAP_PRIVATE \| MAP_ANONYMOUS,
107	.msg = "mmap(HIGH_ADDR, MAP_HUGETLB)",
108	.keep_mapped = 1,
109	},
110	{
111	.addr = HIGH_ADDR,
112	.size = 2UL << 20,
113	.flags = MAP_HUGETLB \| MAP_PRIVATE \| MAP_ANONYMOUS,
114	.msg = "mmap(HIGH_ADDR, MAP_HUGETLB) again",
115	.keep_mapped = 1,
116	},
117	{
118	.addr = HIGH_ADDR,
119	.size = 2UL << 20,
120	.flags = MAP_HUGETLB \| MAP_PRIVATE \| MAP_ANONYMOUS \| MAP_FIXED,
121	.msg = "mmap(HIGH_ADDR, MAP_FIXED \| MAP_HUGETLB)",
122	},
123	{
124	.addr = (void*) -1,
125	.size = 2UL << 20,
126	.flags = MAP_HUGETLB \| MAP_PRIVATE \| MAP_ANONYMOUS,
127	.msg = "mmap(-1, MAP_HUGETLB)",
128	.keep_mapped = 1,
129	},
130	{
131	.addr = (void*) -1,
132	.size = 2UL << 20,
133	.flags = MAP_HUGETLB \| MAP_PRIVATE \| MAP_ANONYMOUS,
134	.msg = "mmap(-1, MAP_HUGETLB) again",
135	},
136	{
137	.addr = (void *)((1UL << 47) - PAGE_SIZE),
138	.size = 4UL << 20,
139	.flags = MAP_HUGETLB \| MAP_PRIVATE \| MAP_ANONYMOUS,
140	.msg = "mmap((1UL << 47), 4UL << 20, MAP_HUGETLB)",
141	.low_addr_required = 1,
142	.keep_mapped = 1,
143	},
144	{
145	.addr = (void *)((1UL << 47) - (2UL << 20)),
146	.size = 4UL << 20,
147	.flags = MAP_HUGETLB \| MAP_PRIVATE \| MAP_ANONYMOUS \| MAP_FIXED,
148	.msg = "mmap((1UL << 47) - (2UL << 20), 4UL << 20, MAP_FIXED \| MAP_HUGETLB)",
149	},
150	};
151
152	int main(int argc, char **argv)
153	{
154	int i;
155	void *p;
156
157	for (i = 0; i < ARRAY_SIZE(testcases); i++) {
158	struct testcase *t = testcases + i;
159
160	p = mmap(t->addr, t->size, PROT_NONE, t->flags, -1, 0);
161
162	printf("%s: %p - ", t->msg, p);
163
164	if (p == MAP_FAILED) {
165	printf("FAILED\n");
166	continue;
167	}
168
169	if (t->low_addr_required && p >= (void *)(1UL << 47))
170	printf("FAILED\n");
171	else
172	printf("OK\n");
173	if (!t->keep_mapped)
174	munmap(p, t->size);
175	}
176	return 0;
177	}