kvm_emulate.h 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469
  1. /*
  2. * Copyright (C) 2012,2013 - ARM Ltd
  3. * Author: Marc Zyngier <marc.zyngier@arm.com>
  4. *
  5. * Derived from arch/arm/include/kvm_emulate.h
  6. * Copyright (C) 2012 - Virtual Open Systems and Columbia University
  7. * Author: Christoffer Dall <c.dall@virtualopensystems.com>
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License version 2 as
  11. * published by the Free Software Foundation.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  20. */
  21. #ifndef __ARM64_KVM_EMULATE_H__
  22. #define __ARM64_KVM_EMULATE_H__
  23. #include <linux/kvm_host.h>
  24. #include <asm/esr.h>
  25. #include <asm/kvm_arm.h>
  26. #include <asm/kvm_hyp.h>
  27. #include <asm/kvm_mmio.h>
  28. #include <asm/ptrace.h>
  29. #include <asm/cputype.h>
  30. #include <asm/virt.h>
  31. unsigned long *vcpu_reg32(const struct kvm_vcpu *vcpu, u8 reg_num);
  32. unsigned long vcpu_read_spsr32(const struct kvm_vcpu *vcpu);
  33. void vcpu_write_spsr32(struct kvm_vcpu *vcpu, unsigned long v);
  34. bool kvm_condition_valid32(const struct kvm_vcpu *vcpu);
  35. void kvm_skip_instr32(struct kvm_vcpu *vcpu, bool is_wide_instr);
  36. void kvm_inject_undefined(struct kvm_vcpu *vcpu);
  37. void kvm_inject_vabt(struct kvm_vcpu *vcpu);
  38. void kvm_inject_dabt(struct kvm_vcpu *vcpu, unsigned long addr);
  39. void kvm_inject_pabt(struct kvm_vcpu *vcpu, unsigned long addr);
  40. void kvm_inject_undef32(struct kvm_vcpu *vcpu);
  41. void kvm_inject_dabt32(struct kvm_vcpu *vcpu, unsigned long addr);
  42. void kvm_inject_pabt32(struct kvm_vcpu *vcpu, unsigned long addr);
  43. static inline bool vcpu_el1_is_32bit(struct kvm_vcpu *vcpu)
  44. {
  45. return !(vcpu->arch.hcr_el2 & HCR_RW);
  46. }
  47. static inline void vcpu_reset_hcr(struct kvm_vcpu *vcpu)
  48. {
  49. vcpu->arch.hcr_el2 = HCR_GUEST_FLAGS;
  50. if (is_kernel_in_hyp_mode())
  51. vcpu->arch.hcr_el2 |= HCR_E2H;
  52. if (cpus_have_const_cap(ARM64_HAS_RAS_EXTN)) {
  53. /* route synchronous external abort exceptions to EL2 */
  54. vcpu->arch.hcr_el2 |= HCR_TEA;
  55. /* trap error record accesses */
  56. vcpu->arch.hcr_el2 |= HCR_TERR;
  57. }
  58. if (cpus_have_const_cap(ARM64_HAS_STAGE2_FWB))
  59. vcpu->arch.hcr_el2 |= HCR_FWB;
  60. if (test_bit(KVM_ARM_VCPU_EL1_32BIT, vcpu->arch.features))
  61. vcpu->arch.hcr_el2 &= ~HCR_RW;
  62. /*
  63. * TID3: trap feature register accesses that we virtualise.
  64. * For now this is conditional, since no AArch32 feature regs
  65. * are currently virtualised.
  66. */
  67. if (!vcpu_el1_is_32bit(vcpu))
  68. vcpu->arch.hcr_el2 |= HCR_TID3;
  69. }
  70. static inline unsigned long *vcpu_hcr(struct kvm_vcpu *vcpu)
  71. {
  72. return (unsigned long *)&vcpu->arch.hcr_el2;
  73. }
  74. static inline void vcpu_clear_wfe_traps(struct kvm_vcpu *vcpu)
  75. {
  76. vcpu->arch.hcr_el2 &= ~HCR_TWE;
  77. }
  78. static inline void vcpu_set_wfe_traps(struct kvm_vcpu *vcpu)
  79. {
  80. vcpu->arch.hcr_el2 |= HCR_TWE;
  81. }
  82. static inline unsigned long vcpu_get_vsesr(struct kvm_vcpu *vcpu)
  83. {
  84. return vcpu->arch.vsesr_el2;
  85. }
  86. static inline void vcpu_set_vsesr(struct kvm_vcpu *vcpu, u64 vsesr)
  87. {
  88. vcpu->arch.vsesr_el2 = vsesr;
  89. }
  90. static inline unsigned long *vcpu_pc(const struct kvm_vcpu *vcpu)
  91. {
  92. return (unsigned long *)&vcpu_gp_regs(vcpu)->regs.pc;
  93. }
  94. static inline unsigned long *__vcpu_elr_el1(const struct kvm_vcpu *vcpu)
  95. {
  96. return (unsigned long *)&vcpu_gp_regs(vcpu)->elr_el1;
  97. }
  98. static inline unsigned long vcpu_read_elr_el1(const struct kvm_vcpu *vcpu)
  99. {
  100. if (vcpu->arch.sysregs_loaded_on_cpu)
  101. return read_sysreg_el1(elr);
  102. else
  103. return *__vcpu_elr_el1(vcpu);
  104. }
  105. static inline void vcpu_write_elr_el1(const struct kvm_vcpu *vcpu, unsigned long v)
  106. {
  107. if (vcpu->arch.sysregs_loaded_on_cpu)
  108. write_sysreg_el1(v, elr);
  109. else
  110. *__vcpu_elr_el1(vcpu) = v;
  111. }
  112. static inline unsigned long *vcpu_cpsr(const struct kvm_vcpu *vcpu)
  113. {
  114. return (unsigned long *)&vcpu_gp_regs(vcpu)->regs.pstate;
  115. }
  116. static inline bool vcpu_mode_is_32bit(const struct kvm_vcpu *vcpu)
  117. {
  118. return !!(*vcpu_cpsr(vcpu) & PSR_MODE32_BIT);
  119. }
  120. static inline bool kvm_condition_valid(const struct kvm_vcpu *vcpu)
  121. {
  122. if (vcpu_mode_is_32bit(vcpu))
  123. return kvm_condition_valid32(vcpu);
  124. return true;
  125. }
  126. static inline void kvm_skip_instr(struct kvm_vcpu *vcpu, bool is_wide_instr)
  127. {
  128. if (vcpu_mode_is_32bit(vcpu))
  129. kvm_skip_instr32(vcpu, is_wide_instr);
  130. else
  131. *vcpu_pc(vcpu) += 4;
  132. }
  133. static inline void vcpu_set_thumb(struct kvm_vcpu *vcpu)
  134. {
  135. *vcpu_cpsr(vcpu) |= PSR_AA32_T_BIT;
  136. }
  137. /*
  138. * vcpu_get_reg and vcpu_set_reg should always be passed a register number
  139. * coming from a read of ESR_EL2. Otherwise, it may give the wrong result on
  140. * AArch32 with banked registers.
  141. */
  142. static inline unsigned long vcpu_get_reg(const struct kvm_vcpu *vcpu,
  143. u8 reg_num)
  144. {
  145. return (reg_num == 31) ? 0 : vcpu_gp_regs(vcpu)->regs.regs[reg_num];
  146. }
  147. static inline void vcpu_set_reg(struct kvm_vcpu *vcpu, u8 reg_num,
  148. unsigned long val)
  149. {
  150. if (reg_num != 31)
  151. vcpu_gp_regs(vcpu)->regs.regs[reg_num] = val;
  152. }
  153. static inline unsigned long vcpu_read_spsr(const struct kvm_vcpu *vcpu)
  154. {
  155. if (vcpu_mode_is_32bit(vcpu))
  156. return vcpu_read_spsr32(vcpu);
  157. if (vcpu->arch.sysregs_loaded_on_cpu)
  158. return read_sysreg_el1(spsr);
  159. else
  160. return vcpu_gp_regs(vcpu)->spsr[KVM_SPSR_EL1];
  161. }
  162. static inline void vcpu_write_spsr(struct kvm_vcpu *vcpu, unsigned long v)
  163. {
  164. if (vcpu_mode_is_32bit(vcpu)) {
  165. vcpu_write_spsr32(vcpu, v);
  166. return;
  167. }
  168. if (vcpu->arch.sysregs_loaded_on_cpu)
  169. write_sysreg_el1(v, spsr);
  170. else
  171. vcpu_gp_regs(vcpu)->spsr[KVM_SPSR_EL1] = v;
  172. }
  173. /*
  174. * The layout of SPSR for an AArch32 state is different when observed from an
  175. * AArch64 SPSR_ELx or an AArch32 SPSR_*. This function generates the AArch32
  176. * view given an AArch64 view.
  177. *
  178. * In ARM DDI 0487E.a see:
  179. *
  180. * - The AArch64 view (SPSR_EL2) in section C5.2.18, page C5-426
  181. * - The AArch32 view (SPSR_abt) in section G8.2.126, page G8-6256
  182. * - The AArch32 view (SPSR_und) in section G8.2.132, page G8-6280
  183. *
  184. * Which show the following differences:
  185. *
  186. * | Bit | AA64 | AA32 | Notes |
  187. * +-----+------+------+-----------------------------|
  188. * | 24 | DIT | J | J is RES0 in ARMv8 |
  189. * | 21 | SS | DIT | SS doesn't exist in AArch32 |
  190. *
  191. * ... and all other bits are (currently) common.
  192. */
  193. static inline unsigned long host_spsr_to_spsr32(unsigned long spsr)
  194. {
  195. const unsigned long overlap = BIT(24) | BIT(21);
  196. unsigned long dit = !!(spsr & PSR_AA32_DIT_BIT);
  197. spsr &= ~overlap;
  198. spsr |= dit << 21;
  199. return spsr;
  200. }
  201. static inline bool vcpu_mode_priv(const struct kvm_vcpu *vcpu)
  202. {
  203. u32 mode;
  204. if (vcpu_mode_is_32bit(vcpu)) {
  205. mode = *vcpu_cpsr(vcpu) & PSR_AA32_MODE_MASK;
  206. return mode > PSR_AA32_MODE_USR;
  207. }
  208. mode = *vcpu_cpsr(vcpu) & PSR_MODE_MASK;
  209. return mode != PSR_MODE_EL0t;
  210. }
  211. static inline u32 kvm_vcpu_get_hsr(const struct kvm_vcpu *vcpu)
  212. {
  213. return vcpu->arch.fault.esr_el2;
  214. }
  215. static inline int kvm_vcpu_get_condition(const struct kvm_vcpu *vcpu)
  216. {
  217. u32 esr = kvm_vcpu_get_hsr(vcpu);
  218. if (esr & ESR_ELx_CV)
  219. return (esr & ESR_ELx_COND_MASK) >> ESR_ELx_COND_SHIFT;
  220. return -1;
  221. }
  222. static inline unsigned long kvm_vcpu_get_hfar(const struct kvm_vcpu *vcpu)
  223. {
  224. return vcpu->arch.fault.far_el2;
  225. }
  226. static inline phys_addr_t kvm_vcpu_get_fault_ipa(const struct kvm_vcpu *vcpu)
  227. {
  228. return ((phys_addr_t)vcpu->arch.fault.hpfar_el2 & HPFAR_MASK) << 8;
  229. }
  230. static inline u64 kvm_vcpu_get_disr(const struct kvm_vcpu *vcpu)
  231. {
  232. return vcpu->arch.fault.disr_el1;
  233. }
  234. static inline u32 kvm_vcpu_hvc_get_imm(const struct kvm_vcpu *vcpu)
  235. {
  236. return kvm_vcpu_get_hsr(vcpu) & ESR_ELx_xVC_IMM_MASK;
  237. }
  238. static inline bool kvm_vcpu_dabt_isvalid(const struct kvm_vcpu *vcpu)
  239. {
  240. return !!(kvm_vcpu_get_hsr(vcpu) & ESR_ELx_ISV);
  241. }
  242. static inline bool kvm_vcpu_dabt_issext(const struct kvm_vcpu *vcpu)
  243. {
  244. return !!(kvm_vcpu_get_hsr(vcpu) & ESR_ELx_SSE);
  245. }
  246. static inline bool kvm_vcpu_dabt_issf(const struct kvm_vcpu *vcpu)
  247. {
  248. return !!(kvm_vcpu_get_hsr(vcpu) & ESR_ELx_SF);
  249. }
  250. static inline int kvm_vcpu_dabt_get_rd(const struct kvm_vcpu *vcpu)
  251. {
  252. return (kvm_vcpu_get_hsr(vcpu) & ESR_ELx_SRT_MASK) >> ESR_ELx_SRT_SHIFT;
  253. }
  254. static inline bool kvm_vcpu_abt_iss1tw(const struct kvm_vcpu *vcpu)
  255. {
  256. return !!(kvm_vcpu_get_hsr(vcpu) & ESR_ELx_S1PTW);
  257. }
  258. static inline bool kvm_vcpu_dabt_iswrite(const struct kvm_vcpu *vcpu)
  259. {
  260. return !!(kvm_vcpu_get_hsr(vcpu) & ESR_ELx_WNR) ||
  261. kvm_vcpu_abt_iss1tw(vcpu); /* AF/DBM update */
  262. }
  263. static inline bool kvm_vcpu_dabt_is_cm(const struct kvm_vcpu *vcpu)
  264. {
  265. return !!(kvm_vcpu_get_hsr(vcpu) & ESR_ELx_CM);
  266. }
  267. static inline int kvm_vcpu_dabt_get_as(const struct kvm_vcpu *vcpu)
  268. {
  269. return 1 << ((kvm_vcpu_get_hsr(vcpu) & ESR_ELx_SAS) >> ESR_ELx_SAS_SHIFT);
  270. }
  271. /* This one is not specific to Data Abort */
  272. static inline bool kvm_vcpu_trap_il_is32bit(const struct kvm_vcpu *vcpu)
  273. {
  274. return !!(kvm_vcpu_get_hsr(vcpu) & ESR_ELx_IL);
  275. }
  276. static inline u8 kvm_vcpu_trap_get_class(const struct kvm_vcpu *vcpu)
  277. {
  278. return ESR_ELx_EC(kvm_vcpu_get_hsr(vcpu));
  279. }
  280. static inline bool kvm_vcpu_trap_is_iabt(const struct kvm_vcpu *vcpu)
  281. {
  282. return kvm_vcpu_trap_get_class(vcpu) == ESR_ELx_EC_IABT_LOW;
  283. }
  284. static inline bool kvm_vcpu_trap_is_exec_fault(const struct kvm_vcpu *vcpu)
  285. {
  286. return kvm_vcpu_trap_is_iabt(vcpu) && !kvm_vcpu_abt_iss1tw(vcpu);
  287. }
  288. static inline u8 kvm_vcpu_trap_get_fault(const struct kvm_vcpu *vcpu)
  289. {
  290. return kvm_vcpu_get_hsr(vcpu) & ESR_ELx_FSC;
  291. }
  292. static inline u8 kvm_vcpu_trap_get_fault_type(const struct kvm_vcpu *vcpu)
  293. {
  294. return kvm_vcpu_get_hsr(vcpu) & ESR_ELx_FSC_TYPE;
  295. }
  296. static inline bool kvm_vcpu_dabt_isextabt(const struct kvm_vcpu *vcpu)
  297. {
  298. switch (kvm_vcpu_trap_get_fault(vcpu)) {
  299. case FSC_SEA:
  300. case FSC_SEA_TTW0:
  301. case FSC_SEA_TTW1:
  302. case FSC_SEA_TTW2:
  303. case FSC_SEA_TTW3:
  304. case FSC_SECC:
  305. case FSC_SECC_TTW0:
  306. case FSC_SECC_TTW1:
  307. case FSC_SECC_TTW2:
  308. case FSC_SECC_TTW3:
  309. return true;
  310. default:
  311. return false;
  312. }
  313. }
  314. static inline int kvm_vcpu_sys_get_rt(struct kvm_vcpu *vcpu)
  315. {
  316. u32 esr = kvm_vcpu_get_hsr(vcpu);
  317. return (esr & ESR_ELx_SYS64_ISS_RT_MASK) >> ESR_ELx_SYS64_ISS_RT_SHIFT;
  318. }
  319. static inline unsigned long kvm_vcpu_get_mpidr_aff(struct kvm_vcpu *vcpu)
  320. {
  321. return vcpu_read_sys_reg(vcpu, MPIDR_EL1) & MPIDR_HWID_BITMASK;
  322. }
  323. static inline void kvm_vcpu_set_be(struct kvm_vcpu *vcpu)
  324. {
  325. if (vcpu_mode_is_32bit(vcpu)) {
  326. *vcpu_cpsr(vcpu) |= PSR_AA32_E_BIT;
  327. } else {
  328. u64 sctlr = vcpu_read_sys_reg(vcpu, SCTLR_EL1);
  329. sctlr |= (1 << 25);
  330. vcpu_write_sys_reg(vcpu, sctlr, SCTLR_EL1);
  331. }
  332. }
  333. static inline bool kvm_vcpu_is_be(struct kvm_vcpu *vcpu)
  334. {
  335. if (vcpu_mode_is_32bit(vcpu))
  336. return !!(*vcpu_cpsr(vcpu) & PSR_AA32_E_BIT);
  337. return !!(vcpu_read_sys_reg(vcpu, SCTLR_EL1) & (1 << 25));
  338. }
  339. static inline unsigned long vcpu_data_guest_to_host(struct kvm_vcpu *vcpu,
  340. unsigned long data,
  341. unsigned int len)
  342. {
  343. if (kvm_vcpu_is_be(vcpu)) {
  344. switch (len) {
  345. case 1:
  346. return data & 0xff;
  347. case 2:
  348. return be16_to_cpu(data & 0xffff);
  349. case 4:
  350. return be32_to_cpu(data & 0xffffffff);
  351. default:
  352. return be64_to_cpu(data);
  353. }
  354. } else {
  355. switch (len) {
  356. case 1:
  357. return data & 0xff;
  358. case 2:
  359. return le16_to_cpu(data & 0xffff);
  360. case 4:
  361. return le32_to_cpu(data & 0xffffffff);
  362. default:
  363. return le64_to_cpu(data);
  364. }
  365. }
  366. return data; /* Leave LE untouched */
  367. }
  368. static inline unsigned long vcpu_data_host_to_guest(struct kvm_vcpu *vcpu,
  369. unsigned long data,
  370. unsigned int len)
  371. {
  372. if (kvm_vcpu_is_be(vcpu)) {
  373. switch (len) {
  374. case 1:
  375. return data & 0xff;
  376. case 2:
  377. return cpu_to_be16(data & 0xffff);
  378. case 4:
  379. return cpu_to_be32(data & 0xffffffff);
  380. default:
  381. return cpu_to_be64(data);
  382. }
  383. } else {
  384. switch (len) {
  385. case 1:
  386. return data & 0xff;
  387. case 2:
  388. return cpu_to_le16(data & 0xffff);
  389. case 4:
  390. return cpu_to_le32(data & 0xffffffff);
  391. default:
  392. return cpu_to_le64(data);
  393. }
  394. }
  395. return data; /* Leave LE untouched */
  396. }
  397. #endif /* __ARM64_KVM_EMULATE_H__ */