Revision a5b85f79 linux-user/mmap.c
b/linux-user/mmap.c | ||
---|---|---|
36 | 36 |
int prot1, ret; |
37 | 37 |
|
38 | 38 |
#ifdef DEBUG_MMAP |
39 |
printf("mprotect: start=0x%lx len=0x%lx prot=%c%c%c\n", start, len, |
|
39 |
printf("mprotect: start=0x" TARGET_FMT_lx |
|
40 |
"len=0x" TARGET_FMT_lx " prot=%c%c%c\n", start, len, |
|
40 | 41 |
prot & PROT_READ ? 'r' : '-', |
41 | 42 |
prot & PROT_WRITE ? 'w' : '-', |
42 | 43 |
prot & PROT_EXEC ? 'x' : '-'); |
... | ... | |
151 | 152 |
} |
152 | 153 |
|
153 | 154 |
/* NOTE: all the constants are the HOST ones */ |
154 |
long target_mmap(target_ulong start, target_ulong len, int prot, |
|
155 |
target_long target_mmap(target_ulong start, target_ulong len, int prot,
|
|
155 | 156 |
int flags, int fd, target_ulong offset) |
156 | 157 |
{ |
157 | 158 |
target_ulong ret, end, real_start, real_end, retaddr, host_offset, host_len; |
158 |
long host_start; |
|
159 |
unsigned long host_start;
|
|
159 | 160 |
#if defined(__alpha__) || defined(__sparc__) || defined(__x86_64__) || \ |
160 | 161 |
defined(__ia64) || defined(__mips__) |
161 | 162 |
static target_ulong last_start = 0x40000000; |
... | ... | |
166 | 167 |
|
167 | 168 |
#ifdef DEBUG_MMAP |
168 | 169 |
{ |
169 |
printf("mmap: start=0x%lx len=0x%lx prot=%c%c%c flags=", |
|
170 |
printf("mmap: start=0x" TARGET_FMT_lx |
|
171 |
" len=0x" TARGET_FMT_lx " prot=%c%c%c flags=", |
|
170 | 172 |
start, len, |
171 | 173 |
prot & PROT_READ ? 'r' : '-', |
172 | 174 |
prot & PROT_WRITE ? 'w' : '-', |
... | ... | |
186 | 188 |
printf("[MAP_TYPE=0x%x] ", flags & MAP_TYPE); |
187 | 189 |
break; |
188 | 190 |
} |
189 |
printf("fd=%d offset=%lx\n", fd, offset);
|
|
191 |
printf("fd=%d offset=" TARGET_FMT_lx "\n", fd, offset);
|
|
190 | 192 |
} |
191 | 193 |
#endif |
192 | 194 |
|
... | ... | |
209 | 211 |
last_start += HOST_PAGE_ALIGN(len); |
210 | 212 |
} |
211 | 213 |
#endif |
212 |
if (0 && qemu_host_page_size != qemu_real_host_page_size) { |
|
213 |
/* NOTE: this code is only for debugging with '-p' option */ |
|
214 |
/* ??? Can also occur when TARGET_PAGE_SIZE > host page size. */ |
|
215 |
/* reserve a memory area */ |
|
216 |
/* ??? This needs fixing for remapping. */ |
|
217 |
abort(); |
|
218 |
host_len = HOST_PAGE_ALIGN(len) + qemu_host_page_size - TARGET_PAGE_SIZE; |
|
219 |
real_start = (long)mmap(g2h(real_start), host_len, PROT_NONE, |
|
220 |
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); |
|
221 |
if (real_start == -1) |
|
222 |
return real_start; |
|
223 |
real_end = real_start + host_len; |
|
224 |
start = HOST_PAGE_ALIGN(real_start); |
|
225 |
end = start + HOST_PAGE_ALIGN(len); |
|
226 |
if (start > real_start) |
|
227 |
munmap((void *)g2h(real_start), start - real_start); |
|
228 |
if (end < real_end) |
|
229 |
munmap((void *)g2h(end), real_end - end); |
|
230 |
/* use it as a fixed mapping */ |
|
231 |
flags |= MAP_FIXED; |
|
232 |
} else { |
|
233 |
/* if not fixed, no need to do anything */ |
|
234 | 214 |
host_offset = offset & qemu_host_page_mask; |
235 | 215 |
host_len = len + offset - host_offset; |
216 |
|
|
217 |
if (qemu_host_page_size > qemu_real_host_page_size) { |
|
218 |
/* |
|
219 |
* The guest expects to see mmapped areas aligned to it's pagesize. |
|
220 |
* If the host's real page size is smaller than the guest's, we need |
|
221 |
* to fixup the maps. It is done by allocating a larger area, |
|
222 |
* displacing the map (if needed) and finally chopping off the spare |
|
223 |
* room at the edges. |
|
224 |
*/ |
|
225 |
|
|
226 |
/* |
|
227 |
* We assume qemu_host_page_size is always the same as |
|
228 |
* TARGET_PAGE_SIZE, see exec.c. qemu_real_host_page_size is the |
|
229 |
* hosts real page size. |
|
230 |
*/ |
|
231 |
target_ulong host_end; |
|
232 |
unsigned long host_aligned_start; |
|
233 |
|
|
234 |
host_len = HOST_PAGE_ALIGN(host_len + qemu_host_page_size |
|
235 |
- qemu_real_host_page_size); |
|
236 |
host_start = (unsigned long) mmap(real_start ? |
|
237 |
g2h(real_start) : NULL, |
|
238 |
host_len, prot, flags, |
|
239 |
fd, host_offset); |
|
240 |
if (host_start == -1) |
|
241 |
return -1; |
|
242 |
|
|
243 |
host_end = host_start + host_len; |
|
244 |
|
|
245 |
/* Find start and end, aligned to the targets pagesize with-in the |
|
246 |
large mmaped area. */ |
|
247 |
host_aligned_start = TARGET_PAGE_ALIGN(host_start); |
|
248 |
if (!(flags & MAP_ANONYMOUS)) |
|
249 |
host_aligned_start += offset - host_offset; |
|
250 |
|
|
251 |
start = h2g(host_aligned_start); |
|
252 |
end = start + TARGET_PAGE_ALIGN(len); |
|
253 |
|
|
254 |
/* Chop off the leftovers, if any. */ |
|
255 |
if (host_aligned_start > host_start) |
|
256 |
munmap((void *)host_start, host_aligned_start - host_start); |
|
257 |
if (end < host_end) |
|
258 |
munmap((void *)g2h(end), host_end - end); |
|
259 |
|
|
260 |
goto the_end1; |
|
261 |
} else { |
|
262 |
/* if not fixed, no need to do anything */ |
|
236 | 263 |
host_start = (long)mmap(real_start ? g2h(real_start) : NULL, |
237 | 264 |
host_len, prot, flags, fd, host_offset); |
238 | 265 |
if (host_start == -1) |
239 |
return host_start;
|
|
266 |
return -1;
|
|
240 | 267 |
/* update start so that it points to the file position at 'offset' */ |
241 | 268 |
if (!(flags & MAP_ANONYMOUS)) |
242 | 269 |
host_start += offset - host_offset; |
... | ... | |
267 | 294 |
MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, |
268 | 295 |
-1, 0); |
269 | 296 |
if (retaddr == -1) |
270 |
return retaddr;
|
|
297 |
return -1;
|
|
271 | 298 |
pread(fd, g2h(start), len, offset); |
272 | 299 |
if (!(prot & PROT_WRITE)) { |
273 | 300 |
ret = target_mprotect(start, len, prot); |
... | ... | |
300 | 327 |
prot, flags, fd, |
301 | 328 |
offset + real_end - qemu_host_page_size - start); |
302 | 329 |
if (ret == -1) |
303 |
return ret;
|
|
330 |
return -1;
|
|
304 | 331 |
real_end -= qemu_host_page_size; |
305 | 332 |
} |
306 | 333 |
|
... | ... | |
314 | 341 |
ret = (long)mmap(g2h(real_start), real_end - real_start, |
315 | 342 |
prot, flags, fd, offset1); |
316 | 343 |
if (ret == -1) |
317 |
return ret;
|
|
344 |
return -1;
|
|
318 | 345 |
} |
319 | 346 |
the_end1: |
320 | 347 |
page_set_flags(start, start + len, prot | PAGE_VALID); |
321 | 348 |
the_end: |
322 | 349 |
#ifdef DEBUG_MMAP |
323 |
printf("ret=0x%lx\n", (long)start);
|
|
350 |
printf("ret=0x%llx\n", start);
|
|
324 | 351 |
page_dump(stdout); |
325 | 352 |
printf("\n"); |
326 | 353 |
#endif |
... | ... | |
381 | 408 |
|
382 | 409 |
/* XXX: currently, we only handle MAP_ANONYMOUS and not MAP_FIXED |
383 | 410 |
blocks which have been allocated starting on a host page */ |
384 |
long target_mremap(target_ulong old_addr, target_ulong old_size, |
|
411 |
target_long target_mremap(target_ulong old_addr, target_ulong old_size,
|
|
385 | 412 |
target_ulong new_size, unsigned long flags, |
386 | 413 |
target_ulong new_addr) |
387 | 414 |
{ |
388 | 415 |
int prot; |
416 |
unsigned long host_addr; |
|
389 | 417 |
|
390 | 418 |
/* XXX: use 5 args syscall */ |
391 |
new_addr = (long)mremap(g2h(old_addr), old_size, new_size, flags);
|
|
392 |
if (new_addr == -1)
|
|
393 |
return new_addr;
|
|
394 |
new_addr = h2g(new_addr);
|
|
419 |
host_addr = (long)mremap(g2h(old_addr), old_size, new_size, flags);
|
|
420 |
if (host_addr == -1)
|
|
421 |
return -1;
|
|
422 |
new_addr = h2g(host_addr);
|
|
395 | 423 |
prot = page_get_flags(old_addr); |
396 | 424 |
page_set_flags(old_addr, old_addr + old_size, 0); |
397 | 425 |
page_set_flags(new_addr, new_addr + new_size, prot | PAGE_VALID); |
Also available in: Unified diff