mirror of
https://gitlab.gnome.org/GNOME/libxml2.git
synced 2025-03-09 04:58:16 +03:00
2b0c4abb1f
On Linux, we tried to detect the presence of libpthread to disable things like locks. This questionable hack doesn't work since glibc 2.34 which merged libpthread into libc.
578 lines
13 KiB
C
578 lines
13 KiB
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 <stdlib.h>
|
|
|
|
#include <libxml/threads.h>
|
|
#include <libxml/parser.h>
|
|
#ifdef LIBXML_CATALOG_ENABLED
|
|
#include <libxml/catalog.h>
|
|
#endif
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
#include <libxml/xmlschemastypes.h>
|
|
#include <libxml/relaxng.h>
|
|
#endif
|
|
|
|
#if defined(SOLARIS)
|
|
#include <note.h>
|
|
#endif
|
|
|
|
#include "private/cata.h"
|
|
#include "private/dict.h"
|
|
#include "private/enc.h"
|
|
#include "private/globals.h"
|
|
#include "private/io.h"
|
|
#include "private/memory.h"
|
|
#include "private/threads.h"
|
|
#include "private/xpath.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 ...
|
|
*/
|
|
|
|
/*
|
|
* xmlRMutex are reentrant mutual exception locks
|
|
*/
|
|
struct _xmlRMutex {
|
|
#ifdef HAVE_POSIX_THREADS
|
|
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;
|
|
#else
|
|
int empty;
|
|
#endif
|
|
};
|
|
|
|
static xmlRMutexPtr xmlLibraryLock = NULL;
|
|
|
|
/**
|
|
* xmlInitMutex:
|
|
* @mutex: the mutex
|
|
*
|
|
* Initialize a mutex.
|
|
*/
|
|
void
|
|
xmlInitMutex(xmlMutexPtr mutex)
|
|
{
|
|
#ifdef HAVE_POSIX_THREADS
|
|
pthread_mutex_init(&mutex->lock, NULL);
|
|
#elif defined HAVE_WIN32_THREADS
|
|
InitializeCriticalSection(&mutex->cs);
|
|
#else
|
|
(void) mutex;
|
|
#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);
|
|
xmlInitMutex(tok);
|
|
return (tok);
|
|
}
|
|
|
|
/**
|
|
* xmlCleanupMutex:
|
|
* @mutex: the simple mutex
|
|
*
|
|
* Reclaim resources associated with a mutex.
|
|
*/
|
|
void
|
|
xmlCleanupMutex(xmlMutexPtr mutex)
|
|
{
|
|
#ifdef HAVE_POSIX_THREADS
|
|
pthread_mutex_destroy(&mutex->lock);
|
|
#elif defined HAVE_WIN32_THREADS
|
|
DeleteCriticalSection(&mutex->cs);
|
|
#else
|
|
(void) mutex;
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* xmlFreeMutex:
|
|
* @tok: the simple mutex
|
|
*
|
|
* Free a mutex.
|
|
*/
|
|
void
|
|
xmlFreeMutex(xmlMutexPtr tok)
|
|
{
|
|
if (tok == NULL)
|
|
return;
|
|
|
|
xmlCleanupMutex(tok);
|
|
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_POSIX_THREADS
|
|
/*
|
|
* This assumes that __libc_single_threaded won't change while the
|
|
* lock is held.
|
|
*/
|
|
pthread_mutex_lock(&tok->lock);
|
|
#elif defined HAVE_WIN32_THREADS
|
|
EnterCriticalSection(&tok->cs);
|
|
#endif
|
|
|
|
}
|
|
|
|
/**
|
|
* xmlMutexUnlock:
|
|
* @tok: the simple mutex
|
|
*
|
|
* xmlMutexUnlock() is used to unlock a libxml2 token.
|
|
*/
|
|
void
|
|
xmlMutexUnlock(xmlMutexPtr tok)
|
|
{
|
|
if (tok == NULL)
|
|
return;
|
|
#ifdef HAVE_POSIX_THREADS
|
|
pthread_mutex_unlock(&tok->lock);
|
|
#elif defined HAVE_WIN32_THREADS
|
|
LeaveCriticalSection(&tok->cs);
|
|
#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_POSIX_THREADS
|
|
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);
|
|
#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_POSIX_THREADS
|
|
pthread_mutex_destroy(&tok->lock);
|
|
pthread_cond_destroy(&tok->cv);
|
|
#elif defined HAVE_WIN32_THREADS
|
|
DeleteCriticalSection(&tok->cs);
|
|
#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_POSIX_THREADS
|
|
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);
|
|
#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_POSIX_THREADS
|
|
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
|
|
LeaveCriticalSection(&tok->cs);
|
|
#endif
|
|
}
|
|
|
|
/************************************************************************
|
|
* *
|
|
* Library wide thread interfaces *
|
|
* *
|
|
************************************************************************/
|
|
|
|
/**
|
|
* xmlGetThreadId:
|
|
*
|
|
* DEPRECATED: Internal function, do not use.
|
|
*
|
|
* 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_POSIX_THREADS
|
|
pthread_t id;
|
|
int ret;
|
|
|
|
id = pthread_self();
|
|
/* horrible but preserves compat, see warning above */
|
|
memcpy(&ret, &id, sizeof(ret));
|
|
return (ret);
|
|
#elif defined HAVE_WIN32_THREADS
|
|
return GetCurrentThreadId();
|
|
#else
|
|
return ((int) 0);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* xmlLockLibrary:
|
|
*
|
|
* xmlLockLibrary() is used to take out a re-entrant lock on the libxml2
|
|
* library.
|
|
*/
|
|
void
|
|
xmlLockLibrary(void)
|
|
{
|
|
xmlRMutexLock(xmlLibraryLock);
|
|
}
|
|
|
|
/**
|
|
* xmlUnlockLibrary:
|
|
*
|
|
* xmlUnlockLibrary() is used to release a re-entrant lock on the libxml2
|
|
* library.
|
|
*/
|
|
void
|
|
xmlUnlockLibrary(void)
|
|
{
|
|
xmlRMutexUnlock(xmlLibraryLock);
|
|
}
|
|
|
|
/**
|
|
* xmlInitThreads:
|
|
*
|
|
* DEPRECATED: Alias for xmlInitParser.
|
|
*/
|
|
void
|
|
xmlInitThreads(void)
|
|
{
|
|
xmlInitParser();
|
|
}
|
|
|
|
/**
|
|
* xmlCleanupThreads:
|
|
*
|
|
* DEPRECATED: This function is a no-op. Call xmlCleanupParser
|
|
* to free global state but see the warnings there. xmlCleanupParser
|
|
* should be only called once at program exit. In most cases, you don't
|
|
* have call cleanup functions at all.
|
|
*/
|
|
void
|
|
xmlCleanupThreads(void)
|
|
{
|
|
}
|
|
|
|
/************************************************************************
|
|
* *
|
|
* Library wide initialization *
|
|
* *
|
|
************************************************************************/
|
|
|
|
static int xmlParserInitialized = 0;
|
|
static int xmlParserInnerInitialized = 0;
|
|
|
|
|
|
#ifdef HAVE_POSIX_THREADS
|
|
static pthread_mutex_t global_init_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
#elif defined HAVE_WIN32_THREADS
|
|
static volatile LPCRITICAL_SECTION global_init_lock = NULL;
|
|
#endif
|
|
|
|
/**
|
|
* xmlGlobalInitMutexLock
|
|
*
|
|
* Makes sure that the global initialization mutex is initialized and
|
|
* locks it.
|
|
*/
|
|
static void
|
|
xmlGlobalInitMutexLock(void) {
|
|
#ifdef HAVE_POSIX_THREADS
|
|
|
|
/* The mutex is statically initialized, so we just lock it. */
|
|
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) {
|
|
fprintf(stderr, "libxml2: xmlInitParser: out of memory\n");
|
|
abort();
|
|
}
|
|
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);
|
|
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
xmlGlobalInitMutexUnlock(void) {
|
|
#ifdef HAVE_POSIX_THREADS
|
|
pthread_mutex_unlock(&global_init_lock);
|
|
#elif defined HAVE_WIN32_THREADS
|
|
if (global_init_lock != NULL)
|
|
LeaveCriticalSection(global_init_lock);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* xmlGlobalInitMutexDestroy
|
|
*
|
|
* Makes sure that the global initialization mutex is destroyed before
|
|
* application termination.
|
|
*/
|
|
static void
|
|
xmlGlobalInitMutexDestroy(void) {
|
|
#ifdef HAVE_POSIX_THREADS
|
|
#elif defined HAVE_WIN32_THREADS
|
|
if (global_init_lock != NULL) {
|
|
DeleteCriticalSection(global_init_lock);
|
|
free(global_init_lock);
|
|
global_init_lock = NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* xmlInitParser:
|
|
*
|
|
* Initialization function for the XML parser.
|
|
*
|
|
* Call once from the main thread before using the library in
|
|
* multithreaded programs.
|
|
*/
|
|
void
|
|
xmlInitParser(void) {
|
|
/*
|
|
* Note that the initialization code must not make memory allocations.
|
|
*/
|
|
if (xmlParserInitialized != 0)
|
|
return;
|
|
|
|
xmlGlobalInitMutexLock();
|
|
|
|
if (xmlParserInnerInitialized == 0) {
|
|
#if defined(_WIN32) && \
|
|
!defined(LIBXML_THREAD_ALLOC_ENABLED) && \
|
|
(!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
|
|
if (xmlFree == free)
|
|
atexit(xmlCleanupParser);
|
|
#endif
|
|
|
|
xmlInitRandom(); /* Required by xmlInitGlobalsInternal */
|
|
xmlInitMemoryInternal();
|
|
xmlInitGlobalsInternal();
|
|
xmlInitDictInternal();
|
|
xmlInitEncodingInternal();
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
xmlInitXPathInternal();
|
|
#endif
|
|
xmlInitIOCallbacks();
|
|
#ifdef LIBXML_CATALOG_ENABLED
|
|
xmlInitCatalogInternal();
|
|
#endif
|
|
|
|
xmlParserInnerInitialized = 1;
|
|
}
|
|
|
|
xmlGlobalInitMutexUnlock();
|
|
|
|
xmlParserInitialized = 1;
|
|
}
|
|
|
|
/**
|
|
* xmlCleanupParser:
|
|
*
|
|
* This function name is somewhat misleading. It does not clean up
|
|
* parser state, it cleans up memory allocated by the library itself.
|
|
* It is a cleanup function for the XML library. It tries to reclaim all
|
|
* related global memory allocated for the library processing.
|
|
* It doesn't deallocate any document related memory. One should
|
|
* call xmlCleanupParser() only when the process has finished using
|
|
* the library and all XML/HTML documents built with it.
|
|
* See also xmlInitParser() which has the opposite function of preparing
|
|
* the library for operations.
|
|
*
|
|
* 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
|
|
xmlCleanupParser(void) {
|
|
if (!xmlParserInitialized)
|
|
return;
|
|
|
|
/* These functions can call xmlFree. */
|
|
|
|
xmlCleanupCharEncodingHandlers();
|
|
#ifdef LIBXML_CATALOG_ENABLED
|
|
xmlCatalogCleanup();
|
|
xmlCleanupCatalogInternal();
|
|
#endif
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
xmlSchemaCleanupTypes();
|
|
xmlRelaxNGCleanupTypes();
|
|
#endif
|
|
|
|
/* These functions should never call xmlFree. */
|
|
|
|
xmlCleanupDictInternal();
|
|
xmlCleanupRandom();
|
|
xmlCleanupGlobalsInternal();
|
|
/*
|
|
* Must come last. On Windows, xmlCleanupGlobalsInternal can call
|
|
* xmlFree which uses xmlMemMutex in debug mode.
|
|
*/
|
|
xmlCleanupMemoryInternal();
|
|
|
|
xmlGlobalInitMutexDestroy();
|
|
|
|
xmlParserInitialized = 0;
|
|
xmlParserInnerInitialized = 0;
|
|
}
|
|
|
|
#if defined(HAVE_ATTRIBUTE_DESTRUCTOR) && \
|
|
!defined(LIBXML_THREAD_ALLOC_ENABLED) && \
|
|
!defined(LIBXML_STATIC) && \
|
|
!defined(_WIN32)
|
|
static void
|
|
ATTRIBUTE_DESTRUCTOR
|
|
xmlDestructor(void) {
|
|
/*
|
|
* Calling custom deallocation functions in a destructor can cause
|
|
* problems, for example with Nokogiri.
|
|
*/
|
|
if (xmlFree == free)
|
|
xmlCleanupParser();
|
|
}
|
|
#endif
|
|
|