init: major improvement in documentation and signal handling.

Lots of nasty, but hard to trip, races are fixed. text data bss dec hex filename 1038828 924 10932 1050684 10083c busybox_old 1038787 924 10932 1050643 100813 busybox_unstripped
author: Denis Vlasenko <vda.linux@googlemail.com> 2009-01-31 01:03:45 +0000
committer: Denis Vlasenko <vda.linux@googlemail.com> 2009-01-31 01:03:45 +0000
commit: 72c99af0b44e150a712891f6a3ea7d41827cfffe (patch)
tree: efd1f29d140f906deca0e8816e6b50ff2e87a77f /init/init.c
parent: cab28aa7de336b0a39ef43ce0eb035a2cab30d4d (diff)
download: busybox-w32-72c99af0b44e150a712891f6a3ea7d41827cfffe.tar.gz
busybox-w32-72c99af0b44e150a712891f6a3ea7d41827cfffe.tar.bz2
busybox-w32-72c99af0b44e150a712891f6a3ea7d41827cfffe.zip
1 files changed, 374 insertions, 297 deletions
diff --git a/init/init.c b/init/init.c
index 6af6830e4..3a02ece4b 100644
--- a/init/init.c
+++ b/init/init.c
@@ -15,6 +15,7 @@
 #include <sys/reboot.h>
 #include <sys/resource.h>
 /* Was a CONFIG_xxx option. A lot of people were building
 * not fully functional init by switching it on! */
 #define DEBUG_INIT 0
@@ -22,22 +23,53 @@
 #define COMMAND_SIZE      256
 #define CONSOLE_NAME_SIZE 32
+/* Default sysinit script. */
 #ifndef INIT_SCRIPT
-#define INIT_SCRIPT  "/etc/init.d/rcS"  /* Default sysinit script. */
+#define INIT_SCRIPT  "/etc/init.d/rcS"
 #endif
-/* Allowed init action types */
+/* Each type of actions can appear many times. They will be
+ * handled in order. RESTART is an exception, only 1st is used.
+ */
+/* Start these actions first and wait for completion */
 #define SYSINIT     0x01
-#define RESPAWN     0x02
+/* Start these after SYSINIT and wait for completion */
-/* like respawn, but wait for <Enter> to be pressed on tty: */
+#define WAIT        0x02
-#define ASKFIRST    0x04
+/* Start these after WAIT and *dont* wait for completion */
-#define WAIT        0x08
+#define ONCE        0x04
-#define ONCE        0x10
+/*
+ * NB: while SYSINIT/WAIT/ONCE are being processed,
+ * SIGHUP ("reread /etc/inittab") will be ignored.
+ * Rationale: it would be ambiguous whether SYSINIT/WAIT/ONCE
+ * need to be rerun or not.
+ */
+/* Start these after ONCE are started, restart on exit */
+#define RESPAWN     0x08
+/* Like RESPAWN, but wait for <Enter> to be pressed on tty */
+#define ASKFIRST    0x10
+/*
+ * Start these on SIGINT, and wait for completion.
+ * Then go back to respawning RESPAWN and ASKFIRST actions.
+ * NB: kernel sends SIGINT to us if Ctrl-Alt-Del was pressed.
+ */
 #define CTRLALTDEL  0x20
+/*
+ * Start these before killing all processes in preparation for
+ * running RESTART actions or doing low-level halt/reboot/poweroff
+ * (initiated by SIGUSR1/SIGTERM/SIGUSR2).
+ * Wait for completion before proceeding.
+ */
 #define SHUTDOWN    0x40
+/*
+ * exec() on SIGQUIT. SHUTDOWN actions are started and waited for,
+ * then all processes are killed, then init exec's 1st RESTART action,
+ * replacing itself by it. If no RESTART action specified,
+ * SIGQUIT has no effect.
+ */
 #define RESTART     0x80
