slub: Fix up missing kmalloc_cache -> kmem_cache_node case for memoryhotplug
[linux-2.6.git] / mm / slub.c
index 78f1a20..b244a5a 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -17,7 +17,6 @@
 #include <linux/slab.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
-#include <linux/kmemtrace.h>
 #include <linux/kmemcheck.h>
 #include <linux/cpu.h>
 #include <linux/cpuset.h>
  *                     the fast path and disables lockless freelists.
  */
 
+#define SLAB_DEBUG_FLAGS (SLAB_RED_ZONE | SLAB_POISON | SLAB_STORE_USER | \
+               SLAB_TRACE | SLAB_DEBUG_FREE)
+
+static inline int kmem_cache_debug(struct kmem_cache *s)
+{
 #ifdef CONFIG_SLUB_DEBUG
-#define SLABDEBUG 1
+       return unlikely(s->flags & SLAB_DEBUG_FLAGS);
 #else
-#define SLABDEBUG 0
+       return 0;
 #endif
+}
 
 /*
  * Issues still to be resolved:
 #define SLUB_MERGE_SAME (SLAB_DEBUG_FREE | SLAB_RECLAIM_ACCOUNT | \
                SLAB_CACHE_DMA | SLAB_NOTRACK)
 
-#ifndef ARCH_KMALLOC_MINALIGN
-#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
-#endif
-
-#ifndef ARCH_SLAB_MINALIGN
-#define ARCH_SLAB_MINALIGN __alignof__(unsigned long long)
-#endif
-
 #define OO_SHIFT       16
 #define OO_MASK                ((1 << OO_SHIFT) - 1)
 #define MAX_OBJS_PER_PAGE      65535 /* since page.objects is u16 */
 
 /* Internal SLUB flags */
-#define __OBJECT_POISON                0x80000000 /* Poison object */
-#define __SYSFS_ADD_DEFERRED   0x40000000 /* Not yet visible via sysfs */
+#define __OBJECT_POISON                0x80000000UL /* Poison object */
 
 static int kmem_size = sizeof(struct kmem_cache);
 
@@ -181,7 +177,7 @@ static struct notifier_block slab_notifier;
 
 static enum {
        DOWN,           /* No slab functionality available */
-       PARTIAL,        /* kmem_cache_open() works but kmalloc does not */
+       PARTIAL,        /* Kmem_cache_node works */
        UP,             /* Everything works but does not show up in sysfs */
        SYSFS           /* Sysfs up */
 } slab_state = DOWN;
@@ -795,6 +791,39 @@ static void trace(struct kmem_cache *s, struct page *page, void *object,
 }
 
 /*
+ * Hooks for other subsystems that check memory allocations. In a typical
+ * production configuration these hooks all should produce no code at all.
+ */
+static inline int slab_pre_alloc_hook(struct kmem_cache *s, gfp_t flags)
+{
+       flags &= gfp_allowed_mask;
+       lockdep_trace_alloc(flags);
+       might_sleep_if(flags & __GFP_WAIT);
+
+       return should_failslab(s->objsize, flags, s->flags);
+}
+
+static inline void slab_post_alloc_hook(struct kmem_cache *s, gfp_t flags, void *object)
+{
+       flags &= gfp_allowed_mask;
+       kmemcheck_slab_alloc(s, flags, object, s->objsize);
+       kmemleak_alloc_recursive(object, s->objsize, 1, s->flags, flags);
+}
+
+static inline void slab_free_hook(struct kmem_cache *s, void *x)
+{
+       kmemleak_free_recursive(x, s->flags);
+}
+
+static inline void slab_free_hook_irq(struct kmem_cache *s, void *object)
+{
+       kmemcheck_slab_free(s, object, s->objsize);
+       debug_check_no_locks_freed(object, s->objsize);
+       if (!(s->flags & SLAB_DEBUG_OBJECTS))
+               debug_check_no_obj_freed(object, s->objsize);
+}
+
+/*
  * Tracking of fully allocated slabs for debugging purposes.
  */
 static void add_full(struct kmem_cache_node *n, struct page *page)
@@ -865,7 +894,7 @@ static void setup_object_debug(struct kmem_cache *s, struct page *page,
        init_tracking(s, object);
 }
 
