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 (file)
--- 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 <daveho@cs.umd.edu>
- * $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 <geekos/ktypes.h>
+#include <geekos/fmtout.h>
 
 #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 (file)
--- 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 (file)
--- a/palacios/include/geekos/svm.h
+++ b/palacios/include/geekos/svm.h
@@ -1,9 +1,7 @@
 #ifndef __SVM_H
 #define __SVM_H
 
-#include <geekos/screen.h>
-#include <geekos/serial.h>
-
+#include <geekos/vmm.h>
 
 #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 (file)
--- 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 <geekos/serial.h>
 #include <geekos/vmcs_gen.h>
 
 #endif 

diff --git a/palacios/include/geekos/vmcs_gen.h b/palacios/include/geekos/vmcs_gen.h
index 4bdef7c..0e10af9 100644 (file)
--- 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 <geekos/vmcs.h>
+#include <geekos/vmm.h>
 
 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 (file)
--- a/palacios/include/geekos/vmm.h
+++ b/palacios/include/geekos/vmm.h
@@ -2,6 +2,45 @@
 #define __VMM_H
 
 
+#include <geekos/ktypes.h>
+#include <geekos/string.h>
+
+
+
+/* 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 (file)
--- 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 (file)
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 <geekos/vmm.h>
+
+
+
+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 (executable)
--- 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 <geekos/vmcs.h>\n";
+print HEADER "#ifndef $file\n";
+print HEADER "#define $file\n";
+print HEADER "#include <geekos/vmcs.h>\n";
+
 print SOURCE "#include <geekos/$file.h>\n";
 
 while (<STDIN>) {
@@ -28,10 +31,10 @@ sub GenSerUnserCode {
 
   print SOURCE <<END
 
-void    Set_$name(uint_t val) { VMCS_WRITE($name,val); } 
+void    Set_$name(uint_t val) { VMCS_WRITE($name,val); }
 uint_t  Get_$name() { uint_t rc; VMCS_READ($name,&rc); return rc; }
 
-void    SerialPrint_$name() { SerialPrint("$name = %x\\n", Get_$name()); }
+void    Print_$name() { PrintTrace("$name = %x\\n", Get_$name()); }
 
 END
 
@@ -41,7 +44,7 @@ END
 void    Set_$name(uint_t val);
 uint_t  Get_$name();
 
-void    SerialPrint_$name();
+void    Print_$name();
 
 END2
 
@@ -51,10 +54,10 @@ END2
 
 
 sub GenPrintAllCode  {
-  print SOURCE "void SerialPrint_VMCS_ALL() {\n";
+  print SOURCE "void PrintTrace_VMCS_ALL() {\n";
   while (my $name=shift) { 
-    print SOURCE "  SerialPrint_$name();\n";
+    print SOURCE "  PrintTrace_$name();\n";
   }
   print SOURCE "}\n";
-  print HEADER "void SerialPrint_VMCS_ALL();\n";
+  print HEADER "void PrintTrace_VMCS_ALL();\n";
 }

diff --git a/palacios/src/geekos/crc32.c b/palacios/src/geekos/crc32.c
index 0165c3b..a349bad 100644 (file)
--- a/palacios/src/geekos/crc32.c
+++ b/palacios/src/geekos/crc32.c
@@ -9,6 +9,7 @@
 #include <geekos/crc32.h>
 #include <geekos/kassert.h>
 #include <geekos/serial.h>
+#include <geekos/debug.h>
 
 #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 (file)
--- 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 <daveho@cs.umd.edu>
- * $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 <geekos/defs.h>
 #include <geekos/idt.h>
 #include <geekos/serial.h>
-
+#include <geekos/debug.h>
 /* ----------------------------------------------------------------------
  * Private data and functions
  * ---------------------------------------------------------------------- */

diff --git a/palacios/src/geekos/int.c b/palacios/src/geekos/int.c
index b4016f6..70b7b70 100644 (file)
--- 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 <daveho@cs.umd.edu>
- * $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 <geekos/kassert.h>
 #include <geekos/int.h>
 #include <geekos/serial.h>
-#include <geekos/vmcs.h>
+#include <geekos/debug.h>
 
 #include <geekos/cpu.h>
 
@@ -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 (file)
--- 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 <daveho@cs.umd.edu>
- * $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 <geekos/kthread.h>
 #include <geekos/malloc.h>
 #include <geekos/serial.h>
