[linux-2.6-block.git] / include / linux / lockdep_types.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Runtime locking correctness validator
 *
 *  Copyright (C) 2006,2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
 *  Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra
 *
 * see Documentation/locking/lockdep-design.rst for more details.
 */
#ifndef __LINUX_LOCKDEP_TYPES_H
#define __LINUX_LOCKDEP_TYPES_H

#include <linux/types.h>

#define MAX_LOCKDEP_SUBCLASSES		8UL

enum lockdep_wait_type {
	LD_WAIT_INV = 0,	/* not checked, catch all */

	LD_WAIT_FREE,		/* wait free, rcu etc.. */
	LD_WAIT_SPIN,		/* spin loops, raw_spinlock_t etc.. */

#ifdef CONFIG_PROVE_RAW_LOCK_NESTING
	LD_WAIT_CONFIG,		/* CONFIG_PREEMPT_LOCK, spinlock_t etc.. */
#else
	LD_WAIT_CONFIG = LD_WAIT_SPIN,
#endif
	LD_WAIT_SLEEP,		/* sleeping locks, mutex_t etc.. */

	LD_WAIT_MAX,		/* must be last */
};

#ifdef CONFIG_LOCKDEP

/*
 * We'd rather not expose kernel/lockdep_states.h this wide, but we do need
 * the total number of states... :-(
 *
 * XXX_LOCK_USAGE_STATES is the number of lines in lockdep_states.h, for each
 * of those we generates 4 states, Additionally we report on USED and USED_READ.
 */
#define XXX_LOCK_USAGE_STATES		2
#define LOCK_TRACE_STATES		(XXX_LOCK_USAGE_STATES*4 + 2)

/*
 * NR_LOCKDEP_CACHING_CLASSES ... Number of classes
 * cached in the instance of lockdep_map
 *
 * Currently main class (subclass == 0) and signle depth subclass
 * are cached in lockdep_map. This optimization is mainly targeting
 * on rq->lock. double_rq_lock() acquires this highly competitive with
 * single depth.
 */
#define NR_LOCKDEP_CACHING_CLASSES	2

/*
 * A lockdep key is associated with each lock object. For static locks we use
 * the lock address itself as the key. Dynamically allocated lock objects can
 * have a statically or dynamically allocated key. Dynamically allocated lock
 * keys must be registered before being used and must be unregistered before
 * the key memory is freed.
 */
struct lockdep_subclass_key {
	char __one_byte;
} __attribute__ ((__packed__));

/* hash_entry is used to keep track of dynamically allocated keys. */
struct lock_class_key {
	union {
		struct hlist_node		hash_entry;
		struct lockdep_subclass_key	subkeys[MAX_LOCKDEP_SUBCLASSES];
	};
};

extern struct lock_class_key __lockdep_no_validate__;

struct lock_trace;

#define LOCKSTAT_POINTS		4

/*
 * The lock-class itself. The order of the structure members matters.
 * reinit_class() zeroes the key member and all subsequent members.
 */
struct lock_class {
	/*
	 * class-hash:
	 */
	struct hlist_node		hash_entry;

	/*
	 * Entry in all_lock_classes when in use. Entry in free_lock_classes
	 * when not in use. Instances that are being freed are on one of the
	 * zapped_classes lists.
	 */
	struct list_head		lock_entry;

	/*
	 * These fields represent a directed graph of lock dependencies,
	 * to every node we attach a list of "forward" and a list of
	 * "backward" graph nodes.
	 */
	struct list_head		locks_after, locks_before;

	const struct lockdep_subclass_key *key;
	unsigned int			subclass;
	unsigned int			dep_gen_id;

	/*
	 * IRQ/softirq usage tracking bits:
	 */
	unsigned long			usage_mask;
	const struct lock_trace		*usage_traces[LOCK_TRACE_STATES];

	/*
	 * Generation counter, when doing certain classes of graph walking,
	 * to ensure that we check one node only once:
	 */
	int				name_version;
	const char			*name;

