1 files changed, 181 insertions, 1 deletions

diff --git a/mm/slab_common.c b/mm/slab_common.c
index 069a24e64403..a8e76d79ee65 100644
--- a/mm/slab_common.c
+++ b/mm/slab_common.c
@@ -13,6 +13,8 @@
 #include <linux/module.h>
 #include <linux/cpu.h>
 #include <linux/uaccess.h>
+#include <linux/seq_file.h>
+#include <linux/proc_fs.h>
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
 #include <asm/page.h>
@@ -71,6 +73,34 @@ static inline int kmem_cache_sanity_check(const char *name, size_t size)
 #endif
 
 /*
+ * Figure out what the alignment of the objects will be given a set of
+ * flags, a user specified alignment and the size of the objects.
+ */
+unsigned long calculate_alignment(unsigned long flags,
+                unsigned long align, unsigned long size)
+{
+        /*
+         * If the user wants hardware cache aligned objects then follow that
+         * suggestion if the object is sufficiently large.
+         *
+         * The hardware cache alignment cannot override the specified
+         * alignment though. If that is greater then use it.
+         */
+        if (flags & SLAB_HWCACHE_ALIGN) {
+                unsigned long ralign = cache_line_size();
+                while (size <= ralign / 2)
+                        ralign /= 2;
+                align = max(align, ralign);
+        }
+
+        if (align < ARCH_SLAB_MINALIGN)
+                align = ARCH_SLAB_MINALIGN;
+
+        return ALIGN(align, sizeof(void *));
+}
+
+
+/*
  * kmem_cache_create - Create a cache.
  * @name: A string which is used in /proc/slabinfo to identify this cache.
  * @size: The size of objects to be created in this cache.
@@ -107,6 +137,13 @@ struct kmem_cache *kmem_cache_create(const char *name, size_t size, size_t align
         if (!kmem_cache_sanity_check(name, size) == 0)
                 goto out_locked;
 
+        /*
+         * Some allocators will constraint the set of valid flags to a subset
+         * of all flags. We expect them to define CACHE_CREATE_MASK in this
+         * case, and we'll just provide them with a sanitized version of the
+         * passed flags.
+         */
+        flags &= CACHE_CREATE_MASK;
 
         s = __kmem_cache_alias(name, size, align, flags, ctor);
         if (s)
