pci: Unregister BARs before device exit

[qemu.git] / xen-all.c

diff --git a/xen-all.c b/xen-all.c
index 1b8248f04af1a21106de4b8ce6e972fb0f9b6da9..b5220cc6a31ca8dcf524fee6b2266b5eed9881c6 100644 (file)
--- a/xen-all.c
+++ b/xen-all.c
@@ -4,6 +4,8 @@
  * This work is licensed under the terms of the GNU GPL, version 2.  See
  * the COPYING file in the top-level directory.
  *
  * This work is licensed under the terms of the GNU GPL, version 2.  See
  * the COPYING file in the top-level directory.
  *

+ * Contributions after 2012-01-13 are licensed under the terms of the
+ * GNU GPL, version 2 or (at your option) any later version.

  */
 
 #include <sys/mman.h>
  */
 
 #include <sys/mman.h>


@@ -57,13 +59,16 @@ static inline ioreq_t *xen_vcpu_ioreq(shared_iopage_t *shared_page, int vcpu)
 }
 #  define FMT_ioreq_size "u"
 #endif
 }
 #  define FMT_ioreq_size "u"
 #endif

+#ifndef HVM_PARAM_BUFIOREQ_EVTCHN
+#define HVM_PARAM_BUFIOREQ_EVTCHN 26
+#endif

 
 #define BUFFER_IO_MAX_DELAY  100
 
 typedef struct XenPhysmap {
     target_phys_addr_t start_addr;
     ram_addr_t size;
 
 #define BUFFER_IO_MAX_DELAY  100
 
 typedef struct XenPhysmap {
     target_phys_addr_t start_addr;
     ram_addr_t size;

-    MemoryRegion *mr;
+    char *name;

     target_phys_addr_t phys_offset;
 
     QLIST_ENTRY(XenPhysmap) list;
     target_phys_addr_t phys_offset;
 
     QLIST_ENTRY(XenPhysmap) list;


@@ -75,6 +80,8 @@ typedef struct XenIOState {
     QEMUTimer *buffered_io_timer;
     /* the evtchn port for polling the notification, */
     evtchn_port_t *ioreq_local_port;
     QEMUTimer *buffered_io_timer;
     /* the evtchn port for polling the notification, */
     evtchn_port_t *ioreq_local_port;

+    /* evtchn local port for buffered io */
+    evtchn_port_t bufioreq_local_port;

     /* the evtchn fd for polling */
     XenEvtchn xce_handle;
     /* which vcpu we are serving */
     /* the evtchn fd for polling */
     XenEvtchn xce_handle;
     /* which vcpu we are serving */


@@ -87,6 +94,7 @@ typedef struct XenIOState {
     const XenPhysmap *log_for_dirtybit;
 
     Notifier exit;
     const XenPhysmap *log_for_dirtybit;
 
     Notifier exit;

+    Notifier suspend;

 } XenIOState;
 
 /* Xen specific function for piix pci */
 } XenIOState;
 
 /* Xen specific function for piix pci */


@@ -119,12 +127,14 @@ void xen_piix_pci_write_config_client(uint32_t address, uint32_t val, int len)
     }
 }
 
     }
 }
 

-void xen_cmos_set_s3_resume(void *opaque, int irq, int level)
+void xen_hvm_inject_msi(uint64_t addr, uint32_t data)

 {
 {

-    pc_cmos_set_s3_resume(opaque, irq, level);
-    if (level) {
-        xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 3);
-    }
+    xen_xc_hvm_inject_msi(xen_xc, xen_domid, addr, data);
+}
+
+static void xen_suspend_notifier(Notifier *notifier, void *data)
+{
+    xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 3);

 }
 
 /* Xen Interrupt Controller */
 }
 
 /* Xen Interrupt Controller */


@@ -190,6 +200,14 @@ void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size, MemoryRegion *mr)
     xen_pfn_t *pfn_list;
     int i;
 
     xen_pfn_t *pfn_list;
     int i;
 

