?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Rename kvm_(load|save)_mpstate to kvm_arch_(load|save)_mpstate
[qemu-kvm/fedora.git] / qemu-kvm.c
blob60e2e767d19c64c472e46371bc7d8441b5560641
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 if (env->exit_request)
1680 return 1;
1681 pthread_mutex_unlock(&qemu_mutex);
1682 return 0;
1683 }
1684
1685 static void kvm_do_load_registers(void *_env)
1686 {
1687 CPUState *env = _env;
1688
1689 kvm_arch_load_regs(env);
1690 }
1691
1692 void kvm_load_registers(CPUState *env)
1693 {
1694 if (kvm_enabled() && qemu_system_ready)
1695 on_vcpu(env, kvm_do_load_registers, env);
1696 }
1697
1698 static void kvm_do_save_registers(void *_env)
1699 {
1700 CPUState *env = _env;
1701
1702 kvm_arch_save_regs(env);
1703 }
1704
1705 void kvm_save_registers(CPUState *env)
1706 {
1707 if (kvm_enabled())
1708 on_vcpu(env, kvm_do_save_registers, env);
1709 }
1710
1711 int kvm_cpu_exec(CPUState *env)
1712 {
1713 int r;
1714
1715 r = kvm_run(env->kvm_cpu_state.vcpu_ctx, env);
1716 if (r < 0) {
1717 printf("kvm_run returned %d\n", r);
1718 vm_stop(0);
1719 }
1720
1721 return 0;
1722 }
1723
1724 static int has_work(CPUState *env)
1725 {
1726 if (!vm_running || (env && env->kvm_cpu_state.stopped))
1727 return 0;
1728 if (kvm_irqchip_in_kernel(kvm_context))
1729 return 1;
1730 if (!env->halted)
1731 return 1;
1732 return kvm_arch_has_work(env);
1733 }
1734
1735 static void flush_queued_work(CPUState *env)
1736 {
1737 struct qemu_work_item *wi;
1738
1739 if (!env->kvm_cpu_state.queued_work_first)
1740 return;
1741
1742 while ((wi = env->kvm_cpu_state.queued_work_first)) {
1743 env->kvm_cpu_state.queued_work_first = wi->next;
1744 wi->func(wi->data);
1745 wi->done = true;
1746 }
1747 env->kvm_cpu_state.queued_work_last = NULL;
1748 pthread_cond_broadcast(&qemu_work_cond);
1749 }
1750
1751 static void kvm_main_loop_wait(CPUState *env, int timeout)
1752 {
1753 struct timespec ts;
1754 int r, e;
1755 siginfo_t siginfo;
1756 sigset_t waitset;
1757
1758 pthread_mutex_unlock(&qemu_mutex);
1759
1760 ts.tv_sec = timeout / 1000;
1761 ts.tv_nsec = (timeout % 1000) * 1000000;
1762 sigemptyset(&waitset);
1763 sigaddset(&waitset, SIG_IPI);
1764
1765 r = sigtimedwait(&waitset, &siginfo, &ts);
1766 e = errno;
1767
1768 pthread_mutex_lock(&qemu_mutex);
1769
1770 if (r == -1 && !(e == EAGAIN || e == EINTR)) {
1771 printf("sigtimedwait: %s\n", strerror(e));
1772 exit(1);
1773 }
1774
1775 cpu_single_env = env;
1776 flush_queued_work(env);
1777
1778 if (env->kvm_cpu_state.stop) {
1779 env->kvm_cpu_state.stop = 0;
1780 env->kvm_cpu_state.stopped = 1;
1781 pthread_cond_signal(&qemu_pause_cond);
1782 }
1783
1784 env->kvm_cpu_state.signalled = 0;
1785 }
1786
1787 static int all_threads_paused(void)
1788 {
1789 CPUState *penv = first_cpu;
1790
1791 while (penv) {
1792 if (penv->kvm_cpu_state.stop)
1793 return 0;
1794 penv = (CPUState *)penv->next_cpu;
1795 }
1796
1797 return 1;
1798 }
1799
1800 static void pause_all_threads(void)
1801 {
1802 CPUState *penv = first_cpu;
1803
1804 while (penv) {
1805 if (penv != cpu_single_env) {
1806 penv->kvm_cpu_state.stop = 1;
1807 pthread_kill(penv->kvm_cpu_state.thread, SIG_IPI);
1808 } else {
1809 penv->kvm_cpu_state.stop = 0;
1810 penv->kvm_cpu_state.stopped = 1;
1811 cpu_exit(penv);
1812 }
1813 penv = (CPUState *)penv->next_cpu;
1814 }
1815
1816 while (!all_threads_paused())
1817 qemu_cond_wait(&qemu_pause_cond);
1818 }
1819
1820 static void resume_all_threads(void)
1821 {
1822 CPUState *penv = first_cpu;
1823
1824 assert(!cpu_single_env);
1825
1826 while (penv) {
1827 penv->kvm_cpu_state.stop = 0;
1828 penv->kvm_cpu_state.stopped = 0;
1829 pthread_kill(penv->kvm_cpu_state.thread, SIG_IPI);
1830 penv = (CPUState *)penv->next_cpu;
1831 }
1832 }
1833
1834 static void kvm_vm_state_change_handler(void *context, int running, int reason)
1835 {
1836 if (running)
1837 resume_all_threads();
1838 else
1839 pause_all_threads();
1840 }
1841
1842 static void update_regs_for_sipi(CPUState *env)
1843 {
1844 kvm_arch_update_regs_for_sipi(env);
1845 env->kvm_cpu_state.sipi_needed = 0;
1846 }
1847
1848 static void update_regs_for_init(CPUState *env)
1849 {
1850 #ifdef TARGET_I386
1851 SegmentCache cs = env->segs[R_CS];
1852 #endif
1853
1854 cpu_reset(env);
1855
1856 #ifdef TARGET_I386
1857 /* restore SIPI vector */
1858 if(env->kvm_cpu_state.sipi_needed)
1859 env->segs[R_CS] = cs;
1860 #endif
1861
1862 env->kvm_cpu_state.init = 0;
1863 kvm_arch_load_regs(env);
1864 }
1865
1866 static void setup_kernel_sigmask(CPUState *env)
1867 {
1868 sigset_t set;
1869
1870 sigemptyset(&set);
1871 sigaddset(&set, SIGUSR2);
1872 sigaddset(&set, SIGIO);
1873 sigaddset(&set, SIGALRM);
1874 sigprocmask(SIG_BLOCK, &set, NULL);
1875
1876 sigprocmask(SIG_BLOCK, NULL, &set);
1877 sigdelset(&set, SIG_IPI);
1878
1879 kvm_set_signal_mask(env->kvm_cpu_state.vcpu_ctx, &set);
1880 }
1881
1882 static void qemu_kvm_system_reset(void)
1883 {
1884 CPUState *penv = first_cpu;
1885
1886 pause_all_threads();
1887
1888 qemu_system_reset();
1889
1890 while (penv) {
1891 kvm_arch_cpu_reset(penv);
1892 penv = (CPUState *)penv->next_cpu;
1893 }
1894
1895 resume_all_threads();
1896 }
1897
1898 static int kvm_main_loop_cpu(CPUState *env)
1899 {
1900 setup_kernel_sigmask(env);
1901
1902 pthread_mutex_lock(&qemu_mutex);
1903
1904 kvm_qemu_init_env(env);
1905 #ifdef TARGET_I386
1906 kvm_tpr_vcpu_start(env);
1907 #endif
1908
1909 cpu_single_env = env;
1910 kvm_arch_load_regs(env);
1911
1912 while (1) {
1913 while (!has_work(env))
1914 kvm_main_loop_wait(env, 1000);
1915 if (env->interrupt_request & (CPU_INTERRUPT_HARD | CPU_INTERRUPT_NMI))
1916 env->halted = 0;
1917 if (!kvm_irqchip_in_kernel(kvm_context)) {
1918 if (env->kvm_cpu_state.init)
1919 update_regs_for_init(env);
1920 if (env->kvm_cpu_state.sipi_needed)
1921 update_regs_for_sipi(env);
1922 }
1923 if (!env->halted || kvm_irqchip_in_kernel(kvm_context))
1924 kvm_cpu_exec(env);
1925 env->exit_request = 0;
1926 env->exception_index = EXCP_INTERRUPT;
1927 kvm_main_loop_wait(env, 0);
1928 }
1929 pthread_mutex_unlock(&qemu_mutex);
1930 return 0;
1931 }
1932
1933 static void *ap_main_loop(void *_env)
1934 {
1935 CPUState *env = _env;
1936 sigset_t signals;
1937 struct ioperm_data *data = NULL;
1938
1939 current_env = env;
1940 env->thread_id = kvm_get_thread_id();
1941 sigfillset(&signals);
1942 sigprocmask(SIG_BLOCK, &signals, NULL);
1943 env->kvm_cpu_state.vcpu_ctx = kvm_create_vcpu(kvm_context, env->cpu_index);
1944
1945 #ifdef USE_KVM_DEVICE_ASSIGNMENT
1946 /* do ioperm for io ports of assigned devices */
1947 LIST_FOREACH(data, &ioperm_head, entries)
1948 on_vcpu(env, kvm_arch_do_ioperm, data);
1949 #endif
1950
1951 /* signal VCPU creation */
1952 pthread_mutex_lock(&qemu_mutex);
1953 current_env->kvm_cpu_state.created = 1;
1954 pthread_cond_signal(&qemu_vcpu_cond);
1955
1956 /* and wait for machine initialization */
1957 while (!qemu_system_ready)
1958 qemu_cond_wait(&qemu_system_cond);
1959 pthread_mutex_unlock(&qemu_mutex);
1960
1961 kvm_main_loop_cpu(env);
1962 return NULL;
1963 }
1964
1965 void kvm_init_vcpu(CPUState *env)
1966 {
1967 pthread_create(&env->kvm_cpu_state.thread, NULL, ap_main_loop, env);
1968
1969 while (env->kvm_cpu_state.created == 0)
1970 qemu_cond_wait(&qemu_vcpu_cond);
1971 }
1972
1973 int kvm_vcpu_inited(CPUState *env)
1974 {
1975 return env->kvm_cpu_state.created;
1976 }
1977
1978 int kvm_init_ap(void)
1979 {
1980 #ifdef TARGET_I386
1981 kvm_tpr_opt_setup();
1982 #endif
1983 qemu_add_vm_change_state_handler(kvm_vm_state_change_handler, NULL);
1984
1985 signal(SIG_IPI, sig_ipi_handler);
1986 return 0;
1987 }
1988
1989 void qemu_kvm_notify_work(void)
1990 {
1991 uint64_t value = 1;
1992 char buffer[8];
1993 size_t offset = 0;
1994
1995 if (io_thread_fd == -1)
1996 return;
1997
1998 memcpy(buffer, &value, sizeof(value));
1999
2000 while (offset < 8) {
2001 ssize_t len;
2002
2003 len = write(io_thread_fd, buffer + offset, 8 - offset);
2004 if (len == -1 && errno == EINTR)
2005 continue;
2006
2007 if (len <= 0)
2008 break;
2009
2010 offset += len;
2011 }
2012
2013 if (offset != 8)
2014 fprintf(stderr, "failed to notify io thread\n");
2015 }
2016
2017 /* If we have signalfd, we mask out the signals we want to handle and then
2018 * use signalfd to listen for them. We rely on whatever the current signal
2019 * handler is to dispatch the signals when we receive them.
2020 */
2021
2022 static void sigfd_handler(void *opaque)
2023 {
2024 int fd = (unsigned long)opaque;
2025 struct qemu_signalfd_siginfo info;
2026 struct sigaction action;
2027 ssize_t len;
2028
2029 while (1) {
2030 do {
2031 len = read(fd, &info, sizeof(info));
2032 } while (len == -1 && errno == EINTR);
2033
2034 if (len == -1 && errno == EAGAIN)
2035 break;
2036
2037 if (len != sizeof(info)) {
2038 printf("read from sigfd returned %zd: %m\n", len);
2039 return;
2040 }
2041
2042 sigaction(info.ssi_signo, NULL, &action);
2043 if (action.sa_handler)
2044 action.sa_handler(info.ssi_signo);
2045
2046 }
2047 }
2048
2049 /* Used to break IO thread out of select */
2050 static void io_thread_wakeup(void *opaque)
2051 {
2052 int fd = (unsigned long)opaque;
2053 char buffer[8];
2054 size_t offset = 0;
2055
2056 while (offset < 8) {
2057 ssize_t len;
2058
2059 len = read(fd, buffer + offset, 8 - offset);
2060 if (len == -1 && errno == EINTR)
2061 continue;
2062
2063 if (len <= 0)
2064 break;
2065
2066 offset += len;
2067 }
2068 }
2069
2070 int kvm_main_loop(void)
2071 {
2072 int fds[2];
2073 sigset_t mask;
2074 int sigfd;
2075
2076 io_thread = pthread_self();
2077 qemu_system_ready = 1;
2078
2079 if (qemu_eventfd(fds) == -1) {
2080 fprintf(stderr, "failed to create eventfd\n");
2081 return -errno;
2082 }
2083
2084 qemu_set_fd_handler2(fds[0], NULL, io_thread_wakeup, NULL,
2085 (void *)(unsigned long)fds[0]);
2086
2087 io_thread_fd = fds[1];
2088
2089 sigemptyset(&mask);
2090 sigaddset(&mask, SIGIO);
2091 sigaddset(&mask, SIGALRM);
2092 sigprocmask(SIG_BLOCK, &mask, NULL);
2093
2094 sigfd = qemu_signalfd(&mask);
2095 if (sigfd == -1) {
2096 fprintf(stderr, "failed to create signalfd\n");
2097 return -errno;
2098 }
2099
2100 fcntl(sigfd, F_SETFL, O_NONBLOCK);
2101
2102 qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
2103 (void *)(unsigned long)sigfd);
2104
2105 pthread_cond_broadcast(&qemu_system_cond);
2106
2107 io_thread_sigfd = sigfd;
2108 cpu_single_env = NULL;
2109
2110 while (1) {
2111 main_loop_wait(1000);
2112 if (qemu_shutdown_requested()) {
2113 if (qemu_no_shutdown()) {
2114 vm_stop(0);
2115 } else
2116 break;
2117 } else if (qemu_powerdown_requested())
2118 qemu_system_powerdown();
2119 else if (qemu_reset_requested())
2120 qemu_kvm_system_reset();
2121 else if (kvm_debug_cpu_requested) {
2122 gdb_set_stop_cpu(kvm_debug_cpu_requested);
2123 vm_stop(EXCP_DEBUG);
2124 kvm_debug_cpu_requested = NULL;
2125 }
2126 }
2127
2128 pause_all_threads();
2129 pthread_mutex_unlock(&qemu_mutex);
2130
2131 return 0;
2132 }
2133
2134 #ifdef KVM_CAP_SET_GUEST_DEBUG
2135 static int kvm_debug(void *opaque, void *data,
2136 struct kvm_debug_exit_arch *arch_info)
2137 {
2138 int handle = kvm_arch_debug(arch_info);
2139 CPUState *env = data;
2140
2141 if (handle) {
2142 kvm_debug_cpu_requested = env;
2143 env->kvm_cpu_state.stopped = 1;
2144 }
2145 return handle;
2146 }
2147 #endif
2148
2149 static int kvm_inb(void *opaque, uint16_t addr, uint8_t *data)
2150 {
2151 *data = cpu_inb(0, addr);
2152 return 0;
2153 }
2154
2155 static int kvm_inw(void *opaque, uint16_t addr, uint16_t *data)
2156 {
2157 *data = cpu_inw(0, addr);
2158 return 0;
2159 }
2160
2161 static int kvm_inl(void *opaque, uint16_t addr, uint32_t *data)
2162 {
2163 *data = cpu_inl(0, addr);
2164 return 0;
2165 }
2166
2167 #define PM_IO_BASE 0xb000
2168
2169 static int kvm_outb(void *opaque, uint16_t addr, uint8_t data)
2170 {
2171 if (addr == 0xb2) {
2172 switch (data) {
2173 case 0: {
2174 cpu_outb(0, 0xb3, 0);
2175 break;
2176 }
2177 case 0xf0: {
2178 unsigned x;
2179
2180 /* enable acpi */
2181 x = cpu_inw(0, PM_IO_BASE + 4);
2182 x &= ~1;
2183 cpu_outw(0, PM_IO_BASE + 4, x);
2184 break;
2185 }
2186 case 0xf1: {
2187 unsigned x;
2188
2189 /* enable acpi */
2190 x = cpu_inw(0, PM_IO_BASE + 4);
2191 x |= 1;
2192 cpu_outw(0, PM_IO_BASE + 4, x);
2193 break;
2194 }
2195 default:
2196 break;
2197 }
2198 return 0;
2199 }
2200 cpu_outb(0, addr, data);
2201 return 0;
2202 }
2203
2204 static int kvm_outw(void *opaque, uint16_t addr, uint16_t data)
2205 {
2206 cpu_outw(0, addr, data);
2207 return 0;
2208 }
2209
2210 static int kvm_outl(void *opaque, uint16_t addr, uint32_t data)
2211 {
2212 cpu_outl(0, addr, data);
2213 return 0;
2214 }
2215
2216 static int kvm_mmio_read(void *opaque, uint64_t addr, uint8_t *data, int len)
2217 {
2218 cpu_physical_memory_rw(addr, data, len, 0);
2219 return 0;
2220 }
2221
2222 static int kvm_mmio_write(void *opaque, uint64_t addr, uint8_t *data, int len)
2223 {
2224 cpu_physical_memory_rw(addr, data, len, 1);
2225 return 0;
2226 }
2227
2228 static int kvm_io_window(void *opaque)
2229 {
2230 return 1;
2231 }
2232
2233
2234 static int kvm_halt(void *opaque, kvm_vcpu_context_t vcpu)
2235 {
2236 return kvm_arch_halt(opaque, vcpu);
2237 }
2238
2239 static int kvm_shutdown(void *opaque, void *data)
2240 {
2241 CPUState *env = (CPUState *)data;
2242
2243 /* stop the current vcpu from going back to guest mode */
2244 env->kvm_cpu_state.stopped = 1;
2245
2246 qemu_system_reset_request();
2247 return 1;
2248 }
2249
2250 static int handle_unhandled(kvm_context_t kvm, kvm_vcpu_context_t vcpu,
2251 uint64_t reason)
2252 {
2253 fprintf(stderr, "kvm: unhandled exit %"PRIx64"\n", reason);
2254 return -EINVAL;
2255 }
2256
2257 static struct kvm_callbacks qemu_kvm_ops = {
2258 #ifdef KVM_CAP_SET_GUEST_DEBUG
2259 .debug = kvm_debug,
2260 #endif
2261 .inb = kvm_inb,
2262 .inw = kvm_inw,
2263 .inl = kvm_inl,
2264 .outb = kvm_outb,
2265 .outw = kvm_outw,
2266 .outl = kvm_outl,
2267 .mmio_read = kvm_mmio_read,
2268 .mmio_write = kvm_mmio_write,
2269 .halt = kvm_halt,
2270 .shutdown = kvm_shutdown,
2271 .io_window = kvm_io_window,
2272 .try_push_interrupts = kvm_try_push_interrupts,
2273 #ifdef KVM_CAP_USER_NMI
2274 .push_nmi = kvm_arch_push_nmi,
2275 #endif
2276 .post_kvm_run = kvm_post_run,
2277 .pre_kvm_run = kvm_pre_run,
2278 #ifdef TARGET_I386
2279 .tpr_access = handle_tpr_access,
2280 #endif
2281 #ifdef TARGET_PPC
2282 .powerpc_dcr_read = handle_powerpc_dcr_read,
2283 .powerpc_dcr_write = handle_powerpc_dcr_write,
2284 #endif
2285 .unhandled = handle_unhandled,
2286 };
2287
2288 int kvm_qemu_init()
2289 {
2290 /* Try to initialize kvm */
2291 kvm_context = kvm_init(&qemu_kvm_ops, cpu_single_env);
2292 if (!kvm_context) {
2293 return -1;
2294 }
2295 pthread_mutex_lock(&qemu_mutex);
2296
2297 return 0;
2298 }
2299
2300 #ifdef TARGET_I386
2301 static int destroy_region_works = 0;
2302 #endif
2303
2304
2305 #if !defined(TARGET_I386)
2306 int kvm_arch_init_irq_routing(void)
2307 {
2308 return 0;
2309 }
2310 #endif
2311
2312 int kvm_qemu_create_context(void)
2313 {
2314 int r;
2315
2316 if (!kvm_irqchip) {
2317 kvm_disable_irqchip_creation(kvm_context);
2318 }
2319 if (!kvm_pit) {
2320 kvm_disable_pit_creation(kvm_context);
2321 }
2322 if (kvm_create(kvm_context, 0, NULL) < 0) {
2323 kvm_qemu_destroy();
2324 return -1;
2325 }
2326 r = kvm_arch_qemu_create_context();
2327 if(r <0)
2328 kvm_qemu_destroy();
2329 if (kvm_pit && !kvm_pit_reinject) {
2330 if (kvm_reinject_control(kvm_context, 0)) {
2331 fprintf(stderr, "failure to disable in-kernel PIT reinjection\n");
2332 return -1;
2333 }
2334 }
2335 #ifdef TARGET_I386
2336 destroy_region_works = kvm_destroy_memory_region_works(kvm_context);
2337 #endif
2338
2339 r = kvm_arch_init_irq_routing();
2340 if (r < 0) {
2341 return r;
2342 }
2343
2344 return 0;
2345 }
2346
2347 void kvm_qemu_destroy(void)
2348 {
2349 kvm_finalize(kvm_context);
2350 }
2351
2352 #ifdef TARGET_I386
2353 static int must_use_aliases_source(target_phys_addr_t addr)
2354 {
2355 if (destroy_region_works)
2356 return false;
2357 if (addr == 0xa0000 || addr == 0xa8000)
2358 return true;
2359 return false;
2360 }
2361
2362 static int must_use_aliases_target(target_phys_addr_t addr)
2363 {
2364 if (destroy_region_works)
2365 return false;
2366 if (addr >= 0xe0000000 && addr < 0x100000000ull)
2367 return true;
2368 return false;
2369 }
2370
2371 static struct mapping {
2372 target_phys_addr_t phys;
2373 ram_addr_t ram;
2374 ram_addr_t len;
2375 } mappings[50];
2376 static int nr_mappings;
2377
2378 static struct mapping *find_ram_mapping(ram_addr_t ram_addr)
2379 {
2380 struct mapping *p;
2381
2382 for (p = mappings; p < mappings + nr_mappings; ++p) {
2383 if (p->ram <= ram_addr && ram_addr < p->ram + p->len) {
2384 return p;
2385 }
2386 }
2387 return NULL;
2388 }
2389
2390 static struct mapping *find_mapping(target_phys_addr_t start_addr)
2391 {
2392 struct mapping *p;
2393
2394 for (p = mappings; p < mappings + nr_mappings; ++p) {
2395 if (p->phys <= start_addr && start_addr < p->phys + p->len) {
2396 return p;
2397 }
2398 }
2399 return NULL;
2400 }
2401
2402 static void drop_mapping(target_phys_addr_t start_addr)
2403 {
2404 struct mapping *p = find_mapping(start_addr);
2405
2406 if (p)
2407 *p = mappings[--nr_mappings];
2408 }
2409 #endif
2410
2411 void kvm_cpu_register_physical_memory(target_phys_addr_t start_addr,
2412 unsigned long size,
2413 unsigned long phys_offset)
2414 {
2415 int r = 0;
2416 unsigned long area_flags;
2417 #ifdef TARGET_I386
2418 struct mapping *p;
2419 #endif
2420
2421 if (start_addr + size > phys_ram_size) {
2422 phys_ram_size = start_addr + size;
2423 }
2424
2425 phys_offset &= ~IO_MEM_ROM;
2426 area_flags = phys_offset & ~TARGET_PAGE_MASK;
2427
2428 if (area_flags != IO_MEM_RAM) {
2429 #ifdef TARGET_I386
2430 if (must_use_aliases_source(start_addr)) {
2431 kvm_destroy_memory_alias(kvm_context, start_addr);
2432 return;
2433 }
2434 if (must_use_aliases_target(start_addr))
2435 return;
2436 #endif
2437 while (size > 0) {
2438 p = find_mapping(start_addr);
2439 if (p) {
2440 kvm_unregister_memory_area(kvm_context, p->phys, p->len);
2441 drop_mapping(p->phys);
2442 }
2443 start_addr += TARGET_PAGE_SIZE;
2444 if (size > TARGET_PAGE_SIZE) {
2445 size -= TARGET_PAGE_SIZE;
2446 } else {
2447 size = 0;
2448 }
2449 }
2450 return;
2451 }
2452
2453 r = kvm_is_containing_region(kvm_context, start_addr, size);
2454 if (r)
2455 return;
2456
2457 if (area_flags >= TLB_MMIO)
2458 return;
2459
2460 #ifdef TARGET_I386
2461 if (must_use_aliases_source(start_addr)) {
2462 p = find_ram_mapping(phys_offset);
2463 if (p) {
2464 kvm_create_memory_alias(kvm_context, start_addr, size,
2465 p->phys + (phys_offset - p->ram));
2466 }
2467 return;
2468 }
2469 #endif
2470
2471 r = kvm_register_phys_mem(kvm_context, start_addr,
2472 qemu_get_ram_ptr(phys_offset),
2473 size, 0);
2474 if (r < 0) {
2475 printf("kvm_cpu_register_physical_memory: failed\n");
2476 exit(1);
2477 }
2478
2479 #ifdef TARGET_I386
2480 drop_mapping(start_addr);
2481 p = &mappings[nr_mappings++];
2482 p->phys = start_addr;
2483 p->ram = phys_offset;
2484 p->len = size;
2485 #endif
2486
2487 return;
2488 }
2489
2490 void kvm_cpu_unregister_physical_memory(target_phys_addr_t start_addr,
2491 target_phys_addr_t size,
2492 unsigned long phys_offset)
2493 {
2494 kvm_unregister_memory_area(kvm_context, start_addr, size);
2495 }
2496
2497 int kvm_setup_guest_memory(void *area, unsigned long size)
2498 {
2499 int ret = 0;
2500
2501 #ifdef MADV_DONTFORK
2502 if (kvm_enabled() && !kvm_has_sync_mmu())
2503 ret = madvise(area, size, MADV_DONTFORK);
2504 #endif
2505
2506 if (ret)
2507 perror ("madvise");
2508
2509 return ret;
2510 }
2511
2512 int kvm_qemu_check_extension(int ext)
2513 {
2514 return kvm_check_extension(kvm_context, ext);
2515 }
2516
2517 int kvm_qemu_init_env(CPUState *cenv)
2518 {
2519 return kvm_arch_qemu_init_env(cenv);
2520 }
2521
2522 #ifdef KVM_CAP_SET_GUEST_DEBUG
2523 struct kvm_sw_breakpoint_head kvm_sw_breakpoints =
2524 TAILQ_HEAD_INITIALIZER(kvm_sw_breakpoints);
2525
2526 struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(target_ulong pc)
2527 {
2528 struct kvm_sw_breakpoint *bp;
2529
2530 TAILQ_FOREACH(bp, &kvm_sw_breakpoints, entry) {
2531 if (bp->pc == pc)
2532 return bp;
2533 }
2534 return NULL;
2535 }
2536
2537 struct kvm_set_guest_debug_data {
2538 struct kvm_guest_debug dbg;
2539 int err;
2540 };
2541
2542 static void kvm_invoke_set_guest_debug(void *data)
2543 {
2544 struct kvm_set_guest_debug_data *dbg_data = data;
2545
2546 dbg_data->err = kvm_set_guest_debug(cpu_single_env->kvm_cpu_state.vcpu_ctx,
2547 &dbg_data->dbg);
2548 }
2549
2550 int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
2551 {
2552 struct kvm_set_guest_debug_data data;
2553
2554 data.dbg.control = 0;
2555 if (env->singlestep_enabled)
2556 data.dbg.control = KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
2557
2558 kvm_arch_update_guest_debug(env, &data.dbg);
2559 data.dbg.control |= reinject_trap;
2560
2561 on_vcpu(env, kvm_invoke_set_guest_debug, &data);
2562 return data.err;
2563 }
2564
2565 int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
2566 target_ulong len, int type)
2567 {
2568 struct kvm_sw_breakpoint *bp;
2569 CPUState *env;
2570 int err;
2571
2572 if (type == GDB_BREAKPOINT_SW) {
2573 bp = kvm_find_sw_breakpoint(addr);
2574 if (bp) {
2575 bp->use_count++;
2576 return 0;
2577 }
2578
2579 bp = qemu_malloc(sizeof(struct kvm_sw_breakpoint));
2580 if (!bp)
2581 return -ENOMEM;
2582
2583 bp->pc = addr;
2584 bp->use_count = 1;
2585 err = kvm_arch_insert_sw_breakpoint(current_env, bp);
2586 if (err) {
2587 free(bp);
2588 return err;
2589 }
2590
2591 TAILQ_INSERT_HEAD(&kvm_sw_breakpoints, bp, entry);
2592 } else {
2593 err = kvm_arch_insert_hw_breakpoint(addr, len, type);
2594 if (err)
2595 return err;
2596 }
2597
2598 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2599 err = kvm_update_guest_debug(env, 0);
2600 if (err)
2601 return err;
2602 }
2603 return 0;
2604 }
2605
2606 int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
2607 target_ulong len, int type)
2608 {
2609 struct kvm_sw_breakpoint *bp;
2610 CPUState *env;
2611 int err;
2612
2613 if (type == GDB_BREAKPOINT_SW) {
2614 bp = kvm_find_sw_breakpoint(addr);
2615 if (!bp)
2616 return -ENOENT;
2617
2618 if (bp->use_count > 1) {
2619 bp->use_count--;
2620 return 0;
2621 }
2622
2623 err = kvm_arch_remove_sw_breakpoint(current_env, bp);
2624 if (err)
2625 return err;
2626
2627 TAILQ_REMOVE(&kvm_sw_breakpoints, bp, entry);
2628 qemu_free(bp);
2629 } else {
2630 err = kvm_arch_remove_hw_breakpoint(addr, len, type);
2631 if (err)
2632 return err;
2633 }
2634
2635 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2636 err = kvm_update_guest_debug(env, 0);
2637 if (err)
2638 return err;
2639 }
2640 return 0;
2641 }
2642
2643 void kvm_remove_all_breakpoints(CPUState *current_env)
2644 {
2645 struct kvm_sw_breakpoint *bp, *next;
2646 CPUState *env;
2647
2648 TAILQ_FOREACH_SAFE(bp, &kvm_sw_breakpoints, entry, next) {
2649 if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
2650 /* Try harder to find a CPU that currently sees the breakpoint. */
2651 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2652 if (kvm_arch_remove_sw_breakpoint(env, bp) == 0)
2653 break;
2654 }
2655 }
2656 }
2657 kvm_arch_remove_all_hw_breakpoints();
2658
2659 for (env = first_cpu; env != NULL; env = env->next_cpu)
2660 kvm_update_guest_debug(env, 0);
2661 }
2662
2663 #else /* !KVM_CAP_SET_GUEST_DEBUG */
2664
2665 int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
2666 {
2667 return -EINVAL;
2668 }
2669
2670 int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
2671 target_ulong len, int type)
2672 {
2673 return -EINVAL;
2674 }
2675
2676 int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
2677 target_ulong len, int type)
2678 {
2679 return -EINVAL;
2680 }
2681
2682 void kvm_remove_all_breakpoints(CPUState *current_env)
2683 {
2684 }
2685 #endif /* !KVM_CAP_SET_GUEST_DEBUG */
2686
2687 /*
2688 * dirty pages logging
2689 */
2690 /* FIXME: use unsigned long pointer instead of unsigned char */
2691 unsigned char *kvm_dirty_bitmap = NULL;
2692 int kvm_physical_memory_set_dirty_tracking(int enable)
2693 {
2694 int r = 0;
2695
2696 if (!kvm_enabled())
2697 return 0;
2698
2699 if (enable) {
2700 if (!kvm_dirty_bitmap) {
2701 unsigned bitmap_size = BITMAP_SIZE(phys_ram_size);
2702 kvm_dirty_bitmap = qemu_malloc(bitmap_size);
2703 if (kvm_dirty_bitmap == NULL) {
2704 perror("Failed to allocate dirty pages bitmap");
2705 r=-1;
2706 }
2707 else {
2708 r = kvm_dirty_pages_log_enable_all(kvm_context);
2709 }
2710 }
2711 }
2712 else {
2713 if (kvm_dirty_bitmap) {
2714 r = kvm_dirty_pages_log_reset(kvm_context);
2715 qemu_free(kvm_dirty_bitmap);
2716 kvm_dirty_bitmap = NULL;
2717 }
2718 }
2719 return r;
2720 }
2721
2722 /* get kvm's dirty pages bitmap and update qemu's */
2723 static int kvm_get_dirty_pages_log_range(unsigned long start_addr,
2724 unsigned char *bitmap,
2725 unsigned long offset,
2726 unsigned long mem_size)
2727 {
2728 unsigned int i, j, n=0;
2729 unsigned char c;
2730 unsigned long page_number, addr, addr1;
2731 ram_addr_t ram_addr;
2732 unsigned int len = ((mem_size/TARGET_PAGE_SIZE) + 7) / 8;
2733
2734 /*
2735 * bitmap-traveling is faster than memory-traveling (for addr...)
2736 * especially when most of the memory is not dirty.
2737 */
2738 for (i=0; i<len; i++) {
2739 c = bitmap[i];
2740 while (c>0) {
2741 j = ffsl(c) - 1;
2742 c &= ~(1u<<j);
2743 page_number = i * 8 + j;
2744 addr1 = page_number * TARGET_PAGE_SIZE;
2745 addr = offset + addr1;
2746 ram_addr = cpu_get_physical_page_desc(addr);
2747 cpu_physical_memory_set_dirty(ram_addr);
2748 n++;
2749 }
2750 }
2751 return 0;
2752 }
2753 static int kvm_get_dirty_bitmap_cb(unsigned long start, unsigned long len,
2754 void *bitmap, void *opaque)
2755 {
2756 return kvm_get_dirty_pages_log_range(start, bitmap, start, len);
2757 }
2758
2759 /*
2760 * get kvm's dirty pages bitmap and update qemu's
2761 * we only care about physical ram, which resides in slots 0 and 3
2762 */
2763 int kvm_update_dirty_pages_log(void)
2764 {
2765 int r = 0;
2766
2767
2768 r = kvm_get_dirty_pages_range(kvm_context, 0, -1UL,
2769 kvm_dirty_bitmap, NULL,
2770 kvm_get_dirty_bitmap_cb);
2771 return r;
2772 }
2773
2774 void kvm_qemu_log_memory(target_phys_addr_t start, target_phys_addr_t size,
2775 int log)
2776 {
2777 if (log)
2778 kvm_dirty_pages_log_enable_slot(kvm_context, start, size);
2779 else {
2780 #ifdef TARGET_I386
2781 if (must_use_aliases_target(start))
2782 return;
2783 #endif
2784 kvm_dirty_pages_log_disable_slot(kvm_context, start, size);
2785 }
2786 }
2787
2788 int kvm_get_phys_ram_page_bitmap(unsigned char *bitmap)
2789 {
2790 unsigned int bsize = BITMAP_SIZE(phys_ram_size);
2791 unsigned int brsize = BITMAP_SIZE(ram_size);
2792 unsigned int extra_pages = (phys_ram_size - ram_size) / TARGET_PAGE_SIZE;
2793 unsigned int extra_bytes = (extra_pages +7)/8;
2794 unsigned int hole_start = BITMAP_SIZE(0xa0000);
2795 unsigned int hole_end = BITMAP_SIZE(0xc0000);
2796
2797 memset(bitmap, 0xFF, brsize + extra_bytes);
2798 memset(bitmap + hole_start, 0, hole_end - hole_start);
2799 memset(bitmap + brsize + extra_bytes, 0, bsize - brsize - extra_bytes);
2800
2801 return 0;
2802 }
2803
2804 #ifdef KVM_CAP_IRQCHIP
2805
2806 int kvm_set_irq(int irq, int level, int *status)
2807 {
2808 return kvm_set_irq_level(kvm_context, irq, level, status);
2809 }
2810
2811 #endif
2812
2813 int qemu_kvm_get_dirty_pages(unsigned long phys_addr, void *buf)
2814 {
2815 return kvm_get_dirty_pages(kvm_context, phys_addr, buf);
2816 }
2817
2818 void *kvm_cpu_create_phys_mem(target_phys_addr_t start_addr,
2819 unsigned long size, int log, int writable)
2820 {
2821 return kvm_create_phys_mem(kvm_context, start_addr, size, log, writable);
2822 }
2823
2824 void kvm_cpu_destroy_phys_mem(target_phys_addr_t start_addr,
2825 unsigned long size)
2826 {
2827 kvm_destroy_phys_mem(kvm_context, start_addr, size);
2828 }
2829
2830 void kvm_mutex_unlock(void)
2831 {
2832 assert(!cpu_single_env);
2833 pthread_mutex_unlock(&qemu_mutex);
2834 }
2835
2836 void kvm_mutex_lock(void)
2837 {
2838 pthread_mutex_lock(&qemu_mutex);
2839 cpu_single_env = NULL;
2840 }
2841
2842 int qemu_kvm_register_coalesced_mmio(target_phys_addr_t addr, unsigned int size)
2843 {
2844 return kvm_register_coalesced_mmio(kvm_context, addr, size);
2845 }
2846
2847 int qemu_kvm_unregister_coalesced_mmio(target_phys_addr_t addr,
2848 unsigned int size)
2849 {
2850 return kvm_unregister_coalesced_mmio(kvm_context, addr, size);
2851 }
2852
2853 int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
2854 {
2855 return kvm_register_coalesced_mmio(kvm_context, start, size);
2856 }
2857
2858 int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
2859 {
2860 return kvm_unregister_coalesced_mmio(kvm_context, start, size);
2861 }
2862
2863 #ifdef USE_KVM_DEVICE_ASSIGNMENT
2864 void kvm_add_ioperm_data(struct ioperm_data *data)
2865 {
2866 LIST_INSERT_HEAD(&ioperm_head, data, entries);
2867 }
2868
2869 void kvm_remove_ioperm_data(unsigned long start_port, unsigned long num)
2870 {
2871 struct ioperm_data *data;
2872
2873 data = LIST_FIRST(&ioperm_head);
2874 while (data) {
2875 struct ioperm_data *next = LIST_NEXT(data, entries);
2876
2877 if (data->start_port == start_port && data->num == num) {
2878 LIST_REMOVE(data, entries);
2879 qemu_free(data);
2880 }
2881
2882 data = next;
2883 }
2884 }
2885
2886 void kvm_ioperm(CPUState *env, void *data)
2887 {
2888 if (kvm_enabled() && qemu_system_ready)
2889 on_vcpu(env, kvm_arch_do_ioperm, data);
2890 }
2891
2892 #endif
2893
2894 int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr, target_phys_addr_t end_addr)
2895 {
2896 #ifndef TARGET_IA64
2897 void *buf;
2898
2899 #ifdef TARGET_I386
2900 if (must_use_aliases_source(start_addr))
2901 return 0;
2902 #endif
2903
2904 buf = qemu_malloc((end_addr - start_addr) / 8 + 2);
2905 kvm_get_dirty_pages_range(kvm_context, start_addr, end_addr - start_addr,
2906 buf, NULL, kvm_get_dirty_bitmap_cb);
2907 qemu_free(buf);
2908 #endif
2909 return 0;
2910 }
2911
2912 int kvm_log_start(target_phys_addr_t phys_addr, target_phys_addr_t len)
2913 {
2914 #ifdef TARGET_I386
2915 if (must_use_aliases_source(phys_addr))
2916 return 0;
2917 #endif
2918
2919 #ifndef TARGET_IA64
2920 kvm_qemu_log_memory(phys_addr, len, 1);
2921 #endif
2922 return 0;
2923 }
2924
2925 int kvm_log_stop(target_phys_addr_t phys_addr, target_phys_addr_t len)
2926 {
2927 #ifdef TARGET_I386
2928 if (must_use_aliases_source(phys_addr))
2929 return 0;
2930 #endif
2931
2932 #ifndef TARGET_IA64
2933 kvm_qemu_log_memory(phys_addr, len, 0);
2934 #endif
2935 return 0;
2936 }
2937
2938 void qemu_kvm_cpu_stop(CPUState *env)
2939 {
2940 if (kvm_enabled())
2941 env->kvm_cpu_state.stopped = 1;
2942 }
Patches shipped by Fedora