1: /*
2: * Copyright (C) 2009-2012 Tobias Brunner
3: * HSR Hochschule fuer Technik Rapperswil
4: *
5: * This program is free software; you can redistribute it and/or modify it
6: * under the terms of the GNU General Public License as published by the
7: * Free Software Foundation; either version 2 of the License, or (at your
8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
9: *
10: * This program is distributed in the hope that it will be useful, but
11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13: * for more details.
14: */
15:
16: #define _GNU_SOURCE
17: #include <pthread.h>
18: #include <signal.h>
19:
20: #ifdef HAVE_GETTID
21: #include <sys/types.h>
22: #include <unistd.h>
23: #endif
24:
25: #ifdef HAVE_SYS_GETTID
26: #include <sys/syscall.h>
27: static inline pid_t gettid()
28: {
29: return syscall(SYS_gettid);
30: }
31: #endif
32:
33: #include <library.h>
34: #include <utils/debug.h>
35:
36: #include <threading/thread_value.h>
37: #include <threading/mutex.h>
38: #include <collections/linked_list.h>
39:
40: #include "thread.h"
41:
42: typedef struct private_thread_t private_thread_t;
43:
44: struct private_thread_t {
45: /**
46: * Public interface.
47: */
48: thread_t public;
49:
50: /**
51: * Identifier of this thread (human-readable/thread ID).
52: */
53: u_int id;
54:
55: /**
56: * ID of the underlying thread.
57: */
58: pthread_t thread_id;
59:
60: /**
61: * Main function of this thread (NULL for the main thread).
62: */
63: thread_main_t main;
64:
65: /**
66: * Argument for the main function.
67: */
68: void *arg;
69:
70: /**
71: * Stack of cleanup handlers.
72: */
73: linked_list_t *cleanup_handlers;
74:
75: /**
76: * Mutex to make modifying thread properties safe.
77: */
78: mutex_t *mutex;
79:
80: /**
81: * TRUE if this thread has been detached or joined, i.e. can be cleaned
82: * up after terminating.
83: */
84: bool detached_or_joined;
85:
86: /**
87: * TRUE if the threads has terminated (cancelled, via thread_exit or
88: * returned from the main function)
89: */
90: bool terminated;
91:
92: };
93:
94: typedef struct {
95: /**
96: * Cleanup callback function.
97: */
98: thread_cleanup_t cleanup;
99:
100: /**
101: * Argument provided to the cleanup function.
102: */
103: void *arg;
104:
105: } cleanup_handler_t;
106:
107:
108: /**
109: * Next thread ID.
110: */
111: static u_int next_id;
112:
113: /**
114: * Mutex to safely access the next thread ID.
115: */
116: static mutex_t *id_mutex;
117:
118: /**
119: * Store the thread object in a thread-specific value.
120: */
121: static thread_value_t *current_thread;
122:
123:
124: #ifndef HAVE_PTHREAD_CANCEL
125: /* if pthread_cancel is not available, we emulate it using a signal */
126: #ifdef ANDROID
127: #define SIG_CANCEL SIGUSR2
128: #else
129: #define SIG_CANCEL (SIGRTMIN+7)
130: #endif
131:
132: /* the signal handler for SIG_CANCEL uses pthread_exit to terminate the
133: * "cancelled" thread */
134: static void cancel_signal_handler(int sig)
135: {
136: pthread_exit(NULL);
137: }
138: #endif
139:
140:
141: /**
142: * Destroy an internal thread object.
143: *
144: * @note The mutex of this thread object has to be locked, it gets unlocked
145: * automatically.
146: */
147: static void thread_destroy(private_thread_t *this)
148: {
149: if (!this->terminated || !this->detached_or_joined)
150: {
151: this->mutex->unlock(this->mutex);
152: return;
153: }
154: this->cleanup_handlers->destroy(this->cleanup_handlers);
155: this->mutex->unlock(this->mutex);
156: this->mutex->destroy(this->mutex);
157: free(this);
158: }
159:
160: /**
161: * Determine the ID of the current thread
162: */
163: static u_int get_thread_id()
164: {
165: u_int id;
166:
167: #if defined(USE_THREAD_IDS) && defined(HAVE_GETTID)
168: id = gettid();
169: #else
170: id_mutex->lock(id_mutex);
171: id = next_id++;
172: id_mutex->unlock(id_mutex);
173: #endif
174: return id;
175: }
176:
177: METHOD(thread_t, cancel, void,
178: private_thread_t *this)
179: {
180: this->mutex->lock(this->mutex);
181: if (pthread_equal(this->thread_id, pthread_self()))
182: {
183: this->mutex->unlock(this->mutex);
184: DBG1(DBG_LIB, "!!! CANNOT CANCEL CURRENT THREAD !!!");
185: return;
186: }
187: #ifdef HAVE_PTHREAD_CANCEL
188: pthread_cancel(this->thread_id);
189: #else
190: pthread_kill(this->thread_id, SIG_CANCEL);
191: #endif /* HAVE_PTHREAD_CANCEL */
192: this->mutex->unlock(this->mutex);
193: }
194:
195: METHOD(thread_t, kill_, void,
196: private_thread_t *this, int sig)
197: {
198: this->mutex->lock(this->mutex);
199: if (pthread_equal(this->thread_id, pthread_self()))
200: {
201: /* it might actually be possible to send a signal to pthread_self (there
202: * is an example in raise(3) describing that), the problem is though,
203: * that the thread only returns here after the signal handler has
204: * returned, so depending on the signal, the lock might not get
205: * unlocked. */
206: this->mutex->unlock(this->mutex);
207: DBG1(DBG_LIB, "!!! CANNOT SEND SIGNAL TO CURRENT THREAD !!!");
208: return;
209: }
210: pthread_kill(this->thread_id, sig);
211: this->mutex->unlock(this->mutex);
212: }
213:
214: METHOD(thread_t, detach, void,
215: private_thread_t *this)
216: {
217: this->mutex->lock(this->mutex);
218: pthread_detach(this->thread_id);
219: this->detached_or_joined = TRUE;
220: thread_destroy(this);
221: }
222:
223: METHOD(thread_t, join, void*,
224: private_thread_t *this)
225: {
226: pthread_t thread_id;
227: void *val;
228:
229: this->mutex->lock(this->mutex);
230: if (pthread_equal(this->thread_id, pthread_self()))
231: {
232: this->mutex->unlock(this->mutex);
233: DBG1(DBG_LIB, "!!! CANNOT JOIN CURRENT THREAD !!!");
234: return NULL;
235: }
236: if (this->detached_or_joined)
237: {
238: this->mutex->unlock(this->mutex);
239: DBG1(DBG_LIB, "!!! CANNOT JOIN DETACHED THREAD !!!");
240: return NULL;
241: }
242: thread_id = this->thread_id;
243: this->detached_or_joined = TRUE;
244: if (this->terminated)
245: {
246: /* thread has terminated before the call to join */
247: thread_destroy(this);
248: }
249: else
250: {
251: /* thread_destroy is called when the thread terminates normally */
252: this->mutex->unlock(this->mutex);
253: }
254: pthread_join(thread_id, &val);
255:
256: return val;
257: }
258:
259: /**
260: * Create an internal thread object.
261: */
262: static private_thread_t *thread_create_internal()
263: {
264: private_thread_t *this;
265:
266: INIT(this,
267: .public = {
268: .cancel = _cancel,
269: .kill = _kill_,
270: .detach = _detach,
271: .join = _join,
272: },
273: .cleanup_handlers = linked_list_create(),
274: .mutex = mutex_create(MUTEX_TYPE_DEFAULT),
275: );
276:
277: return this;
278: }
279:
280: /**
281: * Remove and run all cleanup handlers in reverse order.
282: */
283: static void thread_cleanup_popall_internal(private_thread_t *this)
284: {
285: cleanup_handler_t *handler;
286:
287: while (this->cleanup_handlers->remove_last(this->cleanup_handlers,
288: (void**)&handler) == SUCCESS)
289: {
290: handler->cleanup(handler->arg);
291: free(handler);
292: }
293: }
294:
295: /**
296: * Main cleanup function for threads.
297: */
298: static void thread_cleanup(private_thread_t *this)
299: {
300: thread_cleanup_popall_internal(this);
301: this->mutex->lock(this->mutex);
302: this->terminated = TRUE;
303: thread_destroy(this);
304: }
305:
306: /**
307: * Main function wrapper for threads.
308: */
309: static void *thread_main(private_thread_t *this)
310: {
311: void *res;
312:
313: this->id = get_thread_id();
314:
315: current_thread->set(current_thread, this);
316: pthread_cleanup_push((thread_cleanup_t)thread_cleanup, this);
317:
318: /* TODO: this is not 100% portable as pthread_t is an opaque type (i.e.
319: * could be of any size, or even a struct) */
320: #ifdef HAVE_GETTID
321: DBG2(DBG_LIB, "created thread %.2d [%u]",
322: this->id, gettid());
323: #elif defined(WIN32)
324: DBG2(DBG_LIB, "created thread %.2d [%p]",
325: this->id, this->thread_id.p);
326: #else
327: DBG2(DBG_LIB, "created thread %.2d [%lx]",
328: this->id, (u_long)this->thread_id);
329: #endif
330:
331: res = this->main(this->arg);
332: pthread_cleanup_pop(TRUE);
333:
334: return res;
335: }
336:
337: /**
338: * Described in header.
339: */
340: thread_t *thread_create(thread_main_t main, void *arg)
341: {
342: private_thread_t *this = thread_create_internal();
343:
344: this->main = main;
345: this->arg = arg;
346:
347: if (pthread_create(&this->thread_id, NULL, (void*)thread_main, this) != 0)
348: {
349: DBG1(DBG_LIB, "failed to create thread!");
350: this->mutex->lock(this->mutex);
351: this->terminated = TRUE;
352: this->detached_or_joined = TRUE;
353: thread_destroy(this);
354: return NULL;
355: }
356:
357: return &this->public;
358: }
359:
360: /**
361: * Described in header.
362: */
363: thread_t *thread_current()
364: {
365: private_thread_t *this;
366:
367: this = (private_thread_t*)current_thread->get(current_thread);
368: if (!this)
369: {
370: this = thread_create_internal();
371: this->id = get_thread_id();
372: current_thread->set(current_thread, (void*)this);
373: }
374: return &this->public;
375: }
376:
377: /**
378: * Described in header.
379: */
380: u_int thread_current_id()
381: {
382: private_thread_t *this = (private_thread_t*)thread_current();
383:
384: return this ? this->id : 0;
385: }
386:
387: /**
388: * Described in header.
389: */
390: void thread_cleanup_push(thread_cleanup_t cleanup, void *arg)
391: {
392: private_thread_t *this = (private_thread_t*)thread_current();
393: cleanup_handler_t *handler;
394:
395: INIT(handler,
396: .cleanup = cleanup,
397: .arg = arg,
398: );
399:
400: this->cleanup_handlers->insert_last(this->cleanup_handlers, handler);
401: }
402:
403: /**
404: * Described in header.
405: */
406: void thread_cleanup_pop(bool execute)
407: {
408: private_thread_t *this = (private_thread_t*)thread_current();
409: cleanup_handler_t *handler;
410:
411: if (this->cleanup_handlers->remove_last(this->cleanup_handlers,
412: (void**)&handler) != SUCCESS)
413: {
414: DBG1(DBG_LIB, "!!! THREAD CLEANUP ERROR !!!");
415: return;
416: }
417:
418: if (execute)
419: {
420: handler->cleanup(handler->arg);
421: }
422: free(handler);
423: }
424:
425: /**
426: * Described in header.
427: */
428: void thread_cleanup_popall()
429: {
430: private_thread_t *this = (private_thread_t*)thread_current();
431:
432: thread_cleanup_popall_internal(this);
433: }
434:
435: /**
436: * Described in header.
437: */
438: bool thread_cancelability(bool enable)
439: {
440: #ifdef HAVE_PTHREAD_CANCEL
441: int old;
442:
443: pthread_setcancelstate(enable ? PTHREAD_CANCEL_ENABLE
444: : PTHREAD_CANCEL_DISABLE, &old);
445:
446: return old == PTHREAD_CANCEL_ENABLE;
447: #else
448: sigset_t new, old;
449:
450: sigemptyset(&new);
451: sigaddset(&new, SIG_CANCEL);
452: pthread_sigmask(enable ? SIG_UNBLOCK : SIG_BLOCK, &new, &old);
453:
454: return sigismember(&old, SIG_CANCEL) == 0;
455: #endif /* HAVE_PTHREAD_CANCEL */
456: }
457:
458: /**
459: * Described in header.
460: */
461: void thread_cancellation_point()
462: {
463: bool old = thread_cancelability(TRUE);
464:
465: #ifdef HAVE_PTHREAD_CANCEL
466: pthread_testcancel();
467: #endif /* HAVE_PTHREAD_CANCEL */
468: thread_cancelability(old);
469: }
470:
471: /**
472: * Described in header.
473: */
474: void thread_exit(void *val)
475: {
476: pthread_exit(val);
477: }
478:
479: /**
480: * A dummy thread value that reserved pthread_key_t value "0". A buggy PKCS#11
481: * library mangles this key, without owning it, so we allocate it for them.
482: */
483: static thread_value_t *dummy1;
484:
485: /**
486: * Described in header.
487: */
488: void threads_init()
489: {
490: private_thread_t *main_thread = thread_create_internal();
491:
492: dummy1 = thread_value_create(NULL);
493:
494: next_id = 0;
495: main_thread->thread_id = pthread_self();
496: current_thread = thread_value_create(NULL);
497: current_thread->set(current_thread, (void*)main_thread);
498: id_mutex = mutex_create(MUTEX_TYPE_DEFAULT);
499: main_thread->id = get_thread_id();
500:
501: #ifndef HAVE_PTHREAD_CANCEL
502: { /* install a signal handler for our custom SIG_CANCEL */
503: struct sigaction action = {
504: .sa_handler = cancel_signal_handler
505: };
506: sigaction(SIG_CANCEL, &action, NULL);
507: }
508: #endif /* HAVE_PTHREAD_CANCEL */
509: }
510:
511: /**
512: * Described in header.
513: */
514: void threads_deinit()
515: {
516: private_thread_t *main_thread = (private_thread_t*)thread_current();
517:
518: dummy1->destroy(dummy1);
519:
520: main_thread->mutex->lock(main_thread->mutex);
521: main_thread->terminated = TRUE;
522: main_thread->detached_or_joined = TRUE;
523: thread_destroy(main_thread);
524: current_thread->destroy(current_thread);
525: id_mutex->destroy(id_mutex);
526: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to thread.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / threading