path: root/contrib/libs/libxml/threads.c

/** 
 * threads.c: set of generic threading related routines 
 * 
 * See Copyright for the status of this software. 
 * 
 * Gary Pennington <Gary.Pennington@uk.sun.com> 
 * daniel@veillard.com 
 */ 
 
#define IN_LIBXML 
#include "libxml.h" 
 
#include <string.h> 
 
#include <libxml/threads.h> 
#include <libxml/globals.h> 
 
#ifdef HAVE_SYS_TYPES_H 
#include <sys/types.h> 
#endif 
#ifdef HAVE_UNISTD_H 
#include <unistd.h> 
#endif 
#ifdef HAVE_STDLIB_H 
#include <stdlib.h> 
#endif 
#ifdef HAVE_PTHREAD_H 
#include <pthread.h> 
#elif defined HAVE_WIN32_THREADS 
#define WIN32_LEAN_AND_MEAN
#include <windows.h> 
#ifndef HAVE_COMPILER_TLS 
#include <process.h> 
#endif 
#endif 
 
#ifdef HAVE_BEOS_THREADS 
#include <OS.h> 
#include <TLS.h> 
#endif 
 
#if defined(SOLARIS) 
#include <note.h> 
#endif 
 
/* #define DEBUG_THREADS */ 
 
#ifdef HAVE_PTHREAD_H 
 
#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 303) && \
    defined(__GLIBC__) && defined(__linux__)

static int libxml_is_threaded = -1; 

#define XML_PTHREAD_WEAK

#pragma weak pthread_once
#pragma weak pthread_getspecific
#pragma weak pthread_setspecific
#pragma weak pthread_key_create
#pragma weak pthread_key_delete
#pragma weak pthread_mutex_init
#pragma weak pthread_mutex_destroy
#pragma weak pthread_mutex_lock
#pragma weak pthread_mutex_unlock
#pragma weak pthread_cond_init
#pragma weak pthread_cond_destroy
#pragma weak pthread_cond_wait
#pragma weak pthread_equal
#pragma weak pthread_self
#pragma weak pthread_key_create
#pragma weak pthread_key_delete
#pragma weak pthread_cond_signal

#else /* __GNUC__, __GLIBC__, __linux__ */

static int libxml_is_threaded = 1;

#endif /* __GNUC__, __GLIBC__, __linux__ */

#endif /* HAVE_PTHREAD_H */ 
 
/* 
 * TODO: this module still uses malloc/free and not xmlMalloc/xmlFree 
 *       to avoid some craziness since xmlMalloc/xmlFree may actually
 *       be hosted on allocated blocks needing them for the allocation ... 
 */ 
 
/* 
 * xmlMutex are a simple mutual exception locks 
 */ 
struct _xmlMutex { 
#ifdef HAVE_PTHREAD_H 
    pthread_mutex_t lock; 
#elif defined HAVE_WIN32_THREADS 
    HANDLE mutex; 
#elif defined HAVE_BEOS_THREADS 
    sem_id sem; 
    thread_id tid; 
#else 
    int empty; 
#endif 
}; 
 
/* 
 * xmlRMutex are reentrant mutual exception locks 
 */ 
struct _xmlRMutex { 
#ifdef HAVE_PTHREAD_H 
    pthread_mutex_t lock; 
    unsigned int held; 
    unsigned int waiters; 
    pthread_t tid; 
    pthread_cond_t cv; 
#elif defined HAVE_WIN32_THREADS 
    CRITICAL_SECTION cs; 
    unsigned int count; 
#elif defined HAVE_BEOS_THREADS 
    xmlMutexPtr lock; 
    thread_id tid; 
    int32 count; 
#else 
    int empty; 
#endif 
}; 
 
/* 
 * This module still has some internal static data. 
 *   - xmlLibraryLock a global lock 
 *   - globalkey used for per-thread data 
 */ 
 
#ifdef HAVE_PTHREAD_H 
static pthread_key_t globalkey; 
static pthread_t mainthread; 
static pthread_once_t once_control = PTHREAD_ONCE_INIT; 
static pthread_once_t once_control_init = PTHREAD_ONCE_INIT; 
static pthread_mutex_t global_init_lock = PTHREAD_MUTEX_INITIALIZER; 
#elif defined HAVE_WIN32_THREADS 
#if defined(HAVE_COMPILER_TLS) 
static __declspec(thread) xmlGlobalState tlstate; 
static __declspec(thread) int tlstate_inited = 0; 
#else /* HAVE_COMPILER_TLS */ 
static DWORD globalkey = TLS_OUT_OF_INDEXES; 
#endif /* HAVE_COMPILER_TLS */ 
static DWORD mainthread; 
static struct { 
    DWORD done; 
    LONG control;
} run_once = { 0, 0}; 
static volatile LPCRITICAL_SECTION global_init_lock = NULL; 
 
