palacios/src/palacios/svm.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
  11  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Jack Lange <jarusl@cs.northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20
  21 #include <palacios/svm.h>
  22 #include <palacios/vmm.h>
  23
  24 #include <palacios/vmcb.h>
  25 #include <palacios/vmm_mem.h>
  26 #include <palacios/vmm_paging.h>
  27 #include <palacios/svm_handler.h>
  28
  29 #include <palacios/vmm_debug.h>
  30 #include <palacios/vm_guest_mem.h>
  31
  32 #include <palacios/vmm_decoder.h>
  33 #include <palacios/vmm_string.h>
  34 #include <palacios/vmm_lowlevel.h>
  35 #include <palacios/svm_msr.h>
  36
  37 #include <palacios/vmm_rbtree.h>
  38 #include <palacios/vmm_barrier.h>
  39
  40 #ifdef V3_CONFIG_CHECKPOINT
  41 #include <palacios/vmm_checkpoint.h>
  42 #endif
  43
  44 #include <palacios/vmm_direct_paging.h>
  45
  46 #include <palacios/vmm_ctrl_regs.h>
  47 #include <palacios/svm_io.h>
  48
  49 #include <palacios/vmm_sprintf.h>
  50
  51
  52 #ifndef V3_CONFIG_DEBUG_SVM
  53 #undef PrintDebug
  54 #define PrintDebug(fmt, args...)
  55 #endif
  56
  57
  58 uint32_t v3_last_exit;
  59
  60 // This is a global pointer to the host's VMCB
  61 static addr_t host_vmcbs[V3_CONFIG_MAX_CPUS] = { [0 ... V3_CONFIG_MAX_CPUS - 1] = 0};
  62
  63
  64
  65 extern void v3_stgi();
  66 extern void v3_clgi();
  67 //extern int v3_svm_launch(vmcb_t * vmcb, struct v3_gprs * vm_regs, uint64_t * fs, uint64_t * gs);
  68 extern int v3_svm_launch(vmcb_t * vmcb, struct v3_gprs * vm_regs, vmcb_t * host_vmcb);
  69
  70
  71 static vmcb_t * Allocate_VMCB() {
  72     vmcb_t * vmcb_page = NULL;
  73     addr_t vmcb_pa = (addr_t)V3_AllocPages(1);
  74
  75     if ((void *)vmcb_pa == NULL) {
  76         PrintError("Error allocating VMCB\n");
  77         return NULL;
  78     }
  79
  80     vmcb_page = (vmcb_t *)V3_VAddr((void *)vmcb_pa);
  81
  82     memset(vmcb_page, 0, 4096);
  83
  84     return vmcb_page;
  85 }
  86
  87
  88 static int v3_svm_handle_efer_write(struct guest_info * core, uint_t msr, struct v3_msr src, void * priv_data)
  89 {
  90     int status;
  91
  92     // Call arch-independent handler
  93     if ((status = v3_handle_efer_write(core, msr, src, priv_data)) != 0) {
  94         return status;
  95     }
  96
  97     // SVM-specific code
  98     {
  99         // Ensure that hardware visible EFER.SVME bit is set (SVM Enable)
 100         struct efer_64 * hw_efer = (struct efer_64 *)&(core->ctrl_regs.efer);
 101         hw_efer->svme = 1;
 102     }
 103
 104     return 0;
 105 }
 106
 107
 108 static void Init_VMCB_BIOS(vmcb_t * vmcb, struct guest_info * core) {
 109     vmcb_ctrl_t * ctrl_area = GET_VMCB_CTRL_AREA(vmcb);
 110     vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA(vmcb);
 111     uint_t i;
 112
 113
 114     //
 115     ctrl_area->svm_instrs.VMRUN = 1;
 116     ctrl_area->svm_instrs.VMMCALL = 1;
 117     ctrl_area->svm_instrs.VMLOAD = 1;
 118     ctrl_area->svm_instrs.VMSAVE = 1;
 119     ctrl_area->svm_instrs.STGI = 1;
 120     ctrl_area->svm_instrs.CLGI = 1;
 121     ctrl_area->svm_instrs.SKINIT = 1;
 122     ctrl_area->svm_instrs.ICEBP = 1;
 123     ctrl_area->svm_instrs.WBINVD = 1;
 124     ctrl_area->svm_instrs.MONITOR = 1;
 125     ctrl_area->svm_instrs.MWAIT_always = 1;
 126     ctrl_area->svm_instrs.MWAIT_if_armed = 1;
 127     ctrl_area->instrs.INVLPGA = 1;
 128     ctrl_area->instrs.CPUID = 1;
 129
 130     ctrl_area->instrs.HLT = 1;
 131
 132     /* Set at VMM launch as needed */
 133     ctrl_area->instrs.RDTSC = 0;
 134     ctrl_area->svm_instrs.RDTSCP = 0;
 135
 136     // guest_state->cr0 = 0x00000001;    // PE
 137
 138     /*
 139       ctrl_area->exceptions.de = 1;
 140       ctrl_area->exceptions.df = 1;
 141
 142       ctrl_area->exceptions.ts = 1;
 143       ctrl_area->exceptions.ss = 1;
 144       ctrl_area->exceptions.ac = 1;
 145       ctrl_area->exceptions.mc = 1;
 146       ctrl_area->exceptions.gp = 1;
 147       ctrl_area->exceptions.ud = 1;
 148       ctrl_area->exceptions.np = 1;
 149       ctrl_area->exceptions.of = 1;
 150
 151       ctrl_area->exceptions.nmi = 1;
 152     */
 153
 154
 155     ctrl_area->instrs.NMI = 1;
 156     ctrl_area->instrs.SMI = 0; // allow SMIs to run in guest
 157     ctrl_area->instrs.INIT = 1;
 158     ctrl_area->instrs.PAUSE = 1;
 159     ctrl_area->instrs.shutdown_evts = 1;
 160
 161
 162     /* DEBUG FOR RETURN CODE */
 163     ctrl_area->exit_code = 1;
 164
 165
 166     /* Setup Guest Machine state */
 167
 168     core->vm_regs.rsp = 0x00;
 169     core->rip = 0xfff0;
 170
 171     core->vm_regs.rdx = 0x00000f00;
 172
 173
 174     core->cpl = 0;
 175
 176     core->ctrl_regs.rflags = 0x00000002; // The reserved bit is always 1
 177     core->ctrl_regs.cr0 = 0x60010010; // Set the WP flag so the memory hooks work in real-mode
 178     core->ctrl_regs.efer |= EFER_MSR_svm_enable;
 179
 180
 181
 182
 183
 184     core->segments.cs.selector = 0xf000;
 185     core->segments.cs.limit = 0xffff;
 186     core->segments.cs.base = 0x0000000f0000LL;
 187
 188     // (raw attributes = 0xf3)
 189     core->segments.cs.type = 0x3;
 190     core->segments.cs.system = 0x1;
 191     core->segments.cs.dpl = 0x3;
 192     core->segments.cs.present = 1;
 193
 194
 195
 196     struct v3_segment * segregs [] = {&(core->segments.ss), &(core->segments.ds),
 197                                       &(core->segments.es), &(core->segments.fs),
 198                                       &(core->segments.gs), NULL};
 199
 200     for ( i = 0; segregs[i] != NULL; i++) {
 201         struct v3_segment * seg = segregs[i];
 202
 203         seg->selector = 0x0000;
 204         //    seg->base = seg->selector << 4;
 205         seg->base = 0x00000000;
 206         seg->limit = ~0u;
 207
 208         // (raw attributes = 0xf3)
 209         seg->type = 0x3;
 210         seg->system = 0x1;
 211         seg->dpl = 0x3;
 212         seg->present = 1;
 213     }
 214
 215     core->segments.gdtr.limit = 0x0000ffff;
 216     core->segments.gdtr.base = 0x0000000000000000LL;
 217     core->segments.idtr.limit = 0x0000ffff;
 218     core->segments.idtr.base = 0x0000000000000000LL;
 219
 220     core->segments.ldtr.selector = 0x0000;
 221     core->segments.ldtr.limit = 0x0000ffff;
 222     core->segments.ldtr.base = 0x0000000000000000LL;
 223     core->segments.tr.selector = 0x0000;
 224     core->segments.tr.limit = 0x0000ffff;
 225     core->segments.tr.base = 0x0000000000000000LL;
 226
 227
 228     core->dbg_regs.dr6 = 0x00000000ffff0ff0LL;
 229     core->dbg_regs.dr7 = 0x0000000000000400LL;
 230
 231
 232     ctrl_area->IOPM_BASE_PA = (addr_t)V3_PAddr(core->vm_info->io_map.arch_data);
 233     ctrl_area->instrs.IOIO_PROT = 1;
 234
 235     ctrl_area->MSRPM_BASE_PA = (addr_t)V3_PAddr(core->vm_info->msr_map.arch_data);
 236     ctrl_area->instrs.MSR_PROT = 1;
 237
 238
 239     PrintDebug("Exiting on interrupts\n");
 240     ctrl_area->guest_ctrl.V_INTR_MASKING = 1;
 241     ctrl_area->instrs.INTR = 1;
 242
 243
 244     v3_hook_msr(core->vm_info, EFER_MSR,
 245                 &v3_handle_efer_read,
 246                 &v3_svm_handle_efer_write,
 247                 core);
 248
 249     if (core->shdw_pg_mode == SHADOW_PAGING) {
 250         PrintDebug("Creating initial shadow page table\n");
 251
 252         /* JRL: This is a performance killer, and a simplistic solution */
 253         /* We need to fix this */
 254         ctrl_area->TLB_CONTROL = 1;
 255         ctrl_area->guest_ASID = 1;
 256
 257
 258         if (v3_init_passthrough_pts(core) == -1) {
 259             PrintError("Could not initialize passthrough page tables\n");
 260             return ;
 261         }
 262
 263
 264         core->shdw_pg_state.guest_cr0 = 0x0000000000000010LL;
 265         PrintDebug("Created\n");
 266
 267         core->ctrl_regs.cr0 |= 0x80000000;
 268         core->ctrl_regs.cr3 = core->direct_map_pt;
 269
 270         ctrl_area->cr_reads.cr0 = 1;
 271         ctrl_area->cr_writes.cr0 = 1;
 272         //ctrl_area->cr_reads.cr4 = 1;
 273         ctrl_area->cr_writes.cr4 = 1;
 274         ctrl_area->cr_reads.cr3 = 1;
 275         ctrl_area->cr_writes.cr3 = 1;
 276
 277
 278
 279         ctrl_area->instrs.INVLPG = 1;
 280
 281         ctrl_area->exceptions.pf = 1;
 282
 283         guest_state->g_pat = 0x7040600070406ULL;
 284
 285
 286
 287     } else if (core->shdw_pg_mode == NESTED_PAGING) {
 288         // Flush the TLB on entries/exits
 289         ctrl_area->TLB_CONTROL = 1;
 290         ctrl_area->guest_ASID = 1;
 291
 292         // Enable Nested Paging
 293         ctrl_area->NP_ENABLE = 1;
 294
 295         PrintDebug("NP_Enable at 0x%p\n", (void *)&(ctrl_area->NP_ENABLE));
 296
 297         // Set the Nested Page Table pointer
 298         if (v3_init_passthrough_pts(core) == -1) {
 299             PrintError("Could not initialize Nested page tables\n");
 300             return ;
 301         }
 302
 303         ctrl_area->N_CR3 = core->direct_map_pt;
 304
 305         guest_state->g_pat = 0x7040600070406ULL;
 306     }
 307
 308     /* tell the guest that we don't support SVM */
 309     v3_hook_msr(core->vm_info, SVM_VM_CR_MSR,
 310         &v3_handle_vm_cr_read,
 311         &v3_handle_vm_cr_write,
 312         core);
 313
 314
 315     {
 316 #define INT_PENDING_AMD_MSR             0xc0010055
 317
 318         v3_hook_msr(core->vm_info, IA32_STAR_MSR, NULL, NULL, NULL);
 319         v3_hook_msr(core->vm_info, IA32_LSTAR_MSR, NULL, NULL, NULL);
 320         v3_hook_msr(core->vm_info, IA32_FMASK_MSR, NULL, NULL, NULL);
 321         v3_hook_msr(core->vm_info, IA32_KERN_GS_BASE_MSR, NULL, NULL, NULL);
 322         v3_hook_msr(core->vm_info, IA32_CSTAR_MSR, NULL, NULL, NULL);
 323
 324         v3_hook_msr(core->vm_info, SYSENTER_CS_MSR, NULL, NULL, NULL);
 325         v3_hook_msr(core->vm_info, SYSENTER_ESP_MSR, NULL, NULL, NULL);
 326         v3_hook_msr(core->vm_info, SYSENTER_EIP_MSR, NULL, NULL, NULL);
 327
 328
 329         v3_hook_msr(core->vm_info, FS_BASE_MSR, NULL, NULL, NULL);
 330         v3_hook_msr(core->vm_info, GS_BASE_MSR, NULL, NULL, NULL);
 331
 332         // Passthrough read operations are ok.
 333         v3_hook_msr(core->vm_info, INT_PENDING_AMD_MSR, NULL, v3_msr_unhandled_write, NULL);
 334     }
 335 }
 336
 337
 338 int v3_init_svm_vmcb(struct guest_info * core, v3_vm_class_t vm_class) {
 339
 340     PrintDebug("Allocating VMCB\n");
 341     core->vmm_data = (void *)Allocate_VMCB();
 342
 343     if (core->vmm_data == NULL) {
 344         PrintError("Could not allocate VMCB, Exiting...\n");
 345         return -1;
 346     }
 347
 348     if (vm_class == V3_PC_VM) {
 349         PrintDebug("Initializing VMCB (addr=%p)\n", (void *)core->vmm_data);
 350         Init_VMCB_BIOS((vmcb_t*)(core->vmm_data), core);
 351     } else {
 352         PrintError("Invalid VM class\n");
 353         return -1;
 354     }
 355
 356     return 0;
 357 }
 358
 359
 360 int v3_deinit_svm_vmcb(struct guest_info * core) {
 361     V3_FreePages(V3_PAddr(core->vmm_data), 1);
 362     return 0;
 363 }
 364
 365
 366 #ifdef V3_CONFIG_CHECKPOINT
 367 int v3_svm_save_core(struct guest_info * core, void * ctx){
 368
 369     v3_chkpt_save_8(ctx, "cpl", &(core->cpl));
 370     v3_chkpt_save(ctx, "vmcb_data", PAGE_SIZE, core->vmm_data);
 371
 372     return 0;
 373 }
 374
 375 int v3_svm_load_core(struct guest_info * core, void * ctx){
 376
 377     v3_chkpt_load_8(ctx, "cpl", &(core->cpl));
 378
 379     if (v3_chkpt_load(ctx, "vmcb_data", PAGE_SIZE, core->vmm_data) == -1) {
 380         return -1;
 381     }
 382
 383     return 0;
 384 }
 385 #endif
 386
 387 static int update_irq_exit_state(struct guest_info * info) {
 388     vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 389
 390     // Fix for QEMU bug using EVENTINJ as an internal cache
 391     guest_ctrl->EVENTINJ.valid = 0;
 392
 393     if ((info->intr_core_state.irq_pending == 1) && (guest_ctrl->guest_ctrl.V_IRQ == 0)) {
 394
 395 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 396         PrintDebug("INTAK cycle completed for irq %d\n", info->intr_core_state.irq_vector);
 397 #endif
 398
 399         info->intr_core_state.irq_started = 1;
 400         info->intr_core_state.irq_pending = 0;
 401
 402         v3_injecting_intr(info, info->intr_core_state.irq_vector, V3_EXTERNAL_IRQ);
 403     }
 404
 405     if ((info->intr_core_state.irq_started == 1) && (guest_ctrl->exit_int_info.valid == 0)) {
 406 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 407         PrintDebug("Interrupt %d taken by guest\n", info->intr_core_state.irq_vector);
 408 #endif
 409
 410         // Interrupt was taken fully vectored
 411         info->intr_core_state.irq_started = 0;
 412
 413     } else if ((info->intr_core_state.irq_started == 1) && (guest_ctrl->exit_int_info.valid == 1)) {
 414 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 415         PrintDebug("EXIT INT INFO is set (vec=%d)\n", guest_ctrl->exit_int_info.vector);
 416 #endif
 417     }
 418
 419     return 0;
 420 }
 421
 422
 423 static int update_irq_entry_state(struct guest_info * info) {
 424     vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 425
 426
 427     if (info->intr_core_state.irq_pending == 0) {
 428         guest_ctrl->guest_ctrl.V_IRQ = 0;
 429         guest_ctrl->guest_ctrl.V_INTR_VECTOR = 0;
 430     }
 431
 432     if (v3_excp_pending(info)) {
 433         uint_t excp = v3_get_excp_number(info);
 434
 435         guest_ctrl->EVENTINJ.type = SVM_INJECTION_EXCEPTION;
 436
 437         if (info->excp_state.excp_error_code_valid) {
 438             guest_ctrl->EVENTINJ.error_code = info->excp_state.excp_error_code;
 439             guest_ctrl->EVENTINJ.ev = 1;
 440 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 441             PrintDebug("Injecting exception %d with error code %x\n", excp, guest_ctrl->EVENTINJ.error_code);
 442 #endif
 443         }
 444
 445         guest_ctrl->EVENTINJ.vector = excp;
 446
 447         guest_ctrl->EVENTINJ.valid = 1;
 448
 449 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 450         PrintDebug("<%d> Injecting Exception %d (CR2=%p) (EIP=%p)\n",
 451                    (int)info->num_exits,
 452                    guest_ctrl->EVENTINJ.vector,
 453                    (void *)(addr_t)info->ctrl_regs.cr2,
 454                    (void *)(addr_t)info->rip);
 455 #endif
 456
 457         v3_injecting_excp(info, excp);
 458     } else if (info->intr_core_state.irq_started == 1) {
 459 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 460         PrintDebug("IRQ pending from previous injection\n");
 461 #endif
 462         guest_ctrl->guest_ctrl.V_IRQ = 1;
 463         guest_ctrl->guest_ctrl.V_INTR_VECTOR = info->intr_core_state.irq_vector;
 464         guest_ctrl->guest_ctrl.V_IGN_TPR = 1;
 465         guest_ctrl->guest_ctrl.V_INTR_PRIO = 0xf;
 466
 467     } else {
 468         switch (v3_intr_pending(info)) {
 469             case V3_EXTERNAL_IRQ: {
 470                 uint32_t irq = v3_get_intr(info);
 471
 472                 guest_ctrl->guest_ctrl.V_IRQ = 1;
 473                 guest_ctrl->guest_ctrl.V_INTR_VECTOR = irq;
 474                 guest_ctrl->guest_ctrl.V_IGN_TPR = 1;
 475                 guest_ctrl->guest_ctrl.V_INTR_PRIO = 0xf;
 476
 477 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 478                 PrintDebug("Injecting Interrupt %d (EIP=%p)\n",
 479                            guest_ctrl->guest_ctrl.V_INTR_VECTOR,
 480                            (void *)(addr_t)info->rip);
 481 #endif
 482
 483                 info->intr_core_state.irq_pending = 1;
 484                 info->intr_core_state.irq_vector = irq;
 485
 486                 break;
 487             }
 488             case V3_NMI:
 489                 guest_ctrl->EVENTINJ.type = SVM_INJECTION_NMI;
 490                 break;
 491             case V3_SOFTWARE_INTR:
 492                 guest_ctrl->EVENTINJ.type = SVM_INJECTION_SOFT_INTR;
 493
 494 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 495                 PrintDebug("Injecting software interrupt --  type: %d, vector: %d\n",
 496                            SVM_INJECTION_SOFT_INTR, info->intr_core_state.swintr_vector);
 497 #endif
 498                 guest_ctrl->EVENTINJ.vector = info->intr_core_state.swintr_vector;
 499                 guest_ctrl->EVENTINJ.valid = 1;
 500
 501                 /* reset swintr state */
 502                 info->intr_core_state.swintr_posted = 0;
 503                 info->intr_core_state.swintr_vector = 0;
 504
 505                 break;
 506             case V3_VIRTUAL_IRQ:
 507                 guest_ctrl->EVENTINJ.type = SVM_INJECTION_IRQ;
 508                 break;
 509
 510             case V3_INVALID_INTR:
 511             default:
 512                 break;
 513         }
 514
 515     }
 516
 517     return 0;
 518 }
 519
 520 int
 521 v3_svm_config_tsc_virtualization(struct guest_info * info) {
 522     vmcb_ctrl_t * ctrl_area = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 523
 524     if (info->time_state.time_flags & V3_TIME_TRAP_RDTSC) {
 525         ctrl_area->instrs.RDTSC = 1;
 526         ctrl_area->svm_instrs.RDTSCP = 1;
 527     } else {
 528         ctrl_area->instrs.RDTSC = 0;
 529         ctrl_area->svm_instrs.RDTSCP = 0;
 530         ctrl_area->TSC_OFFSET = v3_tsc_host_offset(&info->time_state);
 531     }
 532     return 0;
 533 }
 534
 535 /*
 536  * CAUTION and DANGER!!!
 537  *
 538  * The VMCB CANNOT(!!) be accessed outside of the clgi/stgi calls inside this function
 539  * When exectuing a symbiotic call, the VMCB WILL be overwritten, so any dependencies
 540  * on its contents will cause things to break. The contents at the time of the exit WILL
 541  * change before the exit handler is executed.
 542  */
 543 int v3_svm_enter(struct guest_info * info) {
 544     vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 545     vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA((vmcb_t*)(info->vmm_data));
 546     addr_t exit_code = 0, exit_info1 = 0, exit_info2 = 0;
 547     uint64_t guest_cycles = 0;
 548
 549     // Conditionally yield the CPU if the timeslice has expired
 550     v3_yield_cond(info);
 551
 552     // disable global interrupts for vm state transition
 553     v3_clgi();
 554
 555     // Update timer devices after being in the VM, with interupts
 556     // disabled, but before doing IRQ updates, so that any interrupts they
 557     //raise get seen immediately.
 558     v3_advance_time(info);
 559     v3_update_timers(info);
 560
 561     // Synchronize the guest state to the VMCB
 562     guest_state->cr0 = info->ctrl_regs.cr0;
 563     guest_state->cr2 = info->ctrl_regs.cr2;
 564     guest_state->cr3 = info->ctrl_regs.cr3;
 565     guest_state->cr4 = info->ctrl_regs.cr4;
 566     guest_state->dr6 = info->dbg_regs.dr6;
 567     guest_state->dr7 = info->dbg_regs.dr7;
 568     guest_ctrl->guest_ctrl.V_TPR = info->ctrl_regs.cr8 & 0xff;
 569     guest_state->rflags = info->ctrl_regs.rflags;
 570     guest_state->efer = info->ctrl_regs.efer;
 571
 572     guest_state->cpl = info->cpl;
 573
 574     v3_set_vmcb_segments((vmcb_t*)(info->vmm_data), &(info->segments));
 575
 576     guest_state->rax = info->vm_regs.rax;
 577     guest_state->rip = info->rip;
 578     guest_state->rsp = info->vm_regs.rsp;
 579
 580 #ifdef V3_CONFIG_SYMCALL
 581     if (info->sym_core_state.symcall_state.sym_call_active == 0) {
 582         update_irq_entry_state(info);
 583     }
 584 #else
 585     update_irq_entry_state(info);
 586 #endif
 587
 588
 589     /* ** */
 590
 591     /*
 592       PrintDebug("SVM Entry to CS=%p  rip=%p...\n",
 593       (void *)(addr_t)info->segments.cs.base,
 594       (void *)(addr_t)info->rip);
 595     */
 596
 597 #ifdef V3_CONFIG_SYMCALL
 598     if (info->sym_core_state.symcall_state.sym_call_active == 1) {
 599         if (guest_ctrl->guest_ctrl.V_IRQ == 1) {
 600             V3_Print("!!! Injecting Interrupt during Sym call !!!\n");
 601         }
 602     }
 603 #endif
 604
 605     v3_time_enter_vm(info);
 606     v3_svm_config_tsc_virtualization(info);
 607
 608     //V3_Print("Calling v3_svm_launch\n");
 609     {
 610         uint64_t entry_tsc = 0;
 611         uint64_t exit_tsc = 0;
 612
 613         rdtscll(entry_tsc);
 614
 615         v3_svm_launch((vmcb_t *)V3_PAddr(info->vmm_data), &(info->vm_regs), (vmcb_t *)host_vmcbs[V3_Get_CPU()]);
 616
 617         rdtscll(exit_tsc);
 618
 619         guest_cycles = exit_tsc - entry_tsc;
 620     }
 621
 622
 623     //V3_Print("SVM Returned: Exit Code: %x, guest_rip=%lx\n", (uint32_t)(guest_ctrl->exit_code), (unsigned long)guest_state->rip);
 624
 625     v3_last_exit = (uint32_t)(guest_ctrl->exit_code);
 626
 627     // Immediate exit from VM time bookkeeping
 628     v3_time_exit_vm(info, &guest_cycles);
 629
 630     info->num_exits++;
 631
 632     // Save Guest state from VMCB
 633     info->rip = guest_state->rip;
 634     info->vm_regs.rsp = guest_state->rsp;
 635     info->vm_regs.rax = guest_state->rax;
 636
 637     info->cpl = guest_state->cpl;
 638
 639     info->ctrl_regs.cr0 = guest_state->cr0;
 640     info->ctrl_regs.cr2 = guest_state->cr2;
 641     info->ctrl_regs.cr3 = guest_state->cr3;
 642     info->ctrl_regs.cr4 = guest_state->cr4;
 643     info->dbg_regs.dr6 = guest_state->dr6;
 644     info->dbg_regs.dr7 = guest_state->dr7;
 645     info->ctrl_regs.cr8 = guest_ctrl->guest_ctrl.V_TPR;
 646     info->ctrl_regs.rflags = guest_state->rflags;
 647     info->ctrl_regs.efer = guest_state->efer;
 648
 649     v3_get_vmcb_segments((vmcb_t*)(info->vmm_data), &(info->segments));
 650     info->cpu_mode = v3_get_vm_cpu_mode(info);
 651     info->mem_mode = v3_get_vm_mem_mode(info);
 652     /* ** */
 653
 654     // save exit info here
 655     exit_code = guest_ctrl->exit_code;
 656     exit_info1 = guest_ctrl->exit_info1;
 657     exit_info2 = guest_ctrl->exit_info2;
 658
 659 #ifdef V3_CONFIG_SYMCALL
 660     if (info->sym_core_state.symcall_state.sym_call_active == 0) {
 661         update_irq_exit_state(info);
 662     }
 663 #else
 664     update_irq_exit_state(info);
 665 #endif
 666
 667     // reenable global interrupts after vm exit
 668     v3_stgi();
 669
 670     // Conditionally yield the CPU if the timeslice has expired
 671     v3_yield_cond(info);
 672
 673     {
 674         int ret = v3_handle_svm_exit(info, exit_code, exit_info1, exit_info2);
 675
 676         if (ret != 0) {
 677             PrintError("Error in SVM exit handler (ret=%d)\n", ret);
 678             PrintError("  last Exit was %d (exit code=0x%llx)\n", v3_last_exit, (uint64_t) exit_code);
 679             return -1;
 680         }
 681     }
 682
 683     if (info->timeouts.timeout_active) {
 684         /* Check to see if any timeouts have expired */
 685         v3_handle_timeouts(info, guest_cycles);
 686     }
 687
 688
 689     return 0;
 690 }
 691
 692
 693 int v3_start_svm_guest(struct guest_info * info) {
 694     //    vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA((vmcb_t*)(info->vmm_data));
 695     //  vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 696
 697     PrintDebug("Starting SVM core %u (on logical core %u)\n", info->vcpu_id, info->pcpu_id);
 698
 699     if (info->vcpu_id == 0) {
 700         info->core_run_state = CORE_RUNNING;
 701     } else  {
 702         PrintDebug("SVM core %u (on %u): Waiting for core initialization\n", info->vcpu_id, info->pcpu_id);
 703
 704         while (info->core_run_state == CORE_STOPPED) {
 705
 706             if (info->vm_info->run_state == VM_STOPPED) {
 707                 // The VM was stopped before this core was initialized.
 708                 return 0;
 709             }
 710
 711             v3_yield(info);
 712             //PrintDebug("SVM core %u: still waiting for INIT\n", info->vcpu_id);
 713         }
 714
 715         PrintDebug("SVM core %u(on %u) initialized\n", info->vcpu_id, info->pcpu_id);
 716
 717         // We'll be paranoid about race conditions here
 718         v3_wait_at_barrier(info);
 719     }
 720
 721     PrintDebug("SVM core %u(on %u): I am starting at CS=0x%x (base=0x%p, limit=0x%x),  RIP=0x%p\n",
 722                info->vcpu_id, info->pcpu_id,
 723                info->segments.cs.selector, (void *)(info->segments.cs.base),
 724                info->segments.cs.limit, (void *)(info->rip));
 725
 726
 727
 728     PrintDebug("SVM core %u: Launching SVM VM (vmcb=%p) (on cpu %u)\n",
 729                info->vcpu_id, (void *)info->vmm_data, info->pcpu_id);
 730     //PrintDebugVMCB((vmcb_t*)(info->vmm_data));
 731
 732     v3_start_time(info);
 733
 734     while (1) {
 735
 736         if (info->vm_info->run_state == VM_STOPPED) {
 737             info->core_run_state = CORE_STOPPED;
 738             break;
 739         }
 740
 741         if (v3_svm_enter(info) == -1) {
 742             vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 743             addr_t host_addr;
 744             addr_t linear_addr = 0;
 745
 746             info->vm_info->run_state = VM_ERROR;
 747
 748             V3_Print("SVM core %u: SVM ERROR!!\n", info->vcpu_id);
 749
 750             v3_print_guest_state(info);
 751
 752             V3_Print("SVM core %u: SVM Exit Code: %p\n", info->vcpu_id, (void *)(addr_t)guest_ctrl->exit_code);
 753
 754             V3_Print("SVM core %u: exit_info1 low = 0x%.8x\n", info->vcpu_id, *(uint_t*)&(guest_ctrl->exit_info1));
 755             V3_Print("SVM core %u: exit_info1 high = 0x%.8x\n", info->vcpu_id, *(uint_t *)(((uchar_t *)&(guest_ctrl->exit_info1)) + 4));
 756
 757             V3_Print("SVM core %u: exit_info2 low = 0x%.8x\n", info->vcpu_id, *(uint_t*)&(guest_ctrl->exit_info2));
 758             V3_Print("SVM core %u: exit_info2 high = 0x%.8x\n", info->vcpu_id, *(uint_t *)(((uchar_t *)&(guest_ctrl->exit_info2)) + 4));
 759
 760             linear_addr = get_addr_linear(info, info->rip, &(info->segments.cs));
 761
 762             if (info->mem_mode == PHYSICAL_MEM) {
 763                 v3_gpa_to_hva(info, linear_addr, &host_addr);
 764             } else if (info->mem_mode == VIRTUAL_MEM) {
 765                 v3_gva_to_hva(info, linear_addr, &host_addr);
 766             }
 767
 768             V3_Print("SVM core %u: Host Address of rip = 0x%p\n", info->vcpu_id, (void *)host_addr);
 769
 770             V3_Print("SVM core %u: Instr (15 bytes) at %p:\n", info->vcpu_id, (void *)host_addr);
 771             v3_dump_mem((uint8_t *)host_addr, 15);
 772
 773             v3_print_stack(info);
 774
 775             break;
 776         }
 777
 778         v3_wait_at_barrier(info);
 779
 780
 781         if (info->vm_info->run_state == VM_STOPPED) {
 782             info->core_run_state = CORE_STOPPED;
 783             break;
 784         }
 785
 786
 787
 788 /*
 789         if ((info->num_exits % 50000) == 0) {
 790             V3_Print("SVM Exit number %d\n", (uint32_t)info->num_exits);
 791             v3_print_guest_state(info);
 792         }
 793 */
 794
 795     }
 796
 797     // Need to take down the other cores on error...
 798
 799     return 0;
 800 }
 801
 802
 803
 804
 805 int v3_reset_svm_vm_core(struct guest_info * core, addr_t rip) {
 806     // init vmcb_bios
 807
 808     // Write the RIP, CS, and descriptor
 809     // assume the rest is already good to go
 810     //
 811     // vector VV -> rip at 0
 812     //              CS = VV00
 813     //  This means we start executing at linear address VV000
 814     //
 815     // So the selector needs to be VV00
 816     // and the base needs to be VV000
 817     //
 818     core->rip = 0;
 819     core->segments.cs.selector = rip << 8;
 820     core->segments.cs.limit = 0xffff;
 821     core->segments.cs.base = rip << 12;
 822
 823     return 0;
 824 }
 825
 826
 827
 828
 829
 830
 831 /* Checks machine SVM capability */
 832 /* Implemented from: AMD Arch Manual 3, sect 15.4 */
 833 int v3_is_svm_capable() {
 834     uint_t vm_cr_low = 0, vm_cr_high = 0;
 835     uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
 836
 837     v3_cpuid(CPUID_EXT_FEATURE_IDS, &eax, &ebx, &ecx, &edx);
 838
 839     PrintDebug("CPUID_EXT_FEATURE_IDS_ecx=0x%x\n", ecx);
 840
 841     if ((ecx & CPUID_EXT_FEATURE_IDS_ecx_svm_avail) == 0) {
 842       V3_Print("SVM Not Available\n");
 843       return 0;
 844     }  else {
 845         v3_get_msr(SVM_VM_CR_MSR, &vm_cr_high, &vm_cr_low);
 846
 847         PrintDebug("SVM_VM_CR_MSR = 0x%x 0x%x\n", vm_cr_high, vm_cr_low);
 848
 849         if ((vm_cr_low & SVM_VM_CR_MSR_svmdis) == 1) {
 850             V3_Print("SVM is available but is disabled.\n");
 851
 852             v3_cpuid(CPUID_SVM_REV_AND_FEATURE_IDS, &eax, &ebx, &ecx, &edx);
 853
 854             PrintDebug("CPUID_SVM_REV_AND_FEATURE_IDS_edx=0x%x\n", edx);
 855
 856             if ((edx & CPUID_SVM_REV_AND_FEATURE_IDS_edx_svml) == 0) {
 857                 V3_Print("SVM BIOS Disabled, not unlockable\n");
 858             } else {
 859                 V3_Print("SVM is locked with a key\n");
 860             }
 861             return 0;
 862
 863         } else {
 864             V3_Print("SVM is available and  enabled.\n");
 865
 866             v3_cpuid(CPUID_SVM_REV_AND_FEATURE_IDS, &eax, &ebx, &ecx, &edx);
 867             PrintDebug("CPUID_SVM_REV_AND_FEATURE_IDS_eax=0x%x\n", eax);
 868             PrintDebug("CPUID_SVM_REV_AND_FEATURE_IDS_ebx=0x%x\n", ebx);
 869             PrintDebug("CPUID_SVM_REV_AND_FEATURE_IDS_ecx=0x%x\n", ecx);
 870             PrintDebug("CPUID_SVM_REV_AND_FEATURE_IDS_edx=0x%x\n", edx);
 871
 872             return 1;
 873         }
 874     }
 875 }
 876
 877 static int has_svm_nested_paging() {
 878     uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
 879
 880     v3_cpuid(CPUID_SVM_REV_AND_FEATURE_IDS, &eax, &ebx, &ecx, &edx);
 881
 882     //PrintDebug("CPUID_EXT_FEATURE_IDS_edx=0x%x\n", edx);
 883
 884     if ((edx & CPUID_SVM_REV_AND_FEATURE_IDS_edx_np) == 0) {
 885         V3_Print("SVM Nested Paging not supported\n");
 886         return 0;
 887     } else {
 888         V3_Print("SVM Nested Paging supported\n");
 889         return 1;
 890     }
 891  }
 892
 893
 894
 895 void v3_init_svm_cpu(int cpu_id) {
 896     reg_ex_t msr;
 897     extern v3_cpu_arch_t v3_cpu_types[];
 898
 899     // Enable SVM on the CPU
 900     v3_get_msr(EFER_MSR, &(msr.e_reg.high), &(msr.e_reg.low));
 901     msr.e_reg.low |= EFER_MSR_svm_enable;
 902     v3_set_msr(EFER_MSR, 0, msr.e_reg.low);
 903
 904     V3_Print("SVM Enabled\n");
 905
 906     // Setup the host state save area
 907     host_vmcbs[cpu_id] = (addr_t)V3_AllocPages(4);
 908
 909     /* 64-BIT-ISSUE */
 910     //  msr.e_reg.high = 0;
 911     //msr.e_reg.low = (uint_t)host_vmcb;
 912     msr.r_reg = host_vmcbs[cpu_id];
 913
 914     PrintDebug("Host State being saved at %p\n", (void *)host_vmcbs[cpu_id]);
 915     v3_set_msr(SVM_VM_HSAVE_PA_MSR, msr.e_reg.high, msr.e_reg.low);
 916
 917
 918     if (has_svm_nested_paging() == 1) {
 919         v3_cpu_types[cpu_id] = V3_SVM_REV3_CPU;
 920     } else {
 921         v3_cpu_types[cpu_id] = V3_SVM_CPU;
 922     }
 923 }
 924
 925
 926
 927 void v3_deinit_svm_cpu(int cpu_id) {
 928     reg_ex_t msr;
 929     extern v3_cpu_arch_t v3_cpu_types[];
 930
 931     // reset SVM_VM_HSAVE_PA_MSR
 932     // Does setting it to NULL disable??
 933     msr.r_reg = 0;
 934     v3_set_msr(SVM_VM_HSAVE_PA_MSR, msr.e_reg.high, msr.e_reg.low);
 935
 936     // Disable SVM?
 937     v3_get_msr(EFER_MSR, &(msr.e_reg.high), &(msr.e_reg.low));
 938     msr.e_reg.low &= ~EFER_MSR_svm_enable;
 939     v3_set_msr(EFER_MSR, 0, msr.e_reg.low);
 940
 941     v3_cpu_types[cpu_id] = V3_INVALID_CPU;
 942
 943     V3_FreePages((void *)host_vmcbs[cpu_id], 4);
 944
 945     V3_Print("Host CPU %d host area freed, and SVM disabled\n", cpu_id);
 946     return;
 947 }
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998 #if 0
 999 /*
1000  * Test VMSAVE/VMLOAD Latency
1001  */
1002 #define vmsave ".byte 0x0F,0x01,0xDB ; "
1003 #define vmload ".byte 0x0F,0x01,0xDA ; "
1004 {
1005     uint32_t start_lo, start_hi;
1006     uint32_t end_lo, end_hi;
1007     uint64_t start, end;
1008
1009     __asm__ __volatile__ (
1010                           "rdtsc ; "
1011                           "movl %%eax, %%esi ; "
1012                           "movl %%edx, %%edi ; "
1013                           "movq  %%rcx, %%rax ; "
1014                           vmsave
1015                           "rdtsc ; "
1016                           : "=D"(start_hi), "=S"(start_lo), "=a"(end_lo),"=d"(end_hi)
1017                           : "c"(host_vmcb[cpu_id]), "0"(0), "1"(0), "2"(0), "3"(0)
1018                           );
1019
1020     start = start_hi;
1021     start <<= 32;
1022     start += start_lo;
1023
1024     end = end_hi;
1025     end <<= 32;
1026     end += end_lo;
1027
1028     PrintDebug("VMSave Cycle Latency: %d\n", (uint32_t)(end - start));
1029
1030     __asm__ __volatile__ (
1031                           "rdtsc ; "
1032                           "movl %%eax, %%esi ; "
1033                           "movl %%edx, %%edi ; "
1034                           "movq  %%rcx, %%rax ; "
1035                           vmload
1036                           "rdtsc ; "
1037                           : "=D"(start_hi), "=S"(start_lo), "=a"(end_lo),"=d"(end_hi)
1038                               : "c"(host_vmcb[cpu_id]), "0"(0), "1"(0), "2"(0), "3"(0)
1039                               );
1040
1041         start = start_hi;
1042         start <<= 32;
1043         start += start_lo;
1044
1045         end = end_hi;
1046         end <<= 32;
1047         end += end_lo;
1048
1049
1050         PrintDebug("VMLoad Cycle Latency: %d\n", (uint32_t)(end - start));
1051     }
1052     /* End Latency Test */
1053
1054 #endif
1055
1056
1057
1058
1059
1060
1061
1062 #if 0
1063 void Init_VMCB_pe(vmcb_t *vmcb, struct guest_info vm_info) {
1064   vmcb_ctrl_t * ctrl_area = GET_VMCB_CTRL_AREA(vmcb);
1065   vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA(vmcb);
1066   uint_t i = 0;
1067
1068
1069   guest_state->rsp = vm_info.vm_regs.rsp;
1070   guest_state->rip = vm_info.rip;
1071
1072
1073   /* I pretty much just gutted this from TVMM */
1074   /* Note: That means its probably wrong */
1075
1076   // set the segment registers to mirror ours
1077   guest_state->cs.selector = 1<<3;
1078   guest_state->cs.attrib.fields.type = 0xa; // Code segment+read
1079   guest_state->cs.attrib.fields.S = 1;
1080   guest_state->cs.attrib.fields.P = 1;
1081   guest_state->cs.attrib.fields.db = 1;
1082   guest_state->cs.attrib.fields.G = 1;
1083   guest_state->cs.limit = 0xfffff;
1084   guest_state->cs.base = 0;
1085
1086   struct vmcb_selector *segregs [] = {&(guest_state->ss), &(guest_state->ds), &(guest_state->es), &(guest_state->fs), &(guest_state->gs), NULL};
1087   for ( i = 0; segregs[i] != NULL; i++) {
1088     struct vmcb_selector * seg = segregs[i];
1089
1090     seg->selector = 2<<3;
1091     seg->attrib.fields.type = 0x2; // Data Segment+read/write
1092     seg->attrib.fields.S = 1;
1093     seg->attrib.fields.P = 1;
1094     seg->attrib.fields.db = 1;
1095     seg->attrib.fields.G = 1;
1096     seg->limit = 0xfffff;
1097     seg->base = 0;
1098   }
1099
1100
1101   {
1102     /* JRL THIS HAS TO GO */
1103
1104     //    guest_state->tr.selector = GetTR_Selector();
1105     guest_state->tr.attrib.fields.type = 0x9;
1106     guest_state->tr.attrib.fields.P = 1;
1107     // guest_state->tr.limit = GetTR_Limit();
1108     //guest_state->tr.base = GetTR_Base();// - 0x2000;
1109     /* ** */
1110   }
1111
1112
1113   /* ** */
1114
1115
1116   guest_state->efer |= EFER_MSR_svm_enable;
1117   guest_state->rflags = 0x00000002; // The reserved bit is always 1
1118   ctrl_area->svm_instrs.VMRUN = 1;
1119   guest_state->cr0 = 0x00000001;    // PE
1120   ctrl_area->guest_ASID = 1;
1121
1122
1123   //  guest_state->cpl = 0;
1124
1125
1126
1127   // Setup exits
1128
1129   ctrl_area->cr_writes.cr4 = 1;
1130
1131   ctrl_area->exceptions.de = 1;
1132   ctrl_area->exceptions.df = 1;
1133   ctrl_area->exceptions.pf = 1;
1134   ctrl_area->exceptions.ts = 1;
1135   ctrl_area->exceptions.ss = 1;
1136   ctrl_area->exceptions.ac = 1;
1137   ctrl_area->exceptions.mc = 1;
1138   ctrl_area->exceptions.gp = 1;
1139   ctrl_area->exceptions.ud = 1;
1140   ctrl_area->exceptions.np = 1;
1141   ctrl_area->exceptions.of = 1;
1142   ctrl_area->exceptions.nmi = 1;
1143
1144
1145
1146   ctrl_area->instrs.IOIO_PROT = 1;
1147   ctrl_area->IOPM_BASE_PA = (uint_t)V3_AllocPages(3);
1148
1149   {
1150     reg_ex_t tmp_reg;
1151     tmp_reg.r_reg = ctrl_area->IOPM_BASE_PA;
1152     memset((void*)(tmp_reg.e_reg.low), 0xffffffff, PAGE_SIZE * 2);
1153   }
1154
1155   ctrl_area->instrs.INTR = 1;
1156
1157
1158   {
1159     char gdt_buf[6];
1160     char idt_buf[6];
1161
1162     memset(gdt_buf, 0, 6);
1163     memset(idt_buf, 0, 6);
1164
1165
1166     uint_t gdt_base, idt_base;
1167     ushort_t gdt_limit, idt_limit;
1168
1169     GetGDTR(gdt_buf);
1170     gdt_base = *(ulong_t*)((uchar_t*)gdt_buf + 2) & 0xffffffff;
1171     gdt_limit = *(ushort_t*)(gdt_buf) & 0xffff;
1172     PrintDebug("GDT: base: %x, limit: %x\n", gdt_base, gdt_limit);
1173
1174     GetIDTR(idt_buf);
1175     idt_base = *(ulong_t*)(idt_buf + 2) & 0xffffffff;
1176     idt_limit = *(ushort_t*)(idt_buf) & 0xffff;
1177     PrintDebug("IDT: base: %x, limit: %x\n",idt_base, idt_limit);
1178
1179
1180     // gdt_base -= 0x2000;
1181     //idt_base -= 0x2000;
1182
1183     guest_state->gdtr.base = gdt_base;
1184     guest_state->gdtr.limit = gdt_limit;
1185     guest_state->idtr.base = idt_base;
1186     guest_state->idtr.limit = idt_limit;
1187
1188
1189   }
1190
1191
1192   // also determine if CPU supports nested paging
1193   /*
1194   if (vm_info.page_tables) {
1195     //   if (0) {
1196     // Flush the TLB on entries/exits
1197     ctrl_area->TLB_CONTROL = 1;
1198
1199     // Enable Nested Paging
1200     ctrl_area->NP_ENABLE = 1;
1201
1202     PrintDebug("NP_Enable at 0x%x\n", &(ctrl_area->NP_ENABLE));
1203
1204         // Set the Nested Page Table pointer
1205     ctrl_area->N_CR3 |= ((addr_t)vm_info.page_tables & 0xfffff000);
1206
1207
1208     //   ctrl_area->N_CR3 = Get_CR3();
1209     // guest_state->cr3 |= (Get_CR3() & 0xfffff000);
1210
1211     guest_state->g_pat = 0x7040600070406ULL;
1212
1213     PrintDebug("Set Nested CR3: lo: 0x%x  hi: 0x%x\n", (uint_t)*(&(ctrl_area->N_CR3)), (uint_t)*((unsigned char *)&(ctrl_area->N_CR3) + 4));
1214     PrintDebug("Set Guest CR3: lo: 0x%x  hi: 0x%x\n", (uint_t)*(&(guest_state->cr3)), (uint_t)*((unsigned char *)&(guest_state->cr3) + 4));
1215     // Enable Paging
1216     //    guest_state->cr0 |= 0x80000000;
1217   }
1218   */
1219
1220 }
1221
1222
1223
1224
1225
1226 #endif
1227
1228