blob: 99758460efdef8364abb8678cd5d136a70bdb094 [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>
24#include <linux/module.h>
25#include <linux/vmalloc.h>
Alexander Graf544c6762009-11-02 12:02:31 +000026#include <linux/hrtimer.h>
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050027#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090028#include <linux/slab.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>
Hollis Blanchard73e75b42008-12-02 15:51:57 -060033#include "timing.h"
Paul Mackerrasfad7b9b2008-12-23 14:57:26 +110034#include "../mm/mmu_decl.h"
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050035
Marcelo Tosatti46f43c62009-06-18 11:47:27 -030036#define CREATE_TRACE_POINTS
37#include "trace.h"
38
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050039int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
40{
Alexander Graf666e7252010-07-29 14:47:43 +020041 return !(v->arch.shared->msr & MSR_WE) ||
42 !!(v->arch.pending_exceptions);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050043}
44
Alexander Graf2a342ed2010-07-29 14:47:48 +020045int kvmppc_kvm_pv(struct kvm_vcpu *vcpu)
46{
47 int nr = kvmppc_get_gpr(vcpu, 11);
48 int r;
49 unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3);
50 unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4);
51 unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5);
52 unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6);
53 unsigned long r2 = 0;
54
55 if (!(vcpu->arch.shared->msr & MSR_SF)) {
56 /* 32 bit mode */
57 param1 &= 0xffffffff;
58 param2 &= 0xffffffff;
59 param3 &= 0xffffffff;
60 param4 &= 0xffffffff;
61 }
62
63 switch (nr) {
Alexander Graf5fc87402010-07-29 14:47:55 +020064 case HC_VENDOR_KVM | KVM_HC_PPC_MAP_MAGIC_PAGE:
65 {
66 vcpu->arch.magic_page_pa = param1;
67 vcpu->arch.magic_page_ea = param2;
68
Alexander Grafdf1bfa22010-08-03 02:29:27 +020069 r2 = KVM_MAGIC_FEAT_SR;
Alexander Graf7508e162010-08-03 11:32:56 +020070
Alexander Graf5fc87402010-07-29 14:47:55 +020071 r = HC_EV_SUCCESS;
72 break;
73 }
Alexander Graf2a342ed2010-07-29 14:47:48 +020074 case HC_VENDOR_KVM | KVM_HC_FEATURES:
75 r = HC_EV_SUCCESS;
Alexander Graf5fc87402010-07-29 14:47:55 +020076#if defined(CONFIG_PPC_BOOK3S) /* XXX Missing magic page on BookE */
77 r2 |= (1 << KVM_FEATURE_MAGIC_PAGE);
78#endif
Alexander Graf2a342ed2010-07-29 14:47:48 +020079
80 /* Second return value is in r4 */
Alexander Graf2a342ed2010-07-29 14:47:48 +020081 break;
82 default:
83 r = HC_EV_UNIMPLEMENTED;
84 break;
85 }
86
Alexander Graf7508e162010-08-03 11:32:56 +020087 kvmppc_set_gpr(vcpu, 4, r2);
88
Alexander Graf2a342ed2010-07-29 14:47:48 +020089 return r;
90}
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050091
92int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu)
93{
94 enum emulation_result er;
95 int r;
96
97 er = kvmppc_emulate_instruction(run, vcpu);
98 switch (er) {
99 case EMULATE_DONE:
100 /* Future optimization: only reload non-volatiles if they were
101 * actually modified. */
102 r = RESUME_GUEST_NV;
103 break;
104 case EMULATE_DO_MMIO:
105 run->exit_reason = KVM_EXIT_MMIO;
106 /* We must reload nonvolatiles because "update" load/store
107 * instructions modify register state. */
108 /* Future optimization: only reload non-volatiles if they were
109 * actually modified. */
110 r = RESUME_HOST_NV;
111 break;
112 case EMULATE_FAIL:
113 /* XXX Deliver Program interrupt to guest. */
114 printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__,
Alexander Grafc7f38f42010-04-16 00:11:40 +0200115 kvmppc_get_last_inst(vcpu));
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500116 r = RESUME_HOST;
117 break;
118 default:
119 BUG();
120 }
121
122 return r;
123}
124
Alexander Graf10474ae2009-09-15 11:37:46 +0200125int kvm_arch_hardware_enable(void *garbage)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500126{
Alexander Graf10474ae2009-09-15 11:37:46 +0200127 return 0;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500128}
129
130void kvm_arch_hardware_disable(void *garbage)
131{
132}
133
134int kvm_arch_hardware_setup(void)
135{
136 return 0;
137}
138
139void kvm_arch_hardware_unsetup(void)
140{
141}
142
143void kvm_arch_check_processor_compat(void *rtn)
144{
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600145 *(int *)rtn = kvmppc_core_check_processor_compat();
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500146}
147
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100148int kvm_arch_init_vm(struct kvm *kvm)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500149{
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100150 return 0;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500151}
152
Jan Kiszkad89f5ef2010-11-09 17:02:49 +0100153void kvm_arch_destroy_vm(struct kvm *kvm)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500154{
155 unsigned int i;
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300156 struct kvm_vcpu *vcpu;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500157
Gleb Natapov988a2ca2009-06-09 15:56:29 +0300158 kvm_for_each_vcpu(i, vcpu, kvm)
159 kvm_arch_vcpu_free(vcpu);
160
161 mutex_lock(&kvm->lock);
162 for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
163 kvm->vcpus[i] = NULL;
164
165 atomic_set(&kvm->online_vcpus, 0);
166 mutex_unlock(&kvm->lock);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500167}
168
Sheng Yangad8ba2c2009-01-06 10:03:02 +0800169void kvm_arch_sync_events(struct kvm *kvm)
170{
171}
172
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500173int kvm_dev_ioctl_check_extension(long ext)
174{
175 int r;
176
177 switch (ext) {
Alexander Grafe15a1132009-11-30 03:02:02 +0000178 case KVM_CAP_PPC_SEGSTATE:
Alexander Grafc10207f2010-02-19 11:00:45 +0100179 case KVM_CAP_PPC_PAIRED_SINGLES:
Alexander Graf18978762010-03-24 21:48:18 +0100180 case KVM_CAP_PPC_UNSET_IRQ:
Alexander Graf7b4203e2010-08-30 13:50:45 +0200181 case KVM_CAP_PPC_IRQ_LEVEL:
Alexander Graf71fbfd52010-03-24 21:48:29 +0100182 case KVM_CAP_ENABLE_CAP:
Alexander Grafad0a0482010-03-24 21:48:30 +0100183 case KVM_CAP_PPC_OSI:
Alexander Graf15711e92010-07-29 14:48:08 +0200184 case KVM_CAP_PPC_GET_PVINFO:
Alexander Grafe15a1132009-11-30 03:02:02 +0000185 r = 1;
186 break;
Laurent Vivier588968b2008-05-30 16:05:56 +0200187 case KVM_CAP_COALESCED_MMIO:
188 r = KVM_COALESCED_MMIO_PAGE_OFFSET;
189 break;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500190 default:
191 r = 0;
192 break;
193 }
194 return r;
195
196}
197
198long kvm_arch_dev_ioctl(struct file *filp,
199 unsigned int ioctl, unsigned long arg)
200{
201 return -EINVAL;
202}
203
Marcelo Tosattif7784b82009-12-23 14:35:18 -0200204int kvm_arch_prepare_memory_region(struct kvm *kvm,
205 struct kvm_memory_slot *memslot,
206 struct kvm_memory_slot old,
207 struct kvm_userspace_memory_region *mem,
208 int user_alloc)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500209{
210 return 0;
211}
212
Marcelo Tosattif7784b82009-12-23 14:35:18 -0200213void kvm_arch_commit_memory_region(struct kvm *kvm,
214 struct kvm_userspace_memory_region *mem,
215 struct kvm_memory_slot old,
216 int user_alloc)
217{
218 return;
219}
220
221
Marcelo Tosatti34d4cb82008-07-10 20:49:31 -0300222void kvm_arch_flush_shadow(struct kvm *kvm)
223{
224}
225
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500226struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id)
227{
Hollis Blanchard73e75b42008-12-02 15:51:57 -0600228 struct kvm_vcpu *vcpu;
229 vcpu = kvmppc_core_vcpu_create(kvm, id);
Wei Yongjun06056bf2010-03-09 14:13:43 +0800230 if (!IS_ERR(vcpu))
231 kvmppc_create_vcpu_debugfs(vcpu, id);
Hollis Blanchard73e75b42008-12-02 15:51:57 -0600232 return vcpu;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500233}
234
235void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
236{
Alexander Grafa5954052010-02-22 16:52:14 +0100237 /* Make sure we're not using the vcpu anymore */
238 hrtimer_cancel(&vcpu->arch.dec_timer);
239 tasklet_kill(&vcpu->arch.tasklet);
240
Hollis Blanchard73e75b42008-12-02 15:51:57 -0600241 kvmppc_remove_vcpu_debugfs(vcpu);
Hollis Blancharddb93f572008-11-05 09:36:18 -0600242 kvmppc_core_vcpu_free(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500243}
244
245void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
246{
247 kvm_arch_vcpu_free(vcpu);
248}
249
250int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
251{
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600252 return kvmppc_core_pending_dec(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500253}
254
255static void kvmppc_decrementer_func(unsigned long data)
256{
257 struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data;
258
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600259 kvmppc_core_queue_dec(vcpu);
Hollis Blanchard45c5eb62008-04-25 17:55:49 -0500260
261 if (waitqueue_active(&vcpu->wq)) {
262 wake_up_interruptible(&vcpu->wq);
263 vcpu->stat.halt_wakeup++;
264 }
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500265}
266
Alexander Graf544c6762009-11-02 12:02:31 +0000267/*
268 * low level hrtimer wake routine. Because this runs in hardirq context
269 * we schedule a tasklet to do the real work.
270 */
271enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer)
272{
273 struct kvm_vcpu *vcpu;
274
275 vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer);
276 tasklet_schedule(&vcpu->arch.tasklet);
277
278 return HRTIMER_NORESTART;
279}
280
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500281int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
282{
Alexander Graf544c6762009-11-02 12:02:31 +0000283 hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
284 tasklet_init(&vcpu->arch.tasklet, kvmppc_decrementer_func, (ulong)vcpu);
285 vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500286
287 return 0;
288}
289
290void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
291{
Hollis Blanchardecc09812009-01-03 16:22:59 -0600292 kvmppc_mmu_destroy(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500293}
294
295void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
296{
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600297 kvmppc_core_vcpu_load(vcpu, cpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500298}
299
300void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
301{
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600302 kvmppc_core_vcpu_put(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500303}
304
Jan Kiszkad0bfb942008-12-15 13:52:10 +0100305int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
Hollis Blanchardf5d09062009-01-04 13:51:09 -0600306 struct kvm_guest_debug *dbg)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500307{
Hollis Blanchardf5d09062009-01-04 13:51:09 -0600308 return -EINVAL;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500309}
310
311static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu,
312 struct kvm_run *run)
313{
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100314 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500315}
316
317static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu,
318 struct kvm_run *run)
319{
Denis Kirjanov69b61832010-06-11 11:23:26 +0000320 u64 uninitialized_var(gpr);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500321
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100322 if (run->mmio.len > sizeof(gpr)) {
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500323 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len);
324 return;
325 }
326
327 if (vcpu->arch.mmio_is_bigendian) {
328 switch (run->mmio.len) {
Alexander Grafb104d062010-02-19 11:00:29 +0100329 case 8: gpr = *(u64 *)run->mmio.data; break;
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100330 case 4: gpr = *(u32 *)run->mmio.data; break;
331 case 2: gpr = *(u16 *)run->mmio.data; break;
332 case 1: gpr = *(u8 *)run->mmio.data; break;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500333 }
334 } else {
335 /* Convert BE data from userland back to LE. */
336 switch (run->mmio.len) {
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100337 case 4: gpr = ld_le32((u32 *)run->mmio.data); break;
338 case 2: gpr = ld_le16((u16 *)run->mmio.data); break;
339 case 1: gpr = *(u8 *)run->mmio.data; break;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500340 }
341 }
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100342
Alexander Graf3587d532010-02-19 11:00:30 +0100343 if (vcpu->arch.mmio_sign_extend) {
344 switch (run->mmio.len) {
345#ifdef CONFIG_PPC64
346 case 4:
347 gpr = (s64)(s32)gpr;
348 break;
349#endif
350 case 2:
351 gpr = (s64)(s16)gpr;
352 break;
353 case 1:
354 gpr = (s64)(s8)gpr;
355 break;
356 }
357 }
358
Alexander Graf8e5b26b2010-01-08 02:58:01 +0100359 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
Alexander Grafb104d062010-02-19 11:00:29 +0100360
361 switch (vcpu->arch.io_gpr & KVM_REG_EXT_MASK) {
362 case KVM_REG_GPR:
363 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
364 break;
365 case KVM_REG_FPR:
366 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
367 break;
Alexander Graf287d5612010-04-01 15:33:21 +0200368#ifdef CONFIG_PPC_BOOK3S
Alexander Grafb104d062010-02-19 11:00:29 +0100369 case KVM_REG_QPR:
370 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
371 break;
372 case KVM_REG_FQPR:
373 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
374 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
375 break;
Alexander Graf287d5612010-04-01 15:33:21 +0200376#endif
Alexander Grafb104d062010-02-19 11:00:29 +0100377 default:
378 BUG();
379 }
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500380}
381
382int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
383 unsigned int rt, unsigned int bytes, int is_bigendian)
384{
385 if (bytes > sizeof(run->mmio.data)) {
386 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
387 run->mmio.len);
388 }
389
390 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
391 run->mmio.len = bytes;
392 run->mmio.is_write = 0;
393
394 vcpu->arch.io_gpr = rt;
395 vcpu->arch.mmio_is_bigendian = is_bigendian;
396 vcpu->mmio_needed = 1;
397 vcpu->mmio_is_write = 0;
Alexander Graf3587d532010-02-19 11:00:30 +0100398 vcpu->arch.mmio_sign_extend = 0;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500399
400 return EMULATE_DO_MMIO;
401}
402
Alexander Graf3587d532010-02-19 11:00:30 +0100403/* Same as above, but sign extends */
404int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu,
405 unsigned int rt, unsigned int bytes, int is_bigendian)
406{
407 int r;
408
409 r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian);
410 vcpu->arch.mmio_sign_extend = 1;
411
412 return r;
413}
414
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500415int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu,
Alexander Grafb104d062010-02-19 11:00:29 +0100416 u64 val, unsigned int bytes, int is_bigendian)
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500417{
418 void *data = run->mmio.data;
419
420 if (bytes > sizeof(run->mmio.data)) {
421 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
422 run->mmio.len);
423 }
424
425 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
426 run->mmio.len = bytes;
427 run->mmio.is_write = 1;
428 vcpu->mmio_needed = 1;
429 vcpu->mmio_is_write = 1;
430
431 /* Store the value at the lowest bytes in 'data'. */
432 if (is_bigendian) {
433 switch (bytes) {
Alexander Grafb104d062010-02-19 11:00:29 +0100434 case 8: *(u64 *)data = val; break;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500435 case 4: *(u32 *)data = val; break;
436 case 2: *(u16 *)data = val; break;
437 case 1: *(u8 *)data = val; break;
438 }
439 } else {
440 /* Store LE value into 'data'. */
441 switch (bytes) {
442 case 4: st_le32(data, val); break;
443 case 2: st_le16(data, val); break;
444 case 1: *(u8 *)data = val; break;
445 }
446 }
447
448 return EMULATE_DO_MMIO;
449}
450
451int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
452{
453 int r;
454 sigset_t sigsaved;
455
456 if (vcpu->sigset_active)
457 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
458
459 if (vcpu->mmio_needed) {
460 if (!vcpu->mmio_is_write)
461 kvmppc_complete_mmio_load(vcpu, run);
462 vcpu->mmio_needed = 0;
463 } else if (vcpu->arch.dcr_needed) {
464 if (!vcpu->arch.dcr_is_write)
465 kvmppc_complete_dcr_load(vcpu, run);
466 vcpu->arch.dcr_needed = 0;
Alexander Grafad0a0482010-03-24 21:48:30 +0100467 } else if (vcpu->arch.osi_needed) {
468 u64 *gprs = run->osi.gprs;
469 int i;
470
471 for (i = 0; i < 32; i++)
472 kvmppc_set_gpr(vcpu, i, gprs[i]);
473 vcpu->arch.osi_needed = 0;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500474 }
475
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600476 kvmppc_core_deliver_interrupts(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500477
478 local_irq_disable();
479 kvm_guest_enter();
480 r = __kvmppc_vcpu_run(run, vcpu);
481 kvm_guest_exit();
482 local_irq_enable();
483
484 if (vcpu->sigset_active)
485 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
486
487 return r;
488}
489
490int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq)
491{
Alexander Graf18978762010-03-24 21:48:18 +0100492 if (irq->irq == KVM_INTERRUPT_UNSET)
493 kvmppc_core_dequeue_external(vcpu, irq);
494 else
495 kvmppc_core_queue_external(vcpu, irq);
Hollis Blanchard45c5eb62008-04-25 17:55:49 -0500496
497 if (waitqueue_active(&vcpu->wq)) {
498 wake_up_interruptible(&vcpu->wq);
499 vcpu->stat.halt_wakeup++;
500 }
501
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500502 return 0;
503}
504
Alexander Graf71fbfd52010-03-24 21:48:29 +0100505static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
506 struct kvm_enable_cap *cap)
507{
508 int r;
509
510 if (cap->flags)
511 return -EINVAL;
512
513 switch (cap->cap) {
Alexander Grafad0a0482010-03-24 21:48:30 +0100514 case KVM_CAP_PPC_OSI:
515 r = 0;
516 vcpu->arch.osi_enabled = true;
517 break;
Alexander Graf71fbfd52010-03-24 21:48:29 +0100518 default:
519 r = -EINVAL;
520 break;
521 }
522
523 return r;
524}
525
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500526int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
527 struct kvm_mp_state *mp_state)
528{
529 return -EINVAL;
530}
531
532int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
533 struct kvm_mp_state *mp_state)
534{
535 return -EINVAL;
536}
537
538long kvm_arch_vcpu_ioctl(struct file *filp,
539 unsigned int ioctl, unsigned long arg)
540{
541 struct kvm_vcpu *vcpu = filp->private_data;
542 void __user *argp = (void __user *)arg;
543 long r;
544
Avi Kivity93736622010-05-13 12:35:17 +0300545 switch (ioctl) {
546 case KVM_INTERRUPT: {
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500547 struct kvm_interrupt irq;
548 r = -EFAULT;
549 if (copy_from_user(&irq, argp, sizeof(irq)))
Avi Kivity93736622010-05-13 12:35:17 +0300550 goto out;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500551 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq);
Avi Kivity93736622010-05-13 12:35:17 +0300552 goto out;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500553 }
Avi Kivity19483d12010-05-13 12:30:43 +0300554
Alexander Graf71fbfd52010-03-24 21:48:29 +0100555 case KVM_ENABLE_CAP:
556 {
557 struct kvm_enable_cap cap;
558 r = -EFAULT;
559 if (copy_from_user(&cap, argp, sizeof(cap)))
560 goto out;
561 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
562 break;
563 }
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500564 default:
565 r = -EINVAL;
566 }
567
568out:
569 return r;
570}
571
Alexander Graf15711e92010-07-29 14:48:08 +0200572static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo)
573{
574 u32 inst_lis = 0x3c000000;
575 u32 inst_ori = 0x60000000;
576 u32 inst_nop = 0x60000000;
577 u32 inst_sc = 0x44000002;
578 u32 inst_imm_mask = 0xffff;
579
580 /*
581 * The hypercall to get into KVM from within guest context is as
582 * follows:
583 *
584 * lis r0, r0, KVM_SC_MAGIC_R0@h
585 * ori r0, KVM_SC_MAGIC_R0@l
586 * sc
587 * nop
588 */
589 pvinfo->hcall[0] = inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask);
590 pvinfo->hcall[1] = inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask);
591 pvinfo->hcall[2] = inst_sc;
592 pvinfo->hcall[3] = inst_nop;
593
594 return 0;
595}
596
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500597long kvm_arch_vm_ioctl(struct file *filp,
598 unsigned int ioctl, unsigned long arg)
599{
Alexander Graf15711e92010-07-29 14:48:08 +0200600 void __user *argp = (void __user *)arg;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500601 long r;
602
603 switch (ioctl) {
Alexander Graf15711e92010-07-29 14:48:08 +0200604 case KVM_PPC_GET_PVINFO: {
605 struct kvm_ppc_pvinfo pvinfo;
Vasiliy Kulikovd8cdddc2010-10-30 13:04:24 +0400606 memset(&pvinfo, 0, sizeof(pvinfo));
Alexander Graf15711e92010-07-29 14:48:08 +0200607 r = kvm_vm_ioctl_get_pvinfo(&pvinfo);
608 if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) {
609 r = -EFAULT;
610 goto out;
611 }
612
613 break;
614 }
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500615 default:
Avi Kivity367e1312009-08-26 14:57:07 +0300616 r = -ENOTTY;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500617 }
618
Alexander Graf15711e92010-07-29 14:48:08 +0200619out:
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500620 return r;
621}
622
623int kvm_arch_init(void *opaque)
624{
625 return 0;
626}
627
628void kvm_arch_exit(void)
629{
630}