1 /* 2 * kernel/lockdep_proc.c 3 * 4 * Runtime locking correctness validator 5 * 6 * Started by Ingo Molnar: 7 * 8 * Copyright (C) 2006,2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com> 9 * Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra <pzijlstr@redhat.com> 10 * 11 * Code for /proc/lockdep and /proc/lockdep_stats: 12 * 13 */ 14 #include <linux/export.h> 15 #include <linux/proc_fs.h> 16 #include <linux/seq_file.h> 17 #include <linux/kallsyms.h> 18 #include <linux/debug_locks.h> 19 #include <linux/vmalloc.h> 20 #include <linux/sort.h> 21 #include <asm/uaccess.h> 22 #include <asm/div64.h> 23 24 #include "lockdep_internals.h" 25 26 static void *l_next(struct seq_file *m, void *v, loff_t *pos) 27 { 28 return seq_list_next(v, &all_lock_classes, pos); 29 } 30 31 static void *l_start(struct seq_file *m, loff_t *pos) 32 { 33 return seq_list_start_head(&all_lock_classes, *pos); 34 } 35 36 static void l_stop(struct seq_file *m, void *v) 37 { 38 } 39 40 static void print_name(struct seq_file *m, struct lock_class *class) 41 { 42 char str[KSYM_NAME_LEN]; 43 const char *name = class->name; 44 45 if (!name) { 46 name = __get_key_name(class->key, str); 47 seq_printf(m, "%s", name); 48 } else{ 49 seq_printf(m, "%s", name); 50 if (class->name_version > 1) 51 seq_printf(m, "#%d", class->name_version); 52 if (class->subclass) 53 seq_printf(m, "/%d", class->subclass); 54 } 55 } 56 57 static int l_show(struct seq_file *m, void *v) 58 { 59 struct lock_class *class = list_entry(v, struct lock_class, lock_entry); 60 struct lock_list *entry; 61 char usage[LOCK_USAGE_CHARS]; 62 63 if (v == &all_lock_classes) { 64 seq_printf(m, "all lock classes:\n"); 65 return 0; 66 } 67 68 seq_printf(m, "%p", class->key); 69 #ifdef CONFIG_DEBUG_LOCKDEP 70 seq_printf(m, " OPS:%8ld", class->ops); 71 #endif 72 #ifdef CONFIG_PROVE_LOCKING 73 seq_printf(m, " FD:%5ld", lockdep_count_forward_deps(class)); 74 seq_printf(m, " BD:%5ld", lockdep_count_backward_deps(class)); 75 #endif 76 77 get_usage_chars(class, usage); 78 seq_printf(m, " %s", usage); 79 80 seq_printf(m, ": "); 81 print_name(m, class); 82 seq_puts(m, "\n"); 83 84 list_for_each_entry(entry, &class->locks_after, entry) { 85 if (entry->distance == 1) { 86 seq_printf(m, " -> [%p] ", entry->class->key); 87 print_name(m, entry->class); 88 seq_puts(m, "\n"); 89 } 90 } 91 seq_puts(m, "\n"); 92 93 return 0; 94 } 95 96 static const struct seq_operations lockdep_ops = { 97 .start = l_start, 98 .next = l_next, 99 .stop = l_stop, 100 .show = l_show, 101 }; 102 103 static int lockdep_open(struct inode *inode, struct file *file) 104 { 105 return seq_open(file, &lockdep_ops); 106 } 107 108 static const struct file_operations proc_lockdep_operations = { 109 .open = lockdep_open, 110 .read = seq_read, 111 .llseek = seq_lseek, 112 .release = seq_release, 113 }; 114 115 #ifdef CONFIG_PROVE_LOCKING 116 static void *lc_start(struct seq_file *m, loff_t *pos) 117 { 118 if (*pos == 0) 119 return SEQ_START_TOKEN; 120 121 if (*pos - 1 < nr_lock_chains) 122 return lock_chains + (*pos - 1); 123 124 return NULL; 125 } 126 127 static void *lc_next(struct seq_file *m, void *v, loff_t *pos) 128 { 129 (*pos)++; 130 return lc_start(m, pos); 131 } 132 133 static void lc_stop(struct seq_file *m, void *v) 134 { 135 } 136 137 static int lc_show(struct seq_file *m, void *v) 138 { 139 struct lock_chain *chain = v; 140 struct lock_class *class; 141 int i; 142 143 if (v == SEQ_START_TOKEN) { 144 seq_printf(m, "all lock chains:\n"); 145 return 0; 146 } 147 148 seq_printf(m, "irq_context: %d\n", chain->irq_context); 149 150 for (i = 0; i < chain->depth; i++) { 151 class = lock_chain_get_class(chain, i); 152 if (!class->key) 153 continue; 154 155 seq_printf(m, "[%p] ", class->key); 156 print_name(m, class); 157 seq_puts(m, "\n"); 158 } 159 seq_puts(m, "\n"); 160 161 return 0; 162 } 163 164 static const struct seq_operations lockdep_chains_ops = { 165 .start = lc_start, 166 .next = lc_next, 167 .stop = lc_stop, 168 .show = lc_show, 169 }; 170 171 static int lockdep_chains_open(struct inode *inode, struct file *file) 172 { 173 return seq_open(file, &lockdep_chains_ops); 174 } 175 176 static const struct file_operations proc_lockdep_chains_operations = { 177 .open = lockdep_chains_open, 178 .read = seq_read, 179 .llseek = seq_lseek, 180 .release = seq_release, 181 }; 182 #endif /* CONFIG_PROVE_LOCKING */ 183 184 static void lockdep_stats_debug_show(struct seq_file *m) 185 { 186 #ifdef CONFIG_DEBUG_LOCKDEP 187 unsigned long long hi1 = debug_atomic_read(hardirqs_on_events), 188 hi2 = debug_atomic_read(hardirqs_off_events), 189 hr1 = debug_atomic_read(redundant_hardirqs_on), 190 hr2 = debug_atomic_read(redundant_hardirqs_off), 191 si1 = debug_atomic_read(softirqs_on_events), 192 si2 = debug_atomic_read(softirqs_off_events), 193 sr1 = debug_atomic_read(redundant_softirqs_on), 194 sr2 = debug_atomic_read(redundant_softirqs_off); 195 196 seq_printf(m, " chain lookup misses: %11llu\n", 197 debug_atomic_read(chain_lookup_misses)); 198 seq_printf(m, " chain lookup hits: %11llu\n", 199 debug_atomic_read(chain_lookup_hits)); 200 seq_printf(m, " cyclic checks: %11llu\n", 201 debug_atomic_read(nr_cyclic_checks)); 202 seq_printf(m, " find-mask forwards checks: %11llu\n", 203 debug_atomic_read(nr_find_usage_forwards_checks)); 204 seq_printf(m, " find-mask backwards checks: %11llu\n", 205 debug_atomic_read(nr_find_usage_backwards_checks)); 206 207 seq_printf(m, " hardirq on events: %11llu\n", hi1); 208 seq_printf(m, " hardirq off events: %11llu\n", hi2); 209 seq_printf(m, " redundant hardirq ons: %11llu\n", hr1); 210 seq_printf(m, " redundant hardirq offs: %11llu\n", hr2); 211 seq_printf(m, " softirq on events: %11llu\n", si1); 212 seq_printf(m, " softirq off events: %11llu\n", si2); 213 seq_printf(m, " redundant softirq ons: %11llu\n", sr1); 214 seq_printf(m, " redundant softirq offs: %11llu\n", sr2); 215 #endif 216 } 217 218 static int lockdep_stats_show(struct seq_file *m, void *v) 219 { 220 struct lock_class *class; 221 unsigned long nr_unused = 0, nr_uncategorized = 0, 222 nr_irq_safe = 0, nr_irq_unsafe = 0, 223 nr_softirq_safe = 0, nr_softirq_unsafe = 0, 224 nr_hardirq_safe = 0, nr_hardirq_unsafe = 0, 225 nr_irq_read_safe = 0, nr_irq_read_unsafe = 0, 226 nr_softirq_read_safe = 0, nr_softirq_read_unsafe = 0, 227 nr_hardirq_read_safe = 0, nr_hardirq_read_unsafe = 0, 228 sum_forward_deps = 0; 229 230 list_for_each_entry(class, &all_lock_classes, lock_entry) { 231 232 if (class->usage_mask == 0) 233 nr_unused++; 234 if (class->usage_mask == LOCKF_USED) 235 nr_uncategorized++; 236 if (class->usage_mask & LOCKF_USED_IN_IRQ) 237 nr_irq_safe++; 238 if (class->usage_mask & LOCKF_ENABLED_IRQ) 239 nr_irq_unsafe++; 240 if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ) 241 nr_softirq_safe++; 242 if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ) 243 nr_softirq_unsafe++; 244 if (class->usage_mask & LOCKF_USED_IN_HARDIRQ) 245 nr_hardirq_safe++; 246 if (class->usage_mask & LOCKF_ENABLED_HARDIRQ) 247 nr_hardirq_unsafe++; 248 if (class->usage_mask & LOCKF_USED_IN_IRQ_READ) 249 nr_irq_read_safe++; 250 if (class->usage_mask & LOCKF_ENABLED_IRQ_READ) 251 nr_irq_read_unsafe++; 252 if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ) 253 nr_softirq_read_safe++; 254 if (class->usage_mask & LOCKF_ENABLED_SOFTIRQ_READ) 255 nr_softirq_read_unsafe++; 256 if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ) 257 nr_hardirq_read_safe++; 258 if (class->usage_mask & LOCKF_ENABLED_HARDIRQ_READ) 259 nr_hardirq_read_unsafe++; 260 261 #ifdef CONFIG_PROVE_LOCKING 262 sum_forward_deps += lockdep_count_forward_deps(class); 263 #endif 264 } 265 #ifdef CONFIG_DEBUG_LOCKDEP 266 DEBUG_LOCKS_WARN_ON(debug_atomic_read(nr_unused_locks) != nr_unused); 267 #endif 268 seq_printf(m, " lock-classes: %11lu [max: %lu]\n", 269 nr_lock_classes, MAX_LOCKDEP_KEYS); 270 seq_printf(m, " direct dependencies: %11lu [max: %lu]\n", 271 nr_list_entries, MAX_LOCKDEP_ENTRIES); 272 seq_printf(m, " indirect dependencies: %11lu\n", 273 sum_forward_deps); 274 275 /* 276 * Total number of dependencies: 277 * 278 * All irq-safe locks may nest inside irq-unsafe locks, 279 * plus all the other known dependencies: 280 */ 281 seq_printf(m, " all direct dependencies: %11lu\n", 282 nr_irq_unsafe * nr_irq_safe + 283 nr_hardirq_unsafe * nr_hardirq_safe + 284 nr_list_entries); 285 286 #ifdef CONFIG_PROVE_LOCKING 287 seq_printf(m, " dependency chains: %11lu [max: %lu]\n", 288 nr_lock_chains, MAX_LOCKDEP_CHAINS); 289 seq_printf(m, " dependency chain hlocks: %11d [max: %lu]\n", 290 nr_chain_hlocks, MAX_LOCKDEP_CHAIN_HLOCKS); 291 #endif 292 293 #ifdef CONFIG_TRACE_IRQFLAGS 294 seq_printf(m, " in-hardirq chains: %11u\n", 295 nr_hardirq_chains); 296 seq_printf(m, " in-softirq chains: %11u\n", 297 nr_softirq_chains); 298 #endif 299 seq_printf(m, " in-process chains: %11u\n", 300 nr_process_chains); 301 seq_printf(m, " stack-trace entries: %11lu [max: %lu]\n", 302 nr_stack_trace_entries, MAX_STACK_TRACE_ENTRIES); 303 seq_printf(m, " combined max dependencies: %11u\n", 304 (nr_hardirq_chains + 1) * 305 (nr_softirq_chains + 1) * 306 (nr_process_chains + 1) 307 ); 308 seq_printf(m, " hardirq-safe locks: %11lu\n", 309 nr_hardirq_safe); 310 seq_printf(m, " hardirq-unsafe locks: %11lu\n", 311 nr_hardirq_unsafe); 312 seq_printf(m, " softirq-safe locks: %11lu\n", 313 nr_softirq_safe); 314 seq_printf(m, " softirq-unsafe locks: %11lu\n", 315 nr_softirq_unsafe); 316 seq_printf(m, " irq-safe locks: %11lu\n", 317 nr_irq_safe); 318 seq_printf(m, " irq-unsafe locks: %11lu\n", 319 nr_irq_unsafe); 320 321 seq_printf(m, " hardirq-read-safe locks: %11lu\n", 322 nr_hardirq_read_safe); 323 seq_printf(m, " hardirq-read-unsafe locks: %11lu\n", 324 nr_hardirq_read_unsafe); 325 seq_printf(m, " softirq-read-safe locks: %11lu\n", 326 nr_softirq_read_safe); 327 seq_printf(m, " softirq-read-unsafe locks: %11lu\n", 328 nr_softirq_read_unsafe); 329 seq_printf(m, " irq-read-safe locks: %11lu\n", 330 nr_irq_read_safe); 331 seq_printf(m, " irq-read-unsafe locks: %11lu\n", 332 nr_irq_read_unsafe); 333 334 seq_printf(m, " uncategorized locks: %11lu\n", 335 nr_uncategorized); 336 seq_printf(m, " unused locks: %11lu\n", 337 nr_unused); 338 seq_printf(m, " max locking depth: %11u\n", 339 max_lockdep_depth); 340 #ifdef CONFIG_PROVE_LOCKING 341 seq_printf(m, " max bfs queue depth: %11u\n", 342 max_bfs_queue_depth); 343 #endif 344 lockdep_stats_debug_show(m); 345 seq_printf(m, " debug_locks: %11u\n", 346 debug_locks); 347 348 return 0; 349 } 350 351 static int lockdep_stats_open(struct inode *inode, struct file *file) 352 { 353 return single_open(file, lockdep_stats_show, NULL); 354 } 355 356 static const struct file_operations proc_lockdep_stats_operations = { 357 .open = lockdep_stats_open, 358 .read = seq_read, 359 .llseek = seq_lseek, 360 .release = single_release, 361 }; 362 363 #ifdef CONFIG_LOCK_STAT 364 365 struct lock_stat_data { 366 struct lock_class *class; 367 struct lock_class_stats stats; 368 }; 369 370 struct lock_stat_seq { 371 struct lock_stat_data *iter_end; 372 struct lock_stat_data stats[MAX_LOCKDEP_KEYS]; 373 }; 374 375 /* 376 * sort on absolute number of contentions 377 */ 378 static int lock_stat_cmp(const void *l, const void *r) 379 { 380 const struct lock_stat_data *dl = l, *dr = r; 381 unsigned long nl, nr; 382 383 nl = dl->stats.read_waittime.nr + dl->stats.write_waittime.nr; 384 nr = dr->stats.read_waittime.nr + dr->stats.write_waittime.nr; 385 386 return nr - nl; 387 } 388 389 static void seq_line(struct seq_file *m, char c, int offset, int length) 390 { 391 int i; 392 393 for (i = 0; i < offset; i++) 394 seq_puts(m, " "); 395 for (i = 0; i < length; i++) 396 seq_printf(m, "%c", c); 397 seq_puts(m, "\n"); 398 } 399 400 static void snprint_time(char *buf, size_t bufsiz, s64 nr) 401 { 402 s64 div; 403 s32 rem; 404 405 nr += 5; /* for display rounding */ 406 div = div_s64_rem(nr, 1000, &rem); 407 snprintf(buf, bufsiz, "%lld.%02d", (long long)div, (int)rem/10); 408 } 409 410 static void seq_time(struct seq_file *m, s64 time) 411 { 412 char num[15]; 413 414 snprint_time(num, sizeof(num), time); 415 seq_printf(m, " %14s", num); 416 } 417 418 static void seq_lock_time(struct seq_file *m, struct lock_time *lt) 419 { 420 seq_printf(m, "%14lu", lt->nr); 421 seq_time(m, lt->min); 422 seq_time(m, lt->max); 423 seq_time(m, lt->total); 424 seq_time(m, lt->nr ? div_s64(lt->total, lt->nr) : 0); 425 } 426 427 static void seq_stats(struct seq_file *m, struct lock_stat_data *data) 428 { 429 struct lockdep_subclass_key *ckey; 430 struct lock_class_stats *stats; 431 struct lock_class *class; 432 const char *cname; 433 int i, namelen; 434 char name[39]; 435 436 class = data->class; 437 stats = &data->stats; 438 439 namelen = 38; 440 if (class->name_version > 1) 441 namelen -= 2; /* XXX truncates versions > 9 */ 442 if (class->subclass) 443 namelen -= 2; 444 445 rcu_read_lock_sched(); 446 cname = rcu_dereference_sched(class->name); 447 ckey = rcu_dereference_sched(class->key); 448 449 if (!cname && !ckey) { 450 rcu_read_unlock_sched(); 451 return; 452 453 } else if (!cname) { 454 char str[KSYM_NAME_LEN]; 455 const char *key_name; 456 457 key_name = __get_key_name(ckey, str); 458 snprintf(name, namelen, "%s", key_name); 459 } else { 460 snprintf(name, namelen, "%s", cname); 461 } 462 rcu_read_unlock_sched(); 463 464 namelen = strlen(name); 465 if (class->name_version > 1) { 466 snprintf(name+namelen, 3, "#%d", class->name_version); 467 namelen += 2; 468 } 469 if (class->subclass) { 470 snprintf(name+namelen, 3, "/%d", class->subclass); 471 namelen += 2; 472 } 473 474 if (stats->write_holdtime.nr) { 475 if (stats->read_holdtime.nr) 476 seq_printf(m, "%38s-W:", name); 477 else 478 seq_printf(m, "%40s:", name); 479 480 seq_printf(m, "%14lu ", stats->bounces[bounce_contended_write]); 481 seq_lock_time(m, &stats->write_waittime); 482 seq_printf(m, " %14lu ", stats->bounces[bounce_acquired_write]); 483 seq_lock_time(m, &stats->write_holdtime); 484 seq_puts(m, "\n"); 485 } 486 487 if (stats->read_holdtime.nr) { 488 seq_printf(m, "%38s-R:", name); 489 seq_printf(m, "%14lu ", stats->bounces[bounce_contended_read]); 490 seq_lock_time(m, &stats->read_waittime); 491 seq_printf(m, " %14lu ", stats->bounces[bounce_acquired_read]); 492 seq_lock_time(m, &stats->read_holdtime); 493 seq_puts(m, "\n"); 494 } 495 496 if (stats->read_waittime.nr + stats->write_waittime.nr == 0) 497 return; 498 499 if (stats->read_holdtime.nr) 500 namelen += 2; 501 502 for (i = 0; i < LOCKSTAT_POINTS; i++) { 503 char ip[32]; 504 505 if (class->contention_point[i] == 0) 506 break; 507 508 if (!i) 509 seq_line(m, '-', 40-namelen, namelen); 510 511 snprintf(ip, sizeof(ip), "[<%p>]", 512 (void *)class->contention_point[i]); 513 seq_printf(m, "%40s %14lu %29s %pS\n", 514 name, stats->contention_point[i], 515 ip, (void *)class->contention_point[i]); 516 } 517 for (i = 0; i < LOCKSTAT_POINTS; i++) { 518 char ip[32]; 519 520 if (class->contending_point[i] == 0) 521 break; 522 523 if (!i) 524 seq_line(m, '-', 40-namelen, namelen); 525 526 snprintf(ip, sizeof(ip), "[<%p>]", 527 (void *)class->contending_point[i]); 528 seq_printf(m, "%40s %14lu %29s %pS\n", 529 name, stats->contending_point[i], 530 ip, (void *)class->contending_point[i]); 531 } 532 if (i) { 533 seq_puts(m, "\n"); 534 seq_line(m, '.', 0, 40 + 1 + 12 * (14 + 1)); 535 seq_puts(m, "\n"); 536 } 537 } 538 539 static void seq_header(struct seq_file *m) 540 { 541 seq_puts(m, "lock_stat version 0.4\n"); 542 543 if (unlikely(!debug_locks)) 544 seq_printf(m, "*WARNING* lock debugging disabled!! - possibly due to a lockdep warning\n"); 545 546 seq_line(m, '-', 0, 40 + 1 + 12 * (14 + 1)); 547 seq_printf(m, "%40s %14s %14s %14s %14s %14s %14s %14s %14s %14s %14s " 548 "%14s %14s\n", 549 "class name", 550 "con-bounces", 551 "contentions", 552 "waittime-min", 553 "waittime-max", 554 "waittime-total", 555 "waittime-avg", 556 "acq-bounces", 557 "acquisitions", 558 "holdtime-min", 559 "holdtime-max", 560 "holdtime-total", 561 "holdtime-avg"); 562 seq_line(m, '-', 0, 40 + 1 + 12 * (14 + 1)); 563 seq_printf(m, "\n"); 564 } 565 566 static void *ls_start(struct seq_file *m, loff_t *pos) 567 { 568 struct lock_stat_seq *data = m->private; 569 struct lock_stat_data *iter; 570 571 if (*pos == 0) 572 return SEQ_START_TOKEN; 573 574 iter = data->stats + (*pos - 1); 575 if (iter >= data->iter_end) 576 iter = NULL; 577 578 return iter; 579 } 580 581 static void *ls_next(struct seq_file *m, void *v, loff_t *pos) 582 { 583 (*pos)++; 584 return ls_start(m, pos); 585 } 586 587 static void ls_stop(struct seq_file *m, void *v) 588 { 589 } 590 591 static int ls_show(struct seq_file *m, void *v) 592 { 593 if (v == SEQ_START_TOKEN) 594 seq_header(m); 595 else 596 seq_stats(m, v); 597 598 return 0; 599 } 600 601 static const struct seq_operations lockstat_ops = { 602 .start = ls_start, 603 .next = ls_next, 604 .stop = ls_stop, 605 .show = ls_show, 606 }; 607 608 static int lock_stat_open(struct inode *inode, struct file *file) 609 { 610 int res; 611 struct lock_class *class; 612 struct lock_stat_seq *data = vmalloc(sizeof(struct lock_stat_seq)); 613 614 if (!data) 615 return -ENOMEM; 616 617 res = seq_open(file, &lockstat_ops); 618 if (!res) { 619 struct lock_stat_data *iter = data->stats; 620 struct seq_file *m = file->private_data; 621 622 list_for_each_entry(class, &all_lock_classes, lock_entry) { 623 iter->class = class; 624 iter->stats = lock_stats(class); 625 iter++; 626 } 627 data->iter_end = iter; 628 629 sort(data->stats, data->iter_end - data->stats, 630 sizeof(struct lock_stat_data), 631 lock_stat_cmp, NULL); 632 633 m->private = data; 634 } else 635 vfree(data); 636 637 return res; 638 } 639 640 static ssize_t lock_stat_write(struct file *file, const char __user *buf, 641 size_t count, loff_t *ppos) 642 { 643 struct lock_class *class; 644 char c; 645 646 if (count) { 647 if (get_user(c, buf)) 648 return -EFAULT; 649 650 if (c != '0') 651 return count; 652 653 list_for_each_entry(class, &all_lock_classes, lock_entry) 654 clear_lock_stats(class); 655 } 656 return count; 657 } 658 659 static int lock_stat_release(struct inode *inode, struct file *file) 660 { 661 struct seq_file *seq = file->private_data; 662 663 vfree(seq->private); 664 return seq_release(inode, file); 665 } 666 667 static const struct file_operations proc_lock_stat_operations = { 668 .open = lock_stat_open, 669 .write = lock_stat_write, 670 .read = seq_read, 671 .llseek = seq_lseek, 672 .release = lock_stat_release, 673 }; 674 #endif /* CONFIG_LOCK_STAT */ 675 676 static int __init lockdep_proc_init(void) 677 { 678 proc_create("lockdep", S_IRUSR, NULL, &proc_lockdep_operations); 679 #ifdef CONFIG_PROVE_LOCKING 680 proc_create("lockdep_chains", S_IRUSR, NULL, 681 &proc_lockdep_chains_operations); 682 #endif 683 proc_create("lockdep_stats", S_IRUSR, NULL, 684 &proc_lockdep_stats_operations); 685 686 #ifdef CONFIG_LOCK_STAT 687 proc_create("lock_stat", S_IRUSR | S_IWUSR, NULL, 688 &proc_lock_stat_operations); 689 #endif 690 691 return 0; 692 } 693 694 __initcall(lockdep_proc_init); 695 696