openmpi/opal/mca/pmix/ext2x/pmix2x.c

/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
/*
 * Copyright (c) 2014-2016 Intel, Inc.  All rights reserved.
 * Copyright (c) 2014-2017 Research Organization for Information Science
 *                         and Technology (RIST). All rights reserved.
 * Copyright (c) 2014-2015 Mellanox Technologies, Inc.
 *                         All rights reserved.
 * Copyright (c) 2016      Cisco Systems, Inc.  All rights reserved.
 * $COPYRIGHT$
 *
 * Additional copyrights may follow
 *
 * $HEADER$
 */

#include "opal_config.h"
#include "opal/constants.h"
#include "opal/types.h"

#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include "opal/dss/dss.h"
#include "opal/mca/event/event.h"
#include "opal/mca/hwloc/base/base.h"
#include "opal/runtime/opal.h"
#include "opal/runtime/opal_progress_threads.h"
#include "opal/util/argv.h"
#include "opal/util/error.h"
#include "opal/util/output.h"
#include "opal/util/proc.h"
#include "opal/util/show_help.h"

#include "pmix2x.h"
#include "opal/mca/pmix/base/base.h"
#include "opal/mca/pmix/pmix_types.h"

#include <pmix_common.h>
#include <pmix.h>

/****    C.O.M.M.O.N   I.N.T.E.R.F.A.C.E.S     ****/

/* These are functions used by both client and server to
 * access common functions in the embedded PMIx library */

static const char *pmix2x_get_nspace(opal_jobid_t jobid);
static void pmix2x_register_jobid(opal_jobid_t jobid, const char *nspace);
static void register_handler(opal_list_t *event_codes,
                             opal_list_t *info,
                             opal_pmix_notification_fn_t evhandler,
                             opal_pmix_evhandler_reg_cbfunc_t cbfunc,
                             void *cbdata);
static void deregister_handler(size_t evhandler,
                               opal_pmix_op_cbfunc_t cbfunc,
                               void *cbdata);
static int notify_event(int status,
                        const opal_process_name_t *source,
                        opal_pmix_data_range_t range,
                        opal_list_t *info,
                        opal_pmix_op_cbfunc_t cbfunc, void *cbdata);
static void pmix2x_query(opal_list_t *queries,
                         opal_pmix_info_cbfunc_t cbfunc, void *cbdata);
static void pmix2x_log(opal_list_t *info,
                       opal_pmix_op_cbfunc_t cbfunc, void *cbdata);

const opal_pmix_base_module_t opal_pmix_ext2x_module = {
    /* client APIs */
    .init = pmix2x_client_init,
    .finalize = pmix2x_client_finalize,
    .initialized = pmix2x_initialized,
    .abort = pmix2x_abort,
    .commit = pmix2x_commit,
    .fence = pmix2x_fence,
    .fence_nb = pmix2x_fencenb,
    .put = pmix2x_put,
    .get = pmix2x_get,
    .get_nb = pmix2x_getnb,
    .publish = pmix2x_publish,
    .publish_nb = pmix2x_publishnb,
    .lookup = pmix2x_lookup,
    .lookup_nb = pmix2x_lookupnb,
    .unpublish = pmix2x_unpublish,
    .unpublish_nb = pmix2x_unpublishnb,
    .spawn = pmix2x_spawn,
    .spawn_nb = pmix2x_spawnnb,
    .connect = pmix2x_connect,
    .connect_nb = pmix2x_connectnb,
    .disconnect = pmix2x_disconnect,
    .disconnect_nb = pmix2x_disconnectnb,
    .resolve_peers = pmix2x_resolve_peers,
    .resolve_nodes = pmix2x_resolve_nodes,
    .query = pmix2x_query,
    .log = pmix2x_log,
    /* server APIs */
    .server_init = pmix2x_server_init,
    .server_finalize = pmix2x_server_finalize,
    .generate_regex = pmix2x_server_gen_regex,
    .generate_ppn = pmix2x_server_gen_ppn,
    .server_register_nspace = pmix2x_server_register_nspace,
    .server_deregister_nspace = pmix2x_server_deregister_nspace,
    .server_register_client = pmix2x_server_register_client,
    .server_deregister_client = pmix2x_server_deregister_client,
    .server_setup_fork = pmix2x_server_setup_fork,
    .server_dmodex_request = pmix2x_server_dmodex,
    .server_notify_event = pmix2x_server_notify_event,
    /* utility APIs */
    .get_version = PMIx_Get_version,
    .register_evhandler = register_handler,
    .deregister_evhandler = deregister_handler,
    .notify_event = notify_event,
    .store_local = pmix2x_store_local,
    .get_nspace = pmix2x_get_nspace,
    .register_jobid = pmix2x_register_jobid
};

static const char *pmix2x_get_nspace(opal_jobid_t jobid)
{
    opal_pmix2x_jobid_trkr_t *jptr;

    OPAL_LIST_FOREACH(jptr, &mca_pmix_ext2x_component.jobids, opal_pmix2x_jobid_trkr_t) {
        if (jptr->jobid == jobid) {
            return jptr->nspace;
        }
    }
    return NULL;
}

static void pmix2x_register_jobid(opal_jobid_t jobid, const char *nspace)
{
    opal_pmix2x_jobid_trkr_t *jptr;

    /* if we don't already have it, add this to our jobid tracker */
    OPAL_LIST_FOREACH(jptr, &mca_pmix_ext2x_component.jobids, opal_pmix2x_jobid_trkr_t) {
        if (jptr->jobid == jobid) {
            return;
        }
    }
    jptr = OBJ_NEW(opal_pmix2x_jobid_trkr_t);
    (void)strncpy(jptr->nspace, nspace, PMIX_MAX_NSLEN);
    jptr->jobid = jobid;
    opal_list_append(&mca_pmix_ext2x_component.jobids, &jptr->super);
}

static void completion_handler(int status, void *cbdata)
{
    opal_pmix2x_event_chain_t *chain = (opal_pmix2x_event_chain_t*)cbdata;
    if (NULL != chain->info) {
        OPAL_LIST_RELEASE(chain->info);
    }
}

