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