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