/* endif HAVE_WIN32_THREADS */ 
#elif defined HAVE_BEOS_THREADS 
int32 globalkey = 0; 
thread_id mainthread = 0; 
int32 run_once_init = 0; 
static int32 global_init_lock = -1; 
static vint32 global_init_count = 0; 
#endif 
 
static xmlRMutexPtr xmlLibraryLock = NULL; 
 
#ifdef LIBXML_THREAD_ENABLED 
static void xmlOnceInit(void); 
#endif 
 
/** 
 * xmlNewMutex: 
 * 
 * xmlNewMutex() is used to allocate a libxml2 token struct for use in 
 * synchronizing access to data. 
 * 
 * Returns a new simple mutex pointer or NULL in case of error 
 */ 
xmlMutexPtr 
xmlNewMutex(void) 
{ 
    xmlMutexPtr tok; 
 
    if ((tok = malloc(sizeof(xmlMutex))) == NULL) 
        return (NULL); 
#ifdef HAVE_PTHREAD_H 
    if (libxml_is_threaded != 0) 
        pthread_mutex_init(&tok->lock, NULL); 
#elif defined HAVE_WIN32_THREADS 
    tok->mutex = CreateMutex(NULL, FALSE, NULL); 
#elif defined HAVE_BEOS_THREADS 
    if ((tok->sem = create_sem(1, "xmlMutex")) < B_OK) { 
        free(tok); 
        return NULL; 
    } 
    tok->tid = -1; 
#endif 
    return (tok); 
} 
 
/** 
 * xmlFreeMutex: 
 * @tok:  the simple mutex 
 * 
 * xmlFreeMutex() is used to reclaim resources associated with a libxml2 token 
 * struct. 
 */ 
void 
xmlFreeMutex(xmlMutexPtr tok) 
{ 
    if (tok == NULL) 
        return; 
 
#ifdef HAVE_PTHREAD_H 
    if (libxml_is_threaded != 0) 
        pthread_mutex_destroy(&tok->lock); 
#elif defined HAVE_WIN32_THREADS 
    CloseHandle(tok->mutex); 
#elif defined HAVE_BEOS_THREADS 
    delete_sem(tok->sem); 
#endif 
    free(tok); 
} 
 
/** 
 * xmlMutexLock: 
 * @tok:  the simple mutex 
 * 
 * xmlMutexLock() is used to lock a libxml2 token. 
 */ 
void 
xmlMutexLock(xmlMutexPtr tok) 
{ 
    if (tok == NULL) 
        return; 
#ifdef HAVE_PTHREAD_H 
    if (libxml_is_threaded != 0) 
        pthread_mutex_lock(&tok->lock); 
#elif defined HAVE_WIN32_THREADS 
    WaitForSingleObject(tok->mutex, INFINITE); 
#elif defined HAVE_BEOS_THREADS 
    if (acquire_sem(tok->sem) != B_NO_ERROR) { 
#ifdef DEBUG_THREADS 
        xmlGenericError(xmlGenericErrorContext, 
                        "xmlMutexLock():BeOS:Couldn't acquire semaphore\n");
#endif 
    } 
    tok->tid = find_thread(NULL); 
#endif 
 
} 
 
/** 
 * xmlMutexUnlock: 
 * @tok:  the simple mutex 
 * 
 * xmlMutexUnlock() is used to unlock a libxml2 token. 
 */ 
void 
xmlMutexUnlock(xmlMutexPtr tok) 
{ 
    if (tok == NULL) 
        return; 
#ifdef HAVE_PTHREAD_H 
    if (libxml_is_threaded != 0) 
        pthread_mutex_unlock(&tok->lock); 
#elif defined HAVE_WIN32_THREADS 
    ReleaseMutex(tok->mutex); 
#elif defined HAVE_BEOS_THREADS 
    if (tok->tid == find_thread(NULL)) { 
        tok->tid = -1; 
        release_sem(tok->sem); 
    } 
#endif 
} 
 