static void progress_local_event_hdlr(int status,
                                      opal_list_t *results,
                                      opal_pmix_op_cbfunc_t cbfunc, void *thiscbdata,
                                      void *notification_cbdata)
{
    opal_pmix2x_event_chain_t *chain = (opal_pmix2x_event_chain_t*)notification_cbdata;
    size_t n;
    opal_list_item_t *nxt;
    opal_pmix2x_single_event_t *sing;
    opal_pmix2x_multi_event_t *multi;
    opal_pmix2x_default_event_t *def;

    /* if the caller indicates that the chain is completed, then stop here */
    if (OPAL_ERR_HANDLERS_COMPLETE == status) {
        goto complete;
    }

    /* if any results were provided, then add them here */
    if (NULL != results) {
        while (NULL != (nxt = opal_list_remove_first(results))) {
            opal_list_append(results, nxt);
        }
    }

    /* see if we need to continue, starting with the single code events */
    if (NULL != chain->sing) {
        /* the last handler was for a single code - see if there are
         * any others that match this event */
        while (opal_list_get_end(&mca_pmix_ext2x_component.single_events) != (nxt = opal_list_get_next(&chain->sing->super))) {
            sing = (opal_pmix2x_single_event_t*)nxt;
            if (sing->code == chain->status) {
                OBJ_RETAIN(chain);
                chain->sing = sing;
                opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                    "%s PROGRESS CALLING SINGLE EVHDLR",
                                    OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
                sing->handler(chain->status, &chain->source,
                              chain->info, &chain->results,
                              progress_local_event_hdlr, (void*)chain);
                goto complete;
            }
        }
        /* if we get here, then there are no more single code
         * events that match */
        chain->sing = NULL;
        /* pickup the beginning of the multi-code event list */
        if (0 < opal_list_get_size(&mca_pmix_ext2x_component.multi_events)) {
            chain->multi = (opal_pmix2x_multi_event_t*)opal_list_get_begin(&mca_pmix_ext2x_component.multi_events);
        }
    }

    /* see if we need to continue with the multi code events */
    if (NULL != chain->multi) {
        while (opal_list_get_end(&mca_pmix_ext2x_component.multi_events) != (nxt = opal_list_get_next(&chain->multi->super))) {
            multi = (opal_pmix2x_multi_event_t*)nxt;
            for (n=0; n < multi->ncodes; n++) {
                if (multi->codes[n] == chain->status) {
                    /* found it - invoke the handler, pointing its
                     * callback function to our progression function */
                    OBJ_RETAIN(chain);
                    chain->multi = multi;
                    opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                        "%s PROGRESS CALLING MULTI EVHDLR",
                                        OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
                    multi->handler(chain->status, &chain->source,
                                   chain->info, &chain->results,
                                   progress_local_event_hdlr, (void*)chain);
                    goto complete;
                }
            }
        }
        /* if we get here, then there are no more multi-mode
         * events that match */
        chain->multi = NULL;
        /* pickup the beginning of the default event list */
        if (0 < opal_list_get_size(&mca_pmix_ext2x_component.default_events)) {
            chain->def = (opal_pmix2x_default_event_t*)opal_list_get_begin(&mca_pmix_ext2x_component.default_events);
        }
    }

    /* if they didn't want it to go to a default handler, then we are done */
    if (chain->nondefault) {
        goto complete;
    }

    if (NULL != chain->def) {
        if (opal_list_get_end(&mca_pmix_ext2x_component.default_events) != (nxt = opal_list_get_next(&chain->def->super))) {
            def = (opal_pmix2x_default_event_t*)nxt;
            OBJ_RETAIN(chain);
            chain->def = def;
            opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                "%s PROGRESS CALLING DEFAULT EVHDLR",
                                OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
            def->handler(chain->status, &chain->source,
                         chain->info, &chain->results,
                         progress_local_event_hdlr, (void*)chain);
        }
    }

  complete:
    /* we still have to call their final callback */
    if (NULL != chain->final_cbfunc) {
        chain->final_cbfunc(OPAL_SUCCESS, chain->final_cbdata);
    }
    /* maintain acctng */
    OBJ_RELEASE(chain);
    /* let the caller know that we are done with their callback */
    if (NULL != cbfunc) {
        cbfunc(OPAL_SUCCESS, thiscbdata);
    }
}

static void _event_hdlr(int sd, short args, void *cbdata)
{
    pmix2x_threadshift_t *cd = (pmix2x_threadshift_t*)cbdata;
    size_t n;
    opal_pmix2x_event_chain_t *chain;
    opal_pmix2x_single_event_t *sing;
    opal_pmix2x_multi_event_t *multi;
    opal_pmix2x_default_event_t *def;

    opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                        "%s _EVENT_HDLR RECEIVED NOTIFICATION OF STATUS %d",
                        OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), cd->status);

    chain = OBJ_NEW(opal_pmix2x_event_chain_t);
    /* point it at our final callback */
    chain->final_cbfunc = completion_handler;
    chain->final_cbdata = chain;

    /* carry across provided info */
    chain->status = cd->status;
    chain->source = cd->pname;
    chain->info = cd->info;
    chain->nondefault = cd->nondefault;

    /* cycle thru the single-event registrations first */
    OPAL_LIST_FOREACH(sing, &mca_pmix_ext2x_component.single_events, opal_pmix2x_single_event_t) {
        if (sing->code == chain->status) {
            /* found it - invoke the handler, pointing its
             * callback function to our progression function */
            chain->sing = sing;
            opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                "%s _EVENT_HDLR CALLING SINGLE EVHDLR",
                                OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
            sing->handler(chain->status, &chain->source,
                          chain->info, &chain->results,
                          progress_local_event_hdlr, (void*)chain);
            return;
        }
    }

    /* if we didn't find any match in the single-event registrations,
     * then cycle thru the multi-event registrations next */
    OPAL_LIST_FOREACH(multi, &mca_pmix_ext2x_component.multi_events, opal_pmix2x_multi_event_t) {
        for (n=0; n < multi->ncodes; n++) {
            if (multi->codes[n] == chain->status) {
                /* found it - invoke the handler, pointing its
                 * callback function to our progression function */
                chain->multi = multi;
                opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                    "%s _EVENT_HDLR CALLING MULTI EVHDLR",
                                    OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
                multi->handler(chain->status, &chain->source,
                               chain->info, &chain->results,
                               progress_local_event_hdlr, (void*)chain);
                return;
            }
        }
    }

      /* if they didn't want it to go to a default handler, then we are done */
    if (chain->nondefault) {
        /* if we get here, then we need to cache this event in case they
         * register for it later - we cannot lose individual events */
        opal_list_append(&mca_pmix_ext2x_component.cache, &chain->super);
        return;
    }

    /* we are done with the threadshift caddy */
    OBJ_RELEASE(cd);

    /* finally, pass it to any default handlers */
    if (0 < opal_list_get_size(&mca_pmix_ext2x_component.default_events)) {
        def = (opal_pmix2x_default_event_t*)opal_list_get_first(&mca_pmix_ext2x_component.default_events);
        chain->def = def;
        opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                            "%s _EVENT_HDLR CALLING DEFAULT EVHDLR",
                            OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
        def->handler(chain->status, &chain->source,
                     chain->info, &chain->results,
                     progress_local_event_hdlr, (void*)chain);
        return;
    }

    /* we still have to call their final callback */
    if (NULL != chain->final_cbfunc) {
        chain->final_cbfunc(PMIX_SUCCESS, chain->final_cbdata);
    }
    
    OBJ_RELEASE(chain);

    return;
}

/* this function will be called by the PMIx client library
 * whenever it receives notification of an event. The
 * notification can come from an ORTE daemon (when launched
 * by mpirun), directly from a RM (when direct launched), or
 * from another process (via the local daemon).
 * The call will occur in the PMIx event base */
