Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
debugobjects.c
Go to the documentation of this file.
1 /*
2  * Generic infrastructure for lifetime debugging of objects.
3  *
4  * Started by Thomas Gleixner
5  *
6  * Copyright (C) 2008, Thomas Gleixner <[email protected]>
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;
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 void fill_pool(void)
83 {
85  struct debug_obj *new;
86  unsigned long flags;
87 
88  if (likely(obj_pool_free >= ODEBUG_POOL_MIN_LEVEL))
89  return;
90 
91  if (unlikely(!obj_cache))
92  return;
93 
94  while (obj_pool_free < ODEBUG_POOL_MIN_LEVEL) {
95 
96  new = kmem_cache_zalloc(obj_cache, gfp);
97  if (!new)
98  return;
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 }
106 
107 /*
108  * Lookup an object in the hash bucket.
109  */
110 static struct debug_obj *lookup_object(void *addr, struct debug_bucket *b)
111 {
112  struct hlist_node *node;
113  struct debug_obj *obj;
114  int cnt = 0;
115 
116  hlist_for_each_entry(obj, node, &b->list, node) {
117  cnt++;
118  if (obj->object == addr)
119  return obj;
120  }
121  if (cnt > debug_objects_maxchain)
122  debug_objects_maxchain = cnt;
123 
124  return NULL;
125 }
126 
127 /*
128  * Allocate a new object. If the pool is empty, switch off the debugger.
129  * Must be called with interrupts disabled.
130  */
131 static struct debug_obj *
132 alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
133 {
134  struct debug_obj *obj = NULL;
135 
136  raw_spin_lock(&pool_lock);
137  if (obj_pool.first) {
138  obj = hlist_entry(obj_pool.first, typeof(*obj), node);
139 
140  obj->object = addr;
141  obj->descr = descr;
142  obj->state = ODEBUG_STATE_NONE;
143  obj->astate = 0;
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 = keventd_up() && !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  struct debug_obj_descr *descr = obj->descr;
252  static int limit;
253 
254  if (limit < 5 && descr != descr_test) {
255  void *hint = descr->debug_hint ?
256  descr->debug_hint(obj->object) : NULL;
257  limit++;
258  WARN(1, KERN_ERR "ODEBUG: %s %s (active state %u) "
259  "object type: %s hint: %pS\n",
260  msg, obj_states[obj->state], obj->astate,
261  descr->name, hint);
262  }
263  debug_objects_warnings++;
264 }
265 
266 /*
267  * Try to repair the damage, so we have a better chance to get useful
268  * debug output.
269  */
270 static int
271 debug_object_fixup(int (*fixup)(void *addr, enum debug_obj_state state),
272  void * addr, enum debug_obj_state state)
273 {
274  int fixed = 0;
275 
276  if (fixup)
277  fixed = fixup(addr, state);
278  debug_objects_fixups += fixed;
279  return fixed;
280 }
281 
282 static void debug_object_is_on_stack(void *addr, int onstack)
283 {
284  int is_on_stack;
285  static int limit;
286 
287  if (limit > 4)
288  return;
289 
290  is_on_stack = object_is_on_stack(addr);
291  if (is_on_stack == onstack)
292  return;
293 
294  limit++;
295  if (is_on_stack)
297  "ODEBUG: object is on stack, but not annotated\n");
298  else
300  "ODEBUG: object is not on stack, but annotated\n");
301  WARN_ON(1);
302 }
303 
304 static void
305 __debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
306 {
307  enum debug_obj_state state;
308  struct debug_bucket *db;
309  struct debug_obj *obj;
310  unsigned long flags;
311 
312  fill_pool();
313 
314  db = get_bucket((unsigned long) addr);
315 
316  raw_spin_lock_irqsave(&db->lock, flags);
317 
318  obj = lookup_object(addr, db);
319  if (!obj) {
320  obj = alloc_object(addr, db, descr);
321  if (!obj) {
322  debug_objects_enabled = 0;
323  raw_spin_unlock_irqrestore(&db->lock, flags);
324  debug_objects_oom();
325  return;
326  }
327  debug_object_is_on_stack(addr, onstack);
328  }
329 
330  switch (obj->state) {
331  case ODEBUG_STATE_NONE:
332  case ODEBUG_STATE_INIT:
334  obj->state = ODEBUG_STATE_INIT;
335  break;
336 
337  case ODEBUG_STATE_ACTIVE:
338  debug_print_object(obj, "init");
339  state = obj->state;
340  raw_spin_unlock_irqrestore(&db->lock, flags);
341  debug_object_fixup(descr->fixup_init, addr, state);
342  return;
343 
345  debug_print_object(obj, "init");
346  break;
347  default:
348  break;
349  }
350 
351  raw_spin_unlock_irqrestore(&db->lock, flags);
352 }
353 
359 void debug_object_init(void *addr, struct debug_obj_descr *descr)
360 {
361  if (!debug_objects_enabled)
362  return;
363 
364  __debug_object_init(addr, descr, 0);
365 }
366 
373 void debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr)
374 {
375  if (!debug_objects_enabled)
376  return;
377 
378  __debug_object_init(addr, descr, 1);
379 }
380 
386 void debug_object_activate(void *addr, struct debug_obj_descr *descr)
387 {
388  enum debug_obj_state state;
389  struct debug_bucket *db;
390  struct debug_obj *obj;
391  unsigned long flags;
392  struct debug_obj o = { .object = addr,
393  .state = ODEBUG_STATE_NOTAVAILABLE,
394  .descr = descr };
395 
396  if (!debug_objects_enabled)
397  return;
398 
399  db = get_bucket((unsigned long) addr);
400 
401  raw_spin_lock_irqsave(&db->lock, flags);
402 
403  obj = lookup_object(addr, db);
404  if (obj) {
405  switch (obj->state) {
406  case ODEBUG_STATE_INIT:
408  obj->state = ODEBUG_STATE_ACTIVE;
409  break;
410 
411  case ODEBUG_STATE_ACTIVE:
412  debug_print_object(obj, "activate");
413  state = obj->state;
414  raw_spin_unlock_irqrestore(&db->lock, flags);
415  debug_object_fixup(descr->fixup_activate, addr, state);
416  return;
417 
419  debug_print_object(obj, "activate");
420  break;
421  default:
422  break;
423  }
424  raw_spin_unlock_irqrestore(&db->lock, flags);
425  return;
426  }
427 
428  raw_spin_unlock_irqrestore(&db->lock, flags);
429  /*
430  * This happens when a static object is activated. We
431  * let the type specific code decide whether this is
432  * true or not.
433  */
434  if (debug_object_fixup(descr->fixup_activate, addr,
436  debug_print_object(&o, "activate");
437 }
438 
444 void debug_object_deactivate(void *addr, struct debug_obj_descr *descr)
445 {
446  struct debug_bucket *db;
447  struct debug_obj *obj;
448  unsigned long flags;
449 
450  if (!debug_objects_enabled)
451  return;
452 
453  db = get_bucket((unsigned long) addr);
454 
455  raw_spin_lock_irqsave(&db->lock, flags);
456 
457  obj = lookup_object(addr, db);
458  if (obj) {
459  switch (obj->state) {
460  case ODEBUG_STATE_INIT:
462  case ODEBUG_STATE_ACTIVE:
463  if (!obj->astate)
465  else
466  debug_print_object(obj, "deactivate");
467  break;
468 
470  debug_print_object(obj, "deactivate");
471  break;
472  default:
473  break;
474  }
475  } else {
476  struct debug_obj o = { .object = addr,
477  .state = ODEBUG_STATE_NOTAVAILABLE,
478  .descr = descr };
479 
480  debug_print_object(&o, "deactivate");
481  }
482 
483  raw_spin_unlock_irqrestore(&db->lock, flags);
484 }
485 
491 void debug_object_destroy(void *addr, struct debug_obj_descr *descr)
492 {
493  enum debug_obj_state state;
494  struct debug_bucket *db;
495  struct debug_obj *obj;
496  unsigned long flags;
497 
498  if (!debug_objects_enabled)
499  return;
500 
501  db = get_bucket((unsigned long) addr);
502 
503  raw_spin_lock_irqsave(&db->lock, flags);
504 
505  obj = lookup_object(addr, db);
506  if (!obj)
507  goto out_unlock;
508 
509  switch (obj->state) {
510  case ODEBUG_STATE_NONE:
511  case ODEBUG_STATE_INIT:
514  break;
515  case ODEBUG_STATE_ACTIVE:
516  debug_print_object(obj, "destroy");
517  state = obj->state;
518  raw_spin_unlock_irqrestore(&db->lock, flags);
519  debug_object_fixup(descr->fixup_destroy, addr, state);
520  return;
521 
523  debug_print_object(obj, "destroy");
524  break;
525  default:
526  break;
527  }
528 out_unlock:
529  raw_spin_unlock_irqrestore(&db->lock, flags);
530 }
531 
537 void debug_object_free(void *addr, struct debug_obj_descr *descr)
538 {
539  enum debug_obj_state state;
540  struct debug_bucket *db;
541  struct debug_obj *obj;
542  unsigned long flags;
543 
544  if (!debug_objects_enabled)
545  return;
546 
547  db = get_bucket((unsigned long) addr);
548 
549  raw_spin_lock_irqsave(&db->lock, flags);
550 
551  obj = lookup_object(addr, db);
552  if (!obj)
553  goto out_unlock;
554 
555  switch (obj->state) {
556  case ODEBUG_STATE_ACTIVE:
557  debug_print_object(obj, "free");
558  state = obj->state;
559  raw_spin_unlock_irqrestore(&db->lock, flags);
560  debug_object_fixup(descr->fixup_free, addr, state);
561  return;
562  default:
563  hlist_del(&obj->node);
564  raw_spin_unlock_irqrestore(&db->lock, flags);
565  free_object(obj);
566  return;
567  }
568 out_unlock:
569  raw_spin_unlock_irqrestore(&db->lock, flags);
570 }
571 
577 void debug_object_assert_init(void *addr, struct debug_obj_descr *descr)
578 {
579  struct debug_bucket *db;
580  struct debug_obj *obj;
581  unsigned long flags;
582 
583  if (!debug_objects_enabled)
584  return;
585 
586  db = get_bucket((unsigned long) addr);
587 
588  raw_spin_lock_irqsave(&db->lock, flags);
589 
590  obj = lookup_object(addr, db);
591  if (!obj) {
592  struct debug_obj o = { .object = addr,
593  .state = ODEBUG_STATE_NOTAVAILABLE,
594  .descr = descr };
595 
596  raw_spin_unlock_irqrestore(&db->lock, flags);
597  /*
598  * Maybe the object is static. Let the type specific
599  * code decide what to do.
600  */
601  if (debug_object_fixup(descr->fixup_assert_init, addr,
603  debug_print_object(&o, "assert_init");
604  return;
605  }
606 
607  raw_spin_unlock_irqrestore(&db->lock, flags);
608 }
609 
617 void
618 debug_object_active_state(void *addr, struct debug_obj_descr *descr,
619  unsigned int expect, unsigned int next)
620 {
621  struct debug_bucket *db;
622  struct debug_obj *obj;
623  unsigned long flags;
624 
625  if (!debug_objects_enabled)
626  return;
627 
628  db = get_bucket((unsigned long) addr);
629 
630  raw_spin_lock_irqsave(&db->lock, flags);
631 
632  obj = lookup_object(addr, db);
633  if (obj) {
634  switch (obj->state) {
635  case ODEBUG_STATE_ACTIVE:
636  if (obj->astate == expect)
637  obj->astate = next;
638  else
639  debug_print_object(obj, "active_state");
640  break;
641 
642  default:
643  debug_print_object(obj, "active_state");
644  break;
645  }
646  } else {
647  struct debug_obj o = { .object = addr,
648  .state = ODEBUG_STATE_NOTAVAILABLE,
649  .descr = descr };
650 
651  debug_print_object(&o, "active_state");
652  }
653 
654  raw_spin_unlock_irqrestore(&db->lock, flags);
655 }
656 
657 #ifdef CONFIG_DEBUG_OBJECTS_FREE
658 static void __debug_check_no_obj_freed(const void *address, unsigned long size)
659 {
660  unsigned long flags, oaddr, saddr, eaddr, paddr, chunks;
661  struct hlist_node *node, *tmp;
662  HLIST_HEAD(freelist);
663  struct debug_obj_descr *descr;
664  enum debug_obj_state state;
665  struct debug_bucket *db;
666  struct debug_obj *obj;
667  int cnt;
668 
669  saddr = (unsigned long) address;
670  eaddr = saddr + size;
671  paddr = saddr & ODEBUG_CHUNK_MASK;
672  chunks = ((eaddr - paddr) + (ODEBUG_CHUNK_SIZE - 1));
673  chunks >>= ODEBUG_CHUNK_SHIFT;
674 
675  for (;chunks > 0; chunks--, paddr += ODEBUG_CHUNK_SIZE) {
676  db = get_bucket(paddr);
677 
678 repeat:
679  cnt = 0;
680  raw_spin_lock_irqsave(&db->lock, flags);
681  hlist_for_each_entry_safe(obj, node, tmp, &db->list, node) {
682  cnt++;
683  oaddr = (unsigned long) obj->object;
684  if (oaddr < saddr || oaddr >= eaddr)
685  continue;
686 
687  switch (obj->state) {
688  case ODEBUG_STATE_ACTIVE:
689  debug_print_object(obj, "free");
690  descr = obj->descr;
691  state = obj->state;
692  raw_spin_unlock_irqrestore(&db->lock, flags);
693  debug_object_fixup(descr->fixup_free,
694  (void *) oaddr, state);
695  goto repeat;
696  default:
697  hlist_del(&obj->node);
698  hlist_add_head(&obj->node, &freelist);
699  break;
700  }
701  }
702  raw_spin_unlock_irqrestore(&db->lock, flags);
703 
704  /* Now free them */
705  hlist_for_each_entry_safe(obj, node, tmp, &freelist, node) {
706  hlist_del(&obj->node);
707  free_object(obj);
708  }
709 
710  if (cnt > debug_objects_maxchain)
711  debug_objects_maxchain = cnt;
712  }
713 }
714 
715 void debug_check_no_obj_freed(const void *address, unsigned long size)
716 {
717  if (debug_objects_enabled)
718  __debug_check_no_obj_freed(address, size);
719 }
720 #endif
721 
722 #ifdef CONFIG_DEBUG_FS
723 
724 static int debug_stats_show(struct seq_file *m, void *v)
725 {
726  seq_printf(m, "max_chain :%d\n", debug_objects_maxchain);
727  seq_printf(m, "warnings :%d\n", debug_objects_warnings);
728  seq_printf(m, "fixups :%d\n", debug_objects_fixups);
729  seq_printf(m, "pool_free :%d\n", obj_pool_free);
730  seq_printf(m, "pool_min_free :%d\n", obj_pool_min_free);
731  seq_printf(m, "pool_used :%d\n", obj_pool_used);
732  seq_printf(m, "pool_max_used :%d\n", obj_pool_max_used);
733  return 0;
734 }
735 
736 static int debug_stats_open(struct inode *inode, struct file *filp)
737 {
738  return single_open(filp, debug_stats_show, NULL);
739 }
740 
741 static const struct file_operations debug_stats_fops = {
742  .open = debug_stats_open,
743  .read = seq_read,
744  .llseek = seq_lseek,
745  .release = single_release,
746 };
747 
748 static int __init debug_objects_init_debugfs(void)
749 {
750  struct dentry *dbgdir, *dbgstats;
751 
752  if (!debug_objects_enabled)
753  return 0;
754 
755  dbgdir = debugfs_create_dir("debug_objects", NULL);
756  if (!dbgdir)
757  return -ENOMEM;
758 
759  dbgstats = debugfs_create_file("stats", 0444, dbgdir, NULL,
760  &debug_stats_fops);
761  if (!dbgstats)
762  goto err;
763 
764  return 0;
765 
766 err:
767  debugfs_remove(dbgdir);
768 
769  return -ENOMEM;
770 }
771 __initcall(debug_objects_init_debugfs);
772 
773 #else
774 static inline void debug_objects_init_debugfs(void) { }
775 #endif
776 
777 #ifdef CONFIG_DEBUG_OBJECTS_SELFTEST
778 
779 /* Random data structure for the self test */
780 struct self_test {
781  unsigned long dummy1[6];
782  int static_init;
783  unsigned long dummy2[3];
784 };
785 
786 static __initdata struct debug_obj_descr descr_type_test;
787 
788 /*
789  * fixup_init is called when:
790  * - an active object is initialized
791  */
792 static int __init fixup_init(void *addr, enum debug_obj_state state)
793 {
794  struct self_test *obj = addr;
795 
796  switch (state) {
797  case ODEBUG_STATE_ACTIVE:
798  debug_object_deactivate(obj, &descr_type_test);
799  debug_object_init(obj, &descr_type_test);
800  return 1;
801  default:
802  return 0;
803  }
804 }
805 
806 /*
807  * fixup_activate is called when:
808  * - an active object is activated
809  * - an unknown object is activated (might be a statically initialized object)
810  */
811 static int __init fixup_activate(void *addr, enum debug_obj_state state)
812 {
813  struct self_test *obj = addr;
814 
815  switch (state) {
817  if (obj->static_init == 1) {
818  debug_object_init(obj, &descr_type_test);
819  debug_object_activate(obj, &descr_type_test);
820  return 0;
821  }
822  return 1;
823 
824  case ODEBUG_STATE_ACTIVE:
825  debug_object_deactivate(obj, &descr_type_test);
826  debug_object_activate(obj, &descr_type_test);
827  return 1;
828 
829  default:
830  return 0;
831  }
832 }
833 
834 /*
835  * fixup_destroy is called when:
836  * - an active object is destroyed
837  */
838 static int __init fixup_destroy(void *addr, enum debug_obj_state state)
839 {
840  struct self_test *obj = addr;
841 
842  switch (state) {
843  case ODEBUG_STATE_ACTIVE:
844  debug_object_deactivate(obj, &descr_type_test);
845  debug_object_destroy(obj, &descr_type_test);
846  return 1;
847  default:
848  return 0;
849  }
850 }
851 
852 /*
853  * fixup_free is called when:
854  * - an active object is freed
855  */
856 static int __init fixup_free(void *addr, enum debug_obj_state state)
857 {
858  struct self_test *obj = addr;
859 
860  switch (state) {
861  case ODEBUG_STATE_ACTIVE:
862  debug_object_deactivate(obj, &descr_type_test);
863  debug_object_free(obj, &descr_type_test);
864  return 1;
865  default:
866  return 0;
867  }
868 }
869 
870 static int __init
871 check_results(void *addr, enum debug_obj_state state, int fixups, int warnings)
872 {
873  struct debug_bucket *db;
874  struct debug_obj *obj;
875  unsigned long flags;
876  int res = -EINVAL;
877 
878  db = get_bucket((unsigned long) addr);
879 
880  raw_spin_lock_irqsave(&db->lock, flags);
881 
882  obj = lookup_object(addr, db);
883  if (!obj && state != ODEBUG_STATE_NONE) {
884  WARN(1, KERN_ERR "ODEBUG: selftest object not found\n");
885  goto out;
886  }
887  if (obj && obj->state != state) {
888  WARN(1, KERN_ERR "ODEBUG: selftest wrong state: %d != %d\n",
889  obj->state, state);
890  goto out;
891  }
892  if (fixups != debug_objects_fixups) {
893  WARN(1, KERN_ERR "ODEBUG: selftest fixups failed %d != %d\n",
894  fixups, debug_objects_fixups);
895  goto out;
896  }
897  if (warnings != debug_objects_warnings) {
898  WARN(1, KERN_ERR "ODEBUG: selftest warnings failed %d != %d\n",
899  warnings, debug_objects_warnings);
900  goto out;
901  }
902  res = 0;
903 out:
904  raw_spin_unlock_irqrestore(&db->lock, flags);
905  if (res)
906  debug_objects_enabled = 0;
907  return res;
908 }
909 
910 static __initdata struct debug_obj_descr descr_type_test = {
911  .name = "selftest",
912  .fixup_init = fixup_init,
913  .fixup_activate = fixup_activate,
914  .fixup_destroy = fixup_destroy,
915  .fixup_free = fixup_free,
916 };
917 
918 static __initdata struct self_test obj = { .static_init = 0 };
919 
920 static void __init debug_objects_selftest(void)
921 {
922  int fixups, oldfixups, warnings, oldwarnings;
923  unsigned long flags;
924 
925  local_irq_save(flags);
926 
927  fixups = oldfixups = debug_objects_fixups;
928  warnings = oldwarnings = debug_objects_warnings;
929  descr_test = &descr_type_test;
930 
931  debug_object_init(&obj, &descr_type_test);
932  if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
933  goto out;
934  debug_object_activate(&obj, &descr_type_test);
935  if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
936  goto out;
937  debug_object_activate(&obj, &descr_type_test);
938  if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, ++warnings))
939  goto out;
940  debug_object_deactivate(&obj, &descr_type_test);
941  if (check_results(&obj, ODEBUG_STATE_INACTIVE, fixups, warnings))
942  goto out;
943  debug_object_destroy(&obj, &descr_type_test);
944  if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, warnings))
945  goto out;
946  debug_object_init(&obj, &descr_type_test);
947  if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
948  goto out;
949  debug_object_activate(&obj, &descr_type_test);
950  if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
951  goto out;
952  debug_object_deactivate(&obj, &descr_type_test);
953  if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
954  goto out;
955  debug_object_free(&obj, &descr_type_test);
956  if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
957  goto out;
958 
959  obj.static_init = 1;
960  debug_object_activate(&obj, &descr_type_test);
961  if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
962  goto out;
963  debug_object_init(&obj, &descr_type_test);
964  if (check_results(&obj, ODEBUG_STATE_INIT, ++fixups, ++warnings))
965  goto out;
966  debug_object_free(&obj, &descr_type_test);
967  if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
968  goto out;
969 
970 #ifdef CONFIG_DEBUG_OBJECTS_FREE
971  debug_object_init(&obj, &descr_type_test);
972  if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
973  goto out;
974  debug_object_activate(&obj, &descr_type_test);
975  if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
976  goto out;
977  __debug_check_no_obj_freed(&obj, sizeof(obj));
978  if (check_results(&obj, ODEBUG_STATE_NONE, ++fixups, ++warnings))
979  goto out;
980 #endif
981  printk(KERN_INFO "ODEBUG: selftest passed\n");
982 
983 out:
984  debug_objects_fixups = oldfixups;
985  debug_objects_warnings = oldwarnings;
986  descr_test = NULL;
987 
988  local_irq_restore(flags);
989 }
990 #else
991 static inline void debug_objects_selftest(void) { }
992 #endif
993 
994 /*
995  * Called during early boot to initialize the hash buckets and link
996  * the static object pool objects into the poll list. After this call
997  * the object tracker is fully operational.
998  */
1000 {
1001  int i;
1002 
1003  for (i = 0; i < ODEBUG_HASH_SIZE; i++)
1004  raw_spin_lock_init(&obj_hash[i].lock);
1005 
1006  for (i = 0; i < ODEBUG_POOL_SIZE; i++)
1007  hlist_add_head(&obj_static_pool[i].node, &obj_pool);
1008 }
1009 
1010 /*
1011  * Convert the statically allocated objects to dynamic ones:
1012  */
1013 static int __init debug_objects_replace_static_objects(void)
1014 {
1015  struct debug_bucket *db = obj_hash;
1016  struct hlist_node *node, *tmp;
1017  struct debug_obj *obj, *new;
1018  HLIST_HEAD(objects);
1019  int i, cnt = 0;
1020 
1021  for (i = 0; i < ODEBUG_POOL_SIZE; i++) {
1022  obj = kmem_cache_zalloc(obj_cache, GFP_KERNEL);
1023  if (!obj)
1024  goto free;
1025  hlist_add_head(&obj->node, &objects);
1026  }
1027 
1028  /*
1029  * When debug_objects_mem_init() is called we know that only
1030  * one CPU is up, so disabling interrupts is enough
1031  * protection. This avoids the lockdep hell of lock ordering.
1032  */
1034 
1035  /* Remove the statically allocated objects from the pool */
1036  hlist_for_each_entry_safe(obj, node, tmp, &obj_pool, node)
1037  hlist_del(&obj->node);
1038  /* Move the allocated objects to the pool */
1039  hlist_move_list(&objects, &obj_pool);
1040 
1041  /* Replace the active object references */
1042  for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
1043  hlist_move_list(&db->list, &objects);
1044 
1045  hlist_for_each_entry(obj, node, &objects, node) {
1046  new = hlist_entry(obj_pool.first, typeof(*obj), node);
1047  hlist_del(&new->node);
1048  /* copy object data */
1049  *new = *obj;
1050  hlist_add_head(&new->node, &db->list);
1051  cnt++;
1052  }
1053  }
1054  local_irq_enable();
1055 
1056  printk(KERN_DEBUG "ODEBUG: %d of %d active objects replaced\n", cnt,
1057  obj_pool_used);
1058  return 0;
1059 free:
1060  hlist_for_each_entry_safe(obj, node, tmp, &objects, node) {
1061  hlist_del(&obj->node);
1062  kmem_cache_free(obj_cache, obj);
1063  }
1064  return -ENOMEM;
1065 }
1066 
1067 /*
1068  * Called after the kmem_caches are functional to setup a dedicated
1069  * cache pool, which has the SLAB_DEBUG_OBJECTS flag set. This flag
1070  * prevents that the debug code is called on kmem_cache_free() for the
1071  * debug tracker objects to avoid recursive calls.
1072  */
1074 {
1075  if (!debug_objects_enabled)
1076  return;
1077 
1078  obj_cache = kmem_cache_create("debug_objects_cache",
1079  sizeof (struct debug_obj), 0,
1081 
1082  if (!obj_cache || debug_objects_replace_static_objects()) {
1083  debug_objects_enabled = 0;
1084  if (obj_cache)
1085  kmem_cache_destroy(obj_cache);
1086  printk(KERN_WARNING "ODEBUG: out of memory.\n");
1087  } else
1088  debug_objects_selftest();
1089 }