-/* Set up a linked list of init_actions, to be read from inittab */
+/* A linked list of init_actions, to be read from inittab */
 struct init_action {
        struct init_action *next;
        pid_t pid;
@@ -65,13 +97,6 @@ enum {
 static void halt_reboot_pwoff(int sig) NORETURN;
-static void loop_forever(void) NORETURN;
-static void loop_forever(void)
-{
-        while (1)
-                sleep(1);
-}
 /* Print a message to the specified device.
 * "where" may be bitwise-or'd from L_LOG | L_CONSOLE
 * NB: careful, we can be called after vfork!
@@ -241,6 +266,7 @@ static void open_stdio_to_tty(const char* tty_name, int exit_on_failure)
        /* empty tty_name means "use init's tty", else... */
        if (tty_name[0]) {
                int fd;
                close(STDIN_FILENO);
                /* fd can be only < 0 or 0: */
                fd = device_open(tty_name, O_RDWR);
@@ -252,7 +278,8 @@ static void open_stdio_to_tty(const char* tty_name, int exit_on_failure)
                        if (DEBUG_INIT)
                                _exit(2);
                        /* NB: we don't reach this if we were called after vfork.
-                         * Thus halt_reboot_pwoff() itself need not be vfork-safe. */
+                         * Thus halt_reboot_pwoff() itself needs not be vfork-safe.
+                         */
                        halt_reboot_pwoff(SIGUSR1); /* halt the system */
                }
                dup2(STDIN_FILENO, STDOUT_FILENO);
@@ -313,89 +340,37 @@ static void init_exec(const char *command)
 static pid_t run(const struct init_action *a)
 {
        pid_t pid;
-        sigset_t nmask, omask;
-        /* Block sigchild while forking (why?) */
-        sigemptyset(&nmask);
-        sigaddset(&nmask, SIGCHLD);
-        sigprocmask(SIG_BLOCK, &nmask, &omask);
        if (BB_MMU && (a->action_type & ASKFIRST))
                pid = fork();
        else
                pid = vfork();
-        sigprocmask(SIG_SETMASK, &omask, NULL);
        if (pid < 0)
                message(L_LOG | L_CONSOLE, "can't fork");
        if (pid)
-                return pid;
+                return pid; /* Parent or error */
        /* Child */
        /* Reset signal handlers that were set by the parent process */
+//TODO: block signals across fork(), prevent them to affect child before
+//signals are reset?
        bb_signals(0
                + (1 << SIGUSR1)
                + (1 << SIGUSR2)
-                + (1 << SIGINT)
                + (1 << SIGTERM)
-                + (1 << SIGHUP)
                + (1 << SIGQUIT)
-                + (1 << SIGCONT)
+                + (1 << SIGINT)
-                + (1 << SIGSTOP)
+                + (1 << SIGHUP)
                + (1 << SIGTSTP)
                , SIG_DFL);
-        /* Create a new session and make ourself the process
+        /* Create a new session and make ourself the process group leader */
-         * group leader */
        setsid();
        /* Open the new terminal device */
        open_stdio_to_tty(a->terminal, 1 /* - exit if open fails */);
-// NB: do not enable unless you change vfork to fork above
-#ifdef BUT_RUN_ACTIONS_ALREADY_DOES_WAITING
-        /* If the init Action requires us to wait, then force the
-         * supplied terminal to be the controlling tty. */
-        if (a->action_type & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) {
-                /* Now fork off another process to just hang around */
-                pid = fork();
-                if (pid < 0) {
-                        message(L_LOG | L_CONSOLE, "can't fork");
-                        _exit(EXIT_FAILURE);
-                }
-                if (pid > 0) {
-                        /* Parent - wait till the child is done */
-                        bb_signals(0
-                                + (1 << SIGINT)
-                                + (1 << SIGTSTP)
-                                + (1 << SIGQUIT)
-                                , SIG_IGN);
-                        signal(SIGCHLD, SIG_DFL);
-                        waitfor(pid);
-                        /* See if stealing the controlling tty back is necessary */
-                        if (tcgetpgrp(0) != getpid())
-                                _exit(EXIT_SUCCESS);
-                        /* Use a temporary process to steal the controlling tty. */
-                        pid = fork();
-                        if (pid < 0) {
-                                message(L_LOG | L_CONSOLE, "can't fork");
-                                _exit(EXIT_FAILURE);
-                        }
-                        if (pid == 0) {
-                                setsid();
-                                ioctl(0, TIOCSCTTY, 1);
-                                _exit(EXIT_SUCCESS);
-                        }
-                        waitfor(pid);
-                        _exit(EXIT_SUCCESS);
-                }
-                /* Child - fall though to actually execute things */
-        }
-#endif
        /* NB: on NOMMU we can't wait for input in child, so
         * "askfirst" will work the same as "respawn". */
        if (BB_MMU && (a->action_type & ASKFIRST)) {
@@ -449,21 +424,32 @@ static pid_t run(const struct init_action *a)
 static void delete_init_action(struct init_action *action)
 {
-        struct init_action *a, *b = NULL;
+        struct init_action *a, **nextp;
-        for (a = init_action_list; a; b = a, a = a->next) {
+        nextp = &init_action_list;
+        while ((a = *nextp) != NULL) {
                if (a == action) {
-                        if (b == NULL) {
+                        *nextp = a->next;
-                                init_action_list = a->next;
-                        } else {
-                                b->next = a->next;
-                        }
                        free(a);
                        break;
                }
+                nextp = &a->next;
        }
 }
+static struct init_action *mark_terminated(int pid)
+{
+        struct init_action *a;
+        for (a = init_action_list; a; a = a->next) {
+                if (a->pid == pid) {
+                        a->pid = 0;
+                        return a;
+                }
+        }
+        return NULL;
+}
 static void waitfor(pid_t pid)
 {
        /* waitfor(run(x)): protect against failed fork inside run() */
@@ -472,176 +458,71 @@ static void waitfor(pid_t pid)
        /* Wait for any child (prevent zombies from exiting orphaned processes)
         * but exit the loop only when specified one has exited. */
-        while (wait(NULL) != pid)
+        while (1) {
-                continue;
+                pid_t wpid = wait(NULL);
+                mark_terminated(wpid);
+                /* Unsafe. SIGTSTP handler might have wait'ed it already */
+                /*if (wpid == pid) break;*/
+                /* More reliable */
+                if (kill(pid, 0))
+                        break;
+        }
 }
 /* Run all commands of a particular type */
 static void run_actions(int action_type)
 {
-        struct init_action *a, *tmp;
-        for (a = init_action_list; a; a = tmp) {
-                tmp = a->next;
-                if (a->action_type & action_type) {
-                        // Pointless: run() will error out if open of device fails.
-                        ///* a->terminal of "" means "init's console" */
-                        //if (a->terminal[0] && access(a->terminal, R_OK | W_OK)) {
-                        //      //message(L_LOG | L_CONSOLE, "Device %s cannot be opened in RW mode", a->terminal /*, strerror(errno)*/);
-                        //      delete_init_action(a);
-                        //} else
-                        if (a->action_type & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) {
-                                waitfor(run(a));
-                                delete_init_action(a);
-                        } else if (a->action_type & ONCE) {
-                                run(a);
-                                delete_init_action(a);
-                        } else if (a->action_type & (RESPAWN | ASKFIRST)) {
-                                /* Only run stuff with pid==0.  If they have
-                                 * a pid, that means it is still running */
-                                if (a->pid == 0) {
-                                        a->pid = run(a);
-                                }
-                        }
-                }
-        }
-}
-static void low_level_reboot(unsigned long magic)
-{
-        pid_t pid;
-        /* We have to fork here, since the kernel calls do_exit(EXIT_SUCCESS) in
-         * linux/kernel/sys.c, which can cause the machine to panic when
-         * the init process is killed.... */
-        pid = vfork();
-        if (pid == 0) { /* child */
-                reboot(magic);
-                _exit(EXIT_SUCCESS);
-        }
-        waitfor(pid);
-}
-static void kill_all_processes(void)
-{
-        /* run everything to be run at "shutdown".  This is done _prior_
-         * to killing everything, in case people wish to use scripts to
-         * shut things down gracefully... */
-        run_actions(SHUTDOWN);
-        /* first disable all our signals */
-        sigprocmask_allsigs(SIG_BLOCK);
-        message(L_CONSOLE | L_LOG, "The system is going down NOW!");
-        /* Allow Ctrl-Alt-Del to reboot system. */
-        low_level_reboot(RB_ENABLE_CAD);
-        /* Send signals to every process _except_ pid 1 */
-        message(L_CONSOLE | L_LOG, "Sending SIG%s to all processes", "TERM");
-        kill(-1, SIGTERM);
-        sync();
-        sleep(1);
-        message(L_CONSOLE | L_LOG, "Sending SIG%s to all processes", "KILL");
-        kill(-1, SIGKILL);
-        sync();
-        sleep(1);
-}
-static void halt_reboot_pwoff(int sig)
-{
-        const char *m = "halt";
-        int rb;
-        kill_all_processes();
-        rb = RB_HALT_SYSTEM;
-        if (sig == SIGTERM) {
-                m = "reboot";
-                rb = RB_AUTOBOOT;
-        } else if (sig == SIGUSR2) {
-                m = "poweroff";
-                rb = RB_POWER_OFF;
-        }
-        message(L_CONSOLE | L_LOG, "Requesting system %s", m);
-        /* allow time for last message to reach serial console */
-        sleep(2);
-        low_level_reboot(rb);
-        loop_forever();
-}
-/* Handler for QUIT - exec "restart" action,
- * else (no such action defined) do nothing */
-static void restart_handler(int sig UNUSED_PARAM)
-{
        struct init_action *a;
        for (a = init_action_list; a; a = a->next) {
-                if (a->action_type & RESTART) {
+                if (!(a->action_type & action_type))
-                        kill_all_processes();
+                        continue;
-                        /* unblock all signals (blocked in kill_all_processes()) */
-                        sigprocmask_allsigs(SIG_UNBLOCK);
-                        /* Open the new terminal device */
-                        open_stdio_to_tty(a->terminal, 0 /* - halt if open fails */);
-                        messageD(L_CONSOLE | L_LOG, "Trying to re-exec %s", a->command);
+                if (a->action_type & (SYSINIT | WAIT | ONCE | CTRLALTDEL | SHUTDOWN)) {
-                        init_exec(a->command);
+                        pid_t pid = run(a);
-                        sleep(2);
+                        if (a->action_type & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN))
-                        low_level_reboot(RB_HALT_SYSTEM);
+                                waitfor(pid);
-                        loop_forever();
+                }
+                if (a->action_type & (RESPAWN | ASKFIRST)) {
+                        /* Only run stuff with pid == 0. If pid != 0,
+                         * it is already running
+                         */
+                        if (a->pid == 0)
+                                a->pid = run(a);
                }
        }
 }
-static void ctrlaltdel_signal(int sig UNUSED_PARAM)
-{
-        run_actions(CTRLALTDEL);
-}
-/* The SIGCONT handler is set to record_signo().
- * It just sets bb_got_signal = SIGCONT.  */
-/* The SIGSTOP & SIGTSTP handler */
-static void stop_handler(int sig UNUSED_PARAM)
-{
-        int saved_errno = errno;
-        bb_got_signal = 0;
-        while (bb_got_signal == 0)
-                pause();
-        errno = saved_errno;
-}
 static void new_init_action(uint8_t action_type, const char *command, const char *cons)
 {
-        struct init_action *a, *last;
+        struct init_action *a, **nextp;
-// Why?
+//BUG
-//      if (strcmp(cons, bb_dev_null) == 0 && (action & ASKFIRST))
+//old:
-//              return;
+//::shutdown:umount -a -r
+//::shutdown:swapoff -a
-        /* Append to the end of the list */
+//new: swapped:
-        for (a = last = init_action_list; a; a = a->next) {
+//::shutdown:swapoff -a
-                /* don't enter action if it's already in the list,
+//::shutdown:umount -a -r
-                 * but do overwrite existing actions */
+//on SIGHUP, new one will be loaded, but order will be wrong.
+        nextp = &init_action_list;
+        while ((a = *nextp) != NULL) {
+                /* Don't enter action if it's already in the list,
+                 * just overwrite existing one's type.
+                 * This prevents losing running RESPAWNs.
+                 */
                if ((strcmp(a->command, command) == 0)
                 && (strcmp(a->terminal, cons) == 0)
                ) {
                        a->action_type = action_type;
                        return;
                }
-                last = a;
+                nextp = &a->next;
        }
+        /* Append to the end of the list */
        a = xzalloc(sizeof(*a));
-        if (last) {
+        *nextp = a;
-                last->next = a;
-        } else {
-                init_action_list = a;
-        }
        a->action_type = action_type;
        safe_strncpy(a->command, command, sizeof(a->command));
        safe_strncpy(a->terminal, cons, sizeof(a->terminal));
@@ -665,7 +546,7 @@ static void parse_inittab(void)
        if (parser == NULL)
 #endif
        {
-                /* No inittab file -- set up some default behavior */
+                /* No inittab file - set up some default behavior */
                /* Reboot on Ctrl-Alt-Del */
                new_init_action(CTRLALTDEL, "reboot", "");
                /* Umount all filesystems on halt/reboot */
@@ -694,7 +575,7 @@ static void parse_inittab(void)
                                PARSE_NORMAL & ~(PARSE_TRIM | PARSE_COLLAPSE))) {
                /* order must correspond to SYSINIT..RESTART constants */
                static const char actions[] ALIGN1 =
-                        "sysinit\0""respawn\0""askfirst\0""wait\0""once\0"
+                        "sysinit\0""wait\0""once\0""respawn\0""askfirst\0"
                        "ctrlaltdel\0""shutdown\0""restart\0";
                int action;
                char *tty = token[0];
@@ -722,14 +603,172 @@ static void parse_inittab(void)
 #endif
 }
+static void low_level_reboot(unsigned magic) NORETURN;
+static void low_level_reboot(unsigned magic)
+{
+        pid_t pid;
+        /* Allow time for last message to reach serial console, etc */
+        sleep(1);
+        /* We have to fork here, since the kernel calls do_exit(EXIT_SUCCESS)
+         * in linux/kernel/sys.c, which can cause the machine to panic when
+         * the init process exits... */
+        pid = vfork();
+        if (pid == 0) { /* child */
+                reboot(magic);
+                _exit(EXIT_SUCCESS);
+        }
+        waitfor(pid);
+        while (1)
+                sleep(1);
+}
+static void kill_all_processes(void)
+{
+        /* Run everything to be run at "shutdown".  This is done _prior_
+         * to killing everything, in case people wish to use scripts to
+         * shut things down gracefully... */
+        run_actions(SHUTDOWN);
+        message(L_CONSOLE | L_LOG, "The system is going down NOW!");
+        /* Allow Ctrl-Alt-Del to reboot system. */
+        reboot(RB_ENABLE_CAD); /* misnomer */
+        /* Send signals to every process _except_ pid 1 */
+        message(L_CONSOLE | L_LOG, "Sending SIG%s to all processes", "TERM");
+        kill(-1, SIGTERM);
+        sync();
+        sleep(1);
+        message(L_CONSOLE, "Sending SIG%s to all processes", "KILL");
+        kill(-1, SIGKILL);
+        sync();
+        sleep(1);
+}
+/* Signal handling by init:
+ *
+ * For process with PID==1, on entry kernel sets all signals to SIG_DFL
+ * and unmasks all signals. However, for process with PID==1,
+ * default action (SIG_DFL) on any signal is to ignore it,
+ * even for special signals SIGKILL and SIGCONT.
+ * (SIGSTOP is still handled specially, at least in 2.6.20)
+ * Also, any signal can be caught or blocked.
+ *
+ * We install two kinds of handlers, "immediate" and "delayed".
+ *
+ * Immediate handlers execute at any time, even while, say, sysinit
+ * is running.
+ *
+ * Delayed handlers just set a flag variable. The variable is checked
+ * in the main loop and acted upon.
+ *
+ * halt/poweroff/reboot and restart have immediate handlers.
+ * They only traverse linked list of struct action's, never modify it,
+ * this should be safe to do even in signal handler. Also they
+ * never return.
+ *
+ * SIGSTOP and SIGTSTP have immediate handlers. They just wait
+ * for SIGCONT to happen.
+ *
+ * SIGHUP has a delayed handler, because modifying linked list
+ * of struct action's from a signal handler while it is manipulated
+ * by the program may be disastrous.
+ *
+ * Ctrl-Alt-Del has a delayed handler. Not a must, but allowing
+ * it to happen even somewhere inside "sysinit" would be a bit awkward.
+ *
+ * There is a tiny probability that SIGHUP and Ctrl-Alt-Del will collide
+ * and only one will be remebered and acted upon.
+ */
+static void halt_reboot_pwoff(int sig)
+{
+        const char *m;
+        unsigned rb;
+        kill_all_processes();
+        m = "halt";
+        rb = RB_HALT_SYSTEM;
+        if (sig == SIGTERM) {
+                m = "reboot";
+                rb = RB_AUTOBOOT;
+        } else if (sig == SIGUSR2) {
+                m = "poweroff";
+                rb = RB_POWER_OFF;
+        }
+        message(L_CONSOLE, "Requesting system %s", m);
+        low_level_reboot(rb);
+        /* not reached */
+}
+/* The SIGSTOP/SIGTSTP handler
+ * NB: inside it, all signals except SIGCONT are masked
+ * via appropriate setup in sigaction().
+ */
+static void stop_handler(int sig UNUSED_PARAM)
+{
+        int saved_errno;
+        smallint saved_bb_got_signal;
+        saved_errno = errno;
+        saved_bb_got_signal = bb_got_signal;
+        signal(SIGCONT, record_signo);
+        while (1) {
+                pid_t wpid;
+                if (bb_got_signal == SIGCONT)
+                        break;
+                /* NB: this can accidentally wait() for a process
+                 * which we waitfor() elsewhere! waitfor() must have
+                 * code which is resilient against this.
+                 */
+                wpid = wait_any_nohang(NULL);
+                if (wpid > 0)
+                        mark_terminated(wpid);
+                sleep(1);
+        }
+        signal(SIGCONT, SIG_DFL);
+        bb_got_signal = saved_bb_got_signal;
+        errno = saved_errno;
+}
+/* Handler for QUIT - exec "restart" action,
+ * else (no such action defined) do nothing */
+static void restart_handler(int sig UNUSED_PARAM)
+{
+        struct init_action *a;
+        for (a = init_action_list; a; a = a->next) {
+                if (!(a->action_type & RESTART))
+                        continue;
+                /* Starting from here, we won't return.
+                 * Thus don't need to worry about preserving errno
+                 * and such.
+                 */
+                kill_all_processes();
+                open_stdio_to_tty(a->terminal, 0 /* - halt if open fails */);
+                messageD(L_CONSOLE, "Trying to re-exec %s", a->command);
+                init_exec(a->command);
+                low_level_reboot(RB_HALT_SYSTEM);
+                /* not reached */
+        }
+}
 #if ENABLE_FEATURE_USE_INITTAB
-static void reload_inittab(int sig UNUSED_PARAM)
+static void reload_inittab(void)
 {
        struct init_action *a, *tmp;
        message(L_LOG, "reloading /etc/inittab");
-        /* disable old entrys */
+        /* Disable old entries */
        for (a = init_action_list; a; a = a->next) {
                a->action_type = ONCE;
        }
@@ -738,47 +777,57 @@ static void reload_inittab(int sig UNUSED_PARAM)
        if (ENABLE_FEATURE_KILL_REMOVED) {
                /* Be nice and send SIGTERM first */
-                for (a = init_action_list; a; a = a->next) {
+                for (a = init_action_list; a; a = a->next)
-                        pid_t pid = a->pid;
+                        if (a->pid != 0)
-                        if ((a->action_type & ONCE) && pid != 0) {
+                                kill(a->pid, SIGTERM);
-                                kill(pid, SIGTERM);
-                        }
-                }
 #if CONFIG_FEATURE_KILL_DELAY
                /* NB: parent will wait in NOMMU case */
                if ((BB_MMU ? fork() : vfork()) == 0) { /* child */
                        sleep(CONFIG_FEATURE_KILL_DELAY);
-                        for (a = init_action_list; a; a = a->next) {
+                        for (a = init_action_list; a; a = a->next)
-                                pid_t pid = a->pid;
+                                if (a->pid != 0)
-                                if ((a->action_type & ONCE) && pid != 0) {
+                                        kill(a->pid, SIGKILL);
-                                        kill(pid, SIGKILL);
-                                }
-                        }
                        _exit(EXIT_SUCCESS);
                }
 #endif
        }
-        /* remove unused entrys */
+        /* Remove old and unused entries */
        for (a = init_action_list; a; a = tmp) {
                tmp = a->next;
-                if ((a->action_type & (ONCE | SYSINIT | WAIT)) && a->pid == 0) {
+                if (a->action_type & (ONCE | SYSINIT | WAIT))
                        delete_init_action(a);
-                }
        }
-        run_actions(RESPAWN | ASKFIRST);
+        /* Not needed: */
+        /* run_actions(RESPAWN | ASKFIRST); */
+        /* - we return to main loop, which does this automagically */
 }
-#else
-void reload_inittab(int sig);
 #endif
+static int check_delayed_sigs(void)
+{
+        int sigs_seen = 0;
+        while (1) {
+                smallint sig = bb_got_signal;
+                if (!sig)
+                        return sigs_seen;
+                bb_got_signal = 0;
+                sigs_seen = 1;
+#if ENABLE_FEATURE_USE_INITTAB
+                if (sig == SIGHUP)
+                        reload_inittab();
+#endif
+                if (sig == SIGINT)
+                        run_actions(CTRLALTDEL);
+        }
+}
 int init_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int init_main(int argc UNUSED_PARAM, char **argv)
 {
-        struct init_action *a;
+        die_sleep = 30 * 24*60*60; /* if xmalloc would ever die... */
-        pid_t wpid;
-        die_sleep = 30 * 24*60*60; /* if xmalloc will ever die... */
        if (argv[1] && !strcmp(argv[1], "-q")) {
                return kill(1, SIGHUP);
@@ -791,28 +840,9 @@ int init_main(int argc UNUSED_PARAM, char **argv)
                ) {
                        bb_show_usage();
                }
-                /* Set up sig handlers  -- be sure to
+                /* Turn off rebooting via CTL-ALT-DEL - we get a
-                 * clear all of these in run() */
-// TODO: handlers should just set a flag variable.
-// Move signal handling from handlers to main loop -
-// we have bad races otherwise.
-// E.g. parse_inittab() vs. delete_init_action()...
-                signal(SIGQUIT, restart_handler);
-                bb_signals(0
-                        + (1 << SIGUSR1)  /* halt */
-                        + (1 << SIGUSR2)  /* poweroff */
-                        + (1 << SIGTERM)  /* reboot */
-                        , halt_reboot_pwoff);
-                signal(SIGINT, ctrlaltdel_signal);
-                signal(SIGCONT, record_signo);
-                bb_signals(0
-                        + (1 << SIGSTOP)
-                        + (1 << SIGTSTP)
-                        , stop_handler);
-                /* Turn off rebooting via CTL-ALT-DEL -- we get a
                 * SIGINT on CAD so we can shut things down gracefully... */
-                low_level_reboot(RB_DISABLE_CAD);
+                reboot(RB_DISABLE_CAD); /* misnomer */
        }
        /* Figure out where the default console should be */
@@ -857,11 +887,11 @@ int init_main(int argc UNUSED_PARAM, char **argv)
                /* Start a shell on console */
                new_init_action(RESPAWN, bb_default_login_shell, "");
        } else {
-                /* Not in single user mode -- see what inittab says */
+                /* Not in single user mode - see what inittab says */
                /* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
                 * then parse_inittab() simply adds in some default
-                 * actions(i.e., runs INIT_SCRIPT and then starts a pair
+                 * actions(i.e., INIT_SCRIPT and a pair
                 * of "askfirst" shells */
                parse_inittab();
        }
@@ -888,44 +918,91 @@ int init_main(int argc UNUSED_PARAM, char **argv)
        while (*++argv)
                memset(*argv, 0, strlen(*argv));
-        /* Now run everything that needs to be run */
+        /* Set up signal handlers */
+        if (!DEBUG_INIT) {
+                struct sigaction sa;
+                bb_signals(0
+                        + (1 << SIGUSR1) /* halt */
+                        + (1 << SIGTERM) /* reboot */
+                        + (1 << SIGUSR2) /* poweroff */
+                        , halt_reboot_pwoff);
+                signal(SIGQUIT, restart_handler); /* re-exec another init */
+                /* Stop handler must allow only SIGCONT inside itself */
+                memset(&sa, 0, sizeof(sa));
+                sigfillset(&sa.sa_mask);
+                sigdelset(&sa.sa_mask, SIGCONT);
+                sa.sa_handler = stop_handler;
+                /* NB: sa_flags doesn't have SA_RESTART.
+                 * It must be able to interrupt wait().
+                 */
+                sigaction_set(SIGTSTP, &sa); /* pause */
+                /* Does not work as intended, at least in 2.6.20.
+                 * SIGSTOP is simply ignored by init:
+                 */
+                sigaction_set(SIGSTOP, &sa); /* pause */
+                /* SIGINT (Ctrl-Alt-Del) must interrupt wait(),
+                 * setting handler without SA_RESTART flag.
+                 */
+                bb_signals_recursive_norestart((1 << SIGINT), record_signo);
+        }
+        /* Now run everything that needs to be run */
        /* First run the sysinit command */
        run_actions(SYSINIT);
+        check_delayed_sigs();
        /* Next run anything that wants to block */
        run_actions(WAIT);
+        check_delayed_sigs();
        /* Next run anything to be run only once */
        run_actions(ONCE);
-        /* Redefine SIGHUP to reread /etc/inittab */
+        /* Set up "reread /etc/inittab" handler.
-        signal(SIGHUP, ENABLE_FEATURE_USE_INITTAB ? reload_inittab : SIG_IGN);
+         * Handler is set up without SA_RESTART, it will interrupt syscalls.
+         */
+        if (!DEBUG_INIT && ENABLE_FEATURE_USE_INITTAB)
+                bb_signals_recursive_norestart((1 << SIGHUP), record_signo);
-        /* Now run the looping stuff for the rest of forever */
+        /* Now run the looping stuff for the rest of forever.
+         * NB: if delayed signal happened, avoid blocking in wait().
+         */
        while (1) {
-                /* run the respawn/askfirst stuff */
+                pid_t wpid;
+                int got_sigs;
+                got_sigs = check_delayed_sigs();
+                /* (Re)run the respawn/askfirst stuff */
                run_actions(RESPAWN | ASKFIRST);
-                /* Don't consume all CPU time -- sleep a bit */
+                got_sigs |= check_delayed_sigs();
+                /* Don't consume all CPU time - sleep a bit */
                sleep(1);
-                /* Wait for any child process to exit */
+                got_sigs |= check_delayed_sigs();
+                /* Wait for any child process to exit.
+                 * NB: "delayed" signals will also interrupt this wait(),
+                 * bb_signals_recursive_norestart() set them up for that.
+                 * This guarantees we won't be stuck here
+                 * till next orphan dies.
+                 */
+                if (got_sigs)
+                        goto dont_block;
                wpid = wait(NULL);
                while (wpid > 0) {
-                        /* Find out who died and clean up their corpse */
+                        struct init_action *a = mark_terminated(wpid);
-                        for (a = init_action_list; a; a = a->next) {
+                        if (a) {
-                                if (a->pid == wpid) {
+                                message(L_LOG, "process '%s' (pid %d) exited. "
-                                        /* Set the pid to 0 so that the process gets
+                                                "Scheduling for restart.",
-                                         * restarted by run_actions() */
+                                                a->command, wpid);
-                                        a->pid = 0;
-                                        message(L_LOG, "process '%s' (pid %d) exited. "
-                                                        "Scheduling for restart.",
-                                                        a->command, wpid);
-                                }
                        }
-                        /* see if anyone else is waiting to be reaped */
+                        /* See if anyone else is waiting to be reaped */
+ dont_block:
                        wpid = wait_any_nohang(NULL);
                }
-        }
+        } /* while (1) */
 }
author	Denis Vlasenko <vda.linux@googlemail.com>	2009-01-31 01:03:45 +0000
committer	Denis Vlasenko <vda.linux@googlemail.com>	2009-01-31 01:03:45 +0000
commit	72c99af0b44e150a712891f6a3ea7d41827cfffe (patch)
tree	efd1f29d140f906deca0e8816e6b50ff2e87a77f /init/init.c
parent	cab28aa7de336b0a39ef43ce0eb035a2cab30d4d (diff)
download	busybox-w32-72c99af0b44e150a712891f6a3ea7d41827cfffe.tar.gz busybox-w32-72c99af0b44e150a712891f6a3ea7d41827cfffe.tar.bz2 busybox-w32-72c99af0b44e150a712891f6a3ea7d41827cfffe.zip