Update init.c per my changes in the stable branch

 -Erik

1 files changed, 269 insertions, 222 deletions

diff --git a/init/init.c b/init/init.c
index e48dc50cc..408dd1f95 100644
--- a/init/init.c
+++ b/init/init.c
@@ -47,6 +47,9 @@
 # include <sys/syslog.h>
 #endif
 
+#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_MMU__)
+#define fork    vfork
+#endif
 
 /* From <linux/vt.h> */
 struct vt_stat {
@@ -82,19 +85,10 @@ struct serial_struct {
   #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 
@@ -115,7 +109,6 @@ static const int RB_AUTOBOOT = 0x01234567;
         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 */
@@ -124,35 +117,24 @@ static const int RB_AUTOBOOT = 0x01234567;
 #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
-
 
 /* Allowed init action types */
-typedef enum {
-        SYSINIT = 1,
-        RESPAWN,
-        ASKFIRST,
-        WAIT,
-        ONCE,
-        CTRLALTDEL,
-        SHUTDOWN,
-        RESTART
-} 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},
@@ -164,18 +146,17 @@ static const struct initActionType actions[] = {
         {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[256];
+        char terminal[256];
+        struct init_action *next;
+        int action;
 };
-static initAction *initActionList = NULL;
-
 
+/* Static variables */
+static struct init_action *init_action_list = NULL;
 static char *secondConsole = VC_2;
 static char *thirdConsole  = VC_3;
 static char *fourthConsole = VC_4;
@@ -183,9 +164,26 @@ static char *log           = VC_5;
 static int  kernelVersion  = 0;
 static char termType[32]   = "TERM=linux";
 static char console[32]    = _PATH_CONSOLE;
-sig_atomic_t got_cont = 0;
+static sig_atomic_t got_cont = 0;
+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
+#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
+
+/* Function prototypes */
+static void delete_init_action(struct init_action *a);
+static int waitfor(struct init_action *a);
 
-static void delete_initAction(initAction * action);
 
 static void loop_forever(void)
 {
@@ -200,8 +198,7 @@ static inline messageND(int device, char *fmt, ...) { }
 #else 
 #define messageND message
 #endif
-static void message(int device, char *fmt, ...)
-                   __attribute__ ((format (printf, 2, 3)));
+static void message(int device, char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
 static void message(int device, char *fmt, ...)
 {
         va_list arguments;
@@ -216,7 +213,7 @@ static void message(int device, char *fmt, ...)
                 va_start(arguments, fmt);
                 vsnprintf(msg, sizeof(msg), fmt, arguments);
                 va_end(arguments);
-                syslog_msg(LOG_USER, LOG_USER|LOG_INFO, msg);
+                syslog_msg(LOG_USER, LOG_INFO, msg);
         }
 #else
         static int log_fd = -1;
@@ -247,8 +244,7 @@ static void message(int device, char *fmt, ...)
                 /* 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) {
+                         device_open(_PATH_CONSOLE, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0) {
                         va_start(arguments, fmt);
                         vdprintf(fd, fmt, arguments);
                         va_end(arguments);
@@ -383,8 +379,8 @@ static void console_init(void)
                 /* 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 */
+                /* 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;
@@ -418,23 +414,41 @@ static void fixup_argv(int argc, char **argv, char *new_argv0)
         }
 }
 
-
-static pid_t run(char *command, char *terminal, int get_enter)
+/* 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)
 {
-        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[] =
+        struct stat statBuf;
 
-#ifdef CUSTOMIZED_BANNER
-#include CUSTOMIZED_BANNER
+        if (check_free_memory() > 1000)
+                return;
+
+#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
+        if (stat("/etc/fstab", &statBuf) == 0) {
+                /* swapon -a requires /proc typically */
+                system("/bin/mount -t proc proc /proc");
+                /* Try to turn on swap */
+                system("/sbin/swapon -a");
+                if (check_free_memory() < 1000)
+                        goto goodnight;
+        } else
+                goto goodnight;
+        return;
 #endif
 
-                "\nPlease press Enter to activate this console. ";
+  goodnight:
+        message(CONSOLE,
+                        "Sorry, your computer does not have enough memory.\n");
+        loop_forever();
+}
+
+static pid_t run(struct init_action *a)
+{
+        struct stat sb;
+        int i, j, fd, junk; 
+        pid_t pid, pgrp, tmp_pid;
+        char *s, *tmpCmd, *cmd[255], *cmdpath, buf[255];
+        sigset_t nmask, omask;
         char *environment[MAXENV+1] = {
                 termType,
                 "HOME=/",
@@ -443,6 +457,11 @@ static pid_t run(char *command, char *terminal, int get_enter)
                 "USER=root",
                 NULL
         };
+        static const char press_enter[] =
+#ifdef CUSTOMIZED_BANNER
+#include CUSTOMIZED_BANNER
+#endif
+                "\nPlease press Enter to activate this console. ";
 
         /* inherit environment to the child, merging our values -andy */
         for (i=0; environ[i]; i++) {
@@ -457,57 +476,117 @@ static pid_t run(char *command, char *terminal, int get_enter)
                 }
         }
 
-#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
+        /* Block sigchild while forking.  */
+        sigemptyset(&nmask);
+        sigaddset(&nmask, SIGCHLD);
+        sigprocmask(SIG_BLOCK, &nmask, &omask);
+
         if ((pid = fork()) == 0) 
-#else
-        if ((pid = vfork()) == 0) 
-#endif
         {
                 /* Clean up */
                 ioctl(0, TIOCNOTTY, 0);
                 close(0);
                 close(1);
                 close(2);
+                sigprocmask(SIG_SETMASK, &omask, NULL);
+
+                /* Create a new session and make ourself the process group leader */
                 setsid();
 
-                /* 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(SIGINT,  SIG_DFL);
                 signal(SIGTERM, SIG_DFL);
-                signal(SIGHUP, SIG_DFL);
+                signal(SIGHUP,  SIG_DFL);
                 signal(SIGCONT, SIG_DFL);
                 signal(SIGSTOP, SIG_DFL);
                 signal(SIGTSTP, SIG_DFL);
 
-                if ((fd = device_open(terminal, O_RDWR)) < 0) {
-                        if (stat(terminal, &sb) != 0) {
+                /* Open the new terminal device */
+                if ((fd = device_open(a->terminal, O_RDWR|O_NOCTTY)) < 0) {
+                        if (stat(a->terminal, &sb) != 0) {
                                 message(LOG | CONSOLE, "device '%s' does not exist.\n",
-                                                terminal);
-                                exit(1);
+                                                a->terminal);
+                                _exit(1);
                         }
-                        message(LOG | CONSOLE, "Bummer, can't open %s\n", terminal);
-                        exit(1);
+                        message(LOG | CONSOLE, "Bummer, can't open %s\n", a->terminal);
+                        _exit(1);
                 }
-                dup2(fd, 0);
-                dup2(fd, 1);
-                dup2(fd, 2);
-                ioctl(0, TIOCSCTTY, 1);
-                tcsetpgrp(0, getpgrp());
+                /* Make sure the terminal will act fairly normal for us */
                 set_term(0);
 
+                /* If the init Action requires up to wait, then force the
+                 * supplied terminal to be the controlling tty. */
+                if (a->action & (SYSINIT|WAIT|CTRLALTDEL|SHUTDOWN|RESTART)) {
+
+                        /* Take over the controlling tty */
+                        ioctl(fd, TIOCSCTTY, 1);
+                        /* Setup stdin, stdout, stderr for the new process so 
+                         * they point to the supplied terminal */
+                        dup(fd);
+                        dup(fd);
+
+                        /* Now fork off another process to just hang around */
+                        if ((pid = fork()) < 0) {
+                                message(LOG | CONSOLE, "Can't fork!\n");
+                                _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);
+
+                                /* Wait for child to exit */
+                                while ((tmp_pid = waitpid(pid, &junk, 0)) != pid) {
+                                        if (tmp_pid < 0 && errno == ECHILD)
+                                                break;
+                                }
+
+                                /* See if stealing the controlling tty back is necessary */
+                                pgrp = tcgetpgrp(tmp_pid);
+                                if (pgrp != getpid())
+                                        _exit(0);
+
+                                /* Use a temporary process to steal the controlling tty. */
+                                if ((pid = fork()) < 0) {
+                                        message(LOG | CONSOLE, "Can't fork!\n");
+                                        _exit(1);
+                                }       
+                                if (pid == 0) {
+                                        setsid();
+                                        ioctl(tmp_pid, TIOCSCTTY, 1);
+                                        _exit(0);
+                                }       
+                                while((tmp_pid = waitpid(pid, &junk, 0)) != pid) {
+                                        if (tmp_pid < 0 && errno == ECHILD)
+                                                break;
+                                }
+                                _exit(0);
+                        }
+
+                        /* Now fall though to actually execute things */
+                } else {
+                        dup(fd);
+                        dup(fd);
+                }
+
                 /* See if any special /bin/sh requiring characters are present */
-                if (strpbrk(command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) {
+                if (strpbrk(a->command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) {
                         cmd[0] = SHELL;
                         cmd[1] = "-c";
                         strcpy(buf, "exec ");
-                        safe_strncpy(buf + sizeof("exec "), command, 
+                        safe_strncpy(buf + sizeof("exec "), a->command, 
                                         sizeof(buf) - sizeof("exec "));
                         cmd[2] = buf;
                         cmd[3] = NULL;
                 } else {
                         /* Convert command (char*) into cmd (char**, one word per string) */
-                        safe_strncpy(buf, command, sizeof(buf));
+                        safe_strncpy(buf, a->command, sizeof(buf));
                         s = buf;
                         for (tmpCmd = buf, i = 0;
                                         (tmpCmd = strsep(&s, " \t")) != NULL;) {
@@ -547,7 +626,7 @@ static pid_t run(char *command, char *terminal, int get_enter)
                         }
                 }
 
-                if (get_enter) {
+                if (a->action & ASKFIRST) {
                         /*
                          * Save memory by not exec-ing anything large (like a shell)
                          * before the user wants it. This is critical if swap is not
@@ -556,15 +635,15 @@ static pid_t run(char *command, char *terminal, int get_enter)
                          * 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);
+                        messageND(LOG, "Waiting for enter to start '%s' (pid %d, terminal %s)\n",
+                                        cmdpath, getpid(), a->terminal);
                         write(fileno(stdout), press_enter, sizeof(press_enter) - 1);
                         getc(stdin);
                 }
 
                 /* Log the process name and args */
                 messageND(LOG, "Starting pid %d, console %s: '%s'\n",
-                                getpid(), terminal, command);
+                                getpid(), a->terminal, cmdpath);
 
 #if defined CONFIG_FEATURE_INIT_COREDUMPS
                 if (stat (CORE_ENABLE_FLAG_FILE, &sb) == 0) {
@@ -582,16 +661,18 @@ static pid_t run(char *command, char *terminal, int get_enter)
                 /* We're still here?  Some error happened. */
                 message(LOG | CONSOLE, "Bummer, could not run '%s': %s\n", cmdpath,
                                 strerror(errno));
-                exit(-1);
+                _exit(-1);
         }
+        sigprocmask(SIG_SETMASK, &omask, NULL);
         return pid;
 }
 
-static int waitfor(char *command, char *terminal, int get_enter)
+static int waitfor(struct init_action *a)
 {
+        int pid; 
         int status, wpid;
-        int pid = run(command, terminal, get_enter);
 
+        pid = run(a);
         while (1) {
                 wpid = wait(&status);
                 if (wpid > 0 && wpid != pid) {
@@ -603,43 +684,27 @@ static int waitfor(char *command, char *terminal, int get_enter)
         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;
+        struct init_action *a, *tmp;
 
-        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("/bin/mount -t proc proc /proc", console, FALSE);
-                /* Try to turn on swap */
-                waitfor("/sbin/swapon -a", console, FALSE);
-                if (check_free_memory() < 1000)
-                        goto goodnight;
-        } else
-                goto goodnight;
-        return;
-#endif
-
-  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 (a->action & (SYSINIT|WAIT|CTRLALTDEL|SHUTDOWN|RESTART)) {
+                                waitfor(a);
+                                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);
+                                }
+                        }
                 }
         }
 }
@@ -692,16 +757,16 @@ static void shutdown_system(void)
 
 static void exec_signal(int sig)
 {
-        initAction *a, *tmp;
-        for (a = initActionList; a; a = tmp) {
-                tmp = a->nextPtr;
-                if (a->action == RESTART) {
+        struct init_action *a, *tmp;
+        for (a = init_action_list; a; a = tmp) {
+                tmp = a->next;
+                if (a->action & RESTART) {
                         shutdown_system();
-                        message(CONSOLE|LOG, "Trying to re-exec %s\n", a->process);
-                        execl(a->process, a->process, NULL);
+                        message(CONSOLE|LOG, "Trying to re-exec %s\n", a->command);
+                        execl(a->command, a->command, NULL);
         
                         message(CONSOLE|LOG, "execl of %s failed: %s\n", 
-                                a->process, sys_errlist[errno]);
+                                a->command, sys_errlist[errno]);
                         sync();
                         sleep(2);
                         init_reboot(RB_HALT_SYSTEM);
@@ -755,12 +820,10 @@ static void ctrlaltdel_signal(int sig)
         run_actions(CTRLALTDEL);
 }
 
-/*
- *      The SIGSTOP & SIGTSTP handler
- */
+/* The SIGSTOP & SIGTSTP handler */
 static void stop_handler(int sig)
 {
-        int     saved_errno = errno;
+        int saved_errno = errno;
 
         got_cont = 0;
         while(!got_cont) pause();
@@ -768,9 +831,7 @@ static void stop_handler(int sig)
         errno = saved_errno;
 }
 
-/*
- *  The SIGCONT handler
- */ 
+/* The SIGCONT handler */ 
 static void cont_handler(int sig)
 {
         got_cont = 1;
@@ -778,53 +839,54 @@ static void cont_handler(int sig)
 
 #endif                                                  /* ! DEBUG_INIT */
 
-static void new_initAction(initActionEnum action, char *process, char *cons)
+static void new_init_action(int action, char *command, char *cons)
 {
-        initAction *newAction;
-        initAction *a;
+        struct init_action *new_action, *a;
 
         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.
+        /* 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, "/dev/null") == 0 && (action & ASKFIRST))
                 return;
 
-        newAction = calloc((size_t) (1), sizeof(initAction));
-        if (!newAction) {
+        new_action = calloc((size_t) (1), sizeof(struct init_action));
+        if (!new_action) {
                 message(LOG | CONSOLE, "Memory allocation failure\n");
                 loop_forever();
         }
-        for (a = initActionList; a && a->nextPtr; a = a->nextPtr) ;
+
+        /* Append to the end of the list */
+        for (a = init_action_list; a && a->next; a = a->next) ;
         if (a) {
-                a->nextPtr = newAction;
+                a->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);
+        safe_strncpy(new_action->command, command, 255);
+        new_action->action = action;
+        safe_strncpy(new_action->terminal, cons, 255);
+        new_action->pid = 0;
+//    message(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;
@@ -844,8 +906,8 @@ 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;
+        char *id, *runlev, *action, *command, *eol;
+        const struct init_action_type *a = actions;
         int foundIt;
 
 
@@ -854,28 +916,28 @@ 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", console);
                 /* Umount all filesystems on halt/reboot */
-                new_initAction(SHUTDOWN, "/bin/umount -a -r", console);
+                new_init_action(SHUTDOWN, "/bin/umount -a -r", console);
 #if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
                 /* Swapoff on halt/reboot */
-                new_initAction(SHUTDOWN, "/sbin/swapoff -a", console);
+                new_init_action(SHUTDOWN, "/sbin/swapoff -a", console);
 #endif
                 /* Prepare to restart init when a HUP is received */
-                new_initAction(RESTART, "/sbin/init", console);
+                new_init_action(RESTART, "/sbin/init", console);
                 /* Askfirst shell on tty1 */
-                new_initAction(ASKFIRST, LOGIN_SHELL, console);
+                new_init_action(ASKFIRST, LOGIN_SHELL, console);
                 /* Askfirst shell on tty2 */
                 if (secondConsole != NULL)
-                        new_initAction(ASKFIRST, LOGIN_SHELL, secondConsole);
+                        new_init_action(ASKFIRST, LOGIN_SHELL, secondConsole);
                 /* Askfirst shell on tty3 */
                 if (thirdConsole != NULL)
-                        new_initAction(ASKFIRST, LOGIN_SHELL, thirdConsole);
+                        new_init_action(ASKFIRST, LOGIN_SHELL, thirdConsole);
                 /* Askfirst shell on tty4 */
                 if (fourthConsole != NULL)
-                        new_initAction(ASKFIRST, LOGIN_SHELL, fourthConsole);
+                        new_init_action(ASKFIRST, LOGIN_SHELL, fourthConsole);
                 /* sysinit */
-                new_initAction(SYSINIT, INIT_SCRIPT, console);
+                new_init_action(SYSINIT, INIT_SCRIPT, console);
 
                 return;
 #ifdef CONFIG_FEATURE_USE_INITTAB
@@ -918,14 +980,14 @@ static void parse_inittab(void)
                         ++action;
                 }
 
-                /* Separate the action from the process */
-                process = strchr(action, ':');
-                if (process == NULL || *(process + 1) == '\0') {
+                /* Separate the action from the command */
+                command = strchr(action, ':');
+                if (command == NULL || *(command + 1) == '\0') {
                         message(LOG | CONSOLE, "Bad inittab entry: %s\n", lineAsRead);
                         continue;
                 } else {
-                        *process = '\0';
-                        ++process;
+                        *command = '\0';
+                        ++command;
                 }
 
                 /* Ok, now process it */
@@ -937,12 +999,12 @@ static void parse_inittab(void)
                                         strncat(tmpConsole, id, 200);
                                         id = tmpConsole;
                                 }
-                                new_initAction(a->action, process, id);
+                                new_init_action(a->action, command, id);
                                 foundIt = TRUE;
                         }
                         a++;
                 }
-                if (foundIt)
+                if (foundIt == TRUE)
                         continue;
                 else {
                         /* Choke on an unknown action */
@@ -957,11 +1019,10 @@ static void parse_inittab(void)
 
 extern int init_main(int argc, char **argv)
 {
-        initAction *a, *tmp;
+        struct init_action *a;
         pid_t wpid;
         int status;
 
-
         if (argc > 1 && !strcmp(argv[1], "-q")) {
                 /* don't assume init's pid == 1 */
                 long *pid = find_pid_by_name("init");
@@ -986,10 +1047,10 @@ extern int init_main(int argc, char **argv)
         }
         /* Set up sig handlers  -- be sure to
          * clear all of these in run() */
-        signal(SIGHUP, exec_signal);
+        signal(SIGHUP,  exec_signal);
         signal(SIGUSR1, halt_signal);
         signal(SIGUSR2, halt_signal);
-        signal(SIGINT, ctrlaltdel_signal);
+        signal(SIGINT,  ctrlaltdel_signal);
         signal(SIGTERM, reboot_signal);
         signal(SIGCONT, cont_handler);
         signal(SIGSTOP, stop_handler);
@@ -1029,13 +1090,13 @@ extern int init_main(int argc, char **argv)
                                          !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);
+                        new_init_action(ASKFIRST, LOGIN_SHELL, secondConsole);
                 if (thirdConsole != NULL)
-                        new_initAction(ASKFIRST, LOGIN_SHELL, thirdConsole);
+                        new_init_action(ASKFIRST, LOGIN_SHELL, thirdConsole);
                 if (fourthConsole != NULL)
-                        new_initAction(ASKFIRST, LOGIN_SHELL, fourthConsole);
+                        new_init_action(ASKFIRST, LOGIN_SHELL, fourthConsole);
                 /* Start a shell on tty1 */
-                new_initAction(RESPAWN, LOGIN_SHELL, console);
+                new_init_action(RESPAWN, LOGIN_SHELL, console);
         } else {
                 /* Not in single user mode -- see what inittab says */
 
@@ -1053,58 +1114,44 @@ 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);
-                }
-        }
+        run_actions(ONCE);
+
         /* If there is nothing else to do, stop */
-        if (initActionList == NULL) {
-                message(LOG | CONSOLE,
-                                "No more tasks for init -- sleeping forever.\n");
+        if (init_action_list == NULL) {
+                message(LOG | CONSOLE, "No more tasks for init -- sleeping forever.\n");
                 loop_forever();
         }
 
         /* 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) {
                         /* 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.\n", a->command, wpid);
                                 }
                         }
                 }
-                sleep(1);
         }
 }