@@ -115,7 +152,7 @@ struct kmem_cache *kmem_cache_create(const char *name, size_t size, size_t align
         s = kmem_cache_zalloc(kmem_cache, GFP_KERNEL);
         if (s) {
                 s->object_size = s->size = size;
-                s->align = align;
+                s->align = calculate_alignment(flags, align, size);
                 s->ctor = ctor;
                 s->name = kstrdup(name, GFP_KERNEL);
                 if (!s->name) {
@@ -192,3 +229,146 @@ int slab_is_available(void)
 {
         return slab_state >= UP;
 }
+
+#ifndef CONFIG_SLOB
+/* Create a cache during boot when no slab services are available yet */
+void __init create_boot_cache(struct kmem_cache *s, const char *name, size_t size,
+                unsigned long flags)
+{
+        int err;
+
+        s->name = name;
+        s->size = s->object_size = size;
+        s->align = calculate_alignment(flags, ARCH_KMALLOC_MINALIGN, size);
+        err = __kmem_cache_create(s, flags);
+
+        if (err)
+                panic("Creation of kmalloc slab %s size=%zd failed. Reason %d\n",
+                                        name, size, err);
+
+        s->refcount = -1;       /* Exempt from merging for now */
+}
+
+struct kmem_cache *__init create_kmalloc_cache(const char *name, size_t size,
+                                unsigned long flags)
+{
+        struct kmem_cache *s = kmem_cache_zalloc(kmem_cache, GFP_NOWAIT);
+
+        if (!s)
+                panic("Out of memory when creating slab %s\n", name);
+
+        create_boot_cache(s, name, size, flags);
+        list_add(&s->list, &slab_caches);
+        s->refcount = 1;
+        return s;
+}
+
+#endif /* !CONFIG_SLOB */
+
+
+#ifdef CONFIG_SLABINFO
+static void print_slabinfo_header(struct seq_file *m)
+{
+        /*
+         * Output format version, so at least we can change it
+         * without _too_ many complaints.
+         */
+#ifdef CONFIG_DEBUG_SLAB
+        seq_puts(m, "slabinfo - version: 2.1 (statistics)\n");
+#else
+        seq_puts(m, "slabinfo - version: 2.1\n");
+#endif
+        seq_puts(m, "# name            <active_objs> <num_objs> <objsize> "
+                 "<objperslab> <pagesperslab>");
+        seq_puts(m, " : tunables <limit> <batchcount> <sharedfactor>");
+        seq_puts(m, " : slabdata <active_slabs> <num_slabs> <sharedavail>");
+#ifdef CONFIG_DEBUG_SLAB
+        seq_puts(m, " : globalstat <listallocs> <maxobjs> <grown> <reaped> "
+                 "<error> <maxfreeable> <nodeallocs> <remotefrees> <alienoverflow>");
+        seq_puts(m, " : cpustat <allochit> <allocmiss> <freehit> <freemiss>");
+#endif
+        seq_putc(m, '\n');
+}
+
+static void *s_start(struct seq_file *m, loff_t *pos)
+{
+        loff_t n = *pos;
+
+        mutex_lock(&slab_mutex);
+        if (!n)
+                print_slabinfo_header(m);
+
+        return seq_list_start(&slab_caches, *pos);
+}
+
+static void *s_next(struct seq_file *m, void *p, loff_t *pos)
+{
+        return seq_list_next(p, &slab_caches, pos);
+}
+
+static void s_stop(struct seq_file *m, void *p)
+{
+        mutex_unlock(&slab_mutex);
+}
+
+static int s_show(struct seq_file *m, void *p)
+{
+        struct kmem_cache *s = list_entry(p, struct kmem_cache, list);
+        struct slabinfo sinfo;
+
+        memset(&sinfo, 0, sizeof(sinfo));
+        get_slabinfo(s, &sinfo);
+
+        seq_printf(m, "%-17s %6lu %6lu %6u %4u %4d",
+                   s->name, sinfo.active_objs, sinfo.num_objs, s->size,
+                   sinfo.objects_per_slab, (1 << sinfo.cache_order));
+
+        seq_printf(m, " : tunables %4u %4u %4u",
+                   sinfo.limit, sinfo.batchcount, sinfo.shared);
+        seq_printf(m, " : slabdata %6lu %6lu %6lu",
+                   sinfo.active_slabs, sinfo.num_slabs, sinfo.shared_avail);
+        slabinfo_show_stats(m, s);
+        seq_putc(m, '\n');
+        return 0;
+}
+
+/*
+ * slabinfo_op - iterator that generates /proc/slabinfo
+ *
+ * Output layout:
+ * cache-name
+ * num-active-objs
+ * total-objs
+ * object size
+ * num-active-slabs
+ * total-slabs
+ * num-pages-per-slab
+ * + further values on SMP and with statistics enabled
+ */
+static const struct seq_operations slabinfo_op = {
+        .start = s_start,
+        .next = s_next,
+        .stop = s_stop,
+        .show = s_show,
+};
+
+static int slabinfo_open(struct inode *inode, struct file *file)
+{
+        return seq_open(file, &slabinfo_op);
+}
+
+static const struct file_operations proc_slabinfo_operations = {
+        .open           = slabinfo_open,
+        .read           = seq_read,
+        .write          = slabinfo_write,
+        .llseek         = seq_lseek,
+        .release        = seq_release,
+};
+
+static int __init slab_proc_init(void)
+{
+        proc_create("slabinfo", S_IRUSR, NULL, &proc_slabinfo_operations);
+        return 0;
+}
+module_init(slab_proc_init);
+#endif /* CONFIG_SLABINFO */