int pmix_mca_base_var_group_init (void)
{
int ret;
if (!pmix_mca_base_var_group_initialized) {
PMIX_CONSTRUCT(&pmix_mca_base_var_groups, pmix_pointer_array_t);
/* These values are arbitrary */
ret = pmix_pointer_array_init (&pmix_mca_base_var_groups, 128, 16384, 128);
if (PMIX_SUCCESS != ret) {
return ret;
}
PMIX_CONSTRUCT(&pmix_mca_base_var_group_index_hash, pmix_hash_table_t);
ret = pmix_hash_table_init (&pmix_mca_base_var_group_index_hash, 256);
if (PMIX_SUCCESS != ret) {
return ret;
}
pmix_mca_base_var_group_initialized = true;
pmix_mca_base_var_group_count = 0;
}
return PMIX_SUCCESS;
}
void pmix_globals_init(void)
{
memset(&pmix_globals.myid, 0, sizeof(pmix_proc_t));
PMIX_CONSTRUCT(&pmix_globals.nspaces, pmix_list_t);
PMIX_CONSTRUCT(&pmix_globals.errregs, pmix_pointer_array_t);
pmix_pointer_array_init(&pmix_globals.errregs, 16, PMIX_MAX_ERROR_REGISTRATIONS, 16);
}
PMIX_EXPORT pmix_status_t PMIx_Data_copy_payload(pmix_data_buffer_t *dest,
pmix_data_buffer_t *src)
{
pmix_status_t rc;
pmix_buffer_t buf1, buf2;
/* setup the hosts */
PMIX_CONSTRUCT(&buf1, pmix_buffer_t);
PMIX_CONSTRUCT(&buf2, pmix_buffer_t);
/* embed the data buffer into a buffer */
PMIX_EMBED_DATA_BUFFER(&buf1, dest);
PMIX_EMBED_DATA_BUFFER(&buf2, src);
/* copy payload */
PMIX_BFROPS_COPY_PAYLOAD(rc, pmix_globals.mypeer,
&buf1, &buf2);
/* extract the dest data buffer - the pointers may have changed */
PMIX_EXTRACT_DATA_BUFFER(&buf1, dest);
PMIX_EXTRACT_DATA_BUFFER(&buf2, src);
/* no need to cleanup as all storage was xfered */
return rc;
}
/* we need to pass three things to the client:
*
* (a) the list of nodes involved in this nspace
*
* (b) the hostname for each proc in this nspace
*
* (c) the list of procs on each node for reverse lookup
*/
void pmix_pack_proc_map(pmix_buffer_t *buf,
char **nodes, char **procs)
{
pmix_kval_t kv;
pmix_value_t val;
pmix_status_t rc;
pmix_buffer_t buf2;
size_t i, nnodes;
/* bozo check - need procs for each node */
if (pmix_argv_count(nodes) != pmix_argv_count(procs)) {
PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
return;
}
PMIX_CONSTRUCT(&buf2, pmix_buffer_t);
PMIX_CONSTRUCT(&kv, pmix_kval_t);
kv.value = &val;
val.type = PMIX_STRING;
/* pass the number of nodes involved in this namespace */
nnodes = pmix_argv_count(nodes);
if (PMIX_SUCCESS != (rc = pmix_bfrop.pack(&buf2, &nnodes, 1, PMIX_SIZE))) {
PMIX_ERROR_LOG(rc);
goto cleanup;
}
for (i=0; i < nnodes; i++) {
/* pass the complete list of procs on this node */
kv.key = nodes[i];
val.data.string = procs[i];
if (PMIX_SUCCESS != (rc = pmix_bfrop.pack(&buf2, &kv, 1, PMIX_KVAL))) {
PMIX_ERROR_LOG(rc);
kv.key = NULL;
val.data.string = NULL;
goto cleanup;
}
}
kv.key = NULL;
val.data.string = NULL;
/* pass the completed blob */
kv.key = PMIX_MAP_BLOB;
val.type = PMIX_BYTE_OBJECT;
val.data.bo.bytes = buf2.base_ptr;
val.data.bo.size = buf2.bytes_used;
if (PMIX_SUCCESS != (rc = pmix_bfrop.pack(buf, &kv, 1, PMIX_KVAL))) {
PMIX_ERROR_LOG(rc);
}
kv.key = NULL;
kv.value = NULL;
val.data.bo.bytes = NULL;
val.data.bo.size = 0;
cleanup:
PMIX_DESTRUCT(&buf2);
PMIX_DESTRUCT(&kv);
return;
}
static void nscon(pmix_nspace_t *p)
{
memset(p->nspace, 0, PMIX_MAX_NSLEN);
PMIX_CONSTRUCT(&p->nodes, pmix_list_t);
PMIX_CONSTRUCT(&p->internal, pmix_hash_table_t);
pmix_hash_table_init(&p->internal, 16);
PMIX_CONSTRUCT(&p->modex, pmix_hash_table_t);
pmix_hash_table_init(&p->modex, 256);
p->server = NULL;
}
static void pmix_mca_base_var_group_constructor (pmix_mca_base_var_group_t *group)
{
memset ((char *) group + sizeof (group->super), 0, sizeof (*group) - sizeof (group->super));
PMIX_CONSTRUCT(&group->group_subgroups, pmix_value_array_t);
pmix_value_array_init (&group->group_subgroups, sizeof (int));
PMIX_CONSTRUCT(&group->group_vars, pmix_value_array_t);
pmix_value_array_init (&group->group_vars, sizeof (int));
}
static void sncon(pmix_server_nspace_t *p)
{
p->nlocalprocs = 0;
p->all_registered = false;
PMIX_CONSTRUCT(&p->job_info, pmix_buffer_t);
PMIX_CONSTRUCT(&p->ranks, pmix_list_t);
PMIX_CONSTRUCT(&p->mylocal, pmix_hash_table_t);
pmix_hash_table_init(&p->mylocal, 16);
PMIX_CONSTRUCT(&p->myremote, pmix_hash_table_t);
pmix_hash_table_init(&p->myremote, 16);
PMIX_CONSTRUCT(&p->remote, pmix_hash_table_t);
pmix_hash_table_init(&p->remote, 256);
}
pmix_status_t pmix_bfrop_unpack_kval(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_kval_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d kvals", *num_vals);
ptr = (pmix_kval_t*) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_CONSTRUCT(&ptr[i], pmix_kval_t);
/* unpack the key */
m = 1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &ptr[i].key, &m, PMIX_STRING))) {
PMIX_ERROR_LOG(ret);
return ret;
}
/* allocate the space */
ptr[i].value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
/* unpack the value */
m = 1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_value(buffer, ptr[i].value, &m, PMIX_VALUE))) {
PMIX_ERROR_LOG(ret);
return ret;
}
}
return PMIX_SUCCESS;
}
PMIX_EXPORT pmix_status_t PMIx_Data_unpack(const pmix_proc_t *source,
pmix_data_buffer_t *buffer, void *dest,
int32_t *max_num_values,
pmix_data_type_t type)
{
pmix_status_t rc;
pmix_buffer_t buf;
pmix_peer_t *peer;
if (NULL == (peer = find_peer(source))) {
return PMIX_ERR_NOT_SUPPORTED;
}
/* setup the host */
PMIX_CONSTRUCT(&buf, pmix_buffer_t);
/* embed the data buffer into a buffer */
PMIX_EMBED_DATA_BUFFER(&buf, buffer);
/* unpack the value */
PMIX_BFROPS_UNPACK(rc, peer,
&buf, dest, max_num_values, type);
/* extract the data buffer - the pointers may have changed */
PMIX_EXTRACT_DATA_BUFFER(&buf, buffer);
/* no need to cleanup as all storage was xfered */
return rc;
}
pmix_status_t pmix_bfrops_base_unpack_kval(pmix_pointer_array_t *regtypes,
pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_kval_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
"pmix_bfrop_unpack: %d kvals", *num_vals);
ptr = (pmix_kval_t*) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_CONSTRUCT(&ptr[i], pmix_kval_t);
/* unpack the key */
m = 1;
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &ptr[i].key, &m, PMIX_STRING, regtypes);
if (PMIX_SUCCESS != ret) {
return ret;
}
/* allocate the space */
ptr[i].value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
/* unpack the value */
m = 1;
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, ptr[i].value, &m, PMIX_VALUE, regtypes);
if (PMIX_SUCCESS != ret) {
return ret;
}
}
return PMIX_SUCCESS;
}
static void rvcon(pmix_regex_value_t *p)
{
p->prefix = NULL;
p->suffix = NULL;
p->num_digits = 0;
PMIX_CONSTRUCT(&p->ranges, pmix_list_t);
}
pmix_status_t component_open(void)
{
/* setup the types array */
PMIX_CONSTRUCT(&mca_bfrops_v20_component.types, pmix_pointer_array_t);
pmix_pointer_array_init(&mca_bfrops_v20_component.types, 32, INT_MAX, 16);
return PMIX_SUCCESS;
}
static void tacon(tcp_available_ports_t *p)
{
PMIX_CONSTRUCT(&p->devices, pmix_list_t);
p->type = NULL;
p->plane = NULL;
p->ports = NULL;
p->nports = 0;
}
static pmix_status_t pmix_ptl_open(pmix_mca_base_open_flag_t flags)
{
pmix_status_t rc;
/* initialize globals */
pmix_ptl_globals.initialized = true;
PMIX_CONSTRUCT(&pmix_ptl_globals.actives, pmix_list_t);
PMIX_CONSTRUCT(&pmix_ptl_globals.posted_recvs, pmix_list_t);
PMIX_CONSTRUCT(&pmix_ptl_globals.unexpected_msgs, pmix_list_t);
pmix_ptl_globals.listen_thread_active = false;
PMIX_CONSTRUCT(&pmix_ptl_globals.listeners, pmix_list_t);
pmix_ptl_globals.current_tag = PMIX_PTL_TAG_DYNAMIC;
/* Open up all available components */
rc = pmix_mca_base_framework_components_open(&pmix_ptl_base_framework, flags);
pmix_ptl_base_output = pmix_ptl_base_framework.framework_output;
return rc;
}
static void pcon(pmix_peer_t *p)
{
p->info = NULL;
p->sd = -1;
p->send_ev_active = false;
p->recv_ev_active = false;
PMIX_CONSTRUCT(&p->send_queue, pmix_list_t);
p->send_msg = NULL;
p->recv_msg = NULL;
}
static void cbcon(pmix_cb_t *p)
{
PMIX_CONSTRUCT_LOCK(&p->lock);
p->checked = false;
PMIX_CONSTRUCT(&p->data, pmix_buffer_t);
p->cbfunc.ptlfn = NULL;
p->cbdata = NULL;
p->pname.nspace = NULL;
p->pname.rank = PMIX_RANK_UNDEF;
p->scope = PMIX_SCOPE_UNDEF;
p->key = NULL;
p->value = NULL;
p->procs = NULL;
p->nprocs = 0;
p->info = NULL;
p->ninfo = 0;
p->nvals = 0;
PMIX_CONSTRUCT(&p->kvs, pmix_list_t);
p->copy = false;
p->timer_running = false;
}
static void nscon(pmix_nspace_t *p)
{
p->nspace = NULL;
p->nlocalprocs = 0;
p->all_registered = false;
p->jobinfo = NULL;
p->njobinfo = 0;
p->jobbkt = NULL;
p->ndelivered = 0;
PMIX_CONSTRUCT(&p->ranks, pmix_list_t);
memset(&p->compat, 0, sizeof(p->compat));
}
static int pmix_pif_base_open (pmix_mca_base_open_flag_t flags)
{
if (frameopen) {
return PMIX_SUCCESS;
}
frameopen = true;
/* setup the global list */
PMIX_CONSTRUCT(&pmix_if_list, pmix_list_t);
return pmix_mca_base_framework_components_open(&pmix_pif_base_framework, flags);
}
static pmix_status_t pmix_bfrop_open(pmix_mca_base_open_flag_t flags)
{
pmix_status_t rc;
/* initialize globals */
pmix_bfrops_globals.initialized = true;
PMIX_CONSTRUCT(&pmix_bfrops_globals.actives, pmix_list_t);
/* Open up all available components */
rc = pmix_mca_base_framework_components_open(&pmix_bfrops_base_framework, flags);
pmix_bfrops_base_output = pmix_bfrops_base_framework.framework_output;
return rc;
}
static void cbcon(pmix_cb_t *p)
{
p->active = false;
PMIX_CONSTRUCT(&p->data, pmix_buffer_t);
p->cbfunc = NULL;
p->op_cbfunc = NULL;
p->value_cbfunc = NULL;
p->lookup_cbfunc = NULL;
p->spawn_cbfunc = NULL;
p->cbdata = NULL;
memset(p->nspace, 0, PMIX_MAX_NSLEN+1);
p->rank = -1;
p->key = NULL;
p->value = NULL;
}
static void pcon(pmix_peer_t *p)
{
p->proc_type = PMIX_PROC_UNDEF;
p->finalized = false;
p->info = NULL;
p->proc_cnt = 0;
p->index = 0;
p->sd = -1;
p->finalized = false;
p->send_ev_active = false;
p->recv_ev_active = false;
PMIX_CONSTRUCT(&p->send_queue, pmix_list_t);
p->send_msg = NULL;
p->recv_msg = NULL;
}
pmix_status_t pmix_bfrops_base_unpack_buf(pmix_pointer_array_t *regtypes,
pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_buffer_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
size_t nbytes;
ptr = (pmix_buffer_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_CONSTRUCT(&ptr[i], pmix_buffer_t);
/* unpack the type of buffer */
m=1;
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &ptr[i].type, &m, PMIX_BYTE, regtypes);
if (PMIX_SUCCESS != ret) {
return ret;
}
/* unpack the number of bytes */
m=1;
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &nbytes, &m, PMIX_SIZE, regtypes);
if (PMIX_SUCCESS != ret) {
return ret;
}
m = nbytes;
/* setup the buffer's data region */
if (0 < nbytes) {
ptr[i].base_ptr = (char*)malloc(nbytes);
if (NULL == ptr[i].base_ptr) {
return PMIX_ERR_NOMEM;
}
/* unpack the bytes */
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, ptr[i].base_ptr, &m, PMIX_BYTE, regtypes);
if (PMIX_SUCCESS != ret) {
return ret;
}
}
ptr[i].pack_ptr = ptr[i].base_ptr + m;
ptr[i].unpack_ptr = ptr[i].base_ptr;
ptr[i].bytes_allocated = nbytes;
ptr[i].bytes_used = m;
}
return PMIX_SUCCESS;
}
void cli_init(int nprocs, int order[])
{
int n, i;
cli_info = malloc( sizeof(cli_info_t) * nprocs);
cli_info_cnt = nprocs;
for (n=0; n < nprocs; n++) {
cli_info[n].sd = -1;
cli_info[n].ev = NULL;
cli_info[n].pid = -1;
cli_info[n].state = CLI_UNINIT;
PMIX_CONSTRUCT(&(cli_info[n].modex), pmix_list_t);
for (i = 0; i < CLI_TERM+1; i++) {
cli_info[n].next_state[i] = order[i];
}
cli_info[n].rank = -1;
cli_info[n].ns = NULL;
}
}
void pmix_usock_init(pmix_usock_cbfunc_t cbfunc)
{
pmix_usock_posted_recv_t *req;
/* setup the usock globals */
PMIX_CONSTRUCT(&pmix_usock_globals.posted_recvs, pmix_list_t);
/* if a cbfunc was given, post a persistent recv
* for the special 0 tag so the client can recv
* error notifications from the server */
if (NULL != cbfunc) {
req = PMIX_NEW(pmix_usock_posted_recv_t);
req->tag = 0;
req->cbfunc = cbfunc;
pmix_output_verbose(5, pmix_globals.debug_output,
"posting notification recv on tag %d", req->tag);
/* add it to the list of recvs - we cannot have unexpected messages
* in this subsystem as the server never sends us something that
* we didn't previously request */
pmix_list_prepend(&pmix_usock_globals.posted_recvs, &req->super);
}
}
PMIX_EXPORT pmix_status_t PMIx_Log(const pmix_info_t data[], size_t ndata,
const pmix_info_t directives[], size_t ndirs)
{
pmix_cb_t cb;
pmix_status_t rc;
PMIX_ACQUIRE_THREAD(&pmix_global_lock);
if (pmix_globals.init_cntr <= 0) {
PMIX_RELEASE_THREAD(&pmix_global_lock);
return PMIX_ERR_INIT;
}
PMIX_RELEASE_THREAD(&pmix_global_lock);
pmix_output_verbose(2, pmix_plog_base_framework.framework_output,
"%s pmix:log", PMIX_NAME_PRINT(&pmix_globals.myid));
/* create a callback object as we need to pass it to the
* recv routine so we know which callback to use when
* the return message is recvd */
PMIX_CONSTRUCT(&cb, pmix_cb_t);
if (PMIX_SUCCESS != (rc = PMIx_Log_nb(data, ndata, directives,
ndirs, opcbfunc, &cb))) {
PMIX_DESTRUCT(&cb);
return rc;
}
/* wait for the operation to complete */
PMIX_WAIT_THREAD(&cb.lock);
rc = cb.status;
PMIX_DESTRUCT(&cb);
pmix_output_verbose(2, pmix_plog_base_framework.framework_output,
"pmix:log completed");
return rc;
}
PMIX_EXPORT pmix_status_t PMIx_Allocation_request(pmix_alloc_directive_t directive,
pmix_info_t *info, size_t ninfo)
{
pmix_cb_t cb;
pmix_status_t rc;
PMIX_ACQUIRE_THREAD(&pmix_global_lock);
if (pmix_globals.init_cntr <= 0) {
PMIX_RELEASE_THREAD(&pmix_global_lock);
return PMIX_ERR_INIT;
}
PMIX_RELEASE_THREAD(&pmix_global_lock);
pmix_output_verbose(2, pmix_globals.debug_output,
"%s pmix:allocate", PMIX_NAME_PRINT(&pmix_globals.myid));
/* create a callback object as we need to pass it to the
* recv routine so we know which callback to use when
* the return message is recvd */
PMIX_CONSTRUCT(&cb, pmix_cb_t);
if (PMIX_SUCCESS != (rc = PMIx_Allocation_request_nb(directive, info, ninfo,
acb, &cb))) {
PMIX_DESTRUCT(&cb);
return rc;
}
/* wait for the operation to complete */
PMIX_WAIT_THREAD(&cb.lock);
rc = cb.status;
PMIX_DESTRUCT(&cb);
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix:allocate completed");
return rc;
}
static pmix_status_t allocate(pmix_nspace_t *nptr,
pmix_info_t *info,
pmix_list_t *ilist)
{
uint64_t unique_key[2];
size_t n, nreqs=0;
int ports_per_node=0;
pmix_kval_t *kv;
pmix_status_t rc;
pmix_info_t *requests = NULL;
char **reqs, *cptr;
bool allocated = false, seckey = false;
tcp_port_tracker_t *trk;
tcp_available_ports_t *avail, *aptr;
pmix_list_t mylist;
pmix_buffer_t buf;
char *type = NULL, *plane = NULL, *idkey = NULL;
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"pnet:tcp:allocate for nspace %s", nptr->nspace);
/* if I am not the gateway, then ignore this call - should never
* happen, but check to be safe */
if (!PMIX_PROC_IS_GATEWAY(pmix_globals.mypeer)) {
return PMIX_SUCCESS;
}
if (NULL == info) {
return PMIX_ERR_TAKE_NEXT_OPTION;
}
/* check directives to see if a crypto key and/or
* network resource allocations requested */
PMIX_CONSTRUCT(&mylist, pmix_list_t);
if (0 == strncmp(info->key, PMIX_SETUP_APP_ENVARS, PMIX_MAX_KEYLEN) ||
0 == strncmp(info->key, PMIX_SETUP_APP_ALL, PMIX_MAX_KEYLEN)) {
if (NULL != mca_pnet_tcp_component.include) {
rc = pmix_pnet_base_harvest_envars(mca_pnet_tcp_component.include,
mca_pnet_tcp_component.exclude,
ilist);
return rc;
}
return PMIX_SUCCESS;
} else if (0 != strncmp(info->key, PMIX_ALLOC_NETWORK, PMIX_MAX_KEYLEN)) {
/* not a network allocation request */
return PMIX_SUCCESS;
}
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"pnet:tcp:allocate alloc_network for nspace %s",
nptr->nspace);
/* this info key includes an array of pmix_info_t, each providing
* a key (that is to be used as the key for the allocated ports) and
* a number of ports to allocate for that key */
if (PMIX_DATA_ARRAY != info->value.type ||
NULL == info->value.data.darray ||
PMIX_INFO != info->value.data.darray->type ||
NULL == info->value.data.darray->array) {
/* they made an error */
PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
return PMIX_ERR_BAD_PARAM;
}
requests = (pmix_info_t*)info->value.data.darray->array;
nreqs = info->value.data.darray->size;
/* cycle thru the provided array and see if this refers to
* tcp/udp-based resources - there is no required ordering
* of the keys, so just have to do a search */
for (n=0; n < nreqs; n++) {
if (0 == strncasecmp(requests[n].key, PMIX_ALLOC_NETWORK_TYPE, PMIX_MAX_KEYLEN)) {
/* check for bozo error */
if (PMIX_STRING != requests[n].value.type ||
NULL == requests[n].value.data.string) {
PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
return PMIX_ERR_BAD_PARAM;
}
type = requests[n].value.data.string;
} else if (0 == strncasecmp(requests[n].key, PMIX_ALLOC_NETWORK_PLANE, PMIX_MAX_KEYLEN)) {
/* check for bozo error */
if (PMIX_STRING != requests[n].value.type ||
NULL == requests[n].value.data.string) {
PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
return PMIX_ERR_BAD_PARAM;
}
plane = requests[n].value.data.string;
} else if (0 == strncasecmp(requests[n].key, PMIX_ALLOC_NETWORK_ENDPTS, PMIX_MAX_KEYLEN)) {
PMIX_VALUE_GET_NUMBER(rc, &requests[n].value, ports_per_node, int);
if (PMIX_SUCCESS != rc) {
return rc;
}
} else if (0 == strncmp(requests[n].key, PMIX_ALLOC_NETWORK_ID, PMIX_MAX_KEYLEN)) {
static pmix_status_t tcp_init(void)
{
tcp_available_ports_t *trk;
char *p, **grps;
size_t n;
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"pnet: tcp init");
/* if we are not the "gateway", then there is nothing
* for us to do */
if (!PMIX_PROC_IS_GATEWAY(pmix_globals.mypeer)) {
return PMIX_SUCCESS;
}
PMIX_CONSTRUCT(&allocations, pmix_list_t);
PMIX_CONSTRUCT(&available, pmix_list_t);
/* if we have no static ports, then we don't have
* anything to manage. However, we cannot just disqualify
* ourselves as we may still need to provide inventory.
*
* NOTE: need to check inventory in addition to MCA param as
* the inventory may have reported back static ports */
if (NULL == mca_pnet_tcp_component.static_ports) {
return PMIX_SUCCESS;
}
/* split on semi-colons */
grps = pmix_argv_split(mca_pnet_tcp_component.static_ports, ';');
for (n=0; NULL != grps[n]; n++) {
trk = PMIX_NEW(tcp_available_ports_t);
if (NULL == trk) {
pmix_argv_free(grps);
return PMIX_ERR_NOMEM;
}
/* there must be at least one colon */
if (NULL == (p = strrchr(grps[n], ':'))) {
pmix_argv_free(grps);
return PMIX_ERR_BAD_PARAM;
}
/* extract the ports */
*p = '\0';
++p;
pmix_util_parse_range_options(p, &trk->ports);
trk->nports = pmix_argv_count(trk->ports);
/* see if they provided a plane */
if (NULL != (p = strchr(grps[n], ':'))) {
/* yep - save the plane */
*p = '\0';
++p;
trk->plane = strdup(p);
}
/* the type is just what is left at the front */
trk->type = strdup(grps[n]);
pmix_output_verbose(2, pmix_pnet_base_framework.framework_output,
"TYPE: %s PLANE %s", trk->type,
(NULL == trk->plane) ? "NULL" : trk->plane);
pmix_list_append(&available, &trk->super);
}
pmix_argv_free(grps);
return PMIX_SUCCESS;
}
/* Xfer FUNCTIONS FOR GENERIC PMIX TYPES */
pmix_status_t pmix_bfrops_base_value_xfer(pmix_value_t *p,
pmix_value_t *src)
{
size_t n, m;
pmix_status_t rc;
char **prarray, **strarray;
pmix_value_t *pv, *sv;
pmix_info_t *p1, *s1;
pmix_app_t *pa, *sa;
pmix_pdata_t *pd, *sd;
pmix_buffer_t *pb, *sb;
pmix_byte_object_t *pbo, *sbo;
pmix_kval_t *pk, *sk;
pmix_modex_data_t *pm, *sm;
pmix_proc_info_t *pi, *si;
pmix_query_t *pq, *sq;
pmix_envar_t *pe, *se;
/* copy the right field */
p->type = src->type;
switch (src->type) {
case PMIX_UNDEF:
break;
case PMIX_BOOL:
p->data.flag = src->data.flag;
break;
case PMIX_BYTE:
p->data.byte = src->data.byte;
break;
case PMIX_STRING:
if (NULL != src->data.string) {
p->data.string = strdup(src->data.string);
} else {
p->data.string = NULL;
}
break;
case PMIX_SIZE:
p->data.size = src->data.size;
break;
case PMIX_PID:
p->data.pid = src->data.pid;
break;
case PMIX_INT:
/* to avoid alignment issues */
memcpy(&p->data.integer, &src->data.integer, sizeof(int));
break;
case PMIX_INT8:
p->data.int8 = src->data.int8;
break;
case PMIX_INT16:
/* to avoid alignment issues */
memcpy(&p->data.int16, &src->data.int16, 2);
break;
case PMIX_INT32:
/* to avoid alignment issues */
memcpy(&p->data.int32, &src->data.int32, 4);
break;
case PMIX_INT64:
/* to avoid alignment issues */
memcpy(&p->data.int64, &src->data.int64, 8);
break;
case PMIX_UINT:
/* to avoid alignment issues */
memcpy(&p->data.uint, &src->data.uint, sizeof(unsigned int));
break;
case PMIX_UINT8:
p->data.uint8 = src->data.uint8;
break;
case PMIX_UINT16:
/* to avoid alignment issues */
memcpy(&p->data.uint16, &src->data.uint16, 2);
break;
case PMIX_UINT32:
/* to avoid alignment issues */
memcpy(&p->data.uint32, &src->data.uint32, 4);
break;
case PMIX_UINT64:
/* to avoid alignment issues */
memcpy(&p->data.uint64, &src->data.uint64, 8);
break;
case PMIX_FLOAT:
p->data.fval = src->data.fval;
break;
case PMIX_DOUBLE:
p->data.dval = src->data.dval;
break;
case PMIX_TIMEVAL:
memcpy(&p->data.tv, &src->data.tv, sizeof(struct timeval));
break;
case PMIX_TIME:
memcpy(&p->data.time, &src->data.time, sizeof(time_t));
break;
case PMIX_STATUS:
memcpy(&p->data.status, &src->data.status, sizeof(pmix_status_t));
break;
case PMIX_PROC:
PMIX_PROC_CREATE(p->data.proc, 1);
if (NULL == p->data.proc) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.proc, src->data.proc, sizeof(pmix_proc_t));
break;
case PMIX_PROC_RANK:
memcpy(&p->data.rank, &src->data.rank, sizeof(pmix_rank_t));
break;
case PMIX_BYTE_OBJECT:
case PMIX_COMPRESSED_STRING:
memset(&p->data.bo, 0, sizeof(pmix_byte_object_t));
if (NULL != src->data.bo.bytes && 0 < src->data.bo.size) {
p->data.bo.bytes = malloc(src->data.bo.size);
memcpy(p->data.bo.bytes, src->data.bo.bytes, src->data.bo.size);
p->data.bo.size = src->data.bo.size;
} else {
p->data.bo.bytes = NULL;
p->data.bo.size = 0;
}
break;
case PMIX_PERSIST:
memcpy(&p->data.persist, &src->data.persist, sizeof(pmix_persistence_t));
break;
case PMIX_SCOPE:
memcpy(&p->data.scope, &src->data.scope, sizeof(pmix_scope_t));
break;
case PMIX_DATA_RANGE:
memcpy(&p->data.range, &src->data.range, sizeof(pmix_data_range_t));
break;
case PMIX_PROC_STATE:
memcpy(&p->data.state, &src->data.state, sizeof(pmix_proc_state_t));
break;
case PMIX_PROC_INFO:
PMIX_PROC_INFO_CREATE(p->data.pinfo, 1);
if (NULL != src->data.pinfo->hostname) {
p->data.pinfo->hostname = strdup(src->data.pinfo->hostname);
}
if (NULL != src->data.pinfo->executable_name) {
p->data.pinfo->executable_name = strdup(src->data.pinfo->executable_name);
}
memcpy(&p->data.pinfo->pid, &src->data.pinfo->pid, sizeof(pid_t));
memcpy(&p->data.pinfo->exit_code, &src->data.pinfo->exit_code, sizeof(int));
memcpy(&p->data.pinfo->state, &src->data.pinfo->state, sizeof(pmix_proc_state_t));
break;
case PMIX_DATA_ARRAY:
p->data.darray = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t));
p->data.darray->type = src->data.darray->type;
p->data.darray->size = src->data.darray->size;
if (0 == p->data.darray->size || NULL == src->data.darray->array) {
p->data.darray->array = NULL;
p->data.darray->size = 0;
break;
}
/* allocate space and do the copy */
switch (src->data.darray->type) {
case PMIX_UINT8:
case PMIX_INT8:
case PMIX_BYTE:
p->data.darray->array = (char*)malloc(src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size);
break;
case PMIX_UINT16:
case PMIX_INT16:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint16_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint16_t));
break;
case PMIX_UINT32:
case PMIX_INT32:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint32_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint32_t));
break;
case PMIX_UINT64:
case PMIX_INT64:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint64_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint64_t));
break;
case PMIX_BOOL:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(bool));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(bool));
break;
case PMIX_SIZE:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(size_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(size_t));
break;
case PMIX_PID:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(pid_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pid_t));
break;
case PMIX_STRING:
p->data.darray->array = (char**)malloc(src->data.darray->size * sizeof(char*));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
prarray = (char**)p->data.darray->array;
strarray = (char**)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != strarray[n]) {
prarray[n] = strdup(strarray[n]);
}
}
break;
case PMIX_INT:
case PMIX_UINT:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(int));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(int));
break;
case PMIX_FLOAT:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(float));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(float));
break;
case PMIX_DOUBLE:
p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(double));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(double));
break;
case PMIX_TIMEVAL:
p->data.darray->array = (struct timeval*)malloc(src->data.darray->size * sizeof(struct timeval));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(struct timeval));
break;
case PMIX_TIME:
p->data.darray->array = (time_t*)malloc(src->data.darray->size * sizeof(time_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(time_t));
break;
case PMIX_STATUS:
p->data.darray->array = (pmix_status_t*)malloc(src->data.darray->size * sizeof(pmix_status_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_status_t));
break;
case PMIX_VALUE:
PMIX_VALUE_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pv = (pmix_value_t*)p->data.darray->array;
sv = (pmix_value_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (PMIX_SUCCESS != (rc = pmix_value_xfer(&pv[n], &sv[n]))) {
PMIX_VALUE_FREE(pv, src->data.darray->size);
return rc;
}
}
break;
case PMIX_PROC:
PMIX_PROC_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_proc_t));
break;
case PMIX_APP:
PMIX_APP_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pa = (pmix_app_t*)p->data.darray->array;
sa = (pmix_app_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != sa[n].cmd) {
pa[n].cmd = strdup(sa[n].cmd);
}
if (NULL != sa[n].argv) {
pa[n].argv = pmix_argv_copy(sa[n].argv);
}
if (NULL != sa[n].env) {
pa[n].env = pmix_argv_copy(sa[n].env);
}
if (NULL != sa[n].cwd) {
pa[n].cwd = strdup(sa[n].cwd);
}
pa[n].maxprocs = sa[n].maxprocs;
if (0 < sa[n].ninfo && NULL != sa[n].info) {
PMIX_INFO_CREATE(pa[n].info, sa[n].ninfo);
if (NULL == pa[n].info) {
PMIX_APP_FREE(pa, src->data.darray->size);
return PMIX_ERR_NOMEM;
}
pa[n].ninfo = sa[n].ninfo;
for (m=0; m < pa[n].ninfo; m++) {
PMIX_INFO_XFER(&pa[n].info[m], &sa[n].info[m]);
}
}
}
break;
case PMIX_INFO:
PMIX_INFO_CREATE(p->data.darray->array, src->data.darray->size);
p1 = (pmix_info_t*)p->data.darray->array;
s1 = (pmix_info_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
PMIX_INFO_XFER(&p1[n], &s1[n]);
}
break;
case PMIX_PDATA:
PMIX_PDATA_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pd = (pmix_pdata_t*)p->data.darray->array;
sd = (pmix_pdata_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
PMIX_PDATA_XFER(&pd[n], &sd[n]);
}
break;
case PMIX_BUFFER:
p->data.darray->array = (pmix_buffer_t*)malloc(src->data.darray->size * sizeof(pmix_buffer_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pb = (pmix_buffer_t*)p->data.darray->array;
sb = (pmix_buffer_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
PMIX_CONSTRUCT(&pb[n], pmix_buffer_t);
pmix_bfrops_base_copy_payload(&pb[n], &sb[n]);
}
break;
case PMIX_BYTE_OBJECT:
case PMIX_COMPRESSED_STRING:
p->data.darray->array = (pmix_byte_object_t*)malloc(src->data.darray->size * sizeof(pmix_byte_object_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pbo = (pmix_byte_object_t*)p->data.darray->array;
sbo = (pmix_byte_object_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != sbo[n].bytes && 0 < sbo[n].size) {
pbo[n].size = sbo[n].size;
pbo[n].bytes = (char*)malloc(pbo[n].size);
memcpy(pbo[n].bytes, sbo[n].bytes, pbo[n].size);
} else {
pbo[n].bytes = NULL;
pbo[n].size = 0;
}
}
break;
case PMIX_KVAL:
p->data.darray->array = (pmix_kval_t*)calloc(src->data.darray->size , sizeof(pmix_kval_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pk = (pmix_kval_t*)p->data.darray->array;
sk = (pmix_kval_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != sk[n].key) {
pk[n].key = strdup(sk[n].key);
}
if (NULL != sk[n].value) {
PMIX_VALUE_CREATE(pk[n].value, 1);
if (NULL == pk[n].value) {
free(p->data.darray->array);
return PMIX_ERR_NOMEM;
}
if (PMIX_SUCCESS != (rc = pmix_value_xfer(pk[n].value, sk[n].value))) {
return rc;
}
}
}
break;
case PMIX_MODEX:
PMIX_MODEX_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pm = (pmix_modex_data_t*)p->data.darray->array;
sm = (pmix_modex_data_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
memcpy(&pm[n], &sm[n], sizeof(pmix_modex_data_t));
if (NULL != sm[n].blob && 0 < sm[n].size) {
pm[n].blob = (uint8_t*)malloc(sm[n].size);
if (NULL == pm[n].blob) {
return PMIX_ERR_NOMEM;
}
memcpy(pm[n].blob, sm[n].blob, sm[n].size);
pm[n].size = sm[n].size;
} else {
pm[n].blob = NULL;
pm[n].size = 0;
}
}
break;
case PMIX_PERSIST:
p->data.darray->array = (pmix_persistence_t*)malloc(src->data.darray->size * sizeof(pmix_persistence_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_persistence_t));
break;
case PMIX_POINTER:
p->data.darray->array = (char**)malloc(src->data.darray->size * sizeof(char*));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
prarray = (char**)p->data.darray->array;
strarray = (char**)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
prarray[n] = strarray[n];
}
break;
case PMIX_SCOPE:
p->data.darray->array = (pmix_scope_t*)malloc(src->data.darray->size * sizeof(pmix_scope_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_scope_t));
break;
case PMIX_DATA_RANGE:
p->data.darray->array = (pmix_data_range_t*)malloc(src->data.darray->size * sizeof(pmix_data_range_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_data_range_t));
break;
case PMIX_COMMAND:
p->data.darray->array = (pmix_cmd_t*)malloc(src->data.darray->size * sizeof(pmix_cmd_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_cmd_t));
break;
case PMIX_INFO_DIRECTIVES:
p->data.darray->array = (pmix_info_directives_t*)malloc(src->data.darray->size * sizeof(pmix_info_directives_t));
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_info_directives_t));
break;
case PMIX_PROC_INFO:
PMIX_PROC_INFO_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pi = (pmix_proc_info_t*)p->data.darray->array;
si = (pmix_proc_info_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
memcpy(&pi[n].proc, &si[n].proc, sizeof(pmix_proc_t));
if (NULL != si[n].hostname) {
pi[n].hostname = strdup(si[n].hostname);
} else {
pi[n].hostname = NULL;
}
if (NULL != si[n].executable_name) {
pi[n].executable_name = strdup(si[n].executable_name);
} else {
pi[n].executable_name = NULL;
}
pi[n].pid = si[n].pid;
pi[n].exit_code = si[n].exit_code;
pi[n].state = si[n].state;
}
break;
case PMIX_DATA_ARRAY:
PMIX_ERROR_LOG(PMIX_ERR_NOT_SUPPORTED);
return PMIX_ERR_NOT_SUPPORTED; // don't support iterative arrays
case PMIX_QUERY:
PMIX_QUERY_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pq = (pmix_query_t*)p->data.darray->array;
sq = (pmix_query_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != sq[n].keys) {
pq[n].keys = pmix_argv_copy(sq[n].keys);
}
if (NULL != sq[n].qualifiers && 0 < sq[n].nqual) {
PMIX_INFO_CREATE(pq[n].qualifiers, sq[n].nqual);
if (NULL == pq[n].qualifiers) {
PMIX_QUERY_FREE(pq, src->data.darray->size);
return PMIX_ERR_NOMEM;
}
for (m=0; m < sq[n].nqual; m++) {
PMIX_INFO_XFER(&pq[n].qualifiers[m], &sq[n].qualifiers[m]);
}
pq[n].nqual = sq[n].nqual;
} else {
pq[n].qualifiers = NULL;
pq[n].nqual = 0;
}
}
break;
case PMIX_ENVAR:
PMIX_ENVAR_CREATE(p->data.darray->array, src->data.darray->size);
if (NULL == p->data.darray->array) {
return PMIX_ERR_NOMEM;
}
pe = (pmix_envar_t*)p->data.darray->array;
se = (pmix_envar_t*)src->data.darray->array;
for (n=0; n < src->data.darray->size; n++) {
if (NULL != se[n].envar) {
pe[n].envar = strdup(se[n].envar);
}
if (NULL != se[n].value) {
pe[n].value = strdup(se[n].value);
}
pe[n].separator = se[n].separator;
}
break;
default:
return PMIX_ERR_UNKNOWN_DATA_TYPE;
}
break;
case PMIX_POINTER:
memcpy(&p->data.ptr, &src->data.ptr, sizeof(void*));
break;
case PMIX_ENVAR:
PMIX_ENVAR_CONSTRUCT(&p->data.envar);
if (NULL != src->data.envar.envar) {
p->data.envar.envar = strdup(src->data.envar.envar);
}
if (NULL != src->data.envar.value) {
p->data.envar.value = strdup(src->data.envar.value);
}
p->data.envar.separator = src->data.envar.separator;
break;
/**** DEPRECATED ****/
case PMIX_INFO_ARRAY:
p->data.array->size = src->data.array->size;
if (0 < src->data.array->size) {
p->data.array->array = (pmix_info_t*)malloc(src->data.array->size * sizeof(pmix_info_t));
if (NULL == p->data.array->array) {
return PMIX_ERR_NOMEM;
}
p1 = (pmix_info_t*)p->data.array->array;
s1 = (pmix_info_t*)src->data.array->array;
for (n=0; n < src->data.darray->size; n++) {
PMIX_INFO_XFER(&p1[n], &s1[n]);
}
}
break;
/********************/
default:
pmix_output(0, "XFER-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)src->type);
assert(0);
return PMIX_ERROR;
}
return PMIX_SUCCESS;
}
/*
* 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;
}
