Annotation of embedaddon/libxml2/threads.c, revision 1.1
1.1 ! misho 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: #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:
! 49: static int libxml_is_threaded = -1;
! 50: #ifdef __GNUC__
! 51: #ifdef linux
! 52: #if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || (__GNUC__ > 3)
! 53: extern int pthread_once (pthread_once_t *__once_control,
! 54: void (*__init_routine) (void))
! 55: __attribute((weak));
! 56: extern void *pthread_getspecific (pthread_key_t __key)
! 57: __attribute((weak));
! 58: extern int pthread_setspecific (pthread_key_t __key,
! 59: __const void *__pointer)
! 60: __attribute((weak));
! 61: extern int pthread_key_create (pthread_key_t *__key,
! 62: void (*__destr_function) (void *))
! 63: __attribute((weak));
! 64: extern int pthread_key_delete (pthread_key_t __key)
! 65: __attribute((weak));
! 66: extern int pthread_mutex_init ()
! 67: __attribute((weak));
! 68: extern int pthread_mutex_destroy ()
! 69: __attribute((weak));
! 70: extern int pthread_mutex_lock ()
! 71: __attribute((weak));
! 72: extern int pthread_mutex_unlock ()
! 73: __attribute((weak));
! 74: extern int pthread_cond_init ()
! 75: __attribute((weak));
! 76: extern int pthread_cond_destroy ()
! 77: __attribute((weak));
! 78: extern int pthread_cond_wait ()
! 79: __attribute((weak));
! 80: extern int pthread_equal ()
! 81: __attribute((weak));
! 82: extern pthread_t pthread_self ()
! 83: __attribute((weak));
! 84: extern int pthread_key_create ()
! 85: __attribute((weak));
! 86: extern int pthread_key_delete ()
! 87: __attribute((weak));
! 88: extern int pthread_cond_signal ()
! 89: __attribute((weak));
! 90: #endif
! 91: #endif /* linux */
! 92: #endif /* __GNUC__ */
! 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: */
! 104: struct _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: */
! 120: struct _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
! 146: static pthread_key_t globalkey;
! 147: static pthread_t mainthread;
! 148: static pthread_once_t once_control = PTHREAD_ONCE_INIT;
! 149: static pthread_mutex_t global_init_lock = PTHREAD_MUTEX_INITIALIZER;
! 150: #elif defined HAVE_WIN32_THREADS
! 151: #if defined(HAVE_COMPILER_TLS)
! 152: static __declspec(thread) xmlGlobalState tlstate;
! 153: static __declspec(thread) int tlstate_inited = 0;
! 154: #else /* HAVE_COMPILER_TLS */
! 155: static DWORD globalkey = TLS_OUT_OF_INDEXES;
! 156: #endif /* HAVE_COMPILER_TLS */
! 157: static DWORD mainthread;
! 158: static struct {
! 159: DWORD done;
! 160: DWORD control;
! 161: } run_once = { 0, 0};
! 162: static volatile LPCRITICAL_SECTION global_init_lock = NULL;
! 163:
! 164: /* endif HAVE_WIN32_THREADS */
! 165: #elif defined HAVE_BEOS_THREADS
! 166: int32 globalkey = 0;
! 167: thread_id mainthread = 0;
! 168: int32 run_once_init = 0;
! 169: static int32 global_init_lock = -1;
! 170: static vint32 global_init_count = 0;
! 171: #endif
! 172:
! 173: static xmlRMutexPtr xmlLibraryLock = NULL;
! 174:
! 175: #ifdef LIBXML_THREAD_ENABLED
! 176: static void xmlOnceInit(void);
! 177: #endif
! 178:
! 179: /**
! 180: * xmlNewMutex:
! 181: *
! 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: */
! 187: xmlMutexPtr
! 188: xmlNewMutex(void)
! 189: {
! 190: xmlMutexPtr tok;
! 191:
! 192: if ((tok = malloc(sizeof(xmlMutex))) == NULL)
! 193: return (NULL);
! 194: #ifdef HAVE_PTHREAD_H
! 195: if (libxml_is_threaded != 0)
! 196: pthread_mutex_init(&tok->lock, NULL);
! 197: #elif defined HAVE_WIN32_THREADS
! 198: tok->mutex = CreateMutex(NULL, FALSE, NULL);
! 199: #elif defined HAVE_BEOS_THREADS
! 200: if ((tok->sem = create_sem(1, "xmlMutex")) < B_OK) {
! 201: free(tok);
! 202: return NULL;
! 203: }
! 204: tok->tid = -1;
! 205: #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: */
! 216: void
! 217: xmlFreeMutex(xmlMutexPtr tok)
! 218: {
! 219: if (tok == NULL)
! 220: return;
! 221:
! 222: #ifdef HAVE_PTHREAD_H
! 223: if (libxml_is_threaded != 0)
! 224: pthread_mutex_destroy(&tok->lock);
! 225: #elif defined HAVE_WIN32_THREADS
! 226: CloseHandle(tok->mutex);
! 227: #elif defined HAVE_BEOS_THREADS
! 228: delete_sem(tok->sem);
! 229: #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: */
! 239: void
! 240: xmlMutexLock(xmlMutexPtr tok)
! 241: {
! 242: if (tok == NULL)
! 243: return;
! 244: #ifdef HAVE_PTHREAD_H
! 245: if (libxml_is_threaded != 0)
! 246: pthread_mutex_lock(&tok->lock);
! 247: #elif defined HAVE_WIN32_THREADS
! 248: WaitForSingleObject(tok->mutex, INFINITE);
! 249: #elif defined HAVE_BEOS_THREADS
! 250: if (acquire_sem(tok->sem) != B_NO_ERROR) {
! 251: #ifdef DEBUG_THREADS
! 252: xmlGenericError(xmlGenericErrorContext,
! 253: "xmlMutexLock():BeOS:Couldn't aquire semaphore\n");
! 254: exit();
! 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: */
! 268: void
! 269: xmlMutexUnlock(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: */
! 296: xmlRMutexPtr
! 297: xmlNewRMutex(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: */
! 330: void
! 331: xmlFreeRMutex(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: */
! 354: void
! 355: xmlRMutexLock(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: */
! 399: void
! 400: xmlRMutexUnlock(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)
! 418: LeaveCriticalSection(&tok->cs);
! 419: #elif defined HAVE_BEOS_THREADS
! 420: if (tok->lock->tid == find_thread(NULL)) {
! 421: tok->count--;
! 422: if (tok->count == 0) {
! 423: xmlMutexUnlock(tok->lock);
! 424: }
! 425: return;
! 426: }
! 427: #endif
! 428: }
! 429:
! 430: /**
! 431: * xmlGlobalInitMutexLock
! 432: *
! 433: * Makes sure that the global initialization mutex is initialized and
! 434: * locks it.
! 435: */
! 436: void
! 437: __xmlGlobalInitMutexLock(void)
! 438: {
! 439: /* Make sure the global init lock is initialized and then lock it. */
! 440: #ifdef HAVE_PTHREAD_H
! 441: /* The mutex is statically initialized, so we just lock it. */
! 442: if (pthread_mutex_lock)
! 443: pthread_mutex_lock(&global_init_lock);
! 444: #elif defined HAVE_WIN32_THREADS
! 445: LPCRITICAL_SECTION cs;
! 446:
! 447: /* Create a new critical section */
! 448: if (global_init_lock == NULL) {
! 449: cs = malloc(sizeof(CRITICAL_SECTION));
! 450: if (cs == NULL) {
! 451: xmlGenericError(xmlGenericErrorContext,
! 452: "xmlGlobalInitMutexLock: out of memory\n");
! 453: return;
! 454: }
! 455: InitializeCriticalSection(cs);
! 456:
! 457: /* Swap it into the global_init_lock */
! 458: #ifdef InterlockedCompareExchangePointer
! 459: InterlockedCompareExchangePointer(&global_init_lock, cs, NULL);
! 460: #else /* Use older void* version */
! 461: InterlockedCompareExchange((void **) &global_init_lock,
! 462: (void *) cs, NULL);
! 463: #endif /* InterlockedCompareExchangePointer */
! 464:
! 465: /* If another thread successfully recorded its critical
! 466: * section in the global_init_lock then discard the one
! 467: * allocated by this thread. */
! 468: if (global_init_lock != cs) {
! 469: DeleteCriticalSection(cs);
! 470: free(cs);
! 471: }
! 472: }
! 473:
! 474: /* Lock the chosen critical section */
! 475: EnterCriticalSection(global_init_lock);
! 476: #elif defined HAVE_BEOS_THREADS
! 477: int32 sem;
! 478:
! 479: /* Allocate a new semaphore */
! 480: sem = create_sem(1, "xmlGlobalinitMutex");
! 481:
! 482: while (global_init_lock == -1) {
! 483: if (atomic_add(&global_init_count, 1) == 0) {
! 484: global_init_lock = sem;
! 485: } else {
! 486: snooze(1);
! 487: atomic_add(&global_init_count, -1);
! 488: }
! 489: }
! 490:
! 491: /* If another thread successfully recorded its critical
! 492: * section in the global_init_lock then discard the one
! 493: * allocated by this thread. */
! 494: if (global_init_lock != sem)
! 495: delete_sem(sem);
! 496:
! 497: /* Acquire the chosen semaphore */
! 498: if (acquire_sem(global_init_lock) != B_NO_ERROR) {
! 499: #ifdef DEBUG_THREADS
! 500: xmlGenericError(xmlGenericErrorContext,
! 501: "xmlGlobalInitMutexLock():BeOS:Couldn't acquire semaphore\n");
! 502: exit();
! 503: #endif
! 504: }
! 505: #endif
! 506: }
! 507:
! 508: void
! 509: __xmlGlobalInitMutexUnlock(void)
! 510: {
! 511: #ifdef HAVE_PTHREAD_H
! 512: if (pthread_mutex_unlock)
! 513: pthread_mutex_unlock(&global_init_lock);
! 514: #elif defined HAVE_WIN32_THREADS
! 515: if (global_init_lock != NULL) {
! 516: LeaveCriticalSection(global_init_lock);
! 517: }
! 518: #elif defined HAVE_BEOS_THREADS
! 519: release_sem(global_init_lock);
! 520: #endif
! 521: }
! 522:
! 523: /**
! 524: * xmlGlobalInitMutexDestroy
! 525: *
! 526: * Makes sure that the global initialization mutex is destroyed before
! 527: * application termination.
! 528: */
! 529: void
! 530: __xmlGlobalInitMutexDestroy(void)
! 531: {
! 532: #ifdef HAVE_PTHREAD_H
! 533: #elif defined HAVE_WIN32_THREADS
! 534: if (global_init_lock != NULL) {
! 535: DeleteCriticalSection(global_init_lock);
! 536: free(global_init_lock);
! 537: global_init_lock = NULL;
! 538: }
! 539: #endif
! 540: }
! 541:
! 542: /************************************************************************
! 543: * *
! 544: * Per thread global state handling *
! 545: * *
! 546: ************************************************************************/
! 547:
! 548: #ifdef LIBXML_THREAD_ENABLED
! 549: #ifdef xmlLastError
! 550: #undef xmlLastError
! 551: #endif
! 552:
! 553: /**
! 554: * xmlFreeGlobalState:
! 555: * @state: a thread global state
! 556: *
! 557: * xmlFreeGlobalState() is called when a thread terminates with a non-NULL
! 558: * global state. It is is used here to reclaim memory resources.
! 559: */
! 560: static void
! 561: xmlFreeGlobalState(void *state)
! 562: {
! 563: xmlGlobalState *gs = (xmlGlobalState *) state;
! 564:
! 565: /* free any memory allocated in the thread's xmlLastError */
! 566: xmlResetError(&(gs->xmlLastError));
! 567: free(state);
! 568: }
! 569:
! 570: /**
! 571: * xmlNewGlobalState:
! 572: *
! 573: * xmlNewGlobalState() allocates a global state. This structure is used to
! 574: * hold all data for use by a thread when supporting backwards compatibility
! 575: * of libxml2 to pre-thread-safe behaviour.
! 576: *
! 577: * Returns the newly allocated xmlGlobalStatePtr or NULL in case of error
! 578: */
! 579: static xmlGlobalStatePtr
! 580: xmlNewGlobalState(void)
! 581: {
! 582: xmlGlobalState *gs;
! 583:
! 584: gs = malloc(sizeof(xmlGlobalState));
! 585: if (gs == NULL) {
! 586: xmlGenericError(xmlGenericErrorContext,
! 587: "xmlGetGlobalState: out of memory\n");
! 588: return (NULL);
! 589: }
! 590:
! 591: memset(gs, 0, sizeof(xmlGlobalState));
! 592: xmlInitializeGlobalState(gs);
! 593: return (gs);
! 594: }
! 595: #endif /* LIBXML_THREAD_ENABLED */
! 596:
! 597: #ifdef HAVE_PTHREAD_H
! 598: #elif defined HAVE_WIN32_THREADS
! 599: #if !defined(HAVE_COMPILER_TLS)
! 600: #if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
! 601: typedef struct _xmlGlobalStateCleanupHelperParams {
! 602: HANDLE thread;
! 603: void *memory;
! 604: } xmlGlobalStateCleanupHelperParams;
! 605:
! 606: static void XMLCDECL
! 607: xmlGlobalStateCleanupHelper(void *p)
! 608: {
! 609: xmlGlobalStateCleanupHelperParams *params =
! 610: (xmlGlobalStateCleanupHelperParams *) p;
! 611: WaitForSingleObject(params->thread, INFINITE);
! 612: CloseHandle(params->thread);
! 613: xmlFreeGlobalState(params->memory);
! 614: free(params);
! 615: _endthread();
! 616: }
! 617: #else /* LIBXML_STATIC && !LIBXML_STATIC_FOR_DLL */
! 618:
! 619: typedef struct _xmlGlobalStateCleanupHelperParams {
! 620: void *memory;
! 621: struct _xmlGlobalStateCleanupHelperParams *prev;
! 622: struct _xmlGlobalStateCleanupHelperParams *next;
! 623: } xmlGlobalStateCleanupHelperParams;
! 624:
! 625: static xmlGlobalStateCleanupHelperParams *cleanup_helpers_head = NULL;
! 626: static CRITICAL_SECTION cleanup_helpers_cs;
! 627:
! 628: #endif /* LIBXMLSTATIC && !LIBXML_STATIC_FOR_DLL */
! 629: #endif /* HAVE_COMPILER_TLS */
! 630: #endif /* HAVE_WIN32_THREADS */
! 631:
! 632: #if defined HAVE_BEOS_THREADS
! 633:
! 634: /**
! 635: * xmlGlobalStateCleanup:
! 636: * @data: unused parameter
! 637: *
! 638: * Used for Beos only
! 639: */
! 640: void
! 641: xmlGlobalStateCleanup(void *data)
! 642: {
! 643: void *globalval = tls_get(globalkey);
! 644:
! 645: if (globalval != NULL)
! 646: xmlFreeGlobalState(globalval);
! 647: }
! 648: #endif
! 649:
! 650: /**
! 651: * xmlGetGlobalState:
! 652: *
! 653: * xmlGetGlobalState() is called to retrieve the global state for a thread.
! 654: *
! 655: * Returns the thread global state or NULL in case of error
! 656: */
! 657: xmlGlobalStatePtr
! 658: xmlGetGlobalState(void)
! 659: {
! 660: #ifdef HAVE_PTHREAD_H
! 661: xmlGlobalState *globalval;
! 662:
! 663: if (libxml_is_threaded == 0)
! 664: return (NULL);
! 665:
! 666: pthread_once(&once_control, xmlOnceInit);
! 667:
! 668: if ((globalval = (xmlGlobalState *)
! 669: pthread_getspecific(globalkey)) == NULL) {
! 670: xmlGlobalState *tsd = xmlNewGlobalState();
! 671: if (tsd == NULL)
! 672: return(NULL);
! 673:
! 674: pthread_setspecific(globalkey, tsd);
! 675: return (tsd);
! 676: }
! 677: return (globalval);
! 678: #elif defined HAVE_WIN32_THREADS
! 679: #if defined(HAVE_COMPILER_TLS)
! 680: if (!tlstate_inited) {
! 681: tlstate_inited = 1;
! 682: xmlInitializeGlobalState(&tlstate);
! 683: }
! 684: return &tlstate;
! 685: #else /* HAVE_COMPILER_TLS */
! 686: xmlGlobalState *globalval;
! 687: xmlGlobalStateCleanupHelperParams *p;
! 688:
! 689: xmlOnceInit();
! 690: #if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
! 691: globalval = (xmlGlobalState *) TlsGetValue(globalkey);
! 692: #else
! 693: p = (xmlGlobalStateCleanupHelperParams *) TlsGetValue(globalkey);
! 694: globalval = (xmlGlobalState *) (p ? p->memory : NULL);
! 695: #endif
! 696: if (globalval == NULL) {
! 697: xmlGlobalState *tsd = xmlNewGlobalState();
! 698:
! 699: if (tsd == NULL)
! 700: return(NULL);
! 701: p = (xmlGlobalStateCleanupHelperParams *)
! 702: malloc(sizeof(xmlGlobalStateCleanupHelperParams));
! 703: if (p == NULL) {
! 704: xmlGenericError(xmlGenericErrorContext,
! 705: "xmlGetGlobalState: out of memory\n");
! 706: xmlFreeGlobalState(tsd);
! 707: return(NULL);
! 708: }
! 709: p->memory = tsd;
! 710: #if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
! 711: DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
! 712: GetCurrentProcess(), &p->thread, 0, TRUE,
! 713: DUPLICATE_SAME_ACCESS);
! 714: TlsSetValue(globalkey, tsd);
! 715: _beginthread(xmlGlobalStateCleanupHelper, 0, p);
! 716: #else
! 717: EnterCriticalSection(&cleanup_helpers_cs);
! 718: if (cleanup_helpers_head != NULL) {
! 719: cleanup_helpers_head->prev = p;
! 720: }
! 721: p->next = cleanup_helpers_head;
! 722: p->prev = NULL;
! 723: cleanup_helpers_head = p;
! 724: TlsSetValue(globalkey, p);
! 725: LeaveCriticalSection(&cleanup_helpers_cs);
! 726: #endif
! 727:
! 728: return (tsd);
! 729: }
! 730: return (globalval);
! 731: #endif /* HAVE_COMPILER_TLS */
! 732: #elif defined HAVE_BEOS_THREADS
! 733: xmlGlobalState *globalval;
! 734:
! 735: xmlOnceInit();
! 736:
! 737: if ((globalval = (xmlGlobalState *) tls_get(globalkey)) == NULL) {
! 738: xmlGlobalState *tsd = xmlNewGlobalState();
! 739: if (tsd == NULL)
! 740: return (NULL);
! 741:
! 742: tls_set(globalkey, tsd);
! 743: on_exit_thread(xmlGlobalStateCleanup, NULL);
! 744: return (tsd);
! 745: }
! 746: return (globalval);
! 747: #else
! 748: return (NULL);
! 749: #endif
! 750: }
! 751:
! 752: /************************************************************************
! 753: * *
! 754: * Library wide thread interfaces *
! 755: * *
! 756: ************************************************************************/
! 757:
! 758: /**
! 759: * xmlGetThreadId:
! 760: *
! 761: * xmlGetThreadId() find the current thread ID number
! 762: * Note that this is likely to be broken on some platforms using pthreads
! 763: * as the specification doesn't mandate pthread_t to be an integer type
! 764: *
! 765: * Returns the current thread ID number
! 766: */
! 767: int
! 768: xmlGetThreadId(void)
! 769: {
! 770: #ifdef HAVE_PTHREAD_H
! 771: pthread_t id;
! 772: int ret;
! 773:
! 774: if (libxml_is_threaded == 0)
! 775: return (0);
! 776: id = pthread_self();
! 777: /* horrible but preserves compat, see warning above */
! 778: memcpy(&ret, &id, sizeof(ret));
! 779: return (ret);
! 780: #elif defined HAVE_WIN32_THREADS
! 781: return GetCurrentThreadId();
! 782: #elif defined HAVE_BEOS_THREADS
! 783: return find_thread(NULL);
! 784: #else
! 785: return ((int) 0);
! 786: #endif
! 787: }
! 788:
! 789: /**
! 790: * xmlIsMainThread:
! 791: *
! 792: * xmlIsMainThread() check whether the current thread is the main thread.
! 793: *
! 794: * Returns 1 if the current thread is the main thread, 0 otherwise
! 795: */
! 796: int
! 797: xmlIsMainThread(void)
! 798: {
! 799: #ifdef HAVE_PTHREAD_H
! 800: if (libxml_is_threaded == -1)
! 801: xmlInitThreads();
! 802: if (libxml_is_threaded == 0)
! 803: return (1);
! 804: pthread_once(&once_control, xmlOnceInit);
! 805: #elif defined HAVE_WIN32_THREADS
! 806: xmlOnceInit();
! 807: #elif defined HAVE_BEOS_THREADS
! 808: xmlOnceInit();
! 809: #endif
! 810:
! 811: #ifdef DEBUG_THREADS
! 812: xmlGenericError(xmlGenericErrorContext, "xmlIsMainThread()\n");
! 813: #endif
! 814: #ifdef HAVE_PTHREAD_H
! 815: return (pthread_equal(mainthread,pthread_self()));
! 816: #elif defined HAVE_WIN32_THREADS
! 817: return (mainthread == GetCurrentThreadId());
! 818: #elif defined HAVE_BEOS_THREADS
! 819: return (mainthread == find_thread(NULL));
! 820: #else
! 821: return (1);
! 822: #endif
! 823: }
! 824:
! 825: /**
! 826: * xmlLockLibrary:
! 827: *
! 828: * xmlLockLibrary() is used to take out a re-entrant lock on the libxml2
! 829: * library.
! 830: */
! 831: void
! 832: xmlLockLibrary(void)
! 833: {
! 834: #ifdef DEBUG_THREADS
! 835: xmlGenericError(xmlGenericErrorContext, "xmlLockLibrary()\n");
! 836: #endif
! 837: xmlRMutexLock(xmlLibraryLock);
! 838: }
! 839:
! 840: /**
! 841: * xmlUnlockLibrary:
! 842: *
! 843: * xmlUnlockLibrary() is used to release a re-entrant lock on the libxml2
! 844: * library.
! 845: */
! 846: void
! 847: xmlUnlockLibrary(void)
! 848: {
! 849: #ifdef DEBUG_THREADS
! 850: xmlGenericError(xmlGenericErrorContext, "xmlUnlockLibrary()\n");
! 851: #endif
! 852: xmlRMutexUnlock(xmlLibraryLock);
! 853: }
! 854:
! 855: /**
! 856: * xmlInitThreads:
! 857: *
! 858: * xmlInitThreads() is used to to initialize all the thread related
! 859: * data of the libxml2 library.
! 860: */
! 861: void
! 862: xmlInitThreads(void)
! 863: {
! 864: #ifdef HAVE_PTHREAD_H
! 865: if (libxml_is_threaded == -1) {
! 866: if ((pthread_once != NULL) &&
! 867: (pthread_getspecific != NULL) &&
! 868: (pthread_setspecific != NULL) &&
! 869: (pthread_key_create != NULL) &&
! 870: (pthread_key_delete != NULL) &&
! 871: (pthread_mutex_init != NULL) &&
! 872: (pthread_mutex_destroy != NULL) &&
! 873: (pthread_mutex_lock != NULL) &&
! 874: (pthread_mutex_unlock != NULL) &&
! 875: (pthread_cond_init != NULL) &&
! 876: (pthread_cond_destroy != NULL) &&
! 877: (pthread_cond_wait != NULL) &&
! 878: (pthread_equal != NULL) &&
! 879: (pthread_self != NULL) &&
! 880: (pthread_cond_signal != NULL)) {
! 881: libxml_is_threaded = 1;
! 882:
! 883: /* fprintf(stderr, "Running multithreaded\n"); */
! 884: } else {
! 885:
! 886: /* fprintf(stderr, "Running without multithread\n"); */
! 887: libxml_is_threaded = 0;
! 888: }
! 889: }
! 890: #elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
! 891: InitializeCriticalSection(&cleanup_helpers_cs);
! 892: #endif
! 893: }
! 894:
! 895: /**
! 896: * xmlCleanupThreads:
! 897: *
! 898: * xmlCleanupThreads() is used to to cleanup all the thread related
! 899: * data of the libxml2 library once processing has ended.
! 900: *
! 901: * WARNING: if your application is multithreaded or has plugin support
! 902: * calling this may crash the application if another thread or
! 903: * a plugin is still using libxml2. It's sometimes very hard to
! 904: * guess if libxml2 is in use in the application, some libraries
! 905: * or plugins may use it without notice. In case of doubt abstain
! 906: * from calling this function or do it just before calling exit()
! 907: * to avoid leak reports from valgrind !
! 908: */
! 909: void
! 910: xmlCleanupThreads(void)
! 911: {
! 912: #ifdef DEBUG_THREADS
! 913: xmlGenericError(xmlGenericErrorContext, "xmlCleanupThreads()\n");
! 914: #endif
! 915: #ifdef HAVE_PTHREAD_H
! 916: if ((libxml_is_threaded) && (pthread_key_delete != NULL))
! 917: pthread_key_delete(globalkey);
! 918: #elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
! 919: if (globalkey != TLS_OUT_OF_INDEXES) {
! 920: xmlGlobalStateCleanupHelperParams *p;
! 921:
! 922: EnterCriticalSection(&cleanup_helpers_cs);
! 923: p = cleanup_helpers_head;
! 924: while (p != NULL) {
! 925: xmlGlobalStateCleanupHelperParams *temp = p;
! 926:
! 927: p = p->next;
! 928: xmlFreeGlobalState(temp->memory);
! 929: free(temp);
! 930: }
! 931: cleanup_helpers_head = 0;
! 932: LeaveCriticalSection(&cleanup_helpers_cs);
! 933: TlsFree(globalkey);
! 934: globalkey = TLS_OUT_OF_INDEXES;
! 935: }
! 936: DeleteCriticalSection(&cleanup_helpers_cs);
! 937: #endif
! 938: }
! 939:
! 940: #ifdef LIBXML_THREAD_ENABLED
! 941:
! 942: /**
! 943: * xmlOnceInit
! 944: *
! 945: * xmlOnceInit() is used to initialize the value of mainthread for use
! 946: * in other routines. This function should only be called using
! 947: * pthread_once() in association with the once_control variable to ensure
! 948: * that the function is only called once. See man pthread_once for more
! 949: * details.
! 950: */
! 951: static void
! 952: xmlOnceInit(void)
! 953: {
! 954: #ifdef HAVE_PTHREAD_H
! 955: (void) pthread_key_create(&globalkey, xmlFreeGlobalState);
! 956: mainthread = pthread_self();
! 957: #elif defined(HAVE_WIN32_THREADS)
! 958: if (!run_once.done) {
! 959: if (InterlockedIncrement(&run_once.control) == 1) {
! 960: #if !defined(HAVE_COMPILER_TLS)
! 961: globalkey = TlsAlloc();
! 962: #endif
! 963: mainthread = GetCurrentThreadId();
! 964: run_once.done = 1;
! 965: } else {
! 966: /* Another thread is working; give up our slice and
! 967: * wait until they're done. */
! 968: while (!run_once.done)
! 969: Sleep(0);
! 970: }
! 971: }
! 972: #elif defined HAVE_BEOS_THREADS
! 973: if (atomic_add(&run_once_init, 1) == 0) {
! 974: globalkey = tls_allocate();
! 975: tls_set(globalkey, NULL);
! 976: mainthread = find_thread(NULL);
! 977: } else
! 978: atomic_add(&run_once_init, -1);
! 979: #endif
! 980: }
! 981: #endif
! 982:
! 983: /**
! 984: * DllMain:
! 985: * @hinstDLL: handle to DLL instance
! 986: * @fdwReason: Reason code for entry
! 987: * @lpvReserved: generic pointer (depends upon reason code)
! 988: *
! 989: * Entry point for Windows library. It is being used to free thread-specific
! 990: * storage.
! 991: *
! 992: * Returns TRUE always
! 993: */
! 994: #ifdef HAVE_PTHREAD_H
! 995: #elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
! 996: #if defined(LIBXML_STATIC_FOR_DLL)
! 997: BOOL XMLCALL
! 998: xmlDllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
! 999: #else
! 1000: BOOL WINAPI
! 1001: DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
! 1002: #endif
! 1003: {
! 1004: switch (fdwReason) {
! 1005: case DLL_THREAD_DETACH:
! 1006: if (globalkey != TLS_OUT_OF_INDEXES) {
! 1007: xmlGlobalState *globalval = NULL;
! 1008: xmlGlobalStateCleanupHelperParams *p =
! 1009: (xmlGlobalStateCleanupHelperParams *)
! 1010: TlsGetValue(globalkey);
! 1011: globalval = (xmlGlobalState *) (p ? p->memory : NULL);
! 1012: if (globalval) {
! 1013: xmlFreeGlobalState(globalval);
! 1014: TlsSetValue(globalkey, NULL);
! 1015: }
! 1016: if (p) {
! 1017: EnterCriticalSection(&cleanup_helpers_cs);
! 1018: if (p == cleanup_helpers_head)
! 1019: cleanup_helpers_head = p->next;
! 1020: else
! 1021: p->prev->next = p->next;
! 1022: if (p->next != NULL)
! 1023: p->next->prev = p->prev;
! 1024: LeaveCriticalSection(&cleanup_helpers_cs);
! 1025: free(p);
! 1026: }
! 1027: }
! 1028: break;
! 1029: }
! 1030: return TRUE;
! 1031: }
! 1032: #endif
! 1033: #define bottom_threads
! 1034: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to threads.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2