runit/runsvdir.c

   1 /*
   2 Copyright (c) 2001-2006, Gerrit Pape
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions are met:
   7
   8    1. Redistributions of source code must retain the above copyright notice,
   9       this list of conditions and the following disclaimer.
  10    2. Redistributions in binary form must reproduce the above copyright
  11       notice, this list of conditions and the following disclaimer in the
  12       documentation and/or other materials provided with the distribution.
  13    3. The name of the author may not be used to endorse or promote products
  14       derived from this software without specific prior written permission.
  15
  16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19 EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22 OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27
  28 /* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
  29 /* TODO: depends on runit_lib.c - review and reduce/eliminate */
  30
  31 #include <sys/poll.h>
  32 #include <sys/file.h>
  33 #include "libbb.h"
  34 #include "runit_lib.h"
  35
  36 #define MAXSERVICES 1000
  37
  38 /* Should be not needed - all dirs are on same FS, right? */
  39 #define CHECK_DEVNO_TOO 0
  40
  41 struct service {
  42 #if CHECK_DEVNO_TOO
  43         dev_t dev;
  44 #endif
  45         ino_t ino;
  46         pid_t pid;
  47         smallint isgone;
  48 };
  49
  50 struct globals {
  51         struct service *sv;
  52         char *svdir;
  53         int svnum;
  54 #if ENABLE_FEATURE_RUNSVDIR_LOG
  55         char *rplog;
  56         int rploglen;
  57         struct fd_pair logpipe;
  58         struct pollfd pfd[1];
  59         unsigned stamplog;
  60 #endif
  61 };
  62 #define G (*(struct globals*)&bb_common_bufsiz1)
  63 #define sv          (G.sv          )
  64 #define svdir       (G.svdir       )
  65 #define svnum       (G.svnum       )
  66 #define rplog       (G.rplog       )
  67 #define rploglen    (G.rploglen    )
  68 #define logpipe     (G.logpipe     )
  69 #define pfd         (G.pfd         )
  70 #define stamplog    (G.stamplog    )
  71 #define INIT_G() do { \
  72 } while (0)
  73
  74 static void fatal2_cannot(const char *m1, const char *m2)
  75 {
  76         bb_perror_msg_and_die("%s: fatal: cannot %s%s", svdir, m1, m2);
  77         /* was exiting 100 */
  78 }
  79 static void warn3x(const char *m1, const char *m2, const char *m3)
  80 {
  81         bb_error_msg("%s: warning: %s%s%s", svdir, m1, m2, m3);
  82 }
  83 static void warn2_cannot(const char *m1, const char *m2)
  84 {
  85         warn3x("cannot ", m1, m2);
  86 }
  87 #if ENABLE_FEATURE_RUNSVDIR_LOG
  88 static void warnx(const char *m1)
  89 {
  90         warn3x(m1, "", "");
  91 }
  92 #endif
  93
  94 /* inlining + vfork -> bigger code */
  95 static NOINLINE pid_t runsv(const char *name)
  96 {
  97         pid_t pid;
  98
  99         /* If we got signaled, stop spawning children at once! */
 100         if (bb_got_signal)
 101                 return 0;
 102
 103         pid = vfork();
 104         if (pid == -1) {
 105                 warn2_cannot("vfork", "");
 106                 return 0;
 107         }
 108         if (pid == 0) {
 109                 /* child */
 110                 if (option_mask32) /* -P option? */
 111                         setsid();
 112 /* man execv:
 113  * "Signals set to be caught by the calling process image
 114  *  shall be set to the default action in the new process image."
 115  * Therefore, we do not need this: */
 116 #if 0
 117                 bb_signals(0
 118                         | (1 << SIGHUP)
 119                         | (1 << SIGTERM)
 120                         , SIG_DFL);
 121 #endif
 122                 execlp("runsv", "runsv", name, NULL);
 123                 fatal2_cannot("start runsv ", name);
 124         }
 125         return pid;
 126 }
 127
 128 /* gcc 4.3.0 does better with NOINLINE */
 129 static NOINLINE int do_rescan(void)
 130 {
 131         DIR *dir;
 132         direntry *d;
 133         int i;
 134         struct stat s;
 135         int need_rescan = 0;
 136
 137         dir = opendir(".");
 138         if (!dir) {
 139                 warn2_cannot("open directory ", svdir);
 140                 return 1; /* need to rescan again soon */
 141         }
 142         for (i = 0; i < svnum; i++)
 143                 sv[i].isgone = 1;
 144
 145         while (1) {
 146                 errno = 0;
 147                 d = readdir(dir);
 148                 if (!d)
 149                         break;
 150                 if (d->d_name[0] == '.')
 151                         continue;
 152                 if (stat(d->d_name, &s) == -1) {
 153                         warn2_cannot("stat ", d->d_name);
 154                         continue;
 155                 }
 156                 if (!S_ISDIR(s.st_mode))
 157                         continue;
 158                 /* Do we have this service listed already? */
 159                 for (i = 0; i < svnum; i++) {
 160                         if ((sv[i].ino == s.st_ino)
 161 #if CHECK_DEVNO_TOO
 162                          && (sv[i].dev == s.st_dev)
 163 #endif
 164                         ) {
 165                                 if (sv[i].pid == 0) /* restart if it has died */
 166                                         goto run_ith_sv;
 167                                 sv[i].isgone = 0; /* "we still see you" */
 168                                 goto next_dentry;
 169                         }
 170                 }
 171                 { /* Not found, make new service */
 172                         struct service *svnew = realloc(sv, (i+1) * sizeof(*sv));
 173                         if (!svnew) {
 174                                 warn2_cannot("start runsv ", d->d_name);
 175                                 need_rescan = 1;
 176                                 continue;
 177                         }
 178                         sv = svnew;
 179                         svnum++;
 180 #if CHECK_DEVNO_TOO
 181                         sv[i].dev = s.st_dev;
 182 #endif
 183                         sv[i].ino = s.st_ino;
 184  run_ith_sv:
 185                         sv[i].pid = runsv(d->d_name);
 186                         sv[i].isgone = 0;
 187                 }
 188  next_dentry: ;
 189         }
 190         i = errno;
 191         closedir(dir);
 192         if (i) { /* readdir failed */
 193                 warn2_cannot("read directory ", svdir);
 194                 return 1; /* need to rescan again soon */
 195         }
 196
 197         /* Send SIGTERM to runsv whose directories
 198          * were no longer found (-> must have been removed) */
 199         for (i = 0; i < svnum; i++) {
 200                 if (!sv[i].isgone)
 201                         continue;
 202                 if (sv[i].pid)
 203                         kill(sv[i].pid, SIGTERM);
 204                 svnum--;
 205                 sv[i] = sv[svnum];
 206                 i--; /* so that we don't skip new sv[i] (bug was here!) */
 207         }
 208         return need_rescan;
 209 }
 210
 211 int runsvdir_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 212 int runsvdir_main(int argc UNUSED_PARAM, char **argv)
 213 {
 214         struct stat s;
 215         dev_t last_dev = last_dev; /* for gcc */
 216         ino_t last_ino = last_ino; /* for gcc */
 217         time_t last_mtime = 0;
 218         int wstat;
 219         int curdir;
 220         int pid;
 221         unsigned deadline;
 222         unsigned now;
 223         unsigned stampcheck;
 224         int i;
 225         int need_rescan = 1;
 226
 227         INIT_G();
 228
 229         opt_complementary = "-1";
 230         getopt32(argv, "P");
 231         argv += optind;
 232
 233         bb_signals(0
 234                 | (1 << SIGTERM)
 235                 | (1 << SIGHUP)
 236                 /* For busybox's init, SIGTERM == reboot,
 237                  * SIGUSR1 == halt
 238                  * SIGUSR2 == poweroff
 239                  * so we need to intercept SIGUSRn too.
 240                  * Note that we do not implement actual reboot
 241                  * (killall(TERM) + umount, etc), we just pause
 242                  * respawing and avoid exiting (-> making kernel oops).
 243                  * The user is responsible for the rest. */
 244                 | (getpid() == 1 ? ((1 << SIGUSR1) | (1 << SIGUSR2)) : 0)
 245                 , record_signo);
 246         svdir = *argv++;
 247
 248 #if ENABLE_FEATURE_RUNSVDIR_LOG
 249         /* setup log */
 250         if (*argv) {
 251                 rplog = *argv;
 252                 rploglen = strlen(rplog);
 253                 if (rploglen < 7) {
 254                         warnx("log must have at least seven characters");
 255                 } else if (piped_pair(logpipe)) {
 256                         warnx("cannot create pipe for log");
 257                 } else {
 258                         close_on_exec_on(logpipe.rd);
 259                         close_on_exec_on(logpipe.wr);
 260                         ndelay_on(logpipe.rd);
 261                         ndelay_on(logpipe.wr);
 262                         if (dup2(logpipe.wr, 2) == -1) {
 263                                 warnx("cannot set filedescriptor for log");
 264                         } else {
 265                                 pfd[0].fd = logpipe.rd;
 266                                 pfd[0].events = POLLIN;
 267                                 stamplog = monotonic_sec();
 268                                 goto run;
 269                         }
 270                 }
 271                 rplog = NULL;
 272                 warnx("log service disabled");
 273         }
 274  run:
 275 #endif
 276         curdir = open_read(".");
 277         if (curdir == -1)
 278                 fatal2_cannot("open current directory", "");
 279         close_on_exec_on(curdir);
 280
 281         stampcheck = monotonic_sec();
 282
 283         for (;;) {
 284                 /* collect children */
 285                 for (;;) {
 286                         pid = wait_any_nohang(&wstat);
 287                         if (pid <= 0)
 288                                 break;
 289                         for (i = 0; i < svnum; i++) {
 290                                 if (pid == sv[i].pid) {
 291                                         /* runsv has died */
 292                                         sv[i].pid = 0;
 293                                         need_rescan = 1;
 294                                 }
 295                         }
 296                 }
 297
 298                 now = monotonic_sec();
 299                 if ((int)(now - stampcheck) >= 0) {
 300                         /* wait at least a second */
 301                         stampcheck = now + 1;
 302
 303                         if (stat(svdir, &s) != -1) {
 304                                 if (need_rescan || s.st_mtime != last_mtime
 305                                  || s.st_ino != last_ino || s.st_dev != last_dev
 306                                 ) {
 307                                         /* svdir modified */
 308                                         if (chdir(svdir) != -1) {
 309                                                 last_mtime = s.st_mtime;
 310                                                 last_dev = s.st_dev;
 311                                                 last_ino = s.st_ino;
 312                                                 //if (now <= mtime)
 313                                                 //      sleep(1);
 314                                                 need_rescan = do_rescan();
 315                                                 while (fchdir(curdir) == -1) {
 316                                                         warn2_cannot("change directory, pausing", "");
 317                                                         sleep(5);
 318                                                 }
 319                                         } else {
 320                                                 warn2_cannot("change directory to ", svdir);
 321                                         }
 322                                 }
 323                         } else {
 324                                 warn2_cannot("stat ", svdir);
 325                         }
 326                 }
 327
 328 #if ENABLE_FEATURE_RUNSVDIR_LOG
 329                 if (rplog) {
 330                         if ((int)(now - stamplog) >= 0) {
 331                                 write(logpipe.wr, ".", 1);
 332                                 stamplog = now + 900;
 333                         }
 334                 }
 335                 pfd[0].revents = 0;
 336 #endif
 337                 deadline = (need_rescan ? 1 : 5);
 338  do_sleep:
 339                 sig_block(SIGCHLD);
 340 #if ENABLE_FEATURE_RUNSVDIR_LOG
 341                 if (rplog)
 342                         poll(pfd, 1, deadline*1000);
 343                 else
 344 #endif
 345                         sleep(deadline);
 346                 sig_unblock(SIGCHLD);
 347
 348 #if ENABLE_FEATURE_RUNSVDIR_LOG
 349                 if (pfd[0].revents & POLLIN) {
 350                         char ch;
 351                         while (read(logpipe.rd, &ch, 1) > 0) {
 352                                 if (ch < ' ')
 353                                         ch = ' ';
 354                                 for (i = 6; i < rploglen; i++)
 355                                         rplog[i-1] = rplog[i];
 356                                 rplog[rploglen-1] = ch;
 357                         }
 358                 }
 359 #endif
 360                 switch (bb_got_signal) {
 361                 case 0: /* we are not signaled, business as usual */
 362                         break;
 363                 case SIGHUP:
 364                         for (i = 0; i < svnum; i++)
 365                                 if (sv[i].pid)
 366                                         kill(sv[i].pid, SIGTERM);
 367                         /* fall through */
 368                 case SIGTERM:
 369                         /* exit, unless we are init */
 370                         if (getpid() != 1)
 371                                 goto ret;
 372                 default:
 373                         /* so we are init. do not exit,
 374                          * and pause respawning - we may be rebooting
 375                          * (but SIGHUP is not a reboot, make short pause) */
 376                         deadline = (SIGHUP == bb_got_signal) ? 5 : 60;
 377                         bb_got_signal = 0;
 378                         goto do_sleep;
 379                 }
 380         }
 381  ret:
 382         return (SIGHUP == bb_got_signal) ? 111 : EXIT_SUCCESS;
 383 }