void pmix2x_event_hdlr(size_t evhdlr_registration_id,
                       pmix_status_t status, const pmix_proc_t *source,
                       pmix_info_t info[], size_t ninfo,
                       pmix_info_t results[], size_t nresults,
                       pmix_event_notification_cbfunc_fn_t cbfunc,
                       void *cbdata)
{
    pmix2x_threadshift_t *cd;
    int rc;
    opal_value_t *iptr;
    size_t n;

    /* this is in the PMIx local thread - need to threadshift to
     * our own thread as we will be accessing framework-global
     * lists and objects */

     opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                         "%s RECEIVED NOTIFICATION OF STATUS %d",
                         OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), status);

    cd = OBJ_NEW(pmix2x_threadshift_t);

    /* convert the incoming status */
    cd->status = pmix2x_convert_rc(status);
    opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                        "%s CONVERTED STATUS %d TO STATUS %d",
                        OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), status, cd->status);

    /* convert the nspace/rank to an opal_process_name_t */
    if (NULL == source) {
        cd->pname.jobid = OPAL_NAME_INVALID->jobid;
        cd->pname.vpid = OPAL_NAME_INVALID->vpid;
    } else {
        if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&cd->pname.jobid, source->nspace))) {
            OPAL_ERROR_LOG(rc);
            OBJ_RELEASE(cd);
            return;
        }
        cd->pname.vpid = pmix2x_convert_rank(source->rank);
    }

    /* convert the array of info */
    if (NULL != info) {
        cd->info = OBJ_NEW(opal_list_t);
        for (n=0; n < ninfo; n++) {
            if (0 == strncmp(info[n].key, PMIX_EVENT_NON_DEFAULT, PMIX_MAX_KEYLEN)) {
                cd->nondefault = true;
            }
            iptr = OBJ_NEW(opal_value_t);
            iptr->key = strdup(info[n].key);
            if (OPAL_SUCCESS != (rc = pmix2x_value_unload(iptr, &info[n].value))) {
                OPAL_ERROR_LOG(rc);
                OBJ_RELEASE(iptr);
                continue;
            }
            opal_list_append(cd->info, &iptr->super);
        }
    }
    /* now push it into the local thread */
    event_assign(&cd->ev, opal_pmix_base.evbase,
                 -1, EV_WRITE, _event_hdlr, cd);
    event_active(&cd->ev, EV_WRITE, 1);

    /* we don't need any of the data they provided,
     * so let them go - also tell them that we will handle
     * everything from this point forward */
    if (NULL != cbfunc) {
        cbfunc(PMIX_EVENT_ACTION_COMPLETE, NULL, 0, NULL, NULL, cbdata);
    }
}

opal_vpid_t pmix2x_convert_rank(int rank)
{
    switch(rank) {
    case PMIX_RANK_UNDEF:
        return OPAL_VPID_INVALID;
    case PMIX_RANK_WILDCARD:
        return OPAL_VPID_WILDCARD;
    default:
        return (opal_vpid_t)rank;
    }
}

pmix_rank_t pmix2x_convert_opalrank(opal_vpid_t vpid)
{
    switch(vpid) {
    case OPAL_VPID_WILDCARD:
        return PMIX_RANK_WILDCARD;
    case OPAL_VPID_INVALID:
        return PMIX_RANK_UNDEF;
    default:
        return (pmix_rank_t)vpid;
    }
}

pmix_status_t pmix2x_convert_opalrc(int rc)
{
    switch (rc) {
    case OPAL_ERR_DEBUGGER_RELEASE:
        return PMIX_ERR_DEBUGGER_RELEASE;

    case OPAL_ERR_HANDLERS_COMPLETE:
        return PMIX_EVENT_ACTION_COMPLETE;

    case OPAL_ERR_PROC_ABORTED:
        return PMIX_ERR_PROC_ABORTED;

    case OPAL_ERR_PROC_REQUESTED_ABORT:
        return PMIX_ERR_PROC_REQUESTED_ABORT;

    case OPAL_ERR_PROC_ABORTING:
        return PMIX_ERR_PROC_ABORTING;

    case OPAL_ERR_NODE_DOWN:
        return PMIX_ERR_NODE_DOWN;

    case OPAL_ERR_NODE_OFFLINE:
        return PMIX_ERR_NODE_OFFLINE;

    case OPAL_ERR_JOB_TERMINATED:
        return PMIX_ERR_JOB_TERMINATED;

    case OPAL_ERR_PROC_RESTART:
        return PMIX_ERR_PROC_RESTART;

    case OPAL_ERR_PROC_CHECKPOINT:
        return PMIX_ERR_PROC_CHECKPOINT;

    case OPAL_ERR_PROC_MIGRATE:
        return PMIX_ERR_PROC_MIGRATE;

    case OPAL_ERR_EVENT_REGISTRATION:
        return PMIX_ERR_EVENT_REGISTRATION;

    case OPAL_ERR_NOT_IMPLEMENTED:
    case OPAL_ERR_NOT_SUPPORTED:
        return PMIX_ERR_NOT_SUPPORTED;

    case OPAL_ERR_NOT_FOUND:
        return PMIX_ERR_NOT_FOUND;

    case OPAL_ERR_PERM:
    case OPAL_ERR_UNREACH:
    case OPAL_ERR_SERVER_NOT_AVAIL:
        return PMIX_ERR_UNREACH;

    case OPAL_ERR_BAD_PARAM:
        return PMIX_ERR_BAD_PARAM;

    case OPAL_ERR_OUT_OF_RESOURCE:
        return PMIX_ERR_OUT_OF_RESOURCE;

    case OPAL_ERR_DATA_VALUE_NOT_FOUND:
        return PMIX_ERR_DATA_VALUE_NOT_FOUND;

    case OPAL_ERR_TIMEOUT:
        return PMIX_ERR_TIMEOUT;

    case OPAL_ERR_WOULD_BLOCK:
        return PMIX_ERR_WOULD_BLOCK;

    case OPAL_EXISTS:
        return PMIX_EXISTS;

    case OPAL_ERR_PARTIAL_SUCCESS:
        return PMIX_QUERY_PARTIAL_SUCCESS;

    case OPAL_ERROR:
        return PMIX_ERROR;
    case OPAL_SUCCESS:
        return PMIX_SUCCESS;
    default:
        return PMIX_ERROR;
    }
}

