/*
* Reopen all the streams; used during checkpoint/restart.
*/
void pmix_output_reopen_all(void)
{
char *str;
char hostname[32];
str = getenv("PMIX_OUTPUT_STDERR_FD");
if (NULL != str) {
default_stderr_fd = atoi(str);
} else {
default_stderr_fd = -1;
}
gethostname(hostname, sizeof(hostname));
if( NULL != verbose.lds_prefix ) {
free(verbose.lds_prefix);
verbose.lds_prefix = NULL;
}
asprintf(&verbose.lds_prefix, "[%s:%05d] ", hostname, getpid());
#if 0
int i;
pmix_output_stream_t lds;
for (i = 0; i < PMIX_OUTPUT_MAX_STREAMS; ++i) {
/* scan till we find ldi_used == 0, which is the end-marker */
if (!info[i].ldi_used) {
break;
}
/*
* set this to zero to ensure that pmix_output_open will
* return this same index as the output stream id
*/
info[i].ldi_used = false;
#if USE_SYSLOG
lds.lds_want_syslog = info[i].ldi_syslog;
lds.lds_syslog_priority = info[i].ldi_syslog_priority;
lds.lds_syslog_ident = info[i].ldi_syslog_ident;
#else
lds.lds_want_syslog = false;
#endif
lds.lds_prefix = info[i].ldi_prefix;
lds.lds_suffix = info[i].ldi_suffix;
lds.lds_want_stdout = info[i].ldi_stdout;
lds.lds_want_stderr = info[i].ldi_stderr;
lds.lds_want_file = (-1 == info[i].ldi_fd) ? false : true;
/* open all streams in append mode */
lds.lds_want_file_append = true;
lds.lds_file_suffix = info[i].ldi_file_suffix;
/*
* call pmix_output_open to open the stream. The return value
* is guaranteed to be i. So we can ignore it.
*/
pmix_output_open(&lds);
}
#endif
}
/*
* Setup the output stream infrastructure
*/
bool pmix_output_init(void)
{
int i;
char hostname[PMIX_MAXHOSTNAMELEN];
char *str;
if (initialized) {
return true;
}
str = getenv("PMIX_OUTPUT_STDERR_FD");
if (NULL != str) {
default_stderr_fd = atoi(str);
}
str = getenv("PMIX_OUTPUT_REDIRECT");
if (NULL != str) {
if (0 == strcasecmp(str, "syslog")) {
pmix_output_redirected_to_syslog = true;
}
}
str = getenv("PMIX_OUTPUT_SYSLOG_PRI");
#ifdef HAVE_SYSLOG_H
if (NULL != str) {
if (0 == strcasecmp(str, "info")) {
pmix_output_redirected_syslog_pri = LOG_INFO;
} else if (0 == strcasecmp(str, "error")) {
pmix_output_redirected_syslog_pri = LOG_ERR;
} else if (0 == strcasecmp(str, "warn")) {
pmix_output_redirected_syslog_pri = LOG_WARNING;
} else {
pmix_output_redirected_syslog_pri = LOG_ERR;
}
} else {
pmix_output_redirected_syslog_pri = LOG_ERR;
}
#endif
str = getenv("PMIX_OUTPUT_SYSLOG_IDENT");
if (NULL != str) {
redirect_syslog_ident = strdup(str);
}
PMIX_CONSTRUCT(&verbose, pmix_output_stream_t);
if (pmix_output_redirected_to_syslog) {
verbose.lds_want_syslog = true;
verbose.lds_syslog_priority = pmix_output_redirected_syslog_pri;
if (NULL != str) {
verbose.lds_syslog_ident = strdup(redirect_syslog_ident);
}
verbose.lds_want_stderr = false;
verbose.lds_want_stdout = false;
} else {
verbose.lds_want_stderr = true;
}
gethostname(hostname, sizeof(hostname));
hostname[sizeof(hostname)-1] = '\0';
if (0 > asprintf(&verbose.lds_prefix, "[%s:%05d] ", hostname, getpid())) {
return PMIX_ERR_NOMEM;
}
for (i = 0; i < PMIX_OUTPUT_MAX_STREAMS; ++i) {
info[i].ldi_used = false;
info[i].ldi_enabled = false;
info[i].ldi_syslog = pmix_output_redirected_to_syslog;
info[i].ldi_file = false;
info[i].ldi_file_suffix = NULL;
info[i].ldi_file_want_append = false;
info[i].ldi_fd = -1;
info[i].ldi_file_num_lines_lost = 0;
}
initialized = true;
/* Set some defaults */
if (0 > asprintf(&output_prefix, "output-pid%d-", getpid())) {
return false;
}
output_dir = strdup(pmix_tmp_directory());
/* Open the default verbose stream */
verbose_stream = pmix_output_open(&verbose);
return true;
}
int pmix_rte_init(pmix_proc_type_t type,
pmix_info_t info[], size_t ninfo,
pmix_ptl_cbfunc_t cbfunc)
{
int ret, debug_level;
char *error = NULL, *evar;
size_t n;
char hostname[PMIX_MAXHOSTNAMELEN];
if( ++pmix_initialized != 1 ) {
if( pmix_initialized < 1 ) {
return PMIX_ERROR;
}
return PMIX_SUCCESS;
}
#if PMIX_NO_LIB_DESTRUCTOR
if (pmix_init_called) {
/* can't use show_help here */
fprintf (stderr, "pmix_init: attempted to initialize after finalize without compiler "
"support for either __attribute__(destructor) or linker support for -fini -- process "
"will likely abort\n");
return PMIX_ERR_NOT_SUPPORTED;
}
#endif
pmix_init_called = true;
/* initialize the output system */
if (!pmix_output_init()) {
return PMIX_ERROR;
}
/* initialize install dirs code */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_pinstalldirs_base_framework, 0))) {
fprintf(stderr, "pmix_pinstalldirs_base_open() failed -- process will likely abort (%s:%d, returned %d instead of PMIX_SUCCESS)\n",
__FILE__, __LINE__, ret);
return ret;
}
/* initialize the help system */
pmix_show_help_init();
/* keyval lex-based parser */
if (PMIX_SUCCESS != (ret = pmix_util_keyval_parse_init())) {
error = "pmix_util_keyval_parse_init";
goto return_error;
}
/* Setup the parameter system */
if (PMIX_SUCCESS != (ret = pmix_mca_base_var_init())) {
error = "mca_base_var_init";
goto return_error;
}
/* register params for pmix */
if (PMIX_SUCCESS != (ret = pmix_register_params())) {
error = "pmix_register_params";
goto return_error;
}
/* initialize the mca */
if (PMIX_SUCCESS != (ret = pmix_mca_base_open())) {
error = "mca_base_open";
goto return_error;
}
/* setup the globals structure */
gethostname(hostname, PMIX_MAXHOSTNAMELEN);
pmix_globals.hostname = strdup(hostname);
memset(&pmix_globals.myid.nspace, 0, PMIX_MAX_NSLEN+1);
pmix_globals.myid.rank = PMIX_RANK_INVALID;
PMIX_CONSTRUCT(&pmix_globals.events, pmix_events_t);
pmix_globals.event_window.tv_sec = pmix_event_caching_window;
pmix_globals.event_window.tv_usec = 0;
PMIX_CONSTRUCT(&pmix_globals.cached_events, pmix_list_t);
/* construct the global notification ring buffer */
PMIX_CONSTRUCT(&pmix_globals.notifications, pmix_hotel_t);
ret = pmix_hotel_init(&pmix_globals.notifications, pmix_globals.max_events,
pmix_globals.evbase, pmix_globals.event_eviction_time,
_notification_eviction_cbfunc);
if (PMIX_SUCCESS != ret) {
error = "notification hotel init";
goto return_error;
}
/* and setup the iof request tracking list */
PMIX_CONSTRUCT(&pmix_globals.iof_requests, pmix_list_t);
/* Setup client verbosities as all procs are allowed to
* access client APIs */
if (0 < pmix_client_globals.get_verbose) {
/* set default output */
pmix_client_globals.get_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.get_output,
pmix_client_globals.get_verbose);
}
if (0 < pmix_client_globals.connect_verbose) {
/* set default output */
pmix_client_globals.connect_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.connect_output,
pmix_client_globals.connect_verbose);
}
if (0 < pmix_client_globals.fence_verbose) {
/* set default output */
pmix_client_globals.fence_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.fence_output,
pmix_client_globals.fence_verbose);
}
if (0 < pmix_client_globals.pub_verbose) {
/* set default output */
pmix_client_globals.pub_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.pub_output,
pmix_client_globals.pub_verbose);
}
if (0 < pmix_client_globals.spawn_verbose) {
/* set default output */
pmix_client_globals.spawn_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.spawn_output,
pmix_client_globals.spawn_verbose);
}
if (0 < pmix_client_globals.event_verbose) {
/* set default output */
pmix_client_globals.event_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.event_output,
pmix_client_globals.event_verbose);
}
if (0 < pmix_client_globals.iof_verbose) {
/* set default output */
pmix_client_globals.iof_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.iof_output,
pmix_client_globals.iof_verbose);
}
/* get our effective id's */
pmix_globals.uid = geteuid();
pmix_globals.gid = getegid();
/* see if debug is requested */
if (NULL != (evar = getenv("PMIX_DEBUG"))) {
debug_level = strtol(evar, NULL, 10);
pmix_globals.debug_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_globals.debug_output, debug_level);
}
/* create our peer object */
pmix_globals.mypeer = PMIX_NEW(pmix_peer_t);
if (NULL == pmix_globals.mypeer) {
ret = PMIX_ERR_NOMEM;
goto return_error;
}
/* whatever our declared proc type, we are definitely v3.0 */
pmix_globals.mypeer->proc_type = type | PMIX_PROC_V3;
/* create an nspace object for ourselves - we will
* fill in the nspace name later */
pmix_globals.mypeer->nptr = PMIX_NEW(pmix_namespace_t);
if (NULL == pmix_globals.mypeer->nptr) {
PMIX_RELEASE(pmix_globals.mypeer);
ret = PMIX_ERR_NOMEM;
goto return_error;
}
/* scan incoming info for directives */
if (NULL != info) {
for (n=0; n < ninfo; n++) {
if (PMIX_CHECK_KEY(&info[n], PMIX_EVENT_BASE)) {
pmix_globals.evbase = (pmix_event_base_t*)info[n].value.data.ptr;
pmix_globals.external_evbase = true;
} else if (PMIX_CHECK_KEY(&info[n], PMIX_HOSTNAME)) {
if (NULL != pmix_globals.hostname) {
free(pmix_globals.hostname);
}
pmix_globals.hostname = strdup(info[n].value.data.string);
} else if (PMIX_CHECK_KEY(&info[n], PMIX_NODEID)) {
PMIX_VALUE_GET_NUMBER(ret, &info[n].value, pmix_globals.nodeid, uint32_t);
if (PMIX_SUCCESS != ret) {
goto return_error;
}
}
}
}
/* the choice of modules to use when communicating with a peer
* will be done by the individual init functions and at the
* time of connection to that peer */
/* open the bfrops and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_bfrops_base_framework, 0)) ) {
error = "pmix_bfrops_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_bfrop_base_select()) ) {
error = "pmix_bfrops_base_select";
goto return_error;
}
/* open the ptl and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_ptl_base_framework, 0)) ) {
error = "pmix_ptl_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_ptl_base_select()) ) {
error = "pmix_ptl_base_select";
goto return_error;
}
/* set the notification callback function */
if (PMIX_SUCCESS != (ret = pmix_ptl_base_set_notification_cbfunc(cbfunc))) {
error = "pmix_ptl_set_notification_cbfunc";
goto return_error;
}
/* open the psec and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_psec_base_framework, 0))) {
error = "pmix_psec_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_psec_base_select())) {
error = "pmix_psec_base_select";
goto return_error;
}
/* open the gds and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_gds_base_framework, 0)) ) {
error = "pmix_gds_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_gds_base_select(info, ninfo)) ) {
error = "pmix_gds_base_select";
goto return_error;
}
/* initialize pif framework */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_pif_base_framework, 0))) {
error = "pmix_pif_base_open";
return ret;
}
/* open the preg and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_preg_base_framework, 0)) ) {
error = "pmix_preg_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_preg_base_select()) ) {
error = "pmix_preg_base_select";
goto return_error;
}
/* open the plog and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_plog_base_framework, 0)) ) {
error = "pmix_plog_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_plog_base_select()) ) {
error = "pmix_plog_base_select";
goto return_error;
}
/* if an external event base wasn't provide, create one */
if (!pmix_globals.external_evbase) {
/* tell libevent that we need thread support */
pmix_event_use_threads();
/* create an event base and progress thread for us */
if (NULL == (pmix_globals.evbase = pmix_progress_thread_init(NULL))) {
error = "progress thread";
ret = PMIX_ERROR;
goto return_error;
}
}
return PMIX_SUCCESS;
return_error:
if (PMIX_ERR_SILENT != ret) {
pmix_show_help( "help-pmix-runtime.txt",
"pmix_init:startup:internal-failure", true,
error, ret );
}
return ret;
}
