qemu-kvm.c

   1 /*
   2  * qemu/kvm integration
   3  *
   4  * Copyright (C) 2006-2008 Qumranet Technologies
   5  *
   6  * Licensed under the terms of the GNU GPL version 2 or higher.
   7  */
   8 #include "config.h"
   9 #include "config-host.h"
  10
  11 #include <assert.h>
  12 #include <string.h>
  13 #include "hw/hw.h"
  14 #include "sysemu.h"
  15 #include "qemu-common.h"
  16 #include "console.h"
  17 #include "block.h"
  18 #include "compatfd.h"
  19 #include "gdbstub.h"
  20 #include "monitor.h"
  21 #include "cpus.h"
  22
  23 #include "qemu-kvm.h"
  24
  25 #define EXPECTED_KVM_API_VERSION 12
  26
  27 #if EXPECTED_KVM_API_VERSION != KVM_API_VERSION
  28 #error libkvm: userspace and kernel version mismatch
  29 #endif
  30
  31 int kvm_irqchip = 1;
  32 int kvm_pit = 1;
  33 int kvm_pit_reinject = 1;
  34
  35 #define ALIGN(x, y) (((x)+(y)-1) & ~((y)-1))
  36
  37 static inline void set_gsi(KVMState *s, unsigned int gsi)
  38 {
  39     uint32_t *bitmap = s->used_gsi_bitmap;
  40
  41     if (gsi < s->max_gsi) {
  42         bitmap[gsi / 32] |= 1U << (gsi % 32);
  43     } else {
  44         DPRINTF("Invalid GSI %u\n", gsi);
  45     }
  46 }
  47
  48 static inline void clear_gsi(KVMState *s, unsigned int gsi)
  49 {
  50     uint32_t *bitmap = s->used_gsi_bitmap;
  51
  52     if (gsi < s->max_gsi) {
  53         bitmap[gsi / 32] &= ~(1U << (gsi % 32));
  54     } else {
  55         DPRINTF("Invalid GSI %u\n", gsi);
  56     }
  57 }
  58
  59 static int kvm_init_irq_routing(KVMState *s)
  60 {
  61 #ifdef KVM_CAP_IRQ_ROUTING
  62     int r, gsi_count;
  63
  64     gsi_count = kvm_check_extension(s, KVM_CAP_IRQ_ROUTING);
  65     if (gsi_count > 0) {
  66         int gsi_bits, i;
  67
  68         /* Round up so we can search ints using ffs */
  69         gsi_bits = ALIGN(gsi_count, 32);
  70         s->used_gsi_bitmap = g_malloc0(gsi_bits / 8);
  71         s->max_gsi = gsi_bits;
  72
  73         /* Mark any over-allocated bits as already in use */
  74         for (i = gsi_count; i < gsi_bits; i++) {
  75             set_gsi(s, i);
  76         }
  77     }
  78
  79     s->irq_routes = g_malloc0(sizeof(*s->irq_routes));
  80     s->nr_allocated_irq_routes = 0;
  81
  82     r = kvm_arch_init_irq_routing();
  83     if (r < 0) {
  84         return r;
  85     }
  86 #endif
  87
  88     return 0;
  89 }
  90
  91 int kvm_create_irqchip(KVMState *s)
  92 {
  93 #ifdef KVM_CAP_IRQCHIP
  94     int r;
  95
  96     if (!kvm_irqchip || !kvm_check_extension(s, KVM_CAP_IRQCHIP)) {
  97         return 0;
  98     }
  99
 100     r = kvm_vm_ioctl(s, KVM_CREATE_IRQCHIP);
 101     if (r < 0) {
 102         fprintf(stderr, "Create kernel PIC irqchip failed\n");
 103         return r;
 104     }
 105
 106     s->irqchip_inject_ioctl = KVM_IRQ_LINE;
 107 #if defined(KVM_CAP_IRQ_INJECT_STATUS) && defined(KVM_IRQ_LINE_STATUS)
 108     if (kvm_check_extension(s, KVM_CAP_IRQ_INJECT_STATUS)) {
 109         s->irqchip_inject_ioctl = KVM_IRQ_LINE_STATUS;
 110     }
 111 #endif
 112     s->irqchip_in_kernel = 1;
 113
 114     r = kvm_init_irq_routing(s);
 115     if (r < 0) {
 116         return r;
 117     }
 118 #endif
 119
 120     return 0;
 121 }
 122
 123 #ifdef KVM_CAP_IRQCHIP
 124
 125 int kvm_set_irq(int irq, int level, int *status)
 126 {
 127     struct kvm_irq_level event;
 128     int r;
 129
 130     if (!kvm_state->irqchip_in_kernel) {
 131         return 0;
 132     }
 133     event.level = level;
 134     event.irq = irq;
 135     r = kvm_vm_ioctl(kvm_state, kvm_state->irqchip_inject_ioctl,
 136                      &event);
 137     if (r < 0) {
 138         perror("kvm_set_irq");
 139     }
 140
 141     if (status) {
 142 #ifdef KVM_CAP_IRQ_INJECT_STATUS
 143         *status = (kvm_state->irqchip_inject_ioctl == KVM_IRQ_LINE) ?
 144             1 : event.status;
 145 #else
 146         *status = 1;
 147 #endif
 148     }
 149
 150     return 1;
 151 }
 152
 153 int kvm_get_irqchip(KVMState *s, struct kvm_irqchip *chip)
 154 {
 155     int r;
 156
 157     if (!s->irqchip_in_kernel) {
 158         return 0;
 159     }
 160     r = kvm_vm_ioctl(s, KVM_GET_IRQCHIP, chip);
 161     if (r < 0) {
 162         perror("kvm_get_irqchip\n");
 163     }
 164     return r;
 165 }
 166
 167 int kvm_set_irqchip(KVMState *s, struct kvm_irqchip *chip)
 168 {
 169     int r;
 170
 171     if (!s->irqchip_in_kernel) {
 172         return 0;
 173     }
 174     r = kvm_vm_ioctl(s, KVM_SET_IRQCHIP, chip);
 175     if (r < 0) {
 176         perror("kvm_set_irqchip\n");
 177     }
 178     return r;
 179 }
 180
 181 #endif
 182
 183 #ifdef KVM_CAP_DEVICE_ASSIGNMENT
 184 int kvm_assign_pci_device(KVMState *s,
 185                           struct kvm_assigned_pci_dev *assigned_dev)
 186 {
 187     return kvm_vm_ioctl(s, KVM_ASSIGN_PCI_DEVICE, assigned_dev);
 188 }
 189
 190 static int kvm_old_assign_irq(KVMState *s,
 191                               struct kvm_assigned_irq *assigned_irq)
 192 {
 193     return kvm_vm_ioctl(s, KVM_ASSIGN_IRQ, assigned_irq);
 194 }
 195
 196 #ifdef KVM_CAP_ASSIGN_DEV_IRQ
 197 int kvm_assign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq)
 198 {
 199     int ret;
 200
 201     ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_ASSIGN_DEV_IRQ);
 202     if (ret > 0) {
 203         return kvm_vm_ioctl(s, KVM_ASSIGN_DEV_IRQ, assigned_irq);
 204     }
 205
 206     return kvm_old_assign_irq(s, assigned_irq);
 207 }
 208
 209 int kvm_deassign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq)
 210 {
 211     return kvm_vm_ioctl(s, KVM_DEASSIGN_DEV_IRQ, assigned_irq);
 212 }
 213 #else
 214 int kvm_assign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq)
 215 {
 216     return kvm_old_assign_irq(s, assigned_irq);
 217 }
 218 #endif
 219 #endif
 220
 221 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
 222 int kvm_deassign_pci_device(KVMState *s,
 223                             struct kvm_assigned_pci_dev *assigned_dev)
 224 {
 225     return kvm_vm_ioctl(s, KVM_DEASSIGN_PCI_DEVICE, assigned_dev);
 226 }
 227 #endif
 228
 229 int kvm_reinject_control(KVMState *s, int pit_reinject)
 230 {
 231 #ifdef KVM_CAP_REINJECT_CONTROL
 232     int r;
 233     struct kvm_reinject_control control;
 234
 235     control.pit_reinject = pit_reinject;
 236
 237     r = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_REINJECT_CONTROL);
 238     if (r > 0) {
 239         return kvm_vm_ioctl(s, KVM_REINJECT_CONTROL, &control);
 240     }
 241 #endif
 242     return -ENOSYS;
 243 }
 244
 245 int kvm_has_gsi_routing(void)
 246 {
 247     int r = 0;
 248
 249 #ifdef KVM_CAP_IRQ_ROUTING
 250     r = kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING);
 251 #endif
 252     return r;
 253 }
 254
 255 int kvm_clear_gsi_routes(void)
 256 {
 257 #ifdef KVM_CAP_IRQ_ROUTING
 258     kvm_state->irq_routes->nr = 0;
 259     return 0;
 260 #else
 261     return -EINVAL;
 262 #endif
 263 }
 264
 265 int kvm_add_routing_entry(struct kvm_irq_routing_entry *entry)
 266 {
 267 #ifdef KVM_CAP_IRQ_ROUTING
 268     KVMState *s = kvm_state;
 269     struct kvm_irq_routing *z;
 270     struct kvm_irq_routing_entry *new;
 271     int n, size;
 272
 273     if (s->irq_routes->nr == s->nr_allocated_irq_routes) {
 274         n = s->nr_allocated_irq_routes * 2;
 275         if (n < 64) {
 276             n = 64;
 277         }
 278         size = sizeof(struct kvm_irq_routing);
 279         size += n * sizeof(*new);
 280         z = realloc(s->irq_routes, size);
 281         if (!z) {
 282             return -ENOMEM;
 283         }
 284         s->nr_allocated_irq_routes = n;
 285         s->irq_routes = z;
 286     }
 287     n = s->irq_routes->nr++;
 288     new = &s->irq_routes->entries[n];
 289     memset(new, 0, sizeof(*new));
 290     new->gsi = entry->gsi;
 291     new->type = entry->type;
 292     new->flags = entry->flags;
 293     new->u = entry->u;
 294
 295     set_gsi(s, entry->gsi);
 296
 297     return 0;
 298 #else
 299     return -ENOSYS;
 300 #endif
 301 }
 302
 303 int kvm_add_irq_route(int gsi, int irqchip, int pin)
 304 {
 305 #ifdef KVM_CAP_IRQ_ROUTING
 306     struct kvm_irq_routing_entry e;
 307
 308     e.gsi = gsi;
 309     e.type = KVM_IRQ_ROUTING_IRQCHIP;
 310     e.flags = 0;
 311     e.u.irqchip.irqchip = irqchip;
 312     e.u.irqchip.pin = pin;
 313     return kvm_add_routing_entry(&e);
 314 #else
 315     return -ENOSYS;
 316 #endif
 317 }
 318
 319 int kvm_del_routing_entry(struct kvm_irq_routing_entry *entry)
 320 {
 321 #ifdef KVM_CAP_IRQ_ROUTING
 322     KVMState *s = kvm_state;
 323     struct kvm_irq_routing_entry *e, *p;
 324     int i, gsi, found = 0;
 325
 326     gsi = entry->gsi;
 327
 328     for (i = 0; i < s->irq_routes->nr; ++i) {
 329         e = &s->irq_routes->entries[i];
 330         if (e->type == entry->type && e->gsi == gsi) {
 331             switch (e->type) {
 332             case KVM_IRQ_ROUTING_IRQCHIP:{
 333                     if (e->u.irqchip.irqchip ==
 334                         entry->u.irqchip.irqchip
 335                         && e->u.irqchip.pin == entry->u.irqchip.pin) {
 336                         p = &s->irq_routes->entries[--s->irq_routes->nr];
 337                         *e = *p;
 338                         found = 1;
 339                     }
 340                     break;
 341                 }
 342             case KVM_IRQ_ROUTING_MSI:{
 343                     if (e->u.msi.address_lo ==
 344                         entry->u.msi.address_lo
 345                         && e->u.msi.address_hi ==
 346                         entry->u.msi.address_hi
 347                         && e->u.msi.data == entry->u.msi.data) {
 348                         p = &s->irq_routes->entries[--s->irq_routes->nr];
 349                         *e = *p;
 350                         found = 1;
 351                     }
 352                     break;
 353                 }
 354             default:
 355                 break;
 356             }
 357             if (found) {
 358                 /* If there are no other users of this GSI
 359                  * mark it available in the bitmap */
 360                 for (i = 0; i < s->irq_routes->nr; i++) {
 361                     e = &s->irq_routes->entries[i];
 362                     if (e->gsi == gsi)
 363                         break;
 364                 }
 365                 if (i == s->irq_routes->nr) {
 366                     clear_gsi(s, gsi);
 367                 }
 368
 369                 return 0;
 370             }
 371         }
 372     }
 373     return -ESRCH;
 374 #else
 375     return -ENOSYS;
 376 #endif
 377 }
 378
 379 int kvm_update_routing_entry(struct kvm_irq_routing_entry *entry,
 380                              struct kvm_irq_routing_entry *newentry)
 381 {
 382 #ifdef KVM_CAP_IRQ_ROUTING
 383     KVMState *s = kvm_state;
 384     struct kvm_irq_routing_entry *e;
 385     int i;
 386
 387     if (entry->gsi != newentry->gsi || entry->type != newentry->type) {
 388         return -EINVAL;
 389     }
 390
 391     for (i = 0; i < s->irq_routes->nr; ++i) {
 392         e = &s->irq_routes->entries[i];
 393         if (e->type != entry->type || e->gsi != entry->gsi) {
 394             continue;
 395         }
 396         switch (e->type) {
 397         case KVM_IRQ_ROUTING_IRQCHIP:
 398             if (e->u.irqchip.irqchip == entry->u.irqchip.irqchip &&
 399                 e->u.irqchip.pin == entry->u.irqchip.pin) {
 400                 memcpy(&e->u.irqchip, &newentry->u.irqchip,
 401                        sizeof e->u.irqchip);
 402                 return 0;
 403             }
 404             break;
 405         case KVM_IRQ_ROUTING_MSI:
 406             if (e->u.msi.address_lo == entry->u.msi.address_lo &&
 407                 e->u.msi.address_hi == entry->u.msi.address_hi &&
 408                 e->u.msi.data == entry->u.msi.data) {
 409                 memcpy(&e->u.msi, &newentry->u.msi, sizeof e->u.msi);
 410                 return 0;
 411             }
 412             break;
 413         default:
 414             break;
 415         }
 416     }
 417     return -ESRCH;
 418 #else
 419     return -ENOSYS;
 420 #endif
 421 }
 422
 423 int kvm_del_irq_route(int gsi, int irqchip, int pin)
 424 {
 425 #ifdef KVM_CAP_IRQ_ROUTING
 426     struct kvm_irq_routing_entry e;
 427
 428     e.gsi = gsi;
 429     e.type = KVM_IRQ_ROUTING_IRQCHIP;
 430     e.flags = 0;
 431     e.u.irqchip.irqchip = irqchip;
 432     e.u.irqchip.pin = pin;
 433     return kvm_del_routing_entry(&e);
 434 #else
 435     return -ENOSYS;
 436 #endif
 437 }
 438
 439 int kvm_commit_irq_routes(void)
 440 {
 441 #ifdef KVM_CAP_IRQ_ROUTING
 442     KVMState *s = kvm_state;
 443
 444     s->irq_routes->flags = 0;
 445     return kvm_vm_ioctl(s, KVM_SET_GSI_ROUTING, s->irq_routes);
 446 #else
 447     return -ENOSYS;
 448 #endif
 449 }
 450
 451 int kvm_get_irq_route_gsi(void)
 452 {
 453     KVMState *s = kvm_state;
 454     int i, bit;
 455     uint32_t *buf = s->used_gsi_bitmap;
 456
 457     /* Return the lowest unused GSI in the bitmap */
 458     for (i = 0; i < s->max_gsi / 32; i++) {
 459         bit = ffs(~buf[i]);
 460         if (!bit) {
 461             continue;
 462         }
 463
 464         return bit - 1 + i * 32;
 465     }
 466
 467     return -ENOSPC;
 468 }
 469
 470 static void kvm_msi_routing_entry(struct kvm_irq_routing_entry *e,
 471                                   KVMMsiMessage *msg)
 472
 473 {
 474     e->gsi = msg->gsi;
 475     e->type = KVM_IRQ_ROUTING_MSI;
 476     e->flags = 0;
 477     e->u.msi.address_lo = msg->addr_lo;
 478     e->u.msi.address_hi = msg->addr_hi;
 479     e->u.msi.data = msg->data;
 480 }
 481
 482 int kvm_msi_message_add(KVMMsiMessage *msg)
 483 {
 484     struct kvm_irq_routing_entry e;
 485     int ret;
 486
 487     ret = kvm_get_irq_route_gsi();
 488     if (ret < 0) {
 489         return ret;
 490     }
 491     msg->gsi = ret;
 492
 493     kvm_msi_routing_entry(&e, msg);
 494     return kvm_add_routing_entry(&e);
 495 }
 496
 497 int kvm_msi_message_del(KVMMsiMessage *msg)
 498 {
 499     struct kvm_irq_routing_entry e;
 500
 501     kvm_msi_routing_entry(&e, msg);
 502     return kvm_del_routing_entry(&e);
 503 }
 504
 505 int kvm_msi_message_update(KVMMsiMessage *old, KVMMsiMessage *new)
 506 {
 507     struct kvm_irq_routing_entry e1, e2;
 508     int ret;
 509
 510     new->gsi = old->gsi;
 511     if (memcmp(old, new, sizeof(KVMMsiMessage)) == 0) {
 512         return 0;
 513     }
 514
 515     kvm_msi_routing_entry(&e1, old);
 516     kvm_msi_routing_entry(&e2, new);
 517
 518     ret = kvm_update_routing_entry(&e1, &e2);
 519     if (ret < 0) {
 520         return ret;
 521     }
 522
 523     return 1;
 524 }
 525
 526
 527 #ifdef KVM_CAP_DEVICE_MSIX
 528 int kvm_assign_set_msix_nr(KVMState *s, struct kvm_assigned_msix_nr *msix_nr)
 529 {
 530     return kvm_vm_ioctl(s, KVM_ASSIGN_SET_MSIX_NR, msix_nr);
 531 }
 532
 533 int kvm_assign_set_msix_entry(KVMState *s,
 534                               struct kvm_assigned_msix_entry *entry)
 535 {
 536     return kvm_vm_ioctl(s, KVM_ASSIGN_SET_MSIX_ENTRY, entry);
 537 }
 538 #endif
 539
 540 #ifdef TARGET_I386
 541 void kvm_hpet_disable_kpit(void)
 542 {
 543     struct kvm_pit_state2 ps2;
 544
 545     kvm_get_pit2(kvm_state, &ps2);
 546     ps2.flags |= KVM_PIT_FLAGS_HPET_LEGACY;
 547     kvm_set_pit2(kvm_state, &ps2);
 548 }
 549
 550 void kvm_hpet_enable_kpit(void)
 551 {
 552     struct kvm_pit_state2 ps2;
 553
 554     kvm_get_pit2(kvm_state, &ps2);
 555     ps2.flags &= ~KVM_PIT_FLAGS_HPET_LEGACY;
 556     kvm_set_pit2(kvm_state, &ps2);
 557 }
 558 #endif
 559
 560 #if !defined(TARGET_I386)
 561 int kvm_arch_init_irq_routing(void)
 562 {
 563     return 0;
 564 }
 565 #endif
 566
 567 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
 568 typedef struct KVMIOPortRegion {
 569     unsigned long start;
 570     unsigned long size;
 571     int status;
 572     QLIST_ENTRY(KVMIOPortRegion) entry;
 573 } KVMIOPortRegion;
 574
 575 static QLIST_HEAD(, KVMIOPortRegion) ioport_regions;
 576
 577 static void do_set_ioport_access(void *data)
 578 {
 579     KVMIOPortRegion *region = data;
 580     bool enable = region->status > 0;
 581     int r;
 582
 583     r = kvm_arch_set_ioport_access(region->start, region->size, enable);
 584     if (r < 0) {
 585         region->status = r;
 586     } else {
 587         region->status = 1;
 588     }
 589 }
 590
 591 int kvm_add_ioport_region(unsigned long start, unsigned long size,
 592                           bool is_hot_plug)
 593 {
 594     KVMIOPortRegion *region = g_malloc0(sizeof(KVMIOPortRegion));
 595     CPUState *env;
 596     int r = 0;
 597
 598     region->start = start;
 599     region->size = size;
 600     region->status = 1;
 601     QLIST_INSERT_HEAD(&ioport_regions, region, entry);
 602
 603     if (is_hot_plug) {
 604         for (env = first_cpu; env != NULL; env = env->next_cpu) {
 605             run_on_cpu(env, do_set_ioport_access, region);
 606             if (region->status < 0) {
 607                 r = region->status;
 608                 kvm_remove_ioport_region(start, size, is_hot_plug);
 609                 break;
 610             }
 611         }
 612     }
 613     return r;
 614 }
 615
 616 int kvm_remove_ioport_region(unsigned long start, unsigned long size,
 617                              bool is_hot_unplug)
 618 {
 619     KVMIOPortRegion *region, *tmp;
 620     CPUState *env;
 621     int r = -ENOENT;
 622
 623     QLIST_FOREACH_SAFE(region, &ioport_regions, entry, tmp) {
 624         if (region->start == start && region->size == size) {
 625             region->status = 0;
 626         }
 627         if (is_hot_unplug) {
 628             for (env = first_cpu; env != NULL; env = env->next_cpu) {
 629                 run_on_cpu(env, do_set_ioport_access, region);
 630             }
 631         }
 632         QLIST_REMOVE(region, entry);
 633         g_free(region);
 634         r = 0;
 635     }
 636     return r;
 637 }
 638 #endif /* CONFIG_KVM_DEVICE_ASSIGNMENT */
 639
 640 int kvm_update_ioport_access(CPUState *env)
 641 {
 642 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
 643     KVMIOPortRegion *region;
 644     int r;
 645
 646     assert(qemu_cpu_is_self(env));
 647
 648     QLIST_FOREACH(region, &ioport_regions, entry) {
 649         bool enable = region->status > 0;
 650
 651         r = kvm_arch_set_ioport_access(region->start, region->size, enable);
 652         if (r < 0) {
 653             return r;
 654         }
 655     }
 656 #endif /* CONFIG_KVM_DEVICE_ASSIGNMENT */
 657     return 0;
 658 }