lael-labs/linux

Documentation/spinlocks.txt+1−23

@@ -86,7 +86,7 @@ to change the variables it has to get an exclusive write lock. · 85 unmodified lines
86		86
87	The routines look the same as above:	87	The routines look the same as above:
88		88
89	rwlock_t xxx_lock = RW_LOCK_UNLOCKED;	89	rwlock_t xxx_lock = __RW_LOCK_UNLOCKED(xxx_lock);
90		90
91	unsigned long flags;	91	unsigned long flags;
92		92
@@ -196,25 +196,3 @@ appropriate: · 103 unmodified lines
196		196
197	For static initialization, use DEFINE_SPINLOCK() / DEFINE_RWLOCK() or	197	For static initialization, use DEFINE_SPINLOCK() / DEFINE_RWLOCK() or
198	__SPIN_LOCK_UNLOCKED() / __RW_LOCK_UNLOCKED() as appropriate.	198	__SPIN_LOCK_UNLOCKED() / __RW_LOCK_UNLOCKED() as appropriate.
199
200	SPIN_LOCK_UNLOCKED and RW_LOCK_UNLOCKED are deprecated. These interfere
201	with lockdep state tracking.
202
203	Most of the time, you can simply turn:
204	static spinlock_t xxx_lock = SPIN_LOCK_UNLOCKED;
205	into:
206	static DEFINE_SPINLOCK(xxx_lock);
207
208	Static structure member variables go from:
209
210	struct foo bar {
211	.lock = SPIN_LOCK_UNLOCKED;
212	};
213
214	to:
215
216	struct foo bar {
217	.lock = __SPIN_LOCK_UNLOCKED(bar.lock);
218	};
219
220	Declaration of static rw_locks undergo a similar transformation.

arch/alpha/include/asm/rwsem.h+0−36

@@ -13,44 +13,13 @@ · 12 unmodified lines
13	#ifdef __KERNEL__	13	#ifdef __KERNEL__
14		14
15	#include <linux/compiler.h>	15	#include <linux/compiler.h>
16	#include <linux/list.h>
17	#include <linux/spinlock.h>
18		16
19	struct rwsem_waiter;
20
21	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore sem);
22	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore sem);
23	extern struct rw_semaphore rwsem_wake(struct rw_semaphore );
24	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore sem);
25
26	/*
27	* the semaphore definition
28	*/
29	struct rw_semaphore {
30	long count;
31	#define RWSEM_UNLOCKED_VALUE 0x0000000000000000L	17	#define RWSEM_UNLOCKED_VALUE 0x0000000000000000L
32	#define RWSEM_ACTIVE_BIAS 0x0000000000000001L	18	#define RWSEM_ACTIVE_BIAS 0x0000000000000001L
33	#define RWSEM_ACTIVE_MASK 0x00000000ffffffffL	19	#define RWSEM_ACTIVE_MASK 0x00000000ffffffffL
34	#define RWSEM_WAITING_BIAS (-0x0000000100000000L)	20	#define RWSEM_WAITING_BIAS (-0x0000000100000000L)
35	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS	21	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS
36	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)	22	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
37	spinlock_t wait_lock;
38	struct list_head wait_list;
39	};
40
41	#define __RWSEM_INITIALIZER(name) \
42	{ RWSEM_UNLOCKED_VALUE, SPIN_LOCK_UNLOCKED, \
43	LIST_HEAD_INIT((name).wait_list) }
44
45	#define DECLARE_RWSEM(name) \
46	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
47
48	static inline void init_rwsem(struct rw_semaphore *sem)
49	{
50	sem->count = RWSEM_UNLOCKED_VALUE;
51	spin_lock_init(&sem->wait_lock);
52	INIT_LIST_HEAD(&sem->wait_list);
53	}
54		23
55	static inline void __down_read(struct rw_semaphore *sem)	24	static inline void __down_read(struct rw_semaphore *sem)
56	{	25	{
@@ -250,10 +219,5 @@ static inline long rwsem_atomic_update(long val, struct rw_semaphore *sem) · 193 unmodified lines
250	#endif	219	#endif
251	}	220	}
252		221
253	static inline int rwsem_is_locked(struct rw_semaphore *sem)
254	{
255	return (sem->count != 0);
256	}
257
258	#endif /* __KERNEL__ */	222	#endif /* __KERNEL__ */
259	#endif /* _ALPHA_RWSEM_H */	223	#endif /* _ALPHA_RWSEM_H */

arch/cris/arch-v32/kernel/smp.c+3−1

@@ -26,7 +26,9 @@ · 25 unmodified lines
26	#define FLUSH_ALL (void*)0xffffffff	26	#define FLUSH_ALL (void*)0xffffffff
27		27
28	/* Vector of locks used for various atomic operations */	28	/* Vector of locks used for various atomic operations */
29	spinlock_t cris_atomic_locks[] = { [0 ... LOCK_COUNT - 1] = SPIN_LOCK_UNLOCKED};	29	spinlock_t cris_atomic_locks[] = {
		30	[0 ... LOCK_COUNT - 1] = __SPIN_LOCK_UNLOCKED(cris_atomic_locks)
		31	};
30		32
31	/* CPU masks */	33	/* CPU masks */
32	cpumask_t phys_cpu_present_map = CPU_MASK_NONE;	34	cpumask_t phys_cpu_present_map = CPU_MASK_NONE;

arch/ia64/include/asm/rwsem.h+0−37

@@ -25,20 +25,8 @@ · 24 unmodified lines
25	#error "Please don't include <asm/rwsem.h> directly, use <linux/rwsem.h> instead."	25	#error "Please don't include <asm/rwsem.h> directly, use <linux/rwsem.h> instead."
26	#endif	26	#endif
27		27
28	#include <linux/list.h>
29	#include <linux/spinlock.h>
30
31	#include <asm/intrinsics.h>	28	#include <asm/intrinsics.h>
32		29
33	/*
34	* the semaphore definition
35	*/
36	struct rw_semaphore {
37	signed long count;
38	spinlock_t wait_lock;
39	struct list_head wait_list;
40	};
41
42	#define RWSEM_UNLOCKED_VALUE __IA64_UL_CONST(0x0000000000000000)	30	#define RWSEM_UNLOCKED_VALUE __IA64_UL_CONST(0x0000000000000000)
43	#define RWSEM_ACTIVE_BIAS (1L)	31	#define RWSEM_ACTIVE_BIAS (1L)
44	#define RWSEM_ACTIVE_MASK (0xffffffffL)	32	#define RWSEM_ACTIVE_MASK (0xffffffffL)
@@ -46,26 +34,6 @@ struct rw_semaphore { · 1 unmodified line
46	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS	34	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS
47	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)	35	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
48		36
49	#define __RWSEM_INITIALIZER(name) \
50	{ RWSEM_UNLOCKED_VALUE, __SPIN_LOCK_UNLOCKED((name).wait_lock), \
51	LIST_HEAD_INIT((name).wait_list) }
52
53	#define DECLARE_RWSEM(name) \
54	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
55
56	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore sem);
57	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore sem);
58	extern struct rw_semaphore rwsem_wake(struct rw_semaphore sem);
59	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore sem);
60
61	static inline void
62	init_rwsem (struct rw_semaphore *sem)
63	{
64	sem->count = RWSEM_UNLOCKED_VALUE;
65	spin_lock_init(&sem->wait_lock);
66	INIT_LIST_HEAD(&sem->wait_list);
67	}
68
69	/*	37	/*
70	* lock for reading	38	* lock for reading
71	*/	39	*/
@@ -174,9 +142,4 @@ __downgrade_write (struct rw_semaphore *sem) · 102 unmodified lines
174	#define rwsem_atomic_add(delta, sem) atomic64_add(delta, (atomic64_t *)(&(sem)->count))	142	#define rwsem_atomic_add(delta, sem) atomic64_add(delta, (atomic64_t *)(&(sem)->count))
175	#define rwsem_atomic_update(delta, sem) atomic64_add_return(delta, (atomic64_t *)(&(sem)->count))	143	#define rwsem_atomic_update(delta, sem) atomic64_add_return(delta, (atomic64_t *)(&(sem)->count))
176		144
177	static inline int rwsem_is_locked(struct rw_semaphore *sem)
178	{
179	return (sem->count != 0);
180	}
181
182	#endif /* _ASM_IA64_RWSEM_H */	145	#endif /* _ASM_IA64_RWSEM_H */

arch/powerpc/include/asm/rwsem.h+0−51

@@ -13,11 +13,6 @@ · 12 unmodified lines
13	* by Paul Mackerras <paulus@samba.org>.	13	* by Paul Mackerras <paulus@samba.org>.
14	*/	14	*/
15		15
16	#include <linux/list.h>
17	#include <linux/spinlock.h>
18	#include <asm/atomic.h>
19	#include <asm/system.h>
20
21	/*	16	/*
22	* the semaphore definition	17	* the semaphore definition
23	*/	18	*/
@@ -33,47 +28,6 @@ · 9 unmodified lines
33	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS	28	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS
34	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)	29	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
35		30
36	struct rw_semaphore {
37	long count;
38	spinlock_t wait_lock;
39	struct list_head wait_list;
40	#ifdef CONFIG_DEBUG_LOCK_ALLOC
41	struct lockdep_map dep_map;
42	#endif
43	};
44
45	#ifdef CONFIG_DEBUG_LOCK_ALLOC
46	# define __RWSEM_DEP_MAP_INIT(lockname) , .dep_map = { .name = #lockname }
47	#else
48	# define __RWSEM_DEP_MAP_INIT(lockname)
49	#endif
50
51	#define __RWSEM_INITIALIZER(name) \
52	{ \
53	RWSEM_UNLOCKED_VALUE, \
54	__SPIN_LOCK_UNLOCKED((name).wait_lock), \
55	LIST_HEAD_INIT((name).wait_list) \
56	__RWSEM_DEP_MAP_INIT(name) \
57	}
58
59	#define DECLARE_RWSEM(name) \
60	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
61
62	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore sem);
63	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore sem);
64	extern struct rw_semaphore rwsem_wake(struct rw_semaphore sem);
65	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore sem);
66
67	extern void __init_rwsem(struct rw_semaphore sem, const char name,
68	struct lock_class_key *key);
69
70	#define init_rwsem(sem) \
71	do { \
72	static struct lock_class_key __key; \
73	\
74	__init_rwsem((sem), #sem, &__key); \
75	} while (0)
76
77	/*	31	/*
78	* lock for reading	32	* lock for reading
79	*/	33	*/
@@ -174,10 +128,5 @@ static inline long rwsem_atomic_update(long delta, struct rw_semaphore *sem) · 94 unmodified lines
174	return atomic_long_add_return(delta, (atomic_long_t *)&sem->count);	128	return atomic_long_add_return(delta, (atomic_long_t *)&sem->count);
175	}	129	}
176		130
177	static inline int rwsem_is_locked(struct rw_semaphore *sem)
178	{
179	return sem->count != 0;
180	}
181
182	#endif /* __KERNEL__ */	131	#endif /* __KERNEL__ */
183	#endif /* _ASM_POWERPC_RWSEM_H */	132	#endif /* _ASM_POWERPC_RWSEM_H */