+    if (runstate_check(RUN_STATE_INMIGRATE)) {
+        /* RAM already populated in Xen */
+        fprintf(stderr, "%s: do not alloc "RAM_ADDR_FMT
+                " bytes of ram at "RAM_ADDR_FMT" when runstate is INMIGRATE\n",
+                __func__, size, ram_addr); 
+        return;
+    }
+

     if (mr == &ram_memory) {
         return;
     }
     if (mr == &ram_memory) {
         return;
     }


@@ -225,6 +243,22 @@ static XenPhysmap *get_physmapping(XenIOState *state,
     return NULL;
 }
 
     return NULL;
 }
 

+static target_phys_addr_t xen_phys_offset_to_gaddr(target_phys_addr_t start_addr,
+                                                   ram_addr_t size, void *opaque)
+{
+    target_phys_addr_t addr = start_addr & TARGET_PAGE_MASK;
+    XenIOState *xen_io_state = opaque;
+    XenPhysmap *physmap = NULL;
+
+    QLIST_FOREACH(physmap, &xen_io_state->physmap, list) {
+        if (range_covers_byte(physmap->phys_offset, physmap->size, addr)) {
+            return physmap->start_addr;
+        }
+    }
+
+    return start_addr;
+}
+

 #if CONFIG_XEN_CTRL_INTERFACE_VERSION >= 340
 static int xen_add_to_physmap(XenIOState *state,
                               target_phys_addr_t start_addr,
 #if CONFIG_XEN_CTRL_INTERFACE_VERSION >= 340
 static int xen_add_to_physmap(XenIOState *state,
                               target_phys_addr_t start_addr,


@@ -237,6 +271,7 @@ static int xen_add_to_physmap(XenIOState *state,
     XenPhysmap *physmap = NULL;
     target_phys_addr_t pfn, start_gpfn;
     target_phys_addr_t phys_offset = memory_region_get_ram_addr(mr);
     XenPhysmap *physmap = NULL;
     target_phys_addr_t pfn, start_gpfn;
     target_phys_addr_t phys_offset = memory_region_get_ram_addr(mr);

+    char path[80], value[17];

 
     if (get_physmapping(state, start_addr, size)) {
         return 0;
 
     if (get_physmapping(state, start_addr, size)) {
         return 0;


@@ -275,6 +310,7 @@ go_physmap:
 
     physmap->start_addr = start_addr;
     physmap->size = size;
 
     physmap->start_addr = start_addr;
     physmap->size = size;

+    physmap->name = (char *)mr->name;

     physmap->phys_offset = phys_offset;
 
     QLIST_INSERT_HEAD(&state->physmap, physmap, list);
     physmap->phys_offset = phys_offset;
 
     QLIST_INSERT_HEAD(&state->physmap, physmap, list);


@@ -283,6 +319,30 @@ go_physmap:
                                    start_addr >> TARGET_PAGE_BITS,
                                    (start_addr + size) >> TARGET_PAGE_BITS,
                                    XEN_DOMCTL_MEM_CACHEATTR_WB);
                                    start_addr >> TARGET_PAGE_BITS,
                                    (start_addr + size) >> TARGET_PAGE_BITS,
                                    XEN_DOMCTL_MEM_CACHEATTR_WB);

+
+    snprintf(path, sizeof(path),
+            "/local/domain/0/device-model/%d/physmap/%"PRIx64"/start_addr",
+            xen_domid, (uint64_t)phys_offset);
+    snprintf(value, sizeof(value), "%"PRIx64, (uint64_t)start_addr);
+    if (!xs_write(state->xenstore, 0, path, value, strlen(value))) {
+        return -1;
+    }
+    snprintf(path, sizeof(path),
+            "/local/domain/0/device-model/%d/physmap/%"PRIx64"/size",
+            xen_domid, (uint64_t)phys_offset);
+    snprintf(value, sizeof(value), "%"PRIx64, (uint64_t)size);
+    if (!xs_write(state->xenstore, 0, path, value, strlen(value))) {
+        return -1;
+    }
+    if (mr->name) {
+        snprintf(path, sizeof(path),
+                "/local/domain/0/device-model/%d/physmap/%"PRIx64"/name",
+                xen_domid, (uint64_t)phys_offset);
+        if (!xs_write(state->xenstore, 0, path, mr->name, strlen(mr->name))) {
+            return -1;
+        }
+    }
+

     return 0;
 }
 
     return 0;
 }
 


@@ -392,6 +452,14 @@ static void xen_set_memory(struct MemoryListener *listener,
     }
 }
 
     }
 }
 

