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