tools/testing/selftests/kvm/include/x86_64/processor.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * tools/testing/selftests/kvm/include/x86_64/processor.h
   4  *
   5  * Copyright (C) 2018, Google LLC.
   6  */
   7
   8 #ifndef SELFTEST_KVM_PROCESSOR_H
   9 #define SELFTEST_KVM_PROCESSOR_H
  10
  11 #include <assert.h>
  12 #include <stdint.h>
  13
  14 #include <asm/msr-index.h>
  15
  16 #include "../kvm_util.h"
  17
  18 #define X86_EFLAGS_FIXED         (1u << 1)
  19
  20 #define X86_CR4_VME             (1ul << 0)
  21 #define X86_CR4_PVI             (1ul << 1)
  22 #define X86_CR4_TSD             (1ul << 2)
  23 #define X86_CR4_DE              (1ul << 3)
  24 #define X86_CR4_PSE             (1ul << 4)
  25 #define X86_CR4_PAE             (1ul << 5)
  26 #define X86_CR4_MCE             (1ul << 6)
  27 #define X86_CR4_PGE             (1ul << 7)
  28 #define X86_CR4_PCE             (1ul << 8)
  29 #define X86_CR4_OSFXSR          (1ul << 9)
  30 #define X86_CR4_OSXMMEXCPT      (1ul << 10)
  31 #define X86_CR4_UMIP            (1ul << 11)
  32 #define X86_CR4_LA57            (1ul << 12)
  33 #define X86_CR4_VMXE            (1ul << 13)
  34 #define X86_CR4_SMXE            (1ul << 14)
  35 #define X86_CR4_FSGSBASE        (1ul << 16)
  36 #define X86_CR4_PCIDE           (1ul << 17)
  37 #define X86_CR4_OSXSAVE         (1ul << 18)
  38 #define X86_CR4_SMEP            (1ul << 20)
  39 #define X86_CR4_SMAP            (1ul << 21)
  40 #define X86_CR4_PKE             (1ul << 22)
  41
  42 /* CPUID.1.ECX */
  43 #define CPUID_VMX               (1ul << 5)
  44 #define CPUID_SMX               (1ul << 6)
  45 #define CPUID_PCID              (1ul << 17)
  46 #define CPUID_XSAVE             (1ul << 26)
  47
  48 /* CPUID.7.EBX */
  49 #define CPUID_FSGSBASE          (1ul << 0)
  50 #define CPUID_SMEP              (1ul << 7)
  51 #define CPUID_SMAP              (1ul << 20)
  52
  53 /* CPUID.7.ECX */
  54 #define CPUID_UMIP              (1ul << 2)
  55 #define CPUID_PKU               (1ul << 3)
  56 #define CPUID_LA57              (1ul << 16)
  57
  58 /* CPUID.0x8000_0001.EDX */
  59 #define CPUID_GBPAGES           (1ul << 26)
  60
  61 #define UNEXPECTED_VECTOR_PORT 0xfff0u
  62
  63 /* General Registers in 64-Bit Mode */
  64 struct gpr64_regs {
  65         u64 rax;
  66         u64 rcx;
  67         u64 rdx;
  68         u64 rbx;
  69         u64 rsp;
  70         u64 rbp;
  71         u64 rsi;
  72         u64 rdi;
  73         u64 r8;
  74         u64 r9;
  75         u64 r10;
  76         u64 r11;
  77         u64 r12;
  78         u64 r13;
  79         u64 r14;
  80         u64 r15;
  81 };
  82
  83 struct desc64 {
  84         uint16_t limit0;
  85         uint16_t base0;
  86         unsigned base1:8, type:4, s:1, dpl:2, p:1;
  87         unsigned limit1:4, avl:1, l:1, db:1, g:1, base2:8;
  88         uint32_t base3;
  89         uint32_t zero1;
  90 } __attribute__((packed));
  91
  92 struct desc_ptr {
  93         uint16_t size;
  94         uint64_t address;
  95 } __attribute__((packed));
  96
  97 static inline uint64_t get_desc64_base(const struct desc64 *desc)
  98 {
  99         return ((uint64_t)desc->base3 << 32) |
 100                 (desc->base0 | ((desc->base1) << 16) | ((desc->base2) << 24));
 101 }
 102
 103 static inline uint64_t rdtsc(void)
 104 {
 105         uint32_t eax, edx;
 106         uint64_t tsc_val;
 107         /*
 108          * The lfence is to wait (on Intel CPUs) until all previous
 109          * instructions have been executed. If software requires RDTSC to be
 110          * executed prior to execution of any subsequent instruction, it can
 111          * execute LFENCE immediately after RDTSC
 112          */
 113         __asm__ __volatile__("lfence; rdtsc; lfence" : "=a"(eax), "=d"(edx));
 114         tsc_val = ((uint64_t)edx) << 32 | eax;
 115         return tsc_val;
 116 }
 117
 118 static inline uint64_t rdtscp(uint32_t *aux)
 119 {
 120         uint32_t eax, edx;
 121
 122         __asm__ __volatile__("rdtscp" : "=a"(eax), "=d"(edx), "=c"(*aux));
 123         return ((uint64_t)edx) << 32 | eax;
 124 }
 125
 126 static inline uint64_t rdmsr(uint32_t msr)
 127 {
 128         uint32_t a, d;
 129
 130         __asm__ __volatile__("rdmsr" : "=a"(a), "=d"(d) : "c"(msr) : "memory");
 131
 132         return a | ((uint64_t) d << 32);
 133 }
 134
 135 static inline void wrmsr(uint32_t msr, uint64_t value)
 136 {
 137         uint32_t a = value;
 138         uint32_t d = value >> 32;
 139
 140         __asm__ __volatile__("wrmsr" :: "a"(a), "d"(d), "c"(msr) : "memory");
 141 }
 142
 143
 144 static inline uint16_t inw(uint16_t port)
 145 {
 146         uint16_t tmp;
 147
 148         __asm__ __volatile__("in %%dx, %%ax"
 149                 : /* output */ "=a" (tmp)
 150                 : /* input */ "d" (port));
 151
 152         return tmp;
 153 }
 154
 155 static inline uint16_t get_es(void)
 156 {
 157         uint16_t es;
 158
 159         __asm__ __volatile__("mov %%es, %[es]"
 160                              : /* output */ [es]"=rm"(es));
 161         return es;
 162 }
 163
 164 static inline uint16_t get_cs(void)
 165 {
 166         uint16_t cs;
 167
 168         __asm__ __volatile__("mov %%cs, %[cs]"
 169                              : /* output */ [cs]"=rm"(cs));
 170         return cs;
 171 }
 172
 173 static inline uint16_t get_ss(void)
 174 {
 175         uint16_t ss;
 176
 177         __asm__ __volatile__("mov %%ss, %[ss]"
 178                              : /* output */ [ss]"=rm"(ss));
 179         return ss;
 180 }
 181
 182 static inline uint16_t get_ds(void)
 183 {
 184         uint16_t ds;
 185
 186         __asm__ __volatile__("mov %%ds, %[ds]"
 187                              : /* output */ [ds]"=rm"(ds));
 188         return ds;
 189 }
 190
 191 static inline uint16_t get_fs(void)
 192 {
 193         uint16_t fs;
 194
 195         __asm__ __volatile__("mov %%fs, %[fs]"
 196                              : /* output */ [fs]"=rm"(fs));
 197         return fs;
 198 }
 199
 200 static inline uint16_t get_gs(void)
 201 {
 202         uint16_t gs;
 203
 204         __asm__ __volatile__("mov %%gs, %[gs]"
 205                              : /* output */ [gs]"=rm"(gs));
 206         return gs;
 207 }
 208
 209 static inline uint16_t get_tr(void)
 210 {
 211         uint16_t tr;
 212
 213         __asm__ __volatile__("str %[tr]"
 214                              : /* output */ [tr]"=rm"(tr));
 215         return tr;
 216 }
 217
 218 static inline uint64_t get_cr0(void)
 219 {
 220         uint64_t cr0;
 221
 222         __asm__ __volatile__("mov %%cr0, %[cr0]"
 223                              : /* output */ [cr0]"=r"(cr0));
 224         return cr0;
 225 }
 226
 227 static inline uint64_t get_cr3(void)
 228 {
 229         uint64_t cr3;
 230
 231         __asm__ __volatile__("mov %%cr3, %[cr3]"
 232                              : /* output */ [cr3]"=r"(cr3));
 233         return cr3;
 234 }
 235
 236 static inline uint64_t get_cr4(void)
 237 {
 238         uint64_t cr4;
 239
 240         __asm__ __volatile__("mov %%cr4, %[cr4]"
 241                              : /* output */ [cr4]"=r"(cr4));
 242         return cr4;
 243 }
 244
 245 static inline void set_cr4(uint64_t val)
 246 {
 247         __asm__ __volatile__("mov %0, %%cr4" : : "r" (val) : "memory");
 248 }
 249
 250 static inline struct desc_ptr get_gdt(void)
 251 {
 252         struct desc_ptr gdt;
 253         __asm__ __volatile__("sgdt %[gdt]"
 254                              : /* output */ [gdt]"=m"(gdt));
 255         return gdt;
 256 }
 257
 258 static inline struct desc_ptr get_idt(void)
 259 {
 260         struct desc_ptr idt;
 261         __asm__ __volatile__("sidt %[idt]"
 262                              : /* output */ [idt]"=m"(idt));
 263         return idt;
 264 }
 265
 266 static inline void outl(uint16_t port, uint32_t value)
 267 {
 268         __asm__ __volatile__("outl %%eax, %%dx" : : "d"(port), "a"(value));
 269 }
 270
 271 static inline void cpuid(uint32_t *eax, uint32_t *ebx,
 272                          uint32_t *ecx, uint32_t *edx)
 273 {
 274         /* ecx is often an input as well as an output. */
 275         asm volatile("cpuid"
 276             : "=a" (*eax),
 277               "=b" (*ebx),
 278               "=c" (*ecx),
 279               "=d" (*edx)
 280             : "0" (*eax), "2" (*ecx)
 281             : "memory");
 282 }
 283
 284 #define SET_XMM(__var, __xmm) \
 285         asm volatile("movq %0, %%"#__xmm : : "r"(__var) : #__xmm)
 286
 287 static inline void set_xmm(int n, unsigned long val)
 288 {
 289         switch (n) {
 290         case 0:
 291                 SET_XMM(val, xmm0);
 292                 break;
 293         case 1:
 294                 SET_XMM(val, xmm1);
 295                 break;
 296         case 2:
 297                 SET_XMM(val, xmm2);
 298                 break;
 299         case 3:
 300                 SET_XMM(val, xmm3);
 301                 break;
 302         case 4:
 303                 SET_XMM(val, xmm4);
 304                 break;
 305         case 5:
 306                 SET_XMM(val, xmm5);
 307                 break;
 308         case 6:
 309                 SET_XMM(val, xmm6);
 310                 break;
 311         case 7:
 312                 SET_XMM(val, xmm7);
 313                 break;
 314         }
 315 }
 316
 317 typedef unsigned long v1di __attribute__ ((vector_size (8)));
 318 static inline unsigned long get_xmm(int n)
 319 {
 320         assert(n >= 0 && n <= 7);
 321
 322         register v1di xmm0 __asm__("%xmm0");
 323         register v1di xmm1 __asm__("%xmm1");
 324         register v1di xmm2 __asm__("%xmm2");
 325         register v1di xmm3 __asm__("%xmm3");
 326         register v1di xmm4 __asm__("%xmm4");
 327         register v1di xmm5 __asm__("%xmm5");
 328         register v1di xmm6 __asm__("%xmm6");
 329         register v1di xmm7 __asm__("%xmm7");
 330         switch (n) {
 331         case 0:
 332                 return (unsigned long)xmm0;
 333         case 1:
 334                 return (unsigned long)xmm1;
 335         case 2:
 336                 return (unsigned long)xmm2;
 337         case 3:
 338                 return (unsigned long)xmm3;
 339         case 4:
 340                 return (unsigned long)xmm4;
 341         case 5:
 342                 return (unsigned long)xmm5;
 343         case 6:
 344                 return (unsigned long)xmm6;
 345         case 7:
 346                 return (unsigned long)xmm7;
 347         }
 348         return 0;
 349 }
 350
 351 bool is_intel_cpu(void);
 352
 353 struct kvm_x86_state;
 354 struct kvm_x86_state *vcpu_save_state(struct kvm_vm *vm, uint32_t vcpuid);
 355 void vcpu_load_state(struct kvm_vm *vm, uint32_t vcpuid,
 356                      struct kvm_x86_state *state);
 357
 358 struct kvm_msr_list *kvm_get_msr_index_list(void);
 359 uint64_t kvm_get_feature_msr(uint64_t msr_index);
 360 struct kvm_cpuid2 *kvm_get_supported_cpuid(void);
 361
 362 struct kvm_cpuid2 *vcpu_get_cpuid(struct kvm_vm *vm, uint32_t vcpuid);
 363 void vcpu_set_cpuid(struct kvm_vm *vm, uint32_t vcpuid,
 364                     struct kvm_cpuid2 *cpuid);
 365
 366 struct kvm_cpuid_entry2 *
 367 kvm_get_supported_cpuid_index(uint32_t function, uint32_t index);
 368
 369 static inline struct kvm_cpuid_entry2 *
 370 kvm_get_supported_cpuid_entry(uint32_t function)
 371 {
 372         return kvm_get_supported_cpuid_index(function, 0);
 373 }
 374
 375 uint64_t vcpu_get_msr(struct kvm_vm *vm, uint32_t vcpuid, uint64_t msr_index);
 376 int _vcpu_set_msr(struct kvm_vm *vm, uint32_t vcpuid, uint64_t msr_index,
 377                   uint64_t msr_value);
 378 void vcpu_set_msr(struct kvm_vm *vm, uint32_t vcpuid, uint64_t msr_index,
 379                   uint64_t msr_value);
 380
 381 uint32_t kvm_get_cpuid_max_basic(void);
 382 uint32_t kvm_get_cpuid_max_extended(void);
 383 void kvm_get_cpu_address_width(unsigned int *pa_bits, unsigned int *va_bits);
 384
 385 struct ex_regs {
 386         uint64_t rax, rcx, rdx, rbx;
 387         uint64_t rbp, rsi, rdi;
 388         uint64_t r8, r9, r10, r11;
 389         uint64_t r12, r13, r14, r15;
 390         uint64_t vector;
 391         uint64_t error_code;
 392         uint64_t rip;
 393         uint64_t cs;
 394         uint64_t rflags;
 395 };
 396
 397 void vm_init_descriptor_tables(struct kvm_vm *vm);
 398 void vcpu_init_descriptor_tables(struct kvm_vm *vm, uint32_t vcpuid);
 399 void vm_handle_exception(struct kvm_vm *vm, int vector,
 400                         void (*handler)(struct ex_regs *));
 401
 402 uint64_t vm_get_page_table_entry(struct kvm_vm *vm, int vcpuid, uint64_t vaddr);
 403 void vm_set_page_table_entry(struct kvm_vm *vm, int vcpuid, uint64_t vaddr,
 404                              uint64_t pte);
 405
 406 /*
 407  * set_cpuid() - overwrites a matching cpuid entry with the provided value.
 408  *               matches based on ent->function && ent->index. returns true
 409  *               if a match was found and successfully overwritten.
 410  * @cpuid: the kvm cpuid list to modify.
 411  * @ent: cpuid entry to insert
 412  */
 413 bool set_cpuid(struct kvm_cpuid2 *cpuid, struct kvm_cpuid_entry2 *ent);
 414
 415 uint64_t kvm_hypercall(uint64_t nr, uint64_t a0, uint64_t a1, uint64_t a2,
 416                        uint64_t a3);
 417
 418 struct kvm_cpuid2 *kvm_get_supported_hv_cpuid(void);
 419 void vcpu_set_hv_cpuid(struct kvm_vm *vm, uint32_t vcpuid);
 420 struct kvm_cpuid2 *vcpu_get_supported_hv_cpuid(struct kvm_vm *vm, uint32_t vcpuid);
 421
 422 enum x86_page_size {
 423         X86_PAGE_SIZE_4K = 0,
 424         X86_PAGE_SIZE_2M,
 425         X86_PAGE_SIZE_1G,
 426 };
 427 void __virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,
 428                    enum x86_page_size page_size);
 429
 430 /*
 431  * Basic CPU control in CR0
 432  */
 433 #define X86_CR0_PE          (1UL<<0) /* Protection Enable */
 434 #define X86_CR0_MP          (1UL<<1) /* Monitor Coprocessor */
 435 #define X86_CR0_EM          (1UL<<2) /* Emulation */
 436 #define X86_CR0_TS          (1UL<<3) /* Task Switched */
 437 #define X86_CR0_ET          (1UL<<4) /* Extension Type */
 438 #define X86_CR0_NE          (1UL<<5) /* Numeric Error */
 439 #define X86_CR0_WP          (1UL<<16) /* Write Protect */
 440 #define X86_CR0_AM          (1UL<<18) /* Alignment Mask */
 441 #define X86_CR0_NW          (1UL<<29) /* Not Write-through */
 442 #define X86_CR0_CD          (1UL<<30) /* Cache Disable */
 443 #define X86_CR0_PG          (1UL<<31) /* Paging */
 444
 445 /* VMX_EPT_VPID_CAP bits */
 446 #define VMX_EPT_VPID_CAP_AD_BITS       (1ULL << 21)
 447
 448 #endif /* SELFTEST_KVM_PROCESSOR_H */