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