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