1 files changed, 347 insertions, 0 deletions
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
new file mode 100644
index 000000000000..80ec7a4dbc98
--- /dev/null
+++ b/include/linux/lockdep.h
@@ -0,0 +1,347 @@
+/*
+ * Runtime locking correctness validator
+ *
+ *  Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
+ *
+ * see Documentation/lockdep-design.txt for more details.
+ */
+#ifndef __LINUX_LOCKDEP_H
+#define __LINUX_LOCKDEP_H
+#include <linux/linkage.h>
+#include <linux/list.h>
+#include <linux/debug_locks.h>
+#include <linux/stacktrace.h>
+#ifdef CONFIG_LOCKDEP
+/*
+ * Lock-class usage-state bits:
+ */
+enum lock_usage_bit
+{
+        LOCK_USED = 0,
+        LOCK_USED_IN_HARDIRQ,
+        LOCK_USED_IN_SOFTIRQ,
+        LOCK_ENABLED_SOFTIRQS,
+        LOCK_ENABLED_HARDIRQS,
+        LOCK_USED_IN_HARDIRQ_READ,
+        LOCK_USED_IN_SOFTIRQ_READ,
+        LOCK_ENABLED_SOFTIRQS_READ,
+        LOCK_ENABLED_HARDIRQS_READ,
+        LOCK_USAGE_STATES
+};
+/*
+ * Usage-state bitmasks:
+ */
+#define LOCKF_USED                      (1 << LOCK_USED)
+#define LOCKF_USED_IN_HARDIRQ           (1 << LOCK_USED_IN_HARDIRQ)
+#define LOCKF_USED_IN_SOFTIRQ           (1 << LOCK_USED_IN_SOFTIRQ)
+#define LOCKF_ENABLED_HARDIRQS          (1 << LOCK_ENABLED_HARDIRQS)
+#define LOCKF_ENABLED_SOFTIRQS          (1 << LOCK_ENABLED_SOFTIRQS)
+#define LOCKF_ENABLED_IRQS (LOCKF_ENABLED_HARDIRQS | LOCKF_ENABLED_SOFTIRQS)
+#define LOCKF_USED_IN_IRQ (LOCKF_USED_IN_HARDIRQ | LOCKF_USED_IN_SOFTIRQ)
+#define LOCKF_USED_IN_HARDIRQ_READ      (1 << LOCK_USED_IN_HARDIRQ_READ)
+#define LOCKF_USED_IN_SOFTIRQ_READ      (1 << LOCK_USED_IN_SOFTIRQ_READ)
+#define LOCKF_ENABLED_HARDIRQS_READ     (1 << LOCK_ENABLED_HARDIRQS_READ)
+#define LOCKF_ENABLED_SOFTIRQS_READ     (1 << LOCK_ENABLED_SOFTIRQS_READ)
+#define LOCKF_ENABLED_IRQS_READ \
+                (LOCKF_ENABLED_HARDIRQS_READ | LOCKF_ENABLED_SOFTIRQS_READ)
+#define LOCKF_USED_IN_IRQ_READ \
+                (LOCKF_USED_IN_HARDIRQ_READ | LOCKF_USED_IN_SOFTIRQ_READ)
+#define MAX_LOCKDEP_SUBCLASSES          8UL
+/*
+ * Lock-classes are keyed via unique addresses, by embedding the
+ * lockclass-key into the kernel (or module) .data section. (For
+ * static locks we use the lock address itself as the key.)
+ */
+struct lockdep_subclass_key {
+        char __one_byte;
+} __attribute__ ((__packed__));
+struct lock_class_key {
+        struct lockdep_subclass_key     subkeys[MAX_LOCKDEP_SUBCLASSES];
+};
+/*
+ * The lock-class itself:
+ */
+struct lock_class {
+        /*
+         * class-hash:
+         */
+        struct list_head                hash_entry;
+        /*
+         * global list of all lock-classes:
+         */
+        struct list_head                lock_entry;
+        struct lockdep_subclass_key     *key;
+        unsigned int                    subclass;
+        /*
+         * IRQ/softirq usage tracking bits:
+         */
+        unsigned long                   usage_mask;
+        struct stack_trace              usage_traces[LOCK_USAGE_STATES];
+        /*
+         * 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;
+        /*
+         * Generation counter, when doing certain classes of graph walking,
+         * to ensure that we check one node only once:
+         */
+        unsigned int                    version;
+        /*
+         * Statistics counter:
+         */
+        unsigned long                   ops;
+        const char                      *name;
+        int                             name_version;
+};
+/*
+ * 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[MAX_LOCKDEP_SUBCLASSES];
+        const char                      *name;
+};
+/*
+ * Every lock has a list of other locks that were taken after it.
+ * We only grow the list, never remove from it:
+ */
+struct lock_list {
+        struct list_head                entry;
+        struct lock_class               *class;
+        struct stack_trace              trace;
+};
+/*
+ * We record lock dependency chains, so that we can cache them:
+ */
+struct lock_chain {
+        struct list_head                entry;
+        u64                             chain_key;
+};
+struct held_lock {
+        /*
+         * One-way hash of the dependency chain up to this point. We
+         * hash the hashes step by step as the dependency chain grows.
+         *
+         * We use it for dependency-caching and we skip detection
+         * passes and dependency-updates if there is a cache-hit, so
+         * it is absolutely critical for 100% coverage of the validator
+         * to have a unique key value for every unique dependency path
+         * that can occur in the system, to make a unique hash value
+         * as likely as possible - hence the 64-bit width.
+         *
+         * The task struct holds the current hash value (initialized
+         * with zero), here we store the previous hash value:
+         */
+        u64                             prev_chain_key;
+        struct lock_class               *class;
+        unsigned long                   acquire_ip;
+        struct lockdep_map              *instance;
+        /*
+         * The lock-stack is unified in that the lock chains of interrupt
+         * contexts nest ontop of process context chains, but we 'separate'
+         * the hashes by starting with 0 if we cross into an interrupt
+         * context, and we also keep do not add cross-context lock
+         * dependencies - the lock usage graph walking covers that area
+         * anyway, and we'd just unnecessarily increase the number of
+         * dependencies otherwise. [Note: hardirq and softirq contexts
+         * are separated from each other too.]
+         *
+         * The following field is used to detect when we cross into an
+         * interrupt context:
+         */
+        int                             irq_context;
+        int                             trylock;
+        int                             read;
+        int                             check;
+        int                             hardirqs_off;
+};
+/*
+ * Initialization, self-test and debugging-output methods:
+ */
+extern void lockdep_init(void);
+extern void lockdep_info(void);
+extern void lockdep_reset(void);
+extern void lockdep_reset_lock(struct lockdep_map *lock);
+extern void lockdep_free_key_range(void *start, unsigned long size);
+extern void lockdep_off(void);
+extern void lockdep_on(void);
+extern int lockdep_internal(void);
+/*
+ * These methods are used by specific locking variants (spinlocks,
+ * rwlocks, mutexes and rwsems) to pass init/acquire/release events
+ * to lockdep:
+ */
+extern void lockdep_init_map(struct lockdep_map *lock, const char *name,
+                             struct lock_class_key *key);
+/*
+ * Reinitialize a lock key - for cases where there is special locking or
+ * special initialization of locks so that the validator gets the scope
+ * of dependencies wrong: they are either too broad (they need a class-split)
+ * or they are too narrow (they suffer from a false class-split):
+ */
+#define lockdep_set_class(lock, key) \
+                lockdep_init_map(&(lock)->dep_map, #key, key)
+#define lockdep_set_class_and_name(lock, key, name) \
+                lockdep_init_map(&(lock)->dep_map, name, key)
+/*
+ * Acquire a lock.
+ *
+ * Values for "read":
+ *
+ *   0: exclusive (write) acquire
+ *   1: read-acquire (no recursion allowed)
+ *   2: read-acquire with same-instance recursion allowed
+ *
+ * Values for check:
+ *
+ *   0: disabled
+ *   1: simple checks (freeing, held-at-exit-time, etc.)
+ *   2: full validation
+ */
+extern void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
+                         int trylock, int read, int check, unsigned long ip);
+extern void lock_release(struct lockdep_map *lock, int nested,
+                         unsigned long ip);
+# define INIT_LOCKDEP                           .lockdep_recursion = 0,
+#else /* !LOCKDEP */
+static inline void lockdep_off(void)
+{
+}
+static inline void lockdep_on(void)
+{
+}
+static inline int lockdep_internal(void)
+{
+        return 0;
+}
+# define lock_acquire(l, s, t, r, c, i)         do { } while (0)
+# define lock_release(l, n, i)                  do { } while (0)
+# define lockdep_init()                         do { } while (0)
+# define lockdep_info()                         do { } while (0)
+# define lockdep_init_map(lock, name, key)      do { (void)(key); } while (0)
+# define lockdep_set_class(lock, key)           do { (void)(key); } while (0)
+# define lockdep_set_class_and_name(lock, key, name) \
+                do { (void)(key); } while (0)
+# define INIT_LOCKDEP
+# define lockdep_reset()                do { debug_locks = 1; } while (0)
+# define lockdep_free_key_range(start, size)    do { } while (0)
+/*
+ * The class key takes no space if lockdep is disabled:
+ */
+struct lock_class_key { };
+#endif /* !LOCKDEP */
+#ifdef CONFIG_TRACE_IRQFLAGS
+extern void early_boot_irqs_off(void);
+extern void early_boot_irqs_on(void);
+#else
+# define early_boot_irqs_off()                  do { } while (0)
+# define early_boot_irqs_on()                   do { } while (0)
+#endif
+/*
+ * For trivial one-depth nesting of a lock-class, the following
+ * global define can be used. (Subsystems with multiple levels
+ * of nesting should define their own lock-nesting subclasses.)
+ */
+#define SINGLE_DEPTH_NESTING                    1
+/*
+ * Map the dependency ops to NOP or to real lockdep ops, depending
+ * on the per lock-class debug mode:
+ */
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+# ifdef CONFIG_PROVE_LOCKING
+#  define spin_acquire(l, s, t, i)              lock_acquire(l, s, t, 0, 2, i)
+# else
+#  define spin_acquire(l, s, t, i)              lock_acquire(l, s, t, 0, 1, i)
+# endif
+# define spin_release(l, n, i)                  lock_release(l, n, i)
+#else
+# define spin_acquire(l, s, t, i)               do { } while (0)
+# define spin_release(l, n, i)                  do { } while (0)
+#endif
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+# ifdef CONFIG_PROVE_LOCKING
+#  define rwlock_acquire(l, s, t, i)            lock_acquire(l, s, t, 0, 2, i)
+#  define rwlock_acquire_read(l, s, t, i)       lock_acquire(l, s, t, 2, 2, i)
+# else
+#  define rwlock_acquire(l, s, t, i)            lock_acquire(l, s, t, 0, 1, i)
+#  define rwlock_acquire_read(l, s, t, i)       lock_acquire(l, s, t, 2, 1, i)
+# endif
+# define rwlock_release(l, n, i)                lock_release(l, n, i)
+#else
+# define rwlock_acquire(l, s, t, i)             do { } while (0)
+# define rwlock_acquire_read(l, s, t, i)        do { } while (0)
+# define rwlock_release(l, n, i)                do { } while (0)
+#endif
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+# ifdef CONFIG_PROVE_LOCKING
+#  define mutex_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 2, i)
+# else
+#  define mutex_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 1, i)
+# endif
+# define mutex_release(l, n, i)                 lock_release(l, n, i)
+#else
+# define mutex_acquire(l, s, t, i)              do { } while (0)
+# define mutex_release(l, n, i)                 do { } while (0)
+#endif
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+# ifdef CONFIG_PROVE_LOCKING
+#  define rwsem_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 2, i)
+#  define rwsem_acquire_read(l, s, t, i)        lock_acquire(l, s, t, 1, 2, i)
+# else
+#  define rwsem_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 1, i)
+#  define rwsem_acquire_read(l, s, t, i)        lock_acquire(l, s, t, 1, 1, i)
+# endif
+# define rwsem_release(l, n, i)                 lock_release(l, n, i)
+#else
+# define rwsem_acquire(l, s, t, i)              do { } while (0)
+# define rwsem_acquire_read(l, s, t, i)         do { } while (0)
+# define rwsem_release(l, n, i)                 do { } while (0)
+#endif
+#endif /* __LINUX_LOCKDEP_H */

diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h new file mode 100644 index 000000000000..80ec7a4dbc98 --- /dev/null +++ b/include/linux/lockdep.h
@@ -0,0 +1,347 @@
	1	/*
	2	* Runtime locking correctness validator
	3	*
	4	* Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
	5	*
	6	* see Documentation/lockdep-design.txt for more details.
	7	*/
	8	#ifndef __LINUX_LOCKDEP_H
	9	#define __LINUX_LOCKDEP_H
	10
	11	#include <linux/linkage.h>
	12	#include <linux/list.h>
	13	#include <linux/debug_locks.h>
	14	#include <linux/stacktrace.h>
	15
	16	#ifdef CONFIG_LOCKDEP
	17
	18	/*
	19	* Lock-class usage-state bits:
	20	*/
	21	enum lock_usage_bit
	22	{
	23	LOCK_USED = 0,
	24	LOCK_USED_IN_HARDIRQ,
	25	LOCK_USED_IN_SOFTIRQ,
	26	LOCK_ENABLED_SOFTIRQS,
	27	LOCK_ENABLED_HARDIRQS,
	28	LOCK_USED_IN_HARDIRQ_READ,
	29	LOCK_USED_IN_SOFTIRQ_READ,
	30	LOCK_ENABLED_SOFTIRQS_READ,
	31	LOCK_ENABLED_HARDIRQS_READ,
	32	LOCK_USAGE_STATES
	33	};
	34
	35	/*
	36	* Usage-state bitmasks:
	37	*/
	38	#define LOCKF_USED (1 << LOCK_USED)
	39	#define LOCKF_USED_IN_HARDIRQ (1 << LOCK_USED_IN_HARDIRQ)
	40	#define LOCKF_USED_IN_SOFTIRQ (1 << LOCK_USED_IN_SOFTIRQ)
	41	#define LOCKF_ENABLED_HARDIRQS (1 << LOCK_ENABLED_HARDIRQS)
	42	#define LOCKF_ENABLED_SOFTIRQS (1 << LOCK_ENABLED_SOFTIRQS)
	43
	44	#define LOCKF_ENABLED_IRQS (LOCKF_ENABLED_HARDIRQS \| LOCKF_ENABLED_SOFTIRQS)
	45	#define LOCKF_USED_IN_IRQ (LOCKF_USED_IN_HARDIRQ \| LOCKF_USED_IN_SOFTIRQ)
	46
	47	#define LOCKF_USED_IN_HARDIRQ_READ (1 << LOCK_USED_IN_HARDIRQ_READ)
	48	#define LOCKF_USED_IN_SOFTIRQ_READ (1 << LOCK_USED_IN_SOFTIRQ_READ)
	49	#define LOCKF_ENABLED_HARDIRQS_READ (1 << LOCK_ENABLED_HARDIRQS_READ)
	50	#define LOCKF_ENABLED_SOFTIRQS_READ (1 << LOCK_ENABLED_SOFTIRQS_READ)
	51
	52	#define LOCKF_ENABLED_IRQS_READ \
	53	(LOCKF_ENABLED_HARDIRQS_READ \| LOCKF_ENABLED_SOFTIRQS_READ)
	54	#define LOCKF_USED_IN_IRQ_READ \
	55	(LOCKF_USED_IN_HARDIRQ_READ \| LOCKF_USED_IN_SOFTIRQ_READ)
	56
	57	#define MAX_LOCKDEP_SUBCLASSES 8UL
	58
	59	/*
	60	* Lock-classes are keyed via unique addresses, by embedding the
	61	* lockclass-key into the kernel (or module) .data section. (For
	62	* static locks we use the lock address itself as the key.)
	63	*/
	64	struct lockdep_subclass_key {
	65	char __one_byte;
	66	} __attribute__ ((__packed__));
	67
	68	struct lock_class_key {
	69	struct lockdep_subclass_key subkeys[MAX_LOCKDEP_SUBCLASSES];
	70	};
	71
	72	/*
	73	* The lock-class itself:
	74	*/
	75	struct lock_class {
	76	/*
	77	* class-hash:
	78	*/
	79	struct list_head hash_entry;
	80
	81	/*
	82	* global list of all lock-classes:
	83	*/
	84	struct list_head lock_entry;
	85
	86	struct lockdep_subclass_key *key;
	87	unsigned int subclass;
	88
	89	/*
	90	* IRQ/softirq usage tracking bits:
	91	*/
	92	unsigned long usage_mask;
	93	struct stack_trace usage_traces[LOCK_USAGE_STATES];
	94
	95	/*
	96	* These fields represent a directed graph of lock dependencies,
	97	* to every node we attach a list of "forward" and a list of
	98	* "backward" graph nodes.
	99	*/
	100	struct list_head locks_after, locks_before;
	101
	102	/*
	103	* Generation counter, when doing certain classes of graph walking,
	104	* to ensure that we check one node only once:
	105	*/
	106	unsigned int version;
	107
	108	/*
	109	* Statistics counter:
	110	*/
	111	unsigned long ops;
	112
	113	const char *name;
	114	int name_version;
	115	};
	116
	117	/*
	118	* Map the lock object (the lock instance) to the lock-class object.
	119	* This is embedded into specific lock instances:
	120	*/
	121	struct lockdep_map {
	122	struct lock_class_key *key;
	123	struct lock_class *class[MAX_LOCKDEP_SUBCLASSES];
	124	const char *name;
	125	};
	126
	127	/*
	128	* Every lock has a list of other locks that were taken after it.
	129	* We only grow the list, never remove from it:
	130	*/
	131	struct lock_list {
	132	struct list_head entry;
	133	struct lock_class *class;
	134	struct stack_trace trace;
	135	};
	136
	137	/*
	138	* We record lock dependency chains, so that we can cache them:
	139	*/
	140	struct lock_chain {
	141	struct list_head entry;
	142	u64 chain_key;
	143	};
	144
	145	struct held_lock {
	146	/*
	147	* One-way hash of the dependency chain up to this point. We
	148	* hash the hashes step by step as the dependency chain grows.
	149	*
	150	* We use it for dependency-caching and we skip detection
	151	* passes and dependency-updates if there is a cache-hit, so
	152	* it is absolutely critical for 100% coverage of the validator
	153	* to have a unique key value for every unique dependency path
	154	* that can occur in the system, to make a unique hash value
	155	* as likely as possible - hence the 64-bit width.
	156	*
	157	* The task struct holds the current hash value (initialized
	158	* with zero), here we store the previous hash value:
	159	*/
	160	u64 prev_chain_key;
	161	struct lock_class *class;
	162	unsigned long acquire_ip;
	163	struct lockdep_map *instance;
	164
	165	/*
	166	* The lock-stack is unified in that the lock chains of interrupt
	167	* contexts nest ontop of process context chains, but we 'separate'
	168	* the hashes by starting with 0 if we cross into an interrupt
	169	* context, and we also keep do not add cross-context lock
	170	* dependencies - the lock usage graph walking covers that area
	171	* anyway, and we'd just unnecessarily increase the number of
	172	* dependencies otherwise. [Note: hardirq and softirq contexts
	173	* are separated from each other too.]
	174	*
	175	* The following field is used to detect when we cross into an
	176	* interrupt context:
	177	*/
	178	int irq_context;
	179	int trylock;
	180	int read;
	181	int check;
	182	int hardirqs_off;
	183	};
	184
	185	/*
	186	* Initialization, self-test and debugging-output methods:
	187	*/
	188	extern void lockdep_init(void);
	189	extern void lockdep_info(void);
	190	extern void lockdep_reset(void);
	191	extern void lockdep_reset_lock(struct lockdep_map *lock);
	192	extern void lockdep_free_key_range(void *start, unsigned long size);
	193
	194	extern void lockdep_off(void);
	195	extern void lockdep_on(void);
	196	extern int lockdep_internal(void);
	197
	198	/*
	199	* These methods are used by specific locking variants (spinlocks,
	200	* rwlocks, mutexes and rwsems) to pass init/acquire/release events
	201	* to lockdep:
	202	*/
	203
	204	extern void lockdep_init_map(struct lockdep_map lock, const char name,
	205	struct lock_class_key *key);
	206
	207	/*
	208	* Reinitialize a lock key - for cases where there is special locking or
	209	* special initialization of locks so that the validator gets the scope
	210	* of dependencies wrong: they are either too broad (they need a class-split)
	211	* or they are too narrow (they suffer from a false class-split):
	212	*/
	213	#define lockdep_set_class(lock, key) \
	214	lockdep_init_map(&(lock)->dep_map, #key, key)
	215	#define lockdep_set_class_and_name(lock, key, name) \
	216	lockdep_init_map(&(lock)->dep_map, name, key)
	217
	218	/*
	219	* Acquire a lock.
	220	*
	221	* Values for "read":
	222	*
	223	* 0: exclusive (write) acquire
	224	* 1: read-acquire (no recursion allowed)
	225	* 2: read-acquire with same-instance recursion allowed
	226	*
	227	* Values for check:
	228	*
	229	* 0: disabled
	230	* 1: simple checks (freeing, held-at-exit-time, etc.)
	231	* 2: full validation
	232	*/
	233	extern void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
	234	int trylock, int read, int check, unsigned long ip);
	235
	236	extern void lock_release(struct lockdep_map *lock, int nested,
	237	unsigned long ip);
	238
	239	# define INIT_LOCKDEP .lockdep_recursion = 0,
	240
	241	#else /* !LOCKDEP */
	242
	243	static inline void lockdep_off(void)
	244	{
	245	}
	246
	247	static inline void lockdep_on(void)
	248	{
	249	}
	250
	251	static inline int lockdep_internal(void)
	252	{
	253	return 0;
	254	}
	255
	256	# define lock_acquire(l, s, t, r, c, i) do { } while (0)
	257	# define lock_release(l, n, i) do { } while (0)
	258	# define lockdep_init() do { } while (0)
	259	# define lockdep_info() do { } while (0)
	260	# define lockdep_init_map(lock, name, key) do { (void)(key); } while (0)
	261	# define lockdep_set_class(lock, key) do { (void)(key); } while (0)
	262	# define lockdep_set_class_and_name(lock, key, name) \
	263	do { (void)(key); } while (0)
	264	# define INIT_LOCKDEP
	265	# define lockdep_reset() do { debug_locks = 1; } while (0)
	266	# define lockdep_free_key_range(start, size) do { } while (0)
	267	/*
	268	* The class key takes no space if lockdep is disabled:
	269	*/
	270	struct lock_class_key { };
	271	#endif /* !LOCKDEP */
	272
	273	#ifdef CONFIG_TRACE_IRQFLAGS
	274	extern void early_boot_irqs_off(void);
	275	extern void early_boot_irqs_on(void);
	276	#else
	277	# define early_boot_irqs_off() do { } while (0)
	278	# define early_boot_irqs_on() do { } while (0)
	279	#endif
	280
	281	/*
	282	* For trivial one-depth nesting of a lock-class, the following
	283	* global define can be used. (Subsystems with multiple levels
	284	* of nesting should define their own lock-nesting subclasses.)
	285	*/
	286	#define SINGLE_DEPTH_NESTING 1
	287
	288	/*
	289	* Map the dependency ops to NOP or to real lockdep ops, depending
	290	* on the per lock-class debug mode:
	291	*/
	292
	293	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	294	# ifdef CONFIG_PROVE_LOCKING
	295	# define spin_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 2, i)
	296	# else
	297	# define spin_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 1, i)
	298	# endif
	299	# define spin_release(l, n, i) lock_release(l, n, i)
	300	#else
	301	# define spin_acquire(l, s, t, i) do { } while (0)
	302	# define spin_release(l, n, i) do { } while (0)
	303	#endif
	304
	305	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	306	# ifdef CONFIG_PROVE_LOCKING
	307	# define rwlock_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 2, i)
	308	# define rwlock_acquire_read(l, s, t, i) lock_acquire(l, s, t, 2, 2, i)
	309	# else
	310	# define rwlock_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 1, i)
	311	# define rwlock_acquire_read(l, s, t, i) lock_acquire(l, s, t, 2, 1, i)
	312	# endif
	313	# define rwlock_release(l, n, i) lock_release(l, n, i)
	314	#else
	315	# define rwlock_acquire(l, s, t, i) do { } while (0)
	316	# define rwlock_acquire_read(l, s, t, i) do { } while (0)
	317	# define rwlock_release(l, n, i) do { } while (0)
	318	#endif
	319
	320	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	321	# ifdef CONFIG_PROVE_LOCKING
	322	# define mutex_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 2, i)
	323	# else
	324	# define mutex_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 1, i)
	325	# endif
	326	# define mutex_release(l, n, i) lock_release(l, n, i)
	327	#else
	328	# define mutex_acquire(l, s, t, i) do { } while (0)
	329	# define mutex_release(l, n, i) do { } while (0)
	330	#endif
	331
	332	#ifdef CONFIG_DEBUG_LOCK_ALLOC
	333	# ifdef CONFIG_PROVE_LOCKING
	334	# define rwsem_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 2, i)
	335	# define rwsem_acquire_read(l, s, t, i) lock_acquire(l, s, t, 1, 2, i)
	336	# else
	337	# define rwsem_acquire(l, s, t, i) lock_acquire(l, s, t, 0, 1, i)
	338	# define rwsem_acquire_read(l, s, t, i) lock_acquire(l, s, t, 1, 1, i)
	339	# endif
	340	# define rwsem_release(l, n, i) lock_release(l, n, i)
	341	#else
	342	# define rwsem_acquire(l, s, t, i) do { } while (0)
	343	# define rwsem_acquire_read(l, s, t, i) do { } while (0)
	344	# define rwsem_release(l, n, i) do { } while (0)
	345	#endif
	346
	347	#endif /* __LINUX_LOCKDEP_H */