Revision 17e2377a
b/Makefile | ||
---|---|---|
39 | 39 |
####################################################################### |
40 | 40 |
# BLOCK_OBJS is code used by both qemu system emulation and qemu-img |
41 | 41 |
|
42 |
BLOCK_OBJS=cutils.o |
|
42 |
BLOCK_OBJS=cutils.o qemu-malloc.o
|
|
43 | 43 |
BLOCK_OBJS+=block-cow.o block-qcow.o aes.o block-vmdk.o block-cloop.o |
44 | 44 |
BLOCK_OBJS+=block-dmg.o block-bochs.o block-vpc.o block-vvfat.o |
45 | 45 |
BLOCK_OBJS+=block-qcow2.o block-parallels.o |
b/Makefile.target | ||
---|---|---|
387 | 387 |
endif |
388 | 388 |
endif |
389 | 389 |
|
390 |
OBJS= main.o syscall.o strace.o mmap.o signal.o path.o osdep.o thunk.o \
|
|
390 |
OBJS= main.o syscall.o strace.o mmap.o signal.o path.o thunk.o \ |
|
391 | 391 |
elfload.o linuxload.o uaccess.o |
392 | 392 |
LIBS+= $(AIOLIBS) |
393 | 393 |
ifdef TARGET_HAS_BFLT |
... | ... | |
444 | 444 |
|
445 | 445 |
LIBS+=-lmx |
446 | 446 |
|
447 |
OBJS= main.o commpage.o machload.o mmap.o osdep.o signal.o syscall.o thunk.o
|
|
447 |
OBJS= main.o commpage.o machload.o mmap.o signal.o syscall.o thunk.o |
|
448 | 448 |
|
449 | 449 |
OBJS+= libqemu.a |
450 | 450 |
|
b/cutils.c | ||
---|---|---|
95 | 95 |
t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; |
96 | 96 |
return t; |
97 | 97 |
} |
98 |
|
|
99 |
void *get_mmap_addr(unsigned long size) |
|
100 |
{ |
|
101 |
return NULL; |
|
102 |
} |
|
103 |
|
|
104 |
void qemu_free(void *ptr) |
|
105 |
{ |
|
106 |
free(ptr); |
|
107 |
} |
|
108 |
|
|
109 |
void *qemu_malloc(size_t size) |
|
110 |
{ |
|
111 |
return malloc(size); |
|
112 |
} |
|
113 |
|
|
114 |
void *qemu_mallocz(size_t size) |
|
115 |
{ |
|
116 |
void *ptr; |
|
117 |
ptr = qemu_malloc(size); |
|
118 |
if (!ptr) |
|
119 |
return NULL; |
|
120 |
memset(ptr, 0, size); |
|
121 |
return ptr; |
|
122 |
} |
|
123 |
|
|
124 |
char *qemu_strdup(const char *str) |
|
125 |
{ |
|
126 |
char *ptr; |
|
127 |
ptr = qemu_malloc(strlen(str) + 1); |
|
128 |
if (!ptr) |
|
129 |
return NULL; |
|
130 |
strcpy(ptr, str); |
|
131 |
return ptr; |
|
132 |
} |
b/exec.c | ||
---|---|---|
263 | 263 |
{ |
264 | 264 |
PageDesc **lp, *p; |
265 | 265 |
|
266 |
#if TARGET_LONG_BITS > 32 |
|
267 |
/* Host memory outside guest VM. For 32-bit targets we have already |
|
268 |
excluded high addresses. */ |
|
269 |
if (index > ((target_ulong)L2_SIZE * L1_SIZE * TARGET_PAGE_SIZE)) |
|
270 |
return NULL; |
|
271 |
#endif |
|
266 | 272 |
lp = &l1_map[index >> L2_BITS]; |
267 | 273 |
p = *lp; |
268 | 274 |
if (!p) { |
269 | 275 |
/* allocate if not found */ |
270 |
p = qemu_malloc(sizeof(PageDesc) * L2_SIZE); |
|
271 |
memset(p, 0, sizeof(PageDesc) * L2_SIZE); |
|
276 |
#if defined(CONFIG_USER_ONLY) |
|
277 |
unsigned long addr; |
|
278 |
size_t len = sizeof(PageDesc) * L2_SIZE; |
|
279 |
/* Don't use qemu_malloc because it may recurse. */ |
|
280 |
p = mmap(0, len, PROT_READ | PROT_WRITE, |
|
281 |
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); |
|
282 |
*lp = p; |
|
283 |
addr = h2g(p); |
|
284 |
if (addr == (target_ulong)addr) { |
|
285 |
page_set_flags(addr & TARGET_PAGE_MASK, |
|
286 |
TARGET_PAGE_ALIGN(addr + len), |
|
287 |
PAGE_RESERVED); |
|
288 |
} |
|
289 |
#else |
|
290 |
p = qemu_mallocz(sizeof(PageDesc) * L2_SIZE); |
|
272 | 291 |
*lp = p; |
292 |
#endif |
|
273 | 293 |
} |
274 | 294 |
return p + (index & (L2_SIZE - 1)); |
275 | 295 |
} |
... | ... | |
1912 | 1932 |
flags |= PAGE_WRITE_ORG; |
1913 | 1933 |
for(addr = start; addr < end; addr += TARGET_PAGE_SIZE) { |
1914 | 1934 |
p = page_find_alloc(addr >> TARGET_PAGE_BITS); |
1935 |
/* We may be called for host regions that are outside guest |
|
1936 |
address space. */ |
|
1937 |
if (!p) |
|
1938 |
return; |
|
1915 | 1939 |
/* if the write protection is set, then we invalidate the code |
1916 | 1940 |
inside */ |
1917 | 1941 |
if (!(p->flags & PAGE_WRITE) && |
b/linux-user/mmap.c | ||
---|---|---|
73 | 73 |
} |
74 | 74 |
#endif |
75 | 75 |
|
76 |
void *qemu_vmalloc(size_t size) |
|
77 |
{ |
|
78 |
void *p; |
|
79 |
unsigned long addr; |
|
80 |
mmap_lock(); |
|
81 |
/* Use map and mark the pages as used. */ |
|
82 |
p = mmap(NULL, size, PROT_READ | PROT_WRITE, |
|
83 |
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); |
|
84 |
|
|
85 |
addr = (unsigned long)p; |
|
86 |
if (addr == (target_ulong) addr) { |
|
87 |
/* Allocated region overlaps guest address space. |
|
88 |
This may recurse. */ |
|
89 |
page_set_flags(addr & TARGET_PAGE_MASK, TARGET_PAGE_ALIGN(addr + size), |
|
90 |
PAGE_RESERVED); |
|
91 |
} |
|
92 |
|
|
93 |
mmap_unlock(); |
|
94 |
return p; |
|
95 |
} |
|
96 |
|
|
97 |
void *qemu_malloc(size_t size) |
|
98 |
{ |
|
99 |
char * p; |
|
100 |
size += 16; |
|
101 |
p = qemu_vmalloc(size); |
|
102 |
*(size_t *)p = size; |
|
103 |
return p + 16; |
|
104 |
} |
|
105 |
|
|
106 |
/* We use map, which is always zero initialized. */ |
|
107 |
void * qemu_mallocz(size_t size) |
|
108 |
{ |
|
109 |
return qemu_malloc(size); |
|
110 |
} |
|
111 |
|
|
112 |
void qemu_free(void *ptr) |
|
113 |
{ |
|
114 |
/* FIXME: We should unmark the reserved pages here. However this gets |
|
115 |
complicated when one target page spans multiple host pages, so we |
|
116 |
don't bother. */ |
|
117 |
size_t *p; |
|
118 |
p = (size_t *)((char *)ptr - 16); |
|
119 |
munmap(p, *p); |
|
120 |
} |
|
121 |
|
|
76 | 122 |
/* NOTE: all the constants are the HOST ones, but addresses are target. */ |
77 | 123 |
int target_mprotect(abi_ulong start, abi_ulong len, int prot) |
78 | 124 |
{ |
b/qemu-malloc.c | ||
---|---|---|
1 |
/* |
|
2 |
* malloc-like functions for system emulation. |
|
3 |
* |
|
4 |
* Copyright (c) 2006 Fabrice Bellard |
|
5 |
* |
|
6 |
* Permission is hereby granted, free of charge, to any person obtaining a copy |
|
7 |
* of this software and associated documentation files (the "Software"), to deal |
|
8 |
* in the Software without restriction, including without limitation the rights |
|
9 |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
10 |
* copies of the Software, and to permit persons to whom the Software is |
|
11 |
* furnished to do so, subject to the following conditions: |
|
12 |
* |
|
13 |
* The above copyright notice and this permission notice shall be included in |
|
14 |
* all copies or substantial portions of the Software. |
|
15 |
* |
|
16 |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
17 |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
18 |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
|
19 |
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
20 |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
21 |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|
22 |
* THE SOFTWARE. |
|
23 |
*/ |
|
24 |
#include "qemu-common.h" |
|
25 |
|
|
26 |
void *get_mmap_addr(unsigned long size) |
|
27 |
{ |
|
28 |
return NULL; |
|
29 |
} |
|
30 |
|
|
31 |
void qemu_free(void *ptr) |
|
32 |
{ |
|
33 |
free(ptr); |
|
34 |
} |
|
35 |
|
|
36 |
void *qemu_malloc(size_t size) |
|
37 |
{ |
|
38 |
return malloc(size); |
|
39 |
} |
|
40 |
|
|
41 |
void *qemu_mallocz(size_t size) |
|
42 |
{ |
|
43 |
void *ptr; |
|
44 |
ptr = qemu_malloc(size); |
|
45 |
if (!ptr) |
|
46 |
return NULL; |
|
47 |
memset(ptr, 0, size); |
|
48 |
return ptr; |
|
49 |
} |
|
50 |
|
|
51 |
char *qemu_strdup(const char *str) |
|
52 |
{ |
|
53 |
char *ptr; |
|
54 |
ptr = qemu_malloc(strlen(str) + 1); |
|
55 |
if (!ptr) |
|
56 |
return NULL; |
|
57 |
strcpy(ptr, str); |
|
58 |
return ptr; |
|
59 |
} |
Also available in: Unified diff