Root/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#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/hash.h>
16
17#define ODEBUG_HASH_BITS 14
18#define ODEBUG_HASH_SIZE (1 << ODEBUG_HASH_BITS)
19
20#define ODEBUG_POOL_SIZE 512
21#define ODEBUG_POOL_MIN_LEVEL 256
22
23#define ODEBUG_CHUNK_SHIFT PAGE_SHIFT
24#define ODEBUG_CHUNK_SIZE (1 << ODEBUG_CHUNK_SHIFT)
25#define ODEBUG_CHUNK_MASK (~(ODEBUG_CHUNK_SIZE - 1))
26
27struct debug_bucket {
28    struct hlist_head list;
29    spinlock_t lock;
30};
31
32static struct debug_bucket obj_hash[ODEBUG_HASH_SIZE];
33
34static struct debug_obj obj_static_pool[ODEBUG_POOL_SIZE] __initdata;
35
36static DEFINE_SPINLOCK(pool_lock);
37
38static HLIST_HEAD(obj_pool);
39
40static int obj_pool_min_free = ODEBUG_POOL_SIZE;
41static int obj_pool_free = ODEBUG_POOL_SIZE;
42static int obj_pool_used;
43static int obj_pool_max_used;
44static struct kmem_cache *obj_cache;
45
46static int debug_objects_maxchain __read_mostly;
47static int debug_objects_fixups __read_mostly;
48static int debug_objects_warnings __read_mostly;
49static int debug_objects_enabled __read_mostly
50                = CONFIG_DEBUG_OBJECTS_ENABLE_DEFAULT;
51
52static struct debug_obj_descr *descr_test __read_mostly;
53
54static void free_obj_work(struct work_struct *work);
55static DECLARE_WORK(debug_obj_work, free_obj_work);
56
57static int __init enable_object_debug(char *str)
58{
59    debug_objects_enabled = 1;
60    return 0;
61}
62
63static int __init disable_object_debug(char *str)
64{
65    debug_objects_enabled = 0;
66    return 0;
67}
68
69early_param("debug_objects", enable_object_debug);
70early_param("no_debug_objects", disable_object_debug);
71
72static const char *obj_states[ODEBUG_STATE_MAX] = {
73    [ODEBUG_STATE_NONE] = "none",
74    [ODEBUG_STATE_INIT] = "initialized",
75    [ODEBUG_STATE_INACTIVE] = "inactive",
76    [ODEBUG_STATE_ACTIVE] = "active",
77    [ODEBUG_STATE_DESTROYED] = "destroyed",
78    [ODEBUG_STATE_NOTAVAILABLE] = "not available",
79};
80
81static int fill_pool(void)
82{
83    gfp_t gfp = GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN;
84    struct debug_obj *new;
85    unsigned long flags;
86
87    if (likely(obj_pool_free >= ODEBUG_POOL_MIN_LEVEL))
88        return obj_pool_free;
89
90    if (unlikely(!obj_cache))
91        return obj_pool_free;
92
93    while (obj_pool_free < ODEBUG_POOL_MIN_LEVEL) {
94
95        new = kmem_cache_zalloc(obj_cache, gfp);
96        if (!new)
97            return obj_pool_free;
98
99        spin_lock_irqsave(&pool_lock, flags);
100        hlist_add_head(&new->node, &obj_pool);
101        obj_pool_free++;
102        spin_unlock_irqrestore(&pool_lock, flags);
103    }
104    return obj_pool_free;
105}
106
107/*
108 * Lookup an object in the hash bucket.
109 */
110static 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 */
131static struct debug_obj *
132alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
133{
134    struct debug_obj *obj = NULL;
135
136    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        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    spin_unlock(&pool_lock);
156
157    return obj;
158}
159
160/*
161 * workqueue function to free objects.
162 */
163static void free_obj_work(struct work_struct *work)
164{
165    struct debug_obj *obj;
166    unsigned long flags;
167
168    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        spin_unlock_irqrestore(&pool_lock, flags);
178        kmem_cache_free(obj_cache, obj);
179        spin_lock_irqsave(&pool_lock, flags);
180    }
181    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 */
188static void free_object(struct debug_obj *obj)
189{
190    unsigned long flags;
191    int sched = 0;
192
193    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 = !work_pending(&debug_obj_work);
200    hlist_add_head(&obj->node, &obj_pool);
201    obj_pool_free++;
202    obj_pool_used--;
203    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 */
212static void debug_objects_oom(void)
213{
214    struct debug_bucket *db = obj_hash;
215    struct hlist_node *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        spin_lock_irqsave(&db->lock, flags);
225        hlist_move_list(&db->list, &freelist);
226        spin_unlock_irqrestore(&db->lock, flags);
227
228        /* Now free them */
229        hlist_for_each_entry_safe(obj, node, 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 */
240static 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
248static void debug_print_object(struct debug_obj *obj, char *msg)
249{
250    static int limit;
251
252    if (limit < 5 && obj->descr != descr_test) {
253        limit++;
254        WARN(1, KERN_ERR "ODEBUG: %s %s object type: %s\n", msg,
255               obj_states[obj->state], obj->descr->name);
256    }
257    debug_objects_warnings++;
258}
259
260/*
261 * Try to repair the damage, so we have a better chance to get useful
262 * debug output.
263 */
264static void
265debug_object_fixup(int (*fixup)(void *addr, enum debug_obj_state state),
266           void * addr, enum debug_obj_state state)
267{
268    if (fixup)
269        debug_objects_fixups += fixup(addr, state);
270}
271
272static void debug_object_is_on_stack(void *addr, int onstack)
273{
274    int is_on_stack;
275    static int limit;
276
277    if (limit > 4)
278        return;
279
280    is_on_stack = object_is_on_stack(addr);
281    if (is_on_stack == onstack)
282        return;
283
284    limit++;
285    if (is_on_stack)
286        printk(KERN_WARNING
287               "ODEBUG: object is on stack, but not annotated\n");
288    else
289        printk(KERN_WARNING
290               "ODEBUG: object is not on stack, but annotated\n");
291    WARN_ON(1);
292}
293
294static void
295__debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
296{
297    enum debug_obj_state state;
298    struct debug_bucket *db;
299    struct debug_obj *obj;
300    unsigned long flags;
301
302    fill_pool();
303
304    db = get_bucket((unsigned long) addr);
305
306    spin_lock_irqsave(&db->lock, flags);
307
308    obj = lookup_object(addr, db);
309    if (!obj) {
310        obj = alloc_object(addr, db, descr);
311        if (!obj) {
312            debug_objects_enabled = 0;
313            spin_unlock_irqrestore(&db->lock, flags);
314            debug_objects_oom();
315            return;
316        }
317        debug_object_is_on_stack(addr, onstack);
318    }
319
320    switch (obj->state) {
321    case ODEBUG_STATE_NONE:
322    case ODEBUG_STATE_INIT:
323    case ODEBUG_STATE_INACTIVE:
324        obj->state = ODEBUG_STATE_INIT;
325        break;
326
327    case ODEBUG_STATE_ACTIVE:
328        debug_print_object(obj, "init");
329        state = obj->state;
330        spin_unlock_irqrestore(&db->lock, flags);
331        debug_object_fixup(descr->fixup_init, addr, state);
332        return;
333
334    case ODEBUG_STATE_DESTROYED:
335        debug_print_object(obj, "init");
336        break;
337    default:
338        break;
339    }
340
341    spin_unlock_irqrestore(&db->lock, flags);
342}
343
344/**
345 * debug_object_init - debug checks when an object is initialized
346 * @addr: address of the object
347 * @descr: pointer to an object specific debug description structure
348 */
349void debug_object_init(void *addr, struct debug_obj_descr *descr)
350{
351    if (!debug_objects_enabled)
352        return;
353
354    __debug_object_init(addr, descr, 0);
355}
356
357/**
358 * debug_object_init_on_stack - debug checks when an object on stack is
359 * initialized
360 * @addr: address of the object
361 * @descr: pointer to an object specific debug description structure
362 */
363void debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr)
364{
365    if (!debug_objects_enabled)
366        return;
367
368    __debug_object_init(addr, descr, 1);
369}
370
371/**
372 * debug_object_activate - debug checks when an object is activated
373 * @addr: address of the object
374 * @descr: pointer to an object specific debug description structure
375 */
376void debug_object_activate(void *addr, struct debug_obj_descr *descr)
377{
378    enum debug_obj_state state;
379    struct debug_bucket *db;
380    struct debug_obj *obj;
381    unsigned long flags;
382
383    if (!debug_objects_enabled)
384        return;
385
386    db = get_bucket((unsigned long) addr);
387
388    spin_lock_irqsave(&db->lock, flags);
389
390    obj = lookup_object(addr, db);
391    if (obj) {
392        switch (obj->state) {
393        case ODEBUG_STATE_INIT:
394        case ODEBUG_STATE_INACTIVE:
395            obj->state = ODEBUG_STATE_ACTIVE;
396            break;
397
398        case ODEBUG_STATE_ACTIVE:
399            debug_print_object(obj, "activate");
400            state = obj->state;
401            spin_unlock_irqrestore(&db->lock, flags);
402            debug_object_fixup(descr->fixup_activate, addr, state);
403            return;
404
405        case ODEBUG_STATE_DESTROYED:
406            debug_print_object(obj, "activate");
407            break;
408        default:
409            break;
410        }
411        spin_unlock_irqrestore(&db->lock, flags);
412        return;
413    }
414
415    spin_unlock_irqrestore(&db->lock, flags);
416    /*
417     * This happens when a static object is activated. We
418     * let the type specific code decide whether this is
419     * true or not.
420     */
421    debug_object_fixup(descr->fixup_activate, addr,
422               ODEBUG_STATE_NOTAVAILABLE);
423}
424
425/**
426 * debug_object_deactivate - debug checks when an object is deactivated
427 * @addr: address of the object
428 * @descr: pointer to an object specific debug description structure
429 */
430void debug_object_deactivate(void *addr, struct debug_obj_descr *descr)
431{
432    struct debug_bucket *db;
433    struct debug_obj *obj;
434    unsigned long flags;
435
436    if (!debug_objects_enabled)
437        return;
438
439    db = get_bucket((unsigned long) addr);
440
441    spin_lock_irqsave(&db->lock, flags);
442
443    obj = lookup_object(addr, db);
444    if (obj) {
445        switch (obj->state) {
446        case ODEBUG_STATE_INIT:
447        case ODEBUG_STATE_INACTIVE:
448        case ODEBUG_STATE_ACTIVE:
449            obj->state = ODEBUG_STATE_INACTIVE;
450            break;
451
452        case ODEBUG_STATE_DESTROYED:
453            debug_print_object(obj, "deactivate");
454            break;
455        default:
456            break;
457        }
458    } else {
459        struct debug_obj o = { .object = addr,
460                       .state = ODEBUG_STATE_NOTAVAILABLE,
461                       .descr = descr };
462
463        debug_print_object(&o, "deactivate");
464    }
465
466    spin_unlock_irqrestore(&db->lock, flags);
467}
468
469/**
470 * debug_object_destroy - debug checks when an object is destroyed
471 * @addr: address of the object
472 * @descr: pointer to an object specific debug description structure
473 */
474void debug_object_destroy(void *addr, struct debug_obj_descr *descr)
475{
476    enum debug_obj_state state;
477    struct debug_bucket *db;
478    struct debug_obj *obj;
479    unsigned long flags;
480
481    if (!debug_objects_enabled)
482        return;
483
484    db = get_bucket((unsigned long) addr);
485
486    spin_lock_irqsave(&db->lock, flags);
487
488    obj = lookup_object(addr, db);
489    if (!obj)
490        goto out_unlock;
491
492    switch (obj->state) {
493    case ODEBUG_STATE_NONE:
494    case ODEBUG_STATE_INIT:
495    case ODEBUG_STATE_INACTIVE:
496        obj->state = ODEBUG_STATE_DESTROYED;
497        break;
498    case ODEBUG_STATE_ACTIVE:
499        debug_print_object(obj, "destroy");
500        state = obj->state;
501        spin_unlock_irqrestore(&db->lock, flags);
502        debug_object_fixup(descr->fixup_destroy, addr, state);
503        return;
504
505    case ODEBUG_STATE_DESTROYED:
506        debug_print_object(obj, "destroy");
507        break;
508    default:
509        break;
510    }
511out_unlock:
512    spin_unlock_irqrestore(&db->lock, flags);
513}
514
515/**
516 * debug_object_free - debug checks when an object is freed
517 * @addr: address of the object
518 * @descr: pointer to an object specific debug description structure
519 */
520void debug_object_free(void *addr, struct debug_obj_descr *descr)
521{
522    enum debug_obj_state state;
523    struct debug_bucket *db;
524    struct debug_obj *obj;
525    unsigned long flags;
526
527    if (!debug_objects_enabled)
528        return;
529
530    db = get_bucket((unsigned long) addr);
531
532    spin_lock_irqsave(&db->lock, flags);
533
534    obj = lookup_object(addr, db);
535    if (!obj)
536        goto out_unlock;
537
538    switch (obj->state) {
539    case ODEBUG_STATE_ACTIVE:
540        debug_print_object(obj, "free");
541        state = obj->state;
542        spin_unlock_irqrestore(&db->lock, flags);
543        debug_object_fixup(descr->fixup_free, addr, state);
544        return;
545    default:
546        hlist_del(&obj->node);
547        spin_unlock_irqrestore(&db->lock, flags);
548        free_object(obj);
549        return;
550    }
551out_unlock:
552    spin_unlock_irqrestore(&db->lock, flags);
553}
554
555#ifdef CONFIG_DEBUG_OBJECTS_FREE
556static void __debug_check_no_obj_freed(const void *address, unsigned long size)
557{
558    unsigned long flags, oaddr, saddr, eaddr, paddr, chunks;
559    struct hlist_node *node, *tmp;
560    HLIST_HEAD(freelist);
561    struct debug_obj_descr *descr;
562    enum debug_obj_state state;
563    struct debug_bucket *db;
564    struct debug_obj *obj;
565    int cnt;
566
567    saddr = (unsigned long) address;
568    eaddr = saddr + size;
569    paddr = saddr & ODEBUG_CHUNK_MASK;
570    chunks = ((eaddr - paddr) + (ODEBUG_CHUNK_SIZE - 1));
571    chunks >>= ODEBUG_CHUNK_SHIFT;
572
573    for (;chunks > 0; chunks--, paddr += ODEBUG_CHUNK_SIZE) {
574        db = get_bucket(paddr);
575
576repeat:
577        cnt = 0;
578        spin_lock_irqsave(&db->lock, flags);
579        hlist_for_each_entry_safe(obj, node, tmp, &db->list, node) {
580            cnt++;
581            oaddr = (unsigned long) obj->object;
582            if (oaddr < saddr || oaddr >= eaddr)
583                continue;
584
585            switch (obj->state) {
586            case ODEBUG_STATE_ACTIVE:
587                debug_print_object(obj, "free");
588                descr = obj->descr;
589                state = obj->state;
590                spin_unlock_irqrestore(&db->lock, flags);
591                debug_object_fixup(descr->fixup_free,
592                           (void *) oaddr, state);
593                goto repeat;
594            default:
595                hlist_del(&obj->node);
596                hlist_add_head(&obj->node, &freelist);
597                break;
598            }
599        }
600        spin_unlock_irqrestore(&db->lock, flags);
601
602        /* Now free them */
603        hlist_for_each_entry_safe(obj, node, tmp, &freelist, node) {
604            hlist_del(&obj->node);
605            free_object(obj);
606        }
607
608        if (cnt > debug_objects_maxchain)
609            debug_objects_maxchain = cnt;
610    }
611}
612
613void debug_check_no_obj_freed(const void *address, unsigned long size)
614{
615    if (debug_objects_enabled)
616        __debug_check_no_obj_freed(address, size);
617}
618#endif
619
620#ifdef CONFIG_DEBUG_FS
621
622static int debug_stats_show(struct seq_file *m, void *v)
623{
624    seq_printf(m, "max_chain :%d\n", debug_objects_maxchain);
625    seq_printf(m, "warnings :%d\n", debug_objects_warnings);
626    seq_printf(m, "fixups :%d\n", debug_objects_fixups);
627    seq_printf(m, "pool_free :%d\n", obj_pool_free);
628    seq_printf(m, "pool_min_free :%d\n", obj_pool_min_free);
629    seq_printf(m, "pool_used :%d\n", obj_pool_used);
630    seq_printf(m, "pool_max_used :%d\n", obj_pool_max_used);
631    return 0;
632}
633
634static int debug_stats_open(struct inode *inode, struct file *filp)
635{
636    return single_open(filp, debug_stats_show, NULL);
637}
638
639static const struct file_operations debug_stats_fops = {
640    .open = debug_stats_open,
641    .read = seq_read,
642    .llseek = seq_lseek,
643    .release = single_release,
644};
645
646static int __init debug_objects_init_debugfs(void)
647{
648    struct dentry *dbgdir, *dbgstats;
649
650    if (!debug_objects_enabled)
651        return 0;
652
653    dbgdir = debugfs_create_dir("debug_objects", NULL);
654    if (!dbgdir)
655        return -ENOMEM;
656
657    dbgstats = debugfs_create_file("stats", 0444, dbgdir, NULL,
658                       &debug_stats_fops);
659    if (!dbgstats)
660        goto err;
661
662    return 0;
663
664err:
665    debugfs_remove(dbgdir);
666
667    return -ENOMEM;
668}
669__initcall(debug_objects_init_debugfs);
670
671#else
672static inline void debug_objects_init_debugfs(void) { }
673#endif
674
675#ifdef CONFIG_DEBUG_OBJECTS_SELFTEST
676
677/* Random data structure for the self test */
678struct self_test {
679    unsigned long dummy1[6];
680    int static_init;
681    unsigned long dummy2[3];
682};
683
684static __initdata struct debug_obj_descr descr_type_test;
685
686/*
687 * fixup_init is called when:
688 * - an active object is initialized
689 */
690static int __init fixup_init(void *addr, enum debug_obj_state state)
691{
692    struct self_test *obj = addr;
693
694    switch (state) {
695    case ODEBUG_STATE_ACTIVE:
696        debug_object_deactivate(obj, &descr_type_test);
697        debug_object_init(obj, &descr_type_test);
698        return 1;
699    default:
700        return 0;
701    }
702}
703
704/*
705 * fixup_activate is called when:
706 * - an active object is activated
707 * - an unknown object is activated (might be a statically initialized object)
708 */
709static int __init fixup_activate(void *addr, enum debug_obj_state state)
710{
711    struct self_test *obj = addr;
712
713    switch (state) {
714    case ODEBUG_STATE_NOTAVAILABLE:
715        if (obj->static_init == 1) {
716            debug_object_init(obj, &descr_type_test);
717            debug_object_activate(obj, &descr_type_test);
718            /*
719             * Real code should return 0 here ! This is
720             * not a fixup of some bad behaviour. We
721             * merily call the debug_init function to keep
722             * track of the object.
723             */
724            return 1;
725        } else {
726            /* Real code needs to emit a warning here */
727        }
728        return 0;
729
730    case ODEBUG_STATE_ACTIVE:
731        debug_object_deactivate(obj, &descr_type_test);
732        debug_object_activate(obj, &descr_type_test);
733        return 1;
734
735    default:
736        return 0;
737    }
738}
739
740/*
741 * fixup_destroy is called when:
742 * - an active object is destroyed
743 */
744static int __init fixup_destroy(void *addr, enum debug_obj_state state)
745{
746    struct self_test *obj = addr;
747
748    switch (state) {
749    case ODEBUG_STATE_ACTIVE:
750        debug_object_deactivate(obj, &descr_type_test);
751        debug_object_destroy(obj, &descr_type_test);
752        return 1;
753    default:
754        return 0;
755    }
756}
757
758/*
759 * fixup_free is called when:
760 * - an active object is freed
761 */
762static int __init fixup_free(void *addr, enum debug_obj_state state)
763{
764    struct self_test *obj = addr;
765
766    switch (state) {
767    case ODEBUG_STATE_ACTIVE:
768        debug_object_deactivate(obj, &descr_type_test);
769        debug_object_free(obj, &descr_type_test);
770        return 1;
771    default:
772        return 0;
773    }
774}
775
776static int
777check_results(void *addr, enum debug_obj_state state, int fixups, int warnings)
778{
779    struct debug_bucket *db;
780    struct debug_obj *obj;
781    unsigned long flags;
782    int res = -EINVAL;
783
784    db = get_bucket((unsigned long) addr);
785
786    spin_lock_irqsave(&db->lock, flags);
787
788    obj = lookup_object(addr, db);
789    if (!obj && state != ODEBUG_STATE_NONE) {
790        WARN(1, KERN_ERR "ODEBUG: selftest object not found\n");
791        goto out;
792    }
793    if (obj && obj->state != state) {
794        WARN(1, KERN_ERR "ODEBUG: selftest wrong state: %d != %d\n",
795               obj->state, state);
796        goto out;
797    }
798    if (fixups != debug_objects_fixups) {
799        WARN(1, KERN_ERR "ODEBUG: selftest fixups failed %d != %d\n",
800               fixups, debug_objects_fixups);
801        goto out;
802    }
803    if (warnings != debug_objects_warnings) {
804        WARN(1, KERN_ERR "ODEBUG: selftest warnings failed %d != %d\n",
805               warnings, debug_objects_warnings);
806        goto out;
807    }
808    res = 0;
809out:
810    spin_unlock_irqrestore(&db->lock, flags);
811    if (res)
812        debug_objects_enabled = 0;
813    return res;
814}
815
816static __initdata struct debug_obj_descr descr_type_test = {
817    .name = "selftest",
818    .fixup_init = fixup_init,
819    .fixup_activate = fixup_activate,
820    .fixup_destroy = fixup_destroy,
821    .fixup_free = fixup_free,
822};
823
824static __initdata struct self_test obj = { .static_init = 0 };
825
826static void __init debug_objects_selftest(void)
827{
828    int fixups, oldfixups, warnings, oldwarnings;
829    unsigned long flags;
830
831    local_irq_save(flags);
832
833    fixups = oldfixups = debug_objects_fixups;
834    warnings = oldwarnings = debug_objects_warnings;
835    descr_test = &descr_type_test;
836
837    debug_object_init(&obj, &descr_type_test);
838    if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
839        goto out;
840    debug_object_activate(&obj, &descr_type_test);
841    if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
842        goto out;
843    debug_object_activate(&obj, &descr_type_test);
844    if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, ++warnings))
845        goto out;
846    debug_object_deactivate(&obj, &descr_type_test);
847    if (check_results(&obj, ODEBUG_STATE_INACTIVE, fixups, warnings))
848        goto out;
849    debug_object_destroy(&obj, &descr_type_test);
850    if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, warnings))
851        goto out;
852    debug_object_init(&obj, &descr_type_test);
853    if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
854        goto out;
855    debug_object_activate(&obj, &descr_type_test);
856    if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
857        goto out;
858    debug_object_deactivate(&obj, &descr_type_test);
859    if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
860        goto out;
861    debug_object_free(&obj, &descr_type_test);
862    if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
863        goto out;
864
865    obj.static_init = 1;
866    debug_object_activate(&obj, &descr_type_test);
867    if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, warnings))
868        goto out;
869    debug_object_init(&obj, &descr_type_test);
870    if (check_results(&obj, ODEBUG_STATE_INIT, ++fixups, ++warnings))
871        goto out;
872    debug_object_free(&obj, &descr_type_test);
873    if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
874        goto out;
875
876#ifdef CONFIG_DEBUG_OBJECTS_FREE
877    debug_object_init(&obj, &descr_type_test);
878    if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
879        goto out;
880    debug_object_activate(&obj, &descr_type_test);
881    if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
882        goto out;
883    __debug_check_no_obj_freed(&obj, sizeof(obj));
884    if (check_results(&obj, ODEBUG_STATE_NONE, ++fixups, ++warnings))
885        goto out;
886#endif
887    printk(KERN_INFO "ODEBUG: selftest passed\n");
888
889out:
890    debug_objects_fixups = oldfixups;
891    debug_objects_warnings = oldwarnings;
892    descr_test = NULL;
893
894    local_irq_restore(flags);
895}
896#else
897static inline void debug_objects_selftest(void) { }
898#endif
899
900/*
901 * Called during early boot to initialize the hash buckets and link
902 * the static object pool objects into the poll list. After this call
903 * the object tracker is fully operational.
904 */
905void __init debug_objects_early_init(void)
906{
907    int i;
908
909    for (i = 0; i < ODEBUG_HASH_SIZE; i++)
910        spin_lock_init(&obj_hash[i].lock);
911
912    for (i = 0; i < ODEBUG_POOL_SIZE; i++)
913        hlist_add_head(&obj_static_pool[i].node, &obj_pool);
914}
915
916/*
917 * Convert the statically allocated objects to dynamic ones:
918 */
919static int debug_objects_replace_static_objects(void)
920{
921    struct debug_bucket *db = obj_hash;
922    struct hlist_node *node, *tmp;
923    struct debug_obj *obj, *new;
924    HLIST_HEAD(objects);
925    int i, cnt = 0;
926
927    for (i = 0; i < ODEBUG_POOL_SIZE; i++) {
928        obj = kmem_cache_zalloc(obj_cache, GFP_KERNEL);
929        if (!obj)
930            goto free;
931        hlist_add_head(&obj->node, &objects);
932    }
933
934    /*
935     * When debug_objects_mem_init() is called we know that only
936     * one CPU is up, so disabling interrupts is enough
937     * protection. This avoids the lockdep hell of lock ordering.
938     */
939    local_irq_disable();
940
941    /* Remove the statically allocated objects from the pool */
942    hlist_for_each_entry_safe(obj, node, tmp, &obj_pool, node)
943        hlist_del(&obj->node);
944    /* Move the allocated objects to the pool */
945    hlist_move_list(&objects, &obj_pool);
946
947    /* Replace the active object references */
948    for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
949        hlist_move_list(&db->list, &objects);
950
951        hlist_for_each_entry(obj, node, &objects, node) {
952            new = hlist_entry(obj_pool.first, typeof(*obj), node);
953            hlist_del(&new->node);
954            /* copy object data */
955            *new = *obj;
956            hlist_add_head(&new->node, &db->list);
957            cnt++;
958        }
959    }
960
961    printk(KERN_DEBUG "ODEBUG: %d of %d active objects replaced\n", cnt,
962           obj_pool_used);
963    local_irq_enable();
964    return 0;
965free:
966    hlist_for_each_entry_safe(obj, node, tmp, &objects, node) {
967        hlist_del(&obj->node);
968        kmem_cache_free(obj_cache, obj);
969    }
970    return -ENOMEM;
971}
972
973/*
974 * Called after the kmem_caches are functional to setup a dedicated
975 * cache pool, which has the SLAB_DEBUG_OBJECTS flag set. This flag
976 * prevents that the debug code is called on kmem_cache_free() for the
977 * debug tracker objects to avoid recursive calls.
978 */
979void __init debug_objects_mem_init(void)
980{
981    if (!debug_objects_enabled)
982        return;
983
984    obj_cache = kmem_cache_create("debug_objects_cache",
985                      sizeof (struct debug_obj), 0,
986                      SLAB_DEBUG_OBJECTS, NULL);
987
988    if (!obj_cache || debug_objects_replace_static_objects()) {
989        debug_objects_enabled = 0;
990        if (obj_cache)
991            kmem_cache_destroy(obj_cache);
992        printk(KERN_WARNING "ODEBUG: out of memory.\n");
993    } else
994        debug_objects_selftest();
995}
996

Archive Download this file



interactive