2 * mmap support for qemu
4 * Copyright (c) 2003 Fabrice Bellard
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.
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.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32 /* NOTE: all the constants are the HOST ones */
33 int target_mprotect(unsigned long start, unsigned long len, int prot)
35 unsigned long end, host_start, host_end, addr;
39 printf("mprotect: start=0x%lx len=0x%lx prot=%c%c%c\n", start, len,
40 prot & PROT_READ ? 'r' : '-',
41 prot & PROT_WRITE ? 'w' : '-',
42 prot & PROT_EXEC ? 'x' : '-');
45 if ((start & ~TARGET_PAGE_MASK) != 0)
47 len = TARGET_PAGE_ALIGN(len);
51 if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
56 host_start = start & host_page_mask;
57 host_end = HOST_PAGE_ALIGN(end);
58 if (start > host_start) {
59 /* handle host page containing start */
61 for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) {
62 prot1 |= page_get_flags(addr);
64 if (host_end == host_start + host_page_size) {
65 for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
66 prot1 |= page_get_flags(addr);
70 ret = mprotect((void *)host_start, host_page_size, prot1 & PAGE_BITS);
73 host_start += host_page_size;
77 for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
78 prot1 |= page_get_flags(addr);
80 ret = mprotect((void *)(host_end - host_page_size), host_page_size,
84 host_end -= host_page_size;
87 /* handle the pages in the middle */
88 if (host_start < host_end) {
89 ret = mprotect((void *)host_start, host_end - host_start, prot);
93 page_set_flags(start, start + len, prot | PAGE_VALID);
97 /* map an incomplete host page */
98 int mmap_frag(unsigned long host_start,
99 unsigned long start, unsigned long end,
100 int prot, int flags, int fd, unsigned long offset)
102 unsigned long host_end, ret, addr;
105 host_end = host_start + host_page_size;
107 /* get the protection of the target pages outside the mapping */
109 for(addr = host_start; addr < host_end; addr++) {
110 if (addr < start || addr >= end)
111 prot1 |= page_get_flags(addr);
115 /* no page was there, so we allocate one */
116 ret = (long)mmap((void *)host_start, host_page_size, prot,
117 flags | MAP_ANONYMOUS, -1, 0);
123 prot_new = prot | prot1;
124 if (!(flags & MAP_ANONYMOUS)) {
125 /* msync() won't work here, so we return an error if write is
126 possible while it is a shared mapping */
127 if ((flags & MAP_TYPE) == MAP_SHARED &&
131 /* adjust protection to be able to read */
132 if (!(prot1 & PROT_WRITE))
133 mprotect((void *)host_start, host_page_size, prot1 | PROT_WRITE);
135 /* read the corresponding file data */
136 pread(fd, (void *)start, end - start, offset);
138 /* put final protection */
139 if (prot_new != (prot1 | PROT_WRITE))
140 mprotect((void *)host_start, host_page_size, prot_new);
142 /* just update the protection */
143 if (prot_new != prot1) {
144 mprotect((void *)host_start, host_page_size, prot_new);
150 /* NOTE: all the constants are the HOST ones */
151 long target_mmap(unsigned long start, unsigned long len, int prot,
152 int flags, int fd, unsigned long offset)
154 unsigned long ret, end, host_start, host_end, retaddr, host_offset, host_len;
158 printf("mmap: start=0x%lx len=0x%lx prot=%c%c%c flags=",
160 prot & PROT_READ ? 'r' : '-',
161 prot & PROT_WRITE ? 'w' : '-',
162 prot & PROT_EXEC ? 'x' : '-');
163 if (flags & MAP_FIXED)
164 printf("MAP_FIXED ");
165 if (flags & MAP_ANONYMOUS)
167 switch(flags & MAP_TYPE) {
169 printf("MAP_PRIVATE ");
172 printf("MAP_SHARED ");
175 printf("[MAP_TYPE=0x%x] ", flags & MAP_TYPE);
178 printf("fd=%d offset=%lx\n", fd, offset);
182 if (offset & ~TARGET_PAGE_MASK)
185 len = TARGET_PAGE_ALIGN(len);
188 host_start = start & host_page_mask;
190 if (!(flags & MAP_FIXED)) {
191 if (host_page_size != real_host_page_size) {
192 /* NOTE: this code is only for debugging with '-p' option */
193 /* reserve a memory area */
194 host_len = HOST_PAGE_ALIGN(len) + host_page_size - TARGET_PAGE_SIZE;
195 host_start = (long)mmap((void *)host_start, host_len, PROT_NONE,
196 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
197 if (host_start == -1)
199 host_end = host_start + host_len;
200 start = HOST_PAGE_ALIGN(host_start);
201 end = start + HOST_PAGE_ALIGN(len);
202 if (start > host_start)
203 munmap((void *)host_start, start - host_start);
205 munmap((void *)end, host_end - end);
206 /* use it as a fixed mapping */
209 /* if not fixed, no need to do anything */
210 host_offset = offset & host_page_mask;
211 host_len = len + offset - host_offset;
212 start = (long)mmap((void *)host_start, host_len,
213 prot, flags, fd, host_offset);
216 /* update start so that it points to the file position at 'offset' */
217 if (!(flags & MAP_ANONYMOUS))
218 start += offset - host_offset;
223 if (start & ~TARGET_PAGE_MASK)
226 host_end = HOST_PAGE_ALIGN(end);
228 /* worst case: we cannot map the file because the offset is not
229 aligned, so we read it */
230 if (!(flags & MAP_ANONYMOUS) &&
231 (offset & ~host_page_mask) != (start & ~host_page_mask)) {
232 /* msync() won't work here, so we return an error if write is
233 possible while it is a shared mapping */
234 if ((flags & MAP_TYPE) == MAP_SHARED &&
237 retaddr = target_mmap(start, len, prot | PROT_WRITE,
238 MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,
242 pread(fd, (void *)start, len, offset);
243 if (!(prot & PROT_WRITE)) {
244 ret = target_mprotect(start, len, prot);
251 /* handle the start of the mapping */
252 if (start > host_start) {
253 if (host_end == host_start + host_page_size) {
254 /* one single host page */
255 ret = mmap_frag(host_start, start, end,
256 prot, flags, fd, offset);
261 ret = mmap_frag(host_start, start, host_start + host_page_size,
262 prot, flags, fd, offset);
265 host_start += host_page_size;
267 /* handle the end of the mapping */
268 if (end < host_end) {
269 ret = mmap_frag(host_end - host_page_size,
270 host_end - host_page_size, host_end,
272 offset + host_end - host_page_size - start);
275 host_end -= host_page_size;
278 /* map the middle (easier) */
279 if (host_start < host_end) {
280 ret = (long)mmap((void *)host_start, host_end - host_start,
281 prot, flags, fd, offset + host_start - start);
286 page_set_flags(start, start + len, prot | PAGE_VALID);
295 int target_munmap(unsigned long start, unsigned long len)
297 unsigned long end, host_start, host_end, addr;
301 printf("munmap: start=0x%lx len=0x%lx\n", start, len);
303 if (start & ~TARGET_PAGE_MASK)
305 len = TARGET_PAGE_ALIGN(len);
309 host_start = start & host_page_mask;
310 host_end = HOST_PAGE_ALIGN(end);
312 if (start > host_start) {
313 /* handle host page containing start */
315 for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) {
316 prot |= page_get_flags(addr);
318 if (host_end == host_start + host_page_size) {
319 for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
320 prot |= page_get_flags(addr);
325 host_start += host_page_size;
327 if (end < host_end) {
329 for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
330 prot |= page_get_flags(addr);
333 host_end -= host_page_size;
336 /* unmap what we can */
337 if (host_start < host_end) {
338 ret = munmap((void *)host_start, host_end - host_start);
343 page_set_flags(start, start + len, 0);
347 /* XXX: currently, we only handle MAP_ANONYMOUS and not MAP_FIXED
348 blocks which have been allocated starting on a host page */
349 long target_mremap(unsigned long old_addr, unsigned long old_size,
350 unsigned long new_size, unsigned long flags,
351 unsigned long new_addr)
355 /* XXX: use 5 args syscall */
356 new_addr = (long)mremap((void *)old_addr, old_size, new_size, flags);
359 prot = page_get_flags(old_addr);
360 page_set_flags(old_addr, old_addr + old_size, 0);
361 page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID);
365 int target_msync(unsigned long start, unsigned long len, int flags)
369 if (start & ~TARGET_PAGE_MASK)
371 len = TARGET_PAGE_ALIGN(len);
378 start &= host_page_mask;
379 return msync((void *)start, end - start, flags);