blob: 1913d6a3377099178b4c62c0b3b964a103d5fa8a [file] [log] [blame]
aliguori05330442008-11-05 16:29:27 +00001/*
2 * QEMU KVM support
3 *
4 * Copyright IBM, Corp. 2008
aliguori5832d1f2008-11-24 19:36:26 +00005 * Red Hat, Inc. 2008
aliguori05330442008-11-05 16:29:27 +00006 *
7 * Authors:
8 * Anthony Liguori <aliguori@us.ibm.com>
aliguori5832d1f2008-11-24 19:36:26 +00009 * Glauber Costa <gcosta@redhat.com>
aliguori05330442008-11-05 16:29:27 +000010 *
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>
aliguori984b5182008-11-13 19:21:00 +000019#include <stdarg.h>
aliguori05330442008-11-05 16:29:27 +000020
21#include <linux/kvm.h>
22
23#include "qemu-common.h"
Marcelo Tosatti85199472010-02-22 13:57:54 -030024#include "qemu-barrier.h"
aliguori05330442008-11-05 16:29:27 +000025#include "sysemu.h"
Jan Kiszkad33a1812009-05-02 00:29:37 +020026#include "hw/hw.h"
Jan Kiszka04fa27f2012-05-16 15:41:10 -030027#include "hw/msi.h"
aliguorie22a25c2009-03-12 20:12:48 +000028#include "gdbstub.h"
aliguori05330442008-11-05 16:29:27 +000029#include "kvm.h"
Marcelo Tosatti8369e012010-04-23 14:04:14 -030030#include "bswap.h"
Avi Kivitya01672d2011-12-18 14:06:05 +020031#include "memory.h"
Avi Kivity80a1ea32012-02-08 16:39:06 +020032#include "exec-memory.h"
aliguori05330442008-11-05 16:29:27 +000033
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +020034/* This check must be after config-host.h is included */
35#ifdef CONFIG_EVENTFD
36#include <sys/eventfd.h>
37#endif
38
Stefan Weil93148aa2012-02-26 18:46:12 +010039/* KVM uses PAGE_SIZE in its definition of COALESCED_MMIO_MAX */
aliguorif65ed4c2008-12-09 20:09:57 +000040#define PAGE_SIZE TARGET_PAGE_SIZE
41
aliguori05330442008-11-05 16:29:27 +000042//#define DEBUG_KVM
43
44#ifdef DEBUG_KVM
Blue Swirl8c0d5772010-04-18 14:22:14 +000045#define DPRINTF(fmt, ...) \
aliguori05330442008-11-05 16:29:27 +000046 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
47#else
Blue Swirl8c0d5772010-04-18 14:22:14 +000048#define DPRINTF(fmt, ...) \
aliguori05330442008-11-05 16:29:27 +000049 do { } while (0)
50#endif
51
Jan Kiszka04fa27f2012-05-16 15:41:10 -030052#define KVM_MSI_HASHTAB_SIZE 256
53
aliguori34fc6432008-11-19 17:41:58 +000054typedef struct KVMSlot
55{
Anthony Liguoric227f092009-10-01 16:12:16 -050056 target_phys_addr_t start_addr;
57 ram_addr_t memory_size;
Avi Kivity9f213ed2011-12-15 19:55:26 +020058 void *ram;
aliguori34fc6432008-11-19 17:41:58 +000059 int slot;
60 int flags;
61} KVMSlot;
aliguori05330442008-11-05 16:29:27 +000062
aliguori5832d1f2008-11-24 19:36:26 +000063typedef struct kvm_dirty_log KVMDirtyLog;
64
Jan Kiszka04fa27f2012-05-16 15:41:10 -030065typedef struct KVMMSIRoute {
66 struct kvm_irq_routing_entry kroute;
67 QTAILQ_ENTRY(KVMMSIRoute) entry;
68} KVMMSIRoute;
69
aliguori05330442008-11-05 16:29:27 +000070struct KVMState
71{
72 KVMSlot slots[32];
73 int fd;
74 int vmfd;
aliguorif65ed4c2008-12-09 20:09:57 +000075 int coalesced_mmio;
Sheng Yang62a27442010-01-26 19:21:16 +080076 struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
Avi Kivity1cae88b2011-10-18 19:43:12 +020077 bool coalesced_flush_in_progress;
Jan Kiszkae69917e2009-05-01 20:42:15 +020078 int broken_set_mem_region;
Jan Kiszka4495d6a2009-05-01 20:52:46 +020079 int migration_log;
Jan Kiszkaa0fb0022009-11-25 00:33:03 +010080 int vcpu_events;
Jan Kiszkab0b1d692010-03-01 19:10:29 +010081 int robust_singlestep;
Jan Kiszkaff44f1a2010-03-12 15:20:49 +010082 int debugregs;
aliguorie22a25c2009-03-12 20:12:48 +000083#ifdef KVM_CAP_SET_GUEST_DEBUG
84 struct kvm_sw_breakpoint_head kvm_sw_breakpoints;
85#endif
Jan Kiszka8a7c7392012-03-02 20:28:48 +010086 int pit_state2;
Sheng Yangf1665b22010-06-17 17:53:07 +080087 int xsave, xcrs;
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +020088 int many_ioeventfds;
David Gibson92e4b512012-03-07 14:41:09 +000089 /* The man page (and posix) say ioctl numbers are signed int, but
90 * they're not. Linux, glibc and *BSD all treat ioctl numbers as
91 * unsigned, and treating them as signed here can break things */
92 unsigned irqchip_inject_ioctl;
Jan Kiszka84b058d2011-10-15 11:49:47 +020093#ifdef KVM_CAP_IRQ_ROUTING
94 struct kvm_irq_routing *irq_routes;
95 int nr_allocated_irq_routes;
96 uint32_t *used_gsi_bitmap;
Jan Kiszka4e2e4e62012-05-16 15:41:08 -030097 unsigned int gsi_count;
Jan Kiszka04fa27f2012-05-16 15:41:10 -030098 QTAILQ_HEAD(msi_hashtab, KVMMSIRoute) msi_hashtab[KVM_MSI_HASHTAB_SIZE];
Jan Kiszka4a3adeb2012-05-16 15:41:14 -030099 bool direct_msi;
Jan Kiszka84b058d2011-10-15 11:49:47 +0200100#endif
aliguori05330442008-11-05 16:29:27 +0000101};
102
Jan Kiszka6a7af8c2011-02-07 12:19:25 +0100103KVMState *kvm_state;
Jan Kiszka3d4b2642012-01-31 19:17:52 +0100104bool kvm_kernel_irqchip;
aliguori05330442008-11-05 16:29:27 +0000105
Jan Kiszka94a8d392011-01-21 21:48:17 +0100106static const KVMCapabilityInfo kvm_required_capabilites[] = {
107 KVM_CAP_INFO(USER_MEMORY),
108 KVM_CAP_INFO(DESTROY_MEMORY_REGION_WORKS),
109 KVM_CAP_LAST_INFO
110};
111
aliguori05330442008-11-05 16:29:27 +0000112static KVMSlot *kvm_alloc_slot(KVMState *s)
113{
114 int i;
115
116 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
Jan Kiszkaa426e122011-01-04 09:32:13 +0100117 if (s->slots[i].memory_size == 0) {
aliguori05330442008-11-05 16:29:27 +0000118 return &s->slots[i];
Jan Kiszkaa426e122011-01-04 09:32:13 +0100119 }
aliguori05330442008-11-05 16:29:27 +0000120 }
121
aliguorid3f8d372009-04-17 14:26:29 +0000122 fprintf(stderr, "%s: no free slot available\n", __func__);
123 abort();
124}
125
126static KVMSlot *kvm_lookup_matching_slot(KVMState *s,
Anthony Liguoric227f092009-10-01 16:12:16 -0500127 target_phys_addr_t start_addr,
128 target_phys_addr_t end_addr)
aliguorid3f8d372009-04-17 14:26:29 +0000129{
130 int i;
131
132 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
133 KVMSlot *mem = &s->slots[i];
134
135 if (start_addr == mem->start_addr &&
136 end_addr == mem->start_addr + mem->memory_size) {
137 return mem;
138 }
139 }
140
aliguori05330442008-11-05 16:29:27 +0000141 return NULL;
142}
143
aliguori6152e2a2009-04-17 14:26:33 +0000144/*
145 * Find overlapping slot with lowest start address
146 */
147static KVMSlot *kvm_lookup_overlapping_slot(KVMState *s,
Anthony Liguoric227f092009-10-01 16:12:16 -0500148 target_phys_addr_t start_addr,
149 target_phys_addr_t end_addr)
aliguori05330442008-11-05 16:29:27 +0000150{
aliguori6152e2a2009-04-17 14:26:33 +0000151 KVMSlot *found = NULL;
aliguori05330442008-11-05 16:29:27 +0000152 int i;
153
154 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
155 KVMSlot *mem = &s->slots[i];
156
aliguori6152e2a2009-04-17 14:26:33 +0000157 if (mem->memory_size == 0 ||
158 (found && found->start_addr < mem->start_addr)) {
159 continue;
160 }
161
162 if (end_addr > mem->start_addr &&
163 start_addr < mem->start_addr + mem->memory_size) {
164 found = mem;
165 }
aliguori05330442008-11-05 16:29:27 +0000166 }
167
aliguori6152e2a2009-04-17 14:26:33 +0000168 return found;
aliguori05330442008-11-05 16:29:27 +0000169}
170
Avi Kivity9f213ed2011-12-15 19:55:26 +0200171int kvm_physical_memory_addr_from_host(KVMState *s, void *ram,
172 target_phys_addr_t *phys_addr)
Huang Ying983dfc32010-10-11 15:31:20 -0300173{
174 int i;
175
176 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
177 KVMSlot *mem = &s->slots[i];
178
Avi Kivity9f213ed2011-12-15 19:55:26 +0200179 if (ram >= mem->ram && ram < mem->ram + mem->memory_size) {
180 *phys_addr = mem->start_addr + (ram - mem->ram);
Huang Ying983dfc32010-10-11 15:31:20 -0300181 return 1;
182 }
183 }
184
185 return 0;
186}
187
aliguori5832d1f2008-11-24 19:36:26 +0000188static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot)
189{
190 struct kvm_userspace_memory_region mem;
191
192 mem.slot = slot->slot;
193 mem.guest_phys_addr = slot->start_addr;
194 mem.memory_size = slot->memory_size;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200195 mem.userspace_addr = (unsigned long)slot->ram;
aliguori5832d1f2008-11-24 19:36:26 +0000196 mem.flags = slot->flags;
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200197 if (s->migration_log) {
198 mem.flags |= KVM_MEM_LOG_DIRTY_PAGES;
199 }
aliguori5832d1f2008-11-24 19:36:26 +0000200 return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
201}
202
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200203static void kvm_reset_vcpu(void *opaque)
204{
Andreas Färber9349b4f2012-03-14 01:38:32 +0100205 CPUArchState *env = opaque;
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200206
Jan Kiszkacaa5af02009-11-06 19:39:24 +0100207 kvm_arch_reset_vcpu(env);
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200208}
aliguori5832d1f2008-11-24 19:36:26 +0000209
Andreas Färber9349b4f2012-03-14 01:38:32 +0100210int kvm_init_vcpu(CPUArchState *env)
aliguori05330442008-11-05 16:29:27 +0000211{
212 KVMState *s = kvm_state;
213 long mmap_size;
214 int ret;
215
Blue Swirl8c0d5772010-04-18 14:22:14 +0000216 DPRINTF("kvm_init_vcpu\n");
aliguori05330442008-11-05 16:29:27 +0000217
aliguori984b5182008-11-13 19:21:00 +0000218 ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index);
aliguori05330442008-11-05 16:29:27 +0000219 if (ret < 0) {
Blue Swirl8c0d5772010-04-18 14:22:14 +0000220 DPRINTF("kvm_create_vcpu failed\n");
aliguori05330442008-11-05 16:29:27 +0000221 goto err;
222 }
223
224 env->kvm_fd = ret;
225 env->kvm_state = s;
Jan Kiszkad841b6c2011-03-15 12:26:20 +0100226 env->kvm_vcpu_dirty = 1;
aliguori05330442008-11-05 16:29:27 +0000227
228 mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
229 if (mmap_size < 0) {
Jan Kiszka748a6802011-02-01 22:15:48 +0100230 ret = mmap_size;
Blue Swirl8c0d5772010-04-18 14:22:14 +0000231 DPRINTF("KVM_GET_VCPU_MMAP_SIZE failed\n");
aliguori05330442008-11-05 16:29:27 +0000232 goto err;
233 }
234
235 env->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
236 env->kvm_fd, 0);
237 if (env->kvm_run == MAP_FAILED) {
238 ret = -errno;
Blue Swirl8c0d5772010-04-18 14:22:14 +0000239 DPRINTF("mmap'ing vcpu state failed\n");
aliguori05330442008-11-05 16:29:27 +0000240 goto err;
241 }
242
Jan Kiszkaa426e122011-01-04 09:32:13 +0100243 if (s->coalesced_mmio && !s->coalesced_mmio_ring) {
244 s->coalesced_mmio_ring =
245 (void *)env->kvm_run + s->coalesced_mmio * PAGE_SIZE;
246 }
Sheng Yang62a27442010-01-26 19:21:16 +0800247
aliguori05330442008-11-05 16:29:27 +0000248 ret = kvm_arch_init_vcpu(env);
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200249 if (ret == 0) {
Jan Kiszkaa08d4362009-06-27 09:25:07 +0200250 qemu_register_reset(kvm_reset_vcpu, env);
Jan Kiszkacaa5af02009-11-06 19:39:24 +0100251 kvm_arch_reset_vcpu(env);
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200252 }
aliguori05330442008-11-05 16:29:27 +0000253err:
254 return ret;
255}
256
aliguori5832d1f2008-11-24 19:36:26 +0000257/*
258 * dirty pages logging control
259 */
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300260
261static int kvm_mem_flags(KVMState *s, bool log_dirty)
262{
263 return log_dirty ? KVM_MEM_LOG_DIRTY_PAGES : 0;
264}
265
266static int kvm_slot_dirty_pages_log_change(KVMSlot *mem, bool log_dirty)
aliguori5832d1f2008-11-24 19:36:26 +0000267{
268 KVMState *s = kvm_state;
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300269 int flags, mask = KVM_MEM_LOG_DIRTY_PAGES;
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200270 int old_flags;
271
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200272 old_flags = mem->flags;
aliguori5832d1f2008-11-24 19:36:26 +0000273
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300274 flags = (mem->flags & ~mask) | kvm_mem_flags(s, log_dirty);
aliguori5832d1f2008-11-24 19:36:26 +0000275 mem->flags = flags;
276
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200277 /* If nothing changed effectively, no need to issue ioctl */
278 if (s->migration_log) {
279 flags |= KVM_MEM_LOG_DIRTY_PAGES;
280 }
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300281
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200282 if (flags == old_flags) {
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300283 return 0;
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200284 }
285
aliguori5832d1f2008-11-24 19:36:26 +0000286 return kvm_set_user_memory_region(s, mem);
287}
288
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300289static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr,
290 ram_addr_t size, bool log_dirty)
291{
292 KVMState *s = kvm_state;
293 KVMSlot *mem = kvm_lookup_matching_slot(s, phys_addr, phys_addr + size);
294
295 if (mem == NULL) {
296 fprintf(stderr, "BUG: %s: invalid parameters " TARGET_FMT_plx "-"
297 TARGET_FMT_plx "\n", __func__, phys_addr,
298 (target_phys_addr_t)(phys_addr + size - 1));
299 return -EINVAL;
300 }
301 return kvm_slot_dirty_pages_log_change(mem, log_dirty);
302}
303
Avi Kivitya01672d2011-12-18 14:06:05 +0200304static void kvm_log_start(MemoryListener *listener,
305 MemoryRegionSection *section)
aliguori5832d1f2008-11-24 19:36:26 +0000306{
Avi Kivitya01672d2011-12-18 14:06:05 +0200307 int r;
308
309 r = kvm_dirty_pages_log_change(section->offset_within_address_space,
310 section->size, true);
311 if (r < 0) {
312 abort();
313 }
aliguori5832d1f2008-11-24 19:36:26 +0000314}
315
Avi Kivitya01672d2011-12-18 14:06:05 +0200316static void kvm_log_stop(MemoryListener *listener,
317 MemoryRegionSection *section)
aliguori5832d1f2008-11-24 19:36:26 +0000318{
Avi Kivitya01672d2011-12-18 14:06:05 +0200319 int r;
320
321 r = kvm_dirty_pages_log_change(section->offset_within_address_space,
322 section->size, false);
323 if (r < 0) {
324 abort();
325 }
aliguori5832d1f2008-11-24 19:36:26 +0000326}
327
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200328static int kvm_set_migration_log(int enable)
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200329{
330 KVMState *s = kvm_state;
331 KVMSlot *mem;
332 int i, err;
333
334 s->migration_log = enable;
335
336 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
337 mem = &s->slots[i];
338
Alex Williamson70fedd72010-07-14 13:36:49 -0600339 if (!mem->memory_size) {
340 continue;
341 }
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200342 if (!!(mem->flags & KVM_MEM_LOG_DIRTY_PAGES) == enable) {
343 continue;
344 }
345 err = kvm_set_user_memory_region(s, mem);
346 if (err) {
347 return err;
348 }
349 }
350 return 0;
351}
352
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300353/* get kvm's dirty pages bitmap and update qemu's */
Avi Kivityffcde122011-12-19 13:18:13 +0200354static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section,
355 unsigned long *bitmap)
Alexander Graf96c16062009-07-27 12:49:56 +0200356{
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300357 unsigned int i, j;
Benjamin Herrenschmidtaa90fec2012-01-11 19:46:21 +0000358 unsigned long page_number, c;
359 target_phys_addr_t addr, addr1;
Avi Kivityffcde122011-12-19 13:18:13 +0200360 unsigned int len = ((section->size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) / HOST_LONG_BITS;
David Gibson3145fcb2012-04-04 11:15:54 +1000361 unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE;
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300362
363 /*
364 * bitmap-traveling is faster than memory-traveling (for addr...)
365 * especially when most of the memory is not dirty.
366 */
367 for (i = 0; i < len; i++) {
368 if (bitmap[i] != 0) {
369 c = leul_to_cpu(bitmap[i]);
370 do {
371 j = ffsl(c) - 1;
372 c &= ~(1ul << j);
David Gibson3145fcb2012-04-04 11:15:54 +1000373 page_number = (i * HOST_LONG_BITS + j) * hpratio;
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300374 addr1 = page_number * TARGET_PAGE_SIZE;
Avi Kivityffcde122011-12-19 13:18:13 +0200375 addr = section->offset_within_region + addr1;
David Gibson3145fcb2012-04-04 11:15:54 +1000376 memory_region_set_dirty(section->mr, addr,
377 TARGET_PAGE_SIZE * hpratio);
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300378 } while (c != 0);
379 }
380 }
381 return 0;
Alexander Graf96c16062009-07-27 12:49:56 +0200382}
383
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300384#define ALIGN(x, y) (((x)+(y)-1) & ~((y)-1))
385
aliguori5832d1f2008-11-24 19:36:26 +0000386/**
387 * kvm_physical_sync_dirty_bitmap - Grab dirty bitmap from kernel space
Blue Swirlfd4aa972011-10-16 16:04:59 +0000388 * This function updates qemu's dirty bitmap using
389 * memory_region_set_dirty(). This means all bits are set
390 * to dirty.
aliguori5832d1f2008-11-24 19:36:26 +0000391 *
aliguorid3f8d372009-04-17 14:26:29 +0000392 * @start_add: start of logged region.
aliguori5832d1f2008-11-24 19:36:26 +0000393 * @end_addr: end of logged region.
394 */
Avi Kivityffcde122011-12-19 13:18:13 +0200395static int kvm_physical_sync_dirty_bitmap(MemoryRegionSection *section)
aliguori5832d1f2008-11-24 19:36:26 +0000396{
397 KVMState *s = kvm_state;
Jan Kiszka151f7742009-05-01 20:52:47 +0200398 unsigned long size, allocated_size = 0;
Jan Kiszka151f7742009-05-01 20:52:47 +0200399 KVMDirtyLog d;
400 KVMSlot *mem;
401 int ret = 0;
Avi Kivityffcde122011-12-19 13:18:13 +0200402 target_phys_addr_t start_addr = section->offset_within_address_space;
403 target_phys_addr_t end_addr = start_addr + section->size;
aliguori5832d1f2008-11-24 19:36:26 +0000404
Jan Kiszka151f7742009-05-01 20:52:47 +0200405 d.dirty_bitmap = NULL;
406 while (start_addr < end_addr) {
407 mem = kvm_lookup_overlapping_slot(s, start_addr, end_addr);
408 if (mem == NULL) {
409 break;
410 }
411
Michael Tokarev51b0c602011-04-26 20:13:49 +0400412 /* XXX bad kernel interface alert
413 * For dirty bitmap, kernel allocates array of size aligned to
414 * bits-per-long. But for case when the kernel is 64bits and
415 * the userspace is 32bits, userspace can't align to the same
416 * bits-per-long, since sizeof(long) is different between kernel
417 * and user space. This way, userspace will provide buffer which
418 * may be 4 bytes less than the kernel will use, resulting in
419 * userspace memory corruption (which is not detectable by valgrind
420 * too, in most cases).
421 * So for now, let's align to 64 instead of HOST_LONG_BITS here, in
422 * a hope that sizeof(long) wont become >8 any time soon.
423 */
424 size = ALIGN(((mem->memory_size) >> TARGET_PAGE_BITS),
425 /*HOST_LONG_BITS*/ 64) / 8;
Jan Kiszka151f7742009-05-01 20:52:47 +0200426 if (!d.dirty_bitmap) {
Anthony Liguori7267c092011-08-20 22:09:37 -0500427 d.dirty_bitmap = g_malloc(size);
Jan Kiszka151f7742009-05-01 20:52:47 +0200428 } else if (size > allocated_size) {
Anthony Liguori7267c092011-08-20 22:09:37 -0500429 d.dirty_bitmap = g_realloc(d.dirty_bitmap, size);
Jan Kiszka151f7742009-05-01 20:52:47 +0200430 }
431 allocated_size = size;
432 memset(d.dirty_bitmap, 0, allocated_size);
433
434 d.slot = mem->slot;
435
Anthony Liguori6e489f32009-07-27 15:23:59 -0500436 if (kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d) == -1) {
Blue Swirl8c0d5772010-04-18 14:22:14 +0000437 DPRINTF("ioctl failed %d\n", errno);
Jan Kiszka151f7742009-05-01 20:52:47 +0200438 ret = -1;
439 break;
440 }
441
Avi Kivityffcde122011-12-19 13:18:13 +0200442 kvm_get_dirty_pages_log_range(section, d.dirty_bitmap);
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300443 start_addr = mem->start_addr + mem->memory_size;
aliguori5832d1f2008-11-24 19:36:26 +0000444 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500445 g_free(d.dirty_bitmap);
Jan Kiszka151f7742009-05-01 20:52:47 +0200446
447 return ret;
aliguori5832d1f2008-11-24 19:36:26 +0000448}
449
Anthony Liguoric227f092009-10-01 16:12:16 -0500450int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
aliguorif65ed4c2008-12-09 20:09:57 +0000451{
452 int ret = -ENOSYS;
aliguorif65ed4c2008-12-09 20:09:57 +0000453 KVMState *s = kvm_state;
454
455 if (s->coalesced_mmio) {
456 struct kvm_coalesced_mmio_zone zone;
457
458 zone.addr = start;
459 zone.size = size;
Michael S. Tsirkin7e680752012-02-29 17:54:29 +0200460 zone.pad = 0;
aliguorif65ed4c2008-12-09 20:09:57 +0000461
462 ret = kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
463 }
aliguorif65ed4c2008-12-09 20:09:57 +0000464
465 return ret;
466}
467
Anthony Liguoric227f092009-10-01 16:12:16 -0500468int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
aliguorif65ed4c2008-12-09 20:09:57 +0000469{
470 int ret = -ENOSYS;
aliguorif65ed4c2008-12-09 20:09:57 +0000471 KVMState *s = kvm_state;
472
473 if (s->coalesced_mmio) {
474 struct kvm_coalesced_mmio_zone zone;
475
476 zone.addr = start;
477 zone.size = size;
Michael S. Tsirkin7e680752012-02-29 17:54:29 +0200478 zone.pad = 0;
aliguorif65ed4c2008-12-09 20:09:57 +0000479
480 ret = kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
481 }
aliguorif65ed4c2008-12-09 20:09:57 +0000482
483 return ret;
484}
485
Anthony Liguoriad7b8b32009-05-08 15:33:24 -0500486int kvm_check_extension(KVMState *s, unsigned int extension)
487{
488 int ret;
489
490 ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, extension);
491 if (ret < 0) {
492 ret = 0;
493 }
494
495 return ret;
496}
497
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +0200498static int kvm_check_many_ioeventfds(void)
499{
Stefan Hajnoczid0dcac82011-01-25 16:17:14 +0000500 /* Userspace can use ioeventfd for io notification. This requires a host
501 * that supports eventfd(2) and an I/O thread; since eventfd does not
502 * support SIGIO it cannot interrupt the vcpu.
503 *
504 * Older kernels have a 6 device limit on the KVM io bus. Find out so we
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +0200505 * can avoid creating too many ioeventfds.
506 */
Anthony Liguori12d45362011-08-22 08:24:58 -0500507#if defined(CONFIG_EVENTFD)
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +0200508 int ioeventfds[7];
509 int i, ret = 0;
510 for (i = 0; i < ARRAY_SIZE(ioeventfds); i++) {
511 ioeventfds[i] = eventfd(0, EFD_CLOEXEC);
512 if (ioeventfds[i] < 0) {
513 break;
514 }
515 ret = kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, true);
516 if (ret < 0) {
517 close(ioeventfds[i]);
518 break;
519 }
520 }
521
522 /* Decide whether many devices are supported or not */
523 ret = i == ARRAY_SIZE(ioeventfds);
524
525 while (i-- > 0) {
526 kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, false);
527 close(ioeventfds[i]);
528 }
529 return ret;
530#else
531 return 0;
532#endif
533}
534
Jan Kiszka94a8d392011-01-21 21:48:17 +0100535static const KVMCapabilityInfo *
536kvm_check_extension_list(KVMState *s, const KVMCapabilityInfo *list)
537{
538 while (list->name) {
539 if (!kvm_check_extension(s, list->value)) {
540 return list;
541 }
542 list++;
543 }
544 return NULL;
545}
546
Avi Kivitya01672d2011-12-18 14:06:05 +0200547static void kvm_set_phys_mem(MemoryRegionSection *section, bool add)
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200548{
549 KVMState *s = kvm_state;
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200550 KVMSlot *mem, old;
551 int err;
Avi Kivitya01672d2011-12-18 14:06:05 +0200552 MemoryRegion *mr = section->mr;
553 bool log_dirty = memory_region_is_logging(mr);
554 target_phys_addr_t start_addr = section->offset_within_address_space;
555 ram_addr_t size = section->size;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200556 void *ram = NULL;
Avi Kivity8f6f9622012-02-29 13:22:12 +0200557 unsigned delta;
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200558
Gleb Natapov14542fe2010-07-28 18:13:23 +0300559 /* kvm works in page size chunks, but the function may be called
560 with sub-page size and unaligned start address. */
Avi Kivity8f6f9622012-02-29 13:22:12 +0200561 delta = TARGET_PAGE_ALIGN(size) - size;
562 if (delta > size) {
563 return;
564 }
565 start_addr += delta;
566 size -= delta;
567 size &= TARGET_PAGE_MASK;
568 if (!size || (start_addr & ~TARGET_PAGE_MASK)) {
569 return;
570 }
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200571
Avi Kivitya01672d2011-12-18 14:06:05 +0200572 if (!memory_region_is_ram(mr)) {
573 return;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200574 }
575
Avi Kivity8f6f9622012-02-29 13:22:12 +0200576 ram = memory_region_get_ram_ptr(mr) + section->offset_within_region + delta;
Avi Kivitya01672d2011-12-18 14:06:05 +0200577
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200578 while (1) {
579 mem = kvm_lookup_overlapping_slot(s, start_addr, start_addr + size);
580 if (!mem) {
581 break;
582 }
583
Avi Kivitya01672d2011-12-18 14:06:05 +0200584 if (add && start_addr >= mem->start_addr &&
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200585 (start_addr + size <= mem->start_addr + mem->memory_size) &&
Avi Kivity9f213ed2011-12-15 19:55:26 +0200586 (ram - start_addr == mem->ram - mem->start_addr)) {
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200587 /* The new slot fits into the existing one and comes with
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300588 * identical parameters - update flags and done. */
589 kvm_slot_dirty_pages_log_change(mem, log_dirty);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200590 return;
591 }
592
593 old = *mem;
594
Avi Kivity3fbffb62012-01-15 16:13:59 +0200595 if (mem->flags & KVM_MEM_LOG_DIRTY_PAGES) {
596 kvm_physical_sync_dirty_bitmap(section);
597 }
598
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200599 /* unregister the overlapping slot */
600 mem->memory_size = 0;
601 err = kvm_set_user_memory_region(s, mem);
602 if (err) {
603 fprintf(stderr, "%s: error unregistering overlapping slot: %s\n",
604 __func__, strerror(-err));
605 abort();
606 }
607
608 /* Workaround for older KVM versions: we can't join slots, even not by
609 * unregistering the previous ones and then registering the larger
610 * slot. We have to maintain the existing fragmentation. Sigh.
611 *
612 * This workaround assumes that the new slot starts at the same
613 * address as the first existing one. If not or if some overlapping
614 * slot comes around later, we will fail (not seen in practice so far)
615 * - and actually require a recent KVM version. */
616 if (s->broken_set_mem_region &&
Avi Kivitya01672d2011-12-18 14:06:05 +0200617 old.start_addr == start_addr && old.memory_size < size && add) {
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200618 mem = kvm_alloc_slot(s);
619 mem->memory_size = old.memory_size;
620 mem->start_addr = old.start_addr;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200621 mem->ram = old.ram;
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300622 mem->flags = kvm_mem_flags(s, log_dirty);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200623
624 err = kvm_set_user_memory_region(s, mem);
625 if (err) {
626 fprintf(stderr, "%s: error updating slot: %s\n", __func__,
627 strerror(-err));
628 abort();
629 }
630
631 start_addr += old.memory_size;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200632 ram += old.memory_size;
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200633 size -= old.memory_size;
634 continue;
635 }
636
637 /* register prefix slot */
638 if (old.start_addr < start_addr) {
639 mem = kvm_alloc_slot(s);
640 mem->memory_size = start_addr - old.start_addr;
641 mem->start_addr = old.start_addr;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200642 mem->ram = old.ram;
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300643 mem->flags = kvm_mem_flags(s, log_dirty);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200644
645 err = kvm_set_user_memory_region(s, mem);
646 if (err) {
647 fprintf(stderr, "%s: error registering prefix slot: %s\n",
648 __func__, strerror(-err));
Alexander Grafd4d68682011-04-16 10:15:11 +0200649#ifdef TARGET_PPC
650 fprintf(stderr, "%s: This is probably because your kernel's " \
651 "PAGE_SIZE is too big. Please try to use 4k " \
652 "PAGE_SIZE!\n", __func__);
653#endif
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200654 abort();
655 }
656 }
657
658 /* register suffix slot */
659 if (old.start_addr + old.memory_size > start_addr + size) {
660 ram_addr_t size_delta;
661
662 mem = kvm_alloc_slot(s);
663 mem->start_addr = start_addr + size;
664 size_delta = mem->start_addr - old.start_addr;
665 mem->memory_size = old.memory_size - size_delta;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200666 mem->ram = old.ram + size_delta;
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300667 mem->flags = kvm_mem_flags(s, log_dirty);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200668
669 err = kvm_set_user_memory_region(s, mem);
670 if (err) {
671 fprintf(stderr, "%s: error registering suffix slot: %s\n",
672 __func__, strerror(-err));
673 abort();
674 }
675 }
676 }
677
678 /* in case the KVM bug workaround already "consumed" the new slot */
Jan Kiszkaa426e122011-01-04 09:32:13 +0100679 if (!size) {
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200680 return;
Jan Kiszkaa426e122011-01-04 09:32:13 +0100681 }
Avi Kivitya01672d2011-12-18 14:06:05 +0200682 if (!add) {
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200683 return;
Jan Kiszkaa426e122011-01-04 09:32:13 +0100684 }
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200685 mem = kvm_alloc_slot(s);
686 mem->memory_size = size;
687 mem->start_addr = start_addr;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200688 mem->ram = ram;
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300689 mem->flags = kvm_mem_flags(s, log_dirty);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200690
691 err = kvm_set_user_memory_region(s, mem);
692 if (err) {
693 fprintf(stderr, "%s: error registering slot: %s\n", __func__,
694 strerror(-err));
695 abort();
696 }
697}
698
Avi Kivity50c1e142012-02-08 21:36:02 +0200699static void kvm_begin(MemoryListener *listener)
700{
701}
702
703static void kvm_commit(MemoryListener *listener)
704{
705}
706
Avi Kivitya01672d2011-12-18 14:06:05 +0200707static void kvm_region_add(MemoryListener *listener,
708 MemoryRegionSection *section)
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200709{
Avi Kivitya01672d2011-12-18 14:06:05 +0200710 kvm_set_phys_mem(section, true);
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200711}
712
Avi Kivitya01672d2011-12-18 14:06:05 +0200713static void kvm_region_del(MemoryListener *listener,
714 MemoryRegionSection *section)
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200715{
Avi Kivitya01672d2011-12-18 14:06:05 +0200716 kvm_set_phys_mem(section, false);
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200717}
718
Avi Kivity50c1e142012-02-08 21:36:02 +0200719static void kvm_region_nop(MemoryListener *listener,
720 MemoryRegionSection *section)
721{
722}
723
Avi Kivitya01672d2011-12-18 14:06:05 +0200724static void kvm_log_sync(MemoryListener *listener,
725 MemoryRegionSection *section)
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200726{
Avi Kivitya01672d2011-12-18 14:06:05 +0200727 int r;
728
Avi Kivityffcde122011-12-19 13:18:13 +0200729 r = kvm_physical_sync_dirty_bitmap(section);
Avi Kivitya01672d2011-12-18 14:06:05 +0200730 if (r < 0) {
731 abort();
732 }
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200733}
734
Avi Kivitya01672d2011-12-18 14:06:05 +0200735static void kvm_log_global_start(struct MemoryListener *listener)
736{
737 int r;
738
739 r = kvm_set_migration_log(1);
740 assert(r >= 0);
741}
742
743static void kvm_log_global_stop(struct MemoryListener *listener)
744{
745 int r;
746
747 r = kvm_set_migration_log(0);
748 assert(r >= 0);
749}
750
Avi Kivity80a1ea32012-02-08 16:39:06 +0200751static void kvm_mem_ioeventfd_add(MemoryRegionSection *section,
752 bool match_data, uint64_t data, int fd)
753{
754 int r;
755
Michael S. Tsirkin4b8f1c82012-03-20 14:31:38 +0200756 assert(match_data && section->size <= 8);
Avi Kivity80a1ea32012-02-08 16:39:06 +0200757
Michael S. Tsirkin4b8f1c82012-03-20 14:31:38 +0200758 r = kvm_set_ioeventfd_mmio(fd, section->offset_within_address_space,
759 data, true, section->size);
Avi Kivity80a1ea32012-02-08 16:39:06 +0200760 if (r < 0) {
761 abort();
762 }
763}
764
765static void kvm_mem_ioeventfd_del(MemoryRegionSection *section,
766 bool match_data, uint64_t data, int fd)
767{
768 int r;
769
Michael S. Tsirkin4b8f1c82012-03-20 14:31:38 +0200770 r = kvm_set_ioeventfd_mmio(fd, section->offset_within_address_space,
771 data, false, section->size);
Avi Kivity80a1ea32012-02-08 16:39:06 +0200772 if (r < 0) {
773 abort();
774 }
775}
776
777static void kvm_io_ioeventfd_add(MemoryRegionSection *section,
778 bool match_data, uint64_t data, int fd)
779{
780 int r;
781
782 assert(match_data && section->size == 2);
783
784 r = kvm_set_ioeventfd_pio_word(fd, section->offset_within_address_space,
785 data, true);
786 if (r < 0) {
787 abort();
788 }
789}
790
791static void kvm_io_ioeventfd_del(MemoryRegionSection *section,
792 bool match_data, uint64_t data, int fd)
793
794{
795 int r;
796
797 r = kvm_set_ioeventfd_pio_word(fd, section->offset_within_address_space,
798 data, false);
799 if (r < 0) {
800 abort();
801 }
802}
803
804static void kvm_eventfd_add(MemoryListener *listener,
805 MemoryRegionSection *section,
806 bool match_data, uint64_t data, int fd)
807{
808 if (section->address_space == get_system_memory()) {
809 kvm_mem_ioeventfd_add(section, match_data, data, fd);
810 } else {
811 kvm_io_ioeventfd_add(section, match_data, data, fd);
812 }
813}
814
815static void kvm_eventfd_del(MemoryListener *listener,
816 MemoryRegionSection *section,
817 bool match_data, uint64_t data, int fd)
818{
819 if (section->address_space == get_system_memory()) {
820 kvm_mem_ioeventfd_del(section, match_data, data, fd);
821 } else {
822 kvm_io_ioeventfd_del(section, match_data, data, fd);
823 }
824}
825
Avi Kivitya01672d2011-12-18 14:06:05 +0200826static MemoryListener kvm_memory_listener = {
Avi Kivity50c1e142012-02-08 21:36:02 +0200827 .begin = kvm_begin,
828 .commit = kvm_commit,
Avi Kivitya01672d2011-12-18 14:06:05 +0200829 .region_add = kvm_region_add,
830 .region_del = kvm_region_del,
Avi Kivity50c1e142012-02-08 21:36:02 +0200831 .region_nop = kvm_region_nop,
Anthony PERARDe5896b12011-02-07 12:19:23 +0100832 .log_start = kvm_log_start,
833 .log_stop = kvm_log_stop,
Avi Kivitya01672d2011-12-18 14:06:05 +0200834 .log_sync = kvm_log_sync,
835 .log_global_start = kvm_log_global_start,
836 .log_global_stop = kvm_log_global_stop,
Avi Kivity80a1ea32012-02-08 16:39:06 +0200837 .eventfd_add = kvm_eventfd_add,
838 .eventfd_del = kvm_eventfd_del,
Avi Kivity72e22d22012-02-08 15:05:50 +0200839 .priority = 10,
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200840};
841
Andreas Färber9349b4f2012-03-14 01:38:32 +0100842static void kvm_handle_interrupt(CPUArchState *env, int mask)
Jan Kiszkaaa7f74d2011-04-13 01:32:56 +0200843{
844 env->interrupt_request |= mask;
845
846 if (!qemu_cpu_is_self(env)) {
847 qemu_cpu_kick(env);
848 }
849}
850
Jan Kiszka84b058d2011-10-15 11:49:47 +0200851int kvm_irqchip_set_irq(KVMState *s, int irq, int level)
852{
853 struct kvm_irq_level event;
854 int ret;
855
Jan Kiszka3d4b2642012-01-31 19:17:52 +0100856 assert(kvm_irqchip_in_kernel());
Jan Kiszka84b058d2011-10-15 11:49:47 +0200857
858 event.level = level;
859 event.irq = irq;
860 ret = kvm_vm_ioctl(s, s->irqchip_inject_ioctl, &event);
861 if (ret < 0) {
862 perror("kvm_set_irqchip_line");
863 abort();
864 }
865
866 return (s->irqchip_inject_ioctl == KVM_IRQ_LINE) ? 1 : event.status;
867}
868
869#ifdef KVM_CAP_IRQ_ROUTING
870static void set_gsi(KVMState *s, unsigned int gsi)
871{
Jan Kiszka84b058d2011-10-15 11:49:47 +0200872 s->used_gsi_bitmap[gsi / 32] |= 1U << (gsi % 32);
873}
874
Jan Kiszka04fa27f2012-05-16 15:41:10 -0300875static void clear_gsi(KVMState *s, unsigned int gsi)
876{
877 s->used_gsi_bitmap[gsi / 32] &= ~(1U << (gsi % 32));
878}
879
Jan Kiszka84b058d2011-10-15 11:49:47 +0200880static void kvm_init_irq_routing(KVMState *s)
881{
Jan Kiszka04fa27f2012-05-16 15:41:10 -0300882 int gsi_count, i;
Jan Kiszka84b058d2011-10-15 11:49:47 +0200883
884 gsi_count = kvm_check_extension(s, KVM_CAP_IRQ_ROUTING);
885 if (gsi_count > 0) {
886 unsigned int gsi_bits, i;
887
888 /* Round up so we can search ints using ffs */
Jason Baronbc8c6782012-03-28 14:18:05 -0400889 gsi_bits = ALIGN(gsi_count, 32);
Jan Kiszka84b058d2011-10-15 11:49:47 +0200890 s->used_gsi_bitmap = g_malloc0(gsi_bits / 8);
Jan Kiszka4e2e4e62012-05-16 15:41:08 -0300891 s->gsi_count = gsi_count;
Jan Kiszka84b058d2011-10-15 11:49:47 +0200892
893 /* Mark any over-allocated bits as already in use */
894 for (i = gsi_count; i < gsi_bits; i++) {
895 set_gsi(s, i);
896 }
897 }
898
899 s->irq_routes = g_malloc0(sizeof(*s->irq_routes));
900 s->nr_allocated_irq_routes = 0;
901
Jan Kiszka4a3adeb2012-05-16 15:41:14 -0300902 if (!s->direct_msi) {
903 for (i = 0; i < KVM_MSI_HASHTAB_SIZE; i++) {
904 QTAILQ_INIT(&s->msi_hashtab[i]);
905 }
Jan Kiszka04fa27f2012-05-16 15:41:10 -0300906 }
907
Jan Kiszka84b058d2011-10-15 11:49:47 +0200908 kvm_arch_init_irq_routing(s);
909}
910
911static void kvm_add_routing_entry(KVMState *s,
912 struct kvm_irq_routing_entry *entry)
913{
914 struct kvm_irq_routing_entry *new;
915 int n, size;
916
917 if (s->irq_routes->nr == s->nr_allocated_irq_routes) {
918 n = s->nr_allocated_irq_routes * 2;
919 if (n < 64) {
920 n = 64;
921 }
922 size = sizeof(struct kvm_irq_routing);
923 size += n * sizeof(*new);
924 s->irq_routes = g_realloc(s->irq_routes, size);
925 s->nr_allocated_irq_routes = n;
926 }
927 n = s->irq_routes->nr++;
928 new = &s->irq_routes->entries[n];
929 memset(new, 0, sizeof(*new));
930 new->gsi = entry->gsi;
931 new->type = entry->type;
932 new->flags = entry->flags;
933 new->u = entry->u;
934
935 set_gsi(s, entry->gsi);
936}
937
938void kvm_irqchip_add_route(KVMState *s, int irq, int irqchip, int pin)
939{
940 struct kvm_irq_routing_entry e;
941
Jan Kiszka4e2e4e62012-05-16 15:41:08 -0300942 assert(pin < s->gsi_count);
943
Jan Kiszka84b058d2011-10-15 11:49:47 +0200944 e.gsi = irq;
945 e.type = KVM_IRQ_ROUTING_IRQCHIP;
946 e.flags = 0;
947 e.u.irqchip.irqchip = irqchip;
948 e.u.irqchip.pin = pin;
949 kvm_add_routing_entry(s, &e);
950}
951
952int kvm_irqchip_commit_routes(KVMState *s)
953{
954 s->irq_routes->flags = 0;
955 return kvm_vm_ioctl(s, KVM_SET_GSI_ROUTING, s->irq_routes);
956}
957
Jan Kiszka04fa27f2012-05-16 15:41:10 -0300958static void kvm_irqchip_release_virq(KVMState *s, int virq)
959{
960 struct kvm_irq_routing_entry *e;
961 int i;
962
963 for (i = 0; i < s->irq_routes->nr; i++) {
964 e = &s->irq_routes->entries[i];
965 if (e->gsi == virq) {
966 s->irq_routes->nr--;
967 *e = s->irq_routes->entries[s->irq_routes->nr];
968 }
969 }
970 clear_gsi(s, virq);
971}
972
973static unsigned int kvm_hash_msi(uint32_t data)
974{
975 /* This is optimized for IA32 MSI layout. However, no other arch shall
976 * repeat the mistake of not providing a direct MSI injection API. */
977 return data & 0xff;
978}
979
980static void kvm_flush_dynamic_msi_routes(KVMState *s)
981{
982 KVMMSIRoute *route, *next;
983 unsigned int hash;
984
985 for (hash = 0; hash < KVM_MSI_HASHTAB_SIZE; hash++) {
986 QTAILQ_FOREACH_SAFE(route, &s->msi_hashtab[hash], entry, next) {
987 kvm_irqchip_release_virq(s, route->kroute.gsi);
988 QTAILQ_REMOVE(&s->msi_hashtab[hash], route, entry);
989 g_free(route);
990 }
991 }
992}
993
994static int kvm_irqchip_get_virq(KVMState *s)
995{
996 uint32_t *word = s->used_gsi_bitmap;
997 int max_words = ALIGN(s->gsi_count, 32) / 32;
998 int i, bit;
999 bool retry = true;
1000
1001again:
1002 /* Return the lowest unused GSI in the bitmap */
1003 for (i = 0; i < max_words; i++) {
1004 bit = ffs(~word[i]);
1005 if (!bit) {
1006 continue;
1007 }
1008
1009 return bit - 1 + i * 32;
1010 }
Jan Kiszka4a3adeb2012-05-16 15:41:14 -03001011 if (!s->direct_msi && retry) {
Jan Kiszka04fa27f2012-05-16 15:41:10 -03001012 retry = false;
1013 kvm_flush_dynamic_msi_routes(s);
1014 goto again;
1015 }
1016 return -ENOSPC;
1017
1018}
1019
1020static KVMMSIRoute *kvm_lookup_msi_route(KVMState *s, MSIMessage msg)
1021{
1022 unsigned int hash = kvm_hash_msi(msg.data);
1023 KVMMSIRoute *route;
1024
1025 QTAILQ_FOREACH(route, &s->msi_hashtab[hash], entry) {
1026 if (route->kroute.u.msi.address_lo == (uint32_t)msg.address &&
1027 route->kroute.u.msi.address_hi == (msg.address >> 32) &&
1028 route->kroute.u.msi.data == msg.data) {
1029 return route;
1030 }
1031 }
1032 return NULL;
1033}
1034
1035int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg)
1036{
Jan Kiszka4a3adeb2012-05-16 15:41:14 -03001037 struct kvm_msi msi;
Jan Kiszka04fa27f2012-05-16 15:41:10 -03001038 KVMMSIRoute *route;
1039
Jan Kiszka4a3adeb2012-05-16 15:41:14 -03001040 if (s->direct_msi) {
1041 msi.address_lo = (uint32_t)msg.address;
1042 msi.address_hi = msg.address >> 32;
1043 msi.data = msg.data;
1044 msi.flags = 0;
1045 memset(msi.pad, 0, sizeof(msi.pad));
1046
1047 return kvm_vm_ioctl(s, KVM_SIGNAL_MSI, &msi);
1048 }
1049
Jan Kiszka04fa27f2012-05-16 15:41:10 -03001050 route = kvm_lookup_msi_route(s, msg);
1051 if (!route) {
1052 int virq, ret;
1053
1054 virq = kvm_irqchip_get_virq(s);
1055 if (virq < 0) {
1056 return virq;
1057 }
1058
1059 route = g_malloc(sizeof(KVMMSIRoute));
1060 route->kroute.gsi = virq;
1061 route->kroute.type = KVM_IRQ_ROUTING_MSI;
1062 route->kroute.flags = 0;
1063 route->kroute.u.msi.address_lo = (uint32_t)msg.address;
1064 route->kroute.u.msi.address_hi = msg.address >> 32;
1065 route->kroute.u.msi.data = msg.data;
1066
1067 kvm_add_routing_entry(s, &route->kroute);
1068
1069 QTAILQ_INSERT_TAIL(&s->msi_hashtab[kvm_hash_msi(msg.data)], route,
1070 entry);
1071
1072 ret = kvm_irqchip_commit_routes(s);
1073 if (ret < 0) {
1074 return ret;
1075 }
1076 }
1077
1078 assert(route->kroute.type == KVM_IRQ_ROUTING_MSI);
1079
1080 return kvm_irqchip_set_irq(s, route->kroute.gsi, 1);
1081}
1082
Jan Kiszka84b058d2011-10-15 11:49:47 +02001083#else /* !KVM_CAP_IRQ_ROUTING */
1084
1085static void kvm_init_irq_routing(KVMState *s)
1086{
1087}
Jan Kiszka04fa27f2012-05-16 15:41:10 -03001088
1089int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg)
1090{
1091 abort();
1092}
Jan Kiszka84b058d2011-10-15 11:49:47 +02001093#endif /* !KVM_CAP_IRQ_ROUTING */
1094
1095static int kvm_irqchip_create(KVMState *s)
1096{
1097 QemuOptsList *list = qemu_find_opts("machine");
1098 int ret;
1099
1100 if (QTAILQ_EMPTY(&list->head) ||
1101 !qemu_opt_get_bool(QTAILQ_FIRST(&list->head),
Jan Kiszkaa24b9102012-05-16 15:41:15 -03001102 "kernel_irqchip", true) ||
Jan Kiszka84b058d2011-10-15 11:49:47 +02001103 !kvm_check_extension(s, KVM_CAP_IRQCHIP)) {
1104 return 0;
1105 }
1106
1107 ret = kvm_vm_ioctl(s, KVM_CREATE_IRQCHIP);
1108 if (ret < 0) {
1109 fprintf(stderr, "Create kernel irqchip failed\n");
1110 return ret;
1111 }
1112
1113 s->irqchip_inject_ioctl = KVM_IRQ_LINE;
1114 if (kvm_check_extension(s, KVM_CAP_IRQ_INJECT_STATUS)) {
1115 s->irqchip_inject_ioctl = KVM_IRQ_LINE_STATUS;
1116 }
Jan Kiszka3d4b2642012-01-31 19:17:52 +01001117 kvm_kernel_irqchip = true;
Jan Kiszka84b058d2011-10-15 11:49:47 +02001118
1119 kvm_init_irq_routing(s);
1120
1121 return 0;
1122}
1123
Jan Kiszkacad1e282011-01-21 21:48:16 +01001124int kvm_init(void)
aliguori05330442008-11-05 16:29:27 +00001125{
Jan Kiszka168ccc12009-06-07 11:30:25 +02001126 static const char upgrade_note[] =
1127 "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
1128 "(see http://sourceforge.net/projects/kvm).\n";
aliguori05330442008-11-05 16:29:27 +00001129 KVMState *s;
Jan Kiszka94a8d392011-01-21 21:48:17 +01001130 const KVMCapabilityInfo *missing_cap;
aliguori05330442008-11-05 16:29:27 +00001131 int ret;
1132 int i;
1133
Anthony Liguori7267c092011-08-20 22:09:37 -05001134 s = g_malloc0(sizeof(KVMState));
aliguori05330442008-11-05 16:29:27 +00001135
David Gibson3145fcb2012-04-04 11:15:54 +10001136 /*
1137 * On systems where the kernel can support different base page
1138 * sizes, host page size may be different from TARGET_PAGE_SIZE,
1139 * even with KVM. TARGET_PAGE_SIZE is assumed to be the minimum
1140 * page size for the system though.
1141 */
1142 assert(TARGET_PAGE_SIZE <= getpagesize());
1143
aliguorie22a25c2009-03-12 20:12:48 +00001144#ifdef KVM_CAP_SET_GUEST_DEBUG
Blue Swirl72cf2d42009-09-12 07:36:22 +00001145 QTAILQ_INIT(&s->kvm_sw_breakpoints);
aliguorie22a25c2009-03-12 20:12:48 +00001146#endif
Jan Kiszkaa426e122011-01-04 09:32:13 +01001147 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
aliguori05330442008-11-05 16:29:27 +00001148 s->slots[i].slot = i;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001149 }
aliguori05330442008-11-05 16:29:27 +00001150 s->vmfd = -1;
Kevin Wolf40ff6d72009-12-02 12:24:42 +01001151 s->fd = qemu_open("/dev/kvm", O_RDWR);
aliguori05330442008-11-05 16:29:27 +00001152 if (s->fd == -1) {
1153 fprintf(stderr, "Could not access KVM kernel module: %m\n");
1154 ret = -errno;
1155 goto err;
1156 }
1157
1158 ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
1159 if (ret < KVM_API_VERSION) {
Jan Kiszkaa426e122011-01-04 09:32:13 +01001160 if (ret > 0) {
aliguori05330442008-11-05 16:29:27 +00001161 ret = -EINVAL;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001162 }
aliguori05330442008-11-05 16:29:27 +00001163 fprintf(stderr, "kvm version too old\n");
1164 goto err;
1165 }
1166
1167 if (ret > KVM_API_VERSION) {
1168 ret = -EINVAL;
1169 fprintf(stderr, "kvm version not supported\n");
1170 goto err;
1171 }
1172
1173 s->vmfd = kvm_ioctl(s, KVM_CREATE_VM, 0);
Alexander Graf0104dca2010-04-01 18:42:37 +02001174 if (s->vmfd < 0) {
1175#ifdef TARGET_S390X
1176 fprintf(stderr, "Please add the 'switch_amode' kernel parameter to "
1177 "your host kernel command line\n");
1178#endif
Xu He Jiedb9eae12011-10-27 10:15:13 +08001179 ret = s->vmfd;
aliguori05330442008-11-05 16:29:27 +00001180 goto err;
Alexander Graf0104dca2010-04-01 18:42:37 +02001181 }
aliguori05330442008-11-05 16:29:27 +00001182
Jan Kiszka94a8d392011-01-21 21:48:17 +01001183 missing_cap = kvm_check_extension_list(s, kvm_required_capabilites);
1184 if (!missing_cap) {
1185 missing_cap =
1186 kvm_check_extension_list(s, kvm_arch_required_capabilities);
1187 }
1188 if (missing_cap) {
Anthony Liguoriad7b8b32009-05-08 15:33:24 -05001189 ret = -EINVAL;
Jan Kiszka94a8d392011-01-21 21:48:17 +01001190 fprintf(stderr, "kvm does not support %s\n%s",
1191 missing_cap->name, upgrade_note);
aliguori05330442008-11-05 16:29:27 +00001192 goto err;
1193 }
1194
Anthony Liguoriad7b8b32009-05-08 15:33:24 -05001195 s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
aliguorif65ed4c2008-12-09 20:09:57 +00001196
Jan Kiszkae69917e2009-05-01 20:42:15 +02001197 s->broken_set_mem_region = 1;
Lai Jiangshan14a09512010-12-10 15:52:36 +08001198 ret = kvm_check_extension(s, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
Jan Kiszkae69917e2009-05-01 20:42:15 +02001199 if (ret > 0) {
1200 s->broken_set_mem_region = 0;
1201 }
Jan Kiszkae69917e2009-05-01 20:42:15 +02001202
Jan Kiszkaa0fb0022009-11-25 00:33:03 +01001203#ifdef KVM_CAP_VCPU_EVENTS
1204 s->vcpu_events = kvm_check_extension(s, KVM_CAP_VCPU_EVENTS);
1205#endif
1206
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001207 s->robust_singlestep =
1208 kvm_check_extension(s, KVM_CAP_X86_ROBUST_SINGLESTEP);
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001209
Jan Kiszkaff44f1a2010-03-12 15:20:49 +01001210#ifdef KVM_CAP_DEBUGREGS
1211 s->debugregs = kvm_check_extension(s, KVM_CAP_DEBUGREGS);
1212#endif
1213
Sheng Yangf1665b22010-06-17 17:53:07 +08001214#ifdef KVM_CAP_XSAVE
1215 s->xsave = kvm_check_extension(s, KVM_CAP_XSAVE);
1216#endif
1217
Sheng Yangf1665b22010-06-17 17:53:07 +08001218#ifdef KVM_CAP_XCRS
1219 s->xcrs = kvm_check_extension(s, KVM_CAP_XCRS);
1220#endif
1221
Jan Kiszka8a7c7392012-03-02 20:28:48 +01001222#ifdef KVM_CAP_PIT_STATE2
1223 s->pit_state2 = kvm_check_extension(s, KVM_CAP_PIT_STATE2);
1224#endif
1225
Jan Kiszka4a3adeb2012-05-16 15:41:14 -03001226 s->direct_msi = (kvm_check_extension(s, KVM_CAP_SIGNAL_MSI) > 0);
1227
Jan Kiszkacad1e282011-01-21 21:48:16 +01001228 ret = kvm_arch_init(s);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001229 if (ret < 0) {
aliguori05330442008-11-05 16:29:27 +00001230 goto err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001231 }
aliguori05330442008-11-05 16:29:27 +00001232
Jan Kiszka84b058d2011-10-15 11:49:47 +02001233 ret = kvm_irqchip_create(s);
1234 if (ret < 0) {
1235 goto err;
1236 }
1237
aliguori05330442008-11-05 16:29:27 +00001238 kvm_state = s;
Avi Kivity7376e582012-02-08 21:05:17 +02001239 memory_listener_register(&kvm_memory_listener, NULL);
aliguori05330442008-11-05 16:29:27 +00001240
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +02001241 s->many_ioeventfds = kvm_check_many_ioeventfds();
1242
Jan Kiszkaaa7f74d2011-04-13 01:32:56 +02001243 cpu_interrupt_handler = kvm_handle_interrupt;
1244
aliguori05330442008-11-05 16:29:27 +00001245 return 0;
1246
1247err:
1248 if (s) {
Xu He Jiedb9eae12011-10-27 10:15:13 +08001249 if (s->vmfd >= 0) {
aliguori05330442008-11-05 16:29:27 +00001250 close(s->vmfd);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001251 }
1252 if (s->fd != -1) {
aliguori05330442008-11-05 16:29:27 +00001253 close(s->fd);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001254 }
aliguori05330442008-11-05 16:29:27 +00001255 }
Anthony Liguori7267c092011-08-20 22:09:37 -05001256 g_free(s);
aliguori05330442008-11-05 16:29:27 +00001257
1258 return ret;
1259}
1260
Jan Kiszkab30e93e2011-02-01 22:16:01 +01001261static void kvm_handle_io(uint16_t port, void *data, int direction, int size,
1262 uint32_t count)
aliguori05330442008-11-05 16:29:27 +00001263{
1264 int i;
1265 uint8_t *ptr = data;
1266
1267 for (i = 0; i < count; i++) {
1268 if (direction == KVM_EXIT_IO_IN) {
1269 switch (size) {
1270 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001271 stb_p(ptr, cpu_inb(port));
aliguori05330442008-11-05 16:29:27 +00001272 break;
1273 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001274 stw_p(ptr, cpu_inw(port));
aliguori05330442008-11-05 16:29:27 +00001275 break;
1276 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001277 stl_p(ptr, cpu_inl(port));
aliguori05330442008-11-05 16:29:27 +00001278 break;
1279 }
1280 } else {
1281 switch (size) {
1282 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001283 cpu_outb(port, ldub_p(ptr));
aliguori05330442008-11-05 16:29:27 +00001284 break;
1285 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001286 cpu_outw(port, lduw_p(ptr));
aliguori05330442008-11-05 16:29:27 +00001287 break;
1288 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001289 cpu_outl(port, ldl_p(ptr));
aliguori05330442008-11-05 16:29:27 +00001290 break;
1291 }
1292 }
1293
1294 ptr += size;
1295 }
aliguori05330442008-11-05 16:29:27 +00001296}
1297
Andreas Färber9349b4f2012-03-14 01:38:32 +01001298static int kvm_handle_internal_error(CPUArchState *env, struct kvm_run *run)
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001299{
Jan Kiszkabb44e0d2011-01-21 21:48:07 +01001300 fprintf(stderr, "KVM internal error.");
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001301 if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) {
1302 int i;
1303
Jan Kiszkabb44e0d2011-01-21 21:48:07 +01001304 fprintf(stderr, " Suberror: %d\n", run->internal.suberror);
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001305 for (i = 0; i < run->internal.ndata; ++i) {
1306 fprintf(stderr, "extra data[%d]: %"PRIx64"\n",
1307 i, (uint64_t)run->internal.data[i]);
1308 }
Jan Kiszkabb44e0d2011-01-21 21:48:07 +01001309 } else {
1310 fprintf(stderr, "\n");
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001311 }
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001312 if (run->internal.suberror == KVM_INTERNAL_ERROR_EMULATION) {
1313 fprintf(stderr, "emulation failure\n");
Jan Kiszkaa426e122011-01-04 09:32:13 +01001314 if (!kvm_arch_stop_on_emulation_error(env)) {
Jan Kiszkaf5c848e2011-01-21 21:48:08 +01001315 cpu_dump_state(env, stderr, fprintf, CPU_DUMP_CODE);
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001316 return EXCP_INTERRUPT;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001317 }
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001318 }
1319 /* FIXME: Should trigger a qmp message to let management know
1320 * something went wrong.
1321 */
Jan Kiszka73aaec42011-01-21 21:48:06 +01001322 return -1;
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001323}
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001324
Sheng Yang62a27442010-01-26 19:21:16 +08001325void kvm_flush_coalesced_mmio_buffer(void)
aliguorif65ed4c2008-12-09 20:09:57 +00001326{
aliguorif65ed4c2008-12-09 20:09:57 +00001327 KVMState *s = kvm_state;
Avi Kivity1cae88b2011-10-18 19:43:12 +02001328
1329 if (s->coalesced_flush_in_progress) {
1330 return;
1331 }
1332
1333 s->coalesced_flush_in_progress = true;
1334
Sheng Yang62a27442010-01-26 19:21:16 +08001335 if (s->coalesced_mmio_ring) {
1336 struct kvm_coalesced_mmio_ring *ring = s->coalesced_mmio_ring;
aliguorif65ed4c2008-12-09 20:09:57 +00001337 while (ring->first != ring->last) {
1338 struct kvm_coalesced_mmio *ent;
1339
1340 ent = &ring->coalesced_mmio[ring->first];
1341
1342 cpu_physical_memory_write(ent->phys_addr, ent->data, ent->len);
Marcelo Tosatti85199472010-02-22 13:57:54 -03001343 smp_wmb();
aliguorif65ed4c2008-12-09 20:09:57 +00001344 ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
1345 }
1346 }
Avi Kivity1cae88b2011-10-18 19:43:12 +02001347
1348 s->coalesced_flush_in_progress = false;
aliguorif65ed4c2008-12-09 20:09:57 +00001349}
1350
Jan Kiszka2705d562010-05-04 09:45:23 -03001351static void do_kvm_cpu_synchronize_state(void *_env)
Avi Kivity4c0960c2009-08-17 23:19:53 +03001352{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001353 CPUArchState *env = _env;
Jan Kiszka2705d562010-05-04 09:45:23 -03001354
Jan Kiszka9ded2742010-02-03 21:17:05 +01001355 if (!env->kvm_vcpu_dirty) {
Avi Kivity4c0960c2009-08-17 23:19:53 +03001356 kvm_arch_get_registers(env);
Jan Kiszka9ded2742010-02-03 21:17:05 +01001357 env->kvm_vcpu_dirty = 1;
Avi Kivity4c0960c2009-08-17 23:19:53 +03001358 }
1359}
1360
Andreas Färber9349b4f2012-03-14 01:38:32 +01001361void kvm_cpu_synchronize_state(CPUArchState *env)
Jan Kiszka2705d562010-05-04 09:45:23 -03001362{
Jan Kiszkaa426e122011-01-04 09:32:13 +01001363 if (!env->kvm_vcpu_dirty) {
Jan Kiszka2705d562010-05-04 09:45:23 -03001364 run_on_cpu(env, do_kvm_cpu_synchronize_state, env);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001365 }
Jan Kiszka2705d562010-05-04 09:45:23 -03001366}
1367
Andreas Färber9349b4f2012-03-14 01:38:32 +01001368void kvm_cpu_synchronize_post_reset(CPUArchState *env)
Jan Kiszkaea375f92010-03-01 19:10:30 +01001369{
1370 kvm_arch_put_registers(env, KVM_PUT_RESET_STATE);
1371 env->kvm_vcpu_dirty = 0;
1372}
1373
Andreas Färber9349b4f2012-03-14 01:38:32 +01001374void kvm_cpu_synchronize_post_init(CPUArchState *env)
Jan Kiszkaea375f92010-03-01 19:10:30 +01001375{
1376 kvm_arch_put_registers(env, KVM_PUT_FULL_STATE);
1377 env->kvm_vcpu_dirty = 0;
1378}
1379
Andreas Färber9349b4f2012-03-14 01:38:32 +01001380int kvm_cpu_exec(CPUArchState *env)
aliguori05330442008-11-05 16:29:27 +00001381{
1382 struct kvm_run *run = env->kvm_run;
Jan Kiszka7cbb5332011-03-15 12:26:25 +01001383 int ret, run_ret;
aliguori05330442008-11-05 16:29:27 +00001384
Blue Swirl8c0d5772010-04-18 14:22:14 +00001385 DPRINTF("kvm_cpu_exec()\n");
aliguori05330442008-11-05 16:29:27 +00001386
Jan Kiszka99036862011-03-02 08:56:13 +01001387 if (kvm_arch_process_async_events(env)) {
Jan Kiszka9ccfac92011-02-01 22:16:00 +01001388 env->exit_request = 0;
Jan Kiszka6792a572011-02-07 12:19:18 +01001389 return EXCP_HLT;
Jan Kiszka9ccfac92011-02-01 22:16:00 +01001390 }
1391
aliguori05330442008-11-05 16:29:27 +00001392 do {
Jan Kiszka9ded2742010-02-03 21:17:05 +01001393 if (env->kvm_vcpu_dirty) {
Jan Kiszkaea375f92010-03-01 19:10:30 +01001394 kvm_arch_put_registers(env, KVM_PUT_RUNTIME_STATE);
Jan Kiszka9ded2742010-02-03 21:17:05 +01001395 env->kvm_vcpu_dirty = 0;
Avi Kivity4c0960c2009-08-17 23:19:53 +03001396 }
1397
Jan Kiszka8c14c172009-05-30 10:01:45 +02001398 kvm_arch_pre_run(env, run);
Jan Kiszka9ccfac92011-02-01 22:16:00 +01001399 if (env->exit_request) {
1400 DPRINTF("interrupt exit requested\n");
1401 /*
1402 * KVM requires us to reenter the kernel after IO exits to complete
1403 * instruction emulation. This self-signal will ensure that we
1404 * leave ASAP again.
1405 */
1406 qemu_cpu_kick_self();
1407 }
Glauber Costad549db52009-10-07 16:38:03 -03001408 qemu_mutex_unlock_iothread();
Jan Kiszka9ccfac92011-02-01 22:16:00 +01001409
Jan Kiszka7cbb5332011-03-15 12:26:25 +01001410 run_ret = kvm_vcpu_ioctl(env, KVM_RUN, 0);
Jan Kiszka9ccfac92011-02-01 22:16:00 +01001411
Glauber Costad549db52009-10-07 16:38:03 -03001412 qemu_mutex_lock_iothread();
aliguori05330442008-11-05 16:29:27 +00001413 kvm_arch_post_run(env, run);
1414
Jan Kiszkab0c883b2011-01-21 21:48:19 +01001415 kvm_flush_coalesced_mmio_buffer();
1416
Jan Kiszka7cbb5332011-03-15 12:26:25 +01001417 if (run_ret < 0) {
Jan Kiszkadc77d342011-03-15 12:26:26 +01001418 if (run_ret == -EINTR || run_ret == -EAGAIN) {
1419 DPRINTF("io window exit\n");
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001420 ret = EXCP_INTERRUPT;
Jan Kiszkadc77d342011-03-15 12:26:26 +01001421 break;
1422 }
Michael Ellerman7b011fb2011-12-16 11:20:20 +11001423 fprintf(stderr, "error: kvm run failed %s\n",
1424 strerror(-run_ret));
aliguori05330442008-11-05 16:29:27 +00001425 abort();
1426 }
1427
aliguori05330442008-11-05 16:29:27 +00001428 switch (run->exit_reason) {
1429 case KVM_EXIT_IO:
Blue Swirl8c0d5772010-04-18 14:22:14 +00001430 DPRINTF("handle_io\n");
Jan Kiszkab30e93e2011-02-01 22:16:01 +01001431 kvm_handle_io(run->io.port,
1432 (uint8_t *)run + run->io.data_offset,
1433 run->io.direction,
1434 run->io.size,
1435 run->io.count);
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001436 ret = 0;
aliguori05330442008-11-05 16:29:27 +00001437 break;
1438 case KVM_EXIT_MMIO:
Blue Swirl8c0d5772010-04-18 14:22:14 +00001439 DPRINTF("handle_mmio\n");
aliguori05330442008-11-05 16:29:27 +00001440 cpu_physical_memory_rw(run->mmio.phys_addr,
1441 run->mmio.data,
1442 run->mmio.len,
1443 run->mmio.is_write);
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001444 ret = 0;
aliguori05330442008-11-05 16:29:27 +00001445 break;
1446 case KVM_EXIT_IRQ_WINDOW_OPEN:
Blue Swirl8c0d5772010-04-18 14:22:14 +00001447 DPRINTF("irq_window_open\n");
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001448 ret = EXCP_INTERRUPT;
aliguori05330442008-11-05 16:29:27 +00001449 break;
1450 case KVM_EXIT_SHUTDOWN:
Blue Swirl8c0d5772010-04-18 14:22:14 +00001451 DPRINTF("shutdown\n");
aliguori05330442008-11-05 16:29:27 +00001452 qemu_system_reset_request();
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001453 ret = EXCP_INTERRUPT;
aliguori05330442008-11-05 16:29:27 +00001454 break;
1455 case KVM_EXIT_UNKNOWN:
Jan Kiszkabb44e0d2011-01-21 21:48:07 +01001456 fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
1457 (uint64_t)run->hw.hardware_exit_reason);
Jan Kiszka73aaec42011-01-21 21:48:06 +01001458 ret = -1;
aliguori05330442008-11-05 16:29:27 +00001459 break;
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001460 case KVM_EXIT_INTERNAL_ERROR:
Jan Kiszka73aaec42011-01-21 21:48:06 +01001461 ret = kvm_handle_internal_error(env, run);
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001462 break;
aliguori05330442008-11-05 16:29:27 +00001463 default:
Blue Swirl8c0d5772010-04-18 14:22:14 +00001464 DPRINTF("kvm_arch_handle_exit\n");
aliguori05330442008-11-05 16:29:27 +00001465 ret = kvm_arch_handle_exit(env, run);
1466 break;
1467 }
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001468 } while (ret == 0);
aliguori05330442008-11-05 16:29:27 +00001469
Jan Kiszka73aaec42011-01-21 21:48:06 +01001470 if (ret < 0) {
Jan Kiszkaf5c848e2011-01-21 21:48:08 +01001471 cpu_dump_state(env, stderr, fprintf, CPU_DUMP_CODE);
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001472 vm_stop(RUN_STATE_INTERNAL_ERROR);
Jan Kiszka73aaec42011-01-21 21:48:06 +01001473 }
aliguoribecfc392008-11-10 15:55:14 +00001474
Jan Kiszka6792a572011-02-07 12:19:18 +01001475 env->exit_request = 0;
aliguori05330442008-11-05 16:29:27 +00001476 return ret;
1477}
1478
aliguori984b5182008-11-13 19:21:00 +00001479int kvm_ioctl(KVMState *s, int type, ...)
aliguori05330442008-11-05 16:29:27 +00001480{
1481 int ret;
aliguori984b5182008-11-13 19:21:00 +00001482 void *arg;
1483 va_list ap;
aliguori05330442008-11-05 16:29:27 +00001484
aliguori984b5182008-11-13 19:21:00 +00001485 va_start(ap, type);
1486 arg = va_arg(ap, void *);
1487 va_end(ap);
1488
1489 ret = ioctl(s->fd, type, arg);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001490 if (ret == -1) {
aliguori05330442008-11-05 16:29:27 +00001491 ret = -errno;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001492 }
aliguori05330442008-11-05 16:29:27 +00001493 return ret;
1494}
1495
aliguori984b5182008-11-13 19:21:00 +00001496int kvm_vm_ioctl(KVMState *s, int type, ...)
aliguori05330442008-11-05 16:29:27 +00001497{
1498 int ret;
aliguori984b5182008-11-13 19:21:00 +00001499 void *arg;
1500 va_list ap;
aliguori05330442008-11-05 16:29:27 +00001501
aliguori984b5182008-11-13 19:21:00 +00001502 va_start(ap, type);
1503 arg = va_arg(ap, void *);
1504 va_end(ap);
1505
1506 ret = ioctl(s->vmfd, type, arg);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001507 if (ret == -1) {
aliguori05330442008-11-05 16:29:27 +00001508 ret = -errno;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001509 }
aliguori05330442008-11-05 16:29:27 +00001510 return ret;
1511}
1512
Andreas Färber9349b4f2012-03-14 01:38:32 +01001513int kvm_vcpu_ioctl(CPUArchState *env, int type, ...)
aliguori05330442008-11-05 16:29:27 +00001514{
1515 int ret;
aliguori984b5182008-11-13 19:21:00 +00001516 void *arg;
1517 va_list ap;
aliguori05330442008-11-05 16:29:27 +00001518
aliguori984b5182008-11-13 19:21:00 +00001519 va_start(ap, type);
1520 arg = va_arg(ap, void *);
1521 va_end(ap);
1522
1523 ret = ioctl(env->kvm_fd, type, arg);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001524 if (ret == -1) {
aliguori05330442008-11-05 16:29:27 +00001525 ret = -errno;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001526 }
aliguori05330442008-11-05 16:29:27 +00001527 return ret;
1528}
aliguoribd322082008-12-04 20:33:06 +00001529
1530int kvm_has_sync_mmu(void)
1531{
Jan Kiszka94a8d392011-01-21 21:48:17 +01001532 return kvm_check_extension(kvm_state, KVM_CAP_SYNC_MMU);
aliguoribd322082008-12-04 20:33:06 +00001533}
aliguorie22a25c2009-03-12 20:12:48 +00001534
Jan Kiszkaa0fb0022009-11-25 00:33:03 +01001535int kvm_has_vcpu_events(void)
1536{
1537 return kvm_state->vcpu_events;
1538}
1539
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001540int kvm_has_robust_singlestep(void)
1541{
1542 return kvm_state->robust_singlestep;
1543}
1544
Jan Kiszkaff44f1a2010-03-12 15:20:49 +01001545int kvm_has_debugregs(void)
1546{
1547 return kvm_state->debugregs;
1548}
1549
Sheng Yangf1665b22010-06-17 17:53:07 +08001550int kvm_has_xsave(void)
1551{
1552 return kvm_state->xsave;
1553}
1554
1555int kvm_has_xcrs(void)
1556{
1557 return kvm_state->xcrs;
1558}
1559
Jan Kiszka8a7c7392012-03-02 20:28:48 +01001560int kvm_has_pit_state2(void)
1561{
1562 return kvm_state->pit_state2;
1563}
1564
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +02001565int kvm_has_many_ioeventfds(void)
1566{
1567 if (!kvm_enabled()) {
1568 return 0;
1569 }
1570 return kvm_state->many_ioeventfds;
1571}
1572
Jan Kiszka84b058d2011-10-15 11:49:47 +02001573int kvm_has_gsi_routing(void)
1574{
Alexander Grafa9c5eb02012-01-25 18:28:05 +01001575#ifdef KVM_CAP_IRQ_ROUTING
Jan Kiszka84b058d2011-10-15 11:49:47 +02001576 return kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING);
Alexander Grafa9c5eb02012-01-25 18:28:05 +01001577#else
1578 return false;
1579#endif
Jan Kiszka84b058d2011-10-15 11:49:47 +02001580}
1581
Jan Kiszka9b5b76d2011-10-15 14:08:26 +02001582int kvm_allows_irq0_override(void)
1583{
Jan Kiszka3d4b2642012-01-31 19:17:52 +01001584 return !kvm_irqchip_in_kernel() || kvm_has_gsi_routing();
Jan Kiszka9b5b76d2011-10-15 14:08:26 +02001585}
1586
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001587void kvm_setup_guest_memory(void *start, size_t size)
1588{
1589 if (!kvm_has_sync_mmu()) {
Andreas Färbere78815a2010-09-25 11:26:05 +00001590 int ret = qemu_madvise(start, size, QEMU_MADV_DONTFORK);
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001591
1592 if (ret) {
Andreas Färbere78815a2010-09-25 11:26:05 +00001593 perror("qemu_madvise");
1594 fprintf(stderr,
1595 "Need MADV_DONTFORK in absence of synchronous KVM MMU\n");
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001596 exit(1);
1597 }
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001598 }
1599}
1600
aliguorie22a25c2009-03-12 20:12:48 +00001601#ifdef KVM_CAP_SET_GUEST_DEBUG
Andreas Färber9349b4f2012-03-14 01:38:32 +01001602struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUArchState *env,
aliguorie22a25c2009-03-12 20:12:48 +00001603 target_ulong pc)
1604{
1605 struct kvm_sw_breakpoint *bp;
1606
Blue Swirl72cf2d42009-09-12 07:36:22 +00001607 QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) {
Jan Kiszkaa426e122011-01-04 09:32:13 +01001608 if (bp->pc == pc) {
aliguorie22a25c2009-03-12 20:12:48 +00001609 return bp;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001610 }
aliguorie22a25c2009-03-12 20:12:48 +00001611 }
1612 return NULL;
1613}
1614
Andreas Färber9349b4f2012-03-14 01:38:32 +01001615int kvm_sw_breakpoints_active(CPUArchState *env)
aliguorie22a25c2009-03-12 20:12:48 +00001616{
Blue Swirl72cf2d42009-09-12 07:36:22 +00001617 return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints);
aliguorie22a25c2009-03-12 20:12:48 +00001618}
1619
Glauber Costa452e4752009-07-16 17:55:28 -04001620struct kvm_set_guest_debug_data {
1621 struct kvm_guest_debug dbg;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001622 CPUArchState *env;
Glauber Costa452e4752009-07-16 17:55:28 -04001623 int err;
1624};
1625
1626static void kvm_invoke_set_guest_debug(void *data)
1627{
1628 struct kvm_set_guest_debug_data *dbg_data = data;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001629 CPUArchState *env = dbg_data->env;
Jan Kiszkab3807722009-09-17 20:05:58 +02001630
Jan Kiszkab3807722009-09-17 20:05:58 +02001631 dbg_data->err = kvm_vcpu_ioctl(env, KVM_SET_GUEST_DEBUG, &dbg_data->dbg);
Glauber Costa452e4752009-07-16 17:55:28 -04001632}
1633
Andreas Färber9349b4f2012-03-14 01:38:32 +01001634int kvm_update_guest_debug(CPUArchState *env, unsigned long reinject_trap)
aliguorie22a25c2009-03-12 20:12:48 +00001635{
Glauber Costa452e4752009-07-16 17:55:28 -04001636 struct kvm_set_guest_debug_data data;
aliguorie22a25c2009-03-12 20:12:48 +00001637
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001638 data.dbg.control = reinject_trap;
aliguorie22a25c2009-03-12 20:12:48 +00001639
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001640 if (env->singlestep_enabled) {
1641 data.dbg.control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
1642 }
Glauber Costa452e4752009-07-16 17:55:28 -04001643 kvm_arch_update_guest_debug(env, &data.dbg);
Glauber Costa452e4752009-07-16 17:55:28 -04001644 data.env = env;
aliguorie22a25c2009-03-12 20:12:48 +00001645
Jan Kiszkabe41cbe2010-05-20 00:28:45 +02001646 run_on_cpu(env, kvm_invoke_set_guest_debug, &data);
Glauber Costa452e4752009-07-16 17:55:28 -04001647 return data.err;
aliguorie22a25c2009-03-12 20:12:48 +00001648}
1649
Andreas Färber9349b4f2012-03-14 01:38:32 +01001650int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr,
aliguorie22a25c2009-03-12 20:12:48 +00001651 target_ulong len, int type)
1652{
1653 struct kvm_sw_breakpoint *bp;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001654 CPUArchState *env;
aliguorie22a25c2009-03-12 20:12:48 +00001655 int err;
1656
1657 if (type == GDB_BREAKPOINT_SW) {
1658 bp = kvm_find_sw_breakpoint(current_env, addr);
1659 if (bp) {
1660 bp->use_count++;
1661 return 0;
1662 }
1663
Anthony Liguori7267c092011-08-20 22:09:37 -05001664 bp = g_malloc(sizeof(struct kvm_sw_breakpoint));
Jan Kiszkaa426e122011-01-04 09:32:13 +01001665 if (!bp) {
aliguorie22a25c2009-03-12 20:12:48 +00001666 return -ENOMEM;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001667 }
aliguorie22a25c2009-03-12 20:12:48 +00001668
1669 bp->pc = addr;
1670 bp->use_count = 1;
1671 err = kvm_arch_insert_sw_breakpoint(current_env, bp);
1672 if (err) {
Anthony Liguori7267c092011-08-20 22:09:37 -05001673 g_free(bp);
aliguorie22a25c2009-03-12 20:12:48 +00001674 return err;
1675 }
1676
Blue Swirl72cf2d42009-09-12 07:36:22 +00001677 QTAILQ_INSERT_HEAD(&current_env->kvm_state->kvm_sw_breakpoints,
aliguorie22a25c2009-03-12 20:12:48 +00001678 bp, entry);
1679 } else {
1680 err = kvm_arch_insert_hw_breakpoint(addr, len, type);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001681 if (err) {
aliguorie22a25c2009-03-12 20:12:48 +00001682 return err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001683 }
aliguorie22a25c2009-03-12 20:12:48 +00001684 }
1685
1686 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1687 err = kvm_update_guest_debug(env, 0);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001688 if (err) {
aliguorie22a25c2009-03-12 20:12:48 +00001689 return err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001690 }
aliguorie22a25c2009-03-12 20:12:48 +00001691 }
1692 return 0;
1693}
1694
Andreas Färber9349b4f2012-03-14 01:38:32 +01001695int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr,
aliguorie22a25c2009-03-12 20:12:48 +00001696 target_ulong len, int type)
1697{
1698 struct kvm_sw_breakpoint *bp;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001699 CPUArchState *env;
aliguorie22a25c2009-03-12 20:12:48 +00001700 int err;
1701
1702 if (type == GDB_BREAKPOINT_SW) {
1703 bp = kvm_find_sw_breakpoint(current_env, addr);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001704 if (!bp) {
aliguorie22a25c2009-03-12 20:12:48 +00001705 return -ENOENT;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001706 }
aliguorie22a25c2009-03-12 20:12:48 +00001707
1708 if (bp->use_count > 1) {
1709 bp->use_count--;
1710 return 0;
1711 }
1712
1713 err = kvm_arch_remove_sw_breakpoint(current_env, bp);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001714 if (err) {
aliguorie22a25c2009-03-12 20:12:48 +00001715 return err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001716 }
aliguorie22a25c2009-03-12 20:12:48 +00001717
Blue Swirl72cf2d42009-09-12 07:36:22 +00001718 QTAILQ_REMOVE(&current_env->kvm_state->kvm_sw_breakpoints, bp, entry);
Anthony Liguori7267c092011-08-20 22:09:37 -05001719 g_free(bp);
aliguorie22a25c2009-03-12 20:12:48 +00001720 } else {
1721 err = kvm_arch_remove_hw_breakpoint(addr, len, type);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001722 if (err) {
aliguorie22a25c2009-03-12 20:12:48 +00001723 return err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001724 }
aliguorie22a25c2009-03-12 20:12:48 +00001725 }
1726
1727 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1728 err = kvm_update_guest_debug(env, 0);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001729 if (err) {
aliguorie22a25c2009-03-12 20:12:48 +00001730 return err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001731 }
aliguorie22a25c2009-03-12 20:12:48 +00001732 }
1733 return 0;
1734}
1735
Andreas Färber9349b4f2012-03-14 01:38:32 +01001736void kvm_remove_all_breakpoints(CPUArchState *current_env)
aliguorie22a25c2009-03-12 20:12:48 +00001737{
1738 struct kvm_sw_breakpoint *bp, *next;
1739 KVMState *s = current_env->kvm_state;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001740 CPUArchState *env;
aliguorie22a25c2009-03-12 20:12:48 +00001741
Blue Swirl72cf2d42009-09-12 07:36:22 +00001742 QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
aliguorie22a25c2009-03-12 20:12:48 +00001743 if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
1744 /* Try harder to find a CPU that currently sees the breakpoint. */
1745 for (env = first_cpu; env != NULL; env = env->next_cpu) {
Jan Kiszkaa426e122011-01-04 09:32:13 +01001746 if (kvm_arch_remove_sw_breakpoint(env, bp) == 0) {
aliguorie22a25c2009-03-12 20:12:48 +00001747 break;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001748 }
aliguorie22a25c2009-03-12 20:12:48 +00001749 }
1750 }
1751 }
1752 kvm_arch_remove_all_hw_breakpoints();
1753
Jan Kiszkaa426e122011-01-04 09:32:13 +01001754 for (env = first_cpu; env != NULL; env = env->next_cpu) {
aliguorie22a25c2009-03-12 20:12:48 +00001755 kvm_update_guest_debug(env, 0);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001756 }
aliguorie22a25c2009-03-12 20:12:48 +00001757}
1758
1759#else /* !KVM_CAP_SET_GUEST_DEBUG */
1760
Andreas Färber9349b4f2012-03-14 01:38:32 +01001761int kvm_update_guest_debug(CPUArchState *env, unsigned long reinject_trap)
aliguorie22a25c2009-03-12 20:12:48 +00001762{
1763 return -EINVAL;
1764}
1765
Andreas Färber9349b4f2012-03-14 01:38:32 +01001766int kvm_insert_breakpoint(CPUArchState *current_env, target_ulong addr,
aliguorie22a25c2009-03-12 20:12:48 +00001767 target_ulong len, int type)
1768{
1769 return -EINVAL;
1770}
1771
Andreas Färber9349b4f2012-03-14 01:38:32 +01001772int kvm_remove_breakpoint(CPUArchState *current_env, target_ulong addr,
aliguorie22a25c2009-03-12 20:12:48 +00001773 target_ulong len, int type)
1774{
1775 return -EINVAL;
1776}
1777
Andreas Färber9349b4f2012-03-14 01:38:32 +01001778void kvm_remove_all_breakpoints(CPUArchState *current_env)
aliguorie22a25c2009-03-12 20:12:48 +00001779{
1780}
1781#endif /* !KVM_CAP_SET_GUEST_DEBUG */
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001782
Andreas Färber9349b4f2012-03-14 01:38:32 +01001783int kvm_set_signal_mask(CPUArchState *env, const sigset_t *sigset)
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001784{
1785 struct kvm_signal_mask *sigmask;
1786 int r;
1787
Jan Kiszkaa426e122011-01-04 09:32:13 +01001788 if (!sigset) {
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001789 return kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, NULL);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001790 }
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001791
Anthony Liguori7267c092011-08-20 22:09:37 -05001792 sigmask = g_malloc(sizeof(*sigmask) + sizeof(*sigset));
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001793
1794 sigmask->len = 8;
1795 memcpy(sigmask->sigset, sigset, sizeof(*sigset));
1796 r = kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, sigmask);
Anthony Liguori7267c092011-08-20 22:09:37 -05001797 g_free(sigmask);
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001798
1799 return r;
1800}
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001801
Michael S. Tsirkin4b8f1c82012-03-20 14:31:38 +02001802int kvm_set_ioeventfd_mmio(int fd, uint32_t addr, uint32_t val, bool assign,
1803 uint32_t size)
Cam Macdonell44f1a3d2010-07-26 18:10:59 -06001804{
Cam Macdonell44f1a3d2010-07-26 18:10:59 -06001805 int ret;
1806 struct kvm_ioeventfd iofd;
1807
1808 iofd.datamatch = val;
1809 iofd.addr = addr;
Michael S. Tsirkin4b8f1c82012-03-20 14:31:38 +02001810 iofd.len = size;
Cam Macdonell44f1a3d2010-07-26 18:10:59 -06001811 iofd.flags = KVM_IOEVENTFD_FLAG_DATAMATCH;
1812 iofd.fd = fd;
1813
1814 if (!kvm_enabled()) {
1815 return -ENOSYS;
1816 }
1817
1818 if (!assign) {
1819 iofd.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
1820 }
1821
1822 ret = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &iofd);
1823
1824 if (ret < 0) {
1825 return -errno;
1826 }
1827
1828 return 0;
Cam Macdonell44f1a3d2010-07-26 18:10:59 -06001829}
1830
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001831int kvm_set_ioeventfd_pio_word(int fd, uint16_t addr, uint16_t val, bool assign)
1832{
1833 struct kvm_ioeventfd kick = {
1834 .datamatch = val,
1835 .addr = addr,
1836 .len = 2,
1837 .flags = KVM_IOEVENTFD_FLAG_DATAMATCH | KVM_IOEVENTFD_FLAG_PIO,
1838 .fd = fd,
1839 };
1840 int r;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001841 if (!kvm_enabled()) {
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001842 return -ENOSYS;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001843 }
1844 if (!assign) {
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001845 kick.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001846 }
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001847 r = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &kick);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001848 if (r < 0) {
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001849 return r;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001850 }
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001851 return 0;
Paolo Bonzini98c85732010-04-19 18:59:30 +00001852}
Jan Kiszkaa1b87fe2011-02-01 22:15:51 +01001853
Andreas Färber9349b4f2012-03-14 01:38:32 +01001854int kvm_on_sigbus_vcpu(CPUArchState *env, int code, void *addr)
Jan Kiszkaa1b87fe2011-02-01 22:15:51 +01001855{
1856 return kvm_arch_on_sigbus_vcpu(env, code, addr);
1857}
1858
1859int kvm_on_sigbus(int code, void *addr)
1860{
1861 return kvm_arch_on_sigbus(code, addr);
1862}