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