4 files changed, 293 insertions, 19 deletions

diff --git a/Documentation/vm/slabinfo.c b/Documentation/vm/slabinfo.c
index 488c1f31b992..7123fee708ca 100644
--- a/Documentation/vm/slabinfo.c
+++ b/Documentation/vm/slabinfo.c
@@ -32,6 +32,13 @@ struct slabinfo {
         int sanity_checks, slab_size, store_user, trace;
         int order, poison, reclaim_account, red_zone;
         unsigned long partial, objects, slabs;
+        unsigned long alloc_fastpath, alloc_slowpath;
+        unsigned long free_fastpath, free_slowpath;
+        unsigned long free_frozen, free_add_partial, free_remove_partial;
+        unsigned long alloc_from_partial, alloc_slab, free_slab, alloc_refill;
+        unsigned long cpuslab_flush, deactivate_full, deactivate_empty;
+        unsigned long deactivate_to_head, deactivate_to_tail;
+        unsigned long deactivate_remote_frees;
         int numa[MAX_NODES];
         int numa_partial[MAX_NODES];
 } slabinfo[MAX_SLABS];
@@ -64,8 +71,10 @@ int show_inverted = 0;
 int show_single_ref = 0;
 int show_totals = 0;
 int sort_size = 0;
+int sort_active = 0;
 int set_debug = 0;
 int show_ops = 0;
+int show_activity = 0;
 
 /* Debug options */
 int sanity = 0;
