KVM: x86 emulator: add get_cached_segment_base() callback to x86_emulate_ops

[linux-2.6-block.git] / arch / x86 / kvm / x86.c

diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 05d571f6f19615cab8a90dec413e0a39537e914a..9a469df6011ca63825135d3abd9c1248ea79f375 100644 (file)
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -1562,7 +1562,7 @@ static int msr_io(struct kvm_vcpu *vcpu, struct kvm_msrs __user *user_msrs,
 
        r = -ENOMEM;
        size = sizeof(struct kvm_msr_entry) * msrs.nmsrs;
-       entries = vmalloc(size);
+       entries = kmalloc(size, GFP_KERNEL);
        if (!entries)
                goto out;
 
@@ -1581,7 +1581,7 @@ static int msr_io(struct kvm_vcpu *vcpu, struct kvm_msrs __user *user_msrs,
        r = n;
 
 out_free:
-       vfree(entries);
+       kfree(entries);
 out:
        return r;
 }
@@ -1731,8 +1731,8 @@ void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
 
 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
 {
-       kvm_put_guest_fpu(vcpu);
        kvm_x86_ops->vcpu_put(vcpu);
+       kvm_put_guest_fpu(vcpu);
 }
 
 static int is_efer_nx(void)
@@ -2797,7 +2797,6 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
        struct kvm_memory_slot *memslot;
        unsigned long n;
        unsigned long is_dirty = 0;
-       unsigned long *dirty_bitmap = NULL;
 
        mutex_lock(&kvm->slots_lock);
 
@@ -2812,27 +2811,30 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
 
        n = kvm_dirty_bitmap_bytes(memslot);
 
-       r = -ENOMEM;
-       dirty_bitmap = vmalloc(n);
-       if (!dirty_bitmap)
-               goto out;
-       memset(dirty_bitmap, 0, n);
-
        for (i = 0; !is_dirty && i < n/sizeof(long); i++)
                is_dirty = memslot->dirty_bitmap[i];
 
        /* If nothing is dirty, don't bother messing with page tables. */
        if (is_dirty) {
                struct kvm_memslots *slots, *old_slots;
+               unsigned long *dirty_bitmap;
 
                spin_lock(&kvm->mmu_lock);
                kvm_mmu_slot_remove_write_access(kvm, log->slot);
                spin_unlock(&kvm->mmu_lock);
 
-               slots = kzalloc(sizeof(struct kvm_memslots), GFP_KERNEL);
-               if (!slots)
-                       goto out_free;
+               r = -ENOMEM;
+               dirty_bitmap = vmalloc(n);
+               if (!dirty_bitmap)
+                       goto out;
+               memset(dirty_bitmap, 0, n);
 
+               r = -ENOMEM;
+               slots = kzalloc(sizeof(struct kvm_memslots), GFP_KERNEL);
+               if (!slots) {
+                       vfree(dirty_bitmap);
+                       goto out;
+               }
                memcpy(slots, kvm->memslots, sizeof(struct kvm_memslots));
                slots->memslots[log->slot].dirty_bitmap = dirty_bitmap;
 
@@ -2841,13 +2843,20 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
                synchronize_srcu_expedited(&kvm->srcu);
                dirty_bitmap = old_slots->memslots[log->slot].dirty_bitmap;
                kfree(old_slots);
+
+               r = -EFAULT;
+               if (copy_to_user(log->dirty_bitmap, dirty_bitmap, n)) {
+                       vfree(dirty_bitmap);
+                       goto out;
+               }
+               vfree(dirty_bitmap);
+       } else {
+               r = -EFAULT;
+               if (clear_user(log->dirty_bitmap, n))
+                       goto out;
        }
 
        r = 0;
-       if (copy_to_user(log->dirty_bitmap, dirty_bitmap, n))
-               r = -EFAULT;
-out_free:
-       vfree(dirty_bitmap);
 out:
        mutex_unlock(&kvm->slots_lock);
        return r;
@@ -3611,16 +3620,14 @@ int emulate_clts(struct kvm_vcpu *vcpu)
        return X86EMUL_CONTINUE;
 }
 
-int emulator_get_dr(struct x86_emulate_ctxt *ctxt, int dr, unsigned long *dest)
+int emulator_get_dr(int dr, unsigned long *dest, struct kvm_vcpu *vcpu)
 {
-       return kvm_get_dr(ctxt->vcpu, dr, dest);
+       return kvm_get_dr(vcpu, dr, dest);
 }
 
-int emulator_set_dr(struct x86_emulate_ctxt *ctxt, int dr, unsigned long value)
+int emulator_set_dr(int dr, unsigned long value, struct kvm_vcpu *vcpu)
 {
-       unsigned long mask = (ctxt->mode == X86EMUL_MODE_PROT64) ? ~0ULL : ~0U;
-
-       return kvm_set_dr(ctxt->vcpu, dr, value & mask);
+       return kvm_set_dr(vcpu, dr, value);
 }
 
 void kvm_report_emulation_failure(struct kvm_vcpu *vcpu, const char *context)
@@ -3707,6 +3714,12 @@ static void emulator_get_gdt(struct desc_ptr *dt, struct kvm_vcpu *vcpu)
        kvm_x86_ops->get_gdt(vcpu, dt);
 }
 
+static unsigned long emulator_get_cached_segment_base(int seg,
+                                                     struct kvm_vcpu *vcpu)
+{
+       return get_segment_base(vcpu, seg);
+}
+
 static bool emulator_get_cached_descriptor(struct desc_struct *desc, int seg,
                                           struct kvm_vcpu *vcpu)
 {
@@ -3797,11 +3810,16 @@ static struct x86_emulate_ops emulate_ops = {
        .set_cached_descriptor = emulator_set_cached_descriptor,
        .get_segment_selector = emulator_get_segment_selector,
        .set_segment_selector = emulator_set_segment_selector,
+       .get_cached_segment_base = emulator_get_cached_segment_base,
        .get_gdt             = emulator_get_gdt,
        .get_cr              = emulator_get_cr,
        .set_cr              = emulator_set_cr,
        .cpl                 = emulator_get_cpl,
        .set_rflags          = emulator_set_rflags,
+       .get_dr              = emulator_get_dr,
+       .set_dr              = emulator_set_dr,
+       .set_msr             = kvm_set_msr,
+       .get_msr             = kvm_get_msr,
 };
 
 static void cache_all_regs(struct kvm_vcpu *vcpu)