/** 
 * xmlNewRMutex: 
 * 
 * xmlRNewMutex() is used to allocate a reentrant mutex for use in 
 * synchronizing access to data. token_r is a re-entrant lock and thus useful 
 * for synchronizing access to data structures that may be manipulated in a 
 * recursive fashion. 
 * 
 * Returns the new reentrant mutex pointer or NULL in case of error 
 */ 
xmlRMutexPtr 
xmlNewRMutex(void) 
{ 
    xmlRMutexPtr tok; 
 
    if ((tok = malloc(sizeof(xmlRMutex))) == NULL) 
        return (NULL); 
#ifdef HAVE_PTHREAD_H 
    if (libxml_is_threaded != 0) { 
        pthread_mutex_init(&tok->lock, NULL); 
        tok->held = 0; 
        tok->waiters = 0; 
        pthread_cond_init(&tok->cv, NULL); 
    } 
#elif defined HAVE_WIN32_THREADS 
    InitializeCriticalSection(&tok->cs); 
    tok->count = 0; 
#elif defined HAVE_BEOS_THREADS 
    if ((tok->lock = xmlNewMutex()) == NULL) { 
        free(tok); 
        return NULL; 
    } 
    tok->count = 0; 
#endif 
    return (tok); 
} 
 
/** 
 * xmlFreeRMutex: 
 * @tok:  the reentrant mutex 
 * 
 * xmlRFreeMutex() is used to reclaim resources associated with a 
 * reentrant mutex. 
 */ 
void 
xmlFreeRMutex(xmlRMutexPtr tok ATTRIBUTE_UNUSED) 
{ 
    if (tok == NULL) 
        return; 
#ifdef HAVE_PTHREAD_H 
    if (libxml_is_threaded != 0) { 
        pthread_mutex_destroy(&tok->lock); 
        pthread_cond_destroy(&tok->cv); 
    } 
#elif defined HAVE_WIN32_THREADS 
    DeleteCriticalSection(&tok->cs); 
#elif defined HAVE_BEOS_THREADS 
    xmlFreeMutex(tok->lock); 
#endif 
    free(tok); 
} 
 
/** 
 * xmlRMutexLock: 
 * @tok:  the reentrant mutex 
 * 
 * xmlRMutexLock() is used to lock a libxml2 token_r. 
 */ 
void 
xmlRMutexLock(xmlRMutexPtr tok) 
{ 
    if (tok == NULL) 
        return; 
#ifdef HAVE_PTHREAD_H 
    if (libxml_is_threaded == 0) 
        return; 
 
    pthread_mutex_lock(&tok->lock); 
    if (tok->held) { 
        if (pthread_equal(tok->tid, pthread_self())) { 
            tok->held++; 
            pthread_mutex_unlock(&tok->lock); 
            return; 
        } else { 
            tok->waiters++; 
            while (tok->held) 
                pthread_cond_wait(&tok->cv, &tok->lock); 
            tok->waiters--; 
        } 
    } 
    tok->tid = pthread_self(); 
    tok->held = 1; 
    pthread_mutex_unlock(&tok->lock); 
#elif defined HAVE_WIN32_THREADS 
    EnterCriticalSection(&tok->cs); 
    tok->count++; 
#elif defined HAVE_BEOS_THREADS 
    if (tok->lock->tid == find_thread(NULL)) { 
        tok->count++; 
        return; 
    } else { 
        xmlMutexLock(tok->lock); 
        tok->count = 1; 
    } 
#endif 
} 
 
/** 
 * xmlRMutexUnlock: 
 * @tok:  the reentrant mutex 
 * 
 * xmlRMutexUnlock() is used to unlock a libxml2 token_r. 
 */ 
void 
xmlRMutexUnlock(xmlRMutexPtr tok ATTRIBUTE_UNUSED) 
{ 
    if (tok == NULL) 
        return; 
#ifdef HAVE_PTHREAD_H 
    if (libxml_is_threaded == 0) 
        return; 
 
    pthread_mutex_lock(&tok->lock); 
    tok->held--; 
    if (tok->held == 0) { 
        if (tok->waiters) 
            pthread_cond_signal(&tok->cv); 
        memset(&tok->tid, 0, sizeof(tok->tid)); 
    } 
    pthread_mutex_unlock(&tok->lock); 
#elif defined HAVE_WIN32_THREADS 
    if (tok->count > 0) { 
	tok->count--;
        LeaveCriticalSection(&tok->cs);
    } 
#elif defined HAVE_BEOS_THREADS 
    if (tok->lock->tid == find_thread(NULL)) { 
        tok->count--; 
        if (tok->count == 0) { 
            xmlMutexUnlock(tok->lock); 
        } 
        return; 
    } 
#endif 
} 
 