@@ -93,8 +102,10 @@ void usage(void)
         printf("slabinfo 5/7/2007. (c) 2007 sgi. clameter@sgi.com\n\n"
                 "slabinfo [-ahnpvtsz] [-d debugopts] [slab-regexp]\n"
                 "-a|--aliases           Show aliases\n"
+                "-A|--activity          Most active slabs first\n"
                 "-d<options>|--debug=<options> Set/Clear Debug options\n"
-                "-e|--empty             Show empty slabs\n"
+                "-D|--display-active    Switch line format to activity\n"
+                "-e|--empty             Show empty slabs\n"
                 "-f|--first-alias       Show first alias\n"
                 "-h|--help              Show usage information\n"
                 "-i|--inverted          Inverted list\n"
@@ -281,8 +292,11 @@ int line = 0;
 
 void first_line(void)
 {
-        printf("Name                   Objects Objsize    Space "
-                "Slabs/Part/Cpu  O/S O %%Fr %%Ef Flg\n");
+        if (show_activity)
+                printf("Name                   Objects    Alloc     Free   %%Fast\n");
+        else
+                printf("Name                   Objects Objsize    Space "
+                        "Slabs/Part/Cpu  O/S O %%Fr %%Ef Flg\n");
 }
 
 /*
@@ -309,6 +323,12 @@ unsigned long slab_size(struct slabinfo *s)
         return  s->slabs * (page_size << s->order);
 }
 
+unsigned long slab_activity(struct slabinfo *s)
+{
+        return  s->alloc_fastpath + s->free_fastpath +
+                s->alloc_slowpath + s->free_slowpath;
+}
+
 void slab_numa(struct slabinfo *s, int mode)
 {
         int node;
@@ -392,6 +412,71 @@ const char *onoff(int x)
         return "Off";
 }
 
+void slab_stats(struct slabinfo *s)
+{
+        unsigned long total_alloc;
+        unsigned long total_free;
+        unsigned long total;
+
+        if (!s->alloc_slab)
+                return;
+
+        total_alloc = s->alloc_fastpath + s->alloc_slowpath;
+        total_free = s->free_fastpath + s->free_slowpath;
+
+        if (!total_alloc)
+                return;
+
+        printf("\n");
+        printf("Slab Perf Counter       Alloc     Free %%Al %%Fr\n");
+        printf("--------------------------------------------------\n");
+        printf("Fastpath             %8lu %8lu %3lu %3lu\n",
+                s->alloc_fastpath, s->free_fastpath,
+                s->alloc_fastpath * 100 / total_alloc,
+                s->free_fastpath * 100 / total_free);
+        printf("Slowpath             %8lu %8lu %3lu %3lu\n",
+                total_alloc - s->alloc_fastpath, s->free_slowpath,
+                (total_alloc - s->alloc_fastpath) * 100 / total_alloc,
+                s->free_slowpath * 100 / total_free);
+        printf("Page Alloc           %8lu %8lu %3lu %3lu\n",
+                s->alloc_slab, s->free_slab,
+                s->alloc_slab * 100 / total_alloc,
+                s->free_slab * 100 / total_free);
+        printf("Add partial          %8lu %8lu %3lu %3lu\n",
+                s->deactivate_to_head + s->deactivate_to_tail,
+                s->free_add_partial,
+                (s->deactivate_to_head + s->deactivate_to_tail) * 100 / total_alloc,
+                s->free_add_partial * 100 / total_free);
+        printf("Remove partial       %8lu %8lu %3lu %3lu\n",
+                s->alloc_from_partial, s->free_remove_partial,
+                s->alloc_from_partial * 100 / total_alloc,
+                s->free_remove_partial * 100 / total_free);
+
+        printf("RemoteObj/SlabFrozen %8lu %8lu %3lu %3lu\n",
+                s->deactivate_remote_frees, s->free_frozen,
+                s->deactivate_remote_frees * 100 / total_alloc,
+                s->free_frozen * 100 / total_free);
+
+        printf("Total                %8lu %8lu\n\n", total_alloc, total_free);
+
+        if (s->cpuslab_flush)
+                printf("Flushes %8lu\n", s->cpuslab_flush);
+
+        if (s->alloc_refill)
+                printf("Refill %8lu\n", s->alloc_refill);
+
+        total = s->deactivate_full + s->deactivate_empty +
+                        s->deactivate_to_head + s->deactivate_to_tail;
+
+        if (total)
+                printf("Deactivate Full=%lu(%lu%%) Empty=%lu(%lu%%) "
+                        "ToHead=%lu(%lu%%) ToTail=%lu(%lu%%)\n",
+                        s->deactivate_full, (s->deactivate_full * 100) / total,
+                        s->deactivate_empty, (s->deactivate_empty * 100) / total,
+                        s->deactivate_to_head, (s->deactivate_to_head * 100) / total,
+                        s->deactivate_to_tail, (s->deactivate_to_tail * 100) / total);
+}
+
 void report(struct slabinfo *s)
 {
         if (strcmp(s->name, "*") == 0)
@@ -430,6 +515,7 @@ void report(struct slabinfo *s)
         ops(s);
         show_tracking(s);
         slab_numa(s, 1);
+        slab_stats(s);
 }
 
 void slabcache(struct slabinfo *s)
@@ -479,13 +565,27 @@ void slabcache(struct slabinfo *s)
                 *p++ = 'T';
 
         *p = 0;
-        printf("%-21s %8ld %7d %8s %14s %4d %1d %3ld %3ld %s\n",
-                s->name, s->objects, s->object_size, size_str, dist_str,
-                s->objs_per_slab, s->order,
-                s->slabs ? (s->partial * 100) / s->slabs : 100,
-                s->slabs ? (s->objects * s->object_size * 100) /
-                        (s->slabs * (page_size << s->order)) : 100,
-                flags);
+        if (show_activity) {
+                unsigned long total_alloc;
+                unsigned long total_free;
+
+                total_alloc = s->alloc_fastpath + s->alloc_slowpath;
+                total_free = s->free_fastpath + s->free_slowpath;
+
+                printf("%-21s %8ld %8ld %8ld %3ld %3ld \n",
+                        s->name, s->objects,
+                        total_alloc, total_free,
+                        total_alloc ? (s->alloc_fastpath * 100 / total_alloc) : 0,
+                        total_free ? (s->free_fastpath * 100 / total_free) : 0);
+        }
+        else
+                printf("%-21s %8ld %7d %8s %14s %4d %1d %3ld %3ld %s\n",
+                        s->name, s->objects, s->object_size, size_str, dist_str,
+                        s->objs_per_slab, s->order,
+                        s->slabs ? (s->partial * 100) / s->slabs : 100,
+                        s->slabs ? (s->objects * s->object_size * 100) /
+                                (s->slabs * (page_size << s->order)) : 100,
+                        flags);
 }
 
 /*
@@ -892,6 +992,8 @@ void sort_slabs(void)
 
                         if (sort_size)
                                 result = slab_size(s1) < slab_size(s2);
+                        else if (sort_active)
+                                result = slab_activity(s1) < slab_activity(s2);
                         else
                                 result = strcasecmp(s1->name, s2->name);
 
@@ -1074,6 +1176,23 @@ void read_slab_dir(void)
                         free(t);
                         slab->store_user = get_obj("store_user");
                         slab->trace = get_obj("trace");
+                        slab->alloc_fastpath = get_obj("alloc_fastpath");
+                        slab->alloc_slowpath = get_obj("alloc_slowpath");
+                        slab->free_fastpath = get_obj("free_fastpath");
+                        slab->free_slowpath = get_obj("free_slowpath");
+                        slab->free_frozen= get_obj("free_frozen");
+                        slab->free_add_partial = get_obj("free_add_partial");
+                        slab->free_remove_partial = get_obj("free_remove_partial");
+                        slab->alloc_from_partial = get_obj("alloc_from_partial");
+                        slab->alloc_slab = get_obj("alloc_slab");
+                        slab->alloc_refill = get_obj("alloc_refill");
+                        slab->free_slab = get_obj("free_slab");
+                        slab->cpuslab_flush = get_obj("cpuslab_flush");
+                        slab->deactivate_full = get_obj("deactivate_full");
+                        slab->deactivate_empty = get_obj("deactivate_empty");
+                        slab->deactivate_to_head = get_obj("deactivate_to_head");
+                        slab->deactivate_to_tail = get_obj("deactivate_to_tail");
+                        slab->deactivate_remote_frees = get_obj("deactivate_remote_frees");
                         chdir("..");
                         if (slab->name[0] == ':')
                                 alias_targets++;
@@ -1124,7 +1243,9 @@ void output_slabs(void)
 
 struct option opts[] = {
         { "aliases", 0, NULL, 'a' },
+        { "activity", 0, NULL, 'A' },
         { "debug", 2, NULL, 'd' },
+        { "display-activity", 0, NULL, 'D' },
         { "empty", 0, NULL, 'e' },
         { "first-alias", 0, NULL, 'f' },
         { "help", 0, NULL, 'h' },
@@ -1149,7 +1270,7 @@ int main(int argc, char *argv[])
 
         page_size = getpagesize();
 
-        while ((c = getopt_long(argc, argv, "ad::efhil1noprstvzTS",
+        while ((c = getopt_long(argc, argv, "aAd::Defhil1noprstvzTS",
                                                 opts, NULL)) != -1)
                 switch (c) {
                 case '1':
@@ -1158,11 +1279,17 @@ int main(int argc, char *argv[])
                 case 'a':
                         show_alias = 1;
                         break;
+                case 'A':
+                        sort_active = 1;
+                        break;
                 case 'd':
                         set_debug = 1;
                         if (!debug_opt_scan(optarg))
                                 fatal("Invalid debug option '%s'\n", optarg);
                         break;
+                case 'D':
+                        show_activity = 1;
+                        break;
                 case 'e':
                         show_empty = 1;
                         break;
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index ddb1a706b144..5e6d3d634d5b 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -11,12 +11,35 @@
 #include <linux/workqueue.h>
 #include <linux/kobject.h>
 
+enum stat_item {
+        ALLOC_FASTPATH,         /* Allocation from cpu slab */
+        ALLOC_SLOWPATH,         /* Allocation by getting a new cpu slab */
+        FREE_FASTPATH,          /* Free to cpu slub */
+        FREE_SLOWPATH,          /* Freeing not to cpu slab */
+        FREE_FROZEN,            /* Freeing to frozen slab */
+        FREE_ADD_PARTIAL,       /* Freeing moves slab to partial list */
+        FREE_REMOVE_PARTIAL,    /* Freeing removes last object */
+        ALLOC_FROM_PARTIAL,     /* Cpu slab acquired from partial list */
+        ALLOC_SLAB,             /* Cpu slab acquired from page allocator */
+        ALLOC_REFILL,           /* Refill cpu slab from slab freelist */
+        FREE_SLAB,              /* Slab freed to the page allocator */
+        CPUSLAB_FLUSH,          /* Abandoning of the cpu slab */
+        DEACTIVATE_FULL,        /* Cpu slab was full when deactivated */
+        DEACTIVATE_EMPTY,       /* Cpu slab was empty when deactivated */
+        DEACTIVATE_TO_HEAD,     /* Cpu slab was moved to the head of partials */
+        DEACTIVATE_TO_TAIL,     /* Cpu slab was moved to the tail of partials */
+        DEACTIVATE_REMOTE_FREES,/* Slab contained remotely freed objects */
+        NR_SLUB_STAT_ITEMS };
+
 struct kmem_cache_cpu {
         void **freelist;        /* Pointer to first free per cpu object */
         struct page *page;      /* The slab from which we are allocating */
         int node;               /* The node of the page (or -1 for debug) */
         unsigned int offset;    /* Freepointer offset (in word units) */
         unsigned int objsize;   /* Size of an object (from kmem_cache) */
+#ifdef CONFIG_SLUB_STATS
+        unsigned stat[NR_SLUB_STAT_ITEMS];
+#endif
 };
 
 struct kmem_cache_node {
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 0d385be682db..4f4008fc73e4 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -205,6 +205,19 @@ config SLUB_DEBUG_ON
           off in a kernel built with CONFIG_SLUB_DEBUG_ON by specifying
           "slub_debug=-".
 
+config SLUB_STATS
+        default n
+        bool "Enable SLUB performance statistics"
+        depends on SLUB
+        help
+          SLUB statistics are useful to debug SLUBs allocation behavior in
+          order find ways to optimize the allocator. This should never be
+          enabled for production use since keeping statistics slows down
+          the allocator by a few percentage points. The slabinfo command
+          supports the determination of the most active slabs to figure
+          out which slabs are relevant to a particular load.
+          Try running: slabinfo -DA
+
 config DEBUG_PREEMPT
         bool "Debug preemptible kernel"
         depends on DEBUG_KERNEL && PREEMPT && (TRACE_IRQFLAGS_SUPPORT || PPC64)
diff --git a/mm/slub.c b/mm/slub.c
index 20ab8f0a4eb9..ac836d31e3be 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -250,6 +250,7 @@ enum track_item { TRACK_ALLOC, TRACK_FREE };
 static int sysfs_slab_add(struct kmem_cache *);
 static int sysfs_slab_alias(struct kmem_cache *, const char *);
 static void sysfs_slab_remove(struct kmem_cache *);
+
 #else
 static inline int sysfs_slab_add(struct kmem_cache *s) { return 0; }
 static inline int sysfs_slab_alias(struct kmem_cache *s, const char *p)
@@ -258,8 +259,16 @@ static inline void sysfs_slab_remove(struct kmem_cache *s)
 {
         kfree(s);
 }
+
 #endif
 
+static inline void stat(struct kmem_cache_cpu *c, enum stat_item si)
+{
+#ifdef CONFIG_SLUB_STATS
+        c->stat[si]++;
+#endif
+}
+
 /********************************************************************
  *                      Core slab cache functions
  *******************************************************************/
@@ -1364,17 +1373,22 @@ static struct page *get_partial(struct kmem_cache *s, gfp_t flags, int node)
 static void unfreeze_slab(struct kmem_cache *s, struct page *page, int tail)
 {
         struct kmem_cache_node *n = get_node(s, page_to_nid(page));
+        struct kmem_cache_cpu *c = get_cpu_slab(s, smp_processor_id());
 
         ClearSlabFrozen(page);
         if (page->inuse) {
 
-                if (page->freelist != page->end)
+                if (page->freelist != page->end) {
                         add_partial(n, page, tail);
-                else if (SlabDebug(page) && (s->flags & SLAB_STORE_USER))
-                        add_full(n, page);
+                        stat(c, tail ? DEACTIVATE_TO_TAIL : DEACTIVATE_TO_HEAD);
+                } else {
+                        stat(c, DEACTIVATE_FULL);
+                        if (SlabDebug(page) && (s->flags & SLAB_STORE_USER))
+                                add_full(n, page);
+                }
                 slab_unlock(page);
-
         } else {
+                stat(c, DEACTIVATE_EMPTY);
                 if (n->nr_partial < MIN_PARTIAL) {
                         /*
                          * Adding an empty slab to the partial slabs in order
@@ -1388,6 +1402,7 @@ static void unfreeze_slab(struct kmem_cache *s, struct page *page, int tail)
                         slab_unlock(page);
                 } else {
                         slab_unlock(page);
+                        stat(get_cpu_slab(s, raw_smp_processor_id()), FREE_SLAB);
                         discard_slab(s, page);
                 }
         }
@@ -1400,6 +1415,9 @@ static void deactivate_slab(struct kmem_cache *s, struct kmem_cache_cpu *c)
 {
         struct page *page = c->page;
         int tail = 1;
+
+        if (c->freelist)
+                stat(c, DEACTIVATE_REMOTE_FREES);
         /*
          * Merge cpu freelist into freelist. Typically we get here
          * because both freelists are empty. So this is unlikely
@@ -1429,6 +1447,7 @@ static void deactivate_slab(struct kmem_cache *s, struct kmem_cache_cpu *c)
 
 static inline void flush_slab(struct kmem_cache *s, struct kmem_cache_cpu *c)
 {
+        stat(c, CPUSLAB_FLUSH);
         slab_lock(c->page);
         deactivate_slab(s, c);
 }
@@ -1511,6 +1530,7 @@ static void *__slab_alloc(struct kmem_cache *s,
         slab_lock(c->page);
         if (unlikely(!node_match(c, node)))
                 goto another_slab;
+        stat(c, ALLOC_REFILL);
 load_freelist:
         object = c->page->freelist;
         if (unlikely(object == c->page->end))
@@ -1525,6 +1545,7 @@ load_freelist:
         c->node = page_to_nid(c->page);
 unlock_out:
         slab_unlock(c->page);
+        stat(c, ALLOC_SLOWPATH);
 out:
 #ifdef SLUB_FASTPATH
         local_irq_restore(flags);
@@ -1538,6 +1559,7 @@ new_slab:
         new = get_partial(s, gfpflags, node);
         if (new) {
                 c->page = new;
+                stat(c, ALLOC_FROM_PARTIAL);
                 goto load_freelist;
         }
 
@@ -1551,6 +1573,7 @@ new_slab:
 
         if (new) {
                 c = get_cpu_slab(s, smp_processor_id());
+                stat(c, ALLOC_SLAB);
                 if (c->page)
                         flush_slab(s, c);
                 slab_lock(new);
@@ -1610,6 +1633,7 @@ static __always_inline void *slab_alloc(struct kmem_cache *s,
                         object = __slab_alloc(s, gfpflags, node, addr, c);
                         break;
                 }
+                stat(c, ALLOC_FASTPATH);
         } while (cmpxchg_local(&c->freelist, object, object[c->offset])
                                                                 != object);
 #else
@@ -1624,6 +1648,7 @@ static __always_inline void *slab_alloc(struct kmem_cache *s,
         else {
                 object = c->freelist;
                 c->freelist = object[c->offset];
+                stat(c, ALLOC_FASTPATH);
         }
         local_irq_restore(flags);
 #endif
@@ -1661,12 +1686,15 @@ static void __slab_free(struct kmem_cache *s, struct page *page,
 {
         void *prior;
         void **object = (void *)x;
+        struct kmem_cache_cpu *c;
 
 #ifdef SLUB_FASTPATH
         unsigned long flags;
 
         local_irq_save(flags);
 #endif
+        c = get_cpu_slab(s, raw_smp_processor_id());
+        stat(c, FREE_SLOWPATH);
         slab_lock(page);
 
         if (unlikely(SlabDebug(page)))
@@ -1676,8 +1704,10 @@ checks_ok:
         page->freelist = object;
         page->inuse--;
 
-        if (unlikely(SlabFrozen(page)))
+        if (unlikely(SlabFrozen(page))) {
+                stat(c, FREE_FROZEN);
                 goto out_unlock;
+        }
 
         if (unlikely(!page->inuse))
                 goto slab_empty;
@@ -1687,8 +1717,10 @@ checks_ok:
          * was not on the partial list before
          * then add it.
          */
-        if (unlikely(prior == page->end))
+        if (unlikely(prior == page->end)) {
                 add_partial(get_node(s, page_to_nid(page)), page, 1);
+                stat(c, FREE_ADD_PARTIAL);
+        }
 
 out_unlock:
         slab_unlock(page);
@@ -1698,13 +1730,15 @@ out_unlock:
         return;
 
 slab_empty:
-        if (prior != page->end)
+        if (prior != page->end) {
                 /*
                  * Slab still on the partial list.
                  */
                 remove_partial(s, page);
-
+                stat(c, FREE_REMOVE_PARTIAL);
+        }
         slab_unlock(page);
+        stat(c, FREE_SLAB);
 #ifdef SLUB_FASTPATH
         local_irq_restore(flags);
 #endif
@@ -1758,6 +1792,7 @@ static __always_inline void slab_free(struct kmem_cache *s,
                         break;
                 }
                 object[c->offset] = freelist;
+                stat(c, FREE_FASTPATH);
         } while (cmpxchg_local(&c->freelist, freelist, object) != freelist);
 #else
         unsigned long flags;
@@ -1768,6 +1803,7 @@ static __always_inline void slab_free(struct kmem_cache *s,
         if (likely(page == c->page && c->node >= 0)) {
                 object[c->offset] = c->freelist;
                 c->freelist = object;
+                stat(c, FREE_FASTPATH);
         } else
                 __slab_free(s, page, x, addr, c->offset);
 
@@ -3980,6 +4016,62 @@ static ssize_t remote_node_defrag_ratio_store(struct kmem_cache *s,
 SLAB_ATTR(remote_node_defrag_ratio);
 #endif
 
+#ifdef CONFIG_SLUB_STATS
+
+static int show_stat(struct kmem_cache *s, char *buf, enum stat_item si)
+{
+        unsigned long sum  = 0;
+        int cpu;
+        int len;
+        int *data = kmalloc(nr_cpu_ids * sizeof(int), GFP_KERNEL);
+
+        if (!data)
+                return -ENOMEM;
+
+        for_each_online_cpu(cpu) {
+                unsigned x = get_cpu_slab(s, cpu)->stat[si];
+
+                data[cpu] = x;
+                sum += x;
+        }
+
+        len = sprintf(buf, "%lu", sum);
+
+        for_each_online_cpu(cpu) {
+                if (data[cpu] && len < PAGE_SIZE - 20)
+                        len += sprintf(buf + len, " c%d=%u", cpu, data[cpu]);
+        }
+        kfree(data);
+        return len + sprintf(buf + len, "\n");
+}
+
+#define STAT_ATTR(si, text)                                     \
+static ssize_t text##_show(struct kmem_cache *s, char *buf)     \
+{                                                               \
+        return show_stat(s, buf, si);                           \
+}                                                               \
+SLAB_ATTR_RO(text);                                             \
+
+STAT_ATTR(ALLOC_FASTPATH, alloc_fastpath);
+STAT_ATTR(ALLOC_SLOWPATH, alloc_slowpath);
+STAT_ATTR(FREE_FASTPATH, free_fastpath);
+STAT_ATTR(FREE_SLOWPATH, free_slowpath);
+STAT_ATTR(FREE_FROZEN, free_frozen);
+STAT_ATTR(FREE_ADD_PARTIAL, free_add_partial);
+STAT_ATTR(FREE_REMOVE_PARTIAL, free_remove_partial);
+STAT_ATTR(ALLOC_FROM_PARTIAL, alloc_from_partial);
+STAT_ATTR(ALLOC_SLAB, alloc_slab);
+STAT_ATTR(ALLOC_REFILL, alloc_refill);
+STAT_ATTR(FREE_SLAB, free_slab);
+STAT_ATTR(CPUSLAB_FLUSH, cpuslab_flush);
+STAT_ATTR(DEACTIVATE_FULL, deactivate_full);
+STAT_ATTR(DEACTIVATE_EMPTY, deactivate_empty);
+STAT_ATTR(DEACTIVATE_TO_HEAD, deactivate_to_head);
+STAT_ATTR(DEACTIVATE_TO_TAIL, deactivate_to_tail);
+STAT_ATTR(DEACTIVATE_REMOTE_FREES, deactivate_remote_frees);
+
+#endif
+
 static struct attribute *slab_attrs[] = {
         &slab_size_attr.attr,
         &object_size_attr.attr,
@@ -4010,6 +4102,25 @@ static struct attribute *slab_attrs[] = {
 #ifdef CONFIG_NUMA
         &remote_node_defrag_ratio_attr.attr,
 #endif
+#ifdef CONFIG_SLUB_STATS
+        &alloc_fastpath_attr.attr,
+        &alloc_slowpath_attr.attr,
+        &free_fastpath_attr.attr,
+        &free_slowpath_attr.attr,
+        &free_frozen_attr.attr,
+        &free_add_partial_attr.attr,
+        &free_remove_partial_attr.attr,
+        &alloc_from_partial_attr.attr,
+        &alloc_slab_attr.attr,
+        &alloc_refill_attr.attr,
+        &free_slab_attr.attr,
+        &cpuslab_flush_attr.attr,
+        &deactivate_full_attr.attr,
+        &deactivate_empty_attr.attr,
+        &deactivate_to_head_attr.attr,
+        &deactivate_to_tail_attr.attr,
+        &deactivate_remote_frees_attr.attr,
+#endif
         NULL
 };