1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * kernel/lockdep_internals.h 4 * 5 * Runtime locking correctness validator 6 * 7 * lockdep subsystem internal functions and variables. 8 */ 9 10 /* 11 * Lock-class usage-state bits: 12 */ 13 enum lock_usage_bit { 14 #define LOCKDEP_STATE(__STATE) \ 15 LOCK_USED_IN_##__STATE, \ 16 LOCK_USED_IN_##__STATE##_READ, \ 17 LOCK_ENABLED_##__STATE, \ 18 LOCK_ENABLED_##__STATE##_READ, 19 #include "lockdep_states.h" 20 #undef LOCKDEP_STATE 21 LOCK_USED, 22 LOCK_USAGE_STATES 23 }; 24 25 #define LOCK_USAGE_READ_MASK 1 26 #define LOCK_USAGE_DIR_MASK 2 27 #define LOCK_USAGE_STATE_MASK (~(LOCK_USAGE_READ_MASK | LOCK_USAGE_DIR_MASK)) 28 29 /* 30 * Usage-state bitmasks: 31 */ 32 #define __LOCKF(__STATE) LOCKF_##__STATE = (1 << LOCK_##__STATE), 33 34 enum { 35 #define LOCKDEP_STATE(__STATE) \ 36 __LOCKF(USED_IN_##__STATE) \ 37 __LOCKF(USED_IN_##__STATE##_READ) \ 38 __LOCKF(ENABLED_##__STATE) \ 39 __LOCKF(ENABLED_##__STATE##_READ) 40 #include "lockdep_states.h" 41 #undef LOCKDEP_STATE 42 __LOCKF(USED) 43 }; 44 45 #define LOCKDEP_STATE(__STATE) LOCKF_ENABLED_##__STATE | 46 static const unsigned long LOCKF_ENABLED_IRQ = 47 #include "lockdep_states.h" 48 0; 49 #undef LOCKDEP_STATE 50 51 #define LOCKDEP_STATE(__STATE) LOCKF_USED_IN_##__STATE | 52 static const unsigned long LOCKF_USED_IN_IRQ = 53 #include "lockdep_states.h" 54 0; 55 #undef LOCKDEP_STATE 56 57 #define LOCKDEP_STATE(__STATE) LOCKF_ENABLED_##__STATE##_READ | 58 static const unsigned long LOCKF_ENABLED_IRQ_READ = 59 #include "lockdep_states.h" 60 0; 61 #undef LOCKDEP_STATE 62 63 #define LOCKDEP_STATE(__STATE) LOCKF_USED_IN_##__STATE##_READ | 64 static const unsigned long LOCKF_USED_IN_IRQ_READ = 65 #include "lockdep_states.h" 66 0; 67 #undef LOCKDEP_STATE 68 69 #define LOCKF_ENABLED_IRQ_ALL (LOCKF_ENABLED_IRQ | LOCKF_ENABLED_IRQ_READ) 70 #define LOCKF_USED_IN_IRQ_ALL (LOCKF_USED_IN_IRQ | LOCKF_USED_IN_IRQ_READ) 71 72 #define LOCKF_IRQ (LOCKF_ENABLED_IRQ | LOCKF_USED_IN_IRQ) 73 #define LOCKF_IRQ_READ (LOCKF_ENABLED_IRQ_READ | LOCKF_USED_IN_IRQ_READ) 74 75 /* 76 * CONFIG_LOCKDEP_SMALL is defined for sparc. Sparc requires .text, 77 * .data and .bss to fit in required 32MB limit for the kernel. With 78 * CONFIG_LOCKDEP we could go over this limit and cause system boot-up problems. 79 * So, reduce the static allocations for lockdeps related structures so that 80 * everything fits in current required size limit. 81 */ 82 #ifdef CONFIG_LOCKDEP_SMALL 83 /* 84 * MAX_LOCKDEP_ENTRIES is the maximum number of lock dependencies 85 * we track. 86 * 87 * We use the per-lock dependency maps in two ways: we grow it by adding 88 * every to-be-taken lock to all currently held lock's own dependency 89 * table (if it's not there yet), and we check it for lock order 90 * conflicts and deadlocks. 91 */ 92 #define MAX_LOCKDEP_ENTRIES 16384UL 93 #define MAX_LOCKDEP_CHAINS_BITS 15 94 #define MAX_STACK_TRACE_ENTRIES 262144UL 95 #define STACK_TRACE_HASH_SIZE 8192 96 #else 97 #define MAX_LOCKDEP_ENTRIES 32768UL 98 99 #define MAX_LOCKDEP_CHAINS_BITS 16 100 101 /* 102 * Stack-trace: tightly packed array of stack backtrace 103 * addresses. Protected by the hash_lock. 104 */ 105 #define MAX_STACK_TRACE_ENTRIES 524288UL 106 #define STACK_TRACE_HASH_SIZE 16384 107 #endif 108 109 /* 110 * Bit definitions for lock_chain.irq_context 111 */ 112 #define LOCK_CHAIN_SOFTIRQ_CONTEXT (1 << 0) 113 #define LOCK_CHAIN_HARDIRQ_CONTEXT (1 << 1) 114 115 #define MAX_LOCKDEP_CHAINS (1UL << MAX_LOCKDEP_CHAINS_BITS) 116 117 #define MAX_LOCKDEP_CHAIN_HLOCKS (MAX_LOCKDEP_CHAINS*5) 118 119 extern struct list_head all_lock_classes; 120 extern struct lock_chain lock_chains[]; 121 122 #define LOCK_USAGE_CHARS (1+LOCK_USAGE_STATES/2) 123 124 extern void get_usage_chars(struct lock_class *class, 125 char usage[LOCK_USAGE_CHARS]); 126 127 extern const char *__get_key_name(const struct lockdep_subclass_key *key, 128 char *str); 129 130 struct lock_class *lock_chain_get_class(struct lock_chain *chain, int i); 131 132 extern unsigned long nr_lock_classes; 133 extern unsigned long nr_zapped_classes; 134 extern unsigned long nr_zapped_lock_chains; 135 extern unsigned long nr_list_entries; 136 long lockdep_next_lockchain(long i); 137 unsigned long lock_chain_count(void); 138 extern unsigned long nr_stack_trace_entries; 139 140 extern unsigned int nr_hardirq_chains; 141 extern unsigned int nr_softirq_chains; 142 extern unsigned int nr_process_chains; 143 extern unsigned int nr_chain_hlocks; 144 145 extern unsigned int max_lockdep_depth; 146 extern unsigned int max_bfs_queue_depth; 147 148 #ifdef CONFIG_PROVE_LOCKING 149 extern unsigned long lockdep_count_forward_deps(struct lock_class *); 150 extern unsigned long lockdep_count_backward_deps(struct lock_class *); 151 #ifdef CONFIG_TRACE_IRQFLAGS 152 u64 lockdep_stack_trace_count(void); 153 u64 lockdep_stack_hash_count(void); 154 #endif 155 #else 156 static inline unsigned long 157 lockdep_count_forward_deps(struct lock_class *class) 158 { 159 return 0; 160 } 161 static inline unsigned long 162 lockdep_count_backward_deps(struct lock_class *class) 163 { 164 return 0; 165 } 166 #endif 167 168 #ifdef CONFIG_DEBUG_LOCKDEP 169 170 #include <asm/local.h> 171 /* 172 * Various lockdep statistics. 173 * We want them per cpu as they are often accessed in fast path 174 * and we want to avoid too much cache bouncing. 175 */ 176 struct lockdep_stats { 177 unsigned long chain_lookup_hits; 178 unsigned int chain_lookup_misses; 179 unsigned long hardirqs_on_events; 180 unsigned long hardirqs_off_events; 181 unsigned long redundant_hardirqs_on; 182 unsigned long redundant_hardirqs_off; 183 unsigned long softirqs_on_events; 184 unsigned long softirqs_off_events; 185 unsigned long redundant_softirqs_on; 186 unsigned long redundant_softirqs_off; 187 int nr_unused_locks; 188 unsigned int nr_redundant_checks; 189 unsigned int nr_redundant; 190 unsigned int nr_cyclic_checks; 191 unsigned int nr_find_usage_forwards_checks; 192 unsigned int nr_find_usage_backwards_checks; 193 194 /* 195 * Per lock class locking operation stat counts 196 */ 197 unsigned long lock_class_ops[MAX_LOCKDEP_KEYS]; 198 }; 199 200 DECLARE_PER_CPU(struct lockdep_stats, lockdep_stats); 201 extern struct lock_class lock_classes[MAX_LOCKDEP_KEYS]; 202 203 #define __debug_atomic_inc(ptr) \ 204 this_cpu_inc(lockdep_stats.ptr); 205 206 #define debug_atomic_inc(ptr) { \ 207 WARN_ON_ONCE(!irqs_disabled()); \ 208 __this_cpu_inc(lockdep_stats.ptr); \ 209 } 210 211 #define debug_atomic_dec(ptr) { \ 212 WARN_ON_ONCE(!irqs_disabled()); \ 213 __this_cpu_dec(lockdep_stats.ptr); \ 214 } 215 216 #define debug_atomic_read(ptr) ({ \ 217 struct lockdep_stats *__cpu_lockdep_stats; \ 218 unsigned long long __total = 0; \ 219 int __cpu; \ 220 for_each_possible_cpu(__cpu) { \ 221 __cpu_lockdep_stats = &per_cpu(lockdep_stats, __cpu); \ 222 __total += __cpu_lockdep_stats->ptr; \ 223 } \ 224 __total; \ 225 }) 226 227 static inline void debug_class_ops_inc(struct lock_class *class) 228 { 229 int idx; 230 231 idx = class - lock_classes; 232 __debug_atomic_inc(lock_class_ops[idx]); 233 } 234 235 static inline unsigned long debug_class_ops_read(struct lock_class *class) 236 { 237 int idx, cpu; 238 unsigned long ops = 0; 239 240 idx = class - lock_classes; 241 for_each_possible_cpu(cpu) 242 ops += per_cpu(lockdep_stats.lock_class_ops[idx], cpu); 243 return ops; 244 } 245 246 #else 247 # define __debug_atomic_inc(ptr) do { } while (0) 248 # define debug_atomic_inc(ptr) do { } while (0) 249 # define debug_atomic_dec(ptr) do { } while (0) 250 # define debug_atomic_read(ptr) 0 251 # define debug_class_ops_inc(ptr) do { } while (0) 252 #endif 253