[qemu.git] / tests / test-mmap.c

/*
 * Small test program to verify simulated mmap behaviour.
 *
 * When running qemu-linux-user with the -p flag, you may need to tell
 * this test program about the pagesize because getpagesize() will not reflect
 * the -p choice. Simply pass one argument beeing the pagesize.
 *
 * Copyright (c) 2007 AXIS Communications AB
 * Written by Edgar E. Iglesias.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
 *  MA 02110-1301, USA.
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>

#include <sys/mman.h>

#define D(x)

#define fail_unless(x)                                         \
do                                                             \
{                                                              \
  if (!(x)) {                                                  \
    fprintf (stderr, "FAILED at %s:%d\n", __FILE__, __LINE__); \
    exit (EXIT_FAILURE);                                       \
  }                                                            \
} while (0);

unsigned char *dummybuf;
static unsigned int pagesize;
static unsigned int pagemask;
int test_fd;
size_t test_fsize;

void check_aligned_anonymous_unfixed_mmaps(void)
{
	void *p1;
	void *p2;
	void *p3;
	void *p4;
	void *p5;
	uintptr_t p;
	int i;

	fprintf (stderr, "%s", __func__);
	for (i = 0; i < 0x1fff; i++)
	{
		size_t len;

		len = pagesize + (pagesize * i & 7);
		p1 = mmap(NULL, len, PROT_READ, 
			  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
		p2 = mmap(NULL, len, PROT_READ, 
			  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
		p3 = mmap(NULL, len, PROT_READ, 
			  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
		p4 = mmap(NULL, len, PROT_READ, 
			  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
		p5 = mmap(NULL, len, PROT_READ, 
			  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

		/* Make sure we get pages aligned with the pagesize. The
		   target expects this.  */
		fail_unless (p1 != MAP_FAILED);
		fail_unless (p2 != MAP_FAILED);
		fail_unless (p3 != MAP_FAILED);
		fail_unless (p4 != MAP_FAILED);
		fail_unless (p5 != MAP_FAILED);
		p = (uintptr_t) p1;
		D(printf ("p=%x\n", p));
		fail_unless ((p & pagemask) == 0);
		p = (uintptr_t) p2;
		fail_unless ((p & pagemask) == 0);
		p = (uintptr_t) p3;
		fail_unless ((p & pagemask) == 0);
		p = (uintptr_t) p4;
		fail_unless ((p & pagemask) == 0);
		p = (uintptr_t) p5;
		fail_unless ((p & pagemask) == 0);

		/* Make sure we can read from the entire area.  */
		memcpy (dummybuf, p1, pagesize);
		memcpy (dummybuf, p2, pagesize);
		memcpy (dummybuf, p3, pagesize);
		memcpy (dummybuf, p4, pagesize);
		memcpy (dummybuf, p5, pagesize);

		munmap (p1, len);
		munmap (p2, len);
		munmap (p3, len);
		munmap (p4, len);
		munmap (p5, len);
	}
	fprintf (stderr, " passed\n");
}

