2 * Generic infrastructure for lifetime debugging of objects.
4 * Started by Thomas Gleixner
6 * Copyright (C) 2008, Thomas Gleixner <tglx@linutronix.de>
8 * For licencing details see kernel-base/COPYING
11 #define pr_fmt(fmt) "ODEBUG: " fmt
13 #include <linux/debugobjects.h>
14 #include <linux/interrupt.h>
15 #include <linux/sched.h>
16 #include <linux/sched/task_stack.h>
17 #include <linux/seq_file.h>
18 #include <linux/debugfs.h>
19 #include <linux/slab.h>
20 #include <linux/hash.h>
21 #include <linux/kmemleak.h>
23 #define ODEBUG_HASH_BITS 14
24 #define ODEBUG_HASH_SIZE (1 << ODEBUG_HASH_BITS)
26 #define ODEBUG_POOL_SIZE 1024
27 #define ODEBUG_POOL_MIN_LEVEL 256
29 #define ODEBUG_CHUNK_SHIFT PAGE_SHIFT
30 #define ODEBUG_CHUNK_SIZE (1 << ODEBUG_CHUNK_SHIFT)
31 #define ODEBUG_CHUNK_MASK (~(ODEBUG_CHUNK_SIZE - 1))
34 struct hlist_head list;
38 static struct debug_bucket obj_hash[ODEBUG_HASH_SIZE];
40 static struct debug_obj obj_static_pool[ODEBUG_POOL_SIZE] __initdata;
42 static DEFINE_RAW_SPINLOCK(pool_lock);
44 static HLIST_HEAD(obj_pool);
45 static HLIST_HEAD(obj_to_free);
47 static int obj_pool_min_free = ODEBUG_POOL_SIZE;
48 static int obj_pool_free = ODEBUG_POOL_SIZE;
49 static int obj_pool_used;
50 static int obj_pool_max_used;
51 /* The number of objs on the global free list */
52 static int obj_nr_tofree;
53 static struct kmem_cache *obj_cache;
55 static int debug_objects_maxchain __read_mostly;
56 static int debug_objects_maxchecked __read_mostly;
57 static int debug_objects_fixups __read_mostly;
58 static int debug_objects_warnings __read_mostly;
59 static int debug_objects_enabled __read_mostly
60 = CONFIG_DEBUG_OBJECTS_ENABLE_DEFAULT;
61 static int debug_objects_pool_size __read_mostly
63 static int debug_objects_pool_min_level __read_mostly
64 = ODEBUG_POOL_MIN_LEVEL;
65 static struct debug_obj_descr *descr_test __read_mostly;
68 * Track numbers of kmem_cache_alloc()/free() calls done.
70 static int debug_objects_allocated;
71 static int debug_objects_freed;
73 static void free_obj_work(struct work_struct *work);
74 static DECLARE_WORK(debug_obj_work, free_obj_work);
76 static int __init enable_object_debug(char *str)
78 debug_objects_enabled = 1;
82 static int __init disable_object_debug(char *str)
84 debug_objects_enabled = 0;
88 early_param("debug_objects", enable_object_debug);
89 early_param("no_debug_objects", disable_object_debug);
91 static const char *obj_states[ODEBUG_STATE_MAX] = {
92 [ODEBUG_STATE_NONE] = "none",
93 [ODEBUG_STATE_INIT] = "initialized",
94 [ODEBUG_STATE_INACTIVE] = "inactive",
95 [ODEBUG_STATE_ACTIVE] = "active",
96 [ODEBUG_STATE_DESTROYED] = "destroyed",
97 [ODEBUG_STATE_NOTAVAILABLE] = "not available",
100 static void fill_pool(void)
102 gfp_t gfp = GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN;
103 struct debug_obj *new, *obj;
106 if (likely(obj_pool_free >= debug_objects_pool_min_level))
110 * Reuse objs from the global free list; they will be reinitialized
113 while (obj_nr_tofree && (obj_pool_free < obj_pool_min_free)) {
114 raw_spin_lock_irqsave(&pool_lock, flags);
116 * Recheck with the lock held as the worker thread might have
117 * won the race and freed the global free list already.
120 obj = hlist_entry(obj_to_free.first, typeof(*obj), node);
121 hlist_del(&obj->node);
123 hlist_add_head(&obj->node, &obj_pool);
126 raw_spin_unlock_irqrestore(&pool_lock, flags);
129 if (unlikely(!obj_cache))
132 while (obj_pool_free < debug_objects_pool_min_level) {
134 new = kmem_cache_zalloc(obj_cache, gfp);
138 kmemleak_ignore(new);
139 raw_spin_lock_irqsave(&pool_lock, flags);
140 hlist_add_head(&new->node, &obj_pool);
141 debug_objects_allocated++;
143 raw_spin_unlock_irqrestore(&pool_lock, flags);
148 * Lookup an object in the hash bucket.
150 static struct debug_obj *lookup_object(void *addr, struct debug_bucket *b)
152 struct debug_obj *obj;
155 hlist_for_each_entry(obj, &b->list, node) {
157 if (obj->object == addr)
160 if (cnt > debug_objects_maxchain)
161 debug_objects_maxchain = cnt;
167 * Allocate a new object. If the pool is empty, switch off the debugger.
168 * Must be called with interrupts disabled.
170 static struct debug_obj *
171 alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
173 struct debug_obj *obj = NULL;
175 raw_spin_lock(&pool_lock);
176 if (obj_pool.first) {
177 obj = hlist_entry(obj_pool.first, typeof(*obj), node);
181 obj->state = ODEBUG_STATE_NONE;
183 hlist_del(&obj->node);
185 hlist_add_head(&obj->node, &b->list);
188 if (obj_pool_used > obj_pool_max_used)
189 obj_pool_max_used = obj_pool_used;
192 if (obj_pool_free < obj_pool_min_free)
193 obj_pool_min_free = obj_pool_free;
195 raw_spin_unlock(&pool_lock);
201 * workqueue function to free objects.
203 * To reduce contention on the global pool_lock, the actual freeing of
204 * debug objects will be delayed if the pool_lock is busy.
206 static void free_obj_work(struct work_struct *work)
208 struct hlist_node *tmp;
209 struct debug_obj *obj;
213 if (!raw_spin_trylock_irqsave(&pool_lock, flags))
217 * The objs on the pool list might be allocated before the work is
218 * run, so recheck if pool list it full or not, if not fill pool
219 * list from the global free list
221 while (obj_nr_tofree && obj_pool_free < debug_objects_pool_size) {
222 obj = hlist_entry(obj_to_free.first, typeof(*obj), node);
223 hlist_del(&obj->node);
224 hlist_add_head(&obj->node, &obj_pool);
230 * Pool list is already full and there are still objs on the free
231 * list. Move remaining free objs to a temporary list to free the
232 * memory outside the pool_lock held region.
235 hlist_move_list(&obj_to_free, &tofree);
238 raw_spin_unlock_irqrestore(&pool_lock, flags);
240 hlist_for_each_entry_safe(obj, tmp, &tofree, node) {
241 hlist_del(&obj->node);
242 kmem_cache_free(obj_cache, obj);
246 static bool __free_object(struct debug_obj *obj)
251 raw_spin_lock_irqsave(&pool_lock, flags);
252 work = (obj_pool_free > debug_objects_pool_size) && obj_cache;
257 hlist_add_head(&obj->node, &obj_to_free);
260 hlist_add_head(&obj->node, &obj_pool);
262 raw_spin_unlock_irqrestore(&pool_lock, flags);
267 * Put the object back into the pool and schedule work to free objects
270 static void free_object(struct debug_obj *obj)
272 if (__free_object(obj))
273 schedule_work(&debug_obj_work);
277 * We run out of memory. That means we probably have tons of objects
280 static void debug_objects_oom(void)
282 struct debug_bucket *db = obj_hash;
283 struct hlist_node *tmp;
284 HLIST_HEAD(freelist);
285 struct debug_obj *obj;
289 pr_warn("Out of memory. ODEBUG disabled\n");
291 for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
292 raw_spin_lock_irqsave(&db->lock, flags);
293 hlist_move_list(&db->list, &freelist);
294 raw_spin_unlock_irqrestore(&db->lock, flags);
297 hlist_for_each_entry_safe(obj, tmp, &freelist, node) {
298 hlist_del(&obj->node);
305 * We use the pfn of the address for the hash. That way we can check
306 * for freed objects simply by checking the affected bucket.
308 static struct debug_bucket *get_bucket(unsigned long addr)
312 hash = hash_long((addr >> ODEBUG_CHUNK_SHIFT), ODEBUG_HASH_BITS);
313 return &obj_hash[hash];
316 static void debug_print_object(struct debug_obj *obj, char *msg)
318 struct debug_obj_descr *descr = obj->descr;
321 if (limit < 5 && descr != descr_test) {
322 void *hint = descr->debug_hint ?
323 descr->debug_hint(obj->object) : NULL;
325 WARN(1, KERN_ERR "ODEBUG: %s %s (active state %u) "
326 "object type: %s hint: %pS\n",
327 msg, obj_states[obj->state], obj->astate,
330 debug_objects_warnings++;
334 * Try to repair the damage, so we have a better chance to get useful
338 debug_object_fixup(bool (*fixup)(void *addr, enum debug_obj_state state),
339 void * addr, enum debug_obj_state state)
341 if (fixup && fixup(addr, state)) {
342 debug_objects_fixups++;
348 static void debug_object_is_on_stack(void *addr, int onstack)
356 is_on_stack = object_is_on_stack(addr);
357 if (is_on_stack == onstack)
362 pr_warn("object is on stack, but not annotated\n");
364 pr_warn("object is not on stack, but annotated\n");
369 __debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
371 enum debug_obj_state state;
372 struct debug_bucket *db;
373 struct debug_obj *obj;
378 db = get_bucket((unsigned long) addr);
380 raw_spin_lock_irqsave(&db->lock, flags);
382 obj = lookup_object(addr, db);
384 obj = alloc_object(addr, db, descr);
386 debug_objects_enabled = 0;
387 raw_spin_unlock_irqrestore(&db->lock, flags);
391 debug_object_is_on_stack(addr, onstack);
394 switch (obj->state) {
395 case ODEBUG_STATE_NONE:
396 case ODEBUG_STATE_INIT:
397 case ODEBUG_STATE_INACTIVE:
398 obj->state = ODEBUG_STATE_INIT;
401 case ODEBUG_STATE_ACTIVE:
402 debug_print_object(obj, "init");
404 raw_spin_unlock_irqrestore(&db->lock, flags);
405 debug_object_fixup(descr->fixup_init, addr, state);
408 case ODEBUG_STATE_DESTROYED:
409 debug_print_object(obj, "init");
415 raw_spin_unlock_irqrestore(&db->lock, flags);
419 * debug_object_init - debug checks when an object is initialized
420 * @addr: address of the object
421 * @descr: pointer to an object specific debug description structure
423 void debug_object_init(void *addr, struct debug_obj_descr *descr)
425 if (!debug_objects_enabled)
428 __debug_object_init(addr, descr, 0);
430 EXPORT_SYMBOL_GPL(debug_object_init);
433 * debug_object_init_on_stack - debug checks when an object on stack is
435 * @addr: address of the object
436 * @descr: pointer to an object specific debug description structure
438 void debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr)
440 if (!debug_objects_enabled)
443 __debug_object_init(addr, descr, 1);
445 EXPORT_SYMBOL_GPL(debug_object_init_on_stack);
448 * debug_object_activate - debug checks when an object is activated
449 * @addr: address of the object
450 * @descr: pointer to an object specific debug description structure
451 * Returns 0 for success, -EINVAL for check failed.
453 int debug_object_activate(void *addr, struct debug_obj_descr *descr)
455 enum debug_obj_state state;
456 struct debug_bucket *db;
457 struct debug_obj *obj;
460 struct debug_obj o = { .object = addr,
461 .state = ODEBUG_STATE_NOTAVAILABLE,
464 if (!debug_objects_enabled)
467 db = get_bucket((unsigned long) addr);
469 raw_spin_lock_irqsave(&db->lock, flags);
471 obj = lookup_object(addr, db);
473 switch (obj->state) {
474 case ODEBUG_STATE_INIT:
475 case ODEBUG_STATE_INACTIVE:
476 obj->state = ODEBUG_STATE_ACTIVE;
480 case ODEBUG_STATE_ACTIVE:
481 debug_print_object(obj, "activate");
483 raw_spin_unlock_irqrestore(&db->lock, flags);
484 ret = debug_object_fixup(descr->fixup_activate, addr, state);
485 return ret ? 0 : -EINVAL;
487 case ODEBUG_STATE_DESTROYED:
488 debug_print_object(obj, "activate");
495 raw_spin_unlock_irqrestore(&db->lock, flags);
499 raw_spin_unlock_irqrestore(&db->lock, flags);
501 * We are here when a static object is activated. We
502 * let the type specific code confirm whether this is
503 * true or not. if true, we just make sure that the
504 * static object is tracked in the object tracker. If
505 * not, this must be a bug, so we try to fix it up.
507 if (descr->is_static_object && descr->is_static_object(addr)) {
508 /* track this static object */
509 debug_object_init(addr, descr);
510 debug_object_activate(addr, descr);
512 debug_print_object(&o, "activate");
513 ret = debug_object_fixup(descr->fixup_activate, addr,
514 ODEBUG_STATE_NOTAVAILABLE);
515 return ret ? 0 : -EINVAL;
519 EXPORT_SYMBOL_GPL(debug_object_activate);
522 * debug_object_deactivate - debug checks when an object is deactivated
523 * @addr: address of the object
524 * @descr: pointer to an object specific debug description structure
526 void debug_object_deactivate(void *addr, struct debug_obj_descr *descr)
528 struct debug_bucket *db;
529 struct debug_obj *obj;
532 if (!debug_objects_enabled)
535 db = get_bucket((unsigned long) addr);
537 raw_spin_lock_irqsave(&db->lock, flags);
539 obj = lookup_object(addr, db);
541 switch (obj->state) {
542 case ODEBUG_STATE_INIT:
543 case ODEBUG_STATE_INACTIVE:
544 case ODEBUG_STATE_ACTIVE:
546 obj->state = ODEBUG_STATE_INACTIVE;
548 debug_print_object(obj, "deactivate");
551 case ODEBUG_STATE_DESTROYED:
552 debug_print_object(obj, "deactivate");
558 struct debug_obj o = { .object = addr,
559 .state = ODEBUG_STATE_NOTAVAILABLE,
562 debug_print_object(&o, "deactivate");
565 raw_spin_unlock_irqrestore(&db->lock, flags);
567 EXPORT_SYMBOL_GPL(debug_object_deactivate);
570 * debug_object_destroy - debug checks when an object is destroyed
571 * @addr: address of the object
572 * @descr: pointer to an object specific debug description structure
574 void debug_object_destroy(void *addr, struct debug_obj_descr *descr)
576 enum debug_obj_state state;
577 struct debug_bucket *db;
578 struct debug_obj *obj;
581 if (!debug_objects_enabled)
584 db = get_bucket((unsigned long) addr);
586 raw_spin_lock_irqsave(&db->lock, flags);
588 obj = lookup_object(addr, db);
592 switch (obj->state) {
593 case ODEBUG_STATE_NONE:
594 case ODEBUG_STATE_INIT:
595 case ODEBUG_STATE_INACTIVE:
596 obj->state = ODEBUG_STATE_DESTROYED;
598 case ODEBUG_STATE_ACTIVE:
599 debug_print_object(obj, "destroy");
601 raw_spin_unlock_irqrestore(&db->lock, flags);
602 debug_object_fixup(descr->fixup_destroy, addr, state);
605 case ODEBUG_STATE_DESTROYED:
606 debug_print_object(obj, "destroy");
612 raw_spin_unlock_irqrestore(&db->lock, flags);
614 EXPORT_SYMBOL_GPL(debug_object_destroy);
617 * debug_object_free - debug checks when an object is freed
618 * @addr: address of the object
619 * @descr: pointer to an object specific debug description structure
621 void debug_object_free(void *addr, struct debug_obj_descr *descr)
623 enum debug_obj_state state;
624 struct debug_bucket *db;
625 struct debug_obj *obj;
628 if (!debug_objects_enabled)
631 db = get_bucket((unsigned long) addr);
633 raw_spin_lock_irqsave(&db->lock, flags);
635 obj = lookup_object(addr, db);
639 switch (obj->state) {
640 case ODEBUG_STATE_ACTIVE:
641 debug_print_object(obj, "free");
643 raw_spin_unlock_irqrestore(&db->lock, flags);
644 debug_object_fixup(descr->fixup_free, addr, state);
647 hlist_del(&obj->node);
648 raw_spin_unlock_irqrestore(&db->lock, flags);
653 raw_spin_unlock_irqrestore(&db->lock, flags);
655 EXPORT_SYMBOL_GPL(debug_object_free);
658 * debug_object_assert_init - debug checks when object should be init-ed
659 * @addr: address of the object
660 * @descr: pointer to an object specific debug description structure
662 void debug_object_assert_init(void *addr, struct debug_obj_descr *descr)
664 struct debug_bucket *db;
665 struct debug_obj *obj;
668 if (!debug_objects_enabled)
671 db = get_bucket((unsigned long) addr);
673 raw_spin_lock_irqsave(&db->lock, flags);
675 obj = lookup_object(addr, db);
677 struct debug_obj o = { .object = addr,
678 .state = ODEBUG_STATE_NOTAVAILABLE,
681 raw_spin_unlock_irqrestore(&db->lock, flags);
683 * Maybe the object is static, and we let the type specific
684 * code confirm. Track this static object if true, else invoke
687 if (descr->is_static_object && descr->is_static_object(addr)) {
688 /* Track this static object */
689 debug_object_init(addr, descr);
691 debug_print_object(&o, "assert_init");
692 debug_object_fixup(descr->fixup_assert_init, addr,
693 ODEBUG_STATE_NOTAVAILABLE);
698 raw_spin_unlock_irqrestore(&db->lock, flags);
700 EXPORT_SYMBOL_GPL(debug_object_assert_init);
703 * debug_object_active_state - debug checks object usage state machine
704 * @addr: address of the object
705 * @descr: pointer to an object specific debug description structure
706 * @expect: expected state
707 * @next: state to move to if expected state is found
710 debug_object_active_state(void *addr, struct debug_obj_descr *descr,
711 unsigned int expect, unsigned int next)
713 struct debug_bucket *db;
714 struct debug_obj *obj;
717 if (!debug_objects_enabled)
720 db = get_bucket((unsigned long) addr);
722 raw_spin_lock_irqsave(&db->lock, flags);
724 obj = lookup_object(addr, db);
726 switch (obj->state) {
727 case ODEBUG_STATE_ACTIVE:
728 if (obj->astate == expect)
731 debug_print_object(obj, "active_state");
735 debug_print_object(obj, "active_state");
739 struct debug_obj o = { .object = addr,
740 .state = ODEBUG_STATE_NOTAVAILABLE,
743 debug_print_object(&o, "active_state");
746 raw_spin_unlock_irqrestore(&db->lock, flags);
748 EXPORT_SYMBOL_GPL(debug_object_active_state);
750 #ifdef CONFIG_DEBUG_OBJECTS_FREE
751 static void __debug_check_no_obj_freed(const void *address, unsigned long size)
753 unsigned long flags, oaddr, saddr, eaddr, paddr, chunks;
754 struct debug_obj_descr *descr;
755 enum debug_obj_state state;
756 struct debug_bucket *db;
757 struct hlist_node *tmp;
758 struct debug_obj *obj;
759 int cnt, objs_checked = 0;
762 saddr = (unsigned long) address;
763 eaddr = saddr + size;
764 paddr = saddr & ODEBUG_CHUNK_MASK;
765 chunks = ((eaddr - paddr) + (ODEBUG_CHUNK_SIZE - 1));
766 chunks >>= ODEBUG_CHUNK_SHIFT;
768 for (;chunks > 0; chunks--, paddr += ODEBUG_CHUNK_SIZE) {
769 db = get_bucket(paddr);
773 raw_spin_lock_irqsave(&db->lock, flags);
774 hlist_for_each_entry_safe(obj, tmp, &db->list, node) {
776 oaddr = (unsigned long) obj->object;
777 if (oaddr < saddr || oaddr >= eaddr)
780 switch (obj->state) {
781 case ODEBUG_STATE_ACTIVE:
782 debug_print_object(obj, "free");
785 raw_spin_unlock_irqrestore(&db->lock, flags);
786 debug_object_fixup(descr->fixup_free,
787 (void *) oaddr, state);
790 hlist_del(&obj->node);
791 work |= __free_object(obj);
795 raw_spin_unlock_irqrestore(&db->lock, flags);
797 if (cnt > debug_objects_maxchain)
798 debug_objects_maxchain = cnt;
803 if (objs_checked > debug_objects_maxchecked)
804 debug_objects_maxchecked = objs_checked;
806 /* Schedule work to actually kmem_cache_free() objects */
808 schedule_work(&debug_obj_work);
811 void debug_check_no_obj_freed(const void *address, unsigned long size)
813 if (debug_objects_enabled)
814 __debug_check_no_obj_freed(address, size);
818 #ifdef CONFIG_DEBUG_FS
820 static int debug_stats_show(struct seq_file *m, void *v)
822 seq_printf(m, "max_chain :%d\n", debug_objects_maxchain);
823 seq_printf(m, "max_checked :%d\n", debug_objects_maxchecked);
824 seq_printf(m, "warnings :%d\n", debug_objects_warnings);
825 seq_printf(m, "fixups :%d\n", debug_objects_fixups);
826 seq_printf(m, "pool_free :%d\n", obj_pool_free);
827 seq_printf(m, "pool_min_free :%d\n", obj_pool_min_free);
828 seq_printf(m, "pool_used :%d\n", obj_pool_used);
829 seq_printf(m, "pool_max_used :%d\n", obj_pool_max_used);
830 seq_printf(m, "on_free_list :%d\n", obj_nr_tofree);
831 seq_printf(m, "objs_allocated:%d\n", debug_objects_allocated);
832 seq_printf(m, "objs_freed :%d\n", debug_objects_freed);
836 static int debug_stats_open(struct inode *inode, struct file *filp)
838 return single_open(filp, debug_stats_show, NULL);
841 static const struct file_operations debug_stats_fops = {
842 .open = debug_stats_open,
845 .release = single_release,
848 static int __init debug_objects_init_debugfs(void)
850 struct dentry *dbgdir, *dbgstats;
852 if (!debug_objects_enabled)
855 dbgdir = debugfs_create_dir("debug_objects", NULL);
859 dbgstats = debugfs_create_file("stats", 0444, dbgdir, NULL,
867 debugfs_remove(dbgdir);
871 __initcall(debug_objects_init_debugfs);
874 static inline void debug_objects_init_debugfs(void) { }
877 #ifdef CONFIG_DEBUG_OBJECTS_SELFTEST
879 /* Random data structure for the self test */
881 unsigned long dummy1[6];
883 unsigned long dummy2[3];
886 static __initdata struct debug_obj_descr descr_type_test;
888 static bool __init is_static_object(void *addr)
890 struct self_test *obj = addr;
892 return obj->static_init;
896 * fixup_init is called when:
897 * - an active object is initialized
899 static bool __init fixup_init(void *addr, enum debug_obj_state state)
901 struct self_test *obj = addr;
904 case ODEBUG_STATE_ACTIVE:
905 debug_object_deactivate(obj, &descr_type_test);
906 debug_object_init(obj, &descr_type_test);
914 * fixup_activate is called when:
915 * - an active object is activated
916 * - an unknown non-static object is activated
918 static bool __init fixup_activate(void *addr, enum debug_obj_state state)
920 struct self_test *obj = addr;
923 case ODEBUG_STATE_NOTAVAILABLE:
925 case ODEBUG_STATE_ACTIVE:
926 debug_object_deactivate(obj, &descr_type_test);
927 debug_object_activate(obj, &descr_type_test);
936 * fixup_destroy is called when:
937 * - an active object is destroyed
939 static bool __init fixup_destroy(void *addr, enum debug_obj_state state)
941 struct self_test *obj = addr;
944 case ODEBUG_STATE_ACTIVE:
945 debug_object_deactivate(obj, &descr_type_test);
946 debug_object_destroy(obj, &descr_type_test);
954 * fixup_free is called when:
955 * - an active object is freed
957 static bool __init fixup_free(void *addr, enum debug_obj_state state)
959 struct self_test *obj = addr;
962 case ODEBUG_STATE_ACTIVE:
963 debug_object_deactivate(obj, &descr_type_test);
964 debug_object_free(obj, &descr_type_test);
972 check_results(void *addr, enum debug_obj_state state, int fixups, int warnings)
974 struct debug_bucket *db;
975 struct debug_obj *obj;
979 db = get_bucket((unsigned long) addr);
981 raw_spin_lock_irqsave(&db->lock, flags);
983 obj = lookup_object(addr, db);
984 if (!obj && state != ODEBUG_STATE_NONE) {
985 WARN(1, KERN_ERR "ODEBUG: selftest object not found\n");
988 if (obj && obj->state != state) {
989 WARN(1, KERN_ERR "ODEBUG: selftest wrong state: %d != %d\n",
993 if (fixups != debug_objects_fixups) {
994 WARN(1, KERN_ERR "ODEBUG: selftest fixups failed %d != %d\n",
995 fixups, debug_objects_fixups);
998 if (warnings != debug_objects_warnings) {
999 WARN(1, KERN_ERR "ODEBUG: selftest warnings failed %d != %d\n",
1000 warnings, debug_objects_warnings);
1005 raw_spin_unlock_irqrestore(&db->lock, flags);
1007 debug_objects_enabled = 0;
1011 static __initdata struct debug_obj_descr descr_type_test = {
1013 .is_static_object = is_static_object,
1014 .fixup_init = fixup_init,
1015 .fixup_activate = fixup_activate,
1016 .fixup_destroy = fixup_destroy,
1017 .fixup_free = fixup_free,
1020 static __initdata struct self_test obj = { .static_init = 0 };
1022 static void __init debug_objects_selftest(void)
1024 int fixups, oldfixups, warnings, oldwarnings;
1025 unsigned long flags;
1027 local_irq_save(flags);
1029 fixups = oldfixups = debug_objects_fixups;
1030 warnings = oldwarnings = debug_objects_warnings;
1031 descr_test = &descr_type_test;
1033 debug_object_init(&obj, &descr_type_test);
1034 if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
1036 debug_object_activate(&obj, &descr_type_test);
1037 if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
1039 debug_object_activate(&obj, &descr_type_test);
1040 if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, ++warnings))
1042 debug_object_deactivate(&obj, &descr_type_test);
1043 if (check_results(&obj, ODEBUG_STATE_INACTIVE, fixups, warnings))
1045 debug_object_destroy(&obj, &descr_type_test);
1046 if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, warnings))
1048 debug_object_init(&obj, &descr_type_test);
1049 if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
1051 debug_object_activate(&obj, &descr_type_test);
1052 if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
1054 debug_object_deactivate(&obj, &descr_type_test);
1055 if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
1057 debug_object_free(&obj, &descr_type_test);
1058 if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
1061 obj.static_init = 1;
1062 debug_object_activate(&obj, &descr_type_test);
1063 if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
1065 debug_object_init(&obj, &descr_type_test);
1066 if (check_results(&obj, ODEBUG_STATE_INIT, ++fixups, ++warnings))
1068 debug_object_free(&obj, &descr_type_test);
1069 if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
1072 #ifdef CONFIG_DEBUG_OBJECTS_FREE
1073 debug_object_init(&obj, &descr_type_test);
1074 if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
1076 debug_object_activate(&obj, &descr_type_test);
1077 if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
1079 __debug_check_no_obj_freed(&obj, sizeof(obj));
1080 if (check_results(&obj, ODEBUG_STATE_NONE, ++fixups, ++warnings))
1083 pr_info("selftest passed\n");
1086 debug_objects_fixups = oldfixups;
1087 debug_objects_warnings = oldwarnings;
1090 local_irq_restore(flags);
1093 static inline void debug_objects_selftest(void) { }
1097 * Called during early boot to initialize the hash buckets and link
1098 * the static object pool objects into the poll list. After this call
1099 * the object tracker is fully operational.
1101 void __init debug_objects_early_init(void)
1105 for (i = 0; i < ODEBUG_HASH_SIZE; i++)
1106 raw_spin_lock_init(&obj_hash[i].lock);
1108 for (i = 0; i < ODEBUG_POOL_SIZE; i++)
1109 hlist_add_head(&obj_static_pool[i].node, &obj_pool);
1113 * Convert the statically allocated objects to dynamic ones:
1115 static int __init debug_objects_replace_static_objects(void)
1117 struct debug_bucket *db = obj_hash;
1118 struct hlist_node *tmp;
1119 struct debug_obj *obj, *new;
1120 HLIST_HEAD(objects);
1123 for (i = 0; i < ODEBUG_POOL_SIZE; i++) {
1124 obj = kmem_cache_zalloc(obj_cache, GFP_KERNEL);
1127 kmemleak_ignore(obj);
1128 hlist_add_head(&obj->node, &objects);
1132 * When debug_objects_mem_init() is called we know that only
1133 * one CPU is up, so disabling interrupts is enough
1134 * protection. This avoids the lockdep hell of lock ordering.
1136 local_irq_disable();
1138 /* Remove the statically allocated objects from the pool */
1139 hlist_for_each_entry_safe(obj, tmp, &obj_pool, node)
1140 hlist_del(&obj->node);
1141 /* Move the allocated objects to the pool */
1142 hlist_move_list(&objects, &obj_pool);
1144 /* Replace the active object references */
1145 for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
1146 hlist_move_list(&db->list, &objects);
1148 hlist_for_each_entry(obj, &objects, node) {
1149 new = hlist_entry(obj_pool.first, typeof(*obj), node);
1150 hlist_del(&new->node);
1151 /* copy object data */
1153 hlist_add_head(&new->node, &db->list);
1159 pr_debug("%d of %d active objects replaced\n",
1160 cnt, obj_pool_used);
1163 hlist_for_each_entry_safe(obj, tmp, &objects, node) {
1164 hlist_del(&obj->node);
1165 kmem_cache_free(obj_cache, obj);
1171 * Called after the kmem_caches are functional to setup a dedicated
1172 * cache pool, which has the SLAB_DEBUG_OBJECTS flag set. This flag
1173 * prevents that the debug code is called on kmem_cache_free() for the
1174 * debug tracker objects to avoid recursive calls.
1176 void __init debug_objects_mem_init(void)
1178 if (!debug_objects_enabled)
1181 obj_cache = kmem_cache_create("debug_objects_cache",
1182 sizeof (struct debug_obj), 0,
1183 SLAB_DEBUG_OBJECTS, NULL);
1185 if (!obj_cache || debug_objects_replace_static_objects()) {
1186 debug_objects_enabled = 0;
1188 kmem_cache_destroy(obj_cache);
1189 pr_warn("out of memory.\n");
1191 debug_objects_selftest();
1194 * Increase the thresholds for allocating and freeing objects
1195 * according to the number of possible CPUs available in the system.
1197 debug_objects_pool_size += num_possible_cpus() * 32;
1198 debug_objects_pool_min_level += num_possible_cpus() * 4;