Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 178 insertions, 81 deletions

diff --git a/mm/nommu.c b/mm/nommu.c
index 88ff091eb07a..9edc897a3970 100644
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -10,7 +10,7 @@
  *  Copyright (c) 2000-2003 David McCullough <davidm@snapgear.com>
  *  Copyright (c) 2000-2001 D Jeff Dionne <jeff@uClinux.org>
  *  Copyright (c) 2002      Greg Ungerer <gerg@snapgear.com>
- *  Copyright (c) 2007-2009 Paul Mundt <lethal@linux-sh.org>
+ *  Copyright (c) 2007-2010 Paul Mundt <lethal@linux-sh.org>
  */
 
 #include <linux/module.h>
@@ -29,6 +29,7 @@
 #include <linux/personality.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
+#include <linux/audit.h>
 
 #include <asm/uaccess.h>
 #include <asm/tlb.h>
@@ -126,7 +127,8 @@ unsigned int kobjsize(const void *objp)
 
 int __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
                      unsigned long start, int nr_pages, unsigned int foll_flags,
-                     struct page **pages, struct vm_area_struct **vmas)
+                     struct page **pages, struct vm_area_struct **vmas,
+                     int *retry)
 {
         struct vm_area_struct *vma;
         unsigned long vm_flags;
@@ -184,7 +186,8 @@ int get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
         if (force)
                 flags |= FOLL_FORCE;
 
-        return __get_user_pages(tsk, mm, start, nr_pages, flags, pages, vmas);
+        return __get_user_pages(tsk, mm, start, nr_pages, flags, pages, vmas,
+                                NULL);
 }
 EXPORT_SYMBOL(get_user_pages);
 
@@ -293,12 +296,60 @@ void *vmalloc(unsigned long size)
 }
 EXPORT_SYMBOL(vmalloc);
 
+/*
+ *      vzalloc - allocate virtually continguos memory with zero fill
+ *
+ *      @size:          allocation size
+ *
+ *      Allocate enough pages to cover @size from the page level
+ *      allocator and map them into continguos kernel virtual space.
+ *      The memory allocated is set to zero.
+ *
+ *      For tight control over page level allocator and protection flags
+ *      use __vmalloc() instead.
+ */
+void *vzalloc(unsigned long size)
+{
+        return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO,
+                        PAGE_KERNEL);
+}
+EXPORT_SYMBOL(vzalloc);
+
+/**
+ * vmalloc_node - allocate memory on a specific node
+ * @size:       allocation size
+ * @node:       numa node
+ *
+ * Allocate enough pages to cover @size from the page level
+ * allocator and map them into contiguous kernel virtual space.
+ *
+ * For tight control over page level allocator and protection flags
+ * use __vmalloc() instead.
+ */
 void *vmalloc_node(unsigned long size, int node)
 {
         return vmalloc(size);
 }
 EXPORT_SYMBOL(vmalloc_node);
 
+/**
+ * vzalloc_node - allocate memory on a specific node with zero fill
+ * @size:       allocation size
+ * @node:       numa node
+ *
+ * Allocate enough pages to cover @size from the page level
+ * allocator and map them into contiguous kernel virtual space.
+ * The memory allocated is set to zero.
+ *
+ * For tight control over page level allocator and protection flags
+ * use __vmalloc() instead.
+ */
+void *vzalloc_node(unsigned long size, int node)
+{
+        return vzalloc(size);
+}
+EXPORT_SYMBOL(vzalloc_node);
+
 #ifndef PAGE_KERNEL_EXEC
 # define PAGE_KERNEL_EXEC PAGE_KERNEL
 #endif
@@ -392,6 +443,31 @@ void  __attribute__((weak)) vmalloc_sync_all(void)
 {
 }
 