+static void xen_begin(MemoryListener *listener)
+{
+}
+
+static void xen_commit(MemoryListener *listener)
+{
+}
+

 static void xen_region_add(MemoryListener *listener,
                            MemoryRegionSection *section)
 {
 static void xen_region_add(MemoryListener *listener,
                            MemoryRegionSection *section)
 {


@@ -404,12 +472,16 @@ static void xen_region_del(MemoryListener *listener,
     xen_set_memory(listener, section, false);
 }
 
     xen_set_memory(listener, section, false);
 }
 

-static int xen_sync_dirty_bitmap(XenIOState *state,
-                                 target_phys_addr_t start_addr,
-                                 ram_addr_t size)
+static void xen_region_nop(MemoryListener *listener,
+                           MemoryRegionSection *section)
+{
+}
+
+static void xen_sync_dirty_bitmap(XenIOState *state,
+                                  target_phys_addr_t start_addr,
+                                  ram_addr_t size)

 {
     target_phys_addr_t npages = size >> TARGET_PAGE_BITS;
 {
     target_phys_addr_t npages = size >> TARGET_PAGE_BITS;

-    target_phys_addr_t vram_offset = 0;

     const int width = sizeof(unsigned long) * 8;
     unsigned long bitmap[(npages + width - 1) / width];
     int rc, i, j;
     const int width = sizeof(unsigned long) * 8;
     unsigned long bitmap[(npages + width - 1) / width];
     int rc, i, j;


@@ -418,21 +490,26 @@ static int xen_sync_dirty_bitmap(XenIOState *state,
     physmap = get_physmapping(state, start_addr, size);
     if (physmap == NULL) {
         /* not handled */
     physmap = get_physmapping(state, start_addr, size);
     if (physmap == NULL) {
         /* not handled */

-        return -1;
+        return;

     }
 
     if (state->log_for_dirtybit == NULL) {
         state->log_for_dirtybit = physmap;
     } else if (state->log_for_dirtybit != physmap) {
     }
 
     if (state->log_for_dirtybit == NULL) {
         state->log_for_dirtybit = physmap;
     } else if (state->log_for_dirtybit != physmap) {

-        return -1;
+        /* Only one range for dirty bitmap can be tracked. */
+        return;

     }
     }

-    vram_offset = physmap->phys_offset;

 
     rc = xc_hvm_track_dirty_vram(xen_xc, xen_domid,
                                  start_addr >> TARGET_PAGE_BITS, npages,
                                  bitmap);
 
     rc = xc_hvm_track_dirty_vram(xen_xc, xen_domid,
                                  start_addr >> TARGET_PAGE_BITS, npages,
                                  bitmap);

-    if (rc) {
-        return rc;
+    if (rc < 0) {
+        if (rc != -ENODATA) {
+            fprintf(stderr, "xen: track_dirty_vram failed (0x" TARGET_FMT_plx
+                    ", 0x" TARGET_FMT_plx "): %s\n",
+                    start_addr, start_addr + size, strerror(-rc));
+        }
+        return;

     }
 
     for (i = 0; i < ARRAY_SIZE(bitmap); i++) {
     }
 
     for (i = 0; i < ARRAY_SIZE(bitmap); i++) {


@@ -440,43 +517,37 @@ static int xen_sync_dirty_bitmap(XenIOState *state,
         while (map != 0) {
             j = ffsl(map) - 1;
             map &= ~(1ul << j);
         while (map != 0) {
             j = ffsl(map) - 1;
             map &= ~(1ul << j);

-            cpu_physical_memory_set_dirty(vram_offset + (i * width + j) * TARGET_PAGE_SIZE);
+            memory_region_set_dirty(framebuffer,
+                                    (i * width + j) * TARGET_PAGE_SIZE,
+                                    TARGET_PAGE_SIZE);

         };
     }
         };
     }

-
-    return 0;

 }
 
 static void xen_log_start(MemoryListener *listener,
                           MemoryRegionSection *section)
 {
     XenIOState *state = container_of(listener, XenIOState, memory_listener);
 }
 
 static void xen_log_start(MemoryListener *listener,
                           MemoryRegionSection *section)
 {
     XenIOState *state = container_of(listener, XenIOState, memory_listener);

-    int r;

 
 

-    r = xen_sync_dirty_bitmap(state, section->offset_within_address_space,
-                              section->size);
-    assert(r >= 0);
+    xen_sync_dirty_bitmap(state, section->offset_within_address_space,
+                          section->size);

 }
 
 static void xen_log_stop(MemoryListener *listener, MemoryRegionSection *section)
 {
     XenIOState *state = container_of(listener, XenIOState, memory_listener);
 }
 
 static void xen_log_stop(MemoryListener *listener, MemoryRegionSection *section)
 {
     XenIOState *state = container_of(listener, XenIOState, memory_listener);

-    int r;

 
     state->log_for_dirtybit = NULL;
     /* Disable dirty bit tracking */
 
     state->log_for_dirtybit = NULL;
     /* Disable dirty bit tracking */

-    r = xc_hvm_track_dirty_vram(xen_xc, xen_domid, 0, 0, NULL);
-    assert(r >= 0);
+    xc_hvm_track_dirty_vram(xen_xc, xen_domid, 0, 0, NULL);

 }
 
 static void xen_log_sync(MemoryListener *listener, MemoryRegionSection *section)
 {
     XenIOState *state = container_of(listener, XenIOState, memory_listener);
 }
 
 static void xen_log_sync(MemoryListener *listener, MemoryRegionSection *section)
 {
     XenIOState *state = container_of(listener, XenIOState, memory_listener);

-    int r;

 
 

-    r = xen_sync_dirty_bitmap(state, section->offset_within_address_space,
-                              section->size);
-    assert(r >= 0);
+    xen_sync_dirty_bitmap(state, section->offset_within_address_space,
+                          section->size);

 }
 
 static void xen_log_global_start(MemoryListener *listener)
 }
 
 static void xen_log_global_start(MemoryListener *listener)


@@ -487,33 +558,55 @@ static void xen_log_global_stop(MemoryListener *listener)
 {
 }
 
 {
 }
 

+static void xen_eventfd_add(MemoryListener *listener,
+                            MemoryRegionSection *section,
+                            bool match_data, uint64_t data, int fd)
+{
+}
+
+static void xen_eventfd_del(MemoryListener *listener,
+                            MemoryRegionSection *section,
+                            bool match_data, uint64_t data, int fd)
+{
+}
+

 static MemoryListener xen_memory_listener = {
 static MemoryListener xen_memory_listener = {

+    .begin = xen_begin,
+    .commit = xen_commit,

     .region_add = xen_region_add,
     .region_del = xen_region_del,
     .region_add = xen_region_add,
     .region_del = xen_region_del,

+    .region_nop = xen_region_nop,

     .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,
     .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,

+    .eventfd_add = xen_eventfd_add,
+    .eventfd_del = xen_eventfd_del,
+    .priority = 10,

 };
 
 /* VCPU Operations, MMIO, IO ring ... */
 
 static void xen_reset_vcpu(void *opaque)
 {
 };
 
 /* VCPU Operations, MMIO, IO ring ... */
 
 static void xen_reset_vcpu(void *opaque)
 {

-    CPUState *env = opaque;
+    CPUArchState *env = opaque;

 
     env->halted = 1;
 }
 
 void xen_vcpu_init(void)
 {
 
     env->halted = 1;
 }
 
 void xen_vcpu_init(void)
 {

-    CPUState *first_cpu;
+    CPUArchState *first_cpu;

 
     if ((first_cpu = qemu_get_cpu(0))) {
         qemu_register_reset(xen_reset_vcpu, first_cpu);
         xen_reset_vcpu(first_cpu);
     }
 
     if ((first_cpu = qemu_get_cpu(0))) {
         qemu_register_reset(xen_reset_vcpu, first_cpu);
         xen_reset_vcpu(first_cpu);
     }

+    /* if rtc_clock is left to default (host_clock), disable it */
+    if (rtc_clock == host_clock) {
+        qemu_clock_enable(rtc_clock, false);
+    }

 }
 
 /* get the ioreq packets from share mem */
 }
 
 /* get the ioreq packets from share mem */


@@ -545,6 +638,12 @@ static ioreq_t *cpu_get_ioreq(XenIOState *state)
     evtchn_port_t port;
 
     port = xc_evtchn_pending(state->xce_handle);
     evtchn_port_t port;
 
     port = xc_evtchn_pending(state->xce_handle);

+    if (port == state->bufioreq_local_port) {
+        qemu_mod_timer(state->buffered_io_timer,
+                BUFFER_IO_MAX_DELAY + qemu_get_clock_ms(rt_clock));
+        return NULL;
+    }
+

     if (port != -1) {
         for (i = 0; i < smp_cpus; i++) {
             if (state->ioreq_local_port[i] == port) {
     if (port != -1) {
         for (i = 0; i < smp_cpus; i++) {
             if (state->ioreq_local_port[i] == port) {


@@ -693,16 +792,18 @@ static void handle_ioreq(ioreq_t *req)
     }
 }
 
     }
 }
 

-static void handle_buffered_iopage(XenIOState *state)
+static int handle_buffered_iopage(XenIOState *state)

 {
     buf_ioreq_t *buf_req = NULL;
     ioreq_t req;
     int qw;
 
     if (!state->buffered_io_page) {
 {
     buf_ioreq_t *buf_req = NULL;
     ioreq_t req;
     int qw;
 
     if (!state->buffered_io_page) {

-        return;
+        return 0;

     }
 
     }
 

+    memset(&req, 0x00, sizeof(req));
+

     while (state->buffered_io_page->read_pointer != state->buffered_io_page->write_pointer) {
         buf_req = &state->buffered_io_page->buf_ioreq[
             state->buffered_io_page->read_pointer % IOREQ_BUFFER_SLOT_NUM];
     while (state->buffered_io_page->read_pointer != state->buffered_io_page->write_pointer) {
         buf_req = &state->buffered_io_page->buf_ioreq[
             state->buffered_io_page->read_pointer % IOREQ_BUFFER_SLOT_NUM];


@@ -727,15 +828,21 @@ static void handle_buffered_iopage(XenIOState *state)
         xen_mb();
         state->buffered_io_page->read_pointer += qw ? 2 : 1;
     }
         xen_mb();
         state->buffered_io_page->read_pointer += qw ? 2 : 1;
     }

+
+    return req.count;

 }
 
 static void handle_buffered_io(void *opaque)
 {
     XenIOState *state = opaque;
 
 }
 
 static void handle_buffered_io(void *opaque)
 {
     XenIOState *state = opaque;
 

-    handle_buffered_iopage(state);
-    qemu_mod_timer(state->buffered_io_timer,
-                   BUFFER_IO_MAX_DELAY + qemu_get_clock_ms(rt_clock));
+    if (handle_buffered_iopage(state)) {
+        qemu_mod_timer(state->buffered_io_timer,
+                BUFFER_IO_MAX_DELAY + qemu_get_clock_ms(rt_clock));
+    } else {
+        qemu_del_timer(state->buffered_io_timer);
+        xc_evtchn_unmask(state->xce_handle, state->bufioreq_local_port);
+    }

 }
 
 static void cpu_handle_ioreq(void *opaque)
 }
 
 static void cpu_handle_ioreq(void *opaque)


@@ -753,7 +860,7 @@ static void cpu_handle_ioreq(void *opaque)
                     "data: %"PRIx64", count: %" FMT_ioreq_size ", size: %" FMT_ioreq_size "\n",
                     req->state, req->data_is_ptr, req->addr,
                     req->data, req->count, req->size);
                     "data: %"PRIx64", count: %" FMT_ioreq_size ", size: %" FMT_ioreq_size "\n",
                     req->state, req->data_is_ptr, req->addr,
                     req->data, req->count, req->size);

-            destroy_hvm_domain();
+            destroy_hvm_domain(false);

             return;
         }
 
             return;
         }
 


@@ -767,10 +874,11 @@ static void cpu_handle_ioreq(void *opaque)
          */
         if (runstate_is_running()) {
             if (qemu_shutdown_requested_get()) {
          */
         if (runstate_is_running()) {
             if (qemu_shutdown_requested_get()) {

-                destroy_hvm_domain();
+                destroy_hvm_domain(false);

             }
             if (qemu_reset_requested_get()) {
                 qemu_system_reset(VMRESET_REPORT);
             }
             if (qemu_reset_requested_get()) {
                 qemu_system_reset(VMRESET_REPORT);

+                destroy_hvm_domain(true);

             }
         }
 
             }
         }
 


@@ -865,7 +973,6 @@ static void xen_main_loop_prepare(XenIOState *state)
 
     state->buffered_io_timer = qemu_new_timer_ms(rt_clock, handle_buffered_io,
                                                  state);
 
     state->buffered_io_timer = qemu_new_timer_ms(rt_clock, handle_buffered_io,
                                                  state);

-    qemu_mod_timer(state->buffered_io_timer, qemu_get_clock_ms(rt_clock));

 
     if (evtchn_fd != -1) {
         qemu_set_fd_handler(evtchn_fd, cpu_handle_ioreq, NULL, state);
 
     if (evtchn_fd != -1) {
         qemu_set_fd_handler(evtchn_fd, cpu_handle_ioreq, NULL, state);


@@ -913,10 +1020,60 @@ int xen_init(void)
     return 0;
 }
 
     return 0;
 }
 

+static void xen_read_physmap(XenIOState *state)
+{
+    XenPhysmap *physmap = NULL;
+    unsigned int len, num, i;
+    char path[80], *value = NULL;
+    char **entries = NULL;
+
+    snprintf(path, sizeof(path),
+            "/local/domain/0/device-model/%d/physmap", xen_domid);
+    entries = xs_directory(state->xenstore, 0, path, &num);
+    if (entries == NULL)
+        return;
+
+    for (i = 0; i < num; i++) {
+        physmap = g_malloc(sizeof (XenPhysmap));
+        physmap->phys_offset = strtoull(entries[i], NULL, 16);
+        snprintf(path, sizeof(path),
+                "/local/domain/0/device-model/%d/physmap/%s/start_addr",
+                xen_domid, entries[i]);
+        value = xs_read(state->xenstore, 0, path, &len);
+        if (value == NULL) {
+            free(physmap);
+            continue;
+        }
+        physmap->start_addr = strtoull(value, NULL, 16);
+        free(value);
+
+        snprintf(path, sizeof(path),
+                "/local/domain/0/device-model/%d/physmap/%s/size",
+                xen_domid, entries[i]);
+        value = xs_read(state->xenstore, 0, path, &len);
+        if (value == NULL) {
+            free(physmap);
+            continue;
+        }
+        physmap->size = strtoull(value, NULL, 16);
+        free(value);
+
+        snprintf(path, sizeof(path),
+                "/local/domain/0/device-model/%d/physmap/%s/name",
+                xen_domid, entries[i]);
+        physmap->name = xs_read(state->xenstore, 0, path, &len);
+
+        QLIST_INSERT_HEAD(&state->physmap, physmap, list);
+    }
+    free(entries);
+    return;
+}
+

 int xen_hvm_init(void)
 {
     int i, rc;
     unsigned long ioreq_pfn;
 int xen_hvm_init(void)
 {
     int i, rc;
     unsigned long ioreq_pfn;

+    unsigned long bufioreq_evtchn;

     XenIOState *state;
 
     state = g_malloc0(sizeof (XenIOState));
     XenIOState *state;
 
     state = g_malloc0(sizeof (XenIOState));


@@ -936,6 +1093,9 @@ int xen_hvm_init(void)
     state->exit.notify = xen_exit_notifier;
     qemu_add_exit_notifier(&state->exit);
 
     state->exit.notify = xen_exit_notifier;
     qemu_add_exit_notifier(&state->exit);
 

+    state->suspend.notify = xen_suspend_notifier;
+    qemu_register_suspend_notifier(&state->suspend);
+

     xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &ioreq_pfn);
     DPRINTF("shared page at pfn %lx\n", ioreq_pfn);
     state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
     xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &ioreq_pfn);
     DPRINTF("shared page at pfn %lx\n", ioreq_pfn);
     state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,


@@ -966,15 +1126,29 @@ int xen_hvm_init(void)
         state->ioreq_local_port[i] = rc;
     }
 
         state->ioreq_local_port[i] = rc;
     }
 

+    rc = xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_EVTCHN,
+            &bufioreq_evtchn);
+    if (rc < 0) {
+        fprintf(stderr, "failed to get HVM_PARAM_BUFIOREQ_EVTCHN\n");
+        return -1;
+    }
+    rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,
+            (uint32_t)bufioreq_evtchn);
+    if (rc == -1) {
+        fprintf(stderr, "bind interdomain ioctl error %d\n", errno);
+        return -1;
+    }
+    state->bufioreq_local_port = rc;
+

     /* Init RAM management */
     /* Init RAM management */

-    xen_map_cache_init();
+    xen_map_cache_init(xen_phys_offset_to_gaddr, state);

     xen_ram_init(ram_size);
 
     qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);
 
     state->memory_listener = xen_memory_listener;
     QLIST_INIT(&state->physmap);
     xen_ram_init(ram_size);
 
     qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);
 
     state->memory_listener = xen_memory_listener;
     QLIST_INIT(&state->physmap);

-    memory_listener_register(&state->memory_listener);
+    memory_listener_register(&state->memory_listener, get_system_memory());

     state->log_for_dirtybit = NULL;
 
     /* Initialize backend core & drivers */
     state->log_for_dirtybit = NULL;
 
     /* Initialize backend core & drivers */


@@ -985,11 +1159,12 @@ int xen_hvm_init(void)
     xen_be_register("console", &xen_console_ops);
     xen_be_register("vkbd", &xen_kbdmouse_ops);
     xen_be_register("qdisk", &xen_blkdev_ops);
     xen_be_register("console", &xen_console_ops);
     xen_be_register("vkbd", &xen_kbdmouse_ops);
     xen_be_register("qdisk", &xen_blkdev_ops);

