Merge git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-rc-fixes-2.6

[cascardo/linux.git] / mm / slub.c

diff --git a/mm/slub.c b/mm/slub.c
index e29a429..9acb413 100644 (file)
--- 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:
@@ -1079,7 +1080,6 @@ static struct page *new_slab(struct kmem_cache *s, gfp_t flags, int node)
        struct page *page;
        struct kmem_cache_node *n;
        void *start;
-       void *end;
        void *last;
        void *p;
 
@@ -1100,7 +1100,6 @@ static struct page *new_slab(struct kmem_cache *s, gfp_t flags, int node)
                SetSlabDebug(page);
 
        start = page_address(page);
-       end = start + s->objects * s->size;
 
        if (unlikely(s->flags & SLAB_POISON))
                memset(start, POISON_INUSE, PAGE_SIZE << s->order);
@@ -1510,26 +1509,8 @@ new_slab:
 
        if (new) {
                c = get_cpu_slab(s, smp_processor_id());
-               if (c->page) {
-                       /*
-                        * Someone else populated the cpu_slab while we
-                        * enabled interrupts, or we have gotten scheduled
-                        * on another cpu. The page may not be on the
-                        * requested node even if __GFP_THISNODE was
-                        * specified. So we need to recheck.
-                        */
-                       if (node_match(c, node)) {
-                               /*
-                                * Current cpuslab is acceptable and we
-                                * want the current one since its cache hot
-                                */
-                               discard_slab(s, new);
-                               slab_lock(c->page);
-                               goto load_freelist;
-                       }
-                       /* New slab does not fit our expectations */
+               if (c->page)
                        flush_slab(s, c);
-               }
                slab_lock(new);
                SetSlabFrozen(new);
                c->page = new;
@@ -2694,6 +2675,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_long_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 +2811,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 */