arch/s390/include/asm/rwsem.h+0−63

@@ -43,29 +43,6 @@ · 42 unmodified lines
43		43
44	#ifdef __KERNEL__	44	#ifdef __KERNEL__
45		45
46	#include <linux/list.h>
47	#include <linux/spinlock.h>
48
49	struct rwsem_waiter;
50
51	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore );
52	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore );
53	extern struct rw_semaphore rwsem_wake(struct rw_semaphore );
54	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore );
55	extern struct rw_semaphore rwsem_downgrade_write(struct rw_semaphore );
56
57	/*
58	* the semaphore definition
59	*/
60	struct rw_semaphore {
61	signed long count;
62	spinlock_t wait_lock;
63	struct list_head wait_list;
64	#ifdef CONFIG_DEBUG_LOCK_ALLOC
65	struct lockdep_map dep_map;
66	#endif
67	};
68
69	#ifndef __s390x__	46	#ifndef __s390x__
70	#define RWSEM_UNLOCKED_VALUE 0x00000000	47	#define RWSEM_UNLOCKED_VALUE 0x00000000
71	#define RWSEM_ACTIVE_BIAS 0x00000001	48	#define RWSEM_ACTIVE_BIAS 0x00000001
@@ -80,41 +57,6 @@ struct rw_semaphore { · 8 unmodified lines
80	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS	57	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS
81	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)	58	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
82		59
83	/*
84	* initialisation
85	*/
86
87	#ifdef CONFIG_DEBUG_LOCK_ALLOC
88	# define __RWSEM_DEP_MAP_INIT(lockname) , .dep_map = { .name = #lockname }
89	#else
90	# define __RWSEM_DEP_MAP_INIT(lockname)
91	#endif
92
93	#define __RWSEM_INITIALIZER(name) \
94	{ RWSEM_UNLOCKED_VALUE, __SPIN_LOCK_UNLOCKED((name).wait.lock), \
95	LIST_HEAD_INIT((name).wait_list) __RWSEM_DEP_MAP_INIT(name) }
96
97	#define DECLARE_RWSEM(name) \
98	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
99
100	static inline void init_rwsem(struct rw_semaphore *sem)
101	{
102	sem->count = RWSEM_UNLOCKED_VALUE;
103	spin_lock_init(&sem->wait_lock);
104	INIT_LIST_HEAD(&sem->wait_list);
105	}
106
107	extern void __init_rwsem(struct rw_semaphore sem, const char name,
108	struct lock_class_key *key);
109
110	#define init_rwsem(sem) \
111	do { \
112	static struct lock_class_key __key; \
113	\
114	__init_rwsem((sem), #sem, &__key); \
115	} while (0)
116
117
118	/*	60	/*
119	* lock for reading	61	* lock for reading
120	*/	62	*/
@@ -377,10 +319,5 @@ static inline long rwsem_atomic_update(long delta, struct rw_semaphore *sem) · 256 unmodified lines
377	return new;	319	return new;
378	}	320	}
379		321
380	static inline int rwsem_is_locked(struct rw_semaphore *sem)
381	{
382	return (sem->count != 0);
383	}
384
385	#endif /* __KERNEL__ */	322	#endif /* __KERNEL__ */
386	#endif /* _S390_RWSEM_H */	323	#endif /* _S390_RWSEM_H */

arch/sh/include/asm/rwsem.h+0−56

