void thread_id_assign() { static int cnt = 0; long thread_id; globus_thread_once(&thread_ids_initialized, thread_ids_init); globus_mutex_lock(&common_mutex); { thread_id = cnt++; } globus_mutex_unlock(&common_mutex); globus_thread_setspecific(thread_ids, (void *) thread_id); # if (DEBUG_LEVEL > 0) { globus_stdio_lock(); { printf("%04ld: thread_id_assign() - complete\n", thread_id_get()); } globus_stdio_unlock(); } # endif }
static void globus_l_libtool_set_error( const char * error) { globus_thread_setspecific(globus_l_libtool_key, (void *) error); }
globus_object_t * globus_error_peek( globus_result_t result) { globus_object_t * error; int err; if (! s_error_cache_initialized ) return NULL; if ( result == GLOBUS_SUCCESS ) return NULL; err = local_mutex_lock (&s_result_to_object_mutex); if (err) return NULL; error = globus_object_cache_lookup (&s_result_to_object_mapper, (void *) (intptr_t) result); if (error!=NULL) { globus_object_t * cached; globus_object_reference(error); cached = (globus_object_t *) globus_thread_getspecific(s_peek_key); if(cached) { globus_object_free(cached); } globus_thread_setspecific(s_peek_key, error); } local_mutex_unlock (&s_result_to_object_mutex); if (error!=NULL) return error; else return GLOBUS_ERROR_NO_INFO; }
/* * globus_module_deactivate() */ int globus_module_deactivate( globus_module_descriptor_t * module_descriptor) { globus_l_module_key_t parent_key; int ret_val; globus_l_module_key_t parent_key_save; /* * If module activation hasn't been initialized then return an error */ if (!globus_i_module_initialized) { return GLOBUS_FAILURE; } parent_key = (globus_l_module_key_t) globus_thread_getspecific(globus_l_deactivate_parent_key); /* * Once the recursive mutex has been acquired, decrement the reference * counter for this module, and call it's deactivation function if it is * no longer being used. */ ret_val = GLOBUS_SUCCESS; if (module_descriptor->activation_func != GLOBUS_NULL) { globus_l_module_entry_t * entry; globus_l_module_mutex_lock(&globus_l_module_mutex); entry = globus_l_module_decrement(module_descriptor, parent_key); if (entry && entry->reference_count == 0) { globus_l_module_mutex_unlock(&globus_l_module_mutex); parent_key_save = parent_key; globus_thread_setspecific( globus_l_deactivate_parent_key, module_descriptor->activation_func); if(entry->deactivate_cb) { ret_val = entry->deactivate_cb( module_descriptor, entry->user_arg); } else if(module_descriptor->deactivation_func != NULL) { ret_val = module_descriptor->deactivation_func(); } globus_thread_setspecific( globus_l_deactivate_parent_key, parent_key_save); } else { if(globus_l_module_reference_count(module_descriptor) == 0) { ret_val = GLOBUS_FAILURE; } globus_l_module_mutex_unlock(&globus_l_module_mutex); } } return ret_val; }
/* * globus_module_activate() */ int globus_module_activate_proxy( globus_module_descriptor_t * module_descriptor, globus_module_deactivate_proxy_cb_t deactivate_cb, void * user_arg) { globus_l_module_key_t parent_key; int ret_val; globus_l_module_key_t parent_key_save; /* * If this is the first time this routine has been called, then we need to * initialize the internal data structures and activate the threads * packages if the system has been configured to use threads. */ if (globus_i_module_initialized == GLOBUS_FALSE) { globus_i_module_initialized = GLOBUS_TRUE; globus_l_module_initialize(); } parent_key = (globus_l_module_key_t) globus_thread_getspecific(globus_l_activate_parent_key); /* * Once the recursive mutex has been acquired, increment the reference * counter for this module, and call it's activation function if it is not * currently active. */ globus_l_module_mutex_lock(&globus_l_module_mutex); { ret_val = GLOBUS_SUCCESS; if (module_descriptor->activation_func != GLOBUS_NULL) { if (globus_l_module_increment(module_descriptor, parent_key, deactivate_cb, user_arg) == GLOBUS_TRUE) { parent_key_save = parent_key; globus_thread_setspecific( globus_l_activate_parent_key, module_descriptor->activation_func); ret_val = module_descriptor->activation_func(); if(ret_val != GLOBUS_SUCCESS) { globus_l_module_decrement( module_descriptor, parent_key_save); } else { /* * Set up the exit handler */ # if defined(HAVE_ATEXIT) || defined(HAVE_ONEXIT) { if(module_descriptor->atexit_func != GLOBUS_NULL) { /* only call the atexit function once */ if(!globus_list_search( globus_l_module_atexit_funcs, (void *) module_descriptor->atexit_func)) { globus_list_insert( &globus_l_module_atexit_funcs, (void *) module_descriptor->atexit_func); atexit(module_descriptor->atexit_func); } } } # endif } globus_thread_setspecific( globus_l_activate_parent_key, parent_key_save); } } } globus_l_module_mutex_unlock(&globus_l_module_mutex); return ret_val; }
int globus_extension_activate( const char * extension_name) { globus_l_extension_module_t * extension; globus_l_extension_module_t * last_extension; globus_l_extension_builtin_t * builtin; int rc; globus_result_t result = GLOBUS_FAILURE; GlobusFuncName(globus_extension_activate); GlobusExtensionDebugEnterSymbol(extension_name); if(!extension_name) { goto error_param; } globus_rmutex_lock(&globus_l_extension_mutex); { extension = (globus_l_extension_module_t *) globus_hashtable_lookup( &globus_l_extension_loaded, (void *) extension_name); if(!extension) { extension = (globus_l_extension_module_t *) globus_malloc(sizeof(globus_l_extension_module_t)); if(!extension) { goto error_alloc; } extension->module_ref = 1; extension->ref = 1; extension->name = globus_libc_strdup(extension_name); if(!extension->name) { goto error_strdup; } builtin = (globus_l_extension_builtin_t *) globus_hashtable_lookup( &globus_l_extension_builtins, (void *) extension_name); if(builtin && (!builtin->owner || builtin->owner->module_ref > 0)) { # if !defined(BUILD_STATIC_ONLY) { extension->dlhandle = NULL; } # endif extension->module = builtin->module; extension->owner = builtin->owner; if(extension->owner) { extension->owner->ref++; } } else { extension->owner = NULL; # if !defined(BUILD_STATIC_ONLY) { result = globus_l_extension_dlopen( extension->name, &extension->dlhandle); if(result != GLOBUS_SUCCESS) { goto error_dll; } result = globus_l_extension_get_module( extension->dlhandle, extension_name, &extension->module); } # else { globus_assert(BUILD_STATIC_ONLY == 0); result = globus_error_put( globus_error_construct_error( GLOBUS_EXTENSION_MODULE, NULL, GLOBUS_EXTENSION_ERROR_OPEN_FAILED, __FILE__, _globus_func_name, __LINE__, "No support for dynamically loading %s\n", extension->name)); } # endif /* !defined(BUILD_STATIC_ONLY) */ if(result != GLOBUS_SUCCESS) { goto error_module; } } globus_hashtable_insert( &globus_l_extension_loaded, extension->name, extension); last_extension = (globus_l_extension_module_t *) globus_thread_getspecific(globus_l_extension_owner_key); globus_thread_setspecific(globus_l_extension_owner_key, extension); #if USE_SYMBOL_LABELS { int pre_warned = WARNING_USING_MIXED_THREAD_MODELS; #endif rc = globus_module_activate_proxy( extension->module, globus_l_extension_deactivate_proxy, extension); #if USE_SYMBOL_LABELS if ((!pre_warned) && WARNING_USING_MIXED_THREAD_MODELS) { GlobusExtensionDebugPrintf( GLOBUS_L_EXTENSION_DEBUG_VERBOSE, (_GCSL("[%s] Warning: extension %s was compiled with pthreads for GT 5.0.x and may not work correctly\n"), _globus_func_name, extension->name)); } } #endif globus_thread_setspecific( globus_l_extension_owner_key, last_extension); if(rc != GLOBUS_SUCCESS) { goto error_activate; } } else { extension->module_ref++; extension->ref++; } } globus_rmutex_unlock(&globus_l_extension_mutex); GlobusExtensionDebugExit(); return GLOBUS_SUCCESS; error_activate: globus_hashtable_remove( &globus_l_extension_loaded, extension->name); if(builtin && builtin->owner) { builtin->owner->ref--; } error_module: #ifndef BUILD_STATIC_ONLY if(extension->dlhandle) { lt_dlclose(extension->dlhandle); } error_dll: #endif /* !BUILD_STATIC_ONLY */ globus_free(extension->name); error_strdup: globus_free(extension); error_alloc: globus_rmutex_unlock(&globus_l_extension_mutex); error_param: GlobusExtensionDebugExitWithError(); return result; }