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
  72         if (likely(obj_pool_free >= ODEBUG_POOL_MIN_LEVEL))
  73                 return obj_pool_free;
  74
  75         if (unlikely(!obj_cache))
  76                 return obj_pool_free;
  77
  78         while (obj_pool_free < ODEBUG_POOL_MIN_LEVEL) {
  79
  80                 new = kmem_cache_zalloc(obj_cache, gfp);
  81                 if (!new)
  82                         return obj_pool_free;
  83
  84                 spin_lock(&pool_lock);
  85                 hlist_add_head(&new->node, &obj_pool);
  86                 obj_pool_free++;
  87                 spin_unlock(&pool_lock);
  88         }
  89         return obj_pool_free;
  90 }
  91
  92 /*
  93  * Lookup an object in the hash bucket.
  94  */
  95 static struct debug_obj *lookup_object(void *addr, struct debug_bucket *b)
  96 {
  97         struct hlist_node *node;
  98         struct debug_obj *obj;
  99         int cnt = 0;
 100
 101         hlist_for_each_entry(obj, node, &b->list, node) {
 102                 cnt++;
 103                 if (obj->object == addr)
 104                         return obj;
 105         }
 106         if (cnt > debug_objects_maxchain)
 107                 debug_objects_maxchain = cnt;
 108
 109         return NULL;
 110 }
 111
 112 /*
 113  * Allocate a new object. If the pool is empty and no refill possible,
 114  * switch off the debugger.
 115  */
 116 static struct debug_obj *
 117 alloc_object(void *addr, struct debug_bucket *b, struct debug_obj_descr *descr)
 118 {
 119         struct debug_obj *obj = NULL;
 120         int retry = 0;
 121
 122 repeat:
 123         spin_lock(&pool_lock);
 124         if (obj_pool.first) {
 125                 obj         = hlist_entry(obj_pool.first, typeof(*obj), node);
 126
 127                 obj->object = addr;
 128                 obj->descr  = descr;
 129                 obj->state  = ODEBUG_STATE_NONE;
 130                 hlist_del(&obj->node);
 131
 132                 hlist_add_head(&obj->node, &b->list);
 133
 134                 obj_pool_used++;
 135                 if (obj_pool_used > obj_pool_max_used)
 136                         obj_pool_max_used = obj_pool_used;
 137
 138                 obj_pool_free--;
 139                 if (obj_pool_free < obj_pool_min_free)
 140                         obj_pool_min_free = obj_pool_free;
 141         }
 142         spin_unlock(&pool_lock);
 143
 144         if (fill_pool() && !obj && !retry++)
 145                 goto repeat;
 146
 147         return obj;
 148 }
 149
 150 /*
 151  * Put the object back into the pool or give it back to kmem_cache:
 152  */
 153 static void free_object(struct debug_obj *obj)
 154 {
 155         unsigned long idx = (unsigned long)(obj - obj_static_pool);
 156
 157         if (obj_pool_free < ODEBUG_POOL_SIZE || idx < ODEBUG_POOL_SIZE) {
 158                 spin_lock(&pool_lock);
 159                 hlist_add_head(&obj->node, &obj_pool);
 160                 obj_pool_free++;
 161                 obj_pool_used--;
 162                 spin_unlock(&pool_lock);
 163         } else {
 164                 spin_lock(&pool_lock);
 165                 obj_pool_used--;
 166                 spin_unlock(&pool_lock);
 167                 kmem_cache_free(obj_cache, obj);
 168         }
 169 }
 170
 171 /*
 172  * We run out of memory. That means we probably have tons of objects
 173  * allocated.
 174  */
 175 static void debug_objects_oom(void)
 176 {
 177         struct debug_bucket *db = obj_hash;
 178         struct hlist_node *node, *tmp;
 179         struct debug_obj *obj;
 180         unsigned long flags;
 181         int i;
 182
 183         printk(KERN_WARNING "ODEBUG: Out of memory. ODEBUG disabled\n");
 184
 185         for (i = 0; i < ODEBUG_HASH_SIZE; i++, db++) {
 186                 spin_lock_irqsave(&db->lock, flags);
 187                 hlist_for_each_entry_safe(obj, node, tmp, &db->list, node) {
 188                         hlist_del(&obj->node);
 189                         free_object(obj);
 190                 }
 191                 spin_unlock_irqrestore(&db->lock, flags);
 192         }
 193 }
 194
 195 /*
 196  * We use the pfn of the address for the hash. That way we can check
 197  * for freed objects simply by checking the affected bucket.
 198  */
 199 static struct debug_bucket *get_bucket(unsigned long addr)
 200 {
 201         unsigned long hash;
 202
 203         hash = hash_long((addr >> ODEBUG_CHUNK_SHIFT), ODEBUG_HASH_BITS);
 204         return &obj_hash[hash];
 205 }
 206
 207 static void debug_print_object(struct debug_obj *obj, char *msg)
 208 {
 209         static int limit;
 210
 211         if (limit < 5 && obj->descr != descr_test) {
 212                 limit++;
 213                 printk(KERN_ERR "ODEBUG: %s %s object type: %s\n", msg,
 214                        obj_states[obj->state], obj->descr->name);
 215                 WARN_ON(1);
 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         void *stack = current->stack;
 235         int is_on_stack;
 236         static int limit;
 237
 238         if (limit > 4)
 239                 return;
 240
 241         is_on_stack = (addr >= stack && addr < (stack + THREAD_SIZE));
 242
 243         if (is_on_stack == onstack)
 244                 return;
 245
 246         limit++;
 247         if (is_on_stack)
 248                 printk(KERN_WARNING
 249                        "ODEBUG: object is on stack, but not annotated\n");
 250         else
 251                 printk(KERN_WARNING
 252                        "ODEBUG: object is not on stack, but annotated\n");
 253         WARN_ON(1);
 254 }
 255
 256 static void
 257 __debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
 258 {
 259         enum debug_obj_state state;
 260         struct debug_bucket *db;
 261         struct debug_obj *obj;
 262         unsigned long flags;
 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                 free_object(obj);
 508                 break;
 509         }
 510 out_unlock:
 511         spin_unlock_irqrestore(&db->lock, flags);
 512 }
 513
 514 #ifdef CONFIG_DEBUG_OBJECTS_FREE
 515 static void __debug_check_no_obj_freed(const void *address, unsigned long size)
 516 {
 517         unsigned long flags, oaddr, saddr, eaddr, paddr, chunks;
 518         struct hlist_node *node, *tmp;
 519         struct debug_obj_descr *descr;
 520         enum debug_obj_state state;
 521         struct debug_bucket *db;
 522         struct debug_obj *obj;
 523         int cnt;
 524
 525         saddr = (unsigned long) address;
 526         eaddr = saddr + size;
 527         paddr = saddr & ODEBUG_CHUNK_MASK;
 528         chunks = ((eaddr - paddr) + (ODEBUG_CHUNK_SIZE - 1));
 529         chunks >>= ODEBUG_CHUNK_SHIFT;
 530
 531         for (;chunks > 0; chunks--, paddr += ODEBUG_CHUNK_SIZE) {
 532                 db = get_bucket(paddr);
 533
 534 repeat:
 535                 cnt = 0;
 536                 spin_lock_irqsave(&db->lock, flags);
 537                 hlist_for_each_entry_safe(obj, node, tmp, &db->list, node) {
 538                         cnt++;
 539                         oaddr = (unsigned long) obj->object;
 540                         if (oaddr < saddr || oaddr >= eaddr)
 541                                 continue;
 542
 543                         switch (obj->state) {
 544                         case ODEBUG_STATE_ACTIVE:
 545                                 debug_print_object(obj, "free");
 546                                 descr = obj->descr;
 547                                 state = obj->state;
 548                                 spin_unlock_irqrestore(&db->lock, flags);
 549                                 debug_object_fixup(descr->fixup_free,
 550                                                    (void *) oaddr, state);
 551                                 goto repeat;
 552                         default:
 553                                 hlist_del(&obj->node);
 554                                 free_object(obj);
 555                                 break;
 556                         }
 557                 }
 558                 spin_unlock_irqrestore(&db->lock, flags);
 559                 if (cnt > debug_objects_maxchain)
 560                         debug_objects_maxchain = cnt;
 561         }
 562 }
 563
 564 void debug_check_no_obj_freed(const void *address, unsigned long size)
 565 {
 566         if (debug_objects_enabled)
 567                 __debug_check_no_obj_freed(address, size);
 568 }
 569 #endif
 570
 571 #ifdef CONFIG_DEBUG_FS
 572
 573 static int debug_stats_show(struct seq_file *m, void *v)
 574 {
 575         seq_printf(m, "max_chain     :%d\n", debug_objects_maxchain);
 576         seq_printf(m, "warnings      :%d\n", debug_objects_warnings);
 577         seq_printf(m, "fixups        :%d\n", debug_objects_fixups);
 578         seq_printf(m, "pool_free     :%d\n", obj_pool_free);
 579         seq_printf(m, "pool_min_free :%d\n", obj_pool_min_free);
 580         seq_printf(m, "pool_used     :%d\n", obj_pool_used);
 581         seq_printf(m, "pool_max_used :%d\n", obj_pool_max_used);
 582         return 0;
 583 }
 584
 585 static int debug_stats_open(struct inode *inode, struct file *filp)
 586 {
 587         return single_open(filp, debug_stats_show, NULL);
 588 }
 589
 590 static const struct file_operations debug_stats_fops = {
 591         .open           = debug_stats_open,
 592         .read           = seq_read,
 593         .llseek         = seq_lseek,
 594         .release        = single_release,
 595 };
 596
 597 static int __init debug_objects_init_debugfs(void)
 598 {
 599         struct dentry *dbgdir, *dbgstats;
 600
 601         if (!debug_objects_enabled)
 602                 return 0;
 603
 604         dbgdir = debugfs_create_dir("debug_objects", NULL);
 605         if (!dbgdir)
 606                 return -ENOMEM;
 607
 608         dbgstats = debugfs_create_file("stats", 0444, dbgdir, NULL,
 609                                        &debug_stats_fops);
 610         if (!dbgstats)
 611                 goto err;
 612
 613         return 0;
 614
 615 err:
 616         debugfs_remove(dbgdir);
 617
 618         return -ENOMEM;
 619 }
 620 __initcall(debug_objects_init_debugfs);
 621
 622 #else
 623 static inline void debug_objects_init_debugfs(void) { }
 624 #endif
 625
 626 #ifdef CONFIG_DEBUG_OBJECTS_SELFTEST
 627
 628 /* Random data structure for the self test */
 629 struct self_test {
 630         unsigned long   dummy1[6];
 631         int             static_init;
 632         unsigned long   dummy2[3];
 633 };
 634
 635 static __initdata struct debug_obj_descr descr_type_test;
 636
 637 /*
 638  * fixup_init is called when:
 639  * - an active object is initialized
 640  */
 641 static int __init fixup_init(void *addr, enum debug_obj_state state)
 642 {
 643         struct self_test *obj = addr;
 644
 645         switch (state) {
 646         case ODEBUG_STATE_ACTIVE:
 647                 debug_object_deactivate(obj, &descr_type_test);
 648                 debug_object_init(obj, &descr_type_test);
 649                 return 1;
 650         default:
 651                 return 0;
 652         }
 653 }
 654
 655 /*
 656  * fixup_activate is called when:
 657  * - an active object is activated
 658  * - an unknown object is activated (might be a statically initialized object)
 659  */
 660 static int __init fixup_activate(void *addr, enum debug_obj_state state)
 661 {
 662         struct self_test *obj = addr;
 663
 664         switch (state) {
 665         case ODEBUG_STATE_NOTAVAILABLE:
 666                 if (obj->static_init == 1) {
 667                         debug_object_init(obj, &descr_type_test);
 668                         debug_object_activate(obj, &descr_type_test);
 669                         /*
 670                          * Real code should return 0 here ! This is
 671                          * not a fixup of some bad behaviour. We
 672                          * merily call the debug_init function to keep
 673                          * track of the object.
 674                          */
 675                         return 1;
 676                 } else {
 677                         /* Real code needs to emit a warning here */
 678                 }
 679                 return 0;
 680
 681         case ODEBUG_STATE_ACTIVE:
 682                 debug_object_deactivate(obj, &descr_type_test);
 683                 debug_object_activate(obj, &descr_type_test);
 684                 return 1;
 685
 686         default:
 687                 return 0;
 688         }
 689 }
 690
 691 /*
 692  * fixup_destroy is called when:
 693  * - an active object is destroyed
 694  */
 695 static int __init fixup_destroy(void *addr, enum debug_obj_state state)
 696 {
 697         struct self_test *obj = addr;
 698
 699         switch (state) {
 700         case ODEBUG_STATE_ACTIVE:
 701                 debug_object_deactivate(obj, &descr_type_test);
 702                 debug_object_destroy(obj, &descr_type_test);
 703                 return 1;
 704         default:
 705                 return 0;
 706         }
 707 }
 708
 709 /*
 710  * fixup_free is called when:
 711  * - an active object is freed
 712  */
 713 static int __init fixup_free(void *addr, enum debug_obj_state state)
 714 {
 715         struct self_test *obj = addr;
 716
 717         switch (state) {
 718         case ODEBUG_STATE_ACTIVE:
 719                 debug_object_deactivate(obj, &descr_type_test);
 720                 debug_object_free(obj, &descr_type_test);
 721                 return 1;
 722         default:
 723                 return 0;
 724         }
 725 }
 726
 727 static int
 728 check_results(void *addr, enum debug_obj_state state, int fixups, int warnings)
 729 {
 730         struct debug_bucket *db;
 731         struct debug_obj *obj;
 732         unsigned long flags;
 733         int res = -EINVAL;
 734
 735         db = get_bucket((unsigned long) addr);
 736
 737         spin_lock_irqsave(&db->lock, flags);
 738
 739         obj = lookup_object(addr, db);
 740         if (!obj && state != ODEBUG_STATE_NONE) {
 741                 printk(KERN_ERR "ODEBUG: selftest object not found\n");
 742                 WARN_ON(1);
 743                 goto out;
 744         }
 745         if (obj && obj->state != state) {
 746                 printk(KERN_ERR "ODEBUG: selftest wrong state: %d != %d\n",
 747                        obj->state, state);
 748                 WARN_ON(1);
 749                 goto out;
 750         }
 751         if (fixups != debug_objects_fixups) {
 752                 printk(KERN_ERR "ODEBUG: selftest fixups failed %d != %d\n",
 753                        fixups, debug_objects_fixups);
 754                 WARN_ON(1);
 755                 goto out;
 756         }
 757         if (warnings != debug_objects_warnings) {
 758                 printk(KERN_ERR "ODEBUG: selftest warnings failed %d != %d\n",
 759                        warnings, debug_objects_warnings);
 760                 WARN_ON(1);
 761                 goto out;
 762         }
 763         res = 0;
 764 out:
 765         spin_unlock_irqrestore(&db->lock, flags);
 766         if (res)
 767                 debug_objects_enabled = 0;
 768         return res;
 769 }
 770
 771 static __initdata struct debug_obj_descr descr_type_test = {
 772         .name                   = "selftest",
 773         .fixup_init             = fixup_init,
 774         .fixup_activate         = fixup_activate,
 775         .fixup_destroy          = fixup_destroy,
 776         .fixup_free             = fixup_free,
 777 };
 778
 779 static __initdata struct self_test obj = { .static_init = 0 };
 780
 781 static void __init debug_objects_selftest(void)
 782 {
 783         int fixups, oldfixups, warnings, oldwarnings;
 784         unsigned long flags;
 785
 786         local_irq_save(flags);
 787
 788         fixups = oldfixups = debug_objects_fixups;
 789         warnings = oldwarnings = debug_objects_warnings;
 790         descr_test = &descr_type_test;
 791
 792         debug_object_init(&obj, &descr_type_test);
 793         if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
 794                 goto out;
 795         debug_object_activate(&obj, &descr_type_test);
 796         if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
 797                 goto out;
 798         debug_object_activate(&obj, &descr_type_test);
 799         if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, ++warnings))
 800                 goto out;
 801         debug_object_deactivate(&obj, &descr_type_test);
 802         if (check_results(&obj, ODEBUG_STATE_INACTIVE, fixups, warnings))
 803                 goto out;
 804         debug_object_destroy(&obj, &descr_type_test);
 805         if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, warnings))
 806                 goto out;
 807         debug_object_init(&obj, &descr_type_test);
 808         if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
 809                 goto out;
 810         debug_object_activate(&obj, &descr_type_test);
 811         if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
 812                 goto out;
 813         debug_object_deactivate(&obj, &descr_type_test);
 814         if (check_results(&obj, ODEBUG_STATE_DESTROYED, fixups, ++warnings))
 815                 goto out;
 816         debug_object_free(&obj, &descr_type_test);
 817         if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
 818                 goto out;
 819
 820         obj.static_init = 1;
 821         debug_object_activate(&obj, &descr_type_test);
 822         if (check_results(&obj, ODEBUG_STATE_ACTIVE, ++fixups, warnings))
 823                 goto out;
 824         debug_object_init(&obj, &descr_type_test);
 825         if (check_results(&obj, ODEBUG_STATE_INIT, ++fixups, ++warnings))
 826                 goto out;
 827         debug_object_free(&obj, &descr_type_test);
 828         if (check_results(&obj, ODEBUG_STATE_NONE, fixups, warnings))
 829                 goto out;
 830
 831 #ifdef CONFIG_DEBUG_OBJECTS_FREE
 832         debug_object_init(&obj, &descr_type_test);
 833         if (check_results(&obj, ODEBUG_STATE_INIT, fixups, warnings))
 834                 goto out;
 835         debug_object_activate(&obj, &descr_type_test);
 836         if (check_results(&obj, ODEBUG_STATE_ACTIVE, fixups, warnings))
 837                 goto out;
 838         __debug_check_no_obj_freed(&obj, sizeof(obj));
 839         if (check_results(&obj, ODEBUG_STATE_NONE, ++fixups, ++warnings))
 840                 goto out;
 841 #endif
 842         printk(KERN_INFO "ODEBUG: selftest passed\n");
 843
 844 out:
 845         debug_objects_fixups = oldfixups;
 846         debug_objects_warnings = oldwarnings;
 847         descr_test = NULL;
 848
 849         local_irq_restore(flags);
 850 }
 851 #else
 852 static inline void debug_objects_selftest(void) { }
 853 #endif
 854
 855 /*
 856  * Called during early boot to initialize the hash buckets and link
 857  * the static object pool objects into the poll list. After this call
 858  * the object tracker is fully operational.
 859  */
 860 void __init debug_objects_early_init(void)
 861 {
 862         int i;
 863
 864         for (i = 0; i < ODEBUG_HASH_SIZE; i++)
 865                 spin_lock_init(&obj_hash[i].lock);
 866
 867         for (i = 0; i < ODEBUG_POOL_SIZE; i++)
 868                 hlist_add_head(&obj_static_pool[i].node, &obj_pool);
 869 }
 870
 871 /*
 872  * Called after the kmem_caches are functional to setup a dedicated
 873  * cache pool, which has the SLAB_DEBUG_OBJECTS flag set. This flag
 874  * prevents that the debug code is called on kmem_cache_free() for the
 875  * debug tracker objects to avoid recursive calls.
 876  */
 877 void __init debug_objects_mem_init(void)
 878 {
 879         if (!debug_objects_enabled)
 880                 return;
 881
 882         obj_cache = kmem_cache_create("debug_objects_cache",
 883                                       sizeof (struct debug_obj), 0,
 884                                       SLAB_DEBUG_OBJECTS, NULL);
 885
 886         if (!obj_cache)
 887                 debug_objects_enabled = 0;
 888         else
 889                 debug_objects_selftest();
 890 }