Merge branch 'akpm' (Andrew's patchbomb)

Merge misc updates from Andrew Morton:
 "About half of most of MM.  Going very early this time due to
  uncertainty over the coreautounifiednumasched things.  I'll send the
  other half of most of MM tomorrow.  The rest of MM awaits a slab merge
  from Pekka."

* emailed patches from Andrew Morton: (71 commits)
  memory_hotplug: ensure every online node has NORMAL memory
  memory_hotplug: handle empty zone when online_movable/online_kernel
  mm, memory-hotplug: dynamic configure movable memory and portion memory
  drivers/base/node.c: cleanup node_state_attr[]
  bootmem: fix wrong call parameter for free_bootmem()
  avr32, kconfig: remove HAVE_ARCH_BOOTMEM
  mm: cma: remove watermark hacks
  mm: cma: skip watermarks check for already isolated blocks in split_free_page()
  mm, oom: fix race when specifying a thread as the oom origin
  mm, oom: change type of oom_score_adj to short
  mm: cleanup register_node()
  mm, mempolicy: remove duplicate code
  mm/vmscan.c: try_to_freeze() returns boolean
  mm: introduce putback_movable_pages()
  virtio_balloon: introduce migration primitives to balloon pages
  mm: introduce compaction and migration for ballooned pages
  mm: introduce a common interface for balloon pages mobility
  mm: redefine address_space.assoc_mapping
  mm: adjust address_space_operations.migratepage() return code
  arch/sparc/kernel/sys_sparc_64.c: s/COLOUR/COLOR/
  ...

2 files changed, 81 insertions, 39 deletions

diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 86c88216a503..987604d56c83 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -70,6 +70,13 @@ void unregister_memory_isolate_notifier(struct notifier_block *nb)
 }
 EXPORT_SYMBOL(unregister_memory_isolate_notifier);
 
+static void memory_block_release(struct device *dev)
+{
+        struct memory_block *mem = container_of(dev, struct memory_block, dev);
+
+        kfree(mem);
+}
+
 /*
  * register_memory - Setup a sysfs device for a memory block
  */
@@ -80,6 +87,7 @@ int register_memory(struct memory_block *memory)
 
         memory->dev.bus = &memory_subsys;
         memory->dev.id = memory->start_section_nr / sections_per_block;
+        memory->dev.release = memory_block_release;
 
         error = device_register(&memory->dev);
         return error;
