[PATCH] Mark __remove_vm_area() static
[linux-2.6.git] / mm / vmalloc.c
index 5e91205..1ac191c 100644 (file)
@@ -24,6 +24,9 @@
 DEFINE_RWLOCK(vmlist_lock);
 struct vm_struct *vmlist;
 
+static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
+                           int node);
+
 static void vunmap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end)
 {
        pte_t *pte;
@@ -89,7 +92,7 @@ static int vmap_pte_range(pmd_t *pmd, unsigned long addr,
 {
        pte_t *pte;
 
-       pte = pte_alloc_kernel(&init_mm, pmd, addr);
+       pte = pte_alloc_kernel(pmd, addr);
        if (!pte)
                return -ENOMEM;
        do {
@@ -147,14 +150,12 @@ int map_vm_area(struct vm_struct *area, pgprot_t prot, struct page ***pages)
 
        BUG_ON(addr >= end);
        pgd = pgd_offset_k(addr);
-       spin_lock(&init_mm.page_table_lock);
        do {
                next = pgd_addr_end(addr, end);
                err = vmap_pud_range(pgd, addr, next, prot, pages);
                if (err)
                        break;
        } while (pgd++, addr = next, addr != end);
-       spin_unlock(&init_mm.page_table_lock);
        flush_cache_vmap((unsigned long) area->addr, end);
        return err;
 }
@@ -240,7 +241,6 @@ struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
 
 /**
  *     get_vm_area  -  reserve a contingous kernel virtual area
- *
  *     @size:          size of the area
  *     @flags:         %VM_IOREMAP for I/O mappings or VM_ALLOC
  *
@@ -259,7 +259,20 @@ struct vm_struct *get_vm_area_node(unsigned long size, unsigned long flags, int
 }
 
 /* Caller must hold vmlist_lock */
-struct vm_struct *__remove_vm_area(void *addr)
+static struct vm_struct *__find_vm_area(void *addr)
+{
+       struct vm_struct *tmp;
+
+       for (tmp = vmlist; tmp != NULL; tmp = tmp->next) {
+                if (tmp->addr == addr)
+                       break;
+       }
+
+       return tmp;
+}
+
+/* Caller must hold vmlist_lock */
+static struct vm_struct *__remove_vm_area(void *addr)
 {
        struct vm_struct **p, *tmp;
 
@@ -282,7 +295,6 @@ found:
 
 /**
  *     remove_vm_area  -  find and remove a contingous kernel virtual area
- *
  *     @addr:          base address
  *
  *     Search for the kernel VM area starting at @addr, and remove it.
@@ -319,16 +331,17 @@ void __vunmap(void *addr, int deallocate_pages)
                return;
        }
 
+       debug_check_no_locks_freed(addr, area->size);
+
        if (deallocate_pages) {
                int i;
 
                for (i = 0; i < area->nr_pages; i++) {
-                       if (unlikely(!area->pages[i]))
-                               BUG();
+                       BUG_ON(!area->pages[i]);
                        __free_page(area->pages[i]);
                }
 
-               if (area->nr_pages > PAGE_SIZE/sizeof(struct page *))
+               if (area->flags & VM_VPAGES)
                        vfree(area->pages);
                else
                        kfree(area->pages);
@@ -340,7 +353,6 @@ void __vunmap(void *addr, int deallocate_pages)
 
 /**
  *     vfree  -  release memory allocated by vmalloc()
- *
  *     @addr:          memory base address
  *
  *     Free the virtually contiguous memory area starting at @addr, as
@@ -358,7 +370,6 @@ EXPORT_SYMBOL(vfree);
 
 /**
  *     vunmap  -  release virtual mapping obtained by vmap()
- *
  *     @addr:          memory base address
  *
  *     Free the virtually contiguous memory area starting at @addr,
@@ -375,7 +386,6 @@ EXPORT_SYMBOL(vunmap);
 
 /**
  *     vmap  -  map an array of pages into virtually contiguous space
- *
  *     @pages:         array of page pointers
  *     @count:         number of pages to map
  *     @flags:         vm_area->flags
@@ -415,9 +425,10 @@ void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
 
        area->nr_pages = nr_pages;
        /* Please note that the recursion is strictly bounded. */
-       if (array_size > PAGE_SIZE)
+       if (array_size > PAGE_SIZE) {
                pages = __vmalloc_node(array_size, gfp_mask, PAGE_KERNEL, node);
-       else
+               area->flags |= VM_VPAGES;
+       } else
                pages = kmalloc_node(array_size, (gfp_mask & ~__GFP_HIGHMEM), node);
        area->pages = pages;
        if (!area->pages) {
@@ -455,18 +466,17 @@ void *__vmalloc_area(struct vm_struct *area, gfp_t gfp_mask, pgprot_t prot)
 
 /**
  *     __vmalloc_node  -  allocate virtually contiguous memory
- *
  *     @size:          allocation size
  *     @gfp_mask:      flags for the page level allocator
  *     @prot:          protection mask for the allocated pages
- *     @node           node to use for allocation or -1
+ *     @node:          node to use for allocation or -1
  *
  *     Allocate enough pages to cover @size from the page level
  *     allocator with @gfp_mask flags.  Map them into contiguous
  *     kernel virtual space, using a pagetable protection of @prot.
  */
-void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
-                       int node)
+static void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
+                           int node)
 {
        struct vm_struct *area;
 
@@ -480,7 +490,6 @@ void *__vmalloc_node(unsigned long size, gfp_t gfp_mask, pgprot_t prot,
 
        return __vmalloc_area_node(area, gfp_mask, prot, node);
 }
-EXPORT_SYMBOL(__vmalloc_node);
 
 void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
 {
@@ -490,9 +499,7 @@ EXPORT_SYMBOL(__vmalloc);
 
 /**
  *     vmalloc  -  allocate virtually contiguous memory
- *
  *     @size:          allocation size
- *
  *     Allocate enough pages to cover @size from the page level
  *     allocator and map them into contiguous kernel virtual space.
  *
@@ -501,15 +508,36 @@ EXPORT_SYMBOL(__vmalloc);
  */
 void *vmalloc(unsigned long size)
 {
-       return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
+       return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
 }
 EXPORT_SYMBOL(vmalloc);
 
 /**
- *     vmalloc_node  -  allocate memory on a specific node
+ * vmalloc_user - allocate zeroed virtually contiguous memory for userspace
+ * @size: allocation size
  *
+ * The resulting memory area is zeroed so it can be mapped to userspace
+ * without leaking data.
+ */
+void *vmalloc_user(unsigned long size)
+{
+       struct vm_struct *area;
+       void *ret;
+
+       ret = __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL);
+       write_lock(&vmlist_lock);
+       area = __find_vm_area(ret);
+       area->flags |= VM_USERMAP;
+       write_unlock(&vmlist_lock);
+
+       return ret;
+}
+EXPORT_SYMBOL(vmalloc_user);
+
+/**
+ *     vmalloc_node  -  allocate memory on a specific node
  *     @size:          allocation size
- *     @node;          numa node
+ *     @node:          numa node
  *
  *     Allocate enough pages to cover @size from the page level
  *     allocator and map them into contiguous kernel virtual space.
@@ -519,7 +547,7 @@ EXPORT_SYMBOL(vmalloc);
  */
 void *vmalloc_node(unsigned long size, int node)
 {
-       return __vmalloc_node(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL, node);
+       return __vmalloc_node(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL, node);
 }
 EXPORT_SYMBOL(vmalloc_node);
 
@@ -529,7 +557,6 @@ EXPORT_SYMBOL(vmalloc_node);
 
 /**
  *     vmalloc_exec  -  allocate virtually contiguous, executable memory
- *
  *     @size:          allocation size
  *
  *     Kernel-internal function to allocate enough pages to cover @size
@@ -547,7 +574,6 @@ void *vmalloc_exec(unsigned long size)
 
 /**
  *     vmalloc_32  -  allocate virtually contiguous memory (32bit addressable)
- *
  *     @size:          allocation size
  *
  *     Allocate enough 32bit PA addressable pages to cover @size from the
@@ -559,6 +585,28 @@ void *vmalloc_32(unsigned long size)
 }
 EXPORT_SYMBOL(vmalloc_32);
 
+/**
+ * vmalloc_32_user - allocate zeroed virtually contiguous 32bit memory
+ *     @size:          allocation size
+ *
+ * The resulting memory area is 32bit addressable and zeroed so it can be
+ * mapped to userspace without leaking data.
+ */
+void *vmalloc_32_user(unsigned long size)
+{
+       struct vm_struct *area;
+       void *ret;
+
+       ret = __vmalloc(size, GFP_KERNEL | __GFP_ZERO, PAGE_KERNEL);
+       write_lock(&vmlist_lock);
+       area = __find_vm_area(ret);
+       area->flags |= VM_USERMAP;
+       write_unlock(&vmlist_lock);
+
+       return ret;
+}
+EXPORT_SYMBOL(vmalloc_32_user);
+
 long vread(char *buf, char *addr, unsigned long count)
 {
        struct vm_struct *tmp;
@@ -633,3 +681,63 @@ finished:
        read_unlock(&vmlist_lock);
        return buf - buf_start;
 }
+
+/**
+ *     remap_vmalloc_range  -  map vmalloc pages to userspace
+ *     @vma:           vma to cover (map full range of vma)
+ *     @addr:          vmalloc memory
+ *     @pgoff:         number of pages into addr before first page to map
+ *     @returns:       0 for success, -Exxx on failure
+ *
+ *     This function checks that addr is a valid vmalloc'ed area, and
+ *     that it is big enough to cover the vma. Will return failure if
+ *     that criteria isn't met.
+ *
+ *     Similar to remap_pfn_range (see mm/memory.c)
+ */
+int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
+                                               unsigned long pgoff)
+{
+       struct vm_struct *area;
+       unsigned long uaddr = vma->vm_start;
+       unsigned long usize = vma->vm_end - vma->vm_start;
+       int ret;
+
+       if ((PAGE_SIZE-1) & (unsigned long)addr)
+               return -EINVAL;
+
+       read_lock(&vmlist_lock);
+       area = __find_vm_area(addr);
+       if (!area)
+               goto out_einval_locked;
+
+       if (!(area->flags & VM_USERMAP))
+               goto out_einval_locked;
+
+       if (usize + (pgoff << PAGE_SHIFT) > area->size - PAGE_SIZE)
+               goto out_einval_locked;
+       read_unlock(&vmlist_lock);
+
+       addr += pgoff << PAGE_SHIFT;
+       do {
+               struct page *page = vmalloc_to_page(addr);
+               ret = vm_insert_page(vma, uaddr, page);
+               if (ret)
+                       return ret;
+
+               uaddr += PAGE_SIZE;
+               addr += PAGE_SIZE;
+               usize -= PAGE_SIZE;
+       } while (usize > 0);
+
+       /* Prevent "things" like memory migration? VM_flags need a cleanup... */
+       vma->vm_flags |= VM_RESERVED;
+
+       return ret;
+
+out_einval_locked:
+       read_unlock(&vmlist_lock);
+       return -EINVAL;
+}
+EXPORT_SYMBOL(remap_vmalloc_range);
+