Return to TSRM.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / TSRM

php 5.4.3+patches

    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: 
   23: typedef struct _tsrm_tls_entry tsrm_tls_entry;
   24: 
   25: struct _tsrm_tls_entry {
   26: 	void **storage;
   27: 	int count;
   28: 	THREAD_T thread_id;
   29: 	tsrm_tls_entry *next;
   30: };
   31: 
   32: 
   33: typedef 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 */
   42: static tsrm_tls_entry	**tsrm_tls_table=NULL;
   43: static int				tsrm_tls_table_size;
   44: static ts_rsrc_id		id_count;
   45: 
   46: /* The resource sizes table */
   47: static tsrm_resource_type	*resource_types_table=NULL;
   48: static int					resource_types_table_size;
   49: 
   50: 
   51: static MUTEX_T tsmm_mutex;	/* thread-safe memory manager mutex */
   52: 
   53: /* New thread handlers */
   54: static tsrm_thread_begin_func_t tsrm_new_thread_begin_handler;
   55: static tsrm_thread_end_func_t tsrm_new_thread_end_handler;
   56: 
   57: /* Debug support */
   58: int tsrm_error(int level, const char *format, ...);
   59: 
   60: /* Read a resource from a thread's resource storage */
   61: static int tsrm_error_level;
   62: static 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 */
   94: static 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)
   99: static 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)
  104: static 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)
  109: static 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) */
  120: TSRM_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) */
  165: TSRM_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 */
  215: TSRM_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: 
  270: static 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 */
  308: TSRM_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 */
  383: void 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: 
  405: void *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 */
  423: void *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 */
  442: void 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 */
  484: void 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 */
  530: void 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 */
  570: TSRM_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 */
  591: TSRM_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 */
  622: TSRM_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: */
  654: TSRM_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: */
  686: TSRM_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
  717: TSRM_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: 
  730: TSRM_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: 
  739: TSRM_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
  754: int 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: 
  774: void 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 */