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__)
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
);