sys/sys/fkvm.h

   1 /*-
   2  * Copyright (c) 2008 Brent Stephens <brents@rice.edu>
   3  * Copyright (c) 2008 Diego Ongaro <diego.ongaro@rice.edu>
   4  * Copyright (c) 2008 Kaushik Kumar Ram <kaushik@rice.edu>
   5  * Copyright (c) 2008 Oleg Pesok <olegpesok@gmail.com>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #ifndef _FKVM_H_
  31 #define _FKVM_H_
  32
  33 #include <sys/types.h>
  34
  35 #define KVM_NR_INTERRUPTS 256
  36 #define MAX_VCPUS 8
  37
  38 /* MSR */
  39
  40 struct kvm_msr_list {
  41         uint32_t nmsrs; /* number of msrs in entries */
  42         uint32_t indices[0];
  43 };
  44
  45 struct kvm_msr_entry {
  46         uint32_t index;
  47         uint32_t reserved;
  48         uint64_t data;
  49 };
  50
  51 struct kvm_msrs {
  52         uint32_t nmsrs; /* number of msrs in entries */
  53         uint32_t pad;
  54
  55         struct kvm_msr_entry entries[0];
  56 };
  57
  58 #if defined(_KERNEL) || defined(FKVM_INTERNAL)
  59 enum {
  60         FKVM_REGS_TYPE_REGS=1,
  61         FKVM_REGS_TYPE_SREGS=2,
  62         FKVM_REGS_TYPE_MSRS=3,
  63 };
  64 #endif
  65
  66 /* get/set regs */
  67
  68 struct kvm_regs {
  69         uint64_t rax;
  70         uint64_t rbx;
  71         uint64_t rcx;
  72         uint64_t rdx;
  73         uint64_t rsi;
  74         uint64_t rdi;
  75         uint64_t rsp;
  76         uint64_t rbp;
  77         uint64_t r8;
  78         uint64_t r9;
  79         uint64_t r10;
  80         uint64_t r11;
  81         uint64_t r12;
  82         uint64_t r13;
  83         uint64_t r14;
  84         uint64_t r15;
  85         uint64_t rip;
  86         uint64_t rflags;
  87 };
  88
  89 /* get/set fpu */
  90
  91 struct kvm_fpu {
  92         uint8_t  fpr[8][16];
  93         uint16_t fcw;
  94         uint16_t fsw;
  95         uint8_t  ftwx;  /* in fxsave format */
  96         uint8_t  pad1;
  97         uint16_t last_opcode;
  98         uint64_t last_ip;
  99         uint64_t last_dp;
 100         uint8_t  xmm[16][16];
 101         uint32_t mxcsr;
 102         uint32_t pad2;
 103 };
 104
 105 /* get/set sregs */
 106
 107 struct kvm_segment {
 108         uint64_t base;
 109         uint32_t limit;
 110         uint16_t selector;
 111         uint8_t  type;
 112         uint8_t  present;
 113         uint8_t  dpl;
 114         uint8_t  db;
 115         uint8_t  s;
 116         uint8_t  l;
 117         uint8_t  g;
 118         uint8_t  avl;
 119         uint8_t  unusable;
 120         uint8_t  padding;
 121 };
 122
 123 struct kvm_dtable {
 124         uint64_t base;
 125         uint16_t limit;
 126         uint16_t padding[3];
 127 };
 128
 129 struct kvm_sregs {
 130         struct kvm_segment cs;
 131         struct kvm_segment ds;
 132         struct kvm_segment es;
 133         struct kvm_segment fs;
 134         struct kvm_segment gs;
 135         struct kvm_segment ss;
 136         struct kvm_segment tr;
 137         struct kvm_segment ldt;
 138         struct kvm_dtable  gdt;
 139         struct kvm_dtable  idt;
 140         uint64_t cr0;
 141         uint64_t cr2;
 142         uint64_t cr3;
 143         uint64_t cr4;
 144         uint64_t cr8;
 145         uint64_t efer;
 146         uint64_t apic_base;
 147         uint64_t interrupt_bitmap[(KVM_NR_INTERRUPTS + 63) / 64];
 148 };
 149
 150 /* debug */
 151
 152 struct kvm_breakpoint {
 153         uint32_t enabled;
 154         uint32_t padding;
 155         uint64_t address;
 156 };
 157
 158 struct kvm_debug_guest {
 159         uint32_t enabled;
 160         uint32_t pad;
 161         struct kvm_breakpoint breakpoints[4];
 162         uint32_t singlestep;
 163 };
 164
 165 /* cpuid */
 166
 167 struct kvm_cpuid_entry {
 168         uint32_t function;
 169         uint32_t eax;
 170         uint32_t ebx;
 171         uint32_t ecx;
 172         uint32_t edx;
 173         uint32_t padding;
 174 };
 175
 176 #if defined(_KERNEL) || defined(FKVM_INTERNAL)
 177
 178 enum {
 179         KVM_EXIT_UNKNOWN         = 0,
 180         KVM_EXIT_EXCEPTION       = 1,
 181         KVM_EXIT_IO              = 2,
 182         KVM_EXIT_HYPERCALL       = 3,
 183         KVM_EXIT_DEBUG           = 4,
 184         KVM_EXIT_HLT             = 5,
 185         KVM_EXIT_MMIO            = 6,
 186         KVM_EXIT_IRQ_WINDOW_OPEN = 7,
 187         KVM_EXIT_SHUTDOWN        = 8,
 188         KVM_EXIT_FAIL_ENTRY      = 9,
 189         KVM_EXIT_INTR            = 10,
 190         KVM_EXIT_SET_TPR         = 11,
 191         KVM_EXIT_TPR_ACCESS      = 12,
 192         KVM_EXIT_S390_SIEIC      = 13,
 193         KVM_EXIT_S390_RESET      = 14,
 194         KVM_EXIT_DCR             = 15,
 195         KVM_EXIT_NMI             = 16,
 196         KVM_EXIT_NMI_WINDOW_OPEN = 17,
 197         KVM_EXIT_CONTINUE        = 18,
 198 };
 199
 200 struct kvm_run {
 201         /* in */
 202         uint8_t request_interrupt_window;
 203         uint8_t request_nmi_window;
 204         uint8_t padding1[6];
 205
 206         /* out */
 207         uint32_t exit_reason;
 208         uint8_t ready_for_interrupt_injection;
 209         uint8_t if_flag;
 210         uint8_t ready_for_nmi_injection;
 211         uint8_t padding2;
 212
 213         /* in (pre_kvm_run), out (post_kvm_run) */
 214         uint64_t cr8;
 215         uint64_t apic_base;
 216
 217         union {
 218                 /* KVM_EXIT_UNKNOWN */
 219                 struct {
 220                         uint64_t hardware_exit_reason;
 221                 } hw;
 222                 /* KVM_EXIT_FAIL_ENTRY */
 223                 struct {
 224                         uint64_t hardware_entry_failure_reason;
 225                 } fail_entry;
 226                 /* KVM_EXIT_EXCEPTION */
 227                 struct {
 228                         uint32_t exception;
 229                         uint32_t error_code;
 230                 } ex;
 231                 /* KVM_EXIT_IO */
 232                 struct kvm_io {
 233 #define KVM_EXIT_IO_IN  0
 234 #define KVM_EXIT_IO_OUT 1
 235                         uint8_t  in; /* 1 = in 0 = out */
 236                         uint8_t  size; /* bytes */
 237                         uint16_t port;
 238                         uint32_t count;
 239                         uint64_t data_offset; /* relative to kvm_run start */
 240                         uint64_t pio_data; /* This is an entire page in KVM, we only need 4 bytes for now */
 241
 242                 } io;
 243                 /* KVM_EXIT_MMIO */
 244                 struct {
 245                         uint64_t phys_addr;
 246                         uint8_t  data[8];
 247                         uint32_t len;
 248                         uint8_t  is_write;
 249                 } mmio;
 250                 /* KVM_EXIT_TPR_ACCESS */
 251                 struct {
 252                         uint64_t rip;
 253                         uint32_t is_write;
 254                         uint32_t pad;
 255                 } tpr_access;
 256                 /* KVM_EXIT_DCR */
 257                 struct {
 258                         uint32_t dcrn;
 259                         uint32_t data;
 260                         uint8_t  is_write;
 261                 } dcr;
 262                 /* Fix the size of the union. */
 263                 uint8_t padding[32];
 264         } u;
 265 };
 266 #endif
 267
 268 #endif /* !_FKVM_H_ */