From 65d381f32c0d2cb2361055fddbd5c4a9119031d1 Mon Sep 17 00:00:00 2001 From: Nick Wellnhofer Date: Thu, 24 Nov 2022 20:54:18 +0100 Subject: [PATCH] threads: Allocate mutexes statically --- dict.c | 27 +++++------ globals.c | 96 ++++++++++++++++++--------------------- include/private/threads.h | 32 +++++++++++++ threads.c | 80 ++++++++++++++++---------------- xmlmemory.c | 60 ++++++++++++------------ 5 files changed, 153 insertions(+), 142 deletions(-) diff --git a/dict.c b/dict.c index 2cc9ce06..13353872 100644 --- a/dict.c +++ b/dict.c @@ -24,6 +24,7 @@ #include #include "private/dict.h" +#include "private/threads.h" /* * Following http://www.ocert.org/advisories/ocert-2011-003.html @@ -129,7 +130,7 @@ struct _xmlDict { * A mutex for modifying the reference counter for shared * dictionaries. */ -static xmlMutexPtr xmlDictMutex = NULL; +static xmlMutex xmlDictMutex; #ifdef DICT_RANDOMIZATION #ifdef HAVE_RAND_R @@ -155,14 +156,9 @@ int xmlInitializeDict(void) { * * This function is not public * Do the dictionary mutex initialization. - * - * Returns 0 if initialization was already done, and 1 if that - * call led to the initialization */ int __xmlInitializeDict(void) { - if ((xmlDictMutex = xmlNewMutex()) == NULL) - return(0); - xmlMutexLock(xmlDictMutex); + xmlInitMutex(&xmlDictMutex); #ifdef DICT_RANDOMIZATION #ifdef HAVE_RAND_R @@ -172,7 +168,6 @@ int __xmlInitializeDict(void) { srand(time(NULL)); #endif #endif - xmlMutexUnlock(xmlDictMutex); return(1); } @@ -180,13 +175,13 @@ int __xmlInitializeDict(void) { int __xmlRandom(void) { int ret; - xmlMutexLock(xmlDictMutex); + xmlMutexLock(&xmlDictMutex); #ifdef HAVE_RAND_R ret = rand_r(& rand_seed); #else ret = rand(); #endif - xmlMutexUnlock(xmlDictMutex); + xmlMutexUnlock(&xmlDictMutex); return(ret); } #endif @@ -210,7 +205,7 @@ xmlDictCleanup(void) { */ void xmlCleanupDictInternal(void) { - xmlFreeMutex(xmlDictMutex); + xmlCleanupMutex(&xmlDictMutex); } /* @@ -627,9 +622,9 @@ xmlDictCreateSub(xmlDictPtr sub) { int xmlDictReference(xmlDictPtr dict) { if (dict == NULL) return -1; - xmlMutexLock(xmlDictMutex); + xmlMutexLock(&xmlDictMutex); dict->ref_counter++; - xmlMutexUnlock(xmlDictMutex); + xmlMutexUnlock(&xmlDictMutex); return(0); } @@ -787,14 +782,14 @@ xmlDictFree(xmlDictPtr dict) { return; /* decrement the counter, it may be shared by a parser and docs */ - xmlMutexLock(xmlDictMutex); + xmlMutexLock(&xmlDictMutex); dict->ref_counter--; if (dict->ref_counter > 0) { - xmlMutexUnlock(xmlDictMutex); + xmlMutexUnlock(&xmlDictMutex); return; } - xmlMutexUnlock(xmlDictMutex); + xmlMutexUnlock(&xmlDictMutex); if (dict->subdict != NULL) { xmlDictFree(dict->subdict); diff --git a/globals.c b/globals.c index 8d9c103a..c3e10a76 100644 --- a/globals.c +++ b/globals.c @@ -40,7 +40,7 @@ /* * Mutex to protect "ForNewThreads" variables */ -static xmlMutexPtr xmlThrDefMutex = NULL; +static xmlMutex xmlThrDefMutex; /** * xmlInitGlobals: @@ -57,8 +57,7 @@ void xmlInitGlobals(void) { * Additional initialisation for multi-threading */ void xmlInitGlobalsInternal(void) { - if (xmlThrDefMutex == NULL) - xmlThrDefMutex = xmlNewMutex(); + xmlInitMutex(&xmlThrDefMutex); } /************************************************************************ @@ -508,13 +507,7 @@ xmlInitializeGlobalState(xmlGlobalStatePtr gs) (void *) gs, xmlGetThreadId()); #endif - /* - * Perform initialization as required by libxml - */ - if (xmlThrDefMutex == NULL) - xmlInitGlobalsInternal(); - - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_LEGACY_ENABLED) && defined(LIBXML_SAX1_ENABLED) inithtmlDefaultSAXHandler(&gs->htmlDefaultSAXHandler); @@ -569,7 +562,7 @@ xmlInitializeGlobalState(xmlGlobalStatePtr gs) gs->xmlOutputBufferCreateFilenameValue = xmlOutputBufferCreateFilenameValueThrDef; memset(&gs->xmlLastError, 0, sizeof(xmlError)); - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); } /** @@ -591,30 +584,27 @@ void xmlCleanupGlobals(void) { void xmlCleanupGlobalsInternal(void) { xmlResetError(&xmlLastError); - if (xmlThrDefMutex != NULL) { - xmlFreeMutex(xmlThrDefMutex); - xmlThrDefMutex = NULL; - } + xmlCleanupMutex(&xmlThrDefMutex); __xmlGlobalInitMutexDestroy(); } void xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) { - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); xmlGenericErrorContextThrDef = ctx; if (handler != NULL) xmlGenericErrorThrDef = handler; else xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); } void xmlThrDefSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) { - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); xmlStructuredErrorContextThrDef = ctx; xmlStructuredErrorThrDef = handler; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); } /** @@ -640,12 +630,12 @@ xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func) { xmlRegisterNodeFunc old; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); old = xmlRegisterNodeDefaultValueThrDef; __xmlRegisterCallbacks = 1; xmlRegisterNodeDefaultValueThrDef = func; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return(old); } @@ -673,12 +663,12 @@ xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func) { xmlDeregisterNodeFunc old; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); old = xmlDeregisterNodeDefaultValueThrDef; __xmlRegisterCallbacks = 1; xmlDeregisterNodeDefaultValueThrDef = func; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return(old); } @@ -688,14 +678,14 @@ xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilena { xmlParserInputBufferCreateFilenameFunc old; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); old = xmlParserInputBufferCreateFilenameValueThrDef; if (old == NULL) { old = __xmlParserInputBufferCreateFilename; } xmlParserInputBufferCreateFilenameValueThrDef = func; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return(old); } @@ -705,7 +695,7 @@ xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc fun { xmlOutputBufferCreateFilenameFunc old; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); old = xmlOutputBufferCreateFilenameValueThrDef; #ifdef LIBXML_OUTPUT_ENABLED if (old == NULL) { @@ -713,7 +703,7 @@ xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc fun } #endif xmlOutputBufferCreateFilenameValueThrDef = func; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return(old); } @@ -816,10 +806,10 @@ __xmlBufferAllocScheme(void) { } xmlBufferAllocationScheme xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v) { xmlBufferAllocationScheme ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlBufferAllocSchemeThrDef; xmlBufferAllocSchemeThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -833,10 +823,10 @@ __xmlDefaultBufferSize(void) { } int xmlThrDefDefaultBufferSize(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlDefaultBufferSizeThrDef; xmlDefaultBufferSizeThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -870,10 +860,10 @@ __xmlDoValidityCheckingDefaultValue(void) { } int xmlThrDefDoValidityCheckingDefaultValue(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlDoValidityCheckingDefaultValueThrDef; xmlDoValidityCheckingDefaultValueThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -923,10 +913,10 @@ __xmlGetWarningsDefaultValue(void) { } int xmlThrDefGetWarningsDefaultValue(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlGetWarningsDefaultValueThrDef; xmlGetWarningsDefaultValueThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -940,10 +930,10 @@ __xmlIndentTreeOutput(void) { } int xmlThrDefIndentTreeOutput(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlIndentTreeOutputThrDef; xmlIndentTreeOutputThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -957,10 +947,10 @@ __xmlTreeIndentString(void) { } const char * xmlThrDefTreeIndentString(const char * v) { const char * ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlTreeIndentStringThrDef; xmlTreeIndentStringThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -974,10 +964,10 @@ __xmlKeepBlanksDefaultValue(void) { } int xmlThrDefKeepBlanksDefaultValue(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlKeepBlanksDefaultValueThrDef; xmlKeepBlanksDefaultValueThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -991,10 +981,10 @@ __xmlLineNumbersDefaultValue(void) { } int xmlThrDefLineNumbersDefaultValue(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlLineNumbersDefaultValueThrDef; xmlLineNumbersDefaultValueThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -1008,10 +998,10 @@ __xmlLoadExtDtdDefaultValue(void) { } int xmlThrDefLoadExtDtdDefaultValue(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlLoadExtDtdDefaultValueThrDef; xmlLoadExtDtdDefaultValueThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -1025,10 +1015,10 @@ __xmlParserDebugEntities(void) { } int xmlThrDefParserDebugEntities(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlParserDebugEntitiesThrDef; xmlParserDebugEntitiesThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -1051,10 +1041,10 @@ __xmlPedanticParserDefaultValue(void) { } int xmlThrDefPedanticParserDefaultValue(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlPedanticParserDefaultValueThrDef; xmlPedanticParserDefaultValueThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -1068,10 +1058,10 @@ __xmlSaveNoEmptyTags(void) { } int xmlThrDefSaveNoEmptyTags(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlSaveNoEmptyTagsThrDef; xmlSaveNoEmptyTagsThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } @@ -1085,10 +1075,10 @@ __xmlSubstituteEntitiesDefaultValue(void) { } int xmlThrDefSubstituteEntitiesDefaultValue(int v) { int ret; - xmlMutexLock(xmlThrDefMutex); + xmlMutexLock(&xmlThrDefMutex); ret = xmlSubstituteEntitiesDefaultValueThrDef; xmlSubstituteEntitiesDefaultValueThrDef = v; - xmlMutexUnlock(xmlThrDefMutex); + xmlMutexUnlock(&xmlThrDefMutex); return ret; } diff --git a/include/private/threads.h b/include/private/threads.h index 59dbab10..efb64cf0 100644 --- a/include/private/threads.h +++ b/include/private/threads.h @@ -1,6 +1,35 @@ #ifndef XML_THREADS_H_PRIVATE__ #define XML_THREADS_H_PRIVATE__ +#include + +#ifdef LIBXML_THREAD_ENABLED + #ifdef HAVE_PTHREAD_H + #include + #define HAVE_POSIX_THREADS + #elif defined(_WIN32) + #define WIN32_LEAN_AND_MEAN + #include + #ifndef HAVE_COMPILER_TLS + #include + #endif + #define HAVE_WIN32_THREADS + #endif +#endif + +/* + * xmlMutex are a simple mutual exception locks + */ +struct _xmlMutex { +#ifdef HAVE_POSIX_THREADS + pthread_mutex_t lock; +#elif defined HAVE_WIN32_THREADS + CRITICAL_SECTION cs; +#else + int empty; +#endif +}; + void __xmlGlobalInitMutexLock(void); void __xmlGlobalInitMutexUnlock(void); void __xmlGlobalInitMutexDestroy(void); @@ -8,4 +37,7 @@ void __xmlGlobalInitMutexDestroy(void); void xmlInitThreadsInternal(void); void xmlCleanupThreadsInternal(void); +void xmlInitMutex(xmlMutexPtr mutex); +void xmlCleanupMutex(xmlMutexPtr mutex); + #endif /* XML_THREADS_H_PRIVATE__ */ diff --git a/threads.c b/threads.c index 69dfcffd..b2662e21 100644 --- a/threads.c +++ b/threads.c @@ -16,20 +16,6 @@ #include #include -#ifdef LIBXML_THREAD_ENABLED - #ifdef HAVE_PTHREAD_H - #include - #define HAVE_POSIX_THREADS - #elif defined(_WIN32) - #define WIN32_LEAN_AND_MEAN - #include - #ifndef HAVE_COMPILER_TLS - #include - #endif - #define HAVE_WIN32_THREADS - #endif -#endif - #if defined(SOLARIS) #include #endif @@ -78,19 +64,6 @@ static int libxml_is_threaded = 1; * be hosted on allocated blocks needing them for the allocation ... */ -/* - * xmlMutex are a simple mutual exception locks - */ -struct _xmlMutex { -#ifdef HAVE_POSIX_THREADS - pthread_mutex_t lock; -#elif defined HAVE_WIN32_THREADS - CRITICAL_SECTION cs; -#else - int empty; -#endif -}; - /* * xmlRMutex are reentrant mutual exception locks */ @@ -131,6 +104,24 @@ static volatile LPCRITICAL_SECTION global_init_lock = NULL; 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: * @@ -146,21 +137,33 @@ xmlNewMutex(void) if ((tok = malloc(sizeof(xmlMutex))) == NULL) return (NULL); -#ifdef HAVE_POSIX_THREADS - if (libxml_is_threaded != 0) - pthread_mutex_init(&tok->lock, NULL); -#elif defined HAVE_WIN32_THREADS - InitializeCriticalSection(&tok->cs); -#endif + 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 * - * xmlFreeMutex() is used to reclaim resources associated with a libxml2 token - * struct. + * Free a mutex. */ void xmlFreeMutex(xmlMutexPtr tok) @@ -168,12 +171,7 @@ xmlFreeMutex(xmlMutexPtr tok) if (tok == NULL) return; -#ifdef HAVE_POSIX_THREADS - if (libxml_is_threaded != 0) - pthread_mutex_destroy(&tok->lock); -#elif defined HAVE_WIN32_THREADS - DeleteCriticalSection(&tok->cs); -#endif + xmlCleanupMutex(tok); free(tok); } diff --git a/xmlmemory.c b/xmlmemory.c index 7304f197..fed39f94 100644 --- a/xmlmemory.c +++ b/xmlmemory.c @@ -32,11 +32,12 @@ #include #include "private/memory.h" +#include "private/threads.h" static unsigned long debugMemSize = 0; static unsigned long debugMemBlocks = 0; static unsigned long debugMaxMemSize = 0; -static xmlMutexPtr xmlMemMutex = NULL; +static xmlMutex xmlMemMutex; void xmlMallocBreakpoint(void); @@ -176,7 +177,7 @@ xmlMallocLoc(size_t size, const char * file, int line) p->mh_type = MALLOC_TYPE; p->mh_file = file; p->mh_line = line; - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); p->mh_number = ++block; debugMemSize += size; debugMemBlocks++; @@ -184,7 +185,7 @@ xmlMallocLoc(size_t size, const char * file, int line) #ifdef MEM_LIST debugmem_list_add(p); #endif - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); #ifdef DEBUG_MEMORY xmlGenericError(xmlGenericErrorContext, @@ -252,7 +253,7 @@ xmlMallocAtomicLoc(size_t size, const char * file, int line) p->mh_type = MALLOC_ATOMIC_TYPE; p->mh_file = file; p->mh_line = line; - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); p->mh_number = ++block; debugMemSize += size; debugMemBlocks++; @@ -260,7 +261,7 @@ xmlMallocAtomicLoc(size_t size, const char * file, int line) #ifdef MEM_LIST debugmem_list_add(p); #endif - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); #ifdef DEBUG_MEMORY xmlGenericError(xmlGenericErrorContext, @@ -332,7 +333,7 @@ xmlReallocLoc(void *ptr,size_t size, const char * file, int line) goto error; } p->mh_tag = ~MEMTAG; - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); debugMemSize -= p->mh_size; debugMemBlocks--; #ifdef DEBUG_MEMORY @@ -341,7 +342,7 @@ xmlReallocLoc(void *ptr,size_t size, const char * file, int line) #ifdef MEM_LIST debugmem_list_delete(p); #endif - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); if (size > (MAX_SIZE_T - RESERVE_SIZE)) { xmlGenericError(xmlGenericErrorContext, @@ -369,14 +370,14 @@ xmlReallocLoc(void *ptr,size_t size, const char * file, int line) p->mh_size = size; p->mh_file = file; p->mh_line = line; - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); debugMemSize += size; debugMemBlocks++; if (debugMemSize > debugMaxMemSize) debugMaxMemSize = debugMemSize; #ifdef MEM_LIST debugmem_list_add(p); #endif - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); TEST_POINT @@ -447,7 +448,7 @@ xmlMemFree(void *ptr) if (xmlMemStopAtBlock == p->mh_number) xmlMallocBreakpoint(); p->mh_tag = ~MEMTAG; memset(target, -1, p->mh_size); - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); debugMemSize -= p->mh_size; debugMemBlocks--; #ifdef DEBUG_MEMORY @@ -456,7 +457,7 @@ xmlMemFree(void *ptr) #ifdef MEM_LIST debugmem_list_delete(p); #endif - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); free(p); @@ -513,7 +514,7 @@ xmlMemStrdupLoc(const char *str, const char *file, int line) p->mh_type = STRDUP_TYPE; p->mh_file = file; p->mh_line = line; - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); p->mh_number = ++block; debugMemSize += size; debugMemBlocks++; @@ -521,7 +522,7 @@ xmlMemStrdupLoc(const char *str, const char *file, int line) #ifdef MEM_LIST debugmem_list_add(p); #endif - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); s = (char *) HDR_2_CLIENT(p); @@ -569,9 +570,9 @@ int xmlMemUsed(void) { int res; - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); res = debugMemSize; - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); return(res); } @@ -587,9 +588,9 @@ int xmlMemBlocks(void) { int res; - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); res = debugMemBlocks; - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); return(res); } @@ -689,7 +690,7 @@ xmlMemDisplayLast(FILE *fp, long nbBytes) nbBytes, debugMemSize, debugMaxMemSize); fprintf(fp,"BLOCK NUMBER SIZE TYPE\n"); idx = 0; - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); p = memlist; while ((p) && (nbBytes > 0)) { fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number, @@ -702,7 +703,7 @@ xmlMemDisplayLast(FILE *fp, long nbBytes) case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break; default: fprintf(fp,"Unknown memory block, may be corrupted"); - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); if (old_fp == NULL) fclose(fp); return; @@ -720,7 +721,7 @@ xmlMemDisplayLast(FILE *fp, long nbBytes) nbBytes -= (unsigned long)p->mh_size; p = p->mh_next; } - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); #else fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n"); #endif @@ -766,7 +767,7 @@ xmlMemDisplay(FILE *fp) debugMemSize, debugMaxMemSize); fprintf(fp,"BLOCK NUMBER SIZE TYPE\n"); idx = 0; - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); p = memlist; while (p) { fprintf(fp,"%-5u %6lu %6lu ",idx++,p->mh_number, @@ -779,7 +780,7 @@ xmlMemDisplay(FILE *fp) case REALLOC_ATOMIC_TYPE:fprintf(fp,"atomicrealloc() in ");break; default: fprintf(fp,"Unknown memory block, may be corrupted"); - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); if (old_fp == NULL) fclose(fp); return; @@ -796,7 +797,7 @@ xmlMemDisplay(FILE *fp) fprintf(fp,"\n"); p = p->mh_next; } - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); #else fprintf(fp,"Memory list not compiled (MEM_LIST not defined !)\n"); #endif @@ -873,7 +874,7 @@ xmlMemShow(FILE *fp, int nr ATTRIBUTE_UNUSED) fprintf(fp," MEMORY ALLOCATED : %lu, MAX was %lu\n", debugMemSize, debugMaxMemSize); #ifdef MEM_LIST - xmlMutexLock(xmlMemMutex); + xmlMutexLock(&xmlMemMutex); if (nr > 0) { fprintf(fp,"NUMBER SIZE TYPE WHERE\n"); p = memlist; @@ -897,7 +898,7 @@ xmlMemShow(FILE *fp, int nr ATTRIBUTE_UNUSED) p = p->mh_next; } } - xmlMutexUnlock(xmlMemMutex); + xmlMutexUnlock(&xmlMemMutex); #endif /* MEM_LIST */ } @@ -958,11 +959,7 @@ xmlInitMemoryInternal(void) { xmlGenericError(xmlGenericErrorContext, "xmlInitMemory()\n"); #endif - /* - This is really not good code (see Bug 130419). Suggestions for - improvement will be welcome! - */ - xmlMemMutex = xmlNewMutex(); + xmlInitMutex(&xmlMemMutex); breakpoint = getenv("XML_MEM_BREAKPOINT"); if (breakpoint != NULL) { @@ -1004,8 +1001,7 @@ xmlCleanupMemoryInternal(void) { "xmlCleanupMemory()\n"); #endif - xmlFreeMutex(xmlMemMutex); - xmlMemMutex = NULL; + xmlCleanupMutex(&xmlMemMutex); #ifdef DEBUG_MEMORY xmlGenericError(xmlGenericErrorContext, "xmlCleanupMemory() Ok\n");