Slab allocators: Drop support for destructors

There is no user of destructors left.  There is no reason why we should keep
checking for destructors calls in the slab allocators.

The RFC for this patch was discussed at
http://marc.info/?l=linux-kernel&m=117882364330705&w=2

Destructors were mainly used for list management which required them to take a
spinlock.  Taking a spinlock in a destructor is a bit risky since the slab
allocators may run the destructors anytime they decide a slab is no longer
needed.

Patch drops destructor support.  Any attempt to use a destructor will BUG().

Acked-by: Pekka Enberg <penberg@cs.helsinki.fi>
Acked-by: Paul Mundt <lethal@linux-sh.org>
Signed-off-by: Christoph Lameter <clameter@sgi.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 14 insertions, 31 deletions

diff --git a/mm/slub.c b/mm/slub.c
index 5e3e8bc9838f..022c1b4d74d4 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -891,13 +891,13 @@ static void kmem_cache_open_debug_check(struct kmem_cache *s)
          * On 32 bit platforms the limit is 256k. On 64bit platforms
          * the limit is 512k.
          *
-         * Debugging or ctor/dtors may create a need to move the free
+         * Debugging or ctor may create a need to move the free
          * pointer. Fail if this happens.
          */
         if (s->size >= 65535 * sizeof(void *)) {
                 BUG_ON(s->flags & (SLAB_RED_ZONE | SLAB_POISON |
                                 SLAB_STORE_USER | SLAB_DESTROY_BY_RCU));
-                BUG_ON(s->ctor || s->dtor);
+                BUG_ON(s->ctor);
         }
         else
                 /*
@@ -1030,15 +1030,12 @@ static void __free_slab(struct kmem_cache *s, struct page *page)
 {
         int pages = 1 << s->order;
 
-        if (unlikely(SlabDebug(page) || s->dtor)) {
+        if (unlikely(SlabDebug(page))) {
                 void *p;
 
                 slab_pad_check(s, page);
-                for_each_object(p, s, page_address(page)) {
-                        if (s->dtor)
-                                s->dtor(p, s, 0);
+                for_each_object(p, s, page_address(page))
                         check_object(s, page, p, 0);
-                }
         }
 
         mod_zone_page_state(page_zone(page),
@@ -1871,7 +1868,7 @@ static int calculate_sizes(struct kmem_cache *s)
          * then we should never poison the object itself.
          */
         if ((flags & SLAB_POISON) && !(flags & SLAB_DESTROY_BY_RCU) &&
-                        !s->ctor && !s->dtor)
+                        !s->ctor)
                 s->flags |= __OBJECT_POISON;
         else
                 s->flags &= ~__OBJECT_POISON;
@@ -1901,7 +1898,7 @@ static int calculate_sizes(struct kmem_cache *s)
 
 #ifdef CONFIG_SLUB_DEBUG
         if (((flags & (SLAB_DESTROY_BY_RCU | SLAB_POISON)) ||
-                s->ctor || s->dtor)) {
+                s->ctor)) {
                 /*
                  * Relocate free pointer after the object if it is not
                  * permitted to overwrite the first word of the object on
@@ -1970,13 +1967,11 @@ static int calculate_sizes(struct kmem_cache *s)
 static int kmem_cache_open(struct kmem_cache *s, gfp_t gfpflags,
                 const char *name, size_t size,
                 size_t align, unsigned long flags,
-                void (*ctor)(void *, struct kmem_cache *, unsigned long),
-                void (*dtor)(void *, struct kmem_cache *, unsigned long))
+                void (*ctor)(void *, struct kmem_cache *, unsigned long))
 {
         memset(s, 0, kmem_size);
         s->name = name;
         s->ctor = ctor;
-        s->dtor = dtor;
         s->objsize = size;
         s->flags = flags;
         s->align = align;
@@ -2161,7 +2156,7 @@ static struct kmem_cache *create_kmalloc_cache(struct kmem_cache *s,
 
         down_write(&slub_lock);
         if (!kmem_cache_open(s, gfp_flags, name, size, ARCH_KMALLOC_MINALIGN,
-                        flags, NULL, NULL))
+                        flags, NULL))
                 goto panic;
 
         list_add(&s->list, &slab_caches);
@@ -2463,7 +2458,7 @@ static int slab_unmergeable(struct kmem_cache *s)
         if (slub_nomerge || (s->flags & SLUB_NEVER_MERGE))
                 return 1;
 
-        if (s->ctor || s->dtor)
+        if (s->ctor)
                 return 1;
 
         return 0;
@@ -2471,15 +2466,14 @@ static int slab_unmergeable(struct kmem_cache *s)
 
 static struct kmem_cache *find_mergeable(size_t size,
                 size_t align, unsigned long flags,
-                void (*ctor)(void *, struct kmem_cache *, unsigned long),
-                void (*dtor)(void *, struct kmem_cache *, unsigned long))
+                void (*ctor)(void *, struct kmem_cache *, unsigned long))
 {
         struct list_head *h;
 
         if (slub_nomerge || (flags & SLUB_NEVER_MERGE))
                 return NULL;
 
-        if (ctor || dtor)
+        if (ctor)
                 return NULL;
 
         size = ALIGN(size, sizeof(void *));
@@ -2521,8 +2515,9 @@ struct kmem_cache *kmem_cache_create(const char *name, size_t size,
 {
         struct kmem_cache *s;
 
+        BUG_ON(dtor);
         down_write(&slub_lock);
-        s = find_mergeable(size, align, flags, ctor, dtor);
+        s = find_mergeable(size, align, flags, ctor);
         if (s) {
                 s->refcount++;
                 /*
@@ -2536,7 +2531,7 @@ struct kmem_cache *kmem_cache_create(const char *name, size_t size,
         } else {
                 s = kmalloc(kmem_size, GFP_KERNEL);
                 if (s && kmem_cache_open(s, GFP_KERNEL, name,
-                                size, align, flags, ctor, dtor)) {
+                                size, align, flags, ctor)) {
                         if (sysfs_slab_add(s)) {
                                 kfree(s);
                                 goto err;
@@ -3177,17 +3172,6 @@ static ssize_t ctor_show(struct kmem_cache *s, char *buf)
 }
 SLAB_ATTR_RO(ctor);
 
-static ssize_t dtor_show(struct kmem_cache *s, char *buf)
-{
-        if (s->dtor) {
-                int n = sprint_symbol(buf, (unsigned long)s->dtor);
-
-                return n + sprintf(buf + n, "\n");
-        }
-        return 0;
-}
-SLAB_ATTR_RO(dtor);
-
 static ssize_t aliases_show(struct kmem_cache *s, char *buf)
 {
         return sprintf(buf, "%d\n", s->refcount - 1);
@@ -3419,7 +3403,6 @@ static struct attribute * slab_attrs[] = {
         &partial_attr.attr,
         &cpu_slabs_attr.attr,
         &ctor_attr.attr,
-        &dtor_attr.attr,
         &aliases_attr.attr,
         &align_attr.attr,
         &sanity_checks_attr.attr,