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.


removed obsolete telemetry fn
[palacios.git] / palacios / include / palacios / vmm_decoder.h
1 /*
2  * This file is part of the Palacios Virtual Machine Monitor developed
3  * by the V3VEE Project with funding from the United States National 
4  * Science Foundation and the Department of Energy.  
5  *
6  * The V3VEE Project is a joint project between Northwestern University
7  * and the University of New Mexico.  You can find out more at 
8  * http://www.v3vee.org
9  *
10  * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu> 
11  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org> 
12  * All rights reserved.
13  *
14  * Author: Jack Lange <jarusl@cs.northwestern.edu>
15  *
16  * This is free software.  You are permitted to use,
17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
18  */
19
20 #ifndef __VMM_DECODER_H
21 #define __VMM_DECODER_H
22
23 #ifdef __V3VEE__
24
25 #include <palacios/vm_guest.h>
26 #include <palacios/vmm.h>
27
28
29 typedef enum { V3_INVALID_OP,
30                V3_OP_MOVCR2, V3_OP_MOV2CR, V3_OP_SMSW, V3_OP_LMSW, V3_OP_CLTS,
31                V3_OP_INVLPG,
32                V3_OP_ADC, V3_OP_ADD, V3_OP_AND, V3_OP_OR, V3_OP_XOR, V3_OP_SUB,
33                V3_OP_INC, V3_OP_DEC, V3_OP_NEG, V3_OP_MOV, V3_OP_NOT, V3_OP_XCHG, 
34                V3_OP_SETB, V3_OP_SETBE, V3_OP_SETL, V3_OP_SETLE, V3_OP_SETNB, 
35                V3_OP_SETNBE, V3_OP_SETNL, V3_OP_SETNLE, V3_OP_SETNO, V3_OP_SETNP,
36                V3_OP_SETNS, V3_OP_SETNZ, V3_OP_SETO, V3_OP_SETP, V3_OP_SETS, 
37                V3_OP_SETZ, V3_OP_MOVS, V3_OP_STOS, V3_OP_MOVZX, V3_OP_MOVSX } v3_op_type_t;
38
39
40 typedef enum {INVALID_OPERAND, REG_OPERAND, MEM_OPERAND, IMM_OPERAND} v3_operand_type_t;
41
42 struct x86_operand {
43     addr_t operand;
44     uint_t size;
45     v3_operand_type_t type;
46     uint8_t read : 1;   // This operand value will be read by the instruction
47     uint8_t write : 1;  // This operand value will be written to by the instruction
48 } __attribute__((packed));
49
50 struct x86_prefixes {
51     uint_t lock   : 1;  // 0xF0
52     uint_t repne  : 1;  // 0xF2
53     uint_t repnz  : 1;  // 0xF2
54     uint_t rep    : 1;  // 0xF3
55     uint_t repe   : 1;  // 0xF3
56     uint_t repz   : 1;  // 0xF3
57     uint_t cs_override : 1;  // 0x2E
58     uint_t ss_override : 1;  // 0x36
59     uint_t ds_override : 1;  // 0x3E
60     uint_t es_override : 1;  // 0x26
61     uint_t fs_override : 1;  // 0x64
62     uint_t gs_override : 1;  // 0x65
63     uint_t br_not_taken : 1;  // 0x2E
64     uint_t br_taken   : 1;  // 0x3E
65     uint_t op_size     : 1;  // 0x66
66     uint_t addr_size   : 1;  // 0x67
67
68     uint_t rex   : 1;
69     
70     uint_t rex_rm        : 1;  // REX.B
71     uint_t rex_sib_idx   : 1;  // REX.X
72     uint_t rex_reg       : 1;  // REX.R
73     uint_t rex_op_size   : 1;  // REX.W
74
75 } __attribute__((packed));
76
77
78 struct x86_instr {
79     struct x86_prefixes prefixes;
80     uint8_t instr_length;
81     v3_op_type_t op_type;
82     uint_t num_operands;
83     struct x86_operand dst_operand;
84     struct x86_operand src_operand;
85     struct x86_operand third_operand;
86     addr_t str_op_length;
87     addr_t is_str_op;
88 };
89
90
91 /************************/
92 /* EXTERNAL DECODER API */
93 /************************/
94 /* 
95    This is an External API definition that must be implemented by a decoder
96 */
97
98
99 /* 
100  * Initializes a decoder
101  */
102 int v3_init_decoder(struct guest_info * core);
103 int v3_deinit_decoder(struct guest_info * core);
104
105 /* 
106  * Decodes an instruction 
107  * All addresses in arguments are in the host address space
108  * instr_ptr is the host address of the instruction 
109  * IMPORTANT: make sure the instr_ptr is in contiguous host memory
110  *   ie. Copy it to a buffer before the call
111  */
112 int v3_decode(struct guest_info * info, addr_t instr_ptr, struct x86_instr * instr);
113
114 /* 
115  * Encodes an instruction
116  * All addresses in arguments are in the host address space
117  * The instruction is encoded from the struct, and copied into a 15 byte host buffer
118  * referenced by instr_buf
119  * any unused bytes at the end of instr_buf will be filled with nops
120  * IMPORTANT: instr_buf must be allocated and 15 bytes long
121  */
122 int v3_encode(struct guest_info * info, struct x86_instr * instr, uint8_t * instr_buf);
123
124
125
126 /* Removes a rep prefix in place */
127 void v3_strip_rep_prefix(uint8_t * instr, int length);
128 uint8_t v3_get_prefixes(uint8_t * instr, struct x86_prefixes * prefixes);
129
130
131 void v3_print_instr(struct x86_instr * instr);
132
133
134 #define PREFIX_LOCK         0xF0
135 #define PREFIX_REPNE        0xF2
136 #define PREFIX_REPNZ        0xF2
137 #define PREFIX_REP          0xF3
138 #define PREFIX_REPE         0xF3
139 #define PREFIX_REPZ         0xF3
140 #define PREFIX_CS_OVERRIDE  0x2E
141 #define PREFIX_SS_OVERRIDE  0x36
142 #define PREFIX_DS_OVERRIDE  0x3E
143 #define PREFIX_ES_OVERRIDE  0x26
144 #define PREFIX_FS_OVERRIDE  0x64
145 #define PREFIX_GS_OVERRIDE  0x65
146 #define PREFIX_BR_NOT_TAKEN 0x2E
147 #define PREFIX_BR_TAKEN     0x3E
148 #define PREFIX_OP_SIZE      0x66
149 #define PREFIX_ADDR_SIZE    0x67
150
151
152
153
154 static inline int is_prefix_byte(uchar_t byte) {
155     switch (byte) {
156         case 0xF0:      // lock
157         case 0xF2:      // REPNE/REPNZ
158         case 0xF3:      // REP or REPE/REPZ
159         case 0x2E:      // CS override or Branch hint not taken (with Jcc instrs)
160         case 0x36:      // SS override
161         case 0x3E:      // DS override or Branch hint taken (with Jcc instrs)
162         case 0x26:      // ES override
163         case 0x64:      // FS override
164         case 0x65:      // GS override
165             //case 0x2E:      // branch not taken hint
166             //  case 0x3E:      // branch taken hint
167         case 0x66:      // operand size override
168         case 0x67:      // address size override
169             return 1;
170             break;
171         default:
172             return 0;
173             break;
174     }
175 }
176
177
178 static inline v3_reg_t get_gpr_mask(struct guest_info * info) {
179     switch (info->cpu_mode) {
180         case REAL: 
181         case LONG_16_COMPAT:
182             return 0xffff;
183             break;
184         case PROTECTED:
185         case LONG_32_COMPAT:
186         case PROTECTED_PAE:
187             return 0xffffffff;
188         case LONG:
189             return 0xffffffffffffffffLL;
190         default:
191             PrintError("Unsupported Address Mode\n");
192             return -1;
193     }
194 }
195
196
197
198 static inline addr_t get_addr_linear(struct guest_info * info, addr_t addr, struct v3_segment * seg) {
199     switch (info->cpu_mode) {
200         case REAL:
201             // It appears that the segment values are computed and cached in the vmcb structure 
202             // We Need to check this for Intel
203             /*   return addr + (seg->selector << 4);
204                  break;*/
205
206         case PROTECTED:
207         case PROTECTED_PAE:
208         case LONG_32_COMPAT:
209             return addr + seg->base;
210             break;
211
212         case LONG:
213             // In long mode the segment bases are disregarded (forced to 0), unless using 
214             // FS or GS, then the base addresses are added
215             return addr + seg->base;
216
217         case LONG_16_COMPAT:
218         default:
219             PrintError("Unsupported CPU Mode: %d\n", info->cpu_mode);
220             return -1;
221     }
222 }
223
224
225
226 #endif // !__V3VEE__
227
228
229 #endif