@@ -11,64 +11,13 @@ · 10 unmodified lines
11	#endif	11	#endif
12		12
13	#ifdef __KERNEL__	13	#ifdef __KERNEL__
14	#include <linux/list.h>
15	#include <linux/spinlock.h>
16	#include <asm/atomic.h>
17	#include <asm/system.h>
18		14
19	/*
20	* the semaphore definition
21	*/
22	struct rw_semaphore {
23	long count;
24	#define RWSEM_UNLOCKED_VALUE 0x00000000	15	#define RWSEM_UNLOCKED_VALUE 0x00000000
25	#define RWSEM_ACTIVE_BIAS 0x00000001	16	#define RWSEM_ACTIVE_BIAS 0x00000001
26	#define RWSEM_ACTIVE_MASK 0x0000ffff	17	#define RWSEM_ACTIVE_MASK 0x0000ffff
27	#define RWSEM_WAITING_BIAS (-0x00010000)	18	#define RWSEM_WAITING_BIAS (-0x00010000)
28	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS	19	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS
29	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)	20	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
30	spinlock_t wait_lock;
31	struct list_head wait_list;
32	#ifdef CONFIG_DEBUG_LOCK_ALLOC
33	struct lockdep_map dep_map;
34	#endif
35	};
36
37	#ifdef CONFIG_DEBUG_LOCK_ALLOC
38	# define __RWSEM_DEP_MAP_INIT(lockname) , .dep_map = { .name = #lockname }
39	#else
40	# define __RWSEM_DEP_MAP_INIT(lockname)
41	#endif
42
43	#define __RWSEM_INITIALIZER(name) \
44	{ RWSEM_UNLOCKED_VALUE, __SPIN_LOCK_UNLOCKED((name).wait_lock), \
45	LIST_HEAD_INIT((name).wait_list) \
46	__RWSEM_DEP_MAP_INIT(name) }
47
48	#define DECLARE_RWSEM(name) \
49	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
50
51	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore sem);
52	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore sem);
53	extern struct rw_semaphore rwsem_wake(struct rw_semaphore sem);
54	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore sem);
55
56	extern void __init_rwsem(struct rw_semaphore sem, const char name,
57	struct lock_class_key *key);
58
59	#define init_rwsem(sem) \
60	do { \
61	static struct lock_class_key __key; \
62	\
63	__init_rwsem((sem), #sem, &__key); \
64	} while (0)
65
66	static inline void init_rwsem(struct rw_semaphore *sem)
67	{
68	sem->count = RWSEM_UNLOCKED_VALUE;
69	spin_lock_init(&sem->wait_lock);
70	INIT_LIST_HEAD(&sem->wait_list);
71	}
72		21
73	/*	22	/*
74	* lock for reading	23	* lock for reading
@@ -179,10 +128,5 @@ static inline int rwsem_atomic_update(int delta, struct rw_semaphore *sem) · 104 unmodified lines
179	return atomic_add_return(delta, (atomic_t *)(&sem->count));	128	return atomic_add_return(delta, (atomic_t *)(&sem->count));
180	}	129	}
181		130
182	static inline int rwsem_is_locked(struct rw_semaphore *sem)
183	{
184	return (sem->count != 0);
185	}
186
187	#endif /* __KERNEL__ */	131	#endif /* __KERNEL__ */
188	#endif /* _ASM_SH_RWSEM_H */	132	#endif /* _ASM_SH_RWSEM_H */

arch/sparc/include/asm/rwsem.h+0−46

@@ -13,53 +13,12 @@ · 12 unmodified lines
13		13
14	#ifdef __KERNEL__	14	#ifdef __KERNEL__
15		15
16	#include <linux/list.h>
17	#include <linux/spinlock.h>
18
19	struct rwsem_waiter;
20
21	struct rw_semaphore {
22	signed long count;
23	#define RWSEM_UNLOCKED_VALUE 0x00000000L	16	#define RWSEM_UNLOCKED_VALUE 0x00000000L
24	#define RWSEM_ACTIVE_BIAS 0x00000001L	17	#define RWSEM_ACTIVE_BIAS 0x00000001L
25	#define RWSEM_ACTIVE_MASK 0xffffffffL	18	#define RWSEM_ACTIVE_MASK 0xffffffffL
26	#define RWSEM_WAITING_BIAS (-RWSEM_ACTIVE_MASK-1)	19	#define RWSEM_WAITING_BIAS (-RWSEM_ACTIVE_MASK-1)
27	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS	20	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS
28	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)	21	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
29	spinlock_t wait_lock;
30	struct list_head wait_list;
31	#ifdef CONFIG_DEBUG_LOCK_ALLOC
32	struct lockdep_map dep_map;
33	#endif
34	};
35
36	#ifdef CONFIG_DEBUG_LOCK_ALLOC
37	# define __RWSEM_DEP_MAP_INIT(lockname) , .dep_map = { .name = #lockname }
38	#else
39	# define __RWSEM_DEP_MAP_INIT(lockname)
40	#endif
41
42	#define __RWSEM_INITIALIZER(name) \
43	{ RWSEM_UNLOCKED_VALUE, __SPIN_LOCK_UNLOCKED((name).wait_lock), \
44	LIST_HEAD_INIT((name).wait_list) __RWSEM_DEP_MAP_INIT(name) }
45
46	#define DECLARE_RWSEM(name) \
47	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
48
49	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore sem);
50	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore sem);
51	extern struct rw_semaphore rwsem_wake(struct rw_semaphore sem);
52	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore sem);
53
54	extern void __init_rwsem(struct rw_semaphore sem, const char name,
55	struct lock_class_key *key);
56
57	#define init_rwsem(sem) \
58	do { \
59	static struct lock_class_key __key; \
60	\
61	__init_rwsem((sem), #sem, &__key); \
62	} while (0)
63		22
64	/*	23	/*
65	* lock for reading	24	* lock for reading
@@ -160,11 +119,6 @@ static inline long rwsem_atomic_update(long delta, struct rw_semaphore *sem) · 94 unmodified lines
160	return atomic64_add_return(delta, (atomic64_t *)(&sem->count));	119	return atomic64_add_return(delta, (atomic64_t *)(&sem->count));
161	}	120	}
162		121
163	static inline int rwsem_is_locked(struct rw_semaphore *sem)
164	{
165	return (sem->count != 0);
166	}
167
168	#endif /* __KERNEL__ */	122	#endif /* __KERNEL__ */
169		123
170	#endif /* _SPARC64_RWSEM_H */	124	#endif /* _SPARC64_RWSEM_H */

arch/sparc/lib/atomic32.c+1−1

@@ -16,7 +16,7 @@ · 15 unmodified lines
16	#define ATOMIC_HASH(a) (&__atomic_hash[(((unsigned long)a)>>8) & (ATOMIC_HASH_SIZE-1)])	16	#define ATOMIC_HASH(a) (&__atomic_hash[(((unsigned long)a)>>8) & (ATOMIC_HASH_SIZE-1)])
17		17
18	spinlock_t __atomic_hash[ATOMIC_HASH_SIZE] = {	18	spinlock_t __atomic_hash[ATOMIC_HASH_SIZE] = {
19	[0 ... (ATOMIC_HASH_SIZE-1)] = SPIN_LOCK_UNLOCKED	19	[0 ... (ATOMIC_HASH_SIZE-1)] = __SPIN_LOCK_UNLOCKED(__atomic_hash)
20	};	20	};
21		21
22	#else /* SMP */	22	#else /* SMP */

arch/um/drivers/ubd_kern.c+1−1

@@ -185,7 +185,7 @@ struct ubd { · 184 unmodified lines
185	.no_cow = 0, \	185	.no_cow = 0, \
186	.shared = 0, \	186	.shared = 0, \
187	.cow = DEFAULT_COW, \	187	.cow = DEFAULT_COW, \
188	.lock = SPIN_LOCK_UNLOCKED, \	188	.lock = __SPIN_LOCK_UNLOCKED(ubd_devs.lock), \
189	.request = NULL, \	189	.request = NULL, \
190	.start_sg = 0, \	190	.start_sg = 0, \
191	.end_sg = 0, \	191	.end_sg = 0, \

arch/x86/include/asm/rwsem.h+9−71

 #endif
 #ifdef __KERNEL__
-#include <linux/list.h>
-#include <linux/spinlock.h>
-#include <linux/lockdep.h>
 #include <asm/asm.h>
-struct rwsem_waiter;
-extern asmregparm struct rw_semaphore *
- rwsem_down_read_failed(struct rw_semaphore *sem);
-extern asmregparm struct rw_semaphore *
- rwsem_down_write_failed(struct rw_semaphore *sem);
-extern asmregparm struct rw_semaphore *
- rwsem_wake(struct rw_semaphore *);
-extern asmregparm struct rw_semaphore *
- rwsem_downgrade_wake(struct rw_semaphore *sem);
 /*
- * the semaphore definition
- *
  * The bias values and the counter type limits the number of
  * potential readers/writers to 32767 for 32 bits and 2147483647
  * for 64 bits.
 #define RWSEM_ACTIVE_READ_BIAS		RWSEM_ACTIVE_BIAS
 #define RWSEM_ACTIVE_WRITE_BIAS		(RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
-typedef signed long rwsem_count_t;
-struct rw_semaphore {
-	rwsem_count_t		count;
-	spinlock_t		wait_lock;
-	struct list_head	wait_list;
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-	struct lockdep_map dep_map;
-#endif
-};
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-# define __RWSEM_DEP_MAP_INIT(lockname) , .dep_map = { .name = #lockname }
-#else
-# define __RWSEM_DEP_MAP_INIT(lockname)
-#endif
-#define __RWSEM_INITIALIZER(name)				\
-{								\
-	RWSEM_UNLOCKED_VALUE, __SPIN_LOCK_UNLOCKED((name).wait_lock), \
-	LIST_HEAD_INIT((name).wait_list) __RWSEM_DEP_MAP_INIT(name) \
-}
-#define DECLARE_RWSEM(name)					\
-	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
-extern void __init_rwsem(struct rw_semaphore *sem, const char *name,
-			 struct lock_class_key *key);
-#define init_rwsem(sem)						\
-do {								\
-	static struct lock_class_key __key;			\
-								\
-	__init_rwsem((sem), #sem, &__key);			\
-} while (0)
 /*
  * lock for reading
  */
  */
 static inline int __down_read_trylock(struct rw_semaphore *sem)
 {
-	rwsem_count_t result, tmp;
+	long result, tmp;
 	asm volatile("# beginning __down_read_trylock\n\t"
 		     "  mov          %0,%1\n\t"
 		     "1:\n\t"
  */
 static inline void __down_write_nested(struct rw_semaphore *sem, int subclass)
 {
-	rwsem_count_t tmp;
+	long tmp;
 	asm volatile("# beginning down_write\n\t"
 		     LOCK_PREFIX "  xadd      %1,(%2)\n\t"
 		     /* adds 0xffff0001, returns the old value */
  */
 static inline int __down_write_trylock(struct rw_semaphore *sem)
 {
-	rwsem_count_t ret = cmpxchg(&sem->count,
+	long ret = cmpxchg(&sem->count, RWSEM_UNLOCKED_VALUE,
-				    RWSEM_UNLOCKED_VALUE,
+			   RWSEM_ACTIVE_WRITE_BIAS);
-				    RWSEM_ACTIVE_WRITE_BIAS);
 	if (ret == RWSEM_UNLOCKED_VALUE)
 		return 1;
 	return 0;
  */
 static inline void __up_read(struct rw_semaphore *sem)
 {
-	rwsem_count_t tmp;
+	long tmp;
 	asm volatile("# beginning __up_read\n\t"
 		     LOCK_PREFIX "  xadd      %1,(%2)\n\t"
 		     /* subtracts 1, returns the old value */
  */
 static inline void __up_write(struct rw_semaphore *sem)
 {
-	rwsem_count_t tmp;
+	long tmp;
 	asm volatile("# beginning __up_write\n\t"
 		     LOCK_PREFIX "  xadd      %1,(%2)\n\t"
 		     /* subtracts 0xffff0001, returns the old value */
 /*
  * implement atomic add functionality
  */
-static inline void rwsem_atomic_add(rwsem_count_t delta,
+static inline void rwsem_atomic_add(long delta, struct rw_semaphore *sem)
-				    struct rw_semaphore *sem)
 {
 	asm volatile(LOCK_PREFIX _ASM_ADD "%1,%0"
 		     : "+m" (sem->count)
 /*
  * implement exchange and add functionality
  */
-static inline rwsem_count_t rwsem_atomic_update(rwsem_count_t delta,
+static inline long rwsem_atomic_update(long delta, struct rw_semaphore *sem)
-						struct rw_semaphore *sem)
 {
-	rwsem_count_t tmp = delta;
+	long tmp = delta;
 	asm volatile(LOCK_PREFIX "xadd %0,%1"
 		     : "+r" (tmp), "+m" (sem->count)
 	return tmp + delta;
 }
-static inline int rwsem_is_locked(struct rw_semaphore *sem)
-{
-	return (sem->count != 0);
-}
 #endif /* __KERNEL__ */
 #endif /* _ASM_X86_RWSEM_H */

arch/xtensa/include/asm/rwsem.h+0−37

@@ -17,44 +17,12 @@ · 16 unmodified lines
17	#error "Please don't include <asm/rwsem.h> directly, use <linux/rwsem.h> instead."	17	#error "Please don't include <asm/rwsem.h> directly, use <linux/rwsem.h> instead."
18	#endif	18	#endif
19		19
20	#include <linux/list.h>
21	#include <linux/spinlock.h>
22	#include <asm/atomic.h>
23	#include <asm/system.h>
24
25	/*
26	* the semaphore definition
27	*/
28	struct rw_semaphore {
29	signed long count;
30	#define RWSEM_UNLOCKED_VALUE 0x00000000	20	#define RWSEM_UNLOCKED_VALUE 0x00000000
31	#define RWSEM_ACTIVE_BIAS 0x00000001	21	#define RWSEM_ACTIVE_BIAS 0x00000001
32	#define RWSEM_ACTIVE_MASK 0x0000ffff	22	#define RWSEM_ACTIVE_MASK 0x0000ffff
33	#define RWSEM_WAITING_BIAS (-0x00010000)	23	#define RWSEM_WAITING_BIAS (-0x00010000)
34	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS	24	#define RWSEM_ACTIVE_READ_BIAS RWSEM_ACTIVE_BIAS
35	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)	25	#define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
36	spinlock_t wait_lock;
37	struct list_head wait_list;
38	};
39
40	#define __RWSEM_INITIALIZER(name) \
41	{ RWSEM_UNLOCKED_VALUE, SPIN_LOCK_UNLOCKED, \
42	LIST_HEAD_INIT((name).wait_list) }
43
44	#define DECLARE_RWSEM(name) \
45	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
46
47	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore sem);
48	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore sem);
49	extern struct rw_semaphore rwsem_wake(struct rw_semaphore sem);
50	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore sem);
51
52	static inline void init_rwsem(struct rw_semaphore *sem)
53	{
54	sem->count = RWSEM_UNLOCKED_VALUE;
55	spin_lock_init(&sem->wait_lock);
56	INIT_LIST_HEAD(&sem->wait_list);
57	}
58		26
59	/*	27	/*
60	* lock for reading	28	* lock for reading
@@ -160,9 +128,4 @@ static inline int rwsem_atomic_update(int delta, struct rw_semaphore *sem) · 99 unmodified lines
160	return atomic_add_return(delta, (atomic_t *)(&sem->count));	128	return atomic_add_return(delta, (atomic_t *)(&sem->count));
161	}	129	}
162		130
163	static inline int rwsem_is_locked(struct rw_semaphore *sem)
164	{
165	return (sem->count != 0);
166	}
167
168	#endif /* _XTENSA_RWSEM_H */	131	#endif /* _XTENSA_RWSEM_H */

include/linux/kthread.h+1−1

@@ -64,7 +64,7 @@ struct kthread_work { · 63 unmodified lines
64	};	64	};
65		65
66	#define KTHREAD_WORKER_INIT(worker) { \	66	#define KTHREAD_WORKER_INIT(worker) { \
67	.lock = SPIN_LOCK_UNLOCKED, \	67	.lock = __SPIN_LOCK_UNLOCKED((worker).lock), \
68	.work_list = LIST_HEAD_INIT((worker).work_list), \	68	.work_list = LIST_HEAD_INIT((worker).work_list), \
69	}	69	}
70		70

include/linux/rwlock_types.h+0−8

@@ -43,14 +43,6 @@ typedef struct { · 42 unmodified lines
43	RW_DEP_MAP_INIT(lockname) }	43	RW_DEP_MAP_INIT(lockname) }
44	#endif	44	#endif
45		45
46	/*
47	* RW_LOCK_UNLOCKED defeat lockdep state tracking and is hence
48	* deprecated.
49	*
50	* Please use DEFINE_RWLOCK() or __RW_LOCK_UNLOCKED() as appropriate.
51	*/
52	#define RW_LOCK_UNLOCKED __RW_LOCK_UNLOCKED(old_style_rw_init)
53
54	#define DEFINE_RWLOCK(x) rwlock_t x = __RW_LOCK_UNLOCKED(x)	46	#define DEFINE_RWLOCK(x) rwlock_t x = __RW_LOCK_UNLOCKED(x)
55		47
56	#endif /* __LINUX_RWLOCK_TYPES_H */	48	#endif /* __LINUX_RWLOCK_TYPES_H */

include/linux/rwsem-spinlock.h+1−30

@@ -12,15 +12,7 @@ · 11 unmodified lines
12	#error "please don't include linux/rwsem-spinlock.h directly, use linux/rwsem.h instead"	12	#error "please don't include linux/rwsem-spinlock.h directly, use linux/rwsem.h instead"
13	#endif	13	#endif
14		14
15	#include <linux/spinlock.h>
16	#include <linux/list.h>
17
18	#ifdef __KERNEL__	15	#ifdef __KERNEL__
19
20	#include <linux/types.h>
21
22	struct rwsem_waiter;
23
24	/*	16	/*
25	* the rw-semaphore definition	17	* the rw-semaphore definition
26	* - if activity is 0 then there are no active readers or writers	18	* - if activity is 0 then there are no active readers or writers
@@ -37,28 +29,7 @@ struct rw_semaphore { · 10 unmodified lines
37	#endif	29	#endif
38	};	30	};
39		31
40	#ifdef CONFIG_DEBUG_LOCK_ALLOC	32	#define RWSEM_UNLOCKED_VALUE 0x00000000
41	# define __RWSEM_DEP_MAP_INIT(lockname) , .dep_map = { .name = #lockname }
42	#else
43	# define __RWSEM_DEP_MAP_INIT(lockname)
44	#endif
45
46	#define __RWSEM_INITIALIZER(name) \
47	{ 0, __SPIN_LOCK_UNLOCKED(name.wait_lock), LIST_HEAD_INIT((name).wait_list) \
48	__RWSEM_DEP_MAP_INIT(name) }
49
50	#define DECLARE_RWSEM(name) \
51	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
52
53	extern void __init_rwsem(struct rw_semaphore sem, const char name,
54	struct lock_class_key *key);
55
56	#define init_rwsem(sem) \
57	do { \
58	static struct lock_class_key __key; \
59	\
60	__init_rwsem((sem), #sem, &__key); \
61	} while (0)
62		33
63	extern void __down_read(struct rw_semaphore *sem);	34	extern void __down_read(struct rw_semaphore *sem);
64	extern int __down_read_trylock(struct rw_semaphore *sem);	35	extern int __down_read_trylock(struct rw_semaphore *sem);

include/linux/rwsem.h+52−1

@@ -11,6 +11,9 @@ · 10 unmodified lines
11		11
12	#include <linux/types.h>	12	#include <linux/types.h>
13	#include <linux/kernel.h>	13	#include <linux/kernel.h>
		14	#include <linux/list.h>
		15	#include <linux/spinlock.h>
		16
14	#include <asm/system.h>	17	#include <asm/system.h>
15	#include <asm/atomic.h>	18	#include <asm/atomic.h>
16		19
@@ -19,9 +22,57 @@ struct rw_semaphore; · 2 unmodified lines
19	#ifdef CONFIG_RWSEM_GENERIC_SPINLOCK	22	#ifdef CONFIG_RWSEM_GENERIC_SPINLOCK
20	#include <linux/rwsem-spinlock.h> /* use a generic implementation */	23	#include <linux/rwsem-spinlock.h> /* use a generic implementation */
21	#else	24	#else
22	#include <asm/rwsem.h> /* use an arch-specific implementation */	25	/* All arch specific implementations share the same struct */
		26	struct rw_semaphore {
		27	long count;
		28	spinlock_t wait_lock;
		29	struct list_head wait_list;
		30	#ifdef CONFIG_DEBUG_LOCK_ALLOC
		31	struct lockdep_map dep_map;
		32	#endif
		33	};
		34
		35	extern struct rw_semaphore rwsem_down_read_failed(struct rw_semaphore sem);
		36	extern struct rw_semaphore rwsem_down_write_failed(struct rw_semaphore sem);
		37	extern struct rw_semaphore rwsem_wake(struct rw_semaphore );
		38	extern struct rw_semaphore rwsem_downgrade_wake(struct rw_semaphore sem);
		39
		40	/* Include the arch specific part */
		41	#include <asm/rwsem.h>
		42
		43	/* In all implementations count != 0 means locked */
		44	static inline int rwsem_is_locked(struct rw_semaphore *sem)
		45	{
		46	return sem->count != 0;
		47	}
		48
		49	#endif
		50
		51	/* Common initializer macros and functions */
		52
		53	#ifdef CONFIG_DEBUG_LOCK_ALLOC
		54	# define __RWSEM_DEP_MAP_INIT(lockname) , .dep_map = { .name = #lockname }
		55	#else
		56	# define __RWSEM_DEP_MAP_INIT(lockname)
23	#endif	57	#endif
24		58
		59	#define __RWSEM_INITIALIZER(name) \
		60	{ RWSEM_UNLOCKED_VALUE, __SPIN_LOCK_UNLOCKED(name.wait_lock), \
		61	LIST_HEAD_INIT((name).wait_list) __RWSEM_DEP_MAP_INIT(name) }
		62
		63	#define DECLARE_RWSEM(name) \
		64	struct rw_semaphore name = __RWSEM_INITIALIZER(name)
		65
		66	extern void __init_rwsem(struct rw_semaphore sem, const char name,
		67	struct lock_class_key *key);
		68
		69	#define init_rwsem(sem) \
		70	do { \
		71	static struct lock_class_key __key; \
		72	\
		73	__init_rwsem((sem), #sem, &__key); \
		74	} while (0)
		75
25	/*	76	/*
26	* lock for reading	77	* lock for reading
27	*/	78	*/

include/linux/spinlock_types.h+0−8

@@ -81,14 +81,6 @@ typedef struct spinlock { · 80 unmodified lines
81	#define __SPIN_LOCK_UNLOCKED(lockname) \	81	#define __SPIN_LOCK_UNLOCKED(lockname) \
82	(spinlock_t ) __SPIN_LOCK_INITIALIZER(lockname)	82	(spinlock_t ) __SPIN_LOCK_INITIALIZER(lockname)
83		83
84	/*
85	* SPIN_LOCK_UNLOCKED defeats lockdep state tracking and is hence
86	* deprecated.
87	* Please use DEFINE_SPINLOCK() or __SPIN_LOCK_UNLOCKED() as
88	* appropriate.
89	*/
90	#define SPIN_LOCK_UNLOCKED __SPIN_LOCK_UNLOCKED(old_style_spin_init)
91
92	#define DEFINE_SPINLOCK(x) spinlock_t x = __SPIN_LOCK_UNLOCKED(x)	84	#define DEFINE_SPINLOCK(x) spinlock_t x = __SPIN_LOCK_UNLOCKED(x)
93		85
94	#include <linux/rwlock_types.h>	86	#include <linux/rwlock_types.h>

kernel/cred.c+1−1

@@ -35,7 +35,7 @@ static struct kmem_cache *cred_jar; · 34 unmodified lines
35	static struct thread_group_cred init_tgcred = {	35	static struct thread_group_cred init_tgcred = {
36	.usage = ATOMIC_INIT(2),	36	.usage = ATOMIC_INIT(2),
37	.tgid = 0,	37	.tgid = 0,
38	.lock = SPIN_LOCK_UNLOCKED,	38	.lock = __SPIN_LOCK_UNLOCKED(init_cred.tgcred.lock),
39	};	39	};
40	#endif	40	#endif
41		41

kernel/futex.c+12−10

 	/*
 	 * We are here either because we stole the rtmutex from the
-	 * pending owner or we are the pending owner which failed to
+	 * previous highest priority waiter or we are the highest priority
-	 * get the rtmutex. We have to replace the pending owner TID
+	 * waiter but failed to get the rtmutex the first time.
-	 * in the user space variable. This must be atomic as we have
+	 * We have to replace the newowner TID in the user space variable.
-	 * to preserve the owner died bit here.
+	 * This must be atomic as we have to preserve the owner died bit here.
 	 *
 	 * Note: We write the user space value _before_ changing the pi_state
 	 * because we can fault here. Imagine swapped out pages or a fork
 	/*
 	 * To handle the page fault we need to drop the hash bucket
-	 * lock here. That gives the other task (either the pending
+	 * lock here. That gives the other task (either the highest priority
-	 * owner itself or the task which stole the rtmutex) the
+	 * waiter itself or the task which stole the rtmutex) the
 	 * chance to try the fixup of the pi_state. So once we are
 	 * back from handling the fault we need to check the pi_state
 	 * after reacquiring the hash bucket lock and before trying to
 		/*
 		 * pi_state is incorrect, some other task did a lock steal and
 		 * we returned due to timeout or signal without taking the
-		 * rt_mutex. Too late. We can access the rt_mutex_owner without
+		 * rt_mutex. Too late.
-		 * locking, as the other task is now blocked on the hash bucket
-		 * lock. Fix the state up.
 		 */
+		raw_spin_lock(&q->pi_state->pi_mutex.wait_lock);
 		owner = rt_mutex_owner(&q->pi_state->pi_mutex);
+		if (!owner)
+			owner = rt_mutex_next_owner(&q->pi_state->pi_mutex);
+		raw_spin_unlock(&q->pi_state->pi_mutex.wait_lock);
 		ret = fixup_pi_state_owner(uaddr, q, owner);
 		goto out;
 	}
 	/*
 	 * Paranoia check. If we did not take the lock, then we should not be
-	 * the owner, nor the pending owner, of the rt_mutex.
+	 * the owner of the rt_mutex.
 	 */
 	if (rt_mutex_owner(&q->pi_state->pi_mutex) == current)
 		printk(KERN_ERR "fixup_owner: ret = %d pi-mutex: %p "

kernel/rtmutex-debug.c+0−1

@@ -215,7 +215,6 @@ void debug_rt_mutex_free_waiter(struct rt_mutex_waiter *waiter) · 214 unmodified lines
215	put_pid(waiter->deadlock_task_pid);	215	put_pid(waiter->deadlock_task_pid);
216	TRACE_WARN_ON(!plist_node_empty(&waiter->list_entry));	216	TRACE_WARN_ON(!plist_node_empty(&waiter->list_entry));
217	TRACE_WARN_ON(!plist_node_empty(&waiter->pi_list_entry));	217	TRACE_WARN_ON(!plist_node_empty(&waiter->pi_list_entry));
218	TRACE_WARN_ON(waiter->task);
219	memset(waiter, 0x22, sizeof(*waiter));	218	memset(waiter, 0x22, sizeof(*waiter));
220	}	219	}
221		220

kernel/rtmutex-tester.c+4−36

 #include <linux/kthread.h>
 #include <linux/module.h>
 #include <linux/sched.h>
-#include <linux/smp_lock.h>
 #include <linux/spinlock.h>
 #include <linux/sysdev.h>
 #include <linux/timer.h>
 	int			opcode;
 	int			opdata;
 	int			mutexes[MAX_RT_TEST_MUTEXES];
-	int			bkl;
 	int			event;
 	struct sys_device	sysdev;
 };
 	RTTEST_LOCKINTNOWAIT,	/* 6 Lock interruptible no wait in wakeup, data = lockindex */
 	RTTEST_LOCKCONT,	/* 7 Continue locking after the wakeup delay */
 	RTTEST_UNLOCK,		/* 8 Unlock, data = lockindex */
-	RTTEST_LOCKBKL,		/* 9 Lock BKL */
+	/* 9, 10 - reserved for BKL commemoration */
-	RTTEST_UNLOCKBKL,	/* 10 Unlock BKL */
+	RTTEST_SIGNAL = 11,	/* 11 Signal other test thread, data = thread id */
-	RTTEST_SIGNAL,		/* 11 Signal other test thread, data = thread id */
 	RTTEST_RESETEVENT = 98,	/* 98 Reset event counter */
 	RTTEST_RESET = 99,	/* 99 Reset all pending operations */
 };
 				td->mutexes[i] = 0;
 			}
 		}
-		if (!lockwakeup && td->bkl == 4) {
-#ifdef CONFIG_LOCK_KERNEL
-			unlock_kernel();
-#endif
-			td->bkl = 0;
-		}
 		return 0;
 	case RTTEST_RESETEVENT:
 		td->mutexes[id] = 0;
 		return 0;
-	case RTTEST_LOCKBKL:
-		if (td->bkl)
-			return 0;
-		td->bkl = 1;
-#ifdef CONFIG_LOCK_KERNEL
-		lock_kernel();
-#endif
-		td->bkl = 4;
-		return 0;
-	case RTTEST_UNLOCKBKL:
-		if (td->bkl != 4)
-			break;
-#ifdef CONFIG_LOCK_KERNEL
-		unlock_kernel();
-#endif
-		td->bkl = 0;
-		return 0;
 	default:
 		break;
 	}
 		td->event = atomic_add_return(1, &rttest_event);
 		break;
-	case RTTEST_LOCKBKL:
 	default:
 		break;
 	}
 		td->event = atomic_add_return(1, &rttest_event);
 		return;
