@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
c 563 lines 15.9 KB
Raw
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 #define _GNU_SOURCE
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <stdint.h>
29 #include <string.h>
30 #include <unistd.h>
31 #include <errno.h>
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; /* length is 2*pagesize */
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 fprintf(stdout, "%s", __func__);
61 for (i = 0; i < 8; i++) {
62 size_t len;
63 len = pagesize + (pagesize * i);
64 p1 = mmap(NULL, len, PROT_READ,
65 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
66 p2 = mmap(NULL, len, PROT_READ,
67 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
68 p3 = mmap(NULL, len, PROT_READ,
69 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
70 p4 = mmap(NULL, len, PROT_READ,
71 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
72 p5 = mmap(NULL, len, PROT_READ,
73 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
74
75 /*
76 * Make sure we get pages aligned with the pagesize. The
77 * target expects this.
78 */
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 munmap(p1, len);
103 munmap(p2, len);
104 munmap(p3, len);
105 munmap(p4, len);
106 munmap(p5, len);
107 }
108 fprintf(stdout, " passed\n");
109 }
110
111 void check_large_anonymous_unfixed_mmap(void)
112 {
113 void *p1;
114 uintptr_t p;
115 size_t len;
116
117 fprintf(stdout, "%s", __func__);
118
119 len = 0x02000000;
120 p1 = mmap(NULL, len, PROT_READ,
121 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
122
123 /* Make sure we get pages aligned with the pagesize. The
124 target expects this. */
125 fail_unless (p1 != MAP_FAILED);
126 p = (uintptr_t) p1;
127 fail_unless ((p & pagemask) == 0);
128
129 /* Make sure we can read from the entire area. */
130 memcpy (dummybuf, p1, pagesize);
131 munmap (p1, len);
132 fprintf(stdout, " passed\n");
133 }
134
135 void check_aligned_anonymous_unfixed_colliding_mmaps(void)
136 {
137 char *p1;
138 char *p2;
139 char *p3;
140 uintptr_t p;
141 int i;
142
143 fprintf(stdout, "%s", __func__);
144 for (i = 0; i < 2; i++) {
145 int nlen;
146 p1 = mmap(NULL, pagesize, PROT_READ,
147 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
148 fail_unless(p1 != MAP_FAILED);
149 p = (uintptr_t) p1;
150 fail_unless((p & pagemask) == 0);
151 memcpy(dummybuf, p1, pagesize);
152
153 p2 = mmap(NULL, pagesize, PROT_READ,
154 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
155 fail_unless(p2 != MAP_FAILED);
156 p = (uintptr_t) p2;
157 fail_unless((p & pagemask) == 0);
158 memcpy(dummybuf, p2, pagesize);
159
160
161 munmap(p1, pagesize);
162 nlen = pagesize * 8;
163 p3 = mmap(NULL, nlen, PROT_READ,
164 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
165 fail_unless(p3 != MAP_FAILED);
166
167 /* Check if the mmaped areas collide. */
168 if (p3 < p2
169 && (p3 + nlen) > p2) {
170 fail_unless(0);
171 }
172
173 memcpy(dummybuf, p3, pagesize);
174
175 /*
176 * Make sure we get pages aligned with the pagesize. The
177 * target expects this.
178 */
179 p = (uintptr_t) p3;
180 fail_unless((p & pagemask) == 0);
181 munmap(p2, pagesize);
182 munmap(p3, nlen);
183 }
184 fprintf(stdout, " 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(stdout, "%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(stdout, " 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(stdout, "%s addr=%p", __func__, addr);
230 fprintf(stdout, "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(stdout, " 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(stdout, "%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(stdout, " 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(stdout, "%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 accessible and zeroed. */
327 cp = (void *) p1;
328 fail_unless (cp[pagesize - 4] == 0);
329 munmap (p1, pagesize);
330 }
331 fprintf(stdout, " 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(stdout, "%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 accessible and zeroed. */
370 cp = (void *)p1;
371 fail_unless (cp[pagesize - 4] == 0);
372 munmap (p1, pagesize);
373 addr += pagesize;
374 }
375 fprintf(stdout, " 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(stdout, "%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(stdout, " passed\n");
431 }
432
433 void checked_write(int fd, const void *buf, size_t count)
434 {
435 ssize_t rc = write(fd, buf, count);
436 fail_unless(rc == count);
437 }
438
439 void check_invalid_mmaps(void)
440 {
441 unsigned char *addr;
442
443 /* Attempt to map a zero length page. */
444 addr = mmap(NULL, 0, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
445 fprintf(stdout, "%s addr=%p errno=%d\n", __func__, (void *)addr, errno);
446 fail_unless(addr == MAP_FAILED);
447 fail_unless(errno == EINVAL);
448
449 /* Attempt to map a over length page. */
450 addr = mmap(NULL, -4, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
451 fprintf(stdout, "%s addr=%p errno=%d\n", __func__, (void *)addr, errno);
452 fail_unless(addr == MAP_FAILED);
453 fail_unless(errno == ENOMEM);
454
455 /* Attempt to remap a region which exceeds the bounds of memory. */
456 addr = mremap((void *)((uintptr_t)pagesize * 10), SIZE_MAX & ~(size_t)pagemask, pagesize, 0);
457 fprintf(stdout, "%s mremap addr=%p errno=%d\n", __func__, (void *)addr, errno);
458 fail_unless(addr == MAP_FAILED);
459 fail_unless(errno == EFAULT);
460
461 fprintf(stdout, " passed\n");
462 }
463
464 void check_shrink_mmaps(void)
465 {
466 unsigned char *a, *b, *c;
467 a = mmap(NULL, pagesize * 2, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
468 fprintf(stdout, "%s addr=%p errno=%d\n", __func__, (void *)a, errno);
469 b = mmap(NULL, pagesize * 2, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
470 fprintf(stdout, "%s addr=%p errno=%d\n", __func__, (void *)b, errno);
471 c = mmap(NULL, pagesize * 2, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
472 fprintf(stdout, "%s addr=%p errno=%d\n", __func__, (void *)c, errno);
473
474 fail_unless(a != MAP_FAILED);
475 fail_unless(b != MAP_FAILED);
476 fail_unless(c != MAP_FAILED);
477
478 /* Ensure we can read the full mappings */
479 memcpy(dummybuf, a, 2 * pagesize);
480 memcpy(dummybuf, b, 2 * pagesize);
481 memcpy(dummybuf, c, 2 * pagesize);
482
483 /* Shrink the middle mapping in-place; the others should be unaffected */
484 b = mremap(b, pagesize * 2, pagesize, 0);
485 fprintf(stdout, "%s mremap addr=%p errno=%d\n", __func__, (void *)b, errno);
486 fail_unless(b != MAP_FAILED);
487
488 /* Ensure we can still access all valid mappings */
489 memcpy(dummybuf, a, 2 * pagesize);
490 memcpy(dummybuf, b, pagesize);
491 memcpy(dummybuf, c, 2 * pagesize);
492
493 munmap(a, 2 * pagesize);
494 munmap(b, pagesize);
495 munmap(c, 2 * pagesize);
496
497 fprintf(stdout, " passed\n");
498 }
499
500 void check_mmaps_beyond_addr_space(void)
501 {
502 unsigned char *addr;
503 addr = mmap((void *)(-(unsigned long)pagesize * 10), pagesize * 2,
504 PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
505 fprintf(stdout, "%s addr=%p errno=%d", __func__, (void *)addr, errno);
506 fail_unless(addr != MAP_FAILED);
507
508 memcpy(dummybuf, addr, 2 * pagesize);
509 munmap(addr, 2 * pagesize);
510
511 fprintf(stdout, " passed\n");
512 }
513
514 int main(int argc, char **argv)
515 {
516 char tempname[] = "/tmp/.cmmapXXXXXX";
517 unsigned int i;
518
519 /* Trust the first argument, otherwise probe the system for our
520 pagesize. */
521 if (argc > 1)
522 pagesize = strtoul(argv[1], NULL, 0);
523 else
524 pagesize = sysconf(_SC_PAGESIZE);
525
526 /* Assume pagesize is a power of two. */
527 pagemask = pagesize - 1;
528 dummybuf = malloc (pagesize * 2);
529 printf ("pagesize=%u pagemask=%x\n", pagesize, pagemask);
530
531 test_fd = mkstemp(tempname);
532 unlink(tempname);
533
534 /* Fill the file with int's counting from zero and up. */
535 for (i = 0; i < (pagesize * 4) / sizeof i; i++) {
536 checked_write(test_fd, &i, sizeof i);
537 }
538
539 /* Append a few extra writes to make the file end at non
540 page boundary. */
541 checked_write(test_fd, &i, sizeof i); i++;
542 checked_write(test_fd, &i, sizeof i); i++;
543 checked_write(test_fd, &i, sizeof i); i++;
544
545 test_fsize = lseek(test_fd, 0, SEEK_CUR);
546
547 /* Run the tests. */
548 check_aligned_anonymous_unfixed_mmaps();
549 check_aligned_anonymous_unfixed_colliding_mmaps();
550 check_aligned_anonymous_fixed_mmaps();
551 check_file_unfixed_mmaps();
552 check_file_fixed_mmaps();
553 check_file_fixed_eof_mmaps();
554 check_file_unfixed_eof_mmaps();
555 check_invalid_mmaps();
556 check_shrink_mmaps();
557 check_mmaps_beyond_addr_space();
558
559 /* Fails at the moment. */
560 /* check_aligned_anonymous_fixed_mmaps_collide_with_host(); */
561
562 return EXIT_SUCCESS;
563 }