x86_emulate.h 7.0 KB

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