?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Disable -Werror by default for kvm
[qemu-kvm/fedora.git] / qemu-kvm.c
blob4129fe205b909b3ca80e08ba0a9dda55f2292f22
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 *buf, 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
700 for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS; ++i) {
701 if ((slots[i].len && (uint64_t)slots[i].phys_addr >= phys_addr)
702 && ((uint64_t)slots[i].phys_addr + slots[i].len <= end_addr)) {
703 r = kvm_get_map(kvm, KVM_GET_DIRTY_LOG, i, buf);
704 if (r)
705 return r;
706 r = cb(slots[i].phys_addr, slots[i].len, buf, opaque);
707 if (r)
708 return r;
709 }
710 }
711 return 0;
712 }
713
714 #ifdef KVM_CAP_IRQCHIP
715
716 int kvm_set_irq_level(kvm_context_t kvm, int irq, int level, int *status)
717 {
718 struct kvm_irq_level event;
719 int r;
720
721 if (!kvm->irqchip_in_kernel)
722 return 0;
723 event.level = level;
724 event.irq = irq;
725 r = ioctl(kvm->vm_fd, kvm->irqchip_inject_ioctl, &event);
726 if (r == -1)
727 perror("kvm_set_irq_level");
728
729 if (status) {
730 #ifdef KVM_CAP_IRQ_INJECT_STATUS
731 *status = (kvm->irqchip_inject_ioctl == KVM_IRQ_LINE) ?
732 1 : event.status;
733 #else
734 *status = 1;
735 #endif
736 }
737
738 return 1;
739 }
740
741 int kvm_get_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip)
742 {
743 int r;
744
745 if (!kvm->irqchip_in_kernel)
746 return 0;
747 r = ioctl(kvm->vm_fd, KVM_GET_IRQCHIP, chip);
748 if (r == -1) {
749 r = -errno;
750 perror("kvm_get_irqchip\n");
751 }
752 return r;
753 }
754
755 int kvm_set_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip)
756 {
757 int r;
758
759 if (!kvm->irqchip_in_kernel)
760 return 0;
761 r = ioctl(kvm->vm_fd, KVM_SET_IRQCHIP, chip);
762 if (r == -1) {
763 r = -errno;
764 perror("kvm_set_irqchip\n");
765 }
766 return r;
767 }
768
769 #endif
770
771 static int handle_io(kvm_vcpu_context_t vcpu)
772 {
773 struct kvm_run *run = vcpu->run;
774 kvm_context_t kvm = vcpu->kvm;
775 uint16_t addr = run->io.port;
776 int r;
777 int i;
778 void *p = (void *)run + run->io.data_offset;
779
780 for (i = 0; i < run->io.count; ++i) {
781 switch (run->io.direction) {
782 case KVM_EXIT_IO_IN:
783 switch (run->io.size) {
784 case 1:
785 r = kvm->callbacks->inb(kvm->opaque, addr, p);
786 break;
787 case 2:
788 r = kvm->callbacks->inw(kvm->opaque, addr, p);
789 break;
790 case 4:
791 r = kvm->callbacks->inl(kvm->opaque, addr, p);
792 break;
793 default:
794 fprintf(stderr, "bad I/O size %d\n", run->io.size);
795 return -EMSGSIZE;
796 }
797 break;
798 case KVM_EXIT_IO_OUT:
799 switch (run->io.size) {
800 case 1:
801 r = kvm->callbacks->outb(kvm->opaque, addr,
802 *(uint8_t *)p);
803 break;
804 case 2:
805 r = kvm->callbacks->outw(kvm->opaque, addr,
806 *(uint16_t *)p);
807 break;
808 case 4:
809 r = kvm->callbacks->outl(kvm->opaque, addr,
810 *(uint32_t *)p);
811 break;
812 default:
813 fprintf(stderr, "bad I/O size %d\n", run->io.size);
814 return -EMSGSIZE;
815 }
816 break;
817 default:
818 fprintf(stderr, "bad I/O direction %d\n", run->io.direction);
819 return -EPROTO;
820 }
821
822 p += run->io.size;
823 }
824
825 return 0;
826 }
827
828 int handle_debug(kvm_vcpu_context_t vcpu, void *env)
829 {
830 #ifdef KVM_CAP_SET_GUEST_DEBUG
831 struct kvm_run *run = vcpu->run;
832 kvm_context_t kvm = vcpu->kvm;
833
834 return kvm->callbacks->debug(kvm->opaque, env, &run->debug.arch);
835 #else
836 return 0;
837 #endif
838 }
839
840 int kvm_get_regs(kvm_vcpu_context_t vcpu, struct kvm_regs *regs)
841 {
842 return ioctl(vcpu->fd, KVM_GET_REGS, regs);
843 }
844
845 int kvm_set_regs(kvm_vcpu_context_t vcpu, struct kvm_regs *regs)
846 {
847 return ioctl(vcpu->fd, KVM_SET_REGS, regs);
848 }
849
850 int kvm_get_fpu(kvm_vcpu_context_t vcpu, struct kvm_fpu *fpu)
851 {
852 return ioctl(vcpu->fd, KVM_GET_FPU, fpu);
853 }
854
855 int kvm_set_fpu(kvm_vcpu_context_t vcpu, struct kvm_fpu *fpu)
856 {
857 return ioctl(vcpu->fd, KVM_SET_FPU, fpu);
858 }
859
860 int kvm_get_sregs(kvm_vcpu_context_t vcpu, struct kvm_sregs *sregs)
861 {
862 return ioctl(vcpu->fd, KVM_GET_SREGS, sregs);
863 }
864
865 int kvm_set_sregs(kvm_vcpu_context_t vcpu, struct kvm_sregs *sregs)
866 {
867 return ioctl(vcpu->fd, KVM_SET_SREGS, sregs);
868 }
869
870 #ifdef KVM_CAP_MP_STATE
871 int kvm_get_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state)
872 {
873 int r;
874
875 r = ioctl(vcpu->kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_MP_STATE);
876 if (r > 0)
877 return ioctl(vcpu->fd, KVM_GET_MP_STATE, mp_state);
878 return -ENOSYS;
879 }
880
881 int kvm_set_mpstate(kvm_vcpu_context_t vcpu, struct kvm_mp_state *mp_state)
882 {
883 int r;
884
885 r = ioctl(vcpu->kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_MP_STATE);
886 if (r > 0)
887 return ioctl(vcpu->fd, KVM_SET_MP_STATE, mp_state);
888 return -ENOSYS;
889 }
890 #endif
891
892 static int handle_mmio(kvm_vcpu_context_t vcpu)
893 {
894 unsigned long addr = vcpu->run->mmio.phys_addr;
895 kvm_context_t kvm = vcpu->kvm;
896 struct kvm_run *kvm_run = vcpu->run;
897 void *data = kvm_run->mmio.data;
898
899 /* hack: Red Hat 7.1 generates these weird accesses. */
900 if ((addr > 0xa0000-4 && addr <= 0xa0000) && kvm_run->mmio.len == 3)
901 return 0;
902
903 if (kvm_run->mmio.is_write)
904 return kvm->callbacks->mmio_write(kvm->opaque, addr, data,
905 kvm_run->mmio.len);
906 else
907 return kvm->callbacks->mmio_read(kvm->opaque, addr, data,
908 kvm_run->mmio.len);
909 }
910
911 int handle_io_window(kvm_context_t kvm)
912 {
913 return kvm->callbacks->io_window(kvm->opaque);
914 }
915
916 int handle_halt(kvm_vcpu_context_t vcpu)
917 {
918 return vcpu->kvm->callbacks->halt(vcpu->kvm->opaque, vcpu);
919 }
920
921 int handle_shutdown(kvm_context_t kvm, void *env)
922 {
923 return kvm->callbacks->shutdown(kvm->opaque, env);
924 }
925
926 int try_push_interrupts(kvm_context_t kvm)
927 {
928 return kvm->callbacks->try_push_interrupts(kvm->opaque);
929 }
930
931 static inline void push_nmi(kvm_context_t kvm)
932 {
933 #ifdef KVM_CAP_USER_NMI
934 kvm->callbacks->push_nmi(kvm->opaque);
935 #endif /* KVM_CAP_USER_NMI */
936 }
937
938 void post_kvm_run(kvm_context_t kvm, void *env)
939 {
940 kvm->callbacks->post_kvm_run(kvm->opaque, env);
941 }
942
943 int pre_kvm_run(kvm_context_t kvm, void *env)
944 {
945 return kvm->callbacks->pre_kvm_run(kvm->opaque, env);
946 }
947
948 int kvm_get_interrupt_flag(kvm_vcpu_context_t vcpu)
949 {
950 return vcpu->run->if_flag;
951 }
952
953 int kvm_is_ready_for_interrupt_injection(kvm_vcpu_context_t vcpu)
954 {
955 return vcpu->run->ready_for_interrupt_injection;
956 }
957
958 int kvm_run(kvm_vcpu_context_t vcpu, void *env)
959 {
960 int r;
961 int fd = vcpu->fd;
962 struct kvm_run *run = vcpu->run;
963 kvm_context_t kvm = vcpu->kvm;
964
965 again:
966 push_nmi(kvm);
967 #if !defined(__s390__)
968 if (!kvm->irqchip_in_kernel)
969 run->request_interrupt_window = try_push_interrupts(kvm);
970 #endif
971 r = pre_kvm_run(kvm, env);
972 if (r)
973 return r;
974 r = ioctl(fd, KVM_RUN, 0);
975
976 if (r == -1 && errno != EINTR && errno != EAGAIN) {
977 r = -errno;
978 post_kvm_run(kvm, env);
979 fprintf(stderr, "kvm_run: %s\n", strerror(-r));
980 return r;
981 }
982
983 post_kvm_run(kvm, env);
984
985 #if defined(KVM_CAP_COALESCED_MMIO)
986 if (kvm->coalesced_mmio) {
987 struct kvm_coalesced_mmio_ring *ring = (void *)run +
988 kvm->coalesced_mmio * PAGE_SIZE;
989 while (ring->first != ring->last) {
990 kvm->callbacks->mmio_write(kvm->opaque,
991 ring->coalesced_mmio[ring->first].phys_addr,
992 &ring->coalesced_mmio[ring->first].data[0],
993 ring->coalesced_mmio[ring->first].len);
994 smp_wmb();
995 ring->first = (ring->first + 1) %
996 KVM_COALESCED_MMIO_MAX;
997 }
998 }
999 #endif
1000
1001 #if !defined(__s390__)
1002 if (r == -1) {
1003 r = handle_io_window(kvm);
1004 goto more;
1005 }
1006 #endif
1007 if (1) {
1008 switch (run->exit_reason) {
1009 case KVM_EXIT_UNKNOWN:
1010 r = kvm->callbacks->unhandled(kvm, vcpu,
1011 run->hw.hardware_exit_reason);
1012 break;
1013 case KVM_EXIT_FAIL_ENTRY:
1014 r = kvm->callbacks->unhandled(kvm, vcpu,
1015 run->fail_entry.hardware_entry_failure_reason);
1016 break;
1017 case KVM_EXIT_EXCEPTION:
1018 fprintf(stderr, "exception %d (%x)\n",
1019 run->ex.exception,
1020 run->ex.error_code);
1021 kvm_show_regs(vcpu);
1022 kvm_show_code(vcpu);
1023 abort();
1024 break;
1025 case KVM_EXIT_IO:
1026 r = handle_io(vcpu);
1027 break;
1028 case KVM_EXIT_DEBUG:
1029 r = handle_debug(vcpu, env);
1030 break;
1031 case KVM_EXIT_MMIO:
1032 r = handle_mmio(vcpu);
1033 break;
1034 case KVM_EXIT_HLT:
1035 r = handle_halt(vcpu);
1036 break;
1037 case KVM_EXIT_IRQ_WINDOW_OPEN:
1038 break;
1039 case KVM_EXIT_SHUTDOWN:
1040 r = handle_shutdown(kvm, env);
1041 break;
1042 #if defined(__s390__)
1043 case KVM_EXIT_S390_SIEIC:
1044 r = kvm->callbacks->s390_handle_intercept(kvm, vcpu,
1045 run);
1046 break;
1047 case KVM_EXIT_S390_RESET:
1048 r = kvm->callbacks->s390_handle_reset(kvm, vcpu, run);
1049 break;
1050 #endif
1051 default:
1052 if (kvm_arch_run(vcpu)) {
1053 fprintf(stderr, "unhandled vm exit: 0x%x\n",
1054 run->exit_reason);
1055 kvm_show_regs(vcpu);
1056 abort();
1057 }
1058 break;
1059 }
1060 }
1061 more:
1062 if (!r)
1063 goto again;
1064 return r;
1065 }
1066
1067 int kvm_inject_irq(kvm_vcpu_context_t vcpu, unsigned irq)
1068 {
1069 struct kvm_interrupt intr;
1070
1071 intr.irq = irq;
1072 return ioctl(vcpu->fd, KVM_INTERRUPT, &intr);
1073 }
1074
1075 #ifdef KVM_CAP_SET_GUEST_DEBUG
1076 int kvm_set_guest_debug(kvm_vcpu_context_t vcpu, struct kvm_guest_debug *dbg)
1077 {
1078 return ioctl(vcpu->fd, KVM_SET_GUEST_DEBUG, dbg);
1079 }
1080 #endif
1081
1082 int kvm_set_signal_mask(kvm_vcpu_context_t vcpu, const sigset_t *sigset)
1083 {
1084 struct kvm_signal_mask *sigmask;
1085 int r;
1086
1087 if (!sigset) {
1088 r = ioctl(vcpu->fd, KVM_SET_SIGNAL_MASK, NULL);
1089 if (r == -1)
1090 r = -errno;
1091 return r;
1092 }
1093 sigmask = malloc(sizeof(*sigmask) + sizeof(*sigset));
1094 if (!sigmask)
1095 return -ENOMEM;
1096
1097 sigmask->len = 8;
1098 memcpy(sigmask->sigset, sigset, sizeof(*sigset));
1099 r = ioctl(vcpu->fd, KVM_SET_SIGNAL_MASK, sigmask);
1100 if (r == -1)
1101 r = -errno;
1102 free(sigmask);
1103 return r;
1104 }
1105
1106 int kvm_irqchip_in_kernel(kvm_context_t kvm)
1107 {
1108 return kvm->irqchip_in_kernel;
1109 }
1110
1111 int kvm_pit_in_kernel(kvm_context_t kvm)
1112 {
1113 return kvm->pit_in_kernel;
1114 }
1115
1116 int kvm_has_sync_mmu(void)
1117 {
1118 int r = 0;
1119 #ifdef KVM_CAP_SYNC_MMU
1120 r = ioctl(kvm_context->fd, KVM_CHECK_EXTENSION, KVM_CAP_SYNC_MMU);
1121 #endif
1122 return r;
1123 }
1124
1125 int kvm_inject_nmi(kvm_vcpu_context_t vcpu)
1126 {
1127 #ifdef KVM_CAP_USER_NMI
1128 return ioctl(vcpu->fd, KVM_NMI);
1129 #else
1130 return -ENOSYS;
1131 #endif
1132 }
1133
1134 int kvm_init_coalesced_mmio(kvm_context_t kvm)
1135 {
1136 int r = 0;
1137 kvm->coalesced_mmio = 0;
1138 #ifdef KVM_CAP_COALESCED_MMIO
1139 r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_COALESCED_MMIO);
1140 if (r > 0) {
1141 kvm->coalesced_mmio = r;
1142 return 0;
1143 }
1144 #endif
1145 return r;
1146 }
1147
1148 int kvm_register_coalesced_mmio(kvm_context_t kvm, uint64_t addr, uint32_t size)
1149 {
1150 #ifdef KVM_CAP_COALESCED_MMIO
1151 struct kvm_coalesced_mmio_zone zone;
1152 int r;
1153
1154 if (kvm->coalesced_mmio) {
1155
1156 zone.addr = addr;
1157 zone.size = size;
1158
1159 r = ioctl(kvm->vm_fd, KVM_REGISTER_COALESCED_MMIO, &zone);
1160 if (r == -1) {
1161 perror("kvm_register_coalesced_mmio_zone");
1162 return -errno;
1163 }
1164 return 0;
1165 }
1166 #endif
1167 return -ENOSYS;
1168 }
1169
1170 int kvm_unregister_coalesced_mmio(kvm_context_t kvm, uint64_t addr, uint32_t size)
1171 {
1172 #ifdef KVM_CAP_COALESCED_MMIO
1173 struct kvm_coalesced_mmio_zone zone;
1174 int r;
1175
1176 if (kvm->coalesced_mmio) {
1177
1178 zone.addr = addr;
1179 zone.size = size;
1180
1181 r = ioctl(kvm->vm_fd, KVM_UNREGISTER_COALESCED_MMIO, &zone);
1182 if (r == -1) {
1183 perror("kvm_unregister_coalesced_mmio_zone");
1184 return -errno;
1185 }
1186 DPRINTF("Unregistered coalesced mmio region for %llx (%lx)\n", addr, size);
1187 return 0;
1188 }
1189 #endif
1190 return -ENOSYS;
1191 }
1192
1193 #ifdef KVM_CAP_DEVICE_ASSIGNMENT
1194 int kvm_assign_pci_device(kvm_context_t kvm,
1195 struct kvm_assigned_pci_dev *assigned_dev)
1196 {
1197 int ret;
1198
1199 ret = ioctl(kvm->vm_fd, KVM_ASSIGN_PCI_DEVICE, assigned_dev);
1200 if (ret < 0)
1201 return -errno;
1202
1203 return ret;
1204 }
1205
1206 static int kvm_old_assign_irq(kvm_context_t kvm,
1207 struct kvm_assigned_irq *assigned_irq)
1208 {
1209 int ret;
1210
1211 ret = ioctl(kvm->vm_fd, KVM_ASSIGN_IRQ, assigned_irq);
1212 if (ret < 0)
1213 return -errno;
1214
1215 return ret;
1216 }
1217
1218 #ifdef KVM_CAP_ASSIGN_DEV_IRQ
1219 int kvm_assign_irq(kvm_context_t kvm,
1220 struct kvm_assigned_irq *assigned_irq)
1221 {
1222 int ret;
1223
1224 ret = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_ASSIGN_DEV_IRQ);
1225 if (ret > 0) {
1226 ret = ioctl(kvm->vm_fd, KVM_ASSIGN_DEV_IRQ, assigned_irq);
1227 if (ret < 0)
1228 return -errno;
1229 return ret;
1230 }
1231
1232 return kvm_old_assign_irq(kvm, assigned_irq);
1233 }
1234
1235 int kvm_deassign_irq(kvm_context_t kvm,
1236 struct kvm_assigned_irq *assigned_irq)
1237 {
1238 int ret;
1239
1240 ret = ioctl(kvm->vm_fd, KVM_DEASSIGN_DEV_IRQ, assigned_irq);
1241 if (ret < 0)
1242 return -errno;
1243
1244 return ret;
1245 }
1246 #else
1247 int kvm_assign_irq(kvm_context_t kvm,
1248 struct kvm_assigned_irq *assigned_irq)
1249 {
1250 return kvm_old_assign_irq(kvm, assigned_irq);
1251 }
1252 #endif
1253 #endif
1254
1255 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
1256 int kvm_deassign_pci_device(kvm_context_t kvm,
1257 struct kvm_assigned_pci_dev *assigned_dev)
1258 {
1259 int ret;
1260
1261 ret = ioctl(kvm->vm_fd, KVM_DEASSIGN_PCI_DEVICE, assigned_dev);
1262 if (ret < 0)
1263 return -errno;
1264
1265 return ret;
1266 }
1267 #endif
1268
1269 int kvm_destroy_memory_region_works(kvm_context_t kvm)
1270 {
1271 int ret = 0;
1272
1273 #ifdef KVM_CAP_DESTROY_MEMORY_REGION_WORKS
1274 ret = ioctl(kvm->fd, KVM_CHECK_EXTENSION,
1275 KVM_CAP_DESTROY_MEMORY_REGION_WORKS);
1276 if (ret <= 0)
1277 ret = 0;
1278 #endif
1279 return ret;
1280 }
1281
1282 int kvm_reinject_control(kvm_context_t kvm, int pit_reinject)
1283 {
1284 #ifdef KVM_CAP_REINJECT_CONTROL
1285 int r;
1286 struct kvm_reinject_control control;
1287
1288 control.pit_reinject = pit_reinject;
1289
1290 r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_REINJECT_CONTROL);
1291 if (r > 0) {
1292 r = ioctl(kvm->vm_fd, KVM_REINJECT_CONTROL, &control);
1293 if (r == -1)
1294 return -errno;
1295 return r;
1296 }
1297 #endif
1298 return -ENOSYS;
1299 }
1300
1301 int kvm_has_gsi_routing(kvm_context_t kvm)
1302 {
1303 int r = 0;
1304
1305 #ifdef KVM_CAP_IRQ_ROUTING
1306 r = kvm_check_extension(kvm, KVM_CAP_IRQ_ROUTING);
1307 #endif
1308 return r;
1309 }
1310
1311 int kvm_get_gsi_count(kvm_context_t kvm)
1312 {
1313 #ifdef KVM_CAP_IRQ_ROUTING
1314 return kvm_check_extension(kvm, KVM_CAP_IRQ_ROUTING);
1315 #else
1316 return -EINVAL;
1317 #endif
1318 }
1319
1320 int kvm_clear_gsi_routes(kvm_context_t kvm)
1321 {
1322 #ifdef KVM_CAP_IRQ_ROUTING
1323 kvm->irq_routes->nr = 0;
1324 return 0;
1325 #else
1326 return -EINVAL;
1327 #endif
1328 }
1329
1330 int kvm_add_routing_entry(kvm_context_t kvm,
1331 struct kvm_irq_routing_entry* entry)
1332 {
1333 #ifdef KVM_CAP_IRQ_ROUTING
1334 struct kvm_irq_routing *z;
1335 struct kvm_irq_routing_entry *new;
1336 int n, size;
1337
1338 if (kvm->irq_routes->nr == kvm->nr_allocated_irq_routes) {
1339 n = kvm->nr_allocated_irq_routes * 2;
1340 if (n < 64)
1341 n = 64;
1342 size = sizeof(struct kvm_irq_routing);
1343 size += n * sizeof(*new);
1344 z = realloc(kvm->irq_routes, size);
1345 if (!z)
1346 return -ENOMEM;
1347 kvm->nr_allocated_irq_routes = n;
1348 kvm->irq_routes = z;
1349 }
1350 n = kvm->irq_routes->nr++;
1351 new = &kvm->irq_routes->entries[n];
1352 memset(new, 0, sizeof(*new));
1353 new->gsi = entry->gsi;
1354 new->type = entry->type;
1355 new->flags = entry->flags;
1356 new->u = entry->u;
1357
1358 set_gsi(kvm, entry->gsi);
1359
1360 return 0;
1361 #else
1362 return -ENOSYS;
1363 #endif
1364 }
1365
1366 int kvm_add_irq_route(kvm_context_t kvm, int gsi, int irqchip, int pin)
1367 {
1368 #ifdef KVM_CAP_IRQ_ROUTING
1369 struct kvm_irq_routing_entry e;
1370
1371 e.gsi = gsi;
1372 e.type = KVM_IRQ_ROUTING_IRQCHIP;
1373 e.flags = 0;
1374 e.u.irqchip.irqchip = irqchip;
1375 e.u.irqchip.pin = pin;
1376 return kvm_add_routing_entry(kvm, &e);
1377 #else
1378 return -ENOSYS;
1379 #endif
1380 }
1381
1382 int kvm_del_routing_entry(kvm_context_t kvm,
1383 struct kvm_irq_routing_entry* entry)
1384 {
1385 #ifdef KVM_CAP_IRQ_ROUTING
1386 struct kvm_irq_routing_entry *e, *p;
1387 int i, gsi, found = 0;
1388
1389 gsi = entry->gsi;
1390
1391 for (i = 0; i < kvm->irq_routes->nr; ++i) {
1392 e = &kvm->irq_routes->entries[i];
1393 if (e->type == entry->type
1394 && e->gsi == gsi) {
1395 switch (e->type)
1396 {
1397 case KVM_IRQ_ROUTING_IRQCHIP: {
1398 if (e->u.irqchip.irqchip ==
1399 entry->u.irqchip.irqchip
1400 && e->u.irqchip.pin ==
1401 entry->u.irqchip.pin) {
1402 p = &kvm->irq_routes->
1403 entries[--kvm->irq_routes->nr];
1404 *e = *p;
1405 found = 1;
1406 }
1407 break;
1408 }
1409 case KVM_IRQ_ROUTING_MSI: {
1410 if (e->u.msi.address_lo ==
1411 entry->u.msi.address_lo
1412 && e->u.msi.address_hi ==
1413 entry->u.msi.address_hi
1414 && e->u.msi.data == entry->u.msi.data) {
1415 p = &kvm->irq_routes->
1416 entries[--kvm->irq_routes->nr];
1417 *e = *p;
1418 found = 1;
1419 }
1420 break;
1421 }
1422 default:
1423 break;
1424 }
1425 if (found) {
1426 /* If there are no other users of this GSI
1427 * mark it available in the bitmap */
1428 for (i = 0; i < kvm->irq_routes->nr; i++) {
1429 e = &kvm->irq_routes->entries[i];
1430 if (e->gsi == gsi)
1431 break;
1432 }
1433 if (i == kvm->irq_routes->nr)
1434 clear_gsi(kvm, gsi);
1435
1436 return 0;
1437 }
1438 }
1439 }
1440 return -ESRCH;
1441 #else
1442 return -ENOSYS;
1443 #endif
1444 }
1445
1446 int kvm_del_irq_route(kvm_context_t kvm, int gsi, int irqchip, int pin)
1447 {
1448 #ifdef KVM_CAP_IRQ_ROUTING
1449 struct kvm_irq_routing_entry e;
1450
1451 e.gsi = gsi;
1452 e.type = KVM_IRQ_ROUTING_IRQCHIP;
1453 e.flags = 0;
1454 e.u.irqchip.irqchip = irqchip;
1455 e.u.irqchip.pin = pin;
1456 return kvm_del_routing_entry(kvm, &e);
1457 #else
1458 return -ENOSYS;
1459 #endif
1460 }
1461
1462 int kvm_commit_irq_routes(kvm_context_t kvm)
1463 {
1464 #ifdef KVM_CAP_IRQ_ROUTING
1465 int r;
1466
1467 kvm->irq_routes->flags = 0;
1468 r = ioctl(kvm->vm_fd, KVM_SET_GSI_ROUTING, kvm->irq_routes);
1469 if (r == -1)
1470 r = -errno;
1471 return r;
1472 #else
1473 return -ENOSYS;
1474 #endif
1475 }
1476
1477 int kvm_get_irq_route_gsi(kvm_context_t kvm)
1478 {
1479 int i, bit;
1480 uint32_t *buf = kvm->used_gsi_bitmap;
1481
1482 /* Return the lowest unused GSI in the bitmap */
1483 for (i = 0; i < kvm->max_gsi / 32; i++) {
1484 bit = ffs(~buf[i]);
1485 if (!bit)
1486 continue;
1487
1488 return bit - 1 + i * 32;
1489 }
1490
1491 return -ENOSPC;
1492 }
1493
1494 #ifdef KVM_CAP_DEVICE_MSIX
1495 int kvm_assign_set_msix_nr(kvm_context_t kvm,
1496 struct kvm_assigned_msix_nr *msix_nr)
1497 {
1498 int ret;
1499
1500 ret = ioctl(kvm->vm_fd, KVM_ASSIGN_SET_MSIX_NR, msix_nr);
1501 if (ret < 0)
1502 return -errno;
1503
1504 return ret;
1505 }
1506
1507 int kvm_assign_set_msix_entry(kvm_context_t kvm,
1508 struct kvm_assigned_msix_entry *entry)
1509 {
1510 int ret;
1511
1512 ret = ioctl(kvm->vm_fd, KVM_ASSIGN_SET_MSIX_ENTRY, entry);
1513 if (ret < 0)
1514 return -errno;
1515
1516 return ret;
1517 }
1518 #endif
1519
1520 #if defined(KVM_CAP_IRQFD) && defined(CONFIG_eventfd)
1521
1522 #include <sys/eventfd.h>
1523
1524 static int _kvm_irqfd(kvm_context_t kvm, int fd, int gsi, int flags)
1525 {
1526 int r;
1527 struct kvm_irqfd data = {
1528 .fd = fd,
1529 .gsi = gsi,
1530 .flags = flags,
1531 };
1532
1533 r = ioctl(kvm->vm_fd, KVM_IRQFD, &data);
1534 if (r == -1)
1535 r = -errno;
1536 return r;
1537 }
1538
1539 int kvm_irqfd(kvm_context_t kvm, int gsi, int flags)
1540 {
1541 int r;
1542 int fd;
1543
1544 if (!kvm_check_extension(kvm, KVM_CAP_IRQFD))
1545 return -ENOENT;
1546
1547 fd = eventfd(0, 0);
1548 if (fd < 0)
1549 return -errno;
1550
1551 r = _kvm_irqfd(kvm, fd, gsi, 0);
1552 if (r < 0) {
1553 close(fd);
1554 return -errno;
1555 }
1556
1557 return fd;
1558 }
1559
1560 #else /* KVM_CAP_IRQFD */
1561
1562 int kvm_irqfd(kvm_context_t kvm, int gsi, int flags)
1563 {
1564 return -ENOSYS;
1565 }
1566
1567 #endif /* KVM_CAP_IRQFD */
1568 static inline unsigned long kvm_get_thread_id(void)
1569 {
1570 return syscall(SYS_gettid);
1571 }
1572
1573 static void qemu_cond_wait(pthread_cond_t *cond)
1574 {
1575 CPUState *env = cpu_single_env;
1576 static const struct timespec ts = {
1577 .tv_sec = 0,
1578 .tv_nsec = 100000,
1579 };
1580
1581 pthread_cond_timedwait(cond, &qemu_mutex, &ts);
1582 cpu_single_env = env;
1583 }
1584
1585 static void sig_ipi_handler(int n)
1586 {
1587 }
1588
1589 static void on_vcpu(CPUState *env, void (*func)(void *data), void *data)
1590 {
1591 struct qemu_work_item wi;
1592
1593 if (env == current_env) {
1594 func(data);
1595 return;
1596 }
1597
1598 wi.func = func;
1599 wi.data = data;
1600 if (!env->kvm_cpu_state.queued_work_first)
1601 env->kvm_cpu_state.queued_work_first = &wi;
1602 else
1603 env->kvm_cpu_state.queued_work_last->next = &wi;
1604 env->kvm_cpu_state.queued_work_last = &wi;
1605 wi.next = NULL;
1606 wi.done = false;
1607
1608 pthread_kill(env->kvm_cpu_state.thread, SIG_IPI);
1609 while (!wi.done)
1610 qemu_cond_wait(&qemu_work_cond);
1611 }
1612
1613 static void inject_interrupt(void *data)
1614 {
1615 cpu_interrupt(current_env, (long)data);
1616 }
1617
1618 void kvm_inject_interrupt(CPUState *env, int mask)
1619 {
1620 on_vcpu(env, inject_interrupt, (void *)(long)mask);
1621 }
1622
1623 void kvm_update_interrupt_request(CPUState *env)
1624 {
1625 int signal = 0;
1626
1627 if (env) {
1628 if (!current_env || !current_env->kvm_cpu_state.created)
1629 signal = 1;
1630 /*
1631 * Testing for created here is really redundant
1632 */
1633 if (current_env && current_env->kvm_cpu_state.created &&
1634 env != current_env && !env->kvm_cpu_state.signalled)
1635 signal = 1;
1636
1637 if (signal) {
1638 env->kvm_cpu_state.signalled = 1;
1639 if (env->kvm_cpu_state.thread)
1640 pthread_kill(env->kvm_cpu_state.thread, SIG_IPI);
1641 }
1642 }
1643 }
1644
1645 void kvm_update_after_sipi(CPUState *env)
1646 {
1647 env->kvm_cpu_state.sipi_needed = 1;
1648 kvm_update_interrupt_request(env);
1649 }
1650
1651 void kvm_apic_init(CPUState *env)
1652 {
1653 if (env->cpu_index != 0)
1654 env->kvm_cpu_state.init = 1;
1655 kvm_update_interrupt_request(env);
1656 }
1657
1658 #include <signal.h>
1659
1660 static int kvm_try_push_interrupts(void *opaque)
1661 {
1662 return kvm_arch_try_push_interrupts(opaque);
1663 }
1664
1665 static void kvm_post_run(void *opaque, void *data)
1666 {
1667 CPUState *env = (CPUState *)data;
1668
1669 pthread_mutex_lock(&qemu_mutex);
1670 kvm_arch_post_kvm_run(opaque, env);
1671 }
1672
1673 static int kvm_pre_run(void *opaque, void *data)
1674 {
1675 CPUState *env = (CPUState *)data;
1676
1677 kvm_arch_pre_kvm_run(opaque, env);
1678
1679 pthread_mutex_unlock(&qemu_mutex);
1680 return 0;
1681 }
1682
1683 static void kvm_do_load_registers(void *_env)
1684 {
1685 CPUState *env = _env;
1686
1687 kvm_arch_load_regs(env);
1688 }
1689
1690 void kvm_load_registers(CPUState *env)
1691 {
1692 if (kvm_enabled() && qemu_system_ready)
1693 on_vcpu(env, kvm_do_load_registers, env);
1694 }
1695
1696 static void kvm_do_save_registers(void *_env)
1697 {
1698 CPUState *env = _env;
1699
1700 kvm_arch_save_regs(env);
1701 }
1702
1703 void kvm_save_registers(CPUState *env)
1704 {
1705 if (kvm_enabled())
1706 on_vcpu(env, kvm_do_save_registers, env);
1707 }
1708
1709 static void kvm_do_load_mpstate(void *_env)
1710 {
1711 CPUState *env = _env;
1712
1713 kvm_arch_load_mpstate(env);
1714 }
1715
1716 void kvm_load_mpstate(CPUState *env)
1717 {
1718 if (kvm_enabled() && qemu_system_ready)
1719 on_vcpu(env, kvm_do_load_mpstate, env);
1720 }
1721
1722 static void kvm_do_save_mpstate(void *_env)
1723 {
1724 CPUState *env = _env;
1725
1726 kvm_arch_save_mpstate(env);
1727 env->halted = (env->mp_state == KVM_MP_STATE_HALTED);
1728 }
1729
1730 void kvm_save_mpstate(CPUState *env)
1731 {
1732 if (kvm_enabled())
1733 on_vcpu(env, kvm_do_save_mpstate, env);
1734 }
1735
1736 int kvm_cpu_exec(CPUState *env)
1737 {
1738 int r;
1739
1740 r = kvm_run(env->kvm_cpu_state.vcpu_ctx, env);
1741 if (r < 0) {
1742 printf("kvm_run returned %d\n", r);
1743 vm_stop(0);
1744 }
1745
1746 return 0;
1747 }
1748
1749 static int has_work(CPUState *env)
1750 {
1751 if (!vm_running || (env && env->kvm_cpu_state.stopped))
1752 return 0;
1753 if (kvm_irqchip_in_kernel(kvm_context))
1754 return 1;
1755 if (!env->halted)
1756 return 1;
1757 return kvm_arch_has_work(env);
1758 }
1759
1760 static void flush_queued_work(CPUState *env)
1761 {
1762 struct qemu_work_item *wi;
1763
1764 if (!env->kvm_cpu_state.queued_work_first)
1765 return;
1766
1767 while ((wi = env->kvm_cpu_state.queued_work_first)) {
1768 env->kvm_cpu_state.queued_work_first = wi->next;
1769 wi->func(wi->data);
1770 wi->done = true;
1771 }
1772 env->kvm_cpu_state.queued_work_last = NULL;
1773 pthread_cond_broadcast(&qemu_work_cond);
1774 }
1775
1776 static void kvm_main_loop_wait(CPUState *env, int timeout)
1777 {
1778 struct timespec ts;
1779 int r, e;
1780 siginfo_t siginfo;
1781 sigset_t waitset;
1782
1783 pthread_mutex_unlock(&qemu_mutex);
1784
1785 ts.tv_sec = timeout / 1000;
1786 ts.tv_nsec = (timeout % 1000) * 1000000;
1787 sigemptyset(&waitset);
1788 sigaddset(&waitset, SIG_IPI);
1789
1790 r = sigtimedwait(&waitset, &siginfo, &ts);
1791 e = errno;
1792
1793 pthread_mutex_lock(&qemu_mutex);
1794
1795 if (r == -1 && !(e == EAGAIN || e == EINTR)) {
1796 printf("sigtimedwait: %s\n", strerror(e));
1797 exit(1);
1798 }
1799
1800 cpu_single_env = env;
1801 flush_queued_work(env);
1802
1803 if (env->kvm_cpu_state.stop) {
1804 env->kvm_cpu_state.stop = 0;
1805 env->kvm_cpu_state.stopped = 1;
1806 pthread_cond_signal(&qemu_pause_cond);
1807 }
1808
1809 env->kvm_cpu_state.signalled = 0;
1810 }
1811
1812 static int all_threads_paused(void)
1813 {
1814 CPUState *penv = first_cpu;
1815
1816 while (penv) {
1817 if (penv->kvm_cpu_state.stop)
1818 return 0;
1819 penv = (CPUState *)penv->next_cpu;
1820 }
1821
1822 return 1;
1823 }
1824
1825 static void pause_all_threads(void)
1826 {
1827 CPUState *penv = first_cpu;
1828
1829 while (penv) {
1830 if (penv != cpu_single_env) {
1831 penv->kvm_cpu_state.stop = 1;
1832 pthread_kill(penv->kvm_cpu_state.thread, SIG_IPI);
1833 } else {
1834 penv->kvm_cpu_state.stop = 0;
1835 penv->kvm_cpu_state.stopped = 1;
1836 cpu_exit(penv);
1837 }
1838 penv = (CPUState *)penv->next_cpu;
1839 }
1840
1841 while (!all_threads_paused())
1842 qemu_cond_wait(&qemu_pause_cond);
1843 }
1844
1845 static void resume_all_threads(void)
1846 {
1847 CPUState *penv = first_cpu;
1848
1849 assert(!cpu_single_env);
1850
1851 while (penv) {
1852 penv->kvm_cpu_state.stop = 0;
1853 penv->kvm_cpu_state.stopped = 0;
1854 pthread_kill(penv->kvm_cpu_state.thread, SIG_IPI);
1855 penv = (CPUState *)penv->next_cpu;
1856 }
1857 }
1858
1859 static void kvm_vm_state_change_handler(void *context, int running, int reason)
1860 {
1861 if (running)
1862 resume_all_threads();
1863 else
1864 pause_all_threads();
1865 }
1866
1867 static void update_regs_for_sipi(CPUState *env)
1868 {
1869 kvm_arch_update_regs_for_sipi(env);
1870 env->kvm_cpu_state.sipi_needed = 0;
1871 }
1872
1873 static void update_regs_for_init(CPUState *env)
1874 {
1875 #ifdef TARGET_I386
1876 SegmentCache cs = env->segs[R_CS];
1877 #endif
1878
1879 cpu_reset(env);
1880
1881 #ifdef TARGET_I386
1882 /* restore SIPI vector */
1883 if(env->kvm_cpu_state.sipi_needed)
1884 env->segs[R_CS] = cs;
1885 #endif
1886
1887 env->kvm_cpu_state.init = 0;
1888 kvm_arch_load_regs(env);
1889 }
1890
1891 static void setup_kernel_sigmask(CPUState *env)
1892 {
1893 sigset_t set;
1894
1895 sigemptyset(&set);
1896 sigaddset(&set, SIGUSR2);
1897 sigaddset(&set, SIGIO);
1898 sigaddset(&set, SIGALRM);
1899 sigprocmask(SIG_BLOCK, &set, NULL);
1900
1901 sigprocmask(SIG_BLOCK, NULL, &set);
1902 sigdelset(&set, SIG_IPI);
1903
1904 kvm_set_signal_mask(env->kvm_cpu_state.vcpu_ctx, &set);
1905 }
1906
1907 static void qemu_kvm_system_reset(void)
1908 {
1909 CPUState *penv = first_cpu;
1910
1911 pause_all_threads();
1912
1913 qemu_system_reset();
1914
1915 while (penv) {
1916 kvm_arch_cpu_reset(penv);
1917 penv = (CPUState *)penv->next_cpu;
1918 }
1919
1920 resume_all_threads();
1921 }
1922
1923 static int kvm_main_loop_cpu(CPUState *env)
1924 {
1925 setup_kernel_sigmask(env);
1926
1927 pthread_mutex_lock(&qemu_mutex);
1928
1929 kvm_qemu_init_env(env);
1930 #ifdef TARGET_I386
1931 kvm_tpr_vcpu_start(env);
1932 #endif
1933
1934 cpu_single_env = env;
1935 kvm_arch_load_regs(env);
1936
1937 while (1) {
1938 while (!has_work(env))
1939 kvm_main_loop_wait(env, 1000);
1940 if (env->interrupt_request & (CPU_INTERRUPT_HARD | CPU_INTERRUPT_NMI))
1941 env->halted = 0;
1942 if (!kvm_irqchip_in_kernel(kvm_context)) {
1943 if (env->kvm_cpu_state.init)
1944 update_regs_for_init(env);
1945 if (env->kvm_cpu_state.sipi_needed)
1946 update_regs_for_sipi(env);
1947 }
1948 if (!env->halted || kvm_irqchip_in_kernel(kvm_context))
1949 kvm_cpu_exec(env);
1950 kvm_main_loop_wait(env, 0);
1951 }
1952 pthread_mutex_unlock(&qemu_mutex);
1953 return 0;
1954 }
1955
1956 static void *ap_main_loop(void *_env)
1957 {
1958 CPUState *env = _env;
1959 sigset_t signals;
1960 struct ioperm_data *data = NULL;
1961
1962 current_env = env;
1963 env->thread_id = kvm_get_thread_id();
1964 sigfillset(&signals);
1965 sigprocmask(SIG_BLOCK, &signals, NULL);
1966 env->kvm_cpu_state.vcpu_ctx = kvm_create_vcpu(kvm_context, env->cpu_index);
1967
1968 #ifdef USE_KVM_DEVICE_ASSIGNMENT
1969 /* do ioperm for io ports of assigned devices */
1970 LIST_FOREACH(data, &ioperm_head, entries)
1971 on_vcpu(env, kvm_arch_do_ioperm, data);
1972 #endif
1973
1974 /* signal VCPU creation */
1975 pthread_mutex_lock(&qemu_mutex);
1976 current_env->kvm_cpu_state.created = 1;
1977 pthread_cond_signal(&qemu_vcpu_cond);
1978
1979 /* and wait for machine initialization */
1980 while (!qemu_system_ready)
1981 qemu_cond_wait(&qemu_system_cond);
1982 pthread_mutex_unlock(&qemu_mutex);
1983
1984 kvm_main_loop_cpu(env);
1985 return NULL;
1986 }
1987
1988 void kvm_init_vcpu(CPUState *env)
1989 {
1990 pthread_create(&env->kvm_cpu_state.thread, NULL, ap_main_loop, env);
1991
1992 while (env->kvm_cpu_state.created == 0)
1993 qemu_cond_wait(&qemu_vcpu_cond);
1994 }
1995
1996 int kvm_vcpu_inited(CPUState *env)
1997 {
1998 return env->kvm_cpu_state.created;
1999 }
2000
2001 int kvm_init_ap(void)
2002 {
2003 #ifdef TARGET_I386
2004 kvm_tpr_opt_setup();
2005 #endif
2006 qemu_add_vm_change_state_handler(kvm_vm_state_change_handler, NULL);
2007
2008 signal(SIG_IPI, sig_ipi_handler);
2009 return 0;
2010 }
2011
2012 void qemu_kvm_notify_work(void)
2013 {
2014 uint64_t value = 1;
2015 char buffer[8];
2016 size_t offset = 0;
2017
2018 if (io_thread_fd == -1)
2019 return;
2020
2021 memcpy(buffer, &value, sizeof(value));
2022
2023 while (offset < 8) {
2024 ssize_t len;
2025
2026 len = write(io_thread_fd, buffer + offset, 8 - offset);
2027 if (len == -1 && errno == EINTR)
2028 continue;
2029
2030 if (len <= 0)
2031 break;
2032
2033 offset += len;
2034 }
2035
2036 if (offset != 8)
2037 fprintf(stderr, "failed to notify io thread\n");
2038 }
2039
2040 /* If we have signalfd, we mask out the signals we want to handle and then
2041 * use signalfd to listen for them. We rely on whatever the current signal
2042 * handler is to dispatch the signals when we receive them.
2043 */
2044
2045 static void sigfd_handler(void *opaque)
2046 {
2047 int fd = (unsigned long)opaque;
2048 struct qemu_signalfd_siginfo info;
2049 struct sigaction action;
2050 ssize_t len;
2051
2052 while (1) {
2053 do {
2054 len = read(fd, &info, sizeof(info));
2055 } while (len == -1 && errno == EINTR);
2056
2057 if (len == -1 && errno == EAGAIN)
2058 break;
2059
2060 if (len != sizeof(info)) {
2061 printf("read from sigfd returned %zd: %m\n", len);
2062 return;
2063 }
2064
2065 sigaction(info.ssi_signo, NULL, &action);
2066 if (action.sa_handler)
2067 action.sa_handler(info.ssi_signo);
2068
2069 }
2070 }
2071
2072 /* Used to break IO thread out of select */
2073 static void io_thread_wakeup(void *opaque)
2074 {
2075 int fd = (unsigned long)opaque;
2076 char buffer[8];
2077 size_t offset = 0;
2078
2079 while (offset < 8) {
2080 ssize_t len;
2081
2082 len = read(fd, buffer + offset, 8 - offset);
2083 if (len == -1 && errno == EINTR)
2084 continue;
2085
2086 if (len <= 0)
2087 break;
2088
2089 offset += len;
2090 }
2091 }
2092
2093 int kvm_main_loop(void)
2094 {
2095 int fds[2];
2096 sigset_t mask;
2097 int sigfd;
2098
2099 io_thread = pthread_self();
2100 qemu_system_ready = 1;
2101
2102 if (qemu_eventfd(fds) == -1) {
2103 fprintf(stderr, "failed to create eventfd\n");
2104 return -errno;
2105 }
2106
2107 qemu_set_fd_handler2(fds[0], NULL, io_thread_wakeup, NULL,
2108 (void *)(unsigned long)fds[0]);
2109
2110 io_thread_fd = fds[1];
2111
2112 sigemptyset(&mask);
2113 sigaddset(&mask, SIGIO);
2114 sigaddset(&mask, SIGALRM);
2115 sigprocmask(SIG_BLOCK, &mask, NULL);
2116
2117 sigfd = qemu_signalfd(&mask);
2118 if (sigfd == -1) {
2119 fprintf(stderr, "failed to create signalfd\n");
2120 return -errno;
2121 }
2122
2123 fcntl(sigfd, F_SETFL, O_NONBLOCK);
2124
2125 qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
2126 (void *)(unsigned long)sigfd);
2127
2128 pthread_cond_broadcast(&qemu_system_cond);
2129
2130 io_thread_sigfd = sigfd;
2131 cpu_single_env = NULL;
2132
2133 while (1) {
2134 main_loop_wait(1000);
2135 if (qemu_shutdown_requested()) {
2136 if (qemu_no_shutdown()) {
2137 vm_stop(0);
2138 } else
2139 break;
2140 } else if (qemu_powerdown_requested())
2141 qemu_system_powerdown();
2142 else if (qemu_reset_requested())
2143 qemu_kvm_system_reset();
2144 else if (kvm_debug_cpu_requested) {
2145 gdb_set_stop_cpu(kvm_debug_cpu_requested);
2146 vm_stop(EXCP_DEBUG);
2147 kvm_debug_cpu_requested = NULL;
2148 }
2149 }
2150
2151 pause_all_threads();
2152 pthread_mutex_unlock(&qemu_mutex);
2153
2154 return 0;
2155 }
2156
2157 #ifdef KVM_CAP_SET_GUEST_DEBUG
2158 static int kvm_debug(void *opaque, void *data,
2159 struct kvm_debug_exit_arch *arch_info)
2160 {
2161 int handle = kvm_arch_debug(arch_info);
2162 CPUState *env = data;
2163
2164 if (handle) {
2165 kvm_debug_cpu_requested = env;
2166 env->kvm_cpu_state.stopped = 1;
2167 }
2168 return handle;
2169 }
2170 #endif
2171
2172 static int kvm_inb(void *opaque, uint16_t addr, uint8_t *data)
2173 {
2174 *data = cpu_inb(0, addr);
2175 return 0;
2176 }
2177
2178 static int kvm_inw(void *opaque, uint16_t addr, uint16_t *data)
2179 {
2180 *data = cpu_inw(0, addr);
2181 return 0;
2182 }
2183
2184 static int kvm_inl(void *opaque, uint16_t addr, uint32_t *data)
2185 {
2186 *data = cpu_inl(0, addr);
2187 return 0;
2188 }
2189
2190 #define PM_IO_BASE 0xb000
2191
2192 static int kvm_outb(void *opaque, uint16_t addr, uint8_t data)
2193 {
2194 if (addr == 0xb2) {
2195 switch (data) {
2196 case 0: {
2197 cpu_outb(0, 0xb3, 0);
2198 break;
2199 }
2200 case 0xf0: {
2201 unsigned x;
2202
2203 /* enable acpi */
2204 x = cpu_inw(0, PM_IO_BASE + 4);
2205 x &= ~1;
2206 cpu_outw(0, PM_IO_BASE + 4, x);
2207 break;
2208 }
2209 case 0xf1: {
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 default:
2219 break;
2220 }
2221 return 0;
2222 }
2223 cpu_outb(0, addr, data);
2224 return 0;
2225 }
2226
2227 static int kvm_outw(void *opaque, uint16_t addr, uint16_t data)
2228 {
2229 cpu_outw(0, addr, data);
2230 return 0;
2231 }
2232
2233 static int kvm_outl(void *opaque, uint16_t addr, uint32_t data)
2234 {
2235 cpu_outl(0, addr, data);
2236 return 0;
2237 }
2238
2239 static int kvm_mmio_read(void *opaque, uint64_t addr, uint8_t *data, int len)
2240 {
2241 cpu_physical_memory_rw(addr, data, len, 0);
2242 return 0;
2243 }
2244
2245 static int kvm_mmio_write(void *opaque, uint64_t addr, uint8_t *data, int len)
2246 {
2247 cpu_physical_memory_rw(addr, data, len, 1);
2248 return 0;
2249 }
2250
2251 static int kvm_io_window(void *opaque)
2252 {
2253 return 1;
2254 }
2255
2256
2257 static int kvm_halt(void *opaque, kvm_vcpu_context_t vcpu)
2258 {
2259 return kvm_arch_halt(opaque, vcpu);
2260 }
2261
2262 static int kvm_shutdown(void *opaque, void *data)
2263 {
2264 CPUState *env = (CPUState *)data;
2265
2266 /* stop the current vcpu from going back to guest mode */
2267 env->kvm_cpu_state.stopped = 1;
2268
2269 qemu_system_reset_request();
2270 return 1;
2271 }
2272
2273 static int handle_unhandled(kvm_context_t kvm, kvm_vcpu_context_t vcpu,
2274 uint64_t reason)
2275 {
2276 fprintf(stderr, "kvm: unhandled exit %"PRIx64"\n", reason);
2277 return -EINVAL;
2278 }
2279
2280 static struct kvm_callbacks qemu_kvm_ops = {
2281 #ifdef KVM_CAP_SET_GUEST_DEBUG
2282 .debug = kvm_debug,
2283 #endif
2284 .inb = kvm_inb,
2285 .inw = kvm_inw,
2286 .inl = kvm_inl,
2287 .outb = kvm_outb,
2288 .outw = kvm_outw,
2289 .outl = kvm_outl,
2290 .mmio_read = kvm_mmio_read,
2291 .mmio_write = kvm_mmio_write,
2292 .halt = kvm_halt,
2293 .shutdown = kvm_shutdown,
2294 .io_window = kvm_io_window,
2295 .try_push_interrupts = kvm_try_push_interrupts,
2296 #ifdef KVM_CAP_USER_NMI
2297 .push_nmi = kvm_arch_push_nmi,
2298 #endif
2299 .post_kvm_run = kvm_post_run,
2300 .pre_kvm_run = kvm_pre_run,
2301 #ifdef TARGET_I386
2302 .tpr_access = handle_tpr_access,
2303 #endif
2304 #ifdef TARGET_PPC
2305 .powerpc_dcr_read = handle_powerpc_dcr_read,
2306 .powerpc_dcr_write = handle_powerpc_dcr_write,
2307 #endif
2308 .unhandled = handle_unhandled,
2309 };
2310
2311 int kvm_qemu_init()
2312 {
2313 /* Try to initialize kvm */
2314 kvm_context = kvm_init(&qemu_kvm_ops, cpu_single_env);
2315 if (!kvm_context) {
2316 return -1;
2317 }
2318 pthread_mutex_lock(&qemu_mutex);
2319
2320 return 0;
2321 }
2322
2323 #ifdef TARGET_I386
2324 static int destroy_region_works = 0;
2325 #endif
2326
2327
2328 #if !defined(TARGET_I386)
2329 int kvm_arch_init_irq_routing(void)
2330 {
2331 return 0;
2332 }
2333 #endif
2334
2335 int kvm_qemu_create_context(void)
2336 {
2337 int r;
2338
2339 if (!kvm_irqchip) {
2340 kvm_disable_irqchip_creation(kvm_context);
2341 }
2342 if (!kvm_pit) {
2343 kvm_disable_pit_creation(kvm_context);
2344 }
2345 if (kvm_create(kvm_context, 0, NULL) < 0) {
2346 kvm_qemu_destroy();
2347 return -1;
2348 }
2349 r = kvm_arch_qemu_create_context();
2350 if(r <0)
2351 kvm_qemu_destroy();
2352 if (kvm_pit && !kvm_pit_reinject) {
2353 if (kvm_reinject_control(kvm_context, 0)) {
2354 fprintf(stderr, "failure to disable in-kernel PIT reinjection\n");
2355 return -1;
2356 }
2357 }
2358 #ifdef TARGET_I386
2359 destroy_region_works = kvm_destroy_memory_region_works(kvm_context);
2360 #endif
2361
2362 r = kvm_arch_init_irq_routing();
2363 if (r < 0) {
2364 return r;
2365 }
2366
2367 return 0;
2368 }
2369
2370 void kvm_qemu_destroy(void)
2371 {
2372 kvm_finalize(kvm_context);
2373 }
2374
2375 #ifdef TARGET_I386
2376 static int must_use_aliases_source(target_phys_addr_t addr)
2377 {
2378 if (destroy_region_works)
2379 return false;
2380 if (addr == 0xa0000 || addr == 0xa8000)
2381 return true;
2382 return false;
2383 }
2384
2385 static int must_use_aliases_target(target_phys_addr_t addr)
2386 {
2387 if (destroy_region_works)
2388 return false;
2389 if (addr >= 0xe0000000 && addr < 0x100000000ull)
2390 return true;
2391 return false;
2392 }
2393
2394 static struct mapping {
2395 target_phys_addr_t phys;
2396 ram_addr_t ram;
2397 ram_addr_t len;
2398 } mappings[50];
2399 static int nr_mappings;
2400
2401 static struct mapping *find_ram_mapping(ram_addr_t ram_addr)
2402 {
2403 struct mapping *p;
2404
2405 for (p = mappings; p < mappings + nr_mappings; ++p) {
2406 if (p->ram <= ram_addr && ram_addr < p->ram + p->len) {
2407 return p;
2408 }
2409 }
2410 return NULL;
2411 }
2412
2413 static struct mapping *find_mapping(target_phys_addr_t start_addr)
2414 {
2415 struct mapping *p;
2416
2417 for (p = mappings; p < mappings + nr_mappings; ++p) {
2418 if (p->phys <= start_addr && start_addr < p->phys + p->len) {
2419 return p;
2420 }
2421 }
2422 return NULL;
2423 }
2424
2425 static void drop_mapping(target_phys_addr_t start_addr)
2426 {
2427 struct mapping *p = find_mapping(start_addr);
2428
2429 if (p)
2430 *p = mappings[--nr_mappings];
2431 }
2432 #endif
2433
2434 void kvm_cpu_register_physical_memory(target_phys_addr_t start_addr,
2435 unsigned long size,
2436 unsigned long phys_offset)
2437 {
2438 int r = 0;
2439 unsigned long area_flags;
2440 #ifdef TARGET_I386
2441 struct mapping *p;
2442 #endif
2443
2444 if (start_addr + size > phys_ram_size) {
2445 phys_ram_size = start_addr + size;
2446 }
2447
2448 phys_offset &= ~IO_MEM_ROM;
2449 area_flags = phys_offset & ~TARGET_PAGE_MASK;
2450
2451 if (area_flags != IO_MEM_RAM) {
2452 #ifdef TARGET_I386
2453 if (must_use_aliases_source(start_addr)) {
2454 kvm_destroy_memory_alias(kvm_context, start_addr);
2455 return;
2456 }
2457 if (must_use_aliases_target(start_addr))
2458 return;
2459 #endif
2460 while (size > 0) {
2461 p = find_mapping(start_addr);
2462 if (p) {
2463 kvm_unregister_memory_area(kvm_context, p->phys, p->len);
2464 drop_mapping(p->phys);
2465 }
2466 start_addr += TARGET_PAGE_SIZE;
2467 if (size > TARGET_PAGE_SIZE) {
2468 size -= TARGET_PAGE_SIZE;
2469 } else {
2470 size = 0;
2471 }
2472 }
2473 return;
2474 }
2475
2476 r = kvm_is_containing_region(kvm_context, start_addr, size);
2477 if (r)
2478 return;
2479
2480 if (area_flags >= TLB_MMIO)
2481 return;
2482
2483 #ifdef TARGET_I386
2484 if (must_use_aliases_source(start_addr)) {
2485 p = find_ram_mapping(phys_offset);
2486 if (p) {
2487 kvm_create_memory_alias(kvm_context, start_addr, size,
2488 p->phys + (phys_offset - p->ram));
2489 }
2490 return;
2491 }
2492 #endif
2493
2494 r = kvm_register_phys_mem(kvm_context, start_addr,
2495 qemu_get_ram_ptr(phys_offset),
2496 size, 0);
2497 if (r < 0) {
2498 printf("kvm_cpu_register_physical_memory: failed\n");
2499 exit(1);
2500 }
2501
2502 #ifdef TARGET_I386
2503 drop_mapping(start_addr);
2504 p = &mappings[nr_mappings++];
2505 p->phys = start_addr;
2506 p->ram = phys_offset;
2507 p->len = size;
2508 #endif
2509
2510 return;
2511 }
2512
2513 void kvm_cpu_unregister_physical_memory(target_phys_addr_t start_addr,
2514 target_phys_addr_t size,
2515 unsigned long phys_offset)
2516 {
2517 kvm_unregister_memory_area(kvm_context, start_addr, size);
2518 }
2519
2520 int kvm_setup_guest_memory(void *area, unsigned long size)
2521 {
2522 int ret = 0;
2523
2524 #ifdef MADV_DONTFORK
2525 if (kvm_enabled() && !kvm_has_sync_mmu())
2526 ret = madvise(area, size, MADV_DONTFORK);
2527 #endif
2528
2529 if (ret)
2530 perror ("madvise");
2531
2532 return ret;
2533 }
2534
2535 int kvm_qemu_check_extension(int ext)
2536 {
2537 return kvm_check_extension(kvm_context, ext);
2538 }
2539
2540 int kvm_qemu_init_env(CPUState *cenv)
2541 {
2542 return kvm_arch_qemu_init_env(cenv);
2543 }
2544
2545 #ifdef KVM_CAP_SET_GUEST_DEBUG
2546 struct kvm_sw_breakpoint_head kvm_sw_breakpoints =
2547 TAILQ_HEAD_INITIALIZER(kvm_sw_breakpoints);
2548
2549 struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(target_ulong pc)
2550 {
2551 struct kvm_sw_breakpoint *bp;
2552
2553 TAILQ_FOREACH(bp, &kvm_sw_breakpoints, entry) {
2554 if (bp->pc == pc)
2555 return bp;
2556 }
2557 return NULL;
2558 }
2559
2560 struct kvm_set_guest_debug_data {
2561 struct kvm_guest_debug dbg;
2562 int err;
2563 };
2564
2565 static void kvm_invoke_set_guest_debug(void *data)
2566 {
2567 struct kvm_set_guest_debug_data *dbg_data = data;
2568
2569 dbg_data->err = kvm_set_guest_debug(cpu_single_env->kvm_cpu_state.vcpu_ctx,
2570 &dbg_data->dbg);
2571 }
2572
2573 int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
2574 {
2575 struct kvm_set_guest_debug_data data;
2576
2577 data.dbg.control = 0;
2578 if (env->singlestep_enabled)
2579 data.dbg.control = KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
2580
2581 kvm_arch_update_guest_debug(env, &data.dbg);
2582 data.dbg.control |= reinject_trap;
2583
2584 on_vcpu(env, kvm_invoke_set_guest_debug, &data);
2585 return data.err;
2586 }
2587
2588 int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
2589 target_ulong len, int type)
2590 {
2591 struct kvm_sw_breakpoint *bp;
2592 CPUState *env;
2593 int err;
2594
2595 if (type == GDB_BREAKPOINT_SW) {
2596 bp = kvm_find_sw_breakpoint(addr);
2597 if (bp) {
2598 bp->use_count++;
2599 return 0;
2600 }
2601
2602 bp = qemu_malloc(sizeof(struct kvm_sw_breakpoint));
2603 if (!bp)
2604 return -ENOMEM;
2605
2606 bp->pc = addr;
2607 bp->use_count = 1;
2608 err = kvm_arch_insert_sw_breakpoint(current_env, bp);
2609 if (err) {
2610 free(bp);
2611 return err;
2612 }
2613
2614 TAILQ_INSERT_HEAD(&kvm_sw_breakpoints, bp, entry);
2615 } else {
2616 err = kvm_arch_insert_hw_breakpoint(addr, len, type);
2617 if (err)
2618 return err;
2619 }
2620
2621 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2622 err = kvm_update_guest_debug(env, 0);
2623 if (err)
2624 return err;
2625 }
2626 return 0;
2627 }
2628
2629 int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
2630 target_ulong len, int type)
2631 {
2632 struct kvm_sw_breakpoint *bp;
2633 CPUState *env;
2634 int err;
2635
2636 if (type == GDB_BREAKPOINT_SW) {
2637 bp = kvm_find_sw_breakpoint(addr);
2638 if (!bp)
2639 return -ENOENT;
2640
2641 if (bp->use_count > 1) {
2642 bp->use_count--;
2643 return 0;
2644 }
2645
2646 err = kvm_arch_remove_sw_breakpoint(current_env, bp);
2647 if (err)
2648 return err;
2649
2650 TAILQ_REMOVE(&kvm_sw_breakpoints, bp, entry);
2651 qemu_free(bp);
2652 } else {
2653 err = kvm_arch_remove_hw_breakpoint(addr, len, type);
2654 if (err)
2655 return err;
2656 }
2657
2658 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2659 err = kvm_update_guest_debug(env, 0);
2660 if (err)
2661 return err;
2662 }
2663 return 0;
2664 }
2665
2666 void kvm_remove_all_breakpoints(CPUState *current_env)
2667 {
2668 struct kvm_sw_breakpoint *bp, *next;
2669 CPUState *env;
2670
2671 TAILQ_FOREACH_SAFE(bp, &kvm_sw_breakpoints, entry, next) {
2672 if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
2673 /* Try harder to find a CPU that currently sees the breakpoint. */
2674 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2675 if (kvm_arch_remove_sw_breakpoint(env, bp) == 0)
2676 break;
2677 }
2678 }
2679 }
2680 kvm_arch_remove_all_hw_breakpoints();
2681
2682 for (env = first_cpu; env != NULL; env = env->next_cpu)
2683 kvm_update_guest_debug(env, 0);
2684 }
2685
2686 #else /* !KVM_CAP_SET_GUEST_DEBUG */
2687
2688 int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
2689 {
2690 return -EINVAL;
2691 }
2692
2693 int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
2694 target_ulong len, int type)
2695 {
2696 return -EINVAL;
2697 }
2698
2699 int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
2700 target_ulong len, int type)
2701 {
2702 return -EINVAL;
2703 }
2704
2705 void kvm_remove_all_breakpoints(CPUState *current_env)
2706 {
2707 }
2708 #endif /* !KVM_CAP_SET_GUEST_DEBUG */
2709
2710 /*
2711 * dirty pages logging
2712 */
2713 /* FIXME: use unsigned long pointer instead of unsigned char */
2714 unsigned char *kvm_dirty_bitmap = NULL;
2715 int kvm_physical_memory_set_dirty_tracking(int enable)
2716 {
2717 int r = 0;
2718
2719 if (!kvm_enabled())
2720 return 0;
2721
2722 if (enable) {
2723 if (!kvm_dirty_bitmap) {
2724 unsigned bitmap_size = BITMAP_SIZE(phys_ram_size);
2725 kvm_dirty_bitmap = qemu_malloc(bitmap_size);
2726 if (kvm_dirty_bitmap == NULL) {
2727 perror("Failed to allocate dirty pages bitmap");
2728 r=-1;
2729 }
2730 else {
2731 r = kvm_dirty_pages_log_enable_all(kvm_context);
2732 }
2733 }
2734 }
2735 else {
2736 if (kvm_dirty_bitmap) {
2737 r = kvm_dirty_pages_log_reset(kvm_context);
2738 qemu_free(kvm_dirty_bitmap);
2739 kvm_dirty_bitmap = NULL;
2740 }
2741 }
2742 return r;
2743 }
2744
2745 /* get kvm's dirty pages bitmap and update qemu's */
2746 static int kvm_get_dirty_pages_log_range(unsigned long start_addr,
2747 unsigned char *bitmap,
2748 unsigned long offset,
2749 unsigned long mem_size)
2750 {
2751 unsigned int i, j, n=0;
2752 unsigned char c;
2753 unsigned long page_number, addr, addr1;
2754 ram_addr_t ram_addr;
2755 unsigned int len = ((mem_size/TARGET_PAGE_SIZE) + 7) / 8;
2756
2757 /*
2758 * bitmap-traveling is faster than memory-traveling (for addr...)
2759 * especially when most of the memory is not dirty.
2760 */
2761 for (i=0; i<len; i++) {
2762 c = bitmap[i];
2763 while (c>0) {
2764 j = ffsl(c) - 1;
2765 c &= ~(1u<<j);
2766 page_number = i * 8 + j;
2767 addr1 = page_number * TARGET_PAGE_SIZE;
2768 addr = offset + addr1;
2769 ram_addr = cpu_get_physical_page_desc(addr);
2770 cpu_physical_memory_set_dirty(ram_addr);
2771 n++;
2772 }
2773 }
2774 return 0;
2775 }
2776 static int kvm_get_dirty_bitmap_cb(unsigned long start, unsigned long len,
2777 void *bitmap, void *opaque)
2778 {
2779 return kvm_get_dirty_pages_log_range(start, bitmap, start, len);
2780 }
2781
2782 /*
2783 * get kvm's dirty pages bitmap and update qemu's
2784 * we only care about physical ram, which resides in slots 0 and 3
2785 */
2786 int kvm_update_dirty_pages_log(void)
2787 {
2788 int r = 0;
2789
2790
2791 r = kvm_get_dirty_pages_range(kvm_context, 0, -1UL,
2792 kvm_dirty_bitmap, NULL,
2793 kvm_get_dirty_bitmap_cb);
2794 return r;
2795 }
2796
2797 void kvm_qemu_log_memory(target_phys_addr_t start, target_phys_addr_t size,
2798 int log)
2799 {
2800 if (log)
2801 kvm_dirty_pages_log_enable_slot(kvm_context, start, size);
2802 else {
2803 #ifdef TARGET_I386
2804 if (must_use_aliases_target(start))
2805 return;
2806 #endif
2807 kvm_dirty_pages_log_disable_slot(kvm_context, start, size);
2808 }
2809 }
2810
2811 int kvm_get_phys_ram_page_bitmap(unsigned char *bitmap)
2812 {
2813 unsigned int bsize = BITMAP_SIZE(phys_ram_size);
2814 unsigned int brsize = BITMAP_SIZE(ram_size);
2815 unsigned int extra_pages = (phys_ram_size - ram_size) / TARGET_PAGE_SIZE;
2816 unsigned int extra_bytes = (extra_pages +7)/8;
2817 unsigned int hole_start = BITMAP_SIZE(0xa0000);
2818 unsigned int hole_end = BITMAP_SIZE(0xc0000);
2819
2820 memset(bitmap, 0xFF, brsize + extra_bytes);
2821 memset(bitmap + hole_start, 0, hole_end - hole_start);
2822 memset(bitmap + brsize + extra_bytes, 0, bsize - brsize - extra_bytes);
2823
2824 return 0;
2825 }
2826
2827 #ifdef KVM_CAP_IRQCHIP
2828
2829 int kvm_set_irq(int irq, int level, int *status)
2830 {
2831 return kvm_set_irq_level(kvm_context, irq, level, status);
2832 }
2833
2834 #endif
2835
2836 int qemu_kvm_get_dirty_pages(unsigned long phys_addr, void *buf)
2837 {
2838 return kvm_get_dirty_pages(kvm_context, phys_addr, buf);
2839 }
2840
2841 void *kvm_cpu_create_phys_mem(target_phys_addr_t start_addr,
2842 unsigned long size, int log, int writable)
2843 {
2844 return kvm_create_phys_mem(kvm_context, start_addr, size, log, writable);
2845 }
2846
2847 void kvm_cpu_destroy_phys_mem(target_phys_addr_t start_addr,
2848 unsigned long size)
2849 {
2850 kvm_destroy_phys_mem(kvm_context, start_addr, size);
2851 }
2852
2853 void kvm_mutex_unlock(void)
2854 {
2855 assert(!cpu_single_env);
2856 pthread_mutex_unlock(&qemu_mutex);
2857 }
2858
2859 void kvm_mutex_lock(void)
2860 {
2861 pthread_mutex_lock(&qemu_mutex);
2862 cpu_single_env = NULL;
2863 }
2864
2865 int qemu_kvm_register_coalesced_mmio(target_phys_addr_t addr, unsigned int size)
2866 {
2867 return kvm_register_coalesced_mmio(kvm_context, addr, size);
2868 }
2869
2870 int qemu_kvm_unregister_coalesced_mmio(target_phys_addr_t addr,
2871 unsigned int size)
2872 {
2873 return kvm_unregister_coalesced_mmio(kvm_context, addr, size);
2874 }
2875
2876 int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
2877 {
2878 return kvm_register_coalesced_mmio(kvm_context, start, size);
2879 }
2880
2881 int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
2882 {
2883 return kvm_unregister_coalesced_mmio(kvm_context, start, size);
2884 }
2885
2886 #ifdef USE_KVM_DEVICE_ASSIGNMENT
2887 void kvm_add_ioperm_data(struct ioperm_data *data)
2888 {
2889 LIST_INSERT_HEAD(&ioperm_head, data, entries);
2890 }
2891
2892 void kvm_remove_ioperm_data(unsigned long start_port, unsigned long num)
2893 {
2894 struct ioperm_data *data;
2895
2896 data = LIST_FIRST(&ioperm_head);
2897 while (data) {
2898 struct ioperm_data *next = LIST_NEXT(data, entries);
2899
2900 if (data->start_port == start_port && data->num == num) {
2901 LIST_REMOVE(data, entries);
2902 qemu_free(data);
2903 }
2904
2905 data = next;
2906 }
2907 }
2908
2909 void kvm_ioperm(CPUState *env, void *data)
2910 {
2911 if (kvm_enabled() && qemu_system_ready)
2912 on_vcpu(env, kvm_arch_do_ioperm, data);
2913 }
2914
2915 #endif
2916
2917 int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr, target_phys_addr_t end_addr)
2918 {
2919 #ifndef TARGET_IA64
2920 void *buf;
2921
2922 #ifdef TARGET_I386
2923 if (must_use_aliases_source(start_addr))
2924 return 0;
2925 #endif
2926
2927 buf = qemu_malloc((end_addr - start_addr) / 8 + 2);
2928 kvm_get_dirty_pages_range(kvm_context, start_addr, end_addr - start_addr,
2929 buf, NULL, kvm_get_dirty_bitmap_cb);
2930 qemu_free(buf);
2931 #endif
2932 return 0;
2933 }
2934
2935 int kvm_log_start(target_phys_addr_t phys_addr, target_phys_addr_t len)
2936 {
2937 #ifdef TARGET_I386
2938 if (must_use_aliases_source(phys_addr))
2939 return 0;
2940 #endif
2941
2942 #ifndef TARGET_IA64
2943 kvm_qemu_log_memory(phys_addr, len, 1);
2944 #endif
2945 return 0;
2946 }
2947
2948 int kvm_log_stop(target_phys_addr_t phys_addr, target_phys_addr_t len)
2949 {
2950 #ifdef TARGET_I386
2951 if (must_use_aliases_source(phys_addr))
2952 return 0;
2953 #endif
2954
2955 #ifndef TARGET_IA64
2956 kvm_qemu_log_memory(phys_addr, len, 0);
2957 #endif
2958 return 0;
2959 }
2960
2961 void qemu_kvm_cpu_stop(CPUState *env)
2962 {
2963 if (kvm_enabled())
2964 env->kvm_cpu_state.stopped = 1;
2965 }
Patches shipped by Fedora