Patched in Tegra support.

1 files changed, 81 insertions, 109 deletions

diff --git a/mm/nobootmem.c b/mm/nobootmem.c
index b8294fc03df..6e93dc7f258 100644
--- a/mm/nobootmem.c
+++ b/mm/nobootmem.c
@@ -12,7 +12,7 @@
 #include <linux/pfn.h>
 #include <linux/slab.h>
 #include <linux/bootmem.h>
-#include <linux/export.h>
+#include <linux/module.h>
 #include <linux/kmemleak.h>
 #include <linux/range.h>
 #include <linux/memblock.h>
@@ -41,13 +41,14 @@ static void * __init __alloc_memory_core_early(int nid, u64 size, u64 align,
         if (limit > memblock.current_limit)
                 limit = memblock.current_limit;
 
-        addr = memblock_find_in_range_node(goal, limit, size, align, nid);
-        if (!addr)
+        addr = find_memory_core_early(nid, size, align, goal, limit);
+
+        if (addr == MEMBLOCK_ERROR)
                 return NULL;
 
         ptr = phys_to_virt(addr);
         memset(ptr, 0, size);
-        memblock_reserve(addr, size);
+        memblock_x86_reserve_range(addr, addr + size, "BOOTMEM");
         /*
          * The min_count is set to 0 so that bootmem allocated blocks
          * are never reported as leaks.
@@ -82,7 +83,8 @@ void __init free_bootmem_late(unsigned long addr, unsigned long size)
 
 static void __init __free_pages_memory(unsigned long start, unsigned long end)
 {
-        unsigned long i, start_aligned, end_aligned;
+        int i;
+        unsigned long start_aligned, end_aligned;
         int order = ilog2(BITS_PER_LONG);
 
         start_aligned = (start + (BITS_PER_LONG - 1)) & ~(BITS_PER_LONG - 1);
@@ -105,54 +107,26 @@ static void __init __free_pages_memory(unsigned long start, unsigned long end)
                 __free_pages_bootmem(pfn_to_page(i), 0);
 }
 
-static unsigned long __init __free_memory_core(phys_addr_t start,
-                                 phys_addr_t end)
-{
-        unsigned long start_pfn = PFN_UP(start);
-        unsigned long end_pfn = min_t(unsigned long,
-                                      PFN_DOWN(end), max_low_pfn);
-
-        if (start_pfn > end_pfn)
-                return 0;
-
-        __free_pages_memory(start_pfn, end_pfn);
-
-        return end_pfn - start_pfn;
-}
-
-unsigned long __init free_low_memory_core_early(int nodeid)
+unsigned long __init free_all_memory_core_early(int nodeid)
 {
+        int i;
+        u64 start, end;
         unsigned long count = 0;
-        phys_addr_t start, end, size;
-        u64 i;
+        struct range *range = NULL;
+        int nr_range;
 
-        for_each_free_mem_range(i, MAX_NUMNODES, &start, &end, NULL)
-                count += __free_memory_core(start, end);
+        nr_range = get_free_all_memory_range(&range, nodeid);
 
-        /* free range that is used for reserved array if we allocate it */
-        size = get_allocated_memblock_reserved_regions_info(&start);
-        if (size)
-                count += __free_memory_core(start, start + size);
+        for (i = 0; i < nr_range; i++) {
+                start = range[i].start;
+                end = range[i].end;
+                count += end - start;
+                __free_pages_memory(start, end);
+        }
 
         return count;
 }
 