/** 
 * xmlGlobalInitMutexLock 
 * 
 * Makes sure that the global initialization mutex is initialized and 
 * locks it. 
 */ 
void 
__xmlGlobalInitMutexLock(void) 
{ 
    /* Make sure the global init lock is initialized and then lock it. */ 
#ifdef HAVE_PTHREAD_H 
    /* The mutex is statically initialized, so we just lock it. */ 
#ifdef XML_PTHREAD_WEAK
    if (pthread_mutex_lock == NULL)
        return;
#endif /* XML_PTHREAD_WEAK */
    pthread_mutex_lock(&global_init_lock);
#elif defined HAVE_WIN32_THREADS 
    LPCRITICAL_SECTION cs; 
 
    /* Create a new critical section */ 
    if (global_init_lock == NULL) { 
        cs = malloc(sizeof(CRITICAL_SECTION)); 
        if (cs == NULL) { 
            xmlGenericError(xmlGenericErrorContext, 
                            "xmlGlobalInitMutexLock: out of memory\n"); 
            return; 
        } 
        InitializeCriticalSection(cs); 
 
        /* Swap it into the global_init_lock */ 
#ifdef InterlockedCompareExchangePointer 
        InterlockedCompareExchangePointer((void **) &global_init_lock,
                                          cs, NULL);
#else /* Use older void* version */ 
        InterlockedCompareExchange((void **) &global_init_lock, 
                                   (void *) cs, NULL); 
#endif /* InterlockedCompareExchangePointer */ 
 
        /* If another thread successfully recorded its critical 
         * section in the global_init_lock then discard the one 
         * allocated by this thread. */ 
        if (global_init_lock != cs) { 
            DeleteCriticalSection(cs); 
            free(cs); 
        } 
    } 
 
    /* Lock the chosen critical section */ 
    EnterCriticalSection(global_init_lock); 
#elif defined HAVE_BEOS_THREADS 
    int32 sem; 
 
    /* Allocate a new semaphore */ 
    sem = create_sem(1, "xmlGlobalinitMutex"); 
 
    while (global_init_lock == -1) { 
        if (atomic_add(&global_init_count, 1) == 0) { 
            global_init_lock = sem; 
        } else { 
            snooze(1); 
            atomic_add(&global_init_count, -1); 
        } 
    } 
 
    /* If another thread successfully recorded its critical 
     * section in the global_init_lock then discard the one 
     * allocated by this thread. */ 
    if (global_init_lock != sem) 
        delete_sem(sem); 
 
    /* Acquire the chosen semaphore */ 
    if (acquire_sem(global_init_lock) != B_NO_ERROR) { 
#ifdef DEBUG_THREADS 
        xmlGenericError(xmlGenericErrorContext, 
                        "xmlGlobalInitMutexLock():BeOS:Couldn't acquire semaphore\n"); 
#endif 
    } 
#endif 
} 
 
void 
__xmlGlobalInitMutexUnlock(void) 
{ 
#ifdef HAVE_PTHREAD_H 
#ifdef XML_PTHREAD_WEAK
    if (pthread_mutex_unlock == NULL)
        return;
#endif /* XML_PTHREAD_WEAK */
    pthread_mutex_unlock(&global_init_lock);
#elif defined HAVE_WIN32_THREADS 
    if (global_init_lock != NULL) { 
	LeaveCriticalSection(global_init_lock); 
    } 
#elif defined HAVE_BEOS_THREADS 
    release_sem(global_init_lock); 
#endif 
} 
 
/** 
 * xmlGlobalInitMutexDestroy 
 * 
 * Makes sure that the global initialization mutex is destroyed before 
 * application termination. 
 */ 
void 
__xmlGlobalInitMutexDestroy(void) 
{ 
#ifdef HAVE_PTHREAD_H 
#elif defined HAVE_WIN32_THREADS 
    if (global_init_lock != NULL) { 
        DeleteCriticalSection(global_init_lock); 
        free(global_init_lock); 
        global_init_lock = NULL; 
    } 
#endif 
} 
 
/************************************************************************ 
 *									* 
 *			Per thread global state handling		* 
 *									* 
 ************************************************************************/ 
 
