4 files changed, 75 insertions, 57 deletions

diff --git a/drivers/acpi/acpi_memhotplug.c b/drivers/acpi/acpi_memhotplug.c
index 01a1bd239263..2143609d2936 100644
--- a/drivers/acpi/acpi_memhotplug.c
+++ b/drivers/acpi/acpi_memhotplug.c
@@ -200,8 +200,7 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
          * Note: Assume that this function returns zero on success
          */
         result = add_memory(mem_device->start_addr,
-                            (mem_device->end_addr - mem_device->start_addr) + 1,
-                            mem_device->read_write_attribute);
+                            (mem_device->end_addr - mem_device->start_addr) + 1);
         if (result) {
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n"));
                 mem_device->state = MEMORY_INVALID_STATE;
@@ -259,7 +258,7 @@ static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
          * Ask the VM to offline this memory range.
          * Note: Assume that this function returns zero on success
          */
-        result = remove_memory(start, len, attr);
+        result = remove_memory(start, len);
         if (result) {
                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Hot-Remove failed.\n"));
                 return_VALUE(result);
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 785cb6e6b91c..b7ddd651d664 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -340,15 +340,12 @@ static int memory_probe_init(void)
 static int add_memory_block(unsigned long node_id, struct mem_section *section,
                      unsigned long state, int phys_device)
 {
-        size_t size = sizeof(struct memory_block);
-        struct memory_block *mem = kmalloc(size, GFP_KERNEL);
+        struct memory_block *mem = kzalloc(sizeof(*mem), GFP_KERNEL);
         int ret = 0;
 
         if (!mem)
                 return -ENOMEM;
 
-        memset(mem, 0, size);
-
         mem->phys_index = __section_nr(section);
         mem->state = state;
         init_MUTEX(&mem->state_sem);
diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 855e0fc928b3..2e916c308ae6 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -24,28 +24,6 @@
 
 #include <asm/tlbflush.h>
 
-static struct page *__kmalloc_section_memmap(unsigned long nr_pages)
-{
-        struct page *page, *ret;
-        unsigned long memmap_size = sizeof(struct page) * nr_pages;
-
-        page = alloc_pages(GFP_KERNEL, get_order(memmap_size));
-        if (page)
-                goto got_map_page;
-
-        ret = vmalloc(memmap_size);
-        if (ret)
-                goto got_map_ptr;
-
-        return NULL;
-got_map_page:
-        ret = (struct page *)pfn_to_kaddr(page_to_pfn(page));
-got_map_ptr:
-        memset(ret, 0, memmap_size);
-
-        return ret;
-}
-
 extern void zonetable_add(struct zone *zone, int nid, int zid, unsigned long pfn,
                           unsigned long size);
 static void __add_zone(struct zone *zone, unsigned long phys_start_pfn)
@@ -60,35 +38,15 @@ static void __add_zone(struct zone *zone, unsigned long phys_start_pfn)
         zonetable_add(zone, nid, zone_type, phys_start_pfn, nr_pages);
 }
 
-extern int sparse_add_one_section(struct zone *, unsigned long,
-                                  struct page *mem_map);
+extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,
+                                  int nr_pages);
 static int __add_section(struct zone *zone, unsigned long phys_start_pfn)
 {
         struct pglist_data *pgdat = zone->zone_pgdat;
         int nr_pages = PAGES_PER_SECTION;
-        struct page *memmap;
         int ret;
 
-        /*
-         * This can potentially allocate memory, and does its own
-         * internal locking.
-         */
-        sparse_index_init(pfn_to_section_nr(phys_start_pfn), pgdat->node_id);
-
-        pgdat_resize_lock(pgdat, &flags);
-        memmap = __kmalloc_section_memmap(nr_pages);
-        ret = sparse_add_one_section(zone, phys_start_pfn, memmap);
-        pgdat_resize_unlock(pgdat, &flags);
-
-        if (ret <= 0) {
-                /* the mem_map didn't get used */
-                if (memmap >= (struct page *)VMALLOC_START &&
-                    memmap < (struct page *)VMALLOC_END)
-                        vfree(memmap);
-                else
-                        free_pages((unsigned long)memmap,
-                                   get_order(sizeof(struct page) * nr_pages));
-        }
+        ret = sparse_add_one_section(zone, phys_start_pfn, nr_pages);
 
         if (ret < 0)
                 return ret;
diff --git a/mm/sparse.c b/mm/sparse.c
index 0d3bd4bf3aaa..72079b538e2d 100644
--- a/mm/sparse.c
+++ b/mm/sparse.c
@@ -5,8 +5,10 @@
 #include <linux/mm.h>
 #include <linux/mmzone.h>
 #include <linux/bootmem.h>
+#include <linux/highmem.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
+#include <linux/vmalloc.h>
 #include <asm/dma.h>
 
 /*
@@ -187,6 +189,45 @@ static struct page *sparse_early_mem_map_alloc(unsigned long pnum)
         return NULL;
 }
 
+static struct page *__kmalloc_section_memmap(unsigned long nr_pages)
+{
+        struct page *page, *ret;
+        unsigned long memmap_size = sizeof(struct page) * nr_pages;
+
+        page = alloc_pages(GFP_KERNEL, get_order(memmap_size));
+        if (page)
+                goto got_map_page;
+
+        ret = vmalloc(memmap_size);
+        if (ret)
+                goto got_map_ptr;
+
+        return NULL;
+got_map_page:
+        ret = (struct page *)pfn_to_kaddr(page_to_pfn(page));
+got_map_ptr:
+        memset(ret, 0, memmap_size);
+
+        return ret;
+}
+
+static int vaddr_in_vmalloc_area(void *addr)
+{
+        if (addr >= (void *)VMALLOC_START &&
+            addr < (void *)VMALLOC_END)
+                return 1;
+        return 0;
+}
+
+static void __kfree_section_memmap(struct page *memmap, unsigned long nr_pages)
+{
+        if (vaddr_in_vmalloc_area(memmap))
+                vfree(memmap);
+        else
+                free_pages((unsigned long)memmap,
+                           get_order(sizeof(struct page) * nr_pages));
+}
+
 /*
  * Allocate the accumulated non-linear sections, allocate a mem_map
  * for each and record the physical to section mapping.
@@ -212,14 +253,37 @@ void sparse_init(void)
  * set.  If this is <=0, then that means that the passed-in
  * map was not consumed and must be freed.
  */
-int sparse_add_one_section(unsigned long start_pfn, int nr_pages, struct page *map)
+int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,
+                           int nr_pages)
 {
-        struct mem_section *ms = __pfn_to_section(start_pfn);
+        unsigned long section_nr = pfn_to_section_nr(start_pfn);
+        struct pglist_data *pgdat = zone->zone_pgdat;
+        struct mem_section *ms;
+        struct page *memmap;
+        unsigned long flags;
+        int ret;
 
-        if (ms->section_mem_map & SECTION_MARKED_PRESENT)
-                return -EEXIST;
+        /*
+         * no locking for this, because it does its own
+         * plus, it does a kmalloc
+         */
+        sparse_index_init(section_nr, pgdat->node_id);
+        memmap = __kmalloc_section_memmap(nr_pages);
+
+        pgdat_resize_lock(pgdat, &flags);
 
+        ms = __pfn_to_section(start_pfn);
+        if (ms->section_mem_map & SECTION_MARKED_PRESENT) {
+                ret = -EEXIST;
+                goto out;
+        }
         ms->section_mem_map |= SECTION_MARKED_PRESENT;
 
-        return sparse_init_one_section(ms, pfn_to_section_nr(start_pfn), map);
+        ret = sparse_init_one_section(ms, section_nr, memmap);
+
+        if (ret <= 0)
+                __kfree_section_memmap(memmap, nr_pages);
+out:
+        pgdat_resize_unlock(pgdat, &flags);
+        return ret;
 }