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