« back to all changes in this revision
Viewing changes to libkvm/libkvm.c
- browse files at revision 16
- compare with another revision
- download diff
- download tarball
- view history from revision 16
- Committer: Bazaar Package Importer
- Author(s): Soren Hansen
- Date: 2007-11-15 02:21:55 UTC
- mfrom: (1.1.10 upstream)
- Revision ID: james.westby@ubuntu.com-20071115022155-pxoxb8kfcrkn72mi
Tags: 1:52+dfsg-0ubuntu1
* New upstream release.
* 08_default_tdf.patch
- Make -tdf the default and add a -no-tdf option.
* 08_default_tdf.patch
- Make -tdf the default and add a -no-tdf option.
- files added:
- config.mak
- libkvm
- user/test/x86
- files removed:
- patches/kvm-48.patch
- files modified:
- Makefile
added
removed
libkvm/libkvm.c
1
/*
2
* Kernel-based Virtual Machine control library
3
*
4
* This library provides an API to control the kvm hardware virtualization
5
* module.
6
*
7
* Copyright (C) 2006 Qumranet
8
*
9
* Authors:
10
*
11
* Avi Kivity <avi@qumranet.com>
12
* Yaniv Kamay <yaniv@qumranet.com>
13
*
14
* This work is licensed under the GNU LGPL license, version 2.
15
*/
16
17
#ifndef __user
18
#define __user /* temporary, until installed via make headers_install */
19
#endif
20
21
#include <linux/kvm.h>
22
23
#define EXPECTED_KVM_API_VERSION 12
24
25
#if EXPECTED_KVM_API_VERSION != KVM_API_VERSION
26
#error libkvm: userspace and kernel version mismatch
27
#endif
28
29
#include <unistd.h>
30
#include <fcntl.h>
31
#include <stdio.h>
32
#include <stdlib.h>
33
#include <sys/mman.h>
34
#include <string.h>
35
#include <errno.h>
36
#include <sys/ioctl.h>
37
#include "libkvm.h"
38
#include "kvm-abi-10.h"
39
40
#if defined(__x86_64__) || defined(__i386__)
41
#include "kvm-x86.h"
42
#endif
43
44
int kvm_abi = EXPECTED_KVM_API_VERSION;
45
46
struct slot_info {
47
unsigned long phys_addr;
48
unsigned long len;
49
int user_alloc;
50
unsigned long userspace_addr;
51
};
52
53
struct slot_info slots[KVM_MAX_NUM_MEM_REGIONS];
54
55
void init_slots(void)
56
{
57
int i;
58
59
for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS; ++i)
60
slots[i].len = 0;
61
}
62
63
int get_free_slot(kvm_context_t kvm)
64
{
65
int i;
66
int tss_ext;
67
68
#ifdef KVM_CAP_SET_TSS_ADDR
69
tss_ext = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_SET_TSS_ADDR);
70
#else
71
tss_ext = 0;
72
#endif
73
74
/*
75
* on older kernels where the set tss ioctl is not supprted we must save
76
* slot 0 to hold the extended memory, as the vmx will use the last 3
77
* pages of this slot.
78
*/
79
if (tss_ext > 0)
80
i = 0;
81
else
82
i = 1;
83
84
for (; i < KVM_MAX_NUM_MEM_REGIONS; ++i)
85
if (!slots[i].len)
86
return i;
87
return -1;
88
}
89
90
void register_slot(int slot, unsigned long phys_addr, unsigned long len,
91
int user_alloc, unsigned long userspace_addr)
92
{
93
slots[slot].phys_addr = phys_addr;
94
slots[slot].len = len;
95
slots[slot].user_alloc = user_alloc;
96
slots[slot].userspace_addr = userspace_addr;
97
}
98
99
void free_slot(int slot)
100
{
101
slots[slot].len = 0;
102
}
103
104
int get_slot(unsigned long phys_addr)
105
{
106
int i;
107
108
for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS ; ++i) {
109
if (slots[i].len && slots[i].phys_addr <= phys_addr &&
110
(slots[i].phys_addr + slots[i].len) >= phys_addr)
111
return i;
112
}
113
return -1;
114
}
115
116
int get_intersecting_slot(unsigned long phys_addr)
117
{
118
int i;
119
120
for (i = 0; i < KVM_MAX_NUM_MEM_REGIONS ; ++i)
121
if (slots[i].len && slots[i].phys_addr < phys_addr &&
122
(slots[i].phys_addr + slots[i].len) > phys_addr)
123
return i;
124
return -1;
125
}
126
127
/*
128
* dirty pages logging control
129
*/
130
static int kvm_dirty_pages_log_change(kvm_context_t kvm, unsigned long phys_addr
131
, __u32 flag)
132
{
133
int r;
134
int slot;
135
136
slot = get_slot(phys_addr);
137
if (slot == -1) {
138
fprintf(stderr, "BUG: %s: invalid parameters\n", __FUNCTION__);
139
return 1;
140
}
141
#ifdef KVM_CAP_USER_MEMORY
142
if (slots[slot].user_alloc) {
143
struct kvm_userspace_memory_region mem = {
144
.slot = slot,
145
.memory_size = slots[slot].len,
146
.guest_phys_addr = slots[slot].phys_addr,
147
.userspace_addr = slots[slot].userspace_addr,
148
.flags = flag,
149
};
150
r = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &mem);
151
}
152
#endif
153
if (!slots[slot].user_alloc) {
154
struct kvm_memory_region mem = {
155
.slot = slot,
156
.memory_size = slots[slot].len,
157
.guest_phys_addr = slots[slot].phys_addr,
158
.flags = flag,
159
};
160
r = ioctl(kvm->vm_fd, KVM_SET_MEMORY_REGION, &mem);
161
}
162
if (r == -1)
163
fprintf(stderr, "%s: %m\n", __FUNCTION__);
164
return r;
165
}
166
167
static int kvm_dirty_pages_log_change_all(kvm_context_t kvm, __u32 flag)
168
{
169
int i, r;
170
171
for (i=r=0; i<KVM_MAX_NUM_MEM_REGIONS && r==0; i++) {
172
if (slots[i].len)
173
r = kvm_dirty_pages_log_change(kvm, slots[i].phys_addr,
174
flag);
175
}
176
return r;
177
}
178
179
/**
180
* Enable dirty page logging for all memory regions
181
*/
182
int kvm_dirty_pages_log_enable_all(kvm_context_t kvm)
183
{
184
if (kvm->dirty_pages_log_all)
185
return 0;
186
kvm->dirty_pages_log_all = 1;
187
return kvm_dirty_pages_log_change_all(kvm, KVM_MEM_LOG_DIRTY_PAGES);
188
}
189
190
/**
191
* Enable dirty page logging only for memory regions that were created with
192
* dirty logging enabled (disable for all other memory regions).
193
*/
194
int kvm_dirty_pages_log_reset(kvm_context_t kvm)
195
{
196
if (!kvm->dirty_pages_log_all)
197
return 0;
198
kvm->dirty_pages_log_all = 0;
199
return kvm_dirty_pages_log_change_all(kvm, 0);
200
}
201
202
203
kvm_context_t kvm_init(struct kvm_callbacks *callbacks,
204
void *opaque)
205
{
206
int fd;
207
kvm_context_t kvm;
208
int r;
209
210
fd = open("/dev/kvm", O_RDWR);
211
if (fd == -1) {
212
perror("open /dev/kvm");
213
return NULL;
214
}
215
r = ioctl(fd, KVM_GET_API_VERSION, 0);
216
if (r == -1) {
217
fprintf(stderr, "kvm kernel version too old: "
218
"KVM_GET_API_VERSION ioctl not supported\n");
219
goto out_close;
220
}
221
if (r < EXPECTED_KVM_API_VERSION && r != 10) {
222
fprintf(stderr, "kvm kernel version too old: "
223
"We expect API version %d or newer, but got "
224
"version %d\n",
225
EXPECTED_KVM_API_VERSION, r);
226
goto out_close;
227
}
228
if (r > EXPECTED_KVM_API_VERSION) {
229
fprintf(stderr, "kvm userspace version too old\n");
230
goto out_close;
231
}
232
kvm_abi = r;
233
kvm = malloc(sizeof(*kvm));
234
kvm->fd = fd;
235
kvm->vm_fd = -1;
236
kvm->callbacks = callbacks;
237
kvm->opaque = opaque;
238
kvm->dirty_pages_log_all = 0;
239
kvm->no_irqchip_creation = 0;
240
memset(&kvm->mem_regions, 0, sizeof(kvm->mem_regions));
241
242
return kvm;
243
out_close:
244
close(fd);
245
return NULL;
246
}
247
248
void kvm_finalize(kvm_context_t kvm)
249
{
250
if (kvm->vcpu_fd[0] != -1)
251
close(kvm->vcpu_fd[0]);
252
if (kvm->vm_fd != -1)
253
close(kvm->vm_fd);
254
close(kvm->fd);
255
free(kvm);
256
}
257
258
void kvm_disable_irqchip_creation(kvm_context_t kvm)
259
{
260
kvm->no_irqchip_creation = 1;
261
}
262
263
int kvm_create_vcpu(kvm_context_t kvm, int slot)
264
{
265
long mmap_size;
266
int r;
267
268
r = ioctl(kvm->vm_fd, KVM_CREATE_VCPU, slot);
269
if (r == -1) {
270
r = -errno;
271
fprintf(stderr, "kvm_create_vcpu: %m\n");
272
return r;
273
}
274
kvm->vcpu_fd[slot] = r;
275
mmap_size = ioctl(kvm->fd, KVM_GET_VCPU_MMAP_SIZE, 0);
276
if (mmap_size == -1) {
277
r = -errno;
278
fprintf(stderr, "get vcpu mmap size: %m\n");
279
return r;
280
}
281
kvm->run[slot] = mmap(NULL, mmap_size, PROT_READ|PROT_WRITE, MAP_SHARED,
282
kvm->vcpu_fd[slot], 0);
283
if (kvm->run[slot] == MAP_FAILED) {
284
r = -errno;
285
fprintf(stderr, "mmap vcpu area: %m\n");
286
return r;
287
}
288
return 0;
289
}
290
291
int kvm_set_shadow_pages(kvm_context_t kvm, unsigned int nrshadow_pages)
292
{
293
#ifdef KVM_CAP_MMU_SHADOW_CACHE_CONTROL
294
int r;
295
296
r = ioctl(kvm->fd, KVM_CHECK_EXTENSION,
297
KVM_CAP_MMU_SHADOW_CACHE_CONTROL);
298
if (r > 0) {
299
r = ioctl(kvm->vm_fd, KVM_SET_NR_MMU_PAGES, nrshadow_pages);
300
if (r == -1) {
301
fprintf(stderr, "kvm_set_shadow_pages: %m\n");
302
return -errno;
303
}
304
return 0;
305
}
306
#endif
307
return -1;
308
}
309
310
int kvm_get_shadow_pages(kvm_context_t kvm, unsigned int *nrshadow_pages)
311
{
312
#ifdef KVM_CAP_MMU_SHADOW_CACHE_CONTROL
313
int r;
314
315
r = ioctl(kvm->fd, KVM_CHECK_EXTENSION,
316
KVM_CAP_MMU_SHADOW_CACHE_CONTROL);
317
if (r > 0) {
318
*nrshadow_pages = ioctl(kvm->vm_fd, KVM_GET_NR_MMU_PAGES);
319
return 0;
320
}
321
#endif
322
return -1;
323
}
324
325
326
int kvm_create_vm(kvm_context_t kvm)
327
{
328
int fd = kvm->fd;
329
330
kvm->vcpu_fd[0] = -1;
331
332
fd = ioctl(fd, KVM_CREATE_VM, 0);
333
if (fd == -1) {
334
fprintf(stderr, "kvm_create_vm: %m\n");
335
return -1;
336
}
337
kvm->vm_fd = fd;
338
return 0;
339
}
340
341
static int kvm_create_default_phys_mem(kvm_context_t kvm,
342
unsigned long phys_mem_bytes,
343
void **vm_mem)
344
{
345
unsigned long memory = (phys_mem_bytes + PAGE_SIZE - 1) & PAGE_MASK;
346
int r;
347
348
#ifdef KVM_CAP_USER_MEMORY
349
r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_USER_MEMORY);
350
if (r > 0)
351
return 0;
352
else
353
#endif
354
r = kvm_alloc_kernel_memory(kvm, memory, vm_mem);
355
if (r < 0)
356
return r;
357
358
r = kvm_arch_create_default_phys_mem(kvm, phys_mem_bytes, vm_mem);
359
if (r < 0)
360
return r;
361
362
kvm->physical_memory = *vm_mem;
363
return 0;
364
}
365
366
int kvm_check_extension(kvm_context_t kvm, int ext)
367
{
368
int ret;
369
370
ret = ioctl(kvm->fd, KVM_CHECK_EXTENSION, ext);
371
if (ret > 0)
372
return 1;
373
return 0;
374
}
375
376
void kvm_create_irqchip(kvm_context_t kvm)
377
{
378
int r;
379
380
kvm->irqchip_in_kernel = 0;
381
#ifdef KVM_CAP_IRQCHIP
382
if (!kvm->no_irqchip_creation) {
383
r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_IRQCHIP);
384
if (r > 0) { /* kernel irqchip supported */
385
r = ioctl(kvm->vm_fd, KVM_CREATE_IRQCHIP);
386
if (r >= 0)
387
kvm->irqchip_in_kernel = 1;
388
else
389
printf("Create kernel PIC irqchip failed\n");
390
}
391
}
392
#endif
393
}
394
395
int kvm_create(kvm_context_t kvm, unsigned long phys_mem_bytes, void **vm_mem)
396
{
397
int r;
398
399
r = kvm_create_vm(kvm);
400
if (r < 0)
401
return r;
402
r = kvm_arch_create(kvm, phys_mem_bytes, vm_mem);
403
if (r < 0)
404
return r;
405
init_slots();
406
r = kvm_create_default_phys_mem(kvm, phys_mem_bytes, vm_mem);
407
if (r < 0)
408
return r;
409
kvm_create_irqchip(kvm);
410
r = kvm_create_vcpu(kvm, 0);
411
if (r < 0)
412
return r;
413
414
return 0;
415
}
416
417
418
#ifdef KVM_CAP_USER_MEMORY
419
420
void *kvm_create_userspace_phys_mem(kvm_context_t kvm, unsigned long phys_start,
421
unsigned long len, int log, int writable)
422
{
423
int r;
424
int prot = PROT_READ;
425
void *ptr;
426
struct kvm_userspace_memory_region memory = {
427
.memory_size = len,
428
.guest_phys_addr = phys_start,
429
.flags = log ? KVM_MEM_LOG_DIRTY_PAGES : 0,
430
};
431
432
if (writable)
433
prot |= PROT_WRITE;
434
435
ptr = mmap(NULL, len, prot, MAP_ANONYMOUS | MAP_SHARED, -1, 0);
436
if (ptr == MAP_FAILED) {
437
fprintf(stderr, "create_userspace_phys_mem: %s", strerror(errno));
438
return 0;
439
}
440
441
memset(ptr, 0, len);
442
443
memory.userspace_addr = (unsigned long)ptr;
444
memory.slot = get_free_slot(kvm);
445
r = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &memory);
446
if (r == -1) {
447
fprintf(stderr, "create_userspace_phys_mem: %s", strerror(errno));
448
return 0;
449
}
450
register_slot(memory.slot, memory.guest_phys_addr, memory.memory_size,
451
1, memory.userspace_addr);
452
453
return ptr;
454
}
455
456
#endif
457
458
void *kvm_create_phys_mem(kvm_context_t kvm, unsigned long phys_start,
459
unsigned long len, int log, int writable)
460
{
461
#ifdef KVM_CAP_USER_MEMORY
462
int r;
463
464
r = ioctl(kvm->fd, KVM_CHECK_EXTENSION, KVM_CAP_USER_MEMORY);
465
if (r > 0)
466
return kvm_create_userspace_phys_mem(kvm, phys_start, len,
467
log, writable);
468
else
469
#endif
470
return kvm_create_kernel_phys_mem(kvm, phys_start, len,
471
log, writable);
472
}
473
474
int kvm_is_intersecting_mem(kvm_context_t kvm, unsigned long phys_start)
475
{
476
return get_intersecting_slot(phys_start) != -1;
477
}
478
479
int kvm_is_allocated_mem(kvm_context_t kvm, unsigned long phys_start,
480
unsigned long len)
481
{
482
int slot;
483
484
slot = get_slot(phys_start);
485
if (slot == -1)
486
return 0;
487
if (slots[slot].len == len)
488
return 1;
489
return 0;
490
}
491
492
int kvm_create_mem_hole(kvm_context_t kvm, unsigned long phys_start,
493
unsigned long len)
494
{
495
#ifdef KVM_CAP_USER_MEMORY
496
int slot;
497
int r;
498
struct kvm_userspace_memory_region rmslot;
499
struct kvm_userspace_memory_region newslot1;
500
struct kvm_userspace_memory_region newslot2;
501
502
len = (len + PAGE_SIZE - 1) & PAGE_MASK;
503
504
slot = get_intersecting_slot(phys_start);
505
/* no need to create hole, as there is already hole */
506
if (slot == -1)
507
return 0;
508
509
memset(&rmslot, 0, sizeof(struct kvm_userspace_memory_region));
510
memset(&newslot1, 0, sizeof(struct kvm_userspace_memory_region));
511
memset(&newslot2, 0, sizeof(struct kvm_userspace_memory_region));
512
513
rmslot.guest_phys_addr = slots[slot].phys_addr;
514
rmslot.slot = slot;
515
516
newslot1.guest_phys_addr = slots[slot].phys_addr;
517
newslot1.memory_size = phys_start - slots[slot].phys_addr;
518
newslot1.slot = slot;
519
newslot1.userspace_addr = slots[slot].userspace_addr;
520
521
newslot2.guest_phys_addr = newslot1.guest_phys_addr +
522
newslot1.memory_size + len;
523
newslot2.memory_size = slots[slot].phys_addr +
524
slots[slot].len - newslot2.guest_phys_addr;
525
newslot2.userspace_addr = newslot1.userspace_addr +
526
newslot1.memory_size;
527
newslot2.slot = get_free_slot(kvm);
528
529
r = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &rmslot);
530
if (r == -1) {
531
fprintf(stderr, "kvm_create_mem_hole: %s\n", strerror(errno));
532
return -1;
533
}
534
free_slot(slot);
535
536
r = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &newslot1);
537
if (r == -1) {
538
fprintf(stderr, "kvm_create_mem_hole: %s\n", strerror(errno));
539
return -1;
540
}
541
register_slot(newslot1.slot, newslot1.guest_phys_addr,
542
newslot1.memory_size, 1, newslot1.userspace_addr);
543
544
r = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &newslot2);
545
if (r == -1) {
546
fprintf(stderr, "kvm_create_mem_hole: %s\n", strerror(errno));
547
return -1;
548
}
549
register_slot(newslot2.slot, newslot2.guest_phys_addr,
550
newslot2.memory_size, 1, newslot2.userspace_addr);
551
#endif
552
return 0;
553
}
554
555
int kvm_register_userspace_phys_mem(kvm_context_t kvm,
556
unsigned long phys_start, void *userspace_addr,
557
unsigned long len, int log)
558
{
559
#ifdef KVM_CAP_USER_MEMORY
560
struct kvm_userspace_memory_region memory = {
561
.memory_size = len,
562
.guest_phys_addr = phys_start,
563
.userspace_addr = (intptr_t)userspace_addr,
564
.flags = log ? KVM_MEM_LOG_DIRTY_PAGES : 0,
565
};
566
int r;
567
568
if (!kvm->physical_memory)
569
kvm->physical_memory = userspace_addr - phys_start;
570
571
memory.slot = get_free_slot(kvm);
572
r = ioctl(kvm->vm_fd, KVM_SET_USER_MEMORY_REGION, &memory);
573
if (r == -1) {
574
fprintf(stderr, "create_userspace_phys_mem: %s\n", strerror(errno));
575
return -1;
576
}
577
register_slot(memory.slot, memory.guest_phys_addr, memory.memory_size,
578
1, memory.userspace_addr);
579
return 0;
580
#else
581
return -ENOSYS;
582
#endif
583
}
584
585
586
/* destroy/free a whole slot.
587
* phys_start, len and slot are the params passed to kvm_create_phys_mem()
588
*/
589
void kvm_destroy_phys_mem(kvm_context_t kvm, unsigned long phys_start,
590
unsigned long len)
591
{
592
int slot;
593
struct kvm_memory_region *mem;
594
595
slot = get_slot(phys_start);
596
597
if (slot >= KVM_MAX_NUM_MEM_REGIONS) {
598
fprintf(stderr, "BUG: %s: invalid parameters (slot=%d)\n",
599
__FUNCTION__, slot);
600
return;
601
}
602
mem = &kvm->mem_regions[slot];
603
if (phys_start != mem->guest_phys_addr) {
604
fprintf(stderr,
605
"WARNING: %s: phys_start is 0x%lx expecting 0x%llx\n",
606
__FUNCTION__, phys_start, mem->guest_phys_addr);
607
phys_start = mem->guest_phys_addr;
608
}
609
kvm_create_phys_mem(kvm, phys_start, 0, 0, 0);
610
}
611
612
static int kvm_get_map(kvm_context_t kvm, int ioctl_num, int slot, void *buf)
613
{
614
int r;
615
struct kvm_dirty_log log = {
616
.slot = slot,
617
};
618
619
log.dirty_bitmap = buf;
620
621
r = ioctl(kvm->vm_fd, ioctl_num, &log);
622
if (r == -1)
623
return -errno;
624
return 0;
625
}
626
627
int kvm_get_dirty_pages(kvm_context_t kvm, unsigned long phys_addr, void *buf)
628
{
629
int slot;
630
631
slot = get_slot(phys_addr);
632
return kvm_get_map(kvm, KVM_GET_DIRTY_LOG, slot, buf);
633
}
634
635
int kvm_get_mem_map(kvm_context_t kvm, unsigned long phys_addr, void *buf)
636
{
637
int slot;
638
639
slot = get_slot(phys_addr);
640
#ifdef KVM_GET_MEM_MAP
641
return kvm_get_map(kvm, KVM_GET_MEM_MAP, slot, buf);
642
#else /* not KVM_GET_MEM_MAP ==> fake it: all pages exist */
643
unsigned long i, n, m, npages;
644
unsigned char v;
645
646
if (slot >= KVM_MAX_NUM_MEM_REGIONS) {
647
errno = -EINVAL;
648
return -1;
649
}
650
npages = kvm->mem_regions[slot].memory_size / PAGE_SIZE;
651
n = npages / 8;
652
m = npages % 8;
653
memset(buf, 0xff, n); /* all pages exist */
654
v = 0;
655
for (i=0; i<=m; i++) /* last byte may not be "aligned" */
656
v |= 1<<(7-i);
657
if (v)
658
*(unsigned char*)(buf+n) = v;
659
return 0;
660
#endif /* KVM_GET_MEM_MAP */
661
}
662
663
#ifdef KVM_CAP_IRQCHIP
664
665
int kvm_set_irq_level(kvm_context_t kvm, int irq, int level)
666
{
667
struct kvm_irq_level event;
668
int r;
669
670
if (!kvm->irqchip_in_kernel)
671
return 0;
672
event.level = level;
673
event.irq = irq;
674
r = ioctl(kvm->vm_fd, KVM_IRQ_LINE, &event);
675
if (r == -1)
676
perror("kvm_set_irq_level");
677
return 1;
678
}
679
680
int kvm_get_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip)
681
{
682
int r;
683
684
if (!kvm->irqchip_in_kernel)
685
return 0;
686
r = ioctl(kvm->vm_fd, KVM_GET_IRQCHIP, chip);
687
if (r == -1) {
688
r = -errno;
689
perror("kvm_get_irqchip\n");
690
}
691
return r;
692
}
693
694
int kvm_set_irqchip(kvm_context_t kvm, struct kvm_irqchip *chip)
695
{
696
int r;
697
698
if (!kvm->irqchip_in_kernel)
699
return 0;
700
r = ioctl(kvm->vm_fd, KVM_SET_IRQCHIP, chip);
701
if (r == -1) {
702
r = -errno;
703
perror("kvm_set_irqchip\n");
704
}
705
return r;
706
}
707
708
#endif
709
710
static int handle_io(kvm_context_t kvm, struct kvm_run *run, int vcpu)
711
{
712
uint16_t addr = run->io.port;
713
int r;
714
int i;
715
void *p = (void *)run + run->io.data_offset;
716
717
for (i = 0; i < run->io.count; ++i) {
718
switch (run->io.direction) {
719
case KVM_EXIT_IO_IN:
720
switch (run->io.size) {
721
case 1:
722
r = kvm->callbacks->inb(kvm->opaque, addr, p);
723
break;
724
case 2:
725
r = kvm->callbacks->inw(kvm->opaque, addr, p);
726
break;
727
case 4:
728
r = kvm->callbacks->inl(kvm->opaque, addr, p);
729
break;
730
default:
731
fprintf(stderr, "bad I/O size %d\n", run->io.size);
732
return -EMSGSIZE;
733
}
734
break;
735
case KVM_EXIT_IO_OUT:
736
switch (run->io.size) {
737
case 1:
738
r = kvm->callbacks->outb(kvm->opaque, addr,
739
*(uint8_t *)p);
740
break;
741
case 2:
742
r = kvm->callbacks->outw(kvm->opaque, addr,
743
*(uint16_t *)p);
744
break;
745
case 4:
746
r = kvm->callbacks->outl(kvm->opaque, addr,
747
*(uint32_t *)p);
748
break;
749
default:
750
fprintf(stderr, "bad I/O size %d\n", run->io.size);
751
return -EMSGSIZE;
752
}
753
break;
754
default:
755
fprintf(stderr, "bad I/O direction %d\n", run->io.direction);
756
return -EPROTO;
757
}
758
759
p += run->io.size;
760
}
761
762
return 0;
763
}
764
765
int handle_debug(kvm_context_t kvm, int vcpu)
766
{
767
return kvm->callbacks->debug(kvm->opaque, vcpu);
768
}
769
770
int kvm_get_regs(kvm_context_t kvm, int vcpu, struct kvm_regs *regs)
771
{
772
return ioctl(kvm->vcpu_fd[vcpu], KVM_GET_REGS, regs);
773
}
774
775
int kvm_set_regs(kvm_context_t kvm, int vcpu, struct kvm_regs *regs)
776
{
777
return ioctl(kvm->vcpu_fd[vcpu], KVM_SET_REGS, regs);
778
}
779
780
int kvm_get_fpu(kvm_context_t kvm, int vcpu, struct kvm_fpu *fpu)
781
{
782
return ioctl(kvm->vcpu_fd[vcpu], KVM_GET_FPU, fpu);
783
}
784
785
int kvm_set_fpu(kvm_context_t kvm, int vcpu, struct kvm_fpu *fpu)
786
{
787
return ioctl(kvm->vcpu_fd[vcpu], KVM_SET_FPU, fpu);
788
}
789
790
int kvm_get_sregs(kvm_context_t kvm, int vcpu, struct kvm_sregs *sregs)
791
{
792
return ioctl(kvm->vcpu_fd[vcpu], KVM_GET_SREGS, sregs);
793
}
794
795
int kvm_set_sregs(kvm_context_t kvm, int vcpu, struct kvm_sregs *sregs)
796
{
797
return ioctl(kvm->vcpu_fd[vcpu], KVM_SET_SREGS, sregs);
798
}
799
800
static int handle_mmio(kvm_context_t kvm, struct kvm_run *kvm_run)
801
{
802
unsigned long addr = kvm_run->mmio.phys_addr;
803
void *data = kvm_run->mmio.data;
804
int r = -1;
805
806
/* hack: Red Hat 7.1 generates these wierd accesses. */
807
if (addr == 0xa0000 && kvm_run->mmio.len == 3)
808
return 0;
809
810
if (kvm_run->mmio.is_write) {
811
switch (kvm_run->mmio.len) {
812
case 1:
813
r = kvm->callbacks->writeb(kvm->opaque, addr, *(uint8_t *)data);
814
break;
815
case 2:
816
r = kvm->callbacks->writew(kvm->opaque, addr, *(uint16_t *)data);
817
break;
818
case 4:
819
r = kvm->callbacks->writel(kvm->opaque, addr, *(uint32_t *)data);
820
break;
821
case 8:
822
r = kvm->callbacks->writeq(kvm->opaque, addr, *(uint64_t *)data);
823
break;
824
}
825
} else {
826
switch (kvm_run->mmio.len) {
827
case 1:
828
r = kvm->callbacks->readb(kvm->opaque, addr, (uint8_t *)data);
829
break;
830
case 2:
831
r = kvm->callbacks->readw(kvm->opaque, addr, (uint16_t *)data);
832
break;
833
case 4:
834
r = kvm->callbacks->readl(kvm->opaque, addr, (uint32_t *)data);
835
break;
836
case 8:
837
r = kvm->callbacks->readq(kvm->opaque, addr, (uint64_t *)data);
838
break;
839
}
840
}
841
return r;
842
}
843
844
int handle_io_window(kvm_context_t kvm)
845
{
846
return kvm->callbacks->io_window(kvm->opaque);
847
}
848
849
int handle_halt(kvm_context_t kvm, int vcpu)
850
{
851
return kvm->callbacks->halt(kvm->opaque, vcpu);
852
}
853
854
int handle_shutdown(kvm_context_t kvm, int vcpu)
855
{
856
return kvm->callbacks->shutdown(kvm->opaque, vcpu);
857
}
858
859
int try_push_interrupts(kvm_context_t kvm)
860
{
861
return kvm->callbacks->try_push_interrupts(kvm->opaque);
862
}
863
864
void post_kvm_run(kvm_context_t kvm, int vcpu)
865
{
866
kvm->callbacks->post_kvm_run(kvm->opaque, vcpu);
867
}
868
869
int pre_kvm_run(kvm_context_t kvm, int vcpu)
870
{
871
return kvm->callbacks->pre_kvm_run(kvm->opaque, vcpu);
872
}
873
874
int kvm_get_interrupt_flag(kvm_context_t kvm, int vcpu)
875
{
876
struct kvm_run *run = kvm->run[vcpu];
877
878
if (kvm_abi == 10)
879
return ((struct kvm_run_abi10 *)run)->if_flag;
880
return run->if_flag;
881
}
882
883
int kvm_is_ready_for_interrupt_injection(kvm_context_t kvm, int vcpu)
884
{
885
struct kvm_run *run = kvm->run[vcpu];
886
887
if (kvm_abi == 10)
888
return ((struct kvm_run_abi10 *)run)->ready_for_interrupt_injection;
889
return run->ready_for_interrupt_injection;
890
}
891
892
int kvm_run(kvm_context_t kvm, int vcpu)
893
{
894
int r;
895
int fd = kvm->vcpu_fd[vcpu];
896
struct kvm_run *run = kvm->run[vcpu];
897
898
if (kvm_abi == 10)
899
return kvm_run_abi10(kvm, vcpu);
900
901
again:
902
if (!kvm->irqchip_in_kernel)
903
run->request_interrupt_window = try_push_interrupts(kvm);
904
r = pre_kvm_run(kvm, vcpu);
905
if (r)
906
return r;
907
r = ioctl(fd, KVM_RUN, 0);
908
post_kvm_run(kvm, vcpu);
909
910
if (r == -1 && errno != EINTR && errno != EAGAIN) {
911
r = -errno;
912
printf("kvm_run: %m\n");
913
return r;
914
}
915
if (r == -1) {
916
r = handle_io_window(kvm);
917
goto more;
918
}
919
if (1) {
920
switch (run->exit_reason) {
921
case KVM_EXIT_UNKNOWN:
922
fprintf(stderr, "unhandled vm exit: 0x%x vcpu_id %d\n",
923
(unsigned)run->hw.hardware_exit_reason, vcpu);
924
kvm_show_regs(kvm, vcpu);
925
abort();
926
break;
927
case KVM_EXIT_FAIL_ENTRY:
928
fprintf(stderr, "kvm_run: failed entry, reason %u\n",
929
(unsigned)run->fail_entry.hardware_entry_failure_reason & 0xffff);
930
return -ENOEXEC;
931
break;
932
case KVM_EXIT_EXCEPTION:
933
fprintf(stderr, "exception %d (%x)\n",
934
run->ex.exception,
935
run->ex.error_code);
936
kvm_show_regs(kvm, vcpu);
937
kvm_show_code(kvm, vcpu);
938
abort();
939
break;
940
case KVM_EXIT_IO:
941
r = handle_io(kvm, run, vcpu);
942
break;
943
case KVM_EXIT_DEBUG:
944
r = handle_debug(kvm, vcpu);
945
break;
946
case KVM_EXIT_MMIO:
947
r = handle_mmio(kvm, run);
948
break;
949
case KVM_EXIT_HLT:
950
r = handle_halt(kvm, vcpu);
951
break;
952
case KVM_EXIT_IRQ_WINDOW_OPEN:
953
break;
954
case KVM_EXIT_SHUTDOWN:
955
r = handle_shutdown(kvm, vcpu);
956
break;
957
#ifdef KVM_EXIT_SET_TPR
958
case KVM_EXIT_SET_TPR:
959
break;
960
#endif
961
default:
962
fprintf(stderr, "unhandled vm exit: 0x%x\n", run->exit_reason);
963
kvm_show_regs(kvm, vcpu);
964
abort();
965
break;
966
}
967
}
968
more:
969
if (!r)
970
goto again;
971
return r;
972
}
973
974
int kvm_inject_irq(kvm_context_t kvm, int vcpu, unsigned irq)
975
{
976
struct kvm_interrupt intr;
977
978
intr.irq = irq;
979
return ioctl(kvm->vcpu_fd[vcpu], KVM_INTERRUPT, &intr);
980
}
981
982
int kvm_guest_debug(kvm_context_t kvm, int vcpu, struct kvm_debug_guest *dbg)
983
{
984
return ioctl(kvm->vcpu_fd[vcpu], KVM_DEBUG_GUEST, dbg);
985
}
986
987
int kvm_set_signal_mask(kvm_context_t kvm, int vcpu, const sigset_t *sigset)
988
{
989
struct kvm_signal_mask *sigmask;
990
int r;
991
992
if (!sigset) {
993
r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_SIGNAL_MASK, NULL);
994
if (r == -1)
995
r = -errno;
996
return r;
997
}
998
sigmask = malloc(sizeof(*sigmask) + sizeof(*sigset));
999
if (!sigmask)
1000
return -ENOMEM;
1001
1002
sigmask->len = 8;
1003
memcpy(sigmask->sigset, sigset, sizeof(*sigset));
1004
r = ioctl(kvm->vcpu_fd[vcpu], KVM_SET_SIGNAL_MASK, sigmask);
1005
if (r == -1)
1006
r = -errno;
1007
free(sigmask);
1008
return r;
1009
}
1010
1011
int kvm_irqchip_in_kernel(kvm_context_t kvm)
1012
{
1013
return kvm->irqchip_in_kernel;
1014
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1