1 /*
2 * QEMU KVM support
3 *
4 * Copyright IBM, Corp. 2008
5 * Red Hat, Inc. 2008
6 *
7 * Authors:
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Glauber Costa <gcosta@redhat.com>
10 *
11 * This work is licensed under the terms of the GNU GPL, version 2 or later.
12 * See the COPYING file in the top-level directory.
13 *
14 */
15
16 #include <sys/types.h>
17 #include <sys/ioctl.h>
18 #include <sys/mman.h>
19 #include <stdarg.h>
20
21 #include <linux/kvm.h>
22
23 #include "qemu-common.h"
24 #include "sysemu.h"
25 #include "hw/hw.h"
26 #include "gdbstub.h"
27 #include "kvm.h"
28
29 /* KVM uses PAGE_SIZE in it's definition of COALESCED_MMIO_MAX */
30 #define PAGE_SIZE TARGET_PAGE_SIZE
31
32 //#define DEBUG_KVM
33
34 #ifdef DEBUG_KVM
35 #define dprintf(fmt, ...) \
36 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
37 #else
38 #define dprintf(fmt, ...) \
39 do { } while (0)
40 #endif
41
42 typedef struct KVMSlot
43 {
44 target_phys_addr_t start_addr;
45 ram_addr_t memory_size;
46 ram_addr_t phys_offset;
47 int slot;
48 int flags;
49 } KVMSlot;
50
51 typedef struct kvm_dirty_log KVMDirtyLog;
52
53 int kvm_allowed = 0;
54
55 struct KVMState
56 {
57 KVMSlot slots[32];
58 int fd;
59 int vmfd;
60 int coalesced_mmio;
61 int broken_set_mem_region;
62 int migration_log;
63 #ifdef KVM_CAP_SET_GUEST_DEBUG
64 struct kvm_sw_breakpoint_head kvm_sw_breakpoints;
65 #endif
66 };
67
68 static KVMState *kvm_state;
69
kvm_alloc_slot(KVMState * s)70 static KVMSlot *kvm_alloc_slot(KVMState *s)
71 {
72 int i;
73
74 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
75 /* KVM private memory slots */
76 if (i >= 8 && i < 12)
77 continue;
78 if (s->slots[i].memory_size == 0)
79 return &s->slots[i];
80 }
81
82 fprintf(stderr, "%s: no free slot available\n", __func__);
83 abort();
84 }
85
kvm_lookup_matching_slot(KVMState * s,target_phys_addr_t start_addr,target_phys_addr_t end_addr)86 static KVMSlot *kvm_lookup_matching_slot(KVMState *s,
87 target_phys_addr_t start_addr,
88 target_phys_addr_t end_addr)
89 {
90 int i;
91
92 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
93 KVMSlot *mem = &s->slots[i];
94
95 if (start_addr == mem->start_addr &&
96 end_addr == mem->start_addr + mem->memory_size) {
97 return mem;
98 }
99 }
100
101 return NULL;
102 }
103
104 /*
105 * Find overlapping slot with lowest start address
106 */
kvm_lookup_overlapping_slot(KVMState * s,target_phys_addr_t start_addr,target_phys_addr_t end_addr)107 static KVMSlot *kvm_lookup_overlapping_slot(KVMState *s,
108 target_phys_addr_t start_addr,
109 target_phys_addr_t end_addr)
110 {
111 KVMSlot *found = NULL;
112 int i;
113
114 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
115 KVMSlot *mem = &s->slots[i];
116
117 if (mem->memory_size == 0 ||
118 (found && found->start_addr < mem->start_addr)) {
119 continue;
120 }
121
122 if (end_addr > mem->start_addr &&
123 start_addr < mem->start_addr + mem->memory_size) {
124 found = mem;
125 }
126 }
127
128 return found;
129 }
130
kvm_set_user_memory_region(KVMState * s,KVMSlot * slot)131 static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot)
132 {
133 struct kvm_userspace_memory_region mem;
134
135 mem.slot = slot->slot;
136 mem.guest_phys_addr = slot->start_addr;
137 mem.memory_size = slot->memory_size;
138 mem.userspace_addr = (unsigned long)qemu_get_ram_ptr(slot->phys_offset);
139 mem.flags = slot->flags;
140 if (s->migration_log) {
141 mem.flags |= KVM_MEM_LOG_DIRTY_PAGES;
142 }
143 return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
144 }
145
146
kvm_init_vcpu(CPUState * env)147 int kvm_init_vcpu(CPUState *env)
148 {
149 KVMState *s = kvm_state;
150 long mmap_size;
151 int ret;
152
153 dprintf("kvm_init_vcpu\n");
154
155 ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index);
156 if (ret < 0) {
157 dprintf("kvm_create_vcpu failed\n");
158 goto err;
159 }
160
161 env->kvm_fd = ret;
162 env->kvm_state = s;
163
164 mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
165 if (mmap_size < 0) {
166 dprintf("KVM_GET_VCPU_MMAP_SIZE failed\n");
167 goto err;
168 }
169
170 env->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
171 env->kvm_fd, 0);
172 if (env->kvm_run == MAP_FAILED) {
173 ret = -errno;
174 dprintf("mmap'ing vcpu state failed\n");
175 goto err;
176 }
177
178 ret = kvm_arch_init_vcpu(env);
179
180 err:
181 return ret;
182 }
183
kvm_put_mp_state(CPUState * env)184 int kvm_put_mp_state(CPUState *env)
185 {
186 struct kvm_mp_state mp_state = { .mp_state = env->mp_state };
187
188 return kvm_vcpu_ioctl(env, KVM_SET_MP_STATE, &mp_state);
189 }
190
kvm_get_mp_state(CPUState * env)191 int kvm_get_mp_state(CPUState *env)
192 {
193 struct kvm_mp_state mp_state;
194 int ret;
195
196 ret = kvm_vcpu_ioctl(env, KVM_GET_MP_STATE, &mp_state);
197 if (ret < 0) {
198 return ret;
199 }
200 env->mp_state = mp_state.mp_state;
201 return 0;
202 }
203
kvm_sync_vcpus(void)204 int kvm_sync_vcpus(void)
205 {
206 CPUState *env;
207
208 for (env = first_cpu; env != NULL; env = env->next_cpu) {
209 int ret;
210
211 ret = kvm_arch_put_registers(env);
212 if (ret)
213 return ret;
214 }
215
216 return 0;
217 }
218
219 /*
220 * dirty pages logging control
221 */
kvm_dirty_pages_log_change(target_phys_addr_t phys_addr,ram_addr_t size,int flags,int mask)222 static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr,
223 ram_addr_t size, int flags, int mask)
224 {
225 KVMState *s = kvm_state;
226 KVMSlot *mem = kvm_lookup_matching_slot(s, phys_addr, phys_addr + size);
227 int old_flags;
228
229 if (mem == NULL) {
230 fprintf(stderr, "BUG: %s: invalid parameters " TARGET_FMT_plx "-"
231 TARGET_FMT_plx "\n", __func__, phys_addr,
232 phys_addr + size - 1);
233 return -EINVAL;
234 }
235
236 old_flags = mem->flags;
237
238 flags = (mem->flags & ~mask) | flags;
239 mem->flags = flags;
240
241 /* If nothing changed effectively, no need to issue ioctl */
242 if (s->migration_log) {
243 flags |= KVM_MEM_LOG_DIRTY_PAGES;
244 }
245 if (flags == old_flags) {
246 return 0;
247 }
248
249 return kvm_set_user_memory_region(s, mem);
250 }
251
kvm_log_start(target_phys_addr_t phys_addr,ram_addr_t size)252 int kvm_log_start(target_phys_addr_t phys_addr, ram_addr_t size)
253 {
254 return kvm_dirty_pages_log_change(phys_addr, size,
255 KVM_MEM_LOG_DIRTY_PAGES,
256 KVM_MEM_LOG_DIRTY_PAGES);
257 }
258
kvm_log_stop(target_phys_addr_t phys_addr,ram_addr_t size)259 int kvm_log_stop(target_phys_addr_t phys_addr, ram_addr_t size)
260 {
261 return kvm_dirty_pages_log_change(phys_addr, size,
262 0,
263 KVM_MEM_LOG_DIRTY_PAGES);
264 }
265
kvm_set_migration_log(int enable)266 int kvm_set_migration_log(int enable)
267 {
268 KVMState *s = kvm_state;
269 KVMSlot *mem;
270 int i, err;
271
272 s->migration_log = enable;
273
274 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
275 mem = &s->slots[i];
276
277 if (!!(mem->flags & KVM_MEM_LOG_DIRTY_PAGES) == enable) {
278 continue;
279 }
280 err = kvm_set_user_memory_region(s, mem);
281 if (err) {
282 return err;
283 }
284 }
285 return 0;
286 }
287
288 /**
289 * kvm_physical_sync_dirty_bitmap - Grab dirty bitmap from kernel space
290 * This function updates qemu's dirty bitmap using cpu_physical_memory_set_dirty().
291 * This means all bits are set to dirty.
292 *
293 * @start_add: start of logged region.
294 * @end_addr: end of logged region.
295 */
kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,target_phys_addr_t end_addr)296 int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
297 target_phys_addr_t end_addr)
298 {
299 KVMState *s = kvm_state;
300 unsigned long size, allocated_size = 0;
301 target_phys_addr_t phys_addr;
302 ram_addr_t addr;
303 KVMDirtyLog d;
304 KVMSlot *mem;
305 int ret = 0;
306
307 d.dirty_bitmap = NULL;
308 while (start_addr < end_addr) {
309 mem = kvm_lookup_overlapping_slot(s, start_addr, end_addr);
310 if (mem == NULL) {
311 break;
312 }
313
314 size = ((mem->memory_size >> TARGET_PAGE_BITS) + 7) / 8;
315 if (!d.dirty_bitmap) {
316 d.dirty_bitmap = qemu_malloc(size);
317 } else if (size > allocated_size) {
318 d.dirty_bitmap = qemu_realloc(d.dirty_bitmap, size);
319 }
320 allocated_size = size;
321 memset(d.dirty_bitmap, 0, allocated_size);
322
323 d.slot = mem->slot;
324
325 if (kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d) == -1) {
326 dprintf("ioctl failed %d\n", errno);
327 ret = -1;
328 break;
329 }
330
331 for (phys_addr = mem->start_addr, addr = mem->phys_offset;
332 phys_addr < mem->start_addr + mem->memory_size;
333 phys_addr += TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
334 unsigned long *bitmap = (unsigned long *)d.dirty_bitmap;
335 unsigned nr = (phys_addr - mem->start_addr) >> TARGET_PAGE_BITS;
336 unsigned word = nr / (sizeof(*bitmap) * 8);
337 unsigned bit = nr % (sizeof(*bitmap) * 8);
338
339 if ((bitmap[word] >> bit) & 1) {
340 cpu_physical_memory_set_dirty(addr);
341 }
342 }
343 start_addr = phys_addr;
344 }
345 qemu_free(d.dirty_bitmap);
346
347 return ret;
348 }
349
kvm_coalesce_mmio_region(target_phys_addr_t start,ram_addr_t size)350 int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
351 {
352 int ret = -ENOSYS;
353 #ifdef KVM_CAP_COALESCED_MMIO
354 KVMState *s = kvm_state;
355
356 if (s->coalesced_mmio) {
357 struct kvm_coalesced_mmio_zone zone;
358
359 zone.addr = start;
360 zone.size = size;
361
362 ret = kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
363 }
364 #endif
365
366 return ret;
367 }
368
kvm_uncoalesce_mmio_region(target_phys_addr_t start,ram_addr_t size)369 int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
370 {
371 int ret = -ENOSYS;
372 #ifdef KVM_CAP_COALESCED_MMIO
373 KVMState *s = kvm_state;
374
375 if (s->coalesced_mmio) {
376 struct kvm_coalesced_mmio_zone zone;
377
378 zone.addr = start;
379 zone.size = size;
380
381 ret = kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
382 }
383 #endif
384
385 return ret;
386 }
387
kvm_check_extension(KVMState * s,unsigned int extension)388 int kvm_check_extension(KVMState *s, unsigned int extension)
389 {
390 int ret;
391
392 ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, extension);
393 if (ret < 0) {
394 ret = 0;
395 }
396
397 return ret;
398 }
399
kvm_reset_vcpus(void * opaque)400 static void kvm_reset_vcpus(void *opaque)
401 {
402 kvm_sync_vcpus();
403 }
404
kvm_init(int smp_cpus)405 int kvm_init(int smp_cpus)
406 {
407 static const char upgrade_note[] =
408 "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
409 "(see http://sourceforge.net/projects/kvm).\n";
410 KVMState *s;
411 int ret;
412 int i;
413
414 if (smp_cpus > 1) {
415 fprintf(stderr, "No SMP KVM support, use '-smp 1'\n");
416 return -EINVAL;
417 }
418
419 s = qemu_mallocz(sizeof(KVMState));
420
421 #ifdef KVM_CAP_SET_GUEST_DEBUG
422 QTAILQ_INIT(&s->kvm_sw_breakpoints);
423 #endif
424 for (i = 0; i < ARRAY_SIZE(s->slots); i++)
425 s->slots[i].slot = i;
426
427 s->vmfd = -1;
428 s->fd = open("/dev/kvm", O_RDWR);
429 if (s->fd == -1) {
430 ret = -errno;
431 fprintf(stderr, "Could not access KVM kernel module: %m\n");
432 goto err;
433 }
434
435 ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
436 if (ret < KVM_API_VERSION) {
437 if (ret > 0)
438 ret = -EINVAL;
439 fprintf(stderr, "kvm version too old\n");
440 goto err;
441 }
442
443 if (ret > KVM_API_VERSION) {
444 ret = -EINVAL;
445 fprintf(stderr, "kvm version not supported\n");
446 goto err;
447 }
448
449 s->vmfd = kvm_ioctl(s, KVM_CREATE_VM, 0);
450 if (s->vmfd < 0) {
451 ret = -errno;
452 fprintf(stderr, "ioctl(KVM_CREATE_VM) failed: %s\n", strerror(errno));
453 goto err;
454 }
455
456 /* initially, KVM allocated its own memory and we had to jump through
457 * hooks to make phys_ram_base point to this. Modern versions of KVM
458 * just use a user allocated buffer so we can use regular pages
459 * unmodified. Make sure we have a sufficiently modern version of KVM.
460 */
461 if (!kvm_check_extension(s, KVM_CAP_USER_MEMORY)) {
462 ret = -EINVAL;
463 fprintf(stderr, "kvm does not support KVM_CAP_USER_MEMORY\n%s",
464 upgrade_note);
465 goto err;
466 }
467
468 /* There was a nasty bug in < kvm-80 that prevents memory slots from being
469 * destroyed properly. Since we rely on this capability, refuse to work
470 * with any kernel without this capability. */
471 if (!kvm_check_extension(s, KVM_CAP_DESTROY_MEMORY_REGION_WORKS)) {
472 ret = -EINVAL;
473
474 fprintf(stderr,
475 "KVM kernel module broken (DESTROY_MEMORY_REGION).\n%s",
476 upgrade_note);
477 goto err;
478 }
479
480 #ifdef KVM_CAP_COALESCED_MMIO
481 s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
482 #else
483 s->coalesced_mmio = 0;
484 #endif
485
486 s->broken_set_mem_region = 1;
487 #ifdef KVM_CAP_JOIN_MEMORY_REGIONS_WORKS
488 ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
489 if (ret > 0) {
490 s->broken_set_mem_region = 0;
491 }
492 #endif
493
494 ret = kvm_arch_init(s, smp_cpus);
495 if (ret < 0)
496 goto err;
497
498 qemu_register_reset(kvm_reset_vcpus, INT_MAX, NULL);
499
500 kvm_state = s;
501
502 return 0;
503
504 err:
505 if (s) {
506 if (s->vmfd != -1)
507 close(s->vmfd);
508 if (s->fd != -1)
509 close(s->fd);
510 }
511 qemu_free(s);
512
513 return ret;
514 }
515
kvm_handle_io(CPUState * env,uint16_t port,void * data,int direction,int size,uint32_t count)516 static int kvm_handle_io(CPUState *env, uint16_t port, void *data,
517 int direction, int size, uint32_t count)
518 {
519 int i;
520 uint8_t *ptr = data;
521
522 for (i = 0; i < count; i++) {
523 if (direction == KVM_EXIT_IO_IN) {
524 switch (size) {
525 case 1:
526 stb_p(ptr, cpu_inb(port));
527 break;
528 case 2:
529 stw_p(ptr, cpu_inw(port));
530 break;
531 case 4:
532 stl_p(ptr, cpu_inl(port));
533 break;
534 }
535 } else {
536 switch (size) {
537 case 1:
538 cpu_outb(port, ldub_p(ptr));
539 break;
540 case 2:
541 cpu_outw(port, lduw_p(ptr));
542 break;
543 case 4:
544 cpu_outl(port, ldl_p(ptr));
545 break;
546 }
547 }
548
549 ptr += size;
550 }
551
552 return 1;
553 }
554
kvm_run_coalesced_mmio(CPUState * env,struct kvm_run * run)555 static void kvm_run_coalesced_mmio(CPUState *env, struct kvm_run *run)
556 {
557 #ifdef KVM_CAP_COALESCED_MMIO
558 KVMState *s = kvm_state;
559 if (s->coalesced_mmio) {
560 struct kvm_coalesced_mmio_ring *ring;
561
562 ring = (void *)run + (s->coalesced_mmio * TARGET_PAGE_SIZE);
563 while (ring->first != ring->last) {
564 struct kvm_coalesced_mmio *ent;
565
566 ent = &ring->coalesced_mmio[ring->first];
567
568 cpu_physical_memory_write(ent->phys_addr, ent->data, ent->len);
569 /* FIXME smp_wmb() */
570 ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
571 }
572 }
573 #endif
574 }
575
kvm_cpu_exec(CPUState * env)576 int kvm_cpu_exec(CPUState *env)
577 {
578 struct kvm_run *run = env->kvm_run;
579 int ret;
580
581 dprintf("kvm_cpu_exec()\n");
582
583 do {
584 if (env->exit_request) {
585 dprintf("interrupt exit requested\n");
586 ret = 0;
587 break;
588 }
589
590 kvm_arch_pre_run(env, run);
591 ret = kvm_arch_vcpu_run(env);
592 kvm_arch_post_run(env, run);
593
594 if (ret == -EINTR || ret == -EAGAIN) {
595 dprintf("io window exit\n");
596 ret = 0;
597 break;
598 }
599
600 if (ret < 0) {
601 dprintf("kvm run failed %s\n", strerror(-ret));
602 abort();
603 }
604
605 kvm_run_coalesced_mmio(env, run);
606
607 ret = 0; /* exit loop */
608 switch (run->exit_reason) {
609 case KVM_EXIT_IO:
610 dprintf("handle_io\n");
611 ret = kvm_handle_io(env, run->io.port,
612 (uint8_t *)run + run->io.data_offset,
613 run->io.direction,
614 run->io.size,
615 run->io.count);
616 break;
617 case KVM_EXIT_MMIO:
618 dprintf("handle_mmio\n");
619 cpu_physical_memory_rw(run->mmio.phys_addr,
620 run->mmio.data,
621 run->mmio.len,
622 run->mmio.is_write);
623 ret = 1;
624 break;
625 case KVM_EXIT_IRQ_WINDOW_OPEN:
626 dprintf("irq_window_open\n");
627 break;
628 case KVM_EXIT_SHUTDOWN:
629 dprintf("shutdown\n");
630 qemu_system_reset_request();
631 ret = 1;
632 break;
633 case KVM_EXIT_UNKNOWN:
634 dprintf("kvm_exit_unknown\n");
635 break;
636 case KVM_EXIT_FAIL_ENTRY:
637 dprintf("kvm_exit_fail_entry\n");
638 break;
639 case KVM_EXIT_EXCEPTION:
640 dprintf("kvm_exit_exception\n");
641 break;
642 case KVM_EXIT_DEBUG:
643 dprintf("kvm_exit_debug\n");
644 #ifdef KVM_CAP_SET_GUEST_DEBUG
645 if (kvm_arch_debug(&run->debug.arch)) {
646 gdb_set_stop_cpu(env);
647 vm_stop(EXCP_DEBUG);
648 env->exception_index = EXCP_DEBUG;
649 return 0;
650 }
651 /* re-enter, this exception was guest-internal */
652 ret = 1;
653 #endif /* KVM_CAP_SET_GUEST_DEBUG */
654 break;
655 default:
656 dprintf("kvm_arch_handle_exit\n");
657 ret = kvm_arch_handle_exit(env, run);
658 break;
659 }
660 } while (ret > 0);
661
662 if (env->exit_request) {
663 env->exit_request = 0;
664 env->exception_index = EXCP_INTERRUPT;
665 }
666
667 return ret;
668 }
669
kvm_set_phys_mem(target_phys_addr_t start_addr,ram_addr_t size,ram_addr_t phys_offset)670 void kvm_set_phys_mem(target_phys_addr_t start_addr,
671 ram_addr_t size,
672 ram_addr_t phys_offset)
673 {
674 KVMState *s = kvm_state;
675 ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
676 KVMSlot *mem, old;
677 int err;
678
679 if (start_addr & ~TARGET_PAGE_MASK) {
680 if (flags >= IO_MEM_UNASSIGNED) {
681 if (!kvm_lookup_overlapping_slot(s, start_addr,
682 start_addr + size)) {
683 return;
684 }
685 fprintf(stderr, "Unaligned split of a KVM memory slot\n");
686 } else {
687 fprintf(stderr, "Only page-aligned memory slots supported\n");
688 }
689 abort();
690 }
691
692 /* KVM does not support read-only slots */
693 phys_offset &= ~IO_MEM_ROM;
694
695 while (1) {
696 mem = kvm_lookup_overlapping_slot(s, start_addr, start_addr + size);
697 if (!mem) {
698 break;
699 }
700
701 if (flags < IO_MEM_UNASSIGNED && start_addr >= mem->start_addr &&
702 (start_addr + size <= mem->start_addr + mem->memory_size) &&
703 (phys_offset - start_addr == mem->phys_offset - mem->start_addr)) {
704 /* The new slot fits into the existing one and comes with
705 * identical parameters - nothing to be done. */
706 return;
707 }
708
709 old = *mem;
710
711 /* unregister the overlapping slot */
712 mem->memory_size = 0;
713 err = kvm_set_user_memory_region(s, mem);
714 if (err) {
715 fprintf(stderr, "%s: error unregistering overlapping slot: %s\n",
716 __func__, strerror(-err));
717 abort();
718 }
719
720 /* Workaround for older KVM versions: we can't join slots, even not by
721 * unregistering the previous ones and then registering the larger
722 * slot. We have to maintain the existing fragmentation. Sigh.
723 *
724 * This workaround assumes that the new slot starts at the same
725 * address as the first existing one. If not or if some overlapping
726 * slot comes around later, we will fail (not seen in practice so far)
727 * - and actually require a recent KVM version. */
728 if (s->broken_set_mem_region &&
729 old.start_addr == start_addr && old.memory_size < size &&
730 flags < IO_MEM_UNASSIGNED) {
731 mem = kvm_alloc_slot(s);
732 mem->memory_size = old.memory_size;
733 mem->start_addr = old.start_addr;
734 mem->phys_offset = old.phys_offset;
735 mem->flags = 0;
736
737 err = kvm_set_user_memory_region(s, mem);
738 if (err) {
739 fprintf(stderr, "%s: error updating slot: %s\n", __func__,
740 strerror(-err));
741 abort();
742 }
743
744 start_addr += old.memory_size;
745 phys_offset += old.memory_size;
746 size -= old.memory_size;
747 continue;
748 }
749
750 /* register prefix slot */
751 if (old.start_addr < start_addr) {
752 mem = kvm_alloc_slot(s);
753 mem->memory_size = start_addr - old.start_addr;
754 mem->start_addr = old.start_addr;
755 mem->phys_offset = old.phys_offset;
756 mem->flags = 0;
757
758 err = kvm_set_user_memory_region(s, mem);
759 if (err) {
760 fprintf(stderr, "%s: error registering prefix slot: %s\n",
761 __func__, strerror(-err));
762 abort();
763 }
764 }
765
766 /* register suffix slot */
767 if (old.start_addr + old.memory_size > start_addr + size) {
768 ram_addr_t size_delta;
769
770 mem = kvm_alloc_slot(s);
771 mem->start_addr = start_addr + size;
772 size_delta = mem->start_addr - old.start_addr;
773 mem->memory_size = old.memory_size - size_delta;
774 mem->phys_offset = old.phys_offset + size_delta;
775 mem->flags = 0;
776
777 err = kvm_set_user_memory_region(s, mem);
778 if (err) {
779 fprintf(stderr, "%s: error registering suffix slot: %s\n",
780 __func__, strerror(-err));
781 abort();
782 }
783 }
784 }
785
786 /* in case the KVM bug workaround already "consumed" the new slot */
787 if (!size)
788 return;
789
790 /* KVM does not need to know about this memory */
791 if (flags >= IO_MEM_UNASSIGNED)
792 return;
793
794 mem = kvm_alloc_slot(s);
795 mem->memory_size = size;
796 mem->start_addr = start_addr;
797 mem->phys_offset = phys_offset;
798 mem->flags = 0;
799
800 err = kvm_set_user_memory_region(s, mem);
801 if (err) {
802 fprintf(stderr, "%s: error registering slot: %s\n", __func__,
803 strerror(-err));
804 abort();
805 }
806 }
807
kvm_ioctl(KVMState * s,int type,...)808 int kvm_ioctl(KVMState *s, int type, ...)
809 {
810 int ret;
811 void *arg;
812 va_list ap;
813
814 va_start(ap, type);
815 arg = va_arg(ap, void *);
816 va_end(ap);
817
818 ret = ioctl(s->fd, type, arg);
819 if (ret == -1)
820 ret = -errno;
821
822 return ret;
823 }
824
kvm_vm_ioctl(KVMState * s,int type,...)825 int kvm_vm_ioctl(KVMState *s, int type, ...)
826 {
827 int ret;
828 void *arg;
829 va_list ap;
830
831 va_start(ap, type);
832 arg = va_arg(ap, void *);
833 va_end(ap);
834
835 ret = ioctl(s->vmfd, type, arg);
836 if (ret == -1)
837 ret = -errno;
838
839 return ret;
840 }
841
kvm_vcpu_ioctl(CPUState * env,int type,...)842 int kvm_vcpu_ioctl(CPUState *env, int type, ...)
843 {
844 int ret;
845 void *arg;
846 va_list ap;
847
848 va_start(ap, type);
849 arg = va_arg(ap, void *);
850 va_end(ap);
851
852 ret = ioctl(env->kvm_fd, type, arg);
853 if (ret == -1)
854 ret = -errno;
855
856 return ret;
857 }
858
kvm_has_sync_mmu(void)859 int kvm_has_sync_mmu(void)
860 {
861 #ifdef KVM_CAP_SYNC_MMU
862 KVMState *s = kvm_state;
863
864 return kvm_check_extension(s, KVM_CAP_SYNC_MMU);
865 #else
866 return 0;
867 #endif
868 }
869
kvm_setup_guest_memory(void * start,size_t size)870 void kvm_setup_guest_memory(void *start, size_t size)
871 {
872 if (!kvm_has_sync_mmu()) {
873 #ifdef MADV_DONTFORK
874 int ret = madvise(start, size, MADV_DONTFORK);
875
876 if (ret) {
877 perror("madvice");
878 exit(1);
879 }
880 #else
881 fprintf(stderr,
882 "Need MADV_DONTFORK in absence of synchronous KVM MMU\n");
883 exit(1);
884 #endif
885 }
886 }
887
888 #ifdef KVM_CAP_SET_GUEST_DEBUG
kvm_find_sw_breakpoint(CPUState * env,target_ulong pc)889 struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
890 target_ulong pc)
891 {
892 struct kvm_sw_breakpoint *bp;
893
894 QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) {
895 if (bp->pc == pc)
896 return bp;
897 }
898 return NULL;
899 }
900
kvm_sw_breakpoints_active(CPUState * env)901 int kvm_sw_breakpoints_active(CPUState *env)
902 {
903 return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints);
904 }
905
kvm_update_guest_debug(CPUState * env,unsigned long reinject_trap)906 int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
907 {
908 struct kvm_guest_debug dbg;
909
910 dbg.control = 0;
911 if (env->singlestep_enabled)
912 dbg.control = KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
913
914 kvm_arch_update_guest_debug(env, &dbg);
915 dbg.control |= reinject_trap;
916
917 return kvm_vcpu_ioctl(env, KVM_SET_GUEST_DEBUG, &dbg);
918 }
919
kvm_insert_breakpoint(CPUState * current_env,target_ulong addr,target_ulong len,int type)920 int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
921 target_ulong len, int type)
922 {
923 struct kvm_sw_breakpoint *bp;
924 CPUState *env;
925 int err;
926
927 if (type == GDB_BREAKPOINT_SW) {
928 bp = kvm_find_sw_breakpoint(current_env, addr);
929 if (bp) {
930 bp->use_count++;
931 return 0;
932 }
933
934 bp = qemu_malloc(sizeof(struct kvm_sw_breakpoint));
935 if (!bp)
936 return -ENOMEM;
937
938 bp->pc = addr;
939 bp->use_count = 1;
940 err = kvm_arch_insert_sw_breakpoint(current_env, bp);
941 if (err) {
942 free(bp);
943 return err;
944 }
945
946 QTAILQ_INSERT_HEAD(¤t_env->kvm_state->kvm_sw_breakpoints,
947 bp, entry);
948 } else {
949 err = kvm_arch_insert_hw_breakpoint(addr, len, type);
950 if (err)
951 return err;
952 }
953
954 for (env = first_cpu; env != NULL; env = env->next_cpu) {
955 err = kvm_update_guest_debug(env, 0);
956 if (err)
957 return err;
958 }
959 return 0;
960 }
961
kvm_remove_breakpoint(CPUState * current_env,target_ulong addr,target_ulong len,int type)962 int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
963 target_ulong len, int type)
964 {
965 struct kvm_sw_breakpoint *bp;
966 CPUState *env;
967 int err;
968
969 if (type == GDB_BREAKPOINT_SW) {
970 bp = kvm_find_sw_breakpoint(current_env, addr);
971 if (!bp)
972 return -ENOENT;
973
974 if (bp->use_count > 1) {
975 bp->use_count--;
976 return 0;
977 }
978
979 err = kvm_arch_remove_sw_breakpoint(current_env, bp);
980 if (err)
981 return err;
982
983 QTAILQ_REMOVE(¤t_env->kvm_state->kvm_sw_breakpoints, bp, entry);
984 qemu_free(bp);
985 } else {
986 err = kvm_arch_remove_hw_breakpoint(addr, len, type);
987 if (err)
988 return err;
989 }
990
991 for (env = first_cpu; env != NULL; env = env->next_cpu) {
992 err = kvm_update_guest_debug(env, 0);
993 if (err)
994 return err;
995 }
996 return 0;
997 }
998
kvm_remove_all_breakpoints(CPUState * current_env)999 void kvm_remove_all_breakpoints(CPUState *current_env)
1000 {
1001 struct kvm_sw_breakpoint *bp, *next;
1002 KVMState *s = current_env->kvm_state;
1003 CPUState *env;
1004
1005 QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
1006 if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
1007 /* Try harder to find a CPU that currently sees the breakpoint. */
1008 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1009 if (kvm_arch_remove_sw_breakpoint(env, bp) == 0)
1010 break;
1011 }
1012 }
1013 }
1014 kvm_arch_remove_all_hw_breakpoints();
1015
1016 for (env = first_cpu; env != NULL; env = env->next_cpu)
1017 kvm_update_guest_debug(env, 0);
1018 }
1019
1020 #else /* !KVM_CAP_SET_GUEST_DEBUG */
1021
kvm_update_guest_debug(CPUState * env,unsigned long reinject_trap)1022 int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
1023 {
1024 return -EINVAL;
1025 }
1026
kvm_insert_breakpoint(CPUState * current_env,target_ulong addr,target_ulong len,int type)1027 int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
1028 target_ulong len, int type)
1029 {
1030 return -EINVAL;
1031 }
1032
kvm_remove_breakpoint(CPUState * current_env,target_ulong addr,target_ulong len,int type)1033 int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
1034 target_ulong len, int type)
1035 {
1036 return -EINVAL;
1037 }
1038
kvm_remove_all_breakpoints(CPUState * current_env)1039 void kvm_remove_all_breakpoints(CPUState *current_env)
1040 {
1041 }
1042 #endif /* !KVM_CAP_SET_GUEST_DEBUG */
1043