lockdep_proc.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361
  1. /*
  2. * kernel/lockdep_proc.c
  3. *
  4. * Runtime locking correctness validator
  5. *
  6. * Started by Ingo Molnar:
  7. *
  8. * Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
  9. *
  10. * Code for /proc/lockdep and /proc/lockdep_stats:
  11. *
  12. */
  13. #include <linux/module.h>
  14. #include <linux/proc_fs.h>
  15. #include <linux/seq_file.h>
  16. #include <linux/kallsyms.h>
  17. #include <linux/debug_locks.h>
  18. #include "lockdep_internals.h"
  19. static void *l_next(struct seq_file *m, void *v, loff_t *pos)
  20. {
  21. struct lock_class *class = v;
  22. (*pos)++;
  23. if (class->lock_entry.next != &all_lock_classes)
  24. class = list_entry(class->lock_entry.next, struct lock_class,
  25. lock_entry);
  26. else
  27. class = NULL;
  28. m->private = class;
  29. return class;
  30. }
  31. static void *l_start(struct seq_file *m, loff_t *pos)
  32. {
  33. struct lock_class *class = m->private;
  34. if (&class->lock_entry == all_lock_classes.next)
  35. seq_printf(m, "all lock classes:\n");
  36. return class;
  37. }
  38. static void l_stop(struct seq_file *m, void *v)
  39. {
  40. }
  41. static unsigned long count_forward_deps(struct lock_class *class)
  42. {
  43. struct lock_list *entry;
  44. unsigned long ret = 1;
  45. /*
  46. * Recurse this class's dependency list:
  47. */
  48. list_for_each_entry(entry, &class->locks_after, entry)
  49. ret += count_forward_deps(entry->class);
  50. return ret;
  51. }
  52. static unsigned long count_backward_deps(struct lock_class *class)
  53. {
  54. struct lock_list *entry;
  55. unsigned long ret = 1;
  56. /*
  57. * Recurse this class's dependency list:
  58. */
  59. list_for_each_entry(entry, &class->locks_before, entry)
  60. ret += count_backward_deps(entry->class);
  61. return ret;
  62. }
  63. static void print_name(struct seq_file *m, struct lock_class *class)
  64. {
  65. char str[128];
  66. const char *name = class->name;
  67. if (!name) {
  68. name = __get_key_name(class->key, str);
  69. seq_printf(m, "%s", name);
  70. } else{
  71. seq_printf(m, "%s", name);
  72. if (class->name_version > 1)
  73. seq_printf(m, "#%d", class->name_version);
  74. if (class->subclass)
  75. seq_printf(m, "/%d", class->subclass);
  76. }
  77. }
  78. static int l_show(struct seq_file *m, void *v)
  79. {
  80. unsigned long nr_forward_deps, nr_backward_deps;
  81. struct lock_class *class = m->private;
  82. struct lock_list *entry;
  83. char c1, c2, c3, c4;
  84. seq_printf(m, "%p", class->key);
  85. #ifdef CONFIG_DEBUG_LOCKDEP
  86. seq_printf(m, " OPS:%8ld", class->ops);
  87. #endif
  88. nr_forward_deps = count_forward_deps(class);
  89. seq_printf(m, " FD:%5ld", nr_forward_deps);
  90. nr_backward_deps = count_backward_deps(class);
  91. seq_printf(m, " BD:%5ld", nr_backward_deps);
  92. get_usage_chars(class, &c1, &c2, &c3, &c4);
  93. seq_printf(m, " %c%c%c%c", c1, c2, c3, c4);
  94. seq_printf(m, ": ");
  95. print_name(m, class);
  96. seq_puts(m, "\n");
  97. list_for_each_entry(entry, &class->locks_after, entry) {
  98. if (entry->distance == 1) {
  99. seq_printf(m, " -> [%p] ", entry->class);
  100. print_name(m, entry->class);
  101. seq_puts(m, "\n");
  102. }
  103. }
  104. seq_puts(m, "\n");
  105. return 0;
  106. }
  107. static const struct seq_operations lockdep_ops = {
  108. .start = l_start,
  109. .next = l_next,
  110. .stop = l_stop,
  111. .show = l_show,
  112. };
  113. static int lockdep_open(struct inode *inode, struct file *file)
  114. {
  115. int res = seq_open(file, &lockdep_ops);
  116. if (!res) {
  117. struct seq_file *m = file->private_data;
  118. if (!list_empty(&all_lock_classes))
  119. m->private = list_entry(all_lock_classes.next,
  120. struct lock_class, lock_entry);
  121. else
  122. m->private = NULL;
  123. }
  124. return res;
  125. }
  126. static const struct file_operations proc_lockdep_operations = {
  127. .open = lockdep_open,
  128. .read = seq_read,
  129. .llseek = seq_lseek,
  130. .release = seq_release,
  131. };
  132. static void lockdep_stats_debug_show(struct seq_file *m)
  133. {
  134. #ifdef CONFIG_DEBUG_LOCKDEP
  135. unsigned int hi1 = debug_atomic_read(&hardirqs_on_events),
  136. hi2 = debug_atomic_read(&hardirqs_off_events),
  137. hr1 = debug_atomic_read(&redundant_hardirqs_on),
  138. hr2 = debug_atomic_read(&redundant_hardirqs_off),
  139. si1 = debug_atomic_read(&softirqs_on_events),
  140. si2 = debug_atomic_read(&softirqs_off_events),
  141. sr1 = debug_atomic_read(&redundant_softirqs_on),
  142. sr2 = debug_atomic_read(&redundant_softirqs_off);
  143. seq_printf(m, " chain lookup misses: %11u\n",
  144. debug_atomic_read(&chain_lookup_misses));
  145. seq_printf(m, " chain lookup hits: %11u\n",
  146. debug_atomic_read(&chain_lookup_hits));
  147. seq_printf(m, " cyclic checks: %11u\n",
  148. debug_atomic_read(&nr_cyclic_checks));
  149. seq_printf(m, " cyclic-check recursions: %11u\n",
  150. debug_atomic_read(&nr_cyclic_check_recursions));
  151. seq_printf(m, " find-mask forwards checks: %11u\n",
  152. debug_atomic_read(&nr_find_usage_forwards_checks));
  153. seq_printf(m, " find-mask forwards recursions: %11u\n",
  154. debug_atomic_read(&nr_find_usage_forwards_recursions));
  155. seq_printf(m, " find-mask backwards checks: %11u\n",
  156. debug_atomic_read(&nr_find_usage_backwards_checks));
  157. seq_printf(m, " find-mask backwards recursions:%11u\n",
  158. debug_atomic_read(&nr_find_usage_backwards_recursions));
  159. seq_printf(m, " hardirq on events: %11u\n", hi1);
  160. seq_printf(m, " hardirq off events: %11u\n", hi2);
  161. seq_printf(m, " redundant hardirq ons: %11u\n", hr1);
  162. seq_printf(m, " redundant hardirq offs: %11u\n", hr2);
  163. seq_printf(m, " softirq on events: %11u\n", si1);
  164. seq_printf(m, " softirq off events: %11u\n", si2);
  165. seq_printf(m, " redundant softirq ons: %11u\n", sr1);
  166. seq_printf(m, " redundant softirq offs: %11u\n", sr2);
  167. #endif
  168. }
  169. static int lockdep_stats_show(struct seq_file *m, void *v)
  170. {
  171. struct lock_class *class;
  172. unsigned long nr_unused = 0, nr_uncategorized = 0,
  173. nr_irq_safe = 0, nr_irq_unsafe = 0,
  174. nr_softirq_safe = 0, nr_softirq_unsafe = 0,
  175. nr_hardirq_safe = 0, nr_hardirq_unsafe = 0,
  176. nr_irq_read_safe = 0, nr_irq_read_unsafe = 0,
  177. nr_softirq_read_safe = 0, nr_softirq_read_unsafe = 0,
  178. nr_hardirq_read_safe = 0, nr_hardirq_read_unsafe = 0,
  179. sum_forward_deps = 0, factor = 0;
  180. list_for_each_entry(class, &all_lock_classes, lock_entry) {
  181. if (class->usage_mask == 0)
  182. nr_unused++;
  183. if (class->usage_mask == LOCKF_USED)
  184. nr_uncategorized++;
  185. if (class->usage_mask & LOCKF_USED_IN_IRQ)
  186. nr_irq_safe++;
  187. if (class->usage_mask & LOCKF_ENABLED_IRQS)
  188. nr_irq_unsafe++;
  189. if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ)
  190. nr_softirq_safe++;
  191. if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS)
  192. nr_softirq_unsafe++;
  193. if (class->usage_mask & LOCKF_USED_IN_HARDIRQ)
  194. nr_hardirq_safe++;
  195. if (class->usage_mask & LOCKF_ENABLED_HARDIRQS)
  196. nr_hardirq_unsafe++;
  197. if (class->usage_mask & LOCKF_USED_IN_IRQ_READ)
  198. nr_irq_read_safe++;
  199. if (class->usage_mask & LOCKF_ENABLED_IRQS_READ)
  200. nr_irq_read_unsafe++;
  201. if (class->usage_mask & LOCKF_USED_IN_SOFTIRQ_READ)
  202. nr_softirq_read_safe++;
  203. if (class->usage_mask & LOCKF_ENABLED_SOFTIRQS_READ)
  204. nr_softirq_read_unsafe++;
  205. if (class->usage_mask & LOCKF_USED_IN_HARDIRQ_READ)
  206. nr_hardirq_read_safe++;
  207. if (class->usage_mask & LOCKF_ENABLED_HARDIRQS_READ)
  208. nr_hardirq_read_unsafe++;
  209. sum_forward_deps += count_forward_deps(class);
  210. }
  211. #ifdef CONFIG_DEBUG_LOCKDEP
  212. DEBUG_LOCKS_WARN_ON(debug_atomic_read(&nr_unused_locks) != nr_unused);
  213. #endif
  214. seq_printf(m, " lock-classes: %11lu [max: %lu]\n",
  215. nr_lock_classes, MAX_LOCKDEP_KEYS);
  216. seq_printf(m, " direct dependencies: %11lu [max: %lu]\n",
  217. nr_list_entries, MAX_LOCKDEP_ENTRIES);
  218. seq_printf(m, " indirect dependencies: %11lu\n",
  219. sum_forward_deps);
  220. /*
  221. * Total number of dependencies:
  222. *
  223. * All irq-safe locks may nest inside irq-unsafe locks,
  224. * plus all the other known dependencies:
  225. */
  226. seq_printf(m, " all direct dependencies: %11lu\n",
  227. nr_irq_unsafe * nr_irq_safe +
  228. nr_hardirq_unsafe * nr_hardirq_safe +
  229. nr_list_entries);
  230. /*
  231. * Estimated factor between direct and indirect
  232. * dependencies:
  233. */
  234. if (nr_list_entries)
  235. factor = sum_forward_deps / nr_list_entries;
  236. seq_printf(m, " dependency chains: %11lu [max: %lu]\n",
  237. nr_lock_chains, MAX_LOCKDEP_CHAINS);
  238. #ifdef CONFIG_TRACE_IRQFLAGS
  239. seq_printf(m, " in-hardirq chains: %11u\n",
  240. nr_hardirq_chains);
  241. seq_printf(m, " in-softirq chains: %11u\n",
  242. nr_softirq_chains);
  243. #endif
  244. seq_printf(m, " in-process chains: %11u\n",
  245. nr_process_chains);
  246. seq_printf(m, " stack-trace entries: %11lu [max: %lu]\n",
  247. nr_stack_trace_entries, MAX_STACK_TRACE_ENTRIES);
  248. seq_printf(m, " combined max dependencies: %11u\n",
  249. (nr_hardirq_chains + 1) *
  250. (nr_softirq_chains + 1) *
  251. (nr_process_chains + 1)
  252. );
  253. seq_printf(m, " hardirq-safe locks: %11lu\n",
  254. nr_hardirq_safe);
  255. seq_printf(m, " hardirq-unsafe locks: %11lu\n",
  256. nr_hardirq_unsafe);
  257. seq_printf(m, " softirq-safe locks: %11lu\n",
  258. nr_softirq_safe);
  259. seq_printf(m, " softirq-unsafe locks: %11lu\n",
  260. nr_softirq_unsafe);
  261. seq_printf(m, " irq-safe locks: %11lu\n",
  262. nr_irq_safe);
  263. seq_printf(m, " irq-unsafe locks: %11lu\n",
  264. nr_irq_unsafe);
  265. seq_printf(m, " hardirq-read-safe locks: %11lu\n",
  266. nr_hardirq_read_safe);
  267. seq_printf(m, " hardirq-read-unsafe locks: %11lu\n",
  268. nr_hardirq_read_unsafe);
  269. seq_printf(m, " softirq-read-safe locks: %11lu\n",
  270. nr_softirq_read_safe);
  271. seq_printf(m, " softirq-read-unsafe locks: %11lu\n",
  272. nr_softirq_read_unsafe);
  273. seq_printf(m, " irq-read-safe locks: %11lu\n",
  274. nr_irq_read_safe);
  275. seq_printf(m, " irq-read-unsafe locks: %11lu\n",
  276. nr_irq_read_unsafe);
  277. seq_printf(m, " uncategorized locks: %11lu\n",
  278. nr_uncategorized);
  279. seq_printf(m, " unused locks: %11lu\n",
  280. nr_unused);
  281. seq_printf(m, " max locking depth: %11u\n",
  282. max_lockdep_depth);
  283. seq_printf(m, " max recursion depth: %11u\n",
  284. max_recursion_depth);
  285. lockdep_stats_debug_show(m);
  286. seq_printf(m, " debug_locks: %11u\n",
  287. debug_locks);
  288. return 0;
  289. }
  290. static int lockdep_stats_open(struct inode *inode, struct file *file)
  291. {
  292. return single_open(file, lockdep_stats_show, NULL);
  293. }
  294. static const struct file_operations proc_lockdep_stats_operations = {
  295. .open = lockdep_stats_open,
  296. .read = seq_read,
  297. .llseek = seq_lseek,
  298. .release = seq_release,
  299. };
  300. static int __init lockdep_proc_init(void)
  301. {
  302. struct proc_dir_entry *entry;
  303. entry = create_proc_entry("lockdep", S_IRUSR, NULL);
  304. if (entry)
  305. entry->proc_fops = &proc_lockdep_operations;
  306. entry = create_proc_entry("lockdep_stats", S_IRUSR, NULL);
  307. if (entry)
  308. entry->proc_fops = &proc_lockdep_stats_operations;
  309. return 0;
  310. }
  311. __initcall(lockdep_proc_init);