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 } FIX_ALIASING;
  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: can't %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("can't ", 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 & 1) /* -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, (char *) 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         struct dirent *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         pid_t pid;
 221         unsigned deadline;
 222         unsigned now;
 223         unsigned stampcheck;
 224         int i;
 225         int need_rescan = 1;
 226         char *opt_s_argv[3];
 227
 228         INIT_G();
 229
 230         opt_complementary = "-1";
 231         opt_s_argv[0] = NULL;
 232         opt_s_argv[2] = NULL;
 233         getopt32(argv, "Ps:", &opt_s_argv[0]);
 234         argv += optind;
 235
 236         bb_signals(0
 237                 | (1 << SIGTERM)
 238                 | (1 << SIGHUP)
 239                 /* For busybox's init, SIGTERM == reboot,
 240                  * SIGUSR1 == halt
 241                  * SIGUSR2 == poweroff
 242                  * so we need to intercept SIGUSRn too.
 243                  * Note that we do not implement actual reboot
 244                  * (killall(TERM) + umount, etc), we just pause
 245                  * respawing and avoid exiting (-> making kernel oops).
 246                  * The user is responsible for the rest. */
 247                 | (getpid() == 1 ? ((1 << SIGUSR1) | (1 << SIGUSR2)) : 0)
 248                 , record_signo);
 249         svdir = *argv++;
 250
 251 #if ENABLE_FEATURE_RUNSVDIR_LOG
 252         /* setup log */
 253         if (*argv) {
 254                 rplog = *argv;
 255                 rploglen = strlen(rplog);
 256                 if (rploglen < 7) {
 257                         warnx("log must have at least seven characters");
 258                 } else if (piped_pair(logpipe)) {
 259                         warnx("can't create pipe for log");
 260                 } else {
 261                         close_on_exec_on(logpipe.rd);
 262                         close_on_exec_on(logpipe.wr);
 263                         ndelay_on(logpipe.rd);
 264                         ndelay_on(logpipe.wr);
 265                         if (dup2(logpipe.wr, 2) == -1) {
 266                                 warnx("can't set filedescriptor for log");
 267                         } else {
 268                                 pfd[0].fd = logpipe.rd;
 269                                 pfd[0].events = POLLIN;
 270                                 stamplog = monotonic_sec();
 271                                 goto run;
 272                         }
 273                 }
 274                 rplog = NULL;
 275                 warnx("log service disabled");
 276         }
 277  run:
 278 #endif
 279         curdir = open(".", O_RDONLY|O_NDELAY);
 280         if (curdir == -1)
 281                 fatal2_cannot("open current directory", "");
 282         close_on_exec_on(curdir);
 283
 284         stampcheck = monotonic_sec();
 285
 286         for (;;) {
 287                 /* collect children */
 288                 for (;;) {
 289                         pid = wait_any_nohang(&wstat);
 290                         if (pid <= 0)
 291                                 break;
 292                         for (i = 0; i < svnum; i++) {
 293                                 if (pid == sv[i].pid) {
 294                                         /* runsv has died */
 295                                         sv[i].pid = 0;
 296                                         need_rescan = 1;
 297                                 }
 298                         }
 299                 }
 300
 301                 now = monotonic_sec();
 302                 if ((int)(now - stampcheck) >= 0) {
 303                         /* wait at least a second */
 304                         stampcheck = now + 1;
 305
 306                         if (stat(svdir, &s) != -1) {
 307                                 if (need_rescan || s.st_mtime != last_mtime
 308                                  || s.st_ino != last_ino || s.st_dev != last_dev
 309                                 ) {
 310                                         /* svdir modified */
 311                                         if (chdir(svdir) != -1) {
 312                                                 last_mtime = s.st_mtime;
 313                                                 last_dev = s.st_dev;
 314                                                 last_ino = s.st_ino;
 315                                                 /* if the svdir changed this very second, wait until the
 316                                                  * next second, because we won't be able to detect more
 317                                                  * changes within this second */
 318                                                 while (time(NULL) == last_mtime)
 319                                                         usleep(100000);
 320                                                 need_rescan = do_rescan();
 321                                                 while (fchdir(curdir) == -1) {
 322                                                         warn2_cannot("change directory, pausing", "");
 323                                                         sleep(5);
 324                                                 }
 325                                         } else {
 326                                                 warn2_cannot("change directory to ", svdir);
 327                                         }
 328                                 }
 329                         } else {
 330                                 warn2_cannot("stat ", svdir);
 331                         }
 332                 }
 333
 334 #if ENABLE_FEATURE_RUNSVDIR_LOG
 335                 if (rplog) {
 336                         if ((int)(now - stamplog) >= 0) {
 337                                 write(logpipe.wr, ".", 1);
 338                                 stamplog = now + 900;
 339                         }
 340                 }
 341                 pfd[0].revents = 0;
 342 #endif
 343                 deadline = (need_rescan ? 1 : 5);
 344                 sig_block(SIGCHLD);
 345 #if ENABLE_FEATURE_RUNSVDIR_LOG
 346                 if (rplog)
 347                         poll(pfd, 1, deadline*1000);
 348                 else
 349 #endif
 350                         sleep(deadline);
 351                 sig_unblock(SIGCHLD);
 352
 353 #if ENABLE_FEATURE_RUNSVDIR_LOG
 354                 if (pfd[0].revents & POLLIN) {
 355                         char ch;
 356                         while (read(logpipe.rd, &ch, 1) > 0) {
 357                                 if (ch < ' ')
 358                                         ch = ' ';
 359                                 for (i = 6; i < rploglen; i++)
 360                                         rplog[i-1] = rplog[i];
 361                                 rplog[rploglen-1] = ch;
 362                         }
 363                 }
 364 #endif
 365                 if (!bb_got_signal)
 366                         continue;
 367
 368                 /* -s SCRIPT: useful if we are init.
 369                  * In this case typically script never returns,
 370                  * it halts/powers off/reboots the system. */
 371                 if (opt_s_argv[0]) {
 372                         /* Single parameter: signal# */
 373                         opt_s_argv[1] = utoa(bb_got_signal);
 374                         pid = spawn(opt_s_argv);
 375                         if (pid > 0) {
 376                                 /* Remembering to wait for _any_ children,
 377                                  * not just pid */
 378                                 while (wait(NULL) != pid)
 379                                         continue;
 380                         }
 381                 }
 382
 383                 if (bb_got_signal == SIGHUP) {
 384                         for (i = 0; i < svnum; i++)
 385                                 if (sv[i].pid)
 386                                         kill(sv[i].pid, SIGTERM);
 387                 }
 388                 /* SIGHUP or SIGTERM (or SIGUSRn if we are init) */
 389                 /* Exit unless we are init */
 390                 if (getpid() != 1)
 391                         return (SIGHUP == bb_got_signal) ? 111 : EXIT_SUCCESS;
 392
 393                 /* init continues to monitor services forever */
 394                 bb_got_signal = 0;
 395         } /* for (;;) */
 396 }