lockdep_types.h

  1/* SPDX-License-Identifier: GPL-2.0 */
  2/*
  3 * Runtime locking correctness validator
  4 *
  5 *  Copyright (C) 2006,2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
  6 *  Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra
  7 *
  8 * see Documentation/locking/lockdep-design.rst for more details.
  9 */
 10#ifndef __LINUX_LOCKDEP_TYPES_H
 11#define __LINUX_LOCKDEP_TYPES_H
 12
 13#include <linux/types.h>
 14
 15#define MAX_LOCKDEP_SUBCLASSES		8UL
 16
 17enum lockdep_wait_type {
 18	LD_WAIT_INV = 0,	/* not checked, catch all */
 19
 20	LD_WAIT_FREE,		/* wait free, rcu etc.. */
 21	LD_WAIT_SPIN,		/* spin loops, raw_spinlock_t etc.. */
 22
 23#ifdef CONFIG_PROVE_RAW_LOCK_NESTING
 24	LD_WAIT_CONFIG,		/* preemptible in PREEMPT_RT, spinlock_t etc.. */
 25#else
 26	LD_WAIT_CONFIG = LD_WAIT_SPIN,
 27#endif
 28	LD_WAIT_SLEEP,		/* sleeping locks, mutex_t etc.. */
 29
 30	LD_WAIT_MAX,		/* must be last */
 31};
 32
 33enum lockdep_lock_type {
 34	LD_LOCK_NORMAL = 0,	/* normal, catch all */
 35	LD_LOCK_PERCPU,		/* percpu */
 36	LD_LOCK_WAIT_OVERRIDE,	/* annotation */
 37	LD_LOCK_MAX,
 38};
 39
 40#ifdef CONFIG_LOCKDEP
 41
 42/*
 43 * We'd rather not expose kernel/lockdep_states.h this wide, but we do need
 44 * the total number of states... :-(
 45 *
 46 * XXX_LOCK_USAGE_STATES is the number of lines in lockdep_states.h, for each
 47 * of those we generates 4 states, Additionally we report on USED and USED_READ.
 48 */
 49#define XXX_LOCK_USAGE_STATES		2
 50#define LOCK_TRACE_STATES		(XXX_LOCK_USAGE_STATES*4 + 2)
 51
 52/*
 53 * NR_LOCKDEP_CACHING_CLASSES ... Number of classes
 54 * cached in the instance of lockdep_map
 55 *
 56 * Currently main class (subclass == 0) and single depth subclass
 57 * are cached in lockdep_map. This optimization is mainly targeting
 58 * on rq->lock. double_rq_lock() acquires this highly competitive with
 59 * single depth.
 60 */
 61#define NR_LOCKDEP_CACHING_CLASSES	2
 62
 63/*
 64 * A lockdep key is associated with each lock object. For static locks we use
 65 * the lock address itself as the key. Dynamically allocated lock objects can
 66 * have a statically or dynamically allocated key. Dynamically allocated lock
 67 * keys must be registered before being used and must be unregistered before
 68 * the key memory is freed.
 69 */
 70struct lockdep_subclass_key {
 71	char __one_byte;
 72} __attribute__ ((__packed__));
 73
 74/* hash_entry is used to keep track of dynamically allocated keys. */
 75struct lock_class_key {
 76	union {
 77		struct hlist_node		hash_entry;
 78		struct lockdep_subclass_key	subkeys[MAX_LOCKDEP_SUBCLASSES];
 79	};
 80};
 81
 82extern struct lock_class_key __lockdep_no_validate__;
 83extern struct lock_class_key __lockdep_no_track__;
 84
 85struct lock_trace;
 86
 87#define LOCKSTAT_POINTS		4
 88
 89struct lockdep_map;
 90typedef int (*lock_cmp_fn)(const struct lockdep_map *a,
 91			   const struct lockdep_map *b);
 92typedef void (*lock_print_fn)(const struct lockdep_map *map);
 93
 94/*
 95 * The lock-class itself. The order of the structure members matters.
 96 * reinit_class() zeroes the key member and all subsequent members.
 97 */
 98struct lock_class {
 99	/*
100	 * class-hash:
101	 */
102	struct hlist_node		hash_entry;
103
104	/*
105	 * Entry in all_lock_classes when in use. Entry in free_lock_classes
106	 * when not in use. Instances that are being freed are on one of the
107	 * zapped_classes lists.
108	 */
109	struct list_head		lock_entry;
110
111	/*
112	 * These fields represent a directed graph of lock dependencies,
113	 * to every node we attach a list of "forward" and a list of
114	 * "backward" graph nodes.
115	 */
116	struct list_head		locks_after, locks_before;
117
118	const struct lockdep_subclass_key *key;
119	lock_cmp_fn			cmp_fn;
120	lock_print_fn			print_fn;
121
122	unsigned int			subclass;
123	unsigned int			dep_gen_id;
124
125	/*
126	 * IRQ/softirq usage tracking bits:
127	 */
128	unsigned long			usage_mask;
129	const struct lock_trace		*usage_traces[LOCK_TRACE_STATES];
130
131	const char			*name;
132	/*
133	 * Generation counter, when doing certain classes of graph walking,
134	 * to ensure that we check one node only once:
135	 */
136	int				name_version;
137
138	u8				wait_type_inner;
139	u8				wait_type_outer;
140	u8				lock_type;
141	/* u8				hole; */
142
143#ifdef CONFIG_LOCK_STAT
144	unsigned long			contention_point[LOCKSTAT_POINTS];
145	unsigned long			contending_point[LOCKSTAT_POINTS];
146#endif
147} __no_randomize_layout;
148
149#ifdef CONFIG_LOCK_STAT
150struct lock_time {
151	s64				min;
152	s64				max;
153	s64				total;
154	unsigned long			nr;
155};
156
157enum bounce_type {
158	bounce_acquired_write,
159	bounce_acquired_read,
160	bounce_contended_write,
161	bounce_contended_read,
162	nr_bounce_types,
163
164	bounce_acquired = bounce_acquired_write,
165	bounce_contended = bounce_contended_write,
166};
167
168struct lock_class_stats {
169	unsigned long			contention_point[LOCKSTAT_POINTS];
170	unsigned long			contending_point[LOCKSTAT_POINTS];
171	struct lock_time		read_waittime;
172	struct lock_time		write_waittime;
173	struct lock_time		read_holdtime;
174	struct lock_time		write_holdtime;
175	unsigned long			bounces[nr_bounce_types];
176};
177
178void lock_stats(struct lock_class *class, struct lock_class_stats *stats);
179void clear_lock_stats(struct lock_class *class);
180#endif
181
182/*
183 * Map the lock object (the lock instance) to the lock-class object.
184 * This is embedded into specific lock instances:
185 */
186struct lockdep_map {
187	struct lock_class_key		*key;
188	struct lock_class		*class_cache[NR_LOCKDEP_CACHING_CLASSES];
189	const char			*name;
190	u8				wait_type_outer; /* can be taken in this context */
191	u8				wait_type_inner; /* presents this context */
192	u8				lock_type;
193	/* u8				hole; */
194#ifdef CONFIG_LOCK_STAT
195	int				cpu;
196	unsigned long			ip;
197#endif
198};
199
200struct pin_cookie { unsigned int val; };
201
202#define MAX_LOCKDEP_KEYS_BITS		13
203#define MAX_LOCKDEP_KEYS		(1UL << MAX_LOCKDEP_KEYS_BITS)
204#define INITIAL_CHAIN_KEY		-1
205
206struct held_lock {
207	/*
208	 * One-way hash of the dependency chain up to this point. We
209	 * hash the hashes step by step as the dependency chain grows.
210	 *
211	 * We use it for dependency-caching and we skip detection
212	 * passes and dependency-updates if there is a cache-hit, so
213	 * it is absolutely critical for 100% coverage of the validator
214	 * to have a unique key value for every unique dependency path
215	 * that can occur in the system, to make a unique hash value
216	 * as likely as possible - hence the 64-bit width.
217	 *
218	 * The task struct holds the current hash value (initialized
219	 * with zero), here we store the previous hash value:
220	 */
221	u64				prev_chain_key;
222	unsigned long			acquire_ip;
223	struct lockdep_map		*instance;
224	struct lockdep_map		*nest_lock;
225#ifdef CONFIG_LOCK_STAT
226	u64 				waittime_stamp;
227	u64				holdtime_stamp;
228#endif
229	/*
230	 * class_idx is zero-indexed; it points to the element in
231	 * lock_classes this held lock instance belongs to. class_idx is in
232	 * the range from 0 to (MAX_LOCKDEP_KEYS-1) inclusive.
233	 */
234	unsigned int			class_idx:MAX_LOCKDEP_KEYS_BITS;
235	/*
236	 * The lock-stack is unified in that the lock chains of interrupt
237	 * contexts nest ontop of process context chains, but we 'separate'
238	 * the hashes by starting with 0 if we cross into an interrupt
239	 * context, and we also keep do not add cross-context lock
240	 * dependencies - the lock usage graph walking covers that area
241	 * anyway, and we'd just unnecessarily increase the number of
242	 * dependencies otherwise. [Note: hardirq and softirq contexts
243	 * are separated from each other too.]
244	 *
245	 * The following field is used to detect when we cross into an
246	 * interrupt context:
247	 */
248	unsigned int irq_context:2; /* bit 0 - soft, bit 1 - hard */
249	unsigned int trylock:1;						/* 16 bits */
250
251	unsigned int read:2;        /* see lock_acquire() comment */
252	unsigned int check:1;       /* see lock_acquire() comment */
253	unsigned int hardirqs_off:1;
254	unsigned int sync:1;
255	unsigned int references:11;					/* 32 bits */
256	unsigned int pin_count;
257};
258
259#else /* !CONFIG_LOCKDEP */
260
261/*
262 * The class key takes no space if lockdep is disabled:
263 */
264struct lock_class_key { };
265
266/*
267 * The lockdep_map takes no space if lockdep is disabled:
268 */
269struct lockdep_map { };
270
271struct pin_cookie { };
272
273#endif /* !LOCKDEP */
274
275#endif /* __LINUX_LOCKDEP_TYPES_H */