int pmix2x_convert_rc(pmix_status_t rc)
{
    switch (rc) {
    case PMIX_ERR_DEBUGGER_RELEASE:
        return OPAL_ERR_DEBUGGER_RELEASE;

    case PMIX_EVENT_ACTION_COMPLETE:
        return OPAL_ERR_HANDLERS_COMPLETE;

    case PMIX_ERR_PROC_ABORTED:
        return OPAL_ERR_PROC_ABORTED;

    case PMIX_ERR_PROC_REQUESTED_ABORT:
        return OPAL_ERR_PROC_REQUESTED_ABORT;

    case PMIX_ERR_PROC_ABORTING:
        return OPAL_ERR_PROC_ABORTING;

    case PMIX_ERR_NODE_DOWN:
        return OPAL_ERR_NODE_DOWN;

    case PMIX_ERR_NODE_OFFLINE:
        return OPAL_ERR_NODE_OFFLINE;

    case PMIX_ERR_JOB_TERMINATED:
        return OPAL_ERR_JOB_TERMINATED;

    case PMIX_ERR_PROC_RESTART:
        return OPAL_ERR_PROC_RESTART;

    case PMIX_ERR_PROC_CHECKPOINT:
        return OPAL_ERR_PROC_CHECKPOINT;

    case PMIX_ERR_PROC_MIGRATE:
        return OPAL_ERR_PROC_MIGRATE;

    case PMIX_ERR_EVENT_REGISTRATION:
        return OPAL_ERR_EVENT_REGISTRATION;

    case PMIX_ERR_NOT_SUPPORTED:
        return OPAL_ERR_NOT_SUPPORTED;

    case PMIX_ERR_NOT_FOUND:
        return OPAL_ERR_NOT_FOUND;

    case PMIX_ERR_OUT_OF_RESOURCE:
        return OPAL_ERR_OUT_OF_RESOURCE;

    case PMIX_ERR_INIT:
        return OPAL_ERROR;

    case PMIX_ERR_BAD_PARAM:
        return OPAL_ERR_BAD_PARAM;

    case PMIX_ERR_UNREACH:
    case PMIX_ERR_NO_PERMISSIONS:
        return OPAL_ERR_UNREACH;

    case PMIX_ERR_TIMEOUT:
        return OPAL_ERR_TIMEOUT;

    case PMIX_ERR_WOULD_BLOCK:
        return OPAL_ERR_WOULD_BLOCK;

    case PMIX_ERR_LOST_CONNECTION_TO_SERVER:
    case PMIX_ERR_LOST_PEER_CONNECTION:
    case PMIX_ERR_LOST_CONNECTION_TO_CLIENT:
        return OPAL_ERR_COMM_FAILURE;

    case PMIX_EXISTS:
        return OPAL_EXISTS;

    case PMIX_QUERY_PARTIAL_SUCCESS:
        return OPAL_ERR_PARTIAL_SUCCESS;

    case PMIX_ERROR:
        return OPAL_ERROR;
    case PMIX_SUCCESS:
        return OPAL_SUCCESS;
    default:
        return OPAL_ERROR;
    }
}

opal_pmix_scope_t pmix2x_convert_scope(pmix_scope_t scope)
{
    switch(scope) {
        case PMIX_SCOPE_UNDEF:
            return OPAL_PMIX_SCOPE_UNDEF;
        case PMIX_LOCAL:
            return OPAL_PMIX_LOCAL;
        case PMIX_REMOTE:
            return OPAL_PMIX_REMOTE;
        case PMIX_GLOBAL:
            return OPAL_PMIX_GLOBAL;
        default:
            return OPAL_PMIX_SCOPE_UNDEF;
    }
}

pmix_scope_t pmix2x_convert_opalscope(opal_pmix_scope_t scope) {
    switch(scope) {
    case OPAL_PMIX_LOCAL:
        return PMIX_LOCAL;
    case OPAL_PMIX_REMOTE:
        return PMIX_REMOTE;
    case OPAL_PMIX_GLOBAL:
        return PMIX_GLOBAL;
    default:
        return PMIX_SCOPE_UNDEF;
    }
}

pmix_data_range_t pmix2x_convert_opalrange(opal_pmix_data_range_t range) {
    switch(range) {
    case OPAL_PMIX_RANGE_UNDEF:
        return PMIX_RANGE_UNDEF;
    case OPAL_PMIX_RANGE_LOCAL:
        return PMIX_RANGE_LOCAL;
    case OPAL_PMIX_RANGE_NAMESPACE:
        return PMIX_RANGE_NAMESPACE;
    case OPAL_PMIX_RANGE_SESSION:
        return PMIX_RANGE_SESSION;
    case OPAL_PMIX_RANGE_GLOBAL:
        return PMIX_RANGE_GLOBAL;
    case OPAL_PMIX_RANGE_CUSTOM:
        return PMIX_RANGE_CUSTOM;
    default:
        return PMIX_SCOPE_UNDEF;
    }
}

opal_pmix_data_range_t pmix2x_convert_range(pmix_data_range_t range) {
    switch(range) {
    case PMIX_RANGE_UNDEF:
        return OPAL_PMIX_RANGE_UNDEF;
    case PMIX_RANGE_LOCAL:
        return OPAL_PMIX_RANGE_LOCAL;
    case PMIX_RANGE_NAMESPACE:
        return OPAL_PMIX_RANGE_NAMESPACE;
    case PMIX_RANGE_SESSION:
        return OPAL_PMIX_RANGE_SESSION;
    case PMIX_RANGE_GLOBAL:
        return OPAL_PMIX_RANGE_GLOBAL;
    case PMIX_RANGE_CUSTOM:
        return OPAL_PMIX_RANGE_CUSTOM;
    default:
        return OPAL_PMIX_RANGE_UNDEF;
    }
}

opal_pmix_persistence_t pmix2x_convert_persist(pmix_persistence_t persist)
{
    switch(persist) {
        case PMIX_PERSIST_INDEF:
            return OPAL_PMIX_PERSIST_INDEF;
        case PMIX_PERSIST_FIRST_READ:
            return OPAL_PMIX_PERSIST_FIRST_READ;
        case PMIX_PERSIST_PROC:
            return OPAL_PMIX_PERSIST_PROC;
        case PMIX_PERSIST_APP:
            return OPAL_PMIX_PERSIST_APP;
        case PMIX_PERSIST_SESSION:
            return OPAL_PMIX_PERSIST_SESSION;
        default:
        return OPAL_PMIX_PERSIST_INDEF;
    }
}

pmix_persistence_t pmix2x_convert_opalpersist(opal_pmix_persistence_t persist)
{
    switch(persist) {
        case OPAL_PMIX_PERSIST_INDEF:
            return PMIX_PERSIST_INDEF;
        case OPAL_PMIX_PERSIST_FIRST_READ:
            return PMIX_PERSIST_FIRST_READ;
        case OPAL_PMIX_PERSIST_PROC:
            return PMIX_PERSIST_PROC;
        case OPAL_PMIX_PERSIST_APP:
            return PMIX_PERSIST_APP;
        case OPAL_PMIX_PERSIST_SESSION:
            return PMIX_PERSIST_SESSION;
        default:
            return PMIX_PERSIST_INDEF;
    }
}

/****   RHC: NEED TO ADD SUPPORT FOR NEW PMIX DATA TYPES, INCLUDING
 ****   CONVERSION OF PROC STATES    ****/

