← Commit list

0298be88a

Eric Andersen

2002-03-05

FAILED Duration: 345s

Subject

Update init.c per my changes in the stable branch -Erik

Binary

No binary (build failed)

Architecture & Compiler Flags

Architecture: x86_64-linux-gnu Compiler: gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0

—

Build Log

(log yok)

Commit Diff GitHub →

init/init.c +269 -222

init/init.c+269 -222

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