From: Jack Lange Date: Thu, 28 Feb 2008 00:22:31 +0000 (+0000) Subject: split the vmm from the internal geekos X-Git-Tag: working-cdboot-physical-but-not-qemu~66 X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=commitdiff_plain;h=01e2bfdc462dbbe8d62b71c7e99e198c27844f0f;p=palacios-OLD.git split the vmm from the internal geekos --- diff --git a/palacios/include/geekos/screen.h b/palacios/include/geekos/screen.h index 241fc6f..39133e7 100644 --- a/palacios/include/geekos/screen.h +++ b/palacios/include/geekos/screen.h @@ -1,7 +1,7 @@ /* * GeekOS text screen output * Copyright (c) 2001,2003 David H. Hovemeyer - * $Revision: 1.1 $ + * $Revision: 1.2 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -11,6 +11,7 @@ #define GEEKOS_SCREEN_H #include +#include #define BLACK 0 #define BLUE 1 @@ -51,6 +52,8 @@ void Put_Char(int c); void Put_String(const char* s); void Put_Buf(const char* buf, ulong_t length); void Print(const char* fmt, ...) __attribute__ ((format (printf, 1, 2))); +void PrintList(const char * fmt, va_list ap); + #endif /* GEEKOS */ diff --git a/palacios/include/geekos/serial.h b/palacios/include/geekos/serial.h index 4ebe0b0..c04c1a9 100644 --- a/palacios/include/geekos/serial.h +++ b/palacios/include/geekos/serial.h @@ -10,51 +10,15 @@ #define DEFAULT_SERIAL_ADDR 0x3F8 -#ifndef SERIAL_PRINT -#define SERIAL_PRINT 1 -#endif -#ifndef SERIAL_PRINT_DEBUG -#define SERIAL_PRINT_DEBUG 1 -#endif #ifndef SERIAL_PRINT_DEBUG_LEVEL #define SERIAL_PRINT_DEBUG_LEVEL 10 #endif -#define SERIAL_PRINT_MAXBUF 256 - - -#if SERIAL_PRINT -#define SerialPrint(format, args...) \ -do { \ - char buf[SERIAL_PRINT_MAXBUF]; \ - snprintf( buf, SERIAL_PRINT_MAXBUF, format, ## args ) ; \ - SerialPutLineN(buf, SERIAL_PRINT_MAXBUF); \ -} while (0) -#else -#define SerialPrint(format, args...) do {} while (0) -#endif - - -#define PrintBoth(format, args...) \ -do { \ - Print(format, ## args); \ - SerialPrint(format, ##args); \ - } while (0) -#if SERIAL_PRINT_DEBUG -#define SerialPrintLevel(level, format, args...) \ -do { \ - char buf[SERIAL_PRINT_MAXBUF]; \ - if (level >= SERIAL_PRINT_DEBUG_LEVEL ) { \ - snprintf( buf, SERIAL_PRINT_MAXBUF, format, ## args ) ; \ - SerialPutLineN(buf, SERIAL_PRINT_MAXBUF); \ - } \ -} while (0) -#else -#define SerialPrintLevel(level, format, args...) do {} while (0) -#endif - +void SerialPrint(const char * format, ...); +void SerialPrintLevel(int level, const char * format, ...); +void SerialPrintList(const char * format, va_list ap); void SerialPutLine(char * line); void SerialPutLineN(char * line, int len); @@ -63,7 +27,7 @@ void SerialPutLineN(char * line, int len); void SerialPrintHex(unsigned char x); void SerialMemDump(unsigned char *start, int n); -void InitSerial(); +void Init_Serial(); void InitSerialAddr(unsigned short io_addr); #endif diff --git a/palacios/include/geekos/svm.h b/palacios/include/geekos/svm.h index f61ee6c..b0b6dcc 100644 --- a/palacios/include/geekos/svm.h +++ b/palacios/include/geekos/svm.h @@ -1,9 +1,7 @@ #ifndef __SVM_H #define __SVM_H -#include -#include - +#include #define CPUID_FEATURE_IDS 0x80000001 #define CPUID_FEATURE_IDS_ecx_svm_avail 0x00000004 diff --git a/palacios/include/geekos/vmcs.h b/palacios/include/geekos/vmcs.h index 30af389..b6d7027 100644 --- a/palacios/include/geekos/vmcs.h +++ b/palacios/include/geekos/vmcs.h @@ -560,15 +560,15 @@ struct VMXRegs { uint_t eax; }; -void SerialPrint_VMX_Regs(struct VMXRegs *regs); -void SerialPrint_VMCSData(struct VMCSData * vmcs); -void SerialPrint_VMCSGuestStateArea(struct VMCSGuestStateArea * guestState); -void SerialPrint_VMCSHostStateArea(struct VMCSHostStateArea * hostState); -void SerialPrint_VMCSExecCtrlFields(struct VMCSExecCtrlFields * execCtrls); -void SerialPrint_VMCSExitCtrlFields(struct VMCSExitCtrlFields * exitCtrls); -void SerialPrint_VMCSEntryCtrlFields(struct VMCSEntryCtrlFields * entryCtrls); -void SerialPrint_VMCSExitInfoFields(struct VMCSExitInfoFields * exitInfo); -void SerialPrint_VMCSSegment(char * segname, struct VMCSSegment * seg, int abbr); +void PrintTrace_VMX_Regs(struct VMXRegs *regs); +void PrintTrace_VMCSData(struct VMCSData * vmcs); +void PrintTrace_VMCSGuestStateArea(struct VMCSGuestStateArea * guestState); +void PrintTrace_VMCSHostStateArea(struct VMCSHostStateArea * hostState); +void PrintTrace_VMCSExecCtrlFields(struct VMCSExecCtrlFields * execCtrls); +void PrintTrace_VMCSExitCtrlFields(struct VMCSExitCtrlFields * exitCtrls); +void PrintTrace_VMCSEntryCtrlFields(struct VMCSEntryCtrlFields * entryCtrls); +void PrintTrace_VMCSExitInfoFields(struct VMCSExitInfoFields * exitInfo); +void PrintTrace_VMCSSegment(char * segname, struct VMCSSegment * seg, int abbr); VMCS * CreateVMCS(); extern uint_t VMCS_WRITE(); @@ -577,10 +577,6 @@ extern uint_t VMCS_READ(); //uint_t VMCSRead(uint_t tag, void * val); - - - -#include #include #endif diff --git a/palacios/include/geekos/vmcs_gen.h b/palacios/include/geekos/vmcs_gen.h index 4bdef7c..0e10af9 100644 --- a/palacios/include/geekos/vmcs_gen.h +++ b/palacios/include/geekos/vmcs_gen.h @@ -1,779 +1,780 @@ #ifndef vmcs_gen #define vmcs_gen #include +#include void Set_VMCS_GUEST_ES_SELECTOR(uint_t val); uint_t Get_VMCS_GUEST_ES_SELECTOR(); -void SerialPrint_VMCS_GUEST_ES_SELECTOR(); +void PrintTrace_VMCS_GUEST_ES_SELECTOR(); void Set_VMCS_GUEST_CS_SELECTOR(uint_t val); uint_t Get_VMCS_GUEST_CS_SELECTOR(); -void SerialPrint_VMCS_GUEST_CS_SELECTOR(); +void PrintTrace_VMCS_GUEST_CS_SELECTOR(); void Set_VMCS_GUEST_SS_SELECTOR(uint_t val); uint_t Get_VMCS_GUEST_SS_SELECTOR(); -void SerialPrint_VMCS_GUEST_SS_SELECTOR(); +void PrintTrace_VMCS_GUEST_SS_SELECTOR(); void Set_VMCS_GUEST_DS_SELECTOR(uint_t val); uint_t Get_VMCS_GUEST_DS_SELECTOR(); -void SerialPrint_VMCS_GUEST_DS_SELECTOR(); +void PrintTrace_VMCS_GUEST_DS_SELECTOR(); void Set_VMCS_GUEST_FS_SELECTOR(uint_t val); uint_t Get_VMCS_GUEST_FS_SELECTOR(); -void SerialPrint_VMCS_GUEST_FS_SELECTOR(); +void PrintTrace_VMCS_GUEST_FS_SELECTOR(); void Set_VMCS_GUEST_GS_SELECTOR(uint_t val); uint_t Get_VMCS_GUEST_GS_SELECTOR(); -void SerialPrint_VMCS_GUEST_GS_SELECTOR(); +void PrintTrace_VMCS_GUEST_GS_SELECTOR(); void Set_VMCS_GUEST_LDTR_SELECTOR(uint_t val); uint_t Get_VMCS_GUEST_LDTR_SELECTOR(); -void SerialPrint_VMCS_GUEST_LDTR_SELECTOR(); +void PrintTrace_VMCS_GUEST_LDTR_SELECTOR(); void Set_VMCS_GUEST_TR_SELECTOR(uint_t val); uint_t Get_VMCS_GUEST_TR_SELECTOR(); -void SerialPrint_VMCS_GUEST_TR_SELECTOR(); +void PrintTrace_VMCS_GUEST_TR_SELECTOR(); void Set_VMCS_HOST_ES_SELECTOR(uint_t val); uint_t Get_VMCS_HOST_ES_SELECTOR(); -void SerialPrint_VMCS_HOST_ES_SELECTOR(); +void PrintTrace_VMCS_HOST_ES_SELECTOR(); void Set_VMCS_HOST_CS_SELECTOR(uint_t val); uint_t Get_VMCS_HOST_CS_SELECTOR(); -void SerialPrint_VMCS_HOST_CS_SELECTOR(); +void PrintTrace_VMCS_HOST_CS_SELECTOR(); void Set_VMCS_HOST_SS_SELECTOR(uint_t val); uint_t Get_VMCS_HOST_SS_SELECTOR(); -void SerialPrint_VMCS_HOST_SS_SELECTOR(); +void PrintTrace_VMCS_HOST_SS_SELECTOR(); void Set_VMCS_HOST_DS_SELECTOR(uint_t val); uint_t Get_VMCS_HOST_DS_SELECTOR(); -void SerialPrint_VMCS_HOST_DS_SELECTOR(); +void PrintTrace_VMCS_HOST_DS_SELECTOR(); void Set_VMCS_HOST_FS_SELECTOR(uint_t val); uint_t Get_VMCS_HOST_FS_SELECTOR(); -void SerialPrint_VMCS_HOST_FS_SELECTOR(); +void PrintTrace_VMCS_HOST_FS_SELECTOR(); void Set_VMCS_HOST_GS_SELECTOR(uint_t val); uint_t Get_VMCS_HOST_GS_SELECTOR(); -void SerialPrint_VMCS_HOST_GS_SELECTOR(); +void PrintTrace_VMCS_HOST_GS_SELECTOR(); void Set_VMCS_HOST_TR_SELECTOR(uint_t val); uint_t Get_VMCS_HOST_TR_SELECTOR(); -void SerialPrint_VMCS_HOST_TR_SELECTOR(); +void PrintTrace_VMCS_HOST_TR_SELECTOR(); void Set_IO_BITMAP_A_ADDR(uint_t val); uint_t Get_IO_BITMAP_A_ADDR(); -void SerialPrint_IO_BITMAP_A_ADDR(); +void PrintTrace_IO_BITMAP_A_ADDR(); void Set_IO_BITMAP_A_ADDR_HIGH(uint_t val); uint_t Get_IO_BITMAP_A_ADDR_HIGH(); -void SerialPrint_IO_BITMAP_A_ADDR_HIGH(); +void PrintTrace_IO_BITMAP_A_ADDR_HIGH(); void Set_IO_BITMAP_B_ADDR(uint_t val); uint_t Get_IO_BITMAP_B_ADDR(); -void SerialPrint_IO_BITMAP_B_ADDR(); +void PrintTrace_IO_BITMAP_B_ADDR(); void Set_IO_BITMAP_B_ADDR_HIGH(uint_t val); uint_t Get_IO_BITMAP_B_ADDR_HIGH(); -void SerialPrint_IO_BITMAP_B_ADDR_HIGH(); +void PrintTrace_IO_BITMAP_B_ADDR_HIGH(); void Set_MSR_BITMAPS(uint_t val); uint_t Get_MSR_BITMAPS(); -void SerialPrint_MSR_BITMAPS(); +void PrintTrace_MSR_BITMAPS(); void Set_MSR_BITMAPS_HIGH(uint_t val); uint_t Get_MSR_BITMAPS_HIGH(); -void SerialPrint_MSR_BITMAPS_HIGH(); +void PrintTrace_MSR_BITMAPS_HIGH(); void Set_VM_EXIT_MSR_STORE_ADDR(uint_t val); uint_t Get_VM_EXIT_MSR_STORE_ADDR(); -void SerialPrint_VM_EXIT_MSR_STORE_ADDR(); +void PrintTrace_VM_EXIT_MSR_STORE_ADDR(); void Set_VM_EXIT_MSR_STORE_ADDR_HIGH(uint_t val); uint_t Get_VM_EXIT_MSR_STORE_ADDR_HIGH(); -void SerialPrint_VM_EXIT_MSR_STORE_ADDR_HIGH(); +void PrintTrace_VM_EXIT_MSR_STORE_ADDR_HIGH(); void Set_VM_EXIT_MSR_LOAD_ADDR(uint_t val); uint_t Get_VM_EXIT_MSR_LOAD_ADDR(); -void SerialPrint_VM_EXIT_MSR_LOAD_ADDR(); +void PrintTrace_VM_EXIT_MSR_LOAD_ADDR(); void Set_VM_EXIT_MSR_LOAD_ADDR_HIGH(uint_t val); uint_t Get_VM_EXIT_MSR_LOAD_ADDR_HIGH(); -void SerialPrint_VM_EXIT_MSR_LOAD_ADDR_HIGH(); +void PrintTrace_VM_EXIT_MSR_LOAD_ADDR_HIGH(); void Set_VM_ENTRY_MSR_LOAD_ADDR(uint_t val); uint_t Get_VM_ENTRY_MSR_LOAD_ADDR(); -void SerialPrint_VM_ENTRY_MSR_LOAD_ADDR(); +void PrintTrace_VM_ENTRY_MSR_LOAD_ADDR(); void Set_VM_ENTRY_MSR_LOAD_ADDR_HIGH(uint_t val); uint_t Get_VM_ENTRY_MSR_LOAD_ADDR_HIGH(); -void SerialPrint_VM_ENTRY_MSR_LOAD_ADDR_HIGH(); +void PrintTrace_VM_ENTRY_MSR_LOAD_ADDR_HIGH(); void Set_VMCS_EXEC_PTR(uint_t val); uint_t Get_VMCS_EXEC_PTR(); -void SerialPrint_VMCS_EXEC_PTR(); +void PrintTrace_VMCS_EXEC_PTR(); void Set_VMCS_EXEC_PTR_HIGH(uint_t val); uint_t Get_VMCS_EXEC_PTR_HIGH(); -void SerialPrint_VMCS_EXEC_PTR_HIGH(); +void PrintTrace_VMCS_EXEC_PTR_HIGH(); void Set_TSC_OFFSET(uint_t val); uint_t Get_TSC_OFFSET(); -void SerialPrint_TSC_OFFSET(); +void PrintTrace_TSC_OFFSET(); void Set_TSC_OFFSET_HIGH(uint_t val); uint_t Get_TSC_OFFSET_HIGH(); -void SerialPrint_TSC_OFFSET_HIGH(); +void PrintTrace_TSC_OFFSET_HIGH(); void Set_VIRT_APIC_PAGE_ADDR(uint_t val); uint_t Get_VIRT_APIC_PAGE_ADDR(); -void SerialPrint_VIRT_APIC_PAGE_ADDR(); +void PrintTrace_VIRT_APIC_PAGE_ADDR(); void Set_VIRT_APIC_PAGE_ADDR_HIGH(uint_t val); uint_t Get_VIRT_APIC_PAGE_ADDR_HIGH(); -void SerialPrint_VIRT_APIC_PAGE_ADDR_HIGH(); +void PrintTrace_VIRT_APIC_PAGE_ADDR_HIGH(); void Set_VMCS_LINK_PTR(uint_t val); uint_t Get_VMCS_LINK_PTR(); -void SerialPrint_VMCS_LINK_PTR(); +void PrintTrace_VMCS_LINK_PTR(); void Set_VMCS_LINK_PTR_HIGH(uint_t val); uint_t Get_VMCS_LINK_PTR_HIGH(); -void SerialPrint_VMCS_LINK_PTR_HIGH(); +void PrintTrace_VMCS_LINK_PTR_HIGH(); void Set_GUEST_IA32_DEBUGCTL(uint_t val); uint_t Get_GUEST_IA32_DEBUGCTL(); -void SerialPrint_GUEST_IA32_DEBUGCTL(); +void PrintTrace_GUEST_IA32_DEBUGCTL(); void Set_GUEST_IA32_DEBUGCTL_HIGH(uint_t val); uint_t Get_GUEST_IA32_DEBUGCTL_HIGH(); -void SerialPrint_GUEST_IA32_DEBUGCTL_HIGH(); +void PrintTrace_GUEST_IA32_DEBUGCTL_HIGH(); void Set_PIN_VM_EXEC_CTRLS(uint_t val); uint_t Get_PIN_VM_EXEC_CTRLS(); -void SerialPrint_PIN_VM_EXEC_CTRLS(); +void PrintTrace_PIN_VM_EXEC_CTRLS(); void Set_PROC_VM_EXEC_CTRLS(uint_t val); uint_t Get_PROC_VM_EXEC_CTRLS(); -void SerialPrint_PROC_VM_EXEC_CTRLS(); +void PrintTrace_PROC_VM_EXEC_CTRLS(); void Set_EXCEPTION_BITMAP(uint_t val); uint_t Get_EXCEPTION_BITMAP(); -void SerialPrint_EXCEPTION_BITMAP(); +void PrintTrace_EXCEPTION_BITMAP(); void Set_PAGE_FAULT_ERROR_MASK(uint_t val); uint_t Get_PAGE_FAULT_ERROR_MASK(); -void SerialPrint_PAGE_FAULT_ERROR_MASK(); +void PrintTrace_PAGE_FAULT_ERROR_MASK(); void Set_PAGE_FAULT_ERROR_MATCH(uint_t val); uint_t Get_PAGE_FAULT_ERROR_MATCH(); -void SerialPrint_PAGE_FAULT_ERROR_MATCH(); +void PrintTrace_PAGE_FAULT_ERROR_MATCH(); void Set_CR3_TARGET_COUNT(uint_t val); uint_t Get_CR3_TARGET_COUNT(); -void SerialPrint_CR3_TARGET_COUNT(); +void PrintTrace_CR3_TARGET_COUNT(); void Set_VM_EXIT_CTRLS(uint_t val); uint_t Get_VM_EXIT_CTRLS(); -void SerialPrint_VM_EXIT_CTRLS(); +void PrintTrace_VM_EXIT_CTRLS(); void Set_VM_EXIT_MSR_STORE_COUNT(uint_t val); uint_t Get_VM_EXIT_MSR_STORE_COUNT(); -void SerialPrint_VM_EXIT_MSR_STORE_COUNT(); +void PrintTrace_VM_EXIT_MSR_STORE_COUNT(); void Set_VM_EXIT_MSR_LOAD_COUNT(uint_t val); uint_t Get_VM_EXIT_MSR_LOAD_COUNT(); -void SerialPrint_VM_EXIT_MSR_LOAD_COUNT(); +void PrintTrace_VM_EXIT_MSR_LOAD_COUNT(); void Set_VM_ENTRY_CTRLS(uint_t val); uint_t Get_VM_ENTRY_CTRLS(); -void SerialPrint_VM_ENTRY_CTRLS(); +void PrintTrace_VM_ENTRY_CTRLS(); void Set_VM_ENTRY_MSR_LOAD_COUNT(uint_t val); uint_t Get_VM_ENTRY_MSR_LOAD_COUNT(); -void SerialPrint_VM_ENTRY_MSR_LOAD_COUNT(); +void PrintTrace_VM_ENTRY_MSR_LOAD_COUNT(); void Set_VM_ENTRY_INT_INFO_FIELD(uint_t val); uint_t Get_VM_ENTRY_INT_INFO_FIELD(); -void SerialPrint_VM_ENTRY_INT_INFO_FIELD(); +void PrintTrace_VM_ENTRY_INT_INFO_FIELD(); void Set_VM_ENTRY_EXCEPTION_ERROR(uint_t val); uint_t Get_VM_ENTRY_EXCEPTION_ERROR(); -void SerialPrint_VM_ENTRY_EXCEPTION_ERROR(); +void PrintTrace_VM_ENTRY_EXCEPTION_ERROR(); void Set_VM_ENTRY_INSTR_LENGTH(uint_t val); uint_t Get_VM_ENTRY_INSTR_LENGTH(); -void SerialPrint_VM_ENTRY_INSTR_LENGTH(); +void PrintTrace_VM_ENTRY_INSTR_LENGTH(); void Set_TPR_THRESHOLD(uint_t val); uint_t Get_TPR_THRESHOLD(); -void SerialPrint_TPR_THRESHOLD(); +void PrintTrace_TPR_THRESHOLD(); void Set_VM_INSTR_ERROR(uint_t val); uint_t Get_VM_INSTR_ERROR(); -void SerialPrint_VM_INSTR_ERROR(); +void PrintTrace_VM_INSTR_ERROR(); void Set_EXIT_REASON(uint_t val); uint_t Get_EXIT_REASON(); -void SerialPrint_EXIT_REASON(); +void PrintTrace_EXIT_REASON(); void Set_VM_EXIT_INT_INFO(uint_t val); uint_t Get_VM_EXIT_INT_INFO(); -void SerialPrint_VM_EXIT_INT_INFO(); +void PrintTrace_VM_EXIT_INT_INFO(); void Set_VM_EXIT_INT_ERROR(uint_t val); uint_t Get_VM_EXIT_INT_ERROR(); -void SerialPrint_VM_EXIT_INT_ERROR(); +void PrintTrace_VM_EXIT_INT_ERROR(); void Set_IDT_VECTOR_INFO(uint_t val); uint_t Get_IDT_VECTOR_INFO(); -void SerialPrint_IDT_VECTOR_INFO(); +void PrintTrace_IDT_VECTOR_INFO(); void Set_IDT_VECTOR_ERROR(uint_t val); uint_t Get_IDT_VECTOR_ERROR(); -void SerialPrint_IDT_VECTOR_ERROR(); +void PrintTrace_IDT_VECTOR_ERROR(); void Set_VM_EXIT_INSTR_LENGTH(uint_t val); uint_t Get_VM_EXIT_INSTR_LENGTH(); -void SerialPrint_VM_EXIT_INSTR_LENGTH(); +void PrintTrace_VM_EXIT_INSTR_LENGTH(); void Set_VMX_INSTR_INFO(uint_t val); uint_t Get_VMX_INSTR_INFO(); -void SerialPrint_VMX_INSTR_INFO(); +void PrintTrace_VMX_INSTR_INFO(); void Set_GUEST_ES_LIMIT(uint_t val); uint_t Get_GUEST_ES_LIMIT(); -void SerialPrint_GUEST_ES_LIMIT(); +void PrintTrace_GUEST_ES_LIMIT(); void Set_GUEST_CS_LIMIT(uint_t val); uint_t Get_GUEST_CS_LIMIT(); -void SerialPrint_GUEST_CS_LIMIT(); +void PrintTrace_GUEST_CS_LIMIT(); void Set_GUEST_SS_LIMIT(uint_t val); uint_t Get_GUEST_SS_LIMIT(); -void SerialPrint_GUEST_SS_LIMIT(); +void PrintTrace_GUEST_SS_LIMIT(); void Set_GUEST_DS_LIMIT(uint_t val); uint_t Get_GUEST_DS_LIMIT(); -void SerialPrint_GUEST_DS_LIMIT(); +void PrintTrace_GUEST_DS_LIMIT(); void Set_GUEST_FS_LIMIT(uint_t val); uint_t Get_GUEST_FS_LIMIT(); -void SerialPrint_GUEST_FS_LIMIT(); +void PrintTrace_GUEST_FS_LIMIT(); void Set_GUEST_GS_LIMIT(uint_t val); uint_t Get_GUEST_GS_LIMIT(); -void SerialPrint_GUEST_GS_LIMIT(); +void PrintTrace_GUEST_GS_LIMIT(); void Set_GUEST_LDTR_LIMIT(uint_t val); uint_t Get_GUEST_LDTR_LIMIT(); -void SerialPrint_GUEST_LDTR_LIMIT(); +void PrintTrace_GUEST_LDTR_LIMIT(); void Set_GUEST_TR_LIMIT(uint_t val); uint_t Get_GUEST_TR_LIMIT(); -void SerialPrint_GUEST_TR_LIMIT(); +void PrintTrace_GUEST_TR_LIMIT(); void Set_GUEST_GDTR_LIMIT(uint_t val); uint_t Get_GUEST_GDTR_LIMIT(); -void SerialPrint_GUEST_GDTR_LIMIT(); +void PrintTrace_GUEST_GDTR_LIMIT(); void Set_GUEST_IDTR_LIMIT(uint_t val); uint_t Get_GUEST_IDTR_LIMIT(); -void SerialPrint_GUEST_IDTR_LIMIT(); +void PrintTrace_GUEST_IDTR_LIMIT(); void Set_GUEST_ES_ACCESS(uint_t val); uint_t Get_GUEST_ES_ACCESS(); -void SerialPrint_GUEST_ES_ACCESS(); +void PrintTrace_GUEST_ES_ACCESS(); void Set_GUEST_CS_ACCESS(uint_t val); uint_t Get_GUEST_CS_ACCESS(); -void SerialPrint_GUEST_CS_ACCESS(); +void PrintTrace_GUEST_CS_ACCESS(); void Set_GUEST_SS_ACCESS(uint_t val); uint_t Get_GUEST_SS_ACCESS(); -void SerialPrint_GUEST_SS_ACCESS(); +void PrintTrace_GUEST_SS_ACCESS(); void Set_GUEST_DS_ACCESS(uint_t val); uint_t Get_GUEST_DS_ACCESS(); -void SerialPrint_GUEST_DS_ACCESS(); +void PrintTrace_GUEST_DS_ACCESS(); void Set_GUEST_FS_ACCESS(uint_t val); uint_t Get_GUEST_FS_ACCESS(); -void SerialPrint_GUEST_FS_ACCESS(); +void PrintTrace_GUEST_FS_ACCESS(); void Set_GUEST_GS_ACCESS(uint_t val); uint_t Get_GUEST_GS_ACCESS(); -void SerialPrint_GUEST_GS_ACCESS(); +void PrintTrace_GUEST_GS_ACCESS(); void Set_GUEST_LDTR_ACCESS(uint_t val); uint_t Get_GUEST_LDTR_ACCESS(); -void SerialPrint_GUEST_LDTR_ACCESS(); +void PrintTrace_GUEST_LDTR_ACCESS(); void Set_GUEST_TR_ACCESS(uint_t val); uint_t Get_GUEST_TR_ACCESS(); -void SerialPrint_GUEST_TR_ACCESS(); +void PrintTrace_GUEST_TR_ACCESS(); void Set_GUEST_INT_STATE(uint_t val); uint_t Get_GUEST_INT_STATE(); -void SerialPrint_GUEST_INT_STATE(); +void PrintTrace_GUEST_INT_STATE(); void Set_GUEST_ACTIVITY_STATE(uint_t val); uint_t Get_GUEST_ACTIVITY_STATE(); -void SerialPrint_GUEST_ACTIVITY_STATE(); +void PrintTrace_GUEST_ACTIVITY_STATE(); void Set_GUEST_SMBASE(uint_t val); uint_t Get_GUEST_SMBASE(); -void SerialPrint_GUEST_SMBASE(); +void PrintTrace_GUEST_SMBASE(); void Set_GUEST_IA32_SYSENTER_CS(uint_t val); uint_t Get_GUEST_IA32_SYSENTER_CS(); -void SerialPrint_GUEST_IA32_SYSENTER_CS(); +void PrintTrace_GUEST_IA32_SYSENTER_CS(); void Set_HOST_IA32_SYSENTER_CS(uint_t val); uint_t Get_HOST_IA32_SYSENTER_CS(); -void SerialPrint_HOST_IA32_SYSENTER_CS(); +void PrintTrace_HOST_IA32_SYSENTER_CS(); void Set_CR0_GUEST_HOST_MASK(uint_t val); uint_t Get_CR0_GUEST_HOST_MASK(); -void SerialPrint_CR0_GUEST_HOST_MASK(); +void PrintTrace_CR0_GUEST_HOST_MASK(); void Set_CR4_GUEST_HOST_MASK(uint_t val); uint_t Get_CR4_GUEST_HOST_MASK(); -void SerialPrint_CR4_GUEST_HOST_MASK(); +void PrintTrace_CR4_GUEST_HOST_MASK(); void Set_CR0_READ_SHADOW(uint_t val); uint_t Get_CR0_READ_SHADOW(); -void SerialPrint_CR0_READ_SHADOW(); +void PrintTrace_CR0_READ_SHADOW(); void Set_CR4_READ_SHADOW(uint_t val); uint_t Get_CR4_READ_SHADOW(); -void SerialPrint_CR4_READ_SHADOW(); +void PrintTrace_CR4_READ_SHADOW(); void Set_CR3_TARGET_VALUE_0(uint_t val); uint_t Get_CR3_TARGET_VALUE_0(); -void SerialPrint_CR3_TARGET_VALUE_0(); +void PrintTrace_CR3_TARGET_VALUE_0(); void Set_CR3_TARGET_VALUE_1(uint_t val); uint_t Get_CR3_TARGET_VALUE_1(); -void SerialPrint_CR3_TARGET_VALUE_1(); +void PrintTrace_CR3_TARGET_VALUE_1(); void Set_CR3_TARGET_VALUE_2(uint_t val); uint_t Get_CR3_TARGET_VALUE_2(); -void SerialPrint_CR3_TARGET_VALUE_2(); +void PrintTrace_CR3_TARGET_VALUE_2(); void Set_CR3_TARGET_VALUE_3(uint_t val); uint_t Get_CR3_TARGET_VALUE_3(); -void SerialPrint_CR3_TARGET_VALUE_3(); +void PrintTrace_CR3_TARGET_VALUE_3(); void Set_EXIT_QUALIFICATION(uint_t val); uint_t Get_EXIT_QUALIFICATION(); -void SerialPrint_EXIT_QUALIFICATION(); +void PrintTrace_EXIT_QUALIFICATION(); void Set_IO_RCX(uint_t val); uint_t Get_IO_RCX(); -void SerialPrint_IO_RCX(); +void PrintTrace_IO_RCX(); void Set_IO_RSI(uint_t val); uint_t Get_IO_RSI(); -void SerialPrint_IO_RSI(); +void PrintTrace_IO_RSI(); void Set_IO_RDI(uint_t val); uint_t Get_IO_RDI(); -void SerialPrint_IO_RDI(); +void PrintTrace_IO_RDI(); void Set_IO_RIP(uint_t val); uint_t Get_IO_RIP(); -void SerialPrint_IO_RIP(); +void PrintTrace_IO_RIP(); void Set_GUEST_LINEAR_ADDR(uint_t val); uint_t Get_GUEST_LINEAR_ADDR(); -void SerialPrint_GUEST_LINEAR_ADDR(); +void PrintTrace_GUEST_LINEAR_ADDR(); void Set_GUEST_CR0(uint_t val); uint_t Get_GUEST_CR0(); -void SerialPrint_GUEST_CR0(); +void PrintTrace_GUEST_CR0(); void Set_GUEST_CR3(uint_t val); uint_t Get_GUEST_CR3(); -void SerialPrint_GUEST_CR3(); +void PrintTrace_GUEST_CR3(); void Set_GUEST_CR4(uint_t val); uint_t Get_GUEST_CR4(); -void SerialPrint_GUEST_CR4(); +void PrintTrace_GUEST_CR4(); void Set_GUEST_ES_BASE(uint_t val); uint_t Get_GUEST_ES_BASE(); -void SerialPrint_GUEST_ES_BASE(); +void PrintTrace_GUEST_ES_BASE(); void Set_GUEST_CS_BASE(uint_t val); uint_t Get_GUEST_CS_BASE(); -void SerialPrint_GUEST_CS_BASE(); +void PrintTrace_GUEST_CS_BASE(); void Set_GUEST_SS_BASE(uint_t val); uint_t Get_GUEST_SS_BASE(); -void SerialPrint_GUEST_SS_BASE(); +void PrintTrace_GUEST_SS_BASE(); void Set_GUEST_DS_BASE(uint_t val); uint_t Get_GUEST_DS_BASE(); -void SerialPrint_GUEST_DS_BASE(); +void PrintTrace_GUEST_DS_BASE(); void Set_GUEST_FS_BASE(uint_t val); uint_t Get_GUEST_FS_BASE(); -void SerialPrint_GUEST_FS_BASE(); +void PrintTrace_GUEST_FS_BASE(); void Set_GUEST_GS_BASE(uint_t val); uint_t Get_GUEST_GS_BASE(); -void SerialPrint_GUEST_GS_BASE(); +void PrintTrace_GUEST_GS_BASE(); void Set_GUEST_LDTR_BASE(uint_t val); uint_t Get_GUEST_LDTR_BASE(); -void SerialPrint_GUEST_LDTR_BASE(); +void PrintTrace_GUEST_LDTR_BASE(); void Set_GUEST_TR_BASE(uint_t val); uint_t Get_GUEST_TR_BASE(); -void SerialPrint_GUEST_TR_BASE(); +void PrintTrace_GUEST_TR_BASE(); void Set_GUEST_GDTR_BASE(uint_t val); uint_t Get_GUEST_GDTR_BASE(); -void SerialPrint_GUEST_GDTR_BASE(); +void PrintTrace_GUEST_GDTR_BASE(); void Set_GUEST_IDTR_BASE(uint_t val); uint_t Get_GUEST_IDTR_BASE(); -void SerialPrint_GUEST_IDTR_BASE(); +void PrintTrace_GUEST_IDTR_BASE(); void Set_GUEST_DR7(uint_t val); uint_t Get_GUEST_DR7(); -void SerialPrint_GUEST_DR7(); +void PrintTrace_GUEST_DR7(); void Set_GUEST_RSP(uint_t val); uint_t Get_GUEST_RSP(); -void SerialPrint_GUEST_RSP(); +void PrintTrace_GUEST_RSP(); void Set_GUEST_RIP(uint_t val); uint_t Get_GUEST_RIP(); -void SerialPrint_GUEST_RIP(); +void PrintTrace_GUEST_RIP(); void Set_GUEST_RFLAGS(uint_t val); uint_t Get_GUEST_RFLAGS(); -void SerialPrint_GUEST_RFLAGS(); +void PrintTrace_GUEST_RFLAGS(); void Set_GUEST_PENDING_DEBUG_EXCS(uint_t val); uint_t Get_GUEST_PENDING_DEBUG_EXCS(); -void SerialPrint_GUEST_PENDING_DEBUG_EXCS(); +void PrintTrace_GUEST_PENDING_DEBUG_EXCS(); void Set_GUEST_IA32_SYSENTER_ESP(uint_t val); uint_t Get_GUEST_IA32_SYSENTER_ESP(); -void SerialPrint_GUEST_IA32_SYSENTER_ESP(); +void PrintTrace_GUEST_IA32_SYSENTER_ESP(); void Set_GUEST_IA32_SYSENTER_EIP(uint_t val); uint_t Get_GUEST_IA32_SYSENTER_EIP(); -void SerialPrint_GUEST_IA32_SYSENTER_EIP(); +void PrintTrace_GUEST_IA32_SYSENTER_EIP(); void Set_HOST_CR0(uint_t val); uint_t Get_HOST_CR0(); -void SerialPrint_HOST_CR0(); +void PrintTrace_HOST_CR0(); void Set_HOST_CR3(uint_t val); uint_t Get_HOST_CR3(); -void SerialPrint_HOST_CR3(); +void PrintTrace_HOST_CR3(); void Set_HOST_CR4(uint_t val); uint_t Get_HOST_CR4(); -void SerialPrint_HOST_CR4(); +void PrintTrace_HOST_CR4(); void Set_HOST_FS_BASE(uint_t val); uint_t Get_HOST_FS_BASE(); -void SerialPrint_HOST_FS_BASE(); +void PrintTrace_HOST_FS_BASE(); void Set_HOST_GS_BASE(uint_t val); uint_t Get_HOST_GS_BASE(); -void SerialPrint_HOST_GS_BASE(); +void PrintTrace_HOST_GS_BASE(); void Set_HOST_TR_BASE(uint_t val); uint_t Get_HOST_TR_BASE(); -void SerialPrint_HOST_TR_BASE(); +void PrintTrace_HOST_TR_BASE(); void Set_HOST_GDTR_BASE(uint_t val); uint_t Get_HOST_GDTR_BASE(); -void SerialPrint_HOST_GDTR_BASE(); +void PrintTrace_HOST_GDTR_BASE(); void Set_HOST_IDTR_BASE(uint_t val); uint_t Get_HOST_IDTR_BASE(); -void SerialPrint_HOST_IDTR_BASE(); +void PrintTrace_HOST_IDTR_BASE(); void Set_HOST_IA32_SYSENTER_ESP(uint_t val); uint_t Get_HOST_IA32_SYSENTER_ESP(); -void SerialPrint_HOST_IA32_SYSENTER_ESP(); +void PrintTrace_HOST_IA32_SYSENTER_ESP(); void Set_HOST_IA32_SYSENTER_EIP(uint_t val); uint_t Get_HOST_IA32_SYSENTER_EIP(); -void SerialPrint_HOST_IA32_SYSENTER_EIP(); +void PrintTrace_HOST_IA32_SYSENTER_EIP(); void Set_HOST_RSP(uint_t val); uint_t Get_HOST_RSP(); -void SerialPrint_HOST_RSP(); +void PrintTrace_HOST_RSP(); void Set_HOST_RIP(uint_t val); uint_t Get_HOST_RIP(); -void SerialPrint_HOST_RIP(); +void PrintTrace_HOST_RIP(); -void SerialPrint_VMCS_ALL(); +void PrintTrace_VMCS_ALL(); #endif diff --git a/palacios/include/geekos/vmm.h b/palacios/include/geekos/vmm.h index 6cc48e4..467fe24 100644 --- a/palacios/include/geekos/vmm.h +++ b/palacios/include/geekos/vmm.h @@ -2,6 +2,45 @@ #define __VMM_H +#include +#include + + + +/* utility definitions */ +#define PrintDebug(fmt, args...) \ + do { \ + extern struct vmm_os_hooks * os_hooks; \ + if ((os_hooks) && (os_hooks)->print_debug) { \ + (os_hooks)->print_debug((fmt), ##args); \ + } \ + } while (0) \ + + + +#define PrintInfo(fmt, args...) \ + do { \ + extern struct vmm_os_hooks * os_hooks; \ + if ((os_hooks) && (os_hooks)->print_info) { \ + (os_hooks)->print_info((fmt), ##args); \ + } \ + } while (0) \ + + +#define PrintTrace(fmt, args...) \ + do { \ + extern struct vmm_os_hooks * os_hooks; \ + if ((os_hooks) && (os_hooks)->print_trace) { \ + (os_hooks)->print_trace((fmt), ##args); \ + } \ + } while (0) \ + + +/* ** */ + + + + #define VMM_INVALID_CPU 0 #define VMM_VMX_CPU 1 #define VMM_SVM_CPU 2 @@ -9,8 +48,9 @@ /* This will contain function pointers that provide OS services */ struct vmm_os_hooks { - - + void (*print_info)(const char * format, ...); + void (*print_debug)(const char * format, ...); + void (*print_trace)(const char * format, ...); }; @@ -24,7 +64,8 @@ struct vmm_ctrl_ops { -void Init_VMM(); +void Init_VMM(struct vmm_os_hooks * hooks); + diff --git a/palacios/include/geekos/vmm_sizes.h b/palacios/include/geekos/vmm_sizes.h index 39806c1..bdf1052 100644 --- a/palacios/include/geekos/vmm_sizes.h +++ b/palacios/include/geekos/vmm_sizes.h @@ -2,7 +2,7 @@ #define __vmm_sizes #define KERNEL_LOAD_ADDRESS 0x2fe9d000 #define KERNEL_START (KERNEL_LOAD_ADDRESS) -#define KERNEL_CORE_LENGTH ( 230 *512) +#define KERNEL_CORE_LENGTH ( 195 *512) #define KERNEL_END (KERNEL_LOAD_ADDRESS+KERNEL_CORE_LENGTH-1) #define VM_KERNEL_LENGTH ( 97 *512) #define VM_KERNEL_START (KERNEL_LOAD_ADDRESS + KERNEL_CORE_LENGTH) diff --git a/palacios/include/geekos/vmm_util.h b/palacios/include/geekos/vmm_util.h new file mode 100644 index 0000000..144d886 --- /dev/null +++ b/palacios/include/geekos/vmm_util.h @@ -0,0 +1,14 @@ +#ifndef __VMM_UTIL_H +#define __VMM_UTIL_H + +#include + + + +void PrintTraceHex(unsigned char x); + +void PrintTraceMemDump(unsigned char * start, int n); + + + +#endif diff --git a/palacios/scripts/generate_vmcs_serialization.pl b/palacios/scripts/generate_vmcs_serialization.pl index ca1fdeb..747e2c6 100755 --- a/palacios/scripts/generate_vmcs_serialization.pl +++ b/palacios/scripts/generate_vmcs_serialization.pl @@ -9,7 +9,10 @@ $file=shift; open(HEADER,">$file.h"); open(SOURCE,">$file.c"); -print HEADER "#ifndef $file\n#define $file\n#include \n"; +print HEADER "#ifndef $file\n"; +print HEADER "#define $file\n"; +print HEADER "#include \n"; + print SOURCE "#include \n"; while () { @@ -28,10 +31,10 @@ sub GenSerUnserCode { print SOURCE < #include #include +#include #define POLYNOMIAL (ulong_t)0xedb88320 static ulong_t crc_table[256]; diff --git a/palacios/src/geekos/idt.c b/palacios/src/geekos/idt.c index 37c7fd0..c37a4d1 100644 --- a/palacios/src/geekos/idt.c +++ b/palacios/src/geekos/idt.c @@ -1,7 +1,7 @@ /* * GeekOS IDT initialization code * Copyright (c) 2001, David H. Hovemeyer - * $Revision: 1.1 $ + * $Revision: 1.2 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -11,7 +11,7 @@ #include #include #include - +#include /* ---------------------------------------------------------------------- * Private data and functions * ---------------------------------------------------------------------- */ diff --git a/palacios/src/geekos/int.c b/palacios/src/geekos/int.c index b4016f6..70b7b70 100644 --- a/palacios/src/geekos/int.c +++ b/palacios/src/geekos/int.c @@ -1,7 +1,7 @@ /* * GeekOS interrupt handling data structures and functions * Copyright (c) 2001,2003 David H. Hovemeyer - * $Revision: 1.2 $ + * $Revision: 1.3 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -12,7 +12,7 @@ #include #include #include -#include +#include #include @@ -25,6 +25,290 @@ ulong_t Get_Current_EFLAGS(void); * Private functions and data * ---------------------------------------------------------------------- */ + + + + + + + + + + + +char *exception_names[] = { + "#DE (Divide Error)", + "#DB (Reserved)", + "NMI", + "#BP (Breakpoint)", + "#OF (Overflow)", + "#BR (BOUND Range Exceeded)", + "#UD (Invalid Opcode)", + "#NM (No Math Coprocessor)", + "#DF (Double Fault)", + "Coprocessor Segment Overrun", + "#TS (Invalid TSS)", + "#NP (Segment Not Present)", + "#SS (Stack Segment Fault)", + "#GP (General Protection Fault)", + "#PF (Page Fault)", + "(Reserved - 15)", + "#MF (Math Fault x87)", + "#AC (Alignment Check)", + "#MC (Machine Check)", + "#XF (SIMD FP Exception)", + "(Reserved - 20)", + "(Reserved - 21)", + "(Reserved - 22)", + "(Reserved - 23)", + "(Reserved - 24)", + "(Reserved - 25)", + "(Reserved - 26)", + "(Reserved - 27)", + "(Reserved - 28)", + "(Reserved - 29)", + "(Reserved - 30)", + "(Reserved - 31)", + "USER 32", + "USER 33", + "USER 34", + "USER 35", + "USER 36", + "USER 37", + "USER 38", + "USER 39", + "USER 40", + "USER 41", + "USER 42", + "USER 43", + "USER 44", + "USER 45", + "USER 46", + "USER 47", + "USER 48", + "USER 49", + "USER 50", + "USER 51", + "USER 52", + "USER 53", + "USER 54", + "USER 55", + "USER 56", + "USER 57", + "USER 58", + "USER 59", + "USER 60", + "USER 61", + "USER 62", + "USER 63", + "USER 64", + "USER 65", + "USER 66", + "USER 67", + "USER 68", + "USER 69", + "USER 70", + "USER 71", + "USER 72", + "USER 73", + "USER 74", + "USER 75", + "USER 76", + "USER 77", + "USER 78", + "USER 79", + "USER 80", + "USER 81", + "USER 82", + "USER 83", + "USER 84", + "USER 85", + "USER 86", + "USER 87", + "USER 88", + "USER 89", + "USER 90", + "USER 91", + "USER 92", + "USER 93", + "USER 94", + "USER 95", + "USER 96", + "USER 97", + "USER 98", + "USER 99", + "USER 100", + "USER 101", + "USER 102", + "USER 103", + "USER 104", + "USER 105", + "USER 106", + "USER 107", + "USER 108", + "USER 109", + "USER 110", + "USER 111", + "USER 112", + "USER 113", + "USER 114", + "USER 115", + "USER 116", + "USER 117", + "USER 118", + "USER 119", + "USER 120", + "USER 121", + "USER 122", + "USER 123", + "USER 124", + "USER 125", + "USER 126", + "USER 127", + "USER 128", + "USER 129", + "USER 130", + "USER 131", + "USER 132", + "USER 133", + "USER 134", + "USER 135", + "USER 136", + "USER 137", + "USER 138", + "USER 139", + "USER 140", + "USER 141", + "USER 142", + "USER 143", + "USER 144", + "USER 145", + "USER 146", + "USER 147", + "USER 148", + "USER 149", + "USER 150", + "USER 151", + "USER 152", + "USER 153", + "USER 154", + "USER 155", + "USER 156", + "USER 157", + "USER 158", + "USER 159", + "USER 160", + "USER 161", + "USER 162", + "USER 163", + "USER 164", + "USER 165", + "USER 166", + "USER 167", + "USER 168", + "USER 169", + "USER 170", + "USER 171", + "USER 172", + "USER 173", + "USER 174", + "USER 175", + "USER 176", + "USER 177", + "USER 178", + "USER 179", + "USER 180", + "USER 181", + "USER 182", + "USER 183", + "USER 184", + "USER 185", + "USER 186", + "USER 187", + "USER 188", + "USER 189", + "USER 190", + "USER 191", + "USER 192", + "USER 193", + "USER 194", + "USER 195", + "USER 196", + "USER 197", + "USER 198", + "USER 199", + "USER 200", + "USER 201", + "USER 202", + "USER 203", + "USER 204", + "USER 205", + "USER 206", + "USER 207", + "USER 208", + "USER 209", + "USER 210", + "USER 211", + "USER 212", + "USER 213", + "USER 214", + "USER 215", + "USER 216", + "USER 217", + "USER 218", + "USER 219", + "USER 220", + "USER 221", + "USER 222", + "USER 223", + "USER 224", + "USER 225", + "USER 226", + "USER 227", + "USER 228", + "USER 229", + "USER 230", + "USER 231", + "USER 232", + "USER 233", + "USER 234", + "USER 235", + "USER 236", + "USER 237", + "USER 238", + "USER 239", + "USER 240", + "USER 241", + "USER 242", + "USER 243", + "USER 244", + "USER 245", + "USER 246", + "USER 247", + "USER 248", + "USER 249", + "USER 250", + "USER 251", + "USER 252", + "USER 253", + "USER 254", + "USER 255", +}; + +char *exception_type_names[] = { + "External Interrupt", + "NOT USED", + "NMI", + "Hardware Exception", + "NOT USED", + "NOT USED", + "Software Exception", + "NOT USED" +}; + + + + /* * A dummy interrupt handler function. * Ensures that the low-level interrupt code always @@ -132,3 +416,4 @@ void Dump_Interrupt_State(struct Interrupt_State* state) } + diff --git a/palacios/src/geekos/kthread.c b/palacios/src/geekos/kthread.c index e2a6df2..9b614d2 100644 --- a/palacios/src/geekos/kthread.c +++ b/palacios/src/geekos/kthread.c @@ -1,7 +1,7 @@ /* * Kernel threads * Copyright (c) 2001,2003 David H. Hovemeyer - * $Revision: 1.1 $ + * $Revision: 1.2 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -17,6 +17,7 @@ #include #include #include +#include /* ---------------------------------------------------------------------- * Private data diff --git a/palacios/src/geekos/main.c b/palacios/src/geekos/main.c index 2cd5a6a..41ece4d 100644 --- a/palacios/src/geekos/main.c +++ b/palacios/src/geekos/main.c @@ -3,7 +3,7 @@ * Copyright (c) 2001,2003,2004 David H. Hovemeyer * Copyright (c) 2003, Jeffrey K. Hollingsworth * Copyright (c) 2004, Iulian Neamtiu - * $Revision: 1.10 $ + * $Revision: 1.11 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -27,6 +27,7 @@ #include #include +#include #include #include @@ -285,7 +286,7 @@ void Main(struct Boot_Info* bootInfo) Init_Screen(); - InitSerial(); + Init_Serial(); Init_Mem(bootInfo); Init_CRC32(); Init_TSS(); @@ -319,15 +320,13 @@ void Main(struct Boot_Info* bootInfo) - - SerialPrint("\n\nHello, Welcome to this horrid output-only serial interface\n"); - SerialPrint("Eventually, this will let us control the VMM\n\n"); - - SerialPrint("\n\n===>"); - + struct vmm_os_hooks os_hooks; + os_hooks.print_debug = &PrintBoth; + os_hooks.print_info = &Print; + os_hooks.print_trace = &SerialPrint; - Init_VMM(); + Init_VMM(&os_hooks); SerialPrintLevel(1000,"Launching Noisemaker and keyboard listener threads\n"); diff --git a/palacios/src/geekos/mem.c b/palacios/src/geekos/mem.c index 5698c07..b5ae966 100644 --- a/palacios/src/geekos/mem.c +++ b/palacios/src/geekos/mem.c @@ -2,7 +2,7 @@ * Physical memory allocation * Copyright (c) 2001,2003,2004 David H. Hovemeyer * Copyright (c) 2003, Jeffrey K. Hollingsworth - * $Revision: 1.2 $ + * $Revision: 1.3 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -21,6 +21,7 @@ #include #include +#include /* ---------------------------------------------------------------------- * Global data @@ -163,7 +164,7 @@ void Init_Mem(struct Boot_Info* bootInfo) PrintBoth("VM End: %x\n",START_OF_VM+VM_SIZE-1); - PrintBoth("Page struct size: %u bytes\n", sizeof(struct Page)); + PrintBoth("Page struct size: %lu bytes\n", sizeof(struct Page)); PrintBoth("Page List Size: %u bytes\n", numPageListBytes); diff --git a/palacios/src/geekos/paging.c b/palacios/src/geekos/paging.c index bb19af3..6618642 100644 --- a/palacios/src/geekos/paging.c +++ b/palacios/src/geekos/paging.c @@ -2,7 +2,7 @@ * Paging (virtual memory) support * Copyright (c) 2003, Jeffrey K. Hollingsworth * Copyright (c) 2003,2004 David H. Hovemeyer - * $Revision: 1.1 $ + * $Revision: 1.2 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -23,7 +23,7 @@ #include #include #include -#include +#include /* ---------------------------------------------------------------------- * Public data @@ -166,7 +166,7 @@ static void Print_Fault_Info(uint_t address, faultcode_t faultCode) SerialPrintLevel(100,"Unexpected Page Fault received\n"); Print_Fault_Info(address, faultCode); Dump_Interrupt_State(state); - SerialPrint_VMCS_ALL(); + //SerialPrint_VMCS_ALL(); /* user faults just kill the process */ if (!faultCode.userModeFault) KASSERT(0); diff --git a/palacios/src/geekos/screen.c b/palacios/src/geekos/screen.c index 9c78dde..b43dbf4 100644 --- a/palacios/src/geekos/screen.c +++ b/palacios/src/geekos/screen.c @@ -1,7 +1,7 @@ /* * GeekOS text screen output * Copyright (c) 2001,2003,2004 David H. Hovemeyer - * $Revision: 1.1 $ + * $Revision: 1.2 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -12,8 +12,8 @@ #include #include #include -#include #include +#include /* * Information sources for VT100 and ANSI escape sequences: @@ -518,16 +518,26 @@ static struct Output_Sink s_outputSink = { &Print_Emit, &Print_Finish }; * Print to console using printf()-style formatting. * Calls into Format_Output in common library. */ + +static __inline__ void PrintInternal(const char * format, va_list ap) { + Format_Output(&s_outputSink, format, ap); +} + void Print(const char *fmt, ...) { va_list args; - bool iflag = Begin_Int_Atomic(); va_start(args, fmt); - Format_Output(&s_outputSink, fmt, args); + PrintInternal(fmt, args); va_end(args); End_Int_Atomic(iflag); } + +void PrintList(const char * fmt, va_list ap) { + bool iflag = Begin_Int_Atomic(); + PrintInternal(fmt, ap); + End_Int_Atomic(iflag); +} diff --git a/palacios/src/geekos/serial.c b/palacios/src/geekos/serial.c index 68ef275..4f79c84 100644 --- a/palacios/src/geekos/serial.c +++ b/palacios/src/geekos/serial.c @@ -2,11 +2,13 @@ #include #include #include +#include unsigned short serial_io_addr = 0; +uint_t serial_print_level; static void Serial_Interrupt_Handler(struct Interrupt_State * state) { @@ -38,12 +40,7 @@ static void Serial_Interrupt_Handler(struct Interrupt_State * state) { End_IRQ(state); } -void InitSerial() { - Print("Initialzing Serial\n"); - Install_IRQ(COM1_IRQ, Serial_Interrupt_Handler); - Enable_IRQ(COM1_IRQ); - InitSerialAddr(DEFAULT_SERIAL_ADDR); -} + void InitSerialAddr(unsigned short io_addr) { serial_io_addr = io_addr; @@ -68,6 +65,8 @@ void InitSerialAddr(unsigned short io_addr) { } + + inline static void SerialPutChar(unsigned char c) { // static unsigned short io_adr; @@ -138,3 +137,67 @@ void SerialMemDump(unsigned char *start, int n) SerialPrint("\n"); } } + + +static struct Output_Sink serial_output_sink; +static void Serial_Emit(struct Output_Sink * o, int ch) { + SerialPutChar((unsigned char)ch); +} +static void Serial_Finish(struct Output_Sink * o) { return; } + + +static void __inline__ SerialPrintInternal(const char * format, va_list ap) { + Format_Output(&serial_output_sink, format, ap); +} + + +void SerialPrint(const char * format, ...) { + va_list args; + bool iflag = Begin_Int_Atomic(); + + va_start(args, format); + SerialPrintInternal(format, args); + va_end(args); + + End_Int_Atomic(iflag); +} + +void SerialPrintList(const char * format, va_list ap) { + bool iflag = Begin_Int_Atomic(); + SerialPrintInternal(format, ap); + End_Int_Atomic(iflag); + +} + + + + +void SerialPrintLevel(int level, const char * format, ...) { + if (level > serial_print_level) { + va_list args; + bool iflag = Begin_Int_Atomic(); + + va_start(args, format); + SerialPrintInternal(format, args); + va_end(args); + + End_Int_Atomic(iflag); + } +} + + + + +void Init_Serial() { + + serial_print_level = SERIAL_PRINT_DEBUG_LEVEL; + + Print("Initialzing Serial\n"); + + serial_output_sink.Emit = &Serial_Emit; + serial_output_sink.Finish = &Serial_Finish; + + Install_IRQ(COM1_IRQ, Serial_Interrupt_Handler); + Enable_IRQ(COM1_IRQ); + InitSerialAddr(DEFAULT_SERIAL_ADDR); +} diff --git a/palacios/src/geekos/svm.c b/palacios/src/geekos/svm.c index 3f9d278..fcf5a00 100644 --- a/palacios/src/geekos/svm.c +++ b/palacios/src/geekos/svm.c @@ -14,7 +14,7 @@ int is_svm_capable() { if ((ret & CPUID_FEATURE_IDS_ecx_svm_avail) == 0) { - Print("SVM Not Available\n"); + PrintDebug("SVM Not Available\n"); return 0; } @@ -27,9 +27,9 @@ int is_svm_capable() { ret = cpuid_edx(CPUID_SVM_REV_AND_FEATURE_IDS); if ((ret & CPUID_SVM_REV_AND_FEATURE_IDS_edx_svml) == 0) { - Print("SVM BIOS Disabled, not unlockable\n"); + PrintDebug("SVM BIOS Disabled, not unlockable\n"); } else { - Print("SVM is locked with a key\n"); + PrintDebug("SVM is locked with a key\n"); } return 0; @@ -42,7 +42,7 @@ void Init_SVM() { msr_val_low |= EFER_MSR_svm_enable; Set_MSR(EFER_MSR, 0, msr_val_low); - Print("SVM Inited\n"); + PrintDebug("SVM Inited\n"); return; } diff --git a/palacios/src/geekos/timer.c b/palacios/src/geekos/timer.c index d38ec74..113a17f 100644 --- a/palacios/src/geekos/timer.c +++ b/palacios/src/geekos/timer.c @@ -2,7 +2,7 @@ * GeekOS timer interrupt support * Copyright (c) 2001,2003 David H. Hovemeyer * Copyright (c) 2003, Jeffrey K. Hollingsworth - * $Revision: 1.2 $ + * $Revision: 1.3 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -16,6 +16,7 @@ #include #include +#include #define HZ 100 diff --git a/palacios/src/geekos/trap.c b/palacios/src/geekos/trap.c index 2085a99..f1bbf28 100644 --- a/palacios/src/geekos/trap.c +++ b/palacios/src/geekos/trap.c @@ -1,7 +1,7 @@ /* * Trap handlers * Copyright (c) 2001,2003,2004 David H. Hovemeyer - * $Revision: 1.1 $ + * $Revision: 1.2 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -12,7 +12,7 @@ #include #include #include - +#include /* * TODO: need to add handlers for other exceptions (such as bounds * check, debug, etc.) diff --git a/palacios/src/geekos/tss.c b/palacios/src/geekos/tss.c index a94bc52..6936711 100644 --- a/palacios/src/geekos/tss.c +++ b/palacios/src/geekos/tss.c @@ -1,7 +1,7 @@ /* * x86 TSS data structure and routines * Copyright (c) 2001,2004 David H. Hovemeyer - * $Revision: 1.1 $ + * $Revision: 1.2 $ * * This is free software. You are permitted to use, * redistribute, and modify it as specified in the file "COPYING". @@ -20,6 +20,8 @@ #include #include +#include + /* * We use one TSS in GeekOS. @@ -31,6 +33,7 @@ static ushort_t s_tssSelector; static void __inline__ Load_Task_Register(void) { + /* Critical: TSS must be marked as not busy */ s_tssDesc->type = 0x09; diff --git a/palacios/src/geekos/vmcs.c b/palacios/src/geekos/vmcs.c index 5f9de3a..fdb962f 100644 --- a/palacios/src/geekos/vmcs.c +++ b/palacios/src/geekos/vmcs.c @@ -4,276 +4,8 @@ -char *exception_names[] = { - "#DE (Divide Error)", - "#DB (Reserved)", - "NMI", - "#BP (Breakpoint)", - "#OF (Overflow)", - "#BR (BOUND Range Exceeded)", - "#UD (Invalid Opcode)", - "#NM (No Math Coprocessor)", - "#DF (Double Fault)", - "Coprocessor Segment Overrun", - "#TS (Invalid TSS)", - "#NP (Segment Not Present)", - "#SS (Stack Segment Fault)", - "#GP (General Protection Fault)", - "#PF (Page Fault)", - "(Reserved - 15)", - "#MF (Math Fault x87)", - "#AC (Alignment Check)", - "#MC (Machine Check)", - "#XF (SIMD FP Exception)", - "(Reserved - 20)", - "(Reserved - 21)", - "(Reserved - 22)", - "(Reserved - 23)", - "(Reserved - 24)", - "(Reserved - 25)", - "(Reserved - 26)", - "(Reserved - 27)", - "(Reserved - 28)", - "(Reserved - 29)", - "(Reserved - 30)", - "(Reserved - 31)", - "USER 32", - "USER 33", - "USER 34", - "USER 35", - "USER 36", - "USER 37", - "USER 38", - "USER 39", - "USER 40", - "USER 41", - "USER 42", - "USER 43", - "USER 44", - "USER 45", - "USER 46", - "USER 47", - "USER 48", - "USER 49", - "USER 50", - "USER 51", - "USER 52", - "USER 53", - "USER 54", - "USER 55", - "USER 56", - "USER 57", - "USER 58", - "USER 59", - "USER 60", - "USER 61", - "USER 62", - "USER 63", - "USER 64", - "USER 65", - "USER 66", - "USER 67", - "USER 68", - "USER 69", - "USER 70", - "USER 71", - "USER 72", - "USER 73", - "USER 74", - "USER 75", - "USER 76", - "USER 77", - "USER 78", - "USER 79", - "USER 80", - "USER 81", - "USER 82", - "USER 83", - "USER 84", - "USER 85", - "USER 86", - "USER 87", - "USER 88", - "USER 89", - "USER 90", - "USER 91", - "USER 92", - "USER 93", - "USER 94", - "USER 95", - "USER 96", - "USER 97", - "USER 98", - "USER 99", - "USER 100", - "USER 101", - "USER 102", - "USER 103", - "USER 104", - "USER 105", - "USER 106", - "USER 107", - "USER 108", - "USER 109", - "USER 110", - "USER 111", - "USER 112", - "USER 113", - "USER 114", - "USER 115", - "USER 116", - "USER 117", - "USER 118", - "USER 119", - "USER 120", - "USER 121", - "USER 122", - "USER 123", - "USER 124", - "USER 125", - "USER 126", - "USER 127", - "USER 128", - "USER 129", - "USER 130", - "USER 131", - "USER 132", - "USER 133", - "USER 134", - "USER 135", - "USER 136", - "USER 137", - "USER 138", - "USER 139", - "USER 140", - "USER 141", - "USER 142", - "USER 143", - "USER 144", - "USER 145", - "USER 146", - "USER 147", - "USER 148", - "USER 149", - "USER 150", - "USER 151", - "USER 152", - "USER 153", - "USER 154", - "USER 155", - "USER 156", - "USER 157", - "USER 158", - "USER 159", - "USER 160", - "USER 161", - "USER 162", - "USER 163", - "USER 164", - "USER 165", - "USER 166", - "USER 167", - "USER 168", - "USER 169", - "USER 170", - "USER 171", - "USER 172", - "USER 173", - "USER 174", - "USER 175", - "USER 176", - "USER 177", - "USER 178", - "USER 179", - "USER 180", - "USER 181", - "USER 182", - "USER 183", - "USER 184", - "USER 185", - "USER 186", - "USER 187", - "USER 188", - "USER 189", - "USER 190", - "USER 191", - "USER 192", - "USER 193", - "USER 194", - "USER 195", - "USER 196", - "USER 197", - "USER 198", - "USER 199", - "USER 200", - "USER 201", - "USER 202", - "USER 203", - "USER 204", - "USER 205", - "USER 206", - "USER 207", - "USER 208", - "USER 209", - "USER 210", - "USER 211", - "USER 212", - "USER 213", - "USER 214", - "USER 215", - "USER 216", - "USER 217", - "USER 218", - "USER 219", - "USER 220", - "USER 221", - "USER 222", - "USER 223", - "USER 224", - "USER 225", - "USER 226", - "USER 227", - "USER 228", - "USER 229", - "USER 230", - "USER 231", - "USER 232", - "USER 233", - "USER 234", - "USER 235", - "USER 236", - "USER 237", - "USER 238", - "USER 239", - "USER 240", - "USER 241", - "USER 242", - "USER 243", - "USER 244", - "USER 245", - "USER 246", - "USER 247", - "USER 248", - "USER 249", - "USER 250", - "USER 251", - "USER 252", - "USER 253", - "USER 254", - "USER 255", -}; - -char *exception_type_names[] = { - "External Interrupt", - "NOT USED", - "NMI", - "Hardware Exception", - "NOT USED", - "NOT USED", - "Software Exception", - "NOT USED" -}; +//extern char * exception_names; // // Ignores "HIGH" addresses - 32 bit only for now // @@ -615,175 +347,175 @@ int CopyInVMCSData(struct VMCSData *p) { } -void SerialPrint_VMX_Regs(struct VMXRegs * regs) { - SerialPrint("==>VMX Register values:\n"); - SerialPrint("EAX: %x\n", regs->eax); - SerialPrint("ECX: %x\n", regs->ecx); - SerialPrint("EDX: %x\n", regs->edx); - SerialPrint("EBX: %x\n", regs->ebx); - SerialPrint("ESP: %x\n", regs->esp); - SerialPrint("EBP: %x\n", regs->ebp); - SerialPrint("ESI: %x\n", regs->esi); - SerialPrint("EDI: %x\n", regs->edi); - SerialPrint("\n"); +void PrintTrace_VMX_Regs(struct VMXRegs * regs) { + PrintTrace("==>VMX Register values:\n"); + PrintTrace("EAX: %x\n", regs->eax); + PrintTrace("ECX: %x\n", regs->ecx); + PrintTrace("EDX: %x\n", regs->edx); + PrintTrace("EBX: %x\n", regs->ebx); + PrintTrace("ESP: %x\n", regs->esp); + PrintTrace("EBP: %x\n", regs->ebp); + PrintTrace("ESI: %x\n", regs->esi); + PrintTrace("EDI: %x\n", regs->edi); + PrintTrace("\n"); } -void SerialPrint_VMCSSegment(char * segname, struct VMCSSegment * seg, int abbr) { - SerialPrint("Segment: %s\n", segname); +void PrintTrace_VMCSSegment(char * segname, struct VMCSSegment * seg, int abbr) { + PrintTrace("Segment: %s\n", segname); if (abbr == 0) { - SerialPrint("\tSelector: %x\n", (uint_t)seg->selector); - SerialPrint("\tAccess: %x\n", *(uint_t*)&(seg->access)); + PrintTrace("\tSelector: %x\n", (uint_t)seg->selector); + PrintTrace("\tAccess: %x\n", *(uint_t*)&(seg->access)); } - SerialPrint("\tBase Addr: %x\n", (uint_t)seg->baseAddr); - SerialPrint("\tLimit: %x\n", (uint_t)seg->limit); + PrintTrace("\tBase Addr: %x\n", (uint_t)seg->baseAddr); + PrintTrace("\tLimit: %x\n", (uint_t)seg->limit); } -void SerialPrint_VMCSGuestStateArea(struct VMCSGuestStateArea * guestState) { - SerialPrint("==>Guest State Area\n"); - SerialPrint("==>==> Guest Register State\n"); - SerialPrint("GUEST_CR0: %x\n",(uint_t) guestState->cr0); - SerialPrint("GUEST_CR3: %x\n",(uint_t)guestState->cr3); - SerialPrint("GUEST_CR4: %x\n",(uint_t)guestState->cr4); - SerialPrint("GUEST_DR7: %x\n",(uint_t)guestState->dr7); - SerialPrint("GUEST_RSP: %x\n",(uint_t)guestState->rsp); - SerialPrint("GUEST_RIP: %x\n",(uint_t)guestState->rip); - SerialPrint("GUEST_RFLAGS: %x\n",(uint_t)guestState->rflags); - - SerialPrint_VMCSSegment("Guest CS", &(guestState->cs), 0); - SerialPrint_VMCSSegment("Guest SS", &(guestState->ss), 0); - SerialPrint_VMCSSegment("Guest DS",&(guestState->ds), 0); - SerialPrint_VMCSSegment("Guest ES", &(guestState->es), 0); - SerialPrint_VMCSSegment("Guest FS", &(guestState->fs), 0); - SerialPrint_VMCSSegment("Guest GS", &(guestState->gs), 0); - SerialPrint_VMCSSegment("Guest LDTR", &(guestState->ldtr), 0); - SerialPrint_VMCSSegment("Guest TR", &(guestState->tr), 0); - SerialPrint_VMCSSegment("Guest GDTR", &(guestState->gdtr), 1); - SerialPrint_VMCSSegment("Guest IDTR", &(guestState->idtr), 1); - - - SerialPrint("GUEST_IA32_DEBUGCTL: %x\n",(uint_t)(guestState->dbg_ctrl & 0xffffffff)); - SerialPrint("GUEST_IA32_DEBUGCTL_HIGH: %x\n",(uint_t)(guestState->dbg_ctrl >> 32) & 0xffffffff); - SerialPrint("GUEST_IA32_SYSENTER_CS: %x\n",guestState->sysenter_cs); - SerialPrint("GUEST_IA32_SYSENTER_ESP: %x\n",(uint_t)guestState->sysenter_esp); - SerialPrint("GUEST_IA32_SYSENTER_EIP: %x\n",(uint_t)guestState->sysenter_eip); - SerialPrint("GUEST_SMBASE: %x\n", (uint_t)guestState->smbase); - - SerialPrint("==>==> Guest Non-Register State\n"); - SerialPrint("GUEST_ACTIVITY_STATE: %x\n", (uint_t)guestState->activity); - SerialPrint("GUEST_INT_STATE: %x\n", (uint_t)guestState->interrupt_state); - SerialPrint("GUEST_PENDING_DEBUG_EXCS: %x\n", (uint_t)guestState->pending_dbg_exceptions); - SerialPrint("VMCS_LINK_PTR: %x\n", (uint_t)guestState->vmcs_link & 0xffffffff); - SerialPrint("VMCS_LINK_PTR_HIGH: %x\n", (uint_t)(guestState->vmcs_link >> 32) & 0xffffffff); +void PrintTrace_VMCSGuestStateArea(struct VMCSGuestStateArea * guestState) { + PrintTrace("==>Guest State Area\n"); + PrintTrace("==>==> Guest Register State\n"); + PrintTrace("GUEST_CR0: %x\n",(uint_t) guestState->cr0); + PrintTrace("GUEST_CR3: %x\n",(uint_t)guestState->cr3); + PrintTrace("GUEST_CR4: %x\n",(uint_t)guestState->cr4); + PrintTrace("GUEST_DR7: %x\n",(uint_t)guestState->dr7); + PrintTrace("GUEST_RSP: %x\n",(uint_t)guestState->rsp); + PrintTrace("GUEST_RIP: %x\n",(uint_t)guestState->rip); + PrintTrace("GUEST_RFLAGS: %x\n",(uint_t)guestState->rflags); + + PrintTrace_VMCSSegment("Guest CS", &(guestState->cs), 0); + PrintTrace_VMCSSegment("Guest SS", &(guestState->ss), 0); + PrintTrace_VMCSSegment("Guest DS",&(guestState->ds), 0); + PrintTrace_VMCSSegment("Guest ES", &(guestState->es), 0); + PrintTrace_VMCSSegment("Guest FS", &(guestState->fs), 0); + PrintTrace_VMCSSegment("Guest GS", &(guestState->gs), 0); + PrintTrace_VMCSSegment("Guest LDTR", &(guestState->ldtr), 0); + PrintTrace_VMCSSegment("Guest TR", &(guestState->tr), 0); + PrintTrace_VMCSSegment("Guest GDTR", &(guestState->gdtr), 1); + PrintTrace_VMCSSegment("Guest IDTR", &(guestState->idtr), 1); + + + PrintTrace("GUEST_IA32_DEBUGCTL: %x\n",(uint_t)(guestState->dbg_ctrl & 0xffffffff)); + PrintTrace("GUEST_IA32_DEBUGCTL_HIGH: %x\n",(uint_t)(guestState->dbg_ctrl >> 32) & 0xffffffff); + PrintTrace("GUEST_IA32_SYSENTER_CS: %x\n",guestState->sysenter_cs); + PrintTrace("GUEST_IA32_SYSENTER_ESP: %x\n",(uint_t)guestState->sysenter_esp); + PrintTrace("GUEST_IA32_SYSENTER_EIP: %x\n",(uint_t)guestState->sysenter_eip); + PrintTrace("GUEST_SMBASE: %x\n", (uint_t)guestState->smbase); + + PrintTrace("==>==> Guest Non-Register State\n"); + PrintTrace("GUEST_ACTIVITY_STATE: %x\n", (uint_t)guestState->activity); + PrintTrace("GUEST_INT_STATE: %x\n", (uint_t)guestState->interrupt_state); + PrintTrace("GUEST_PENDING_DEBUG_EXCS: %x\n", (uint_t)guestState->pending_dbg_exceptions); + PrintTrace("VMCS_LINK_PTR: %x\n", (uint_t)guestState->vmcs_link & 0xffffffff); + PrintTrace("VMCS_LINK_PTR_HIGH: %x\n", (uint_t)(guestState->vmcs_link >> 32) & 0xffffffff); } -void SerialPrint_VMCSHostStateArea(struct VMCSHostStateArea * hostState) { - SerialPrint("\n==> Host State Area\n"); - SerialPrint("HOST_CR0: %x\n", (uint_t)hostState->cr0); - SerialPrint("HOST_CR3: %x\n", (uint_t)hostState->cr3); - SerialPrint("HOST_CR4: %x\n", (uint_t)hostState->cr4); - SerialPrint("HOST_RSP: %x\n", (uint_t)hostState->rsp); - SerialPrint("HOST_RIP: %x\n", (uint_t)hostState->rip); - SerialPrint("VMCS_HOST_CS_SELECTOR: %x\n", (uint_t)hostState->csSelector); - SerialPrint("VMCS_HOST_SS_SELECTOR: %x\n", (uint_t)hostState->ssSelector); - SerialPrint("VMCS_HOST_DS_SELECTOR: %x\n", (uint_t)hostState->dsSelector); - SerialPrint("VMCS_HOST_ES_SELECTOR: %x\n", (uint_t)hostState->esSelector); - SerialPrint("VMCS_HOST_FS_SELECTOR: %x\n", (uint_t)hostState->fsSelector); - SerialPrint("VMCS_HOST_GS_SELECTOR: %x\n", (uint_t)hostState->gsSelector); - SerialPrint("VMCS_HOST_TR_SELECTOR: %x\n", (uint_t)hostState->trSelector); - SerialPrint("HOST_FS_BASE: %x\n", (uint_t)hostState->fsBaseAddr); - SerialPrint("HOST_GS_BASE: %x\n", (uint_t)hostState->gsBaseAddr); - SerialPrint("HOST_TR_BASE: %x\n", (uint_t)hostState->trBaseAddr); - SerialPrint("HOST_GDTR_BASE: %x\n", (uint_t)hostState->gdtrBaseAddr); - SerialPrint("HOST_IDTR_BASE: %x\n", (uint_t)hostState->idtrBaseAddr); - SerialPrint("HOST_IA32_SYSENTER_CS: %x\n", (uint_t)hostState->sysenter_cs); - SerialPrint("HOST_IA32_SYSENTER_ESP: %x\n", (uint_t)hostState->sysenter_esp); - SerialPrint("HOST_IA32_SYSENTER_EIP: %x\n", (uint_t)hostState->sysenter_eip); +void PrintTrace_VMCSHostStateArea(struct VMCSHostStateArea * hostState) { + PrintTrace("\n==> Host State Area\n"); + PrintTrace("HOST_CR0: %x\n", (uint_t)hostState->cr0); + PrintTrace("HOST_CR3: %x\n", (uint_t)hostState->cr3); + PrintTrace("HOST_CR4: %x\n", (uint_t)hostState->cr4); + PrintTrace("HOST_RSP: %x\n", (uint_t)hostState->rsp); + PrintTrace("HOST_RIP: %x\n", (uint_t)hostState->rip); + PrintTrace("VMCS_HOST_CS_SELECTOR: %x\n", (uint_t)hostState->csSelector); + PrintTrace("VMCS_HOST_SS_SELECTOR: %x\n", (uint_t)hostState->ssSelector); + PrintTrace("VMCS_HOST_DS_SELECTOR: %x\n", (uint_t)hostState->dsSelector); + PrintTrace("VMCS_HOST_ES_SELECTOR: %x\n", (uint_t)hostState->esSelector); + PrintTrace("VMCS_HOST_FS_SELECTOR: %x\n", (uint_t)hostState->fsSelector); + PrintTrace("VMCS_HOST_GS_SELECTOR: %x\n", (uint_t)hostState->gsSelector); + PrintTrace("VMCS_HOST_TR_SELECTOR: %x\n", (uint_t)hostState->trSelector); + PrintTrace("HOST_FS_BASE: %x\n", (uint_t)hostState->fsBaseAddr); + PrintTrace("HOST_GS_BASE: %x\n", (uint_t)hostState->gsBaseAddr); + PrintTrace("HOST_TR_BASE: %x\n", (uint_t)hostState->trBaseAddr); + PrintTrace("HOST_GDTR_BASE: %x\n", (uint_t)hostState->gdtrBaseAddr); + PrintTrace("HOST_IDTR_BASE: %x\n", (uint_t)hostState->idtrBaseAddr); + PrintTrace("HOST_IA32_SYSENTER_CS: %x\n", (uint_t)hostState->sysenter_cs); + PrintTrace("HOST_IA32_SYSENTER_ESP: %x\n", (uint_t)hostState->sysenter_esp); + PrintTrace("HOST_IA32_SYSENTER_EIP: %x\n", (uint_t)hostState->sysenter_eip); } -void SerialPrint_VMCSExecCtrlFields(struct VMCSExecCtrlFields * execCtrls) { - SerialPrint("\n==> VM-Execution Controls:\n"); - SerialPrint("PIN_VM_EXEC_CTRLS: %x\n", (uint_t) execCtrls->pinCtrls); - SerialPrint("PROC_VM_EXEC_CTRLS: %x\n", (uint_t) execCtrls->procCtrls); - SerialPrint("EXCEPTION_BITMAP: %x\n", (uint_t) execCtrls->execBitmap); - SerialPrint("PAGE_FAULT_ERROR_MASK: %x\n", (uint_t) execCtrls->pageFaultErrorMask); - SerialPrint("PAGE_FAULT_ERROR_MATCH: %x\n", (uint_t) execCtrls->pageFaultErrorMatch); - SerialPrint("IO_BITMAP_A_ADDR: %x\n", (uint_t) execCtrls->ioBitmapA); - // SerialPrint("IO_BITMAP_A_ADDR_HIGH: %x\n", (uint_t) execCtrls->); - SerialPrint("IO_BITMAP_B_ADDR: %x\n", (uint_t) execCtrls->ioBitmapB); - // SerialPrint("IO_BITMAP_B_ADDR_HIGH: %x\n", (uint_t) execCtrls->); - SerialPrint("TSC_OFFSET: %x\n", (uint_t) execCtrls->tscOffset & 0xffffffff); - SerialPrint("TSC_OFFSET_HIGH: %x\n", (uint_t) (execCtrls->tscOffset >> 32) & 0xffffffff); - SerialPrint("CR0_GUEST_HOST_MASK: %x\n", (uint_t) execCtrls->cr0GuestHostMask); - SerialPrint("CR0_READ_SHADOW: %x\n", (uint_t) execCtrls->cr0ReadShadow); - SerialPrint("CR4_GUEST_HOST_MASK: %x\n", (uint_t) execCtrls->cr4GuestHostMask); - SerialPrint("CR4_READ_SHADOW: %x\n", (uint_t) execCtrls->cr4ReadShadow); - SerialPrint("CR3_TARGET_COUNT: %x\n", (uint_t) execCtrls->cr3TargetCount); - SerialPrint("CR3_TARGET_VALUE_0: %x\n", (uint_t) execCtrls->cr3TargetValue0); - SerialPrint("CR3_TARGET_VALUE_1: %x\n", (uint_t) execCtrls->cr3TargetValue1); - SerialPrint("CR3_TARGET_VALUE_2: %x\n", (uint_t) execCtrls->cr3TargetValue2); - SerialPrint("CR3_TARGET_VALUE_3: %x\n", (uint_t) execCtrls->cr3TargetValue3); - SerialPrint("VIRT_APIC_PAGE_ADDR: %x\n", (uint_t) execCtrls->virtApicPageAddr & 0xffffffff); - SerialPrint("VIRT_APIC_PAGE_ADDR_HIGH: %x\n", (uint_t) (execCtrls->virtApicPageAddr >> 32) & 0xffffffff); - SerialPrint("TPR_THRESHOLD: %x\n", (uint_t) execCtrls->tprThreshold); - SerialPrint("MSR_BITMAPS: %x\n", (uint_t) execCtrls->MSRBitmapsBaseAddr & 0xffffffff); - SerialPrint("MSR_BITMAPS_HIGH: %x\n", (uint_t) (execCtrls->MSRBitmapsBaseAddr >> 32) & 0xffffffff); - SerialPrint("VMCS_EXEC_PTR: %x\n", (uint_t) execCtrls->vmcsExecPtr & 0xffffffff); - SerialPrint("VMCS_EXEC_PTR_HIGH: %x\n", (uint_t) (execCtrls->vmcsExecPtr >> 32) & 0xffffffff); +void PrintTrace_VMCSExecCtrlFields(struct VMCSExecCtrlFields * execCtrls) { + PrintTrace("\n==> VM-Execution Controls:\n"); + PrintTrace("PIN_VM_EXEC_CTRLS: %x\n", (uint_t) execCtrls->pinCtrls); + PrintTrace("PROC_VM_EXEC_CTRLS: %x\n", (uint_t) execCtrls->procCtrls); + PrintTrace("EXCEPTION_BITMAP: %x\n", (uint_t) execCtrls->execBitmap); + PrintTrace("PAGE_FAULT_ERROR_MASK: %x\n", (uint_t) execCtrls->pageFaultErrorMask); + PrintTrace("PAGE_FAULT_ERROR_MATCH: %x\n", (uint_t) execCtrls->pageFaultErrorMatch); + PrintTrace("IO_BITMAP_A_ADDR: %x\n", (uint_t) execCtrls->ioBitmapA); + // PrintTrace("IO_BITMAP_A_ADDR_HIGH: %x\n", (uint_t) execCtrls->); + PrintTrace("IO_BITMAP_B_ADDR: %x\n", (uint_t) execCtrls->ioBitmapB); + // PrintTrace("IO_BITMAP_B_ADDR_HIGH: %x\n", (uint_t) execCtrls->); + PrintTrace("TSC_OFFSET: %x\n", (uint_t) execCtrls->tscOffset & 0xffffffff); + PrintTrace("TSC_OFFSET_HIGH: %x\n", (uint_t) (execCtrls->tscOffset >> 32) & 0xffffffff); + PrintTrace("CR0_GUEST_HOST_MASK: %x\n", (uint_t) execCtrls->cr0GuestHostMask); + PrintTrace("CR0_READ_SHADOW: %x\n", (uint_t) execCtrls->cr0ReadShadow); + PrintTrace("CR4_GUEST_HOST_MASK: %x\n", (uint_t) execCtrls->cr4GuestHostMask); + PrintTrace("CR4_READ_SHADOW: %x\n", (uint_t) execCtrls->cr4ReadShadow); + PrintTrace("CR3_TARGET_COUNT: %x\n", (uint_t) execCtrls->cr3TargetCount); + PrintTrace("CR3_TARGET_VALUE_0: %x\n", (uint_t) execCtrls->cr3TargetValue0); + PrintTrace("CR3_TARGET_VALUE_1: %x\n", (uint_t) execCtrls->cr3TargetValue1); + PrintTrace("CR3_TARGET_VALUE_2: %x\n", (uint_t) execCtrls->cr3TargetValue2); + PrintTrace("CR3_TARGET_VALUE_3: %x\n", (uint_t) execCtrls->cr3TargetValue3); + PrintTrace("VIRT_APIC_PAGE_ADDR: %x\n", (uint_t) execCtrls->virtApicPageAddr & 0xffffffff); + PrintTrace("VIRT_APIC_PAGE_ADDR_HIGH: %x\n", (uint_t) (execCtrls->virtApicPageAddr >> 32) & 0xffffffff); + PrintTrace("TPR_THRESHOLD: %x\n", (uint_t) execCtrls->tprThreshold); + PrintTrace("MSR_BITMAPS: %x\n", (uint_t) execCtrls->MSRBitmapsBaseAddr & 0xffffffff); + PrintTrace("MSR_BITMAPS_HIGH: %x\n", (uint_t) (execCtrls->MSRBitmapsBaseAddr >> 32) & 0xffffffff); + PrintTrace("VMCS_EXEC_PTR: %x\n", (uint_t) execCtrls->vmcsExecPtr & 0xffffffff); + PrintTrace("VMCS_EXEC_PTR_HIGH: %x\n", (uint_t) (execCtrls->vmcsExecPtr >> 32) & 0xffffffff); } -void SerialPrint_VMCSExitCtrlFields(struct VMCSExitCtrlFields * exitCtrls) { - SerialPrint("\n==> VM Exit Controls\n"); - SerialPrint("VM_EXIT_CTRLS: %x\n", (uint_t) exitCtrls->exitCtrls); - SerialPrint("VM_EXIT_MSR_STORE_COUNT: %x\n", (uint_t) exitCtrls->msrStoreCount); - SerialPrint("VM_EXIT_MSR_STORE_ADDR: %x\n", (uint_t) exitCtrls->msrStoreAddr & 0xffffffff); - SerialPrint("VM_EXIT_MSR_STORE_ADDR_HIGH: %x\n", (uint_t) (exitCtrls->msrStoreAddr >> 32) & 0xffffffff); - SerialPrint("VM_EXIT_MSR_LOAD_COUNT: %x\n", (uint_t) exitCtrls->msrLoadCount); - SerialPrint("VM_EXIT_MSR_LOAD_ADDR: %x\n", (uint_t) exitCtrls->msrLoadAddr & 0xffffffff); - SerialPrint("VM_EXIT_MSR_LOAD_ADDR_HIGH: %x\n", (uint_t) (exitCtrls->msrLoadAddr >> 32) & 0xffffffff); +void PrintTrace_VMCSExitCtrlFields(struct VMCSExitCtrlFields * exitCtrls) { + PrintTrace("\n==> VM Exit Controls\n"); + PrintTrace("VM_EXIT_CTRLS: %x\n", (uint_t) exitCtrls->exitCtrls); + PrintTrace("VM_EXIT_MSR_STORE_COUNT: %x\n", (uint_t) exitCtrls->msrStoreCount); + PrintTrace("VM_EXIT_MSR_STORE_ADDR: %x\n", (uint_t) exitCtrls->msrStoreAddr & 0xffffffff); + PrintTrace("VM_EXIT_MSR_STORE_ADDR_HIGH: %x\n", (uint_t) (exitCtrls->msrStoreAddr >> 32) & 0xffffffff); + PrintTrace("VM_EXIT_MSR_LOAD_COUNT: %x\n", (uint_t) exitCtrls->msrLoadCount); + PrintTrace("VM_EXIT_MSR_LOAD_ADDR: %x\n", (uint_t) exitCtrls->msrLoadAddr & 0xffffffff); + PrintTrace("VM_EXIT_MSR_LOAD_ADDR_HIGH: %x\n", (uint_t) (exitCtrls->msrLoadAddr >> 32) & 0xffffffff); } -void SerialPrint_VMCSEntryCtrlFields(struct VMCSEntryCtrlFields * entryCtrls) { - SerialPrint("\n==> VM Entry Controls\n"); - SerialPrint("VM_ENTRY_CTRLS: %x\n", (uint_t) entryCtrls->entryCtrls); - SerialPrint("VM_ENTRY_MSR_LOAD_COUNT: %x\n", (uint_t) entryCtrls->msrLoadCount); - SerialPrint("VM_ENTRY_MSR_LOAD_ADDR: %x\n", (uint_t) entryCtrls->msrLoadAddr & 0xffffffff); - SerialPrint("VM_ENTRY_MSR_LOAD_ADDR_HIGH: %x\n", (uint_t) (entryCtrls->msrLoadAddr >> 32) & 0xffffffff); - SerialPrint("VM_ENTRY_INT_INFO_FIELD: %x\n", (uint_t) entryCtrls->intInfo); - SerialPrint("VM_ENTRY_EXCEPTION_ERROR: %x\n", (uint_t) entryCtrls->exceptionErrorCode); - SerialPrint("VM_ENTRY_INSTR_LENGTH: %x\n", (uint_t) entryCtrls->instrLength); +void PrintTrace_VMCSEntryCtrlFields(struct VMCSEntryCtrlFields * entryCtrls) { + PrintTrace("\n==> VM Entry Controls\n"); + PrintTrace("VM_ENTRY_CTRLS: %x\n", (uint_t) entryCtrls->entryCtrls); + PrintTrace("VM_ENTRY_MSR_LOAD_COUNT: %x\n", (uint_t) entryCtrls->msrLoadCount); + PrintTrace("VM_ENTRY_MSR_LOAD_ADDR: %x\n", (uint_t) entryCtrls->msrLoadAddr & 0xffffffff); + PrintTrace("VM_ENTRY_MSR_LOAD_ADDR_HIGH: %x\n", (uint_t) (entryCtrls->msrLoadAddr >> 32) & 0xffffffff); + PrintTrace("VM_ENTRY_INT_INFO_FIELD: %x\n", (uint_t) entryCtrls->intInfo); + PrintTrace("VM_ENTRY_EXCEPTION_ERROR: %x\n", (uint_t) entryCtrls->exceptionErrorCode); + PrintTrace("VM_ENTRY_INSTR_LENGTH: %x\n", (uint_t) entryCtrls->instrLength); } -void SerialPrint_VMCSExitInfoFields(struct VMCSExitInfoFields * exitInfo) { - SerialPrint("\n==> VM Exit Info\n"); - SerialPrint("EXIT_REASON: %x\n", (uint_t) exitInfo->reason); - SerialPrint("EXIT_QUALIFICATION: %x\n", (uint_t) exitInfo->qualification); - SerialPrint("VM_EXIT_INT_INFO: %x\n", (uint_t) exitInfo->intInfo); - SerialPrint("VM_EXIT_INT_ERROR: %x\n", (uint_t) exitInfo->intErrorCode); - SerialPrint("IDT_VECTOR_INFO: %x\n", (uint_t) exitInfo->idtVectorInfo); - SerialPrint("IDT_VECTOR_ERROR: %x\n", (uint_t) exitInfo->idtVectorErrorCode); - SerialPrint("VM_EXIT_INSTR_LENGTH: %x\n", (uint_t) exitInfo->instrLength); - SerialPrint("GUEST_LINEAR_ADDR: %x\n", (uint_t) exitInfo->guestLinearAddr); - SerialPrint("VMX_INSTR_INFO: %x\n", (uint_t) exitInfo->instrInfo); - SerialPrint("IO_RCX: %x\n", (uint_t) exitInfo->ioRCX); - SerialPrint("IO_RSI: %x\n", (uint_t) exitInfo->ioRSI); - SerialPrint("IO_RDI: %x\n", (uint_t) exitInfo->ioRDI); - SerialPrint("IO_RIP: %x\n", (uint_t) exitInfo->ioRIP); - SerialPrint("VM_INSTR_ERROR: %x\n", (uint_t) exitInfo->instrErrorField); +void PrintTrace_VMCSExitInfoFields(struct VMCSExitInfoFields * exitInfo) { + PrintTrace("\n==> VM Exit Info\n"); + PrintTrace("EXIT_REASON: %x\n", (uint_t) exitInfo->reason); + PrintTrace("EXIT_QUALIFICATION: %x\n", (uint_t) exitInfo->qualification); + PrintTrace("VM_EXIT_INT_INFO: %x\n", (uint_t) exitInfo->intInfo); + PrintTrace("VM_EXIT_INT_ERROR: %x\n", (uint_t) exitInfo->intErrorCode); + PrintTrace("IDT_VECTOR_INFO: %x\n", (uint_t) exitInfo->idtVectorInfo); + PrintTrace("IDT_VECTOR_ERROR: %x\n", (uint_t) exitInfo->idtVectorErrorCode); + PrintTrace("VM_EXIT_INSTR_LENGTH: %x\n", (uint_t) exitInfo->instrLength); + PrintTrace("GUEST_LINEAR_ADDR: %x\n", (uint_t) exitInfo->guestLinearAddr); + PrintTrace("VMX_INSTR_INFO: %x\n", (uint_t) exitInfo->instrInfo); + PrintTrace("IO_RCX: %x\n", (uint_t) exitInfo->ioRCX); + PrintTrace("IO_RSI: %x\n", (uint_t) exitInfo->ioRSI); + PrintTrace("IO_RDI: %x\n", (uint_t) exitInfo->ioRDI); + PrintTrace("IO_RIP: %x\n", (uint_t) exitInfo->ioRIP); + PrintTrace("VM_INSTR_ERROR: %x\n", (uint_t) exitInfo->instrErrorField); } -void SerialPrint_VMCSData(struct VMCSData * vmcs) { - SerialPrint("VMCSData Structure\n"); +void PrintTrace_VMCSData(struct VMCSData * vmcs) { + PrintTrace("VMCSData Structure\n"); - SerialPrint_VMCSGuestStateArea(&(vmcs->guestStateArea)); - SerialPrint_VMCSHostStateArea(&(vmcs->hostStateArea)); - SerialPrint_VMCSExecCtrlFields(&(vmcs->execCtrlFields)); - SerialPrint_VMCSExitCtrlFields(&(vmcs->exitCtrlFields)); - SerialPrint_VMCSEntryCtrlFields(&(vmcs->entryCtrlFields)); - SerialPrint_VMCSExitInfoFields(&(vmcs->exitInfoFields)); - SerialPrint("\n"); + PrintTrace_VMCSGuestStateArea(&(vmcs->guestStateArea)); + PrintTrace_VMCSHostStateArea(&(vmcs->hostStateArea)); + PrintTrace_VMCSExecCtrlFields(&(vmcs->execCtrlFields)); + PrintTrace_VMCSExitCtrlFields(&(vmcs->exitCtrlFields)); + PrintTrace_VMCSEntryCtrlFields(&(vmcs->entryCtrlFields)); + PrintTrace_VMCSExitInfoFields(&(vmcs->exitInfoFields)); + PrintTrace("\n"); } diff --git a/palacios/src/geekos/vmcs_gen.c b/palacios/src/geekos/vmcs_gen.c index c96127e..76e49ba 100644 --- a/palacios/src/geekos/vmcs_gen.c +++ b/palacios/src/geekos/vmcs_gen.c @@ -6,921 +6,921 @@ void Set_VMCS_GUEST_ES_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_GUEST_ES_SELECTOR,val); } uint_t Get_VMCS_GUEST_ES_SELECTOR() { uint_t rc; VMCS_READ(VMCS_GUEST_ES_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_GUEST_ES_SELECTOR() { SerialPrint("VMCS_GUEST_ES_SELECTOR = %x\n", Get_VMCS_GUEST_ES_SELECTOR()); } +void PrintTrace_VMCS_GUEST_ES_SELECTOR() { PrintTrace("VMCS_GUEST_ES_SELECTOR = %x\n", Get_VMCS_GUEST_ES_SELECTOR()); } void Set_VMCS_GUEST_CS_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_GUEST_CS_SELECTOR,val); } uint_t Get_VMCS_GUEST_CS_SELECTOR() { uint_t rc; VMCS_READ(VMCS_GUEST_CS_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_GUEST_CS_SELECTOR() { SerialPrint("VMCS_GUEST_CS_SELECTOR = %x\n", Get_VMCS_GUEST_CS_SELECTOR()); } +void PrintTrace_VMCS_GUEST_CS_SELECTOR() { PrintTrace("VMCS_GUEST_CS_SELECTOR = %x\n", Get_VMCS_GUEST_CS_SELECTOR()); } void Set_VMCS_GUEST_SS_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_GUEST_SS_SELECTOR,val); } uint_t Get_VMCS_GUEST_SS_SELECTOR() { uint_t rc; VMCS_READ(VMCS_GUEST_SS_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_GUEST_SS_SELECTOR() { SerialPrint("VMCS_GUEST_SS_SELECTOR = %x\n", Get_VMCS_GUEST_SS_SELECTOR()); } +void PrintTrace_VMCS_GUEST_SS_SELECTOR() { PrintTrace("VMCS_GUEST_SS_SELECTOR = %x\n", Get_VMCS_GUEST_SS_SELECTOR()); } void Set_VMCS_GUEST_DS_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_GUEST_DS_SELECTOR,val); } uint_t Get_VMCS_GUEST_DS_SELECTOR() { uint_t rc; VMCS_READ(VMCS_GUEST_DS_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_GUEST_DS_SELECTOR() { SerialPrint("VMCS_GUEST_DS_SELECTOR = %x\n", Get_VMCS_GUEST_DS_SELECTOR()); } +void PrintTrace_VMCS_GUEST_DS_SELECTOR() { PrintTrace("VMCS_GUEST_DS_SELECTOR = %x\n", Get_VMCS_GUEST_DS_SELECTOR()); } void Set_VMCS_GUEST_FS_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_GUEST_FS_SELECTOR,val); } uint_t Get_VMCS_GUEST_FS_SELECTOR() { uint_t rc; VMCS_READ(VMCS_GUEST_FS_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_GUEST_FS_SELECTOR() { SerialPrint("VMCS_GUEST_FS_SELECTOR = %x\n", Get_VMCS_GUEST_FS_SELECTOR()); } +void PrintTrace_VMCS_GUEST_FS_SELECTOR() { PrintTrace("VMCS_GUEST_FS_SELECTOR = %x\n", Get_VMCS_GUEST_FS_SELECTOR()); } void Set_VMCS_GUEST_GS_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_GUEST_GS_SELECTOR,val); } uint_t Get_VMCS_GUEST_GS_SELECTOR() { uint_t rc; VMCS_READ(VMCS_GUEST_GS_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_GUEST_GS_SELECTOR() { SerialPrint("VMCS_GUEST_GS_SELECTOR = %x\n", Get_VMCS_GUEST_GS_SELECTOR()); } +void PrintTrace_VMCS_GUEST_GS_SELECTOR() { PrintTrace("VMCS_GUEST_GS_SELECTOR = %x\n", Get_VMCS_GUEST_GS_SELECTOR()); } void Set_VMCS_GUEST_LDTR_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_GUEST_LDTR_SELECTOR,val); } uint_t Get_VMCS_GUEST_LDTR_SELECTOR() { uint_t rc; VMCS_READ(VMCS_GUEST_LDTR_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_GUEST_LDTR_SELECTOR() { SerialPrint("VMCS_GUEST_LDTR_SELECTOR = %x\n", Get_VMCS_GUEST_LDTR_SELECTOR()); } +void PrintTrace_VMCS_GUEST_LDTR_SELECTOR() { PrintTrace("VMCS_GUEST_LDTR_SELECTOR = %x\n", Get_VMCS_GUEST_LDTR_SELECTOR()); } void Set_VMCS_GUEST_TR_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_GUEST_TR_SELECTOR,val); } uint_t Get_VMCS_GUEST_TR_SELECTOR() { uint_t rc; VMCS_READ(VMCS_GUEST_TR_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_GUEST_TR_SELECTOR() { SerialPrint("VMCS_GUEST_TR_SELECTOR = %x\n", Get_VMCS_GUEST_TR_SELECTOR()); } +void PrintTrace_VMCS_GUEST_TR_SELECTOR() { PrintTrace("VMCS_GUEST_TR_SELECTOR = %x\n", Get_VMCS_GUEST_TR_SELECTOR()); } void Set_VMCS_HOST_ES_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_HOST_ES_SELECTOR,val); } uint_t Get_VMCS_HOST_ES_SELECTOR() { uint_t rc; VMCS_READ(VMCS_HOST_ES_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_HOST_ES_SELECTOR() { SerialPrint("VMCS_HOST_ES_SELECTOR = %x\n", Get_VMCS_HOST_ES_SELECTOR()); } +void PrintTrace_VMCS_HOST_ES_SELECTOR() { PrintTrace("VMCS_HOST_ES_SELECTOR = %x\n", Get_VMCS_HOST_ES_SELECTOR()); } void Set_VMCS_HOST_CS_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_HOST_CS_SELECTOR,val); } uint_t Get_VMCS_HOST_CS_SELECTOR() { uint_t rc; VMCS_READ(VMCS_HOST_CS_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_HOST_CS_SELECTOR() { SerialPrint("VMCS_HOST_CS_SELECTOR = %x\n", Get_VMCS_HOST_CS_SELECTOR()); } +void PrintTrace_VMCS_HOST_CS_SELECTOR() { PrintTrace("VMCS_HOST_CS_SELECTOR = %x\n", Get_VMCS_HOST_CS_SELECTOR()); } void Set_VMCS_HOST_SS_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_HOST_SS_SELECTOR,val); } uint_t Get_VMCS_HOST_SS_SELECTOR() { uint_t rc; VMCS_READ(VMCS_HOST_SS_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_HOST_SS_SELECTOR() { SerialPrint("VMCS_HOST_SS_SELECTOR = %x\n", Get_VMCS_HOST_SS_SELECTOR()); } +void PrintTrace_VMCS_HOST_SS_SELECTOR() { PrintTrace("VMCS_HOST_SS_SELECTOR = %x\n", Get_VMCS_HOST_SS_SELECTOR()); } void Set_VMCS_HOST_DS_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_HOST_DS_SELECTOR,val); } uint_t Get_VMCS_HOST_DS_SELECTOR() { uint_t rc; VMCS_READ(VMCS_HOST_DS_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_HOST_DS_SELECTOR() { SerialPrint("VMCS_HOST_DS_SELECTOR = %x\n", Get_VMCS_HOST_DS_SELECTOR()); } +void PrintTrace_VMCS_HOST_DS_SELECTOR() { PrintTrace("VMCS_HOST_DS_SELECTOR = %x\n", Get_VMCS_HOST_DS_SELECTOR()); } void Set_VMCS_HOST_FS_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_HOST_FS_SELECTOR,val); } uint_t Get_VMCS_HOST_FS_SELECTOR() { uint_t rc; VMCS_READ(VMCS_HOST_FS_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_HOST_FS_SELECTOR() { SerialPrint("VMCS_HOST_FS_SELECTOR = %x\n", Get_VMCS_HOST_FS_SELECTOR()); } +void PrintTrace_VMCS_HOST_FS_SELECTOR() { PrintTrace("VMCS_HOST_FS_SELECTOR = %x\n", Get_VMCS_HOST_FS_SELECTOR()); } void Set_VMCS_HOST_GS_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_HOST_GS_SELECTOR,val); } uint_t Get_VMCS_HOST_GS_SELECTOR() { uint_t rc; VMCS_READ(VMCS_HOST_GS_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_HOST_GS_SELECTOR() { SerialPrint("VMCS_HOST_GS_SELECTOR = %x\n", Get_VMCS_HOST_GS_SELECTOR()); } +void PrintTrace_VMCS_HOST_GS_SELECTOR() { PrintTrace("VMCS_HOST_GS_SELECTOR = %x\n", Get_VMCS_HOST_GS_SELECTOR()); } void Set_VMCS_HOST_TR_SELECTOR(uint_t val) { VMCS_WRITE(VMCS_HOST_TR_SELECTOR,val); } uint_t Get_VMCS_HOST_TR_SELECTOR() { uint_t rc; VMCS_READ(VMCS_HOST_TR_SELECTOR,&rc); return rc; } -void SerialPrint_VMCS_HOST_TR_SELECTOR() { SerialPrint("VMCS_HOST_TR_SELECTOR = %x\n", Get_VMCS_HOST_TR_SELECTOR()); } +void PrintTrace_VMCS_HOST_TR_SELECTOR() { PrintTrace("VMCS_HOST_TR_SELECTOR = %x\n", Get_VMCS_HOST_TR_SELECTOR()); } void Set_IO_BITMAP_A_ADDR(uint_t val) { VMCS_WRITE(IO_BITMAP_A_ADDR,val); } uint_t Get_IO_BITMAP_A_ADDR() { uint_t rc; VMCS_READ(IO_BITMAP_A_ADDR,&rc); return rc; } -void SerialPrint_IO_BITMAP_A_ADDR() { SerialPrint("IO_BITMAP_A_ADDR = %x\n", Get_IO_BITMAP_A_ADDR()); } +void PrintTrace_IO_BITMAP_A_ADDR() { PrintTrace("IO_BITMAP_A_ADDR = %x\n", Get_IO_BITMAP_A_ADDR()); } void Set_IO_BITMAP_A_ADDR_HIGH(uint_t val) { VMCS_WRITE(IO_BITMAP_A_ADDR_HIGH,val); } uint_t Get_IO_BITMAP_A_ADDR_HIGH() { uint_t rc; VMCS_READ(IO_BITMAP_A_ADDR_HIGH,&rc); return rc; } -void SerialPrint_IO_BITMAP_A_ADDR_HIGH() { SerialPrint("IO_BITMAP_A_ADDR_HIGH = %x\n", Get_IO_BITMAP_A_ADDR_HIGH()); } +void PrintTrace_IO_BITMAP_A_ADDR_HIGH() { PrintTrace("IO_BITMAP_A_ADDR_HIGH = %x\n", Get_IO_BITMAP_A_ADDR_HIGH()); } void Set_IO_BITMAP_B_ADDR(uint_t val) { VMCS_WRITE(IO_BITMAP_B_ADDR,val); } uint_t Get_IO_BITMAP_B_ADDR() { uint_t rc; VMCS_READ(IO_BITMAP_B_ADDR,&rc); return rc; } -void SerialPrint_IO_BITMAP_B_ADDR() { SerialPrint("IO_BITMAP_B_ADDR = %x\n", Get_IO_BITMAP_B_ADDR()); } +void PrintTrace_IO_BITMAP_B_ADDR() { PrintTrace("IO_BITMAP_B_ADDR = %x\n", Get_IO_BITMAP_B_ADDR()); } void Set_IO_BITMAP_B_ADDR_HIGH(uint_t val) { VMCS_WRITE(IO_BITMAP_B_ADDR_HIGH,val); } uint_t Get_IO_BITMAP_B_ADDR_HIGH() { uint_t rc; VMCS_READ(IO_BITMAP_B_ADDR_HIGH,&rc); return rc; } -void SerialPrint_IO_BITMAP_B_ADDR_HIGH() { SerialPrint("IO_BITMAP_B_ADDR_HIGH = %x\n", Get_IO_BITMAP_B_ADDR_HIGH()); } +void PrintTrace_IO_BITMAP_B_ADDR_HIGH() { PrintTrace("IO_BITMAP_B_ADDR_HIGH = %x\n", Get_IO_BITMAP_B_ADDR_HIGH()); } void Set_MSR_BITMAPS(uint_t val) { VMCS_WRITE(MSR_BITMAPS,val); } uint_t Get_MSR_BITMAPS() { uint_t rc; VMCS_READ(MSR_BITMAPS,&rc); return rc; } -void SerialPrint_MSR_BITMAPS() { SerialPrint("MSR_BITMAPS = %x\n", Get_MSR_BITMAPS()); } +void PrintTrace_MSR_BITMAPS() { PrintTrace("MSR_BITMAPS = %x\n", Get_MSR_BITMAPS()); } void Set_MSR_BITMAPS_HIGH(uint_t val) { VMCS_WRITE(MSR_BITMAPS_HIGH,val); } uint_t Get_MSR_BITMAPS_HIGH() { uint_t rc; VMCS_READ(MSR_BITMAPS_HIGH,&rc); return rc; } -void SerialPrint_MSR_BITMAPS_HIGH() { SerialPrint("MSR_BITMAPS_HIGH = %x\n", Get_MSR_BITMAPS_HIGH()); } +void PrintTrace_MSR_BITMAPS_HIGH() { PrintTrace("MSR_BITMAPS_HIGH = %x\n", Get_MSR_BITMAPS_HIGH()); } void Set_VM_EXIT_MSR_STORE_ADDR(uint_t val) { VMCS_WRITE(VM_EXIT_MSR_STORE_ADDR,val); } uint_t Get_VM_EXIT_MSR_STORE_ADDR() { uint_t rc; VMCS_READ(VM_EXIT_MSR_STORE_ADDR,&rc); return rc; } -void SerialPrint_VM_EXIT_MSR_STORE_ADDR() { SerialPrint("VM_EXIT_MSR_STORE_ADDR = %x\n", Get_VM_EXIT_MSR_STORE_ADDR()); } +void PrintTrace_VM_EXIT_MSR_STORE_ADDR() { PrintTrace("VM_EXIT_MSR_STORE_ADDR = %x\n", Get_VM_EXIT_MSR_STORE_ADDR()); } void Set_VM_EXIT_MSR_STORE_ADDR_HIGH(uint_t val) { VMCS_WRITE(VM_EXIT_MSR_STORE_ADDR_HIGH,val); } uint_t Get_VM_EXIT_MSR_STORE_ADDR_HIGH() { uint_t rc; VMCS_READ(VM_EXIT_MSR_STORE_ADDR_HIGH,&rc); return rc; } -void SerialPrint_VM_EXIT_MSR_STORE_ADDR_HIGH() { SerialPrint("VM_EXIT_MSR_STORE_ADDR_HIGH = %x\n", Get_VM_EXIT_MSR_STORE_ADDR_HIGH()); } +void PrintTrace_VM_EXIT_MSR_STORE_ADDR_HIGH() { PrintTrace("VM_EXIT_MSR_STORE_ADDR_HIGH = %x\n", Get_VM_EXIT_MSR_STORE_ADDR_HIGH()); } void Set_VM_EXIT_MSR_LOAD_ADDR(uint_t val) { VMCS_WRITE(VM_EXIT_MSR_LOAD_ADDR,val); } uint_t Get_VM_EXIT_MSR_LOAD_ADDR() { uint_t rc; VMCS_READ(VM_EXIT_MSR_LOAD_ADDR,&rc); return rc; } -void SerialPrint_VM_EXIT_MSR_LOAD_ADDR() { SerialPrint("VM_EXIT_MSR_LOAD_ADDR = %x\n", Get_VM_EXIT_MSR_LOAD_ADDR()); } +void PrintTrace_VM_EXIT_MSR_LOAD_ADDR() { PrintTrace("VM_EXIT_MSR_LOAD_ADDR = %x\n", Get_VM_EXIT_MSR_LOAD_ADDR()); } void Set_VM_EXIT_MSR_LOAD_ADDR_HIGH(uint_t val) { VMCS_WRITE(VM_EXIT_MSR_LOAD_ADDR_HIGH,val); } uint_t Get_VM_EXIT_MSR_LOAD_ADDR_HIGH() { uint_t rc; VMCS_READ(VM_EXIT_MSR_LOAD_ADDR_HIGH,&rc); return rc; } -void SerialPrint_VM_EXIT_MSR_LOAD_ADDR_HIGH() { SerialPrint("VM_EXIT_MSR_LOAD_ADDR_HIGH = %x\n", Get_VM_EXIT_MSR_LOAD_ADDR_HIGH()); } +void PrintTrace_VM_EXIT_MSR_LOAD_ADDR_HIGH() { PrintTrace("VM_EXIT_MSR_LOAD_ADDR_HIGH = %x\n", Get_VM_EXIT_MSR_LOAD_ADDR_HIGH()); } void Set_VM_ENTRY_MSR_LOAD_ADDR(uint_t val) { VMCS_WRITE(VM_ENTRY_MSR_LOAD_ADDR,val); } uint_t Get_VM_ENTRY_MSR_LOAD_ADDR() { uint_t rc; VMCS_READ(VM_ENTRY_MSR_LOAD_ADDR,&rc); return rc; } -void SerialPrint_VM_ENTRY_MSR_LOAD_ADDR() { SerialPrint("VM_ENTRY_MSR_LOAD_ADDR = %x\n", Get_VM_ENTRY_MSR_LOAD_ADDR()); } +void PrintTrace_VM_ENTRY_MSR_LOAD_ADDR() { PrintTrace("VM_ENTRY_MSR_LOAD_ADDR = %x\n", Get_VM_ENTRY_MSR_LOAD_ADDR()); } void Set_VM_ENTRY_MSR_LOAD_ADDR_HIGH(uint_t val) { VMCS_WRITE(VM_ENTRY_MSR_LOAD_ADDR_HIGH,val); } uint_t Get_VM_ENTRY_MSR_LOAD_ADDR_HIGH() { uint_t rc; VMCS_READ(VM_ENTRY_MSR_LOAD_ADDR_HIGH,&rc); return rc; } -void SerialPrint_VM_ENTRY_MSR_LOAD_ADDR_HIGH() { SerialPrint("VM_ENTRY_MSR_LOAD_ADDR_HIGH = %x\n", Get_VM_ENTRY_MSR_LOAD_ADDR_HIGH()); } +void PrintTrace_VM_ENTRY_MSR_LOAD_ADDR_HIGH() { PrintTrace("VM_ENTRY_MSR_LOAD_ADDR_HIGH = %x\n", Get_VM_ENTRY_MSR_LOAD_ADDR_HIGH()); } void Set_VMCS_EXEC_PTR(uint_t val) { VMCS_WRITE(VMCS_EXEC_PTR,val); } uint_t Get_VMCS_EXEC_PTR() { uint_t rc; VMCS_READ(VMCS_EXEC_PTR,&rc); return rc; } -void SerialPrint_VMCS_EXEC_PTR() { SerialPrint("VMCS_EXEC_PTR = %x\n", Get_VMCS_EXEC_PTR()); } +void PrintTrace_VMCS_EXEC_PTR() { PrintTrace("VMCS_EXEC_PTR = %x\n", Get_VMCS_EXEC_PTR()); } void Set_VMCS_EXEC_PTR_HIGH(uint_t val) { VMCS_WRITE(VMCS_EXEC_PTR_HIGH,val); } uint_t Get_VMCS_EXEC_PTR_HIGH() { uint_t rc; VMCS_READ(VMCS_EXEC_PTR_HIGH,&rc); return rc; } -void SerialPrint_VMCS_EXEC_PTR_HIGH() { SerialPrint("VMCS_EXEC_PTR_HIGH = %x\n", Get_VMCS_EXEC_PTR_HIGH()); } +void PrintTrace_VMCS_EXEC_PTR_HIGH() { PrintTrace("VMCS_EXEC_PTR_HIGH = %x\n", Get_VMCS_EXEC_PTR_HIGH()); } void Set_TSC_OFFSET(uint_t val) { VMCS_WRITE(TSC_OFFSET,val); } uint_t Get_TSC_OFFSET() { uint_t rc; VMCS_READ(TSC_OFFSET,&rc); return rc; } -void SerialPrint_TSC_OFFSET() { SerialPrint("TSC_OFFSET = %x\n", Get_TSC_OFFSET()); } +void PrintTrace_TSC_OFFSET() { PrintTrace("TSC_OFFSET = %x\n", Get_TSC_OFFSET()); } void Set_TSC_OFFSET_HIGH(uint_t val) { VMCS_WRITE(TSC_OFFSET_HIGH,val); } uint_t Get_TSC_OFFSET_HIGH() { uint_t rc; VMCS_READ(TSC_OFFSET_HIGH,&rc); return rc; } -void SerialPrint_TSC_OFFSET_HIGH() { SerialPrint("TSC_OFFSET_HIGH = %x\n", Get_TSC_OFFSET_HIGH()); } +void PrintTrace_TSC_OFFSET_HIGH() { PrintTrace("TSC_OFFSET_HIGH = %x\n", Get_TSC_OFFSET_HIGH()); } void Set_VIRT_APIC_PAGE_ADDR(uint_t val) { VMCS_WRITE(VIRT_APIC_PAGE_ADDR,val); } uint_t Get_VIRT_APIC_PAGE_ADDR() { uint_t rc; VMCS_READ(VIRT_APIC_PAGE_ADDR,&rc); return rc; } -void SerialPrint_VIRT_APIC_PAGE_ADDR() { SerialPrint("VIRT_APIC_PAGE_ADDR = %x\n", Get_VIRT_APIC_PAGE_ADDR()); } +void PrintTrace_VIRT_APIC_PAGE_ADDR() { PrintTrace("VIRT_APIC_PAGE_ADDR = %x\n", Get_VIRT_APIC_PAGE_ADDR()); } void Set_VIRT_APIC_PAGE_ADDR_HIGH(uint_t val) { VMCS_WRITE(VIRT_APIC_PAGE_ADDR_HIGH,val); } uint_t Get_VIRT_APIC_PAGE_ADDR_HIGH() { uint_t rc; VMCS_READ(VIRT_APIC_PAGE_ADDR_HIGH,&rc); return rc; } -void SerialPrint_VIRT_APIC_PAGE_ADDR_HIGH() { SerialPrint("VIRT_APIC_PAGE_ADDR_HIGH = %x\n", Get_VIRT_APIC_PAGE_ADDR_HIGH()); } +void PrintTrace_VIRT_APIC_PAGE_ADDR_HIGH() { PrintTrace("VIRT_APIC_PAGE_ADDR_HIGH = %x\n", Get_VIRT_APIC_PAGE_ADDR_HIGH()); } void Set_VMCS_LINK_PTR(uint_t val) { VMCS_WRITE(VMCS_LINK_PTR,val); } uint_t Get_VMCS_LINK_PTR() { uint_t rc; VMCS_READ(VMCS_LINK_PTR,&rc); return rc; } -void SerialPrint_VMCS_LINK_PTR() { SerialPrint("VMCS_LINK_PTR = %x\n", Get_VMCS_LINK_PTR()); } +void PrintTrace_VMCS_LINK_PTR() { PrintTrace("VMCS_LINK_PTR = %x\n", Get_VMCS_LINK_PTR()); } void Set_VMCS_LINK_PTR_HIGH(uint_t val) { VMCS_WRITE(VMCS_LINK_PTR_HIGH,val); } uint_t Get_VMCS_LINK_PTR_HIGH() { uint_t rc; VMCS_READ(VMCS_LINK_PTR_HIGH,&rc); return rc; } -void SerialPrint_VMCS_LINK_PTR_HIGH() { SerialPrint("VMCS_LINK_PTR_HIGH = %x\n", Get_VMCS_LINK_PTR_HIGH()); } +void PrintTrace_VMCS_LINK_PTR_HIGH() { PrintTrace("VMCS_LINK_PTR_HIGH = %x\n", Get_VMCS_LINK_PTR_HIGH()); } void Set_GUEST_IA32_DEBUGCTL(uint_t val) { VMCS_WRITE(GUEST_IA32_DEBUGCTL,val); } uint_t Get_GUEST_IA32_DEBUGCTL() { uint_t rc; VMCS_READ(GUEST_IA32_DEBUGCTL,&rc); return rc; } -void SerialPrint_GUEST_IA32_DEBUGCTL() { SerialPrint("GUEST_IA32_DEBUGCTL = %x\n", Get_GUEST_IA32_DEBUGCTL()); } +void PrintTrace_GUEST_IA32_DEBUGCTL() { PrintTrace("GUEST_IA32_DEBUGCTL = %x\n", Get_GUEST_IA32_DEBUGCTL()); } void Set_GUEST_IA32_DEBUGCTL_HIGH(uint_t val) { VMCS_WRITE(GUEST_IA32_DEBUGCTL_HIGH,val); } uint_t Get_GUEST_IA32_DEBUGCTL_HIGH() { uint_t rc; VMCS_READ(GUEST_IA32_DEBUGCTL_HIGH,&rc); return rc; } -void SerialPrint_GUEST_IA32_DEBUGCTL_HIGH() { SerialPrint("GUEST_IA32_DEBUGCTL_HIGH = %x\n", Get_GUEST_IA32_DEBUGCTL_HIGH()); } +void PrintTrace_GUEST_IA32_DEBUGCTL_HIGH() { PrintTrace("GUEST_IA32_DEBUGCTL_HIGH = %x\n", Get_GUEST_IA32_DEBUGCTL_HIGH()); } void Set_PIN_VM_EXEC_CTRLS(uint_t val) { VMCS_WRITE(PIN_VM_EXEC_CTRLS,val); } uint_t Get_PIN_VM_EXEC_CTRLS() { uint_t rc; VMCS_READ(PIN_VM_EXEC_CTRLS,&rc); return rc; } -void SerialPrint_PIN_VM_EXEC_CTRLS() { SerialPrint("PIN_VM_EXEC_CTRLS = %x\n", Get_PIN_VM_EXEC_CTRLS()); } +void PrintTrace_PIN_VM_EXEC_CTRLS() { PrintTrace("PIN_VM_EXEC_CTRLS = %x\n", Get_PIN_VM_EXEC_CTRLS()); } void Set_PROC_VM_EXEC_CTRLS(uint_t val) { VMCS_WRITE(PROC_VM_EXEC_CTRLS,val); } uint_t Get_PROC_VM_EXEC_CTRLS() { uint_t rc; VMCS_READ(PROC_VM_EXEC_CTRLS,&rc); return rc; } -void SerialPrint_PROC_VM_EXEC_CTRLS() { SerialPrint("PROC_VM_EXEC_CTRLS = %x\n", Get_PROC_VM_EXEC_CTRLS()); } +void PrintTrace_PROC_VM_EXEC_CTRLS() { PrintTrace("PROC_VM_EXEC_CTRLS = %x\n", Get_PROC_VM_EXEC_CTRLS()); } void Set_EXCEPTION_BITMAP(uint_t val) { VMCS_WRITE(EXCEPTION_BITMAP,val); } uint_t Get_EXCEPTION_BITMAP() { uint_t rc; VMCS_READ(EXCEPTION_BITMAP,&rc); return rc; } -void SerialPrint_EXCEPTION_BITMAP() { SerialPrint("EXCEPTION_BITMAP = %x\n", Get_EXCEPTION_BITMAP()); } +void PrintTrace_EXCEPTION_BITMAP() { PrintTrace("EXCEPTION_BITMAP = %x\n", Get_EXCEPTION_BITMAP()); } void Set_PAGE_FAULT_ERROR_MASK(uint_t val) { VMCS_WRITE(PAGE_FAULT_ERROR_MASK,val); } uint_t Get_PAGE_FAULT_ERROR_MASK() { uint_t rc; VMCS_READ(PAGE_FAULT_ERROR_MASK,&rc); return rc; } -void SerialPrint_PAGE_FAULT_ERROR_MASK() { SerialPrint("PAGE_FAULT_ERROR_MASK = %x\n", Get_PAGE_FAULT_ERROR_MASK()); } +void PrintTrace_PAGE_FAULT_ERROR_MASK() { PrintTrace("PAGE_FAULT_ERROR_MASK = %x\n", Get_PAGE_FAULT_ERROR_MASK()); } void Set_PAGE_FAULT_ERROR_MATCH(uint_t val) { VMCS_WRITE(PAGE_FAULT_ERROR_MATCH,val); } uint_t Get_PAGE_FAULT_ERROR_MATCH() { uint_t rc; VMCS_READ(PAGE_FAULT_ERROR_MATCH,&rc); return rc; } -void SerialPrint_PAGE_FAULT_ERROR_MATCH() { SerialPrint("PAGE_FAULT_ERROR_MATCH = %x\n", Get_PAGE_FAULT_ERROR_MATCH()); } +void PrintTrace_PAGE_FAULT_ERROR_MATCH() { PrintTrace("PAGE_FAULT_ERROR_MATCH = %x\n", Get_PAGE_FAULT_ERROR_MATCH()); } void Set_CR3_TARGET_COUNT(uint_t val) { VMCS_WRITE(CR3_TARGET_COUNT,val); } uint_t Get_CR3_TARGET_COUNT() { uint_t rc; VMCS_READ(CR3_TARGET_COUNT,&rc); return rc; } -void SerialPrint_CR3_TARGET_COUNT() { SerialPrint("CR3_TARGET_COUNT = %x\n", Get_CR3_TARGET_COUNT()); } +void PrintTrace_CR3_TARGET_COUNT() { PrintTrace("CR3_TARGET_COUNT = %x\n", Get_CR3_TARGET_COUNT()); } void Set_VM_EXIT_CTRLS(uint_t val) { VMCS_WRITE(VM_EXIT_CTRLS,val); } uint_t Get_VM_EXIT_CTRLS() { uint_t rc; VMCS_READ(VM_EXIT_CTRLS,&rc); return rc; } -void SerialPrint_VM_EXIT_CTRLS() { SerialPrint("VM_EXIT_CTRLS = %x\n", Get_VM_EXIT_CTRLS()); } +void PrintTrace_VM_EXIT_CTRLS() { PrintTrace("VM_EXIT_CTRLS = %x\n", Get_VM_EXIT_CTRLS()); } void Set_VM_EXIT_MSR_STORE_COUNT(uint_t val) { VMCS_WRITE(VM_EXIT_MSR_STORE_COUNT,val); } uint_t Get_VM_EXIT_MSR_STORE_COUNT() { uint_t rc; VMCS_READ(VM_EXIT_MSR_STORE_COUNT,&rc); return rc; } -void SerialPrint_VM_EXIT_MSR_STORE_COUNT() { SerialPrint("VM_EXIT_MSR_STORE_COUNT = %x\n", Get_VM_EXIT_MSR_STORE_COUNT()); } +void PrintTrace_VM_EXIT_MSR_STORE_COUNT() { PrintTrace("VM_EXIT_MSR_STORE_COUNT = %x\n", Get_VM_EXIT_MSR_STORE_COUNT()); } void Set_VM_EXIT_MSR_LOAD_COUNT(uint_t val) { VMCS_WRITE(VM_EXIT_MSR_LOAD_COUNT,val); } uint_t Get_VM_EXIT_MSR_LOAD_COUNT() { uint_t rc; VMCS_READ(VM_EXIT_MSR_LOAD_COUNT,&rc); return rc; } -void SerialPrint_VM_EXIT_MSR_LOAD_COUNT() { SerialPrint("VM_EXIT_MSR_LOAD_COUNT = %x\n", Get_VM_EXIT_MSR_LOAD_COUNT()); } +void PrintTrace_VM_EXIT_MSR_LOAD_COUNT() { PrintTrace("VM_EXIT_MSR_LOAD_COUNT = %x\n", Get_VM_EXIT_MSR_LOAD_COUNT()); } void Set_VM_ENTRY_CTRLS(uint_t val) { VMCS_WRITE(VM_ENTRY_CTRLS,val); } uint_t Get_VM_ENTRY_CTRLS() { uint_t rc; VMCS_READ(VM_ENTRY_CTRLS,&rc); return rc; } -void SerialPrint_VM_ENTRY_CTRLS() { SerialPrint("VM_ENTRY_CTRLS = %x\n", Get_VM_ENTRY_CTRLS()); } +void PrintTrace_VM_ENTRY_CTRLS() { PrintTrace("VM_ENTRY_CTRLS = %x\n", Get_VM_ENTRY_CTRLS()); } void Set_VM_ENTRY_MSR_LOAD_COUNT(uint_t val) { VMCS_WRITE(VM_ENTRY_MSR_LOAD_COUNT,val); } uint_t Get_VM_ENTRY_MSR_LOAD_COUNT() { uint_t rc; VMCS_READ(VM_ENTRY_MSR_LOAD_COUNT,&rc); return rc; } -void SerialPrint_VM_ENTRY_MSR_LOAD_COUNT() { SerialPrint("VM_ENTRY_MSR_LOAD_COUNT = %x\n", Get_VM_ENTRY_MSR_LOAD_COUNT()); } +void PrintTrace_VM_ENTRY_MSR_LOAD_COUNT() { PrintTrace("VM_ENTRY_MSR_LOAD_COUNT = %x\n", Get_VM_ENTRY_MSR_LOAD_COUNT()); } void Set_VM_ENTRY_INT_INFO_FIELD(uint_t val) { VMCS_WRITE(VM_ENTRY_INT_INFO_FIELD,val); } uint_t Get_VM_ENTRY_INT_INFO_FIELD() { uint_t rc; VMCS_READ(VM_ENTRY_INT_INFO_FIELD,&rc); return rc; } -void SerialPrint_VM_ENTRY_INT_INFO_FIELD() { SerialPrint("VM_ENTRY_INT_INFO_FIELD = %x\n", Get_VM_ENTRY_INT_INFO_FIELD()); } +void PrintTrace_VM_ENTRY_INT_INFO_FIELD() { PrintTrace("VM_ENTRY_INT_INFO_FIELD = %x\n", Get_VM_ENTRY_INT_INFO_FIELD()); } void Set_VM_ENTRY_EXCEPTION_ERROR(uint_t val) { VMCS_WRITE(VM_ENTRY_EXCEPTION_ERROR,val); } uint_t Get_VM_ENTRY_EXCEPTION_ERROR() { uint_t rc; VMCS_READ(VM_ENTRY_EXCEPTION_ERROR,&rc); return rc; } -void SerialPrint_VM_ENTRY_EXCEPTION_ERROR() { SerialPrint("VM_ENTRY_EXCEPTION_ERROR = %x\n", Get_VM_ENTRY_EXCEPTION_ERROR()); } +void PrintTrace_VM_ENTRY_EXCEPTION_ERROR() { PrintTrace("VM_ENTRY_EXCEPTION_ERROR = %x\n", Get_VM_ENTRY_EXCEPTION_ERROR()); } void Set_VM_ENTRY_INSTR_LENGTH(uint_t val) { VMCS_WRITE(VM_ENTRY_INSTR_LENGTH,val); } uint_t Get_VM_ENTRY_INSTR_LENGTH() { uint_t rc; VMCS_READ(VM_ENTRY_INSTR_LENGTH,&rc); return rc; } -void SerialPrint_VM_ENTRY_INSTR_LENGTH() { SerialPrint("VM_ENTRY_INSTR_LENGTH = %x\n", Get_VM_ENTRY_INSTR_LENGTH()); } +void PrintTrace_VM_ENTRY_INSTR_LENGTH() { PrintTrace("VM_ENTRY_INSTR_LENGTH = %x\n", Get_VM_ENTRY_INSTR_LENGTH()); } void Set_TPR_THRESHOLD(uint_t val) { VMCS_WRITE(TPR_THRESHOLD,val); } uint_t Get_TPR_THRESHOLD() { uint_t rc; VMCS_READ(TPR_THRESHOLD,&rc); return rc; } -void SerialPrint_TPR_THRESHOLD() { SerialPrint("TPR_THRESHOLD = %x\n", Get_TPR_THRESHOLD()); } +void PrintTrace_TPR_THRESHOLD() { PrintTrace("TPR_THRESHOLD = %x\n", Get_TPR_THRESHOLD()); } void Set_VM_INSTR_ERROR(uint_t val) { VMCS_WRITE(VM_INSTR_ERROR,val); } uint_t Get_VM_INSTR_ERROR() { uint_t rc; VMCS_READ(VM_INSTR_ERROR,&rc); return rc; } -void SerialPrint_VM_INSTR_ERROR() { SerialPrint("VM_INSTR_ERROR = %x\n", Get_VM_INSTR_ERROR()); } +void PrintTrace_VM_INSTR_ERROR() { PrintTrace("VM_INSTR_ERROR = %x\n", Get_VM_INSTR_ERROR()); } void Set_EXIT_REASON(uint_t val) { VMCS_WRITE(EXIT_REASON,val); } uint_t Get_EXIT_REASON() { uint_t rc; VMCS_READ(EXIT_REASON,&rc); return rc; } -void SerialPrint_EXIT_REASON() { SerialPrint("EXIT_REASON = %x\n", Get_EXIT_REASON()); } +void PrintTrace_EXIT_REASON() { PrintTrace("EXIT_REASON = %x\n", Get_EXIT_REASON()); } void Set_VM_EXIT_INT_INFO(uint_t val) { VMCS_WRITE(VM_EXIT_INT_INFO,val); } uint_t Get_VM_EXIT_INT_INFO() { uint_t rc; VMCS_READ(VM_EXIT_INT_INFO,&rc); return rc; } -void SerialPrint_VM_EXIT_INT_INFO() { SerialPrint("VM_EXIT_INT_INFO = %x\n", Get_VM_EXIT_INT_INFO()); } +void PrintTrace_VM_EXIT_INT_INFO() { PrintTrace("VM_EXIT_INT_INFO = %x\n", Get_VM_EXIT_INT_INFO()); } void Set_VM_EXIT_INT_ERROR(uint_t val) { VMCS_WRITE(VM_EXIT_INT_ERROR,val); } uint_t Get_VM_EXIT_INT_ERROR() { uint_t rc; VMCS_READ(VM_EXIT_INT_ERROR,&rc); return rc; } -void SerialPrint_VM_EXIT_INT_ERROR() { SerialPrint("VM_EXIT_INT_ERROR = %x\n", Get_VM_EXIT_INT_ERROR()); } +void PrintTrace_VM_EXIT_INT_ERROR() { PrintTrace("VM_EXIT_INT_ERROR = %x\n", Get_VM_EXIT_INT_ERROR()); } void Set_IDT_VECTOR_INFO(uint_t val) { VMCS_WRITE(IDT_VECTOR_INFO,val); } uint_t Get_IDT_VECTOR_INFO() { uint_t rc; VMCS_READ(IDT_VECTOR_INFO,&rc); return rc; } -void SerialPrint_IDT_VECTOR_INFO() { SerialPrint("IDT_VECTOR_INFO = %x\n", Get_IDT_VECTOR_INFO()); } +void PrintTrace_IDT_VECTOR_INFO() { PrintTrace("IDT_VECTOR_INFO = %x\n", Get_IDT_VECTOR_INFO()); } void Set_IDT_VECTOR_ERROR(uint_t val) { VMCS_WRITE(IDT_VECTOR_ERROR,val); } uint_t Get_IDT_VECTOR_ERROR() { uint_t rc; VMCS_READ(IDT_VECTOR_ERROR,&rc); return rc; } -void SerialPrint_IDT_VECTOR_ERROR() { SerialPrint("IDT_VECTOR_ERROR = %x\n", Get_IDT_VECTOR_ERROR()); } +void PrintTrace_IDT_VECTOR_ERROR() { PrintTrace("IDT_VECTOR_ERROR = %x\n", Get_IDT_VECTOR_ERROR()); } void Set_VM_EXIT_INSTR_LENGTH(uint_t val) { VMCS_WRITE(VM_EXIT_INSTR_LENGTH,val); } uint_t Get_VM_EXIT_INSTR_LENGTH() { uint_t rc; VMCS_READ(VM_EXIT_INSTR_LENGTH,&rc); return rc; } -void SerialPrint_VM_EXIT_INSTR_LENGTH() { SerialPrint("VM_EXIT_INSTR_LENGTH = %x\n", Get_VM_EXIT_INSTR_LENGTH()); } +void PrintTrace_VM_EXIT_INSTR_LENGTH() { PrintTrace("VM_EXIT_INSTR_LENGTH = %x\n", Get_VM_EXIT_INSTR_LENGTH()); } void Set_VMX_INSTR_INFO(uint_t val) { VMCS_WRITE(VMX_INSTR_INFO,val); } uint_t Get_VMX_INSTR_INFO() { uint_t rc; VMCS_READ(VMX_INSTR_INFO,&rc); return rc; } -void SerialPrint_VMX_INSTR_INFO() { SerialPrint("VMX_INSTR_INFO = %x\n", Get_VMX_INSTR_INFO()); } +void PrintTrace_VMX_INSTR_INFO() { PrintTrace("VMX_INSTR_INFO = %x\n", Get_VMX_INSTR_INFO()); } void Set_GUEST_ES_LIMIT(uint_t val) { VMCS_WRITE(GUEST_ES_LIMIT,val); } uint_t Get_GUEST_ES_LIMIT() { uint_t rc; VMCS_READ(GUEST_ES_LIMIT,&rc); return rc; } -void SerialPrint_GUEST_ES_LIMIT() { SerialPrint("GUEST_ES_LIMIT = %x\n", Get_GUEST_ES_LIMIT()); } +void PrintTrace_GUEST_ES_LIMIT() { PrintTrace("GUEST_ES_LIMIT = %x\n", Get_GUEST_ES_LIMIT()); } void Set_GUEST_CS_LIMIT(uint_t val) { VMCS_WRITE(GUEST_CS_LIMIT,val); } uint_t Get_GUEST_CS_LIMIT() { uint_t rc; VMCS_READ(GUEST_CS_LIMIT,&rc); return rc; } -void SerialPrint_GUEST_CS_LIMIT() { SerialPrint("GUEST_CS_LIMIT = %x\n", Get_GUEST_CS_LIMIT()); } +void PrintTrace_GUEST_CS_LIMIT() { PrintTrace("GUEST_CS_LIMIT = %x\n", Get_GUEST_CS_LIMIT()); } void Set_GUEST_SS_LIMIT(uint_t val) { VMCS_WRITE(GUEST_SS_LIMIT,val); } uint_t Get_GUEST_SS_LIMIT() { uint_t rc; VMCS_READ(GUEST_SS_LIMIT,&rc); return rc; } -void SerialPrint_GUEST_SS_LIMIT() { SerialPrint("GUEST_SS_LIMIT = %x\n", Get_GUEST_SS_LIMIT()); } +void PrintTrace_GUEST_SS_LIMIT() { PrintTrace("GUEST_SS_LIMIT = %x\n", Get_GUEST_SS_LIMIT()); } void Set_GUEST_DS_LIMIT(uint_t val) { VMCS_WRITE(GUEST_DS_LIMIT,val); } uint_t Get_GUEST_DS_LIMIT() { uint_t rc; VMCS_READ(GUEST_DS_LIMIT,&rc); return rc; } -void SerialPrint_GUEST_DS_LIMIT() { SerialPrint("GUEST_DS_LIMIT = %x\n", Get_GUEST_DS_LIMIT()); } +void PrintTrace_GUEST_DS_LIMIT() { PrintTrace("GUEST_DS_LIMIT = %x\n", Get_GUEST_DS_LIMIT()); } void Set_GUEST_FS_LIMIT(uint_t val) { VMCS_WRITE(GUEST_FS_LIMIT,val); } uint_t Get_GUEST_FS_LIMIT() { uint_t rc; VMCS_READ(GUEST_FS_LIMIT,&rc); return rc; } -void SerialPrint_GUEST_FS_LIMIT() { SerialPrint("GUEST_FS_LIMIT = %x\n", Get_GUEST_FS_LIMIT()); } +void PrintTrace_GUEST_FS_LIMIT() { PrintTrace("GUEST_FS_LIMIT = %x\n", Get_GUEST_FS_LIMIT()); } void Set_GUEST_GS_LIMIT(uint_t val) { VMCS_WRITE(GUEST_GS_LIMIT,val); } uint_t Get_GUEST_GS_LIMIT() { uint_t rc; VMCS_READ(GUEST_GS_LIMIT,&rc); return rc; } -void SerialPrint_GUEST_GS_LIMIT() { SerialPrint("GUEST_GS_LIMIT = %x\n", Get_GUEST_GS_LIMIT()); } +void PrintTrace_GUEST_GS_LIMIT() { PrintTrace("GUEST_GS_LIMIT = %x\n", Get_GUEST_GS_LIMIT()); } void Set_GUEST_LDTR_LIMIT(uint_t val) { VMCS_WRITE(GUEST_LDTR_LIMIT,val); } uint_t Get_GUEST_LDTR_LIMIT() { uint_t rc; VMCS_READ(GUEST_LDTR_LIMIT,&rc); return rc; } -void SerialPrint_GUEST_LDTR_LIMIT() { SerialPrint("GUEST_LDTR_LIMIT = %x\n", Get_GUEST_LDTR_LIMIT()); } +void PrintTrace_GUEST_LDTR_LIMIT() { PrintTrace("GUEST_LDTR_LIMIT = %x\n", Get_GUEST_LDTR_LIMIT()); } void Set_GUEST_TR_LIMIT(uint_t val) { VMCS_WRITE(GUEST_TR_LIMIT,val); } uint_t Get_GUEST_TR_LIMIT() { uint_t rc; VMCS_READ(GUEST_TR_LIMIT,&rc); return rc; } -void SerialPrint_GUEST_TR_LIMIT() { SerialPrint("GUEST_TR_LIMIT = %x\n", Get_GUEST_TR_LIMIT()); } +void PrintTrace_GUEST_TR_LIMIT() { PrintTrace("GUEST_TR_LIMIT = %x\n", Get_GUEST_TR_LIMIT()); } void Set_GUEST_GDTR_LIMIT(uint_t val) { VMCS_WRITE(GUEST_GDTR_LIMIT,val); } uint_t Get_GUEST_GDTR_LIMIT() { uint_t rc; VMCS_READ(GUEST_GDTR_LIMIT,&rc); return rc; } -void SerialPrint_GUEST_GDTR_LIMIT() { SerialPrint("GUEST_GDTR_LIMIT = %x\n", Get_GUEST_GDTR_LIMIT()); } +void PrintTrace_GUEST_GDTR_LIMIT() { PrintTrace("GUEST_GDTR_LIMIT = %x\n", Get_GUEST_GDTR_LIMIT()); } void Set_GUEST_IDTR_LIMIT(uint_t val) { VMCS_WRITE(GUEST_IDTR_LIMIT,val); } uint_t Get_GUEST_IDTR_LIMIT() { uint_t rc; VMCS_READ(GUEST_IDTR_LIMIT,&rc); return rc; } -void SerialPrint_GUEST_IDTR_LIMIT() { SerialPrint("GUEST_IDTR_LIMIT = %x\n", Get_GUEST_IDTR_LIMIT()); } +void PrintTrace_GUEST_IDTR_LIMIT() { PrintTrace("GUEST_IDTR_LIMIT = %x\n", Get_GUEST_IDTR_LIMIT()); } void Set_GUEST_ES_ACCESS(uint_t val) { VMCS_WRITE(GUEST_ES_ACCESS,val); } uint_t Get_GUEST_ES_ACCESS() { uint_t rc; VMCS_READ(GUEST_ES_ACCESS,&rc); return rc; } -void SerialPrint_GUEST_ES_ACCESS() { SerialPrint("GUEST_ES_ACCESS = %x\n", Get_GUEST_ES_ACCESS()); } +void PrintTrace_GUEST_ES_ACCESS() { PrintTrace("GUEST_ES_ACCESS = %x\n", Get_GUEST_ES_ACCESS()); } void Set_GUEST_CS_ACCESS(uint_t val) { VMCS_WRITE(GUEST_CS_ACCESS,val); } uint_t Get_GUEST_CS_ACCESS() { uint_t rc; VMCS_READ(GUEST_CS_ACCESS,&rc); return rc; } -void SerialPrint_GUEST_CS_ACCESS() { SerialPrint("GUEST_CS_ACCESS = %x\n", Get_GUEST_CS_ACCESS()); } +void PrintTrace_GUEST_CS_ACCESS() { PrintTrace("GUEST_CS_ACCESS = %x\n", Get_GUEST_CS_ACCESS()); } void Set_GUEST_SS_ACCESS(uint_t val) { VMCS_WRITE(GUEST_SS_ACCESS,val); } uint_t Get_GUEST_SS_ACCESS() { uint_t rc; VMCS_READ(GUEST_SS_ACCESS,&rc); return rc; } -void SerialPrint_GUEST_SS_ACCESS() { SerialPrint("GUEST_SS_ACCESS = %x\n", Get_GUEST_SS_ACCESS()); } +void PrintTrace_GUEST_SS_ACCESS() { PrintTrace("GUEST_SS_ACCESS = %x\n", Get_GUEST_SS_ACCESS()); } void Set_GUEST_DS_ACCESS(uint_t val) { VMCS_WRITE(GUEST_DS_ACCESS,val); } uint_t Get_GUEST_DS_ACCESS() { uint_t rc; VMCS_READ(GUEST_DS_ACCESS,&rc); return rc; } -void SerialPrint_GUEST_DS_ACCESS() { SerialPrint("GUEST_DS_ACCESS = %x\n", Get_GUEST_DS_ACCESS()); } +void PrintTrace_GUEST_DS_ACCESS() { PrintTrace("GUEST_DS_ACCESS = %x\n", Get_GUEST_DS_ACCESS()); } void Set_GUEST_FS_ACCESS(uint_t val) { VMCS_WRITE(GUEST_FS_ACCESS,val); } uint_t Get_GUEST_FS_ACCESS() { uint_t rc; VMCS_READ(GUEST_FS_ACCESS,&rc); return rc; } -void SerialPrint_GUEST_FS_ACCESS() { SerialPrint("GUEST_FS_ACCESS = %x\n", Get_GUEST_FS_ACCESS()); } +void PrintTrace_GUEST_FS_ACCESS() { PrintTrace("GUEST_FS_ACCESS = %x\n", Get_GUEST_FS_ACCESS()); } void Set_GUEST_GS_ACCESS(uint_t val) { VMCS_WRITE(GUEST_GS_ACCESS,val); } uint_t Get_GUEST_GS_ACCESS() { uint_t rc; VMCS_READ(GUEST_GS_ACCESS,&rc); return rc; } -void SerialPrint_GUEST_GS_ACCESS() { SerialPrint("GUEST_GS_ACCESS = %x\n", Get_GUEST_GS_ACCESS()); } +void PrintTrace_GUEST_GS_ACCESS() { PrintTrace("GUEST_GS_ACCESS = %x\n", Get_GUEST_GS_ACCESS()); } void Set_GUEST_LDTR_ACCESS(uint_t val) { VMCS_WRITE(GUEST_LDTR_ACCESS,val); } uint_t Get_GUEST_LDTR_ACCESS() { uint_t rc; VMCS_READ(GUEST_LDTR_ACCESS,&rc); return rc; } -void SerialPrint_GUEST_LDTR_ACCESS() { SerialPrint("GUEST_LDTR_ACCESS = %x\n", Get_GUEST_LDTR_ACCESS()); } +void PrintTrace_GUEST_LDTR_ACCESS() { PrintTrace("GUEST_LDTR_ACCESS = %x\n", Get_GUEST_LDTR_ACCESS()); } void Set_GUEST_TR_ACCESS(uint_t val) { VMCS_WRITE(GUEST_TR_ACCESS,val); } uint_t Get_GUEST_TR_ACCESS() { uint_t rc; VMCS_READ(GUEST_TR_ACCESS,&rc); return rc; } -void SerialPrint_GUEST_TR_ACCESS() { SerialPrint("GUEST_TR_ACCESS = %x\n", Get_GUEST_TR_ACCESS()); } +void PrintTrace_GUEST_TR_ACCESS() { PrintTrace("GUEST_TR_ACCESS = %x\n", Get_GUEST_TR_ACCESS()); } void Set_GUEST_INT_STATE(uint_t val) { VMCS_WRITE(GUEST_INT_STATE,val); } uint_t Get_GUEST_INT_STATE() { uint_t rc; VMCS_READ(GUEST_INT_STATE,&rc); return rc; } -void SerialPrint_GUEST_INT_STATE() { SerialPrint("GUEST_INT_STATE = %x\n", Get_GUEST_INT_STATE()); } +void PrintTrace_GUEST_INT_STATE() { PrintTrace("GUEST_INT_STATE = %x\n", Get_GUEST_INT_STATE()); } void Set_GUEST_ACTIVITY_STATE(uint_t val) { VMCS_WRITE(GUEST_ACTIVITY_STATE,val); } uint_t Get_GUEST_ACTIVITY_STATE() { uint_t rc; VMCS_READ(GUEST_ACTIVITY_STATE,&rc); return rc; } -void SerialPrint_GUEST_ACTIVITY_STATE() { SerialPrint("GUEST_ACTIVITY_STATE = %x\n", Get_GUEST_ACTIVITY_STATE()); } +void PrintTrace_GUEST_ACTIVITY_STATE() { PrintTrace("GUEST_ACTIVITY_STATE = %x\n", Get_GUEST_ACTIVITY_STATE()); } void Set_GUEST_SMBASE(uint_t val) { VMCS_WRITE(GUEST_SMBASE,val); } uint_t Get_GUEST_SMBASE() { uint_t rc; VMCS_READ(GUEST_SMBASE,&rc); return rc; } -void SerialPrint_GUEST_SMBASE() { SerialPrint("GUEST_SMBASE = %x\n", Get_GUEST_SMBASE()); } +void PrintTrace_GUEST_SMBASE() { PrintTrace("GUEST_SMBASE = %x\n", Get_GUEST_SMBASE()); } void Set_GUEST_IA32_SYSENTER_CS(uint_t val) { VMCS_WRITE(GUEST_IA32_SYSENTER_CS,val); } uint_t Get_GUEST_IA32_SYSENTER_CS() { uint_t rc; VMCS_READ(GUEST_IA32_SYSENTER_CS,&rc); return rc; } -void SerialPrint_GUEST_IA32_SYSENTER_CS() { SerialPrint("GUEST_IA32_SYSENTER_CS = %x\n", Get_GUEST_IA32_SYSENTER_CS()); } +void PrintTrace_GUEST_IA32_SYSENTER_CS() { PrintTrace("GUEST_IA32_SYSENTER_CS = %x\n", Get_GUEST_IA32_SYSENTER_CS()); } void Set_HOST_IA32_SYSENTER_CS(uint_t val) { VMCS_WRITE(HOST_IA32_SYSENTER_CS,val); } uint_t Get_HOST_IA32_SYSENTER_CS() { uint_t rc; VMCS_READ(HOST_IA32_SYSENTER_CS,&rc); return rc; } -void SerialPrint_HOST_IA32_SYSENTER_CS() { SerialPrint("HOST_IA32_SYSENTER_CS = %x\n", Get_HOST_IA32_SYSENTER_CS()); } +void PrintTrace_HOST_IA32_SYSENTER_CS() { PrintTrace("HOST_IA32_SYSENTER_CS = %x\n", Get_HOST_IA32_SYSENTER_CS()); } void Set_CR0_GUEST_HOST_MASK(uint_t val) { VMCS_WRITE(CR0_GUEST_HOST_MASK,val); } uint_t Get_CR0_GUEST_HOST_MASK() { uint_t rc; VMCS_READ(CR0_GUEST_HOST_MASK,&rc); return rc; } -void SerialPrint_CR0_GUEST_HOST_MASK() { SerialPrint("CR0_GUEST_HOST_MASK = %x\n", Get_CR0_GUEST_HOST_MASK()); } +void PrintTrace_CR0_GUEST_HOST_MASK() { PrintTrace("CR0_GUEST_HOST_MASK = %x\n", Get_CR0_GUEST_HOST_MASK()); } void Set_CR4_GUEST_HOST_MASK(uint_t val) { VMCS_WRITE(CR4_GUEST_HOST_MASK,val); } uint_t Get_CR4_GUEST_HOST_MASK() { uint_t rc; VMCS_READ(CR4_GUEST_HOST_MASK,&rc); return rc; } -void SerialPrint_CR4_GUEST_HOST_MASK() { SerialPrint("CR4_GUEST_HOST_MASK = %x\n", Get_CR4_GUEST_HOST_MASK()); } +void PrintTrace_CR4_GUEST_HOST_MASK() { PrintTrace("CR4_GUEST_HOST_MASK = %x\n", Get_CR4_GUEST_HOST_MASK()); } void Set_CR0_READ_SHADOW(uint_t val) { VMCS_WRITE(CR0_READ_SHADOW,val); } uint_t Get_CR0_READ_SHADOW() { uint_t rc; VMCS_READ(CR0_READ_SHADOW,&rc); return rc; } -void SerialPrint_CR0_READ_SHADOW() { SerialPrint("CR0_READ_SHADOW = %x\n", Get_CR0_READ_SHADOW()); } +void PrintTrace_CR0_READ_SHADOW() { PrintTrace("CR0_READ_SHADOW = %x\n", Get_CR0_READ_SHADOW()); } void Set_CR4_READ_SHADOW(uint_t val) { VMCS_WRITE(CR4_READ_SHADOW,val); } uint_t Get_CR4_READ_SHADOW() { uint_t rc; VMCS_READ(CR4_READ_SHADOW,&rc); return rc; } -void SerialPrint_CR4_READ_SHADOW() { SerialPrint("CR4_READ_SHADOW = %x\n", Get_CR4_READ_SHADOW()); } +void PrintTrace_CR4_READ_SHADOW() { PrintTrace("CR4_READ_SHADOW = %x\n", Get_CR4_READ_SHADOW()); } void Set_CR3_TARGET_VALUE_0(uint_t val) { VMCS_WRITE(CR3_TARGET_VALUE_0,val); } uint_t Get_CR3_TARGET_VALUE_0() { uint_t rc; VMCS_READ(CR3_TARGET_VALUE_0,&rc); return rc; } -void SerialPrint_CR3_TARGET_VALUE_0() { SerialPrint("CR3_TARGET_VALUE_0 = %x\n", Get_CR3_TARGET_VALUE_0()); } +void PrintTrace_CR3_TARGET_VALUE_0() { PrintTrace("CR3_TARGET_VALUE_0 = %x\n", Get_CR3_TARGET_VALUE_0()); } void Set_CR3_TARGET_VALUE_1(uint_t val) { VMCS_WRITE(CR3_TARGET_VALUE_1,val); } uint_t Get_CR3_TARGET_VALUE_1() { uint_t rc; VMCS_READ(CR3_TARGET_VALUE_1,&rc); return rc; } -void SerialPrint_CR3_TARGET_VALUE_1() { SerialPrint("CR3_TARGET_VALUE_1 = %x\n", Get_CR3_TARGET_VALUE_1()); } +void PrintTrace_CR3_TARGET_VALUE_1() { PrintTrace("CR3_TARGET_VALUE_1 = %x\n", Get_CR3_TARGET_VALUE_1()); } void Set_CR3_TARGET_VALUE_2(uint_t val) { VMCS_WRITE(CR3_TARGET_VALUE_2,val); } uint_t Get_CR3_TARGET_VALUE_2() { uint_t rc; VMCS_READ(CR3_TARGET_VALUE_2,&rc); return rc; } -void SerialPrint_CR3_TARGET_VALUE_2() { SerialPrint("CR3_TARGET_VALUE_2 = %x\n", Get_CR3_TARGET_VALUE_2()); } +void PrintTrace_CR3_TARGET_VALUE_2() { PrintTrace("CR3_TARGET_VALUE_2 = %x\n", Get_CR3_TARGET_VALUE_2()); } void Set_CR3_TARGET_VALUE_3(uint_t val) { VMCS_WRITE(CR3_TARGET_VALUE_3,val); } uint_t Get_CR3_TARGET_VALUE_3() { uint_t rc; VMCS_READ(CR3_TARGET_VALUE_3,&rc); return rc; } -void SerialPrint_CR3_TARGET_VALUE_3() { SerialPrint("CR3_TARGET_VALUE_3 = %x\n", Get_CR3_TARGET_VALUE_3()); } +void PrintTrace_CR3_TARGET_VALUE_3() { PrintTrace("CR3_TARGET_VALUE_3 = %x\n", Get_CR3_TARGET_VALUE_3()); } void Set_EXIT_QUALIFICATION(uint_t val) { VMCS_WRITE(EXIT_QUALIFICATION,val); } uint_t Get_EXIT_QUALIFICATION() { uint_t rc; VMCS_READ(EXIT_QUALIFICATION,&rc); return rc; } -void SerialPrint_EXIT_QUALIFICATION() { SerialPrint("EXIT_QUALIFICATION = %x\n", Get_EXIT_QUALIFICATION()); } +void PrintTrace_EXIT_QUALIFICATION() { PrintTrace("EXIT_QUALIFICATION = %x\n", Get_EXIT_QUALIFICATION()); } void Set_IO_RCX(uint_t val) { VMCS_WRITE(IO_RCX,val); } uint_t Get_IO_RCX() { uint_t rc; VMCS_READ(IO_RCX,&rc); return rc; } -void SerialPrint_IO_RCX() { SerialPrint("IO_RCX = %x\n", Get_IO_RCX()); } +void PrintTrace_IO_RCX() { PrintTrace("IO_RCX = %x\n", Get_IO_RCX()); } void Set_IO_RSI(uint_t val) { VMCS_WRITE(IO_RSI,val); } uint_t Get_IO_RSI() { uint_t rc; VMCS_READ(IO_RSI,&rc); return rc; } -void SerialPrint_IO_RSI() { SerialPrint("IO_RSI = %x\n", Get_IO_RSI()); } +void PrintTrace_IO_RSI() { PrintTrace("IO_RSI = %x\n", Get_IO_RSI()); } void Set_IO_RDI(uint_t val) { VMCS_WRITE(IO_RDI,val); } uint_t Get_IO_RDI() { uint_t rc; VMCS_READ(IO_RDI,&rc); return rc; } -void SerialPrint_IO_RDI() { SerialPrint("IO_RDI = %x\n", Get_IO_RDI()); } +void PrintTrace_IO_RDI() { PrintTrace("IO_RDI = %x\n", Get_IO_RDI()); } void Set_IO_RIP(uint_t val) { VMCS_WRITE(IO_RIP,val); } uint_t Get_IO_RIP() { uint_t rc; VMCS_READ(IO_RIP,&rc); return rc; } -void SerialPrint_IO_RIP() { SerialPrint("IO_RIP = %x\n", Get_IO_RIP()); } +void PrintTrace_IO_RIP() { PrintTrace("IO_RIP = %x\n", Get_IO_RIP()); } void Set_GUEST_LINEAR_ADDR(uint_t val) { VMCS_WRITE(GUEST_LINEAR_ADDR,val); } uint_t Get_GUEST_LINEAR_ADDR() { uint_t rc; VMCS_READ(GUEST_LINEAR_ADDR,&rc); return rc; } -void SerialPrint_GUEST_LINEAR_ADDR() { SerialPrint("GUEST_LINEAR_ADDR = %x\n", Get_GUEST_LINEAR_ADDR()); } +void PrintTrace_GUEST_LINEAR_ADDR() { PrintTrace("GUEST_LINEAR_ADDR = %x\n", Get_GUEST_LINEAR_ADDR()); } void Set_GUEST_CR0(uint_t val) { VMCS_WRITE(GUEST_CR0,val); } uint_t Get_GUEST_CR0() { uint_t rc; VMCS_READ(GUEST_CR0,&rc); return rc; } -void SerialPrint_GUEST_CR0() { SerialPrint("GUEST_CR0 = %x\n", Get_GUEST_CR0()); } +void PrintTrace_GUEST_CR0() { PrintTrace("GUEST_CR0 = %x\n", Get_GUEST_CR0()); } void Set_GUEST_CR3(uint_t val) { VMCS_WRITE(GUEST_CR3,val); } uint_t Get_GUEST_CR3() { uint_t rc; VMCS_READ(GUEST_CR3,&rc); return rc; } -void SerialPrint_GUEST_CR3() { SerialPrint("GUEST_CR3 = %x\n", Get_GUEST_CR3()); } +void PrintTrace_GUEST_CR3() { PrintTrace("GUEST_CR3 = %x\n", Get_GUEST_CR3()); } void Set_GUEST_CR4(uint_t val) { VMCS_WRITE(GUEST_CR4,val); } uint_t Get_GUEST_CR4() { uint_t rc; VMCS_READ(GUEST_CR4,&rc); return rc; } -void SerialPrint_GUEST_CR4() { SerialPrint("GUEST_CR4 = %x\n", Get_GUEST_CR4()); } +void PrintTrace_GUEST_CR4() { PrintTrace("GUEST_CR4 = %x\n", Get_GUEST_CR4()); } void Set_GUEST_ES_BASE(uint_t val) { VMCS_WRITE(GUEST_ES_BASE,val); } uint_t Get_GUEST_ES_BASE() { uint_t rc; VMCS_READ(GUEST_ES_BASE,&rc); return rc; } -void SerialPrint_GUEST_ES_BASE() { SerialPrint("GUEST_ES_BASE = %x\n", Get_GUEST_ES_BASE()); } +void PrintTrace_GUEST_ES_BASE() { PrintTrace("GUEST_ES_BASE = %x\n", Get_GUEST_ES_BASE()); } void Set_GUEST_CS_BASE(uint_t val) { VMCS_WRITE(GUEST_CS_BASE,val); } uint_t Get_GUEST_CS_BASE() { uint_t rc; VMCS_READ(GUEST_CS_BASE,&rc); return rc; } -void SerialPrint_GUEST_CS_BASE() { SerialPrint("GUEST_CS_BASE = %x\n", Get_GUEST_CS_BASE()); } +void PrintTrace_GUEST_CS_BASE() { PrintTrace("GUEST_CS_BASE = %x\n", Get_GUEST_CS_BASE()); } void Set_GUEST_SS_BASE(uint_t val) { VMCS_WRITE(GUEST_SS_BASE,val); } uint_t Get_GUEST_SS_BASE() { uint_t rc; VMCS_READ(GUEST_SS_BASE,&rc); return rc; } -void SerialPrint_GUEST_SS_BASE() { SerialPrint("GUEST_SS_BASE = %x\n", Get_GUEST_SS_BASE()); } +void PrintTrace_GUEST_SS_BASE() { PrintTrace("GUEST_SS_BASE = %x\n", Get_GUEST_SS_BASE()); } void Set_GUEST_DS_BASE(uint_t val) { VMCS_WRITE(GUEST_DS_BASE,val); } uint_t Get_GUEST_DS_BASE() { uint_t rc; VMCS_READ(GUEST_DS_BASE,&rc); return rc; } -void SerialPrint_GUEST_DS_BASE() { SerialPrint("GUEST_DS_BASE = %x\n", Get_GUEST_DS_BASE()); } +void PrintTrace_GUEST_DS_BASE() { PrintTrace("GUEST_DS_BASE = %x\n", Get_GUEST_DS_BASE()); } void Set_GUEST_FS_BASE(uint_t val) { VMCS_WRITE(GUEST_FS_BASE,val); } uint_t Get_GUEST_FS_BASE() { uint_t rc; VMCS_READ(GUEST_FS_BASE,&rc); return rc; } -void SerialPrint_GUEST_FS_BASE() { SerialPrint("GUEST_FS_BASE = %x\n", Get_GUEST_FS_BASE()); } +void PrintTrace_GUEST_FS_BASE() { PrintTrace("GUEST_FS_BASE = %x\n", Get_GUEST_FS_BASE()); } void Set_GUEST_GS_BASE(uint_t val) { VMCS_WRITE(GUEST_GS_BASE,val); } uint_t Get_GUEST_GS_BASE() { uint_t rc; VMCS_READ(GUEST_GS_BASE,&rc); return rc; } -void SerialPrint_GUEST_GS_BASE() { SerialPrint("GUEST_GS_BASE = %x\n", Get_GUEST_GS_BASE()); } +void PrintTrace_GUEST_GS_BASE() { PrintTrace("GUEST_GS_BASE = %x\n", Get_GUEST_GS_BASE()); } void Set_GUEST_LDTR_BASE(uint_t val) { VMCS_WRITE(GUEST_LDTR_BASE,val); } uint_t Get_GUEST_LDTR_BASE() { uint_t rc; VMCS_READ(GUEST_LDTR_BASE,&rc); return rc; } -void SerialPrint_GUEST_LDTR_BASE() { SerialPrint("GUEST_LDTR_BASE = %x\n", Get_GUEST_LDTR_BASE()); } +void PrintTrace_GUEST_LDTR_BASE() { PrintTrace("GUEST_LDTR_BASE = %x\n", Get_GUEST_LDTR_BASE()); } void Set_GUEST_TR_BASE(uint_t val) { VMCS_WRITE(GUEST_TR_BASE,val); } uint_t Get_GUEST_TR_BASE() { uint_t rc; VMCS_READ(GUEST_TR_BASE,&rc); return rc; } -void SerialPrint_GUEST_TR_BASE() { SerialPrint("GUEST_TR_BASE = %x\n", Get_GUEST_TR_BASE()); } +void PrintTrace_GUEST_TR_BASE() { PrintTrace("GUEST_TR_BASE = %x\n", Get_GUEST_TR_BASE()); } void Set_GUEST_GDTR_BASE(uint_t val) { VMCS_WRITE(GUEST_GDTR_BASE,val); } uint_t Get_GUEST_GDTR_BASE() { uint_t rc; VMCS_READ(GUEST_GDTR_BASE,&rc); return rc; } -void SerialPrint_GUEST_GDTR_BASE() { SerialPrint("GUEST_GDTR_BASE = %x\n", Get_GUEST_GDTR_BASE()); } +void PrintTrace_GUEST_GDTR_BASE() { PrintTrace("GUEST_GDTR_BASE = %x\n", Get_GUEST_GDTR_BASE()); } void Set_GUEST_IDTR_BASE(uint_t val) { VMCS_WRITE(GUEST_IDTR_BASE,val); } uint_t Get_GUEST_IDTR_BASE() { uint_t rc; VMCS_READ(GUEST_IDTR_BASE,&rc); return rc; } -void SerialPrint_GUEST_IDTR_BASE() { SerialPrint("GUEST_IDTR_BASE = %x\n", Get_GUEST_IDTR_BASE()); } +void PrintTrace_GUEST_IDTR_BASE() { PrintTrace("GUEST_IDTR_BASE = %x\n", Get_GUEST_IDTR_BASE()); } void Set_GUEST_DR7(uint_t val) { VMCS_WRITE(GUEST_DR7,val); } uint_t Get_GUEST_DR7() { uint_t rc; VMCS_READ(GUEST_DR7,&rc); return rc; } -void SerialPrint_GUEST_DR7() { SerialPrint("GUEST_DR7 = %x\n", Get_GUEST_DR7()); } +void PrintTrace_GUEST_DR7() { PrintTrace("GUEST_DR7 = %x\n", Get_GUEST_DR7()); } void Set_GUEST_RSP(uint_t val) { VMCS_WRITE(GUEST_RSP,val); } uint_t Get_GUEST_RSP() { uint_t rc; VMCS_READ(GUEST_RSP,&rc); return rc; } -void SerialPrint_GUEST_RSP() { SerialPrint("GUEST_RSP = %x\n", Get_GUEST_RSP()); } +void PrintTrace_GUEST_RSP() { PrintTrace("GUEST_RSP = %x\n", Get_GUEST_RSP()); } void Set_GUEST_RIP(uint_t val) { VMCS_WRITE(GUEST_RIP,val); } uint_t Get_GUEST_RIP() { uint_t rc; VMCS_READ(GUEST_RIP,&rc); return rc; } -void SerialPrint_GUEST_RIP() { SerialPrint("GUEST_RIP = %x\n", Get_GUEST_RIP()); } +void PrintTrace_GUEST_RIP() { PrintTrace("GUEST_RIP = %x\n", Get_GUEST_RIP()); } void Set_GUEST_RFLAGS(uint_t val) { VMCS_WRITE(GUEST_RFLAGS,val); } uint_t Get_GUEST_RFLAGS() { uint_t rc; VMCS_READ(GUEST_RFLAGS,&rc); return rc; } -void SerialPrint_GUEST_RFLAGS() { SerialPrint("GUEST_RFLAGS = %x\n", Get_GUEST_RFLAGS()); } +void PrintTrace_GUEST_RFLAGS() { PrintTrace("GUEST_RFLAGS = %x\n", Get_GUEST_RFLAGS()); } void Set_GUEST_PENDING_DEBUG_EXCS(uint_t val) { VMCS_WRITE(GUEST_PENDING_DEBUG_EXCS,val); } uint_t Get_GUEST_PENDING_DEBUG_EXCS() { uint_t rc; VMCS_READ(GUEST_PENDING_DEBUG_EXCS,&rc); return rc; } -void SerialPrint_GUEST_PENDING_DEBUG_EXCS() { SerialPrint("GUEST_PENDING_DEBUG_EXCS = %x\n", Get_GUEST_PENDING_DEBUG_EXCS()); } +void PrintTrace_GUEST_PENDING_DEBUG_EXCS() { PrintTrace("GUEST_PENDING_DEBUG_EXCS = %x\n", Get_GUEST_PENDING_DEBUG_EXCS()); } void Set_GUEST_IA32_SYSENTER_ESP(uint_t val) { VMCS_WRITE(GUEST_IA32_SYSENTER_ESP,val); } uint_t Get_GUEST_IA32_SYSENTER_ESP() { uint_t rc; VMCS_READ(GUEST_IA32_SYSENTER_ESP,&rc); return rc; } -void SerialPrint_GUEST_IA32_SYSENTER_ESP() { SerialPrint("GUEST_IA32_SYSENTER_ESP = %x\n", Get_GUEST_IA32_SYSENTER_ESP()); } +void PrintTrace_GUEST_IA32_SYSENTER_ESP() { PrintTrace("GUEST_IA32_SYSENTER_ESP = %x\n", Get_GUEST_IA32_SYSENTER_ESP()); } void Set_GUEST_IA32_SYSENTER_EIP(uint_t val) { VMCS_WRITE(GUEST_IA32_SYSENTER_EIP,val); } uint_t Get_GUEST_IA32_SYSENTER_EIP() { uint_t rc; VMCS_READ(GUEST_IA32_SYSENTER_EIP,&rc); return rc; } -void SerialPrint_GUEST_IA32_SYSENTER_EIP() { SerialPrint("GUEST_IA32_SYSENTER_EIP = %x\n", Get_GUEST_IA32_SYSENTER_EIP()); } +void PrintTrace_GUEST_IA32_SYSENTER_EIP() { PrintTrace("GUEST_IA32_SYSENTER_EIP = %x\n", Get_GUEST_IA32_SYSENTER_EIP()); } void Set_HOST_CR0(uint_t val) { VMCS_WRITE(HOST_CR0,val); } uint_t Get_HOST_CR0() { uint_t rc; VMCS_READ(HOST_CR0,&rc); return rc; } -void SerialPrint_HOST_CR0() { SerialPrint("HOST_CR0 = %x\n", Get_HOST_CR0()); } +void PrintTrace_HOST_CR0() { PrintTrace("HOST_CR0 = %x\n", Get_HOST_CR0()); } void Set_HOST_CR3(uint_t val) { VMCS_WRITE(HOST_CR3,val); } uint_t Get_HOST_CR3() { uint_t rc; VMCS_READ(HOST_CR3,&rc); return rc; } -void SerialPrint_HOST_CR3() { SerialPrint("HOST_CR3 = %x\n", Get_HOST_CR3()); } +void PrintTrace_HOST_CR3() { PrintTrace("HOST_CR3 = %x\n", Get_HOST_CR3()); } void Set_HOST_CR4(uint_t val) { VMCS_WRITE(HOST_CR4,val); } uint_t Get_HOST_CR4() { uint_t rc; VMCS_READ(HOST_CR4,&rc); return rc; } -void SerialPrint_HOST_CR4() { SerialPrint("HOST_CR4 = %x\n", Get_HOST_CR4()); } +void PrintTrace_HOST_CR4() { PrintTrace("HOST_CR4 = %x\n", Get_HOST_CR4()); } void Set_HOST_FS_BASE(uint_t val) { VMCS_WRITE(HOST_FS_BASE,val); } uint_t Get_HOST_FS_BASE() { uint_t rc; VMCS_READ(HOST_FS_BASE,&rc); return rc; } -void SerialPrint_HOST_FS_BASE() { SerialPrint("HOST_FS_BASE = %x\n", Get_HOST_FS_BASE()); } +void PrintTrace_HOST_FS_BASE() { PrintTrace("HOST_FS_BASE = %x\n", Get_HOST_FS_BASE()); } void Set_HOST_GS_BASE(uint_t val) { VMCS_WRITE(HOST_GS_BASE,val); } uint_t Get_HOST_GS_BASE() { uint_t rc; VMCS_READ(HOST_GS_BASE,&rc); return rc; } -void SerialPrint_HOST_GS_BASE() { SerialPrint("HOST_GS_BASE = %x\n", Get_HOST_GS_BASE()); } +void PrintTrace_HOST_GS_BASE() { PrintTrace("HOST_GS_BASE = %x\n", Get_HOST_GS_BASE()); } void Set_HOST_TR_BASE(uint_t val) { VMCS_WRITE(HOST_TR_BASE,val); } uint_t Get_HOST_TR_BASE() { uint_t rc; VMCS_READ(HOST_TR_BASE,&rc); return rc; } -void SerialPrint_HOST_TR_BASE() { SerialPrint("HOST_TR_BASE = %x\n", Get_HOST_TR_BASE()); } +void PrintTrace_HOST_TR_BASE() { PrintTrace("HOST_TR_BASE = %x\n", Get_HOST_TR_BASE()); } void Set_HOST_GDTR_BASE(uint_t val) { VMCS_WRITE(HOST_GDTR_BASE,val); } uint_t Get_HOST_GDTR_BASE() { uint_t rc; VMCS_READ(HOST_GDTR_BASE,&rc); return rc; } -void SerialPrint_HOST_GDTR_BASE() { SerialPrint("HOST_GDTR_BASE = %x\n", Get_HOST_GDTR_BASE()); } +void PrintTrace_HOST_GDTR_BASE() { PrintTrace("HOST_GDTR_BASE = %x\n", Get_HOST_GDTR_BASE()); } void Set_HOST_IDTR_BASE(uint_t val) { VMCS_WRITE(HOST_IDTR_BASE,val); } uint_t Get_HOST_IDTR_BASE() { uint_t rc; VMCS_READ(HOST_IDTR_BASE,&rc); return rc; } -void SerialPrint_HOST_IDTR_BASE() { SerialPrint("HOST_IDTR_BASE = %x\n", Get_HOST_IDTR_BASE()); } +void PrintTrace_HOST_IDTR_BASE() { PrintTrace("HOST_IDTR_BASE = %x\n", Get_HOST_IDTR_BASE()); } void Set_HOST_IA32_SYSENTER_ESP(uint_t val) { VMCS_WRITE(HOST_IA32_SYSENTER_ESP,val); } uint_t Get_HOST_IA32_SYSENTER_ESP() { uint_t rc; VMCS_READ(HOST_IA32_SYSENTER_ESP,&rc); return rc; } -void SerialPrint_HOST_IA32_SYSENTER_ESP() { SerialPrint("HOST_IA32_SYSENTER_ESP = %x\n", Get_HOST_IA32_SYSENTER_ESP()); } +void PrintTrace_HOST_IA32_SYSENTER_ESP() { PrintTrace("HOST_IA32_SYSENTER_ESP = %x\n", Get_HOST_IA32_SYSENTER_ESP()); } void Set_HOST_IA32_SYSENTER_EIP(uint_t val) { VMCS_WRITE(HOST_IA32_SYSENTER_EIP,val); } uint_t Get_HOST_IA32_SYSENTER_EIP() { uint_t rc; VMCS_READ(HOST_IA32_SYSENTER_EIP,&rc); return rc; } -void SerialPrint_HOST_IA32_SYSENTER_EIP() { SerialPrint("HOST_IA32_SYSENTER_EIP = %x\n", Get_HOST_IA32_SYSENTER_EIP()); } +void PrintTrace_HOST_IA32_SYSENTER_EIP() { PrintTrace("HOST_IA32_SYSENTER_EIP = %x\n", Get_HOST_IA32_SYSENTER_EIP()); } void Set_HOST_RSP(uint_t val) { VMCS_WRITE(HOST_RSP,val); } uint_t Get_HOST_RSP() { uint_t rc; VMCS_READ(HOST_RSP,&rc); return rc; } -void SerialPrint_HOST_RSP() { SerialPrint("HOST_RSP = %x\n", Get_HOST_RSP()); } +void PrintTrace_HOST_RSP() { PrintTrace("HOST_RSP = %x\n", Get_HOST_RSP()); } void Set_HOST_RIP(uint_t val) { VMCS_WRITE(HOST_RIP,val); } uint_t Get_HOST_RIP() { uint_t rc; VMCS_READ(HOST_RIP,&rc); return rc; } -void SerialPrint_HOST_RIP() { SerialPrint("HOST_RIP = %x\n", Get_HOST_RIP()); } - -void SerialPrint_VMCS_ALL() { - - SerialPrint("==>Guest State Area\n"); - SerialPrint("==>==> Guest Register State\n"); - SerialPrint_GUEST_CR0(); - SerialPrint_GUEST_CR3(); - SerialPrint_GUEST_CR4(); - SerialPrint_GUEST_DR7(); - SerialPrint_GUEST_RSP(); - SerialPrint_GUEST_RIP(); - SerialPrint_GUEST_RFLAGS(); - SerialPrint_VMCS_GUEST_CS_SELECTOR(); - SerialPrint_VMCS_GUEST_SS_SELECTOR(); - SerialPrint_VMCS_GUEST_DS_SELECTOR(); - SerialPrint_VMCS_GUEST_ES_SELECTOR(); - SerialPrint_VMCS_GUEST_FS_SELECTOR(); - SerialPrint_VMCS_GUEST_GS_SELECTOR(); - SerialPrint_VMCS_GUEST_LDTR_SELECTOR(); - SerialPrint_VMCS_GUEST_TR_SELECTOR(); - SerialPrint_GUEST_CS_BASE(); - SerialPrint_GUEST_SS_BASE(); - SerialPrint_GUEST_DS_BASE(); - SerialPrint_GUEST_ES_BASE(); - SerialPrint_GUEST_FS_BASE(); - SerialPrint_GUEST_GS_BASE(); - SerialPrint_GUEST_LDTR_BASE(); - SerialPrint_GUEST_TR_BASE(); - SerialPrint_GUEST_CS_LIMIT(); - SerialPrint_GUEST_SS_LIMIT(); - SerialPrint_GUEST_DS_LIMIT(); - SerialPrint_GUEST_ES_LIMIT(); - SerialPrint_GUEST_FS_LIMIT(); - SerialPrint_GUEST_GS_LIMIT(); - SerialPrint_GUEST_LDTR_LIMIT(); - SerialPrint_GUEST_TR_LIMIT(); - SerialPrint_GUEST_ES_ACCESS(); - SerialPrint_GUEST_CS_ACCESS(); - SerialPrint_GUEST_SS_ACCESS(); - SerialPrint_GUEST_DS_ACCESS(); - SerialPrint_GUEST_FS_ACCESS(); - SerialPrint_GUEST_GS_ACCESS(); - SerialPrint_GUEST_LDTR_ACCESS(); - SerialPrint_GUEST_TR_ACCESS(); - SerialPrint_GUEST_GDTR_BASE(); - SerialPrint_GUEST_IDTR_BASE(); - SerialPrint_GUEST_GDTR_LIMIT(); - SerialPrint_GUEST_IDTR_LIMIT(); - SerialPrint_GUEST_IA32_DEBUGCTL(); - SerialPrint_GUEST_IA32_DEBUGCTL_HIGH(); - SerialPrint_GUEST_IA32_SYSENTER_CS(); - SerialPrint_GUEST_IA32_SYSENTER_ESP(); - SerialPrint_GUEST_IA32_SYSENTER_EIP(); - SerialPrint_GUEST_SMBASE(); - - SerialPrint("==>==> Guest Non-Register State\n"); - SerialPrint_GUEST_ACTIVITY_STATE(); - SerialPrint_GUEST_INT_STATE(); - SerialPrint_GUEST_PENDING_DEBUG_EXCS(); - SerialPrint_VMCS_LINK_PTR(); - SerialPrint_VMCS_LINK_PTR_HIGH(); - - SerialPrint("\n==> Host State Area\n"); - SerialPrint_HOST_CR0(); - SerialPrint_HOST_CR3(); - SerialPrint_HOST_CR4(); - SerialPrint_HOST_RSP(); - SerialPrint_HOST_RIP(); - SerialPrint_VMCS_HOST_CS_SELECTOR(); - SerialPrint_VMCS_HOST_SS_SELECTOR(); - SerialPrint_VMCS_HOST_DS_SELECTOR(); - SerialPrint_VMCS_HOST_ES_SELECTOR(); - SerialPrint_VMCS_HOST_FS_SELECTOR(); - SerialPrint_VMCS_HOST_GS_SELECTOR(); - SerialPrint_VMCS_HOST_TR_SELECTOR(); - SerialPrint_HOST_FS_BASE(); - SerialPrint_HOST_GS_BASE(); - SerialPrint_HOST_TR_BASE(); - SerialPrint_HOST_GDTR_BASE(); - SerialPrint_HOST_IDTR_BASE(); - SerialPrint_HOST_IA32_SYSENTER_CS(); - SerialPrint_HOST_IA32_SYSENTER_ESP(); - SerialPrint_HOST_IA32_SYSENTER_EIP(); - - - SerialPrint("\n==> VM-Execution Controls:\n"); - SerialPrint_PIN_VM_EXEC_CTRLS(); - SerialPrint_PROC_VM_EXEC_CTRLS(); - SerialPrint_EXCEPTION_BITMAP(); - SerialPrint_PAGE_FAULT_ERROR_MASK(); - SerialPrint_PAGE_FAULT_ERROR_MATCH(); - SerialPrint_IO_BITMAP_A_ADDR(); - SerialPrint_IO_BITMAP_A_ADDR_HIGH(); - SerialPrint_IO_BITMAP_B_ADDR(); - SerialPrint_IO_BITMAP_B_ADDR_HIGH(); - SerialPrint_TSC_OFFSET(); - SerialPrint_TSC_OFFSET_HIGH(); - SerialPrint_CR0_GUEST_HOST_MASK(); - SerialPrint_CR0_READ_SHADOW(); - SerialPrint_CR4_GUEST_HOST_MASK(); - SerialPrint_CR4_READ_SHADOW(); - SerialPrint_CR3_TARGET_COUNT(); - SerialPrint_CR3_TARGET_VALUE_0(); - SerialPrint_CR3_TARGET_VALUE_1(); - SerialPrint_CR3_TARGET_VALUE_2(); - SerialPrint_CR3_TARGET_VALUE_3(); - SerialPrint_VIRT_APIC_PAGE_ADDR(); - SerialPrint_VIRT_APIC_PAGE_ADDR_HIGH(); - SerialPrint_TPR_THRESHOLD(); - SerialPrint_MSR_BITMAPS(); - SerialPrint_MSR_BITMAPS_HIGH(); - SerialPrint_VMCS_EXEC_PTR(); - SerialPrint_VMCS_EXEC_PTR_HIGH(); - - SerialPrint("\n==> VM Exit Controls\n"); - SerialPrint_VM_EXIT_CTRLS(); - SerialPrint_VM_EXIT_MSR_STORE_COUNT(); - SerialPrint_VM_EXIT_MSR_STORE_ADDR(); - SerialPrint_VM_EXIT_MSR_STORE_ADDR_HIGH(); - SerialPrint_VM_EXIT_MSR_LOAD_COUNT(); - SerialPrint_VM_EXIT_MSR_LOAD_ADDR(); - SerialPrint_VM_EXIT_MSR_LOAD_ADDR_HIGH(); - - SerialPrint("\n==> VM Entry Controls\n"); - SerialPrint_VM_ENTRY_CTRLS(); - SerialPrint_VM_ENTRY_MSR_LOAD_COUNT(); - SerialPrint_VM_ENTRY_MSR_LOAD_ADDR(); - SerialPrint_VM_ENTRY_MSR_LOAD_ADDR_HIGH(); - SerialPrint_VM_ENTRY_INT_INFO_FIELD(); - SerialPrint_VM_ENTRY_EXCEPTION_ERROR(); - SerialPrint_VM_ENTRY_INSTR_LENGTH(); - - SerialPrint("\n==> VM Exit Info\n"); - SerialPrint_EXIT_REASON(); - SerialPrint_EXIT_QUALIFICATION(); - SerialPrint_VM_EXIT_INT_INFO(); - SerialPrint_VM_EXIT_INT_ERROR(); - SerialPrint_IDT_VECTOR_INFO(); - SerialPrint_IDT_VECTOR_ERROR(); - SerialPrint_VM_EXIT_INSTR_LENGTH(); - SerialPrint_GUEST_LINEAR_ADDR(); - SerialPrint_VMX_INSTR_INFO(); - SerialPrint_IO_RCX(); - SerialPrint_IO_RSI(); - SerialPrint_IO_RDI(); - SerialPrint_IO_RIP(); - SerialPrint_VM_INSTR_ERROR(); - SerialPrint("\n"); +void PrintTrace_HOST_RIP() { PrintTrace("HOST_RIP = %x\n", Get_HOST_RIP()); } + +void PrintTrace_VMCS_ALL() { + + PrintTrace("==>Guest State Area\n"); + PrintTrace("==>==> Guest Register State\n"); + PrintTrace_GUEST_CR0(); + PrintTrace_GUEST_CR3(); + PrintTrace_GUEST_CR4(); + PrintTrace_GUEST_DR7(); + PrintTrace_GUEST_RSP(); + PrintTrace_GUEST_RIP(); + PrintTrace_GUEST_RFLAGS(); + PrintTrace_VMCS_GUEST_CS_SELECTOR(); + PrintTrace_VMCS_GUEST_SS_SELECTOR(); + PrintTrace_VMCS_GUEST_DS_SELECTOR(); + PrintTrace_VMCS_GUEST_ES_SELECTOR(); + PrintTrace_VMCS_GUEST_FS_SELECTOR(); + PrintTrace_VMCS_GUEST_GS_SELECTOR(); + PrintTrace_VMCS_GUEST_LDTR_SELECTOR(); + PrintTrace_VMCS_GUEST_TR_SELECTOR(); + PrintTrace_GUEST_CS_BASE(); + PrintTrace_GUEST_SS_BASE(); + PrintTrace_GUEST_DS_BASE(); + PrintTrace_GUEST_ES_BASE(); + PrintTrace_GUEST_FS_BASE(); + PrintTrace_GUEST_GS_BASE(); + PrintTrace_GUEST_LDTR_BASE(); + PrintTrace_GUEST_TR_BASE(); + PrintTrace_GUEST_CS_LIMIT(); + PrintTrace_GUEST_SS_LIMIT(); + PrintTrace_GUEST_DS_LIMIT(); + PrintTrace_GUEST_ES_LIMIT(); + PrintTrace_GUEST_FS_LIMIT(); + PrintTrace_GUEST_GS_LIMIT(); + PrintTrace_GUEST_LDTR_LIMIT(); + PrintTrace_GUEST_TR_LIMIT(); + PrintTrace_GUEST_ES_ACCESS(); + PrintTrace_GUEST_CS_ACCESS(); + PrintTrace_GUEST_SS_ACCESS(); + PrintTrace_GUEST_DS_ACCESS(); + PrintTrace_GUEST_FS_ACCESS(); + PrintTrace_GUEST_GS_ACCESS(); + PrintTrace_GUEST_LDTR_ACCESS(); + PrintTrace_GUEST_TR_ACCESS(); + PrintTrace_GUEST_GDTR_BASE(); + PrintTrace_GUEST_IDTR_BASE(); + PrintTrace_GUEST_GDTR_LIMIT(); + PrintTrace_GUEST_IDTR_LIMIT(); + PrintTrace_GUEST_IA32_DEBUGCTL(); + PrintTrace_GUEST_IA32_DEBUGCTL_HIGH(); + PrintTrace_GUEST_IA32_SYSENTER_CS(); + PrintTrace_GUEST_IA32_SYSENTER_ESP(); + PrintTrace_GUEST_IA32_SYSENTER_EIP(); + PrintTrace_GUEST_SMBASE(); + + PrintTrace("==>==> Guest Non-Register State\n"); + PrintTrace_GUEST_ACTIVITY_STATE(); + PrintTrace_GUEST_INT_STATE(); + PrintTrace_GUEST_PENDING_DEBUG_EXCS(); + PrintTrace_VMCS_LINK_PTR(); + PrintTrace_VMCS_LINK_PTR_HIGH(); + + PrintTrace("\n==> Host State Area\n"); + PrintTrace_HOST_CR0(); + PrintTrace_HOST_CR3(); + PrintTrace_HOST_CR4(); + PrintTrace_HOST_RSP(); + PrintTrace_HOST_RIP(); + PrintTrace_VMCS_HOST_CS_SELECTOR(); + PrintTrace_VMCS_HOST_SS_SELECTOR(); + PrintTrace_VMCS_HOST_DS_SELECTOR(); + PrintTrace_VMCS_HOST_ES_SELECTOR(); + PrintTrace_VMCS_HOST_FS_SELECTOR(); + PrintTrace_VMCS_HOST_GS_SELECTOR(); + PrintTrace_VMCS_HOST_TR_SELECTOR(); + PrintTrace_HOST_FS_BASE(); + PrintTrace_HOST_GS_BASE(); + PrintTrace_HOST_TR_BASE(); + PrintTrace_HOST_GDTR_BASE(); + PrintTrace_HOST_IDTR_BASE(); + PrintTrace_HOST_IA32_SYSENTER_CS(); + PrintTrace_HOST_IA32_SYSENTER_ESP(); + PrintTrace_HOST_IA32_SYSENTER_EIP(); + + + PrintTrace("\n==> VM-Execution Controls:\n"); + PrintTrace_PIN_VM_EXEC_CTRLS(); + PrintTrace_PROC_VM_EXEC_CTRLS(); + PrintTrace_EXCEPTION_BITMAP(); + PrintTrace_PAGE_FAULT_ERROR_MASK(); + PrintTrace_PAGE_FAULT_ERROR_MATCH(); + PrintTrace_IO_BITMAP_A_ADDR(); + PrintTrace_IO_BITMAP_A_ADDR_HIGH(); + PrintTrace_IO_BITMAP_B_ADDR(); + PrintTrace_IO_BITMAP_B_ADDR_HIGH(); + PrintTrace_TSC_OFFSET(); + PrintTrace_TSC_OFFSET_HIGH(); + PrintTrace_CR0_GUEST_HOST_MASK(); + PrintTrace_CR0_READ_SHADOW(); + PrintTrace_CR4_GUEST_HOST_MASK(); + PrintTrace_CR4_READ_SHADOW(); + PrintTrace_CR3_TARGET_COUNT(); + PrintTrace_CR3_TARGET_VALUE_0(); + PrintTrace_CR3_TARGET_VALUE_1(); + PrintTrace_CR3_TARGET_VALUE_2(); + PrintTrace_CR3_TARGET_VALUE_3(); + PrintTrace_VIRT_APIC_PAGE_ADDR(); + PrintTrace_VIRT_APIC_PAGE_ADDR_HIGH(); + PrintTrace_TPR_THRESHOLD(); + PrintTrace_MSR_BITMAPS(); + PrintTrace_MSR_BITMAPS_HIGH(); + PrintTrace_VMCS_EXEC_PTR(); + PrintTrace_VMCS_EXEC_PTR_HIGH(); + + PrintTrace("\n==> VM Exit Controls\n"); + PrintTrace_VM_EXIT_CTRLS(); + PrintTrace_VM_EXIT_MSR_STORE_COUNT(); + PrintTrace_VM_EXIT_MSR_STORE_ADDR(); + PrintTrace_VM_EXIT_MSR_STORE_ADDR_HIGH(); + PrintTrace_VM_EXIT_MSR_LOAD_COUNT(); + PrintTrace_VM_EXIT_MSR_LOAD_ADDR(); + PrintTrace_VM_EXIT_MSR_LOAD_ADDR_HIGH(); + + PrintTrace("\n==> VM Entry Controls\n"); + PrintTrace_VM_ENTRY_CTRLS(); + PrintTrace_VM_ENTRY_MSR_LOAD_COUNT(); + PrintTrace_VM_ENTRY_MSR_LOAD_ADDR(); + PrintTrace_VM_ENTRY_MSR_LOAD_ADDR_HIGH(); + PrintTrace_VM_ENTRY_INT_INFO_FIELD(); + PrintTrace_VM_ENTRY_EXCEPTION_ERROR(); + PrintTrace_VM_ENTRY_INSTR_LENGTH(); + + PrintTrace("\n==> VM Exit Info\n"); + PrintTrace_EXIT_REASON(); + PrintTrace_EXIT_QUALIFICATION(); + PrintTrace_VM_EXIT_INT_INFO(); + PrintTrace_VM_EXIT_INT_ERROR(); + PrintTrace_IDT_VECTOR_INFO(); + PrintTrace_IDT_VECTOR_ERROR(); + PrintTrace_VM_EXIT_INSTR_LENGTH(); + PrintTrace_GUEST_LINEAR_ADDR(); + PrintTrace_VMX_INSTR_INFO(); + PrintTrace_IO_RCX(); + PrintTrace_IO_RSI(); + PrintTrace_IO_RDI(); + PrintTrace_IO_RIP(); + PrintTrace_VM_INSTR_ERROR(); + PrintTrace("\n"); } diff --git a/palacios/src/geekos/vmm.c b/palacios/src/geekos/vmm.c index 70f5156..b1ff42a 100644 --- a/palacios/src/geekos/vmm.c +++ b/palacios/src/geekos/vmm.c @@ -2,22 +2,31 @@ #include #include + uint_t vmm_cpu_type; -void Init_VMM() { + +struct vmm_os_hooks * os_hooks = NULL; + + +void Init_VMM(struct vmm_os_hooks * hooks) { vmm_cpu_type = VMM_INVALID_CPU; + os_hooks = hooks; + + PrintDebug("sizeof ullong_t: %d\n", sizeof(ullong_t)); + if (is_svm_capable()) { vmm_cpu_type = VMM_SVM_CPU; - Print("Machine is SVM Capable\n"); + PrintDebug("Machine is SVM Capable\n"); Init_SVM(); } else if (is_vmx_capable()) { vmm_cpu_type = VMM_VMX_CPU; - Print("Machine is VMX Capable\n"); + PrintDebug("Machine is VMX Capable\n"); Init_VMX(); } else { - PrintBoth("CPU has no virtualization Extensions\n"); + PrintDebug("CPU has no virtualization Extensions\n"); } } diff --git a/palacios/src/geekos/vmm_util.c b/palacios/src/geekos/vmm_util.c new file mode 100644 index 0000000..2583c39 --- /dev/null +++ b/palacios/src/geekos/vmm_util.c @@ -0,0 +1,33 @@ +#include + + +void PrintTraceHex(unsigned char x) { + unsigned char z; + + z = (x>>4) & 0xf ; + PrintTrace("%x", z); + z = x & 0xf; + PrintTrace("%x", z); +} + + +void PrintTraceMemDump(unsigned char *start, int n) +{ + int i, j; + + for (i=0;i=32) && (start[j]<=126)) ? start[j] : '.'); + } + PrintTrace("\n"); + } +} diff --git a/palacios/src/geekos/vmx.c b/palacios/src/geekos/vmx.c index e5f08c3..84b6bd6 100644 --- a/palacios/src/geekos/vmx.c +++ b/palacios/src/geekos/vmx.c @@ -1,15 +1,18 @@ -#include -#include +/* Eventually we want to get rid of these */ #include -#include #include #include #include - - #include #include +/* ** */ +#include +#include +#include +#include +#include +#include extern void Get_MSR(unsigned int msr, uint_t * high, uint_t * low); extern void Set_MSR(unsigned int msr, uint_t high, uint_t low); @@ -62,13 +65,13 @@ static int ExecFaultingInstructionInVMM(struct VM *vm) myregs = (uint_t)&(vm->registers); - SerialPrintLevel(1000,"About the execute faulting instruction!\n"); - SerialPrintLevel(1000,"Instruction is:\n"); - SerialMemDump((void*)(address),vm->vmcs.exitInfoFields.instrLength); + PrintTrace("About the execute faulting instruction!\n"); + PrintTrace("Instruction is:\n"); + PrintTraceMemDump((void*)(address),vm->vmcs.exitInfoFields.instrLength); - SerialPrintLevel(1000,"The template code is:\n"); - SerialMemDump(&&template_code,TEMPLATE_CODE_LEN); + PrintTrace("The template code is:\n"); + PrintTraceMemDump(&&template_code,TEMPLATE_CODE_LEN); // clone the template code //memcpy(&&template_code,code,MAX_CODE); @@ -78,10 +81,10 @@ static int ExecFaultingInstructionInVMM(struct VM *vm) // overwrite the nops with the faulting instruction memcpy(&&template_code+INSTR_OFFSET_START, (void*)(address),vm->vmcs.exitInfoFields.instrLength); - SerialPrintLevel(1000,"Finished modifying the template code, which now is:\n"); - SerialMemDump(&&template_code,TEMPLATE_CODE_LEN); + PrintTrace("Finished modifying the template code, which now is:\n"); + PrintTraceMemDump(&&template_code,TEMPLATE_CODE_LEN); - SerialPrintLevel(1000,"Now entering modified template code\n"); + PrintTrace("Now entering modified template code\n"); template_code: @@ -117,7 +120,7 @@ static int ExecFaultingInstructionInVMM(struct VM *vm) : "m"(myregs) ); - SerialPrintLevel(1000,"Survived executing the faulting instruction and returning.\n"); + PrintTrace("Survived executing the faulting instruction and returning.\n"); vm->vmcs.guestStateArea.rip += vm->vmcs.exitInfoFields.instrLength; @@ -134,14 +137,14 @@ int is_vmx_capable() { if (ret & CPUID_1_ECX_VTXFLAG) { Get_MSR(IA32_FEATURE_CONTROL_MSR, &featureMSR.regs.high, &featureMSR.regs.low); - SerialPrintLevel(100,"MSRREGlow: 0x%.8x\n", featureMSR.regs.low); + PrintTrace("MSRREGlow: 0x%.8x\n", featureMSR.regs.low); if ((featureMSR.regs.low & FEATURE_CONTROL_VALID) != FEATURE_CONTROL_VALID) { - PrintBoth("VMX is locked -- enable in the BIOS\n"); + PrintDebug("VMX is locked -- enable in the BIOS\n"); return 0; } } else { - PrintBoth("VMX not supported on this cpu\n"); + PrintDebug("VMX not supported on this cpu\n"); return 0; } @@ -160,9 +163,9 @@ VmxOnRegion * Init_VMX() { ret = Enable_VMX((ullong_t)((uint_t)region)); if (ret == 0) { - PrintBoth("VMX Enabled\n"); + PrintDebug("VMX Enabled\n"); } else { - PrintBoth("VMX failure (ret = %d)\n", ret); + PrintDebug("VMX failure (ret = %d)\n", ret); } theVM.vmxonregion = region; @@ -183,9 +186,9 @@ void SetCtrlBitsCorrectly(int msrno, int vmcsno) uint_t reserved =0; union VMX_MSR msr; - SerialPrintLevel(100,"SetCtrlBitsCorrectly(%x,%x)\n",msrno,vmcsno); + PrintTrace("SetCtrlBitsCorrectly(%x,%x)\n",msrno,vmcsno); Get_MSR(msrno, &msr.regs.high, &msr.regs.low); - SerialPrintLevel(100,"MSR %x = %x : %x \n", msrno, msr.regs.high, msr.regs.low); + PrintTrace("MSR %x = %x : %x \n", msrno, msr.regs.high, msr.regs.low); reserved = msr.regs.low; reserved &= msr.regs.high; VMCS_WRITE(vmcsno, &reserved); @@ -197,10 +200,10 @@ void SetCRBitsCorrectly(int msr0no, int msr1no, int vmcsno) uint_t reserved =0; union VMX_MSR msr0, msr1; - SerialPrintLevel(100,"SetCRBitsCorrectly(%x,%x,%x)\n",msr0no,msr1no,vmcsno); + PrintTrace("SetCRBitsCorrectly(%x,%x,%x)\n",msr0no,msr1no,vmcsno); Get_MSR(msr0no, &msr0.regs.high, &msr0.regs.low); Get_MSR(msr1no, &msr1.regs.high, &msr1.regs.low); - SerialPrintLevel(100,"MSR %x = %x, %x = %x \n", msr0no, msr0.regs.low, msr1no, msr1.regs.low); + PrintTrace("MSR %x = %x, %x = %x \n", msr0no, msr0.regs.low, msr1no, msr1.regs.low); reserved = msr0.regs.low; reserved &= msr1.regs.low; VMCS_WRITE(vmcsno, &reserved); @@ -214,9 +217,9 @@ extern int vmRunning; static int PanicUnhandledVMExit(struct VM *vm) { Print("Panicking due to VMExit with reason %u\n",vm->vmcs.exitInfoFields.reason); - SerialPrint("Panicking due to VMExit with reason %u\n",vm->vmcs.exitInfoFields.reason); - SerialPrint_VMCS_ALL(); - SerialPrint_VMX_Regs(&(vm->registers)); + PrintTrace("Panicking due to VMExit with reason %u\n",vm->vmcs.exitInfoFields.reason); + PrintTrace_VMCS_ALL(); + PrintTrace_VMX_Regs(&(vm->registers)); VMXPanic(); return 0; } @@ -229,8 +232,8 @@ static int HandleVMPrintsAndPanics(struct VM *vm, uint_t port, uint_t data) vm->state == VM_VMXASSIST_V8086_BIOS || vm->state == VM_VMXASSIST_V8086)) { // Communication channel from VMXAssist - SerialPrintLevel(1000,"VMXASSIST Output Port\n"); - PrintBoth("%c",data&0xff); + PrintTrace("VMXASSIST Output Port\n"); + PrintDebug("%c",data&0xff); return 1; } @@ -240,14 +243,14 @@ static int HandleVMPrintsAndPanics(struct VM *vm, uint_t port, uint_t data) port==ROMBIOS_INFO_PORT) && (vm->state==VM_VMXASSIST_V8086_BIOS)) { // rombios is communicating - SerialPrintLevel(1000,"ROMBIOS Output Port\n"); - // PrintBoth("%c",data&0xff); + PrintTrace("ROMBIOS Output Port\n"); + // PrintDebug("%c",data&0xff); return 1; } if (port==BOOT_STATE_CARD_PORT && vm->state==VM_VMXASSIST_V8086_BIOS) { // rombios is sending something to the display card - SerialPrintLevel(1000,"Hex Display: 0x%x\n",data&0xff); + PrintTrace("Hex Display: 0x%x\n",data&0xff); return 1; } return 0; @@ -263,15 +266,15 @@ static int HandleInOutExit(struct VM *vm) address=GetLinearIP(vm); - SerialPrintLevel(1000,"Handling Input/Output Instruction Exit\n"); + PrintTrace("Handling Input/Output Instruction Exit\n"); if (SERIAL_PRINT_DEBUG && 1000>=SERIAL_PRINT_DEBUG_LEVEL) { - SerialPrint_VMX_Regs(regs); + PrintTrace_VMX_Regs(regs); } - SerialPrintLevel(1000,"Qualifications=0x%x\n",exitinfo->qualification); - SerialPrintLevel(1000,"Reason=0x%x\n",exitinfo->reason); - SerialPrintLevel(1000,"IO Port: 0x%x (%d)\n", qual->port, qual->port); - SerialPrintLevel(1000,"Instruction Info=%x\n",exitinfo->instrInfo); - SerialPrintLevel(1000,"%x : %s %s %s instruction of length %d for %d bytes from/to port 0x%x\n", + PrintTrace("Qualifications=0x%x\n",exitinfo->qualification); + PrintTrace("Reason=0x%x\n",exitinfo->reason); + PrintTrace("IO Port: 0x%x (%d)\n", qual->port, qual->port); + PrintTrace("Instruction Info=%x\n",exitinfo->instrInfo); + PrintTrace("%x : %s %s %s instruction of length %d for %d bytes from/to port 0x%x\n", address, qual->dir == 0 ? "output" : "input", qual->string ==0 ? "nonstring" : "STRING", @@ -284,7 +287,7 @@ static int HandleInOutExit(struct VM *vm) qual->port==PIC_MASTER_IMR_PORT || qual->port==PIC_SLAVE_CMD_ISR_PORT || qual->port==PIC_SLAVE_IMR_PORT) { - SerialPrintLevel(1000, "PIC Access\n"); + PrintTrace( "PIC Access\n"); } @@ -293,7 +296,7 @@ static int HandleInOutExit(struct VM *vm) vm->vmcs.guestStateArea.rip += exitinfo->instrLength; regs->eax = (regs->eax & 0xffffff00) | byte; - SerialPrintLevel(1000,"Returning 0x%x in eax\n",(regs->eax)); + PrintTrace("Returning 0x%x in eax\n",(regs->eax)); } if (qual->dir==0 && qual->REP==0 && qual->string==0) { @@ -303,7 +306,7 @@ static int HandleInOutExit(struct VM *vm) } else { // If not, just go ahead and do the outb Out_Byte(qual->port,regs->eax); - SerialPrintLevel(1000,"Wrote 0x%x to port\n",(regs->eax)); + PrintTrace("Wrote 0x%x to port\n",(regs->eax)); } vm->vmcs.guestStateArea.rip += exitinfo->instrLength; } @@ -317,15 +320,15 @@ static int HandleExternalIRQExit(struct VM *vm) struct VMCSExitInfoFields * exitinfo = &(vm->vmcs.exitInfoFields); struct VMExitIntInfo * intInfo = (struct VMExitIntInfo *)&(vm->vmcs.exitInfoFields.intInfo); - SerialPrintLevel(1000,"External Interrupt captured\n"); - SerialPrintLevel(100,"IntInfo: %x\n", exitinfo->intInfo); + PrintTrace("External Interrupt captured\n"); + PrintTrace("IntInfo: %x\n", exitinfo->intInfo); if (!intInfo->valid) { // interrupts are off, but this interrupt is not acknoledged (still pending) // so we turn on interrupts to deliver appropriately in the // host - SerialPrintLevel(100,"External Interrupt is invald. Turning Interrupts back on\n"); + PrintTrace("External Interrupt is invald. Turning Interrupts back on\n"); asm("sti"); return 0; } @@ -334,10 +337,10 @@ static int HandleExternalIRQExit(struct VM *vm) // acknowledged. We will now handle the interrupt ourselves // and turn interrupts back on in the host - SerialPrintLevel(100,"type: %d\n", intInfo->type); - SerialPrintLevel(100,"number: %d\n", intInfo->nr); + PrintTrace("type: %d\n", intInfo->type); + PrintTrace("number: %d\n", intInfo->nr); - SerialPrint("Interrupt %d occuring now and handled by HandleExternalIRQExit\n",intInfo->nr); + PrintTrace("Interrupt %d occuring now and handled by HandleExternalIRQExit\n",intInfo->nr); switch (intInfo->type) { case 0: { // ext. IRQ @@ -349,7 +352,7 @@ static int HandleExternalIRQExit(struct VM *vm) ((char*)(&&ext_int_seq_start))[1] = intInfo->nr; - SerialPrintLevel(100,"Interrupt instruction setup done %x\n", *((ushort_t *)(&&ext_int_seq_start))); + PrintTrace("Interrupt instruction setup done %x\n", *((ushort_t *)(&&ext_int_seq_start))); ext_int_seq_start: asm("int $0"); @@ -357,21 +360,21 @@ ext_int_seq_start: break; case 2: // NMI - SerialPrintLevel(100,"Type: NMI\n"); + PrintTrace("Type: NMI\n"); break; case 3: // hw exception - SerialPrintLevel(100,"Type: HW Exception\n"); + PrintTrace("Type: HW Exception\n"); break; case 4: // sw exception - SerialPrintLevel(100,"Type: SW Exception\n"); + PrintTrace("Type: SW Exception\n"); break; default: - SerialPrintLevel(100,"Invalid Interrupt Type\n"); + PrintTrace("Invalid Interrupt Type\n"); return -1; } if (intInfo->valid && intInfo->errorCode) { - SerialPrintLevel(100,"IntError: %x\n", exitinfo->intErrorCode); + PrintTrace("IntError: %x\n", exitinfo->intErrorCode); } @@ -390,8 +393,8 @@ void DecodeCurrentInstruction(struct VM *vm, struct Instruction *inst) - SerialPrintLevel(100,"DecodeCurrentInstruction: instruction is\n"); - SerialMemDump(t,length); + PrintTrace("DecodeCurrentInstruction: instruction is\n"); + PrintTraceMemDump(t,length); if (length==3 && t[0]==0x0f && t[1]==0x22 && t[2]==0xc0) { // mov from eax to cr0 @@ -402,7 +405,7 @@ void DecodeCurrentInstruction(struct VM *vm, struct Instruction *inst) inst->input1=vm->registers.eax; inst->input2=vm->vmcs.guestStateArea.cr0; inst->output=vm->registers.eax; - SerialPrintLevel(100,"MOV FROM EAX TO CR0\n"); + PrintTrace("MOV FROM EAX TO CR0\n"); } else { inst->type=VM_UNKNOWN_INST; } @@ -457,7 +460,7 @@ static void SetupV8086ModeForBoot(struct VM *vm) V8086ModeSegmentRegisterFixup(vm); - SerialPrint_VMCSData(&(vm->vmcs)); + PrintTrace_VMCSData(&(vm->vmcs)); } @@ -475,7 +478,7 @@ static int HandleExceptionOrNMI(struct VM *vm) uint_t ti=0; uint_t selectorindex=0; - SerialPrintLevel(1000,"Exception or NMI occurred\n"); + PrintTrace("Exception or NMI occurred\n"); num=vm->vmcs.exitInfoFields.intInfo & 0xff; type=(vm->vmcs.exitInfoFields.intInfo & 0x700)>>8; @@ -488,35 +491,35 @@ static int HandleExceptionOrNMI(struct VM *vm) selectorindex=(error>>3)&0xffff; } - SerialPrint("Exception %d now - handled by HandleExceptionOrNMI\n",num); + PrintTrace("Exception %d now - handled by HandleExceptionOrNMI\n",num); - SerialPrintLevel(1000,"Exception Number %u : %s\n", num, exception_names[num]); - SerialPrintLevel(1000,"Exception Type %u : %s\n", type, exception_type_names[type]); + PrintTrace("Exception Number %u : %s\n", num, exception_names[num]); + PrintTrace("Exception Type %u : %s\n", type, exception_type_names[type]); if (errorvalid) { if (ext) { - SerialPrintLevel(1000,"External\n"); + PrintTrace("External\n"); } else { - SerialPrintLevel(1000,"%s - Selector Index is %u\n", idt ? "IDT" : ti ? "LDT" : "GDT", selectorindex); + PrintTrace("%s - Selector Index is %u\n", idt ? "IDT" : ti ? "LDT" : "GDT", selectorindex); } } DecodeCurrentInstruction(vm,&inst); if (inst.type==VM_MOV_TO_CR0) { - SerialPrintLevel(1000,"MOV TO CR0, oldvalue=0x%x, newvalue=0x%x\n",inst.input2, inst.input1); + PrintTrace("MOV TO CR0, oldvalue=0x%x, newvalue=0x%x\n",inst.input2, inst.input1); if ((inst.input2 & CR0_PE) && !(inst.input1 & CR0_PE) && vm->state==VM_VMXASSIST_STARTUP) { // This is VMXAssist signalling for us to turn on V8086 mode and // jump into the bios - SerialPrintLevel(1000,"VMXAssist is signaling us for switch to V8086 mode and jump to 0xf000:fff0\n"); + PrintTrace("VMXAssist is signaling us for switch to V8086 mode and jump to 0xf000:fff0\n"); SetupV8086ModeForBoot(vm); goto leave; } else { - SerialPrintLevel(1000,"Instruction is a write to CR0, but we don't understand it so we'll just exec it\n"); + PrintTrace("Instruction is a write to CR0, but we don't understand it so we'll just exec it\n"); } } - SerialPrintLevel(1000,"Trying to execute the faulting instruction in VMM context now\n"); + PrintTrace("Trying to execute the faulting instruction in VMM context now\n"); ExecFaultingInstructionInVMM(vm); leave: @@ -543,7 +546,7 @@ int Do_VMM(struct VMXRegs regs) - SerialPrintLevel(100,"Vm Exit\n"); + PrintTrace("Vm Exit\n"); ret = VMCS_STORE(&vmcs_ptr); vmcs_ptr &= 0xffffffff; vmcs_ptr_low += vmcs_ptr; @@ -551,39 +554,39 @@ int Do_VMM(struct VMXRegs regs) - SerialPrintLevel(100,"ret=%d\n", ret); - SerialPrintLevel(100,"Revision: %x\n", *(uint_t *)(vmcs_ptr_low)); + PrintTrace("ret=%d\n", ret); + PrintTrace("Revision: %x\n", *(uint_t *)(vmcs_ptr_low)); vmx_abort = *(uint_t*)(((char *)vmcs_ptr_low)+4); struct VM *vm = FindVM(); if (vmx_abort != 0) { - SerialPrintLevel(1000,"VM ABORTED w/ code: %x\n", vmx_abort); + PrintTrace("VM ABORTED w/ code: %x\n", vmx_abort); return -1; } vm->registers = regs; if (CopyOutVMCSData(&(vm->vmcs)) != 0) { - SerialPrintLevel(1000,"Could not copy out VMCS\n"); + PrintTrace("Could not copy out VMCS\n"); return -1; } - SerialPrint("Guest esp: 0x%x (%u)\n", vm->vmcs.guestStateArea.rsp, vm->vmcs.guestStateArea.rsp); + PrintTrace("Guest esp: 0x%x (%u)\n", vm->vmcs.guestStateArea.rsp, vm->vmcs.guestStateArea.rsp); - SerialPrintLevel(100,"VM Exit for reason: %d (%x)\n", + PrintTrace("VM Exit for reason: %d (%x)\n", vm->vmcs.exitInfoFields.reason & 0x00000fff, vm->vmcs.exitInfoFields.reason); if (vm->vmcs.exitInfoFields.reason & (0x1<<29) ) { - SerialPrintLevel(1000,"VM Exit is from VMX root operation. Panicking\n"); + PrintTrace("VM Exit is from VMX root operation. Panicking\n"); VMXPanic(); } if (vm->vmcs.exitInfoFields.reason & (0x1<<31) ) { - SerialPrintLevel(1000,"VM Exit is due to a VM entry failure. Shouldn't happen here. Panicking\n"); - SerialPrint_VMCSData(&(vm->vmcs)); + PrintTrace("VM Exit is due to a VM entry failure. Shouldn't happen here. Panicking\n"); + PrintTrace_VMCSData(&(vm->vmcs)); VMXPanic(); } @@ -717,7 +720,7 @@ int Do_VMM(struct VMXRegs regs) } */ - SerialPrintLevel(100,"Returning from Do_VMM: %d\n", ret); + PrintTrace("Returning from Do_VMM: %d\n", ret); return ret; } @@ -772,19 +775,19 @@ int MyLaunch(struct VM *vm) int ret; int vmm_ret = 0; - SerialPrint("Guest ESP: 0x%x (%u)\n", guest_esp, guest_esp); + PrintTrace("Guest ESP: 0x%x (%u)\n", guest_esp, guest_esp); exit_eip=(uint_t)RunVMM; - SerialPrintLevel(100,"Clear\n"); + PrintTrace("Clear\n"); VMCS_CLEAR(vmcs); - SerialPrintLevel(100,"Load\n"); + PrintTrace("Load\n"); VMCS_LOAD(vmcs); - SerialPrintLevel(100,"VMCS_LINK_PTR\n"); + PrintTrace("VMCS_LINK_PTR\n"); VMCS_WRITE(VMCS_LINK_PTR, &f); - SerialPrintLevel(100,"VMCS_LINK_PTR_HIGH\n"); + PrintTrace("VMCS_LINK_PTR_HIGH\n"); VMCS_WRITE(VMCS_LINK_PTR_HIGH, &f); @@ -800,42 +803,42 @@ int MyLaunch(struct VM *vm) /* Host state */ - SerialPrintLevel(100,"Setting up host state\n"); + PrintTrace("Setting up host state\n"); SetCRBitsCorrectly(IA32_VMX_CR0_FIXED0_MSR, IA32_VMX_CR0_FIXED1_MSR, HOST_CR0); SetCRBitsCorrectly(IA32_VMX_CR4_FIXED0_MSR, IA32_VMX_CR4_FIXED1_MSR, HOST_CR4); ret = Init_VMCS_HostState(); if (ret != VMX_SUCCESS) { if (ret == VMX_FAIL_VALID) { - SerialPrintLevel(100,"Init Host state: VMCS FAILED WITH ERROR\n"); + PrintTrace("Init Host state: VMCS FAILED WITH ERROR\n"); } else { - SerialPrintLevel(100,"Init Host state: Invalid VMCS\n"); + PrintTrace("Init Host state: Invalid VMCS\n"); } return ret; } - // SerialPrintLevel(100,"HOST_RIP: %x (%u)\n", exit_eip, exit_eip); + // PrintTrace("HOST_RIP: %x (%u)\n", exit_eip, exit_eip); VMCS_WRITE(HOST_RIP, &exit_eip); /* Guest state */ - SerialPrintLevel(100,"Setting up guest state\n"); - SerialPrintLevel(100,"GUEST_RIP: %x (%u)\n", entry_eip, entry_eip); + PrintTrace("Setting up guest state\n"); + PrintTrace("GUEST_RIP: %x (%u)\n", entry_eip, entry_eip); VMCS_WRITE(GUEST_RIP,&entry_eip); SetCRBitsCorrectly(IA32_VMX_CR0_FIXED0_MSR, IA32_VMX_CR0_FIXED1_MSR, GUEST_CR0); SetCRBitsCorrectly(IA32_VMX_CR4_FIXED0_MSR, IA32_VMX_CR4_FIXED1_MSR, GUEST_CR4); ret = Init_VMCS_GuestState(); - SerialPrintLevel(100,"InitGuestState returned\n"); + PrintTrace("InitGuestState returned\n"); if (ret != VMX_SUCCESS) { if (ret == VMX_FAIL_VALID) { - SerialPrintLevel(100,"Init Guest state: VMCS FAILED WITH ERROR\n"); + PrintTrace("Init Guest state: VMCS FAILED WITH ERROR\n"); } else { - SerialPrintLevel(100,"Init Guest state: Invalid VMCS\n"); + PrintTrace("Init Guest state: Invalid VMCS\n"); } return ret; } - SerialPrintLevel(100,"GUEST_RSP: %x (%u)\n", guest_esp, (uint_t)guest_esp); + PrintTrace("GUEST_RSP: %x (%u)\n", guest_esp, (uint_t)guest_esp); VMCS_WRITE(GUEST_RSP,&guest_esp); // tmpReg = 0x4100; @@ -846,13 +849,13 @@ int MyLaunch(struct VM *vm) ConfigureExits(vm); - SerialPrintLevel(100,"VMCS_LAUNCH\n"); + PrintTrace("VMCS_LAUNCH\n"); vm->state=VM_VMXASSIST_STARTUP; vmm_ret = SAFE_VM_LAUNCH(); - SerialPrintLevel(100,"VMM error %d\n", vmm_ret); + PrintTrace("VMM error %d\n", vmm_ret); return vmm_ret; } @@ -872,9 +875,9 @@ int VMLaunch(struct VMDescriptor *vm) theVM.vmcsregion = vmcs; theVM.descriptor = *vm; - SerialPrintLevel(100,"vmcs_ptr_top=%x vmcs_ptr_bottom=%x, eip=%x\n", top, bottom, vm->entry_ip); + PrintTrace("vmcs_ptr_top=%x vmcs_ptr_bottom=%x, eip=%x\n", top, bottom, vm->entry_ip); rc=MyLaunch(&theVM); // vmcs_ptr, vm->entry_ip, vm->exit_eip, vm->guest_esp); - SerialPrintLevel(100,"Returned from MyLaunch();\n"); + PrintTrace("Returned from MyLaunch();\n"); return rc; } @@ -901,8 +904,8 @@ VMCS * CreateVMCS() { *(ulong_t *)vmcs = basicMSR.vmxBasic.revision; *(ulong_t *)((char*)vmcs + 4) = 0; - SerialPrintLevel(100,"VMCS Region size: %u\n", basicMSR.vmxBasic.regionSize); - SerialPrintLevel(100,"VMCS Abort: %x\n",*(uint_t *)(((char*)vmcs)+4)); + PrintTrace("VMCS Region size: %u\n", basicMSR.vmxBasic.regionSize); + PrintTrace("VMCS Abort: %x\n",*(uint_t *)(((char*)vmcs)+4)); return vmcs; }