source: src/linux/universal/linux-3.18/virt/kvm/kvm_main.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 5 weeks ago

update

File size: 76.4 KB
Line 
1/*
2 * Kernel-based Virtual Machine driver for Linux
3 *
4 * This module enables machines with Intel VT-x extensions to run virtual
5 * machines without emulation or binary translation.
6 *
7 * Copyright (C) 2006 Qumranet, Inc.
8 * Copyright 2010 Red Hat, Inc. and/or its affiliates.
9 *
10 * Authors:
11 *   Avi Kivity   <avi@qumranet.com>
12 *   Yaniv Kamay  <yaniv@qumranet.com>
13 *
14 * This work is licensed under the terms of the GNU GPL, version 2.  See
15 * the COPYING file in the top-level directory.
16 *
17 */
18
19#include "iodev.h"
20
21#include <linux/kvm_host.h>
22#include <linux/kvm.h>
23#include <linux/module.h>
24#include <linux/errno.h>
25#include <linux/percpu.h>
26#include <linux/mm.h>
27#include <linux/miscdevice.h>
28#include <linux/vmalloc.h>
29#include <linux/reboot.h>
30#include <linux/debugfs.h>
31#include <linux/highmem.h>
32#include <linux/file.h>
33#include <linux/syscore_ops.h>
34#include <linux/cpu.h>
35#include <linux/sched.h>
36#include <linux/cpumask.h>
37#include <linux/smp.h>
38#include <linux/anon_inodes.h>
39#include <linux/profile.h>
40#include <linux/kvm_para.h>
41#include <linux/pagemap.h>
42#include <linux/mman.h>
43#include <linux/swap.h>
44#include <linux/bitops.h>
45#include <linux/spinlock.h>
46#include <linux/compat.h>
47#include <linux/srcu.h>
48#include <linux/hugetlb.h>
49#include <linux/slab.h>
50#include <linux/sort.h>
51#include <linux/bsearch.h>
52
53#include <asm/processor.h>
54#include <asm/io.h>
55#include <asm/ioctl.h>
56#include <asm/uaccess.h>
57#include <asm/pgtable.h>
58
59#include "coalesced_mmio.h"
60#include "async_pf.h"
61#include "vfio.h"
62
63#define CREATE_TRACE_POINTS
64#include <trace/events/kvm.h>
65
66MODULE_AUTHOR("Qumranet");
67MODULE_LICENSE("GPL");
68
69/*
70 * Ordering of locks:
71 *
72 *              kvm->lock --> kvm->slots_lock --> kvm->irq_lock
73 */
74
75DEFINE_SPINLOCK(kvm_lock);
76static DEFINE_RAW_SPINLOCK(kvm_count_lock);
77LIST_HEAD(vm_list);
78
79static cpumask_var_t cpus_hardware_enabled;
80static int kvm_usage_count = 0;
81static atomic_t hardware_enable_failed;
82
83struct kmem_cache *kvm_vcpu_cache;
84EXPORT_SYMBOL_GPL(kvm_vcpu_cache);
85
86static __read_mostly struct preempt_ops kvm_preempt_ops;
87
88struct dentry *kvm_debugfs_dir;
89
90static long kvm_vcpu_ioctl(struct file *file, unsigned int ioctl,
91                           unsigned long arg);
92#ifdef CONFIG_COMPAT
93static long kvm_vcpu_compat_ioctl(struct file *file, unsigned int ioctl,
94                                  unsigned long arg);
95#endif
96static int hardware_enable_all(void);
97static void hardware_disable_all(void);
98
99static void kvm_io_bus_destroy(struct kvm_io_bus *bus);
100
101static void kvm_release_pfn_dirty(pfn_t pfn);
102static void mark_page_dirty_in_slot(struct kvm *kvm,
103                                    struct kvm_memory_slot *memslot, gfn_t gfn);
104
105__visible bool kvm_rebooting;
106EXPORT_SYMBOL_GPL(kvm_rebooting);
107
108static bool largepages_enabled = true;
109
110bool kvm_is_reserved_pfn(pfn_t pfn)
111{
112        if (pfn_valid(pfn))
113                return PageReserved(pfn_to_page(pfn));
114
115        return true;
116}
117
118/*
119 * Switches to specified vcpu, until a matching vcpu_put()
120 */
121int vcpu_load(struct kvm_vcpu *vcpu)
122{
123        int cpu;
124
125        if (mutex_lock_killable(&vcpu->mutex))
126                return -EINTR;
127        if (unlikely(vcpu->pid != current->pids[PIDTYPE_PID].pid)) {
128                /* The thread running this VCPU changed. */
129                struct pid *oldpid = vcpu->pid;
130                struct pid *newpid = get_task_pid(current, PIDTYPE_PID);
131                rcu_assign_pointer(vcpu->pid, newpid);
132                if (oldpid)
133                        synchronize_rcu();
134                put_pid(oldpid);
135        }
136        cpu = get_cpu();
137        preempt_notifier_register(&vcpu->preempt_notifier);
138        kvm_arch_vcpu_load(vcpu, cpu);
139        put_cpu();
140        return 0;
141}
142EXPORT_SYMBOL_GPL(vcpu_load);
143
144void vcpu_put(struct kvm_vcpu *vcpu)
145{
146        preempt_disable();
147        kvm_arch_vcpu_put(vcpu);
148        preempt_notifier_unregister(&vcpu->preempt_notifier);
149        preempt_enable();
150        mutex_unlock(&vcpu->mutex);
151}
152EXPORT_SYMBOL_GPL(vcpu_put);
153
154static void ack_flush(void *_completed)
155{
156}
157
158bool kvm_make_all_cpus_request(struct kvm *kvm, unsigned int req)
159{
160        int i, cpu, me;
161        cpumask_var_t cpus;
162        bool called = true;
163        struct kvm_vcpu *vcpu;
164
165        zalloc_cpumask_var(&cpus, GFP_ATOMIC);
166
167        me = get_cpu();
168        kvm_for_each_vcpu(i, vcpu, kvm) {
169                kvm_make_request(req, vcpu);
170                cpu = vcpu->cpu;
171
172                /* Set ->requests bit before we read ->mode */
173                smp_mb();
174
175                if (cpus != NULL && cpu != -1 && cpu != me &&
176                      kvm_vcpu_exiting_guest_mode(vcpu) != OUTSIDE_GUEST_MODE)
177                        cpumask_set_cpu(cpu, cpus);
178        }
179        if (unlikely(cpus == NULL))
180                smp_call_function_many(cpu_online_mask, ack_flush, NULL, 1);
181        else if (!cpumask_empty(cpus))
182                smp_call_function_many(cpus, ack_flush, NULL, 1);
183        else
184                called = false;
185        put_cpu();
186        free_cpumask_var(cpus);
187        return called;
188}
189
190void kvm_flush_remote_tlbs(struct kvm *kvm)
191{
192        long dirty_count = kvm->tlbs_dirty;
193
194        smp_mb();
195        if (kvm_make_all_cpus_request(kvm, KVM_REQ_TLB_FLUSH))
196                ++kvm->stat.remote_tlb_flush;
197        cmpxchg(&kvm->tlbs_dirty, dirty_count, 0);
198}
199EXPORT_SYMBOL_GPL(kvm_flush_remote_tlbs);
200
201void kvm_reload_remote_mmus(struct kvm *kvm)
202{
203        kvm_make_all_cpus_request(kvm, KVM_REQ_MMU_RELOAD);
204}
205
206void kvm_make_mclock_inprogress_request(struct kvm *kvm)
207{
208        kvm_make_all_cpus_request(kvm, KVM_REQ_MCLOCK_INPROGRESS);
209}
210
211void kvm_make_scan_ioapic_request(struct kvm *kvm)
212{
213        kvm_make_all_cpus_request(kvm, KVM_REQ_SCAN_IOAPIC);
214}
215
216int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id)
217{
218        struct page *page;
219        int r;
220
221        mutex_init(&vcpu->mutex);
222        vcpu->cpu = -1;
223        vcpu->kvm = kvm;
224        vcpu->vcpu_id = id;
225        vcpu->pid = NULL;
226        init_waitqueue_head(&vcpu->wq);
227        kvm_async_pf_vcpu_init(vcpu);
228
229        page = alloc_page(GFP_KERNEL | __GFP_ZERO);
230        if (!page) {
231                r = -ENOMEM;
232                goto fail;
233        }
234        vcpu->run = page_address(page);
235
236        kvm_vcpu_set_in_spin_loop(vcpu, false);
237        kvm_vcpu_set_dy_eligible(vcpu, false);
238        vcpu->preempted = false;
239
240        r = kvm_arch_vcpu_init(vcpu);
241        if (r < 0)
242                goto fail_free_run;
243        return 0;
244
245fail_free_run:
246        free_page((unsigned long)vcpu->run);
247fail:
248        return r;
249}
250EXPORT_SYMBOL_GPL(kvm_vcpu_init);
251
252void kvm_vcpu_uninit(struct kvm_vcpu *vcpu)
253{
254        put_pid(vcpu->pid);
255        kvm_arch_vcpu_uninit(vcpu);
256        free_page((unsigned long)vcpu->run);
257}
258EXPORT_SYMBOL_GPL(kvm_vcpu_uninit);
259
260#if defined(CONFIG_MMU_NOTIFIER) && defined(KVM_ARCH_WANT_MMU_NOTIFIER)
261static inline struct kvm *mmu_notifier_to_kvm(struct mmu_notifier *mn)
262{
263        return container_of(mn, struct kvm, mmu_notifier);
264}
265
266static void kvm_mmu_notifier_invalidate_page(struct mmu_notifier *mn,
267                                             struct mm_struct *mm,
268                                             unsigned long address)
269{
270        struct kvm *kvm = mmu_notifier_to_kvm(mn);
271        int need_tlb_flush, idx;
272
273        /*
274         * When ->invalidate_page runs, the linux pte has been zapped
275         * already but the page is still allocated until
276         * ->invalidate_page returns. So if we increase the sequence
277         * here the kvm page fault will notice if the spte can't be
278         * established because the page is going to be freed. If
279         * instead the kvm page fault establishes the spte before
280         * ->invalidate_page runs, kvm_unmap_hva will release it
281         * before returning.
282         *
283         * The sequence increase only need to be seen at spin_unlock
284         * time, and not at spin_lock time.
285         *
286         * Increasing the sequence after the spin_unlock would be
287         * unsafe because the kvm page fault could then establish the
288         * pte after kvm_unmap_hva returned, without noticing the page
289         * is going to be freed.
290         */
291        idx = srcu_read_lock(&kvm->srcu);
292        spin_lock(&kvm->mmu_lock);
293
294        kvm->mmu_notifier_seq++;
295        need_tlb_flush = kvm_unmap_hva(kvm, address) | kvm->tlbs_dirty;
296        /* we've to flush the tlb before the pages can be freed */
297        if (need_tlb_flush)
298                kvm_flush_remote_tlbs(kvm);
299
300        spin_unlock(&kvm->mmu_lock);
301
302        kvm_arch_mmu_notifier_invalidate_page(kvm, address);
303
304        srcu_read_unlock(&kvm->srcu, idx);
305}
306
307static void kvm_mmu_notifier_change_pte(struct mmu_notifier *mn,
308                                        struct mm_struct *mm,
309                                        unsigned long address,
310                                        pte_t pte)
311{
312        struct kvm *kvm = mmu_notifier_to_kvm(mn);
313        int idx;
314
315        idx = srcu_read_lock(&kvm->srcu);
316        spin_lock(&kvm->mmu_lock);
317        kvm->mmu_notifier_seq++;
318        kvm_set_spte_hva(kvm, address, pte);
319        spin_unlock(&kvm->mmu_lock);
320        srcu_read_unlock(&kvm->srcu, idx);
321}
322
323static void kvm_mmu_notifier_invalidate_range_start(struct mmu_notifier *mn,
324                                                    struct mm_struct *mm,
325                                                    unsigned long start,
326                                                    unsigned long end)
327{
328        struct kvm *kvm = mmu_notifier_to_kvm(mn);
329        int need_tlb_flush = 0, idx;
330
331        idx = srcu_read_lock(&kvm->srcu);
332        spin_lock(&kvm->mmu_lock);
333        /*
334         * The count increase must become visible at unlock time as no
335         * spte can be established without taking the mmu_lock and
336         * count is also read inside the mmu_lock critical section.
337         */
338        kvm->mmu_notifier_count++;
339        need_tlb_flush = kvm_unmap_hva_range(kvm, start, end);
340        need_tlb_flush |= kvm->tlbs_dirty;
341        /* we've to flush the tlb before the pages can be freed */
342        if (need_tlb_flush)
343                kvm_flush_remote_tlbs(kvm);
344
345        spin_unlock(&kvm->mmu_lock);
346        srcu_read_unlock(&kvm->srcu, idx);
347}
348
349static void kvm_mmu_notifier_invalidate_range_end(struct mmu_notifier *mn,
350                                                  struct mm_struct *mm,
351                                                  unsigned long start,
352                                                  unsigned long end)
353{
354        struct kvm *kvm = mmu_notifier_to_kvm(mn);
355
356        spin_lock(&kvm->mmu_lock);
357        /*
358         * This sequence increase will notify the kvm page fault that
359         * the page that is going to be mapped in the spte could have
360         * been freed.
361         */
362        kvm->mmu_notifier_seq++;
363        smp_wmb();
364        /*
365         * The above sequence increase must be visible before the
366         * below count decrease, which is ensured by the smp_wmb above
367         * in conjunction with the smp_rmb in mmu_notifier_retry().
368         */
369        kvm->mmu_notifier_count--;
370        spin_unlock(&kvm->mmu_lock);
371
372        BUG_ON(kvm->mmu_notifier_count < 0);
373}
374
375static int kvm_mmu_notifier_clear_flush_young(struct mmu_notifier *mn,
376                                              struct mm_struct *mm,
377                                              unsigned long start,
378                                              unsigned long end)
379{
380        struct kvm *kvm = mmu_notifier_to_kvm(mn);
381        int young, idx;
382
383        idx = srcu_read_lock(&kvm->srcu);
384        spin_lock(&kvm->mmu_lock);
385
386        young = kvm_age_hva(kvm, start, end);
387        if (young)
388                kvm_flush_remote_tlbs(kvm);
389
390        spin_unlock(&kvm->mmu_lock);
391        srcu_read_unlock(&kvm->srcu, idx);
392
393        return young;
394}
395
396static int kvm_mmu_notifier_test_young(struct mmu_notifier *mn,
397                                       struct mm_struct *mm,
398                                       unsigned long address)
399{
400        struct kvm *kvm = mmu_notifier_to_kvm(mn);
401        int young, idx;
402
403        idx = srcu_read_lock(&kvm->srcu);
404        spin_lock(&kvm->mmu_lock);
405        young = kvm_test_age_hva(kvm, address);
406        spin_unlock(&kvm->mmu_lock);
407        srcu_read_unlock(&kvm->srcu, idx);
408
409        return young;
410}
411
412static void kvm_mmu_notifier_release(struct mmu_notifier *mn,
413                                     struct mm_struct *mm)
414{
415        struct kvm *kvm = mmu_notifier_to_kvm(mn);
416        int idx;
417
418        idx = srcu_read_lock(&kvm->srcu);
419        kvm_arch_flush_shadow_all(kvm);
420        srcu_read_unlock(&kvm->srcu, idx);
421}
422
423static const struct mmu_notifier_ops kvm_mmu_notifier_ops = {
424        .invalidate_page        = kvm_mmu_notifier_invalidate_page,
425        .invalidate_range_start = kvm_mmu_notifier_invalidate_range_start,
426        .invalidate_range_end   = kvm_mmu_notifier_invalidate_range_end,
427        .clear_flush_young      = kvm_mmu_notifier_clear_flush_young,
428        .test_young             = kvm_mmu_notifier_test_young,
429        .change_pte             = kvm_mmu_notifier_change_pte,
430        .release                = kvm_mmu_notifier_release,
431};
432
433static int kvm_init_mmu_notifier(struct kvm *kvm)
434{
435        kvm->mmu_notifier.ops = &kvm_mmu_notifier_ops;
436        return mmu_notifier_register(&kvm->mmu_notifier, current->mm);
437}
438
439#else  /* !(CONFIG_MMU_NOTIFIER && KVM_ARCH_WANT_MMU_NOTIFIER) */
440
441static int kvm_init_mmu_notifier(struct kvm *kvm)
442{
443        return 0;
444}
445
446#endif /* CONFIG_MMU_NOTIFIER && KVM_ARCH_WANT_MMU_NOTIFIER */
447
448static void kvm_init_memslots_id(struct kvm *kvm)
449{
450        int i;
451        struct kvm_memslots *slots = kvm->memslots;
452
453        for (i = 0; i < KVM_MEM_SLOTS_NUM; i++)
454                slots->id_to_index[i] = slots->memslots[i].id = i;
455}
456
457static struct kvm *kvm_create_vm(unsigned long type)
458{
459        int r, i;
460        struct kvm *kvm = kvm_arch_alloc_vm();
461
462        if (!kvm)
463                return ERR_PTR(-ENOMEM);
464
465        spin_lock_init(&kvm->mmu_lock);
466        atomic_inc(&current->mm->mm_count);
467        kvm->mm = current->mm;
468        kvm_eventfd_init(kvm);
469        mutex_init(&kvm->lock);
470        mutex_init(&kvm->irq_lock);
471        mutex_init(&kvm->slots_lock);
472        atomic_set(&kvm->users_count, 1);
473        INIT_LIST_HEAD(&kvm->devices);
474
475        r = kvm_arch_init_vm(kvm, type);
476        if (r)
477                goto out_err_no_disable;
478
479        r = hardware_enable_all();
480        if (r)
481                goto out_err_no_disable;
482
483#ifdef CONFIG_HAVE_KVM_IRQCHIP
484        INIT_HLIST_HEAD(&kvm->mask_notifier_list);
485#endif
486#ifdef CONFIG_HAVE_KVM_IRQFD
487        INIT_HLIST_HEAD(&kvm->irq_ack_notifier_list);
488#endif
489
490        BUILD_BUG_ON(KVM_MEM_SLOTS_NUM > SHRT_MAX);
491
492        r = -ENOMEM;
493        kvm->memslots = kvm_kvzalloc(sizeof(struct kvm_memslots));
494        if (!kvm->memslots)
495                goto out_err_no_srcu;
496
497        /*
498         * Init kvm generation close to the maximum to easily test the
499         * code of handling generation number wrap-around.
500         */
501        kvm->memslots->generation = -150;
502
503        kvm_init_memslots_id(kvm);
504        if (init_srcu_struct(&kvm->srcu))
505                goto out_err_no_srcu;
506        if (init_srcu_struct(&kvm->irq_srcu))
507                goto out_err_no_irq_srcu;
508        for (i = 0; i < KVM_NR_BUSES; i++) {
509                kvm->buses[i] = kzalloc(sizeof(struct kvm_io_bus),
510                                        GFP_KERNEL);
511                if (!kvm->buses[i])
512                        goto out_err;
513        }
514
515        r = kvm_init_mmu_notifier(kvm);
516        if (r)
517                goto out_err;
518
519        spin_lock(&kvm_lock);
520        list_add(&kvm->vm_list, &vm_list);
521        spin_unlock(&kvm_lock);
522
523        return kvm;
524
525out_err:
526        cleanup_srcu_struct(&kvm->irq_srcu);
527out_err_no_irq_srcu:
528        cleanup_srcu_struct(&kvm->srcu);
529out_err_no_srcu:
530        hardware_disable_all();
531out_err_no_disable:
532        for (i = 0; i < KVM_NR_BUSES; i++)
533                kfree(kvm->buses[i]);
534        kvfree(kvm->memslots);
535        kvm_arch_free_vm(kvm);
536        mmdrop(current->mm);
537        return ERR_PTR(r);
538}
539
540/*
541 * Avoid using vmalloc for a small buffer.
542 * Should not be used when the size is statically known.
543 */
544void *kvm_kvzalloc(unsigned long size)
545{
546        if (size > PAGE_SIZE)
547                return vzalloc(size);
548        else
549                return kzalloc(size, GFP_KERNEL);
550}
551
552void kvm_kvfree(const void *addr)
553{
554        if (is_vmalloc_addr(addr))
555                vfree(addr);
556        else
557                kfree(addr);
558}
559
560static void kvm_destroy_dirty_bitmap(struct kvm_memory_slot *memslot)
561{
562        if (!memslot->dirty_bitmap)
563                return;
564
565        kvm_kvfree(memslot->dirty_bitmap);
566        memslot->dirty_bitmap = NULL;
567}
568
569/*
570 * Free any memory in @free but not in @dont.
571 */
572static void kvm_free_physmem_slot(struct kvm *kvm, struct kvm_memory_slot *free,
573                                  struct kvm_memory_slot *dont)
574{
575        if (!dont || free->dirty_bitmap != dont->dirty_bitmap)
576                kvm_destroy_dirty_bitmap(free);
577
578        kvm_arch_free_memslot(kvm, free, dont);
579
580        free->npages = 0;
581}
582
583static void kvm_free_physmem(struct kvm *kvm)
584{
585        struct kvm_memslots *slots = kvm->memslots;
586        struct kvm_memory_slot *memslot;
587
588        kvm_for_each_memslot(memslot, slots)
589                kvm_free_physmem_slot(kvm, memslot, NULL);
590
591        kvfree(kvm->memslots);
592}
593
594static void kvm_destroy_devices(struct kvm *kvm)
595{
596        struct list_head *node, *tmp;
597
598        list_for_each_safe(node, tmp, &kvm->devices) {
599                struct kvm_device *dev =
600                        list_entry(node, struct kvm_device, vm_node);
601
602                list_del(node);
603                dev->ops->destroy(dev);
604        }
605}
606
607static void kvm_destroy_vm(struct kvm *kvm)
608{
609        int i;
610        struct mm_struct *mm = kvm->mm;
611
612        kvm_arch_sync_events(kvm);
613        spin_lock(&kvm_lock);
614        list_del(&kvm->vm_list);
615        spin_unlock(&kvm_lock);
616        kvm_free_irq_routing(kvm);
617        for (i = 0; i < KVM_NR_BUSES; i++) {
618                if (kvm->buses[i])
619                        kvm_io_bus_destroy(kvm->buses[i]);
620                kvm->buses[i] = NULL;
621        }
622        kvm_coalesced_mmio_free(kvm);
623#if defined(CONFIG_MMU_NOTIFIER) && defined(KVM_ARCH_WANT_MMU_NOTIFIER)
624        mmu_notifier_unregister(&kvm->mmu_notifier, kvm->mm);
625#else
626        kvm_arch_flush_shadow_all(kvm);
627#endif
628        kvm_arch_destroy_vm(kvm);
629        kvm_destroy_devices(kvm);
630        kvm_free_physmem(kvm);
631        cleanup_srcu_struct(&kvm->irq_srcu);
632        cleanup_srcu_struct(&kvm->srcu);
633        kvm_arch_free_vm(kvm);
634        hardware_disable_all();
635        mmdrop(mm);
636}
637
638void kvm_get_kvm(struct kvm *kvm)
639{
640        atomic_inc(&kvm->users_count);
641}
642EXPORT_SYMBOL_GPL(kvm_get_kvm);
643
644void kvm_put_kvm(struct kvm *kvm)
645{
646        if (atomic_dec_and_test(&kvm->users_count))
647                kvm_destroy_vm(kvm);
648}
649EXPORT_SYMBOL_GPL(kvm_put_kvm);
650
651
652static int kvm_vm_release(struct inode *inode, struct file *filp)
653{
654        struct kvm *kvm = filp->private_data;
655
656        kvm_irqfd_release(kvm);
657
658        kvm_put_kvm(kvm);
659        return 0;
660}
661
662/*
663 * Allocation size is twice as large as the actual dirty bitmap size.
664 * See x86's kvm_vm_ioctl_get_dirty_log() why this is needed.
665 */
666static int kvm_create_dirty_bitmap(struct kvm_memory_slot *memslot)
667{
668        unsigned long dirty_bytes = 2 * kvm_dirty_bitmap_bytes(memslot);
669
670        memslot->dirty_bitmap = kvm_kvzalloc(dirty_bytes);
671        if (!memslot->dirty_bitmap)
672                return -ENOMEM;
673
674        return 0;
675}
676
677static int cmp_memslot(const void *slot1, const void *slot2)
678{
679        struct kvm_memory_slot *s1, *s2;
680
681        s1 = (struct kvm_memory_slot *)slot1;
682        s2 = (struct kvm_memory_slot *)slot2;
683
684        if (s1->npages < s2->npages)
685                return 1;
686        if (s1->npages > s2->npages)
687                return -1;
688
689        return 0;
690}
691
692/*
693 * Sort the memslots base on its size, so the larger slots
694 * will get better fit.
695 */
696static void sort_memslots(struct kvm_memslots *slots)
697{
698        int i;
699
700        sort(slots->memslots, KVM_MEM_SLOTS_NUM,
701              sizeof(struct kvm_memory_slot), cmp_memslot, NULL);
702
703        for (i = 0; i < KVM_MEM_SLOTS_NUM; i++)
704                slots->id_to_index[slots->memslots[i].id] = i;
705}
706
707static void update_memslots(struct kvm_memslots *slots,
708                            struct kvm_memory_slot *new)
709{
710        if (new) {
711                int id = new->id;
712                struct kvm_memory_slot *old = id_to_memslot(slots, id);
713                unsigned long npages = old->npages;
714
715                *old = *new;
716                if (new->npages != npages)
717                        sort_memslots(slots);
718        }
719}
720
721static int check_memory_region_flags(struct kvm_userspace_memory_region *mem)
722{
723        u32 valid_flags = KVM_MEM_LOG_DIRTY_PAGES;
724
725#ifdef __KVM_HAVE_READONLY_MEM
726        valid_flags |= KVM_MEM_READONLY;
727#endif
728
729        if (mem->flags & ~valid_flags)
730                return -EINVAL;
731
732        return 0;
733}
734
735static struct kvm_memslots *install_new_memslots(struct kvm *kvm,
736                struct kvm_memslots *slots, struct kvm_memory_slot *new)
737{
738        struct kvm_memslots *old_memslots = kvm->memslots;
739
740        /*
741         * Set the low bit in the generation, which disables SPTE caching
742         * until the end of synchronize_srcu_expedited.
743         */
744        WARN_ON(old_memslots->generation & 1);
745        slots->generation = old_memslots->generation + 1;
746
747        update_memslots(slots, new);
748        rcu_assign_pointer(kvm->memslots, slots);
749        synchronize_srcu_expedited(&kvm->srcu);
750
751        /*
752         * Increment the new memslot generation a second time. This prevents
753         * vm exits that race with memslot updates from caching a memslot
754         * generation that will (potentially) be valid forever.
755         */
756        slots->generation++;
757
758        kvm_arch_memslots_updated(kvm);
759
760        return old_memslots;
761}
762
763/*
764 * Allocate some memory and give it an address in the guest physical address
765 * space.
766 *
767 * Discontiguous memory is allowed, mostly for framebuffers.
768 *
769 * Must be called holding mmap_sem for write.
770 */
771int __kvm_set_memory_region(struct kvm *kvm,
772                            struct kvm_userspace_memory_region *mem)
773{
774        int r;
775        gfn_t base_gfn;
776        unsigned long npages;
777        struct kvm_memory_slot *slot;
778        struct kvm_memory_slot old, new;
779        struct kvm_memslots *slots = NULL, *old_memslots;
780        enum kvm_mr_change change;
781
782        r = check_memory_region_flags(mem);
783        if (r)
784                goto out;
785
786        r = -EINVAL;
787        /* General sanity checks */
788        if (mem->memory_size & (PAGE_SIZE - 1))
789                goto out;
790        if (mem->guest_phys_addr & (PAGE_SIZE - 1))
791                goto out;
792        /* We can read the guest memory with __xxx_user() later on. */
793        if ((mem->slot < KVM_USER_MEM_SLOTS) &&
794            ((mem->userspace_addr & (PAGE_SIZE - 1)) ||
795             !access_ok(VERIFY_WRITE,
796                        (void __user *)(unsigned long)mem->userspace_addr,
797                        mem->memory_size)))
798                goto out;
799        if (mem->slot >= KVM_MEM_SLOTS_NUM)
800                goto out;
801        if (mem->guest_phys_addr + mem->memory_size < mem->guest_phys_addr)
802                goto out;
803
804        slot = id_to_memslot(kvm->memslots, mem->slot);
805        base_gfn = mem->guest_phys_addr >> PAGE_SHIFT;
806        npages = mem->memory_size >> PAGE_SHIFT;
807
808        if (npages > KVM_MEM_MAX_NR_PAGES)
809                goto out;
810
811        if (!npages)
812                mem->flags &= ~KVM_MEM_LOG_DIRTY_PAGES;
813
814        new = old = *slot;
815
816        new.id = mem->slot;
817        new.base_gfn = base_gfn;
818        new.npages = npages;
819        new.flags = mem->flags;
820
821        if (npages) {
822                if (!old.npages)
823                        change = KVM_MR_CREATE;
824                else { /* Modify an existing slot. */
825                        if ((mem->userspace_addr != old.userspace_addr) ||
826                            (npages != old.npages) ||
827                            ((new.flags ^ old.flags) & KVM_MEM_READONLY))
828                                goto out;
829
830                        if (base_gfn != old.base_gfn)
831                                change = KVM_MR_MOVE;
832                        else if (new.flags != old.flags)
833                                change = KVM_MR_FLAGS_ONLY;
834                        else { /* Nothing to change. */
835                                r = 0;
836                                goto out;
837                        }
838                }
839        } else if (old.npages) {
840                change = KVM_MR_DELETE;
841        } else /* Modify a non-existent slot: disallowed. */
842                goto out;
843
844        if ((change == KVM_MR_CREATE) || (change == KVM_MR_MOVE)) {
845                /* Check for overlaps */
846                r = -EEXIST;
847                kvm_for_each_memslot(slot, kvm->memslots) {
848                        if ((slot->id >= KVM_USER_MEM_SLOTS) ||
849                            (slot->id == mem->slot))
850                                continue;
851                        if (!((base_gfn + npages <= slot->base_gfn) ||
852                              (base_gfn >= slot->base_gfn + slot->npages)))
853                                goto out;
854                }
855        }
856
857        /* Free page dirty bitmap if unneeded */
858        if (!(new.flags & KVM_MEM_LOG_DIRTY_PAGES))
859                new.dirty_bitmap = NULL;
860
861        r = -ENOMEM;
862        if (change == KVM_MR_CREATE) {
863                new.userspace_addr = mem->userspace_addr;
864
865                if (kvm_arch_create_memslot(kvm, &new, npages))
866                        goto out_free;
867        }
868
869        /* Allocate page dirty bitmap if needed */
870        if ((new.flags & KVM_MEM_LOG_DIRTY_PAGES) && !new.dirty_bitmap) {
871                if (kvm_create_dirty_bitmap(&new) < 0)
872                        goto out_free;
873        }
874
875        if ((change == KVM_MR_DELETE) || (change == KVM_MR_MOVE)) {
876                slots = kvm_kvzalloc(sizeof(struct kvm_memslots));
877                if (!slots)
878                        goto out_free;
879                memcpy(slots, kvm->memslots, sizeof(struct kvm_memslots));
880
881                slot = id_to_memslot(slots, mem->slot);
882                slot->flags |= KVM_MEMSLOT_INVALID;
883
884                old_memslots = install_new_memslots(kvm, slots, NULL);
885
886                /* slot was deleted or moved, clear iommu mapping */
887                kvm_iommu_unmap_pages(kvm, &old);
888                /* From this point no new shadow pages pointing to a deleted,
889                 * or moved, memslot will be created.
890                 *
891                 * validation of sp->gfn happens in:
892                 *      - gfn_to_hva (kvm_read_guest, gfn_to_pfn)
893                 *      - kvm_is_visible_gfn (mmu_check_roots)
894                 */
895                kvm_arch_flush_shadow_memslot(kvm, slot);
896                slots = old_memslots;
897        }
898
899        r = kvm_arch_prepare_memory_region(kvm, &new, mem, change);
900        if (r)
901                goto out_slots;
902
903        r = -ENOMEM;
904        /*
905         * We can re-use the old_memslots from above, the only difference
906         * from the currently installed memslots is the invalid flag.  This
907         * will get overwritten by update_memslots anyway.
908         */
909        if (!slots) {
910                slots = kvm_kvzalloc(sizeof(struct kvm_memslots));
911                if (!slots)
912                        goto out_free;
913                memcpy(slots, kvm->memslots, sizeof(struct kvm_memslots));
914        }
915
916        /* actual memory is freed via old in kvm_free_physmem_slot below */
917        if (change == KVM_MR_DELETE) {
918                new.dirty_bitmap = NULL;
919                memset(&new.arch, 0, sizeof(new.arch));
920        }
921
922        old_memslots = install_new_memslots(kvm, slots, &new);
923
924        kvm_arch_commit_memory_region(kvm, mem, &old, change);
925
926        kvm_free_physmem_slot(kvm, &old, &new);
927        kvfree(old_memslots);
928
929        /*
930         * IOMMU mapping:  New slots need to be mapped.  Old slots need to be
931         * un-mapped and re-mapped if their base changes.  Since base change
932         * unmapping is handled above with slot deletion, mapping alone is
933         * needed here.  Anything else the iommu might care about for existing
934         * slots (size changes, userspace addr changes and read-only flag
935         * changes) is disallowed above, so any other attribute changes getting
936         * here can be skipped.
937         */
938        if ((change == KVM_MR_CREATE) || (change == KVM_MR_MOVE)) {
939                r = kvm_iommu_map_pages(kvm, &new);
940                return r;
941        }
942
943        return 0;
944
945out_slots:
946        kvfree(slots);
947out_free:
948        kvm_free_physmem_slot(kvm, &new, &old);
949out:
950        return r;
951}
952EXPORT_SYMBOL_GPL(__kvm_set_memory_region);
953
954int kvm_set_memory_region(struct kvm *kvm,
955                          struct kvm_userspace_memory_region *mem)
956{
957        int r;
958
959        mutex_lock(&kvm->slots_lock);
960        r = __kvm_set_memory_region(kvm, mem);
961        mutex_unlock(&kvm->slots_lock);
962        return r;
963}
964EXPORT_SYMBOL_GPL(kvm_set_memory_region);
965
966static int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
967                                          struct kvm_userspace_memory_region *mem)
968{
969        if (mem->slot >= KVM_USER_MEM_SLOTS)
970                return -EINVAL;
971        return kvm_set_memory_region(kvm, mem);
972}
973
974int kvm_get_dirty_log(struct kvm *kvm,
975                        struct kvm_dirty_log *log, int *is_dirty)
976{
977        struct kvm_memory_slot *memslot;
978        int r, i;
979        unsigned long n;
980        unsigned long any = 0;
981
982        r = -EINVAL;
983        if (log->slot >= KVM_USER_MEM_SLOTS)
984                goto out;
985
986        memslot = id_to_memslot(kvm->memslots, log->slot);
987        r = -ENOENT;
988        if (!memslot->dirty_bitmap)
989                goto out;
990
991        n = kvm_dirty_bitmap_bytes(memslot);
992
993        for (i = 0; !any && i < n/sizeof(long); ++i)
994                any = memslot->dirty_bitmap[i];
995
996        r = -EFAULT;
997        if (copy_to_user(log->dirty_bitmap, memslot->dirty_bitmap, n))
998                goto out;
999
1000        if (any)
1001                *is_dirty = 1;
1002
1003        r = 0;
1004out:
1005        return r;
1006}
1007EXPORT_SYMBOL_GPL(kvm_get_dirty_log);
1008
1009bool kvm_largepages_enabled(void)
1010{
1011        return largepages_enabled;
1012}
1013
1014void kvm_disable_largepages(void)
1015{
1016        largepages_enabled = false;
1017}
1018EXPORT_SYMBOL_GPL(kvm_disable_largepages);
1019
1020struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn)
1021{
1022        return __gfn_to_memslot(kvm_memslots(kvm), gfn);
1023}
1024EXPORT_SYMBOL_GPL(gfn_to_memslot);
1025
1026int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn)
1027{
1028        struct kvm_memory_slot *memslot = gfn_to_memslot(kvm, gfn);
1029
1030        if (!memslot || memslot->id >= KVM_USER_MEM_SLOTS ||
1031              memslot->flags & KVM_MEMSLOT_INVALID)
1032                return 0;
1033
1034        return 1;
1035}
1036EXPORT_SYMBOL_GPL(kvm_is_visible_gfn);
1037
1038unsigned long kvm_host_page_size(struct kvm *kvm, gfn_t gfn)
1039{
1040        struct vm_area_struct *vma;
1041        unsigned long addr, size;
1042
1043        size = PAGE_SIZE;
1044
1045        addr = gfn_to_hva(kvm, gfn);
1046        if (kvm_is_error_hva(addr))
1047                return PAGE_SIZE;
1048
1049        down_read(&current->mm->mmap_sem);
1050        vma = find_vma(current->mm, addr);
1051        if (!vma)
1052                goto out;
1053
1054        size = vma_kernel_pagesize(vma);
1055
1056out:
1057        up_read(&current->mm->mmap_sem);
1058
1059        return size;
1060}
1061
1062static bool memslot_is_readonly(struct kvm_memory_slot *slot)
1063{
1064        return slot->flags & KVM_MEM_READONLY;
1065}
1066
1067static unsigned long __gfn_to_hva_many(struct kvm_memory_slot *slot, gfn_t gfn,
1068                                       gfn_t *nr_pages, bool write)
1069{
1070        if (!slot || slot->flags & KVM_MEMSLOT_INVALID)
1071                return KVM_HVA_ERR_BAD;
1072
1073        if (memslot_is_readonly(slot) && write)
1074                return KVM_HVA_ERR_RO_BAD;
1075
1076        if (nr_pages)
1077                *nr_pages = slot->npages - (gfn - slot->base_gfn);
1078
1079        return __gfn_to_hva_memslot(slot, gfn);
1080}
1081
1082static unsigned long gfn_to_hva_many(struct kvm_memory_slot *slot, gfn_t gfn,
1083                                     gfn_t *nr_pages)
1084{
1085        return __gfn_to_hva_many(slot, gfn, nr_pages, true);
1086}
1087
1088unsigned long gfn_to_hva_memslot(struct kvm_memory_slot *slot,
1089                                        gfn_t gfn)
1090{
1091        return gfn_to_hva_many(slot, gfn, NULL);
1092}
1093EXPORT_SYMBOL_GPL(gfn_to_hva_memslot);
1094
1095unsigned long gfn_to_hva(struct kvm *kvm, gfn_t gfn)
1096{
1097        return gfn_to_hva_many(gfn_to_memslot(kvm, gfn), gfn, NULL);
1098}
1099EXPORT_SYMBOL_GPL(gfn_to_hva);
1100
1101/*
1102 * If writable is set to false, the hva returned by this function is only
1103 * allowed to be read.
1104 */
1105unsigned long gfn_to_hva_memslot_prot(struct kvm_memory_slot *slot,
1106                                      gfn_t gfn, bool *writable)
1107{
1108        unsigned long hva = __gfn_to_hva_many(slot, gfn, NULL, false);
1109
1110        if (!kvm_is_error_hva(hva) && writable)
1111                *writable = !memslot_is_readonly(slot);
1112
1113        return hva;
1114}
1115
1116unsigned long gfn_to_hva_prot(struct kvm *kvm, gfn_t gfn, bool *writable)
1117{
1118        struct kvm_memory_slot *slot = gfn_to_memslot(kvm, gfn);
1119
1120        return gfn_to_hva_memslot_prot(slot, gfn, writable);
1121}
1122
1123static int kvm_read_hva(void *data, void __user *hva, int len)
1124{
1125        return __copy_from_user(data, hva, len);
1126}
1127
1128static int kvm_read_hva_atomic(void *data, void __user *hva, int len)
1129{
1130        return __copy_from_user_inatomic(data, hva, len);
1131}
1132
1133static int get_user_page_nowait(struct task_struct *tsk, struct mm_struct *mm,
1134        unsigned long start, int write, struct page **page)
1135{
1136        int flags = FOLL_TOUCH | FOLL_NOWAIT | FOLL_HWPOISON | FOLL_GET;
1137
1138        if (write)
1139                flags |= FOLL_WRITE;
1140
1141        return __get_user_pages(tsk, mm, start, 1, flags, page, NULL, NULL);
1142}
1143
1144int kvm_get_user_page_io(struct task_struct *tsk, struct mm_struct *mm,
1145                         unsigned long addr, bool write_fault,
1146                         struct page **pagep)
1147{
1148        int npages;
1149        int locked = 1;
1150        int flags = FOLL_TOUCH | FOLL_HWPOISON |
1151                    (pagep ? FOLL_GET : 0) |
1152                    (write_fault ? FOLL_WRITE : 0);
1153
1154        /*
1155         * If retrying the fault, we get here *not* having allowed the filemap
1156         * to wait on the page lock. We should now allow waiting on the IO with
1157         * the mmap semaphore released.
1158         */
1159        down_read(&mm->mmap_sem);
1160        npages = __get_user_pages(tsk, mm, addr, 1, flags, pagep, NULL,
1161                                  &locked);
1162        if (!locked) {
1163                VM_BUG_ON(npages);
1164
1165                if (!pagep)
1166                        return 0;
1167
1168                /*
1169                 * The previous call has now waited on the IO. Now we can
1170                 * retry and complete. Pass TRIED to ensure we do not re
1171                 * schedule async IO (see e.g. filemap_fault).
1172                 */
1173                down_read(&mm->mmap_sem);
1174                npages = __get_user_pages(tsk, mm, addr, 1, flags | FOLL_TRIED,
1175                                          pagep, NULL, NULL);
1176        }
1177        up_read(&mm->mmap_sem);
1178        return npages;
1179}
1180
1181static inline int check_user_page_hwpoison(unsigned long addr)
1182{
1183        int rc, flags = FOLL_TOUCH | FOLL_HWPOISON | FOLL_WRITE;
1184
1185        rc = __get_user_pages(current, current->mm, addr, 1,
1186                              flags, NULL, NULL, NULL);
1187        return rc == -EHWPOISON;
1188}
1189
1190/*
1191 * The atomic path to get the writable pfn which will be stored in @pfn,
1192 * true indicates success, otherwise false is returned.
1193 */
1194static bool hva_to_pfn_fast(unsigned long addr, bool atomic, bool *async,
1195                            bool write_fault, bool *writable, pfn_t *pfn)
1196{
1197        struct page *page[1];
1198        int npages;
1199
1200        if (!(async || atomic))
1201                return false;
1202
1203        /*
1204         * Fast pin a writable pfn only if it is a write fault request
1205         * or the caller allows to map a writable pfn for a read fault
1206         * request.
1207         */
1208        if (!(write_fault || writable))
1209                return false;
1210
1211        npages = __get_user_pages_fast(addr, 1, 1, page);
1212        if (npages == 1) {
1213                *pfn = page_to_pfn(page[0]);
1214
1215                if (writable)
1216                        *writable = true;
1217                return true;
1218        }
1219
1220        return false;
1221}
1222
1223/*
1224 * The slow path to get the pfn of the specified host virtual address,
1225 * 1 indicates success, -errno is returned if error is detected.
1226 */
1227static int hva_to_pfn_slow(unsigned long addr, bool *async, bool write_fault,
1228                           bool *writable, pfn_t *pfn)
1229{
1230        struct page *page[1];
1231        int npages = 0;
1232
1233        might_sleep();
1234
1235        if (writable)
1236                *writable = write_fault;
1237
1238        if (async) {
1239                down_read(&current->mm->mmap_sem);
1240                npages = get_user_page_nowait(current, current->mm,
1241                                              addr, write_fault, page);
1242                up_read(&current->mm->mmap_sem);
1243        } else {
1244                /*
1245                 * By now we have tried gup_fast, and possibly async_pf, and we
1246                 * are certainly not atomic. Time to retry the gup, allowing
1247                 * mmap semaphore to be relinquished in the case of IO.
1248                 */
1249                npages = kvm_get_user_page_io(current, current->mm, addr,
1250                                              write_fault, page);
1251        }
1252        if (npages != 1)
1253                return npages;
1254
1255        /* map read fault as writable if possible */
1256        if (unlikely(!write_fault) && writable) {
1257                struct page *wpage[1];
1258
1259                npages = __get_user_pages_fast(addr, 1, 1, wpage);
1260                if (npages == 1) {
1261                        *writable = true;
1262                        put_page(page[0]);
1263                        page[0] = wpage[0];
1264                }
1265
1266                npages = 1;
1267        }
1268        *pfn = page_to_pfn(page[0]);
1269        return npages;
1270}
1271
1272static bool vma_is_valid(struct vm_area_struct *vma, bool write_fault)
1273{
1274        if (unlikely(!(vma->vm_flags & VM_READ)))
1275                return false;
1276
1277        if (write_fault && (unlikely(!(vma->vm_flags & VM_WRITE))))
1278                return false;
1279
1280        return true;
1281}
1282
1283/*
1284 * Pin guest page in memory and return its pfn.
1285 * @addr: host virtual address which maps memory to the guest
1286 * @atomic: whether this function can sleep
1287 * @async: whether this function need to wait IO complete if the
1288 *         host page is not in the memory
1289 * @write_fault: whether we should get a writable host page
1290 * @writable: whether it allows to map a writable host page for !@write_fault
1291 *
1292 * The function will map a writable host page for these two cases:
1293 * 1): @write_fault = true
1294 * 2): @write_fault = false && @writable, @writable will tell the caller
1295 *     whether the mapping is writable.
1296 */
1297static pfn_t hva_to_pfn(unsigned long addr, bool atomic, bool *async,
1298                        bool write_fault, bool *writable)
1299{
1300        struct vm_area_struct *vma;
1301        pfn_t pfn = 0;
1302        int npages;
1303
1304        /* we can do it either atomically or asynchronously, not both */
1305        BUG_ON(atomic && async);
1306
1307        if (hva_to_pfn_fast(addr, atomic, async, write_fault, writable, &pfn))
1308                return pfn;
1309
1310        if (atomic)
1311                return KVM_PFN_ERR_FAULT;
1312
1313        npages = hva_to_pfn_slow(addr, async, write_fault, writable, &pfn);
1314        if (npages == 1)
1315                return pfn;
1316
1317        down_read(&current->mm->mmap_sem);
1318        if (npages == -EHWPOISON ||
1319              (!async && check_user_page_hwpoison(addr))) {
1320                pfn = KVM_PFN_ERR_HWPOISON;
1321                goto exit;
1322        }
1323
1324        vma = find_vma_intersection(current->mm, addr, addr + 1);
1325
1326        if (vma == NULL)
1327                pfn = KVM_PFN_ERR_FAULT;
1328        else if ((vma->vm_flags & VM_PFNMAP)) {
1329                pfn = ((addr - vma->vm_start) >> PAGE_SHIFT) +
1330                        vma->vm_pgoff;
1331                BUG_ON(!kvm_is_reserved_pfn(pfn));
1332        } else {
1333                if (async && vma_is_valid(vma, write_fault))
1334                        *async = true;
1335                pfn = KVM_PFN_ERR_FAULT;
1336        }
1337exit:
1338        up_read(&current->mm->mmap_sem);
1339        return pfn;
1340}
1341
1342static pfn_t
1343__gfn_to_pfn_memslot(struct kvm_memory_slot *slot, gfn_t gfn, bool atomic,
1344                     bool *async, bool write_fault, bool *writable)
1345{
1346        unsigned long addr = __gfn_to_hva_many(slot, gfn, NULL, write_fault);
1347
1348        if (addr == KVM_HVA_ERR_RO_BAD)
1349                return KVM_PFN_ERR_RO_FAULT;
1350
1351        if (kvm_is_error_hva(addr))
1352                return KVM_PFN_NOSLOT;
1353
1354        /* Do not map writable pfn in the readonly memslot. */
1355        if (writable && memslot_is_readonly(slot)) {
1356                *writable = false;
1357                writable = NULL;
1358        }
1359
1360        return hva_to_pfn(addr, atomic, async, write_fault,
1361                          writable);
1362}
1363
1364static pfn_t __gfn_to_pfn(struct kvm *kvm, gfn_t gfn, bool atomic, bool *async,
1365                          bool write_fault, bool *writable)
1366{
1367        struct kvm_memory_slot *slot;
1368
1369        if (async)
1370                *async = false;
1371
1372        slot = gfn_to_memslot(kvm, gfn);
1373
1374        return __gfn_to_pfn_memslot(slot, gfn, atomic, async, write_fault,
1375                                    writable);
1376}
1377
1378pfn_t gfn_to_pfn_atomic(struct kvm *kvm, gfn_t gfn)
1379{
1380        return __gfn_to_pfn(kvm, gfn, true, NULL, true, NULL);
1381}
1382EXPORT_SYMBOL_GPL(gfn_to_pfn_atomic);
1383
1384pfn_t gfn_to_pfn_async(struct kvm *kvm, gfn_t gfn, bool *async,
1385                       bool write_fault, bool *writable)
1386{
1387        return __gfn_to_pfn(kvm, gfn, false, async, write_fault, writable);
1388}
1389EXPORT_SYMBOL_GPL(gfn_to_pfn_async);
1390
1391pfn_t gfn_to_pfn(struct kvm *kvm, gfn_t gfn)
1392{
1393        return __gfn_to_pfn(kvm, gfn, false, NULL, true, NULL);
1394}
1395EXPORT_SYMBOL_GPL(gfn_to_pfn);
1396
1397pfn_t gfn_to_pfn_prot(struct kvm *kvm, gfn_t gfn, bool write_fault,
1398                      bool *writable)
1399{
1400        return __gfn_to_pfn(kvm, gfn, false, NULL, write_fault, writable);
1401}
1402EXPORT_SYMBOL_GPL(gfn_to_pfn_prot);
1403
1404pfn_t gfn_to_pfn_memslot(struct kvm_memory_slot *slot, gfn_t gfn)
1405{
1406        return __gfn_to_pfn_memslot(slot, gfn, false, NULL, true, NULL);
1407}
1408
1409pfn_t gfn_to_pfn_memslot_atomic(struct kvm_memory_slot *slot, gfn_t gfn)
1410{
1411        return __gfn_to_pfn_memslot(slot, gfn, true, NULL, true, NULL);
1412}
1413EXPORT_SYMBOL_GPL(gfn_to_pfn_memslot_atomic);
1414
1415int gfn_to_page_many_atomic(struct kvm *kvm, gfn_t gfn, struct page **pages,
1416                                                                  int nr_pages)
1417{
1418        unsigned long addr;
1419        gfn_t entry;
1420
1421        addr = gfn_to_hva_many(gfn_to_memslot(kvm, gfn), gfn, &entry);
1422        if (kvm_is_error_hva(addr))
1423                return -1;
1424
1425        if (entry < nr_pages)
1426                return 0;
1427
1428        return __get_user_pages_fast(addr, nr_pages, 1, pages);
1429}
1430EXPORT_SYMBOL_GPL(gfn_to_page_many_atomic);
1431
1432static struct page *kvm_pfn_to_page(pfn_t pfn)
1433{
1434        if (is_error_noslot_pfn(pfn))
1435                return KVM_ERR_PTR_BAD_PAGE;
1436
1437        if (kvm_is_reserved_pfn(pfn)) {
1438                WARN_ON(1);
1439                return KVM_ERR_PTR_BAD_PAGE;
1440        }
1441
1442        return pfn_to_page(pfn);
1443}
1444
1445struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn)
1446{
1447        pfn_t pfn;
1448
1449        pfn = gfn_to_pfn(kvm, gfn);
1450
1451        return kvm_pfn_to_page(pfn);
1452}
1453
1454EXPORT_SYMBOL_GPL(gfn_to_page);
1455
1456void kvm_release_page_clean(struct page *page)
1457{
1458        WARN_ON(is_error_page(page));
1459
1460        kvm_release_pfn_clean(page_to_pfn(page));
1461}
1462EXPORT_SYMBOL_GPL(kvm_release_page_clean);
1463
1464void kvm_release_pfn_clean(pfn_t pfn)
1465{
1466        if (!is_error_noslot_pfn(pfn) && !kvm_is_reserved_pfn(pfn))
1467                put_page(pfn_to_page(pfn));
1468}
1469EXPORT_SYMBOL_GPL(kvm_release_pfn_clean);
1470
1471void kvm_release_page_dirty(struct page *page)
1472{
1473        WARN_ON(is_error_page(page));
1474
1475        kvm_release_pfn_dirty(page_to_pfn(page));
1476}
1477EXPORT_SYMBOL_GPL(kvm_release_page_dirty);
1478
1479static void kvm_release_pfn_dirty(pfn_t pfn)
1480{
1481        kvm_set_pfn_dirty(pfn);
1482        kvm_release_pfn_clean(pfn);
1483}
1484
1485void kvm_set_pfn_dirty(pfn_t pfn)
1486{
1487        if (!kvm_is_reserved_pfn(pfn)) {
1488                struct page *page = pfn_to_page(pfn);
1489                if (!PageReserved(page))
1490                        SetPageDirty(page);
1491        }
1492}
1493EXPORT_SYMBOL_GPL(kvm_set_pfn_dirty);
1494
1495void kvm_set_pfn_accessed(pfn_t pfn)
1496{
1497        if (!kvm_is_reserved_pfn(pfn))
1498                mark_page_accessed(pfn_to_page(pfn));
1499}
1500EXPORT_SYMBOL_GPL(kvm_set_pfn_accessed);
1501
1502void kvm_get_pfn(pfn_t pfn)
1503{
1504        if (!kvm_is_reserved_pfn(pfn))
1505                get_page(pfn_to_page(pfn));
1506}
1507EXPORT_SYMBOL_GPL(kvm_get_pfn);
1508
1509static int next_segment(unsigned long len, int offset)
1510{
1511        if (len > PAGE_SIZE - offset)
1512                return PAGE_SIZE - offset;
1513        else
1514                return len;
1515}
1516
1517int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
1518                        int len)
1519{
1520        int r;
1521        unsigned long addr;
1522
1523        addr = gfn_to_hva_prot(kvm, gfn, NULL);
1524        if (kvm_is_error_hva(addr))
1525                return -EFAULT;
1526        r = kvm_read_hva(data, (void __user *)addr + offset, len);
1527        if (r)
1528                return -EFAULT;
1529        return 0;
1530}
1531EXPORT_SYMBOL_GPL(kvm_read_guest_page);
1532
1533int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len)
1534{
1535        gfn_t gfn = gpa >> PAGE_SHIFT;
1536        int seg;
1537        int offset = offset_in_page(gpa);
1538        int ret;
1539
1540        while ((seg = next_segment(len, offset)) != 0) {
1541                ret = kvm_read_guest_page(kvm, gfn, data, offset, seg);
1542                if (ret < 0)
1543                        return ret;
1544                offset = 0;
1545                len -= seg;
1546                data += seg;
1547                ++gfn;
1548        }
1549        return 0;
1550}
1551EXPORT_SYMBOL_GPL(kvm_read_guest);
1552
1553int kvm_read_guest_atomic(struct kvm *kvm, gpa_t gpa, void *data,
1554                          unsigned long len)
1555{
1556        int r;
1557        unsigned long addr;
1558        gfn_t gfn = gpa >> PAGE_SHIFT;
1559        int offset = offset_in_page(gpa);
1560
1561        addr = gfn_to_hva_prot(kvm, gfn, NULL);
1562        if (kvm_is_error_hva(addr))
1563                return -EFAULT;
1564        pagefault_disable();
1565        r = kvm_read_hva_atomic(data, (void __user *)addr + offset, len);
1566        pagefault_enable();
1567        if (r)
1568                return -EFAULT;
1569        return 0;
1570}
1571EXPORT_SYMBOL(kvm_read_guest_atomic);
1572
1573int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
1574                         int offset, int len)
1575{
1576        int r;
1577        unsigned long addr;
1578
1579        addr = gfn_to_hva(kvm, gfn);
1580        if (kvm_is_error_hva(addr))
1581                return -EFAULT;
1582        r = __copy_to_user((void __user *)addr + offset, data, len);
1583        if (r)
1584                return -EFAULT;
1585        mark_page_dirty(kvm, gfn);
1586        return 0;
1587}
1588EXPORT_SYMBOL_GPL(kvm_write_guest_page);
1589
1590int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
1591                    unsigned long len)
1592{
1593        gfn_t gfn = gpa >> PAGE_SHIFT;
1594        int seg;
1595        int offset = offset_in_page(gpa);
1596        int ret;
1597
1598        while ((seg = next_segment(len, offset)) != 0) {
1599                ret = kvm_write_guest_page(kvm, gfn, data, offset, seg);
1600                if (ret < 0)
1601                        return ret;
1602                offset = 0;
1603                len -= seg;
1604                data += seg;
1605                ++gfn;
1606        }
1607        return 0;
1608}
1609
1610int kvm_gfn_to_hva_cache_init(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
1611                              gpa_t gpa, unsigned long len)
1612{
1613        struct kvm_memslots *slots = kvm_memslots(kvm);
1614        int offset = offset_in_page(gpa);
1615        gfn_t start_gfn = gpa >> PAGE_SHIFT;
1616        gfn_t end_gfn = (gpa + len - 1) >> PAGE_SHIFT;
1617        gfn_t nr_pages_needed = end_gfn - start_gfn + 1;
1618        gfn_t nr_pages_avail;
1619
1620        ghc->gpa = gpa;
1621        ghc->generation = slots->generation;
1622        ghc->len = len;
1623        ghc->memslot = gfn_to_memslot(kvm, start_gfn);
1624        ghc->hva = gfn_to_hva_many(ghc->memslot, start_gfn, NULL);
1625        if (!kvm_is_error_hva(ghc->hva) && nr_pages_needed <= 1) {
1626                ghc->hva += offset;
1627        } else {
1628                /*
1629                 * If the requested region crosses two memslots, we still
1630                 * verify that the entire region is valid here.
1631                 */
1632                while (start_gfn <= end_gfn) {
1633                        ghc->memslot = gfn_to_memslot(kvm, start_gfn);
1634                        ghc->hva = gfn_to_hva_many(ghc->memslot, start_gfn,
1635                                                   &nr_pages_avail);
1636                        if (kvm_is_error_hva(ghc->hva))
1637                                return -EFAULT;
1638                        start_gfn += nr_pages_avail;
1639                }
1640                /* Use the slow path for cross page reads and writes. */
1641                ghc->memslot = NULL;
1642        }
1643        return 0;
1644}
1645EXPORT_SYMBOL_GPL(kvm_gfn_to_hva_cache_init);
1646
1647int kvm_write_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
1648                           void *data, unsigned long len)
1649{
1650        struct kvm_memslots *slots = kvm_memslots(kvm);
1651        int r;
1652
1653        BUG_ON(len > ghc->len);
1654
1655        if (slots->generation != ghc->generation)
1656                kvm_gfn_to_hva_cache_init(kvm, ghc, ghc->gpa, ghc->len);
1657
1658        if (unlikely(!ghc->memslot))
1659                return kvm_write_guest(kvm, ghc->gpa, data, len);
1660
1661        if (kvm_is_error_hva(ghc->hva))
1662                return -EFAULT;
1663
1664        r = __copy_to_user((void __user *)ghc->hva, data, len);
1665        if (r)
1666                return -EFAULT;
1667        mark_page_dirty_in_slot(kvm, ghc->memslot, ghc->gpa >> PAGE_SHIFT);
1668
1669        return 0;
1670}
1671EXPORT_SYMBOL_GPL(kvm_write_guest_cached);
1672
1673int kvm_read_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
1674                           void *data, unsigned long len)
1675{
1676        struct kvm_memslots *slots = kvm_memslots(kvm);
1677        int r;
1678
1679        BUG_ON(len > ghc->len);
1680
1681        if (slots->generation != ghc->generation)
1682                kvm_gfn_to_hva_cache_init(kvm, ghc, ghc->gpa, ghc->len);
1683
1684        if (unlikely(!ghc->memslot))
1685                return kvm_read_guest(kvm, ghc->gpa, data, len);
1686
1687        if (kvm_is_error_hva(ghc->hva))
1688                return -EFAULT;
1689
1690        r = __copy_from_user(data, (void __user *)ghc->hva, len);
1691        if (r)
1692                return -EFAULT;
1693
1694        return 0;
1695}
1696EXPORT_SYMBOL_GPL(kvm_read_guest_cached);
1697
1698int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len)
1699{
1700        const void *zero_page = (const void *) __va(page_to_phys(ZERO_PAGE(0)));
1701
1702        return kvm_write_guest_page(kvm, gfn, zero_page, offset, len);
1703}
1704EXPORT_SYMBOL_GPL(kvm_clear_guest_page);
1705
1706int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len)
1707{
1708        gfn_t gfn = gpa >> PAGE_SHIFT;
1709        int seg;
1710        int offset = offset_in_page(gpa);
1711        int ret;
1712
1713        while ((seg = next_segment(len, offset)) != 0) {
1714                ret = kvm_clear_guest_page(kvm, gfn, offset, seg);
1715                if (ret < 0)
1716                        return ret;
1717                offset = 0;
1718                len -= seg;
1719                ++gfn;
1720        }
1721        return 0;
1722}
1723EXPORT_SYMBOL_GPL(kvm_clear_guest);
1724
1725static void mark_page_dirty_in_slot(struct kvm *kvm,
1726                                    struct kvm_memory_slot *memslot,
1727                                    gfn_t gfn)
1728{
1729        if (memslot && memslot->dirty_bitmap) {
1730                unsigned long rel_gfn = gfn - memslot->base_gfn;
1731
1732                set_bit_le(rel_gfn, memslot->dirty_bitmap);
1733        }
1734}
1735
1736void mark_page_dirty(struct kvm *kvm, gfn_t gfn)
1737{
1738        struct kvm_memory_slot *memslot;
1739
1740        memslot = gfn_to_memslot(kvm, gfn);
1741        mark_page_dirty_in_slot(kvm, memslot, gfn);
1742}
1743EXPORT_SYMBOL_GPL(mark_page_dirty);
1744
1745/*
1746 * The vCPU has executed a HLT instruction with in-kernel mode enabled.
1747 */
1748void kvm_vcpu_block(struct kvm_vcpu *vcpu)
1749{
1750        DEFINE_WAIT(wait);
1751
1752        for (;;) {
1753                prepare_to_wait(&vcpu->wq, &wait, TASK_INTERRUPTIBLE);
1754
1755                if (kvm_arch_vcpu_runnable(vcpu)) {
1756                        kvm_make_request(KVM_REQ_UNHALT, vcpu);
1757                        break;
1758                }
1759                if (kvm_cpu_has_pending_timer(vcpu))
1760                        break;
1761                if (signal_pending(current))
1762                        break;
1763
1764                schedule();
1765        }
1766
1767        finish_wait(&vcpu->wq, &wait);
1768}
1769EXPORT_SYMBOL_GPL(kvm_vcpu_block);
1770
1771#ifndef CONFIG_S390
1772/*
1773 * Kick a sleeping VCPU, or a guest VCPU in guest mode, into host kernel mode.
1774 */
1775void kvm_vcpu_kick(struct kvm_vcpu *vcpu)
1776{
1777        int me;
1778        int cpu = vcpu->cpu;
1779        wait_queue_head_t *wqp;
1780
1781        wqp = kvm_arch_vcpu_wq(vcpu);
1782        if (waitqueue_active(wqp)) {
1783                wake_up_interruptible(wqp);
1784                ++vcpu->stat.halt_wakeup;
1785        }
1786
1787        me = get_cpu();
1788        if (cpu != me && (unsigned)cpu < nr_cpu_ids && cpu_online(cpu))
1789                if (kvm_arch_vcpu_should_kick(vcpu))
1790                        smp_send_reschedule(cpu);
1791        put_cpu();
1792}
1793EXPORT_SYMBOL_GPL(kvm_vcpu_kick);
1794#endif /* !CONFIG_S390 */
1795
1796int kvm_vcpu_yield_to(struct kvm_vcpu *target)
1797{
1798        struct pid *pid;
1799        struct task_struct *task = NULL;
1800        int ret = 0;
1801
1802        rcu_read_lock();
1803        pid = rcu_dereference(target->pid);
1804        if (pid)
1805                task = get_pid_task(pid, PIDTYPE_PID);
1806        rcu_read_unlock();
1807        if (!task)
1808                return ret;
1809        if (task->flags & PF_VCPU) {
1810                put_task_struct(task);
1811                return ret;
1812        }
1813        ret = yield_to(task, 1);
1814        put_task_struct(task);
1815
1816        return ret;
1817}
1818EXPORT_SYMBOL_GPL(kvm_vcpu_yield_to);
1819
1820/*
1821 * Helper that checks whether a VCPU is eligible for directed yield.
1822 * Most eligible candidate to yield is decided by following heuristics:
1823 *
1824 *  (a) VCPU which has not done pl-exit or cpu relax intercepted recently
1825 *  (preempted lock holder), indicated by @in_spin_loop.
1826 *  Set at the beiginning and cleared at the end of interception/PLE handler.
1827 *
1828 *  (b) VCPU which has done pl-exit/ cpu relax intercepted but did not get
1829 *  chance last time (mostly it has become eligible now since we have probably
1830 *  yielded to lockholder in last iteration. This is done by toggling
1831 *  @dy_eligible each time a VCPU checked for eligibility.)
1832 *
1833 *  Yielding to a recently pl-exited/cpu relax intercepted VCPU before yielding
1834 *  to preempted lock-holder could result in wrong VCPU selection and CPU
1835 *  burning. Giving priority for a potential lock-holder increases lock
1836 *  progress.
1837 *
1838 *  Since algorithm is based on heuristics, accessing another VCPU data without
1839 *  locking does not harm. It may result in trying to yield to  same VCPU, fail
1840 *  and continue with next VCPU and so on.
1841 */
1842static bool kvm_vcpu_eligible_for_directed_yield(struct kvm_vcpu *vcpu)
1843{
1844#ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
1845        bool eligible;
1846
1847        eligible = !vcpu->spin_loop.in_spin_loop ||
1848                    vcpu->spin_loop.dy_eligible;
1849
1850        if (vcpu->spin_loop.in_spin_loop)
1851                kvm_vcpu_set_dy_eligible(vcpu, !vcpu->spin_loop.dy_eligible);
1852
1853        return eligible;
1854#else
1855        return true;
1856#endif
1857}
1858
1859void kvm_vcpu_on_spin(struct kvm_vcpu *me)
1860{
1861        struct kvm *kvm = me->kvm;
1862        struct kvm_vcpu *vcpu;
1863        int last_boosted_vcpu = me->kvm->last_boosted_vcpu;
1864        int yielded = 0;
1865        int try = 3;
1866        int pass;
1867        int i;
1868
1869        kvm_vcpu_set_in_spin_loop(me, true);
1870        /*
1871         * We boost the priority of a VCPU that is runnable but not
1872         * currently running, because it got preempted by something
1873         * else and called schedule in __vcpu_run.  Hopefully that
1874         * VCPU is holding the lock that we need and will release it.
1875         * We approximate round-robin by starting at the last boosted VCPU.
1876         */
1877        for (pass = 0; pass < 2 && !yielded && try; pass++) {
1878                kvm_for_each_vcpu(i, vcpu, kvm) {
1879                        if (!pass && i <= last_boosted_vcpu) {
1880                                i = last_boosted_vcpu;
1881                                continue;
1882                        } else if (pass && i > last_boosted_vcpu)
1883                                break;
1884                        if (!ACCESS_ONCE(vcpu->preempted))
1885                                continue;
1886                        if (vcpu == me)
1887                                continue;
1888                        if (waitqueue_active(&vcpu->wq) && !kvm_arch_vcpu_runnable(vcpu))
1889                                continue;
1890                        if (!kvm_vcpu_eligible_for_directed_yield(vcpu))
1891                                continue;
1892
1893                        yielded = kvm_vcpu_yield_to(vcpu);
1894                        if (yielded > 0) {
1895                                kvm->last_boosted_vcpu = i;
1896                                break;
1897                        } else if (yielded < 0) {
1898                                try--;
1899                                if (!try)
1900                                        break;
1901                        }
1902                }
1903        }
1904        kvm_vcpu_set_in_spin_loop(me, false);
1905
1906        /* Ensure vcpu is not eligible during next spinloop */
1907        kvm_vcpu_set_dy_eligible(me, false);
1908}
1909EXPORT_SYMBOL_GPL(kvm_vcpu_on_spin);
1910
1911static int kvm_vcpu_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1912{
1913        struct kvm_vcpu *vcpu = vma->vm_file->private_data;
1914        struct page *page;
1915
1916        if (vmf->pgoff == 0)
1917                page = virt_to_page(vcpu->run);
1918#ifdef CONFIG_X86
1919        else if (vmf->pgoff == KVM_PIO_PAGE_OFFSET)
1920                page = virt_to_page(vcpu->arch.pio_data);
1921#endif
1922#ifdef KVM_COALESCED_MMIO_PAGE_OFFSET
1923        else if (vmf->pgoff == KVM_COALESCED_MMIO_PAGE_OFFSET)
1924                page = virt_to_page(vcpu->kvm->coalesced_mmio_ring);
1925#endif
1926        else
1927                return kvm_arch_vcpu_fault(vcpu, vmf);
1928        get_page(page);
1929        vmf->page = page;
1930        return 0;
1931}
1932
1933static const struct vm_operations_struct kvm_vcpu_vm_ops = {
1934        .fault = kvm_vcpu_fault,
1935};
1936
1937static int kvm_vcpu_mmap(struct file *file, struct vm_area_struct *vma)
1938{
1939        vma->vm_ops = &kvm_vcpu_vm_ops;
1940        return 0;
1941}
1942
1943static int kvm_vcpu_release(struct inode *inode, struct file *filp)
1944{
1945        struct kvm_vcpu *vcpu = filp->private_data;
1946
1947        kvm_put_kvm(vcpu->kvm);
1948        return 0;
1949}
1950
1951static struct file_operations kvm_vcpu_fops = {
1952        .release        = kvm_vcpu_release,
1953        .unlocked_ioctl = kvm_vcpu_ioctl,
1954#ifdef CONFIG_COMPAT
1955        .compat_ioctl   = kvm_vcpu_compat_ioctl,
1956#endif
1957        .mmap           = kvm_vcpu_mmap,
1958        .llseek         = noop_llseek,
1959};
1960
1961/*
1962 * Allocates an inode for the vcpu.
1963 */
1964static int create_vcpu_fd(struct kvm_vcpu *vcpu)
1965{
1966        return anon_inode_getfd("kvm-vcpu", &kvm_vcpu_fops, vcpu, O_RDWR | O_CLOEXEC);
1967}
1968
1969/*
1970 * Creates some virtual cpus.  Good luck creating more than one.
1971 */
1972static int kvm_vm_ioctl_create_vcpu(struct kvm *kvm, u32 id)
1973{
1974        int r;
1975        struct kvm_vcpu *vcpu, *v;
1976
1977        if (id >= KVM_MAX_VCPUS)
1978                return -EINVAL;
1979
1980        vcpu = kvm_arch_vcpu_create(kvm, id);
1981        if (IS_ERR(vcpu))
1982                return PTR_ERR(vcpu);
1983
1984        preempt_notifier_init(&vcpu->preempt_notifier, &kvm_preempt_ops);
1985
1986        r = kvm_arch_vcpu_setup(vcpu);
1987        if (r)
1988                goto vcpu_destroy;
1989
1990        mutex_lock(&kvm->lock);
1991        if (!kvm_vcpu_compatible(vcpu)) {
1992                r = -EINVAL;
1993                goto unlock_vcpu_destroy;
1994        }
1995        if (atomic_read(&kvm->online_vcpus) == KVM_MAX_VCPUS) {
1996                r = -EINVAL;
1997                goto unlock_vcpu_destroy;
1998        }
1999
2000        kvm_for_each_vcpu(r, v, kvm)
2001                if (v->vcpu_id == id) {
2002                        r = -EEXIST;
2003                        goto unlock_vcpu_destroy;
2004                }
2005
2006        BUG_ON(kvm->vcpus[atomic_read(&kvm->online_vcpus)]);
2007
2008        /* Now it's all set up, let userspace reach it */
2009        kvm_get_kvm(kvm);
2010        r = create_vcpu_fd(vcpu);
2011        if (r < 0) {
2012                kvm_put_kvm(kvm);
2013                goto unlock_vcpu_destroy;
2014        }
2015
2016        kvm->vcpus[atomic_read(&kvm->online_vcpus)] = vcpu;
2017        smp_wmb();
2018        atomic_inc(&kvm->online_vcpus);
2019
2020        mutex_unlock(&kvm->lock);
2021        kvm_arch_vcpu_postcreate(vcpu);
2022        return r;
2023
2024unlock_vcpu_destroy:
2025        mutex_unlock(&kvm->lock);
2026vcpu_destroy:
2027        kvm_arch_vcpu_destroy(vcpu);
2028        return r;
2029}
2030
2031static int kvm_vcpu_ioctl_set_sigmask(struct kvm_vcpu *vcpu, sigset_t *sigset)
2032{
2033        if (sigset) {
2034                sigdelsetmask(sigset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2035                vcpu->sigset_active = 1;
2036                vcpu->sigset = *sigset;
2037        } else
2038                vcpu->sigset_active = 0;
2039        return 0;
2040}
2041
2042static long kvm_vcpu_ioctl(struct file *filp,
2043                           unsigned int ioctl, unsigned long arg)
2044{
2045        struct kvm_vcpu *vcpu = filp->private_data;
2046        void __user *argp = (void __user *)arg;
2047        int r;
2048        struct kvm_fpu *fpu = NULL;
2049        struct kvm_sregs *kvm_sregs = NULL;
2050
2051        if (vcpu->kvm->mm != current->mm)
2052                return -EIO;
2053
2054        if (unlikely(_IOC_TYPE(ioctl) != KVMIO))
2055                return -EINVAL;
2056
2057#if defined(CONFIG_S390) || defined(CONFIG_PPC) || defined(CONFIG_MIPS)
2058        /*
2059         * Special cases: vcpu ioctls that are asynchronous to vcpu execution,
2060         * so vcpu_load() would break it.
2061         */
2062        if (ioctl == KVM_S390_INTERRUPT || ioctl == KVM_INTERRUPT)
2063                return kvm_arch_vcpu_ioctl(filp, ioctl, arg);
2064#endif
2065
2066
2067        r = vcpu_load(vcpu);
2068        if (r)
2069                return r;
2070        switch (ioctl) {
2071        case KVM_RUN:
2072                r = -EINVAL;
2073                if (arg)
2074                        goto out;
2075                r = kvm_arch_vcpu_ioctl_run(vcpu, vcpu->run);
2076                trace_kvm_userspace_exit(vcpu->run->exit_reason, r);
2077                break;
2078        case KVM_GET_REGS: {
2079                struct kvm_regs *kvm_regs;
2080
2081                r = -ENOMEM;
2082                kvm_regs = kzalloc(sizeof(struct kvm_regs), GFP_KERNEL);
2083                if (!kvm_regs)
2084                        goto out;
2085                r = kvm_arch_vcpu_ioctl_get_regs(vcpu, kvm_regs);
2086                if (r)
2087                        goto out_free1;
2088                r = -EFAULT;
2089                if (copy_to_user(argp, kvm_regs, sizeof(struct kvm_regs)))
2090                        goto out_free1;
2091                r = 0;
2092out_free1:
2093                kfree(kvm_regs);
2094                break;
2095        }
2096        case KVM_SET_REGS: {
2097                struct kvm_regs *kvm_regs;
2098
2099                r = -ENOMEM;
2100                kvm_regs = memdup_user(argp, sizeof(*kvm_regs));
2101                if (IS_ERR(kvm_regs)) {
2102                        r = PTR_ERR(kvm_regs);
2103                        goto out;
2104                }
2105                r = kvm_arch_vcpu_ioctl_set_regs(vcpu, kvm_regs);
2106                kfree(kvm_regs);
2107                break;
2108        }
2109        case KVM_GET_SREGS: {
2110                kvm_sregs = kzalloc(sizeof(struct kvm_sregs), GFP_KERNEL);
2111                r = -ENOMEM;
2112                if (!kvm_sregs)
2113                        goto out;
2114                r = kvm_arch_vcpu_ioctl_get_sregs(vcpu, kvm_sregs);
2115                if (r)
2116                        goto out;
2117                r = -EFAULT;
2118                if (copy_to_user(argp, kvm_sregs, sizeof(struct kvm_sregs)))
2119                        goto out;
2120                r = 0;
2121                break;
2122        }
2123        case KVM_SET_SREGS: {
2124                kvm_sregs = memdup_user(argp, sizeof(*kvm_sregs));
2125                if (IS_ERR(kvm_sregs)) {
2126                        r = PTR_ERR(kvm_sregs);
2127                        kvm_sregs = NULL;
2128                        goto out;
2129                }
2130                r = kvm_arch_vcpu_ioctl_set_sregs(vcpu, kvm_sregs);
2131                break;
2132        }
2133        case KVM_GET_MP_STATE: {
2134                struct kvm_mp_state mp_state;
2135
2136                r = kvm_arch_vcpu_ioctl_get_mpstate(vcpu, &mp_state);
2137                if (r)
2138                        goto out;
2139                r = -EFAULT;
2140                if (copy_to_user(argp, &mp_state, sizeof mp_state))
2141                        goto out;
2142                r = 0;
2143                break;
2144        }
2145        case KVM_SET_MP_STATE: {
2146                struct kvm_mp_state mp_state;
2147
2148                r = -EFAULT;
2149                if (copy_from_user(&mp_state, argp, sizeof mp_state))
2150                        goto out;
2151                r = kvm_arch_vcpu_ioctl_set_mpstate(vcpu, &mp_state);
2152                break;
2153        }
2154        case KVM_TRANSLATE: {
2155                struct kvm_translation tr;
2156
2157                r = -EFAULT;
2158                if (copy_from_user(&tr, argp, sizeof tr))
2159                        goto out;
2160                r = kvm_arch_vcpu_ioctl_translate(vcpu, &tr);
2161                if (r)
2162                        goto out;
2163                r = -EFAULT;
2164                if (copy_to_user(argp, &tr, sizeof tr))
2165                        goto out;
2166                r = 0;
2167                break;
2168        }
2169        case KVM_SET_GUEST_DEBUG: {
2170                struct kvm_guest_debug dbg;
2171
2172                r = -EFAULT;
2173                if (copy_from_user(&dbg, argp, sizeof dbg))
2174                        goto out;
2175                r = kvm_arch_vcpu_ioctl_set_guest_debug(vcpu, &dbg);
2176                break;
2177        }
2178        case KVM_SET_SIGNAL_MASK: {
2179                struct kvm_signal_mask __user *sigmask_arg = argp;
2180                struct kvm_signal_mask kvm_sigmask;
2181                sigset_t sigset, *p;
2182
2183                p = NULL;
2184                if (argp) {
2185                        r = -EFAULT;
2186                        if (copy_from_user(&kvm_sigmask, argp,
2187                                           sizeof kvm_sigmask))
2188                                goto out;
2189                        r = -EINVAL;
2190                        if (kvm_sigmask.len != sizeof sigset)
2191                                goto out;
2192                        r = -EFAULT;
2193                        if (copy_from_user(&sigset, sigmask_arg->sigset,
2194                                           sizeof sigset))
2195                                goto out;
2196                        p = &sigset;
2197                }
2198                r = kvm_vcpu_ioctl_set_sigmask(vcpu, p);
2199                break;
2200        }
2201        case KVM_GET_FPU: {
2202                fpu = kzalloc(sizeof(struct kvm_fpu), GFP_KERNEL);
2203                r = -ENOMEM;
2204                if (!fpu)
2205                        goto out;
2206                r = kvm_arch_vcpu_ioctl_get_fpu(vcpu, fpu);
2207                if (r)
2208                        goto out;
2209                r = -EFAULT;
2210                if (copy_to_user(argp, fpu, sizeof(struct kvm_fpu)))
2211                        goto out;
2212                r = 0;
2213                break;
2214        }
2215        case KVM_SET_FPU: {
2216                fpu = memdup_user(argp, sizeof(*fpu));
2217                if (IS_ERR(fpu)) {
2218                        r = PTR_ERR(fpu);
2219                        fpu = NULL;
2220                        goto out;
2221                }
2222                r = kvm_arch_vcpu_ioctl_set_fpu(vcpu, fpu);
2223                break;
2224        }
2225        default:
2226                r = kvm_arch_vcpu_ioctl(filp, ioctl, arg);
2227        }
2228out:
2229        vcpu_put(vcpu);
2230        kfree(fpu);
2231        kfree(kvm_sregs);
2232        return r;
2233}
2234
2235#ifdef CONFIG_COMPAT
2236static long kvm_vcpu_compat_ioctl(struct file *filp,
2237                                  unsigned int ioctl, unsigned long arg)
2238{
2239        struct kvm_vcpu *vcpu = filp->private_data;
2240        void __user *argp = compat_ptr(arg);
2241        int r;
2242
2243        if (vcpu->kvm->mm != current->mm)
2244                return -EIO;
2245
2246        switch (ioctl) {
2247        case KVM_SET_SIGNAL_MASK: {
2248                struct kvm_signal_mask __user *sigmask_arg = argp;
2249                struct kvm_signal_mask kvm_sigmask;
2250                compat_sigset_t csigset;
2251                sigset_t sigset;
2252
2253                if (argp) {
2254                        r = -EFAULT;
2255                        if (copy_from_user(&kvm_sigmask, argp,
2256                                           sizeof kvm_sigmask))
2257                                goto out;
2258                        r = -EINVAL;
2259                        if (kvm_sigmask.len != sizeof csigset)
2260                                goto out;
2261                        r = -EFAULT;
2262                        if (copy_from_user(&csigset, sigmask_arg->sigset,
2263                                           sizeof csigset))
2264                                goto out;
2265                        sigset_from_compat(&sigset, &csigset);
2266                        r = kvm_vcpu_ioctl_set_sigmask(vcpu, &sigset);
2267                } else
2268                        r = kvm_vcpu_ioctl_set_sigmask(vcpu, NULL);
2269                break;
2270        }
2271        default:
2272                r = kvm_vcpu_ioctl(filp, ioctl, arg);
2273        }
2274
2275out:
2276        return r;
2277}
2278#endif
2279
2280static int kvm_device_ioctl_attr(struct kvm_device *dev,
2281                                 int (*accessor)(struct kvm_device *dev,
2282                                                 struct kvm_device_attr *attr),
2283                                 unsigned long arg)
2284{
2285        struct kvm_device_attr attr;
2286
2287        if (!accessor)
2288                return -EPERM;
2289
2290        if (copy_from_user(&attr, (void __user *)arg, sizeof(attr)))
2291                return -EFAULT;
2292
2293        return accessor(dev, &attr);
2294}
2295
2296static long kvm_device_ioctl(struct file *filp, unsigned int ioctl,
2297                             unsigned long arg)
2298{
2299        struct kvm_device *dev = filp->private_data;
2300
2301        switch (ioctl) {
2302        case KVM_SET_DEVICE_ATTR:
2303                return kvm_device_ioctl_attr(dev, dev->ops->set_attr, arg);
2304        case KVM_GET_DEVICE_ATTR:
2305                return kvm_device_ioctl_attr(dev, dev->ops->get_attr, arg);
2306        case KVM_HAS_DEVICE_ATTR:
2307                return kvm_device_ioctl_attr(dev, dev->ops->has_attr, arg);
2308        default:
2309                if (dev->ops->ioctl)
2310                        return dev->ops->ioctl(dev, ioctl, arg);
2311
2312                return -ENOTTY;
2313        }
2314}
2315
2316static int kvm_device_release(struct inode *inode, struct file *filp)
2317{
2318        struct kvm_device *dev = filp->private_data;
2319        struct kvm *kvm = dev->kvm;
2320
2321        kvm_put_kvm(kvm);
2322        return 0;
2323}
2324
2325static const struct file_operations kvm_device_fops = {
2326        .unlocked_ioctl = kvm_device_ioctl,
2327#ifdef CONFIG_COMPAT
2328        .compat_ioctl = kvm_device_ioctl,
2329#endif
2330        .release = kvm_device_release,
2331};
2332
2333struct kvm_device *kvm_device_from_filp(struct file *filp)
2334{
2335        if (filp->f_op != &kvm_device_fops)
2336                return NULL;
2337
2338        return filp->private_data;
2339}
2340
2341static struct kvm_device_ops *kvm_device_ops_table[KVM_DEV_TYPE_MAX] = {
2342#ifdef CONFIG_KVM_MPIC
2343        [KVM_DEV_TYPE_FSL_MPIC_20]      = &kvm_mpic_ops,
2344        [KVM_DEV_TYPE_FSL_MPIC_42]      = &kvm_mpic_ops,
2345#endif
2346
2347#ifdef CONFIG_KVM_XICS
2348        [KVM_DEV_TYPE_XICS]             = &kvm_xics_ops,
2349#endif
2350};
2351
2352int kvm_register_device_ops(struct kvm_device_ops *ops, u32 type)
2353{
2354        if (type >= ARRAY_SIZE(kvm_device_ops_table))
2355                return -ENOSPC;
2356
2357        if (kvm_device_ops_table[type] != NULL)
2358                return -EEXIST;
2359
2360        kvm_device_ops_table[type] = ops;
2361        return 0;
2362}
2363
2364void kvm_unregister_device_ops(u32 type)
2365{
2366        if (kvm_device_ops_table[type] != NULL)
2367                kvm_device_ops_table[type] = NULL;
2368}
2369
2370static int kvm_ioctl_create_device(struct kvm *kvm,
2371                                   struct kvm_create_device *cd)
2372{
2373        struct kvm_device_ops *ops = NULL;
2374        struct kvm_device *dev;
2375        bool test = cd->flags & KVM_CREATE_DEVICE_TEST;
2376        int ret;
2377
2378        if (cd->type >= ARRAY_SIZE(kvm_device_ops_table))
2379                return -ENODEV;
2380
2381        ops = kvm_device_ops_table[cd->type];
2382        if (ops == NULL)
2383                return -ENODEV;
2384
2385        if (test)
2386                return 0;
2387
2388        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2389        if (!dev)
2390                return -ENOMEM;
2391
2392        dev->ops = ops;
2393        dev->kvm = kvm;
2394
2395        ret = ops->create(dev, cd->type);
2396        if (ret < 0) {
2397                kfree(dev);
2398                return ret;
2399        }
2400
2401        ret = anon_inode_getfd(ops->name, &kvm_device_fops, dev, O_RDWR | O_CLOEXEC);
2402        if (ret < 0) {
2403                ops->destroy(dev);
2404                return ret;
2405        }
2406
2407        list_add(&dev->vm_node, &kvm->devices);
2408        kvm_get_kvm(kvm);
2409        cd->fd = ret;
2410        return 0;
2411}
2412
2413static long kvm_vm_ioctl_check_extension_generic(struct kvm *kvm, long arg)
2414{
2415        switch (arg) {
2416        case KVM_CAP_USER_MEMORY:
2417        case KVM_CAP_DESTROY_MEMORY_REGION_WORKS:
2418        case KVM_CAP_JOIN_MEMORY_REGIONS_WORKS:
2419#ifdef CONFIG_KVM_APIC_ARCHITECTURE
2420        case KVM_CAP_SET_BOOT_CPU_ID:
2421#endif
2422        case KVM_CAP_INTERNAL_ERROR_DATA:
2423#ifdef CONFIG_HAVE_KVM_MSI
2424        case KVM_CAP_SIGNAL_MSI:
2425#endif
2426#ifdef CONFIG_HAVE_KVM_IRQFD
2427        case KVM_CAP_IRQFD:
2428        case KVM_CAP_IRQFD_RESAMPLE:
2429#endif
2430        case KVM_CAP_CHECK_EXTENSION_VM:
2431                return 1;
2432#ifdef CONFIG_HAVE_KVM_IRQ_ROUTING
2433        case KVM_CAP_IRQ_ROUTING:
2434                return KVM_MAX_IRQ_ROUTES;
2435#endif
2436        default:
2437                break;
2438        }
2439        return kvm_vm_ioctl_check_extension(kvm, arg);
2440}
2441
2442static long kvm_vm_ioctl(struct file *filp,
2443                           unsigned int ioctl, unsigned long arg)
2444{
2445        struct kvm *kvm = filp->private_data;
2446        void __user *argp = (void __user *)arg;
2447        int r;
2448
2449        if (kvm->mm != current->mm)
2450                return -EIO;
2451        switch (ioctl) {
2452        case KVM_CREATE_VCPU:
2453                r = kvm_vm_ioctl_create_vcpu(kvm, arg);
2454                break;
2455        case KVM_SET_USER_MEMORY_REGION: {
2456                struct kvm_userspace_memory_region kvm_userspace_mem;
2457
2458                r = -EFAULT;
2459                if (copy_from_user(&kvm_userspace_mem, argp,
2460                                                sizeof kvm_userspace_mem))
2461                        goto out;
2462
2463                r = kvm_vm_ioctl_set_memory_region(kvm, &kvm_userspace_mem);
2464                break;
2465        }
2466        case KVM_GET_DIRTY_LOG: {
2467                struct kvm_dirty_log log;
2468
2469                r = -EFAULT;
2470                if (copy_from_user(&log, argp, sizeof log))
2471                        goto out;
2472                r = kvm_vm_ioctl_get_dirty_log(kvm, &log);
2473                break;
2474        }
2475#ifdef KVM_COALESCED_MMIO_PAGE_OFFSET
2476        case KVM_REGISTER_COALESCED_MMIO: {
2477                struct kvm_coalesced_mmio_zone zone;
2478                r = -EFAULT;
2479                if (copy_from_user(&zone, argp, sizeof zone))
2480                        goto out;
2481                r = kvm_vm_ioctl_register_coalesced_mmio(kvm, &zone);
2482                break;
2483        }
2484        case KVM_UNREGISTER_COALESCED_MMIO: {
2485                struct kvm_coalesced_mmio_zone zone;
2486                r = -EFAULT;
2487                if (copy_from_user(&zone, argp, sizeof zone))
2488                        goto out;
2489                r = kvm_vm_ioctl_unregister_coalesced_mmio(kvm, &zone);
2490                break;
2491        }
2492#endif
2493        case KVM_IRQFD: {
2494                struct kvm_irqfd data;
2495
2496                r = -EFAULT;
2497                if (copy_from_user(&data, argp, sizeof data))
2498                        goto out;
2499                r = kvm_irqfd(kvm, &data);
2500                break;
2501        }
2502        case KVM_IOEVENTFD: {
2503                struct kvm_ioeventfd data;
2504
2505                r = -EFAULT;
2506                if (copy_from_user(&data, argp, sizeof data))
2507                        goto out;
2508                r = kvm_ioeventfd(kvm, &data);
2509                break;
2510        }
2511#ifdef CONFIG_KVM_APIC_ARCHITECTURE
2512        case KVM_SET_BOOT_CPU_ID:
2513                r = 0;
2514                mutex_lock(&kvm->lock);
2515                if (atomic_read(&kvm->online_vcpus) != 0)
2516                        r = -EBUSY;
2517                else
2518                        kvm->bsp_vcpu_id = arg;
2519                mutex_unlock(&kvm->lock);
2520                break;
2521#endif
2522#ifdef CONFIG_HAVE_KVM_MSI
2523        case KVM_SIGNAL_MSI: {
2524                struct kvm_msi msi;
2525
2526                r = -EFAULT;
2527                if (copy_from_user(&msi, argp, sizeof msi))
2528                        goto out;
2529                r = kvm_send_userspace_msi(kvm, &msi);
2530                break;
2531        }
2532#endif
2533#ifdef __KVM_HAVE_IRQ_LINE
2534        case KVM_IRQ_LINE_STATUS:
2535        case KVM_IRQ_LINE: {
2536                struct kvm_irq_level irq_event;
2537
2538                r = -EFAULT;
2539                if (copy_from_user(&irq_event, argp, sizeof irq_event))
2540                        goto out;
2541
2542                r = kvm_vm_ioctl_irq_line(kvm, &irq_event,
2543                                        ioctl == KVM_IRQ_LINE_STATUS);
2544                if (r)
2545                        goto out;
2546
2547                r = -EFAULT;
2548                if (ioctl == KVM_IRQ_LINE_STATUS) {
2549                        if (copy_to_user(argp, &irq_event, sizeof irq_event))
2550                                goto out;
2551                }
2552
2553                r = 0;
2554                break;
2555        }
2556#endif
2557#ifdef CONFIG_HAVE_KVM_IRQ_ROUTING
2558        case KVM_SET_GSI_ROUTING: {
2559                struct kvm_irq_routing routing;
2560                struct kvm_irq_routing __user *urouting;
2561                struct kvm_irq_routing_entry *entries;
2562
2563                r = -EFAULT;
2564                if (copy_from_user(&routing, argp, sizeof(routing)))
2565                        goto out;
2566                r = -EINVAL;
2567                if (routing.nr > KVM_MAX_IRQ_ROUTES)
2568                        goto out;
2569                if (routing.flags)
2570                        goto out;
2571                r = -ENOMEM;
2572                entries = vmalloc(routing.nr * sizeof(*entries));
2573                if (!entries)
2574                        goto out;
2575                r = -EFAULT;
2576                urouting = argp;
2577                if (copy_from_user(entries, urouting->entries,
2578                                   routing.nr * sizeof(*entries)))
2579                        goto out_free_irq_routing;
2580                r = kvm_set_irq_routing(kvm, entries, routing.nr,
2581                                        routing.flags);
2582        out_free_irq_routing:
2583                vfree(entries);
2584                break;
2585        }
2586#endif /* CONFIG_HAVE_KVM_IRQ_ROUTING */
2587        case KVM_CREATE_DEVICE: {
2588                struct kvm_create_device cd;
2589
2590                r = -EFAULT;
2591                if (copy_from_user(&cd, argp, sizeof(cd)))
2592                        goto out;
2593
2594                r = kvm_ioctl_create_device(kvm, &cd);
2595                if (r)
2596                        goto out;
2597
2598                r = -EFAULT;
2599                if (copy_to_user(argp, &cd, sizeof(cd)))
2600                        goto out;
2601
2602                r = 0;
2603                break;
2604        }
2605        case KVM_CHECK_EXTENSION:
2606                r = kvm_vm_ioctl_check_extension_generic(kvm, arg);
2607                break;
2608        default:
2609                r = kvm_arch_vm_ioctl(filp, ioctl, arg);
2610                if (r == -ENOTTY)
2611                        r = kvm_vm_ioctl_assigned_device(kvm, ioctl, arg);
2612        }
2613out:
2614        return r;
2615}
2616
2617#ifdef CONFIG_COMPAT
2618struct compat_kvm_dirty_log {
2619        __u32 slot;
2620        __u32 padding1;
2621        union {
2622                compat_uptr_t dirty_bitmap; /* one bit per page */
2623                __u64 padding2;
2624        };
2625};
2626
2627static long kvm_vm_compat_ioctl(struct file *filp,
2628                           unsigned int ioctl, unsigned long arg)
2629{
2630        struct kvm *kvm = filp->private_data;
2631        int r;
2632
2633        if (kvm->mm != current->mm)
2634                return -EIO;
2635        switch (ioctl) {
2636        case KVM_GET_DIRTY_LOG: {
2637                struct compat_kvm_dirty_log compat_log;
2638                struct kvm_dirty_log log;
2639
2640                r = -EFAULT;
2641                if (copy_from_user(&compat_log, (void __user *)arg,
2642                                   sizeof(compat_log)))
2643                        goto out;
2644                log.slot         = compat_log.slot;
2645                log.padding1     = compat_log.padding1;
2646                log.padding2     = compat_log.padding2;
2647                log.dirty_bitmap = compat_ptr(compat_log.dirty_bitmap);
2648
2649                r = kvm_vm_ioctl_get_dirty_log(kvm, &log);
2650                break;
2651        }
2652        default:
2653                r = kvm_vm_ioctl(filp, ioctl, arg);
2654        }
2655
2656out:
2657        return r;
2658}
2659#endif
2660
2661static struct file_operations kvm_vm_fops = {
2662        .release        = kvm_vm_release,
2663        .unlocked_ioctl = kvm_vm_ioctl,
2664#ifdef CONFIG_COMPAT
2665        .compat_ioctl   = kvm_vm_compat_ioctl,
2666#endif
2667        .llseek         = noop_llseek,
2668};
2669
2670static int kvm_dev_ioctl_create_vm(unsigned long type)
2671{
2672        int r;
2673        struct kvm *kvm;
2674
2675        kvm = kvm_create_vm(type);
2676        if (IS_ERR(kvm))
2677                return PTR_ERR(kvm);
2678#ifdef KVM_COALESCED_MMIO_PAGE_OFFSET
2679        r = kvm_coalesced_mmio_init(kvm);
2680        if (r < 0) {
2681                kvm_put_kvm(kvm);
2682                return r;
2683        }
2684#endif
2685        r = anon_inode_getfd("kvm-vm", &kvm_vm_fops, kvm, O_RDWR | O_CLOEXEC);
2686        if (r < 0)
2687                kvm_put_kvm(kvm);
2688
2689        return r;
2690}
2691
2692static long kvm_dev_ioctl(struct file *filp,
2693                          unsigned int ioctl, unsigned long arg)
2694{
2695        long r = -EINVAL;
2696
2697        switch (ioctl) {
2698        case KVM_GET_API_VERSION:
2699                if (arg)
2700                        goto out;
2701                r = KVM_API_VERSION;
2702                break;
2703        case KVM_CREATE_VM:
2704                r = kvm_dev_ioctl_create_vm(arg);
2705                break;
2706        case KVM_CHECK_EXTENSION:
2707                r = kvm_vm_ioctl_check_extension_generic(NULL, arg);
2708                break;
2709        case KVM_GET_VCPU_MMAP_SIZE:
2710                if (arg)
2711                        goto out;
2712                r = PAGE_SIZE;     /* struct kvm_run */
2713#ifdef CONFIG_X86
2714                r += PAGE_SIZE;    /* pio data page */
2715#endif
2716#ifdef KVM_COALESCED_MMIO_PAGE_OFFSET
2717                r += PAGE_SIZE;    /* coalesced mmio ring page */
2718#endif
2719                break;
2720        case KVM_TRACE_ENABLE:
2721        case KVM_TRACE_PAUSE:
2722        case KVM_TRACE_DISABLE:
2723                r = -EOPNOTSUPP;
2724                break;
2725        default:
2726                return kvm_arch_dev_ioctl(filp, ioctl, arg);
2727        }
2728out:
2729        return r;
2730}
2731
2732static struct file_operations kvm_chardev_ops = {
2733        .unlocked_ioctl = kvm_dev_ioctl,
2734        .compat_ioctl   = kvm_dev_ioctl,
2735        .llseek         = noop_llseek,
2736};
2737
2738static struct miscdevice kvm_dev = {
2739        KVM_MINOR,
2740        "kvm",
2741        &kvm_chardev_ops,
2742};
2743
2744static void hardware_enable_nolock(void *junk)
2745{
2746        int cpu = raw_smp_processor_id();
2747        int r;
2748
2749        if (cpumask_test_cpu(cpu, cpus_hardware_enabled))
2750                return;
2751
2752        cpumask_set_cpu(cpu, cpus_hardware_enabled);
2753
2754        r = kvm_arch_hardware_enable();
2755
2756        if (r) {
2757                cpumask_clear_cpu(cpu, cpus_hardware_enabled);
2758                atomic_inc(&hardware_enable_failed);
2759                printk(KERN_INFO "kvm: enabling virtualization on "
2760                                 "CPU%d failed\n", cpu);
2761        }
2762}
2763
2764static void hardware_enable(void)
2765{
2766        raw_spin_lock(&kvm_count_lock);
2767        if (kvm_usage_count)
2768                hardware_enable_nolock(NULL);
2769        raw_spin_unlock(&kvm_count_lock);
2770}
2771
2772static void hardware_disable_nolock(void *junk)
2773{
2774        int cpu = raw_smp_processor_id();
2775
2776        if (!cpumask_test_cpu(cpu, cpus_hardware_enabled))
2777                return;
2778        cpumask_clear_cpu(cpu, cpus_hardware_enabled);
2779        kvm_arch_hardware_disable();
2780}
2781
2782static void hardware_disable(void)
2783{
2784        raw_spin_lock(&kvm_count_lock);
2785        if (kvm_usage_count)
2786                hardware_disable_nolock(NULL);
2787        raw_spin_unlock(&kvm_count_lock);
2788}
2789
2790static void hardware_disable_all_nolock(void)
2791{
2792        BUG_ON(!kvm_usage_count);
2793
2794        kvm_usage_count--;
2795        if (!kvm_usage_count)
2796                on_each_cpu(hardware_disable_nolock, NULL, 1);
2797}
2798
2799static void hardware_disable_all(void)
2800{
2801        raw_spin_lock(&kvm_count_lock);
2802        hardware_disable_all_nolock();
2803        raw_spin_unlock(&kvm_count_lock);
2804}
2805
2806static int hardware_enable_all(void)
2807{
2808        int r = 0;
2809
2810        raw_spin_lock(&kvm_count_lock);
2811
2812        kvm_usage_count++;
2813        if (kvm_usage_count == 1) {
2814                atomic_set(&hardware_enable_failed, 0);
2815                on_each_cpu(hardware_enable_nolock, NULL, 1);
2816
2817                if (atomic_read(&hardware_enable_failed)) {
2818                        hardware_disable_all_nolock();
2819                        r = -EBUSY;
2820                }
2821        }
2822
2823        raw_spin_unlock(&kvm_count_lock);
2824
2825        return r;
2826}
2827
2828static int kvm_cpu_hotplug(struct notifier_block *notifier, unsigned long val,
2829                           void *v)
2830{
2831        int cpu = (long)v;
2832
2833        val &= ~CPU_TASKS_FROZEN;
2834        switch (val) {
2835        case CPU_DYING:
2836                printk(KERN_INFO "kvm: disabling virtualization on CPU%d\n",
2837                       cpu);
2838                hardware_disable();
2839                break;
2840        case CPU_STARTING:
2841                printk(KERN_INFO "kvm: enabling virtualization on CPU%d\n",
2842                       cpu);
2843                hardware_enable();
2844                break;
2845        }
2846        return NOTIFY_OK;
2847}
2848
2849static int kvm_reboot(struct notifier_block *notifier, unsigned long val,
2850                      void *v)
2851{
2852        /*
2853         * Some (well, at least mine) BIOSes hang on reboot if
2854         * in vmx root mode.
2855         *
2856         * And Intel TXT required VMX off for all cpu when system shutdown.
2857         */
2858        printk(KERN_INFO "kvm: exiting hardware virtualization\n");
2859        kvm_rebooting = true;
2860        on_each_cpu(hardware_disable_nolock, NULL, 1);
2861        return NOTIFY_OK;
2862}
2863
2864static struct notifier_block kvm_reboot_notifier = {
2865        .notifier_call = kvm_reboot,
2866        .priority = 0,
2867};
2868
2869static void kvm_io_bus_destroy(struct kvm_io_bus *bus)
2870{
2871        int i;
2872
2873        for (i = 0; i < bus->dev_count; i++) {
2874                struct kvm_io_device *pos = bus->range[i].dev;
2875
2876                kvm_iodevice_destructor(pos);
2877        }
2878        kfree(bus);
2879}
2880
2881static inline int kvm_io_bus_cmp(const struct kvm_io_range *r1,
2882                                 const struct kvm_io_range *r2)
2883{
2884        gpa_t addr1 = r1->addr;
2885        gpa_t addr2 = r2->addr;
2886
2887        if (addr1 < addr2)
2888                return -1;
2889
2890        /* If r2->len == 0, match the exact address.  If r2->len != 0,
2891         * accept any overlapping write.  Any order is acceptable for
2892         * overlapping ranges, because kvm_io_bus_get_first_dev ensures
2893         * we process all of them.
2894         */
2895        if (r2->len) {
2896                addr1 += r1->len;
2897                addr2 += r2->len;
2898        }
2899
2900        if (addr1 > addr2)
2901                return 1;
2902
2903        return 0;
2904}
2905
2906static int kvm_io_bus_sort_cmp(const void *p1, const void *p2)
2907{
2908        return kvm_io_bus_cmp(p1, p2);
2909}
2910
2911static int kvm_io_bus_insert_dev(struct kvm_io_bus *bus, struct kvm_io_device *dev,
2912                          gpa_t addr, int len)
2913{
2914        bus->range[bus->dev_count++] = (struct kvm_io_range) {
2915                .addr = addr,
2916                .len = len,
2917                .dev = dev,
2918        };
2919
2920        sort(bus->range, bus->dev_count, sizeof(struct kvm_io_range),
2921                kvm_io_bus_sort_cmp, NULL);
2922
2923        return 0;
2924}
2925
2926static int kvm_io_bus_get_first_dev(struct kvm_io_bus *bus,
2927                             gpa_t addr, int len)
2928{
2929        struct kvm_io_range *range, key;
2930        int off;
2931
2932        key = (struct kvm_io_range) {
2933                .addr = addr,
2934                .len = len,
2935        };
2936
2937        range = bsearch(&key, bus->range, bus->dev_count,
2938                        sizeof(struct kvm_io_range), kvm_io_bus_sort_cmp);
2939        if (range == NULL)
2940                return -ENOENT;
2941
2942        off = range - bus->range;
2943
2944        while (off > 0 && kvm_io_bus_cmp(&key, &bus->range[off-1]) == 0)
2945                off--;
2946
2947        return off;
2948}
2949
2950static int __kvm_io_bus_write(struct kvm_io_bus *bus,
2951                              struct kvm_io_range *range, const void *val)
2952{
2953        int idx;
2954
2955        idx = kvm_io_bus_get_first_dev(bus, range->addr, range->len);
2956        if (idx < 0)
2957                return -EOPNOTSUPP;
2958
2959        while (idx < bus->dev_count &&
2960                kvm_io_bus_cmp(range, &bus->range[idx]) == 0) {
2961                if (!kvm_iodevice_write(bus->range[idx].dev, range->addr,
2962                                        range->len, val))
2963                        return idx;
2964                idx++;
2965        }
2966
2967        return -EOPNOTSUPP;
2968}
2969
2970/* kvm_io_bus_write - called under kvm->slots_lock */
2971int kvm_io_bus_write(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
2972                     int len, const void *val)
2973{
2974        struct kvm_io_bus *bus;
2975        struct kvm_io_range range;
2976        int r;
2977
2978        range = (struct kvm_io_range) {
2979                .addr = addr,
2980                .len = len,
2981        };
2982
2983        bus = srcu_dereference(kvm->buses[bus_idx], &kvm->srcu);
2984        if (!bus)
2985                return -ENOMEM;
2986        r = __kvm_io_bus_write(bus, &range, val);
2987        return r < 0 ? r : 0;
2988}
2989
2990/* kvm_io_bus_write_cookie - called under kvm->slots_lock */
2991int kvm_io_bus_write_cookie(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
2992                            int len, const void *val, long cookie)
2993{
2994        struct kvm_io_bus *bus;
2995        struct kvm_io_range range;
2996
2997        range = (struct kvm_io_range) {
2998                .addr = addr,
2999                .len = len,
3000        };
3001
3002        bus = srcu_dereference(kvm->buses[bus_idx], &kvm->srcu);
3003        if (!bus)
3004                return -ENOMEM;
3005
3006        /* First try the device referenced by cookie. */
3007        if ((cookie >= 0) && (cookie < bus->dev_count) &&
3008            (kvm_io_bus_cmp(&range, &bus->range[cookie]) == 0))
3009                if (!kvm_iodevice_write(bus->range[cookie].dev, addr, len,
3010                                        val))
3011                        return cookie;
3012
3013        /*
3014         * cookie contained garbage; fall back to search and return the
3015         * correct cookie value.
3016         */
3017        return __kvm_io_bus_write(bus, &range, val);
3018}
3019
3020static int __kvm_io_bus_read(struct kvm_io_bus *bus, struct kvm_io_range *range,
3021                             void *val)
3022{
3023        int idx;
3024
3025        idx = kvm_io_bus_get_first_dev(bus, range->addr, range->len);
3026        if (idx < 0)
3027                return -EOPNOTSUPP;
3028
3029        while (idx < bus->dev_count &&
3030                kvm_io_bus_cmp(range, &bus->range[idx]) == 0) {
3031                if (!kvm_iodevice_read(bus->range[idx].dev, range->addr,
3032                                       range->len, val))
3033                        return idx;
3034                idx++;
3035        }
3036
3037        return -EOPNOTSUPP;
3038}
3039EXPORT_SYMBOL_GPL(kvm_io_bus_write);
3040
3041/* kvm_io_bus_read - called under kvm->slots_lock */
3042int kvm_io_bus_read(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
3043                    int len, void *val)
3044{
3045        struct kvm_io_bus *bus;
3046        struct kvm_io_range range;
3047        int r;
3048
3049        range = (struct kvm_io_range) {
3050                .addr = addr,
3051                .len = len,
3052        };
3053
3054        bus = srcu_dereference(kvm->buses[bus_idx], &kvm->srcu);
3055        if (!bus)
3056                return -ENOMEM;
3057        r = __kvm_io_bus_read(bus, &range, val);
3058        return r < 0 ? r : 0;
3059}
3060
3061
3062/* Caller must hold slots_lock. */
3063int kvm_io_bus_register_dev(struct kvm *kvm, enum kvm_bus bus_idx, gpa_t addr,
3064                            int len, struct kvm_io_device *dev)
3065{
3066        struct kvm_io_bus *new_bus, *bus;
3067
3068        bus = kvm->buses[bus_idx];
3069        if (!bus)
3070                return -ENOMEM;
3071
3072        /* exclude ioeventfd which is limited by maximum fd */
3073        if (bus->dev_count - bus->ioeventfd_count > NR_IOBUS_DEVS - 1)
3074                return -ENOSPC;
3075
3076        new_bus = kzalloc(sizeof(*bus) + ((bus->dev_count + 1) *
3077                          sizeof(struct kvm_io_range)), GFP_KERNEL);
3078        if (!new_bus)
3079                return -ENOMEM;
3080        memcpy(new_bus, bus, sizeof(*bus) + (bus->dev_count *
3081               sizeof(struct kvm_io_range)));
3082        kvm_io_bus_insert_dev(new_bus, dev, addr, len);
3083        rcu_assign_pointer(kvm->buses[bus_idx], new_bus);
3084        synchronize_srcu_expedited(&kvm->srcu);
3085        kfree(bus);
3086
3087        return 0;
3088}
3089
3090/* Caller must hold slots_lock. */
3091void kvm_io_bus_unregister_dev(struct kvm *kvm, enum kvm_bus bus_idx,
3092                               struct kvm_io_device *dev)
3093{
3094        int i;
3095        struct kvm_io_bus *new_bus, *bus;
3096
3097        bus = kvm->buses[bus_idx];
3098        if (!bus)
3099                return;
3100
3101        for (i = 0; i < bus->dev_count; i++)
3102                if (bus->range[i].dev == dev) {
3103                        break;
3104                }
3105
3106        if (i == bus->dev_count)
3107                return;
3108
3109        new_bus = kzalloc(sizeof(*bus) + ((bus->dev_count - 1) *
3110                          sizeof(struct kvm_io_range)), GFP_KERNEL);
3111        if (!new_bus)  {
3112                pr_err("kvm: failed to shrink bus, removing it completely\n");
3113                goto broken;
3114        }
3115
3116        memcpy(new_bus, bus, sizeof(*bus) + i * sizeof(struct kvm_io_range));
3117        new_bus->dev_count--;
3118        memcpy(new_bus->range + i, bus->range + i + 1,
3119               (new_bus->dev_count - i) * sizeof(struct kvm_io_range));
3120
3121broken:
3122        rcu_assign_pointer(kvm->buses[bus_idx], new_bus);
3123        synchronize_srcu_expedited(&kvm->srcu);
3124        kfree(bus);
3125        return;
3126}
3127
3128static struct notifier_block kvm_cpu_notifier = {
3129        .notifier_call = kvm_cpu_hotplug,
3130};
3131
3132static int vm_stat_get(void *_offset, u64 *val)
3133{
3134        unsigned offset = (long)_offset;
3135        struct kvm *kvm;
3136
3137        *val = 0;
3138        spin_lock(&kvm_lock);
3139        list_for_each_entry(kvm, &vm_list, vm_list)
3140                *val += *(u32 *)((void *)kvm + offset);
3141        spin_unlock(&kvm_lock);
3142        return 0;
3143}
3144
3145DEFINE_SIMPLE_ATTRIBUTE(vm_stat_fops, vm_stat_get, NULL, "%llu\n");
3146
3147static int vcpu_stat_get(void *_offset, u64 *val)
3148{
3149        unsigned offset = (long)_offset;
3150        struct kvm *kvm;
3151        struct kvm_vcpu *vcpu;
3152        int i;
3153
3154        *val = 0;
3155        spin_lock(&kvm_lock);
3156        list_for_each_entry(kvm, &vm_list, vm_list)
3157                kvm_for_each_vcpu(i, vcpu, kvm)
3158                        *val += *(u32 *)((void *)vcpu + offset);
3159
3160        spin_unlock(&kvm_lock);
3161        return 0;
3162}
3163
3164DEFINE_SIMPLE_ATTRIBUTE(vcpu_stat_fops, vcpu_stat_get, NULL, "%llu\n");
3165
3166static const struct file_operations *stat_fops[] = {
3167        [KVM_STAT_VCPU] = &vcpu_stat_fops,
3168        [KVM_STAT_VM]   = &vm_stat_fops,
3169};
3170
3171static int kvm_init_debug(void)
3172{
3173        int r = -EEXIST;
3174        struct kvm_stats_debugfs_item *p;
3175
3176        kvm_debugfs_dir = debugfs_create_dir("kvm", NULL);
3177        if (kvm_debugfs_dir == NULL)
3178                goto out;
3179
3180        for (p = debugfs_entries; p->name; ++p) {
3181                p->dentry = debugfs_create_file(p->name, 0444, kvm_debugfs_dir,
3182                                                (void *)(long)p->offset,
3183                                                stat_fops[p->kind]);
3184                if (p->dentry == NULL)
3185                        goto out_dir;
3186        }
3187
3188        return 0;
3189
3190out_dir:
3191        debugfs_remove_recursive(kvm_debugfs_dir);
3192out:
3193        return r;
3194}
3195
3196static void kvm_exit_debug(void)
3197{
3198        struct kvm_stats_debugfs_item *p;
3199
3200        for (p = debugfs_entries; p->name; ++p)
3201                debugfs_remove(p->dentry);
3202        debugfs_remove(kvm_debugfs_dir);
3203}
3204
3205static int kvm_suspend(void)
3206{
3207        if (kvm_usage_count)
3208                hardware_disable_nolock(NULL);
3209        return 0;
3210}
3211
3212static void kvm_resume(void)
3213{
3214        if (kvm_usage_count) {
3215                WARN_ON(raw_spin_is_locked(&kvm_count_lock));
3216                hardware_enable_nolock(NULL);
3217        }
3218}
3219
3220static struct syscore_ops kvm_syscore_ops = {
3221        .suspend = kvm_suspend,
3222        .resume = kvm_resume,
3223};
3224
3225static inline
3226struct kvm_vcpu *preempt_notifier_to_vcpu(struct preempt_notifier *pn)
3227{
3228        return container_of(pn, struct kvm_vcpu, preempt_notifier);
3229}
3230
3231static void kvm_sched_in(struct preempt_notifier *pn, int cpu)
3232{
3233        struct kvm_vcpu *vcpu = preempt_notifier_to_vcpu(pn);
3234        if (vcpu->preempted)
3235                vcpu->preempted = false;
3236
3237        kvm_arch_sched_in(vcpu, cpu);
3238
3239        kvm_arch_vcpu_load(vcpu, cpu);
3240}
3241
3242static void kvm_sched_out(struct preempt_notifier *pn,
3243                          struct task_struct *next)
3244{
3245        struct kvm_vcpu *vcpu = preempt_notifier_to_vcpu(pn);
3246
3247        if (current->state == TASK_RUNNING)
3248                vcpu->preempted = true;
3249        kvm_arch_vcpu_put(vcpu);
3250}
3251
3252int kvm_init(void *opaque, unsigned vcpu_size, unsigned vcpu_align,
3253                  struct module *module)
3254{
3255        int r;
3256        int cpu;
3257
3258        r = kvm_arch_init(opaque);
3259        if (r)
3260                goto out_fail;
3261
3262        /*
3263         * kvm_arch_init makes sure there's at most one caller
3264         * for architectures that support multiple implementations,
3265         * like intel and amd on x86.
3266         * kvm_arch_init must be called before kvm_irqfd_init to avoid creating
3267         * conflicts in case kvm is already setup for another implementation.
3268         */
3269        r = kvm_irqfd_init();
3270        if (r)
3271                goto out_irqfd;
3272
3273        if (!zalloc_cpumask_var(&cpus_hardware_enabled, GFP_KERNEL)) {
3274                r = -ENOMEM;
3275                goto out_free_0;
3276        }
3277
3278        r = kvm_arch_hardware_setup();
3279        if (r < 0)
3280                goto out_free_0a;
3281
3282        for_each_online_cpu(cpu) {
3283                smp_call_function_single(cpu,
3284                                kvm_arch_check_processor_compat,
3285                                &r, 1);
3286                if (r < 0)
3287                        goto out_free_1;
3288        }
3289
3290        r = register_cpu_notifier(&kvm_cpu_notifier);
3291        if (r)
3292                goto out_free_2;
3293        register_reboot_notifier(&kvm_reboot_notifier);
3294
3295        /* A kmem cache lets us meet the alignment requirements of fx_save. */
3296        if (!vcpu_align)
3297                vcpu_align = __alignof__(struct kvm_vcpu);
3298        kvm_vcpu_cache = kmem_cache_create("kvm_vcpu", vcpu_size, vcpu_align,
3299                                           0, NULL);
3300        if (!kvm_vcpu_cache) {
3301                r = -ENOMEM;
3302                goto out_free_3;
3303        }
3304
3305        r = kvm_async_pf_init();
3306        if (r)
3307                goto out_free;
3308
3309        kvm_chardev_ops.owner = module;
3310        kvm_vm_fops.owner = module;
3311        kvm_vcpu_fops.owner = module;
3312
3313        r = misc_register(&kvm_dev);
3314        if (r) {
3315                printk(KERN_ERR "kvm: misc device register failed\n");
3316                goto out_unreg;
3317        }
3318
3319        register_syscore_ops(&kvm_syscore_ops);
3320
3321        kvm_preempt_ops.sched_in = kvm_sched_in;
3322        kvm_preempt_ops.sched_out = kvm_sched_out;
3323
3324        r = kvm_init_debug();
3325        if (r) {
3326                printk(KERN_ERR "kvm: create debugfs files failed\n");
3327                goto out_undebugfs;
3328        }
3329
3330        r = kvm_vfio_ops_init();
3331        WARN_ON(r);
3332
3333        return 0;
3334
3335out_undebugfs:
3336        unregister_syscore_ops(&kvm_syscore_ops);
3337        misc_deregister(&kvm_dev);
3338out_unreg:
3339        kvm_async_pf_deinit();
3340out_free:
3341        kmem_cache_destroy(kvm_vcpu_cache);
3342out_free_3:
3343        unregister_reboot_notifier(&kvm_reboot_notifier);
3344        unregister_cpu_notifier(&kvm_cpu_notifier);
3345out_free_2:
3346out_free_1:
3347        kvm_arch_hardware_unsetup();
3348out_free_0a:
3349        free_cpumask_var(cpus_hardware_enabled);
3350out_free_0:
3351        kvm_irqfd_exit();
3352out_irqfd:
3353        kvm_arch_exit();
3354out_fail:
3355        return r;
3356}
3357EXPORT_SYMBOL_GPL(kvm_init);
3358
3359void kvm_exit(void)
3360{
3361        kvm_exit_debug();
3362        misc_deregister(&kvm_dev);
3363        kmem_cache_destroy(kvm_vcpu_cache);
3364        kvm_async_pf_deinit();
3365        unregister_syscore_ops(&kvm_syscore_ops);
3366        unregister_reboot_notifier(&kvm_reboot_notifier);
3367        unregister_cpu_notifier(&kvm_cpu_notifier);
3368        on_each_cpu(hardware_disable_nolock, NULL, 1);
3369        kvm_arch_hardware_unsetup();
3370        kvm_arch_exit();
3371        kvm_irqfd_exit();
3372        free_cpumask_var(cpus_hardware_enabled);
3373        kvm_vfio_ops_exit();
3374}
3375EXPORT_SYMBOL_GPL(kvm_exit);
Note: See TracBrowser for help on using the repository browser.