qemu-kvm-x86.c

   1 /*
   2  * qemu/kvm integration, x86 specific code
   3  *
   4  * Copyright (C) 2006-2008 Qumranet Technologies
   5  *
   6  * Licensed under the terms of the GNU GPL version 2 or higher.
   7  */
   8
   9 #include "config.h"
  10 #include "config-host.h"
  11
  12 #include <string.h>
  13 #include "hw/hw.h"
  14 #include "gdbstub.h"
  15 #include <sys/io.h>
  16
  17 #include "qemu-kvm.h"
  18 #include <pthread.h>
  19 #include <sys/utsname.h>
  20 #include <linux/kvm_para.h>
  21 #include <sys/ioctl.h>
  22
  23 #include "kvm.h"
  24 #include "hw/apic.h"
  25
  26 static int kvm_create_pit(KVMState *s)
  27 {
  28 #ifdef KVM_CAP_PIT
  29     int r;
  30
  31     if (kvm_pit) {
  32         r = kvm_vm_ioctl(s, KVM_CREATE_PIT);
  33         if (r < 0) {
  34             fprintf(stderr, "Create kernel PIC irqchip failed\n");
  35             return r;
  36         }
  37         if (!kvm_pit_reinject) {
  38             r = kvm_reinject_control(s, 0);
  39             if (r < 0) {
  40                 fprintf(stderr,
  41                         "failure to disable in-kernel PIT reinjection\n");
  42                 return r;
  43             }
  44         }
  45     }
  46 #endif
  47     return 0;
  48 }
  49
  50 #ifdef KVM_EXIT_TPR_ACCESS
  51
  52 int kvm_handle_tpr_access(CPUState *env)
  53 {
  54     struct kvm_run *run = env->kvm_run;
  55     kvm_tpr_access_report(env,
  56                           run->tpr_access.rip,
  57                           run->tpr_access.is_write);
  58     return 1;
  59 }
  60
  61
  62 int kvm_enable_vapic(CPUState *env, uint64_t vapic)
  63 {
  64     struct kvm_vapic_addr va = {
  65         .vapic_addr = vapic,
  66     };
  67
  68     return kvm_vcpu_ioctl(env, KVM_SET_VAPIC_ADDR, &va);
  69 }
  70
  71 #endif
  72
  73 #ifdef KVM_CAP_IRQCHIP
  74
  75 int kvm_get_lapic(CPUState *env, struct kvm_lapic_state *s)
  76 {
  77     int r = 0;
  78
  79     if (!kvm_irqchip_in_kernel()) {
  80         return r;
  81     }
  82
  83     r = kvm_vcpu_ioctl(env, KVM_GET_LAPIC, s);
  84     if (r < 0) {
  85         fprintf(stderr, "KVM_GET_LAPIC failed\n");
  86     }
  87     return r;
  88 }
  89
  90 int kvm_set_lapic(CPUState *env, struct kvm_lapic_state *s)
  91 {
  92     int r = 0;
  93
  94     if (!kvm_irqchip_in_kernel()) {
  95         return 0;
  96     }
  97
  98     r = kvm_vcpu_ioctl(env, KVM_SET_LAPIC, s);
  99
 100     if (r < 0) {
 101         fprintf(stderr, "KVM_SET_LAPIC failed\n");
 102     }
 103     return r;
 104 }
 105
 106 #endif
 107
 108 #ifdef KVM_CAP_PIT
 109
 110 int kvm_get_pit(KVMState *s, struct kvm_pit_state *pit_state)
 111 {
 112     if (!kvm_pit_in_kernel()) {
 113         return 0;
 114     }
 115     return kvm_vm_ioctl(s, KVM_GET_PIT, pit_state);
 116 }
 117
 118 int kvm_set_pit(KVMState *s, struct kvm_pit_state *pit_state)
 119 {
 120     if (!kvm_pit_in_kernel()) {
 121         return 0;
 122     }
 123     return kvm_vm_ioctl(s, KVM_SET_PIT, pit_state);
 124 }
 125
 126 #ifdef KVM_CAP_PIT_STATE2
 127 int kvm_get_pit2(KVMState *s, struct kvm_pit_state2 *ps2)
 128 {
 129     if (!kvm_pit_in_kernel()) {
 130         return 0;
 131     }
 132     return kvm_vm_ioctl(s, KVM_GET_PIT2, ps2);
 133 }
 134
 135 int kvm_set_pit2(KVMState *s, struct kvm_pit_state2 *ps2)
 136 {
 137     if (!kvm_pit_in_kernel()) {
 138         return 0;
 139     }
 140     return kvm_vm_ioctl(s, KVM_SET_PIT2, ps2);
 141 }
 142
 143 #endif
 144 #endif
 145
 146 #ifdef KVM_CAP_VAPIC
 147 static int kvm_enable_tpr_access_reporting(CPUState *env)
 148 {
 149     int r;
 150     struct kvm_tpr_access_ctl tac = { .enabled = 1 };
 151
 152     r = kvm_ioctl(env->kvm_state, KVM_CHECK_EXTENSION, KVM_CAP_VAPIC);
 153     if (r <= 0) {
 154         return -ENOSYS;
 155     }
 156     return kvm_vcpu_ioctl(env, KVM_TPR_ACCESS_REPORTING, &tac);
 157 }
 158 #endif
 159
 160 static int _kvm_arch_init_vcpu(CPUState *env)
 161 {
 162     kvm_arch_reset_vcpu(env);
 163
 164 #ifdef KVM_EXIT_TPR_ACCESS
 165     kvm_enable_tpr_access_reporting(env);
 166 #endif
 167
 168     return kvm_update_ioport_access(env);
 169 }
 170
 171 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
 172 int kvm_arch_set_ioport_access(unsigned long start, unsigned long size,
 173                                bool enable)
 174 {
 175     if (ioperm(start, size, enable) < 0) {
 176         return -errno;
 177     }
 178     return 0;
 179 }
 180 #endif
 181
 182 /*
 183  * Setup x86 specific IRQ routing
 184  */
 185 int kvm_arch_init_irq_routing(void)
 186 {
 187     int i, r;
 188
 189     if (kvm_has_gsi_routing()) {
 190         kvm_clear_gsi_routes();
 191         for (i = 0; i < 8; ++i) {
 192             if (i == 2) {
 193                 continue;
 194             }
 195             r = kvm_add_irq_route(i, KVM_IRQCHIP_PIC_MASTER, i);
 196             if (r < 0) {
 197                 return r;
 198             }
 199         }
 200         for (i = 8; i < 16; ++i) {
 201             r = kvm_add_irq_route(i, KVM_IRQCHIP_PIC_SLAVE, i - 8);
 202             if (r < 0) {
 203                 return r;
 204             }
 205         }
 206         for (i = 0; i < 24; ++i) {
 207             if (i == 0) {
 208                 r = kvm_add_irq_route(i, KVM_IRQCHIP_IOAPIC, 2);
 209             } else if (i != 2) {
 210                 r = kvm_add_irq_route(i, KVM_IRQCHIP_IOAPIC, i);
 211             }
 212             if (r < 0) {
 213                 return r;
 214             }
 215         }
 216         kvm_commit_irq_routes();
 217
 218         if (!kvm_has_pit_state2()) {
 219             no_hpet = 1;
 220         }
 221     } else {
 222         /* If kernel can't do irq routing, interrupt source
 223          * override 0->2 can not be set up as required by HPET.
 224          * so we have to disable it.
 225          */
 226         no_hpet = 1;
 227     }
 228
 229     return 0;
 230 }