Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Octocat-spinner-32-eaf2f5

Cannot retrieve contributors at this time

file 206 lines (184 sloc) 6.736 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205
/*
* x86_emulate.h
*
* Generic x86 (32-bit and 64-bit) instruction decoder and emulator.
*
* Copyright (c) 2005 Keir Fraser
*
* From: xen-unstable 10676:af9809f51f81a3c43f276f00c81a52ef558afda4
*
* Copyright (c) 2011 Joyent, Inc.
*/

#ifndef _ASM_X86_KVM_X86_EMULATE_H
#define _ASM_X86_KVM_X86_EMULATE_H

#include <sys/stdint.h>

struct kvm_vcpu;
struct x86_emulate_ctxt;
#ifdef _KERNEL
/*
* x86_emulate_ops:
*
* These operations represent the instruction emulator's interface to memory.
* There are two categories of operation: those that act on ordinary memory
* regions (*_std), and those that act on memory regions known to require
* special treatment or emulation (*_emulated).
*
* The emulator assumes that an instruction accesses only one 'emulated memory'
* location, that this location is the given linear faulting address (cr2), and
* that this is one of the instruction's data operands. Instruction fetches and
* stack operations are assumed never to access emulated memory. The emulator
* automatically deduces which operand of a string-move operation is accessing
* emulated memory, and assumes that the other operand accesses normal memory.
*
* NOTES:
* 1. The emulator isn't very smart about emulated vs. standard memory.
* 'Emulated memory' access addresses should be checked for sanity.
* 'Normal memory' accesses may fault, and the caller must arrange to
* detect and handle reentrancy into the emulator via recursive faults.
* Accesses may be unaligned and may cross page boundaries.
* 2. If the access fails (cannot emulate, or a standard access faults) then
* it is up to the memop to propagate the fault to the guest VM via
* some out-of-band mechanism, unknown to the emulator. The memop signals
* failure by returning X86EMUL_PROPAGATE_FAULT to the emulator, which will
* then immediately bail.
* 3. Valid access sizes are 1, 2, 4 and 8 bytes. On x86/32 systems only
* cmpxchg8b_emulated need support 8-byte accesses.
* 4. The emulator cannot handle 64-bit mode emulation on an x86/32 system.
*/
/* Access completed successfully: continue emulation as normal. */
#define X86EMUL_CONTINUE 0
/* Access is unhandleable: bail from emulation and return error to caller. */
#define X86EMUL_UNHANDLEABLE 1
/* Terminate emulation but return success to the caller. */
/*
* X86EMUL_PROPAGATE_FAULT: propagate a generated fault to guest
* X86EMUL_RETRY_INSTR: retry the instruction for some reason
* X86EMUL_CMPXCHG_FAILD: cmpxchg did not see expected value
*/
#define X86EMUL_PROPAGATE_FAULT 2
#define X86EMUL_RETRY_INSTR 2
#define X86EMUL_CMPXCHG_FAILED 2

