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