#ifdef LIBXML_THREAD_ENABLED 
#ifdef xmlLastError 
#undef xmlLastError 
#endif 
 
/** 
 * xmlFreeGlobalState: 
 * @state:  a thread global state 
 * 
 * xmlFreeGlobalState() is called when a thread terminates with a non-NULL 
 * global state. It is is used here to reclaim memory resources. 
 */ 
static void 
xmlFreeGlobalState(void *state) 
{ 
    xmlGlobalState *gs = (xmlGlobalState *) state; 
 
    /* free any memory allocated in the thread's xmlLastError */ 
    xmlResetError(&(gs->xmlLastError)); 
    free(state); 
} 
 
/** 
 * xmlNewGlobalState: 
 * 
 * xmlNewGlobalState() allocates a global state. This structure is used to 
 * hold all data for use by a thread when supporting backwards compatibility 
 * of libxml2 to pre-thread-safe behaviour. 
 * 
 * Returns the newly allocated xmlGlobalStatePtr or NULL in case of error 
 */ 
static xmlGlobalStatePtr 
xmlNewGlobalState(void) 
{ 
    xmlGlobalState *gs; 
 
    gs = malloc(sizeof(xmlGlobalState)); 
    if (gs == NULL) { 
	xmlGenericError(xmlGenericErrorContext, 
			"xmlGetGlobalState: out of memory\n"); 
        return (NULL); 
    } 
 
    memset(gs, 0, sizeof(xmlGlobalState)); 
    xmlInitializeGlobalState(gs); 
    return (gs); 
} 
#endif /* LIBXML_THREAD_ENABLED */ 
 
#ifdef HAVE_PTHREAD_H 
#elif defined HAVE_WIN32_THREADS 
#if !defined(HAVE_COMPILER_TLS) 
#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL) 
typedef struct _xmlGlobalStateCleanupHelperParams { 
    HANDLE thread; 
    void *memory; 
} xmlGlobalStateCleanupHelperParams; 
 
static void XMLCDECL 
xmlGlobalStateCleanupHelper(void *p) 
{ 
    xmlGlobalStateCleanupHelperParams *params = 
        (xmlGlobalStateCleanupHelperParams *) p; 
    WaitForSingleObject(params->thread, INFINITE); 
    CloseHandle(params->thread); 
    xmlFreeGlobalState(params->memory); 
    free(params); 
    _endthread(); 
} 
#else /* LIBXML_STATIC && !LIBXML_STATIC_FOR_DLL */ 
 
typedef struct _xmlGlobalStateCleanupHelperParams { 
    void *memory; 
    struct _xmlGlobalStateCleanupHelperParams *prev; 
    struct _xmlGlobalStateCleanupHelperParams *next; 
} xmlGlobalStateCleanupHelperParams; 
 
static xmlGlobalStateCleanupHelperParams *cleanup_helpers_head = NULL; 
static CRITICAL_SECTION cleanup_helpers_cs; 
 
#endif /* LIBXMLSTATIC && !LIBXML_STATIC_FOR_DLL */ 
#endif /* HAVE_COMPILER_TLS */ 
#endif /* HAVE_WIN32_THREADS */ 
 
#if defined HAVE_BEOS_THREADS 
 
/** 
 * xmlGlobalStateCleanup: 
 * @data: unused parameter 
 * 
 * Used for Beos only 
 */ 
void 
xmlGlobalStateCleanup(void *data) 
{ 
    void *globalval = tls_get(globalkey); 
 
    if (globalval != NULL) 
        xmlFreeGlobalState(globalval); 
} 
#endif 
 
/** 
 * xmlGetGlobalState: 
 * 
 * xmlGetGlobalState() is called to retrieve the global state for a thread. 
 * 
 * Returns the thread global state or NULL in case of error 
 */ 
