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