ctdb/server/ctdb_fork.c

   1 /*
   2    functions to track and manage processes
   3
   4    Copyright (C) Ronnie Sahlberg 2012
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "replace.h"
  21 #include "system/wait.h"
  22 #include "system/network.h"
  23
  24 #include <talloc.h>
  25 #include <tevent.h>
  26
  27 #include "lib/util/debug.h"
  28 #include "lib/util/time.h"
  29
  30 #include "ctdb_private.h"
  31 #include "ctdb_client.h"
  32
  33 #include "common/rb_tree.h"
  34 #include "common/system.h"
  35 #include "common/common.h"
  36 #include "common/logging.h"
  37
  38 void ctdb_track_child(struct ctdb_context *ctdb, pid_t pid)
  39 {
  40         char *process;
  41
  42         /* Only CTDB main daemon should track child processes */
  43         if (getpid() != ctdb->ctdbd_pid) {
  44                 return;
  45         }
  46
  47         process = talloc_asprintf(ctdb->child_processes, "process:%d", (int)pid);
  48         trbt_insert32(ctdb->child_processes, pid, process);
  49 }
  50
  51 /*
  52  * This function forks a child process and drops the realtime
  53  * scheduler for the child process.
  54  */
  55 pid_t ctdb_fork(struct ctdb_context *ctdb)
  56 {
  57         pid_t pid;
  58         struct timeval before;
  59         double delta_t;
  60
  61         before = timeval_current();
  62
  63         pid = fork();
  64         if (pid == -1) {
  65                 DEBUG(DEBUG_ERR,
  66                       (__location__ " fork() failed (%s)\n", strerror(errno)));
  67                 return -1;
  68         }
  69         if (pid == 0) {
  70                 /* Close the Unix Domain socket and the TCP socket.
  71                  * This ensures that none of the child processes will
  72                  * look like the main daemon when it is not running.
  73                  * tevent needs to be stopped before closing sockets.
  74                  */
  75                 if (ctdb->ev != NULL) {
  76                         talloc_free(ctdb->ev);
  77                         ctdb->ev = NULL;
  78                 }
  79                 if (ctdb->daemon.sd != -1) {
  80                         close(ctdb->daemon.sd);
  81                         ctdb->daemon.sd = -1;
  82                 }
  83                 if (ctdb->methods != NULL && ctdb->methods->shutdown != NULL) {
  84                         ctdb->methods->shutdown(ctdb);
  85                 }
  86
  87                 /* The child does not need to be realtime */
  88                 if (ctdb->do_setsched) {
  89                         reset_scheduler();
  90                 }
  91                 ctdb->can_send_controls = false;
  92
  93                 return 0;
  94         }
  95
  96         delta_t = timeval_elapsed(&before);
  97         if (delta_t > 3.0) {
  98                 DEBUG(DEBUG_WARNING, ("fork() took %lf seconds\n", delta_t));
  99         }
 100
 101         ctdb_track_child(ctdb, pid);
 102         return pid;
 103 }
 104
 105 /*
 106  * vfork + exec
 107  */
 108 pid_t ctdb_vfork_exec(TALLOC_CTX *mem_ctx,
 109                       struct ctdb_context *ctdb,
 110                       const char *helper,
 111                       int helper_argc,
 112                       const char *const *helper_argv)
 113 {
 114         pid_t pid;
 115         struct timeval before;
 116         double delta_t;
 117         char **argv;
 118         int i;
 119
 120         argv = talloc_array(mem_ctx, char *, helper_argc + 1);
 121         if (argv == NULL) {
 122                 DEBUG(DEBUG_ERR, ("Memory allocation error\n"));
 123                 return -1;
 124         }
 125
 126         argv[0] = discard_const(helper);
 127         for (i=0; i<helper_argc; i++) {
 128                 argv[i+1] = discard_const(helper_argv[i]);
 129         }
 130
 131         before = timeval_current();
 132
 133         pid = vfork();
 134         if (pid == -1) {
 135                 DEBUG(DEBUG_ERR, ("vfork() failed (%s)\n", strerror(errno)));
 136                 return -1;
 137         }
 138
 139         if (pid == 0) {
 140                 execv(helper, argv);
 141                 _exit(1);
 142         }
 143
 144         delta_t = timeval_elapsed(&before);
 145         if (delta_t > 3.0) {
 146                 DEBUG(DEBUG_WARNING, ("vfork() took %lf seconds\n", delta_t));
 147         }
 148
 149         ctdb_track_child(ctdb, pid);
 150         return pid;
 151 }
 152
 153 static void ctdb_sigchld_handler(struct tevent_context *ev,
 154         struct tevent_signal *te, int signum, int count,
 155         void *dont_care,
 156         void *private_data)
 157 {
 158         struct ctdb_context *ctdb = talloc_get_type(private_data, struct ctdb_context);
 159         int status;
 160         pid_t pid = -1;
 161
 162         while (pid != 0) {
 163                 pid = waitpid(-1, &status, WNOHANG);
 164                 if (pid == -1) {
 165                         DEBUG(DEBUG_ERR, (__location__ " waitpid() returned error. errno:%d\n", errno));
 166                         return;
 167                 }
 168                 if (pid > 0) {
 169                         char *process;
 170
 171                         if (getpid() != ctdb->ctdbd_pid) {
 172                                 continue;
 173                         }
 174
 175                         process = trbt_lookup32(ctdb->child_processes, pid);
 176                         if (process == NULL) {
 177                                 DEBUG(DEBUG_ERR,("Got SIGCHLD from pid:%d we didn not spawn with ctdb_fork\n", pid));
 178                         }
 179
 180                         DEBUG(DEBUG_DEBUG, ("SIGCHLD from %d %s\n", (int)pid, process));
 181                         talloc_free(process);
 182                 }
 183         }
 184 }
 185
 186
 187 struct tevent_signal *
 188 ctdb_init_sigchld(struct ctdb_context *ctdb)
 189 {
 190         struct tevent_signal *se;
 191
 192         ctdb->child_processes = trbt_create(ctdb, 0);
 193
 194         se = tevent_add_signal(ctdb->ev, ctdb, SIGCHLD, 0, ctdb_sigchld_handler, ctdb);
 195         return se;
 196 }
 197
 198 int
 199 ctdb_kill(struct ctdb_context *ctdb, pid_t pid, int signum)
 200 {
 201         char *process;
 202
 203         if (signum == 0) {
 204                 return kill(pid, signum);
 205         }
 206
 207         if (getpid() != ctdb->ctdbd_pid) {
 208                 return kill(pid, signum);
 209         }
 210
 211         process = trbt_lookup32(ctdb->child_processes, pid);
 212         if (process == NULL) {
 213                 DEBUG(DEBUG_ERR,("ctdb_kill: trying to kill(%d, %d) a process that does not exist\n", pid, signum));
 214                 return 0;
 215         }
 216
 217         return kill(pid, signum);
 218 }