Archipelago » qemu

#include <stdbool.h>

#include "qemu-common.h"

#include "cpu-common.h"

#include "qemu-queue.h"

#include "iorange.h"

#include "ioport.h"

struct MemoryRegionIORange {

    IORange iorange;

    MemoryRegion *mr;

};

/*

    /* Read from the memory region. @addr is relative to @mr; @size is

     * in bytes. */

    uint64_t (*read)(void *opaque,

                     unsigned size);

    /* Write to the memory region. @addr is relative to @mr; @size is

     * in bytes. */

    void (*write)(void *opaque,

                  uint64_t data,

                  unsigned size);

         * by the device (and results in machine dependent behaviour such

         * as a machine check exception).

         */

                        unsigned size, bool is_write);

    } valid;

    /* Internal implementation constraints: */

    void *opaque;

    MemoryRegion *parent;

    Int128 size;

    void (*destructor)(MemoryRegion *mr);

    ram_addr_t ram_addr;

    bool subpage;

    bool warning_printed; /* For reservations */

    bool flush_coalesced_mmio;

    MemoryRegion *alias;

    unsigned priority;

    bool may_overlap;

    QTAILQ_HEAD(subregions, MemoryRegion) subregions;

struct MemoryRegionSection {

    MemoryRegion *mr;

    AddressSpace *address_space;

    uint64_t size;

    bool readonly;

};

    void (*eventfd_del)(MemoryListener *listener, MemoryRegionSection *section,

                        bool match_data, uint64_t data, EventNotifier *e);

    void (*coalesced_mmio_add)(MemoryListener *listener, MemoryRegionSection *section,

    void (*coalesced_mmio_del)(MemoryListener *listener, MemoryRegionSection *section,

    /* Lower = earlier (during add), later (during del) */

    unsigned priority;

    AddressSpace *address_space_filter;

void memory_region_init_alias(MemoryRegion *mr,

                              const char *name,

                              MemoryRegion *orig,

                              uint64_t size);

/**

 * @client: the user of the logging information; %DIRTY_MEMORY_MIGRATION or

 *          %DIRTY_MEMORY_VGA.

 */

/**

 * memory_region_set_dirty: Mark a range of bytes as dirty in a memory region.

 * @addr: the address (relative to the start of the region) being dirtied.

 * @size: size of the range being dirtied.

 */

/**

 * memory_region_sync_dirty_bitmap: Synchronize a region's dirty bitmap with

 * @client: the user of the logging information; %DIRTY_MEMORY_MIGRATION or

 *          %DIRTY_MEMORY_VGA.

 */

/**

 * memory_region_set_readonly: Turn a memory region read-only (or read-write)

 * @size: the size of the subrange to be coalesced.

 */

void memory_region_add_coalescing(MemoryRegion *mr,

                                  uint64_t size);

/**

 * @fd: the eventfd to be triggered when @addr, @size, and @data all match.

 **/

void memory_region_add_eventfd(MemoryRegion *mr,

                               unsigned size,

                               bool match_data,

                               uint64_t data,

 * @fd: the eventfd to be triggered when @addr, @size, and @data all match.

 */

void memory_region_del_eventfd(MemoryRegion *mr,

                               unsigned size,

                               bool match_data,

                               uint64_t data,

 * @subregion: the subregion to be added.

 */

void memory_region_add_subregion(MemoryRegion *mr,

                                 MemoryRegion *subregion);

/**

 * memory_region_add_subregion_overlap: Add a subregion to a container

 * @priority: used for resolving overlaps; highest priority wins.

 */

void memory_region_add_subregion_overlap(MemoryRegion *mr,

                                         MemoryRegion *subregion,

                                         unsigned priority);

 * @mr: the region to be updated

 * @addr: new address, relative to parent region

 */

/*

 * memory_region_set_alias_offset: dynamically update a memory alias's offset

 * @offset: the new offset into the target memory region

 */

void memory_region_set_alias_offset(MemoryRegion *mr,

/**

 * memory_region_find: locate a MemoryRegion in an address space

 * @size: size of the area to be searched

 */

MemoryRegionSection memory_region_find(MemoryRegion *address_space,

/**

 * memory_region_section_addr: get offset within MemoryRegionSection

 * @section: the memory region section being queried

 * @addr: address in address space

 */

memory_region_section_addr(MemoryRegionSection *section,

{

    addr -= section->offset_within_address_space;

    addr += section->offset_within_region;

 * @buf: buffer with the data transferred

 * @is_write: indicates the transfer direction

 */

                      int len, bool is_write);

/**

 * @addr: address within that address space

 * @buf: buffer with the data transferred

 */

                         const uint8_t *buf, int len);

/**

 * @addr: address within that address space

 * @buf: buffer with the data transferred

 */

/* address_space_map: map a physical memory region into a host virtual address

 *

 * @plen: pointer to length of buffer; updated on return

 * @is_write: indicates the transfer direction

 */

/* address_space_unmap: Unmaps a memory region previously mapped by address_space_map()

 *

 * @access_len: amount of data actually transferred

 * @is_write: indicates the transfer direction

 */

#endif