4 * Copyright Fujitsu, Corp. 2011, 2012
7 * Wen Congyang <wency@cn.fujitsu.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
16 #include "qemu-common.h"
18 #include "sysemu/memory_mapping.h"
19 #include "exec/memory.h"
20 #include "exec/address-spaces.h"
22 //#define DEBUG_GUEST_PHYS_REGION_ADD
24 static void memory_mapping_list_add_mapping_sorted(MemoryMappingList
*list
,
25 MemoryMapping
*mapping
)
29 QTAILQ_FOREACH(p
, &list
->head
, next
) {
30 if (p
->phys_addr
>= mapping
->phys_addr
) {
31 QTAILQ_INSERT_BEFORE(p
, mapping
, next
);
35 QTAILQ_INSERT_TAIL(&list
->head
, mapping
, next
);
38 static void create_new_memory_mapping(MemoryMappingList
*list
,
43 MemoryMapping
*memory_mapping
;
45 memory_mapping
= g_malloc(sizeof(MemoryMapping
));
46 memory_mapping
->phys_addr
= phys_addr
;
47 memory_mapping
->virt_addr
= virt_addr
;
48 memory_mapping
->length
= length
;
49 list
->last_mapping
= memory_mapping
;
51 memory_mapping_list_add_mapping_sorted(list
, memory_mapping
);
54 static inline bool mapping_contiguous(MemoryMapping
*map
,
58 return phys_addr
== map
->phys_addr
+ map
->length
&&
59 virt_addr
== map
->virt_addr
+ map
->length
;
63 * [map->phys_addr, map->phys_addr + map->length) and
64 * [phys_addr, phys_addr + length) have intersection?
66 static inline bool mapping_have_same_region(MemoryMapping
*map
,
70 return !(phys_addr
+ length
< map
->phys_addr
||
71 phys_addr
>= map
->phys_addr
+ map
->length
);
75 * [map->phys_addr, map->phys_addr + map->length) and
76 * [phys_addr, phys_addr + length) have intersection. The virtual address in the
77 * intersection are the same?
79 static inline bool mapping_conflict(MemoryMapping
*map
,
83 return virt_addr
- map
->virt_addr
!= phys_addr
- map
->phys_addr
;
87 * [map->virt_addr, map->virt_addr + map->length) and
88 * [virt_addr, virt_addr + length) have intersection. And the physical address
89 * in the intersection are the same.
91 static inline void mapping_merge(MemoryMapping
*map
,
95 if (virt_addr
< map
->virt_addr
) {
96 map
->length
+= map
->virt_addr
- virt_addr
;
97 map
->virt_addr
= virt_addr
;
100 if ((virt_addr
+ length
) >
101 (map
->virt_addr
+ map
->length
)) {
102 map
->length
= virt_addr
+ length
- map
->virt_addr
;
106 void memory_mapping_list_add_merge_sorted(MemoryMappingList
*list
,
111 MemoryMapping
*memory_mapping
, *last_mapping
;
113 if (QTAILQ_EMPTY(&list
->head
)) {
114 create_new_memory_mapping(list
, phys_addr
, virt_addr
, length
);
118 last_mapping
= list
->last_mapping
;
120 if (mapping_contiguous(last_mapping
, phys_addr
, virt_addr
)) {
121 last_mapping
->length
+= length
;
126 QTAILQ_FOREACH(memory_mapping
, &list
->head
, next
) {
127 if (mapping_contiguous(memory_mapping
, phys_addr
, virt_addr
)) {
128 memory_mapping
->length
+= length
;
129 list
->last_mapping
= memory_mapping
;
133 if (phys_addr
+ length
< memory_mapping
->phys_addr
) {
134 /* create a new region before memory_mapping */
138 if (mapping_have_same_region(memory_mapping
, phys_addr
, length
)) {
139 if (mapping_conflict(memory_mapping
, phys_addr
, virt_addr
)) {
143 /* merge this region into memory_mapping */
144 mapping_merge(memory_mapping
, virt_addr
, length
);
145 list
->last_mapping
= memory_mapping
;
150 /* this region can not be merged into any existed memory mapping. */
151 create_new_memory_mapping(list
, phys_addr
, virt_addr
, length
);
154 void memory_mapping_list_free(MemoryMappingList
*list
)
156 MemoryMapping
*p
, *q
;
158 QTAILQ_FOREACH_SAFE(p
, &list
->head
, next
, q
) {
159 QTAILQ_REMOVE(&list
->head
, p
, next
);
164 list
->last_mapping
= NULL
;
167 void memory_mapping_list_init(MemoryMappingList
*list
)
170 list
->last_mapping
= NULL
;
171 QTAILQ_INIT(&list
->head
);
174 void guest_phys_blocks_free(GuestPhysBlockList
*list
)
176 GuestPhysBlock
*p
, *q
;
178 QTAILQ_FOREACH_SAFE(p
, &list
->head
, next
, q
) {
179 QTAILQ_REMOVE(&list
->head
, p
, next
);
185 void guest_phys_blocks_init(GuestPhysBlockList
*list
)
188 QTAILQ_INIT(&list
->head
);
191 typedef struct GuestPhysListener
{
192 GuestPhysBlockList
*list
;
193 MemoryListener listener
;
196 static void guest_phys_blocks_region_add(MemoryListener
*listener
,
197 MemoryRegionSection
*section
)
199 GuestPhysListener
*g
;
200 uint64_t section_size
;
201 hwaddr target_start
, target_end
;
203 GuestPhysBlock
*predecessor
;
205 /* we only care about RAM */
206 if (!memory_region_is_ram(section
->mr
) ||
207 memory_region_is_skip_dump(section
->mr
)) {
211 g
= container_of(listener
, GuestPhysListener
, listener
);
212 section_size
= int128_get64(section
->size
);
213 target_start
= section
->offset_within_address_space
;
214 target_end
= target_start
+ section_size
;
215 host_addr
= memory_region_get_ram_ptr(section
->mr
) +
216 section
->offset_within_region
;
219 /* find continuity in guest physical address space */
220 if (!QTAILQ_EMPTY(&g
->list
->head
)) {
221 hwaddr predecessor_size
;
223 predecessor
= QTAILQ_LAST(&g
->list
->head
, GuestPhysBlockHead
);
224 predecessor_size
= predecessor
->target_end
- predecessor
->target_start
;
226 /* the memory API guarantees monotonically increasing traversal */
227 g_assert(predecessor
->target_end
<= target_start
);
229 /* we want continuity in both guest-physical and host-virtual memory */
230 if (predecessor
->target_end
< target_start
||
231 predecessor
->host_addr
+ predecessor_size
!= host_addr
) {
236 if (predecessor
== NULL
) {
237 /* isolated mapping, allocate it and add it to the list */
238 GuestPhysBlock
*block
= g_malloc0(sizeof *block
);
240 block
->target_start
= target_start
;
241 block
->target_end
= target_end
;
242 block
->host_addr
= host_addr
;
244 QTAILQ_INSERT_TAIL(&g
->list
->head
, block
, next
);
247 /* expand predecessor until @target_end; predecessor's start doesn't
250 predecessor
->target_end
= target_end
;
253 #ifdef DEBUG_GUEST_PHYS_REGION_ADD
254 fprintf(stderr
, "%s: target_start=" TARGET_FMT_plx
" target_end="
255 TARGET_FMT_plx
": %s (count: %u)\n", __FUNCTION__
, target_start
,
256 target_end
, predecessor
? "joined" : "added", g
->list
->num
);
260 void guest_phys_blocks_append(GuestPhysBlockList
*list
)
262 GuestPhysListener g
= { 0 };
265 g
.listener
.region_add
= &guest_phys_blocks_region_add
;
266 memory_listener_register(&g
.listener
, &address_space_memory
);
267 memory_listener_unregister(&g
.listener
);
270 static CPUState
*find_paging_enabled_cpu(CPUState
*start_cpu
)
275 if (cpu_paging_enabled(cpu
)) {
283 void qemu_get_guest_memory_mapping(MemoryMappingList
*list
,
284 const GuestPhysBlockList
*guest_phys_blocks
,
287 CPUState
*cpu
, *first_paging_enabled_cpu
;
288 GuestPhysBlock
*block
;
289 ram_addr_t offset
, length
;
291 first_paging_enabled_cpu
= find_paging_enabled_cpu(first_cpu
);
292 if (first_paging_enabled_cpu
) {
293 for (cpu
= first_paging_enabled_cpu
; cpu
!= NULL
;
294 cpu
= CPU_NEXT(cpu
)) {
296 cpu_get_memory_mapping(cpu
, list
, &err
);
298 error_propagate(errp
, err
);
306 * If the guest doesn't use paging, the virtual address is equal to physical
309 QTAILQ_FOREACH(block
, &guest_phys_blocks
->head
, next
) {
310 offset
= block
->target_start
;
311 length
= block
->target_end
- block
->target_start
;
312 create_new_memory_mapping(list
, offset
, offset
, length
);
316 void qemu_get_guest_simple_memory_mapping(MemoryMappingList
*list
,
317 const GuestPhysBlockList
*guest_phys_blocks
)
319 GuestPhysBlock
*block
;
321 QTAILQ_FOREACH(block
, &guest_phys_blocks
->head
, next
) {
322 create_new_memory_mapping(list
, block
->target_start
, 0,
323 block
->target_end
- block
->target_start
);
327 void memory_mapping_filter(MemoryMappingList
*list
, int64_t begin
,
330 MemoryMapping
*cur
, *next
;
332 QTAILQ_FOREACH_SAFE(cur
, &list
->head
, next
, next
) {
333 if (cur
->phys_addr
>= begin
+ length
||
334 cur
->phys_addr
+ cur
->length
<= begin
) {
335 QTAILQ_REMOVE(&list
->head
, cur
, next
);
340 if (cur
->phys_addr
< begin
) {
341 cur
->length
-= begin
- cur
->phys_addr
;
342 if (cur
->virt_addr
) {
343 cur
->virt_addr
+= begin
- cur
->phys_addr
;
345 cur
->phys_addr
= begin
;
348 if (cur
->phys_addr
+ cur
->length
> begin
+ length
) {
349 cur
->length
-= cur
->phys_addr
+ cur
->length
- begin
- length
;