blob: 2822c8ccfaaf3ae036d6ce8da0fc16b4cf7c12a7 [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>
26#include <linux/fs.h>
27#include <asm/cputable.h>
28#include <asm/uaccess.h>
29#include <asm/kvm_ppc.h>
Hollis Blanchard83aae4a2008-07-25 13:54:52 -050030#include <asm/tlbflush.h>
Hollis Blanchard73e75b42008-12-02 15:51:57 -060031#include "timing.h"
Paul Mackerrasfad7b9b2008-12-23 14:57:26 +110032#include "../mm/mmu_decl.h"
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050033
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050034gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn)
35{
36 return gfn;
37}
38
39int kvm_cpu_has_interrupt(struct kvm_vcpu *v)
40{
Hollis Blanchard45c5eb62008-04-25 17:55:49 -050041 return !!(v->arch.pending_exceptions);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050042}
43
44int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
45{
Hollis Blanchard45c5eb62008-04-25 17:55:49 -050046 return !(v->arch.msr & MSR_WE);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -050047}
48
49
50int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu)
51{
52 enum emulation_result er;
53 int r;
54
55 er = kvmppc_emulate_instruction(run, vcpu);
56 switch (er) {
57 case EMULATE_DONE:
58 /* Future optimization: only reload non-volatiles if they were
59 * actually modified. */
60 r = RESUME_GUEST_NV;
61 break;
62 case EMULATE_DO_MMIO:
63 run->exit_reason = KVM_EXIT_MMIO;
64 /* We must reload nonvolatiles because "update" load/store
65 * instructions modify register state. */
66 /* Future optimization: only reload non-volatiles if they were
67 * actually modified. */
68 r = RESUME_HOST_NV;
69 break;
70 case EMULATE_FAIL:
71 /* XXX Deliver Program interrupt to guest. */
72 printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__,
73 vcpu->arch.last_inst);
74 r = RESUME_HOST;
75 break;
76 default:
77 BUG();
78 }
79
80 return r;
81}
82
83void kvm_arch_hardware_enable(void *garbage)
84{
85}
86
87void kvm_arch_hardware_disable(void *garbage)
88{
89}
90
91int kvm_arch_hardware_setup(void)
92{
93 return 0;
94}
95
96void kvm_arch_hardware_unsetup(void)
97{
98}
99
100void kvm_arch_check_processor_compat(void *rtn)
101{
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600102 *(int *)rtn = kvmppc_core_check_processor_compat();
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500103}
104
105struct kvm *kvm_arch_create_vm(void)
106{
107 struct kvm *kvm;
108
109 kvm = kzalloc(sizeof(struct kvm), GFP_KERNEL);
110 if (!kvm)
111 return ERR_PTR(-ENOMEM);
112
113 return kvm;
114}
115
116static void kvmppc_free_vcpus(struct kvm *kvm)
117{
118 unsigned int i;
119
120 for (i = 0; i < KVM_MAX_VCPUS; ++i) {
121 if (kvm->vcpus[i]) {
122 kvm_arch_vcpu_free(kvm->vcpus[i]);
123 kvm->vcpus[i] = NULL;
124 }
125 }
126}
127
128void kvm_arch_destroy_vm(struct kvm *kvm)
129{
130 kvmppc_free_vcpus(kvm);
131 kvm_free_physmem(kvm);
132 kfree(kvm);
133}
134
135int kvm_dev_ioctl_check_extension(long ext)
136{
137 int r;
138
139 switch (ext) {
Laurent Vivier588968b2008-05-30 16:05:56 +0200140 case KVM_CAP_COALESCED_MMIO:
141 r = KVM_COALESCED_MMIO_PAGE_OFFSET;
142 break;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500143 default:
144 r = 0;
145 break;
146 }
147 return r;
148
149}
150
151long kvm_arch_dev_ioctl(struct file *filp,
152 unsigned int ioctl, unsigned long arg)
153{
154 return -EINVAL;
155}
156
157int kvm_arch_set_memory_region(struct kvm *kvm,
158 struct kvm_userspace_memory_region *mem,
159 struct kvm_memory_slot old,
160 int user_alloc)
161{
162 return 0;
163}
164
Marcelo Tosatti34d4cb82008-07-10 20:49:31 -0300165void kvm_arch_flush_shadow(struct kvm *kvm)
166{
167}
168
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500169struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id)
170{
Hollis Blanchard73e75b42008-12-02 15:51:57 -0600171 struct kvm_vcpu *vcpu;
172 vcpu = kvmppc_core_vcpu_create(kvm, id);
173 kvmppc_create_vcpu_debugfs(vcpu, id);
174 return vcpu;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500175}
176
177void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
178{
Hollis Blanchard73e75b42008-12-02 15:51:57 -0600179 kvmppc_remove_vcpu_debugfs(vcpu);
Hollis Blancharddb93f572008-11-05 09:36:18 -0600180 kvmppc_core_vcpu_free(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500181}
182
183void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
184{
185 kvm_arch_vcpu_free(vcpu);
186}
187
188int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
189{
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600190 return kvmppc_core_pending_dec(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500191}
192
193static void kvmppc_decrementer_func(unsigned long data)
194{
195 struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data;
196
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600197 kvmppc_core_queue_dec(vcpu);
Hollis Blanchard45c5eb62008-04-25 17:55:49 -0500198
199 if (waitqueue_active(&vcpu->wq)) {
200 wake_up_interruptible(&vcpu->wq);
201 vcpu->stat.halt_wakeup++;
202 }
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500203}
204
205int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
206{
207 setup_timer(&vcpu->arch.dec_timer, kvmppc_decrementer_func,
208 (unsigned long)vcpu);
209
210 return 0;
211}
212
213void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
214{
Hollis Blanchardc30f8a62008-11-24 11:37:38 -0600215 kvmppc_core_destroy_mmu(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500216}
217
218void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
219{
Hollis Blanchard6a0ab732008-07-25 13:54:49 -0500220 if (vcpu->guest_debug.enabled)
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600221 kvmppc_core_load_guest_debugstate(vcpu);
Hollis Blanchard83aae4a2008-07-25 13:54:52 -0500222
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600223 kvmppc_core_vcpu_load(vcpu, cpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500224}
225
226void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
227{
Hollis Blanchard6a0ab732008-07-25 13:54:49 -0500228 if (vcpu->guest_debug.enabled)
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600229 kvmppc_core_load_host_debugstate(vcpu);
Hollis Blanchard83aae4a2008-07-25 13:54:52 -0500230
231 /* Don't leave guest TLB entries resident when being de-scheduled. */
232 /* XXX It would be nice to differentiate between heavyweight exit and
233 * sched_out here, since we could avoid the TLB flush for heavyweight
234 * exits. */
Benjamin Herrenschmidt2a4aca112008-12-18 19:13:42 +0000235 _tlbil_all();
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600236 kvmppc_core_vcpu_put(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500237}
238
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500239int kvm_arch_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu,
240 struct kvm_debug_guest *dbg)
241{
Hollis Blanchard6a0ab732008-07-25 13:54:49 -0500242 int i;
243
244 vcpu->guest_debug.enabled = dbg->enabled;
245 if (vcpu->guest_debug.enabled) {
246 for (i=0; i < ARRAY_SIZE(vcpu->guest_debug.bp); i++) {
247 if (dbg->breakpoints[i].enabled)
248 vcpu->guest_debug.bp[i] = dbg->breakpoints[i].address;
249 else
250 vcpu->guest_debug.bp[i] = 0;
251 }
252 }
253
254 return 0;
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500255}
256
257static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu,
258 struct kvm_run *run)
259{
Hollis Blanchard5cf8ca22008-11-05 09:36:19 -0600260 ulong *gpr = &vcpu->arch.gpr[vcpu->arch.io_gpr];
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500261 *gpr = run->dcr.data;
262}
263
264static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu,
265 struct kvm_run *run)
266{
Hollis Blanchard5cf8ca22008-11-05 09:36:19 -0600267 ulong *gpr = &vcpu->arch.gpr[vcpu->arch.io_gpr];
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500268
269 if (run->mmio.len > sizeof(*gpr)) {
270 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len);
271 return;
272 }
273
274 if (vcpu->arch.mmio_is_bigendian) {
275 switch (run->mmio.len) {
276 case 4: *gpr = *(u32 *)run->mmio.data; break;
277 case 2: *gpr = *(u16 *)run->mmio.data; break;
278 case 1: *gpr = *(u8 *)run->mmio.data; break;
279 }
280 } else {
281 /* Convert BE data from userland back to LE. */
282 switch (run->mmio.len) {
283 case 4: *gpr = ld_le32((u32 *)run->mmio.data); break;
284 case 2: *gpr = ld_le16((u16 *)run->mmio.data); break;
285 case 1: *gpr = *(u8 *)run->mmio.data; break;
286 }
287 }
288}
289
290int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
291 unsigned int rt, unsigned int bytes, int is_bigendian)
292{
293 if (bytes > sizeof(run->mmio.data)) {
294 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
295 run->mmio.len);
296 }
297
298 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
299 run->mmio.len = bytes;
300 run->mmio.is_write = 0;
301
302 vcpu->arch.io_gpr = rt;
303 vcpu->arch.mmio_is_bigendian = is_bigendian;
304 vcpu->mmio_needed = 1;
305 vcpu->mmio_is_write = 0;
306
307 return EMULATE_DO_MMIO;
308}
309
310int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu,
311 u32 val, unsigned int bytes, int is_bigendian)
312{
313 void *data = run->mmio.data;
314
315 if (bytes > sizeof(run->mmio.data)) {
316 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
317 run->mmio.len);
318 }
319
320 run->mmio.phys_addr = vcpu->arch.paddr_accessed;
321 run->mmio.len = bytes;
322 run->mmio.is_write = 1;
323 vcpu->mmio_needed = 1;
324 vcpu->mmio_is_write = 1;
325
326 /* Store the value at the lowest bytes in 'data'. */
327 if (is_bigendian) {
328 switch (bytes) {
329 case 4: *(u32 *)data = val; break;
330 case 2: *(u16 *)data = val; break;
331 case 1: *(u8 *)data = val; break;
332 }
333 } else {
334 /* Store LE value into 'data'. */
335 switch (bytes) {
336 case 4: st_le32(data, val); break;
337 case 2: st_le16(data, val); break;
338 case 1: *(u8 *)data = val; break;
339 }
340 }
341
342 return EMULATE_DO_MMIO;
343}
344
345int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
346{
347 int r;
348 sigset_t sigsaved;
349
Hollis Blanchard45c5eb62008-04-25 17:55:49 -0500350 vcpu_load(vcpu);
351
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500352 if (vcpu->sigset_active)
353 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
354
355 if (vcpu->mmio_needed) {
356 if (!vcpu->mmio_is_write)
357 kvmppc_complete_mmio_load(vcpu, run);
358 vcpu->mmio_needed = 0;
359 } else if (vcpu->arch.dcr_needed) {
360 if (!vcpu->arch.dcr_is_write)
361 kvmppc_complete_dcr_load(vcpu, run);
362 vcpu->arch.dcr_needed = 0;
363 }
364
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600365 kvmppc_core_deliver_interrupts(vcpu);
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500366
367 local_irq_disable();
368 kvm_guest_enter();
369 r = __kvmppc_vcpu_run(run, vcpu);
370 kvm_guest_exit();
371 local_irq_enable();
372
373 if (vcpu->sigset_active)
374 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
375
Hollis Blanchard45c5eb62008-04-25 17:55:49 -0500376 vcpu_put(vcpu);
377
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500378 return r;
379}
380
381int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq)
382{
Hollis Blanchard9dd921c2008-11-05 09:36:14 -0600383 kvmppc_core_queue_external(vcpu, irq);
Hollis Blanchard45c5eb62008-04-25 17:55:49 -0500384
385 if (waitqueue_active(&vcpu->wq)) {
386 wake_up_interruptible(&vcpu->wq);
387 vcpu->stat.halt_wakeup++;
388 }
389
Hollis Blanchardbbf45ba2008-04-16 23:28:09 -0500390 return 0;
391}
392
393int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
394 struct kvm_mp_state *mp_state)
395{
396 return -EINVAL;
397}
398
399int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
400 struct kvm_mp_state *mp_state)
401{
402 return -EINVAL;
403}
404
405long kvm_arch_vcpu_ioctl(struct file *filp,
406 unsigned int ioctl, unsigned long arg)
407{
408 struct kvm_vcpu *vcpu = filp->private_data;
409 void __user *argp = (void __user *)arg;
410 long r;
411
412 switch (ioctl) {
413 case KVM_INTERRUPT: {
414 struct kvm_interrupt irq;
415 r = -EFAULT;
416 if (copy_from_user(&irq, argp, sizeof(irq)))
417 goto out;
418 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq);
419 break;
420 }
421 default:
422 r = -EINVAL;
423 }
424
425out:
426 return r;
427}
428
429int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log)
430{
431 return -ENOTSUPP;
432}
433
434long kvm_arch_vm_ioctl(struct file *filp,
435 unsigned int ioctl, unsigned long arg)
436{
437 long r;
438
439 switch (ioctl) {
440 default:
441 r = -EINVAL;
442 }
443
444 return r;
445}
446
447int kvm_arch_init(void *opaque)
448{
449 return 0;
450}
451
452void kvm_arch_exit(void)
453{
454}