void pmix2x_value_load(pmix_value_t *v,
                       opal_value_t *kv)
{
    opal_pmix2x_jobid_trkr_t *job;
    bool found;

    switch(kv->type) {
        case OPAL_UNDEF:
            v->type = PMIX_UNDEF;
            break;
        case OPAL_BOOL:
            v->type = PMIX_BOOL;
            memcpy(&(v->data.flag), &kv->data.flag, 1);
            break;
        case OPAL_BYTE:
            v->type = PMIX_BYTE;
            memcpy(&(v->data.byte), &kv->data.byte, 1);
            break;
        case OPAL_STRING:
            v->type = PMIX_STRING;
            if (NULL != kv->data.string) {
                v->data.string = strdup(kv->data.string);
            } else {
                v->data.string = NULL;
            }
            break;
        case OPAL_SIZE:
            v->type = PMIX_SIZE;
            v->data.size = (size_t)kv->data.size;
            break;
        case OPAL_PID:
            v->type = PMIX_PID;
            memcpy(&(v->data.pid), &kv->data.pid, sizeof(pid_t));
            break;
        case OPAL_INT:
            v->type = PMIX_INT;
            memcpy(&(v->data.integer), &kv->data.integer, sizeof(int));
            break;
        case OPAL_INT8:
            v->type = PMIX_INT8;
            memcpy(&(v->data.int8), &kv->data.int8, 1);
            break;
        case OPAL_INT16:
            v->type = PMIX_INT16;
            memcpy(&(v->data.int16), &kv->data.int16, 2);
            break;
        case OPAL_INT32:
            v->type = PMIX_INT32;
            memcpy(&(v->data.int32), &kv->data.int32, 4);
            break;
        case OPAL_INT64:
            v->type = PMIX_INT64;
            memcpy(&(v->data.int64), &kv->data.int64, 8);
            break;
        case OPAL_UINT:
            v->type = PMIX_UINT;
            memcpy(&(v->data.uint), &kv->data.uint, sizeof(int));
            break;
        case OPAL_UINT8:
            v->type = PMIX_UINT8;
            memcpy(&(v->data.uint8), &kv->data.uint8, 1);
            break;
        case OPAL_UINT16:
            v->type = PMIX_UINT16;
            memcpy(&(v->data.uint16), &kv->data.uint16, 2);
            break;
        case OPAL_UINT32:
            v->type = PMIX_UINT32;
            memcpy(&(v->data.uint32), &kv->data.uint32, 4);
            break;
        case OPAL_UINT64:
            v->type = PMIX_UINT64;
            memcpy(&(v->data.uint64), &kv->data.uint64, 8);
            break;
        case OPAL_FLOAT:
            v->type = PMIX_FLOAT;
            memcpy(&(v->data.fval), &kv->data.fval, sizeof(float));
            break;
        case OPAL_DOUBLE:
            v->type = PMIX_DOUBLE;
            memcpy(&(v->data.dval), &kv->data.dval, sizeof(double));
            break;
        case OPAL_TIMEVAL:
            v->type = PMIX_TIMEVAL;
            memcpy(&(v->data.tv), &kv->data.tv, sizeof(struct timeval));
            break;
        case OPAL_TIME:
            v->type = PMIX_TIME;
            memcpy(&(v->data.time), &kv->data.time, sizeof(time_t));
            break;
        case OPAL_STATUS:
            v->type = PMIX_STATUS;
            memcpy(&(v->data.status), &kv->data.status, sizeof(pmix_status_t));
            break;
        case OPAL_VPID:
            v->type = PMIX_PROC_RANK;
            v->data.rank = pmix2x_convert_opalrank(kv->data.name.vpid);
            break;
        case OPAL_NAME:
            v->type = PMIX_PROC;
            /* have to stringify the jobid */
            PMIX_PROC_CREATE(v->data.proc, 1);
            /* see if this job is in our list of known nspaces */
            found = false;
            OPAL_LIST_FOREACH(job, &mca_pmix_ext2x_component.jobids, opal_pmix2x_jobid_trkr_t) {
                if (job->jobid == kv->data.name.jobid) {
                    (void)strncpy(v->data.proc->nspace, job->nspace, PMIX_MAX_NSLEN);
                    found = true;
                    break;
                }
            }
            if (!found) {
                (void)opal_snprintf_jobid(v->data.proc->nspace, PMIX_MAX_NSLEN, kv->data.name.vpid);
            }
            v->data.proc->rank = pmix2x_convert_opalrank(kv->data.name.vpid);
            break;
        case OPAL_BYTE_OBJECT:
            v->type = PMIX_BYTE_OBJECT;
            if (NULL != kv->data.bo.bytes) {
                v->data.bo.bytes = (char*)malloc(kv->data.bo.size);
                memcpy(v->data.bo.bytes, kv->data.bo.bytes, kv->data.bo.size);
                v->data.bo.size = (size_t)kv->data.bo.size;
            } else {
                v->data.bo.bytes = NULL;
                v->data.bo.size = 0;
            }
            break;
        case OPAL_PERSIST:
            v->type = PMIX_PERSIST;
            v->data.persist = pmix2x_convert_opalpersist(kv->data.uint8);
            break;
        case OPAL_SCOPE:
            v->type = PMIX_SCOPE;
            v->data.scope = pmix2x_convert_opalscope(kv->data.uint8);
            break;
        case OPAL_DATA_RANGE:
            v->type = PMIX_DATA_RANGE;
            v->data.range = pmix2x_convert_opalrange(kv->data.uint8);
            break;
        case OPAL_PROC_STATE:
            v->type = PMIX_PROC_STATE;
            /* the OPAL layer doesn't have any concept of proc state,
             * so the ORTE layer is responsible for converting it */
            memcpy(&v->data.state, &kv->data.uint8, sizeof(uint8_t));
            break;
        case OPAL_PTR:
            v->type = PMIX_POINTER;
            v->data.ptr = kv->data.ptr;
            break;
        default:
            /* silence warnings */
            break;
    }
}

