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 #ifdef KVM_CAP_IRQ_ROUTING
  34 static inline void clear_gsi(KVMState *s, unsigned int gsi)
  35 {
  36     uint32_t *bitmap = s->used_gsi_bitmap;
  37
  38     if (gsi < s->max_gsi) {
  39         bitmap[gsi / 32] &= ~(1U << (gsi % 32));
  40     } else {
  41         DPRINTF("Invalid GSI %u\n", gsi);
  42     }
  43 }
  44 #endif
  45
  46 #ifdef KVM_CAP_DEVICE_ASSIGNMENT
  47 int kvm_assign_pci_device(KVMState *s,
  48                           struct kvm_assigned_pci_dev *assigned_dev)
  49 {
  50     return kvm_vm_ioctl(s, KVM_ASSIGN_PCI_DEVICE, assigned_dev);
  51 }
  52
  53 static int kvm_old_assign_irq(KVMState *s,
  54                               struct kvm_assigned_irq *assigned_irq)
  55 {
  56     return kvm_vm_ioctl(s, KVM_ASSIGN_IRQ, assigned_irq);
  57 }
  58
  59 int kvm_device_intx_set_mask(KVMState *s, uint32_t dev_id, bool masked)
  60 {
  61     struct kvm_assigned_pci_dev assigned_dev;
  62
  63     assigned_dev.assigned_dev_id = dev_id;
  64     assigned_dev.flags = masked ? KVM_DEV_ASSIGN_MASK_INTX : 0;
  65     return kvm_vm_ioctl(s, KVM_ASSIGN_SET_INTX_MASK, &assigned_dev);
  66 }
  67
  68 #ifdef KVM_CAP_ASSIGN_DEV_IRQ
  69 int kvm_assign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq)
  70 {
  71     int ret;
  72
  73     ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_ASSIGN_DEV_IRQ);
  74     if (ret > 0) {
  75         return kvm_vm_ioctl(s, KVM_ASSIGN_DEV_IRQ, assigned_irq);
  76     }
  77
  78     return kvm_old_assign_irq(s, assigned_irq);
  79 }
  80
  81 int kvm_deassign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq)
  82 {
  83     return kvm_vm_ioctl(s, KVM_DEASSIGN_DEV_IRQ, assigned_irq);
  84 }
  85 #else
  86 int kvm_assign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq)
  87 {
  88     return kvm_old_assign_irq(s, assigned_irq);
  89 }
  90 #endif
  91 #endif
  92
  93 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
  94 int kvm_deassign_pci_device(KVMState *s,
  95                             struct kvm_assigned_pci_dev *assigned_dev)
  96 {
  97     return kvm_vm_ioctl(s, KVM_DEASSIGN_PCI_DEVICE, assigned_dev);
  98 }
  99 #endif
 100
 101 int kvm_del_routing_entry(struct kvm_irq_routing_entry *entry)
 102 {
 103 #ifdef KVM_CAP_IRQ_ROUTING
 104     KVMState *s = kvm_state;
 105     struct kvm_irq_routing_entry *e, *p;
 106     int i, gsi, found = 0;
 107
 108     gsi = entry->gsi;
 109
 110     for (i = 0; i < s->irq_routes->nr; ++i) {
 111         e = &s->irq_routes->entries[i];
 112         if (e->type == entry->type && e->gsi == gsi) {
 113             switch (e->type) {
 114             case KVM_IRQ_ROUTING_IRQCHIP:{
 115                     if (e->u.irqchip.irqchip ==
 116                         entry->u.irqchip.irqchip
 117                         && e->u.irqchip.pin == entry->u.irqchip.pin) {
 118                         p = &s->irq_routes->entries[--s->irq_routes->nr];
 119                         *e = *p;
 120                         found = 1;
 121                     }
 122                     break;
 123                 }
 124             case KVM_IRQ_ROUTING_MSI:{
 125                     if (e->u.msi.address_lo ==
 126                         entry->u.msi.address_lo
 127                         && e->u.msi.address_hi ==
 128                         entry->u.msi.address_hi
 129                         && e->u.msi.data == entry->u.msi.data) {
 130                         p = &s->irq_routes->entries[--s->irq_routes->nr];
 131                         *e = *p;
 132                         found = 1;
 133                     }
 134                     break;
 135                 }
 136             default:
 137                 break;
 138             }
 139             if (found) {
 140                 /* If there are no other users of this GSI
 141                  * mark it available in the bitmap */
 142                 for (i = 0; i < s->irq_routes->nr; i++) {
 143                     e = &s->irq_routes->entries[i];
 144                     if (e->gsi == gsi)
 145                         break;
 146                 }
 147                 if (i == s->irq_routes->nr) {
 148                     clear_gsi(s, gsi);
 149                 }
 150
 151                 return 0;
 152             }
 153         }
 154     }
 155     return -ESRCH;
 156 #else
 157     return -ENOSYS;
 158 #endif
 159 }
 160
 161 int kvm_update_routing_entry(struct kvm_irq_routing_entry *entry,
 162                              struct kvm_irq_routing_entry *newentry)
 163 {
 164 #ifdef KVM_CAP_IRQ_ROUTING
 165     KVMState *s = kvm_state;
 166     struct kvm_irq_routing_entry *e;
 167     int i;
 168
 169     if (entry->gsi != newentry->gsi || entry->type != newentry->type) {
 170         return -EINVAL;
 171     }
 172
 173     for (i = 0; i < s->irq_routes->nr; ++i) {
 174         e = &s->irq_routes->entries[i];
 175         if (e->type != entry->type || e->gsi != entry->gsi) {
 176             continue;
 177         }
 178         switch (e->type) {
 179         case KVM_IRQ_ROUTING_IRQCHIP:
 180             if (e->u.irqchip.irqchip == entry->u.irqchip.irqchip &&
 181                 e->u.irqchip.pin == entry->u.irqchip.pin) {
 182                 memcpy(&e->u.irqchip, &newentry->u.irqchip,
 183                        sizeof e->u.irqchip);
 184                 return 0;
 185             }
 186             break;
 187         case KVM_IRQ_ROUTING_MSI:
 188             if (e->u.msi.address_lo == entry->u.msi.address_lo &&
 189                 e->u.msi.address_hi == entry->u.msi.address_hi &&
 190                 e->u.msi.data == entry->u.msi.data) {
 191                 memcpy(&e->u.msi, &newentry->u.msi, sizeof e->u.msi);
 192                 return 0;
 193             }
 194             break;
 195         default:
 196             break;
 197         }
 198     }
 199     return -ESRCH;
 200 #else
 201     return -ENOSYS;
 202 #endif
 203 }
 204
 205 int kvm_get_irq_route_gsi(void)
 206 {
 207 #ifdef KVM_CAP_IRQ_ROUTING
 208     KVMState *s = kvm_state;
 209     int i, bit;
 210     uint32_t *buf = s->used_gsi_bitmap;
 211
 212     /* Return the lowest unused GSI in the bitmap */
 213     for (i = 0; i < s->max_gsi / 32; i++) {
 214         bit = ffs(~buf[i]);
 215         if (!bit) {
 216             continue;
 217         }
 218
 219         return bit - 1 + i * 32;
 220     }
 221
 222     return -ENOSPC;
 223 #else
 224     return -ENOSYS;
 225 #endif
 226 }
 227
 228 #ifdef KVM_CAP_IRQ_ROUTING
 229 static void kvm_msi_routing_entry(struct kvm_irq_routing_entry *e,
 230                                   KVMMsiMessage *msg)
 231
 232 {
 233     e->gsi = msg->gsi;
 234     e->type = KVM_IRQ_ROUTING_MSI;
 235     e->flags = 0;
 236     e->u.msi.address_lo = msg->addr_lo;
 237     e->u.msi.address_hi = msg->addr_hi;
 238     e->u.msi.data = msg->data;
 239 }
 240 #endif
 241
 242 int kvm_msi_message_add(KVMMsiMessage *msg)
 243 {
 244 #ifdef KVM_CAP_IRQ_ROUTING
 245     struct kvm_irq_routing_entry e;
 246     int ret;
 247
 248     ret = kvm_get_irq_route_gsi();
 249     if (ret < 0) {
 250         return ret;
 251     }
 252     msg->gsi = ret;
 253
 254     kvm_msi_routing_entry(&e, msg);
 255     kvm_add_routing_entry(kvm_state, &e);
 256     return 0;
 257 #else
 258     return -ENOSYS;
 259 #endif
 260 }
 261
 262 int kvm_msi_message_del(KVMMsiMessage *msg)
 263 {
 264 #ifdef KVM_CAP_IRQ_ROUTING
 265     struct kvm_irq_routing_entry e;
 266
 267     kvm_msi_routing_entry(&e, msg);
 268     return kvm_del_routing_entry(&e);
 269 #else
 270     return -ENOSYS;
 271 #endif
 272 }
 273
 274 int kvm_msi_message_update(KVMMsiMessage *old, KVMMsiMessage *new)
 275 {
 276 #ifdef KVM_CAP_IRQ_ROUTING
 277     struct kvm_irq_routing_entry e1, e2;
 278     int ret;
 279
 280     new->gsi = old->gsi;
 281     if (memcmp(old, new, sizeof(KVMMsiMessage)) == 0) {
 282         return 0;
 283     }
 284
 285     kvm_msi_routing_entry(&e1, old);
 286     kvm_msi_routing_entry(&e2, new);
 287
 288     ret = kvm_update_routing_entry(&e1, &e2);
 289     if (ret < 0) {
 290         return ret;
 291     }
 292
 293     return 1;
 294 #else
 295     return -ENOSYS;
 296 #endif
 297 }
 298
 299
 300 #ifdef KVM_CAP_DEVICE_MSIX
 301 int kvm_assign_set_msix_nr(KVMState *s, struct kvm_assigned_msix_nr *msix_nr)
 302 {
 303     return kvm_vm_ioctl(s, KVM_ASSIGN_SET_MSIX_NR, msix_nr);
 304 }
 305
 306 int kvm_assign_set_msix_entry(KVMState *s,
 307                               struct kvm_assigned_msix_entry *entry)
 308 {
 309     return kvm_vm_ioctl(s, KVM_ASSIGN_SET_MSIX_ENTRY, entry);
 310 }
 311 #endif
 312
 313 #if !defined(TARGET_I386)
 314 void kvm_arch_init_irq_routing(KVMState *s)
 315 {
 316 }
 317 #endif