Root/
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 void 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; |
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 debug_obj *obj; |
113 | int cnt = 0; |
114 | |
115 | hlist_for_each_entry(obj, &b->list, node) { |
116 | cnt++; |
117 | if (obj->object == addr) |
118 | return obj; |
119 | } |
120 | if (cnt > debug_objects_maxchain) |
121 | debug_objects_maxchain = cnt; |
122 | |
123 | return NULL; |
124 | } |
125 | |
126 | /* |
127 | * Allocate a new object. If the pool is empty, switch off the debugger. |
128 | * Must be called with interrupts disabled. |
129 | */ |
130 | static struct debug_obj * |
131 | alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr) |
132 | { |
133 | struct debug_obj *obj = NULL; |
134 | |
135 | raw_spin_lock(&pool_lock); |
136 | if (obj_pool.first) { |
137 | obj = hlist_entry(obj_pool.first, typeof(*obj), node); |
138 | |
139 | obj->object = addr; |
140 | obj->descr = descr; |
141 | obj->state = ODEBUG_STATE_NONE; |
142 | obj->astate = 0; |
143 | hlist_del(&obj->node); |
144 | |
145 | hlist_add_head(&obj->node, &b->list); |
146 | |
147 | obj_pool_used++; |
148 | if (obj_pool_used > obj_pool_max_used) |
149 | obj_pool_max_used = obj_pool_used; |
150 | |
151 | obj_pool_free--; |
152 | if (obj_pool_free < obj_pool_min_free) |
153 | obj_pool_min_free = obj_pool_free; |
154 | } |
155 | raw_spin_unlock(&pool_lock); |
156 | |
157 | return obj; |
158 | } |
159 | |
160 | /* |
161 | * workqueue function to free objects. |
162 | */ |
163 | static void free_obj_work(struct work_struct *work) |
164 | { |
165 | struct debug_obj *obj; |
166 | unsigned long flags; |
167 | |
168 | raw_spin_lock_irqsave(&pool_lock, flags); |
169 | while (obj_pool_free > ODEBUG_POOL_SIZE) { |
170 | obj = hlist_entry(obj_pool.first, typeof(*obj), node); |
171 | hlist_del(&obj->node); |
172 | obj_pool_free--; |
173 | /* |
174 | * We release pool_lock across kmem_cache_free() to |
175 | * avoid contention on pool_lock. |
176 | */ |
177 | raw_spin_unlock_irqrestore(&pool_lock, flags); |
178 | kmem_cache_free(obj_cache, obj); |
179 | raw_spin_lock_irqsave(&pool_lock, flags); |
180 | } |
181 | raw_spin_unlock_irqrestore(&pool_lock, flags); |
182 | } |
183 | |
184 | /* |
185 | * Put the object back into the pool and schedule work to free objects |
186 | * if necessary. |
187 | */ |
188 | static void free_object(struct debug_obj *obj) |
189 | { |
190 | unsigned long flags; |
191 | int sched = 0; |
192 | |
193 | raw_spin_lock_irqsave(&pool_lock, flags); |
194 | /* |
195 | * schedule work when the pool is filled and the cache is |
196 | * initialized: |
197 | */ |
198 | if (obj_pool_free > ODEBUG_POOL_SIZE && obj_cache) |
199 | sched = keventd_up(); |
200 | hlist_add_head(&obj->node, &obj_pool); |
201 | obj_pool_free++; |
202 | obj_pool_used--; |
203 | raw_spin_unlock_irqrestore(&pool_lock, flags); |
204 | if (sched) |
205 | schedule_work(&debug_obj_work); |
206 | } |
207 | |
208 | /* |
209 | * We run out of memory. That means we probably have tons of objects |
210 | * allocated. |
211 | */ |
212 | static void debug_objects_oom(void) |
213 | { |
214 | struct debug_bucket *db = obj_hash; |
215 | struct hlist_node *tmp; |
216 | HLIST_HEAD(freelist); |
217 | struct debug_obj *obj; |
218 | unsigned long flags; |
219 | int i; |
220 | |
221 | printk(KERN_WARNING "ODEBUG: Out of memory. ODEBUG disabled\n"); |
222 | |
223 | for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) { |
224 | raw_spin_lock_irqsave(&db->lock, flags); |
225 | hlist_move_list(&db->list, &freelist); |
226 | raw_spin_unlock_irqrestore(&db->lock, flags); |
227 | |
228 | /* Now free them */ |
229 | hlist_for_each_entry_safe(obj, tmp, &freelist, node) { |
230 | hlist_del(&obj->node); |
231 | free_object(obj); |
232 | } |
233 | } |
234 | } |
235 | |
236 | /* |
237 | * We use the pfn of the address for the hash. That way we can check |
238 | * for freed objects simply by checking the affected bucket. |
239 | */ |
240 | static struct debug_bucket *get_bucket(unsigned long addr) |
241 | { |
242 | unsigned long hash; |
243 | |
244 | hash = hash_long((addr >> ODEBUG_CHUNK_SHIFT), ODEBUG_HASH_BITS); |
245 | return &obj_hash[hash]; |
246 | } |
247 | |
248 | static void debug_print_object(struct debug_obj *obj, char *msg) |
249 | { |
250 | struct debug_obj_descr *descr = obj->descr; |
251 | static int limit; |
252 | |
253 | if (limit < 5 && descr != descr_test) { |
254 | void *hint = descr->debug_hint ? |
255 | descr->debug_hint(obj->object) : NULL; |
256 | limit++; |
257 | WARN(1, KERN_ERR "ODEBUG: %s %s (active state %u) " |
258 | "object type: %s hint: %pS\n", |
259 | msg, obj_states[obj->state], obj->astate, |
260 | descr->name, hint); |
261 | } |
262 | debug_objects_warnings++; |
263 | } |
264 | |
265 | /* |
266 | * Try to repair the damage, so we have a better chance to get useful |
267 | * debug output. |
268 | */ |
269 | static int |
270 | debug_object_fixup(int (*fixup)(void *addr, enum debug_obj_state state), |
271 | void * addr, enum debug_obj_state state) |
272 | { |
273 | int fixed = 0; |
274 | |
275 | if (fixup) |
276 | fixed = fixup(addr, state); |
277 | debug_objects_fixups += fixed; |
278 | return fixed; |
279 | } |
280 | |
281 | static void debug_object_is_on_stack(void *addr, int onstack) |
282 | { |
283 | int is_on_stack; |
284 | static int limit; |
285 | |
286 | if (limit > 4) |
287 | return; |
288 | |
289 | is_on_stack = object_is_on_stack(addr); |
290 | if (is_on_stack == onstack) |
291 | return; |
292 | |
293 | limit++; |
294 | if (is_on_stack) |
295 | printk(KERN_WARNING |
296 | "ODEBUG: object is on stack, but not annotated\n"); |
297 | else |
298 | printk(KERN_WARNING |
299 | "ODEBUG: object is not on stack, but annotated\n"); |
300 | WARN_ON(1); |
301 | } |
302 | |
303 | static void |
304 | __debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack) |
305 | { |
306 | enum debug_obj_state state; |
307 | struct debug_bucket *db; |
308 | struct debug_obj *obj; |
309 | unsigned long flags; |
310 | |
311 | fill_pool(); |
312 | |
313 | db = get_bucket((unsigned long) addr); |
314 | |
315 | raw_spin_lock_irqsave(&db->lock, flags); |
316 | |
317 | obj = lookup_object(addr, db); |
318 | if (!obj) { |
319 | obj = alloc_object(addr, db, descr); |
320 | if (!obj) { |
321 | debug_objects_enabled = 0; |
322 | raw_spin_unlock_irqrestore(&db->lock, flags); |
323 | debug_objects_oom(); |
324 | return; |
325 | } |
326 | debug_object_is_on_stack(addr, onstack); |
327 | } |
328 | |
329 | switch (obj->state) { |
330 | case ODEBUG_STATE_NONE: |
331 | case ODEBUG_STATE_INIT: |
332 | case ODEBUG_STATE_INACTIVE: |
333 | obj->state = ODEBUG_STATE_INIT; |
334 | break; |
335 | |
336 | case ODEBUG_STATE_ACTIVE: |
337 | debug_print_object(obj, "init"); |
338 | state = obj->state; |
339 | raw_spin_unlock_irqrestore(&db->lock, flags); |
340 | debug_object_fixup(descr->fixup_init, addr, state); |
341 | return; |
342 | |
343 | case ODEBUG_STATE_DESTROYED: |
344 | debug_print_object(obj, "init"); |
345 | break; |
346 | default: |
347 | break; |
348 | } |
349 | |
350 | raw_spin_unlock_irqrestore(&db->lock, flags); |
351 | } |
352 | |
353 | /** |
354 | * debug_object_init - debug checks when an object is initialized |
355 | * @addr: address of the object |
356 | * @descr: pointer to an object specific debug description structure |
357 | */ |
358 | void debug_object_init(void *addr, struct debug_obj_descr *descr) |
359 | { |
360 | if (!debug_objects_enabled) |
361 | return; |
362 | |
363 | __debug_object_init(addr, descr, 0); |
364 | } |
365 | |
366 | /** |
367 | * debug_object_init_on_stack - debug checks when an object on stack is |
368 | * initialized |
369 | * @addr: address of the object |
370 | * @descr: pointer to an object specific debug description structure |
371 | */ |
372 | void debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr) |
373 | { |
374 | if (!debug_objects_enabled) |
375 | return; |
376 | |
377 | __debug_object_init(addr, descr, 1); |
378 | } |
379 | |
380 | /** |
381 | * debug_object_activate - debug checks when an object is activated |
382 | * @addr: address of the object |
383 | * @descr: pointer to an object specific debug description structure |
384 | * Returns 0 for success, -EINVAL for check failed. |
385 | */ |
386 | int 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 | int ret; |
393 | struct debug_obj o = { .object = addr, |
394 | .state = ODEBUG_STATE_NOTAVAILABLE, |
395 | .descr = descr }; |
396 | |
397 | if (!debug_objects_enabled) |
398 | return 0; |
399 | |
400 | db = get_bucket((unsigned long) addr); |
401 | |
402 | raw_spin_lock_irqsave(&db->lock, flags); |
403 | |
404 | obj = lookup_object(addr, db); |
405 | if (obj) { |
406 | switch (obj->state) { |
407 | case ODEBUG_STATE_INIT: |
408 | case ODEBUG_STATE_INACTIVE: |
409 | obj->state = ODEBUG_STATE_ACTIVE; |
410 | ret = 0; |
411 | break; |
412 | |
413 | case ODEBUG_STATE_ACTIVE: |
414 | debug_print_object(obj, "activate"); |
415 | state = obj->state; |
416 | raw_spin_unlock_irqrestore(&db->lock, flags); |
417 | ret = debug_object_fixup(descr->fixup_activate, addr, state); |
418 | return ret ? -EINVAL : 0; |
419 | |
420 | case ODEBUG_STATE_DESTROYED: |
421 | debug_print_object(obj, "activate"); |
422 | ret = -EINVAL; |
423 | break; |
424 | default: |
425 | ret = 0; |
426 | break; |
427 | } |
428 | raw_spin_unlock_irqrestore(&db->lock, flags); |
429 | return ret; |
430 | } |
431 | |
432 | raw_spin_unlock_irqrestore(&db->lock, flags); |
433 | /* |
434 | * This happens when a static object is activated. We |
435 | * let the type specific code decide whether this is |
436 | * true or not. |
437 | */ |
438 | if (debug_object_fixup(descr->fixup_activate, addr, |
439 | ODEBUG_STATE_NOTAVAILABLE)) { |
440 | debug_print_object(&o, "activate"); |
441 | return -EINVAL; |
442 | } |
443 | return 0; |
444 | } |
445 | |
446 | /** |
447 | * debug_object_deactivate - debug checks when an object is deactivated |
448 | * @addr: address of the object |
449 | * @descr: pointer to an object specific debug description structure |
450 | */ |
451 | void debug_object_deactivate(void *addr, struct debug_obj_descr *descr) |
452 | { |
453 | struct debug_bucket *db; |
454 | struct debug_obj *obj; |
455 | unsigned long flags; |
456 | |
457 | if (!debug_objects_enabled) |
458 | return; |
459 | |
460 | db = get_bucket((unsigned long) addr); |
461 | |
462 | raw_spin_lock_irqsave(&db->lock, flags); |
463 | |
464 | obj = lookup_object(addr, db); |
465 | if (obj) { |
466 | switch (obj->state) { |
467 | case ODEBUG_STATE_INIT: |
468 | case ODEBUG_STATE_INACTIVE: |
469 | case ODEBUG_STATE_ACTIVE: |
470 | if (!obj->astate) |
471 | obj->state = ODEBUG_STATE_INACTIVE; |
472 | else |
473 | debug_print_object(obj, "deactivate"); |
474 | break; |
475 | |
476 | case ODEBUG_STATE_DESTROYED: |
477 | debug_print_object(obj, "deactivate"); |
478 | break; |
479 | default: |
480 | break; |
481 | } |
482 | } else { |
483 | struct debug_obj o = { .object = addr, |
484 | .state = ODEBUG_STATE_NOTAVAILABLE, |
485 | .descr = descr }; |
486 | |
487 | debug_print_object(&o, "deactivate"); |
488 | } |
489 | |
490 | raw_spin_unlock_irqrestore(&db->lock, flags); |
491 | } |
492 | |
493 | /** |
494 | * debug_object_destroy - debug checks when an object is destroyed |
495 | * @addr: address of the object |
496 | * @descr: pointer to an object specific debug description structure |
497 | */ |
498 | void debug_object_destroy(void *addr, struct debug_obj_descr *descr) |
499 | { |
500 | enum debug_obj_state state; |
501 | struct debug_bucket *db; |
502 | struct debug_obj *obj; |
503 | unsigned long flags; |
504 | |
505 | if (!debug_objects_enabled) |
506 | return; |
507 | |
508 | db = get_bucket((unsigned long) addr); |
509 | |
510 | raw_spin_lock_irqsave(&db->lock, flags); |
511 | |
512 | obj = lookup_object(addr, db); |
513 | if (!obj) |
514 | goto out_unlock; |
515 | |
516 | switch (obj->state) { |
517 | case ODEBUG_STATE_NONE: |
518 | case ODEBUG_STATE_INIT: |
519 | case ODEBUG_STATE_INACTIVE: |
520 | obj->state = ODEBUG_STATE_DESTROYED; |
521 | break; |
522 | case ODEBUG_STATE_ACTIVE: |
523 | debug_print_object(obj, "destroy"); |
524 | state = obj->state; |
525 | raw_spin_unlock_irqrestore(&db->lock, flags); |
526 | debug_object_fixup(descr->fixup_destroy, addr, state); |
527 | return; |
528 | |
529 | case ODEBUG_STATE_DESTROYED: |
530 | debug_print_object(obj, "destroy"); |
531 | break; |
532 | default: |
533 | break; |
534 | } |
535 | out_unlock: |
536 | raw_spin_unlock_irqrestore(&db->lock, flags); |
537 | } |
538 | |
539 | /** |
540 | * debug_object_free - debug checks when an object is freed |
541 | * @addr: address of the object |
542 | * @descr: pointer to an object specific debug description structure |
543 | */ |
544 | void debug_object_free(void *addr, struct debug_obj_descr *descr) |
545 | { |
546 | enum debug_obj_state state; |
547 | struct debug_bucket *db; |
548 | struct debug_obj *obj; |
549 | unsigned long flags; |
550 | |
551 | if (!debug_objects_enabled) |
552 | return; |
553 | |
554 | db = get_bucket((unsigned long) addr); |
555 | |
556 | raw_spin_lock_irqsave(&db->lock, flags); |
557 | |
558 | obj = lookup_object(addr, db); |
559 | if (!obj) |
560 | goto out_unlock; |
561 | |
562 | switch (obj->state) { |
563 | case ODEBUG_STATE_ACTIVE: |
564 | debug_print_object(obj, "free"); |
565 | state = obj->state; |
566 | raw_spin_unlock_irqrestore(&db->lock, flags); |
567 | debug_object_fixup(descr->fixup_free, addr, state); |
568 | return; |
569 | default: |
570 | hlist_del(&obj->node); |
571 | raw_spin_unlock_irqrestore(&db->lock, flags); |
572 | free_object(obj); |
573 | return; |
574 | } |
575 | out_unlock: |
576 | raw_spin_unlock_irqrestore(&db->lock, flags); |
577 | } |
578 | |
579 | /** |
580 | * debug_object_assert_init - debug checks when object should be init-ed |
581 | * @addr: address of the object |
582 | * @descr: pointer to an object specific debug description structure |
583 | */ |
584 | void debug_object_assert_init(void *addr, struct debug_obj_descr *descr) |
585 | { |
586 | struct debug_bucket *db; |
587 | struct debug_obj *obj; |
588 | unsigned long flags; |
589 | |
590 | if (!debug_objects_enabled) |
591 | return; |
592 | |
593 | db = get_bucket((unsigned long) addr); |
594 | |
595 | raw_spin_lock_irqsave(&db->lock, flags); |
596 | |
597 | obj = lookup_object(addr, db); |
598 | if (!obj) { |
599 | struct debug_obj o = { .object = addr, |
600 | .state = ODEBUG_STATE_NOTAVAILABLE, |
601 | .descr = descr }; |
602 | |
603 | raw_spin_unlock_irqrestore(&db->lock, flags); |
604 | /* |
605 | * Maybe the object is static. Let the type specific |
606 | * code decide what to do. |
607 | */ |
608 | if (debug_object_fixup(descr->fixup_assert_init, addr, |
609 | ODEBUG_STATE_NOTAVAILABLE)) |
610 | debug_print_object(&o, "assert_init"); |
611 | return; |
612 | } |
613 | |
614 | raw_spin_unlock_irqrestore(&db->lock, flags); |
615 | } |
616 | |
617 | /** |
618 | * debug_object_active_state - debug checks object usage state machine |
619 | * @addr: address of the object |
620 | * @descr: pointer to an object specific debug description structure |
621 | * @expect: expected state |
622 | * @next: state to move to if expected state is found |
623 | */ |
624 | void |
625 | debug_object_active_state(void *addr, struct debug_obj_descr *descr, |
626 | unsigned int expect, unsigned int next) |
627 | { |
628 | struct debug_bucket *db; |
629 | struct debug_obj *obj; |
630 | unsigned long flags; |
631 | |
632 | if (!debug_objects_enabled) |
633 | return; |
634 | |
635 | db = get_bucket((unsigned long) addr); |
636 | |
637 | raw_spin_lock_irqsave(&db->lock, flags); |
638 | |
639 | obj = lookup_object(addr, db); |
640 | if (obj) { |
641 | switch (obj->state) { |
642 | case ODEBUG_STATE_ACTIVE: |
643 | if (obj->astate == expect) |
644 | obj->astate = next; |
645 | else |
646 | debug_print_object(obj, "active_state"); |
647 | break; |
648 | |
649 | default: |
650 | debug_print_object(obj, "active_state"); |
651 | break; |
652 | } |
653 | } else { |
654 | struct debug_obj o = { .object = addr, |
655 | .state = ODEBUG_STATE_NOTAVAILABLE, |
656 | .descr = descr }; |
657 | |
658 | debug_print_object(&o, "active_state"); |
659 | } |
660 | |
661 | raw_spin_unlock_irqrestore(&db->lock, flags); |
662 | } |
663 | |
664 | #ifdef CONFIG_DEBUG_OBJECTS_FREE |
665 | static void __debug_check_no_obj_freed(const void *address, unsigned long size) |
666 | { |
667 | unsigned long flags, oaddr, saddr, eaddr, paddr, chunks; |
668 | struct hlist_node *tmp; |
669 | HLIST_HEAD(freelist); |
670 | struct debug_obj_descr *descr; |
671 | enum debug_obj_state state; |
672 | struct debug_bucket *db; |
673 | struct debug_obj *obj; |
674 | int cnt; |
675 | |
676 | saddr = (unsigned long) address; |
677 | eaddr = saddr + size; |
678 | paddr = saddr & ODEBUG_CHUNK_MASK; |
679 | chunks = ((eaddr - paddr) + (ODEBUG_CHUNK_SIZE - 1)); |
680 | chunks >>= ODEBUG_CHUNK_SHIFT; |
681 | |
682 | for (;chunks > 0; chunks--, paddr += ODEBUG_CHUNK_SIZE) { |
683 | db = get_bucket(paddr); |
684 | |
685 | repeat: |
686 | cnt = 0; |
687 | raw_spin_lock_irqsave(&db->lock, flags); |
688 | hlist_for_each_entry_safe(obj, tmp, &db->list, node) { |
689 | cnt++; |
690 | oaddr = (unsigned long) obj->object; |
691 | if (oaddr < saddr || oaddr >= eaddr) |
692 | continue; |
693 | |
694 | switch (obj->state) { |
695 | case ODEBUG_STATE_ACTIVE: |
696 | debug_print_object(obj, "free"); |
697 | descr = obj->descr; |
698 | state = obj->state; |
699 | raw_spin_unlock_irqrestore(&db->lock, flags); |
700 | debug_object_fixup(descr->fixup_free, |
701 | (void *) oaddr, state); |
702 | goto repeat; |
703 | default: |
704 | hlist_del(&obj->node); |
705 | hlist_add_head(&obj->node, &freelist); |
706 | break; |
707 | } |
708 | } |
709 | raw_spin_unlock_irqrestore(&db->lock, flags); |
710 | |
711 | /* Now free them */ |
712 | hlist_for_each_entry_safe(obj, tmp, &freelist, node) { |
713 | hlist_del(&obj->node); |
714 | free_object(obj); |
715 | } |
716 | |
717 | if (cnt > debug_objects_maxchain) |
718 | debug_objects_maxchain = cnt; |
719 | } |
720 | } |
721 | |
722 | void debug_check_no_obj_freed(const void *address, unsigned long size) |
723 | { |
724 | if (debug_objects_enabled) |
725 | __debug_check_no_obj_freed(address, size); |
726 | } |
727 | #endif |
728 | |
729 | #ifdef CONFIG_DEBUG_FS |
730 | |
731 | static int debug_stats_show(struct seq_file *m, void *v) |
732 | { |
733 | seq_printf(m, "max_chain :%d\n", debug_objects_maxchain); |
734 | seq_printf(m, "warnings :%d\n", debug_objects_warnings); |
735 | seq_printf(m, "fixups :%d\n", debug_objects_fixups); |
736 | seq_printf(m, "pool_free :%d\n", obj_pool_free); |
737 | seq_printf(m, "pool_min_free :%d\n", obj_pool_min_free); |
738 | seq_printf(m, "pool_used :%d\n", obj_pool_used); |
739 | seq_printf(m, "pool_max_used :%d\n", obj_pool_max_used); |
740 | return 0; |
741 | } |
742 | |
743 | static int debug_stats_open(struct inode *inode, struct file *filp) |
744 | { |
745 | return single_open(filp, debug_stats_show, NULL); |
746 | } |
747 | |
748 | static const struct file_operations debug_stats_fops = { |
749 | .open = debug_stats_open, |
750 | .read = seq_read, |
751 | .llseek = seq_lseek, |
752 | .release = single_release, |
753 | }; |
754 | |
755 | static int __init debug_objects_init_debugfs(void) |
756 | { |
757 | struct dentry *dbgdir, *dbgstats; |
758 | |
759 | if (!debug_objects_enabled) |
760 | return 0; |
761 | |
762 | dbgdir = debugfs_create_dir("debug_objects", NULL); |
763 | if (!dbgdir) |
764 | return -ENOMEM; |
765 | |
766 | dbgstats = debugfs_create_file("stats", 0444, dbgdir, NULL, |
767 | &debug_stats_fops); |
768 | if (!dbgstats) |
769 | goto err; |
770 | |
771 | return 0; |
772 | |
773 | err: |
774 | debugfs_remove(dbgdir); |
775 | |
776 | return -ENOMEM; |
777 | } |
778 | __initcall(debug_objects_init_debugfs); |
779 | |
780 | #else |
781 | static inline void debug_objects_init_debugfs(void) { } |
782 | #endif |
783 | |
784 | #ifdef CONFIG_DEBUG_OBJECTS_SELFTEST |
785 | |
786 | /* Random data structure for the self test */ |
787 | struct self_test { |
788 | unsigned long dummy1[6]; |
789 | int static_init; |
790 | unsigned long dummy2[3]; |
791 | }; |
792 | |
793 | static __initdata struct debug_obj_descr descr_type_test; |
794 | |
795 | /* |
796 | * fixup_init is called when: |
797 | * - an active object is initialized |
798 | */ |
799 | static int __init fixup_init(void *addr, enum debug_obj_state state) |
800 | { |
801 | struct self_test *obj = addr; |
802 | |
803 | switch (state) { |
804 | case ODEBUG_STATE_ACTIVE: |
805 | debug_object_deactivate(obj, &descr_type_test); |
806 | debug_object_init(obj, &descr_type_test); |
807 | return 1; |
808 | default: |
809 | return 0; |
810 | } |
811 | } |
812 | |
813 | /* |
814 | * fixup_activate is called when: |
815 | * - an active object is activated |
816 | * - an unknown object is activated (might be a statically initialized object) |
817 | */ |
818 | static int __init fixup_activate(void *addr, enum debug_obj_state state) |
819 | { |
820 | struct self_test *obj = addr; |
821 | |
822 | switch (state) { |
823 | case ODEBUG_STATE_NOTAVAILABLE: |
824 | if (obj->static_init == 1) { |
825 | debug_object_init(obj, &descr_type_test); |
826 | debug_object_activate(obj, &descr_type_test); |
827 | return 0; |
828 | } |
829 | return 1; |
830 | |
831 | case ODEBUG_STATE_ACTIVE: |
832 | debug_object_deactivate(obj, &descr_type_test); |
833 | debug_object_activate(obj, &descr_type_test); |
834 | return 1; |
835 | |
836 | default: |
837 | return 0; |
838 | } |
839 | } |
840 | |
841 | /* |
842 | * fixup_destroy is called when: |
843 | * - an active object is destroyed |
844 | */ |
845 | static int __init fixup_destroy(void *addr, enum debug_obj_state state) |
846 | { |
847 | struct self_test *obj = addr; |
848 | |
849 | switch (state) { |
850 | case ODEBUG_STATE_ACTIVE: |
851 | debug_object_deactivate(obj, &descr_type_test); |
852 | debug_object_destroy(obj, &descr_type_test); |
853 | return 1; |
854 | default: |
855 | return 0; |
856 | } |
857 | } |
858 | |
859 | /* |
860 | * fixup_free is called when: |
861 | * - an active object is freed |
862 | */ |
863 | static int __init fixup_free(void *addr, enum debug_obj_state state) |
864 | { |
865 | struct self_test *obj = addr; |
866 | |
867 | switch (state) { |
868 | case ODEBUG_STATE_ACTIVE: |
869 | debug_object_deactivate(obj, &descr_type_test); |
870 | debug_object_free(obj, &descr_type_test); |
871 | return 1; |
872 | default: |
873 | return 0; |
874 | } |
875 | } |
876 | |
877 | static int __init |
878 | check_results(void *addr, enum debug_obj_state state, int fixups, int warnings) |
879 | { |
880 | struct debug_bucket *db; |
881 | struct debug_obj *obj; |
882 | unsigned long flags; |
883 | int res = -EINVAL; |
884 | |
885 | db = get_bucket((unsigned long) addr); |
886 | |
887 | raw_spin_lock_irqsave(&db->lock, flags); |
888 | |
889 | obj = lookup_object(addr, db); |
890 | if (!obj && state != ODEBUG_STATE_NONE) { |
891 | WARN(1, KERN_ERR "ODEBUG: selftest object not found\n"); |
892 | goto out; |
893 | } |
894 | if (obj && obj->state != state) { |
895 | WARN(1, KERN_ERR "ODEBUG: selftest wrong state: %d != %d\n", |
896 | obj->state, state); |
897 | goto out; |
898 | } |
899 | if (fixups != debug_objects_fixups) { |
900 | WARN(1, KERN_ERR "ODEBUG: selftest fixups failed %d != %d\n", |
901 | fixups, debug_objects_fixups); |
902 | goto out; |
903 | } |
904 | if (warnings != debug_objects_warnings) { |
905 | WARN(1, KERN_ERR "ODEBUG: selftest warnings failed %d != %d\n", |
906 | warnings, debug_objects_warnings); |
907 | goto out; |
908 | } |
909 | res = 0; |
910 | out: |
911 | raw_spin_unlock_irqrestore(&db->lock, flags); |
912 | if (res) |
913 | debug_objects_enabled = 0; |
914 | return res; |
915 | } |
916 | |
917 | static __initdata struct debug_obj_descr descr_type_test = { |
918 | .name = "selftest", |
919 | .fixup_init = fixup_init, |
920 | .fixup_activate = fixup_activate, |
921 | .fixup_destroy = fixup_destroy, |
922 | .fixup_free = fixup_free, |
923 | }; |
924 | |
925 | static __initdata struct self_test obj = { .static_init = 0 }; |
926 | |
927 | static void __init debug_objects_selftest(void) |
928 | { |
929 | int fixups, oldfixups, warnings, oldwarnings; |
930 | unsigned long flags; |
931 | |
932 | local_irq_save(flags); |
933 | |
934 | fixups = oldfixups = debug_objects_fixups; |
935 | warnings = oldwarnings = debug_objects_warnings; |
936 | descr_test = &descr_type_test; |
937 | |
938 | debug_object_init(&obj, &descr_type_test); |
939 | if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings)) |
940 | goto out; |
941 | debug_object_activate(&obj, &descr_type_test); |
942 | if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings)) |
943 | goto out; |
944 | debug_object_activate(&obj, &descr_type_test); |
945 | if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, ++warnings)) |
946 | goto out; |
947 | debug_object_deactivate(&obj, &descr_type_test); |
948 | if (check_results(&obj, ODEBUG_STATE_INACTIVE, fixups, warnings)) |
949 | goto out; |
950 | debug_object_destroy(&obj, &descr_type_test); |
951 | if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, warnings)) |
952 | goto out; |
953 | debug_object_init(&obj, &descr_type_test); |
954 | if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings)) |
955 | goto out; |
956 | debug_object_activate(&obj, &descr_type_test); |
957 | if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings)) |
958 | goto out; |
959 | debug_object_deactivate(&obj, &descr_type_test); |
960 | if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings)) |
961 | goto out; |
962 | debug_object_free(&obj, &descr_type_test); |
963 | if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings)) |
964 | goto out; |
965 | |
966 | obj.static_init = 1; |
967 | debug_object_activate(&obj, &descr_type_test); |
968 | if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings)) |
969 | goto out; |
970 | debug_object_init(&obj, &descr_type_test); |
971 | if (check_results(&obj, ODEBUG_STATE_INIT, ++fixups, ++warnings)) |
972 | goto out; |
973 | debug_object_free(&obj, &descr_type_test); |
974 | if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings)) |
975 | goto out; |
976 | |
977 | #ifdef CONFIG_DEBUG_OBJECTS_FREE |
978 | debug_object_init(&obj, &descr_type_test); |
979 | if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings)) |
980 | goto out; |
981 | debug_object_activate(&obj, &descr_type_test); |
982 | if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings)) |
983 | goto out; |
984 | __debug_check_no_obj_freed(&obj, sizeof(obj)); |
985 | if (check_results(&obj, ODEBUG_STATE_NONE, ++fixups, ++warnings)) |
986 | goto out; |
987 | #endif |
988 | printk(KERN_INFO "ODEBUG: selftest passed\n"); |
989 | |
990 | out: |
991 | debug_objects_fixups = oldfixups; |
992 | debug_objects_warnings = oldwarnings; |
993 | descr_test = NULL; |
994 | |
995 | local_irq_restore(flags); |
996 | } |
997 | #else |
998 | static inline void debug_objects_selftest(void) { } |
999 | #endif |
1000 | |
1001 | /* |
1002 | * Called during early boot to initialize the hash buckets and link |
1003 | * the static object pool objects into the poll list. After this call |
1004 | * the object tracker is fully operational. |
1005 | */ |
1006 | void __init debug_objects_early_init(void) |
1007 | { |
1008 | int i; |
1009 | |
1010 | for (i = 0; i < ODEBUG_HASH_SIZE; i++) |
1011 | raw_spin_lock_init(&obj_hash[i].lock); |
1012 | |
1013 | for (i = 0; i < ODEBUG_POOL_SIZE; i++) |
1014 | hlist_add_head(&obj_static_pool[i].node, &obj_pool); |
1015 | } |
1016 | |
1017 | /* |
1018 | * Convert the statically allocated objects to dynamic ones: |
1019 | */ |
1020 | static int __init debug_objects_replace_static_objects(void) |
1021 | { |
1022 | struct debug_bucket *db = obj_hash; |
1023 | struct hlist_node *tmp; |
1024 | struct debug_obj *obj, *new; |
1025 | HLIST_HEAD(objects); |
1026 | int i, cnt = 0; |
1027 | |
1028 | for (i = 0; i < ODEBUG_POOL_SIZE; i++) { |
1029 | obj = kmem_cache_zalloc(obj_cache, GFP_KERNEL); |
1030 | if (!obj) |
1031 | goto free; |
1032 | hlist_add_head(&obj->node, &objects); |
1033 | } |
1034 | |
1035 | /* |
1036 | * When debug_objects_mem_init() is called we know that only |
1037 | * one CPU is up, so disabling interrupts is enough |
1038 | * protection. This avoids the lockdep hell of lock ordering. |
1039 | */ |
1040 | local_irq_disable(); |
1041 | |
1042 | /* Remove the statically allocated objects from the pool */ |
1043 | hlist_for_each_entry_safe(obj, tmp, &obj_pool, node) |
1044 | hlist_del(&obj->node); |
1045 | /* Move the allocated objects to the pool */ |
1046 | hlist_move_list(&objects, &obj_pool); |
1047 | |
1048 | /* Replace the active object references */ |
1049 | for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) { |
1050 | hlist_move_list(&db->list, &objects); |
1051 | |
1052 | hlist_for_each_entry(obj, &objects, node) { |
1053 | new = hlist_entry(obj_pool.first, typeof(*obj), node); |
1054 | hlist_del(&new->node); |
1055 | /* copy object data */ |
1056 | *new = *obj; |
1057 | hlist_add_head(&new->node, &db->list); |
1058 | cnt++; |
1059 | } |
1060 | } |
1061 | local_irq_enable(); |
1062 | |
1063 | printk(KERN_DEBUG "ODEBUG: %d of %d active objects replaced\n", cnt, |
1064 | obj_pool_used); |
1065 | return 0; |
1066 | free: |
1067 | hlist_for_each_entry_safe(obj, tmp, &objects, node) { |
1068 | hlist_del(&obj->node); |
1069 | kmem_cache_free(obj_cache, obj); |
1070 | } |
1071 | return -ENOMEM; |
1072 | } |
1073 | |
1074 | /* |
1075 | * Called after the kmem_caches are functional to setup a dedicated |
1076 | * cache pool, which has the SLAB_DEBUG_OBJECTS flag set. This flag |
1077 | * prevents that the debug code is called on kmem_cache_free() for the |
1078 | * debug tracker objects to avoid recursive calls. |
1079 | */ |
1080 | void __init debug_objects_mem_init(void) |
1081 | { |
1082 | if (!debug_objects_enabled) |
1083 | return; |
1084 | |
1085 | obj_cache = kmem_cache_create("debug_objects_cache", |
1086 | sizeof (struct debug_obj), 0, |
1087 | SLAB_DEBUG_OBJECTS, NULL); |
1088 | |
1089 | if (!obj_cache || debug_objects_replace_static_objects()) { |
1090 | debug_objects_enabled = 0; |
1091 | if (obj_cache) |
1092 | kmem_cache_destroy(obj_cache); |
1093 | printk(KERN_WARNING "ODEBUG: out of memory.\n"); |
1094 | } else |
1095 | debug_objects_selftest(); |
1096 | } |
1097 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9