emulate.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528
  1. /*
  2. * This program is free software; you can redistribute it and/or modify
  3. * it under the terms of the GNU General Public License, version 2, as
  4. * published by the Free Software Foundation.
  5. *
  6. * This program is distributed in the hope that it will be useful,
  7. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  8. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  9. * GNU General Public License for more details.
  10. *
  11. * You should have received a copy of the GNU General Public License
  12. * along with this program; if not, write to the Free Software
  13. * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  14. *
  15. * Copyright IBM Corp. 2007
  16. * Copyright 2011 Freescale Semiconductor, Inc.
  17. *
  18. * Authors: Hollis Blanchard <hollisb@us.ibm.com>
  19. */
  20. #include <linux/jiffies.h>
  21. #include <linux/hrtimer.h>
  22. #include <linux/types.h>
  23. #include <linux/string.h>
  24. #include <linux/kvm_host.h>
  25. #include <linux/clockchips.h>
  26. #include <asm/reg.h>
  27. #include <asm/time.h>
  28. #include <asm/byteorder.h>
  29. #include <asm/kvm_ppc.h>
  30. #include <asm/disassemble.h>
  31. #include "timing.h"
  32. #include "trace.h"
  33. #define OP_TRAP 3
  34. #define OP_TRAP_64 2
  35. #define OP_31_XOP_TRAP 4
  36. #define OP_31_XOP_LWZX 23
  37. #define OP_31_XOP_DCBST 54
  38. #define OP_31_XOP_TRAP_64 68
  39. #define OP_31_XOP_DCBF 86
  40. #define OP_31_XOP_LBZX 87
  41. #define OP_31_XOP_STWX 151
  42. #define OP_31_XOP_STBX 215
  43. #define OP_31_XOP_LBZUX 119
  44. #define OP_31_XOP_STBUX 247
  45. #define OP_31_XOP_LHZX 279
  46. #define OP_31_XOP_LHZUX 311
  47. #define OP_31_XOP_MFSPR 339
  48. #define OP_31_XOP_LHAX 343
  49. #define OP_31_XOP_STHX 407
  50. #define OP_31_XOP_STHUX 439
  51. #define OP_31_XOP_MTSPR 467
  52. #define OP_31_XOP_DCBI 470
  53. #define OP_31_XOP_LWBRX 534
  54. #define OP_31_XOP_TLBSYNC 566
  55. #define OP_31_XOP_STWBRX 662
  56. #define OP_31_XOP_LHBRX 790
  57. #define OP_31_XOP_STHBRX 918
  58. #define OP_LWZ 32
  59. #define OP_LD 58
  60. #define OP_LWZU 33
  61. #define OP_LBZ 34
  62. #define OP_LBZU 35
  63. #define OP_STW 36
  64. #define OP_STWU 37
  65. #define OP_STD 62
  66. #define OP_STB 38
  67. #define OP_STBU 39
  68. #define OP_LHZ 40
  69. #define OP_LHZU 41
  70. #define OP_LHA 42
  71. #define OP_LHAU 43
  72. #define OP_STH 44
  73. #define OP_STHU 45
  74. void kvmppc_emulate_dec(struct kvm_vcpu *vcpu)
  75. {
  76. unsigned long dec_nsec;
  77. unsigned long long dec_time;
  78. pr_debug("mtDEC: %x\n", vcpu->arch.dec);
  79. hrtimer_try_to_cancel(&vcpu->arch.dec_timer);
  80. #ifdef CONFIG_PPC_BOOK3S
  81. /* mtdec lowers the interrupt line when positive. */
  82. kvmppc_core_dequeue_dec(vcpu);
  83. /* POWER4+ triggers a dec interrupt if the value is < 0 */
  84. if (vcpu->arch.dec & 0x80000000) {
  85. kvmppc_core_queue_dec(vcpu);
  86. return;
  87. }
  88. #endif
  89. #ifdef CONFIG_BOOKE
  90. /* On BOOKE, DEC = 0 is as good as decrementer not enabled */
  91. if (vcpu->arch.dec == 0)
  92. return;
  93. #endif
  94. /*
  95. * The decrementer ticks at the same rate as the timebase, so
  96. * that's how we convert the guest DEC value to the number of
  97. * host ticks.
  98. */
  99. dec_time = vcpu->arch.dec;
  100. /*
  101. * Guest timebase ticks at the same frequency as host decrementer.
  102. * So use the host decrementer calculations for decrementer emulation.
  103. */
  104. dec_time = dec_time << decrementer_clockevent.shift;
  105. do_div(dec_time, decrementer_clockevent.mult);
  106. dec_nsec = do_div(dec_time, NSEC_PER_SEC);
  107. hrtimer_start(&vcpu->arch.dec_timer,
  108. ktime_set(dec_time, dec_nsec), HRTIMER_MODE_REL);
  109. vcpu->arch.dec_jiffies = get_tb();
  110. }
  111. u32 kvmppc_get_dec(struct kvm_vcpu *vcpu, u64 tb)
  112. {
  113. u64 jd = tb - vcpu->arch.dec_jiffies;
  114. #ifdef CONFIG_BOOKE
  115. if (vcpu->arch.dec < jd)
  116. return 0;
  117. #endif
  118. return vcpu->arch.dec - jd;
  119. }
  120. static int kvmppc_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, int rs)
  121. {
  122. enum emulation_result emulated = EMULATE_DONE;
  123. ulong spr_val = kvmppc_get_gpr(vcpu, rs);
  124. switch (sprn) {
  125. case SPRN_SRR0:
  126. vcpu->arch.shared->srr0 = spr_val;
  127. break;
  128. case SPRN_SRR1:
  129. vcpu->arch.shared->srr1 = spr_val;
  130. break;
  131. /* XXX We need to context-switch the timebase for
  132. * watchdog and FIT. */
  133. case SPRN_TBWL: break;
  134. case SPRN_TBWU: break;
  135. case SPRN_DEC:
  136. vcpu->arch.dec = spr_val;
  137. kvmppc_emulate_dec(vcpu);
  138. break;
  139. case SPRN_SPRG0:
  140. vcpu->arch.shared->sprg0 = spr_val;
  141. break;
  142. case SPRN_SPRG1:
  143. vcpu->arch.shared->sprg1 = spr_val;
  144. break;
  145. case SPRN_SPRG2:
  146. vcpu->arch.shared->sprg2 = spr_val;
  147. break;
  148. case SPRN_SPRG3:
  149. vcpu->arch.shared->sprg3 = spr_val;
  150. break;
  151. /* PIR can legally be written, but we ignore it */
  152. case SPRN_PIR: break;
  153. default:
  154. emulated = kvmppc_core_emulate_mtspr(vcpu, sprn,
  155. spr_val);
  156. if (emulated == EMULATE_FAIL)
  157. printk(KERN_INFO "mtspr: unknown spr "
  158. "0x%x\n", sprn);
  159. break;
  160. }
  161. kvmppc_set_exit_type(vcpu, EMULATED_MTSPR_EXITS);
  162. return emulated;
  163. }
  164. static int kvmppc_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, int rt)
  165. {
  166. enum emulation_result emulated = EMULATE_DONE;
  167. ulong spr_val = 0;
  168. switch (sprn) {
  169. case SPRN_SRR0:
  170. spr_val = vcpu->arch.shared->srr0;
  171. break;
  172. case SPRN_SRR1:
  173. spr_val = vcpu->arch.shared->srr1;
  174. break;
  175. case SPRN_PVR:
  176. spr_val = vcpu->arch.pvr;
  177. break;
  178. case SPRN_PIR:
  179. spr_val = vcpu->vcpu_id;
  180. break;
  181. /* Note: mftb and TBRL/TBWL are user-accessible, so
  182. * the guest can always access the real TB anyways.
  183. * In fact, we probably will never see these traps. */
  184. case SPRN_TBWL:
  185. spr_val = get_tb() >> 32;
  186. break;
  187. case SPRN_TBWU:
  188. spr_val = get_tb();
  189. break;
  190. case SPRN_SPRG0:
  191. spr_val = vcpu->arch.shared->sprg0;
  192. break;
  193. case SPRN_SPRG1:
  194. spr_val = vcpu->arch.shared->sprg1;
  195. break;
  196. case SPRN_SPRG2:
  197. spr_val = vcpu->arch.shared->sprg2;
  198. break;
  199. case SPRN_SPRG3:
  200. spr_val = vcpu->arch.shared->sprg3;
  201. break;
  202. /* Note: SPRG4-7 are user-readable, so we don't get
  203. * a trap. */
  204. case SPRN_DEC:
  205. spr_val = kvmppc_get_dec(vcpu, get_tb());
  206. break;
  207. default:
  208. emulated = kvmppc_core_emulate_mfspr(vcpu, sprn,
  209. &spr_val);
  210. if (unlikely(emulated == EMULATE_FAIL)) {
  211. printk(KERN_INFO "mfspr: unknown spr "
  212. "0x%x\n", sprn);
  213. }
  214. break;
  215. }
  216. if (emulated == EMULATE_DONE)
  217. kvmppc_set_gpr(vcpu, rt, spr_val);
  218. kvmppc_set_exit_type(vcpu, EMULATED_MFSPR_EXITS);
  219. return emulated;
  220. }
  221. /* XXX to do:
  222. * lhax
  223. * lhaux
  224. * lswx
  225. * lswi
  226. * stswx
  227. * stswi
  228. * lha
  229. * lhau
  230. * lmw
  231. * stmw
  232. *
  233. * XXX is_bigendian should depend on MMU mapping or MSR[LE]
  234. */
  235. /* XXX Should probably auto-generate instruction decoding for a particular core
  236. * from opcode tables in the future. */
  237. int kvmppc_emulate_instruction(struct kvm_run *run, struct kvm_vcpu *vcpu)
  238. {
  239. u32 inst = kvmppc_get_last_inst(vcpu);
  240. int ra = get_ra(inst);
  241. int rs = get_rs(inst);
  242. int rt = get_rt(inst);
  243. int sprn = get_sprn(inst);
  244. enum emulation_result emulated = EMULATE_DONE;
  245. int advance = 1;
  246. /* this default type might be overwritten by subcategories */
  247. kvmppc_set_exit_type(vcpu, EMULATED_INST_EXITS);
  248. pr_debug("Emulating opcode %d / %d\n", get_op(inst), get_xop(inst));
  249. switch (get_op(inst)) {
  250. case OP_TRAP:
  251. #ifdef CONFIG_PPC_BOOK3S
  252. case OP_TRAP_64:
  253. kvmppc_core_queue_program(vcpu, SRR1_PROGTRAP);
  254. #else
  255. kvmppc_core_queue_program(vcpu,
  256. vcpu->arch.shared->esr | ESR_PTR);
  257. #endif
  258. advance = 0;
  259. break;
  260. case 31:
  261. switch (get_xop(inst)) {
  262. case OP_31_XOP_TRAP:
  263. #ifdef CONFIG_64BIT
  264. case OP_31_XOP_TRAP_64:
  265. #endif
  266. #ifdef CONFIG_PPC_BOOK3S
  267. kvmppc_core_queue_program(vcpu, SRR1_PROGTRAP);
  268. #else
  269. kvmppc_core_queue_program(vcpu,
  270. vcpu->arch.shared->esr | ESR_PTR);
  271. #endif
  272. advance = 0;
  273. break;
  274. case OP_31_XOP_LWZX:
  275. emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
  276. break;
  277. case OP_31_XOP_LBZX:
  278. emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
  279. break;
  280. case OP_31_XOP_LBZUX:
  281. emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
  282. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  283. break;
  284. case OP_31_XOP_STWX:
  285. emulated = kvmppc_handle_store(run, vcpu,
  286. kvmppc_get_gpr(vcpu, rs),
  287. 4, 1);
  288. break;
  289. case OP_31_XOP_STBX:
  290. emulated = kvmppc_handle_store(run, vcpu,
  291. kvmppc_get_gpr(vcpu, rs),
  292. 1, 1);
  293. break;
  294. case OP_31_XOP_STBUX:
  295. emulated = kvmppc_handle_store(run, vcpu,
  296. kvmppc_get_gpr(vcpu, rs),
  297. 1, 1);
  298. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  299. break;
  300. case OP_31_XOP_LHAX:
  301. emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1);
  302. break;
  303. case OP_31_XOP_LHZX:
  304. emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
  305. break;
  306. case OP_31_XOP_LHZUX:
  307. emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
  308. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  309. break;
  310. case OP_31_XOP_MFSPR:
  311. emulated = kvmppc_emulate_mfspr(vcpu, sprn, rt);
  312. break;
  313. case OP_31_XOP_STHX:
  314. emulated = kvmppc_handle_store(run, vcpu,
  315. kvmppc_get_gpr(vcpu, rs),
  316. 2, 1);
  317. break;
  318. case OP_31_XOP_STHUX:
  319. emulated = kvmppc_handle_store(run, vcpu,
  320. kvmppc_get_gpr(vcpu, rs),
  321. 2, 1);
  322. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  323. break;
  324. case OP_31_XOP_MTSPR:
  325. emulated = kvmppc_emulate_mtspr(vcpu, sprn, rs);
  326. break;
  327. case OP_31_XOP_DCBST:
  328. case OP_31_XOP_DCBF:
  329. case OP_31_XOP_DCBI:
  330. /* Do nothing. The guest is performing dcbi because
  331. * hardware DMA is not snooped by the dcache, but
  332. * emulated DMA either goes through the dcache as
  333. * normal writes, or the host kernel has handled dcache
  334. * coherence. */
  335. break;
  336. case OP_31_XOP_LWBRX:
  337. emulated = kvmppc_handle_load(run, vcpu, rt, 4, 0);
  338. break;
  339. case OP_31_XOP_TLBSYNC:
  340. break;
  341. case OP_31_XOP_STWBRX:
  342. emulated = kvmppc_handle_store(run, vcpu,
  343. kvmppc_get_gpr(vcpu, rs),
  344. 4, 0);
  345. break;
  346. case OP_31_XOP_LHBRX:
  347. emulated = kvmppc_handle_load(run, vcpu, rt, 2, 0);
  348. break;
  349. case OP_31_XOP_STHBRX:
  350. emulated = kvmppc_handle_store(run, vcpu,
  351. kvmppc_get_gpr(vcpu, rs),
  352. 2, 0);
  353. break;
  354. default:
  355. /* Attempt core-specific emulation below. */
  356. emulated = EMULATE_FAIL;
  357. }
  358. break;
  359. case OP_LWZ:
  360. emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
  361. break;
  362. /* TBD: Add support for other 64 bit load variants like ldu, ldux, ldx etc. */
  363. case OP_LD:
  364. rt = get_rt(inst);
  365. emulated = kvmppc_handle_load(run, vcpu, rt, 8, 1);
  366. break;
  367. case OP_LWZU:
  368. emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
  369. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  370. break;
  371. case OP_LBZ:
  372. emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
  373. break;
  374. case OP_LBZU:
  375. emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
  376. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  377. break;
  378. case OP_STW:
  379. emulated = kvmppc_handle_store(run, vcpu,
  380. kvmppc_get_gpr(vcpu, rs),
  381. 4, 1);
  382. break;
  383. /* TBD: Add support for other 64 bit store variants like stdu, stdux, stdx etc. */
  384. case OP_STD:
  385. rs = get_rs(inst);
  386. emulated = kvmppc_handle_store(run, vcpu,
  387. kvmppc_get_gpr(vcpu, rs),
  388. 8, 1);
  389. break;
  390. case OP_STWU:
  391. emulated = kvmppc_handle_store(run, vcpu,
  392. kvmppc_get_gpr(vcpu, rs),
  393. 4, 1);
  394. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  395. break;
  396. case OP_STB:
  397. emulated = kvmppc_handle_store(run, vcpu,
  398. kvmppc_get_gpr(vcpu, rs),
  399. 1, 1);
  400. break;
  401. case OP_STBU:
  402. emulated = kvmppc_handle_store(run, vcpu,
  403. kvmppc_get_gpr(vcpu, rs),
  404. 1, 1);
  405. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  406. break;
  407. case OP_LHZ:
  408. emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
  409. break;
  410. case OP_LHZU:
  411. emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
  412. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  413. break;
  414. case OP_LHA:
  415. emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1);
  416. break;
  417. case OP_LHAU:
  418. emulated = kvmppc_handle_loads(run, vcpu, rt, 2, 1);
  419. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  420. break;
  421. case OP_STH:
  422. emulated = kvmppc_handle_store(run, vcpu,
  423. kvmppc_get_gpr(vcpu, rs),
  424. 2, 1);
  425. break;
  426. case OP_STHU:
  427. emulated = kvmppc_handle_store(run, vcpu,
  428. kvmppc_get_gpr(vcpu, rs),
  429. 2, 1);
  430. kvmppc_set_gpr(vcpu, ra, vcpu->arch.vaddr_accessed);
  431. break;
  432. default:
  433. emulated = EMULATE_FAIL;
  434. }
  435. if (emulated == EMULATE_FAIL) {
  436. emulated = kvmppc_core_emulate_op(run, vcpu, inst, &advance);
  437. if (emulated == EMULATE_AGAIN) {
  438. advance = 0;
  439. } else if (emulated == EMULATE_FAIL) {
  440. advance = 0;
  441. printk(KERN_ERR "Couldn't emulate instruction 0x%08x "
  442. "(op %d xop %d)\n", inst, get_op(inst), get_xop(inst));
  443. kvmppc_core_queue_program(vcpu, 0);
  444. }
  445. }
  446. trace_kvm_ppc_instr(inst, kvmppc_get_pc(vcpu), emulated);
  447. /* Advance past emulated instruction. */
  448. if (advance)
  449. kvmppc_set_pc(vcpu, kvmppc_get_pc(vcpu) + 4);
  450. return emulated;
  451. }