X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=init%2Finit.c;h=cad64f63ae25f185e5d4a1bf51d515d844ea923c;hb=2aced7ea043aff64bd4e5f2814818fb4d0c803d4;hp=8e2368306fc148b787905c3483226de68b862236;hpb=2480e3a30a063fb400a0912ddf513dff03ebc641;p=oweals%2Fbusybox.git diff --git a/init/init.c b/init/init.c index 8e2368306..cad64f63a 100644 --- a/init/init.c +++ b/init/init.c @@ -2,156 +2,101 @@ /* * Mini init implementation for busybox * - * * Copyright (C) 1995, 1996 by Bruce Perens . + * Copyright (C) 1999-2004 by Erik Andersen * Adjusted by so many folks, it's impossible to keep track. * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. */ -/* Turn this on to disable all the dangerous - rebooting stuff when debugging. -#define DEBUG_INIT -*/ - -#include -#include +#include "busybox.h" #include #include #include -#include -#include -#include -#include -#include -#include #include -#include -#include #include -#include "busybox.h" +#include + +#include "init_shared.h" + #ifdef CONFIG_SYSLOGD # include #endif +#define INIT_BUFFS_SIZE 256 /* From */ struct vt_stat { - unsigned short v_active; /* active vt */ - unsigned short v_signal; /* signal to send */ - unsigned short v_state; /* vt bitmask */ + unsigned short v_active; /* active vt */ + unsigned short v_signal; /* signal to send */ + unsigned short v_state; /* vt bitmask */ }; -static const int VT_GETSTATE = 0x5603; /* get global vt state info */ +enum { VT_GETSTATE = 0x5603 }; /* get global vt state info */ /* From */ struct serial_struct { - int type; - int line; - int port; - int irq; - int flags; - int xmit_fifo_size; - int custom_divisor; - int baud_base; - unsigned short close_delay; - char reserved_char[2]; - int hub6; - unsigned short closing_wait; /* time to wait before closing */ - unsigned short closing_wait2; /* no longer used... */ - int reserved[4]; + int type; + int line; + unsigned int port; + int irq; + int flags; + int xmit_fifo_size; + int custom_divisor; + int baud_base; + unsigned short close_delay; + char io_type; + char reserved_char[1]; + int hub6; + unsigned short closing_wait; /* time to wait before closing */ + unsigned short closing_wait2; /* no longer used... */ + unsigned char *iomem_base; + unsigned short iomem_reg_shift; + unsigned int port_high; + unsigned long iomap_base; /* cookie passed into ioremap */ + int reserved[1]; }; - -#if (__GNU_LIBRARY__ > 5) || defined(__dietlibc__) - #include - #define init_reboot(magic) reboot(magic) -#else - #define init_reboot(magic) reboot(0xfee1dead, 672274793, magic) -#endif - -#ifndef RB_HALT_SYSTEM -static const int RB_HALT_SYSTEM = 0xcdef0123; -static const int RB_ENABLE_CAD = 0x89abcdef; -static const int RB_DISABLE_CAD = 0; -#define RB_POWER_OFF 0x4321fedc -static const int RB_AUTOBOOT = 0x01234567; -#endif - #ifndef _PATH_STDPATH #define _PATH_STDPATH "/usr/bin:/bin:/usr/sbin:/sbin" #endif - #if defined CONFIG_FEATURE_INIT_COREDUMPS /* - * When a file named CORE_ENABLE_FLAG_FILE exists, setrlimit is called + * When a file named CORE_ENABLE_FLAG_FILE exists, setrlimit is called * before processes are spawned to set core file size as unlimited. * This is for debugging only. Don't use this is production, unless * you want core dumps lying about.... */ #define CORE_ENABLE_FLAG_FILE "/.init_enable_core" #include -#include -#endif - -#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c)) - -#if __GNU_LIBRARY__ > 5 - #include -#else - extern int bdflush (int func, long int data); #endif - -#define SHELL "/bin/sh" /* Default shell */ -#define LOGIN_SHELL "-" SHELL /* Default login shell */ -#define INITTAB "/etc/inittab" /* inittab file location */ +#define INITTAB "/etc/inittab" /* inittab file location */ #ifndef INIT_SCRIPT -#define INIT_SCRIPT "/etc/init.d/rcS" /* Default sysinit script. */ +#define INIT_SCRIPT "/etc/init.d/rcS" /* Default sysinit script. */ #endif #define MAXENV 16 /* Number of env. vars */ -//static const int MAXENV = 16; /* Number of env. vars */ -static const int LOG = 0x1; -static const int CONSOLE = 0x2; -#if defined BB_FEATURE_EXTRA_QUIET -static const int MAYBE_CONSOLE = 0x0; -#else -#define MAYBE_CONSOLE CONSOLE -#endif +#define CONSOLE_BUFF_SIZE 32 /* Allowed init action types */ -typedef enum { - SYSINIT = 1, - RESPAWN, - ASKFIRST, - WAIT, - ONCE, - CTRLALTDEL, - SHUTDOWN -} initActionEnum; +#define SYSINIT 0x001 +#define RESPAWN 0x002 +#define ASKFIRST 0x004 +#define WAIT 0x008 +#define ONCE 0x010 +#define CTRLALTDEL 0x020 +#define SHUTDOWN 0x040 +#define RESTART 0x080 /* A mapping between "inittab" action name strings and action type codes. */ -typedef struct initActionType { +struct init_action_type { const char *name; - initActionEnum action; -} initActionType; + int action; +}; -static const struct initActionType actions[] = { +static const struct init_action_type actions[] = { {"sysinit", SYSINIT}, {"respawn", RESPAWN}, {"askfirst", ASKFIRST}, @@ -159,129 +104,170 @@ static const struct initActionType actions[] = { {"once", ONCE}, {"ctrlaltdel", CTRLALTDEL}, {"shutdown", SHUTDOWN}, + {"restart", RESTART}, {0, 0} }; -/* Set up a linked list of initActions, to be read from inittab */ -typedef struct initActionTag initAction; -struct initActionTag { +/* Set up a linked list of init_actions, to be read from inittab */ +struct init_action { pid_t pid; - char process[256]; - char console[256]; - initAction *nextPtr; - initActionEnum action; + char command[INIT_BUFFS_SIZE]; + char terminal[CONSOLE_BUFF_SIZE]; + struct init_action *next; + int action; }; -static initAction *initActionList = NULL; +/* Static variables */ +static struct init_action *init_action_list = NULL; +static char console[CONSOLE_BUFF_SIZE] = CONSOLE_DEV; + +#ifndef CONFIG_SYSLOGD +static char *log_console = VC_5; +#endif +#if !ENABLE_DEBUG_INIT +static sig_atomic_t got_cont = 0; +#endif + +enum { + LOG = 0x1, + CONSOLE = 0x2, + +#if defined CONFIG_FEATURE_EXTRA_QUIET + MAYBE_CONSOLE = 0x0, +#else + MAYBE_CONSOLE = CONSOLE, +#endif + +#ifndef RB_HALT_SYSTEM + RB_HALT_SYSTEM = 0xcdef0123, /* FIXME: this overflows enum */ + RB_ENABLE_CAD = 0x89abcdef, + RB_DISABLE_CAD = 0, + RB_POWER_OFF = 0x4321fedc, + RB_AUTOBOOT = 0x01234567, +#endif +}; -static char *secondConsole = VC_2; -static char *thirdConsole = VC_3; -static char *fourthConsole = VC_4; -static char *log = VC_5; -static int kernelVersion = 0; -static char termType[32] = "TERM=linux"; -static char console[32] = _PATH_CONSOLE; +static const char * const environment[] = { + "HOME=/", + "PATH=" _PATH_STDPATH, + "SHELL=/bin/sh", + "USER=root", + NULL +}; -static void delete_initAction(initAction * action); +/* Function prototypes */ +static void delete_init_action(struct init_action *a); +static int waitfor(const struct init_action *a, pid_t pid); +#if !ENABLE_DEBUG_INIT +static void shutdown_signal(int sig); +#endif static void loop_forever(void) { while (1) - sleep (1); + sleep(1); } /* Print a message to the specified device. * Device may be bitwise-or'd from LOG | CONSOLE */ -#ifdef DEBUG_INIT -static inline messageND(int device, char *fmt, ...) { } -#else -#define messageND message +#if ENABLE_DEBUG_INIT +#define messageD message +#else +static inline void messageD(int ATTRIBUTE_UNUSED device, + const char ATTRIBUTE_UNUSED *fmt, ...) +{ +} #endif -static void message(int device, char *fmt, ...) - __attribute__ ((format (printf, 2, 3))); -static void message(int device, char *fmt, ...) +static void message(int device, const char *fmt, ...) + __attribute__ ((format(printf, 2, 3))); +static void message(int device, const char *fmt, ...) { va_list arguments; - int fd; + int l; + RESERVE_CONFIG_BUFFER(msg, 1024); +#ifndef CONFIG_SYSLOGD + static int log_fd = -1; +#endif -#ifdef CONFIG_SYSLOGD + msg[0] = '\r'; + va_start(arguments, fmt); + l = vsnprintf(msg + 1, 1024 - 2, fmt, arguments) + 1; + va_end(arguments); +#ifdef CONFIG_SYSLOGD /* Log the message to syslogd */ if (device & LOG) { - char msg[1024]; - - va_start(arguments, fmt); - vsnprintf(msg, sizeof(msg), fmt, arguments); - va_end(arguments); - syslog_msg(LOG_USER, LOG_USER|LOG_INFO, msg); + /* don`t out "\r\n" */ + openlog(bb_applet_name, 0, LOG_DAEMON); + syslog(LOG_INFO, "%s", msg + 1); + closelog(); } + + msg[l++] = '\n'; + msg[l] = 0; #else - static int log_fd = -1; + msg[l++] = '\n'; + msg[l] = 0; /* Take full control of the log tty, and never close it. * It's mine, all mine! Muhahahaha! */ if (log_fd < 0) { - if (log == NULL) { - /* don't even try to log, because there is no such console */ - log_fd = -2; - /* log to main console instead */ - device = CONSOLE; - } else if ((log_fd = device_open(log, O_RDWR|O_NDELAY)) < 0) { + if ((log_fd = device_open(log_console, O_RDWR | O_NONBLOCK | O_NOCTTY)) < 0) { log_fd = -2; - fprintf(stderr, "Bummer, can't write to log on %s!\n", log); - log = NULL; + bb_error_msg("Bummer, can't write to log on %s!", log_console); device = CONSOLE; + } else { + fcntl(log_fd, F_SETFD, FD_CLOEXEC); } } if ((device & LOG) && (log_fd >= 0)) { - va_start(arguments, fmt); - vdprintf(log_fd, fmt, arguments); - va_end(arguments); + full_write(log_fd, msg, l); } #endif if (device & CONSOLE) { + int fd = device_open(CONSOLE_DEV, + O_WRONLY | O_NOCTTY | O_NONBLOCK); /* Always send console messages to /dev/console so people will see them. */ - if ( - (fd = - device_open(_PATH_CONSOLE, - O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0) { - va_start(arguments, fmt); - vdprintf(fd, fmt, arguments); - va_end(arguments); + if (fd >= 0) { + full_write(fd, msg, l); close(fd); +#if ENABLE_DEBUG_INIT + /* all descriptors may be closed */ } else { - fprintf(stderr, "Bummer, can't print: "); + bb_error_msg("Bummer, can't print: "); va_start(arguments, fmt); vfprintf(stderr, fmt, arguments); va_end(arguments); +#endif } } + RELEASE_CONFIG_BUFFER(msg); } /* Set terminal settings to reasonable defaults */ -static void set_term(int fd) +static void set_term(void) { struct termios tty; - tcgetattr(fd, &tty); + tcgetattr(STDIN_FILENO, &tty); /* set control chars */ - tty.c_cc[VINTR] = 3; /* C-c */ - tty.c_cc[VQUIT] = 28; /* C-\ */ - tty.c_cc[VERASE] = 127; /* C-? */ - tty.c_cc[VKILL] = 21; /* C-u */ - tty.c_cc[VEOF] = 4; /* C-d */ + tty.c_cc[VINTR] = 3; /* C-c */ + tty.c_cc[VQUIT] = 28; /* C-\ */ + tty.c_cc[VERASE] = 127; /* C-? */ + tty.c_cc[VKILL] = 21; /* C-u */ + tty.c_cc[VEOF] = 4; /* C-d */ tty.c_cc[VSTART] = 17; /* C-q */ - tty.c_cc[VSTOP] = 19; /* C-s */ - tty.c_cc[VSUSP] = 26; /* C-z */ + tty.c_cc[VSTOP] = 19; /* C-s */ + tty.c_cc[VSUSP] = 26; /* C-z */ /* use line dicipline 0 */ tty.c_line = 0; /* Make it be sane */ - tty.c_cflag &= CBAUD|CBAUDEX|CSIZE|CSTOPB|PARENB|PARODD; - tty.c_cflag |= CREAD|HUPCL|CLOCAL; + tty.c_cflag &= CBAUD | CBAUDEX | CSIZE | CSTOPB | PARENB | PARODD; + tty.c_cflag |= CREAD | HUPCL | CLOCAL; /* input modes */ @@ -294,60 +280,20 @@ static void set_term(int fd) tty.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN; - tcsetattr(fd, TCSANOW, &tty); -} - -/* How much memory does this machine have? - Units are kBytes to avoid overflow on 4GB machines */ -static int check_free_memory(void) -{ - struct sysinfo info; - unsigned int result, u, s=10; - - if (sysinfo(&info) != 0) { - perror_msg("Error checking free memory"); - return -1; - } - - /* Kernels 2.0.x and 2.2.x return info.mem_unit==0 with values in bytes. - * Kernels 2.4.0 return info.mem_unit in bytes. */ - u = info.mem_unit; - if (u==0) u=1; - while ( (u&1) == 0 && s > 0 ) { u>>=1; s--; } - result = (info.totalram>>s) + (info.totalswap>>s); - result = result*u; - if (result < 0) result = INT_MAX; - return result; + tcsetattr(STDIN_FILENO, TCSANOW, &tty); } static void console_init(void) { int fd; - int tried_devcons = 0; - int tried_vtprimary = 0; + int tried = 0; struct vt_stat vt; struct serial_struct sr; char *s; - if ((s = getenv("TERM")) != NULL) { - snprintf(termType, sizeof(termType) - 1, "TERM=%s", s); - } - - if ((s = getenv("CONSOLE")) != NULL) { + if ((s = getenv("CONSOLE")) != NULL || (s = getenv("console")) != NULL) { safe_strncpy(console, s, sizeof(console)); - } -#if #cpu(sparc) - /* sparc kernel supports console=tty[ab] parameter which is also - * passed to init, so catch it here */ - else if ((s = getenv("console")) != NULL) { - /* remap tty[ab] to /dev/ttyS[01] */ - if (strcmp(s, "ttya") == 0) - safe_strncpy(console, SC_0, sizeof(console)); - else if (strcmp(s, "ttyb") == 0) - safe_strncpy(console, SC_1, sizeof(console)); - } -#endif - else { + } else { /* 2.2 kernels: identify the real console backend and try to use it */ if (ioctl(0, TIOCGSERIAL, &sr) == 0) { /* this is a serial console */ @@ -356,52 +302,48 @@ static void console_init(void) /* this is linux virtual tty */ snprintf(console, sizeof(console) - 1, VC_FORMAT, vt.v_active); } else { - safe_strncpy(console, _PATH_CONSOLE, sizeof(console)); - tried_devcons++; + safe_strncpy(console, CONSOLE_DEV, sizeof(console)); + tried++; } } - while ((fd = open(console, O_RDONLY | O_NONBLOCK)) < 0) { - /* Can't open selected console -- try /dev/console */ - if (!tried_devcons) { - tried_devcons++; - safe_strncpy(console, _PATH_CONSOLE, sizeof(console)); - continue; - } - /* Can't open selected console -- try vt1 */ - if (!tried_vtprimary) { - tried_vtprimary++; - safe_strncpy(console, VC_1, sizeof(console)); - continue; - } - break; + while ((fd = open(console, O_RDONLY | O_NONBLOCK)) < 0 && tried < 2) { + /* Can't open selected console -- try + logical system console and VT_MASTER */ + safe_strncpy(console, (tried == 0 ? CONSOLE_DEV : CURRENT_VC), + sizeof(console)); + tried++; } if (fd < 0) { /* Perhaps we should panic here? */ - safe_strncpy(console, "/dev/null", sizeof(console)); +#ifndef CONFIG_SYSLOGD + log_console = +#endif + safe_strncpy(console, bb_dev_null, sizeof(console)); } else { - /* check for serial console and disable logging to tty5 & running a - * shell to tty2-4 */ - if (ioctl(0, TIOCGSERIAL, &sr) == 0) { - log = NULL; - secondConsole = NULL; - thirdConsole = NULL; - fourthConsole = NULL; + s = getenv("TERM"); + /* check for serial console */ + if (ioctl(fd, TIOCGSERIAL, &sr) == 0) { /* Force the TERM setting to vt102 for serial console -- - * iff TERM is set to linux (the default) */ - if (strcmp( termType, "TERM=linux" ) == 0) - safe_strncpy(termType, "TERM=vt102", sizeof(termType)); - message(LOG | CONSOLE, - "serial console detected. Disabling virtual terminals.\n"); + * if TERM is set to linux (the default) */ + if (s == NULL || strcmp(s, "linux") == 0) + putenv("TERM=vt102"); +#ifndef CONFIG_SYSLOGD + log_console = console; +#endif + } else { + if (s == NULL) + putenv("TERM=linux"); } close(fd); } - message(LOG, "console=%s\n", console); + messageD(LOG, "console=%s", console); } - + static void fixup_argv(int argc, char **argv, char *new_argv0) { int len; + /* Fix up argv[0] to be certain we claim to be init */ len = strlen(argv[0]); memset(argv[0], 0, len); @@ -415,99 +357,131 @@ static void fixup_argv(int argc, char **argv, char *new_argv0) } } +/* Open the new terminal device */ +static void open_new_terminal(const char * const device, const int fail) { + struct stat sb; + + if ((device_open(device, O_RDWR)) < 0) { + if (stat(device, &sb) != 0) { + message(LOG | CONSOLE, "device '%s' does not exist.", device); + } else { + message(LOG | CONSOLE, "Bummer, can't open %s", device); + } + if (fail) + _exit(1); + /* else */ +#if !ENABLE_DEBUG_INIT + shutdown_signal(SIGUSR1); +#else + _exit(2); +#endif + } +} -static pid_t run(char *command, char *terminal, int get_enter) +static pid_t run(const struct init_action *a) { - int i, j; - int fd; + int i; pid_t pid; - char *tmpCmd, *s; - char *cmd[255], *cmdpath; - char buf[255]; - struct stat sb; + char *s, *tmpCmd, *cmd[INIT_BUFFS_SIZE], *cmdpath; + char buf[INIT_BUFFS_SIZE + 6]; /* INIT_BUFFS_SIZE+strlen("exec ")+1 */ + sigset_t nmask, omask; static const char press_enter[] = - #ifdef CUSTOMIZED_BANNER #include CUSTOMIZED_BANNER #endif - "\nPlease press Enter to activate this console. "; - char *environment[MAXENV+1] = { - termType, - "HOME=/", - "PATH=" _PATH_STDPATH, - "SHELL=" SHELL, - "USER=root", - NULL - }; - - /* inherit environment to the child, merging our values -andy */ - for (i=0; environ[i]; i++) { - for (j=0; environment[j]; j++) { - s = strchr(environment[j], '='); - if (!strncmp(environ[i], environment[j], s - environment[j])) - break; - } - if (!environment[j]) { - environment[j++] = environ[i]; - environment[j] = NULL; - } - } -#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__) - if ((pid = fork()) == 0) -#else - if ((pid = vfork()) == 0) -#endif - { + /* Block sigchild while forking. */ + sigemptyset(&nmask); + sigaddset(&nmask, SIGCHLD); + sigprocmask(SIG_BLOCK, &nmask, &omask); + + if ((pid = fork()) == 0) { + /* Clean up */ - ioctl(0, TIOCNOTTY, 0); close(0); close(1); close(2); - setsid(); + sigprocmask(SIG_SETMASK, &omask, NULL); - /* Reset signal handlers set for parent process */ + /* Reset signal handlers that were set by the parent process */ signal(SIGUSR1, SIG_DFL); signal(SIGUSR2, SIG_DFL); signal(SIGINT, SIG_DFL); signal(SIGTERM, SIG_DFL); signal(SIGHUP, SIG_DFL); + signal(SIGQUIT, SIG_DFL); + signal(SIGCONT, SIG_DFL); + signal(SIGSTOP, SIG_DFL); + signal(SIGTSTP, SIG_DFL); + + /* Create a new session and make ourself the process + * group leader */ + setsid(); + + /* Open the new terminal device */ + open_new_terminal(a->terminal, 1); - if ((fd = device_open(terminal, O_RDWR)) < 0) { - if (stat(terminal, &sb) != 0) { - message(LOG | CONSOLE, "device '%s' does not exist.\n", - terminal); - exit(1); + /* Make sure the terminal will act fairly normal for us */ + set_term(); + /* Setup stdout, stderr for the new process so + * they point to the supplied terminal */ + dup(0); + dup(0); + + /* If the init Action requires us to wait, then force the + * supplied terminal to be the controlling tty. */ + if (a->action & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) { + + /* Now fork off another process to just hang around */ + if ((pid = fork()) < 0) { + message(LOG | CONSOLE, "Can't fork!"); + _exit(1); } - message(LOG | CONSOLE, "Bummer, can't open %s\n", terminal); - exit(1); + + if (pid > 0) { + + /* We are the parent -- wait till the child is done */ + signal(SIGINT, SIG_IGN); + signal(SIGTSTP, SIG_IGN); + signal(SIGQUIT, SIG_IGN); + signal(SIGCHLD, SIG_DFL); + + waitfor(NULL, pid); + /* See if stealing the controlling tty back is necessary */ + if (tcgetpgrp(0) != getpid()) + _exit(0); + + /* Use a temporary process to steal the controlling tty. */ + if ((pid = fork()) < 0) { + message(LOG | CONSOLE, "Can't fork!"); + _exit(1); + } + if (pid == 0) { + setsid(); + ioctl(0, TIOCSCTTY, 1); + _exit(0); + } + waitfor(NULL, pid); + _exit(0); + } + + /* Now fall though to actually execute things */ } - dup2(fd, 0); - dup2(fd, 1); - dup2(fd, 2); - ioctl(0, TIOCSCTTY, 1); - tcsetpgrp(0, getpgrp()); - set_term(0); /* See if any special /bin/sh requiring characters are present */ - if (strpbrk(command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) { - cmd[0] = SHELL; + if (strpbrk(a->command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) { + cmd[0] = (char *)DEFAULT_SHELL; cmd[1] = "-c"; - strcpy(buf, "exec "); - safe_strncpy(buf + sizeof("exec "), command, - sizeof(buf) - sizeof("exec ")); - cmd[2] = buf; + cmd[2] = strcat(strcpy(buf, "exec "), a->command); cmd[3] = NULL; } else { /* Convert command (char*) into cmd (char**, one word per string) */ - safe_strncpy(buf, command, sizeof(buf)); + strcpy(buf, a->command); s = buf; - for (tmpCmd = buf, i = 0; - (tmpCmd = strsep(&s, " \t")) != NULL;) { + for (tmpCmd = buf, i = 0; (tmpCmd = strsep(&s, " \t")) != NULL;) { if (*tmpCmd != '\0') { cmd[i] = tmpCmd; - tmpCmd++; i++; } } @@ -518,8 +492,8 @@ static pid_t run(char *command, char *terminal, int get_enter) /* Interactive shells want to see a dash in argv[0]. This - typically is handled by login, argv will be setup this - way if a dash appears at the front of the command path + typically is handled by login, argv will be setup this + way if a dash appears at the front of the command path (like "-/bin/sh"). */ @@ -529,252 +503,331 @@ static pid_t run(char *command, char *terminal, int get_enter) ++cmdpath; /* find the last component in the command pathname */ - s = get_last_path_component(cmdpath); + s = bb_get_last_path_component(cmdpath); /* make a new argv[0] */ - if ((cmd[0] = malloc(strlen(s)+2)) == NULL) { - message(LOG | CONSOLE, "malloc failed"); + if ((cmd[0] = malloc(strlen(s) + 2)) == NULL) { + message(LOG | CONSOLE, bb_msg_memory_exhausted); cmd[0] = cmdpath; } else { cmd[0][0] = '-'; - strcpy(cmd[0]+1, s); + strcpy(cmd[0] + 1, s); } +#ifdef CONFIG_FEATURE_INIT_SCTTY + /* Establish this process as session leader and + * (attempt) to make the tty (if any) a controlling tty. + */ + (void) setsid(); + (void) ioctl(0, TIOCSCTTY, 0/*don't steal it*/); +#endif } - if (get_enter == TRUE) { +#if !defined(__UCLIBC__) || defined(__ARCH_HAS_MMU__) + if (a->action & ASKFIRST) { + char c; /* * Save memory by not exec-ing anything large (like a shell) * before the user wants it. This is critical if swap is not * enabled and the system has low memory. Generally this will * be run on the second virtual console, and the first will - * be allowed to start a shell or whatever an init script + * be allowed to start a shell or whatever an init script * specifies. */ - messageND(LOG, "Waiting for enter to start '%s' (pid %d, console %s)\n", - cmd[0], getpid(), terminal); - write(fileno(stdout), press_enter, sizeof(press_enter) - 1); - getc(stdin); + messageD(LOG, "Waiting for enter to start '%s'" + "(pid %d, terminal %s)\n", + cmdpath, getpid(), a->terminal); + full_write(1, press_enter, sizeof(press_enter) - 1); + while(read(0, &c, 1) == 1 && c != '\n') + ; } +#endif /* Log the process name and args */ - messageND(LOG, "Starting pid %d, console %s: '%s'\n", - getpid(), terminal, command); + message(LOG, "Starting pid %d, console %s: '%s'", + getpid(), a->terminal, cmdpath); #if defined CONFIG_FEATURE_INIT_COREDUMPS - if (stat (CORE_ENABLE_FLAG_FILE, &sb) == 0) { - struct rlimit limit; - limit.rlim_cur = RLIM_INFINITY; - limit.rlim_max = RLIM_INFINITY; - setrlimit(RLIMIT_CORE, &limit); + { + struct stat sb; + if (stat(CORE_ENABLE_FLAG_FILE, &sb) == 0) { + struct rlimit limit; + + limit.rlim_cur = RLIM_INFINITY; + limit.rlim_max = RLIM_INFINITY; + setrlimit(RLIMIT_CORE, &limit); + } } #endif - /* Now run it. The new program will take over this PID, + /* Now run it. The new program will take over this PID, * so nothing further in init.c should be run. */ - execve(cmdpath, cmd, environment); + execv(cmdpath, cmd); /* We're still here? Some error happened. */ - message(LOG | CONSOLE, "Bummer, could not run '%s': %s\n", cmdpath, - strerror(errno)); - exit(-1); + message(LOG | CONSOLE, "Bummer, could not run '%s': %m", cmdpath); + _exit(-1); } + sigprocmask(SIG_SETMASK, &omask, NULL); return pid; } -static int waitfor(char *command, char *terminal, int get_enter) +static int waitfor(const struct init_action *a, pid_t pid) { + int runpid; int status, wpid; - int pid = run(command, terminal, get_enter); + runpid = (NULL == a)? pid : run(a); while (1) { - wpid = wait(&status); - if (wpid > 0 && wpid != pid) { - continue; - } - if (wpid == pid) + wpid = waitpid(runpid,&status,0); + if (wpid == runpid) break; + if (wpid == -1 && errno == ECHILD) { + /* we missed its termination */ + break; + } + /* FIXME other errors should maybe trigger an error, but allow + * the program to continue */ } return wpid; } -/* Make sure there is enough memory to do something useful. * - * Calls "swapon -a" if needed so be sure /etc/fstab is present... */ -static void check_memory(void) +/* Run all commands of a particular type */ +static void run_actions(int action) { - struct stat statBuf; - - if (check_free_memory() > 1000) - return; - -#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__) - if (stat("/etc/fstab", &statBuf) == 0) { - /* swapon -a requires /proc typically */ - waitfor("mount proc /proc -t proc", console, FALSE); - /* Try to turn on swap */ - waitfor("swapon -a", console, FALSE); - if (check_free_memory() < 1000) - goto goodnight; - } else - goto goodnight; - return; -#endif + struct init_action *a, *tmp; - goodnight: - message(CONSOLE, - "Sorry, your computer does not have enough memory.\n"); - loop_forever(); -} - -/* Run all commands to be run right before halt/reboot */ -static void run_actions(initActionEnum action) -{ - initAction *a, *tmp; - for (a = initActionList; a; a = tmp) { - tmp = a->nextPtr; + for (a = init_action_list; a; a = tmp) { + tmp = a->next; if (a->action == action) { - waitfor(a->process, a->console, FALSE); - delete_initAction(a); + if (access(a->terminal, R_OK | W_OK)) { + delete_init_action(a); + } else if (a->action & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) { + waitfor(a, 0); + delete_init_action(a); + } else if (a->action & ONCE) { + run(a); + delete_init_action(a); + } else if (a->action & (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); + } + } } } } +#if !ENABLE_DEBUG_INIT +static void init_reboot(unsigned long magic) +{ + pid_t pid; + /* We have to fork here, since the kernel calls do_exit(0) in + * linux/kernel/sys.c, which can cause the machine to panic when + * the init process is killed.... */ + if ((pid = fork()) == 0) { + reboot(magic); + _exit(0); + } + waitpid (pid, NULL, 0); +} -#ifndef DEBUG_INIT static void shutdown_system(void) { sigset_t block_signals; + /* 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 */ sigemptyset(&block_signals); sigaddset(&block_signals, SIGHUP); + sigaddset(&block_signals, SIGQUIT); sigaddset(&block_signals, SIGCHLD); sigaddset(&block_signals, SIGUSR1); sigaddset(&block_signals, SIGUSR2); sigaddset(&block_signals, SIGINT); sigaddset(&block_signals, SIGTERM); + sigaddset(&block_signals, SIGCONT); + sigaddset(&block_signals, SIGSTOP); + sigaddset(&block_signals, SIGTSTP); sigprocmask(SIG_BLOCK, &block_signals, NULL); /* Allow Ctrl-Alt-Del to reboot system. */ init_reboot(RB_ENABLE_CAD); - message(CONSOLE|LOG, "\nThe system is going down NOW !!\n"); + message(CONSOLE | LOG, "The system is going down NOW !!"); sync(); /* Send signals to every process _except_ pid 1 */ - message(CONSOLE|LOG, "Sending SIGTERM to all processes.\n"); + message(CONSOLE | LOG, init_sending_format, "TERM"); kill(-1, SIGTERM); sleep(1); sync(); - message(CONSOLE|LOG, "Sending SIGKILL to all processes.\n"); + message(CONSOLE | LOG, init_sending_format, "KILL"); kill(-1, SIGKILL); sleep(1); - /* run everything to be run at "shutdown" */ - run_actions(SHUTDOWN); - sync(); - if (kernelVersion > 0 && kernelVersion <= KERNEL_VERSION(2,2,11)) { - /* bdflush, kupdate not needed for kernels >2.2.11 */ - bdflush(1, 0); - sync(); +} + +static void exec_signal(int sig ATTRIBUTE_UNUSED) +{ + struct init_action *a, *tmp; + sigset_t unblock_signals; + + for (a = init_action_list; a; a = tmp) { + tmp = a->next; + if (a->action & RESTART) { + shutdown_system(); + + /* unblock all signals, blocked in shutdown_system() */ + sigemptyset(&unblock_signals); + sigaddset(&unblock_signals, SIGHUP); + sigaddset(&unblock_signals, SIGQUIT); + sigaddset(&unblock_signals, SIGCHLD); + sigaddset(&unblock_signals, SIGUSR1); + sigaddset(&unblock_signals, SIGUSR2); + sigaddset(&unblock_signals, SIGINT); + sigaddset(&unblock_signals, SIGTERM); + sigaddset(&unblock_signals, SIGCONT); + sigaddset(&unblock_signals, SIGSTOP); + sigaddset(&unblock_signals, SIGTSTP); + sigprocmask(SIG_UNBLOCK, &unblock_signals, NULL); + + /* Close whatever files are open. */ + close(0); + close(1); + close(2); + + /* Open the new terminal device */ + open_new_terminal(a->terminal, 0); + + /* Make sure the terminal will act fairly normal for us */ + set_term(); + /* Setup stdout, stderr on the supplied terminal */ + dup(0); + dup(0); + + messageD(CONSOLE | LOG, "Trying to re-exec %s", a->command); + execl(a->command, a->command, NULL); + + message(CONSOLE | LOG, "exec of '%s' failed: %m", + a->command); + sync(); + sleep(2); + init_reboot(RB_HALT_SYSTEM); + loop_forever(); + } } } -static void halt_signal(int sig) +static void shutdown_signal(int sig) { + char *m; + int rb; + shutdown_system(); - message(CONSOLE|LOG, -#if #cpu(s390) - /* Seems the s390 console is Wierd(tm). */ - "The system is halted. You may reboot now.\n" -#else - /* secondConsole is NULL for a serial console */ - "The system is halted. Press %s or turn off power\n", - (secondConsole == NULL)? "Reset" : "CTRL-ALT-DEL" -#endif - ); + + if (sig == SIGTERM) { + m = "reboot"; + rb = RB_AUTOBOOT; + } else if (sig == SIGUSR2) { + m = "poweroff"; + rb = RB_POWER_OFF; + } else { + m = "halt"; + rb = RB_HALT_SYSTEM; + } + message(CONSOLE | LOG, "Requesting system %s.", m); sync(); /* allow time for last message to reach serial console */ sleep(2); - if (sig == SIGUSR2 && kernelVersion >= KERNEL_VERSION(2,2,0)) - init_reboot(RB_POWER_OFF); - else - init_reboot(RB_HALT_SYSTEM); + init_reboot(rb); loop_forever(); } -static void reboot_signal(int sig) +static void ctrlaltdel_signal(int sig ATTRIBUTE_UNUSED) { - shutdown_system(); - message(CONSOLE|LOG, "Please stand by while rebooting the system.\n"); - sync(); - - /* allow time for last message to reach serial console */ - sleep(2); + run_actions(CTRLALTDEL); +} - init_reboot(RB_AUTOBOOT); +/* The SIGSTOP & SIGTSTP handler */ +static void stop_handler(int sig ATTRIBUTE_UNUSED) +{ + int saved_errno = errno; - loop_forever(); + got_cont = 0; + while (!got_cont) + pause(); + got_cont = 0; + errno = saved_errno; } -static void ctrlaltdel_signal(int sig) +/* The SIGCONT handler */ +static void cont_handler(int sig ATTRIBUTE_UNUSED) { - run_actions(CTRLALTDEL); + got_cont = 1; } -#endif /* ! DEBUG_INIT */ +#endif /* ! ENABLE_DEBUG_INIT */ -static void new_initAction(initActionEnum action, char *process, char *cons) +static void new_init_action(int action, const char *command, const char *cons) { - initAction *newAction; - initAction *a; + struct init_action *new_action, *a, *last; if (*cons == '\0') cons = console; - /* If BusyBox detects that a serial console is in use, - * then entries not refering to the console or null devices will _not_ be run. - * The exception to this rule is the null device. - */ - if (secondConsole == NULL && strcmp(cons, console) - && strcmp(cons, "/dev/null")) - return; - if (strcmp(cons, "/dev/null") == 0 && action == ASKFIRST) + if (strcmp(cons, bb_dev_null) == 0 && (action & ASKFIRST)) return; - newAction = calloc((size_t) (1), sizeof(initAction)); - if (!newAction) { - message(LOG | CONSOLE, "Memory allocation failure\n"); + new_action = calloc((size_t) (1), sizeof(struct init_action)); + if (!new_action) { + message(LOG | CONSOLE, "Memory allocation failure"); loop_forever(); } - for (a = initActionList; a && a->nextPtr; a = a->nextPtr) ; - if (a) { - a->nextPtr = newAction; + + /* 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 */ + if ((strcmp(a->command, command) == 0) && + (strcmp(a->terminal, cons) ==0)) { + a->action = action; + free(new_action); + return; + } + last = a; + } + if (last) { + last->next = new_action; } else { - initActionList = newAction; + init_action_list = new_action; } - safe_strncpy(newAction->process, process, 255); - newAction->action = action; - safe_strncpy(newAction->console, cons, 255); - newAction->pid = 0; -// message(LOG|CONSOLE, "process='%s' action='%d' console='%s'\n", -// newAction->process, newAction->action, newAction->console); + strcpy(new_action->command, command); + new_action->action = action; + strcpy(new_action->terminal, cons); + messageD(LOG|CONSOLE, "command='%s' action='%d' terminal='%s'\n", + new_action->command, new_action->action, new_action->terminal); } -static void delete_initAction(initAction * action) +static void delete_init_action(struct init_action *action) { - initAction *a, *b = NULL; + struct init_action *a, *b = NULL; - for (a = initActionList; a; b = a, a = a->nextPtr) { + for (a = init_action_list; a; b = a, a = a->next) { if (a == action) { if (b == NULL) { - initActionList = a->nextPtr; + init_action_list = a->next; } else { - b->nextPtr = a->nextPtr; + b->next = a->next; } free(a); break; @@ -784,19 +837,19 @@ static void delete_initAction(initAction * action) /* 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 - * of "askfirst" shells). If CONFIG_FEATURE_USE_INITTAB - * _is_ defined, but /etc/inittab is missing, this + * actions(i.e., runs INIT_SCRIPT and then starts a pair + * of "askfirst" shells). If CONFIG_FEATURE_USE_INITTAB + * _is_ defined, but /etc/inittab is missing, this * results in the same set of default behaviors. - * */ + */ static void parse_inittab(void) { #ifdef CONFIG_FEATURE_USE_INITTAB FILE *file; - char buf[256], lineAsRead[256], tmpConsole[256]; - char *id, *runlev, *action, *process, *eol; - const struct initActionType *a = actions; - int foundIt; + char buf[INIT_BUFFS_SIZE], lineAsRead[INIT_BUFFS_SIZE]; + char tmpConsole[CONSOLE_BUFF_SIZE]; + char *id, *runlev, *action, *command, *eol; + const struct init_action_type *a = actions; file = fopen(INITTAB, "r"); @@ -804,33 +857,26 @@ static void parse_inittab(void) /* No inittab file -- set up some default behavior */ #endif /* Reboot on Ctrl-Alt-Del */ - new_initAction(CTRLALTDEL, "/sbin/reboot", console); + new_init_action(CTRLALTDEL, "/sbin/reboot", ""); /* Umount all filesystems on halt/reboot */ - new_initAction(SHUTDOWN, "/bin/umount -a -r", console); -#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__) + new_init_action(SHUTDOWN, "/bin/umount -a -r", ""); /* Swapoff on halt/reboot */ - new_initAction(SHUTDOWN, "/sbin/swapoff -a", console); -#endif - /* Askfirst shell on tty1 */ - new_initAction(ASKFIRST, LOGIN_SHELL, console); - /* Askfirst shell on tty2 */ - if (secondConsole != NULL) - new_initAction(ASKFIRST, LOGIN_SHELL, secondConsole); - /* Askfirst shell on tty3 */ - if (thirdConsole != NULL) - new_initAction(ASKFIRST, LOGIN_SHELL, thirdConsole); - /* Askfirst shell on tty4 */ - if (fourthConsole != NULL) - new_initAction(ASKFIRST, LOGIN_SHELL, fourthConsole); + if(ENABLE_SWAPONOFF) new_init_action(SHUTDOWN, "/sbin/swapoff -a", ""); + /* Prepare to restart init when a HUP is received */ + new_init_action(RESTART, "/sbin/init", ""); + /* Askfirst shell on tty1-4 */ + new_init_action(ASKFIRST, bb_default_login_shell, ""); + new_init_action(ASKFIRST, bb_default_login_shell, VC_2); + new_init_action(ASKFIRST, bb_default_login_shell, VC_3); + new_init_action(ASKFIRST, bb_default_login_shell, VC_4); /* sysinit */ - new_initAction(SYSINIT, INIT_SCRIPT, console); + new_init_action(SYSINIT, INIT_SCRIPT, ""); return; #ifdef CONFIG_FEATURE_USE_INITTAB } - while (fgets(buf, 255, file) != NULL) { - foundIt = FALSE; + while (fgets(buf, INIT_BUFFS_SIZE, file) != NULL) { /* Skip leading spaces */ for (id = buf; *id == ' ' || *id == '\t'; id++); @@ -849,7 +895,7 @@ static void parse_inittab(void) /* Separate the ID field from the runlevels */ runlev = strchr(id, ':'); if (runlev == NULL || *(runlev + 1) == '\0') { - message(LOG | CONSOLE, "Bad inittab entry: %s\n", lineAsRead); + message(LOG | CONSOLE, "Bad inittab entry: %s", lineAsRead); continue; } else { *runlev = '\0'; @@ -859,124 +905,181 @@ static void parse_inittab(void) /* Separate the runlevels from the action */ action = strchr(runlev, ':'); if (action == NULL || *(action + 1) == '\0') { - message(LOG | CONSOLE, "Bad inittab entry: %s\n", lineAsRead); + message(LOG | CONSOLE, "Bad inittab entry: %s", lineAsRead); continue; } else { *action = '\0'; ++action; } - /* Separate the action from the process */ - process = strchr(action, ':'); - if (process == NULL || *(process + 1) == '\0') { - message(LOG | CONSOLE, "Bad inittab entry: %s\n", lineAsRead); + /* Separate the action from the command */ + command = strchr(action, ':'); + if (command == NULL || *(command + 1) == '\0') { + message(LOG | CONSOLE, "Bad inittab entry: %s", lineAsRead); continue; } else { - *process = '\0'; - ++process; + *command = '\0'; + ++command; } /* Ok, now process it */ - a = actions; - while (a->name != 0) { + for (a = actions; a->name != 0; a++) { if (strcmp(a->name, action) == 0) { if (*id != '\0') { + if(strncmp(id, "/dev/", 5) == 0) + id += 5; strcpy(tmpConsole, "/dev/"); - strncat(tmpConsole, id, 200); + safe_strncpy(tmpConsole + 5, id, + CONSOLE_BUFF_SIZE - 5); id = tmpConsole; } - new_initAction(a->action, process, id); - foundIt = TRUE; + new_init_action(a->action, command, id); + break; } - a++; } - if (foundIt == TRUE) - continue; - else { + if (a->name == 0) { /* Choke on an unknown action */ - message(LOG | CONSOLE, "Bad inittab entry: %s\n", lineAsRead); + message(LOG | CONSOLE, "Bad inittab entry: %s", lineAsRead); } } + fclose(file); return; -#endif /* CONFIG_FEATURE_USE_INITTAB */ +#endif /* CONFIG_FEATURE_USE_INITTAB */ } +#ifdef CONFIG_FEATURE_USE_INITTAB +static void reload_signal(int sig ATTRIBUTE_UNUSED) +{ + struct init_action *a, *tmp; + + message(LOG, "Reloading /etc/inittab"); + + /* disable old entrys */ + for (a = init_action_list; a; a = a->next ) { + a->action = ONCE; + } + + parse_inittab(); + /* remove unused entrys */ + for (a = init_action_list; a; a = tmp) { + tmp = a->next; + if (a->action & (ONCE | SYSINIT | WAIT ) && + a->pid == 0 ) { + delete_init_action(a); + } + } + run_actions(RESPAWN); + return; +} +#endif /* CONFIG_FEATURE_USE_INITTAB */ -extern int init_main(int argc, char **argv) +int init_main(int argc, char **argv) { - initAction *a, *tmp; + struct init_action *a; pid_t wpid; - int status; -#ifndef DEBUG_INIT + if (argc > 1 && !strcmp(argv[1], "-q")) { + return kill(1,SIGHUP); + } +#if !ENABLE_DEBUG_INIT /* Expect to be invoked as init with PID=1 or be invoked as linuxrc */ - if (getpid() != 1 -#ifdef CONFIG_FEATURE_INITRD - && strstr(applet_name, "linuxrc") == NULL -#endif - ) + if (getpid() != 1 && + (!ENABLE_FEATURE_INITRD || !strstr(bb_applet_name, "linuxrc"))) { - show_usage(); + bb_show_usage(); } /* Set up sig handlers -- be sure to * clear all of these in run() */ - signal(SIGUSR1, halt_signal); - signal(SIGUSR2, halt_signal); + signal(SIGHUP, exec_signal); + signal(SIGQUIT, exec_signal); + signal(SIGUSR1, shutdown_signal); + signal(SIGUSR2, shutdown_signal); signal(SIGINT, ctrlaltdel_signal); - signal(SIGTERM, reboot_signal); + signal(SIGTERM, shutdown_signal); + signal(SIGCONT, cont_handler); + signal(SIGSTOP, stop_handler); + signal(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... */ init_reboot(RB_DISABLE_CAD); #endif - /* Figure out what kernel this is running */ - kernelVersion = get_kernel_revision(); + /* Figure out where the default console should be */ + console_init(); /* Close whatever files are open, and reset the console. */ close(0); close(1); close(2); - /* Figure out where the default console should be */ - console_init(); + if (device_open(console, O_RDWR | O_NOCTTY) == 0) { + set_term(); + close(0); + } - set_term(0); chdir("/"); setsid(); + { + const char * const *e; + /* Make sure environs is set to something sane */ + for(e = environment; *e; e++) + putenv((char *) *e); + } - /* Make sure PATH is set to something sane */ - putenv("PATH="_PATH_STDPATH); + if (argc > 1) setenv("RUNLEVEL", argv[1], 1); /* Hello world */ - message(MAYBE_CONSOLE|LOG, "init started: %s\n", full_version); + message(MAYBE_CONSOLE | LOG, "init started: %s", bb_msg_full_version); /* Make sure there is enough memory to do something useful. */ - check_memory(); + if (ENABLE_SWAPONOFF) { + struct sysinfo info; + + if (!sysinfo(&info) && + (info.mem_unit ? : 1) * (long long)info.totalram < MEGABYTE) + { + message(CONSOLE,"Low memory: forcing swapon."); + /* swapon -a requires /proc typically */ + new_init_action(SYSINIT, "/bin/mount -t proc proc /proc", ""); + /* Try to turn on swap */ + new_init_action(SYSINIT, "/sbin/swapon -a", ""); + run_actions(SYSINIT); /* wait and removing */ + } + } /* Check if we are supposed to be in single user mode */ if (argc > 1 && (!strcmp(argv[1], "single") || !strcmp(argv[1], "-s") || !strcmp(argv[1], "1"))) { - /* Ask first then start a shell on tty2-4 */ - if (secondConsole != NULL) - new_initAction(ASKFIRST, LOGIN_SHELL, secondConsole); - if (thirdConsole != NULL) - new_initAction(ASKFIRST, LOGIN_SHELL, thirdConsole); - if (fourthConsole != NULL) - new_initAction(ASKFIRST, LOGIN_SHELL, fourthConsole); - /* Start a shell on tty1 */ - new_initAction(RESPAWN, LOGIN_SHELL, console); + /* Start a shell on console */ + new_init_action(RESPAWN, bb_default_login_shell, ""); } else { /* 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., runs INIT_SCRIPT and then starts a pair * of "askfirst" shells */ parse_inittab(); } +#ifdef CONFIG_SELINUX + if (getenv("SELINUX_INIT") == NULL) { + int enforce = 0; + + putenv("SELINUX_INIT=YES"); + if (selinux_init_load_policy(&enforce) == 0) { + execv(argv[0], argv); + } else if (enforce > 0) { + /* SELinux in enforcing mode but load_policy failed */ + /* At this point, we probably can't open /dev/console, so log() won't work */ + message(CONSOLE,"Unable to load SELinux Policy. Machine is in enforcing mode. Halting now."); + exit(1); + } + } +#endif /* CONFIG_SELINUX */ + /* Make the command line just say "init" -- thats all, nothing else */ fixup_argv(argc, argv, "init"); @@ -984,65 +1087,48 @@ extern int init_main(int argc, char **argv) /* First run the sysinit command */ run_actions(SYSINIT); + /* Next run anything that wants to block */ run_actions(WAIT); + /* Next run anything to be run only once */ - for (a = initActionList; a; a = tmp) { - tmp = a->nextPtr; - if (a->action == ONCE) { - run(a->process, a->console, FALSE); - /* Now remove the "once" entry from the list */ - delete_initAction(a); - } - } - /* If there is nothing else to do, stop */ - if (initActionList == NULL) { - message(LOG | CONSOLE, - "No more tasks for init -- sleeping forever.\n"); - loop_forever(); - } + run_actions(ONCE); + +#ifdef CONFIG_FEATURE_USE_INITTAB + /* Redefine SIGHUP to reread /etc/inittab */ + signal(SIGHUP, reload_signal); +#else + signal(SIGHUP, SIG_IGN); +#endif /* CONFIG_FEATURE_USE_INITTAB */ + /* Now run the looping stuff for the rest of forever */ while (1) { - for (a = initActionList; a; a = a->nextPtr) { - /* Only run stuff with pid==0. If they have - * a pid, that means they are still running */ - if (a->pid == 0) { - switch (a->action) { - case RESPAWN: - /* run the respawn stuff */ - a->pid = run(a->process, a->console, FALSE); - break; - case ASKFIRST: - /* run the askfirst stuff */ - a->pid = run(a->process, a->console, TRUE); - break; - /* silence the compiler's incessant whining */ - default: - break; - } - } - } + /* run the respawn stuff */ + run_actions(RESPAWN); + + /* run the askfirst stuff */ + run_actions(ASKFIRST); + + /* Don't consume all CPU time -- sleep a bit */ + sleep(1); + /* Wait for a child process to exit */ - wpid = wait(&status); - if (wpid > 0) { + wpid = wait(NULL); + while (wpid > 0) { /* Find out who died and clean up their corpse */ - for (a = initActionList; a; a = a->nextPtr) { + 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(LOG, "Process '%s' (pid %d) exited. Scheduling it for restart.\n", - a->process, wpid); + message(LOG, "Process '%s' (pid %d) exited. " + "Scheduling it for restart.", + a->command, wpid); } } + /* see if anyone else is waiting to be reaped */ + wpid = waitpid (-1, NULL, WNOHANG); } - sleep(1); } } - -/* -Local Variables: -c-file-style: "linux" -c-basic-offset: 4 -tab-width: 4 -End: -*/