3 files changed, 177 insertions, 26 deletions

diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 1833879f8438..3a47871a29d9 100644
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -187,7 +187,24 @@ int online_pages(unsigned long pfn, unsigned long nr_pages)
         unsigned long onlined_pages = 0;
         struct zone *zone;
         int need_zonelists_rebuild = 0;
+        int nid;
+        int ret;
+        struct memory_notify arg;
+
+        arg.start_pfn = pfn;
+        arg.nr_pages = nr_pages;
+        arg.status_change_nid = -1;
+
+        nid = page_to_nid(pfn_to_page(pfn));
+        if (node_present_pages(nid) == 0)
+                arg.status_change_nid = nid;
 
+        ret = memory_notify(MEM_GOING_ONLINE, &arg);
+        ret = notifier_to_errno(ret);
+        if (ret) {
+                memory_notify(MEM_CANCEL_ONLINE, &arg);
+                return ret;
+        }
         /*
          * This doesn't need a lock to do pfn_to_page().
          * The section can't be removed here because of the
@@ -222,6 +239,10 @@ int online_pages(unsigned long pfn, unsigned long nr_pages)
                 build_all_zonelists();
         vm_total_pages = nr_free_pagecache_pages();
         writeback_set_ratelimit();
+
+        if (onlined_pages)
+                memory_notify(MEM_ONLINE, &arg);
+
         return 0;
 }
 #endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */
@@ -467,8 +488,9 @@ int offline_pages(unsigned long start_pfn,
 {
         unsigned long pfn, nr_pages, expire;
         long offlined_pages;
-        int ret, drain, retry_max;
+        int ret, drain, retry_max, node;
         struct zone *zone;
+        struct memory_notify arg;
 
         BUG_ON(start_pfn >= end_pfn);
         /* at least, alignment against pageblock is necessary */
@@ -480,11 +502,27 @@ int offline_pages(unsigned long start_pfn,
            we assume this for now. .*/
         if (!test_pages_in_a_zone(start_pfn, end_pfn))
                 return -EINVAL;
+
+        zone = page_zone(pfn_to_page(start_pfn));
+        node = zone_to_nid(zone);
+        nr_pages = end_pfn - start_pfn;
+
         /* set above range as isolated */
         ret = start_isolate_page_range(start_pfn, end_pfn);
         if (ret)
                 return ret;
-        nr_pages = end_pfn - start_pfn;
+
+        arg.start_pfn = start_pfn;
+        arg.nr_pages = nr_pages;
+        arg.status_change_nid = -1;
+        if (nr_pages >= node_present_pages(node))
+                arg.status_change_nid = node;
+
+        ret = memory_notify(MEM_GOING_OFFLINE, &arg);
+        ret = notifier_to_errno(ret);
+        if (ret)
+                goto failed_removal;
+
         pfn = start_pfn;
         expire = jiffies + timeout;
         drain = 0;
@@ -539,20 +577,24 @@ repeat:
         /* reset pagetype flags */
         start_isolate_page_range(start_pfn, end_pfn);
         /* removal success */
-        zone = page_zone(pfn_to_page(start_pfn));
         zone->present_pages -= offlined_pages;
         zone->zone_pgdat->node_present_pages -= offlined_pages;
         totalram_pages -= offlined_pages;
         num_physpages -= offlined_pages;
+
         vm_total_pages = nr_free_pagecache_pages();
         writeback_set_ratelimit();
+
+        memory_notify(MEM_OFFLINE, &arg);
         return 0;
 
 failed_removal:
         printk(KERN_INFO "memory offlining %lx to %lx failed\n",
                 start_pfn, end_pfn);
+        memory_notify(MEM_CANCEL_OFFLINE, &arg);
         /* pushback to free area */
         undo_isolate_page_range(start_pfn, end_pfn);
+
         return ret;
 }
 #else
diff --git a/mm/shmem.c b/mm/shmem.c
index 289dbb0a6fd6..404e53bb2127 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -2020,33 +2020,25 @@ static int shmem_match(struct inode *ino, void *vfh)
         return ino->i_ino == inum && fh[0] == ino->i_generation;
 }
 
-static struct dentry *shmem_get_dentry(struct super_block *sb, void *vfh)
+static struct dentry *shmem_fh_to_dentry(struct super_block *sb,
+                struct fid *fid, int fh_len, int fh_type)
 {
-        struct dentry *de = NULL;
         struct inode *inode;
-        __u32 *fh = vfh;
-        __u64 inum = fh[2];
-        inum = (inum << 32) | fh[1];
+        struct dentry *dentry = NULL;
+        u64 inum = fid->raw[2];
+        inum = (inum << 32) | fid->raw[1];
+
+        if (fh_len < 3)
+                return NULL;
 
-        inode = ilookup5(sb, (unsigned long)(inum+fh[0]), shmem_match, vfh);
+        inode = ilookup5(sb, (unsigned long)(inum + fid->raw[0]),
+                        shmem_match, fid->raw);
         if (inode) {
-                de = d_find_alias(inode);
+                dentry = d_find_alias(inode);
                 iput(inode);
         }
 
-        return de? de: ERR_PTR(-ESTALE);
-}
-
-static struct dentry *shmem_decode_fh(struct super_block *sb, __u32 *fh,
-                int len, int type,
-                int (*acceptable)(void *context, struct dentry *de),
-                void *context)
-{
-        if (len < 3)
-                return ERR_PTR(-ESTALE);
-
-        return sb->s_export_op->find_exported_dentry(sb, fh, NULL, acceptable,
-                                                        context);
+        return dentry;
 }
 
 static int shmem_encode_fh(struct dentry *dentry, __u32 *fh, int *len,
@@ -2079,11 +2071,10 @@ static int shmem_encode_fh(struct dentry *dentry, __u32 *fh, int *len,
         return 1;
 }
 
-static struct export_operations shmem_export_ops = {
+static const struct export_operations shmem_export_ops = {
         .get_parent     = shmem_get_parent,
-        .get_dentry     = shmem_get_dentry,
         .encode_fh      = shmem_encode_fh,
-        .decode_fh      = shmem_decode_fh,
+        .fh_to_dentry   = shmem_fh_to_dentry,
 };
 
 static int shmem_parse_options(char *options, int *mode, uid_t *uid,
diff --git a/mm/slub.c b/mm/slub.c
index e29a42988c78..aac1dd3c657d 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -20,6 +20,7 @@
 #include <linux/mempolicy.h>
 #include <linux/ctype.h>
 #include <linux/kallsyms.h>
+#include <linux/memory.h>
 
 /*
  * Lock order:
@@ -2694,6 +2695,121 @@ int kmem_cache_shrink(struct kmem_cache *s)
 }
 EXPORT_SYMBOL(kmem_cache_shrink);
 
+#if defined(CONFIG_NUMA) && defined(CONFIG_MEMORY_HOTPLUG)
+static int slab_mem_going_offline_callback(void *arg)
+{
+        struct kmem_cache *s;
+
+        down_read(&slub_lock);
+        list_for_each_entry(s, &slab_caches, list)
+                kmem_cache_shrink(s);
+        up_read(&slub_lock);
+
+        return 0;
+}
+
+static void slab_mem_offline_callback(void *arg)
+{
+        struct kmem_cache_node *n;
+        struct kmem_cache *s;
+        struct memory_notify *marg = arg;
+        int offline_node;
+
+        offline_node = marg->status_change_nid;
+
+        /*
+         * If the node still has available memory. we need kmem_cache_node
+         * for it yet.
+         */
+        if (offline_node < 0)
+                return;
+
+        down_read(&slub_lock);
+        list_for_each_entry(s, &slab_caches, list) {
+                n = get_node(s, offline_node);
+                if (n) {
+                        /*
+                         * if n->nr_slabs > 0, slabs still exist on the node
+                         * that is going down. We were unable to free them,
+                         * and offline_pages() function shoudn't call this
+                         * callback. So, we must fail.
+                         */
+                        BUG_ON(atomic_read(&n->nr_slabs));
+
+                        s->node[offline_node] = NULL;
+                        kmem_cache_free(kmalloc_caches, n);
+                }
+        }
+        up_read(&slub_lock);
+}
+
+static int slab_mem_going_online_callback(void *arg)
+{
+        struct kmem_cache_node *n;
+        struct kmem_cache *s;
+        struct memory_notify *marg = arg;
+        int nid = marg->status_change_nid;
+        int ret = 0;
+
+        /*
+         * If the node's memory is already available, then kmem_cache_node is
+         * already created. Nothing to do.
+         */
+        if (nid < 0)
+                return 0;
+
+        /*
+         * We are bringing a node online. No memory is availabe yet. We must
+         * allocate a kmem_cache_node structure in order to bring the node
+         * online.
+         */
+        down_read(&slub_lock);
+        list_for_each_entry(s, &slab_caches, list) {
+                /*
+                 * XXX: kmem_cache_alloc_node will fallback to other nodes
+                 *      since memory is not yet available from the node that
+                 *      is brought up.
+                 */
+                n = kmem_cache_alloc(kmalloc_caches, GFP_KERNEL);
+                if (!n) {
+                        ret = -ENOMEM;
+                        goto out;
+                }
+                init_kmem_cache_node(n);
+                s->node[nid] = n;
+        }
+out:
+        up_read(&slub_lock);
+        return ret;
+}
+
+static int slab_memory_callback(struct notifier_block *self,
+                                unsigned long action, void *arg)
+{
+        int ret = 0;
+
+        switch (action) {
+        case MEM_GOING_ONLINE:
+                ret = slab_mem_going_online_callback(arg);
+                break;
+        case MEM_GOING_OFFLINE:
+                ret = slab_mem_going_offline_callback(arg);
+                break;
+        case MEM_OFFLINE:
+        case MEM_CANCEL_ONLINE:
+                slab_mem_offline_callback(arg);
+                break;
+        case MEM_ONLINE:
+        case MEM_CANCEL_OFFLINE:
+                break;
+        }
+
+        ret = notifier_from_errno(ret);
+        return ret;
+}
+
+#endif /* CONFIG_MEMORY_HOTPLUG */
+
 /********************************************************************
  *                      Basic setup of slabs
  *******************************************************************/
@@ -2715,6 +2831,8 @@ void __init kmem_cache_init(void)
                 sizeof(struct kmem_cache_node), GFP_KERNEL);
         kmalloc_caches[0].refcount = -1;
         caches++;
+
+        hotplug_memory_notifier(slab_memory_callback, 1);
 #endif
 
         /* Able to allocate the per node structures */