int pmix2x_value_unload(opal_value_t *kv,
                       const pmix_value_t *v)
{
    int rc=OPAL_SUCCESS;
    bool found;
    opal_pmix2x_jobid_trkr_t *job;

    switch(v->type) {
    case PMIX_UNDEF:
        kv->type = OPAL_UNDEF;
        break;
    case PMIX_BOOL:
        kv->type = OPAL_BOOL;
        memcpy(&kv->data.flag, &(v->data.flag), 1);
        break;
    case PMIX_BYTE:
        kv->type = OPAL_BYTE;
        memcpy(&kv->data.byte, &(v->data.byte), 1);
        break;
    case PMIX_STRING:
        kv->type = OPAL_STRING;
        if (NULL != v->data.string) {
            kv->data.string = strdup(v->data.string);
        }
        break;
    case PMIX_SIZE:
        kv->type = OPAL_SIZE;
        kv->data.size = (int)v->data.size;
        break;
    case PMIX_PID:
        kv->type = OPAL_PID;
        memcpy(&kv->data.pid, &(v->data.pid), sizeof(pid_t));
        break;
    case PMIX_INT:
        kv->type = OPAL_INT;
        memcpy(&kv->data.integer, &(v->data.integer), sizeof(int));
        break;
    case PMIX_INT8:
        kv->type = OPAL_INT8;
        memcpy(&kv->data.int8, &(v->data.int8), 1);
        break;
    case PMIX_INT16:
        kv->type = OPAL_INT16;
        memcpy(&kv->data.int16, &(v->data.int16), 2);
        break;
    case PMIX_INT32:
        kv->type = OPAL_INT32;
        memcpy(&kv->data.int32, &(v->data.int32), 4);
        break;
    case PMIX_INT64:
        kv->type = OPAL_INT64;
        memcpy(&kv->data.int64, &(v->data.int64), 8);
        break;
    case PMIX_UINT:
        kv->type = OPAL_UINT;
        memcpy(&kv->data.uint, &(v->data.uint), sizeof(int));
        break;
    case PMIX_UINT8:
        kv->type = OPAL_UINT8;
        memcpy(&kv->data.uint8, &(v->data.uint8), 1);
        break;
    case PMIX_UINT16:
        kv->type = OPAL_UINT16;
        memcpy(&kv->data.uint16, &(v->data.uint16), 2);
        break;
    case PMIX_UINT32:
        kv->type = OPAL_UINT32;
        memcpy(&kv->data.uint32, &(v->data.uint32), 4);
        break;
    case PMIX_UINT64:
        kv->type = OPAL_UINT64;
        memcpy(&kv->data.uint64, &(v->data.uint64), 8);
        break;
    case PMIX_FLOAT:
        kv->type = OPAL_FLOAT;
        memcpy(&kv->data.fval, &(v->data.fval), sizeof(float));
        break;
    case PMIX_DOUBLE:
        kv->type = OPAL_DOUBLE;
        memcpy(&kv->data.dval, &(v->data.dval), sizeof(double));
        break;
    case PMIX_TIMEVAL:
        kv->type = OPAL_TIMEVAL;
        memcpy(&kv->data.tv, &(v->data.tv), sizeof(struct timeval));
        break;
    case PMIX_TIME:
        kv->type = OPAL_TIME;
        memcpy(&kv->data.time, &(v->data.time), sizeof(time_t));
        break;
    case PMIX_STATUS:
        kv->type = OPAL_STATUS;
        memcpy(&kv->data.status, &(v->data.status), sizeof(opal_status_t));
        break;
    case PMIX_PROC_RANK:
        kv->type = OPAL_VPID;
        kv->data.name.vpid = pmix2x_convert_rank(v->data.rank);
        break;
    case PMIX_PROC:
        kv->type = OPAL_NAME;
        /* see if this job is in our list of known nspaces */
        found = false;
        OPAL_LIST_FOREACH(job, &mca_pmix_ext2x_component.jobids, opal_pmix2x_jobid_trkr_t) {
            if (0 == strncmp(job->nspace, v->data.proc->nspace, PMIX_MAX_NSLEN)) {
                kv->data.name.jobid = job->jobid;
                found = true;
                break;
            }
        }
        if (!found) {
            if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&kv->data.name.jobid, v->data.proc->nspace))) {
                return pmix2x_convert_opalrc(rc);
            }
        }
        kv->data.name.vpid = pmix2x_convert_rank(v->data.proc->rank);
        break;
    case PMIX_BYTE_OBJECT:
        kv->type = OPAL_BYTE_OBJECT;
        if (NULL != v->data.bo.bytes && 0 < v->data.bo.size) {
            kv->data.bo.bytes = (uint8_t*)malloc(v->data.bo.size);
            memcpy(kv->data.bo.bytes, v->data.bo.bytes, v->data.bo.size);
            kv->data.bo.size = (int)v->data.bo.size;
        } else {
            kv->data.bo.bytes = NULL;
            kv->data.bo.size = 0;
        }
        break;
    case PMIX_PERSIST:
        kv->type = OPAL_PERSIST;
        kv->data.uint8 = pmix2x_convert_persist(v->data.persist);
        break;
    case PMIX_SCOPE:
        kv->type = OPAL_SCOPE;
        kv->data.uint8 = pmix2x_convert_scope(v->data.scope);
        break;
    case PMIX_DATA_RANGE:
        kv->type = OPAL_DATA_RANGE;
        kv->data.uint8 = pmix2x_convert_range(v->data.range);
        break;
    case PMIX_PROC_STATE:
        kv->type = OPAL_PROC_STATE;
        /* the OPAL layer doesn't have any concept of proc state,
         * so the ORTE layer is responsible for converting it */
        memcpy(&kv->data.uint8, &v->data.state, sizeof(uint8_t));
        break;
    case PMIX_POINTER:
        kv->type = OPAL_PTR;
        kv->data.ptr = v->data.ptr;
        break;
    default:
        /* silence warnings */
        rc = OPAL_ERROR;
        break;
    }
    return rc;
}

static void _reg_hdlr(int sd, short args, void *cbdata)
{
    pmix2x_threadshift_t *cd = (pmix2x_threadshift_t*)cbdata;
    opal_pmix2x_event_chain_t *chain;
    opal_pmix2x_single_event_t *sing = NULL;
    opal_pmix2x_multi_event_t *multi = NULL;
    opal_pmix2x_default_event_t *def = NULL;
    opal_value_t *kv;
    int i;
    bool prepend = false;
    size_t n;

    opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                        "%s REGISTER HANDLER CODES %s",
                        OPAL_NAME_PRINT(OPAL_PROC_MY_NAME),
                        (NULL == cd->event_codes) ? "NULL" : "NON-NULL");

    if (NULL != cd->info) {
        OPAL_LIST_FOREACH(kv, cd->info, opal_value_t) {
            if (0 == strcmp(kv->key, OPAL_PMIX_EVENT_ORDER_PREPEND)) {
                prepend = true;
                break;
            }
        }
    }

    if (NULL == cd->event_codes) {
        /* this is a default handler */
        def = OBJ_NEW(opal_pmix2x_default_event_t);
        def->handler = cd->evhandler;
        def->index = mca_pmix_ext2x_component.evindex;
        if (prepend) {
             opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                "%s PREPENDING TO DEFAULT EVENTS",
                                OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
            opal_list_prepend(&mca_pmix_ext2x_component.default_events, &def->super);
        } else {
            opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                "%s APPENDING TO DEFAULT EVENTS",
                                OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
            opal_list_append(&mca_pmix_ext2x_component.default_events, &def->super);
        }
    } else if (1 == opal_list_get_size(cd->event_codes)) {
        /* single handler */
        sing = OBJ_NEW(opal_pmix2x_single_event_t);
        kv = (opal_value_t*)opal_list_get_first(cd->event_codes);
        sing->code = kv->data.integer;
        sing->index = mca_pmix_ext2x_component.evindex;
        sing->handler = cd->evhandler;
        if (prepend) {
            opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                "%s PREPENDING TO SINGLE EVENTS WITH CODE %d",
                                OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), sing->code);
            opal_list_prepend(&mca_pmix_ext2x_component.single_events, &sing->super);
        } else {
            opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                "%s APPENDING TO SINGLE EVENTS WITH CODE %d",
                                OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), sing->code);
            opal_list_append(&mca_pmix_ext2x_component.single_events, &sing->super);
        }
    } else {
        multi = OBJ_NEW(opal_pmix2x_multi_event_t);
        multi->ncodes = opal_list_get_size(cd->event_codes);
        multi->codes = (int*)malloc(multi->ncodes * sizeof(int));
        i=0;
        OPAL_LIST_FOREACH(kv, cd->event_codes, opal_value_t) {
            multi->codes[i] = kv->data.integer;
            ++i;
        }
        multi->index = mca_pmix_ext2x_component.evindex;
        multi->handler = cd->evhandler;
        if (prepend) {
            opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                "%s PREPENDING TO MULTI EVENTS",
                                OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
            opal_list_prepend(&mca_pmix_ext2x_component.multi_events, &multi->super);
        } else {
            opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                "%s APPENDING TO MULTI EVENTS",
                                OPAL_NAME_PRINT(OPAL_PROC_MY_NAME));
            opal_list_append(&mca_pmix_ext2x_component.multi_events, &multi->super);
        }
    }

    /* release the caller */
    if (NULL != cd->cbfunc) {
        cd->cbfunc(OPAL_SUCCESS, mca_pmix_ext2x_component.evindex, cd->cbdata);
    }
    mca_pmix_ext2x_component.evindex++;

    /* check if any matching notifications have been cached - only nondefault
     * events will have been cached*/
    if (NULL == def) {
        /* check single code registrations */
        if (NULL != sing) {
            OPAL_LIST_FOREACH(chain, &mca_pmix_ext2x_component.cache, opal_pmix2x_event_chain_t) {
                if (sing->code == chain->status) {
                    opal_list_remove_item(&mca_pmix_ext2x_component.cache, &chain->super);
                    chain->sing = sing;
                    sing->handler(chain->status, &chain->source,
                                  chain->info, &chain->results,
                                  progress_local_event_hdlr, (void*)chain);
                    OBJ_RELEASE(cd);
                    return;
                }
            }
        } else if (NULL != multi) {
            /* check for multi code registrations */
            OPAL_LIST_FOREACH(chain, &mca_pmix_ext2x_component.cache, opal_pmix2x_event_chain_t) {
                for (n=0; n < multi->ncodes; n++) {
                    if (multi->codes[n] == chain->status) {
                        opal_list_remove_item(&mca_pmix_ext2x_component.cache, &chain->super);
                        chain->multi = multi;
                        multi->handler(chain->status, &chain->source,
                                      chain->info, &chain->results,
                                      progress_local_event_hdlr, (void*)chain);
                        OBJ_RELEASE(cd);
                        return;
                    }
                }
            }
        }
    }

    OBJ_RELEASE(cd);
    return;
}
static void register_handler(opal_list_t *event_codes,
                             opal_list_t *info,
                             opal_pmix_notification_fn_t evhandler,
                             opal_pmix_evhandler_reg_cbfunc_t cbfunc,
                             void *cbdata)
{
    /* we must threadshift this request as we might not be in an event
     * and we are going to access framework-global lists/objects */

    OPAL_PMIX_THREADSHIFT(event_codes, info, evhandler, _reg_hdlr, cbfunc, cbdata);
    return;
}

