fs/coda: remove static inline forward declarations

[pandora-kernel.git] / mm / sparse.c

diff --git a/mm/sparse.c b/mm/sparse.c
index 186a85b..dff71f1 100644 (file)
--- a/mm/sparse.c
+++ b/mm/sparse.c
@@ -8,6 +8,7 @@
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include <linux/vmalloc.h>
+#include "internal.h"
 #include <asm/dma.h>
 #include <asm/pgalloc.h>
 #include <asm/pgtable.h>
@@ -210,7 +211,6 @@ static unsigned long sparse_encode_mem_map(struct page *mem_map, unsigned long p
 /*
  * Decode mem_map from the coded memmap
  */
-static
 struct page *sparse_decode_mem_map(unsigned long coded_mem_map, unsigned long pnum)
 {
        /* mask off the extra low bits of information */
@@ -233,7 +233,7 @@ static int __meminit sparse_init_one_section(struct mem_section *ms,
        return 1;
 }
 
-static unsigned long usemap_size(void)
+unsigned long usemap_size(void)
 {
        unsigned long size_bytes;
        size_bytes = roundup(SECTION_BLOCKFLAGS_BITS, 8) / 8;
@@ -250,11 +250,22 @@ static unsigned long *__kmalloc_section_usemap(void)
 
 static unsigned long *__init sparse_early_usemap_alloc(unsigned long pnum)
 {
-       unsigned long *usemap;
+       unsigned long *usemap, section_nr;
        struct mem_section *ms = __nr_to_section(pnum);
        int nid = sparse_early_nid(ms);
+       struct pglist_data *pgdat = NODE_DATA(nid);
 
-       usemap = alloc_bootmem_node(NODE_DATA(nid), usemap_size());
+       /*
+        * Usemap's page can't be freed until freeing other sections
+        * which use it. And, Pgdat has same feature.
+        * If section A has pgdat and section B has usemap for other
+        * sections (includes section A), both sections can't be removed,
+        * because there is the dependency each other.
+        * To solve above issue, this collects all usemap on the same section
+        * which has pgdat.
+        */
+       section_nr = pfn_to_section_nr(__pa(pgdat) >> PAGE_SHIFT);
+       usemap = alloc_bootmem_section(usemap_size(), section_nr);
        if (usemap)
                return usemap;
 
@@ -274,8 +285,8 @@ struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid)
        if (map)
                return map;
 
-       map = alloc_bootmem_node(NODE_DATA(nid),
-                       sizeof(struct page) * PAGES_PER_SECTION);
+       map = alloc_bootmem_pages_node(NODE_DATA(nid),
+                      PAGE_ALIGN(sizeof(struct page) * PAGES_PER_SECTION));
        return map;
 }
 #endif /* !CONFIG_SPARSEMEM_VMEMMAP */
@@ -366,6 +377,9 @@ static void __kfree_section_memmap(struct page *memmap, unsigned long nr_pages)
 {
        return; /* XXX: Not implemented yet */
 }
+static void free_map_bootmem(struct page *page, unsigned long nr_pages)
+{
+}
 #else
 static struct page *__kmalloc_section_memmap(unsigned long nr_pages)
 {
@@ -403,17 +417,47 @@ static void __kfree_section_memmap(struct page *memmap, unsigned long nr_pages)
                free_pages((unsigned long)memmap,
                           get_order(sizeof(struct page) * nr_pages));
 }
+
+static void free_map_bootmem(struct page *page, unsigned long nr_pages)
+{
+       unsigned long maps_section_nr, removing_section_nr, i;
+       int magic;
+
+       for (i = 0; i < nr_pages; i++, page++) {
+               magic = atomic_read(&page->_mapcount);
+
+               BUG_ON(magic == NODE_INFO);
+
+               maps_section_nr = pfn_to_section_nr(page_to_pfn(page));
+               removing_section_nr = page->private;
+
+               /*
+                * When this function is called, the removing section is
+                * logical offlined state. This means all pages are isolated
+                * from page allocator. If removing section's memmap is placed
+                * on the same section, it must not be freed.
+                * If it is freed, page allocator may allocate it which will
+                * be removed physically soon.
+                */
+               if (maps_section_nr != removing_section_nr)
+                       put_page_bootmem(page);
+       }
+}
 #endif /* CONFIG_SPARSEMEM_VMEMMAP */
 
 static void free_section_usemap(struct page *memmap, unsigned long *usemap)
 {
+       struct page *usemap_page;
+       unsigned long nr_pages;
+
        if (!usemap)
                return;
 
+       usemap_page = virt_to_page(usemap);
        /*
         * Check to see if allocation came from hot-plug-add
         */
-       if (PageSlab(virt_to_page(usemap))) {
+       if (PageSlab(usemap_page)) {
                kfree(usemap);
                if (memmap)
                        __kfree_section_memmap(memmap, PAGES_PER_SECTION);
@@ -421,10 +465,19 @@ static void free_section_usemap(struct page *memmap, unsigned long *usemap)
        }
 
        /*
-        * TODO: Allocations came from bootmem - how do I free up ?
+        * The usemap came from bootmem. This is packed with other usemaps
+        * on the section which has pgdat at boot time. Just keep it as is now.
         */
-       printk(KERN_WARNING "Not freeing up allocations from bootmem "
-                       "- leaking memory\n");
+
+       if (memmap) {
+               struct page *memmap_page;
+               memmap_page = virt_to_page(memmap);
+
+               nr_pages = PAGE_ALIGN(PAGES_PER_SECTION * sizeof(struct page))
+                       >> PAGE_SHIFT;
+
+               free_map_bootmem(memmap_page, nr_pages);
+       }
 }
 
 /*