+#include <geekos/debug.h>
 
 /* ----------------------------------------------------------------------
  * Private data

diff --git a/palacios/src/geekos/main.c b/palacios/src/geekos/main.c
index 2cd5a6a..41ece4d 100644 (file)
--- a/palacios/src/geekos/main.c
+++ b/palacios/src/geekos/main.c
@@ -3,7 +3,7 @@
  * Copyright (c) 2001,2003,2004 David H. Hovemeyer <daveho@cs.umd.edu>
  * Copyright (c) 2003, Jeffrey K. Hollingsworth <hollings@cs.umd.edu>
  * Copyright (c) 2004, Iulian Neamtiu <neamtiu@cs.umd.edu>
- * $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 <geekos/paging.h>
 #include <geekos/ide.h>
 
+#include <geekos/debug.h>
 #include <geekos/vmm.h>
 
 #include <geekos/gdt.h>
@@ -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 (file)
--- 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 <daveho@cs.umd.edu>
  * Copyright (c) 2003, Jeffrey K. Hollingsworth <hollings@cs.umd.edu>
- * $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 <geekos/vmm_sizes.h>
 #include <geekos/serial.h>
+#include <geekos/debug.h>
 
 /* ----------------------------------------------------------------------
  * 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 (file)
--- 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 <hollings@cs.umd.edu>
  * Copyright (c) 2003,2004 David H. Hovemeyer <daveho@cs.umd.edu>
- * $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 <geekos/crc32.h>
 #include <geekos/paging.h>
 #include <geekos/serial.h>
-#include <geekos/vmcs.h>
+#include <geekos/debug.h>
 
 /* ----------------------------------------------------------------------
  * 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 (file)
--- 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 <daveho@cs.umd.edu>
- * $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 <geekos/ktypes.h>
 #include <geekos/io.h>
 #include <geekos/int.h>
-#include <geekos/fmtout.h>
 #include <geekos/screen.h>
+#include <geekos/debug.h>
 
 /*
  * 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 (file)
--- a/palacios/src/geekos/serial.c
+++ b/palacios/src/geekos/serial.c
@@ -2,11 +2,13 @@
 #include <geekos/reboot.h>
 #include <geekos/gdt.h>
 #include <geekos/idt.h>
+#include <geekos/fmtout.h>
 
 
 
 
 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 (file)
--- 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 (file)
--- 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 <daveho@cs.umd.edu>
  * Copyright (c) 2003, Jeffrey K. Hollingsworth <hollings@cs.umd.edu>
- * $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 <geekos/timer.h>
 
 #include <geekos/serial.h>
+#include <geekos/debug.h>
 
 #define HZ 100
 

diff --git a/palacios/src/geekos/trap.c b/palacios/src/geekos/trap.c
index 2085a99..f1bbf28 100644 (file)
--- 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 <daveho@cs.umd.edu>
- * $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 <geekos/defs.h>
 #include <geekos/trap.h>
 #include <geekos/serial.h>
-
+#include <geekos/debug.h>
 /*
  * 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 (file)
--- 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 <daveho@cs.umd.edu>
- * $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 <geekos/tss.h>
 
 #include <geekos/serial.h>
+#include <geekos/debug.h>
+
 
 /*
  * 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 (file)
--- 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 (file)
--- 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 (file)
--- a/palacios/src/geekos/vmm.c
+++ b/palacios/src/geekos/vmm.c
@@ -2,22 +2,31 @@
 #include <geekos/svm.h>
 #include <geekos/vmx.h>
 
+
 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 (file)
index 0000000..2583c39
--- /dev/null
+++ b/palacios/src/geekos/vmm_util.c
@@ -0,0 +1,33 @@
+#include <geekos/vmm_util.h>
+
+
+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<n;i+=16) {
+    PrintTrace("%8x", (unsigned)(start+i));
+    for (j=i; j<i+16 && j<n; j+=2) {
+      PrintTrace(" ");
+      PrintTraceHex(*((unsigned char *)(start+j)));
+      if ((j+1)<n) { 
+       PrintTraceHex(*((unsigned char *)(start+j+1)));
+      }
+    }
+    PrintTrace(" ");
+    for (j=i; j<i+16 && j<n;j++) {
+      PrintTrace("%c", ((start[j]>=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 (file)
--- a/palacios/src/geekos/vmx.c
+++ b/palacios/src/geekos/vmx.c
@@ -1,15 +1,18 @@
-#include <geekos/vmx.h>
-#include <geekos/vmcs.h>
+/* Eventually  we want to get rid of these */
 #include <geekos/mem.h>
-#include <geekos/serial.h>
 #include <geekos/segment.h>
 #include <geekos/gdt.h>
 #include <geekos/idt.h>
-
-
 #include <geekos/cpu.h>
 #include <geekos/io_devs.h>
+/* ** */
 
+#include <geekos/vmx.h>
+#include <geekos/vmcs.h>
+#include <geekos/vmm.h>
+#include <geekos/vmm_util.h>
+#include <geekos/string.h>
+#include <geekos/io.h>
 
 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;
 }