test-mmap.c@ 36143

Last change on this file since 36143 was 36140, checked in by vboxsync, 14 years ago
rem: Re-synced to svn://svn.savannah.nongnu.org/qemu/trunk@5495 (repo UUID c046a42c-6fe2-441c-8c8c-71466251a162).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 12.4 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/recompiler/tests/test-mmap.c@ 36143

Download in other formats: