hw/i386/xen/xen-hvm.c

   1 /*
   2  * Copyright (C) 2010       Citrix Ltd.
   3  *
   4  * This work is licensed under the terms of the GNU GPL, version 2.  See
   5  * the COPYING file in the top-level directory.
   6  *
   7  * Contributions after 2012-01-13 are licensed under the terms of the
   8  * GNU GPL, version 2 or (at your option) any later version.
   9  */
  10
  11 #include "qemu/osdep.h"
  12
  13 #include "cpu.h"
  14 #include "hw/pci/pci.h"
  15 #include "hw/i386/pc.h"
  16 #include "hw/i386/apic-msidef.h"
  17 #include "hw/xen/xen_common.h"
  18 #include "hw/xen/xen_backend.h"
  19 #include "qapi/error.h"
  20 #include "qapi/qapi-commands-misc.h"
  21 #include "qemu/error-report.h"
  22 #include "qemu/range.h"
  23 #include "sysemu/xen-mapcache.h"
  24 #include "trace.h"
  25 #include "exec/address-spaces.h"
  26
  27 #include <xen/hvm/ioreq.h>
  28 #include <xen/hvm/params.h>
  29 #include <xen/hvm/e820.h>
  30
  31 //#define DEBUG_XEN_HVM
  32
  33 #ifdef DEBUG_XEN_HVM
  34 #define DPRINTF(fmt, ...) \
  35     do { fprintf(stderr, "xen: " fmt, ## __VA_ARGS__); } while (0)
  36 #else
  37 #define DPRINTF(fmt, ...) \
  38     do { } while (0)
  39 #endif
  40
  41 static MemoryRegion ram_memory, ram_640k, ram_lo, ram_hi;
  42 static MemoryRegion *framebuffer;
  43 static bool xen_in_migration;
  44
  45 /* Compatibility with older version */
  46
  47 /* This allows QEMU to build on a system that has Xen 4.5 or earlier
  48  * installed.  This here (not in hw/xen/xen_common.h) because xen/hvm/ioreq.h
  49  * needs to be included before this block and hw/xen/xen_common.h needs to
  50  * be included before xen/hvm/ioreq.h
  51  */
  52 #ifndef IOREQ_TYPE_VMWARE_PORT
  53 #define IOREQ_TYPE_VMWARE_PORT  3
  54 struct vmware_regs {
  55     uint32_t esi;
  56     uint32_t edi;
  57     uint32_t ebx;
  58     uint32_t ecx;
  59     uint32_t edx;
  60 };
  61 typedef struct vmware_regs vmware_regs_t;
  62
  63 struct shared_vmport_iopage {
  64     struct vmware_regs vcpu_vmport_regs[1];
  65 };
  66 typedef struct shared_vmport_iopage shared_vmport_iopage_t;
  67 #endif
  68
  69 static inline uint32_t xen_vcpu_eport(shared_iopage_t *shared_page, int i)
  70 {
  71     return shared_page->vcpu_ioreq[i].vp_eport;
  72 }
  73 static inline ioreq_t *xen_vcpu_ioreq(shared_iopage_t *shared_page, int vcpu)
  74 {
  75     return &shared_page->vcpu_ioreq[vcpu];
  76 }
  77
  78 #define BUFFER_IO_MAX_DELAY  100
  79
  80 typedef struct XenPhysmap {
  81     hwaddr start_addr;
  82     ram_addr_t size;
  83     const char *name;
  84     hwaddr phys_offset;
  85
  86     QLIST_ENTRY(XenPhysmap) list;
  87 } XenPhysmap;
  88
  89 static QLIST_HEAD(, XenPhysmap) xen_physmap;
  90
  91 typedef struct XenIOState {
  92     ioservid_t ioservid;
  93     shared_iopage_t *shared_page;
  94     shared_vmport_iopage_t *shared_vmport_page;
  95     buffered_iopage_t *buffered_io_page;
  96     QEMUTimer *buffered_io_timer;
  97     CPUState **cpu_by_vcpu_id;
  98     /* the evtchn port for polling the notification, */
  99     evtchn_port_t *ioreq_local_port;
 100     /* evtchn remote and local ports for buffered io */
 101     evtchn_port_t bufioreq_remote_port;
 102     evtchn_port_t bufioreq_local_port;
 103     /* the evtchn fd for polling */
 104     xenevtchn_handle *xce_handle;
 105     /* which vcpu we are serving */
 106     int send_vcpu;
 107
 108     struct xs_handle *xenstore;
 109     MemoryListener memory_listener;
 110     MemoryListener io_listener;
 111     DeviceListener device_listener;
 112     hwaddr free_phys_offset;
 113     const XenPhysmap *log_for_dirtybit;
 114
 115     Notifier exit;
 116     Notifier suspend;
 117     Notifier wakeup;
 118 } XenIOState;
 119
 120 /* Xen specific function for piix pci */
 121
 122 int xen_pci_slot_get_pirq(PCIDevice *pci_dev, int irq_num)
 123 {
 124     return irq_num + ((pci_dev->devfn >> 3) << 2);
 125 }
 126
 127 void xen_piix3_set_irq(void *opaque, int irq_num, int level)
 128 {
 129     xen_set_pci_intx_level(xen_domid, 0, 0, irq_num >> 2,
 130                            irq_num & 3, level);
 131 }
 132
 133 void xen_piix_pci_write_config_client(uint32_t address, uint32_t val, int len)
 134 {
 135     int i;
 136
 137     /* Scan for updates to PCI link routes (0x60-0x63). */
 138     for (i = 0; i < len; i++) {
 139         uint8_t v = (val >> (8 * i)) & 0xff;
 140         if (v & 0x80) {
 141             v = 0;
 142         }
 143         v &= 0xf;
 144         if (((address + i) >= 0x60) && ((address + i) <= 0x63)) {
 145             xen_set_pci_link_route(xen_domid, address + i - 0x60, v);
 146         }
 147     }
 148 }
 149
 150 int xen_is_pirq_msi(uint32_t msi_data)
 151 {
 152     /* If vector is 0, the msi is remapped into a pirq, passed as
 153      * dest_id.
 154      */
 155     return ((msi_data & MSI_DATA_VECTOR_MASK) >> MSI_DATA_VECTOR_SHIFT) == 0;
 156 }
 157
 158 void xen_hvm_inject_msi(uint64_t addr, uint32_t data)
 159 {
 160     xen_inject_msi(xen_domid, addr, data);
 161 }
 162
 163 static void xen_suspend_notifier(Notifier *notifier, void *data)
 164 {
 165     xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 3);
 166 }
 167
 168 /* Xen Interrupt Controller */
 169
 170 static void xen_set_irq(void *opaque, int irq, int level)
 171 {
 172     xen_set_isa_irq_level(xen_domid, irq, level);
 173 }
 174
 175 qemu_irq *xen_interrupt_controller_init(void)
 176 {
 177     return qemu_allocate_irqs(xen_set_irq, NULL, 16);
 178 }
 179
 180 /* Memory Ops */
 181
 182 static void xen_ram_init(PCMachineState *pcms,
 183                          ram_addr_t ram_size, MemoryRegion **ram_memory_p)
 184 {
 185     MemoryRegion *sysmem = get_system_memory();
 186     ram_addr_t block_len;
 187     uint64_t user_lowmem = object_property_get_uint(qdev_get_machine(),
 188                                                     PC_MACHINE_MAX_RAM_BELOW_4G,
 189                                                     &error_abort);
 190
 191     /* Handle the machine opt max-ram-below-4g.  It is basically doing
 192      * min(xen limit, user limit).
 193      */
 194     if (!user_lowmem) {
 195         user_lowmem = HVM_BELOW_4G_RAM_END; /* default */
 196     }
 197     if (HVM_BELOW_4G_RAM_END <= user_lowmem) {
 198         user_lowmem = HVM_BELOW_4G_RAM_END;
 199     }
 200
 201     if (ram_size >= user_lowmem) {
 202         pcms->above_4g_mem_size = ram_size - user_lowmem;
 203         pcms->below_4g_mem_size = user_lowmem;
 204     } else {
 205         pcms->above_4g_mem_size = 0;
 206         pcms->below_4g_mem_size = ram_size;
 207     }
 208     if (!pcms->above_4g_mem_size) {
 209         block_len = ram_size;
 210     } else {
 211         /*
 212          * Xen does not allocate the memory continuously, it keeps a
 213          * hole of the size computed above or passed in.
 214          */
 215         block_len = (1ULL << 32) + pcms->above_4g_mem_size;
 216     }
 217     memory_region_init_ram(&ram_memory, NULL, "xen.ram", block_len,
 218                            &error_fatal);
 219     *ram_memory_p = &ram_memory;
 220
 221     memory_region_init_alias(&ram_640k, NULL, "xen.ram.640k",
 222                              &ram_memory, 0, 0xa0000);
 223     memory_region_add_subregion(sysmem, 0, &ram_640k);
 224     /* Skip of the VGA IO memory space, it will be registered later by the VGA
 225      * emulated device.
 226      *
 227      * The area between 0xc0000 and 0x100000 will be used by SeaBIOS to load
 228      * the Options ROM, so it is registered here as RAM.
 229      */
 230     memory_region_init_alias(&ram_lo, NULL, "xen.ram.lo",
 231                              &ram_memory, 0xc0000,
 232                              pcms->below_4g_mem_size - 0xc0000);
 233     memory_region_add_subregion(sysmem, 0xc0000, &ram_lo);
 234     if (pcms->above_4g_mem_size > 0) {
 235         memory_region_init_alias(&ram_hi, NULL, "xen.ram.hi",
 236                                  &ram_memory, 0x100000000ULL,
 237                                  pcms->above_4g_mem_size);
 238         memory_region_add_subregion(sysmem, 0x100000000ULL, &ram_hi);
 239     }
 240 }
 241
 242 void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size, MemoryRegion *mr,
 243                    Error **errp)
 244 {
 245     unsigned long nr_pfn;
 246     xen_pfn_t *pfn_list;
 247     int i;
 248
 249     if (runstate_check(RUN_STATE_INMIGRATE)) {
 250         /* RAM already populated in Xen */
 251         fprintf(stderr, "%s: do not alloc "RAM_ADDR_FMT
 252                 " bytes of ram at "RAM_ADDR_FMT" when runstate is INMIGRATE\n",
 253                 __func__, size, ram_addr);
 254         return;
 255     }
 256
 257     if (mr == &ram_memory) {
 258         return;
 259     }
 260
 261     trace_xen_ram_alloc(ram_addr, size);
 262
 263     nr_pfn = size >> TARGET_PAGE_BITS;
 264     pfn_list = g_malloc(sizeof (*pfn_list) * nr_pfn);
 265
 266     for (i = 0; i < nr_pfn; i++) {
 267         pfn_list[i] = (ram_addr >> TARGET_PAGE_BITS) + i;
 268     }
 269
 270     if (xc_domain_populate_physmap_exact(xen_xc, xen_domid, nr_pfn, 0, 0, pfn_list)) {
 271         error_setg(errp, "xen: failed to populate ram at " RAM_ADDR_FMT,
 272                    ram_addr);
 273     }
 274
 275     g_free(pfn_list);
 276 }
 277
 278 static XenPhysmap *get_physmapping(hwaddr start_addr, ram_addr_t size)
 279 {
 280     XenPhysmap *physmap = NULL;
 281
 282     start_addr &= TARGET_PAGE_MASK;
 283
 284     QLIST_FOREACH(physmap, &xen_physmap, list) {
 285         if (range_covers_byte(physmap->start_addr, physmap->size, start_addr)) {
 286             return physmap;
 287         }
 288     }
 289     return NULL;
 290 }
 291
 292 static hwaddr xen_phys_offset_to_gaddr(hwaddr phys_offset, ram_addr_t size)
 293 {
 294     hwaddr addr = phys_offset & TARGET_PAGE_MASK;
 295     XenPhysmap *physmap = NULL;
 296
 297     QLIST_FOREACH(physmap, &xen_physmap, list) {
 298         if (range_covers_byte(physmap->phys_offset, physmap->size, addr)) {
 299             return physmap->start_addr + (phys_offset - physmap->phys_offset);
 300         }
 301     }
 302
 303     return phys_offset;
 304 }
 305
 306 #ifdef XEN_COMPAT_PHYSMAP
 307 static int xen_save_physmap(XenIOState *state, XenPhysmap *physmap)
 308 {
 309     char path[80], value[17];
 310
 311     snprintf(path, sizeof(path),
 312             "/local/domain/0/device-model/%d/physmap/%"PRIx64"/start_addr",
 313             xen_domid, (uint64_t)physmap->phys_offset);
 314     snprintf(value, sizeof(value), "%"PRIx64, (uint64_t)physmap->start_addr);
 315     if (!xs_write(state->xenstore, 0, path, value, strlen(value))) {
 316         return -1;
 317     }
 318     snprintf(path, sizeof(path),
 319             "/local/domain/0/device-model/%d/physmap/%"PRIx64"/size",
 320             xen_domid, (uint64_t)physmap->phys_offset);
 321     snprintf(value, sizeof(value), "%"PRIx64, (uint64_t)physmap->size);
 322     if (!xs_write(state->xenstore, 0, path, value, strlen(value))) {
 323         return -1;
 324     }
 325     if (physmap->name) {
 326         snprintf(path, sizeof(path),
 327                 "/local/domain/0/device-model/%d/physmap/%"PRIx64"/name",
 328                 xen_domid, (uint64_t)physmap->phys_offset);
 329         if (!xs_write(state->xenstore, 0, path,
 330                       physmap->name, strlen(physmap->name))) {
 331             return -1;
 332         }
 333     }
 334     return 0;
 335 }
 336 #else
 337 static int xen_save_physmap(XenIOState *state, XenPhysmap *physmap)
 338 {
 339     return 0;
 340 }
 341 #endif
 342
 343 static int xen_add_to_physmap(XenIOState *state,
 344                               hwaddr start_addr,
 345                               ram_addr_t size,
 346                               MemoryRegion *mr,
 347                               hwaddr offset_within_region)
 348 {
 349     unsigned long nr_pages;
 350     int rc = 0;
 351     XenPhysmap *physmap = NULL;
 352     hwaddr pfn, start_gpfn;
 353     hwaddr phys_offset = memory_region_get_ram_addr(mr);
 354     const char *mr_name;
 355
 356     if (get_physmapping(start_addr, size)) {
 357         return 0;
 358     }
 359     if (size <= 0) {
 360         return -1;
 361     }
 362
 363     /* Xen can only handle a single dirty log region for now and we want
 364      * the linear framebuffer to be that region.
 365      * Avoid tracking any regions that is not videoram and avoid tracking
 366      * the legacy vga region. */
 367     if (mr == framebuffer && start_addr > 0xbffff) {
 368         goto go_physmap;
 369     }
 370     return -1;
 371
 372 go_physmap:
 373     DPRINTF("mapping vram to %"HWADDR_PRIx" - %"HWADDR_PRIx"\n",
 374             start_addr, start_addr + size);
 375
 376     mr_name = memory_region_name(mr);
 377
 378     physmap = g_malloc(sizeof(XenPhysmap));
 379
 380     physmap->start_addr = start_addr;
 381     physmap->size = size;
 382     physmap->name = mr_name;
 383     physmap->phys_offset = phys_offset;
 384
 385     QLIST_INSERT_HEAD(&xen_physmap, physmap, list);
 386
 387     if (runstate_check(RUN_STATE_INMIGRATE)) {
 388         /* Now when we have a physmap entry we can replace a dummy mapping with
 389          * a real one of guest foreign memory. */
 390         uint8_t *p = xen_replace_cache_entry(phys_offset, start_addr, size);
 391         assert(p && p == memory_region_get_ram_ptr(mr));
 392
 393         return 0;
 394     }
 395
 396     pfn = phys_offset >> TARGET_PAGE_BITS;
 397     start_gpfn = start_addr >> TARGET_PAGE_BITS;
 398     nr_pages = size >> TARGET_PAGE_BITS;
 399     rc = xendevicemodel_relocate_memory(xen_dmod, xen_domid, nr_pages, pfn,
 400                                         start_gpfn);
 401     if (rc) {
 402         int saved_errno = errno;
 403
 404         error_report("relocate_memory %lu pages from GFN %"HWADDR_PRIx
 405                      " to GFN %"HWADDR_PRIx" failed: %s",
 406                      nr_pages, pfn, start_gpfn, strerror(saved_errno));
 407         errno = saved_errno;
 408         return -1;
 409     }
 410
 411     rc = xendevicemodel_pin_memory_cacheattr(xen_dmod, xen_domid,
 412                                    start_addr >> TARGET_PAGE_BITS,
 413                                    (start_addr + size - 1) >> TARGET_PAGE_BITS,
 414                                    XEN_DOMCTL_MEM_CACHEATTR_WB);
 415     if (rc) {
 416         error_report("pin_memory_cacheattr failed: %s", strerror(errno));
 417     }
 418     return xen_save_physmap(state, physmap);
 419 }
 420
 421 static int xen_remove_from_physmap(XenIOState *state,
 422                                    hwaddr start_addr,
 423                                    ram_addr_t size)
 424 {
 425     int rc = 0;
 426     XenPhysmap *physmap = NULL;
 427     hwaddr phys_offset = 0;
 428
 429     physmap = get_physmapping(start_addr, size);
 430     if (physmap == NULL) {
 431         return -1;
 432     }
 433
 434     phys_offset = physmap->phys_offset;
 435     size = physmap->size;
 436
 437     DPRINTF("unmapping vram to %"HWADDR_PRIx" - %"HWADDR_PRIx", at "
 438             "%"HWADDR_PRIx"\n", start_addr, start_addr + size, phys_offset);
 439
 440     size >>= TARGET_PAGE_BITS;
 441     start_addr >>= TARGET_PAGE_BITS;
 442     phys_offset >>= TARGET_PAGE_BITS;
 443     rc = xendevicemodel_relocate_memory(xen_dmod, xen_domid, size, start_addr,
 444                                         phys_offset);
 445     if (rc) {
 446         int saved_errno = errno;
 447
 448         error_report("relocate_memory "RAM_ADDR_FMT" pages"
 449                      " from GFN %"HWADDR_PRIx
 450                      " to GFN %"HWADDR_PRIx" failed: %s",
 451                      size, start_addr, phys_offset, strerror(saved_errno));
 452         errno = saved_errno;
 453         return -1;
 454     }
 455
 456     QLIST_REMOVE(physmap, list);
 457     if (state->log_for_dirtybit == physmap) {
 458         state->log_for_dirtybit = NULL;
 459     }
 460     g_free(physmap);
 461
 462     return 0;
 463 }
 464
 465 static void xen_set_memory(struct MemoryListener *listener,
 466                            MemoryRegionSection *section,
 467                            bool add)
 468 {
 469     XenIOState *state = container_of(listener, XenIOState, memory_listener);
 470     hwaddr start_addr = section->offset_within_address_space;
 471     ram_addr_t size = int128_get64(section->size);
 472     bool log_dirty = memory_region_is_logging(section->mr, DIRTY_MEMORY_VGA);
 473     hvmmem_type_t mem_type;
 474
 475     if (section->mr == &ram_memory) {
 476         return;
 477     } else {
 478         if (add) {
 479             xen_map_memory_section(xen_domid, state->ioservid,
 480                                    section);
 481         } else {
 482             xen_unmap_memory_section(xen_domid, state->ioservid,
 483                                      section);
 484         }
 485     }
 486
 487     if (!memory_region_is_ram(section->mr)) {
 488         return;
 489     }
 490
 491     if (log_dirty != add) {
 492         return;
 493     }
 494
 495     trace_xen_client_set_memory(start_addr, size, log_dirty);
 496
 497     start_addr &= TARGET_PAGE_MASK;
 498     size = TARGET_PAGE_ALIGN(size);
 499
 500     if (add) {
 501         if (!memory_region_is_rom(section->mr)) {
 502             xen_add_to_physmap(state, start_addr, size,
 503                                section->mr, section->offset_within_region);
 504         } else {
 505             mem_type = HVMMEM_ram_ro;
 506             if (xen_set_mem_type(xen_domid, mem_type,
 507                                  start_addr >> TARGET_PAGE_BITS,
 508                                  size >> TARGET_PAGE_BITS)) {
 509                 DPRINTF("xen_set_mem_type error, addr: "TARGET_FMT_plx"\n",
 510                         start_addr);
 511             }
 512         }
 513     } else {
 514         if (xen_remove_from_physmap(state, start_addr, size) < 0) {
 515             DPRINTF("physmapping does not exist at "TARGET_FMT_plx"\n", start_addr);
 516         }
 517     }
 518 }
 519
 520 static void xen_region_add(MemoryListener *listener,
 521                            MemoryRegionSection *section)
 522 {
 523     memory_region_ref(section->mr);
 524     xen_set_memory(listener, section, true);
 525 }
 526
 527 static void xen_region_del(MemoryListener *listener,
 528                            MemoryRegionSection *section)
 529 {
 530     xen_set_memory(listener, section, false);
 531     memory_region_unref(section->mr);
 532 }
 533
 534 static void xen_io_add(MemoryListener *listener,
 535                        MemoryRegionSection *section)
 536 {
 537     XenIOState *state = container_of(listener, XenIOState, io_listener);
 538     MemoryRegion *mr = section->mr;
 539
 540     if (mr->ops == &unassigned_io_ops) {
 541         return;
 542     }
 543
 544     memory_region_ref(mr);
 545
 546     xen_map_io_section(xen_domid, state->ioservid, section);
 547 }
 548
 549 static void xen_io_del(MemoryListener *listener,
 550                        MemoryRegionSection *section)
 551 {
 552     XenIOState *state = container_of(listener, XenIOState, io_listener);
 553     MemoryRegion *mr = section->mr;
 554
 555     if (mr->ops == &unassigned_io_ops) {
 556         return;
 557     }
 558
 559     xen_unmap_io_section(xen_domid, state->ioservid, section);
 560
 561     memory_region_unref(mr);
 562 }
 563
 564 static void xen_device_realize(DeviceListener *listener,
 565                                DeviceState *dev)
 566 {
 567     XenIOState *state = container_of(listener, XenIOState, device_listener);
 568
 569     if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) {
 570         PCIDevice *pci_dev = PCI_DEVICE(dev);
 571
 572         xen_map_pcidev(xen_domid, state->ioservid, pci_dev);
 573     }
 574 }
 575
 576 static void xen_device_unrealize(DeviceListener *listener,
 577                                  DeviceState *dev)
 578 {
 579     XenIOState *state = container_of(listener, XenIOState, device_listener);
 580
 581     if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) {
 582         PCIDevice *pci_dev = PCI_DEVICE(dev);
 583
 584         xen_unmap_pcidev(xen_domid, state->ioservid, pci_dev);
 585     }
 586 }
 587
 588 static void xen_sync_dirty_bitmap(XenIOState *state,
 589                                   hwaddr start_addr,
 590                                   ram_addr_t size)
 591 {
 592     hwaddr npages = size >> TARGET_PAGE_BITS;
 593     const int width = sizeof(unsigned long) * 8;
 594     unsigned long bitmap[DIV_ROUND_UP(npages, width)];
 595     int rc, i, j;
 596     const XenPhysmap *physmap = NULL;
 597
 598     physmap = get_physmapping(start_addr, size);
 599     if (physmap == NULL) {
 600         /* not handled */
 601         return;
 602     }
 603
 604     if (state->log_for_dirtybit == NULL) {
 605         state->log_for_dirtybit = physmap;
 606     } else if (state->log_for_dirtybit != physmap) {
 607         /* Only one range for dirty bitmap can be tracked. */
 608         return;
 609     }
 610
 611     rc = xen_track_dirty_vram(xen_domid, start_addr >> TARGET_PAGE_BITS,
 612                               npages, bitmap);
 613     if (rc < 0) {
 614 #ifndef ENODATA
 615 #define ENODATA  ENOENT
 616 #endif
 617         if (errno == ENODATA) {
 618             memory_region_set_dirty(framebuffer, 0, size);
 619             DPRINTF("xen: track_dirty_vram failed (0x" TARGET_FMT_plx
 620                     ", 0x" TARGET_FMT_plx "): %s\n",
 621                     start_addr, start_addr + size, strerror(errno));
 622         }
 623         return;
 624     }
 625
 626     for (i = 0; i < ARRAY_SIZE(bitmap); i++) {
 627         unsigned long map = bitmap[i];
 628         while (map != 0) {
 629             j = ctzl(map);
 630             map &= ~(1ul << j);
 631             memory_region_set_dirty(framebuffer,
 632                                     (i * width + j) * TARGET_PAGE_SIZE,
 633                                     TARGET_PAGE_SIZE);
 634         };
 635     }
 636 }
 637
 638 static void xen_log_start(MemoryListener *listener,
 639                           MemoryRegionSection *section,
 640                           int old, int new)
 641 {
 642     XenIOState *state = container_of(listener, XenIOState, memory_listener);
 643
 644     if (new & ~old & (1 << DIRTY_MEMORY_VGA)) {
 645         xen_sync_dirty_bitmap(state, section->offset_within_address_space,
 646                               int128_get64(section->size));
 647     }
 648 }
 649
 650 static void xen_log_stop(MemoryListener *listener, MemoryRegionSection *section,
 651                          int old, int new)
 652 {
 653     XenIOState *state = container_of(listener, XenIOState, memory_listener);
 654
 655     if (old & ~new & (1 << DIRTY_MEMORY_VGA)) {
 656         state->log_for_dirtybit = NULL;
 657         /* Disable dirty bit tracking */
 658         xen_track_dirty_vram(xen_domid, 0, 0, NULL);
 659     }
 660 }
 661
 662 static void xen_log_sync(MemoryListener *listener, MemoryRegionSection *section)
 663 {
 664     XenIOState *state = container_of(listener, XenIOState, memory_listener);
 665
 666     xen_sync_dirty_bitmap(state, section->offset_within_address_space,
 667                           int128_get64(section->size));
 668 }
 669
 670 static void xen_log_global_start(MemoryListener *listener)
 671 {
 672     if (xen_enabled()) {
 673         xen_in_migration = true;
 674     }
 675 }
 676
 677 static void xen_log_global_stop(MemoryListener *listener)
 678 {
 679     xen_in_migration = false;
 680 }
 681
 682 static MemoryListener xen_memory_listener = {
 683     .region_add = xen_region_add,
 684     .region_del = xen_region_del,
 685     .log_start = xen_log_start,
 686     .log_stop = xen_log_stop,
 687     .log_sync = xen_log_sync,
 688     .log_global_start = xen_log_global_start,
 689     .log_global_stop = xen_log_global_stop,
 690     .priority = 10,
 691 };
 692
 693 static MemoryListener xen_io_listener = {
 694     .region_add = xen_io_add,
 695     .region_del = xen_io_del,
 696     .priority = 10,
 697 };
 698
 699 static DeviceListener xen_device_listener = {
 700     .realize = xen_device_realize,
 701     .unrealize = xen_device_unrealize,
 702 };
 703
 704 /* get the ioreq packets from share mem */
 705 static ioreq_t *cpu_get_ioreq_from_shared_memory(XenIOState *state, int vcpu)
 706 {
 707     ioreq_t *req = xen_vcpu_ioreq(state->shared_page, vcpu);
 708
 709     if (req->state != STATE_IOREQ_READY) {
 710         DPRINTF("I/O request not ready: "
 711                 "%x, ptr: %x, port: %"PRIx64", "
 712                 "data: %"PRIx64", count: %u, size: %u\n",
 713                 req->state, req->data_is_ptr, req->addr,
 714                 req->data, req->count, req->size);
 715         return NULL;
 716     }
 717
 718     xen_rmb(); /* see IOREQ_READY /then/ read contents of ioreq */
 719
 720     req->state = STATE_IOREQ_INPROCESS;
 721     return req;
 722 }
 723
 724 /* use poll to get the port notification */
 725 /* ioreq_vec--out,the */
 726 /* retval--the number of ioreq packet */
 727 static ioreq_t *cpu_get_ioreq(XenIOState *state)
 728 {
 729     int i;
 730     evtchn_port_t port;
 731
 732     port = xenevtchn_pending(state->xce_handle);
 733     if (port == state->bufioreq_local_port) {
 734         timer_mod(state->buffered_io_timer,
 735                 BUFFER_IO_MAX_DELAY + qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
 736         return NULL;
 737     }
 738
 739     if (port != -1) {
 740         for (i = 0; i < max_cpus; i++) {
 741             if (state->ioreq_local_port[i] == port) {
 742                 break;
 743             }
 744         }
 745
 746         if (i == max_cpus) {
 747             hw_error("Fatal error while trying to get io event!\n");
 748         }
 749
 750         /* unmask the wanted port again */
 751         xenevtchn_unmask(state->xce_handle, port);
 752
 753         /* get the io packet from shared memory */
 754         state->send_vcpu = i;
 755         return cpu_get_ioreq_from_shared_memory(state, i);
 756     }
 757
 758     /* read error or read nothing */
 759     return NULL;
 760 }
 761
 762 static uint32_t do_inp(uint32_t addr, unsigned long size)
 763 {
 764     switch (size) {
 765         case 1:
 766             return cpu_inb(addr);
 767         case 2:
 768             return cpu_inw(addr);
 769         case 4:
 770             return cpu_inl(addr);
 771         default:
 772             hw_error("inp: bad size: %04x %lx", addr, size);
 773     }
 774 }
 775
 776 static void do_outp(uint32_t addr,
 777         unsigned long size, uint32_t val)
 778 {
 779     switch (size) {
 780         case 1:
 781             return cpu_outb(addr, val);
 782         case 2:
 783             return cpu_outw(addr, val);
 784         case 4:
 785             return cpu_outl(addr, val);
 786         default:
 787             hw_error("outp: bad size: %04x %lx", addr, size);
 788     }
 789 }
 790
 791 /*
 792  * Helper functions which read/write an object from/to physical guest
 793  * memory, as part of the implementation of an ioreq.
 794  *
 795  * Equivalent to
 796  *   cpu_physical_memory_rw(addr + (req->df ? -1 : +1) * req->size * i,
 797  *                          val, req->size, 0/1)
 798  * except without the integer overflow problems.
 799  */
 800 static void rw_phys_req_item(hwaddr addr,
 801                              ioreq_t *req, uint32_t i, void *val, int rw)
 802 {
 803     /* Do everything unsigned so overflow just results in a truncated result
 804      * and accesses to undesired parts of guest memory, which is up
 805      * to the guest */
 806     hwaddr offset = (hwaddr)req->size * i;
 807     if (req->df) {
 808         addr -= offset;
 809     } else {
 810         addr += offset;
 811     }
 812     cpu_physical_memory_rw(addr, val, req->size, rw);
 813 }
 814
 815 static inline void read_phys_req_item(hwaddr addr,
 816                                       ioreq_t *req, uint32_t i, void *val)
 817 {
 818     rw_phys_req_item(addr, req, i, val, 0);
 819 }
 820 static inline void write_phys_req_item(hwaddr addr,
 821                                        ioreq_t *req, uint32_t i, void *val)
 822 {
 823     rw_phys_req_item(addr, req, i, val, 1);
 824 }
 825
 826
 827 static void cpu_ioreq_pio(ioreq_t *req)
 828 {
 829     uint32_t i;
 830
 831     trace_cpu_ioreq_pio(req, req->dir, req->df, req->data_is_ptr, req->addr,
 832                          req->data, req->count, req->size);
 833
 834     if (req->size > sizeof(uint32_t)) {
 835         hw_error("PIO: bad size (%u)", req->size);
 836     }
 837
 838     if (req->dir == IOREQ_READ) {
 839         if (!req->data_is_ptr) {
 840             req->data = do_inp(req->addr, req->size);
 841             trace_cpu_ioreq_pio_read_reg(req, req->data, req->addr,
 842                                          req->size);
 843         } else {
 844             uint32_t tmp;
 845
 846             for (i = 0; i < req->count; i++) {
 847                 tmp = do_inp(req->addr, req->size);
 848                 write_phys_req_item(req->data, req, i, &tmp);
 849             }
 850         }
 851     } else if (req->dir == IOREQ_WRITE) {
 852         if (!req->data_is_ptr) {
 853             trace_cpu_ioreq_pio_write_reg(req, req->data, req->addr,
 854                                           req->size);
 855             do_outp(req->addr, req->size, req->data);
 856         } else {
 857             for (i = 0; i < req->count; i++) {
 858                 uint32_t tmp = 0;
 859
 860                 read_phys_req_item(req->data, req, i, &tmp);
 861                 do_outp(req->addr, req->size, tmp);
 862             }
 863         }
 864     }
 865 }
 866
 867 static void cpu_ioreq_move(ioreq_t *req)
 868 {
 869     uint32_t i;
 870
 871     trace_cpu_ioreq_move(req, req->dir, req->df, req->data_is_ptr, req->addr,
 872                          req->data, req->count, req->size);
 873
 874     if (req->size > sizeof(req->data)) {
 875         hw_error("MMIO: bad size (%u)", req->size);
 876     }
 877
 878     if (!req->data_is_ptr) {
 879         if (req->dir == IOREQ_READ) {
 880             for (i = 0; i < req->count; i++) {
 881                 read_phys_req_item(req->addr, req, i, &req->data);
 882             }
 883         } else if (req->dir == IOREQ_WRITE) {
 884             for (i = 0; i < req->count; i++) {
 885                 write_phys_req_item(req->addr, req, i, &req->data);
 886             }
 887         }
 888     } else {
 889         uint64_t tmp;
 890
 891         if (req->dir == IOREQ_READ) {
 892             for (i = 0; i < req->count; i++) {
 893                 read_phys_req_item(req->addr, req, i, &tmp);
 894                 write_phys_req_item(req->data, req, i, &tmp);
 895             }
 896         } else if (req->dir == IOREQ_WRITE) {
 897             for (i = 0; i < req->count; i++) {
 898                 read_phys_req_item(req->data, req, i, &tmp);
 899                 write_phys_req_item(req->addr, req, i, &tmp);
 900             }
 901         }
 902     }
 903 }
 904
 905 static void regs_to_cpu(vmware_regs_t *vmport_regs, ioreq_t *req)
 906 {
 907     X86CPU *cpu;
 908     CPUX86State *env;
 909
 910     cpu = X86_CPU(current_cpu);
 911     env = &cpu->env;
 912     env->regs[R_EAX] = req->data;
 913     env->regs[R_EBX] = vmport_regs->ebx;
 914     env->regs[R_ECX] = vmport_regs->ecx;
 915     env->regs[R_EDX] = vmport_regs->edx;
 916     env->regs[R_ESI] = vmport_regs->esi;
 917     env->regs[R_EDI] = vmport_regs->edi;
 918 }
 919
 920 static void regs_from_cpu(vmware_regs_t *vmport_regs)
 921 {
 922     X86CPU *cpu = X86_CPU(current_cpu);
 923     CPUX86State *env = &cpu->env;
 924
 925     vmport_regs->ebx = env->regs[R_EBX];
 926     vmport_regs->ecx = env->regs[R_ECX];
 927     vmport_regs->edx = env->regs[R_EDX];
 928     vmport_regs->esi = env->regs[R_ESI];
 929     vmport_regs->edi = env->regs[R_EDI];
 930 }
 931
 932 static void handle_vmport_ioreq(XenIOState *state, ioreq_t *req)
 933 {
 934     vmware_regs_t *vmport_regs;
 935
 936     assert(state->shared_vmport_page);
 937     vmport_regs =
 938         &state->shared_vmport_page->vcpu_vmport_regs[state->send_vcpu];
 939     QEMU_BUILD_BUG_ON(sizeof(*req) < sizeof(*vmport_regs));
 940
 941     current_cpu = state->cpu_by_vcpu_id[state->send_vcpu];
 942     regs_to_cpu(vmport_regs, req);
 943     cpu_ioreq_pio(req);
 944     regs_from_cpu(vmport_regs);
 945     current_cpu = NULL;
 946 }
 947
 948 static void handle_ioreq(XenIOState *state, ioreq_t *req)
 949 {
 950     trace_handle_ioreq(req, req->type, req->dir, req->df, req->data_is_ptr,
 951                        req->addr, req->data, req->count, req->size);
 952
 953     if (!req->data_is_ptr && (req->dir == IOREQ_WRITE) &&
 954             (req->size < sizeof (target_ulong))) {
 955         req->data &= ((target_ulong) 1 << (8 * req->size)) - 1;
 956     }
 957
 958     if (req->dir == IOREQ_WRITE)
 959         trace_handle_ioreq_write(req, req->type, req->df, req->data_is_ptr,
 960                                  req->addr, req->data, req->count, req->size);
 961
 962     switch (req->type) {
 963         case IOREQ_TYPE_PIO:
 964             cpu_ioreq_pio(req);
 965             break;
 966         case IOREQ_TYPE_COPY:
 967             cpu_ioreq_move(req);
 968             break;
 969         case IOREQ_TYPE_VMWARE_PORT:
 970             handle_vmport_ioreq(state, req);
 971             break;
 972         case IOREQ_TYPE_TIMEOFFSET:
 973             break;
 974         case IOREQ_TYPE_INVALIDATE:
 975             xen_invalidate_map_cache();
 976             break;
 977         case IOREQ_TYPE_PCI_CONFIG: {
 978             uint32_t sbdf = req->addr >> 32;
 979             uint32_t val;
 980
 981             /* Fake a write to port 0xCF8 so that
 982              * the config space access will target the
 983              * correct device model.
 984              */
 985             val = (1u << 31) |
 986                   ((req->addr & 0x0f00) << 16) |
 987                   ((sbdf & 0xffff) << 8) |
 988                   (req->addr & 0xfc);
 989             do_outp(0xcf8, 4, val);
 990
 991             /* Now issue the config space access via
 992              * port 0xCFC
 993              */
 994             req->addr = 0xcfc | (req->addr & 0x03);
 995             cpu_ioreq_pio(req);
 996             break;
 997         }
 998         default:
 999             hw_error("Invalid ioreq type 0x%x\n", req->type);
1000     }
1001     if (req->dir == IOREQ_READ) {
1002         trace_handle_ioreq_read(req, req->type, req->df, req->data_is_ptr,
1003                                 req->addr, req->data, req->count, req->size);
1004     }
1005 }
1006
1007 static int handle_buffered_iopage(XenIOState *state)
1008 {
1009     buffered_iopage_t *buf_page = state->buffered_io_page;
1010     buf_ioreq_t *buf_req = NULL;
1011     ioreq_t req;
1012     int qw;
1013
1014     if (!buf_page) {
1015         return 0;
1016     }
1017
1018     memset(&req, 0x00, sizeof(req));
1019     req.state = STATE_IOREQ_READY;
1020     req.count = 1;
1021     req.dir = IOREQ_WRITE;
1022
1023     for (;;) {
1024         uint32_t rdptr = buf_page->read_pointer, wrptr;
1025
1026         xen_rmb();
1027         wrptr = buf_page->write_pointer;
1028         xen_rmb();
1029         if (rdptr != buf_page->read_pointer) {
1030             continue;
1031         }
1032         if (rdptr == wrptr) {
1033             break;
1034         }
1035         buf_req = &buf_page->buf_ioreq[rdptr % IOREQ_BUFFER_SLOT_NUM];
1036         req.size = 1U << buf_req->size;
1037         req.addr = buf_req->addr;
1038         req.data = buf_req->data;
1039         req.type = buf_req->type;
1040         xen_rmb();
1041         qw = (req.size == 8);
1042         if (qw) {
1043             if (rdptr + 1 == wrptr) {
1044                 hw_error("Incomplete quad word buffered ioreq");
1045             }
1046             buf_req = &buf_page->buf_ioreq[(rdptr + 1) %
1047                                            IOREQ_BUFFER_SLOT_NUM];
1048             req.data |= ((uint64_t)buf_req->data) << 32;
1049             xen_rmb();
1050         }
1051
1052         handle_ioreq(state, &req);
1053
1054         /* Only req.data may get updated by handle_ioreq(), albeit even that
1055          * should not happen as such data would never make it to the guest (we
1056          * can only usefully see writes here after all).
1057          */
1058         assert(req.state == STATE_IOREQ_READY);
1059         assert(req.count == 1);
1060         assert(req.dir == IOREQ_WRITE);
1061         assert(!req.data_is_ptr);
1062
1063         atomic_add(&buf_page->read_pointer, qw + 1);
1064     }
1065
1066     return req.count;
1067 }
1068
1069 static void handle_buffered_io(void *opaque)
1070 {
1071     XenIOState *state = opaque;
1072
1073     if (handle_buffered_iopage(state)) {
1074         timer_mod(state->buffered_io_timer,
1075                 BUFFER_IO_MAX_DELAY + qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
1076     } else {
1077         timer_del(state->buffered_io_timer);
1078         xenevtchn_unmask(state->xce_handle, state->bufioreq_local_port);
1079     }
1080 }
1081
1082 static void cpu_handle_ioreq(void *opaque)
1083 {
1084     XenIOState *state = opaque;
1085     ioreq_t *req = cpu_get_ioreq(state);
1086
1087     handle_buffered_iopage(state);
1088     if (req) {
1089         ioreq_t copy = *req;
1090
1091         xen_rmb();
1092         handle_ioreq(state, &copy);
1093         req->data = copy.data;
1094
1095         if (req->state != STATE_IOREQ_INPROCESS) {
1096             fprintf(stderr, "Badness in I/O request ... not in service?!: "
1097                     "%x, ptr: %x, port: %"PRIx64", "
1098                     "data: %"PRIx64", count: %u, size: %u, type: %u\n",
1099                     req->state, req->data_is_ptr, req->addr,
1100                     req->data, req->count, req->size, req->type);
1101             destroy_hvm_domain(false);
1102             return;
1103         }
1104
1105         xen_wmb(); /* Update ioreq contents /then/ update state. */
1106
1107         /*
1108          * We do this before we send the response so that the tools
1109          * have the opportunity to pick up on the reset before the
1110          * guest resumes and does a hlt with interrupts disabled which
1111          * causes Xen to powerdown the domain.
1112          */
1113         if (runstate_is_running()) {
1114             ShutdownCause request;
1115
1116             if (qemu_shutdown_requested_get()) {
1117                 destroy_hvm_domain(false);
1118             }
1119             request = qemu_reset_requested_get();
1120             if (request) {
1121                 qemu_system_reset(request);
1122                 destroy_hvm_domain(true);
1123             }
1124         }
1125
1126         req->state = STATE_IORESP_READY;
1127         xenevtchn_notify(state->xce_handle,
1128                          state->ioreq_local_port[state->send_vcpu]);
1129     }
1130 }
1131
1132 static void xen_main_loop_prepare(XenIOState *state)
1133 {
1134     int evtchn_fd = -1;
1135
1136     if (state->xce_handle != NULL) {
1137         evtchn_fd = xenevtchn_fd(state->xce_handle);
1138     }
1139
1140     state->buffered_io_timer = timer_new_ms(QEMU_CLOCK_REALTIME, handle_buffered_io,
1141                                                  state);
1142
1143     if (evtchn_fd != -1) {
1144         CPUState *cpu_state;
1145
1146         DPRINTF("%s: Init cpu_by_vcpu_id\n", __func__);
1147         CPU_FOREACH(cpu_state) {
1148             DPRINTF("%s: cpu_by_vcpu_id[%d]=%p\n",
1149                     __func__, cpu_state->cpu_index, cpu_state);
1150             state->cpu_by_vcpu_id[cpu_state->cpu_index] = cpu_state;
1151         }
1152         qemu_set_fd_handler(evtchn_fd, cpu_handle_ioreq, NULL, state);
1153     }
1154 }
1155
1156
1157 static void xen_hvm_change_state_handler(void *opaque, int running,
1158                                          RunState rstate)
1159 {
1160     XenIOState *state = opaque;
1161
1162     if (running) {
1163         xen_main_loop_prepare(state);
1164     }
1165
1166     xen_set_ioreq_server_state(xen_domid,
1167                                state->ioservid,
1168                                (rstate == RUN_STATE_RUNNING));
1169 }
1170
1171 static void xen_exit_notifier(Notifier *n, void *data)
1172 {
1173     XenIOState *state = container_of(n, XenIOState, exit);
1174
1175     xenevtchn_close(state->xce_handle);
1176     xs_daemon_close(state->xenstore);
1177 }
1178
1179 #ifdef XEN_COMPAT_PHYSMAP
1180 static void xen_read_physmap(XenIOState *state)
1181 {
1182     XenPhysmap *physmap = NULL;
1183     unsigned int len, num, i;
1184     char path[80], *value = NULL;
1185     char **entries = NULL;
1186
1187     snprintf(path, sizeof(path),
1188             "/local/domain/0/device-model/%d/physmap", xen_domid);
1189     entries = xs_directory(state->xenstore, 0, path, &num);
1190     if (entries == NULL)
1191         return;
1192
1193     for (i = 0; i < num; i++) {
1194         physmap = g_malloc(sizeof (XenPhysmap));
1195         physmap->phys_offset = strtoull(entries[i], NULL, 16);
1196         snprintf(path, sizeof(path),
1197                 "/local/domain/0/device-model/%d/physmap/%s/start_addr",
1198                 xen_domid, entries[i]);
1199         value = xs_read(state->xenstore, 0, path, &len);
1200         if (value == NULL) {
1201             g_free(physmap);
1202             continue;
1203         }
1204         physmap->start_addr = strtoull(value, NULL, 16);
1205         free(value);
1206
1207         snprintf(path, sizeof(path),
1208                 "/local/domain/0/device-model/%d/physmap/%s/size",
1209                 xen_domid, entries[i]);
1210         value = xs_read(state->xenstore, 0, path, &len);
1211         if (value == NULL) {
1212             g_free(physmap);
1213             continue;
1214         }
1215         physmap->size = strtoull(value, NULL, 16);
1216         free(value);
1217
1218         snprintf(path, sizeof(path),
1219                 "/local/domain/0/device-model/%d/physmap/%s/name",
1220                 xen_domid, entries[i]);
1221         physmap->name = xs_read(state->xenstore, 0, path, &len);
1222
1223         QLIST_INSERT_HEAD(&xen_physmap, physmap, list);
1224     }
1225     free(entries);
1226 }
1227 #else
1228 static void xen_read_physmap(XenIOState *state)
1229 {
1230 }
1231 #endif
1232
1233 static void xen_wakeup_notifier(Notifier *notifier, void *data)
1234 {
1235     xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 0);
1236 }
1237
1238 static int xen_map_ioreq_server(XenIOState *state)
1239 {
1240     void *addr = NULL;
1241     xenforeignmemory_resource_handle *fres;
1242     xen_pfn_t ioreq_pfn;
1243     xen_pfn_t bufioreq_pfn;
1244     evtchn_port_t bufioreq_evtchn;
1245     int rc;
1246
1247     /*
1248      * Attempt to map using the resource API and fall back to normal
1249      * foreign mapping if this is not supported.
1250      */
1251     QEMU_BUILD_BUG_ON(XENMEM_resource_ioreq_server_frame_bufioreq != 0);
1252     QEMU_BUILD_BUG_ON(XENMEM_resource_ioreq_server_frame_ioreq(0) != 1);
1253     fres = xenforeignmemory_map_resource(xen_fmem, xen_domid,
1254                                          XENMEM_resource_ioreq_server,
1255                                          state->ioservid, 0, 2,
1256                                          &addr,
1257                                          PROT_READ | PROT_WRITE, 0);
1258     if (fres != NULL) {
1259         trace_xen_map_resource_ioreq(state->ioservid, addr);
1260         state->buffered_io_page = addr;
1261         state->shared_page = addr + TARGET_PAGE_SIZE;
1262     } else if (errno != EOPNOTSUPP) {
1263         error_report("failed to map ioreq server resources: error %d handle=%p",
1264                      errno, xen_xc);
1265         return -1;
1266     }
1267
1268     rc = xen_get_ioreq_server_info(xen_domid, state->ioservid,
1269                                    (state->shared_page == NULL) ?
1270                                    &ioreq_pfn : NULL,
1271                                    (state->buffered_io_page == NULL) ?
1272                                    &bufioreq_pfn : NULL,
1273                                    &bufioreq_evtchn);
1274     if (rc < 0) {
1275         error_report("failed to get ioreq server info: error %d handle=%p",
1276                      errno, xen_xc);
1277         return rc;
1278     }
1279
1280     if (state->shared_page == NULL) {
1281         DPRINTF("shared page at pfn %lx\n", ioreq_pfn);
1282
1283         state->shared_page = xenforeignmemory_map(xen_fmem, xen_domid,
1284                                                   PROT_READ | PROT_WRITE,
1285                                                   1, &ioreq_pfn, NULL);
1286         if (state->shared_page == NULL) {
1287             error_report("map shared IO page returned error %d handle=%p",
1288                          errno, xen_xc);
1289         }
1290     }
1291
1292     if (state->buffered_io_page == NULL) {
1293         DPRINTF("buffered io page at pfn %lx\n", bufioreq_pfn);
1294
1295         state->buffered_io_page = xenforeignmemory_map(xen_fmem, xen_domid,
1296                                                        PROT_READ | PROT_WRITE,
1297                                                        1, &bufioreq_pfn,
1298                                                        NULL);
1299         if (state->buffered_io_page == NULL) {
1300             error_report("map buffered IO page returned error %d", errno);
1301             return -1;
1302         }
1303     }
1304
1305     if (state->shared_page == NULL || state->buffered_io_page == NULL) {
1306         return -1;
1307     }
1308
1309     DPRINTF("buffered io evtchn is %x\n", bufioreq_evtchn);
1310
1311     state->bufioreq_remote_port = bufioreq_evtchn;
1312
1313     return 0;
1314 }
1315
1316 void xen_hvm_init(PCMachineState *pcms, MemoryRegion **ram_memory)
1317 {
1318     int i, rc;
1319     xen_pfn_t ioreq_pfn;
1320     XenIOState *state;
1321
1322     state = g_malloc0(sizeof (XenIOState));
1323
1324     state->xce_handle = xenevtchn_open(NULL, 0);
1325     if (state->xce_handle == NULL) {
1326         perror("xen: event channel open");
1327         goto err;
1328     }
1329
1330     state->xenstore = xs_daemon_open();
1331     if (state->xenstore == NULL) {
1332         perror("xen: xenstore open");
1333         goto err;
1334     }
1335
1336     xen_create_ioreq_server(xen_domid, &state->ioservid);
1337
1338     state->exit.notify = xen_exit_notifier;
1339     qemu_add_exit_notifier(&state->exit);
1340
1341     state->suspend.notify = xen_suspend_notifier;
1342     qemu_register_suspend_notifier(&state->suspend);
1343
1344     state->wakeup.notify = xen_wakeup_notifier;
1345     qemu_register_wakeup_notifier(&state->wakeup);
1346
1347     rc = xen_map_ioreq_server(state);
1348     if (rc < 0) {
1349         goto err;
1350     }
1351
1352     rc = xen_get_vmport_regs_pfn(xen_xc, xen_domid, &ioreq_pfn);
1353     if (!rc) {
1354         DPRINTF("shared vmport page at pfn %lx\n", ioreq_pfn);
1355         state->shared_vmport_page =
1356             xenforeignmemory_map(xen_fmem, xen_domid, PROT_READ|PROT_WRITE,
1357                                  1, &ioreq_pfn, NULL);
1358         if (state->shared_vmport_page == NULL) {
1359             error_report("map shared vmport IO page returned error %d handle=%p",
1360                          errno, xen_xc);
1361             goto err;
1362         }
1363     } else if (rc != -ENOSYS) {
1364         error_report("get vmport regs pfn returned error %d, rc=%d",
1365                      errno, rc);
1366         goto err;
1367     }
1368
1369     /* Note: cpus is empty at this point in init */
1370     state->cpu_by_vcpu_id = g_malloc0(max_cpus * sizeof(CPUState *));
1371
1372     rc = xen_set_ioreq_server_state(xen_domid, state->ioservid, true);
1373     if (rc < 0) {
1374         error_report("failed to enable ioreq server info: error %d handle=%p",
1375                      errno, xen_xc);
1376         goto err;
1377     }
1378
1379     state->ioreq_local_port = g_malloc0(max_cpus * sizeof (evtchn_port_t));
1380
1381     /* FIXME: how about if we overflow the page here? */
1382     for (i = 0; i < max_cpus; i++) {
1383         rc = xenevtchn_bind_interdomain(state->xce_handle, xen_domid,
1384                                         xen_vcpu_eport(state->shared_page, i));
1385         if (rc == -1) {
1386             error_report("shared evtchn %d bind error %d", i, errno);
1387             goto err;
1388         }
1389         state->ioreq_local_port[i] = rc;
1390     }
1391
1392     rc = xenevtchn_bind_interdomain(state->xce_handle, xen_domid,
1393                                     state->bufioreq_remote_port);
1394     if (rc == -1) {
1395         error_report("buffered evtchn bind error %d", errno);
1396         goto err;
1397     }
1398     state->bufioreq_local_port = rc;
1399
1400     /* Init RAM management */
1401 #ifdef XEN_COMPAT_PHYSMAP
1402     xen_map_cache_init(xen_phys_offset_to_gaddr, state);
1403 #else
1404     xen_map_cache_init(NULL, state);
1405 #endif
1406     xen_ram_init(pcms, ram_size, ram_memory);
1407
1408     qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);
1409
1410     state->memory_listener = xen_memory_listener;
1411     memory_listener_register(&state->memory_listener, &address_space_memory);
1412     state->log_for_dirtybit = NULL;
1413
1414     state->io_listener = xen_io_listener;
1415     memory_listener_register(&state->io_listener, &address_space_io);
1416
1417     state->device_listener = xen_device_listener;
1418     device_listener_register(&state->device_listener);
1419
1420     /* Initialize backend core & drivers */
1421     if (xen_be_init() != 0) {
1422         error_report("xen backend core setup failed");
1423         goto err;
1424     }
1425     xen_be_register_common();
1426
1427     QLIST_INIT(&xen_physmap);
1428     xen_read_physmap(state);
1429
1430     /* Disable ACPI build because Xen handles it */
1431     pcms->acpi_build_enabled = false;
1432
1433     return;
1434
1435 err:
1436     error_report("xen hardware virtual machine initialisation failed");
1437     exit(1);
1438 }
1439
1440 void destroy_hvm_domain(bool reboot)
1441 {
1442     xc_interface *xc_handle;
1443     int sts;
1444     int rc;
1445
1446     unsigned int reason = reboot ? SHUTDOWN_reboot : SHUTDOWN_poweroff;
1447
1448     if (xen_dmod) {
1449         rc = xendevicemodel_shutdown(xen_dmod, xen_domid, reason);
1450         if (!rc) {
1451             return;
1452         }
1453         if (errno != ENOTTY /* old Xen */) {
1454             perror("xendevicemodel_shutdown failed");
1455         }
1456         /* well, try the old thing then */
1457     }
1458
1459     xc_handle = xc_interface_open(0, 0, 0);
1460     if (xc_handle == NULL) {
1461         fprintf(stderr, "Cannot acquire xenctrl handle\n");
1462     } else {
1463         sts = xc_domain_shutdown(xc_handle, xen_domid, reason);
1464         if (sts != 0) {
1465             fprintf(stderr, "xc_domain_shutdown failed to issue %s, "
1466                     "sts %d, %s\n", reboot ? "reboot" : "poweroff",
1467                     sts, strerror(errno));
1468         } else {
1469             fprintf(stderr, "Issued domain %d %s\n", xen_domid,
1470                     reboot ? "reboot" : "poweroff");
1471         }
1472         xc_interface_close(xc_handle);
1473     }
1474 }
1475
1476 void xen_register_framebuffer(MemoryRegion *mr)
1477 {
1478     framebuffer = mr;
1479 }
1480
1481 void xen_shutdown_fatal_error(const char *fmt, ...)
1482 {
1483     va_list ap;
1484
1485     va_start(ap, fmt);
1486     vfprintf(stderr, fmt, ap);
1487     va_end(ap);
1488     fprintf(stderr, "Will destroy the domain.\n");
1489     /* destroy the domain */
1490     qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_ERROR);
1491 }
1492
1493 void xen_hvm_modified_memory(ram_addr_t start, ram_addr_t length)
1494 {
1495     if (unlikely(xen_in_migration)) {
1496         int rc;
1497         ram_addr_t start_pfn, nb_pages;
1498
1499         start = xen_phys_offset_to_gaddr(start, length);
1500
1501         if (length == 0) {
1502             length = TARGET_PAGE_SIZE;
1503         }
1504         start_pfn = start >> TARGET_PAGE_BITS;
1505         nb_pages = ((start + length + TARGET_PAGE_SIZE - 1) >> TARGET_PAGE_BITS)
1506             - start_pfn;
1507         rc = xen_modified_memory(xen_domid, start_pfn, nb_pages);
1508         if (rc) {
1509             fprintf(stderr,
1510                     "%s failed for "RAM_ADDR_FMT" ("RAM_ADDR_FMT"): %i, %s\n",
1511                     __func__, start, nb_pages, errno, strerror(errno));
1512         }
1513     }
1514 }
1515
1516 void qmp_xen_set_global_dirty_log(bool enable, Error **errp)
1517 {
1518     if (enable) {
1519         memory_global_dirty_log_start();
1520     } else {
1521         memory_global_dirty_log_stop();
1522     }
1523 }