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