← Back to branch summary

~ubuntu-branches/ubuntu/hardy/kvm/hardy-backports

« back to all changes in this revision

Viewing changes to kernel/kvm_main.c

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2008-01-03 10:39:25 UTC
  • mfrom: (1.1.16 upstream)
  • Revision ID: james.westby@ubuntu.com-20080103103925-8480u7sq2646hvbh
Tags: 1:59+dfsg-0ubuntu1
* New upstream release
* Build with alsa support (cherry pick from 57+dfsg-2)

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/kvm_main.c
46
46
#include <asm/uaccess.h>
47
47
#include <asm/pgtable.h>
48
48
 
49
 
MODULE_INFO(version, "kvm-57");
 
49
MODULE_INFO(version, "kvm-59");
50
50
MODULE_AUTHOR("Qumranet");
51
51
MODULE_LICENSE("GPL");
52
52
 
166
166
 
167
167
        kvm->mm = current->mm;
168
168
//      atomic_inc(&kvm->mm->mm_count);
 
169
        spin_lock_init(&kvm->mmu_lock);
169
170
        kvm_io_bus_init(&kvm->pio_bus);
170
171
        mutex_init(&kvm->lock);
171
172
        kvm_io_bus_init(&kvm->mmio_bus);
228
229
 *
229
230
 * Discontiguous memory is allowed, mostly for framebuffers.
230
231
 *
231
 
 * Must be called holding kvm->lock.
 
232
 * Must be called holding mmap_sem for write.
232
233
 */
233
234
int __kvm_set_memory_region(struct kvm *kvm,
234
235
                            struct kvm_userspace_memory_region *mem,
339
340
{
340
341
        int r;
341
342
 
342
 
        mutex_lock(&kvm->lock);
 
343
        down_write(&current->mm->mmap_sem);
343
344
        r = __kvm_set_memory_region(kvm, mem, user_alloc);
344
 
        mutex_unlock(&kvm->lock);
 
345
        up_write(&current->mm->mmap_sem);
345
346
        return r;
346
347
}
347
348
EXPORT_SYMBOL_GPL(kvm_set_memory_region);
457
458
/*
458
459
 * Requires current->mm->mmap_sem to be held
459
460
 */
460
 
static struct page *__gfn_to_page(struct kvm *kvm, gfn_t gfn)
 
461
struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn)
461
462
{
462
463
        struct page *page[1];
463
464
        unsigned long addr;
471
472
                return bad_page;
472
473
        }
473
474
 
474
 
        npages = get_user_pages(current, current->mm, addr, 1, 1, 0, page,
 
475
        npages = get_user_pages(current, current->mm, addr, 1, 1, 1, page,
475
476
                                NULL);
476
477
 
477
478
        if (npages != 1) {
482
483
        return page[0];
483
484
}
484
485
 
485
 
struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn)
486
 
{
487
 
        struct page *page;
488
 
 
489
 
        down_read(&current->mm->mmap_sem);
490
 
        page = __gfn_to_page(kvm, gfn);
491
 
        up_read(&current->mm->mmap_sem);
492
 
 
493
 
        return page;
494
 
}
495
 
 
496
486
EXPORT_SYMBOL_GPL(gfn_to_page);
497
487
 
498
488
void kvm_release_page_clean(struct page *page)
553
543
}
554
544
EXPORT_SYMBOL_GPL(kvm_read_guest);
555
545
 
 
546
int kvm_read_guest_atomic(struct kvm *kvm, gpa_t gpa, void *data,
 
547
                          unsigned long len)
 
548
{
 
549
        int r;
 
550
        unsigned long addr;
 
551
        gfn_t gfn = gpa >> PAGE_SHIFT;
 
552
        int offset = offset_in_page(gpa);
 
553
 
 
554
        addr = gfn_to_hva(kvm, gfn);
 
555
        if (kvm_is_error_hva(addr))
 
556
                return -EFAULT;
 
557
        r = __copy_from_user_inatomic(data, (void __user *)addr + offset, len);
 
558
        if (r)
 
559
                return -EFAULT;
 
560
        return 0;
 
561
}
 
562
EXPORT_SYMBOL(kvm_read_guest_atomic);
 
563
 
556
564
int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
557
565
                         int offset, int len)
558
566
{
978
986
 
979
987
        if (!kvm_is_visible_gfn(kvm, vmf->pgoff))
980
988
                return VM_FAULT_SIGBUS;
981
 
        /* current->mm->mmap_sem is already held so call lockless version */
982
 
        page = __gfn_to_page(kvm, vmf->pgoff);
 
989
        page = gfn_to_page(kvm, vmf->pgoff);
983
990
        if (is_error_page(page)) {
984
991
                kvm_release_page_clean(page);
985
992
                return VM_FAULT_SIGBUS;
1358
1365
                goto out;
1359
1366
        }
1360
1367
        preempt_notifier_sys_init();
1361
 
        printk("loaded kvm module (kvm-57)\n");
 
1368
        printk("loaded kvm module (kvm-59)\n");
1362
1369
        return 0;
1363
1370
 
1364
1371
out_free: