1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 <asm/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
46struct kvmppc_ops *kvmppc_hv_ops;
47EXPORT_SYMBOL_GPL(kvmppc_hv_ops);
48struct kvmppc_ops *kvmppc_pr_ops;
49EXPORT_SYMBOL_GPL(kvmppc_pr_ops);
50
51
52int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
53{
54 return !!(v->arch.pending_exceptions) ||
55 v->requests;
56}
57
58int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
59{
60 return 1;
61}
62
63
64
65
66
67
68
69
70
71
72int 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
98
99
100
101
102
103
104
105 smp_mb();
106
107 if (vcpu->requests) {
108
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
120
121 continue;
122 }
123
124 guest_enter_irqoff();
125 return 1;
126 }
127
128
129 local_irq_enable();
130 return r;
131}
132EXPORT_SYMBOL_GPL(kvmppc_prepare_to_enter);
133
134#if defined(CONFIG_PPC_BOOK3S_64) && defined(CONFIG_KVM_BOOK3S_PR_POSSIBLE)
135static 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
155int 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
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
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
189
190
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
202
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
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}
245EXPORT_SYMBOL_GPL(kvmppc_kvm_pv);
246
247int kvmppc_sanity_check(struct kvm_vcpu *vcpu)
248{
249 int r = false;
250
251
252 if (!vcpu->arch.pvr)
253 goto out;
254
255
256 if ((vcpu->arch.cpu_type != KVM_CPU_3S_64) && vcpu->arch.papr_enabled)
257 goto out;
258
259
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
270out:
271 vcpu->arch.sane = r;
272 return r ? 0 : -EINVAL;
273}
274EXPORT_SYMBOL_GPL(kvmppc_sanity_check);
275
276int 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
285
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
294
295
296
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
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}
316EXPORT_SYMBOL_GPL(kvmppc_emulate_mmio);
317
318int 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
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}
352EXPORT_SYMBOL_GPL(kvmppc_st);
353
354int 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
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}
391EXPORT_SYMBOL_GPL(kvmppc_ld);
392
393int kvm_arch_hardware_enable(void)
394{
395 return 0;
396}
397
398int kvm_arch_hardware_setup(void)
399{
400 return 0;
401}
402
403void kvm_arch_check_processor_compat(void *rtn)
404{
405 *(int *)rtn = kvmppc_core_check_processor_compat();
406}
407
408int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
409{
410 struct kvmppc_ops *kvm_ops = NULL;
411
412
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);
437err_out:
438 return -EINVAL;
439}
440
441bool kvm_arch_has_vcpu_debugfs(void)
442{
443 return false;
444}
445
446int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu)
447{
448 return 0;
449}
450
451void 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
459
460
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
480 module_put(kvm->arch.kvm_ops->owner);
481}
482
483int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
484{
485 int r;
486
487 int hv_enabled = kvmppc_hv_ops ? 1 : 0;
488
489 if (kvm) {
490
491
492
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
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_ALLOC_HTAB:
540 case KVM_CAP_PPC_RTAS:
541 case KVM_CAP_PPC_FIXUP_HCALL:
542 case KVM_CAP_PPC_ENABLE_HCALL:
543#ifdef CONFIG_KVM_XICS
544 case KVM_CAP_IRQ_XICS:
545#endif
546 r = 1;
547 break;
548#endif
549#ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
550 case KVM_CAP_PPC_SMT:
551 if (hv_enabled)
552 r = threads_per_subcore;
553 else
554 r = 0;
555 break;
556 case KVM_CAP_PPC_RMA:
557 r = 0;
558 break;
559 case KVM_CAP_PPC_HWRNG:
560 r = kvmppc_hwrng_present();
561 break;
562#endif
563 case KVM_CAP_SYNC_MMU:
564#ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
565 r = hv_enabled;
566#elif defined(KVM_ARCH_WANT_MMU_NOTIFIER)
567 r = 1;
568#else
569 r = 0;
570#endif
571 break;
572#ifdef CONFIG_KVM_BOOK3S_HV_POSSIBLE
573 case KVM_CAP_PPC_HTAB_FD:
574 r = hv_enabled;
575 break;
576#endif
577 case KVM_CAP_NR_VCPUS:
578
579
580
581
582
583
584 if (hv_enabled)
585 r = num_present_cpus();
586 else
587 r = num_online_cpus();
588 break;
589 case KVM_CAP_NR_MEMSLOTS:
590 r = KVM_USER_MEM_SLOTS;
591 break;
592 case KVM_CAP_MAX_VCPUS:
593 r = KVM_MAX_VCPUS;
594 break;
595#ifdef CONFIG_PPC_BOOK3S_64
596 case KVM_CAP_PPC_GET_SMMU_INFO:
597 r = 1;
598 break;
599 case KVM_CAP_SPAPR_MULTITCE:
600 r = 1;
601 break;
602#endif
603 case KVM_CAP_PPC_HTM:
604 r = cpu_has_feature(CPU_FTR_TM_COMP) &&
605 is_kvmppc_hv_enabled(kvm);
606 break;
607 default:
608 r = 0;
609 break;
610 }
611 return r;
612
613}
614
615long kvm_arch_dev_ioctl(struct file *filp,
616 unsigned int ioctl, unsigned long arg)
617{
618 return -EINVAL;
619}
620
621void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
622 struct kvm_memory_slot *dont)
623{
624 kvmppc_core_free_memslot(kvm, free, dont);
625}
626
627int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
628 unsigned long npages)
629{
630 return kvmppc_core_create_memslot(kvm, slot, npages);
631}
632
633int kvm_arch_prepare_memory_region(struct kvm *kvm,
634 struct kvm_memory_slot *memslot,
635 const struct kvm_userspace_memory_region *mem,
636 enum kvm_mr_change change)
637{
638 return kvmppc_core_prepare_memory_region(kvm, memslot, mem);
639}
640
641void kvm_arch_commit_memory_region(struct kvm *kvm,
642 const struct kvm_userspace_memory_region *mem,
643 const struct kvm_memory_slot *old,
644 const struct kvm_memory_slot *new,
645 enum kvm_mr_change change)
646{
647 kvmppc_core_commit_memory_region(kvm, mem, old, new);
648}
649
650void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
651 struct kvm_memory_slot *slot)
652{
653 kvmppc_core_flush_memslot(kvm, slot);
654}
655
656struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id)
657{
658 struct kvm_vcpu *vcpu;
659 vcpu = kvmppc_core_vcpu_create(kvm, id);
660 if (!IS_ERR(vcpu)) {
661 vcpu->arch.wqp = &vcpu->wq;
662 kvmppc_create_vcpu_debugfs(vcpu, id);
663 }
664 return vcpu;
665}
666
667void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
668{
669}
670
671void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
672{
673
674 hrtimer_cancel(&vcpu->arch.dec_timer);
675
676 kvmppc_remove_vcpu_debugfs(vcpu);
677
678 switch (vcpu->arch.irq_type) {
679 case KVMPPC_IRQ_MPIC:
680 kvmppc_mpic_disconnect_vcpu(vcpu->arch.mpic, vcpu);
681 break;
682 case KVMPPC_IRQ_XICS:
683 kvmppc_xics_free_icp(vcpu);
684 break;
685 }
686
687 kvmppc_core_vcpu_free(vcpu);
688}
689
690void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
691{
692 kvm_arch_vcpu_free(vcpu);
693}
694
695int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
696{
697 return kvmppc_core_pending_dec(vcpu);
698}
699
700static enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer)
701{
702 struct kvm_vcpu *vcpu;
703
704 vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer);
705 kvmppc_decrementer_func(vcpu);
706
707 return HRTIMER_NORESTART;
708}
709
710int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
711{
712 int ret;
713
714 hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
715 vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup;
716 vcpu->arch.dec_expires = ~(u64)0;
717
718#ifdef CONFIG_KVM_EXIT_TIMING
719 mutex_init(&vcpu->arch.exit_timing_lock);
720#endif
721 ret = kvmppc_subarch_vcpu_init(vcpu);
722 return ret;
723}
724
725void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
726{
727 kvmppc_mmu_destroy(vcpu);
728 kvmppc_subarch_vcpu_uninit(vcpu);
729}
730
731void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
732{
733#ifdef CONFIG_BOOKE
734
735
736
737
738
739
740
741 mtspr(SPRN_VRSAVE, vcpu->arch.vrsave);
742#endif
743 kvmppc_core_vcpu_load(vcpu, cpu);
744}
745
746void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
747{
748 kvmppc_core_vcpu_put(vcpu);
749#ifdef CONFIG_BOOKE
750 vcpu->arch.vrsave = mfspr(SPRN_VRSAVE);
751#endif
752}
753
754
755
756
757
758
759
760bool kvm_arch_has_irq_bypass(void)
761{
762 return ((kvmppc_hv_ops && kvmppc_hv_ops->irq_bypass_add_producer) ||
763 (kvmppc_pr_ops && kvmppc_pr_ops->irq_bypass_add_producer));
764}
765
766int kvm_arch_irq_bypass_add_producer(struct irq_bypass_consumer *cons,
767 struct irq_bypass_producer *prod)
768{
769 struct kvm_kernel_irqfd *irqfd =
770 container_of(cons, struct kvm_kernel_irqfd, consumer);
771 struct kvm *kvm = irqfd->kvm;
772
773 if (kvm->arch.kvm_ops->irq_bypass_add_producer)
774 return kvm->arch.kvm_ops->irq_bypass_add_producer(cons, prod);
775
776 return 0;
777}
778
779void kvm_arch_irq_bypass_del_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_del_producer)
787 kvm->arch.kvm_ops->irq_bypass_del_producer(cons, prod);
788}
789
790static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu,
791 struct kvm_run *run)
792{
793 u64 uninitialized_var(gpr);
794
795 if (run->mmio.len > sizeof(gpr)) {
796 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len);
797 return;
798 }
799
800 if (!vcpu->arch.mmio_host_swabbed) {
801 switch (run->mmio.len) {
802 case 8: gpr = *(u64 *)run->mmio.data; break;
803 case 4: gpr = *(u32 *)run->mmio.data; break;
804 case 2: gpr = *(u16 *)run->mmio.data; break;
805 case 1: gpr = *(u8 *)run->mmio.data; break;
806 }
807 } else {
808 switch (run->mmio.len) {
809 case 8: gpr = swab64(*(u64 *)run->mmio.data); break;
810 case 4: gpr = swab32(*(u32 *)run->mmio.data); break;
811 case 2: gpr = swab16(*(u16 *)run->mmio.data); break;
812 case 1: gpr = *(u8 *)run->mmio.data; break;
813 }
814 }
815
816 if (vcpu->arch.mmio_sign_extend) {
817 switch (run->mmio.len) {
818#ifdef CONFIG_PPC64
819 case 4:
820 gpr = (s64)(s32)gpr;
821 break;
822#endif
823 case 2:
824 gpr = (s64)(s16)gpr;
825 break;
826 case 1:
827 gpr = (s64)(s8)gpr;
828 break;
829 }
830 }
831
832 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
833
834 switch (vcpu->arch.io_gpr & KVM_MMIO_REG_EXT_MASK) {
835 case KVM_MMIO_REG_GPR:
836 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
837 break;
838 case KVM_MMIO_REG_FPR:
839 VCPU_FPR(vcpu, vcpu->arch.io_gpr & KVM_MMIO_REG_MASK) = gpr;
840 break;
841#ifdef CONFIG_PPC_BOOK3S
842 case KVM_MMIO_REG_QPR:
843 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
844 break;
845 case KVM_MMIO_REG_FQPR:
846 VCPU_FPR(vcpu, vcpu->arch.io_gpr & KVM_MMIO_REG_MASK) = gpr;
847 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
848 break;
849#endif
850 default:
851 BUG();
852 }
853}
854
855static int __kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
856 unsigned int rt, unsigned int bytes,
857 int is_default_endian, int sign_extend)
858{
859 int idx, ret;
860 bool host_swabbed;
861
862
863 if (kvmppc_need_byteswap(vcpu)) {
864 host_swabbed = is_default_endian;
865 } else {
866 host_swabbed = !is_default_endian;
867 }
868
869 if (bytes > sizeof(run->mmio.data)) {
870 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
871 run->mmio.len);
872 }
873
874 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
875 run->mmio.len = bytes;
876 run->mmio.is_write = 0;
877
878 vcpu->arch.io_gpr = rt;
879 vcpu->arch.mmio_host_swabbed = host_swabbed;
880 vcpu->mmio_needed = 1;
881 vcpu->mmio_is_write = 0;
882 vcpu->arch.mmio_sign_extend = sign_extend;
883
884 idx = srcu_read_lock(&vcpu->kvm->srcu);
885
886 ret = kvm_io_bus_read(vcpu, KVM_MMIO_BUS, run->mmio.phys_addr,
887 bytes, &run->mmio.data);
888
889 srcu_read_unlock(&vcpu->kvm->srcu, idx);
890
891 if (!ret) {
892 kvmppc_complete_mmio_load(vcpu, run);
893 vcpu->mmio_needed = 0;
894 return EMULATE_DONE;
895 }
896
897 return EMULATE_DO_MMIO;
898}
899
900int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
901 unsigned int rt, unsigned int bytes,
902 int is_default_endian)
903{
904 return __kvmppc_handle_load(run, vcpu, rt, bytes, is_default_endian, 0);
905}
906EXPORT_SYMBOL_GPL(kvmppc_handle_load);
907
908
909int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu,
910 unsigned int rt, unsigned int bytes,
911 int is_default_endian)
912{
913 return __kvmppc_handle_load(run, vcpu, rt, bytes, is_default_endian, 1);
914}
915
916int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu,
917 u64 val, unsigned int bytes, int is_default_endian)
918{
919 void *data = run->mmio.data;
920 int idx, ret;
921 bool host_swabbed;
922
923
924 if (kvmppc_need_byteswap(vcpu)) {
925 host_swabbed = is_default_endian;
926 } else {
927 host_swabbed = !is_default_endian;
928 }
929
930 if (bytes > sizeof(run->mmio.data)) {
931 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
932 run->mmio.len);
933 }
934
935 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
936 run->mmio.len = bytes;
937 run->mmio.is_write = 1;
938 vcpu->mmio_needed = 1;
939 vcpu->mmio_is_write = 1;
940
941
942 if (!host_swabbed) {
943 switch (bytes) {
944 case 8: *(u64 *)data = val; break;
945 case 4: *(u32 *)data = val; break;
946 case 2: *(u16 *)data = val; break;
947 case 1: *(u8 *)data = val; break;
948 }
949 } else {
950 switch (bytes) {
951 case 8: *(u64 *)data = swab64(val); break;
952 case 4: *(u32 *)data = swab32(val); break;
953 case 2: *(u16 *)data = swab16(val); break;
954 case 1: *(u8 *)data = val; break;
955 }
956 }
957
958 idx = srcu_read_lock(&vcpu->kvm->srcu);
959
960 ret = kvm_io_bus_write(vcpu, KVM_MMIO_BUS, run->mmio.phys_addr,
961 bytes, &run->mmio.data);
962
963 srcu_read_unlock(&vcpu->kvm->srcu, idx);
964
965 if (!ret) {
966 vcpu->mmio_needed = 0;
967 return EMULATE_DONE;
968 }
969
970 return EMULATE_DO_MMIO;
971}
972EXPORT_SYMBOL_GPL(kvmppc_handle_store);
973
974int kvm_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
975{
976 int r = 0;
977 union kvmppc_one_reg val;
978 int size;
979
980 size = one_reg_size(reg->id);
981 if (size > sizeof(val))
982 return -EINVAL;
983
984 r = kvmppc_get_one_reg(vcpu, reg->id, &val);
985 if (r == -EINVAL) {
986 r = 0;
987 switch (reg->id) {
988#ifdef CONFIG_ALTIVEC
989 case KVM_REG_PPC_VR0 ... KVM_REG_PPC_VR31:
990 if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
991 r = -ENXIO;
992 break;
993 }
994 val.vval = vcpu->arch.vr.vr[reg->id - KVM_REG_PPC_VR0];
995 break;
996 case KVM_REG_PPC_VSCR:
997 if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
998 r = -ENXIO;
999 break;
1000 }
1001 val = get_reg_val(reg->id, vcpu->arch.vr.vscr.u[3]);
1002 break;
1003 case KVM_REG_PPC_VRSAVE:
1004 val = get_reg_val(reg->id, vcpu->arch.vrsave);
1005 break;
1006#endif
1007 default:
1008 r = -EINVAL;
1009 break;
1010 }
1011 }
1012
1013 if (r)
1014 return r;
1015
1016 if (copy_to_user((char __user *)(unsigned long)reg->addr, &val, size))
1017 r = -EFAULT;
1018
1019 return r;
1020}
1021
1022int kvm_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu, struct kvm_one_reg *reg)
1023{
1024 int r;
1025 union kvmppc_one_reg val;
1026 int size;
1027
1028 size = one_reg_size(reg->id);
1029 if (size > sizeof(val))
1030 return -EINVAL;
1031
1032 if (copy_from_user(&val, (char __user *)(unsigned long)reg->addr, size))
1033 return -EFAULT;
1034
1035 r = kvmppc_set_one_reg(vcpu, reg->id, &val);
1036 if (r == -EINVAL) {
1037 r = 0;
1038 switch (reg->id) {
1039#ifdef CONFIG_ALTIVEC
1040 case KVM_REG_PPC_VR0 ... KVM_REG_PPC_VR31:
1041 if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
1042 r = -ENXIO;
1043 break;
1044 }
1045 vcpu->arch.vr.vr[reg->id - KVM_REG_PPC_VR0] = val.vval;
1046 break;
1047 case KVM_REG_PPC_VSCR:
1048 if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
1049 r = -ENXIO;
1050 break;
1051 }
1052 vcpu->arch.vr.vscr.u[3] = set_reg_val(reg->id, val);
1053 break;
1054 case KVM_REG_PPC_VRSAVE:
1055 if (!cpu_has_feature(CPU_FTR_ALTIVEC)) {
1056 r = -ENXIO;
1057 break;
1058 }
1059 vcpu->arch.vrsave = set_reg_val(reg->id, val);
1060 break;
1061#endif
1062 default:
1063 r = -EINVAL;
1064 break;
1065 }
1066 }
1067
1068 return r;
1069}
1070
1071int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
1072{
1073 int r;
1074 sigset_t sigsaved;
1075
1076 if (vcpu->sigset_active)
1077 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
1078
1079 if (vcpu->mmio_needed) {
1080 if (!vcpu->mmio_is_write)
1081 kvmppc_complete_mmio_load(vcpu, run);
1082 vcpu->mmio_needed = 0;
1083 } else if (vcpu->arch.osi_needed) {
1084 u64 *gprs = run->osi.gprs;
1085 int i;
1086
1087 for (i = 0; i < 32; i++)
1088 kvmppc_set_gpr(vcpu, i, gprs[i]);
1089 vcpu->arch.osi_needed = 0;
1090 } else if (vcpu->arch.hcall_needed) {
1091 int i;
1092
1093 kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret);
1094 for (i = 0; i < 9; ++i)
1095 kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]);
1096 vcpu->arch.hcall_needed = 0;
1097#ifdef CONFIG_BOOKE
1098 } else if (vcpu->arch.epr_needed) {
1099 kvmppc_set_epr(vcpu, run->epr.epr);
1100 vcpu->arch.epr_needed = 0;
1101#endif
1102 }
1103
1104 r = kvmppc_vcpu_run(run, vcpu);
1105
1106 if (vcpu->sigset_active)
1107 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1108
1109 return r;
1110}
1111
1112int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq)
1113{
1114 if (irq->irq == KVM_INTERRUPT_UNSET) {
1115 kvmppc_core_dequeue_external(vcpu);
1116 return 0;
1117 }
1118
1119 kvmppc_core_queue_external(vcpu, irq);
1120
1121 kvm_vcpu_kick(vcpu);
1122
1123 return 0;
1124}
1125
1126static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
1127 struct kvm_enable_cap *cap)
1128{
1129 int r;
1130
1131 if (cap->flags)
1132 return -EINVAL;
1133
1134 switch (cap->cap) {
1135 case KVM_CAP_PPC_OSI:
1136 r = 0;
1137 vcpu->arch.osi_enabled = true;
1138 break;
1139 case KVM_CAP_PPC_PAPR:
1140 r = 0;
1141 vcpu->arch.papr_enabled = true;
1142 break;
1143 case KVM_CAP_PPC_EPR:
1144 r = 0;
1145 if (cap->args[0])
1146 vcpu->arch.epr_flags |= KVMPPC_EPR_USER;
1147 else
1148 vcpu->arch.epr_flags &= ~KVMPPC_EPR_USER;
1149 break;
1150#ifdef CONFIG_BOOKE
1151 case KVM_CAP_PPC_BOOKE_WATCHDOG:
1152 r = 0;
1153 vcpu->arch.watchdog_enabled = true;
1154 break;
1155#endif
1156#if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
1157 case KVM_CAP_SW_TLB: {
1158 struct kvm_config_tlb cfg;
1159 void __user *user_ptr = (void __user *)(uintptr_t)cap->args[0];
1160
1161 r = -EFAULT;
1162 if (copy_from_user(&cfg, user_ptr, sizeof(cfg)))
1163 break;
1164
1165 r = kvm_vcpu_ioctl_config_tlb(vcpu, &cfg);
1166 break;
1167 }
1168#endif
1169#ifdef CONFIG_KVM_MPIC
1170 case KVM_CAP_IRQ_MPIC: {
1171 struct fd f;
1172 struct kvm_device *dev;
1173
1174 r = -EBADF;
1175 f = fdget(cap->args[0]);
1176 if (!f.file)
1177 break;
1178
1179 r = -EPERM;
1180 dev = kvm_device_from_filp(f.file);
1181 if (dev)
1182 r = kvmppc_mpic_connect_vcpu(dev, vcpu, cap->args[1]);
1183
1184 fdput(f);
1185 break;
1186 }
1187#endif
1188#ifdef CONFIG_KVM_XICS
1189 case KVM_CAP_IRQ_XICS: {
1190 struct fd f;
1191 struct kvm_device *dev;
1192
1193 r = -EBADF;
1194 f = fdget(cap->args[0]);
1195 if (!f.file)
1196 break;
1197
1198 r = -EPERM;
1199 dev = kvm_device_from_filp(f.file);
1200 if (dev)
1201 r = kvmppc_xics_connect_vcpu(dev, vcpu, cap->args[1]);
1202
1203 fdput(f);
1204 break;
1205 }
1206#endif
1207 default:
1208 r = -EINVAL;
1209 break;
1210 }
1211
1212 if (!r)
1213 r = kvmppc_sanity_check(vcpu);
1214
1215 return r;
1216}
1217
1218bool kvm_arch_intc_initialized(struct kvm *kvm)
1219{
1220#ifdef CONFIG_KVM_MPIC
1221 if (kvm->arch.mpic)
1222 return true;
1223#endif
1224#ifdef CONFIG_KVM_XICS
1225 if (kvm->arch.xics)
1226 return true;
1227#endif
1228 return false;
1229}
1230
1231int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
1232 struct kvm_mp_state *mp_state)
1233{
1234 return -EINVAL;
1235}
1236
1237int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
1238 struct kvm_mp_state *mp_state)
1239{
1240 return -EINVAL;
1241}
1242
1243long kvm_arch_vcpu_ioctl(struct file *filp,
1244 unsigned int ioctl, unsigned long arg)
1245{
1246 struct kvm_vcpu *vcpu = filp->private_data;
1247 void __user *argp = (void __user *)arg;
1248 long r;
1249
1250 switch (ioctl) {
1251 case KVM_INTERRUPT: {
1252 struct kvm_interrupt irq;
1253 r = -EFAULT;
1254 if (copy_from_user(&irq, argp, sizeof(irq)))
1255 goto out;
1256 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq);
1257 goto out;
1258 }
1259
1260 case KVM_ENABLE_CAP:
1261 {
1262 struct kvm_enable_cap cap;
1263 r = -EFAULT;
1264 if (copy_from_user(&cap, argp, sizeof(cap)))
1265 goto out;
1266 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
1267 break;
1268 }
1269
1270 case KVM_SET_ONE_REG:
1271 case KVM_GET_ONE_REG:
1272 {
1273 struct kvm_one_reg reg;
1274 r = -EFAULT;
1275 if (copy_from_user(®, argp, sizeof(reg)))
1276 goto out;
1277 if (ioctl == KVM_SET_ONE_REG)
1278 r = kvm_vcpu_ioctl_set_one_reg(vcpu, ®);
1279 else
1280 r = kvm_vcpu_ioctl_get_one_reg(vcpu, ®);
1281 break;
1282 }
1283
1284#if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
1285 case KVM_DIRTY_TLB: {
1286 struct kvm_dirty_tlb dirty;
1287 r = -EFAULT;
1288 if (copy_from_user(&dirty, argp, sizeof(dirty)))
1289 goto out;
1290 r = kvm_vcpu_ioctl_dirty_tlb(vcpu, &dirty);
1291 break;
1292 }
1293#endif
1294 default:
1295 r = -EINVAL;
1296 }
1297
1298out:
1299 return r;
1300}
1301
1302int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
1303{
1304 return VM_FAULT_SIGBUS;
1305}
1306
1307static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo)
1308{
1309 u32 inst_nop = 0x60000000;
1310#ifdef CONFIG_KVM_BOOKE_HV
1311 u32 inst_sc1 = 0x44000022;
1312 pvinfo->hcall[0] = cpu_to_be32(inst_sc1);
1313 pvinfo->hcall[1] = cpu_to_be32(inst_nop);
1314 pvinfo->hcall[2] = cpu_to_be32(inst_nop);
1315 pvinfo->hcall[3] = cpu_to_be32(inst_nop);
1316#else
1317 u32 inst_lis = 0x3c000000;
1318 u32 inst_ori = 0x60000000;
1319 u32 inst_sc = 0x44000002;
1320 u32 inst_imm_mask = 0xffff;
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331 pvinfo->hcall[0] = cpu_to_be32(inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask));
1332 pvinfo->hcall[1] = cpu_to_be32(inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask));
1333 pvinfo->hcall[2] = cpu_to_be32(inst_sc);
1334 pvinfo->hcall[3] = cpu_to_be32(inst_nop);
1335#endif
1336
1337 pvinfo->flags = KVM_PPC_PVINFO_FLAGS_EV_IDLE;
1338
1339 return 0;
1340}
1341
1342int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_event,
1343 bool line_status)
1344{
1345 if (!irqchip_in_kernel(kvm))
1346 return -ENXIO;
1347
1348 irq_event->status = kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID,
1349 irq_event->irq, irq_event->level,
1350 line_status);
1351 return 0;
1352}
1353
1354
1355static int kvm_vm_ioctl_enable_cap(struct kvm *kvm,
1356 struct kvm_enable_cap *cap)
1357{
1358 int r;
1359
1360 if (cap->flags)
1361 return -EINVAL;
1362
1363 switch (cap->cap) {
1364#ifdef CONFIG_KVM_BOOK3S_64_HANDLER
1365 case KVM_CAP_PPC_ENABLE_HCALL: {
1366 unsigned long hcall = cap->args[0];
1367
1368 r = -EINVAL;
1369 if (hcall > MAX_HCALL_OPCODE || (hcall & 3) ||
1370 cap->args[1] > 1)
1371 break;
1372 if (!kvmppc_book3s_hcall_implemented(kvm, hcall))
1373 break;
1374 if (cap->args[1])
1375 set_bit(hcall / 4, kvm->arch.enabled_hcalls);
1376 else
1377 clear_bit(hcall / 4, kvm->arch.enabled_hcalls);
1378 r = 0;
1379 break;
1380 }
1381#endif
1382 default:
1383 r = -EINVAL;
1384 break;
1385 }
1386
1387 return r;
1388}
1389
1390long kvm_arch_vm_ioctl(struct file *filp,
1391 unsigned int ioctl, unsigned long arg)
1392{
1393 struct kvm *kvm __maybe_unused = filp->private_data;
1394 void __user *argp = (void __user *)arg;
1395 long r;
1396
1397 switch (ioctl) {
1398 case KVM_PPC_GET_PVINFO: {
1399 struct kvm_ppc_pvinfo pvinfo;
1400 memset(&pvinfo, 0, sizeof(pvinfo));
1401 r = kvm_vm_ioctl_get_pvinfo(&pvinfo);
1402 if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) {
1403 r = -EFAULT;
1404 goto out;
1405 }
1406
1407 break;
1408 }
1409 case KVM_ENABLE_CAP:
1410 {
1411 struct kvm_enable_cap cap;
1412 r = -EFAULT;
1413 if (copy_from_user(&cap, argp, sizeof(cap)))
1414 goto out;
1415 r = kvm_vm_ioctl_enable_cap(kvm, &cap);
1416 break;
1417 }
1418#ifdef CONFIG_PPC_BOOK3S_64
1419 case KVM_CREATE_SPAPR_TCE_64: {
1420 struct kvm_create_spapr_tce_64 create_tce_64;
1421
1422 r = -EFAULT;
1423 if (copy_from_user(&create_tce_64, argp, sizeof(create_tce_64)))
1424 goto out;
1425 if (create_tce_64.flags) {
1426 r = -EINVAL;
1427 goto out;
1428 }
1429 r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce_64);
1430 goto out;
1431 }
1432 case KVM_CREATE_SPAPR_TCE: {
1433 struct kvm_create_spapr_tce create_tce;
1434 struct kvm_create_spapr_tce_64 create_tce_64;
1435
1436 r = -EFAULT;
1437 if (copy_from_user(&create_tce, argp, sizeof(create_tce)))
1438 goto out;
1439
1440 create_tce_64.liobn = create_tce.liobn;
1441 create_tce_64.page_shift = IOMMU_PAGE_SHIFT_4K;
1442 create_tce_64.offset = 0;
1443 create_tce_64.size = create_tce.window_size >>
1444 IOMMU_PAGE_SHIFT_4K;
1445 create_tce_64.flags = 0;
1446 r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce_64);
1447 goto out;
1448 }
1449 case KVM_PPC_GET_SMMU_INFO: {
1450 struct kvm_ppc_smmu_info info;
1451 struct kvm *kvm = filp->private_data;
1452
1453 memset(&info, 0, sizeof(info));
1454 r = kvm->arch.kvm_ops->get_smmu_info(kvm, &info);
1455 if (r >= 0 && copy_to_user(argp, &info, sizeof(info)))
1456 r = -EFAULT;
1457 break;
1458 }
1459 case KVM_PPC_RTAS_DEFINE_TOKEN: {
1460 struct kvm *kvm = filp->private_data;
1461
1462 r = kvm_vm_ioctl_rtas_define_token(kvm, argp);
1463 break;
1464 }
1465 default: {
1466 struct kvm *kvm = filp->private_data;
1467 r = kvm->arch.kvm_ops->arch_vm_ioctl(filp, ioctl, arg);
1468 }
1469#else
1470 default:
1471 r = -ENOTTY;
1472#endif
1473 }
1474out:
1475 return r;
1476}
1477
1478static unsigned long lpid_inuse[BITS_TO_LONGS(KVMPPC_NR_LPIDS)];
1479static unsigned long nr_lpids;
1480
1481long kvmppc_alloc_lpid(void)
1482{
1483 long lpid;
1484
1485 do {
1486 lpid = find_first_zero_bit(lpid_inuse, KVMPPC_NR_LPIDS);
1487 if (lpid >= nr_lpids) {
1488 pr_err("%s: No LPIDs free\n", __func__);
1489 return -ENOMEM;
1490 }
1491 } while (test_and_set_bit(lpid, lpid_inuse));
1492
1493 return lpid;
1494}
1495EXPORT_SYMBOL_GPL(kvmppc_alloc_lpid);
1496
1497void kvmppc_claim_lpid(long lpid)
1498{
1499 set_bit(lpid, lpid_inuse);
1500}
1501EXPORT_SYMBOL_GPL(kvmppc_claim_lpid);
1502
1503void kvmppc_free_lpid(long lpid)
1504{
1505 clear_bit(lpid, lpid_inuse);
1506}
1507EXPORT_SYMBOL_GPL(kvmppc_free_lpid);
1508
1509void kvmppc_init_lpid(unsigned long nr_lpids_param)
1510{
1511 nr_lpids = min_t(unsigned long, KVMPPC_NR_LPIDS, nr_lpids_param);
1512 memset(lpid_inuse, 0, sizeof(lpid_inuse));
1513}
1514EXPORT_SYMBOL_GPL(kvmppc_init_lpid);
1515
1516int kvm_arch_init(void *opaque)
1517{
1518 return 0;
1519}
1520
1521EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_ppc_instr);
1522
