lock.h revision 86c12bf0
1/*
2 * Copyright 2008-2011, Ingo Weinhold, ingo_weinhold@gmx.de.
3 * Copyright 2002-2009, Axel D��rfler, axeld@pinc-software.de.
4 * Distributed under the terms of the MIT License.
5 *
6 * Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
7 * Distributed under the terms of the NewOS License.
8 */
9#ifndef _KERNEL_LOCK_H
10#define _KERNEL_LOCK_H
11
12
13#include <OS.h>
14
15#include <arch/atomic.h>
16#include <debug.h>
17
18
19struct mutex_waiter;
20
21typedef struct mutex {
22	const char*				name;
23	struct mutex_waiter*	waiters;
24	spinlock				lock;
25#if KDEBUG
26	thread_id				holder;
27#else
28	int32					count;
29	uint16					ignore_unlock_count;
30#endif
31	uint8					flags;
32} mutex;
33
34#define MUTEX_FLAG_CLONE_NAME	0x1
35
36
37typedef struct recursive_lock {
38	mutex		lock;
39#if !KDEBUG
40	thread_id	holder;
41#endif
42	int			recursion;
43} recursive_lock;
44
45
46struct rw_lock_waiter;
47
48typedef struct rw_lock {
49	const char*				name;
50	struct rw_lock_waiter*	waiters;
51	spinlock				lock;
52	thread_id				holder;
53	int32					count;
54	int32					owner_count;
55	int16					active_readers;
56								// Only > 0 while a writer is waiting: number
57								// of active readers when the first waiting
58								// writer started waiting.
59	int16					pending_readers;
60								// Number of readers that have already
61								// incremented "count", but have not yet started
62								// to wait at the time the last writer unlocked.
63	uint32					flags;
64} rw_lock;
65
66#define RW_LOCK_WRITER_COUNT_BASE	0x10000
67
68#define RW_LOCK_FLAG_CLONE_NAME	0x1
69
70
71#if KDEBUG
72#	define KDEBUG_RW_LOCK_DEBUG 0
73		// Define to 1 if you want to use ASSERT_READ_LOCKED_RW_LOCK().
74		// The rw_lock will just behave like a recursive locker then.
75#	define ASSERT_LOCKED_RECURSIVE(r) \
76		{ ASSERT(find_thread(NULL) == (r)->lock.holder); }
77#	define ASSERT_LOCKED_MUTEX(m) { ASSERT(find_thread(NULL) == (m)->holder); }
78#	define ASSERT_WRITE_LOCKED_RW_LOCK(l) \
79		{ ASSERT(find_thread(NULL) == (l)->holder); }
80#	if KDEBUG_RW_LOCK_DEBUG
81#		define ASSERT_READ_LOCKED_RW_LOCK(l) \
82			{ ASSERT(find_thread(NULL) == (l)->holder); }
83#	else
84#		define ASSERT_READ_LOCKED_RW_LOCK(l) do {} while (false)
85#	endif
86#else
87#	define ASSERT_LOCKED_RECURSIVE(r)		do {} while (false)
88#	define ASSERT_LOCKED_MUTEX(m)			do {} while (false)
89#	define ASSERT_WRITE_LOCKED_RW_LOCK(m)	do {} while (false)
90#	define ASSERT_READ_LOCKED_RW_LOCK(l)	do {} while (false)
91#endif
92
93
94// static initializers
95#if KDEBUG
96#	define MUTEX_INITIALIZER(name) \
97	{ name, NULL, B_SPINLOCK_INITIALIZER, -1, 0 }
98#	define RECURSIVE_LOCK_INITIALIZER(name)	{ MUTEX_INITIALIZER(name), 0 }
99#else
100#	define MUTEX_INITIALIZER(name) \
101	{ name, NULL, B_SPINLOCK_INITIALIZER, 0, 0, 0 }
102#	define RECURSIVE_LOCK_INITIALIZER(name)	{ MUTEX_INITIALIZER(name), -1, 0 }
103#endif
104
105#define RW_LOCK_INITIALIZER(name) \
106	{ name, NULL, B_SPINLOCK_INITIALIZER, -1, 0, 0, 0, 0, 0 }
107
108
109#if KDEBUG
110#	define RECURSIVE_LOCK_HOLDER(recursiveLock)	((recursiveLock)->lock.holder)
111#else
112#	define RECURSIVE_LOCK_HOLDER(recursiveLock)	((recursiveLock)->holder)
113#endif
114
115
116#ifdef __cplusplus
117extern "C" {
118#endif
119
120extern void	recursive_lock_init(recursive_lock *lock, const char *name);
121	// name is *not* cloned nor freed in recursive_lock_destroy()
122extern void recursive_lock_init_etc(recursive_lock *lock, const char *name,
123	uint32 flags);
124extern void recursive_lock_destroy(recursive_lock *lock);
125extern status_t recursive_lock_lock(recursive_lock *lock);
126extern status_t recursive_lock_trylock(recursive_lock *lock);
127extern void recursive_lock_unlock(recursive_lock *lock);
128extern int32 recursive_lock_get_recursion(recursive_lock *lock);
129
130extern void rw_lock_init(rw_lock* lock, const char* name);
131	// name is *not* cloned nor freed in rw_lock_destroy()
132extern void rw_lock_init_etc(rw_lock* lock, const char* name, uint32 flags);
133extern void rw_lock_destroy(rw_lock* lock);
134extern status_t rw_lock_write_lock(rw_lock* lock);
135
136extern void mutex_init(mutex* lock, const char* name);
137	// name is *not* cloned nor freed in mutex_destroy()
138extern void mutex_init_etc(mutex* lock, const char* name, uint32 flags);
139extern void mutex_destroy(mutex* lock);
140extern status_t mutex_switch_lock(mutex* from, mutex* to);
141	// Unlocks "from" and locks "to" such that unlocking and starting to wait
142	// for the lock is atomically. I.e. if "from" guards the object "to" belongs
143	// to, the operation is safe as long as "from" is held while destroying
144	// "to".
145extern status_t mutex_switch_from_read_lock(rw_lock* from, mutex* to);
146	// Like mutex_switch_lock(), just for a switching from a read-locked
147	// rw_lock.
148
149
150// implementation private:
151
152extern status_t _rw_lock_read_lock(rw_lock* lock);
153extern status_t _rw_lock_read_lock_with_timeout(rw_lock* lock,
154	uint32 timeoutFlags, bigtime_t timeout);
155extern void _rw_lock_read_unlock(rw_lock* lock);
156extern void _rw_lock_write_unlock(rw_lock* lock);
157
158extern status_t _mutex_lock(mutex* lock, void* locker);
159extern void _mutex_unlock(mutex* lock);
160extern status_t _mutex_trylock(mutex* lock);
161extern status_t _mutex_lock_with_timeout(mutex* lock, uint32 timeoutFlags,
162	bigtime_t timeout);
163
164
165static inline status_t
166rw_lock_read_lock(rw_lock* lock)
167{
168#if KDEBUG_RW_LOCK_DEBUG
169	return rw_lock_write_lock(lock);
170#else
171	int32 oldCount = atomic_add(&lock->count, 1);
172	if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
173		return _rw_lock_read_lock(lock);
174	return B_OK;
175#endif
176}
177
178
179static inline status_t
180rw_lock_read_lock_with_timeout(rw_lock* lock, uint32 timeoutFlags,
181	bigtime_t timeout)
182{
183#if KDEBUG_RW_LOCK_DEBUG
184	return mutex_lock_with_timeout(lock, timeoutFlags, timeout);
185#else
186	int32 oldCount = atomic_add(&lock->count, 1);
187	if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
188		return _rw_lock_read_lock_with_timeout(lock, timeoutFlags, timeout);
189	return B_OK;
190#endif
191}
192
193
194static inline void
195rw_lock_read_unlock(rw_lock* lock)
196{
197#if KDEBUG_RW_LOCK_DEBUG
198	rw_lock_write_unlock(lock);
199#else
200	int32 oldCount = atomic_add(&lock->count, -1);
201	if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
202		_rw_lock_read_unlock(lock);
203#endif
204}
205
206
207static inline void
208rw_lock_write_unlock(rw_lock* lock)
209{
210	_rw_lock_write_unlock(lock);
211}
212
213
214static inline status_t
215mutex_lock(mutex* lock)
216{
217#if KDEBUG
218	return _mutex_lock(lock, NULL);
219#else
220	if (atomic_add(&lock->count, -1) < 0)
221		return _mutex_lock(lock, NULL);
222	return B_OK;
223#endif
224}
225
226
227static inline status_t
228mutex_trylock(mutex* lock)
229{
230#if KDEBUG
231	return _mutex_trylock(lock);
232#else
233	if (atomic_test_and_set(&lock->count, -1, 0) != 0)
234		return B_WOULD_BLOCK;
235	return B_OK;
236#endif
237}
238
239
240static inline status_t
241mutex_lock_with_timeout(mutex* lock, uint32 timeoutFlags, bigtime_t timeout)
242{
243#if KDEBUG
244	return _mutex_lock_with_timeout(lock, timeoutFlags, timeout);
245#else
246	if (atomic_add(&lock->count, -1) < 0)
247		return _mutex_lock_with_timeout(lock, timeoutFlags, timeout);
248	return B_OK;
249#endif
250}
251
252
253static inline void
254mutex_unlock(mutex* lock)
255{
256#if !KDEBUG
257	if (atomic_add(&lock->count, 1) < -1)
258#endif
259		_mutex_unlock(lock);
260}
261
262
263static inline void
264mutex_transfer_lock(mutex* lock, thread_id thread)
265{
266#if KDEBUG
267	lock->holder = thread;
268#endif
269}
270
271
272static inline void
273recursive_lock_transfer_lock(recursive_lock* lock, thread_id thread)
274{
275	if (lock->recursion != 1)
276		panic("invalid recursion level for lock transfer!");
277
278#if KDEBUG
279	lock->lock.holder = thread;
280#else
281	lock->holder = thread;
282#endif
283}
284
285
286extern void lock_debug_init();
287
288#ifdef __cplusplus
289}
290#endif
291
292#endif	/* _KERNEL_LOCK_H */
293