@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
c 945 lines 28.8 KB
Raw
1 #include "qemu/osdep.h"
2 #include "qemu/units.h"
3 #include "qemu/bitops.h"
4 #include "qemu/error-report.h"
5 #include "qemu/target-info.h"
6 #include "qapi/error.h"
7 #include "qapi/qapi-events-misc.h"
8 #include "exec/target_page.h"
9 #include "trace.h"
10
11 #include "hw/core/hw-error.h"
12 #include "hw/pci/pci_host.h"
13 #include "hw/xen/xen-hvm-common.h"
14 #include "hw/xen/xen-bus.h"
15 #include "hw/core/boards.h"
16 #include "hw/xen/arch_hvm.h"
17 #include "system/memory.h"
18 #include "system/runstate.h"
19 #include "system/system.h"
20 #include "system/xen.h"
21 #include "system/xen-mapcache.h"
22
23 MemoryRegion xen_memory, xen_grants;
24
25 /* Check for any kind of xen memory, foreign mappings or grants. */
26 bool xen_mr_is_memory(const MemoryRegion *mr)
27 {
28 return mr == &xen_memory || mr == &xen_grants;
29 }
30
31 /* Check specifically for grants. */
32 bool xen_mr_is_grants(const MemoryRegion *mr)
33 {
34 return mr == &xen_grants;
35 }
36
37 void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size,
38 const MemoryRegion *mr, Error **errp)
39 {
40 unsigned target_page_bits = qemu_target_page_bits();
41 unsigned long nr_pfn;
42 xen_pfn_t *pfn_list;
43 int i;
44
45 if (runstate_check(RUN_STATE_INMIGRATE)) {
46 /* RAM already populated in Xen */
47 warn_report("%s: do not alloc "RAM_ADDR_FMT
48 " bytes of ram at "RAM_ADDR_FMT" when runstate is INMIGRATE",
49 __func__, size, ram_addr);
50 return;
51 }
52
53 if (xen_mr_is_memory(mr)) {
54 return;
55 }
56
57 trace_xen_ram_alloc(ram_addr, size);
58
59 nr_pfn = size >> target_page_bits;
60 pfn_list = g_new(xen_pfn_t, nr_pfn);
61
62 for (i = 0; i < nr_pfn; i++) {
63 pfn_list[i] = (ram_addr >> target_page_bits) + i;
64 }
65
66 if (xc_domain_populate_physmap_exact(xen_xc, xen_domid, nr_pfn, 0, 0, pfn_list)) {
67 error_setg(errp, "xen: failed to populate ram at " RAM_ADDR_FMT,
68 ram_addr);
69 }
70
71 g_free(pfn_list);
72 }
73
74 static void xen_set_memory(struct MemoryListener *listener,
75 MemoryRegionSection *section,
76 bool add)
77 {
78 XenIOState *state = container_of(listener, XenIOState, memory_listener);
79
80 if (xen_mr_is_memory(section->mr)) {
81 return;
82 } else {
83 if (add) {
84 xen_map_memory_section(xen_domid, state->ioservid,
85 section);
86 } else {
87 xen_unmap_memory_section(xen_domid, state->ioservid,
88 section);
89 }
90 }
91
92 arch_xen_set_memory(state, section, add);
93 }
94
95 void xen_region_add(MemoryListener *listener,
96 MemoryRegionSection *section)
97 {
98 memory_region_ref(section->mr);
99 xen_set_memory(listener, section, true);
100 }
101
102 void xen_region_del(MemoryListener *listener,
103 MemoryRegionSection *section)
104 {
105 xen_set_memory(listener, section, false);
106 memory_region_unref(section->mr);
107 }
108
109 void xen_io_add(MemoryListener *listener,
110 MemoryRegionSection *section)
111 {
112 XenIOState *state = container_of(listener, XenIOState, io_listener);
113 MemoryRegion *mr = section->mr;
114
115 if (mr->ops == &unassigned_io_ops) {
116 return;
117 }
118
119 memory_region_ref(mr);
120
121 xen_map_io_section(xen_domid, state->ioservid, section);
122 }
123
124 void xen_io_del(MemoryListener *listener,
125 MemoryRegionSection *section)
126 {
127 XenIOState *state = container_of(listener, XenIOState, io_listener);
128 MemoryRegion *mr = section->mr;
129
130 if (mr->ops == &unassigned_io_ops) {
131 return;
132 }
133
134 xen_unmap_io_section(xen_domid, state->ioservid, section);
135
136 memory_region_unref(mr);
137 }
138
139 void xen_device_realize(DeviceListener *listener,
140 DeviceState *dev)
141 {
142 XenIOState *state = container_of(listener, XenIOState, device_listener);
143
144 if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) {
145 PCIDevice *pci_dev = PCI_DEVICE(dev);
146 XenPciDevice *xendev = g_new(XenPciDevice, 1);
147
148 xendev->pci_dev = pci_dev;
149 xendev->sbdf = PCI_BUILD_BDF(pci_dev_bus_num(pci_dev),
150 pci_dev->devfn);
151 QLIST_INSERT_HEAD(&state->dev_list, xendev, entry);
152
153 xen_map_pcidev(xen_domid, state->ioservid, pci_dev);
154 }
155 }
156
157 void xen_device_unrealize(DeviceListener *listener,
158 DeviceState *dev)
159 {
160 XenIOState *state = container_of(listener, XenIOState, device_listener);
161
162 if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) {
163 PCIDevice *pci_dev = PCI_DEVICE(dev);
164 XenPciDevice *xendev, *next;
165
166 xen_unmap_pcidev(xen_domid, state->ioservid, pci_dev);
167
168 QLIST_FOREACH_SAFE(xendev, &state->dev_list, entry, next) {
169 if (xendev->pci_dev == pci_dev) {
170 QLIST_REMOVE(xendev, entry);
171 g_free(xendev);
172 break;
173 }
174 }
175 }
176 }
177
178 MemoryListener xen_io_listener = {
179 .name = "xen-io",
180 .region_add = xen_io_add,
181 .region_del = xen_io_del,
182 .priority = MEMORY_LISTENER_PRIORITY_ACCEL,
183 };
184
185 DeviceListener xen_device_listener = {
186 .realize = xen_device_realize,
187 .unrealize = xen_device_unrealize,
188 };
189
190 /* get the ioreq packets from share mem */
191 static ioreq_t *cpu_get_ioreq_from_shared_memory(XenIOState *state, int vcpu)
192 {
193 ioreq_t *req = xen_vcpu_ioreq(state->shared_page, vcpu);
194
195 if (req->state != STATE_IOREQ_READY) {
196 trace_cpu_get_ioreq_from_shared_memory_req_not_ready(req->state,
197 req->data_is_ptr,
198 req->addr,
199 req->data,
200 req->count,
201 req->size);
202 return NULL;
203 }
204
205 xen_rmb(); /* see IOREQ_READY /then/ read contents of ioreq */
206
207 req->state = STATE_IOREQ_INPROCESS;
208 return req;
209 }
210
211 /* use poll to get the port notification */
212 /* ioreq_vec--out,the */
213 /* retval--the number of ioreq packet */
214 static ioreq_t *cpu_get_ioreq(XenIOState *state)
215 {
216 MachineState *ms = MACHINE(qdev_get_machine());
217 unsigned int max_cpus = ms->smp.max_cpus;
218 int i;
219 evtchn_port_t port;
220
221 port = qemu_xen_evtchn_pending(state->xce_handle);
222 if (port == state->bufioreq_local_port) {
223 timer_mod(state->buffered_io_timer,
224 BUFFER_IO_MAX_DELAY + qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
225 return NULL;
226 }
227
228 if (port != -1) {
229 for (i = 0; i < max_cpus; i++) {
230 if (state->ioreq_local_port[i] == port) {
231 break;
232 }
233 }
234
235 if (i == max_cpus) {
236 hw_error("Fatal error while trying to get io event!\n");
237 }
238
239 /* unmask the wanted port again */
240 qemu_xen_evtchn_unmask(state->xce_handle, port);
241
242 /* get the io packet from shared memory */
243 state->send_vcpu = i;
244 return cpu_get_ioreq_from_shared_memory(state, i);
245 }
246
247 /* read error or read nothing */
248 return NULL;
249 }
250
251 static uint32_t do_inp(uint32_t addr, unsigned long size)
252 {
253 switch (size) {
254 case 1:
255 return cpu_inb(addr);
256 case 2:
257 return cpu_inw(addr);
258 case 4:
259 return cpu_inl(addr);
260 default:
261 hw_error("inp: bad size: %04x %lx", addr, size);
262 }
263 }
264
265 static void do_outp(uint32_t addr,
266 unsigned long size, uint32_t val)
267 {
268 switch (size) {
269 case 1:
270 return cpu_outb(addr, val);
271 case 2:
272 return cpu_outw(addr, val);
273 case 4:
274 return cpu_outl(addr, val);
275 default:
276 hw_error("outp: bad size: %04x %lx", addr, size);
277 }
278 }
279
280 /*
281 * Helper functions which read/write an object from/to physical guest
282 * memory, as part of the implementation of an ioreq.
283 *
284 * Equivalent to
285 * address_space_rw(as, addr + (req->df ? -1 : +1) * req->size * i,
286 * attrs, val, req->size, 0/1)
287 * except without the integer overflow problems.
288 */
289 static void rw_phys_req_item(hwaddr addr,
290 ioreq_t *req, uint32_t i, void *val, int rw)
291 {
292 /* Do everything unsigned so overflow just results in a truncated result
293 * and accesses to undesired parts of guest memory, which is up
294 * to the guest */
295 hwaddr offset = (hwaddr)req->size * i;
296 if (req->df) {
297 addr -= offset;
298 } else {
299 addr += offset;
300 }
301 address_space_rw(&address_space_memory, addr, MEMTXATTRS_UNSPECIFIED,
302 val, req->size, rw);
303 }
304
305 static inline void read_phys_req_item(hwaddr addr,
306 ioreq_t *req, uint32_t i, void *val)
307 {
308 rw_phys_req_item(addr, req, i, val, 0);
309 }
310 static inline void write_phys_req_item(hwaddr addr,
311 ioreq_t *req, uint32_t i, void *val)
312 {
313 rw_phys_req_item(addr, req, i, val, 1);
314 }
315
316
317 void cpu_ioreq_pio(ioreq_t *req)
318 {
319 uint32_t i;
320
321 trace_cpu_ioreq_pio(req, req->dir, req->df, req->data_is_ptr, req->addr,
322 req->data, req->count, req->size);
323
324 if (req->size > sizeof(uint32_t)) {
325 hw_error("PIO: bad size (%u)", req->size);
326 }
327
328 if (req->dir == IOREQ_READ) {
329 if (!req->data_is_ptr) {
330 req->data = do_inp(req->addr, req->size);
331 trace_cpu_ioreq_pio_read_reg(req, req->data, req->addr,
332 req->size);
333 } else {
334 uint32_t tmp;
335
336 for (i = 0; i < req->count; i++) {
337 tmp = do_inp(req->addr, req->size);
338 write_phys_req_item(req->data, req, i, &tmp);
339 }
340 }
341 } else if (req->dir == IOREQ_WRITE) {
342 if (!req->data_is_ptr) {
343 trace_cpu_ioreq_pio_write_reg(req, req->data, req->addr,
344 req->size);
345 do_outp(req->addr, req->size, req->data);
346 } else {
347 for (i = 0; i < req->count; i++) {
348 uint32_t tmp = 0;
349
350 read_phys_req_item(req->data, req, i, &tmp);
351 do_outp(req->addr, req->size, tmp);
352 }
353 }
354 }
355 }
356
357 static void cpu_ioreq_move(ioreq_t *req)
358 {
359 uint32_t i;
360
361 trace_cpu_ioreq_move(req, req->dir, req->df, req->data_is_ptr, req->addr,
362 req->data, req->count, req->size);
363
364 if (req->size > sizeof(req->data)) {
365 hw_error("MMIO: bad size (%u)", req->size);
366 }
367
368 if (!req->data_is_ptr) {
369 if (req->dir == IOREQ_READ) {
370 for (i = 0; i < req->count; i++) {
371 read_phys_req_item(req->addr, req, i, &req->data);
372 }
373 } else if (req->dir == IOREQ_WRITE) {
374 for (i = 0; i < req->count; i++) {
375 write_phys_req_item(req->addr, req, i, &req->data);
376 }
377 }
378 } else {
379 uint64_t tmp;
380
381 if (req->dir == IOREQ_READ) {
382 for (i = 0; i < req->count; i++) {
383 read_phys_req_item(req->addr, req, i, &tmp);
384 write_phys_req_item(req->data, req, i, &tmp);
385 }
386 } else if (req->dir == IOREQ_WRITE) {
387 for (i = 0; i < req->count; i++) {
388 read_phys_req_item(req->data, req, i, &tmp);
389 write_phys_req_item(req->addr, req, i, &tmp);
390 }
391 }
392 }
393 }
394
395 static void cpu_ioreq_config(XenIOState *state, ioreq_t *req)
396 {
397 uint32_t sbdf = req->addr >> 32;
398 uint32_t reg = req->addr;
399 XenPciDevice *xendev;
400
401 if (req->size != sizeof(uint8_t) && req->size != sizeof(uint16_t) &&
402 req->size != sizeof(uint32_t)) {
403 hw_error("PCI config access: bad size (%u)", req->size);
404 }
405
406 if (req->count != 1) {
407 hw_error("PCI config access: bad count (%u)", req->count);
408 }
409
410 QLIST_FOREACH(xendev, &state->dev_list, entry) {
411 if (xendev->sbdf != sbdf) {
412 continue;
413 }
414
415 if (!req->data_is_ptr) {
416 if (req->dir == IOREQ_READ) {
417 req->data = pci_host_config_read_common(
418 xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE,
419 req->size);
420 trace_cpu_ioreq_config_read(req, xendev->sbdf, reg,
421 req->size, req->data);
422 } else if (req->dir == IOREQ_WRITE) {
423 trace_cpu_ioreq_config_write(req, xendev->sbdf, reg,
424 req->size, req->data);
425 pci_host_config_write_common(
426 xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE,
427 req->data, req->size);
428 }
429 } else {
430 uint32_t tmp;
431
432 if (req->dir == IOREQ_READ) {
433 tmp = pci_host_config_read_common(
434 xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE,
435 req->size);
436 trace_cpu_ioreq_config_read(req, xendev->sbdf, reg,
437 req->size, tmp);
438 write_phys_req_item(req->data, req, 0, &tmp);
439 } else if (req->dir == IOREQ_WRITE) {
440 read_phys_req_item(req->data, req, 0, &tmp);
441 trace_cpu_ioreq_config_write(req, xendev->sbdf, reg,
442 req->size, tmp);
443 pci_host_config_write_common(
444 xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE,
445 tmp, req->size);
446 }
447 }
448 }
449 }
450
451 static void handle_ioreq(XenIOState *state, ioreq_t *req)
452 {
453 size_t req_size_bits = req->size * BITS_PER_BYTE;
454
455 trace_handle_ioreq(req, req->type, req->dir, req->df, req->data_is_ptr,
456 req->addr, req->data, req->count, req->size);
457
458 if (!req->data_is_ptr && (req->dir == IOREQ_WRITE) &&
459 (req_size_bits < target_long_bits())) {
460 req->data &= MAKE_64BIT_MASK(0, req_size_bits);
461 }
462
463 if (req->dir == IOREQ_WRITE)
464 trace_handle_ioreq_write(req, req->type, req->df, req->data_is_ptr,
465 req->addr, req->data, req->count, req->size);
466
467 switch (req->type) {
468 case IOREQ_TYPE_PIO:
469 cpu_ioreq_pio(req);
470 break;
471 case IOREQ_TYPE_COPY:
472 cpu_ioreq_move(req);
473 break;
474 case IOREQ_TYPE_TIMEOFFSET:
475 qapi_event_send_rtc_change((int64_t)req->data, "");
476 break;
477 case IOREQ_TYPE_INVALIDATE:
478 if (xen_map_cache_enabled()) {
479 xen_invalidate_map_cache();
480 }
481 break;
482 case IOREQ_TYPE_PCI_CONFIG:
483 cpu_ioreq_config(state, req);
484 break;
485 default:
486 arch_handle_ioreq(state, req);
487 }
488 if (req->dir == IOREQ_READ) {
489 trace_handle_ioreq_read(req, req->type, req->df, req->data_is_ptr,
490 req->addr, req->data, req->count, req->size);
491 }
492 }
493
494 static unsigned int handle_buffered_iopage(XenIOState *state)
495 {
496 buffered_iopage_t *buf_page = state->buffered_io_page;
497 buf_ioreq_t *buf_req = NULL;
498 unsigned int handled = 0;
499 ioreq_t req;
500 int qw;
501
502 if (!buf_page) {
503 return 0;
504 }
505
506 memset(&req, 0x00, sizeof(req));
507 req.state = STATE_IOREQ_READY;
508 req.count = 1;
509 req.dir = IOREQ_WRITE;
510
511 do {
512 uint32_t rdptr = buf_page->read_pointer, wrptr;
513
514 xen_rmb();
515 wrptr = buf_page->write_pointer;
516 xen_rmb();
517 if (rdptr != buf_page->read_pointer) {
518 continue;
519 }
520 if (rdptr == wrptr) {
521 break;
522 }
523 buf_req = &buf_page->buf_ioreq[rdptr % IOREQ_BUFFER_SLOT_NUM];
524 req.size = 1U << buf_req->size;
525 req.addr = buf_req->addr;
526 req.data = buf_req->data;
527 req.type = buf_req->type;
528 xen_rmb();
529 qw = (req.size == 8);
530 if (qw) {
531 if (rdptr + 1 == wrptr) {
532 hw_error("Incomplete quad word buffered ioreq");
533 }
534 buf_req = &buf_page->buf_ioreq[(rdptr + 1) %
535 IOREQ_BUFFER_SLOT_NUM];
536 req.data |= ((uint64_t)buf_req->data) << 32;
537 xen_rmb();
538 }
539
540 handle_ioreq(state, &req);
541
542 /* Only req.data may get updated by handle_ioreq(), albeit even that
543 * should not happen as such data would never make it to the guest (we
544 * can only usefully see writes here after all).
545 */
546 assert(req.state == STATE_IOREQ_READY);
547 assert(req.count == 1);
548 assert(req.dir == IOREQ_WRITE);
549 assert(!req.data_is_ptr);
550
551 qatomic_add(&buf_page->read_pointer, qw + 1);
552 handled += qw + 1;
553 } while (handled < IOREQ_BUFFER_SLOT_NUM);
554
555 return handled;
556 }
557
558 static void handle_buffered_io(void *opaque)
559 {
560 unsigned int handled;
561 XenIOState *state = opaque;
562
563 handled = handle_buffered_iopage(state);
564 if (handled >= IOREQ_BUFFER_SLOT_NUM) {
565 /* We handled a full page of ioreqs. Schedule a timer to continue
566 * processing while giving other stuff a chance to run.
567 */
568 timer_mod(state->buffered_io_timer,
569 qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
570 } else if (handled == 0) {
571 timer_del(state->buffered_io_timer);
572 qemu_xen_evtchn_unmask(state->xce_handle, state->bufioreq_local_port);
573 } else {
574 timer_mod(state->buffered_io_timer,
575 BUFFER_IO_MAX_DELAY + qemu_clock_get_ms(QEMU_CLOCK_REALTIME));
576 }
577 }
578
579 static void cpu_handle_ioreq(void *opaque)
580 {
581 XenIOState *state = opaque;
582 ioreq_t *req = cpu_get_ioreq(state);
583
584 handle_buffered_iopage(state);
585 if (req) {
586 ioreq_t copy = *req;
587
588 xen_rmb();
589 handle_ioreq(state, &copy);
590 req->data = copy.data;
591
592 if (req->state != STATE_IOREQ_INPROCESS) {
593 warn_report("Badness in I/O request ... not in service?!: "
594 "%x, ptr: %x, port: %"PRIx64", "
595 "data: %"PRIx64", count: %u, size: %u, type: %u",
596 req->state, req->data_is_ptr, req->addr,
597 req->data, req->count, req->size, req->type);
598 destroy_hvm_domain(false);
599 return;
600 }
601
602 xen_wmb(); /* Update ioreq contents /then/ update state. */
603
604 /*
605 * We do this before we send the response so that the tools
606 * have the opportunity to pick up on the reset before the
607 * guest resumes and does a hlt with interrupts disabled which
608 * causes Xen to powerdown the domain.
609 */
610 if (runstate_is_running()) {
611 ShutdownCause request;
612
613 if (qemu_shutdown_requested_get()) {
614 destroy_hvm_domain(false);
615 }
616 request = qemu_reset_requested_get();
617 if (request) {
618 qemu_system_reset(request);
619 destroy_hvm_domain(true);
620 }
621 }
622
623 req->state = STATE_IORESP_READY;
624 qemu_xen_evtchn_notify(state->xce_handle,
625 state->ioreq_local_port[state->send_vcpu]);
626 }
627 }
628
629 static void xen_main_loop_prepare(XenIOState *state)
630 {
631 int evtchn_fd = -1;
632
633 if (state->xce_handle != NULL) {
634 evtchn_fd = qemu_xen_evtchn_fd(state->xce_handle);
635 }
636
637 state->buffered_io_timer = timer_new_ms(QEMU_CLOCK_REALTIME, handle_buffered_io,
638 state);
639
640 if (evtchn_fd != -1) {
641 CPUState *cpu_state;
642
643 CPU_FOREACH(cpu_state) {
644 trace_xen_main_loop_prepare_init_cpu(cpu_state->cpu_index,
645 cpu_state);
646 state->cpu_by_vcpu_id[cpu_state->cpu_index] = cpu_state;
647 }
648 qemu_set_fd_handler(evtchn_fd, cpu_handle_ioreq, NULL, state);
649 }
650 }
651
652
653 void xen_hvm_change_state_handler(void *opaque, bool running,
654 RunState rstate)
655 {
656 XenIOState *state = opaque;
657
658 if (running) {
659 xen_main_loop_prepare(state);
660 }
661
662 xen_set_ioreq_server_state(xen_domid,
663 state->ioservid,
664 running);
665 }
666
667 void xen_exit_notifier(Notifier *n, void *data)
668 {
669 XenIOState *state = container_of(n, XenIOState, exit);
670
671 xen_destroy_ioreq_server(xen_domid, state->ioservid);
672 if (state->fres != NULL) {
673 xenforeignmemory_unmap_resource(xen_fmem, state->fres);
674 }
675
676 qemu_xen_evtchn_close(state->xce_handle);
677 xs_daemon_close(state->xenstore);
678 }
679
680 static int xen_map_ioreq_server(XenIOState *state)
681 {
682 void *addr = NULL;
683 xen_pfn_t ioreq_pfn;
684 xen_pfn_t bufioreq_pfn;
685 evtchn_port_t bufioreq_evtchn;
686 unsigned long num_frames = 1;
687 unsigned long frame = 1;
688 int rc;
689
690 /*
691 * Attempt to map using the resource API and fall back to normal
692 * foreign mapping if this is not supported.
693 */
694 QEMU_BUILD_BUG_ON(XENMEM_resource_ioreq_server_frame_bufioreq != 0);
695 QEMU_BUILD_BUG_ON(XENMEM_resource_ioreq_server_frame_ioreq(0) != 1);
696
697 if (state->has_bufioreq) {
698 frame = 0;
699 num_frames = 2;
700 }
701 state->fres = xenforeignmemory_map_resource(xen_fmem, xen_domid,
702 XENMEM_resource_ioreq_server,
703 state->ioservid,
704 frame, num_frames,
705 &addr,
706 PROT_READ | PROT_WRITE, 0);
707 if (state->fres != NULL) {
708 trace_xen_map_resource_ioreq(state->ioservid, addr);
709 state->shared_page = addr;
710 if (state->has_bufioreq) {
711 state->buffered_io_page = addr;
712 state->shared_page = addr + XC_PAGE_SIZE;
713 }
714 } else if (errno != EOPNOTSUPP) {
715 error_report("failed to map ioreq server resources: error %d handle=%p",
716 errno, xen_xc);
717 return -1;
718 }
719
720 /*
721 * If we fail to map the shared page with xenforeignmemory_map_resource()
722 * or if we're using buffered ioreqs, we need xen_get_ioreq_server_info()
723 * to provide the addresses to map the shared page and/or to get the
724 * event-channel port for buffered ioreqs.
725 */
726 if (state->shared_page == NULL || state->has_bufioreq) {
727 rc = xen_get_ioreq_server_info(xen_domid, state->ioservid,
728 (state->shared_page == NULL) ?
729 &ioreq_pfn : NULL,
730 (state->has_bufioreq &&
731 state->buffered_io_page == NULL) ?
732 &bufioreq_pfn : NULL,
733 &bufioreq_evtchn);
734 if (rc < 0) {
735 error_report("failed to get ioreq server info: error %d handle=%p",
736 errno, xen_xc);
737 return rc;
738 }
739
740 if (state->shared_page == NULL) {
741 trace_xen_map_ioreq_server_shared_page(ioreq_pfn);
742
743 state->shared_page = xenforeignmemory_map(xen_fmem, xen_domid,
744 PROT_READ | PROT_WRITE,
745 1, &ioreq_pfn, NULL);
746 }
747 if (state->shared_page == NULL) {
748 error_report("map shared IO page returned error %d handle=%p",
749 errno, xen_xc);
750 }
751
752 if (state->has_bufioreq && state->buffered_io_page == NULL) {
753 trace_xen_map_ioreq_server_buffered_io_page(bufioreq_pfn);
754
755 state->buffered_io_page = xenforeignmemory_map(xen_fmem, xen_domid,
756 PROT_READ | PROT_WRITE,
757 1, &bufioreq_pfn,
758 NULL);
759 if (state->buffered_io_page == NULL) {
760 error_report("map buffered IO page returned error %d", errno);
761 return -1;
762 }
763 }
764 }
765
766 if (state->shared_page == NULL ||
767 (state->has_bufioreq && state->buffered_io_page == NULL)) {
768 return -1;
769 }
770
771 if (state->has_bufioreq) {
772 trace_xen_map_ioreq_server_buffered_io_evtchn(bufioreq_evtchn);
773 state->bufioreq_remote_port = bufioreq_evtchn;
774 }
775
776 return 0;
777 }
778
779 void destroy_hvm_domain(bool reboot)
780 {
781 xc_interface *xc_handle;
782 int sts;
783 int rc;
784
785 unsigned int reason = reboot ? SHUTDOWN_reboot : SHUTDOWN_poweroff;
786
787 if (xen_dmod) {
788 rc = xendevicemodel_shutdown(xen_dmod, xen_domid, reason);
789 if (!rc) {
790 return;
791 }
792 if (errno != ENOTTY /* old Xen */) {
793 error_report("xendevicemodel_shutdown failed with error %d", errno);
794 }
795 /* well, try the old thing then */
796 }
797
798 xc_handle = xc_interface_open(0, 0, 0);
799 if (xc_handle == NULL) {
800 trace_destroy_hvm_domain_cannot_acquire_handle();
801 } else {
802 sts = xc_domain_shutdown(xc_handle, xen_domid, reason);
803 if (sts != 0) {
804 trace_destroy_hvm_domain_failed_action(
805 reboot ? "reboot" : "poweroff", sts, strerror(errno)
806 );
807 } else {
808 trace_destroy_hvm_domain_action(
809 xen_domid, reboot ? "reboot" : "poweroff"
810 );
811 }
812 xc_interface_close(xc_handle);
813 }
814 }
815
816 void xen_shutdown_fatal_error(const char *fmt, ...)
817 {
818 va_list ap;
819
820 va_start(ap, fmt);
821 error_vreport(fmt, ap);
822 va_end(ap);
823 error_report("Will destroy the domain.");
824 /* destroy the domain */
825 qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_ERROR);
826 }
827
828 static void xen_do_ioreq_register(XenIOState *state,
829 unsigned int max_cpus,
830 const MemoryListener *xen_memory_listener,
831 bool mapcache)
832 {
833 int i, rc;
834
835 state->exit.notify = xen_exit_notifier;
836 qemu_add_exit_notifier(&state->exit);
837
838 /*
839 * Register wake-up support in QMP query-current-machine API
840 */
841 qemu_register_wakeup_support();
842
843 rc = xen_map_ioreq_server(state);
844 if (rc < 0) {
845 goto err;
846 }
847
848 /* Note: cpus is empty at this point in init */
849 state->cpu_by_vcpu_id = g_new0(CPUState *, max_cpus);
850
851 rc = xen_set_ioreq_server_state(xen_domid, state->ioservid, true);
852 if (rc < 0) {
853 error_report("failed to enable ioreq server info: error %d handle=%p",
854 errno, xen_xc);
855 goto err;
856 }
857
858 state->ioreq_local_port = g_new0(evtchn_port_t, max_cpus);
859
860 /* FIXME: how about if we overflow the page here? */
861 for (i = 0; i < max_cpus; i++) {
862 rc = qemu_xen_evtchn_bind_interdomain(state->xce_handle, xen_domid,
863 xen_vcpu_eport(state->shared_page,
864 i));
865 if (rc == -1) {
866 error_report("shared evtchn %d bind error %d", i, errno);
867 goto err;
868 }
869 state->ioreq_local_port[i] = rc;
870 }
871
872 if (state->has_bufioreq) {
873 rc = qemu_xen_evtchn_bind_interdomain(state->xce_handle, xen_domid,
874 state->bufioreq_remote_port);
875 if (rc == -1) {
876 error_report("buffered evtchn bind error %d", errno);
877 goto err;
878 }
879 state->bufioreq_local_port = rc;
880 }
881 /* Init RAM management */
882 if (mapcache) {
883 #ifdef XEN_COMPAT_PHYSMAP
884 xen_map_cache_init(xen_phys_offset_to_gaddr, state);
885 #else
886 xen_map_cache_init(NULL, state);
887 #endif
888 }
889
890 qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);
891
892 state->memory_listener = *xen_memory_listener;
893 memory_listener_register(&state->memory_listener, &address_space_memory);
894
895 state->io_listener = xen_io_listener;
896 memory_listener_register(&state->io_listener, &address_space_io);
897
898 state->device_listener = xen_device_listener;
899 QLIST_INIT(&state->dev_list);
900 device_listener_register(&state->device_listener);
901
902 return;
903
904 err:
905 error_report("xen hardware virtual machine initialisation failed");
906 exit(1);
907 }
908
909 void xen_register_ioreq(XenIOState *state, unsigned int max_cpus,
910 uint8_t handle_bufioreq,
911 const MemoryListener *xen_memory_listener,
912 bool mapcache)
913 {
914 int rc;
915
916 setup_xen_backend_ops();
917
918 state->xce_handle = qemu_xen_evtchn_open();
919 if (state->xce_handle == NULL) {
920 error_report("xen: event channel open failed with error %d", errno);
921 goto err;
922 }
923
924 state->xenstore = xs_daemon_open();
925 if (state->xenstore == NULL) {
926 error_report("xen: xenstore open failed with error %d", errno);
927 goto err;
928 }
929
930 state->has_bufioreq = handle_bufioreq != HVM_IOREQSRV_BUFIOREQ_OFF;
931 rc = xen_create_ioreq_server(xen_domid, handle_bufioreq, &state->ioservid);
932 if (!rc) {
933 xen_do_ioreq_register(state, max_cpus, xen_memory_listener, mapcache);
934 } else {
935 warn_report("xen: failed to create ioreq server");
936 }
937
938 xen_bus_init();
939
940 return;
941
942 err:
943 error_report("xen hardware virtual machine backend registration failed");
944 exit(1);
945 }