palacios/src/palacios/vmcs.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 #include <palacios/vmcs.h>
  21 #include <palacios/vmx_lowlevel.h>
  22 #include <palacios/vmm.h>
  23 #include <palacios/vmx.h>
  24 #include <palacios/vm_guest_mem.h>
  25 #include <palacios/vmm_ctrl_regs.h>
  26 #include <palacios/vmm_lowlevel.h>
  27
  28
  29
  30
  31
  32 static int inline check_vmcs_write(vmcs_field_t field, addr_t val) {
  33     int ret = 0;
  34     ret = vmcs_write(field, val);
  35
  36     if (ret != VMX_SUCCESS) {
  37         PrintError("VMWRITE error on %s!: %d\n", v3_vmcs_field_to_str(field), ret);
  38         return 1;
  39     }
  40
  41     return 0;
  42 }
  43
  44 static int inline check_vmcs_read(vmcs_field_t field, void * val) {
  45     int ret = 0;
  46     ret = vmcs_read(field, val);
  47
  48     if (ret != VMX_SUCCESS) {
  49         PrintError("VMREAD error on %s!: %d\n", v3_vmcs_field_to_str(field), ret);
  50     }
  51
  52     return ret;
  53 }
  54
  55
  56
  57
  58
  59
  60
  61 typedef enum { ES = 0,
  62                CS = 2,
  63                SS = 4,
  64                DS = 6,
  65                FS = 8,
  66                GS = 10,
  67                LDTR = 12,
  68                TR = 14,
  69                GDTR = 16,
  70                IDTR = 18} vmcs_seg_offsets_t;
  71
  72 typedef enum {BASE = VMCS_GUEST_ES_BASE,
  73               LIMIT = VMCS_GUEST_ES_LIMIT,
  74               ACCESS = VMCS_GUEST_ES_ACCESS,
  75               SELECTOR = VMCS_GUEST_ES_SELECTOR } vmcs_seg_bases_t;
  76
  77
  78
  79 static int v3_read_vmcs_segment(struct v3_segment * seg, vmcs_seg_offsets_t seg_type) {
  80     vmcs_field_t selector = VMCS_GUEST_ES_SELECTOR + seg_type;
  81     vmcs_field_t base = VMCS_GUEST_ES_BASE + seg_type;
  82     vmcs_field_t limit = VMCS_GUEST_ES_LIMIT + seg_type;
  83     vmcs_field_t access = VMCS_GUEST_ES_ACCESS + seg_type;
  84     struct vmcs_segment vmcs_seg;
  85
  86     memset(&vmcs_seg, 0, sizeof(struct vmcs_segment));
  87
  88     check_vmcs_read(limit, &(vmcs_seg.limit));
  89     check_vmcs_read(base, &(vmcs_seg.base));
  90
  91     if ((seg_type != GDTR) && (seg_type != IDTR)) {
  92         check_vmcs_read(selector, &(vmcs_seg.selector));
  93         check_vmcs_read(access, &(vmcs_seg.access.val));
  94     }
  95
  96     v3_vmxseg_to_seg(&vmcs_seg, seg);
  97
  98     return 0;
  99 }
 100
 101 static int v3_write_vmcs_segment(struct v3_segment * seg, vmcs_seg_offsets_t seg_type) {
 102     vmcs_field_t selector = VMCS_GUEST_ES_SELECTOR + seg_type;
 103     vmcs_field_t base = VMCS_GUEST_ES_BASE + seg_type;
 104     vmcs_field_t limit = VMCS_GUEST_ES_LIMIT + seg_type;
 105     vmcs_field_t access = VMCS_GUEST_ES_ACCESS + seg_type;
 106     struct vmcs_segment vmcs_seg;
 107
 108     v3_seg_to_vmxseg(seg, &vmcs_seg);
 109
 110     check_vmcs_write(limit, vmcs_seg.limit);
 111     check_vmcs_write(base, vmcs_seg.base);
 112
 113     if ((seg_type != GDTR) && (seg_type != IDTR)) {
 114         check_vmcs_write(access, vmcs_seg.access.val);
 115         check_vmcs_write(selector, vmcs_seg.selector);
 116     }
 117
 118     return 0;
 119 }
 120
 121 int v3_read_vmcs_segments(struct v3_segments * segs) {
 122     v3_read_vmcs_segment(&(segs->cs), CS);
 123     v3_read_vmcs_segment(&(segs->ds), DS);
 124     v3_read_vmcs_segment(&(segs->es), ES);
 125     v3_read_vmcs_segment(&(segs->fs), FS);
 126     v3_read_vmcs_segment(&(segs->gs), GS);
 127     v3_read_vmcs_segment(&(segs->ss), SS);
 128     v3_read_vmcs_segment(&(segs->ldtr), LDTR);
 129     v3_read_vmcs_segment(&(segs->gdtr), GDTR);
 130     v3_read_vmcs_segment(&(segs->idtr), IDTR);
 131     v3_read_vmcs_segment(&(segs->tr), TR);
 132
 133     return 0;
 134 }
 135
 136 int v3_write_vmcs_segments(struct v3_segments * segs) {
 137     v3_write_vmcs_segment(&(segs->cs), CS);
 138     v3_write_vmcs_segment(&(segs->ds), DS);
 139     v3_write_vmcs_segment(&(segs->es), ES);
 140     v3_write_vmcs_segment(&(segs->fs), FS);
 141     v3_write_vmcs_segment(&(segs->gs), GS);
 142     v3_write_vmcs_segment(&(segs->ss), SS);
 143     v3_write_vmcs_segment(&(segs->ldtr), LDTR);
 144     v3_write_vmcs_segment(&(segs->gdtr), GDTR);
 145     v3_write_vmcs_segment(&(segs->idtr), IDTR);
 146     v3_write_vmcs_segment(&(segs->tr), TR);
 147
 148     return 0;
 149 }
 150
 151
 152 void v3_vmxseg_to_seg(struct vmcs_segment * vmcs_seg, struct v3_segment * seg) {
 153     memset(seg, 0, sizeof(struct v3_segment));
 154
 155     seg->selector = vmcs_seg->selector;
 156     seg->limit = vmcs_seg->limit;
 157     seg->base = vmcs_seg->base;
 158
 159     seg->type = vmcs_seg->access.type;
 160     seg->system = vmcs_seg->access.desc_type;
 161     seg->dpl = vmcs_seg->access.dpl;
 162     seg->present = vmcs_seg->access.present;
 163     seg->avail = vmcs_seg->access.avail;
 164     seg->long_mode = vmcs_seg->access.long_mode;
 165     seg->db = vmcs_seg->access.db;
 166     seg->granularity = vmcs_seg->access.granularity;
 167     seg->unusable = vmcs_seg->access.unusable;
 168
 169 }
 170
 171 void v3_seg_to_vmxseg(struct v3_segment * seg, struct vmcs_segment * vmcs_seg) {
 172     memset(vmcs_seg, 0, sizeof(struct vmcs_segment));
 173
 174     vmcs_seg->selector = seg->selector;
 175     vmcs_seg->limit = seg->limit;
 176     vmcs_seg->base = seg->base;
 177
 178     vmcs_seg->access.type = seg->type;
 179     vmcs_seg->access.desc_type = seg->system;
 180     vmcs_seg->access.dpl = seg->dpl;
 181     vmcs_seg->access.present = seg->present;
 182     vmcs_seg->access.avail = seg->avail;
 183     vmcs_seg->access.long_mode = seg->long_mode;
 184     vmcs_seg->access.db = seg->db;
 185     vmcs_seg->access.granularity = seg->granularity;
 186     vmcs_seg->access.unusable = seg->unusable;
 187 }
 188
 189
 190
 191
 192 int v3_update_vmcs_ctrl_fields(struct guest_info * info) {
 193     int vmx_ret = 0;
 194     struct vmx_data * arch_data = (struct vmx_data *)(info->vmm_data);
 195
 196     vmx_ret |= check_vmcs_write(VMCS_PIN_CTRLS, arch_data->pin_ctrls.value);
 197     vmx_ret |= check_vmcs_write(VMCS_PROC_CTRLS, arch_data->pri_proc_ctrls.value);
 198
 199     if (arch_data->pri_proc_ctrls.sec_ctrls) {
 200         vmx_ret |= check_vmcs_write(VMCS_SEC_PROC_CTRLS, arch_data->sec_proc_ctrls.value);
 201     }
 202
 203     vmx_ret |= check_vmcs_write(VMCS_EXIT_CTRLS, arch_data->exit_ctrls.value);
 204     vmx_ret |= check_vmcs_write(VMCS_ENTRY_CTRLS, arch_data->entry_ctrls.value);
 205
 206     return vmx_ret;
 207 }
 208
 209
 210
 211
 212
 213
 214 int v3_vmx_save_vmcs(struct guest_info * info) {
 215     struct vmx_data * vmx_info = (struct vmx_data *)(info->vmm_data);
 216     int error = 0;
 217
 218     check_vmcs_read(VMCS_GUEST_RIP, &(info->rip));
 219     check_vmcs_read(VMCS_GUEST_RSP, &(info->vm_regs.rsp));
 220
 221     check_vmcs_read(VMCS_GUEST_CR0, &(info->ctrl_regs.cr0));
 222     check_vmcs_read(VMCS_CR0_READ_SHDW, &(info->shdw_pg_state.guest_cr0));
 223     check_vmcs_read(VMCS_GUEST_CR3, &(info->ctrl_regs.cr3));
 224     check_vmcs_read(VMCS_GUEST_CR4, &(info->ctrl_regs.cr4));
 225     check_vmcs_read(VMCS_CR4_READ_SHDW, &(vmx_info->guest_cr4));
 226     check_vmcs_read(VMCS_GUEST_DR7, &(info->dbg_regs.dr7));
 227
 228     check_vmcs_read(VMCS_GUEST_RFLAGS, &(info->ctrl_regs.rflags));
 229     if (((struct vmx_data *)info->vmm_data)->ia32e_avail) {
 230         check_vmcs_read(VMCS_GUEST_EFER, &(info->ctrl_regs.efer));
 231     }
 232
 233     error =  v3_read_vmcs_segments(&(info->segments));
 234
 235     return error;
 236 }
 237
 238
 239 int v3_vmx_restore_vmcs(struct guest_info * info) {
 240     struct vmx_data * vmx_info = (struct vmx_data *)(info->vmm_data);
 241     int error = 0;
 242
 243     check_vmcs_write(VMCS_GUEST_RIP, info->rip);
 244     check_vmcs_write(VMCS_GUEST_RSP, info->vm_regs.rsp);
 245
 246     check_vmcs_write(VMCS_GUEST_CR0, info->ctrl_regs.cr0);
 247     check_vmcs_write(VMCS_CR0_READ_SHDW, info->shdw_pg_state.guest_cr0);
 248     check_vmcs_write(VMCS_GUEST_CR3, info->ctrl_regs.cr3);
 249     check_vmcs_write(VMCS_GUEST_CR4, info->ctrl_regs.cr4);
 250     check_vmcs_write(VMCS_CR4_READ_SHDW, vmx_info->guest_cr4);
 251     check_vmcs_write(VMCS_GUEST_DR7, info->dbg_regs.dr7);
 252
 253     check_vmcs_write(VMCS_GUEST_RFLAGS, info->ctrl_regs.rflags);
 254
 255     if (((struct vmx_data *)info->vmm_data)->ia32e_avail) {
 256         check_vmcs_write(VMCS_GUEST_EFER, info->ctrl_regs.efer);
 257     }
 258
 259     error = v3_write_vmcs_segments(&(info->segments));
 260
 261     return error;
 262
 263 }
 264
 265
 266
 267 int v3_update_vmcs_host_state(struct guest_info * info) {
 268     int vmx_ret = 0;
 269     addr_t tmp;
 270     struct vmx_data * arch_data = (struct vmx_data *)(info->vmm_data);
 271     struct v3_msr tmp_msr;
 272
 273 #ifdef __V3_64BIT__
 274     __asm__ __volatile__ ( "movq    %%cr0, %0; "
 275                            : "=q"(tmp)
 276                            :
 277     );
 278 #else
 279     __asm__ __volatile__ ( "movl    %%cr0, %0; "
 280                            : "=q"(tmp)
 281                            :
 282     );
 283 #endif
 284     vmx_ret |= check_vmcs_write(VMCS_HOST_CR0, tmp);
 285
 286
 287 #ifdef __V3_64BIT__
 288     __asm__ __volatile__ ( "movq %%cr3, %0; "
 289                            : "=q"(tmp)
 290                            :
 291     );
 292 #else
 293     __asm__ __volatile__ ( "movl %%cr3, %0; "
 294                            : "=q"(tmp)
 295                            :
 296     );
 297 #endif
 298     vmx_ret |= check_vmcs_write(VMCS_HOST_CR3, tmp);
 299
 300
 301 #ifdef __V3_64BIT__
 302     __asm__ __volatile__ ( "movq %%cr4, %0; "
 303                            : "=q"(tmp)
 304                            :
 305     );
 306 #else
 307     __asm__ __volatile__ ( "movl %%cr4, %0; "
 308                            : "=q"(tmp)
 309                            :
 310     );
 311 #endif
 312     vmx_ret |= check_vmcs_write(VMCS_HOST_CR4, tmp);
 313
 314
 315
 316     vmx_ret |= check_vmcs_write(VMCS_HOST_GDTR_BASE, arch_data->host_state.gdtr.base);
 317     vmx_ret |= check_vmcs_write(VMCS_HOST_IDTR_BASE, arch_data->host_state.idtr.base);
 318     vmx_ret |= check_vmcs_write(VMCS_HOST_TR_BASE, arch_data->host_state.tr.base);
 319
 320 #define FS_BASE_MSR 0xc0000100
 321 #define GS_BASE_MSR 0xc0000101
 322
 323     // FS.BASE MSR
 324     v3_get_msr(FS_BASE_MSR, &(tmp_msr.hi), &(tmp_msr.lo));
 325     vmx_ret |= check_vmcs_write(VMCS_HOST_FS_BASE, tmp_msr.value);
 326
 327     // GS.BASE MSR
 328     v3_get_msr(GS_BASE_MSR, &(tmp_msr.hi), &(tmp_msr.lo));
 329     vmx_ret |= check_vmcs_write(VMCS_HOST_GS_BASE, tmp_msr.value);
 330
 331
 332
 333 #ifdef __V3_64BIT__
 334     __asm__ __volatile__ ( "movq %%cs, %0; "
 335                            : "=q"(tmp)
 336                            :
 337     );
 338 #else
 339     __asm__ __volatile__ ( "movl %%cs, %0; "
 340                            : "=q"(tmp)
 341                            :
 342     );
 343 #endif
 344     vmx_ret |= check_vmcs_write(VMCS_HOST_CS_SELECTOR, tmp);
 345
 346 #ifdef __V3_64BIT__
 347     __asm__ __volatile__ ( "movq %%ss, %0; "
 348                            : "=q"(tmp)
 349                            :
 350     );
 351 #else
 352     __asm__ __volatile__ ( "movl %%ss, %0; "
 353                            : "=q"(tmp)
 354                            :
 355     );
 356 #endif
 357     vmx_ret |= check_vmcs_write(VMCS_HOST_SS_SELECTOR, tmp);
 358
 359 #ifdef __V3_64BIT__
 360     __asm__ __volatile__ ( "movq %%ds, %0; "
 361                            : "=q"(tmp)
 362                            :
 363     );
 364 #else
 365     __asm__ __volatile__ ( "movl %%ds, %0; "
 366                            : "=q"(tmp)
 367                            :
 368     );
 369 #endif
 370     vmx_ret |= check_vmcs_write(VMCS_HOST_DS_SELECTOR, tmp);
 371
 372 #ifdef __V3_64BIT__
 373     __asm__ __volatile__ ( "movq %%es, %0; "
 374                            : "=q"(tmp)
 375                            :
 376     );
 377 #else
 378     __asm__ __volatile__ ( "movl %%es, %0; "
 379                            : "=q"(tmp)
 380                            :
 381     );
 382 #endif
 383     vmx_ret |= check_vmcs_write(VMCS_HOST_ES_SELECTOR, tmp);
 384
 385 #ifdef __V3_64BIT__
 386     __asm__ __volatile__ ( "movq %%fs, %0; "
 387                            : "=q"(tmp)
 388                            :
 389     );
 390 #else
 391     __asm__ __volatile__ ( "movl %%fs, %0; "
 392                            : "=q"(tmp)
 393                            :
 394     );
 395 #endif
 396     vmx_ret |= check_vmcs_write(VMCS_HOST_FS_SELECTOR, tmp);
 397
 398 #ifdef __V3_64BIT__
 399     __asm__ __volatile__ ( "movq %%gs, %0; "
 400                            : "=q"(tmp)
 401                            :
 402     );
 403 #else
 404     __asm__ __volatile__ ( "movl %%gs, %0; "
 405                            : "=q"(tmp)
 406                            :
 407     );
 408 #endif
 409     vmx_ret |= check_vmcs_write(VMCS_HOST_GS_SELECTOR, tmp);
 410
 411     vmx_ret |= check_vmcs_write(VMCS_HOST_TR_SELECTOR, arch_data->host_state.tr.selector);
 412
 413
 414 #define SYSENTER_CS_MSR 0x00000174
 415 #define SYSENTER_ESP_MSR 0x00000175
 416 #define SYSENTER_EIP_MSR 0x00000176
 417
 418    // SYSENTER CS MSR
 419     v3_get_msr(SYSENTER_CS_MSR, &(tmp_msr.hi), &(tmp_msr.lo));
 420     vmx_ret |= check_vmcs_write(VMCS_HOST_SYSENTER_CS, tmp_msr.lo);
 421
 422     // SYSENTER_ESP MSR
 423     v3_get_msr(SYSENTER_ESP_MSR, &(tmp_msr.hi), &(tmp_msr.lo));
 424     vmx_ret |= check_vmcs_write(VMCS_HOST_SYSENTER_ESP, tmp_msr.value);
 425
 426     // SYSENTER_EIP MSR
 427     v3_get_msr(SYSENTER_EIP_MSR, &(tmp_msr.hi), &(tmp_msr.lo));
 428     vmx_ret |= check_vmcs_write(VMCS_HOST_SYSENTER_EIP, tmp_msr.value);
 429
 430     return vmx_ret;
 431 }
 432
 433
 434
 435
 436
 437
 438 static inline void print_vmcs_field(vmcs_field_t vmcs_index) {
 439     int len = v3_vmcs_get_field_len(vmcs_index);
 440     addr_t val;
 441
 442     if (vmcs_read(vmcs_index, &val) != VMX_SUCCESS) {
 443         PrintError("VMCS_READ error for %s\n", v3_vmcs_field_to_str(vmcs_index));
 444         return;
 445     };
 446
 447     if (len == 2) {
 448         PrintDebug("\t%s: 0x%.4x\n", v3_vmcs_field_to_str(vmcs_index), (uint16_t)val);
 449     } else if (len == 4) {
 450         PrintDebug("\t%s: 0x%.8x\n", v3_vmcs_field_to_str(vmcs_index), (uint32_t)val);
 451     } else if (len == 8) {
 452         PrintDebug("\t%s: 0x%p\n", v3_vmcs_field_to_str(vmcs_index), (void *)(addr_t)val);
 453     }
 454 }
 455
 456
 457 static void print_vmcs_segments() {
 458     struct v3_segments segs;
 459
 460     v3_read_vmcs_segments(&segs);
 461     v3_print_segments(&segs);
 462
 463
 464     PrintDebug("   ==> CS\n");
 465     print_vmcs_field(VMCS_GUEST_CS_SELECTOR);
 466     print_vmcs_field(VMCS_GUEST_CS_BASE);
 467     print_vmcs_field(VMCS_GUEST_CS_LIMIT);
 468     print_vmcs_field(VMCS_GUEST_CS_ACCESS);
 469
 470     PrintDebug("   ==> SS\n");
 471     print_vmcs_field(VMCS_GUEST_SS_SELECTOR);
 472     print_vmcs_field(VMCS_GUEST_SS_BASE);
 473     print_vmcs_field(VMCS_GUEST_SS_LIMIT);
 474     print_vmcs_field(VMCS_GUEST_SS_ACCESS);
 475
 476     PrintDebug("   ==> DS\n");
 477     print_vmcs_field(VMCS_GUEST_DS_SELECTOR);
 478     print_vmcs_field(VMCS_GUEST_DS_BASE);
 479     print_vmcs_field(VMCS_GUEST_DS_LIMIT);
 480     print_vmcs_field(VMCS_GUEST_DS_ACCESS);
 481
 482     PrintDebug("   ==> ES\n");
 483     print_vmcs_field(VMCS_GUEST_ES_SELECTOR);
 484     print_vmcs_field(VMCS_GUEST_ES_BASE);
 485     print_vmcs_field(VMCS_GUEST_ES_LIMIT);
 486     print_vmcs_field(VMCS_GUEST_ES_ACCESS);
 487
 488     PrintDebug("   ==> FS\n");
 489     print_vmcs_field(VMCS_GUEST_FS_SELECTOR);
 490     print_vmcs_field(VMCS_GUEST_FS_BASE);
 491     print_vmcs_field(VMCS_GUEST_FS_LIMIT);
 492     print_vmcs_field(VMCS_GUEST_FS_ACCESS);
 493
 494     PrintDebug("   ==> GS\n");
 495     print_vmcs_field(VMCS_GUEST_GS_SELECTOR);
 496     print_vmcs_field(VMCS_GUEST_GS_BASE);
 497     print_vmcs_field(VMCS_GUEST_GS_LIMIT);
 498     print_vmcs_field(VMCS_GUEST_GS_ACCESS);
 499
 500     PrintDebug("   ==> LDTR\n");
 501     print_vmcs_field(VMCS_GUEST_LDTR_SELECTOR);
 502     print_vmcs_field(VMCS_GUEST_LDTR_BASE);
 503     print_vmcs_field(VMCS_GUEST_LDTR_LIMIT);
 504     print_vmcs_field(VMCS_GUEST_LDTR_ACCESS);
 505
 506     PrintDebug("   ==> TR\n");
 507     print_vmcs_field(VMCS_GUEST_TR_SELECTOR);
 508     print_vmcs_field(VMCS_GUEST_TR_BASE);
 509     print_vmcs_field(VMCS_GUEST_TR_LIMIT);
 510     print_vmcs_field(VMCS_GUEST_TR_ACCESS);
 511
 512     PrintDebug("   ==> GDTR\n");
 513     print_vmcs_field(VMCS_GUEST_GDTR_BASE);
 514     print_vmcs_field(VMCS_GUEST_GDTR_LIMIT);
 515
 516     PrintDebug("   ==> IDTR\n");
 517     print_vmcs_field(VMCS_GUEST_IDTR_BASE);
 518     print_vmcs_field(VMCS_GUEST_IDTR_LIMIT);
 519
 520
 521 }
 522
 523
 524
 525
 526 static void print_guest_state()
 527 {
 528     PrintDebug("VMCS_GUEST_STATE\n");
 529     print_vmcs_field(VMCS_GUEST_RIP);
 530     print_vmcs_field(VMCS_GUEST_RSP);
 531     print_vmcs_field(VMCS_GUEST_RFLAGS);
 532     print_vmcs_field(VMCS_GUEST_CR0);
 533     print_vmcs_field(VMCS_GUEST_CR3);
 534     print_vmcs_field(VMCS_GUEST_CR4);
 535     print_vmcs_field(VMCS_GUEST_DR7);
 536
 537
 538     PrintDebug("\n");
 539
 540     print_vmcs_segments();
 541
 542     PrintDebug("\n");
 543
 544     print_vmcs_field(VMCS_GUEST_DBG_CTL);
 545 #ifdef __V3_32BIT__
 546     print_vmcs_field(VMCS_GUEST_DBG_CTL_HIGH);
 547 #endif
 548     print_vmcs_field(VMCS_GUEST_SYSENTER_CS);
 549     print_vmcs_field(VMCS_GUEST_SYSENTER_ESP);
 550     print_vmcs_field(VMCS_GUEST_SYSENTER_EIP);
 551
 552     print_vmcs_field(VMCS_GUEST_PERF_GLOBAL_CTRL);
 553 #ifdef __V3_32BIT__
 554     print_vmcs_field(VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH);
 555 #endif
 556
 557     print_vmcs_field(VMCS_GUEST_SMBASE);
 558
 559
 560     PrintDebug("GUEST_NON_REGISTER_STATE\n");
 561
 562     print_vmcs_field(VMCS_GUEST_ACTIVITY_STATE);
 563     print_vmcs_field(VMCS_GUEST_INT_STATE);
 564     print_vmcs_field(VMCS_GUEST_PENDING_DBG_EXCP);
 565
 566 }
 567
 568 static void print_host_state()
 569 {
 570     PrintDebug("VMCS_HOST_STATE\n");
 571
 572     print_vmcs_field(VMCS_HOST_RIP);
 573     print_vmcs_field(VMCS_HOST_RSP);
 574     print_vmcs_field(VMCS_HOST_CR0);
 575     print_vmcs_field(VMCS_HOST_CR3);
 576     print_vmcs_field(VMCS_HOST_CR4);
 577
 578     PrintDebug("\n");
 579     print_vmcs_field(VMCS_HOST_CS_SELECTOR);
 580     print_vmcs_field(VMCS_HOST_SS_SELECTOR);
 581     print_vmcs_field(VMCS_HOST_DS_SELECTOR);
 582     print_vmcs_field(VMCS_HOST_ES_SELECTOR);
 583     print_vmcs_field(VMCS_HOST_FS_SELECTOR);
 584     print_vmcs_field(VMCS_HOST_GS_SELECTOR);
 585     print_vmcs_field(VMCS_HOST_TR_SELECTOR);
 586
 587     PrintDebug("\n");
 588     print_vmcs_field(VMCS_HOST_FS_BASE);
 589     print_vmcs_field(VMCS_HOST_GS_BASE);
 590     print_vmcs_field(VMCS_HOST_TR_BASE);
 591     print_vmcs_field(VMCS_HOST_GDTR_BASE);
 592     print_vmcs_field(VMCS_HOST_IDTR_BASE);
 593
 594     PrintDebug("\n");
 595     print_vmcs_field(VMCS_HOST_SYSENTER_CS);
 596     print_vmcs_field(VMCS_HOST_SYSENTER_ESP);
 597     print_vmcs_field(VMCS_HOST_SYSENTER_EIP);
 598
 599     print_vmcs_field(VMCS_HOST_PERF_GLOBAL_CTRL);
 600 #ifdef __V3_32BIT__
 601     print_vmcs_field(VMCS_HOST_PERF_GLOBAL_CTRL_HIGH);
 602 #endif
 603 }
 604
 605
 606 static void print_exec_ctrls() {
 607     PrintDebug("VMCS_EXEC_CTRL_FIELDS\n");
 608     print_vmcs_field(VMCS_PIN_CTRLS);
 609     print_vmcs_field(VMCS_PROC_CTRLS);
 610     print_vmcs_field(VMCS_SEC_PROC_CTRLS);
 611
 612     print_vmcs_field(VMCS_EXCP_BITMAP);
 613     print_vmcs_field(VMCS_PG_FAULT_ERR_MASK);
 614     print_vmcs_field(VMCS_PG_FAULT_ERR_MATCH);
 615
 616     print_vmcs_field(VMCS_IO_BITMAP_A_ADDR);
 617 #ifdef __V3_32BIT__
 618     print_vmcs_field(VMCS_IO_BITMAP_A_ADDR_HIGH);
 619 #endif
 620     print_vmcs_field(VMCS_IO_BITMAP_B_ADDR);
 621 #ifdef __V3_32BIT__
 622     print_vmcs_field(VMCS_IO_BITMAP_B_ADDR_HIGH);
 623 #endif
 624
 625     print_vmcs_field(VMCS_TSC_OFFSET);
 626 #ifdef __V3_32BIT__
 627     print_vmcs_field(VMCS_TSC_OFFSET_HIGH);
 628 #endif
 629
 630     PrintDebug("\n");
 631
 632     print_vmcs_field(VMCS_CR0_MASK);
 633     print_vmcs_field(VMCS_CR0_READ_SHDW);
 634     print_vmcs_field(VMCS_CR4_MASK);
 635     print_vmcs_field(VMCS_CR4_READ_SHDW);
 636
 637     print_vmcs_field(VMCS_CR3_TGT_CNT);
 638     print_vmcs_field(VMCS_CR3_TGT_VAL_0);
 639     print_vmcs_field(VMCS_CR3_TGT_VAL_1);
 640     print_vmcs_field(VMCS_CR3_TGT_VAL_2);
 641     print_vmcs_field(VMCS_CR3_TGT_VAL_3);
 642
 643     PrintDebug("\n");
 644
 645     print_vmcs_field(VMCS_APIC_ACCESS_ADDR);
 646 #ifdef __V3_32BIT__
 647     print_vmcs_field(VMCS_APIC_ACCESS_ADDR_HIGH);
 648 #endif
 649
 650     print_vmcs_field(VMCS_VAPIC_ADDR);
 651 #ifdef __V3_32BIT__
 652     print_vmcs_field(VMCS_VAPIC_ADDR_HIGH);
 653 #endif
 654
 655     print_vmcs_field(VMCS_TPR_THRESHOLD);
 656
 657     print_vmcs_field(VMCS_MSR_BITMAP);
 658 #ifdef __V3_32BIT__
 659     print_vmcs_field(VMCS_MSR_BITMAP_HIGH);
 660 #endif
 661
 662     print_vmcs_field(VMCS_EXEC_PTR);
 663 #ifdef __V3_32BIT__
 664     print_vmcs_field(VMCS_EXEC_PTR_HIGH);
 665 #endif
 666 }
 667
 668
 669 static void print_exit_ctrls() {
 670     PrintDebug("VMCS_EXIT_CTRLS\n");
 671
 672     print_vmcs_field(VMCS_EXIT_CTRLS);
 673
 674
 675     print_vmcs_field(VMCS_EXIT_MSR_STORE_CNT);
 676     print_vmcs_field(VMCS_EXIT_MSR_STORE_ADDR);
 677 #ifdef __V3_32BIT__
 678     print_vmcs_field(VMCS_EXIT_MSR_STORE_ADDR_HIGH);
 679 #endif
 680
 681     print_vmcs_field(VMCS_EXIT_MSR_LOAD_CNT);
 682     print_vmcs_field(VMCS_EXIT_MSR_LOAD_ADDR);
 683 #ifdef __V3_32BIT__
 684     print_vmcs_field(VMCS_EXIT_MSR_LOAD_ADDR_HIGH);
 685 #endif
 686
 687 }
 688
 689
 690 static void print_entry_ctrls() {
 691     PrintDebug("VMCS_ENTRY_CTRLS\n");
 692
 693     print_vmcs_field(VMCS_ENTRY_CTRLS);
 694
 695     print_vmcs_field(VMCS_ENTRY_MSR_LOAD_CNT);
 696     print_vmcs_field(VMCS_ENTRY_MSR_LOAD_ADDR);
 697 #ifdef __V3_32BIT__
 698     print_vmcs_field(VMCS_ENTRY_MSR_LOAD_ADDR_HIGH);
 699 #endif
 700
 701     print_vmcs_field(VMCS_ENTRY_INT_INFO);
 702     print_vmcs_field(VMCS_ENTRY_EXCP_ERR);
 703     print_vmcs_field(VMCS_ENTRY_INSTR_LEN);
 704
 705
 706 }
 707
 708
 709 static void print_exit_info() {
 710     PrintDebug("VMCS_EXIT_INFO\n");
 711
 712     print_vmcs_field(VMCS_EXIT_REASON);
 713     print_vmcs_field(VMCS_EXIT_QUAL);
 714
 715     print_vmcs_field(VMCS_EXIT_INT_INFO);
 716     print_vmcs_field(VMCS_EXIT_INT_ERR);
 717
 718     print_vmcs_field(VMCS_IDT_VECTOR_INFO);
 719     print_vmcs_field(VMCS_IDT_VECTOR_ERR);
 720
 721     print_vmcs_field(VMCS_EXIT_INSTR_LEN);
 722
 723     print_vmcs_field(VMCS_GUEST_LINEAR_ADDR);
 724     print_vmcs_field(VMCS_EXIT_INSTR_INFO);
 725
 726     print_vmcs_field(VMCS_IO_RCX);
 727     print_vmcs_field(VMCS_IO_RSI);
 728     print_vmcs_field(VMCS_IO_RDI);
 729     print_vmcs_field(VMCS_IO_RIP);
 730
 731
 732     print_vmcs_field(VMCS_INSTR_ERR);
 733 }
 734
 735 void v3_print_vmcs() {
 736
 737     print_vmcs_field(VMCS_LINK_PTR);
 738 #ifdef __V3_32BIT__
 739     print_vmcs_field(VMCS_LINK_PTR_HIGH);
 740 #endif
 741
 742     print_guest_state();
 743     print_host_state();
 744
 745     print_exec_ctrls();
 746     print_exit_ctrls();
 747     print_entry_ctrls();
 748     print_exit_info();
 749
 750
 751
 752
 753 }
 754
 755
 756 /*
 757  * Returns the field length in bytes
 758  */
 759 int v3_vmcs_get_field_len(vmcs_field_t field) {
 760     switch(field)  {
 761         /* 16 bit Control Fields */
 762         case VMCS_GUEST_ES_SELECTOR:
 763         case VMCS_GUEST_CS_SELECTOR:
 764         case VMCS_GUEST_SS_SELECTOR:
 765         case VMCS_GUEST_DS_SELECTOR:
 766         case VMCS_GUEST_FS_SELECTOR:
 767         case VMCS_GUEST_GS_SELECTOR:
 768         case VMCS_GUEST_LDTR_SELECTOR:
 769         case VMCS_GUEST_TR_SELECTOR:
 770         case VMCS_HOST_ES_SELECTOR:
 771         case VMCS_HOST_CS_SELECTOR:
 772         case VMCS_HOST_SS_SELECTOR:
 773         case VMCS_HOST_DS_SELECTOR:
 774         case VMCS_HOST_FS_SELECTOR:
 775         case VMCS_HOST_GS_SELECTOR:
 776         case VMCS_HOST_TR_SELECTOR:
 777             return 2;
 778
 779         /* 32 bit Control Fields */
 780         case VMCS_PIN_CTRLS:
 781         case VMCS_PROC_CTRLS:
 782         case VMCS_SEC_PROC_CTRLS:
 783         case VMCS_EXCP_BITMAP:
 784         case VMCS_PG_FAULT_ERR_MASK:
 785         case VMCS_PG_FAULT_ERR_MATCH:
 786         case VMCS_CR3_TGT_CNT:
 787         case VMCS_EXIT_CTRLS:
 788         case VMCS_EXIT_MSR_STORE_CNT:
 789         case VMCS_EXIT_MSR_LOAD_CNT:
 790         case VMCS_ENTRY_CTRLS:
 791         case VMCS_ENTRY_MSR_LOAD_CNT:
 792         case VMCS_ENTRY_INT_INFO:
 793         case VMCS_ENTRY_EXCP_ERR:
 794         case VMCS_ENTRY_INSTR_LEN:
 795         case VMCS_TPR_THRESHOLD:
 796         case VMCS_INSTR_ERR:
 797         case VMCS_EXIT_REASON:
 798         case VMCS_EXIT_INT_INFO:
 799         case VMCS_EXIT_INT_ERR:
 800         case VMCS_IDT_VECTOR_INFO:
 801         case VMCS_IDT_VECTOR_ERR:
 802         case VMCS_EXIT_INSTR_LEN:
 803         case VMCS_EXIT_INSTR_INFO:
 804         case VMCS_GUEST_ES_LIMIT:
 805         case VMCS_GUEST_CS_LIMIT:
 806         case VMCS_GUEST_SS_LIMIT:
 807         case VMCS_GUEST_DS_LIMIT:
 808         case VMCS_GUEST_FS_LIMIT:
 809         case VMCS_GUEST_GS_LIMIT:
 810         case VMCS_GUEST_LDTR_LIMIT:
 811         case VMCS_GUEST_TR_LIMIT:
 812         case VMCS_GUEST_GDTR_LIMIT:
 813         case VMCS_GUEST_IDTR_LIMIT:
 814         case VMCS_GUEST_ES_ACCESS:
 815         case VMCS_GUEST_CS_ACCESS:
 816         case VMCS_GUEST_SS_ACCESS:
 817         case VMCS_GUEST_DS_ACCESS:
 818         case VMCS_GUEST_FS_ACCESS:
 819         case VMCS_GUEST_GS_ACCESS:
 820         case VMCS_GUEST_LDTR_ACCESS:
 821         case VMCS_GUEST_TR_ACCESS:
 822         case VMCS_GUEST_INT_STATE:
 823         case VMCS_GUEST_ACTIVITY_STATE:
 824         case VMCS_GUEST_SMBASE:
 825         case VMCS_GUEST_SYSENTER_CS:
 826         case VMCS_HOST_SYSENTER_CS:
 827             return 4;
 828
 829
 830         /* high bits of variable width fields
 831          * We can probably just delete most of these....
 832          */
 833         case VMCS_IO_BITMAP_A_ADDR_HIGH:
 834         case VMCS_IO_BITMAP_B_ADDR_HIGH:
 835         case VMCS_MSR_BITMAP_HIGH:
 836         case VMCS_EXIT_MSR_STORE_ADDR_HIGH:
 837         case VMCS_EXIT_MSR_LOAD_ADDR_HIGH:
 838         case VMCS_ENTRY_MSR_LOAD_ADDR_HIGH:
 839         case VMCS_EXEC_PTR_HIGH:
 840         case VMCS_TSC_OFFSET_HIGH:
 841         case VMCS_VAPIC_ADDR_HIGH:
 842         case VMCS_APIC_ACCESS_ADDR_HIGH:
 843         case VMCS_LINK_PTR_HIGH:
 844         case VMCS_GUEST_DBG_CTL_HIGH:
 845         case VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH:
 846         case VMCS_HOST_PERF_GLOBAL_CTRL_HIGH:
 847             return 4;
 848
 849             /* Natural Width Control Fields */
 850         case VMCS_IO_BITMAP_A_ADDR:
 851         case VMCS_IO_BITMAP_B_ADDR:
 852         case VMCS_MSR_BITMAP:
 853         case VMCS_EXIT_MSR_STORE_ADDR:
 854         case VMCS_EXIT_MSR_LOAD_ADDR:
 855         case VMCS_ENTRY_MSR_LOAD_ADDR:
 856         case VMCS_EXEC_PTR:
 857         case VMCS_TSC_OFFSET:
 858         case VMCS_VAPIC_ADDR:
 859         case VMCS_APIC_ACCESS_ADDR:
 860         case VMCS_LINK_PTR:
 861         case VMCS_GUEST_DBG_CTL:
 862         case VMCS_GUEST_PERF_GLOBAL_CTRL:
 863         case VMCS_HOST_PERF_GLOBAL_CTRL:
 864         case VMCS_CR0_MASK:
 865         case VMCS_CR4_MASK:
 866         case VMCS_CR0_READ_SHDW:
 867         case VMCS_CR4_READ_SHDW:
 868         case VMCS_CR3_TGT_VAL_0:
 869         case VMCS_CR3_TGT_VAL_1:
 870         case VMCS_CR3_TGT_VAL_2:
 871         case VMCS_CR3_TGT_VAL_3:
 872         case VMCS_EXIT_QUAL:
 873         case VMCS_IO_RCX:
 874         case VMCS_IO_RSI:
 875         case VMCS_IO_RDI:
 876         case VMCS_IO_RIP:
 877         case VMCS_GUEST_LINEAR_ADDR:
 878         case VMCS_GUEST_CR0:
 879         case VMCS_GUEST_CR3:
 880         case VMCS_GUEST_CR4:
 881         case VMCS_GUEST_ES_BASE:
 882         case VMCS_GUEST_CS_BASE:
 883         case VMCS_GUEST_SS_BASE:
 884         case VMCS_GUEST_DS_BASE:
 885         case VMCS_GUEST_FS_BASE:
 886         case VMCS_GUEST_GS_BASE:
 887         case VMCS_GUEST_LDTR_BASE:
 888         case VMCS_GUEST_TR_BASE:
 889         case VMCS_GUEST_GDTR_BASE:
 890         case VMCS_GUEST_IDTR_BASE:
 891         case VMCS_GUEST_DR7:
 892         case VMCS_GUEST_RSP:
 893         case VMCS_GUEST_RIP:
 894         case VMCS_GUEST_RFLAGS:
 895         case VMCS_GUEST_PENDING_DBG_EXCP:
 896         case VMCS_GUEST_SYSENTER_ESP:
 897         case VMCS_GUEST_SYSENTER_EIP:
 898         case VMCS_HOST_CR0:
 899         case VMCS_HOST_CR3:
 900         case VMCS_HOST_CR4:
 901         case VMCS_HOST_FS_BASE:
 902         case VMCS_HOST_GS_BASE:
 903         case VMCS_HOST_TR_BASE:
 904         case VMCS_HOST_GDTR_BASE:
 905         case VMCS_HOST_IDTR_BASE:
 906         case VMCS_HOST_SYSENTER_ESP:
 907         case VMCS_HOST_SYSENTER_EIP:
 908         case VMCS_HOST_RSP:
 909         case VMCS_HOST_RIP:
 910             return sizeof(addr_t);
 911
 912         default:
 913             PrintError("Invalid VMCS field\n");
 914             return -1;
 915     }
 916 }
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929 static const char VMCS_GUEST_ES_SELECTOR_STR[] = "GUEST_ES_SELECTOR";
 930 static const char VMCS_GUEST_CS_SELECTOR_STR[] = "GUEST_CS_SELECTOR";
 931 static const char VMCS_GUEST_SS_SELECTOR_STR[] = "GUEST_SS_SELECTOR";
 932 static const char VMCS_GUEST_DS_SELECTOR_STR[] = "GUEST_DS_SELECTOR";
 933 static const char VMCS_GUEST_FS_SELECTOR_STR[] = "GUEST_FS_SELECTOR";
 934 static const char VMCS_GUEST_GS_SELECTOR_STR[] = "GUEST_GS_SELECTOR";
 935 static const char VMCS_GUEST_LDTR_SELECTOR_STR[] = "GUEST_LDTR_SELECTOR";
 936 static const char VMCS_GUEST_TR_SELECTOR_STR[] = "GUEST_TR_SELECTOR";
 937 static const char VMCS_HOST_ES_SELECTOR_STR[] = "HOST_ES_SELECTOR";
 938 static const char VMCS_HOST_CS_SELECTOR_STR[] = "HOST_CS_SELECTOR";
 939 static const char VMCS_HOST_SS_SELECTOR_STR[] = "HOST_SS_SELECTOR";
 940 static const char VMCS_HOST_DS_SELECTOR_STR[] = "HOST_DS_SELECTOR";
 941 static const char VMCS_HOST_FS_SELECTOR_STR[] = "HOST_FS_SELECTOR";
 942 static const char VMCS_HOST_GS_SELECTOR_STR[] = "HOST_GS_SELECTOR";
 943 static const char VMCS_HOST_TR_SELECTOR_STR[] = "HOST_TR_SELECTOR";
 944 static const char VMCS_IO_BITMAP_A_ADDR_STR[] = "IO_BITMAP_A_ADDR";
 945 static const char VMCS_IO_BITMAP_A_ADDR_HIGH_STR[] = "IO_BITMAP_A_ADDR_HIGH";
 946 static const char VMCS_IO_BITMAP_B_ADDR_STR[] = "IO_BITMAP_B_ADDR";
 947 static const char VMCS_IO_BITMAP_B_ADDR_HIGH_STR[] = "IO_BITMAP_B_ADDR_HIGH";
 948 static const char VMCS_MSR_BITMAP_STR[] = "MSR_BITMAPS";
 949 static const char VMCS_MSR_BITMAP_HIGH_STR[] = "MSR_BITMAPS_HIGH";
 950 static const char VMCS_EXIT_MSR_STORE_ADDR_STR[] = "EXIT_MSR_STORE_ADDR";
 951 static const char VMCS_EXIT_MSR_STORE_ADDR_HIGH_STR[] = "EXIT_MSR_STORE_ADDR_HIGH";
 952 static const char VMCS_EXIT_MSR_LOAD_ADDR_STR[] = "EXIT_MSR_LOAD_ADDR";
 953 static const char VMCS_EXIT_MSR_LOAD_ADDR_HIGH_STR[] = "EXIT_MSR_LOAD_ADDR_HIGH";
 954 static const char VMCS_ENTRY_MSR_LOAD_ADDR_STR[] = "ENTRY_MSR_LOAD_ADDR";
 955 static const char VMCS_ENTRY_MSR_LOAD_ADDR_HIGH_STR[] = "ENTRY_MSR_LOAD_ADDR_HIGH";
 956 static const char VMCS_EXEC_PTR_STR[] = "VMCS_EXEC_PTR";
 957 static const char VMCS_EXEC_PTR_HIGH_STR[] = "VMCS_EXEC_PTR_HIGH";
 958 static const char VMCS_TSC_OFFSET_STR[] = "TSC_OFFSET";
 959 static const char VMCS_TSC_OFFSET_HIGH_STR[] = "TSC_OFFSET_HIGH";
 960 static const char VMCS_VAPIC_ADDR_STR[] = "VAPIC_PAGE_ADDR";
 961 static const char VMCS_VAPIC_ADDR_HIGH_STR[] = "VAPIC_PAGE_ADDR_HIGH";
 962 static const char VMCS_APIC_ACCESS_ADDR_STR[] = "APIC_ACCESS_ADDR";
 963 static const char VMCS_APIC_ACCESS_ADDR_HIGH_STR[] = "APIC_ACCESS_ADDR_HIGH";
 964 static const char VMCS_LINK_PTR_STR[] = "VMCS_LINK_PTR";
 965 static const char VMCS_LINK_PTR_HIGH_STR[] = "VMCS_LINK_PTR_HIGH";
 966 static const char VMCS_GUEST_DBG_CTL_STR[] = "GUEST_DEBUG_CTL";
 967 static const char VMCS_GUEST_DBG_CTL_HIGH_STR[] = "GUEST_DEBUG_CTL_HIGH";
 968 static const char VMCS_GUEST_PERF_GLOBAL_CTRL_STR[] = "GUEST_PERF_GLOBAL_CTRL";
 969 static const char VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH_STR[] = "GUEST_PERF_GLOBAL_CTRL_HIGH";
 970 static const char VMCS_HOST_PERF_GLOBAL_CTRL_STR[] = "HOST_PERF_GLOBAL_CTRL";
 971 static const char VMCS_HOST_PERF_GLOBAL_CTRL_HIGH_STR[] = "HOST_PERF_GLOBAL_CTRL_HIGH";
 972 static const char VMCS_PIN_CTRLS_STR[] = "PIN_VM_EXEC_CTRLS";
 973 static const char VMCS_PROC_CTRLS_STR[] = "PROC_VM_EXEC_CTRLS";
 974 static const char VMCS_EXCP_BITMAP_STR[] = "EXCEPTION_BITMAP";
 975 static const char VMCS_PG_FAULT_ERR_MASK_STR[] = "PAGE_FAULT_ERROR_MASK";
 976 static const char VMCS_PG_FAULT_ERR_MATCH_STR[] = "PAGE_FAULT_ERROR_MATCH";
 977 static const char VMCS_CR3_TGT_CNT_STR[] = "CR3_TARGET_COUNT";
 978 static const char VMCS_EXIT_CTRLS_STR[] = "VM_EXIT_CTRLS";
 979 static const char VMCS_EXIT_MSR_STORE_CNT_STR[] = "VM_EXIT_MSR_STORE_COUNT";
 980 static const char VMCS_EXIT_MSR_LOAD_CNT_STR[] = "VM_EXIT_MSR_LOAD_COUNT";
 981 static const char VMCS_ENTRY_CTRLS_STR[] = "VM_ENTRY_CTRLS";
 982 static const char VMCS_ENTRY_MSR_LOAD_CNT_STR[] = "VM_ENTRY_MSR_LOAD_COUNT";
 983 static const char VMCS_ENTRY_INT_INFO_STR[] = "VM_ENTRY_INT_INFO_FIELD";
 984 static const char VMCS_ENTRY_EXCP_ERR_STR[] = "VM_ENTRY_EXCEPTION_ERROR";
 985 static const char VMCS_ENTRY_INSTR_LEN_STR[] = "VM_ENTRY_INSTR_LENGTH";
 986 static const char VMCS_TPR_THRESHOLD_STR[] = "TPR_THRESHOLD";
 987 static const char VMCS_SEC_PROC_CTRLS_STR[] = "VMCS_SEC_PROC_CTRLS";
 988 static const char VMCS_INSTR_ERR_STR[] = "VM_INSTR_ERROR";
 989 static const char VMCS_EXIT_REASON_STR[] = "EXIT_REASON";
 990 static const char VMCS_EXIT_INT_INFO_STR[] = "VM_EXIT_INT_INFO";
 991 static const char VMCS_EXIT_INT_ERR_STR[] = "VM_EXIT_INT_ERROR";
 992 static const char VMCS_IDT_VECTOR_INFO_STR[] = "IDT_VECTOR_INFO";
 993 static const char VMCS_IDT_VECTOR_ERR_STR[] = "IDT_VECTOR_ERROR";
 994 static const char VMCS_EXIT_INSTR_LEN_STR[] = "VM_EXIT_INSTR_LENGTH";
 995 static const char VMCS_EXIT_INSTR_INFO_STR[] = "VMX_INSTR_INFO";
 996 static const char VMCS_GUEST_ES_LIMIT_STR[] = "GUEST_ES_LIMIT";
 997 static const char VMCS_GUEST_CS_LIMIT_STR[] = "GUEST_CS_LIMIT";
 998 static const char VMCS_GUEST_SS_LIMIT_STR[] = "GUEST_SS_LIMIT";
 999 static const char VMCS_GUEST_DS_LIMIT_STR[] = "GUEST_DS_LIMIT";
