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.


Fix for option processing
[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_INT } 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     union {
52         uint32_t val;
53         
54         struct {
55             uint32_t lock   : 1;  // 0xF0
56             uint32_t repne  : 1;  // 0xF2
57             uint32_t repnz  : 1;  // 0xF2
58             uint32_t rep    : 1;  // 0xF3
59             uint32_t repe   : 1;  // 0xF3
60             uint32_t repz   : 1;  // 0xF3
61             uint32_t cs_override : 1;  // 0x2E
62             uint32_t ss_override : 1;  // 0x36
63             uint32_t ds_override : 1;  // 0x3E
64             uint32_t es_override : 1;  // 0x26
65             uint32_t fs_override : 1;  // 0x64
66             uint32_t gs_override : 1;  // 0x65
67             uint32_t br_not_taken : 1;  // 0x2E
68             uint32_t br_taken   : 1;  // 0x3E
69             uint32_t op_size     : 1;  // 0x66
70             uint32_t addr_size   : 1;  // 0x67
71
72             uint32_t rex   : 1;
73     
74             uint32_t rex_rm        : 1;  // REX.B
75             uint32_t rex_sib_idx   : 1;  // REX.X
76             uint32_t rex_reg       : 1;  // REX.R
77             uint32_t rex_op_size   : 1;  // REX.W
78
79             uint32_t rsvd          : 11;
80         } __attribute__((packed));
81     } __attribute__((packed));
82 } __attribute__((packed));
83
84
85 struct x86_instr {
86     struct x86_prefixes prefixes;
87     uint8_t instr_length;
88     v3_op_type_t op_type;
89     uint_t num_operands;
90     struct x86_operand dst_operand;
91     struct x86_operand src_operand;
92     struct x86_operand third_operand;
93     addr_t str_op_length;
94     addr_t is_str_op;
95 };
96
97
98 /************************/
99 /* EXTERNAL DECODER API */
100 /************************/
101 /* 
102    This is an External API definition that must be implemented by a decoder
103 */
104
105
106 /* 
107  * Initializes a decoder
108  */
109 int v3_init_decoder(struct guest_info * core);
110 int v3_deinit_decoder(struct guest_info * core);
111
112 /* 
113  * Decodes an instruction 
114  * All addresses in arguments are in the host address space
115  * instr_ptr is the host address of the instruction 
116  * IMPORTANT: make sure the instr_ptr is in contiguous host memory
117  *   ie. Copy it to a buffer before the call
118  */
119 int v3_decode(struct guest_info * info, addr_t instr_ptr, struct x86_instr * instr);
120
121 /* 
122  * Encodes an instruction
123  * All addresses in arguments are in the host address space
124  * The instruction is encoded from the struct, and copied into a 15 byte host buffer
125  * referenced by instr_buf
126  * any unused bytes at the end of instr_buf will be filled with nops
127  * IMPORTANT: instr_buf must be allocated and 15 bytes long
128  */
129 int v3_encode(struct guest_info * info, struct x86_instr * instr, uint8_t * instr_buf);
130
131
132
133 /* Removes a rep prefix in place */
134 void v3_strip_rep_prefix(uint8_t * instr, int length);
135 uint8_t v3_get_prefixes(uint8_t * instr, struct x86_prefixes * prefixes);
136
137
138 void v3_print_instr(struct x86_instr * instr);
139
140
141 #define PREFIX_LOCK         0xF0
142 #define PREFIX_REPNE        0xF2
143 #define PREFIX_REPNZ        0xF2
144 #define PREFIX_REP          0xF3
145 #define PREFIX_REPE         0xF3
146 #define PREFIX_REPZ         0xF3
147 #define PREFIX_CS_OVERRIDE  0x2E
148 #define PREFIX_SS_OVERRIDE  0x36
149 #define PREFIX_DS_OVERRIDE  0x3E
150 #define PREFIX_ES_OVERRIDE  0x26
151 #define PREFIX_FS_OVERRIDE  0x64
152 #define PREFIX_GS_OVERRIDE  0x65
153 #define PREFIX_BR_NOT_TAKEN 0x2E
154 #define PREFIX_BR_TAKEN     0x3E
155 #define PREFIX_OP_SIZE      0x66
156 #define PREFIX_ADDR_SIZE    0x67
157
158
159
160
161 static inline int is_prefix_byte(uchar_t byte) {
162     switch (byte) {
163         case 0xF0:      // lock
164         case 0xF2:      // REPNE/REPNZ
165         case 0xF3:      // REP or REPE/REPZ
166         case 0x2E:      // CS override or Branch hint not taken (with Jcc instrs)
167         case 0x36:      // SS override
168         case 0x3E:      // DS override or Branch hint taken (with Jcc instrs)
169         case 0x26:      // ES override
170         case 0x64:      // FS override
171         case 0x65:      // GS override
172             //case 0x2E:      // branch not taken hint
173             //  case 0x3E:      // branch taken hint
174         case 0x66:      // operand size override
175         case 0x67:      // address size override
176             return 1;
177             break;
178         default:
179             return 0;
180             break;
181     }
182 }
183
184
185 static inline v3_reg_t get_gpr_mask(struct guest_info * info) {
186     switch (info->cpu_mode) {
187         case REAL: 
188         case LONG_16_COMPAT:
189             return 0xffff;
190             break;
191         case PROTECTED:
192         case LONG_32_COMPAT:
193         case PROTECTED_PAE:
194             return 0xffffffff;
195         case LONG:
196             return 0xffffffffffffffffLL;
197         default:
198             PrintError(info->vm_info, info, "Unsupported Address Mode\n");
199             return -1;
200     }
201 }
202
203
204
205 static inline addr_t get_addr_linear(struct guest_info * info, addr_t addr, struct v3_segment * seg) {
206     switch (info->cpu_mode) {
207         case REAL: {
208             return ((seg->selector & 0xffff) << 4) + (addr & 0xffff);
209             break;
210         }
211         case PROTECTED:
212         case PROTECTED_PAE:
213         case LONG_32_COMPAT:
214             return addr + seg->base;
215             break;
216
217         case LONG: {
218             uint64_t seg_base = 0;
219
220             // In long mode the segment bases are disregarded (forced to 0), unless using 
221             // FS or GS, then the base addresses are added
222
223             if (seg) {
224                 seg_base = seg->base;
225             }
226
227             return addr + seg_base;
228         }
229         case LONG_16_COMPAT:
230         default:
231           PrintError(info->vm_info, info,"Unsupported CPU Mode: %d\n", info->cpu_mode);
232             return -1;
233     }
234 }
235
236
237
238 #endif // !__V3VEE__
239
240
241 #endif