static void end_read(TsHashTable *ht) { #ifdef ZTS tsrm_mutex_lock(ht->mx_reader); if ((--(ht->reader)) == 0) { tsrm_mutex_unlock(ht->mx_writer); } tsrm_mutex_unlock(ht->mx_reader); #endif }
/* allocates a new thread-safe-resource id */ TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor) {/*{{{*/ int i; TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtaining a new resource id, %d bytes", size)); tsrm_mutex_lock(tsmm_mutex); /* obtain a resource id */ *rsrc_id = TSRM_SHUFFLE_RSRC_ID(id_count++); TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtained resource id %d", *rsrc_id)); /* store the new resource type in the resource sizes table */ if (resource_types_table_size < id_count) { tsrm_resource_type *_tmp; _tmp = (tsrm_resource_type *) realloc(resource_types_table, sizeof(tsrm_resource_type)*id_count); if (!_tmp) { tsrm_mutex_unlock(tsmm_mutex); TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Unable to allocate storage for resource")); *rsrc_id = 0; return 0; } resource_types_table = _tmp; resource_types_table_size = id_count; } resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].size = size; resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].ctor = ctor; resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].dtor = dtor; resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].done = 0; /* enlarge the arrays for the already active threads */ for (i=0; i<tsrm_tls_table_size; i++) { tsrm_tls_entry *p = tsrm_tls_table[i]; while (p) { if (p->count < id_count) { int j; p->storage = (void *) realloc(p->storage, sizeof(void *)*id_count); for (j=p->count; j<id_count; j++) { p->storage[j] = (void *) malloc(resource_types_table[j].size); if (resource_types_table[j].ctor) { resource_types_table[j].ctor(p->storage[j]); } } p->count = id_count; } p = p->next; } } tsrm_mutex_unlock(tsmm_mutex); TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Successfully allocated new resource id %d", *rsrc_id)); return *rsrc_id; }/*}}}*/
/* }}} */ void xc_mutex_unlock(xc_mutex_t *mutex) /* {{{ */ { #ifndef NDEBUG assert(mutex->locked); mutex->locked = 0; assert(!mutex->locked); #endif #ifdef XC_MUTEX_USE_FCNTL if (xc_want_inter_process()) { xc_fcntl_unlock(&mutex->fcntl_mutex); } #endif #ifdef XC_MUTEX_USE_TSRM if (tsrm_mutex_unlock(mutex->tsrm_mutex) < 0) { zend_error(E_ERROR, "xc_mutex_unlock failed errno:%d", errno); } #endif #ifdef XC_MUTEX_USE_PTHREAD if (pthread_mutex_unlock(&mutex->pthread_mutex) < 0) { zend_error(E_ERROR, "xc_mutex_unlock failed errno:%d", errno); } #endif }
/* deallocates all occurrences of a given id */ void ts_free_id(ts_rsrc_id id) {/*{{{*/ int i; int j = TSRM_UNSHUFFLE_RSRC_ID(id); tsrm_mutex_lock(tsmm_mutex); TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Freeing resource id %d", id)); if (tsrm_tls_table) { for (i=0; i<tsrm_tls_table_size; i++) { tsrm_tls_entry *p = tsrm_tls_table[i]; while (p) { if (p->count > j && p->storage[j]) { if (resource_types_table && resource_types_table[j].dtor) { resource_types_table[j].dtor(p->storage[j]); } free(p->storage[j]); p->storage[j] = NULL; } p = p->next; } } } resource_types_table[j].done = 1; tsrm_mutex_unlock(tsmm_mutex); TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Successfully freed resource id %d", id)); }/*}}}*/
void _crypt_extended_init_r(void) { #ifdef PHP_WIN32 LONG volatile initialized = 0; #elif defined(HAVE_ATOMIC_H) /* Solaris 10 defines atomic API within */ volatile unsigned int initialized = 0; #else static volatile sig_atomic_t initialized = 0; #endif #ifdef ZTS tsrm_mutex_lock(php_crypt_extended_init_lock); #endif if (!initialized) { #ifdef PHP_WIN32 InterlockedIncrement(&initialized); #elif defined(HAVE_SYNC_FETCH_AND_ADD) __sync_fetch_and_add(&initialized, 1); #elif (defined(__GNUC__) && (__GNUC__ >= 3)) initialized = 1; #elif defined(HAVE_ATOMIC_H) /* Solaris 10 defines atomic API within */ membar_producer(); atomic_add_int(&initialized, 1); #endif _crypt_extended_init(); } #ifdef ZTS tsrm_mutex_unlock(php_crypt_extended_init_lock); #endif }
static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_T thread_id) { int i; TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Creating data structures for thread %x", thread_id)); (*thread_resources_ptr) = (tsrm_tls_entry *) malloc(sizeof(tsrm_tls_entry)); (*thread_resources_ptr)->storage = (void **) malloc(sizeof(void *)*id_count); (*thread_resources_ptr)->count = id_count; (*thread_resources_ptr)->thread_id = thread_id; (*thread_resources_ptr)->next = NULL; /* Set thread local storage to this new thread resources structure */ tsrm_tls_set(*thread_resources_ptr); if (tsrm_new_thread_begin_handler) { tsrm_new_thread_begin_handler(thread_id, &((*thread_resources_ptr)->storage)); } for (i=0; i<id_count; i++) { if (resource_types_table[i].done) { (*thread_resources_ptr)->storage[i] = NULL; } else { (*thread_resources_ptr)->storage[i] = (void *) malloc(resource_types_table[i].size); if (resource_types_table[i].ctor) { resource_types_table[i].ctor((*thread_resources_ptr)->storage[i], &(*thread_resources_ptr)->storage); } } } if (tsrm_new_thread_end_handler) { tsrm_new_thread_end_handler(thread_id, &((*thread_resources_ptr)->storage)); } tsrm_mutex_unlock(tsmm_mutex); }
/* fetches the requested resource for the current thread */ TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id) {/*{{{*/ THREAD_T thread_id; int hash_value; tsrm_tls_entry *thread_resources; if (!th_id) { /* Fast path for looking up the resources for the current * thread. Its used by just about every call to * ts_resource_ex(). This avoids the need for a mutex lock * and our hashtable lookup. */ thread_resources = tsrm_tls_get(); if (thread_resources) { TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for current thread %d", id, (long) thread_resources->thread_id)); /* Read a specific resource from the thread's resources. * This is called outside of a mutex, so have to be aware about external * changes to the structure as we read it. */ TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count); } thread_id = tsrm_thread_id(); } else { thread_id = *th_id; } TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for thread %ld", id, (long) thread_id)); tsrm_mutex_lock(tsmm_mutex); hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size); thread_resources = tsrm_tls_table[hash_value]; if (!thread_resources) { allocate_new_resource(&tsrm_tls_table[hash_value], thread_id); return ts_resource_ex(id, &thread_id); } else { do { if (thread_resources->thread_id == thread_id) { break; } if (thread_resources->next) { thread_resources = thread_resources->next; } else { allocate_new_resource(&thread_resources->next, thread_id); return ts_resource_ex(id, &thread_id); /* * thread_resources = thread_resources->next; * break; */ } } while (thread_resources); } tsrm_mutex_unlock(tsmm_mutex); /* Read a specific resource from the thread's resources. * This is called outside of a mutex, so have to be aware about external * changes to the structure as we read it. */ TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count); }/*}}}*/
static void php_http_openssl_thread_lock(int mode, int n, const char * file, int line) { if (mode & CRYPTO_LOCK) { tsrm_mutex_lock(php_http_openssl_tsl[n]); } else { tsrm_mutex_unlock(php_http_openssl_tsl[n]); } }
void php_win32_free_rng_lock() { tsrm_mutex_lock(php_lock_win32_cryptoctx); CryptReleaseContext(hCryptProv, 0); has_crypto_ctx = 0; tsrm_mutex_unlock(php_lock_win32_cryptoctx); tsrm_mutex_free(php_lock_win32_cryptoctx); }
/* ts management functions */ static void begin_read(TsHashTable *ht) { #ifdef ZTS tsrm_mutex_lock(ht->mx_reader); if ((++(ht->reader)) == 1) { tsrm_mutex_lock(ht->mx_writer); } tsrm_mutex_unlock(ht->mx_reader); #endif }
void mkd_shlib_destructor() { /* on merge: added critical section */ #ifdef ZTS tsrm_mutex_lock(tags_mutex); #endif mkd_deallocate_tags(); #ifdef ZTS tsrm_mutex_unlock(tags_mutex); #endif }
void zend_shared_alloc_unlock(void) { ZCG(locked) = 0; #ifndef ZEND_WIN32 if (fcntl(lock_file, F_SETLK, &mem_write_unlock) == -1) { zend_accel_error(ACCEL_LOG_ERROR, "Cannot remove lock - %s (%d)", strerror(errno), errno); } #ifdef ZTS tsrm_mutex_unlock(zts_lock); #endif #else zend_shared_alloc_unlock_win32(); #endif }
void mkd_shlib_destructor() { /* on merge: added critical section */ #ifdef ZTS tsrm_mutex_lock(tags_mutex); #endif /* on merge: reduced to call to mkd_deallocate_tags(); */ /*if ( !need_to_setup ) { need_to_setup = 1;*/ mkd_deallocate_tags(); /*}*/ #ifdef ZTS tsrm_mutex_unlock(tags_mutex); #endif }
PHPAPI int php_win32_get_random_bytes(unsigned char *buf, size_t size) { /* {{{ */ unsigned int has_contextg = 0; BOOL ret; size_t i = 0; #ifdef ZTS tsrm_mutex_lock(php_lock_win32_cryptoctx); #endif if (has_crypto_ctx == 0) { /* CRYPT_VERIFYCONTEXT > only hashing&co-like use, no need to acces prv keys */ if (!CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_MACHINE_KEYSET|CRYPT_VERIFYCONTEXT )) { /* Could mean that the key container does not exist, let try again by asking for a new one. If it fails here, it surely means that the user running this process does not have the permission(s) to use this container. */ if (GetLastError() == NTE_BAD_KEYSET) { if (CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_NEWKEYSET | CRYPT_MACHINE_KEYSET | CRYPT_VERIFYCONTEXT )) { has_crypto_ctx = 1; } else { has_crypto_ctx = 0; } } } else { has_crypto_ctx = 1; } } #ifdef ZTS tsrm_mutex_unlock(php_lock_win32_cryptoctx); #endif if (has_crypto_ctx == 0) { return FAILURE; } ret = CryptGenRandom(hCryptProv, size, buf); if (ret) { return SUCCESS; } else { return FAILURE; } }
void zend_shared_alloc_unlock(TSRMLS_D) { /* Destroy translation table */ zend_hash_destroy(&xlat_table); ZCG(locked) = 0; #ifndef ZEND_WIN32 if (fcntl(lock_file, F_SETLK, &mem_write_unlock) == -1) { zend_accel_error(ACCEL_LOG_ERROR, "Cannot remove lock - %s (%d)", strerror(errno), errno); } #ifdef ZTS tsrm_mutex_unlock(zts_lock); #endif #else zend_shared_alloc_unlock_win32(); #endif }
void _crypt_extended_init_r(void) { static volatile sig_atomic_t initialized = 0; #ifdef ZTS tsrm_mutex_lock(php_crypt_extended_init_lock); #endif if (initialized) { return; } else { _crypt_extended_init(); initialized = 1; } #ifdef ZTS tsrm_mutex_unlock(php_crypt_extended_init_lock); #endif }
/* frees all resources allocated for all threads except current */ void ts_free_worker_threads(void) {/*{{{*/ tsrm_tls_entry *thread_resources; int i; THREAD_T thread_id = tsrm_thread_id(); int hash_value; tsrm_tls_entry *last=NULL; tsrm_mutex_lock(tsmm_mutex); hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size); thread_resources = tsrm_tls_table[hash_value]; while (thread_resources) { if (thread_resources->thread_id != thread_id) { for (i=0; i<thread_resources->count; i++) { if (resource_types_table[i].dtor) { resource_types_table[i].dtor(thread_resources->storage[i]); } } for (i=0; i<thread_resources->count; i++) { free(thread_resources->storage[i]); } free(thread_resources->storage); if (last) { last->next = thread_resources->next; } else { tsrm_tls_table[hash_value] = thread_resources->next; } free(thread_resources); if (last) { thread_resources = last->next; } else { thread_resources = tsrm_tls_table[hash_value]; } } else { if (thread_resources->next) { last = thread_resources; } thread_resources = thread_resources->next; } } tsrm_mutex_unlock(tsmm_mutex); }/*}}}*/
void mkd_initialize() { /* on merge: added critical section */ #ifdef ZTS tsrm_mutex_lock(tags_mutex); #endif /* on merge: reduced to call to mkd_prepare_tags(); */ /* if ( need_to_initrng ) { need_to_initrng = 0; INITRNG(time(0)); } if ( need_to_setup ) { need_to_setup = 0;*/ mkd_prepare_tags(); /*}*/ #ifdef ZTS tsrm_mutex_unlock(tags_mutex); #endif }
ancillary_reg_entry *get_ancillary_reg_entry(int cmsg_level, int msg_type) { anc_reg_key key = { cmsg_level, msg_type }; ancillary_reg_entry *entry; #ifdef ZTS tsrm_mutex_lock(ancillary_mutex); #endif if (!ancillary_registry.initialized) { init_ancillary_registry(); } #ifdef ZTS tsrm_mutex_unlock(ancillary_mutex); #endif if ((entry = zend_hash_str_find_ptr(&ancillary_registry.ht, (char*)&key, sizeof(key) - 1)) != NULL) { return entry; } else { return NULL; } }
ancillary_reg_entry *get_ancillary_reg_entry(int cmsg_level, int msg_type) { anc_reg_key key = { cmsg_level, msg_type }; ancillary_reg_entry *entry; #ifdef ZTS tsrm_mutex_lock(ancillary_mutex); #endif if (!ancillary_registry.initialized) { init_ancillary_registry(); } #ifdef ZTS tsrm_mutex_unlock(ancillary_mutex); #endif if (zend_hash_find(&ancillary_registry.ht, (char*)&key, sizeof(key), (void**)&entry) == SUCCESS) { return entry; } else { return NULL; } }
static void end_write(TsHashTable *ht) { #ifdef ZTS tsrm_mutex_unlock(ht->mx_writer); #endif }
void call_backtrace(int fd, zend_backtrace_globals* g, backtrace_callback_t callback) { #ifdef DEBUG fprintf(stderr, "[%d]: call_backtrace()\n", getpid()); fflush(stderr); #endif if (!callback) { return; } HashPosition pos; void** current; THREAD_T self = tsrm_thread_id(); int processed_self = 0; tsrm_mutex_lock(mutex); for ( zend_hash_internal_pointer_reset_ex(&thread_ids, &pos); SUCCESS == zend_hash_get_current_data_ex(&thread_ids, (void**)¤t, &pos); zend_hash_move_forward_ex(&thread_ids, &pos) ) { char* key; uint key_len; ulong idx; int type; type = zend_hash_get_current_key_ex(&thread_ids, &key, &key_len, &idx, 0, &pos); if (HASH_KEY_IS_STRING == type) { idx = atol(key); } #ifdef DEBUG fprintf(stderr, "[%d]: Trying thread %lu\n", getpid(), idx); fflush(stderr); #endif if (idx) { #if defined(PTHREADS) int res = pthread_kill((pthread_t)idx, 0); if (res) { continue; } #elif defined(GNUPTH) int res = pth_raise((pth_t)idx, 0); if (!res) { continue; } #endif #ifdef DEBUG fprintf(stderr, "[%d]: Processing thread %lu\n", getpid(), idx); fflush(stderr); #endif THREAD_T thread_id = idx; #if defined(PTHREADS) if (!processed_self && pthread_equal(thread_id, self)) { processed_self = 1; } #else if (thread_id == self) { processed_self = 1; } #endif void*** tsrm_ls = (void***)ts_resource_ex(0, &thread_id); callback(fd, g, tsrm_ls); #ifdef DEBUG fprintf(stderr, "[%d]: Processed thread %lu\n", getpid(), idx); fflush(stderr); #endif } } if (!processed_self) { #ifdef DEBUG fprintf(stderr, "[%d]: Processing self\n", getpid()); fflush(stderr); #endif void*** tsrm_ls = (void***)ts_resource_ex(0, (THREAD_T*)0); callback(fd, g, tsrm_ls); #ifdef DEBUG fprintf(stderr, "[%d]: Processed self\n", getpid()); fflush(stderr); #endif } tsrm_mutex_unlock(mutex); }
static int php_http_gnutls_mutex_unlock(void **m) { return tsrm_mutex_unlock(*((MUTEX_T *) m)); }
/* fetches the requested resource for the current thread */ TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id) { THREAD_T thread_id; int hash_value; tsrm_tls_entry *thread_resources; #ifdef NETWARE /* The below if loop is added for NetWare to fix an abend while unloading PHP * when an Apache unload command is issued on the system console. * While exiting from PHP, at the end for some reason, this function is called * with tsrm_tls_table = NULL. When this happened, the server abends when * tsrm_tls_table is accessed since it is NULL. */ if(tsrm_tls_table) { #endif if (!th_id) { /* Fast path for looking up the resources for the current * thread. Its used by just about every call to * ts_resource_ex(). This avoids the need for a mutex lock * and our hashtable lookup. */ thread_resources = tsrm_tls_get(); if (thread_resources) { TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for current thread %d", id, (long) thread_resources->thread_id)); /* Read a specific resource from the thread's resources. * This is called outside of a mutex, so have to be aware about external * changes to the structure as we read it. */ TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count); } thread_id = tsrm_thread_id(); } else { thread_id = *th_id; } TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for thread %ld", id, (long) thread_id)); tsrm_mutex_lock(tsmm_mutex); hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size); thread_resources = tsrm_tls_table[hash_value]; if (!thread_resources) { allocate_new_resource(&tsrm_tls_table[hash_value], thread_id); return ts_resource_ex(id, &thread_id); } else { do { if (thread_resources->thread_id == thread_id) { break; } if (thread_resources->next) { thread_resources = thread_resources->next; } else { allocate_new_resource(&thread_resources->next, thread_id); return ts_resource_ex(id, &thread_id); /* * thread_resources = thread_resources->next; * break; */ } } while (thread_resources); } tsrm_mutex_unlock(tsmm_mutex); /* Read a specific resource from the thread's resources. * This is called outside of a mutex, so have to be aware about external * changes to the structure as we read it. */ TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count); #ifdef NETWARE } /* if(tsrm_tls_table) */ #endif }