memblock: introduce a for_each_reserved_mem_region iterator

[karo-tx-linux.git] / mm / slab_common.c

diff --git a/mm/slab_common.c b/mm/slab_common.c
index 999bb3424d44df71eb9b92d3ae6da75287a391d4..983b78694c4637adcd617de8085498acecfbd288 100644 (file)
--- a/mm/slab_common.c
+++ b/mm/slab_common.c
@@ -784,25 +784,45 @@ struct kmem_cache *kmalloc_slab(size_t size, gfp_t flags)
 }
 
 /*
- * Create the kmalloc array. Some of the regular kmalloc arrays
- * may already have been created because they were needed to
- * enable allocations for slab creation.
+ * kmalloc_info[] is to make slub_debug=,kmalloc-xx option work at boot time.
+ * kmalloc_index() supports up to 2^26=64MB, so the final entry of the table is
+ * kmalloc-67108864.
  */
-void __init create_kmalloc_caches(unsigned long flags)
+static struct {
+       const char *name;
+       unsigned long size;
+} const kmalloc_info[] __initconst = {
+       {NULL,                      0},         {"kmalloc-96",             96},
+       {"kmalloc-192",           192},         {"kmalloc-8",               8},
+       {"kmalloc-16",             16},         {"kmalloc-32",             32},
+       {"kmalloc-64",             64},         {"kmalloc-128",           128},
+       {"kmalloc-256",           256},         {"kmalloc-512",           512},
+       {"kmalloc-1024",         1024},         {"kmalloc-2048",         2048},
+       {"kmalloc-4096",         4096},         {"kmalloc-8192",         8192},
+       {"kmalloc-16384",       16384},         {"kmalloc-32768",       32768},
+       {"kmalloc-65536",       65536},         {"kmalloc-131072",     131072},
+       {"kmalloc-262144",     262144},         {"kmalloc-524288",     524288},
+       {"kmalloc-1048576",   1048576},         {"kmalloc-2097152",   2097152},
+       {"kmalloc-4194304",   4194304},         {"kmalloc-8388608",   8388608},
+       {"kmalloc-16777216", 16777216},         {"kmalloc-33554432", 33554432},
+       {"kmalloc-67108864", 67108864}
+};
+
+/*
+ * Patch up the size_index table if we have strange large alignment
+ * requirements for the kmalloc array. This is only the case for
+ * MIPS it seems. The standard arches will not generate any code here.
+ *
+ * Largest permitted alignment is 256 bytes due to the way we
+ * handle the index determination for the smaller caches.
+ *
+ * Make sure that nothing crazy happens if someone starts tinkering
+ * around with ARCH_KMALLOC_MINALIGN
+ */
+void __init setup_kmalloc_cache_index_table(void)
 {
        int i;
 
-       /*
-        * Patch up the size_index table if we have strange large alignment
-        * requirements for the kmalloc array. This is only the case for
-        * MIPS it seems. The standard arches will not generate any code here.
-        *
-        * Largest permitted alignment is 256 bytes due to the way we
-        * handle the index determination for the smaller caches.
-        *
-        * Make sure that nothing crazy happens if someone starts tinkering
-        * around with ARCH_KMALLOC_MINALIGN
-        */
        BUILD_BUG_ON(KMALLOC_MIN_SIZE > 256 ||
                (KMALLOC_MIN_SIZE & (KMALLOC_MIN_SIZE - 1)));
 
@@ -833,11 +853,26 @@ void __init create_kmalloc_caches(unsigned long flags)
                for (i = 128 + 8; i <= 192; i += 8)
                        size_index[size_index_elem(i)] = 8;
        }
+}
+
+static void new_kmalloc_cache(int idx, unsigned long flags)
+{
+       kmalloc_caches[idx] = create_kmalloc_cache(kmalloc_info[idx].name,
+                                       kmalloc_info[idx].size, flags);
+}
+
+/*
+ * Create the kmalloc array. Some of the regular kmalloc arrays
+ * may already have been created because they were needed to
+ * enable allocations for slab creation.
+ */
+void __init create_kmalloc_caches(unsigned long flags)
+{
+       int i;
+
        for (i = KMALLOC_SHIFT_LOW; i <= KMALLOC_SHIFT_HIGH; i++) {
-               if (!kmalloc_caches[i]) {
-                       kmalloc_caches[i] = create_kmalloc_cache(NULL,
-                                                       1 << i, flags);
-               }
+               if (!kmalloc_caches[i])
+                       new_kmalloc_cache(i, flags);
 
                /*
                 * Caches that are not of the two-to-the-power-of size.
@@ -845,27 +880,14 @@ void __init create_kmalloc_caches(unsigned long flags)
                 * earlier power of two caches
                 */
                if (KMALLOC_MIN_SIZE <= 32 && !kmalloc_caches[1] && i == 6)
-                       kmalloc_caches[1] = create_kmalloc_cache(NULL, 96, flags);
-
+                       new_kmalloc_cache(1, flags);
                if (KMALLOC_MIN_SIZE <= 64 && !kmalloc_caches[2] && i == 7)
-                       kmalloc_caches[2] = create_kmalloc_cache(NULL, 192, flags);
+                       new_kmalloc_cache(2, flags);
        }
 
        /* Kmalloc array is now usable */
        slab_state = UP;
 
-       for (i = 0; i <= KMALLOC_SHIFT_HIGH; i++) {
-               struct kmem_cache *s = kmalloc_caches[i];
-               char *n;
-
-               if (s) {
-                       n = kasprintf(GFP_NOWAIT, "kmalloc-%d", kmalloc_size(i));
-
-                       BUG_ON(!n);
-                       s->name = n;
-               }
-       }
-
 #ifdef CONFIG_ZONE_DMA
        for (i = 0; i <= KMALLOC_SHIFT_HIGH; i++) {
                struct kmem_cache *s = kmalloc_caches[i];