slub: Rearrange #ifdef CONFIG_SLUB_DEBUG in calculate_sizes()

[net-next-2.6.git] / mm / slub.c

diff --git a/mm/slub.c b/mm/slub.c
index e01d399894c43935a7460cf56ef69b89922b637b..72f5f4ecd1d2590cda078b37b2d857e32c3ab937 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -852,7 +852,7 @@ static int alloc_debug_processing(struct kmem_cache *s, struct page *page,
        if (!check_slab(s, page))
                goto bad;
 
-       if (object && !on_freelist(s, page, object)) {
+       if (!on_freelist(s, page, object)) {
                object_err(s, page, object, "Object already allocated");
                goto bad;
        }
@@ -862,7 +862,7 @@ static int alloc_debug_processing(struct kmem_cache *s, struct page *page,
                goto bad;
        }
 
-       if (object && !check_object(s, page, object, 0))
+       if (!check_object(s, page, object, 0))
                goto bad;
 
        /* Success perform special debug activities for allocs */
@@ -997,30 +997,11 @@ static unsigned long kmem_cache_flags(unsigned long objsize,
        void (*ctor)(struct kmem_cache *, void *))
 {
        /*
-        * The page->offset field is only 16 bit wide. This is an offset
-        * in units of words from the beginning of an object. If the slab
-        * size is bigger then we cannot move the free pointer behind the
-        * object anymore.
-        *
-        * On 32 bit platforms the limit is 256k. On 64bit platforms
-        * the limit is 512k.
-        *
-        * Debugging or ctor may create a need to move the free
-        * pointer. Fail if this happens.
+        * Enable debugging if selected on the kernel commandline.
         */
-       if (objsize >= 65535 * sizeof(void *)) {
-               BUG_ON(flags & (SLAB_RED_ZONE | SLAB_POISON |
-                               SLAB_STORE_USER | SLAB_DESTROY_BY_RCU));
-               BUG_ON(ctor);
-       } else {
-               /*
-                * Enable debugging if selected on the kernel commandline.
-                */
-               if (slub_debug && (!slub_debug_slabs ||
-                   strncmp(slub_debug_slabs, name,
-                       strlen(slub_debug_slabs)) == 0))
-                               flags |= slub_debug;
-       }
+       if (slub_debug && (!slub_debug_slabs ||
+           strncmp(slub_debug_slabs, name, strlen(slub_debug_slabs)) == 0))
+                       flags |= slub_debug;
 
        return flags;
 }
@@ -1700,8 +1681,8 @@ static __always_inline void slab_free(struct kmem_cache *s,
        unsigned long flags;
 
        local_irq_save(flags);
-       debug_check_no_locks_freed(object, s->objsize);
        c = get_cpu_slab(s, smp_processor_id());
+       debug_check_no_locks_freed(object, c->objsize);
        if (likely(page == c->page && c->node >= 0)) {
                object[c->offset] = c->freelist;
                c->freelist = object;
@@ -2148,6 +2129,14 @@ static int calculate_sizes(struct kmem_cache *s)
        unsigned long size = s->objsize;
        unsigned long align = s->align;
 
+       /*
+        * Round up object size to the next word boundary. We can only
+        * place the free pointer at word boundaries and this determines
+        * the possible location of the free pointer.
+        */
+       size = ALIGN(size, sizeof(void *));
+
+#ifdef CONFIG_SLUB_DEBUG
        /*
         * Determine if we can poison the object itself. If the user of
         * the slab may touch the object after free or before allocation
@@ -2159,14 +2148,7 @@ static int calculate_sizes(struct kmem_cache *s)
        else
                s->flags &= ~__OBJECT_POISON;
 
-       /*
-        * Round up object size to the next word boundary. We can only
-        * place the free pointer at word boundaries and this determines
-        * the possible location of the free pointer.
-        */
-       size = ALIGN(size, sizeof(void *));
 
-#ifdef CONFIG_SLUB_DEBUG
        /*
         * If we are Redzoning then check if there is some space between the
         * end of the object and the free pointer. If not then add an
@@ -2629,19 +2611,17 @@ size_t ksize(const void *object)
        struct page *page;
        struct kmem_cache *s;
 
-       BUG_ON(!object);
        if (unlikely(object == ZERO_SIZE_PTR))
                return 0;
 
        page = virt_to_head_page(object);
-       BUG_ON(!page);
 
        if (unlikely(!PageSlab(page)))
                return PAGE_SIZE << compound_order(page);
 
        s = page->slab;
-       BUG_ON(!s);
 
+#ifdef CONFIG_SLUB_DEBUG
        /*
         * Debugging requires use of the padding between object
         * and whatever may come after it.
@@ -2649,6 +2629,7 @@ size_t ksize(const void *object)
        if (s->flags & (SLAB_RED_ZONE | SLAB_POISON))
                return s->objsize;
 
+#endif
        /*
         * If we have the need to store the freelist pointer
         * back there or track user information then we can
@@ -2656,7 +2637,6 @@ size_t ksize(const void *object)
         */
        if (s->flags & (SLAB_DESTROY_BY_RCU | SLAB_STORE_USER))
                return s->inuse;
-
        /*
         * Else we can use all the padding etc for the allocation
         */