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;
}
