linux/lib/debugobjects.c
<<
>>
Prefs
   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/seq_file.h>
  13#include <linux/debugfs.h>
  14#include <linux/hash.h>
  15
  16#define ODEBUG_HASH_BITS        14
  17#define ODEBUG_HASH_SIZE        (1 << ODEBUG_HASH_BITS)
  18
  19#define ODEBUG_POOL_SIZE        512
  20#define ODEBUG_POOL_MIN_LEVEL   256
  21
  22#define ODEBUG_CHUNK_SHIFT      PAGE_SHIFT
  23#define ODEBUG_CHUNK_SIZE       (1 << ODEBUG_CHUNK_SHIFT)
  24#define ODEBUG_CHUNK_MASK       (~(ODEBUG_CHUNK_SIZE - 1))
  25
  26struct debug_bucket {
  27        struct hlist_head       list;
  28        spinlock_t              lock;
  29};
  30
  31static struct debug_bucket      obj_hash[ODEBUG_HASH_SIZE];
  32
  33static struct debug_obj         obj_static_pool[ODEBUG_POOL_SIZE];
  34
  35static DEFINE_SPINLOCK(pool_lock);
  36
  37static HLIST_HEAD(obj_pool);
  38
  39static int                      obj_pool_min_free = ODEBUG_POOL_SIZE;
  40static int                      obj_pool_free = ODEBUG_POOL_SIZE;
  41static int                      obj_pool_used;
  42static int                      obj_pool_max_used;
  43static struct kmem_cache        *obj_cache;
  44
  45static int                      debug_objects_maxchain __read_mostly;
  46static int                      debug_objects_fixups __read_mostly;
  47static int                      debug_objects_warnings __read_mostly;
  48static int                      debug_objects_enabled __read_mostly;
  49static struct debug_obj_descr   *descr_test  __read_mostly;
  50
  51static int __init enable_object_debug(char *str)
  52{
  53        debug_objects_enabled = 1;
  54        return 0;
  55}
  56early_param("debug_objects", enable_object_debug);
  57
  58static const char *obj_states[ODEBUG_STATE_MAX] = {
  59        [ODEBUG_STATE_NONE]             = "none",
  60        [ODEBUG_STATE_INIT]             = "initialized",
  61        [ODEBUG_STATE_INACTIVE]         = "inactive",
  62        [ODEBUG_STATE_ACTIVE]           = "active",
  63        [ODEBUG_STATE_DESTROYED]        = "destroyed",
  64        [ODEBUG_STATE_NOTAVAILABLE]     = "not available",
  65};
  66
  67static int fill_pool(void)
  68{
  69        gfp_t gfp = GFP_ATOMIC | __GFP_NORETRY | __GFP_NOWARN;
  70        struct debug_obj *new;
  71        unsigned long flags;
  72
  73        if (likely(obj_pool_free >= ODEBUG_POOL_MIN_LEVEL))
  74                return obj_pool_free;
  75
  76        if (unlikely(!obj_cache))
  77                return obj_pool_free;
  78
  79        while (obj_pool_free < ODEBUG_POOL_MIN_LEVEL) {
  80
  81                new = kmem_cache_zalloc(obj_cache, gfp);
  82                if (!new)
  83                        return obj_pool_free;
  84
  85                spin_lock_irqsave(&pool_lock, flags);
  86                hlist_add_head(&new->node, &obj_pool);
  87                obj_pool_free++;
  88                spin_unlock_irqrestore(&pool_lock, flags);
  89        }
  90        return obj_pool_free;
  91}
  92
  93/*
  94 * Lookup an object in the hash bucket.
  95 */
  96static struct debug_obj *lookup_object(void *addr, struct debug_bucket *b)
  97{
  98        struct hlist_node *node;
  99        struct debug_obj *obj;
 100        int cnt = 0;
 101
 102        hlist_for_each_entry(obj, node, &b->list, node) {
 103                cnt++;
 104                if (obj->object == addr)
 105                        return obj;
 106        }
 107        if (cnt > debug_objects_maxchain)
 108                debug_objects_maxchain = cnt;
 109
 110        return NULL;
 111}
 112
 113/*
 114 * Allocate a new object. If the pool is empty, switch off the debugger.
 115 * Must be called with interrupts disabled.
 116 */
 117static struct debug_obj *
 118alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
 119{
 120        struct debug_obj *obj = NULL;
 121
 122        spin_lock(&pool_lock);
 123        if (obj_pool.first) {
 124                obj         = hlist_entry(obj_pool.first, typeof(*obj), node);
 125
 126                obj->object = addr;
 127                obj->descr  = descr;
 128                obj->state  = ODEBUG_STATE_NONE;
 129                hlist_del(&obj->node);
 130
 131                hlist_add_head(&obj->node, &b->list);
 132
 133                obj_pool_used++;
 134                if (obj_pool_used > obj_pool_max_used)
 135                        obj_pool_max_used = obj_pool_used;
 136
 137                obj_pool_free--;
 138                if (obj_pool_free < obj_pool_min_free)
 139                        obj_pool_min_free = obj_pool_free;
 140        }
 141        spin_unlock(&pool_lock);
 142
 143        return obj;
 144}
 145
 146/*
 147 * Put the object back into the pool or give it back to kmem_cache:
 148 */
 149static void free_object(struct debug_obj *obj)
 150{
 151        unsigned long idx = (unsigned long)(obj - obj_static_pool);
 152        unsigned long flags;
 153
 154        if (obj_pool_free < ODEBUG_POOL_SIZE || idx < ODEBUG_POOL_SIZE) {
 155                spin_lock_irqsave(&pool_lock, flags);
 156                hlist_add_head(&obj->node, &obj_pool);
 157                obj_pool_free++;
 158                obj_pool_used--;
 159                spin_unlock_irqrestore(&pool_lock, flags);
 160        } else {
 161                spin_lock_irqsave(&pool_lock, flags);
 162                obj_pool_used--;
 163                spin_unlock_irqrestore(&pool_lock, flags);
 164                kmem_cache_free(obj_cache, obj);
 165        }
 166}
 167
 168/*
 169 * We run out of memory. That means we probably have tons of objects
 170 * allocated.
 171 */
 172static void debug_objects_oom(void)
 173{
 174        struct debug_bucket *db = obj_hash;
 175        struct hlist_node *node, *tmp;
 176        HLIST_HEAD(freelist);
 177        struct debug_obj *obj;
 178        unsigned long flags;
 179        int i;
 180
 181        printk(KERN_WARNING "ODEBUG: Out of memory. ODEBUG disabled\n");
 182
 183        for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
 184                spin_lock_irqsave(&db->lock, flags);
 185                hlist_move_list(&db->list, &freelist);
 186                spin_unlock_irqrestore(&db->lock, flags);
 187
 188                /* Now free them */
 189                hlist_for_each_entry_safe(obj, node, tmp, &freelist, node) {
 190                        hlist_del(&obj->node);
 191                        free_object(obj);
 192                }
 193        }
 194}
 195
 196/*
 197 * We use the pfn of the address for the hash. That way we can check
 198 * for freed objects simply by checking the affected bucket.
 199 */
 200static struct debug_bucket *get_bucket(unsigned long addr)
 201{
 202        unsigned long hash;
 203
 204        hash = hash_long((addr >> ODEBUG_CHUNK_SHIFT), ODEBUG_HASH_BITS);
 205        return &obj_hash[hash];
 206}
 207
 208static void debug_print_object(struct debug_obj *obj, char *msg)
 209{
 210        static int limit;
 211
 212        if (limit < 5 && obj->descr != descr_test) {
 213                limit++;
 214                WARN(1, KERN_ERR "ODEBUG: %s %s object type: %s\n", msg,
 215                       obj_states[obj->state], obj->descr->name);
 216        }
 217        debug_objects_warnings++;
 218}
 219
 220/*
 221 * Try to repair the damage, so we have a better chance to get useful
 222 * debug output.
 223 */
 224static void
 225debug_object_fixup(int (*fixup)(void *addr, enum debug_obj_state state),
 226                   void * addr, enum debug_obj_state state)
 227{
 228        if (fixup)
 229                debug_objects_fixups += fixup(addr, state);
 230}
 231
 232static void debug_object_is_on_stack(void *addr, int onstack)
 233{
 234        int is_on_stack;
 235        static int limit;
 236
 237        if (limit > 4)
 238                return;
 239
 240        is_on_stack = object_is_on_stack(addr);
 241        if (is_on_stack == onstack)
 242                return;
 243
 244        limit++;
 245        if (is_on_stack)
 246                printk(KERN_WARNING
 247                       "ODEBUG: object is on stack, but not annotated\n");
 248        else
 249                printk(KERN_WARNING
 250                       "ODEBUG: object is not on stack, but annotated\n");
 251        WARN_ON(1);
 252}
 253
 254static void
 255__debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
 256{
 257        enum debug_obj_state state;
 258        struct debug_bucket *db;
 259        struct debug_obj *obj;
 260        unsigned long flags;
 261
 262        fill_pool();
 263
 264        db = get_bucket((unsigned long) addr);
 265
 266        spin_lock_irqsave(&db->lock, flags);
 267
 268        obj = lookup_object(addr, db);
 269        if (!obj) {
 270                obj = alloc_object(addr, db, descr);
 271                if (!obj) {
 272                        debug_objects_enabled = 0;
 273                        spin_unlock_irqrestore(&db->lock, flags);
 274                        debug_objects_oom();
 275                        return;
 276                }
 277                debug_object_is_on_stack(addr, onstack);
 278        }
 279
 280        switch (obj->state) {
 281        case ODEBUG_STATE_NONE:
 282        case ODEBUG_STATE_INIT:
 283        case ODEBUG_STATE_INACTIVE:
 284                obj->state = ODEBUG_STATE_INIT;
 285                break;
 286
 287        case ODEBUG_STATE_ACTIVE:
 288                debug_print_object(obj, "init");
 289                state = obj->state;
 290                spin_unlock_irqrestore(&db->lock, flags);
 291                debug_object_fixup(descr->fixup_init, addr, state);
 292                return;
 293
 294        case ODEBUG_STATE_DESTROYED:
 295                debug_print_object(obj, "init");
 296                break;
 297        default:
 298                break;
 299        }
 300
 301        spin_unlock_irqrestore(&db->lock, flags);
 302}
 303
 304/**
 305 * debug_object_init - debug checks when an object is initialized
 306 * @addr:       address of the object
 307 * @descr:      pointer to an object specific debug description structure
 308 */
 309void debug_object_init(void *addr, struct debug_obj_descr *descr)
 310{
 311        if (!debug_objects_enabled)
 312                return;
 313
 314        __debug_object_init(addr, descr, 0);
 315}
 316
 317/**
 318 * debug_object_init_on_stack - debug checks when an object on stack is
 319 *                              initialized
 320 * @addr:       address of the object
 321 * @descr:      pointer to an object specific debug description structure
 322 */
 323void debug_object_init_on_stack(void *addr, struct debug_obj_descr *descr)
 324{
 325        if (!debug_objects_enabled)
 326                return;
 327
 328        __debug_object_init(addr, descr, 1);
 329}
 330
 331/**
 332 * debug_object_activate - debug checks when an object is activated
 333 * @addr:       address of the object
 334 * @descr:      pointer to an object specific debug description structure
 335 */
 336void debug_object_activate(void *addr, struct debug_obj_descr *descr)
 337{
 338        enum debug_obj_state state;
 339        struct debug_bucket *db;
 340        struct debug_obj *obj;
 341        unsigned long flags;
 342
 343        if (!debug_objects_enabled)
 344                return;
 345
 346        db = get_bucket((unsigned long) addr);
 347
 348        spin_lock_irqsave(&db->lock, flags);
 349
 350        obj = lookup_object(addr, db);
 351        if (obj) {
 352                switch (obj->state) {
 353                case ODEBUG_STATE_INIT:
 354                case ODEBUG_STATE_INACTIVE:
 355                        obj->state = ODEBUG_STATE_ACTIVE;
 356                        break;
 357
 358                case ODEBUG_STATE_ACTIVE:
 359                        debug_print_object(obj, "activate");
 360                        state = obj->state;
 361                        spin_unlock_irqrestore(&db->lock, flags);
 362                        debug_object_fixup(descr->fixup_activate, addr, state);
 363                        return;
 364
 365                case ODEBUG_STATE_DESTROYED:
 366                        debug_print_object(obj, "activate");
 367                        break;
 368                default:
 369                        break;
 370                }
 371                spin_unlock_irqrestore(&db->lock, flags);
 372                return;
 373        }
 374
 375        spin_unlock_irqrestore(&db->lock, flags);
 376        /*
 377         * This happens when a static object is activated. We
 378         * let the type specific code decide whether this is
 379         * true or not.
 380         */
 381        debug_object_fixup(descr->fixup_activate, addr,
 382                           ODEBUG_STATE_NOTAVAILABLE);
 383}
 384
 385/**
 386 * debug_object_deactivate - debug checks when an object is deactivated
 387 * @addr:       address of the object
 388 * @descr:      pointer to an object specific debug description structure
 389 */
 390void debug_object_deactivate(void *addr, struct debug_obj_descr *descr)
 391{
 392        struct debug_bucket *db;
 393        struct debug_obj *obj;
 394        unsigned long flags;
 395
 396        if (!debug_objects_enabled)
 397                return;
 398
 399        db = get_bucket((unsigned long) addr);
 400
 401        spin_lock_irqsave(&db->lock, flags);
 402
 403        obj = lookup_object(addr, db);
 404        if (obj) {
 405                switch (obj->state) {
 406                case ODEBUG_STATE_INIT:
 407                case ODEBUG_STATE_INACTIVE:
 408                case ODEBUG_STATE_ACTIVE:
 409                        obj->state = ODEBUG_STATE_INACTIVE;
 410                        break;
 411
 412                case ODEBUG_STATE_DESTROYED:
 413                        debug_print_object(obj, "deactivate");
 414                        break;
 415                default:
 416                        break;
 417                }
 418        } else {
 419                struct debug_obj o = { .object = addr,
 420                                       .state = ODEBUG_STATE_NOTAVAILABLE,
 421                                       .descr = descr };
 422
 423                debug_print_object(&o, "deactivate");
 424        }
 425
 426        spin_unlock_irqrestore(&db->lock, flags);
 427}
 428
 429/**
 430 * debug_object_destroy - debug checks when an object is destroyed
 431 * @addr:       address of the object
 432 * @descr:      pointer to an object specific debug description structure
 433 */
 434void debug_object_destroy(void *addr, struct debug_obj_descr *descr)
 435{
 436        enum debug_obj_state state;
 437        struct debug_bucket *db;
 438        struct debug_obj *obj;
 439        unsigned long flags;
 440
 441        if (!debug_objects_enabled)
 442                return;
 443
 444        db = get_bucket((unsigned long) addr);
 445
 446        spin_lock_irqsave(&db->lock, flags);
 447
 448        obj = lookup_object(addr, db);
 449        if (!obj)
 450                goto out_unlock;
 451
 452        switch (obj->state) {
 453        case ODEBUG_STATE_NONE:
 454        case ODEBUG_STATE_INIT:
 455        case ODEBUG_STATE_INACTIVE:
 456                obj->state = ODEBUG_STATE_DESTROYED;
 457                break;
 458        case ODEBUG_STATE_ACTIVE:
 459                debug_print_object(obj, "destroy");
 460                state = obj->state;
 461                spin_unlock_irqrestore(&db->lock, flags);
 462                debug_object_fixup(descr->fixup_destroy, addr, state);
 463                return;
 464
 465        case ODEBUG_STATE_DESTROYED:
 466                debug_print_object(obj, "destroy");
 467                break;
 468        default:
 469                break;
 470        }
 471out_unlock:
 472        spin_unlock_irqrestore(&db->lock, flags);
 473}
 474
 475/**
 476 * debug_object_free - debug checks when an object is freed
 477 * @addr:       address of the object
 478 * @descr:      pointer to an object specific debug description structure
 479 */
 480void debug_object_free(void *addr, struct debug_obj_descr *descr)
 481{
 482        enum debug_obj_state state;
 483        struct debug_bucket *db;
 484        struct debug_obj *obj;
 485        unsigned long flags;
 486
 487        if (!debug_objects_enabled)
 488                return;
 489
 490        db = get_bucket((unsigned long) addr);
 491
 492        spin_lock_irqsave(&db->lock, flags);
 493
 494        obj = lookup_object(addr, db);
 495        if (!obj)
 496                goto out_unlock;
 497
 498        switch (obj->state) {
 499        case ODEBUG_STATE_ACTIVE:
 500                debug_print_object(obj, "free");
 501                state = obj->state;
 502                spin_unlock_irqrestore(&db->lock, flags);
 503                debug_object_fixup(descr->fixup_free, addr, state);
 504                return;
 505        default:
 506                hlist_del(&obj->node);
 507                spin_unlock_irqrestore(&db->lock, flags);
 508                free_object(obj);
 509                return;
 510        }
 511out_unlock:
 512        spin_unlock_irqrestore(&db->lock, flags);
 513}
 514
 515#ifdef CONFIG_DEBUG_OBJECTS_FREE
 516static void __debug_check_no_obj_freed(const void *address, unsigned long size)
 517{
 518        unsigned long flags, oaddr, saddr, eaddr, paddr, chunks;
 519        struct hlist_node *node, *tmp;
 520        HLIST_HEAD(freelist);
 521        struct debug_obj_descr *descr;
 522        enum debug_obj_state state;
 523        struct debug_bucket *db;
 524        struct debug_obj *obj;
 525        int cnt;
 526
 527        saddr = (unsigned long) address;
 528        eaddr = saddr + size;
 529        paddr = saddr & ODEBUG_CHUNK_MASK;
 530        chunks = ((eaddr - paddr) + (ODEBUG_CHUNK_SIZE - 1));
 531        chunks >>= ODEBUG_CHUNK_SHIFT;
 532
 533        for (;chunks > 0; chunks--, paddr += ODEBUG_CHUNK_SIZE) {
 534                db = get_bucket(paddr);
 535
 536repeat:
 537                cnt = 0;
 538                spin_lock_irqsave(&db->lock, flags);
 539                hlist_for_each_entry_safe(obj, node, tmp, &db->list, node) {
 540                        cnt++;
 541                        oaddr = (unsigned long) obj->object;
 542                        if (oaddr < saddr || oaddr >= eaddr)
 543                                continue;
 544
 545                        switch (obj->state) {
 546                        case ODEBUG_STATE_ACTIVE:
 547                                debug_print_object(obj, "free");
 548                                descr = obj->descr;
 549                                state = obj->state;
 550                                spin_unlock_irqrestore(&db->lock, flags);
 551                                debug_object_fixup(descr->fixup_free,
 552                                                   (void *) oaddr, state);
 553                                goto repeat;
 554                        default:
 555                                hlist_del(&obj->node);
 556                                hlist_add_head(&obj->node, &freelist);
 557                                break;
 558                        }
 559                }
 560                spin_unlock_irqrestore(&db->lock, flags);
 561
 562                /* Now free them */
 563                hlist_for_each_entry_safe(obj, node, tmp, &freelist, node) {
 564                        hlist_del(&obj->node);
 565                        free_object(obj);
 566                }
 567
 568                if (cnt > debug_objects_maxchain)
 569                        debug_objects_maxchain = cnt;
 570        }
 571}
 572
 573void debug_check_no_obj_freed(const void *address, unsigned long size)
 574{
 575        if (debug_objects_enabled)
 576                __debug_check_no_obj_freed(address, size);
 577}
 578#endif
 579
 580#ifdef CONFIG_DEBUG_FS
 581
 582static int debug_stats_show(struct seq_file *m, void *v)
 583{
 584        seq_printf(m, "max_chain     :%d\n", debug_objects_maxchain);
 585        seq_printf(m, "warnings      :%d\n", debug_objects_warnings);
 586        seq_printf(m, "fixups        :%d\n", debug_objects_fixups);
 587        seq_printf(m, "pool_free     :%d\n", obj_pool_free);
 588        seq_printf(m, "pool_min_free :%d\n", obj_pool_min_free);
 589        seq_printf(m, "pool_used     :%d\n", obj_pool_used);
 590        seq_printf(m, "pool_max_used :%d\n", obj_pool_max_used);
 591        return 0;
 592}
 593
 594static int debug_stats_open(struct inode *inode, struct file *filp)
 595{
 596        return single_open(filp, debug_stats_show, NULL);
 597}
 598
 599static const struct file_operations debug_stats_fops = {
 600        .open           = debug_stats_open,
 601        .read           = seq_read,
 602        .llseek         = seq_lseek,
 603        .release        = single_release,
 604};
 605
 606static int __init debug_objects_init_debugfs(void)
 607{
 608        struct dentry *dbgdir, *dbgstats;
 609
 610        if (!debug_objects_enabled)
 611                return 0;
 612
 613        dbgdir = debugfs_create_dir("debug_objects", NULL);
 614        if (!dbgdir)
 615                return -ENOMEM;
 616
 617        dbgstats = debugfs_create_file("stats", 0444, dbgdir, NULL,
 618                                       &debug_stats_fops);
 619        if (!dbgstats)
 620                goto err;
 621
 622        return 0;
 623
 624err:
 625        debugfs_remove(dbgdir);
 626
 627        return -ENOMEM;
 628}
 629__initcall(debug_objects_init_debugfs);
 630
 631#else
 632static inline void debug_objects_init_debugfs(void) { }
 633#endif
 634
 635#ifdef CONFIG_DEBUG_OBJECTS_SELFTEST
 636
 637/* Random data structure for the self test */
 638struct self_test {
 639        unsigned long   dummy1[6];
 640        int             static_init;
 641        unsigned long   dummy2[3];
 642};
 643
 644static __initdata struct debug_obj_descr descr_type_test;
 645
 646/*
 647 * fixup_init is called when:
 648 * - an active object is initialized
 649 */
 650static int __init fixup_init(void *addr, enum debug_obj_state state)
 651{
 652        struct self_test *obj = addr;
 653
 654        switch (state) {
 655        case ODEBUG_STATE_ACTIVE:
 656                debug_object_deactivate(obj, &descr_type_test);
 657                debug_object_init(obj, &descr_type_test);
 658                return 1;
 659        default:
 660                return 0;
 661        }
 662}
 663
 664/*
 665 * fixup_activate is called when:
 666 * - an active object is activated
 667 * - an unknown object is activated (might be a statically initialized object)
 668 */
 669static int __init fixup_activate(void *addr, enum debug_obj_state state)
 670{
 671        struct self_test *obj = addr;
 672
 673        switch (state) {
 674        case ODEBUG_STATE_NOTAVAILABLE:
 675                if (obj->static_init == 1) {
 676                        debug_object_init(obj, &descr_type_test);
 677                        debug_object_activate(obj, &descr_type_test);
 678                        /*
 679                         * Real code should return 0 here ! This is
 680                         * not a fixup of some bad behaviour. We
 681                         * merily call the debug_init function to keep
 682                         * track of the object.
 683                         */
 684                        return 1;
 685                } else {
 686                        /* Real code needs to emit a warning here */
 687                }
 688                return 0;
 689
 690        case ODEBUG_STATE_ACTIVE:
 691                debug_object_deactivate(obj, &descr_type_test);
 692                debug_object_activate(obj, &descr_type_test);
 693                return 1;
 694
 695        default:
 696                return 0;
 697        }
 698}
 699
 700/*
 701 * fixup_destroy is called when:
 702 * - an active object is destroyed
 703 */
 704static int __init fixup_destroy(void *addr, enum debug_obj_state state)
 705{
 706        struct self_test *obj = addr;
 707
 708        switch (state) {
 709        case ODEBUG_STATE_ACTIVE:
 710                debug_object_deactivate(obj, &descr_type_test);
 711                debug_object_destroy(obj, &descr_type_test);
 712                return 1;
 713        default:
 714                return 0;
 715        }
 716}
 717
 718/*
 719 * fixup_free is called when:
 720 * - an active object is freed
 721 */
 722static int __init fixup_free(void *addr, enum debug_obj_state state)
 723{
 724        struct self_test *obj = addr;
 725
 726        switch (state) {
 727        case ODEBUG_STATE_ACTIVE:
 728                debug_object_deactivate(obj, &descr_type_test);
 729                debug_object_free(obj, &descr_type_test);
 730                return 1;
 731        default:
 732                return 0;
 733        }
 734}
 735
 736static int
 737check_results(void *addr, enum debug_obj_state state, int fixups, int warnings)
 738{
 739        struct debug_bucket *db;
 740        struct debug_obj *obj;
 741        unsigned long flags;
 742        int res = -EINVAL;
 743
 744        db = get_bucket((unsigned long) addr);
 745
 746        spin_lock_irqsave(&db->lock, flags);
 747
 748        obj = lookup_object(addr, db);
 749        if (!obj && state != ODEBUG_STATE_NONE) {
 750                WARN(1, KERN_ERR "ODEBUG: selftest object not found\n");
 751                goto out;
 752        }
 753        if (obj && obj->state != state) {
 754                WARN(1, KERN_ERR "ODEBUG: selftest wrong state: %d != %d\n",
 755                       obj->state, state);
 756                goto out;
 757        }
 758        if (fixups != debug_objects_fixups) {
 759                WARN(1, KERN_ERR "ODEBUG: selftest fixups failed %d != %d\n",
 760                       fixups, debug_objects_fixups);
 761                goto out;
 762        }
 763        if (warnings != debug_objects_warnings) {
 764                WARN(1, KERN_ERR "ODEBUG: selftest warnings failed %d != %d\n",
 765                       warnings, debug_objects_warnings);
 766                goto out;
 767        }
 768        res = 0;
 769out:
 770        spin_unlock_irqrestore(&db->lock, flags);
 771        if (res)
 772                debug_objects_enabled = 0;
 773        return res;
 774}
 775
 776static __initdata struct debug_obj_descr descr_type_test = {
 777        .name                   = "selftest",
 778        .fixup_init             = fixup_init,
 779        .fixup_activate         = fixup_activate,
 780        .fixup_destroy          = fixup_destroy,
 781        .fixup_free             = fixup_free,
 782};
 783
 784static __initdata struct self_test obj = { .static_init = 0 };
 785
 786static void __init debug_objects_selftest(void)
 787{
 788        int fixups, oldfixups, warnings, oldwarnings;
 789        unsigned long flags;
 790
 791        local_irq_save(flags);
 792
 793        fixups = oldfixups = debug_objects_fixups;
 794        warnings = oldwarnings = debug_objects_warnings;
 795        descr_test = &descr_type_test;
 796
 797        debug_object_init(&obj, &descr_type_test);
 798        if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
 799                goto out;
 800        debug_object_activate(&obj, &descr_type_test);
 801        if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
 802                goto out;
 803        debug_object_activate(&obj, &descr_type_test);
 804        if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, ++warnings))
 805                goto out;
 806        debug_object_deactivate(&obj, &descr_type_test);
 807        if (check_results(&obj, ODEBUG_STATE_INACTIVE, fixups, warnings))
 808                goto out;
 809        debug_object_destroy(&obj, &descr_type_test);
 810        if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, warnings))
 811                goto out;
 812        debug_object_init(&obj, &descr_type_test);
 813        if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
 814                goto out;
 815        debug_object_activate(&obj, &descr_type_test);
 816        if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
 817                goto out;
 818        debug_object_deactivate(&obj, &descr_type_test);
 819        if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
 820                goto out;
 821        debug_object_free(&obj, &descr_type_test);
 822        if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
 823                goto out;
 824
 825        obj.static_init = 1;
 826        debug_object_activate(&obj, &descr_type_test);
 827        if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, warnings))
 828                goto out;
 829        debug_object_init(&obj, &descr_type_test);
 830        if (check_results(&obj, ODEBUG_STATE_INIT, ++fixups, ++warnings))
 831                goto out;
 832        debug_object_free(&obj, &descr_type_test);
 833        if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
 834                goto out;
 835
 836#ifdef CONFIG_DEBUG_OBJECTS_FREE
 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_check_no_obj_freed(&obj, sizeof(obj));
 844        if (check_results(&obj, ODEBUG_STATE_NONE, ++fixups, ++warnings))
 845                goto out;
 846#endif
 847        printk(KERN_INFO "ODEBUG: selftest passed\n");
 848
 849out:
 850        debug_objects_fixups = oldfixups;
 851        debug_objects_warnings = oldwarnings;
 852        descr_test = NULL;
 853
 854        local_irq_restore(flags);
 855}
 856#else
 857static inline void debug_objects_selftest(void) { }
 858#endif
 859
 860/*
 861 * Called during early boot to initialize the hash buckets and link
 862 * the static object pool objects into the poll list. After this call
 863 * the object tracker is fully operational.
 864 */
 865void __init debug_objects_early_init(void)
 866{
 867        int i;
 868
 869        for (i = 0; i < ODEBUG_HASH_SIZE; i++)
 870                spin_lock_init(&obj_hash[i].lock);
 871
 872        for (i = 0; i < ODEBUG_POOL_SIZE; i++)
 873                hlist_add_head(&obj_static_pool[i].node, &obj_pool);
 874}
 875
 876/*
 877 * Called after the kmem_caches are functional to setup a dedicated
 878 * cache pool, which has the SLAB_DEBUG_OBJECTS flag set. This flag
 879 * prevents that the debug code is called on kmem_cache_free() for the
 880 * debug tracker objects to avoid recursive calls.
 881 */
 882void __init debug_objects_mem_init(void)
 883{
 884        if (!debug_objects_enabled)
 885                return;
 886
 887        obj_cache = kmem_cache_create("debug_objects_cache",
 888                                      sizeof (struct debug_obj), 0,
 889                                      SLAB_DEBUG_OBJECTS, NULL);
 890
 891        if (!obj_cache)
 892                debug_objects_enabled = 0;
 893        else
 894                debug_objects_selftest();
 895}
 896
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.