X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=init.c;h=ab4ad56519f2085ebd46226be8cddba1fa5bde87;hb=79565b6c910e76c19cd5c0729659d6e96472c785;hp=3c800b9b2ad8bc7acdd87d1e09865e2affc24903;hpb=2cb55077e2f65f17dbc8933eec47760bcc2a6ba1;p=oweals%2Fbusybox.git diff --git a/init.c b/init.c index 3c800b9b2..ab4ad5651 100644 --- a/init.c +++ b/init.c @@ -1,3 +1,4 @@ +/* vi: set sw=4 ts=4: */ /* * Mini init implementation for busybox * @@ -21,581 +22,1039 @@ * */ +/* Turn this on to disable all the dangerous + rebooting stuff when debugging. +#define DEBUG_INIT +*/ + #include "internal.h" #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 #ifdef BB_SYSLOGD -#include +# include #endif -#if ! defined BB_FEATURE_USE_PROCFS -#error Sorry, I depend on the /proc filesystem right now. +#define bb_need_full_version +#define BB_DECLARE_EXTERN +#include "messages.c" + +/* From */ +struct vt_stat { + unsigned short v_active; /* active vt */ + unsigned short v_signal; /* signal to send */ + unsigned short v_state; /* vt bitmask */ +}; +#define 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 +#define RB_HALT_SYSTEM 0xcdef0123 +#define RB_ENABLE_CAD 0x89abcdef +#define RB_DISABLE_CAD 0 +#define RB_POWER_OFF 0x4321fedc +#define RB_AUTOBOOT 0x01234567 +#if defined(__GLIBC__) +#include + #define init_reboot(magic) reboot(magic) +#else + #define init_reboot(magic) reboot(0xfee1dead, 672274793, magic) +#endif #endif +#ifndef _PATH_STDPATH +#define _PATH_STDPATH "/usr/bin:/bin:/usr/sbin:/sbin" +#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 GETTY "/sbin/getty" /* Default location of getty */ -#define SHELL "/bin/sh" /* Default shell */ -#define INITSCRIPT "/etc/init.d/rcS" /* Initscript. */ -#define LOG 0x1 -#define CONSOLE 0x2 -static char *console = _PATH_CONSOLE; -static char *second_console = VT_SECONDARY; -static char *log = VT_LOG; -static int kernel_version = 0; +#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 +#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c)) -/* 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; -} +#if defined(__GLIBC__) +#include +#else +static _syscall2(int, bdflush, int, func, int, data); +#endif /* __GLIBC__ */ + + +#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 "/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 -/* print a message to the specified device: - * device may be bitwise-or'd from LOG | CONSOLE */ -void message(int device, char *fmt, ...) +#define LOG 0x1 +#define CONSOLE 0x2 + +/* Allowed init action types */ +typedef enum { + SYSINIT = 1, + RESPAWN, + ASKFIRST, + WAIT, + ONCE, + CTRLALTDEL +} initActionEnum; + +/* 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}, + {"ctrlaltdel", CTRLALTDEL}, + {0, 0} +}; + +/* 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; +}; +initAction *initActionList = NULL; + + +static char *secondConsole = VT_SECONDARY; +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); + + +/* 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, ...) { - int fd; - va_list arguments; + 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("init", 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); + fflush(stderr); + 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); + fflush(stderr); + va_end(arguments); + } } - } } - /* Set terminal settings to reasonable defaults */ -void set_term( int fd) +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 */ - memcpy(tty.c_cc, control_characters, sizeof(control_characters)); + /* 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 */ - /* 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 |= 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() +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; + + /* Pre initialize mem_unit in case this kernel is something prior to + * the linux 2.4 kernel (which will actually fill in mem_unit... */ + sysinfo(&info); + if (sysinfo(&info) != 0) { + printf("Error checking free memory: %s\n", strerror(errno)); + return -1; } - } - return -1; + if (info.mem_unit==0) { + /* Looks like we have a kernel prior to Linux 2.4.x */ + info.mem_unit=1024; + info.totalram/=info.mem_unit; + info.totalswap/=info.mem_unit; + } else { + /* Bah. Linux 2.4.x completely changed sysinfo. This can in theory + overflow a 32 bit unsigned long, but who puts more then 4GiB ram+swap + on an embedded system? */ + info.mem_unit/=1024; + info.totalram*=info.mem_unit; + info.totalswap*=info.mem_unit; + } + + return(info.totalram+info.totalswap); } 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) { + snprintf(console, sizeof(console) - 1, "%s", 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) + snprintf(console, sizeof(console) - 1, "%s", SERIAL_CON0); + else if (strcmp(s, "ttyb") == 0) + snprintf(console, sizeof(console) - 1, "%s", SERIAL_CON1); } - } - - 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; +#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 { + snprintf(console, sizeof(console) - 1, "%s", _PATH_CONSOLE); + tried_devcons++; + } } - /* Can't open selected console -- try vt1 */ - if (!tried_vtprimary) { - tried_vtprimary++; - console = VT_PRIMARY; - continue; + + while ((fd = open(console, O_RDONLY | O_NONBLOCK)) < 0) { + /* Can't open selected console -- try /dev/console */ + if (!tried_devcons) { + tried_devcons++; + snprintf(console, sizeof(console) - 1, "%s", _PATH_CONSOLE); + continue; + } + /* Can't open selected console -- try vt1 */ + if (!tried_vtprimary) { + tried_vtprimary++; + snprintf(console, sizeof(console) - 1, "%s", VT_PRIMARY); + continue; + } + break; } - 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; + if (fd < 0) { + /* Perhaps we should panic here? */ + snprintf(console, sizeof(console) - 1, "/dev/null"); + } else { + /* check for serial console and disable logging to tty3 & running a + * shell to tty2 */ + if (ioctl(0, TIOCGSERIAL, &sr) == 0) { + log = NULL; + secondConsole = NULL; + /* Force the TERM setting to vt102 for serial console -- + * iff TERM is set to linux (the default) */ + if (strcmp( termType, "TERM=linux" ) == 0) + snprintf(termType, sizeof(termType) - 1, "TERM=vt102"); + 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 pid_t run(char *command, char *terminal, int get_enter) { - int status, wpid; - - message(LOG, "Waiting for process %d.\n", pid); - while ((wpid = wait(&status)) != pid) { - if (wpid > 0) - message(LOG, "pid %d exited, status=0x%x.\n", wpid, status); - } - return wpid; -} + int i, fd; + pid_t pid; + char *tmpCmd; + char *cmd[255]; + char buf[255]; + static const char press_enter[] = + + "\nPlease press Enter to activate this console. "; + char *environment[] = { + "HOME=/", + "PATH=/usr/bin:/bin:/usr/sbin:/sbin", + "SHELL=/bin/sh", + termType, + "USER=root", + 0 + }; -static pid_t run(const char * const* command, - char *terminal, int get_enter) -{ - int fd; - pid_t pid; - const char * const* cmd = command+1; - static const char press_enter[] = - "\nPlease press Enter to activate this console. "; - - if ((pid = fork()) == 0) { - /* Clean up */ - close(0); - close(1); - close(2); - setsid(); + if ((pid = fork()) == 0) { + /* Clean up */ + 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) { + 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, 0); + tcsetpgrp(0, getpgrp()); + set_term(0); + + 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; +#ifdef DEBUG_INIT + pid_t shell_pgid = getpid(); + message(LOG, "Waiting for enter to start '%s' (pid %d, console %s)\r\n", + command, shell_pgid, terminal); +#endif + write(fileno(stdout), press_enter, sizeof(press_enter) - 1); + read(fileno(stdin), &c, 1); + } - /* Reset signal handlers set for parent process */ - signal(SIGUSR1, SIG_DFL); - signal(SIGUSR2, SIG_DFL); - signal(SIGINT, SIG_DFL); - signal(SIGTERM, SIG_DFL); +#ifdef DEBUG_INIT + /* Log the process name and args */ + message(LOG, "Starting pid %d, console %s: '%s'\r\n", + shell_pgid, terminal, command); +#endif - if ((fd = device_open(terminal, O_RDWR)) < 0) { - message(LOG, "Bummer, can't open %s\r\n", terminal); - exit(-1); - } - dup(fd); - dup(fd); - 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; + } + +#if defined BB_FEATURE_INIT_COREDUMPS + { + 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, + * so nothing further in init.c should be run. */ + execve(cmd[0], cmd, environment); - 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", - *cmd, getpid(), terminal ); - write(1, press_enter, sizeof(press_enter) - 1); - read(0, &c, 1); + /* 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; +} - /* Log the process name and args */ - message(LOG|CONSOLE, "Starting pid %d, console %s: '", getpid(), terminal); - while ( *cmd) message(LOG|CONSOLE, "%s ", *cmd++); - message(LOG|CONSOLE, "'\r\n"); - - /* Now run it. The new program will take over this PID, - * so nothing further in init.c should be run. */ - execvp(*command, (char**)command+1); - - message(LOG, "Bummer, could not run '%s'\n", command); - exit(-1); - } - return pid; +static int waitfor(char *command, char *terminal, int get_enter) +{ + int status, wpid; + int pid = run(command, terminal, get_enter); + + while (1) { + wpid = wait(&status); + if (wpid > 0 && wpid != pid) { + continue; + } + if (wpid == pid) + break; + } + 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; - const char* const swap_on_cmd[] = - { "/bin/swapon", "swapon", "-a", 0}; - - 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(swap_on_cmd, 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); } -static void shutdown_system(void) +/* Run all commands to be run right before halt/reboot */ +static void run_lastAction(void) { - const char* const swap_off_cmd[] = { "swapoff", "swapoff", "-a", 0}; - const char* const umount_cmd[] = { "umount", "umount", "-a", 0}; + initAction *a; + for (a = initActionList; a; a = a->nextPtr) { + if (a->action == CTRLALTDEL) { + waitfor(a->process, a->console, FALSE); + delete_initAction(a); + } + } +} + #ifndef DEBUG_INIT - /* Allow Ctrl-Alt-Del to reboot system. */ - reboot(RB_ENABLE_CAD); -#endif - 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"); -#ifndef DEBUG_INIT - kill(-1, SIGHUP); -#endif - sleep(2); - sync(); - message(CONSOLE, "Sending SIGKILL to all processes.\r\n"); -#ifndef DEBUG_INIT - kill(-1, SIGKILL); -#endif - sleep(1); - message(CONSOLE, "Disabling swap.\r\n"); - waitfor(run( swap_off_cmd, console, FALSE)); - message(CONSOLE, "Unmounting filesystems.\r\n"); - waitfor(run( umount_cmd, 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); +static void shutdown_system(void) +{ + + /* 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 "ctrlaltdel" */ + run_lastAction(); + 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(); -#ifndef DEBUG_INIT - if (sig == SIGUSR2) - reboot(RB_POWER_OFF); - else - reboot(RB_HALT_SYSTEM); -#endif - 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(); -#ifndef DEBUG_INIT - reboot(RB_AUTOBOOT); + shutdown_system(); + message(CONSOLE|LOG, "Please stand by while rebooting the system.\r\n"); + sync(); + + /* allow time for last message to reach serial console */ + sleep(2); + + init_reboot(RB_AUTOBOOT); + exit(0); +} + +#if defined BB_FEATURE_INIT_CHROOT + +#if ! defined BB_FEATURE_USE_PROCFS +#error Sorry, I depend on the /proc filesystem right now. #endif - exit(0); + +static void check_chroot(int sig) +{ + char *argv_init[2] = { "init", NULL, }; + char *envp_init[3] = { "HOME=/", "TERM=linux", NULL, }; + char rootpath[256], *tc; + int fd; + + if ((fd = open("/proc/sys/kernel/init-chroot", O_RDONLY)) == -1) { + message(CONSOLE, + "SIGHUP recived, but could not open proc file\r\n"); + sleep(2); + return; + } + if (read(fd, rootpath, sizeof(rootpath)) == -1) { + message(CONSOLE, + "SIGHUP recived, but could not read proc file\r\n"); + sleep(2); + return; + } + close(fd); + + if (rootpath[0] == '\0') { + message(CONSOLE, + "SIGHUP recived, but new root is not valid: %s\r\n", + rootpath); + sleep(2); + return; + } + + tc = strrchr(rootpath, '\n'); + *tc = '\0'; + + /* Ok, making it this far means we commit */ + message(CONSOLE, "Please stand by, changing root to `%s'.\r\n", + rootpath); + + /* kill all other programs first */ + message(CONSOLE, "Sending SIGTERM to all processes.\r\n"); + kill(-1, SIGTERM); + sleep(2); + sync(); + + message(CONSOLE, "Sending SIGKILL to all processes.\r\n"); + kill(-1, SIGKILL); + sleep(2); + sync(); + + /* ok, we don't need /proc anymore. we also assume that the signaling + * process left the rest of the filesystems alone for us */ + umount("/proc"); + + /* Ok, now we chroot. Hopefully we only have two things mounted, the + * new chroot'd mount point, and the old "/" mount. s, + * we go ahead and unmount the old "/". This should trigger the kernel + * to set things up the Right Way(tm). */ + + if (!chroot(rootpath)) + umount("/dev/root"); + + /* If the chroot fails, we are already too far to turn back, so we + * continue and hope that executing init below will revive the system */ + + /* close all of our descriptors and open new ones */ + close(0); + close(1); + close(2); + open("/dev/console", O_RDWR, 0); + dup(0); + dup(0); + + message(CONSOLE, "Executing real init...\r\n"); + /* execute init in the (hopefully) new root */ + execve("/sbin/init", argv_init, envp_init); + + message(CONSOLE, + "ERROR: Could not exec new init. Press %s to reboot.\r\n", + (secondConsole == NULL) /* serial console */ + ? "Reset" : "CTRL-ALT-DEL"); + return; } +#endif /* BB_FEATURE_INIT_CHROOT */ -extern int init_main(int argc, char **argv) +#endif /* ! DEBUG_INIT */ + +void new_initAction(initActionEnum action, char *process, char *cons) { - int run_rc = FALSE; - int single = FALSE; - int wait_for_enter_tty1 = TRUE; - int wait_for_enter_tty2 = TRUE; - pid_t pid1 = 0; - pid_t pid2 = 0; - struct stat statbuf; - const char* const rc_script_command[] = { INITSCRIPT, INITSCRIPT, 0}; - const char* const getty1_command[] = { GETTY, GETTY, VT_PRIMARY, 0}; - const char* const getty2_command[] = { GETTY, GETTY, VT_SECONDARY, 0}; - const char* const shell_command[] = { SHELL, "-" SHELL, 0}; - const char* const* tty1_command = shell_command; - const char* const* tty2_command = shell_command; -#ifdef BB_INIT_CMD_IF_RC_SCRIPT_EXITS - const char* const rc_exit_command[] = { "BB_INIT_CMD_IF_RC_SCRIPT_EXITS", - "BB_INIT_CMD_IF_RC_SCRIPT_EXITS", 0 }; -#endif + 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); + newAction->pid = 0; +// message(LOG|CONSOLE, "process='%s' action='%d' console='%s'\n", +// newAction->process, newAction->action, newAction->console); +} -#ifdef DEBUG_INIT - char *hello_msg_format = - "init(%d) started: BusyBox v%s (%s) multi-call binary\r\n"; -#else - char *hello_msg_format = - "init started: BusyBox v%s (%s) multi-call binary\r\n"; +static void delete_initAction(initAction * action) +{ + 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, this + * results in the same set of default behaviors. + * */ +void parse_inittab(void) +{ +#ifdef BB_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; + + + file = fopen(INITTAB, "r"); + if (file == NULL) { + /* No inittab file -- set up some default behavior */ #endif + /* Swapoff on halt/reboot */ + new_initAction(CTRLALTDEL, "/sbin/swapoff -a > /dev/null 2>&1", console); + /* Umount all filesystems on halt/reboot */ + new_initAction(CTRLALTDEL, "/bin/umount -a -r > /dev/null 2>&1", console); + /* Askfirst shell on tty1 */ + new_initAction(ASKFIRST, SHELL, console); + /* Askfirst shell on tty2 */ + if (secondConsole != NULL) + new_initAction(ASKFIRST, SHELL, secondConsole); + /* sysinit */ + new_initAction(SYSINIT, INIT_SCRIPT, console); + + return; +#ifdef BB_FEATURE_USE_INITTAB + } + + 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; + } + + /* 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; + } + + /* 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') { + struct stat statBuf; + + strcpy(tmpConsole, "/dev/"); + strncat(tmpConsole, id, 200); + if (stat(tmpConsole, &statBuf) != 0) { + message(LOG | CONSOLE, + "device '%s' does not exist. Did you read the directions?\n", + tmpConsole); + break; + } + 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 /* BB_FEATURE_USE_INITTAB */ +} + + + +extern int init_main(int argc, char **argv) +{ + initAction *a; + 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"); - } + /* 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 + ) + { + 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"); + } + /* Set up sig handlers -- be sure to + * clear all of these in run() */ + signal(SIGUSR1, halt_signal); + signal(SIGUSR2, halt_signal); + signal(SIGINT, reboot_signal); + signal(SIGTERM, reboot_signal); +#if defined BB_FEATURE_INIT_CHROOT + signal(SIGHUP, check_chroot); #endif - /* 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... */ + init_reboot(RB_DISABLE_CAD); +#endif - /* Turn off rebooting via CTL-ALT-DEL -- we get a - * SIGINT on CAD so we can shut things down gracefully... */ -#ifndef DEBUG_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(); + /* 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); - setsid(); + /* 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_STDPATH); + /* Make sure PATH is set to something sane */ + putenv(_PATH_STDPATH); - - /* Hello world */ + /* Hello world */ #ifndef DEBUG_INIT - message(CONSOLE|LOG, hello_msg_format, 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, hello_msg_format, 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"); - -fprintf(stderr, "got proc\n"); - - /* Make sure there is enough memory to do something useful. */ - check_memory(); -fprintf(stderr, "got check_memory\n"); - - /* 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"))) { - single = TRUE; - tty1_command = shell_command; - tty2_command = shell_command; - } -fprintf(stderr, "got single\n"); - - /* Make sure an init script exists before trying to run it */ - if (single==FALSE && stat(INITSCRIPT, &statbuf)==0) { - run_rc = TRUE; - wait_for_enter_tty1 = FALSE; - tty1_command = rc_script_command; - } - - /* Make sure /sbin/getty exists before trying to run it */ - if (stat(GETTY, &statbuf)==0) { - char* where; -fprintf(stderr, "\n"); - wait_for_enter_tty2 = FALSE; - where = strrchr( console, '/'); - if ( where != NULL) { - strcpy( (char*)getty2_command[2], where); - } - tty2_command = getty2_command; - /* Check on hooking a getty onto tty1 */ - if (run_rc == FALSE && single==FALSE) { - wait_for_enter_tty1 = FALSE; - where = strrchr( second_console, '/'); - if ( where != NULL) { - strcpy( (char*)getty1_command[2], where); - } - tty1_command = getty1_command; + + /* 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 (secondConsole != NULL) + new_initAction(ASKFIRST, SHELL, secondConsole); + /* 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(); } - } - - /* Ok, now launch the tty1_command and tty2_command */ - for (;;) { - pid_t wpid; - int status; + /* Fix up argv[0] to be certain we claim to be init */ + strncpy(argv[0], "init", strlen(argv[0])+1); + if (argc > 1) + strncpy(argv[1], "\0", strlen(argv[1])+1); - if (pid1 == 0 && tty1_command) { - pid1 = run(tty1_command, console, wait_for_enter_tty1); + /* 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(a->process, a->console, FALSE); + /* Now remove the "sysinit" entry from the list */ + delete_initAction(a); + } } -#ifdef BB_FEATURE_INIT_SECOND_CONSOLE - if (pid2 == 0 && tty2_command && second_console) { - pid2 = run(tty2_command, second_console, wait_for_enter_tty2); + /* Next run anything that wants to block */ + for (a = initActionList; a; a = a->nextPtr) { + if (a->action == WAIT) { + waitfor(a->process, a->console, FALSE); + /* Now remove the "wait" entry from the list */ + delete_initAction(a); + } } -#endif - wpid = wait(&status); - if (wpid > 0 ) { - message(LOG, "pid %d exited, status=%x.\n", wpid, status); + /* Next run anything to be run only once */ + for (a = initActionList; a; a = a->nextPtr) { + if (a->action == ONCE) { + run(a->process, a->console, FALSE); + /* Now remove the "once" entry from the list */ + delete_initAction(a); + } } - /* Don't respawn init script if it exits */ - if (wpid == pid1) { - if (run_rc == FALSE) { - pid1 = 0; - } -#ifdef BB_INIT_CMD_IF_RC_SCRIPT_EXITS - else { - pid1 = 0; - run_rc=FALSE; - wait_for_enter_tty1=TRUE; - tty1_command=rc_exit_command; - } -#endif + /* 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); } -#ifdef BB_FEATURE_INIT_SECOND_CONSOLE - if (wpid == pid2) { - pid2 = 0; + + /* 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); } -#endif - sleep(1); - } } + +/* +Local Variables: +c-file-style: "linux" +c-basic-offset: 4 +tab-width: 4 +End: +*/