Merge branch 'core-debugobjects-for-linus' of git://git.kernel.org/pub/scm/linux...
[pandora-kernel.git] / lib / debugobjects.c
1 /*
2  * Generic infrastructure for lifetime debugging of objects.
3  *
4  * Started by Thomas Gleixner
5  *
6  * Copyright (C) 2008, Thomas Gleixner <tglx@linutronix.de>
7  *
8  * For licencing details see kernel-base/COPYING
9  */
10 #include <linux/debugobjects.h>
11 #include <linux/interrupt.h>
12 #include <linux/sched.h>
13 #include <linux/seq_file.h>
14 #include <linux/debugfs.h>
15 #include <linux/slab.h>
16 #include <linux/hash.h>
17
18 #define ODEBUG_HASH_BITS        14
19 #define ODEBUG_HASH_SIZE        (1 << ODEBUG_HASH_BITS)
20
21 #define ODEBUG_POOL_SIZE        512
22 #define ODEBUG_POOL_MIN_LEVEL   256
23
24 #define ODEBUG_CHUNK_SHIFT      PAGE_SHIFT
25 #define ODEBUG_CHUNK_SIZE       (1 << ODEBUG_CHUNK_SHIFT)
26 #define ODEBUG_CHUNK_MASK       (~(ODEBUG_CHUNK_SIZE - 1))
27
28 struct debug_bucket {
29         struct hlist_head       list;
30         raw_spinlock_t          lock;
31 };
32
33 static struct debug_bucket      obj_hash[ODEBUG_HASH_SIZE];
34
35 static struct debug_obj         obj_static_pool[ODEBUG_POOL_SIZE] __initdata;
36
37 static DEFINE_RAW_SPINLOCK(pool_lock);
38
39 static HLIST_HEAD(obj_pool);
40
41 static int                      obj_pool_min_free = ODEBUG_POOL_SIZE;
42 static int                      obj_pool_free = ODEBUG_POOL_SIZE;
43 static int                      obj_pool_used;
44 static int                      obj_pool_max_used;
45 static struct kmem_cache        *obj_cache;
46
47 static int                      debug_objects_maxchain __read_mostly;
48 static int                      debug_objects_fixups __read_mostly;
49 static int                      debug_objects_warnings __read_mostly;
50 static int                      debug_objects_enabled __read_mostly
51                                 = CONFIG_DEBUG_OBJECTS_ENABLE_DEFAULT;
52
53 static struct debug_obj_descr   *descr_test  __read_mostly;
54
55 static void free_obj_work(struct work_struct *work);
56 static DECLARE_WORK(debug_obj_work, free_obj_work);
57
58 static int __init enable_object_debug(char *str)
59 {
60         debug_objects_enabled = 1;
61         return 0;
62 }
63
64 static int __init disable_object_debug(char *str)
65 {
66         debug_objects_enabled = 0;
67         return 0;
68 }
69
70 early_param("debug_objects", enable_object_debug);
71 early_param("no_debug_objects", disable_object_debug);
72
73 static const char *obj_states[ODEBUG_STATE_MAX] = {
74         [ODEBUG_STATE_NONE]             = "none",
75         [ODEBUG_STATE_INIT]             = "initialized",
76         [ODEBUG_STATE_INACTIVE]         = "inactive",
77         [ODEBUG_STATE_ACTIVE]           = "active",
78         [ODEBUG_STATE_DESTROYED]        = "destroyed",
79         [ODEBUG_STATE_NOTAVAILABLE]     = "not available",
80 };
81
82 static int fill_pool(void)
83 {
84         gfp_t gfp = GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN;
85         struct debug_obj *new;
86         unsigned long flags;
87
88         if (likely(obj_pool_free >= ODEBUG_POOL_MIN_LEVEL))
89                 return obj_pool_free;
90
91         if (unlikely(!obj_cache))
92                 return obj_pool_free;
93
94         while (obj_pool_free < ODEBUG_POOL_MIN_LEVEL) {
95
96                 new = kmem_cache_zalloc(obj_cache, gfp);
97                 if (!new)
98                         return obj_pool_free;
99
100                 raw_spin_lock_irqsave(&pool_lock, flags);
101                 hlist_add_head(&new->node, &obj_pool);
102                 obj_pool_free++;
103                 raw_spin_unlock_irqrestore(&pool_lock, flags);
104         }
105         return obj_pool_free;
106 }
107
108 /*
109  * Lookup an object in the hash bucket.
110  */
111 static struct debug_obj *lookup_object(void *addr, struct debug_bucket *b)
112 {
113         struct hlist_node *node;
114         struct debug_obj *obj;
115         int cnt = 0;
116
117         hlist_for_each_entry(obj, node, &b->list, node) {
118                 cnt++;
119                 if (obj->object == addr)
120                         return obj;
121         }
122         if (cnt > debug_objects_maxchain)
123                 debug_objects_maxchain = cnt;
124
125         return NULL;
126 }
127
128 /*
129  * Allocate a new object. If the pool is empty, switch off the debugger.
130  * Must be called with interrupts disabled.
131  */
132 static struct debug_obj *
133 alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
134 {
135         struct debug_obj *obj = NULL;
136
137         raw_spin_lock(&pool_lock);
138         if (obj_pool.first) {
139                 obj         = hlist_entry(obj_pool.first, typeof(*obj), node);
140
141                 obj->object = addr;
142                 obj->descr  = descr;
143                 obj->state  = ODEBUG_STATE_NONE;
144                 hlist_del(&obj->node);
145
146                 hlist_add_head(&obj->node, &b->list);
147
148                 obj_pool_used++;
149                 if (obj_pool_used > obj_pool_max_used)
150                         obj_pool_max_used = obj_pool_used;
151
152                 obj_pool_free--;
153                 if (obj_pool_free < obj_pool_min_free)
154                         obj_pool_min_free = obj_pool_free;
155         }
156         raw_spin_unlock(&pool_lock);
157
158         return obj;
159 }
160
161 /*
162  * workqueue function to free objects.
163  */
164 static void free_obj_work(struct work_struct *work)
165 {
166         struct debug_obj *obj;
167         unsigned long flags;
168
169         raw_spin_lock_irqsave(&pool_lock, flags);
170         while (obj_pool_free > ODEBUG_POOL_SIZE) {
171                 obj = hlist_entry(obj_pool.first, typeof(*obj), node);
172                 hlist_del(&obj->node);
173                 obj_pool_free--;
174                 /*
175                  * We release pool_lock across kmem_cache_free() to
176                  * avoid contention on pool_lock.
177                  */
178                 raw_spin_unlock_irqrestore(&pool_lock, flags);
179                 kmem_cache_free(obj_cache, obj);
180                 raw_spin_lock_irqsave(&pool_lock, flags);
181         }
182         raw_spin_unlock_irqrestore(&pool_lock, flags);
183 }
184
185 /*
186  * Put the object back into the pool and schedule work to free objects
187  * if necessary.
188  */
189 static void free_object(struct debug_obj *obj)
190 {
191         unsigned long flags;
192         int sched = 0;
193
194         raw_spin_lock_irqsave(&pool_lock, flags);
195         /*
196          * schedule work when the pool is filled and the cache is
197          * initialized:
198          */
199         if (obj_pool_free > ODEBUG_POOL_SIZE && obj_cache)
200                 sched = !work_pending(&debug_obj_work);
201         hlist_add_head(&obj->node, &obj_pool);
202         obj_pool_free++;
203         obj_pool_used--;
204         raw_spin_unlock_irqrestore(&pool_lock, flags);
205         if (sched)
206                 schedule_work(&debug_obj_work);
207 }
208
209 /*
210  * We run out of memory. That means we probably have tons of objects
211  * allocated.
212  */
213 static void debug_objects_oom(void)
214 {
215         struct debug_bucket *db = obj_hash;
216         struct hlist_node *node, *tmp;
217         HLIST_HEAD(freelist);
218         struct debug_obj *obj;
219         unsigned long flags;
220         int i;
221
222         printk(KERN_WARNING "ODEBUG: Out of memory. ODEBUG disabled\n");
223
224         for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
225                 raw_spin_lock_irqsave(&db->lock, flags);
226                 hlist_move_list(&db->list, &freelist);
227                 raw_spin_unlock_irqrestore(&db->lock, flags);
228
229                 /* Now free them */
230                 hlist_for_each_entry_safe(obj, node, tmp, &freelist, node) {
231                         hlist_del(&obj->node);
232                         free_object(obj);
233                 }
234         }
235 }
236
237 /*
238  * We use the pfn of the address for the hash. That way we can check
239  * for freed objects simply by checking the affected bucket.
240  */
241 static struct debug_bucket *get_bucket(unsigned long addr)
242 {
243         unsigned long hash;
244
245         hash = hash_long((addr >> ODEBUG_CHUNK_SHIFT), ODEBUG_HASH_BITS);
246         return &obj_hash[hash];
247 }
248
249 static void debug_print_object(struct debug_obj *obj, char *msg)
250 {
251         static int limit;
252
253         if (limit < 5 && obj->descr != descr_test) {
254                 limit++;
255                 WARN(1, KERN_ERR "ODEBUG: %s %s object type: %s\n", msg,
256                        obj_states[obj->state], obj->descr->name);
257         }
258         debug_objects_warnings++;
259 }
260
261 /*
262  * Try to repair the damage, so we have a better chance to get useful
263  * debug output.
264  */
265 static void
266 debug_object_fixup(int (*fixup)(void *addr, enum debug_obj_state state),
267                    void * addr, enum debug_obj_state state)
268 {
269         if (fixup)
270                 debug_objects_fixups += fixup(addr, state);
271 }
272
273 static void debug_object_is_on_stack(void *addr, int onstack)
274 {
275         int is_on_stack;
276         static int limit;
277
278         if (limit > 4)
279                 return;
280
281         is_on_stack = object_is_on_stack(addr);
282         if (is_on_stack == onstack)
283                 return;
284
285         limit++;
286         if (is_on_stack)
287                 printk(KERN_WARNING
288                        "ODEBUG: object is on stack, but not annotated\n");
289         else
290                 printk(KERN_WARNING
291                        "ODEBUG: object is not on stack, but annotated\n");
292         WARN_ON(1);
293 }
294
295 static void
296 __debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
297 {
298         enum debug_obj_state state;
299         struct debug_bucket *db;
300         struct debug_obj *obj;
301         unsigned long flags;
302
303         fill_pool();
304
305         db = get_bucket((unsigned long) addr);
306
307         raw_spin_lock_irqsave(&db->lock, flags);
308
309         obj = lookup_object(addr, db);
310         if (!obj) {
311                 obj = alloc_object(addr, db, descr);
312                 if (!obj) {
313                         debug_objects_enabled = 0;
314                         raw_spin_unlock_irqrestore(&db->lock, flags);
315                         debug_objects_oom();
316                         return;
317                 }
318                 debug_object_is_on_stack(addr, onstack);
319         }
320
321         switch (obj->state) {
322         case ODEBUG_STATE_NONE:
323         case ODEBUG_STATE_INIT:
324         case ODEBUG_STATE_INACTIVE:
325                 obj->state = ODEBUG_STATE_INIT;
326                 break;
327
328         case ODEBUG_STATE_ACTIVE:
329                 debug_print_object(obj, "init");
330                 state = obj->state;
331                 raw_spin_unlock_irqrestore(&db->lock, flags);
332                 debug_object_fixup(descr->fixup_init, addr, state);
333                 return;
334
335         case ODEBUG_STATE_DESTROYED:
336                 debug_print_object(obj, "init");
337                 break;
338         default:
339                 break;
340         }
341
342         raw_spin_unlock_irqrestore(&db->lock, flags);
343 }
344
345 /**
346  * debug_object_init - debug checks when an object is initialized
347  * @addr:       address of the object
348  * @descr:      pointer to an object specific debug description structure
349  */
350 void debug_object_init(void *addr, struct debug_obj_descr *descr)
351 {
352         if (!debug_objects_enabled)
353                 return;
354
355         __debug_object_init(addr, descr, 0);
356 }
357
358 /**
359  * debug_object_init_on_stack - debug checks when an object on stack is
360  *                              initialized
361  * @addr:       address of the object
362  * @descr:      pointer to an object specific debug description structure
363  */
364 void debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr)
365 {
366         if (!debug_objects_enabled)
367                 return;
368
369         __debug_object_init(addr, descr, 1);
370 }
371
372 /**
373  * debug_object_activate - debug checks when an object is activated
374  * @addr:       address of the object
375  * @descr:      pointer to an object specific debug description structure
376  */
377 void debug_object_activate(void *addr, struct debug_obj_descr *descr)
378 {
379         enum debug_obj_state state;
380         struct debug_bucket *db;
381         struct debug_obj *obj;
382         unsigned long flags;
383
384         if (!debug_objects_enabled)
385                 return;
386
387         db = get_bucket((unsigned long) addr);
388
389         raw_spin_lock_irqsave(&db->lock, flags);
390
391         obj = lookup_object(addr, db);
392         if (obj) {
393                 switch (obj->state) {
394                 case ODEBUG_STATE_INIT:
395                 case ODEBUG_STATE_INACTIVE:
396                         obj->state = ODEBUG_STATE_ACTIVE;
397                         break;
398
399                 case ODEBUG_STATE_ACTIVE:
400                         debug_print_object(obj, "activate");
401                         state = obj->state;
402                         raw_spin_unlock_irqrestore(&db->lock, flags);
403                         debug_object_fixup(descr->fixup_activate, addr, state);
404                         return;
405
406                 case ODEBUG_STATE_DESTROYED:
407                         debug_print_object(obj, "activate");
408                         break;
409                 default:
410                         break;
411                 }
412                 raw_spin_unlock_irqrestore(&db->lock, flags);
413                 return;
414         }
415
416         raw_spin_unlock_irqrestore(&db->lock, flags);
417         /*
418          * This happens when a static object is activated. We
419          * let the type specific code decide whether this is
420          * true or not.
421          */
422         debug_object_fixup(descr->fixup_activate, addr,
423                            ODEBUG_STATE_NOTAVAILABLE);
424 }
425
426 /**
427  * debug_object_deactivate - debug checks when an object is deactivated
428  * @addr:       address of the object
429  * @descr:      pointer to an object specific debug description structure
430  */
431 void debug_object_deactivate(void *addr, struct debug_obj_descr *descr)
432 {
433         struct debug_bucket *db;
434         struct debug_obj *obj;
435         unsigned long flags;
436
437         if (!debug_objects_enabled)
438                 return;
439
440         db = get_bucket((unsigned long) addr);
441
442         raw_spin_lock_irqsave(&db->lock, flags);
443
444         obj = lookup_object(addr, db);
445         if (obj) {
446                 switch (obj->state) {
447                 case ODEBUG_STATE_INIT:
448                 case ODEBUG_STATE_INACTIVE:
449                 case ODEBUG_STATE_ACTIVE:
450                         obj->state = ODEBUG_STATE_INACTIVE;
451                         break;
452
453                 case ODEBUG_STATE_DESTROYED:
454                         debug_print_object(obj, "deactivate");
455                         break;
456                 default:
457                         break;
458                 }
459         } else {
460                 struct debug_obj o = { .object = addr,
461                                        .state = ODEBUG_STATE_NOTAVAILABLE,
462                                        .descr = descr };
463
464                 debug_print_object(&o, "deactivate");
465         }
466
467         raw_spin_unlock_irqrestore(&db->lock, flags);
468 }
469
470 /**
471  * debug_object_destroy - debug checks when an object is destroyed
472  * @addr:       address of the object
473  * @descr:      pointer to an object specific debug description structure
474  */
475 void debug_object_destroy(void *addr, struct debug_obj_descr *descr)
476 {
477         enum debug_obj_state state;
478         struct debug_bucket *db;
479         struct debug_obj *obj;
480         unsigned long flags;
481
482         if (!debug_objects_enabled)
483                 return;
484
485         db = get_bucket((unsigned long) addr);
486
487         raw_spin_lock_irqsave(&db->lock, flags);
488
489         obj = lookup_object(addr, db);
490         if (!obj)
491                 goto out_unlock;
492
493         switch (obj->state) {
494         case ODEBUG_STATE_NONE:
495         case ODEBUG_STATE_INIT:
496         case ODEBUG_STATE_INACTIVE:
497                 obj->state = ODEBUG_STATE_DESTROYED;
498                 break;
499         case ODEBUG_STATE_ACTIVE:
500                 debug_print_object(obj, "destroy");
501                 state = obj->state;
502                 raw_spin_unlock_irqrestore(&db->lock, flags);
503                 debug_object_fixup(descr->fixup_destroy, addr, state);
504                 return;
505
506         case ODEBUG_STATE_DESTROYED:
507                 debug_print_object(obj, "destroy");
508                 break;
509         default:
510                 break;
511         }
512 out_unlock:
513         raw_spin_unlock_irqrestore(&db->lock, flags);
514 }
515
516 /**
517  * debug_object_free - debug checks when an object is freed
518  * @addr:       address of the object
519  * @descr:      pointer to an object specific debug description structure
520  */
521 void debug_object_free(void *addr, struct debug_obj_descr *descr)
522 {
523         enum debug_obj_state state;
524         struct debug_bucket *db;
525         struct debug_obj *obj;
526         unsigned long flags;
527
528         if (!debug_objects_enabled)
529                 return;
530
531         db = get_bucket((unsigned long) addr);
532
533         raw_spin_lock_irqsave(&db->lock, flags);
534
535         obj = lookup_object(addr, db);
536         if (!obj)
537                 goto out_unlock;
538
539         switch (obj->state) {
540         case ODEBUG_STATE_ACTIVE:
541                 debug_print_object(obj, "free");
542                 state = obj->state;
543                 raw_spin_unlock_irqrestore(&db->lock, flags);
544                 debug_object_fixup(descr->fixup_free, addr, state);
545                 return;
546         default:
547                 hlist_del(&obj->node);
548                 raw_spin_unlock_irqrestore(&db->lock, flags);
549                 free_object(obj);
550                 return;
551         }
552 out_unlock:
553         raw_spin_unlock_irqrestore(&db->lock, flags);
554 }
555
556 #ifdef CONFIG_DEBUG_OBJECTS_FREE
557 static void __debug_check_no_obj_freed(const void *address, unsigned long size)
558 {
559         unsigned long flags, oaddr, saddr, eaddr, paddr, chunks;
560         struct hlist_node *node, *tmp;
561         HLIST_HEAD(freelist);
562         struct debug_obj_descr *descr;
563         enum debug_obj_state state;
564         struct debug_bucket *db;
565         struct debug_obj *obj;
566         int cnt;
567
568         saddr = (unsigned long) address;
569         eaddr = saddr + size;
570         paddr = saddr & ODEBUG_CHUNK_MASK;
571         chunks = ((eaddr - paddr) + (ODEBUG_CHUNK_SIZE - 1));
572         chunks >>= ODEBUG_CHUNK_SHIFT;
573
574         for (;chunks > 0; chunks--, paddr += ODEBUG_CHUNK_SIZE) {
575                 db = get_bucket(paddr);
576
577 repeat:
578                 cnt = 0;
579                 raw_spin_lock_irqsave(&db->lock, flags);
580                 hlist_for_each_entry_safe(obj, node, tmp, &db->list, node) {
581                         cnt++;
582                         oaddr = (unsigned long) obj->object;
583                         if (oaddr < saddr || oaddr >= eaddr)
584                                 continue;
585
586                         switch (obj->state) {
587                         case ODEBUG_STATE_ACTIVE:
588                                 debug_print_object(obj, "free");
589                                 descr = obj->descr;
590                                 state = obj->state;
591                                 raw_spin_unlock_irqrestore(&db->lock, flags);
592                                 debug_object_fixup(descr->fixup_free,
593                                                    (void *) oaddr, state);
594                                 goto repeat;
595                         default:
596                                 hlist_del(&obj->node);
597                                 hlist_add_head(&obj->node, &freelist);
598                                 break;
599                         }
600                 }
601                 raw_spin_unlock_irqrestore(&db->lock, flags);
602
603                 /* Now free them */
604                 hlist_for_each_entry_safe(obj, node, tmp, &freelist, node) {
605                         hlist_del(&obj->node);
606                         free_object(obj);
607                 }
608
609                 if (cnt > debug_objects_maxchain)
610                         debug_objects_maxchain = cnt;
611         }
612 }
613
614 void debug_check_no_obj_freed(const void *address, unsigned long size)
615 {
616         if (debug_objects_enabled)
617                 __debug_check_no_obj_freed(address, size);
618 }
619 #endif
620
621 #ifdef CONFIG_DEBUG_FS
622
623 static int debug_stats_show(struct seq_file *m, void *v)
624 {
625         seq_printf(m, "max_chain     :%d\n", debug_objects_maxchain);
626         seq_printf(m, "warnings      :%d\n", debug_objects_warnings);
627         seq_printf(m, "fixups        :%d\n", debug_objects_fixups);
628         seq_printf(m, "pool_free     :%d\n", obj_pool_free);
629         seq_printf(m, "pool_min_free :%d\n", obj_pool_min_free);
630         seq_printf(m, "pool_used     :%d\n", obj_pool_used);
631         seq_printf(m, "pool_max_used :%d\n", obj_pool_max_used);
632         return 0;
633 }
634
635 static int debug_stats_open(struct inode *inode, struct file *filp)
636 {
637         return single_open(filp, debug_stats_show, NULL);
638 }
639
640 static const struct file_operations debug_stats_fops = {
641         .open           = debug_stats_open,
642         .read           = seq_read,
643         .llseek         = seq_lseek,
644         .release        = single_release,
645 };
646
647 static int __init debug_objects_init_debugfs(void)
648 {
649         struct dentry *dbgdir, *dbgstats;
650
651         if (!debug_objects_enabled)
652                 return 0;
653
654         dbgdir = debugfs_create_dir("debug_objects", NULL);
655         if (!dbgdir)
656                 return -ENOMEM;
657
658         dbgstats = debugfs_create_file("stats", 0444, dbgdir, NULL,
659                                        &debug_stats_fops);
660         if (!dbgstats)
661                 goto err;
662
663         return 0;
664
665 err:
666         debugfs_remove(dbgdir);
667
668         return -ENOMEM;
669 }
670 __initcall(debug_objects_init_debugfs);
671
672 #else
673 static inline void debug_objects_init_debugfs(void) { }
674 #endif
675
676 #ifdef CONFIG_DEBUG_OBJECTS_SELFTEST
677
678 /* Random data structure for the self test */
679 struct self_test {
680         unsigned long   dummy1[6];
681         int             static_init;
682         unsigned long   dummy2[3];
683 };
684
685 static __initdata struct debug_obj_descr descr_type_test;
686
687 /*
688  * fixup_init is called when:
689  * - an active object is initialized
690  */
691 static int __init fixup_init(void *addr, enum debug_obj_state state)
692 {
693         struct self_test *obj = addr;
694
695         switch (state) {
696         case ODEBUG_STATE_ACTIVE:
697                 debug_object_deactivate(obj, &descr_type_test);
698                 debug_object_init(obj, &descr_type_test);
699                 return 1;
700         default:
701                 return 0;
702         }
703 }
704
705 /*
706  * fixup_activate is called when:
707  * - an active object is activated
708  * - an unknown object is activated (might be a statically initialized object)
709  */
710 static int __init fixup_activate(void *addr, enum debug_obj_state state)
711 {
712         struct self_test *obj = addr;
713
714         switch (state) {
715         case ODEBUG_STATE_NOTAVAILABLE:
716                 if (obj->static_init == 1) {
717                         debug_object_init(obj, &descr_type_test);
718                         debug_object_activate(obj, &descr_type_test);
719                         /*
720                          * Real code should return 0 here ! This is
721                          * not a fixup of some bad behaviour. We
722                          * merily call the debug_init function to keep
723                          * track of the object.
724                          */
725                         return 1;
726                 } else {
727                         /* Real code needs to emit a warning here */
728                 }
729                 return 0;
730
731         case ODEBUG_STATE_ACTIVE:
732                 debug_object_deactivate(obj, &descr_type_test);
733                 debug_object_activate(obj, &descr_type_test);
734                 return 1;
735
736         default:
737                 return 0;
738         }
739 }
740
741 /*
742  * fixup_destroy is called when:
743  * - an active object is destroyed
744  */
745 static int __init fixup_destroy(void *addr, enum debug_obj_state state)
746 {
747         struct self_test *obj = addr;
748
749         switch (state) {
750         case ODEBUG_STATE_ACTIVE:
751                 debug_object_deactivate(obj, &descr_type_test);
752                 debug_object_destroy(obj, &descr_type_test);
753                 return 1;
754         default:
755                 return 0;
756         }
757 }
758
759 /*
760  * fixup_free is called when:
761  * - an active object is freed
762  */
763 static int __init fixup_free(void *addr, enum debug_obj_state state)
764 {
765         struct self_test *obj = addr;
766
767         switch (state) {
768         case ODEBUG_STATE_ACTIVE:
769                 debug_object_deactivate(obj, &descr_type_test);
770                 debug_object_free(obj, &descr_type_test);
771                 return 1;
772         default:
773                 return 0;
774         }
775 }
776
777 static int __init
778 check_results(void *addr, enum debug_obj_state state, int fixups, int warnings)
779 {
780         struct debug_bucket *db;
781         struct debug_obj *obj;
782         unsigned long flags;
783         int res = -EINVAL;
784
785         db = get_bucket((unsigned long) addr);
786
787         raw_spin_lock_irqsave(&db->lock, flags);
788
789         obj = lookup_object(addr, db);
790         if (!obj && state != ODEBUG_STATE_NONE) {
791                 WARN(1, KERN_ERR "ODEBUG: selftest object not found\n");
792                 goto out;
793         }
794         if (obj && obj->state != state) {
795                 WARN(1, KERN_ERR "ODEBUG: selftest wrong state: %d != %d\n",
796                        obj->state, state);
797                 goto out;
798         }
799         if (fixups != debug_objects_fixups) {
800                 WARN(1, KERN_ERR "ODEBUG: selftest fixups failed %d != %d\n",
801                        fixups, debug_objects_fixups);
802                 goto out;
803         }
804         if (warnings != debug_objects_warnings) {
805                 WARN(1, KERN_ERR "ODEBUG: selftest warnings failed %d != %d\n",
806                        warnings, debug_objects_warnings);
807                 goto out;
808         }
809         res = 0;
810 out:
811         raw_spin_unlock_irqrestore(&db->lock, flags);
812         if (res)
813                 debug_objects_enabled = 0;
814         return res;
815 }
816
817 static __initdata struct debug_obj_descr descr_type_test = {
818         .name                   = "selftest",
819         .fixup_init             = fixup_init,
820         .fixup_activate         = fixup_activate,
821         .fixup_destroy          = fixup_destroy,
822         .fixup_free             = fixup_free,
823 };
824
825 static __initdata struct self_test obj = { .static_init = 0 };
826
827 static void __init debug_objects_selftest(void)
828 {
829         int fixups, oldfixups, warnings, oldwarnings;
830         unsigned long flags;
831
832         local_irq_save(flags);
833
834         fixups = oldfixups = debug_objects_fixups;
835         warnings = oldwarnings = debug_objects_warnings;
836         descr_test = &descr_type_test;
837
838         debug_object_init(&obj, &descr_type_test);
839         if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
840                 goto out;
841         debug_object_activate(&obj, &descr_type_test);
842         if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
843                 goto out;
844         debug_object_activate(&obj, &descr_type_test);
845         if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, ++warnings))
846                 goto out;
847         debug_object_deactivate(&obj, &descr_type_test);
848         if (check_results(&obj, ODEBUG_STATE_INACTIVE, fixups, warnings))
849                 goto out;
850         debug_object_destroy(&obj, &descr_type_test);
851         if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, warnings))
852                 goto out;
853         debug_object_init(&obj, &descr_type_test);
854         if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
855                 goto out;
856         debug_object_activate(&obj, &descr_type_test);
857         if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
858                 goto out;
859         debug_object_deactivate(&obj, &descr_type_test);
860         if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
861                 goto out;
862         debug_object_free(&obj, &descr_type_test);
863         if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
864                 goto out;
865
866         obj.static_init = 1;
867         debug_object_activate(&obj, &descr_type_test);
868         if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, warnings))
869                 goto out;
870         debug_object_init(&obj, &descr_type_test);
871         if (check_results(&obj, ODEBUG_STATE_INIT, ++fixups, ++warnings))
872                 goto out;
873         debug_object_free(&obj, &descr_type_test);
874         if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
875                 goto out;
876
877 #ifdef CONFIG_DEBUG_OBJECTS_FREE
878         debug_object_init(&obj, &descr_type_test);
879         if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
880                 goto out;
881         debug_object_activate(&obj, &descr_type_test);
882         if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
883                 goto out;
884         __debug_check_no_obj_freed(&obj, sizeof(obj));
885         if (check_results(&obj, ODEBUG_STATE_NONE, ++fixups, ++warnings))
886                 goto out;
887 #endif
888         printk(KERN_INFO "ODEBUG: selftest passed\n");
889
890 out:
891         debug_objects_fixups = oldfixups;
892         debug_objects_warnings = oldwarnings;
893         descr_test = NULL;
894
895         local_irq_restore(flags);
896 }
897 #else
898 static inline void debug_objects_selftest(void) { }
899 #endif
900
901 /*
902  * Called during early boot to initialize the hash buckets and link
903  * the static object pool objects into the poll list. After this call
904  * the object tracker is fully operational.
905  */
906 void __init debug_objects_early_init(void)
907 {
908         int i;
909
910         for (i = 0; i < ODEBUG_HASH_SIZE; i++)
911                 raw_spin_lock_init(&obj_hash[i].lock);
912
913         for (i = 0; i < ODEBUG_POOL_SIZE; i++)
914                 hlist_add_head(&obj_static_pool[i].node, &obj_pool);
915 }
916
917 /*
918  * Convert the statically allocated objects to dynamic ones:
919  */
920 static int __init debug_objects_replace_static_objects(void)
921 {
922         struct debug_bucket *db = obj_hash;
923         struct hlist_node *node, *tmp;
924         struct debug_obj *obj, *new;
925         HLIST_HEAD(objects);
926         int i, cnt = 0;
927
928         for (i = 0; i < ODEBUG_POOL_SIZE; i++) {
929                 obj = kmem_cache_zalloc(obj_cache, GFP_KERNEL);
930                 if (!obj)
931                         goto free;
932                 hlist_add_head(&obj->node, &objects);
933         }
934
935         /*
936          * When debug_objects_mem_init() is called we know that only
937          * one CPU is up, so disabling interrupts is enough
938          * protection. This avoids the lockdep hell of lock ordering.
939          */
940         local_irq_disable();
941
942         /* Remove the statically allocated objects from the pool */
943         hlist_for_each_entry_safe(obj, node, tmp, &obj_pool, node)
944                 hlist_del(&obj->node);
945         /* Move the allocated objects to the pool */
946         hlist_move_list(&objects, &obj_pool);
947
948         /* Replace the active object references */
949         for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
950                 hlist_move_list(&db->list, &objects);
951
952                 hlist_for_each_entry(obj, node, &objects, node) {
953                         new = hlist_entry(obj_pool.first, typeof(*obj), node);
954                         hlist_del(&new->node);
955                         /* copy object data */
956                         *new = *obj;
957                         hlist_add_head(&new->node, &db->list);
958                         cnt++;
959                 }
960         }
961
962         printk(KERN_DEBUG "ODEBUG: %d of %d active objects replaced\n", cnt,
963                obj_pool_used);
964         local_irq_enable();
965         return 0;
966 free:
967         hlist_for_each_entry_safe(obj, node, tmp, &objects, node) {
968                 hlist_del(&obj->node);
969                 kmem_cache_free(obj_cache, obj);
970         }
971         return -ENOMEM;
972 }
973
974 /*
975  * Called after the kmem_caches are functional to setup a dedicated
976  * cache pool, which has the SLAB_DEBUG_OBJECTS flag set. This flag
977  * prevents that the debug code is called on kmem_cache_free() for the
978  * debug tracker objects to avoid recursive calls.
979  */
980 void __init debug_objects_mem_init(void)
981 {
982         if (!debug_objects_enabled)
983                 return;
984
985         obj_cache = kmem_cache_create("debug_objects_cache",
986                                       sizeof (struct debug_obj), 0,
987                                       SLAB_DEBUG_OBJECTS, NULL);
988
989         if (!obj_cache || debug_objects_replace_static_objects()) {
990                 debug_objects_enabled = 0;
991                 if (obj_cache)
992                         kmem_cache_destroy(obj_cache);
993                 printk(KERN_WARNING "ODEBUG: out of memory.\n");
994         } else
995                 debug_objects_selftest();
996 }