-static int alloc_debug_processing(struct kmem_cache *s, struct page *page,
+static noinline int alloc_debug_processing(struct kmem_cache *s, struct page *page,
                                        void *object, unsigned long addr)
 {
        if (!check_slab(s, page))
@@ -905,8 +934,8 @@ bad:
        return 0;
 }
 
-static int free_debug_processing(struct kmem_cache *s, struct page *page,
-                                       void *object, unsigned long addr)
+static noinline int free_debug_processing(struct kmem_cache *s,
+                struct page *page, void *object, unsigned long addr)
 {
        if (!check_slab(s, page))
                goto fail;
@@ -1069,6 +1098,18 @@ static inline void inc_slabs_node(struct kmem_cache *s, int node,
                                                        int objects) {}
 static inline void dec_slabs_node(struct kmem_cache *s, int node,
                                                        int objects) {}
+
+static inline int slab_pre_alloc_hook(struct kmem_cache *s, gfp_t flags)
+                                                       { return 0; }
+
+static inline void slab_post_alloc_hook(struct kmem_cache *s, gfp_t flags,
+               void *object) {}
+
+static inline void slab_free_hook(struct kmem_cache *s, void *x) {}
+
+static inline void slab_free_hook_irq(struct kmem_cache *s,
+               void *object) {}
+
 #endif
 
 /*
@@ -1081,10 +1122,10 @@ static inline struct page *alloc_slab_page(gfp_t flags, int node,
 
        flags |= __GFP_NOTRACK;
 
-       if (node == -1)
+       if (node == NUMA_NO_NODE)
                return alloc_pages(flags, order);
        else
-               return alloc_pages_node(node, flags, order);
+               return alloc_pages_exact_node(node, flags, order);
 }
 
 static struct page *allocate_slab(struct kmem_cache *s, gfp_t flags, int node)
@@ -1165,9 +1206,6 @@ static struct page *new_slab(struct kmem_cache *s, gfp_t flags, int node)
        inc_slabs_node(s, page_to_nid(page), page->objects);
        page->slab = s;
        page->flags |= 1 << PG_slab;
-       if (s->flags & (SLAB_DEBUG_FREE | SLAB_RED_ZONE | SLAB_POISON |
-                       SLAB_STORE_USER | SLAB_TRACE))
-               __SetPageSlubDebug(page);
 
        start = page_address(page);
 
@@ -1194,14 +1232,13 @@ static void __free_slab(struct kmem_cache *s, struct page *page)
        int order = compound_order(page);
        int pages = 1 << order;
 
-       if (unlikely(SLABDEBUG && PageSlubDebug(page))) {
+       if (kmem_cache_debug(s)) {
                void *p;
 
                slab_pad_check(s, page);
                for_each_object(p, s, page_address(page),
                                                page->objects)
                        check_object(s, page, p, 0);
-               __ClearPageSlubDebug(page);
        }
 
        kmemcheck_free_shadow(page, compound_order(page));
@@ -1368,6 +1405,7 @@ static struct page *get_any_partial(struct kmem_cache *s, gfp_t flags)
                        get_cycles() % 1024 > s->remote_node_defrag_ratio)
                return NULL;
 
+       get_mems_allowed();
        zonelist = node_zonelist(slab_node(current->mempolicy), flags);
        for_each_zone_zonelist(zone, z, zonelist, high_zoneidx) {
                struct kmem_cache_node *n;
@@ -1377,10 +1415,13 @@ static struct page *get_any_partial(struct kmem_cache *s, gfp_t flags)
                if (n && cpuset_zone_allowed_hardwall(zone, flags) &&
                                n->nr_partial > s->min_partial) {
                        page = get_partial_node(n);
-                       if (page)
+                       if (page) {
+                               put_mems_allowed();
                                return page;
+                       }
                }
        }
+       put_mems_allowed();
 #endif
        return NULL;
 }
@@ -1391,10 +1432,10 @@ static struct page *get_any_partial(struct kmem_cache *s, gfp_t flags)
 static struct page *get_partial(struct kmem_cache *s, gfp_t flags, int node)
 {
        struct page *page;
-       int searchnode = (node == -1) ? numa_node_id() : node;
+       int searchnode = (node == NUMA_NO_NODE) ? numa_node_id() : node;
 
        page = get_partial_node(get_node(s, searchnode));
-       if (page || (flags & __GFP_THISNODE))
+       if (page || node != -1)
                return page;
 
        return get_any_partial(s, flags);
@@ -1419,8 +1460,7 @@ static void unfreeze_slab(struct kmem_cache *s, struct page *page, int tail)
                        stat(s, tail ? DEACTIVATE_TO_TAIL : DEACTIVATE_TO_HEAD);
                } else {
                        stat(s, DEACTIVATE_FULL);
-                       if (SLABDEBUG && PageSlubDebug(page) &&
-                                               (s->flags & SLAB_STORE_USER))
+                       if (kmem_cache_debug(s) && (s->flags & SLAB_STORE_USER))
                                add_full(n, page);
                }
                slab_unlock(page);
@@ -1519,7 +1559,7 @@ static void flush_all(struct kmem_cache *s)
 static inline int node_match(struct kmem_cache_cpu *c, int node)
 {
 #ifdef CONFIG_NUMA
-       if (node != -1 && c->node != node)
+       if (node != NUMA_NO_NODE && c->node != node)
                return 0;
 #endif
        return 1;
@@ -1628,7 +1668,7 @@ load_freelist:
        object = c->page->freelist;
        if (unlikely(!object))
                goto another_slab;
-       if (unlikely(SLABDEBUG && PageSlubDebug(c->page)))
+       if (kmem_cache_debug(s))
                goto debug;
 
        c->freelist = get_freepointer(s, object);
@@ -1651,6 +1691,7 @@ new_slab:
                goto load_freelist;
        }
 
+       gfpflags &= gfp_allowed_mask;
        if (gfpflags & __GFP_WAIT)
                local_irq_enable();
 
@@ -1699,12 +1740,7 @@ static __always_inline void *slab_alloc(struct kmem_cache *s,
        struct kmem_cache_cpu *c;
        unsigned long flags;
 
-       gfpflags &= gfp_allowed_mask;
-
-       lockdep_trace_alloc(gfpflags);
-       might_sleep_if(gfpflags & __GFP_WAIT);
-
-       if (should_failslab(s->objsize, gfpflags, s->flags))
+       if (slab_pre_alloc_hook(s, gfpflags))
                return NULL;
 
        local_irq_save(flags);
@@ -1723,15 +1759,14 @@ static __always_inline void *slab_alloc(struct kmem_cache *s,
        if (unlikely(gfpflags & __GFP_ZERO) && object)
                memset(object, 0, s->objsize);
 
-       kmemcheck_slab_alloc(s, gfpflags, object, s->objsize);
-       kmemleak_alloc_recursive(object, s->objsize, 1, s->flags, gfpflags);
+       slab_post_alloc_hook(s, gfpflags, object);
 
        return object;
 }
 
 void *kmem_cache_alloc(struct kmem_cache *s, gfp_t gfpflags)
 {
-       void *ret = slab_alloc(s, gfpflags, -1, _RET_IP_);
+       void *ret = slab_alloc(s, gfpflags, NUMA_NO_NODE, _RET_IP_);
 
        trace_kmem_cache_alloc(_RET_IP_, ret, s->objsize, s->size, gfpflags);
 
@@ -1742,7 +1777,7 @@ EXPORT_SYMBOL(kmem_cache_alloc);
 #ifdef CONFIG_TRACING
 void *kmem_cache_alloc_notrace(struct kmem_cache *s, gfp_t gfpflags)
 {
-       return slab_alloc(s, gfpflags, -1, _RET_IP_);
+       return slab_alloc(s, gfpflags, NUMA_NO_NODE, _RET_IP_);
 }
 EXPORT_SYMBOL(kmem_cache_alloc_notrace);
 #endif
@@ -1787,7 +1822,7 @@ static void __slab_free(struct kmem_cache *s, struct page *page,
        stat(s, FREE_SLOWPATH);
        slab_lock(page);
 
-       if (unlikely(SLABDEBUG && PageSlubDebug(page)))
+       if (kmem_cache_debug(s))
                goto debug;
 
 checks_ok:
@@ -1854,13 +1889,13 @@ static __always_inline void slab_free(struct kmem_cache *s,
        struct kmem_cache_cpu *c;
        unsigned long flags;
 
-       kmemleak_free_recursive(x, s->flags);
+       slab_free_hook(s, x);
+
        local_irq_save(flags);
        c = __this_cpu_ptr(s->cpu_slab);
-       kmemcheck_slab_free(s, object, s->objsize);
-       debug_check_no_locks_freed(object, s->objsize);
-       if (!(s->flags & SLAB_DEBUG_OBJECTS))
-               debug_check_no_obj_freed(object, s->objsize);
+
+       slab_free_hook_irq(s, x);
+
        if (likely(page == c->page && c->node >= 0)) {
                set_freepointer(s, object, c->freelist);
                c->freelist = object;
@@ -2066,26 +2101,19 @@ init_kmem_cache_node(struct kmem_cache_node *n, struct kmem_cache *s)
 #endif
 }
 
-static DEFINE_PER_CPU(struct kmem_cache_cpu, kmalloc_percpu[KMALLOC_CACHES]);
-
-static inline int alloc_kmem_cache_cpus(struct kmem_cache *s, gfp_t flags)
+static inline int alloc_kmem_cache_cpus(struct kmem_cache *s)
 {
-       if (s < kmalloc_caches + KMALLOC_CACHES && s >= kmalloc_caches)
-               /*
-                * Boot time creation of the kmalloc array. Use static per cpu data
-                * since the per cpu allocator is not available yet.
-                */
-               s->cpu_slab = kmalloc_percpu + (s - kmalloc_caches);
-       else
-               s->cpu_slab =  alloc_percpu(struct kmem_cache_cpu);
+       BUILD_BUG_ON(PERCPU_DYNAMIC_EARLY_SIZE <
+                       SLUB_PAGE_SHIFT * sizeof(struct kmem_cache_cpu));
 
-       if (!s->cpu_slab)
-               return 0;
+       s->cpu_slab = alloc_percpu(struct kmem_cache_cpu);
 
-       return 1;
+       return s->cpu_slab != NULL;
 }
 
 #ifdef CONFIG_NUMA
+static struct kmem_cache *kmem_cache_node;
+
 /*
  * No kmalloc_node yet so do it by hand. We know that this is the first
  * slab on the node for this slabcache. There are no concurrent accesses
@@ -2095,15 +2123,15 @@ static inline int alloc_kmem_cache_cpus(struct kmem_cache *s, gfp_t flags)
  * when allocating for the kmalloc_node_cache. This is used for bootstrapping
  * memory on a fresh node that has no slab structures yet.
  */
-static void early_kmem_cache_node_alloc(gfp_t gfpflags, int node)
+static void early_kmem_cache_node_alloc(int node)
 {
        struct page *page;
        struct kmem_cache_node *n;
        unsigned long flags;
 
-       BUG_ON(kmalloc_caches->size < sizeof(struct kmem_cache_node));
+       BUG_ON(kmem_cache_node->size < sizeof(struct kmem_cache_node));
 
-       page = new_slab(kmalloc_caches, gfpflags, node);
+       page = new_slab(kmem_cache_node, GFP_NOWAIT, node);
 
        BUG_ON(!page);
        if (page_to_nid(page) != node) {
@@ -2115,15 +2143,15 @@ static void early_kmem_cache_node_alloc(gfp_t gfpflags, int node)
 
        n = page->freelist;
        BUG_ON(!n);
-       page->freelist = get_freepointer(kmalloc_caches, n);
+       page->freelist = get_freepointer(kmem_cache_node, n);
        page->inuse++;
-       kmalloc_caches->node[node] = n;
+       kmem_cache_node->node[node] = n;
 #ifdef CONFIG_SLUB_DEBUG
-       init_object(kmalloc_caches, n, 1);
-       init_tracking(kmalloc_caches, n);
+       init_object(kmem_cache_node, n, 1);
+       init_tracking(kmem_cache_node, n);
 #endif
-       init_kmem_cache_node(n, kmalloc_caches);
-       inc_slabs_node(kmalloc_caches, node, page->objects);
+       init_kmem_cache_node(n, kmem_cache_node);
+       inc_slabs_node(kmem_cache_node, node, page->objects);
 
        /*
         * lockdep requires consistent irq usage for each lock
@@ -2141,42 +2169,33 @@ static void free_kmem_cache_nodes(struct kmem_cache *s)
 
        for_each_node_state(node, N_NORMAL_MEMORY) {
                struct kmem_cache_node *n = s->node[node];
-               if (n && n != &s->local_node)
-                       kmem_cache_free(kmalloc_caches, n);
+
+               if (n)
+                       kmem_cache_free(kmem_cache_node, n);
+
                s->node[node] = NULL;
        }
 }
 
-static int init_kmem_cache_nodes(struct kmem_cache *s, gfp_t gfpflags)
+static int init_kmem_cache_nodes(struct kmem_cache *s)
 {
        int node;
-       int local_node;
-
-       if (slab_state >= UP && (s < kmalloc_caches ||
-                       s >= kmalloc_caches + KMALLOC_CACHES))
-               local_node = page_to_nid(virt_to_page(s));
-       else
-               local_node = 0;
 
        for_each_node_state(node, N_NORMAL_MEMORY) {
                struct kmem_cache_node *n;
 
-               if (local_node == node)
-                       n = &s->local_node;
-               else {
-                       if (slab_state == DOWN) {
-                               early_kmem_cache_node_alloc(gfpflags, node);
-                               continue;
-                       }
-                       n = kmem_cache_alloc_node(kmalloc_caches,
-                                                       gfpflags, node);
-
-                       if (!n) {
-                               free_kmem_cache_nodes(s);
-                               return 0;
-                       }
+               if (slab_state == DOWN) {
+                       early_kmem_cache_node_alloc(node);
+                       continue;
+               }
+               n = kmem_cache_alloc_node(kmem_cache_node,
+                                               GFP_KERNEL, node);
 
+               if (!n) {
+                       free_kmem_cache_nodes(s);
+                       return 0;
                }
+
                s->node[node] = n;
                init_kmem_cache_node(n, s);
        }
@@ -2187,7 +2206,7 @@ static void free_kmem_cache_nodes(struct kmem_cache *s)
 {
 }
 
-static int init_kmem_cache_nodes(struct kmem_cache *s, gfp_t gfpflags)
+static int init_kmem_cache_nodes(struct kmem_cache *s)
 {
        init_kmem_cache_node(&s->local_node, s);
        return 1;
@@ -2327,7 +2346,7 @@ static int calculate_sizes(struct kmem_cache *s, int forced_order)
 
 }
 
-static int kmem_cache_open(struct kmem_cache *s, gfp_t gfpflags,
+static int kmem_cache_open(struct kmem_cache *s,
                const char *name, size_t size,
                size_t align, unsigned long flags,
                void (*ctor)(void *))
@@ -2363,10 +2382,10 @@ static int kmem_cache_open(struct kmem_cache *s, gfp_t gfpflags,
 #ifdef CONFIG_NUMA
        s->remote_node_defrag_ratio = 1000;
 #endif
-       if (!init_kmem_cache_nodes(s, gfpflags & ~SLUB_DMA))
+       if (!init_kmem_cache_nodes(s))
                goto error;
 
-       if (alloc_kmem_cache_cpus(s, gfpflags & ~SLUB_DMA))
+       if (alloc_kmem_cache_cpus(s))
                return 1;
 
        free_kmem_cache_nodes(s);
@@ -2505,7 +2524,6 @@ void kmem_cache_destroy(struct kmem_cache *s)
        s->refcount--;
        if (!s->refcount) {
                list_del(&s->list);
-               up_write(&slub_lock);
                if (kmem_cache_close(s)) {
                        printk(KERN_ERR "SLUB %s: %s called for cache that "
                                "still has objects.\n", s->name, __func__);
@@ -2514,8 +2532,8 @@ void kmem_cache_destroy(struct kmem_cache *s)
                if (s->flags & SLAB_DESTROY_BY_RCU)
                        rcu_barrier();
                sysfs_slab_remove(s);
-       } else
-               up_write(&slub_lock);
+       }
+       up_write(&slub_lock);
 }
 EXPORT_SYMBOL(kmem_cache_destroy);
 
@@ -2523,9 +2541,15 @@ EXPORT_SYMBOL(kmem_cache_destroy);
  *             Kmalloc subsystem
  *******************************************************************/
 
-struct kmem_cache kmalloc_caches[KMALLOC_CACHES] __cacheline_aligned;
+struct kmem_cache *kmalloc_caches[SLUB_PAGE_SHIFT];
 EXPORT_SYMBOL(kmalloc_caches);
 
+static struct kmem_cache *kmem_cache;
+
+#ifdef CONFIG_ZONE_DMA
+static struct kmem_cache *kmalloc_dma_caches[SLUB_PAGE_SHIFT];
+#endif
+
 static int __init setup_slub_min_order(char *str)
 {
        get_option(&str, &slub_min_order);
@@ -2562,116 +2586,29 @@ static int __init setup_slub_nomerge(char *str)
 
 __setup("slub_nomerge", setup_slub_nomerge);
 
-static struct kmem_cache *create_kmalloc_cache(struct kmem_cache *s,
-               const char *name, int size, gfp_t gfp_flags)
+static struct kmem_cache *__init create_kmalloc_cache(const char *name,
+                                               int size, unsigned int flags)
 {
-       unsigned int flags = 0;
+       struct kmem_cache *s;
 
-       if (gfp_flags & SLUB_DMA)
-               flags = SLAB_CACHE_DMA;
+       s = kmem_cache_alloc(kmem_cache, GFP_NOWAIT);
 
        /*
         * This function is called with IRQs disabled during early-boot on
         * single CPU so there's no need to take slub_lock here.
         */
-       if (!kmem_cache_open(s, gfp_flags, name, size, ARCH_KMALLOC_MINALIGN,
+       if (!kmem_cache_open(s, name, size, ARCH_KMALLOC_MINALIGN,
                                                                flags, NULL))
                goto panic;
 
        list_add(&s->list, &slab_caches);
-
-       if (sysfs_slab_add(s))
-               goto panic;
        return s;
 
 panic:
        panic("Creation of kmalloc slab %s size=%d failed.\n", name, size);
+       return NULL;
 }
 
-#ifdef CONFIG_ZONE_DMA
-static struct kmem_cache *kmalloc_caches_dma[SLUB_PAGE_SHIFT];
-
-static void sysfs_add_func(struct work_struct *w)
-{
-       struct kmem_cache *s;
-
-       down_write(&slub_lock);
-       list_for_each_entry(s, &slab_caches, list) {
-               if (s->flags & __SYSFS_ADD_DEFERRED) {
-                       s->flags &= ~__SYSFS_ADD_DEFERRED;
-                       sysfs_slab_add(s);
-               }
-       }
-       up_write(&slub_lock);
-}
-
-static DECLARE_WORK(sysfs_add_work, sysfs_add_func);
-
-static noinline struct kmem_cache *dma_kmalloc_cache(int index, gfp_t flags)
-{
-       struct kmem_cache *s;
-       char *text;
-       size_t realsize;
-       unsigned long slabflags;
-       int i;
-
-       s = kmalloc_caches_dma[index];
-       if (s)
-               return s;
-
-       /* Dynamically create dma cache */
-       if (flags & __GFP_WAIT)
-               down_write(&slub_lock);
-       else {
-               if (!down_write_trylock(&slub_lock))
-                       goto out;
-       }
-
-       if (kmalloc_caches_dma[index])
-               goto unlock_out;
-
-       realsize = kmalloc_caches[index].objsize;
-       text = kasprintf(flags & ~SLUB_DMA, "kmalloc_dma-%d",
-                        (unsigned int)realsize);
-
-       s = NULL;
-       for (i = 0; i < KMALLOC_CACHES; i++)
-               if (!kmalloc_caches[i].size)
-                       break;
-
-       BUG_ON(i >= KMALLOC_CACHES);
-       s = kmalloc_caches + i;
-
-       /*
-        * Must defer sysfs creation to a workqueue because we don't know
-        * what context we are called from. Before sysfs comes up, we don't
-        * need to do anything because our sysfs initcall will start by
-        * adding all existing slabs to sysfs.
-        */
-       slabflags = SLAB_CACHE_DMA|SLAB_NOTRACK;
-       if (slab_state >= SYSFS)
-               slabflags |= __SYSFS_ADD_DEFERRED;
-
-       if (!text || !kmem_cache_open(s, flags, text,
-                       realsize, ARCH_KMALLOC_MINALIGN, slabflags, NULL)) {
-               s->size = 0;
-               kfree(text);
-               goto unlock_out;
-       }
-
-       list_add(&s->list, &slab_caches);
-       kmalloc_caches_dma[index] = s;
-
-       if (slab_state >= SYSFS)
-               schedule_work(&sysfs_add_work);
-
-unlock_out:
-       up_write(&slub_lock);
-out:
-       return kmalloc_caches_dma[index];
-}
-#endif
-
 /*
  * Conversion table for small slabs sizes / 8 to the index in the
  * kmalloc array. This is necessary for slabs < 192 since we have non power
@@ -2724,10 +2661,10 @@ static struct kmem_cache *get_slab(size_t size, gfp_t flags)
 
 #ifdef CONFIG_ZONE_DMA
        if (unlikely((flags & SLUB_DMA)))
-               return dma_kmalloc_cache(index, flags);
+               return kmalloc_dma_caches[index];
 
 #endif
-       return &kmalloc_caches[index];
+       return kmalloc_caches[index];
 }
 
 void *__kmalloc(size_t size, gfp_t flags)
@@ -2743,7 +2680,7 @@ void *__kmalloc(size_t size, gfp_t flags)
        if (unlikely(ZERO_OR_NULL_PTR(s)))
                return s;
 
-       ret = slab_alloc(s, flags, -1, _RET_IP_);
+       ret = slab_alloc(s, flags, NUMA_NO_NODE, _RET_IP_);
 
        trace_kmalloc(_RET_IP_, ret, size, s->size, flags);
 
@@ -2972,7 +2909,7 @@ static void slab_mem_offline_callback(void *arg)
                        BUG_ON(slabs_node(s, offline_node));
 
                        s->node[offline_node] = NULL;
-                       kmem_cache_free(kmalloc_caches, n);
+                       kmem_cache_free(kmem_cache_node, n);
                }
        }
        up_read(&slub_lock);
@@ -3005,7 +2942,7 @@ static int slab_mem_going_online_callback(void *arg)
                 *      since memory is not yet available from the node that
                 *      is brought up.
                 */
-               n = kmem_cache_alloc(kmalloc_caches, GFP_KERNEL);
+               n = kmem_cache_alloc(kmem_cache_node, GFP_KERNEL);
                if (!n) {
                        ret = -ENOMEM;
                        goto out;
@@ -3051,46 +2988,113 @@ static int slab_memory_callback(struct notifier_block *self,
  *                     Basic setup of slabs
  *******************************************************************/
 
+/*
+ * Used for early kmem_cache structures that were allocated using
+ * the page allocator
+ */
+
+static void __init kmem_cache_bootstrap_fixup(struct kmem_cache *s)
+{
+       int node;
+
+       list_add(&s->list, &slab_caches);
+       s->refcount = -1;
+
+       for_each_node_state(node, N_NORMAL_MEMORY) {
+               struct kmem_cache_node *n = get_node(s, node);
+               struct page *p;
+
+               if (n) {
+                       list_for_each_entry(p, &n->partial, lru)
+                               p->slab = s;
+
+#ifdef CONFIG_SLAB_DEBUG
+                       list_for_each_entry(p, &n->full, lru)
+                               p->slab = s;
+#endif
+               }
+       }
+}
+
 void __init kmem_cache_init(void)
 {
        int i;
        int caches = 0;
+       struct kmem_cache *temp_kmem_cache;
+       int order;
 
 #ifdef CONFIG_NUMA
+       struct kmem_cache *temp_kmem_cache_node;
+       unsigned long kmalloc_size;
+
+       kmem_size = offsetof(struct kmem_cache, node) +
+                               nr_node_ids * sizeof(struct kmem_cache_node *);
+
+       /* Allocate two kmem_caches from the page allocator */
+       kmalloc_size = ALIGN(kmem_size, cache_line_size());
+       order = get_order(2 * kmalloc_size);
+       kmem_cache = (void *)__get_free_pages(GFP_NOWAIT, order);
+
        /*
         * Must first have the slab cache available for the allocations of the
         * struct kmem_cache_node's. There is special bootstrap code in
         * kmem_cache_open for slab_state == DOWN.
         */
-       create_kmalloc_cache(&kmalloc_caches[0], "kmem_cache_node",
-               sizeof(struct kmem_cache_node), GFP_NOWAIT);
-       kmalloc_caches[0].refcount = -1;
-       caches++;
+       kmem_cache_node = (void *)kmem_cache + kmalloc_size;
+
+       kmem_cache_open(kmem_cache_node, "kmem_cache_node",
+               sizeof(struct kmem_cache_node),
+               0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
 
        hotplug_memory_notifier(slab_memory_callback, SLAB_CALLBACK_PRI);
+#else
+       /* Allocate a single kmem_cache from the page allocator */
+       kmem_size = sizeof(struct kmem_cache);
+       order = get_order(kmem_size);
+       kmem_cache = (void *)__get_free_pages(GFP_NOWAIT, order);
 #endif
 
        /* Able to allocate the per node structures */
        slab_state = PARTIAL;
 
-       /* Caches that are not of the two-to-the-power-of size */
-       if (KMALLOC_MIN_SIZE <= 32) {
-               create_kmalloc_cache(&kmalloc_caches[1],
-                               "kmalloc-96", 96, GFP_NOWAIT);
-               caches++;
-       }
-       if (KMALLOC_MIN_SIZE <= 64) {
-               create_kmalloc_cache(&kmalloc_caches[2],
-                               "kmalloc-192", 192, GFP_NOWAIT);
-               caches++;
-       }
+       temp_kmem_cache = kmem_cache;
+       kmem_cache_open(kmem_cache, "kmem_cache", kmem_size,
+               0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
+       kmem_cache = kmem_cache_alloc(kmem_cache, GFP_NOWAIT);
+       memcpy(kmem_cache, temp_kmem_cache, kmem_size);
 
-       for (i = KMALLOC_SHIFT_LOW; i < SLUB_PAGE_SHIFT; i++) {
-               create_kmalloc_cache(&kmalloc_caches[i],
-                       "kmalloc", 1 << i, GFP_NOWAIT);
-               caches++;
-       }
+#ifdef CONFIG_NUMA
+       /*
+        * Allocate kmem_cache_node properly from the kmem_cache slab.
+        * kmem_cache_node is separately allocated so no need to
+        * update any list pointers.
+        */
+       temp_kmem_cache_node = kmem_cache_node;
 
+       kmem_cache_node = kmem_cache_alloc(kmem_cache, GFP_NOWAIT);
+       memcpy(kmem_cache_node, temp_kmem_cache_node, kmem_size);
+
+       kmem_cache_bootstrap_fixup(kmem_cache_node);
+
+       caches++;
+#else
+       /*
+        * kmem_cache has kmem_cache_node embedded and we moved it!
+        * Update the list heads
+        */
+       INIT_LIST_HEAD(&kmem_cache->local_node.partial);
+       list_splice(&temp_kmem_cache->local_node.partial, &kmem_cache->local_node.partial);
+#ifdef CONFIG_SLUB_DEBUG
+       INIT_LIST_HEAD(&kmem_cache->local_node.full);
+       list_splice(&temp_kmem_cache->local_node.full, &kmem_cache->local_node.full);
+#endif
+#endif
+       kmem_cache_bootstrap_fixup(kmem_cache);
+       caches++;
+       /* Free temporary boot structure */
+       free_pages((unsigned long)temp_kmem_cache, order);
+
+       /* Now we can use the kmem_cache to allocate kmalloc slabs */
 
        /*
         * Patch up the size_index table if we have strange large alignment
@@ -3130,23 +3134,50 @@ void __init kmem_cache_init(void)
                        size_index[size_index_elem(i)] = 8;
        }
 
+       /* Caches that are not of the two-to-the-power-of size */
+       if (KMALLOC_MIN_SIZE <= 32) {
+               kmalloc_caches[1] = create_kmalloc_cache("kmalloc-96", 96, 0);
+               caches++;
+       }
+
+       if (KMALLOC_MIN_SIZE <= 64) {
+               kmalloc_caches[2] = create_kmalloc_cache("kmalloc-192", 192, 0);
+               caches++;
+       }
+
+       for (i = KMALLOC_SHIFT_LOW; i < SLUB_PAGE_SHIFT; i++) {
+               kmalloc_caches[i] = create_kmalloc_cache("kmalloc", 1 << i, 0);
+               caches++;
+       }
+
        slab_state = UP;
 
        /* Provide the correct kmalloc names now that the caches are up */
-       for (i = KMALLOC_SHIFT_LOW; i < SLUB_PAGE_SHIFT; i++)
-               kmalloc_caches[i]. name =
-                       kasprintf(GFP_NOWAIT, "kmalloc-%d", 1 << i);
+       for (i = KMALLOC_SHIFT_LOW; i < SLUB_PAGE_SHIFT; i++) {
+               char *s = kasprintf(GFP_NOWAIT, "kmalloc-%d", 1 << i);
+
+               BUG_ON(!s);
+               kmalloc_caches[i]->name = s;
+       }
 
 #ifdef CONFIG_SMP
        register_cpu_notifier(&slab_notifier);
 #endif
-#ifdef CONFIG_NUMA
-       kmem_size = offsetof(struct kmem_cache, node) +
-                               nr_node_ids * sizeof(struct kmem_cache_node *);
-#else
-       kmem_size = sizeof(struct kmem_cache);
-#endif
 
+#ifdef CONFIG_ZONE_DMA
+       for (i = 0; i < SLUB_PAGE_SHIFT; i++) {
+               struct kmem_cache *s = kmalloc_caches[i];
+
+               if (s && s->size) {
+                       char *name = kasprintf(GFP_NOWAIT,
+                                "dma-kmalloc-%d", s->objsize);
+
+                       BUG_ON(!name);
+                       kmalloc_dma_caches[i] = create_kmalloc_cache(name,
+                               s->objsize, SLAB_CACHE_DMA);
+               }
+       }
+#endif
        printk(KERN_INFO
                "SLUB: Genslabs=%d, HWalign=%d, Order=%d-%d, MinObjects=%d,"
                " CPUs=%d, Nodes=%d\n",
@@ -3238,30 +3269,26 @@ struct kmem_cache *kmem_cache_create(const char *name, size_t size,
                 */
                s->objsize = max(s->objsize, (int)size);
                s->inuse = max_t(int, s->inuse, ALIGN(size, sizeof(void *)));
-               up_write(&slub_lock);
 
                if (sysfs_slab_alias(s, name)) {
-                       down_write(&slub_lock);
                        s->refcount--;
-                       up_write(&slub_lock);
                        goto err;
                }
+               up_write(&slub_lock);
                return s;
        }
 
        s = kmalloc(kmem_size, GFP_KERNEL);
        if (s) {
-               if (kmem_cache_open(s, GFP_KERNEL, name,
+               if (kmem_cache_open(s, name,
                                size, align, flags, ctor)) {
                        list_add(&s->list, &slab_caches);
-                       up_write(&slub_lock);
                        if (sysfs_slab_add(s)) {
-                               down_write(&slub_lock);
                                list_del(&s->list);
-                               up_write(&slub_lock);
                                kfree(s);
                                goto err;
                        }
+                       up_write(&slub_lock);
                        return s;
                }
                kfree(s);
@@ -3327,7 +3354,7 @@ void *__kmalloc_track_caller(size_t size, gfp_t gfpflags, unsigned long caller)
        if (unlikely(ZERO_OR_NULL_PTR(s)))
                return s;
 
-       ret = slab_alloc(s, gfpflags, -1, caller);
+       ret = slab_alloc(s, gfpflags, NUMA_NO_NODE, caller);
 
        /* Honor the call site pointer we recieved. */
        trace_kmalloc(caller, ret, size, s->size, gfpflags);
@@ -3341,8 +3368,15 @@ void *__kmalloc_node_track_caller(size_t size, gfp_t gfpflags,
        struct kmem_cache *s;
        void *ret;
 
-       if (unlikely(size > SLUB_MAX_SIZE))
-               return kmalloc_large_node(size, gfpflags, node);
+       if (unlikely(size > SLUB_MAX_SIZE)) {
+               ret = kmalloc_large_node(size, gfpflags, node);
+
+               trace_kmalloc_node(caller, ret,
+                                  size, PAGE_SIZE << get_order(size),
+                                  gfpflags, node);
+
+               return ret;
+       }
 
        s = get_slab(size, gfpflags);
 
@@ -3403,16 +3437,6 @@ static void validate_slab_slab(struct kmem_cache *s, struct page *page,
        } else
                printk(KERN_INFO "SLUB %s: Skipped busy slab 0x%p\n",
                        s->name, page);
-
-       if (s->flags & DEBUG_DEFAULT_FLAGS) {
-               if (!PageSlubDebug(page))
-                       printk(KERN_ERR "SLUB %s: SlubDebug not set "
-                               "on slab 0x%p\n", s->name, page);
-       } else {
-               if (PageSlubDebug(page))
-                       printk(KERN_ERR "SLUB %s: SlubDebug set on "
-                               "slab 0x%p\n", s->name, page);
-       }
 }
 
 static int validate_slab_node(struct kmem_cache *s,
@@ -4512,6 +4536,13 @@ static int sysfs_slab_add(struct kmem_cache *s)
 
 static void sysfs_slab_remove(struct kmem_cache *s)
 {
+       if (slab_state < SYSFS)
+               /*
+                * Sysfs has not been setup yet so no need to remove the
+                * cache from sysfs.
+                */
+               return;
+
        kobject_uevent(&s->kobj, KOBJ_REMOVE);
        kobject_del(&s->kobj);
        kobject_put(&s->kobj);
@@ -4557,8 +4588,11 @@ static int __init slab_sysfs_init(void)
        struct kmem_cache *s;
        int err;
 
+       down_write(&slub_lock);
+
        slab_kset = kset_create_and_add("slab", &slab_uevent_ops, kernel_kobj);
        if (!slab_kset) {
+               up_write(&slub_lock);
                printk(KERN_ERR "Cannot register slab subsystem.\n");
                return -ENOSYS;
        }
@@ -4583,6 +4617,7 @@ static int __init slab_sysfs_init(void)
                kfree(al);
        }
 
+       up_write(&slub_lock);
        resiliency_test();
        return 0;
 }