	short				wait_type_inner;
	short				wait_type_outer;

#ifdef CONFIG_LOCK_STAT
	unsigned long			contention_point[LOCKSTAT_POINTS];
	unsigned long			contending_point[LOCKSTAT_POINTS];
#endif
} __no_randomize_layout;

#ifdef CONFIG_LOCK_STAT
struct lock_time {
	s64				min;
	s64				max;
	s64				total;
	unsigned long			nr;
};

enum bounce_type {
	bounce_acquired_write,
	bounce_acquired_read,
	bounce_contended_write,
	bounce_contended_read,
	nr_bounce_types,

	bounce_acquired = bounce_acquired_write,
	bounce_contended = bounce_contended_write,
};

struct lock_class_stats {
	unsigned long			contention_point[LOCKSTAT_POINTS];
	unsigned long			contending_point[LOCKSTAT_POINTS];
	struct lock_time		read_waittime;
	struct lock_time		write_waittime;
	struct lock_time		read_holdtime;
	struct lock_time		write_holdtime;
	unsigned long			bounces[nr_bounce_types];
};

struct lock_class_stats lock_stats(struct lock_class *class);
void clear_lock_stats(struct lock_class *class);
#endif

/*
 * Map the lock object (the lock instance) to the lock-class object.
 * This is embedded into specific lock instances:
 */
struct lockdep_map {
	struct lock_class_key		*key;
	struct lock_class		*class_cache[NR_LOCKDEP_CACHING_CLASSES];
	const char			*name;
	short				wait_type_outer; /* can be taken in this context */
	short				wait_type_inner; /* presents this context */
#ifdef CONFIG_LOCK_STAT
	int				cpu;
	unsigned long			ip;
#endif
};

struct pin_cookie { unsigned int val; };

#else /* !CONFIG_LOCKDEP */

/*
 * The class key takes no space if lockdep is disabled:
 */
struct lock_class_key { };

/*
 * The lockdep_map takes no space if lockdep is disabled:
 */
struct lockdep_map { };

struct pin_cookie { };

#endif /* !LOCKDEP */

