shaba/libxml2
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/libxml2.git synced 2024-12-25 23:21:26 +03:00
Code
7e511f35f1
libxml2/threads.c
Nick Wellnhofer b2dbcc432b io: Rework default callbacks 
Register a dummy callback struct for default callbacks. Handle them in a
separate function which will later allow to return meaningful error
codes.
2023-12-21 15:02:24 +01:00

672 lines
16 KiB
C
Raw Blame History

/**
* 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/dict.h"
#include "private/enc.h"
#include "private/globals.h"
#include "private/memory.h"
#include "private/threads.h"
#include "private/xpath.h"
#if defined(HAVE_POSIX_THREADS) && \
defined(__GLIBC__) && \
__GLIBC__ * 100 + __GLIBC_MINOR__ >= 234
/*
* The modern way available since glibc 2.32.
*
* The check above is for glibc 2.34 which merged the pthread symbols into
* libc. Since we still allow linking without pthread symbols (see below),
* this only works if pthread symbols are guaranteed to be available.
*/
#include <sys/single_threaded.h>
#define XML_IS_THREADED() (!__libc_single_threaded)
#define XML_IS_NEVER_THREADED() 0
#elif defined(HAVE_POSIX_THREADS) && \
defined(__GLIBC__) && \
defined(__GNUC__)
/*
* The traditional way to check for single-threaded applications with
* glibc was to check whether the separate libpthread library is
* linked in. This works by not linking libxml2 with libpthread (see
* BASE_THREAD_LIBS in configure.ac and Makefile.am) and declaring
* pthread functions as weak symbols.
*
* In glibc 2.34, the pthread symbols were moved from libpthread to libc,
* so this doesn't work anymore.
*
* At some point, this legacy code and the BASE_THREAD_LIBS hack in
* configure.ac can probably be removed.
*/
#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_cond_signal
#define XML_PTHREAD_WEAK
#define XML_IS_THREADED() libxml_is_threaded
#define XML_IS_NEVER_THREADED() (!libxml_is_threaded)
static int libxml_is_threaded = -1;
#else /* other POSIX platforms */
#define XML_IS_THREADED() 1
#define XML_IS_NEVER_THREADED() 0
#endif
/*
* 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
if (XML_IS_NEVER_THREADED() == 0)
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
if (XML_IS_NEVER_THREADED() == 0)
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.
*/
if (XML_IS_THREADED() != 0)
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
if (XML_IS_THREADED() != 0)
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
if (XML_IS_NEVER_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);
#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
if (XML_IS_NEVER_THREADED() == 0) {
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
if (XML_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);
#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
if (XML_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
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;
if (XML_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();
#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
#ifdef XML_PTHREAD_WEAK
/*
* This is somewhat unreliable since libpthread could be loaded
* later with dlopen() and threads could be created. But it's
* long-standing behavior and hard to work around.
*/
if (libxml_is_threaded == -1)
libxml_is_threaded =
(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 can be inline, resuting in -Waddress warnings.
* Let's assume it's available if all the other functions are.
*/
/* (pthread_equal != NULL) && */
(pthread_self != NULL) &&
(pthread_cond_signal != NULL);
#endif
/* The mutex is statically initialized, so we just lock it. */
if (XML_IS_THREADED() != 0)
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
if (XML_IS_THREADED() != 0)
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
xmlInitMemoryInternal(); /* Should come second */
xmlInitGlobalsInternal();
xmlInitRandom();
xmlInitDictInternal();
xmlInitEncodingInternal();
#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
xmlInitXPathInternal();
#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();
#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
View Git Blame Copy Permalink