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