opal/mca/pmix/ext1x/pmix1x_server

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
opal_opcbfunc
server_client_connected_fn
server_client_finalized_fn
server_abort_fn
_data_release
opmdx_response
server_fencenb_fn
server_dmodex_req_fn
server_publish_fn
opal_lkupcbfunc
server_lookup_fn
server_unpublish_fn
opal_spncbfunc
server_spawn_fn
server_connect_fn
server_disconnect_fn
server_register_events
server_deregister_events
server_listener_fn
   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$
  10  *
  11  * Additional copyrights may follow
  12  *
  13  * $HEADER$
  14  */
  15 
  16 #include "opal_config.h"
  17 #include "opal/constants.h"
  18 #include "opal/types.h"
  19 
  20 #ifdef HAVE_STRING_H
  21 #include <string.h>
  22 #endif
  23 #ifdef HAVE_UNISTD_H
  24 #include <unistd.h>
  25 #endif
  26 
  27 #include "opal/dss/dss.h"
  28 #include "opal/mca/event/event.h"
  29 #include "opal/mca/hwloc/base/base.h"
  30 #include "opal/runtime/opal.h"
  31 #include "opal/runtime/opal_progress_threads.h"
  32 #include "opal/util/argv.h"
  33 #include "opal/util/error.h"
  34 #include "opal/util/output.h"
  35 #include "opal/util/proc.h"
  36 #include "opal/util/show_help.h"
  37 #include "opal/util/string_copy.h"
  38 #include "opal/mca/pmix/base/base.h"
  39 #include "pmix1x.h"
  40 
  41 #include "pmix.h"
  42 #include "pmix_server.h"
  43 
  44 /****    N.O.R.T.H.B.O.U.N.D   I.N.T.E.R.F.A.C.E.S     ****/
  45 
  46 /* These are the interfaces used by the embedded PMIx server
  47  * to call up into ORTE for service requests */
  48 
  49  static pmix_status_t server_client_connected_fn(const pmix_proc_t *proc, void* server_object);
  50 static pmix_status_t server_client_finalized_fn(const pmix_proc_t *proc, void* server_object,
  51                                                 pmix_op_cbfunc_t cbfunc, void *cbdata);
  52 static pmix_status_t server_abort_fn(const pmix_proc_t *proc, void *server_object,
  53                                      int status, const char msg[],
  54                                      pmix_proc_t procs[], size_t nprocs,
  55                                      pmix_op_cbfunc_t cbfunc, void *cbdata);
  56 static pmix_status_t server_fencenb_fn(const pmix_proc_t procs[], size_t nprocs,
  57                                        const pmix_info_t info[], size_t ninfo,
  58                                        char *data, size_t ndata,
  59                                        pmix_modex_cbfunc_t cbfunc, void *cbdata);
  60 static pmix_status_t server_dmodex_req_fn(const pmix_proc_t *proc,
  61                                           const pmix_info_t info[], size_t ninfo,
  62                                           pmix_modex_cbfunc_t cbfunc, void *cbdata);
  63 static pmix_status_t server_publish_fn(const pmix_proc_t *proc,
  64                                        const pmix_info_t info[], size_t ninfo,
  65                                        pmix_op_cbfunc_t cbfunc, void *cbdata);
  66 static pmix_status_t server_lookup_fn(const pmix_proc_t *proc,  char **keys,
  67                                       const pmix_info_t info[], size_t ninfo,
  68                                       pmix_lookup_cbfunc_t cbfunc, void *cbdata);
  69 static pmix_status_t server_unpublish_fn(const pmix_proc_t *proc, char **keys,
  70                                          const pmix_info_t info[], size_t ninfo,
  71                                          pmix_op_cbfunc_t cbfunc, void *cbdata);
  72 static pmix_status_t server_spawn_fn(const pmix_proc_t *proc,
  73                                      const pmix_info_t job_info[], size_t ninfo,
  74                                      const pmix_app_t apps[], size_t napps,
  75                                      pmix_spawn_cbfunc_t cbfunc, void *cbdata);
  76 static pmix_status_t server_connect_fn(const pmix_proc_t procs[], size_t nprocs,
  77                                        const pmix_info_t info[], size_t ninfo,
  78                                        pmix_op_cbfunc_t cbfunc, void *cbdata);
  79 static pmix_status_t server_disconnect_fn(const pmix_proc_t procs[], size_t nprocs,
  80                                           const pmix_info_t info[], size_t ninfo,
  81                                           pmix_op_cbfunc_t cbfunc, void *cbdata);
  82 static pmix_status_t server_register_events(const pmix_info_t info[], size_t ninfo,
  83                                             pmix_op_cbfunc_t cbfunc, void *cbdata);
  84 static pmix_status_t server_deregister_events(const pmix_info_t info[], size_t ninfo,
  85                                            pmix_op_cbfunc_t cbfunc, void *cbdata);
  86 static pmix_status_t server_listener_fn(int listening_sd,
  87                                         pmix_connection_cbfunc_t cbfunc);
  88 
  89 pmix_server_module_t mymodule = {
  90     .client_connected = server_client_connected_fn,
  91     .client_finalized = server_client_finalized_fn,
  92     .abort = server_abort_fn,
  93     .fence_nb = server_fencenb_fn,
  94     .direct_modex = server_dmodex_req_fn,
  95     .publish = server_publish_fn,
  96     .lookup = server_lookup_fn,
  97     .unpublish = server_unpublish_fn,
  98     .spawn = server_spawn_fn,
  99     .connect = server_connect_fn,
 100     .disconnect = server_disconnect_fn,
 101     .register_events = server_register_events,
 102     .deregister_events = server_deregister_events,
 103     .listener = server_listener_fn
 104 };
 105 
 106 opal_pmix_server_module_t *host_module = NULL;
 107 
 108 
 109 static void opal_opcbfunc(int status, void *cbdata)
 110 {
 111     pmix1_opalcaddy_t *opalcaddy = (pmix1_opalcaddy_t*)cbdata;
 112 
 113     if (NULL != opalcaddy->opcbfunc) {
 114         opalcaddy->opcbfunc(pmix1_convert_opalrc(status), opalcaddy->cbdata);
 115     }
 116     OBJ_RELEASE(opalcaddy);
 117 }
 118 
 119 static pmix_status_t server_client_connected_fn(const pmix_proc_t *p, void *server_object)
 120 {
 121     int rc;
 122     opal_process_name_t proc;
 123 
 124     if (NULL == host_module || NULL == host_module->client_connected) {
 125         return PMIX_SUCCESS;
 126     }
 127 
 128     /* convert the nspace/rank to an opal_process_name_t */
 129     if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) {
 130         return pmix1_convert_opalrc(rc);
 131     }
 132     proc.vpid = p->rank;
 133 
 134     /* pass it up */
 135     rc = host_module->client_connected(&proc, server_object,
 136                                        NULL, NULL);
 137     return pmix1_convert_opalrc(rc);
 138 }
 139 
 140 static pmix_status_t server_client_finalized_fn(const pmix_proc_t *p, void* server_object,
 141                                                 pmix_op_cbfunc_t cbfunc, void *cbdata)
 142 {
 143     int rc;
 144     pmix1_opalcaddy_t *opalcaddy;
 145     opal_process_name_t proc;
 146 
 147     if (NULL == host_module || NULL == host_module->client_finalized) {
 148         return PMIX_SUCCESS;
 149     }
 150 
 151     /* convert the nspace/rank to an opal_process_name_t */
 152     if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) {
 153         return pmix1_convert_opalrc(rc);
 154     }
 155     proc.vpid = p->rank;
 156 
 157     /* setup the caddy */
 158     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 159     opalcaddy->opcbfunc = cbfunc;
 160     opalcaddy->cbdata = cbdata;
 161 
 162     /* pass it up */
 163     rc = host_module->client_finalized(&proc, server_object, opal_opcbfunc, opalcaddy);
 164     if (OPAL_SUCCESS != rc) {
 165         OBJ_RELEASE(opalcaddy);
 166     }
 167     return pmix1_convert_opalrc(rc);
 168 }
 169 
 170 static pmix_status_t server_abort_fn(const pmix_proc_t *p, void *server_object,
 171                                      int status, const char msg[],
 172                                      pmix_proc_t procs[], size_t nprocs,
 173                                      pmix_op_cbfunc_t cbfunc, void *cbdata)
 174 {
 175     size_t n;
 176     opal_namelist_t *nm;
 177     opal_process_name_t proc;
 178     int rc;
 179     pmix1_opalcaddy_t *opalcaddy;
 180 
 181     if (NULL == host_module || NULL == host_module->abort) {
 182         return PMIX_ERR_NOT_SUPPORTED;
 183     }
 184 
 185     /* convert the nspace/rank to an opal_process_name_t */
 186     if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) {
 187         return pmix1_convert_opalrc(rc);
 188     }
 189     proc.vpid = p->rank;
 190 
 191     /* setup the caddy */
 192     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 193     opalcaddy->opcbfunc = cbfunc;
 194     opalcaddy->cbdata = cbdata;
 195 
 196     /* convert the array of pmix_proc_t to the list of procs */
 197     for (n=0; n < nprocs; n++) {
 198         nm = OBJ_NEW(opal_namelist_t);
 199         opal_list_append(&opalcaddy->procs, &nm->super);
 200         if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&nm->name.jobid, procs[n].nspace))) {
 201             OBJ_RELEASE(opalcaddy);
 202             return pmix1_convert_opalrc(rc);
 203         }
 204         if (PMIX_RANK_WILDCARD == procs[n].rank) {
 205             nm->name.vpid = OPAL_VPID_WILDCARD;
 206         } else {
 207             nm->name.vpid = procs[n].rank;
 208         }
 209     }
 210 
 211     /* pass it up */
 212     rc = host_module->abort(&proc, server_object, status, msg,
 213                             &opalcaddy->procs, opal_opcbfunc, opalcaddy);
 214     if (OPAL_SUCCESS != rc) {
 215         OBJ_RELEASE(opalcaddy);
 216     }
 217     return pmix1_convert_opalrc(rc);
 218 }
 219 
 220 static void _data_release(void *cbdata)
 221 {
 222     pmix1_opalcaddy_t *opalcaddy = (pmix1_opalcaddy_t*)cbdata;
 223 
 224     if (NULL != opalcaddy->odmdxfunc) {
 225         opalcaddy->odmdxfunc(opalcaddy->ocbdata);
 226     }
 227     OBJ_RELEASE(opalcaddy);
 228 }
 229 
 230 static void opmdx_response(int status, const char *data, size_t sz, void *cbdata,
 231                            opal_pmix_release_cbfunc_t relcbfunc, void *relcbdata)
 232 {
 233     pmix_status_t rc;
 234     pmix1_opalcaddy_t *opalcaddy = (pmix1_opalcaddy_t*)cbdata;
 235 
 236     rc = pmix1_convert_rc(status);
 237     if (NULL != opalcaddy->mdxcbfunc) {
 238         opalcaddy->odmdxfunc = relcbfunc;
 239         opalcaddy->ocbdata = relcbdata;
 240         opalcaddy->mdxcbfunc(rc, data, sz, opalcaddy->cbdata,
 241                              _data_release, opalcaddy);
 242     } else {
 243         OBJ_RELEASE(opalcaddy);
 244     }
 245 }
 246 
 247 static pmix_status_t server_fencenb_fn(const pmix_proc_t procs[], size_t nprocs,
 248                                        const pmix_info_t info[], size_t ninfo,
 249                                        char *data, size_t ndata,
 250                                        pmix_modex_cbfunc_t cbfunc, void *cbdata)
 251 {
 252     pmix1_opalcaddy_t *opalcaddy;
 253     size_t n;
 254     opal_namelist_t *nm;
 255     opal_value_t *iptr;
 256     int rc;
 257 
 258     if (NULL == host_module || NULL == host_module->fence_nb) {
 259         return PMIX_ERR_NOT_SUPPORTED;
 260     }
 261 
 262     /* setup the caddy */
 263     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 264     opalcaddy->mdxcbfunc = cbfunc;
 265     opalcaddy->cbdata = cbdata;
 266 
 267     /* convert the array of pmix_proc_t to the list of procs */
 268     for (n=0; n < nprocs; n++) {
 269         nm = OBJ_NEW(opal_namelist_t);
 270         opal_list_append(&opalcaddy->procs, &nm->super);
 271         if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&nm->name.jobid, procs[n].nspace))) {
 272             OBJ_RELEASE(opalcaddy);
 273             return pmix1_convert_opalrc(rc);
 274         }
 275         if (PMIX_RANK_WILDCARD == procs[n].rank) {
 276             nm->name.vpid = OPAL_VPID_WILDCARD;
 277         } else {
 278             nm->name.vpid = procs[n].rank;
 279         }
 280     }
 281 
 282     /* convert the array of pmix_info_t to the list of info */
 283     for (n=0; n < ninfo; n++) {
 284         iptr = OBJ_NEW(opal_value_t);
 285         opal_list_append(&opalcaddy->info, &iptr->super);
 286         iptr->key = strdup(info[n].key);
 287         if (OPAL_SUCCESS != (rc = pmix1_value_unload(iptr, &info[n].value))) {
 288             OBJ_RELEASE(opalcaddy);
 289             return pmix1_convert_opalrc(rc);
 290         }
 291     }
 292 
 293     /* pass it up */
 294     rc = host_module->fence_nb(&opalcaddy->procs, &opalcaddy->info,
 295                                data, ndata, opmdx_response, opalcaddy);
 296     if (OPAL_SUCCESS != rc) {
 297         OBJ_RELEASE(opalcaddy);
 298     }
 299     return pmix1_convert_opalrc(rc);
 300 }
 301 
 302 static pmix_status_t server_dmodex_req_fn(const pmix_proc_t *p,
 303                                           const pmix_info_t info[], size_t ninfo,
 304                                           pmix_modex_cbfunc_t cbfunc, void *cbdata)
 305 {
 306     int rc;
 307     pmix1_opalcaddy_t *opalcaddy;
 308     opal_process_name_t proc;
 309     opal_value_t *iptr;
 310     size_t n;
 311 
 312     if (NULL == host_module || NULL == host_module->direct_modex) {
 313         return PMIX_ERR_NOT_SUPPORTED;
 314     }
 315 
 316     /* convert the nspace/rank to an opal_process_name_t */
 317     if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) {
 318         return pmix1_convert_opalrc(rc);
 319     }
 320     if (PMIX_RANK_WILDCARD == p->rank) {
 321         proc.vpid = OPAL_VPID_WILDCARD;
 322     } else {
 323         proc.vpid = p->rank;
 324     }
 325 
 326     /* setup the caddy */
 327     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 328     opalcaddy->mdxcbfunc = cbfunc;
 329     opalcaddy->cbdata = cbdata;
 330 
 331     /* convert the array of pmix_info_t to the list of info */
 332     for (n=0; n < ninfo; n++) {
 333         iptr = OBJ_NEW(opal_value_t);
 334         opal_list_append(&opalcaddy->info, &iptr->super);
 335         iptr->key = strdup(info[n].key);
 336         if (OPAL_SUCCESS != (rc = pmix1_value_unload(iptr, &info[n].value))) {
 337             OBJ_RELEASE(opalcaddy);
 338             return pmix1_convert_opalrc(rc);
 339         }
 340     }
 341 
 342     /* pass it up */
 343     rc = host_module->direct_modex(&proc, &opalcaddy->info, opmdx_response, opalcaddy);
 344     if (OPAL_SUCCESS != rc && OPAL_ERR_IN_PROCESS != rc) {
 345         OBJ_RELEASE(opalcaddy);
 346     }
 347     if (OPAL_ERR_IN_PROCESS == rc) {
 348         rc = OPAL_SUCCESS;
 349     }
 350     return pmix1_convert_opalrc(rc);
 351 }
 352 
 353 static pmix_status_t server_publish_fn(const pmix_proc_t *p,
 354                                        const pmix_info_t info[], size_t ninfo,
 355                                        pmix_op_cbfunc_t cbfunc, void *cbdata)
 356 {
 357     int rc;
 358     size_t n;
 359     pmix1_opalcaddy_t *opalcaddy;
 360     opal_process_name_t proc;
 361     opal_value_t *oinfo;
 362 
 363     if (NULL == host_module || NULL == host_module->publish) {
 364         return PMIX_ERR_NOT_SUPPORTED;
 365     }
 366 
 367    /* convert the nspace/rank to an opal_process_name_t */
 368     if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) {
 369         return pmix1_convert_opalrc(rc);
 370     }
 371     if (PMIX_RANK_WILDCARD == p->rank) {
 372         proc.vpid = OPAL_VPID_WILDCARD;
 373     } else {
 374         proc.vpid = p->rank;
 375     }
 376 
 377     /* setup the caddy */
 378     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 379     opalcaddy->opcbfunc = cbfunc;
 380     opalcaddy->cbdata = cbdata;
 381 
 382     /* convert the info array */
 383     for (n=0; n < ninfo; n++) {
 384         oinfo = OBJ_NEW(opal_value_t);
 385         opal_list_append(&opalcaddy->info, &oinfo->super);
 386         oinfo->key = strdup(info[n].key);
 387         if (OPAL_SUCCESS != (rc = pmix1_value_unload(oinfo, &info[n].value))) {
 388             OBJ_RELEASE(opalcaddy);
 389             return pmix1_convert_opalrc(rc);
 390         }
 391     }
 392 
 393     /* pass it up */
 394     rc = host_module->publish(&proc, &opalcaddy->info, opal_opcbfunc, opalcaddy);
 395     if (OPAL_SUCCESS != rc) {
 396         OBJ_RELEASE(opalcaddy);
 397     }
 398 
 399     return pmix1_convert_opalrc(rc);
 400 }
 401 
 402 static void opal_lkupcbfunc(int status,
 403                             opal_list_t *data,
 404                             void *cbdata)
 405 {
 406     pmix1_opalcaddy_t *opalcaddy = (pmix1_opalcaddy_t*)cbdata;
 407     pmix_status_t rc;
 408     pmix_pdata_t *d=NULL;
 409     size_t nd=0, n;
 410     opal_pmix_pdata_t *p;
 411 
 412     if (NULL != opalcaddy->lkupcbfunc) {
 413         rc = pmix1_convert_opalrc(status);
 414         /* convert any returned data */
 415         if (NULL != data) {
 416             nd = opal_list_get_size(data);
 417             PMIX_PDATA_CREATE(d, nd);
 418             n=0;
 419             OPAL_LIST_FOREACH(p, data, opal_pmix_pdata_t) {
 420                 /* convert the jobid */
 421                 (void)opal_snprintf_jobid(d[n].proc.nspace, PMIX_MAX_NSLEN, p->proc.jobid);
 422                 d[n].proc.rank = p->proc.vpid;
 423                 (void)opal_string_copy(d[n].key, p->value.key, PMIX_MAX_KEYLEN);
 424                 pmix1_value_load(&d[n].value, &p->value);
 425             }
 426         }
 427         opalcaddy->lkupcbfunc(rc, d, nd, opalcaddy->cbdata);
 428         PMIX_PDATA_FREE(d, nd);
 429     }
 430     OBJ_RELEASE(opalcaddy);
 431 }
 432 
 433 static pmix_status_t server_lookup_fn(const pmix_proc_t *p, char **keys,
 434                                       const pmix_info_t info[], size_t ninfo,
 435                                       pmix_lookup_cbfunc_t cbfunc, void *cbdata)
 436 {
 437     int rc;
 438     pmix1_opalcaddy_t *opalcaddy;
 439     opal_process_name_t proc;
 440     opal_value_t *iptr;
 441     size_t n;
 442 
 443     if (NULL == host_module || NULL == host_module->lookup) {
 444         return PMIX_ERR_NOT_SUPPORTED;
 445     }
 446 
 447     /* convert the nspace/rank to an opal_process_name_t */
 448     if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) {
 449         return pmix1_convert_opalrc(rc);
 450     }
 451     if (PMIX_RANK_WILDCARD == p->rank) {
 452         proc.vpid = OPAL_VPID_WILDCARD;
 453     } else {
 454         proc.vpid = p->rank;
 455     }
 456 
 457     /* setup the caddy */
 458     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 459     opalcaddy->lkupcbfunc = cbfunc;
 460     opalcaddy->cbdata = cbdata;
 461 
 462     /* convert the array of pmix_info_t to the list of info */
 463     for (n=0; n < ninfo; n++) {
 464         iptr = OBJ_NEW(opal_value_t);
 465         opal_list_append(&opalcaddy->info, &iptr->super);
 466         iptr->key = strdup(info[n].key);
 467         if (OPAL_SUCCESS != (rc = pmix1_value_unload(iptr, &info[n].value))) {
 468             OBJ_RELEASE(opalcaddy);
 469             return pmix1_convert_opalrc(rc);
 470         }
 471     }
 472 
 473     /* pass it up */
 474     rc = host_module->lookup(&proc, keys, &opalcaddy->info, opal_lkupcbfunc, opalcaddy);
 475     if (OPAL_SUCCESS != rc) {
 476         OBJ_RELEASE(opalcaddy);
 477     }
 478 
 479     return pmix1_convert_opalrc(rc);
 480 }
 481 
 482 
 483 static pmix_status_t server_unpublish_fn(const pmix_proc_t *p, char **keys,
 484                                          const pmix_info_t info[], size_t ninfo,
 485                                          pmix_op_cbfunc_t cbfunc, void *cbdata)
 486 {
 487     int rc;
 488     pmix1_opalcaddy_t *opalcaddy;
 489     opal_process_name_t proc;
 490     opal_value_t *iptr;
 491     size_t n;
 492 
 493     if (NULL == host_module || NULL == host_module->unpublish) {
 494         return PMIX_SUCCESS;
 495     }
 496 
 497     /* convert the nspace/rank to an opal_process_name_t */
 498     if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) {
 499         return pmix1_convert_opalrc(rc);
 500     }
 501     if (PMIX_RANK_WILDCARD == p->rank) {
 502         proc.vpid = OPAL_VPID_WILDCARD;
 503     } else {
 504         proc.vpid = p->rank;
 505     }
 506 
 507     /* setup the caddy */
 508     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 509     opalcaddy->opcbfunc = cbfunc;
 510     opalcaddy->cbdata = cbdata;
 511 
 512     /* convert the array of pmix_info_t to the list of info */
 513     for (n=0; n < ninfo; n++) {
 514         iptr = OBJ_NEW(opal_value_t);
 515         opal_list_append(&opalcaddy->info, &iptr->super);
 516         iptr->key = strdup(info[n].key);
 517         if (OPAL_SUCCESS != (rc = pmix1_value_unload(iptr, &info[n].value))) {
 518             OBJ_RELEASE(opalcaddy);
 519             return pmix1_convert_opalrc(rc);
 520         }
 521     }
 522 
 523     /* pass it up */
 524     rc = host_module->unpublish(&proc, keys, &opalcaddy->info, opal_opcbfunc, opalcaddy);
 525     if (OPAL_SUCCESS != rc) {
 526         OBJ_RELEASE(opalcaddy);
 527     }
 528 
 529     return pmix1_convert_opalrc(rc);
 530 }
 531 
 532 static void opal_spncbfunc(int status, opal_jobid_t jobid, void *cbdata)
 533 {
 534     pmix1_opalcaddy_t *opalcaddy = (pmix1_opalcaddy_t*)cbdata;
 535     pmix_status_t rc;
 536     char nspace[PMIX_MAX_NSLEN];
 537 
 538     if (NULL != opalcaddy->spwncbfunc) {
 539         rc = pmix1_convert_opalrc(status);
 540         /* convert the jobid */
 541         (void)opal_snprintf_jobid(nspace, PMIX_MAX_NSLEN, jobid);
 542         opalcaddy->spwncbfunc(rc, nspace, opalcaddy->cbdata);
 543     }
 544     OBJ_RELEASE(opalcaddy);
 545 }
 546 
 547 static pmix_status_t server_spawn_fn(const pmix_proc_t *p,
 548                                      const pmix_info_t job_info[], size_t ninfo,
 549                                      const pmix_app_t apps[], size_t napps,
 550                                      pmix_spawn_cbfunc_t cbfunc, void *cbdata)
 551 {
 552     pmix1_opalcaddy_t *opalcaddy;
 553     opal_process_name_t proc;
 554     opal_pmix_app_t *app;
 555     opal_value_t *oinfo;
 556     size_t k, n;
 557     int rc;
 558 
 559     if (NULL == host_module || NULL == host_module->spawn) {
 560         return PMIX_ERR_NOT_SUPPORTED;
 561     }
 562 
 563     /* convert the nspace/rank to an opal_process_name_t */
 564     if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) {
 565         return pmix1_convert_opalrc(rc);
 566     }
 567     if (PMIX_RANK_WILDCARD == p->rank) {
 568         proc.vpid = OPAL_VPID_WILDCARD;
 569     } else {
 570         proc.vpid = p->rank;
 571     }
 572 
 573     /* setup the caddy */
 574     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 575     opalcaddy->spwncbfunc = cbfunc;
 576     opalcaddy->cbdata = cbdata;
 577 
 578     /* convert the job info */
 579     for (k=0; k < ninfo; k++) {
 580         oinfo = OBJ_NEW(opal_value_t);
 581         opal_list_append(&opalcaddy->info, &oinfo->super);
 582         oinfo->key = strdup(job_info[k].key);
 583         if (OPAL_SUCCESS != (rc = pmix1_value_unload(oinfo, &job_info[k].value))) {
 584             OBJ_RELEASE(opalcaddy);
 585             return pmix1_convert_opalrc(rc);
 586         }
 587     }
 588 
 589     /* convert the apps */
 590     for (n=0; n < napps; n++) {
 591         app = OBJ_NEW(opal_pmix_app_t);
 592         opal_list_append(&opalcaddy->apps, &app->super);
 593         if (NULL != apps[n].cmd) {
 594             app->cmd = strdup(apps[n].cmd);
 595         }
 596         if (NULL != apps[n].argv) {
 597             app->argv = opal_argv_copy(apps[n].argv);
 598         }
 599         if (NULL != apps[n].env) {
 600             app->env = opal_argv_copy(apps[n].env);
 601         }
 602         app->maxprocs = apps[n].maxprocs;
 603         for (k=0; k < apps[n].ninfo; k++) {
 604             oinfo = OBJ_NEW(opal_value_t);
 605             opal_list_append(&app->info, &oinfo->super);
 606             oinfo->key = strdup(apps[n].info[k].key);
 607             if (OPAL_SUCCESS != (rc = pmix1_value_unload(oinfo,  &apps[n].info[k].value))) {
 608                 OBJ_RELEASE(opalcaddy);
 609                 return pmix1_convert_opalrc(rc);
 610             }
 611         }
 612     }
 613 
 614     /* pass it up */
 615     rc = host_module->spawn(&proc, &opalcaddy->info, &opalcaddy->apps, opal_spncbfunc, opalcaddy);
 616     if (OPAL_SUCCESS != rc) {
 617         OPAL_ERROR_LOG(rc);
 618         OBJ_RELEASE(opalcaddy);
 619     }
 620 
 621     return pmix1_convert_opalrc(rc);
 622 }
 623 
 624 
 625 static pmix_status_t server_connect_fn(const pmix_proc_t procs[], size_t nprocs,
 626                                        const pmix_info_t info[], size_t ninfo,
 627                                        pmix_op_cbfunc_t cbfunc, void *cbdata)
 628 {
 629     int rc;
 630     pmix1_opalcaddy_t *opalcaddy;
 631     opal_namelist_t *nm;
 632     size_t n;
 633     opal_value_t *oinfo;
 634 
 635     if (NULL == host_module || NULL == host_module->connect) {
 636         return PMIX_ERR_NOT_SUPPORTED;
 637     }
 638 
 639     /* setup the caddy */
 640     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 641     opalcaddy->opcbfunc = cbfunc;
 642     opalcaddy->cbdata = cbdata;
 643 
 644     /* convert the array of pmix_proc_t to the list of procs */
 645     for (n=0; n < nprocs; n++) {
 646         nm = OBJ_NEW(opal_namelist_t);
 647         opal_list_append(&opalcaddy->procs, &nm->super);
 648         if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&nm->name.jobid, procs[n].nspace))) {
 649             OBJ_RELEASE(opalcaddy);
 650             return pmix1_convert_opalrc(rc);
 651         }
 652         if (PMIX_RANK_WILDCARD == procs[n].rank) {
 653             nm->name.vpid = OPAL_VPID_WILDCARD;
 654         } else {
 655             nm->name.vpid = procs[n].rank;
 656         }
 657     }
 658 
 659     /* convert the info */
 660     for (n=0; n < ninfo; n++) {
 661         oinfo = OBJ_NEW(opal_value_t);
 662         opal_list_append(&opalcaddy->info, &oinfo->super);
 663         oinfo->key = strdup(info[n].key);
 664         if (OPAL_SUCCESS != (rc = pmix1_value_unload(oinfo, &info[n].value))) {
 665             OBJ_RELEASE(opalcaddy);
 666             return pmix1_convert_opalrc(rc);
 667         }
 668     }
 669 
 670     /* pass it up */
 671     rc = host_module->connect(&opalcaddy->procs, &opalcaddy->info, opal_opcbfunc, opalcaddy);
 672     if (OPAL_SUCCESS != rc) {
 673         OBJ_RELEASE(opalcaddy);
 674     }
 675 
 676     return pmix1_convert_opalrc(rc);
 677 }
 678 
 679 
 680 static pmix_status_t server_disconnect_fn(const pmix_proc_t procs[], size_t nprocs,
 681                                           const pmix_info_t info[], size_t ninfo,
 682                                           pmix_op_cbfunc_t cbfunc, void *cbdata)
 683 {
 684     int rc;
 685     pmix1_opalcaddy_t *opalcaddy;
 686     opal_namelist_t *nm;
 687     size_t n;
 688     opal_value_t *oinfo;
 689 
 690     if (NULL == host_module || NULL == host_module->disconnect) {
 691         return PMIX_ERR_NOT_SUPPORTED;
 692     }
 693 
 694     /* setup the caddy */
 695     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 696     opalcaddy->opcbfunc = cbfunc;
 697     opalcaddy->cbdata = cbdata;
 698 
 699     /* convert the array of pmix_proc_t to the list of procs */
 700     for (n=0; n < nprocs; n++) {
 701         nm = OBJ_NEW(opal_namelist_t);
 702         opal_list_append(&opalcaddy->procs, &nm->super);
 703         if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&nm->name.jobid, procs[n].nspace))) {
 704             OBJ_RELEASE(opalcaddy);
 705             return pmix1_convert_opalrc(rc);
 706         }
 707         if (PMIX_RANK_WILDCARD == procs[n].rank) {
 708             nm->name.vpid = OPAL_VPID_WILDCARD;
 709         } else {
 710             nm->name.vpid = procs[n].rank;
 711         }
 712     }
 713 
 714     /* convert the info */
 715     for (n=0; n < ninfo; n++) {
 716         oinfo = OBJ_NEW(opal_value_t);
 717         opal_list_append(&opalcaddy->info, &oinfo->super);
 718         oinfo->key = strdup(info[n].key);
 719         if (OPAL_SUCCESS != (rc = pmix1_value_unload(oinfo, &info[n].value))) {
 720             OBJ_RELEASE(opalcaddy);
 721             return pmix1_convert_opalrc(rc);
 722         }
 723     }
 724 
 725     /* pass it up */
 726     rc = host_module->disconnect(&opalcaddy->procs, &opalcaddy->info, opal_opcbfunc, opalcaddy);
 727     if (OPAL_SUCCESS != rc) {
 728         OBJ_RELEASE(opalcaddy);
 729     }
 730 
 731     return pmix1_convert_opalrc(rc);
 732 }
 733 
 734 static pmix_status_t server_register_events(const pmix_info_t info[], size_t ninfo,
 735                                             pmix_op_cbfunc_t cbfunc, void *cbdata)
 736 {
 737     pmix1_opalcaddy_t *opalcaddy;
 738     size_t n;
 739     opal_value_t *oinfo;
 740     int rc;
 741 
 742     /* setup the caddy */
 743     opalcaddy = OBJ_NEW(pmix1_opalcaddy_t);
 744     opalcaddy->opcbfunc = cbfunc;
 745     opalcaddy->cbdata = cbdata;
 746 
 747     /* convert the info */
 748     for (n=0; n < ninfo; n++) {
 749         oinfo = OBJ_NEW(opal_value_t);
 750         opal_list_append(&opalcaddy->info, &oinfo->super);
 751         oinfo->key = strdup(info[n].key);
 752         if (OPAL_SUCCESS != (rc = pmix1_value_unload(oinfo, &info[n].value))) {
 753             OBJ_RELEASE(opalcaddy);
 754             return pmix1_convert_opalrc(rc);
 755         }
 756     }
 757 
 758     /* pass it up */
 759     rc = host_module->register_events(&opalcaddy->info, opal_opcbfunc, opalcaddy);
 760     if (OPAL_SUCCESS != rc) {
 761         OBJ_RELEASE(opalcaddy);
 762     }
 763 
 764     return pmix1_convert_opalrc(rc);
 765 }
 766 
 767 static pmix_status_t server_deregister_events(const pmix_info_t info[], size_t ninfo,
 768                                               pmix_op_cbfunc_t cbfunc, void *cbdata)
 769 {
 770     return PMIX_ERR_NOT_IMPLEMENTED;
 771 }
 772 static pmix_status_t server_listener_fn(int listening_sd,
 773                                         pmix_connection_cbfunc_t cbfunc)
 774 {
 775     int rc;
 776 
 777     if (NULL == host_module || NULL == host_module->listener) {
 778         return PMIX_ERR_NOT_SUPPORTED;
 779     }
 780 
 781     rc = host_module->listener(listening_sd, cbfunc);
 782     return pmix1_convert_opalrc(rc);
 783 }
/* [<][>][^][v][top][bottom][index][help] */
root/opal/mca/pmix/ext1x/pmix1x_server_north.c

DEFINITIONS
