blob: 98fd2c23f2e8b676030ff5f1a28e585e55f31e00 [file] [log] [blame]
Daniel Veillardb8478642001-10-12 17:29:10 +00001/**
Daniel Veillarddee23482008-04-11 12:58:43 +00002 * threads.c: set of generic threading related routines
Daniel Veillardb8478642001-10-12 17:29:10 +00003 *
4 * See Copyright for the status of this software.
5 *
6 * Gary Pennington <Gary.Pennington@uk.sun.com>
7 * daniel@veillard.com
8 */
9
Daniel Veillard34ce8be2002-03-18 19:37:11 +000010#define IN_LIBXML
Daniel Veillardb8478642001-10-12 17:29:10 +000011#include "libxml.h"
12
13#include <string.h>
14
15#include <libxml/threads.h>
16#include <libxml/globals.h>
17
18#ifdef HAVE_SYS_TYPES_H
19#include <sys/types.h>
20#endif
21#ifdef HAVE_UNISTD_H
22#include <unistd.h>
23#endif
24#ifdef HAVE_STDLIB_H
25#include <stdlib.h>
26#endif
27#ifdef HAVE_PTHREAD_H
28#include <pthread.h>
Eric Zurcher243b0342009-10-01 00:13:07 +020029#elif defined HAVE_WIN32_THREADS
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +000030#include <windows.h>
Igor Zlatkovicf2160a02002-10-31 15:58:42 +000031#ifndef HAVE_COMPILER_TLS
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +000032#include <process.h>
33#endif
34#endif
Daniel Veillardb8478642001-10-12 17:29:10 +000035
Daniel Veillard82cb3192003-10-29 13:39:15 +000036#ifdef HAVE_BEOS_THREADS
37#include <OS.h>
38#include <TLS.h>
39#endif
40
Daniel Veillardb8478642001-10-12 17:29:10 +000041#if defined(SOLARIS)
42#include <note.h>
43#endif
44
Daniel Veillard6f350292001-10-14 09:56:15 +000045/* #define DEBUG_THREADS */
Daniel Veillardb8478642001-10-12 17:29:10 +000046
Daniel Veillarddbfe05a2005-05-04 09:18:00 +000047#ifdef HAVE_PTHREAD_H
48
49static int libxml_is_threaded = -1;
50#ifdef __GNUC__
51#ifdef linux
52#if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || (__GNUC__ > 3)
53extern int pthread_once (pthread_once_t *__once_control,
54 void (*__init_routine) (void))
55 __attribute((weak));
56extern void *pthread_getspecific (pthread_key_t __key)
57 __attribute((weak));
58extern int pthread_setspecific (pthread_key_t __key,
59 __const void *__pointer)
60 __attribute((weak));
61extern int pthread_key_create (pthread_key_t *__key,
62 void (*__destr_function) (void *))
63 __attribute((weak));
Daniel Veillardd4a3f242009-01-18 15:41:30 +000064extern int pthread_key_delete (pthread_key_t __key)
65 __attribute((weak));
Daniel Veillarddbfe05a2005-05-04 09:18:00 +000066extern int pthread_mutex_init ()
67 __attribute((weak));
68extern int pthread_mutex_destroy ()
69 __attribute((weak));
70extern int pthread_mutex_lock ()
71 __attribute((weak));
72extern int pthread_mutex_unlock ()
73 __attribute((weak));
74extern int pthread_cond_init ()
75 __attribute((weak));
Daniel Veillard2cba4152008-08-27 11:45:41 +000076extern int pthread_cond_destroy ()
77 __attribute((weak));
78extern int pthread_cond_wait ()
79 __attribute((weak));
Daniel Veillarddbfe05a2005-05-04 09:18:00 +000080extern int pthread_equal ()
81 __attribute((weak));
82extern pthread_t pthread_self ()
83 __attribute((weak));
84extern int pthread_key_create ()
85 __attribute((weak));
Daniel Veillardd4a3f242009-01-18 15:41:30 +000086extern int pthread_key_delete ()
87 __attribute((weak));
Daniel Veillarddbfe05a2005-05-04 09:18:00 +000088extern int pthread_cond_signal ()
89 __attribute((weak));
90#endif
91#endif /* linux */
92#endif /* __GNUC__ */
93#endif /* HAVE_PTHREAD_H */
94
Daniel Veillardb8478642001-10-12 17:29:10 +000095/*
96 * TODO: this module still uses malloc/free and not xmlMalloc/xmlFree
97 * to avoid some crazyness since xmlMalloc/xmlFree may actually
98 * be hosted on allocated blocks needing them for the allocation ...
99 */
100
101/*
102 * xmlMutex are a simple mutual exception locks
103 */
104struct _xmlMutex {
105#ifdef HAVE_PTHREAD_H
106 pthread_mutex_t lock;
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000107#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000108 HANDLE mutex;
Daniel Veillard82cb3192003-10-29 13:39:15 +0000109#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000110 sem_id sem;
111 thread_id tid;
Daniel Veillardb8478642001-10-12 17:29:10 +0000112#else
113 int empty;
114#endif
115};
116
117/*
118 * xmlRMutex are reentrant mutual exception locks
119 */
120struct _xmlRMutex {
121#ifdef HAVE_PTHREAD_H
122 pthread_mutex_t lock;
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000123 unsigned int held;
124 unsigned int waiters;
125 pthread_t tid;
126 pthread_cond_t cv;
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000127#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000128 CRITICAL_SECTION cs;
129 unsigned int count;
Daniel Veillard82cb3192003-10-29 13:39:15 +0000130#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000131 xmlMutexPtr lock;
132 thread_id tid;
133 int32 count;
Daniel Veillardb8478642001-10-12 17:29:10 +0000134#else
135 int empty;
136#endif
137};
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000138
Daniel Veillardb8478642001-10-12 17:29:10 +0000139/*
140 * This module still has some internal static data.
141 * - xmlLibraryLock a global lock
142 * - globalkey used for per-thread data
Daniel Veillardb8478642001-10-12 17:29:10 +0000143 */
Daniel Veillard6f350292001-10-14 09:56:15 +0000144
Daniel Veillardb8478642001-10-12 17:29:10 +0000145#ifdef HAVE_PTHREAD_H
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000146static pthread_key_t globalkey;
147static pthread_t mainthread;
Daniel Veillarde28313b2001-12-06 14:08:31 +0000148static pthread_once_t once_control = PTHREAD_ONCE_INIT;
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000149static pthread_mutex_t global_init_lock = PTHREAD_MUTEX_INITIALIZER;
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000150#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000151#if defined(HAVE_COMPILER_TLS)
152static __declspec(thread) xmlGlobalState tlstate;
153static __declspec(thread) int tlstate_inited = 0;
154#else /* HAVE_COMPILER_TLS */
Igor Zlatkovicd58a42d2003-05-17 10:55:15 +0000155static DWORD globalkey = TLS_OUT_OF_INDEXES;
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000156#endif /* HAVE_COMPILER_TLS */
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000157static DWORD mainthread;
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000158static struct {
Daniel Veillard36616dd2005-02-25 07:31:49 +0000159 DWORD done;
160 DWORD control;
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000161} run_once = { 0, 0};
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000162static volatile LPCRITICAL_SECTION global_init_lock = NULL;
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000163
Daniel Veillard82cb3192003-10-29 13:39:15 +0000164/* endif HAVE_WIN32_THREADS */
165#elif defined HAVE_BEOS_THREADS
166int32 globalkey = 0;
167thread_id mainthread = 0;
168int32 run_once_init = 0;
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000169static int32 global_init_lock = -1;
170static vint32 global_init_count = 0;
Daniel Veillard82cb3192003-10-29 13:39:15 +0000171#endif
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000172
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000173static xmlRMutexPtr xmlLibraryLock = NULL;
174
Daniel Veillarda9cce9c2003-09-29 13:20:24 +0000175#ifdef LIBXML_THREAD_ENABLED
Daniel Veillarde28313b2001-12-06 14:08:31 +0000176static void xmlOnceInit(void);
Daniel Veillarda9cce9c2003-09-29 13:20:24 +0000177#endif
Daniel Veillardb8478642001-10-12 17:29:10 +0000178
179/**
Daniel Veillard01c13b52002-12-10 15:19:08 +0000180 * xmlNewMutex:
Daniel Veillardb8478642001-10-12 17:29:10 +0000181 *
182 * xmlNewMutex() is used to allocate a libxml2 token struct for use in
183 * synchronizing access to data.
184 *
185 * Returns a new simple mutex pointer or NULL in case of error
186 */
187xmlMutexPtr
188xmlNewMutex(void)
189{
190 xmlMutexPtr tok;
191
192 if ((tok = malloc(sizeof(xmlMutex))) == NULL)
193 return (NULL);
194#ifdef HAVE_PTHREAD_H
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000195 if (libxml_is_threaded != 0)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000196 pthread_mutex_init(&tok->lock, NULL);
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000197#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000198 tok->mutex = CreateMutex(NULL, FALSE, NULL);
Daniel Veillard82cb3192003-10-29 13:39:15 +0000199#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000200 if ((tok->sem = create_sem(1, "xmlMutex")) < B_OK) {
201 free(tok);
202 return NULL;
203 }
204 tok->tid = -1;
Daniel Veillardb8478642001-10-12 17:29:10 +0000205#endif
206 return (tok);
207}
208
209/**
210 * xmlFreeMutex:
211 * @tok: the simple mutex
212 *
213 * xmlFreeMutex() is used to reclaim resources associated with a libxml2 token
214 * struct.
215 */
216void
217xmlFreeMutex(xmlMutexPtr tok)
218{
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000219 if (tok == NULL)
220 return;
Daniel Veillarddf101d82003-07-08 14:03:36 +0000221
Daniel Veillardb8478642001-10-12 17:29:10 +0000222#ifdef HAVE_PTHREAD_H
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000223 if (libxml_is_threaded != 0)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000224 pthread_mutex_destroy(&tok->lock);
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000225#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000226 CloseHandle(tok->mutex);
Daniel Veillard82cb3192003-10-29 13:39:15 +0000227#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000228 delete_sem(tok->sem);
Daniel Veillardb8478642001-10-12 17:29:10 +0000229#endif
230 free(tok);
231}
232
233/**
234 * xmlMutexLock:
235 * @tok: the simple mutex
236 *
237 * xmlMutexLock() is used to lock a libxml2 token.
238 */
239void
Daniel Veillard70bcb0e2003-08-08 14:00:28 +0000240xmlMutexLock(xmlMutexPtr tok)
Daniel Veillardb8478642001-10-12 17:29:10 +0000241{
Daniel Veillard70bcb0e2003-08-08 14:00:28 +0000242 if (tok == NULL)
243 return;
Daniel Veillardb8478642001-10-12 17:29:10 +0000244#ifdef HAVE_PTHREAD_H
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000245 if (libxml_is_threaded != 0)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000246 pthread_mutex_lock(&tok->lock);
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000247#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000248 WaitForSingleObject(tok->mutex, INFINITE);
Daniel Veillard82cb3192003-10-29 13:39:15 +0000249#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000250 if (acquire_sem(tok->sem) != B_NO_ERROR) {
Daniel Veillard82cb3192003-10-29 13:39:15 +0000251#ifdef DEBUG_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000252 xmlGenericError(xmlGenericErrorContext,
253 "xmlMutexLock():BeOS:Couldn't aquire semaphore\n");
254 exit();
Daniel Veillard82cb3192003-10-29 13:39:15 +0000255#endif
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000256 }
257 tok->tid = find_thread(NULL);
Daniel Veillardb8478642001-10-12 17:29:10 +0000258#endif
259
260}
261
262/**
263 * xmlMutexUnlock:
264 * @tok: the simple mutex
265 *
266 * xmlMutexUnlock() is used to unlock a libxml2 token.
267 */
268void
Daniel Veillard5805be22003-08-28 08:03:23 +0000269xmlMutexUnlock(xmlMutexPtr tok)
Daniel Veillardb8478642001-10-12 17:29:10 +0000270{
Daniel Veillard5805be22003-08-28 08:03:23 +0000271 if (tok == NULL)
272 return;
Daniel Veillardb8478642001-10-12 17:29:10 +0000273#ifdef HAVE_PTHREAD_H
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000274 if (libxml_is_threaded != 0)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000275 pthread_mutex_unlock(&tok->lock);
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000276#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000277 ReleaseMutex(tok->mutex);
Daniel Veillard82cb3192003-10-29 13:39:15 +0000278#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000279 if (tok->tid == find_thread(NULL)) {
280 tok->tid = -1;
281 release_sem(tok->sem);
282 }
Daniel Veillardb8478642001-10-12 17:29:10 +0000283#endif
284}
285
286/**
Daniel Veillard01c13b52002-12-10 15:19:08 +0000287 * xmlNewRMutex:
Daniel Veillardb8478642001-10-12 17:29:10 +0000288 *
289 * xmlRNewMutex() is used to allocate a reentrant mutex for use in
290 * synchronizing access to data. token_r is a re-entrant lock and thus useful
291 * for synchronizing access to data structures that may be manipulated in a
292 * recursive fashion.
293 *
294 * Returns the new reentrant mutex pointer or NULL in case of error
295 */
296xmlRMutexPtr
297xmlNewRMutex(void)
298{
299 xmlRMutexPtr tok;
300
301 if ((tok = malloc(sizeof(xmlRMutex))) == NULL)
302 return (NULL);
303#ifdef HAVE_PTHREAD_H
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000304 if (libxml_is_threaded != 0) {
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000305 pthread_mutex_init(&tok->lock, NULL);
306 tok->held = 0;
307 tok->waiters = 0;
308 pthread_cond_init(&tok->cv, NULL);
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000309 }
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000310#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000311 InitializeCriticalSection(&tok->cs);
312 tok->count = 0;
Daniel Veillard82cb3192003-10-29 13:39:15 +0000313#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000314 if ((tok->lock = xmlNewMutex()) == NULL) {
315 free(tok);
316 return NULL;
317 }
318 tok->count = 0;
Daniel Veillardb8478642001-10-12 17:29:10 +0000319#endif
320 return (tok);
321}
322
323/**
Daniel Veillard01c13b52002-12-10 15:19:08 +0000324 * xmlFreeRMutex:
Daniel Veillardb8478642001-10-12 17:29:10 +0000325 * @tok: the reentrant mutex
326 *
327 * xmlRFreeMutex() is used to reclaim resources associated with a
328 * reentrant mutex.
329 */
330void
Daniel Veillard0ba59232002-02-10 13:20:39 +0000331xmlFreeRMutex(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
Daniel Veillardb8478642001-10-12 17:29:10 +0000332{
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000333 if (tok == NULL)
334 return;
Daniel Veillardb8478642001-10-12 17:29:10 +0000335#ifdef HAVE_PTHREAD_H
Daniel Veillarda8b54132006-06-29 11:50:18 +0000336 if (libxml_is_threaded != 0) {
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000337 pthread_mutex_destroy(&tok->lock);
338 pthread_cond_destroy(&tok->cv);
Daniel Veillarda8b54132006-06-29 11:50:18 +0000339 }
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000340#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000341 DeleteCriticalSection(&tok->cs);
Daniel Veillard82cb3192003-10-29 13:39:15 +0000342#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000343 xmlFreeMutex(tok->lock);
Daniel Veillardb8478642001-10-12 17:29:10 +0000344#endif
345 free(tok);
346}
347
348/**
349 * xmlRMutexLock:
350 * @tok: the reentrant mutex
351 *
352 * xmlRMutexLock() is used to lock a libxml2 token_r.
353 */
354void
Daniel Veillard5f1e1f82003-09-11 23:35:09 +0000355xmlRMutexLock(xmlRMutexPtr tok)
Daniel Veillardb8478642001-10-12 17:29:10 +0000356{
Daniel Veillard5f1e1f82003-09-11 23:35:09 +0000357 if (tok == NULL)
358 return;
Daniel Veillardb8478642001-10-12 17:29:10 +0000359#ifdef HAVE_PTHREAD_H
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000360 if (libxml_is_threaded == 0)
361 return;
362
Daniel Veillardb8478642001-10-12 17:29:10 +0000363 pthread_mutex_lock(&tok->lock);
364 if (tok->held) {
365 if (pthread_equal(tok->tid, pthread_self())) {
366 tok->held++;
367 pthread_mutex_unlock(&tok->lock);
368 return;
369 } else {
370 tok->waiters++;
371 while (tok->held)
372 pthread_cond_wait(&tok->cv, &tok->lock);
373 tok->waiters--;
374 }
375 }
376 tok->tid = pthread_self();
377 tok->held = 1;
378 pthread_mutex_unlock(&tok->lock);
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000379#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000380 EnterCriticalSection(&tok->cs);
381 ++tok->count;
Daniel Veillard82cb3192003-10-29 13:39:15 +0000382#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000383 if (tok->lock->tid == find_thread(NULL)) {
384 tok->count++;
385 return;
386 } else {
387 xmlMutexLock(tok->lock);
388 tok->count = 1;
389 }
Daniel Veillardb8478642001-10-12 17:29:10 +0000390#endif
391}
392
393/**
394 * xmlRMutexUnlock:
395 * @tok: the reentrant mutex
396 *
397 * xmlRMutexUnlock() is used to unlock a libxml2 token_r.
398 */
399void
Daniel Veillard0ba59232002-02-10 13:20:39 +0000400xmlRMutexUnlock(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
Daniel Veillardb8478642001-10-12 17:29:10 +0000401{
Daniel Veillard5f1e1f82003-09-11 23:35:09 +0000402 if (tok == NULL)
403 return;
Daniel Veillardb8478642001-10-12 17:29:10 +0000404#ifdef HAVE_PTHREAD_H
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000405 if (libxml_is_threaded == 0)
406 return;
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000407
Daniel Veillardb8478642001-10-12 17:29:10 +0000408 pthread_mutex_lock(&tok->lock);
409 tok->held--;
410 if (tok->held == 0) {
411 if (tok->waiters)
412 pthread_cond_signal(&tok->cv);
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200413 memset(&tok->tid, 0, sizeof(tok->tid));
Daniel Veillardb8478642001-10-12 17:29:10 +0000414 }
415 pthread_mutex_unlock(&tok->lock);
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000416#elif defined HAVE_WIN32_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000417 if (!--tok->count)
418 LeaveCriticalSection(&tok->cs);
Daniel Veillard82cb3192003-10-29 13:39:15 +0000419#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000420 if (tok->lock->tid == find_thread(NULL)) {
421 tok->count--;
422 if (tok->count == 0) {
423 xmlMutexUnlock(tok->lock);
424 }
425 return;
426 }
Daniel Veillardb8478642001-10-12 17:29:10 +0000427#endif
428}
429
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000430/**
431 * xmlGlobalInitMutexLock
432 *
433 * Makes sure that the global initialization mutex is initialized and
434 * locks it.
435 */
436void
437__xmlGlobalInitMutexLock(void)
438{
439 /* Make sure the global init lock is initialized and then lock it. */
440#ifdef HAVE_PTHREAD_H
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000441 /* The mutex is statically initialized, so we just lock it. */
442 pthread_mutex_lock(&global_init_lock);
443#elif defined HAVE_WIN32_THREADS
444 LPCRITICAL_SECTION cs;
445
446 /* Create a new critical section */
447 if (global_init_lock == NULL) {
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000448 cs = malloc(sizeof(CRITICAL_SECTION));
449 if (cs == NULL) {
450 xmlGenericError(xmlGenericErrorContext,
451 "xmlGlobalInitMutexLock: out of memory\n");
452 return;
453 }
454 InitializeCriticalSection(cs);
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000455
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000456 /* Swap it into the global_init_lock */
Rob Richardse967f0b2007-06-08 19:36:04 +0000457#ifdef InterlockedCompareExchangePointer
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000458 InterlockedCompareExchangePointer(&global_init_lock, cs, NULL);
459#else /* Use older void* version */
460 InterlockedCompareExchange((void **) &global_init_lock,
461 (void *) cs, NULL);
Rob Richardse967f0b2007-06-08 19:36:04 +0000462#endif /* InterlockedCompareExchangePointer */
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000463
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000464 /* If another thread successfully recorded its critical
465 * section in the global_init_lock then discard the one
466 * allocated by this thread. */
467 if (global_init_lock != cs) {
468 DeleteCriticalSection(cs);
469 free(cs);
470 }
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000471 }
472
473 /* Lock the chosen critical section */
474 EnterCriticalSection(global_init_lock);
475#elif defined HAVE_BEOS_THREADS
476 int32 sem;
477
478 /* Allocate a new semaphore */
479 sem = create_sem(1, "xmlGlobalinitMutex");
480
481 while (global_init_lock == -1) {
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000482 if (atomic_add(&global_init_count, 1) == 0) {
483 global_init_lock = sem;
484 } else {
485 snooze(1);
486 atomic_add(&global_init_count, -1);
487 }
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000488 }
489
490 /* If another thread successfully recorded its critical
491 * section in the global_init_lock then discard the one
492 * allocated by this thread. */
493 if (global_init_lock != sem)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000494 delete_sem(sem);
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000495
496 /* Acquire the chosen semaphore */
497 if (acquire_sem(global_init_lock) != B_NO_ERROR) {
498#ifdef DEBUG_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000499 xmlGenericError(xmlGenericErrorContext,
500 "xmlGlobalInitMutexLock():BeOS:Couldn't acquire semaphore\n");
501 exit();
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000502#endif
503 }
504#endif
505}
506
507void
508__xmlGlobalInitMutexUnlock(void)
509{
510#ifdef HAVE_PTHREAD_H
511 pthread_mutex_unlock(&global_init_lock);
512#elif defined HAVE_WIN32_THREADS
Daniel Veillard14d465d2008-03-24 11:12:55 +0000513 if (global_init_lock != NULL) {
514 LeaveCriticalSection(global_init_lock);
515 }
Daniel Veillardfde5b0b2007-02-12 17:31:53 +0000516#elif defined HAVE_BEOS_THREADS
517 release_sem(global_init_lock);
518#endif
519}
520
Rob Richards91eb5602007-11-16 10:54:59 +0000521/**
522 * xmlGlobalInitMutexDestroy
523 *
524 * Makes sure that the global initialization mutex is destroyed before
525 * application termination.
526 */
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000527void
528__xmlGlobalInitMutexDestroy(void)
Rob Richards91eb5602007-11-16 10:54:59 +0000529{
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200530#ifdef HAVE_PTHREAD_H
531#elif defined HAVE_WIN32_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000532 if (global_init_lock != NULL) {
533 DeleteCriticalSection(global_init_lock);
534 free(global_init_lock);
535 global_init_lock = NULL;
Rob Richards91eb5602007-11-16 10:54:59 +0000536 }
537#endif
538}
539
Daniel Veillardb8478642001-10-12 17:29:10 +0000540/************************************************************************
541 * *
542 * Per thread global state handling *
543 * *
544 ************************************************************************/
545
Daniel Veillard8bdb91d2001-10-31 17:52:43 +0000546#ifdef LIBXML_THREAD_ENABLED
Daniel Veillard01c3bd52004-10-22 13:16:10 +0000547#ifdef xmlLastError
548#undef xmlLastError
549#endif
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000550
Daniel Veillardb8478642001-10-12 17:29:10 +0000551/**
552 * xmlFreeGlobalState:
553 * @state: a thread global state
554 *
555 * xmlFreeGlobalState() is called when a thread terminates with a non-NULL
556 * global state. It is is used here to reclaim memory resources.
557 */
558static void
559xmlFreeGlobalState(void *state)
560{
Daniel Veillard01c3bd52004-10-22 13:16:10 +0000561 xmlGlobalState *gs = (xmlGlobalState *) state;
562
563 /* free any memory allocated in the thread's xmlLastError */
564 xmlResetError(&(gs->xmlLastError));
Daniel Veillardb8478642001-10-12 17:29:10 +0000565 free(state);
566}
567
568/**
569 * xmlNewGlobalState:
570 *
571 * xmlNewGlobalState() allocates a global state. This structure is used to
572 * hold all data for use by a thread when supporting backwards compatibility
Daniel Veillardcbaf3992001-12-31 16:16:02 +0000573 * of libxml2 to pre-thread-safe behaviour.
Daniel Veillardb8478642001-10-12 17:29:10 +0000574 *
575 * Returns the newly allocated xmlGlobalStatePtr or NULL in case of error
576 */
577static xmlGlobalStatePtr
578xmlNewGlobalState(void)
579{
580 xmlGlobalState *gs;
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000581
Daniel Veillardb8478642001-10-12 17:29:10 +0000582 gs = malloc(sizeof(xmlGlobalState));
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000583 if (gs == NULL) {
584 xmlGenericError(xmlGenericErrorContext,
585 "xmlGetGlobalState: out of memory\n");
586 return (NULL);
587 }
Daniel Veillardb8478642001-10-12 17:29:10 +0000588
William M. Brack8b2c7f12002-11-22 05:07:29 +0000589 memset(gs, 0, sizeof(xmlGlobalState));
Daniel Veillardb8478642001-10-12 17:29:10 +0000590 xmlInitializeGlobalState(gs);
591 return (gs);
592}
Daniel Veillard8bdb91d2001-10-31 17:52:43 +0000593#endif /* LIBXML_THREAD_ENABLED */
Daniel Veillardb8478642001-10-12 17:29:10 +0000594
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200595#ifdef HAVE_PTHREAD_H
Eric Zurcher243b0342009-10-01 00:13:07 +0200596#elif defined HAVE_WIN32_THREADS
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000597#if !defined(HAVE_COMPILER_TLS)
598#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000599typedef struct _xmlGlobalStateCleanupHelperParams {
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000600 HANDLE thread;
601 void *memory;
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000602} xmlGlobalStateCleanupHelperParams;
603
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000604static void XMLCDECL
605xmlGlobalStateCleanupHelper(void *p)
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000606{
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000607 xmlGlobalStateCleanupHelperParams *params =
608 (xmlGlobalStateCleanupHelperParams *) p;
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000609 WaitForSingleObject(params->thread, INFINITE);
610 CloseHandle(params->thread);
611 xmlFreeGlobalState(params->memory);
612 free(params);
613 _endthread();
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000614}
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000615#else /* LIBXML_STATIC && !LIBXML_STATIC_FOR_DLL */
616
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000617typedef struct _xmlGlobalStateCleanupHelperParams {
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000618 void *memory;
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000619 struct _xmlGlobalStateCleanupHelperParams *prev;
620 struct _xmlGlobalStateCleanupHelperParams *next;
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000621} xmlGlobalStateCleanupHelperParams;
622
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000623static xmlGlobalStateCleanupHelperParams *cleanup_helpers_head = NULL;
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000624static CRITICAL_SECTION cleanup_helpers_cs;
625
626#endif /* LIBXMLSTATIC && !LIBXML_STATIC_FOR_DLL */
627#endif /* HAVE_COMPILER_TLS */
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000628#endif /* HAVE_WIN32_THREADS */
629
Daniel Veillard82cb3192003-10-29 13:39:15 +0000630#if defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000631
William M. Brackb1d53162003-11-18 06:54:40 +0000632/**
633 * xmlGlobalStateCleanup:
634 * @data: unused parameter
635 *
636 * Used for Beos only
637 */
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000638void
639xmlGlobalStateCleanup(void *data)
Daniel Veillard82cb3192003-10-29 13:39:15 +0000640{
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000641 void *globalval = tls_get(globalkey);
642
643 if (globalval != NULL)
644 xmlFreeGlobalState(globalval);
Daniel Veillard82cb3192003-10-29 13:39:15 +0000645}
646#endif
647
Daniel Veillard01c13b52002-12-10 15:19:08 +0000648/**
649 * xmlGetGlobalState:
650 *
651 * xmlGetGlobalState() is called to retrieve the global state for a thread.
652 *
653 * Returns the thread global state or NULL in case of error
654 */
Daniel Veillardb8478642001-10-12 17:29:10 +0000655xmlGlobalStatePtr
656xmlGetGlobalState(void)
657{
658#ifdef HAVE_PTHREAD_H
659 xmlGlobalState *globalval;
660
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000661 if (libxml_is_threaded == 0)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000662 return (NULL);
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000663
Daniel Veillarde28313b2001-12-06 14:08:31 +0000664 pthread_once(&once_control, xmlOnceInit);
665
Daniel Veillardb8478642001-10-12 17:29:10 +0000666 if ((globalval = (xmlGlobalState *)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000667 pthread_getspecific(globalkey)) == NULL) {
Daniel Veillardb8478642001-10-12 17:29:10 +0000668 xmlGlobalState *tsd = xmlNewGlobalState();
Daniel Veillard14d465d2008-03-24 11:12:55 +0000669 if (tsd == NULL)
670 return(NULL);
Daniel Veillardb8478642001-10-12 17:29:10 +0000671
672 pthread_setspecific(globalkey, tsd);
673 return (tsd);
Daniel Veillard6f350292001-10-14 09:56:15 +0000674 }
675 return (globalval);
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000676#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000677#if defined(HAVE_COMPILER_TLS)
678 if (!tlstate_inited) {
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000679 tlstate_inited = 1;
680 xmlInitializeGlobalState(&tlstate);
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000681 }
682 return &tlstate;
683#else /* HAVE_COMPILER_TLS */
684 xmlGlobalState *globalval;
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000685 xmlGlobalStateCleanupHelperParams *p;
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000686
Daniel Veillard62121e22005-02-24 15:38:52 +0000687 xmlOnceInit();
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000688#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000689 globalval = (xmlGlobalState *) TlsGetValue(globalkey);
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000690#else
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000691 p = (xmlGlobalStateCleanupHelperParams *) TlsGetValue(globalkey);
692 globalval = (xmlGlobalState *) (p ? p->memory : NULL);
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000693#endif
694 if (globalval == NULL) {
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000695 xmlGlobalState *tsd = xmlNewGlobalState();
696
697 if (tsd == NULL)
698 return(NULL);
699 p = (xmlGlobalStateCleanupHelperParams *)
700 malloc(sizeof(xmlGlobalStateCleanupHelperParams));
701 if (p == NULL) {
702 xmlGenericError(xmlGenericErrorContext,
703 "xmlGetGlobalState: out of memory\n");
Daniel Veillardbf2ebff2009-01-18 14:57:04 +0000704 xmlFreeGlobalState(tsd);
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000705 return(NULL);
706 }
707 p->memory = tsd;
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000708#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000709 DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
710 GetCurrentProcess(), &p->thread, 0, TRUE,
711 DUPLICATE_SAME_ACCESS);
712 TlsSetValue(globalkey, tsd);
713 _beginthread(xmlGlobalStateCleanupHelper, 0, p);
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000714#else
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000715 EnterCriticalSection(&cleanup_helpers_cs);
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000716 if (cleanup_helpers_head != NULL) {
717 cleanup_helpers_head->prev = p;
718 }
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000719 p->next = cleanup_helpers_head;
720 p->prev = NULL;
721 cleanup_helpers_head = p;
722 TlsSetValue(globalkey, p);
723 LeaveCriticalSection(&cleanup_helpers_cs);
Igor Zlatkovicd58a42d2003-05-17 10:55:15 +0000724#endif
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000725
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000726 return (tsd);
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000727 }
728 return (globalval);
729#endif /* HAVE_COMPILER_TLS */
Daniel Veillard82cb3192003-10-29 13:39:15 +0000730#elif defined HAVE_BEOS_THREADS
731 xmlGlobalState *globalval;
732
733 xmlOnceInit();
734
Daniel Veillard14d465d2008-03-24 11:12:55 +0000735 if ((globalval = (xmlGlobalState *) tls_get(globalkey)) == NULL) {
Daniel Veillard82cb3192003-10-29 13:39:15 +0000736 xmlGlobalState *tsd = xmlNewGlobalState();
Daniel Veillard14d465d2008-03-24 11:12:55 +0000737 if (tsd == NULL)
738 return (NULL);
Daniel Veillard82cb3192003-10-29 13:39:15 +0000739
740 tls_set(globalkey, tsd);
741 on_exit_thread(xmlGlobalStateCleanup, NULL);
742 return (tsd);
743 }
744 return (globalval);
Daniel Veillard6f350292001-10-14 09:56:15 +0000745#else
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000746 return (NULL);
Daniel Veillardb8478642001-10-12 17:29:10 +0000747#endif
748}
749
Daniel Veillardb8478642001-10-12 17:29:10 +0000750/************************************************************************
751 * *
752 * Library wide thread interfaces *
753 * *
754 ************************************************************************/
755
756/**
Daniel Veillard3c01b1d2001-10-17 15:58:35 +0000757 * xmlGetThreadId:
758 *
759 * xmlGetThreadId() find the current thread ID number
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200760 * Note that this is likely to be broken on some platforms using pthreads
761 * as the specification doesn't mandate pthread_t to be an integer type
Daniel Veillard3c01b1d2001-10-17 15:58:35 +0000762 *
763 * Returns the current thread ID number
764 */
765int
766xmlGetThreadId(void)
767{
768#ifdef HAVE_PTHREAD_H
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200769 pthread_t id;
770 int ret;
771
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000772 if (libxml_is_threaded == 0)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000773 return (0);
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200774 id = pthread_self();
775 /* horrible but preserves compat, see warning above */
776 memcpy(&ret, &id, sizeof(ret));
777 return (ret);
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000778#elif defined HAVE_WIN32_THREADS
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000779 return GetCurrentThreadId();
Daniel Veillard82cb3192003-10-29 13:39:15 +0000780#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000781 return find_thread(NULL);
Daniel Veillard3c01b1d2001-10-17 15:58:35 +0000782#else
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000783 return ((int) 0);
Daniel Veillard3c01b1d2001-10-17 15:58:35 +0000784#endif
785}
786
787/**
Daniel Veillard6f350292001-10-14 09:56:15 +0000788 * xmlIsMainThread:
789 *
Daniel Veillardcbaf3992001-12-31 16:16:02 +0000790 * xmlIsMainThread() check whether the current thread is the main thread.
Daniel Veillard6f350292001-10-14 09:56:15 +0000791 *
792 * Returns 1 if the current thread is the main thread, 0 otherwise
793 */
794int
795xmlIsMainThread(void)
796{
Daniel Veillarde28313b2001-12-06 14:08:31 +0000797#ifdef HAVE_PTHREAD_H
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000798 if (libxml_is_threaded == -1)
799 xmlInitThreads();
800 if (libxml_is_threaded == 0)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000801 return (1);
Daniel Veillarde28313b2001-12-06 14:08:31 +0000802 pthread_once(&once_control, xmlOnceInit);
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000803#elif defined HAVE_WIN32_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000804 xmlOnceInit();
Daniel Veillard82cb3192003-10-29 13:39:15 +0000805#elif defined HAVE_BEOS_THREADS
Daniel Veillard62121e22005-02-24 15:38:52 +0000806 xmlOnceInit();
Daniel Veillarde28313b2001-12-06 14:08:31 +0000807#endif
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000808
Daniel Veillard6f350292001-10-14 09:56:15 +0000809#ifdef DEBUG_THREADS
810 xmlGenericError(xmlGenericErrorContext, "xmlIsMainThread()\n");
811#endif
812#ifdef HAVE_PTHREAD_H
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200813 return (pthread_equal(mainthread,pthread_self()));
Daniel Veillarddb0eb8d2002-01-13 13:35:00 +0000814#elif defined HAVE_WIN32_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000815 return (mainthread == GetCurrentThreadId());
Daniel Veillard82cb3192003-10-29 13:39:15 +0000816#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000817 return (mainthread == find_thread(NULL));
Daniel Veillard6f350292001-10-14 09:56:15 +0000818#else
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000819 return (1);
Daniel Veillard6f350292001-10-14 09:56:15 +0000820#endif
821}
822
823/**
Daniel Veillardb8478642001-10-12 17:29:10 +0000824 * xmlLockLibrary:
825 *
826 * xmlLockLibrary() is used to take out a re-entrant lock on the libxml2
827 * library.
828 */
829void
830xmlLockLibrary(void)
831{
Daniel Veillard6f350292001-10-14 09:56:15 +0000832#ifdef DEBUG_THREADS
833 xmlGenericError(xmlGenericErrorContext, "xmlLockLibrary()\n");
834#endif
Daniel Veillardb8478642001-10-12 17:29:10 +0000835 xmlRMutexLock(xmlLibraryLock);
836}
837
838/**
839 * xmlUnlockLibrary:
840 *
841 * xmlUnlockLibrary() is used to release a re-entrant lock on the libxml2
842 * library.
843 */
844void
845xmlUnlockLibrary(void)
846{
Daniel Veillard6f350292001-10-14 09:56:15 +0000847#ifdef DEBUG_THREADS
848 xmlGenericError(xmlGenericErrorContext, "xmlUnlockLibrary()\n");
849#endif
Daniel Veillardb8478642001-10-12 17:29:10 +0000850 xmlRMutexUnlock(xmlLibraryLock);
851}
852
853/**
854 * xmlInitThreads:
855 *
856 * xmlInitThreads() is used to to initialize all the thread related
857 * data of the libxml2 library.
858 */
859void
860xmlInitThreads(void)
861{
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000862#ifdef HAVE_PTHREAD_H
863 if (libxml_is_threaded == -1) {
864 if ((pthread_once != NULL) &&
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000865 (pthread_getspecific != NULL) &&
866 (pthread_setspecific != NULL) &&
867 (pthread_key_create != NULL) &&
Daniel Veillardd4a3f242009-01-18 15:41:30 +0000868 (pthread_key_delete != NULL) &&
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000869 (pthread_mutex_init != NULL) &&
870 (pthread_mutex_destroy != NULL) &&
871 (pthread_mutex_lock != NULL) &&
872 (pthread_mutex_unlock != NULL) &&
873 (pthread_cond_init != NULL) &&
Daniel Veillard2cba4152008-08-27 11:45:41 +0000874 (pthread_cond_destroy != NULL) &&
875 (pthread_cond_wait != NULL) &&
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000876 (pthread_equal != NULL) &&
877 (pthread_self != NULL) &&
878 (pthread_cond_signal != NULL)) {
879 libxml_is_threaded = 1;
880
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000881/* fprintf(stderr, "Running multithreaded\n"); */
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000882 } else {
883
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000884/* fprintf(stderr, "Running without multithread\n"); */
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000885 libxml_is_threaded = 0;
886 }
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000887 }
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200888#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
889 InitializeCriticalSection(&cleanup_helpers_cs);
Daniel Veillarddbfe05a2005-05-04 09:18:00 +0000890#endif
Daniel Veillardb8478642001-10-12 17:29:10 +0000891}
892
893/**
894 * xmlCleanupThreads:
895 *
896 * xmlCleanupThreads() is used to to cleanup all the thread related
897 * data of the libxml2 library once processing has ended.
Daniel Veillard01101202009-02-21 09:22:04 +0000898 *
899 * WARNING: if your application is multithreaded or has plugin support
900 * calling this may crash the application if another thread or
901 * a plugin is still using libxml2. It's sometimes very hard to
902 * guess if libxml2 is in use in the application, some libraries
903 * or plugins may use it without notice. In case of doubt abstain
904 * from calling this function or do it just before calling exit()
905 * to avoid leak reports from valgrind !
Daniel Veillardb8478642001-10-12 17:29:10 +0000906 */
907void
908xmlCleanupThreads(void)
909{
Daniel Veillard6f350292001-10-14 09:56:15 +0000910#ifdef DEBUG_THREADS
911 xmlGenericError(xmlGenericErrorContext, "xmlCleanupThreads()\n");
912#endif
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200913#ifdef HAVE_PTHREAD_H
914 if ((libxml_is_threaded) && (pthread_key_delete != NULL))
915 pthread_key_delete(globalkey);
916#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000917 if (globalkey != TLS_OUT_OF_INDEXES) {
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000918 xmlGlobalStateCleanupHelperParams *p;
919
920 EnterCriticalSection(&cleanup_helpers_cs);
921 p = cleanup_helpers_head;
922 while (p != NULL) {
923 xmlGlobalStateCleanupHelperParams *temp = p;
924
925 p = p->next;
926 xmlFreeGlobalState(temp->memory);
927 free(temp);
928 }
929 cleanup_helpers_head = 0;
930 LeaveCriticalSection(&cleanup_helpers_cs);
931 TlsFree(globalkey);
932 globalkey = TLS_OUT_OF_INDEXES;
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000933 }
934 DeleteCriticalSection(&cleanup_helpers_cs);
935#endif
Daniel Veillarde28313b2001-12-06 14:08:31 +0000936}
Daniel Veillard6f350292001-10-14 09:56:15 +0000937
Daniel Veillarda9cce9c2003-09-29 13:20:24 +0000938#ifdef LIBXML_THREAD_ENABLED
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000939
Daniel Veillarde28313b2001-12-06 14:08:31 +0000940/**
941 * xmlOnceInit
942 *
943 * xmlOnceInit() is used to initialize the value of mainthread for use
944 * in other routines. This function should only be called using
945 * pthread_once() in association with the once_control variable to ensure
946 * that the function is only called once. See man pthread_once for more
947 * details.
948 */
949static void
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000950xmlOnceInit(void)
951{
Daniel Veillarde28313b2001-12-06 14:08:31 +0000952#ifdef HAVE_PTHREAD_H
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000953 (void) pthread_key_create(&globalkey, xmlFreeGlobalState);
Daniel Veillarde28313b2001-12-06 14:08:31 +0000954 mainthread = pthread_self();
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200955#elif defined(HAVE_WIN32_THREADS)
Daniel Veillard62121e22005-02-24 15:38:52 +0000956 if (!run_once.done) {
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000957 if (InterlockedIncrement(&run_once.control) == 1) {
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000958#if !defined(HAVE_COMPILER_TLS)
Daniel Veillard62121e22005-02-24 15:38:52 +0000959 globalkey = TlsAlloc();
Igor Zlatkovicf2160a02002-10-31 15:58:42 +0000960#endif
Daniel Veillard62121e22005-02-24 15:38:52 +0000961 mainthread = GetCurrentThreadId();
962 run_once.done = 1;
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000963 } else {
Daniel Veillard62121e22005-02-24 15:38:52 +0000964 /* Another thread is working; give up our slice and
965 * wait until they're done. */
966 while (!run_once.done)
967 Sleep(0);
968 }
969 }
Eric Zurcher243b0342009-10-01 00:13:07 +0200970#elif defined HAVE_BEOS_THREADS
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000971 if (atomic_add(&run_once_init, 1) == 0) {
972 globalkey = tls_allocate();
973 tls_set(globalkey, NULL);
974 mainthread = find_thread(NULL);
975 } else
976 atomic_add(&run_once_init, -1);
Daniel Veillard82cb3192003-10-29 13:39:15 +0000977#endif
Daniel Veillardb8478642001-10-12 17:29:10 +0000978}
Daniel Veillarda9cce9c2003-09-29 13:20:24 +0000979#endif
Igor Zlatkovicd58a42d2003-05-17 10:55:15 +0000980
981/**
William M. Brack7a821652003-08-15 07:27:40 +0000982 * DllMain:
983 * @hinstDLL: handle to DLL instance
984 * @fdwReason: Reason code for entry
985 * @lpvReserved: generic pointer (depends upon reason code)
Igor Zlatkovicd58a42d2003-05-17 10:55:15 +0000986 *
987 * Entry point for Windows library. It is being used to free thread-specific
988 * storage.
William M. Brack7a821652003-08-15 07:27:40 +0000989 *
990 * Returns TRUE always
Igor Zlatkovicd58a42d2003-05-17 10:55:15 +0000991 */
Daniel Veillardd87c5d12009-09-10 17:46:07 +0200992#ifdef HAVE_PTHREAD_H
993#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000994#if defined(LIBXML_STATIC_FOR_DLL)
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000995BOOL XMLCALL
996xmlDllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
Daniel Veillardd96f6d32003-10-07 21:25:12 +0000997#else
Daniel Veillardddbe38b2008-03-18 08:24:25 +0000998BOOL WINAPI
999DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
Daniel Veillardd96f6d32003-10-07 21:25:12 +00001000#endif
Igor Zlatkovicd58a42d2003-05-17 10:55:15 +00001001{
Daniel Veillardddbe38b2008-03-18 08:24:25 +00001002 switch (fdwReason) {
1003 case DLL_THREAD_DETACH:
1004 if (globalkey != TLS_OUT_OF_INDEXES) {
1005 xmlGlobalState *globalval = NULL;
1006 xmlGlobalStateCleanupHelperParams *p =
1007 (xmlGlobalStateCleanupHelperParams *)
1008 TlsGetValue(globalkey);
1009 globalval = (xmlGlobalState *) (p ? p->memory : NULL);
1010 if (globalval) {
1011 xmlFreeGlobalState(globalval);
1012 TlsSetValue(globalkey, NULL);
1013 }
1014 if (p) {
1015 EnterCriticalSection(&cleanup_helpers_cs);
1016 if (p == cleanup_helpers_head)
1017 cleanup_helpers_head = p->next;
1018 else
1019 p->prev->next = p->next;
1020 if (p->next != NULL)
1021 p->next->prev = p->prev;
1022 LeaveCriticalSection(&cleanup_helpers_cs);
1023 free(p);
1024 }
Daniel Veillardd96f6d32003-10-07 21:25:12 +00001025 }
Daniel Veillardddbe38b2008-03-18 08:24:25 +00001026 break;
Igor Zlatkovicd58a42d2003-05-17 10:55:15 +00001027 }
1028 return TRUE;
1029}
1030#endif
Daniel Veillard5d4644e2005-04-01 13:11:58 +00001031#define bottom_threads
1032#include "elfgcchack.h"