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_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;
}
static void log_cbfunc(struct pmix_peer_t *peer,
pmix_ptl_hdr_t *hdr,
pmix_buffer_t *buf, void *cbdata)
{
pmix_shift_caddy_t *cd = (pmix_shift_caddy_t*)cbdata;
int32_t m;
pmix_status_t rc, status;
/* unpack the return status */
m=1;
PMIX_BFROPS_UNPACK(rc, peer, buf, &status, &m, PMIX_STATUS);
if (PMIX_SUCCESS != rc) {
status = rc;
}
if (NULL != cd->cbfunc.opcbfn) {
cd->cbfunc.opcbfn(status, cd->cbdata);
}
PMIX_RELEASE(cd);
}
static pmix_status_t unpack_return(pmix_buffer_t *data)
{
pmix_status_t rc;
pmix_status_t ret;
int32_t cnt;
pmix_output_verbose(2, pmix_globals.debug_output,
"client:unpack fence called");
/* unpack the status code */
cnt = 1;
PMIX_BFROPS_UNPACK(rc, pmix_client_globals.myserver,
data, &ret, &cnt, PMIX_STATUS);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
return rc;
}
pmix_output_verbose(2, pmix_globals.debug_output,
"client:unpack fence received status %d", ret);
return PMIX_SUCCESS;
}
static void wait_cbfunc(struct pmix_peer_t *pr,
pmix_ptl_hdr_t *hdr,
pmix_buffer_t *buf, void *cbdata)
{
pmix_cb_t *cb = (pmix_cb_t*)cbdata;
pmix_status_t rc;
int ret;
int32_t cnt;
PMIX_ACQUIRE_OBJECT(cb);
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix:client recv callback activated with %d bytes",
(NULL == buf) ? -1 : (int)buf->bytes_used);
if (NULL == buf) {
rc = PMIX_ERR_BAD_PARAM;
goto report;
}
/* a zero-byte buffer indicates that this recv is being
* completed due to a lost connection */
if (PMIX_BUFFER_IS_EMPTY(buf)) {
rc = PMIX_ERR_UNREACH;
goto report;
}
/* unpack the returned status */
cnt = 1;
PMIX_BFROPS_UNPACK(rc, pmix_client_globals.myserver,
buf, &ret, &cnt, PMIX_STATUS);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
}
report:
if (NULL != cb->cbfunc.opfn) {
cb->cbfunc.opfn(rc, cb->cbdata);
}
PMIX_RELEASE(cb);
}
static void wait_lookup_cbfunc(struct pmix_peer_t *pr,
pmix_ptl_hdr_t *hdr,
pmix_buffer_t *buf, void *cbdata)
{
pmix_cb_t *cb = (pmix_cb_t*)cbdata;
pmix_status_t rc, ret;
int32_t cnt;
pmix_pdata_t *pdata;
size_t ndata;
PMIX_ACQUIRE_OBJECT(cb);
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix:client recv callback activated with %d bytes",
(NULL == buf) ? -1 : (int)buf->bytes_used);
/* set the defaults */
pdata = NULL;
ndata = 0;
if (NULL == cb->cbfunc.lookupfn) {
/* nothing we can do with this */
PMIX_RELEASE(cb);
return;
}
if (NULL == buf) {
rc = PMIX_ERR_BAD_PARAM;
goto report;
}
/* a zero-byte buffer indicates that this recv is being
* completed due to a lost connection */
if (PMIX_BUFFER_IS_EMPTY(buf)) {
rc = PMIX_ERR_UNREACH;
goto report;
}
/* unpack the returned status */
cnt = 1;
PMIX_BFROPS_UNPACK(rc, pmix_client_globals.myserver,
buf, &ret, &cnt, PMIX_STATUS);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
ret = rc;
}
if (PMIX_SUCCESS != ret) {
if (NULL != cb->cbfunc.lookupfn) {
cb->cbfunc.lookupfn(ret, NULL, 0, cb->cbdata);
}
PMIX_RELEASE(cb);
return;
}
/* unpack the number of returned values */
cnt = 1;
PMIX_BFROPS_UNPACK(rc, pmix_client_globals.myserver,
buf, &ndata, &cnt, PMIX_SIZE);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
PMIX_RELEASE(cb);
return;
}
if (0 < ndata) {
/* create the array storage */
PMIX_PDATA_CREATE(pdata, ndata);
cnt = ndata;
/* unpack the returned values into the pdata array */
PMIX_BFROPS_UNPACK(rc, pmix_client_globals.myserver,
buf, pdata, &cnt, PMIX_PDATA);
if (PMIX_SUCCESS != rc) {
PMIX_ERROR_LOG(rc);
goto cleanup;
}
}
report:
if (NULL != cb->cbfunc.lookupfn) {
cb->cbfunc.lookupfn(rc, pdata, ndata, cb->cbdata);
}
cleanup:
/* cleanup */
if (NULL != pdata) {
PMIX_PDATA_FREE(pdata, ndata);
}
PMIX_RELEASE(cb);
}
