added 32 bit operand support

diff --git a/palacios/include/geekos/vmcs.h b/palacios/include/geekos/vmcs.h
index b6d7027..f73ec3d 100644 (file)
--- a/palacios/include/geekos/vmcs.h
+++ b/palacios/include/geekos/vmcs.h
@@ -350,10 +350,9 @@ union SegAccess {
 
 struct VMCSSegment {
   ushort_t selector   ; 
-  uint_t baseAddr     ; // should be 64 bits?
+  union SegAccess access;
   uint_t limit        ; 
-  union SegAccess access       ;
-
+  uint_t baseAddr     ; // should be 64 bits?
 };
 
 

diff --git a/palacios/include/geekos/vmm_emulate.h b/palacios/include/geekos/vmm_emulate.h
index e82777c..6a6c144 100644 (file)
--- a/palacios/include/geekos/vmm_emulate.h
+++ b/palacios/include/geekos/vmm_emulate.h
@@ -46,7 +46,7 @@
 
 #define MODRM_MOD(x) ((x >> 6) & 0x3)
 #define MODRM_REG(x) ((x >> 3) & 0x7)
-#define MODRM_RM(x)  (x & 0x07)
+#define MODRM_RM(x)  (x & 0x7)
 
 struct modrm_byte {
   uint_t rm   :   3 PACKED;
@@ -55,6 +55,10 @@ struct modrm_byte {
 };
 
 
+#define SIB_BASE(x) ((x >> 6) & 0x3)
+#define SIB_INDEX(x) ((x >> 3) & 0x7)
+#define SIB_SCALE(x) (x & 0x7)
+
 struct sib_byte {
   uint_t base     :   3 PACKED;
   uint_t index    :   3 PACKED;
@@ -127,168 +131,305 @@ static inline int is_prefix_byte(char byte) {
   }
 }
 
-typedef enum {INVALID_ADDR_TYPE, REG, DISP0, DISP8, DISP16, DISP32} modrm_addr_type_t;
+typedef enum {INVALID_ADDR_TYPE, REG, DISP0, DISP8, DISP16, DISP32} modrm_mode_t;
 typedef enum {INVALID_REG_SIZE, REG64, REG32, REG16, REG8} reg_size_t;
-typedef enum {INVALID_OPERAND_TYPE, REG_TO_REG, REG_TO_MEM, MEM_TO_REG} operand_type_t;
+typedef enum {INVALID_OPERAND, REG_OPERAND, MEM_OPERAND} operand_type_t;
 
 struct guest_gprs;
 
+static inline addr_t decode_register(struct guest_gprs * gprs, char reg_code, reg_size_t reg_size) {
+  addr_t reg_addr;
 
-static inline int decode_operands16(struct guest_gprs * gprs, 
-                                   char * modrm_instr, 
-                                   addr_t * first_operand,
-                                   addr_t * second_operand, 
-                                   reg_size_t reg_size) {
+  switch (reg_code) {
+  case 0:
+    reg_addr = (addr_t)&(gprs->rax);
+    break;
+  case 1:
+    reg_addr = (addr_t)&(gprs->rcx);
+    break;
+  case 2:
+    reg_addr = (addr_t)&(gprs->rdx);
+    break;
+  case 3:
+    reg_addr = (addr_t)&(gprs->rbx);
+    break;
+  case 4:
+    if (reg_size == REG8) {
+      reg_addr = (addr_t)&(gprs->rax) + 1;
+    } else {
+      reg_addr = (addr_t)&(gprs->rsp);
+    }
+    break;
+  case 5:
+    if (reg_size == REG8) {
+      reg_addr = (addr_t)&(gprs->rcx) + 1;
+    } else {
+      reg_addr = (addr_t)&(gprs->rbp);
+    }
+    break;
+  case 6:
+    if (reg_size == REG8) {
+      reg_addr = (addr_t)&(gprs->rdx) + 1;
+    } else {
+      reg_addr = (addr_t)&(gprs->rsi);
+    }
+    break;
+  case 7:
+    if (reg_size == REG8) {
+      reg_addr = (addr_t)&(gprs->rbx) + 1;
+    } else {
+      reg_addr = (addr_t)&(gprs->rdi);
+    }
+    break;
+  default:
+    reg_addr = 0;
+    break;
+  }
+
+  return reg_addr;
+}
+
+
+
+static inline operand_type_t decode_operands16(struct guest_gprs * gprs, 
+                                              char * modrm_instr, 
+                                              addr_t * first_operand,
+                                              addr_t * second_operand, 
+                                              reg_size_t reg_size) {
   
-  struct modrm_byte * modrm = (struct modrm_byte*)modrm_instr;
+  struct modrm_byte * modrm = (struct modrm_byte *)modrm_instr;
   addr_t base_addr = 0;
-  modrm_addr_type_t mod_type = 0;
+  modrm_mode_t mod_mode = 0;
+  operand_type_t addr_type = INVALID_OPERAND;
 
   PrintDebug("ModRM mod=%d\n", modrm->mod);
 
   if (modrm->mod == 3) {
-    mod_type = REG;
-
+    mod_mode = REG;
+    addr_type = REG_OPERAND;
     PrintDebug("first operand = Register (RM=%d)\n",modrm->rm);
 
-    switch (modrm->rm) {
-    case 0:
-      PrintDebug("EAX Operand\n");
-      *first_operand = (addr_t)&(gprs->rax);
-      break;
-    case 1:
-      *first_operand = (addr_t)&(gprs->rcx);
-      break;
-    case 2:
-      *first_operand = (addr_t)&(gprs->rdx);
-      break;
-    case 3:
-      *first_operand = (addr_t)&(gprs->rbx);
-      break;
-    case 4:
-      if (reg_size == REG8) {
-       *first_operand = (addr_t)(&(gprs->rax) + 1);
-      } else {
-       *first_operand = (addr_t)&(gprs->rsp);
-      }
-      break;
-    case 5:
-      if (reg_size == REG8) {
-       *first_operand = (addr_t)(&(gprs->rcx) + 1);
-      } else {
-       *first_operand = (addr_t)&(gprs->rbp);
-      }
-      break;
-    case 6:
-      if (reg_size == REG8) {
-       *first_operand = (addr_t)(&(gprs->rdx) + 1);
-      } else {
-       *first_operand = (addr_t)&(gprs->rsi);
-      }
-      break;
-    case 7:
-      if (reg_size == REG8) {
-       *first_operand = (addr_t)(&(gprs->rbx) + 1);
-      } else {
-       *first_operand = (addr_t)&(gprs->rdi);
-      }
-      break;
-    }
+    *first_operand = decode_register(gprs, modrm->rm, reg_size);
 
   } else {
+
+    addr_type = MEM_OPERAND;
+
     if (modrm->mod == 0) {
-      mod_type = DISP0;
+      mod_mode = DISP0;
     } else if (modrm->mod == 1) {
-      mod_type = DISP8;
+      mod_mode = DISP8;
     } else if (modrm->mod == 2) {
-      mod_type = DISP16;
+      mod_mode = DISP16;
     }
 
     switch (modrm->rm) {
     case 0:
       base_addr = gprs->rbx + gprs->rsi;
+      break;
     case 1:
       base_addr = gprs->rbx + gprs->rdi;
+      break;
     case 2:
       base_addr = gprs->rbp + gprs->rsi;
+      break;
     case 3:
       base_addr = gprs->rbp + gprs->rdi;
+      break;
     case 4:
       base_addr = gprs->rsi;
+      break;
     case 5:
       base_addr = gprs->rdi;
+      break;
     case 6:
       if (modrm->mod == 0) {
        base_addr = 0;
-       mod_type = DISP16;
+       mod_mode = DISP16;
       } else {
        base_addr = gprs->rbp;
       }
+      break;
     case 7:
       base_addr = gprs->rbx;
+      break;
     }
 
-    if (mod_type == DISP8) {
+    if (mod_mode == DISP8) {
       base_addr += (uchar_t)*(modrm_instr + 1);
-    } else if (mod_type == DISP16) {
+    } else if (mod_mode == DISP16) {
       base_addr += (ushort_t)*(modrm_instr + 1);
     }
     
-    
     *first_operand = base_addr;
   }
 
+  *second_operand = decode_register(gprs, modrm->reg, reg_size);
+
+  return addr_type;
+}
+
 
 
-  switch (modrm->reg) {
+static inline operand_type_t decode_operands32(struct guest_gprs * gprs, 
+                                   char * modrm_instr,
+                                   addr_t * first_operand,
+                                   addr_t * second_operand, 
+                                   reg_size_t reg_size) {
+
+  char * instr_cursor = modrm_instr;
+  struct modrm_byte * modrm = (struct modrm_byte *)modrm_instr;
+  addr_t base_addr = 0;
+  modrm_mode_t mod_mode = 0;
+  uint_t has_sib_byte = 0;
+  operand_type_t addr_type = INVALID_OPERAND;
+
+  if (modrm->mod == 3) {
+    mod_mode = REG;
+    addr_type = REG_OPERAND;
+    
+    PrintDebug("first operand = Register (RM=%d)\n",modrm->rm);
+
+    *first_operand = decode_register(gprs, modrm->rm, reg_size);
+
+  } else {
+
+    addr_type = MEM_OPERAND;
+
+    if (modrm->mod == 0) {
+      mod_mode = DISP0;
+    } else if (modrm->mod == 1) {
+      mod_mode = DISP8;
+    } else if (modrm->mod == 2) {
+      mod_mode = DISP32;
+    }
+    
+    switch (modrm->rm) {
     case 0:
-      *second_operand = (addr_t)&(gprs->rax);
+      base_addr = gprs->rax;
       break;
     case 1:
-      *second_operand = (addr_t)&(gprs->rcx);
+      base_addr = gprs->rcx;
       break;
     case 2:
-      *second_operand = (addr_t)&(gprs->rdx);
+      base_addr = gprs->rdx;
       break;
     case 3:
-      *second_operand = (addr_t)&(gprs->rbx);
+      base_addr = gprs->rbx;
       break;
     case 4:
-      if (reg_size == REG8) {
-       *second_operand = (addr_t)&(gprs->rax) + 1;
-      } else {
-       *second_operand = (addr_t)&(gprs->rsp);
-      }
+      has_sib_byte = 1;
       break;
     case 5:
-      if (reg_size == REG8) {
-       *second_operand = (addr_t)&(gprs->rcx) + 1;
+      if (modrm->mod == 0) {
+       base_addr = 0;
+       mod_mode = DISP32;
       } else {
-       *second_operand = (addr_t)&(gprs->rbp);
+       base_addr = gprs->rbp;
       }
       break;
     case 6:
-      if (reg_size == REG8) {
-       *second_operand = (addr_t)&(gprs->rdx) + 1;
-      } else {
-       *second_operand = (addr_t)&(gprs->rsi);
-      }
+      base_addr = gprs->rsi;
       break;
     case 7:
-      if (reg_size == REG8) {
-       *second_operand = (addr_t)&(gprs->rbx) + 1;
-      } else {
-       *second_operand = (addr_t)&(gprs->rdi);
-      }
+      base_addr = gprs->rdi;
       break;
+    }
+
+    if (has_sib_byte) {
+      instr_cursor += 1;
+      struct sib_byte * sib = (struct sib_byte *)(instr_cursor);
+      int scale = 1;
+
+
+      if (sib->scale == 1) {
+       scale = 2;
+      } else if (sib->scale == 2) {
+       scale = 4;
+      } else if (sib->scale == 3) {
+       scale = 8;
+      }
+
+
+      switch (sib->index) {
+      case 0:
+       base_addr = gprs->rax;
+       break;
+      case 1:
+       base_addr = gprs->rcx;
+       break;
+      case 2:
+       base_addr = gprs->rdx;
+       break;
+      case 3:
+       base_addr = gprs->rbx;
+       break;
+      case 4:
+       base_addr = 0;
+       break;
+      case 5:
+       base_addr = gprs->rbp;
+       break;
+      case 6:
+       base_addr = gprs->rsi;
+       break;
+      case 7:
+       base_addr = gprs->rdi;
+       break;
+      }
+
+      base_addr *= scale;
+
+
+      switch (sib->base) {
+      case 0:
+       base_addr += gprs->rax;
+       break;
+      case 1:
+       base_addr += gprs->rcx;
+       break;
+      case 2:
+       base_addr += gprs->rdx;
+       break;
+      case 3:
+       base_addr += gprs->rbx;
+       break;
+      case 4:
+       base_addr += gprs->rsp;
+       break;
+      case 5:
+       if (modrm->mod != 0) {
+         base_addr += gprs->rbp;
+       }
+       break;
+      case 6:
+       base_addr += gprs->rsi;
+       break;
+      case 7:
+       base_addr += gprs->rdi;
+       break;
+      }
+
+    } 
+
+    instr_cursor += 1;
+
+    if (mod_mode == DISP8) {
+      base_addr += (uchar_t)*(instr_cursor);
+    } else if (mod_mode == DISP32) {
+      base_addr += (uint_t)*(instr_cursor);
+    }
+    
+
+    *first_operand = base_addr;
   }
 
-  return 0;
+  *second_operand = decode_register(gprs, modrm->reg, reg_size);
 
+  return addr_type;
 }
 
 
 
 
-
 #endif

diff --git a/palacios/src/geekos/svm.c b/palacios/src/geekos/svm.c
index 8108ddb..7d012e4 100644 (file)
--- a/palacios/src/geekos/svm.c
+++ b/palacios/src/geekos/svm.c
@@ -111,7 +111,6 @@ int init_svm_guest(struct guest_info *info) {
   //info->page_tables = generate_guest_page_tables(&(info->mem_layout), &(info->mem_list));
   //PrintDebugPageTables(info->page_tables);
 
-  
 
   PrintDebug("Initializing VMCB (addr=%x)\n", info->vmm_data);
   Init_VMCB((vmcb_t*)(info->vmm_data), *info);
@@ -262,9 +261,6 @@ void Init_VMCB_Real(vmcb_t * vmcb, struct guest_info vm_info) {
       *bitmap |= 1 << (port % 8);
     }
 
-    //    memset((uchar_t*)io_port_bitmap, 0xff, PAGE_SIZE * 2);
-    //PrintDebugMemDump((uchar_t*)io_port_bitmap, PAGE_SIZE *2);
-
     ctrl_area->instrs.instrs.IOIO_PROT = 1;
   }
 

diff --git a/palacios/src/geekos/svm_ctrl_regs.c b/palacios/src/geekos/svm_ctrl_regs.c
index 3929222..1ae1ccf 100644 (file)
--- a/palacios/src/geekos/svm_ctrl_regs.c
+++ b/palacios/src/geekos/svm_ctrl_regs.c
@@ -13,8 +13,6 @@ int handle_cr0_write(struct guest_info * info) {
   char instr[15];
   
   
-
-
   if (info->cpu_mode == REAL) {
     int index = 0;
     int ret;
@@ -28,11 +26,8 @@ int handle_cr0_write(struct guest_info * info) {
     }
 
     while (is_prefix_byte(instr[index])) {
-      PrintDebug("instr(%d): 0x%x\n", index, instr[index]);
       index++; 
     }
-    PrintDebug("instr(%d): 0x%x\n", index, instr[index]);
-    PrintDebug("instr(%d): 0x%x\n", index+1, instr[index + 1]);
 
     if ((instr[index] == cr_access_byte) && 
        (instr[index + 1] == lmsw_byte) && 

diff --git a/palacios/src/geekos/vm_guest_mem.c b/palacios/src/geekos/vm_guest_mem.c
index 98ed0c3..364dde4 100644 (file)
--- a/palacios/src/geekos/vm_guest_mem.c
+++ b/palacios/src/geekos/vm_guest_mem.c
@@ -288,7 +288,7 @@ int read_guest_va_memory(struct guest_info * guest_info, addr_t guest_va, int co
     addr_t host_addr;
 
     if (guest_va_to_host_va(guest_info, cursor, &host_addr) != 0) {
-      return -1;
+      return bytes_read;
     }
 
     memcpy(dest + bytes_read, (void*)host_addr, bytes_to_copy);
@@ -298,7 +298,7 @@ int read_guest_va_memory(struct guest_info * guest_info, addr_t guest_va, int co
     cursor += bytes_to_copy;    
   }
 
-  return 0;
+  return bytes_read;
 }
 
 
@@ -319,7 +319,7 @@ int read_guest_pa_memory(struct guest_info * guest_info, addr_t guest_pa, int co
     addr_t host_addr;
 
     if (guest_pa_to_host_va(guest_info, cursor, &host_addr) != 0) {
-      return -1;
+      return bytes_read;
     }
 
     memcpy(dest + bytes_read, (void*)host_addr, bytes_to_copy);
@@ -329,7 +329,7 @@ int read_guest_pa_memory(struct guest_info * guest_info, addr_t guest_pa, int co
     cursor += bytes_to_copy;    
   }
 
-  return 0;
+  return bytes_read;
 }
 
 
@@ -348,7 +348,7 @@ int write_guest_pa_memory(struct guest_info * guest_info, addr_t guest_pa, int c
     addr_t host_addr;
 
     if (guest_pa_to_host_va(guest_info, cursor, &host_addr) != 0) {
-      return -1;
+      return bytes_written;
     }
 
     memcpy((void*)host_addr, src + bytes_written, bytes_to_copy);
@@ -358,6 +358,6 @@ int write_guest_pa_memory(struct guest_info * guest_info, addr_t guest_pa, int c
     cursor += bytes_to_copy;    
   }
 
-  return 0;
+  return bytes_written;
 }