-static void reset_node_lowmem_managed_pages(pg_data_t *pgdat)
-{
-        struct zone *z;
-
-        /*
-         * In free_area_init_core(), highmem zone's managed_pages is set to
-         * present_pages, and bootmem allocator doesn't allocate from highmem
-         * zones. So there's no need to recalculate managed_pages because all
-         * highmem pages will be managed by the buddy system. Here highmem
-         * zone also includes highmem movable zone.
-         */
-        for (z = pgdat->node_zones; z < pgdat->node_zones + MAX_NR_ZONES; z++)
-                if (!is_highmem(z))
-                        z->managed_pages = 0;
-}
-
 /**
  * free_all_bootmem_node - release a node's free pages to the buddy allocator
  * @pgdat: node to be released
@@ -162,9 +136,8 @@ static void reset_node_lowmem_managed_pages(pg_data_t *pgdat)
 unsigned long __init free_all_bootmem_node(pg_data_t *pgdat)
 {
         register_page_bootmem_info_node(pgdat);
-        reset_node_lowmem_managed_pages(pgdat);
 
-        /* free_low_memory_core_early(MAX_NUMNODES) will be called later */
+        /* free_all_memory_core_early(MAX_NUMNODES) will be called later */
         return 0;
 }
 
@@ -175,17 +148,14 @@ unsigned long __init free_all_bootmem_node(pg_data_t *pgdat)
  */
 unsigned long __init free_all_bootmem(void)
 {
-        struct pglist_data *pgdat;
-
-        for_each_online_pgdat(pgdat)
-                reset_node_lowmem_managed_pages(pgdat);
-
         /*
          * We need to use MAX_NUMNODES instead of NODE_DATA(0)->node_id
          *  because in some case like Node0 doesn't have RAM installed
          *  low ram will be on Node1
+         * Use MAX_NUMNODES will make sure all ranges in early_node_map[]
+         *  will be used instead of only Node0 related
          */
-        return free_low_memory_core_early(MAX_NUMNODES);
+        return free_all_memory_core_early(MAX_NUMNODES);
 }
 
 /**
@@ -202,7 +172,7 @@ void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
                               unsigned long size)
 {
         kmemleak_free_part(__va(physaddr), size);
-        memblock_free(physaddr, size);
+        memblock_x86_free_range(physaddr, physaddr + size);
 }
 
 /**
@@ -217,7 +187,7 @@ void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
 void __init free_bootmem(unsigned long addr, unsigned long size)
 {
         kmemleak_free_part(__va(addr), size);
-        memblock_free(addr, size);
+        memblock_x86_free_range(addr, addr + size);
 }
 
 static void * __init ___alloc_bootmem_nopanic(unsigned long size,
@@ -302,57 +272,6 @@ void * __init __alloc_bootmem(unsigned long size, unsigned long align,
         return ___alloc_bootmem(size, align, goal, limit);
 }
 
-void * __init ___alloc_bootmem_node_nopanic(pg_data_t *pgdat,
-                                                   unsigned long size,
-                                                   unsigned long align,
-                                                   unsigned long goal,
-                                                   unsigned long limit)
-{
-        void *ptr;
-
-again:
-        ptr = __alloc_memory_core_early(pgdat->node_id, size, align,
-                                        goal, limit);
-        if (ptr)
-                return ptr;
-
-        ptr = __alloc_memory_core_early(MAX_NUMNODES, size, align,
-                                        goal, limit);
-        if (ptr)
-                return ptr;
-
-        if (goal) {
-                goal = 0;
-                goto again;
-        }
-
-        return NULL;
-}
-
-void * __init __alloc_bootmem_node_nopanic(pg_data_t *pgdat, unsigned long size,
-                                   unsigned long align, unsigned long goal)
-{
-        if (WARN_ON_ONCE(slab_is_available()))
-                return kzalloc_node(size, GFP_NOWAIT, pgdat->node_id);
-
-        return ___alloc_bootmem_node_nopanic(pgdat, size, align, goal, 0);
-}
-
-void * __init ___alloc_bootmem_node(pg_data_t *pgdat, unsigned long size,
-                                    unsigned long align, unsigned long goal,
-                                    unsigned long limit)
-{
-        void *ptr;
-
-        ptr = ___alloc_bootmem_node_nopanic(pgdat, size, align, goal, limit);
-        if (ptr)
-                return ptr;
-
-        printk(KERN_ALERT "bootmem alloc of %lu bytes failed!\n", size);
-        panic("Out of memory");
-        return NULL;
-}
-
 /**
  * __alloc_bootmem_node - allocate boot memory from a specific node
  * @pgdat: node to allocate from
@@ -371,10 +290,18 @@ void * __init ___alloc_bootmem_node(pg_data_t *pgdat, unsigned long size,
 void * __init __alloc_bootmem_node(pg_data_t *pgdat, unsigned long size,
                                    unsigned long align, unsigned long goal)
 {
+        void *ptr;
+
         if (WARN_ON_ONCE(slab_is_available()))
                 return kzalloc_node(size, GFP_NOWAIT, pgdat->node_id);
 
-        return ___alloc_bootmem_node(pgdat, size, align, goal, 0);
+        ptr = __alloc_memory_core_early(pgdat->node_id, size, align,
+                                         goal, -1ULL);
+        if (ptr)
+                return ptr;
+
+        return __alloc_memory_core_early(MAX_NUMNODES, size, align,
+                                         goal, -1ULL);
 }
 
 void * __init __alloc_bootmem_node_high(pg_data_t *pgdat, unsigned long size,
@@ -383,6 +310,44 @@ void * __init __alloc_bootmem_node_high(pg_data_t *pgdat, unsigned long size,
         return __alloc_bootmem_node(pgdat, size, align, goal);
 }
 
+#ifdef CONFIG_SPARSEMEM
+/**
+ * alloc_bootmem_section - allocate boot memory from a specific section
+ * @size: size of the request in bytes
+ * @section_nr: sparse map section to allocate from
+ *
+ * Return NULL on failure.
+ */
+void * __init alloc_bootmem_section(unsigned long size,
+                                    unsigned long section_nr)
+{
+        unsigned long pfn, goal, limit;
+
+        pfn = section_nr_to_pfn(section_nr);
+        goal = pfn << PAGE_SHIFT;
+        limit = section_nr_to_pfn(section_nr + 1) << PAGE_SHIFT;
+
+        return __alloc_memory_core_early(early_pfn_to_nid(pfn), size,
+                                         SMP_CACHE_BYTES, goal, limit);
+}
+#endif
+
+void * __init __alloc_bootmem_node_nopanic(pg_data_t *pgdat, unsigned long size,
+                                   unsigned long align, unsigned long goal)
+{
+        void *ptr;
+
+        if (WARN_ON_ONCE(slab_is_available()))
+                return kzalloc_node(size, GFP_NOWAIT, pgdat->node_id);
+
+        ptr =  __alloc_memory_core_early(pgdat->node_id, size, align,
+                                                 goal, -1ULL);
+        if (ptr)
+                return ptr;
+
+        return __alloc_bootmem_nopanic(size, align, goal);
+}
+
 #ifndef ARCH_LOW_ADDRESS_LIMIT
 #define ARCH_LOW_ADDRESS_LIMIT  0xffffffffUL
 #endif
@@ -424,9 +389,16 @@ void * __init __alloc_bootmem_low(unsigned long size, unsigned long align,
 void * __init __alloc_bootmem_low_node(pg_data_t *pgdat, unsigned long size,
                                        unsigned long align, unsigned long goal)
 {
+        void *ptr;
+
         if (WARN_ON_ONCE(slab_is_available()))
                 return kzalloc_node(size, GFP_NOWAIT, pgdat->node_id);
 
-        return ___alloc_bootmem_node(pgdat, size, align, goal,
-                                     ARCH_LOW_ADDRESS_LIMIT);
+        ptr = __alloc_memory_core_early(pgdat->node_id, size, align,
+                                goal, ARCH_LOW_ADDRESS_LIMIT);
+        if (ptr)
+                return ptr;
+
+        return  __alloc_memory_core_early(MAX_NUMNODES, size, align,
+                                goal, ARCH_LOW_ADDRESS_LIMIT);
 }