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 ROMD
360 * Returns %true is a memory region is ROMD 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
->readable
;
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_readable: enable/disable ROM readability
507 * Allows a ROM device (initialized with memory_region_init_rom_device() to
508 * to be marked as readable (default) or not readable. When it is readable,
509 * the device is mapped to guest memory. When not readable, reads are
510 * forwarded to the #MemoryRegion.read function.
512 * @mr: the memory region to be updated
513 * @readable: whether reads are satisified directly (%true) or via callbacks
516 void memory_region_rom_device_set_readable(MemoryRegion
*mr
, bool readable
);
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: locate a MemoryRegion in an address space
723 * Locates the first #MemoryRegion within an address space given by
724 * @address_space that overlaps the range given by @addr and @size.
726 * Returns a #MemoryRegionSection that describes a contiguous overlap.
727 * It will have the following characteristics:
728 * .@offset_within_address_space >= @addr
729 * .@offset_within_address_space + .@size <= @addr + @size
730 * .@size = 0 iff no overlap was found
731 * .@mr is non-%NULL iff an overlap was found
733 * @address_space: a top-level (i.e. parentless) region that contains
734 * the region to be found
735 * @addr: start of the area within @address_space to be searched
736 * @size: size of the area to be searched
738 MemoryRegionSection
memory_region_find(MemoryRegion
*address_space
,
739 hwaddr addr
, uint64_t size
);
742 * memory_region_section_addr: get offset within MemoryRegionSection
744 * Returns offset within MemoryRegionSection
746 * @section: the memory region section being queried
747 * @addr: address in address space
750 memory_region_section_addr(MemoryRegionSection
*section
,
753 addr
-= section
->offset_within_address_space
;
754 addr
+= section
->offset_within_region
;
759 * memory_global_sync_dirty_bitmap: synchronize the dirty log for all memory
761 * Synchronizes the dirty page log for an entire address space.
762 * @address_space: a top-level (i.e. parentless) region that contains the
763 * memory being synchronized
765 void memory_global_sync_dirty_bitmap(MemoryRegion
*address_space
);
768 * memory_region_transaction_begin: Start a transaction.
770 * During a transaction, changes will be accumulated and made visible
771 * only when the transaction ends (is committed).
773 void memory_region_transaction_begin(void);
776 * memory_region_transaction_commit: Commit a transaction and make changes
777 * visible to the guest.
779 void memory_region_transaction_commit(void);
782 * memory_listener_register: register callbacks to be called when memory
783 * sections are mapped or unmapped into an address
786 * @listener: an object containing the callbacks to be called
787 * @filter: if non-%NULL, only regions in this address space will be observed
789 void memory_listener_register(MemoryListener
*listener
, AddressSpace
*filter
);
792 * memory_listener_unregister: undo the effect of memory_listener_register()
794 * @listener: an object containing the callbacks to be removed
796 void memory_listener_unregister(MemoryListener
*listener
);
799 * memory_global_dirty_log_start: begin dirty logging for all regions
801 void memory_global_dirty_log_start(void);
804 * memory_global_dirty_log_stop: end dirty logging for all regions
806 void memory_global_dirty_log_stop(void);
808 void mtree_info(fprintf_function mon_printf
, void *f
);
811 * address_space_init: initializes an address space
813 * @as: an uninitialized #AddressSpace
814 * @root: a #MemoryRegion that routes addesses for the address space
816 void address_space_init(AddressSpace
*as
, MemoryRegion
*root
);
820 * address_space_destroy: destroy an address space
822 * Releases all resources associated with an address space. After an address space
823 * is destroyed, its root memory region (given by address_space_init()) may be destroyed
826 * @as: address space to be destroyed
828 void address_space_destroy(AddressSpace
*as
);
831 * address_space_rw: read from or write to an address space.
833 * @as: #AddressSpace to be accessed
834 * @addr: address within that address space
835 * @buf: buffer with the data transferred
836 * @is_write: indicates the transfer direction
838 void address_space_rw(AddressSpace
*as
, hwaddr addr
, uint8_t *buf
,
839 int len
, bool is_write
);
842 * address_space_write: write to address space.
844 * @as: #AddressSpace to be accessed
845 * @addr: address within that address space
846 * @buf: buffer with the data transferred
848 void address_space_write(AddressSpace
*as
, hwaddr addr
,
849 const uint8_t *buf
, int len
);
852 * address_space_read: read from an address space.
854 * @as: #AddressSpace to be accessed
855 * @addr: address within that address space
856 * @buf: buffer with the data transferred
858 void address_space_read(AddressSpace
*as
, hwaddr addr
, uint8_t *buf
, int len
);
860 /* address_space_map: map a physical memory region into a host virtual address
862 * May map a subset of the requested range, given by and returned in @plen.
863 * May return %NULL if resources needed to perform the mapping are exhausted.
864 * Use only for reads OR writes - not for read-modify-write operations.
865 * Use cpu_register_map_client() to know when retrying the map operation is
868 * @as: #AddressSpace to be accessed
869 * @addr: address within that address space
870 * @plen: pointer to length of buffer; updated on return
871 * @is_write: indicates the transfer direction
873 void *address_space_map(AddressSpace
*as
, hwaddr addr
,
874 hwaddr
*plen
, bool is_write
);
876 /* address_space_unmap: Unmaps a memory region previously mapped by address_space_map()
878 * Will also mark the memory as dirty if @is_write == %true. @access_len gives
879 * the amount of memory that was actually read or written by the caller.
881 * @as: #AddressSpace used
882 * @addr: address within that address space
883 * @len: buffer length as returned by address_space_map()
884 * @access_len: amount of data actually transferred
885 * @is_write: indicates the transfer direction
887 void address_space_unmap(AddressSpace
*as
, void *buffer
, hwaddr len
,
888 int is_write
, hwaddr access_len
);