projects / deliverable / linux.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
kvm/ppc/mpic: remove users
[deliverable/linux.git] / arch / powerpc / kvm / powerpc.c
... / ...
CommitLineData
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 <asm/cputable.h>
30#include <asm/uaccess.h>
31#include <asm/kvm_ppc.h>
32#include <asm/tlbflush.h>
33#include <asm/cputhreads.h>
34#include <asm/irqflags.h>
35#include "timing.h"
36#include "irq.h"
37#include "../mm/mmu_decl.h"
38
39#define CREATE_TRACE_POINTS
40#include "trace.h"
41
42int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
43{
44 return !!(v->arch.pending_exceptions) ||
45 v->requests;
46}
47
48int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
49{
50 return 1;
51}
52
53#ifndef CONFIG_KVM_BOOK3S_64_HV
54/*
55 * Common checks before entering the guest world. Call with interrupts
56 * disabled.
57 *
58 * returns:
59 *
60 * == 1 if we're ready to go into guest state
61 * <= 0 if we need to go back to the host with return value
62 */
63int kvmppc_prepare_to_enter(struct kvm_vcpu *vcpu)
64{
65 int r = 1;
66
67 WARN_ON_ONCE(!irqs_disabled());
68 while (true) {
69 if (need_resched()) {
70 local_irq_enable();
71 cond_resched();
72 local_irq_disable();
73 continue;
74 }
75
76 if (signal_pending(current)) {
77 kvmppc_account_exit(vcpu, SIGNAL_EXITS);
78 vcpu->run->exit_reason = KVM_EXIT_INTR;
79 r = -EINTR;
80 break;
81 }
82
83 vcpu->mode = IN_GUEST_MODE;
84
85 /*
86 * Reading vcpu->requests must happen after setting vcpu->mode,
87 * so we don't miss a request because the requester sees
88 * OUTSIDE_GUEST_MODE and assumes we'll be checking requests
89 * before next entering the guest (and thus doesn't IPI).
90 */
91 smp_mb();
92
93 if (vcpu->requests) {
94 /* Make sure we process requests preemptable */
95 local_irq_enable();
96 trace_kvm_check_requests(vcpu);
97 r = kvmppc_core_check_requests(vcpu);
98 local_irq_disable();
99 if (r > 0)
100 continue;
101 break;
102 }
103
104 if (kvmppc_core_prepare_to_enter(vcpu)) {
105 /* interrupts got enabled in between, so we
106 are back at square 1 */
107 continue;
108 }
109
110#ifdef CONFIG_PPC64
111 /* lazy EE magic */
112 hard_irq_disable();
113 if (lazy_irq_pending()) {
114 /* Got an interrupt in between, try again */
115 local_irq_enable();
116 local_irq_disable();
117 kvm_guest_exit();
118 continue;
119 }
120
121 trace_hardirqs_on();
122#endif
123
124 kvm_guest_enter();
125 break;
126 }
127
128 return r;
129}
130#endif /* CONFIG_KVM_BOOK3S_64_HV */
131
132int kvmppc_kvm_pv(struct kvm_vcpu *vcpu)
133{
134 int nr = kvmppc_get_gpr(vcpu, 11);
135 int r;
136 unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3);
137 unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4);
138 unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5);
139 unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6);
140 unsigned long r2 = 0;
141
142 if (!(vcpu->arch.shared->msr & MSR_SF)) {
143 /* 32 bit mode */
144 param1 &= 0xffffffff;
145 param2 &= 0xffffffff;
146 param3 &= 0xffffffff;
147 param4 &= 0xffffffff;
148 }
149
150 switch (nr) {
151 case KVM_HCALL_TOKEN(KVM_HC_PPC_MAP_MAGIC_PAGE):
152 {
153 vcpu->arch.magic_page_pa = param1;
154 vcpu->arch.magic_page_ea = param2;
155
156 r2 = KVM_MAGIC_FEAT_SR | KVM_MAGIC_FEAT_MAS0_TO_SPRG7;
157
158 r = EV_SUCCESS;
159 break;
160 }
161 case KVM_HCALL_TOKEN(KVM_HC_FEATURES):
162 r = EV_SUCCESS;
163#if defined(CONFIG_PPC_BOOK3S) || defined(CONFIG_KVM_E500V2)
164 /* XXX Missing magic page on 44x */
165 r2 |= (1 << KVM_FEATURE_MAGIC_PAGE);
166#endif
167
168 /* Second return value is in r4 */
169 break;
170 case EV_HCALL_TOKEN(EV_IDLE):
171 r = EV_SUCCESS;
172 kvm_vcpu_block(vcpu);
173 clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
174 break;
175 default:
176 r = EV_UNIMPLEMENTED;
177 break;
178 }
179
180 kvmppc_set_gpr(vcpu, 4, r2);
181
182 return r;
183}
184
185int kvmppc_sanity_check(struct kvm_vcpu *vcpu)
186{
187 int r = false;
188
189 /* We have to know what CPU to virtualize */
190 if (!vcpu->arch.pvr)
191 goto out;
192
193 /* PAPR only works with book3s_64 */
194 if ((vcpu->arch.cpu_type != KVM_CPU_3S_64) && vcpu->arch.papr_enabled)
195 goto out;
196
197#ifdef CONFIG_KVM_BOOK3S_64_HV
198 /* HV KVM can only do PAPR mode for now */
199 if (!vcpu->arch.papr_enabled)
200 goto out;
201#endif
202
203#ifdef CONFIG_KVM_BOOKE_HV
204 if (!cpu_has_feature(CPU_FTR_EMB_HV))
205 goto out;
206#endif
207
208 r = true;
209
210out:
211 vcpu->arch.sane = r;
212 return r ? 0 : -EINVAL;
213}
214
215int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu)
216{
217 enum emulation_result er;
218 int r;
219
220 er = kvmppc_emulate_instruction(run, vcpu);
221 switch (er) {
222 case EMULATE_DONE:
223 /* Future optimization: only reload non-volatiles if they were
224 * actually modified. */
225 r = RESUME_GUEST_NV;
226 break;
227 case EMULATE_DO_MMIO:
228 run->exit_reason = KVM_EXIT_MMIO;
229 /* We must reload nonvolatiles because "update" load/store
230 * instructions modify register state. */
231 /* Future optimization: only reload non-volatiles if they were
232 * actually modified. */
233 r = RESUME_HOST_NV;
234 break;
235 case EMULATE_FAIL:
236 /* XXX Deliver Program interrupt to guest. */
237 printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__,
238 kvmppc_get_last_inst(vcpu));
239 r = RESUME_HOST;
240 break;
241 default:
242 WARN_ON(1);
243 r = RESUME_GUEST;
244 }
245
246 return r;
247}
248
249int kvm_arch_hardware_enable(void *garbage)
250{
251 return 0;
252}
253
254void kvm_arch_hardware_disable(void *garbage)
255{
256}
257
258int kvm_arch_hardware_setup(void)
259{
260 return 0;
261}
262
263void kvm_arch_hardware_unsetup(void)
264{
265}
266
267void kvm_arch_check_processor_compat(void *rtn)
268{
269 *(int *)rtn = kvmppc_core_check_processor_compat();
270}
271
272int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
273{
274 if (type)
275 return -EINVAL;
276
277 return kvmppc_core_init_vm(kvm);
278}
279
280void kvm_arch_destroy_vm(struct kvm *kvm)
281{
282 unsigned int i;
283 struct kvm_vcpu *vcpu;
284
285 kvm_for_each_vcpu(i, vcpu, kvm)
286 kvm_arch_vcpu_free(vcpu);
287
288 mutex_lock(&kvm->lock);
289 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
290 kvm->vcpus[i] = NULL;
291
292 atomic_set(&kvm->online_vcpus, 0);
293
294 kvmppc_core_destroy_vm(kvm);
295
296 mutex_unlock(&kvm->lock);
297}
298
299void kvm_arch_sync_events(struct kvm *kvm)
300{
301}
302
303int kvm_dev_ioctl_check_extension(long ext)
304{
305 int r;
306
307 switch (ext) {
308#ifdef CONFIG_BOOKE
309 case KVM_CAP_PPC_BOOKE_SREGS:
310 case KVM_CAP_PPC_BOOKE_WATCHDOG:
311 case KVM_CAP_PPC_EPR:
312#else
313 case KVM_CAP_PPC_SEGSTATE:
314 case KVM_CAP_PPC_HIOR:
315 case KVM_CAP_PPC_PAPR:
316#endif
317 case KVM_CAP_PPC_UNSET_IRQ:
318 case KVM_CAP_PPC_IRQ_LEVEL:
319 case KVM_CAP_ENABLE_CAP:
320 case KVM_CAP_ONE_REG:
321 case KVM_CAP_IOEVENTFD:
322 case KVM_CAP_DEVICE_CTRL:
323 r = 1;
324 break;
325#ifndef CONFIG_KVM_BOOK3S_64_HV
326 case KVM_CAP_PPC_PAIRED_SINGLES:
327 case KVM_CAP_PPC_OSI:
328 case KVM_CAP_PPC_GET_PVINFO:
329#if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
330 case KVM_CAP_SW_TLB:
331#endif
332#ifdef CONFIG_KVM_MPIC
333 case KVM_CAP_IRQ_MPIC:
334#endif
335 r = 1;
336 break;
337 case KVM_CAP_COALESCED_MMIO:
338 r = KVM_COALESCED_MMIO_PAGE_OFFSET;
339 break;
340#endif
341#ifdef CONFIG_PPC_BOOK3S_64
342 case KVM_CAP_SPAPR_TCE:
343 case KVM_CAP_PPC_ALLOC_HTAB:
344 case KVM_CAP_PPC_RTAS:
345 r = 1;
346 break;
347#endif /* CONFIG_PPC_BOOK3S_64 */
348#ifdef CONFIG_KVM_BOOK3S_64_HV
349 case KVM_CAP_PPC_SMT:
350 r = threads_per_core;
351 break;
352 case KVM_CAP_PPC_RMA:
353 r = 1;
354 /* PPC970 requires an RMA */
355 if (cpu_has_feature(CPU_FTR_ARCH_201))
356 r = 2;
357 break;
358#endif
359 case KVM_CAP_SYNC_MMU:
360#ifdef CONFIG_KVM_BOOK3S_64_HV
361 r = cpu_has_feature(CPU_FTR_ARCH_206) ? 1 : 0;
362#elif defined(KVM_ARCH_WANT_MMU_NOTIFIER)
363 r = 1;
364#else
365 r = 0;
366 break;
367#endif
368#ifdef CONFIG_KVM_BOOK3S_64_HV
369 case KVM_CAP_PPC_HTAB_FD:
370 r = 1;
371 break;
372#endif
373 break;
374 case KVM_CAP_NR_VCPUS:
375 /*
376 * Recommending a number of CPUs is somewhat arbitrary; we
377 * return the number of present CPUs for -HV (since a host
378 * will have secondary threads "offline"), and for other KVM
379 * implementations just count online CPUs.
380 */
381#ifdef CONFIG_KVM_BOOK3S_64_HV
382 r = num_present_cpus();
383#else
384 r = num_online_cpus();
385#endif
386 break;
387 case KVM_CAP_MAX_VCPUS:
388 r = KVM_MAX_VCPUS;
389 break;
390#ifdef CONFIG_PPC_BOOK3S_64
391 case KVM_CAP_PPC_GET_SMMU_INFO:
392 r = 1;
393 break;
394#endif
395 default:
396 r = 0;
397 break;
398 }
399 return r;
400
401}
402
403long kvm_arch_dev_ioctl(struct file *filp,
404 unsigned int ioctl, unsigned long arg)
405{
406 return -EINVAL;
407}
408
409void kvm_arch_free_memslot(struct kvm_memory_slot *free,
410 struct kvm_memory_slot *dont)
411{
412 kvmppc_core_free_memslot(free, dont);
413}
414
415int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
416{
417 return kvmppc_core_create_memslot(slot, npages);
418}
419
420int kvm_arch_prepare_memory_region(struct kvm *kvm,
421 struct kvm_memory_slot *memslot,
422 struct kvm_userspace_memory_region *mem,
423 enum kvm_mr_change change)
424{
425 return kvmppc_core_prepare_memory_region(kvm, memslot, mem);
426}
427
428void kvm_arch_commit_memory_region(struct kvm *kvm,
429 struct kvm_userspace_memory_region *mem,
430 const struct kvm_memory_slot *old,
431 enum kvm_mr_change change)
432{
433 kvmppc_core_commit_memory_region(kvm, mem, old);
434}
435
436void kvm_arch_flush_shadow_all(struct kvm *kvm)
437{
438}
439
440void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
441 struct kvm_memory_slot *slot)
442{
443 kvmppc_core_flush_memslot(kvm, slot);
444}
445
446struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id)
447{
448 struct kvm_vcpu *vcpu;
449 vcpu = kvmppc_core_vcpu_create(kvm, id);
450 if (!IS_ERR(vcpu)) {
451 vcpu->arch.wqp = &vcpu->wq;
452 kvmppc_create_vcpu_debugfs(vcpu, id);
453 }
454 return vcpu;
455}
456
457int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
458{
459 return 0;
460}
461
462void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
463{
464 /* Make sure we're not using the vcpu anymore */
465 hrtimer_cancel(&vcpu->arch.dec_timer);
466 tasklet_kill(&vcpu->arch.tasklet);
467
468 kvmppc_remove_vcpu_debugfs(vcpu);
469
470 switch (vcpu->arch.irq_type) {
471 case KVMPPC_IRQ_MPIC:
472 kvmppc_mpic_disconnect_vcpu(vcpu->arch.mpic, vcpu);
473 break;
474 case KVMPPC_IRQ_XICS:
475 kvmppc_xics_free_icp(vcpu);
476 break;
477 }
478
479 kvmppc_core_vcpu_free(vcpu);
480}
481
482void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
483{
484 kvm_arch_vcpu_free(vcpu);
485}
486
487int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
488{
489 return kvmppc_core_pending_dec(vcpu);
490}
491
492/*
493 * low level hrtimer wake routine. Because this runs in hardirq context
494 * we schedule a tasklet to do the real work.
495 */
496enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer)
497{
498 struct kvm_vcpu *vcpu;
499
500 vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer);
501 tasklet_schedule(&vcpu->arch.tasklet);
502
503 return HRTIMER_NORESTART;
504}
505
506int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
507{
508 int ret;
509
510 hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
511 tasklet_init(&vcpu->arch.tasklet, kvmppc_decrementer_func, (ulong)vcpu);
512 vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup;
513 vcpu->arch.dec_expires = ~(u64)0;
514
515#ifdef CONFIG_KVM_EXIT_TIMING
516 mutex_init(&vcpu->arch.exit_timing_lock);
517#endif
518 ret = kvmppc_subarch_vcpu_init(vcpu);
519 return ret;
520}
521
522void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
523{
524 kvmppc_mmu_destroy(vcpu);
525 kvmppc_subarch_vcpu_uninit(vcpu);
526}
527
528void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
529{
530#ifdef CONFIG_BOOKE
531 /*
532 * vrsave (formerly usprg0) isn't used by Linux, but may
533 * be used by the guest.
534 *
535 * On non-booke this is associated with Altivec and
536 * is handled by code in book3s.c.
537 */
538 mtspr(SPRN_VRSAVE, vcpu->arch.vrsave);
539#endif
540 kvmppc_core_vcpu_load(vcpu, cpu);
541}
542
543void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
544{
545 kvmppc_core_vcpu_put(vcpu);
546#ifdef CONFIG_BOOKE
547 vcpu->arch.vrsave = mfspr(SPRN_VRSAVE);
548#endif
549}
550
551static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu,
552 struct kvm_run *run)
553{
554 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data);
555}
556
557static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu,
558 struct kvm_run *run)
559{
560 u64 uninitialized_var(gpr);
561
562 if (run->mmio.len > sizeof(gpr)) {
563 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len);
564 return;
565 }
566
567 if (vcpu->arch.mmio_is_bigendian) {
568 switch (run->mmio.len) {
569 case 8: gpr = *(u64 *)run->mmio.data; break;
570 case 4: gpr = *(u32 *)run->mmio.data; break;
571 case 2: gpr = *(u16 *)run->mmio.data; break;
572 case 1: gpr = *(u8 *)run->mmio.data; break;
573 }
574 } else {
575 /* Convert BE data from userland back to LE. */
576 switch (run->mmio.len) {
577 case 4: gpr = ld_le32((u32 *)run->mmio.data); break;
578 case 2: gpr = ld_le16((u16 *)run->mmio.data); break;
579 case 1: gpr = *(u8 *)run->mmio.data; break;
580 }
581 }
582
583 if (vcpu->arch.mmio_sign_extend) {
584 switch (run->mmio.len) {
585#ifdef CONFIG_PPC64
586 case 4:
587 gpr = (s64)(s32)gpr;
588 break;
589#endif
590 case 2:
591 gpr = (s64)(s16)gpr;
592 break;
593 case 1:
594 gpr = (s64)(s8)gpr;
595 break;
596 }
597 }
598
599 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
600
601 switch (vcpu->arch.io_gpr & KVM_MMIO_REG_EXT_MASK) {
602 case KVM_MMIO_REG_GPR:
603 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
604 break;
605 case KVM_MMIO_REG_FPR:
606 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
607 break;
608#ifdef CONFIG_PPC_BOOK3S
609 case KVM_MMIO_REG_QPR:
610 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
611 break;
612 case KVM_MMIO_REG_FQPR:
613 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
614 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
615 break;
616#endif
617 default:
618 BUG();
619 }
620}
621
622int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
623 unsigned int rt, unsigned int bytes, int is_bigendian)
624{
625 if (bytes > sizeof(run->mmio.data)) {
626 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
627 run->mmio.len);
628 }
629
630 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
631 run->mmio.len = bytes;
632 run->mmio.is_write = 0;
633
634 vcpu->arch.io_gpr = rt;
635 vcpu->arch.mmio_is_bigendian = is_bigendian;
636 vcpu->mmio_needed = 1;
637 vcpu->mmio_is_write = 0;
638 vcpu->arch.mmio_sign_extend = 0;
639
640 if (!kvm_io_bus_read(vcpu->kvm, KVM_MMIO_BUS, run->mmio.phys_addr,
641 bytes, &run->mmio.data)) {
642 kvmppc_complete_mmio_load(vcpu, run);
643 vcpu->mmio_needed = 0;
644 return EMULATE_DONE;
645 }
646
647 return EMULATE_DO_MMIO;
648}
649
650/* Same as above, but sign extends */
651int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu,
652 unsigned int rt, unsigned int bytes, int is_bigendian)
653{
654 int r;
655
656 vcpu->arch.mmio_sign_extend = 1;
657 r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian);
658
659 return r;
660}
661
662int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu,
663 u64 val, unsigned int bytes, int is_bigendian)
664{
665 void *data = run->mmio.data;
666
667 if (bytes > sizeof(run->mmio.data)) {
668 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
669 run->mmio.len);
670 }
671
672 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
673 run->mmio.len = bytes;
674 run->mmio.is_write = 1;
675 vcpu->mmio_needed = 1;
676 vcpu->mmio_is_write = 1;
677
678 /* Store the value at the lowest bytes in 'data'. */
679 if (is_bigendian) {
680 switch (bytes) {
681 case 8: *(u64 *)data = val; break;
682 case 4: *(u32 *)data = val; break;
683 case 2: *(u16 *)data = val; break;
684 case 1: *(u8 *)data = val; break;
685 }
686 } else {
687 /* Store LE value into 'data'. */
688 switch (bytes) {
689 case 4: st_le32(data, val); break;
690 case 2: st_le16(data, val); break;
691 case 1: *(u8 *)data = val; break;
692 }
693 }
694
695 if (!kvm_io_bus_write(vcpu->kvm, KVM_MMIO_BUS, run->mmio.phys_addr,
696 bytes, &run->mmio.data)) {
697 vcpu->mmio_needed = 0;
698 return EMULATE_DONE;
699 }
700
701 return EMULATE_DO_MMIO;
702}
703
704int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
705{
706 int r;
707 sigset_t sigsaved;
708
709 if (vcpu->sigset_active)
710 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
711
712 if (vcpu->mmio_needed) {
713 if (!vcpu->mmio_is_write)
714 kvmppc_complete_mmio_load(vcpu, run);
715 vcpu->mmio_needed = 0;
716 } else if (vcpu->arch.dcr_needed) {
717 if (!vcpu->arch.dcr_is_write)
718 kvmppc_complete_dcr_load(vcpu, run);
719 vcpu->arch.dcr_needed = 0;
720 } else if (vcpu->arch.osi_needed) {
721 u64 *gprs = run->osi.gprs;
722 int i;
723
724 for (i = 0; i < 32; i++)
725 kvmppc_set_gpr(vcpu, i, gprs[i]);
726 vcpu->arch.osi_needed = 0;
727 } else if (vcpu->arch.hcall_needed) {
728 int i;
729
730 kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret);
731 for (i = 0; i < 9; ++i)
732 kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]);
733 vcpu->arch.hcall_needed = 0;
734#ifdef CONFIG_BOOKE
735 } else if (vcpu->arch.epr_needed) {
736 kvmppc_set_epr(vcpu, run->epr.epr);
737 vcpu->arch.epr_needed = 0;
738#endif
739 }
740
741 r = kvmppc_vcpu_run(run, vcpu);
742
743 if (vcpu->sigset_active)
744 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
745
746 return r;
747}
748
749int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq)
750{
751 if (irq->irq == KVM_INTERRUPT_UNSET) {
752 kvmppc_core_dequeue_external(vcpu);
753 return 0;
754 }
755
756 kvmppc_core_queue_external(vcpu, irq);
757
758 kvm_vcpu_kick(vcpu);
759
760 return 0;
761}
762
763static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
764 struct kvm_enable_cap *cap)
765{
766 int r;
767
768 if (cap->flags)
769 return -EINVAL;
770
771 switch (cap->cap) {
772 case KVM_CAP_PPC_OSI:
773 r = 0;
774 vcpu->arch.osi_enabled = true;
775 break;
776 case KVM_CAP_PPC_PAPR:
777 r = 0;
778 vcpu->arch.papr_enabled = true;
779 break;
780 case KVM_CAP_PPC_EPR:
781 r = 0;
782 if (cap->args[0])
783 vcpu->arch.epr_flags |= KVMPPC_EPR_USER;
784 else
785 vcpu->arch.epr_flags &= ~KVMPPC_EPR_USER;
786 break;
787#ifdef CONFIG_BOOKE
788 case KVM_CAP_PPC_BOOKE_WATCHDOG:
789 r = 0;
790 vcpu->arch.watchdog_enabled = true;
791 break;
792#endif
793#if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
794 case KVM_CAP_SW_TLB: {
795 struct kvm_config_tlb cfg;
796 void __user *user_ptr = (void __user *)(uintptr_t)cap->args[0];
797
798 r = -EFAULT;
799 if (copy_from_user(&cfg, user_ptr, sizeof(cfg)))
800 break;
801
802 r = kvm_vcpu_ioctl_config_tlb(vcpu, &cfg);
803 break;
804 }
805#endif
806#ifdef CONFIG_KVM_MPIC
807 case KVM_CAP_IRQ_MPIC: {
808 struct file *filp;
809 struct kvm_device *dev;
810
811 r = -EBADF;
812 filp = fget(cap->args[0]);
813 if (!filp)
814 break;
815
816 r = -EPERM;
817 dev = kvm_device_from_filp(filp);
818 if (dev)
819 r = kvmppc_mpic_connect_vcpu(dev, vcpu, cap->args[1]);
820
821 fput(filp);
822 break;
823 }
824#endif
825 default:
826 r = -EINVAL;
827 break;
828 }
829
830 if (!r)
831 r = kvmppc_sanity_check(vcpu);
832
833 return r;
834}
835
836int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
837 struct kvm_mp_state *mp_state)
838{
839 return -EINVAL;
840}
841
842int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
843 struct kvm_mp_state *mp_state)
844{
845 return -EINVAL;
846}
847
848long kvm_arch_vcpu_ioctl(struct file *filp,
849 unsigned int ioctl, unsigned long arg)
850{
851 struct kvm_vcpu *vcpu = filp->private_data;
852 void __user *argp = (void __user *)arg;
853 long r;
854
855 switch (ioctl) {
856 case KVM_INTERRUPT: {
857 struct kvm_interrupt irq;
858 r = -EFAULT;
859 if (copy_from_user(&irq, argp, sizeof(irq)))
860 goto out;
861 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq);
862 goto out;
863 }
864
865 case KVM_ENABLE_CAP:
866 {
867 struct kvm_enable_cap cap;
868 r = -EFAULT;
869 if (copy_from_user(&cap, argp, sizeof(cap)))
870 goto out;
871 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
872 break;
873 }
874
875 case KVM_SET_ONE_REG:
876 case KVM_GET_ONE_REG:
877 {
878 struct kvm_one_reg reg;
879 r = -EFAULT;
880 if (copy_from_user(&reg, argp, sizeof(reg)))
881 goto out;
882 if (ioctl == KVM_SET_ONE_REG)
883 r = kvm_vcpu_ioctl_set_one_reg(vcpu, &reg);
884 else
885 r = kvm_vcpu_ioctl_get_one_reg(vcpu, &reg);
886 break;
887 }
888
889#if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
890 case KVM_DIRTY_TLB: {
891 struct kvm_dirty_tlb dirty;
892 r = -EFAULT;
893 if (copy_from_user(&dirty, argp, sizeof(dirty)))
894 goto out;
895 r = kvm_vcpu_ioctl_dirty_tlb(vcpu, &dirty);
896 break;
897 }
898#endif
899 default:
900 r = -EINVAL;
901 }
902
903out:
904 return r;
905}
906
907int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
908{
909 return VM_FAULT_SIGBUS;
910}
911
912static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo)
913{
914 u32 inst_nop = 0x60000000;
915#ifdef CONFIG_KVM_BOOKE_HV
916 u32 inst_sc1 = 0x44000022;
917 pvinfo->hcall[0] = inst_sc1;
918 pvinfo->hcall[1] = inst_nop;
919 pvinfo->hcall[2] = inst_nop;
920 pvinfo->hcall[3] = inst_nop;
921#else
922 u32 inst_lis = 0x3c000000;
923 u32 inst_ori = 0x60000000;
924 u32 inst_sc = 0x44000002;
925 u32 inst_imm_mask = 0xffff;
926
927 /*
928 * The hypercall to get into KVM from within guest context is as
929 * follows:
930 *
931 * lis r0, r0, KVM_SC_MAGIC_R0@h
932 * ori r0, KVM_SC_MAGIC_R0@l
933 * sc
934 * nop
935 */
936 pvinfo->hcall[0] = inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask);
937 pvinfo->hcall[1] = inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask);
938 pvinfo->hcall[2] = inst_sc;
939 pvinfo->hcall[3] = inst_nop;
940#endif
941
942 pvinfo->flags = KVM_PPC_PVINFO_FLAGS_EV_IDLE;
943
944 return 0;
945}
946
947int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_event,
948 bool line_status)
949{
950 if (!irqchip_in_kernel(kvm))
951 return -ENXIO;
952
953 irq_event->status = kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID,
954 irq_event->irq, irq_event->level,
955 line_status);
956 return 0;
957}
958
959long kvm_arch_vm_ioctl(struct file *filp,
960 unsigned int ioctl, unsigned long arg)
961{
962 struct kvm *kvm __maybe_unused = filp->private_data;
963 void __user *argp = (void __user *)arg;
964 long r;
965
966 switch (ioctl) {
967 case KVM_PPC_GET_PVINFO: {
968 struct kvm_ppc_pvinfo pvinfo;
969 memset(&pvinfo, 0, sizeof(pvinfo));
970 r = kvm_vm_ioctl_get_pvinfo(&pvinfo);
971 if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) {
972 r = -EFAULT;
973 goto out;
974 }
975
976 break;
977 }
978#ifdef CONFIG_PPC_BOOK3S_64
979 case KVM_CREATE_SPAPR_TCE: {
980 struct kvm_create_spapr_tce create_tce;
981
982 r = -EFAULT;
983 if (copy_from_user(&create_tce, argp, sizeof(create_tce)))
984 goto out;
985 r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce);
986 goto out;
987 }
988#endif /* CONFIG_PPC_BOOK3S_64 */
989
990#ifdef CONFIG_KVM_BOOK3S_64_HV
991 case KVM_ALLOCATE_RMA: {
992 struct kvm_allocate_rma rma;
993 struct kvm *kvm = filp->private_data;
994
995 r = kvm_vm_ioctl_allocate_rma(kvm, &rma);
996 if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma)))
997 r = -EFAULT;
998 break;
999 }
1000
1001 case KVM_PPC_ALLOCATE_HTAB: {
1002 u32 htab_order;
1003
1004 r = -EFAULT;
1005 if (get_user(htab_order, (u32 __user *)argp))
1006 break;
1007 r = kvmppc_alloc_reset_hpt(kvm, &htab_order);
1008 if (r)
1009 break;
1010 r = -EFAULT;
1011 if (put_user(htab_order, (u32 __user *)argp))
1012 break;
1013 r = 0;
1014 break;
1015 }
1016
1017 case KVM_PPC_GET_HTAB_FD: {
1018 struct kvm_get_htab_fd ghf;
1019
1020 r = -EFAULT;
1021 if (copy_from_user(&ghf, argp, sizeof(ghf)))
1022 break;
1023 r = kvm_vm_ioctl_get_htab_fd(kvm, &ghf);
1024 break;
1025 }
1026#endif /* CONFIG_KVM_BOOK3S_64_HV */
1027
1028#ifdef CONFIG_PPC_BOOK3S_64
1029 case KVM_PPC_GET_SMMU_INFO: {
1030 struct kvm_ppc_smmu_info info;
1031
1032 memset(&info, 0, sizeof(info));
1033 r = kvm_vm_ioctl_get_smmu_info(kvm, &info);
1034 if (r >= 0 && copy_to_user(argp, &info, sizeof(info)))
1035 r = -EFAULT;
1036 break;
1037 }
1038 case KVM_PPC_RTAS_DEFINE_TOKEN: {
1039 struct kvm *kvm = filp->private_data;
1040
1041 r = kvm_vm_ioctl_rtas_define_token(kvm, argp);
1042 break;
1043 }
1044#endif /* CONFIG_PPC_BOOK3S_64 */
1045 default:
1046 r = -ENOTTY;
1047 }
1048
1049out:
1050 return r;
1051}
1052
1053static unsigned long lpid_inuse[BITS_TO_LONGS(KVMPPC_NR_LPIDS)];
1054static unsigned long nr_lpids;
1055
1056long kvmppc_alloc_lpid(void)
1057{
1058 long lpid;
1059
1060 do {
1061 lpid = find_first_zero_bit(lpid_inuse, KVMPPC_NR_LPIDS);
1062 if (lpid >= nr_lpids) {
1063 pr_err("%s: No LPIDs free\n", __func__);
1064 return -ENOMEM;
1065 }
1066 } while (test_and_set_bit(lpid, lpid_inuse));
1067
1068 return lpid;
1069}
1070
1071void kvmppc_claim_lpid(long lpid)
1072{
1073 set_bit(lpid, lpid_inuse);
1074}
1075
1076void kvmppc_free_lpid(long lpid)
1077{
1078 clear_bit(lpid, lpid_inuse);
1079}
1080
1081void kvmppc_init_lpid(unsigned long nr_lpids_param)
1082{
1083 nr_lpids = min_t(unsigned long, KVMPPC_NR_LPIDS, nr_lpids_param);
1084 memset(lpid_inuse, 0, sizeof(lpid_inuse));
1085}
1086
1087int kvm_arch_init(void *opaque)
1088{
1089 return 0;
1090}
1091
1092void kvm_arch_exit(void)
1093{
1094}
Linux kernel - Deliverables
This page took 0.040395 seconds and 5 git commands to generate.