KVM: PPC: Book3S: Add infrastructure to implement kernel-side RTAS calls
authorMichael Ellerman <michael@ellerman.id.au>
Wed, 17 Apr 2013 20:30:00 +0000 (20:30 +0000)
committerAlexander Graf <agraf@suse.de>
Fri, 26 Apr 2013 18:27:29 +0000 (20:27 +0200)
For pseries machine emulation, in order to move the interrupt
controller code to the kernel, we need to intercept some RTAS
calls in the kernel itself.  This adds an infrastructure to allow
in-kernel handlers to be registered for RTAS services by name.
A new ioctl, KVM_PPC_RTAS_DEFINE_TOKEN, then allows userspace to
associate token values with those service names.  Then, when the
guest requests an RTAS service with one of those token values, it
will be handled by the relevant in-kernel handler rather than being
passed up to userspace as at present.

Signed-off-by: Michael Ellerman <michael@ellerman.id.au>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
[agraf: fix warning]
Signed-off-by: Alexander Graf <agraf@suse.de>
12 files changed:
Documentation/virtual/kvm/api.txt
arch/powerpc/include/asm/hvcall.h
arch/powerpc/include/asm/kvm_host.h
arch/powerpc/include/asm/kvm_ppc.h
arch/powerpc/include/uapi/asm/kvm.h
arch/powerpc/kvm/Makefile
arch/powerpc/kvm/book3s_hv.c
arch/powerpc/kvm/book3s_pr.c
arch/powerpc/kvm/book3s_pr_papr.c
arch/powerpc/kvm/book3s_rtas.c [new file with mode: 0644]
arch/powerpc/kvm/powerpc.c
include/uapi/linux/kvm.h

index 149558b1e81eedbd238e2e3808ee1c20e48e7f8b..fb308be8521bf76fe74f22ae7499e38bed35c245 100644 (file)
@@ -2341,6 +2341,25 @@ and distributor interface, the ioctl must be called after calling
 KVM_CREATE_IRQCHIP, but before calling KVM_RUN on any of the VCPUs.  Calling
 this ioctl twice for any of the base addresses will return -EEXIST.
 
+4.82 KVM_PPC_RTAS_DEFINE_TOKEN
+
+Capability: KVM_CAP_PPC_RTAS
+Architectures: ppc
+Type: vm ioctl
+Parameters: struct kvm_rtas_token_args
+Returns: 0 on success, -1 on error
+
+Defines a token value for a RTAS (Run Time Abstraction Services)
+service in order to allow it to be handled in the kernel.  The
+argument struct gives the name of the service, which must be the name
+of a service that has a kernel-side implementation.  If the token
+value is non-zero, it will be associated with that service, and
+subsequent RTAS calls by the guest specifying that token will be
+handled by the kernel.  If the token value is 0, then any token
+associated with the service will be forgotten, and subsequent RTAS
+calls by the guest for that service will be passed to userspace to be
+handled.
+
 
 5. The kvm_run structure
 ------------------------
index 4bc2c3dad6adf4045de3c9749c1c7fec1b777bb5..cf4df8e2139af0a1a0c083ba3ad2618b2efc57c4 100644 (file)
 #define H_SET_MODE             0x31C
 #define MAX_HCALL_OPCODE       H_SET_MODE
 
+/* Platform specific hcalls, used by KVM */
+#define H_RTAS                 0xf000
+
 #ifndef __ASSEMBLY__
 
 /**
index 13740a645a6dadc55a5c387628e9b4fb4937a8a7..311f7e6f09e99b078a590f56ce1c4541e60cb14b 100644 (file)
@@ -259,6 +259,7 @@ struct kvm_arch {
 #endif /* CONFIG_KVM_BOOK3S_64_HV */
 #ifdef CONFIG_PPC_BOOK3S_64
        struct list_head spapr_tce_tables;
+       struct list_head rtas_tokens;
 #endif
 #ifdef CONFIG_KVM_MPIC
        struct openpic *mpic;
index df9c80b3790560cf23b2be0c5b835564ad2f824e..8a30eb7f2becf67e3adcc3f7ef2f78c97f79fd77 100644 (file)
@@ -166,6 +166,10 @@ extern int kvm_vm_ioctl_get_htab_fd(struct kvm *kvm, struct kvm_get_htab_fd *);
 
 int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq);
 
