2 * Physical memory management
4 * Copyright 2011 Red Hat, Inc. and/or its affiliates
7 * Avi Kivity <avi@redhat.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
15 #include "exec-memory.h"
21 #define WANT_EXEC_OBSOLETE
22 #include "exec-obsolete.h"
24 unsigned memory_region_transaction_depth
= 0;
25 static bool memory_region_update_pending
= false;
26 static bool global_dirty_log
= false;
28 static QLIST_HEAD(, MemoryListener
) memory_listeners
29 = QLIST_HEAD_INITIALIZER(memory_listeners
);
31 typedef struct AddrRange AddrRange
;
34 * Note using signed integers limits us to physical addresses at most
35 * 63 bits wide. They are needed for negative offsetting in aliases
36 * (large MemoryRegion::alias_offset).
43 static AddrRange
addrrange_make(Int128 start
, Int128 size
)
45 return (AddrRange
) { start
, size
};
48 static bool addrrange_equal(AddrRange r1
, AddrRange r2
)
50 return int128_eq(r1
.start
, r2
.start
) && int128_eq(r1
.size
, r2
.size
);
53 static Int128
addrrange_end(AddrRange r
)
55 return int128_add(r
.start
, r
.size
);
58 static AddrRange
addrrange_shift(AddrRange range
, Int128 delta
)
60 int128_addto(&range
.start
, delta
);
64 static bool addrrange_contains(AddrRange range
, Int128 addr
)
66 return int128_ge(addr
, range
.start
)
67 && int128_lt(addr
, addrrange_end(range
));
70 static bool addrrange_intersects(AddrRange r1
, AddrRange r2
)
72 return addrrange_contains(r1
, r2
.start
)
73 || addrrange_contains(r2
, r1
.start
);
76 static AddrRange
addrrange_intersection(AddrRange r1
, AddrRange r2
)
78 Int128 start
= int128_max(r1
.start
, r2
.start
);
79 Int128 end
= int128_min(addrrange_end(r1
), addrrange_end(r2
));
80 return addrrange_make(start
, int128_sub(end
, start
));
83 struct CoalescedMemoryRange
{
85 QTAILQ_ENTRY(CoalescedMemoryRange
) link
;
88 struct MemoryRegionIoeventfd
{
95 static bool memory_region_ioeventfd_before(MemoryRegionIoeventfd a
,
96 MemoryRegionIoeventfd b
)
98 if (int128_lt(a
.addr
.start
, b
.addr
.start
)) {
100 } else if (int128_gt(a
.addr
.start
, b
.addr
.start
)) {
102 } else if (int128_lt(a
.addr
.size
, b
.addr
.size
)) {
104 } else if (int128_gt(a
.addr
.size
, b
.addr
.size
)) {
106 } else if (a
.match_data
< b
.match_data
) {
108 } else if (a
.match_data
> b
.match_data
) {
110 } else if (a
.match_data
) {
111 if (a
.data
< b
.data
) {
113 } else if (a
.data
> b
.data
) {
119 } else if (a
.fd
> b
.fd
) {
125 static bool memory_region_ioeventfd_equal(MemoryRegionIoeventfd a
,
126 MemoryRegionIoeventfd b
)
128 return !memory_region_ioeventfd_before(a
, b
)
129 && !memory_region_ioeventfd_before(b
, a
);
132 typedef struct FlatRange FlatRange
;
133 typedef struct FlatView FlatView
;
135 /* Range of memory in the global map. Addresses are absolute. */
138 target_phys_addr_t offset_in_region
;
140 uint8_t dirty_log_mask
;
145 /* Flattened global view of current active memory hierarchy. Kept in sorted
151 unsigned nr_allocated
;
154 typedef struct AddressSpace AddressSpace
;
155 typedef struct AddressSpaceOps AddressSpaceOps
;
157 /* A system address space - I/O, memory, etc. */
158 struct AddressSpace
{
159 const AddressSpaceOps
*ops
;
161 FlatView current_map
;
163 MemoryRegionIoeventfd
*ioeventfds
;
166 struct AddressSpaceOps
{
167 void (*range_add
)(AddressSpace
*as
, FlatRange
*fr
);
168 void (*range_del
)(AddressSpace
*as
, FlatRange
*fr
);
169 void (*log_start
)(AddressSpace
*as
, FlatRange
*fr
);
170 void (*log_stop
)(AddressSpace
*as
, FlatRange
*fr
);
171 void (*ioeventfd_add
)(AddressSpace
*as
, MemoryRegionIoeventfd
*fd
);
172 void (*ioeventfd_del
)(AddressSpace
*as
, MemoryRegionIoeventfd
*fd
);
175 #define FOR_EACH_FLAT_RANGE(var, view) \
176 for (var = (view)->ranges; var < (view)->ranges + (view)->nr; ++var)
178 static bool flatrange_equal(FlatRange
*a
, FlatRange
*b
)
180 return a
->mr
== b
->mr
181 && addrrange_equal(a
->addr
, b
->addr
)
182 && a
->offset_in_region
== b
->offset_in_region
183 && a
->readable
== b
->readable
184 && a
->readonly
== b
->readonly
;
187 static void flatview_init(FlatView
*view
)
191 view
->nr_allocated
= 0;
194 /* Insert a range into a given position. Caller is responsible for maintaining
197 static void flatview_insert(FlatView
*view
, unsigned pos
, FlatRange
*range
)
199 if (view
->nr
== view
->nr_allocated
) {
200 view
->nr_allocated
= MAX(2 * view
->nr
, 10);
201 view
->ranges
= g_realloc(view
->ranges
,
202 view
->nr_allocated
* sizeof(*view
->ranges
));
204 memmove(view
->ranges
+ pos
+ 1, view
->ranges
+ pos
,
205 (view
->nr
- pos
) * sizeof(FlatRange
));
206 view
->ranges
[pos
] = *range
;
210 static void flatview_destroy(FlatView
*view
)
212 g_free(view
->ranges
);
215 static bool can_merge(FlatRange
*r1
, FlatRange
*r2
)
217 return int128_eq(addrrange_end(r1
->addr
), r2
->addr
.start
)
219 && int128_eq(int128_add(int128_make64(r1
->offset_in_region
),
221 int128_make64(r2
->offset_in_region
))
222 && r1
->dirty_log_mask
== r2
->dirty_log_mask
223 && r1
->readable
== r2
->readable
224 && r1
->readonly
== r2
->readonly
;
227 /* Attempt to simplify a view by merging ajacent ranges */
228 static void flatview_simplify(FlatView
*view
)
233 while (i
< view
->nr
) {
236 && can_merge(&view
->ranges
[j
-1], &view
->ranges
[j
])) {
237 int128_addto(&view
->ranges
[i
].addr
.size
, view
->ranges
[j
].addr
.size
);
241 memmove(&view
->ranges
[i
], &view
->ranges
[j
],
242 (view
->nr
- j
) * sizeof(view
->ranges
[j
]));
247 static void memory_region_read_accessor(void *opaque
,
248 target_phys_addr_t addr
,
254 MemoryRegion
*mr
= opaque
;
257 tmp
= mr
->ops
->read(mr
->opaque
, addr
, size
);
258 *value
|= (tmp
& mask
) << shift
;
261 static void memory_region_write_accessor(void *opaque
,
262 target_phys_addr_t addr
,
268 MemoryRegion
*mr
= opaque
;
271 tmp
= (*value
>> shift
) & mask
;
272 mr
->ops
->write(mr
->opaque
, addr
, tmp
, size
);
275 static void access_with_adjusted_size(target_phys_addr_t addr
,
278 unsigned access_size_min
,
279 unsigned access_size_max
,
280 void (*access
)(void *opaque
,
281 target_phys_addr_t addr
,
288 uint64_t access_mask
;
289 unsigned access_size
;
292 if (!access_size_min
) {
295 if (!access_size_max
) {
298 access_size
= MAX(MIN(size
, access_size_max
), access_size_min
);
299 access_mask
= -1ULL >> (64 - access_size
* 8);
300 for (i
= 0; i
< size
; i
+= access_size
) {
301 /* FIXME: big-endian support */
302 access(opaque
, addr
+ i
, value
, access_size
, i
* 8, access_mask
);
306 static void memory_region_prepare_ram_addr(MemoryRegion
*mr
);
308 static void as_memory_range_add(AddressSpace
*as
, FlatRange
*fr
)
310 ram_addr_t phys_offset
, region_offset
;
312 memory_region_prepare_ram_addr(fr
->mr
);
314 phys_offset
= fr
->mr
->ram_addr
;
315 region_offset
= fr
->offset_in_region
;
316 /* cpu_register_physical_memory_log() wants region_offset for
317 * mmio, but prefers offseting phys_offset for RAM. Humour it.
319 if ((phys_offset
& ~TARGET_PAGE_MASK
) <= IO_MEM_ROM
) {
320 phys_offset
+= region_offset
;
325 phys_offset
&= ~TARGET_PAGE_MASK
& ~IO_MEM_ROMD
;
329 phys_offset
|= IO_MEM_ROM
;
332 cpu_register_physical_memory_log(int128_get64(fr
->addr
.start
),
333 int128_get64(fr
->addr
.size
),
339 static void as_memory_range_del(AddressSpace
*as
, FlatRange
*fr
)
341 if (fr
->dirty_log_mask
) {
342 Int128 end
= addrrange_end(fr
->addr
);
343 cpu_physical_sync_dirty_bitmap(int128_get64(fr
->addr
.start
),
346 cpu_register_physical_memory(int128_get64(fr
->addr
.start
),
347 int128_get64(fr
->addr
.size
),
351 static void as_memory_log_start(AddressSpace
*as
, FlatRange
*fr
)
353 cpu_physical_log_start(int128_get64(fr
->addr
.start
),
354 int128_get64(fr
->addr
.size
));
357 static void as_memory_log_stop(AddressSpace
*as
, FlatRange
*fr
)
359 cpu_physical_log_stop(int128_get64(fr
->addr
.start
),
360 int128_get64(fr
->addr
.size
));
363 static void as_memory_ioeventfd_add(AddressSpace
*as
, MemoryRegionIoeventfd
*fd
)
367 assert(fd
->match_data
&& int128_get64(fd
->addr
.size
) == 4);
369 r
= kvm_set_ioeventfd_mmio_long(fd
->fd
, int128_get64(fd
->addr
.start
),
376 static void as_memory_ioeventfd_del(AddressSpace
*as
, MemoryRegionIoeventfd
*fd
)
380 r
= kvm_set_ioeventfd_mmio_long(fd
->fd
, int128_get64(fd
->addr
.start
),
387 static const AddressSpaceOps address_space_ops_memory
= {
388 .range_add
= as_memory_range_add
,
389 .range_del
= as_memory_range_del
,
390 .log_start
= as_memory_log_start
,
391 .log_stop
= as_memory_log_stop
,
392 .ioeventfd_add
= as_memory_ioeventfd_add
,
393 .ioeventfd_del
= as_memory_ioeventfd_del
,
396 static AddressSpace address_space_memory
= {
397 .ops
= &address_space_ops_memory
,
400 static const MemoryRegionPortio
*find_portio(MemoryRegion
*mr
, uint64_t offset
,
401 unsigned width
, bool write
)
403 const MemoryRegionPortio
*mrp
;
405 for (mrp
= mr
->ops
->old_portio
; mrp
->size
; ++mrp
) {
406 if (offset
>= mrp
->offset
&& offset
< mrp
->offset
+ mrp
->len
407 && width
== mrp
->size
408 && (write
? (bool)mrp
->write
: (bool)mrp
->read
)) {
415 static void memory_region_iorange_read(IORange
*iorange
,
420 MemoryRegion
*mr
= container_of(iorange
, MemoryRegion
, iorange
);
422 if (mr
->ops
->old_portio
) {
423 const MemoryRegionPortio
*mrp
= find_portio(mr
, offset
, width
, false);
425 *data
= ((uint64_t)1 << (width
* 8)) - 1;
427 *data
= mrp
->read(mr
->opaque
, offset
+ mr
->offset
);
428 } else if (width
== 2) {
429 mrp
= find_portio(mr
, offset
, 1, false);
431 *data
= mrp
->read(mr
->opaque
, offset
+ mr
->offset
) |
432 (mrp
->read(mr
->opaque
, offset
+ mr
->offset
+ 1) << 8);
437 access_with_adjusted_size(offset
+ mr
->offset
, data
, width
,
438 mr
->ops
->impl
.min_access_size
,
439 mr
->ops
->impl
.max_access_size
,
440 memory_region_read_accessor
, mr
);
443 static void memory_region_iorange_write(IORange
*iorange
,
448 MemoryRegion
*mr
= container_of(iorange
, MemoryRegion
, iorange
);
450 if (mr
->ops
->old_portio
) {
451 const MemoryRegionPortio
*mrp
= find_portio(mr
, offset
, width
, true);
454 mrp
->write(mr
->opaque
, offset
+ mr
->offset
, data
);
455 } else if (width
== 2) {
456 mrp
= find_portio(mr
, offset
, 1, false);
458 mrp
->write(mr
->opaque
, offset
+ mr
->offset
, data
& 0xff);
459 mrp
->write(mr
->opaque
, offset
+ mr
->offset
+ 1, data
>> 8);
463 access_with_adjusted_size(offset
+ mr
->offset
, &data
, width
,
464 mr
->ops
->impl
.min_access_size
,
465 mr
->ops
->impl
.max_access_size
,
466 memory_region_write_accessor
, mr
);
469 static const IORangeOps memory_region_iorange_ops
= {
470 .read
= memory_region_iorange_read
,
471 .write
= memory_region_iorange_write
,
474 static void as_io_range_add(AddressSpace
*as
, FlatRange
*fr
)
476 iorange_init(&fr
->mr
->iorange
, &memory_region_iorange_ops
,
477 int128_get64(fr
->addr
.start
), int128_get64(fr
->addr
.size
));
478 ioport_register(&fr
->mr
->iorange
);
481 static void as_io_range_del(AddressSpace
*as
, FlatRange
*fr
)
483 isa_unassign_ioport(int128_get64(fr
->addr
.start
),
484 int128_get64(fr
->addr
.size
));
487 static void as_io_ioeventfd_add(AddressSpace
*as
, MemoryRegionIoeventfd
*fd
)
491 assert(fd
->match_data
&& int128_get64(fd
->addr
.size
) == 2);
493 r
= kvm_set_ioeventfd_pio_word(fd
->fd
, int128_get64(fd
->addr
.start
),
500 static void as_io_ioeventfd_del(AddressSpace
*as
, MemoryRegionIoeventfd
*fd
)
504 r
= kvm_set_ioeventfd_pio_word(fd
->fd
, int128_get64(fd
->addr
.start
),
511 static const AddressSpaceOps address_space_ops_io
= {
512 .range_add
= as_io_range_add
,
513 .range_del
= as_io_range_del
,
514 .ioeventfd_add
= as_io_ioeventfd_add
,
515 .ioeventfd_del
= as_io_ioeventfd_del
,
518 static AddressSpace address_space_io
= {
519 .ops
= &address_space_ops_io
,
522 static AddressSpace
*memory_region_to_address_space(MemoryRegion
*mr
)
527 if (mr
== address_space_memory
.root
) {
528 return &address_space_memory
;
530 if (mr
== address_space_io
.root
) {
531 return &address_space_io
;
536 /* Render a memory region into the global view. Ranges in @view obscure
539 static void render_memory_region(FlatView
*view
,
545 MemoryRegion
*subregion
;
547 target_phys_addr_t offset_in_region
;
557 int128_addto(&base
, int128_make64(mr
->addr
));
558 readonly
|= mr
->readonly
;
560 tmp
= addrrange_make(base
, mr
->size
);
562 if (!addrrange_intersects(tmp
, clip
)) {
566 clip
= addrrange_intersection(tmp
, clip
);
569 int128_subfrom(&base
, int128_make64(mr
->alias
->addr
));
570 int128_subfrom(&base
, int128_make64(mr
->alias_offset
));
571 render_memory_region(view
, mr
->alias
, base
, clip
, readonly
);
575 /* Render subregions in priority order. */
576 QTAILQ_FOREACH(subregion
, &mr
->subregions
, subregions_link
) {
577 render_memory_region(view
, subregion
, base
, clip
, readonly
);
580 if (!mr
->terminates
) {
584 offset_in_region
= int128_get64(int128_sub(clip
.start
, base
));
588 /* Render the region itself into any gaps left by the current view. */
589 for (i
= 0; i
< view
->nr
&& int128_nz(remain
); ++i
) {
590 if (int128_ge(base
, addrrange_end(view
->ranges
[i
].addr
))) {
593 if (int128_lt(base
, view
->ranges
[i
].addr
.start
)) {
594 now
= int128_min(remain
,
595 int128_sub(view
->ranges
[i
].addr
.start
, base
));
597 fr
.offset_in_region
= offset_in_region
;
598 fr
.addr
= addrrange_make(base
, now
);
599 fr
.dirty_log_mask
= mr
->dirty_log_mask
;
600 fr
.readable
= mr
->readable
;
601 fr
.readonly
= readonly
;
602 flatview_insert(view
, i
, &fr
);
604 int128_addto(&base
, now
);
605 offset_in_region
+= int128_get64(now
);
606 int128_subfrom(&remain
, now
);
608 if (int128_eq(base
, view
->ranges
[i
].addr
.start
)) {
609 now
= int128_min(remain
, view
->ranges
[i
].addr
.size
);
610 int128_addto(&base
, now
);
611 offset_in_region
+= int128_get64(now
);
612 int128_subfrom(&remain
, now
);
615 if (int128_nz(remain
)) {
617 fr
.offset_in_region
= offset_in_region
;
618 fr
.addr
= addrrange_make(base
, remain
);
619 fr
.dirty_log_mask
= mr
->dirty_log_mask
;
620 fr
.readable
= mr
->readable
;
621 fr
.readonly
= readonly
;
622 flatview_insert(view
, i
, &fr
);
626 /* Render a memory topology into a list of disjoint absolute ranges. */
627 static FlatView
generate_memory_topology(MemoryRegion
*mr
)
631 flatview_init(&view
);
633 render_memory_region(&view
, mr
, int128_zero(),
634 addrrange_make(int128_zero(), int128_2_64()), false);
635 flatview_simplify(&view
);
640 static void address_space_add_del_ioeventfds(AddressSpace
*as
,
641 MemoryRegionIoeventfd
*fds_new
,
643 MemoryRegionIoeventfd
*fds_old
,
648 /* Generate a symmetric difference of the old and new fd sets, adding
649 * and deleting as necessary.
653 while (iold
< fds_old_nb
|| inew
< fds_new_nb
) {
654 if (iold
< fds_old_nb
655 && (inew
== fds_new_nb
656 || memory_region_ioeventfd_before(fds_old
[iold
],
658 as
->ops
->ioeventfd_del(as
, &fds_old
[iold
]);
660 } else if (inew
< fds_new_nb
661 && (iold
== fds_old_nb
662 || memory_region_ioeventfd_before(fds_new
[inew
],
664 as
->ops
->ioeventfd_add(as
, &fds_new
[inew
]);
673 static void address_space_update_ioeventfds(AddressSpace
*as
)
676 unsigned ioeventfd_nb
= 0;
677 MemoryRegionIoeventfd
*ioeventfds
= NULL
;
681 FOR_EACH_FLAT_RANGE(fr
, &as
->current_map
) {
682 for (i
= 0; i
< fr
->mr
->ioeventfd_nb
; ++i
) {
683 tmp
= addrrange_shift(fr
->mr
->ioeventfds
[i
].addr
,
684 int128_sub(fr
->addr
.start
,
685 int128_make64(fr
->offset_in_region
)));
686 if (addrrange_intersects(fr
->addr
, tmp
)) {
688 ioeventfds
= g_realloc(ioeventfds
,
689 ioeventfd_nb
* sizeof(*ioeventfds
));
690 ioeventfds
[ioeventfd_nb
-1] = fr
->mr
->ioeventfds
[i
];
691 ioeventfds
[ioeventfd_nb
-1].addr
= tmp
;
696 address_space_add_del_ioeventfds(as
, ioeventfds
, ioeventfd_nb
,
697 as
->ioeventfds
, as
->ioeventfd_nb
);
699 g_free(as
->ioeventfds
);
700 as
->ioeventfds
= ioeventfds
;
701 as
->ioeventfd_nb
= ioeventfd_nb
;
704 typedef void ListenerCallback(MemoryListener
*listener
,
705 MemoryRegionSection
*mrs
);
707 /* Want "void (&MemoryListener::*callback)(const MemoryRegionSection& s)" */
708 static void memory_listener_update_region(FlatRange
*fr
, AddressSpace
*as
,
709 size_t callback_offset
)
711 MemoryRegionSection section
= {
713 .address_space
= as
->root
,
714 .offset_within_region
= fr
->offset_in_region
,
715 .size
= int128_get64(fr
->addr
.size
),
716 .offset_within_address_space
= int128_get64(fr
->addr
.start
),
718 MemoryListener
*listener
;
720 QLIST_FOREACH(listener
, &memory_listeners
, link
) {
721 ListenerCallback
*callback
722 = *(ListenerCallback
**)((void *)listener
+ callback_offset
);
723 callback(listener
, §ion
);
727 #define MEMORY_LISTENER_UPDATE_REGION(fr, as, callback) \
728 memory_listener_update_region(fr, as, offsetof(MemoryListener, callback))
730 static void address_space_update_topology_pass(AddressSpace
*as
,
736 FlatRange
*frold
, *frnew
;
738 /* Generate a symmetric difference of the old and new memory maps.
739 * Kill ranges in the old map, and instantiate ranges in the new map.
742 while (iold
< old_view
.nr
|| inew
< new_view
.nr
) {
743 if (iold
< old_view
.nr
) {
744 frold
= &old_view
.ranges
[iold
];
748 if (inew
< new_view
.nr
) {
749 frnew
= &new_view
.ranges
[inew
];
756 || int128_lt(frold
->addr
.start
, frnew
->addr
.start
)
757 || (int128_eq(frold
->addr
.start
, frnew
->addr
.start
)
758 && !flatrange_equal(frold
, frnew
)))) {
759 /* In old, but (not in new, or in new but attributes changed). */
762 MEMORY_LISTENER_UPDATE_REGION(frold
, as
, region_del
);
763 as
->ops
->range_del(as
, frold
);
767 } else if (frold
&& frnew
&& flatrange_equal(frold
, frnew
)) {
768 /* In both (logging may have changed) */
771 if (frold
->dirty_log_mask
&& !frnew
->dirty_log_mask
) {
772 MEMORY_LISTENER_UPDATE_REGION(frnew
, as
, log_stop
);
773 as
->ops
->log_stop(as
, frnew
);
774 } else if (frnew
->dirty_log_mask
&& !frold
->dirty_log_mask
) {
775 as
->ops
->log_start(as
, frnew
);
776 MEMORY_LISTENER_UPDATE_REGION(frnew
, as
, log_start
);
786 as
->ops
->range_add(as
, frnew
);
787 MEMORY_LISTENER_UPDATE_REGION(frnew
, as
, region_add
);
796 static void address_space_update_topology(AddressSpace
*as
)
798 FlatView old_view
= as
->current_map
;
799 FlatView new_view
= generate_memory_topology(as
->root
);
801 address_space_update_topology_pass(as
, old_view
, new_view
, false);
802 address_space_update_topology_pass(as
, old_view
, new_view
, true);
804 as
->current_map
= new_view
;
805 flatview_destroy(&old_view
);
806 address_space_update_ioeventfds(as
);
809 static void memory_region_update_topology(MemoryRegion
*mr
)
811 if (memory_region_transaction_depth
) {
812 memory_region_update_pending
|= !mr
|| mr
->enabled
;
816 if (mr
&& !mr
->enabled
) {
820 if (address_space_memory
.root
) {
821 address_space_update_topology(&address_space_memory
);
823 if (address_space_io
.root
) {
824 address_space_update_topology(&address_space_io
);
827 memory_region_update_pending
= false;
830 void memory_region_transaction_begin(void)
832 ++memory_region_transaction_depth
;
835 void memory_region_transaction_commit(void)
837 assert(memory_region_transaction_depth
);
838 --memory_region_transaction_depth
;
839 if (!memory_region_transaction_depth
&& memory_region_update_pending
) {
840 memory_region_update_topology(NULL
);
844 static void memory_region_destructor_none(MemoryRegion
*mr
)
848 static void memory_region_destructor_ram(MemoryRegion
*mr
)
850 qemu_ram_free(mr
->ram_addr
);
853 static void memory_region_destructor_ram_from_ptr(MemoryRegion
*mr
)
855 qemu_ram_free_from_ptr(mr
->ram_addr
);
858 static void memory_region_destructor_iomem(MemoryRegion
*mr
)
860 cpu_unregister_io_memory(mr
->ram_addr
);
863 static void memory_region_destructor_rom_device(MemoryRegion
*mr
)
865 qemu_ram_free(mr
->ram_addr
& TARGET_PAGE_MASK
);
866 cpu_unregister_io_memory(mr
->ram_addr
& ~(TARGET_PAGE_MASK
| IO_MEM_ROMD
));
869 void memory_region_init(MemoryRegion
*mr
,
875 mr
->size
= int128_make64(size
);
876 if (size
== UINT64_MAX
) {
877 mr
->size
= int128_2_64();
882 mr
->terminates
= false;
885 mr
->readonly
= false;
886 mr
->destructor
= memory_region_destructor_none
;
888 mr
->may_overlap
= false;
890 QTAILQ_INIT(&mr
->subregions
);
891 memset(&mr
->subregions_link
, 0, sizeof mr
->subregions_link
);
892 QTAILQ_INIT(&mr
->coalesced
);
893 mr
->name
= g_strdup(name
);
894 mr
->dirty_log_mask
= 0;
895 mr
->ioeventfd_nb
= 0;
896 mr
->ioeventfds
= NULL
;
899 static bool memory_region_access_valid(MemoryRegion
*mr
,
900 target_phys_addr_t addr
,
904 if (mr
->ops
->valid
.accepts
905 && !mr
->ops
->valid
.accepts(mr
->opaque
, addr
, size
, is_write
)) {
909 if (!mr
->ops
->valid
.unaligned
&& (addr
& (size
- 1))) {
913 /* Treat zero as compatibility all valid */
914 if (!mr
->ops
->valid
.max_access_size
) {
918 if (size
> mr
->ops
->valid
.max_access_size
919 || size
< mr
->ops
->valid
.min_access_size
) {
925 static uint32_t memory_region_read_thunk_n(void *_mr
,
926 target_phys_addr_t addr
,
929 MemoryRegion
*mr
= _mr
;
932 if (!memory_region_access_valid(mr
, addr
, size
, false)) {
933 return -1U; /* FIXME: better signalling */
936 if (!mr
->ops
->read
) {
937 return mr
->ops
->old_mmio
.read
[bitops_ffsl(size
)](mr
->opaque
, addr
);
940 /* FIXME: support unaligned access */
941 access_with_adjusted_size(addr
+ mr
->offset
, &data
, size
,
942 mr
->ops
->impl
.min_access_size
,
943 mr
->ops
->impl
.max_access_size
,
944 memory_region_read_accessor
, mr
);
949 static void memory_region_write_thunk_n(void *_mr
,
950 target_phys_addr_t addr
,
954 MemoryRegion
*mr
= _mr
;
956 if (!memory_region_access_valid(mr
, addr
, size
, true)) {
957 return; /* FIXME: better signalling */
960 if (!mr
->ops
->write
) {
961 mr
->ops
->old_mmio
.write
[bitops_ffsl(size
)](mr
->opaque
, addr
, data
);
965 /* FIXME: support unaligned access */
966 access_with_adjusted_size(addr
+ mr
->offset
, &data
, size
,
967 mr
->ops
->impl
.min_access_size
,
968 mr
->ops
->impl
.max_access_size
,
969 memory_region_write_accessor
, mr
);
972 static uint32_t memory_region_read_thunk_b(void *mr
, target_phys_addr_t addr
)
974 return memory_region_read_thunk_n(mr
, addr
, 1);
977 static uint32_t memory_region_read_thunk_w(void *mr
, target_phys_addr_t addr
)
979 return memory_region_read_thunk_n(mr
, addr
, 2);
982 static uint32_t memory_region_read_thunk_l(void *mr
, target_phys_addr_t addr
)
984 return memory_region_read_thunk_n(mr
, addr
, 4);
987 static void memory_region_write_thunk_b(void *mr
, target_phys_addr_t addr
,
990 memory_region_write_thunk_n(mr
, addr
, 1, data
);
993 static void memory_region_write_thunk_w(void *mr
, target_phys_addr_t addr
,
996 memory_region_write_thunk_n(mr
, addr
, 2, data
);
999 static void memory_region_write_thunk_l(void *mr
, target_phys_addr_t addr
,
1002 memory_region_write_thunk_n(mr
, addr
, 4, data
);
1005 static CPUReadMemoryFunc
* const memory_region_read_thunk
[] = {
1006 memory_region_read_thunk_b
,
1007 memory_region_read_thunk_w
,
1008 memory_region_read_thunk_l
,
1011 static CPUWriteMemoryFunc
* const memory_region_write_thunk
[] = {
1012 memory_region_write_thunk_b
,
1013 memory_region_write_thunk_w
,
1014 memory_region_write_thunk_l
,
1017 static void memory_region_prepare_ram_addr(MemoryRegion
*mr
)
1019 if (mr
->backend_registered
) {
1023 mr
->destructor
= memory_region_destructor_iomem
;
1024 mr
->ram_addr
= cpu_register_io_memory(memory_region_read_thunk
,
1025 memory_region_write_thunk
,
1027 mr
->ops
->endianness
);
1028 mr
->backend_registered
= true;
1031 void memory_region_init_io(MemoryRegion
*mr
,
1032 const MemoryRegionOps
*ops
,
1037 memory_region_init(mr
, name
, size
);
1039 mr
->opaque
= opaque
;
1040 mr
->terminates
= true;
1041 mr
->backend_registered
= false;
1044 void memory_region_init_ram(MemoryRegion
*mr
,
1049 memory_region_init(mr
, name
, size
);
1051 mr
->terminates
= true;
1052 mr
->destructor
= memory_region_destructor_ram
;
1053 mr
->ram_addr
= qemu_ram_alloc(dev
, name
, size
, mr
);
1054 mr
->backend_registered
= true;
1057 void memory_region_init_ram_ptr(MemoryRegion
*mr
,
1063 memory_region_init(mr
, name
, size
);
1065 mr
->terminates
= true;
1066 mr
->destructor
= memory_region_destructor_ram_from_ptr
;
1067 mr
->ram_addr
= qemu_ram_alloc_from_ptr(dev
, name
, size
, ptr
, mr
);
1068 mr
->backend_registered
= true;
1071 void memory_region_init_alias(MemoryRegion
*mr
,
1074 target_phys_addr_t offset
,
1077 memory_region_init(mr
, name
, size
);
1079 mr
->alias_offset
= offset
;
1082 void memory_region_init_rom_device(MemoryRegion
*mr
,
1083 const MemoryRegionOps
*ops
,
1089 memory_region_init(mr
, name
, size
);
1091 mr
->opaque
= opaque
;
1092 mr
->terminates
= true;
1093 mr
->destructor
= memory_region_destructor_rom_device
;
1094 mr
->ram_addr
= qemu_ram_alloc(dev
, name
, size
, mr
);
1095 mr
->ram_addr
|= cpu_register_io_memory(memory_region_read_thunk
,
1096 memory_region_write_thunk
,
1098 mr
->ops
->endianness
);
1099 mr
->ram_addr
|= IO_MEM_ROMD
;
1100 mr
->backend_registered
= true;
1103 void memory_region_destroy(MemoryRegion
*mr
)
1105 assert(QTAILQ_EMPTY(&mr
->subregions
));
1107 memory_region_clear_coalescing(mr
);
1108 g_free((char *)mr
->name
);
1109 g_free(mr
->ioeventfds
);
1112 uint64_t memory_region_size(MemoryRegion
*mr
)
1114 if (int128_eq(mr
->size
, int128_2_64())) {
1117 return int128_get64(mr
->size
);
1120 bool memory_region_is_ram(MemoryRegion
*mr
)
1125 bool memory_region_is_logging(MemoryRegion
*mr
)
1127 return mr
->dirty_log_mask
;
1130 bool memory_region_is_rom(MemoryRegion
*mr
)
1132 return mr
->ram
&& mr
->readonly
;
1135 void memory_region_set_offset(MemoryRegion
*mr
, target_phys_addr_t offset
)
1137 mr
->offset
= offset
;
1140 void memory_region_set_log(MemoryRegion
*mr
, bool log
, unsigned client
)
1142 uint8_t mask
= 1 << client
;
1144 mr
->dirty_log_mask
= (mr
->dirty_log_mask
& ~mask
) | (log
* mask
);
1145 memory_region_update_topology(mr
);
1148 bool memory_region_get_dirty(MemoryRegion
*mr
, target_phys_addr_t addr
,
1151 assert(mr
->terminates
);
1152 return cpu_physical_memory_get_dirty(mr
->ram_addr
+ addr
, 1 << client
);
1155 void memory_region_set_dirty(MemoryRegion
*mr
, target_phys_addr_t addr
)
1157 assert(mr
->terminates
);
1158 return cpu_physical_memory_set_dirty(mr
->ram_addr
+ addr
);
1161 void memory_region_sync_dirty_bitmap(MemoryRegion
*mr
)
1165 FOR_EACH_FLAT_RANGE(fr
, &address_space_memory
.current_map
) {
1167 MEMORY_LISTENER_UPDATE_REGION(fr
, &address_space_memory
, log_sync
);
1168 cpu_physical_sync_dirty_bitmap(int128_get64(fr
->addr
.start
),
1169 int128_get64(addrrange_end(fr
->addr
)));
1174 void memory_region_set_readonly(MemoryRegion
*mr
, bool readonly
)
1176 if (mr
->readonly
!= readonly
) {
1177 mr
->readonly
= readonly
;
1178 memory_region_update_topology(mr
);
1182 void memory_region_rom_device_set_readable(MemoryRegion
*mr
, bool readable
)
1184 if (mr
->readable
!= readable
) {
1185 mr
->readable
= readable
;
1186 memory_region_update_topology(mr
);
1190 void memory_region_reset_dirty(MemoryRegion
*mr
, target_phys_addr_t addr
,
1191 target_phys_addr_t size
, unsigned client
)
1193 assert(mr
->terminates
);
1194 cpu_physical_memory_reset_dirty(mr
->ram_addr
+ addr
,
1195 mr
->ram_addr
+ addr
+ size
,
1199 void *memory_region_get_ram_ptr(MemoryRegion
*mr
)
1202 return memory_region_get_ram_ptr(mr
->alias
) + mr
->alias_offset
;
1205 assert(mr
->terminates
);
1207 return qemu_get_ram_ptr(mr
->ram_addr
& TARGET_PAGE_MASK
);
1210 static void memory_region_update_coalesced_range(MemoryRegion
*mr
)
1213 CoalescedMemoryRange
*cmr
;
1216 FOR_EACH_FLAT_RANGE(fr
, &address_space_memory
.current_map
) {
1218 qemu_unregister_coalesced_mmio(int128_get64(fr
->addr
.start
),
1219 int128_get64(fr
->addr
.size
));
1220 QTAILQ_FOREACH(cmr
, &mr
->coalesced
, link
) {
1221 tmp
= addrrange_shift(cmr
->addr
,
1222 int128_sub(fr
->addr
.start
,
1223 int128_make64(fr
->offset_in_region
)));
1224 if (!addrrange_intersects(tmp
, fr
->addr
)) {
1227 tmp
= addrrange_intersection(tmp
, fr
->addr
);
1228 qemu_register_coalesced_mmio(int128_get64(tmp
.start
),
1229 int128_get64(tmp
.size
));
1235 void memory_region_set_coalescing(MemoryRegion
*mr
)
1237 memory_region_clear_coalescing(mr
);
1238 memory_region_add_coalescing(mr
, 0, int128_get64(mr
->size
));
1241 void memory_region_add_coalescing(MemoryRegion
*mr
,
1242 target_phys_addr_t offset
,
1245 CoalescedMemoryRange
*cmr
= g_malloc(sizeof(*cmr
));
1247 cmr
->addr
= addrrange_make(int128_make64(offset
), int128_make64(size
));
1248 QTAILQ_INSERT_TAIL(&mr
->coalesced
, cmr
, link
);
1249 memory_region_update_coalesced_range(mr
);
1252 void memory_region_clear_coalescing(MemoryRegion
*mr
)
1254 CoalescedMemoryRange
*cmr
;
1256 while (!QTAILQ_EMPTY(&mr
->coalesced
)) {
1257 cmr
= QTAILQ_FIRST(&mr
->coalesced
);
1258 QTAILQ_REMOVE(&mr
->coalesced
, cmr
, link
);
1261 memory_region_update_coalesced_range(mr
);
1264 void memory_region_add_eventfd(MemoryRegion
*mr
,
1265 target_phys_addr_t addr
,
1271 MemoryRegionIoeventfd mrfd
= {
1272 .addr
.start
= int128_make64(addr
),
1273 .addr
.size
= int128_make64(size
),
1274 .match_data
= match_data
,
1280 for (i
= 0; i
< mr
->ioeventfd_nb
; ++i
) {
1281 if (memory_region_ioeventfd_before(mrfd
, mr
->ioeventfds
[i
])) {
1286 mr
->ioeventfds
= g_realloc(mr
->ioeventfds
,
1287 sizeof(*mr
->ioeventfds
) * mr
->ioeventfd_nb
);
1288 memmove(&mr
->ioeventfds
[i
+1], &mr
->ioeventfds
[i
],
1289 sizeof(*mr
->ioeventfds
) * (mr
->ioeventfd_nb
-1 - i
));
1290 mr
->ioeventfds
[i
] = mrfd
;
1291 memory_region_update_topology(mr
);
1294 void memory_region_del_eventfd(MemoryRegion
*mr
,
1295 target_phys_addr_t addr
,
1301 MemoryRegionIoeventfd mrfd
= {
1302 .addr
.start
= int128_make64(addr
),
1303 .addr
.size
= int128_make64(size
),
1304 .match_data
= match_data
,
1310 for (i
= 0; i
< mr
->ioeventfd_nb
; ++i
) {
1311 if (memory_region_ioeventfd_equal(mrfd
, mr
->ioeventfds
[i
])) {
1315 assert(i
!= mr
->ioeventfd_nb
);
1316 memmove(&mr
->ioeventfds
[i
], &mr
->ioeventfds
[i
+1],
1317 sizeof(*mr
->ioeventfds
) * (mr
->ioeventfd_nb
- (i
+1)));
1319 mr
->ioeventfds
= g_realloc(mr
->ioeventfds
,
1320 sizeof(*mr
->ioeventfds
)*mr
->ioeventfd_nb
+ 1);
1321 memory_region_update_topology(mr
);
1324 static void memory_region_add_subregion_common(MemoryRegion
*mr
,
1325 target_phys_addr_t offset
,
1326 MemoryRegion
*subregion
)
1328 MemoryRegion
*other
;
1330 assert(!subregion
->parent
);
1331 subregion
->parent
= mr
;
1332 subregion
->addr
= offset
;
1333 QTAILQ_FOREACH(other
, &mr
->subregions
, subregions_link
) {
1334 if (subregion
->may_overlap
|| other
->may_overlap
) {
1337 if (int128_gt(int128_make64(offset
),
1338 int128_add(int128_make64(other
->addr
), other
->size
))
1339 || int128_le(int128_add(int128_make64(offset
), subregion
->size
),
1340 int128_make64(other
->addr
))) {
1344 printf("warning: subregion collision %llx/%llx (%s) "
1345 "vs %llx/%llx (%s)\n",
1346 (unsigned long long)offset
,
1347 (unsigned long long)int128_get64(subregion
->size
),
1349 (unsigned long long)other
->addr
,
1350 (unsigned long long)int128_get64(other
->size
),
1354 QTAILQ_FOREACH(other
, &mr
->subregions
, subregions_link
) {
1355 if (subregion
->priority
>= other
->priority
) {
1356 QTAILQ_INSERT_BEFORE(other
, subregion
, subregions_link
);
1360 QTAILQ_INSERT_TAIL(&mr
->subregions
, subregion
, subregions_link
);
1362 memory_region_update_topology(mr
);
1366 void memory_region_add_subregion(MemoryRegion
*mr
,
1367 target_phys_addr_t offset
,
1368 MemoryRegion
*subregion
)
1370 subregion
->may_overlap
= false;
1371 subregion
->priority
= 0;
1372 memory_region_add_subregion_common(mr
, offset
, subregion
);
1375 void memory_region_add_subregion_overlap(MemoryRegion
*mr
,
1376 target_phys_addr_t offset
,
1377 MemoryRegion
*subregion
,
1380 subregion
->may_overlap
= true;
1381 subregion
->priority
= priority
;
1382 memory_region_add_subregion_common(mr
, offset
, subregion
);
1385 void memory_region_del_subregion(MemoryRegion
*mr
,
1386 MemoryRegion
*subregion
)
1388 assert(subregion
->parent
== mr
);
1389 subregion
->parent
= NULL
;
1390 QTAILQ_REMOVE(&mr
->subregions
, subregion
, subregions_link
);
1391 memory_region_update_topology(mr
);
1394 void memory_region_set_enabled(MemoryRegion
*mr
, bool enabled
)
1396 if (enabled
== mr
->enabled
) {
1399 mr
->enabled
= enabled
;
1400 memory_region_update_topology(NULL
);
1403 void memory_region_set_address(MemoryRegion
*mr
, target_phys_addr_t addr
)
1405 MemoryRegion
*parent
= mr
->parent
;
1406 unsigned priority
= mr
->priority
;
1407 bool may_overlap
= mr
->may_overlap
;
1409 if (addr
== mr
->addr
|| !parent
) {
1414 memory_region_transaction_begin();
1415 memory_region_del_subregion(parent
, mr
);
1417 memory_region_add_subregion_overlap(parent
, addr
, mr
, priority
);
1419 memory_region_add_subregion(parent
, addr
, mr
);
1421 memory_region_transaction_commit();
1424 void memory_region_set_alias_offset(MemoryRegion
*mr
, target_phys_addr_t offset
)
1426 target_phys_addr_t old_offset
= mr
->alias_offset
;
1429 mr
->alias_offset
= offset
;
1431 if (offset
== old_offset
|| !mr
->parent
) {
1435 memory_region_update_topology(mr
);
1438 static int cmp_flatrange_addr(const void *addr_
, const void *fr_
)
1440 const AddrRange
*addr
= addr_
;
1441 const FlatRange
*fr
= fr_
;
1443 if (int128_le(addrrange_end(*addr
), fr
->addr
.start
)) {
1445 } else if (int128_ge(addr
->start
, addrrange_end(fr
->addr
))) {
1451 static FlatRange
*address_space_lookup(AddressSpace
*as
, AddrRange addr
)
1453 return bsearch(&addr
, as
->current_map
.ranges
, as
->current_map
.nr
,
1454 sizeof(FlatRange
), cmp_flatrange_addr
);
1457 MemoryRegionSection
memory_region_find(MemoryRegion
*address_space
,
1458 target_phys_addr_t addr
, uint64_t size
)
1460 AddressSpace
*as
= memory_region_to_address_space(address_space
);
1461 AddrRange range
= addrrange_make(int128_make64(addr
),
1462 int128_make64(size
));
1463 FlatRange
*fr
= address_space_lookup(as
, range
);
1464 MemoryRegionSection ret
= { .mr
= NULL
, .size
= 0 };
1470 while (fr
> as
->current_map
.ranges
1471 && addrrange_intersects(fr
[-1].addr
, range
)) {
1476 range
= addrrange_intersection(range
, fr
->addr
);
1477 ret
.offset_within_region
= fr
->offset_in_region
;
1478 ret
.offset_within_region
+= int128_get64(int128_sub(range
.start
,
1480 ret
.size
= int128_get64(range
.size
);
1481 ret
.offset_within_address_space
= int128_get64(range
.start
);
1485 void memory_global_sync_dirty_bitmap(MemoryRegion
*address_space
)
1487 AddressSpace
*as
= memory_region_to_address_space(address_space
);
1490 cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX
);
1491 FOR_EACH_FLAT_RANGE(fr
, &as
->current_map
) {
1492 MEMORY_LISTENER_UPDATE_REGION(fr
, as
, log_sync
);
1496 void memory_global_dirty_log_start(void)
1498 MemoryListener
*listener
;
1500 global_dirty_log
= true;
1501 QLIST_FOREACH(listener
, &memory_listeners
, link
) {
1502 listener
->log_global_start(listener
);
1506 void memory_global_dirty_log_stop(void)
1508 MemoryListener
*listener
;
1510 global_dirty_log
= false;
1511 QLIST_FOREACH(listener
, &memory_listeners
, link
) {
1512 listener
->log_global_stop(listener
);
1516 static void listener_add_address_space(MemoryListener
*listener
,
1521 if (global_dirty_log
) {
1522 listener
->log_global_start(listener
);
1524 FOR_EACH_FLAT_RANGE(fr
, &as
->current_map
) {
1525 MemoryRegionSection section
= {
1527 .address_space
= as
->root
,
1528 .offset_within_region
= fr
->offset_in_region
,
1529 .size
= int128_get64(fr
->addr
.size
),
1530 .offset_within_address_space
= int128_get64(fr
->addr
.start
),
1532 listener
->region_add(listener
, §ion
);
1536 void memory_listener_register(MemoryListener
*listener
)
1538 QLIST_INSERT_HEAD(&memory_listeners
, listener
, link
);
1539 listener_add_address_space(listener
, &address_space_memory
);
1540 listener_add_address_space(listener
, &address_space_io
);
1543 void memory_listener_unregister(MemoryListener
*listener
)
1545 QLIST_REMOVE(listener
, link
);
1548 void set_system_memory_map(MemoryRegion
*mr
)
1550 address_space_memory
.root
= mr
;
1551 memory_region_update_topology(NULL
);
1554 void set_system_io_map(MemoryRegion
*mr
)
1556 address_space_io
.root
= mr
;
1557 memory_region_update_topology(NULL
);
1560 typedef struct MemoryRegionList MemoryRegionList
;
1562 struct MemoryRegionList
{
1563 const MemoryRegion
*mr
;
1565 QTAILQ_ENTRY(MemoryRegionList
) queue
;
1568 typedef QTAILQ_HEAD(queue
, MemoryRegionList
) MemoryRegionListHead
;
1570 static void mtree_print_mr(fprintf_function mon_printf
, void *f
,
1571 const MemoryRegion
*mr
, unsigned int level
,
1572 target_phys_addr_t base
,
1573 MemoryRegionListHead
*alias_print_queue
)
1575 MemoryRegionList
*new_ml
, *ml
, *next_ml
;
1576 MemoryRegionListHead submr_print_queue
;
1577 const MemoryRegion
*submr
;
1584 for (i
= 0; i
< level
; i
++) {
1589 MemoryRegionList
*ml
;
1592 /* check if the alias is already in the queue */
1593 QTAILQ_FOREACH(ml
, alias_print_queue
, queue
) {
1594 if (ml
->mr
== mr
->alias
&& !ml
->printed
) {
1600 ml
= g_new(MemoryRegionList
, 1);
1602 ml
->printed
= false;
1603 QTAILQ_INSERT_TAIL(alias_print_queue
, ml
, queue
);
1605 mon_printf(f
, TARGET_FMT_plx
"-" TARGET_FMT_plx
" (prio %d): alias %s @%s "
1606 TARGET_FMT_plx
"-" TARGET_FMT_plx
"\n",
1609 + (target_phys_addr_t
)int128_get64(mr
->size
) - 1,
1615 + (target_phys_addr_t
)int128_get64(mr
->size
) - 1);
1617 mon_printf(f
, TARGET_FMT_plx
"-" TARGET_FMT_plx
" (prio %d): %s\n",
1620 + (target_phys_addr_t
)int128_get64(mr
->size
) - 1,
1625 QTAILQ_INIT(&submr_print_queue
);
1627 QTAILQ_FOREACH(submr
, &mr
->subregions
, subregions_link
) {
1628 new_ml
= g_new(MemoryRegionList
, 1);
1630 QTAILQ_FOREACH(ml
, &submr_print_queue
, queue
) {
1631 if (new_ml
->mr
->addr
< ml
->mr
->addr
||
1632 (new_ml
->mr
->addr
== ml
->mr
->addr
&&
1633 new_ml
->mr
->priority
> ml
->mr
->priority
)) {
1634 QTAILQ_INSERT_BEFORE(ml
, new_ml
, queue
);
1640 QTAILQ_INSERT_TAIL(&submr_print_queue
, new_ml
, queue
);
1644 QTAILQ_FOREACH(ml
, &submr_print_queue
, queue
) {
1645 mtree_print_mr(mon_printf
, f
, ml
->mr
, level
+ 1, base
+ mr
->addr
,
1649 QTAILQ_FOREACH_SAFE(ml
, &submr_print_queue
, queue
, next_ml
) {
1654 void mtree_info(fprintf_function mon_printf
, void *f
)
1656 MemoryRegionListHead ml_head
;
1657 MemoryRegionList
*ml
, *ml2
;
1659 QTAILQ_INIT(&ml_head
);
1661 mon_printf(f
, "memory\n");
1662 mtree_print_mr(mon_printf
, f
, address_space_memory
.root
, 0, 0, &ml_head
);
1664 /* print aliased regions */
1665 QTAILQ_FOREACH(ml
, &ml_head
, queue
) {
1667 mon_printf(f
, "%s\n", ml
->mr
->name
);
1668 mtree_print_mr(mon_printf
, f
, ml
->mr
, 0, 0, &ml_head
);
1672 QTAILQ_FOREACH_SAFE(ml
, &ml_head
, queue
, ml2
) {
1676 if (address_space_io
.root
&&
1677 !QTAILQ_EMPTY(&address_space_io
.root
->subregions
)) {
1678 QTAILQ_INIT(&ml_head
);
1679 mon_printf(f
, "I/O\n");
1680 mtree_print_mr(mon_printf
, f
, address_space_io
.root
, 0, 0, &ml_head
);