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 clear_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 #ifdef KVM_CAP_DEVICE_ASSIGNMENT
  45 int kvm_assign_pci_device(KVMState *s,
  46                           struct kvm_assigned_pci_dev *assigned_dev)
  47 {
  48     return kvm_vm_ioctl(s, KVM_ASSIGN_PCI_DEVICE, assigned_dev);
  49 }
  50
  51 static int kvm_old_assign_irq(KVMState *s,
  52                               struct kvm_assigned_irq *assigned_irq)
  53 {
  54     return kvm_vm_ioctl(s, KVM_ASSIGN_IRQ, assigned_irq);
  55 }
  56
  57 int kvm_device_intx_set_mask(KVMState *s, uint32_t dev_id, bool masked)
  58 {
  59     struct kvm_assigned_pci_dev assigned_dev;
  60
  61     assigned_dev.assigned_dev_id = dev_id;
  62     assigned_dev.flags = masked ? KVM_DEV_ASSIGN_MASK_INTX : 0;
  63     return kvm_vm_ioctl(s, KVM_ASSIGN_SET_INTX_MASK, &assigned_dev);
  64 }
  65
  66 #ifdef KVM_CAP_ASSIGN_DEV_IRQ
  67 int kvm_assign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq)
  68 {
  69     int ret;
  70
  71     ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_ASSIGN_DEV_IRQ);
  72     if (ret > 0) {
  73         return kvm_vm_ioctl(s, KVM_ASSIGN_DEV_IRQ, assigned_irq);
  74     }
  75
  76     return kvm_old_assign_irq(s, assigned_irq);
  77 }
  78
  79 int kvm_deassign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq)
  80 {
  81     return kvm_vm_ioctl(s, KVM_DEASSIGN_DEV_IRQ, assigned_irq);
  82 }
  83 #else
  84 int kvm_assign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq)
  85 {
  86     return kvm_old_assign_irq(s, assigned_irq);
  87 }
  88 #endif
  89 #endif
  90
  91 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
  92 int kvm_deassign_pci_device(KVMState *s,
  93                             struct kvm_assigned_pci_dev *assigned_dev)
  94 {
  95     return kvm_vm_ioctl(s, KVM_DEASSIGN_PCI_DEVICE, assigned_dev);
  96 }
  97 #endif
  98
  99 int kvm_clear_gsi_routes(void)
 100 {
 101 #ifdef KVM_CAP_IRQ_ROUTING
 102     kvm_state->irq_routes->nr = 0;
 103     return 0;
 104 #else
 105     return -EINVAL;
 106 #endif
 107 }
 108
 109 int kvm_del_routing_entry(struct kvm_irq_routing_entry *entry)
 110 {
 111 #ifdef KVM_CAP_IRQ_ROUTING
 112     KVMState *s = kvm_state;
 113     struct kvm_irq_routing_entry *e, *p;
 114     int i, gsi, found = 0;
 115
 116     gsi = entry->gsi;
 117
 118     for (i = 0; i < s->irq_routes->nr; ++i) {
 119         e = &s->irq_routes->entries[i];
 120         if (e->type == entry->type && e->gsi == gsi) {
 121             switch (e->type) {
 122             case KVM_IRQ_ROUTING_IRQCHIP:{
 123                     if (e->u.irqchip.irqchip ==
 124                         entry->u.irqchip.irqchip
 125                         && e->u.irqchip.pin == entry->u.irqchip.pin) {
 126                         p = &s->irq_routes->entries[--s->irq_routes->nr];
 127                         *e = *p;
 128                         found = 1;
 129                     }
 130                     break;
 131                 }
 132             case KVM_IRQ_ROUTING_MSI:{
 133                     if (e->u.msi.address_lo ==
 134                         entry->u.msi.address_lo
 135                         && e->u.msi.address_hi ==
 136                         entry->u.msi.address_hi
 137                         && e->u.msi.data == entry->u.msi.data) {
 138                         p = &s->irq_routes->entries[--s->irq_routes->nr];
 139                         *e = *p;
 140                         found = 1;
 141                     }
 142                     break;
 143                 }
 144             default:
 145                 break;
 146             }
 147             if (found) {
 148                 /* If there are no other users of this GSI
 149                  * mark it available in the bitmap */
 150                 for (i = 0; i < s->irq_routes->nr; i++) {
 151                     e = &s->irq_routes->entries[i];
 152                     if (e->gsi == gsi)
 153                         break;
 154                 }
 155                 if (i == s->irq_routes->nr) {
 156                     clear_gsi(s, gsi);
 157                 }
 158
 159                 return 0;
 160             }
 161         }
 162     }
 163     return -ESRCH;
 164 #else
 165     return -ENOSYS;
 166 #endif
 167 }
 168
 169 int kvm_update_routing_entry(struct kvm_irq_routing_entry *entry,
 170                              struct kvm_irq_routing_entry *newentry)
 171 {
 172 #ifdef KVM_CAP_IRQ_ROUTING
 173     KVMState *s = kvm_state;
 174     struct kvm_irq_routing_entry *e;
 175     int i;
 176
 177     if (entry->gsi != newentry->gsi || entry->type != newentry->type) {
 178         return -EINVAL;
 179     }
 180
 181     for (i = 0; i < s->irq_routes->nr; ++i) {
 182         e = &s->irq_routes->entries[i];
 183         if (e->type != entry->type || e->gsi != entry->gsi) {
 184             continue;
 185         }
 186         switch (e->type) {
 187         case KVM_IRQ_ROUTING_IRQCHIP:
 188             if (e->u.irqchip.irqchip == entry->u.irqchip.irqchip &&
 189                 e->u.irqchip.pin == entry->u.irqchip.pin) {
 190                 memcpy(&e->u.irqchip, &newentry->u.irqchip,
 191                        sizeof e->u.irqchip);
 192                 return 0;
 193             }
 194             break;
 195         case KVM_IRQ_ROUTING_MSI:
 196             if (e->u.msi.address_lo == entry->u.msi.address_lo &&
 197                 e->u.msi.address_hi == entry->u.msi.address_hi &&
 198                 e->u.msi.data == entry->u.msi.data) {
 199                 memcpy(&e->u.msi, &newentry->u.msi, sizeof e->u.msi);
 200                 return 0;
 201             }
 202             break;
 203         default:
 204             break;
 205         }
 206     }
 207     return -ESRCH;
 208 #else
 209     return -ENOSYS;
 210 #endif
 211 }
 212
 213 int kvm_del_irq_route(int gsi, int irqchip, int pin)
 214 {
 215 #ifdef KVM_CAP_IRQ_ROUTING
 216     struct kvm_irq_routing_entry e;
 217
 218     e.gsi = gsi;
 219     e.type = KVM_IRQ_ROUTING_IRQCHIP;
 220     e.flags = 0;
 221     e.u.irqchip.irqchip = irqchip;
 222     e.u.irqchip.pin = pin;
 223     return kvm_del_routing_entry(&e);
 224 #else
 225     return -ENOSYS;
 226 #endif
 227 }
 228
 229 int kvm_get_irq_route_gsi(void)
 230 {
 231     KVMState *s = kvm_state;
 232     int i, bit;
 233     uint32_t *buf = s->used_gsi_bitmap;
 234
 235     /* Return the lowest unused GSI in the bitmap */
 236     for (i = 0; i < s->max_gsi / 32; i++) {
 237         bit = ffs(~buf[i]);
 238         if (!bit) {
 239             continue;
 240         }
 241
 242         return bit - 1 + i * 32;
 243     }
 244
 245     return -ENOSPC;
 246 }
 247
 248 static void kvm_msi_routing_entry(struct kvm_irq_routing_entry *e,
 249                                   KVMMsiMessage *msg)
 250
 251 {
 252     e->gsi = msg->gsi;
 253     e->type = KVM_IRQ_ROUTING_MSI;
 254     e->flags = 0;
 255     e->u.msi.address_lo = msg->addr_lo;
 256     e->u.msi.address_hi = msg->addr_hi;
 257     e->u.msi.data = msg->data;
 258 }
 259
 260 int kvm_msi_message_add(KVMMsiMessage *msg)
 261 {
 262     struct kvm_irq_routing_entry e;
 263     int ret;
 264
 265     ret = kvm_get_irq_route_gsi();
 266     if (ret < 0) {
 267         return ret;
 268     }
 269     msg->gsi = ret;
 270
 271     kvm_msi_routing_entry(&e, msg);
 272     kvm_add_routing_entry(kvm_state, &e);
 273     return 0;
 274 }
 275
 276 int kvm_msi_message_del(KVMMsiMessage *msg)
 277 {
 278     struct kvm_irq_routing_entry e;
 279
 280     kvm_msi_routing_entry(&e, msg);
 281     return kvm_del_routing_entry(&e);
 282 }
 283
 284 int kvm_msi_message_update(KVMMsiMessage *old, KVMMsiMessage *new)
 285 {
 286     struct kvm_irq_routing_entry e1, e2;
 287     int ret;
 288
 289     new->gsi = old->gsi;
 290     if (memcmp(old, new, sizeof(KVMMsiMessage)) == 0) {
 291         return 0;
 292     }
 293
 294     kvm_msi_routing_entry(&e1, old);
 295     kvm_msi_routing_entry(&e2, new);
 296
 297     ret = kvm_update_routing_entry(&e1, &e2);
 298     if (ret < 0) {
 299         return ret;
 300     }
 301
 302     return 1;
 303 }
 304
 305
 306 #ifdef KVM_CAP_DEVICE_MSIX
 307 int kvm_assign_set_msix_nr(KVMState *s, struct kvm_assigned_msix_nr *msix_nr)
 308 {
 309     return kvm_vm_ioctl(s, KVM_ASSIGN_SET_MSIX_NR, msix_nr);
 310 }
 311
 312 int kvm_assign_set_msix_entry(KVMState *s,
 313                               struct kvm_assigned_msix_entry *entry)
 314 {
 315     return kvm_vm_ioctl(s, KVM_ASSIGN_SET_MSIX_ENTRY, entry);
 316 }
 317 #endif
 318
 319 #if !defined(TARGET_I386)
 320 int kvm_arch_init_irq_routing(void)
 321 {
 322     return 0;
 323 }
 324 #endif
 325
 326 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
 327 typedef struct KVMIOPortRegion {
 328     unsigned long start;
 329     unsigned long size;
 330     int status;
 331     QLIST_ENTRY(KVMIOPortRegion) entry;
 332 } KVMIOPortRegion;
 333
 334 static QLIST_HEAD(, KVMIOPortRegion) ioport_regions;
 335
 336 static void do_set_ioport_access(void *data)
 337 {
 338     KVMIOPortRegion *region = data;
 339     bool enable = region->status > 0;
 340     int r;
 341
 342     r = kvm_arch_set_ioport_access(region->start, region->size, enable);
 343     if (r < 0) {
 344         region->status = r;
 345     } else {
 346         region->status = 1;
 347     }
 348 }
 349
 350 int kvm_add_ioport_region(unsigned long start, unsigned long size,
 351                           bool is_hot_plug)
 352 {
 353     KVMIOPortRegion *region = g_malloc0(sizeof(KVMIOPortRegion));
 354     CPUState *env;
 355     int r = 0;
 356
 357     region->start = start;
 358     region->size = size;
 359     region->status = 1;
 360     QLIST_INSERT_HEAD(&ioport_regions, region, entry);
 361
 362     if (is_hot_plug) {
 363         for (env = first_cpu; env != NULL; env = env->next_cpu) {
 364             run_on_cpu(env, do_set_ioport_access, region);
 365             if (region->status < 0) {
 366                 r = region->status;
 367                 kvm_remove_ioport_region(start, size, is_hot_plug);
 368                 break;
 369             }
 370         }
 371     }
 372     return r;
 373 }
 374
 375 int kvm_remove_ioport_region(unsigned long start, unsigned long size,
 376                              bool is_hot_unplug)
 377 {
 378     KVMIOPortRegion *region, *tmp;
 379     CPUState *env;
 380     int r = -ENOENT;
 381
 382     QLIST_FOREACH_SAFE(region, &ioport_regions, entry, tmp) {
 383         if (region->start == start && region->size == size) {
 384             region->status = 0;
 385         }
 386         if (is_hot_unplug) {
 387             for (env = first_cpu; env != NULL; env = env->next_cpu) {
 388                 run_on_cpu(env, do_set_ioport_access, region);
 389             }
 390         }
 391         QLIST_REMOVE(region, entry);
 392         g_free(region);
 393         r = 0;
 394     }
 395     return r;
 396 }
 397 #endif /* CONFIG_KVM_DEVICE_ASSIGNMENT */
 398
 399 int kvm_update_ioport_access(CPUState *env)
 400 {
 401 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
 402     KVMIOPortRegion *region;
 403     int r;
 404
 405     assert(qemu_cpu_is_self(env));
 406
 407     QLIST_FOREACH(region, &ioport_regions, entry) {
 408         bool enable = region->status > 0;
 409
 410         r = kvm_arch_set_ioport_access(region->start, region->size, enable);
 411         if (r < 0) {
 412             return r;
 413         }
 414     }
 415 #endif /* CONFIG_KVM_DEVICE_ASSIGNMENT */
 416     return 0;
 417 }