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