arch/powerpc/kvm/powerpc.c

   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/hrtimer.h>
  27 #include <linux/fs.h>
  28 #include <linux/slab.h>
  29 #include <asm/cputable.h>
  30 #include <asm/uaccess.h>
  31 #include <asm/kvm_ppc.h>
  32 #include <asm/tlbflush.h>
  33 #include <asm/cputhreads.h>
  34 #include "timing.h"
  35 #include "../mm/mmu_decl.h"
  36
  37 #define CREATE_TRACE_POINTS
  38 #include "trace.h"
  39
  40 int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
  41 {
  42 #ifndef CONFIG_KVM_BOOK3S_64_HV
  43         return !(v->arch.shared->msr & MSR_WE) ||
  44                !!(v->arch.pending_exceptions);
  45 #else
  46         return !(v->arch.ceded) || !!(v->arch.pending_exceptions);
  47 #endif
  48 }
  49
  50 int kvmppc_kvm_pv(struct kvm_vcpu *vcpu)
  51 {
  52         int nr = kvmppc_get_gpr(vcpu, 11);
  53         int r;
  54         unsigned long __maybe_unused param1 = kvmppc_get_gpr(vcpu, 3);
  55         unsigned long __maybe_unused param2 = kvmppc_get_gpr(vcpu, 4);
  56         unsigned long __maybe_unused param3 = kvmppc_get_gpr(vcpu, 5);
  57         unsigned long __maybe_unused param4 = kvmppc_get_gpr(vcpu, 6);
  58         unsigned long r2 = 0;
  59
  60         if (!(vcpu->arch.shared->msr & MSR_SF)) {
  61                 /* 32 bit mode */
  62                 param1 &= 0xffffffff;
  63                 param2 &= 0xffffffff;
  64                 param3 &= 0xffffffff;
  65                 param4 &= 0xffffffff;
  66         }
  67
  68         switch (nr) {
  69         case HC_VENDOR_KVM | KVM_HC_PPC_MAP_MAGIC_PAGE:
  70         {
  71                 vcpu->arch.magic_page_pa = param1;
  72                 vcpu->arch.magic_page_ea = param2;
  73
  74                 r2 = KVM_MAGIC_FEAT_SR;
  75
  76                 r = HC_EV_SUCCESS;
  77                 break;
  78         }
  79         case HC_VENDOR_KVM | KVM_HC_FEATURES:
  80                 r = HC_EV_SUCCESS;
  81 #if defined(CONFIG_PPC_BOOK3S) || defined(CONFIG_KVM_E500)
  82                 /* XXX Missing magic page on 44x */
  83                 r2 |= (1 << KVM_FEATURE_MAGIC_PAGE);
  84 #endif
  85
  86                 /* Second return value is in r4 */
  87                 break;
  88         default:
  89                 r = HC_EV_UNIMPLEMENTED;
  90                 break;
  91         }
  92
  93         kvmppc_set_gpr(vcpu, 4, r2);
  94
  95         return r;
  96 }
  97
  98 int kvmppc_emulate_mmio(struct kvm_run *run, struct kvm_vcpu *vcpu)
  99 {
 100         enum emulation_result er;
 101         int r;
 102
 103         er = kvmppc_emulate_instruction(run, vcpu);
 104         switch (er) {
 105         case EMULATE_DONE:
 106                 /* Future optimization: only reload non-volatiles if they were
 107                  * actually modified. */
 108                 r = RESUME_GUEST_NV;
 109                 break;
 110         case EMULATE_DO_MMIO:
 111                 run->exit_reason = KVM_EXIT_MMIO;
 112                 /* We must reload nonvolatiles because "update" load/store
 113                  * instructions modify register state. */
 114                 /* Future optimization: only reload non-volatiles if they were
 115                  * actually modified. */
 116                 r = RESUME_HOST_NV;
 117                 break;
 118         case EMULATE_FAIL:
 119                 /* XXX Deliver Program interrupt to guest. */
 120                 printk(KERN_EMERG "%s: emulation failed (%08x)\n", __func__,
 121                        kvmppc_get_last_inst(vcpu));
 122                 r = RESUME_HOST;
 123                 break;
 124         default:
 125                 BUG();
 126         }
 127
 128         return r;
 129 }
 130
 131 int kvm_arch_hardware_enable(void *garbage)
 132 {
 133         return 0;
 134 }
 135
 136 void kvm_arch_hardware_disable(void *garbage)
 137 {
 138 }
 139
 140 int kvm_arch_hardware_setup(void)
 141 {
 142         return 0;
 143 }
 144
 145 void kvm_arch_hardware_unsetup(void)
 146 {
 147 }
 148
 149 void kvm_arch_check_processor_compat(void *rtn)
 150 {
 151         *(int *)rtn = kvmppc_core_check_processor_compat();
 152 }
 153
 154 int kvm_arch_init_vm(struct kvm *kvm)
 155 {
 156         return kvmppc_core_init_vm(kvm);
 157 }
 158
 159 void kvm_arch_destroy_vm(struct kvm *kvm)
 160 {
 161         unsigned int i;
 162         struct kvm_vcpu *vcpu;
 163
 164         kvm_for_each_vcpu(i, vcpu, kvm)
 165                 kvm_arch_vcpu_free(vcpu);
 166
 167         mutex_lock(&kvm->lock);
 168         for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
 169                 kvm->vcpus[i] = NULL;
 170
 171         atomic_set(&kvm->online_vcpus, 0);
 172
 173         kvmppc_core_destroy_vm(kvm);
 174
 175         mutex_unlock(&kvm->lock);
 176 }
 177
 178 void kvm_arch_sync_events(struct kvm *kvm)
 179 {
 180 }
 181
 182 int kvm_dev_ioctl_check_extension(long ext)
 183 {
 184         int r;
 185
 186         switch (ext) {
 187 #ifdef CONFIG_BOOKE
 188         case KVM_CAP_PPC_BOOKE_SREGS:
 189 #else
 190         case KVM_CAP_PPC_SEGSTATE:
 191 #endif
 192         case KVM_CAP_PPC_UNSET_IRQ:
 193         case KVM_CAP_PPC_IRQ_LEVEL:
 194         case KVM_CAP_ENABLE_CAP:
 195                 r = 1;
 196                 break;
 197 #ifndef CONFIG_KVM_BOOK3S_64_HV
 198         case KVM_CAP_PPC_PAIRED_SINGLES:
 199         case KVM_CAP_PPC_OSI:
 200         case KVM_CAP_PPC_GET_PVINFO:
 201                 r = 1;
 202                 break;
 203         case KVM_CAP_COALESCED_MMIO:
 204                 r = KVM_COALESCED_MMIO_PAGE_OFFSET;
 205                 break;
 206 #endif
 207 #ifdef CONFIG_KVM_BOOK3S_64_HV
 208         case KVM_CAP_SPAPR_TCE:
 209                 r = 1;
 210                 break;
 211         case KVM_CAP_PPC_SMT:
 212                 r = threads_per_core;
 213                 break;
 214         case KVM_CAP_PPC_RMA:
 215                 r = 1;
 216                 /* PPC970 requires an RMA */
 217                 if (cpu_has_feature(CPU_FTR_ARCH_201))
 218                         r = 2;
 219                 break;
 220 #endif
 221         default:
 222                 r = 0;
 223                 break;
 224         }
 225         return r;
 226
 227 }
 228
 229 long kvm_arch_dev_ioctl(struct file *filp,
 230                         unsigned int ioctl, unsigned long arg)
 231 {
 232         return -EINVAL;
 233 }
 234
 235 int kvm_arch_prepare_memory_region(struct kvm *kvm,
 236                                    struct kvm_memory_slot *memslot,
 237                                    struct kvm_memory_slot old,
 238                                    struct kvm_userspace_memory_region *mem,
 239                                    int user_alloc)
 240 {
 241         return kvmppc_core_prepare_memory_region(kvm, mem);
 242 }
 243
 244 void kvm_arch_commit_memory_region(struct kvm *kvm,
 245                struct kvm_userspace_memory_region *mem,
 246                struct kvm_memory_slot old,
 247                int user_alloc)
 248 {
 249         kvmppc_core_commit_memory_region(kvm, mem);
 250 }
 251
 252
 253 void kvm_arch_flush_shadow(struct kvm *kvm)
 254 {
 255 }
 256
 257 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id)
 258 {
 259         struct kvm_vcpu *vcpu;
 260         vcpu = kvmppc_core_vcpu_create(kvm, id);
 261         if (!IS_ERR(vcpu))
 262                 kvmppc_create_vcpu_debugfs(vcpu, id);
 263         return vcpu;
 264 }
 265
 266 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
 267 {
 268         /* Make sure we're not using the vcpu anymore */
 269         hrtimer_cancel(&vcpu->arch.dec_timer);
 270         tasklet_kill(&vcpu->arch.tasklet);
 271
 272         kvmppc_remove_vcpu_debugfs(vcpu);
 273         kvmppc_core_vcpu_free(vcpu);
 274 }
 275
 276 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
 277 {
 278         kvm_arch_vcpu_free(vcpu);
 279 }
 280
 281 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
 282 {
 283         return kvmppc_core_pending_dec(vcpu);
 284 }
 285
 286 static void kvmppc_decrementer_func(unsigned long data)
 287 {
 288         struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data;
 289
 290         kvmppc_core_queue_dec(vcpu);
 291
 292         if (waitqueue_active(&vcpu->wq)) {
 293                 wake_up_interruptible(&vcpu->wq);
 294                 vcpu->stat.halt_wakeup++;
 295         }
 296 }
 297
 298 /*
 299  * low level hrtimer wake routine. Because this runs in hardirq context
 300  * we schedule a tasklet to do the real work.
 301  */
 302 enum hrtimer_restart kvmppc_decrementer_wakeup(struct hrtimer *timer)
 303 {
 304         struct kvm_vcpu *vcpu;
 305
 306         vcpu = container_of(timer, struct kvm_vcpu, arch.dec_timer);
 307         tasklet_schedule(&vcpu->arch.tasklet);
 308
 309         return HRTIMER_NORESTART;
 310 }
 311
 312 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
 313 {
 314         hrtimer_init(&vcpu->arch.dec_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
 315         tasklet_init(&vcpu->arch.tasklet, kvmppc_decrementer_func, (ulong)vcpu);
 316         vcpu->arch.dec_timer.function = kvmppc_decrementer_wakeup;
 317         vcpu->arch.dec_expires = ~(u64)0;
 318
 319 #ifdef CONFIG_KVM_EXIT_TIMING
 320         mutex_init(&vcpu->arch.exit_timing_lock);
 321 #endif
 322
 323         return 0;
 324 }
 325
 326 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
 327 {
 328         kvmppc_mmu_destroy(vcpu);
 329 }
 330
 331 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
 332 {
 333 #ifdef CONFIG_BOOKE
 334         /*
 335          * vrsave (formerly usprg0) isn't used by Linux, but may
 336          * be used by the guest.
 337          *
 338          * On non-booke this is associated with Altivec and
 339          * is handled by code in book3s.c.
 340          */
 341         mtspr(SPRN_VRSAVE, vcpu->arch.vrsave);
 342 #endif
 343         kvmppc_core_vcpu_load(vcpu, cpu);
 344         vcpu->cpu = smp_processor_id();
 345 }
 346
 347 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
 348 {
 349         kvmppc_core_vcpu_put(vcpu);
 350 #ifdef CONFIG_BOOKE
 351         vcpu->arch.vrsave = mfspr(SPRN_VRSAVE);
 352 #endif
 353         vcpu->cpu = -1;
 354 }
 355
 356 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
 357                                         struct kvm_guest_debug *dbg)
 358 {
 359         return -EINVAL;
 360 }
 361
 362 static void kvmppc_complete_dcr_load(struct kvm_vcpu *vcpu,
 363                                      struct kvm_run *run)
 364 {
 365         kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, run->dcr.data);
 366 }
 367
 368 static void kvmppc_complete_mmio_load(struct kvm_vcpu *vcpu,
 369                                       struct kvm_run *run)
 370 {
 371         u64 uninitialized_var(gpr);
 372
 373         if (run->mmio.len > sizeof(gpr)) {
 374                 printk(KERN_ERR "bad MMIO length: %d\n", run->mmio.len);
 375                 return;
 376         }
 377
 378         if (vcpu->arch.mmio_is_bigendian) {
 379                 switch (run->mmio.len) {
 380                 case 8: gpr = *(u64 *)run->mmio.data; break;
 381                 case 4: gpr = *(u32 *)run->mmio.data; break;
 382                 case 2: gpr = *(u16 *)run->mmio.data; break;
 383                 case 1: gpr = *(u8 *)run->mmio.data; break;
 384                 }
 385         } else {
 386                 /* Convert BE data from userland back to LE. */
 387                 switch (run->mmio.len) {
 388                 case 4: gpr = ld_le32((u32 *)run->mmio.data); break;
 389                 case 2: gpr = ld_le16((u16 *)run->mmio.data); break;
 390                 case 1: gpr = *(u8 *)run->mmio.data; break;
 391                 }
 392         }
 393
 394         if (vcpu->arch.mmio_sign_extend) {
 395                 switch (run->mmio.len) {
 396 #ifdef CONFIG_PPC64
 397                 case 4:
 398                         gpr = (s64)(s32)gpr;
 399                         break;
 400 #endif
 401                 case 2:
 402                         gpr = (s64)(s16)gpr;
 403                         break;
 404                 case 1:
 405                         gpr = (s64)(s8)gpr;
 406                         break;
 407                 }
 408         }
 409
 410         kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
 411
 412         switch (vcpu->arch.io_gpr & KVM_REG_EXT_MASK) {
 413         case KVM_REG_GPR:
 414                 kvmppc_set_gpr(vcpu, vcpu->arch.io_gpr, gpr);
 415                 break;
 416         case KVM_REG_FPR:
 417                 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
 418                 break;
 419 #ifdef CONFIG_PPC_BOOK3S
 420         case KVM_REG_QPR:
 421                 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
 422                 break;
 423         case KVM_REG_FQPR:
 424                 vcpu->arch.fpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
 425                 vcpu->arch.qpr[vcpu->arch.io_gpr & KVM_REG_MASK] = gpr;
 426                 break;
 427 #endif
 428         default:
 429                 BUG();
 430         }
 431 }
 432
 433 int kvmppc_handle_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
 434                        unsigned int rt, unsigned int bytes, int is_bigendian)
 435 {
 436         if (bytes > sizeof(run->mmio.data)) {
 437                 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
 438                        run->mmio.len);
 439         }
 440
 441         run->mmio.phys_addr = vcpu->arch.paddr_accessed;
 442         run->mmio.len = bytes;
 443         run->mmio.is_write = 0;
 444
 445         vcpu->arch.io_gpr = rt;
 446         vcpu->arch.mmio_is_bigendian = is_bigendian;
 447         vcpu->mmio_needed = 1;
 448         vcpu->mmio_is_write = 0;
 449         vcpu->arch.mmio_sign_extend = 0;
 450
 451         return EMULATE_DO_MMIO;
 452 }
 453
 454 /* Same as above, but sign extends */
 455 int kvmppc_handle_loads(struct kvm_run *run, struct kvm_vcpu *vcpu,
 456                         unsigned int rt, unsigned int bytes, int is_bigendian)
 457 {
 458         int r;
 459
 460         r = kvmppc_handle_load(run, vcpu, rt, bytes, is_bigendian);
 461         vcpu->arch.mmio_sign_extend = 1;
 462
 463         return r;
 464 }
 465
 466 int kvmppc_handle_store(struct kvm_run *run, struct kvm_vcpu *vcpu,
 467                         u64 val, unsigned int bytes, int is_bigendian)
 468 {
 469         void *data = run->mmio.data;
 470
 471         if (bytes > sizeof(run->mmio.data)) {
 472                 printk(KERN_ERR "%s: bad MMIO length: %d\n", __func__,
 473                        run->mmio.len);
 474         }
 475
 476         run->mmio.phys_addr = vcpu->arch.paddr_accessed;
 477         run->mmio.len = bytes;
 478         run->mmio.is_write = 1;
 479         vcpu->mmio_needed = 1;
 480         vcpu->mmio_is_write = 1;
 481
 482         /* Store the value at the lowest bytes in 'data'. */
 483         if (is_bigendian) {
 484                 switch (bytes) {
 485                 case 8: *(u64 *)data = val; break;
 486                 case 4: *(u32 *)data = val; break;
 487                 case 2: *(u16 *)data = val; break;
 488                 case 1: *(u8  *)data = val; break;
 489                 }
 490         } else {
 491                 /* Store LE value into 'data'. */
 492                 switch (bytes) {
 493                 case 4: st_le32(data, val); break;
 494                 case 2: st_le16(data, val); break;
 495                 case 1: *(u8 *)data = val; break;
 496                 }
 497         }
 498
 499         return EMULATE_DO_MMIO;
 500 }
 501
 502 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
 503 {
 504         int r;
 505         sigset_t sigsaved;
 506
 507         if (vcpu->sigset_active)
 508                 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
 509
 510         if (vcpu->mmio_needed) {
 511                 if (!vcpu->mmio_is_write)
 512                         kvmppc_complete_mmio_load(vcpu, run);
 513                 vcpu->mmio_needed = 0;
 514         } else if (vcpu->arch.dcr_needed) {
 515                 if (!vcpu->arch.dcr_is_write)
 516                         kvmppc_complete_dcr_load(vcpu, run);
 517                 vcpu->arch.dcr_needed = 0;
 518         } else if (vcpu->arch.osi_needed) {
 519                 u64 *gprs = run->osi.gprs;
 520                 int i;
 521
 522                 for (i = 0; i < 32; i++)
 523                         kvmppc_set_gpr(vcpu, i, gprs[i]);
 524                 vcpu->arch.osi_needed = 0;
 525         } else if (vcpu->arch.hcall_needed) {
 526                 int i;
 527
 528                 kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret);
 529                 for (i = 0; i < 9; ++i)
 530                         kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]);
 531                 vcpu->arch.hcall_needed = 0;
 532         }
 533
 534         kvmppc_core_deliver_interrupts(vcpu);
 535
 536         r = kvmppc_vcpu_run(run, vcpu);
 537
 538         if (vcpu->sigset_active)
 539                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
 540
 541         return r;
 542 }
 543
 544 int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq)
 545 {
 546         if (irq->irq == KVM_INTERRUPT_UNSET)
 547                 kvmppc_core_dequeue_external(vcpu, irq);
 548         else
 549                 kvmppc_core_queue_external(vcpu, irq);
 550
 551         if (waitqueue_active(&vcpu->wq)) {
 552                 wake_up_interruptible(&vcpu->wq);
 553                 vcpu->stat.halt_wakeup++;
 554         } else if (vcpu->cpu != -1) {
 555                 smp_send_reschedule(vcpu->cpu);
 556         }
 557
 558         return 0;
 559 }
 560
 561 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
 562                                      struct kvm_enable_cap *cap)
 563 {
 564         int r;
 565
 566         if (cap->flags)
 567                 return -EINVAL;
 568
 569         switch (cap->cap) {
 570         case KVM_CAP_PPC_OSI:
 571                 r = 0;
 572                 vcpu->arch.osi_enabled = true;
 573                 break;
 574         default:
 575                 r = -EINVAL;
 576                 break;
 577         }
 578
 579         return r;
 580 }
 581
 582 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
 583                                     struct kvm_mp_state *mp_state)
 584 {
 585         return -EINVAL;
 586 }
 587
 588 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
 589                                     struct kvm_mp_state *mp_state)
 590 {
 591         return -EINVAL;
 592 }
 593
 594 long kvm_arch_vcpu_ioctl(struct file *filp,
 595                          unsigned int ioctl, unsigned long arg)
 596 {
 597         struct kvm_vcpu *vcpu = filp->private_data;
 598         void __user *argp = (void __user *)arg;
 599         long r;
 600
 601         switch (ioctl) {
 602         case KVM_INTERRUPT: {
 603                 struct kvm_interrupt irq;
 604                 r = -EFAULT;
 605                 if (copy_from_user(&irq, argp, sizeof(irq)))
 606                         goto out;
 607                 r = kvm_vcpu_ioctl_interrupt(vcpu, &irq);
 608                 goto out;
 609         }
 610
 611         case KVM_ENABLE_CAP:
 612         {
 613                 struct kvm_enable_cap cap;
 614                 r = -EFAULT;
 615                 if (copy_from_user(&cap, argp, sizeof(cap)))
 616                         goto out;
 617                 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
 618                 break;
 619         }
 620         default:
 621                 r = -EINVAL;
 622         }
 623
 624 out:
 625         return r;
 626 }
 627
 628 static int kvm_vm_ioctl_get_pvinfo(struct kvm_ppc_pvinfo *pvinfo)
 629 {
 630         u32 inst_lis = 0x3c000000;
 631         u32 inst_ori = 0x60000000;
 632         u32 inst_nop = 0x60000000;
 633         u32 inst_sc = 0x44000002;
 634         u32 inst_imm_mask = 0xffff;
 635
 636         /*
 637          * The hypercall to get into KVM from within guest context is as
 638          * follows:
 639          *
 640          *    lis r0, r0, KVM_SC_MAGIC_R0@h
 641          *    ori r0, KVM_SC_MAGIC_R0@l
 642          *    sc
 643          *    nop
 644          */
 645         pvinfo->hcall[0] = inst_lis | ((KVM_SC_MAGIC_R0 >> 16) & inst_imm_mask);
 646         pvinfo->hcall[1] = inst_ori | (KVM_SC_MAGIC_R0 & inst_imm_mask);
 647         pvinfo->hcall[2] = inst_sc;
 648         pvinfo->hcall[3] = inst_nop;
 649
 650         return 0;
 651 }
 652
 653 long kvm_arch_vm_ioctl(struct file *filp,
 654                        unsigned int ioctl, unsigned long arg)
 655 {
 656         void __user *argp = (void __user *)arg;
 657         long r;
 658
 659         switch (ioctl) {
 660         case KVM_PPC_GET_PVINFO: {
 661                 struct kvm_ppc_pvinfo pvinfo;
 662                 memset(&pvinfo, 0, sizeof(pvinfo));
 663                 r = kvm_vm_ioctl_get_pvinfo(&pvinfo);
 664                 if (copy_to_user(argp, &pvinfo, sizeof(pvinfo))) {
 665                         r = -EFAULT;
 666                         goto out;
 667                 }
 668
 669                 break;
 670         }
 671 #ifdef CONFIG_KVM_BOOK3S_64_HV
 672         case KVM_CREATE_SPAPR_TCE: {
 673                 struct kvm_create_spapr_tce create_tce;
 674                 struct kvm *kvm = filp->private_data;
 675
 676                 r = -EFAULT;
 677                 if (copy_from_user(&create_tce, argp, sizeof(create_tce)))
 678                         goto out;
 679                 r = kvm_vm_ioctl_create_spapr_tce(kvm, &create_tce);
 680                 goto out;
 681         }
 682
 683         case KVM_ALLOCATE_RMA: {
 684                 struct kvm *kvm = filp->private_data;
 685                 struct kvm_allocate_rma rma;
 686
 687                 r = kvm_vm_ioctl_allocate_rma(kvm, &rma);
 688                 if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma)))
 689                         r = -EFAULT;
 690                 break;
 691         }
 692 #endif /* CONFIG_KVM_BOOK3S_64_HV */
 693
 694         default:
 695                 r = -ENOTTY;
 696         }
 697
 698 out:
 699         return r;
 700 }
 701
 702 int kvm_arch_init(void *opaque)
 703 {
 704         return 0;
 705 }
 706
 707 void kvm_arch_exit(void)
 708 {
 709 }