1000 static const char VMCS_GUEST_FS_LIMIT_STR[] = "GUEST_FS_LIMIT";
1001 static const char VMCS_GUEST_GS_LIMIT_STR[] = "GUEST_GS_LIMIT";
1002 static const char VMCS_GUEST_LDTR_LIMIT_STR[] = "GUEST_LDTR_LIMIT";
1003 static const char VMCS_GUEST_TR_LIMIT_STR[] = "GUEST_TR_LIMIT";
1004 static const char VMCS_GUEST_GDTR_LIMIT_STR[] = "GUEST_GDTR_LIMIT";
1005 static const char VMCS_GUEST_IDTR_LIMIT_STR[] = "GUEST_IDTR_LIMIT";
1006 static const char VMCS_GUEST_ES_ACCESS_STR[] = "GUEST_ES_ACCESS";
1007 static const char VMCS_GUEST_CS_ACCESS_STR[] = "GUEST_CS_ACCESS";
1008 static const char VMCS_GUEST_SS_ACCESS_STR[] = "GUEST_SS_ACCESS";
1009 static const char VMCS_GUEST_DS_ACCESS_STR[] = "GUEST_DS_ACCESS";
1010 static const char VMCS_GUEST_FS_ACCESS_STR[] = "GUEST_FS_ACCESS";
1011 static const char VMCS_GUEST_GS_ACCESS_STR[] = "GUEST_GS_ACCESS";
1012 static const char VMCS_GUEST_LDTR_ACCESS_STR[] = "GUEST_LDTR_ACCESS";
1013 static const char VMCS_GUEST_TR_ACCESS_STR[] = "GUEST_TR_ACCESS";
1014 static const char VMCS_GUEST_INT_STATE_STR[] = "GUEST_INT_STATE";
1015 static const char VMCS_GUEST_ACTIVITY_STATE_STR[] = "GUEST_ACTIVITY_STATE";
1016 static const char VMCS_GUEST_SMBASE_STR[] = "GUEST_SMBASE";
1017 static const char VMCS_GUEST_SYSENTER_CS_STR[] = "GUEST_SYSENTER_CS";
1018 static const char VMCS_HOST_SYSENTER_CS_STR[] = "HOST_SYSENTER_CS";
1019 static const char VMCS_CR0_MASK_STR[] = "CR0_GUEST_HOST_MASK";
1020 static const char VMCS_CR4_MASK_STR[] = "CR4_GUEST_HOST_MASK";
1021 static const char VMCS_CR0_READ_SHDW_STR[] = "CR0_READ_SHADOW";
1022 static const char VMCS_CR4_READ_SHDW_STR[] = "CR4_READ_SHADOW";
1023 static const char VMCS_CR3_TGT_VAL_0_STR[] = "CR3_TARGET_VALUE_0";
1024 static const char VMCS_CR3_TGT_VAL_1_STR[] = "CR3_TARGET_VALUE_1";
1025 static const char VMCS_CR3_TGT_VAL_2_STR[] = "CR3_TARGET_VALUE_2";
1026 static const char VMCS_CR3_TGT_VAL_3_STR[] = "CR3_TARGET_VALUE_3";
1027 static const char VMCS_EXIT_QUAL_STR[] = "EXIT_QUALIFICATION";
1028 static const char VMCS_IO_RCX_STR[] = "IO_RCX";
1029 static const char VMCS_IO_RSI_STR[] = "IO_RSI";
1030 static const char VMCS_IO_RDI_STR[] = "IO_RDI";
1031 static const char VMCS_IO_RIP_STR[] = "IO_RIP";
1032 static const char VMCS_GUEST_LINEAR_ADDR_STR[] = "GUEST_LINEAR_ADDR";
1033 static const char VMCS_GUEST_CR0_STR[] = "GUEST_CR0";
1034 static const char VMCS_GUEST_CR3_STR[] = "GUEST_CR3";
1035 static const char VMCS_GUEST_CR4_STR[] = "GUEST_CR4";
1036 static const char VMCS_GUEST_ES_BASE_STR[] = "GUEST_ES_BASE";
1037 static const char VMCS_GUEST_CS_BASE_STR[] = "GUEST_CS_BASE";
1038 static const char VMCS_GUEST_SS_BASE_STR[] = "GUEST_SS_BASE";
1039 static const char VMCS_GUEST_DS_BASE_STR[] = "GUEST_DS_BASE";
1040 static const char VMCS_GUEST_FS_BASE_STR[] = "GUEST_FS_BASE";
1041 static const char VMCS_GUEST_GS_BASE_STR[] = "GUEST_GS_BASE";
1042 static const char VMCS_GUEST_LDTR_BASE_STR[] = "GUEST_LDTR_BASE";
1043 static const char VMCS_GUEST_TR_BASE_STR[] = "GUEST_TR_BASE";
1044 static const char VMCS_GUEST_GDTR_BASE_STR[] = "GUEST_GDTR_BASE";
1045 static const char VMCS_GUEST_IDTR_BASE_STR[] = "GUEST_IDTR_BASE";
1046 static const char VMCS_GUEST_DR7_STR[] = "GUEST_DR7";
1047 static const char VMCS_GUEST_RSP_STR[] = "GUEST_RSP";
1048 static const char VMCS_GUEST_RIP_STR[] = "GUEST_RIP";
1049 static const char VMCS_GUEST_RFLAGS_STR[] = "GUEST_RFLAGS";
1050 static const char VMCS_GUEST_PENDING_DBG_EXCP_STR[] = "GUEST_PENDING_DEBUG_EXCS";
1051 static const char VMCS_GUEST_SYSENTER_ESP_STR[] = "GUEST_SYSENTER_ESP";
1052 static const char VMCS_GUEST_SYSENTER_EIP_STR[] = "GUEST_SYSENTER_EIP";
1053 static const char VMCS_HOST_CR0_STR[] = "HOST_CR0";
1054 static const char VMCS_HOST_CR3_STR[] = "HOST_CR3";
1055 static const char VMCS_HOST_CR4_STR[] = "HOST_CR4";
1056 static const char VMCS_HOST_FS_BASE_STR[] = "HOST_FS_BASE";
1057 static const char VMCS_HOST_GS_BASE_STR[] = "HOST_GS_BASE";
1058 static const char VMCS_HOST_TR_BASE_STR[] = "HOST_TR_BASE";
1059 static const char VMCS_HOST_GDTR_BASE_STR[] = "HOST_GDTR_BASE";
1060 static const char VMCS_HOST_IDTR_BASE_STR[] = "HOST_IDTR_BASE";
1061 static const char VMCS_HOST_SYSENTER_ESP_STR[] = "HOST_SYSENTER_ESP";
1062 static const char VMCS_HOST_SYSENTER_EIP_STR[] = "HOST_SYSENTER_EIP";
1063 static const char VMCS_HOST_RSP_STR[] = "HOST_RSP";
1064 static const char VMCS_HOST_RIP_STR[] = "HOST_RIP";
1065
1066
1067
1068 const char * v3_vmcs_field_to_str(vmcs_field_t field) {
1069     switch (field) {
1070         case VMCS_GUEST_ES_SELECTOR:
1071             return VMCS_GUEST_ES_SELECTOR_STR;
1072         case VMCS_GUEST_CS_SELECTOR:
1073             return VMCS_GUEST_CS_SELECTOR_STR;
1074         case VMCS_GUEST_SS_SELECTOR:
1075             return VMCS_GUEST_SS_SELECTOR_STR;
1076         case VMCS_GUEST_DS_SELECTOR:
1077             return VMCS_GUEST_DS_SELECTOR_STR;
1078         case VMCS_GUEST_FS_SELECTOR:
1079             return VMCS_GUEST_FS_SELECTOR_STR;
1080         case VMCS_GUEST_GS_SELECTOR:
1081             return VMCS_GUEST_GS_SELECTOR_STR;
1082         case VMCS_GUEST_LDTR_SELECTOR:
1083             return VMCS_GUEST_LDTR_SELECTOR_STR;
1084         case VMCS_GUEST_TR_SELECTOR:
1085             return VMCS_GUEST_TR_SELECTOR_STR;
1086         case VMCS_HOST_ES_SELECTOR:
1087             return VMCS_HOST_ES_SELECTOR_STR;
1088         case VMCS_HOST_CS_SELECTOR:
1089             return VMCS_HOST_CS_SELECTOR_STR;
1090         case VMCS_HOST_SS_SELECTOR:
1091             return VMCS_HOST_SS_SELECTOR_STR;
1092         case VMCS_HOST_DS_SELECTOR:
1093             return VMCS_HOST_DS_SELECTOR_STR;
1094         case VMCS_HOST_FS_SELECTOR:
1095             return VMCS_HOST_FS_SELECTOR_STR;
1096         case VMCS_HOST_GS_SELECTOR:
1097             return VMCS_HOST_GS_SELECTOR_STR;
1098         case VMCS_HOST_TR_SELECTOR:
1099             return VMCS_HOST_TR_SELECTOR_STR;
1100         case VMCS_IO_BITMAP_A_ADDR:
1101             return VMCS_IO_BITMAP_A_ADDR_STR;
1102         case VMCS_IO_BITMAP_A_ADDR_HIGH:
1103             return VMCS_IO_BITMAP_A_ADDR_HIGH_STR;
1104         case VMCS_IO_BITMAP_B_ADDR:
1105             return VMCS_IO_BITMAP_B_ADDR_STR;
1106         case VMCS_IO_BITMAP_B_ADDR_HIGH:
1107             return VMCS_IO_BITMAP_B_ADDR_HIGH_STR;
1108         case VMCS_MSR_BITMAP:
1109             return VMCS_MSR_BITMAP_STR;
1110         case VMCS_MSR_BITMAP_HIGH:
1111             return VMCS_MSR_BITMAP_HIGH_STR;
1112         case VMCS_EXIT_MSR_STORE_ADDR:
1113             return VMCS_EXIT_MSR_STORE_ADDR_STR;
1114         case VMCS_EXIT_MSR_STORE_ADDR_HIGH:
1115             return VMCS_EXIT_MSR_STORE_ADDR_HIGH_STR;
1116         case VMCS_EXIT_MSR_LOAD_ADDR:
1117             return VMCS_EXIT_MSR_LOAD_ADDR_STR;
1118         case VMCS_EXIT_MSR_LOAD_ADDR_HIGH:
1119             return VMCS_EXIT_MSR_LOAD_ADDR_HIGH_STR;
1120         case VMCS_ENTRY_MSR_LOAD_ADDR:
1121             return VMCS_ENTRY_MSR_LOAD_ADDR_STR;
1122         case VMCS_ENTRY_MSR_LOAD_ADDR_HIGH:
1123             return VMCS_ENTRY_MSR_LOAD_ADDR_HIGH_STR;
1124         case VMCS_EXEC_PTR:
1125             return VMCS_EXEC_PTR_STR;
1126         case VMCS_EXEC_PTR_HIGH:
1127             return VMCS_EXEC_PTR_HIGH_STR;
1128         case VMCS_TSC_OFFSET:
1129             return VMCS_TSC_OFFSET_STR;
1130         case VMCS_TSC_OFFSET_HIGH:
1131             return VMCS_TSC_OFFSET_HIGH_STR;
1132         case VMCS_VAPIC_ADDR:
1133             return VMCS_VAPIC_ADDR_STR;
1134         case VMCS_VAPIC_ADDR_HIGH:
1135             return VMCS_VAPIC_ADDR_HIGH_STR;
1136         case VMCS_APIC_ACCESS_ADDR:
1137             return VMCS_APIC_ACCESS_ADDR_STR;
1138         case VMCS_APIC_ACCESS_ADDR_HIGH:
1139             return VMCS_APIC_ACCESS_ADDR_HIGH_STR;
1140         case VMCS_LINK_PTR:
1141             return VMCS_LINK_PTR_STR;
1142         case VMCS_LINK_PTR_HIGH:
1143             return VMCS_LINK_PTR_HIGH_STR;
1144         case VMCS_GUEST_DBG_CTL:
1145             return VMCS_GUEST_DBG_CTL_STR;
1146         case VMCS_GUEST_DBG_CTL_HIGH:
1147             return VMCS_GUEST_DBG_CTL_HIGH_STR;
1148         case VMCS_GUEST_PERF_GLOBAL_CTRL:
1149             return VMCS_GUEST_PERF_GLOBAL_CTRL_STR;
1150         case VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH:
1151             return VMCS_GUEST_PERF_GLOBAL_CTRL_HIGH_STR;
1152         case VMCS_HOST_PERF_GLOBAL_CTRL:
1153             return VMCS_HOST_PERF_GLOBAL_CTRL_STR;
1154         case VMCS_HOST_PERF_GLOBAL_CTRL_HIGH:
1155             return VMCS_HOST_PERF_GLOBAL_CTRL_HIGH_STR;
1156         case VMCS_PIN_CTRLS:
1157             return VMCS_PIN_CTRLS_STR;
1158         case VMCS_PROC_CTRLS:
1159             return VMCS_PROC_CTRLS_STR;
1160         case VMCS_EXCP_BITMAP:
1161             return VMCS_EXCP_BITMAP_STR;
1162         case VMCS_PG_FAULT_ERR_MASK:
1163             return VMCS_PG_FAULT_ERR_MASK_STR;
1164         case VMCS_PG_FAULT_ERR_MATCH:
1165             return VMCS_PG_FAULT_ERR_MATCH_STR;
1166         case VMCS_CR3_TGT_CNT:
1167             return VMCS_CR3_TGT_CNT_STR;
1168         case VMCS_EXIT_CTRLS:
1169             return VMCS_EXIT_CTRLS_STR;
1170         case VMCS_EXIT_MSR_STORE_CNT:
1171             return VMCS_EXIT_MSR_STORE_CNT_STR;
1172         case VMCS_EXIT_MSR_LOAD_CNT:
1173             return VMCS_EXIT_MSR_LOAD_CNT_STR;
1174         case VMCS_ENTRY_CTRLS:
1175             return VMCS_ENTRY_CTRLS_STR;
1176         case VMCS_ENTRY_MSR_LOAD_CNT:
1177             return VMCS_ENTRY_MSR_LOAD_CNT_STR;
1178         case VMCS_ENTRY_INT_INFO:
1179             return VMCS_ENTRY_INT_INFO_STR;
1180         case VMCS_ENTRY_EXCP_ERR:
1181             return VMCS_ENTRY_EXCP_ERR_STR;
1182         case VMCS_ENTRY_INSTR_LEN:
1183             return VMCS_ENTRY_INSTR_LEN_STR;
1184         case VMCS_TPR_THRESHOLD:
1185             return VMCS_TPR_THRESHOLD_STR;
1186         case VMCS_SEC_PROC_CTRLS:
1187             return VMCS_SEC_PROC_CTRLS_STR;
1188         case VMCS_INSTR_ERR:
1189             return VMCS_INSTR_ERR_STR;
1190         case VMCS_EXIT_REASON:
1191             return VMCS_EXIT_REASON_STR;
1192         case VMCS_EXIT_INT_INFO:
1193             return VMCS_EXIT_INT_INFO_STR;
1194         case VMCS_EXIT_INT_ERR:
1195             return VMCS_EXIT_INT_ERR_STR;
1196         case VMCS_IDT_VECTOR_INFO:
1197             return VMCS_IDT_VECTOR_INFO_STR;
1198         case VMCS_IDT_VECTOR_ERR:
1199             return VMCS_IDT_VECTOR_ERR_STR;
1200         case VMCS_EXIT_INSTR_LEN:
1201             return VMCS_EXIT_INSTR_LEN_STR;
1202         case VMCS_EXIT_INSTR_INFO:
1203             return VMCS_EXIT_INSTR_INFO_STR;
1204         case VMCS_GUEST_ES_LIMIT:
1205             return VMCS_GUEST_ES_LIMIT_STR;
1206         case VMCS_GUEST_CS_LIMIT:
1207             return VMCS_GUEST_CS_LIMIT_STR;
1208         case VMCS_GUEST_SS_LIMIT:
1209             return VMCS_GUEST_SS_LIMIT_STR;
1210         case VMCS_GUEST_DS_LIMIT:
1211             return VMCS_GUEST_DS_LIMIT_STR;
1212         case VMCS_GUEST_FS_LIMIT:
1213             return VMCS_GUEST_FS_LIMIT_STR;
1214         case VMCS_GUEST_GS_LIMIT:
1215             return VMCS_GUEST_GS_LIMIT_STR;
1216         case VMCS_GUEST_LDTR_LIMIT:
1217             return VMCS_GUEST_LDTR_LIMIT_STR;
1218         case VMCS_GUEST_TR_LIMIT:
1219             return VMCS_GUEST_TR_LIMIT_STR;
1220         case VMCS_GUEST_GDTR_LIMIT:
1221             return VMCS_GUEST_GDTR_LIMIT_STR;
1222         case VMCS_GUEST_IDTR_LIMIT:
1223             return VMCS_GUEST_IDTR_LIMIT_STR;
1224         case VMCS_GUEST_ES_ACCESS:
1225             return VMCS_GUEST_ES_ACCESS_STR;
1226         case VMCS_GUEST_CS_ACCESS:
1227             return VMCS_GUEST_CS_ACCESS_STR;
1228         case VMCS_GUEST_SS_ACCESS:
1229             return VMCS_GUEST_SS_ACCESS_STR;
1230         case VMCS_GUEST_DS_ACCESS:
1231             return VMCS_GUEST_DS_ACCESS_STR;
1232         case VMCS_GUEST_FS_ACCESS:
1233             return VMCS_GUEST_FS_ACCESS_STR;
1234         case VMCS_GUEST_GS_ACCESS:
1235             return VMCS_GUEST_GS_ACCESS_STR;
1236         case VMCS_GUEST_LDTR_ACCESS:
1237             return VMCS_GUEST_LDTR_ACCESS_STR;
1238         case VMCS_GUEST_TR_ACCESS:
1239             return VMCS_GUEST_TR_ACCESS_STR;
1240         case VMCS_GUEST_INT_STATE:
1241             return VMCS_GUEST_INT_STATE_STR;
1242         case VMCS_GUEST_ACTIVITY_STATE:
1243             return VMCS_GUEST_ACTIVITY_STATE_STR;
1244         case VMCS_GUEST_SMBASE:
1245             return VMCS_GUEST_SMBASE_STR;
1246         case VMCS_GUEST_SYSENTER_CS:
1247             return VMCS_GUEST_SYSENTER_CS_STR;
1248         case VMCS_HOST_SYSENTER_CS:
1249             return VMCS_HOST_SYSENTER_CS_STR;
1250         case VMCS_CR0_MASK:
1251             return VMCS_CR0_MASK_STR;
1252         case VMCS_CR4_MASK:
1253             return VMCS_CR4_MASK_STR;
1254         case VMCS_CR0_READ_SHDW:
1255             return VMCS_CR0_READ_SHDW_STR;
1256         case VMCS_CR4_READ_SHDW:
1257             return VMCS_CR4_READ_SHDW_STR;
1258         case VMCS_CR3_TGT_VAL_0:
1259             return VMCS_CR3_TGT_VAL_0_STR;
1260         case VMCS_CR3_TGT_VAL_1:
1261             return VMCS_CR3_TGT_VAL_1_STR;
1262         case VMCS_CR3_TGT_VAL_2:
1263             return VMCS_CR3_TGT_VAL_2_STR;
1264         case VMCS_CR3_TGT_VAL_3:
1265             return VMCS_CR3_TGT_VAL_3_STR;
1266         case VMCS_EXIT_QUAL:
1267             return VMCS_EXIT_QUAL_STR;
1268         case VMCS_IO_RCX:
1269             return VMCS_IO_RCX_STR;
1270         case VMCS_IO_RSI:
1271             return VMCS_IO_RSI_STR;
1272         case VMCS_IO_RDI:
1273             return VMCS_IO_RDI_STR;
1274         case VMCS_IO_RIP:
1275             return VMCS_IO_RIP_STR;
1276         case VMCS_GUEST_LINEAR_ADDR:
1277             return VMCS_GUEST_LINEAR_ADDR_STR;
1278         case VMCS_GUEST_CR0:
1279             return VMCS_GUEST_CR0_STR;
1280         case VMCS_GUEST_CR3:
1281             return VMCS_GUEST_CR3_STR;
1282         case VMCS_GUEST_CR4:
1283             return VMCS_GUEST_CR4_STR;
1284         case VMCS_GUEST_ES_BASE:
1285             return VMCS_GUEST_ES_BASE_STR;
1286         case VMCS_GUEST_CS_BASE:
1287             return VMCS_GUEST_CS_BASE_STR;
1288         case VMCS_GUEST_SS_BASE:
1289             return VMCS_GUEST_SS_BASE_STR;
1290         case VMCS_GUEST_DS_BASE:
1291             return VMCS_GUEST_DS_BASE_STR;
1292         case VMCS_GUEST_FS_BASE:
1293             return VMCS_GUEST_FS_BASE_STR;
1294         case VMCS_GUEST_GS_BASE:
1295             return VMCS_GUEST_GS_BASE_STR;
1296         case VMCS_GUEST_LDTR_BASE:
1297             return VMCS_GUEST_LDTR_BASE_STR;
1298         case VMCS_GUEST_TR_BASE:
1299             return VMCS_GUEST_TR_BASE_STR;
1300         case VMCS_GUEST_GDTR_BASE:
1301             return VMCS_GUEST_GDTR_BASE_STR;
1302         case VMCS_GUEST_IDTR_BASE:
1303             return VMCS_GUEST_IDTR_BASE_STR;
1304         case VMCS_GUEST_DR7:
1305             return VMCS_GUEST_DR7_STR;
1306         case VMCS_GUEST_RSP:
1307             return VMCS_GUEST_RSP_STR;
1308         case VMCS_GUEST_RIP:
1309             return VMCS_GUEST_RIP_STR;
1310         case VMCS_GUEST_RFLAGS:
1311             return VMCS_GUEST_RFLAGS_STR;
1312         case VMCS_GUEST_PENDING_DBG_EXCP:
1313             return VMCS_GUEST_PENDING_DBG_EXCP_STR;
1314         case VMCS_GUEST_SYSENTER_ESP:
1315             return VMCS_GUEST_SYSENTER_ESP_STR;
1316         case VMCS_GUEST_SYSENTER_EIP:
1317             return VMCS_GUEST_SYSENTER_EIP_STR;
1318         case VMCS_HOST_CR0:
1319             return VMCS_HOST_CR0_STR;
1320         case VMCS_HOST_CR3:
1321             return VMCS_HOST_CR3_STR;
1322         case VMCS_HOST_CR4:
1323             return VMCS_HOST_CR4_STR;
1324         case VMCS_HOST_FS_BASE:
1325             return VMCS_HOST_FS_BASE_STR;
1326         case VMCS_HOST_GS_BASE:
1327             return VMCS_HOST_GS_BASE_STR;
1328         case VMCS_HOST_TR_BASE:
1329             return VMCS_HOST_TR_BASE_STR;
1330         case VMCS_HOST_GDTR_BASE:
1331             return VMCS_HOST_GDTR_BASE_STR;
1332         case VMCS_HOST_IDTR_BASE:
1333             return VMCS_HOST_IDTR_BASE_STR;
1334         case VMCS_HOST_SYSENTER_ESP:
1335             return VMCS_HOST_SYSENTER_ESP_STR;
1336         case VMCS_HOST_SYSENTER_EIP:
1337             return VMCS_HOST_SYSENTER_EIP_STR;
1338         case VMCS_HOST_RSP:
1339             return VMCS_HOST_RSP_STR;
1340         case VMCS_HOST_RIP:
1341             return VMCS_HOST_RIP_STR;
1342         default:
1343             return NULL;
1344     }
1345 }
1346
1347
1348