Stop multiple invocations of debugger-release

It is possible for a tool to receive two copies
of a "debugger-release" event - one directly from
the source and another from the server to which it
is connected. This can create a race condition that
thread-locks the tool.

Add a new PMIX_EVENT_ONESHOT attribute by which a
process can request that an event handler be atomically
deregistered once handling of that event is complete.
Thus, even if a second event is received, the event
notification system will ignore it unless the process
re-registers a handler for it.

Signed-off-by: Ralph Castain <rhc@pmix.org>

Author: rhc54

include/pmix_common.h.in

@@ -432,7 +432,8 @@ typedef uint32_t pmix_rank_t;
 #define PMIX_EVENT_TEXT_MESSAGE             "pmix.evtext"           // (char*) text message suitable for output by recipient - e.g., describing
                                                                     //         the cause of the event
 #define PMIX_EVENT_TIMESTAMP                "pmix.evtstamp"         // (time_t) System time when the associated event occurred.
-
+#define PMIX_EVENT_ONESHOT                  "pmix.evone"            // (bool) when registering, indicate that this event handler is to be deleted
+                                                                    //        after being invoked
 
 /* fault tolerance-related events */
 #define PMIX_EVENT_TERMINATE_SESSION        "pmix.evterm.sess"      // (bool) RM intends to terminate session

src/client/pmix_client.c