+extern int kvm_vm_ioctl_rtas_define_token(struct kvm *kvm, void __user *argp);
+extern int kvmppc_rtas_hcall(struct kvm_vcpu *vcpu);
+extern void kvmppc_rtas_tokens_free(struct kvm *kvm);
+
 /*
  * Cuts out inst bits with ordering according to spec.
  * That means the leftmost bit is zero. All given bits are included.
index 03c7819a44a38bb5d78913fa42934572fd27895e..eb9e25c194adb7bf6e97e3ee2fe6b6f29a35ad57 100644 (file)
@@ -324,6 +324,12 @@ struct kvm_allocate_rma {
        __u64 rma_size;
 };
 
+/* for KVM_CAP_PPC_RTAS */
+struct kvm_rtas_token_args {
+       char name[120];
+       __u64 token;    /* Use a token of 0 to undefine a mapping */
+};
+
 struct kvm_book3e_206_tlb_entry {
        __u32 mas8;
        __u32 mas1;
index 4eada0c010829f76d35c209454b5190630cb96d7..3faf5c07329c98f9d9f68ec071eba07ad09be042 100644 (file)
@@ -86,6 +86,7 @@ kvm-book3s_64-module-objs := \
        emulate.o \
        book3s.o \
        book3s_64_vio.o \
+       book3s_rtas.o \
        $(kvm-book3s_64-objs-y)
 
 kvm-objs-$(CONFIG_KVM_BOOK3S_64) := $(kvm-book3s_64-module-objs)
index 5af0f29798332f1ca908efd8975e48f138beb5d0..f3d7af7981c7d457945b102dc1892be398104a4a 100644 (file)
@@ -483,7 +483,7 @@ int kvmppc_pseries_do_hcall(struct kvm_vcpu *vcpu)
        unsigned long req = kvmppc_get_gpr(vcpu, 3);
        unsigned long target, ret = H_SUCCESS;
        struct kvm_vcpu *tvcpu;
-       int idx;
+       int idx, rc;
 
        switch (req) {
        case H_ENTER:
@@ -519,6 +519,19 @@ int kvmppc_pseries_do_hcall(struct kvm_vcpu *vcpu)
                                        kvmppc_get_gpr(vcpu, 5),
                                        kvmppc_get_gpr(vcpu, 6));
                break;
+       case H_RTAS:
+               if (list_empty(&vcpu->kvm->arch.rtas_tokens))
+                       return RESUME_HOST;
+
+               rc = kvmppc_rtas_hcall(vcpu);
+
+               if (rc == -ENOENT)
+                       return RESUME_HOST;
+               else if (rc == 0)
+                       break;
+
+               /* Send the error out to userspace via KVM_RUN */
+               return rc;
        default:
                return RESUME_HOST;
        }
@@ -1829,6 +1842,7 @@ int kvmppc_core_init_vm(struct kvm *kvm)
        cpumask_setall(&kvm->arch.need_tlb_flush);
 
        INIT_LIST_HEAD(&kvm->arch.spapr_tce_tables);
+       INIT_LIST_HEAD(&kvm->arch.rtas_tokens);
 
        kvm->arch.rma = NULL;
 
@@ -1874,6 +1888,8 @@ void kvmppc_core_destroy_vm(struct kvm *kvm)
                kvm->arch.rma = NULL;
        }
 
+       kvmppc_rtas_tokens_free(kvm);
+
        kvmppc_free_hpt(kvm);
        WARN_ON(!list_empty(&kvm->arch.spapr_tce_tables));
 }
index c1cffa882a69c911c6adbf9d000d3df2dc180088..d09baf143500401b159caf2da1227b5fc023fcc8 100644 (file)
@@ -1296,6 +1296,7 @@ int kvmppc_core_init_vm(struct kvm *kvm)
 {
 #ifdef CONFIG_PPC64
        INIT_LIST_HEAD(&kvm->arch.spapr_tce_tables);
+       INIT_LIST_HEAD(&kvm->arch.rtas_tokens);
 #endif
 
        if (firmware_has_feature(FW_FEATURE_SET_MODE)) {
index ee02b30878ed4bec733af6cbd9aa152eefe22d0f..4efa4a4f3722a430f1cf95a46eee4fa8c5b09f90 100644 (file)
@@ -246,6 +246,13 @@ int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd)
                clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
                vcpu->stat.halt_wakeup++;
                return EMULATE_DONE;
+       case H_RTAS:
+               if (list_empty(&vcpu->kvm->arch.rtas_tokens))
+                       return RESUME_HOST;
+               if (kvmppc_rtas_hcall(vcpu))
+                       break;
+               kvmppc_set_gpr(vcpu, 3, 0);
+               return EMULATE_DONE;
        }
 
        return EMULATE_FAIL;
