[PATCH] rename wakeup_bdflush to wakeup_pdflush

[linux-2.6] / mm / slab.c

diff --git a/mm/slab.c b/mm/slab.c
index ec660d85ddd769c1f94b3385ca571ebb8b316005..122d031baab2f957bc73abdac853d4195ba78619 100644 (file)
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -92,6 +92,7 @@
 #include       <linux/sysctl.h>
 #include       <linux/module.h>
 #include       <linux/rcupdate.h>
+#include       <linux/string.h>
 
 #include       <asm/uaccess.h>
 #include       <asm/cacheflush.h>
@@ -583,7 +584,7 @@ static inline struct array_cache *ac_data(kmem_cache_t *cachep)
        return cachep->array[smp_processor_id()];
 }
 
-static inline kmem_cache_t *kmem_find_general_cachep(size_t size, int gfpflags)
+static inline kmem_cache_t *__find_general_cachep(size_t size, int gfpflags)
 {
        struct cache_sizes *csizep = malloc_sizes;
 
@@ -607,6 +608,12 @@ static inline kmem_cache_t *kmem_find_general_cachep(size_t size, int gfpflags)
        return csizep->cs_cachep;
 }
 
+kmem_cache_t *kmem_find_general_cachep(size_t size, int gfpflags)
+{
+       return __find_general_cachep(size, gfpflags);
+}
+EXPORT_SYMBOL(kmem_find_general_cachep);
+
 /* Cal the num objs, wastage, and bytes left over for a given slab size. */
 static void cache_estimate(unsigned long gfporder, size_t size, size_t align,
                 int flags, size_t *left_over, unsigned int *num)
@@ -672,14 +679,11 @@ static struct array_cache *alloc_arraycache(int cpu, int entries,
        int memsize = sizeof(void*)*entries+sizeof(struct array_cache);
        struct array_cache *nc = NULL;
 
-       if (cpu != -1) {
-               kmem_cache_t *cachep;
-               cachep = kmem_find_general_cachep(memsize, GFP_KERNEL);
-               if (cachep)
-                       nc = kmem_cache_alloc_node(cachep, cpu_to_node(cpu));
-       }
-       if (!nc)
+       if (cpu == -1)
                nc = kmalloc(memsize, GFP_KERNEL);
+       else
+               nc = kmalloc_node(memsize, GFP_KERNEL, cpu_to_node(cpu));
+
        if (nc) {
                nc->avail = 0;
                nc->limit = entries;
@@ -1663,7 +1667,7 @@ int kmem_cache_destroy(kmem_cache_t * cachep)
        }
 
        if (unlikely(cachep->flags & SLAB_DESTROY_BY_RCU))
-               synchronize_kernel();
+               synchronize_rcu();
 
        /* no cpu_online check required here since we clear the percpu
         * array on cpu offline and set this to NULL.
@@ -2361,7 +2365,7 @@ out:
  * and can sleep. And it will allocate memory on the given node, which
  * can improve the performance for cpu bound structures.
  */
-void *kmem_cache_alloc_node(kmem_cache_t *cachep, int nodeid)
+void *kmem_cache_alloc_node(kmem_cache_t *cachep, int flags, int nodeid)
 {
        int loop;
        void *objp;
@@ -2393,7 +2397,7 @@ void *kmem_cache_alloc_node(kmem_cache_t *cachep, int nodeid)
                spin_unlock_irq(&cachep->spinlock);
 
                local_irq_disable();
-               if (!cache_grow(cachep, GFP_KERNEL, nodeid)) {
+               if (!cache_grow(cachep, flags, nodeid)) {
                        local_irq_enable();
                        return NULL;
                }
@@ -2435,6 +2439,16 @@ got_slabp:
 }
 EXPORT_SYMBOL(kmem_cache_alloc_node);
 
+void *kmalloc_node(size_t size, int flags, int node)
+{
+       kmem_cache_t *cachep;
+
+       cachep = kmem_find_general_cachep(size, flags);
+       if (unlikely(cachep == NULL))
+               return NULL;
+       return kmem_cache_alloc_node(cachep, flags, node);
+}
+EXPORT_SYMBOL(kmalloc_node);
 #endif
 
 /**
@@ -2462,7 +2476,12 @@ void *__kmalloc(size_t size, unsigned int __nocast flags)
 {
        kmem_cache_t *cachep;
 
-       cachep = kmem_find_general_cachep(size, flags);
+       /* If you want to save a few bytes .text space: replace
+        * __ with kmem_.
+        * Then kmalloc uses the uninlined functions instead of the inline
+        * functions.
+        */
+       cachep = __find_general_cachep(size, flags);
        if (unlikely(cachep == NULL))
                return NULL;
        return __cache_alloc(cachep, flags);
@@ -2489,9 +2508,8 @@ void *__alloc_percpu(size_t size, size_t align)
        for (i = 0; i < NR_CPUS; i++) {
                if (!cpu_possible(i))
                        continue;
-               pdata->ptrs[i] = kmem_cache_alloc_node(
-                               kmem_find_general_cachep(size, GFP_KERNEL),
-                               cpu_to_node(i));
+               pdata->ptrs[i] = kmalloc_node(size, GFP_KERNEL,
+                                               cpu_to_node(i));
 
                if (!pdata->ptrs[i])
                        goto unwind_oom;
@@ -2603,6 +2621,12 @@ unsigned int kmem_cache_size(kmem_cache_t *cachep)
 }
 EXPORT_SYMBOL(kmem_cache_size);
 
+const char *kmem_cache_name(kmem_cache_t *cachep)
+{
+       return cachep->name;
+}
+EXPORT_SYMBOL_GPL(kmem_cache_name);
+
 struct ccupdate_struct {
        kmem_cache_t *cachep;
        struct array_cache *new[NR_CPUS];
@@ -2828,6 +2852,7 @@ next:
        }
        check_irq_on();
        up(&cache_chain_sem);
+       drain_remote_pages();
        /* Setup the next iteration */
        schedule_delayed_work(&__get_cpu_var(reap_work), REAPTIMEOUT_CPUC + smp_processor_id());
 }
@@ -3058,3 +3083,26 @@ unsigned int ksize(const void *objp)
 
        return size;
 }
+
+
+/*
+ * kstrdup - allocate space for and copy an existing string
+ *
+ * @s: the string to duplicate
+ * @gfp: the GFP mask used in the kmalloc() call when allocating memory
+ */
+char *kstrdup(const char *s, int gfp)
+{
+       size_t len;
+       char *buf;
+
+       if (!s)
+               return NULL;
+
+       len = strlen(s) + 1;
+       buf = kmalloc(len, gfp);
+       if (buf)
+               memcpy(buf, s, len);
+       return buf;
+}
+EXPORT_SYMBOL(kstrdup);