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 defined(__alpha__) || defined(__sparc__) || defined(__x86_64__)
192 /* tell the kenel to search at the same place as i386 */
194 host_start = 0x40000000;
196 if (host_page_size != real_host_page_size) {
197 /* NOTE: this code is only for debugging with '-p' option */
198 /* reserve a memory area */
199 host_len = HOST_PAGE_ALIGN(len) + host_page_size - TARGET_PAGE_SIZE;
200 host_start = (long)mmap((void *)host_start, host_len, PROT_NONE,
201 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
202 if (host_start == -1)
204 host_end = host_start + host_len;
205 start = HOST_PAGE_ALIGN(host_start);
206 end = start + HOST_PAGE_ALIGN(len);
207 if (start > host_start)
208 munmap((void *)host_start, start - host_start);
210 munmap((void *)end, host_end - end);
211 /* use it as a fixed mapping */
214 /* if not fixed, no need to do anything */
215 host_offset = offset & host_page_mask;
216 host_len = len + offset - host_offset;
217 start = (long)mmap((void *)host_start, host_len,
218 prot, flags, fd, host_offset);
221 /* update start so that it points to the file position at 'offset' */
222 if (!(flags & MAP_ANONYMOUS))
223 start += offset - host_offset;
228 if (start & ~TARGET_PAGE_MASK)
231 host_end = HOST_PAGE_ALIGN(end);
233 /* worst case: we cannot map the file because the offset is not
234 aligned, so we read it */
235 if (!(flags & MAP_ANONYMOUS) &&
236 (offset & ~host_page_mask) != (start & ~host_page_mask)) {
237 /* msync() won't work here, so we return an error if write is
238 possible while it is a shared mapping */
239 if ((flags & MAP_TYPE) == MAP_SHARED &&
242 retaddr = target_mmap(start, len, prot | PROT_WRITE,
243 MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS,
247 pread(fd, (void *)start, len, offset);
248 if (!(prot & PROT_WRITE)) {
249 ret = target_mprotect(start, len, prot);
256 /* handle the start of the mapping */
257 if (start > host_start) {
258 if (host_end == host_start + host_page_size) {
259 /* one single host page */
260 ret = mmap_frag(host_start, start, end,
261 prot, flags, fd, offset);
266 ret = mmap_frag(host_start, start, host_start + host_page_size,
267 prot, flags, fd, offset);
270 host_start += host_page_size;
272 /* handle the end of the mapping */
273 if (end < host_end) {
274 ret = mmap_frag(host_end - host_page_size,
275 host_end - host_page_size, host_end,
277 offset + host_end - host_page_size - start);
280 host_end -= host_page_size;
283 /* map the middle (easier) */
284 if (host_start < host_end) {
285 unsigned long offset1;
286 if (flags & MAP_ANONYMOUS)
289 offset1 = offset + host_start - start;
290 ret = (long)mmap((void *)host_start, host_end - host_start,
291 prot, flags, fd, offset1);
296 page_set_flags(start, start + len, prot | PAGE_VALID);
299 printf("ret=0x%lx\n", (long)start);
306 int target_munmap(unsigned long start, unsigned long len)
308 unsigned long end, host_start, host_end, addr;
312 printf("munmap: start=0x%lx len=0x%lx\n", start, len);
314 if (start & ~TARGET_PAGE_MASK)
316 len = TARGET_PAGE_ALIGN(len);
320 host_start = start & host_page_mask;
321 host_end = HOST_PAGE_ALIGN(end);
323 if (start > host_start) {
324 /* handle host page containing start */
326 for(addr = host_start; addr < start; addr += TARGET_PAGE_SIZE) {
327 prot |= page_get_flags(addr);
329 if (host_end == host_start + host_page_size) {
330 for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
331 prot |= page_get_flags(addr);
336 host_start += host_page_size;
338 if (end < host_end) {
340 for(addr = end; addr < host_end; addr += TARGET_PAGE_SIZE) {
341 prot |= page_get_flags(addr);
344 host_end -= host_page_size;
347 /* unmap what we can */
348 if (host_start < host_end) {
349 ret = munmap((void *)host_start, host_end - host_start);
354 page_set_flags(start, start + len, 0);
358 /* XXX: currently, we only handle MAP_ANONYMOUS and not MAP_FIXED
359 blocks which have been allocated starting on a host page */
360 long target_mremap(unsigned long old_addr, unsigned long old_size,
361 unsigned long new_size, unsigned long flags,
362 unsigned long new_addr)
366 /* XXX: use 5 args syscall */
367 new_addr = (long)mremap((void *)old_addr, old_size, new_size, flags);
370 prot = page_get_flags(old_addr);
371 page_set_flags(old_addr, old_addr + old_size, 0);
372 page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID);
376 int target_msync(unsigned long start, unsigned long len, int flags)
380 if (start & ~TARGET_PAGE_MASK)
382 len = TARGET_PAGE_ALIGN(len);
389 start &= host_page_mask;
390 return msync((void *)start, end - start, flags);