2 * Physical memory management API
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.
17 #ifndef CONFIG_USER_ONLY
21 #include "qemu-common.h"
22 #include "exec/cpu-common.h"
23 #include "exec/hwaddr.h"
24 #include "qemu/queue.h"
25 #include "exec/iorange.h"
26 #include "exec/ioport.h"
27 #include "qemu/int128.h"
29 typedef struct MemoryRegionOps MemoryRegionOps
;
30 typedef struct MemoryRegionPortio MemoryRegionPortio
;
31 typedef struct MemoryRegionMmio MemoryRegionMmio
;
33 /* Must match *_DIRTY_FLAGS in cpu-all.h. To be replaced with dynamic
36 #define DIRTY_MEMORY_VGA 0
37 #define DIRTY_MEMORY_CODE 1
38 #define DIRTY_MEMORY_MIGRATION 3
40 struct MemoryRegionMmio
{
41 CPUReadMemoryFunc
*read
[3];
42 CPUWriteMemoryFunc
*write
[3];
45 /* Internal use; thunks between old-style IORange and MemoryRegions. */
46 typedef struct MemoryRegionIORange MemoryRegionIORange
;
47 struct MemoryRegionIORange
{
54 * Memory region callbacks
56 struct MemoryRegionOps
{
57 /* Read from the memory region. @addr is relative to @mr; @size is
59 uint64_t (*read
)(void *opaque
,
62 /* Write to the memory region. @addr is relative to @mr; @size is
64 void (*write
)(void *opaque
,
69 enum device_endian endianness
;
70 /* Guest-visible constraints: */
72 /* If nonzero, specify bounds on access sizes beyond which a machine
75 unsigned min_access_size
;
76 unsigned max_access_size
;
77 /* If true, unaligned accesses are supported. Otherwise unaligned
78 * accesses throw machine checks.
82 * If present, and returns #false, the transaction is not accepted
83 * by the device (and results in machine dependent behaviour such
84 * as a machine check exception).
86 bool (*accepts
)(void *opaque
, hwaddr addr
,
87 unsigned size
, bool is_write
);
89 /* Internal implementation constraints: */
91 /* If nonzero, specifies the minimum size implemented. Smaller sizes
92 * will be rounded upwards and a partial result will be returned.
94 unsigned min_access_size
;
95 /* If nonzero, specifies the maximum size implemented. Larger sizes
96 * will be done as a series of accesses with smaller sizes.
98 unsigned max_access_size
;
99 /* If true, unaligned accesses are supported. Otherwise all accesses
100 * are converted to (possibly multiple) naturally aligned accesses.
105 /* If .read and .write are not present, old_portio may be used for
106 * backwards compatibility with old portio registration
108 const MemoryRegionPortio
*old_portio
;
109 /* If .read and .write are not present, old_mmio may be used for
110 * backwards compatibility with old mmio registration
112 const MemoryRegionMmio old_mmio
;
115 typedef struct CoalescedMemoryRange CoalescedMemoryRange
;
116 typedef struct MemoryRegionIoeventfd MemoryRegionIoeventfd
;
118 struct MemoryRegion
{
119 /* All fields are private - violators will be prosecuted */
120 const MemoryRegionOps
*ops
;
122 MemoryRegion
*parent
;
125 void (*destructor
)(MemoryRegion
*mr
);
131 bool readonly
; /* For RAM regions */
134 bool warning_printed
; /* For reservations */
135 bool flush_coalesced_mmio
;
140 QTAILQ_HEAD(subregions
, MemoryRegion
) subregions
;
141 QTAILQ_ENTRY(MemoryRegion
) subregions_link
;
142 QTAILQ_HEAD(coalesced_ranges
, CoalescedMemoryRange
) coalesced
;
144 uint8_t dirty_log_mask
;
145 unsigned ioeventfd_nb
;
146 MemoryRegionIoeventfd
*ioeventfds
;
149 struct MemoryRegionPortio
{
153 IOPortReadFunc
*read
;
154 IOPortWriteFunc
*write
;
157 #define PORTIO_END_OF_LIST() { }
160 * AddressSpace: describes a mapping of addresses to #MemoryRegion objects
162 struct AddressSpace
{
163 /* All fields are private. */
166 struct FlatView
*current_map
;
168 struct MemoryRegionIoeventfd
*ioeventfds
;
169 struct AddressSpaceDispatch
*dispatch
;
170 QTAILQ_ENTRY(AddressSpace
) address_spaces_link
;
174 * MemoryRegionSection: describes a fragment of a #MemoryRegion
176 * @mr: the region, or %NULL if empty
177 * @address_space: the address space the region is mapped in
178 * @offset_within_region: the beginning of the section, relative to @mr's start
179 * @size: the size of the section; will not exceed @mr's boundaries
180 * @offset_within_address_space: the address of the first byte of the section
181 * relative to the region's address space
182 * @readonly: writes to this section are ignored
184 struct MemoryRegionSection
{
186 AddressSpace
*address_space
;
187 hwaddr offset_within_region
;
189 hwaddr offset_within_address_space
;
193 typedef struct MemoryListener MemoryListener
;
196 * MemoryListener: callbacks structure for updates to the physical memory map
198 * Allows a component to adjust to changes in the guest-visible memory map.
199 * Use with memory_listener_register() and memory_listener_unregister().
201 struct MemoryListener
{
202 void (*begin
)(MemoryListener
*listener
);
203 void (*commit
)(MemoryListener
*listener
);
204 void (*region_add
)(MemoryListener
*listener
, MemoryRegionSection
*section
);
205 void (*region_del
)(MemoryListener
*listener
, MemoryRegionSection
*section
);
206 void (*region_nop
)(MemoryListener
*listener
, MemoryRegionSection
*section
);
207 void (*log_start
)(MemoryListener
*listener
, MemoryRegionSection
*section
);
208 void (*log_stop
)(MemoryListener
*listener
, MemoryRegionSection
*section
);
209 void (*log_sync
)(MemoryListener
*listener
, MemoryRegionSection
*section
);
210 void (*log_global_start
)(MemoryListener
*listener
);
211 void (*log_global_stop
)(MemoryListener
*listener
);
212 void (*eventfd_add
)(MemoryListener
*listener
, MemoryRegionSection
*section
,
213 bool match_data
, uint64_t data
, EventNotifier
*e
);
214 void (*eventfd_del
)(MemoryListener
*listener
, MemoryRegionSection
*section
,
215 bool match_data
, uint64_t data
, EventNotifier
*e
);
216 void (*coalesced_mmio_add
)(MemoryListener
*listener
, MemoryRegionSection
*section
,
217 hwaddr addr
, hwaddr len
);
218 void (*coalesced_mmio_del
)(MemoryListener
*listener
, MemoryRegionSection
*section
,
219 hwaddr addr
, hwaddr len
);
220 /* Lower = earlier (during add), later (during del) */
222 AddressSpace
*address_space_filter
;
223 QTAILQ_ENTRY(MemoryListener
) link
;
227 * memory_region_init: Initialize a memory region
229 * The region typically acts as a container for other memory regions. Use
230 * memory_region_add_subregion() to add subregions.
232 * @mr: the #MemoryRegion to be initialized
233 * @name: used for debugging; not visible to the user or ABI
234 * @size: size of the region; any subregions beyond this size will be clipped
236 void memory_region_init(MemoryRegion
*mr
,
240 * memory_region_init_io: Initialize an I/O memory region.
242 * Accesses into the region will cause the callbacks in @ops to be called.
243 * if @size is nonzero, subregions will be clipped to @size.
245 * @mr: the #MemoryRegion to be initialized.
246 * @ops: a structure containing read and write callbacks to be used when
247 * I/O is performed on the region.
248 * @opaque: passed to to the read and write callbacks of the @ops structure.
249 * @name: used for debugging; not visible to the user or ABI
250 * @size: size of the region.
252 void memory_region_init_io(MemoryRegion
*mr
,
253 const MemoryRegionOps
*ops
,
259 * memory_region_init_ram: Initialize RAM memory region. Accesses into the
260 * region will modify memory directly.
262 * @mr: the #MemoryRegion to be initialized.
263 * @name: the name of the region.
264 * @size: size of the region.
266 void memory_region_init_ram(MemoryRegion
*mr
,
271 * memory_region_init_ram_ptr: Initialize RAM memory region from a
272 * user-provided pointer. Accesses into the
273 * region will modify memory directly.
275 * @mr: the #MemoryRegion to be initialized.
276 * @name: the name of the region.
277 * @size: size of the region.
278 * @ptr: memory to be mapped; must contain at least @size bytes.
280 void memory_region_init_ram_ptr(MemoryRegion
*mr
,
286 * memory_region_init_alias: Initialize a memory region that aliases all or a
287 * part of another memory region.
289 * @mr: the #MemoryRegion to be initialized.
290 * @name: used for debugging; not visible to the user or ABI
291 * @orig: the region to be referenced; @mr will be equivalent to
292 * @orig between @offset and @offset + @size - 1.
293 * @offset: start of the section in @orig to be referenced.
294 * @size: size of the region.
296 void memory_region_init_alias(MemoryRegion
*mr
,
303 * memory_region_init_rom_device: Initialize a ROM memory region. Writes are
304 * handled via callbacks.
306 * @mr: the #MemoryRegion to be initialized.
307 * @ops: callbacks for write access handling.
308 * @name: the name of the region.
309 * @size: size of the region.
311 void memory_region_init_rom_device(MemoryRegion
*mr
,
312 const MemoryRegionOps
*ops
,
318 * memory_region_init_reservation: Initialize a memory region that reserves
321 * A reservation region primariy serves debugging purposes. It claims I/O
322 * space that is not supposed to be handled by QEMU itself. Any access via
323 * the memory API will cause an abort().
325 * @mr: the #MemoryRegion to be initialized
326 * @name: used for debugging; not visible to the user or ABI
327 * @size: size of the region.
329 void memory_region_init_reservation(MemoryRegion
*mr
,
333 * memory_region_destroy: Destroy a memory region and reclaim all resources.
335 * @mr: the region to be destroyed. May not currently be a subregion
336 * (see memory_region_add_subregion()) or referenced in an alias
337 * (see memory_region_init_alias()).
339 void memory_region_destroy(MemoryRegion
*mr
);
342 * memory_region_size: get a memory region's size.
344 * @mr: the memory region being queried.
346 uint64_t memory_region_size(MemoryRegion
*mr
);
349 * memory_region_is_ram: check whether a memory region is random access
351 * Returns %true is a memory region is random access.
353 * @mr: the memory region being queried
355 bool memory_region_is_ram(MemoryRegion
*mr
);
358 * memory_region_is_romd: check whether a memory region is in ROMD mode
360 * Returns %true if a memory region is a ROM device and currently set to allow
363 * @mr: the memory region being queried
365 static inline bool memory_region_is_romd(MemoryRegion
*mr
)
367 return mr
->rom_device
&& mr
->romd_mode
;
371 * memory_region_name: get a memory region's name
373 * Returns the string that was used to initialize the memory region.
375 * @mr: the memory region being queried
377 const char *memory_region_name(MemoryRegion
*mr
);
380 * memory_region_is_logging: return whether a memory region is logging writes
382 * Returns %true if the memory region is logging writes
384 * @mr: the memory region being queried
386 bool memory_region_is_logging(MemoryRegion
*mr
);
389 * memory_region_is_rom: check whether a memory region is ROM
391 * Returns %true is a memory region is read-only memory.
393 * @mr: the memory region being queried
395 bool memory_region_is_rom(MemoryRegion
*mr
);
398 * memory_region_get_ram_ptr: Get a pointer into a RAM memory region.
400 * Returns a host pointer to a RAM memory region (created with
401 * memory_region_init_ram() or memory_region_init_ram_ptr()). Use with
404 * @mr: the memory region being queried.
406 void *memory_region_get_ram_ptr(MemoryRegion
*mr
);
409 * memory_region_set_log: Turn dirty logging on or off for a region.
411 * Turns dirty logging on or off for a specified client (display, migration).
412 * Only meaningful for RAM regions.
414 * @mr: the memory region being updated.
415 * @log: whether dirty logging is to be enabled or disabled.
416 * @client: the user of the logging information; %DIRTY_MEMORY_MIGRATION or
419 void memory_region_set_log(MemoryRegion
*mr
, bool log
, unsigned client
);
422 * memory_region_get_dirty: Check whether a range of bytes is dirty
423 * for a specified client.
425 * Checks whether a range of bytes has been written to since the last
426 * call to memory_region_reset_dirty() with the same @client. Dirty logging
429 * @mr: the memory region being queried.
430 * @addr: the address (relative to the start of the region) being queried.
431 * @size: the size of the range being queried.
432 * @client: the user of the logging information; %DIRTY_MEMORY_MIGRATION or
435 bool memory_region_get_dirty(MemoryRegion
*mr
, hwaddr addr
,
436 hwaddr size
, unsigned client
);
439 * memory_region_set_dirty: Mark a range of bytes as dirty in a memory region.
441 * Marks a range of bytes as dirty, after it has been dirtied outside
444 * @mr: the memory region being dirtied.
445 * @addr: the address (relative to the start of the region) being dirtied.
446 * @size: size of the range being dirtied.
448 void memory_region_set_dirty(MemoryRegion
*mr
, hwaddr addr
,
452 * memory_region_test_and_clear_dirty: Check whether a range of bytes is dirty
453 * for a specified client. It clears them.
455 * Checks whether a range of bytes has been written to since the last
456 * call to memory_region_reset_dirty() with the same @client. Dirty logging
459 * @mr: the memory region being queried.
460 * @addr: the address (relative to the start of the region) being queried.
461 * @size: the size of the range being queried.
462 * @client: the user of the logging information; %DIRTY_MEMORY_MIGRATION or
465 bool memory_region_test_and_clear_dirty(MemoryRegion
*mr
, hwaddr addr
,
466 hwaddr size
, unsigned client
);
468 * memory_region_sync_dirty_bitmap: Synchronize a region's dirty bitmap with
469 * any external TLBs (e.g. kvm)
471 * Flushes dirty information from accelerators such as kvm and vhost-net
472 * and makes it available to users of the memory API.
474 * @mr: the region being flushed.
476 void memory_region_sync_dirty_bitmap(MemoryRegion
*mr
);
479 * memory_region_reset_dirty: Mark a range of pages as clean, for a specified
482 * Marks a range of pages as no longer dirty.
484 * @mr: the region being updated.
485 * @addr: the start of the subrange being cleaned.
486 * @size: the size of the subrange being cleaned.
487 * @client: the user of the logging information; %DIRTY_MEMORY_MIGRATION or
490 void memory_region_reset_dirty(MemoryRegion
*mr
, hwaddr addr
,
491 hwaddr size
, unsigned client
);
494 * memory_region_set_readonly: Turn a memory region read-only (or read-write)
496 * Allows a memory region to be marked as read-only (turning it into a ROM).
497 * only useful on RAM regions.
499 * @mr: the region being updated.
500 * @readonly: whether rhe region is to be ROM or RAM.
502 void memory_region_set_readonly(MemoryRegion
*mr
, bool readonly
);
505 * memory_region_rom_device_set_romd: enable/disable ROMD mode
507 * Allows a ROM device (initialized with memory_region_init_rom_device() to
508 * set to ROMD mode (default) or MMIO mode. When it is in ROMD mode, the
509 * device is mapped to guest memory and satisfies read access directly.
510 * When in MMIO mode, reads are forwarded to the #MemoryRegion.read function.
511 * Writes are always handled by the #MemoryRegion.write function.
513 * @mr: the memory region to be updated
514 * @romd_mode: %true to put the region into ROMD mode
516 void memory_region_rom_device_set_romd(MemoryRegion
*mr
, bool romd_mode
);
519 * memory_region_set_coalescing: Enable memory coalescing for the region.
521 * Enabled writes to a region to be queued for later processing. MMIO ->write
522 * callbacks may be delayed until a non-coalesced MMIO is issued.
523 * Only useful for IO regions. Roughly similar to write-combining hardware.
525 * @mr: the memory region to be write coalesced
527 void memory_region_set_coalescing(MemoryRegion
*mr
);
530 * memory_region_add_coalescing: Enable memory coalescing for a sub-range of
533 * Like memory_region_set_coalescing(), but works on a sub-range of a region.
534 * Multiple calls can be issued coalesced disjoint ranges.
536 * @mr: the memory region to be updated.
537 * @offset: the start of the range within the region to be coalesced.
538 * @size: the size of the subrange to be coalesced.
540 void memory_region_add_coalescing(MemoryRegion
*mr
,
545 * memory_region_clear_coalescing: Disable MMIO coalescing for the region.
547 * Disables any coalescing caused by memory_region_set_coalescing() or
548 * memory_region_add_coalescing(). Roughly equivalent to uncacheble memory
551 * @mr: the memory region to be updated.
553 void memory_region_clear_coalescing(MemoryRegion
*mr
);
556 * memory_region_set_flush_coalesced: Enforce memory coalescing flush before
559 * Ensure that pending coalesced MMIO request are flushed before the memory
560 * region is accessed. This property is automatically enabled for all regions
561 * passed to memory_region_set_coalescing() and memory_region_add_coalescing().
563 * @mr: the memory region to be updated.
565 void memory_region_set_flush_coalesced(MemoryRegion
*mr
);
568 * memory_region_clear_flush_coalesced: Disable memory coalescing flush before
571 * Clear the automatic coalesced MMIO flushing enabled via
572 * memory_region_set_flush_coalesced. Note that this service has no effect on
573 * memory regions that have MMIO coalescing enabled for themselves. For them,
574 * automatic flushing will stop once coalescing is disabled.
576 * @mr: the memory region to be updated.
578 void memory_region_clear_flush_coalesced(MemoryRegion
*mr
);
581 * memory_region_add_eventfd: Request an eventfd to be triggered when a word
582 * is written to a location.
584 * Marks a word in an IO region (initialized with memory_region_init_io())
585 * as a trigger for an eventfd event. The I/O callback will not be called.
586 * The caller must be prepared to handle failure (that is, take the required
587 * action if the callback _is_ called).
589 * @mr: the memory region being updated.
590 * @addr: the address within @mr that is to be monitored
591 * @size: the size of the access to trigger the eventfd
592 * @match_data: whether to match against @data, instead of just @addr
593 * @data: the data to match against the guest write
594 * @fd: the eventfd to be triggered when @addr, @size, and @data all match.
596 void memory_region_add_eventfd(MemoryRegion
*mr
,
604 * memory_region_del_eventfd: Cancel an eventfd.
606 * Cancels an eventfd trigger requested by a previous
607 * memory_region_add_eventfd() call.
609 * @mr: the memory region being updated.
610 * @addr: the address within @mr that is to be monitored
611 * @size: the size of the access to trigger the eventfd
612 * @match_data: whether to match against @data, instead of just @addr
613 * @data: the data to match against the guest write
614 * @fd: the eventfd to be triggered when @addr, @size, and @data all match.
616 void memory_region_del_eventfd(MemoryRegion
*mr
,
624 * memory_region_add_subregion: Add a subregion to a container.
626 * Adds a subregion at @offset. The subregion may not overlap with other
627 * subregions (except for those explicitly marked as overlapping). A region
628 * may only be added once as a subregion (unless removed with
629 * memory_region_del_subregion()); use memory_region_init_alias() if you
630 * want a region to be a subregion in multiple locations.
632 * @mr: the region to contain the new subregion; must be a container
633 * initialized with memory_region_init().
634 * @offset: the offset relative to @mr where @subregion is added.
635 * @subregion: the subregion to be added.
637 void memory_region_add_subregion(MemoryRegion
*mr
,
639 MemoryRegion
*subregion
);
641 * memory_region_add_subregion_overlap: Add a subregion to a container
644 * Adds a subregion at @offset. The subregion may overlap with other
645 * subregions. Conflicts are resolved by having a higher @priority hide a
646 * lower @priority. Subregions without priority are taken as @priority 0.
647 * A region may only be added once as a subregion (unless removed with
648 * memory_region_del_subregion()); use memory_region_init_alias() if you
649 * want a region to be a subregion in multiple locations.
651 * @mr: the region to contain the new subregion; must be a container
652 * initialized with memory_region_init().
653 * @offset: the offset relative to @mr where @subregion is added.
654 * @subregion: the subregion to be added.
655 * @priority: used for resolving overlaps; highest priority wins.
657 void memory_region_add_subregion_overlap(MemoryRegion
*mr
,
659 MemoryRegion
*subregion
,
663 * memory_region_get_ram_addr: Get the ram address associated with a memory
666 * DO NOT USE THIS FUNCTION. This is a temporary workaround while the Xen
667 * code is being reworked.
669 ram_addr_t
memory_region_get_ram_addr(MemoryRegion
*mr
);
672 * memory_region_del_subregion: Remove a subregion.
674 * Removes a subregion from its container.
676 * @mr: the container to be updated.
677 * @subregion: the region being removed; must be a current subregion of @mr.
679 void memory_region_del_subregion(MemoryRegion
*mr
,
680 MemoryRegion
*subregion
);
683 * memory_region_set_enabled: dynamically enable or disable a region
685 * Enables or disables a memory region. A disabled memory region
686 * ignores all accesses to itself and its subregions. It does not
687 * obscure sibling subregions with lower priority - it simply behaves as
688 * if it was removed from the hierarchy.
690 * Regions default to being enabled.
692 * @mr: the region to be updated
693 * @enabled: whether to enable or disable the region
695 void memory_region_set_enabled(MemoryRegion
*mr
, bool enabled
);
698 * memory_region_set_address: dynamically update the address of a region
700 * Dynamically updates the address of a region, relative to its parent.
701 * May be used on regions are currently part of a memory hierarchy.
703 * @mr: the region to be updated
704 * @addr: new address, relative to parent region
706 void memory_region_set_address(MemoryRegion
*mr
, hwaddr addr
);
709 * memory_region_set_alias_offset: dynamically update a memory alias's offset
711 * Dynamically updates the offset into the target region that an alias points
712 * to, as if the fourth argument to memory_region_init_alias() has changed.
714 * @mr: the #MemoryRegion to be updated; should be an alias.
715 * @offset: the new offset into the target memory region
717 void memory_region_set_alias_offset(MemoryRegion
*mr
,
721 * memory_region_find: translate an address/size relative to a
722 * MemoryRegion into a #MemoryRegionSection.
724 * Locates the first #MemoryRegion within @mr that overlaps the range
725 * given by @addr and @size.
727 * Returns a #MemoryRegionSection that describes a contiguous overlap.
728 * It will have the following characteristics:
729 * .@size = 0 iff no overlap was found
730 * .@mr is non-%NULL iff an overlap was found
732 * Remember that in the return value the @offset_within_region is
733 * relative to the returned region (in the .@mr field), not to the
736 * Similarly, the .@offset_within_address_space is relative to the
737 * address space that contains both regions, the passed and the
738 * returned one. However, in the special case where the @mr argument
739 * has no parent (and thus is the root of the address space), the
740 * following will hold:
741 * .@offset_within_address_space >= @addr
742 * .@offset_within_address_space + .@size <= @addr + @size
744 * @mr: a MemoryRegion within which @addr is a relative address
745 * @addr: start of the area within @as to be searched
746 * @size: size of the area to be searched
748 MemoryRegionSection
memory_region_find(MemoryRegion
*mr
,
749 hwaddr addr
, uint64_t size
);
752 * memory_region_section_addr: get offset within MemoryRegionSection
754 * Returns offset within MemoryRegionSection
756 * @section: the memory region section being queried
757 * @addr: address in address space
760 memory_region_section_addr(MemoryRegionSection
*section
,
763 addr
-= section
->offset_within_address_space
;
764 addr
+= section
->offset_within_region
;
769 * address_space_sync_dirty_bitmap: synchronize the dirty log for all memory
771 * Synchronizes the dirty page log for an entire address space.
772 * @as: the address space that contains the memory being synchronized
774 void address_space_sync_dirty_bitmap(AddressSpace
*as
);
777 * memory_region_transaction_begin: Start a transaction.
779 * During a transaction, changes will be accumulated and made visible
780 * only when the transaction ends (is committed).
782 void memory_region_transaction_begin(void);
785 * memory_region_transaction_commit: Commit a transaction and make changes
786 * visible to the guest.
788 void memory_region_transaction_commit(void);
791 * memory_listener_register: register callbacks to be called when memory
792 * sections are mapped or unmapped into an address
795 * @listener: an object containing the callbacks to be called
796 * @filter: if non-%NULL, only regions in this address space will be observed
798 void memory_listener_register(MemoryListener
*listener
, AddressSpace
*filter
);
801 * memory_listener_unregister: undo the effect of memory_listener_register()
803 * @listener: an object containing the callbacks to be removed
805 void memory_listener_unregister(MemoryListener
*listener
);
808 * memory_global_dirty_log_start: begin dirty logging for all regions
810 void memory_global_dirty_log_start(void);
813 * memory_global_dirty_log_stop: end dirty logging for all regions
815 void memory_global_dirty_log_stop(void);
817 void mtree_info(fprintf_function mon_printf
, void *f
);
820 * address_space_init: initializes an address space
822 * @as: an uninitialized #AddressSpace
823 * @root: a #MemoryRegion that routes addesses for the address space
825 void address_space_init(AddressSpace
*as
, MemoryRegion
*root
);
829 * address_space_destroy: destroy an address space
831 * Releases all resources associated with an address space. After an address space
832 * is destroyed, its root memory region (given by address_space_init()) may be destroyed
835 * @as: address space to be destroyed
837 void address_space_destroy(AddressSpace
*as
);
840 * address_space_rw: read from or write to an address space.
842 * @as: #AddressSpace to be accessed
843 * @addr: address within that address space
844 * @buf: buffer with the data transferred
845 * @is_write: indicates the transfer direction
847 void address_space_rw(AddressSpace
*as
, hwaddr addr
, uint8_t *buf
,
848 int len
, bool is_write
);
851 * address_space_write: write to address space.
853 * @as: #AddressSpace to be accessed
854 * @addr: address within that address space
855 * @buf: buffer with the data transferred
857 void address_space_write(AddressSpace
*as
, hwaddr addr
,
858 const uint8_t *buf
, int len
);
861 * address_space_read: read from an address space.
863 * @as: #AddressSpace to be accessed
864 * @addr: address within that address space
865 * @buf: buffer with the data transferred
867 void address_space_read(AddressSpace
*as
, hwaddr addr
, uint8_t *buf
, int len
);
869 /* address_space_map: map a physical memory region into a host virtual address
871 * May map a subset of the requested range, given by and returned in @plen.
872 * May return %NULL if resources needed to perform the mapping are exhausted.
873 * Use only for reads OR writes - not for read-modify-write operations.
874 * Use cpu_register_map_client() to know when retrying the map operation is
877 * @as: #AddressSpace to be accessed
878 * @addr: address within that address space
879 * @plen: pointer to length of buffer; updated on return
880 * @is_write: indicates the transfer direction
882 void *address_space_map(AddressSpace
*as
, hwaddr addr
,
883 hwaddr
*plen
, bool is_write
);
885 /* address_space_unmap: Unmaps a memory region previously mapped by address_space_map()
887 * Will also mark the memory as dirty if @is_write == %true. @access_len gives
888 * the amount of memory that was actually read or written by the caller.
890 * @as: #AddressSpace used
891 * @addr: address within that address space
892 * @len: buffer length as returned by address_space_map()
893 * @access_len: amount of data actually transferred
894 * @is_write: indicates the transfer direction
896 void address_space_unmap(AddressSpace
*as
, void *buffer
, hwaddr len
,
897 int is_write
, hwaddr access_len
);