#endif /* __LINUX_LOCKDEP_TYPES_H */
Commit	Line	Data
c935cd62 HX	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
	17	enum 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, /* CONFIG_PREEMPT_LOCK, 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
	33	#ifdef CONFIG_LOCKDEP
	34
c935cd62 HX	35	/*
	36	* We'd rather not expose kernel/lockdep_states.h this wide, but we do need
	37	* the total number of states... :-(
2bb8945b PZ	38	*
	39	* XXX_LOCK_USAGE_STATES is the number of lines in lockdep_states.h, for each
	40	* of those we generates 4 states, Additionally we report on USED and USED_READ.
c935cd62	41	*/
2bb8945b PZ	42	#define XXX_LOCK_USAGE_STATES 2
2bb8945b PZ	43	#define LOCK_TRACE_STATES (XXX_LOCK_USAGE_STATES*4 + 2)
c935cd62 HX	44
	45	/*
	46	* NR_LOCKDEP_CACHING_CLASSES ... Number of classes
	47	* cached in the instance of lockdep_map
	48	*
	49	* Currently main class (subclass == 0) and signle depth subclass
	50	* are cached in lockdep_map. This optimization is mainly targeting
	51	* on rq->lock. double_rq_lock() acquires this highly competitive with
	52	* single depth.
	53	*/
	54	#define NR_LOCKDEP_CACHING_CLASSES 2
	55
	56	/*
	57	* A lockdep key is associated with each lock object. For static locks we use
	58	* the lock address itself as the key. Dynamically allocated lock objects can
	59	* have a statically or dynamically allocated key. Dynamically allocated lock
	60	* keys must be registered before being used and must be unregistered before
	61	* the key memory is freed.
	62	*/
	63	struct lockdep_subclass_key {
	64	char __one_byte;
	65	} __attribute__ ((__packed__));
	66
	67	/* hash_entry is used to keep track of dynamically allocated keys. */
	68	struct lock_class_key {
	69	union {
	70	struct hlist_node hash_entry;
	71	struct lockdep_subclass_key subkeys[MAX_LOCKDEP_SUBCLASSES];
	72	};
	73	};
	74
	75	extern struct lock_class_key __lockdep_no_validate__;
	76
	77	struct lock_trace;
	78
	79	#define LOCKSTAT_POINTS 4
	80
	81	/*
	82	* The lock-class itself. The order of the structure members matters.
	83	* reinit_class() zeroes the key member and all subsequent members.
	84	*/
	85	struct lock_class {
	86	/*
	87	* class-hash:
	88	*/
	89	struct hlist_node hash_entry;
	90
	91	/*
	92	* Entry in all_lock_classes when in use. Entry in free_lock_classes
	93	* when not in use. Instances that are being freed are on one of the
	94	* zapped_classes lists.
	95	*/
	96	struct list_head lock_entry;
	97
	98	/*
	99	* These fields represent a directed graph of lock dependencies,
	100	* to every node we attach a list of "forward" and a list of
	101	* "backward" graph nodes.
	102	*/
	103	struct list_head locks_after, locks_before;
	104
	105	const struct lockdep_subclass_key *key;
	106	unsigned int subclass;
	107	unsigned int dep_gen_id;
108
109	/*
110	* IRQ/softirq usage tracking bits:
111	*/
112	unsigned long usage_mask;
2bb8945b	113	const struct lock_trace *usage_traces[LOCK_TRACE_STATES];
c935cd62 HX	114
	115	/*
	116	* Generation counter, when doing certain classes of graph walking,
	117	* to ensure that we check one node only once:
	118	*/
	119	int name_version;
	120	const char *name;
	121
	122	short wait_type_inner;
	123	short wait_type_outer;
	124
	125	#ifdef CONFIG_LOCK_STAT
	126	unsigned long contention_point[LOCKSTAT_POINTS];
	127	unsigned long contending_point[LOCKSTAT_POINTS];
	128	#endif
	129	} __no_randomize_layout;
	130
	131	#ifdef CONFIG_LOCK_STAT
	132	struct lock_time {
	133	s64 min;
	134	s64 max;
	135	s64 total;
	136	unsigned long nr;
	137	};
	138
	139	enum bounce_type {
	140	bounce_acquired_write,
	141	bounce_acquired_read,
	142	bounce_contended_write,
	143	bounce_contended_read,
	144	nr_bounce_types,
	145
	146	bounce_acquired = bounce_acquired_write,
	147	bounce_contended = bounce_contended_write,
	148	};
	149
	150	struct lock_class_stats {
	151	unsigned long contention_point[LOCKSTAT_POINTS];
	152	unsigned long contending_point[LOCKSTAT_POINTS];
	153	struct lock_time read_waittime;
	154	struct lock_time write_waittime;
	155	struct lock_time read_holdtime;
	156	struct lock_time write_holdtime;
	157	unsigned long bounces[nr_bounce_types];
	158	};
	159
	160	struct lock_class_stats lock_stats(struct lock_class *class);
	161	void clear_lock_stats(struct lock_class *class);
	162	#endif
	163
	164	/*
	165	* Map the lock object (the lock instance) to the lock-class object.
	166	* This is embedded into specific lock instances:
	167	*/
	168	struct lockdep_map {
	169	struct lock_class_key *key;
	170	struct lock_class *class_cache[NR_LOCKDEP_CACHING_CLASSES];
	171	const char *name;
	172	short wait_type_outer; /* can be taken in this context */
	173	short wait_type_inner; /* presents this context */
	174	#ifdef CONFIG_LOCK_STAT
	175	int cpu;
	176	unsigned long ip;
	177	#endif
178	};
179
180	struct pin_cookie { unsigned int val; };
181
182	#else /* !CONFIG_LOCKDEP */
183
184	/*
185	* The class key takes no space if lockdep is disabled:
186	*/
187	struct lock_class_key { };
188
189	/*
190	* The lockdep_map takes no space if lockdep is disabled:
191	*/
192	struct lockdep_map { };
193
194	struct pin_cookie { };
195
196	#endif /* !LOCKDEP */
197
198	#endif /* __LINUX_LOCKDEP_TYPES_H */