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);
 	}
 }