@@ -559,7 +559,7 @@ PMIX_EXPORT pmix_status_t PMIx_Init(pmix_proc_t *proc, pmix_info_t info[], size_
     pmix_cmd_t cmd = PMIX_REQ_CMD;
     pmix_status_t code;
     pmix_proc_t wildcard;
-    pmix_info_t ginfo, evinfo[2];
+    pmix_info_t ginfo, evinfo[3];
     pmix_value_t *val = NULL;
     pmix_lock_t reglock, releaselock;
     size_t n;
@@ -884,11 +884,12 @@ PMIX_EXPORT pmix_status_t PMIx_Init(pmix_proc_t *proc, pmix_info_t info[], size_
             PMIX_CONSTRUCT_LOCK(&releaselock);
             PMIX_INFO_LOAD(&evinfo[0], PMIX_EVENT_RETURN_OBJECT, &releaselock, PMIX_POINTER);
             PMIX_INFO_LOAD(&evinfo[1], PMIX_EVENT_HDLR_NAME, "WAIT-FOR-DEBUGGER", PMIX_STRING);
+            PMIX_INFO_LOAD(&evinfo[2], PMIX_EVENT_ONESHOT, NULL, PMIX_BOOL);
             pmix_output_verbose(2, pmix_client_globals.event_output,
                                 "[%s:%d] REGISTERING WAIT FOR DEBUGGER", pmix_globals.myid.nspace,
                                 pmix_globals.myid.rank);
             code = PMIX_DEBUGGER_RELEASE;
-            PMIx_Register_event_handler(&code, 1, evinfo, 2, notification_fn, evhandler_reg_callbk,
+            PMIx_Register_event_handler(&code, 1, evinfo, 3, notification_fn, evhandler_reg_callbk,
                                         (void *) &reglock);
             /* wait for registration to complete */
             PMIX_WAIT_THREAD(&reglock);

src/event/pmix_event.h

@@ -29,6 +29,7 @@
 
 #include "pmix_common.h"
 #include "src/class/pmix_list.h"
+#include "src/mca/bfrops/bfrops_types.h"
 #include "src/util/pmix_output.h"
 
 BEGIN_C_DECLS
@@ -70,6 +71,7 @@ typedef struct {
     char *name;
     size_t index;
     uint8_t precedence;
+    bool oneshot;
     char *locator;
     pmix_proc_t source; // who generated this event
     /* When registering for events, callers can specify
@@ -206,6 +208,9 @@ PMIX_EXPORT bool pmix_notify_check_range(pmix_range_trkr_t *rng, const pmix_proc
 PMIX_EXPORT bool pmix_notify_check_affected(pmix_proc_t *interested, size_t ninterested,
                                             pmix_proc_t *affected, size_t naffected);
 
+PMIX_EXPORT pmix_status_t pmix_deregister_event_hdlr(size_t event_hdlr_ref,
+                                                     pmix_buffer_t *msg);
+
 /* invoke the server event notification handler */
 PMIX_EXPORT pmix_status_t pmix_server_notify_client_of_event(pmix_status_t status,
                                                              const pmix_proc_t *source,

src/event/pmix_event_notification.c

@@ -51,7 +51,8 @@ PMIX_EXPORT pmix_status_t PMIx_Notify_event(pmix_status_t status, const pmix_pro
         return PMIX_ERR_INIT;
     }
 
-    if (PMIX_PEER_IS_SERVER(pmix_globals.mypeer) || PMIX_PEER_IS_TOOL(pmix_globals.mypeer)) {
+    if (PMIX_PEER_IS_SERVER(pmix_globals.mypeer) ||
+        PMIX_PEER_IS_TOOL(pmix_globals.mypeer)) {
         PMIX_RELEASE_THREAD(&pmix_global_lock);
 
         pmix_output_verbose(2, pmix_server_globals.event_output,
@@ -273,8 +274,10 @@ static pmix_status_t notify_server_of_event(pmix_status_t status, const pmix_pro
 
     if (PMIX_RANGE_PROC_LOCAL != range && NULL != msg) {
         /* if this is a "lost-connection" event, then there is no
-         * server to pass it to! */
-        if (PMIX_ERR_LOST_CONNECTION == status) {
+         * server to pass it to! Likewise, we don't pass it to
+         * ourselves */
+        if (PMIX_ERR_LOST_CONNECTION == status ||
+            pmix_globals.mypeer == pmix_client_globals.myserver) {
             PMIX_RELEASE(msg);
             goto local;
         }
@@ -391,11 +394,15 @@ static void cycle_events(int sd, short args, void *cbdata)
 
     /* if the caller indicates that the chain is completed,
      * or we completed the "last" event */
-    if (PMIX_EVENT_ACTION_COMPLETE == chain->interim_status
-        || PMIX_EVENT_ORDER_LAST_OVERALL == chain->evhdlr->precedence || chain->endchain) {
+    if (PMIX_EVENT_ACTION_COMPLETE == chain->interim_status ||
+        PMIX_EVENT_ORDER_LAST_OVERALL == chain->evhdlr->precedence || chain->endchain) {
         if (PMIX_EVENT_ACTION_COMPLETE == chain->interim_status) {
             chain->interim_status = PMIX_SUCCESS;
         }
+        if (chain->evhdlr->oneshot) {
+            /* remove this handler */
+            pmix_deregister_event_hdlr(chain->evhdlr->index, NULL);
+        }
         goto complete;
     }
     item = NULL;
@@ -409,8 +416,7 @@ static void cycle_events(int sd, short args, void *cbdata)
         } else {
             item = &chain->evhdlr->super;
         }
-        while (pmix_list_get_end(&pmix_globals.events.single_events)
-               != (item = pmix_list_get_next(item))) {
+        while (pmix_list_get_end(&pmix_globals.events.single_events) != (item = pmix_list_get_next(item))) {
             nxt = (pmix_event_hdlr_t *) item;
             if (nxt->codes[0] == chain->status && pmix_notify_check_range(&nxt->rng, &chain->source)
                 && pmix_notify_check_affected(nxt->affected, nxt->naffected, chain->affected,
@@ -499,8 +505,7 @@ static void cycle_events(int sd, short args, void *cbdata)
         } else if (NULL == item) {
             item = &chain->evhdlr->super;
         }
-        if (pmix_list_get_end(&pmix_globals.events.default_events)
-            != (item = pmix_list_get_next(item))) {
+        if (pmix_list_get_end(&pmix_globals.events.default_events) != (item = pmix_list_get_next(item))) {
             nxt = (pmix_event_hdlr_t *) item;
             /* if this event handler provided a range, check to see if
              * the source fits within it */
@@ -687,7 +692,8 @@ void pmix_invoke_local_event_hdlr(pmix_event_chain_t *chain)
             }
         }
         if (!found) {
-            pmix_output_verbose(8, pmix_client_globals.event_output, "%s %s:%d",
+            pmix_output_verbose(8, pmix_client_globals.event_output,
+                                "%s Ignoring event %s:%d",
                                 PMIX_NAME_PRINT(&pmix_globals.myid), __FILE__, __LINE__);
             goto complete;
         }
@@ -1089,6 +1095,10 @@ static void _notify_client_event(int sd, short args, void *cbdata)
                     if (PMIX_CHECK_PROCID(&cd->source, &pr->peer->info->pname)) {
                         continue;
                     }
+                    /* don't notify ourselves - we handle this internally */
+                    if (PMIX_CHECK_PROCID(&pmix_globals.myid, &pr->peer->info->pname)) {
+                        continue;
+                    }
                     /* if we have already notified this client, then don't do it again */
                     matched = false;
                     PMIX_LIST_FOREACH (nm, &trk, pmix_namelist_t) {
@@ -1353,8 +1363,10 @@ void pmix_event_timeout_cb(int fd, short flags, void *arg)
     PMIX_RETAIN(ch);
 
     /* process this event thru the regular channels */
-    if (PMIX_PEER_IS_SERVER(pmix_globals.mypeer) && !PMIX_PEER_IS_LAUNCHER(pmix_globals.mypeer)) {
-        pmix_server_notify_client_of_event(ch->status, &ch->source, ch->range, ch->info, ch->ninfo,
+    if (PMIX_PEER_IS_SERVER(pmix_globals.mypeer) &&
+        !PMIX_PEER_IS_LAUNCHER(pmix_globals.mypeer)) {
+        pmix_server_notify_client_of_event(ch->status, &ch->source, ch->range,
+                                           ch->info, ch->ninfo,
                                            ch->final_cbfunc, ch->final_cbdata);
     } else {
         pmix_invoke_local_event_hdlr(ch);
@@ -1427,6 +1439,7 @@ static void sevcon(pmix_event_hdlr_t *p)
     p->name = NULL;
     p->index = UINT_MAX;
     p->precedence = PMIX_EVENT_ORDER_NONE;
+    p->oneshot = false;
     p->locator = NULL;
     p->rng.range = PMIX_RANGE_UNDEF;
     p->rng.procs = NULL;