]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - arch/powerpc/kvm/powerpc.c
projects / mirror_ubuntu-zesty-kernel.git / blob
? search:


40a5b2d75ed19979aa0b52246d1c7951ecf0a367
[mirror_ubuntu-zesty-kernel.git] / arch / powerpc / kvm / powerpc.c
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 *
17 * Authors: Hollis Blanchard <hollisb@us.ibm.com>
18 * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
19 */
20
21 #include <linux/errno.h>
22 #include <linux/err.h>
23 #include <linux/kvm_host.h>
24 #include <linux/vmalloc.h>
25 #include <linux/hrtimer.h>
26 #include <linux/fs.h>
27 #include <linux/slab.h>
28 #include <linux/file.h>
29 #include <linux/module.h>
30 #include <linux/irqbypass.h>
31 #include <linux/kvm_irqfd.h>
32 #include <asm/cputable.h>
33 #include <linux/uaccess.h>
34 #include <asm/kvm_ppc.h>
35 #include <asm/tlbflush.h>
36 #include <asm/cputhreads.h>
37 #include <asm/irqflags.h>
38 #include <asm/iommu.h>
39 #include "timing.h"
40 #include "irq.h"
41 #include "../mm/mmu_decl.h"
42
43 #define CREATE_TRACE_POINTS
44 #include "trace.h"
45
46 struct kvmppc_ops *kvmppc_hv_ops;
47 EXPORT_SYMBOL_GPL(kvmppc_hv_ops);
48 struct kvmppc_ops *kvmppc_pr_ops;
49 EXPORT_SYMBOL_GPL(kvmppc_pr_ops);
50
51
52 int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
53 {
54 return !!(v->arch.pending_exceptions) ||
55 v->requests;
56 }
57
58 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
59 {
60 return 1;
61 }
62
63 /*
64 * Common checks before entering the guest world. Call with interrupts
65 * disabled.
66 *
67 * returns:
68 *
69 * == 1 if we're ready to go into guest state
70 * <= 0 if we need to go back to the host with return value
71 */
72 int kvmppc_prepare_to_enter(struct kvm_vcpu *vcpu)
73 {
74 int r;
75
76 WARN_ON(irqs_disabled());
77 hard_irq_disable();
78
79 while (true) {
80 if (need_resched()) {
81 local_irq_enable();
82 cond_resched();
83 hard_irq_disable();
84 continue;
85 }
86
87 if (signal_pending(current)) {
88 kvmppc_account_exit(vcpu, SIGNAL_EXITS);
89 vcpu->run->exit_reason = KVM_EXIT_INTR;
90 r = -EINTR;
91 break;
92 }
93
94 vcpu->mode = IN_GUEST_MODE;
95
96 /*
97 * Reading vcpu->requests must happen after setting vcpu->mode,
98 * so we don't miss a request because the requester sees
99 * OUTSIDE_GUEST_MODE and assumes we'll be checking requests
100 * before next entering the guest (and thus doesn't IPI).
101 * This also orders the write to mode from any reads
102 * to the page tables done while the VCPU is running.
103 * Please see the comment in kvm_flush_remote_tlbs.
104 */
105 smp_mb();
106
107 if (vcpu->requests) {
108 /* Make sure we process requests preemptable */
109 local_irq_enable();
110 trace_kvm_check_requests(vcpu);
111 r = kvmppc_core_check_requests(vcpu);
112 hard_irq_disable();
113 if (r > 0)
114 continue;
115 break;
116 }
117
118 if (kvmppc_core_prepare_to_enter(vcpu)) {
119 /* interrupts got enabled in between, so we
120 are back at square 1 */
121 continue;
122 }
123
124 guest_enter_irqoff();
125 return 1;
126 }
127
128 /* return to host */
129 local_irq_enable();
130 return r;
131 }
132 EXPORT_SYMBOL_GPL(kvmppc_prepare_to_enter);
133
134 #if defined(CONFIG_PPC_BOOK3S_64) && defined(CONFIG_KVM_BOOK3S_PR_POSSIBLE)
135 static void kvmppc_swab_shared(struct kvm_vcpu *vcpu)
136 {
137 struct kvm_vcpu_arch_shared *shared = vcpu->arch.shared;
138 int i;
139
140 shared->sprg0 = swab64(shared->sprg0);
141 shared->sprg1 = swab64(shared->sprg1);
142 shared->sprg2 = swab64(shared->sprg2);
143 shared->sprg3 = swab64(shared->sprg3);
144 shared->srr0 = swab64(shared->srr0);
145 shared->srr1 = swab64(shared->srr1);
146 shared->dar = swab64(shared->dar);
147 shared->msr = swab64(shared->msr);
148 shared->dsisr = swab32(shared->dsisr);
149 shared->int_pending = swab32(shared->int_pending);
150 for (i = 0; i < ARRAY_SIZE(shared->sr); i++)
151 shared->sr[i] = swab32(shared->sr[i]);
152 }
153 #endif
154
155 int kvmppc_kvm_pv(struct kvm_vcpu *vcpu)
156 {
157 int nr = kvmppc_get_gpr(vcpu, 11);
158 int r;
159 unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3);
160 unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4);
161 unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5);
162 unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6);
163 unsigned long r2 = 0;
164
165 if (!(kvmppc_get_msr(vcpu) & MSR_SF)) {
166 /* 32 bit mode */
167 param1 &= 0xffffffff;
168 param2 &= 0xffffffff;
169 param3 &= 0xffffffff;
170 param4 &= 0xffffffff;
171 }
172
173 switch (nr) {
174 case KVM_HCALL_TOKEN(KVM_HC_PPC_MAP_MAGIC_PAGE):
175 {
176 #if defined(CONFIG_PPC_BOOK3S_64) && defined(CONFIG_KVM_BOOK3S_PR_POSSIBLE)
177 /* Book3S can be little endian, find it out here */
178 int shared_big_endian = true;
179 if (vcpu->arch.intr_msr & MSR_LE)
180 shared_big_endian = false;
181 if (shared_big_endian != vcpu->arch.shared_big_endian)
182 kvmppc_swab_shared(vcpu);
183 vcpu->arch.shared_big_endian = shared_big_endian;
184 #endif
185
186 if (!(param2 & MAGIC_PAGE_FLAG_NOT_MAPPED_NX)) {
187 /*
188 * Older versions of the Linux magic page code had
189 * a bug where they would map their trampoline code
190 * NX. If that's the case, remove !PR NX capability.
191 */
192 vcpu->arch.disable_kernel_nx = true;
193 kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
194 }
195
196 vcpu->arch.magic_page_pa = param1 & ~0xfffULL;
197 vcpu->arch.magic_page_ea = param2 & ~0xfffULL;
198
199 #ifdef CONFIG_PPC_64K_PAGES
200 /*
201 * Make sure our 4k magic page is in the same window of a 64k
202 * page within the guest and within the host's page.
203 */
204 if ((vcpu->arch.magic_page_pa & 0xf000) !=
205 ((ulong)vcpu->arch.shared & 0xf000)) {
206 void *old_shared = vcpu->arch.shared;
207 ulong shared = (ulong)vcpu->arch.shared;
208 void *new_shared;
209
210 shared &= PAGE_MASK;
211 shared |= vcpu->arch.magic_page_pa & 0xf000;
212 new_shared = (void*)shared;
213 memcpy(new_shared, old_shared, 0x1000);
214 vcpu->arch.shared = new_shared;
215 }
216 #endif
217
218 r2 = KVM_MAGIC_FEAT_SR | KVM_MAGIC_FEAT_MAS0_TO_SPRG7;
219
220 r = EV_SUCCESS;
221 break;
222 }
223 case KVM_HCALL_TOKEN(KVM_HC_FEATURES):
224 r = EV_SUCCESS;
225 #if defined(CONFIG_PPC_BOOK3S) || defined(CONFIG_KVM_E500V2)
226 r2 |= (1 << KVM_FEATURE_MAGIC_PAGE);
227 #endif
228
229 /* Second return value is in r4 */
230 break;
231 case EV_HCALL_TOKEN(EV_IDLE):
232 r = EV_SUCCESS;
233 kvm_vcpu_block(vcpu);
234 clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
235 break;
236 default:
237 r = EV_UNIMPLEMENTED;
238 break;
239 }
240
241 kvmppc_set_gpr(vcpu, 4, r2);
242
243 return r;
244 }
245 EXPORT_SYMBOL_GPL(kvmppc_kvm_pv);
246
247 int kvmppc_sanity_check(struct kvm_vcpu *vcpu)
248 {
249 int r = false;
250
251 /* We have to know what CPU to virtualize */
252 if (!vcpu->arch.pvr)
253 goto out;
254
255 /* PAPR only works with book3s_64 */
256 if ((vcpu->arch.cpu_type != KVM_CPU_3S_64) && vcpu->arch.papr_enabled)
257 goto out;
258
259 /* HV KVM can only do PAPR mode for now */
260 if (!vcpu->arch.papr_enabled && is_kvmppc_hv_enabled(vcpu->kvm))
261 goto out;
262
263 #ifdef CONFIG_KVM_BOOKE_HV
264 if (!cpu_has_feature(CPU_FTR_EMB_HV))
265 goto out;
266 #endif
267
268 r = true;
269
270 out:
271 vcpu->arch.sane = r;
272 return r ? 0 : -EINVAL;
273 }
274 EXPORT_SYMBOL_GPL(kvmppc_sanity_check);
275
276 int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu)
277 {
278 enum emulation_result er;
279 int r;
280
281 er = kvmppc_emulate_loadstore(vcpu);
282 switch (er) {
283 case EMULATE_DONE:
284 /* Future optimization: only reload non-volatiles if they were
285 * actually modified. */
286 r = RESUME_GUEST_NV;
287 break;
288 case EMULATE_AGAIN:
289 r = RESUME_GUEST;
290 break;
291 case EMULATE_DO_MMIO:
292 run->exit_reason = KVM_EXIT_MMIO;
293 /* We must reload nonvolatiles because "update" load/store
294 * instructions modify register state. */
295 /* Future optimization: only reload non-volatiles if they were
296 * actually modified. */
297 r = RESUME_HOST_NV;
298 break;
299 case EMULATE_FAIL:
300 {
301 u32 last_inst;
302
303 kvmppc_get_last_inst(vcpu, INST_GENERIC, &last_inst);
304 /* XXX Deliver Program interrupt to guest. */
305 pr_emerg("%s: emulation failed (%08x)\n", __func__, last_inst);
306 r = RESUME_HOST;
307 break;
308 }
309 default:
310 WARN_ON(1);
311 r = RESUME_GUEST;
312 }
313
314 return r;
315 }
316 EXPORT_SYMBOL_GPL(kvmppc_emulate_mmio);
317
318 int kvmppc_st(struct kvm_vcpu *vcpu, ulong *eaddr, int size, void *ptr,
319 bool data)
320 {
321 ulong mp_pa = vcpu->arch.magic_page_pa & KVM_PAM & PAGE_MASK;
322 struct kvmppc_pte pte;
323 int r;
324
325 vcpu->stat.st++;
326
327 r = kvmppc_xlate(vcpu, *eaddr, data ? XLATE_DATA : XLATE_INST,
328 XLATE_WRITE, &pte);
329 if (r < 0)
330 return r;
331
332 *eaddr = pte.raddr;
333
334 if (!pte.may_write)
335 return -EPERM;
336
337 /* Magic page override */
338 if (kvmppc_supports_magic_page(vcpu) && mp_pa &&
339 ((pte.raddr & KVM_PAM & PAGE_MASK) == mp_pa) &&
340 !(kvmppc_get_msr(vcpu) & MSR_PR)) {
341 void *magic = vcpu->arch.shared;
342 magic += pte.eaddr & 0xfff;
343 memcpy(magic, ptr, size);
344 return EMULATE_DONE;
345 }
346
347 if (kvm_write_guest(vcpu->kvm, pte.raddr, ptr, size))
348 return EMULATE_DO_MMIO;
349
350 return EMULATE_DONE;
351 }
352 EXPORT_SYMBOL_GPL(kvmppc_st);
353
354 int kvmppc_ld(struct kvm_vcpu *vcpu, ulong *eaddr, int size, void *ptr,
355 bool data)
356 {
357 ulong mp_pa = vcpu->arch.magic_page_pa & KVM_PAM & PAGE_MASK;
358 struct kvmppc_pte pte;
359 int rc;
360
361 vcpu->stat.ld++;
362
363 rc = kvmppc_xlate(vcpu, *eaddr, data ? XLATE_DATA : XLATE_INST,
364 XLATE_READ, &pte);
365 if (rc)
366 return rc;
367
368 *eaddr = pte.raddr;
369
370 if (!pte.may_read)
371 return -EPERM;
372
373 if (!data && !pte.may_execute)
374 return -ENOEXEC;
375
376 /* Magic page override */
377 if (kvmppc_supports_magic_page(vcpu) && mp_pa &&
378 ((pte.raddr & KVM_PAM & PAGE_MASK) == mp_pa) &&
379 !(kvmppc_get_msr(vcpu) & MSR_PR)) {
380 void *magic = vcpu->arch.shared;
381 magic += pte.eaddr & 0xfff;
382 memcpy(ptr, magic, size);
383 return EMULATE_DONE;
384 }
385
386 if (kvm_read_guest(vcpu->kvm, pte.raddr, ptr, size))
387 return EMULATE_DO_MMIO;
388
389 return EMULATE_DONE;
390 }
391 EXPORT_SYMBOL_GPL(kvmppc_ld);
392
393 int kvm_arch_hardware_enable(void)
394 {
395 return 0;
396 }
397
398 int kvm_arch_hardware_setup(void)
399 {
400 return 0;
401 }
402
403 void kvm_arch_check_processor_compat(void *rtn)
404 {
405 *(int *)rtn = kvmppc_core_check_processor_compat();
406 }
407
408 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
409 {
410 struct kvmppc_ops *kvm_ops = NULL;
411 /*
412 * if we have both HV and PR enabled, default is HV
413 */
414 if (type == 0) {
415 if (kvmppc_hv_ops)
416 kvm_ops = kvmppc_hv_ops;
417 else
418 kvm_ops = kvmppc_pr_ops;
419 if (!kvm_ops)
420 goto err_out;
421 } else if (type == KVM_VM_PPC_HV) {
422 if (!kvmppc_hv_ops)
423 goto err_out;
424 kvm_ops = kvmppc_hv_ops;
425 } else if (type == KVM_VM_PPC_PR) {
426 if (!kvmppc_pr_ops)
427 goto err_out;
428 kvm_ops = kvmppc_pr_ops;
429 } else
430 goto err_out;
431
432 if (kvm_ops->owner && !try_module_get(kvm_ops->owner))
433 return -ENOENT;
434
435 kvm->arch.kvm_ops = kvm_ops;
436 return kvmppc_core_init_vm(kvm);
437 err_out:
438 return -EINVAL;
439 }
440
441 bool kvm_arch_has_vcpu_debugfs(void)
442 {
443 return false;
444 }
445
446 int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
447 {
448 return 0;
449 }
450
451 void kvm_arch_destroy_vm(struct kvm *kvm)
452 {
453 unsigned int i;
454 struct kvm_vcpu *vcpu;
455
456 #ifdef CONFIG_KVM_XICS
457 /*
458 * We call kick_all_cpus_sync() to ensure that all
459 * CPUs have executed any pending IPIs before we
460 * continue and free VCPUs structures below.
461 */
462 if (is_kvmppc_hv_enabled(kvm))
463 kick_all_cpus_sync();
464 #endif
465
466 kvm_for_each_vcpu(i, vcpu, kvm)
467 kvm_arch_vcpu_free(vcpu);
468
469 mutex_lock(&kvm->lock);
470 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
471 kvm->vcpus[i] = NULL;
472
473 atomic_set(&kvm->online_vcpus, 0);
474
475 kvmppc_core_destroy_vm(kvm);
476
477 mutex_unlock(&kvm->lock);
478
479 /* drop the module reference */
480 module_put(kvm->arch.kvm_ops->owner);
481 }
482
483 int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
484 {
485 int r;
486 /* Assume we're using HV mode when the HV module is loaded */
487 int hv_enabled = kvmppc_hv_ops ? 1 : 0;
488
489 if (kvm) {
490 /*
491 * Hooray - we know which VM type we're running on. Depend on
492 * that rather than the guess above.
493 */
494 hv_enabled = is_kvmppc_hv_enabled(kvm);
495 }
496
497 switch (ext) {
498 #ifdef CONFIG_BOOKE
499 case KVM_CAP_PPC_BOOKE_SREGS:
500 case KVM_CAP_PPC_BOOKE_WATCHDOG:
501 case KVM_CAP_PPC_EPR:
502 #else
503 case KVM_CAP_PPC_SEGSTATE:
504 case KVM_CAP_PPC_HIOR:
505 case KVM_CAP_PPC_PAPR:
506 #endif
507 case KVM_CAP_PPC_UNSET_IRQ:
508 case KVM_CAP_PPC_IRQ_LEVEL:
509 case KVM_CAP_ENABLE_CAP:
510 case KVM_CAP_ENABLE_CAP_VM:
511 case KVM_CAP_ONE_REG:
512 case KVM_CAP_IOEVENTFD:
513 case KVM_CAP_DEVICE_CTRL:
514 r = 1;
515 break;
516 case KVM_CAP_PPC_PAIRED_SINGLES:
517 case KVM_CAP_PPC_OSI:
518 case KVM_CAP_PPC_GET_PVINFO:
519 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
520 case KVM_CAP_SW_TLB:
521 #endif
522 /* We support this only for PR */
523 r = !hv_enabled;
524 break;
525 #ifdef CONFIG_KVM_MMIO
526 case KVM_CAP_COALESCED_MMIO:
527 r = KVM_COALESCED_MMIO_PAGE_OFFSET;
528 break;
529 #endif
530 #ifdef CONFIG_KVM_MPIC
531 case KVM_CAP_IRQ_MPIC:
532 r = 1;
533 break;
534 #endif
535
536 #ifdef CONFIG_PPC_BOOK3S_64
537 case KVM_CAP_SPAPR_TCE:
538 case KVM_CAP_SPAPR_TCE_64:
539 case KVM_CAP_PPC_RTAS:
540 case KVM_CAP_PPC_FIXUP_HCALL:
541 case KVM_CAP_PPC_ENABLE_HCALL:
542 #ifdef CONFIG_KVM_XICS
543 case KVM_CAP_IRQ_XICS:
544 #endif
545 r = 1;
546 break;
547
548 case KVM_CAP_PPC_ALLOC_HTAB:
549 r = hv_enabled;
550 break;
551 #endif /* CONFIG_PPC_BOOK3S_64 */
552 #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
553 case KVM_CAP_PPC_SMT:
554 r = 0;
555 if (hv_enabled) {
556 if (cpu_has_feature(CPU_FTR_ARCH_300))
557 r = 1;
558 else
559 r = threads_per_subcore;
560 }
561 break;
562 case KVM_CAP_PPC_RMA:
563 r = 0;
564 break;
565 case KVM_CAP_PPC_HWRNG:
566 r = kvmppc_hwrng_present();
567 break;
568 case KVM_CAP_PPC_MMU_RADIX:
569 r = !!(hv_enabled && radix_enabled());
570 break;
571 case KVM_CAP_PPC_MMU_HASH_V3:
572 r = !!(hv_enabled && !radix_enabled() &&
573 cpu_has_feature(CPU_FTR_ARCH_300));
574 break;
575 #endif
576 case KVM_CAP_SYNC_MMU:
577 #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
578 r = hv_enabled;
579 #elif defined(KVM_ARCH_WANT_MMU_NOTIFIER)
580 r = 1;
581 #else
582 r = 0;
583 #endif
584 break;
585 #ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
586 case KVM_CAP_PPC_HTAB_FD:
587 r = hv_enabled;
588 break;
589 #endif
590 case KVM_CAP_NR_VCPUS:
591 /*
592 * Recommending a number of CPUs is somewhat arbitrary; we
593 * return the number of present CPUs for -HV (since a host
594 * will have secondary threads "offline"), and for other KVM
595 * implementations just count online CPUs.
596 */
597 if (hv_enabled)
598 r = num_present_cpus();
599 else
600 r = num_online_cpus();
601 break;
602 case KVM_CAP_NR_MEMSLOTS:
603 r = KVM_USER_MEM_SLOTS;
604 break;
605 case KVM_CAP_MAX_VCPUS:
606 r = KVM_MAX_VCPUS;
607 break;
608 #ifdef CONFIG_PPC_BOOK3S_64
609 case KVM_CAP_PPC_GET_SMMU_INFO:
610 r = 1;
611 break;
612 case KVM_CAP_SPAPR_MULTITCE:
613 r = 1;
614 break;
615 #endif
616 case KVM_CAP_PPC_HTM:
617 r = cpu_has_feature(CPU_FTR_TM_COMP) &&
618 is_kvmppc_hv_enabled(kvm);
619 break;
620 default:
621 r = 0;
622 break;
623 }
624 return r;
625
626 }
627
628 long kvm_arch_dev_ioctl(struct file *filp,
629 unsigned int ioctl, unsigned long arg)
630 {
631 return -EINVAL;
632 }
633
634 void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
635 struct kvm_memory_slot *dont)
636 {
637 kvmppc_core_free_memslot(kvm, free, dont);
638 }
639
640 int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
641 unsigned long npages)
642 {
643 return kvmppc_core_create_memslot(kvm, slot, npages);
644 }
645
646 int kvm_arch_prepare_memory_region(struct kvm *kvm,
647 struct kvm_memory_slot *memslot,
648 const struct kvm_userspace_memory_region *mem,
649 enum kvm_mr_change change)
650 {
651 return kvmppc_core_prepare_memory_region(kvm, memslot, mem);
652 }
653
654 void kvm_arch_commit_memory_region(struct kvm *kvm,
655 const struct kvm_userspace_memory_region *mem,
656 const struct kvm_memory_slot *old,
657 const struct kvm_memory_slot *new,
658 enum kvm_mr_change change)
659 {
660 kvmppc_core_commit_memory_region(kvm, mem, old, new);
661 }
662
663 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
664 struct kvm_memory_slot *slot)
665 {
666 kvmppc_core_flush_memslot(kvm, slot);
667 }
668
669 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id)
670 {
671 struct kvm_vcpu *vcpu;
672 vcpu = kvmppc_core_vcpu_create(kvm, id);
673 if (!IS_ERR(vcpu)) {
674 vcpu->arch.wqp = &vcpu->wq;
675 kvmppc_create_vcpu_debugfs(vcpu, id);
676 }
677 return vcpu;
678 }
679
680 void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
681 {
682 }
683
684 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
685 {
686 /* Make sure we're not using the vcpu anymore */
687 hrtimer_cancel(&vcpu->arch.dec_timer);
688
689 kvmppc_remove_vcpu_debugfs(vcpu);
690
691 switch (vcpu->arch.irq_type) {
692 case KVMPPC_IRQ_MPIC:
693 kvmppc_mpic_disconnect_vcpu(vcpu->arch.mpic, vcpu);
694 break;
695 case KVMPPC_IRQ_XICS:
696 kvmppc_xics_free_icp(vcpu);
697 break;
698 }
699
700 kvmppc_core_vcpu_free(vcpu);
701 }
702
703 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
704 {
705 kvm_arch_vcpu_free(vcpu);
706 }
707
708 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
709 {
710 return kvmppc_core_pending_dec(vcpu);
711 }
712
713 static enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer)
714 {
715 struct kvm_vcpu *vcpu;
716
717 vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer);
718 kvmppc_decrementer_func(vcpu);
719
720 return HRTIMER_NORESTART;
721 }
722
723 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
724 {
725 int ret;
726
727 hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
728 vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup;
729 vcpu->arch.dec_expires = ~(u64)0;
730
731 #ifdef CONFIG_KVM_EXIT_TIMING
732 mutex_init(&vcpu->arch.exit_timing_lock);
733 #endif
734 ret = kvmppc_subarch_vcpu_init(vcpu);
735 return ret;
736 }
737
738 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
739 {
740 kvmppc_mmu_destroy(vcpu);
741 kvmppc_subarch_vcpu_uninit(vcpu);
742 }
743
744 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
745 {
746 #ifdef CONFIG_BOOKE
747 /*
748 * vrsave (formerly usprg0) isn't used by Linux, but may
749 * be used by the guest.
750 *
751 * On non-booke this is associated with Altivec and
752 * is handled by code in book3s.c.
753 */
754 mtspr(SPRN_VRSAVE, vcpu->arch.vrsave);
755 #endif
756 kvmppc_core_vcpu_load(vcpu, cpu);
757 }
758
759 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
760 {
761 kvmppc_core_vcpu_put(vcpu);
762 #ifdef CONFIG_BOOKE
763 vcpu->arch.vrsave = mfspr(SPRN_VRSAVE);
764 #endif
765 }
766
767 /*
768 * irq_bypass_add_producer and irq_bypass_del_producer are only
769 * useful if the architecture supports PCI passthrough.
770 * irq_bypass_stop and irq_bypass_start are not needed and so
771 * kvm_ops are not defined for them.
772 */
773 bool kvm_arch_has_irq_bypass(void)
774 {
775 return ((kvmppc_hv_ops && kvmppc_hv_ops->irq_bypass_add_producer) ||
776 (kvmppc_pr_ops && kvmppc_pr_ops->irq_bypass_add_producer));
777 }
778
779 int kvm_arch_irq_bypass_add_producer(struct irq_bypass_consumer *cons,
780 struct irq_bypass_producer *prod)
781 {
782 struct kvm_kernel_irqfd *irqfd =
783 container_of(cons, struct kvm_kernel_irqfd, consumer);
784 struct kvm *kvm = irqfd->kvm;
785
786 if (kvm->arch.kvm_ops->irq_bypass_add_producer)
787 return kvm->arch.kvm_ops->irq_bypass_add_producer(cons, prod);
788
789 return 0;
790 }
791
792 void kvm_arch_irq_bypass_del_producer(struct irq_bypass_consumer *cons,
793 struct irq_bypass_producer *prod)
794 {
795 struct kvm_kernel_irqfd *irqfd =
796 container_of(cons, struct kvm_kernel_irqfd, consumer);
797 struct kvm *kvm = irqfd->kvm;
798
799 if (kvm->arch.kvm_ops->irq_bypass_del_producer)
800 kvm->arch.kvm_ops->irq_bypass_del_producer(cons, prod);
801 }
802
803 static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu,
804 struct kvm_run *run)
805 {
806 u64 uninitialized_var(gpr);
807
808 if (run->mmio.len > sizeof(gpr)) {
809 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len);
810 return;
811 }
812
813 if (!vcpu->arch.mmio_host_swabbed) {
814 switch (run->mmio.len) {
815 case 8: gpr = *(u64 *)run->mmio.data; break;
816 case 4: gpr = *(u32 *)run->mmio.data; break;
817 case 2: gpr = *(u16 *)run->mmio.data; break;
818 case 1: gpr = *(u8 *)run->mmio.data; break;
819 }
820 } else {
821 switch (run->mmio.len) {
822 case 8: gpr = swab64(*(u64 *)run->mmio.data); break;
823 case 4: gpr = swab32(*(u32 *)run->mmio.data); break;
824 case 2: gpr = swab16(*(u16 *)run->mmio.data); break;
825 case 1: gpr = *(u8 *)run->mmio.data; break;
826 }
827 }
828
829 if (vcpu->arch.mmio_sign_extend) {
830 switch (run->mmio.len) {
831 #ifdef CONFIG_PPC64
832 case 4:
833 gpr = (s64)(s32)gpr;
834 break;
835 #endif
836 case 2:
837 gpr = (s64)(s16)gpr;
838 break;
839 case 1:
840 gpr = (s64)(s8)gpr;
841 break;
842 }
843 }
844
845 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
846
847 switch (vcpu->arch.io_gpr & KVM_MMIO_REG_EXT_MASK) {
848 case KVM_MMIO_REG_GPR:
849 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
850 break;
851 case KVM_MMIO_REG_FPR:
852 VCPU_FPR(vcpu, vcpu->arch.io_gpr & KVM_MMIO_REG_MASK) = gpr;
853 break;
854 #ifdef CONFIG_PPC_BOOK3S
855 case KVM_MMIO_REG_QPR:
856 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
857 break;
858 case KVM_MMIO_REG_FQPR:
859 VCPU_FPR(vcpu, vcpu->arch.io_gpr & KVM_MMIO_REG_MASK) = gpr;
860 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
861 break;
862 #endif
863 default:
864 BUG();
865 }
866 }
867
868 static int __kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
869 unsigned int rt, unsigned int bytes,
870 int is_default_endian, int sign_extend)
871 {
872 int idx, ret;
873 bool host_swabbed;
874
875 /* Pity C doesn't have a logical XOR operator */
876 if (kvmppc_need_byteswap(vcpu)) {
877 host_swabbed = is_default_endian;
878 } else {
879 host_swabbed = !is_default_endian;
880 }
881
882 if (bytes > sizeof(run->mmio.data)) {
883 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
884 run->mmio.len);
885 }
886
887 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
888 run->mmio.len = bytes;
889 run->mmio.is_write = 0;
890
891 vcpu->arch.io_gpr = rt;
892 vcpu->arch.mmio_host_swabbed = host_swabbed;
893 vcpu->mmio_needed = 1;
894 vcpu->mmio_is_write = 0;
895 vcpu->arch.mmio_sign_extend = sign_extend;
896
897 idx = srcu_read_lock(&vcpu->kvm->srcu);
898
899 ret = kvm_io_bus_read(vcpu, KVM_MMIO_BUS, run->mmio.phys_addr,
900 bytes, &run->mmio.data);
901
902 srcu_read_unlock(&vcpu->kvm->srcu, idx);
903
904 if (!ret) {
905 kvmppc_complete_mmio_load(vcpu, run);
906 vcpu->mmio_needed = 0;
907 return EMULATE_DONE;
908 }
909
910 return EMULATE_DO_MMIO;
911 }
912
913 int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
914 unsigned int rt, unsigned int bytes,
915 int is_default_endian)
916 {
917 return __kvmppc_handle_load(run, vcpu, rt, bytes, is_default_endian, 0);
918 }
919 EXPORT_SYMBOL_GPL(kvmppc_handle_load);
920
921 /* Same as above, but sign extends */
922 int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu,
923 unsigned int rt, unsigned int bytes,
924 int is_default_endian)
925 {
926 return __kvmppc_handle_load(run, vcpu, rt, bytes, is_default_endian, 1);
927 }
928
929 int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu,
930 u64 val, unsigned int bytes, int is_default_endian)
931 {
932 void *data = run->mmio.data;
933 int idx, ret;
934 bool host_swabbed;
935
936 /* Pity C doesn't have a logical XOR operator */
937 if (kvmppc_need_byteswap(vcpu)) {
938 host_swabbed = is_default_endian;
939 } else {
940 host_swabbed = !is_default_endian;
941 }
942
943 if (bytes > sizeof(run->mmio.data)) {
944 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
945 run->mmio.len);
946 }
947
948 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
949 run->mmio.len = bytes;
950 run->mmio.is_write = 1;
951 vcpu->mmio_needed = 1;
952 vcpu->mmio_is_write = 1;
953
954 /* Store the value at the lowest bytes in 'data'. */
955 if (!host_swabbed) {
956 switch (bytes) {
957 case 8: *(u64 *)data = val; break;
958 case 4: *(u32 *)data = val; break;
959 case 2: *(u16 *)data = val; break;
960 case 1: *(u8 *)data = val; break;
961 }
962 } else {
963 switch (bytes) {
964 case 8: *(u64 *)data = swab64(val); break;
965 case 4: *(u32 *)data = swab32(val); break;
966 case 2: *(u16 *)data = swab16(val); break;
967 case 1: *(u8 *)data = val; break;
968 }
969 }
970
971 idx = srcu_read_lock(&vcpu->kvm->srcu);
972
973 ret = kvm_io_bus_write(vcpu, KVM_MMIO_BUS, run->mmio.phys_addr,
974 bytes, &run->mmio.data);
975
976 srcu_read_unlock(&vcpu->kvm->srcu, idx);
977
978 if (!ret) {
979 vcpu->mmio_needed = 0;
980 return EMULATE_DONE;
981 }
982
983 return EMULATE_DO_MMIO;
984 }
985 EXPORT_SYMBOL_GPL(kvmppc_handle_store);
986
987 int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
988 {
989 int r = 0;
990 union kvmppc_one_reg val;
991 int size;
992
993 size = one_reg_size(reg->id);
994 if (size > sizeof(val))
995 return -EINVAL;
996
997 r = kvmppc_get_one_reg(vcpu, reg->id, &val);
998 if (r == -EINVAL) {
999 r = 0;
1000 switch (reg->id) {
1001 #ifdef CONFIG_ALTIVEC
1002 case KVM_REG_PPC_VR0 ... KVM_REG_PPC_VR31:
1003 if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
1004 r = -ENXIO;
1005 break;
1006 }
1007 val.vval = vcpu->arch.vr.vr[reg->id - KVM_REG_PPC_VR0];
1008 break;
1009 case KVM_REG_PPC_VSCR:
1010 if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
1011 r = -ENXIO;
1012 break;
1013 }
1014 val = get_reg_val(reg->id, vcpu->arch.vr.vscr.u[3]);
1015 break;
1016 case KVM_REG_PPC_VRSAVE:
1017 val = get_reg_val(reg->id, vcpu->arch.vrsave);
1018 break;
1019 #endif /* CONFIG_ALTIVEC */
1020 default:
1021 r = -EINVAL;
1022 break;
1023 }
1024 }
1025
1026 if (r)
1027 return r;
1028
1029 if (copy_to_user((char __user *)(unsigned long)reg->addr, &val, size))
1030 r = -EFAULT;
1031
1032 return r;
1033 }
1034
1035 int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
1036 {
1037 int r;
1038 union kvmppc_one_reg val;
1039 int size;
1040
1041 size = one_reg_size(reg->id);
1042 if (size > sizeof(val))
1043 return -EINVAL;
1044
1045 if (copy_from_user(&val, (char __user *)(unsigned long)reg->addr, size))
1046 return -EFAULT;
1047
1048 r = kvmppc_set_one_reg(vcpu, reg->id, &val);
1049 if (r == -EINVAL) {
1050 r = 0;
1051 switch (reg->id) {
1052 #ifdef CONFIG_ALTIVEC
1053 case KVM_REG_PPC_VR0 ... KVM_REG_PPC_VR31:
1054 if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
1055 r = -ENXIO;
1056 break;
1057 }
1058 vcpu->arch.vr.vr[reg->id - KVM_REG_PPC_VR0] = val.vval;
1059 break;
1060 case KVM_REG_PPC_VSCR:
1061 if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
1062 r = -ENXIO;
1063 break;
1064 }
1065 vcpu->arch.vr.vscr.u[3] = set_reg_val(reg->id, val);
1066 break;
1067 case KVM_REG_PPC_VRSAVE:
1068 if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
1069 r = -ENXIO;
1070 break;
1071 }
1072 vcpu->arch.vrsave = set_reg_val(reg->id, val);
1073 break;
1074 #endif /* CONFIG_ALTIVEC */
1075 default:
1076 r = -EINVAL;
1077 break;
1078 }
1079 }
1080
1081 return r;
1082 }
1083
1084 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
1085 {
1086 int r;
1087 sigset_t sigsaved;
1088
1089 if (vcpu->sigset_active)
1090 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
1091
1092 if (vcpu->mmio_needed) {
1093 if (!vcpu->mmio_is_write)
1094 kvmppc_complete_mmio_load(vcpu, run);
1095 vcpu->mmio_needed = 0;
1096 } else if (vcpu->arch.osi_needed) {
1097 u64 *gprs = run->osi.gprs;
1098 int i;
1099
1100 for (i = 0; i < 32; i++)
1101 kvmppc_set_gpr(vcpu, i, gprs[i]);
1102 vcpu->arch.osi_needed = 0;
1103 } else if (vcpu->arch.hcall_needed) {
1104 int i;
1105
1106 kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret);
1107 for (i = 0; i < 9; ++i)
1108 kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]);
1109 vcpu->arch.hcall_needed = 0;
1110 #ifdef CONFIG_BOOKE
1111 } else if (vcpu->arch.epr_needed) {
1112 kvmppc_set_epr(vcpu, run->epr.epr);
1113 vcpu->arch.epr_needed = 0;
1114 #endif
1115 }
1116
1117 r = kvmppc_vcpu_run(run, vcpu);
1118
1119 if (vcpu->sigset_active)
1120 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1121
1122 return r;
1123 }
1124
1125 int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq)
1126 {
1127 if (irq->irq == KVM_INTERRUPT_UNSET) {
1128 kvmppc_core_dequeue_external(vcpu);
1129 return 0;
1130 }
1131
1132 kvmppc_core_queue_external(vcpu, irq);
1133
1134 kvm_vcpu_kick(vcpu);
1135
1136 return 0;
1137 }
1138
1139 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
1140 struct kvm_enable_cap *cap)
1141 {
1142 int r;
1143
1144 if (cap->flags)
1145 return -EINVAL;
1146
1147 switch (cap->cap) {
1148 case KVM_CAP_PPC_OSI:
1149 r = 0;
1150 vcpu->arch.osi_enabled = true;
1151 break;
1152 case KVM_CAP_PPC_PAPR:
1153 r = 0;
1154 vcpu->arch.papr_enabled = true;
1155 break;
1156 case KVM_CAP_PPC_EPR:
1157 r = 0;
1158 if (cap->args[0])
1159 vcpu->arch.epr_flags |= KVMPPC_EPR_USER;
1160 else
1161 vcpu->arch.epr_flags &= ~KVMPPC_EPR_USER;
1162 break;
1163 #ifdef CONFIG_BOOKE
1164 case KVM_CAP_PPC_BOOKE_WATCHDOG:
1165 r = 0;
1166 vcpu->arch.watchdog_enabled = true;
1167 break;
1168 #endif
1169 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
1170 case KVM_CAP_SW_TLB: {
1171 struct kvm_config_tlb cfg;
1172 void __user *user_ptr = (void __user *)(uintptr_t)cap->args[0];
1173
1174 r = -EFAULT;
1175 if (copy_from_user(&cfg, user_ptr, sizeof(cfg)))
1176 break;
1177
1178 r = kvm_vcpu_ioctl_config_tlb(vcpu, &cfg);
1179 break;
1180 }
1181 #endif
1182 #ifdef CONFIG_KVM_MPIC
1183 case KVM_CAP_IRQ_MPIC: {
1184 struct fd f;
1185 struct kvm_device *dev;
1186
1187 r = -EBADF;
1188 f = fdget(cap->args[0]);
1189 if (!f.file)
1190 break;
1191
1192 r = -EPERM;
1193 dev = kvm_device_from_filp(f.file);
1194 if (dev)
1195 r = kvmppc_mpic_connect_vcpu(dev, vcpu, cap->args[1]);
1196
1197 fdput(f);
1198 break;
1199 }
1200 #endif
1201 #ifdef CONFIG_KVM_XICS
1202 case KVM_CAP_IRQ_XICS: {
1203 struct fd f;
1204 struct kvm_device *dev;
1205
1206 r = -EBADF;
1207 f = fdget(cap->args[0]);
1208 if (!f.file)
1209 break;
1210
1211 r = -EPERM;
1212 dev = kvm_device_from_filp(f.file);
1213 if (dev)
1214 r = kvmppc_xics_connect_vcpu(dev, vcpu, cap->args[1]);
1215
1216 fdput(f);
1217 break;
1218 }
1219 #endif /* CONFIG_KVM_XICS */
1220 default:
1221 r = -EINVAL;
1222 break;
1223 }
1224
1225 if (!r)
1226 r = kvmppc_sanity_check(vcpu);
1227
1228 return r;
1229 }
1230
1231 bool kvm_arch_intc_initialized(struct kvm *kvm)
1232 {
1233 #ifdef CONFIG_KVM_MPIC
1234 if (kvm->arch.mpic)
1235 return true;
1236 #endif
1237 #ifdef CONFIG_KVM_XICS
1238 if (kvm->arch.xics)
1239 return true;
1240 #endif
1241 return false;
1242 }
1243
1244 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
1245 struct kvm_mp_state *mp_state)
1246 {
1247 return -EINVAL;
1248 }
1249
1250 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
1251 struct kvm_mp_state *mp_state)
1252 {
1253 return -EINVAL;
1254 }
1255
1256 long kvm_arch_vcpu_ioctl(struct file *filp,
1257 unsigned int ioctl, unsigned long arg)
1258 {
1259 struct kvm_vcpu *vcpu = filp->private_data;
1260 void __user *argp = (void __user *)arg;
1261 long r;
1262
1263 switch (ioctl) {
1264 case KVM_INTERRUPT: {
1265 struct kvm_interrupt irq;
1266 r = -EFAULT;
1267 if (copy_from_user(&irq, argp, sizeof(irq)))
1268 goto out;
1269 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq);
1270 goto out;
1271 }
1272
1273 case KVM_ENABLE_CAP:
1274 {
1275 struct kvm_enable_cap cap;
1276 r = -EFAULT;
1277 if (copy_from_user(&cap, argp, sizeof(cap)))
1278 goto out;
1279 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
1280 break;
1281 }
1282
1283 case KVM_SET_ONE_REG:
1284 case KVM_GET_ONE_REG:
1285 {
1286 struct kvm_one_reg reg;
1287 r = -EFAULT;
1288 if (copy_from_user(&reg, argp, sizeof(reg)))
1289 goto out;
1290 if (ioctl == KVM_SET_ONE_REG)
1291 r = kvm_vcpu_ioctl_set_one_reg(vcpu, &reg);
1292 else
1293 r = kvm_vcpu_ioctl_get_one_reg(vcpu, &reg);
1294 break;
1295 }
1296
1297 #if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
1298 case KVM_DIRTY_TLB: {
1299 struct kvm_dirty_tlb dirty;
1300 r = -EFAULT;
1301 if (copy_from_user(&dirty, argp, sizeof(dirty)))
1302 goto out;
1303 r = kvm_vcpu_ioctl_dirty_tlb(vcpu, &dirty);
1304 break;
1305 }
1306 #endif
1307 default:
1308 r = -EINVAL;
1309 }
1310
1311 out:
1312 return r;
1313 }
1314
1315 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
1316 {
1317 return VM_FAULT_SIGBUS;
1318 }
1319
1320 static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo)
1321 {
1322 u32 inst_nop = 0x60000000;
1323 #ifdef CONFIG_KVM_BOOKE_HV
1324 u32 inst_sc1 = 0x44000022;
1325 pvinfo->hcall[0] = cpu_to_be32(inst_sc1);
1326 pvinfo->hcall[1] = cpu_to_be32(inst_nop);
1327 pvinfo->hcall[2] = cpu_to_be32(inst_nop);
1328 pvinfo->hcall[3] = cpu_to_be32(inst_nop);
1329 #else
1330 u32 inst_lis = 0x3c000000;
1331 u32 inst_ori = 0x60000000;
1332 u32 inst_sc = 0x44000002;
1333 u32 inst_imm_mask = 0xffff;
1334
1335 /*
1336 * The hypercall to get into KVM from within guest context is as
1337 * follows:
1338 *
1339 * lis r0, r0, KVM_SC_MAGIC_R0@h
1340 * ori r0, KVM_SC_MAGIC_R0@l
1341 * sc
1342 * nop
1343 */
1344 pvinfo->hcall[0] = cpu_to_be32(inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask));
1345 pvinfo->hcall[1] = cpu_to_be32(inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask));
1346 pvinfo->hcall[2] = cpu_to_be32(inst_sc);
1347 pvinfo->hcall[3] = cpu_to_be32(inst_nop);
1348 #endif
1349
1350 pvinfo->flags = KVM_PPC_PVINFO_FLAGS_EV_IDLE;
1351
1352 return 0;
1353 }
1354
1355 int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_event,
1356 bool line_status)
1357 {
1358 if (!irqchip_in_kernel(kvm))
1359 return -ENXIO;
1360
1361 irq_event->status = kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID,
1362 irq_event->irq, irq_event->level,
1363 line_status);
1364 return 0;
1365 }
1366
1367
1368 static int kvm_vm_ioctl_enable_cap(struct kvm *kvm,
1369 struct kvm_enable_cap *cap)
1370 {
1371 int r;
1372
1373 if (cap->flags)
1374 return -EINVAL;
1375
1376 switch (cap->cap) {
1377 #ifdef CONFIG_KVM_BOOK3S_64_HANDLER
1378 case KVM_CAP_PPC_ENABLE_HCALL: {
1379 unsigned long hcall = cap->args[0];
1380
1381 r = -EINVAL;
1382 if (hcall > MAX_HCALL_OPCODE || (hcall & 3) ||
1383 cap->args[1] > 1)
1384 break;
1385 if (!kvmppc_book3s_hcall_implemented(kvm, hcall))
1386 break;
1387 if (cap->args[1])
1388 set_bit(hcall / 4, kvm->arch.enabled_hcalls);
1389 else
1390 clear_bit(hcall / 4, kvm->arch.enabled_hcalls);
1391 r = 0;
1392 break;
1393 }
1394 #endif
1395 default:
1396 r = -EINVAL;
1397 break;
1398 }
1399
1400 return r;
1401 }
1402
1403 long kvm_arch_vm_ioctl(struct file *filp,
1404 unsigned int ioctl, unsigned long arg)
1405 {
1406 struct kvm *kvm __maybe_unused = filp->private_data;
1407 void __user *argp = (void __user *)arg;
1408 long r;
1409
1410 switch (ioctl) {
1411 case KVM_PPC_GET_PVINFO: {
1412 struct kvm_ppc_pvinfo pvinfo;
1413 memset(&pvinfo, 0, sizeof(pvinfo));
1414 r = kvm_vm_ioctl_get_pvinfo(&pvinfo);
1415 if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) {
1416 r = -EFAULT;
1417 goto out;
1418 }
1419
1420 break;
1421 }
1422 case KVM_ENABLE_CAP:
1423 {
1424 struct kvm_enable_cap cap;
1425 r = -EFAULT;
1426 if (copy_from_user(&cap, argp, sizeof(cap)))
1427 goto out;
1428 r = kvm_vm_ioctl_enable_cap(kvm, &cap);
1429 break;
1430 }
1431 #ifdef CONFIG_PPC_BOOK3S_64
1432 case KVM_CREATE_SPAPR_TCE_64: {
1433 struct kvm_create_spapr_tce_64 create_tce_64;
1434
1435 r = -EFAULT;
1436 if (copy_from_user(&create_tce_64, argp, sizeof(create_tce_64)))
1437 goto out;
1438 if (create_tce_64.flags) {
1439 r = -EINVAL;
1440 goto out;
1441 }
1442 r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce_64);
1443 goto out;
1444 }
1445 case KVM_CREATE_SPAPR_TCE: {
1446 struct kvm_create_spapr_tce create_tce;
1447 struct kvm_create_spapr_tce_64 create_tce_64;
1448
1449 r = -EFAULT;
1450 if (copy_from_user(&create_tce, argp, sizeof(create_tce)))
1451 goto out;
1452
1453 create_tce_64.liobn = create_tce.liobn;
1454 create_tce_64.page_shift = IOMMU_PAGE_SHIFT_4K;
1455 create_tce_64.offset = 0;
1456 create_tce_64.size = create_tce.window_size >>
1457 IOMMU_PAGE_SHIFT_4K;
1458 create_tce_64.flags = 0;
1459 r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce_64);
1460 goto out;
1461 }
1462 case KVM_PPC_GET_SMMU_INFO: {
1463 struct kvm_ppc_smmu_info info;
1464 struct kvm *kvm = filp->private_data;
1465
1466 memset(&info, 0, sizeof(info));
1467 r = kvm->arch.kvm_ops->get_smmu_info(kvm, &info);
1468 if (r >= 0 && copy_to_user(argp, &info, sizeof(info)))
1469 r = -EFAULT;
1470 break;
1471 }
1472 case KVM_PPC_RTAS_DEFINE_TOKEN: {
1473 struct kvm *kvm = filp->private_data;
1474
1475 r = kvm_vm_ioctl_rtas_define_token(kvm, argp);
1476 break;
1477 }
1478 case KVM_PPC_CONFIGURE_V3_MMU: {
1479 struct kvm *kvm = filp->private_data;
1480 struct kvm_ppc_mmuv3_cfg cfg;
1481
1482 r = -EINVAL;
1483 if (!kvm->arch.kvm_ops->configure_mmu)
1484 goto out;
1485 r = -EFAULT;
1486 if (copy_from_user(&cfg, argp, sizeof(cfg)))
1487 goto out;
1488 r = kvm->arch.kvm_ops->configure_mmu(kvm, &cfg);
1489 break;
1490 }
1491 case KVM_PPC_GET_RMMU_INFO: {
1492 struct kvm *kvm = filp->private_data;
1493 struct kvm_ppc_rmmu_info info;
1494
1495 r = -EINVAL;
1496 if (!kvm->arch.kvm_ops->get_rmmu_info)
1497 goto out;
1498 r = kvm->arch.kvm_ops->get_rmmu_info(kvm, &info);
1499 if (r >= 0 && copy_to_user(argp, &info, sizeof(info)))
1500 r = -EFAULT;
1501 break;
1502 }
1503 default: {
1504 struct kvm *kvm = filp->private_data;
1505 r = kvm->arch.kvm_ops->arch_vm_ioctl(filp, ioctl, arg);
1506 }
1507 #else /* CONFIG_PPC_BOOK3S_64 */
1508 default:
1509 r = -ENOTTY;
1510 #endif
1511 }
1512 out:
1513 return r;
1514 }
1515
1516 static unsigned long lpid_inuse[BITS_TO_LONGS(KVMPPC_NR_LPIDS)];
1517 static unsigned long nr_lpids;
1518
1519 long kvmppc_alloc_lpid(void)
1520 {
1521 long lpid;
1522
1523 do {
1524 lpid = find_first_zero_bit(lpid_inuse, KVMPPC_NR_LPIDS);
1525 if (lpid >= nr_lpids) {
1526 pr_err("%s: No LPIDs free\n", __func__);
1527 return -ENOMEM;
1528 }
1529 } while (test_and_set_bit(lpid, lpid_inuse));
1530
1531 return lpid;
1532 }
1533 EXPORT_SYMBOL_GPL(kvmppc_alloc_lpid);
1534
1535 void kvmppc_claim_lpid(long lpid)
1536 {
1537 set_bit(lpid, lpid_inuse);
1538 }
1539 EXPORT_SYMBOL_GPL(kvmppc_claim_lpid);
1540
1541 void kvmppc_free_lpid(long lpid)
1542 {
1543 clear_bit(lpid, lpid_inuse);
1544 }
1545 EXPORT_SYMBOL_GPL(kvmppc_free_lpid);
1546
1547 void kvmppc_init_lpid(unsigned long nr_lpids_param)
1548 {
1549 nr_lpids = min_t(unsigned long, KVMPPC_NR_LPIDS, nr_lpids_param);
1550 memset(lpid_inuse, 0, sizeof(lpid_inuse));
1551 }
1552 EXPORT_SYMBOL_GPL(kvmppc_init_lpid);
1553
1554 int kvm_arch_init(void *opaque)
1555 {
1556 return 0;
1557 }
1558
1559 EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_ppc_instr);
ubuntu-zesty-kernel mirror