4 files changed, 229 insertions, 6 deletions

diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index c3852fd4a1cc..e30687bad075 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -19,10 +19,16 @@ struct page {
         unsigned long flags;            /* Atomic flags, some possibly
                                          * updated asynchronously */
         atomic_t _count;                /* Usage count, see below. */
-        atomic_t _mapcount;             /* Count of ptes mapped in mms,
+        union {
+                atomic_t _mapcount;     /* Count of ptes mapped in mms,
                                          * to show when page is mapped
                                          * & limit reverse map searches.
                                          */
+                struct {        /* SLUB uses */
+                        short unsigned int inuse;
+                        short unsigned int offset;
+                };
+        };
         union {
             struct {
                 unsigned long private;          /* Mapping-private opaque data:
@@ -43,8 +49,15 @@ struct page {
 #if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
             spinlock_t ptl;
 #endif
+            struct {                    /* SLUB uses */
+                struct page *first_page;        /* Compound pages */
+                struct kmem_cache *slab;        /* Pointer to slab */
+            };
+        };
+        union {
+                pgoff_t index;          /* Our offset within mapping. */
+                void *freelist;         /* SLUB: pointer to free object */
         };
-        pgoff_t index;                  /* Our offset within mapping. */
         struct list_head lru;           /* Pageout list, eg. active_list
                                          * protected by zone->lru_lock !
                                          */
diff --git a/include/linux/poison.h b/include/linux/poison.h
index 89580b764959..95f518b17684 100644
--- a/include/linux/poison.h
+++ b/include/linux/poison.h
@@ -18,6 +18,9 @@
 #define RED_INACTIVE    0x5A2CF071UL    /* when obj is inactive */
 #define RED_ACTIVE      0x170FC2A5UL    /* when obj is active */
 
+#define SLUB_RED_INACTIVE       0xbb
+#define SLUB_RED_ACTIVE         0xcc
+
 /* ...and for poisoning */
 #define POISON_INUSE    0x5a    /* for use-uninitialised poisoning */
 #define POISON_FREE     0x6b    /* for use-after-free poisoning */
diff --git a/include/linux/slab.h b/include/linux/slab.h
index f9ed9346bfd6..67425c277e12 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -32,6 +32,7 @@ typedef struct kmem_cache kmem_cache_t __deprecated;
 #define SLAB_PANIC              0x00040000UL    /* Panic if kmem_cache_create() fails */
 #define SLAB_DESTROY_BY_RCU     0x00080000UL    /* Defer freeing slabs to RCU */
 #define SLAB_MEM_SPREAD         0x00100000UL    /* Spread some memory over cpuset */
+#define SLAB_TRACE              0x00200000UL    /* Trace allocations and frees */
 
 /* Flags passed to a constructor functions */
 #define SLAB_CTOR_CONSTRUCTOR   0x001UL         /* If not set, then deconstructor */
@@ -42,7 +43,7 @@ typedef struct kmem_cache kmem_cache_t __deprecated;
  * struct kmem_cache related prototypes
  */
 void __init kmem_cache_init(void);
-extern int slab_is_available(void);
+int slab_is_available(void);
 
 struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
                         unsigned long,
@@ -95,9 +96,14 @@ static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
  * the appropriate general cache at compile time.
  */
 
-#ifdef CONFIG_SLAB
+#if defined(CONFIG_SLAB) || defined(CONFIG_SLUB)
+#ifdef CONFIG_SLUB
+#include <linux/slub_def.h>
+#else
 #include <linux/slab_def.h>
+#endif /* !CONFIG_SLUB */
 #else
+
 /*
  * Fallback definitions for an allocator not wanting to provide
  * its own optimized kmalloc definitions (like SLOB).
@@ -184,7 +190,7 @@ static inline void *__kmalloc_node(size_t size, gfp_t flags, int node)
  * allocator where we care about the real place the memory allocation
  * request comes from.
  */
-#ifdef CONFIG_DEBUG_SLAB
+#if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB)
 extern void *__kmalloc_track_caller(size_t, gfp_t, void*);
 #define kmalloc_track_caller(size, flags) \
         __kmalloc_track_caller(size, flags, __builtin_return_address(0))
@@ -202,7 +208,7 @@ extern void *__kmalloc_track_caller(size_t, gfp_t, void*);
  * standard allocator where we care about the real place the memory
  * allocation request comes from.
  */
