lib/debugobjects.c

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