during ip allocation, there are failure modes where a node might hold a ip address

[sahlberg/ctdb.git] / server / eventscript.c

diff --git a/server/eventscript.c b/server/eventscript.c
index 41da296031b81e6cce0195c0162ae3d8772dc84e..ce2fd89eca5a61fc8dda0dc65d3e06751ed1540b 100644 (file)
--- a/server/eventscript.c
+++ b/server/eventscript.c
@@ -24,13 +24,13 @@
 #include "system/dir.h"
 #include "system/locale.h"
 #include "../include/ctdb_private.h"
-#include "lib/events/events.h"
+#include "lib/tevent/tevent.h"
 #include "../common/rb_tree.h"
 
 static void ctdb_event_script_timeout(struct event_context *ev, struct timed_event *te, struct timeval t, void *p);
 
 /*
-  ctdbd sends us a SIGTERM when we should time out the current script
+  ctdbd sends us a SIGTERM when we should die.
  */
 static void sigterm(int sig)
 {
@@ -39,17 +39,6 @@ static void sigterm(int sig)
        _exit(1);
 }
 
-/*
-  ctdbd sends us a SIGABRT when we should abort the current script.
-  we abort any active monitor script any time a different event is generated.
- */
-static void sigabrt(int sig)
-{
-       /* all the child processes will be running in the same process group */
-       kill(-getpgrp(), SIGKILL);
-       _exit(1);
-}
-
 struct ctdb_event_script_state {
        struct ctdb_context *ctdb;
        pid_t child;
@@ -58,7 +47,6 @@ struct ctdb_event_script_state {
        int fd[2];
        void *private_data;
        bool from_user;
-       bool aborted;
        enum ctdb_eventscript_call call;
        const char *options;
        struct timeval timeout;
@@ -271,7 +259,6 @@ static int child_setup(struct ctdb_context *ctdb)
        }
 
        signal(SIGTERM, sigterm);
-       signal(SIGABRT, sigabrt);
        return 0;
 }
 
@@ -376,6 +363,7 @@ static int fork_child_for_script(struct ctdb_context *ctdb,
                                 struct ctdb_event_script_state *state)
 {
        int r;
+       struct tevent_fd *fde;
        struct ctdb_script_wire *current = get_current_script(state);
 
        current->start = timeval_current();
@@ -398,6 +386,9 @@ static int fork_child_for_script(struct ctdb_context *ctdb,
        if (state->child == 0) {
                int rt;
 
+               debug_extra = talloc_asprintf(NULL, "eventscript-%s-%s:",
+                                             current->name,
+                                             ctdb_eventscript_call_names[state->call]);
                close(state->fd[0]);
                set_close_on_exec(state->fd[1]);
 
@@ -415,8 +406,10 @@ static int fork_child_for_script(struct ctdb_context *ctdb,
        DEBUG(DEBUG_DEBUG, (__location__ " Created PIPE FD:%d to child eventscript process\n", state->fd[0]));
 
        /* Set ourselves up to be called when that's done. */
-       event_add_fd(ctdb->ev, state, state->fd[0], EVENT_FD_READ|EVENT_FD_AUTOCLOSE,
-                    ctdb_event_script_handler, state);
+       fde = event_add_fd(ctdb->ev, state, state->fd[0], EVENT_FD_READ,
+                          ctdb_event_script_handler, state);
+       tevent_fd_set_auto_close(fde);
+
        return 0;
 }
 
@@ -522,6 +515,8 @@ static void debug_timeout(struct ctdb_event_script_state *state)
        if (pid == 0) {
                ctdb_reduce_priority(state->ctdb);
                system(buf);
+               /* Now we can kill the child */
+               kill(state->child, SIGTERM);
                exit(0);
        }
        if (pid == -1) {
@@ -529,6 +524,8 @@ static void debug_timeout(struct ctdb_event_script_state *state)
                                 strerror(errno)));
        } else {
                DEBUG(DEBUG_ERR,("Logged timedout eventscript : %s\n", buf));
+               /* Don't kill child until timeout done. */
+               state->child = 0;
        }
 }
 
@@ -560,11 +557,6 @@ static void ctdb_event_script_timeout(struct event_context *ev, struct timed_eve
                debug_timeout(state);
        }
 
-       if (kill(state->child, 0) != 0) {
-               DEBUG(DEBUG_ERR,("Event script child process already dead, errno %s(%d)\n", strerror(errno), errno));
-               state->child = 0;
-       }
-
        talloc_free(state);
 }
 
@@ -576,17 +568,10 @@ static int event_script_destructor(struct ctdb_event_script_state *state)
        int status;
 
        if (state->child) {
-               if (state->aborted != True) {
-                       DEBUG(DEBUG_ERR,(__location__ " Sending SIGTERM to child pid:%d\n", state->child));
+               DEBUG(DEBUG_ERR,(__location__ " Sending SIGTERM to child pid:%d\n", state->child));
 
-                       if (kill(state->child, SIGTERM) != 0) {
-                               DEBUG(DEBUG_ERR,("Failed to kill child process for eventscript, errno %s(%d)\n", strerror(errno), errno));
-                       }
-               } else {
-                       DEBUG(DEBUG_INFO,(__location__ " Sending SIGABRT to script child pid:%d\n", state->child));
-                       if (kill(state->child, SIGABRT) != 0) {
-                               DEBUG(DEBUG_ERR,("Failed to kill child process for eventscript, errno %s(%d)\n", strerror(errno), errno));
-                       }
+               if (kill(state->child, SIGTERM) != 0) {
+                       DEBUG(DEBUG_ERR,("Failed to kill child process for eventscript, errno %s(%d)\n", strerror(errno), errno));
                }
        }
 
@@ -648,6 +633,7 @@ static bool check_options(enum ctdb_eventscript_call call, const char *options)
        case CTDB_EVENT_STATUS:
        case CTDB_EVENT_SHUTDOWN:
        case CTDB_EVENT_RELOAD:
+       case CTDB_EVENT_IPREALLOCATED:
                return count_words(options) == 0;
 
        case CTDB_EVENT_TAKE_IP: /* interface, IP address, netmask bits. */
@@ -683,7 +669,6 @@ static int ctdb_event_script_callback_v(struct ctdb_context *ctdb,
        state->callback = callback;
        state->private_data = private_data;
        state->from_user = from_user;
-       state->aborted = False;
        state->call = call;
        state->options = talloc_vasprintf(state, fmt, ap);
        state->timeout = timeval_set(ctdb->tunable.script_timeout, 0);
@@ -726,7 +711,6 @@ static int ctdb_event_script_callback_v(struct ctdb_context *ctdb,
        /* Kill off any running monitor events to run this event. */
        if (ctdb->current_monitor) {
                /* Discard script status so we don't save to last_status */
-               ctdb->current_monitor->aborted = True;
                talloc_free(ctdb->current_monitor->scripts);
                ctdb->current_monitor->scripts = NULL;
                talloc_free(ctdb->current_monitor);