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