diff options
Diffstat (limited to 'init')
| -rw-r--r-- | init/init.c | 671 |
1 files changed, 374 insertions, 297 deletions
diff --git a/init/init.c b/init/init.c index 6af6830..3a02ece 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 -/* like respawn, but wait for <Enter> to be pressed on tty: */ -#define ASKFIRST 0x04 -#define WAIT 0x08 -#define ONCE 0x10 +/* Start these after SYSINIT and wait for completion */ +#define WAIT 0x02 +/* Start these after WAIT and *dont* wait for completion */ +#define ONCE 0x04 +/* + * 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 << SIGSTOP) + + (1 << SIGINT) + + (1 << SIGHUP) + (1 << SIGTSTP) , SIG_DFL); - /* Create a new session and make ourself the process - * group leader */ + /* Create a new session and make ourself the process 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) { - init_action_list = a->next; - } else { - b->next = a->next; - } + *nextp = 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) - continue; + while (1) { + 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) { - kill_all_processes(); - - /* 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 */); + if (!(a->action_type & action_type)) + continue; - messageD(L_CONSOLE | L_LOG, "Trying to re-exec %s", a->command); - init_exec(a->command); - sleep(2); - low_level_reboot(RB_HALT_SYSTEM); - loop_forever(); + if (a->action_type & (SYSINIT | WAIT | ONCE | CTRLALTDEL | SHUTDOWN)) { + pid_t pid = run(a); + if (a->action_type & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN)) + waitfor(pid); + } + 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; - -// Why? -// if (strcmp(cons, bb_dev_null) == 0 && (action & ASKFIRST)) -// return; - - /* Append to the end of the list */ - for (a = last = init_action_list; a; a = a->next) { - /* don't enter action if it's already in the list, - * but do overwrite existing actions */ + struct init_action *a, **nextp; + +//BUG +//old: +//::shutdown:umount -a -r +//::shutdown:swapoff -a +//new: swapped: +//::shutdown:swapoff -a +//::shutdown:umount -a -r +//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) { - last->next = a; - } else { - init_action_list = a; - } + *nextp = 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) { - pid_t pid = a->pid; - if ((a->action_type & ONCE) && pid != 0) { - kill(pid, SIGTERM); - } - } + for (a = init_action_list; a; a = a->next) + if (a->pid != 0) + kill(a->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) { - pid_t pid = a->pid; - if ((a->action_type & ONCE) && pid != 0) { - kill(pid, SIGKILL); - } - } + for (a = init_action_list; a; a = a->next) + if (a->pid != 0) + kill(a->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; - pid_t wpid; - - die_sleep = 30 * 24*60*60; /* if xmalloc will ever die... */ + die_sleep = 30 * 24*60*60; /* if xmalloc would 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 - * 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 + /* 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 */ - signal(SIGHUP, ENABLE_FEATURE_USE_INITTAB ? reload_inittab : SIG_IGN); + /* Set up "reread /etc/inittab" handler. + * 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 */ - for (a = init_action_list; a; a = a->next) { - if (a->pid == wpid) { - /* Set the pid to 0 so that the process gets - * restarted by run_actions() */ - a->pid = 0; - message(L_LOG, "process '%s' (pid %d) exited. " - "Scheduling for restart.", - a->command, wpid); - } + struct init_action *a = mark_terminated(wpid); + if (a) { + 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) */ } |