VirtualBox

source: vbox/trunk/src/libs/libxml2-2.6.31/threads.c@ 39954

Last change on this file since 39954 was 39915, checked in by vboxsync, 13 years ago

libxml-2.6.31 unmodified
  • Property svn:eol-style set to native
File size: 23.2 KB
Line 
1/**
2 * threads.c: set of generic threading related routines
3 *
4 * See Copyright for the status of this software.
5 *
6 * Gary Pennington <[email protected]>
7 * [email protected]
8 */
9
10#define IN_LIBXML
11#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>
29#endif
30
31#ifdef HAVE_WIN32_THREADS
32#include <windows.h>
33#ifndef HAVE_COMPILER_TLS
34#include <process.h>
35#endif
36#endif
37
38#ifdef HAVE_BEOS_THREADS
39#include <OS.h>
40#include <TLS.h>
41#endif
42
43#if defined(SOLARIS)
44#include <note.h>
45#endif
46
47/* #define DEBUG_THREADS */
48
49#ifdef HAVE_PTHREAD_H
50
51static int libxml_is_threaded = -1;
52#ifdef __GNUC__
53#ifdef linux
54#if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || (__GNUC__ > 3)
55extern int pthread_once (pthread_once_t *__once_control,
56 void (*__init_routine) (void))
57 __attribute((weak));
58extern void *pthread_getspecific (pthread_key_t __key)
59 __attribute((weak));
60extern int pthread_setspecific (pthread_key_t __key,
61 __const void *__pointer)
62 __attribute((weak));
63extern int pthread_key_create (pthread_key_t *__key,
64 void (*__destr_function) (void *))
65 __attribute((weak));
66extern 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));
76extern int pthread_equal ()
77 __attribute((weak));
78extern pthread_t pthread_self ()
79 __attribute((weak));
80extern int pthread_key_create ()
81 __attribute((weak));
82extern int pthread_cond_signal ()
83 __attribute((weak));
84#endif
85#endif /* linux */
86#endif /* __GNUC__ */
87#endif /* HAVE_PTHREAD_H */
88
89/*
90 * TODO: this module still uses malloc/free and not xmlMalloc/xmlFree
91 * to avoid some crazyness since xmlMalloc/xmlFree may actually
92 * be hosted on allocated blocks needing them for the allocation ...
93 */
94
95/*
96 * xmlMutex are a simple mutual exception locks
97 */
98struct _xmlMutex {
99#ifdef HAVE_PTHREAD_H
100 pthread_mutex_t lock;
101#elif defined HAVE_WIN32_THREADS
102 HANDLE mutex;
103#elif defined HAVE_BEOS_THREADS
104 sem_id sem;
105 thread_id tid;
106#else
107 int empty;
108#endif
109};
110
111/*
112 * xmlRMutex are reentrant mutual exception locks
113 */
114struct _xmlRMutex {
115#ifdef HAVE_PTHREAD_H
116 pthread_mutex_t lock;
117 unsigned int held;
118 unsigned int waiters;
119 pthread_t tid;
120 pthread_cond_t cv;
121#elif defined HAVE_WIN32_THREADS
122 CRITICAL_SECTION cs;
123 unsigned int count;
124#elif defined HAVE_BEOS_THREADS
125 xmlMutexPtr lock;
126 thread_id tid;
127 int32 count;
128#else
129 int empty;
130#endif
131};
132/*
133 * This module still has some internal static data.
134 * - xmlLibraryLock a global lock
135 * - globalkey used for per-thread data
136 */
137
138#ifdef HAVE_PTHREAD_H
139static pthread_key_t globalkey;
140static pthread_t mainthread;
141static pthread_once_t once_control = PTHREAD_ONCE_INIT;
142static pthread_mutex_t global_init_lock = PTHREAD_MUTEX_INITIALIZER;
143#elif defined HAVE_WIN32_THREADS
144#if defined(HAVE_COMPILER_TLS)
145static __declspec(thread) xmlGlobalState tlstate;
146static __declspec(thread) int tlstate_inited = 0;
147#else /* HAVE_COMPILER_TLS */
148static DWORD globalkey = TLS_OUT_OF_INDEXES;
149#endif /* HAVE_COMPILER_TLS */
150static DWORD mainthread;
151static struct
152{
153 DWORD done;
154 DWORD control;
155} run_once = { 0, 0 };
156static volatile LPCRITICAL_SECTION global_init_lock = NULL;
157/* endif HAVE_WIN32_THREADS */
158#elif defined HAVE_BEOS_THREADS
159int32 globalkey = 0;
160thread_id mainthread = 0;
161int32 run_once_init = 0;
162static int32 global_init_lock = -1;
163static vint32 global_init_count = 0;
164#endif
165
166static xmlRMutexPtr xmlLibraryLock = NULL;
167#ifdef LIBXML_THREAD_ENABLED
168static void xmlOnceInit(void);
169#endif
170
171/**
172 * xmlNewMutex:
173 *
174 * xmlNewMutex() is used to allocate a libxml2 token struct for use in
175 * synchronizing access to data.
176 *
177 * Returns a new simple mutex pointer or NULL in case of error
178 */
179xmlMutexPtr
180xmlNewMutex(void)
181{
182 xmlMutexPtr tok;
183
184 if ((tok = malloc(sizeof(xmlMutex))) == NULL)
185 return (NULL);
186#ifdef HAVE_PTHREAD_H
187 if (libxml_is_threaded != 0)
188 pthread_mutex_init(&tok->lock, NULL);
189#elif defined HAVE_WIN32_THREADS
190 tok->mutex = CreateMutex(NULL, FALSE, NULL);
191#elif defined HAVE_BEOS_THREADS
192 if ((tok->sem = create_sem(1, "xmlMutex")) < B_OK) {
193 free(tok);
194 return NULL;
195 }
196 tok->tid = -1;
197#endif
198 return (tok);
199}
200
201/**
202 * xmlFreeMutex:
203 * @tok: the simple mutex
204 *
205 * xmlFreeMutex() is used to reclaim resources associated with a libxml2 token
206 * struct.
207 */
208void
209xmlFreeMutex(xmlMutexPtr tok)
210{
211 if (tok == NULL) return;
212
213#ifdef HAVE_PTHREAD_H
214 if (libxml_is_threaded != 0)
215 pthread_mutex_destroy(&tok->lock);
216#elif defined HAVE_WIN32_THREADS
217 CloseHandle(tok->mutex);
218#elif defined HAVE_BEOS_THREADS
219 delete_sem(tok->sem);
220#endif
221 free(tok);
222}
223
224/**
225 * xmlMutexLock:
226 * @tok: the simple mutex
227 *
228 * xmlMutexLock() is used to lock a libxml2 token.
229 */
230void
231xmlMutexLock(xmlMutexPtr tok)
232{
233 if (tok == NULL)
234 return;
235#ifdef HAVE_PTHREAD_H
236 if (libxml_is_threaded != 0)
237 pthread_mutex_lock(&tok->lock);
238#elif defined HAVE_WIN32_THREADS
239 WaitForSingleObject(tok->mutex, INFINITE);
240#elif defined HAVE_BEOS_THREADS
241 if (acquire_sem(tok->sem) != B_NO_ERROR) {
242#ifdef DEBUG_THREADS
243 xmlGenericError(xmlGenericErrorContext, "xmlMutexLock():BeOS:Couldn't aquire semaphore\n");
244 exit();
245#endif
246 }
247 tok->tid = find_thread(NULL);
248#endif
249
250}
251
252/**
253 * xmlMutexUnlock:
254 * @tok: the simple mutex
255 *
256 * xmlMutexUnlock() is used to unlock a libxml2 token.
257 */
258void
259xmlMutexUnlock(xmlMutexPtr tok)
260{
261 if (tok == NULL)
262 return;
263#ifdef HAVE_PTHREAD_H
264 if (libxml_is_threaded != 0)
265 pthread_mutex_unlock(&tok->lock);
266#elif defined HAVE_WIN32_THREADS
267 ReleaseMutex(tok->mutex);
268#elif defined HAVE_BEOS_THREADS
269 if (tok->tid == find_thread(NULL)) {
270 tok->tid = -1;
271 release_sem(tok->sem);
272 }
273#endif
274}
275
276/**
277 * xmlNewRMutex:
278 *
279 * xmlRNewMutex() is used to allocate a reentrant mutex for use in
280 * synchronizing access to data. token_r is a re-entrant lock and thus useful
281 * for synchronizing access to data structures that may be manipulated in a
282 * recursive fashion.
283 *
284 * Returns the new reentrant mutex pointer or NULL in case of error
285 */
286xmlRMutexPtr
287xmlNewRMutex(void)
288{
289 xmlRMutexPtr tok;
290
291 if ((tok = malloc(sizeof(xmlRMutex))) == NULL)
292 return (NULL);
293#ifdef HAVE_PTHREAD_H
294 if (libxml_is_threaded != 0) {
295 pthread_mutex_init(&tok->lock, NULL);
296 tok->held = 0;
297 tok->waiters = 0;
298 pthread_cond_init(&tok->cv, NULL);
299 }
300#elif defined HAVE_WIN32_THREADS
301 InitializeCriticalSection(&tok->cs);
302 tok->count = 0;
303#elif defined HAVE_BEOS_THREADS
304 if ((tok->lock = xmlNewMutex()) == NULL) {
305 free(tok);
306 return NULL;
307 }
308 tok->count = 0;
309#endif
310 return (tok);
311}
312
313/**
314 * xmlFreeRMutex:
315 * @tok: the reentrant mutex
316 *
317 * xmlRFreeMutex() is used to reclaim resources associated with a
318 * reentrant mutex.
319 */
320void
321xmlFreeRMutex(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
322{
323 if (tok == NULL)
324 return;
325#ifdef HAVE_PTHREAD_H
326 if (libxml_is_threaded != 0) {
327 pthread_mutex_destroy(&tok->lock);
328 pthread_cond_destroy(&tok->cv);
329 }
330#elif defined HAVE_WIN32_THREADS
331 DeleteCriticalSection(&tok->cs);
332#elif defined HAVE_BEOS_THREADS
333 xmlFreeMutex(tok->lock);
334#endif
335 free(tok);
336}
337
338/**
339 * xmlRMutexLock:
340 * @tok: the reentrant mutex
341 *
342 * xmlRMutexLock() is used to lock a libxml2 token_r.
343 */
344void
345xmlRMutexLock(xmlRMutexPtr tok)
346{
347 if (tok == NULL)
348 return;
349#ifdef HAVE_PTHREAD_H
350 if (libxml_is_threaded == 0)
351 return;
352
353 pthread_mutex_lock(&tok->lock);
354 if (tok->held) {
355 if (pthread_equal(tok->tid, pthread_self())) {
356 tok->held++;
357 pthread_mutex_unlock(&tok->lock);
358 return;
359 } else {
360 tok->waiters++;
361 while (tok->held)
362 pthread_cond_wait(&tok->cv, &tok->lock);
363 tok->waiters--;
364 }
365 }
366 tok->tid = pthread_self();
367 tok->held = 1;
368 pthread_mutex_unlock(&tok->lock);
369#elif defined HAVE_WIN32_THREADS
370 EnterCriticalSection(&tok->cs);
371 ++tok->count;
372#elif defined HAVE_BEOS_THREADS
373 if (tok->lock->tid == find_thread(NULL)) {
374 tok->count++;
375 return;
376 } else {
377 xmlMutexLock(tok->lock);
378 tok->count = 1;
379 }
380#endif
381}
382
383/**
384 * xmlRMutexUnlock:
385 * @tok: the reentrant mutex
386 *
387 * xmlRMutexUnlock() is used to unlock a libxml2 token_r.
388 */
389void
390xmlRMutexUnlock(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
391{
392 if (tok == NULL)
393 return;
394#ifdef HAVE_PTHREAD_H
395 if (libxml_is_threaded == 0)
396 return;
397
398 pthread_mutex_lock(&tok->lock);
399 tok->held--;
400 if (tok->held == 0) {
401 if (tok->waiters)
402 pthread_cond_signal(&tok->cv);
403 tok->tid = 0;
404 }
405 pthread_mutex_unlock(&tok->lock);
406#elif defined HAVE_WIN32_THREADS
407 if (!--tok->count)
408 LeaveCriticalSection(&tok->cs);
409#elif defined HAVE_BEOS_THREADS
410 if (tok->lock->tid == find_thread(NULL)) {
411 tok->count--;
412 if (tok->count == 0) {
413 xmlMutexUnlock(tok->lock);
414 }
415 return;
416 }
417#endif
418}
419
420/**
421 * xmlGlobalInitMutexLock
422 *
423 * Makes sure that the global initialization mutex is initialized and
424 * locks it.
425 */
426void
427__xmlGlobalInitMutexLock(void)
428{
429 /* Make sure the global init lock is initialized and then lock it. */
430#ifdef HAVE_PTHREAD_H
431 /* The mutex is statically initialized, so we just lock it. */
432 pthread_mutex_lock(&global_init_lock);
433#elif defined HAVE_WIN32_THREADS
434 LPCRITICAL_SECTION cs;
435
436 /* Create a new critical section */
437 if (global_init_lock == NULL) {
438 cs = malloc(sizeof(CRITICAL_SECTION));
439 InitializeCriticalSection(cs);
440
441 /* Swap it into the global_init_lock */
442#ifdef InterlockedCompareExchangePointer
443 InterlockedCompareExchangePointer(&global_init_lock, cs, NULL);
444#else /* Use older void* version */
445 InterlockedCompareExchange((void **)&global_init_lock, (void *)cs, NULL);
446#endif /* InterlockedCompareExchangePointer */
447
448 /* If another thread successfully recorded its critical
449 * section in the global_init_lock then discard the one
450 * allocated by this thread. */
451 if (global_init_lock != cs) {
452 DeleteCriticalSection(cs);
453 free(cs);
454 }
455 }
456
457 /* Lock the chosen critical section */
458 EnterCriticalSection(global_init_lock);
459#elif defined HAVE_BEOS_THREADS
460 int32 sem;
461
462 /* Allocate a new semaphore */
463 sem = create_sem(1, "xmlGlobalinitMutex");
464
465 while (global_init_lock == -1) {
466 if (atomic_add(&global_init_count, 1) == 0) {
467 global_init_lock = sem;
468 } else {
469 snooze(1);
470 atomic_add(&global_init_count, -1);
471 }
472 }
473
474 /* If another thread successfully recorded its critical
475 * section in the global_init_lock then discard the one
476 * allocated by this thread. */
477 if (global_init_lock != sem)
478 delete_sem(sem);
479
480 /* Acquire the chosen semaphore */
481 if (acquire_sem(global_init_lock) != B_NO_ERROR) {
482#ifdef DEBUG_THREADS
483 xmlGenericError(xmlGenericErrorContext, "xmlGlobalInitMutexLock():BeOS:Couldn't acquire semaphore\n");
484 exit();
485#endif
486 }
487#endif
488}
489
490void
491__xmlGlobalInitMutexUnlock(void)
492{
493#ifdef HAVE_PTHREAD_H
494 pthread_mutex_unlock(&global_init_lock);
495#elif defined HAVE_WIN32_THREADS
496 LeaveCriticalSection(global_init_lock);
497#elif defined HAVE_BEOS_THREADS
498 release_sem(global_init_lock);
499#endif
500}
501
502/**
503 * xmlGlobalInitMutexDestroy
504 *
505 * Makes sure that the global initialization mutex is destroyed before
506 * application termination.
507 */
508void __xmlGlobalInitMutexDestroy(void)
509{
510#if defined HAVE_WIN32_THREADS
511 if (global_init_lock != NULL)
512 {
513 DeleteCriticalSection(global_init_lock);
514 free(global_init_lock);
515 global_init_lock = NULL;
516 }
517#endif
518}
519
520/************************************************************************
521 * *
522 * Per thread global state handling *
523 * *
524 ************************************************************************/
525
526#ifdef LIBXML_THREAD_ENABLED
527#ifdef xmlLastError
528#undef xmlLastError
529#endif
530/**
531 * xmlFreeGlobalState:
532 * @state: a thread global state
533 *
534 * xmlFreeGlobalState() is called when a thread terminates with a non-NULL
535 * global state. It is is used here to reclaim memory resources.
536 */
537static void
538xmlFreeGlobalState(void *state)
539{
540 xmlGlobalState *gs = (xmlGlobalState *) state;
541
542 /* free any memory allocated in the thread's xmlLastError */
543 xmlResetError(&(gs->xmlLastError));
544 free(state);
545}
546
547/**
548 * xmlNewGlobalState:
549 *
550 * xmlNewGlobalState() allocates a global state. This structure is used to
551 * hold all data for use by a thread when supporting backwards compatibility
552 * of libxml2 to pre-thread-safe behaviour.
553 *
554 * Returns the newly allocated xmlGlobalStatePtr or NULL in case of error
555 */
556static xmlGlobalStatePtr
557xmlNewGlobalState(void)
558{
559 xmlGlobalState *gs;
560
561 gs = malloc(sizeof(xmlGlobalState));
562 if (gs == NULL)
563 return(NULL);
564
565 memset(gs, 0, sizeof(xmlGlobalState));
566 xmlInitializeGlobalState(gs);
567 return (gs);
568}
569#endif /* LIBXML_THREAD_ENABLED */
570
571
572#ifdef HAVE_WIN32_THREADS
573#if !defined(HAVE_COMPILER_TLS)
574#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
575typedef struct _xmlGlobalStateCleanupHelperParams
576{
577 HANDLE thread;
578 void *memory;
579} xmlGlobalStateCleanupHelperParams;
580
581static void XMLCDECL xmlGlobalStateCleanupHelper (void *p)
582{
583 xmlGlobalStateCleanupHelperParams *params = (xmlGlobalStateCleanupHelperParams *) p;
584 WaitForSingleObject(params->thread, INFINITE);
585 CloseHandle(params->thread);
586 xmlFreeGlobalState(params->memory);
587 free(params);
588 _endthread();
589}
590#else /* LIBXML_STATIC && !LIBXML_STATIC_FOR_DLL */
591
592typedef struct _xmlGlobalStateCleanupHelperParams
593{
594 void *memory;
595 struct _xmlGlobalStateCleanupHelperParams * prev;
596 struct _xmlGlobalStateCleanupHelperParams * next;
597} xmlGlobalStateCleanupHelperParams;
598
599static xmlGlobalStateCleanupHelperParams * cleanup_helpers_head = NULL;
600static CRITICAL_SECTION cleanup_helpers_cs;
601
602#endif /* LIBXMLSTATIC && !LIBXML_STATIC_FOR_DLL */
603#endif /* HAVE_COMPILER_TLS */
604#endif /* HAVE_WIN32_THREADS */
605
606#if defined HAVE_BEOS_THREADS
607/**
608 * xmlGlobalStateCleanup:
609 * @data: unused parameter
610 *
611 * Used for Beos only
612 */
613void xmlGlobalStateCleanup(void *data)
614{
615 void *globalval = tls_get(globalkey);
616 if (globalval != NULL)
617 xmlFreeGlobalState(globalval);
618}
619#endif
620
621/**
622 * xmlGetGlobalState:
623 *
624 * xmlGetGlobalState() is called to retrieve the global state for a thread.
625 *
626 * Returns the thread global state or NULL in case of error
627 */
628xmlGlobalStatePtr
629xmlGetGlobalState(void)
630{
631#ifdef HAVE_PTHREAD_H
632 xmlGlobalState *globalval;
633
634 if (libxml_is_threaded == 0)
635 return(NULL);
636
637 pthread_once(&once_control, xmlOnceInit);
638
639 if ((globalval = (xmlGlobalState *)
640 pthread_getspecific(globalkey)) == NULL) {
641 xmlGlobalState *tsd = xmlNewGlobalState();
642
643 pthread_setspecific(globalkey, tsd);
644 return (tsd);
645 }
646 return (globalval);
647#elif defined HAVE_WIN32_THREADS
648#if defined(HAVE_COMPILER_TLS)
649 if (!tlstate_inited) {
650 tlstate_inited = 1;
651 xmlInitializeGlobalState(&tlstate);
652 }
653 return &tlstate;
654#else /* HAVE_COMPILER_TLS */
655 xmlGlobalState *globalval;
656 xmlGlobalStateCleanupHelperParams * p;
657
658 xmlOnceInit();
659#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
660 globalval = (xmlGlobalState *)TlsGetValue(globalkey);
661#else
662 p = (xmlGlobalStateCleanupHelperParams*)TlsGetValue(globalkey);
663 globalval = (xmlGlobalState *)(p ? p->memory : NULL);
664#endif
665 if (globalval == NULL) {
666 xmlGlobalState *tsd = xmlNewGlobalState();
667 p = (xmlGlobalStateCleanupHelperParams *) malloc(sizeof(xmlGlobalStateCleanupHelperParams));
668 p->memory = tsd;
669#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
670 DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
671 GetCurrentProcess(), &p->thread, 0, TRUE, DUPLICATE_SAME_ACCESS);
672 TlsSetValue(globalkey, tsd);
673 _beginthread(xmlGlobalStateCleanupHelper, 0, p);
674#else
675 EnterCriticalSection(&cleanup_helpers_cs);
676 if (cleanup_helpers_head != NULL) {
677 cleanup_helpers_head->prev = p;
678 }
679 p->next = cleanup_helpers_head;
680 p->prev = NULL;
681 cleanup_helpers_head = p;
682 TlsSetValue(globalkey, p);
683 LeaveCriticalSection(&cleanup_helpers_cs);
684#endif
685
686 return (tsd);
687 }
688 return (globalval);
689#endif /* HAVE_COMPILER_TLS */
690#elif defined HAVE_BEOS_THREADS
691 xmlGlobalState *globalval;
692
693 xmlOnceInit();
694
695 if ((globalval = (xmlGlobalState *)
696 tls_get(globalkey)) == NULL) {
697 xmlGlobalState *tsd = xmlNewGlobalState();
698
699 tls_set(globalkey, tsd);
700 on_exit_thread(xmlGlobalStateCleanup, NULL);
701 return (tsd);
702 }
703 return (globalval);
704#else
705 return(NULL);
706#endif
707}
708
709/************************************************************************
710 * *
711 * Library wide thread interfaces *
712 * *
713 ************************************************************************/
714
715/**
716 * xmlGetThreadId:
717 *
718 * xmlGetThreadId() find the current thread ID number
719 *
720 * Returns the current thread ID number
721 */
722int
723xmlGetThreadId(void)
724{
725#ifdef HAVE_PTHREAD_H
726 if (libxml_is_threaded == 0)
727 return(0);
728 return((int) pthread_self());
729#elif defined HAVE_WIN32_THREADS
730 return GetCurrentThreadId();
731#elif defined HAVE_BEOS_THREADS
732 return find_thread(NULL);
733#else
734 return((int) 0);
735#endif
736}
737
738/**
739 * xmlIsMainThread:
740 *
741 * xmlIsMainThread() check whether the current thread is the main thread.
742 *
743 * Returns 1 if the current thread is the main thread, 0 otherwise
744 */
745int
746xmlIsMainThread(void)
747{
748#ifdef HAVE_PTHREAD_H
749 if (libxml_is_threaded == -1)
750 xmlInitThreads();
751 if (libxml_is_threaded == 0)
752 return(1);
753 pthread_once(&once_control, xmlOnceInit);
754#elif defined HAVE_WIN32_THREADS
755 xmlOnceInit ();
756#elif defined HAVE_BEOS_THREADS
757 xmlOnceInit();
758#endif
759
760#ifdef DEBUG_THREADS
761 xmlGenericError(xmlGenericErrorContext, "xmlIsMainThread()\n");
762#endif
763#ifdef HAVE_PTHREAD_H
764 return(mainthread == pthread_self());
765#elif defined HAVE_WIN32_THREADS
766 return(mainthread == GetCurrentThreadId ());
767#elif defined HAVE_BEOS_THREADS
768 return(mainthread == find_thread(NULL));
769#else
770 return(1);
771#endif
772}
773
774/**
775 * xmlLockLibrary:
776 *
777 * xmlLockLibrary() is used to take out a re-entrant lock on the libxml2
778 * library.
779 */
780void
781xmlLockLibrary(void)
782{
783#ifdef DEBUG_THREADS
784 xmlGenericError(xmlGenericErrorContext, "xmlLockLibrary()\n");
785#endif
786 xmlRMutexLock(xmlLibraryLock);
787}
788
789/**
790 * xmlUnlockLibrary:
791 *
792 * xmlUnlockLibrary() is used to release a re-entrant lock on the libxml2
793 * library.
794 */
795void
796xmlUnlockLibrary(void)
797{
798#ifdef DEBUG_THREADS
799 xmlGenericError(xmlGenericErrorContext, "xmlUnlockLibrary()\n");
800#endif
801 xmlRMutexUnlock(xmlLibraryLock);
802}
803
804/**
805 * xmlInitThreads:
806 *
807 * xmlInitThreads() is used to to initialize all the thread related
808 * data of the libxml2 library.
809 */
810void
811xmlInitThreads(void)
812{
813#ifdef DEBUG_THREADS
814 xmlGenericError(xmlGenericErrorContext, "xmlInitThreads()\n");
815#endif
816#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
817 InitializeCriticalSection(&cleanup_helpers_cs);
818#endif
819#ifdef HAVE_PTHREAD_H
820 if (libxml_is_threaded == -1) {
821 if ((pthread_once != NULL) &&
822 (pthread_getspecific != NULL) &&
823 (pthread_setspecific != NULL) &&
824 (pthread_key_create != NULL) &&
825 (pthread_mutex_init != NULL) &&
826 (pthread_mutex_destroy != NULL) &&
827 (pthread_mutex_lock != NULL) &&
828 (pthread_mutex_unlock != NULL) &&
829 (pthread_cond_init != NULL) &&
830 (pthread_equal != NULL) &&
831 (pthread_self != NULL) &&
832 (pthread_key_create != NULL) &&
833 (pthread_cond_signal != NULL)) {
834 libxml_is_threaded = 1;
835/* fprintf(stderr, "Running multithreaded\n"); */
836 } else {
837/* fprintf(stderr, "Running without multithread\n"); */
838 libxml_is_threaded = 0;
839 }
840 }
841#endif
842}
843
844/**
845 * xmlCleanupThreads:
846 *
847 * xmlCleanupThreads() is used to to cleanup all the thread related
848 * data of the libxml2 library once processing has ended.
849 */
850void
851xmlCleanupThreads(void)
852{
853#ifdef DEBUG_THREADS
854 xmlGenericError(xmlGenericErrorContext, "xmlCleanupThreads()\n");
855#endif
856#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
857 if (globalkey != TLS_OUT_OF_INDEXES) {
858 xmlGlobalStateCleanupHelperParams * p;
859 EnterCriticalSection(&cleanup_helpers_cs);
860 p = cleanup_helpers_head;
861 while (p != NULL) {
862 xmlGlobalStateCleanupHelperParams * temp = p;
863 p = p->next;
864 xmlFreeGlobalState(temp->memory);
865 free(temp);
866 }
867 cleanup_helpers_head = 0;
868 LeaveCriticalSection(&cleanup_helpers_cs);
869 TlsFree(globalkey);
870 globalkey = TLS_OUT_OF_INDEXES;
871 }
872 DeleteCriticalSection(&cleanup_helpers_cs);
873#endif
874}
875
876#ifdef LIBXML_THREAD_ENABLED
877/**
878 * xmlOnceInit
879 *
880 * xmlOnceInit() is used to initialize the value of mainthread for use
881 * in other routines. This function should only be called using
882 * pthread_once() in association with the once_control variable to ensure
883 * that the function is only called once. See man pthread_once for more
884 * details.
885 */
886static void
887xmlOnceInit(void) {
888#ifdef HAVE_PTHREAD_H
889 (void) pthread_key_create(&globalkey, xmlFreeGlobalState);
890 mainthread = pthread_self();
891#endif
892
893#if defined(HAVE_WIN32_THREADS)
894 if (!run_once.done) {
895 if (InterlockedIncrement(&run_once.control) == 1)
896 {
897#if !defined(HAVE_COMPILER_TLS)
898 globalkey = TlsAlloc();
899#endif
900 mainthread = GetCurrentThreadId();
901 run_once.done = 1;
902 }
903 else {
904 /* Another thread is working; give up our slice and
905 * wait until they're done. */
906 while (!run_once.done)
907 Sleep(0);
908 }
909 }
910#endif
911
912#ifdef HAVE_BEOS_THREADS
913 if (atomic_add(&run_once_init, 1) == 0) {
914 globalkey = tls_allocate();
915 tls_set(globalkey, NULL);
916 mainthread = find_thread(NULL);
917 } else
918 atomic_add(&run_once_init, -1);
919#endif
920}
921#endif
922
923/**
924 * DllMain:
925 * @hinstDLL: handle to DLL instance
926 * @fdwReason: Reason code for entry
927 * @lpvReserved: generic pointer (depends upon reason code)
928 *
929 * Entry point for Windows library. It is being used to free thread-specific
930 * storage.
931 *
932 * Returns TRUE always
933 */
934#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
935#if defined(LIBXML_STATIC_FOR_DLL)
936BOOL XMLCALL xmlDllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
937#else
938BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
939#endif
940{
941 switch(fdwReason) {
942 case DLL_THREAD_DETACH:
943 if (globalkey != TLS_OUT_OF_INDEXES) {
944 xmlGlobalState *globalval = NULL;
945 xmlGlobalStateCleanupHelperParams * p =
946 (xmlGlobalStateCleanupHelperParams*)TlsGetValue(globalkey);
947 globalval = (xmlGlobalState *)(p ? p->memory : NULL);
948 if (globalval) {
949 xmlFreeGlobalState(globalval);
950 TlsSetValue(globalkey,NULL);
951 }
952 if (p)
953 {
954 EnterCriticalSection(&cleanup_helpers_cs);
955 if (p == cleanup_helpers_head)
956 cleanup_helpers_head = p->next;
957 else
958 p->prev->next = p->next;
959 if (p->next != NULL)
960 p->next->prev = p->prev;
961 LeaveCriticalSection(&cleanup_helpers_cs);
962 free(p);
963 }
964 }
965 break;
966 }
967 return TRUE;
968}
969#endif
970#define bottom_threads
971#include "elfgcchack.h"
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette