VirtualBox

source: vbox/trunk/src/libs/libxml2-2.9.4/threads.c@ 84932

Last change on this file since 84932 was 65950, checked in by vboxsync, 8 years ago

libxml 2.9.4: fix export

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