3 files changed, 88 insertions, 55 deletions

diff --git a/virt/kvm/Kconfig b/virt/kvm/Kconfig
index 70691c08e1ed..cca7e065a075 100644
--- a/virt/kvm/Kconfig
+++ b/virt/kvm/Kconfig
@@ -51,3 +51,6 @@ config KVM_COMPAT
 
 config HAVE_KVM_IRQ_BYPASS
        bool
+
+config HAVE_KVM_VCPU_ASYNC_IOCTL
+       bool
diff --git a/virt/kvm/arm/arm.c b/virt/kvm/arm/arm.c
index 04ee7a327870..92b95ae9a2ca 100644
--- a/virt/kvm/arm/arm.c
+++ b/virt/kvm/arm/arm.c
@@ -384,17 +384,24 @@ static void vcpu_power_off(struct kvm_vcpu *vcpu)
 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
                                     struct kvm_mp_state *mp_state)
 {
+        vcpu_load(vcpu);
+
         if (vcpu->arch.power_off)
                 mp_state->mp_state = KVM_MP_STATE_STOPPED;
         else
                 mp_state->mp_state = KVM_MP_STATE_RUNNABLE;
 
+        vcpu_put(vcpu);
         return 0;
 }
 
 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
                                     struct kvm_mp_state *mp_state)
 {
+        int ret = 0;
+
+        vcpu_load(vcpu);
+
         switch (mp_state->mp_state) {
         case KVM_MP_STATE_RUNNABLE:
                 vcpu->arch.power_off = false;
@@ -403,10 +410,11 @@ int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
                 vcpu_power_off(vcpu);
                 break;
         default:
-                return -EINVAL;
+                ret = -EINVAL;
         }
 
-        return 0;
+        vcpu_put(vcpu);
+        return ret;
 }
 
 /**
@@ -630,21 +638,27 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
         if (unlikely(!kvm_vcpu_initialized(vcpu)))
                 return -ENOEXEC;
 
+        vcpu_load(vcpu);
+
         ret = kvm_vcpu_first_run_init(vcpu);
         if (ret)
-                return ret;
+                goto out;
 
         if (run->exit_reason == KVM_EXIT_MMIO) {
                 ret = kvm_handle_mmio_return(vcpu, vcpu->run);
                 if (ret)
-                        return ret;
-                if (kvm_arm_handle_step_debug(vcpu, vcpu->run))
-                        return 0;
+                        goto out;
+                if (kvm_arm_handle_step_debug(vcpu, vcpu->run)) {
+                        ret = 0;
+                        goto out;
+                }
 
         }
 
-        if (run->immediate_exit)
-                return -EINTR;
+        if (run->immediate_exit) {
+                ret = -EINTR;
+                goto out;
+        }
 
         kvm_sigset_activate(vcpu);
 
@@ -796,6 +810,8 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run)
 
         kvm_sigset_deactivate(vcpu);
 
+out:
+        vcpu_put(vcpu);
         return ret;
 }
 
@@ -1011,66 +1027,88 @@ long kvm_arch_vcpu_ioctl(struct file *filp,
         struct kvm_vcpu *vcpu = filp->private_data;
         void __user *argp = (void __user *)arg;
         struct kvm_device_attr attr;
+        long r;
+
+        vcpu_load(vcpu);
 
         switch (ioctl) {
         case KVM_ARM_VCPU_INIT: {
                 struct kvm_vcpu_init init;
 
+                r = -EFAULT;
                 if (copy_from_user(&init, argp, sizeof(init)))
-                        return -EFAULT;
+                        break;
 
-                return kvm_arch_vcpu_ioctl_vcpu_init(vcpu, &init);
+                r = kvm_arch_vcpu_ioctl_vcpu_init(vcpu, &init);
+                break;
         }
         case KVM_SET_ONE_REG:
         case KVM_GET_ONE_REG: {
                 struct kvm_one_reg reg;
 
+                r = -ENOEXEC;
                 if (unlikely(!kvm_vcpu_initialized(vcpu)))
-                        return -ENOEXEC;
+                        break;
 
+                r = -EFAULT;
                 if (copy_from_user(&reg, argp, sizeof(reg)))
-                        return -EFAULT;
+                        break;
+
                 if (ioctl == KVM_SET_ONE_REG)
-                        return kvm_arm_set_reg(vcpu, &reg);
+                        r = kvm_arm_set_reg(vcpu, &reg);
                 else
-                        return kvm_arm_get_reg(vcpu, &reg);
+                        r = kvm_arm_get_reg(vcpu, &reg);
+                break;
         }
         case KVM_GET_REG_LIST: {
                 struct kvm_reg_list __user *user_list = argp;
                 struct kvm_reg_list reg_list;
                 unsigned n;
 
+                r = -ENOEXEC;
                 if (unlikely(!kvm_vcpu_initialized(vcpu)))
-                        return -ENOEXEC;
+                        break;
 
+                r = -EFAULT;
                 if (copy_from_user(&reg_list, user_list, sizeof(reg_list)))
-                        return -EFAULT;
+                        break;
                 n = reg_list.n;
                 reg_list.n = kvm_arm_num_regs(vcpu);
                 if (copy_to_user(user_list, &reg_list, sizeof(reg_list)))
-                        return -EFAULT;
+                        break;
+                r = -E2BIG;
                 if (n < reg_list.n)
-                        return -E2BIG;
-                return kvm_arm_copy_reg_indices(vcpu, user_list->reg);
+                        break;
+                r = kvm_arm_copy_reg_indices(vcpu, user_list->reg);
+                break;
         }
         case KVM_SET_DEVICE_ATTR: {
+                r = -EFAULT;
                 if (copy_from_user(&attr, argp, sizeof(attr)))
-                        return -EFAULT;
-                return kvm_arm_vcpu_set_attr(vcpu, &attr);
+                        break;
+                r = kvm_arm_vcpu_set_attr(vcpu, &attr);
+                break;
         }
         case KVM_GET_DEVICE_ATTR: {
+                r = -EFAULT;
                 if (copy_from_user(&attr, argp, sizeof(attr)))
-                        return -EFAULT;
-                return kvm_arm_vcpu_get_attr(vcpu, &attr);
+                        break;
+                r = kvm_arm_vcpu_get_attr(vcpu, &attr);
+                break;
         }
         case KVM_HAS_DEVICE_ATTR: {
+                r = -EFAULT;
                 if (copy_from_user(&attr, argp, sizeof(attr)))
-                        return -EFAULT;
-                return kvm_arm_vcpu_has_attr(vcpu, &attr);
+                        break;
+                r = kvm_arm_vcpu_has_attr(vcpu, &attr);
+                break;
         }
         default:
-                return -EINVAL;
+                r = -EINVAL;
         }
+
+        vcpu_put(vcpu);
+        return r;
 }
 
 /**
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index 210bf820385a..b4414842b023 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -151,17 +151,12 @@ bool kvm_is_reserved_pfn(kvm_pfn_t pfn)
 /*
  * Switches to specified vcpu, until a matching vcpu_put()
  */