@@ -246,7 +254,7 @@ static bool pages_correctly_reserved(unsigned long start_pfn,
  * OK to have direct references to sparsemem variables in here.
  */
 static int
-memory_block_action(unsigned long phys_index, unsigned long action)
+memory_block_action(unsigned long phys_index, unsigned long action, int online_type)
 {
         unsigned long start_pfn;
         unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
@@ -261,7 +269,7 @@ memory_block_action(unsigned long phys_index, unsigned long action)
                         if (!pages_correctly_reserved(start_pfn, nr_pages))
                                 return -EBUSY;
 
-                        ret = online_pages(start_pfn, nr_pages);
+                        ret = online_pages(start_pfn, nr_pages, online_type);
                         break;
                 case MEM_OFFLINE:
                         ret = offline_pages(start_pfn, nr_pages);
@@ -276,7 +284,8 @@ memory_block_action(unsigned long phys_index, unsigned long action)
 }
 
 static int __memory_block_change_state(struct memory_block *mem,
-                unsigned long to_state, unsigned long from_state_req)
+                unsigned long to_state, unsigned long from_state_req,
+                int online_type)
 {
         int ret = 0;
 
@@ -288,7 +297,7 @@ static int __memory_block_change_state(struct memory_block *mem,
         if (to_state == MEM_OFFLINE)
                 mem->state = MEM_GOING_OFFLINE;
 
-        ret = memory_block_action(mem->start_section_nr, to_state);
+        ret = memory_block_action(mem->start_section_nr, to_state, online_type);
 
         if (ret) {
                 mem->state = from_state_req;
@@ -311,12 +320,14 @@ out:
 }
 
 static int memory_block_change_state(struct memory_block *mem,
-                unsigned long to_state, unsigned long from_state_req)
+                unsigned long to_state, unsigned long from_state_req,
+                int online_type)
 {
         int ret;
 
         mutex_lock(&mem->state_mutex);
-        ret = __memory_block_change_state(mem, to_state, from_state_req);
+        ret = __memory_block_change_state(mem, to_state, from_state_req,
+                                          online_type);
         mutex_unlock(&mem->state_mutex);
 
         return ret;
@@ -330,10 +341,18 @@ store_mem_state(struct device *dev,
 
         mem = container_of(dev, struct memory_block, dev);
 
-        if (!strncmp(buf, "online", min((int)count, 6)))
-                ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
-        else if(!strncmp(buf, "offline", min((int)count, 7)))
-                ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
+        if (!strncmp(buf, "online_kernel", min_t(int, count, 13)))
+                ret = memory_block_change_state(mem, MEM_ONLINE,
+                                                MEM_OFFLINE, ONLINE_KERNEL);
+        else if (!strncmp(buf, "online_movable", min_t(int, count, 14)))
+                ret = memory_block_change_state(mem, MEM_ONLINE,
+                                                MEM_OFFLINE, ONLINE_MOVABLE);
+        else if (!strncmp(buf, "online", min_t(int, count, 6)))
+                ret = memory_block_change_state(mem, MEM_ONLINE,
+                                                MEM_OFFLINE, ONLINE_KEEP);
+        else if(!strncmp(buf, "offline", min_t(int, count, 7)))
+                ret = memory_block_change_state(mem, MEM_OFFLINE,
+                                                MEM_ONLINE, -1);
 
         if (ret)
                 return ret;
@@ -635,7 +654,6 @@ int remove_memory_block(unsigned long node_id, struct mem_section *section,
                 mem_remove_simple_file(mem, phys_device);
                 mem_remove_simple_file(mem, removable);
                 unregister_memory(mem);
-                kfree(mem);
         } else
                 kobject_put(&mem->dev.kobj);
 
@@ -669,7 +687,7 @@ int offline_memory_block(struct memory_block *mem)
 
         mutex_lock(&mem->state_mutex);
         if (mem->state != MEM_OFFLINE)
-                ret = __memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
+                ret = __memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE, -1);
         mutex_unlock(&mem->state_mutex);
 
         return ret;
diff --git a/drivers/base/node.c b/drivers/base/node.c
index af1a177216f1..294e31626210 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -252,6 +252,24 @@ static inline void hugetlb_register_node(struct node *node) {}
 static inline void hugetlb_unregister_node(struct node *node) {}
 #endif
 
+static void node_device_release(struct device *dev)
+{
+        struct node *node = to_node(dev);
+
+#if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) && defined(CONFIG_HUGETLBFS)
+        /*
+         * We schedule the work only when a memory section is
+         * onlined/offlined on this node. When we come here,
+         * all the memory on this node has been offlined,
+         * so we won't enqueue new work to this work.
+         *
+         * The work is using node->node_work, so we should
+         * flush work before freeing the memory.
+         */
+        flush_work(&node->node_work);
+#endif
+        kfree(node);
+}
 
 /*
  * register_node - Setup a sysfs device for a node.
@@ -259,12 +277,13 @@ static inline void hugetlb_unregister_node(struct node *node) {}
  *
  * Initialize and register the node device.
  */
-int register_node(struct node *node, int num, struct node *parent)
+static int register_node(struct node *node, int num, struct node *parent)
 {
         int error;
 
         node->dev.id = num;
         node->dev.bus = &node_subsys;
+        node->dev.release = node_device_release;
         error = device_register(&node->dev);
 
         if (!error){
@@ -306,7 +325,7 @@ void unregister_node(struct node *node)
         device_unregister(&node->dev);
 }
 
-struct node node_devices[MAX_NUMNODES];
+struct node *node_devices[MAX_NUMNODES];
 
 /*
  * register cpu under node
@@ -323,15 +342,15 @@ int register_cpu_under_node(unsigned int cpu, unsigned int nid)
         if (!obj)
                 return 0;
 
-        ret = sysfs_create_link(&node_devices[nid].dev.kobj,
+        ret = sysfs_create_link(&node_devices[nid]->dev.kobj,
                                 &obj->kobj,
                                 kobject_name(&obj->kobj));
         if (ret)
                 return ret;
 
         return sysfs_create_link(&obj->kobj,
-                                 &node_devices[nid].dev.kobj,
-                                 kobject_name(&node_devices[nid].dev.kobj));
+                                 &node_devices[nid]->dev.kobj,
+                                 kobject_name(&node_devices[nid]->dev.kobj));
 }
 
 int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
@@ -345,10 +364,10 @@ int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
         if (!obj)
                 return 0;
 
-        sysfs_remove_link(&node_devices[nid].dev.kobj,
+        sysfs_remove_link(&node_devices[nid]->dev.kobj,
                           kobject_name(&obj->kobj));
         sysfs_remove_link(&obj->kobj,
-                          kobject_name(&node_devices[nid].dev.kobj));
+                          kobject_name(&node_devices[nid]->dev.kobj));
 
         return 0;
 }
@@ -390,15 +409,15 @@ int register_mem_sect_under_node(struct memory_block *mem_blk, int nid)
                         continue;
                 if (page_nid != nid)
                         continue;
-                ret = sysfs_create_link_nowarn(&node_devices[nid].dev.kobj,
+                ret = sysfs_create_link_nowarn(&node_devices[nid]->dev.kobj,
                                         &mem_blk->dev.kobj,
                                         kobject_name(&mem_blk->dev.kobj));
                 if (ret)
                         return ret;
 
                 return sysfs_create_link_nowarn(&mem_blk->dev.kobj,
-                                &node_devices[nid].dev.kobj,
-                                kobject_name(&node_devices[nid].dev.kobj));
+                                &node_devices[nid]->dev.kobj,
+                                kobject_name(&node_devices[nid]->dev.kobj));
         }
         /* mem section does not span the specified node */
         return 0;
@@ -431,10 +450,10 @@ int unregister_mem_sect_under_nodes(struct memory_block *mem_blk,
                         continue;
                 if (node_test_and_set(nid, *unlinked_nodes))
                         continue;
-                sysfs_remove_link(&node_devices[nid].dev.kobj,
+                sysfs_remove_link(&node_devices[nid]->dev.kobj,
                          kobject_name(&mem_blk->dev.kobj));
                 sysfs_remove_link(&mem_blk->dev.kobj,
-                         kobject_name(&node_devices[nid].dev.kobj));
+                         kobject_name(&node_devices[nid]->dev.kobj));
         }
         NODEMASK_FREE(unlinked_nodes);
         return 0;
@@ -500,7 +519,7 @@ static void node_hugetlb_work(struct work_struct *work)
 
 static void init_node_hugetlb_work(int nid)
 {
-        INIT_WORK(&node_devices[nid].node_work, node_hugetlb_work);
+        INIT_WORK(&node_devices[nid]->node_work, node_hugetlb_work);
 }
 
 static int node_memory_callback(struct notifier_block *self,
@@ -517,7 +536,7 @@ static int node_memory_callback(struct notifier_block *self,
                  * when transitioning to/from memoryless state.
                  */
                 if (nid != NUMA_NO_NODE)
-                        schedule_work(&node_devices[nid].node_work);
+                        schedule_work(&node_devices[nid]->node_work);
                 break;
 
         case MEM_GOING_ONLINE:
@@ -558,9 +577,13 @@ int register_one_node(int nid)
                 struct node *parent = NULL;
 
                 if (p_node != nid)
-                        parent = &node_devices[p_node];
+                        parent = node_devices[p_node];
+
+                node_devices[nid] = kzalloc(sizeof(struct node), GFP_KERNEL);
+                if (!node_devices[nid])
+                        return -ENOMEM;
 
-                error = register_node(&node_devices[nid], nid, parent);
+                error = register_node(node_devices[nid], nid, parent);
 
                 /* link cpu under this node */
                 for_each_present_cpu(cpu) {
@@ -581,7 +604,8 @@ int register_one_node(int nid)
 
 void unregister_one_node(int nid)
 {
-        unregister_node(&node_devices[nid]);
+        unregister_node(node_devices[nid]);
+        node_devices[nid] = NULL;
 }
 
 /*
@@ -614,23 +638,23 @@ static ssize_t show_node_state(struct device *dev,
         { __ATTR(name, 0444, show_node_state, NULL), state }
 
 static struct node_attr node_state_attr[] = {
-        _NODE_ATTR(possible, N_POSSIBLE),
-        _NODE_ATTR(online, N_ONLINE),
-        _NODE_ATTR(has_normal_memory, N_NORMAL_MEMORY),
-        _NODE_ATTR(has_cpu, N_CPU),
+        [N_POSSIBLE] = _NODE_ATTR(possible, N_POSSIBLE),
+        [N_ONLINE] = _NODE_ATTR(online, N_ONLINE),
+        [N_NORMAL_MEMORY] = _NODE_ATTR(has_normal_memory, N_NORMAL_MEMORY),
 #ifdef CONFIG_HIGHMEM
-        _NODE_ATTR(has_high_memory, N_HIGH_MEMORY),
+        [N_HIGH_MEMORY] = _NODE_ATTR(has_high_memory, N_HIGH_MEMORY),
 #endif
+        [N_CPU] = _NODE_ATTR(has_cpu, N_CPU),
 };
 
 static struct attribute *node_state_attrs[] = {
-        &node_state_attr[0].attr.attr,
-        &node_state_attr[1].attr.attr,
-        &node_state_attr[2].attr.attr,
-        &node_state_attr[3].attr.attr,
+        &node_state_attr[N_POSSIBLE].attr.attr,
+        &node_state_attr[N_ONLINE].attr.attr,
+        &node_state_attr[N_NORMAL_MEMORY].attr.attr,
 #ifdef CONFIG_HIGHMEM
-        &node_state_attr[4].attr.attr,
+        &node_state_attr[N_HIGH_MEMORY].attr.attr,
 #endif
+        &node_state_attr[N_CPU].attr.attr,
         NULL
 };