xref: /freebsd/contrib/ntp/sntp/libevent/evthread.c (revision aa1a8ff2d6dbc51ef058f46f3db5a8bb77967145) 
1 /*
2  * Copyright (c) 2008-2012 Niels Provos, Nick Mathewson
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  * 3. The name of the author may not be used to endorse or promote products
13  *    derived from this software without specific prior written permission.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26 
27 #include "event2/event-config.h"
28 #include "evconfig-private.h"
29 
30 #ifndef EVENT__DISABLE_THREAD_SUPPORT
31 
32 #include "event2/thread.h"
33 
34 #include <stdlib.h>
35 #include <string.h>
36 
37 #include "log-internal.h"
38 #include "mm-internal.h"
39 #include "util-internal.h"
40 #include "evthread-internal.h"
41 
42 #ifdef EVTHREAD_EXPOSE_STRUCTS
43 #define GLOBAL
44 #else
45 #define GLOBAL static
46 #endif
47 
48 #ifndef EVENT__DISABLE_DEBUG_MODE
49 extern int event_debug_created_threadable_ctx_;
50 extern int event_debug_mode_on_;
51 #endif
52 
53 /* globals */
54 GLOBAL int evthread_lock_debugging_enabled_ = 0;
55 GLOBAL struct evthread_lock_callbacks evthread_lock_fns_ = {
56 	0, 0, NULL, NULL, NULL, NULL
57 };
58 GLOBAL unsigned long (*evthread_id_fn_)(void) = NULL;
59 GLOBAL struct evthread_condition_callbacks evthread_cond_fns_ = {
60 	0, NULL, NULL, NULL, NULL
61 };
62 
63 /* Used for debugging */
64 static struct evthread_lock_callbacks original_lock_fns_ = {
65 	0, 0, NULL, NULL, NULL, NULL
66 };
67 static struct evthread_condition_callbacks original_cond_fns_ = {
68 	0, NULL, NULL, NULL, NULL
69 };
70 
71 void
72 evthread_set_id_callback(unsigned long (*id_fn)(void))
73 {
74 	evthread_id_fn_ = id_fn;
75 }
76 
77 struct evthread_lock_callbacks *evthread_get_lock_callbacks()
78 {
79 	return evthread_lock_debugging_enabled_
80 	    ? &original_lock_fns_ : &evthread_lock_fns_;
81 }
82 struct evthread_condition_callbacks *evthread_get_condition_callbacks()
83 {
84 	return evthread_lock_debugging_enabled_
85 	    ? &original_cond_fns_ : &evthread_cond_fns_;
86 }
87 void evthreadimpl_disable_lock_debugging_(void)
88 {
89 	evthread_lock_debugging_enabled_ = 0;
90 }
91 
92 int
93 evthread_set_lock_callbacks(const struct evthread_lock_callbacks *cbs)
94 {
95 	struct evthread_lock_callbacks *target = evthread_get_lock_callbacks();
96 
97 #ifndef EVENT__DISABLE_DEBUG_MODE
98 	if (event_debug_mode_on_) {
99 		if (event_debug_created_threadable_ctx_) {
100 		    event_errx(1, "evthread initialization must be called BEFORE anything else!");
101 		}
102 	}
103 #endif
104 
105 	if (!cbs) {
106 		if (target->alloc)
107 			event_warnx("Trying to disable lock functions after "
108 			    "they have been set up will probaby not work.");
109 		memset(target, 0, sizeof(evthread_lock_fns_));
110 		return 0;
111 	}
112 	if (target->alloc) {
113 		/* Uh oh; we already had locking callbacks set up.*/
114 		if (target->lock_api_version == cbs->lock_api_version &&
115 			target->supported_locktypes == cbs->supported_locktypes &&
116 			target->alloc == cbs->alloc &&
117 			target->free == cbs->free &&
118 			target->lock == cbs->lock &&
119 			target->unlock == cbs->unlock) {
120 			/* no change -- allow this. */
121 			return 0;
122 		}
123 		event_warnx("Can't change lock callbacks once they have been "
124 		    "initialized.");
125 		return -1;
126 	}
127 	if (cbs->alloc && cbs->free && cbs->lock && cbs->unlock) {
128 		memcpy(target, cbs, sizeof(evthread_lock_fns_));
129 		return event_global_setup_locks_(1);
130 	} else {
131 		return -1;
132 	}
133 }
134 
135 int
136 evthread_set_condition_callbacks(const struct evthread_condition_callbacks *cbs)
137 {
138 	struct evthread_condition_callbacks *target = evthread_get_condition_callbacks();
139 
140 #ifndef EVENT__DISABLE_DEBUG_MODE
141 	if (event_debug_mode_on_) {
142 		if (event_debug_created_threadable_ctx_) {
143 		    event_errx(1, "evthread initialization must be called BEFORE anything else!");
144 		}
145 	}
146 #endif
147 
148 	if (!cbs) {
149 		if (target->alloc_condition)
150 			event_warnx("Trying to disable condition functions "
151 			    "after they have been set up will probaby not "
152 			    "work.");
153 		memset(target, 0, sizeof(evthread_cond_fns_));
154 		return 0;
155 	}
156 	if (target->alloc_condition) {
157 		/* Uh oh; we already had condition callbacks set up.*/
158 		if (target->condition_api_version == cbs->condition_api_version &&
159 			target->alloc_condition == cbs->alloc_condition &&
160 			target->free_condition == cbs->free_condition &&
161 			target->signal_condition == cbs->signal_condition &&
162 			target->wait_condition == cbs->wait_condition) {
163 			/* no change -- allow this. */
164 			return 0;
165 		}
166 		event_warnx("Can't change condition callbacks once they "
167 		    "have been initialized.");
168 		return -1;
169 	}
170 	if (cbs->alloc_condition && cbs->free_condition &&
171 	    cbs->signal_condition && cbs->wait_condition) {
172 		memcpy(target, cbs, sizeof(evthread_cond_fns_));
173 	}
174 	if (evthread_lock_debugging_enabled_) {
175 		evthread_cond_fns_.alloc_condition = cbs->alloc_condition;
176 		evthread_cond_fns_.free_condition = cbs->free_condition;
177 		evthread_cond_fns_.signal_condition = cbs->signal_condition;
178 	}
179 	return 0;
180 }
181 
182 #define DEBUG_LOCK_SIG	0xdeb0b10c
183 
184 struct debug_lock {
185 	unsigned signature;
186 	unsigned locktype;
187 	unsigned long held_by;
188 	/* XXXX if we ever use read-write locks, we will need a separate
189 	 * lock to protect count. */
190 	int count;
191 	void *lock;
192 };
193 
194 static void *
195 debug_lock_alloc(unsigned locktype)
196 {
197 	struct debug_lock *result = mm_malloc(sizeof(struct debug_lock));
198 	if (!result)
199 		return NULL;
200 	if (original_lock_fns_.alloc) {
201 		if (!(result->lock = original_lock_fns_.alloc(
202 				locktype|EVTHREAD_LOCKTYPE_RECURSIVE))) {
203 			mm_free(result);
204 			return NULL;
205 		}
206 	} else {
207 		result->lock = NULL;
208 	}
209 	result->signature = DEBUG_LOCK_SIG;
210 	result->locktype = locktype;
211 	result->count = 0;
212 	result->held_by = 0;
213 	return result;
214 }
215 
216 static void
217 debug_lock_free(void *lock_, unsigned locktype)
218 {
219 	struct debug_lock *lock = lock_;
220 	EVUTIL_ASSERT(lock->count == 0);
221 	EVUTIL_ASSERT(locktype == lock->locktype);
222 	EVUTIL_ASSERT(DEBUG_LOCK_SIG == lock->signature);
223 	if (original_lock_fns_.free) {
224 		original_lock_fns_.free(lock->lock,
225 		    lock->locktype|EVTHREAD_LOCKTYPE_RECURSIVE);
226 	}
227 	lock->lock = NULL;
228 	lock->count = -100;
229 	lock->signature = 0x12300fda;
230 	mm_free(lock);
231 }
232 
233 static void
234 evthread_debug_lock_mark_locked(unsigned mode, struct debug_lock *lock)
235 {
236 	EVUTIL_ASSERT(DEBUG_LOCK_SIG == lock->signature);
237 	++lock->count;
238 	if (!(lock->locktype & EVTHREAD_LOCKTYPE_RECURSIVE))
239 		EVUTIL_ASSERT(lock->count == 1);
240 	if (evthread_id_fn_) {
241 		unsigned long me;
242 		me = evthread_id_fn_();
243 		if (lock->count > 1)
244 			EVUTIL_ASSERT(lock->held_by == me);
245 		lock->held_by = me;
246 	}
247 }
248 
249 static int
250 debug_lock_lock(unsigned mode, void *lock_)
251 {
252 	struct debug_lock *lock = lock_;
253 	int res = 0;
254 	if (lock->locktype & EVTHREAD_LOCKTYPE_READWRITE)
255 		EVUTIL_ASSERT(mode & (EVTHREAD_READ|EVTHREAD_WRITE));
256 	else
257 		EVUTIL_ASSERT((mode & (EVTHREAD_READ|EVTHREAD_WRITE)) == 0);
258 	if (original_lock_fns_.lock)
259 		res = original_lock_fns_.lock(mode, lock->lock);
260 	if (!res) {
261 		evthread_debug_lock_mark_locked(mode, lock);
262 	}
263 	return res;
264 }
265 
266 static void
267 evthread_debug_lock_mark_unlocked(unsigned mode, struct debug_lock *lock)
268 {
269 	EVUTIL_ASSERT(DEBUG_LOCK_SIG == lock->signature);
270 	if (lock->locktype & EVTHREAD_LOCKTYPE_READWRITE)
271 		EVUTIL_ASSERT(mode & (EVTHREAD_READ|EVTHREAD_WRITE));
272 	else
273 		EVUTIL_ASSERT((mode & (EVTHREAD_READ|EVTHREAD_WRITE)) == 0);
274 	if (evthread_id_fn_) {
275 		unsigned long me;
276 		me = evthread_id_fn_();
277 		EVUTIL_ASSERT(lock->held_by == me);
278 		if (lock->count == 1)
279 			lock->held_by = 0;
280 	}
281 	--lock->count;
282 	EVUTIL_ASSERT(lock->count >= 0);
283 }
284 
285 static int
286 debug_lock_unlock(unsigned mode, void *lock_)
287 {
288 	struct debug_lock *lock = lock_;
289 	int res = 0;
290 	evthread_debug_lock_mark_unlocked(mode, lock);
291 	if (original_lock_fns_.unlock)
292 		res = original_lock_fns_.unlock(mode, lock->lock);
293 	return res;
294 }
295 
296 static int
297 debug_cond_wait(void *cond_, void *lock_, const struct timeval *tv)
298 {
299 	int r;
300 	struct debug_lock *lock = lock_;
301 	EVUTIL_ASSERT(lock);
302 	EVUTIL_ASSERT(DEBUG_LOCK_SIG == lock->signature);
303 	EVLOCK_ASSERT_LOCKED(lock_);
304 	evthread_debug_lock_mark_unlocked(0, lock);
305 	r = original_cond_fns_.wait_condition(cond_, lock->lock, tv);
306 	evthread_debug_lock_mark_locked(0, lock);
307 	return r;
308 }
309 
310 /* misspelled version for backward compatibility */
311 void
312 evthread_enable_lock_debuging(void)
313 {
314 	evthread_enable_lock_debugging();
315 }
316 
317 void
318 evthread_enable_lock_debugging(void)
319 {
320 	struct evthread_lock_callbacks cbs = {
321 		EVTHREAD_LOCK_API_VERSION,
322 		EVTHREAD_LOCKTYPE_RECURSIVE,
323 		debug_lock_alloc,
324 		debug_lock_free,
325 		debug_lock_lock,
326 		debug_lock_unlock
327 	};
328 	if (evthread_lock_debugging_enabled_)
329 		return;
330 	memcpy(&original_lock_fns_, &evthread_lock_fns_,
331 	    sizeof(struct evthread_lock_callbacks));
332 	memcpy(&evthread_lock_fns_, &cbs,
333 	    sizeof(struct evthread_lock_callbacks));
334 
335 	memcpy(&original_cond_fns_, &evthread_cond_fns_,
336 	    sizeof(struct evthread_condition_callbacks));
337 	evthread_cond_fns_.wait_condition = debug_cond_wait;
338 	evthread_lock_debugging_enabled_ = 1;
339 
340 	/* XXX return value should get checked. */
341 	event_global_setup_locks_(0);
342 }
343 
344 int
345 evthread_is_debug_lock_held_(void *lock_)
346 {
347 	struct debug_lock *lock = lock_;
348 	if (! lock->count)
349 		return 0;
350 	if (evthread_id_fn_) {
351 		unsigned long me = evthread_id_fn_();
352 		if (lock->held_by != me)
353 			return 0;
354 	}
355 	return 1;
356 }
357 
358 void *
359 evthread_debug_get_real_lock_(void *lock_)
360 {
361 	struct debug_lock *lock = lock_;
362 	return lock->lock;
363 }
364 
365 void *
366 evthread_setup_global_lock_(void *lock_, unsigned locktype, int enable_locks)
367 {
368 	/* there are four cases here:
369 	   1) we're turning on debugging; locking is not on.
370 	   2) we're turning on debugging; locking is on.
371 	   3) we're turning on locking; debugging is not on.
372 	   4) we're turning on locking; debugging is on. */
373 
374 	if (!enable_locks && original_lock_fns_.alloc == NULL) {
375 		/* Case 1: allocate a debug lock. */
376 		EVUTIL_ASSERT(lock_ == NULL);
377 		return debug_lock_alloc(locktype);
378 	} else if (!enable_locks && original_lock_fns_.alloc != NULL) {
379 		/* Case 2: wrap the lock in a debug lock. */
380 		struct debug_lock *lock;
381 		EVUTIL_ASSERT(lock_ != NULL);
382 
383 		if (!(locktype & EVTHREAD_LOCKTYPE_RECURSIVE)) {
384 			/* We can't wrap it: We need a recursive lock */
385 			original_lock_fns_.free(lock_, locktype);
386 			return debug_lock_alloc(locktype);
387 		}
388 		lock = mm_malloc(sizeof(struct debug_lock));
389 		if (!lock) {
390 			original_lock_fns_.free(lock_, locktype);
391 			return NULL;
392 		}
393 		lock->lock = lock_;
394 		lock->locktype = locktype;
395 		lock->count = 0;
396 		lock->held_by = 0;
397 		return lock;
398 	} else if (enable_locks && ! evthread_lock_debugging_enabled_) {
399 		/* Case 3: allocate a regular lock */
400 		EVUTIL_ASSERT(lock_ == NULL);
401 		return evthread_lock_fns_.alloc(locktype);
402 	} else {
403 		/* Case 4: Fill in a debug lock with a real lock */
404 		struct debug_lock *lock = lock_ ? lock_ : debug_lock_alloc(locktype);
405 		EVUTIL_ASSERT(enable_locks &&
406 		              evthread_lock_debugging_enabled_);
407 		EVUTIL_ASSERT(lock->locktype == locktype);
408 		if (!lock->lock) {
409 			lock->lock = original_lock_fns_.alloc(
410 				locktype|EVTHREAD_LOCKTYPE_RECURSIVE);
411 			if (!lock->lock) {
412 				lock->count = -200;
413 				mm_free(lock);
414 				return NULL;
415 			}
416 		}
417 		return lock;
418 	}
419 }
420 
421 
422 #ifndef EVTHREAD_EXPOSE_STRUCTS
423 unsigned long
424 evthreadimpl_get_id_()
425 {
426 	return evthread_id_fn_ ? evthread_id_fn_() : 1;
427 }
428 void *
429 evthreadimpl_lock_alloc_(unsigned locktype)
430 {
431 #ifndef EVENT__DISABLE_DEBUG_MODE
432 	if (event_debug_mode_on_) {
433 		event_debug_created_threadable_ctx_ = 1;
434 	}
435 #endif
436 
437 	return evthread_lock_fns_.alloc ?
438 	    evthread_lock_fns_.alloc(locktype) : NULL;
439 }
440 void
441 evthreadimpl_lock_free_(void *lock, unsigned locktype)
442 {
443 	if (evthread_lock_fns_.free)
444 		evthread_lock_fns_.free(lock, locktype);
445 }
446 int
447 evthreadimpl_lock_lock_(unsigned mode, void *lock)
448 {
449 	if (evthread_lock_fns_.lock)
450 		return evthread_lock_fns_.lock(mode, lock);
451 	else
452 		return 0;
453 }
454 int
455 evthreadimpl_lock_unlock_(unsigned mode, void *lock)
456 {
457 	if (evthread_lock_fns_.unlock)
458 		return evthread_lock_fns_.unlock(mode, lock);
459 	else
460 		return 0;
461 }
462 void *
463 evthreadimpl_cond_alloc_(unsigned condtype)
464 {
465 #ifndef EVENT__DISABLE_DEBUG_MODE
466 	if (event_debug_mode_on_) {
467 		event_debug_created_threadable_ctx_ = 1;
468 	}
469 #endif
470 
471 	return evthread_cond_fns_.alloc_condition ?
472 	    evthread_cond_fns_.alloc_condition(condtype) : NULL;
473 }
474 void
475 evthreadimpl_cond_free_(void *cond)
476 {
477 	if (evthread_cond_fns_.free_condition)
478 		evthread_cond_fns_.free_condition(cond);
479 }
480 int
481 evthreadimpl_cond_signal_(void *cond, int broadcast)
482 {
483 	if (evthread_cond_fns_.signal_condition)
484 		return evthread_cond_fns_.signal_condition(cond, broadcast);
485 	else
486 		return 0;
487 }
488 int
489 evthreadimpl_cond_wait_(void *cond, void *lock, const struct timeval *tv)
490 {
491 	if (evthread_cond_fns_.wait_condition)
492 		return evthread_cond_fns_.wait_condition(cond, lock, tv);
493 	else
494 		return 0;
495 }
496 int
497 evthreadimpl_is_lock_debugging_enabled_(void)
498 {
499 	return evthread_lock_debugging_enabled_;
500 }
501 
502 int
503 evthreadimpl_locking_enabled_(void)
504 {
505 	return evthread_lock_fns_.lock != NULL;
506 }
507 #endif
508 
509 #endif
510