4 files changed, 167 insertions, 24 deletions

diff --git a/lib/cpumask.c b/lib/cpumask.c
index 3389e2440da0..1f71b97de0f9 100644
--- a/lib/cpumask.c
+++ b/lib/cpumask.c
@@ -109,10 +109,10 @@ bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node)
 #endif
         /* FIXME: Bandaid to save us from old primitives which go to NR_CPUS. */
         if (*mask) {
+                unsigned char *ptr = (unsigned char *)cpumask_bits(*mask);
                 unsigned int tail;
                 tail = BITS_TO_LONGS(NR_CPUS - nr_cpumask_bits) * sizeof(long);
-                memset(cpumask_bits(*mask) + cpumask_size() - tail,
-                       0, tail);
+                memset(ptr + cpumask_size() - tail, 0, tail);
         }
 
         return *mask != NULL;
diff --git a/lib/debugobjects.c b/lib/debugobjects.c
index 5d99be1fd988..2755a3bd16a1 100644
--- a/lib/debugobjects.c
+++ b/lib/debugobjects.c
@@ -30,7 +30,7 @@ struct debug_bucket {
 
 static struct debug_bucket      obj_hash[ODEBUG_HASH_SIZE];
 
-static struct debug_obj         obj_static_pool[ODEBUG_POOL_SIZE];
+static struct debug_obj         obj_static_pool[ODEBUG_POOL_SIZE] __initdata;
 
 static DEFINE_SPINLOCK(pool_lock);
 
@@ -50,12 +50,23 @@ static int			debug_objects_enabled __read_mostly
 
 static struct debug_obj_descr   *descr_test  __read_mostly;
 
+static void free_obj_work(struct work_struct *work);
+static DECLARE_WORK(debug_obj_work, free_obj_work);
+
 static int __init enable_object_debug(char *str)
 {
         debug_objects_enabled = 1;
         return 0;
 }
+
+static int __init disable_object_debug(char *str)
+{
+        debug_objects_enabled = 0;
+        return 0;
+}
+
 early_param("debug_objects", enable_object_debug);
+early_param("no_debug_objects", disable_object_debug);
 
 static const char *obj_states[ODEBUG_STATE_MAX] = {
         [ODEBUG_STATE_NONE]             = "none",
@@ -146,25 +157,51 @@ alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
 }
 
 /*
- * Put the object back into the pool or give it back to kmem_cache:
+ * workqueue function to free objects.
  */
-static void free_object(struct debug_obj *obj)
+static void free_obj_work(struct work_struct *work)
 {
-        unsigned long idx = (unsigned long)(obj - obj_static_pool);
+        struct debug_obj *obj;
         unsigned long flags;
 
-        if (obj_pool_free < ODEBUG_POOL_SIZE || idx < ODEBUG_POOL_SIZE) {
-                spin_lock_irqsave(&pool_lock, flags);
-                hlist_add_head(&obj->node, &obj_pool);
-                obj_pool_free++;
-                obj_pool_used--;
-                spin_unlock_irqrestore(&pool_lock, flags);
-        } else {
-                spin_lock_irqsave(&pool_lock, flags);
-                obj_pool_used--;
+        spin_lock_irqsave(&pool_lock, flags);
+        while (obj_pool_free > ODEBUG_POOL_SIZE) {
+                obj = hlist_entry(obj_pool.first, typeof(*obj), node);
+                hlist_del(&obj->node);
+                obj_pool_free--;
+                /*
+                 * We release pool_lock across kmem_cache_free() to
+                 * avoid contention on pool_lock.
+                 */
                 spin_unlock_irqrestore(&pool_lock, flags);
                 kmem_cache_free(obj_cache, obj);
+                spin_lock_irqsave(&pool_lock, flags);
         }
+        spin_unlock_irqrestore(&pool_lock, flags);
+}
+
+/*
+ * Put the object back into the pool and schedule work to free objects
+ * if necessary.
+ */
+static void free_object(struct debug_obj *obj)
+{
+        unsigned long flags;
+        int sched = 0;
+
+        spin_lock_irqsave(&pool_lock, flags);
+        /*
+         * schedule work when the pool is filled and the cache is
+         * initialized:
+         */
+        if (obj_pool_free > ODEBUG_POOL_SIZE && obj_cache)
+                sched = !work_pending(&debug_obj_work);
+        hlist_add_head(&obj->node, &obj_pool);
+        obj_pool_free++;
+        obj_pool_used--;
+        spin_unlock_irqrestore(&pool_lock, flags);
+        if (sched)
+                schedule_work(&debug_obj_work);
 }
 
 /*
@@ -876,6 +913,63 @@ void __init debug_objects_early_init(void)
 }
 
 /*
+ * Convert the statically allocated objects to dynamic ones:
+ */
+static int debug_objects_replace_static_objects(void)
+{
+        struct debug_bucket *db = obj_hash;
+        struct hlist_node *node, *tmp;
+        struct debug_obj *obj, *new;
+        HLIST_HEAD(objects);
+        int i, cnt = 0;
+
+        for (i = 0; i < ODEBUG_POOL_SIZE; i++) {
+                obj = kmem_cache_zalloc(obj_cache, GFP_KERNEL);
+                if (!obj)
+                        goto free;
+                hlist_add_head(&obj->node, &objects);
+        }
+
+        /*
+         * When debug_objects_mem_init() is called we know that only
+         * one CPU is up, so disabling interrupts is enough
+         * protection. This avoids the lockdep hell of lock ordering.
+         */
+        local_irq_disable();
+
+        /* Remove the statically allocated objects from the pool */
+        hlist_for_each_entry_safe(obj, node, tmp, &obj_pool, node)
+                hlist_del(&obj->node);
+        /* Move the allocated objects to the pool */
+        hlist_move_list(&objects, &obj_pool);
+
+        /* Replace the active object references */
+        for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
+                hlist_move_list(&db->list, &objects);
+
+                hlist_for_each_entry(obj, node, &objects, node) {
+                        new = hlist_entry(obj_pool.first, typeof(*obj), node);
+                        hlist_del(&new->node);
+                        /* copy object data */
+                        *new = *obj;
+                        hlist_add_head(&new->node, &db->list);
+                        cnt++;
+                }
+        }
+
+        printk(KERN_DEBUG "ODEBUG: %d of %d active objects replaced\n", cnt,
+               obj_pool_used);
+        local_irq_enable();
+        return 0;
+free:
+        hlist_for_each_entry_safe(obj, node, tmp, &objects, node) {
+                hlist_del(&obj->node);
+                kmem_cache_free(obj_cache, obj);
+        }
+        return -ENOMEM;
+}
+
+/*
  * Called after the kmem_caches are functional to setup a dedicated
  * cache pool, which has the SLAB_DEBUG_OBJECTS flag set. This flag
  * prevents that the debug code is called on kmem_cache_free() for the
@@ -890,8 +984,11 @@ void __init debug_objects_mem_init(void)
                                       sizeof (struct debug_obj), 0,
                                       SLAB_DEBUG_OBJECTS, NULL);
 
-        if (!obj_cache)
+        if (!obj_cache || debug_objects_replace_static_objects()) {
                 debug_objects_enabled = 0;
-        else
+                if (obj_cache)
+                        kmem_cache_destroy(obj_cache);
+                printk(KERN_WARNING "ODEBUG: out of memory.\n");
+        } else
                 debug_objects_selftest();
 }
diff --git a/lib/idr.c b/lib/idr.c
index dab4bca86f5d..80ca9aca038b 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -579,6 +579,52 @@ int idr_for_each(struct idr *idp,
 EXPORT_SYMBOL(idr_for_each);
 
 /**
+ * idr_get_next - lookup next object of id to given id.
+ * @idp: idr handle
+ * @id:  pointer to lookup key
+ *
+ * Returns pointer to registered object with id, which is next number to
+ * given id.
+ */
+
+void *idr_get_next(struct idr *idp, int *nextidp)
+{
+        struct idr_layer *p, *pa[MAX_LEVEL];
+        struct idr_layer **paa = &pa[0];
+        int id = *nextidp;
+        int n, max;
+
+        /* find first ent */
+        n = idp->layers * IDR_BITS;
+        max = 1 << n;
+        p = rcu_dereference(idp->top);
+        if (!p)
+                return NULL;
+
+        while (id < max) {
+                while (n > 0 && p) {
+                        n -= IDR_BITS;
+                        *paa++ = p;
+                        p = rcu_dereference(p->ary[(id >> n) & IDR_MASK]);
+                }
+
+                if (p) {
+                        *nextidp = id;
+                        return p;
+                }
+
+                id += 1 << n;
+                while (n < fls(id)) {
+                        n += IDR_BITS;
+                        p = *--paa;
+                }
+        }
+        return NULL;
+}
+
+
+
+/**
  * idr_replace - replace pointer for given id
  * @idp: idr handle
  * @ptr: pointer you want associated with the id
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index dc1674377009..be3001f912e4 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -398,7 +398,7 @@ static noinline char* put_dec(char *buf, unsigned long long num)
 
 enum format_type {
         FORMAT_TYPE_NONE, /* Just a string part */
-        FORMAT_TYPE_WITDH,
+        FORMAT_TYPE_WIDTH,
         FORMAT_TYPE_PRECISION,
         FORMAT_TYPE_CHAR,
         FORMAT_TYPE_STR,
@@ -770,7 +770,7 @@ static int format_decode(const char *fmt, struct printf_spec *spec)
         const char *start = fmt;
 
         /* we finished early by reading the field width */
-        if (spec->type == FORMAT_TYPE_WITDH) {
+        if (spec->type == FORMAT_TYPE_WIDTH) {
                 if (spec->field_width < 0) {
                         spec->field_width = -spec->field_width;
                         spec->flags |= LEFT;
@@ -828,7 +828,7 @@ static int format_decode(const char *fmt, struct printf_spec *spec)
                 spec->field_width = skip_atoi(&fmt);
         else if (*fmt == '*') {
                 /* it's the next argument */
-                spec->type = FORMAT_TYPE_WITDH;
+                spec->type = FORMAT_TYPE_WIDTH;
                 return ++fmt - start;
         }
 
@@ -843,7 +843,7 @@ precision:
                                 spec->precision = 0;
                 } else if (*fmt == '*') {
                         /* it's the next argument */
-                        spec->type = FORMAT_TYPE_WITDH;
+                        spec->type = FORMAT_TYPE_PRECISION;
                         return ++fmt - start;
                 }
         }
@@ -1002,7 +1002,7 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
                         break;
                 }
 
-                case FORMAT_TYPE_WITDH:
+                case FORMAT_TYPE_WIDTH:
                         spec.field_width = va_arg(args, int);
                         break;
 
@@ -1306,7 +1306,7 @@ do {									\
                 case FORMAT_TYPE_NONE:
                         break;
 
-                case FORMAT_TYPE_WITDH:
+                case FORMAT_TYPE_WIDTH:
                 case FORMAT_TYPE_PRECISION:
                         save_arg(int);
                         break;
@@ -1472,7 +1472,7 @@ int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
                         break;
                 }
 
-                case FORMAT_TYPE_WITDH:
+                case FORMAT_TYPE_WIDTH:
                         spec.field_width = get_arg(int);
                         break;