opal/mca/pmix/pmix4x/pmix4x.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
legacy_get
opcbfunc
pmix4x_get_nspace
pmix4x_register_jobid
event_hdlr_complete
return_local_event_hdlr
process_event
pmix4x_event_hdlr
pmix4x_register_cleanup
pmix4x_convert_rank
pmix4x_convert_opalrank
pmix4x_convert_opalrc
pmix4x_convert_rc
pmix4x_convert_scope
pmix4x_convert_opalscope
pmix4x_convert_opalrange
pmix4x_convert_range
pmix4x_convert_persist
pmix4x_convert_opalpersist
pmix4x_convert_jobid
pmix4x_value_load
pmix4x_value_unload
errreg_cbfunc
register_handler
deregister_handler
notify_complete
notify_event
relcbfunc
infocbfunc
pmix4x_query
pmix4x_log
pmix4x_convert_allocdir
pmix4x_convert_state
pmix4x_convert_opalstate
evcon
evdes
opcon
opdes
ocadcon
ocaddes
tscon
tsdes
dmcon
dmdes
   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
   2 /*
   3  * Copyright (c) 2014-2018 Intel, Inc. All rights reserved.
   4  * Copyright (c) 2014-2017 Research Organization for Information Science
   5  *                         and Technology (RIST). All rights reserved.
   6  * Copyright (c) 2014-2015 Mellanox Technologies, Inc.
   7  *                         All rights reserved.
   8  * Copyright (c) 2016      Cisco Systems, Inc.  All rights reserved.
   9  * Copyright (c) 2017      Los Alamos National Security, LLC. All rights
  10  *                         reserved.
  11  * $COPYRIGHT$
  12  *
  13  * Additional copyrights may follow
  14  *
  15  * $HEADER$
  16  */
  17 
  18 #include "opal_config.h"
  19 #include "opal/constants.h"
  20 #include "opal/types.h"
  21 
  22 #ifdef HAVE_STRING_H
  23 #include <string.h>
  24 #endif
  25 #ifdef HAVE_UNISTD_H
  26 #include <unistd.h>
  27 #endif
  28 #ifdef HAVE_SYS_STAT_H
  29 #include <sys/stat.h>
  30 #endif
  31 
  32 #include "opal/dss/dss.h"
  33 #include "opal/mca/event/event.h"
  34 #include "opal/mca/hwloc/base/base.h"
  35 #include "opal/runtime/opal.h"
  36 #include "opal/runtime/opal_progress_threads.h"
  37 #include "opal/threads/threads.h"
  38 #include "opal/util/argv.h"
  39 #include "opal/util/error.h"
  40 #include "opal/util/opal_environ.h"
  41 #include "opal/util/output.h"
  42 #include "opal/util/proc.h"
  43 #include "opal/util/show_help.h"
  44 
  45 #include "pmix4x.h"
  46 #include "opal/mca/pmix/base/base.h"
  47 #include "opal/mca/pmix/pmix_types.h"
  48 
  49 #include <pmix_common.h>
  50 #include <pmix.h>
  51 
  52 /****    C.O.M.M.O.N   I.N.T.E.R.F.A.C.E.S     ****/
  53 
  54 /* These are functions used by both client and server to
  55  * access common functions in the embedded PMIx library */
  56 static bool legacy_get(void);
  57 static const char *pmix4x_get_nspace(opal_jobid_t jobid);
  58 static void pmix4x_register_jobid(opal_jobid_t jobid, const char *nspace);
  59 static void register_handler(opal_list_t *event_codes,
  60                              opal_list_t *info,
  61                              opal_pmix_notification_fn_t evhandler,
  62                              opal_pmix_evhandler_reg_cbfunc_t cbfunc,
  63                              void *cbdata);
  64 static void deregister_handler(size_t evhandler,
  65                                opal_pmix_op_cbfunc_t cbfunc,
  66                                void *cbdata);
  67 static int notify_event(int status,
  68                         const opal_process_name_t *source,
  69                         opal_pmix_data_range_t range,
  70                         opal_list_t *info,
  71                         opal_pmix_op_cbfunc_t cbfunc, void *cbdata);
  72 static void pmix4x_query(opal_list_t *queries,
  73                          opal_pmix_info_cbfunc_t cbfunc, void *cbdata);
  74 static void pmix4x_log(opal_list_t *info,
  75                        opal_pmix_op_cbfunc_t cbfunc, void *cbdata);
  76 
  77 static int pmix4x_register_cleanup(char *path, bool directory, bool ignore, bool jobscope);
  78 
  79 const opal_pmix_base_module_t opal_pmix_pmix4x_module = {
  80     .legacy_get = legacy_get,
  81     /* client APIs */
  82     .init = pmix4x_client_init,
  83     .finalize = pmix4x_client_finalize,
  84     .initialized = pmix4x_initialized,
  85     .abort = pmix4x_abort,
  86     .commit = pmix4x_commit,
  87     .fence = pmix4x_fence,
  88     .fence_nb = pmix4x_fencenb,
  89     .put = pmix4x_put,
  90     .get = pmix4x_get,
  91     .get_nb = pmix4x_getnb,
  92     .publish = pmix4x_publish,
  93     .publish_nb = pmix4x_publishnb,
  94     .lookup = pmix4x_lookup,
  95     .lookup_nb = pmix4x_lookupnb,
  96     .unpublish = pmix4x_unpublish,
  97     .unpublish_nb = pmix4x_unpublishnb,
  98     .spawn = pmix4x_spawn,
  99     .spawn_nb = pmix4x_spawnnb,
 100     .connect = pmix4x_connect,
 101     .connect_nb = pmix4x_connectnb,
 102     .disconnect = pmix4x_disconnect,
 103     .disconnect_nb = pmix4x_disconnectnb,
 104     .resolve_peers = pmix4x_resolve_peers,
 105     .resolve_nodes = pmix4x_resolve_nodes,
 106     .query = pmix4x_query,
 107     .log = pmix4x_log,
 108     .allocate = pmix4x_allocate,
 109     .job_control = pmix4x_job_control,
 110     .register_cleanup = pmix4x_register_cleanup,
 111     /* server APIs */
 112     .server_init = pmix4x_server_init,
 113     .server_finalize = pmix4x_server_finalize,
 114     .generate_regex = pmix4x_server_gen_regex,
 115     .generate_ppn = pmix4x_server_gen_ppn,
 116     .server_register_nspace = pmix4x_server_register_nspace,
 117     .server_deregister_nspace = pmix4x_server_deregister_nspace,
 118     .server_register_client = pmix4x_server_register_client,
 119     .server_deregister_client = pmix4x_server_deregister_client,
 120     .server_setup_fork = pmix4x_server_setup_fork,
 121     .server_dmodex_request = pmix4x_server_dmodex,
 122     .server_notify_event = pmix4x_server_notify_event,
 123     .server_iof_push = pmix4x_server_iof_push,
 124     .server_setup_application = pmix4x_server_setup_application,
 125     .server_setup_local_support = pmix4x_server_setup_local_support,
 126     /* tool APIs */
 127     .tool_init = pmix4x_tool_init,
 128     .tool_finalize = pmix4x_tool_fini,
 129     /* utility APIs */
 130     .get_version = PMIx_Get_version,
 131     .register_evhandler = register_handler,
 132     .deregister_evhandler = deregister_handler,
 133     .notify_event = notify_event,
 134     .store_local = pmix4x_store_local,
 135     .get_nspace = pmix4x_get_nspace,
 136     .register_jobid = pmix4x_register_jobid
 137 };
 138 
 139 static bool legacy_get(void)
 140 {
 141     return false;
 142 }
 143 
 144 static void opcbfunc(pmix_status_t status, void *cbdata)
 145 {
 146     pmix4x_opcaddy_t *op = (pmix4x_opcaddy_t*)cbdata;
 147 
 148     OPAL_ACQUIRE_OBJECT(op);
 149 
 150     if (NULL != op->opcbfunc) {
 151         op->opcbfunc(pmix4x_convert_rc(status), op->cbdata);
 152     }
 153     OBJ_RELEASE(op);
 154 }
 155 
 156 
 157 static const char *pmix4x_get_nspace(opal_jobid_t jobid)
 158 {
 159     opal_pmix4x_jobid_trkr_t *jptr;
 160 
 161     OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
 162 
 163     OPAL_LIST_FOREACH(jptr, &mca_pmix_pmix4x_component.jobids, opal_pmix4x_jobid_trkr_t) {
 164         if (jptr->jobid == jobid) {
 165             OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
 166             return jptr->nspace;
 167         }
 168     }
 169     OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
 170     return NULL;
 171 }
 172 
 173 static void pmix4x_register_jobid(opal_jobid_t jobid, const char *nspace)
 174 {
 175     opal_pmix4x_jobid_trkr_t *jptr;
 176 
 177     OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
 178 
 179     /* if we don't already have it, add this to our jobid tracker */
 180     OPAL_LIST_FOREACH(jptr, &mca_pmix_pmix4x_component.jobids, opal_pmix4x_jobid_trkr_t) {
 181         if (jptr->jobid == jobid) {
 182             OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
 183             return;
 184         }
 185     }
 186     jptr = OBJ_NEW(opal_pmix4x_jobid_trkr_t);
 187     (void)strncpy(jptr->nspace, nspace, PMIX_MAX_NSLEN);
 188     jptr->jobid = jobid;
 189     opal_list_append(&mca_pmix_pmix4x_component.jobids, &jptr->super);
 190     OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
 191 }
 192 
 193 static void event_hdlr_complete(pmix_status_t status, void *cbdata)
 194 {
 195     pmix4x_opcaddy_t *op = (pmix4x_opcaddy_t*)cbdata;
 196 
 197     OBJ_RELEASE(op);
 198 }
 199 
 200 static void return_local_event_hdlr(int status, opal_list_t *results,
 201                                     opal_pmix_op_cbfunc_t cbfunc, void *thiscbdata,
 202                                     void *notification_cbdata)
 203 {
 204     pmix4x_threadshift_t *cd = (pmix4x_threadshift_t*)notification_cbdata;
 205     pmix4x_opcaddy_t *op;
 206     opal_value_t *kv;
 207     pmix_status_t pstatus;
 208     size_t n;
 209 
 210     OPAL_ACQUIRE_OBJECT(cd);
 211     if (NULL != cd->pmixcbfunc) {
 212         op = OBJ_NEW(pmix4x_opcaddy_t);
 213 
 214         if (NULL != results && 0 < (op->ninfo = opal_list_get_size(results))) {
 215             /* convert the list of results to an array of info */
 216             PMIX_INFO_CREATE(op->info, op->ninfo);
 217             n=0;
 218             OPAL_LIST_FOREACH(kv, cd->info, opal_value_t) {
 219                 (void)strncpy(op->info[n].key, kv->key, PMIX_MAX_KEYLEN);
 220                 pmix4x_value_load(&op->info[n].value, kv);
 221                 ++n;
 222             }
 223         }
 224         /* convert the status */
 225         pstatus = pmix4x_convert_opalrc(status);
 226         /* call the library's callback function */
 227         cd->pmixcbfunc(pstatus, op->info, op->ninfo, event_hdlr_complete, op, cd->cbdata);
 228     }
 229 
 230     /* release the threadshift object */
 231     if (NULL != cd->info) {
 232         OPAL_LIST_RELEASE(cd->info);
 233     }
 234     OBJ_RELEASE(cd);
 235 
 236     /* release the caller */
 237     if (NULL != cbfunc) {
 238         cbfunc(OPAL_SUCCESS, thiscbdata);
 239     }
 240 }
 241 
 242 /* process the notification */
 243 static void process_event(int sd, short args, void *cbdata)
 244 {
 245     pmix4x_threadshift_t *cd = (pmix4x_threadshift_t*)cbdata;
 246     opal_pmix4x_event_t *event;
 247 
 248     OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
 249 
 250     /* cycle thru the registrations */
 251     OPAL_LIST_FOREACH(event, &mca_pmix_pmix4x_component.events, opal_pmix4x_event_t) {
 252         if (cd->id == event->index) {
 253             /* found it - invoke the handler, pointing its
 254              * callback function to our callback function */
 255             opal_output_verbose(2, opal_pmix_base_framework.framework_output,
 256                                 "%s _EVENT_HDLR CALLING EVHDLR",
 257                                 OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
 258             if (NULL != event->handler) {
 259                 OBJ_RETAIN(event);
 260                 OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
 261                 event->handler(cd->status, &cd->pname,
 262                                cd->info, &cd->results,
 263                                return_local_event_hdlr, cd);
 264                 OBJ_RELEASE(event);
 265                 return;
 266             }
 267         }
 268     }
 269 
 270     OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
 271 
 272     /* if we didn't find a match, we still have to call their final callback */
 273     if (NULL != cd->pmixcbfunc) {
 274         cd->pmixcbfunc(PMIX_SUCCESS, NULL, 0, NULL, NULL, cd->cbdata);
 275     }
 276     OPAL_LIST_RELEASE(cd->info);
 277     OBJ_RELEASE(cd);
 278     return;
 279 
 280 }
 281 /* this function will be called by the PMIx client library
 282  * whenever it receives notification of an event. The
 283  * notification can come from an ORTE daemon (when launched
 284  * by mpirun), directly from a RM (when direct launched), or
 285  * from another process (via the local daemon).
 286  * The call will occur in the PMIx event base */
 287 void pmix4x_event_hdlr(size_t evhdlr_registration_id,
 288                        pmix_status_t status, const pmix_proc_t *source,
 289                        pmix_info_t info[], size_t ninfo,
 290                        pmix_info_t results[], size_t nresults,
 291                        pmix_event_notification_cbfunc_fn_t cbfunc,
 292                        void *cbdata)
 293 {
 294     pmix4x_threadshift_t *cd;
 295     int rc;
 296     opal_value_t *iptr;
 297     size_t n;
 298 
 299     opal_output_verbose(2, opal_pmix_base_framework.framework_output,
 300                         "%s RECEIVED NOTIFICATION OF STATUS %d ON HDLR %lu",
 301                         OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), status,
 302                         (unsigned long)evhdlr_registration_id);
 303 
 304     OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
 305 
 306     cd = OBJ_NEW(pmix4x_threadshift_t);
 307     cd->id = evhdlr_registration_id;
 308     cd->pmixcbfunc = cbfunc;
 309     cd->cbdata = cbdata;
 310 
 311     /* convert the incoming status */
 312     cd->status = pmix4x_convert_rc(status);
 313     opal_output_verbose(2, opal_pmix_base_framework.framework_output,
 314                         "%s CONVERTED STATUS %d TO STATUS %d",
 315                         OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), status, cd->status);
 316 
 317     /* convert the nspace/rank to an opal_process_name_t */
 318     if (NULL == source) {
 319         cd->pname.jobid = OPAL_NAME_INVALID->jobid;
 320         cd->pname.vpid = OPAL_NAME_INVALID->vpid;
 321     } else {
 322         if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&cd->pname.jobid, source->nspace))) {
 323             OPAL_ERROR_LOG(rc);
 324             cd->pname.jobid = OPAL_NAME_INVALID->jobid;
 325         }
 326         cd->pname.vpid = pmix4x_convert_rank(source->rank);
 327     }
 328 
 329     /* convert the array of info */
 330     if (NULL != info) {
 331         cd->info = OBJ_NEW(opal_list_t);
 332         for (n=0; n < ninfo; n++) {
 333             iptr = OBJ_NEW(opal_value_t);
 334             iptr->key = strdup(info[n].key);
 335             if (OPAL_SUCCESS != (rc = pmix4x_value_unload(iptr, &info[n].value))) {
 336                 OPAL_ERROR_LOG(rc);
 337                 OBJ_RELEASE(iptr);
 338                 continue;
 339             }
 340             opal_list_append(cd->info, &iptr->super);
 341         }
 342     }
 343 
 344     /* convert the array of prior results */
 345     if (NULL != results) {
 346         for (n=0; n < nresults; n++) {
 347             iptr = OBJ_NEW(opal_value_t);
 348             iptr->key = strdup(results[n].key);
 349             if (OPAL_SUCCESS != (rc = pmix4x_value_unload(iptr, &results[n].value))) {
 350                 OPAL_ERROR_LOG(rc);
 351                 OBJ_RELEASE(iptr);
 352                 continue;
 353             }
 354             opal_list_append(&cd->results, &iptr->super);
 355         }
 356     }
 357 
 358     OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
 359 
 360     /* do NOT directly call the event handler as this
 361      * may lead to a deadlock condition should the
 362      * handler invoke a PMIx function */
 363     OPAL_PMIX2X_THREADSHIFT(cd, process_event);
 364     return;
 365 }
 366 
 367 static int pmix4x_register_cleanup(char *path, bool directory, bool ignore, bool jobscope)
 368 {
 369     pmix_info_t pinfo[3];
 370     size_t n, ninfo=0;
 371     pmix_status_t rc;
 372     int ret;
 373 
 374     if (ignore) {
 375         /* they want this path ignored */
 376         PMIX_INFO_LOAD(&pinfo[ninfo], PMIX_CLEANUP_IGNORE, path, PMIX_STRING);
 377         ++ninfo;
 378     } else {
 379         if (directory) {
 380             PMIX_INFO_LOAD(&pinfo[ninfo], PMIX_REGISTER_CLEANUP_DIR, path, PMIX_STRING);
 381             ++ninfo;
 382             /* recursively cleanup directories */
 383             PMIX_INFO_LOAD(&pinfo[ninfo], PMIX_CLEANUP_RECURSIVE, NULL, PMIX_BOOL);
 384             ++ninfo;
 385         } else {
 386             /* order cleanup of the provided path */
 387             PMIX_INFO_LOAD(&pinfo[ninfo], PMIX_REGISTER_CLEANUP, path, PMIX_STRING);
 388             ++ninfo;
 389         }
 390     }
 391 
 392     /* if they want this applied to the job, then indicate so */
 393     if (jobscope) {
 394         rc = PMIx_Job_control_nb(NULL, 0, pinfo, ninfo, NULL, NULL);
 395     } else {
 396         /* only applies to us */
 397         rc = PMIx_Job_control_nb(&mca_pmix_pmix4x_component.myproc, 1, pinfo, ninfo, NULL, NULL);
 398     }
 399     ret = pmix4x_convert_rc(rc);
 400     for (n=0; n < ninfo; n++) {
 401         PMIX_INFO_DESTRUCT(&pinfo[n]);
 402     }
 403     return ret;
 404 }
 405 
 406 opal_vpid_t pmix4x_convert_rank(pmix_rank_t rank)
 407 {
 408     switch(rank) {
 409     case PMIX_RANK_UNDEF:
 410         return OPAL_VPID_INVALID;
 411     case PMIX_RANK_WILDCARD:
 412         return OPAL_VPID_WILDCARD;
 413     default:
 414         return (opal_vpid_t)rank;
 415     }
 416 }
 417 
 418 pmix_rank_t pmix4x_convert_opalrank(opal_vpid_t vpid)
 419 {
 420     switch(vpid) {
 421     case OPAL_VPID_WILDCARD:
 422         return PMIX_RANK_WILDCARD;
 423     case OPAL_VPID_INVALID:
 424         return PMIX_RANK_UNDEF;
 425     default:
 426         return (pmix_rank_t)vpid;
 427     }
 428 }
 429 
 430 pmix_status_t pmix4x_convert_opalrc(int rc)
 431 {
 432     switch (rc) {
 433     case OPAL_ERR_DEBUGGER_RELEASE:
 434         return PMIX_ERR_DEBUGGER_RELEASE;
 435 
 436     case OPAL_ERR_HANDLERS_COMPLETE:
 437         return PMIX_EVENT_ACTION_COMPLETE;
 438 
 439     case OPAL_ERR_PROC_ABORTED:
 440         return PMIX_ERR_PROC_ABORTED;
 441 
 442     case OPAL_ERR_PROC_REQUESTED_ABORT:
 443         return PMIX_ERR_PROC_REQUESTED_ABORT;
 444 
 445     case OPAL_ERR_PROC_ABORTING:
 446         return PMIX_ERR_PROC_ABORTING;
 447 
 448     case OPAL_ERR_NODE_DOWN:
 449         return PMIX_ERR_NODE_DOWN;
 450 
 451     case OPAL_ERR_NODE_OFFLINE:
 452         return PMIX_ERR_NODE_OFFLINE;
 453 
 454     case OPAL_ERR_JOB_TERMINATED:
 455         return PMIX_ERR_JOB_TERMINATED;
 456 
 457     case OPAL_ERR_PROC_RESTART:
 458         return PMIX_ERR_PROC_RESTART;
 459 
 460     case OPAL_ERR_PROC_CHECKPOINT:
 461         return PMIX_ERR_PROC_CHECKPOINT;
 462 
 463     case OPAL_ERR_PROC_MIGRATE:
 464         return PMIX_ERR_PROC_MIGRATE;
 465 
 466     case OPAL_ERR_EVENT_REGISTRATION:
 467         return PMIX_ERR_EVENT_REGISTRATION;
 468 
 469     case OPAL_ERR_NOT_IMPLEMENTED:
 470     case OPAL_ERR_NOT_SUPPORTED:
 471         return PMIX_ERR_NOT_SUPPORTED;
 472 
 473     case OPAL_ERR_NOT_FOUND:
 474         return PMIX_ERR_NOT_FOUND;
 475 
 476     case OPAL_ERR_PERM:
 477     case OPAL_ERR_UNREACH:
 478     case OPAL_ERR_SERVER_NOT_AVAIL:
 479         return PMIX_ERR_UNREACH;
 480 
 481     case OPAL_ERR_BAD_PARAM:
 482         return PMIX_ERR_BAD_PARAM;
 483 
 484     case OPAL_ERR_OUT_OF_RESOURCE:
 485         return PMIX_ERR_OUT_OF_RESOURCE;
 486 
 487     case OPAL_ERR_DATA_VALUE_NOT_FOUND:
 488         return PMIX_ERR_DATA_VALUE_NOT_FOUND;
 489 
 490     case OPAL_ERR_TIMEOUT:
 491         return PMIX_ERR_TIMEOUT;
 492 
 493     case OPAL_ERR_WOULD_BLOCK:
 494         return PMIX_ERR_WOULD_BLOCK;
 495 
 496     case OPAL_EXISTS:
 497         return PMIX_EXISTS;
 498 
 499     case OPAL_ERR_PARTIAL_SUCCESS:
 500         return PMIX_QUERY_PARTIAL_SUCCESS;
 501 
 502     case OPAL_ERR_MODEL_DECLARED:
 503         return PMIX_MODEL_DECLARED;
 504 
 505     case OPAL_ERROR:
 506         return PMIX_ERROR;
 507     case OPAL_SUCCESS:
 508         return PMIX_SUCCESS;
 509 
 510     case OPAL_OPERATION_SUCCEEDED:
 511         return PMIX_OPERATION_SUCCEEDED;
 512 
 513     default:
 514         return rc;
 515     }
 516 }
 517 
 518 int pmix4x_convert_rc(pmix_status_t rc)
 519 {
 520     switch (rc) {
 521     case PMIX_ERR_DEBUGGER_RELEASE:
 522         return OPAL_ERR_DEBUGGER_RELEASE;
 523 
 524     case PMIX_EVENT_ACTION_COMPLETE:
 525         return OPAL_ERR_HANDLERS_COMPLETE;
 526 
 527     case PMIX_ERR_PROC_ABORTED:
 528         return OPAL_ERR_PROC_ABORTED;
 529 
 530     case PMIX_ERR_PROC_REQUESTED_ABORT:
 531         return OPAL_ERR_PROC_REQUESTED_ABORT;
 532 
 533     case PMIX_ERR_PROC_ABORTING:
 534         return OPAL_ERR_PROC_ABORTING;
 535 
 536     case PMIX_ERR_NODE_DOWN:
 537         return OPAL_ERR_NODE_DOWN;
 538 
 539     case PMIX_ERR_NODE_OFFLINE:
 540         return OPAL_ERR_NODE_OFFLINE;
 541 
 542     case PMIX_ERR_JOB_TERMINATED:
 543         return OPAL_ERR_JOB_TERMINATED;
 544 
 545     case PMIX_ERR_PROC_RESTART:
 546         return OPAL_ERR_PROC_RESTART;
 547 
 548     case PMIX_ERR_PROC_CHECKPOINT:
 549         return OPAL_ERR_PROC_CHECKPOINT;
 550 
 551     case PMIX_ERR_PROC_MIGRATE:
 552         return OPAL_ERR_PROC_MIGRATE;
 553 
 554     case PMIX_ERR_EVENT_REGISTRATION:
 555         return OPAL_ERR_EVENT_REGISTRATION;
 556 
 557     case PMIX_ERR_NOT_SUPPORTED:
 558         return OPAL_ERR_NOT_SUPPORTED;
 559 
 560     case PMIX_ERR_NOT_FOUND:
 561         return OPAL_ERR_NOT_FOUND;
 562 
 563     case PMIX_ERR_OUT_OF_RESOURCE:
 564         return OPAL_ERR_OUT_OF_RESOURCE;
 565 
 566     case PMIX_ERR_INIT:
 567         return OPAL_ERROR;
 568 
 569     case PMIX_ERR_BAD_PARAM:
 570         return OPAL_ERR_BAD_PARAM;
 571 
 572     case PMIX_ERR_UNREACH:
 573     case PMIX_ERR_NO_PERMISSIONS:
 574         return OPAL_ERR_UNREACH;
 575 
 576     case PMIX_ERR_TIMEOUT:
 577         return OPAL_ERR_TIMEOUT;
 578 
 579     case PMIX_ERR_WOULD_BLOCK:
 580         return OPAL_ERR_WOULD_BLOCK;
 581 
 582     case PMIX_ERR_LOST_CONNECTION_TO_SERVER:
 583     case PMIX_ERR_LOST_PEER_CONNECTION:
 584     case PMIX_ERR_LOST_CONNECTION_TO_CLIENT:
 585         return OPAL_ERR_COMM_FAILURE;
 586 
 587     case PMIX_EXISTS:
 588         return OPAL_EXISTS;
 589 
 590     case PMIX_QUERY_PARTIAL_SUCCESS:
 591         return OPAL_ERR_PARTIAL_SUCCESS;
 592 
 593     case PMIX_MONITOR_HEARTBEAT_ALERT:
 594         return OPAL_ERR_HEARTBEAT_ALERT;
 595 
 596     case PMIX_MONITOR_FILE_ALERT:
 597         return OPAL_ERR_FILE_ALERT;
 598 
 599     case PMIX_MODEL_DECLARED:
 600         return OPAL_ERR_MODEL_DECLARED;
 601 
 602     case PMIX_ERROR:
 603         return OPAL_ERROR;
 604     case PMIX_SUCCESS:
 605         return OPAL_SUCCESS;
 606 
 607     case PMIX_OPERATION_SUCCEEDED:
 608         return OPAL_OPERATION_SUCCEEDED;
 609 
 610     default:
 611         return rc;
 612     }
 613 }
 614 
 615 opal_pmix_scope_t pmix4x_convert_scope(pmix_scope_t scope)
 616 {
 617     switch(scope) {
 618         case PMIX_SCOPE_UNDEF:
 619             return OPAL_PMIX_SCOPE_UNDEF;
 620         case PMIX_LOCAL:
 621             return OPAL_PMIX_LOCAL;
 622         case PMIX_REMOTE:
 623             return OPAL_PMIX_REMOTE;
 624         case PMIX_GLOBAL:
 625             return OPAL_PMIX_GLOBAL;
 626         default:
 627             return OPAL_PMIX_SCOPE_UNDEF;
 628     }
 629 }
 630 
 631 pmix_scope_t pmix4x_convert_opalscope(opal_pmix_scope_t scope) {
 632     switch(scope) {
 633     case OPAL_PMIX_LOCAL:
 634         return PMIX_LOCAL;
 635     case OPAL_PMIX_REMOTE:
 636         return PMIX_REMOTE;
 637     case OPAL_PMIX_GLOBAL:
 638         return PMIX_GLOBAL;
 639     default:
 640         return PMIX_SCOPE_UNDEF;
 641     }
 642 }
 643 
 644 pmix_data_range_t pmix4x_convert_opalrange(opal_pmix_data_range_t range) {
 645     switch(range) {
 646     case OPAL_PMIX_RANGE_UNDEF:
 647         return PMIX_RANGE_UNDEF;
 648     case OPAL_PMIX_RANGE_LOCAL:
 649         return PMIX_RANGE_LOCAL;
 650     case OPAL_PMIX_RANGE_NAMESPACE:
 651         return PMIX_RANGE_NAMESPACE;
 652     case OPAL_PMIX_RANGE_SESSION:
 653         return PMIX_RANGE_SESSION;
 654     case OPAL_PMIX_RANGE_GLOBAL:
 655         return PMIX_RANGE_GLOBAL;
 656     case OPAL_PMIX_RANGE_CUSTOM:
 657         return PMIX_RANGE_CUSTOM;
 658     case OPAL_PMIX_RANGE_PROC_LOCAL:
 659         return PMIX_RANGE_PROC_LOCAL;
 660     default:
 661         return PMIX_SCOPE_UNDEF;
 662     }
 663 }
 664 
 665 opal_pmix_data_range_t pmix4x_convert_range(pmix_data_range_t range) {
 666     switch(range) {
 667     case PMIX_RANGE_UNDEF:
 668         return OPAL_PMIX_RANGE_UNDEF;
 669     case PMIX_RANGE_LOCAL:
 670         return OPAL_PMIX_RANGE_LOCAL;
 671     case PMIX_RANGE_NAMESPACE:
 672         return OPAL_PMIX_RANGE_NAMESPACE;
 673     case PMIX_RANGE_SESSION:
 674         return OPAL_PMIX_RANGE_SESSION;
 675     case PMIX_RANGE_GLOBAL:
 676         return OPAL_PMIX_RANGE_GLOBAL;
 677     case PMIX_RANGE_CUSTOM:
 678         return OPAL_PMIX_RANGE_CUSTOM;
 679     default:
 680         return OPAL_PMIX_RANGE_UNDEF;
 681     }
 682 }
 683 
 684 opal_pmix_persistence_t pmix4x_convert_persist(pmix_persistence_t persist)
 685 {
 686     switch(persist) {
 687         case PMIX_PERSIST_INDEF:
 688             return OPAL_PMIX_PERSIST_INDEF;
 689         case PMIX_PERSIST_FIRST_READ:
 690             return OPAL_PMIX_PERSIST_FIRST_READ;
 691         case PMIX_PERSIST_PROC:
 692             return OPAL_PMIX_PERSIST_PROC;
 693         case PMIX_PERSIST_APP:
 694             return OPAL_PMIX_PERSIST_APP;
 695         case PMIX_PERSIST_SESSION:
 696             return OPAL_PMIX_PERSIST_SESSION;
 697         default:
 698         return OPAL_PMIX_PERSIST_INDEF;
 699     }
 700 }
 701 
 702 pmix_persistence_t pmix4x_convert_opalpersist(opal_pmix_persistence_t persist)
 703 {
 704     switch(persist) {
 705         case OPAL_PMIX_PERSIST_INDEF:
 706             return PMIX_PERSIST_INDEF;
 707         case OPAL_PMIX_PERSIST_FIRST_READ:
 708             return PMIX_PERSIST_FIRST_READ;
 709         case OPAL_PMIX_PERSIST_PROC:
 710             return PMIX_PERSIST_PROC;
 711         case OPAL_PMIX_PERSIST_APP:
 712             return PMIX_PERSIST_APP;
 713         case OPAL_PMIX_PERSIST_SESSION:
 714             return PMIX_PERSIST_SESSION;
 715         default:
 716             return PMIX_PERSIST_INDEF;
 717     }
 718 }
 719 
 720 char* pmix4x_convert_jobid(opal_jobid_t jobid)
 721 {
 722     opal_pmix4x_jobid_trkr_t *jptr;
 723 
 724     /* look thru our list of jobids and find the
 725      * corresponding nspace */
 726     OPAL_LIST_FOREACH(jptr, &mca_pmix_pmix4x_component.jobids, opal_pmix4x_jobid_trkr_t) {
 727         if (jptr->jobid == jobid) {
 728             return jptr->nspace;
 729         }
 730     }
 731     return NULL;
 732 }
 733 
 734 /****   RHC: NEED TO ADD SUPPORT FOR NEW PMIX DATA TYPES, INCLUDING
 735  ****   CONVERSION OF PROC STATES    ****/
 736 
 737 void pmix4x_value_load(pmix_value_t *v,
 738                        opal_value_t *kv)
 739 {
 740     opal_pmix4x_jobid_trkr_t *job;
 741     bool found;
 742     opal_list_t *list;
 743     opal_value_t *val;
 744     pmix_info_t *info;
 745     size_t n;
 746 
 747     switch(kv->type) {
 748         case OPAL_UNDEF:
 749             v->type = PMIX_UNDEF;
 750             break;
 751         case OPAL_BOOL:
 752             v->type = PMIX_BOOL;
 753             memcpy(&(v->data.flag), &kv->data.flag, 1);
 754             break;
 755         case OPAL_BYTE:
 756             v->type = PMIX_BYTE;
 757             memcpy(&(v->data.byte), &kv->data.byte, 1);
 758             break;
 759         case OPAL_STRING:
 760             v->type = PMIX_STRING;
 761             if (NULL != kv->data.string) {
 762                 v->data.string = strdup(kv->data.string);
 763             } else {
 764                 v->data.string = NULL;
 765             }
 766             break;
 767         case OPAL_SIZE:
 768             v->type = PMIX_SIZE;
 769             memcpy(&(v->data.size), &kv->data.size, sizeof(size_t));
 770             break;
 771         case OPAL_PID:
 772             v->type = PMIX_PID;
 773             memcpy(&(v->data.pid), &kv->data.pid, sizeof(pid_t));
 774             break;
 775         case OPAL_INT:
 776             v->type = PMIX_INT;
 777             memcpy(&(v->data.integer), &kv->data.integer, sizeof(int));
 778             break;
 779         case OPAL_INT8:
 780             v->type = PMIX_INT8;
 781             memcpy(&(v->data.int8), &kv->data.int8, 1);
 782             break;
 783         case OPAL_INT16:
 784             v->type = PMIX_INT16;
 785             memcpy(&(v->data.int16), &kv->data.int16, 2);
 786             break;
 787         case OPAL_INT32:
 788             v->type = PMIX_INT32;
 789             memcpy(&(v->data.int32), &kv->data.int32, 4);
 790             break;
 791         case OPAL_INT64:
 792             v->type = PMIX_INT64;
 793             memcpy(&(v->data.int64), &kv->data.int64, 8);
 794             break;
 795         case OPAL_UINT:
 796             v->type = PMIX_UINT;
 797             memcpy(&(v->data.uint), &kv->data.uint, sizeof(int));
 798             break;
 799         case OPAL_UINT8:
 800             v->type = PMIX_UINT8;
 801             memcpy(&(v->data.uint8), &kv->data.uint8, 1);
 802             break;
 803         case OPAL_UINT16:
 804             v->type = PMIX_UINT16;
 805             memcpy(&(v->data.uint16), &kv->data.uint16, 2);
 806             break;
 807         case OPAL_UINT32:
 808             v->type = PMIX_UINT32;
 809             memcpy(&(v->data.uint32), &kv->data.uint32, 4);
 810             break;
 811         case OPAL_UINT64:
 812             v->type = PMIX_UINT64;
 813             memcpy(&(v->data.uint64), &kv->data.uint64, 8);
 814             break;
 815         case OPAL_FLOAT:
 816             v->type = PMIX_FLOAT;
 817             memcpy(&(v->data.fval), &kv->data.fval, sizeof(float));
 818             break;
 819         case OPAL_DOUBLE:
 820             v->type = PMIX_DOUBLE;
 821             memcpy(&(v->data.dval), &kv->data.dval, sizeof(double));
 822             break;
 823         case OPAL_TIMEVAL:
 824             v->type = PMIX_TIMEVAL;
 825             memcpy(&(v->data.tv), &kv->data.tv, sizeof(struct timeval));
 826             break;
 827         case OPAL_TIME:
 828             v->type = PMIX_TIME;
 829             memcpy(&(v->data.time), &kv->data.time, sizeof(time_t));
 830             break;
 831         case OPAL_STATUS:
 832             v->type = PMIX_STATUS;
 833             v->data.status = pmix4x_convert_opalrc(kv->data.status);
 834             break;
 835         case OPAL_VPID:
 836             v->type = PMIX_PROC_RANK;
 837             v->data.rank = pmix4x_convert_opalrank(kv->data.name.vpid);
 838             break;
 839         case OPAL_NAME:
 840             v->type = PMIX_PROC;
 841             /* have to stringify the jobid */
 842             PMIX_PROC_CREATE(v->data.proc, 1);
 843             /* see if this job is in our list of known nspaces */
 844             found = false;
 845             OPAL_LIST_FOREACH(job, &mca_pmix_pmix4x_component.jobids, opal_pmix4x_jobid_trkr_t) {
 846                 if (job->jobid == kv->data.name.jobid) {
 847                     (void)strncpy(v->data.proc->nspace, job->nspace, PMIX_MAX_NSLEN);
 848                     found = true;
 849                     break;
 850                 }
 851             }
 852             if (!found) {
 853                 (void)opal_snprintf_jobid(v->data.proc->nspace, PMIX_MAX_NSLEN, kv->data.name.jobid);
 854             }
 855             v->data.proc->rank = pmix4x_convert_opalrank(kv->data.name.vpid);
 856             break;
 857         case OPAL_BYTE_OBJECT:
 858             v->type = PMIX_BYTE_OBJECT;
 859             if (NULL != kv->data.bo.bytes) {
 860                 v->data.bo.bytes = (char*)malloc(kv->data.bo.size);
 861                 memcpy(v->data.bo.bytes, kv->data.bo.bytes, kv->data.bo.size);
 862                 v->data.bo.size = (size_t)kv->data.bo.size;
 863             } else {
 864                 v->data.bo.bytes = NULL;
 865                 v->data.bo.size = 0;
 866             }
 867             break;
 868         case OPAL_PERSIST:
 869             v->type = PMIX_PERSIST;
 870             v->data.persist = pmix4x_convert_opalpersist((opal_pmix_persistence_t)kv->data.uint8);
 871             break;
 872         case OPAL_SCOPE:
 873             v->type = PMIX_SCOPE;
 874             v->data.scope = pmix4x_convert_opalscope((opal_pmix_scope_t)kv->data.uint8);
 875             break;
 876         case OPAL_DATA_RANGE:
 877             v->type = PMIX_DATA_RANGE;
 878             v->data.range = pmix4x_convert_opalrange((opal_pmix_data_range_t)kv->data.uint8);
 879             break;
 880         case OPAL_PROC_STATE:
 881             v->type = PMIX_PROC_STATE;
 882             /* the OPAL layer doesn't have any concept of proc state,
 883              * so the ORTE layer is responsible for converting it */
 884             memcpy(&v->data.state, &kv->data.uint8, sizeof(uint8_t));
 885             break;
 886         case OPAL_PTR:
 887             /* if the opal_value_t is passing a true pointer, then
 888              * respect that request and pass it along */
 889             if (0 == strcmp(kv->key, OPAL_PMIX_EVENT_RETURN_OBJECT)) {
 890                 v->type = PMIX_POINTER;
 891                 v->data.ptr = kv->data.ptr;
 892                 break;
 893             }
 894             /* otherwise, it must be to a list of
 895              * opal_value_t's that we need to convert to a pmix_data_array
 896              * of pmix_info_t structures */
 897             list = (opal_list_t*)kv->data.ptr;
 898             v->type = PMIX_DATA_ARRAY;
 899             v->data.darray = (pmix_data_array_t*)malloc(sizeof(pmix_data_array_t));
 900             v->data.darray->type = PMIX_INFO;
 901             v->data.darray->size = opal_list_get_size(list);
 902             if (0 < v->data.darray->size) {
 903                 PMIX_INFO_CREATE(info, v->data.darray->size);
 904                 v->data.darray->array = info;
 905                 n=0;
 906                 OPAL_LIST_FOREACH(val, list, opal_value_t) {
 907                     if (NULL != val->key) {
 908                         (void)strncpy(info[n].key, val->key, PMIX_MAX_KEYLEN);
 909                     }
 910                     pmix4x_value_load(&info[n].value, val);
 911                     ++n;
 912                 }
 913             } else {
 914                 v->data.darray->array = NULL;
 915             }
 916             break;
 917         case OPAL_PROC_INFO:
 918             v->type = PMIX_PROC_INFO;
 919             PMIX_PROC_INFO_CREATE(v->data.pinfo, 1);
 920             /* see if this job is in our list of known nspaces */
 921             found = false;
 922             OPAL_LIST_FOREACH(job, &mca_pmix_pmix4x_component.jobids, opal_pmix4x_jobid_trkr_t) {
 923                 if (job->jobid == kv->data.pinfo.name.jobid) {
 924                     (void)strncpy(v->data.pinfo->proc.nspace, job->nspace, PMIX_MAX_NSLEN);
 925                     found = true;
 926                     break;
 927                 }
 928             }
 929             if (!found) {
 930                 (void)opal_snprintf_jobid(v->data.pinfo->proc.nspace, PMIX_MAX_NSLEN, kv->data.pinfo.name.jobid);
 931             }
 932             v->data.pinfo->proc.rank = pmix4x_convert_opalrank(kv->data.pinfo.name.vpid);
 933             if (NULL != kv->data.pinfo.hostname) {
 934                 v->data.pinfo->hostname = strdup(kv->data.pinfo.hostname);
 935             }
 936             if (NULL != kv->data.pinfo.executable_name) {
 937                 v->data.pinfo->executable_name = strdup(kv->data.pinfo.executable_name);
 938             }
 939             v->data.pinfo->pid = kv->data.pinfo.pid;
 940             v->data.pinfo->exit_code = kv->data.pinfo.exit_code;
 941             v->data.pinfo->state = pmix4x_convert_opalstate(kv->data.pinfo.state);
 942             break;
 943         case OPAL_ENVAR:
 944             v->type = PMIX_ENVAR;
 945             PMIX_ENVAR_CONSTRUCT(&v->data.envar);
 946             if (NULL != kv->data.envar.envar) {
 947                 v->data.envar.envar = strdup(kv->data.envar.envar);
 948             }
 949             if (NULL != kv->data.envar.value) {
 950                 v->data.envar.value = strdup(kv->data.envar.value);
 951             }
 952             v->data.envar.separator = kv->data.envar.separator;
 953             break;
 954         default:
 955             /* silence warnings */
 956             break;
 957     }
 958 }
 959 
 960 int pmix4x_value_unload(opal_value_t *kv,
 961                         const pmix_value_t *v)
 962 {
 963     int rc=OPAL_SUCCESS;
 964     bool found;
 965     opal_pmix4x_jobid_trkr_t *job;
 966     opal_list_t *lt;
 967     opal_value_t *ival;
 968     size_t n;
 969 
 970     switch(v->type) {
 971     case PMIX_UNDEF:
 972         kv->type = OPAL_UNDEF;
 973         break;
 974     case PMIX_BOOL:
 975         kv->type = OPAL_BOOL;
 976         memcpy(&kv->data.flag, &(v->data.flag), 1);
 977         break;
 978     case PMIX_BYTE:
 979         kv->type = OPAL_BYTE;
 980         memcpy(&kv->data.byte, &(v->data.byte), 1);
 981         break;
 982     case PMIX_STRING:
 983         kv->type = OPAL_STRING;
 984         if (NULL != v->data.string) {
 985             kv->data.string = strdup(v->data.string);
 986         }
 987         break;
 988     case PMIX_SIZE:
 989         kv->type = OPAL_SIZE;
 990         memcpy(&kv->data.size, &(v->data.size), sizeof(size_t));
 991         break;
 992     case PMIX_PID:
 993         kv->type = OPAL_PID;
 994         memcpy(&kv->data.pid, &(v->data.pid), sizeof(pid_t));
 995         break;
 996     case PMIX_INT:
 997         kv->type = OPAL_INT;
 998         memcpy(&kv->data.integer, &(v->data.integer), sizeof(int));
 999         break;
1000     case PMIX_INT8:
1001         kv->type = OPAL_INT8;
1002         memcpy(&kv->data.int8, &(v->data.int8), 1);
1003         break;
1004     case PMIX_INT16:
1005         kv->type = OPAL_INT16;
1006         memcpy(&kv->data.int16, &(v->data.int16), 2);
1007         break;
1008     case PMIX_INT32:
1009         kv->type = OPAL_INT32;
1010         memcpy(&kv->data.int32, &(v->data.int32), 4);
1011         break;
1012     case PMIX_INT64:
1013         kv->type = OPAL_INT64;
1014         memcpy(&kv->data.int64, &(v->data.int64), 8);
1015         break;
1016     case PMIX_UINT:
1017         kv->type = OPAL_UINT;
1018         memcpy(&kv->data.uint, &(v->data.uint), sizeof(int));
1019         break;
1020     case PMIX_UINT8:
1021         kv->type = OPAL_UINT8;
1022         memcpy(&kv->data.uint8, &(v->data.uint8), 1);
1023         break;
1024     case PMIX_UINT16:
1025         kv->type = OPAL_UINT16;
1026         memcpy(&kv->data.uint16, &(v->data.uint16), 2);
1027         break;
1028     case PMIX_UINT32:
1029         kv->type = OPAL_UINT32;
1030         memcpy(&kv->data.uint32, &(v->data.uint32), 4);
1031         break;
1032     case PMIX_UINT64:
1033         kv->type = OPAL_UINT64;
1034         memcpy(&kv->data.uint64, &(v->data.uint64), 8);
1035         break;
1036     case PMIX_FLOAT:
1037         kv->type = OPAL_FLOAT;
1038         memcpy(&kv->data.fval, &(v->data.fval), sizeof(float));
1039         break;
1040     case PMIX_DOUBLE:
1041         kv->type = OPAL_DOUBLE;
1042         memcpy(&kv->data.dval, &(v->data.dval), sizeof(double));
1043         break;
1044     case PMIX_TIMEVAL:
1045         kv->type = OPAL_TIMEVAL;
1046         memcpy(&kv->data.tv, &(v->data.tv), sizeof(struct timeval));
1047         break;
1048     case PMIX_TIME:
1049         kv->type = OPAL_TIME;
1050         memcpy(&kv->data.time, &(v->data.time), sizeof(time_t));
1051         break;
1052     case PMIX_STATUS:
1053         kv->type = OPAL_STATUS;
1054         kv->data.status = pmix4x_convert_rc(v->data.status);
1055         break;
1056     case PMIX_VALUE:
1057         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1058         rc = OPAL_ERR_NOT_SUPPORTED;
1059         break;
1060     case PMIX_PROC:
1061         kv->type = OPAL_NAME;
1062         /* see if this job is in our list of known nspaces */
1063         found = false;
1064         OPAL_LIST_FOREACH(job, &mca_pmix_pmix4x_component.jobids, opal_pmix4x_jobid_trkr_t) {
1065             if (0 == strncmp(job->nspace, v->data.proc->nspace, PMIX_MAX_NSLEN)) {
1066                 kv->data.name.jobid = job->jobid;
1067                 found = true;
1068                 break;
1069             }
1070         }
1071         if (!found) {
1072             if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&kv->data.name.jobid, v->data.proc->nspace))) {
1073                 return pmix4x_convert_opalrc(rc);
1074             }
1075         }
1076         kv->data.name.vpid = pmix4x_convert_rank(v->data.proc->rank);
1077         break;
1078     case PMIX_APP:
1079         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1080         rc = OPAL_ERR_NOT_SUPPORTED;
1081         break;
1082     case PMIX_INFO:
1083         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1084         rc = OPAL_ERR_NOT_SUPPORTED;
1085         break;
1086     case PMIX_PDATA:
1087         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1088         rc = OPAL_ERR_NOT_SUPPORTED;
1089         break;
1090     case PMIX_BUFFER:
1091     OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1092     rc = OPAL_ERR_NOT_SUPPORTED;
1093     break;
1094     case PMIX_BYTE_OBJECT:
1095         kv->type = OPAL_BYTE_OBJECT;
1096         if (NULL != v->data.bo.bytes && 0 < v->data.bo.size) {
1097             kv->data.bo.bytes = (uint8_t*)malloc(v->data.bo.size);
1098             memcpy(kv->data.bo.bytes, v->data.bo.bytes, v->data.bo.size);
1099             kv->data.bo.size = (int)v->data.bo.size;
1100         } else {
1101             kv->data.bo.bytes = NULL;
1102             kv->data.bo.size = 0;
1103         }
1104         break;
1105     case PMIX_KVAL:
1106         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1107         rc = OPAL_ERR_NOT_SUPPORTED;
1108         break;
1109     case PMIX_PERSIST:
1110         kv->type = OPAL_PERSIST;
1111         kv->data.uint8 = pmix4x_convert_persist(v->data.persist);
1112         break;
1113     case PMIX_POINTER:
1114         kv->type = OPAL_PTR;
1115         kv->data.ptr = v->data.ptr;
1116         break;
1117     case PMIX_SCOPE:
1118         kv->type = OPAL_SCOPE;
1119         kv->data.uint8 = pmix4x_convert_scope(v->data.scope);
1120         break;
1121     case PMIX_DATA_RANGE:
1122         kv->type = OPAL_DATA_RANGE;
1123         kv->data.uint8 = pmix4x_convert_range(v->data.range);
1124         break;
1125     case PMIX_COMMAND:
1126         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1127         rc = OPAL_ERR_NOT_SUPPORTED;
1128         break;
1129     case PMIX_INFO_DIRECTIVES:
1130         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1131         rc = OPAL_ERR_NOT_SUPPORTED;
1132         break;
1133     case PMIX_DATA_TYPE:
1134         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1135         rc = OPAL_ERR_NOT_SUPPORTED;
1136         break;
1137     case PMIX_PROC_STATE:
1138         kv->type = OPAL_PROC_STATE;
1139         /* the OPAL layer doesn't have any concept of proc state,
1140          * so the ORTE layer is responsible for converting it */
1141         memcpy(&kv->data.uint8, &v->data.state, sizeof(uint8_t));
1142         break;
1143     case PMIX_PROC_INFO:
1144         kv->type = OPAL_PROC_INFO;
1145         if (NULL == v->data.pinfo) {
1146             rc = OPAL_ERR_BAD_PARAM;
1147             break;
1148         }
1149         /* see if this job is in our list of known nspaces */
1150         found = false;
1151         OPAL_LIST_FOREACH(job, &mca_pmix_pmix4x_component.jobids, opal_pmix4x_jobid_trkr_t) {
1152             if (0 == strncmp(job->nspace, v->data.pinfo->proc.nspace, PMIX_MAX_NSLEN)) {
1153                 kv->data.pinfo.name.jobid = job->jobid;
1154                 found = true;
1155                 break;
1156             }
1157         }
1158         if (!found) {
1159             if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&kv->data.pinfo.name.jobid, v->data.pinfo->proc.nspace))) {
1160                 return pmix4x_convert_opalrc(rc);
1161             }
1162         }
1163         kv->data.pinfo.name.vpid = pmix4x_convert_rank(v->data.pinfo->proc.rank);
1164         if (NULL != v->data.pinfo->hostname) {
1165             kv->data.pinfo.hostname = strdup(v->data.pinfo->hostname);
1166         }
1167         if (NULL != v->data.pinfo->executable_name) {
1168             kv->data.pinfo.executable_name = strdup(v->data.pinfo->executable_name);
1169         }
1170         kv->data.pinfo.pid = v->data.pinfo->pid;
1171         kv->data.pinfo.exit_code = v->data.pinfo->exit_code;
1172         kv->data.pinfo.state = pmix4x_convert_state(v->data.pinfo->state);
1173         break;
1174     case PMIX_DATA_ARRAY:
1175         if (NULL == v->data.darray || NULL == v->data.darray->array) {
1176             kv->data.ptr = NULL;
1177             break;
1178         }
1179         lt = OBJ_NEW(opal_list_t);
1180         kv->type = OPAL_PTR;
1181         kv->data.ptr = (void*)lt;
1182         for (n=0; n < v->data.darray->size; n++) {
1183             ival = OBJ_NEW(opal_value_t);
1184             opal_list_append(lt, &ival->super);
1185             /* handle the various types */
1186             if (PMIX_INFO == v->data.darray->type) {
1187                 pmix_info_t *iptr = (pmix_info_t*)v->data.darray->array;
1188                 if (NULL == iptr) {
1189                     rc = OPAL_ERR_BAD_PARAM;
1190                     break;
1191                 }
1192                 ival->key = strdup(iptr[n].key);
1193                 rc = pmix4x_value_unload(ival, &iptr[n].value);
1194                 if (OPAL_SUCCESS != rc) {
1195                     OPAL_LIST_RELEASE(lt);
1196                     kv->type = OPAL_UNDEF;
1197                     kv->data.ptr = NULL;
1198                     break;
1199                 }
1200             }
1201         }
1202         break;
1203     case PMIX_PROC_RANK:
1204         kv->type = OPAL_VPID;
1205         kv->data.name.vpid = pmix4x_convert_rank(v->data.rank);
1206         break;
1207     case PMIX_QUERY:
1208         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1209         rc = OPAL_ERR_NOT_SUPPORTED;
1210         break;
1211     case PMIX_COMPRESSED_STRING:
1212         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1213         rc = OPAL_ERR_NOT_SUPPORTED;
1214         break;
1215     case PMIX_ALLOC_DIRECTIVE:
1216         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1217         rc = OPAL_ERR_NOT_SUPPORTED;
1218         break;
1219     case PMIX_IOF_CHANNEL:
1220         OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
1221         rc = OPAL_ERR_NOT_SUPPORTED;
1222         break;
1223     case PMIX_ENVAR:
1224         kv->type = OPAL_ENVAR;
1225         OBJ_CONSTRUCT(&kv->data.envar, opal_envar_t);
1226         if (NULL != v->data.envar.envar) {
1227             kv->data.envar.envar = strdup(v->data.envar.envar);
1228         }
1229         if (NULL != v->data.envar.value) {
1230             kv->data.envar.value = strdup(v->data.envar.value);
1231         }
1232         kv->data.envar.separator = v->data.envar.separator;
1233         break;
1234     default:
1235         /* silence warnings */
1236         rc = OPAL_ERROR;
1237         break;
1238     }
1239     return rc;
1240 }
1241 
1242 static void errreg_cbfunc (pmix_status_t status,
1243                            size_t errhandler_ref,
1244                            void *cbdata)
1245 {
1246     pmix4x_opcaddy_t *op = (pmix4x_opcaddy_t*)cbdata;
1247 
1248     OPAL_ACQUIRE_OBJECT(op);
1249     op->event->index = errhandler_ref;
1250     opal_output_verbose(5, opal_pmix_base_framework.framework_output,
1251                         "PMIX2x errreg_cbfunc - error handler registered status=%d, reference=%lu",
1252                         status, (unsigned long)errhandler_ref);
1253     if (NULL != op->evregcbfunc) {
1254         op->evregcbfunc(pmix4x_convert_rc(status), errhandler_ref, op->cbdata);
1255     }
1256     OBJ_RELEASE(op);
1257 }
1258 
1259 static void register_handler(opal_list_t *event_codes,
1260                              opal_list_t *info,
1261                              opal_pmix_notification_fn_t evhandler,
1262                              opal_pmix_evhandler_reg_cbfunc_t cbfunc,
1263                              void *cbdata)
1264 {
1265     pmix4x_opcaddy_t *op = (pmix4x_opcaddy_t*)cbdata;
1266     size_t n;
1267     opal_value_t *kv;
1268 
1269     OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
1270     if (0 >= opal_pmix_base.initialized) {
1271         OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1272         if (NULL != cbfunc) {
1273             cbfunc(OPAL_ERR_NOT_INITIALIZED, 0, cbdata);
1274         }
1275         return;
1276     }
1277 
1278     op = OBJ_NEW(pmix4x_opcaddy_t);
1279     op->evregcbfunc = cbfunc;
1280     op->cbdata = cbdata;
1281 
1282     /* convert the event codes */
1283     if (NULL != event_codes) {
1284         op->ncodes = opal_list_get_size(event_codes);
1285         op->pcodes = (pmix_status_t*)malloc(op->ncodes * sizeof(pmix_status_t));
1286         n=0;
1287         OPAL_LIST_FOREACH(kv, event_codes, opal_value_t) {
1288             op->pcodes[n] = pmix4x_convert_opalrc(kv->data.integer);
1289             ++n;
1290         }
1291     }
1292 
1293     /* convert the list of info to an array of pmix_info_t */
1294     if (NULL != info && 0 < (op->ninfo = opal_list_get_size(info))) {
1295         PMIX_INFO_CREATE(op->info, op->ninfo);
1296         n=0;
1297         OPAL_LIST_FOREACH(kv, info, opal_value_t) {
1298             (void)strncpy(op->info[n].key, kv->key, PMIX_MAX_KEYLEN);
1299             pmix4x_value_load(&op->info[n].value, kv);
1300             ++n;
1301         }
1302     }
1303 
1304     /* register the event */
1305     op->event = OBJ_NEW(opal_pmix4x_event_t);
1306     op->event->handler = evhandler;
1307     opal_list_append(&mca_pmix_pmix4x_component.events, &op->event->super);
1308     OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1309 
1310     PMIx_Register_event_handler(op->pcodes, op->ncodes,
1311                                 op->info, op->ninfo,
1312                                 pmix4x_event_hdlr, errreg_cbfunc, op);
1313     return;
1314 }
1315 
1316 static void deregister_handler(size_t evhandler,
1317                                opal_pmix_op_cbfunc_t cbfunc,
1318                                void *cbdata)
1319 {
1320     pmix4x_opcaddy_t *op;
1321     opal_pmix4x_event_t *event;
1322 
1323     OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
1324     if (0 >= opal_pmix_base.initialized) {
1325         OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1326         if (NULL != cbfunc) {
1327             cbfunc(OPAL_ERR_NOT_INITIALIZED, cbdata);
1328         }
1329         return;
1330     }
1331 
1332     /* look for this event */
1333     OPAL_LIST_FOREACH(event, &mca_pmix_pmix4x_component.events, opal_pmix4x_event_t) {
1334         if (evhandler == event->index) {
1335             opal_list_remove_item(&mca_pmix_pmix4x_component.events, &event->super);
1336             OBJ_RELEASE(event);
1337             break;
1338         }
1339     }
1340 
1341     OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1342 
1343     op = OBJ_NEW(pmix4x_opcaddy_t);
1344     op->opcbfunc = cbfunc;
1345     op->cbdata = cbdata;
1346 
1347     /* tell the library to deregister this handler */
1348     PMIx_Deregister_event_handler(evhandler, opcbfunc, op);
1349     return;
1350 }
1351 
1352 static void notify_complete(pmix_status_t status, void *cbdata)
1353 {
1354     pmix4x_opcaddy_t *op = (pmix4x_opcaddy_t*)cbdata;
1355     if (NULL != op->opcbfunc) {
1356         op->opcbfunc(pmix4x_convert_rc(status), op->cbdata);
1357     }
1358     OBJ_RELEASE(op);
1359 }
1360 
1361 static int notify_event(int status,
1362                         const opal_process_name_t *source,
1363                         opal_pmix_data_range_t range,
1364                         opal_list_t *info,
1365                         opal_pmix_op_cbfunc_t cbfunc, void *cbdata)
1366 {
1367     pmix4x_opcaddy_t *op;
1368     opal_value_t *kv;
1369     pmix_proc_t p, *pptr;
1370     pmix_status_t pstatus;
1371     size_t n;
1372     pmix_data_range_t prange;
1373     char *nsptr;
1374 
1375     OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
1376     if (0 >= opal_pmix_base.initialized) {
1377         OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1378         return OPAL_ERR_NOT_INITIALIZED;
1379     }
1380 
1381     op = OBJ_NEW(pmix4x_opcaddy_t);
1382     op->opcbfunc = cbfunc;
1383     op->cbdata = cbdata;
1384 
1385     /* convert the status */
1386     pstatus = pmix4x_convert_opalrc(status);
1387 
1388     /* convert the source */
1389     if (NULL == source) {
1390         pptr = NULL;
1391     } else {
1392         if (NULL == (nsptr = pmix4x_convert_jobid(source->jobid))) {
1393             OBJ_RELEASE(op);
1394             OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1395             return OPAL_ERR_NOT_FOUND;
1396         }
1397         (void)strncpy(p.nspace, nsptr, PMIX_MAX_NSLEN);
1398         p.rank = pmix4x_convert_opalrank(source->vpid);
1399         pptr = &p;
1400     }
1401     OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1402 
1403     /* convert the range */
1404     prange = pmix4x_convert_opalrange(range);
1405 
1406     /* convert the list of info */
1407     if (NULL != info && 0 < (op->ninfo = opal_list_get_size(info))) {
1408         PMIX_INFO_CREATE(op->info, op->ninfo);
1409         n=0;
1410         OPAL_LIST_FOREACH(kv, info, opal_value_t) {
1411             (void)strncpy(op->info[n].key, kv->key, PMIX_MAX_KEYLEN);
1412             /* little dicey here as we need to convert a status, if
1413              * provided, and it will be an int coming down to us */
1414             if (0 == strcmp(kv->key, OPAL_PMIX_JOB_TERM_STATUS)) {
1415                 op->info[n].value.type = PMIX_STATUS;
1416                 op->info[n].value.data.status = pmix4x_convert_opalrc(kv->data.integer);
1417             } else {
1418                 pmix4x_value_load(&op->info[n].value, kv);
1419             }
1420             ++n;
1421         }
1422     }
1423 
1424     /* ask the library to notify our clients */
1425     pstatus = PMIx_Notify_event(pstatus, pptr, prange, op->info, op->ninfo, notify_complete, op);
1426 
1427     return pmix4x_convert_rc(pstatus);
1428 }
1429 
1430 static void relcbfunc(void *cbdata)
1431 {
1432     opal_list_t *results = (opal_list_t*)cbdata;
1433     if (NULL != results) {
1434         OPAL_LIST_RELEASE(results);
1435     }
1436 }
1437 
1438 static void infocbfunc(pmix_status_t status,
1439                        pmix_info_t *info, size_t ninfo,
1440                        void *cbdata,
1441                        pmix_release_cbfunc_t release_fn,
1442                        void *release_cbdata)
1443 {
1444     pmix4x_opcaddy_t *cd = (pmix4x_opcaddy_t*)cbdata;
1445     int rc = OPAL_SUCCESS;
1446     opal_list_t *results = NULL;
1447     opal_value_t *iptr;
1448     size_t n;
1449 
1450     OPAL_ACQUIRE_OBJECT(cd);
1451 
1452     /* convert the array of pmix_info_t to the list of info */
1453     if (NULL != info) {
1454         results = OBJ_NEW(opal_list_t);
1455         for (n=0; n < ninfo; n++) {
1456             iptr = OBJ_NEW(opal_value_t);
1457             opal_list_append(results, &iptr->super);
1458             iptr->key = strdup(info[n].key);
1459             if (OPAL_SUCCESS != (rc = pmix4x_value_unload(iptr, &info[n].value))) {
1460                 OPAL_ERROR_LOG(rc);
1461                 OPAL_LIST_RELEASE(results);
1462                 results = NULL;
1463                 break;
1464             }
1465         }
1466     }
1467 
1468     if (NULL != release_fn) {
1469         release_fn(release_cbdata);
1470     }
1471 
1472     /* return the values to the original requestor */
1473     if (NULL != cd->qcbfunc) {
1474         cd->qcbfunc(rc, results, cd->cbdata, relcbfunc, results);
1475     }
1476     OBJ_RELEASE(cd);
1477 }
1478 
1479 static void pmix4x_query(opal_list_t *queries,
1480                          opal_pmix_info_cbfunc_t cbfunc, void *cbdata)
1481 {
1482     int rc;
1483     opal_value_t *ival;
1484     size_t n, nqueries, nq;
1485     pmix4x_opcaddy_t *cd;
1486     pmix_status_t prc;
1487     opal_pmix_query_t *q;
1488 
1489     OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
1490     if (0 >= opal_pmix_base.initialized) {
1491         OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1492         if (NULL != cbfunc) {
1493             cbfunc(OPAL_ERR_NOT_INITIALIZED, NULL, cbdata, NULL, NULL);
1494         }
1495         return;
1496     }
1497     OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1498 
1499     /* create the caddy */
1500     cd = OBJ_NEW(pmix4x_opcaddy_t);
1501 
1502     /* bozo check */
1503     if (NULL == queries || 0 == (nqueries = opal_list_get_size(queries))) {
1504         rc = OPAL_ERR_BAD_PARAM;
1505         goto CLEANUP;
1506     }
1507 
1508     /* setup the operation */
1509     cd->qcbfunc = cbfunc;
1510     cd->cbdata = cbdata;
1511     cd->nqueries = nqueries;
1512 
1513     /* convert the list to an array of query objects */
1514     PMIX_QUERY_CREATE(cd->queries, cd->nqueries);
1515     n=0;
1516     OPAL_LIST_FOREACH(q, queries, opal_pmix_query_t) {
1517         cd->queries[n].keys = opal_argv_copy(q->keys);
1518         cd->queries[n].nqual = opal_list_get_size(&q->qualifiers);
1519         if (0 < cd->queries[n].nqual) {
1520             PMIX_INFO_CREATE(cd->queries[n].qualifiers, cd->queries[n].nqual);
1521             nq = 0;
1522             OPAL_LIST_FOREACH(ival, &q->qualifiers, opal_value_t) {
1523                 (void)strncpy(cd->queries[n].qualifiers[nq].key, ival->key, PMIX_MAX_KEYLEN);
1524                 pmix4x_value_load(&cd->queries[n].qualifiers[nq].value, ival);
1525                 ++nq;
1526             }
1527         }
1528         ++n;
1529     }
1530 
1531     /* pass it down */
1532     if (PMIX_SUCCESS != (prc = PMIx_Query_info_nb(cd->queries, cd->nqueries,
1533                                                   infocbfunc, cd))) {
1534         /* do not hang! */
1535         rc = pmix4x_convert_rc(prc);
1536         goto CLEANUP;
1537     }
1538 
1539     return;
1540 
1541   CLEANUP:
1542     if (NULL != cbfunc) {
1543         cbfunc(rc, NULL, cbdata, NULL, NULL);
1544     }
1545     OBJ_RELEASE(cd);
1546     return;
1547 }
1548 
1549 static void pmix4x_log(opal_list_t *info,
1550                        opal_pmix_op_cbfunc_t cbfunc, void *cbdata)
1551 {
1552     int rc;
1553     opal_value_t *ival;
1554     size_t n, ninfo;
1555     pmix4x_opcaddy_t *cd;
1556     pmix_status_t prc;
1557 
1558     OPAL_PMIX_ACQUIRE_THREAD(&opal_pmix_base.lock);
1559     if (0 >= opal_pmix_base.initialized) {
1560         OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1561         if (NULL != cbfunc) {
1562             cbfunc(OPAL_ERR_NOT_INITIALIZED, cbdata);
1563         }
1564         return;
1565     }
1566     OPAL_PMIX_RELEASE_THREAD(&opal_pmix_base.lock);
1567 
1568     /* create the caddy */
1569     cd = OBJ_NEW(pmix4x_opcaddy_t);
1570 
1571     /* bozo check */
1572     if (NULL == info || 0 == (ninfo = opal_list_get_size(info))) {
1573         rc = OPAL_ERR_BAD_PARAM;
1574         goto CLEANUP;
1575     }
1576 
1577     /* setup the operation */
1578     cd->opcbfunc = cbfunc;
1579     cd->cbdata = cbdata;
1580     cd->ninfo = ninfo;
1581 
1582     /* convert the list to an array of info objects */
1583     PMIX_INFO_CREATE(cd->info, cd->ninfo);
1584     n=0;
1585     OPAL_LIST_FOREACH(ival, info, opal_value_t) {
1586         (void)strncpy(cd->info[n].key, ival->key, PMIX_MAX_KEYLEN);
1587         pmix4x_value_load(&cd->info[n].value, ival);
1588         ++n;
1589     }
1590 
1591     /* pass it down */
1592     if (PMIX_SUCCESS != (prc = PMIx_Log_nb(cd->info, cd->ninfo, NULL, 0,
1593                                            opcbfunc, cd))) {
1594         /* do not hang! */
1595         rc = pmix4x_convert_rc(prc);
1596         goto CLEANUP;
1597     }
1598 
1599     return;
1600 
1601   CLEANUP:
1602     if (NULL != cbfunc) {
1603         cbfunc(rc, cbdata);
1604     }
1605     OBJ_RELEASE(cd);
1606 }
1607 
1608 opal_pmix_alloc_directive_t pmix4x_convert_allocdir(pmix_alloc_directive_t dir)
1609 {
1610     switch (dir) {
1611         case PMIX_ALLOC_NEW:
1612             return OPAL_PMIX_ALLOC_NEW;
1613         case PMIX_ALLOC_EXTEND:
1614             return OPAL_PMIX_ALLOC_EXTEND;
1615         case PMIX_ALLOC_RELEASE:
1616             return OPAL_PMIX_ALLOC_RELEASE;
1617         case PMIX_ALLOC_REAQUIRE:
1618             return OPAL_PMIX_ALLOC_REAQCUIRE;
1619         default:
1620             return OPAL_PMIX_ALLOC_UNDEF;
1621     }
1622 }
1623 
1624 int pmix4x_convert_state(pmix_proc_state_t state)
1625 {
1626     switch(state) {
1627         case PMIX_PROC_STATE_UNDEF:
1628             return 0;
1629         case PMIX_PROC_STATE_PREPPED:
1630         case PMIX_PROC_STATE_LAUNCH_UNDERWAY:
1631             return 1;
1632         case PMIX_PROC_STATE_RESTART:
1633             return 2;
1634         case PMIX_PROC_STATE_TERMINATE:
1635             return 3;
1636         case PMIX_PROC_STATE_RUNNING:
1637             return 4;
1638         case PMIX_PROC_STATE_CONNECTED:
1639             return 5;
1640         case PMIX_PROC_STATE_UNTERMINATED:
1641             return 15;
1642         case PMIX_PROC_STATE_TERMINATED:
1643             return 20;
1644         case PMIX_PROC_STATE_KILLED_BY_CMD:
1645             return 51;
1646         case PMIX_PROC_STATE_ABORTED:
1647             return 52;
1648         case PMIX_PROC_STATE_FAILED_TO_START:
1649             return 53;
1650         case PMIX_PROC_STATE_ABORTED_BY_SIG:
1651             return 54;
1652         case PMIX_PROC_STATE_TERM_WO_SYNC:
1653             return 55;
1654         case PMIX_PROC_STATE_COMM_FAILED:
1655             return 56;
1656         case PMIX_PROC_STATE_CALLED_ABORT:
1657             return 58;
1658         case PMIX_PROC_STATE_MIGRATING:
1659             return 60;
1660         case PMIX_PROC_STATE_CANNOT_RESTART:
1661             return 61;
1662         case PMIX_PROC_STATE_TERM_NON_ZERO:
1663             return 62;
1664         case PMIX_PROC_STATE_FAILED_TO_LAUNCH:
1665             return 63;
1666         default:
1667             return 0;  // undef
1668     }
1669 }
1670 
1671 pmix_proc_state_t pmix4x_convert_opalstate(int state)
1672 {
1673     switch(state) {
1674         case 0:
1675             return PMIX_PROC_STATE_UNDEF;
1676         case 1:
1677             return PMIX_PROC_STATE_LAUNCH_UNDERWAY;
1678         case 2:
1679             return PMIX_PROC_STATE_RESTART;
1680         case 3:
1681             return PMIX_PROC_STATE_TERMINATE;
1682         case 4:
1683             return PMIX_PROC_STATE_RUNNING;
1684         case 5:
1685             return PMIX_PROC_STATE_CONNECTED;
1686         case 51:
1687             return PMIX_PROC_STATE_KILLED_BY_CMD;
1688         case 52:
1689             return PMIX_PROC_STATE_ABORTED;
1690         case 53:
1691             return PMIX_PROC_STATE_FAILED_TO_START;
1692         case 54:
1693             return PMIX_PROC_STATE_ABORTED_BY_SIG;
1694         case 55:
1695             return PMIX_PROC_STATE_TERM_WO_SYNC;
1696         case 56:
1697             return PMIX_PROC_STATE_COMM_FAILED;
1698         case 58:
1699             return PMIX_PROC_STATE_CALLED_ABORT;
1700         case 59:
1701             return PMIX_PROC_STATE_MIGRATING;
1702         case 61:
1703             return PMIX_PROC_STATE_CANNOT_RESTART;
1704         case 62:
1705             return PMIX_PROC_STATE_TERM_NON_ZERO;
1706         case 63:
1707             return PMIX_PROC_STATE_FAILED_TO_LAUNCH;
1708         default:
1709             return PMIX_PROC_STATE_UNDEF;
1710     }
1711 }
1712 
1713 /****  INSTANTIATE INTERNAL CLASSES  ****/
1714 OBJ_CLASS_INSTANCE(opal_pmix4x_jobid_trkr_t,
1715                    opal_list_item_t,
1716                    NULL, NULL);
1717 
1718 static void evcon(opal_pmix4x_event_t *p)
1719 {
1720     OPAL_PMIX_CONSTRUCT_LOCK(&p->lock);
1721     p->handler = NULL;
1722     p->cbdata = NULL;
1723 }
1724 static void evdes(opal_pmix4x_event_t *p)
1725 {
1726     OPAL_PMIX_DESTRUCT_LOCK(&p->lock);
1727 }
1728 OBJ_CLASS_INSTANCE(opal_pmix4x_event_t,
1729                    opal_list_item_t,
1730                    evcon, evdes);
1731 
1732 static void opcon(pmix4x_opcaddy_t *p)
1733 {
1734     memset(&p->p, 0, sizeof(pmix_proc_t));
1735     p->nspace = NULL;
1736     p->procs = NULL;
1737     p->nprocs = 0;
1738     p->pdata = NULL;
1739     p->npdata = 0;
1740     p->error_procs = NULL;
1741     p->nerror_procs = 0;
1742     p->info = NULL;
1743     p->ninfo = 0;
1744     p->apps = NULL;
1745     p->sz = 0;
1746     OPAL_PMIX_CONSTRUCT_LOCK(&p->lock);
1747     p->codes = NULL;
1748     p->pcodes = NULL;
1749     p->ncodes = 0;
1750     p->queries = NULL;
1751     p->nqueries = 0;
1752     p->event = NULL;
1753     p->opcbfunc = NULL;
1754     p->mdxcbfunc = NULL;
1755     p->valcbfunc = NULL;
1756     p->lkcbfunc = NULL;
1757     p->spcbfunc = NULL;
1758     p->evregcbfunc = NULL;
1759     p->qcbfunc = NULL;
1760     p->cbdata = NULL;
1761 }
1762 static void opdes(pmix4x_opcaddy_t *p)
1763 {
1764     OPAL_PMIX_DESTRUCT_LOCK(&p->lock);
1765     if (NULL != p->nspace) {
1766         free(p->nspace);
1767     }
1768     if (NULL != p->procs) {
1769         PMIX_PROC_FREE(p->procs, p->nprocs);
1770     }
1771     if (NULL != p->pdata) {
1772         PMIX_PDATA_FREE(p->pdata, p->npdata);
1773     }
1774     if (NULL != p->error_procs) {
1775         PMIX_PROC_FREE(p->error_procs, p->nerror_procs);
1776     }
1777     if (NULL != p->info) {
1778         PMIX_INFO_FREE(p->info, p->ninfo);
1779     }
1780     if (NULL != p->apps) {
1781         PMIX_APP_FREE(p->apps, p->sz);
1782     }
1783     if (NULL != p->pcodes) {
1784         free(p->pcodes);
1785     }
1786     if (NULL != p->queries) {
1787         PMIX_QUERY_FREE(p->queries, p->nqueries);
1788     }
1789 }
1790 OBJ_CLASS_INSTANCE(pmix4x_opcaddy_t,
1791                    opal_object_t,
1792                    opcon, opdes);
1793 
1794 static void ocadcon(pmix4x_opalcaddy_t *p)
1795 {
1796     OBJ_CONSTRUCT(&p->procs, opal_list_t);
1797     OBJ_CONSTRUCT(&p->info, opal_list_t);
1798     OBJ_CONSTRUCT(&p->apps, opal_list_t);
1799     p->opcbfunc = NULL;
1800     p->dmdxfunc = NULL;
1801     p->mdxcbfunc = NULL;
1802     p->lkupcbfunc = NULL;
1803     p->spwncbfunc = NULL;
1804     p->cbdata = NULL;
1805     p->odmdxfunc = NULL;
1806     p->infocbfunc = NULL;
1807     p->toolcbfunc = NULL;
1808     p->ocbdata = NULL;
1809 }
1810 static void ocaddes(pmix4x_opalcaddy_t *p)
1811 {
1812     OPAL_LIST_DESTRUCT(&p->procs);
1813     OPAL_LIST_DESTRUCT(&p->info);
1814     OPAL_LIST_DESTRUCT(&p->apps);
1815 }
1816 OBJ_CLASS_INSTANCE(pmix4x_opalcaddy_t,
1817                    opal_object_t,
1818                    ocadcon, ocaddes);
1819 
1820 static void tscon(pmix4x_threadshift_t *p)
1821 {
1822     OPAL_PMIX_CONSTRUCT_LOCK(&p->lock);
1823     p->msg = NULL;
1824     p->strings = NULL;
1825     p->source = NULL;
1826     p->event_codes = NULL;
1827     p->info = NULL;
1828     OBJ_CONSTRUCT(&p->results, opal_list_t);
1829     p->evhandler = NULL;
1830     p->nondefault = false;
1831     p->cbfunc = NULL;
1832     p->opcbfunc = NULL;
1833     p->cbdata = NULL;
1834 }
1835 static void tsdes(pmix4x_threadshift_t *p)
1836 {
1837     OPAL_PMIX_DESTRUCT_LOCK(&p->lock);
1838     if (NULL != p->strings) {
1839         free(p->strings);
1840     }
1841     OPAL_LIST_DESTRUCT(&p->results);
1842 }
1843 OBJ_CLASS_INSTANCE(pmix4x_threadshift_t,
1844                    opal_object_t,
1845                    tscon, tsdes);
1846 
1847 static void dmcon(opal_pmix4x_dmx_trkr_t *p)
1848 {
1849     p->nspace = NULL;
1850     p->cbfunc = NULL;
1851     p->cbdata = NULL;
1852 }
1853 static void dmdes(opal_pmix4x_dmx_trkr_t *p)
1854 {
1855     if (NULL != p->nspace) {
1856         free(p->nspace);
1857     }
1858 }
1859 OBJ_CLASS_INSTANCE(opal_pmix4x_dmx_trkr_t,
1860                    opal_list_item_t,
1861                    dmcon, dmdes);
/* [<][>][^][v][top][bottom][index][help] */
root/opal/mca/pmix/pmix4x/pmix4x.c

DEFINITIONS
