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