Annotation of qemu/xen-all.c, revision 1.1.1.1

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

unix.superglobalmegacorp.com