xmlGlobalStatePtr 
xmlGetGlobalState(void) 
{ 
#ifdef HAVE_PTHREAD_H 
    xmlGlobalState *globalval; 
 
    if (libxml_is_threaded == 0) 
        return (NULL); 
 
    pthread_once(&once_control, xmlOnceInit); 
 
    if ((globalval = (xmlGlobalState *) 
         pthread_getspecific(globalkey)) == NULL) { 
        xmlGlobalState *tsd = xmlNewGlobalState(); 
	if (tsd == NULL) 
	    return(NULL); 
 
        pthread_setspecific(globalkey, tsd); 
        return (tsd); 
    } 
    return (globalval); 
#elif defined HAVE_WIN32_THREADS 
#if defined(HAVE_COMPILER_TLS) 
    if (!tlstate_inited) { 
        tlstate_inited = 1; 
        xmlInitializeGlobalState(&tlstate); 
    } 
    return &tlstate; 
#else /* HAVE_COMPILER_TLS */ 
    xmlGlobalState *globalval; 
    xmlGlobalStateCleanupHelperParams *p; 
 
    xmlOnceInit(); 
#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL) 
    globalval = (xmlGlobalState *) TlsGetValue(globalkey); 
#else 
    p = (xmlGlobalStateCleanupHelperParams *) TlsGetValue(globalkey); 
    globalval = (xmlGlobalState *) (p ? p->memory : NULL); 
#endif 
    if (globalval == NULL) { 
        xmlGlobalState *tsd = xmlNewGlobalState(); 
 
        if (tsd == NULL) 
	    return(NULL); 
        p = (xmlGlobalStateCleanupHelperParams *) 
            malloc(sizeof(xmlGlobalStateCleanupHelperParams)); 
	if (p == NULL) { 
            xmlGenericError(xmlGenericErrorContext, 
                            "xmlGetGlobalState: out of memory\n"); 
            xmlFreeGlobalState(tsd); 
	    return(NULL); 
	} 
        p->memory = tsd; 
#if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL) 
        DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), 
                        GetCurrentProcess(), &p->thread, 0, TRUE, 
                        DUPLICATE_SAME_ACCESS); 
        TlsSetValue(globalkey, tsd); 
        _beginthread(xmlGlobalStateCleanupHelper, 0, p); 
#else 
        EnterCriticalSection(&cleanup_helpers_cs); 
        if (cleanup_helpers_head != NULL) { 
            cleanup_helpers_head->prev = p; 
        } 
        p->next = cleanup_helpers_head; 
        p->prev = NULL; 
        cleanup_helpers_head = p; 
        TlsSetValue(globalkey, p); 
        LeaveCriticalSection(&cleanup_helpers_cs); 
#endif 
 
        return (tsd); 
    } 
    return (globalval); 
#endif /* HAVE_COMPILER_TLS */ 
#elif defined HAVE_BEOS_THREADS 
    xmlGlobalState *globalval; 
 
    xmlOnceInit(); 
 
    if ((globalval = (xmlGlobalState *) tls_get(globalkey)) == NULL) { 
        xmlGlobalState *tsd = xmlNewGlobalState(); 
	if (tsd == NULL) 
	    return (NULL); 
 
        tls_set(globalkey, tsd); 
        on_exit_thread(xmlGlobalStateCleanup, NULL); 
        return (tsd); 
    } 
    return (globalval); 
#else 
    return (NULL); 
#endif 
} 
 
/************************************************************************ 
 *									* 
 *			Library wide thread interfaces			* 
 *									* 
 ************************************************************************/ 
 
/** 
 * xmlGetThreadId: 
 * 
 * xmlGetThreadId() find the current thread ID number 
 * Note that this is likely to be broken on some platforms using pthreads 
 * as the specification doesn't mandate pthread_t to be an integer type 
 * 
 * Returns the current thread ID number 
 */ 
int 
xmlGetThreadId(void) 
{ 
#ifdef HAVE_PTHREAD_H 
    pthread_t id; 
    int ret; 
 
    if (libxml_is_threaded == 0) 
        return (0); 
    id = pthread_self(); 
    /* horrible but preserves compat, see warning above */ 
    memcpy(&ret, &id, sizeof(ret)); 
    return (ret); 
#elif defined HAVE_WIN32_THREADS 
    return GetCurrentThreadId(); 
#elif defined HAVE_BEOS_THREADS 
    return find_thread(NULL); 
#else 
    return ((int) 0); 
#endif 
} 
 
/** 
 * xmlIsMainThread: 
 * 
 * xmlIsMainThread() check whether the current thread is the main thread. 
 * 
 * Returns 1 if the current thread is the main thread, 0 otherwise 
 */ 
