KVM: Make local routines static

[deliverable/linux.git] / virt / kvm / kvm_main.c

diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index adc68feb5c5a338080ac8ca2385f73577ac6c29a..9ad98769dd75dc471425f06aff6a47cdf3ca18ce 100644 (file)
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -244,6 +244,7 @@ int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id)
 
        kvm_vcpu_set_in_spin_loop(vcpu, false);
        kvm_vcpu_set_dy_eligible(vcpu, false);
+       vcpu->preempted = false;
 
        r = kvm_arch_vcpu_init(vcpu);
        if (r < 0)
@@ -718,24 +719,6 @@ static struct kvm_memslots *install_new_memslots(struct kvm *kvm,
        return old_memslots; 
 }
 
-/*
- * KVM_SET_USER_MEMORY_REGION ioctl allows the following operations:
- * - create a new memory slot
- * - delete an existing memory slot
- * - modify an existing memory slot
- *   -- move it in the guest physical memory space
- *   -- just change its flags
- *
- * Since flags can be changed by some of these operations, the following
- * differentiation is the best we can do for __kvm_set_memory_region():
- */
-enum kvm_mr_change {
-       KVM_MR_CREATE,
-       KVM_MR_DELETE,
-       KVM_MR_MOVE,
-       KVM_MR_FLAGS_ONLY,
-};
-
 /*
  * Allocate some memory and give it an address in the guest physical address
  * space.
@@ -745,8 +728,7 @@ enum kvm_mr_change {
  * Must be called holding mmap_sem for write.
  */
 int __kvm_set_memory_region(struct kvm *kvm,
-                           struct kvm_userspace_memory_region *mem,
-                           bool user_alloc)
+                           struct kvm_userspace_memory_region *mem)
 {
        int r;
        gfn_t base_gfn;
@@ -767,7 +749,7 @@ int __kvm_set_memory_region(struct kvm *kvm,
        if (mem->guest_phys_addr & (PAGE_SIZE - 1))
                goto out;
        /* We can read the guest memory with __xxx_user() later on. */
-       if (user_alloc &&
+       if ((mem->slot < KVM_USER_MEM_SLOTS) &&
            ((mem->userspace_addr & (PAGE_SIZE - 1)) ||
             !access_ok(VERIFY_WRITE,
                        (void __user *)(unsigned long)mem->userspace_addr,
@@ -875,7 +857,7 @@ int __kvm_set_memory_region(struct kvm *kvm,
                slots = old_memslots;
        }
 
-       r = kvm_arch_prepare_memory_region(kvm, &new, old, mem, user_alloc);
+       r = kvm_arch_prepare_memory_region(kvm, &new, mem, change);
        if (r)
                goto out_slots;
 
@@ -915,7 +897,7 @@ int __kvm_set_memory_region(struct kvm *kvm,
 
        old_memslots = install_new_memslots(kvm, slots, &new);
 
-       kvm_arch_commit_memory_region(kvm, mem, old, user_alloc);
+       kvm_arch_commit_memory_region(kvm, mem, &old, change);
 
        kvm_free_physmem_slot(&old, &new);
        kfree(old_memslots);
@@ -932,26 +914,23 @@ out:
 EXPORT_SYMBOL_GPL(__kvm_set_memory_region);
 
 int kvm_set_memory_region(struct kvm *kvm,
-                         struct kvm_userspace_memory_region *mem,
-                         bool user_alloc)
+                         struct kvm_userspace_memory_region *mem)
 {
        int r;
 
        mutex_lock(&kvm->slots_lock);
-       r = __kvm_set_memory_region(kvm, mem, user_alloc);
+       r = __kvm_set_memory_region(kvm, mem);
        mutex_unlock(&kvm->slots_lock);
        return r;
 }
 EXPORT_SYMBOL_GPL(kvm_set_memory_region);
 
 int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
-                                  struct
-                                  kvm_userspace_memory_region *mem,
-                                  bool user_alloc)
+                                  struct kvm_userspace_memory_region *mem)
 {
        if (mem->slot >= KVM_USER_MEM_SLOTS)
                return -EINVAL;
-       return kvm_set_memory_region(kvm, mem, user_alloc);
+       return kvm_set_memory_region(kvm, mem);
 }
 
 int kvm_get_dirty_log(struct kvm *kvm,
@@ -1099,7 +1078,7 @@ static int kvm_read_hva_atomic(void *data, void __user *hva, int len)
        return __copy_from_user_inatomic(data, hva, len);
 }
 
-int get_user_page_nowait(struct task_struct *tsk, struct mm_struct *mm,
+static int get_user_page_nowait(struct task_struct *tsk, struct mm_struct *mm,
        unsigned long start, int write, struct page **page)
 {
        int flags = FOLL_TOUCH | FOLL_NOWAIT | FOLL_HWPOISON | FOLL_GET;
@@ -1789,6 +1768,8 @@ void kvm_vcpu_on_spin(struct kvm_vcpu *me)
                                continue;
                        } else if (pass && i > last_boosted_vcpu)
                                break;
+                       if (!ACCESS_ONCE(vcpu->preempted))
+                               continue;
                        if (vcpu == me)
                                continue;
                        if (waitqueue_active(&vcpu->wq))
@@ -2198,7 +2179,7 @@ static long kvm_vm_ioctl(struct file *filp,
                                                sizeof kvm_userspace_mem))
                        goto out;
 
-               r = kvm_vm_ioctl_set_memory_region(kvm, &kvm_userspace_mem, true);
+               r = kvm_vm_ioctl_set_memory_region(kvm, &kvm_userspace_mem);
                break;
        }
        case KVM_GET_DIRTY_LOG: {
@@ -2631,7 +2612,7 @@ static void kvm_io_bus_destroy(struct kvm_io_bus *bus)
        kfree(bus);
 }
 
-int kvm_io_bus_sort_cmp(const void *p1, const void *p2)
+static int kvm_io_bus_sort_cmp(const void *p1, const void *p2)
 {
        const struct kvm_io_range *r1 = p1;
        const struct kvm_io_range *r2 = p2;
@@ -2643,7 +2624,7 @@ int kvm_io_bus_sort_cmp(const void *p1, const void *p2)
        return 0;
 }
 
-int kvm_io_bus_insert_dev(struct kvm_io_bus *bus, struct kvm_io_device *dev,
+static int kvm_io_bus_insert_dev(struct kvm_io_bus *bus, struct kvm_io_device *dev,
                          gpa_t addr, int len)
 {
        bus->range[bus->dev_count++] = (struct kvm_io_range) {
@@ -2658,7 +2639,7 @@ int kvm_io_bus_insert_dev(struct kvm_io_bus *bus, struct kvm_io_device *dev,
        return 0;
 }
 
-int kvm_io_bus_get_first_dev(struct kvm_io_bus *bus,
+static int kvm_io_bus_get_first_dev(struct kvm_io_bus *bus,
                             gpa_t addr, int len)
 {
        struct kvm_io_range *range, key;
@@ -2902,6 +2883,8 @@ struct kvm_vcpu *preempt_notifier_to_vcpu(struct preempt_notifier *pn)
 static void kvm_sched_in(struct preempt_notifier *pn, int cpu)
 {
        struct kvm_vcpu *vcpu = preempt_notifier_to_vcpu(pn);
+       if (vcpu->preempted)
+               vcpu->preempted = false;
 
        kvm_arch_vcpu_load(vcpu, cpu);
 }
@@ -2911,6 +2894,8 @@ static void kvm_sched_out(struct preempt_notifier *pn,
 {
        struct kvm_vcpu *vcpu = preempt_notifier_to_vcpu(pn);
 
+       if (current->state == TASK_RUNNING)
+               vcpu->preempted = true;
        kvm_arch_vcpu_put(vcpu);
 }
 
@@ -2920,6 +2905,9 @@ int kvm_init(void *opaque, unsigned vcpu_size, unsigned vcpu_align,
        int r;
        int cpu;
 
+       r = kvm_irqfd_init();
+       if (r)
+               goto out_irqfd;
        r = kvm_arch_init(opaque);
        if (r)
                goto out_fail;
@@ -3000,6 +2988,8 @@ out_free_0a:
 out_free_0:
        kvm_arch_exit();
 out_fail:
+       kvm_irqfd_exit();
+out_irqfd:
        return r;
 }
 EXPORT_SYMBOL_GPL(kvm_init);
@@ -3016,6 +3006,7 @@ void kvm_exit(void)
        on_each_cpu(hardware_disable_nolock, NULL, 1);
        kvm_arch_hardware_unsetup();
        kvm_arch_exit();
+       kvm_irqfd_exit();
        free_cpumask_var(cpus_hardware_enabled);
 }
 EXPORT_SYMBOL_GPL(kvm_exit);