diff --git a/arch/powerpc/kvm/book3s_rtas.c b/arch/powerpc/kvm/book3s_rtas.c
new file mode 100644 (file)
index 0000000..6ad7050
--- /dev/null
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2012 Michael Ellerman, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/kvm_host.h>
+#include <linux/kvm.h>
+#include <linux/err.h>
+
+#include <asm/uaccess.h>
+#include <asm/kvm_book3s.h>
+#include <asm/kvm_ppc.h>
+#include <asm/hvcall.h>
+#include <asm/rtas.h>
+
+
+struct rtas_handler {
+       void (*handler)(struct kvm_vcpu *vcpu, struct rtas_args *args);
+       char *name;
+};
+
+static struct rtas_handler rtas_handlers[] = { };
+
+struct rtas_token_definition {
+       struct list_head list;
+       struct rtas_handler *handler;
+       u64 token;
+};
+
+static int rtas_name_matches(char *s1, char *s2)
+{
+       struct kvm_rtas_token_args args;
+       return !strncmp(s1, s2, sizeof(args.name));
+}
+
+static int rtas_token_undefine(struct kvm *kvm, char *name)
+{
+       struct rtas_token_definition *d, *tmp;
+
+       lockdep_assert_held(&kvm->lock);
+
+       list_for_each_entry_safe(d, tmp, &kvm->arch.rtas_tokens, list) {
+               if (rtas_name_matches(d->handler->name, name)) {
+                       list_del(&d->list);
+                       kfree(d);
+                       return 0;
+               }
+       }
+
+       /* It's not an error to undefine an undefined token */
+       return 0;
+}
+
+static int rtas_token_define(struct kvm *kvm, char *name, u64 token)
+{
+       struct rtas_token_definition *d;
+       struct rtas_handler *h = NULL;
+       bool found;
+       int i;
+
+       lockdep_assert_held(&kvm->lock);
+
+       list_for_each_entry(d, &kvm->arch.rtas_tokens, list) {
+               if (d->token == token)
+                       return -EEXIST;
+       }
+
+       found = false;
+       for (i = 0; i < ARRAY_SIZE(rtas_handlers); i++) {
+               h = &rtas_handlers[i];
+               if (rtas_name_matches(h->name, name)) {
+                       found = true;
+                       break;
+               }
+       }
+
+       if (!found)
+               return -ENOENT;
+
+       d = kzalloc(sizeof(*d), GFP_KERNEL);
+       if (!d)
+               return -ENOMEM;
+
+       d->handler = h;
+       d->token = token;
+
+       list_add_tail(&d->list, &kvm->arch.rtas_tokens);
+
+       return 0;
+}
+
+int kvm_vm_ioctl_rtas_define_token(struct kvm *kvm, void __user *argp)
+{
+       struct kvm_rtas_token_args args;
+       int rc;
+
+       if (copy_from_user(&args, argp, sizeof(args)))
+               return -EFAULT;
+
+       mutex_lock(&kvm->lock);
+
+       if (args.token)
+               rc = rtas_token_define(kvm, args.name, args.token);
+       else
+               rc = rtas_token_undefine(kvm, args.name);
+
+       mutex_unlock(&kvm->lock);
+
+       return rc;
+}
+
+int kvmppc_rtas_hcall(struct kvm_vcpu *vcpu)
+{
+       struct rtas_token_definition *d;
+       struct rtas_args args;
+       rtas_arg_t *orig_rets;
+       gpa_t args_phys;
+       int rc;
+
+       /* r4 contains the guest physical address of the RTAS args */
+       args_phys = kvmppc_get_gpr(vcpu, 4);
+
+       rc = kvm_read_guest(vcpu->kvm, args_phys, &args, sizeof(args));
+       if (rc)
+               goto fail;
+
+       /*
+        * args->rets is a pointer into args->args. Now that we've
+        * copied args we need to fix it up to point into our copy,
+        * not the guest args. We also need to save the original
+        * value so we can restore it on the way out.
+        */
+       orig_rets = args.rets;
+       args.rets = &args.args[args.nargs];
+
+       mutex_lock(&vcpu->kvm->lock);
+
+       rc = -ENOENT;
+       list_for_each_entry(d, &vcpu->kvm->arch.rtas_tokens, list) {
+               if (d->token == args.token) {
+                       d->handler->handler(vcpu, &args);
+                       rc = 0;
+                       break;
+               }
+       }
+
+       mutex_unlock(&vcpu->kvm->lock);
+
+       if (rc == 0) {
+               args.rets = orig_rets;
+               rc = kvm_write_guest(vcpu->kvm, args_phys, &args, sizeof(args));
+               if (rc)
+                       goto fail;
+       }
+
+       return rc;
+
+fail:
+       /*
+        * We only get here if the guest has called RTAS with a bogus
+        * args pointer. That means we can't get to the args, and so we
+        * can't fail the RTAS call. So fail right out to userspace,
+        * which should kill the guest.
+        */
+       return rc;
+}
+
+void kvmppc_rtas_tokens_free(struct kvm *kvm)
+{
+       struct rtas_token_definition *d, *tmp;
+
+       lockdep_assert_held(&kvm->lock);
+
+       list_for_each_entry_safe(d, tmp, &kvm->arch.rtas_tokens, list) {
+               list_del(&d->list);
+               kfree(d);
+       }
+}
index d8e81e6c1afe475e7b7fe5f2944d54acd41c9c25..d4fd443ae7bdc4bc1d5bc20588e8fbe6410e5c89 100644 (file)
@@ -341,6 +341,7 @@ int kvm_dev_ioctl_check_extension(long ext)
 #ifdef CONFIG_PPC_BOOK3S_64
        case KVM_CAP_SPAPR_TCE:
        case KVM_CAP_PPC_ALLOC_HTAB:
