static
int
globus_l_xio_pipe_activate(void)
{
int rc;
GlobusXIOName(globus_l_xio_pipe_activate);
GlobusDebugInit(GLOBUS_XIO_PIPE, TRACE INFO);
GlobusXIOPipeDebugEnter();
rc = globus_module_activate(GLOBUS_XIO_SYSTEM_MODULE);
if(rc != GLOBUS_SUCCESS)
{
goto error_activate;
}
# ifdef _WIN32
xio_l_pipe_attr_default.infd = GetStdHandle(STD_INPUT_HANDLE);
xio_l_pipe_attr_default.outfd = GetStdHandle(STD_OUTPUT_HANDLE);
# endif
GlobusXIORegisterDriver(pipe);
GlobusXIOPipeDebugExit();
return GLOBUS_SUCCESS;
error_activate:
GlobusXIOPipeDebugExitWithError();
GlobusDebugDestroy(GLOBUS_XIO_PIPE);
return rc;
}
static
int
globus_l_xio_popen_activate(void)
{
int rc;
GlobusXIOName(globus_l_xio_popen_activate);
GlobusDebugInit(GLOBUS_XIO_POPEN, TRACE INFO);
GlobusXIOPOpenDebugEnter();
rc = globus_module_activate(GLOBUS_XIO_SYSTEM_MODULE);
if(rc != GLOBUS_SUCCESS)
{
goto error_activate;
}
GlobusXIORegisterDriver(popen);
GlobusXIOPOpenDebugExit();
return GLOBUS_SUCCESS;
error_activate:
GlobusXIOPOpenDebugExitWithError();
GlobusDebugDestroy(GLOBUS_XIO_POPEN);
return rc;
}
static
int
globus_l_xio_net_manager_activate(void)
{
int rc;
GlobusDebugInit(GLOBUS_XIO_NET_MANAGER, TRACE);
rc = globus_module_activate(GLOBUS_XIO_MODULE);
if(rc != GLOBUS_SUCCESS)
{
goto activate_xio_fail;
}
rc = globus_module_activate(GLOBUS_NET_MANAGER_MODULE);
if(rc == GLOBUS_SUCCESS)
{
GlobusXIORegisterDriver(net_manager);
}
else
{
globus_module_deactivate(GLOBUS_XIO_MODULE);
}
activate_xio_fail:
return rc;
}
static
int
gfork_l_activate()
{
int rc;
globus_result_t res;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
if(rc != 0)
{
goto error_activate;
}
if(!gfork_l_globals_set)
{
GlobusDebugInit(GLOBUS_GFORK,
ERROR WARNING TRACE INTERNAL_TRACE INFO STATE INFO_VERBOSE);
gfork_i_state_init();
res = globus_xio_stack_init(&gfork_i_file_stack, NULL);
if(res != GLOBUS_SUCCESS)
{
goto error_file_stack;
}
res = globus_xio_driver_load("file", &gfork_i_file_driver);
if(res != GLOBUS_SUCCESS)
{
goto error_file_driver;
}
res = globus_xio_stack_push_driver(
gfork_i_file_stack, gfork_i_file_driver);
if(res != GLOBUS_SUCCESS)
{
goto error_file_push;
}
globus_xio_attr_init(&gfork_i_file_attr);
}
gfork_l_globals_set = GLOBUS_TRUE;
return 0;
error_file_push:
globus_xio_driver_unload(gfork_i_file_driver);
error_file_driver:
globus_xio_stack_destroy(gfork_i_file_stack);
error_file_stack:
globus_module_deactivate(GLOBUS_XIO_MODULE);
error_activate:
return 1;
}
int
activate(void)
{
int rc = globus_module_activate(GLOBUS_COMMON_MODULE);
if(rc != GLOBUS_SUCCESS)
return rc;
globus_extension_registry_add(GLOBUS_GFS_DSI_REGISTRY,
"blackpearl",
GlobusExtensionMyModule(globus_gridftp_server_blackpearl),
&blackpearl_dsi_iface);
GlobusDebugInit(GLOBUS_GRIDFTP_SERVER_BLACKPEARL,
ERROR WARNING TRACE INTERNAL_TRACE INFO STATE INFO_VERBOSE);
return 0;
}
static int
globus_l_usage_stats_activate()
{
globus_result_t result = GLOBUS_SUCCESS;
int rc = 0;
#ifndef TARGET_ARCH_ARM
globus_l_usage_stats_stack = NULL;
globus_l_usage_stats_udp_driver = NULL;
rc = globus_module_activate(GLOBUS_XIO_MODULE);
if(rc != GLOBUS_SUCCESS)
{
return rc;
}
GlobusDebugInit(GLOBUS_USAGE, MESSAGES);
if((result = globus_xio_stack_init(
&globus_l_usage_stats_stack, NULL)) != GLOBUS_SUCCESS)
{
return result;
}
if((result = globus_xio_driver_load(
"udp", &globus_l_usage_stats_udp_driver)) != GLOBUS_SUCCESS)
{
return result;
}
if((result = globus_xio_stack_push_driver(
globus_l_usage_stats_stack, globus_l_usage_stats_udp_driver))
!= GLOBUS_SUCCESS)
{
return result;
}
return 0;
#else
return 1;
#endif
}
static
int
globus_l_job_manager_module_activate(void)
{
time_t timestamp_val;
globus_l_job_manager_logfile_state_t *
logfile_state;
int rc;
globus_reltime_t delay;
globus_result_t result;
char * scheduler;
rc = globus_module_activate(GLOBUS_COMMON_MODULE);
if (rc != GLOBUS_SUCCESS)
{
goto activate_common_failed;
}
rc = globus_mutex_init(&globus_l_job_manager_mutex, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto mutex_init_failed;
}
rc = globus_cond_init(&globus_l_job_manager_cond, NULL);
if (rc != GLOBUS_SUCCESS)
{
goto cond_init_failed;
}
shutdown_called = GLOBUS_FALSE;
callback_count = 0;
GlobusDebugInit(
SEG_JOB_MANAGER,
SEG_JOB_MANAGER_DEBUG_INFO
SEG_JOB_MANAGER_DEBUG_WARN
SEG_JOB_MANAGER_DEBUG_ERROR
SEG_JOB_MANAGER_DEBUG_TRACE);
logfile_state = calloc(1, sizeof(globus_l_job_manager_logfile_state_t));
if (logfile_state == NULL)
{
goto calloc_state_failed;
}
/* Configuration info */
result = globus_scheduler_event_generator_get_timestamp(×tamp_val);
if (result != GLOBUS_SUCCESS)
{
goto get_timestamp_failed;
}
if (timestamp_val != 0)
{
if (globus_libc_gmtime_r(
×tamp_val,
&logfile_state->start_timestamp) == NULL)
{
goto gmtime_failed;
}
}
scheduler = globus_libc_getenv(JOB_MANAGER_SEG_SCHEDULER);
if (scheduler == NULL)
{
SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_ERROR,
("Error: %s not set\n", JOB_MANAGER_SEG_SCHEDULER));
result = GLOBUS_FAILURE;
goto get_scheduler_failed;
}
if (getenv(JOB_MANAGER_SEG_LOG_PATH))
{
logfile_state->log_dir = strdup(getenv(JOB_MANAGER_SEG_LOG_PATH));
}
else
{
char * log_dir_pattern = globus_common_create_string(
"${localstatedir}/lib/globus/globus-seg-%s", scheduler);
globus_eval_path(log_dir_pattern, &logfile_state->log_dir);
free(log_dir_pattern);
}
if (logfile_state->log_dir == NULL)
{
SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_ERROR,
("Error: out of memory\n"));
goto get_path_failed;
}
/* Convert timestamp to filename */
rc = globus_l_job_manager_find_logfile(logfile_state);
if (rc == GLOBUS_SUCCESS)
{
logfile_state->fp = fopen(logfile_state->path, "r");
if (logfile_state->fp == NULL)
{
rc = SEG_JOB_MANAGER_ERROR_OUT_OF_MEMORY;
goto fopen_failed;
}
GlobusTimeReltimeSet(delay, 0, 0);
}
else if(rc == SEG_JOB_MANAGER_ERROR_LOG_NOT_PRESENT)
{
GlobusTimeReltimeSet(delay, 1, 0);
}
else
{
goto bad_log_path;
}
result = globus_callback_register_oneshot(
&logfile_state->callback,
&delay,
globus_l_job_manager_poll_callback,
logfile_state);
if (result != GLOBUS_SUCCESS)
{
goto oneshot_failed;
}
callback_count++;
return 0;
oneshot_failed:
if (logfile_state->fp)
{
fclose(logfile_state->fp);
}
fopen_failed:
if (logfile_state->path)
{
free(logfile_state->path);
}
bad_log_path:
free(logfile_state->log_dir);
get_path_failed:
get_scheduler_failed:
get_timestamp_failed:
gmtime_failed:
free(logfile_state);
calloc_state_failed:
globus_cond_destroy(&globus_l_job_manager_cond);
cond_init_failed:
globus_mutex_destroy(&globus_l_job_manager_mutex);
mutex_init_failed:
globus_module_deactivate(GLOBUS_COMMON_MODULE);
activate_common_failed:
return 1;
}
/**
* load config file. substitute $BUILD_FLAVOR for build_flavor,
*/
static
int
globus_l_extension_activate(void)
{
static globus_bool_t initialized = GLOBUS_FALSE;
globus_result_t result = GLOBUS_SUCCESS;
GlobusFuncName(globus_l_extension_activate);
if(!initialized)
{
GlobusDebugInit(GLOBUS_EXTENSION, TRACE VERBOSE DLL);
GlobusExtensionDebugEnter();
globus_rmutex_init(&globus_l_libtool_mutex, NULL);
globus_thread_key_create(&globus_l_libtool_key, NULL);
# ifndef BUILD_STATIC_ONLY
if(lt_dlinit() != 0)
{
goto error_dlinit;
}
# if HAVE_LT_DLMUTEX_REGISTER
if(lt_dlmutex_register(
globus_l_libtool_mutex_lock,
globus_l_libtool_mutex_unlock,
globus_l_libtool_set_error,
globus_l_libtool_get_error) != 0)
{
goto error_dlmutex;
}
# endif
# endif /* !BUILD_STATIC_ONLY */
globus_hashtable_init(
&globus_l_extension_loaded,
32,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
globus_hashtable_init(
&globus_l_extension_builtins,
32,
globus_hashtable_string_hash,
globus_hashtable_string_keyeq);
globus_rmutex_init(&globus_l_extension_mutex, NULL);
globus_thread_key_create(&globus_l_extension_owner_key, NULL);
result = globus_eval_path("${libdir}", &globus_l_globus_location);
if(result != GLOBUS_SUCCESS)
{
goto error_path;
}
initialized = GLOBUS_TRUE;
GlobusExtensionDebugExit();
}
return GLOBUS_SUCCESS;
error_path:
globus_hashtable_destroy(&globus_l_extension_builtins);
globus_hashtable_destroy(&globus_l_extension_loaded);
# ifndef BUILD_STATIC_ONLY
# if HAVE_LT_DLMUTEX_REGISTER
error_dlmutex:
# endif
lt_dlexit();
error_dlinit:
GlobusExtensionDebugExitWithError();
return GLOBUS_FAILURE;
# endif /* !BUILD_STATIC_ONLY */
}
int
globus_i_xio_system_common_activate(void)
{
GlobusXIOName(globus_i_xio_system_common_activate);
GlobusDebugInit(GLOBUS_XIO_SYSTEM, TRACE DATA INFO RAW);
GlobusXIOSystemDebugEnter();
/* I am going to leave this memory around after deactivation. To safely
* destroy them, I would need a lot more synchronization of kicked out
* callbacks
*/
if(globus_module_activate(GLOBUS_XIO_MODULE) != GLOBUS_SUCCESS)
{
goto error_activate;
}
if(!globus_l_xio_system_memory_initialized)
{
globus_l_xio_system_memory_initialized = GLOBUS_TRUE;
globus_memory_init(
&globus_i_xio_system_op_info_memory,
sizeof(globus_i_xio_system_op_info_t),
10);
globus_memory_init(
&globus_i_xio_system_iov_memory, sizeof(struct iovec) * 10, 10);
}
globus_l_xio_iov_max = -1;
#ifdef _SC_IOV_MAX
if (globus_l_xio_iov_max == -1)
{
/* If this returns -1, the limit might be indefinite if errno is
* unchanged, but that doesn't mean infinite. It's unclear what
* one is to do in that case
*/
globus_l_xio_iov_max = sysconf(_SC_IOV_MAX);
}
#endif
#ifdef IOV_MAX
if (globus_l_xio_iov_max == -1)
{
globus_l_xio_iov_max = IOV_MAX;
}
#endif
#ifdef _XOPEN_IOV_MAX
if (globus_l_xio_iov_max == -1)
{
globus_l_xio_iov_max = _XOPEN_IOV_MAX;
}
#endif
if (globus_l_xio_iov_max == -1)
{
globus_l_xio_iov_max = 16;
}
GlobusXIOSystemDebugExit();
return GLOBUS_SUCCESS;
error_activate:
GlobusXIOSystemDebugExitWithError();
GlobusDebugDestroy(GLOBUS_XIO_SYSTEM);
return GLOBUS_FAILURE;
}
