Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/lib/debugobjects.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us