tools/kvm/kvm-cpu.c

   1 #include "kvm/kvm-cpu.h"
   2
   3 #include "kvm/symbol.h"
   4 #include "kvm/util.h"
   5 #include "kvm/kvm.h"
   6
   7 #include <asm/msr-index.h>
   8
   9 #include <sys/ioctl.h>
  10 #include <sys/mman.h>
  11 #include <signal.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <errno.h>
  15 #include <stdio.h>
  16
  17 static inline bool is_in_protected_mode(struct kvm_cpu *vcpu)
  18 {
  19         return vcpu->sregs.cr0 & 0x01;
  20 }
  21
  22 static inline u64 ip_to_flat(struct kvm_cpu *vcpu, u64 ip)
  23 {
  24         u64 cs;
  25
  26         /*
  27          * NOTE! We should take code segment base address into account here.
  28          * Luckily it's usually zero because Linux uses flat memory model.
  29          */
  30         if (is_in_protected_mode(vcpu))
  31                 return ip;
  32
  33         cs = vcpu->sregs.cs.selector;
  34
  35         return ip + (cs << 4);
  36 }
  37
  38 static inline u32 selector_to_base(u16 selector)
  39 {
  40         /*
  41          * KVM on Intel requires 'base' to be 'selector * 16' in real mode.
  42          */
  43         return (u32)selector * 16;
  44 }
  45
  46 static struct kvm_cpu *kvm_cpu__new(struct kvm *kvm)
  47 {
  48         struct kvm_cpu *vcpu;
  49
  50         vcpu            = calloc(1, sizeof *vcpu);
  51         if (!vcpu)
  52                 return NULL;
  53
  54         vcpu->kvm       = kvm;
  55
  56         return vcpu;
  57 }
  58
  59 void kvm_cpu__delete(struct kvm_cpu *vcpu)
  60 {
  61         if (vcpu->msrs)
  62                 free(vcpu->msrs);
  63
  64         free(vcpu);
  65 }
  66
  67 struct kvm_cpu *kvm_cpu__init(struct kvm *kvm, unsigned long cpu_id)
  68 {
  69         struct kvm_cpu *vcpu;
  70         int mmap_size;
  71
  72         vcpu            = kvm_cpu__new(kvm);
  73         if (!vcpu)
  74                 return NULL;
  75
  76         vcpu->cpu_id    = cpu_id;
  77
  78         vcpu->vcpu_fd = ioctl(vcpu->kvm->vm_fd, KVM_CREATE_VCPU, cpu_id);
  79         if (vcpu->vcpu_fd < 0)
  80                 die_perror("KVM_CREATE_VCPU ioctl");
  81
  82         mmap_size = ioctl(vcpu->kvm->sys_fd, KVM_GET_VCPU_MMAP_SIZE, 0);
  83         if (mmap_size < 0)
  84                 die_perror("KVM_GET_VCPU_MMAP_SIZE ioctl");
  85
  86         vcpu->kvm_run = mmap(NULL, mmap_size, PROT_RW, MAP_SHARED, vcpu->vcpu_fd, 0);
  87         if (vcpu->kvm_run == MAP_FAILED)
  88                 die("unable to mmap vcpu fd");
  89
  90         return vcpu;
  91 }
  92
  93 void kvm_cpu__enable_singlestep(struct kvm_cpu *vcpu)
  94 {
  95         struct kvm_guest_debug debug = {
  96                 .control        = KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP,
  97         };
  98
  99         if (ioctl(vcpu->vcpu_fd, KVM_SET_GUEST_DEBUG, &debug) < 0)
 100                 pr_warning("KVM_SET_GUEST_DEBUG failed");
 101 }
 102
 103 static struct kvm_msrs *kvm_msrs__new(size_t nmsrs)
 104 {
 105         struct kvm_msrs *vcpu = calloc(1, sizeof(*vcpu) + (sizeof(struct kvm_msr_entry) * nmsrs));
 106
 107         if (!vcpu)
 108                 die("out of memory");
 109
 110         return vcpu;
 111 }
 112
 113 #define KVM_MSR_ENTRY(_index, _data)    \
 114         (struct kvm_msr_entry) { .index = _index, .data = _data }
 115
 116 static void kvm_cpu__setup_msrs(struct kvm_cpu *vcpu)
 117 {
 118         unsigned long ndx = 0;
 119
 120         vcpu->msrs = kvm_msrs__new(100);
 121
 122         vcpu->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_SYSENTER_CS,        0x0);
 123         vcpu->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_SYSENTER_ESP,       0x0);
 124         vcpu->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_SYSENTER_EIP,       0x0);
 125 #ifdef CONFIG_X86_64
 126         vcpu->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_STAR,                    0x0);
 127         vcpu->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_CSTAR,                   0x0);
 128         vcpu->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_KERNEL_GS_BASE,          0x0);
 129         vcpu->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_SYSCALL_MASK,            0x0);
 130         vcpu->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_LSTAR,                   0x0);
 131 #endif
 132         vcpu->msrs->entries[ndx++] = KVM_MSR_ENTRY(MSR_IA32_TSC,                0x0);
 133
 134         vcpu->msrs->nmsrs       = ndx;
 135
 136         if (ioctl(vcpu->vcpu_fd, KVM_SET_MSRS, vcpu->msrs) < 0)
 137                 die_perror("KVM_SET_MSRS failed");
 138 }
 139
 140 static void kvm_cpu__setup_fpu(struct kvm_cpu *vcpu)
 141 {
 142         vcpu->fpu = (struct kvm_fpu) {
 143                 .fcw            = 0x37f,
 144                 .mxcsr          = 0x1f80,
 145         };
 146
 147         if (ioctl(vcpu->vcpu_fd, KVM_SET_FPU, &vcpu->fpu) < 0)
 148                 die_perror("KVM_SET_FPU failed");
 149 }
 150
 151 static void kvm_cpu__setup_regs(struct kvm_cpu *vcpu)
 152 {
 153         vcpu->regs = (struct kvm_regs) {
 154                 /* We start the guest in 16-bit real mode  */
 155                 .rflags         = 0x0000000000000002ULL,
 156
 157                 .rip            = vcpu->kvm->boot_ip,
 158                 .rsp            = vcpu->kvm->boot_sp,
 159                 .rbp            = vcpu->kvm->boot_sp,
 160         };
 161
 162         if (vcpu->regs.rip > USHRT_MAX)
 163                 die("ip 0x%llx is too high for real mode", (u64) vcpu->regs.rip);
 164
 165         if (ioctl(vcpu->vcpu_fd, KVM_SET_REGS, &vcpu->regs) < 0)
 166                 die_perror("KVM_SET_REGS failed");
 167 }
 168
 169 static void kvm_cpu__setup_sregs(struct kvm_cpu *vcpu)
 170 {
 171
 172         if (ioctl(vcpu->vcpu_fd, KVM_GET_SREGS, &vcpu->sregs) < 0)
 173                 die_perror("KVM_GET_SREGS failed");
 174
 175         vcpu->sregs.cs.selector = vcpu->kvm->boot_selector;
 176         vcpu->sregs.cs.base     = selector_to_base(vcpu->kvm->boot_selector);
 177         vcpu->sregs.ss.selector = vcpu->kvm->boot_selector;
 178         vcpu->sregs.ss.base     = selector_to_base(vcpu->kvm->boot_selector);
 179         vcpu->sregs.ds.selector = vcpu->kvm->boot_selector;
 180         vcpu->sregs.ds.base     = selector_to_base(vcpu->kvm->boot_selector);
 181         vcpu->sregs.es.selector = vcpu->kvm->boot_selector;
 182         vcpu->sregs.es.base     = selector_to_base(vcpu->kvm->boot_selector);
 183         vcpu->sregs.fs.selector = vcpu->kvm->boot_selector;
 184         vcpu->sregs.fs.base     = selector_to_base(vcpu->kvm->boot_selector);
 185         vcpu->sregs.gs.selector = vcpu->kvm->boot_selector;
 186         vcpu->sregs.gs.base     = selector_to_base(vcpu->kvm->boot_selector);
 187
 188         if (ioctl(vcpu->vcpu_fd, KVM_SET_SREGS, &vcpu->sregs) < 0)
 189                 die_perror("KVM_SET_SREGS failed");
 190 }
 191
 192 /**
 193  * kvm_cpu__reset_vcpu - reset virtual CPU to a known state
 194  */
 195 void kvm_cpu__reset_vcpu(struct kvm_cpu *vcpu)
 196 {
 197         kvm_cpu__setup_sregs(vcpu);
 198         kvm_cpu__setup_regs(vcpu);
 199         kvm_cpu__setup_fpu(vcpu);
 200         kvm_cpu__setup_msrs(vcpu);
 201 }
 202
 203 static void print_dtable(const char *name, struct kvm_dtable *dtable)
 204 {
 205         printf(" %s                 %016llx  %08hx\n",
 206                 name, (u64) dtable->base, (u16) dtable->limit);
 207 }
 208
 209 static void print_segment(const char *name, struct kvm_segment *seg)
 210 {
 211         printf(" %s       %04hx      %016llx  %08x  %02hhx    %x %x   %x  %x %x %x %x\n",
 212                 name, (u16) seg->selector, (u64) seg->base, (u32) seg->limit,
 213                 (u8) seg->type, seg->present, seg->dpl, seg->db, seg->s, seg->l, seg->g, seg->avl);
 214 }
 215
 216 void kvm_cpu__show_registers(struct kvm_cpu *vcpu)
 217 {
 218         unsigned long cr0, cr2, cr3;
 219         unsigned long cr4, cr8;
 220         unsigned long rax, rbx, rcx;
 221         unsigned long rdx, rsi, rdi;
 222         unsigned long rbp,  r8,  r9;
 223         unsigned long r10, r11, r12;
 224         unsigned long r13, r14, r15;
 225         unsigned long rip, rsp;
 226         struct kvm_sregs sregs;
 227         unsigned long rflags;
 228         struct kvm_regs regs;
 229         int i;
 230
 231         if (ioctl(vcpu->vcpu_fd, KVM_GET_REGS, &regs) < 0)
 232                 die("KVM_GET_REGS failed");
 233
 234         rflags = regs.rflags;
 235
 236         rip = regs.rip; rsp = regs.rsp;
 237         rax = regs.rax; rbx = regs.rbx; rcx = regs.rcx;
 238         rdx = regs.rdx; rsi = regs.rsi; rdi = regs.rdi;
 239         rbp = regs.rbp; r8  = regs.r8;  r9  = regs.r9;
 240         r10 = regs.r10; r11 = regs.r11; r12 = regs.r12;
 241         r13 = regs.r13; r14 = regs.r14; r15 = regs.r15;
 242
 243         printf("\n Registers:\n");
 244         printf(  " ----------\n");
 245         printf(" rip: %016lx   rsp: %016lx flags: %016lx\n", rip, rsp, rflags);
 246         printf(" rax: %016lx   rbx: %016lx   rcx: %016lx\n", rax, rbx, rcx);
 247         printf(" rdx: %016lx   rsi: %016lx   rdi: %016lx\n", rdx, rsi, rdi);
 248         printf(" rbp: %016lx    r8: %016lx    r9: %016lx\n", rbp, r8,  r9);
 249         printf(" r10: %016lx   r11: %016lx   r12: %016lx\n", r10, r11, r12);
 250         printf(" r13: %016lx   r14: %016lx   r15: %016lx\n", r13, r14, r15);
 251
 252         if (ioctl(vcpu->vcpu_fd, KVM_GET_SREGS, &sregs) < 0)
 253                 die("KVM_GET_REGS failed");
 254
 255         cr0 = sregs.cr0; cr2 = sregs.cr2; cr3 = sregs.cr3;
 256         cr4 = sregs.cr4; cr8 = sregs.cr8;
 257
 258         printf(" cr0: %016lx   cr2: %016lx   cr3: %016lx\n", cr0, cr2, cr3);
 259         printf(" cr4: %016lx   cr8: %016lx\n", cr4, cr8);
 260         printf("\n Segment registers:\n");
 261         printf(  " ------------------\n");
 262         printf(" register  selector  base              limit     type  p dpl db s l g avl\n");
 263         print_segment("cs ", &sregs.cs);
 264         print_segment("ss ", &sregs.ss);
 265         print_segment("ds ", &sregs.ds);
 266         print_segment("es ", &sregs.es);
 267         print_segment("fs ", &sregs.fs);
 268         print_segment("gs ", &sregs.gs);
 269         print_segment("tr ", &sregs.tr);
 270         print_segment("ldt", &sregs.ldt);
 271         print_dtable("gdt", &sregs.gdt);
 272         print_dtable("idt", &sregs.idt);
 273
 274         printf("\n APIC:\n");
 275         printf(  " -----\n");
 276         printf(" efer: %016llx  apic base: %016llx  nmi: %s\n",
 277                 (u64) sregs.efer, (u64) sregs.apic_base,
 278                 (vcpu->kvm->nmi_disabled ? "disabled" : "enabled"));
 279
 280         printf("\n Interrupt bitmap:\n");
 281         printf(  " -----------------\n");
 282         for (i = 0; i < (KVM_NR_INTERRUPTS + 63) / 64; i++)
 283                 printf(" %016llx", (u64) sregs.interrupt_bitmap[i]);
 284         printf("\n");
 285 }
 286
 287 #define MAX_SYM_LEN             128
 288
 289 void kvm_cpu__show_code(struct kvm_cpu *vcpu)
 290 {
 291         unsigned int code_bytes = 64;
 292         unsigned int code_prologue = code_bytes * 43 / 64;
 293         unsigned int code_len = code_bytes;
 294         char sym[MAX_SYM_LEN];
 295         unsigned char c;
 296         unsigned int i;
 297         u8 *ip;
 298
 299         if (ioctl(vcpu->vcpu_fd, KVM_GET_REGS, &vcpu->regs) < 0)
 300                 die("KVM_GET_REGS failed");
 301
 302         if (ioctl(vcpu->vcpu_fd, KVM_GET_SREGS, &vcpu->sregs) < 0)
 303                 die("KVM_GET_SREGS failed");
 304
 305         ip = guest_flat_to_host(vcpu->kvm, ip_to_flat(vcpu, vcpu->regs.rip) - code_prologue);
 306
 307         printf("\n Code:\n");
 308         printf(  " -----\n");
 309
 310         symbol__lookup(vcpu->kvm, vcpu->regs.rip, sym, MAX_SYM_LEN);
 311
 312         printf(" rip: [<%016lx>] %s\n\n", (unsigned long) vcpu->regs.rip, sym);
 313
 314         for (i = 0; i < code_len; i++, ip++) {
 315                 if (!host_ptr_in_ram(vcpu->kvm, ip))
 316                         break;
 317
 318                 c = *ip;
 319
 320                 if (ip == guest_flat_to_host(vcpu->kvm, ip_to_flat(vcpu, vcpu->regs.rip)))
 321                         printf(" <%02x>", c);
 322                 else
 323                         printf(" %02x", c);
 324         }
 325
 326         printf("\n");
 327
 328         printf("\n Stack:\n");
 329         printf(  " ------\n");
 330         kvm__dump_mem(vcpu->kvm, vcpu->regs.rsp, 32);
 331 }
 332
 333 void kvm_cpu__show_page_tables(struct kvm_cpu *vcpu)
 334 {
 335         u64 *pte1;
 336         u64 *pte2;
 337         u64 *pte3;
 338         u64 *pte4;
 339
 340         if (!is_in_protected_mode(vcpu))
 341                 return;
 342
 343         if (ioctl(vcpu->vcpu_fd, KVM_GET_SREGS, &vcpu->sregs) < 0)
 344                 die("KVM_GET_SREGS failed");
 345
 346         pte4    = guest_flat_to_host(vcpu->kvm, vcpu->sregs.cr3);
 347         if (!host_ptr_in_ram(vcpu->kvm, pte4))
 348                 return;
 349
 350         pte3    = guest_flat_to_host(vcpu->kvm, (*pte4 & ~0xfff));
 351         if (!host_ptr_in_ram(vcpu->kvm, pte3))
 352                 return;
 353
 354         pte2    = guest_flat_to_host(vcpu->kvm, (*pte3 & ~0xfff));
 355         if (!host_ptr_in_ram(vcpu->kvm, pte2))
 356                 return;
 357
 358         pte1    = guest_flat_to_host(vcpu->kvm, (*pte2 & ~0xfff));
 359         if (!host_ptr_in_ram(vcpu->kvm, pte1))
 360                 return;
 361
 362         printf("Page Tables:\n");
 363         if (*pte2 & (1 << 7))
 364                 printf(" pte4: %016llx   pte3: %016llx"
 365                         "   pte2: %016llx\n",
 366                         *pte4, *pte3, *pte2);
 367         else
 368                 printf(" pte4: %016llx  pte3: %016llx   pte2: %016"
 369                         "llx   pte1: %016llx\n",
 370                         *pte4, *pte3, *pte2, *pte1);
 371 }
 372
 373 void kvm_cpu__run(struct kvm_cpu *vcpu)
 374 {
 375         int err;
 376
 377         err = ioctl(vcpu->vcpu_fd, KVM_RUN, 0);
 378         if (err && (errno != EINTR && errno != EAGAIN))
 379                 die_perror("KVM_RUN failed");
 380 }
 381
 382 int kvm_cpu__start(struct kvm_cpu *cpu)
 383 {
 384         sigset_t sigset;
 385
 386         sigemptyset(&sigset);
 387         sigaddset(&sigset, SIGALRM);
 388
 389         pthread_sigmask(SIG_BLOCK, &sigset, NULL);
 390
 391         kvm_cpu__setup_cpuid(cpu);
 392         kvm_cpu__reset_vcpu(cpu);
 393
 394         for (;;) {
 395                 kvm_cpu__run(cpu);
 396
 397                 switch (cpu->kvm_run->exit_reason) {
 398                 case KVM_EXIT_UNKNOWN:
 399                         break;
 400                 case KVM_EXIT_DEBUG:
 401                         kvm_cpu__show_registers(cpu);
 402                         kvm_cpu__show_code(cpu);
 403                         break;
 404                 case KVM_EXIT_IO: {
 405                         bool ret;
 406
 407                         ret = kvm__emulate_io(cpu->kvm,
 408                                         cpu->kvm_run->io.port,
 409                                         (u8 *)cpu->kvm_run +
 410                                         cpu->kvm_run->io.data_offset,
 411                                         cpu->kvm_run->io.direction,
 412                                         cpu->kvm_run->io.size,
 413                                         cpu->kvm_run->io.count);
 414
 415                         if (!ret)
 416                                 goto panic_kvm;
 417                         break;
 418                 }
 419                 case KVM_EXIT_MMIO: {
 420                         bool ret;
 421
 422                         ret = kvm__emulate_mmio(cpu->kvm,
 423                                         cpu->kvm_run->mmio.phys_addr,
 424                                         cpu->kvm_run->mmio.data,
 425                                         cpu->kvm_run->mmio.len,
 426                                         cpu->kvm_run->mmio.is_write);
 427
 428                         if (!ret)
 429                                 goto panic_kvm;
 430                         break;
 431                 }
 432                 case KVM_EXIT_INTR:
 433                         break;
 434                 case KVM_EXIT_SHUTDOWN:
 435                         goto exit_kvm;
 436                 default:
 437                         goto panic_kvm;
 438                 }
 439         }
 440
 441 exit_kvm:
 442         return 0;
 443
 444 panic_kvm:
 445         return 1;
 446 }