threads.c 11.7 KB
Newer Older
1 2 3 4 5 6 7 8 9
/**
 * 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
 */

10
#define IN_LIBXML
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
#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>
#endif
30

31 32
#ifdef HAVE_WIN32_THREADS
#include <windows.h>
33
#ifndef HAVE_COMPILER_TLS
34 35 36
#include <process.h>
#endif
#endif
37 38 39 40 41

#if defined(SOLARIS)
#include <note.h>
#endif

42
/* #define DEBUG_THREADS */
43 44 45 46 47 48 49 50 51 52 53 54 55

/*
 * TODO: this module still uses malloc/free and not xmlMalloc/xmlFree
 *       to avoid some crazyness 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;
56
#elif defined HAVE_WIN32_THREADS
57
    HANDLE mutex;
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
#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;
73
#elif defined HAVE_WIN32_THREADS
74 75
    CRITICAL_SECTION cs;
    unsigned int count;
76 77 78 79 80 81 82 83 84
#else
    int empty;
#endif
};
/*
 * This module still has some internal static data.
 *   - xmlLibraryLock a global lock
 *   - globalkey used for per-thread data
 */
85

86 87
#ifdef HAVE_PTHREAD_H
static pthread_key_t	globalkey;
88
static pthread_t	mainthread;
89
static pthread_once_t once_control = PTHREAD_ONCE_INIT;
90
#elif defined HAVE_WIN32_THREADS
91 92 93 94
#if defined(HAVE_COMPILER_TLS)
static __declspec(thread) xmlGlobalState tlstate;
static __declspec(thread) int tlstate_inited = 0;
#else /* HAVE_COMPILER_TLS */
95
static DWORD globalkey;
96
#endif /* HAVE_COMPILER_TLS */
97 98 99
static DWORD mainthread;
static int run_once_init = 1;
#endif /* HAVE_WIN32_THREADS */
100

101
static xmlRMutexPtr	xmlLibraryLock = NULL;
102
static void xmlOnceInit(void);
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120

/**
 * xmlMutexPtr:
 *
 * 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
    pthread_mutex_init(&tok->lock, NULL);
121
#elif defined HAVE_WIN32_THREADS
122
    tok->mutex = CreateMutex(NULL, FALSE, NULL);
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
#endif
    return (tok);
}

/**
 * xmlFreeMutex:
 * @tok:  the simple mutex
 *
 * xmlFreeMutex() is used to reclaim resources associated with a libxml2 token
 * struct.
 */
void
xmlFreeMutex(xmlMutexPtr tok)
{
#ifdef HAVE_PTHREAD_H
    pthread_mutex_destroy(&tok->lock);
139
#elif defined HAVE_WIN32_THREADS
140
    CloseHandle(tok->mutex);
141 142 143 144 145 146 147 148 149 150 151
#endif
    free(tok);
}

/**
 * xmlMutexLock:
 * @tok:  the simple mutex
 *
 * xmlMutexLock() is used to lock a libxml2 token.
 */
void
152
xmlMutexLock(xmlMutexPtr tok ATTRIBUTE_UNUSED)
153 154 155
{
#ifdef HAVE_PTHREAD_H
    pthread_mutex_lock(&tok->lock);
156
#elif defined HAVE_WIN32_THREADS
157
    WaitForSingleObject(tok->mutex, INFINITE);
158 159 160 161 162 163 164 165 166 167 168
#endif

}

/**
 * xmlMutexUnlock:
 * @tok:  the simple mutex
 *
 * xmlMutexUnlock() is used to unlock a libxml2 token.
 */
void
169
xmlMutexUnlock(xmlMutexPtr tok ATTRIBUTE_UNUSED)
170 171 172
{
#ifdef HAVE_PTHREAD_H
    pthread_mutex_unlock(&tok->lock);
173
#elif defined HAVE_WIN32_THREADS
174
    ReleaseMutex(tok->mutex);
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
#endif
}

/**
 * xmlRNewMutex:
 *
 * 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
    pthread_mutex_init(&tok->lock, NULL);
    tok->held = 0;
    tok->waiters = 0;
199
#elif defined HAVE_WIN32_THREADS
200 201
    InitializeCriticalSection(&tok->cs);
    tok->count = 0;
202 203 204 205 206 207 208 209 210 211 212 213
#endif
    return (tok);
}

/**
 * xmlRFreeMutex:
 * @tok:  the reentrant mutex
 *
 * xmlRFreeMutex() is used to reclaim resources associated with a
 * reentrant mutex.
 */
