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