Add the skeleton for vm support
[akaros.git] / kern / arch / x86 / vmdebug.h
1 /******************************************************************************
2  * x86_emulate.h
3  *
4  * Generic x86 (32-bit and 64-bit) instruction decoder and emulator.
5  *
6  * Copyright (c) 2005 Keir Fraser
7  *
8  * From: xen-unstable 10676:af9809f51f81a3c43f276f00c81a52ef558afda4
9  */
10
11 #ifndef __X86_EMULATE_H__
12 #define __X86_EMULATE_H__
13
14 struct x86_emulate_ctxt;
15
16 /*
17  * x86_emulate_ops:
18  *
19  * These operations represent the instruction emulator's interface to memory.
20  * There are two categories of operation: those that act on ordinary memory
21  * regions (*_std), and those that act on memory regions known to require
22  * special treatment or emulation (*_emulated).
23  *
24  * The emulator assumes that an instruction accesses only one 'emulated memory'
25  * location, that this location is the given linear faulting address (cr2), and
26  * that this is one of the instruction's data operands. Instruction fetches and
27  * stack operations are assumed never to access emulated memory. The emulator
28  * automatically deduces which operand of a string-move operation is accessing
29  * emulated memory, and assumes that the other operand accesses normal memory.
30  *
31  * NOTES:
32  *  1. The emulator isn't very smart about emulated vs. standard memory.
33  *     'Emulated memory' access addresses should be checked for sanity.
34  *     'Normal memory' accesses may fault, and the caller must arrange to
35  *     detect and handle reentrancy into the emulator via recursive faults.
36  *     Accesses may be unaligned and may cross page boundaries.
37  *  2. If the access fails (cannot emulate, or a standard access faults) then
38  *     it is up to the memop to propagate the fault to the guest VM via
39  *     some out-of-band mechanism, unknown to the emulator. The memop signals
40  *     failure by returning X86EMUL_PROPAGATE_FAULT to the emulator, which will
41  *     then immediately bail.
42  *  3. Valid access sizes are 1, 2, 4 and 8 bytes. On x86/32 systems only
43  *     cmpxchg8b_emulated need support 8-byte accesses.
44  *  4. The emulator cannot handle 64-bit mode emulation on an x86/32 system.
45  */
46 /* Access completed successfully: continue emulation as normal. */
47 #define X86EMUL_CONTINUE        0
48 /* Access is unhandleable: bail from emulation and return error to caller. */
49 #define X86EMUL_UNHANDLEABLE    1
50 /* Terminate emulation but return success to the caller. */
51 #define X86EMUL_PROPAGATE_FAULT 2 /* propagate a generated fault to guest */
52 #define X86EMUL_RETRY_INSTR     2 /* retry the instruction for some reason */
53 #define X86EMUL_CMPXCHG_FAILED  2 /* cmpxchg did not see expected value */
54 struct x86_emulate_ops {
55         /*
56          * read_std: Read bytes of standard (non-emulated/special) memory.
57          *           Used for instruction fetch, stack operations, and others.
58          *  @addr:  [IN ] Linear address from which to read.
59          *  @val:   [OUT] Value read from memory, zero-extended to 'u_long'.
60          *  @bytes: [IN ] Number of bytes to read from memory.
61          */
62         int (*read_std)(unsigned long addr,
63                         unsigned long *val,
64                         unsigned int bytes, struct x86_emulate_ctxt * ctxt);
65
66         /*
67          * write_std: Write bytes of standard (non-emulated/special) memory.
68          *            Used for stack operations, and others.
69          *  @addr:  [IN ] Linear address to which to write.
70          *  @val:   [IN ] Value to write to memory (low-order bytes used as
71          *                required).
72          *  @bytes: [IN ] Number of bytes to write to memory.
73          */
74         int (*write_std)(unsigned long addr,
75                          unsigned long val,
76                          unsigned int bytes, struct x86_emulate_ctxt * ctxt);
77
78         /*
79          * read_emulated: Read bytes from emulated/special memory area.
80          *  @addr:  [IN ] Linear address from which to read.
81          *  @val:   [OUT] Value read from memory, zero-extended to 'u_long'.
82          *  @bytes: [IN ] Number of bytes to read from memory.
83          */
84         int (*read_emulated) (unsigned long addr,
85                               unsigned long *val,
86                               unsigned int bytes,
87                               struct x86_emulate_ctxt * ctxt);
88
89         /*
90          * write_emulated: Read bytes from emulated/special memory area.
91          *  @addr:  [IN ] Linear address to which to write.
92          *  @val:   [IN ] Value to write to memory (low-order bytes used as
93          *                required).
94          *  @bytes: [IN ] Number of bytes to write to memory.
95          */
96         int (*write_emulated) (unsigned long addr,
97                                unsigned long val,
98                                unsigned int bytes,
99                                struct x86_emulate_ctxt * ctxt);
100
101         /*
102          * cmpxchg_emulated: Emulate an atomic (LOCKed) CMPXCHG operation on an
103          *                   emulated/special memory area.
104          *  @addr:  [IN ] Linear address to access.
105          *  @old:   [IN ] Value expected to be current at @addr.
106          *  @new:   [IN ] Value to write to @addr.
107          *  @bytes: [IN ] Number of bytes to access using CMPXCHG.
108          */
109         int (*cmpxchg_emulated) (unsigned long addr,
110                                  unsigned long old,
111                                  unsigned long new,
112                                  unsigned int bytes,
113                                  struct x86_emulate_ctxt * ctxt);
114
115         /*
116          * cmpxchg8b_emulated: Emulate an atomic (LOCKed) CMPXCHG8B operation on an
117          *                     emulated/special memory area.
118          *  @addr:  [IN ] Linear address to access.
119          *  @old:   [IN ] Value expected to be current at @addr.
120          *  @new:   [IN ] Value to write to @addr.
121          * NOTES:
122          *  1. This function is only ever called when emulating a real CMPXCHG8B.
123          *  2. This function is *never* called on x86/64 systems.
124          *  2. Not defining this function (i.e., specifying NULL) is equivalent
125          *     to defining a function that always returns X86EMUL_UNHANDLEABLE.
126          */
127         int (*cmpxchg8b_emulated) (unsigned long addr,
128                                    unsigned long old_lo,
129                                    unsigned long old_hi,
130                                    unsigned long new_lo,
131                                    unsigned long new_hi,
132                                    struct x86_emulate_ctxt * ctxt);
133 };
134
135 struct cpu_user_regs;
136
137 struct x86_emulate_ctxt {
138         /* Register state before/after emulation. */
139         struct litevm_vcpu *vcpu;
140
141         /* Linear faulting address (if emulating a page-faulting instruction). */
142         unsigned long eflags;
143         unsigned long cr2;
144
145         /* Emulated execution mode, represented by an X86EMUL_MODE value. */
146         int mode;
147
148         unsigned long cs_base;
149         unsigned long ds_base;
150         unsigned long es_base;
151         unsigned long ss_base;
152         unsigned long gs_base;
153         unsigned long fs_base;
154 };
155
156 /* Execution mode, passed to the emulator. */
157 #define X86EMUL_MODE_REAL     0 /* Real mode.             */
158 #define X86EMUL_MODE_PROT16   2 /* 16-bit protected mode. */
159 #define X86EMUL_MODE_PROT32   4 /* 32-bit protected mode. */
160 #define X86EMUL_MODE_PROT64   8 /* 64-bit (long) mode.    */
161
162 /* Host execution mode. */
163 #if defined(__i386__)
164 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT32
165 #elif defined(__x86_64__)
166 #define X86EMUL_MODE_HOST X86EMUL_MODE_PROT64
167 #endif
168
169 /*
170  * x86_emulate_memop: Emulate an instruction that faulted attempting to
171  *                    read/write a 'special' memory area.
172  * Returns -1 on failure, 0 on success.
173  */
174 int x86_emulate_memop(struct x86_emulate_ctxt *ctxt,
175                       struct x86_emulate_ops *ops);
176
177 /*
178  * Given the 'reg' portion of a ModRM byte, and a register block, return a
179  * pointer into the block that addresses the relevant register.
180  * @highbyte_regs specifies whether to decode AH,CH,DH,BH.
181  */
182 void *decode_register(u8 modrm_reg, unsigned long *regs,
183                       int highbyte_regs);
184
185 #endif                          /* __X86_EMULATE_H__ */