block: User BdrvChild callback for device name
[qemu.git] / linux-user / mmap.c
1 /*
2 * mmap support for qemu
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19 #include "qemu/osdep.h"
20 #include <sys/mman.h>
21 #include <linux/mman.h>
22 #include <linux/unistd.h>
23
24 #include "qemu.h"
25 #include "qemu-common.h"
26 #include "translate-all.h"
27
28 //#define DEBUG_MMAP
29
30 static pthread_mutex_t mmap_mutex = PTHREAD_MUTEX_INITIALIZER;
31 static __thread int mmap_lock_count;
32
33 void mmap_lock(void)
34 {
35 if (mmap_lock_count++ == 0) {
36 pthread_mutex_lock(&mmap_mutex);
37 }
38 }
39
40 void mmap_unlock(void)
41 {
42 if (--mmap_lock_count == 0) {
43 pthread_mutex_unlock(&mmap_mutex);
44 }
45 }
46
47 /* Grab lock to make sure things are in a consistent state after fork(). */
48 void mmap_fork_start(void)
49 {
50 if (mmap_lock_count)
51 abort();
52 pthread_mutex_lock(&mmap_mutex);
53 }
54
55 void mmap_fork_end(int child)
56 {
57 if (child)
58 pthread_mutex_init(&mmap_mutex, NULL);
59 else
60 pthread_mutex_unlock(&mmap_mutex);
61 }
62
63 /* NOTE: all the constants are the HOST ones, but addresses are target. */
64 int target_mprotect(abi_ulong start, abi_ulong len, int prot)
65 {
66 abi_ulong end, host_start, host_end, addr;
67 int prot1, ret;
68
69 #ifdef DEBUG_MMAP
70 printf("mprotect: start=0x" TARGET_ABI_FMT_lx
71 "len=0x" TARGET_ABI_FMT_lx " prot=%c%c%c\n", start, len,
72 prot & PROT_READ ? 'r' : '-',
73 prot & PROT_WRITE ? 'w' : '-',
74 prot & PROT_EXEC ? 'x' : '-');
75 #endif
76
77 if ((start & ~TARGET_PAGE_MASK) != 0)
78 return -EINVAL;
79 len = TARGET_PAGE_ALIGN(len);
80 end = start + len;
81 if (end < start)
82 return -EINVAL;
83 prot &= PROT_READ | PROT_WRITE | PROT_EXEC;
84 if (len == 0)
85 return 0;
86
87 mmap_lock();
88 host_start = start & qemu_host_page_mask;
89 host_end = HOST_PAGE_ALIGN(end);
90 if (start > host_start) {
91 /* handle host page containing start */
92 prot1 = prot;
93 for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) {
94 prot1 |= page_get_flags(addr);
95 }
96 if (host_end == host_start + qemu_host_page_size) {
97 for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
98 prot1 |= page_get_flags(addr);
99 }
100 end = host_end;
101 }
102 ret = mprotect(g2h(host_start), qemu_host_page_size, prot1 & PAGE_BITS);
103 if (ret != 0)
104 goto error;
105 host_start += qemu_host_page_size;
106 }
107 if (end < host_end) {
108 prot1 = prot;
109 for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
110 prot1 |= page_get_flags(addr);
111 }
112 ret = mprotect(g2h(host_end - qemu_host_page_size), qemu_host_page_size,
113 prot1 & PAGE_BITS);
114 if (ret != 0)
115 goto error;
116 host_end -= qemu_host_page_size;
117 }
118
119 /* handle the pages in the middle */
120 if (host_start < host_end) {
121 ret = mprotect(g2h(host_start), host_end - host_start, prot);
122 if (ret != 0)
123 goto error;
124 }
125 page_set_flags(start, start + len, prot | PAGE_VALID);
126 mmap_unlock();
127 return 0;
128 error:
129 mmap_unlock();
130 return ret;
131 }
132
133 /* map an incomplete host page */
134 static int mmap_frag(abi_ulong real_start,
135 abi_ulong start, abi_ulong end,
136 int prot, int flags, int fd, abi_ulong offset)
137 {
138 abi_ulong real_end, addr;
139 void *host_start;
140 int prot1, prot_new;
141
142 real_end = real_start + qemu_host_page_size;
143 host_start = g2h(real_start);
144
145 /* get the protection of the target pages outside the mapping */
146 prot1 = 0;
147 for(addr = real_start; addr < real_end; addr++) {
148 if (addr < start || addr >= end)
149 prot1 |= page_get_flags(addr);
150 }
151
152 if (prot1 == 0) {
153 /* no page was there, so we allocate one */
154 void *p = mmap(host_start, qemu_host_page_size, prot,
155 flags | MAP_ANONYMOUS, -1, 0);
156 if (p == MAP_FAILED)
157 return -1;
158 prot1 = prot;
159 }
160 prot1 &= PAGE_BITS;
161
162 prot_new = prot | prot1;
163 if (!(flags & MAP_ANONYMOUS)) {
164 /* msync() won't work here, so we return an error if write is
165 possible while it is a shared mapping */
166 if ((flags & MAP_TYPE) == MAP_SHARED &&
167 (prot & PROT_WRITE))
168 return -1;
169
170 /* adjust protection to be able to read */
171 if (!(prot1 & PROT_WRITE))
172 mprotect(host_start, qemu_host_page_size, prot1 | PROT_WRITE);
173
174 /* read the corresponding file data */
175 if (pread(fd, g2h(start), end - start, offset) == -1)
176 return -1;
177
178 /* put final protection */
179 if (prot_new != (prot1 | PROT_WRITE))
180 mprotect(host_start, qemu_host_page_size, prot_new);
181 } else {
182 if (prot_new != prot1) {
183 mprotect(host_start, qemu_host_page_size, prot_new);
184 }
185 if (prot_new & PROT_WRITE) {
186 memset(g2h(start), 0, end - start);
187 }
188 }
189 return 0;
190 }
191
192 #if HOST_LONG_BITS == 64 && TARGET_ABI_BITS == 64
193 # define TASK_UNMAPPED_BASE (1ul << 38)
194 #elif defined(__CYGWIN__)
195 /* Cygwin doesn't have a whole lot of address space. */
196 # define TASK_UNMAPPED_BASE 0x18000000
197 #else
198 # define TASK_UNMAPPED_BASE 0x40000000
199 #endif
200 abi_ulong mmap_next_start = TASK_UNMAPPED_BASE;
201
202 unsigned long last_brk;
203
204 /* Subroutine of mmap_find_vma, used when we have pre-allocated a chunk
205 of guest address space. */
206 static abi_ulong mmap_find_vma_reserved(abi_ulong start, abi_ulong size)
207 {
208 abi_ulong addr;
209 abi_ulong end_addr;
210 int prot;
211 int looped = 0;
212
213 if (size > reserved_va) {
214 return (abi_ulong)-1;
215 }
216
217 size = HOST_PAGE_ALIGN(size);
218 end_addr = start + size;
219 if (end_addr > reserved_va) {
220 end_addr = reserved_va;
221 }
222 addr = end_addr - qemu_host_page_size;
223
224 while (1) {
225 if (addr > end_addr) {
226 if (looped) {
227 return (abi_ulong)-1;
228 }
229 end_addr = reserved_va;
230 addr = end_addr - qemu_host_page_size;
231 looped = 1;
232 continue;
233 }
234 prot = page_get_flags(addr);
235 if (prot) {
236 end_addr = addr;
237 }
238 if (addr + size == end_addr) {
239 break;
240 }
241 addr -= qemu_host_page_size;
242 }
243
244 if (start == mmap_next_start) {
245 mmap_next_start = addr;
246 }
247
248 return addr;
249 }
250
251 /*
252 * Find and reserve a free memory area of size 'size'. The search
253 * starts at 'start'.
254 * It must be called with mmap_lock() held.
255 * Return -1 if error.
256 */
257 abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size)
258 {
259 void *ptr, *prev;
260 abi_ulong addr;
261 int wrapped, repeat;
262
263 /* If 'start' == 0, then a default start address is used. */
264 if (start == 0) {
265 start = mmap_next_start;
266 } else {
267 start &= qemu_host_page_mask;
268 }
269
270 size = HOST_PAGE_ALIGN(size);
271
272 if (reserved_va) {
273 return mmap_find_vma_reserved(start, size);
274 }
275
276 addr = start;
277 wrapped = repeat = 0;
278 prev = 0;
279
280 for (;; prev = ptr) {
281 /*
282 * Reserve needed memory area to avoid a race.
283 * It should be discarded using:
284 * - mmap() with MAP_FIXED flag
285 * - mremap() with MREMAP_FIXED flag
286 * - shmat() with SHM_REMAP flag
287 */
288 ptr = mmap(g2h(addr), size, PROT_NONE,
289 MAP_ANONYMOUS|MAP_PRIVATE|MAP_NORESERVE, -1, 0);
290
291 /* ENOMEM, if host address space has no memory */
292 if (ptr == MAP_FAILED) {
293 return (abi_ulong)-1;
294 }
295
296 /* Count the number of sequential returns of the same address.
297 This is used to modify the search algorithm below. */
298 repeat = (ptr == prev ? repeat + 1 : 0);
299
300 if (h2g_valid(ptr + size - 1)) {
301 addr = h2g(ptr);
302
303 if ((addr & ~TARGET_PAGE_MASK) == 0) {
304 /* Success. */
305 if (start == mmap_next_start && addr >= TASK_UNMAPPED_BASE) {
306 mmap_next_start = addr + size;
307 }
308 return addr;
309 }
310
311 /* The address is not properly aligned for the target. */
312 switch (repeat) {
313 case 0:
314 /* Assume the result that the kernel gave us is the
315 first with enough free space, so start again at the
316 next higher target page. */
317 addr = TARGET_PAGE_ALIGN(addr);
318 break;
319 case 1:
320 /* Sometimes the kernel decides to perform the allocation
321 at the top end of memory instead. */
322 addr &= TARGET_PAGE_MASK;
323 break;
324 case 2:
325 /* Start over at low memory. */
326 addr = 0;
327 break;
328 default:
329 /* Fail. This unaligned block must the last. */
330 addr = -1;
331 break;
332 }
333 } else {
334 /* Since the result the kernel gave didn't fit, start
335 again at low memory. If any repetition, fail. */
336 addr = (repeat ? -1 : 0);
337 }
338
339 /* Unmap and try again. */
340 munmap(ptr, size);
341
342 /* ENOMEM if we checked the whole of the target address space. */
343 if (addr == (abi_ulong)-1) {
344 return (abi_ulong)-1;
345 } else if (addr == 0) {
346 if (wrapped) {
347 return (abi_ulong)-1;
348 }
349 wrapped = 1;
350 /* Don't actually use 0 when wrapping, instead indicate
351 that we'd truly like an allocation in low memory. */
352 addr = (mmap_min_addr > TARGET_PAGE_SIZE
353 ? TARGET_PAGE_ALIGN(mmap_min_addr)
354 : TARGET_PAGE_SIZE);
355 } else if (wrapped && addr >= start) {
356 return (abi_ulong)-1;
357 }
358 }
359 }
360
361 /* NOTE: all the constants are the HOST ones */
362 abi_long target_mmap(abi_ulong start, abi_ulong len, int prot,
363 int flags, int fd, abi_ulong offset)
364 {
365 abi_ulong ret, end, real_start, real_end, retaddr, host_offset, host_len;
366
367 mmap_lock();
368 #ifdef DEBUG_MMAP
369 {
370 printf("mmap: start=0x" TARGET_ABI_FMT_lx
371 " len=0x" TARGET_ABI_FMT_lx " prot=%c%c%c flags=",
372 start, len,
373 prot & PROT_READ ? 'r' : '-',
374 prot & PROT_WRITE ? 'w' : '-',
375 prot & PROT_EXEC ? 'x' : '-');
376 if (flags & MAP_FIXED)
377 printf("MAP_FIXED ");
378 if (flags & MAP_ANONYMOUS)
379 printf("MAP_ANON ");
380 switch(flags & MAP_TYPE) {
381 case MAP_PRIVATE:
382 printf("MAP_PRIVATE ");
383 break;
384 case MAP_SHARED:
385 printf("MAP_SHARED ");
386 break;
387 default:
388 printf("[MAP_TYPE=0x%x] ", flags & MAP_TYPE);
389 break;
390 }
391 printf("fd=%d offset=" TARGET_ABI_FMT_lx "\n", fd, offset);
392 }
393 #endif
394
395 if (offset & ~TARGET_PAGE_MASK) {
396 errno = EINVAL;
397 goto fail;
398 }
399
400 len = TARGET_PAGE_ALIGN(len);
401 if (len == 0)
402 goto the_end;
403 real_start = start & qemu_host_page_mask;
404 host_offset = offset & qemu_host_page_mask;
405
406 /* If the user is asking for the kernel to find a location, do that
407 before we truncate the length for mapping files below. */
408 if (!(flags & MAP_FIXED)) {
409 host_len = len + offset - host_offset;
410 host_len = HOST_PAGE_ALIGN(host_len);
411 start = mmap_find_vma(real_start, host_len);
412 if (start == (abi_ulong)-1) {
413 errno = ENOMEM;
414 goto fail;
415 }
416 }
417
418 /* When mapping files into a memory area larger than the file, accesses
419 to pages beyond the file size will cause a SIGBUS.
420
421 For example, if mmaping a file of 100 bytes on a host with 4K pages
422 emulating a target with 8K pages, the target expects to be able to
423 access the first 8K. But the host will trap us on any access beyond
424 4K.
425
426 When emulating a target with a larger page-size than the hosts, we
427 may need to truncate file maps at EOF and add extra anonymous pages
428 up to the targets page boundary. */
429
430 if ((qemu_real_host_page_size < TARGET_PAGE_SIZE)
431 && !(flags & MAP_ANONYMOUS)) {
432 struct stat sb;
433
434 if (fstat (fd, &sb) == -1)
435 goto fail;
436
437 /* Are we trying to create a map beyond EOF?. */
438 if (offset + len > sb.st_size) {
439 /* If so, truncate the file map at eof aligned with
440 the hosts real pagesize. Additional anonymous maps
441 will be created beyond EOF. */
442 len = REAL_HOST_PAGE_ALIGN(sb.st_size - offset);
443 }
444 }
445
446 if (!(flags & MAP_FIXED)) {
447 unsigned long host_start;
448 void *p;
449
450 host_len = len + offset - host_offset;
451 host_len = HOST_PAGE_ALIGN(host_len);
452
453 /* Note: we prefer to control the mapping address. It is
454 especially important if qemu_host_page_size >
455 qemu_real_host_page_size */
456 p = mmap(g2h(start), host_len, prot,
457 flags | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
458 if (p == MAP_FAILED)
459 goto fail;
460 /* update start so that it points to the file position at 'offset' */
461 host_start = (unsigned long)p;
462 if (!(flags & MAP_ANONYMOUS)) {
463 p = mmap(g2h(start), len, prot,
464 flags | MAP_FIXED, fd, host_offset);
465 if (p == MAP_FAILED) {
466 munmap(g2h(start), host_len);
467 goto fail;
468 }
469 host_start += offset - host_offset;
470 }
471 start = h2g(host_start);
472 } else {
473 if (start & ~TARGET_PAGE_MASK) {
474 errno = EINVAL;
475 goto fail;
476 }
477 end = start + len;
478 real_end = HOST_PAGE_ALIGN(end);
479
480 /*
481 * Test if requested memory area fits target address space
482 * It can fail only on 64-bit host with 32-bit target.
483 * On any other target/host host mmap() handles this error correctly.
484 */
485 if ((unsigned long)start + len - 1 > (abi_ulong) -1) {
486 errno = EINVAL;
487 goto fail;
488 }
489
490 /* worst case: we cannot map the file because the offset is not
491 aligned, so we read it */
492 if (!(flags & MAP_ANONYMOUS) &&
493 (offset & ~qemu_host_page_mask) != (start & ~qemu_host_page_mask)) {
494 /* msync() won't work here, so we return an error if write is
495 possible while it is a shared mapping */
496 if ((flags & MAP_TYPE) == MAP_SHARED &&
497 (prot & PROT_WRITE)) {
498 errno = EINVAL;
499 goto fail;
500 }
501 retaddr = target_mmap(start, len, prot | PROT_WRITE,
502 MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,
503 -1, 0);
504 if (retaddr == -1)
505 goto fail;
506 if (pread(fd, g2h(start), len, offset) == -1)
507 goto fail;
508 if (!(prot & PROT_WRITE)) {
509 ret = target_mprotect(start, len, prot);
510 assert(ret == 0);
511 }
512 goto the_end;
513 }
514
515 /* handle the start of the mapping */
516 if (start > real_start) {
517 if (real_end == real_start + qemu_host_page_size) {
518 /* one single host page */
519 ret = mmap_frag(real_start, start, end,
520 prot, flags, fd, offset);
521 if (ret == -1)
522 goto fail;
523 goto the_end1;
524 }
525 ret = mmap_frag(real_start, start, real_start + qemu_host_page_size,
526 prot, flags, fd, offset);
527 if (ret == -1)
528 goto fail;
529 real_start += qemu_host_page_size;
530 }
531 /* handle the end of the mapping */
532 if (end < real_end) {
533 ret = mmap_frag(real_end - qemu_host_page_size,
534 real_end - qemu_host_page_size, end,
535 prot, flags, fd,
536 offset + real_end - qemu_host_page_size - start);
537 if (ret == -1)
538 goto fail;
539 real_end -= qemu_host_page_size;
540 }
541
542 /* map the middle (easier) */
543 if (real_start < real_end) {
544 void *p;
545 unsigned long offset1;
546 if (flags & MAP_ANONYMOUS)
547 offset1 = 0;
548 else
549 offset1 = offset + real_start - start;
550 p = mmap(g2h(real_start), real_end - real_start,
551 prot, flags, fd, offset1);
552 if (p == MAP_FAILED)
553 goto fail;
554 }
555 }
556 the_end1:
557 page_set_flags(start, start + len, prot | PAGE_VALID);
558 the_end:
559 #ifdef DEBUG_MMAP
560 printf("ret=0x" TARGET_ABI_FMT_lx "\n", start);
561 page_dump(stdout);
562 printf("\n");
563 #endif
564 tb_invalidate_phys_range(start, start + len);
565 mmap_unlock();
566 return start;
567 fail:
568 mmap_unlock();
569 return -1;
570 }
571
572 static void mmap_reserve(abi_ulong start, abi_ulong size)
573 {
574 abi_ulong real_start;
575 abi_ulong real_end;
576 abi_ulong addr;
577 abi_ulong end;
578 int prot;
579
580 real_start = start & qemu_host_page_mask;
581 real_end = HOST_PAGE_ALIGN(start + size);
582 end = start + size;
583 if (start > real_start) {
584 /* handle host page containing start */
585 prot = 0;
586 for (addr = real_start; addr < start; addr += TARGET_PAGE_SIZE) {
587 prot |= page_get_flags(addr);
588 }
589 if (real_end == real_start + qemu_host_page_size) {
590 for (addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
591 prot |= page_get_flags(addr);
592 }
593 end = real_end;
594 }
595 if (prot != 0)
596 real_start += qemu_host_page_size;
597 }
598 if (end < real_end) {
599 prot = 0;
600 for (addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
601 prot |= page_get_flags(addr);
602 }
603 if (prot != 0)
604 real_end -= qemu_host_page_size;
605 }
606 if (real_start != real_end) {
607 mmap(g2h(real_start), real_end - real_start, PROT_NONE,
608 MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE,
609 -1, 0);
610 }
611 }
612
613 int target_munmap(abi_ulong start, abi_ulong len)
614 {
615 abi_ulong end, real_start, real_end, addr;
616 int prot, ret;
617
618 #ifdef DEBUG_MMAP
619 printf("munmap: start=0x" TARGET_ABI_FMT_lx " len=0x"
620 TARGET_ABI_FMT_lx "\n",
621 start, len);
622 #endif
623 if (start & ~TARGET_PAGE_MASK)
624 return -EINVAL;
625 len = TARGET_PAGE_ALIGN(len);
626 if (len == 0)
627 return -EINVAL;
628 mmap_lock();
629 end = start + len;
630 real_start = start & qemu_host_page_mask;
631 real_end = HOST_PAGE_ALIGN(end);
632
633 if (start > real_start) {
634 /* handle host page containing start */
635 prot = 0;
636 for(addr = real_start; addr < start; addr += TARGET_PAGE_SIZE) {
637 prot |= page_get_flags(addr);
638 }
639 if (real_end == real_start + qemu_host_page_size) {
640 for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
641 prot |= page_get_flags(addr);
642 }
643 end = real_end;
644 }
645 if (prot != 0)
646 real_start += qemu_host_page_size;
647 }
648 if (end < real_end) {
649 prot = 0;
650 for(addr = end; addr < real_end; addr += TARGET_PAGE_SIZE) {
651 prot |= page_get_flags(addr);
652 }
653 if (prot != 0)
654 real_end -= qemu_host_page_size;
655 }
656
657 ret = 0;
658 /* unmap what we can */
659 if (real_start < real_end) {
660 if (reserved_va) {
661 mmap_reserve(real_start, real_end - real_start);
662 } else {
663 ret = munmap(g2h(real_start), real_end - real_start);
664 }
665 }
666
667 if (ret == 0) {
668 page_set_flags(start, start + len, 0);
669 tb_invalidate_phys_range(start, start + len);
670 }
671 mmap_unlock();
672 return ret;
673 }
674
675 abi_long target_mremap(abi_ulong old_addr, abi_ulong old_size,
676 abi_ulong new_size, unsigned long flags,
677 abi_ulong new_addr)
678 {
679 int prot;
680 void *host_addr;
681
682 mmap_lock();
683
684 if (flags & MREMAP_FIXED) {
685 host_addr = (void *) syscall(__NR_mremap, g2h(old_addr),
686 old_size, new_size,
687 flags,
688 g2h(new_addr));
689
690 if (reserved_va && host_addr != MAP_FAILED) {
691 /* If new and old addresses overlap then the above mremap will
692 already have failed with EINVAL. */
693 mmap_reserve(old_addr, old_size);
694 }
695 } else if (flags & MREMAP_MAYMOVE) {
696 abi_ulong mmap_start;
697
698 mmap_start = mmap_find_vma(0, new_size);
699
700 if (mmap_start == -1) {
701 errno = ENOMEM;
702 host_addr = MAP_FAILED;
703 } else {
704 host_addr = (void *) syscall(__NR_mremap, g2h(old_addr),
705 old_size, new_size,
706 flags | MREMAP_FIXED,
707 g2h(mmap_start));
708 if (reserved_va) {
709 mmap_reserve(old_addr, old_size);
710 }
711 }
712 } else {
713 int prot = 0;
714 if (reserved_va && old_size < new_size) {
715 abi_ulong addr;
716 for (addr = old_addr + old_size;
717 addr < old_addr + new_size;
718 addr++) {
719 prot |= page_get_flags(addr);
720 }
721 }
722 if (prot == 0) {
723 host_addr = mremap(g2h(old_addr), old_size, new_size, flags);
724 if (host_addr != MAP_FAILED && reserved_va && old_size > new_size) {
725 mmap_reserve(old_addr + old_size, new_size - old_size);
726 }
727 } else {
728 errno = ENOMEM;
729 host_addr = MAP_FAILED;
730 }
731 /* Check if address fits target address space */
732 if ((unsigned long)host_addr + new_size > (abi_ulong)-1) {
733 /* Revert mremap() changes */
734 host_addr = mremap(g2h(old_addr), new_size, old_size, flags);
735 errno = ENOMEM;
736 host_addr = MAP_FAILED;
737 }
738 }
739
740 if (host_addr == MAP_FAILED) {
741 new_addr = -1;
742 } else {
743 new_addr = h2g(host_addr);
744 prot = page_get_flags(old_addr);
745 page_set_flags(old_addr, old_addr + old_size, 0);
746 page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID);
747 }
748 tb_invalidate_phys_range(new_addr, new_addr + new_size);
749 mmap_unlock();
750 return new_addr;
751 }
752
753 int target_msync(abi_ulong start, abi_ulong len, int flags)
754 {
755 abi_ulong end;
756
757 if (start & ~TARGET_PAGE_MASK)
758 return -EINVAL;
759 len = TARGET_PAGE_ALIGN(len);
760 end = start + len;
761 if (end < start)
762 return -EINVAL;
763 if (end == start)
764 return 0;
765
766 start &= qemu_host_page_mask;
767 return msync(g2h(start), end - start, flags);
768 }