-#ifdef CONFIG_DEBUG_SLAB
+#if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB)
 extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, void *);
 #define kmalloc_node_track_caller(size, flags, node) \
         __kmalloc_node_track_caller(size, flags, node, \
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
new file mode 100644
index 000000000000..30b154ce7289
--- /dev/null
+++ b/include/linux/slub_def.h
@@ -0,0 +1,201 @@
+#ifndef _LINUX_SLUB_DEF_H
+#define _LINUX_SLUB_DEF_H
+
+/*
+ * SLUB : A Slab allocator without object queues.
+ *
+ * (C) 2007 SGI, Christoph Lameter <clameter@sgi.com>
+ */
+#include <linux/types.h>
+#include <linux/gfp.h>
+#include <linux/workqueue.h>
+#include <linux/kobject.h>
+
+struct kmem_cache_node {
+        spinlock_t list_lock;   /* Protect partial list and nr_partial */
+        unsigned long nr_partial;
+        atomic_long_t nr_slabs;
+        struct list_head partial;
+};
+
+/*
+ * Slab cache management.
+ */
+struct kmem_cache {
+        /* Used for retriving partial slabs etc */
+        unsigned long flags;
+        int size;               /* The size of an object including meta data */
+        int objsize;            /* The size of an object without meta data */
+        int offset;             /* Free pointer offset. */
+        unsigned int order;
+
+        /*
+         * Avoid an extra cache line for UP, SMP and for the node local to
+         * struct kmem_cache.
+         */
+        struct kmem_cache_node local_node;
+
+        /* Allocation and freeing of slabs */
+        int objects;            /* Number of objects in slab */
+        int refcount;           /* Refcount for slab cache destroy */
+        void (*ctor)(void *, struct kmem_cache *, unsigned long);
+        void (*dtor)(void *, struct kmem_cache *, unsigned long);
+        int inuse;              /* Offset to metadata */
+        int align;              /* Alignment */
+        const char *name;       /* Name (only for display!) */
+        struct list_head list;  /* List of slab caches */
+        struct kobject kobj;    /* For sysfs */
+
+#ifdef CONFIG_NUMA
+        int defrag_ratio;
+        struct kmem_cache_node *node[MAX_NUMNODES];
+#endif
+        struct page *cpu_slab[NR_CPUS];
+};
+
+/*
+ * Kmalloc subsystem.
+ */
+#define KMALLOC_SHIFT_LOW 3
+
+#ifdef CONFIG_LARGE_ALLOCS
+#define KMALLOC_SHIFT_HIGH 25
+#else
+#if !defined(CONFIG_MMU) || NR_CPUS > 512 || MAX_NUMNODES > 256
+#define KMALLOC_SHIFT_HIGH 20
+#else
+#define KMALLOC_SHIFT_HIGH 18
+#endif
+#endif
+
+/*
+ * We keep the general caches in an array of slab caches that are used for
+ * 2^x bytes of allocations.
+ */
+extern struct kmem_cache kmalloc_caches[KMALLOC_SHIFT_HIGH + 1];
+
+/*
+ * Sorry that the following has to be that ugly but some versions of GCC
+ * have trouble with constant propagation and loops.
+ */
+static inline int kmalloc_index(int size)
+{
+        if (size == 0)
+                return 0;
+        if (size > 64 && size <= 96)
+                return 1;
+        if (size > 128 && size <= 192)
+                return 2;
+        if (size <=          8) return 3;
+        if (size <=         16) return 4;
+        if (size <=         32) return 5;
+        if (size <=         64) return 6;
+        if (size <=        128) return 7;
+        if (size <=        256) return 8;
+        if (size <=        512) return 9;
+        if (size <=       1024) return 10;
+        if (size <=   2 * 1024) return 11;
+        if (size <=   4 * 1024) return 12;
+        if (size <=   8 * 1024) return 13;
+        if (size <=  16 * 1024) return 14;
+        if (size <=  32 * 1024) return 15;
+        if (size <=  64 * 1024) return 16;
+        if (size <= 128 * 1024) return 17;
+        if (size <= 256 * 1024) return 18;
+#if KMALLOC_SHIFT_HIGH > 18
+        if (size <=  512 * 1024) return 19;
+        if (size <= 1024 * 1024) return 20;
+#endif
+#if KMALLOC_SHIFT_HIGH > 20
+        if (size <=  2 * 1024 * 1024) return 21;
+        if (size <=  4 * 1024 * 1024) return 22;
+        if (size <=  8 * 1024 * 1024) return 23;
+        if (size <= 16 * 1024 * 1024) return 24;
+        if (size <= 32 * 1024 * 1024) return 25;
+#endif
+        return -1;
+
+/*
+ * What we really wanted to do and cannot do because of compiler issues is:
+ *      int i;
+ *      for (i = KMALLOC_SHIFT_LOW; i <= KMALLOC_SHIFT_HIGH; i++)
+ *              if (size <= (1 << i))
+ *                      return i;
+ */
+}
+
+/*
+ * Find the slab cache for a given combination of allocation flags and size.
+ *
+ * This ought to end up with a global pointer to the right cache
+ * in kmalloc_caches.
+ */
+static inline struct kmem_cache *kmalloc_slab(size_t size)
+{
+        int index = kmalloc_index(size);
+
+        if (index == 0)
+                return NULL;
+
+        if (index < 0) {
+                /*
+                 * Generate a link failure. Would be great if we could
+                 * do something to stop the compile here.
+                 */
+                extern void __kmalloc_size_too_large(void);
+                __kmalloc_size_too_large();
+        }
+        return &kmalloc_caches[index];
+}
+
+#ifdef CONFIG_ZONE_DMA
+#define SLUB_DMA __GFP_DMA
+#else
+/* Disable DMA functionality */
+#define SLUB_DMA 0
+#endif
+
+static inline void *kmalloc(size_t size, gfp_t flags)
+{
+        if (__builtin_constant_p(size) && !(flags & SLUB_DMA)) {
+                struct kmem_cache *s = kmalloc_slab(size);
+
+                if (!s)
+                        return NULL;
+
+                return kmem_cache_alloc(s, flags);
+        } else
+                return __kmalloc(size, flags);
+}
+
+static inline void *kzalloc(size_t size, gfp_t flags)
+{
+        if (__builtin_constant_p(size) && !(flags & SLUB_DMA)) {
+                struct kmem_cache *s = kmalloc_slab(size);
+
+                if (!s)
+                        return NULL;
+
+                return kmem_cache_zalloc(s, flags);
+        } else
+                return __kzalloc(size, flags);
+}
+
+#ifdef CONFIG_NUMA
+extern void *__kmalloc_node(size_t size, gfp_t flags, int node);
+
+static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
+{
+        if (__builtin_constant_p(size) && !(flags & SLUB_DMA)) {
+                struct kmem_cache *s = kmalloc_slab(size);
+
+                if (!s)
+                        return NULL;
+
+                return kmem_cache_alloc_node(s, flags, node);
+        } else
+                return __kmalloc_node(size, flags, node);
+}
+#endif
+
+#endif /* _LINUX_SLUB_DEF_H */