locks.h revision 356345 
1/**
2 * util/locks.h - unbound locking primitives
3 *
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
5 *
6 * This software is open source.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
14 *
15 * Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
18 *
19 * Neither the name of the NLNET LABS nor the names of its contributors may
20 * be used to endorse or promote products derived from this software without
21 * specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 */
35
36#ifndef UTIL_LOCKS_H
37#define UTIL_LOCKS_H
38
39/**
40 * \file
41 * Locking primitives.
42 * If pthreads is available, these are used.
43 * If no locking exists, they do nothing.
44 *
45 * The idea is to have different sorts of locks for different tasks.
46 * This allows the locking code to be ported more easily.
47 *
48 * Types of locks that are supported.
49 *   o lock_rw: lock that has many readers and one writer (to a data entry).
50 *   o lock_basic: simple mutex. Blocking, one person has access only.
51 *     This lock is meant for non performance sensitive uses.
52 *   o lock_quick: speed lock. For performance sensitive locking of critical
53 *     sections. Could be implemented by a mutex or a spinlock.
54 *
55 * Also thread creation and deletion functions are defined here.
56 */
57
58/* if you define your own LOCKRET before including locks.h, you can get most
59 * locking functions without the dependency on log_err. */
60#ifndef LOCKRET
61#include "util/log.h"
62/**
63 * The following macro is used to check the return value of the
64 * pthread calls. They return 0 on success and an errno on error.
65 * The errno is logged to the logfile with a descriptive comment.
66 */
67#define LOCKRET(func) do {\
68	int lockret_err;		\
69	if( (lockret_err=(func)) != 0)		\
70		log_err("%s at %d could not " #func ": %s", \
71		__FILE__, __LINE__, strerror(lockret_err));	\
72 	} while(0)
73#endif
74
75/** DEBUG: use thread debug whenever possible */
76#if defined(HAVE_PTHREAD) && defined(HAVE_PTHREAD_SPINLOCK_T) && defined(ENABLE_LOCK_CHECKS)
77#  define USE_THREAD_DEBUG
78#endif
79
80#ifdef USE_THREAD_DEBUG
81/******************* THREAD DEBUG ************************/
82/* (some) checking; to detect races and deadlocks. */
83#include "testcode/checklocks.h"
84
85#else /* USE_THREAD_DEBUG */
86#define lock_protect(lock, area, size) /* nop */
87#define lock_unprotect(lock, area) /* nop */
88#define lock_get_mem(lock) (0) /* nothing */
89#define checklock_start() /* nop */
90#define checklock_stop() /* nop */
91
92#ifdef HAVE_PTHREAD
93#include <pthread.h>
94
95/******************* PTHREAD ************************/
96
97/** use pthread mutex for basic lock */
98typedef pthread_mutex_t lock_basic_type;
99/** small front for pthread init func, NULL is default attrs. */
100#define lock_basic_init(lock) LOCKRET(pthread_mutex_init(lock, NULL))
101#define lock_basic_destroy(lock) LOCKRET(pthread_mutex_destroy(lock))
102#define lock_basic_lock(lock) LOCKRET(pthread_mutex_lock(lock))
103#define lock_basic_unlock(lock) LOCKRET(pthread_mutex_unlock(lock))
104
105#ifndef HAVE_PTHREAD_RWLOCK_T
106/** in case rwlocks are not supported, use a mutex. */
107typedef pthread_mutex_t lock_rw_type;
108#define lock_rw_init(lock) LOCKRET(pthread_mutex_init(lock, NULL))
109#define lock_rw_destroy(lock) LOCKRET(pthread_mutex_destroy(lock))
110#define lock_rw_rdlock(lock) LOCKRET(pthread_mutex_lock(lock))
111#define lock_rw_wrlock(lock) LOCKRET(pthread_mutex_lock(lock))
112#define lock_rw_unlock(lock) LOCKRET(pthread_mutex_unlock(lock))
113#else /* HAVE_PTHREAD_RWLOCK_T */
114/** we use the pthread rwlock */
115typedef pthread_rwlock_t lock_rw_type;
116/** small front for pthread init func, NULL is default attrs. */
117#define lock_rw_init(lock) LOCKRET(pthread_rwlock_init(lock, NULL))
118#define lock_rw_destroy(lock) LOCKRET(pthread_rwlock_destroy(lock))
119#define lock_rw_rdlock(lock) LOCKRET(pthread_rwlock_rdlock(lock))
120#define lock_rw_wrlock(lock) LOCKRET(pthread_rwlock_wrlock(lock))
121#define lock_rw_unlock(lock) LOCKRET(pthread_rwlock_unlock(lock))
122#endif /* HAVE_PTHREAD_RWLOCK_T */
123
124#ifndef HAVE_PTHREAD_SPINLOCK_T
125/** in case spinlocks are not supported, use a mutex. */
126typedef pthread_mutex_t lock_quick_type;
127/** small front for pthread init func, NULL is default attrs. */
128#define lock_quick_init(lock) LOCKRET(pthread_mutex_init(lock, NULL))
129#define lock_quick_destroy(lock) LOCKRET(pthread_mutex_destroy(lock))
130#define lock_quick_lock(lock) LOCKRET(pthread_mutex_lock(lock))
131#define lock_quick_unlock(lock) LOCKRET(pthread_mutex_unlock(lock))
132
133#else /* HAVE_PTHREAD_SPINLOCK_T */
134/** use pthread spinlock for the quick lock */
135typedef pthread_spinlock_t lock_quick_type;
136/**
137 * allocate process private since this is available whether
138 * Thread Process-Shared Synchronization is supported or not.
139 * This means only threads inside this process may access the lock.
140 * (not threads from another process that shares memory).
141 * spinlocks are not supported on all pthread platforms.
142 */
143#define lock_quick_init(lock) LOCKRET(pthread_spin_init(lock, PTHREAD_PROCESS_PRIVATE))
144#define lock_quick_destroy(lock) LOCKRET(pthread_spin_destroy(lock))
145#define lock_quick_lock(lock) LOCKRET(pthread_spin_lock(lock))
146#define lock_quick_unlock(lock) LOCKRET(pthread_spin_unlock(lock))
147
148#endif /* HAVE SPINLOCK */
149
150/** Thread creation */
151typedef pthread_t ub_thread_type;
152/** On alpine linux default thread stack size is 80 Kb. See
153http://wiki.musl-libc.org/wiki/Functional_differences_from_glibc#Thread_stack_size
154This is not enough and cause segfault. Other linux distros have 2 Mb at least.
155Wrapper for set up thread stack size */
156#define PTHREADSTACKSIZE 2*1024*1024
157#define PTHREADCREATE(thr, stackrequired, func, arg) do {\
158	pthread_attr_t attr; \
159	size_t stacksize; \
160	LOCKRET(pthread_attr_init(&attr)); \
161	LOCKRET(pthread_attr_getstacksize(&attr, &stacksize)); \
162	if (stacksize < stackrequired) { \
163		LOCKRET(pthread_attr_setstacksize(&attr, stackrequired)); \
164		LOCKRET(pthread_create(thr, &attr, func, arg)); \
165		LOCKRET(pthread_attr_getstacksize(&attr, &stacksize)); \
166		verbose(VERB_ALGO, "Thread stack size set to %u", (unsigned)stacksize); \
167	} else {LOCKRET(pthread_create(thr, NULL, func, arg));} \
168	} while(0)
169/** Use wrapper for set thread stack size on attributes. */
170#define ub_thread_create(thr, func, arg) PTHREADCREATE(thr, PTHREADSTACKSIZE, func, arg)
171/** get self id. */
172#define ub_thread_self() pthread_self()
173/** wait for another thread to terminate */
174#define ub_thread_join(thread) LOCKRET(pthread_join(thread, NULL))
175typedef pthread_key_t ub_thread_key_type;
176#define ub_thread_key_create(key, f) LOCKRET(pthread_key_create(key, f))
177#define ub_thread_key_set(key, v) LOCKRET(pthread_setspecific(key, v))
178#define ub_thread_key_get(key) pthread_getspecific(key)
179
180#else /* we do not HAVE_PTHREAD */
181#ifdef HAVE_SOLARIS_THREADS
182
183/******************* SOLARIS THREADS ************************/
184#include <synch.h>
185#include <thread.h>
186
187typedef rwlock_t lock_rw_type;
188#define lock_rw_init(lock) LOCKRET(rwlock_init(lock, USYNC_THREAD, NULL))
189#define lock_rw_destroy(lock) LOCKRET(rwlock_destroy(lock))
190#define lock_rw_rdlock(lock) LOCKRET(rw_rdlock(lock))
191#define lock_rw_wrlock(lock) LOCKRET(rw_wrlock(lock))
192#define lock_rw_unlock(lock) LOCKRET(rw_unlock(lock))
193
194/** use basic mutex */
195typedef mutex_t lock_basic_type;
196#define lock_basic_init(lock) LOCKRET(mutex_init(lock, USYNC_THREAD, NULL))
197#define lock_basic_destroy(lock) LOCKRET(mutex_destroy(lock))
198#define lock_basic_lock(lock) LOCKRET(mutex_lock(lock))
199#define lock_basic_unlock(lock) LOCKRET(mutex_unlock(lock))
200
201/** No spinlocks in solaris threads API. Use a mutex. */
202typedef mutex_t lock_quick_type;
203#define lock_quick_init(lock) LOCKRET(mutex_init(lock, USYNC_THREAD, NULL))
204#define lock_quick_destroy(lock) LOCKRET(mutex_destroy(lock))
205#define lock_quick_lock(lock) LOCKRET(mutex_lock(lock))
206#define lock_quick_unlock(lock) LOCKRET(mutex_unlock(lock))
207
208/** Thread creation, create a default thread. */
209typedef thread_t ub_thread_type;
210#define ub_thread_create(thr, func, arg) LOCKRET(thr_create(NULL, NULL, func, arg, NULL, thr))
211#define ub_thread_self() thr_self()
212#define ub_thread_join(thread) LOCKRET(thr_join(thread, NULL, NULL))
213typedef thread_key_t ub_thread_key_type;
214#define ub_thread_key_create(key, f) LOCKRET(thr_keycreate(key, f))
215#define ub_thread_key_set(key, v) LOCKRET(thr_setspecific(key, v))
216void* ub_thread_key_get(ub_thread_key_type key);
217
218
219#else /* we do not HAVE_SOLARIS_THREADS and no PTHREADS */
220/******************* WINDOWS THREADS ************************/
221#ifdef HAVE_WINDOWS_THREADS
222#include <windows.h>
223
224/* Use a mutex */
225typedef LONG lock_rw_type;
226#define lock_rw_init(lock) lock_basic_init(lock)
227#define lock_rw_destroy(lock) lock_basic_destroy(lock)
228#define lock_rw_rdlock(lock) lock_basic_lock(lock)
229#define lock_rw_wrlock(lock) lock_basic_lock(lock)
230#define lock_rw_unlock(lock) lock_basic_unlock(lock)
231
232/** the basic lock is a mutex, implemented opaquely, for error handling. */
233typedef LONG lock_basic_type;
234void lock_basic_init(lock_basic_type* lock);
235void lock_basic_destroy(lock_basic_type* lock);
236void lock_basic_lock(lock_basic_type* lock);
237void lock_basic_unlock(lock_basic_type* lock);
238
239/** on windows no spinlock, use mutex too. */
240typedef LONG lock_quick_type;
241#define lock_quick_init(lock) lock_basic_init(lock)
242#define lock_quick_destroy(lock) lock_basic_destroy(lock)
243#define lock_quick_lock(lock) lock_basic_lock(lock)
244#define lock_quick_unlock(lock) lock_basic_unlock(lock)
245
246/** Thread creation, create a default thread. */
247typedef HANDLE ub_thread_type;
248void ub_thread_create(ub_thread_type* thr, void* (*func)(void*), void* arg);
249ub_thread_type ub_thread_self(void);
250void ub_thread_join(ub_thread_type thr);
251typedef DWORD ub_thread_key_type;
252void ub_thread_key_create(ub_thread_key_type* key, void* f);
253void ub_thread_key_set(ub_thread_key_type key, void* v);
254void* ub_thread_key_get(ub_thread_key_type key);
255
256#else /* we do not HAVE_SOLARIS_THREADS, PTHREADS or WINDOWS_THREADS */
257
258/******************* NO THREADS ************************/
259#define THREADS_DISABLED 1
260/** In case there is no thread support, define locks to do nothing */
261typedef int lock_rw_type;
262#define lock_rw_init(lock) /* nop */
263#define lock_rw_destroy(lock) /* nop */
264#define lock_rw_rdlock(lock) /* nop */
265#define lock_rw_wrlock(lock) /* nop */
266#define lock_rw_unlock(lock) /* nop */
267
268/** define locks to do nothing */
269typedef int lock_basic_type;
270#define lock_basic_init(lock) /* nop */
271#define lock_basic_destroy(lock) /* nop */
272#define lock_basic_lock(lock) /* nop */
273#define lock_basic_unlock(lock) /* nop */
274
275/** define locks to do nothing */
276typedef int lock_quick_type;
277#define lock_quick_init(lock) /* nop */
278#define lock_quick_destroy(lock) /* nop */
279#define lock_quick_lock(lock) /* nop */
280#define lock_quick_unlock(lock) /* nop */
281
282/** Thread creation, threads do not exist */
283typedef pid_t ub_thread_type;
284/** ub_thread_create is simulated with fork (extremely heavy threads,
285  * with no shared memory). */
286#define ub_thread_create(thr, func, arg) \
287	ub_thr_fork_create(thr, func, arg)
288#define ub_thread_self() getpid()
289#define ub_thread_join(thread) ub_thr_fork_wait(thread)
290void ub_thr_fork_wait(ub_thread_type thread);
291void ub_thr_fork_create(ub_thread_type* thr, void* (*func)(void*), void* arg);
292typedef void* ub_thread_key_type;
293#define ub_thread_key_create(key, f) (*(key)) = NULL
294#define ub_thread_key_set(key, v) (key) = (v)
295#define ub_thread_key_get(key) (key)
296
297#endif /* HAVE_WINDOWS_THREADS */
298#endif /* HAVE_SOLARIS_THREADS */
299#endif /* HAVE_PTHREAD */
300#endif /* USE_THREAD_DEBUG */
301
302/**
303 * Block all signals for this thread.
304 * fatal exit on error.
305 */
306void ub_thread_blocksigs(void);
307
308/**
309 * unblock one signal for this thread.
310 */
311void ub_thread_sig_unblock(int sig);
312
313#endif /* UTIL_LOCKS_H */
314