-int vcpu_load(struct kvm_vcpu *vcpu)
+void vcpu_load(struct kvm_vcpu *vcpu)
 {
-        int cpu;
-
-        if (mutex_lock_killable(&vcpu->mutex))
-                return -EINTR;
-        cpu = get_cpu();
+        int cpu = get_cpu();
         preempt_notifier_register(&vcpu->preempt_notifier);
         kvm_arch_vcpu_load(vcpu, cpu);
         put_cpu();
-        return 0;
 }
 EXPORT_SYMBOL_GPL(vcpu_load);
 
@@ -171,7 +166,6 @@ void vcpu_put(struct kvm_vcpu *vcpu)
         kvm_arch_vcpu_put(vcpu);
         preempt_notifier_unregister(&vcpu->preempt_notifier);
         preempt_enable();
-        mutex_unlock(&vcpu->mutex);
 }
 EXPORT_SYMBOL_GPL(vcpu_put);
 
@@ -2550,19 +2544,16 @@ static long kvm_vcpu_ioctl(struct file *filp,
         if (unlikely(_IOC_TYPE(ioctl) != KVMIO))
                 return -EINVAL;
 
-#if defined(CONFIG_S390) || defined(CONFIG_PPC) || defined(CONFIG_MIPS)
         /*
-         * Special cases: vcpu ioctls that are asynchronous to vcpu execution,
-         * so vcpu_load() would break it.
+         * Some architectures have vcpu ioctls that are asynchronous to vcpu
+         * execution; mutex_lock() would break them.
          */
-        if (ioctl == KVM_S390_INTERRUPT || ioctl == KVM_S390_IRQ || ioctl == KVM_INTERRUPT)
-                return kvm_arch_vcpu_ioctl(filp, ioctl, arg);
-#endif
-
-
-        r = vcpu_load(vcpu);
-        if (r)
+        r = kvm_arch_vcpu_async_ioctl(filp, ioctl, arg);
+        if (r != -ENOIOCTLCMD)
                 return r;
+
+        if (mutex_lock_killable(&vcpu->mutex))
+                return -EINTR;
         switch (ioctl) {
         case KVM_RUN: {
                 struct pid *oldpid;
@@ -2734,7 +2725,7 @@ out_free1:
                 r = kvm_arch_vcpu_ioctl(filp, ioctl, arg);
         }
 out:
-        vcpu_put(vcpu);
+        mutex_unlock(&vcpu->mutex);
         kfree(fpu);
         kfree(kvm_sregs);
         return r;
@@ -3186,21 +3177,18 @@ static int kvm_dev_ioctl_create_vm(unsigned long type)
                 return PTR_ERR(kvm);
 #ifdef CONFIG_KVM_MMIO
         r = kvm_coalesced_mmio_init(kvm);
-        if (r < 0) {
-                kvm_put_kvm(kvm);
-                return r;
-        }
+        if (r < 0)
+                goto put_kvm;
 #endif
         r = get_unused_fd_flags(O_CLOEXEC);
-        if (r < 0) {
-                kvm_put_kvm(kvm);
-                return r;
-        }
+        if (r < 0)
+                goto put_kvm;
+
         file = anon_inode_getfile("kvm-vm", &kvm_vm_fops, kvm, O_RDWR);
         if (IS_ERR(file)) {
                 put_unused_fd(r);
-                kvm_put_kvm(kvm);
-                return PTR_ERR(file);
+                r = PTR_ERR(file);
+                goto put_kvm;
         }
 
         /*
@@ -3218,6 +3206,10 @@ static int kvm_dev_ioctl_create_vm(unsigned long type)
 
         fd_install(r, file);
         return r;
+
+put_kvm:
+        kvm_put_kvm(kvm);
+        return r;
 }
 
 static long kvm_dev_ioctl(struct file *filp,