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