+       case KVM_CAP_PPC_RTAS:
                r = 1;
                break;
 #endif /* CONFIG_PPC_BOOK3S_64 */
@@ -986,6 +987,7 @@ long kvm_arch_vm_ioctl(struct file *filp,
 #ifdef CONFIG_KVM_BOOK3S_64_HV
        case KVM_ALLOCATE_RMA: {
                struct kvm_allocate_rma rma;
+               struct kvm *kvm = filp->private_data;
 
                r = kvm_vm_ioctl_allocate_rma(kvm, &rma);
                if (r >= 0 && copy_to_user(argp, &rma, sizeof(rma)))
@@ -1030,6 +1032,12 @@ long kvm_arch_vm_ioctl(struct file *filp,
                        r = -EFAULT;
                break;
        }
+       case KVM_PPC_RTAS_DEFINE_TOKEN: {
+               struct kvm *kvm = filp->private_data;
+
+               r = kvm_vm_ioctl_rtas_define_token(kvm, argp);
+               break;
+       }
 #endif /* CONFIG_PPC_BOOK3S_64 */
        default:
                r = -ENOTTY;
index 0ebf59b50ed0563cf8f27b8fdf5166bc02b7bd6c..d4005192ad6e20ee9416b7813e2c0447aa7f2479 100644 (file)
@@ -668,6 +668,7 @@ struct kvm_ppc_smmu_info {
 #define KVM_CAP_ARM_SET_DEVICE_ADDR 88
 #define KVM_CAP_DEVICE_CTRL 89
 #define KVM_CAP_IRQ_MPIC 90
+#define KVM_CAP_PPC_RTAS 91
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
@@ -928,6 +929,8 @@ struct kvm_s390_ucas_mapping {
 #define KVM_PPC_GET_HTAB_FD      _IOW(KVMIO,  0xaa, struct kvm_get_htab_fd)
 /* Available with KVM_CAP_ARM_SET_DEVICE_ADDR */
 #define KVM_ARM_SET_DEVICE_ADDR          _IOW(KVMIO,  0xab, struct kvm_arm_device_addr)
+/* Available with KVM_CAP_PPC_RTAS */
+#define KVM_PPC_RTAS_DEFINE_TOKEN _IOW(KVMIO,  0xac, struct kvm_rtas_token_args)
 
 /* ioctl for vm fd */
 #define KVM_CREATE_DEVICE        _IOWR(KVMIO,  0xe0, struct kvm_create_device)