int 
xmlIsMainThread(void) 
{ 
#ifdef HAVE_PTHREAD_H 
    if (libxml_is_threaded == -1) 
        xmlInitThreads(); 
    if (libxml_is_threaded == 0) 
        return (1); 
    pthread_once(&once_control, xmlOnceInit); 
#elif defined HAVE_WIN32_THREADS 
    xmlOnceInit(); 
#elif defined HAVE_BEOS_THREADS 
    xmlOnceInit(); 
#endif 
 
#ifdef DEBUG_THREADS 
    xmlGenericError(xmlGenericErrorContext, "xmlIsMainThread()\n"); 
#endif 
#ifdef HAVE_PTHREAD_H 
    return (pthread_equal(mainthread,pthread_self())); 
#elif defined HAVE_WIN32_THREADS 
    return (mainthread == GetCurrentThreadId()); 
#elif defined HAVE_BEOS_THREADS 
    return (mainthread == find_thread(NULL)); 
#else 
    return (1); 
#endif 
} 
 
/** 
 * xmlLockLibrary: 
 * 
 * xmlLockLibrary() is used to take out a re-entrant lock on the libxml2 
 * library. 
 */ 
void 
xmlLockLibrary(void) 
{ 
#ifdef DEBUG_THREADS 
    xmlGenericError(xmlGenericErrorContext, "xmlLockLibrary()\n"); 
#endif 
    xmlRMutexLock(xmlLibraryLock); 
} 
 
/** 
 * xmlUnlockLibrary: 
 * 
 * xmlUnlockLibrary() is used to release a re-entrant lock on the libxml2 
 * library. 
 */ 
void 
xmlUnlockLibrary(void) 
{ 
#ifdef DEBUG_THREADS 
    xmlGenericError(xmlGenericErrorContext, "xmlUnlockLibrary()\n"); 
#endif 
    xmlRMutexUnlock(xmlLibraryLock); 
} 
 
/** 
 * xmlInitThreads: 
 * 
 * xmlInitThreads() is used to to initialize all the thread related 
 * data of the libxml2 library. 
 */ 
void 
xmlInitThreads(void) 
{ 
#ifdef HAVE_PTHREAD_H 
#ifdef XML_PTHREAD_WEAK
    if (libxml_is_threaded == -1) { 
        if ((pthread_once != NULL) && 
            (pthread_getspecific != NULL) && 
            (pthread_setspecific != NULL) && 
            (pthread_key_create != NULL) && 
            (pthread_key_delete != NULL) && 
            (pthread_mutex_init != NULL) && 
            (pthread_mutex_destroy != NULL) && 
            (pthread_mutex_lock != NULL) && 
            (pthread_mutex_unlock != NULL) && 
            (pthread_cond_init != NULL) && 
            (pthread_cond_destroy != NULL) && 
            (pthread_cond_wait != NULL) && 
            (pthread_equal != NULL) && 
            (pthread_self != NULL) && 
            (pthread_cond_signal != NULL)) { 
            libxml_is_threaded = 1; 
 
/* fprintf(stderr, "Running multithreaded\n"); */ 
        } else { 
 
/* fprintf(stderr, "Running without multithread\n"); */ 
            libxml_is_threaded = 0; 
        } 
    } 
#endif /* XML_PTHREAD_WEAK */
#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL)) 
    InitializeCriticalSection(&cleanup_helpers_cs); 
#endif 
} 
 
/** 
 * xmlCleanupThreads: 
 * 
 * xmlCleanupThreads() is used to to cleanup all the thread related 
 * data of the libxml2 library once processing has ended. 
 * 
 * WARNING: if your application is multithreaded or has plugin support 
 *          calling this may crash the application if another thread or 
 *          a plugin is still using libxml2. It's sometimes very hard to 
 *          guess if libxml2 is in use in the application, some libraries 
 *          or plugins may use it without notice. In case of doubt abstain 
 *          from calling this function or do it just before calling exit() 
 *          to avoid leak reports from valgrind ! 
 */ 
void 
xmlCleanupThreads(void) 
{ 
#ifdef DEBUG_THREADS 
    xmlGenericError(xmlGenericErrorContext, "xmlCleanupThreads()\n"); 
#endif 
#ifdef HAVE_PTHREAD_H 
    if (libxml_is_threaded != 0)
        pthread_key_delete(globalkey); 
    once_control = once_control_init; 
#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL)) 
    if (globalkey != TLS_OUT_OF_INDEXES) { 
        xmlGlobalStateCleanupHelperParams *p; 
 
        EnterCriticalSection(&cleanup_helpers_cs); 
        p = cleanup_helpers_head; 
        while (p != NULL) { 
            xmlGlobalStateCleanupHelperParams *temp = p; 
 
            p = p->next; 
            xmlFreeGlobalState(temp->memory); 
            free(temp); 
        } 
        cleanup_helpers_head = 0; 
        LeaveCriticalSection(&cleanup_helpers_cs); 
        TlsFree(globalkey); 
        globalkey = TLS_OUT_OF_INDEXES; 
    } 
    DeleteCriticalSection(&cleanup_helpers_cs); 
#endif 
} 
 
