1/*
2 +----------------------------------------------------------------------+
3 | Thread Safe Resource Manager |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1999-2011, Andi Gutmans, Sascha Schumann, Zeev Suraski |
6 | This source file is subject to the TSRM license, that is bundled |
7 | with this package in the file LICENSE |
8 +----------------------------------------------------------------------+
9 | Authors: Zeev Suraski <zeev@zend.com> |
10 +----------------------------------------------------------------------+
11*/
12
13#include "TSRM.h"
14
15#ifdef ZTS
16
17#include <stdio.h>
18
19#if HAVE_STDARG_H
20#include <stdarg.h>
21#endif
22
23typedef struct _tsrm_tls_entry tsrm_tls_entry;
24
25struct _tsrm_tls_entry {
26 void **storage;
27 int count;
28 THREAD_T thread_id;
29 tsrm_tls_entry *next;
30};
31
32
33typedef struct {
34 size_t size;
35 ts_allocate_ctor ctor;
36 ts_allocate_dtor dtor;
37 int done;
38} tsrm_resource_type;
39
40
41/* The memory manager table */
42static tsrm_tls_entry **tsrm_tls_table=NULL;
43static int tsrm_tls_table_size;
44static ts_rsrc_id id_count;
45
46/* The resource sizes table */
47static tsrm_resource_type *resource_types_table=NULL;
48static int resource_types_table_size;
49
50
51static MUTEX_T tsmm_mutex; /* thread-safe memory manager mutex */
52
53/* New thread handlers */
54static tsrm_thread_begin_func_t tsrm_new_thread_begin_handler;
55static tsrm_thread_end_func_t tsrm_new_thread_end_handler;
56
57/* Debug support */
58int tsrm_error(int level, const char *format, ...);
59
60/* Read a resource from a thread's resource storage */
61static int tsrm_error_level;
62static FILE *tsrm_error_file;
63
64#if TSRM_DEBUG
65#define TSRM_ERROR(args) tsrm_error args
66#define TSRM_SAFE_RETURN_RSRC(array, offset, range) \
67 { \
68 int unshuffled_offset = TSRM_UNSHUFFLE_RSRC_ID(offset); \
69 \
70 if (offset==0) { \
71 return &array; \
72 } else if ((unshuffled_offset)>=0 && (unshuffled_offset)<(range)) { \
73 TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Successfully fetched resource id %d for thread id %ld - 0x%0.8X", \
74 unshuffled_offset, (long) thread_resources->thread_id, array[unshuffled_offset])); \
75 return array[unshuffled_offset]; \
76 } else { \
77 TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Resource id %d is out of range (%d..%d)", \
78 unshuffled_offset, TSRM_SHUFFLE_RSRC_ID(0), TSRM_SHUFFLE_RSRC_ID(thread_resources->count-1))); \
79 return NULL; \
80 } \
81 }
82#else
83#define TSRM_ERROR(args)
84#define TSRM_SAFE_RETURN_RSRC(array, offset, range) \
85 if (offset==0) { \
86 return &array; \
87 } else { \
88 return array[TSRM_UNSHUFFLE_RSRC_ID(offset)]; \
89 }
90#endif
91
92#if defined(PTHREADS)
93/* Thread local storage */
94static pthread_key_t tls_key;
95# define tsrm_tls_set(what) pthread_setspecific(tls_key, (void*)(what))
96# define tsrm_tls_get() pthread_getspecific(tls_key)
97
98#elif defined(TSRM_ST)
99static int tls_key;
100# define tsrm_tls_set(what) st_thread_setspecific(tls_key, (void*)(what))
101# define tsrm_tls_get() st_thread_getspecific(tls_key)
102
103#elif defined(TSRM_WIN32)
104static DWORD tls_key;
105# define tsrm_tls_set(what) TlsSetValue(tls_key, (void*)(what))
106# define tsrm_tls_get() TlsGetValue(tls_key)
107
108#elif defined(BETHREADS)
109static int32 tls_key;
110# define tsrm_tls_set(what) tls_set(tls_key, (void*)(what))
111# define tsrm_tls_get() (tsrm_tls_entry*)tls_get(tls_key)
112
113#else
114# define tsrm_tls_set(what)
115# define tsrm_tls_get() NULL
116# warning tsrm_set_interpreter_context is probably broken on this platform
117#endif
118
119/* Startup TSRM (call once for the entire process) */
120TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_level, char *debug_filename)
121{
122#if defined(GNUPTH)
123 pth_init();
124#elif defined(PTHREADS)
125 pthread_key_create( &tls_key, 0 );
126#elif defined(TSRM_ST)
127 st_init();
128 st_key_create(&tls_key, 0);
129#elif defined(TSRM_WIN32)
130 tls_key = TlsAlloc();
131#elif defined(BETHREADS)
132 tls_key = tls_allocate();
133#endif
134
135 tsrm_error_file = stderr;
136 tsrm_error_set(debug_level, debug_filename);
137 tsrm_tls_table_size = expected_threads;
138
139 tsrm_tls_table = (tsrm_tls_entry **) calloc(tsrm_tls_table_size, sizeof(tsrm_tls_entry *));
140 if (!tsrm_tls_table) {
141 TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Unable to allocate TLS table"));
142 return 0;
143 }
144 id_count=0;
145
146 resource_types_table_size = expected_resources;
147 resource_types_table = (tsrm_resource_type *) calloc(resource_types_table_size, sizeof(tsrm_resource_type));
148 if (!resource_types_table) {
149 TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Unable to allocate resource types table"));
150 free(tsrm_tls_table);
151 tsrm_tls_table = NULL;
152 return 0;
153 }
154
155 tsmm_mutex = tsrm_mutex_alloc();
156
157 tsrm_new_thread_begin_handler = tsrm_new_thread_end_handler = NULL;
158
159 TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Started up TSRM, %d expected threads, %d expected resources", expected_threads, expected_resources));
160 return 1;
161}
162
163
164/* Shutdown TSRM (call once for the entire process) */
165TSRM_API void tsrm_shutdown(void)
166{
167 int i;
168
169 if (tsrm_tls_table) {
170 for (i=0; i<tsrm_tls_table_size; i++) {
171 tsrm_tls_entry *p = tsrm_tls_table[i], *next_p;
172
173 while (p) {
174 int j;
175
176 next_p = p->next;
177 for (j=0; j<p->count; j++) {
178 if (p->storage[j]) {
179 if (resource_types_table && !resource_types_table[j].done && resource_types_table[j].dtor) {
180 resource_types_table[j].dtor(p->storage[j], &p->storage);
181 }
182 free(p->storage[j]);
183 }
184 }
185 free(p->storage);
186 free(p);
187 p = next_p;
188 }
189 }
190 free(tsrm_tls_table);
191 tsrm_tls_table = NULL;
192 }
193 if (resource_types_table) {
194 free(resource_types_table);
195 resource_types_table=NULL;
196 }
197 tsrm_mutex_free(tsmm_mutex);
198 tsmm_mutex = NULL;
199 TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Shutdown TSRM"));
200 if (tsrm_error_file!=stderr) {
201 fclose(tsrm_error_file);
202 }
203#if defined(GNUPTH)
204 pth_kill();
205#elif defined(PTHREADS)
206 pthread_setspecific(tls_key, 0);
207 pthread_key_delete(tls_key);
208#elif defined(TSRM_WIN32)
209 TlsFree(tls_key);
210#endif
211}
212
213
214/* allocates a new thread-safe-resource id */
215TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor)
216{
217 int i;
218
219 TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtaining a new resource id, %d bytes", size));
220
221 tsrm_mutex_lock(tsmm_mutex);
222
223 /* obtain a resource id */
224 *rsrc_id = TSRM_SHUFFLE_RSRC_ID(id_count++);
225 TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtained resource id %d", *rsrc_id));
226
227 /* store the new resource type in the resource sizes table */
228 if (resource_types_table_size < id_count) {
229 resource_types_table = (tsrm_resource_type *) realloc(resource_types_table, sizeof(tsrm_resource_type)*id_count);
230 if (!resource_types_table) {
231 tsrm_mutex_unlock(tsmm_mutex);
232 TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Unable to allocate storage for resource"));
233 *rsrc_id = 0;
234 return 0;
235 }
236 resource_types_table_size = id_count;
237 }
238 resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].size = size;
239 resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].ctor = ctor;
240 resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].dtor = dtor;
241 resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].done = 0;
242
243 /* enlarge the arrays for the already active threads */
244 for (i=0; i<tsrm_tls_table_size; i++) {
245 tsrm_tls_entry *p = tsrm_tls_table[i];
246
247 while (p) {
248 if (p->count < id_count) {
249 int j;
250
251 p->storage = (void *) realloc(p->storage, sizeof(void *)*id_count);
252 for (j=p->count; j<id_count; j++) {
253 p->storage[j] = (void *) malloc(resource_types_table[j].size);
254 if (resource_types_table[j].ctor) {
255 resource_types_table[j].ctor(p->storage[j], &p->storage);
256 }
257 }
258 p->count = id_count;
259 }
260 p = p->next;
261 }
262 }
263 tsrm_mutex_unlock(tsmm_mutex);
264
265 TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Successfully allocated new resource id %d", *rsrc_id));
266 return *rsrc_id;
267}
268
269
270static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_T thread_id)
271{
272 int i;
273
274 TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Creating data structures for thread %x", thread_id));
275 (*thread_resources_ptr) = (tsrm_tls_entry *) malloc(sizeof(tsrm_tls_entry));
276 (*thread_resources_ptr)->storage = (void **) malloc(sizeof(void *)*id_count);
277 (*thread_resources_ptr)->count = id_count;
278 (*thread_resources_ptr)->thread_id = thread_id;
279 (*thread_resources_ptr)->next = NULL;
280
281 /* Set thread local storage to this new thread resources structure */
282 tsrm_tls_set(*thread_resources_ptr);
283
284 if (tsrm_new_thread_begin_handler) {
285 tsrm_new_thread_begin_handler(thread_id, &((*thread_resources_ptr)->storage));
286 }
287 for (i=0; i<id_count; i++) {
288 if (resource_types_table[i].done) {
289 (*thread_resources_ptr)->storage[i] = NULL;
290 } else
291 {
292 (*thread_resources_ptr)->storage[i] = (void *) malloc(resource_types_table[i].size);
293 if (resource_types_table[i].ctor) {
294 resource_types_table[i].ctor((*thread_resources_ptr)->storage[i], &(*thread_resources_ptr)->storage);
295 }
296 }
297 }
298
299 if (tsrm_new_thread_end_handler) {
300 tsrm_new_thread_end_handler(thread_id, &((*thread_resources_ptr)->storage));
301 }
302
303 tsrm_mutex_unlock(tsmm_mutex);
304}
305
306
307/* fetches the requested resource for the current thread */
308TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id)
309{
310 THREAD_T thread_id;
311 int hash_value;
312 tsrm_tls_entry *thread_resources;
313
314#ifdef NETWARE
315 /* The below if loop is added for NetWare to fix an abend while unloading PHP
316 * when an Apache unload command is issued on the system console.
317 * While exiting from PHP, at the end for some reason, this function is called
318 * with tsrm_tls_table = NULL. When this happened, the server abends when
319 * tsrm_tls_table is accessed since it is NULL.
320 */
321 if(tsrm_tls_table) {
322#endif
323 if (!th_id) {
324 /* Fast path for looking up the resources for the current
325 * thread. Its used by just about every call to
326 * ts_resource_ex(). This avoids the need for a mutex lock
327 * and our hashtable lookup.
328 */
329 thread_resources = tsrm_tls_get();
330
331 if (thread_resources) {
332 TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for current thread %d", id, (long) thread_resources->thread_id));
333 /* Read a specific resource from the thread's resources.
334 * This is called outside of a mutex, so have to be aware about external
335 * changes to the structure as we read it.
336 */
337 TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count);
338 }
339 thread_id = tsrm_thread_id();
340 } else {
341 thread_id = *th_id;
342 }
343
344 TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for thread %ld", id, (long) thread_id));
345 tsrm_mutex_lock(tsmm_mutex);
346
347 hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size);
348 thread_resources = tsrm_tls_table[hash_value];
349
350 if (!thread_resources) {
351 allocate_new_resource(&tsrm_tls_table[hash_value], thread_id);
352 return ts_resource_ex(id, &thread_id);
353 } else {
354 do {
355 if (thread_resources->thread_id == thread_id) {
356 break;
357 }
358 if (thread_resources->next) {
359 thread_resources = thread_resources->next;
360 } else {
361 allocate_new_resource(&thread_resources->next, thread_id);
362 return ts_resource_ex(id, &thread_id);
363 /*
364 * thread_resources = thread_resources->next;
365 * break;
366 */
367 }
368 } while (thread_resources);
369 }
370 tsrm_mutex_unlock(tsmm_mutex);
371 /* Read a specific resource from the thread's resources.
372 * This is called outside of a mutex, so have to be aware about external
373 * changes to the structure as we read it.
374 */
375 TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count);
376#ifdef NETWARE
377 } /* if(tsrm_tls_table) */
378#endif
379}
380
381/* frees an interpreter context. You are responsible for making sure that
382 * it is not linked into the TSRM hash, and not marked as the current interpreter */
383void tsrm_free_interpreter_context(void *context)
384{
385 tsrm_tls_entry *next, *thread_resources = (tsrm_tls_entry*)context;
386 int i;
387
388 while (thread_resources) {
389 next = thread_resources->next;
390
391 for (i=0; i<thread_resources->count; i++) {
392 if (resource_types_table[i].dtor) {
393 resource_types_table[i].dtor(thread_resources->storage[i], &thread_resources->storage);
394 }
395 }
396 for (i=0; i<thread_resources->count; i++) {
397 free(thread_resources->storage[i]);
398 }
399 free(thread_resources->storage);
400 free(thread_resources);
401 thread_resources = next;
402 }
403}
404
405void *tsrm_set_interpreter_context(void *new_ctx)
406{
407 tsrm_tls_entry *current;
408
409 current = tsrm_tls_get();
410
411 /* TODO: unlink current from the global linked list, and replace it
412 * it with the new context, protected by mutex where/if appropriate */
413
414 /* Set thread local storage to this new thread resources structure */
415 tsrm_tls_set(new_ctx);
416
417 /* return old context, so caller can restore it when they're done */
418 return current;
419}
420
421
422/* allocates a new interpreter context */
423void *tsrm_new_interpreter_context(void)
424{
425 tsrm_tls_entry *new_ctx, *current;
426 THREAD_T thread_id;
427
428 thread_id = tsrm_thread_id();
429 tsrm_mutex_lock(tsmm_mutex);
430
431 current = tsrm_tls_get();
432
433 allocate_new_resource(&new_ctx, thread_id);
434
435 /* switch back to the context that was in use prior to our creation
436 * of the new one */
437 return tsrm_set_interpreter_context(current);
438}
439
440
441/* frees all resources allocated for the current thread */
442void ts_free_thread(void)
443{
444 tsrm_tls_entry *thread_resources;
445 int i;
446 THREAD_T thread_id = tsrm_thread_id();
447 int hash_value;
448 tsrm_tls_entry *last=NULL;
449
450 tsrm_mutex_lock(tsmm_mutex);
451 hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size);
452 thread_resources = tsrm_tls_table[hash_value];
453
454 while (thread_resources) {
455 if (thread_resources->thread_id == thread_id) {
456 for (i=0; i<thread_resources->count; i++) {
457 if (resource_types_table[i].dtor) {
458 resource_types_table[i].dtor(thread_resources->storage[i], &thread_resources->storage);
459 }
460 }
461 for (i=0; i<thread_resources->count; i++) {
462 free(thread_resources->storage[i]);
463 }
464 free(thread_resources->storage);
465 if (last) {
466 last->next = thread_resources->next;
467 } else {
468 tsrm_tls_table[hash_value] = thread_resources->next;
469 }
470 tsrm_tls_set(0);
471 free(thread_resources);
472 break;
473 }
474 if (thread_resources->next) {
475 last = thread_resources;
476 }
477 thread_resources = thread_resources->next;
478 }
479 tsrm_mutex_unlock(tsmm_mutex);
480}
481
482
483/* frees all resources allocated for all threads except current */
484void ts_free_worker_threads(void)
485{
486 tsrm_tls_entry *thread_resources;
487 int i;
488 THREAD_T thread_id = tsrm_thread_id();
489 int hash_value;
490 tsrm_tls_entry *last=NULL;
491
492 tsrm_mutex_lock(tsmm_mutex);
493 hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size);
494 thread_resources = tsrm_tls_table[hash_value];
495
496 while (thread_resources) {
497 if (thread_resources->thread_id != thread_id) {
498 for (i=0; i<thread_resources->count; i++) {
499 if (resource_types_table[i].dtor) {
500 resource_types_table[i].dtor(thread_resources->storage[i], &thread_resources->storage);
501 }
502 }
503 for (i=0; i<thread_resources->count; i++) {
504 free(thread_resources->storage[i]);
505 }
506 free(thread_resources->storage);
507 if (last) {
508 last->next = thread_resources->next;
509 } else {
510 tsrm_tls_table[hash_value] = thread_resources->next;
511 }
512 free(thread_resources);
513 if (last) {
514 thread_resources = last->next;
515 } else {
516 thread_resources = tsrm_tls_table[hash_value];
517 }
518 } else {
519 if (thread_resources->next) {
520 last = thread_resources;
521 }
522 thread_resources = thread_resources->next;
523 }
524 }
525 tsrm_mutex_unlock(tsmm_mutex);
526}
527
528
529/* deallocates all occurrences of a given id */
530void ts_free_id(ts_rsrc_id id)
531{
532 int i;
533 int j = TSRM_UNSHUFFLE_RSRC_ID(id);
534
535 tsrm_mutex_lock(tsmm_mutex);
536
537 TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Freeing resource id %d", id));
538
539 if (tsrm_tls_table) {
540 for (i=0; i<tsrm_tls_table_size; i++) {
541 tsrm_tls_entry *p = tsrm_tls_table[i];
542
543 while (p) {
544 if (p->count > j && p->storage[j]) {
545 if (resource_types_table && resource_types_table[j].dtor) {
546 resource_types_table[j].dtor(p->storage[j], &p->storage);
547 }
548 free(p->storage[j]);
549 p->storage[j] = NULL;
550 }
551 p = p->next;
552 }
553 }
554 }
555 resource_types_table[j].done = 1;
556
557 tsrm_mutex_unlock(tsmm_mutex);
558
559 TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Successfully freed resource id %d", id));
560}
561
562
563
564
565/*
566 * Utility Functions
567 */
568
569/* Obtain the current thread id */
570TSRM_API THREAD_T tsrm_thread_id(void)
571{
572#ifdef TSRM_WIN32
573 return GetCurrentThreadId();
574#elif defined(GNUPTH)
575 return pth_self();
576#elif defined(PTHREADS)
577 return pthread_self();
578#elif defined(NSAPI)
579 return systhread_current();
580#elif defined(PI3WEB)
581 return PIThread_getCurrent();
582#elif defined(TSRM_ST)
583 return st_thread_self();
584#elif defined(BETHREADS)
585 return find_thread(NULL);
586#endif
587}
588
589
590/* Allocate a mutex */
591TSRM_API MUTEX_T tsrm_mutex_alloc(void)
592{
593 MUTEX_T mutexp;
594#ifdef TSRM_WIN32
595 mutexp = malloc(sizeof(CRITICAL_SECTION));
596 InitializeCriticalSection(mutexp);
597#elif defined(GNUPTH)
598 mutexp = (MUTEX_T) malloc(sizeof(*mutexp));
599 pth_mutex_init(mutexp);
600#elif defined(PTHREADS)
601 mutexp = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
602 pthread_mutex_init(mutexp,NULL);
603#elif defined(NSAPI)
604 mutexp = crit_init();
605#elif defined(PI3WEB)
606 mutexp = PIPlatform_allocLocalMutex();
607#elif defined(TSRM_ST)
608 mutexp = st_mutex_new();
609#elif defined(BETHREADS)
610 mutexp = (beos_ben*)malloc(sizeof(beos_ben));
611 mutexp->ben = 0;
612 mutexp->sem = create_sem(1, "PHP sempahore");
613#endif
614#ifdef THR_DEBUG
615 printf("Mutex created thread: %d\n",mythreadid());
616#endif
617 return( mutexp );
618}
619
620
621/* Free a mutex */
622TSRM_API void tsrm_mutex_free(MUTEX_T mutexp)
623{
624 if (mutexp) {
625#ifdef TSRM_WIN32
626 DeleteCriticalSection(mutexp);
627 free(mutexp);
628#elif defined(GNUPTH)
629 free(mutexp);
630#elif defined(PTHREADS)
631 pthread_mutex_destroy(mutexp);
632 free(mutexp);
633#elif defined(NSAPI)
634 crit_terminate(mutexp);
635#elif defined(PI3WEB)
636 PISync_delete(mutexp);
637#elif defined(TSRM_ST)
638 st_mutex_destroy(mutexp);
639#elif defined(BETHREADS)
640 delete_sem(mutexp->sem);
641 free(mutexp);
642#endif
643 }
644#ifdef THR_DEBUG
645 printf("Mutex freed thread: %d\n",mythreadid());
646#endif
647}
648
649
650/*
651 Lock a mutex.
652 A return value of 0 indicates success
653*/
654TSRM_API int tsrm_mutex_lock(MUTEX_T mutexp)
655{
656 TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Mutex locked thread: %ld", tsrm_thread_id()));
657#ifdef TSRM_WIN32
658 EnterCriticalSection(mutexp);
659 return 0;
660#elif defined(GNUPTH)
661 if (pth_mutex_acquire(mutexp, 0, NULL)) {
662 return 0;
663 }
664 return -1;
665#elif defined(PTHREADS)
666 return pthread_mutex_lock(mutexp);
667#elif defined(NSAPI)
668 crit_enter(mutexp);
669 return 0;
670#elif defined(PI3WEB)
671 return PISync_lock(mutexp);
672#elif defined(TSRM_ST)
673 return st_mutex_lock(mutexp);
674#elif defined(BETHREADS)
675 if (atomic_add(&mutexp->ben, 1) != 0)
676 return acquire_sem(mutexp->sem);
677 return 0;
678#endif
679}
680
681
682/*
683 Unlock a mutex.
684 A return value of 0 indicates success
685*/
686TSRM_API int tsrm_mutex_unlock(MUTEX_T mutexp)
687{
688 TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Mutex unlocked thread: %ld", tsrm_thread_id()));
689#ifdef TSRM_WIN32
690 LeaveCriticalSection(mutexp);
691 return 0;
692#elif defined(GNUPTH)
693 if (pth_mutex_release(mutexp)) {
694 return 0;
695 }
696 return -1;
697#elif defined(PTHREADS)
698 return pthread_mutex_unlock(mutexp);
699#elif defined(NSAPI)
700 crit_exit(mutexp);
701 return 0;
702#elif defined(PI3WEB)
703 return PISync_unlock(mutexp);
704#elif defined(TSRM_ST)
705 return st_mutex_unlock(mutexp);
706#elif defined(BETHREADS)
707 if (atomic_add(&mutexp->ben, -1) != 1)
708 return release_sem(mutexp->sem);
709 return 0;
710#endif
711}
712
713/*
714 Changes the signal mask of the calling thread
715*/
716#ifdef HAVE_SIGPROCMASK
717TSRM_API int tsrm_sigmask(int how, const sigset_t *set, sigset_t *oldset)
718{
719 TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Changed sigmask in thread: %ld", tsrm_thread_id()));
720 /* TODO: add support for other APIs */
721#ifdef PTHREADS
722 return pthread_sigmask(how, set, oldset);
723#else
724 return sigprocmask(how, set, oldset);
725#endif
726}
727#endif
728
729
730TSRM_API void *tsrm_set_new_thread_begin_handler(tsrm_thread_begin_func_t new_thread_begin_handler)
731{
732 void *retval = (void *) tsrm_new_thread_begin_handler;
733
734 tsrm_new_thread_begin_handler = new_thread_begin_handler;
735 return retval;
736}
737
738
739TSRM_API void *tsrm_set_new_thread_end_handler(tsrm_thread_end_func_t new_thread_end_handler)
740{
741 void *retval = (void *) tsrm_new_thread_end_handler;
742
743 tsrm_new_thread_end_handler = new_thread_end_handler;
744 return retval;
745}
746
747
748
749/*
750 * Debug support
751 */
752
753#if TSRM_DEBUG
754int tsrm_error(int level, const char *format, ...)
755{
756 if (level<=tsrm_error_level) {
757 va_list args;
758 int size;
759
760 fprintf(tsrm_error_file, "TSRM: ");
761 va_start(args, format);
762 size = vfprintf(tsrm_error_file, format, args);
763 va_end(args);
764 fprintf(tsrm_error_file, "\n");
765 fflush(tsrm_error_file);
766 return size;
767 } else {
768 return 0;
769 }
770}
771#endif
772
773
774void tsrm_error_set(int level, char *debug_filename)
775{
776 tsrm_error_level = level;
777
778#if TSRM_DEBUG
779 if (tsrm_error_file!=stderr) { /* close files opened earlier */
780 fclose(tsrm_error_file);
781 }
782
783 if (debug_filename) {
784 tsrm_error_file = fopen(debug_filename, "w");
785 if (!tsrm_error_file) {
786 tsrm_error_file = stderr;
787 }
788 } else {
789 tsrm_error_file = stderr;
790 }
791#endif
792}
793
794#endif /* ZTS */
795