src/testbed/gnunet_testbed_mpi_spawn.c

   1 #include "platform.h"
   2 #include "gnunet_util_lib.h"
   3 #include "gnunet_testbed_service.h"
   4
   5
   6 /**
   7  * Generic logging shorthand
   8  */
   9 #define LOG(kind,...)                           \
  10   GNUNET_log (kind, __VA_ARGS__)
  11
  12 /**
  13  * Debug logging shorthand
  14  */
  15 #define LOG_DEBUG(...)                          \
  16   LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
  17
  18 /**
  19  * Global result
  20  */
  21 static int ret;
  22
  23 /**
  24  * The child process we spawn
  25  */
  26 static struct GNUNET_OS_Process *child;
  27
  28 /**
  29  * The arguments including the binary to spawn
  30  */
  31 static char **argv2;
  32
  33 /**
  34  * Pipe used to communicate shutdown via signal.
  35  */
  36 static struct GNUNET_DISK_PipeHandle *sigpipe;
  37
  38 /**
  39  * Filename of the unique file
  40  */
  41 static char *fn;
  42
  43 /**
  44  * Handle to the unique file
  45  */
  46 static int fh;
  47
  48 /**
  49  * The return code of the binary
  50  */
  51 static unsigned long child_exit_code;
  52
  53 /**
  54  * The process status of the child
  55  */
  56 static enum GNUNET_OS_ProcessStatusType child_status;
  57
  58 /**
  59  * Task to kill the child
  60  */
  61 static struct GNUNET_SCHEDULER_Task * terminate_task_id;
  62
  63 /**
  64  * Task to kill the child
  65  */
  66 static struct GNUNET_SCHEDULER_Task * child_death_task_id;
  67
  68 /**
  69  * The shutdown task
  70  */
  71 static void
  72 shutdown_task (void *cls)
  73 {
  74   if (0 != child_exit_code)
  75   {
  76     LOG (GNUNET_ERROR_TYPE_WARNING, "Child exited with error code: %lu\n",
  77          child_exit_code);
  78     ret = 128 + (int) child_exit_code;
  79   }
  80   if (0 != fh)
  81   {
  82     close (fh);
  83   }
  84   if ((NULL != fn) && (0 != unlink (fn)))
  85   {
  86     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "open");
  87     ret = GNUNET_SYSERR;
  88   }
  89 }
  90
  91
  92 static void
  93 terminate_task (void *cls)
  94 {
  95   static int hard_kill;
  96
  97   GNUNET_assert (NULL != child);
  98   terminate_task_id =
  99     GNUNET_SCHEDULER_add_shutdown (&terminate_task, NULL);
 100   if (0 != hard_kill)
 101   {
 102     switch (hard_kill)
 103     {
 104     case 1:
 105     case 2:
 106       LOG (GNUNET_ERROR_TYPE_WARNING,
 107            "%d more interrupts needed to send SIGKILL to the child\n",
 108            3 - hard_kill);
 109       hard_kill++;
 110       return;
 111     case 3:
 112       GNUNET_break (0 == GNUNET_OS_process_kill (child, SIGKILL));
 113       return;
 114     }
 115   }
 116   hard_kill++;
 117   GNUNET_break (0 == GNUNET_OS_process_kill (child, GNUNET_TERM_SIG));
 118   LOG (GNUNET_ERROR_TYPE_INFO, _("Waiting for child to exit.\n"));
 119 }
 120
 121
 122 /**
 123  * Task triggered whenever we receive a SIGCHLD (child
 124  * process died).
 125  *
 126  * @param cls closure, NULL if we need to self-restart
 127  */
 128 static void
 129 child_death_task (void *cls)
 130 {
 131   const struct GNUNET_DISK_FileHandle *pr;
 132   char c[16];
 133   const struct GNUNET_SCHEDULER_TaskContext *tc;
 134
 135
 136   pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
 137   child_death_task_id = NULL;
 138   tc = GNUNET_SCHEDULER_get_task_context ();
 139   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
 140   {
 141     child_death_task_id =
 142         GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
 143                                         pr, &child_death_task, NULL);
 144     return;
 145   }
 146   /* consume the signal */
 147   GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof (c)));
 148   LOG_DEBUG ("Child died\n");
 149   GNUNET_SCHEDULER_cancel (terminate_task_id);
 150   terminate_task_id = NULL;
 151   GNUNET_assert (GNUNET_OK == GNUNET_OS_process_status (child, &child_status,
 152                                                         &child_exit_code));
 153   GNUNET_OS_process_destroy (child);
 154   child = NULL;
 155   GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
 156 }
 157
 158
 159 static void
 160 destroy_hosts(struct GNUNET_TESTBED_Host **hosts, unsigned int nhosts)
 161 {
 162   unsigned int host;
 163
 164   GNUNET_assert (NULL != hosts);
 165   for (host = 0; host < nhosts; host++)
 166     if (NULL != hosts[host])
 167       GNUNET_TESTBED_host_destroy (hosts[host]);
 168   GNUNET_free (hosts);
 169   hosts = NULL;
 170 }
 171
 172
 173 /**
 174  * The main scheduler run task
 175  *
 176  * @param cls NULL
 177  */
 178 static void
 179 run (void *cls)
 180 {
 181   struct GNUNET_TESTBED_Host **hosts;
 182   const struct GNUNET_CONFIGURATION_Handle *null_cfg;
 183   char *tmpdir;
 184   char *hostname;
 185   size_t hostname_len;
 186   unsigned int nhosts;
 187
 188   null_cfg = GNUNET_CONFIGURATION_create ();
 189   nhosts = GNUNET_TESTBED_hosts_load_from_loadleveler (null_cfg, &hosts);
 190   if (0 == nhosts)
 191   {
 192     GNUNET_break (0);
 193     ret = GNUNET_SYSERR;
 194     return;
 195   }
 196   hostname_len = GNUNET_OS_get_hostname_max_length ();
 197   hostname = GNUNET_malloc (hostname_len);
 198   if (0 != gethostname (hostname, hostname_len))
 199   {
 200     LOG (GNUNET_ERROR_TYPE_ERROR, "Cannot get hostname.  Exiting\n");
 201     GNUNET_free (hostname);
 202     destroy_hosts (hosts, nhosts);
 203     ret = GNUNET_SYSERR;
 204     return;
 205   }
 206   if (NULL == strstr (GNUNET_TESTBED_host_get_hostname (hosts[0]), hostname))
 207   {
 208     LOG_DEBUG ("Exiting as `%s' is not the lowest host\n", hostname);
 209     GNUNET_free (hostname);
 210     ret = GNUNET_OK;
 211     return;
 212   }
 213   LOG_DEBUG ("Will be executing `%s' on host `%s'\n", argv2[0], hostname);
 214   GNUNET_free (hostname);
 215   destroy_hosts (hosts, nhosts);
 216   tmpdir = getenv ("TMPDIR");
 217   if (NULL == tmpdir)
 218     tmpdir = getenv ("TMP");
 219   if (NULL == tmpdir)
 220     tmpdir = getenv ("TEMP");
 221   if (NULL == tmpdir)
 222     tmpdir = "/tmp";
 223   (void) GNUNET_asprintf (&fn, "%s/gnunet-testbed-spawn.lock", tmpdir);
 224   /* Open the unique file; we can create it then we can spawn the child process
 225      else we exit */
 226   fh = open (fn, O_CREAT | O_EXCL | O_CLOEXEC,
 227              S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
 228   if (-1 == fh)
 229   {
 230     if (EEXIST == errno)
 231     {
 232       LOG_DEBUG ("Lock file already created by other process.  Exiting\n");
 233       ret = GNUNET_OK;
 234       return;
 235     }
 236     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "open");
 237     ret = GNUNET_SYSERR;
 238     return;
 239   }
 240   /* Spawn the new process here */
 241   LOG (GNUNET_ERROR_TYPE_INFO, _("Spawning process `%s'\n"), argv2[0]);
 242   child = GNUNET_OS_start_process_vap (GNUNET_NO, GNUNET_OS_INHERIT_STD_ALL, NULL,
 243                                        NULL, NULL,
 244                                        argv2[0], argv2);
 245   if (NULL == child)
 246   {
 247     GNUNET_break (0);
 248     ret = GNUNET_SYSERR;
 249     GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
 250     return;
 251   }
 252   ret = GNUNET_OK;
 253   terminate_task_id =
 254       GNUNET_SCHEDULER_add_shutdown (&terminate_task, NULL);
 255   child_death_task_id =
 256     GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
 257                                     GNUNET_DISK_pipe_handle (sigpipe,
 258                                                              GNUNET_DISK_PIPE_END_READ),
 259                                     &child_death_task, NULL);
 260 }
 261
 262
 263 /**
 264  * Signal handler called for SIGCHLD.
 265  */
 266 static void
 267 sighandler_child_death ()
 268 {
 269   static char c;
 270   int old_errno = errno;        /* back-up errno */
 271
 272   GNUNET_break (1 ==
 273                 GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
 274                                         (sigpipe, GNUNET_DISK_PIPE_END_WRITE),
 275                                         &c, sizeof (c)));
 276   errno = old_errno;            /* restore errno */
 277 }
 278
 279
 280 /**
 281  * Execution start point
 282  */
 283 int
 284 main (int argc, char *argv[])
 285 {
 286   struct GNUNET_SIGNAL_Context *shc_chld;
 287   unsigned int cnt;
 288
 289   ret = -1;
 290   if (argc < 2)
 291   {
 292     printf ("Need arguments: gnunet-testbed-mpi-spawn <cmd> <cmd_args>");
 293     return 1;
 294   }
 295   if (GNUNET_OK != GNUNET_log_setup ("gnunet-testbed-spawn", NULL, NULL))
 296   {
 297     GNUNET_break (0);
 298     return 1;
 299   }
 300   if (NULL == (sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO,
 301                                            GNUNET_NO, GNUNET_NO)))
 302   {
 303     GNUNET_break (0);
 304     ret = GNUNET_SYSERR;
 305     return 1;
 306   }
 307   shc_chld =
 308       GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, &sighandler_child_death);
 309   if (NULL == shc_chld)
 310   {
 311     LOG (GNUNET_ERROR_TYPE_ERROR, "Cannot install a signal handler\n");
 312     return 1;
 313   }
 314   argv2 = GNUNET_malloc (sizeof (char *) * argc);
 315   for (cnt = 1; cnt < argc; cnt++)
 316     argv2[cnt - 1] = argv[cnt];
 317   GNUNET_SCHEDULER_run (run, NULL);
 318   GNUNET_free (argv2);
 319   GNUNET_SIGNAL_handler_uninstall (shc_chld);
 320   shc_chld = NULL;
 321   GNUNET_DISK_pipe_close (sigpipe);
 322   GNUNET_free_non_null (fn);
 323   if (GNUNET_OK != ret)
 324     return ret;
 325   return 0;
 326 }