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/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
  26 struct debug_bucket {
  27         struct hlist_head       list;
  28         spinlock_t              lock;
  29 };
  30
  31 static struct debug_bucket      obj_hash[ODEBUG_HASH_SIZE];
  32
  33 static struct debug_obj         obj_static_pool[ODEBUG_POOL_SIZE];
  34
  35 static DEFINE_SPINLOCK(pool_lock);
  36
  37 static HLIST_HEAD(obj_pool);
  38
  39 static int                      obj_pool_min_free = ODEBUG_POOL_SIZE;
  40 static int                      obj_pool_free = ODEBUG_POOL_SIZE;
  41 static int                      obj_pool_used;
  42 static int                      obj_pool_max_used;
  43 static struct kmem_cache        *obj_cache;
  44
  45 static int                      debug_objects_maxchain __read_mostly;
  46 static int                      debug_objects_fixups __read_mostly;
  47 static int                      debug_objects_warnings __read_mostly;
  48 static int                      debug_objects_enabled __read_mostly;
  49 static struct debug_obj_descr   *descr_test  __read_mostly;
  50
  51 static int __init enable_object_debug(char *str)
  52 {
  53         debug_objects_enabled = 1;
  54         return 0;
  55 }
  56 early_param("debug_objects", enable_object_debug);
  57
  58 static 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
  67 static 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  */
  96 static 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  */
 117 static struct debug_obj *
 118 alloc_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  */
 149 static 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  */
 172 static 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  */
 200 static 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
 208 static 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  */
 224 static void
 225 debug_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
 232 static 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
 254 static 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  */
 309 void 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  */
 323 void 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  */
 336 void 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  */
 390 void 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  */
 434 void 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         }
 471 out_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  */
 480 void 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         }
 511 out_unlock:
 512         spin_unlock_irqrestore(&db->lock, flags);
 513 }
 514
 515 #ifdef CONFIG_DEBUG_OBJECTS_FREE
 516 static 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
 536 repeat:
 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
 573 void 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
 582 static 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
 594 static int debug_stats_open(struct inode *inode, struct file *filp)
 595 {
 596         return single_open(filp, debug_stats_show, NULL);
 597 }
 598
 599 static 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
 606 static 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
 624 err:
 625         debugfs_remove(dbgdir);
 626
 627         return -ENOMEM;
 628 }
 629 __initcall(debug_objects_init_debugfs);
 630
 631 #else
 632 static 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 */
 638 struct self_test {
 639         unsigned long   dummy1[6];
 640         int             static_init;
 641         unsigned long   dummy2[3];
 642 };
 643
 644 static __initdata struct debug_obj_descr descr_type_test;
 645
 646 /*
 647  * fixup_init is called when:
 648  * - an active object is initialized
 649  */
 650 static 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  */
 669 static 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  */
 704 static 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  */
 722 static 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
 736 static int
 737 check_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;
 769 out:
 770         spin_unlock_irqrestore(&db->lock, flags);
 771         if (res)
 772                 debug_objects_enabled = 0;
 773         return res;
 774 }
 775
 776 static __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
 784 static __initdata struct self_test obj = { .static_init = 0 };
 785
 786 static 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
 849 out:
 850         debug_objects_fixups = oldfixups;
 851         debug_objects_warnings = oldwarnings;
 852         descr_test = NULL;
 853
 854         local_irq_restore(flags);
 855 }
 856 #else
 857 static 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  */
 865 void __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  */
 882 void __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 }