+/**
+ *      alloc_vm_area - allocate a range of kernel address space
+ *      @size:          size of the area
+ *
+ *      Returns:        NULL on failure, vm_struct on success
+ *
+ *      This function reserves a range of kernel address space, and
+ *      allocates pagetables to map that range.  No actual mappings
+ *      are created.  If the kernel address space is not shared
+ *      between processes, it syncs the pagetable across all
+ *      processes.
+ */
+struct vm_struct *alloc_vm_area(size_t size)
+{
+        BUG();
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(alloc_vm_area);
+
+void free_vm_area(struct vm_struct *area)
+{
+        BUG();
+}
+EXPORT_SYMBOL_GPL(free_vm_area);
+
 int vm_insert_page(struct vm_area_struct *vma, unsigned long addr,
                    struct page *page)
 {
@@ -604,9 +680,9 @@ static void protect_vma(struct vm_area_struct *vma, unsigned long flags)
  */
 static void add_vma_to_mm(struct mm_struct *mm, struct vm_area_struct *vma)
 {
-        struct vm_area_struct *pvma, **pp, *next;
+        struct vm_area_struct *pvma, *prev;
         struct address_space *mapping;
-        struct rb_node **p, *parent;
+        struct rb_node **p, *parent, *rb_prev;
 
         kenter(",%p", vma);
 
@@ -627,7 +703,7 @@ static void add_vma_to_mm(struct mm_struct *mm, struct vm_area_struct *vma)
         }
 
         /* add the VMA to the tree */
-        parent = NULL;
+        parent = rb_prev = NULL;
         p = &mm->mm_rb.rb_node;
         while (*p) {
                 parent = *p;
@@ -637,17 +713,20 @@ static void add_vma_to_mm(struct mm_struct *mm, struct vm_area_struct *vma)
                  * (the latter is necessary as we may get identical VMAs) */
                 if (vma->vm_start < pvma->vm_start)
                         p = &(*p)->rb_left;
-                else if (vma->vm_start > pvma->vm_start)
+                else if (vma->vm_start > pvma->vm_start) {
+                        rb_prev = parent;
                         p = &(*p)->rb_right;
-                else if (vma->vm_end < pvma->vm_end)
+                } else if (vma->vm_end < pvma->vm_end)
                         p = &(*p)->rb_left;
-                else if (vma->vm_end > pvma->vm_end)
+                else if (vma->vm_end > pvma->vm_end) {
+                        rb_prev = parent;
                         p = &(*p)->rb_right;
-                else if (vma < pvma)
+                } else if (vma < pvma)
                         p = &(*p)->rb_left;
-                else if (vma > pvma)
+                else if (vma > pvma) {
+                        rb_prev = parent;
                         p = &(*p)->rb_right;
-                else
+                } else
                         BUG();
         }
 
@@ -655,20 +734,11 @@ static void add_vma_to_mm(struct mm_struct *mm, struct vm_area_struct *vma)
         rb_insert_color(&vma->vm_rb, &mm->mm_rb);
 
         /* add VMA to the VMA list also */
-        for (pp = &mm->mmap; (pvma = *pp); pp = &(*pp)->vm_next) {
-                if (pvma->vm_start > vma->vm_start)
-                        break;
-                if (pvma->vm_start < vma->vm_start)
-                        continue;
-                if (pvma->vm_end < vma->vm_end)
-                        break;
-        }
+        prev = NULL;
+        if (rb_prev)
+                prev = rb_entry(rb_prev, struct vm_area_struct, vm_rb);
 
-        next = *pp;
-        *pp = vma;
-        vma->vm_next = next;
-        if (next)
-                next->vm_prev = vma;
+        __vma_link_list(mm, vma, prev, parent);
 }
 
 /*
@@ -676,7 +746,6 @@ static void add_vma_to_mm(struct mm_struct *mm, struct vm_area_struct *vma)
  */
 static void delete_vma_from_mm(struct vm_area_struct *vma)
 {
-        struct vm_area_struct **pp;
         struct address_space *mapping;
         struct mm_struct *mm = vma->vm_mm;
 
@@ -699,12 +768,14 @@ static void delete_vma_from_mm(struct vm_area_struct *vma)
 
         /* remove from the MM's tree and list */
         rb_erase(&vma->vm_rb, &mm->mm_rb);
-        for (pp = &mm->mmap; *pp; pp = &(*pp)->vm_next) {
-                if (*pp == vma) {
-                        *pp = vma->vm_next;
-                        break;
-                }
-        }
+
+        if (vma->vm_prev)
+                vma->vm_prev->vm_next = vma->vm_next;
+        else
+                mm->mmap = vma->vm_next;
+
+        if (vma->vm_next)
+                vma->vm_next->vm_prev = vma->vm_prev;
 
         vma->vm_mm = NULL;
 }
@@ -733,17 +804,15 @@ static void delete_vma(struct mm_struct *mm, struct vm_area_struct *vma)
 struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr)
 {
         struct vm_area_struct *vma;
-        struct rb_node *n = mm->mm_rb.rb_node;
 
         /* check the cache first */
         vma = mm->mmap_cache;
         if (vma && vma->vm_start <= addr && vma->vm_end > addr)
                 return vma;
 
-        /* trawl the tree (there may be multiple mappings in which addr
+        /* trawl the list (there may be multiple mappings in which addr
          * resides) */
-        for (n = rb_first(&mm->mm_rb); n; n = rb_next(n)) {
-                vma = rb_entry(n, struct vm_area_struct, vm_rb);
+        for (vma = mm->mmap; vma; vma = vma->vm_next) {
                 if (vma->vm_start > addr)
                         return NULL;
                 if (vma->vm_end > addr) {
@@ -783,7 +852,6 @@ static struct vm_area_struct *find_vma_exact(struct mm_struct *mm,
                                              unsigned long len)
 {
         struct vm_area_struct *vma;
-        struct rb_node *n = mm->mm_rb.rb_node;
         unsigned long end = addr + len;
 
         /* check the cache first */
@@ -791,10 +859,9 @@ static struct vm_area_struct *find_vma_exact(struct mm_struct *mm,
         if (vma && vma->vm_start == addr && vma->vm_end == end)
                 return vma;
 
-        /* trawl the tree (there may be multiple mappings in which addr
+        /* trawl the list (there may be multiple mappings in which addr
          * resides) */
-        for (n = rb_first(&mm->mm_rb); n; n = rb_next(n)) {
-                vma = rb_entry(n, struct vm_area_struct, vm_rb);
+        for (vma = mm->mmap; vma; vma = vma->vm_next) {
                 if (vma->vm_start < addr)
                         continue;
                 if (vma->vm_start > addr)
@@ -1057,7 +1124,7 @@ static int do_mmap_private(struct vm_area_struct *vma,
                            unsigned long capabilities)
 {
         struct page *pages;
-        unsigned long total, point, n, rlen;
+        unsigned long total, point, n;
         void *base;
         int ret, order;
 
@@ -1081,13 +1148,12 @@ static int do_mmap_private(struct vm_area_struct *vma,
                  * make a private copy of the data and map that instead */
         }
 
-        rlen = PAGE_ALIGN(len);
 
         /* allocate some memory to hold the mapping
          * - note that this may not return a page-aligned address if the object
          *   we're allocating is smaller than a page
          */
-        order = get_order(rlen);
+        order = get_order(len);
         kdebug("alloc order %d for %lx", order, len);
 
         pages = alloc_pages(GFP_KERNEL, order);
@@ -1097,7 +1163,7 @@ static int do_mmap_private(struct vm_area_struct *vma,
         total = 1 << order;
         atomic_long_add(total, &mmap_pages_allocated);
 
-        point = rlen >> PAGE_SHIFT;
+        point = len >> PAGE_SHIFT;
 
         /* we allocated a power-of-2 sized page set, so we may want to trim off
          * the excess */
@@ -1119,7 +1185,7 @@ static int do_mmap_private(struct vm_area_struct *vma,
         base = page_address(pages);
         region->vm_flags = vma->vm_flags |= VM_MAPPED_COPY;
         region->vm_start = (unsigned long) base;
-        region->vm_end   = region->vm_start + rlen;
+        region->vm_end   = region->vm_start + len;
         region->vm_top   = region->vm_start + (total << PAGE_SHIFT);
 
         vma->vm_start = region->vm_start;
@@ -1135,22 +1201,22 @@ static int do_mmap_private(struct vm_area_struct *vma,
 
                 old_fs = get_fs();
                 set_fs(KERNEL_DS);
-                ret = vma->vm_file->f_op->read(vma->vm_file, base, rlen, &fpos);
+                ret = vma->vm_file->f_op->read(vma->vm_file, base, len, &fpos);
                 set_fs(old_fs);
 
                 if (ret < 0)
                         goto error_free;
 
                 /* clear the last little bit */
-                if (ret < rlen)
-                        memset(base + ret, 0, rlen - ret);
+                if (ret < len)
+                        memset(base + ret, 0, len - ret);
 
         }
 
         return 0;
 
 error_free:
-        free_page_series(region->vm_start, region->vm_end);
+        free_page_series(region->vm_start, region->vm_top);
         region->vm_start = vma->vm_start = 0;
         region->vm_end   = vma->vm_end = 0;
         region->vm_top   = 0;
@@ -1159,7 +1225,7 @@ error_free:
 enomem:
         printk("Allocation of length %lu from process %d (%s) failed\n",
                len, current->pid, current->comm);
-        show_free_areas();
+        show_free_areas(0);
         return -ENOMEM;
 }
 
@@ -1192,6 +1258,7 @@ unsigned long do_mmap_pgoff(struct file *file,
 
         /* we ignore the address hint */
         addr = 0;
+        len = PAGE_ALIGN(len);
 
         /* we've determined that we can make the mapping, now translate what we
          * now know into VMA flags */
@@ -1309,15 +1376,15 @@ unsigned long do_mmap_pgoff(struct file *file,
                 if (capabilities & BDI_CAP_MAP_DIRECT) {
                         addr = file->f_op->get_unmapped_area(file, addr, len,
                                                              pgoff, flags);
-                        if (IS_ERR((void *) addr)) {
+                        if (IS_ERR_VALUE(addr)) {
                                 ret = addr;
-                                if (ret != (unsigned long) -ENOSYS)
+                                if (ret != -ENOSYS)
                                         goto error_just_free;
 
                                 /* the driver refused to tell us where to site
                                  * the mapping so we'll have to attempt to copy
                                  * it */
-                                ret = (unsigned long) -ENODEV;
+                                ret = -ENODEV;
                                 if (!(capabilities & BDI_CAP_MAP_COPY))
                                         goto error_just_free;
 
@@ -1392,14 +1459,14 @@ error_getting_vma:
         printk(KERN_WARNING "Allocation of vma for %lu byte allocation"
                " from process %d failed\n",
                len, current->pid);
-        show_free_areas();
+        show_free_areas(0);
         return -ENOMEM;
 
 error_getting_region:
         printk(KERN_WARNING "Allocation of vm region for %lu byte allocation"
                " from process %d failed\n",
                len, current->pid);
-        show_free_areas();
+        show_free_areas(0);
         return -ENOMEM;
 }
 EXPORT_SYMBOL(do_mmap_pgoff);
@@ -1411,6 +1478,7 @@ SYSCALL_DEFINE6(mmap_pgoff, unsigned long, addr, unsigned long, len,
         struct file *file = NULL;
         unsigned long retval = -EBADF;
 
+        audit_mmap_fd(fd, flags);
         if (!(flags & MAP_ANONYMOUS)) {
                 file = fget(fd);
                 if (!file)
@@ -1567,15 +1635,17 @@ static int shrink_vma(struct mm_struct *mm,
 int do_munmap(struct mm_struct *mm, unsigned long start, size_t len)
 {
         struct vm_area_struct *vma;
-        struct rb_node *rb;
-        unsigned long end = start + len;
+        unsigned long end;
         int ret;
 
         kenter(",%lx,%zx", start, len);
 
+        len = PAGE_ALIGN(len);
         if (len == 0)
                 return -EINVAL;
 
+        end = start + len;
+
         /* find the first potentially overlapping VMA */
         vma = find_vma(mm, start);
         if (!vma) {
@@ -1600,9 +1670,8 @@ int do_munmap(struct mm_struct *mm, unsigned long start, size_t len)
                         }
                         if (end == vma->vm_end)
                                 goto erase_whole_vma;
-                        rb = rb_next(&vma->vm_rb);
-                        vma = rb_entry(rb, struct vm_area_struct, vm_rb);
-                } while (rb);
+                        vma = vma->vm_next;
+                } while (vma);
                 kleave(" = -EINVAL [split file]");
                 return -EINVAL;
         } else {
@@ -1668,6 +1737,7 @@ void exit_mmap(struct mm_struct *mm)
                 mm->mmap = vma->vm_next;
                 delete_vma_from_mm(vma);
                 delete_vma(mm, vma);
+                cond_resched();
         }
 
         kleave("");
@@ -1695,6 +1765,8 @@ unsigned long do_mremap(unsigned long addr,
         struct vm_area_struct *vma;
 
         /* insanity checks first */
+        old_len = PAGE_ALIGN(old_len);
+        new_len = PAGE_ALIGN(new_len);
         if (old_len == 0 || new_len == 0)
                 return (unsigned long) -EINVAL;
 
@@ -1741,10 +1813,13 @@ struct page *follow_page(struct vm_area_struct *vma, unsigned long address,
         return NULL;
 }
 
-int remap_pfn_range(struct vm_area_struct *vma, unsigned long from,
-                unsigned long to, unsigned long size, pgprot_t prot)
+int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr,
+                unsigned long pfn, unsigned long size, pgprot_t prot)
 {
-        vma->vm_start = vma->vm_pgoff << PAGE_SHIFT;
+        if (addr != (pfn << PAGE_SHIFT))
+                return -EINVAL;
+
+        vma->vm_flags |= VM_IO | VM_RESERVED | VM_PFNMAP;
         return 0;
 }
 EXPORT_SYMBOL(remap_pfn_range);
@@ -1764,10 +1839,6 @@ int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
 }
 EXPORT_SYMBOL(remap_vmalloc_range);
 
-void swap_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
-{
-}
-
 unsigned long arch_get_unmapped_area(struct file *file, unsigned long addr,
         unsigned long len, unsigned long pgoff, unsigned long flags)
 {
@@ -1885,7 +1956,7 @@ error:
         return -ENOMEM;
 }
 
-int in_gate_area_no_task(unsigned long addr)
+int in_gate_area_no_mm(unsigned long addr)
 {
         return 0;
 }
@@ -1897,21 +1968,10 @@ int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 }
 EXPORT_SYMBOL(filemap_fault);
 
-/*
- * Access another process' address space.
- * - source/target buffer must be kernel space
- */
-int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write)
+static int __access_remote_vm(struct task_struct *tsk, struct mm_struct *mm,
+                unsigned long addr, void *buf, int len, int write)
 {
         struct vm_area_struct *vma;
-        struct mm_struct *mm;
-
-        if (addr + len < addr)
-                return 0;
-
-        mm = get_task_mm(tsk);
-        if (!mm)
-                return 0;
 
         down_read(&mm->mmap_sem);
 
@@ -1936,6 +1996,43 @@ int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, in
         }
 
         up_read(&mm->mmap_sem);
+
+        return len;
+}
+
+/**
+ * @access_remote_vm - access another process' address space
+ * @mm:         the mm_struct of the target address space
+ * @addr:       start address to access
+ * @buf:        source or destination buffer
+ * @len:        number of bytes to transfer
+ * @write:      whether the access is a write
+ *
+ * The caller must hold a reference on @mm.
+ */
+int access_remote_vm(struct mm_struct *mm, unsigned long addr,
+                void *buf, int len, int write)
+{
+        return __access_remote_vm(NULL, mm, addr, buf, len, write);
+}
+
+/*
+ * Access another process' address space.
+ * - source/target buffer must be kernel space
+ */
+int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write)
+{
+        struct mm_struct *mm;
+
+        if (addr + len < addr)
+                return 0;
+
+        mm = get_task_mm(tsk);
+        if (!mm)
+                return 0;
+
+        len = __access_remote_vm(tsk, mm, addr, buf, len, write);
+
         mmput(mm);
         return len;
 }