void
214
xmlFreeRMutex(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
215 216 217
{
#ifdef HAVE_PTHREAD_H
    pthread_mutex_destroy(&tok->lock);
218
#elif defined HAVE_WIN32_THREADS
219
    DeleteCriticalSection(&tok->cs);
220 221 222 223 224 225 226 227 228 229 230
#endif
    free(tok);
}

/**
 * xmlRMutexLock:
 * @tok:  the reentrant mutex
 *
 * xmlRMutexLock() is used to lock a libxml2 token_r.
 */
void
231
xmlRMutexLock(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
{
#ifdef HAVE_PTHREAD_H
    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);
250
#elif defined HAVE_WIN32_THREADS
251 252
    EnterCriticalSection(&tok->cs);
    ++tok->count;
253 254 255 256 257 258 259 260 261 262
#endif
}

/**
 * xmlRMutexUnlock:
 * @tok:  the reentrant mutex
 *
 * xmlRMutexUnlock() is used to unlock a libxml2 token_r.
 */
void
263
xmlRMutexUnlock(xmlRMutexPtr tok ATTRIBUTE_UNUSED)
264 265 266 267 268 269 270 271 272 273
{
#ifdef HAVE_PTHREAD_H
    pthread_mutex_lock(&tok->lock);
    tok->held--;
    if (tok->held == 0) {
        if (tok->waiters)
            pthread_cond_signal(&tok->cv);
        tok->tid = 0;
    }
    pthread_mutex_unlock(&tok->lock);
274
#elif defined HAVE_WIN32_THREADS
275 276
    if (!--tok->count) 
	LeaveCriticalSection(&tok->cs);
277 278 279 280 281 282 283 284 285
#endif
}

/************************************************************************
 *									*
 *			Per thread global state handling		*
 *									*
 ************************************************************************/

286
#ifdef LIBXML_THREAD_ENABLED
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
/**
 * 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)
{
    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
305
 * of libxml2 to pre-thread-safe behaviour.
306 307 308 309 310 311 312 313 314 315 316 317
 *
 * Returns the newly allocated xmlGlobalStatePtr or NULL in case of error
 */
static xmlGlobalStatePtr
xmlNewGlobalState(void)
{
    xmlGlobalState *gs;
    
    gs = malloc(sizeof(xmlGlobalState));
    if (gs == NULL)
	return(NULL);

William M. Brack's avatar
William M. Brack committed
318
    memset(gs, 0, sizeof(xmlGlobalState));
319 320 321
    xmlInitializeGlobalState(gs);
    return (gs);
}
322
#endif /* LIBXML_THREAD_ENABLED */
323 324 325 326 327 328 329 330 331


/**
 * xmlGetGlobalState:
 *
 * xmlGetGlobalState() is called to retrieve the global state for a thread.
 *
 * Returns the thread global state or NULL in case of error
 */
332 333

#ifdef HAVE_WIN32_THREADS
334
#if !defined(HAVE_COMPILER_TLS)
335 336
typedef struct _xmlGlobalStateCleanupHelperParams
{
337 338
    HANDLE thread;
    void *memory;
339 340
} xmlGlobalStateCleanupHelperParams;

341
void xmlGlobalStateCleanupHelper (void *p)
342
{
343 344 345 346 347 348
    xmlGlobalStateCleanupHelperParams *params = (xmlGlobalStateCleanupHelperParams *) p;
    WaitForSingleObject(params->thread, INFINITE);
    CloseHandle(params->thread);
    xmlFreeGlobalState(params->memory);
    free(params);
    _endthread();
349
}
350
#endif /* HAVE_COMPILER_TLS */
351 352
#endif /* HAVE_WIN32_THREADS */

353 354 355 356 357 358
xmlGlobalStatePtr
xmlGetGlobalState(void)
{
#ifdef HAVE_PTHREAD_H
    xmlGlobalState *globalval;

359 360
    pthread_once(&once_control, xmlOnceInit);

361
    if ((globalval = (xmlGlobalState *)
362
		pthread_getspecific(globalkey)) == NULL) {
363 364 365 366
        xmlGlobalState *tsd = xmlNewGlobalState();

        pthread_setspecific(globalkey, tsd);
        return (tsd);
367 368
    }
    return (globalval);
369
#elif defined HAVE_WIN32_THREADS
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
#if defined(HAVE_COMPILER_TLS)
    if (!tlstate_inited) {
	tlstate_inited = 1;
	xmlInitializeGlobalState(&tlstate);
    }
    return &tlstate;
#else /* HAVE_COMPILER_TLS */
    xmlGlobalState *globalval;

    if (run_once_init) { 
	run_once_init = 0; 
	xmlOnceInit(); 
    }
    if ((globalval = (xmlGlobalState *) TlsGetValue(globalkey)) == NULL) {
	xmlGlobalState *tsd = xmlNewGlobalState();
	xmlGlobalStateCleanupHelperParams *p = 
	    (xmlGlobalStateCleanupHelperParams *) malloc(sizeof(xmlGlobalStateCleanupHelperParams));
	p->memory = tsd;
	DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), 
		GetCurrentProcess(), &p->thread, 0, TRUE, DUPLICATE_SAME_ACCESS);
	TlsSetValue(globalkey, tsd);
	_beginthread(xmlGlobalStateCleanupHelper, 0, p);

	return (tsd);
    }
    return (globalval);
