2 * kernel/lockdep_proc.c
4 * Runtime locking correctness validator
6 * Started by Ingo Molnar:
8 * Copyright (C) 2006,2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
9 * Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra
11 * Code for /proc/lockdep and /proc/lockdep_stats:
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 <linux/uaccess.h>
22 #include <asm/div64.h>
24 #include "lockdep_internals.h"
26 static void *l_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
28 return seq_list_next(v
, &all_lock_classes
, pos
);
31 static void *l_start(struct seq_file
*m
, loff_t
*pos
)
33 return seq_list_start_head(&all_lock_classes
, *pos
);
36 static void l_stop(struct seq_file
*m
, void *v
)
40 static void print_name(struct seq_file
*m
, struct lock_class
*class)
42 char str
[KSYM_NAME_LEN
];
43 const char *name
= class->name
;
46 name
= __get_key_name(class->key
, str
);
47 seq_printf(m
, "%s", name
);
49 seq_printf(m
, "%s", name
);
50 if (class->name_version
> 1)
51 seq_printf(m
, "#%d", class->name_version
);
53 seq_printf(m
, "/%d", class->subclass
);
57 static int l_show(struct seq_file
*m
, void *v
)
59 struct lock_class
*class = list_entry(v
, struct lock_class
, lock_entry
);
60 struct lock_list
*entry
;
61 char usage
[LOCK_USAGE_CHARS
];
63 if (v
== &all_lock_classes
) {
64 seq_printf(m
, "all lock classes:\n");
68 seq_printf(m
, "%p", class->key
);
69 #ifdef CONFIG_DEBUG_LOCKDEP
70 seq_printf(m
, " OPS:%8ld", class->ops
);
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));
77 get_usage_chars(class, usage
);
78 seq_printf(m
, " %s", usage
);
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);
96 static const struct seq_operations lockdep_ops
= {
103 static int lockdep_open(struct inode
*inode
, struct file
*file
)
105 return seq_open(file
, &lockdep_ops
);
108 static const struct file_operations proc_lockdep_operations
= {
109 .open
= lockdep_open
,
112 .release
= seq_release
,
115 #ifdef CONFIG_PROVE_LOCKING
116 static void *lc_start(struct seq_file
*m
, loff_t
*pos
)
119 return SEQ_START_TOKEN
;
121 if (*pos
- 1 < nr_lock_chains
)
122 return lock_chains
+ (*pos
- 1);
127 static void *lc_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
130 return lc_start(m
, pos
);
133 static void lc_stop(struct seq_file
*m
, void *v
)
137 static int lc_show(struct seq_file
*m
, void *v
)
139 struct lock_chain
*chain
= v
;
140 struct lock_class
*class;
143 if (v
== SEQ_START_TOKEN
) {
144 if (nr_chain_hlocks
> MAX_LOCKDEP_CHAIN_HLOCKS
)
145 seq_printf(m
, "(buggered) ");
146 seq_printf(m
, "all lock chains:\n");
150 seq_printf(m
, "irq_context: %d\n", chain
->irq_context
);
152 for (i
= 0; i
< chain
->depth
; i
++) {
153 class = lock_chain_get_class(chain
, i
);
157 seq_printf(m
, "[%p] ", class->key
);
158 print_name(m
, class);
166 static const struct seq_operations lockdep_chains_ops
= {
173 static int lockdep_chains_open(struct inode
*inode
, struct file
*file
)
175 return seq_open(file
, &lockdep_chains_ops
);
178 static const struct file_operations proc_lockdep_chains_operations
= {
179 .open
= lockdep_chains_open
,
182 .release
= seq_release
,
184 #endif /* CONFIG_PROVE_LOCKING */
186 static void lockdep_stats_debug_show(struct seq_file
*m
)
188 #ifdef CONFIG_DEBUG_LOCKDEP
189 unsigned long long hi1
= debug_atomic_read(hardirqs_on_events
),
190 hi2
= debug_atomic_read(hardirqs_off_events
),
191 hr1
= debug_atomic_read(redundant_hardirqs_on
),
192 hr2
= debug_atomic_read(redundant_hardirqs_off
),
193 si1
= debug_atomic_read(softirqs_on_events
),
194 si2
= debug_atomic_read(softirqs_off_events
),
195 sr1
= debug_atomic_read(redundant_softirqs_on
),
196 sr2
= debug_atomic_read(redundant_softirqs_off
);
198 seq_printf(m
, " chain lookup misses: %11llu\n",
199 debug_atomic_read(chain_lookup_misses
));
200 seq_printf(m
, " chain lookup hits: %11llu\n",
201 debug_atomic_read(chain_lookup_hits
));
202 seq_printf(m
, " cyclic checks: %11llu\n",
203 debug_atomic_read(nr_cyclic_checks
));
204 seq_printf(m
, " redundant checks: %11llu\n",
205 debug_atomic_read(nr_redundant_checks
));
206 seq_printf(m
, " redundant links: %11llu\n",
207 debug_atomic_read(nr_redundant
));
208 seq_printf(m
, " find-mask forwards checks: %11llu\n",
209 debug_atomic_read(nr_find_usage_forwards_checks
));
210 seq_printf(m
, " find-mask backwards checks: %11llu\n",
211 debug_atomic_read(nr_find_usage_backwards_checks
));
213 seq_printf(m
, " hardirq on events: %11llu\n", hi1
);
214 seq_printf(m
, " hardirq off events: %11llu\n", hi2
);
215 seq_printf(m
, " redundant hardirq ons: %11llu\n", hr1
);
216 seq_printf(m
, " redundant hardirq offs: %11llu\n", hr2
);
217 seq_printf(m
, " softirq on events: %11llu\n", si1
);
218 seq_printf(m
, " softirq off events: %11llu\n", si2
);
219 seq_printf(m
, " redundant softirq ons: %11llu\n", sr1
);
220 seq_printf(m
, " redundant softirq offs: %11llu\n", sr2
);
224 static int lockdep_stats_show(struct seq_file
*m
, void *v
)
226 struct lock_class
*class;
227 unsigned long nr_unused
= 0, nr_uncategorized
= 0,
228 nr_irq_safe
= 0, nr_irq_unsafe
= 0,
229 nr_softirq_safe
= 0, nr_softirq_unsafe
= 0,
230 nr_hardirq_safe
= 0, nr_hardirq_unsafe
= 0,
231 nr_irq_read_safe
= 0, nr_irq_read_unsafe
= 0,
232 nr_softirq_read_safe
= 0, nr_softirq_read_unsafe
= 0,
233 nr_hardirq_read_safe
= 0, nr_hardirq_read_unsafe
= 0,
234 sum_forward_deps
= 0;
236 list_for_each_entry(class, &all_lock_classes
, lock_entry
) {
238 if (class->usage_mask
== 0)
240 if (class->usage_mask
== LOCKF_USED
)
242 if (class->usage_mask
& LOCKF_USED_IN_IRQ
)
244 if (class->usage_mask
& LOCKF_ENABLED_IRQ
)
246 if (class->usage_mask
& LOCKF_USED_IN_SOFTIRQ
)
248 if (class->usage_mask
& LOCKF_ENABLED_SOFTIRQ
)
250 if (class->usage_mask
& LOCKF_USED_IN_HARDIRQ
)
252 if (class->usage_mask
& LOCKF_ENABLED_HARDIRQ
)
254 if (class->usage_mask
& LOCKF_USED_IN_IRQ_READ
)
256 if (class->usage_mask
& LOCKF_ENABLED_IRQ_READ
)
257 nr_irq_read_unsafe
++;
258 if (class->usage_mask
& LOCKF_USED_IN_SOFTIRQ_READ
)
259 nr_softirq_read_safe
++;
260 if (class->usage_mask
& LOCKF_ENABLED_SOFTIRQ_READ
)
261 nr_softirq_read_unsafe
++;
262 if (class->usage_mask
& LOCKF_USED_IN_HARDIRQ_READ
)
263 nr_hardirq_read_safe
++;
264 if (class->usage_mask
& LOCKF_ENABLED_HARDIRQ_READ
)
265 nr_hardirq_read_unsafe
++;
267 #ifdef CONFIG_PROVE_LOCKING
268 sum_forward_deps
+= lockdep_count_forward_deps(class);
271 #ifdef CONFIG_DEBUG_LOCKDEP
272 DEBUG_LOCKS_WARN_ON(debug_atomic_read(nr_unused_locks
) != nr_unused
);
274 seq_printf(m
, " lock-classes: %11lu [max: %lu]\n",
275 nr_lock_classes
, MAX_LOCKDEP_KEYS
);
276 seq_printf(m
, " direct dependencies: %11lu [max: %lu]\n",
277 nr_list_entries
, MAX_LOCKDEP_ENTRIES
);
278 seq_printf(m
, " indirect dependencies: %11lu\n",
282 * Total number of dependencies:
284 * All irq-safe locks may nest inside irq-unsafe locks,
285 * plus all the other known dependencies:
287 seq_printf(m
, " all direct dependencies: %11lu\n",
288 nr_irq_unsafe
* nr_irq_safe
+
289 nr_hardirq_unsafe
* nr_hardirq_safe
+
292 #ifdef CONFIG_PROVE_LOCKING
293 seq_printf(m
, " dependency chains: %11lu [max: %lu]\n",
294 nr_lock_chains
, MAX_LOCKDEP_CHAINS
);
295 seq_printf(m
, " dependency chain hlocks: %11d [max: %lu]\n",
296 nr_chain_hlocks
, MAX_LOCKDEP_CHAIN_HLOCKS
);
299 #ifdef CONFIG_TRACE_IRQFLAGS
300 seq_printf(m
, " in-hardirq chains: %11u\n",
302 seq_printf(m
, " in-softirq chains: %11u\n",
305 seq_printf(m
, " in-process chains: %11u\n",
307 seq_printf(m
, " stack-trace entries: %11lu [max: %lu]\n",
308 nr_stack_trace_entries
, MAX_STACK_TRACE_ENTRIES
);
309 seq_printf(m
, " combined max dependencies: %11u\n",
310 (nr_hardirq_chains
+ 1) *
311 (nr_softirq_chains
+ 1) *
312 (nr_process_chains
+ 1)
314 seq_printf(m
, " hardirq-safe locks: %11lu\n",
316 seq_printf(m
, " hardirq-unsafe locks: %11lu\n",
318 seq_printf(m
, " softirq-safe locks: %11lu\n",
320 seq_printf(m
, " softirq-unsafe locks: %11lu\n",
322 seq_printf(m
, " irq-safe locks: %11lu\n",
324 seq_printf(m
, " irq-unsafe locks: %11lu\n",
327 seq_printf(m
, " hardirq-read-safe locks: %11lu\n",
328 nr_hardirq_read_safe
);
329 seq_printf(m
, " hardirq-read-unsafe locks: %11lu\n",
330 nr_hardirq_read_unsafe
);
331 seq_printf(m
, " softirq-read-safe locks: %11lu\n",
332 nr_softirq_read_safe
);
333 seq_printf(m
, " softirq-read-unsafe locks: %11lu\n",
334 nr_softirq_read_unsafe
);
335 seq_printf(m
, " irq-read-safe locks: %11lu\n",
337 seq_printf(m
, " irq-read-unsafe locks: %11lu\n",
340 seq_printf(m
, " uncategorized locks: %11lu\n",
342 seq_printf(m
, " unused locks: %11lu\n",
344 seq_printf(m
, " max locking depth: %11u\n",
346 #ifdef CONFIG_PROVE_LOCKING
347 seq_printf(m
, " max bfs queue depth: %11u\n",
348 max_bfs_queue_depth
);
350 lockdep_stats_debug_show(m
);
351 seq_printf(m
, " debug_locks: %11u\n",
357 static int lockdep_stats_open(struct inode
*inode
, struct file
*file
)
359 return single_open(file
, lockdep_stats_show
, NULL
);
362 static const struct file_operations proc_lockdep_stats_operations
= {
363 .open
= lockdep_stats_open
,
366 .release
= single_release
,
369 #ifdef CONFIG_LOCK_STAT
371 struct lock_stat_data
{
372 struct lock_class
*class;
373 struct lock_class_stats stats
;
376 struct lock_stat_seq
{
377 struct lock_stat_data
*iter_end
;
378 struct lock_stat_data stats
[MAX_LOCKDEP_KEYS
];
382 * sort on absolute number of contentions
384 static int lock_stat_cmp(const void *l
, const void *r
)
386 const struct lock_stat_data
*dl
= l
, *dr
= r
;
387 unsigned long nl
, nr
;
389 nl
= dl
->stats
.read_waittime
.nr
+ dl
->stats
.write_waittime
.nr
;
390 nr
= dr
->stats
.read_waittime
.nr
+ dr
->stats
.write_waittime
.nr
;
395 static void seq_line(struct seq_file
*m
, char c
, int offset
, int length
)
399 for (i
= 0; i
< offset
; i
++)
401 for (i
= 0; i
< length
; i
++)
402 seq_printf(m
, "%c", c
);
406 static void snprint_time(char *buf
, size_t bufsiz
, s64 nr
)
411 nr
+= 5; /* for display rounding */
412 div
= div_s64_rem(nr
, 1000, &rem
);
413 snprintf(buf
, bufsiz
, "%lld.%02d", (long long)div
, (int)rem
/10);
416 static void seq_time(struct seq_file
*m
, s64 time
)
420 snprint_time(num
, sizeof(num
), time
);
421 seq_printf(m
, " %14s", num
);
424 static void seq_lock_time(struct seq_file
*m
, struct lock_time
*lt
)
426 seq_printf(m
, "%14lu", lt
->nr
);
427 seq_time(m
, lt
->min
);
428 seq_time(m
, lt
->max
);
429 seq_time(m
, lt
->total
);
430 seq_time(m
, lt
->nr
? div_s64(lt
->total
, lt
->nr
) : 0);
433 static void seq_stats(struct seq_file
*m
, struct lock_stat_data
*data
)
435 struct lockdep_subclass_key
*ckey
;
436 struct lock_class_stats
*stats
;
437 struct lock_class
*class;
443 stats
= &data
->stats
;
446 if (class->name_version
> 1)
447 namelen
-= 2; /* XXX truncates versions > 9 */
451 rcu_read_lock_sched();
452 cname
= rcu_dereference_sched(class->name
);
453 ckey
= rcu_dereference_sched(class->key
);
455 if (!cname
&& !ckey
) {
456 rcu_read_unlock_sched();
460 char str
[KSYM_NAME_LEN
];
461 const char *key_name
;
463 key_name
= __get_key_name(ckey
, str
);
464 snprintf(name
, namelen
, "%s", key_name
);
466 snprintf(name
, namelen
, "%s", cname
);
468 rcu_read_unlock_sched();
470 namelen
= strlen(name
);
471 if (class->name_version
> 1) {
472 snprintf(name
+namelen
, 3, "#%d", class->name_version
);
475 if (class->subclass
) {
476 snprintf(name
+namelen
, 3, "/%d", class->subclass
);
480 if (stats
->write_holdtime
.nr
) {
481 if (stats
->read_holdtime
.nr
)
482 seq_printf(m
, "%38s-W:", name
);
484 seq_printf(m
, "%40s:", name
);
486 seq_printf(m
, "%14lu ", stats
->bounces
[bounce_contended_write
]);
487 seq_lock_time(m
, &stats
->write_waittime
);
488 seq_printf(m
, " %14lu ", stats
->bounces
[bounce_acquired_write
]);
489 seq_lock_time(m
, &stats
->write_holdtime
);
493 if (stats
->read_holdtime
.nr
) {
494 seq_printf(m
, "%38s-R:", name
);
495 seq_printf(m
, "%14lu ", stats
->bounces
[bounce_contended_read
]);
496 seq_lock_time(m
, &stats
->read_waittime
);
497 seq_printf(m
, " %14lu ", stats
->bounces
[bounce_acquired_read
]);
498 seq_lock_time(m
, &stats
->read_holdtime
);
502 if (stats
->read_waittime
.nr
+ stats
->write_waittime
.nr
== 0)
505 if (stats
->read_holdtime
.nr
)
508 for (i
= 0; i
< LOCKSTAT_POINTS
; i
++) {
511 if (class->contention_point
[i
] == 0)
515 seq_line(m
, '-', 40-namelen
, namelen
);
517 snprintf(ip
, sizeof(ip
), "[<%p>]",
518 (void *)class->contention_point
[i
]);
519 seq_printf(m
, "%40s %14lu %29s %pS\n",
520 name
, stats
->contention_point
[i
],
521 ip
, (void *)class->contention_point
[i
]);
523 for (i
= 0; i
< LOCKSTAT_POINTS
; i
++) {
526 if (class->contending_point
[i
] == 0)
530 seq_line(m
, '-', 40-namelen
, namelen
);
532 snprintf(ip
, sizeof(ip
), "[<%p>]",
533 (void *)class->contending_point
[i
]);
534 seq_printf(m
, "%40s %14lu %29s %pS\n",
535 name
, stats
->contending_point
[i
],
536 ip
, (void *)class->contending_point
[i
]);
540 seq_line(m
, '.', 0, 40 + 1 + 12 * (14 + 1));
545 static void seq_header(struct seq_file
*m
)
547 seq_puts(m
, "lock_stat version 0.4\n");
549 if (unlikely(!debug_locks
))
550 seq_printf(m
, "*WARNING* lock debugging disabled!! - possibly due to a lockdep warning\n");
552 seq_line(m
, '-', 0, 40 + 1 + 12 * (14 + 1));
553 seq_printf(m
, "%40s %14s %14s %14s %14s %14s %14s %14s %14s %14s %14s "
568 seq_line(m
, '-', 0, 40 + 1 + 12 * (14 + 1));
572 static void *ls_start(struct seq_file
*m
, loff_t
*pos
)
574 struct lock_stat_seq
*data
= m
->private;
575 struct lock_stat_data
*iter
;
578 return SEQ_START_TOKEN
;
580 iter
= data
->stats
+ (*pos
- 1);
581 if (iter
>= data
->iter_end
)
587 static void *ls_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
590 return ls_start(m
, pos
);
593 static void ls_stop(struct seq_file
*m
, void *v
)
597 static int ls_show(struct seq_file
*m
, void *v
)
599 if (v
== SEQ_START_TOKEN
)
607 static const struct seq_operations lockstat_ops
= {
614 static int lock_stat_open(struct inode
*inode
, struct file
*file
)
617 struct lock_class
*class;
618 struct lock_stat_seq
*data
= vmalloc(sizeof(struct lock_stat_seq
));
623 res
= seq_open(file
, &lockstat_ops
);
625 struct lock_stat_data
*iter
= data
->stats
;
626 struct seq_file
*m
= file
->private_data
;
628 list_for_each_entry(class, &all_lock_classes
, lock_entry
) {
630 iter
->stats
= lock_stats(class);
633 data
->iter_end
= iter
;
635 sort(data
->stats
, data
->iter_end
- data
->stats
,
636 sizeof(struct lock_stat_data
),
637 lock_stat_cmp
, NULL
);
646 static ssize_t
lock_stat_write(struct file
*file
, const char __user
*buf
,
647 size_t count
, loff_t
*ppos
)
649 struct lock_class
*class;
653 if (get_user(c
, buf
))
659 list_for_each_entry(class, &all_lock_classes
, lock_entry
)
660 clear_lock_stats(class);
665 static int lock_stat_release(struct inode
*inode
, struct file
*file
)
667 struct seq_file
*seq
= file
->private_data
;
670 return seq_release(inode
, file
);
673 static const struct file_operations proc_lock_stat_operations
= {
674 .open
= lock_stat_open
,
675 .write
= lock_stat_write
,
678 .release
= lock_stat_release
,
680 #endif /* CONFIG_LOCK_STAT */
682 static int __init
lockdep_proc_init(void)
684 proc_create("lockdep", S_IRUSR
, NULL
, &proc_lockdep_operations
);
685 #ifdef CONFIG_PROVE_LOCKING
686 proc_create("lockdep_chains", S_IRUSR
, NULL
,
687 &proc_lockdep_chains_operations
);
689 proc_create("lockdep_stats", S_IRUSR
, NULL
,
690 &proc_lockdep_stats_operations
);
692 #ifdef CONFIG_LOCK_STAT
693 proc_create("lock_stat", S_IRUSR
| S_IWUSR
, NULL
,
694 &proc_lock_stat_operations
);
700 __initcall(lockdep_proc_init
);