?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'upstream-merge'
[qemu-kvm/fedora.git] / qemu-kvm.c
blob2d0015c9c46e2ffc4601c9b2654b4091951ac5c6
1 /*
2 * qemu/kvm integration
3 *
4 * Copyright (C) 2006-2008 Qumranet Technologies
5 *
6 * Licensed under the terms of the GNU GPL version 2 or higher.
7 */
8 #include "config.h"
9 #include "config-host.h"
10
11 #include <assert.h>
12 #include <string.h>
13 #include "hw/hw.h"
14 #include "sysemu.h"
15 #include "qemu-common.h"
16 #include "console.h"
17 #include "block.h"
18 #include "compatfd.h"
19 #include "gdbstub.h"
20
21 #include "qemu-kvm.h"
22 #include "libkvm-all.h"
23 #include "libkvm.h"
24
25 #include <pthread.h>
26 #include <sys/utsname.h>
27 #include <sys/syscall.h>
28 #include <sys/mman.h>
29 #include <sys/ioctl.h>
30
31 #define false 0
32 #define true 1
33
34 #define EXPECTED_KVM_API_VERSION 12
35
36 #if EXPECTED_KVM_API_VERSION != KVM_API_VERSION
37 #error libkvm: userspace and kernel version mismatch
38 #endif
39
40 int kvm_allowed = 1;
41 int kvm_irqchip = 1;
42 int kvm_pit = 1;
43 int kvm_pit_reinject = 1;
44 int kvm_nested = 0;
45 kvm_context_t kvm_context;
46
47 pthread_mutex_t qemu_mutex = PTHREAD_MUTEX_INITIALIZER;
48 pthread_cond_t qemu_vcpu_cond = PTHREAD_COND_INITIALIZER;
49 pthread_cond_t qemu_system_cond = PTHREAD_COND_INITIALIZER;
50 pthread_cond_t qemu_pause_cond = PTHREAD_COND_INITIALIZER;
51 pthread_cond_t qemu_work_cond = PTHREAD_COND_INITIALIZER;
52 __thread CPUState *current_env;
53
54 static int qemu_system_ready;
55
56 #define SIG_IPI (SIGRTMIN+4)
57
58 pthread_t io_thread;
59 static int io_thread_fd = -1;
60 static int io_thread_sigfd = -1;
61
62 static CPUState *kvm_debug_cpu_requested;
63
64 static uint64_t phys_ram_size;
65
66 /* The list of ioperm_data */
67 static LIST_HEAD(, ioperm_data) ioperm_head;
68
69 //#define DEBUG_MEMREG
70 #ifdef DEBUG_MEMREG
71 #define DPRINTF(fmt, args...) \
72 do { fprintf(stderr, "%s:%d " fmt , __func__, __LINE__, ##args); } while (0)
73 #else
74 #define DPRINTF(fmt, args...) do {} while (0)
75 #endif
76
77 #define ALIGN(x, y) (((x)+(y)-1) & ~((y)-1))
78
79 int kvm_abi = EXPECTED_KVM_API_VERSION;
80 int kvm_page_size;
81
82 static inline void set_gsi(kvm_context_t kvm, unsigned int gsi)
83 {
84 uint32_t *bitmap = kvm->used_gsi_bitmap;
85
86 if (gsi < kvm->max_gsi)
87 bitmap[gsi / 32] |= 1U << (gsi % 32);
88 else
89 DPRINTF("Invalid GSI %d\n");
90 }
91
92 static inline void clear_gsi(kvm_context_t kvm, unsigned int gsi)
93 {
94 uint32_t *bitmap = kvm->used_gsi_bitmap;
95
96 if (gsi < kvm->max_gsi)
97 bitmap[gsi / 32] &= ~(1U << (gsi % 32));
98 else
99 DPRINTF("Invalid GSI %d\n");
100 }
101
102 struct slot_info {
103 unsigned long phys_addr;
104 unsigned long len;
105 unsigned long userspace_addr;
106 unsigned flags;
107 int logging_count;
108 };
109
110 struct slot_info slots[KVM_MAX_NUM_MEM_REGIONS];
111
112 static void init_slots(void)
113 {
114 int i;
115
116 for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS; ++i)
117 slots[i].len = 0;
118 }
119
120 static int get_free_slot(kvm_context_t kvm)
121 {
122 int i;
123 int tss_ext;
124
125 #if defined(KVM_CAP_SET_TSS_ADDR) && !defined(__s390__)
126 tss_ext = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
127 #else
128 tss_ext = 0;
129 #endif
130
131 /*
132 * on older kernels where the set tss ioctl is not supprted we must save
133 * slot 0 to hold the extended memory, as the vmx will use the last 3
134 * pages of this slot.
135 */
136 if (tss_ext > 0)
137 i = 0;
138 else
139 i = 1;
140
141 for (; i < KVM_MAX_NUM_MEM_REGIONS; ++i)
142 if (!slots[i].len)
143 return i;
144 return -1;
145 }
146
147 static void register_slot(int slot, unsigned long phys_addr, unsigned long len,
148 unsigned long userspace_addr, unsigned flags)
149 {
150 slots[slot].phys_addr = phys_addr;
151 slots[slot].len = len;
152 slots[slot].userspace_addr = userspace_addr;
153 slots[slot].flags = flags;
154 }
155
156 static void free_slot(int slot)
157 {
158 slots[slot].len = 0;
159 slots[slot].logging_count = 0;
160 }
161
162 static int get_slot(unsigned long phys_addr)
163 {
164 int i;
165
166 for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS ; ++i) {
167 if (slots[i].len && slots[i].phys_addr <= phys_addr &&
168 (slots[i].phys_addr + slots[i].len-1) >= phys_addr)
169 return i;
170 }
171 return -1;
172 }
173
174 /* Returns -1 if this slot is not totally contained on any other,
175 * and the number of the slot otherwise */
176 static int get_container_slot(uint64_t phys_addr, unsigned long size)
177 {
178 int i;
179
180 for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS ; ++i)
181 if (slots[i].len && slots[i].phys_addr <= phys_addr &&
182 (slots[i].phys_addr + slots[i].len) >= phys_addr + size)
183 return i;
184 return -1;
185 }
186
187 int kvm_is_containing_region(kvm_context_t kvm, unsigned long phys_addr, unsigned long size)
188 {
189 int slot = get_container_slot(phys_addr, size);
190 if (slot == -1)
191 return 0;
192 return 1;
193 }
194
195 /*
196 * dirty pages logging control
197 */
198 static int kvm_dirty_pages_log_change(kvm_context_t kvm,
199 unsigned long phys_addr,
200 unsigned flags,
201 unsigned mask)
202 {
203 int r = -1;
204 int slot = get_slot(phys_addr);
205
206 if (slot == -1) {
207 fprintf(stderr, "BUG: %s: invalid parameters\n", __FUNCTION__);
208 return 1;
209 }
210
211 flags = (slots[slot].flags & ~mask) | flags;
212 if (flags == slots[slot].flags)
213 return 0;
214 slots[slot].flags = flags;
215
216 {
217 struct kvm_userspace_memory_region mem = {
218 .slot = slot,
219 .memory_size = slots[slot].len,
220 .guest_phys_addr = slots[slot].phys_addr,
221 .userspace_addr = slots[slot].userspace_addr,
222 .flags = slots[slot].flags,
223 };
224
225
226 DPRINTF("slot %d start %llx len %llx flags %x\n",
227 mem.slot,
228 mem.guest_phys_addr,
229 mem.memory_size,
230 mem.flags);
231 r = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &mem);
232 if (r == -1)
233 fprintf(stderr, "%s: %m\n", __FUNCTION__);
234 }
235 return r;
236 }
237
238 static int kvm_dirty_pages_log_change_all(kvm_context_t kvm,
239 int (*change)(kvm_context_t kvm,
240 uint64_t start,
241 uint64_t len))
242 {
243 int i, r;
244
245 for (i=r=0; i<KVM_MAX_NUM_MEM_REGIONS && r==0; i++) {
246 if (slots[i].len)
247 r = change(kvm, slots[i].phys_addr, slots[i].len);
248 }
249 return r;
250 }
251
252 int kvm_dirty_pages_log_enable_slot(kvm_context_t kvm,
253 uint64_t phys_addr,
254 uint64_t len)
255 {
256 int slot = get_slot(phys_addr);
257
258 DPRINTF("start %"PRIx64" len %"PRIx64"\n", phys_addr, len);
259 if (slot == -1) {
260 fprintf(stderr, "BUG: %s: invalid parameters\n", __func__);
261 return -EINVAL;
262 }
263
264 if (slots[slot].logging_count++)
265 return 0;
266
267 return kvm_dirty_pages_log_change(kvm, slots[slot].phys_addr,
268 KVM_MEM_LOG_DIRTY_PAGES,
269 KVM_MEM_LOG_DIRTY_PAGES);
270 }
271
272 int kvm_dirty_pages_log_disable_slot(kvm_context_t kvm,
273 uint64_t phys_addr,
274 uint64_t len)
275 {
276 int slot = get_slot(phys_addr);
277
278 if (slot == -1) {
279 fprintf(stderr, "BUG: %s: invalid parameters\n", __func__);
280 return -EINVAL;
281 }
282
283 if (--slots[slot].logging_count)
284 return 0;
285
286 return kvm_dirty_pages_log_change(kvm, slots[slot].phys_addr,
287 0,
288 KVM_MEM_LOG_DIRTY_PAGES);
289 }
290
291 /**
292 * Enable dirty page logging for all memory regions
293 */
294 int kvm_dirty_pages_log_enable_all(kvm_context_t kvm)
295 {
296 if (kvm->dirty_pages_log_all)
297 return 0;
298 kvm->dirty_pages_log_all = 1;
299 return kvm_dirty_pages_log_change_all(kvm,
300 kvm_dirty_pages_log_enable_slot);
301 }
302
303 /**
304 * Enable dirty page logging only for memory regions that were created with
305 * dirty logging enabled (disable for all other memory regions).
306 */
307 int kvm_dirty_pages_log_reset(kvm_context_t kvm)
308 {
309 if (!kvm->dirty_pages_log_all)
310 return 0;
311 kvm->dirty_pages_log_all = 0;
312 return kvm_dirty_pages_log_change_all(kvm,
313 kvm_dirty_pages_log_disable_slot);
314 }
315
316
317 kvm_context_t kvm_init(struct kvm_callbacks *callbacks,
318 void *opaque)
319 {
320 int fd;
321 kvm_context_t kvm;
322 int r, gsi_count;
323
324 fd = open("/dev/kvm", O_RDWR);
325 if (fd == -1) {
326 perror("open /dev/kvm");
327 return NULL;
328 }
329 r = ioctl(fd, KVM_GET_API_VERSION, 0);
330 if (r == -1) {
331 fprintf(stderr, "kvm kernel version too old: "
332 "KVM_GET_API_VERSION ioctl not supported\n");
333 goto out_close;
334 }
335 if (r < EXPECTED_KVM_API_VERSION) {
336 fprintf(stderr, "kvm kernel version too old: "
337 "We expect API version %d or newer, but got "
338 "version %d\n",
339 EXPECTED_KVM_API_VERSION, r);
340 goto out_close;
341 }
342 if (r > EXPECTED_KVM_API_VERSION) {
343 fprintf(stderr, "kvm userspace version too old\n");
344 goto out_close;
345 }
346 kvm_abi = r;
347 kvm_page_size = getpagesize();
348 kvm = malloc(sizeof(*kvm));
349 if (kvm == NULL)
350 goto out_close;
351 memset(kvm, 0, sizeof(*kvm));
352 kvm->fd = fd;
353 kvm->vm_fd = -1;
354 kvm->callbacks = callbacks;
355 kvm->opaque = opaque;
356 kvm->dirty_pages_log_all = 0;
357 kvm->no_irqchip_creation = 0;
358 kvm->no_pit_creation = 0;
359
360 gsi_count = kvm_get_gsi_count(kvm);
361 if (gsi_count > 0) {
362 int gsi_bits, i;
363
364 /* Round up so we can search ints using ffs */
365 gsi_bits = ALIGN(gsi_count, 32);
366 kvm->used_gsi_bitmap = malloc(gsi_bits / 8);
367 if (!kvm->used_gsi_bitmap)
368 goto out_close;
369 memset(kvm->used_gsi_bitmap, 0, gsi_bits / 8);
370 kvm->max_gsi = gsi_bits;
371
372 /* Mark any over-allocated bits as already in use */
373 for (i = gsi_count; i < gsi_bits; i++)
374 set_gsi(kvm, i);
375 }
376
377 return kvm;
378 out_close:
379 close(fd);
380 return NULL;
381 }
382
383 void kvm_finalize(kvm_context_t kvm)
384 {
385 /* FIXME
386 if (kvm->vcpu_fd[0] != -1)
387 close(kvm->vcpu_fd[0]);
388 if (kvm->vm_fd != -1)
389 close(kvm->vm_fd);
390 */
391 close(kvm->fd);
392 free(kvm);
393 }
394
395 void kvm_disable_irqchip_creation(kvm_context_t kvm)
396 {
397 kvm->no_irqchip_creation = 1;
398 }
399
400 void kvm_disable_pit_creation(kvm_context_t kvm)
401 {
402 kvm->no_pit_creation = 1;
403 }
404
405 kvm_vcpu_context_t kvm_create_vcpu(kvm_context_t kvm, int id)
406 {
407 long mmap_size;
408 int r;
409 kvm_vcpu_context_t vcpu_ctx = malloc(sizeof(struct kvm_vcpu_context));
410
411 if (!vcpu_ctx) {
412 errno = ENOMEM;
413 return NULL;
414 }
415
416 vcpu_ctx->kvm = kvm;
417 vcpu_ctx->id = id;
418
419 r = ioctl(kvm->vm_fd, KVM_CREATE_VCPU, id);
420 if (r == -1) {
421 fprintf(stderr, "kvm_create_vcpu: %m\n");
422 goto err;
423 }
424 vcpu_ctx->fd = r;
425 mmap_size = ioctl(kvm->fd, KVM_GET_VCPU_MMAP_SIZE, 0);
426 if (mmap_size == -1) {
427 fprintf(stderr, "get vcpu mmap size: %m\n");
428 goto err_fd;
429 }
430 vcpu_ctx->run = mmap(NULL, mmap_size, PROT_READ|PROT_WRITE, MAP_SHARED,
431 vcpu_ctx->fd, 0);
432 if (vcpu_ctx->run == MAP_FAILED) {
433 fprintf(stderr, "mmap vcpu area: %m\n");
434 goto err_fd;
435 }
436 return vcpu_ctx;
437 err_fd:
438 close(vcpu_ctx->fd);
439 err:
440 free(vcpu_ctx);
441 return NULL;
442 }
443
444 int kvm_create_vm(kvm_context_t kvm)
445 {
446 int fd = kvm->fd;
447
448 #ifdef KVM_CAP_IRQ_ROUTING
449 kvm->irq_routes = malloc(sizeof(*kvm->irq_routes));
450 if (!kvm->irq_routes)
451 return -ENOMEM;
452 memset(kvm->irq_routes, 0, sizeof(*kvm->irq_routes));
453 kvm->nr_allocated_irq_routes = 0;
454 #endif
455
456 fd = ioctl(fd, KVM_CREATE_VM, 0);
457 if (fd == -1) {
458 fprintf(stderr, "kvm_create_vm: %m\n");
459 return -1;
460 }
461 kvm->vm_fd = fd;
462 return 0;
463 }
464
465 static int kvm_create_default_phys_mem(kvm_context_t kvm,
466 unsigned long phys_mem_bytes,
467 void **vm_mem)
468 {
469 #ifdef KVM_CAP_USER_MEMORY
470 int r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_USER_MEMORY);
471 if (r > 0)
472 return 0;
473 fprintf(stderr, "Hypervisor too old: KVM_CAP_USER_MEMORY extension not supported\n");
474 #else
475 #error Hypervisor too old: KVM_CAP_USER_MEMORY extension not supported
476 #endif
477 return -1;
478 }
479
480 int kvm_check_extension(kvm_context_t kvm, int ext)
481 {
482 int ret;
483
484 ret = ioctl(kvm->fd, KVM_CHECK_EXTENSION, ext);
485 if (ret > 0)
486 return ret;
487 return 0;
488 }
489
490 void kvm_create_irqchip(kvm_context_t kvm)
491 {
492 int r;
493
494 kvm->irqchip_in_kernel = 0;
495 #ifdef KVM_CAP_IRQCHIP
496 if (!kvm->no_irqchip_creation) {
497 r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_IRQCHIP);
498 if (r > 0) { /* kernel irqchip supported */
499 r = ioctl(kvm->vm_fd, KVM_CREATE_IRQCHIP);
500 if (r >= 0) {
501 kvm->irqchip_inject_ioctl = KVM_IRQ_LINE;
502 #if defined(KVM_CAP_IRQ_INJECT_STATUS) && defined(KVM_IRQ_LINE_STATUS)
503 r = ioctl(kvm->fd, KVM_CHECK_EXTENSION,
504 KVM_CAP_IRQ_INJECT_STATUS);
505 if (r > 0)
506 kvm->irqchip_inject_ioctl = KVM_IRQ_LINE_STATUS;
507 #endif
508 kvm->irqchip_in_kernel = 1;
509 }
510 else
511 fprintf(stderr, "Create kernel PIC irqchip failed\n");
512 }
513 }
514 #endif
515 }
516
517 int kvm_create(kvm_context_t kvm, unsigned long phys_mem_bytes, void **vm_mem)
518 {
519 int r;
520
521 r = kvm_create_vm(kvm);
522 if (r < 0)
523 return r;
524 r = kvm_arch_create(kvm, phys_mem_bytes, vm_mem);
525 if (r < 0)
526 return r;
527 init_slots();
528 r = kvm_create_default_phys_mem(kvm, phys_mem_bytes, vm_mem);
529 if (r < 0)
530 return r;
531 kvm_create_irqchip(kvm);
532
533 return 0;
534 }
535
536
537 void *kvm_create_phys_mem(kvm_context_t kvm, unsigned long phys_start,
538 unsigned long len, int log, int writable)
539 {
540 int r;
541 int prot = PROT_READ;
542 void *ptr;
543 struct kvm_userspace_memory_region memory = {
544 .memory_size = len,
545 .guest_phys_addr = phys_start,
546 .flags = log ? KVM_MEM_LOG_DIRTY_PAGES : 0,
547 };
548
549 if (writable)
550 prot |= PROT_WRITE;
551
552 #if !defined(__s390__)
553 ptr = mmap(NULL, len, prot, MAP_ANONYMOUS | MAP_SHARED, -1, 0);
554 #else
555 ptr = mmap(LIBKVM_S390_ORIGIN, len, prot | PROT_EXEC,
556 MAP_FIXED | MAP_SHARED | MAP_ANONYMOUS, -1, 0);
557 #endif
558 if (ptr == MAP_FAILED) {
559 fprintf(stderr, "%s: %s", __func__, strerror(errno));
560 return 0;
561 }
562
563 memset(ptr, 0, len);
564
565 memory.userspace_addr = (unsigned long)ptr;
566 memory.slot = get_free_slot(kvm);
567 DPRINTF("slot %d start %llx len %llx flags %x\n",
568 memory.slot,
569 memory.guest_phys_addr,
570 memory.memory_size,
571 memory.flags);
572 r = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &memory);
573 if (r == -1) {
574 fprintf(stderr, "%s: %s", __func__, strerror(errno));
575 return 0;
576 }
577 register_slot(memory.slot, memory.guest_phys_addr, memory.memory_size,
578 memory.userspace_addr, memory.flags);
579
580 return ptr;
581 }
582
583 int kvm_register_phys_mem(kvm_context_t kvm,
584 unsigned long phys_start, void *userspace_addr,
585 unsigned long len, int log)
586 {
587
588 struct kvm_userspace_memory_region memory = {
589 .memory_size = len,
590 .guest_phys_addr = phys_start,
591 .userspace_addr = (unsigned long)(intptr_t)userspace_addr,
592 .flags = log ? KVM_MEM_LOG_DIRTY_PAGES : 0,
593 };
594 int r;
595
596 memory.slot = get_free_slot(kvm);
597 DPRINTF("memory: gpa: %llx, size: %llx, uaddr: %llx, slot: %x, flags: %lx\n",
598 memory.guest_phys_addr, memory.memory_size,
599 memory.userspace_addr, memory.slot, memory.flags);
600 r = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &memory);
601 if (r == -1) {
602 fprintf(stderr, "create_userspace_phys_mem: %s\n", strerror(errno));
603 return -1;
604 }
605 register_slot(memory.slot, memory.guest_phys_addr, memory.memory_size,
606 memory.userspace_addr, memory.flags);
607 return 0;
608 }
609
610
611 /* destroy/free a whole slot.
612 * phys_start, len and slot are the params passed to kvm_create_phys_mem()
613 */
614 void kvm_destroy_phys_mem(kvm_context_t kvm, unsigned long phys_start,
615 unsigned long len)
616 {
617 int slot;
618 int r;
619 struct kvm_userspace_memory_region memory = {
620 .memory_size = 0,
621 .guest_phys_addr = phys_start,
622 .userspace_addr = 0,
623 .flags = 0,
624 };
625
626 slot = get_slot(phys_start);
627
628 if ((slot >= KVM_MAX_NUM_MEM_REGIONS) || (slot == -1)) {
629 fprintf(stderr, "BUG: %s: invalid parameters (slot=%d)\n",
630 __FUNCTION__, slot);
631 return;
632 }
633 if (phys_start != slots[slot].phys_addr) {
634 fprintf(stderr,
635 "WARNING: %s: phys_start is 0x%lx expecting 0x%lx\n",
636 __FUNCTION__, phys_start, slots[slot].phys_addr);
637 phys_start = slots[slot].phys_addr;
638 }
639
640 memory.slot = slot;
641 DPRINTF("slot %d start %llx len %llx flags %x\n",
642 memory.slot,
643 memory.guest_phys_addr,
644 memory.memory_size,
645 memory.flags);
646 r = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &memory);
647 if (r == -1) {
648 fprintf(stderr, "destroy_userspace_phys_mem: %s",
649 strerror(errno));
650 return;
651 }
652
653 free_slot(memory.slot);
654 }
655
656 void kvm_unregister_memory_area(kvm_context_t kvm, uint64_t phys_addr, unsigned long size)
657 {
658
659 int slot = get_container_slot(phys_addr, size);
660
661 if (slot != -1) {
662 DPRINTF("Unregistering memory region %llx (%lx)\n", phys_addr, size);
663 kvm_destroy_phys_mem(kvm, phys_addr, size);
664 return;
665 }
666 }
667
668 static int kvm_get_map(kvm_context_t kvm, int ioctl_num, int slot, void *buf)
669 {
670 int r;
671 struct kvm_dirty_log log = {
672 .slot = slot,
673 };
674
675 log.dirty_bitmap = buf;
676
677 r = ioctl(kvm->vm_fd, ioctl_num, &log);
678 if (r == -1)
679 return -errno;
680 return 0;
681 }
682
683 int kvm_get_dirty_pages(kvm_context_t kvm, unsigned long phys_addr, void *buf)
684 {
685 int slot;
686
687 slot = get_slot(phys_addr);
688 return kvm_get_map(kvm, KVM_GET_DIRTY_LOG, slot, buf);
689 }
690
691 int kvm_get_dirty_pages_range(kvm_context_t kvm, unsigned long phys_addr,
692 unsigned long len, void *opaque,
693 int (*cb)(unsigned long start, unsigned long len,
694 void*bitmap, void *opaque))
695 {
696 int i;
697 int r;
698 unsigned long end_addr = phys_addr + len;
699 void *buf;
700
701 for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS; ++i) {
702 if ((slots[i].len && (uint64_t)slots[i].phys_addr >= phys_addr)
703 && ((uint64_t)slots[i].phys_addr + slots[i].len <= end_addr)) {
704 buf = qemu_malloc((slots[i].len / 4096 + 7) / 8 + 2);
705 r = kvm_get_map(kvm, KVM_GET_DIRTY_LOG, i, buf);
706 if (r) {
707 qemu_free(buf);
708 return r;
709 }
710 r = cb(slots[i].phys_addr, slots[i].len, buf, opaque);
711 qemu_free(buf);
712 if (r)
713 return r;
714 }
715 }
716 return 0;
717 }
718
719 #ifdef KVM_CAP_IRQCHIP
720
721 int kvm_set_irq_level(kvm_context_t kvm, int irq, int level, int *status)
722 {
723 struct kvm_irq_level event;
724 int r;
725
726 if (!kvm->irqchip_in_kernel)
727 return 0;
728 event.level = level;
729 event.irq = irq;
730 r = ioctl(kvm->vm_fd, kvm->irqchip_inject_ioctl, &event);
731 if (r == -1)
732 perror("kvm_set_irq_level");
733
734 if (status) {
735 #ifdef KVM_CAP_IRQ_INJECT_STATUS
736 *status = (kvm->irqchip_inject_ioctl == KVM_IRQ_LINE) ?
737 1 : event.status;
738 #else
739 *status = 1;
740 #endif
741 }
742
743 return 1;
744 }
745
746 int kvm_get_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip)
747 {
748 int r;
749
750 if (!kvm->irqchip_in_kernel)
751 return 0;
752 r = ioctl(kvm->vm_fd, KVM_GET_IRQCHIP, chip);
753 if (r == -1) {
754 r = -errno;
755 perror("kvm_get_irqchip\n");
756 }
757 return r;
758 }
759
760 int kvm_set_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip)
761 {
762 int r;
763
764 if (!kvm->irqchip_in_kernel)
765 return 0;
766 r = ioctl(kvm->vm_fd, KVM_SET_IRQCHIP, chip);
767 if (r == -1) {
768 r = -errno;
769 perror("kvm_set_irqchip\n");
770 }
771 return r;
772 }
773
774 #endif
775
776 static int handle_io(kvm_vcpu_context_t vcpu)
777 {
778 struct kvm_run *run = vcpu->run;
779 kvm_context_t kvm = vcpu->kvm;
780 uint16_t addr = run->io.port;
781 int r;
782 int i;
783 void *p = (void *)run + run->io.data_offset;
784
785 for (i = 0; i < run->io.count; ++i) {
786 switch (run->io.direction) {
787 case KVM_EXIT_IO_IN:
788 switch (run->io.size) {
789 case 1:
790 r = kvm->callbacks->inb(kvm->opaque, addr, p);
791 break;
792 case 2:
793 r = kvm->callbacks->inw(kvm->opaque, addr, p);
794 break;
795 case 4:
796 r = kvm->callbacks->inl(kvm->opaque, addr, p);
797 break;
798 default:
799 fprintf(stderr, "bad I/O size %d\n", run->io.size);
800 return -EMSGSIZE;
801 }
802 break;
803 case KVM_EXIT_IO_OUT:
804 switch (run->io.size) {
805 case 1:
806 r = kvm->callbacks->outb(kvm->opaque, addr,
807 *(uint8_t *)p);
808 break;
809 case 2:
810 r = kvm->callbacks->outw(kvm->opaque, addr,
811 *(uint16_t *)p);
812 break;
813 case 4:
814 r = kvm->callbacks->outl(kvm->opaque, addr,
815 *(uint32_t *)p);
816 break;
817 default:
818 fprintf(stderr, "bad I/O size %d\n", run->io.size);
819 return -EMSGSIZE;
820 }
821 break;
822 default:
823 fprintf(stderr, "bad I/O direction %d\n", run->io.direction);
824 return -EPROTO;
825 }
826
827 p += run->io.size;
828 }
829
830 return 0;
831 }
832
833 int handle_debug(kvm_vcpu_context_t vcpu, void *env)
834 {
835 #ifdef KVM_CAP_SET_GUEST_DEBUG
836 struct kvm_run *run = vcpu->run;
837 kvm_context_t kvm = vcpu->kvm;
838
839 return kvm->callbacks->debug(kvm->opaque, env, &run->debug.arch);
840 #else
841 return 0;
842 #endif
843 }
844
845 int kvm_get_regs(kvm_vcpu_context_t vcpu, struct kvm_regs *regs)
846 {
847 return ioctl(vcpu->fd, KVM_GET_REGS, regs);
848 }
849
850 int kvm_set_regs(kvm_vcpu_context_t vcpu, struct kvm_regs *regs)
851 {
852 return ioctl(vcpu->fd, KVM_SET_REGS, regs);
853 }
854
855 int kvm_get_fpu(kvm_vcpu_context_t vcpu, struct kvm_fpu *fpu)
856 {
857 return ioctl(vcpu->fd, KVM_GET_FPU, fpu);
858 }
859
860 int kvm_set_fpu(kvm_vcpu_context_t vcpu, struct kvm_fpu *fpu)
861 {
862 return ioctl(vcpu->fd, KVM_SET_FPU, fpu);
863 }
864
865 int kvm_get_sregs(kvm_vcpu_context_t vcpu, struct kvm_sregs *sregs)
866 {
867 return ioctl(vcpu->fd, KVM_GET_SREGS, sregs);
868 }
869
870 int kvm_set_sregs(kvm_vcpu_context_t vcpu, struct kvm_sregs *sregs)
871 {
872 return ioctl(vcpu->fd, KVM_SET_SREGS, sregs);
873 }
874
875 #ifdef KVM_CAP_MP_STATE
876 int kvm_get_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state)
877 {
878 int r;
879
880 r = ioctl(vcpu->kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_MP_STATE);
881 if (r > 0)
882 return ioctl(vcpu->fd, KVM_GET_MP_STATE, mp_state);
883 return -ENOSYS;
884 }
885
886 int kvm_set_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state)
887 {
888 int r;
889
890 r = ioctl(vcpu->kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_MP_STATE);
891 if (r > 0)
892 return ioctl(vcpu->fd, KVM_SET_MP_STATE, mp_state);
893 return -ENOSYS;
894 }
895 #endif
896
897 static int handle_mmio(kvm_vcpu_context_t vcpu)
898 {
899 unsigned long addr = vcpu->run->mmio.phys_addr;
900 kvm_context_t kvm = vcpu->kvm;
901 struct kvm_run *kvm_run = vcpu->run;
902 void *data = kvm_run->mmio.data;
903
904 /* hack: Red Hat 7.1 generates these weird accesses. */
905 if ((addr > 0xa0000-4 && addr <= 0xa0000) && kvm_run->mmio.len == 3)
906 return 0;
907
908 if (kvm_run->mmio.is_write)
909 return kvm->callbacks->mmio_write(kvm->opaque, addr, data,
910 kvm_run->mmio.len);
911 else
912 return kvm->callbacks->mmio_read(kvm->opaque, addr, data,
913 kvm_run->mmio.len);
914 }
915
916 int handle_io_window(kvm_context_t kvm)
917 {
918 return kvm->callbacks->io_window(kvm->opaque);
919 }
920
921 int handle_halt(kvm_vcpu_context_t vcpu)
922 {
923 return vcpu->kvm->callbacks->halt(vcpu->kvm->opaque, vcpu);
924 }
925
926 int handle_shutdown(kvm_context_t kvm, void *env)
927 {
928 return kvm->callbacks->shutdown(kvm->opaque, env);
929 }
930
931 int try_push_interrupts(kvm_context_t kvm)
932 {
933 return kvm->callbacks->try_push_interrupts(kvm->opaque);
934 }
935
936 static inline void push_nmi(kvm_context_t kvm)
937 {
938 #ifdef KVM_CAP_USER_NMI
939 kvm->callbacks->push_nmi(kvm->opaque);
940 #endif /* KVM_CAP_USER_NMI */
941 }
942
943 void post_kvm_run(kvm_context_t kvm, void *env)
944 {
945 kvm->callbacks->post_kvm_run(kvm->opaque, env);
946 }
947
948 int pre_kvm_run(kvm_context_t kvm, void *env)
949 {
950 return kvm->callbacks->pre_kvm_run(kvm->opaque, env);
951 }
952
953 int kvm_get_interrupt_flag(kvm_vcpu_context_t vcpu)
954 {
955 return vcpu->run->if_flag;
956 }
957
958 int kvm_is_ready_for_interrupt_injection(kvm_vcpu_context_t vcpu)
959 {
960 return vcpu->run->ready_for_interrupt_injection;
961 }
962
963 int kvm_run(kvm_vcpu_context_t vcpu, void *env)
964 {
965 int r;
966 int fd = vcpu->fd;
967 struct kvm_run *run = vcpu->run;
968 kvm_context_t kvm = vcpu->kvm;
969
970 again:
971 push_nmi(kvm);
972 #if !defined(__s390__)
973 if (!kvm->irqchip_in_kernel)
974 run->request_interrupt_window = try_push_interrupts(kvm);
975 #endif
976 r = pre_kvm_run(kvm, env);
977 if (r)
978 return r;
979 r = ioctl(fd, KVM_RUN, 0);
980
981 if (r == -1 && errno != EINTR && errno != EAGAIN) {
982 r = -errno;
983 post_kvm_run(kvm, env);
984 fprintf(stderr, "kvm_run: %s\n", strerror(-r));
985 return r;
986 }
987
988 post_kvm_run(kvm, env);
989
990 #if defined(KVM_CAP_COALESCED_MMIO)
991 if (kvm->coalesced_mmio) {
992 struct kvm_coalesced_mmio_ring *ring = (void *)run +
993 kvm->coalesced_mmio * PAGE_SIZE;
994 while (ring->first != ring->last) {
995 kvm->callbacks->mmio_write(kvm->opaque,
996 ring->coalesced_mmio[ring->first].phys_addr,
997 &ring->coalesced_mmio[ring->first].data[0],
998 ring->coalesced_mmio[ring->first].len);
999 smp_wmb();
1000 ring->first = (ring->first + 1) %
1001 KVM_COALESCED_MMIO_MAX;
1002 }
1003 }
1004 #endif
1005
1006 #if !defined(__s390__)
1007 if (r == -1) {
1008 r = handle_io_window(kvm);
1009 goto more;
1010 }
1011 #endif
1012 if (1) {
1013 switch (run->exit_reason) {
1014 case KVM_EXIT_UNKNOWN:
1015 r = kvm->callbacks->unhandled(kvm, vcpu,
1016 run->hw.hardware_exit_reason);
1017 break;
1018 case KVM_EXIT_FAIL_ENTRY:
1019 r = kvm->callbacks->unhandled(kvm, vcpu,
1020 run->fail_entry.hardware_entry_failure_reason);
1021 break;
1022 case KVM_EXIT_EXCEPTION:
1023 fprintf(stderr, "exception %d (%x)\n",
1024 run->ex.exception,
1025 run->ex.error_code);
1026 kvm_show_regs(vcpu);
1027 kvm_show_code(vcpu);
1028 abort();
1029 break;
1030 case KVM_EXIT_IO:
1031 r = handle_io(vcpu);
1032 break;
1033 case KVM_EXIT_DEBUG:
1034 r = handle_debug(vcpu, env);
1035 break;
1036 case KVM_EXIT_MMIO:
1037 r = handle_mmio(vcpu);
1038 break;
1039 case KVM_EXIT_HLT:
1040 r = handle_halt(vcpu);
1041 break;
1042 case KVM_EXIT_IRQ_WINDOW_OPEN:
1043 break;
1044 case KVM_EXIT_SHUTDOWN:
1045 r = handle_shutdown(kvm, env);
1046 break;
1047 #if defined(__s390__)
1048 case KVM_EXIT_S390_SIEIC:
1049 r = kvm->callbacks->s390_handle_intercept(kvm, vcpu,
1050 run);
1051 break;
1052 case KVM_EXIT_S390_RESET:
1053 r = kvm->callbacks->s390_handle_reset(kvm, vcpu, run);
1054 break;
1055 #endif
1056 default:
1057 if (kvm_arch_run(vcpu)) {
1058 fprintf(stderr, "unhandled vm exit: 0x%x\n",
1059 run->exit_reason);
1060 kvm_show_regs(vcpu);
1061 abort();
1062 }
1063 break;
1064 }
1065 }
1066 more:
1067 if (!r)
1068 goto again;
1069 return r;
1070 }
1071
1072 int kvm_inject_irq(kvm_vcpu_context_t vcpu, unsigned irq)
1073 {
1074 struct kvm_interrupt intr;
1075
1076 intr.irq = irq;
1077 return ioctl(vcpu->fd, KVM_INTERRUPT, &intr);
1078 }
1079
1080 #ifdef KVM_CAP_SET_GUEST_DEBUG
1081 int kvm_set_guest_debug(kvm_vcpu_context_t vcpu, struct kvm_guest_debug *dbg)
1082 {
1083 return ioctl(vcpu->fd, KVM_SET_GUEST_DEBUG, dbg);
1084 }
1085 #endif
1086
1087 int kvm_set_signal_mask(kvm_vcpu_context_t vcpu, const sigset_t *sigset)
1088 {
1089 struct kvm_signal_mask *sigmask;
1090 int r;
1091
1092 if (!sigset) {
1093 r = ioctl(vcpu->fd, KVM_SET_SIGNAL_MASK, NULL);
1094 if (r == -1)
1095 r = -errno;
1096 return r;
1097 }
1098 sigmask = malloc(sizeof(*sigmask) + sizeof(*sigset));
1099 if (!sigmask)
1100 return -ENOMEM;
1101
1102 sigmask->len = 8;
1103 memcpy(sigmask->sigset, sigset, sizeof(*sigset));
1104 r = ioctl(vcpu->fd, KVM_SET_SIGNAL_MASK, sigmask);
1105 if (r == -1)
1106 r = -errno;
1107 free(sigmask);
1108 return r;
1109 }
1110
1111 int kvm_irqchip_in_kernel(kvm_context_t kvm)
1112 {
1113 return kvm->irqchip_in_kernel;
1114 }
1115
1116 int kvm_pit_in_kernel(kvm_context_t kvm)
1117 {
1118 return kvm->pit_in_kernel;
1119 }
1120
1121 int kvm_has_sync_mmu(void)
1122 {
1123 int r = 0;
1124 #ifdef KVM_CAP_SYNC_MMU
1125 r = ioctl(kvm_context->fd, KVM_CHECK_EXTENSION, KVM_CAP_SYNC_MMU);
1126 #endif
1127 return r;
1128 }
1129
1130 int kvm_inject_nmi(kvm_vcpu_context_t vcpu)
1131 {
1132 #ifdef KVM_CAP_USER_NMI
1133 return ioctl(vcpu->fd, KVM_NMI);
1134 #else
1135 return -ENOSYS;
1136 #endif
1137 }
1138
1139 int kvm_init_coalesced_mmio(kvm_context_t kvm)
1140 {
1141 int r = 0;
1142 kvm->coalesced_mmio = 0;
1143 #ifdef KVM_CAP_COALESCED_MMIO
1144 r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_COALESCED_MMIO);
1145 if (r > 0) {
1146 kvm->coalesced_mmio = r;
1147 return 0;
1148 }
1149 #endif
1150 return r;
1151 }
1152
1153 int kvm_register_coalesced_mmio(kvm_context_t kvm, uint64_t addr, uint32_t size)
1154 {
1155 #ifdef KVM_CAP_COALESCED_MMIO
1156 struct kvm_coalesced_mmio_zone zone;
1157 int r;
1158
1159 if (kvm->coalesced_mmio) {
1160
1161 zone.addr = addr;
1162 zone.size = size;
1163
1164 r = ioctl(kvm->vm_fd, KVM_REGISTER_COALESCED_MMIO, &zone);
1165 if (r == -1) {
1166 perror("kvm_register_coalesced_mmio_zone");
1167 return -errno;
1168 }
1169 return 0;
1170 }
1171 #endif
1172 return -ENOSYS;
1173 }
1174
1175 int kvm_unregister_coalesced_mmio(kvm_context_t kvm, uint64_t addr, uint32_t size)
1176 {
1177 #ifdef KVM_CAP_COALESCED_MMIO
1178 struct kvm_coalesced_mmio_zone zone;
1179 int r;
1180
1181 if (kvm->coalesced_mmio) {
1182
1183 zone.addr = addr;
1184 zone.size = size;
1185
1186 r = ioctl(kvm->vm_fd, KVM_UNREGISTER_COALESCED_MMIO, &zone);
1187 if (r == -1) {
1188 perror("kvm_unregister_coalesced_mmio_zone");
1189 return -errno;
1190 }
1191 DPRINTF("Unregistered coalesced mmio region for %llx (%lx)\n", addr, size);
1192 return 0;
1193 }
1194 #endif
1195 return -ENOSYS;
1196 }
1197
1198 #ifdef KVM_CAP_DEVICE_ASSIGNMENT
1199 int kvm_assign_pci_device(kvm_context_t kvm,
1200 struct kvm_assigned_pci_dev *assigned_dev)
1201 {
1202 int ret;
1203
1204 ret = ioctl(kvm->vm_fd, KVM_ASSIGN_PCI_DEVICE, assigned_dev);
1205 if (ret < 0)
1206 return -errno;
1207
1208 return ret;
1209 }
1210
1211 static int kvm_old_assign_irq(kvm_context_t kvm,
1212 struct kvm_assigned_irq *assigned_irq)
1213 {
1214 int ret;
1215
1216 ret = ioctl(kvm->vm_fd, KVM_ASSIGN_IRQ, assigned_irq);
1217 if (ret < 0)
1218 return -errno;
1219
1220 return ret;
1221 }
1222
1223 #ifdef KVM_CAP_ASSIGN_DEV_IRQ
1224 int kvm_assign_irq(kvm_context_t kvm,
1225 struct kvm_assigned_irq *assigned_irq)
1226 {
1227 int ret;
1228
1229 ret = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_ASSIGN_DEV_IRQ);
1230 if (ret > 0) {
1231 ret = ioctl(kvm->vm_fd, KVM_ASSIGN_DEV_IRQ, assigned_irq);
1232 if (ret < 0)
1233 return -errno;
1234 return ret;
1235 }
1236
1237 return kvm_old_assign_irq(kvm, assigned_irq);
1238 }
1239
1240 int kvm_deassign_irq(kvm_context_t kvm,
1241 struct kvm_assigned_irq *assigned_irq)
1242 {
1243 int ret;
1244
1245 ret = ioctl(kvm->vm_fd, KVM_DEASSIGN_DEV_IRQ, assigned_irq);
1246 if (ret < 0)
1247 return -errno;
1248
1249 return ret;
1250 }
1251 #else
1252 int kvm_assign_irq(kvm_context_t kvm,
1253 struct kvm_assigned_irq *assigned_irq)
1254 {
1255 return kvm_old_assign_irq(kvm, assigned_irq);
1256 }
1257 #endif
1258 #endif
1259
1260 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
1261 int kvm_deassign_pci_device(kvm_context_t kvm,
1262 struct kvm_assigned_pci_dev *assigned_dev)
1263 {
1264 int ret;
1265
1266 ret = ioctl(kvm->vm_fd, KVM_DEASSIGN_PCI_DEVICE, assigned_dev);
1267 if (ret < 0)
1268 return -errno;
1269
1270 return ret;
1271 }
1272 #endif
1273
1274 int kvm_destroy_memory_region_works(kvm_context_t kvm)
1275 {
1276 int ret = 0;
1277
1278 #ifdef KVM_CAP_DESTROY_MEMORY_REGION_WORKS
1279 ret = ioctl(kvm->fd, KVM_CHECK_EXTENSION,
1280 KVM_CAP_DESTROY_MEMORY_REGION_WORKS);
1281 if (ret <= 0)
1282 ret = 0;
1283 #endif
1284 return ret;
1285 }
1286
1287 int kvm_reinject_control(kvm_context_t kvm, int pit_reinject)
1288 {
1289 #ifdef KVM_CAP_REINJECT_CONTROL
1290 int r;
1291 struct kvm_reinject_control control;
1292
1293 control.pit_reinject = pit_reinject;
1294
1295 r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_REINJECT_CONTROL);
1296 if (r > 0) {
1297 r = ioctl(kvm->vm_fd, KVM_REINJECT_CONTROL, &control);
1298 if (r == -1)
1299 return -errno;
1300 return r;
1301 }
1302 #endif
1303 return -ENOSYS;
1304 }
1305
1306 int kvm_has_gsi_routing(kvm_context_t kvm)
1307 {
1308 int r = 0;
1309
1310 #ifdef KVM_CAP_IRQ_ROUTING
1311 r = kvm_check_extension(kvm, KVM_CAP_IRQ_ROUTING);
1312 #endif
1313 return r;
1314 }
1315
1316 int kvm_get_gsi_count(kvm_context_t kvm)
1317 {
1318 #ifdef KVM_CAP_IRQ_ROUTING
1319 return kvm_check_extension(kvm, KVM_CAP_IRQ_ROUTING);
1320 #else
1321 return -EINVAL;
1322 #endif
1323 }
1324
1325 int kvm_clear_gsi_routes(kvm_context_t kvm)
1326 {
1327 #ifdef KVM_CAP_IRQ_ROUTING
1328 kvm->irq_routes->nr = 0;
1329 return 0;
1330 #else
1331 return -EINVAL;
1332 #endif
1333 }
1334
1335 int kvm_add_routing_entry(kvm_context_t kvm,
1336 struct kvm_irq_routing_entry* entry)
1337 {
1338 #ifdef KVM_CAP_IRQ_ROUTING
1339 struct kvm_irq_routing *z;
1340 struct kvm_irq_routing_entry *new;
1341 int n, size;
1342
1343 if (kvm->irq_routes->nr == kvm->nr_allocated_irq_routes) {
1344 n = kvm->nr_allocated_irq_routes * 2;
1345 if (n < 64)
1346 n = 64;
1347 size = sizeof(struct kvm_irq_routing);
1348 size += n * sizeof(*new);
1349 z = realloc(kvm->irq_routes, size);
1350 if (!z)
1351 return -ENOMEM;
1352 kvm->nr_allocated_irq_routes = n;
1353 kvm->irq_routes = z;
1354 }
1355 n = kvm->irq_routes->nr++;
1356 new = &kvm->irq_routes->entries[n];
1357 memset(new, 0, sizeof(*new));
1358 new->gsi = entry->gsi;
1359 new->type = entry->type;
1360 new->flags = entry->flags;
1361 new->u = entry->u;
1362
1363 set_gsi(kvm, entry->gsi);
1364
1365 return 0;
1366 #else
1367 return -ENOSYS;
1368 #endif
1369 }
1370
1371 int kvm_add_irq_route(kvm_context_t kvm, int gsi, int irqchip, int pin)
1372 {
1373 #ifdef KVM_CAP_IRQ_ROUTING
1374 struct kvm_irq_routing_entry e;
1375
1376 e.gsi = gsi;
1377 e.type = KVM_IRQ_ROUTING_IRQCHIP;
1378 e.flags = 0;
1379 e.u.irqchip.irqchip = irqchip;
1380 e.u.irqchip.pin = pin;
1381 return kvm_add_routing_entry(kvm, &e);
1382 #else
1383 return -ENOSYS;
1384 #endif
1385 }
1386
1387 int kvm_del_routing_entry(kvm_context_t kvm,
1388 struct kvm_irq_routing_entry* entry)
1389 {
1390 #ifdef KVM_CAP_IRQ_ROUTING
1391 struct kvm_irq_routing_entry *e, *p;
1392 int i, gsi, found = 0;
1393
1394 gsi = entry->gsi;
1395
1396 for (i = 0; i < kvm->irq_routes->nr; ++i) {
1397 e = &kvm->irq_routes->entries[i];
1398 if (e->type == entry->type
1399 && e->gsi == gsi) {
1400 switch (e->type)
1401 {
1402 case KVM_IRQ_ROUTING_IRQCHIP: {
1403 if (e->u.irqchip.irqchip ==
1404 entry->u.irqchip.irqchip
1405 && e->u.irqchip.pin ==
1406 entry->u.irqchip.pin) {
1407 p = &kvm->irq_routes->
1408 entries[--kvm->irq_routes->nr];
1409 *e = *p;
1410 found = 1;
1411 }
1412 break;
1413 }
1414 case KVM_IRQ_ROUTING_MSI: {
1415 if (e->u.msi.address_lo ==
1416 entry->u.msi.address_lo
1417 && e->u.msi.address_hi ==
1418 entry->u.msi.address_hi
1419 && e->u.msi.data == entry->u.msi.data) {
1420 p = &kvm->irq_routes->
1421 entries[--kvm->irq_routes->nr];
1422 *e = *p;
1423 found = 1;
1424 }
1425 break;
1426 }
1427 default:
1428 break;
1429 }
1430 if (found) {
1431 /* If there are no other users of this GSI
1432 * mark it available in the bitmap */
1433 for (i = 0; i < kvm->irq_routes->nr; i++) {
1434 e = &kvm->irq_routes->entries[i];
1435 if (e->gsi == gsi)
1436 break;
1437 }
1438 if (i == kvm->irq_routes->nr)
1439 clear_gsi(kvm, gsi);
1440
1441 return 0;
1442 }
1443 }
1444 }
1445 return -ESRCH;
1446 #else
1447 return -ENOSYS;
1448 #endif
1449 }
1450
1451 int kvm_del_irq_route(kvm_context_t kvm, int gsi, int irqchip, int pin)
1452 {
1453 #ifdef KVM_CAP_IRQ_ROUTING
1454 struct kvm_irq_routing_entry e;
1455
1456 e.gsi = gsi;
1457 e.type = KVM_IRQ_ROUTING_IRQCHIP;
1458 e.flags = 0;
1459 e.u.irqchip.irqchip = irqchip;
1460 e.u.irqchip.pin = pin;
1461 return kvm_del_routing_entry(kvm, &e);
1462 #else
1463 return -ENOSYS;
1464 #endif
1465 }
1466
1467 int kvm_commit_irq_routes(kvm_context_t kvm)
1468 {
1469 #ifdef KVM_CAP_IRQ_ROUTING
1470 int r;
1471
1472 kvm->irq_routes->flags = 0;
1473 r = ioctl(kvm->vm_fd, KVM_SET_GSI_ROUTING, kvm->irq_routes);
1474 if (r == -1)
1475 r = -errno;
1476 return r;
1477 #else
1478 return -ENOSYS;
1479 #endif
1480 }
1481
1482 int kvm_get_irq_route_gsi(kvm_context_t kvm)
1483 {
1484 int i, bit;
1485 uint32_t *buf = kvm->used_gsi_bitmap;
1486
1487 /* Return the lowest unused GSI in the bitmap */
1488 for (i = 0; i < kvm->max_gsi / 32; i++) {
1489 bit = ffs(~buf[i]);
1490 if (!bit)
1491 continue;
1492
1493 return bit - 1 + i * 32;
1494 }
1495
1496 return -ENOSPC;
1497 }
1498
1499 #ifdef KVM_CAP_DEVICE_MSIX
1500 int kvm_assign_set_msix_nr(kvm_context_t kvm,
1501 struct kvm_assigned_msix_nr *msix_nr)
1502 {
1503 int ret;
1504
1505 ret = ioctl(kvm->vm_fd, KVM_ASSIGN_SET_MSIX_NR, msix_nr);
1506 if (ret < 0)
1507 return -errno;
1508
1509 return ret;
1510 }
1511
1512 int kvm_assign_set_msix_entry(kvm_context_t kvm,
1513 struct kvm_assigned_msix_entry *entry)
1514 {
1515 int ret;
1516
1517 ret = ioctl(kvm->vm_fd, KVM_ASSIGN_SET_MSIX_ENTRY, entry);
1518 if (ret < 0)
1519 return -errno;
1520
1521 return ret;
1522 }
1523 #endif
1524
1525 #if defined(KVM_CAP_IRQFD) && defined(CONFIG_eventfd)
1526
1527 #include <sys/eventfd.h>
1528
1529 static int _kvm_irqfd(kvm_context_t kvm, int fd, int gsi, int flags)
1530 {
1531 int r;
1532 struct kvm_irqfd data = {
1533 .fd = fd,
1534 .gsi = gsi,
1535 .flags = flags,
1536 };
1537
1538 r = ioctl(kvm->vm_fd, KVM_IRQFD, &data);
1539 if (r == -1)
1540 r = -errno;
1541 return r;
1542 }
1543
1544 int kvm_irqfd(kvm_context_t kvm, int gsi, int flags)
1545 {
1546 int r;
1547 int fd;
1548
1549 if (!kvm_check_extension(kvm, KVM_CAP_IRQFD))
1550 return -ENOENT;
1551
1552 fd = eventfd(0, 0);
1553 if (fd < 0)
1554 return -errno;
1555
1556 r = _kvm_irqfd(kvm, fd, gsi, 0);
1557 if (r < 0) {
1558 close(fd);
1559 return -errno;
1560 }
1561
1562 return fd;
1563 }
1564
1565 #else /* KVM_CAP_IRQFD */
1566
1567 int kvm_irqfd(kvm_context_t kvm, int gsi, int flags)
1568 {
1569 return -ENOSYS;
1570 }
1571
1572 #endif /* KVM_CAP_IRQFD */
1573 static inline unsigned long kvm_get_thread_id(void)
1574 {
1575 return syscall(SYS_gettid);
1576 }
1577
1578 static void qemu_cond_wait(pthread_cond_t *cond)
1579 {
1580 CPUState *env = cpu_single_env;
1581 static const struct timespec ts = {
1582 .tv_sec = 0,
1583 .tv_nsec = 100000,
1584 };
1585
1586 pthread_cond_timedwait(cond, &qemu_mutex, &ts);
1587 cpu_single_env = env;
1588 }
1589
1590 static void sig_ipi_handler(int n)
1591 {
1592 }
1593
1594 static void on_vcpu(CPUState *env, void (*func)(void *data), void *data)
1595 {
1596 struct qemu_work_item wi;
1597
1598 if (env == current_env) {
1599 func(data);
1600 return;
1601 }
1602
1603 wi.func = func;
1604 wi.data = data;
1605 if (!env->kvm_cpu_state.queued_work_first)
1606 env->kvm_cpu_state.queued_work_first = &wi;
1607 else
1608 env->kvm_cpu_state.queued_work_last->next = &wi;
1609 env->kvm_cpu_state.queued_work_last = &wi;
1610 wi.next = NULL;
1611 wi.done = false;
1612
1613 pthread_kill(env->kvm_cpu_state.thread, SIG_IPI);
1614 while (!wi.done)
1615 qemu_cond_wait(&qemu_work_cond);
1616 }
1617
1618 static void inject_interrupt(void *data)
1619 {
1620 cpu_interrupt(current_env, (long)data);
1621 }
1622
1623 void kvm_inject_interrupt(CPUState *env, int mask)
1624 {
1625 on_vcpu(env, inject_interrupt, (void *)(long)mask);
1626 }
1627
1628 void kvm_update_interrupt_request(CPUState *env)
1629 {
1630 int signal = 0;
1631
1632 if (env) {
1633 if (!current_env || !current_env->kvm_cpu_state.created)
1634 signal = 1;
1635 /*
1636 * Testing for created here is really redundant
1637 */
1638 if (current_env && current_env->kvm_cpu_state.created &&
1639 env != current_env && !env->kvm_cpu_state.signalled)
1640 signal = 1;
1641
1642 if (signal) {
1643 env->kvm_cpu_state.signalled = 1;
1644 if (env->kvm_cpu_state.thread)
1645 pthread_kill(env->kvm_cpu_state.thread, SIG_IPI);
1646 }
1647 }
1648 }
1649
1650 void kvm_update_after_sipi(CPUState *env)
1651 {
1652 env->kvm_cpu_state.sipi_needed = 1;
1653 kvm_update_interrupt_request(env);
1654 }
1655
1656 void kvm_apic_init(CPUState *env)
1657 {
1658 if (env->cpu_index != 0)
1659 env->kvm_cpu_state.init = 1;
1660 kvm_update_interrupt_request(env);
1661 }
1662
1663 #include <signal.h>
1664
1665 static int kvm_try_push_interrupts(void *opaque)
1666 {
1667 return kvm_arch_try_push_interrupts(opaque);
1668 }
1669
1670 static void kvm_post_run(void *opaque, void *data)
1671 {
1672 CPUState *env = (CPUState *)data;
1673
1674 pthread_mutex_lock(&qemu_mutex);
1675 kvm_arch_post_kvm_run(opaque, env);
1676 }
1677
1678 static int kvm_pre_run(void *opaque, void *data)
1679 {
1680 CPUState *env = (CPUState *)data;
1681
1682 kvm_arch_pre_kvm_run(opaque, env);
1683
1684 pthread_mutex_unlock(&qemu_mutex);
1685 return 0;
1686 }
1687
1688 static void kvm_do_load_registers(void *_env)
1689 {
1690 CPUState *env = _env;
1691
1692 kvm_arch_load_regs(env);
1693 }
1694
1695 void kvm_load_registers(CPUState *env)
1696 {
1697 if (kvm_enabled() && qemu_system_ready)
1698 on_vcpu(env, kvm_do_load_registers, env);
1699 }
1700
1701 static void kvm_do_save_registers(void *_env)
1702 {
1703 CPUState *env = _env;
1704
1705 kvm_arch_save_regs(env);
1706 }
1707
1708 void kvm_save_registers(CPUState *env)
1709 {
1710 if (kvm_enabled())
1711 on_vcpu(env, kvm_do_save_registers, env);
1712 }
1713
1714 static void kvm_do_load_mpstate(void *_env)
1715 {
1716 CPUState *env = _env;
1717
1718 kvm_arch_load_mpstate(env);
1719 }
1720
1721 void kvm_load_mpstate(CPUState *env)
1722 {
1723 if (kvm_enabled() && qemu_system_ready)
1724 on_vcpu(env, kvm_do_load_mpstate, env);
1725 }
1726
1727 static void kvm_do_save_mpstate(void *_env)
1728 {
1729 CPUState *env = _env;
1730
1731 kvm_arch_save_mpstate(env);
1732 env->halted = (env->mp_state == KVM_MP_STATE_HALTED);
1733 }
1734
1735 void kvm_save_mpstate(CPUState *env)
1736 {
1737 if (kvm_enabled())
1738 on_vcpu(env, kvm_do_save_mpstate, env);
1739 }
1740
1741 int kvm_cpu_exec(CPUState *env)
1742 {
1743 int r;
1744
1745 r = kvm_run(env->kvm_cpu_state.vcpu_ctx, env);
1746 if (r < 0) {
1747 printf("kvm_run returned %d\n", r);
1748 vm_stop(0);
1749 }
1750
1751 return 0;
1752 }
1753
1754 static int is_cpu_stopped(CPUState *env)
1755 {
1756 return !vm_running || env->kvm_cpu_state.stopped;
1757 }
1758
1759 static void flush_queued_work(CPUState *env)
1760 {
1761 struct qemu_work_item *wi;
1762
1763 if (!env->kvm_cpu_state.queued_work_first)
1764 return;
1765
1766 while ((wi = env->kvm_cpu_state.queued_work_first)) {
1767 env->kvm_cpu_state.queued_work_first = wi->next;
1768 wi->func(wi->data);
1769 wi->done = true;
1770 }
1771 env->kvm_cpu_state.queued_work_last = NULL;
1772 pthread_cond_broadcast(&qemu_work_cond);
1773 }
1774
1775 static void kvm_main_loop_wait(CPUState *env, int timeout)
1776 {
1777 struct timespec ts;
1778 int r, e;
1779 siginfo_t siginfo;
1780 sigset_t waitset;
1781
1782 pthread_mutex_unlock(&qemu_mutex);
1783
1784 ts.tv_sec = timeout / 1000;
1785 ts.tv_nsec = (timeout % 1000) * 1000000;
1786 sigemptyset(&waitset);
1787 sigaddset(&waitset, SIG_IPI);
1788
1789 r = sigtimedwait(&waitset, &siginfo, &ts);
1790 e = errno;
1791
1792 pthread_mutex_lock(&qemu_mutex);
1793
1794 if (r == -1 && !(e == EAGAIN || e == EINTR)) {
1795 printf("sigtimedwait: %s\n", strerror(e));
1796 exit(1);
1797 }
1798
1799 cpu_single_env = env;
1800 flush_queued_work(env);
1801
1802 if (env->kvm_cpu_state.stop) {
1803 env->kvm_cpu_state.stop = 0;
1804 env->kvm_cpu_state.stopped = 1;
1805 pthread_cond_signal(&qemu_pause_cond);
1806 }
1807
1808 env->kvm_cpu_state.signalled = 0;
1809 }
1810
1811 static int all_threads_paused(void)
1812 {
1813 CPUState *penv = first_cpu;
1814
1815 while (penv) {
1816 if (penv->kvm_cpu_state.stop)
1817 return 0;
1818 penv = (CPUState *)penv->next_cpu;
1819 }
1820
1821 return 1;
1822 }
1823
1824 static void pause_all_threads(void)
1825 {
1826 CPUState *penv = first_cpu;
1827
1828 while (penv) {
1829 if (penv != cpu_single_env) {
1830 penv->kvm_cpu_state.stop = 1;
1831 pthread_kill(penv->kvm_cpu_state.thread, SIG_IPI);
1832 } else {
1833 penv->kvm_cpu_state.stop = 0;
1834 penv->kvm_cpu_state.stopped = 1;
1835 cpu_exit(penv);
1836 }
1837 penv = (CPUState *)penv->next_cpu;
1838 }
1839
1840 while (!all_threads_paused())
1841 qemu_cond_wait(&qemu_pause_cond);
1842 }
1843
1844 static void resume_all_threads(void)
1845 {
1846 CPUState *penv = first_cpu;
1847
1848 assert(!cpu_single_env);
1849
1850 while (penv) {
1851 penv->kvm_cpu_state.stop = 0;
1852 penv->kvm_cpu_state.stopped = 0;
1853 pthread_kill(penv->kvm_cpu_state.thread, SIG_IPI);
1854 penv = (CPUState *)penv->next_cpu;
1855 }
1856 }
1857
1858 static void kvm_vm_state_change_handler(void *context, int running, int reason)
1859 {
1860 if (running)
1861 resume_all_threads();
1862 else
1863 pause_all_threads();
1864 }
1865
1866 static void update_regs_for_sipi(CPUState *env)
1867 {
1868 kvm_arch_update_regs_for_sipi(env);
1869 env->kvm_cpu_state.sipi_needed = 0;
1870 }
1871
1872 static void update_regs_for_init(CPUState *env)
1873 {
1874 #ifdef TARGET_I386
1875 SegmentCache cs = env->segs[R_CS];
1876 #endif
1877
1878 cpu_reset(env);
1879 /* cpu_reset() clears env->halted, cpu should be halted after init */
1880 env->halted = 1;
1881
1882 #ifdef TARGET_I386
1883 /* restore SIPI vector */
1884 if(env->kvm_cpu_state.sipi_needed)
1885 env->segs[R_CS] = cs;
1886 #endif
1887
1888 env->kvm_cpu_state.init = 0;
1889 kvm_arch_load_regs(env);
1890 }
1891
1892 static void setup_kernel_sigmask(CPUState *env)
1893 {
1894 sigset_t set;
1895
1896 sigemptyset(&set);
1897 sigaddset(&set, SIGUSR2);
1898 sigaddset(&set, SIGIO);
1899 sigaddset(&set, SIGALRM);
1900 sigprocmask(SIG_BLOCK, &set, NULL);
1901
1902 sigprocmask(SIG_BLOCK, NULL, &set);
1903 sigdelset(&set, SIG_IPI);
1904
1905 kvm_set_signal_mask(env->kvm_cpu_state.vcpu_ctx, &set);
1906 }
1907
1908 static void qemu_kvm_system_reset(void)
1909 {
1910 CPUState *penv = first_cpu;
1911
1912 pause_all_threads();
1913
1914 qemu_system_reset();
1915
1916 while (penv) {
1917 kvm_arch_cpu_reset(penv);
1918 penv = (CPUState *)penv->next_cpu;
1919 }
1920
1921 resume_all_threads();
1922 }
1923
1924 static void process_irqchip_events(CPUState *env)
1925 {
1926 if (env->kvm_cpu_state.init)
1927 update_regs_for_init(env);
1928 if (env->kvm_cpu_state.sipi_needed)
1929 update_regs_for_sipi(env);
1930 if (kvm_arch_has_work(env))
1931 env->halted = 0;
1932 }
1933
1934 static int kvm_main_loop_cpu(CPUState *env)
1935 {
1936 setup_kernel_sigmask(env);
1937
1938 pthread_mutex_lock(&qemu_mutex);
1939
1940 kvm_qemu_init_env(env);
1941 #ifdef TARGET_I386
1942 kvm_tpr_vcpu_start(env);
1943 #endif
1944
1945 cpu_single_env = env;
1946 kvm_arch_load_regs(env);
1947
1948 while (1) {
1949 int run_cpu = !is_cpu_stopped(env);
1950 if (run_cpu && !kvm_irqchip_in_kernel(kvm_context)) {
1951 process_irqchip_events(env);
1952 run_cpu = !env->halted;
1953 }
1954 if (run_cpu) {
1955 kvm_main_loop_wait(env, 0);
1956 kvm_cpu_exec(env);
1957 } else {
1958 kvm_main_loop_wait(env, 1000);
1959 }
1960 }
1961 pthread_mutex_unlock(&qemu_mutex);
1962 return 0;
1963 }
1964
1965 static void *ap_main_loop(void *_env)
1966 {
1967 CPUState *env = _env;
1968 sigset_t signals;
1969 struct ioperm_data *data = NULL;
1970
1971 current_env = env;
1972 env->thread_id = kvm_get_thread_id();
1973 sigfillset(&signals);
1974 sigprocmask(SIG_BLOCK, &signals, NULL);
1975 env->kvm_cpu_state.vcpu_ctx = kvm_create_vcpu(kvm_context, env->cpu_index);
1976
1977 #ifdef USE_KVM_DEVICE_ASSIGNMENT
1978 /* do ioperm for io ports of assigned devices */
1979 LIST_FOREACH(data, &ioperm_head, entries)
1980 on_vcpu(env, kvm_arch_do_ioperm, data);
1981 #endif
1982
1983 /* signal VCPU creation */
1984 pthread_mutex_lock(&qemu_mutex);
1985 current_env->kvm_cpu_state.created = 1;
1986 pthread_cond_signal(&qemu_vcpu_cond);
1987
1988 /* and wait for machine initialization */
1989 while (!qemu_system_ready)
1990 qemu_cond_wait(&qemu_system_cond);
1991 pthread_mutex_unlock(&qemu_mutex);
1992
1993 kvm_main_loop_cpu(env);
1994 return NULL;
1995 }
1996
1997 void kvm_init_vcpu(CPUState *env)
1998 {
1999 pthread_create(&env->kvm_cpu_state.thread, NULL, ap_main_loop, env);
2000
2001 while (env->kvm_cpu_state.created == 0)
2002 qemu_cond_wait(&qemu_vcpu_cond);
2003 }
2004
2005 int kvm_vcpu_inited(CPUState *env)
2006 {
2007 return env->kvm_cpu_state.created;
2008 }
2009
2010 int kvm_init_ap(void)
2011 {
2012 #ifdef TARGET_I386
2013 kvm_tpr_opt_setup();
2014 #endif
2015 qemu_add_vm_change_state_handler(kvm_vm_state_change_handler, NULL);
2016
2017 signal(SIG_IPI, sig_ipi_handler);
2018 return 0;
2019 }
2020
2021 void qemu_kvm_notify_work(void)
2022 {
2023 uint64_t value = 1;
2024 char buffer[8];
2025 size_t offset = 0;
2026
2027 if (io_thread_fd == -1)
2028 return;
2029
2030 memcpy(buffer, &value, sizeof(value));
2031
2032 while (offset < 8) {
2033 ssize_t len;
2034
2035 len = write(io_thread_fd, buffer + offset, 8 - offset);
2036 if (len == -1 && errno == EINTR)
2037 continue;
2038
2039 if (len <= 0)
2040 break;
2041
2042 offset += len;
2043 }
2044
2045 if (offset != 8)
2046 fprintf(stderr, "failed to notify io thread\n");
2047 }
2048
2049 /* If we have signalfd, we mask out the signals we want to handle and then
2050 * use signalfd to listen for them. We rely on whatever the current signal
2051 * handler is to dispatch the signals when we receive them.
2052 */
2053
2054 static void sigfd_handler(void *opaque)
2055 {
2056 int fd = (unsigned long)opaque;
2057 struct qemu_signalfd_siginfo info;
2058 struct sigaction action;
2059 ssize_t len;
2060
2061 while (1) {
2062 do {
2063 len = read(fd, &info, sizeof(info));
2064 } while (len == -1 && errno == EINTR);
2065
2066 if (len == -1 && errno == EAGAIN)
2067 break;
2068
2069 if (len != sizeof(info)) {
2070 printf("read from sigfd returned %zd: %m\n", len);
2071 return;
2072 }
2073
2074 sigaction(info.ssi_signo, NULL, &action);
2075 if (action.sa_handler)
2076 action.sa_handler(info.ssi_signo);
2077
2078 }
2079 }
2080
2081 /* Used to break IO thread out of select */
2082 static void io_thread_wakeup(void *opaque)
2083 {
2084 int fd = (unsigned long)opaque;
2085 char buffer[8];
2086 size_t offset = 0;
2087
2088 while (offset < 8) {
2089 ssize_t len;
2090
2091 len = read(fd, buffer + offset, 8 - offset);
2092 if (len == -1 && errno == EINTR)
2093 continue;
2094
2095 if (len <= 0)
2096 break;
2097
2098 offset += len;
2099 }
2100 }
2101
2102 int kvm_main_loop(void)
2103 {
2104 int fds[2];
2105 sigset_t mask;
2106 int sigfd;
2107
2108 io_thread = pthread_self();
2109 qemu_system_ready = 1;
2110
2111 if (qemu_eventfd(fds) == -1) {
2112 fprintf(stderr, "failed to create eventfd\n");
2113 return -errno;
2114 }
2115
2116 qemu_set_fd_handler2(fds[0], NULL, io_thread_wakeup, NULL,
2117 (void *)(unsigned long)fds[0]);
2118
2119 io_thread_fd = fds[1];
2120
2121 sigemptyset(&mask);
2122 sigaddset(&mask, SIGIO);
2123 sigaddset(&mask, SIGALRM);
2124 sigprocmask(SIG_BLOCK, &mask, NULL);
2125
2126 sigfd = qemu_signalfd(&mask);
2127 if (sigfd == -1) {
2128 fprintf(stderr, "failed to create signalfd\n");
2129 return -errno;
2130 }
2131
2132 fcntl(sigfd, F_SETFL, O_NONBLOCK);
2133
2134 qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
2135 (void *)(unsigned long)sigfd);
2136
2137 pthread_cond_broadcast(&qemu_system_cond);
2138
2139 io_thread_sigfd = sigfd;
2140 cpu_single_env = NULL;
2141
2142 while (1) {
2143 main_loop_wait(1000);
2144 if (qemu_shutdown_requested()) {
2145 if (qemu_no_shutdown()) {
2146 vm_stop(0);
2147 } else
2148 break;
2149 } else if (qemu_powerdown_requested())
2150 qemu_system_powerdown();
2151 else if (qemu_reset_requested())
2152 qemu_kvm_system_reset();
2153 else if (kvm_debug_cpu_requested) {
2154 gdb_set_stop_cpu(kvm_debug_cpu_requested);
2155 vm_stop(EXCP_DEBUG);
2156 kvm_debug_cpu_requested = NULL;
2157 }
2158 }
2159
2160 pause_all_threads();
2161 pthread_mutex_unlock(&qemu_mutex);
2162
2163 return 0;
2164 }
2165
2166 #ifdef KVM_CAP_SET_GUEST_DEBUG
2167 static int kvm_debug(void *opaque, void *data,
2168 struct kvm_debug_exit_arch *arch_info)
2169 {
2170 int handle = kvm_arch_debug(arch_info);
2171 CPUState *env = data;
2172
2173 if (handle) {
2174 kvm_debug_cpu_requested = env;
2175 env->kvm_cpu_state.stopped = 1;
2176 }
2177 return handle;
2178 }
2179 #endif
2180
2181 static int kvm_inb(void *opaque, uint16_t addr, uint8_t *data)
2182 {
2183 *data = cpu_inb(0, addr);
2184 return 0;
2185 }
2186
2187 static int kvm_inw(void *opaque, uint16_t addr, uint16_t *data)
2188 {
2189 *data = cpu_inw(0, addr);
2190 return 0;
2191 }
2192
2193 static int kvm_inl(void *opaque, uint16_t addr, uint32_t *data)
2194 {
2195 *data = cpu_inl(0, addr);
2196 return 0;
2197 }
2198
2199 #define PM_IO_BASE 0xb000
2200
2201 static int kvm_outb(void *opaque, uint16_t addr, uint8_t data)
2202 {
2203 if (addr == 0xb2) {
2204 switch (data) {
2205 case 0: {
2206 cpu_outb(0, 0xb3, 0);
2207 break;
2208 }
2209 case 0xf0: {
2210 unsigned x;
2211
2212 /* enable acpi */
2213 x = cpu_inw(0, PM_IO_BASE + 4);
2214 x &= ~1;
2215 cpu_outw(0, PM_IO_BASE + 4, x);
2216 break;
2217 }
2218 case 0xf1: {
2219 unsigned x;
2220
2221 /* enable acpi */
2222 x = cpu_inw(0, PM_IO_BASE + 4);
2223 x |= 1;
2224 cpu_outw(0, PM_IO_BASE + 4, x);
2225 break;
2226 }
2227 default:
2228 break;
2229 }
2230 return 0;
2231 }
2232 cpu_outb(0, addr, data);
2233 return 0;
2234 }
2235
2236 static int kvm_outw(void *opaque, uint16_t addr, uint16_t data)
2237 {
2238 cpu_outw(0, addr, data);
2239 return 0;
2240 }
2241
2242 static int kvm_outl(void *opaque, uint16_t addr, uint32_t data)
2243 {
2244 cpu_outl(0, addr, data);
2245 return 0;
2246 }
2247
2248 static int kvm_mmio_read(void *opaque, uint64_t addr, uint8_t *data, int len)
2249 {
2250 cpu_physical_memory_rw(addr, data, len, 0);
2251 return 0;
2252 }
2253
2254 static int kvm_mmio_write(void *opaque, uint64_t addr, uint8_t *data, int len)
2255 {
2256 cpu_physical_memory_rw(addr, data, len, 1);
2257 return 0;
2258 }
2259
2260 static int kvm_io_window(void *opaque)
2261 {
2262 return 1;
2263 }
2264
2265
2266 static int kvm_halt(void *opaque, kvm_vcpu_context_t vcpu)
2267 {
2268 return kvm_arch_halt(opaque, vcpu);
2269 }
2270
2271 static int kvm_shutdown(void *opaque, void *data)
2272 {
2273 CPUState *env = (CPUState *)data;
2274
2275 /* stop the current vcpu from going back to guest mode */
2276 env->kvm_cpu_state.stopped = 1;
2277
2278 qemu_system_reset_request();
2279 return 1;
2280 }
2281
2282 static int handle_unhandled(kvm_context_t kvm, kvm_vcpu_context_t vcpu,
2283 uint64_t reason)
2284 {
2285 fprintf(stderr, "kvm: unhandled exit %"PRIx64"\n", reason);
2286 return -EINVAL;
2287 }
2288
2289 static struct kvm_callbacks qemu_kvm_ops = {
2290 #ifdef KVM_CAP_SET_GUEST_DEBUG
2291 .debug = kvm_debug,
2292 #endif
2293 .inb = kvm_inb,
2294 .inw = kvm_inw,
2295 .inl = kvm_inl,
2296 .outb = kvm_outb,
2297 .outw = kvm_outw,
2298 .outl = kvm_outl,
2299 .mmio_read = kvm_mmio_read,
2300 .mmio_write = kvm_mmio_write,
2301 .halt = kvm_halt,
2302 .shutdown = kvm_shutdown,
2303 .io_window = kvm_io_window,
2304 .try_push_interrupts = kvm_try_push_interrupts,
2305 #ifdef KVM_CAP_USER_NMI
2306 .push_nmi = kvm_arch_push_nmi,
2307 #endif
2308 .post_kvm_run = kvm_post_run,
2309 .pre_kvm_run = kvm_pre_run,
2310 #ifdef TARGET_I386
2311 .tpr_access = handle_tpr_access,
2312 #endif
2313 .unhandled = handle_unhandled,
2314 };
2315
2316 int kvm_qemu_init()
2317 {
2318 /* Try to initialize kvm */
2319 kvm_context = kvm_init(&qemu_kvm_ops, cpu_single_env);
2320 if (!kvm_context) {
2321 return -1;
2322 }
2323 pthread_mutex_lock(&qemu_mutex);
2324
2325 return 0;
2326 }
2327
2328 #ifdef TARGET_I386
2329 static int destroy_region_works = 0;
2330 #endif
2331
2332
2333 #if !defined(TARGET_I386)
2334 int kvm_arch_init_irq_routing(void)
2335 {
2336 return 0;
2337 }
2338 #endif
2339
2340 int kvm_qemu_create_context(void)
2341 {
2342 int r;
2343
2344 if (!kvm_irqchip) {
2345 kvm_disable_irqchip_creation(kvm_context);
2346 }
2347 if (!kvm_pit) {
2348 kvm_disable_pit_creation(kvm_context);
2349 }
2350 if (kvm_create(kvm_context, 0, NULL) < 0) {
2351 kvm_qemu_destroy();
2352 return -1;
2353 }
2354 r = kvm_arch_qemu_create_context();
2355 if(r <0)
2356 kvm_qemu_destroy();
2357 if (kvm_pit && !kvm_pit_reinject) {
2358 if (kvm_reinject_control(kvm_context, 0)) {
2359 fprintf(stderr, "failure to disable in-kernel PIT reinjection\n");
2360 return -1;
2361 }
2362 }
2363 #ifdef TARGET_I386
2364 destroy_region_works = kvm_destroy_memory_region_works(kvm_context);
2365 #endif
2366
2367 r = kvm_arch_init_irq_routing();
2368 if (r < 0) {
2369 return r;
2370 }
2371
2372 return 0;
2373 }
2374
2375 void kvm_qemu_destroy(void)
2376 {
2377 kvm_finalize(kvm_context);
2378 }
2379
2380 #ifdef TARGET_I386
2381 static int must_use_aliases_source(target_phys_addr_t addr)
2382 {
2383 if (destroy_region_works)
2384 return false;
2385 if (addr == 0xa0000 || addr == 0xa8000)
2386 return true;
2387 return false;
2388 }
2389
2390 static int must_use_aliases_target(target_phys_addr_t addr)
2391 {
2392 if (destroy_region_works)
2393 return false;
2394 if (addr >= 0xe0000000 && addr < 0x100000000ull)
2395 return true;
2396 return false;
2397 }
2398
2399 static struct mapping {
2400 target_phys_addr_t phys;
2401 ram_addr_t ram;
2402 ram_addr_t len;
2403 } mappings[50];
2404 static int nr_mappings;
2405
2406 static struct mapping *find_ram_mapping(ram_addr_t ram_addr)
2407 {
2408 struct mapping *p;
2409
2410 for (p = mappings; p < mappings + nr_mappings; ++p) {
2411 if (p->ram <= ram_addr && ram_addr < p->ram + p->len) {
2412 return p;
2413 }
2414 }
2415 return NULL;
2416 }
2417
2418 static struct mapping *find_mapping(target_phys_addr_t start_addr)
2419 {
2420 struct mapping *p;
2421
2422 for (p = mappings; p < mappings + nr_mappings; ++p) {
2423 if (p->phys <= start_addr && start_addr < p->phys + p->len) {
2424 return p;
2425 }
2426 }
2427 return NULL;
2428 }
2429
2430 static void drop_mapping(target_phys_addr_t start_addr)
2431 {
2432 struct mapping *p = find_mapping(start_addr);
2433
2434 if (p)
2435 *p = mappings[--nr_mappings];
2436 }
2437 #endif
2438
2439 void kvm_cpu_register_physical_memory(target_phys_addr_t start_addr,
2440 unsigned long size,
2441 unsigned long phys_offset)
2442 {
2443 int r = 0;
2444 unsigned long area_flags;
2445 #ifdef TARGET_I386
2446 struct mapping *p;
2447 #endif
2448
2449 if (start_addr + size > phys_ram_size) {
2450 phys_ram_size = start_addr + size;
2451 }
2452
2453 phys_offset &= ~IO_MEM_ROM;
2454 area_flags = phys_offset & ~TARGET_PAGE_MASK;
2455
2456 if (area_flags != IO_MEM_RAM) {
2457 #ifdef TARGET_I386
2458 if (must_use_aliases_source(start_addr)) {
2459 kvm_destroy_memory_alias(kvm_context, start_addr);
2460 return;
2461 }
2462 if (must_use_aliases_target(start_addr))
2463 return;
2464 #endif
2465 while (size > 0) {
2466 p = find_mapping(start_addr);
2467 if (p) {
2468 kvm_unregister_memory_area(kvm_context, p->phys, p->len);
2469 drop_mapping(p->phys);
2470 }
2471 start_addr += TARGET_PAGE_SIZE;
2472 if (size > TARGET_PAGE_SIZE) {
2473 size -= TARGET_PAGE_SIZE;
2474 } else {
2475 size = 0;
2476 }
2477 }
2478 return;
2479 }
2480
2481 r = kvm_is_containing_region(kvm_context, start_addr, size);
2482 if (r)
2483 return;
2484
2485 if (area_flags >= TLB_MMIO)
2486 return;
2487
2488 #ifdef TARGET_I386
2489 if (must_use_aliases_source(start_addr)) {
2490 p = find_ram_mapping(phys_offset);
2491 if (p) {
2492 kvm_create_memory_alias(kvm_context, start_addr, size,
2493 p->phys + (phys_offset - p->ram));
2494 }
2495 return;
2496 }
2497 #endif
2498
2499 r = kvm_register_phys_mem(kvm_context, start_addr,
2500 qemu_get_ram_ptr(phys_offset),
2501 size, 0);
2502 if (r < 0) {
2503 printf("kvm_cpu_register_physical_memory: failed\n");
2504 exit(1);
2505 }
2506
2507 #ifdef TARGET_I386
2508 drop_mapping(start_addr);
2509 p = &mappings[nr_mappings++];
2510 p->phys = start_addr;
2511 p->ram = phys_offset;
2512 p->len = size;
2513 #endif
2514
2515 return;
2516 }
2517
2518 void kvm_cpu_unregister_physical_memory(target_phys_addr_t start_addr,
2519 target_phys_addr_t size,
2520 unsigned long phys_offset)
2521 {
2522 kvm_unregister_memory_area(kvm_context, start_addr, size);
2523 }
2524
2525 int kvm_setup_guest_memory(void *area, unsigned long size)
2526 {
2527 int ret = 0;
2528
2529 #ifdef MADV_DONTFORK
2530 if (kvm_enabled() && !kvm_has_sync_mmu())
2531 ret = madvise(area, size, MADV_DONTFORK);
2532 #endif
2533
2534 if (ret)
2535 perror ("madvise");
2536
2537 return ret;
2538 }
2539
2540 int kvm_qemu_check_extension(int ext)
2541 {
2542 return kvm_check_extension(kvm_context, ext);
2543 }
2544
2545 int kvm_qemu_init_env(CPUState *cenv)
2546 {
2547 return kvm_arch_qemu_init_env(cenv);
2548 }
2549
2550 #ifdef KVM_CAP_SET_GUEST_DEBUG
2551 struct kvm_sw_breakpoint_head kvm_sw_breakpoints =
2552 TAILQ_HEAD_INITIALIZER(kvm_sw_breakpoints);
2553
2554 struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(target_ulong pc)
2555 {
2556 struct kvm_sw_breakpoint *bp;
2557
2558 TAILQ_FOREACH(bp, &kvm_sw_breakpoints, entry) {
2559 if (bp->pc == pc)
2560 return bp;
2561 }
2562 return NULL;
2563 }
2564
2565 struct kvm_set_guest_debug_data {
2566 struct kvm_guest_debug dbg;
2567 int err;
2568 };
2569
2570 static void kvm_invoke_set_guest_debug(void *data)
2571 {
2572 struct kvm_set_guest_debug_data *dbg_data = data;
2573
2574 dbg_data->err = kvm_set_guest_debug(cpu_single_env->kvm_cpu_state.vcpu_ctx,
2575 &dbg_data->dbg);
2576 }
2577
2578 int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
2579 {
2580 struct kvm_set_guest_debug_data data;
2581
2582 data.dbg.control = 0;
2583 if (env->singlestep_enabled)
2584 data.dbg.control = KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
2585
2586 kvm_arch_update_guest_debug(env, &data.dbg);
2587 data.dbg.control |= reinject_trap;
2588
2589 on_vcpu(env, kvm_invoke_set_guest_debug, &data);
2590 return data.err;
2591 }
2592
2593 int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
2594 target_ulong len, int type)
2595 {
2596 struct kvm_sw_breakpoint *bp;
2597 CPUState *env;
2598 int err;
2599
2600 if (type == GDB_BREAKPOINT_SW) {
2601 bp = kvm_find_sw_breakpoint(addr);
2602 if (bp) {
2603 bp->use_count++;
2604 return 0;
2605 }
2606
2607 bp = qemu_malloc(sizeof(struct kvm_sw_breakpoint));
2608 if (!bp)
2609 return -ENOMEM;
2610
2611 bp->pc = addr;
2612 bp->use_count = 1;
2613 err = kvm_arch_insert_sw_breakpoint(current_env, bp);
2614 if (err) {
2615 free(bp);
2616 return err;
2617 }
2618
2619 TAILQ_INSERT_HEAD(&kvm_sw_breakpoints, bp, entry);
2620 } else {
2621 err = kvm_arch_insert_hw_breakpoint(addr, len, type);
2622 if (err)
2623 return err;
2624 }
2625
2626 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2627 err = kvm_update_guest_debug(env, 0);
2628 if (err)
2629 return err;
2630 }
2631 return 0;
2632 }
2633
2634 int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
2635 target_ulong len, int type)
2636 {
2637 struct kvm_sw_breakpoint *bp;
2638 CPUState *env;
2639 int err;
2640
2641 if (type == GDB_BREAKPOINT_SW) {
2642 bp = kvm_find_sw_breakpoint(addr);
2643 if (!bp)
2644 return -ENOENT;
2645
2646 if (bp->use_count > 1) {
2647 bp->use_count--;
2648 return 0;
2649 }
2650
2651 err = kvm_arch_remove_sw_breakpoint(current_env, bp);
2652 if (err)
2653 return err;
2654
2655 TAILQ_REMOVE(&kvm_sw_breakpoints, bp, entry);
2656 qemu_free(bp);
2657 } else {
2658 err = kvm_arch_remove_hw_breakpoint(addr, len, type);
2659 if (err)
2660 return err;
2661 }
2662
2663 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2664 err = kvm_update_guest_debug(env, 0);
2665 if (err)
2666 return err;
2667 }
2668 return 0;
2669 }
2670
2671 void kvm_remove_all_breakpoints(CPUState *current_env)
2672 {
2673 struct kvm_sw_breakpoint *bp, *next;
2674 CPUState *env;
2675
2676 TAILQ_FOREACH_SAFE(bp, &kvm_sw_breakpoints, entry, next) {
2677 if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
2678 /* Try harder to find a CPU that currently sees the breakpoint. */
2679 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2680 if (kvm_arch_remove_sw_breakpoint(env, bp) == 0)
2681 break;
2682 }
2683 }
2684 }
2685 kvm_arch_remove_all_hw_breakpoints();
2686
2687 for (env = first_cpu; env != NULL; env = env->next_cpu)
2688 kvm_update_guest_debug(env, 0);
2689 }
2690
2691 #else /* !KVM_CAP_SET_GUEST_DEBUG */
2692
2693 int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
2694 {
2695 return -EINVAL;
2696 }
2697
2698 int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
2699 target_ulong len, int type)
2700 {
2701 return -EINVAL;
2702 }
2703
2704 int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
2705 target_ulong len, int type)
2706 {
2707 return -EINVAL;
2708 }
2709
2710 void kvm_remove_all_breakpoints(CPUState *current_env)
2711 {
2712 }
2713 #endif /* !KVM_CAP_SET_GUEST_DEBUG */
2714
2715 /*
2716 * dirty pages logging
2717 */
2718 /* FIXME: use unsigned long pointer instead of unsigned char */
2719 unsigned char *kvm_dirty_bitmap = NULL;
2720 int kvm_physical_memory_set_dirty_tracking(int enable)
2721 {
2722 int r = 0;
2723
2724 if (!kvm_enabled())
2725 return 0;
2726
2727 if (enable) {
2728 if (!kvm_dirty_bitmap) {
2729 unsigned bitmap_size = BITMAP_SIZE(phys_ram_size);
2730 kvm_dirty_bitmap = qemu_malloc(bitmap_size);
2731 if (kvm_dirty_bitmap == NULL) {
2732 perror("Failed to allocate dirty pages bitmap");
2733 r=-1;
2734 }
2735 else {
2736 r = kvm_dirty_pages_log_enable_all(kvm_context);
2737 }
2738 }
2739 }
2740 else {
2741 if (kvm_dirty_bitmap) {
2742 r = kvm_dirty_pages_log_reset(kvm_context);
2743 qemu_free(kvm_dirty_bitmap);
2744 kvm_dirty_bitmap = NULL;
2745 }
2746 }
2747 return r;
2748 }
2749
2750 /* get kvm's dirty pages bitmap and update qemu's */
2751 static int kvm_get_dirty_pages_log_range(unsigned long start_addr,
2752 unsigned char *bitmap,
2753 unsigned long offset,
2754 unsigned long mem_size)
2755 {
2756 unsigned int i, j, n=0;
2757 unsigned char c;
2758 unsigned long page_number, addr, addr1;
2759 ram_addr_t ram_addr;
2760 unsigned int len = ((mem_size/TARGET_PAGE_SIZE) + 7) / 8;
2761
2762 /*
2763 * bitmap-traveling is faster than memory-traveling (for addr...)
2764 * especially when most of the memory is not dirty.
2765 */
2766 for (i=0; i<len; i++) {
2767 c = bitmap[i];
2768 while (c>0) {
2769 j = ffsl(c) - 1;
2770 c &= ~(1u<<j);
2771 page_number = i * 8 + j;
2772 addr1 = page_number * TARGET_PAGE_SIZE;
2773 addr = offset + addr1;
2774 ram_addr = cpu_get_physical_page_desc(addr);
2775 cpu_physical_memory_set_dirty(ram_addr);
2776 n++;
2777 }
2778 }
2779 return 0;
2780 }
2781 static int kvm_get_dirty_bitmap_cb(unsigned long start, unsigned long len,
2782 void *bitmap, void *opaque)
2783 {
2784 return kvm_get_dirty_pages_log_range(start, bitmap, start, len);
2785 }
2786
2787 /*
2788 * get kvm's dirty pages bitmap and update qemu's
2789 * we only care about physical ram, which resides in slots 0 and 3
2790 */
2791 int kvm_update_dirty_pages_log(void)
2792 {
2793 int r = 0;
2794
2795
2796 r = kvm_get_dirty_pages_range(kvm_context, 0, -1UL,
2797 NULL,
2798 kvm_get_dirty_bitmap_cb);
2799 return r;
2800 }
2801
2802 void kvm_qemu_log_memory(target_phys_addr_t start, target_phys_addr_t size,
2803 int log)
2804 {
2805 if (log)
2806 kvm_dirty_pages_log_enable_slot(kvm_context, start, size);
2807 else {
2808 #ifdef TARGET_I386
2809 if (must_use_aliases_target(start))
2810 return;
2811 #endif
2812 kvm_dirty_pages_log_disable_slot(kvm_context, start, size);
2813 }
2814 }
2815
2816 int kvm_get_phys_ram_page_bitmap(unsigned char *bitmap)
2817 {
2818 unsigned int bsize = BITMAP_SIZE(phys_ram_size);
2819 unsigned int brsize = BITMAP_SIZE(ram_size);
2820 unsigned int extra_pages = (phys_ram_size - ram_size) / TARGET_PAGE_SIZE;
2821 unsigned int extra_bytes = (extra_pages +7)/8;
2822 unsigned int hole_start = BITMAP_SIZE(0xa0000);
2823 unsigned int hole_end = BITMAP_SIZE(0xc0000);
2824
2825 memset(bitmap, 0xFF, brsize + extra_bytes);
2826 memset(bitmap + hole_start, 0, hole_end - hole_start);
2827 memset(bitmap + brsize + extra_bytes, 0, bsize - brsize - extra_bytes);
2828
2829 return 0;
2830 }
2831
2832 #ifdef KVM_CAP_IRQCHIP
2833
2834 int kvm_set_irq(int irq, int level, int *status)
2835 {
2836 return kvm_set_irq_level(kvm_context, irq, level, status);
2837 }
2838
2839 #endif
2840
2841 int qemu_kvm_get_dirty_pages(unsigned long phys_addr, void *buf)
2842 {
2843 return kvm_get_dirty_pages(kvm_context, phys_addr, buf);
2844 }
2845
2846 void *kvm_cpu_create_phys_mem(target_phys_addr_t start_addr,
2847 unsigned long size, int log, int writable)
2848 {
2849 return kvm_create_phys_mem(kvm_context, start_addr, size, log, writable);
2850 }
2851
2852 void kvm_cpu_destroy_phys_mem(target_phys_addr_t start_addr,
2853 unsigned long size)
2854 {
2855 kvm_destroy_phys_mem(kvm_context, start_addr, size);
2856 }
2857
2858 void kvm_mutex_unlock(void)
2859 {
2860 assert(!cpu_single_env);
2861 pthread_mutex_unlock(&qemu_mutex);
2862 }
2863
2864 void kvm_mutex_lock(void)
2865 {
2866 pthread_mutex_lock(&qemu_mutex);
2867 cpu_single_env = NULL;
2868 }
2869
2870 int qemu_kvm_register_coalesced_mmio(target_phys_addr_t addr, unsigned int size)
2871 {
2872 return kvm_register_coalesced_mmio(kvm_context, addr, size);
2873 }
2874
2875 int qemu_kvm_unregister_coalesced_mmio(target_phys_addr_t addr,
2876 unsigned int size)
2877 {
2878 return kvm_unregister_coalesced_mmio(kvm_context, addr, size);
2879 }
2880
2881 int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
2882 {
2883 return kvm_register_coalesced_mmio(kvm_context, start, size);
2884 }
2885
2886 int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
2887 {
2888 return kvm_unregister_coalesced_mmio(kvm_context, start, size);
2889 }
2890
2891 #ifdef USE_KVM_DEVICE_ASSIGNMENT
2892 void kvm_add_ioperm_data(struct ioperm_data *data)
2893 {
2894 LIST_INSERT_HEAD(&ioperm_head, data, entries);
2895 }
2896
2897 void kvm_remove_ioperm_data(unsigned long start_port, unsigned long num)
2898 {
2899 struct ioperm_data *data;
2900
2901 data = LIST_FIRST(&ioperm_head);
2902 while (data) {
2903 struct ioperm_data *next = LIST_NEXT(data, entries);
2904
2905 if (data->start_port == start_port && data->num == num) {
2906 LIST_REMOVE(data, entries);
2907 qemu_free(data);
2908 }
2909
2910 data = next;
2911 }
2912 }
2913
2914 void kvm_ioperm(CPUState *env, void *data)
2915 {
2916 if (kvm_enabled() && qemu_system_ready)
2917 on_vcpu(env, kvm_arch_do_ioperm, data);
2918 }
2919
2920 #endif
2921
2922 int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr, target_phys_addr_t end_addr)
2923 {
2924 #ifndef TARGET_IA64
2925
2926 #ifdef TARGET_I386
2927 if (must_use_aliases_source(start_addr))
2928 return 0;
2929 #endif
2930
2931 kvm_get_dirty_pages_range(kvm_context, start_addr, end_addr - start_addr,
2932 NULL, kvm_get_dirty_bitmap_cb);
2933 #endif
2934 return 0;
2935 }
2936
2937 int kvm_log_start(target_phys_addr_t phys_addr, target_phys_addr_t len)
2938 {
2939 #ifdef TARGET_I386
2940 if (must_use_aliases_source(phys_addr))
2941 return 0;
2942 #endif
2943
2944 #ifndef TARGET_IA64
2945 kvm_qemu_log_memory(phys_addr, len, 1);
2946 #endif
2947 return 0;
2948 }
2949
2950 int kvm_log_stop(target_phys_addr_t phys_addr, target_phys_addr_t len)
2951 {
2952 #ifdef TARGET_I386
2953 if (must_use_aliases_source(phys_addr))
2954 return 0;
2955 #endif
2956
2957 #ifndef TARGET_IA64
2958 kvm_qemu_log_memory(phys_addr, len, 0);
2959 #endif
2960 return 0;
2961 }
2962
2963 void qemu_kvm_cpu_stop(CPUState *env)
2964 {
2965 if (kvm_enabled())
2966 env->kvm_cpu_state.stopped = 1;
2967 }
Patches shipped by Fedora