1 files changed, 24 insertions, 33 deletions

diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index 74962077f632..3b361b2906bd 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -72,7 +72,7 @@ struct kmem_cache {
  * We keep the general caches in an array of slab caches that are used for
  * 2^x bytes of allocations.
  */
-extern struct kmem_cache kmalloc_caches[KMALLOC_SHIFT_HIGH + 1];
+extern struct kmem_cache kmalloc_caches[PAGE_SHIFT];
 
 /*
  * Sorry that the following has to be that ugly but some versions of GCC
@@ -83,9 +83,6 @@ static __always_inline int kmalloc_index(size_t size)
         if (!size)
                 return 0;
 
-        if (size > KMALLOC_MAX_SIZE)
-                return -1;
-
         if (size <= KMALLOC_MIN_SIZE)
                 return KMALLOC_SHIFT_LOW;
 
@@ -102,6 +99,10 @@ static __always_inline int kmalloc_index(size_t size)
         if (size <=        512) return 9;
         if (size <=       1024) return 10;
         if (size <=   2 * 1024) return 11;
+/*
+ * The following is only needed to support architectures with a larger page
+ * size than 4k.
+ */
         if (size <=   4 * 1024) return 12;
         if (size <=   8 * 1024) return 13;
         if (size <=  16 * 1024) return 14;
@@ -109,13 +110,9 @@ static __always_inline int kmalloc_index(size_t size)
         if (size <=  64 * 1024) return 16;
         if (size <= 128 * 1024) return 17;
         if (size <= 256 * 1024) return 18;
-        if (size <=  512 * 1024) return 19;
+        if (size <= 512 * 1024) return 19;
         if (size <= 1024 * 1024) return 20;
         if (size <=  2 * 1024 * 1024) return 21;
-        if (size <=  4 * 1024 * 1024) return 22;
-        if (size <=  8 * 1024 * 1024) return 23;
-        if (size <= 16 * 1024 * 1024) return 24;
-        if (size <= 32 * 1024 * 1024) return 25;
         return -1;
 
 /*
@@ -140,19 +137,6 @@ static __always_inline struct kmem_cache *kmalloc_slab(size_t size)
         if (index == 0)
                 return NULL;
 
-        /*
-         * This function only gets expanded if __builtin_constant_p(size), so
-         * testing it here shouldn't be needed.  But some versions of gcc need
-         * help.
-         */
-        if (__builtin_constant_p(size) && index < 0) {
-                /*
-                 * Generate a link failure. Would be great if we could
-                 * do something to stop the compile here.
-                 */
-                extern void __kmalloc_size_too_large(void);
-                __kmalloc_size_too_large();
-        }
         return &kmalloc_caches[index];
 }
 
@@ -168,15 +152,21 @@ void *__kmalloc(size_t size, gfp_t flags);
 
 static __always_inline void *kmalloc(size_t size, gfp_t flags)
 {
-        if (__builtin_constant_p(size) && !(flags & SLUB_DMA)) {
-                struct kmem_cache *s = kmalloc_slab(size);
+        if (__builtin_constant_p(size)) {
+                if (size > PAGE_SIZE / 2)
+                        return (void *)__get_free_pages(flags | __GFP_COMP,
+                                                        get_order(size));
 
-                if (!s)
-                        return ZERO_SIZE_PTR;
+                if (!(flags & SLUB_DMA)) {
+                        struct kmem_cache *s = kmalloc_slab(size);
+
+                        if (!s)
+                                return ZERO_SIZE_PTR;
 
-                return kmem_cache_alloc(s, flags);
-        } else
-                return __kmalloc(size, flags);
+                        return kmem_cache_alloc(s, flags);
+                }
+        }
+        return __kmalloc(size, flags);
 }
 
 #ifdef CONFIG_NUMA
@@ -185,15 +175,16 @@ void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
 
 static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
-        if (__builtin_constant_p(size) && !(flags & SLUB_DMA)) {
-                struct kmem_cache *s = kmalloc_slab(size);
+        if (__builtin_constant_p(size) &&
+                size <= PAGE_SIZE / 2 && !(flags & SLUB_DMA)) {
+                        struct kmem_cache *s = kmalloc_slab(size);
 
                 if (!s)
                         return ZERO_SIZE_PTR;
 
                 return kmem_cache_alloc_node(s, flags, node);
-        } else
-                return __kmalloc_node(size, flags, node);
+        }
+        return __kmalloc_node(size, flags, node);
 }
 #endif