X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=init.c;h=c26314c8be9b5dfaf2b743d6a9d47fac9fb02483;hb=004015e9c4e8ff98bcbaf955cf42147218204da4;hp=95c2322f7f1eea947f8e73ddf21607adecf037df;hpb=9e7372584f5cbe50e15ba5d345b83a463322d21d;p=oweals%2Fbusybox.git diff --git a/init.c b/init.c index 95c2322f7..c26314c8b 100644 --- a/init.c +++ b/init.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * Mini init implementation for busybox * @@ -21,755 +22,1023 @@ * */ -#include "internal.h" +/* Turn this on to disable all the dangerous + rebooting stuff when debugging. +#define DEBUG_INIT +*/ + #include -#include #include -#include -#include #include +#include #include +#include +#include #include -#include -#include +#include +#include #include -#include -#include -#include -#include -#include -#include -#include /* for serial_struct */ -#include /* for vt_stat */ #include -#include +#include +#include +#include +#include "busybox.h" #ifdef BB_SYSLOGD -#include +# include +#endif + + +/* From */ +struct vt_stat { + 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 */ + +/* 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]; +}; + + + +#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 + +#if __GNU_LIBRARY__ > 5 + #include + #define init_reboot(magic) reboot(magic) +#else + #define init_reboot(magic) reboot(0xfee1dead, 672274793, magic) +#endif + +#ifndef _PATH_STDPATH +#define _PATH_STDPATH "/usr/bin:/bin:/usr/sbin:/sbin" #endif -#if ! defined BB_FEATURE_USE_PROCFS -#error Sorry, I depend on the /proc filesystem right now. + +#if defined BB_FEATURE_INIT_COREDUMPS +/* + * 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 -#ifndef KERNEL_VERSION #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 VT_PRIMARY "/dev/tty1" /* Primary virtual console */ -#define VT_SECONDARY "/dev/tty2" /* Virtual console */ -#define VT_LOG "/dev/tty3" /* Virtual console */ -#define SERIAL_CON0 "/dev/ttyS0" /* Primary serial console */ -#define SERIAL_CON1 "/dev/ttyS1" /* Serial console */ -#define SHELL "-sh" /* Default shell */ -#define INITTAB "/etc/inittab" /* inittab file location */ -#define INIT_SCRIPT "/etc/init.d/rcS" /* Default sysinit script. */ +#define VT_PRIMARY "/dev/tty1" /* Primary virtual console */ +#define VT_SECONDARY "/dev/tty2" /* Virtual console */ +#define VT_THIRD "/dev/tty3" /* Virtual console */ +#define VT_FOURTH "/dev/tty4" /* Virtual console */ +#define VT_LOG "/dev/tty5" /* Virtual console */ +#define SERIAL_CON0 "/dev/ttyS0" /* Primary serial console */ +#define SERIAL_CON1 "/dev/ttyS1" /* Serial console */ +#define SHELL "-/bin/sh" /* Default shell */ +#define INITTAB "/etc/inittab" /* inittab file location */ +#ifndef INIT_SCRIPT +#define INIT_SCRIPT "/etc/init.d/rcS" /* Default sysinit script. */ +#endif -#define LOG 0x1 -#define CONSOLE 0x2 +#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; /* Allowed init action types */ typedef enum { - SYSINIT=1, - RESPAWN, - ASKFIRST, - WAIT, - ONCE + SYSINIT = 1, + RESPAWN, + ASKFIRST, + WAIT, + ONCE, + CTRLALTDEL, + SHUTDOWN } initActionEnum; -/* And now a list of the actions we support in the version of init */ -typedef struct initActionType{ - const char* name; - initActionEnum action; +/* A mapping between "inittab" action name strings and action type codes. */ +typedef struct initActionType { + const char *name; + initActionEnum action; } initActionType; static const struct initActionType actions[] = { - {"sysinit", SYSINIT}, - {"respawn", RESPAWN}, - {"askfirst", ASKFIRST}, - {"wait", WAIT}, - {"once", ONCE}, - {0} + {"sysinit", SYSINIT}, + {"respawn", RESPAWN}, + {"askfirst", ASKFIRST}, + {"wait", WAIT}, + {"once", ONCE}, + {"ctrlaltdel", CTRLALTDEL}, + {"shutdown", SHUTDOWN}, + {0, 0} }; -/* Set up a linked list of initactions, to be read from inittab */ +/* Set up a linked list of initActions, to be read from inittab */ typedef struct initActionTag initAction; struct initActionTag { - pid_t pid; - char process[256]; - char console[256]; - initAction *nextPtr; - initActionEnum action; + pid_t pid; + char process[256]; + char console[256]; + initAction *nextPtr; + initActionEnum action; }; -initAction* initActionList = NULL; +static initAction *initActionList = NULL; -static char *console = _PATH_CONSOLE; -static char *second_console = VT_SECONDARY; -static char *log = VT_LOG; -static int kernel_version = 0; +static char *secondConsole = VT_SECONDARY; +static char *thirdConsole = VT_THIRD; +static char *fourthConsole = VT_FOURTH; +static char *log = VT_LOG; +static int kernelVersion = 0; +static char termType[32] = "TERM=linux"; +static char console[32] = _PATH_CONSOLE; + +static void delete_initAction(initAction * action); -/* try to open up the specified device */ -int device_open(char *device, int mode) -{ - int m, f, fd = -1; - - m = mode | O_NONBLOCK; - - /* Retry up to 5 times */ - for (f = 0; f < 5; f++) - if ((fd = open(device, m)) >= 0) - break; - if (fd < 0) - return fd; - /* Reset original flags. */ - if (m != mode) - fcntl(fd, F_SETFL, mode); - return fd; -} -/* print a message to the specified device: - * device may be bitwise-or'd from LOG | CONSOLE */ -void message(int device, char *fmt, ...) +/* Print a message to the specified device. + * Device may be bitwise-or'd from LOG | CONSOLE */ +static void message(int device, char *fmt, ...) + __attribute__ ((format (printf, 2, 3))); +static void message(int device, char *fmt, ...) { - va_list arguments; - int fd; + va_list arguments; + int fd; #ifdef BB_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(LOG_DAEMON|LOG_NOTICE, msg); - } + /* Log the message to syslogd */ + if (device & LOG) { + char msg[1024]; + va_start(arguments, fmt); + vsnprintf(msg, sizeof(msg), fmt, arguments); + va_end(arguments); + openlog(applet_name, 0, LOG_USER); + syslog(LOG_USER|LOG_INFO, msg); + closelog(); + } #else - static int log_fd=-1; - - /* 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) { - log_fd=-1; - fprintf(stderr, "Bummer, can't write to log on %s!\r\n", log); - fflush(stderr); - return; + static int log_fd = -1; + + /* 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) { + log_fd = -2; + fprintf(stderr, "Bummer, can't write to log on %s!\r\n", log); + log = NULL; + device = CONSOLE; + } + } + if ((device & LOG) && (log_fd >= 0)) { + va_start(arguments, fmt); + vdprintf(log_fd, fmt, arguments); + va_end(arguments); } - } - if ( (device & LOG) && (log_fd >= 0) ) { - va_start(arguments, fmt); - vdprintf(log_fd, fmt, arguments); - va_end(arguments); - } #endif - if (device & CONSOLE) { - /* 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); - close(fd); - } else { - fprintf(stderr, "Bummer, can't print: "); - va_start(arguments, fmt); - vfprintf(stderr, fmt, arguments); - fflush(stderr); - va_end(arguments); + if (device & CONSOLE) { + /* 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); + close(fd); + } else { + fprintf(stderr, "Bummer, can't print: "); + va_start(arguments, fmt); + vfprintf(stderr, fmt, arguments); + va_end(arguments); + } } - } } - /* Set terminal settings to reasonable defaults */ -void set_term( int fd) +static void set_term(int fd) { - struct termios tty; - static const char control_characters[] = { - '\003', '\034', '\177', '\025', '\004', '\0', - '\1', '\0', '\021', '\023', '\032', '\0', '\022', - '\017', '\027', '\026', '\0' - }; + struct termios tty; + + tcgetattr(fd, &tty); - tcgetattr(fd, &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[VSTART] = 17; /* C-q */ + tty.c_cc[VSTOP] = 19; /* C-s */ + tty.c_cc[VSUSP] = 26; /* C-z */ - /* set control chars */ - memcpy(tty.c_cc, control_characters, sizeof(control_characters)); + /* use line dicipline 0 */ + tty.c_line = 0; - /* 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; - /* Make it be sane */ - //tty.c_cflag &= CBAUD|CBAUDEX|CSIZE|CSTOPB|PARENB|PARODD; - //tty.c_cflag |= HUPCL|CLOCAL; - /* input modes */ - tty.c_iflag = ICRNL|IXON|IXOFF; + /* input modes */ + tty.c_iflag = ICRNL | IXON | IXOFF; - /* output modes */ - tty.c_oflag = OPOST|ONLCR; + /* output modes */ + tty.c_oflag = OPOST | ONLCR; - /* local modes */ - tty.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOKE|IEXTEN; + /* local modes */ + tty.c_lflag = + ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN; - tcsetattr(fd, TCSANOW, &tty); + tcsetattr(fd, TCSANOW, &tty); } -/* How much memory does this machine have? */ -static int mem_total() +/* How much memory does this machine have? + Units are kBytes to avoid overflow on 4GB machines */ +static int check_free_memory() { - char s[80]; - char *p = "/proc/meminfo"; - FILE *f; - const char pattern[] = "MemTotal:"; - - if ((f = fopen(p, "r")) < 0) { - message(LOG, "Error opening %s: %s\n", p, strerror( errno)); - return -1; - } - while (NULL != fgets(s, 79, f)) { - p = strstr(s, pattern); - if (NULL != p) { - fclose(f); - return (atoi(p + strlen(pattern))); + struct sysinfo info; + unsigned int result, u, s=10; + + if (sysinfo(&info) != 0) { + perror_msg("Error checking free memory"); + return -1; } - } - 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; } static void console_init() { - int fd; - int tried_devcons = 0; - int tried_vtprimary = 0; - struct serial_struct sr; - char *s; - - if ((s = getenv("CONSOLE")) != NULL) { - console = s; - } -#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) - console = SERIAL_CON0; - else if (strcmp( s, "ttyb" )==0) - console = SERIAL_CON1; - } -#endif - else { + int fd; + int tried_devcons = 0; + int tried_vtprimary = 0; struct vt_stat vt; - static char the_console[13]; + struct serial_struct sr; + char *s; - console = the_console; - /* 2.2 kernels: identify the real console backend and try to use it */ - if (ioctl(0, TIOCGSERIAL, &sr) == 0) { - /* this is a serial console */ - snprintf( the_console, sizeof the_console, "/dev/ttyS%d", sr.line ); + if ((s = getenv("TERM")) != NULL) { + snprintf(termType, sizeof(termType) - 1, "TERM=%s", s); } - else if (ioctl(0, VT_GETSTATE, &vt) == 0) { - /* this is linux virtual tty */ - snprintf( the_console, sizeof the_console, "/dev/tty%d", vt.v_active ); - } else { - console = _PATH_CONSOLE; - tried_devcons++; + + if ((s = getenv("CONSOLE")) != NULL) { + safe_strncpy(console, s, sizeof(console)); } - } - - while ((fd = open(console, O_RDONLY | O_NONBLOCK)) < 0) { - /* Can't open selected console -- try /dev/console */ - if (!tried_devcons) { - tried_devcons++; - console = _PATH_CONSOLE; - continue; +#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, SERIAL_CON0, sizeof(console)); + else if (strcmp(s, "ttyb") == 0) + safe_strncpy(console, SERIAL_CON1, sizeof(console)); } - /* Can't open selected console -- try vt1 */ - if (!tried_vtprimary) { - tried_vtprimary++; - console = VT_PRIMARY; - continue; +#endif + 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 */ + snprintf(console, sizeof(console) - 1, "/dev/ttyS%d", sr.line); + } else if (ioctl(0, VT_GETSTATE, &vt) == 0) { + /* this is linux virtual tty */ + snprintf(console, sizeof(console) - 1, "/dev/tty%d", + vt.v_active); + } else { + safe_strncpy(console, _PATH_CONSOLE, sizeof(console)); + tried_devcons++; + } } - break; - } - if (fd < 0) - /* Perhaps we should panic here? */ - console = "/dev/null"; - else { - /* check for serial console and disable logging to tty3 & running a - * shell to tty2 */ - if (ioctl(0,TIOCGSERIAL,&sr) == 0) { - message(LOG|CONSOLE, "serial console detected. Disabling 2nd virtual terminal.\r\n", console ); - log = NULL; - second_console = NULL; + + 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, VT_PRIMARY, sizeof(console)); + continue; + } + break; + } + if (fd < 0) { + /* Perhaps we should panic here? */ + safe_strncpy(console, "/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; + /* 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.\r\n"); + } + close(fd); } - close(fd); - } - message(LOG, "console=%s\n", console ); + message(LOG, "console=%s\n", console); } - -static int waitfor(int pid) + +static void fixup_argv(int argc, char **argv, char *new_argv0) { - int status, wpid; - - while (1) { - wpid = wait(&status); - if (wpid > 0 ) { - message(LOG, "pid %d exited, status=0x%x.\n", wpid, status); - break; + int len; + /* Fix up argv[0] to be certain we claim to be init */ + len = strlen(argv[0]); + memset(argv[0], 0, len); + strncpy(argv[0], new_argv0, len); + + /* Wipe argv[1]-argv[N] so they don't clutter the ps listing */ + len = 1; + while (argc > len) { + memset(argv[len], 0, strlen(argv[len])); + len++; } - if (wpid == pid ) - break; - } - return wpid; } -static pid_t run(char* command, - char *terminal, int get_enter) -{ - int i; - pid_t pid; - char* tmpCmd; - char* cmd[255]; - static const char press_enter[] = - "\nPlease press Enter to activate this console. "; - if ((pid = fork()) == 0) { - pid_t shell_pgid = getpid (); +static pid_t run(char *command, char *terminal, int get_enter) +{ + int i, j; + int fd; + pid_t pid; + char *tmpCmd, *s; + char *cmd[255], *cmdpath; + char buf[255]; + struct stat sb; + static const char press_enter[] = + +#ifdef CUSTOMIZED_BANNER +#include CUSTOMIZED_BANNER +#endif - /* Clean up */ - close(0); - close(1); - close(2); - setsid(); + "\nPlease press Enter to activate this console. "; + char *environment[MAXENV+1] = { + termType, + "HOME=/", + "PATH=/usr/bin:/bin:/usr/sbin:/sbin", + "SHELL=/bin/sh", + "USER=root", + NULL + }; - if (device_open(terminal, O_RDWR) < 0) { - message(LOG|CONSOLE, "Bummer, can't open %s\r\n", terminal); - exit(1); - } - dup(0); - dup(0); - /* Grab control of the terminal. */ - if (tcsetpgrp (0, getpgrp()) < 0) { - message(LOG|CONSOLE, "tcsetpgrp error: %s\r\n", strerror(errno)); + /* 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; + } } - set_term(0); - /* Reset signal handlers set for parent process */ - signal(SIGUSR1, SIG_DFL); - signal(SIGUSR2, SIG_DFL); - signal(SIGINT, SIG_DFL); - signal(SIGTERM, SIG_DFL); - - - if (get_enter==TRUE) { - /* - * 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 - * specifies. - */ - char c; - message(LOG, "Waiting for enter to start '%s' (pid %d, console %s)\r\n", - command, shell_pgid, terminal ); - write(fileno(stdout), press_enter, sizeof(press_enter) - 1); - read(fileno(stdin), &c, 1); + if ((pid = fork()) == 0) { + /* Clean up */ + ioctl(0, TIOCNOTTY, 0); + close(0); + close(1); + close(2); + setsid(); + + /* Reset signal handlers set for parent process */ + signal(SIGUSR1, SIG_DFL); + signal(SIGUSR2, SIG_DFL); + signal(SIGINT, SIG_DFL); + signal(SIGTERM, SIG_DFL); + signal(SIGHUP, SIG_DFL); + + 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); + } + message(LOG | CONSOLE, "Bummer, can't open %s\r\n", terminal); + exit(1); + } + 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; + cmd[1] = "-c"; + strcpy(buf, "exec "); + strncat(buf, command, sizeof(buf) - strlen(buf) - 1); + cmd[2] = buf; + cmd[3] = NULL; + } else { + /* Convert command (char*) into cmd (char**, one word per string) */ + for (tmpCmd = command, i = 0; + (tmpCmd = strsep(&command, " \t")) != NULL;) { + if (*tmpCmd != '\0') { + cmd[i] = tmpCmd; + tmpCmd++; + i++; + } + } + cmd[i] = NULL; + } + + cmdpath = cmd[0]; + + /* + 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 + (like "-/bin/sh"). + */ + + if (*cmdpath == '-') { + + /* skip over the dash */ + ++cmdpath; + + /* find the last component in the command pathname */ + s = get_last_path_component(cmdpath); + + /* make a new argv[0] */ + if ((cmd[0] = malloc(strlen(s)+2)) == NULL) { + message(LOG | CONSOLE, "malloc failed"); + cmd[0] = cmdpath; + } else { + cmd[0][0] = '-'; + strcpy(cmd[0]+1, s); + } + } + + if (get_enter == TRUE) { + /* + * 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 + * specifies. + */ +#ifdef DEBUG_INIT + message(LOG, "Waiting for enter to start '%s' (pid %d, console %s)\r\n", + cmd[0], getpid(), terminal); +#endif + write(fileno(stdout), press_enter, sizeof(press_enter) - 1); + getc(stdin); + } + +#ifdef DEBUG_INIT + /* Log the process name and args */ + message(LOG, "Starting pid %d, console %s: '%s'\r\n", + getpid(), terminal, command); +#endif + +#if defined BB_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); + } +#endif + + /* Now run it. The new program will take over this PID, + * so nothing further in init.c should be run. */ + execve(cmdpath, cmd, environment); + + /* We're still here? Some error happened. */ + message(LOG | CONSOLE, "Bummer, could not run '%s': %s\n", cmdpath, + strerror(errno)); + exit(-1); } + return pid; +} + +static int waitfor(char *command, char *terminal, int get_enter) +{ + int status, wpid; + int pid = run(command, terminal, get_enter); - /* Convert command (char*) into cmd (char**, one word per string) */ - for (tmpCmd=command, i=0; (tmpCmd=strsep(&command, " \t")) != NULL;) { - if (*tmpCmd != '\0') { - cmd[i] = tmpCmd; - tmpCmd++; - i++; - } + while (1) { + wpid = wait(&status); + if (wpid > 0 && wpid != pid) { + continue; + } + if (wpid == pid) + break; } - cmd[i] = NULL; - - /* Log the process name and args */ - message(LOG, "Starting pid %d, console %s: '%s'\r\n", - shell_pgid, terminal, cmd[0]); - - /* Now run it. The new program will take over this PID, - * so nothing further in init.c should be run. */ - execvp(cmd[0], cmd); - - /* We're still here? Some error happened. */ - message(LOG|CONSOLE, "Bummer, could not run '%s': %s\n", cmd[0], - strerror(errno)); - exit(-1); - } - return pid; + return wpid; } /* Make sure there is enough memory to do something useful. * - * Calls swapon if needed so be sure /proc is mounted. */ + * Calls "swapon -a" if needed so be sure /etc/fstab is present... */ static void check_memory() { - struct stat statbuf; - - if (mem_total() > 3500) + struct stat statBuf; + + if (check_free_memory() > 1000) + return; + + 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; - if (stat("/etc/fstab", &statbuf) == 0) { - /* Try to turn on swap */ - waitfor(run("/bin/swapon swapon -a", log, FALSE)); - if (mem_total() < 3500) - goto goodnight; - } else - goto goodnight; - return; - -goodnight: - message(CONSOLE, "Sorry, your computer does not have enough memory.\r\n"); - while (1) sleep(1); + goodnight: + message(CONSOLE, + "Sorry, your computer does not have enough memory.\r\n"); + while (1) + sleep(1); } +/* 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; + if (a->action == action) { + waitfor(a->process, a->console, FALSE); + delete_initAction(a); + } + } +} + + #ifndef DEBUG_INIT static void shutdown_system(void) { - /* Allow Ctrl-Alt-Del to reboot system. */ - reboot(RB_ENABLE_CAD); - message(CONSOLE, "\r\nThe system is going down NOW !!\r\n"); - sync(); - - /* Send signals to every process _except_ pid 1 */ - message(CONSOLE, "Sending SIGHUP to all processes.\r\n"); - kill(-1, SIGHUP); - sleep(2); - sync(); - - message(CONSOLE, "Sending SIGKILL to all processes.\r\n"); - kill(-1, SIGKILL); - sleep(1); - - message(CONSOLE, "Disabling swap.\r\n"); - waitfor(run( "swapoff -a", console, FALSE)); - message(CONSOLE, "Unmounting filesystems.\r\n"); - waitfor(run( "umount -a", console, FALSE)); - sync(); - if (kernel_version > 0 && kernel_version <= 2 * 65536 + 2 * 256 + 11) { - /* bdflush, kupdate not needed for kernels >2.2.11 */ - message(CONSOLE, "Flushing buffers.\r\n"); - bdflush(1, 0); + + /* first disable our SIGHUP signal */ + signal(SIGHUP, SIG_DFL); + + /* Allow Ctrl-Alt-Del to reboot system. */ + init_reboot(RB_ENABLE_CAD); + + message(CONSOLE|LOG, "\r\nThe system is going down NOW !!\r\n"); + sync(); + + /* Send signals to every process _except_ pid 1 */ + message(CONSOLE|LOG, "Sending SIGTERM to all processes.\r\n"); + kill(-1, SIGTERM); + sleep(1); + sync(); + + message(CONSOLE|LOG, "Sending SIGKILL to all processes.\r\n"); + 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 halt_signal(int sig) { - shutdown_system(); - message(CONSOLE, - "The system is halted. Press CTRL-ALT-DEL or turn off power\r\n"); - sync(); -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) - if (sig == SIGUSR2) - reboot(RB_POWER_OFF); - else -#endif - reboot(RB_HALT_SYSTEM); - exit(0); + shutdown_system(); + message(CONSOLE|LOG, + "The system is halted. Press %s or turn off power\r\n", + (secondConsole == NULL) /* serial console */ + ? "Reset" : "CTRL-ALT-DEL"); + 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); + exit(0); } static void reboot_signal(int sig) { - shutdown_system(); - message(CONSOLE, "Please stand by while rebooting the system.\r\n"); - sync(); - reboot(RB_AUTOBOOT); - exit(0); -} + shutdown_system(); + message(CONSOLE|LOG, "Please stand by while rebooting the system.\r\n"); + sync(); -#endif + /* allow time for last message to reach serial console */ + sleep(2); -void new_initAction (const struct initActionType *a, - char* process, char* cons) + init_reboot(RB_AUTOBOOT); + exit(0); +} + +static void ctrlaltdel_signal(int sig) { - initAction* newAction; + run_actions(CTRLALTDEL); +} - /* If BusyBox detects that a serial console is in use, - * then entries containing non-empty id fields will _not_ be run. - */ - if (second_console != NULL && *cons != '\0') - return; +#endif /* ! DEBUG_INIT */ - newAction = calloc ((size_t)(1), sizeof(initAction)); - if (!newAction) { - fprintf(stderr, "Memory allocation failure\n"); - while (1) sleep(1); - } - newAction->nextPtr = initActionList; - initActionList = newAction; - strncpy( newAction->process, process, 255); - newAction->action = a->action; - if (*cons != '\0') +static void new_initAction(initActionEnum action, char *process, char *cons) +{ + initAction *newAction; + + 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; + + newAction = calloc((size_t) (1), sizeof(initAction)); + if (!newAction) { + message(LOG | CONSOLE, "Memory allocation failure\n"); + while (1) + sleep(1); + } + newAction->nextPtr = initActionList; + initActionList = newAction; + strncpy(newAction->process, process, 255); + newAction->action = action; strncpy(newAction->console, cons, 255); - else - strncpy(newAction->console, console, 255); - newAction->pid = 0; + newAction->pid = 0; +// message(LOG|CONSOLE, "process='%s' action='%d' console='%s'\n", +// newAction->process, newAction->action, newAction->console); } -void delete_initAction (initAction *action) +static void delete_initAction(initAction * action) { - initAction *a, *b=NULL; - for( a=initActionList ; a; b=a, a=a->nextPtr) { - if (a == action && b != NULL) { - b->nextPtr=a->nextPtr; - free( a); - break; + initAction *a, *b = NULL; + + for (a = initActionList; a; b = a, a = a->nextPtr) { + if (a == action) { + if (b == NULL) { + initActionList = a->nextPtr; + } else { + b->nextPtr = a->nextPtr; + } + free(a); + break; + } } - } } /* NOTE that if BB_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 BB_FEATURE_USE_INITTAB - * _is_ defined, but /etc/inittab is missing == same - * default behavior. + * of "askfirst" shells). If BB_FEATURE_USE_INITTAB + * _is_ defined, but /etc/inittab is missing, this + * results in the same set of default behaviors. * */ -void parse_inittab(void) +static void parse_inittab(void) { #ifdef BB_FEATURE_USE_INITTAB - FILE* file; - char buf[256], buf1[256]; - char *p, *q, *r, *s; - const struct initActionType *a = actions; - int foundIt; + FILE *file; + char buf[256], lineAsRead[256], tmpConsole[256]; + char *id, *runlev, *action, *process, *eol; + const struct initActionType *a = actions; + int foundIt; - file = fopen(INITTAB, "r"); - if (file == NULL) { - /* No inittab file -- set up some default behavior */ + file = fopen(INITTAB, "r"); + if (file == NULL) { + /* No inittab file -- set up some default behavior */ #endif - /* Askfirst shell on tty1 */ - new_initAction( &(actions[3]), SHELL, console ); - /* Askfirst shell on tty2 */ - if (second_console != NULL) - new_initAction( &(actions[3]), SHELL, second_console ); - /* sysinit */ - new_initAction( &(actions[0]), INIT_SCRIPT, console ); - - return; + /* Reboot on Ctrl-Alt-Del */ + new_initAction(CTRLALTDEL, "/sbin/reboot", console); + /* Swapoff on halt/reboot */ + new_initAction(SHUTDOWN, "/sbin/swapoff -a", console); + /* Umount all filesystems on halt/reboot */ + new_initAction(SHUTDOWN, "/bin/umount -a -r", console); + /* Askfirst shell on tty1 */ + new_initAction(ASKFIRST, SHELL, console); + /* Askfirst shell on tty2 */ + if (secondConsole != NULL) + new_initAction(ASKFIRST, SHELL, secondConsole); + /* Askfirst shell on tty3 */ + if (thirdConsole != NULL) + new_initAction(ASKFIRST, SHELL, thirdConsole); + /* Askfirst shell on tty4 */ + if (fourthConsole != NULL) + new_initAction(ASKFIRST, SHELL, fourthConsole); + /* sysinit */ + new_initAction(SYSINIT, INIT_SCRIPT, console); + + return; #ifdef BB_FEATURE_USE_INITTAB - } - - while ( fgets(buf, 255, file) != NULL) { - foundIt=FALSE; - for(p = buf; *p == ' ' || *p == '\t'; p++); - if (*p == '#' || *p == '\n') continue; - - /* Trim the trailing \n */ - q = strrchr( p, '\n'); - if (q != NULL) - *q='\0'; - - /* Keep a copy around for posterity's sake (and error msgs) */ - strcpy(buf1, buf); - - /* Grab the ID field */ - s=p; - p = strchr( p, ':'); - if ( p != NULL || *(p+1) != '\0' ) { - *p='\0'; - ++p; } - /* Now peal off the process field from the end - * of the string */ - q = strrchr( p, ':'); - if ( q == NULL || *(q+1) == '\0' ) { - fprintf(stderr, "Bad inittab entry: %s\n", buf1); - continue; - } else { - *q='\0'; - ++q; - } + while (fgets(buf, 255, file) != NULL) { + foundIt = FALSE; + /* Skip leading spaces */ + for (id = buf; *id == ' ' || *id == '\t'; id++); + + /* Skip the line if it's a comment */ + if (*id == '#' || *id == '\n') + continue; + + /* Trim the trailing \n */ + eol = strrchr(id, '\n'); + if (eol != NULL) + *eol = '\0'; + + /* Keep a copy around for posterity's sake (and error msgs) */ + strcpy(lineAsRead, buf); + + /* 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); + continue; + } else { + *runlev = '\0'; + ++runlev; + } - /* Now peal off the action field */ - r = strrchr( p, ':'); - if ( r == NULL || *(r+1) == '\0') { - fprintf(stderr, "Bad inittab entry: %s\n", buf1); - continue; - } else { - ++r; - } + /* Separate the runlevels from the action */ + action = strchr(runlev, ':'); + if (action == NULL || *(action + 1) == '\0') { + message(LOG | CONSOLE, "Bad inittab entry: %s\n", lineAsRead); + continue; + } else { + *action = '\0'; + ++action; + } - /* Ok, now process it */ - a = actions; - while (a->name != 0) { - if (strcmp(a->name, r) == 0) { - new_initAction( a, q, s); - foundIt=TRUE; - } - a++; - } - if (foundIt==TRUE) - continue; - else { - /* Choke on an unknown action */ - fprintf(stderr, "Bad inittab entry: %s\n", buf1); + /* Separate the action from the process */ + process = strchr(action, ':'); + if (process == NULL || *(process + 1) == '\0') { + message(LOG | CONSOLE, "Bad inittab entry: %s\n", lineAsRead); + continue; + } else { + *process = '\0'; + ++process; + } + + /* Ok, now process it */ + a = actions; + while (a->name != 0) { + if (strcmp(a->name, action) == 0) { + if (*id != '\0') { + strcpy(tmpConsole, "/dev/"); + strncat(tmpConsole, id, 200); + id = tmpConsole; + } + new_initAction(a->action, process, id); + foundIt = TRUE; + } + a++; + } + if (foundIt == TRUE) + continue; + else { + /* Choke on an unknown action */ + message(LOG | CONSOLE, "Bad inittab entry: %s\n", lineAsRead); + } } - } - return; -#endif + return; +#endif /* BB_FEATURE_USE_INITTAB */ } + + extern int init_main(int argc, char **argv) { - initAction *a; - pid_t wpid; - int status; + initAction *a, *tmp; + pid_t wpid; + int status; #ifndef DEBUG_INIT - /* Expect to be PID 1 iff we are run as init (not linuxrc) */ - if (getpid() != 1 && strstr(argv[0], "init")!=NULL ) { - usage( "init\n\nInit is the parent of all processes.\n\n" - "This version of init is designed to be run only by the kernel\n"); - } - - /* from the controlling terminal */ - setsid(); - - /* Set up sig handlers -- be sure to clear all of these in run() */ - signal(SIGUSR1, halt_signal); - signal(SIGUSR2, reboot_signal); - signal(SIGINT, reboot_signal); - signal(SIGTERM, reboot_signal); - - /* Turn off rebooting via CTL-ALT-DEL -- we get a - * SIGINT on CAD so we can shut things down gracefully... */ - reboot(RB_DISABLE_CAD); -#endif - - /* 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); - set_term(0); - - /* Make sure PATH is set to something sane */ - putenv(_PATH_STDPATH); - - - /* Hello world */ + /* Expect to be invoked as init with PID=1 or be invoked as linuxrc */ + if (getpid() != 1 +#ifdef BB_FEATURE_LINUXRC + && strstr(applet_name, "linuxrc") == NULL +#endif + ) + { + show_usage(); + } + /* Set up sig handlers -- be sure to + * clear all of these in run() */ + signal(SIGUSR1, halt_signal); + signal(SIGUSR2, halt_signal); + signal(SIGINT, ctrlaltdel_signal); + signal(SIGTERM, reboot_signal); + + /* 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); + set_term(0); + chdir("/"); + setsid(); + + /* Make sure PATH is set to something sane */ + putenv("PATH="_PATH_STDPATH); + + /* Hello world */ #ifndef DEBUG_INIT - message(CONSOLE|LOG, - "init started: BusyBox v%s (%s) multi-call binary\r\n", - BB_VER, BB_BT); + message( +#if ! defined BB_FEATURE_EXTRA_QUIET + CONSOLE| +#endif + LOG, + "init started: %s\r\n", full_version); #else - message(CONSOLE|LOG, - "init(%d) started: BusyBox v%s (%s) multi-call binary\r\n", - getpid(), BB_VER, BB_BT); + message( +#if ! defined BB_FEATURE_EXTRA_QUIET + CONSOLE| +#endif + LOG, + "init(%d) started: %s\r\n", getpid(), full_version); #endif - - /* Mount /proc */ - if (mount ("proc", "/proc", "proc", 0, 0) == 0) { - message(CONSOLE|LOG, "Mounting /proc: done.\n"); - kernel_version = get_kernel_revision(); - } else - message(CONSOLE|LOG, "Mounting /proc: failed!\n"); - - /* Make sure there is enough memory to do something useful. */ - check_memory(); - - /* 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 */ - if (second_console != NULL) - new_initAction( &(actions[3]), SHELL, second_console); - /* Ask first then start a shell on tty1 */ - new_initAction( &(actions[3]), SHELL, console); - } else { - /* Not in single user mode -- see what inittab says */ - - /* NOTE that if BB_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 */ - parse_inittab(); - } - - /* Now run everything that needs to be run */ - - /* First run the sysinit command */ - for( a=initActionList ; a; a=a->nextPtr) { - if (a->action == SYSINIT) { - waitfor(run(a->process, console, FALSE)); - /* Now remove the "sysinit" entry from the list */ - delete_initAction( a); + + /* Make sure there is enough memory to do something useful. */ + check_memory(); + + /* 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, SHELL, secondConsole); + if (thirdConsole != NULL) + new_initAction(ASKFIRST, SHELL, thirdConsole); + if (fourthConsole != NULL) + new_initAction(ASKFIRST, SHELL, fourthConsole); + /* Start a shell on tty1 */ + new_initAction(RESPAWN, SHELL, console); + } else { + /* Not in single user mode -- see what inittab says */ + + /* NOTE that if BB_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 */ + parse_inittab(); } - } - /* Next run anything that wants to block */ - for( a=initActionList ; a; a=a->nextPtr) { - if (a->action == WAIT) { - waitfor(run(a->process, console, FALSE)); - /* Now remove the "wait" entry from the list */ - delete_initAction( a); + + /* Make the command line just say "init" -- thats all, nothing else */ + fixup_argv(argc, argv, "init"); + + /* Now run everything that needs to be run */ + + /* First run the sysinit command */ + for (a = initActionList; a; a = tmp) { + tmp = a->nextPtr; + if (a->action == SYSINIT) { + waitfor(a->process, a->console, FALSE); + /* Now remove the "sysinit" entry from the list */ + delete_initAction(a); + } } - } - /* Next run anything to be run only once */ - for( a=initActionList ; a; a=a->nextPtr) { - if (a->action == ONCE) { - run(a->process, console, FALSE); - /* Now remove the "once" entry from the list */ - delete_initAction( a); + /* Next run anything that wants to block */ + for (a = initActionList; a; a = tmp) { + tmp = a->nextPtr; + if (a->action == WAIT) { + waitfor(a->process, a->console, FALSE); + /* Now remove the "wait" entry from the list */ + delete_initAction(a); + } } - } - - /* 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, console, FALSE); - break; - case ASKFIRST: - /* run the askfirst stuff */ - a->pid = run(a->process, console, TRUE); - break; - /* silence the compiler's incessant whining */ - default: - break; + /* 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); } - } } - /* Wait for a child process to exit */ - wpid = wait(&status); - if (wpid > 0 ) { - /* Find out who died and clean up their corpse */ - for( a=initActionList ; a; a=a->nextPtr) { - if (a->pid==wpid) { - a->pid=0; - message(LOG, "Process '%s' (pid %d) exited. Scheduling it for restart.\n", - a->process, wpid); + /* If there is nothing else to do, stop */ + if (initActionList == NULL) { + message(LOG | CONSOLE, + "No more tasks for init -- sleeping forever.\n"); + while (1) + sleep(1); + } + + /* 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; + } + } + } + /* Wait for a child process to exit */ + wpid = wait(&status); + if (wpid > 0) { + /* Find out who died and clean up their corpse */ + for (a = initActionList; a; a = a->nextPtr) { + if (a->pid == wpid) { + a->pid = 0; + message(LOG, + "Process '%s' (pid %d) exited. Scheduling it for restart.\n", + a->process, wpid); + } + } } - } + sleep(1); } - sleep(1); - } } +/* +Local Variables: +c-file-style: "linux" +c-basic-offset: 4 +tab-width: 4 +End: +*/