book3s.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796
  1. /*
  2. * Copyright (C) 2009. SUSE Linux Products GmbH. All rights reserved.
  3. *
  4. * Authors:
  5. * Alexander Graf <agraf@suse.de>
  6. * Kevin Wolf <mail@kevin-wolf.de>
  7. *
  8. * Description:
  9. * This file is derived from arch/powerpc/kvm/44x.c,
  10. * by Hollis Blanchard <hollisb@us.ibm.com>.
  11. *
  12. * This program is free software; you can redistribute it and/or modify
  13. * it under the terms of the GNU General Public License, version 2, as
  14. * published by the Free Software Foundation.
  15. */
  16. #include <linux/kvm_host.h>
  17. #include <linux/err.h>
  18. #include <linux/export.h>
  19. #include <linux/slab.h>
  20. #include <asm/reg.h>
  21. #include <asm/cputable.h>
  22. #include <asm/cacheflush.h>
  23. #include <asm/tlbflush.h>
  24. #include <asm/uaccess.h>
  25. #include <asm/io.h>
  26. #include <asm/kvm_ppc.h>
  27. #include <asm/kvm_book3s.h>
  28. #include <asm/mmu_context.h>
  29. #include <asm/page.h>
  30. #include <linux/gfp.h>
  31. #include <linux/sched.h>
  32. #include <linux/vmalloc.h>
  33. #include <linux/highmem.h>
  34. #include "trace.h"
  35. #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
  36. /* #define EXIT_DEBUG */
  37. struct kvm_stats_debugfs_item debugfs_entries[] = {
  38. { "exits", VCPU_STAT(sum_exits) },
  39. { "mmio", VCPU_STAT(mmio_exits) },
  40. { "sig", VCPU_STAT(signal_exits) },
  41. { "sysc", VCPU_STAT(syscall_exits) },
  42. { "inst_emu", VCPU_STAT(emulated_inst_exits) },
  43. { "dec", VCPU_STAT(dec_exits) },
  44. { "ext_intr", VCPU_STAT(ext_intr_exits) },
  45. { "queue_intr", VCPU_STAT(queue_intr) },
  46. { "halt_wakeup", VCPU_STAT(halt_wakeup) },
  47. { "pf_storage", VCPU_STAT(pf_storage) },
  48. { "sp_storage", VCPU_STAT(sp_storage) },
  49. { "pf_instruc", VCPU_STAT(pf_instruc) },
  50. { "sp_instruc", VCPU_STAT(sp_instruc) },
  51. { "ld", VCPU_STAT(ld) },
  52. { "ld_slow", VCPU_STAT(ld_slow) },
  53. { "st", VCPU_STAT(st) },
  54. { "st_slow", VCPU_STAT(st_slow) },
  55. { NULL }
  56. };
  57. void kvmppc_core_load_host_debugstate(struct kvm_vcpu *vcpu)
  58. {
  59. }
  60. void kvmppc_core_load_guest_debugstate(struct kvm_vcpu *vcpu)
  61. {
  62. }
  63. void kvmppc_inject_interrupt(struct kvm_vcpu *vcpu, int vec, u64 flags)
  64. {
  65. vcpu->arch.shared->srr0 = kvmppc_get_pc(vcpu);
  66. vcpu->arch.shared->srr1 = vcpu->arch.shared->msr | flags;
  67. kvmppc_set_pc(vcpu, kvmppc_interrupt_offset(vcpu) + vec);
  68. vcpu->arch.mmu.reset_msr(vcpu);
  69. }
  70. static int kvmppc_book3s_vec2irqprio(unsigned int vec)
  71. {
  72. unsigned int prio;
  73. switch (vec) {
  74. case 0x100: prio = BOOK3S_IRQPRIO_SYSTEM_RESET; break;
  75. case 0x200: prio = BOOK3S_IRQPRIO_MACHINE_CHECK; break;
  76. case 0x300: prio = BOOK3S_IRQPRIO_DATA_STORAGE; break;
  77. case 0x380: prio = BOOK3S_IRQPRIO_DATA_SEGMENT; break;
  78. case 0x400: prio = BOOK3S_IRQPRIO_INST_STORAGE; break;
  79. case 0x480: prio = BOOK3S_IRQPRIO_INST_SEGMENT; break;
  80. case 0x500: prio = BOOK3S_IRQPRIO_EXTERNAL; break;
  81. case 0x501: prio = BOOK3S_IRQPRIO_EXTERNAL_LEVEL; break;
  82. case 0x600: prio = BOOK3S_IRQPRIO_ALIGNMENT; break;
  83. case 0x700: prio = BOOK3S_IRQPRIO_PROGRAM; break;
  84. case 0x800: prio = BOOK3S_IRQPRIO_FP_UNAVAIL; break;
  85. case 0x900: prio = BOOK3S_IRQPRIO_DECREMENTER; break;
  86. case 0xc00: prio = BOOK3S_IRQPRIO_SYSCALL; break;
  87. case 0xd00: prio = BOOK3S_IRQPRIO_DEBUG; break;
  88. case 0xf20: prio = BOOK3S_IRQPRIO_ALTIVEC; break;
  89. case 0xf40: prio = BOOK3S_IRQPRIO_VSX; break;
  90. default: prio = BOOK3S_IRQPRIO_MAX; break;
  91. }
  92. return prio;
  93. }
  94. void kvmppc_book3s_dequeue_irqprio(struct kvm_vcpu *vcpu,
  95. unsigned int vec)
  96. {
  97. unsigned long old_pending = vcpu->arch.pending_exceptions;
  98. clear_bit(kvmppc_book3s_vec2irqprio(vec),
  99. &vcpu->arch.pending_exceptions);
  100. kvmppc_update_int_pending(vcpu, vcpu->arch.pending_exceptions,
  101. old_pending);
  102. }
  103. void kvmppc_book3s_queue_irqprio(struct kvm_vcpu *vcpu, unsigned int vec)
  104. {
  105. vcpu->stat.queue_intr++;
  106. set_bit(kvmppc_book3s_vec2irqprio(vec),
  107. &vcpu->arch.pending_exceptions);
  108. #ifdef EXIT_DEBUG
  109. printk(KERN_INFO "Queueing interrupt %x\n", vec);
  110. #endif
  111. }
  112. void kvmppc_core_queue_program(struct kvm_vcpu *vcpu, ulong flags)
  113. {
  114. /* might as well deliver this straight away */
  115. kvmppc_inject_interrupt(vcpu, BOOK3S_INTERRUPT_PROGRAM, flags);
  116. }
  117. void kvmppc_core_queue_dec(struct kvm_vcpu *vcpu)
  118. {
  119. kvmppc_book3s_queue_irqprio(vcpu, BOOK3S_INTERRUPT_DECREMENTER);
  120. }
  121. int kvmppc_core_pending_dec(struct kvm_vcpu *vcpu)
  122. {
  123. return test_bit(BOOK3S_IRQPRIO_DECREMENTER, &vcpu->arch.pending_exceptions);
  124. }
  125. void kvmppc_core_dequeue_dec(struct kvm_vcpu *vcpu)
  126. {
  127. kvmppc_book3s_dequeue_irqprio(vcpu, BOOK3S_INTERRUPT_DECREMENTER);
  128. }
  129. void kvmppc_core_queue_external(struct kvm_vcpu *vcpu,
  130. struct kvm_interrupt *irq)
  131. {
  132. unsigned int vec = BOOK3S_INTERRUPT_EXTERNAL;
  133. if (irq->irq == KVM_INTERRUPT_SET_LEVEL)
  134. vec = BOOK3S_INTERRUPT_EXTERNAL_LEVEL;
  135. kvmppc_book3s_queue_irqprio(vcpu, vec);
  136. }
  137. void kvmppc_core_dequeue_external(struct kvm_vcpu *vcpu)
  138. {
  139. kvmppc_book3s_dequeue_irqprio(vcpu, BOOK3S_INTERRUPT_EXTERNAL);
  140. kvmppc_book3s_dequeue_irqprio(vcpu, BOOK3S_INTERRUPT_EXTERNAL_LEVEL);
  141. }
  142. int kvmppc_book3s_irqprio_deliver(struct kvm_vcpu *vcpu, unsigned int priority)
  143. {
  144. int deliver = 1;
  145. int vec = 0;
  146. bool crit = kvmppc_critical_section(vcpu);
  147. switch (priority) {
  148. case BOOK3S_IRQPRIO_DECREMENTER:
  149. deliver = (vcpu->arch.shared->msr & MSR_EE) && !crit;
  150. vec = BOOK3S_INTERRUPT_DECREMENTER;
  151. break;
  152. case BOOK3S_IRQPRIO_EXTERNAL:
  153. case BOOK3S_IRQPRIO_EXTERNAL_LEVEL:
  154. deliver = (vcpu->arch.shared->msr & MSR_EE) && !crit;
  155. vec = BOOK3S_INTERRUPT_EXTERNAL;
  156. break;
  157. case BOOK3S_IRQPRIO_SYSTEM_RESET:
  158. vec = BOOK3S_INTERRUPT_SYSTEM_RESET;
  159. break;
  160. case BOOK3S_IRQPRIO_MACHINE_CHECK:
  161. vec = BOOK3S_INTERRUPT_MACHINE_CHECK;
  162. break;
  163. case BOOK3S_IRQPRIO_DATA_STORAGE:
  164. vec = BOOK3S_INTERRUPT_DATA_STORAGE;
  165. break;
  166. case BOOK3S_IRQPRIO_INST_STORAGE:
  167. vec = BOOK3S_INTERRUPT_INST_STORAGE;
  168. break;
  169. case BOOK3S_IRQPRIO_DATA_SEGMENT:
  170. vec = BOOK3S_INTERRUPT_DATA_SEGMENT;
  171. break;
  172. case BOOK3S_IRQPRIO_INST_SEGMENT:
  173. vec = BOOK3S_INTERRUPT_INST_SEGMENT;
  174. break;
  175. case BOOK3S_IRQPRIO_ALIGNMENT:
  176. vec = BOOK3S_INTERRUPT_ALIGNMENT;
  177. break;
  178. case BOOK3S_IRQPRIO_PROGRAM:
  179. vec = BOOK3S_INTERRUPT_PROGRAM;
  180. break;
  181. case BOOK3S_IRQPRIO_VSX:
  182. vec = BOOK3S_INTERRUPT_VSX;
  183. break;
  184. case BOOK3S_IRQPRIO_ALTIVEC:
  185. vec = BOOK3S_INTERRUPT_ALTIVEC;
  186. break;
  187. case BOOK3S_IRQPRIO_FP_UNAVAIL:
  188. vec = BOOK3S_INTERRUPT_FP_UNAVAIL;
  189. break;
  190. case BOOK3S_IRQPRIO_SYSCALL:
  191. vec = BOOK3S_INTERRUPT_SYSCALL;
  192. break;
  193. case BOOK3S_IRQPRIO_DEBUG:
  194. vec = BOOK3S_INTERRUPT_TRACE;
  195. break;
  196. case BOOK3S_IRQPRIO_PERFORMANCE_MONITOR:
  197. vec = BOOK3S_INTERRUPT_PERFMON;
  198. break;
  199. default:
  200. deliver = 0;
  201. printk(KERN_ERR "KVM: Unknown interrupt: 0x%x\n", priority);
  202. break;
  203. }
  204. #if 0
  205. printk(KERN_INFO "Deliver interrupt 0x%x? %x\n", vec, deliver);
  206. #endif
  207. if (deliver)
  208. kvmppc_inject_interrupt(vcpu, vec, 0);
  209. return deliver;
  210. }
  211. /*
  212. * This function determines if an irqprio should be cleared once issued.
  213. */
  214. static bool clear_irqprio(struct kvm_vcpu *vcpu, unsigned int priority)
  215. {
  216. switch (priority) {
  217. case BOOK3S_IRQPRIO_DECREMENTER:
  218. /* DEC interrupts get cleared by mtdec */
  219. return false;
  220. case BOOK3S_IRQPRIO_EXTERNAL_LEVEL:
  221. /* External interrupts get cleared by userspace */
  222. return false;
  223. }
  224. return true;
  225. }
  226. int kvmppc_core_prepare_to_enter(struct kvm_vcpu *vcpu)
  227. {
  228. unsigned long *pending = &vcpu->arch.pending_exceptions;
  229. unsigned long old_pending = vcpu->arch.pending_exceptions;
  230. unsigned int priority;
  231. #ifdef EXIT_DEBUG
  232. if (vcpu->arch.pending_exceptions)
  233. printk(KERN_EMERG "KVM: Check pending: %lx\n", vcpu->arch.pending_exceptions);
  234. #endif
  235. priority = __ffs(*pending);
  236. while (priority < BOOK3S_IRQPRIO_MAX) {
  237. if (kvmppc_book3s_irqprio_deliver(vcpu, priority) &&
  238. clear_irqprio(vcpu, priority)) {
  239. clear_bit(priority, &vcpu->arch.pending_exceptions);
  240. break;
  241. }
  242. priority = find_next_bit(pending,
  243. BITS_PER_BYTE * sizeof(*pending),
  244. priority + 1);
  245. }
  246. /* Tell the guest about our interrupt status */
  247. kvmppc_update_int_pending(vcpu, *pending, old_pending);
  248. return 0;
  249. }
  250. pfn_t kvmppc_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn, bool writing,
  251. bool *writable)
  252. {
  253. ulong mp_pa = vcpu->arch.magic_page_pa;
  254. if (!(vcpu->arch.shared->msr & MSR_SF))
  255. mp_pa = (uint32_t)mp_pa;
  256. /* Magic page override */
  257. if (unlikely(mp_pa) &&
  258. unlikely(((gfn << PAGE_SHIFT) & KVM_PAM) ==
  259. ((mp_pa & PAGE_MASK) & KVM_PAM))) {
  260. ulong shared_page = ((ulong)vcpu->arch.shared) & PAGE_MASK;
  261. pfn_t pfn;
  262. pfn = (pfn_t)virt_to_phys((void*)shared_page) >> PAGE_SHIFT;
  263. get_page(pfn_to_page(pfn));
  264. if (writable)
  265. *writable = true;
  266. return pfn;
  267. }
  268. return gfn_to_pfn_prot(vcpu->kvm, gfn, writing, writable);
  269. }
  270. static int kvmppc_xlate(struct kvm_vcpu *vcpu, ulong eaddr, bool data,
  271. bool iswrite, struct kvmppc_pte *pte)
  272. {
  273. int relocated = (vcpu->arch.shared->msr & (data ? MSR_DR : MSR_IR));
  274. int r;
  275. if (relocated) {
  276. r = vcpu->arch.mmu.xlate(vcpu, eaddr, pte, data, iswrite);
  277. } else {
  278. pte->eaddr = eaddr;
  279. pte->raddr = eaddr & KVM_PAM;
  280. pte->vpage = VSID_REAL | eaddr >> 12;
  281. pte->may_read = true;
  282. pte->may_write = true;
  283. pte->may_execute = true;
  284. r = 0;
  285. }
  286. return r;
  287. }
  288. static hva_t kvmppc_bad_hva(void)
  289. {
  290. return PAGE_OFFSET;
  291. }
  292. static hva_t kvmppc_pte_to_hva(struct kvm_vcpu *vcpu, struct kvmppc_pte *pte,
  293. bool read)
  294. {
  295. hva_t hpage;
  296. if (read && !pte->may_read)
  297. goto err;
  298. if (!read && !pte->may_write)
  299. goto err;
  300. hpage = gfn_to_hva(vcpu->kvm, pte->raddr >> PAGE_SHIFT);
  301. if (kvm_is_error_hva(hpage))
  302. goto err;
  303. return hpage | (pte->raddr & ~PAGE_MASK);
  304. err:
  305. return kvmppc_bad_hva();
  306. }
  307. int kvmppc_st(struct kvm_vcpu *vcpu, ulong *eaddr, int size, void *ptr,
  308. bool data)
  309. {
  310. struct kvmppc_pte pte;
  311. vcpu->stat.st++;
  312. if (kvmppc_xlate(vcpu, *eaddr, data, true, &pte))
  313. return -ENOENT;
  314. *eaddr = pte.raddr;
  315. if (!pte.may_write)
  316. return -EPERM;
  317. if (kvm_write_guest(vcpu->kvm, pte.raddr, ptr, size))
  318. return EMULATE_DO_MMIO;
  319. return EMULATE_DONE;
  320. }
  321. int kvmppc_ld(struct kvm_vcpu *vcpu, ulong *eaddr, int size, void *ptr,
  322. bool data)
  323. {
  324. struct kvmppc_pte pte;
  325. hva_t hva = *eaddr;
  326. vcpu->stat.ld++;
  327. if (kvmppc_xlate(vcpu, *eaddr, data, false, &pte))
  328. goto nopte;
  329. *eaddr = pte.raddr;
  330. hva = kvmppc_pte_to_hva(vcpu, &pte, true);
  331. if (kvm_is_error_hva(hva))
  332. goto mmio;
  333. if (copy_from_user(ptr, (void __user *)hva, size)) {
  334. printk(KERN_INFO "kvmppc_ld at 0x%lx failed\n", hva);
  335. goto mmio;
  336. }
  337. return EMULATE_DONE;
  338. nopte:
  339. return -ENOENT;
  340. mmio:
  341. return EMULATE_DO_MMIO;
  342. }
  343. int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
  344. {
  345. return 0;
  346. }
  347. int kvmppc_subarch_vcpu_init(struct kvm_vcpu *vcpu)
  348. {
  349. return 0;
  350. }
  351. void kvmppc_subarch_vcpu_uninit(struct kvm_vcpu *vcpu)
  352. {
  353. }
  354. int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
  355. struct kvm_sregs *sregs)
  356. {
  357. return kvmppc_ops->get_sregs(vcpu, sregs);
  358. }
  359. int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
  360. struct kvm_sregs *sregs)
  361. {
  362. return kvmppc_ops->set_sregs(vcpu, sregs);
  363. }
  364. int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
  365. {
  366. int i;
  367. regs->pc = kvmppc_get_pc(vcpu);
  368. regs->cr = kvmppc_get_cr(vcpu);
  369. regs->ctr = kvmppc_get_ctr(vcpu);
  370. regs->lr = kvmppc_get_lr(vcpu);
  371. regs->xer = kvmppc_get_xer(vcpu);
  372. regs->msr = vcpu->arch.shared->msr;
  373. regs->srr0 = vcpu->arch.shared->srr0;
  374. regs->srr1 = vcpu->arch.shared->srr1;
  375. regs->pid = vcpu->arch.pid;
  376. regs->sprg0 = vcpu->arch.shared->sprg0;
  377. regs->sprg1 = vcpu->arch.shared->sprg1;
  378. regs->sprg2 = vcpu->arch.shared->sprg2;
  379. regs->sprg3 = vcpu->arch.shared->sprg3;
  380. regs->sprg4 = vcpu->arch.shared->sprg4;
  381. regs->sprg5 = vcpu->arch.shared->sprg5;
  382. regs->sprg6 = vcpu->arch.shared->sprg6;
  383. regs->sprg7 = vcpu->arch.shared->sprg7;
  384. for (i = 0; i < ARRAY_SIZE(regs->gpr); i++)
  385. regs->gpr[i] = kvmppc_get_gpr(vcpu, i);
  386. return 0;
  387. }
  388. int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
  389. {
  390. int i;
  391. kvmppc_set_pc(vcpu, regs->pc);
  392. kvmppc_set_cr(vcpu, regs->cr);
  393. kvmppc_set_ctr(vcpu, regs->ctr);
  394. kvmppc_set_lr(vcpu, regs->lr);
  395. kvmppc_set_xer(vcpu, regs->xer);
  396. kvmppc_set_msr(vcpu, regs->msr);
  397. vcpu->arch.shared->srr0 = regs->srr0;
  398. vcpu->arch.shared->srr1 = regs->srr1;
  399. vcpu->arch.shared->sprg0 = regs->sprg0;
  400. vcpu->arch.shared->sprg1 = regs->sprg1;
  401. vcpu->arch.shared->sprg2 = regs->sprg2;
  402. vcpu->arch.shared->sprg3 = regs->sprg3;
  403. vcpu->arch.shared->sprg4 = regs->sprg4;
  404. vcpu->arch.shared->sprg5 = regs->sprg5;
  405. vcpu->arch.shared->sprg6 = regs->sprg6;
  406. vcpu->arch.shared->sprg7 = regs->sprg7;
  407. for (i = 0; i < ARRAY_SIZE(regs->gpr); i++)
  408. kvmppc_set_gpr(vcpu, i, regs->gpr[i]);
  409. return 0;
  410. }
  411. int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
  412. {
  413. return -ENOTSUPP;
  414. }
  415. int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
  416. {
  417. return -ENOTSUPP;
  418. }
  419. int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
  420. {
  421. int r;
  422. union kvmppc_one_reg val;
  423. int size;
  424. long int i;
  425. size = one_reg_size(reg->id);
  426. if (size > sizeof(val))
  427. return -EINVAL;
  428. r = kvmppc_ops->get_one_reg(vcpu, reg->id, &val);
  429. if (r == -EINVAL) {
  430. r = 0;
  431. switch (reg->id) {
  432. case KVM_REG_PPC_DAR:
  433. val = get_reg_val(reg->id, vcpu->arch.shared->dar);
  434. break;
  435. case KVM_REG_PPC_DSISR:
  436. val = get_reg_val(reg->id, vcpu->arch.shared->dsisr);
  437. break;
  438. case KVM_REG_PPC_FPR0 ... KVM_REG_PPC_FPR31:
  439. i = reg->id - KVM_REG_PPC_FPR0;
  440. val = get_reg_val(reg->id, vcpu->arch.fpr[i]);
  441. break;
  442. case KVM_REG_PPC_FPSCR:
  443. val = get_reg_val(reg->id, vcpu->arch.fpscr);
  444. break;
  445. #ifdef CONFIG_ALTIVEC
  446. case KVM_REG_PPC_VR0 ... KVM_REG_PPC_VR31:
  447. if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
  448. r = -ENXIO;
  449. break;
  450. }
  451. val.vval = vcpu->arch.vr[reg->id - KVM_REG_PPC_VR0];
  452. break;
  453. case KVM_REG_PPC_VSCR:
  454. if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
  455. r = -ENXIO;
  456. break;
  457. }
  458. val = get_reg_val(reg->id, vcpu->arch.vscr.u[3]);
  459. break;
  460. case KVM_REG_PPC_VRSAVE:
  461. val = get_reg_val(reg->id, vcpu->arch.vrsave);
  462. break;
  463. #endif /* CONFIG_ALTIVEC */
  464. case KVM_REG_PPC_DEBUG_INST: {
  465. u32 opcode = INS_TW;
  466. r = copy_to_user((u32 __user *)(long)reg->addr,
  467. &opcode, sizeof(u32));
  468. break;
  469. }
  470. #ifdef CONFIG_KVM_XICS
  471. case KVM_REG_PPC_ICP_STATE:
  472. if (!vcpu->arch.icp) {
  473. r = -ENXIO;
  474. break;
  475. }
  476. val = get_reg_val(reg->id, kvmppc_xics_get_icp(vcpu));
  477. break;
  478. #endif /* CONFIG_KVM_XICS */
  479. default:
  480. r = -EINVAL;
  481. break;
  482. }
  483. }
  484. if (r)
  485. return r;
  486. if (copy_to_user((char __user *)(unsigned long)reg->addr, &val, size))
  487. r = -EFAULT;
  488. return r;
  489. }
  490. int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
  491. {
  492. int r;
  493. union kvmppc_one_reg val;
  494. int size;
  495. long int i;
  496. size = one_reg_size(reg->id);
  497. if (size > sizeof(val))
  498. return -EINVAL;
  499. if (copy_from_user(&val, (char __user *)(unsigned long)reg->addr, size))
  500. return -EFAULT;
  501. r = kvmppc_ops->set_one_reg(vcpu, reg->id, &val);
  502. if (r == -EINVAL) {
  503. r = 0;
  504. switch (reg->id) {
  505. case KVM_REG_PPC_DAR:
  506. vcpu->arch.shared->dar = set_reg_val(reg->id, val);
  507. break;
  508. case KVM_REG_PPC_DSISR:
  509. vcpu->arch.shared->dsisr = set_reg_val(reg->id, val);
  510. break;
  511. case KVM_REG_PPC_FPR0 ... KVM_REG_PPC_FPR31:
  512. i = reg->id - KVM_REG_PPC_FPR0;
  513. vcpu->arch.fpr[i] = set_reg_val(reg->id, val);
  514. break;
  515. case KVM_REG_PPC_FPSCR:
  516. vcpu->arch.fpscr = set_reg_val(reg->id, val);
  517. break;
  518. #ifdef CONFIG_ALTIVEC
  519. case KVM_REG_PPC_VR0 ... KVM_REG_PPC_VR31:
  520. if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
  521. r = -ENXIO;
  522. break;
  523. }
  524. vcpu->arch.vr[reg->id - KVM_REG_PPC_VR0] = val.vval;
  525. break;
  526. case KVM_REG_PPC_VSCR:
  527. if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
  528. r = -ENXIO;
  529. break;
  530. }
  531. vcpu->arch.vscr.u[3] = set_reg_val(reg->id, val);
  532. break;
  533. case KVM_REG_PPC_VRSAVE:
  534. if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
  535. r = -ENXIO;
  536. break;
  537. }
  538. vcpu->arch.vrsave = set_reg_val(reg->id, val);
  539. break;
  540. #endif /* CONFIG_ALTIVEC */
  541. #ifdef CONFIG_KVM_XICS
  542. case KVM_REG_PPC_ICP_STATE:
  543. if (!vcpu->arch.icp) {
  544. r = -ENXIO;
  545. break;
  546. }
  547. r = kvmppc_xics_set_icp(vcpu,
  548. set_reg_val(reg->id, val));
  549. break;
  550. #endif /* CONFIG_KVM_XICS */
  551. default:
  552. r = -EINVAL;
  553. break;
  554. }
  555. }
  556. return r;
  557. }
  558. void kvmppc_core_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
  559. {
  560. kvmppc_ops->vcpu_load(vcpu, cpu);
  561. }
  562. void kvmppc_core_vcpu_put(struct kvm_vcpu *vcpu)
  563. {
  564. kvmppc_ops->vcpu_put(vcpu);
  565. }
  566. void kvmppc_set_msr(struct kvm_vcpu *vcpu, u64 msr)
  567. {
  568. kvmppc_ops->set_msr(vcpu, msr);
  569. }
  570. int kvmppc_vcpu_run(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
  571. {
  572. return kvmppc_ops->vcpu_run(kvm_run, vcpu);
  573. }
  574. int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
  575. struct kvm_translation *tr)
  576. {
  577. return 0;
  578. }
  579. int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
  580. struct kvm_guest_debug *dbg)
  581. {
  582. return -EINVAL;
  583. }
  584. void kvmppc_decrementer_func(unsigned long data)
  585. {
  586. struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data;
  587. kvmppc_core_queue_dec(vcpu);
  588. kvm_vcpu_kick(vcpu);
  589. }
  590. struct kvm_vcpu *kvmppc_core_vcpu_create(struct kvm *kvm, unsigned int id)
  591. {
  592. return kvmppc_ops->vcpu_create(kvm, id);
  593. }
  594. void kvmppc_core_vcpu_free(struct kvm_vcpu *vcpu)
  595. {
  596. kvmppc_ops->vcpu_free(vcpu);
  597. }
  598. int kvmppc_core_check_requests(struct kvm_vcpu *vcpu)
  599. {
  600. return kvmppc_ops->check_requests(vcpu);
  601. }
  602. int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log)
  603. {
  604. return kvmppc_ops->get_dirty_log(kvm, log);
  605. }
  606. void kvmppc_core_free_memslot(struct kvm_memory_slot *free,
  607. struct kvm_memory_slot *dont)
  608. {
  609. kvmppc_ops->free_memslot(free, dont);
  610. }
  611. int kvmppc_core_create_memslot(struct kvm_memory_slot *slot,
  612. unsigned long npages)
  613. {
  614. return kvmppc_ops->create_memslot(slot, npages);
  615. }
  616. void kvmppc_core_flush_memslot(struct kvm *kvm, struct kvm_memory_slot *memslot)
  617. {
  618. kvmppc_ops->flush_memslot(kvm, memslot);
  619. }
  620. int kvmppc_core_prepare_memory_region(struct kvm *kvm,
  621. struct kvm_memory_slot *memslot,
  622. struct kvm_userspace_memory_region *mem)
  623. {
  624. return kvmppc_ops->prepare_memory_region(kvm, memslot, mem);
  625. }
  626. void kvmppc_core_commit_memory_region(struct kvm *kvm,
  627. struct kvm_userspace_memory_region *mem,
  628. const struct kvm_memory_slot *old)
  629. {
  630. kvmppc_ops->commit_memory_region(kvm, mem, old);
  631. }
  632. int kvm_unmap_hva(struct kvm *kvm, unsigned long hva)
  633. {
  634. return kvmppc_ops->unmap_hva(kvm, hva);
  635. }
  636. int kvm_unmap_hva_range(struct kvm *kvm, unsigned long start, unsigned long end)
  637. {
  638. return kvmppc_ops->unmap_hva_range(kvm, start, end);
  639. }
  640. int kvm_age_hva(struct kvm *kvm, unsigned long hva)
  641. {
  642. return kvmppc_ops->age_hva(kvm, hva);
  643. }
  644. int kvm_test_age_hva(struct kvm *kvm, unsigned long hva)
  645. {
  646. return kvmppc_ops->test_age_hva(kvm, hva);
  647. }
  648. void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte)
  649. {
  650. kvmppc_ops->set_spte_hva(kvm, hva, pte);
  651. }
  652. void kvmppc_mmu_destroy(struct kvm_vcpu *vcpu)
  653. {
  654. kvmppc_ops->mmu_destroy(vcpu);
  655. }
  656. int kvmppc_core_init_vm(struct kvm *kvm)
  657. {
  658. #ifdef CONFIG_PPC64
  659. INIT_LIST_HEAD(&kvm->arch.spapr_tce_tables);
  660. INIT_LIST_HEAD(&kvm->arch.rtas_tokens);
  661. #endif
  662. return kvmppc_ops->init_vm(kvm);
  663. }
  664. void kvmppc_core_destroy_vm(struct kvm *kvm)
  665. {
  666. kvmppc_ops->destroy_vm(kvm);
  667. #ifdef CONFIG_PPC64
  668. kvmppc_rtas_tokens_free(kvm);
  669. WARN_ON(!list_empty(&kvm->arch.spapr_tce_tables));
  670. #endif
  671. }
  672. int kvmppc_core_check_processor_compat(void)
  673. {
  674. return kvmppc_ops->check_processor_compat();
  675. }