typedef struct x86_emulate_ops {
/*
* read_std: Read bytes of standard (non-emulated/special) memory. Used
* for descriptor reading.
*
* @addr: [IN ] Linear address from which to read.
* @val: [OUT] Value read from memory, zero-extended to 'u_long'.
* @bytes: [IN ] Number of bytes to read from memory.
*/
int (*read_std)(unsigned long, void *,
unsigned int, struct kvm_vcpu *, uint32_t *);

/*
* fetch: Read bytes of standard (non-emulated/special) memory. Used for
* instruction fetch.
*
* @addr: [IN ] Linear address from which to read.
* @val: [OUT] Value read from memory, zero-extended to 'u_long'.
* @bytes: [IN ] Number of bytes to read from memory.
*/
int (*fetch)(unsigned long, void *,
unsigned int, struct kvm_vcpu *, uint32_t *);

/*
* read_emulated: Read bytes from emulated/special memory area.
*
* @addr: [IN ] Linear address from which to read.
* @val: [OUT] Value read from memory, zero-extended to 'u_long'.
* @bytes: [IN ] Number of bytes to read from memory.
*/
int (*read_emulated)(unsigned long, void *, unsigned int,
struct kvm_vcpu *);

/*
* write_emulated: Write bytes to emulated/special memory area.
*
* @addr: [IN ] Linear address to which to write.
* @val: [IN ] Value to write to memory (low-order bytes used as
* required).
* @bytes: [IN ] Number of bytes to write to memory.
*/
int (*write_emulated)(unsigned long, const void *, unsigned int,
struct kvm_vcpu *);

/*
* cmpxchg_emulated: Emulate an atomic (LOCKed) CMPXCHG operation on an
* emulated/special memory area.
*
* @addr: [IN ] Linear address to access.
* @old: [IN ] Value expected to be current at @addr.
* @new: [IN ] Value to write to @addr.
* @bytes: [IN ] Number of bytes to access using CMPXCHG.
*/
int (*cmpxchg_emulated)(unsigned long, const void *, const void *,
unsigned int, struct kvm_vcpu *);

} x86_emulate_ops_t;
#endif /* _KERNEL */

/* Type, address-of, and value of an instruction's operand. */
typedef struct operand {
enum { OP_REG, OP_MEM, OP_IMM, OP_NONE } type;
unsigned int bytes;
unsigned long val, orig_val, *ptr;
} operand_t;

typedef struct fetch_cache {
uint8_t data[15];
unsigned long start;
unsigned long end;
} fetch_cache_t;

typedef struct decode_cache {
uint8_t twobyte;
uint8_t b;
uint8_t lock_prefix;
uint8_t rep_prefix;
uint8_t op_bytes;
uint8_t ad_bytes;
uint8_t rex_prefix;
struct operand src;
struct operand src2;
struct operand dst;
int has_seg_override;
uint8_t seg_override;
unsigned int d;
unsigned long regs[NR_VCPU_REGS];
unsigned long eip, eip_orig;
/* modrm */
uint8_t modrm;
uint8_t modrm_mod;
uint8_t modrm_reg;
uint8_t modrm_rm;
uint8_t use_modrm_ea;
int rip_relative;
unsigned long modrm_ea;
void *modrm_ptr;
unsigned long modrm_val;
struct fetch_cache fetch;
} decode_cache_t;

#define X86_SHADOW_INT_MOV_SS 1
#define X86_SHADOW_INT_STI 2

typedef struct x86_emulate_ctxt {
/* Register state before/after emulation. */
struct kvm_vcpu *vcpu;

unsigned long eflags;
/* Emulated execution mode, represented by an X86EMUL_MODE value. */
int mode;
uint32_t cs_base;

/* interruptibility state, as a result of execution of STI or MOV SS */
int interruptibility;

/* decode cache */
struct decode_cache decode;
} x86_emulate_ctxt_t;

/* Repeat String Operation Prefix */
#define REPE_PREFIX 1
#define REPNE_PREFIX 2

/* Execution mode, passed to the emulator. */
#define X86EMUL_MODE_REAL 0 /* Real mode. */
#define X86EMUL_MODE_VM86 1 /* Virtual 8086 mode. */
#define X86EMUL_MODE_PROT16 2 /* 16-bit protected mode. */
#define X86EMUL_MODE_PROT32 4 /* 32-bit protected mode. */
#define X86EMUL_MODE_PROT64 8 /* 64-bit (long) mode. */

/* Host execution mode. */
#define X86EMUL_MODE_HOST X86EMUL_MODE_PROT64

#ifdef _KERNEL
extern int x86_decode_insn(struct x86_emulate_ctxt *,
    struct x86_emulate_ops *);
extern int x86_emulate_insn(struct x86_emulate_ctxt *,
    struct x86_emulate_ops *);
#endif /* _KERNEL */
#endif /* _ASM_X86_KVM_X86_EMULATE_H */
Something went wrong with that request. Please try again.