PMIX_EXPORT void PMIx_Register_errhandler(pmix_info_t info[], size_t ninfo,
pmix_notification_fn_t errhandler,
pmix_errhandler_reg_cbfunc_t cbfunc,
void *cbdata)
{
if (pmix_globals.init_cntr <= 0) {
return;
}
/* common err handler registration */
if (pmix_globals.server) {
/* PMIX server: store the error handler, process info keys and call
* cbfunc with reference to the errhandler */
pmix_output_verbose(2, pmix_globals.debug_output,
"registering server err handler");
pmix_server_register_errhandler(info, ninfo,
errhandler,
cbfunc,cbdata);
} else {
/* PMIX client: store the error handler, process info keys &
* call pmix_server_register_for_events, and call cbfunc with
* reference to the errhandler */
pmix_output_verbose(2, pmix_globals.debug_output,
"registering client err handler");
pmix_client_register_errhandler(info, ninfo,
errhandler,
cbfunc, cbdata);
}
}
PMIX_EXPORT pmix_status_t PMIx_Notify_error(pmix_status_t status,
pmix_proc_t procs[], size_t nprocs,
pmix_proc_t error_procs[], size_t error_nprocs,
pmix_info_t info[], size_t ninfo,
pmix_op_cbfunc_t cbfunc, void *cbdata)
{
int rc;
if (pmix_globals.init_cntr <= 0) {
return PMIX_ERR_INIT;
}
if (pmix_globals.server) {
rc = pmix_server_notify_error(status, procs, nprocs, error_procs,
error_nprocs, info, ninfo,
cbfunc, cbdata);
pmix_output_verbose(0, pmix_globals.debug_output,
"pmix_server_notify_error error =%d, rc=%d", status, rc);
} else {
rc = pmix_client_notify_error(status, procs, nprocs, error_procs,
error_nprocs, info, ninfo,
cbfunc, cbdata);
pmix_output_verbose(0, pmix_globals.debug_output,
"pmix_client_notify_error error =%d, rc=%d", status, rc);
}
return rc;
}
int _mmap_segment_attach(pmix_sm_seg_t *sm_seg)
{
if (-1 == (sm_seg->seg_id = open(sm_seg->seg_name, O_RDWR))) {
return PMIX_ERROR;
}
if (MAP_FAILED == (sm_seg->seg_base_addr = (unsigned char *)
mmap(NULL, sm_seg->seg_size,
PROT_READ | PROT_WRITE, MAP_SHARED,
sm_seg->seg_id, 0))) {
/* mmap failed, so close the file and return NULL - no error check
* here because we are already in an error path...
*/
pmix_output_verbose(2, pmix_globals.debug_output,
"sys call mmap(2) fail\n");
close(sm_seg->seg_id);
return PMIX_ERROR;
}
/* all is well */
/* if close fails here, that's okay. just let the user know and
* continue. if we got this far, open and mmap were successful...
*/
if (0 != close(sm_seg->seg_id)) {
pmix_output_verbose(2, pmix_globals.debug_output,
"sys call close(2) fail\n");
}
sm_seg->seg_cpid = 0;/* FIXME */
return PMIX_SUCCESS;
}
/*
* A blocking send on a non-blocking socket. Used to send the small amount of connection
* information that identifies the peers endpoint.
*/
pmix_status_t pmix_usock_send_blocking(int sd, char *ptr, size_t size)
{
size_t cnt = 0;
int retval;
pmix_output_verbose(8, pmix_globals.debug_output,
"send blocking of %"PRIsize_t" bytes to socket %d",
size, sd );
while (cnt < size) {
retval = send(sd, (char*)ptr+cnt, size-cnt, 0);
if (retval < 0) {
if (EAGAIN == pmix_socket_errno ||
EWOULDBLOCK == pmix_socket_errno) {
/* just cycle and let it try again */
pmix_output_verbose(8, pmix_globals.debug_output,
"blocking_send received error %d:%s from remote - cycling",
pmix_socket_errno, strerror(pmix_socket_errno));
continue;
}
if (pmix_socket_errno != EINTR) {
pmix_output(8, "usock_peer_send_blocking: send() to socket %d failed: %s (%d)\n",
sd, strerror(pmix_socket_errno),
pmix_socket_errno);
return PMIX_ERR_UNREACH;
}
continue;
}
cnt += retval;
}
pmix_output_verbose(8, pmix_globals.debug_output,
"blocking send complete to socket %d", sd);
return PMIX_SUCCESS;
}
/**** DEPRECATED ****/
pmix_status_t pmix_bfrop_unpack_array(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_info_array_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d info arrays", *num_vals);
ptr = (pmix_info_array_t*) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: init array[%d]", i);
memset(&ptr[i], 0, sizeof(pmix_info_array_t));
/* unpack the size of this array */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_sizet(buffer, &ptr[i].size, &m, PMIX_SIZE))) {
return ret;
}
if (0 < ptr[i].size) {
ptr[i].array = (pmix_info_t*)malloc(ptr[i].size * sizeof(pmix_info_t));
m=ptr[i].size;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_value(buffer, ptr[i].array, &m, PMIX_INFO))) {
return ret;
}
}
}
return PMIX_SUCCESS;
}
PMIX_EXPORT void PMIx_Deregister_errhandler(int errhandler_ref,
pmix_op_cbfunc_t cbfunc,
void *cbdata)
{
if (pmix_globals.init_cntr <= 0) {
return;
}
if (errhandler_ref < 0) {
return;
}
/* common err handler registration */
if (pmix_globals.server) {
/* PMIX server: store the error handler, process info keys and call
* cbfunc with reference to the errhandler */
pmix_server_deregister_errhandler(errhandler_ref,cbfunc,cbdata);
pmix_output_verbose(2, pmix_globals.debug_output,
"deregistering server err handler");
} else {
/* PMIX client: store the error handler, process info keys &
* call pmix_server_register_for_events, and call cbfunc with
* reference to the errhandler */
pmix_client_deregister_errhandler(errhandler_ref, cbfunc, cbdata);
pmix_output_verbose(2, pmix_globals.debug_output,
"deregistering client err handler");
}
}
int PMIx_Disconnect_nb(const pmix_proc_t procs[], size_t nprocs,
pmix_op_cbfunc_t cbfunc, void *cbdata)
{
pmix_buffer_t *msg;
pmix_cmd_t cmd = PMIX_DISCONNECTNB_CMD;
int rc;
pmix_cb_t *cb;
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix: disconnect called");
if (pmix_client_globals.init_cntr <= 0) {
return PMIX_ERR_INIT;
}
/* if we aren't connected, don't attempt to send */
if (!pmix_globals.connected) {
return PMIX_ERR_UNREACH;
}
/* check for bozo input */
if (NULL == procs || 0 >= nprocs) {
return PMIX_ERR_BAD_PARAM;
}
msg = PMIX_NEW(pmix_buffer_t);
/* pack the cmd */
if (PMIX_SUCCESS != (rc = pmix_bfrop.pack(msg, &cmd, 1, PMIX_CMD))) {
PMIX_ERROR_LOG(rc);
return rc;
}
/* pack the number of procs */
if (PMIX_SUCCESS != (rc = pmix_bfrop.pack(msg, &nprocs, 1, PMIX_SIZE))) {
PMIX_ERROR_LOG(rc);
return rc;
}
if (PMIX_SUCCESS != (rc = pmix_bfrop.pack(msg, procs, nprocs, PMIX_PROC))) {
PMIX_ERROR_LOG(rc);
return rc;
}
/* 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 */
cb = PMIX_NEW(pmix_cb_t);
cb->op_cbfunc = cbfunc;
cb->cbdata = cbdata;
/* push the message into our event base to send to the server */
PMIX_ACTIVATE_SEND_RECV(&pmix_client_globals.myserver, msg, wait_cbfunc, cb);
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix: disconnect completed");
return PMIX_SUCCESS;
}
/*
* A blocking recv on a non-blocking socket. Used to receive the small amount of connection
* information that identifies the peers endpoint.
*/
pmix_status_t pmix_usock_recv_blocking(int sd, char *data, size_t size)
{
size_t cnt = 0;
pmix_output_verbose(8, pmix_globals.debug_output,
"waiting for blocking recv of %"PRIsize_t" bytes", size);
while (cnt < size) {
int retval = recv(sd, (char *)data+cnt, size-cnt, MSG_WAITALL);
/* remote closed connection */
if (retval == 0) {
pmix_output_verbose(8, pmix_globals.debug_output,
"usock_recv_blocking: remote closed connection");
return PMIX_ERR_UNREACH;
}
/* handle errors */
if (retval < 0) {
if (EAGAIN == pmix_socket_errno ||
EWOULDBLOCK == pmix_socket_errno) {
/* just cycle and let it try again */
pmix_output_verbose(8, pmix_globals.debug_output,
"blocking_recv received error %d:%s from remote - cycling",
pmix_socket_errno, strerror(pmix_socket_errno));
continue;
}
if (pmix_socket_errno != EINTR ) {
/* If we overflow the listen backlog, it's
possible that even though we finished the three
way handshake, the remote host was unable to
transition the connection from half connected
(received the initial SYN) to fully connected
(in the listen backlog). We likely won't see
the failure until we try to receive, due to
timing and the like. The first thing we'll get
in that case is a RST packet, which receive
will turn into a connection reset by peer
errno. In that case, leave the socket in
CONNECT_ACK and propogate the error up to
recv_connect_ack, who will try to establish the
connection again */
pmix_output_verbose(8, pmix_globals.debug_output,
"blocking_recv received error %d:%s from remote - aborting",
pmix_socket_errno, strerror(pmix_socket_errno));
return PMIX_ERR_UNREACH;
}
continue;
}
cnt += retval;
}
pmix_output_verbose(8, pmix_globals.debug_output,
"blocking receive complete from remote");
return PMIX_SUCCESS;
}
int pmix_compress_bzip_compress_nb(char * fname, char **cname, char **postfix, pid_t *child_pid)
{
char **argv = NULL;
char * base_fname = NULL;
char * dir_fname = NULL;
int status;
bool is_dir;
is_dir = is_directory(fname);
*child_pid = fork();
if( *child_pid == 0 ) { /* Child */
char * cmd;
dir_fname = pmix_dirname(fname);
base_fname = pmix_basename(fname);
chdir(dir_fname);
if( is_dir ) {
pmix_asprintf(cname, "%s.tar.bz2", base_fname);
pmix_asprintf(&cmd, "tar -jcf %s %s", *cname, base_fname);
} else {
pmix_asprintf(cname, "%s.bz2", base_fname);
pmix_asprintf(&cmd, "bzip2 %s", base_fname);
}
pmix_output_verbose(10, mca_compress_bzip_component.super.output_handle,
"compress:bzip: compress_nb(%s -> [%s])",
fname, *cname);
pmix_output_verbose(10, mca_compress_bzip_component.super.output_handle,
"compress:bzip: compress_nb() command [%s]",
cmd);
argv = pmix_argv_split(cmd, ' ');
status = execvp(argv[0], argv);
pmix_output(0, "compress:bzip: compress_nb: Failed to exec child [%s] status = %d\n", cmd, status);
exit(PMIX_ERROR);
}
else if( *child_pid > 0 ) {
if( is_dir ) {
*postfix = strdup(".tar.bz2");
} else {
*postfix = strdup(".bz2");
}
pmix_asprintf(cname, "%s%s", fname, *postfix);
}
else {
return PMIX_ERROR;
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_info(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_info_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
char *tmp;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d info", *num_vals);
ptr = (pmix_info_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
memset(ptr[i].key, 0, sizeof(ptr[i].key));
memset(&ptr[i].value, 0, sizeof(pmix_value_t));
/* unpack key */
m=1;
tmp = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &tmp, &m, PMIX_STRING))) {
PMIX_ERROR_LOG(ret);
return ret;
}
if (NULL == tmp) {
PMIX_ERROR_LOG(PMIX_ERROR);
return PMIX_ERROR;
}
(void)strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
free(tmp);
/* unpack the flags */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_infodirs(buffer, &ptr[i].flags, &m, PMIX_INFO_DIRECTIVES))) {
PMIX_ERROR_LOG(ret);
return ret;
}
/* unpack value - since the value structure is statically-defined
* instead of a pointer in this struct, we directly unpack it to
* avoid the malloc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int(buffer, &ptr[i].value.type, &m, PMIX_INT))) {
PMIX_ERROR_LOG(ret);
return ret;
}
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: info type %d", ptr[i].value.type);
m=1;
if (PMIX_SUCCESS != (ret = unpack_val(buffer, &ptr[i].value))) {
PMIX_ERROR_LOG(ret);
return ret;
}
}
return PMIX_SUCCESS;
}
static void query_cbfunc(struct pmix_peer_t *peer,
pmix_ptl_hdr_t *hdr,
pmix_buffer_t *buf, void *cbdata)
{
pmix_query_caddy_t *cd = (pmix_query_caddy_t*)cbdata;
pmix_status_t rc;
pmix_shift_caddy_t *results;
int cnt;
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix:query cback from server");
results = PMIX_NEW(pmix_shift_caddy_t);
/* unpack the status */
cnt = 1;
PMIX_BFROPS_UNPACK(rc, peer, buf, &results->status, &cnt, PMIX_STATUS);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
results->status = rc;
goto complete;
}
if (PMIX_SUCCESS != results->status) {
goto complete;
}
/* unpack any returned data */
cnt = 1;
PMIX_BFROPS_UNPACK(rc, peer, buf, &results->ninfo, &cnt, PMIX_SIZE);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
results->status = rc;
goto complete;
}
if (0 < results->ninfo) {
PMIX_INFO_CREATE(results->info, results->ninfo);
cnt = results->ninfo;
PMIX_BFROPS_UNPACK(rc, peer, buf, results->info, &cnt, PMIX_INFO);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
results->status = rc;
goto complete;
}
}
complete:
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix:query cback from server releasing");
/* release the caller */
if (NULL != cd->cbfunc) {
cd->cbfunc(results->status, results->info, results->ninfo, cd->cbdata, relcbfunc, results);
}
PMIX_RELEASE(cd);
}
pmix_status_t pmix_bfrops_base_unpack_pdata(pmix_pointer_array_t *regtypes,
pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_pdata_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
char *tmp;
pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
"pmix_bfrop_unpack: %d pdata", *num_vals);
ptr = (pmix_pdata_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_PDATA_CONSTRUCT(&ptr[i]);
/* unpack the proc */
m=1;
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &ptr[i].proc, &m, PMIX_PROC, regtypes);
if (PMIX_SUCCESS != ret) {
return ret;
}
/* unpack key */
m=1;
tmp = NULL;
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &tmp, &m, PMIX_STRING, regtypes);
if (PMIX_SUCCESS != ret) {
return ret;
}
if (NULL == tmp) {
PMIX_ERROR_LOG(PMIX_ERROR);
return PMIX_ERROR;
}
pmix_strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
free(tmp);
/* unpack value - since the value structure is statically-defined
* instead of a pointer in this struct, we directly unpack it to
* avoid the malloc */
if (PMIX_SUCCESS != (ret = pmix_bfrop_get_data_type(regtypes, buffer, &ptr[i].value.type))) {
PMIX_ERROR_LOG(ret);
return ret;
}
pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
"pmix_bfrop_unpack: pdata type %d %s", ptr[i].value.type, ptr[i].value.data.string);
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrops_base_unpack_val(regtypes, buffer, &ptr[i].value))) {
PMIX_ERROR_LOG(ret);
return ret;
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrops_base_unpack_info(pmix_pointer_array_t *regtypes,
pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_info_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
char *tmp;
pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
"pmix_bfrop_unpack: %d info", *num_vals);
ptr = (pmix_info_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
memset(ptr[i].key, 0, sizeof(ptr[i].key));
memset(&ptr[i].value, 0, sizeof(pmix_value_t));
/* unpack key */
m=1;
tmp = NULL;
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &tmp, &m, PMIX_STRING, regtypes);
if (PMIX_SUCCESS != ret) {
PMIX_ERROR_LOG(ret);
return ret;
}
if (NULL == tmp) {
return PMIX_ERROR;
}
pmix_strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
free(tmp);
/* unpack the directives */
m=1;
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &ptr[i].flags, &m, PMIX_INFO_DIRECTIVES, regtypes);
if (PMIX_SUCCESS != ret) {
return ret;
}
/* unpack value - since the value structure is statically-defined
* instead of a pointer in this struct, we directly unpack it to
* avoid the malloc */
if (PMIX_SUCCESS != (ret = pmix_bfrop_get_data_type(regtypes, buffer, &ptr[i].value.type))) {
return ret;
}
pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
"pmix_bfrop_unpack: info type %d", ptr[i].value.type);
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrops_base_unpack_val(regtypes, buffer, &ptr[i].value))) {
return ret;
}
}
return PMIX_SUCCESS;
}
int _mmap_segment_create(pmix_sm_seg_t *sm_seg, const char *file_name, size_t size)
{
int rc = PMIX_SUCCESS;
void *seg_addr = MAP_FAILED;
pid_t my_pid = getpid();
_segment_ds_reset(sm_seg);
/* enough space is available, so create the segment */
if (-1 == (sm_seg->seg_id = open(file_name, O_CREAT | O_RDWR, 0600))) {
pmix_output_verbose(2, pmix_globals.debug_output,
"sys call open(2) fail\n");
rc = PMIX_ERROR;
goto out;
}
/* size backing file - note the use of real_size here */
if (0 != ftruncate(sm_seg->seg_id, size)) {
pmix_output_verbose(2, pmix_globals.debug_output,
"sys call ftruncate(2) fail\n");
rc = PMIX_ERROR;
goto out;
}
if (MAP_FAILED == (seg_addr = mmap(NULL, size,
PROT_READ | PROT_WRITE, MAP_SHARED,
sm_seg->seg_id, 0))) {
pmix_output_verbose(2, pmix_globals.debug_output,
"sys call mmap(2) fail\n");
rc = PMIX_ERROR;
goto out;
}
sm_seg->seg_cpid = my_pid;
sm_seg->seg_size = size;
sm_seg->seg_base_addr = (unsigned char *)seg_addr;
(void)strncpy(sm_seg->seg_name, file_name, PMIX_PATH_MAX - 1);
out:
if (-1 != sm_seg->seg_id) {
if (0 != close(sm_seg->seg_id)) {
pmix_output_verbose(2, pmix_globals.debug_output,
"sys call close(2) fail\n");
rc = PMIX_ERROR;
}
}
/* an error occured, so invalidate the shmem object and munmap if needed */
if (PMIX_SUCCESS != rc) {
if (MAP_FAILED != seg_addr) {
munmap((void *)seg_addr, size);
}
_segment_ds_reset(sm_seg);
}
return rc;
}
void pmix_output_hexdump(int verbose_level, int output_id,
void *ptr, int buflen)
{
unsigned char *buf = (unsigned char *) ptr;
char out_buf[120];
int ret = 0;
int out_pos = 0;
int i, j;
if (output_id >= 0 && output_id < PMIX_OUTPUT_MAX_STREAMS &&
info[output_id].ldi_verbose_level >= verbose_level) {
pmix_output_verbose(verbose_level, output_id, "dump data at %p %d bytes\n", ptr, buflen);
for (i = 0; i < buflen; i += 16) {
out_pos = 0;
ret = sprintf(out_buf + out_pos, "%06x: ", i);
if (ret < 0)
return;
out_pos += ret;
for (j = 0; j < 16; j++) {
if (i + j < buflen)
ret = sprintf(out_buf + out_pos, "%02x ",
buf[i + j]);
else
ret = sprintf(out_buf + out_pos, " ");
if (ret < 0)
return;
out_pos += ret;
}
ret = sprintf(out_buf + out_pos, " ");
if (ret < 0)
return;
out_pos += ret;
for (j = 0; j < 16; j++)
if (i + j < buflen) {
ret = sprintf(out_buf + out_pos, "%c",
isprint(buf[i+j]) ?
buf[i + j] :
'.');
if (ret < 0)
return;
out_pos += ret;
}
ret = sprintf(out_buf + out_pos, "\n");
if (ret < 0)
return;
pmix_output_verbose(verbose_level, output_id, "%s", out_buf);
}
}
}
pmix_status_t pmix_bfrop_unpack_pdata(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_pdata_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
char *tmp;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d pdata", *num_vals);
ptr = (pmix_pdata_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_PDATA_CONSTRUCT(&ptr[i]);
/* unpack the proc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_proc(buffer, &ptr[i].proc, &m, PMIX_PROC))) {
return ret;
}
/* unpack key */
m=1;
tmp = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &tmp, &m, PMIX_STRING))) {
return ret;
}
if (NULL == tmp) {
return PMIX_ERROR;
}
(void)strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
free(tmp);
/* unpack value - since the value structure is statically-defined
* instead of a pointer in this struct, we directly unpack it to
* avoid the malloc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int(buffer, &ptr[i].value.type, &m, PMIX_INT))) {
return ret;
}
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: pdata type %d", ptr[i].value.type);
m=1;
if (PMIX_SUCCESS != (ret = unpack_val(buffer, &ptr[i].value))) {
return ret;
}
}
return PMIX_SUCCESS;
}
/*
* BOOL
*/
pmix_status_t pmix_bfrop_unpack_bool(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
int32_t i;
uint8_t *src;
bool *dst;
pmix_output_verbose(20, pmix_globals.debug_output, "pmix_bfrop_unpack_bool * %d\n", (int)*num_vals);
/* check to see if there's enough data in buffer */
if (pmix_bfrop_too_small(buffer, *num_vals)) {
return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
}
/* unpack the data */
src = (uint8_t*)buffer->unpack_ptr;
dst = (bool*)dest;
for (i=0; i < *num_vals; i++) {
if (src[i]) {
dst[i] = true;
} else {
dst[i] = false;
}
}
/* update buffer pointer */
buffer->unpack_ptr += *num_vals;
return PMIX_SUCCESS;
}
int PMIx_Disconnect(const pmix_proc_t procs[], size_t nprocs)
{
int rc;
pmix_cb_t *cb;
if (pmix_client_globals.init_cntr <= 0) {
return PMIX_ERR_INIT;
}
/* if we aren't connected, don't attempt to send */
if (!pmix_globals.connected) {
return PMIX_ERR_UNREACH;
}
/* 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 */
cb = PMIX_NEW(pmix_cb_t);
cb->active = true;
if (PMIX_SUCCESS != (rc = PMIx_Disconnect_nb(procs, nprocs, op_cbfunc, cb))) {
PMIX_RELEASE(cb);
return rc;
}
/* wait for the connect to complete */
PMIX_WAIT_FOR_COMPLETION(cb->active);
rc = cb->status;
PMIX_RELEASE(cb);
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix: disconnect completed");
return rc;
}
/* KVS_Put - we default to PMIX_GLOBAL scope and ignore the
* provided kvsname as we only put into our own nspace */
PMIX_EXPORT int PMI_KVS_Put(const char kvsname[], const char key[], const char value[])
{
pmix_status_t rc = PMIX_SUCCESS;
pmix_value_t val;
PMI_CHECK();
if ((kvsname == NULL) || (strlen(kvsname) > PMI_MAX_KVSNAME_LEN)) {
return PMI_ERR_INVALID_KVS;
}
if ((key == NULL) || (strlen(key) >PMI_MAX_KEY_LEN)) {
return PMI_ERR_INVALID_KEY;
}
if ((value == NULL) || (strlen(value) > PMI_MAX_VAL_LEN)) {
return PMI_ERR_INVALID_VAL;
}
if (pmi_singleton) {
return PMI_SUCCESS;
}
pmix_output_verbose(2, pmix_globals.debug_output,
"PMI_KVS_Put: KVS=%s, key=%s value=%s", kvsname, key, value);
val.type = PMIX_STRING;
val.data.string = (char*)value;
rc = PMIx_Put(PMIX_GLOBAL, key, &val);
return convert_err(rc);
}
/*
* Open up all directories in a given path and search for components of
* the specified type (and possibly of a given name).
*
* Note that we use our own path iteration functionality because we
* need to look at companion .ompi_info files in the same directory as
* the library to generate dependencies, etc.
*/
static void find_dyn_components(const char *path, pmix_mca_base_framework_t *framework,
const char **names, bool include_mode)
{
pmix_mca_base_component_repository_item_t *ri;
pmix_list_t *dy_components;
int ret;
pmix_output_verbose (PMIX_MCA_BASE_VERBOSE_COMPONENT, framework->framework_output,
"mca: base: find_dyn_components: checking %s for %s components",
path, framework->framework_name);
if (NULL != path) {
ret = pmix_mca_base_component_repository_add(path);
if (PMIX_SUCCESS != ret) {
return;
}
}
ret = pmix_mca_base_component_repository_get_components(framework, &dy_components);
if (PMIX_SUCCESS != ret) {
return;
}
/* Iterate through the repository and find components that can be included */
PMIX_LIST_FOREACH(ri, dy_components, pmix_mca_base_component_repository_item_t) {
if (use_component(include_mode, names, ri->ri_name)) {
pmix_mca_base_component_repository_open(framework, ri);
}
}
}
/* KVS_Fence */
int PMI2_KVS_Fence(void)
{
pmix_status_t rc = PMIX_SUCCESS;
PMI2_CHECK();
pmix_output_verbose(3, pmix_globals.debug_output, "PMI2_KVS_Fence");
if (PMIX_SUCCESS != (rc = PMIx_Commit())) {
return convert_err(rc);
}
/* we want all data to be collected upon completion */
{
pmix_info_t info[1];
bool val_data = 1;
/* set controlling parameters
* PMIX_COLLECT_DATA - meet legacy PMI2 requirement
*/
PMIX_INFO_CONSTRUCT(&info[0]);
PMIX_INFO_LOAD(&info[0], PMIX_COLLECT_DATA, &val_data, PMIX_BOOL);
rc = PMIx_Fence(NULL, 0, &info[0], 1);
PMIX_INFO_DESTRUCT(&info[0]);
}
return convert_err(rc);
}
int pmix_bfrop_pack_buffer(pmix_buffer_t *buffer,
const void *src, int32_t num_vals,
pmix_data_type_t type)
{
int rc;
pmix_bfrop_type_info_t *info;
pmix_output_verbose(20, pmix_globals.debug_output, "pmix_bfrop_pack_buffer( %p, %p, %lu, %d )\n",
(void*)buffer, src, (long unsigned int)num_vals, (int)type);
/* Pack the declared data type */
if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
if (PMIX_SUCCESS != (rc = pmix_bfrop_store_data_type(buffer, type))) {
return rc;
}
}
/* Lookup the pack function for this type and call it */
if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&pmix_bfrop_types, type))) {
return PMIX_ERR_PACK_FAILURE;
}
return info->odti_pack_fn(buffer, src, num_vals, type);
}
PMIX_EXPORT pmix_status_t PMIx_Publish(const pmix_info_t info[],
size_t ninfo)
{
pmix_status_t rc;
pmix_cb_t *cb;
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix: publish called");
if (pmix_globals.init_cntr <= 0) {
return PMIX_ERR_INIT;
}
/* if we aren't connected, don't attempt to send */
if (!pmix_globals.connected) {
return PMIX_ERR_UNREACH;
}
/* create a callback object to let us know when it is done */
cb = PMIX_NEW(pmix_cb_t);
cb->active = true;
if (PMIX_SUCCESS != (rc = PMIx_Publish_nb(info, ninfo, op_cbfunc, cb))) {
PMIX_ERROR_LOG(rc);
PMIX_RELEASE(cb);
return rc;
}
/* wait for the server to ack our request */
PMIX_WAIT_FOR_COMPLETION(cb->active);
rc = (pmix_status_t)cb->status;
PMIX_RELEASE(cb);
return rc;
}
pmix_status_t pmix_bfrop_unpack_buffer(pmix_buffer_t *buffer, void *dst, int32_t *num_vals,
pmix_data_type_t type)
{
pmix_status_t rc;
pmix_data_type_t local_type;
pmix_bfrop_type_info_t *info;
pmix_output_verbose(20, pmix_globals.debug_output, "pmix_bfrop_unpack_buffer( %p, %p, %lu, %d )\n",
(void*)buffer, dst, (long unsigned int)*num_vals, (int)type);
/** Unpack the declared data type */
if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
if (PMIX_SUCCESS != (rc = pmix_bfrop_get_data_type(buffer, &local_type))) {
return rc;
}
/* if the data types don't match, then return an error */
if (type != local_type) {
pmix_output(0, "PMIX bfrop:unpack: got type %d when expecting type %d", local_type, type);
return PMIX_ERR_PACK_MISMATCH;
}
}
/* Lookup the unpack function for this type and call it */
if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&pmix_bfrop_types, type))) {
return PMIX_ERR_UNPACK_FAILURE;
}
return info->odti_unpack_fn(buffer, dst, num_vals, type);
}
PMIX_EXPORT pmix_status_t PMIx_Unpublish(char **keys,
const pmix_info_t info[], size_t ninfo)
{
pmix_status_t rc;
pmix_cb_t *cb;
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix: unpublish called");
/* 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 */
cb = PMIX_NEW(pmix_cb_t);
cb->active = true;
/* push the message into our event base to send to the server */
if (PMIX_SUCCESS != (rc = PMIx_Unpublish_nb(keys, info, ninfo, op_cbfunc, cb))) {
PMIX_RELEASE(cb);
return rc;
}
/* wait for the server to ack our request */
PMIX_WAIT_FOR_COMPLETION(cb->active);
rc = cb->status;
PMIX_RELEASE(cb);
return rc;
}
pmix_status_t pmix_bfrop_unpack_double(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
int32_t i, n;
double *desttmp = (double*) dest, tmp;
pmix_status_t ret;
char *convert;
pmix_output_verbose(20, pmix_globals.debug_output, "pmix_bfrop_unpack_double * %d\n", (int)*num_vals);
/* check to see if there's enough data in buffer */
if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(double))) {
return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
}
/* unpack the data */
for (i = 0; i < (*num_vals); ++i) {
n=1;
convert = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &convert, &n, PMIX_STRING))) {
return ret;
}
if (NULL != convert) {
tmp = strtod(convert, NULL);
memcpy(&desttmp[i], &tmp, sizeof(tmp));
free(convert);
}
}
return PMIX_SUCCESS;
}
/*
* INT64
*/
int pmix_bfrop_pack_int64(pmix_buffer_t *buffer, const void *src,
int32_t num_vals, pmix_data_type_t type)
{
int32_t i;
uint64_t tmp, tmp2;
char *dst;
size_t bytes_packed = num_vals * sizeof(tmp);
pmix_output_verbose(20, pmix_globals.debug_output, "pmix_bfrop_pack_int64 * %d\n", num_vals);
/* check to see if buffer needs extending */
if (NULL == (dst = pmix_bfrop_buffer_extend(buffer, bytes_packed))) {
return PMIX_ERR_OUT_OF_RESOURCE;
}
for (i = 0; i < num_vals; ++i) {
memcpy(&tmp2, (char *)src+i*sizeof(uint64_t), sizeof(uint64_t));
tmp = pmix_hton64(tmp2);
memcpy(dst, &tmp, sizeof(tmp));
dst += sizeof(tmp);
}
buffer->pack_ptr += bytes_packed;
buffer->bytes_used += bytes_packed;
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_timeval(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
int32_t i, n;
int64_t tmp[2];
struct timeval *desttmp = (struct timeval *) dest, tt;
pmix_status_t ret;
pmix_output_verbose(20, pmix_globals.debug_output, "pmix_bfrop_unpack_timeval * %d\n", (int)*num_vals);
/* check to see if there's enough data in buffer */
if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(struct timeval))) {
return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
}
/* unpack the data */
for (i = 0; i < (*num_vals); ++i) {
n=2;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int64(buffer, tmp, &n, PMIX_INT64))) {
return ret;
}
tt.tv_sec = tmp[0];
tt.tv_usec = tmp[1];
memcpy(&desttmp[i], &tt, sizeof(tt));
}
return PMIX_SUCCESS;
}
/*
* BOOL
*/
int pmix_bfrop_pack_bool(pmix_buffer_t *buffer, const void *src,
int32_t num_vals, pmix_data_type_t type)
{
uint8_t *dst;
int32_t i;
bool *s = (bool*)src;
pmix_output_verbose(20, pmix_globals.debug_output, "pmix_bfrop_pack_bool * %d\n", num_vals);
/* check to see if buffer needs extending */
if (NULL == (dst = (uint8_t*)pmix_bfrop_buffer_extend(buffer, num_vals))) {
return PMIX_ERR_OUT_OF_RESOURCE;
}
/* store the data */
for (i=0; i < num_vals; i++) {
if (s[i]) {
dst[i] = 1;
} else {
dst[i] = 0;
}
}
/* update buffer pointers */
buffer->pack_ptr += num_vals;
buffer->bytes_used += num_vals;
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_time(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
int32_t i, n;
time_t *desttmp = (time_t *) dest, tmp;
pmix_status_t ret;
uint64_t ui64;
/* time_t is a system-dependent size, so cast it
* to uint64_t as a generic safe size
*/
pmix_output_verbose(20, pmix_globals.debug_output, "pmix_bfrop_unpack_time * %d\n", (int)*num_vals);
/* check to see if there's enough data in buffer */
if (pmix_bfrop_too_small(buffer, (*num_vals)*(sizeof(uint64_t)))) {
return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
}
/* unpack the data */
for (i = 0; i < (*num_vals); ++i) {
n=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int64(buffer, &ui64, &n, PMIX_UINT64))) {
return ret;
}
tmp = (time_t)ui64;
memcpy(&desttmp[i], &tmp, sizeof(tmp));
}
return PMIX_SUCCESS;
}