{
        int i, idx;
 
-       vcpu_load(vcpu);
-
        idx = srcu_read_lock(&vcpu->kvm->srcu);
        for (i = 0; i < msrs->nmsrs; ++i)
                if (do_msr(vcpu, entries[i].index, &entries[i].data))
                        break;
        srcu_read_unlock(&vcpu->kvm->srcu, idx);
 
-       vcpu_put(vcpu);
-
        return i;
 }
 
        if (copy_from_user(cpuid_entries, entries,
                           cpuid->nent * sizeof(struct kvm_cpuid_entry)))
                goto out_free;
-       vcpu_load(vcpu);
        for (i = 0; i < cpuid->nent; i++) {
                vcpu->arch.cpuid_entries[i].function = cpuid_entries[i].function;
                vcpu->arch.cpuid_entries[i].eax = cpuid_entries[i].eax;
        r = 0;
        kvm_apic_set_version(vcpu);
        kvm_x86_ops->cpuid_update(vcpu);
-       vcpu_put(vcpu);
 
 out_free:
        vfree(cpuid_entries);
        if (copy_from_user(&vcpu->arch.cpuid_entries, entries,
                           cpuid->nent * sizeof(struct kvm_cpuid_entry2)))
                goto out;
-       vcpu_load(vcpu);
        vcpu->arch.cpuid_nent = cpuid->nent;
        kvm_apic_set_version(vcpu);
        kvm_x86_ops->cpuid_update(vcpu);
-       vcpu_put(vcpu);
        return 0;
 
 out:
 {
        int r;
 
-       vcpu_load(vcpu);
        r = -E2BIG;
        if (cpuid->nent < vcpu->arch.cpuid_nent)
                goto out;
 
 out:
        cpuid->nent = vcpu->arch.cpuid_nent;
-       vcpu_put(vcpu);
        return r;
 }
 
 static int kvm_vcpu_ioctl_get_lapic(struct kvm_vcpu *vcpu,
                                    struct kvm_lapic_state *s)
 {
-       vcpu_load(vcpu);
        memcpy(s->regs, vcpu->arch.apic->regs, sizeof *s);
-       vcpu_put(vcpu);
 
        return 0;
 }
 static int kvm_vcpu_ioctl_set_lapic(struct kvm_vcpu *vcpu,
                                    struct kvm_lapic_state *s)
 {
-       vcpu_load(vcpu);
        memcpy(vcpu->arch.apic->regs, s->regs, sizeof *s);
        kvm_apic_post_state_restore(vcpu);
        update_cr8_intercept(vcpu);
-       vcpu_put(vcpu);
 
        return 0;
 }
                return -EINVAL;
        if (irqchip_in_kernel(vcpu->kvm))
                return -ENXIO;
-       vcpu_load(vcpu);
 
        kvm_queue_interrupt(vcpu, irq->irq, false);
 
-       vcpu_put(vcpu);
-
        return 0;
 }
 
 static int kvm_vcpu_ioctl_nmi(struct kvm_vcpu *vcpu)
 {
-       vcpu_load(vcpu);
        kvm_inject_nmi(vcpu);
-       vcpu_put(vcpu);
 
        return 0;
 }
        int r;
        unsigned bank_num = mcg_cap & 0xff, bank;
 
-       vcpu_load(vcpu);
        r = -EINVAL;
        if (!bank_num || bank_num >= KVM_MAX_MCE_BANKS)
                goto out;
        for (bank = 0; bank < bank_num; bank++)
                vcpu->arch.mce_banks[bank*4] = ~(u64)0;
 out:
-       vcpu_put(vcpu);
        return r;
 }
 
 static void kvm_vcpu_ioctl_x86_get_vcpu_events(struct kvm_vcpu *vcpu,
                                               struct kvm_vcpu_events *events)
 {
-       vcpu_load(vcpu);
-
        events->exception.injected =
                vcpu->arch.exception.pending &&
                !kvm_exception_is_soft(vcpu->arch.exception.nr);
        events->flags = (KVM_VCPUEVENT_VALID_NMI_PENDING
                         | KVM_VCPUEVENT_VALID_SIPI_VECTOR
                         | KVM_VCPUEVENT_VALID_SHADOW);
-
-       vcpu_put(vcpu);
 }
 
 static int kvm_vcpu_ioctl_x86_set_vcpu_events(struct kvm_vcpu *vcpu,
                              | KVM_VCPUEVENT_VALID_SHADOW))
                return -EINVAL;
 
-       vcpu_load(vcpu);
-
        vcpu->arch.exception.pending = events->exception.injected;
        vcpu->arch.exception.nr = events->exception.nr;
        vcpu->arch.exception.has_error_code = events->exception.has_error_code;
        if (events->flags & KVM_VCPUEVENT_VALID_SIPI_VECTOR)
                vcpu->arch.sipi_vector = events->sipi_vector;
 
-       vcpu_put(vcpu);
-
        return 0;
 }
 
 static void kvm_vcpu_ioctl_x86_get_debugregs(struct kvm_vcpu *vcpu,
                                             struct kvm_debugregs *dbgregs)
 {
-       vcpu_load(vcpu);
-
        memcpy(dbgregs->db, vcpu->arch.db, sizeof(vcpu->arch.db));
        dbgregs->dr6 = vcpu->arch.dr6;
        dbgregs->dr7 = vcpu->arch.dr7;
        dbgregs->flags = 0;
-
-       vcpu_put(vcpu);
 }
 
 static int kvm_vcpu_ioctl_x86_set_debugregs(struct kvm_vcpu *vcpu,
        if (dbgregs->flags)
                return -EINVAL;
 
-       vcpu_load(vcpu);
-
        memcpy(vcpu->arch.db, dbgregs->db, sizeof(vcpu->arch.db));
        vcpu->arch.dr6 = dbgregs->dr6;
        vcpu->arch.dr7 = dbgregs->dr7;
 
-       vcpu_put(vcpu);
-
        return 0;
 }
 
        int r;
        struct kvm_lapic_state *lapic = NULL;
 
+       vcpu_load(vcpu);
        switch (ioctl) {
        case KVM_GET_LAPIC: {
                r = -EINVAL;
                r = -EFAULT;
                if (copy_from_user(&mce, argp, sizeof mce))
                        goto out;
-               vcpu_load(vcpu);
                r = kvm_vcpu_ioctl_x86_set_mce(vcpu, &mce);
-               vcpu_put(vcpu);
                break;
        }
        case KVM_GET_VCPU_EVENTS: {
                r = -EINVAL;
        }
 out:
+       vcpu_put(vcpu);
        kfree(lapic);
        return r;
 }