#include "range.h"
#include "xen-mapcache.h"
#include "trace.h"
+#include "exec-memory.h"
#include <xen/hvm/ioreq.h>
#include <xen/hvm/params.h>
do { } while (0)
#endif
+static MemoryRegion ram_memory, ram_640k, ram_lo, ram_hi;
+static MemoryRegion *framebuffer;
+
/* Compatibility with older version */
#if __XEN_LATEST_INTERFACE_VERSION__ < 0x0003020a
static inline uint32_t xen_vcpu_eport(shared_iopage_t *shared_page, int i)
typedef struct XenPhysmap {
target_phys_addr_t start_addr;
ram_addr_t size;
+ MemoryRegion *mr;
target_phys_addr_t phys_offset;
QLIST_ENTRY(XenPhysmap) list;
int send_vcpu;
struct xs_handle *xenstore;
- CPUPhysMemoryClient client;
+ MemoryListener memory_listener;
QLIST_HEAD(, XenPhysmap) physmap;
+ target_phys_addr_t free_phys_offset;
const XenPhysmap *log_for_dirtybit;
Notifier exit;
static void xen_ram_init(ram_addr_t ram_size)
{
- RAMBlock *new_block;
+ MemoryRegion *sysmem = get_system_memory();
ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;
+ ram_addr_t block_len;
- new_block = qemu_mallocz(sizeof (*new_block));
- pstrcpy(new_block->idstr, sizeof (new_block->idstr), "xen.ram");
- new_block->host = NULL;
- new_block->offset = 0;
- new_block->length = ram_size;
+ block_len = ram_size;
if (ram_size >= HVM_BELOW_4G_RAM_END) {
/* Xen does not allocate the memory continuously, and keep a hole at
* HVM_BELOW_4G_MMIO_START of HVM_BELOW_4G_MMIO_LENGTH
*/
- new_block->length += HVM_BELOW_4G_MMIO_LENGTH;
+ block_len += HVM_BELOW_4G_MMIO_LENGTH;
}
-
- QLIST_INSERT_HEAD(&ram_list.blocks, new_block, next);
-
- ram_list.phys_dirty = qemu_realloc(ram_list.phys_dirty,
- new_block->length >> TARGET_PAGE_BITS);
- memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
- 0xff, new_block->length >> TARGET_PAGE_BITS);
+ memory_region_init_ram(&ram_memory, NULL, "xen.ram", block_len);
if (ram_size >= HVM_BELOW_4G_RAM_END) {
above_4g_mem_size = ram_size - HVM_BELOW_4G_RAM_END;
below_4g_mem_size = ram_size;
}
- cpu_register_physical_memory(0, 0xa0000, 0);
+ memory_region_init_alias(&ram_640k, "xen.ram.640k",
+ &ram_memory, 0, 0xa0000);
+ memory_region_add_subregion(sysmem, 0, &ram_640k);
/* Skip of the VGA IO memory space, it will be registered later by the VGA
* emulated device.
*
* The area between 0xc0000 and 0x100000 will be used by SeaBIOS to load
* the Options ROM, so it is registered here as RAM.
*/
- cpu_register_physical_memory(0xc0000, below_4g_mem_size - 0xc0000,
- 0xc0000);
+ memory_region_init_alias(&ram_lo, "xen.ram.lo",
+ &ram_memory, 0xc0000, below_4g_mem_size - 0xc0000);
+ memory_region_add_subregion(sysmem, 0xc0000, &ram_lo);
if (above_4g_mem_size > 0) {
- cpu_register_physical_memory(0x100000000ULL, above_4g_mem_size,
- 0x100000000ULL);
+ memory_region_init_alias(&ram_hi, "xen.ram.hi",
+ &ram_memory, 0x100000000ULL,
+ above_4g_mem_size);
+ memory_region_add_subregion(sysmem, 0x100000000ULL, &ram_hi);
}
}
-void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size)
+void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size, MemoryRegion *mr)
{
unsigned long nr_pfn;
xen_pfn_t *pfn_list;
int i;
+ if (mr == &ram_memory) {
+ return;
+ }
+
trace_xen_ram_alloc(ram_addr, size);
nr_pfn = size >> TARGET_PAGE_BITS;
- pfn_list = qemu_malloc(sizeof (*pfn_list) * nr_pfn);
+ pfn_list = g_malloc(sizeof (*pfn_list) * nr_pfn);
for (i = 0; i < nr_pfn; i++) {
pfn_list[i] = (ram_addr >> TARGET_PAGE_BITS) + i;
hw_error("xen: failed to populate ram at " RAM_ADDR_FMT, ram_addr);
}
- qemu_free(pfn_list);
+ g_free(pfn_list);
}
static XenPhysmap *get_physmapping(XenIOState *state,
static int xen_add_to_physmap(XenIOState *state,
target_phys_addr_t start_addr,
ram_addr_t size,
- target_phys_addr_t phys_offset)
+ MemoryRegion *mr,
+ target_phys_addr_t offset_within_region)
{
unsigned long i = 0;
int rc = 0;
XenPhysmap *physmap = NULL;
target_phys_addr_t pfn, start_gpfn;
- RAMBlock *block;
+ target_phys_addr_t phys_offset = memory_region_get_ram_addr(mr);
if (get_physmapping(state, start_addr, size)) {
return 0;
* the linear framebuffer to be that region.
* Avoid tracking any regions that is not videoram and avoid tracking
* the legacy vga region. */
- QLIST_FOREACH(block, &ram_list.blocks, next) {
- if (!strcmp(block->idstr, "vga.vram") && block->offset == phys_offset
- && start_addr > 0xbffff) {
- goto go_physmap;
- }
+ if (mr == framebuffer && start_addr > 0xbffff) {
+ goto go_physmap;
}
return -1;
go_physmap:
- DPRINTF("mapping vram to %llx - %llx, from %llx\n",
- start_addr, start_addr + size, phys_offset);
+ DPRINTF("mapping vram to %llx - %llx\n", start_addr, start_addr + size);
pfn = phys_offset >> TARGET_PAGE_BITS;
start_gpfn = start_addr >> TARGET_PAGE_BITS;
}
}
- physmap = qemu_malloc(sizeof (XenPhysmap));
+ physmap = g_malloc(sizeof (XenPhysmap));
physmap->start_addr = start_addr;
physmap->size = size;
static int xen_add_to_physmap(XenIOState *state,
target_phys_addr_t start_addr,
ram_addr_t size,
- target_phys_addr_t phys_offset)
+ MemoryRegion *mr,
+ target_phys_addr_t offset_within_region)
{
return -ENOSYS;
}
}
#endif
-static void xen_client_set_memory(struct CPUPhysMemoryClient *client,
- target_phys_addr_t start_addr,
- ram_addr_t size,
- ram_addr_t phys_offset,
- bool log_dirty)
+static void xen_set_memory(struct MemoryListener *listener,
+ MemoryRegionSection *section,
+ bool add)
{
- XenIOState *state = container_of(client, XenIOState, client);
- ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
+ XenIOState *state = container_of(listener, XenIOState, memory_listener);
+ target_phys_addr_t start_addr = section->offset_within_address_space;
+ ram_addr_t size = section->size;
+ bool log_dirty = memory_region_is_logging(section->mr);
hvmmem_type_t mem_type;
- if (!(start_addr != phys_offset
- && ( (log_dirty && flags < IO_MEM_UNASSIGNED)
- || (!log_dirty && flags == IO_MEM_UNASSIGNED)))) {
+ if (!memory_region_is_ram(section->mr)) {
return;
}
- trace_xen_client_set_memory(start_addr, size, phys_offset, log_dirty);
+ if (!(section->mr != &ram_memory
+ && ( (log_dirty && add) || (!log_dirty && !add)))) {
+ return;
+ }
+
+ trace_xen_client_set_memory(start_addr, size, log_dirty);
start_addr &= TARGET_PAGE_MASK;
size = TARGET_PAGE_ALIGN(size);
- phys_offset &= TARGET_PAGE_MASK;
-
- switch (flags) {
- case IO_MEM_RAM:
- xen_add_to_physmap(state, start_addr, size, phys_offset);
- break;
- case IO_MEM_ROM:
- mem_type = HVMMEM_ram_ro;
- if (xc_hvm_set_mem_type(xen_xc, xen_domid, mem_type,
- start_addr >> TARGET_PAGE_BITS,
- size >> TARGET_PAGE_BITS)) {
- DPRINTF("xc_hvm_set_mem_type error, addr: "TARGET_FMT_plx"\n",
- start_addr);
+
+ if (add) {
+ if (!memory_region_is_rom(section->mr)) {
+ xen_add_to_physmap(state, start_addr, size,
+ section->mr, section->offset_within_region);
+ } else {
+ mem_type = HVMMEM_ram_ro;
+ if (xc_hvm_set_mem_type(xen_xc, xen_domid, mem_type,
+ start_addr >> TARGET_PAGE_BITS,
+ size >> TARGET_PAGE_BITS)) {
+ DPRINTF("xc_hvm_set_mem_type error, addr: "TARGET_FMT_plx"\n",
+ start_addr);
+ }
}
- break;
- case IO_MEM_UNASSIGNED:
+ } else {
if (xen_remove_from_physmap(state, start_addr, size) < 0) {
DPRINTF("physmapping does not exist at "TARGET_FMT_plx"\n", start_addr);
}
- break;
}
}
+static void xen_region_add(MemoryListener *listener,
+ MemoryRegionSection *section)
+{
+ xen_set_memory(listener, section, true);
+}
+
+static void xen_region_del(MemoryListener *listener,
+ MemoryRegionSection *section)
+{
+ xen_set_memory(listener, section, false);
+}
+
static int xen_sync_dirty_bitmap(XenIOState *state,
target_phys_addr_t start_addr,
ram_addr_t size)
return 0;
}
-static int xen_log_start(CPUPhysMemoryClient *client, target_phys_addr_t phys_addr, ram_addr_t size)
+static void xen_log_start(MemoryListener *listener,
+ MemoryRegionSection *section)
{
- XenIOState *state = container_of(client, XenIOState, client);
+ XenIOState *state = container_of(listener, XenIOState, memory_listener);
+ int r;
- return xen_sync_dirty_bitmap(state, phys_addr, size);
+ r = xen_sync_dirty_bitmap(state, section->offset_within_address_space,
+ section->size);
+ assert(r >= 0);
}
-static int xen_log_stop(CPUPhysMemoryClient *client, target_phys_addr_t phys_addr, ram_addr_t size)
+static void xen_log_stop(MemoryListener *listener, MemoryRegionSection *section)
{
- XenIOState *state = container_of(client, XenIOState, client);
+ XenIOState *state = container_of(listener, XenIOState, memory_listener);
+ int r;
state->log_for_dirtybit = NULL;
/* Disable dirty bit tracking */
- return xc_hvm_track_dirty_vram(xen_xc, xen_domid, 0, 0, NULL);
+ r = xc_hvm_track_dirty_vram(xen_xc, xen_domid, 0, 0, NULL);
+ assert(r >= 0);
}
-static int xen_client_sync_dirty_bitmap(struct CPUPhysMemoryClient *client,
- target_phys_addr_t start_addr,
- target_phys_addr_t end_addr)
+static void xen_log_sync(MemoryListener *listener, MemoryRegionSection *section)
{
- XenIOState *state = container_of(client, XenIOState, client);
+ XenIOState *state = container_of(listener, XenIOState, memory_listener);
+ int r;
- return xen_sync_dirty_bitmap(state, start_addr, end_addr - start_addr);
+ r = xen_sync_dirty_bitmap(state, section->offset_within_address_space,
+ section->size);
+ assert(r >= 0);
}
-static int xen_client_migration_log(struct CPUPhysMemoryClient *client,
- int enable)
+static void xen_log_global_start(MemoryListener *listener)
{
- return 0;
}
-static CPUPhysMemoryClient xen_cpu_phys_memory_client = {
- .set_memory = xen_client_set_memory,
- .sync_dirty_bitmap = xen_client_sync_dirty_bitmap,
- .migration_log = xen_client_migration_log,
+static void xen_log_global_stop(MemoryListener *listener)
+{
+}
+
+static MemoryListener xen_memory_listener = {
+ .region_add = xen_region_add,
+ .region_del = xen_region_del,
.log_start = xen_log_start,
.log_stop = xen_log_stop,
+ .log_sync = xen_log_sync,
+ .log_global_start = xen_log_global_start,
+ .log_global_stop = xen_log_global_stop,
};
/* VCPU Operations, MMIO, IO ring ... */
}
}
} else {
- target_ulong tmp;
+ uint64_t tmp;
if (req->dir == IOREQ_READ) {
for (i = 0; i < req->count; i++) {
* guest resumes and does a hlt with interrupts disabled which
* causes Xen to powerdown the domain.
*/
- if (vm_running) {
+ if (runstate_is_running()) {
if (qemu_shutdown_requested_get()) {
destroy_hvm_domain();
}
/* Initialise Xen */
-static void xen_change_state_handler(void *opaque, int running, int reason)
+static void xen_change_state_handler(void *opaque, int running,
+ RunState state)
{
if (running) {
/* record state running */
}
}
-static void xen_hvm_change_state_handler(void *opaque, int running, int reason)
+static void xen_hvm_change_state_handler(void *opaque, int running,
+ RunState rstate)
{
- XenIOState *state = opaque;
+ XenIOState *xstate = opaque;
if (running) {
- xen_main_loop_prepare(state);
+ xen_main_loop_prepare(xstate);
}
}
unsigned long ioreq_pfn;
XenIOState *state;
- state = qemu_mallocz(sizeof (XenIOState));
+ state = g_malloc0(sizeof (XenIOState));
state->xce_handle = xen_xc_evtchn_open(NULL, 0);
if (state->xce_handle == XC_HANDLER_INITIAL_VALUE) {
hw_error("map buffered IO page returned error %d", errno);
}
- state->ioreq_local_port = qemu_mallocz(smp_cpus * sizeof (evtchn_port_t));
+ state->ioreq_local_port = g_malloc0(smp_cpus * sizeof (evtchn_port_t));
/* FIXME: how about if we overflow the page here? */
for (i = 0; i < smp_cpus; i++) {
qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);
- state->client = xen_cpu_phys_memory_client;
+ state->memory_listener = xen_memory_listener;
QLIST_INIT(&state->physmap);
- cpu_register_phys_memory_client(&state->client);
+ memory_listener_register(&state->memory_listener);
state->log_for_dirtybit = NULL;
/* Initialize backend core & drivers */
xc_interface_close(xc_handle);
}
}
+
+void xen_register_framebuffer(MemoryRegion *mr)
+{
+ framebuffer = mr;
+}
projects / qemu.git / blobdiff