+    xen_read_physmap(state);

 
     return 0;
 }
 
 
     return 0;
 }
 

-void destroy_hvm_domain(void)
+void destroy_hvm_domain(bool reboot)

 {
     XenXC xc_handle;
     int sts;
 {
     XenXC xc_handle;
     int sts;


@@ -998,12 +1173,15 @@ void destroy_hvm_domain(void)
     if (xc_handle == XC_HANDLER_INITIAL_VALUE) {
         fprintf(stderr, "Cannot acquire xenctrl handle\n");
     } else {
     if (xc_handle == XC_HANDLER_INITIAL_VALUE) {
         fprintf(stderr, "Cannot acquire xenctrl handle\n");
     } else {

-        sts = xc_domain_shutdown(xc_handle, xen_domid, SHUTDOWN_poweroff);
+        sts = xc_domain_shutdown(xc_handle, xen_domid,
+                                 reboot ? SHUTDOWN_reboot : SHUTDOWN_poweroff);

         if (sts != 0) {
         if (sts != 0) {

-            fprintf(stderr, "? xc_domain_shutdown failed to issue poweroff, "
-                    "sts %d, %s\n", sts, strerror(errno));
+            fprintf(stderr, "xc_domain_shutdown failed to issue %s, "
+                    "sts %d, %s\n", reboot ? "reboot" : "poweroff",
+                    sts, strerror(errno));

         } else {
         } else {

-            fprintf(stderr, "Issued domain %d poweroff\n", xen_domid);
+            fprintf(stderr, "Issued domain %d %s\n", xen_domid,
+                    reboot ? "reboot" : "poweroff");

         }
         xc_interface_close(xc_handle);
     }
         }
         xc_interface_close(xc_handle);
     }