linux/arch/powerpc/kvm/powerpc.c
<<
>>
Prefs
   1/*
   2 * This program is free software; you can redistribute it and/or modify
   3 * it under the terms of the GNU General Public License, version 2, as
   4 * published by the Free Software Foundation.
   5 *
   6 * This program is distributed in the hope that it will be useful,
   7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9 * GNU General Public License for more details.
  10 *
  11 * You should have received a copy of the GNU General Public License
  12 * along with this program; if not, write to the Free Software
  13 * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  14 *
  15 * Copyright IBM Corp. 2007
  16 *
  17 * Authors: Hollis Blanchard <hollisb@us.ibm.com>
  18 *          Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
  19 */
  20
  21#include <linux/errno.h>
  22#include <linux/err.h>
  23#include <linux/kvm_host.h>
  24#include <linux/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>
  30#include <asm/tlbflush.h>
  31#include "timing.h"
  32#include "../mm/mmu_decl.h"
  33
  34gfn_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{
  41        return !!(v->arch.pending_exceptions);
  42}
  43
  44int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
  45{
  46        return !(v->arch.msr & MSR_WE);
  47}
  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{
 102        *(int *)rtn = kvmppc_core_check_processor_compat();
 103}
 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_sync_events(struct kvm *kvm)
 129{
 130}
 131
 132void kvm_arch_destroy_vm(struct kvm *kvm)
 133{
 134        kvmppc_free_vcpus(kvm);
 135        kvm_free_physmem(kvm);
 136        kfree(kvm);
 137}
 138
 139int kvm_dev_ioctl_check_extension(long ext)
 140{
 141        int r;
 142
 143        switch (ext) {
 144        case KVM_CAP_COALESCED_MMIO:
 145                r = KVM_COALESCED_MMIO_PAGE_OFFSET;
 146                break;
 147        default:
 148                r = 0;
 149                break;
 150        }
 151        return r;
 152
 153}
 154
 155long kvm_arch_dev_ioctl(struct file *filp,
 156                        unsigned int ioctl, unsigned long arg)
 157{
 158        return -EINVAL;
 159}
 160
 161int kvm_arch_set_memory_region(struct kvm *kvm,
 162                               struct kvm_userspace_memory_region *mem,
 163                               struct kvm_memory_slot old,
 164                               int user_alloc)
 165{
 166        return 0;
 167}
 168
 169void kvm_arch_flush_shadow(struct kvm *kvm)
 170{
 171}
 172
 173struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id)
 174{
 175        struct kvm_vcpu *vcpu;
 176        vcpu = kvmppc_core_vcpu_create(kvm, id);
 177        kvmppc_create_vcpu_debugfs(vcpu, id);
 178        return vcpu;
 179}
 180
 181void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
 182{
 183        kvmppc_remove_vcpu_debugfs(vcpu);
 184        kvmppc_core_vcpu_free(vcpu);
 185}
 186
 187void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
 188{
 189        kvm_arch_vcpu_free(vcpu);
 190}
 191
 192int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
 193{
 194        return kvmppc_core_pending_dec(vcpu);
 195}
 196
 197static void kvmppc_decrementer_func(unsigned long data)
 198{
 199        struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data;
 200
 201        kvmppc_core_queue_dec(vcpu);
 202
 203        if (waitqueue_active(&vcpu->wq)) {
 204                wake_up_interruptible(&vcpu->wq);
 205                vcpu->stat.halt_wakeup++;
 206        }
 207}
 208
 209int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
 210{
 211        setup_timer(&vcpu->arch.dec_timer, kvmppc_decrementer_func,
 212                    (unsigned long)vcpu);
 213
 214        return 0;
 215}
 216
 217void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
 218{
 219        kvmppc_mmu_destroy(vcpu);
 220}
 221
 222void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
 223{
 224        kvmppc_core_vcpu_load(vcpu, cpu);
 225}
 226
 227void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
 228{
 229        kvmppc_core_vcpu_put(vcpu);
 230}
 231
 232int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
 233                                        struct kvm_guest_debug *dbg)
 234{
 235        return -EINVAL;
 236}
 237
 238static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu,
 239                                     struct kvm_run *run)
 240{
 241        ulong *gpr = &vcpu->arch.gpr[vcpu->arch.io_gpr];
 242        *gpr = run->dcr.data;
 243}
 244
 245static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu,
 246                                      struct kvm_run *run)
 247{
 248        ulong *gpr = &vcpu->arch.gpr[vcpu->arch.io_gpr];
 249
 250        if (run->mmio.len > sizeof(*gpr)) {
 251                printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len);
 252                return;
 253        }
 254
 255        if (vcpu->arch.mmio_is_bigendian) {
 256                switch (run->mmio.len) {
 257                case 4: *gpr = *(u32 *)run->mmio.data; break;
 258                case 2: *gpr = *(u16 *)run->mmio.data; break;
 259                case 1: *gpr = *(u8 *)run->mmio.data; break;
 260                }
 261        } else {
 262                /* Convert BE data from userland back to LE. */
 263                switch (run->mmio.len) {
 264                case 4: *gpr = ld_le32((u32 *)run->mmio.data); break;
 265                case 2: *gpr = ld_le16((u16 *)run->mmio.data); break;
 266                case 1: *gpr = *(u8 *)run->mmio.data; break;
 267                }
 268        }
 269}
 270
 271int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
 272                       unsigned int rt, unsigned int bytes, int is_bigendian)
 273{
 274        if (bytes > sizeof(run->mmio.data)) {
 275                printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
 276                       run->mmio.len);
 277        }
 278
 279        run->mmio.phys_addr = vcpu->arch.paddr_accessed;
 280        run->mmio.len = bytes;
 281        run->mmio.is_write = 0;
 282
 283        vcpu->arch.io_gpr = rt;
 284        vcpu->arch.mmio_is_bigendian = is_bigendian;
 285        vcpu->mmio_needed = 1;
 286        vcpu->mmio_is_write = 0;
 287
 288        return EMULATE_DO_MMIO;
 289}
 290
 291int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu,
 292                        u32 val, unsigned int bytes, int is_bigendian)
 293{
 294        void *data = run->mmio.data;
 295
 296        if (bytes > sizeof(run->mmio.data)) {
 297                printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
 298                       run->mmio.len);
 299        }
 300
 301        run->mmio.phys_addr = vcpu->arch.paddr_accessed;
 302        run->mmio.len = bytes;
 303        run->mmio.is_write = 1;
 304        vcpu->mmio_needed = 1;
 305        vcpu->mmio_is_write = 1;
 306
 307        /* Store the value at the lowest bytes in 'data'. */
 308        if (is_bigendian) {
 309                switch (bytes) {
 310                case 4: *(u32 *)data = val; break;
 311                case 2: *(u16 *)data = val; break;
 312                case 1: *(u8  *)data = val; break;
 313                }
 314        } else {
 315                /* Store LE value into 'data'. */
 316                switch (bytes) {
 317                case 4: st_le32(data, val); break;
 318                case 2: st_le16(data, val); break;
 319                case 1: *(u8 *)data = val; break;
 320                }
 321        }
 322
 323        return EMULATE_DO_MMIO;
 324}
 325
 326int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
 327{
 328        int r;
 329        sigset_t sigsaved;
 330
 331        vcpu_load(vcpu);
 332
 333        if (vcpu->sigset_active)
 334                sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
 335
 336        if (vcpu->mmio_needed) {
 337                if (!vcpu->mmio_is_write)
 338                        kvmppc_complete_mmio_load(vcpu, run);
 339                vcpu->mmio_needed = 0;
 340        } else if (vcpu->arch.dcr_needed) {
 341                if (!vcpu->arch.dcr_is_write)
 342                        kvmppc_complete_dcr_load(vcpu, run);
 343                vcpu->arch.dcr_needed = 0;
 344        }
 345
 346        kvmppc_core_deliver_interrupts(vcpu);
 347
 348        local_irq_disable();
 349        kvm_guest_enter();
 350        r = __kvmppc_vcpu_run(run, vcpu);
 351        kvm_guest_exit();
 352        local_irq_enable();
 353
 354        if (vcpu->sigset_active)
 355                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
 356
 357        vcpu_put(vcpu);
 358
 359        return r;
 360}
 361
 362int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq)
 363{
 364        kvmppc_core_queue_external(vcpu, irq);
 365
 366        if (waitqueue_active(&vcpu->wq)) {
 367                wake_up_interruptible(&vcpu->wq);
 368                vcpu->stat.halt_wakeup++;
 369        }
 370
 371        return 0;
 372}
 373
 374int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
 375                                    struct kvm_mp_state *mp_state)
 376{
 377        return -EINVAL;
 378}
 379
 380int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
 381                                    struct kvm_mp_state *mp_state)
 382{
 383        return -EINVAL;
 384}
 385
 386long kvm_arch_vcpu_ioctl(struct file *filp,
 387                         unsigned int ioctl, unsigned long arg)
 388{
 389        struct kvm_vcpu *vcpu = filp->private_data;
 390        void __user *argp = (void __user *)arg;
 391        long r;
 392
 393        switch (ioctl) {
 394        case KVM_INTERRUPT: {
 395                struct kvm_interrupt irq;
 396                r = -EFAULT;
 397                if (copy_from_user(&irq, argp, sizeof(irq)))
 398                        goto out;
 399                r = kvm_vcpu_ioctl_interrupt(vcpu, &irq);
 400                break;
 401        }
 402        default:
 403                r = -EINVAL;
 404        }
 405
 406out:
 407        return r;
 408}
 409
 410int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log)
 411{
 412        return -ENOTSUPP;
 413}
 414
 415long kvm_arch_vm_ioctl(struct file *filp,
 416                       unsigned int ioctl, unsigned long arg)
 417{
 418        long r;
 419
 420        switch (ioctl) {
 421        default:
 422                r = -EINVAL;
 423        }
 424
 425        return r;
 426}
 427
 428int kvm_arch_init(void *opaque)
 429{
 430        return 0;
 431}
 432
 433void kvm_arch_exit(void)
 434{
 435}
 436