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     core->core_run_state = CORE_STOPPED;
 357
 358     return 0;
 359 }
 360
 361
 362 int v3_deinit_svm_vmcb(struct guest_info * core) {
 363     V3_FreePages(V3_PAddr(core->vmm_data), 1);
 364     return 0;
 365 }
 366
 367
 368 #ifdef V3_CONFIG_CHECKPOINT
 369 int v3_svm_save_core(struct guest_info * core, void * ctx){
 370
 371     v3_chkpt_save_8(ctx, "cpl", &(core->cpl));
 372     v3_chkpt_save(ctx, "vmcb_data", PAGE_SIZE, core->vmm_data);
 373
 374     return 0;
 375 }
 376
 377 int v3_svm_load_core(struct guest_info * core, void * ctx){
 378
 379     v3_chkpt_load_8(ctx, "cpl", &(core->cpl));
 380
 381     if (v3_chkpt_load(ctx, "vmcb_data", PAGE_SIZE, core->vmm_data) == -1) {
 382         return -1;
 383     }
 384
 385     return 0;
 386 }
 387 #endif
 388
 389 static int update_irq_exit_state(struct guest_info * info) {
 390     vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 391
 392     // Fix for QEMU bug using EVENTINJ as an internal cache
 393     guest_ctrl->EVENTINJ.valid = 0;
 394
 395     if ((info->intr_core_state.irq_pending == 1) && (guest_ctrl->guest_ctrl.V_IRQ == 0)) {
 396
 397 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 398         PrintDebug("INTAK cycle completed for irq %d\n", info->intr_core_state.irq_vector);
 399 #endif
 400
 401         info->intr_core_state.irq_started = 1;
 402         info->intr_core_state.irq_pending = 0;
 403
 404         v3_injecting_intr(info, info->intr_core_state.irq_vector, V3_EXTERNAL_IRQ);
 405     }
 406
 407     if ((info->intr_core_state.irq_started == 1) && (guest_ctrl->exit_int_info.valid == 0)) {
 408 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 409         PrintDebug("Interrupt %d taken by guest\n", info->intr_core_state.irq_vector);
 410 #endif
 411
 412         // Interrupt was taken fully vectored
 413         info->intr_core_state.irq_started = 0;
 414
 415     } else if ((info->intr_core_state.irq_started == 1) && (guest_ctrl->exit_int_info.valid == 1)) {
 416 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 417         PrintDebug("EXIT INT INFO is set (vec=%d)\n", guest_ctrl->exit_int_info.vector);
 418 #endif
 419     }
 420
 421     return 0;
 422 }
 423
 424
 425 static int update_irq_entry_state(struct guest_info * info) {
 426     vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 427
 428
 429     if (info->intr_core_state.irq_pending == 0) {
 430         guest_ctrl->guest_ctrl.V_IRQ = 0;
 431         guest_ctrl->guest_ctrl.V_INTR_VECTOR = 0;
 432     }
 433
 434     if (v3_excp_pending(info)) {
 435         uint_t excp = v3_get_excp_number(info);
 436
 437         guest_ctrl->EVENTINJ.type = SVM_INJECTION_EXCEPTION;
 438
 439         if (info->excp_state.excp_error_code_valid) {
 440             guest_ctrl->EVENTINJ.error_code = info->excp_state.excp_error_code;
 441             guest_ctrl->EVENTINJ.ev = 1;
 442 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 443             PrintDebug("Injecting exception %d with error code %x\n", excp, guest_ctrl->EVENTINJ.error_code);
 444 #endif
 445         }
 446
 447         guest_ctrl->EVENTINJ.vector = excp;
 448
 449         guest_ctrl->EVENTINJ.valid = 1;
 450
 451 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 452         PrintDebug("<%d> Injecting Exception %d (CR2=%p) (EIP=%p)\n",
 453                    (int)info->num_exits,
 454                    guest_ctrl->EVENTINJ.vector,
 455                    (void *)(addr_t)info->ctrl_regs.cr2,
 456                    (void *)(addr_t)info->rip);
 457 #endif
 458
 459         v3_injecting_excp(info, excp);
 460     } else if (info->intr_core_state.irq_started == 1) {
 461 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 462         PrintDebug("IRQ pending from previous injection\n");
 463 #endif
 464         guest_ctrl->guest_ctrl.V_IRQ = 1;
 465         guest_ctrl->guest_ctrl.V_INTR_VECTOR = info->intr_core_state.irq_vector;
 466         guest_ctrl->guest_ctrl.V_IGN_TPR = 1;
 467         guest_ctrl->guest_ctrl.V_INTR_PRIO = 0xf;
 468
 469     } else {
 470         switch (v3_intr_pending(info)) {
 471             case V3_EXTERNAL_IRQ: {
 472                 uint32_t irq = v3_get_intr(info);
 473
 474                 guest_ctrl->guest_ctrl.V_IRQ = 1;
 475                 guest_ctrl->guest_ctrl.V_INTR_VECTOR = irq;
 476                 guest_ctrl->guest_ctrl.V_IGN_TPR = 1;
 477                 guest_ctrl->guest_ctrl.V_INTR_PRIO = 0xf;
 478
 479 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 480                 PrintDebug("Injecting Interrupt %d (EIP=%p)\n",
 481                            guest_ctrl->guest_ctrl.V_INTR_VECTOR,
 482                            (void *)(addr_t)info->rip);
 483 #endif
 484
 485                 info->intr_core_state.irq_pending = 1;
 486                 info->intr_core_state.irq_vector = irq;
 487
 488                 break;
 489             }
 490             case V3_NMI:
 491                 guest_ctrl->EVENTINJ.type = SVM_INJECTION_NMI;
 492                 break;
 493             case V3_SOFTWARE_INTR:
 494                 guest_ctrl->EVENTINJ.type = SVM_INJECTION_SOFT_INTR;
 495
 496 #ifdef V3_CONFIG_DEBUG_INTERRUPTS
 497                 PrintDebug("Injecting software interrupt --  type: %d, vector: %d\n",
 498                            SVM_INJECTION_SOFT_INTR, info->intr_core_state.swintr_vector);
 499 #endif
 500                 guest_ctrl->EVENTINJ.vector = info->intr_core_state.swintr_vector;
 501                 guest_ctrl->EVENTINJ.valid = 1;
 502
 503                 /* reset swintr state */
 504                 info->intr_core_state.swintr_posted = 0;
 505                 info->intr_core_state.swintr_vector = 0;
 506
 507                 break;
 508             case V3_VIRTUAL_IRQ:
 509                 guest_ctrl->EVENTINJ.type = SVM_INJECTION_IRQ;
 510                 break;
 511
 512             case V3_INVALID_INTR:
 513             default:
 514                 break;
 515         }
 516
 517     }
 518
 519     return 0;
 520 }
 521
 522 int
 523 v3_svm_config_tsc_virtualization(struct guest_info * info) {
 524     vmcb_ctrl_t * ctrl_area = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 525
 526     if (info->time_state.time_flags & V3_TIME_TRAP_RDTSC) {
 527         ctrl_area->instrs.RDTSC = 1;
 528         ctrl_area->svm_instrs.RDTSCP = 1;
 529     } else {
 530         ctrl_area->instrs.RDTSC = 0;
 531         ctrl_area->svm_instrs.RDTSCP = 0;
 532         ctrl_area->TSC_OFFSET = v3_tsc_host_offset(&info->time_state);
 533     }
 534     return 0;
 535 }
 536
 537 /*
 538  * CAUTION and DANGER!!!
 539  *
 540  * The VMCB CANNOT(!!) be accessed outside of the clgi/stgi calls inside this function
 541  * When exectuing a symbiotic call, the VMCB WILL be overwritten, so any dependencies
 542  * on its contents will cause things to break. The contents at the time of the exit WILL
 543  * change before the exit handler is executed.
 544  */
 545 int v3_svm_enter(struct guest_info * info) {
 546     vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 547     vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA((vmcb_t*)(info->vmm_data));
 548     addr_t exit_code = 0, exit_info1 = 0, exit_info2 = 0;
 549     uint64_t guest_cycles = 0;
 550
 551     // Conditionally yield the CPU if the timeslice has expired
 552     v3_yield_cond(info);
 553
 554     // disable global interrupts for vm state transition
 555     v3_clgi();
 556
 557     // Update timer devices after being in the VM, with interupts
 558     // disabled, but before doing IRQ updates, so that any interrupts they
 559     //raise get seen immediately.
 560     v3_advance_time(info);
 561     v3_update_timers(info);
 562
 563     // Synchronize the guest state to the VMCB
 564     guest_state->cr0 = info->ctrl_regs.cr0;
 565     guest_state->cr2 = info->ctrl_regs.cr2;
 566     guest_state->cr3 = info->ctrl_regs.cr3;
 567     guest_state->cr4 = info->ctrl_regs.cr4;
 568     guest_state->dr6 = info->dbg_regs.dr6;
 569     guest_state->dr7 = info->dbg_regs.dr7;
 570     guest_ctrl->guest_ctrl.V_TPR = info->ctrl_regs.cr8 & 0xff;
 571     guest_state->rflags = info->ctrl_regs.rflags;
 572     guest_state->efer = info->ctrl_regs.efer;
 573
 574     /* Synchronize MSRs */
 575     guest_state->star = info->msrs.star;
 576     guest_state->lstar = info->msrs.lstar;
 577     guest_state->sfmask = info->msrs.sfmask;
 578     guest_state->KernelGsBase = info->msrs.kern_gs_base;
 579
 580     guest_state->cpl = info->cpl;
 581
 582     v3_set_vmcb_segments((vmcb_t*)(info->vmm_data), &(info->segments));
 583
 584     guest_state->rax = info->vm_regs.rax;
 585     guest_state->rip = info->rip;
 586     guest_state->rsp = info->vm_regs.rsp;
 587
 588 #ifdef V3_CONFIG_SYMCALL
 589     if (info->sym_core_state.symcall_state.sym_call_active == 0) {
 590         update_irq_entry_state(info);
 591     }
 592 #else
 593     update_irq_entry_state(info);
 594 #endif
 595
 596
 597     /* ** */
 598
 599     /*
 600       PrintDebug("SVM Entry to CS=%p  rip=%p...\n",
 601       (void *)(addr_t)info->segments.cs.base,
 602       (void *)(addr_t)info->rip);
 603     */
 604
 605 #ifdef V3_CONFIG_SYMCALL
 606     if (info->sym_core_state.symcall_state.sym_call_active == 1) {
 607         if (guest_ctrl->guest_ctrl.V_IRQ == 1) {
 608             V3_Print("!!! Injecting Interrupt during Sym call !!!\n");
 609         }
 610     }
 611 #endif
 612
 613     v3_time_enter_vm(info);
 614     v3_svm_config_tsc_virtualization(info);
 615
 616     //V3_Print("Calling v3_svm_launch\n");
 617     {
 618         uint64_t entry_tsc = 0;
 619         uint64_t exit_tsc = 0;
 620
 621         rdtscll(entry_tsc);
 622
 623         v3_svm_launch((vmcb_t *)V3_PAddr(info->vmm_data), &(info->vm_regs), (vmcb_t *)host_vmcbs[V3_Get_CPU()]);
 624
 625         rdtscll(exit_tsc);
 626
 627         guest_cycles = exit_tsc - entry_tsc;
 628     }
 629
 630
 631     //V3_Print("SVM Returned: Exit Code: %x, guest_rip=%lx\n", (uint32_t)(guest_ctrl->exit_code), (unsigned long)guest_state->rip);
 632
 633     v3_last_exit = (uint32_t)(guest_ctrl->exit_code);
 634
 635     // Immediate exit from VM time bookkeeping
 636     v3_time_exit_vm(info, &guest_cycles);
 637
 638     info->num_exits++;
 639
 640     // Save Guest state from VMCB
 641     info->rip = guest_state->rip;
 642     info->vm_regs.rsp = guest_state->rsp;
 643     info->vm_regs.rax = guest_state->rax;
 644
 645     info->cpl = guest_state->cpl;
 646
 647     info->ctrl_regs.cr0 = guest_state->cr0;
 648     info->ctrl_regs.cr2 = guest_state->cr2;
 649     info->ctrl_regs.cr3 = guest_state->cr3;
 650     info->ctrl_regs.cr4 = guest_state->cr4;
 651     info->dbg_regs.dr6 = guest_state->dr6;
 652     info->dbg_regs.dr7 = guest_state->dr7;
 653     info->ctrl_regs.cr8 = guest_ctrl->guest_ctrl.V_TPR;
 654     info->ctrl_regs.rflags = guest_state->rflags;
 655     info->ctrl_regs.efer = guest_state->efer;
 656
 657     /* Synchronize MSRs */
 658     info->msrs.star =  guest_state->star;
 659     info->msrs.lstar = guest_state->lstar;
 660     info->msrs.sfmask = guest_state->sfmask;
 661     info->msrs.kern_gs_base = guest_state->KernelGsBase;
 662
 663     v3_get_vmcb_segments((vmcb_t*)(info->vmm_data), &(info->segments));
 664     info->cpu_mode = v3_get_vm_cpu_mode(info);
 665     info->mem_mode = v3_get_vm_mem_mode(info);
 666     /* ** */
 667
 668     // save exit info here
 669     exit_code = guest_ctrl->exit_code;
 670     exit_info1 = guest_ctrl->exit_info1;
 671     exit_info2 = guest_ctrl->exit_info2;
 672
 673 #ifdef V3_CONFIG_SYMCALL
 674     if (info->sym_core_state.symcall_state.sym_call_active == 0) {
 675         update_irq_exit_state(info);
 676     }
 677 #else
 678     update_irq_exit_state(info);
 679 #endif
 680
 681     // reenable global interrupts after vm exit
 682     v3_stgi();
 683
 684     // Conditionally yield the CPU if the timeslice has expired
 685     v3_yield_cond(info);
 686
 687     {
 688         int ret = v3_handle_svm_exit(info, exit_code, exit_info1, exit_info2);
 689
 690         if (ret != 0) {
 691             PrintError("Error in SVM exit handler (ret=%d)\n", ret);
 692             PrintError("  last Exit was %d (exit code=0x%llx)\n", v3_last_exit, (uint64_t) exit_code);
 693             return -1;
 694         }
 695     }
 696
 697     if (info->timeouts.timeout_active) {
 698         /* Check to see if any timeouts have expired */
 699         v3_handle_timeouts(info, guest_cycles);
 700     }
 701
 702
 703     return 0;
 704 }
 705
 706
 707 int v3_start_svm_guest(struct guest_info * info) {
 708     //    vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA((vmcb_t*)(info->vmm_data));
 709     //  vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 710
 711     PrintDebug("Starting SVM core %u (on logical core %u)\n", info->vcpu_id, info->pcpu_id);
 712
 713     if (info->vcpu_id == 0) {
 714         info->core_run_state = CORE_RUNNING;
 715     } else  {
 716         PrintDebug("SVM core %u (on %u): Waiting for core initialization\n", info->vcpu_id, info->pcpu_id);
 717
 718         while (info->core_run_state == CORE_STOPPED) {
 719
 720             if (info->vm_info->run_state == VM_STOPPED) {
 721                 // The VM was stopped before this core was initialized.
 722                 return 0;
 723             }
 724
 725             v3_yield(info);
 726             //PrintDebug("SVM core %u: still waiting for INIT\n", info->vcpu_id);
 727         }
 728
 729         PrintDebug("SVM core %u(on %u) initialized\n", info->vcpu_id, info->pcpu_id);
 730
 731         // We'll be paranoid about race conditions here
 732         v3_wait_at_barrier(info);
 733     }
 734
 735     PrintDebug("SVM core %u(on %u): I am starting at CS=0x%x (base=0x%p, limit=0x%x),  RIP=0x%p\n",
 736                info->vcpu_id, info->pcpu_id,
 737                info->segments.cs.selector, (void *)(info->segments.cs.base),
 738                info->segments.cs.limit, (void *)(info->rip));
 739
 740
 741
 742     PrintDebug("SVM core %u: Launching SVM VM (vmcb=%p) (on cpu %u)\n",
 743                info->vcpu_id, (void *)info->vmm_data, info->pcpu_id);
 744     //PrintDebugVMCB((vmcb_t*)(info->vmm_data));
 745
 746     v3_start_time(info);
 747
 748     while (1) {
 749
 750         if (info->vm_info->run_state == VM_STOPPED) {
 751             info->core_run_state = CORE_STOPPED;
 752             break;
 753         }
 754
 755         if (v3_svm_enter(info) == -1) {
 756             vmcb_ctrl_t * guest_ctrl = GET_VMCB_CTRL_AREA((vmcb_t*)(info->vmm_data));
 757             addr_t host_addr;
 758             addr_t linear_addr = 0;
 759
 760             info->vm_info->run_state = VM_ERROR;
 761
 762             V3_Print("SVM core %u: SVM ERROR!!\n", info->vcpu_id);
 763
 764             v3_print_guest_state(info);
 765
 766             V3_Print("SVM core %u: SVM Exit Code: %p\n", info->vcpu_id, (void *)(addr_t)guest_ctrl->exit_code);
 767
 768             V3_Print("SVM core %u: exit_info1 low = 0x%.8x\n", info->vcpu_id, *(uint_t*)&(guest_ctrl->exit_info1));
 769             V3_Print("SVM core %u: exit_info1 high = 0x%.8x\n", info->vcpu_id, *(uint_t *)(((uchar_t *)&(guest_ctrl->exit_info1)) + 4));
 770
 771             V3_Print("SVM core %u: exit_info2 low = 0x%.8x\n", info->vcpu_id, *(uint_t*)&(guest_ctrl->exit_info2));
 772             V3_Print("SVM core %u: exit_info2 high = 0x%.8x\n", info->vcpu_id, *(uint_t *)(((uchar_t *)&(guest_ctrl->exit_info2)) + 4));
 773
 774             linear_addr = get_addr_linear(info, info->rip, &(info->segments.cs));
 775
 776             if (info->mem_mode == PHYSICAL_MEM) {
 777                 v3_gpa_to_hva(info, linear_addr, &host_addr);
 778             } else if (info->mem_mode == VIRTUAL_MEM) {
 779                 v3_gva_to_hva(info, linear_addr, &host_addr);
 780             }
 781
 782             V3_Print("SVM core %u: Host Address of rip = 0x%p\n", info->vcpu_id, (void *)host_addr);
 783
 784             V3_Print("SVM core %u: Instr (15 bytes) at %p:\n", info->vcpu_id, (void *)host_addr);
 785             v3_dump_mem((uint8_t *)host_addr, 15);
 786
 787             v3_print_stack(info);
 788
 789             break;
 790         }
 791
 792         v3_wait_at_barrier(info);
 793
 794
 795         if (info->vm_info->run_state == VM_STOPPED) {
 796             info->core_run_state = CORE_STOPPED;
 797             break;
 798         }
 799
 800
 801
 802 /*
 803         if ((info->num_exits % 50000) == 0) {
 804             V3_Print("SVM Exit number %d\n", (uint32_t)info->num_exits);
 805             v3_print_guest_state(info);
 806         }
 807 */
 808
 809     }
 810
 811     // Need to take down the other cores on error...
 812
 813     return 0;
 814 }
 815
 816
 817
 818
 819 int v3_reset_svm_vm_core(struct guest_info * core, addr_t rip) {
 820     // init vmcb_bios
 821
 822     // Write the RIP, CS, and descriptor
 823     // assume the rest is already good to go
 824     //
 825     // vector VV -> rip at 0
 826     //              CS = VV00
 827     //  This means we start executing at linear address VV000
 828     //
 829     // So the selector needs to be VV00
 830     // and the base needs to be VV000
 831     //
 832     core->rip = 0;
 833     core->segments.cs.selector = rip << 8;
 834     core->segments.cs.limit = 0xffff;
 835     core->segments.cs.base = rip << 12;
 836
 837     return 0;
 838 }
 839
 840
 841
 842
 843
 844
 845 /* Checks machine SVM capability */
 846 /* Implemented from: AMD Arch Manual 3, sect 15.4 */
 847 int v3_is_svm_capable() {
 848     uint_t vm_cr_low = 0, vm_cr_high = 0;
 849     uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
 850
 851     v3_cpuid(CPUID_EXT_FEATURE_IDS, &eax, &ebx, &ecx, &edx);
 852
 853     PrintDebug("CPUID_EXT_FEATURE_IDS_ecx=0x%x\n", ecx);
 854
 855     if ((ecx & CPUID_EXT_FEATURE_IDS_ecx_svm_avail) == 0) {
 856       V3_Print("SVM Not Available\n");
 857       return 0;
 858     }  else {
 859         v3_get_msr(SVM_VM_CR_MSR, &vm_cr_high, &vm_cr_low);
 860
 861         PrintDebug("SVM_VM_CR_MSR = 0x%x 0x%x\n", vm_cr_high, vm_cr_low);
 862
 863         if ((vm_cr_low & SVM_VM_CR_MSR_svmdis) == 1) {
 864             V3_Print("SVM is available but is disabled.\n");
 865
 866             v3_cpuid(CPUID_SVM_REV_AND_FEATURE_IDS, &eax, &ebx, &ecx, &edx);
 867
 868             PrintDebug("CPUID_SVM_REV_AND_FEATURE_IDS_edx=0x%x\n", edx);
 869
 870             if ((edx & CPUID_SVM_REV_AND_FEATURE_IDS_edx_svml) == 0) {
 871                 V3_Print("SVM BIOS Disabled, not unlockable\n");
 872             } else {
 873                 V3_Print("SVM is locked with a key\n");
 874             }
 875             return 0;
 876
 877         } else {
 878             V3_Print("SVM is available and  enabled.\n");
 879
 880             v3_cpuid(CPUID_SVM_REV_AND_FEATURE_IDS, &eax, &ebx, &ecx, &edx);
 881             PrintDebug("CPUID_SVM_REV_AND_FEATURE_IDS_eax=0x%x\n", eax);
 882             PrintDebug("CPUID_SVM_REV_AND_FEATURE_IDS_ebx=0x%x\n", ebx);
 883             PrintDebug("CPUID_SVM_REV_AND_FEATURE_IDS_ecx=0x%x\n", ecx);
 884             PrintDebug("CPUID_SVM_REV_AND_FEATURE_IDS_edx=0x%x\n", edx);
 885
 886             return 1;
 887         }
 888     }
 889 }
 890
 891 static int has_svm_nested_paging() {
 892     uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
 893
 894     v3_cpuid(CPUID_SVM_REV_AND_FEATURE_IDS, &eax, &ebx, &ecx, &edx);
 895
 896     //PrintDebug("CPUID_EXT_FEATURE_IDS_edx=0x%x\n", edx);
 897
 898     if ((edx & CPUID_SVM_REV_AND_FEATURE_IDS_edx_np) == 0) {
 899         V3_Print("SVM Nested Paging not supported\n");
 900         return 0;
 901     } else {
 902         V3_Print("SVM Nested Paging supported\n");
 903         return 1;
 904     }
 905  }
 906
 907
 908
 909 void v3_init_svm_cpu(int cpu_id) {
 910     reg_ex_t msr;
 911     extern v3_cpu_arch_t v3_cpu_types[];
 912
 913     // Enable SVM on the CPU
 914     v3_get_msr(EFER_MSR, &(msr.e_reg.high), &(msr.e_reg.low));
 915     msr.e_reg.low |= EFER_MSR_svm_enable;
 916     v3_set_msr(EFER_MSR, 0, msr.e_reg.low);
 917
 918     V3_Print("SVM Enabled\n");
 919
 920     // Setup the host state save area
 921     host_vmcbs[cpu_id] = (addr_t)V3_AllocPages(4);
 922
 923     /* 64-BIT-ISSUE */
 924     //  msr.e_reg.high = 0;
 925     //msr.e_reg.low = (uint_t)host_vmcb;
 926     msr.r_reg = host_vmcbs[cpu_id];
 927
 928     PrintDebug("Host State being saved at %p\n", (void *)host_vmcbs[cpu_id]);
 929     v3_set_msr(SVM_VM_HSAVE_PA_MSR, msr.e_reg.high, msr.e_reg.low);
 930
 931
 932     if (has_svm_nested_paging() == 1) {
 933         v3_cpu_types[cpu_id] = V3_SVM_REV3_CPU;
 934     } else {
 935         v3_cpu_types[cpu_id] = V3_SVM_CPU;
 936     }
 937 }
 938
 939
 940
 941 void v3_deinit_svm_cpu(int cpu_id) {
 942     reg_ex_t msr;
 943     extern v3_cpu_arch_t v3_cpu_types[];
 944
 945     // reset SVM_VM_HSAVE_PA_MSR
 946     // Does setting it to NULL disable??
 947     msr.r_reg = 0;
 948     v3_set_msr(SVM_VM_HSAVE_PA_MSR, msr.e_reg.high, msr.e_reg.low);
 949
 950     // Disable SVM?
 951     v3_get_msr(EFER_MSR, &(msr.e_reg.high), &(msr.e_reg.low));
 952     msr.e_reg.low &= ~EFER_MSR_svm_enable;
 953     v3_set_msr(EFER_MSR, 0, msr.e_reg.low);
 954
 955     v3_cpu_types[cpu_id] = V3_INVALID_CPU;
 956
 957     V3_FreePages((void *)host_vmcbs[cpu_id], 4);
 958
 959     V3_Print("Host CPU %d host area freed, and SVM disabled\n", cpu_id);
 960     return;
 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
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012 #if 0
1013 /*
1014  * Test VMSAVE/VMLOAD Latency
1015  */
1016 #define vmsave ".byte 0x0F,0x01,0xDB ; "
1017 #define vmload ".byte 0x0F,0x01,0xDA ; "
1018 {
1019     uint32_t start_lo, start_hi;
1020     uint32_t end_lo, end_hi;
1021     uint64_t start, end;
1022
1023     __asm__ __volatile__ (
1024                           "rdtsc ; "
1025                           "movl %%eax, %%esi ; "
1026                           "movl %%edx, %%edi ; "
1027                           "movq  %%rcx, %%rax ; "
1028                           vmsave
1029                           "rdtsc ; "
1030                           : "=D"(start_hi), "=S"(start_lo), "=a"(end_lo),"=d"(end_hi)
1031                           : "c"(host_vmcb[cpu_id]), "0"(0), "1"(0), "2"(0), "3"(0)
1032                           );
1033
1034     start = start_hi;
1035     start <<= 32;
1036     start += start_lo;
1037
1038     end = end_hi;
1039     end <<= 32;
1040     end += end_lo;
1041
1042     PrintDebug("VMSave Cycle Latency: %d\n", (uint32_t)(end - start));
1043
1044     __asm__ __volatile__ (
1045                           "rdtsc ; "
1046                           "movl %%eax, %%esi ; "
1047                           "movl %%edx, %%edi ; "
1048                           "movq  %%rcx, %%rax ; "
1049                           vmload
1050                           "rdtsc ; "
1051                           : "=D"(start_hi), "=S"(start_lo), "=a"(end_lo),"=d"(end_hi)
1052                               : "c"(host_vmcb[cpu_id]), "0"(0), "1"(0), "2"(0), "3"(0)
1053                               );
1054
1055         start = start_hi;
1056         start <<= 32;
1057         start += start_lo;
1058
1059         end = end_hi;
1060         end <<= 32;
1061         end += end_lo;
1062
1063
1064         PrintDebug("VMLoad Cycle Latency: %d\n", (uint32_t)(end - start));
1065     }
1066     /* End Latency Test */
1067
1068 #endif
1069
1070
1071
1072
1073
1074
1075
1076 #if 0
1077 void Init_VMCB_pe(vmcb_t *vmcb, struct guest_info vm_info) {
1078   vmcb_ctrl_t * ctrl_area = GET_VMCB_CTRL_AREA(vmcb);
1079   vmcb_saved_state_t * guest_state = GET_VMCB_SAVE_STATE_AREA(vmcb);
1080   uint_t i = 0;
1081
1082
1083   guest_state->rsp = vm_info.vm_regs.rsp;
1084   guest_state->rip = vm_info.rip;
1085
1086
1087   /* I pretty much just gutted this from TVMM */
1088   /* Note: That means its probably wrong */
1089
1090   // set the segment registers to mirror ours
1091   guest_state->cs.selector = 1<<3;
1092   guest_state->cs.attrib.fields.type = 0xa; // Code segment+read
1093   guest_state->cs.attrib.fields.S = 1;
1094   guest_state->cs.attrib.fields.P = 1;
1095   guest_state->cs.attrib.fields.db = 1;
1096   guest_state->cs.attrib.fields.G = 1;
1097   guest_state->cs.limit = 0xfffff;
1098   guest_state->cs.base = 0;
1099
1100   struct vmcb_selector *segregs [] = {&(guest_state->ss), &(guest_state->ds), &(guest_state->es), &(guest_state->fs), &(guest_state->gs), NULL};
1101   for ( i = 0; segregs[i] != NULL; i++) {
1102     struct vmcb_selector * seg = segregs[i];
1103
1104     seg->selector = 2<<3;
1105     seg->attrib.fields.type = 0x2; // Data Segment+read/write
1106     seg->attrib.fields.S = 1;
1107     seg->attrib.fields.P = 1;
1108     seg->attrib.fields.db = 1;
1109     seg->attrib.fields.G = 1;
1110     seg->limit = 0xfffff;
1111     seg->base = 0;
1112   }
1113
1114
1115   {
1116     /* JRL THIS HAS TO GO */
1117
1118     //    guest_state->tr.selector = GetTR_Selector();
1119     guest_state->tr.attrib.fields.type = 0x9;
1120     guest_state->tr.attrib.fields.P = 1;
1121     // guest_state->tr.limit = GetTR_Limit();
1122     //guest_state->tr.base = GetTR_Base();// - 0x2000;
1123     /* ** */
1124   }
1125
1126
1127   /* ** */
1128
1129
1130   guest_state->efer |= EFER_MSR_svm_enable;
1131   guest_state->rflags = 0x00000002; // The reserved bit is always 1
1132   ctrl_area->svm_instrs.VMRUN = 1;
1133   guest_state->cr0 = 0x00000001;    // PE
1134   ctrl_area->guest_ASID = 1;
1135
1136
1137   //  guest_state->cpl = 0;
1138
1139
1140
1141   // Setup exits
1142
1143   ctrl_area->cr_writes.cr4 = 1;
1144
1145   ctrl_area->exceptions.de = 1;
1146   ctrl_area->exceptions.df = 1;
1147   ctrl_area->exceptions.pf = 1;
1148   ctrl_area->exceptions.ts = 1;
1149   ctrl_area->exceptions.ss = 1;
1150   ctrl_area->exceptions.ac = 1;
1151   ctrl_area->exceptions.mc = 1;
1152   ctrl_area->exceptions.gp = 1;
1153   ctrl_area->exceptions.ud = 1;
1154   ctrl_area->exceptions.np = 1;
1155   ctrl_area->exceptions.of = 1;
1156   ctrl_area->exceptions.nmi = 1;
1157
1158
1159
1160   ctrl_area->instrs.IOIO_PROT = 1;
1161   ctrl_area->IOPM_BASE_PA = (uint_t)V3_AllocPages(3);
1162
1163   {
1164     reg_ex_t tmp_reg;
1165     tmp_reg.r_reg = ctrl_area->IOPM_BASE_PA;
1166     memset((void*)(tmp_reg.e_reg.low), 0xffffffff, PAGE_SIZE * 2);
1167   }
1168
1169   ctrl_area->instrs.INTR = 1;
1170
1171
1172   {
1173     char gdt_buf[6];
1174     char idt_buf[6];
1175
1176     memset(gdt_buf, 0, 6);
1177     memset(idt_buf, 0, 6);
1178
1179
1180     uint_t gdt_base, idt_base;
1181     ushort_t gdt_limit, idt_limit;
1182
1183     GetGDTR(gdt_buf);
1184     gdt_base = *(ulong_t*)((uchar_t*)gdt_buf + 2) & 0xffffffff;
1185     gdt_limit = *(ushort_t*)(gdt_buf) & 0xffff;
1186     PrintDebug("GDT: base: %x, limit: %x\n", gdt_base, gdt_limit);
1187
1188     GetIDTR(idt_buf);
1189     idt_base = *(ulong_t*)(idt_buf + 2) & 0xffffffff;
1190     idt_limit = *(ushort_t*)(idt_buf) & 0xffff;
1191     PrintDebug("IDT: base: %x, limit: %x\n",idt_base, idt_limit);
1192
1193
1194     // gdt_base -= 0x2000;
1195     //idt_base -= 0x2000;
1196
1197     guest_state->gdtr.base = gdt_base;
1198     guest_state->gdtr.limit = gdt_limit;
1199     guest_state->idtr.base = idt_base;
1200     guest_state->idtr.limit = idt_limit;
1201
1202
1203   }
1204
1205
1206   // also determine if CPU supports nested paging
1207   /*
1208   if (vm_info.page_tables) {
1209     //   if (0) {
1210     // Flush the TLB on entries/exits
1211     ctrl_area->TLB_CONTROL = 1;
1212
1213     // Enable Nested Paging
1214     ctrl_area->NP_ENABLE = 1;
1215
1216     PrintDebug("NP_Enable at 0x%x\n", &(ctrl_area->NP_ENABLE));
1217
1218         // Set the Nested Page Table pointer
1219     ctrl_area->N_CR3 |= ((addr_t)vm_info.page_tables & 0xfffff000);
1220
1221
1222     //   ctrl_area->N_CR3 = Get_CR3();
1223     // guest_state->cr3 |= (Get_CR3() & 0xfffff000);
1224
1225     guest_state->g_pat = 0x7040600070406ULL;
1226
1227     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));
1228     PrintDebug("Set Guest CR3: lo: 0x%x  hi: 0x%x\n", (uint_t)*(&(guest_state->cr3)), (uint_t)*((unsigned char *)&(guest_state->cr3) + 4));
1229     // Enable Paging
1230     //    guest_state->cr0 |= 0x80000000;
1231   }
1232   */
1233
1234 }
1235
1236
1237
1238
1239
1240 #endif
1241
1242