blob: 750835a4ef70759c68a6febf0437fa7a6fff07ea [file] [log] [blame]
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -05001/*
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>
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050024#include <linux/vmalloc.h>
Alexander Graf544c6762009-11-02 12:02:31 +000025#include <linux/hrtimer.h>
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050026#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090027#include <linux/slab.h>
Scott Woodeb1e4f42013-04-12 14:08:47 +000028#include <linux/file.h>
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050029#include <asm/cputable.h>
30#include <asm/uaccess.h>
31#include <asm/kvm_ppc.h>
Hollis Blanchard83aae4a2008-07-25 13:54:52 -050032#include <asm/tlbflush.h>
Paul Mackerras371fefd2011-06-29 00:23:08 +000033#include <asm/cputhreads.h>
Alexander Grafbd2be682012-08-13 01:04:19 +020034#include <asm/irqflags.h>
Hollis Blanchard73e75b412008-12-02 15:51:57 -060035#include "timing.h"
Alexander Graf5efdb4b2013-04-17 00:37:57 +020036#include "irq.h"
Paul Mackerrasfad7b9b2008-12-23 14:57:26 +110037#include "../mm/mmu_decl.h"
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050038
Marcelo Tosatti46f43c62009-06-18 11:47:27 -030039#define CREATE_TRACE_POINTS
40#include "trace.h"
41
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050042int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
43{
Liu Yu-B132019202e072012-07-03 05:48:52 +000044 return !!(v->arch.pending_exceptions) ||
Scott Wooddfd4d472011-11-17 12:39:59 +000045 v->requests;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050046}
47
Christoffer Dallb6d33832012-03-08 16:44:24 -050048int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
49{
50 return 1;
51}
52
Alexander Graf03d25c52012-08-10 12:28:50 +020053#ifndef CONFIG_KVM_BOOK3S_64_HV
54/*
55 * Common checks before entering the guest world. Call with interrupts
56 * disabled.
57 *
Alexander Graf7ee78852012-08-13 12:44:41 +020058 * returns:
59 *
60 * == 1 if we're ready to go into guest state
61 * <= 0 if we need to go back to the host with return value
Alexander Graf03d25c52012-08-10 12:28:50 +020062 */
63int kvmppc_prepare_to_enter(struct kvm_vcpu *vcpu)
64{
Alexander Graf7ee78852012-08-13 12:44:41 +020065 int r = 1;
Alexander Graf03d25c52012-08-10 12:28:50 +020066
67 WARN_ON_ONCE(!irqs_disabled());
68 while (true) {
69 if (need_resched()) {
70 local_irq_enable();
71 cond_resched();
72 local_irq_disable();
73 continue;
74 }
75
76 if (signal_pending(current)) {
Alexander Graf7ee78852012-08-13 12:44:41 +020077 kvmppc_account_exit(vcpu, SIGNAL_EXITS);
78 vcpu->run->exit_reason = KVM_EXIT_INTR;
79 r = -EINTR;
Alexander Graf03d25c52012-08-10 12:28:50 +020080 break;
81 }
82
Scott Wood5bd1cf12012-08-22 15:03:50 +000083 vcpu->mode = IN_GUEST_MODE;
84
85 /*
86 * Reading vcpu->requests must happen after setting vcpu->mode,
87 * so we don't miss a request because the requester sees
88 * OUTSIDE_GUEST_MODE and assumes we'll be checking requests
89 * before next entering the guest (and thus doesn't IPI).
90 */
Alexander Graf03d25c52012-08-10 12:28:50 +020091 smp_mb();
Scott Wood5bd1cf12012-08-22 15:03:50 +000092
Alexander Graf03d25c52012-08-10 12:28:50 +020093 if (vcpu->requests) {
94 /* Make sure we process requests preemptable */
95 local_irq_enable();
96 trace_kvm_check_requests(vcpu);
Alexander Graf7c973a22012-08-13 12:50:35 +020097 r = kvmppc_core_check_requests(vcpu);
Alexander Graf03d25c52012-08-10 12:28:50 +020098 local_irq_disable();
Alexander Graf7c973a22012-08-13 12:50:35 +020099 if (r > 0)
100 continue;
101 break;
Alexander Graf03d25c52012-08-10 12:28:50 +0200102 }
103
104 if (kvmppc_core_prepare_to_enter(vcpu)) {
105 /* interrupts got enabled in between, so we
106 are back at square 1 */
107 continue;
108 }
109
Alexander Grafbd2be682012-08-13 01:04:19 +0200110#ifdef CONFIG_PPC64
111 /* lazy EE magic */
112 hard_irq_disable();
113 if (lazy_irq_pending()) {
114 /* Got an interrupt in between, try again */
115 local_irq_enable();
116 local_irq_disable();
Alexander Graf3766a4c2012-08-13 01:24:01 +0200117 kvm_guest_exit();
Alexander Grafbd2be682012-08-13 01:04:19 +0200118 continue;
119 }
120
121 trace_hardirqs_on();
122#endif
123
Alexander Graf3766a4c2012-08-13 01:24:01 +0200124 kvm_guest_enter();
Alexander Graf03d25c52012-08-10 12:28:50 +0200125 break;
126 }
127
128 return r;
129}
130#endif /* CONFIG_KVM_BOOK3S_64_HV */
131
Alexander Graf2a342ed2010-07-29 14:47:48 +0200132int kvmppc_kvm_pv(struct kvm_vcpu *vcpu)
133{
134 int nr = kvmppc_get_gpr(vcpu, 11);
135 int r;
136 unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3);
137 unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4);
138 unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5);
139 unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6);
140 unsigned long r2 = 0;
141
142 if (!(vcpu->arch.shared->msr & MSR_SF)) {
143 /* 32 bit mode */
144 param1 &= 0xffffffff;
145 param2 &= 0xffffffff;
146 param3 &= 0xffffffff;
147 param4 &= 0xffffffff;
148 }
149
150 switch (nr) {
Stuart Yoderfdcf8bd2012-07-03 05:48:50 +0000151 case KVM_HCALL_TOKEN(KVM_HC_PPC_MAP_MAGIC_PAGE):
Alexander Graf5fc87402010-07-29 14:47:55 +0200152 {
153 vcpu->arch.magic_page_pa = param1;
154 vcpu->arch.magic_page_ea = param2;
155
Scott Woodb5904972011-11-08 18:23:30 -0600156 r2 = KVM_MAGIC_FEAT_SR | KVM_MAGIC_FEAT_MAS0_TO_SPRG7;
Alexander Graf7508e162010-08-03 11:32:56 +0200157
Stuart Yoderfdcf8bd2012-07-03 05:48:50 +0000158 r = EV_SUCCESS;
Alexander Graf5fc87402010-07-29 14:47:55 +0200159 break;
160 }
Stuart Yoderfdcf8bd2012-07-03 05:48:50 +0000161 case KVM_HCALL_TOKEN(KVM_HC_FEATURES):
162 r = EV_SUCCESS;
Alexander Grafbf7ca4b2012-02-15 23:40:00 +0000163#if defined(CONFIG_PPC_BOOK3S) || defined(CONFIG_KVM_E500V2)
Scott Wooda4cd8b22011-06-14 18:34:41 -0500164 /* XXX Missing magic page on 44x */
Alexander Graf5fc87402010-07-29 14:47:55 +0200165 r2 |= (1 << KVM_FEATURE_MAGIC_PAGE);
166#endif
Alexander Graf2a342ed2010-07-29 14:47:48 +0200167
168 /* Second return value is in r4 */
Alexander Graf2a342ed2010-07-29 14:47:48 +0200169 break;
Liu Yu-B132019202e072012-07-03 05:48:52 +0000170 case EV_HCALL_TOKEN(EV_IDLE):
171 r = EV_SUCCESS;
172 kvm_vcpu_block(vcpu);
173 clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
174 break;
Alexander Graf2a342ed2010-07-29 14:47:48 +0200175 default:
Stuart Yoderfdcf8bd2012-07-03 05:48:50 +0000176 r = EV_UNIMPLEMENTED;
Alexander Graf2a342ed2010-07-29 14:47:48 +0200177 break;
178 }
179
Alexander Graf7508e162010-08-03 11:32:56 +0200180 kvmppc_set_gpr(vcpu, 4, r2);
181
Alexander Graf2a342ed2010-07-29 14:47:48 +0200182 return r;
183}
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500184
Alexander Grafaf8f38b2011-08-10 13:57:08 +0200185int kvmppc_sanity_check(struct kvm_vcpu *vcpu)
186{
187 int r = false;
188
189 /* We have to know what CPU to virtualize */
190 if (!vcpu->arch.pvr)
191 goto out;
192
193 /* PAPR only works with book3s_64 */
194 if ((vcpu->arch.cpu_type != KVM_CPU_3S_64) && vcpu->arch.papr_enabled)
195 goto out;
196
197#ifdef CONFIG_KVM_BOOK3S_64_HV
198 /* HV KVM can only do PAPR mode for now */
199 if (!vcpu->arch.papr_enabled)
200 goto out;
201#endif
202
Scott Woodd30f6e42011-12-20 15:34:43 +0000203#ifdef CONFIG_KVM_BOOKE_HV
204 if (!cpu_has_feature(CPU_FTR_EMB_HV))
205 goto out;
206#endif
207
Alexander Grafaf8f38b2011-08-10 13:57:08 +0200208 r = true;
209
210out:
211 vcpu->arch.sane = r;
212 return r ? 0 : -EINVAL;
213}
214
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500215int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu)
216{
217 enum emulation_result er;
218 int r;
219
220 er = kvmppc_emulate_instruction(run, vcpu);
221 switch (er) {
222 case EMULATE_DONE:
223 /* Future optimization: only reload non-volatiles if they were
224 * actually modified. */
225 r = RESUME_GUEST_NV;
226 break;
227 case EMULATE_DO_MMIO:
228 run->exit_reason = KVM_EXIT_MMIO;
229 /* We must reload nonvolatiles because "update" load/store
230 * instructions modify register state. */
231 /* Future optimization: only reload non-volatiles if they were
232 * actually modified. */
233 r = RESUME_HOST_NV;
234 break;
235 case EMULATE_FAIL:
236 /* XXX Deliver Program interrupt to guest. */
237 printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__,
Alexander Grafc7f38f42010-04-16 00:11:40 +0200238 kvmppc_get_last_inst(vcpu));
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500239 r = RESUME_HOST;
240 break;
241 default:
Alexander Graf5a331692012-12-14 23:46:03 +0100242 WARN_ON(1);
243 r = RESUME_GUEST;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500244 }
245
246 return r;
247}
248
Alexander Graf10474ae2009-09-15 11:37:46 +0200249int kvm_arch_hardware_enable(void *garbage)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500250{
Alexander Graf10474ae2009-09-15 11:37:46 +0200251 return 0;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500252}
253
254void kvm_arch_hardware_disable(void *garbage)
255{
256}
257
258int kvm_arch_hardware_setup(void)
259{
260 return 0;
261}
262
263void kvm_arch_hardware_unsetup(void)
264{
265}
266
267void kvm_arch_check_processor_compat(void *rtn)
268{
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600269 *(int *)rtn = kvmppc_core_check_processor_compat();
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500270}
271
Carsten Ottee08b9632012-01-04 10:25:20 +0100272int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500273{
Carsten Ottee08b9632012-01-04 10:25:20 +0100274 if (type)
275 return -EINVAL;
276
Paul Mackerrasf9e05542011-06-29 00:19:22 +0000277 return kvmppc_core_init_vm(kvm);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500278}
279
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100280void kvm_arch_destroy_vm(struct kvm *kvm)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500281{
282 unsigned int i;
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300283 struct kvm_vcpu *vcpu;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500284
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300285 kvm_for_each_vcpu(i, vcpu, kvm)
286 kvm_arch_vcpu_free(vcpu);
287
288 mutex_lock(&kvm->lock);
289 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
290 kvm->vcpus[i] = NULL;
291
292 atomic_set(&kvm->online_vcpus, 0);
Paul Mackerrasf9e05542011-06-29 00:19:22 +0000293
294 kvmppc_core_destroy_vm(kvm);
295
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300296 mutex_unlock(&kvm->lock);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500297}
298
Sheng Yangad8ba2c2009-01-06 10:03:02 +0800299void kvm_arch_sync_events(struct kvm *kvm)
300{
301}
302
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500303int kvm_dev_ioctl_check_extension(long ext)
304{
305 int r;
306
307 switch (ext) {
Scott Wood5ce941e2011-04-27 17:24:21 -0500308#ifdef CONFIG_BOOKE
309 case KVM_CAP_PPC_BOOKE_SREGS:
Bharat Bhushanf61c94b2012-08-08 20:38:19 +0000310 case KVM_CAP_PPC_BOOKE_WATCHDOG:
Alexander Graf1c810632013-01-04 18:12:48 +0100311 case KVM_CAP_PPC_EPR:
Scott Wood5ce941e2011-04-27 17:24:21 -0500312#else
Alexander Grafe15a1132009-11-30 03:02:02 +0000313 case KVM_CAP_PPC_SEGSTATE:
Alexander Graf1022fc32011-09-14 21:45:23 +0200314 case KVM_CAP_PPC_HIOR:
Alexander Graf930b4122011-08-08 17:29:42 +0200315 case KVM_CAP_PPC_PAPR:
Scott Wood5ce941e2011-04-27 17:24:21 -0500316#endif
Alexander Graf18978762010-03-24 21:48:18 +0100317 case KVM_CAP_PPC_UNSET_IRQ:
Alexander Graf7b4203e2010-08-30 13:50:45 +0200318 case KVM_CAP_PPC_IRQ_LEVEL:
Alexander Graf71fbfd52010-03-24 21:48:29 +0100319 case KVM_CAP_ENABLE_CAP:
Alexander Grafe24ed812011-09-14 10:02:41 +0200320 case KVM_CAP_ONE_REG:
Alexander Graf0e673fb2012-10-09 00:06:20 +0200321 case KVM_CAP_IOEVENTFD:
Scott Wood5df554ad2013-04-12 14:08:46 +0000322 case KVM_CAP_DEVICE_CTRL:
Paul Mackerrasde56a942011-06-29 00:21:34 +0000323 r = 1;
324 break;
325#ifndef CONFIG_KVM_BOOK3S_64_HV
326 case KVM_CAP_PPC_PAIRED_SINGLES:
Alexander Grafad0a0482010-03-24 21:48:30 +0100327 case KVM_CAP_PPC_OSI:
Alexander Graf15711e92010-07-29 14:48:08 +0200328 case KVM_CAP_PPC_GET_PVINFO:
Alexander Grafbf7ca4b2012-02-15 23:40:00 +0000329#if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
Scott Wooddc83b8b2011-08-18 15:25:21 -0500330 case KVM_CAP_SW_TLB:
331#endif
Scott Woodeb1e4f42013-04-12 14:08:47 +0000332#ifdef CONFIG_KVM_MPIC
333 case KVM_CAP_IRQ_MPIC:
334#endif
Alexander Grafe15a1132009-11-30 03:02:02 +0000335 r = 1;
336 break;
Laurent Vivier588968b2008-05-30 16:05:56 +0200337 case KVM_CAP_COALESCED_MMIO:
338 r = KVM_COALESCED_MMIO_PAGE_OFFSET;
339 break;
Paul Mackerrasde56a942011-06-29 00:21:34 +0000340#endif
Benjamin Herrenschmidtf31e65e2012-03-15 21:58:34 +0000341#ifdef CONFIG_PPC_BOOK3S_64
David Gibson54738c02011-06-29 00:22:41 +0000342 case KVM_CAP_SPAPR_TCE:
Paul Mackerras32fad282012-05-04 02:32:53 +0000343 case KVM_CAP_PPC_ALLOC_HTAB:
Michael Ellerman8e591cb2013-04-17 20:30:00 +0000344 case KVM_CAP_PPC_RTAS:
Paul Mackerras5975a2e2013-04-27 00:28:37 +0000345#ifdef CONFIG_KVM_XICS
346 case KVM_CAP_IRQ_XICS:
347#endif
David Gibson54738c02011-06-29 00:22:41 +0000348 r = 1;
349 break;
Benjamin Herrenschmidtf31e65e2012-03-15 21:58:34 +0000350#endif /* CONFIG_PPC_BOOK3S_64 */
351#ifdef CONFIG_KVM_BOOK3S_64_HV
Paul Mackerras371fefd2011-06-29 00:23:08 +0000352 case KVM_CAP_PPC_SMT:
353 r = threads_per_core;
354 break;
Paul Mackerrasaa04b4c2011-06-29 00:25:44 +0000355 case KVM_CAP_PPC_RMA:
356 r = 1;
Paul Mackerras9e368f22011-06-29 00:40:08 +0000357 /* PPC970 requires an RMA */
358 if (cpu_has_feature(CPU_FTR_ARCH_201))
359 r = 2;
Paul Mackerrasaa04b4c2011-06-29 00:25:44 +0000360 break;
David Gibson54738c02011-06-29 00:22:41 +0000361#endif
Alexander Graff4800b12012-08-07 10:24:14 +0200362 case KVM_CAP_SYNC_MMU:
363#ifdef CONFIG_KVM_BOOK3S_64_HV
364 r = cpu_has_feature(CPU_FTR_ARCH_206) ? 1 : 0;
365#elif defined(KVM_ARCH_WANT_MMU_NOTIFIER)
366 r = 1;
367#else
368 r = 0;
Paul Mackerrasa2932922012-11-19 22:57:20 +0000369 break;
370#endif
371#ifdef CONFIG_KVM_BOOK3S_64_HV
372 case KVM_CAP_PPC_HTAB_FD:
373 r = 1;
374 break;
Alexander Graff4800b12012-08-07 10:24:14 +0200375#endif
376 break;
Matt Evansb5434032011-12-07 16:55:57 +0000377 case KVM_CAP_NR_VCPUS:
378 /*
379 * Recommending a number of CPUs is somewhat arbitrary; we
380 * return the number of present CPUs for -HV (since a host
381 * will have secondary threads "offline"), and for other KVM
382 * implementations just count online CPUs.
383 */
384#ifdef CONFIG_KVM_BOOK3S_64_HV
385 r = num_present_cpus();
386#else
387 r = num_online_cpus();
388#endif
389 break;
390 case KVM_CAP_MAX_VCPUS:
391 r = KVM_MAX_VCPUS;
392 break;
Benjamin Herrenschmidt5b747162012-04-26 19:43:42 +0000393#ifdef CONFIG_PPC_BOOK3S_64
394 case KVM_CAP_PPC_GET_SMMU_INFO:
395 r = 1;
396 break;
397#endif
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500398 default:
399 r = 0;
400 break;
401 }
402 return r;
403
404}
405
406long kvm_arch_dev_ioctl(struct file *filp,
407 unsigned int ioctl, unsigned long arg)
408{
409 return -EINVAL;
410}
411
Aneesh Kumar K.V84137262013-10-07 22:18:00 +0530412void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +0900413 struct kvm_memory_slot *dont)
414{
Aneesh Kumar K.V84137262013-10-07 22:18:00 +0530415 kvmppc_core_free_memslot(kvm, free, dont);
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +0900416}
417
Aneesh Kumar K.V84137262013-10-07 22:18:00 +0530418int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
419 unsigned long npages)
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +0900420{
Aneesh Kumar K.V84137262013-10-07 22:18:00 +0530421 return kvmppc_core_create_memslot(kvm, slot, npages);
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +0900422}
423
Takuya Yoshikawaa043deb2013-07-04 13:40:29 +0900424void kvm_arch_memslots_updated(struct kvm *kvm)
425{
426}
427
Marcelo Tosattif7784b82009-12-23 14:35:18 -0200428int kvm_arch_prepare_memory_region(struct kvm *kvm,
Takuya Yoshikawa462fce42013-02-27 19:41:56 +0900429 struct kvm_memory_slot *memslot,
Takuya Yoshikawa7b6195a2013-02-27 19:44:34 +0900430 struct kvm_userspace_memory_region *mem,
431 enum kvm_mr_change change)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500432{
Paul Mackerrasa66b48c2012-09-11 13:27:46 +0000433 return kvmppc_core_prepare_memory_region(kvm, memslot, mem);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500434}
435
Marcelo Tosattif7784b82009-12-23 14:35:18 -0200436void kvm_arch_commit_memory_region(struct kvm *kvm,
Takuya Yoshikawa462fce42013-02-27 19:41:56 +0900437 struct kvm_userspace_memory_region *mem,
Takuya Yoshikawa84826442013-02-27 19:45:25 +0900438 const struct kvm_memory_slot *old,
439 enum kvm_mr_change change)
Marcelo Tosattif7784b82009-12-23 14:35:18 -0200440{
Paul Mackerrasdfe49db2012-09-11 13:28:18 +0000441 kvmppc_core_commit_memory_region(kvm, mem, old);
Marcelo Tosattif7784b82009-12-23 14:35:18 -0200442}
443
Marcelo Tosatti2df72e92012-08-24 15:54:57 -0300444void kvm_arch_flush_shadow_all(struct kvm *kvm)
445{
446}
Marcelo Tosattif7784b82009-12-23 14:35:18 -0200447
Marcelo Tosatti2df72e92012-08-24 15:54:57 -0300448void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
449 struct kvm_memory_slot *slot)
Marcelo Tosatti34d4cb82008-07-10 20:49:31 -0300450{
Paul Mackerrasdfe49db2012-09-11 13:28:18 +0000451 kvmppc_core_flush_memslot(kvm, slot);
Marcelo Tosatti34d4cb82008-07-10 20:49:31 -0300452}
453
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500454struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id)
455{
Hollis Blanchard73e75b412008-12-02 15:51:57 -0600456 struct kvm_vcpu *vcpu;
457 vcpu = kvmppc_core_vcpu_create(kvm, id);
Matt Evans03cdab52011-12-06 21:19:42 +0000458 if (!IS_ERR(vcpu)) {
459 vcpu->arch.wqp = &vcpu->wq;
Wei Yongjun06056bf2010-03-09 14:13:43 +0800460 kvmppc_create_vcpu_debugfs(vcpu, id);
Matt Evans03cdab52011-12-06 21:19:42 +0000461 }
Hollis Blanchard73e75b412008-12-02 15:51:57 -0600462 return vcpu;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500463}
464
Marcelo Tosatti42897d82012-11-27 23:29:02 -0200465int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
466{
467 return 0;
468}
469
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500470void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
471{
Alexander Grafa5954052010-02-22 16:52:14 +0100472 /* Make sure we're not using the vcpu anymore */
473 hrtimer_cancel(&vcpu->arch.dec_timer);
474 tasklet_kill(&vcpu->arch.tasklet);
475
Hollis Blanchard73e75b412008-12-02 15:51:57 -0600476 kvmppc_remove_vcpu_debugfs(vcpu);
Scott Woodeb1e4f42013-04-12 14:08:47 +0000477
478 switch (vcpu->arch.irq_type) {
479 case KVMPPC_IRQ_MPIC:
480 kvmppc_mpic_disconnect_vcpu(vcpu->arch.mpic, vcpu);
481 break;
Benjamin Herrenschmidtbc5ad3f2013-04-17 20:30:26 +0000482 case KVMPPC_IRQ_XICS:
483 kvmppc_xics_free_icp(vcpu);
484 break;
Scott Woodeb1e4f42013-04-12 14:08:47 +0000485 }
486
Hollis Blancharddb93f572008-11-05 09:36:18 -0600487 kvmppc_core_vcpu_free(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500488}
489
490void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
491{
492 kvm_arch_vcpu_free(vcpu);
493}
494
495int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
496{
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600497 return kvmppc_core_pending_dec(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500498}
499
Alexander Graf544c6762009-11-02 12:02:31 +0000500/*
501 * low level hrtimer wake routine. Because this runs in hardirq context
502 * we schedule a tasklet to do the real work.
503 */
504enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer)
505{
506 struct kvm_vcpu *vcpu;
507
508 vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer);
509 tasklet_schedule(&vcpu->arch.tasklet);
510
511 return HRTIMER_NORESTART;
512}
513
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500514int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
515{
Bharat Bhushanf61c94b2012-08-08 20:38:19 +0000516 int ret;
517
Alexander Graf544c6762009-11-02 12:02:31 +0000518 hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
519 tasklet_init(&vcpu->arch.tasklet, kvmppc_decrementer_func, (ulong)vcpu);
520 vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup;
Paul Mackerrasde56a942011-06-29 00:21:34 +0000521 vcpu->arch.dec_expires = ~(u64)0;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500522
Bharat Bhushan09000ad2011-03-25 10:32:13 +0530523#ifdef CONFIG_KVM_EXIT_TIMING
524 mutex_init(&vcpu->arch.exit_timing_lock);
525#endif
Bharat Bhushanf61c94b2012-08-08 20:38:19 +0000526 ret = kvmppc_subarch_vcpu_init(vcpu);
527 return ret;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500528}
529
530void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
531{
Hollis Blanchardecc09812009-01-03 16:22:59 -0600532 kvmppc_mmu_destroy(vcpu);
Bharat Bhushanf61c94b2012-08-08 20:38:19 +0000533 kvmppc_subarch_vcpu_uninit(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500534}
535
536void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
537{
Scott Woodeab17672011-04-27 17:24:10 -0500538#ifdef CONFIG_BOOKE
539 /*
540 * vrsave (formerly usprg0) isn't used by Linux, but may
541 * be used by the guest.
542 *
543 * On non-booke this is associated with Altivec and
544 * is handled by code in book3s.c.
545 */
546 mtspr(SPRN_VRSAVE, vcpu->arch.vrsave);
547#endif
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600548 kvmppc_core_vcpu_load(vcpu, cpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500549}
550
551void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
552{
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600553 kvmppc_core_vcpu_put(vcpu);
Scott Woodeab17672011-04-27 17:24:10 -0500554#ifdef CONFIG_BOOKE
555 vcpu->arch.vrsave = mfspr(SPRN_VRSAVE);
556#endif
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500557}
558
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500559static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu,
560 struct kvm_run *run)
561{
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100562 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500563}
564
565static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu,
566 struct kvm_run *run)
567{
Denis Kirjanov69b61832010-06-11 11:23:26 +0000568 u64 uninitialized_var(gpr);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500569
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100570 if (run->mmio.len > sizeof(gpr)) {
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500571 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len);
572 return;
573 }
574
575 if (vcpu->arch.mmio_is_bigendian) {
576 switch (run->mmio.len) {
Alexander Grafb104d062010-02-19 11:00:29 +0100577 case 8: gpr = *(u64 *)run->mmio.data; break;
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100578 case 4: gpr = *(u32 *)run->mmio.data; break;
579 case 2: gpr = *(u16 *)run->mmio.data; break;
580 case 1: gpr = *(u8 *)run->mmio.data; break;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500581 }
582 } else {
583 /* Convert BE data from userland back to LE. */
584 switch (run->mmio.len) {
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100585 case 4: gpr = ld_le32((u32 *)run->mmio.data); break;
586 case 2: gpr = ld_le16((u16 *)run->mmio.data); break;
587 case 1: gpr = *(u8 *)run->mmio.data; break;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500588 }
589 }
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100590
Alexander Graf3587d532010-02-19 11:00:30 +0100591 if (vcpu->arch.mmio_sign_extend) {
592 switch (run->mmio.len) {
593#ifdef CONFIG_PPC64
594 case 4:
595 gpr = (s64)(s32)gpr;
596 break;
597#endif
598 case 2:
599 gpr = (s64)(s16)gpr;
600 break;
601 case 1:
602 gpr = (s64)(s8)gpr;
603 break;
604 }
605 }
606
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100607 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
Alexander Grafb104d062010-02-19 11:00:29 +0100608
Alexander Grafb3c5d3c2012-01-07 02:07:38 +0100609 switch (vcpu->arch.io_gpr & KVM_MMIO_REG_EXT_MASK) {
610 case KVM_MMIO_REG_GPR:
Alexander Grafb104d062010-02-19 11:00:29 +0100611 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
612 break;
Alexander Grafb3c5d3c2012-01-07 02:07:38 +0100613 case KVM_MMIO_REG_FPR:
614 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
Alexander Grafb104d062010-02-19 11:00:29 +0100615 break;
Alexander Graf287d5612010-04-01 15:33:21 +0200616#ifdef CONFIG_PPC_BOOK3S
Alexander Grafb3c5d3c2012-01-07 02:07:38 +0100617 case KVM_MMIO_REG_QPR:
618 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
Alexander Grafb104d062010-02-19 11:00:29 +0100619 break;
Alexander Grafb3c5d3c2012-01-07 02:07:38 +0100620 case KVM_MMIO_REG_FQPR:
621 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
622 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_MMIO_REG_MASK] = gpr;
Alexander Grafb104d062010-02-19 11:00:29 +0100623 break;
Alexander Graf287d5612010-04-01 15:33:21 +0200624#endif
Alexander Grafb104d062010-02-19 11:00:29 +0100625 default:
626 BUG();
627 }
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500628}
629
630int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
631 unsigned int rt, unsigned int bytes, int is_bigendian)
632{
Scott Wooded840ee2013-04-26 14:53:39 +0000633 int idx, ret;
634
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500635 if (bytes > sizeof(run->mmio.data)) {
636 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
637 run->mmio.len);
638 }
639
640 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
641 run->mmio.len = bytes;
642 run->mmio.is_write = 0;
643
644 vcpu->arch.io_gpr = rt;
645 vcpu->arch.mmio_is_bigendian = is_bigendian;
646 vcpu->mmio_needed = 1;
647 vcpu->mmio_is_write = 0;
Alexander Graf3587d532010-02-19 11:00:30 +0100648 vcpu->arch.mmio_sign_extend = 0;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500649
Scott Wooded840ee2013-04-26 14:53:39 +0000650 idx = srcu_read_lock(&vcpu->kvm->srcu);
651
652 ret = kvm_io_bus_read(vcpu->kvm, KVM_MMIO_BUS, run->mmio.phys_addr,
653 bytes, &run->mmio.data);
654
655 srcu_read_unlock(&vcpu->kvm->srcu, idx);
656
657 if (!ret) {
Alexander Graf0e673fb2012-10-09 00:06:20 +0200658 kvmppc_complete_mmio_load(vcpu, run);
659 vcpu->mmio_needed = 0;
660 return EMULATE_DONE;
661 }
662
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500663 return EMULATE_DO_MMIO;
664}
665
Alexander Graf3587d532010-02-19 11:00:30 +0100666/* Same as above, but sign extends */
667int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu,
668 unsigned int rt, unsigned int bytes, int is_bigendian)
669{
670 int r;
671
Alexander Graf3587d532010-02-19 11:00:30 +0100672 vcpu->arch.mmio_sign_extend = 1;
Alexander Graf0e673fb2012-10-09 00:06:20 +0200673 r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian);
Alexander Graf3587d532010-02-19 11:00:30 +0100674
675 return r;
676}
677
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500678int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu,
Alexander Grafb104d062010-02-19 11:00:29 +0100679 u64 val, unsigned int bytes, int is_bigendian)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500680{
681 void *data = run->mmio.data;
Scott Wooded840ee2013-04-26 14:53:39 +0000682 int idx, ret;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500683
684 if (bytes > sizeof(run->mmio.data)) {
685 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
686 run->mmio.len);
687 }
688
689 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
690 run->mmio.len = bytes;
691 run->mmio.is_write = 1;
692 vcpu->mmio_needed = 1;
693 vcpu->mmio_is_write = 1;
694
695 /* Store the value at the lowest bytes in 'data'. */
696 if (is_bigendian) {
697 switch (bytes) {
Alexander Grafb104d062010-02-19 11:00:29 +0100698 case 8: *(u64 *)data = val; break;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500699 case 4: *(u32 *)data = val; break;
700 case 2: *(u16 *)data = val; break;
701 case 1: *(u8 *)data = val; break;
702 }
703 } else {
704 /* Store LE value into 'data'. */
705 switch (bytes) {
706 case 4: st_le32(data, val); break;
707 case 2: st_le16(data, val); break;
708 case 1: *(u8 *)data = val; break;
709 }
710 }
711
Scott Wooded840ee2013-04-26 14:53:39 +0000712 idx = srcu_read_lock(&vcpu->kvm->srcu);
713
714 ret = kvm_io_bus_write(vcpu->kvm, KVM_MMIO_BUS, run->mmio.phys_addr,
715 bytes, &run->mmio.data);
716
717 srcu_read_unlock(&vcpu->kvm->srcu, idx);
718
719 if (!ret) {
Alexander Graf0e673fb2012-10-09 00:06:20 +0200720 vcpu->mmio_needed = 0;
721 return EMULATE_DONE;
722 }
723
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500724 return EMULATE_DO_MMIO;
725}
726
727int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
728{
729 int r;
730 sigset_t sigsaved;
731
732 if (vcpu->sigset_active)
733 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
734
735 if (vcpu->mmio_needed) {
736 if (!vcpu->mmio_is_write)
737 kvmppc_complete_mmio_load(vcpu, run);
738 vcpu->mmio_needed = 0;
739 } else if (vcpu->arch.dcr_needed) {
740 if (!vcpu->arch.dcr_is_write)
741 kvmppc_complete_dcr_load(vcpu, run);
742 vcpu->arch.dcr_needed = 0;
Alexander Grafad0a0482010-03-24 21:48:30 +0100743 } else if (vcpu->arch.osi_needed) {
744 u64 *gprs = run->osi.gprs;
745 int i;
746
747 for (i = 0; i < 32; i++)
748 kvmppc_set_gpr(vcpu, i, gprs[i]);
749 vcpu->arch.osi_needed = 0;
Paul Mackerrasde56a942011-06-29 00:21:34 +0000750 } else if (vcpu->arch.hcall_needed) {
751 int i;
752
753 kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret);
754 for (i = 0; i < 9; ++i)
755 kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]);
756 vcpu->arch.hcall_needed = 0;
Alexander Graf1c810632013-01-04 18:12:48 +0100757#ifdef CONFIG_BOOKE
758 } else if (vcpu->arch.epr_needed) {
759 kvmppc_set_epr(vcpu, run->epr.epr);
760 vcpu->arch.epr_needed = 0;
761#endif
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500762 }
763
Paul Mackerrasdf6909e52011-06-29 00:19:50 +0000764 r = kvmppc_vcpu_run(run, vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500765
766 if (vcpu->sigset_active)
767 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
768
769 return r;
770}
771
772int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq)
773{
Paul Mackerras19ccb762011-07-23 17:42:46 +1000774 if (irq->irq == KVM_INTERRUPT_UNSET) {
Paul Mackerras4fe27d22013-02-14 14:00:25 +0000775 kvmppc_core_dequeue_external(vcpu);
Paul Mackerras19ccb762011-07-23 17:42:46 +1000776 return 0;
777 }
Hollis Blanchard45c5eb62008-04-25 17:55:49 -0500778
Paul Mackerras19ccb762011-07-23 17:42:46 +1000779 kvmppc_core_queue_external(vcpu, irq);
Christoffer Dallb6d33832012-03-08 16:44:24 -0500780
Scott Wooddfd4d472011-11-17 12:39:59 +0000781 kvm_vcpu_kick(vcpu);
Hollis Blanchard45c5eb62008-04-25 17:55:49 -0500782
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500783 return 0;
784}
785
Alexander Graf71fbfd52010-03-24 21:48:29 +0100786static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
787 struct kvm_enable_cap *cap)
788{
789 int r;
790
791 if (cap->flags)
792 return -EINVAL;
793
794 switch (cap->cap) {
Alexander Grafad0a0482010-03-24 21:48:30 +0100795 case KVM_CAP_PPC_OSI:
796 r = 0;
797 vcpu->arch.osi_enabled = true;
798 break;
Alexander Graf930b4122011-08-08 17:29:42 +0200799 case KVM_CAP_PPC_PAPR:
800 r = 0;
801 vcpu->arch.papr_enabled = true;
802 break;
Alexander Graf1c810632013-01-04 18:12:48 +0100803 case KVM_CAP_PPC_EPR:
804 r = 0;
Scott Wood5df554ad2013-04-12 14:08:46 +0000805 if (cap->args[0])
806 vcpu->arch.epr_flags |= KVMPPC_EPR_USER;
807 else
808 vcpu->arch.epr_flags &= ~KVMPPC_EPR_USER;
Alexander Graf1c810632013-01-04 18:12:48 +0100809 break;
Bharat Bhushanf61c94b2012-08-08 20:38:19 +0000810#ifdef CONFIG_BOOKE
811 case KVM_CAP_PPC_BOOKE_WATCHDOG:
812 r = 0;
813 vcpu->arch.watchdog_enabled = true;
814 break;
815#endif
Alexander Grafbf7ca4b2012-02-15 23:40:00 +0000816#if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
Scott Wooddc83b8b2011-08-18 15:25:21 -0500817 case KVM_CAP_SW_TLB: {
818 struct kvm_config_tlb cfg;
819 void __user *user_ptr = (void __user *)(uintptr_t)cap->args[0];
820
821 r = -EFAULT;
822 if (copy_from_user(&cfg, user_ptr, sizeof(cfg)))
823 break;
824
825 r = kvm_vcpu_ioctl_config_tlb(vcpu, &cfg);
826 break;
827 }
828#endif
Scott Woodeb1e4f42013-04-12 14:08:47 +0000829#ifdef CONFIG_KVM_MPIC
830 case KVM_CAP_IRQ_MPIC: {
831 struct file *filp;
832 struct kvm_device *dev;
833
834 r = -EBADF;
835 filp = fget(cap->args[0]);
836 if (!filp)
837 break;
838
839 r = -EPERM;
840 dev = kvm_device_from_filp(filp);
841 if (dev)
842 r = kvmppc_mpic_connect_vcpu(dev, vcpu, cap->args[1]);
843
844 fput(filp);
845 break;
846 }
847#endif
Paul Mackerras5975a2e2013-04-27 00:28:37 +0000848#ifdef CONFIG_KVM_XICS
849 case KVM_CAP_IRQ_XICS: {
850 struct file *filp;
851 struct kvm_device *dev;
852
853 r = -EBADF;
854 filp = fget(cap->args[0]);
855 if (!filp)
856 break;
857
858 r = -EPERM;
859 dev = kvm_device_from_filp(filp);
860 if (dev)
861 r = kvmppc_xics_connect_vcpu(dev, vcpu, cap->args[1]);
862
863 fput(filp);
864 break;
865 }
866#endif /* CONFIG_KVM_XICS */
Alexander Graf71fbfd52010-03-24 21:48:29 +0100867 default:
868 r = -EINVAL;
869 break;
870 }
871
Alexander Grafaf8f38b2011-08-10 13:57:08 +0200872 if (!r)
873 r = kvmppc_sanity_check(vcpu);
874
Alexander Graf71fbfd52010-03-24 21:48:29 +0100875 return r;
876}
877
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500878int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
879 struct kvm_mp_state *mp_state)
880{
881 return -EINVAL;
882}
883
884int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
885 struct kvm_mp_state *mp_state)
886{
887 return -EINVAL;
888}
889
890long kvm_arch_vcpu_ioctl(struct file *filp,
891 unsigned int ioctl, unsigned long arg)
892{
893 struct kvm_vcpu *vcpu = filp->private_data;
894 void __user *argp = (void __user *)arg;
895 long r;
896
Avi Kivity93736622010-05-13 12:35:17 +0300897 switch (ioctl) {
898 case KVM_INTERRUPT: {
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500899 struct kvm_interrupt irq;
900 r = -EFAULT;
901 if (copy_from_user(&irq, argp, sizeof(irq)))
Avi Kivity93736622010-05-13 12:35:17 +0300902 goto out;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500903 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq);
Avi Kivity93736622010-05-13 12:35:17 +0300904 goto out;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500905 }
Avi Kivity19483d12010-05-13 12:30:43 +0300906
Alexander Graf71fbfd52010-03-24 21:48:29 +0100907 case KVM_ENABLE_CAP:
908 {
909 struct kvm_enable_cap cap;
910 r = -EFAULT;
911 if (copy_from_user(&cap, argp, sizeof(cap)))
912 goto out;
913 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
914 break;
915 }
Scott Wooddc83b8b2011-08-18 15:25:21 -0500916
Alexander Grafe24ed812011-09-14 10:02:41 +0200917 case KVM_SET_ONE_REG:
918 case KVM_GET_ONE_REG:
919 {
920 struct kvm_one_reg reg;
921 r = -EFAULT;
922 if (copy_from_user(&reg, argp, sizeof(reg)))
923 goto out;
924 if (ioctl == KVM_SET_ONE_REG)
925 r = kvm_vcpu_ioctl_set_one_reg(vcpu, &reg);
926 else
927 r = kvm_vcpu_ioctl_get_one_reg(vcpu, &reg);
928 break;
929 }
930
Alexander Grafbf7ca4b2012-02-15 23:40:00 +0000931#if defined(CONFIG_KVM_E500V2) || defined(CONFIG_KVM_E500MC)
Scott Wooddc83b8b2011-08-18 15:25:21 -0500932 case KVM_DIRTY_TLB: {
933 struct kvm_dirty_tlb dirty;
934 r = -EFAULT;
935 if (copy_from_user(&dirty, argp, sizeof(dirty)))
936 goto out;
937 r = kvm_vcpu_ioctl_dirty_tlb(vcpu, &dirty);
938 break;
939 }
940#endif
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500941 default:
942 r = -EINVAL;
943 }
944
945out:
946 return r;
947}
948
Carsten Otte5b1c1492012-01-04 10:25:23 +0100949int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
950{
951 return VM_FAULT_SIGBUS;
952}
953
Alexander Graf15711e92010-07-29 14:48:08 +0200954static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo)
955{
Stuart Yoder784bafa2012-07-03 05:48:51 +0000956 u32 inst_nop = 0x60000000;
957#ifdef CONFIG_KVM_BOOKE_HV
958 u32 inst_sc1 = 0x44000022;
959 pvinfo->hcall[0] = inst_sc1;
960 pvinfo->hcall[1] = inst_nop;
961 pvinfo->hcall[2] = inst_nop;
962 pvinfo->hcall[3] = inst_nop;
963#else
Alexander Graf15711e92010-07-29 14:48:08 +0200964 u32 inst_lis = 0x3c000000;
965 u32 inst_ori = 0x60000000;
Alexander Graf15711e92010-07-29 14:48:08 +0200966 u32 inst_sc = 0x44000002;
967 u32 inst_imm_mask = 0xffff;
968
969 /*
970 * The hypercall to get into KVM from within guest context is as
971 * follows:
972 *
973 * lis r0, r0, KVM_SC_MAGIC_R0@h
974 * ori r0, KVM_SC_MAGIC_R0@l
975 * sc
976 * nop
977 */
978 pvinfo->hcall[0] = inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask);
979 pvinfo->hcall[1] = inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask);
980 pvinfo->hcall[2] = inst_sc;
981 pvinfo->hcall[3] = inst_nop;
Stuart Yoder784bafa2012-07-03 05:48:51 +0000982#endif
Alexander Graf15711e92010-07-29 14:48:08 +0200983
Liu Yu-B132019202e072012-07-03 05:48:52 +0000984 pvinfo->flags = KVM_PPC_PVINFO_FLAGS_EV_IDLE;
985
Alexander Graf15711e92010-07-29 14:48:08 +0200986 return 0;
987}
988
Alexander Graf5efdb4b2013-04-17 00:37:57 +0200989int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_event,
990 bool line_status)
991{
992 if (!irqchip_in_kernel(kvm))
993 return -ENXIO;
994
995 irq_event->status = kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID,
996 irq_event->irq, irq_event->level,
997 line_status);
998 return 0;
999}
1000
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -05001001long kvm_arch_vm_ioctl(struct file *filp,
1002 unsigned int ioctl, unsigned long arg)
1003{
Scott Wood5df554ad2013-04-12 14:08:46 +00001004 struct kvm *kvm __maybe_unused = filp->private_data;
Alexander Graf15711e92010-07-29 14:48:08 +02001005 void __user *argp = (void __user *)arg;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -05001006 long r;
1007
1008 switch (ioctl) {
Alexander Graf15711e92010-07-29 14:48:08 +02001009 case KVM_PPC_GET_PVINFO: {
1010 struct kvm_ppc_pvinfo pvinfo;
Vasiliy Kulikovd8cdddc2010-10-30 13:04:24 +04001011 memset(&pvinfo, 0, sizeof(pvinfo));
Alexander Graf15711e92010-07-29 14:48:08 +02001012 r = kvm_vm_ioctl_get_pvinfo(&pvinfo);
1013 if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) {
1014 r = -EFAULT;
1015 goto out;
1016 }
1017
1018 break;
1019 }
Benjamin Herrenschmidtf31e65e2012-03-15 21:58:34 +00001020#ifdef CONFIG_PPC_BOOK3S_64
David Gibson54738c02011-06-29 00:22:41 +00001021 case KVM_CREATE_SPAPR_TCE: {
1022 struct kvm_create_spapr_tce create_tce;
David Gibson54738c02011-06-29 00:22:41 +00001023
1024 r = -EFAULT;
1025 if (copy_from_user(&create_tce, argp, sizeof(create_tce)))
1026 goto out;
1027 r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce);
1028 goto out;
1029 }
Benjamin Herrenschmidtf31e65e2012-03-15 21:58:34 +00001030#endif /* CONFIG_PPC_BOOK3S_64 */
Paul Mackerrasaa04b4c2011-06-29 00:25:44 +00001031
Benjamin Herrenschmidtf31e65e2012-03-15 21:58:34 +00001032#ifdef CONFIG_KVM_BOOK3S_64_HV
Paul Mackerrasaa04b4c2011-06-29 00:25:44 +00001033 case KVM_ALLOCATE_RMA: {
Paul Mackerrasaa04b4c2011-06-29 00:25:44 +00001034 struct kvm_allocate_rma rma;
Michael Ellerman8e591cb2013-04-17 20:30:00 +00001035 struct kvm *kvm = filp->private_data;
Paul Mackerrasaa04b4c2011-06-29 00:25:44 +00001036
1037 r = kvm_vm_ioctl_allocate_rma(kvm, &rma);
1038 if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma)))
1039 r = -EFAULT;
1040 break;
1041 }
Paul Mackerras32fad282012-05-04 02:32:53 +00001042
1043 case KVM_PPC_ALLOCATE_HTAB: {
Paul Mackerras32fad282012-05-04 02:32:53 +00001044 u32 htab_order;
1045
1046 r = -EFAULT;
1047 if (get_user(htab_order, (u32 __user *)argp))
1048 break;
1049 r = kvmppc_alloc_reset_hpt(kvm, &htab_order);
1050 if (r)
1051 break;
1052 r = -EFAULT;
1053 if (put_user(htab_order, (u32 __user *)argp))
1054 break;
1055 r = 0;
1056 break;
1057 }
Paul Mackerrasa2932922012-11-19 22:57:20 +00001058
1059 case KVM_PPC_GET_HTAB_FD: {
Paul Mackerrasa2932922012-11-19 22:57:20 +00001060 struct kvm_get_htab_fd ghf;
1061
1062 r = -EFAULT;
1063 if (copy_from_user(&ghf, argp, sizeof(ghf)))
1064 break;
1065 r = kvm_vm_ioctl_get_htab_fd(kvm, &ghf);
1066 break;
1067 }
David Gibson54738c02011-06-29 00:22:41 +00001068#endif /* CONFIG_KVM_BOOK3S_64_HV */
1069
Benjamin Herrenschmidt5b747162012-04-26 19:43:42 +00001070#ifdef CONFIG_PPC_BOOK3S_64
1071 case KVM_PPC_GET_SMMU_INFO: {
Benjamin Herrenschmidt5b747162012-04-26 19:43:42 +00001072 struct kvm_ppc_smmu_info info;
1073
1074 memset(&info, 0, sizeof(info));
1075 r = kvm_vm_ioctl_get_smmu_info(kvm, &info);
1076 if (r >= 0 && copy_to_user(argp, &info, sizeof(info)))
1077 r = -EFAULT;
1078 break;
1079 }
Michael Ellerman8e591cb2013-04-17 20:30:00 +00001080 case KVM_PPC_RTAS_DEFINE_TOKEN: {
1081 struct kvm *kvm = filp->private_data;
1082
1083 r = kvm_vm_ioctl_rtas_define_token(kvm, argp);
1084 break;
1085 }
Benjamin Herrenschmidt5b747162012-04-26 19:43:42 +00001086#endif /* CONFIG_PPC_BOOK3S_64 */
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -05001087 default:
Avi Kivity367e1312009-08-26 14:57:07 +03001088 r = -ENOTTY;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -05001089 }
1090
Alexander Graf15711e92010-07-29 14:48:08 +02001091out:
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -05001092 return r;
1093}
1094
Scott Wood043cc4d2011-12-20 15:34:20 +00001095static unsigned long lpid_inuse[BITS_TO_LONGS(KVMPPC_NR_LPIDS)];
1096static unsigned long nr_lpids;
1097
1098long kvmppc_alloc_lpid(void)
1099{
1100 long lpid;
1101
1102 do {
1103 lpid = find_first_zero_bit(lpid_inuse, KVMPPC_NR_LPIDS);
1104 if (lpid >= nr_lpids) {
1105 pr_err("%s: No LPIDs free\n", __func__);
1106 return -ENOMEM;
1107 }
1108 } while (test_and_set_bit(lpid, lpid_inuse));
1109
1110 return lpid;
1111}
1112
1113void kvmppc_claim_lpid(long lpid)
1114{
1115 set_bit(lpid, lpid_inuse);
1116}
1117
1118void kvmppc_free_lpid(long lpid)
1119{
1120 clear_bit(lpid, lpid_inuse);
1121}
1122
1123void kvmppc_init_lpid(unsigned long nr_lpids_param)
1124{
1125 nr_lpids = min_t(unsigned long, KVMPPC_NR_LPIDS, nr_lpids_param);
1126 memset(lpid_inuse, 0, sizeof(lpid_inuse));
1127}
1128
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -05001129int kvm_arch_init(void *opaque)
1130{
1131 return 0;
1132}
1133
1134void kvm_arch_exit(void)
1135{
1136}