long
thread_id_get()
{
long thread_id;
thread_id = (long) globus_thread_getspecific(thread_ids);
return thread_id;
}
int
globus_extension_register_builtin(
const char * extension_name,
globus_module_descriptor_t * module_descriptor)
{
globus_l_extension_builtin_t * builtin;
GlobusFuncName(globus_extension_register_builtin);
GlobusExtensionDebugEnterSymbol(extension_name);
builtin = (globus_l_extension_builtin_t *)
globus_malloc(sizeof(globus_l_extension_builtin_t));
if(!builtin)
{
goto error_alloc;
}
builtin->owner = (globus_l_extension_module_t *)
globus_thread_getspecific(globus_l_extension_owner_key);
builtin->module = module_descriptor;
builtin->extension_name = globus_libc_strdup(extension_name);
if(!builtin->extension_name)
{
goto error_strdup;
}
globus_rmutex_lock(&globus_l_extension_mutex);
{
int rc;
rc = globus_hashtable_insert(
&globus_l_extension_builtins, builtin->extension_name, builtin);
if(rc != 0)
{
goto error_insert;
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return GLOBUS_SUCCESS;
error_insert:
globus_rmutex_unlock(&globus_l_extension_mutex);
globus_free(builtin->extension_name);
error_strdup:
globus_free(builtin);
error_alloc:
GlobusExtensionDebugExitWithError();
return GLOBUS_FAILURE;
}
void *
globus_extension_reference(
globus_extension_handle_t handle)
{
globus_l_extension_handle_t * entry;
void * datum = NULL;
GlobusFuncName(globus_extension_reference);
GlobusExtensionDebugEnter();
if(!handle)
{
goto error_param;
}
entry = handle;
globus_rmutex_lock(&globus_l_extension_mutex);
{
datum = entry->datum;
entry->ref++;
if(entry->owner)
{
entry->owner->ref++;
globus_assert(
(entry->owner != (globus_l_extension_module_t *)
globus_thread_getspecific(
globus_l_extension_owner_key)) &&
"You can not reference something owned by the calling module");
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return datum;
error_param:
GlobusExtensionDebugExitWithError();
return NULL;
}
static int s_error_cache_destroy (void)
{
globus_object_t * cached;
cached = (globus_object_t *) globus_thread_getspecific(s_peek_key);
if(cached)
{
globus_object_free(cached);
}
globus_thread_key_delete(s_peek_key);
globus_thread_key_delete(globus_i_error_verbose_key);
globus_object_cache_destroy (&s_result_to_object_mapper);
local_mutex_destroy (&s_result_to_object_mutex);
s_error_cache_initialized = 0;
globus_module_deactivate(GLOBUS_OBJECT_MODULE);
return GLOBUS_SUCCESS;
}
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;
}
void *
globus_extension_lookup(
globus_extension_handle_t * handle,
globus_extension_registry_t * registry,
void * symbol)
{
globus_l_extension_handle_t * entry;
void * datum = NULL;
GlobusFuncName(globus_extension_lookup);
GlobusExtensionDebugEnterSymbol(registry->user_hashing ? "" : symbol);
if(!handle)
{
goto error_param;
}
*handle = NULL;
if(!registry || !symbol)
{
goto error_param;
}
globus_rmutex_lock(&globus_l_extension_mutex);
{
if(registry->initialized)
{
entry = (globus_l_extension_handle_t *)
globus_hashtable_lookup(®istry->table, (void *) symbol);
if(entry && (!entry->owner || entry->owner->module_ref > 0))
{
datum = entry->datum;
entry->ref++;
if(entry->owner)
{
entry->owner->ref++;
globus_assert(
(entry->owner != (globus_l_extension_module_t *)
globus_thread_getspecific(
globus_l_extension_owner_key)) &&
"You can not lookup something owned by the calling module");
GlobusExtensionDebugPrintf(
GLOBUS_L_EXTENSION_DEBUG_VERBOSE,
(_GCSL("[%s] Accessing entry %s within %s\n"),
_globus_func_name,
registry->user_hashing ? "" : symbol,
entry->owner->name));
}
*handle = entry;
}
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return datum;
error_param:
GlobusExtensionDebugExitWithError();
return NULL;
}
int
globus_extension_registry_add(
globus_extension_registry_t * registry,
void * symbol,
globus_module_descriptor_t * module,
void * data)
{
globus_l_extension_handle_t * entry;
GlobusFuncName(globus_extension_registry_add);
GlobusExtensionDebugEnterSymbol(registry->user_hashing ? "" : symbol);
if(!data || !symbol || !registry)
{
goto error_params;
}
entry = (globus_l_extension_handle_t *)
globus_malloc(sizeof(globus_l_extension_handle_t));
if(!entry)
{
goto error_malloc;
}
entry->owner = (globus_l_extension_module_t *)
globus_thread_getspecific(globus_l_extension_owner_key);
entry->module = module;
entry->datum = data;
entry->ref = 1;
entry->symbol = symbol;
entry->user_hashing = registry->user_hashing;
globus_rmutex_lock(&globus_l_extension_mutex);
{
if(!registry->initialized)
{
if(globus_hashtable_init(
®istry->table,
20,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq) != GLOBUS_SUCCESS)
{
goto error_init;
}
registry->initialized = GLOBUS_TRUE;
}
if(globus_hashtable_insert(
®istry->table, entry->symbol, entry) != GLOBUS_SUCCESS)
{
goto error_insert;
}
}
globus_rmutex_unlock(&globus_l_extension_mutex);
GlobusExtensionDebugExit();
return GLOBUS_SUCCESS;
error_insert:
error_init:
globus_rmutex_unlock(&globus_l_extension_mutex);
globus_free(entry);
error_malloc:
error_params:
GlobusExtensionDebugExitWithError();
return GLOBUS_FAILURE;
}
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;
}
static
const char *
globus_l_libtool_get_error(void)
{
return (char *) globus_thread_getspecific(globus_l_libtool_key);
}