static void _dereg_hdlr(int sd, short args, void *cbdata)
{
    pmix2x_threadshift_t *cd = (pmix2x_threadshift_t*)cbdata;
    opal_pmix2x_single_event_t *sing;
    opal_pmix2x_multi_event_t *multi;
    opal_pmix2x_default_event_t *def;

    /* check the single events first */
    OPAL_LIST_FOREACH(sing, &mca_pmix_ext2x_component.single_events, opal_pmix2x_single_event_t) {
        if (cd->handler == sing->index) {
            opal_list_remove_item(&mca_pmix_ext2x_component.single_events, &sing->super);
            OBJ_RELEASE(sing);
            goto release;
        }
    }
    /* check multi events */
    OPAL_LIST_FOREACH(multi, &mca_pmix_ext2x_component.multi_events, opal_pmix2x_multi_event_t) {
        if (cd->handler == multi->index) {
            opal_list_remove_item(&mca_pmix_ext2x_component.multi_events, &multi->super);
            OBJ_RELEASE(multi);
            goto release;
        }
    }
    /* check default events */
    OPAL_LIST_FOREACH(def, &mca_pmix_ext2x_component.default_events, opal_pmix2x_default_event_t) {
        if (cd->handler == def->index) {
            opal_list_remove_item(&mca_pmix_ext2x_component.default_events, &def->super);
            OBJ_RELEASE(def);
            break;
        }
    }

  release:
    if (NULL != cd->opcbfunc) {
        cd->opcbfunc(OPAL_SUCCESS, cd->cbdata);
    }
    OBJ_RELEASE(cd);
}

static void deregister_handler(size_t evhandler,
                               opal_pmix_op_cbfunc_t cbfunc,
                               void *cbdata)
{
    /* we must threadshift this request as we might not be in an event
     * and we are going to access framework-global lists/objects */
    OPAL_PMIX_OP_THREADSHIFT(evhandler, _dereg_hdlr, cbfunc, cbdata);
    return;
}

static void _notify_event(int sd, short args, void *cbdata)
{
    pmix2x_threadshift_t *cd = (pmix2x_threadshift_t*)cbdata;
    size_t i;
    opal_pmix2x_single_event_t *sing;
    opal_pmix2x_multi_event_t *multi;
    opal_pmix2x_default_event_t *def;
    opal_pmix2x_event_chain_t *chain;

    /* check the single events first */
    OPAL_LIST_FOREACH(sing, &mca_pmix_ext2x_component.single_events, opal_pmix2x_single_event_t) {
        if (cd->status == sing->code) {
            /* found it - invoke the handler, pointing its
             * callback function to our progression function */
            chain = OBJ_NEW(opal_pmix2x_event_chain_t);
            chain->status = cd->status;
            chain->range = pmix2x_convert_opalrange(cd->range);
            chain->source = *(cd->source);
            chain->info = cd->info;
            chain->final_cbfunc = cd->opcbfunc;
            chain->final_cbdata = cd->cbdata;
            chain->sing = sing;
            opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                "[%s] CALLING SINGLE EVHDLR FOR STATUS %d",
                                OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), chain->status);
            sing->handler(chain->status, &chain->source,
                          chain->info, &chain->results,
                          progress_local_event_hdlr, (void*)chain);
            OBJ_RELEASE(cd);
            return;
        }
    }
    /* check multi events */
    OPAL_LIST_FOREACH(multi, &mca_pmix_ext2x_component.multi_events, opal_pmix2x_multi_event_t) {
        for (i=0; i < multi->ncodes; i++) {
            if (cd->status == multi->codes[i]) {
                /* found it - invoke the handler, pointing its
                 * callback function to our progression function */
                chain = OBJ_NEW(opal_pmix2x_event_chain_t);
                chain->status = cd->status;
                chain->range = pmix2x_convert_opalrange(cd->range);
                chain->source = *(cd->source);
                chain->info = cd->info;
                chain->final_cbfunc = cd->opcbfunc;
                chain->final_cbdata = cd->cbdata;
                chain->multi = multi;
                opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                                    "[%s] CALLING MULTI EVHDLR FOR STATUS %d",
                                    OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), chain->status);
                multi->handler(chain->status, &chain->source,
                               chain->info, &chain->results,
                               progress_local_event_hdlr, (void*)chain);
                OBJ_RELEASE(cd);
                return;
            }
        }
    }
    /* check default events */
    if (0 < opal_list_get_size(&mca_pmix_ext2x_component.default_events)) {
        def = (opal_pmix2x_default_event_t*)opal_list_get_first(&mca_pmix_ext2x_component.default_events);
        chain = OBJ_NEW(opal_pmix2x_event_chain_t);
        chain->status = cd->status;
        chain->range = pmix2x_convert_opalrange(cd->range);
        chain->source = *(cd->source);
        chain->info = cd->info;
        chain->final_cbfunc = cd->opcbfunc;
        chain->final_cbdata = cd->cbdata;
        chain->def = def;
        opal_output_verbose(2, opal_pmix_base_framework.framework_output,
                            "[%s] CALLING DEFAULT EVHDLR FOR STATUS %d",
                            OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), chain->status);
        def->handler(chain->status, &chain->source,
                     chain->info, &chain->results,
                     progress_local_event_hdlr, (void*)chain);
        OBJ_RELEASE(cd);
        return;
    }

    /* if we get here, then there are no registered event handlers */
    if (NULL != cd->opcbfunc) {
        cd->opcbfunc(OPAL_ERR_NOT_FOUND, cd->cbdata);
    }
    OBJ_RELEASE(cd);
    return;
}

