Palacios Public Git Repository

To checkout Palacios execute 

  git clone http://v3vee.org/palacios/palacios.web/palacios.git
This will give you the master branch. You probably want the devel branch or one of the release branches. To switch to the devel branch, simply execute 
  cd palacios
  git checkout --track -b devel origin/devel
The other branches are similar.

projects / palacios.git / blobdiff
? search: re
summary | shortlog | log | commit | commitdiff | tree
raw
fix merge
[palacios.git] / palacios / include / palacios / vmm_instr_decoder.h
diff --git a/palacios/include/palacios/vmm_instr_decoder.h b/palacios/include/palacios/vmm_instr_decoder.h
index f36a738..d690af9 100644 (file)
--- a/palacios/include/palacios/vmm_instr_decoder.h
+++ b/palacios/include/palacios/vmm_instr_decoder.h
@@ -28,6 +28,7 @@ typedef enum {
     SMSW,
     CLTS,
     INVLPG,
+    INT, // KCH: adding software interrupts
 
     MOV_CR2,
     MOV_2CR,
@@ -261,6 +262,8 @@ static int get_operand_width(struct guest_info * info, struct x86_instr * instr,
                case LONG:
                    if (instr->prefixes.rex_op_size) {
                        return 8;
+                   } else {
+                       return 4;
                    }
                case PROTECTED:
                case PROTECTED_PAE:
@@ -308,6 +311,7 @@ static int get_operand_width(struct guest_info * info, struct x86_instr * instr,
                    return -1;
            }
 
+    case INT: // KCH
        case MOV_DR2:
        case MOV_2DR:
        case MOV_CR2:
@@ -333,6 +337,7 @@ static int get_operand_width(struct guest_info * info, struct x86_instr * instr,
            return -1;
        
     }
+
     return 0;
 }
 
@@ -473,24 +478,6 @@ static inline int decode_cr(struct guest_info * core,
     return 0;
 }
 
-// This converts the displacement into the appropriate masked value
-/* 
-   QUESTION: Are the register Values signed ?????
- */
-#define MASK_DISPLACEMENT(reg, mode) ({                                        \
-           sint64_t val = 0;                                           \
-           if (mode == DISP8) {                                        \
-               val = (sint8_t)(reg & 0xff);                            \
-           } else if (mode == DISP16) {                                \
-               val = (sint16_t)(reg & 0xffff);                         \
-           } else if (mode == DISP32) {                                \
-               val = (sint32_t)(reg & 0xffffffff);                     \
-           } else {                                                    \
-               PrintError("Error invalid displacement size (%d)\n", mode); \
-               /*V3_ASSERT(0);*/                                       \
-           }                                                           \
-           val;                                                        \
-       })
 
 
 #define ADDR_MASK(val, length) ({                            \
@@ -546,37 +533,41 @@ static  int decode_rm_operand16(struct guest_info * core,
            mod_mode = DISP8;
        } else if (modrm->mod == 2) {
            mod_mode = DISP16;
+       } else {
+           PrintError("Instruction format error: Invalid mod_rm mode (%d)\n", modrm->mod);
+           v3_print_instr(instr);
+           return -1;
        }
 
        switch (modrm->rm) {
            case 0:
-               base_addr = gprs->rbx + MASK_DISPLACEMENT(gprs->rsi, mod_mode);
+               base_addr = gprs->rbx + ADDR_MASK(gprs->rsi, 2);
                break;
            case 1:
-               base_addr = gprs->rbx + MASK_DISPLACEMENT(gprs->rdi, mod_mode);
+               base_addr = gprs->rbx + ADDR_MASK(gprs->rdi, 2);
                break;
            case 2:
-               base_addr = gprs->rbp + MASK_DISPLACEMENT(gprs->rsi, mod_mode);
+               base_addr = gprs->rbp + ADDR_MASK(gprs->rsi, 2);
                break;
            case 3:
-               base_addr = gprs->rbp + MASK_DISPLACEMENT(gprs->rdi, mod_mode);
+               base_addr = gprs->rbp + ADDR_MASK(gprs->rdi, 2);
                break;
            case 4:
-               base_addr = gprs->rsi;
+               base_addr = ADDR_MASK(gprs->rsi, 2);
                break;
            case 5:
-               base_addr = gprs->rdi;
+               base_addr = ADDR_MASK(gprs->rdi, 2);
                break;
            case 6:
                if (modrm->mod == 0) {
                    base_addr = 0;
                    mod_mode = DISP16;
                } else {
-                   base_addr = gprs->rbp;
+                   base_addr = ADDR_MASK(gprs->rbp, 2);
                }
                break;
            case 7:
-               base_addr = gprs->rbx;
+               base_addr = ADDR_MASK(gprs->rbx, 2);
                break;
        }
 