-	case RTTEST_LOCKBKL:
-		return;
 	default:
 		return;
 	}
 	spin_lock(&rttest_lock);
 	curr += sprintf(curr,
-		"O: %4d, E:%8d, S: 0x%08lx, P: %4d, N: %4d, B: %p, K: %d, M:",
+		"O: %4d, E:%8d, S: 0x%08lx, P: %4d, N: %4d, B: %p, M:",
 		td->opcode, td->event, tsk->state,
 			(MAX_RT_PRIO - 1) - tsk->prio,
 			(MAX_RT_PRIO - 1) - tsk->normal_prio,
-		tsk->pi_blocked_on, td->bkl);
+		tsk->pi_blocked_on);
 	for (i = MAX_RT_TEST_MUTEXES - 1; i >=0 ; i--)
 		curr += sprintf(curr, "%d", td->mutexes[i]);

kernel/rtmutex.c+113−205

@@ -20,41 +20,34 @@ · 19 unmodified lines
20	/*	20	/*
21	* lock->owner state tracking:	21	* lock->owner state tracking:
22	*	22	*
23	* lock->owner holds the task_struct pointer of the owner. Bit 0 and 1	23	* lock->owner holds the task_struct pointer of the owner. Bit 0
24	* are used to keep track of the "owner is pending" and "lock has	24	* is used to keep track of the "lock has waiters" state.
25	* waiters" state.
26	*	25	*
27	* owner bit1 bit0	26	* owner bit0
28	* NULL 0 0 lock is free (fast acquire possible)	27	* NULL 0 lock is free (fast acquire possible)
29	* NULL 0 1 invalid state	28	* NULL 1 lock is free and has waiters and the top waiter
30	* NULL 1 0 Transitional State*	29	* is going to take the lock*
31	* NULL 1 1 invalid state	30	* taskpointer 0 lock is held (fast release possible)
32	* taskpointer 0 0 lock is held (fast release possible)	31	* taskpointer 1 lock is held and has waiters**
33	* taskpointer 0 1 task is pending owner
34	* taskpointer 1 0 lock is held and has waiters
35	* taskpointer 1 1 task is pending owner and lock has more waiters
36	*
37	* Pending ownership is assigned to the top (highest priority)
38	* waiter of the lock, when the lock is released. The thread is woken
39	* up and can now take the lock. Until the lock is taken (bit 0
40	* cleared) a competing higher priority thread can steal the lock
41	* which puts the woken up thread back on the waiters list.
42	*	32	*
43	* The fast atomic compare exchange based acquire and release is only	33	* The fast atomic compare exchange based acquire and release is only
44	* possible when bit 0 and 1 of lock->owner are 0.	34	* possible when bit 0 of lock->owner is 0.
		35	*
		36	* (*) It also can be a transitional state when grabbing the lock
		37	* with ->wait_lock is held. To prevent any fast path cmpxchg to the lock,
		38	* we need to set the bit0 before looking at the lock, and the owner may be
		39	* NULL in this small time, hence this can be a transitional state.
45	*	40	*
46	* (*) There's a small time where the owner can be NULL and the	41	* (**) There is a small time when bit 0 is set but there are no
47	* "lock has waiters" bit is set. This can happen when grabbing the lock.	42	* waiters. This can happen when grabbing the lock in the slow path.
48	* To prevent a cmpxchg of the owner releasing the lock, we need to set this	43	* To prevent a cmpxchg of the owner releasing the lock, we need to
49	* bit before looking at the lock, hence the reason this is a transitional	44	* set this bit before looking at the lock.
50	* state.
51	*/	45	*/
52		46
53	static void	47	static void
54	rt_mutex_set_owner(struct rt_mutex lock, struct task_struct owner,	48	rt_mutex_set_owner(struct rt_mutex lock, struct task_struct owner)
55	unsigned long mask)
56	{	49	{
57	unsigned long val = (unsigned long)owner \| mask;	50	unsigned long val = (unsigned long)owner;
58		51
59	if (rt_mutex_has_waiters(lock))	52	if (rt_mutex_has_waiters(lock))
60	val \|= RT_MUTEX_HAS_WAITERS;	53	val \|= RT_MUTEX_HAS_WAITERS;
@@ -203,15 +196,14 @@ static int rt_mutex_adjust_prio_chain(struct task_struct *task, · 142 unmodified lines
203	* reached or the state of the chain has changed while we	196	* reached or the state of the chain has changed while we
204	* dropped the locks.	197	* dropped the locks.
205	*/	198	*/
206	if (!waiter \|\| !waiter->task)	199	if (!waiter)
207	goto out_unlock_pi;	200	goto out_unlock_pi;
208		201
209	/*	202	/*
210	* Check the orig_waiter state. After we dropped the locks,	203	* Check the orig_waiter state. After we dropped the locks,
211	* the previous owner of the lock might have released the lock	204	* the previous owner of the lock might have released the lock.
212	* and made us the pending owner:
213	*/	205	*/
214	if (orig_waiter && !orig_waiter->task)	206	if (orig_waiter && !rt_mutex_owner(orig_lock))
215	goto out_unlock_pi;	207	goto out_unlock_pi;
216		208
217	/*	209	/*
@@ -254,6 +246,17 @@ static int rt_mutex_adjust_prio_chain(struct task_struct *task, · 36 unmodified lines
254		246
255	/* Release the task */	247	/* Release the task */
256	raw_spin_unlock_irqrestore(&task->pi_lock, flags);	248	raw_spin_unlock_irqrestore(&task->pi_lock, flags);
		249	if (!rt_mutex_owner(lock)) {
		250	/*
		251	* If the requeue above changed the top waiter, then we need
		252	* to wake the new top waiter up to try to get the lock.
		253	*/
		254
		255	if (top_waiter != rt_mutex_top_waiter(lock))
		256	wake_up_process(rt_mutex_top_waiter(lock)->task);
		257	raw_spin_unlock(&lock->wait_lock);
		258	goto out_put_task;
		259	}
257	put_task_struct(task);	260	put_task_struct(task);
258		261
259	/* Grab the next task */	262	/* Grab the next task */
@@ -295,79 +298,17 @@ static int rt_mutex_adjust_prio_chain(struct task_struct *task, · 35 unmodified lines
295	return ret;	298	return ret;
296	}	299	}
297		300
298	/*
299	* Optimization: check if we can steal the lock from the
300	* assigned pending owner [which might not have taken the
301	* lock yet]:
302	*/
303	static inline int try_to_steal_lock(struct rt_mutex *lock,
304	struct task_struct *task)
305	{
306	struct task_struct *pendowner = rt_mutex_owner(lock);
307	struct rt_mutex_waiter *next;
308	unsigned long flags;
309
310	if (!rt_mutex_owner_pending(lock))
311	return 0;
312
313	if (pendowner == task)
314	return 1;
315
316	raw_spin_lock_irqsave(&pendowner->pi_lock, flags);
317	if (task->prio >= pendowner->prio) {
318	raw_spin_unlock_irqrestore(&pendowner->pi_lock, flags);
319	return 0;
320	}
321
322	/*
323	* Check if a waiter is enqueued on the pending owners
324	* pi_waiters list. Remove it and readjust pending owners
325	* priority.
326	*/
327	if (likely(!rt_mutex_has_waiters(lock))) {
328	raw_spin_unlock_irqrestore(&pendowner->pi_lock, flags);
329	return 1;
330	}
331
332	/* No chain handling, pending owner is not blocked on anything: */
333	next = rt_mutex_top_waiter(lock);
334	plist_del(&next->pi_list_entry, &pendowner->pi_waiters);
335	__rt_mutex_adjust_prio(pendowner);
336	raw_spin_unlock_irqrestore(&pendowner->pi_lock, flags);
337
338	/*
339	* We are going to steal the lock and a waiter was
340	* enqueued on the pending owners pi_waiters queue. So
341	* we have to enqueue this waiter into
342	* task->pi_waiters list. This covers the case,
343	* where task is boosted because it holds another
344	* lock and gets unboosted because the booster is
345	* interrupted, so we would delay a waiter with higher
346	* priority as task->normal_prio.
347	*
348	* Note: in the rare case of a SCHED_OTHER task changing
349	* its priority and thus stealing the lock, next->task
350	* might be task:
351	*/
352	if (likely(next->task != task)) {
353	raw_spin_lock_irqsave(&task->pi_lock, flags);
354	plist_add(&next->pi_list_entry, &task->pi_waiters);
355	__rt_mutex_adjust_prio(task);
356	raw_spin_unlock_irqrestore(&task->pi_lock, flags);
357	}
358	return 1;
359	}
360
361	/*	301	/*
362	* Try to take an rt-mutex	302	* Try to take an rt-mutex
363	*	303	*
364	* This fails
365	* - when the lock has a real owner
366	* - when a different pending owner exists and has higher priority than current
367	*
368	* Must be called with lock->wait_lock held.	304	* Must be called with lock->wait_lock held.
		305	*
		306	* @lock: the lock to be acquired.
		307	* @task: the task which wants to acquire the lock
		308	* @waiter: the waiter that is queued to the lock's wait list. (could be NULL)
369	*/	309	*/
370	static int try_to_take_rt_mutex(struct rt_mutex *lock)	310	static int try_to_take_rt_mutex(struct rt_mutex lock, struct task_struct task,
		311	struct rt_mutex_waiter *waiter)
371	{	312	{
372	/*	313	/*
373	* We have to be careful here if the atomic speedups are	314	* We have to be careful here if the atomic speedups are
@@ -390,15 +331,52 @@ static int try_to_take_rt_mutex(struct rt_mutex *lock) · 16 unmodified lines
390	*/	331	*/
391	mark_rt_mutex_waiters(lock);	332	mark_rt_mutex_waiters(lock);
392		333
393	if (rt_mutex_owner(lock) && !try_to_steal_lock(lock, current))	334	if (rt_mutex_owner(lock))
394	return 0;	335	return 0;
395		336
		337	/*
		338	* It will get the lock because of one of these conditions:
		339	* 1) there is no waiter
		340	* 2) higher priority than waiters
		341	* 3) it is top waiter
		342	*/
		343	if (rt_mutex_has_waiters(lock)) {
		344	if (task->prio >= rt_mutex_top_waiter(lock)->list_entry.prio) {
		345	if (!waiter \|\| waiter != rt_mutex_top_waiter(lock))
		346	return 0;
		347	}
		348	}
		349
		350	if (waiter \|\| rt_mutex_has_waiters(lock)) {
		351	unsigned long flags;
		352	struct rt_mutex_waiter *top;
		353
		354	raw_spin_lock_irqsave(&task->pi_lock, flags);
		355
		356	/* remove the queued waiter. */
		357	if (waiter) {
		358	plist_del(&waiter->list_entry, &lock->wait_list);
		359	task->pi_blocked_on = NULL;
		360	}
		361
		362	/*
		363	* We have to enqueue the top waiter(if it exists) into
		364	* task->pi_waiters list.
		365	*/
		366	if (rt_mutex_has_waiters(lock)) {
		367	top = rt_mutex_top_waiter(lock);
		368	top->pi_list_entry.prio = top->list_entry.prio;
		369	plist_add(&top->pi_list_entry, &task->pi_waiters);
		370	}
		371	raw_spin_unlock_irqrestore(&task->pi_lock, flags);
		372	}
		373
396	/* We got the lock. */	374	/* We got the lock. */
397	debug_rt_mutex_lock(lock);	375	debug_rt_mutex_lock(lock);
398		376
399	rt_mutex_set_owner(lock, current, 0);	377	rt_mutex_set_owner(lock, task);
400		378
401	rt_mutex_deadlock_account_lock(lock, current);	379	rt_mutex_deadlock_account_lock(lock, task);
402		380
403	return 1;	381	return 1;
404	}	382	}
@@ -436,6 +414,9 @@ static int task_blocks_on_rt_mutex(struct rt_mutex *lock, · 31 unmodified lines
436		414
437	raw_spin_unlock_irqrestore(&task->pi_lock, flags);	415	raw_spin_unlock_irqrestore(&task->pi_lock, flags);
438		416
		417	if (!owner)
		418	return 0;
		419
439	if (waiter == rt_mutex_top_waiter(lock)) {	420	if (waiter == rt_mutex_top_waiter(lock)) {
440	raw_spin_lock_irqsave(&owner->pi_lock, flags);	421	raw_spin_lock_irqsave(&owner->pi_lock, flags);
441	plist_del(&top_waiter->pi_list_entry, &owner->pi_waiters);	422	plist_del(&top_waiter->pi_list_entry, &owner->pi_waiters);
@@ -472,21 +453,18 @@ static int task_blocks_on_rt_mutex(struct rt_mutex *lock, · 30 unmodified lines
472	/*	453	/*
473	* Wake up the next waiter on the lock.	454	* Wake up the next waiter on the lock.
474	*	455	*
475	* Remove the top waiter from the current tasks waiter list and from	456	* Remove the top waiter from the current tasks waiter list and wake it up.
476	* the lock waiter list. Set it as pending owner. Then wake it up.
477	*	457	*
478	* Called with lock->wait_lock held.	458	* Called with lock->wait_lock held.
479	*/	459	*/
480	static void wakeup_next_waiter(struct rt_mutex *lock)	460	static void wakeup_next_waiter(struct rt_mutex *lock)
481	{	461	{
482	struct rt_mutex_waiter *waiter;	462	struct rt_mutex_waiter *waiter;
483	struct task_struct *pendowner;
484	unsigned long flags;	463	unsigned long flags;
485		464
486	raw_spin_lock_irqsave(&current->pi_lock, flags);	465	raw_spin_lock_irqsave(&current->pi_lock, flags);
487		466
488	waiter = rt_mutex_top_waiter(lock);	467	waiter = rt_mutex_top_waiter(lock);
489	plist_del(&waiter->list_entry, &lock->wait_list);
490		468
491	/*	469	/*
492	* Remove it from current->pi_waiters. We do not adjust a	470	* Remove it from current->pi_waiters. We do not adjust a
@@ -495,43 +473,19 @@ static void wakeup_next_waiter(struct rt_mutex *lock) · 2 unmodified lines
495	* lock->wait_lock.	473	* lock->wait_lock.
496	*/	474	*/
497	plist_del(&waiter->pi_list_entry, &current->pi_waiters);	475	plist_del(&waiter->pi_list_entry, &current->pi_waiters);
498	pendowner = waiter->task;
499	waiter->task = NULL;
500		476
501	rt_mutex_set_owner(lock, pendowner, RT_MUTEX_OWNER_PENDING);	477	rt_mutex_set_owner(lock, NULL);
502		478
503	raw_spin_unlock_irqrestore(&current->pi_lock, flags);	479	raw_spin_unlock_irqrestore(&current->pi_lock, flags);
504		480
505	/*	481	wake_up_process(waiter->task);
506	* Clear the pi_blocked_on variable and enqueue a possible
507	* waiter into the pi_waiters list of the pending owner. This
508	* prevents that in case the pending owner gets unboosted a
509	* waiter with higher priority than pending-owner->normal_prio
510	* is blocked on the unboosted (pending) owner.
511	*/
512	raw_spin_lock_irqsave(&pendowner->pi_lock, flags);
513
514	WARN_ON(!pendowner->pi_blocked_on);
515	WARN_ON(pendowner->pi_blocked_on != waiter);
516	WARN_ON(pendowner->pi_blocked_on->lock != lock);
517
518	pendowner->pi_blocked_on = NULL;
519
520	if (rt_mutex_has_waiters(lock)) {
521	struct rt_mutex_waiter *next;
522
523	next = rt_mutex_top_waiter(lock);
524	plist_add(&next->pi_list_entry, &pendowner->pi_waiters);
525	}
526	raw_spin_unlock_irqrestore(&pendowner->pi_lock, flags);
527
528	wake_up_process(pendowner);
529	}	482	}
530		483
531	/*	484	/*
532	* Remove a waiter from a lock	485	* Remove a waiter from a lock and give up
533	*	486	*
534	* Must be called with lock->wait_lock held	487	* Must be called with lock->wait_lock held and
		488	* have just failed to try_to_take_rt_mutex().
535	*/	489	*/
536	static void remove_waiter(struct rt_mutex *lock,	490	static void remove_waiter(struct rt_mutex *lock,
537	struct rt_mutex_waiter *waiter)	491	struct rt_mutex_waiter *waiter)
@@ -543,11 +497,13 @@ static void remove_waiter(struct rt_mutex *lock, · 5 unmodified lines
543		497
544	raw_spin_lock_irqsave(&current->pi_lock, flags);	498	raw_spin_lock_irqsave(&current->pi_lock, flags);
545	plist_del(&waiter->list_entry, &lock->wait_list);	499	plist_del(&waiter->list_entry, &lock->wait_list);
546	waiter->task = NULL;
547	current->pi_blocked_on = NULL;	500	current->pi_blocked_on = NULL;
548	raw_spin_unlock_irqrestore(&current->pi_lock, flags);	501	raw_spin_unlock_irqrestore(&current->pi_lock, flags);
549		502
550	if (first && owner != current) {	503	if (!owner)
		504	return;
		505
		506	if (first) {
551		507
552	raw_spin_lock_irqsave(&owner->pi_lock, flags);	508	raw_spin_lock_irqsave(&owner->pi_lock, flags);
553		509
@@ -614,21 +570,19 @@ void rt_mutex_adjust_pi(struct task_struct *task) · 60 unmodified lines
614	* or TASK_UNINTERRUPTIBLE)	570	* or TASK_UNINTERRUPTIBLE)
615	* @timeout: the pre-initialized and started timer, or NULL for none	571	* @timeout: the pre-initialized and started timer, or NULL for none
616	* @waiter: the pre-initialized rt_mutex_waiter	572	* @waiter: the pre-initialized rt_mutex_waiter
617	* @detect_deadlock: passed to task_blocks_on_rt_mutex
618	*	573	*
619	* lock->wait_lock must be held by the caller.	574	* lock->wait_lock must be held by the caller.
620	*/	575	*/
621	static int __sched	576	static int __sched
622	__rt_mutex_slowlock(struct rt_mutex *lock, int state,	577	__rt_mutex_slowlock(struct rt_mutex *lock, int state,
623	struct hrtimer_sleeper *timeout,	578	struct hrtimer_sleeper *timeout,
624	struct rt_mutex_waiter *waiter,	579	struct rt_mutex_waiter *waiter)
625	int detect_deadlock)
626	{	580	{
627	int ret = 0;	581	int ret = 0;
628		582
629	for (;;) {	583	for (;;) {
630	/* Try to acquire the lock: */	584	/* Try to acquire the lock: */
631	if (try_to_take_rt_mutex(lock))	585	if (try_to_take_rt_mutex(lock, current, waiter))
632	break;	586	break;
633		587
634	/*	588	/*
@@ -645,39 +599,11 @@ __rt_mutex_slowlock(struct rt_mutex *lock, int state, · 10 unmodified lines
645	break;	599	break;
646	}	600	}
647		601
648	/*
649	* waiter->task is NULL the first time we come here and
650	* when we have been woken up by the previous owner
651	* but the lock got stolen by a higher prio task.
652	*/
653	if (!waiter->task) {
654	ret = task_blocks_on_rt_mutex(lock, waiter, current,
655	detect_deadlock);
656	/*
657	* If we got woken up by the owner then start loop
658	* all over without going into schedule to try
659	* to get the lock now:
660	*/
661	if (unlikely(!waiter->task)) {
662	/*
663	* Reset the return value. We might
664	* have returned with -EDEADLK and the
665	* owner released the lock while we
666	* were walking the pi chain.
667	*/
668	ret = 0;
669	continue;
670	}
671	if (unlikely(ret))
672	break;
673	}
674
675	raw_spin_unlock(&lock->wait_lock);	602	raw_spin_unlock(&lock->wait_lock);
676		603
677	debug_rt_mutex_print_deadlock(waiter);	604	debug_rt_mutex_print_deadlock(waiter);
678		605
679	if (waiter->task)	606	schedule_rt_mutex(lock);
680	schedule_rt_mutex(lock);
681		607
682	raw_spin_lock(&lock->wait_lock);	608	raw_spin_lock(&lock->wait_lock);
683	set_current_state(state);	609	set_current_state(state);
@@ -698,12 +624,11 @@ rt_mutex_slowlock(struct rt_mutex *lock, int state, · 14 unmodified lines
698	int ret = 0;	624	int ret = 0;
699		625
700	debug_rt_mutex_init_waiter(&waiter);	626	debug_rt_mutex_init_waiter(&waiter);
701	waiter.task = NULL;
702		627
703	raw_spin_lock(&lock->wait_lock);	628	raw_spin_lock(&lock->wait_lock);
704		629
705	/* Try to acquire the lock again: */	630	/* Try to acquire the lock again: */
706	if (try_to_take_rt_mutex(lock)) {	631	if (try_to_take_rt_mutex(lock, current, NULL)) {
707	raw_spin_unlock(&lock->wait_lock);	632	raw_spin_unlock(&lock->wait_lock);
708	return 0;	633	return 0;
709	}	634	}
@@ -717,12 +642,14 @@ rt_mutex_slowlock(struct rt_mutex *lock, int state, · 7 unmodified lines
717	timeout->task = NULL;	642	timeout->task = NULL;
718	}	643	}
719		644
720	ret = __rt_mutex_slowlock(lock, state, timeout, &waiter,	645	ret = task_blocks_on_rt_mutex(lock, &waiter, current, detect_deadlock);
721	detect_deadlock);	646
		647	if (likely(!ret))
		648	ret = __rt_mutex_slowlock(lock, state, timeout, &waiter);
722		649
723	set_current_state(TASK_RUNNING);	650	set_current_state(TASK_RUNNING);
724		651
725	if (unlikely(waiter.task))	652	if (unlikely(ret))
726	remove_waiter(lock, &waiter);	653	remove_waiter(lock, &waiter);
727		654
728	/*	655	/*
@@ -737,14 +664,6 @@ rt_mutex_slowlock(struct rt_mutex *lock, int state, · 8 unmodified lines
737	if (unlikely(timeout))	664	if (unlikely(timeout))
738	hrtimer_cancel(&timeout->timer);	665	hrtimer_cancel(&timeout->timer);
739		666
740	/*
741	* Readjust priority, when we did not get the lock. We might
742	* have been the pending owner and boosted. Since we did not
743	* take the lock, the PI boost has to go.
744	*/
745	if (unlikely(ret))
746	rt_mutex_adjust_prio(current);
747
748	debug_rt_mutex_free_waiter(&waiter);	667	debug_rt_mutex_free_waiter(&waiter);
749		668
750	return ret;	669	return ret;
@@ -762,7 +681,7 @@ rt_mutex_slowtrylock(struct rt_mutex *lock) · 11 unmodified lines
762		681
763	if (likely(rt_mutex_owner(lock) != current)) {	682	if (likely(rt_mutex_owner(lock) != current)) {
764		683
765	ret = try_to_take_rt_mutex(lock);	684	ret = try_to_take_rt_mutex(lock, current, NULL);
766	/*	685	/*
767	* try_to_take_rt_mutex() sets the lock waiters	686	* try_to_take_rt_mutex() sets the lock waiters
768	* bit unconditionally. Clean this up.	687	* bit unconditionally. Clean this up.
@@ -992,7 +911,7 @@ void rt_mutex_init_proxy_locked(struct rt_mutex *lock, · 223 unmodified lines
992	{	911	{
993	__rt_mutex_init(lock, NULL);	912	__rt_mutex_init(lock, NULL);
994	debug_rt_mutex_proxy_lock(lock, proxy_owner);	913	debug_rt_mutex_proxy_lock(lock, proxy_owner);
995	rt_mutex_set_owner(lock, proxy_owner, 0);	914	rt_mutex_set_owner(lock, proxy_owner);
996	rt_mutex_deadlock_account_lock(lock, proxy_owner);	915	rt_mutex_deadlock_account_lock(lock, proxy_owner);
997	}	916	}
998		917
@@ -1008,7 +927,7 @@ void rt_mutex_proxy_unlock(struct rt_mutex *lock, · 9 unmodified lines
1008	struct task_struct *proxy_owner)	927	struct task_struct *proxy_owner)
1009	{	928	{
1010	debug_rt_mutex_proxy_unlock(lock);	929	debug_rt_mutex_proxy_unlock(lock);
1011	rt_mutex_set_owner(lock, NULL, 0);	930	rt_mutex_set_owner(lock, NULL);
1012	rt_mutex_deadlock_account_unlock(proxy_owner);	931	rt_mutex_deadlock_account_unlock(proxy_owner);
1013	}	932	}
1014		933
@@ -1034,20 +953,14 @@ int rt_mutex_start_proxy_lock(struct rt_mutex *lock, · 19 unmodified lines
1034		953
1035	raw_spin_lock(&lock->wait_lock);	954	raw_spin_lock(&lock->wait_lock);
1036		955
1037	mark_rt_mutex_waiters(lock);	956	if (try_to_take_rt_mutex(lock, task, NULL)) {
1038
1039	if (!rt_mutex_owner(lock) \|\| try_to_steal_lock(lock, task)) {
1040	/* We got the lock for task. */
1041	debug_rt_mutex_lock(lock);
1042	rt_mutex_set_owner(lock, task, 0);
1043	raw_spin_unlock(&lock->wait_lock);	957	raw_spin_unlock(&lock->wait_lock);
1044	rt_mutex_deadlock_account_lock(lock, task);
1045	return 1;	958	return 1;
1046	}	959	}
1047		960
1048	ret = task_blocks_on_rt_mutex(lock, waiter, task, detect_deadlock);	961	ret = task_blocks_on_rt_mutex(lock, waiter, task, detect_deadlock);
1049		962
1050	if (ret && !waiter->task) {	963	if (ret && !rt_mutex_owner(lock)) {
1051	/*	964	/*
1052	* Reset the return value. We might have	965	* Reset the return value. We might have
1053	* returned with -EDEADLK and the owner	966	* returned with -EDEADLK and the owner
@@ -1056,6 +969,10 @@ int rt_mutex_start_proxy_lock(struct rt_mutex *lock, · 2 unmodified lines
1056	*/	969	*/
1057	ret = 0;	970	ret = 0;
1058	}	971	}
		972
		973	if (unlikely(ret))
		974	remove_waiter(lock, waiter);
		975
1059	raw_spin_unlock(&lock->wait_lock);	976	raw_spin_unlock(&lock->wait_lock);
1060		977
1061	debug_rt_mutex_print_deadlock(waiter);	978	debug_rt_mutex_print_deadlock(waiter);
@@ -1110,12 +1027,11 @@ int rt_mutex_finish_proxy_lock(struct rt_mutex *lock, · 48 unmodified lines
1110		1027
1111	set_current_state(TASK_INTERRUPTIBLE);	1028	set_current_state(TASK_INTERRUPTIBLE);
1112		1029
1113	ret = __rt_mutex_slowlock(lock, TASK_INTERRUPTIBLE, to, waiter,	1030	ret = __rt_mutex_slowlock(lock, TASK_INTERRUPTIBLE, to, waiter);
1114	detect_deadlock);
1115		1031
1116	set_current_state(TASK_RUNNING);	1032	set_current_state(TASK_RUNNING);
1117		1033
1118	if (unlikely(waiter->task))	1034	if (unlikely(ret))
1119	remove_waiter(lock, waiter);	1035	remove_waiter(lock, waiter);
1120		1036
1121	/*	1037	/*
@@ -1126,13 +1042,5 @@ int rt_mutex_finish_proxy_lock(struct rt_mutex *lock, · 4 unmodified lines
1126		1042
1127	raw_spin_unlock(&lock->wait_lock);	1043	raw_spin_unlock(&lock->wait_lock);
1128		1044
1129	/*
1130	* Readjust priority, when we did not get the lock. We might have been
1131	* the pending owner and boosted. Since we did not take the lock, the
1132	* PI boost has to go.
1133	*/
1134	if (unlikely(ret))
1135	rt_mutex_adjust_prio(current);
1136
1137	return ret;	1045	return ret;
1138	}	1046	}

kernel/rtmutex_common.h+2−14

 /*
  * lock->owner state tracking:
  */
-#define RT_MUTEX_OWNER_PENDING	1UL
+#define RT_MUTEX_HAS_WAITERS	1UL
-#define RT_MUTEX_HAS_WAITERS	2UL
+#define RT_MUTEX_OWNER_MASKALL	1UL
-#define RT_MUTEX_OWNER_MASKALL	3UL
 static inline struct task_struct *rt_mutex_owner(struct rt_mutex *lock)
 {
 		((unsigned long)lock->owner & ~RT_MUTEX_OWNER_MASKALL);
 }
-static inline struct task_struct *rt_mutex_real_owner(struct rt_mutex *lock)
-{
-	return (struct task_struct *)
-		((unsigned long)lock->owner & ~RT_MUTEX_HAS_WAITERS);
-}
-static inline unsigned long rt_mutex_owner_pending(struct rt_mutex *lock)
-{
-	return (unsigned long)lock->owner & RT_MUTEX_OWNER_PENDING;
-}
 /*
  * PI-futex support (proxy locking functions, etc.):
  */

kernel/timer.c+23−0

@@ -970,6 +970,25 @@ EXPORT_SYMBOL(try_to_del_timer_sync); · 969 unmodified lines
970	* add_timer_on(). Upon exit the timer is not queued and the handler is	970	* add_timer_on(). Upon exit the timer is not queued and the handler is
971	* not running on any CPU.	971	* not running on any CPU.
972	*	972	*
		973	* Note: You must not hold locks that are held in interrupt context
		974	* while calling this function. Even if the lock has nothing to do
		975	* with the timer in question. Here's why:
		976	*
		977	* CPU0 CPU1
		978	* ---- ----
		979	* <SOFTIRQ>
		980	* call_timer_fn();
		981	* base->running_timer = mytimer;
		982	* spin_lock_irq(somelock);
		983	* <IRQ>
		984	* spin_lock(somelock);
		985	* del_timer_sync(mytimer);
		986	* while (base->running_timer == mytimer);
		987	*
		988	* Now del_timer_sync() will never return and never release somelock.
		989	* The interrupt on the other CPU is waiting to grab somelock but
		990	* it has interrupted the softirq that CPU0 is waiting to finish.
		991	*
973	* The function returns whether it has deactivated a pending timer or not.	992	* The function returns whether it has deactivated a pending timer or not.
974	*/	993	*/
975	int del_timer_sync(struct timer_list *timer)	994	int del_timer_sync(struct timer_list *timer)
@@ -977,6 +996,10 @@ int del_timer_sync(struct timer_list *timer) · 1 unmodified line
977	#ifdef CONFIG_LOCKDEP	996	#ifdef CONFIG_LOCKDEP
978	unsigned long flags;	997	unsigned long flags;
979		998
		999	/*
		1000	* If lockdep gives a backtrace here, please reference
		1001	* the synchronization rules above.
		1002	*/
980	local_irq_save(flags);	1003	local_irq_save(flags);
981	lock_map_acquire(&timer->lockdep_map);	1004	lock_map_acquire(&timer->lockdep_map);
982	lock_map_release(&timer->lockdep_map);	1005	lock_map_release(&timer->lockdep_map);

lib/rwsem.c+4−6

 /*
  * wait for the read lock to be granted
  */
-asmregparm struct rw_semaphore __sched *
+struct rw_semaphore __sched *rwsem_down_read_failed(struct rw_semaphore *sem)
-rwsem_down_read_failed(struct rw_semaphore *sem)
 {
 	return rwsem_down_failed_common(sem, RWSEM_WAITING_FOR_READ,
 					-RWSEM_ACTIVE_READ_BIAS);
 /*
  * wait for the write lock to be granted
  */
-asmregparm struct rw_semaphore __sched *
+struct rw_semaphore __sched *rwsem_down_write_failed(struct rw_semaphore *sem)
-rwsem_down_write_failed(struct rw_semaphore *sem)
 {
 	return rwsem_down_failed_common(sem, RWSEM_WAITING_FOR_WRITE,
 					-RWSEM_ACTIVE_WRITE_BIAS);
  * handle waking up a waiter on the semaphore
  * - up_read/up_write has decremented the active part of count if we come here
  */
-asmregparm struct rw_semaphore *rwsem_wake(struct rw_semaphore *sem)
+struct rw_semaphore *rwsem_wake(struct rw_semaphore *sem)
 {
 	unsigned long flags;
  * - caller incremented waiting part of count and discovered it still negative
  * - just wake up any readers at the front of the queue
  */
-asmregparm struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *sem)
+struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *sem)
 {
 	unsigned long flags;

scripts/checkpatch.pl+0−5

 			WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
 		}
-# SPIN_LOCK_UNLOCKED & RW_LOCK_UNLOCKED are deprecated
-		if ($line =~ /\b(SPIN_LOCK_UNLOCKED|RW_LOCK_UNLOCKED)/) {
-			ERROR("Use of $1 is deprecated: see Documentation/spinlocks.txt\n" . $herecurr);
-		}
 # warn about #if 0
 		if ($line =~ /^.\s*\#\s*if\s+0\b/) {
 			CHK("if this code is redundant consider removing it\n" .

scripts/rt-tester/rt-tester.py+0−2

     "lockintnowait" : "6",
     "lockcont"      : "7",
     "unlock"        : "8",
-    "lockbkl"       : "9",
-    "unlockbkl"     : "10",
     "signal"        : "11",
     "resetevent"    : "98",
     "reset"         : "99",

scripts/rt-tester/t2-l1-2rt-sameprio.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	0
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t2-l1-pi.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	0
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t2-l1-signal.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	0
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t2-l2-2rt-deadlock.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	0
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t3-l1-pi-1rt.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	thread to signal (0-7)
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t3-l1-pi-2rt.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	thread to signal (0-7)
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t3-l1-pi-3rt.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	thread to signal (0-7)
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t3-l1-pi-signal.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	thread to signal (0-7)
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t3-l1-pi-steal.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	thread to signal (0-7)
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t3-l2-pi.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	thread to signal (0-7)
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t4-l2-pi-deboost.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	thread to signal (0-7)
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t5-l4-pi-boost-deboost-setsched.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	thread to signal (0-7)
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number

scripts/rt-tester/t5-l4-pi-boost-deboost.tst+0−5

 # lockintnowait	lock nr (0-7)
 # lockcont	lock nr (0-7)
 # unlock	lock nr (0-7)
-# lockbkl	lock nr (0-7)
-# unlockbkl	lock nr (0-7)
 # signal	thread to signal (0-7)
 # reset		0
 # resetevent	0
 # blocked	lock nr (0-7)
 # blockedwake	lock nr (0-7)
 # unlocked	lock nr (0-7)
-# lockedbkl	dont care
-# blockedbkl	dont care
-# unlockedbkl	dont care
 # opcodeeq	command opcode or number
 # opcodelt	number
 # opcodegt	number