#ifdef LIBXML_THREAD_ENABLED 
 
/** 
 * xmlOnceInit 
 * 
 * xmlOnceInit() is used to initialize the value of mainthread for use 
 * in other routines. This function should only be called using 
 * pthread_once() in association with the once_control variable to ensure 
 * that the function is only called once. See man pthread_once for more 
 * details. 
 */ 
static void 
xmlOnceInit(void) 
{ 
#ifdef HAVE_PTHREAD_H 
    (void) pthread_key_create(&globalkey, xmlFreeGlobalState); 
    mainthread = pthread_self(); 
    __xmlInitializeDict(); 
#elif defined(HAVE_WIN32_THREADS) 
    if (!run_once.done) { 
        if (InterlockedIncrement(&run_once.control) == 1) { 
#if !defined(HAVE_COMPILER_TLS) 
            globalkey = TlsAlloc(); 
#endif 
            mainthread = GetCurrentThreadId(); 
	    __xmlInitializeDict(); 
            run_once.done = 1; 
        } else { 
            /* Another thread is working; give up our slice and 
             * wait until they're done. */ 
            while (!run_once.done) 
                Sleep(0); 
        } 
    } 
#elif defined HAVE_BEOS_THREADS 
    if (atomic_add(&run_once_init, 1) == 0) { 
        globalkey = tls_allocate(); 
        tls_set(globalkey, NULL); 
        mainthread = find_thread(NULL); 
	__xmlInitializeDict(); 
    } else 
        atomic_add(&run_once_init, -1); 
#endif 
} 
#endif 
 
/** 
 * DllMain: 
 * @hinstDLL: handle to DLL instance 
 * @fdwReason: Reason code for entry 
 * @lpvReserved: generic pointer (depends upon reason code) 
 * 
 * Entry point for Windows library. It is being used to free thread-specific 
 * storage. 
 * 
 * Returns TRUE always 
 */ 
#ifdef HAVE_PTHREAD_H 
#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL)) 
#if defined(LIBXML_STATIC_FOR_DLL) 
int XMLCALL
xmlDllMain(ATTRIBUTE_UNUSED void *hinstDLL, unsigned long fdwReason,
           ATTRIBUTE_UNUSED void *lpvReserved)
#else 
/* declare to avoid "no previous prototype for 'DllMain'" warning */
/* Note that we do NOT want to include this function declaration in
   a public header because it's meant to be called by Windows itself,
   not a program that uses this library.  This also has to be exported. */

XMLPUBFUN BOOL WINAPI
DllMain (HINSTANCE hinstDLL,
         DWORD     fdwReason,
         LPVOID    lpvReserved);

BOOL WINAPI 
DllMain(ATTRIBUTE_UNUSED HINSTANCE hinstDLL, DWORD fdwReason,
        ATTRIBUTE_UNUSED LPVOID lpvReserved)
#endif 
{ 
    switch (fdwReason) { 
        case DLL_THREAD_DETACH: 
            if (globalkey != TLS_OUT_OF_INDEXES) { 
                xmlGlobalState *globalval = NULL; 
                xmlGlobalStateCleanupHelperParams *p = 
                    (xmlGlobalStateCleanupHelperParams *) 
                    TlsGetValue(globalkey); 
                globalval = (xmlGlobalState *) (p ? p->memory : NULL); 
                if (globalval) { 
                    xmlFreeGlobalState(globalval); 
                    TlsSetValue(globalkey, NULL); 
                } 
                if (p) { 
                    EnterCriticalSection(&cleanup_helpers_cs); 
                    if (p == cleanup_helpers_head) 
                        cleanup_helpers_head = p->next; 
                    else 
                        p->prev->next = p->next; 
                    if (p->next != NULL) 
                        p->next->prev = p->prev; 
                    LeaveCriticalSection(&cleanup_helpers_cs); 
                    free(p); 
                } 
            } 
            break; 
    } 
    return TRUE; 
} 
#endif 
#define bottom_threads 
#include "elfgcchack.h"