static int notify_event(int status,
                        const opal_process_name_t *source,
                        opal_pmix_data_range_t range,
                        opal_list_t *info,
                        opal_pmix_op_cbfunc_t cbfunc, void *cbdata)
{
    /* we must threadshift this request as we might not be in an event
     * and we are going to access framework-global lists/objects */
    OPAL_PMIX_NOTIFY_THREADSHIFT(status, source, range, info, _notify_event, cbfunc, cbdata);
    return OPAL_SUCCESS;
}

static void pmix2x_query(opal_list_t *queries,
                         opal_pmix_info_cbfunc_t cbfunc, void *cbdata)
{
    if (NULL != cbfunc) {
        cbfunc(OPAL_ERR_NOT_SUPPORTED, NULL, cbdata, NULL, NULL);
    }
    return;
}

static void opcbfunc(pmix_status_t status, void *cbdata)
{
    pmix2x_opcaddy_t *op = (pmix2x_opcaddy_t*)cbdata;

    if (NULL != op->opcbfunc) {
        op->opcbfunc(pmix2x_convert_rc(status), op->cbdata);
    }
    OBJ_RELEASE(op);
}

static void pmix2x_log(opal_list_t *info,
                       opal_pmix_op_cbfunc_t cbfunc, void *cbdata)
{
    int rc;
    opal_value_t *ival;
    size_t n, ninfo;
    pmix2x_opcaddy_t *cd;
    pmix_status_t prc;

    /* create the caddy */
    cd = OBJ_NEW(pmix2x_opcaddy_t);

    /* bozo check */
    if (NULL == info || 0 == (ninfo = opal_list_get_size(info))) {
        rc = OPAL_ERR_BAD_PARAM;
        goto CLEANUP;
    }

    /* setup the operation */
    cd->opcbfunc = cbfunc;
    cd->cbdata = cbdata;
    cd->ninfo = ninfo;

    /* convert the list to an array of info objects */
    PMIX_INFO_CREATE(cd->info, cd->ninfo);
    n=0;
    OPAL_LIST_FOREACH(ival, info, opal_value_t) {
        (void)strncpy(cd->info[n].key, ival->key, PMIX_MAX_KEYLEN);
        pmix2x_value_load(&cd->info[n].value, ival);
        ++n;
    }

    /* pass it down */
    if (PMIX_SUCCESS != (prc = PMIx_Log_nb(cd->info, cd->ninfo, NULL, 0,
                                           opcbfunc, cd))) {
        /* do not hang! */
        rc = pmix2x_convert_rc(prc);
        goto CLEANUP;
    }

    return;

  CLEANUP:
    if (NULL != cbfunc) {
        cbfunc(rc, cbdata);
    }
    OBJ_RELEASE(cd);
}

/****  INSTANTIATE INTERNAL CLASSES  ****/
OBJ_CLASS_INSTANCE(opal_pmix2x_jobid_trkr_t,
                   opal_list_item_t,
                   NULL, NULL);

OBJ_CLASS_INSTANCE(opal_pmix2x_single_event_t,
                   opal_list_item_t,
                   NULL, NULL);

static void mtevcon(opal_pmix2x_multi_event_t *p)
{
    p->codes = NULL;
    p->ncodes = 0;
}
static void mtevdes(opal_pmix2x_multi_event_t *p)
{
    if (NULL != p->codes) {
        free(p->codes);
    }
}
OBJ_CLASS_INSTANCE(opal_pmix2x_multi_event_t,
                   opal_list_item_t,
                   mtevcon, mtevdes);

OBJ_CLASS_INSTANCE(opal_pmix2x_default_event_t,
                   opal_list_item_t,
                   NULL, NULL);

static void chcon(opal_pmix2x_event_chain_t *p)
{
    p->nondefault = false;
    p->info = NULL;
    OBJ_CONSTRUCT(&p->results, opal_list_t);
    p->sing = NULL;
    p->multi = NULL;
    p->def = NULL;
    p->final_cbfunc = NULL;
    p->final_cbdata = NULL;
}
static void chdes(opal_pmix2x_event_chain_t *p)
{
    OPAL_LIST_DESTRUCT(&p->results);
    if (NULL != p->info) {
        OPAL_LIST_RELEASE(p->info);
    }
}
OBJ_CLASS_INSTANCE(opal_pmix2x_event_chain_t,
                   opal_list_item_t,
                   chcon, chdes);

static void opcon(pmix2x_opcaddy_t *p)
{
    memset(&p->p, 0, sizeof(pmix_proc_t));
    p->procs = NULL;
    p->nprocs = 0;
    p->error_procs = NULL;
    p->nerror_procs = 0;
    p->info = NULL;
    p->ninfo = 0;
    p->apps = NULL;
    p->sz = 0;
    p->active = false;
    p->opcbfunc = NULL;
    p->mdxcbfunc = NULL;
    p->valcbfunc = NULL;
    p->lkcbfunc = NULL;
    p->spcbfunc = NULL;
    p->cbdata = NULL;
}
static void opdes(pmix2x_opcaddy_t *p)
{
    if (NULL != p->procs) {
        PMIX_PROC_FREE(p->procs, p->nprocs);
    }
    if (NULL != p->error_procs) {
        PMIX_PROC_FREE(p->error_procs, p->nerror_procs);
    }
    if (NULL != p->info) {
        PMIX_INFO_FREE(p->info, p->sz);
    }
    if (NULL != p->apps) {
        PMIX_APP_FREE(p->apps, p->sz);
    }
}
OBJ_CLASS_INSTANCE(pmix2x_opcaddy_t,
                   opal_object_t,
                   opcon, opdes);

static void ocadcon(pmix2x_opalcaddy_t *p)
{
    OBJ_CONSTRUCT(&p->procs, opal_list_t);
    OBJ_CONSTRUCT(&p->info, opal_list_t);
    OBJ_CONSTRUCT(&p->apps, opal_list_t);
    p->opcbfunc = NULL;
    p->dmdxfunc = NULL;
    p->mdxcbfunc = NULL;
    p->lkupcbfunc = NULL;
    p->spwncbfunc = NULL;
    p->cbdata = NULL;
    p->odmdxfunc = NULL;
    p->infocbfunc = NULL;
    p->toolcbfunc = NULL;
    p->ocbdata = NULL;
}
static void ocaddes(pmix2x_opalcaddy_t *p)
{
    OPAL_LIST_DESTRUCT(&p->procs);
    OPAL_LIST_DESTRUCT(&p->info);
    OPAL_LIST_DESTRUCT(&p->apps);
}
OBJ_CLASS_INSTANCE(pmix2x_opalcaddy_t,
                   opal_object_t,
                   ocadcon, ocaddes);

static void tscon(pmix2x_threadshift_t *p)
{
    p->active = false;
    p->source = NULL;
    p->event_codes = NULL;
    p->info = NULL;
    p->evhandler = NULL;
    p->nondefault = false;
    p->cbfunc = NULL;
    p->opcbfunc = NULL;
    p->cbdata = NULL;
}
OBJ_CLASS_INSTANCE(pmix2x_threadshift_t,
                   opal_object_t,
                   tscon, NULL);