@@ -651,6 +642,10 @@ static int decode_rm_operand32(struct guest_info * core,
            mod_mode = DISP8;
        } else if (modrm->mod == 2) {
            mod_mode = DISP32;
+       } else {
+           PrintError("Instruction format error: Invalid mod_rm mode (%d)\n", modrm->mod);
+           v3_print_instr(instr);
+           return -1;
        }
     
        switch (modrm->rm) {
@@ -724,30 +719,30 @@ static int decode_rm_operand32(struct guest_info * core,
 
            switch (sib->base) {
                case 0:
-                   base_addr += MASK_DISPLACEMENT(gprs->rax, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rax, 4);
                    break;
                case 1:
-                   base_addr += MASK_DISPLACEMENT(gprs->rcx, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rcx, 4);
                    break;
                case 2:
-                   base_addr += MASK_DISPLACEMENT(gprs->rdx, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rdx, 4);
                    break;
                case 3:
-                   base_addr += MASK_DISPLACEMENT(gprs->rbx, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rbx, 4);
                    break;
                case 4:
-                   base_addr += MASK_DISPLACEMENT(gprs->rsp, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rsp, 4);
                    break;
                case 5:
                    if (modrm->mod != 0) {
-                       base_addr += MASK_DISPLACEMENT(gprs->rbp, mod_mode);
+                       base_addr += ADDR_MASK(gprs->rbp, 4);
                    }
                    break;
                case 6:
-                   base_addr += MASK_DISPLACEMENT(gprs->rsi, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rsi, 4);
                    break;
                case 7:
-                   base_addr += MASK_DISPLACEMENT(gprs->rdi, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rdi, 4);
                    break;
            }
 
@@ -825,6 +820,10 @@ int decode_rm_operand64(struct guest_info * core, uint8_t * modrm_instr,
            mod_mode = DISP8;
        } else if (modrm->mod == 2) {
            mod_mode = DISP32;
+       } else {
+           PrintError("Instruction format error: Invalid mod_rm mode (%d)\n", modrm->mod);
+           v3_print_instr(instr);
+           return -1;
        }
     
        if (rm_val == 4) {
@@ -956,54 +955,54 @@ int decode_rm_operand64(struct guest_info * core, uint8_t * modrm_instr,
 
            switch (base_val) {
                case 0:
-                   base_addr += MASK_DISPLACEMENT(gprs->rax, mod_mode);
+                   base_addr += gprs->rax;
                    break;
                case 1:
-                   base_addr += MASK_DISPLACEMENT(gprs->rcx, mod_mode);
+                   base_addr += gprs->rcx;
                    break;
                case 2:
-                   base_addr += MASK_DISPLACEMENT(gprs->rdx, mod_mode);
+                   base_addr += gprs->rdx;
                    break;
                case 3:
-                   base_addr += MASK_DISPLACEMENT(gprs->rbx, mod_mode);
+                   base_addr += gprs->rbx;
                    break;
                case 4:
-                   base_addr += MASK_DISPLACEMENT(gprs->rsp, mod_mode);
+                   base_addr += gprs->rsp;
                    break;
                case 5:
                    if (modrm->mod != 0) {
-                       base_addr += MASK_DISPLACEMENT(gprs->rbp, mod_mode);
+                       base_addr += gprs->rbp;
                    }
                    break;
                case 6:
-                   base_addr += MASK_DISPLACEMENT(gprs->rsi, mod_mode);
+                   base_addr += gprs->rsi;
                    break;
                case 7:
-                   base_addr += MASK_DISPLACEMENT(gprs->rdi, mod_mode);
+                   base_addr += gprs->rdi;
                    break;
                case 8:
-                   base_addr += MASK_DISPLACEMENT(gprs->r8, mod_mode);
+                   base_addr += gprs->r8;
                    break;
                case 9:
-                   base_addr += MASK_DISPLACEMENT(gprs->r9, mod_mode);
+                   base_addr += gprs->r9;
                    break;
                case 10:
-                   base_addr += MASK_DISPLACEMENT(gprs->r10, mod_mode);
+                   base_addr += gprs->r10;
                    break;
                case 11:
-                   base_addr += MASK_DISPLACEMENT(gprs->r11, mod_mode);
+                   base_addr += gprs->r11;
                    break;
                case 12:
-                   base_addr += MASK_DISPLACEMENT(gprs->r12, mod_mode);
+                   base_addr += gprs->r12;
                    break;
                case 13:
-                   base_addr += MASK_DISPLACEMENT(gprs->r13, mod_mode);
+                   base_addr += gprs->r13;
                    break;
                case 14:
-                   base_addr += MASK_DISPLACEMENT(gprs->r14, mod_mode);
+                   base_addr += gprs->r14;
                    break;
                case 15:
-                   base_addr += MASK_DISPLACEMENT(gprs->r15, mod_mode);
+                   base_addr += gprs->r15;
                    break;
            }
 
@@ -1333,7 +1332,10 @@ static op_form_t op_code_to_form(uint8_t * instr, int * length) {
 
        case 0xf4:
            return HLT;
-
+    
+    // KCH
+    case 0xcd:
+        return INT;
 
        case 0xf6: {
            struct modrm_byte * modrm = (struct modrm_byte *)&(instr[1]);
@@ -1496,6 +1498,7 @@ static char * op_form_to_str(op_form_t form) {
        case SETO: return "SETO";
        case STOS_8: return "STOS_8";
        case STOS: return "STOS";
+    case INT: return "INT"; // KCH
 
        case INVALID_INSTR:
        default:
Public Palacios Development Repository for the V3VEE Project