xen-all.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  */
   8
   9 #include <sys/mman.h>
  10
  11 #include "hw/pci.h"
  12 #include "hw/pc.h"
  13 #include "hw/xen_common.h"
  14 #include "hw/xen_backend.h"
  15
  16 #include "range.h"
  17 #include "xen-mapcache.h"
  18 #include "trace.h"
  19
  20 #include <xen/hvm/ioreq.h>
  21 #include <xen/hvm/params.h>
  22 #include <xen/hvm/e820.h>
  23
  24 //#define DEBUG_XEN
  25
  26 #ifdef DEBUG_XEN
  27 #define DPRINTF(fmt, ...) \
  28     do { fprintf(stderr, "xen: " fmt, ## __VA_ARGS__); } while (0)
  29 #else
  30 #define DPRINTF(fmt, ...) \
  31     do { } while (0)
  32 #endif
  33
  34 /* Compatibility with older version */
  35 #if __XEN_LATEST_INTERFACE_VERSION__ < 0x0003020a
  36 static inline uint32_t xen_vcpu_eport(shared_iopage_t *shared_page, int i)
  37 {
  38     return shared_page->vcpu_iodata[i].vp_eport;
  39 }
  40 static inline ioreq_t *xen_vcpu_ioreq(shared_iopage_t *shared_page, int vcpu)
  41 {
  42     return &shared_page->vcpu_iodata[vcpu].vp_ioreq;
  43 }
  44 #  define FMT_ioreq_size PRIx64
  45 #else
  46 static inline uint32_t xen_vcpu_eport(shared_iopage_t *shared_page, int i)
  47 {
  48     return shared_page->vcpu_ioreq[i].vp_eport;
  49 }
  50 static inline ioreq_t *xen_vcpu_ioreq(shared_iopage_t *shared_page, int vcpu)
  51 {
  52     return &shared_page->vcpu_ioreq[vcpu];
  53 }
  54 #  define FMT_ioreq_size "u"
  55 #endif
  56
  57 #define BUFFER_IO_MAX_DELAY  100
  58
  59 typedef struct XenPhysmap {
  60     target_phys_addr_t start_addr;
  61     ram_addr_t size;
  62     target_phys_addr_t phys_offset;
  63
  64     QLIST_ENTRY(XenPhysmap) list;
  65 } XenPhysmap;
  66
  67 typedef struct XenIOState {
  68     shared_iopage_t *shared_page;
  69     buffered_iopage_t *buffered_io_page;
  70     QEMUTimer *buffered_io_timer;
  71     /* the evtchn port for polling the notification, */
  72     evtchn_port_t *ioreq_local_port;
  73     /* the evtchn fd for polling */
  74     XenEvtchn xce_handle;
  75     /* which vcpu we are serving */
  76     int send_vcpu;
  77
  78     struct xs_handle *xenstore;
  79     CPUPhysMemoryClient client;
  80     QLIST_HEAD(, XenPhysmap) physmap;
  81     const XenPhysmap *log_for_dirtybit;
  82
  83     Notifier exit;
  84 } XenIOState;
  85
  86 /* Xen specific function for piix pci */
  87
  88 int xen_pci_slot_get_pirq(PCIDevice *pci_dev, int irq_num)
  89 {
  90     return irq_num + ((pci_dev->devfn >> 3) << 2);
  91 }
  92
  93 void xen_piix3_set_irq(void *opaque, int irq_num, int level)
  94 {
  95     xc_hvm_set_pci_intx_level(xen_xc, xen_domid, 0, 0, irq_num >> 2,
  96                               irq_num & 3, level);
  97 }
  98
  99 void xen_piix_pci_write_config_client(uint32_t address, uint32_t val, int len)
 100 {
 101     int i;
 102
 103     /* Scan for updates to PCI link routes (0x60-0x63). */
 104     for (i = 0; i < len; i++) {
 105         uint8_t v = (val >> (8 * i)) & 0xff;
 106         if (v & 0x80) {
 107             v = 0;
 108         }
 109         v &= 0xf;
 110         if (((address + i) >= 0x60) && ((address + i) <= 0x63)) {
 111             xc_hvm_set_pci_link_route(xen_xc, xen_domid, address + i - 0x60, v);
 112         }
 113     }
 114 }
 115
 116 void xen_cmos_set_s3_resume(void *opaque, int irq, int level)
 117 {
 118     pc_cmos_set_s3_resume(opaque, irq, level);
 119     if (level) {
 120         xc_set_hvm_param(xen_xc, xen_domid, HVM_PARAM_ACPI_S_STATE, 3);
 121     }
 122 }
 123
 124 /* Xen Interrupt Controller */
 125
 126 static void xen_set_irq(void *opaque, int irq, int level)
 127 {
 128     xc_hvm_set_isa_irq_level(xen_xc, xen_domid, irq, level);
 129 }
 130
 131 qemu_irq *xen_interrupt_controller_init(void)
 132 {
 133     return qemu_allocate_irqs(xen_set_irq, NULL, 16);
 134 }
 135
 136 /* Memory Ops */
 137
 138 static void xen_ram_init(ram_addr_t ram_size)
 139 {
 140     RAMBlock *new_block;
 141     ram_addr_t below_4g_mem_size, above_4g_mem_size = 0;
 142
 143     new_block = g_malloc0(sizeof (*new_block));
 144     pstrcpy(new_block->idstr, sizeof (new_block->idstr), "xen.ram");
 145     new_block->host = NULL;
 146     new_block->offset = 0;
 147     new_block->length = ram_size;
 148     if (ram_size >= HVM_BELOW_4G_RAM_END) {
 149         /* Xen does not allocate the memory continuously, and keep a hole at
 150          * HVM_BELOW_4G_MMIO_START of HVM_BELOW_4G_MMIO_LENGTH
 151          */
 152         new_block->length += HVM_BELOW_4G_MMIO_LENGTH;
 153     }
 154
 155     QLIST_INSERT_HEAD(&ram_list.blocks, new_block, next);
 156
 157     ram_list.phys_dirty = g_realloc(ram_list.phys_dirty,
 158                                        new_block->length >> TARGET_PAGE_BITS);
 159     memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
 160            0xff, new_block->length >> TARGET_PAGE_BITS);
 161
 162     if (ram_size >= HVM_BELOW_4G_RAM_END) {
 163         above_4g_mem_size = ram_size - HVM_BELOW_4G_RAM_END;
 164         below_4g_mem_size = HVM_BELOW_4G_RAM_END;
 165     } else {
 166         below_4g_mem_size = ram_size;
 167     }
 168
 169     cpu_register_physical_memory(0, 0xa0000, 0);
 170     /* Skip of the VGA IO memory space, it will be registered later by the VGA
 171      * emulated device.
 172      *
 173      * The area between 0xc0000 and 0x100000 will be used by SeaBIOS to load
 174      * the Options ROM, so it is registered here as RAM.
 175      */
 176     cpu_register_physical_memory(0xc0000, below_4g_mem_size - 0xc0000,
 177                                  0xc0000);
 178     if (above_4g_mem_size > 0) {
 179         cpu_register_physical_memory(0x100000000ULL, above_4g_mem_size,
 180                                      0x100000000ULL);
 181     }
 182 }
 183
 184 void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size)
 185 {
 186     unsigned long nr_pfn;
 187     xen_pfn_t *pfn_list;
 188     int i;
 189
 190     trace_xen_ram_alloc(ram_addr, size);
 191
 192     nr_pfn = size >> TARGET_PAGE_BITS;
 193     pfn_list = g_malloc(sizeof (*pfn_list) * nr_pfn);
 194
 195     for (i = 0; i < nr_pfn; i++) {
 196         pfn_list[i] = (ram_addr >> TARGET_PAGE_BITS) + i;
 197     }
 198
 199     if (xc_domain_populate_physmap_exact(xen_xc, xen_domid, nr_pfn, 0, 0, pfn_list)) {
 200         hw_error("xen: failed to populate ram at " RAM_ADDR_FMT, ram_addr);
 201     }
 202
 203     g_free(pfn_list);
 204 }
 205
 206 static XenPhysmap *get_physmapping(XenIOState *state,
 207                                    target_phys_addr_t start_addr, ram_addr_t size)
 208 {
 209     XenPhysmap *physmap = NULL;
 210
 211     start_addr &= TARGET_PAGE_MASK;
 212
 213     QLIST_FOREACH(physmap, &state->physmap, list) {
 214         if (range_covers_byte(physmap->start_addr, physmap->size, start_addr)) {
 215             return physmap;
 216         }
 217     }
 218     return NULL;
 219 }
 220
 221 #if CONFIG_XEN_CTRL_INTERFACE_VERSION >= 340
 222 static int xen_add_to_physmap(XenIOState *state,
 223                               target_phys_addr_t start_addr,
 224                               ram_addr_t size,
 225                               target_phys_addr_t phys_offset)
 226 {
 227     unsigned long i = 0;
 228     int rc = 0;
 229     XenPhysmap *physmap = NULL;
 230     target_phys_addr_t pfn, start_gpfn;
 231     RAMBlock *block;
 232
 233     if (get_physmapping(state, start_addr, size)) {
 234         return 0;
 235     }
 236     if (size <= 0) {
 237         return -1;
 238     }
 239
 240     /* Xen can only handle a single dirty log region for now and we want
 241      * the linear framebuffer to be that region.
 242      * Avoid tracking any regions that is not videoram and avoid tracking
 243      * the legacy vga region. */
 244     QLIST_FOREACH(block, &ram_list.blocks, next) {
 245         if (!strcmp(block->idstr, "vga.vram") && block->offset == phys_offset
 246                 && start_addr > 0xbffff) {
 247             goto go_physmap;
 248         }
 249     }
 250     return -1;
 251
 252 go_physmap:
 253     DPRINTF("mapping vram to %llx - %llx, from %llx\n",
 254             start_addr, start_addr + size, phys_offset);
 255
 256     pfn = phys_offset >> TARGET_PAGE_BITS;
 257     start_gpfn = start_addr >> TARGET_PAGE_BITS;
 258     for (i = 0; i < size >> TARGET_PAGE_BITS; i++) {
 259         unsigned long idx = pfn + i;
 260         xen_pfn_t gpfn = start_gpfn + i;
 261
 262         rc = xc_domain_add_to_physmap(xen_xc, xen_domid, XENMAPSPACE_gmfn, idx, gpfn);
 263         if (rc) {
 264             DPRINTF("add_to_physmap MFN %"PRI_xen_pfn" to PFN %"
 265                     PRI_xen_pfn" failed: %d\n", idx, gpfn, rc);
 266             return -rc;
 267         }
 268     }
 269
 270     physmap = g_malloc(sizeof (XenPhysmap));
 271
 272     physmap->start_addr = start_addr;
 273     physmap->size = size;
 274     physmap->phys_offset = phys_offset;
 275
 276     QLIST_INSERT_HEAD(&state->physmap, physmap, list);
 277
 278     xc_domain_pin_memory_cacheattr(xen_xc, xen_domid,
 279                                    start_addr >> TARGET_PAGE_BITS,
 280                                    (start_addr + size) >> TARGET_PAGE_BITS,
 281                                    XEN_DOMCTL_MEM_CACHEATTR_WB);
 282     return 0;
 283 }
 284
 285 static int xen_remove_from_physmap(XenIOState *state,
 286                                    target_phys_addr_t start_addr,
 287                                    ram_addr_t size)
 288 {
 289     unsigned long i = 0;
 290     int rc = 0;
 291     XenPhysmap *physmap = NULL;
 292     target_phys_addr_t phys_offset = 0;
 293
 294     physmap = get_physmapping(state, start_addr, size);
 295     if (physmap == NULL) {
 296         return -1;
 297     }
 298
 299     phys_offset = physmap->phys_offset;
 300     size = physmap->size;
 301
 302     DPRINTF("unmapping vram to %llx - %llx, from %llx\n",
 303             phys_offset, phys_offset + size, start_addr);
 304
 305     size >>= TARGET_PAGE_BITS;
 306     start_addr >>= TARGET_PAGE_BITS;
 307     phys_offset >>= TARGET_PAGE_BITS;
 308     for (i = 0; i < size; i++) {
 309         unsigned long idx = start_addr + i;
 310         xen_pfn_t gpfn = phys_offset + i;
 311
 312         rc = xc_domain_add_to_physmap(xen_xc, xen_domid, XENMAPSPACE_gmfn, idx, gpfn);
 313         if (rc) {
 314             fprintf(stderr, "add_to_physmap MFN %"PRI_xen_pfn" to PFN %"
 315                     PRI_xen_pfn" failed: %d\n", idx, gpfn, rc);
 316             return -rc;
 317         }
 318     }
 319
 320     QLIST_REMOVE(physmap, list);
 321     if (state->log_for_dirtybit == physmap) {
 322         state->log_for_dirtybit = NULL;
 323     }
 324     free(physmap);
 325
 326     return 0;
 327 }
 328
 329 #else
 330 static int xen_add_to_physmap(XenIOState *state,
 331                               target_phys_addr_t start_addr,
 332                               ram_addr_t size,
 333                               target_phys_addr_t phys_offset)
 334 {
 335     return -ENOSYS;
 336 }
 337
 338 static int xen_remove_from_physmap(XenIOState *state,
 339                                    target_phys_addr_t start_addr,
 340                                    ram_addr_t size)
 341 {
 342     return -ENOSYS;
 343 }
 344 #endif
 345
 346 static void xen_client_set_memory(struct CPUPhysMemoryClient *client,
 347                                   target_phys_addr_t start_addr,
 348                                   ram_addr_t size,
 349                                   ram_addr_t phys_offset,
 350                                   bool log_dirty)
 351 {
 352     XenIOState *state = container_of(client, XenIOState, client);
 353     ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
 354     hvmmem_type_t mem_type;
 355
 356     if (!(start_addr != phys_offset
 357           && ( (log_dirty && flags < IO_MEM_UNASSIGNED)
 358                || (!log_dirty && flags == IO_MEM_UNASSIGNED)))) {
 359         return;
 360     }
 361
 362     trace_xen_client_set_memory(start_addr, size, phys_offset, log_dirty);
 363
 364     start_addr &= TARGET_PAGE_MASK;
 365     size = TARGET_PAGE_ALIGN(size);
 366     phys_offset &= TARGET_PAGE_MASK;
 367
 368     switch (flags) {
 369     case IO_MEM_RAM:
 370         xen_add_to_physmap(state, start_addr, size, phys_offset);
 371         break;
 372     case IO_MEM_ROM:
 373         mem_type = HVMMEM_ram_ro;
 374         if (xc_hvm_set_mem_type(xen_xc, xen_domid, mem_type,
 375                                 start_addr >> TARGET_PAGE_BITS,
 376                                 size >> TARGET_PAGE_BITS)) {
 377             DPRINTF("xc_hvm_set_mem_type error, addr: "TARGET_FMT_plx"\n",
 378                     start_addr);
 379         }
 380         break;
 381     case IO_MEM_UNASSIGNED:
 382         if (xen_remove_from_physmap(state, start_addr, size) < 0) {
 383             DPRINTF("physmapping does not exist at "TARGET_FMT_plx"\n", start_addr);
 384         }
 385         break;
 386     }
 387 }
 388
 389 static int xen_sync_dirty_bitmap(XenIOState *state,
 390                                  target_phys_addr_t start_addr,
 391                                  ram_addr_t size)
 392 {
 393     target_phys_addr_t npages = size >> TARGET_PAGE_BITS;
 394     target_phys_addr_t vram_offset = 0;
 395     const int width = sizeof(unsigned long) * 8;
 396     unsigned long bitmap[(npages + width - 1) / width];
 397     int rc, i, j;
 398     const XenPhysmap *physmap = NULL;
 399
 400     physmap = get_physmapping(state, start_addr, size);
 401     if (physmap == NULL) {
 402         /* not handled */
 403         return -1;
 404     }
 405
 406     if (state->log_for_dirtybit == NULL) {
 407         state->log_for_dirtybit = physmap;
 408     } else if (state->log_for_dirtybit != physmap) {
 409         return -1;
 410     }
 411     vram_offset = physmap->phys_offset;
 412
 413     rc = xc_hvm_track_dirty_vram(xen_xc, xen_domid,
 414                                  start_addr >> TARGET_PAGE_BITS, npages,
 415                                  bitmap);
 416     if (rc) {
 417         return rc;
 418     }
 419
 420     for (i = 0; i < ARRAY_SIZE(bitmap); i++) {
 421         unsigned long map = bitmap[i];
 422         while (map != 0) {
 423             j = ffsl(map) - 1;
 424             map &= ~(1ul << j);
 425             cpu_physical_memory_set_dirty(vram_offset + (i * width + j) * TARGET_PAGE_SIZE);
 426         };
 427     }
 428
 429     return 0;
 430 }
 431
 432 static int xen_log_start(CPUPhysMemoryClient *client, target_phys_addr_t phys_addr, ram_addr_t size)
 433 {
 434     XenIOState *state = container_of(client, XenIOState, client);
 435
 436     return xen_sync_dirty_bitmap(state, phys_addr, size);
 437 }
 438
 439 static int xen_log_stop(CPUPhysMemoryClient *client, target_phys_addr_t phys_addr, ram_addr_t size)
 440 {
 441     XenIOState *state = container_of(client, XenIOState, client);
 442
 443     state->log_for_dirtybit = NULL;
 444     /* Disable dirty bit tracking */
 445     return xc_hvm_track_dirty_vram(xen_xc, xen_domid, 0, 0, NULL);
 446 }
 447
 448 static int xen_client_sync_dirty_bitmap(struct CPUPhysMemoryClient *client,
 449                                         target_phys_addr_t start_addr,
 450                                         target_phys_addr_t end_addr)
 451 {
 452     XenIOState *state = container_of(client, XenIOState, client);
 453
 454     return xen_sync_dirty_bitmap(state, start_addr, end_addr - start_addr);
 455 }
 456
 457 static int xen_client_migration_log(struct CPUPhysMemoryClient *client,
 458                                     int enable)
 459 {
 460     return 0;
 461 }
 462
 463 static CPUPhysMemoryClient xen_cpu_phys_memory_client = {
 464     .set_memory = xen_client_set_memory,
 465     .sync_dirty_bitmap = xen_client_sync_dirty_bitmap,
 466     .migration_log = xen_client_migration_log,
 467     .log_start = xen_log_start,
 468     .log_stop = xen_log_stop,
 469 };
 470
 471 /* VCPU Operations, MMIO, IO ring ... */
 472
 473 static void xen_reset_vcpu(void *opaque)
 474 {
 475     CPUState *env = opaque;
 476
 477     env->halted = 1;
 478 }
 479
 480 void xen_vcpu_init(void)
 481 {
 482     CPUState *first_cpu;
 483
 484     if ((first_cpu = qemu_get_cpu(0))) {
 485         qemu_register_reset(xen_reset_vcpu, first_cpu);
 486         xen_reset_vcpu(first_cpu);
 487     }
 488 }
 489
 490 /* get the ioreq packets from share mem */
 491 static ioreq_t *cpu_get_ioreq_from_shared_memory(XenIOState *state, int vcpu)
 492 {
 493     ioreq_t *req = xen_vcpu_ioreq(state->shared_page, vcpu);
 494
 495     if (req->state != STATE_IOREQ_READY) {
 496         DPRINTF("I/O request not ready: "
 497                 "%x, ptr: %x, port: %"PRIx64", "
 498                 "data: %"PRIx64", count: %" FMT_ioreq_size ", size: %" FMT_ioreq_size "\n",
 499                 req->state, req->data_is_ptr, req->addr,
 500                 req->data, req->count, req->size);
 501         return NULL;
 502     }
 503
 504     xen_rmb(); /* see IOREQ_READY /then/ read contents of ioreq */
 505
 506     req->state = STATE_IOREQ_INPROCESS;
 507     return req;
 508 }
 509
 510 /* use poll to get the port notification */
 511 /* ioreq_vec--out,the */
 512 /* retval--the number of ioreq packet */
 513 static ioreq_t *cpu_get_ioreq(XenIOState *state)
 514 {
 515     int i;
 516     evtchn_port_t port;
 517
 518     port = xc_evtchn_pending(state->xce_handle);
 519     if (port != -1) {
 520         for (i = 0; i < smp_cpus; i++) {
 521             if (state->ioreq_local_port[i] == port) {
 522                 break;
 523             }
 524         }
 525
 526         if (i == smp_cpus) {
 527             hw_error("Fatal error while trying to get io event!\n");
 528         }
 529
 530         /* unmask the wanted port again */
 531         xc_evtchn_unmask(state->xce_handle, port);
 532
 533         /* get the io packet from shared memory */
 534         state->send_vcpu = i;
 535         return cpu_get_ioreq_from_shared_memory(state, i);
 536     }
 537
 538     /* read error or read nothing */
 539     return NULL;
 540 }
 541
 542 static uint32_t do_inp(pio_addr_t addr, unsigned long size)
 543 {
 544     switch (size) {
 545         case 1:
 546             return cpu_inb(addr);
 547         case 2:
 548             return cpu_inw(addr);
 549         case 4:
 550             return cpu_inl(addr);
 551         default:
 552             hw_error("inp: bad size: %04"FMT_pioaddr" %lx", addr, size);
 553     }
 554 }
 555
 556 static void do_outp(pio_addr_t addr,
 557         unsigned long size, uint32_t val)
 558 {
 559     switch (size) {
 560         case 1:
 561             return cpu_outb(addr, val);
 562         case 2:
 563             return cpu_outw(addr, val);
 564         case 4:
 565             return cpu_outl(addr, val);
 566         default:
 567             hw_error("outp: bad size: %04"FMT_pioaddr" %lx", addr, size);
 568     }
 569 }
 570
 571 static void cpu_ioreq_pio(ioreq_t *req)
 572 {
 573     int i, sign;
 574
 575     sign = req->df ? -1 : 1;
 576
 577     if (req->dir == IOREQ_READ) {
 578         if (!req->data_is_ptr) {
 579             req->data = do_inp(req->addr, req->size);
 580         } else {
 581             uint32_t tmp;
 582
 583             for (i = 0; i < req->count; i++) {
 584                 tmp = do_inp(req->addr, req->size);
 585                 cpu_physical_memory_write(req->data + (sign * i * req->size),
 586                         (uint8_t *) &tmp, req->size);
 587             }
 588         }
 589     } else if (req->dir == IOREQ_WRITE) {
 590         if (!req->data_is_ptr) {
 591             do_outp(req->addr, req->size, req->data);
 592         } else {
 593             for (i = 0; i < req->count; i++) {
 594                 uint32_t tmp = 0;
 595
 596                 cpu_physical_memory_read(req->data + (sign * i * req->size),
 597                         (uint8_t*) &tmp, req->size);
 598                 do_outp(req->addr, req->size, tmp);
 599             }
 600         }
 601     }
 602 }
 603
 604 static void cpu_ioreq_move(ioreq_t *req)
 605 {
 606     int i, sign;
 607
 608     sign = req->df ? -1 : 1;
 609
 610     if (!req->data_is_ptr) {
 611         if (req->dir == IOREQ_READ) {
 612             for (i = 0; i < req->count; i++) {
 613                 cpu_physical_memory_read(req->addr + (sign * i * req->size),
 614                         (uint8_t *) &req->data, req->size);
 615             }
 616         } else if (req->dir == IOREQ_WRITE) {
 617             for (i = 0; i < req->count; i++) {
 618                 cpu_physical_memory_write(req->addr + (sign * i * req->size),
 619                         (uint8_t *) &req->data, req->size);
 620             }
 621         }
 622     } else {
 623         uint64_t tmp;
 624
 625         if (req->dir == IOREQ_READ) {
 626             for (i = 0; i < req->count; i++) {
 627                 cpu_physical_memory_read(req->addr + (sign * i * req->size),
 628                         (uint8_t*) &tmp, req->size);
 629                 cpu_physical_memory_write(req->data + (sign * i * req->size),
 630                         (uint8_t*) &tmp, req->size);
 631             }
 632         } else if (req->dir == IOREQ_WRITE) {
 633             for (i = 0; i < req->count; i++) {
 634                 cpu_physical_memory_read(req->data + (sign * i * req->size),
 635                         (uint8_t*) &tmp, req->size);
 636                 cpu_physical_memory_write(req->addr + (sign * i * req->size),
 637                         (uint8_t*) &tmp, req->size);
 638             }
 639         }
 640     }
 641 }
 642
 643 static void handle_ioreq(ioreq_t *req)
 644 {
 645     if (!req->data_is_ptr && (req->dir == IOREQ_WRITE) &&
 646             (req->size < sizeof (target_ulong))) {
 647         req->data &= ((target_ulong) 1 << (8 * req->size)) - 1;
 648     }
 649
 650     switch (req->type) {
 651         case IOREQ_TYPE_PIO:
 652             cpu_ioreq_pio(req);
 653             break;
 654         case IOREQ_TYPE_COPY:
 655             cpu_ioreq_move(req);
 656             break;
 657         case IOREQ_TYPE_TIMEOFFSET:
 658             break;
 659         case IOREQ_TYPE_INVALIDATE:
 660             xen_invalidate_map_cache();
 661             break;
 662         default:
 663             hw_error("Invalid ioreq type 0x%x\n", req->type);
 664     }
 665 }
 666
 667 static void handle_buffered_iopage(XenIOState *state)
 668 {
 669     buf_ioreq_t *buf_req = NULL;
 670     ioreq_t req;
 671     int qw;
 672
 673     if (!state->buffered_io_page) {
 674         return;
 675     }
 676
 677     while (state->buffered_io_page->read_pointer != state->buffered_io_page->write_pointer) {
 678         buf_req = &state->buffered_io_page->buf_ioreq[
 679             state->buffered_io_page->read_pointer % IOREQ_BUFFER_SLOT_NUM];
 680         req.size = 1UL << buf_req->size;
 681         req.count = 1;
 682         req.addr = buf_req->addr;
 683         req.data = buf_req->data;
 684         req.state = STATE_IOREQ_READY;
 685         req.dir = buf_req->dir;
 686         req.df = 1;
 687         req.type = buf_req->type;
 688         req.data_is_ptr = 0;
 689         qw = (req.size == 8);
 690         if (qw) {
 691             buf_req = &state->buffered_io_page->buf_ioreq[
 692                 (state->buffered_io_page->read_pointer + 1) % IOREQ_BUFFER_SLOT_NUM];
 693             req.data |= ((uint64_t)buf_req->data) << 32;
 694         }
 695
 696         handle_ioreq(&req);
 697
 698         xen_mb();
 699         state->buffered_io_page->read_pointer += qw ? 2 : 1;
 700     }
 701 }
 702
 703 static void handle_buffered_io(void *opaque)
 704 {
 705     XenIOState *state = opaque;
 706
 707     handle_buffered_iopage(state);
 708     qemu_mod_timer(state->buffered_io_timer,
 709                    BUFFER_IO_MAX_DELAY + qemu_get_clock_ms(rt_clock));
 710 }
 711
 712 static void cpu_handle_ioreq(void *opaque)
 713 {
 714     XenIOState *state = opaque;
 715     ioreq_t *req = cpu_get_ioreq(state);
 716
 717     handle_buffered_iopage(state);
 718     if (req) {
 719         handle_ioreq(req);
 720
 721         if (req->state != STATE_IOREQ_INPROCESS) {
 722             fprintf(stderr, "Badness in I/O request ... not in service?!: "
 723                     "%x, ptr: %x, port: %"PRIx64", "
 724                     "data: %"PRIx64", count: %" FMT_ioreq_size ", size: %" FMT_ioreq_size "\n",
 725                     req->state, req->data_is_ptr, req->addr,
 726                     req->data, req->count, req->size);
 727             destroy_hvm_domain();
 728             return;
 729         }
 730
 731         xen_wmb(); /* Update ioreq contents /then/ update state. */
 732
 733         /*
 734          * We do this before we send the response so that the tools
 735          * have the opportunity to pick up on the reset before the
 736          * guest resumes and does a hlt with interrupts disabled which
 737          * causes Xen to powerdown the domain.
 738          */
 739         if (runstate_is_running()) {
 740             if (qemu_shutdown_requested_get()) {
 741                 destroy_hvm_domain();
 742             }
 743             if (qemu_reset_requested_get()) {
 744                 qemu_system_reset(VMRESET_REPORT);
 745             }
 746         }
 747
 748         req->state = STATE_IORESP_READY;
 749         xc_evtchn_notify(state->xce_handle, state->ioreq_local_port[state->send_vcpu]);
 750     }
 751 }
 752
 753 static int store_dev_info(int domid, CharDriverState *cs, const char *string)
 754 {
 755     struct xs_handle *xs = NULL;
 756     char *path = NULL;
 757     char *newpath = NULL;
 758     char *pts = NULL;
 759     int ret = -1;
 760
 761     /* Only continue if we're talking to a pty. */
 762     if (strncmp(cs->filename, "pty:", 4)) {
 763         return 0;
 764     }
 765     pts = cs->filename + 4;
 766
 767     /* We now have everything we need to set the xenstore entry. */
 768     xs = xs_open(0);
 769     if (xs == NULL) {
 770         fprintf(stderr, "Could not contact XenStore\n");
 771         goto out;
 772     }
 773
 774     path = xs_get_domain_path(xs, domid);
 775     if (path == NULL) {
 776         fprintf(stderr, "xs_get_domain_path() error\n");
 777         goto out;
 778     }
 779     newpath = realloc(path, (strlen(path) + strlen(string) +
 780                 strlen("/tty") + 1));
 781     if (newpath == NULL) {
 782         fprintf(stderr, "realloc error\n");
 783         goto out;
 784     }
 785     path = newpath;
 786
 787     strcat(path, string);
 788     strcat(path, "/tty");
 789     if (!xs_write(xs, XBT_NULL, path, pts, strlen(pts))) {
 790         fprintf(stderr, "xs_write for '%s' fail", string);
 791         goto out;
 792     }
 793     ret = 0;
 794
 795 out:
 796     free(path);
 797     xs_close(xs);
 798
 799     return ret;
 800 }
 801
 802 void xenstore_store_pv_console_info(int i, CharDriverState *chr)
 803 {
 804     if (i == 0) {
 805         store_dev_info(xen_domid, chr, "/console");
 806     } else {
 807         char buf[32];
 808         snprintf(buf, sizeof(buf), "/device/console/%d", i);
 809         store_dev_info(xen_domid, chr, buf);
 810     }
 811 }
 812
 813 static void xenstore_record_dm_state(struct xs_handle *xs, const char *state)
 814 {
 815     char path[50];
 816
 817     if (xs == NULL) {
 818         fprintf(stderr, "xenstore connection not initialized\n");
 819         exit(1);
 820     }
 821
 822     snprintf(path, sizeof (path), "/local/domain/0/device-model/%u/state", xen_domid);
 823     if (!xs_write(xs, XBT_NULL, path, state, strlen(state))) {
 824         fprintf(stderr, "error recording dm state\n");
 825         exit(1);
 826     }
 827 }
 828
 829 static void xen_main_loop_prepare(XenIOState *state)
 830 {
 831     int evtchn_fd = -1;
 832
 833     if (state->xce_handle != XC_HANDLER_INITIAL_VALUE) {
 834         evtchn_fd = xc_evtchn_fd(state->xce_handle);
 835     }
 836
 837     state->buffered_io_timer = qemu_new_timer_ms(rt_clock, handle_buffered_io,
 838                                                  state);
 839     qemu_mod_timer(state->buffered_io_timer, qemu_get_clock_ms(rt_clock));
 840
 841     if (evtchn_fd != -1) {
 842         qemu_set_fd_handler(evtchn_fd, cpu_handle_ioreq, NULL, state);
 843     }
 844 }
 845
 846
 847 /* Initialise Xen */
 848
 849 static void xen_change_state_handler(void *opaque, int running,
 850                                      RunState state)
 851 {
 852     if (running) {
 853         /* record state running */
 854         xenstore_record_dm_state(xenstore, "running");
 855     }
 856 }
 857
 858 static void xen_hvm_change_state_handler(void *opaque, int running,
 859                                          RunState rstate)
 860 {
 861     XenIOState *xstate = opaque;
 862     if (running) {
 863         xen_main_loop_prepare(xstate);
 864     }
 865 }
 866
 867 static void xen_exit_notifier(Notifier *n, void *data)
 868 {
 869     XenIOState *state = container_of(n, XenIOState, exit);
 870
 871     xc_evtchn_close(state->xce_handle);
 872     xs_daemon_close(state->xenstore);
 873 }
 874
 875 int xen_init(void)
 876 {
 877     xen_xc = xen_xc_interface_open(0, 0, 0);
 878     if (xen_xc == XC_HANDLER_INITIAL_VALUE) {
 879         xen_be_printf(NULL, 0, "can't open xen interface\n");
 880         return -1;
 881     }
 882     qemu_add_vm_change_state_handler(xen_change_state_handler, NULL);
 883
 884     return 0;
 885 }
 886
 887 int xen_hvm_init(void)
 888 {
 889     int i, rc;
 890     unsigned long ioreq_pfn;
 891     XenIOState *state;
 892
 893     state = g_malloc0(sizeof (XenIOState));
 894
 895     state->xce_handle = xen_xc_evtchn_open(NULL, 0);
 896     if (state->xce_handle == XC_HANDLER_INITIAL_VALUE) {
 897         perror("xen: event channel open");
 898         return -errno;
 899     }
 900
 901     state->xenstore = xs_daemon_open();
 902     if (state->xenstore == NULL) {
 903         perror("xen: xenstore open");
 904         return -errno;
 905     }
 906
 907     state->exit.notify = xen_exit_notifier;
 908     qemu_add_exit_notifier(&state->exit);
 909
 910     xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &ioreq_pfn);
 911     DPRINTF("shared page at pfn %lx\n", ioreq_pfn);
 912     state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
 913                                               PROT_READ|PROT_WRITE, ioreq_pfn);
 914     if (state->shared_page == NULL) {
 915         hw_error("map shared IO page returned error %d handle=" XC_INTERFACE_FMT,
 916                  errno, xen_xc);
 917     }
 918
 919     xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_PFN, &ioreq_pfn);
 920     DPRINTF("buffered io page at pfn %lx\n", ioreq_pfn);
 921     state->buffered_io_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
 922                                                    PROT_READ|PROT_WRITE, ioreq_pfn);
 923     if (state->buffered_io_page == NULL) {
 924         hw_error("map buffered IO page returned error %d", errno);
 925     }
 926
 927     state->ioreq_local_port = g_malloc0(smp_cpus * sizeof (evtchn_port_t));
 928
 929     /* FIXME: how about if we overflow the page here? */
 930     for (i = 0; i < smp_cpus; i++) {
 931         rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,
 932                                         xen_vcpu_eport(state->shared_page, i));
 933         if (rc == -1) {
 934             fprintf(stderr, "bind interdomain ioctl error %d\n", errno);
 935             return -1;
 936         }
 937         state->ioreq_local_port[i] = rc;
 938     }
 939
 940     /* Init RAM management */
 941     xen_map_cache_init();
 942     xen_ram_init(ram_size);
 943
 944     qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);
 945
 946     state->client = xen_cpu_phys_memory_client;
 947     QLIST_INIT(&state->physmap);
 948     cpu_register_phys_memory_client(&state->client);
 949     state->log_for_dirtybit = NULL;
 950
 951     /* Initialize backend core & drivers */
 952     if (xen_be_init() != 0) {
 953         fprintf(stderr, "%s: xen backend core setup failed\n", __FUNCTION__);
 954         exit(1);
 955     }
 956     xen_be_register("console", &xen_console_ops);
 957     xen_be_register("vkbd", &xen_kbdmouse_ops);
 958     xen_be_register("qdisk", &xen_blkdev_ops);
 959
 960     return 0;
 961 }
 962
 963 void destroy_hvm_domain(void)
 964 {
 965     XenXC xc_handle;
 966     int sts;
 967
 968     xc_handle = xen_xc_interface_open(0, 0, 0);
 969     if (xc_handle == XC_HANDLER_INITIAL_VALUE) {
 970         fprintf(stderr, "Cannot acquire xenctrl handle\n");
 971     } else {
 972         sts = xc_domain_shutdown(xc_handle, xen_domid, SHUTDOWN_poweroff);
 973         if (sts != 0) {
 974             fprintf(stderr, "? xc_domain_shutdown failed to issue poweroff, "
 975                     "sts %d, %s\n", sts, strerror(errno));
 976         } else {
 977             fprintf(stderr, "Issued domain %d poweroff\n", xen_domid);
 978         }
 979         xc_interface_close(xc_handle);
 980     }
 981 }