qemu-kvm.h

   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 #ifndef THE_ORIGINAL_AND_TRUE_QEMU_KVM_H
   9 #define THE_ORIGINAL_AND_TRUE_QEMU_KVM_H
  10
  11 #include "cpu.h"
  12
  13 #include <signal.h>
  14 #include <stdlib.h>
  15
  16 #ifdef CONFIG_KVM
  17
  18 #if defined(__s390__)
  19 #include <asm/ptrace.h>
  20 #endif
  21
  22 #include <stdint.h>
  23
  24 #ifndef __user
  25 #define __user       /* temporary, until installed via make headers_install */
  26 #endif
  27
  28 #include <linux/kvm.h>
  29
  30 #include <signal.h>
  31
  32 /* FIXME: share this number with kvm */
  33 /* FIXME: or dynamically alloc/realloc regions */
  34 #ifdef __s390__
  35 #define KVM_MAX_NUM_MEM_REGIONS 1u
  36 #define MAX_VCPUS 64
  37 #define LIBKVM_S390_ORIGIN (0UL)
  38 #elif defined(__ia64__)
  39 #define KVM_MAX_NUM_MEM_REGIONS 32u
  40 #define MAX_VCPUS 256
  41 #else
  42 #define KVM_MAX_NUM_MEM_REGIONS 32u
  43 #define MAX_VCPUS 16
  44 #endif
  45
  46 #include "kvm.h"
  47
  48 int kvm_arch_run(CPUState *env);
  49
  50 int kvm_create_irqchip(KVMState *s);
  51
  52 /*!
  53  * \brief Check if a vcpu is ready for interrupt injection
  54  *
  55  * This checks if vcpu interrupts are not masked by mov ss or sti.
  56  *
  57  * \param kvm Pointer to the current kvm_context
  58  * \param vcpu Which virtual CPU should get dumped
  59  * \return boolean indicating interrupt injection readiness
  60  */
  61 int kvm_is_ready_for_interrupt_injection(CPUState *env);
  62
  63 #if defined(__i386__) || defined(__x86_64__)
  64 /*!
  65  * \brief Simulate an external vectored interrupt
  66  *
  67  * This allows you to simulate an external vectored interrupt.
  68  *
  69  * \param kvm Pointer to the current kvm_context
  70  * \param vcpu Which virtual CPU should get dumped
  71  * \param irq Vector number
  72  * \return 0 on success
  73  */
  74 int kvm_inject_irq(CPUState *env, unsigned irq);
  75 #endif
  76
  77 #ifdef KVM_CAP_IRQCHIP
  78 /*!
  79  * \brief Dump in kernel IRQCHIP contents
  80  *
  81  * Dump one of the in kernel irq chip devices, including PIC (master/slave)
  82  * and IOAPIC into a kvm_irqchip structure
  83  *
  84  * \param kvm Pointer to the current kvm_context
  85  * \param chip The irq chip device to be dumped
  86  */
  87 int kvm_get_irqchip(KVMState *s, struct kvm_irqchip *chip);
  88
  89 /*!
  90  * \brief Set in kernel IRQCHIP contents
  91  *
  92  * Write one of the in kernel irq chip devices, including PIC (master/slave)
  93  * and IOAPIC
  94  *
  95  *
  96  * \param kvm Pointer to the current kvm_context
  97  * \param chip THe irq chip device to be written
  98  */
  99 int kvm_set_irqchip(KVMState *s, struct kvm_irqchip *chip);
 100
 101 #if defined(__i386__) || defined(__x86_64__)
 102 /*!
 103  * \brief Get in kernel local APIC for vcpu
 104  *
 105  * Save the local apic state including the timer of a virtual CPU
 106  *
 107  * \param kvm Pointer to the current kvm_context
 108  * \param vcpu Which virtual CPU should be accessed
 109  * \param s Local apic state of the specific virtual CPU
 110  */
 111 int kvm_get_lapic(CPUState *env, struct kvm_lapic_state *s);
 112
 113 /*!
 114  * \brief Set in kernel local APIC for vcpu
 115  *
 116  * Restore the local apic state including the timer of a virtual CPU
 117  *
 118  * \param kvm Pointer to the current kvm_context
 119  * \param vcpu Which virtual CPU should be accessed
 120  * \param s Local apic state of the specific virtual CPU
 121  */
 122 int kvm_set_lapic(CPUState *env, struct kvm_lapic_state *s);
 123
 124 #endif
 125
 126 /*!
 127  * \brief Simulate an NMI
 128  *
 129  * This allows you to simulate a non-maskable interrupt.
 130  *
 131  * \param kvm Pointer to the current kvm_context
 132  * \param vcpu Which virtual CPU should get dumped
 133  * \return 0 on success
 134  */
 135 int kvm_inject_nmi(CPUState *env);
 136
 137 #endif
 138
 139 #ifdef KVM_CAP_PIT
 140
 141 #if defined(__i386__) || defined(__x86_64__)
 142 /*!
 143  * \brief Get in kernel PIT of the virtual domain
 144  *
 145  * Save the PIT state.
 146  *
 147  * \param kvm Pointer to the current kvm_context
 148  * \param s PIT state of the virtual domain
 149  */
 150 int kvm_get_pit(KVMState *s, struct kvm_pit_state *pit_state);
 151
 152 /*!
 153  * \brief Set in kernel PIT of the virtual domain
 154  *
 155  * Restore the PIT state.
 156  * Timer would be retriggerred after restored.
 157  *
 158  * \param kvm Pointer to the current kvm_context
 159  * \param s PIT state of the virtual domain
 160  */
 161 int kvm_set_pit(KVMState *s, struct kvm_pit_state *pit_state);
 162
 163 int kvm_reinject_control(KVMState *s, int pit_reinject);
 164
 165 #ifdef KVM_CAP_PIT_STATE2
 166 /*!
 167  * \brief Set in kernel PIT state2 of the virtual domain
 168  *
 169  *
 170  * \param kvm Pointer to the current kvm_context
 171  * \param ps2 PIT state2 of the virtual domain
 172  * \return 0 on success
 173  */
 174 int kvm_set_pit2(KVMState *s, struct kvm_pit_state2 *ps2);
 175
 176 /*!
 177  * \brief Get in kernel PIT state2 of the virtual domain
 178  *
 179  *
 180  * \param kvm Pointer to the current kvm_context
 181  * \param ps2 PIT state2 of the virtual domain
 182  * \return 0 on success
 183  */
 184 int kvm_get_pit2(KVMState *s, struct kvm_pit_state2 *ps2);
 185
 186 #endif
 187 #endif
 188 #endif
 189
 190 #ifdef KVM_CAP_VAPIC
 191
 192 int kvm_enable_vapic(CPUState *env, uint64_t vapic);
 193
 194 #endif
 195
 196 #ifdef KVM_CAP_DEVICE_ASSIGNMENT
 197 /*!
 198  * \brief Notifies host kernel about a PCI device to be assigned to a guest
 199  *
 200  * Used for PCI device assignment, this function notifies the host
 201  * kernel about the assigning of the physical PCI device to a guest.
 202  *
 203  * \param kvm Pointer to the current kvm_context
 204  * \param assigned_dev Parameters, like bus, devfn number, etc
 205  */
 206 int kvm_assign_pci_device(KVMState *s,
 207                           struct kvm_assigned_pci_dev *assigned_dev);
 208
 209 /*!
 210  * \brief Assign IRQ for an assigned device
 211  *
 212  * Used for PCI device assignment, this function assigns IRQ numbers for
 213  * an physical device and guest IRQ handling.
 214  *
 215  * \param kvm Pointer to the current kvm_context
 216  * \param assigned_irq Parameters, like dev id, host irq, guest irq, etc
 217  */
 218 int kvm_assign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq);
 219
 220 #ifdef KVM_CAP_ASSIGN_DEV_IRQ
 221 /*!
 222  * \brief Deassign IRQ for an assigned device
 223  *
 224  * Used for PCI device assignment, this function deassigns IRQ numbers
 225  * for an assigned device.
 226  *
 227  * \param kvm Pointer to the current kvm_context
 228  * \param assigned_irq Parameters, like dev id, host irq, guest irq, etc
 229  */
 230 int kvm_deassign_irq(KVMState *s, struct kvm_assigned_irq *assigned_irq);
 231 #endif
 232 #endif
 233
 234 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
 235 /*!
 236  * \brief Notifies host kernel about a PCI device to be deassigned from a guest
 237  *
 238  * Used for hot remove PCI device, this function notifies the host
 239  * kernel about the deassigning of the physical PCI device from a guest.
 240  *
 241  * \param kvm Pointer to the current kvm_context
 242  * \param assigned_dev Parameters, like bus, devfn number, etc
 243  */
 244 int kvm_deassign_pci_device(KVMState *s,
 245                             struct kvm_assigned_pci_dev *assigned_dev);
 246 #endif
 247
 248 /*!
 249  * \brief Clears the temporary irq routing table
 250  *
 251  * Clears the temporary irq routing table.  Nothing is committed to the
 252  * running VM.
 253  *
 254  */
 255 int kvm_clear_gsi_routes(void);
 256
 257 /*!
 258  * \brief Adds an irq route to the temporary irq routing table
 259  *
 260  * Adds an irq route to the temporary irq routing table.  Nothing is
 261  * committed to the running VM.
 262  */
 263 int kvm_add_irq_route(int gsi, int irqchip, int pin);
 264
 265 /*!
 266  * \brief Removes an irq route from the temporary irq routing table
 267  *
 268  * Adds an irq route to the temporary irq routing table.  Nothing is
 269  * committed to the running VM.
 270  */
 271 int kvm_del_irq_route(int gsi, int irqchip, int pin);
 272
 273 struct kvm_irq_routing_entry;
 274 /*!
 275  * \brief Adds a routing entry to the temporary irq routing table
 276  *
 277  * Adds a filled routing entry to the temporary irq routing table. Nothing is
 278  * committed to the running VM.
 279  */
 280 int kvm_add_routing_entry(struct kvm_irq_routing_entry *entry);
 281
 282 /*!
 283  * \brief Removes a routing from the temporary irq routing table
 284  *
 285  * Remove a routing to the temporary irq routing table.  Nothing is
 286  * committed to the running VM.
 287  */
 288 int kvm_del_routing_entry(struct kvm_irq_routing_entry *entry);
 289
 290 /*!
 291  * \brief Updates a routing in the temporary irq routing table
 292  *
 293  * Update a routing in the temporary irq routing table
 294  * with a new value. entry type and GSI can not be changed.
 295  * Nothing is committed to the running VM.
 296  */
 297 int kvm_update_routing_entry(struct kvm_irq_routing_entry *entry,
 298                              struct kvm_irq_routing_entry *newentry);
 299
 300
 301 #ifdef KVM_CAP_DEVICE_MSIX
 302 int kvm_assign_set_msix_nr(KVMState *s, struct kvm_assigned_msix_nr *msix_nr);
 303 int kvm_assign_set_msix_entry(KVMState *s,
 304                               struct kvm_assigned_msix_entry *entry);
 305 #endif
 306
 307 #else                           /* !CONFIG_KVM */
 308
 309 struct kvm_pit_state {
 310 };
 311
 312 #endif                          /* !CONFIG_KVM */
 313
 314
 315 /*!
 316  * \brief Create new KVM context
 317  *
 318  * This creates a new kvm_context. A KVM context is a small area of data that
 319  * holds information about the KVM instance that gets created by this call.\n
 320  * This should always be your first call to KVM.
 321  *
 322  * \param opaque Not used
 323  * \return NULL on failure
 324  */
 325 int kvm_init(void);
 326
 327 int kvm_main_loop(void);
 328 int kvm_init_ap(void);
 329 void kvm_save_lapic(CPUState *env);
 330 void kvm_load_lapic(CPUState *env);
 331
 332 void kvm_hpet_enable_kpit(void);
 333 void kvm_hpet_disable_kpit(void);
 334
 335 void on_vcpu(CPUState *env, void (*func)(void *data), void *data);
 336 void kvm_update_interrupt_request(CPUState *env);
 337
 338 int kvm_arch_has_work(CPUState *env);
 339 void kvm_arch_process_irqchip_events(CPUState *env);
 340 int kvm_arch_try_push_interrupts(void *opaque);
 341 void kvm_arch_push_nmi(void);
 342 int kvm_set_boot_cpu_id(KVMState *s, uint32_t id);
 343
 344 void kvm_tpr_access_report(CPUState *env, uint64_t rip, int is_write);
 345
 346 int kvm_arch_init_irq_routing(void);
 347
 348 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
 349 struct ioperm_data;
 350
 351 void kvm_ioperm(CPUState *env, void *data);
 352 void kvm_add_ioperm_data(struct ioperm_data *data);
 353 void kvm_remove_ioperm_data(unsigned long start_port, unsigned long num);
 354 void kvm_arch_do_ioperm(void *_data);
 355 #endif
 356
 357 #ifdef CONFIG_KVM
 358 #include "qemu-queue.h"
 359
 360 extern int kvm_irqchip;
 361 extern int kvm_pit;
 362 extern int kvm_pit_reinject;
 363 extern int kvm_nested;
 364 extern unsigned int kvm_shadow_memory;
 365
 366 struct ioperm_data {
 367     unsigned long start_port;
 368     unsigned long num;
 369     int turn_on;
 370     QLIST_ENTRY(ioperm_data) entries;
 371 };
 372
 373 int kvm_arch_halt(CPUState *env);
 374 int handle_tpr_access(void *opaque, CPUState *env, uint64_t rip,
 375                       int is_write);
 376
 377 #else
 378 #define kvm_nested 0
 379 #endif
 380
 381 int kvm_tpr_enable_vapic(CPUState *env);
 382
 383 unsigned long kvm_get_thread_id(void);
 384
 385 #endif