1
2
3
4
5
6
7
8
9#ifndef __LINUX_LOCKDEP_H
10#define __LINUX_LOCKDEP_H
11
12struct task_struct;
13struct lockdep_map;
14
15#ifdef CONFIG_LOCKDEP
16
17#include <linux/linkage.h>
18#include <linux/list.h>
19#include <linux/debug_locks.h>
20#include <linux/stacktrace.h>
21
22
23
24
25
26#define XXX_LOCK_USAGE_STATES (1+3*4)
27
28#define MAX_LOCKDEP_SUBCLASSES 8UL
29
30
31
32
33
34
35struct lockdep_subclass_key {
36 char __one_byte;
37} __attribute__ ((__packed__));
38
39struct lock_class_key {
40 struct lockdep_subclass_key subkeys[MAX_LOCKDEP_SUBCLASSES];
41};
42
43#define LOCKSTAT_POINTS 4
44
45
46
47
48struct lock_class {
49
50
51
52 struct list_head hash_entry;
53
54
55
56
57 struct list_head lock_entry;
58
59 struct lockdep_subclass_key *key;
60 unsigned int subclass;
61 unsigned int dep_gen_id;
62
63
64
65
66 unsigned long usage_mask;
67 struct stack_trace usage_traces[XXX_LOCK_USAGE_STATES];
68
69
70
71
72
73
74 struct list_head locks_after, locks_before;
75
76
77
78
79
80 unsigned int version;
81
82
83
84
85 unsigned long ops;
86
87 const char *name;
88 int name_version;
89
90#ifdef CONFIG_LOCK_STAT
91 unsigned long contention_point[LOCKSTAT_POINTS];
92 unsigned long contending_point[LOCKSTAT_POINTS];
93#endif
94};
95
96#ifdef CONFIG_LOCK_STAT
97struct lock_time {
98 s64 min;
99 s64 max;
100 s64 total;
101 unsigned long nr;
102};
103
104enum bounce_type {
105 bounce_acquired_write,
106 bounce_acquired_read,
107 bounce_contended_write,
108 bounce_contended_read,
109 nr_bounce_types,
110
111 bounce_acquired = bounce_acquired_write,
112 bounce_contended = bounce_contended_write,
113};
114
115struct lock_class_stats {
116 unsigned long contention_point[4];
117 unsigned long contending_point[4];
118 struct lock_time read_waittime;
119 struct lock_time write_waittime;
120 struct lock_time read_holdtime;
121 struct lock_time write_holdtime;
122 unsigned long bounces[nr_bounce_types];
123};
124
125struct lock_class_stats lock_stats(struct lock_class *class);
126void clear_lock_stats(struct lock_class *class);
127#endif
128
129
130
131
132
133struct lockdep_map {
134 struct lock_class_key *key;
135 struct lock_class *class_cache;
136 const char *name;
137#ifdef CONFIG_LOCK_STAT
138 int cpu;
139 unsigned long ip;
140#endif
141};
142
143
144
145
146
147struct lock_list {
148 struct list_head entry;
149 struct lock_class *class;
150 struct stack_trace trace;
151 int distance;
152
153
154
155
156
157 struct lock_list *parent;
158};
159
160
161
162
163struct lock_chain {
164 u8 irq_context;
165 u8 depth;
166 u16 base;
167 struct list_head entry;
168 u64 chain_key;
169};
170
171#define MAX_LOCKDEP_KEYS_BITS 13
172
173
174
175
176
177#define MAX_LOCKDEP_KEYS ((1UL << MAX_LOCKDEP_KEYS_BITS) - 1)
178
179struct held_lock {
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194 u64 prev_chain_key;
195 unsigned long acquire_ip;
196 struct lockdep_map *instance;
197 struct lockdep_map *nest_lock;
198#ifdef CONFIG_LOCK_STAT
199 u64 waittime_stamp;
200 u64 holdtime_stamp;
201#endif
202 unsigned int class_idx:MAX_LOCKDEP_KEYS_BITS;
203
204
205
206
207
208
209
210
211
212
213
214
215
216 unsigned int irq_context:2;
217 unsigned int trylock:1;
218
219 unsigned int read:2;
220 unsigned int check:2;
221 unsigned int hardirqs_off:1;
222 unsigned int references:11;
223};
224
225
226
227
228extern void lockdep_init(void);
229extern void lockdep_info(void);
230extern void lockdep_reset(void);
231extern void lockdep_reset_lock(struct lockdep_map *lock);
232extern void lockdep_free_key_range(void *start, unsigned long size);
233extern void lockdep_sys_exit(void);
234
235extern void lockdep_off(void);
236extern void lockdep_on(void);
237
238
239
240
241
242
243
244extern void lockdep_init_map(struct lockdep_map *lock, const char *name,
245 struct lock_class_key *key, int subclass);
246
247
248
249
250
251#define STATIC_LOCKDEP_MAP_INIT(_name, _key) \
252 { .name = (_name), .key = (void *)(_key), }
253
254
255
256
257
258
259
260#define lockdep_set_class(lock, key) \
261 lockdep_init_map(&(lock)->dep_map, #key, key, 0)
262#define lockdep_set_class_and_name(lock, key, name) \
263 lockdep_init_map(&(lock)->dep_map, name, key, 0)
264#define lockdep_set_class_and_subclass(lock, key, sub) \
265 lockdep_init_map(&(lock)->dep_map, #key, key, sub)
266#define lockdep_set_subclass(lock, sub) \
267 lockdep_init_map(&(lock)->dep_map, #lock, \
268 (lock)->dep_map.key, sub)
269
270
271
272#define lockdep_match_class(lock, key) lockdep_match_key(&(lock)->dep_map, key)
273
274static inline int lockdep_match_key(struct lockdep_map *lock,
275 struct lock_class_key *key)
276{
277 return lock->key == key;
278}
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295extern void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
296 int trylock, int read, int check,
297 struct lockdep_map *nest_lock, unsigned long ip);
298
299extern void lock_release(struct lockdep_map *lock, int nested,
300 unsigned long ip);
301
302#define lockdep_is_held(lock) lock_is_held(&(lock)->dep_map)
303
304extern int lock_is_held(struct lockdep_map *lock);
305
306extern void lock_set_class(struct lockdep_map *lock, const char *name,
307 struct lock_class_key *key, unsigned int subclass,
308 unsigned long ip);
309
310static inline void lock_set_subclass(struct lockdep_map *lock,
311 unsigned int subclass, unsigned long ip)
312{
313 lock_set_class(lock, lock->name, lock->key, subclass, ip);
314}
315
316extern void lockdep_set_current_reclaim_state(gfp_t gfp_mask);
317extern void lockdep_clear_current_reclaim_state(void);
318extern void lockdep_trace_alloc(gfp_t mask);
319
320# define INIT_LOCKDEP .lockdep_recursion = 0, .lockdep_reclaim_gfp = 0,
321
322#define lockdep_depth(tsk) (debug_locks ? (tsk)->lockdep_depth : 0)
323
324#define lockdep_assert_held(l) WARN_ON(debug_locks && !lockdep_is_held(l))
325
326#else
327
328static inline void lockdep_off(void)
329{
330}
331
332static inline void lockdep_on(void)
333{
334}
335
336# define lock_acquire(l, s, t, r, c, n, i) do { } while (0)
337# define lock_release(l, n, i) do { } while (0)
338# define lock_set_class(l, n, k, s, i) do { } while (0)
339# define lock_set_subclass(l, s, i) do { } while (0)
340# define lockdep_set_current_reclaim_state(g) do { } while (0)
341# define lockdep_clear_current_reclaim_state() do { } while (0)
342# define lockdep_trace_alloc(g) do { } while (0)
343# define lockdep_init() do { } while (0)
344# define lockdep_info() do { } while (0)
345# define lockdep_init_map(lock, name, key, sub) \
346 do { (void)(name); (void)(key); } while (0)
347# define lockdep_set_class(lock, key) do { (void)(key); } while (0)
348# define lockdep_set_class_and_name(lock, key, name) \
349 do { (void)(key); (void)(name); } while (0)
350#define lockdep_set_class_and_subclass(lock, key, sub) \
351 do { (void)(key); } while (0)
352#define lockdep_set_subclass(lock, sub) do { } while (0)
353
354
355
356
357
358
359# define INIT_LOCKDEP
360# define lockdep_reset() do { debug_locks = 1; } while (0)
361# define lockdep_free_key_range(start, size) do { } while (0)
362# define lockdep_sys_exit() do { } while (0)
363
364
365
366struct lock_class_key { };
367
368#define lockdep_depth(tsk) (0)
369
370#define lockdep_assert_held(l) do { } while (0)
371
372#endif
373
374#ifdef CONFIG_LOCK_STAT
375
376extern void lock_contended(struct lockdep_map *lock, unsigned long ip);
377extern void lock_acquired(struct lockdep_map *lock, unsigned long ip);
378
379#define LOCK_CONTENDED(_lock, try, lock) \
380do { \
381 if (!try(_lock)) { \
382 lock_contended(&(_lock)->dep_map, _RET_IP_); \
383 lock(_lock); \
384 } \
385 lock_acquired(&(_lock)->dep_map, _RET_IP_); \
386} while (0)
387
388#else
389
390#define lock_contended(lockdep_map, ip) do {} while (0)
391#define lock_acquired(lockdep_map, ip) do {} while (0)
392
393#define LOCK_CONTENDED(_lock, try, lock) \
394 lock(_lock)
395
396#endif
397
398#ifdef CONFIG_LOCKDEP
399
400
401
402
403
404
405#define LOCK_CONTENDED_FLAGS(_lock, try, lock, lockfl, flags) \
406 LOCK_CONTENDED((_lock), (try), (lock))
407
408#else
409
410#define LOCK_CONTENDED_FLAGS(_lock, try, lock, lockfl, flags) \
411 lockfl((_lock), (flags))
412
413#endif
414
415#ifdef CONFIG_GENERIC_HARDIRQS
416extern void early_init_irq_lock_class(void);
417#else
418static inline void early_init_irq_lock_class(void)
419{
420}
421#endif
422
423#ifdef CONFIG_TRACE_IRQFLAGS
424extern void early_boot_irqs_off(void);
425extern void early_boot_irqs_on(void);
426extern void print_irqtrace_events(struct task_struct *curr);
427#else
428static inline void early_boot_irqs_off(void)
429{
430}
431static inline void early_boot_irqs_on(void)
432{
433}
434static inline void print_irqtrace_events(struct task_struct *curr)
435{
436}
437#endif
438
439
440
441
442
443
444#define SINGLE_DEPTH_NESTING 1
445
446
447
448
449
450
451#ifdef CONFIG_DEBUG_LOCK_ALLOC
452# ifdef CONFIG_PROVE_LOCKING
453# define spin_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 2, NULL, i)
454# define spin_acquire_nest(l, s, t, n, i) lock_acquire(l, s, t, 0, 2, n, i)
455# else
456# define spin_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 1, NULL, i)
457# define spin_acquire_nest(l, s, t, n, i) lock_acquire(l, s, t, 0, 1, NULL, i)
458# endif
459# define spin_release(l, n, i) lock_release(l, n, i)
460#else
461# define spin_acquire(l, s, t, i) do { } while (0)
462# define spin_release(l, n, i) do { } while (0)
463#endif
464
465#ifdef CONFIG_DEBUG_LOCK_ALLOC
466# ifdef CONFIG_PROVE_LOCKING
467# define rwlock_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 2, NULL, i)
468# define rwlock_acquire_read(l, s, t, i) lock_acquire(l, s, t, 2, 2, NULL, i)
469# else
470# define rwlock_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 1, NULL, i)
471# define rwlock_acquire_read(l, s, t, i) lock_acquire(l, s, t, 2, 1, NULL, i)
472# endif
473# define rwlock_release(l, n, i) lock_release(l, n, i)
474#else
475# define rwlock_acquire(l, s, t, i) do { } while (0)
476# define rwlock_acquire_read(l, s, t, i) do { } while (0)
477# define rwlock_release(l, n, i) do { } while (0)
478#endif
479
480#ifdef CONFIG_DEBUG_LOCK_ALLOC
481# ifdef CONFIG_PROVE_LOCKING
482# define mutex_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 2, NULL, i)
483# else
484# define mutex_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 1, NULL, i)
485# endif
486# define mutex_release(l, n, i) lock_release(l, n, i)
487#else
488# define mutex_acquire(l, s, t, i) do { } while (0)
489# define mutex_release(l, n, i) do { } while (0)
490#endif
491
492#ifdef CONFIG_DEBUG_LOCK_ALLOC
493# ifdef CONFIG_PROVE_LOCKING
494# define rwsem_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 2, NULL, i)
495# define rwsem_acquire_read(l, s, t, i) lock_acquire(l, s, t, 1, 2, NULL, i)
496# else
497# define rwsem_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 1, NULL, i)
498# define rwsem_acquire_read(l, s, t, i) lock_acquire(l, s, t, 1, 1, NULL, i)
499# endif
500# define rwsem_release(l, n, i) lock_release(l, n, i)
501#else
502# define rwsem_acquire(l, s, t, i) do { } while (0)
503# define rwsem_acquire_read(l, s, t, i) do { } while (0)
504# define rwsem_release(l, n, i) do { } while (0)
505#endif
506
507#ifdef CONFIG_DEBUG_LOCK_ALLOC
508# ifdef CONFIG_PROVE_LOCKING
509# define lock_map_acquire(l) lock_acquire(l, 0, 0, 0, 2, NULL, _THIS_IP_)
510# else
511# define lock_map_acquire(l) lock_acquire(l, 0, 0, 0, 1, NULL, _THIS_IP_)
512# endif
513# define lock_map_release(l) lock_release(l, 1, _THIS_IP_)
514#else
515# define lock_map_acquire(l) do { } while (0)
516# define lock_map_release(l) do { } while (0)
517#endif
518
519#ifdef CONFIG_PROVE_LOCKING
520# define might_lock(lock) \
521do { \
522 typecheck(struct lockdep_map *, &(lock)->dep_map); \
523 lock_acquire(&(lock)->dep_map, 0, 0, 0, 2, NULL, _THIS_IP_); \
524 lock_release(&(lock)->dep_map, 0, _THIS_IP_); \
525} while (0)
526# define might_lock_read(lock) \
527do { \
528 typecheck(struct lockdep_map *, &(lock)->dep_map); \
529 lock_acquire(&(lock)->dep_map, 0, 0, 1, 2, NULL, _THIS_IP_); \
530 lock_release(&(lock)->dep_map, 0, _THIS_IP_); \
531} while (0)
532#else
533# define might_lock(lock) do { } while (0)
534# define might_lock_read(lock) do { } while (0)
535#endif
536
537#endif
538