#endif /* HAVE_COMPILER_TLS */
397 398
#else
    return(NULL);
399 400 401 402 403 404 405 406 407
#endif
}

/************************************************************************
 *									*
 *			Library wide thread interfaces			*
 *									*
 ************************************************************************/

408 409 410 411 412 413 414 415 416 417 418 419
/**
 * xmlGetThreadId:
 *
 * xmlGetThreadId() find the current thread ID number
 *
 * Returns the current thread ID number
 */
int
xmlGetThreadId(void)
{
#ifdef HAVE_PTHREAD_H
    return((int) pthread_self());
420
#elif defined HAVE_WIN32_THREADS
421
    return GetCurrentThreadId();
422 423 424 425 426
#else
    return((int) 0);
#endif
}

427 428 429
/**
 * xmlIsMainThread:
 *
430
 * xmlIsMainThread() check whether the current thread is the main thread.
431 432 433 434 435 436
 *
 * Returns 1 if the current thread is the main thread, 0 otherwise
 */
int
xmlIsMainThread(void)
{
437 438
#ifdef HAVE_PTHREAD_H
    pthread_once(&once_control, xmlOnceInit);
439
#elif defined HAVE_WIN32_THREADS
440 441 442 443
    if (run_once_init) { 
	run_once_init = 0; 
	xmlOnceInit (); 
    }
444
#endif
445 446 447 448 449 450
        
#ifdef DEBUG_THREADS
    xmlGenericError(xmlGenericErrorContext, "xmlIsMainThread()\n");
#endif
#ifdef HAVE_PTHREAD_H
    return(mainthread == pthread_self());
451
#elif defined HAVE_WIN32_THREADS
452
    return(mainthread == GetCurrentThreadId ());
453 454 455 456 457
#else
    return(1);
#endif
}

458 459 460 461 462 463 464 465 466
/**
 * xmlLockLibrary:
 *
 * xmlLockLibrary() is used to take out a re-entrant lock on the libxml2
 * library.
 */
void
xmlLockLibrary(void)
{
467 468 469
#ifdef DEBUG_THREADS
    xmlGenericError(xmlGenericErrorContext, "xmlLockLibrary()\n");
#endif
470 471 472 473 474 475 476 477 478 479 480 481
    xmlRMutexLock(xmlLibraryLock);
}

/**
 * xmlUnlockLibrary:
 *
 * xmlUnlockLibrary() is used to release a re-entrant lock on the libxml2
 * library.
 */
void
xmlUnlockLibrary(void)
{
482 483 484
#ifdef DEBUG_THREADS
    xmlGenericError(xmlGenericErrorContext, "xmlUnlockLibrary()\n");
#endif
485 486 487 488 489 490 491 492 493 494 495 496
    xmlRMutexUnlock(xmlLibraryLock);
}

/**
 * xmlInitThreads:
 *
 * xmlInitThreads() is used to to initialize all the thread related
 * data of the libxml2 library.
 */
void
xmlInitThreads(void)
{
497 498 499
#ifdef DEBUG_THREADS
    xmlGenericError(xmlGenericErrorContext, "xmlInitThreads()\n");
#endif
500 501 502 503 504 505 506 507 508 509 510
}

/**
 * xmlCleanupThreads:
 *
 * xmlCleanupThreads() is used to to cleanup all the thread related
 * data of the libxml2 library once processing has ended.
 */
void
xmlCleanupThreads(void)
{
511 512 513
#ifdef DEBUG_THREADS
    xmlGenericError(xmlGenericErrorContext, "xmlCleanupThreads()\n");
#endif
514
}
515

516 517 518 519 520 521 522 523 524 525 526 527
/**
 * 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
528
    (void) pthread_key_create(&globalkey, xmlFreeGlobalState);
529
    mainthread = pthread_self();
530 531 532 533 534 535 536
#endif

#if defined(HAVE_WIN32_THREADS)
#if !defined(HAVE_COMPILER_TLS)
    globalkey = TlsAlloc();
#endif
    mainthread = GetCurrentThreadId();
537
#endif
538
}