void check_large_anonymous_unfixed_mmap(void)
{
	void *p1;
	uintptr_t p;
	size_t len;

	fprintf (stderr, "%s", __func__);

	len = 0x02000000;
	p1 = mmap(NULL, len, PROT_READ, 
		  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

	/* Make sure we get pages aligned with the pagesize. The
	   target expects this.  */
	fail_unless (p1 != MAP_FAILED);
	p = (uintptr_t) p1;
	fail_unless ((p & pagemask) == 0);
	
	/* Make sure we can read from the entire area.  */
	memcpy (dummybuf, p1, pagesize);
	munmap (p1, len);
	fprintf (stderr, " passed\n");
}

void check_aligned_anonymous_unfixed_colliding_mmaps(void)
{
	char *p1;
	char *p2;
	char *p3;
	uintptr_t p;
	int i;

	fprintf (stderr, "%s", __func__);
	for (i = 0; i < 0x2fff; i++)
	{
		int nlen;
		p1 = mmap(NULL, pagesize, PROT_READ, 
			  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
		fail_unless (p1 != MAP_FAILED);
		p = (uintptr_t) p1;
		fail_unless ((p & pagemask) == 0);
		memcpy (dummybuf, p1, pagesize);

		p2 = mmap(NULL, pagesize, PROT_READ, 
			  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
		fail_unless (p2 != MAP_FAILED);
		p = (uintptr_t) p2;
		fail_unless ((p & pagemask) == 0);
		memcpy (dummybuf, p2, pagesize);


		munmap (p1, pagesize);
		nlen = pagesize * 8;
		p3 = mmap(NULL, nlen, PROT_READ, 
			  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

		/* Check if the mmaped areas collide.  */
		if (p3 < p2 
		    && (p3 + nlen) > p2)
			fail_unless (0);

		memcpy (dummybuf, p3, pagesize);

		/* Make sure we get pages aligned with the pagesize. The
		   target expects this.  */
		fail_unless (p3 != MAP_FAILED);
		p = (uintptr_t) p3;
		fail_unless ((p & pagemask) == 0);
		munmap (p2, pagesize);
		munmap (p3, nlen);
	}
	fprintf (stderr, " passed\n");
}

void check_aligned_anonymous_fixed_mmaps(void)
{
	char *addr;
	void *p1;
	uintptr_t p;
	int i;

	/* Find a suitable address to start with.  */
	addr = mmap(NULL, pagesize * 40, PROT_READ | PROT_WRITE, 
		    MAP_PRIVATE | MAP_ANONYMOUS,
		    -1, 0);
	fprintf (stderr, "%s addr=%p", __func__, addr);
	fail_unless (addr != MAP_FAILED);

	for (i = 0; i < 40; i++)
	{
		/* Create submaps within our unfixed map.  */
		p1 = mmap(addr, pagesize, PROT_READ, 
			  MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
			  -1, 0);
		/* Make sure we get pages aligned with the pagesize. 
		   The target expects this.  */
		p = (uintptr_t) p1;
		fail_unless (p1 == addr);
		fail_unless ((p & pagemask) == 0);		
		memcpy (dummybuf, p1, pagesize);
		munmap (p1, pagesize);
		addr += pagesize;
	}
	fprintf (stderr, " passed\n");
}

void check_aligned_anonymous_fixed_mmaps_collide_with_host(void)
{
	char *addr;
	void *p1;
	uintptr_t p;
	int i;

	/* Find a suitable address to start with.  Right were the x86 hosts
	 stack is.  */
	addr = ((void *)0x80000000);
	fprintf (stderr, "%s addr=%p", __func__, addr);
	fprintf (stderr, "FIXME: QEMU fails to track pages used by the host.");

	for (i = 0; i < 20; i++)
	{
		/* Create submaps within our unfixed map.  */
		p1 = mmap(addr, pagesize, PROT_READ | PROT_WRITE, 
			  MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
			  -1, 0);
		/* Make sure we get pages aligned with the pagesize. 
		   The target expects this.  */
		p = (uintptr_t) p1;
		fail_unless (p1 == addr);
		fail_unless ((p & pagemask) == 0);		
		memcpy (p1, dummybuf, pagesize);
		munmap (p1, pagesize);
		addr += pagesize;
	}
	fprintf (stderr, " passed\n");
}

void check_file_unfixed_mmaps(void)
{
	unsigned int *p1, *p2, *p3;
	uintptr_t p;
	int i;

	fprintf (stderr, "%s", __func__);
	for (i = 0; i < 0x10; i++)
	{
		size_t len;

		len = pagesize;
		p1 = mmap(NULL, len, PROT_READ, 
			  MAP_PRIVATE, 
			  test_fd, 0);
		p2 = mmap(NULL, len, PROT_READ, 
			  MAP_PRIVATE, 
			  test_fd, pagesize);
		p3 = mmap(NULL, len, PROT_READ, 
			  MAP_PRIVATE, 
			  test_fd, pagesize * 2);

		fail_unless (p1 != MAP_FAILED);
		fail_unless (p2 != MAP_FAILED);
		fail_unless (p3 != MAP_FAILED);

		/* Make sure we get pages aligned with the pagesize. The
		   target expects this.  */
		p = (uintptr_t) p1;
		fail_unless ((p & pagemask) == 0);
		p = (uintptr_t) p2;
		fail_unless ((p & pagemask) == 0);
		p = (uintptr_t) p3;
		fail_unless ((p & pagemask) == 0);

		/* Verify that the file maps was made correctly.  */
		D(printf ("p1=%d p2=%d p3=%d\n", *p1, *p2, *p3));
		fail_unless (*p1 == 0);
		fail_unless (*p2 == (pagesize / sizeof *p2));
		fail_unless (*p3 == ((pagesize * 2) / sizeof *p3));

		memcpy (dummybuf, p1, pagesize);
		memcpy (dummybuf, p2, pagesize);
		memcpy (dummybuf, p3, pagesize);
		munmap (p1, len);
		munmap (p2, len);
		munmap (p3, len);
	}
	fprintf (stderr, " passed\n");
}

void check_file_unfixed_eof_mmaps(void)
{
	char *cp;
	unsigned int *p1;
	uintptr_t p;
	int i;

	fprintf (stderr, "%s", __func__);
	for (i = 0; i < 0x10; i++)
	{
		p1 = mmap(NULL, pagesize, PROT_READ, 
			  MAP_PRIVATE, 
			  test_fd, 
			  (test_fsize - sizeof *p1) & ~pagemask);

		fail_unless (p1 != MAP_FAILED);

		/* Make sure we get pages aligned with the pagesize. The
		   target expects this.  */
		p = (uintptr_t) p1;
		fail_unless ((p & pagemask) == 0);
		/* Verify that the file maps was made correctly.  */
		fail_unless (p1[(test_fsize & pagemask) / sizeof *p1 - 1]
			     == ((test_fsize - sizeof *p1) / sizeof *p1));

		/* Verify that the end of page is accessable and zeroed.  */
		cp = (void *) p1;
		fail_unless (cp[pagesize - 4] == 0);
		munmap (p1, pagesize);
	}
	fprintf (stderr, " passed\n");
}

void check_file_fixed_eof_mmaps(void)
{
	char *addr;
	char *cp;
	unsigned int *p1;
	uintptr_t p;
	int i;

	/* Find a suitable address to start with.  */
	addr = mmap(NULL, pagesize * 44, PROT_READ, 
		    MAP_PRIVATE | MAP_ANONYMOUS,
		    -1, 0);

	fprintf (stderr, "%s addr=%p", __func__, (void *)addr);
	fail_unless (addr != MAP_FAILED);

	for (i = 0; i < 0x10; i++)
	{
		/* Create submaps within our unfixed map.  */
		p1 = mmap(addr, pagesize, PROT_READ, 
			  MAP_PRIVATE | MAP_FIXED, 
			  test_fd, 
			  (test_fsize - sizeof *p1) & ~pagemask);

		fail_unless (p1 != MAP_FAILED);

		/* Make sure we get pages aligned with the pagesize. The
		   target expects this.  */
		p = (uintptr_t) p1;
		fail_unless ((p & pagemask) == 0);

		/* Verify that the file maps was made correctly.  */
		fail_unless (p1[(test_fsize & pagemask) / sizeof *p1 - 1]
			     == ((test_fsize - sizeof *p1) / sizeof *p1));

		/* Verify that the end of page is accessable and zeroed.  */
		cp = (void *)p1;
		fail_unless (cp[pagesize - 4] == 0);
		munmap (p1, pagesize);
		addr += pagesize;
	}
	fprintf (stderr, " passed\n");
}

void check_file_fixed_mmaps(void)
{
	unsigned char *addr;
	unsigned int *p1, *p2, *p3, *p4;
	int i;

	/* Find a suitable address to start with.  */
	addr = mmap(NULL, pagesize * 40 * 4, PROT_READ, 
		    MAP_PRIVATE | MAP_ANONYMOUS,
		    -1, 0);
	fprintf (stderr, "%s addr=%p", __func__, (void *)addr);
	fail_unless (addr != MAP_FAILED);

	for (i = 0; i < 40; i++)
	{
		p1 = mmap(addr, pagesize, PROT_READ, 
			  MAP_PRIVATE | MAP_FIXED,
			  test_fd, 0);
		p2 = mmap(addr + pagesize, pagesize, PROT_READ, 
			  MAP_PRIVATE | MAP_FIXED,
			  test_fd, pagesize);
		p3 = mmap(addr + pagesize * 2, pagesize, PROT_READ, 
			  MAP_PRIVATE | MAP_FIXED,
			  test_fd, pagesize * 2);
		p4 = mmap(addr + pagesize * 3, pagesize, PROT_READ, 
			  MAP_PRIVATE | MAP_FIXED,
			  test_fd, pagesize * 3);

		/* Make sure we get pages aligned with the pagesize. 
		   The target expects this.  */
		fail_unless (p1 == (void *)addr);
		fail_unless (p2 == (void *)addr + pagesize);
		fail_unless (p3 == (void *)addr + pagesize * 2);
		fail_unless (p4 == (void *)addr + pagesize * 3);

		/* Verify that the file maps was made correctly.  */
		fail_unless (*p1 == 0);
		fail_unless (*p2 == (pagesize / sizeof *p2));
		fail_unless (*p3 == ((pagesize * 2) / sizeof *p3));
		fail_unless (*p4 == ((pagesize * 3) / sizeof *p4));

		memcpy (dummybuf, p1, pagesize);
		memcpy (dummybuf, p2, pagesize);
		memcpy (dummybuf, p3, pagesize);
		memcpy (dummybuf, p4, pagesize);

		munmap (p1, pagesize);
		munmap (p2, pagesize);
		munmap (p3, pagesize);
		munmap (p4, pagesize);
		addr += pagesize * 4;
	}
	fprintf (stderr, " passed\n");
}

int main(int argc, char **argv)
{
	char tempname[] = "/tmp/.cmmapXXXXXX";
	unsigned int i;

	/* Trust the first argument, otherwise probe the system for our
	   pagesize.  */
	if (argc > 1)
		pagesize = strtoul(argv[1], NULL, 0);
	else
		pagesize = sysconf(_SC_PAGESIZE);

	/* Assume pagesize is a power of two.  */
	pagemask = pagesize - 1;
	dummybuf = malloc (pagesize);
	printf ("pagesize=%u pagemask=%x\n", pagesize, pagemask);

	test_fd = mkstemp(tempname);
	unlink(tempname);

	/* Fill the file with int's counting from zero and up.  */
	for (i = 0; i < (pagesize * 4) / sizeof i; i++)
		write (test_fd, &i, sizeof i);
	/* Append a few extra writes to make the file end at non 
	   page boundary.  */
	write (test_fd, &i, sizeof i); i++;
	write (test_fd, &i, sizeof i); i++;
	write (test_fd, &i, sizeof i); i++;

	test_fsize = lseek(test_fd, 0, SEEK_CUR);

	/* Run the tests.  */
	check_aligned_anonymous_unfixed_mmaps();
	check_aligned_anonymous_unfixed_colliding_mmaps();
	check_aligned_anonymous_fixed_mmaps();
	check_file_unfixed_mmaps();
	check_file_fixed_mmaps();
	check_file_fixed_eof_mmaps();
	check_file_unfixed_eof_mmaps();

	/* Fails at the moment.  */
	/* check_aligned_anonymous_fixed_mmaps_collide_with_host(); */

	return EXIT_SUCCESS;
}
Commit	Line	Data
e1ffb0f1 EI	1	/*
	2	* Small test program to verify simulated mmap behaviour.
	3	*
	4	* When running qemu-linux-user with the -p flag, you may need to tell
	5	* this test program about the pagesize because getpagesize() will not reflect
	6	* the -p choice. Simply pass one argument beeing the pagesize.
	7	*
	8	* Copyright (c) 2007 AXIS Communications AB
	9	* Written by Edgar E. Iglesias.
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to the Free Software
530e7615 BS	23	* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
530e7615 BS	24	* MA 02110-1301, USA.
e1ffb0f1 EI	25	*/
	26
	27	#include <stdio.h>
	28	#include <stdlib.h>
	29	#include <stdint.h>
	30	#include <string.h>
	31	#include <unistd.h>
	32
	33	#include <sys/mman.h>
	34
	35	#define D(x)
	36
	37	#define fail_unless(x) \
	38	do \
	39	{ \
	40	if (!(x)) { \
	41	fprintf (stderr, "FAILED at %s:%d\n", __FILE__, __LINE__); \
	42	exit (EXIT_FAILURE); \
	43	} \
	44	} while (0);
	45
	46	unsigned char *dummybuf;
	47	static unsigned int pagesize;
	48	static unsigned int pagemask;
	49	int test_fd;
	50	size_t test_fsize;
	51
	52	void check_aligned_anonymous_unfixed_mmaps(void)
	53	{
	54	void *p1;
	55	void *p2;
	56	void *p3;
	57	void *p4;
	58	void *p5;
	59	uintptr_t p;
	60	int i;
	61
	62	fprintf (stderr, "%s", __func__);
	63	for (i = 0; i < 0x1fff; i++)
	64	{
	65	size_t len;
	66
	67	len = pagesize + (pagesize * i & 7);
	68	p1 = mmap(NULL, len, PROT_READ,
	69	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
	70	p2 = mmap(NULL, len, PROT_READ,
	71	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
	72	p3 = mmap(NULL, len, PROT_READ,
	73	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
	74	p4 = mmap(NULL, len, PROT_READ,
	75	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
	76	p5 = mmap(NULL, len, PROT_READ,
	77	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
	78
	79	/* Make sure we get pages aligned with the pagesize. The
	80	target expects this. */
	81	fail_unless (p1 != MAP_FAILED);
	82	fail_unless (p2 != MAP_FAILED);
	83	fail_unless (p3 != MAP_FAILED);
	84	fail_unless (p4 != MAP_FAILED);
	85	fail_unless (p5 != MAP_FAILED);
	86	p = (uintptr_t) p1;
	87	D(printf ("p=%x\n", p));
	88	fail_unless ((p & pagemask) == 0);
89	p = (uintptr_t) p2;
90	fail_unless ((p & pagemask) == 0);
91	p = (uintptr_t) p3;
92	fail_unless ((p & pagemask) == 0);
93	p = (uintptr_t) p4;
94	fail_unless ((p & pagemask) == 0);
95	p = (uintptr_t) p5;
96	fail_unless ((p & pagemask) == 0);
97
98	/* Make sure we can read from the entire area. */
99	memcpy (dummybuf, p1, pagesize);
100	memcpy (dummybuf, p2, pagesize);
101	memcpy (dummybuf, p3, pagesize);
102	memcpy (dummybuf, p4, pagesize);
103	memcpy (dummybuf, p5, pagesize);
104
105	munmap (p1, len);
106	munmap (p2, len);
107	munmap (p3, len);
108	munmap (p4, len);
109	munmap (p5, len);
110	}
111	fprintf (stderr, " passed\n");
112	}
113
114	void check_large_anonymous_unfixed_mmap(void)
115	{
116	void *p1;
117	uintptr_t p;
118	size_t len;
119
120	fprintf (stderr, "%s", __func__);
121
122	len = 0x02000000;
123	p1 = mmap(NULL, len, PROT_READ,
124	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
125
126	/* Make sure we get pages aligned with the pagesize. The
127	target expects this. */
128	fail_unless (p1 != MAP_FAILED);
129	p = (uintptr_t) p1;
130	fail_unless ((p & pagemask) == 0);
131
132	/* Make sure we can read from the entire area. */
133	memcpy (dummybuf, p1, pagesize);
134	munmap (p1, len);
135	fprintf (stderr, " passed\n");
136	}
137
138	void check_aligned_anonymous_unfixed_colliding_mmaps(void)
139	{
140	char *p1;
141	char *p2;
142	char *p3;
143	uintptr_t p;
144	int i;
145
146	fprintf (stderr, "%s", __func__);
147	for (i = 0; i < 0x2fff; i++)
148	{
149	int nlen;
150	p1 = mmap(NULL, pagesize, PROT_READ,
151	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
152	fail_unless (p1 != MAP_FAILED);
153	p = (uintptr_t) p1;
154	fail_unless ((p & pagemask) == 0);
155	memcpy (dummybuf, p1, pagesize);
156
157	p2 = mmap(NULL, pagesize, PROT_READ,
158	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
159	fail_unless (p2 != MAP_FAILED);
160	p = (uintptr_t) p2;
161	fail_unless ((p & pagemask) == 0);
162	memcpy (dummybuf, p2, pagesize);
163
164
165	munmap (p1, pagesize);
166	nlen = pagesize * 8;
167	p3 = mmap(NULL, nlen, PROT_READ,
168	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
169
170	/* Check if the mmaped areas collide. */
171	if (p3 < p2
172	&& (p3 + nlen) > p2)
173	fail_unless (0);
174
175	memcpy (dummybuf, p3, pagesize);
176
177	/* Make sure we get pages aligned with the pagesize. The
178	target expects this. */
179	fail_unless (p3 != MAP_FAILED);
180	p = (uintptr_t) p3;
181	fail_unless ((p & pagemask) == 0);
182	munmap (p2, pagesize);
183	munmap (p3, nlen);
184	}
185	fprintf (stderr, " passed\n");
186	}
187
188	void check_aligned_anonymous_fixed_mmaps(void)
189	{
190	char *addr;
191	void *p1;
192	uintptr_t p;
193	int i;
194
195	/* Find a suitable address to start with. */
196	addr = mmap(NULL, pagesize * 40, PROT_READ \| PROT_WRITE,
197	MAP_PRIVATE \| MAP_ANONYMOUS,
198	-1, 0);
199	fprintf (stderr, "%s addr=%p", __func__, addr);
200	fail_unless (addr != MAP_FAILED);
201
202	for (i = 0; i < 40; i++)
203	{
204	/* Create submaps within our unfixed map. */
205	p1 = mmap(addr, pagesize, PROT_READ,
206	MAP_PRIVATE \| MAP_ANONYMOUS \| MAP_FIXED,
207	-1, 0);
208	/* Make sure we get pages aligned with the pagesize.
209	The target expects this. */
210	p = (uintptr_t) p1;
211	fail_unless (p1 == addr);
212	fail_unless ((p & pagemask) == 0);
213	memcpy (dummybuf, p1, pagesize);
214	munmap (p1, pagesize);
215	addr += pagesize;
216	}
217	fprintf (stderr, " passed\n");
218	}
219
220	void check_aligned_anonymous_fixed_mmaps_collide_with_host(void)
221	{
222	char *addr;
223	void *p1;
224	uintptr_t p;
225	int i;
226
227	/* Find a suitable address to start with. Right were the x86 hosts
228	stack is. */
229	addr = ((void *)0x80000000);
230	fprintf (stderr, "%s addr=%p", __func__, addr);
231	fprintf (stderr, "FIXME: QEMU fails to track pages used by the host.");
232
233	for (i = 0; i < 20; i++)
234	{
235	/* Create submaps within our unfixed map. */
236	p1 = mmap(addr, pagesize, PROT_READ \| PROT_WRITE,
237	MAP_PRIVATE \| MAP_ANONYMOUS \| MAP_FIXED,
238	-1, 0);
239	/* Make sure we get pages aligned with the pagesize.
240	The target expects this. */
241	p = (uintptr_t) p1;
242	fail_unless (p1 == addr);
243	fail_unless ((p & pagemask) == 0);
244	memcpy (p1, dummybuf, pagesize);
245	munmap (p1, pagesize);
246	addr += pagesize;
247	}
248	fprintf (stderr, " passed\n");
249	}
250
251	void check_file_unfixed_mmaps(void)
252	{
253	unsigned int p1, p2, *p3;
254	uintptr_t p;
255	int i;
256
257	fprintf (stderr, "%s", __func__);
258	for (i = 0; i < 0x10; i++)
259	{
260	size_t len;
261
262	len = pagesize;
263	p1 = mmap(NULL, len, PROT_READ,
264	MAP_PRIVATE,
265	test_fd, 0);
266	p2 = mmap(NULL, len, PROT_READ,
267	MAP_PRIVATE,
268	test_fd, pagesize);
269	p3 = mmap(NULL, len, PROT_READ,
270	MAP_PRIVATE,
271	test_fd, pagesize * 2);
272
273	fail_unless (p1 != MAP_FAILED);
274	fail_unless (p2 != MAP_FAILED);
275	fail_unless (p3 != MAP_FAILED);
276
277	/* Make sure we get pages aligned with the pagesize. The
278	target expects this. */
279	p = (uintptr_t) p1;
280	fail_unless ((p & pagemask) == 0);
281	p = (uintptr_t) p2;
282	fail_unless ((p & pagemask) == 0);
283	p = (uintptr_t) p3;
284	fail_unless ((p & pagemask) == 0);
285
286	/* Verify that the file maps was made correctly. */
287	D(printf ("p1=%d p2=%d p3=%d\n", p1, p2, *p3));
288	fail_unless (*p1 == 0);
289	fail_unless (p2 == (pagesize / sizeof p2));
290	fail_unless (p3 == ((pagesize 2) / sizeof *p3));
291
292	memcpy (dummybuf, p1, pagesize);
293	memcpy (dummybuf, p2, pagesize);
294	memcpy (dummybuf, p3, pagesize);
295	munmap (p1, len);
296	munmap (p2, len);
297	munmap (p3, len);
298	}
299	fprintf (stderr, " passed\n");
300	}
301
302	void check_file_unfixed_eof_mmaps(void)
303	{
304	char *cp;
305	unsigned int *p1;
306	uintptr_t p;
307	int i;
308
309	fprintf (stderr, "%s", __func__);
310	for (i = 0; i < 0x10; i++)
311	{
312	p1 = mmap(NULL, pagesize, PROT_READ,
313	MAP_PRIVATE,
314	test_fd,
315	(test_fsize - sizeof *p1) & ~pagemask);
316
317	fail_unless (p1 != MAP_FAILED);
318
319	/* Make sure we get pages aligned with the pagesize. The
320	target expects this. */
321	p = (uintptr_t) p1;
322	fail_unless ((p & pagemask) == 0);
323	/* Verify that the file maps was made correctly. */
324	fail_unless (p1[(test_fsize & pagemask) / sizeof *p1 - 1]
325	== ((test_fsize - sizeof p1) / sizeof p1));
326
327	/* Verify that the end of page is accessable and zeroed. */
328	cp = (void *) p1;
329	fail_unless (cp[pagesize - 4] == 0);
330	munmap (p1, pagesize);
331	}
332	fprintf (stderr, " passed\n");
333	}
334
335	void check_file_fixed_eof_mmaps(void)
336	{
337	char *addr;
338	char *cp;
339	unsigned int *p1;
340	uintptr_t p;
341	int i;
342
343	/* Find a suitable address to start with. */
344	addr = mmap(NULL, pagesize * 44, PROT_READ,
345	MAP_PRIVATE \| MAP_ANONYMOUS,
346	-1, 0);
347
348	fprintf (stderr, "%s addr=%p", __func__, (void *)addr);
349	fail_unless (addr != MAP_FAILED);
350
351	for (i = 0; i < 0x10; i++)
352	{
353	/* Create submaps within our unfixed map. */
354	p1 = mmap(addr, pagesize, PROT_READ,
355	MAP_PRIVATE \| MAP_FIXED,
356	test_fd,
357	(test_fsize - sizeof *p1) & ~pagemask);
358
359	fail_unless (p1 != MAP_FAILED);
360
361	/* Make sure we get pages aligned with the pagesize. The
362	target expects this. */
363	p = (uintptr_t) p1;
364	fail_unless ((p & pagemask) == 0);
365
366	/* Verify that the file maps was made correctly. */
367	fail_unless (p1[(test_fsize & pagemask) / sizeof *p1 - 1]
368	== ((test_fsize - sizeof p1) / sizeof p1));
369
370	/* Verify that the end of page is accessable and zeroed. */
371	cp = (void *)p1;
372	fail_unless (cp[pagesize - 4] == 0);
373	munmap (p1, pagesize);
374	addr += pagesize;
375	}
376	fprintf (stderr, " passed\n");
377	}
378
379	void check_file_fixed_mmaps(void)
380	{
7dd7c987	381	unsigned char *addr;
e1ffb0f1 EI	382	unsigned int p1, p2, p3, p4;
	383	int i;
	384
	385	/* Find a suitable address to start with. */
7dd7c987	386	addr = mmap(NULL, pagesize * 40 * 4, PROT_READ,
e1ffb0f1 EI	387	MAP_PRIVATE \| MAP_ANONYMOUS,
	388	-1, 0);
	389	fprintf (stderr, "%s addr=%p", __func__, (void *)addr);
	390	fail_unless (addr != MAP_FAILED);
	391
	392	for (i = 0; i < 40; i++)
	393	{
	394	p1 = mmap(addr, pagesize, PROT_READ,
	395	MAP_PRIVATE \| MAP_FIXED,
	396	test_fd, 0);
	397	p2 = mmap(addr + pagesize, pagesize, PROT_READ,
	398	MAP_PRIVATE \| MAP_FIXED,
	399	test_fd, pagesize);
	400	p3 = mmap(addr + pagesize * 2, pagesize, PROT_READ,
	401	MAP_PRIVATE \| MAP_FIXED,
	402	test_fd, pagesize * 2);
	403	p4 = mmap(addr + pagesize * 3, pagesize, PROT_READ,
	404	MAP_PRIVATE \| MAP_FIXED,
	405	test_fd, pagesize * 3);
	406
	407	/* Make sure we get pages aligned with the pagesize.
	408	The target expects this. */
7dd7c987 EI	409	fail_unless (p1 == (void *)addr);
	410	fail_unless (p2 == (void *)addr + pagesize);
	411	fail_unless (p3 == (void )addr + pagesize 2);
	412	fail_unless (p4 == (void )addr + pagesize 3);
e1ffb0f1 EI	413
	414	/* Verify that the file maps was made correctly. */
	415	fail_unless (*p1 == 0);
	416	fail_unless (p2 == (pagesize / sizeof p2));
	417	fail_unless (p3 == ((pagesize 2) / sizeof *p3));
	418	fail_unless (p4 == ((pagesize 3) / sizeof *p4));
	419
	420	memcpy (dummybuf, p1, pagesize);
	421	memcpy (dummybuf, p2, pagesize);
	422	memcpy (dummybuf, p3, pagesize);
	423	memcpy (dummybuf, p4, pagesize);
	424
	425	munmap (p1, pagesize);
	426	munmap (p2, pagesize);
	427	munmap (p3, pagesize);
	428	munmap (p4, pagesize);
7dd7c987	429	addr += pagesize * 4;
e1ffb0f1 EI	430	}
	431	fprintf (stderr, " passed\n");
	432	}
	433
	434	int main(int argc, char **argv)
	435	{
	436	char tempname[] = "/tmp/.cmmapXXXXXX";
	437	unsigned int i;
	438
	439	/* Trust the first argument, otherwise probe the system for our
	440	pagesize. */
	441	if (argc > 1)
	442	pagesize = strtoul(argv[1], NULL, 0);
	443	else
	444	pagesize = sysconf(_SC_PAGESIZE);
	445
	446	/* Assume pagesize is a power of two. */
	447	pagemask = pagesize - 1;
	448	dummybuf = malloc (pagesize);
	449	printf ("pagesize=%u pagemask=%x\n", pagesize, pagemask);
	450
	451	test_fd = mkstemp(tempname);
	452	unlink(tempname);
	453
	454	/* Fill the file with int's counting from zero and up. */
	455	for (i = 0; i < (pagesize * 4) / sizeof i; i++)
	456	write (test_fd, &i, sizeof i);
	457	/* Append a few extra writes to make the file end at non
	458	page boundary. */
	459	write (test_fd, &i, sizeof i); i++;
	460	write (test_fd, &i, sizeof i); i++;
	461	write (test_fd, &i, sizeof i); i++;
	462
	463	test_fsize = lseek(test_fd, 0, SEEK_CUR);
	464
	465	/* Run the tests. */
	466	check_aligned_anonymous_unfixed_mmaps();
	467	check_aligned_anonymous_unfixed_colliding_mmaps();
	468	check_aligned_anonymous_fixed_mmaps();
	469	check_file_unfixed_mmaps();
	470	check_file_fixed_mmaps();
	471	check_file_fixed_eof_mmaps();
	472	check_file_unfixed_eof_mmaps();
	473
	474	/* Fails at the moment. */
	475	/* check_aligned_anonymous_fixed_mmaps_collide_with_host(); */
	476
	477	return EXIT_SUCCESS;
	478	}