slub: Allow removal of slab caches during boot

Serialize kmem_cache_create and kmem_cache_destroy using the slub_lock. Only
possible after the use of the slub_lock during dynamic dma creation has been
removed.

Then make sure that the setup of the slab sysfs entries does not race
with kmem_cache_create and kmem_cache destroy.

If a slab cache is removed before we have setup sysfs then simply skip over
the sysfs handling.

Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Roland Dreier <rdreier@cisco.com>
Signed-off-by: Christoph Lameter <cl@linux-foundation.org>
Signed-off-by: Pekka Enberg <penberg@cs.helsinki.fi>

1 files changed, 15 insertions, 9 deletions

diff --git a/mm/slub.c b/mm/slub.c
index f0f403693bd9..fb6518efe1ed 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -2491,7 +2491,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__);
@@ -2500,8 +2499,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);
 
@@ -3227,14 +3226,12 @@ 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;
         }
 
@@ -3243,14 +3240,12 @@ struct kmem_cache *kmem_cache_create(const char *name, size_t size,
                 if (kmem_cache_open(s, GFP_KERNEL, 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);
@@ -4498,6 +4493,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);
@@ -4543,8 +4545,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;
         }
@@ -4569,6 +4574,7 @@ static int __init slab_sysfs_init(void)
                 kfree(al);
         }
 
+        up_write(&slub_lock);
         resiliency_test();
         return 0;
 }