palacios/src/geekos/vmcs.c

   1 #include <geekos/vmcs.h>
   2 #include <geekos/serial.h>
   3
   4
   5
   6
   7 char *exception_names[] = {
   8   "#DE (Divide Error)",
   9   "#DB (Reserved)",
  10   "NMI",
  11   "#BP (Breakpoint)",
  12   "#OF (Overflow)",
  13   "#BR (BOUND Range Exceeded)",
  14   "#UD (Invalid Opcode)",
  15   "#NM (No Math Coprocessor)",
  16   "#DF (Double Fault)",
  17   "Coprocessor Segment Overrun",
  18   "#TS (Invalid TSS)",
  19   "#NP (Segment Not Present)",
  20   "#SS (Stack Segment Fault)",
  21   "#GP (General Protection Fault)",
  22   "#PF (Page Fault)",
  23   "(Reserved - 15)",
  24   "#MF (Math Fault x87)",
  25   "#AC (Alignment Check)",
  26   "#MC (Machine Check)",
  27   "#XF (SIMD FP Exception)",
  28   "(Reserved - 20)",
  29   "(Reserved - 21)",
  30   "(Reserved - 22)",
  31   "(Reserved - 23)",
  32   "(Reserved - 24)",
  33   "(Reserved - 25)",
  34   "(Reserved - 26)",
  35   "(Reserved - 27)",
  36   "(Reserved - 28)",
  37   "(Reserved - 29)",
  38   "(Reserved - 30)",
  39   "(Reserved - 31)",
  40   "USER 32",
  41   "USER 33",
  42   "USER 34",
  43   "USER 35",
  44   "USER 36",
  45   "USER 37",
  46   "USER 38",
  47   "USER 39",
  48   "USER 40",
  49   "USER 41",
  50   "USER 42",
  51   "USER 43",
  52   "USER 44",
  53   "USER 45",
  54   "USER 46",
  55   "USER 47",
  56   "USER 48",
  57   "USER 49",
  58   "USER 50",
  59   "USER 51",
  60   "USER 52",
  61   "USER 53",
  62   "USER 54",
  63   "USER 55",
  64   "USER 56",
  65   "USER 57",
  66   "USER 58",
  67   "USER 59",
  68   "USER 60",
  69   "USER 61",
  70   "USER 62",
  71   "USER 63",
  72   "USER 64",
  73   "USER 65",
  74   "USER 66",
  75   "USER 67",
  76   "USER 68",
  77   "USER 69",
  78   "USER 70",
  79   "USER 71",
  80   "USER 72",
  81   "USER 73",
  82   "USER 74",
  83   "USER 75",
  84   "USER 76",
  85   "USER 77",
  86   "USER 78",
  87   "USER 79",
  88   "USER 80",
  89   "USER 81",
  90   "USER 82",
  91   "USER 83",
  92   "USER 84",
  93   "USER 85",
  94   "USER 86",
  95   "USER 87",
  96   "USER 88",
  97   "USER 89",
  98   "USER 90",
  99   "USER 91",
 100   "USER 92",
 101   "USER 93",
 102   "USER 94",
 103   "USER 95",
 104   "USER 96",
 105   "USER 97",
 106   "USER 98",
 107   "USER 99",
 108   "USER 100",
 109   "USER 101",
 110   "USER 102",
 111   "USER 103",
 112   "USER 104",
 113   "USER 105",
 114   "USER 106",
 115   "USER 107",
 116   "USER 108",
 117   "USER 109",
 118   "USER 110",
 119   "USER 111",
 120   "USER 112",
 121   "USER 113",
 122   "USER 114",
 123   "USER 115",
 124   "USER 116",
 125   "USER 117",
 126   "USER 118",
 127   "USER 119",
 128   "USER 120",
 129   "USER 121",
 130   "USER 122",
 131   "USER 123",
 132   "USER 124",
 133   "USER 125",
 134   "USER 126",
 135   "USER 127",
 136   "USER 128",
 137   "USER 129",
 138   "USER 130",
 139   "USER 131",
 140   "USER 132",
 141   "USER 133",
 142   "USER 134",
 143   "USER 135",
 144   "USER 136",
 145   "USER 137",
 146   "USER 138",
 147   "USER 139",
 148   "USER 140",
 149   "USER 141",
 150   "USER 142",
 151   "USER 143",
 152   "USER 144",
 153   "USER 145",
 154   "USER 146",
 155   "USER 147",
 156   "USER 148",
 157   "USER 149",
 158   "USER 150",
 159   "USER 151",
 160   "USER 152",
 161   "USER 153",
 162   "USER 154",
 163   "USER 155",
 164   "USER 156",
 165   "USER 157",
 166   "USER 158",
 167   "USER 159",
 168   "USER 160",
 169   "USER 161",
 170   "USER 162",
 171   "USER 163",
 172   "USER 164",
 173   "USER 165",
 174   "USER 166",
 175   "USER 167",
 176   "USER 168",
 177   "USER 169",
 178   "USER 170",
 179   "USER 171",
 180   "USER 172",
 181   "USER 173",
 182   "USER 174",
 183   "USER 175",
 184   "USER 176",
 185   "USER 177",
 186   "USER 178",
 187   "USER 179",
 188   "USER 180",
 189   "USER 181",
 190   "USER 182",
 191   "USER 183",
 192   "USER 184",
 193   "USER 185",
 194   "USER 186",
 195   "USER 187",
 196   "USER 188",
 197   "USER 189",
 198   "USER 190",
 199   "USER 191",
 200   "USER 192",
 201   "USER 193",
 202   "USER 194",
 203   "USER 195",
 204   "USER 196",
 205   "USER 197",
 206   "USER 198",
 207   "USER 199",
 208   "USER 200",
 209   "USER 201",
 210   "USER 202",
 211   "USER 203",
 212   "USER 204",
 213   "USER 205",
 214   "USER 206",
 215   "USER 207",
 216   "USER 208",
 217   "USER 209",
 218   "USER 210",
 219   "USER 211",
 220   "USER 212",
 221   "USER 213",
 222   "USER 214",
 223   "USER 215",
 224   "USER 216",
 225   "USER 217",
 226   "USER 218",
 227   "USER 219",
 228   "USER 220",
 229   "USER 221",
 230   "USER 222",
 231   "USER 223",
 232   "USER 224",
 233   "USER 225",
 234   "USER 226",
 235   "USER 227",
 236   "USER 228",
 237   "USER 229",
 238   "USER 230",
 239   "USER 231",
 240   "USER 232",
 241   "USER 233",
 242   "USER 234",
 243   "USER 235",
 244   "USER 236",
 245   "USER 237",
 246   "USER 238",
 247   "USER 239",
 248   "USER 240",
 249   "USER 241",
 250   "USER 242",
 251   "USER 243",
 252   "USER 244",
 253   "USER 245",
 254   "USER 246",
 255   "USER 247",
 256   "USER 248",
 257   "USER 249",
 258   "USER 250",
 259   "USER 251",
 260   "USER 252",
 261   "USER 253",
 262   "USER 254",
 263   "USER 255",
 264 };
 265
 266 char *exception_type_names[] = {
 267   "External Interrupt",
 268   "NOT USED",
 269   "NMI",
 270   "Hardware Exception",
 271   "NOT USED",
 272   "NOT USED",
 273   "Software Exception",
 274   "NOT USED"
 275 };
 276
 277 //
 278 // Ignores "HIGH" addresses - 32 bit only for now
 279 //
 280
 281
 282 #define CHK_VMCS_READ(tag, val) {if (VMCS_READ(tag, val) != 0) return -1;}
 283 #define CHK_VMCS_WRITE(tag, val) {if (VMCS_WRITE(tag, val) != 0) return -1;}
 284
 285
 286
 287 int CopyOutVMCSGuestStateArea(struct VMCSGuestStateArea *p) {
 288   CHK_VMCS_READ(GUEST_CR0, &(p->cr0));
 289   CHK_VMCS_READ(GUEST_CR3, &(p->cr3));
 290   CHK_VMCS_READ(GUEST_CR4, &(p->cr4));
 291   CHK_VMCS_READ(GUEST_DR7, &(p->dr7));
 292   CHK_VMCS_READ(GUEST_RSP, &(p->rsp));
 293   CHK_VMCS_READ(GUEST_RIP, &(p->rip));
 294   CHK_VMCS_READ(GUEST_RFLAGS, &(p->rflags));
 295   CHK_VMCS_READ(VMCS_GUEST_CS_SELECTOR, &(p->cs.selector));
 296   CHK_VMCS_READ(VMCS_GUEST_SS_SELECTOR, &(p->ss.selector));
 297   CHK_VMCS_READ(VMCS_GUEST_DS_SELECTOR, &(p->ds.selector));
 298   CHK_VMCS_READ(VMCS_GUEST_ES_SELECTOR, &(p->es.selector));
 299   CHK_VMCS_READ(VMCS_GUEST_FS_SELECTOR, &(p->fs.selector));
 300   CHK_VMCS_READ(VMCS_GUEST_GS_SELECTOR, &(p->gs.selector));
 301   CHK_VMCS_READ(VMCS_GUEST_LDTR_SELECTOR, &(p->ldtr.selector));
 302   CHK_VMCS_READ(VMCS_GUEST_TR_SELECTOR, &(p->tr.selector));
 303   CHK_VMCS_READ(GUEST_CS_BASE, &(p->cs.baseAddr));
 304   CHK_VMCS_READ(GUEST_SS_BASE, &(p->ss.baseAddr));
 305   CHK_VMCS_READ(GUEST_DS_BASE, &(p->ds.baseAddr));
 306   CHK_VMCS_READ(GUEST_ES_BASE, &(p->es.baseAddr));
 307   CHK_VMCS_READ(GUEST_FS_BASE, &(p->fs.baseAddr));
 308   CHK_VMCS_READ(GUEST_GS_BASE, &(p->gs.baseAddr));
 309   CHK_VMCS_READ(GUEST_LDTR_BASE, &(p->ldtr.baseAddr));
 310   CHK_VMCS_READ(GUEST_TR_BASE, &(p->tr.baseAddr));
 311   CHK_VMCS_READ(GUEST_CS_LIMIT, &(p->cs.limit));
 312   CHK_VMCS_READ(GUEST_SS_LIMIT, &(p->ss.limit));
 313   CHK_VMCS_READ(GUEST_DS_LIMIT, &(p->ds.limit));
 314   CHK_VMCS_READ(GUEST_ES_LIMIT, &(p->es.limit));
 315   CHK_VMCS_READ(GUEST_FS_LIMIT, &(p->fs.limit));
 316   CHK_VMCS_READ(GUEST_GS_LIMIT, &(p->gs.limit));
 317   CHK_VMCS_READ(GUEST_LDTR_LIMIT, &(p->ldtr.limit));
 318   CHK_VMCS_READ(GUEST_TR_LIMIT, &(p->tr.limit));
 319   CHK_VMCS_READ(GUEST_CS_ACCESS, &(p->cs.access));
 320   CHK_VMCS_READ(GUEST_SS_ACCESS, &(p->ss.access));
 321   CHK_VMCS_READ(GUEST_DS_ACCESS, &(p->ds.access));
 322   CHK_VMCS_READ(GUEST_ES_ACCESS, &(p->es.access));
 323   CHK_VMCS_READ(GUEST_FS_ACCESS, &(p->fs.access));
 324   CHK_VMCS_READ(GUEST_GS_ACCESS, &(p->gs.access));
 325   CHK_VMCS_READ(GUEST_LDTR_ACCESS, &(p->ldtr.access));
 326   CHK_VMCS_READ(GUEST_TR_ACCESS, &(p->tr.access));
 327   CHK_VMCS_READ(GUEST_GDTR_BASE, &(p->gdtr.baseAddr));
 328   CHK_VMCS_READ(GUEST_IDTR_BASE, &(p->idtr.baseAddr));
 329   CHK_VMCS_READ(GUEST_GDTR_LIMIT, &(p->gdtr.limit));
 330   CHK_VMCS_READ(GUEST_IDTR_LIMIT, &(p->idtr.limit));
 331   CHK_VMCS_READ(GUEST_IA32_DEBUGCTL, &(p->dbg_ctrl));
 332   CHK_VMCS_READ(GUEST_IA32_DEBUGCTL_HIGH, ((char *)&(p->dbg_ctrl)) + 4);
 333   CHK_VMCS_READ(GUEST_IA32_SYSENTER_CS, &(p->sysenter_cs));
 334   CHK_VMCS_READ(GUEST_IA32_SYSENTER_ESP, &(p->sysenter_esp));
 335   CHK_VMCS_READ(GUEST_IA32_SYSENTER_EIP, &(p->sysenter_eip));
 336   CHK_VMCS_READ(GUEST_SMBASE, &(p->smbase));
 337
 338   CHK_VMCS_READ(GUEST_ACTIVITY_STATE, &(p->activity));
 339   CHK_VMCS_READ(GUEST_INT_STATE, &(p->interrupt_state));
 340   CHK_VMCS_READ(GUEST_PENDING_DEBUG_EXCS, &(p->pending_dbg_exceptions));
 341   CHK_VMCS_READ(VMCS_LINK_PTR, &(p->vmcs_link));
 342   CHK_VMCS_READ(VMCS_LINK_PTR_HIGH, ((char *)&(p->vmcs_link)) + 4);
 343   return 0;
 344 }
 345
 346
 347 int CopyInVMCSGuestStateArea(struct VMCSGuestStateArea *p) {
 348   CHK_VMCS_WRITE(GUEST_CR0, &(p->cr0));
 349   CHK_VMCS_WRITE(GUEST_CR3, &(p->cr3));
 350   CHK_VMCS_WRITE(GUEST_CR4, &(p->cr4));
 351   CHK_VMCS_WRITE(GUEST_DR7, &(p->dr7));
 352   CHK_VMCS_WRITE(GUEST_RSP, &(p->rsp));
 353   CHK_VMCS_WRITE(GUEST_RIP, &(p->rip));
 354   CHK_VMCS_WRITE(GUEST_RFLAGS, &(p->rflags));
 355   CHK_VMCS_WRITE(VMCS_GUEST_CS_SELECTOR, &(p->cs.selector));
 356   CHK_VMCS_WRITE(VMCS_GUEST_SS_SELECTOR, &(p->ss.selector));
 357   CHK_VMCS_WRITE(VMCS_GUEST_DS_SELECTOR, &(p->ds.selector));
 358   CHK_VMCS_WRITE(VMCS_GUEST_ES_SELECTOR, &(p->es.selector));
 359   CHK_VMCS_WRITE(VMCS_GUEST_FS_SELECTOR, &(p->fs.selector));
 360   CHK_VMCS_WRITE(VMCS_GUEST_GS_SELECTOR, &(p->gs.selector));
 361   CHK_VMCS_WRITE(VMCS_GUEST_LDTR_SELECTOR, &(p->ldtr.selector));
 362   CHK_VMCS_WRITE(VMCS_GUEST_TR_SELECTOR, &(p->tr.selector));
 363   CHK_VMCS_WRITE(GUEST_CS_BASE, &(p->cs.baseAddr));
 364   CHK_VMCS_WRITE(GUEST_SS_BASE, &(p->ss.baseAddr));
 365   CHK_VMCS_WRITE(GUEST_DS_BASE, &(p->ds.baseAddr));
 366   CHK_VMCS_WRITE(GUEST_ES_BASE, &(p->es.baseAddr));
 367   CHK_VMCS_WRITE(GUEST_FS_BASE, &(p->fs.baseAddr));
 368   CHK_VMCS_WRITE(GUEST_GS_BASE, &(p->gs.baseAddr));
 369   CHK_VMCS_WRITE(GUEST_LDTR_BASE, &(p->ldtr.baseAddr));
 370   CHK_VMCS_WRITE(GUEST_TR_BASE, &(p->tr.baseAddr));
 371   CHK_VMCS_WRITE(GUEST_CS_LIMIT, &(p->cs.limit));
 372   CHK_VMCS_WRITE(GUEST_SS_LIMIT, &(p->ss.limit));
 373   CHK_VMCS_WRITE(GUEST_DS_LIMIT, &(p->ds.limit));
 374   CHK_VMCS_WRITE(GUEST_ES_LIMIT, &(p->es.limit));
 375   CHK_VMCS_WRITE(GUEST_FS_LIMIT, &(p->fs.limit));
 376   CHK_VMCS_WRITE(GUEST_GS_LIMIT, &(p->gs.limit));
 377   CHK_VMCS_WRITE(GUEST_LDTR_LIMIT, &(p->ldtr.limit));
 378   CHK_VMCS_WRITE(GUEST_TR_LIMIT, &(p->tr.limit));
 379   CHK_VMCS_WRITE(GUEST_CS_ACCESS, &(p->cs.access));
 380   CHK_VMCS_WRITE(GUEST_SS_ACCESS, &(p->ss.access));
 381   CHK_VMCS_WRITE(GUEST_DS_ACCESS, &(p->ds.access));
 382   CHK_VMCS_WRITE(GUEST_ES_ACCESS, &(p->es.access));
 383   CHK_VMCS_WRITE(GUEST_FS_ACCESS, &(p->fs.access));
 384   CHK_VMCS_WRITE(GUEST_GS_ACCESS, &(p->gs.access));
 385   CHK_VMCS_WRITE(GUEST_LDTR_ACCESS, &(p->ldtr.access));
 386   CHK_VMCS_WRITE(GUEST_TR_ACCESS, &(p->tr.access));
 387   CHK_VMCS_WRITE(GUEST_GDTR_BASE, &(p->gdtr.baseAddr));
 388   CHK_VMCS_WRITE(GUEST_IDTR_BASE, &(p->idtr.baseAddr));
 389   CHK_VMCS_WRITE(GUEST_GDTR_LIMIT, &(p->gdtr.limit));
 390   CHK_VMCS_WRITE(GUEST_IDTR_LIMIT, &(p->idtr.limit));
 391   CHK_VMCS_WRITE(GUEST_IA32_DEBUGCTL, &(p->dbg_ctrl));
 392   CHK_VMCS_WRITE(GUEST_IA32_DEBUGCTL_HIGH, ((char *)&(p->dbg_ctrl)) + 4);
 393   CHK_VMCS_WRITE(GUEST_IA32_SYSENTER_CS, &(p->sysenter_cs));
 394   CHK_VMCS_WRITE(GUEST_IA32_SYSENTER_ESP, &(p->sysenter_esp));
 395   CHK_VMCS_WRITE(GUEST_IA32_SYSENTER_EIP, &(p->sysenter_eip));
 396   CHK_VMCS_WRITE(GUEST_SMBASE, &(p->smbase));
 397
 398   CHK_VMCS_WRITE(GUEST_ACTIVITY_STATE, &(p->activity));
 399   CHK_VMCS_WRITE(GUEST_INT_STATE, &(p->interrupt_state));
 400   CHK_VMCS_WRITE(GUEST_PENDING_DEBUG_EXCS, &(p->pending_dbg_exceptions));
 401   CHK_VMCS_WRITE(VMCS_LINK_PTR, &(p->vmcs_link));
 402   CHK_VMCS_WRITE(VMCS_LINK_PTR_HIGH, ((char *)&(p->vmcs_link)) + 4);
 403   return 0;
 404 }
 405
 406
 407
 408 int CopyOutVMCSHostStateArea(struct VMCSHostStateArea *p) {
 409   CHK_VMCS_READ(HOST_CR0, &(p->cr0));
 410   CHK_VMCS_READ(HOST_CR3, &(p->cr3));
 411   CHK_VMCS_READ(HOST_CR4, &(p->cr4));
 412   CHK_VMCS_READ(HOST_RSP, &(p->rsp));
 413   CHK_VMCS_READ(HOST_RIP, &(p->rip));
 414   CHK_VMCS_READ(VMCS_HOST_CS_SELECTOR, &(p->csSelector));
 415   CHK_VMCS_READ(VMCS_HOST_SS_SELECTOR, &(p->ssSelector));
 416   CHK_VMCS_READ(VMCS_HOST_DS_SELECTOR, &(p->dsSelector));
 417   CHK_VMCS_READ(VMCS_HOST_ES_SELECTOR, &(p->esSelector));
 418   CHK_VMCS_READ(VMCS_HOST_FS_SELECTOR, &(p->fsSelector));
 419   CHK_VMCS_READ(VMCS_HOST_GS_SELECTOR, &(p->gsSelector));
 420   CHK_VMCS_READ(VMCS_HOST_TR_SELECTOR, &(p->trSelector));
 421   CHK_VMCS_READ(HOST_FS_BASE, &(p->fsBaseAddr));
 422   CHK_VMCS_READ(HOST_GS_BASE, &(p->gsBaseAddr));
 423   CHK_VMCS_READ(HOST_TR_BASE, &(p->trBaseAddr));
 424   CHK_VMCS_READ(HOST_GDTR_BASE, &(p->gdtrBaseAddr));
 425   CHK_VMCS_READ(HOST_IDTR_BASE, &(p->idtrBaseAddr));
 426   CHK_VMCS_READ(HOST_IA32_SYSENTER_CS, &(p->sysenter_cs));
 427   CHK_VMCS_READ(HOST_IA32_SYSENTER_ESP, &(p->sysenter_esp));
 428   CHK_VMCS_READ(HOST_IA32_SYSENTER_EIP, &(p->sysenter_eip));
 429   return 0;
 430 }
 431
 432
 433
 434 int CopyInVMCSHostStateArea(struct VMCSHostStateArea *p) {
 435   CHK_VMCS_WRITE(HOST_CR0, &(p->cr0));
 436   CHK_VMCS_WRITE(HOST_CR3, &(p->cr3));
 437   CHK_VMCS_WRITE(HOST_CR4, &(p->cr4));
 438   CHK_VMCS_WRITE(HOST_RSP, &(p->rsp));
 439   CHK_VMCS_WRITE(HOST_RIP, &(p->rip));
 440   CHK_VMCS_WRITE(VMCS_HOST_CS_SELECTOR, &(p->csSelector));
 441   CHK_VMCS_WRITE(VMCS_HOST_SS_SELECTOR, &(p->ssSelector));
 442   CHK_VMCS_WRITE(VMCS_HOST_DS_SELECTOR, &(p->dsSelector));
 443   CHK_VMCS_WRITE(VMCS_HOST_ES_SELECTOR, &(p->esSelector));
 444   CHK_VMCS_WRITE(VMCS_HOST_FS_SELECTOR, &(p->fsSelector));
 445   CHK_VMCS_WRITE(VMCS_HOST_GS_SELECTOR, &(p->gsSelector));
 446   CHK_VMCS_WRITE(VMCS_HOST_TR_SELECTOR, &(p->trSelector));
 447   CHK_VMCS_WRITE(HOST_FS_BASE, &(p->fsBaseAddr));
 448   CHK_VMCS_WRITE(HOST_GS_BASE, &(p->gsBaseAddr));
 449   CHK_VMCS_WRITE(HOST_TR_BASE, &(p->trBaseAddr));
 450   CHK_VMCS_WRITE(HOST_GDTR_BASE, &(p->gdtrBaseAddr));
 451   CHK_VMCS_WRITE(HOST_IDTR_BASE, &(p->idtrBaseAddr));
 452   CHK_VMCS_WRITE(HOST_IA32_SYSENTER_CS, &(p->sysenter_cs));
 453   CHK_VMCS_WRITE(HOST_IA32_SYSENTER_ESP, &(p->sysenter_esp));
 454   CHK_VMCS_WRITE(HOST_IA32_SYSENTER_EIP, &(p->sysenter_eip));
 455   return 0;
 456 }
 457
 458
 459 int CopyOutVMCSExitCtrlFields(struct VMCSExitCtrlFields *p)
 460 {
 461   CHK_VMCS_READ(VM_EXIT_CTRLS,&(p->exitCtrls));
 462   CHK_VMCS_READ(VM_EXIT_MSR_STORE_COUNT,&(p->msrStoreCount));
 463   CHK_VMCS_READ(VM_EXIT_MSR_STORE_ADDR,&(p->msrStoreAddr));
 464   CHK_VMCS_READ(VM_EXIT_MSR_LOAD_COUNT,&(p->msrLoadCount));
 465   CHK_VMCS_READ(VM_EXIT_MSR_LOAD_ADDR,&(p->msrLoadAddr));
 466   return 0;
 467 }
 468
 469 int CopyInVMCSExitCtrlFields(struct VMCSExitCtrlFields *p)
 470 {
 471   CHK_VMCS_WRITE(VM_EXIT_CTRLS,&(p->exitCtrls));
 472   CHK_VMCS_WRITE(VM_EXIT_MSR_STORE_COUNT,&(p->msrStoreCount));
 473   CHK_VMCS_WRITE(VM_EXIT_MSR_STORE_ADDR,&(p->msrStoreAddr));
 474   CHK_VMCS_WRITE(VM_EXIT_MSR_LOAD_COUNT,&(p->msrLoadCount));
 475   CHK_VMCS_WRITE(VM_EXIT_MSR_LOAD_ADDR,&(p->msrLoadAddr));
 476   return 0;
 477 }
 478
 479
 480 int CopyOutVMCSEntryCtrlFields(struct VMCSEntryCtrlFields *p)
 481 {
 482   CHK_VMCS_READ(VM_ENTRY_CTRLS,&(p->entryCtrls));
 483   CHK_VMCS_READ(VM_ENTRY_MSR_LOAD_COUNT,&(p->msrLoadCount));
 484   CHK_VMCS_READ(VM_ENTRY_MSR_LOAD_ADDR,&(p->msrLoadAddr));
 485   CHK_VMCS_READ(VM_ENTRY_INT_INFO_FIELD,&(p->intInfo));
 486   CHK_VMCS_READ(VM_ENTRY_EXCEPTION_ERROR,&(p->exceptionErrorCode));
 487   CHK_VMCS_READ(VM_ENTRY_INSTR_LENGTH,&(p->instrLength));
 488   return 0;
 489 }
 490
 491 int CopyInVMCSEntryCtrlFields(struct VMCSEntryCtrlFields *p)
 492 {
 493   CHK_VMCS_WRITE(VM_ENTRY_CTRLS,&(p->entryCtrls));
 494   CHK_VMCS_WRITE(VM_ENTRY_MSR_LOAD_COUNT,&(p->msrLoadCount));
 495   CHK_VMCS_WRITE(VM_ENTRY_MSR_LOAD_ADDR,&(p->msrLoadAddr));
 496   CHK_VMCS_WRITE(VM_ENTRY_INT_INFO_FIELD,&(p->intInfo));
 497   CHK_VMCS_WRITE(VM_ENTRY_EXCEPTION_ERROR,&(p->exceptionErrorCode));
 498   CHK_VMCS_WRITE(VM_ENTRY_INSTR_LENGTH,&(p->instrLength));
 499   return 0;
 500 }
 501
 502 int CopyOutVMCSExitInfoFields(struct VMCSExitInfoFields *p) {
 503   CHK_VMCS_READ(EXIT_REASON,&(p->reason));
 504   CHK_VMCS_READ(EXIT_QUALIFICATION,&(p->qualification));
 505   CHK_VMCS_READ(VM_EXIT_INT_INFO,&(p->intInfo));
 506   CHK_VMCS_READ(VM_EXIT_INT_ERROR,&(p->intErrorCode));
 507   CHK_VMCS_READ(IDT_VECTOR_INFO,&(p->idtVectorInfo));
 508   CHK_VMCS_READ(IDT_VECTOR_ERROR,&(p->idtVectorErrorCode));
 509   CHK_VMCS_READ(VM_EXIT_INSTR_LENGTH,&(p->instrLength));
 510   CHK_VMCS_READ(GUEST_LINEAR_ADDR,&(p->guestLinearAddr));
 511   CHK_VMCS_READ(VMX_INSTR_INFO,&(p->instrInfo));
 512   CHK_VMCS_READ(IO_RCX,&(p->ioRCX));
 513   CHK_VMCS_READ(IO_RSI,&(p->ioRSI));
 514   CHK_VMCS_READ(IO_RDI,&(p->ioRDI));
 515   CHK_VMCS_READ(IO_RIP,&(p->ioRIP));
 516   CHK_VMCS_READ(VM_INSTR_ERROR,&(p->instrErrorField));
 517   return 0;
 518 }
 519
 520
 521 int CopyOutVMCSExecCtrlFields(struct VMCSExecCtrlFields *p)
 522 {
 523   CHK_VMCS_READ(PIN_VM_EXEC_CTRLS,&(p->pinCtrls));
 524   CHK_VMCS_READ(PROC_VM_EXEC_CTRLS,&(p->procCtrls));
 525   CHK_VMCS_READ(EXCEPTION_BITMAP,&(p->execBitmap));
 526   CHK_VMCS_READ(PAGE_FAULT_ERROR_MASK,&(p->pageFaultErrorMask));
 527   CHK_VMCS_READ(PAGE_FAULT_ERROR_MATCH,&(p->pageFaultErrorMatch));
 528   CHK_VMCS_READ(IO_BITMAP_A_ADDR,&(p->ioBitmapA));
 529   CHK_VMCS_READ(IO_BITMAP_B_ADDR,&(p->ioBitmapB));
 530   CHK_VMCS_READ(TSC_OFFSET,&(p->tscOffset));
 531   CHK_VMCS_READ(CR0_GUEST_HOST_MASK,&(p->cr0GuestHostMask));
 532   CHK_VMCS_READ(CR0_READ_SHADOW,&(p->cr0ReadShadow));
 533   CHK_VMCS_READ(CR4_GUEST_HOST_MASK,&(p->cr4GuestHostMask));
 534   CHK_VMCS_READ(CR4_READ_SHADOW,&(p->cr4ReadShadow));
 535   CHK_VMCS_READ(CR3_TARGET_COUNT, &(p->cr3TargetCount));
 536   CHK_VMCS_READ(CR3_TARGET_VALUE_0, &(p->cr3TargetValue0));
 537   CHK_VMCS_READ(CR3_TARGET_VALUE_1, &(p->cr3TargetValue1));
 538   CHK_VMCS_READ(CR3_TARGET_VALUE_2, &(p->cr3TargetValue2));
 539   CHK_VMCS_READ(CR3_TARGET_VALUE_3, &(p->cr3TargetValue3));
 540   CHK_VMCS_READ(VIRT_APIC_PAGE_ADDR, &(p->virtApicPageAddr));
 541   CHK_VMCS_READ(TPR_THRESHOLD, &(p->tprThreshold));
 542   CHK_VMCS_READ(MSR_BITMAPS, &(p->MSRBitmapsBaseAddr));
 543   CHK_VMCS_READ(VMCS_EXEC_PTR,&(p->vmcsExecPtr));
 544   return 0;
 545 }
 546
 547
 548 int CopyInVMCSExecCtrlFields(struct VMCSExecCtrlFields *p)
 549 {
 550   CHK_VMCS_WRITE(PIN_VM_EXEC_CTRLS,&(p->pinCtrls));
 551   CHK_VMCS_WRITE(PROC_VM_EXEC_CTRLS,&(p->procCtrls));
 552   CHK_VMCS_WRITE(EXCEPTION_BITMAP,&(p->execBitmap));
 553   CHK_VMCS_WRITE(PAGE_FAULT_ERROR_MASK,&(p->pageFaultErrorMask));
 554   CHK_VMCS_WRITE(PAGE_FAULT_ERROR_MATCH,&(p->pageFaultErrorMatch));
 555   CHK_VMCS_WRITE(IO_BITMAP_A_ADDR,&(p->ioBitmapA));
 556   CHK_VMCS_WRITE(IO_BITMAP_B_ADDR,&(p->ioBitmapB));
 557   CHK_VMCS_WRITE(TSC_OFFSET,&(p->tscOffset));
 558   CHK_VMCS_WRITE(CR0_GUEST_HOST_MASK,&(p->cr0GuestHostMask));
 559   CHK_VMCS_WRITE(CR0_READ_SHADOW,&(p->cr0ReadShadow));
 560   CHK_VMCS_WRITE(CR4_GUEST_HOST_MASK,&(p->cr4GuestHostMask));
 561   CHK_VMCS_WRITE(CR4_READ_SHADOW,&(p->cr4ReadShadow));
 562   CHK_VMCS_WRITE(CR3_TARGET_COUNT, &(p->cr3TargetCount));
 563   CHK_VMCS_WRITE(CR3_TARGET_VALUE_0, &(p->cr3TargetValue0));
 564   CHK_VMCS_WRITE(CR3_TARGET_VALUE_1, &(p->cr3TargetValue1));
 565   CHK_VMCS_WRITE(CR3_TARGET_VALUE_2, &(p->cr3TargetValue2));
 566   CHK_VMCS_WRITE(CR3_TARGET_VALUE_3, &(p->cr3TargetValue3));
 567   CHK_VMCS_WRITE(VIRT_APIC_PAGE_ADDR, &(p->virtApicPageAddr));
 568   CHK_VMCS_WRITE(TPR_THRESHOLD, &(p->tprThreshold));
 569   CHK_VMCS_WRITE(MSR_BITMAPS, &(p->MSRBitmapsBaseAddr));
 570   CHK_VMCS_WRITE(VMCS_EXEC_PTR,&(p->vmcsExecPtr));
 571   return 0;
 572 }
 573
 574
 575 int CopyOutVMCSData(struct VMCSData *p) {
 576   if (CopyOutVMCSGuestStateArea(&(p->guestStateArea)) != 0) {
 577     return -1;
 578   }
 579   if (CopyOutVMCSHostStateArea(&(p->hostStateArea)) != 0) {
 580     return -1;
 581   }
 582   if (CopyOutVMCSExecCtrlFields(&(p->execCtrlFields)) != 0) {
 583     return -1;
 584   }
 585   if (CopyOutVMCSExitCtrlFields(&(p->exitCtrlFields)) != 0) {
 586     return -1;
 587   }
 588   if (CopyOutVMCSEntryCtrlFields(&(p->entryCtrlFields)) != 0) {
 589     return -1;
 590   }
 591   if (CopyOutVMCSExitInfoFields(&(p->exitInfoFields)) != 0) {
 592     return -1;
 593   }
 594   return 0;
 595 }
 596
 597
 598 int CopyInVMCSData(struct VMCSData *p) {
 599   if (CopyInVMCSGuestStateArea(&(p->guestStateArea)) != 0) {
 600     return -1;
 601   }
 602   if (CopyInVMCSHostStateArea(&(p->hostStateArea)) != 0) {
 603     return -1;
 604   }
 605   if (CopyInVMCSExecCtrlFields(&(p->execCtrlFields)) != 0) {
 606     return -1;
 607   }
 608   if (CopyInVMCSExitCtrlFields(&(p->exitCtrlFields)) != 0) {
 609     return -1;
 610   }
 611   if (CopyInVMCSEntryCtrlFields(&(p->entryCtrlFields)) != 0) {
 612     return -1;
 613   }
 614   return 0;
 615 }
 616
 617
 618 void SerialPrint_VMX_Regs(struct VMXRegs * regs) {
 619   SerialPrint("==>VMX Register values:\n");
 620   SerialPrint("EAX: %x\n", regs->eax);
 621   SerialPrint("ECX: %x\n", regs->ecx);
 622   SerialPrint("EDX: %x\n", regs->edx);
 623   SerialPrint("EBX: %x\n", regs->ebx);
 624   SerialPrint("ESP: %x\n", regs->esp);
 625   SerialPrint("EBP: %x\n", regs->ebp);
 626   SerialPrint("ESI: %x\n", regs->esi);
 627   SerialPrint("EDI: %x\n", regs->edi);
 628   SerialPrint("\n");
 629 }
 630
 631
 632 void SerialPrint_VMCSSegment(char * segname, struct VMCSSegment * seg, int abbr) {
 633   SerialPrint("Segment: %s\n", segname);
 634   if (abbr == 0) {
 635     SerialPrint("\tSelector: %x\n", (uint_t)seg->selector);
 636     SerialPrint("\tAccess: %x\n", *(uint_t*)&(seg->access));
 637   }
 638   SerialPrint("\tBase Addr: %x\n", (uint_t)seg->baseAddr);
 639   SerialPrint("\tLimit: %x\n", (uint_t)seg->limit);
 640
 641 }
 642
 643
 644 void SerialPrint_VMCSGuestStateArea(struct VMCSGuestStateArea * guestState) {
 645   SerialPrint("==>Guest State Area\n");
 646   SerialPrint("==>==> Guest Register State\n");
 647   SerialPrint("GUEST_CR0: %x\n",(uint_t) guestState->cr0);
 648   SerialPrint("GUEST_CR3: %x\n",(uint_t)guestState->cr3);
 649   SerialPrint("GUEST_CR4: %x\n",(uint_t)guestState->cr4);
 650   SerialPrint("GUEST_DR7: %x\n",(uint_t)guestState->dr7);
 651   SerialPrint("GUEST_RSP: %x\n",(uint_t)guestState->rsp);
 652   SerialPrint("GUEST_RIP: %x\n",(uint_t)guestState->rip);
 653   SerialPrint("GUEST_RFLAGS: %x\n",(uint_t)guestState->rflags);
 654
 655   SerialPrint_VMCSSegment("Guest CS", &(guestState->cs), 0);
 656   SerialPrint_VMCSSegment("Guest SS", &(guestState->ss), 0);
 657   SerialPrint_VMCSSegment("Guest DS",&(guestState->ds), 0);
 658   SerialPrint_VMCSSegment("Guest ES", &(guestState->es), 0);
 659   SerialPrint_VMCSSegment("Guest FS", &(guestState->fs), 0);
 660   SerialPrint_VMCSSegment("Guest GS", &(guestState->gs), 0);
 661   SerialPrint_VMCSSegment("Guest LDTR", &(guestState->ldtr), 0);
 662   SerialPrint_VMCSSegment("Guest TR", &(guestState->tr), 0);
 663   SerialPrint_VMCSSegment("Guest GDTR", &(guestState->gdtr), 1);
 664   SerialPrint_VMCSSegment("Guest IDTR", &(guestState->idtr), 1);
 665
 666
 667   SerialPrint("GUEST_IA32_DEBUGCTL: %x\n",(uint_t)(guestState->dbg_ctrl & 0xffffffff));
 668   SerialPrint("GUEST_IA32_DEBUGCTL_HIGH: %x\n",(uint_t)(guestState->dbg_ctrl >> 32) & 0xffffffff);
 669   SerialPrint("GUEST_IA32_SYSENTER_CS: %x\n",guestState->sysenter_cs);
 670   SerialPrint("GUEST_IA32_SYSENTER_ESP: %x\n",(uint_t)guestState->sysenter_esp);
 671   SerialPrint("GUEST_IA32_SYSENTER_EIP: %x\n",(uint_t)guestState->sysenter_eip);
 672   SerialPrint("GUEST_SMBASE: %x\n", (uint_t)guestState->smbase);
 673
 674   SerialPrint("==>==> Guest Non-Register State\n");
 675   SerialPrint("GUEST_ACTIVITY_STATE: %x\n", (uint_t)guestState->activity);
 676   SerialPrint("GUEST_INT_STATE: %x\n", (uint_t)guestState->interrupt_state);
 677   SerialPrint("GUEST_PENDING_DEBUG_EXCS: %x\n", (uint_t)guestState->pending_dbg_exceptions);
 678   SerialPrint("VMCS_LINK_PTR: %x\n", (uint_t)guestState->vmcs_link & 0xffffffff);
 679   SerialPrint("VMCS_LINK_PTR_HIGH: %x\n", (uint_t)(guestState->vmcs_link >> 32) & 0xffffffff);
 680 }
 681
 682
 683 void SerialPrint_VMCSHostStateArea(struct VMCSHostStateArea * hostState) {
 684   SerialPrint("\n==> Host State Area\n");
 685   SerialPrint("HOST_CR0: %x\n", (uint_t)hostState->cr0);
 686   SerialPrint("HOST_CR3: %x\n", (uint_t)hostState->cr3);
 687   SerialPrint("HOST_CR4: %x\n", (uint_t)hostState->cr4);
 688   SerialPrint("HOST_RSP: %x\n", (uint_t)hostState->rsp);
 689   SerialPrint("HOST_RIP: %x\n", (uint_t)hostState->rip);
 690   SerialPrint("VMCS_HOST_CS_SELECTOR: %x\n", (uint_t)hostState->csSelector);
 691   SerialPrint("VMCS_HOST_SS_SELECTOR: %x\n", (uint_t)hostState->ssSelector);
 692   SerialPrint("VMCS_HOST_DS_SELECTOR: %x\n", (uint_t)hostState->dsSelector);
 693   SerialPrint("VMCS_HOST_ES_SELECTOR: %x\n", (uint_t)hostState->esSelector);
 694   SerialPrint("VMCS_HOST_FS_SELECTOR: %x\n", (uint_t)hostState->fsSelector);
 695   SerialPrint("VMCS_HOST_GS_SELECTOR: %x\n", (uint_t)hostState->gsSelector);
 696   SerialPrint("VMCS_HOST_TR_SELECTOR: %x\n", (uint_t)hostState->trSelector);
 697   SerialPrint("HOST_FS_BASE: %x\n", (uint_t)hostState->fsBaseAddr);
 698   SerialPrint("HOST_GS_BASE: %x\n", (uint_t)hostState->gsBaseAddr);
 699   SerialPrint("HOST_TR_BASE: %x\n", (uint_t)hostState->trBaseAddr);
 700   SerialPrint("HOST_GDTR_BASE: %x\n", (uint_t)hostState->gdtrBaseAddr);
 701   SerialPrint("HOST_IDTR_BASE: %x\n", (uint_t)hostState->idtrBaseAddr);
 702   SerialPrint("HOST_IA32_SYSENTER_CS: %x\n", (uint_t)hostState->sysenter_cs);
 703   SerialPrint("HOST_IA32_SYSENTER_ESP: %x\n", (uint_t)hostState->sysenter_esp);
 704   SerialPrint("HOST_IA32_SYSENTER_EIP: %x\n", (uint_t)hostState->sysenter_eip);
 705 }
 706
 707 void SerialPrint_VMCSExecCtrlFields(struct VMCSExecCtrlFields * execCtrls) {
 708   SerialPrint("\n==> VM-Execution Controls:\n");
 709   SerialPrint("PIN_VM_EXEC_CTRLS: %x\n", (uint_t) execCtrls->pinCtrls);
 710   SerialPrint("PROC_VM_EXEC_CTRLS: %x\n", (uint_t) execCtrls->procCtrls);
 711   SerialPrint("EXCEPTION_BITMAP: %x\n", (uint_t) execCtrls->execBitmap);
 712   SerialPrint("PAGE_FAULT_ERROR_MASK: %x\n", (uint_t) execCtrls->pageFaultErrorMask);
 713   SerialPrint("PAGE_FAULT_ERROR_MATCH: %x\n", (uint_t) execCtrls->pageFaultErrorMatch);
 714   SerialPrint("IO_BITMAP_A_ADDR: %x\n", (uint_t) execCtrls->ioBitmapA);
 715   //  SerialPrint("IO_BITMAP_A_ADDR_HIGH: %x\n", (uint_t) execCtrls->);
 716   SerialPrint("IO_BITMAP_B_ADDR: %x\n", (uint_t) execCtrls->ioBitmapB);
 717   // SerialPrint("IO_BITMAP_B_ADDR_HIGH: %x\n", (uint_t) execCtrls->);
 718   SerialPrint("TSC_OFFSET: %x\n", (uint_t) execCtrls->tscOffset & 0xffffffff);
 719   SerialPrint("TSC_OFFSET_HIGH: %x\n", (uint_t) (execCtrls->tscOffset >> 32) & 0xffffffff);
 720   SerialPrint("CR0_GUEST_HOST_MASK: %x\n", (uint_t) execCtrls->cr0GuestHostMask);
 721   SerialPrint("CR0_READ_SHADOW: %x\n", (uint_t) execCtrls->cr0ReadShadow);
 722   SerialPrint("CR4_GUEST_HOST_MASK: %x\n", (uint_t) execCtrls->cr4GuestHostMask);
 723   SerialPrint("CR4_READ_SHADOW: %x\n", (uint_t) execCtrls->cr4ReadShadow);
 724   SerialPrint("CR3_TARGET_COUNT: %x\n", (uint_t) execCtrls->cr3TargetCount);
 725   SerialPrint("CR3_TARGET_VALUE_0: %x\n", (uint_t) execCtrls->cr3TargetValue0);
 726   SerialPrint("CR3_TARGET_VALUE_1: %x\n", (uint_t) execCtrls->cr3TargetValue1);
 727   SerialPrint("CR3_TARGET_VALUE_2: %x\n", (uint_t) execCtrls->cr3TargetValue2);
 728   SerialPrint("CR3_TARGET_VALUE_3: %x\n", (uint_t) execCtrls->cr3TargetValue3);
 729   SerialPrint("VIRT_APIC_PAGE_ADDR: %x\n", (uint_t) execCtrls->virtApicPageAddr & 0xffffffff);
 730   SerialPrint("VIRT_APIC_PAGE_ADDR_HIGH: %x\n", (uint_t) (execCtrls->virtApicPageAddr >> 32) & 0xffffffff);
 731   SerialPrint("TPR_THRESHOLD: %x\n", (uint_t) execCtrls->tprThreshold);
 732   SerialPrint("MSR_BITMAPS: %x\n", (uint_t) execCtrls->MSRBitmapsBaseAddr & 0xffffffff);
 733   SerialPrint("MSR_BITMAPS_HIGH: %x\n", (uint_t) (execCtrls->MSRBitmapsBaseAddr >> 32) & 0xffffffff);
 734   SerialPrint("VMCS_EXEC_PTR: %x\n", (uint_t) execCtrls->vmcsExecPtr & 0xffffffff);
 735   SerialPrint("VMCS_EXEC_PTR_HIGH: %x\n", (uint_t) (execCtrls->vmcsExecPtr >> 32) & 0xffffffff);
 736 }
 737
 738 void SerialPrint_VMCSExitCtrlFields(struct VMCSExitCtrlFields * exitCtrls) {
 739   SerialPrint("\n==> VM Exit Controls\n");
 740   SerialPrint("VM_EXIT_CTRLS: %x\n", (uint_t) exitCtrls->exitCtrls);
 741   SerialPrint("VM_EXIT_MSR_STORE_COUNT: %x\n", (uint_t) exitCtrls->msrStoreCount);
 742   SerialPrint("VM_EXIT_MSR_STORE_ADDR: %x\n", (uint_t) exitCtrls->msrStoreAddr & 0xffffffff);
 743   SerialPrint("VM_EXIT_MSR_STORE_ADDR_HIGH: %x\n", (uint_t) (exitCtrls->msrStoreAddr >> 32) & 0xffffffff);
 744   SerialPrint("VM_EXIT_MSR_LOAD_COUNT: %x\n", (uint_t) exitCtrls->msrLoadCount);
 745   SerialPrint("VM_EXIT_MSR_LOAD_ADDR: %x\n", (uint_t) exitCtrls->msrLoadAddr & 0xffffffff);
 746   SerialPrint("VM_EXIT_MSR_LOAD_ADDR_HIGH: %x\n", (uint_t) (exitCtrls->msrLoadAddr >> 32) & 0xffffffff);
 747 }
 748
 749 void SerialPrint_VMCSEntryCtrlFields(struct VMCSEntryCtrlFields * entryCtrls) {
 750   SerialPrint("\n==> VM Entry Controls\n");
 751   SerialPrint("VM_ENTRY_CTRLS: %x\n", (uint_t) entryCtrls->entryCtrls);
 752   SerialPrint("VM_ENTRY_MSR_LOAD_COUNT: %x\n", (uint_t) entryCtrls->msrLoadCount);
 753   SerialPrint("VM_ENTRY_MSR_LOAD_ADDR: %x\n", (uint_t) entryCtrls->msrLoadAddr & 0xffffffff);
 754   SerialPrint("VM_ENTRY_MSR_LOAD_ADDR_HIGH: %x\n", (uint_t) (entryCtrls->msrLoadAddr >> 32) & 0xffffffff);
 755   SerialPrint("VM_ENTRY_INT_INFO_FIELD: %x\n", (uint_t) entryCtrls->intInfo);
 756   SerialPrint("VM_ENTRY_EXCEPTION_ERROR: %x\n", (uint_t) entryCtrls->exceptionErrorCode);
 757   SerialPrint("VM_ENTRY_INSTR_LENGTH: %x\n", (uint_t) entryCtrls->instrLength);
 758 }
 759
 760 void SerialPrint_VMCSExitInfoFields(struct VMCSExitInfoFields * exitInfo) {
 761   SerialPrint("\n==> VM Exit Info\n");
 762   SerialPrint("EXIT_REASON: %x\n", (uint_t) exitInfo->reason);
 763   SerialPrint("EXIT_QUALIFICATION: %x\n", (uint_t) exitInfo->qualification);
 764   SerialPrint("VM_EXIT_INT_INFO: %x\n", (uint_t) exitInfo->intInfo);
 765   SerialPrint("VM_EXIT_INT_ERROR: %x\n", (uint_t) exitInfo->intErrorCode);
 766   SerialPrint("IDT_VECTOR_INFO: %x\n", (uint_t) exitInfo->idtVectorInfo);
 767   SerialPrint("IDT_VECTOR_ERROR: %x\n", (uint_t) exitInfo->idtVectorErrorCode);
 768   SerialPrint("VM_EXIT_INSTR_LENGTH: %x\n", (uint_t) exitInfo->instrLength);
 769   SerialPrint("GUEST_LINEAR_ADDR: %x\n", (uint_t) exitInfo->guestLinearAddr);
 770   SerialPrint("VMX_INSTR_INFO: %x\n", (uint_t) exitInfo->instrInfo);
 771   SerialPrint("IO_RCX: %x\n", (uint_t) exitInfo->ioRCX);
 772   SerialPrint("IO_RSI: %x\n", (uint_t) exitInfo->ioRSI);
 773   SerialPrint("IO_RDI: %x\n", (uint_t) exitInfo->ioRDI);
 774   SerialPrint("IO_RIP: %x\n", (uint_t) exitInfo->ioRIP);
 775   SerialPrint("VM_INSTR_ERROR: %x\n", (uint_t) exitInfo->instrErrorField);
 776 }
 777
 778
 779 void SerialPrint_VMCSData(struct VMCSData * vmcs) {
 780   SerialPrint("VMCSData Structure\n");
 781
 782   SerialPrint_VMCSGuestStateArea(&(vmcs->guestStateArea));
 783   SerialPrint_VMCSHostStateArea(&(vmcs->hostStateArea));
 784   SerialPrint_VMCSExecCtrlFields(&(vmcs->execCtrlFields));
 785   SerialPrint_VMCSExitCtrlFields(&(vmcs->exitCtrlFields));
 786   SerialPrint_VMCSEntryCtrlFields(&(vmcs->entryCtrlFields));
 787   SerialPrint_VMCSExitInfoFields(&(vmcs->exitInfoFields));
 788   SerialPrint("\n");
 789 }