2000-01-27 08:10:21 +05:30
|
|
|
/* vi: set sw=4 ts=4: */
|
1999-10-21 03:38:37 +05:30
|
|
|
/*
|
|
|
|
* Mini init implementation for busybox
|
|
|
|
*
|
|
|
|
* Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
|
2004-03-15 13:59:22 +05:30
|
|
|
* Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
|
1999-10-21 03:38:37 +05:30
|
|
|
* Adjusted by so many folks, it's impossible to keep track.
|
|
|
|
*
|
2006-01-22 08:11:51 +05:30
|
|
|
* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
|
1999-10-21 03:38:37 +05:30
|
|
|
*/
|
|
|
|
|
2007-05-27 00:30:18 +05:30
|
|
|
#include "libbb.h"
|
1999-12-03 14:49:54 +05:30
|
|
|
#include <paths.h>
|
2007-06-01 04:12:12 +05:30
|
|
|
//#include <signal.h>
|
|
|
|
//#include <sys/ioctl.h>
|
|
|
|
//#include <sys/wait.h>
|
2003-07-22 14:26:55 +05:30
|
|
|
#include <sys/reboot.h>
|
2003-06-27 22:38:15 +05:30
|
|
|
|
2007-03-06 01:25:30 +05:30
|
|
|
#if ENABLE_FEATURE_INIT_SYSLOG
|
2000-04-28 05:48:56 +05:30
|
|
|
# include <sys/syslog.h>
|
|
|
|
#endif
|
2003-04-24 17:11:28 +05:30
|
|
|
|
2002-07-04 05:20:16 +05:30
|
|
|
#define INIT_BUFFS_SIZE 256
|
2007-02-21 05:45:20 +05:30
|
|
|
#define CONSOLE_NAME_SIZE 32
|
|
|
|
#define MAXENV 16 /* Number of env. vars */
|
2000-07-09 00:25:24 +05:30
|
|
|
|
2007-01-03 08:26:00 +05:30
|
|
|
#if ENABLE_FEATURE_INIT_COREDUMPS
|
2000-04-04 23:44:25 +05:30
|
|
|
/*
|
2004-03-15 13:59:22 +05:30
|
|
|
* When a file named CORE_ENABLE_FLAG_FILE exists, setrlimit is called
|
2000-04-05 00:06:37 +05:30
|
|
|
* 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....
|
2000-04-04 23:44:25 +05:30
|
|
|
*/
|
|
|
|
#define CORE_ENABLE_FLAG_FILE "/.init_enable_core"
|
|
|
|
#include <sys/resource.h>
|
2000-04-05 00:06:37 +05:30
|
|
|
#endif
|
2000-04-04 23:44:25 +05:30
|
|
|
|
2002-08-22 23:52:10 +05:30
|
|
|
#define INITTAB "/etc/inittab" /* inittab file location */
|
2000-01-07 17:10:44 +05:30
|
|
|
#ifndef INIT_SCRIPT
|
2002-08-22 23:52:10 +05:30
|
|
|
#define INIT_SCRIPT "/etc/init.d/rcS" /* Default sysinit script. */
|
2000-01-07 17:10:44 +05:30
|
|
|
#endif
|
1999-12-30 14:55:17 +05:30
|
|
|
|
2000-01-04 06:40:25 +05:30
|
|
|
/* Allowed init action types */
|
2002-03-05 20:42:19 +05:30
|
|
|
#define SYSINIT 0x001
|
|
|
|
#define RESPAWN 0x002
|
|
|
|
#define ASKFIRST 0x004
|
|
|
|
#define WAIT 0x008
|
|
|
|
#define ONCE 0x010
|
|
|
|
#define CTRLALTDEL 0x020
|
|
|
|
#define SHUTDOWN 0x040
|
|
|
|
#define RESTART 0x080
|
2000-01-04 06:40:25 +05:30
|
|
|
|
2000-03-21 03:04:52 +05:30
|
|
|
/* A mapping between "inittab" action name strings and action type codes. */
|
2002-03-05 20:42:19 +05:30
|
|
|
struct init_action_type {
|
2000-02-09 01:28:47 +05:30
|
|
|
const char *name;
|
2002-03-05 20:42:19 +05:30
|
|
|
int action;
|
|
|
|
};
|
2000-01-04 06:40:25 +05:30
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
static const struct init_action_type actions[] = {
|
2000-02-09 01:28:47 +05:30
|
|
|
{"sysinit", SYSINIT},
|
|
|
|
{"respawn", RESPAWN},
|
|
|
|
{"askfirst", ASKFIRST},
|
|
|
|
{"wait", WAIT},
|
|
|
|
{"once", ONCE},
|
2000-02-09 09:46:43 +05:30
|
|
|
{"ctrlaltdel", CTRLALTDEL},
|
2001-04-03 23:31:51 +05:30
|
|
|
{"shutdown", SHUTDOWN},
|
2001-12-18 04:43:08 +05:30
|
|
|
{"restart", RESTART},
|
2000-07-14 21:14:25 +05:30
|
|
|
{0, 0}
|
2000-01-04 06:40:25 +05:30
|
|
|
};
|
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
/* Set up a linked list of init_actions, to be read from inittab */
|
|
|
|
struct init_action {
|
|
|
|
struct init_action *next;
|
|
|
|
int action;
|
2007-02-21 05:45:20 +05:30
|
|
|
pid_t pid;
|
|
|
|
char command[INIT_BUFFS_SIZE];
|
|
|
|
char terminal[CONSOLE_NAME_SIZE];
|
2000-01-04 06:40:25 +05:30
|
|
|
};
|
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
/* Static variables */
|
|
|
|
static struct init_action *init_action_list = NULL;
|
2002-08-22 23:52:10 +05:30
|
|
|
|
2007-03-06 01:25:30 +05:30
|
|
|
#if !ENABLE_FEATURE_INIT_SYSLOG
|
2007-02-03 09:01:13 +05:30
|
|
|
static const char *log_console = VC_5;
|
2002-07-29 13:30:16 +05:30
|
|
|
#endif
|
2006-06-02 16:13:17 +05:30
|
|
|
#if !ENABLE_DEBUG_INIT
|
2002-03-05 20:42:19 +05:30
|
|
|
static sig_atomic_t got_cont = 0;
|
2006-06-02 16:13:17 +05:30
|
|
|
#endif
|
2006-03-11 00:52:06 +05:30
|
|
|
|
|
|
|
enum {
|
2007-02-17 21:22:02 +05:30
|
|
|
L_LOG = 0x1,
|
|
|
|
L_CONSOLE = 0x2,
|
2002-08-22 23:52:10 +05:30
|
|
|
|
2007-01-03 08:26:00 +05:30
|
|
|
#if ENABLE_FEATURE_EXTRA_QUIET
|
2006-03-11 00:52:06 +05:30
|
|
|
MAYBE_CONSOLE = 0x0,
|
2002-03-05 20:42:19 +05:30
|
|
|
#else
|
2007-02-17 21:22:02 +05:30
|
|
|
MAYBE_CONSOLE = L_CONSOLE,
|
2002-03-05 20:42:19 +05:30
|
|
|
#endif
|
2002-08-22 23:52:10 +05:30
|
|
|
|
2006-03-11 00:52:06 +05:30
|
|
|
#ifndef RB_HALT_SYSTEM
|
2006-06-02 16:13:17 +05:30
|
|
|
RB_HALT_SYSTEM = 0xcdef0123, /* FIXME: this overflows enum */
|
2006-03-11 00:52:06 +05:30
|
|
|
RB_ENABLE_CAD = 0x89abcdef,
|
|
|
|
RB_DISABLE_CAD = 0,
|
|
|
|
RB_POWER_OFF = 0x4321fedc,
|
|
|
|
RB_AUTOBOOT = 0x01234567,
|
2002-03-05 20:42:19 +05:30
|
|
|
#endif
|
2006-03-11 00:52:06 +05:30
|
|
|
};
|
2002-03-05 20:42:19 +05:30
|
|
|
|
2007-08-13 02:28:27 +05:30
|
|
|
static const char *const environment[] = {
|
2003-01-14 03:39:50 +05:30
|
|
|
"HOME=/",
|
2007-06-13 04:05:19 +05:30
|
|
|
bb_PATH_root_path,
|
2003-09-02 08:06:18 +05:30
|
|
|
"SHELL=/bin/sh",
|
2003-01-14 03:39:50 +05:30
|
|
|
"USER=root",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
/* Function prototypes */
|
|
|
|
static void delete_init_action(struct init_action *a);
|
2006-05-30 17:40:29 +05:30
|
|
|
static int waitfor(const struct init_action *a, pid_t pid);
|
2006-06-02 16:13:17 +05:30
|
|
|
#if !ENABLE_DEBUG_INIT
|
2006-06-01 18:47:49 +05:30
|
|
|
static void shutdown_signal(int sig);
|
2006-06-02 16:13:17 +05:30
|
|
|
#endif
|
1999-10-26 05:02:44 +05:30
|
|
|
|
2007-01-03 08:26:00 +05:30
|
|
|
#if !ENABLE_DEBUG_INIT
|
2001-10-18 09:41:39 +05:30
|
|
|
static void loop_forever(void)
|
2001-06-03 11:25:52 +05:30
|
|
|
{
|
|
|
|
while (1)
|
2002-08-22 23:52:10 +05:30
|
|
|
sleep(1);
|
2001-06-03 11:25:52 +05:30
|
|
|
}
|
2007-01-03 08:26:00 +05:30
|
|
|
#endif
|
2001-03-20 23:09:08 +05:30
|
|
|
|
2000-03-21 03:04:52 +05:30
|
|
|
/* Print a message to the specified device.
|
2007-02-17 21:22:02 +05:30
|
|
|
* Device may be bitwise-or'd from L_LOG | L_CONSOLE */
|
2006-05-29 18:38:35 +05:30
|
|
|
#if ENABLE_DEBUG_INIT
|
|
|
|
#define messageD message
|
|
|
|
#else
|
2006-12-26 16:12:51 +05:30
|
|
|
#define messageD(...) do {} while (0)
|
2001-11-17 12:57:14 +05:30
|
|
|
#endif
|
2003-01-14 03:39:50 +05:30
|
|
|
static void message(int device, const char *fmt, ...)
|
2002-08-22 23:52:10 +05:30
|
|
|
__attribute__ ((format(printf, 2, 3)));
|
2003-01-14 03:39:50 +05:30
|
|
|
static void message(int device, const char *fmt, ...)
|
1999-10-05 21:54:54 +05:30
|
|
|
{
|
2007-03-06 01:25:30 +05:30
|
|
|
#if !ENABLE_FEATURE_INIT_SYSLOG
|
2003-01-23 12:38:26 +05:30
|
|
|
static int log_fd = -1;
|
|
|
|
#endif
|
1999-11-26 13:42:56 +05:30
|
|
|
|
2007-02-21 05:45:20 +05:30
|
|
|
va_list arguments;
|
|
|
|
int l;
|
|
|
|
char msg[128];
|
|
|
|
|
2003-01-14 03:39:50 +05:30
|
|
|
msg[0] = '\r';
|
2007-02-21 05:45:20 +05:30
|
|
|
va_start(arguments, fmt);
|
|
|
|
vsnprintf(msg + 1, sizeof(msg) - 2, fmt, arguments);
|
2007-02-17 21:22:02 +05:30
|
|
|
va_end(arguments);
|
2007-02-21 05:45:20 +05:30
|
|
|
msg[sizeof(msg) - 2] = '\0';
|
|
|
|
l = strlen(msg);
|
2003-01-14 03:39:50 +05:30
|
|
|
|
2007-03-06 01:25:30 +05:30
|
|
|
#if ENABLE_FEATURE_INIT_SYSLOG
|
2003-01-14 03:39:50 +05:30
|
|
|
/* Log the message to syslogd */
|
2007-02-17 21:22:02 +05:30
|
|
|
if (device & L_LOG) {
|
2007-02-21 05:45:20 +05:30
|
|
|
/* don't out "\r" */
|
2006-10-04 02:30:43 +05:30
|
|
|
openlog(applet_name, 0, LOG_DAEMON);
|
2007-02-21 05:45:20 +05:30
|
|
|
syslog(LOG_INFO, "init: %s", msg + 1);
|
2004-06-22 15:37:17 +05:30
|
|
|
closelog();
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
2003-01-14 03:39:50 +05:30
|
|
|
msg[l++] = '\n';
|
2007-02-21 05:45:20 +05:30
|
|
|
msg[l] = '\0';
|
1999-11-26 13:42:56 +05:30
|
|
|
#else
|
2003-01-14 03:39:50 +05:30
|
|
|
msg[l++] = '\n';
|
2007-02-21 05:45:20 +05:30
|
|
|
msg[l] = '\0';
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Take full control of the log tty, and never close it.
|
|
|
|
* It's mine, all mine! Muhahahaha! */
|
|
|
|
if (log_fd < 0) {
|
2007-02-21 05:45:20 +05:30
|
|
|
if (!log_console) {
|
|
|
|
log_fd = 2;
|
2002-10-01 01:38:53 +05:30
|
|
|
} else {
|
2007-02-21 05:45:20 +05:30
|
|
|
log_fd = device_open(log_console, O_WRONLY | O_NONBLOCK | O_NOCTTY);
|
|
|
|
if (log_fd < 0) {
|
|
|
|
bb_error_msg("can't log to %s", log_console);
|
|
|
|
device = L_CONSOLE;
|
|
|
|
} else {
|
|
|
|
fcntl(log_fd, F_SETFD, FD_CLOEXEC);
|
|
|
|
}
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
|
|
|
}
|
2007-02-17 21:22:02 +05:30
|
|
|
if (device & L_LOG) {
|
2006-07-16 13:44:35 +05:30
|
|
|
full_write(log_fd, msg, l);
|
2007-02-21 05:45:20 +05:30
|
|
|
if (log_fd == 2)
|
|
|
|
return; /* don't print dup messages */
|
1999-11-04 06:43:21 +05:30
|
|
|
}
|
1999-11-26 13:42:56 +05:30
|
|
|
#endif
|
|
|
|
|
2007-02-17 21:22:02 +05:30
|
|
|
if (device & L_CONSOLE) {
|
2007-02-21 05:45:20 +05:30
|
|
|
/* Send console messages to console so people will see them. */
|
|
|
|
full_write(2, msg, l);
|
1999-11-04 06:43:21 +05:30
|
|
|
}
|
1999-10-05 21:54:54 +05:30
|
|
|
}
|
|
|
|
|
1999-10-26 05:02:44 +05:30
|
|
|
/* Set terminal settings to reasonable defaults */
|
2007-03-06 00:52:04 +05:30
|
|
|
static void set_sane_term(void)
|
1999-10-05 21:54:54 +05:30
|
|
|
{
|
2000-02-09 01:28:47 +05:30
|
|
|
struct termios tty;
|
1999-10-26 05:02:44 +05:30
|
|
|
|
2006-05-29 18:27:52 +05:30
|
|
|
tcgetattr(STDIN_FILENO, &tty);
|
1999-10-30 04:39:13 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* set control chars */
|
2002-08-22 23:52:10 +05:30
|
|
|
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 */
|
2000-07-11 01:26:47 +05:30
|
|
|
tty.c_cc[VSTART] = 17; /* C-q */
|
2002-08-22 23:52:10 +05:30
|
|
|
tty.c_cc[VSTOP] = 19; /* C-s */
|
|
|
|
tty.c_cc[VSUSP] = 26; /* C-z */
|
2000-07-07 02:59:32 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* use line dicipline 0 */
|
|
|
|
tty.c_line = 0;
|
1999-10-30 04:39:13 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Make it be sane */
|
2002-08-22 23:52:10 +05:30
|
|
|
tty.c_cflag &= CBAUD | CBAUDEX | CSIZE | CSTOPB | PARENB | PARODD;
|
|
|
|
tty.c_cflag |= CREAD | HUPCL | CLOCAL;
|
2001-04-23 20:44:11 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* input modes */
|
|
|
|
tty.c_iflag = ICRNL | IXON | IXOFF;
|
1999-11-19 08:08:58 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* output modes */
|
|
|
|
tty.c_oflag = OPOST | ONLCR;
|
1999-10-30 04:39:13 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* local modes */
|
|
|
|
tty.c_lflag =
|
|
|
|
ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN;
|
1999-10-26 05:02:44 +05:30
|
|
|
|
2006-05-29 18:27:52 +05:30
|
|
|
tcsetattr(STDIN_FILENO, TCSANOW, &tty);
|
1999-10-05 21:54:54 +05:30
|
|
|
}
|
|
|
|
|
2007-02-21 05:45:20 +05:30
|
|
|
/* From <linux/serial.h> */
|
|
|
|
struct serial_struct {
|
|
|
|
int type;
|
|
|
|
int line;
|
|
|
|
unsigned int port;
|
|
|
|
int irq;
|
|
|
|
int flags;
|
|
|
|
int xmit_fifo_size;
|
|
|
|
int custom_divisor;
|
|
|
|
int baud_base;
|
|
|
|
unsigned short close_delay;
|
|
|
|
char io_type;
|
|
|
|
char reserved_char[1];
|
|
|
|
int hub6;
|
|
|
|
unsigned short closing_wait; /* time to wait before closing */
|
|
|
|
unsigned short closing_wait2; /* no longer used... */
|
|
|
|
unsigned char *iomem_base;
|
|
|
|
unsigned short iomem_reg_shift;
|
|
|
|
unsigned int port_high;
|
|
|
|
unsigned long iomap_base; /* cookie passed into ioremap */
|
|
|
|
int reserved[1];
|
|
|
|
/* Paranoia (imagine 64bit kernel overwriting 32bit userspace stack) */
|
|
|
|
uint32_t bbox_reserved[16];
|
|
|
|
};
|
2001-10-18 09:41:39 +05:30
|
|
|
static void console_init(void)
|
1999-10-05 21:54:54 +05:30
|
|
|
{
|
2000-02-09 01:28:47 +05:30
|
|
|
struct serial_struct sr;
|
|
|
|
char *s;
|
|
|
|
|
2007-02-21 05:45:20 +05:30
|
|
|
s = getenv("CONSOLE");
|
|
|
|
if (!s) s = getenv("console");
|
|
|
|
if (s) {
|
|
|
|
int fd = open(s, O_RDWR | O_NONBLOCK | O_NOCTTY);
|
|
|
|
if (fd >= 0) {
|
|
|
|
dup2(fd, 0);
|
|
|
|
dup2(fd, 1);
|
|
|
|
dup2(fd, 2);
|
|
|
|
while (fd > 2) close(fd--);
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
2007-02-21 05:45:20 +05:30
|
|
|
messageD(L_LOG, "console='%s'", s);
|
2007-06-14 13:23:06 +05:30
|
|
|
} else {
|
|
|
|
/* Make sure fd 0,1,2 are not closed */
|
|
|
|
bb_sanitize_stdio();
|
1999-10-26 05:02:44 +05:30
|
|
|
}
|
2000-02-09 01:28:47 +05:30
|
|
|
|
2007-02-21 05:45:20 +05:30
|
|
|
s = getenv("TERM");
|
|
|
|
if (ioctl(0, TIOCGSERIAL, &sr) == 0) {
|
|
|
|
/* Force the TERM setting to vt102 for serial console --
|
|
|
|
* if TERM is set to linux (the default) */
|
|
|
|
if (!s || strcmp(s, "linux") == 0)
|
|
|
|
putenv((char*)"TERM=vt102");
|
2007-03-06 01:25:30 +05:30
|
|
|
#if !ENABLE_FEATURE_INIT_SYSLOG
|
2007-02-21 05:45:20 +05:30
|
|
|
log_console = NULL;
|
2003-01-14 03:39:50 +05:30
|
|
|
#endif
|
2007-02-21 05:45:20 +05:30
|
|
|
} else if (!s)
|
|
|
|
putenv((char*)"TERM=linux");
|
1999-10-26 05:02:44 +05:30
|
|
|
}
|
2002-08-22 23:52:10 +05:30
|
|
|
|
2007-06-14 13:23:06 +05:30
|
|
|
static void fixup_argv(char **argv)
|
2001-03-20 23:09:08 +05:30
|
|
|
{
|
|
|
|
/* Fix up argv[0] to be certain we claim to be init */
|
2007-06-14 13:23:06 +05:30
|
|
|
strncpy(argv[0], "init", strlen(argv[0]));
|
2001-03-20 23:09:08 +05:30
|
|
|
|
|
|
|
/* Wipe argv[1]-argv[N] so they don't clutter the ps listing */
|
2007-06-14 13:23:06 +05:30
|
|
|
while (*++argv)
|
|
|
|
memset(*argv, 0, strlen(*argv));
|
2001-03-20 23:09:08 +05:30
|
|
|
}
|
|
|
|
|
2006-05-29 18:24:16 +05:30
|
|
|
/* Open the new terminal device */
|
2007-02-21 05:45:20 +05:30
|
|
|
static void open_stdio_to_tty(const char* tty_name, int fail)
|
|
|
|
{
|
|
|
|
/* empty tty_name means "use init's tty", else... */
|
|
|
|
if (tty_name[0]) {
|
2007-03-06 00:52:04 +05:30
|
|
|
int fd = device_open(tty_name, O_RDWR);
|
|
|
|
if (fd < 0) {
|
2007-02-28 00:50:33 +05:30
|
|
|
message(L_LOG | L_CONSOLE, "Can't open %s: %s",
|
2007-02-21 05:45:20 +05:30
|
|
|
tty_name, strerror(errno));
|
|
|
|
if (fail)
|
|
|
|
_exit(1);
|
2006-06-02 16:13:17 +05:30
|
|
|
#if !ENABLE_DEBUG_INIT
|
2007-02-21 05:45:20 +05:30
|
|
|
shutdown_signal(SIGUSR1);
|
2006-06-02 16:13:17 +05:30
|
|
|
#else
|
2007-02-21 05:45:20 +05:30
|
|
|
_exit(2);
|
2006-06-02 16:13:17 +05:30
|
|
|
#endif
|
2007-03-06 00:52:04 +05:30
|
|
|
} else {
|
|
|
|
dup2(fd, 0);
|
|
|
|
dup2(fd, 1);
|
|
|
|
dup2(fd, 2);
|
|
|
|
if (fd > 2) close(fd);
|
2007-02-21 05:45:20 +05:30
|
|
|
}
|
2006-05-29 18:24:16 +05:30
|
|
|
}
|
2007-03-06 00:52:04 +05:30
|
|
|
set_sane_term();
|
2006-05-29 18:24:16 +05:30
|
|
|
}
|
|
|
|
|
2003-01-14 03:39:50 +05:30
|
|
|
static pid_t run(const struct init_action *a)
|
2002-03-05 20:42:19 +05:30
|
|
|
{
|
2006-05-30 17:40:29 +05:30
|
|
|
int i;
|
2005-07-06 10:30:48 +05:30
|
|
|
pid_t pid;
|
2007-01-30 04:21:44 +05:30
|
|
|
char *s, *tmpCmd, *cmdpath;
|
|
|
|
char *cmd[INIT_BUFFS_SIZE];
|
2002-08-22 23:52:10 +05:30
|
|
|
char buf[INIT_BUFFS_SIZE + 6]; /* INIT_BUFFS_SIZE+strlen("exec ")+1 */
|
2002-03-05 20:42:19 +05:30
|
|
|
sigset_t nmask, omask;
|
1999-10-26 05:02:44 +05:30
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
/* Block sigchild while forking. */
|
|
|
|
sigemptyset(&nmask);
|
|
|
|
sigaddset(&nmask, SIGCHLD);
|
|
|
|
sigprocmask(SIG_BLOCK, &nmask, &omask);
|
2007-02-28 00:50:33 +05:30
|
|
|
pid = fork();
|
|
|
|
sigprocmask(SIG_SETMASK, &omask, NULL);
|
2002-03-05 20:42:19 +05:30
|
|
|
|
2007-02-28 00:50:33 +05:30
|
|
|
if (pid)
|
|
|
|
return pid;
|
|
|
|
|
|
|
|
/* Reset signal handlers that were set by the parent process */
|
|
|
|
signal(SIGUSR1, SIG_DFL);
|
|
|
|
signal(SIGUSR2, SIG_DFL);
|
|
|
|
signal(SIGINT, SIG_DFL);
|
|
|
|
signal(SIGTERM, SIG_DFL);
|
|
|
|
signal(SIGHUP, SIG_DFL);
|
|
|
|
signal(SIGQUIT, SIG_DFL);
|
|
|
|
signal(SIGCONT, SIG_DFL);
|
|
|
|
signal(SIGSTOP, SIG_DFL);
|
|
|
|
signal(SIGTSTP, SIG_DFL);
|
|
|
|
|
|
|
|
/* Create a new session and make ourself the process
|
|
|
|
* group leader */
|
|
|
|
setsid();
|
|
|
|
|
|
|
|
/* Open the new terminal device */
|
|
|
|
open_stdio_to_tty(a->terminal, 1);
|
|
|
|
|
|
|
|
/* If the init Action requires us to wait, then force the
|
|
|
|
* supplied terminal to be the controlling tty. */
|
|
|
|
if (a->action & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) {
|
|
|
|
|
|
|
|
/* Now fork off another process to just hang around */
|
|
|
|
if ((pid = fork()) < 0) {
|
|
|
|
message(L_LOG | L_CONSOLE, "Can't fork");
|
|
|
|
_exit(1);
|
|
|
|
}
|
2002-07-03 16:38:10 +05:30
|
|
|
|
2007-02-28 00:50:33 +05:30
|
|
|
if (pid > 0) {
|
2000-02-09 01:28:47 +05:30
|
|
|
|
2007-02-28 00:50:33 +05:30
|
|
|
/* 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);
|
2002-03-05 20:42:19 +05:30
|
|
|
|
2007-02-28 00:50:33 +05:30
|
|
|
waitfor(NULL, pid);
|
|
|
|
/* See if stealing the controlling tty back is necessary */
|
|
|
|
if (tcgetpgrp(0) != getpid())
|
|
|
|
_exit(0);
|
|
|
|
|
|
|
|
/* Use a temporary process to steal the controlling tty. */
|
2002-03-05 20:42:19 +05:30
|
|
|
if ((pid = fork()) < 0) {
|
2007-02-28 00:50:33 +05:30
|
|
|
message(L_LOG | L_CONSOLE, "Can't fork");
|
2002-03-05 20:42:19 +05:30
|
|
|
_exit(1);
|
|
|
|
}
|
2007-02-28 00:50:33 +05:30
|
|
|
if (pid == 0) {
|
|
|
|
setsid();
|
|
|
|
ioctl(0, TIOCSCTTY, 1);
|
2002-03-05 20:42:19 +05:30
|
|
|
_exit(0);
|
|
|
|
}
|
2007-02-28 00:50:33 +05:30
|
|
|
waitfor(NULL, pid);
|
|
|
|
_exit(0);
|
2002-03-05 20:42:19 +05:30
|
|
|
}
|
|
|
|
|
2007-02-28 00:50:33 +05:30
|
|
|
/* Now fall though to actually execute things */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See if any special /bin/sh requiring characters are present */
|
|
|
|
if (strpbrk(a->command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) {
|
|
|
|
cmd[0] = (char*)DEFAULT_SHELL;
|
|
|
|
cmd[1] = (char*)"-c";
|
|
|
|
cmd[2] = strcat(strcpy(buf, "exec "), a->command);
|
|
|
|
cmd[3] = NULL;
|
|
|
|
} else {
|
|
|
|
/* Convert command (char*) into cmd (char**, one word per string) */
|
|
|
|
strcpy(buf, a->command);
|
|
|
|
s = buf;
|
|
|
|
for (tmpCmd = buf, i = 0; (tmpCmd = strsep(&s, " \t")) != NULL;) {
|
|
|
|
if (*tmpCmd != '\0') {
|
|
|
|
cmd[i] = tmpCmd;
|
|
|
|
i++;
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
|
|
|
}
|
2007-02-28 00:50:33 +05:30
|
|
|
cmd[i] = NULL;
|
|
|
|
}
|
2000-02-09 01:28:47 +05:30
|
|
|
|
2007-02-28 00:50:33 +05:30
|
|
|
cmdpath = cmd[0];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Interactive shells want to see a dash in argv[0]. This
|
|
|
|
* typically is handled by login, argv will be setup this
|
|
|
|
* way if a dash appears at the front of the command path
|
|
|
|
* (like "-/bin/sh").
|
|
|
|
*/
|
|
|
|
if (*cmdpath == '-') {
|
|
|
|
/* skip over the dash */
|
|
|
|
++cmdpath;
|
|
|
|
|
|
|
|
/* find the last component in the command pathname */
|
2007-09-24 23:57:04 +05:30
|
|
|
s = bb_get_last_path_component_nostrip(cmdpath);
|
2007-02-28 00:50:33 +05:30
|
|
|
|
|
|
|
/* make a new argv[0] */
|
2007-09-24 23:57:04 +05:30
|
|
|
cmd[0] = malloc(strlen(s) + 2);
|
|
|
|
if (cmd[0] == NULL) {
|
2007-02-28 00:50:33 +05:30
|
|
|
message(L_LOG | L_CONSOLE, bb_msg_memory_exhausted);
|
|
|
|
cmd[0] = cmdpath;
|
|
|
|
} else {
|
|
|
|
cmd[0][0] = '-';
|
|
|
|
strcpy(cmd[0] + 1, s);
|
|
|
|
}
|
2007-01-03 08:26:00 +05:30
|
|
|
#if ENABLE_FEATURE_INIT_SCTTY
|
2007-02-28 00:50:33 +05:30
|
|
|
/* Establish this process as session leader and
|
|
|
|
* (attempt) to make the tty (if any) a controlling tty.
|
|
|
|
*/
|
|
|
|
setsid();
|
|
|
|
ioctl(0, TIOCSCTTY, 0 /*don't steal it*/);
|
2005-08-01 22:13:13 +05:30
|
|
|
#endif
|
2007-02-28 00:50:33 +05:30
|
|
|
}
|
2001-03-20 23:09:08 +05:30
|
|
|
|
2004-08-16 14:59:42 +05:30
|
|
|
#if !defined(__UCLIBC__) || defined(__ARCH_HAS_MMU__)
|
2007-02-28 00:50:33 +05:30
|
|
|
if (a->action & ASKFIRST) {
|
2007-08-13 02:28:27 +05:30
|
|
|
static const char press_enter[] ALIGN1 =
|
2007-02-28 00:50:33 +05:30
|
|
|
#ifdef CUSTOMIZED_BANNER
|
|
|
|
#include CUSTOMIZED_BANNER
|
2004-08-16 14:59:42 +05:30
|
|
|
#endif
|
2007-02-28 00:50:33 +05:30
|
|
|
"\nPlease press Enter to activate this console. ";
|
|
|
|
char c;
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
messageD(L_LOG, "waiting for enter to start '%s'"
|
|
|
|
"(pid %d, tty '%s')\n",
|
|
|
|
cmdpath, getpid(), a->terminal);
|
|
|
|
full_write(1, press_enter, sizeof(press_enter) - 1);
|
|
|
|
while (read(0, &c, 1) == 1 && c != '\n')
|
|
|
|
;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Log the process name and args */
|
|
|
|
message(L_LOG, "starting pid %d, tty '%s': '%s'",
|
|
|
|
getpid(), a->terminal, cmdpath);
|
2000-09-15 03:31:31 +05:30
|
|
|
|
2007-01-03 08:26:00 +05:30
|
|
|
#if ENABLE_FEATURE_INIT_COREDUMPS
|
2007-02-28 00:50:33 +05:30
|
|
|
{
|
|
|
|
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);
|
2000-04-04 23:44:25 +05:30
|
|
|
}
|
2000-01-04 06:40:25 +05:30
|
|
|
}
|
2007-02-28 00:50:33 +05:30
|
|
|
#endif
|
|
|
|
/* Now run it. The new program will take over this PID,
|
|
|
|
* so nothing further in init.c should be run. */
|
|
|
|
BB_EXECVP(cmdpath, cmd);
|
|
|
|
|
|
|
|
/* We're still here? Some error happened. */
|
|
|
|
message(L_LOG | L_CONSOLE, "Cannot run '%s': %s",
|
|
|
|
cmdpath, strerror(errno));
|
|
|
|
_exit(-1);
|
1999-10-26 05:02:44 +05:30
|
|
|
}
|
|
|
|
|
2006-05-30 17:40:29 +05:30
|
|
|
static int waitfor(const struct init_action *a, pid_t pid)
|
2000-01-07 08:24:55 +05:30
|
|
|
{
|
2006-05-30 17:40:29 +05:30
|
|
|
int runpid;
|
2000-02-09 01:28:47 +05:30
|
|
|
int status, wpid;
|
|
|
|
|
2006-05-30 17:40:29 +05:30
|
|
|
runpid = (NULL == a)? pid : run(a);
|
2000-02-09 01:28:47 +05:30
|
|
|
while (1) {
|
2007-02-16 22:47:07 +05:30
|
|
|
wpid = waitpid(runpid, &status, 0);
|
2006-05-30 17:40:29 +05:30
|
|
|
if (wpid == runpid)
|
2000-02-09 01:28:47 +05:30
|
|
|
break;
|
2003-09-26 16:15:55 +05:30
|
|
|
if (wpid == -1 && errno == ECHILD) {
|
|
|
|
/* we missed its termination */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FIXME other errors should maybe trigger an error, but allow
|
|
|
|
* the program to continue */
|
2000-01-07 08:24:55 +05:30
|
|
|
}
|
2000-02-09 01:28:47 +05:30
|
|
|
return wpid;
|
2000-01-07 08:24:55 +05:30
|
|
|
}
|
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
/* Run all commands of a particular type */
|
|
|
|
static void run_actions(int action)
|
1999-11-03 01:13:01 +05:30
|
|
|
{
|
2002-03-05 20:42:19 +05:30
|
|
|
struct init_action *a, *tmp;
|
2000-02-09 01:28:47 +05:30
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
for (a = init_action_list; a; a = tmp) {
|
|
|
|
tmp = a->next;
|
2001-04-03 23:31:51 +05:30
|
|
|
if (a->action == action) {
|
2007-02-21 05:45:20 +05:30
|
|
|
/* a->terminal of "" means "init's console" */
|
|
|
|
if (a->terminal[0] && access(a->terminal, R_OK | W_OK)) {
|
2006-03-22 23:09:13 +05:30
|
|
|
delete_init_action(a);
|
|
|
|
} else if (a->action & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) {
|
2006-05-30 17:40:29 +05:30
|
|
|
waitfor(a, 0);
|
2002-03-05 20:42:19 +05:30
|
|
|
delete_init_action(a);
|
|
|
|
} else if (a->action & ONCE) {
|
|
|
|
run(a);
|
|
|
|
delete_init_action(a);
|
2002-08-22 23:52:10 +05:30
|
|
|
} else if (a->action & (RESPAWN | ASKFIRST)) {
|
2002-03-05 20:42:19 +05:30
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
}
|
2000-02-09 09:46:43 +05:30
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-29 18:38:35 +05:30
|
|
|
#if !ENABLE_DEBUG_INIT
|
2003-04-24 17:11:28 +05:30
|
|
|
static void init_reboot(unsigned long magic)
|
|
|
|
{
|
|
|
|
pid_t pid;
|
|
|
|
/* We have to fork here, since the kernel calls do_exit(0) in
|
2004-03-15 13:59:22 +05:30
|
|
|
* linux/kernel/sys.c, which can cause the machine to panic when
|
2003-04-24 17:11:28 +05:30
|
|
|
* the init process is killed.... */
|
2007-01-03 08:26:00 +05:30
|
|
|
pid = vfork();
|
|
|
|
if (pid == 0) { /* child */
|
2003-04-24 17:11:28 +05:30
|
|
|
reboot(magic);
|
|
|
|
_exit(0);
|
|
|
|
}
|
2007-01-03 08:26:00 +05:30
|
|
|
waitpid(pid, NULL, 0);
|
2003-04-24 17:11:28 +05:30
|
|
|
}
|
|
|
|
|
1999-10-26 05:48:56 +05:30
|
|
|
static void shutdown_system(void)
|
1999-10-26 05:02:44 +05:30
|
|
|
{
|
2001-10-29 04:19:48 +05:30
|
|
|
sigset_t block_signals;
|
2000-02-09 09:46:43 +05:30
|
|
|
|
2002-09-16 12:19:06 +05:30
|
|
|
/* run everything to be run at "shutdown". This is done _prior_
|
|
|
|
* to killing everything, in case people wish to use scripts to
|
|
|
|
* shut things down gracefully... */
|
|
|
|
run_actions(SHUTDOWN);
|
|
|
|
|
2001-10-28 10:42:20 +05:30
|
|
|
/* first disable all our signals */
|
|
|
|
sigemptyset(&block_signals);
|
|
|
|
sigaddset(&block_signals, SIGHUP);
|
2005-04-16 13:51:34 +05:30
|
|
|
sigaddset(&block_signals, SIGQUIT);
|
2001-10-28 10:42:20 +05:30
|
|
|
sigaddset(&block_signals, SIGCHLD);
|
|
|
|
sigaddset(&block_signals, SIGUSR1);
|
|
|
|
sigaddset(&block_signals, SIGUSR2);
|
|
|
|
sigaddset(&block_signals, SIGINT);
|
|
|
|
sigaddset(&block_signals, SIGTERM);
|
2001-12-01 00:40:58 +05:30
|
|
|
sigaddset(&block_signals, SIGCONT);
|
|
|
|
sigaddset(&block_signals, SIGSTOP);
|
|
|
|
sigaddset(&block_signals, SIGTSTP);
|
2001-10-28 10:42:20 +05:30
|
|
|
sigprocmask(SIG_BLOCK, &block_signals, NULL);
|
2000-02-09 01:28:47 +05:30
|
|
|
|
2007-02-21 05:45:20 +05:30
|
|
|
message(L_CONSOLE | L_LOG, "The system is going down NOW!");
|
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Allow Ctrl-Alt-Del to reboot system. */
|
2000-04-28 05:48:56 +05:30
|
|
|
init_reboot(RB_ENABLE_CAD);
|
2000-02-09 09:46:43 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Send signals to every process _except_ pid 1 */
|
2007-02-21 05:45:20 +05:30
|
|
|
message(L_CONSOLE | L_LOG, "Sending SIG%s to all processes", "TERM");
|
2000-02-09 01:28:47 +05:30
|
|
|
kill(-1, SIGTERM);
|
|
|
|
sync();
|
2000-02-09 09:46:43 +05:30
|
|
|
sleep(1);
|
|
|
|
|
2007-02-21 05:45:20 +05:30
|
|
|
message(L_CONSOLE | L_LOG, "Sending SIG%s to all processes", "KILL");
|
|
|
|
kill(-1, SIGKILL);
|
1999-11-05 06:01:46 +05:30
|
|
|
sync();
|
2007-02-21 05:45:20 +05:30
|
|
|
sleep(1);
|
1999-10-05 21:54:54 +05:30
|
|
|
}
|
|
|
|
|
2006-02-01 20:17:52 +05:30
|
|
|
static void exec_signal(int sig ATTRIBUTE_UNUSED)
|
2001-12-18 04:43:08 +05:30
|
|
|
{
|
2002-03-05 20:42:19 +05:30
|
|
|
struct init_action *a, *tmp;
|
2002-07-03 10:45:23 +05:30
|
|
|
sigset_t unblock_signals;
|
2002-08-22 23:52:10 +05:30
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
for (a = init_action_list; a; a = tmp) {
|
|
|
|
tmp = a->next;
|
|
|
|
if (a->action & RESTART) {
|
2001-12-18 04:43:08 +05:30
|
|
|
shutdown_system();
|
2002-07-03 10:45:23 +05:30
|
|
|
|
|
|
|
/* unblock all signals, blocked in shutdown_system() */
|
|
|
|
sigemptyset(&unblock_signals);
|
|
|
|
sigaddset(&unblock_signals, SIGHUP);
|
2005-04-16 13:51:34 +05:30
|
|
|
sigaddset(&unblock_signals, SIGQUIT);
|
2002-07-03 10:45:23 +05:30
|
|
|
sigaddset(&unblock_signals, SIGCHLD);
|
|
|
|
sigaddset(&unblock_signals, SIGUSR1);
|
|
|
|
sigaddset(&unblock_signals, SIGUSR2);
|
|
|
|
sigaddset(&unblock_signals, SIGINT);
|
|
|
|
sigaddset(&unblock_signals, SIGTERM);
|
|
|
|
sigaddset(&unblock_signals, SIGCONT);
|
|
|
|
sigaddset(&unblock_signals, SIGSTOP);
|
|
|
|
sigaddset(&unblock_signals, SIGTSTP);
|
|
|
|
sigprocmask(SIG_UNBLOCK, &unblock_signals, NULL);
|
|
|
|
|
2003-07-05 13:59:01 +05:30
|
|
|
/* Open the new terminal device */
|
2007-02-21 05:45:20 +05:30
|
|
|
open_stdio_to_tty(a->terminal, 0);
|
2003-07-05 13:59:01 +05:30
|
|
|
|
2007-02-17 21:22:02 +05:30
|
|
|
messageD(L_CONSOLE | L_LOG, "Trying to re-exec %s", a->command);
|
2007-02-03 07:47:41 +05:30
|
|
|
BB_EXECLP(a->command, a->command, NULL);
|
2002-08-22 23:52:10 +05:30
|
|
|
|
2007-02-21 05:45:20 +05:30
|
|
|
message(L_CONSOLE | L_LOG, "Cannot run '%s': %s",
|
|
|
|
a->command, strerror(errno));
|
2001-12-18 04:43:08 +05:30
|
|
|
sleep(2);
|
|
|
|
init_reboot(RB_HALT_SYSTEM);
|
|
|
|
loop_forever();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-01 18:47:49 +05:30
|
|
|
static void shutdown_signal(int sig)
|
1999-10-05 21:54:54 +05:30
|
|
|
{
|
2007-02-03 08:12:47 +05:30
|
|
|
const char *m;
|
2006-06-01 18:47:49 +05:30
|
|
|
int rb;
|
2000-01-25 23:43:53 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
shutdown_system();
|
2006-06-01 18:47:49 +05:30
|
|
|
|
2007-02-03 08:12:47 +05:30
|
|
|
m = "halt";
|
|
|
|
rb = RB_HALT_SYSTEM;
|
2006-06-01 18:47:49 +05:30
|
|
|
if (sig == SIGTERM) {
|
|
|
|
m = "reboot";
|
|
|
|
rb = RB_AUTOBOOT;
|
|
|
|
} else if (sig == SIGUSR2) {
|
|
|
|
m = "poweroff";
|
|
|
|
rb = RB_POWER_OFF;
|
|
|
|
}
|
2007-02-17 21:22:02 +05:30
|
|
|
message(L_CONSOLE | L_LOG, "Requesting system %s", m);
|
2000-02-09 01:28:47 +05:30
|
|
|
/* allow time for last message to reach serial console */
|
|
|
|
sleep(2);
|
2006-06-01 18:47:49 +05:30
|
|
|
init_reboot(rb);
|
2001-06-03 11:25:52 +05:30
|
|
|
loop_forever();
|
1999-10-05 21:54:54 +05:30
|
|
|
}
|
|
|
|
|
2006-02-01 20:17:52 +05:30
|
|
|
static void ctrlaltdel_signal(int sig ATTRIBUTE_UNUSED)
|
2001-04-03 23:31:51 +05:30
|
|
|
{
|
|
|
|
run_actions(CTRLALTDEL);
|
|
|
|
}
|
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
/* The SIGSTOP & SIGTSTP handler */
|
2006-02-01 20:17:52 +05:30
|
|
|
static void stop_handler(int sig ATTRIBUTE_UNUSED)
|
2001-12-01 00:40:58 +05:30
|
|
|
{
|
2002-03-05 20:42:19 +05:30
|
|
|
int saved_errno = errno;
|
2001-12-01 00:40:58 +05:30
|
|
|
|
|
|
|
got_cont = 0;
|
2002-08-22 23:52:10 +05:30
|
|
|
while (!got_cont)
|
|
|
|
pause();
|
2001-12-01 00:40:58 +05:30
|
|
|
got_cont = 0;
|
|
|
|
errno = saved_errno;
|
|
|
|
}
|
|
|
|
|
2002-08-22 23:52:10 +05:30
|
|
|
/* The SIGCONT handler */
|
2006-02-01 20:17:52 +05:30
|
|
|
static void cont_handler(int sig ATTRIBUTE_UNUSED)
|
2001-12-01 00:40:58 +05:30
|
|
|
{
|
|
|
|
got_cont = 1;
|
|
|
|
}
|
|
|
|
|
2007-02-03 08:12:47 +05:30
|
|
|
#endif /* !ENABLE_DEBUG_INIT */
|
2000-02-09 01:28:47 +05:30
|
|
|
|
2003-09-02 08:06:18 +05:30
|
|
|
static void new_init_action(int action, const char *command, const char *cons)
|
2000-02-09 01:28:47 +05:30
|
|
|
{
|
2004-10-08 13:47:39 +05:30
|
|
|
struct init_action *new_action, *a, *last;
|
2000-02-09 01:28:47 +05:30
|
|
|
|
2005-10-12 21:04:25 +05:30
|
|
|
if (strcmp(cons, bb_dev_null) == 0 && (action & ASKFIRST))
|
2001-09-06 01:48:15 +05:30
|
|
|
return;
|
2000-02-09 01:28:47 +05:30
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
/* Append to the end of the list */
|
2004-10-08 13:47:39 +05:30
|
|
|
for (a = last = init_action_list; a; a = a->next) {
|
2004-10-08 13:51:54 +05:30
|
|
|
/* don't enter action if it's already in the list,
|
|
|
|
* but do overwrite existing actions */
|
2007-02-17 21:22:02 +05:30
|
|
|
if ((strcmp(a->command, command) == 0)
|
|
|
|
&& (strcmp(a->terminal, cons) == 0)
|
|
|
|
) {
|
2004-10-08 13:51:54 +05:30
|
|
|
a->action = action;
|
2003-07-22 15:18:56 +05:30
|
|
|
return;
|
|
|
|
}
|
2004-10-08 13:47:39 +05:30
|
|
|
last = a;
|
2003-07-22 15:18:56 +05:30
|
|
|
}
|
2007-02-21 05:45:20 +05:30
|
|
|
|
|
|
|
new_action = xzalloc(sizeof(struct init_action));
|
2004-10-08 13:47:39 +05:30
|
|
|
if (last) {
|
|
|
|
last->next = new_action;
|
2001-09-06 01:48:15 +05:30
|
|
|
} else {
|
2002-03-05 20:42:19 +05:30
|
|
|
init_action_list = new_action;
|
2001-09-06 01:48:15 +05:30
|
|
|
}
|
2002-07-04 05:20:16 +05:30
|
|
|
strcpy(new_action->command, command);
|
2002-03-05 20:42:19 +05:30
|
|
|
new_action->action = action;
|
2002-07-04 05:20:16 +05:30
|
|
|
strcpy(new_action->terminal, cons);
|
2007-02-21 05:45:20 +05:30
|
|
|
messageD(L_LOG | L_CONSOLE, "command='%s' action=%d tty='%s'\n",
|
2003-01-14 03:39:50 +05:30
|
|
|
new_action->command, new_action->action, new_action->terminal);
|
2000-01-04 06:40:25 +05:30
|
|
|
}
|
|
|
|
|
2002-08-22 23:52:10 +05:30
|
|
|
static void delete_init_action(struct init_action *action)
|
2000-01-04 06:40:25 +05:30
|
|
|
{
|
2002-03-05 20:42:19 +05:30
|
|
|
struct init_action *a, *b = NULL;
|
2000-02-09 01:28:47 +05:30
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
for (a = init_action_list; a; b = a, a = a->next) {
|
2000-02-09 01:28:47 +05:30
|
|
|
if (a == action) {
|
|
|
|
if (b == NULL) {
|
2002-03-05 20:42:19 +05:30
|
|
|
init_action_list = a->next;
|
2000-02-09 01:28:47 +05:30
|
|
|
} else {
|
2002-03-05 20:42:19 +05:30
|
|
|
b->next = a->next;
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
|
|
|
free(a);
|
|
|
|
break;
|
|
|
|
}
|
2000-01-04 06:40:25 +05:30
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-10-24 10:30:29 +05:30
|
|
|
/* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
|
2000-01-06 06:46:13 +05:30
|
|
|
* then parse_inittab() simply adds in some default
|
2004-03-15 13:59:22 +05:30
|
|
|
* actions(i.e., runs INIT_SCRIPT and then starts a pair
|
|
|
|
* of "askfirst" shells). If CONFIG_FEATURE_USE_INITTAB
|
|
|
|
* _is_ defined, but /etc/inittab is missing, this
|
2000-01-08 00:00:40 +05:30
|
|
|
* results in the same set of default behaviors.
|
2002-08-22 23:52:10 +05:30
|
|
|
*/
|
2001-03-10 02:54:12 +05:30
|
|
|
static void parse_inittab(void)
|
2000-01-04 06:40:25 +05:30
|
|
|
{
|
2007-01-03 08:26:00 +05:30
|
|
|
#if ENABLE_FEATURE_USE_INITTAB
|
2000-02-09 01:28:47 +05:30
|
|
|
FILE *file;
|
2003-01-14 03:39:50 +05:30
|
|
|
char buf[INIT_BUFFS_SIZE], lineAsRead[INIT_BUFFS_SIZE];
|
2007-02-21 05:45:20 +05:30
|
|
|
char tmpConsole[CONSOLE_NAME_SIZE];
|
2002-03-05 20:42:19 +05:30
|
|
|
char *id, *runlev, *action, *command, *eol;
|
|
|
|
const struct init_action_type *a = actions;
|
2000-01-04 06:40:25 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
file = fopen(INITTAB, "r");
|
|
|
|
if (file == NULL) {
|
|
|
|
/* No inittab file -- set up some default behavior */
|
2000-01-06 06:46:13 +05:30
|
|
|
#endif
|
2001-04-03 23:31:51 +05:30
|
|
|
/* Reboot on Ctrl-Alt-Del */
|
2007-01-21 06:11:04 +05:30
|
|
|
new_init_action(CTRLALTDEL, "reboot", "");
|
2001-09-06 01:48:15 +05:30
|
|
|
/* Umount all filesystems on halt/reboot */
|
2007-01-21 06:11:04 +05:30
|
|
|
new_init_action(SHUTDOWN, "umount -a -r", "");
|
2001-09-06 01:48:15 +05:30
|
|
|
/* Swapoff on halt/reboot */
|
2007-02-16 22:47:07 +05:30
|
|
|
if (ENABLE_SWAPONOFF) new_init_action(SHUTDOWN, "swapoff -a", "");
|
2001-12-18 04:43:08 +05:30
|
|
|
/* Prepare to restart init when a HUP is received */
|
2007-01-21 06:11:04 +05:30
|
|
|
new_init_action(RESTART, "init", "");
|
2002-07-29 12:09:58 +05:30
|
|
|
/* Askfirst shell on tty1-4 */
|
2003-09-02 08:06:18 +05:30
|
|
|
new_init_action(ASKFIRST, bb_default_login_shell, "");
|
|
|
|
new_init_action(ASKFIRST, bb_default_login_shell, VC_2);
|
|
|
|
new_init_action(ASKFIRST, bb_default_login_shell, VC_3);
|
|
|
|
new_init_action(ASKFIRST, bb_default_login_shell, VC_4);
|
2000-02-09 01:28:47 +05:30
|
|
|
/* sysinit */
|
2003-01-14 03:39:50 +05:30
|
|
|
new_init_action(SYSINIT, INIT_SCRIPT, "");
|
2000-02-09 01:28:47 +05:30
|
|
|
|
|
|
|
return;
|
2007-01-03 08:26:00 +05:30
|
|
|
#if ENABLE_FEATURE_USE_INITTAB
|
2000-01-06 06:46:13 +05:30
|
|
|
}
|
2000-01-04 06:40:25 +05:30
|
|
|
|
2002-07-04 05:20:16 +05:30
|
|
|
while (fgets(buf, INIT_BUFFS_SIZE, file) != NULL) {
|
2000-06-01 01:34:38 +05:30
|
|
|
/* Skip leading spaces */
|
|
|
|
for (id = buf; *id == ' ' || *id == '\t'; id++);
|
|
|
|
|
|
|
|
/* Skip the line if it's a comment */
|
|
|
|
if (*id == '#' || *id == '\n')
|
2000-02-09 01:28:47 +05:30
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Trim the trailing \n */
|
2007-02-16 22:47:07 +05:30
|
|
|
//XXX: chomp() ?
|
2000-06-01 01:34:38 +05:30
|
|
|
eol = strrchr(id, '\n');
|
|
|
|
if (eol != NULL)
|
|
|
|
*eol = '\0';
|
2000-02-09 01:28:47 +05:30
|
|
|
|
|
|
|
/* Keep a copy around for posterity's sake (and error msgs) */
|
|
|
|
strcpy(lineAsRead, buf);
|
|
|
|
|
2000-06-01 01:34:38 +05:30
|
|
|
/* Separate the ID field from the runlevels */
|
|
|
|
runlev = strchr(id, ':');
|
|
|
|
if (runlev == NULL || *(runlev + 1) == '\0') {
|
2007-02-17 21:22:02 +05:30
|
|
|
message(L_LOG | L_CONSOLE, "Bad inittab entry: %s", lineAsRead);
|
2000-06-01 01:34:38 +05:30
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
*runlev = '\0';
|
|
|
|
++runlev;
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
2000-01-04 06:40:25 +05:30
|
|
|
|
2000-06-01 01:34:38 +05:30
|
|
|
/* Separate the runlevels from the action */
|
|
|
|
action = strchr(runlev, ':');
|
|
|
|
if (action == NULL || *(action + 1) == '\0') {
|
2007-02-17 21:22:02 +05:30
|
|
|
message(L_LOG | L_CONSOLE, "Bad inittab entry: %s", lineAsRead);
|
2000-02-09 01:28:47 +05:30
|
|
|
continue;
|
|
|
|
} else {
|
2000-06-01 01:34:38 +05:30
|
|
|
*action = '\0';
|
|
|
|
++action;
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
2000-01-04 06:40:25 +05:30
|
|
|
|
2002-03-05 20:42:19 +05:30
|
|
|
/* Separate the action from the command */
|
|
|
|
command = strchr(action, ':');
|
|
|
|
if (command == NULL || *(command + 1) == '\0') {
|
2007-02-17 21:22:02 +05:30
|
|
|
message(L_LOG | L_CONSOLE, "Bad inittab entry: %s", lineAsRead);
|
2000-02-09 01:28:47 +05:30
|
|
|
continue;
|
|
|
|
} else {
|
2002-03-05 20:42:19 +05:30
|
|
|
*command = '\0';
|
|
|
|
++command;
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
/* Ok, now process it */
|
2003-01-14 03:39:50 +05:30
|
|
|
for (a = actions; a->name != 0; a++) {
|
2000-06-01 01:34:38 +05:30
|
|
|
if (strcmp(a->name, action) == 0) {
|
|
|
|
if (*id != '\0') {
|
2007-04-12 06:02:05 +05:30
|
|
|
if (strncmp(id, "/dev/", 5) == 0)
|
2003-01-14 03:39:50 +05:30
|
|
|
id += 5;
|
2000-02-09 01:28:47 +05:30
|
|
|
strcpy(tmpConsole, "/dev/");
|
2003-01-14 03:39:50 +05:30
|
|
|
safe_strncpy(tmpConsole + 5, id,
|
2007-02-21 05:45:20 +05:30
|
|
|
sizeof(tmpConsole) - 5);
|
2000-06-01 01:34:38 +05:30
|
|
|
id = tmpConsole;
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
2002-03-05 20:42:19 +05:30
|
|
|
new_init_action(a->action, command, id);
|
2003-01-14 03:39:50 +05:30
|
|
|
break;
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
|
|
|
}
|
2003-01-14 03:39:50 +05:30
|
|
|
if (a->name == 0) {
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Choke on an unknown action */
|
2007-02-17 21:22:02 +05:30
|
|
|
message(L_LOG | L_CONSOLE, "Bad inittab entry: %s", lineAsRead);
|
2000-01-07 08:24:55 +05:30
|
|
|
}
|
2000-01-04 06:40:25 +05:30
|
|
|
}
|
2002-05-16 03:49:09 +05:30
|
|
|
fclose(file);
|
2007-01-03 08:26:00 +05:30
|
|
|
#endif /* FEATURE_USE_INITTAB */
|
2000-01-04 06:40:25 +05:30
|
|
|
}
|
|
|
|
|
2007-01-03 08:26:00 +05:30
|
|
|
#if ENABLE_FEATURE_USE_INITTAB
|
2006-02-01 20:17:52 +05:30
|
|
|
static void reload_signal(int sig ATTRIBUTE_UNUSED)
|
2003-07-22 15:18:56 +05:30
|
|
|
{
|
2004-10-08 13:51:54 +05:30
|
|
|
struct init_action *a, *tmp;
|
|
|
|
|
2007-02-21 05:45:20 +05:30
|
|
|
message(L_LOG, "reloading /etc/inittab");
|
2004-10-08 13:51:54 +05:30
|
|
|
|
|
|
|
/* disable old entrys */
|
|
|
|
for (a = init_action_list; a; a = a->next ) {
|
|
|
|
a->action = ONCE;
|
|
|
|
}
|
|
|
|
|
|
|
|
parse_inittab();
|
|
|
|
|
|
|
|
/* remove unused entrys */
|
|
|
|
for (a = init_action_list; a; a = tmp) {
|
|
|
|
tmp = a->next;
|
2007-03-24 21:10:16 +05:30
|
|
|
if ((a->action & (ONCE | SYSINIT | WAIT)) && a->pid == 0) {
|
2004-10-08 13:51:54 +05:30
|
|
|
delete_init_action(a);
|
|
|
|
}
|
|
|
|
}
|
2003-07-22 15:18:56 +05:30
|
|
|
run_actions(RESPAWN);
|
|
|
|
}
|
2007-01-03 08:26:00 +05:30
|
|
|
#endif /* FEATURE_USE_INITTAB */
|
2004-10-08 13:51:54 +05:30
|
|
|
|
2007-02-03 22:58:39 +05:30
|
|
|
int init_main(int argc, char **argv);
|
2006-03-07 02:17:33 +05:30
|
|
|
int init_main(int argc, char **argv)
|
1999-10-05 21:54:54 +05:30
|
|
|
{
|
2002-03-05 20:42:19 +05:30
|
|
|
struct init_action *a;
|
2000-02-09 01:28:47 +05:30
|
|
|
pid_t wpid;
|
1999-10-26 05:02:44 +05:30
|
|
|
|
2007-01-03 08:26:00 +05:30
|
|
|
die_sleep = 30 * 24*60*60; /* if xmalloc will ever die... */
|
|
|
|
|
2001-12-18 04:43:08 +05:30
|
|
|
if (argc > 1 && !strcmp(argv[1], "-q")) {
|
2007-02-21 05:45:20 +05:30
|
|
|
return kill(1, SIGHUP);
|
2001-12-18 04:43:08 +05:30
|
|
|
}
|
2006-05-29 18:38:35 +05:30
|
|
|
#if !ENABLE_DEBUG_INIT
|
2000-02-24 23:39:58 +05:30
|
|
|
/* Expect to be invoked as init with PID=1 or be invoked as linuxrc */
|
2007-02-21 05:45:20 +05:30
|
|
|
if (getpid() != 1
|
|
|
|
&& (!ENABLE_FEATURE_INITRD || !strstr(applet_name, "linuxrc"))
|
|
|
|
) {
|
2003-03-19 14:43:01 +05:30
|
|
|
bb_show_usage();
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
|
|
|
/* Set up sig handlers -- be sure to
|
|
|
|
* clear all of these in run() */
|
2002-08-22 23:52:10 +05:30
|
|
|
signal(SIGHUP, exec_signal);
|
2005-04-16 13:51:34 +05:30
|
|
|
signal(SIGQUIT, exec_signal);
|
2006-06-01 18:47:49 +05:30
|
|
|
signal(SIGUSR1, shutdown_signal);
|
|
|
|
signal(SIGUSR2, shutdown_signal);
|
2002-08-22 23:52:10 +05:30
|
|
|
signal(SIGINT, ctrlaltdel_signal);
|
2006-06-01 18:47:49 +05:30
|
|
|
signal(SIGTERM, shutdown_signal);
|
2001-12-01 00:40:58 +05:30
|
|
|
signal(SIGCONT, cont_handler);
|
|
|
|
signal(SIGSTOP, stop_handler);
|
|
|
|
signal(SIGTSTP, stop_handler);
|
1999-10-05 21:54:54 +05:30
|
|
|
|
2004-03-15 13:59:22 +05:30
|
|
|
/* Turn off rebooting via CTL-ALT-DEL -- we get a
|
2000-02-09 01:28:47 +05:30
|
|
|
* SIGINT on CAD so we can shut things down gracefully... */
|
2000-04-28 05:48:56 +05:30
|
|
|
init_reboot(RB_DISABLE_CAD);
|
2000-02-09 01:28:47 +05:30
|
|
|
#endif
|
2000-01-13 10:13:48 +05:30
|
|
|
|
2007-06-14 13:23:06 +05:30
|
|
|
|
2002-07-03 16:38:10 +05:30
|
|
|
/* Figure out where the default console should be */
|
|
|
|
console_init();
|
2007-03-06 00:52:04 +05:30
|
|
|
set_sane_term();
|
2000-04-04 23:44:25 +05:30
|
|
|
chdir("/");
|
2000-02-09 01:28:47 +05:30
|
|
|
setsid();
|
2003-01-14 03:39:50 +05:30
|
|
|
{
|
2007-08-13 02:28:27 +05:30
|
|
|
const char *const *e;
|
2003-01-14 03:39:50 +05:30
|
|
|
/* Make sure environs is set to something sane */
|
2006-12-26 16:12:51 +05:30
|
|
|
for (e = environment; *e; e++)
|
2003-03-19 14:43:01 +05:30
|
|
|
putenv((char *) *e);
|
2003-01-14 03:39:50 +05:30
|
|
|
}
|
2006-07-09 22:58:17 +05:30
|
|
|
|
|
|
|
if (argc > 1) setenv("RUNLEVEL", argv[1], 1);
|
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Hello world */
|
2007-06-13 17:57:17 +05:30
|
|
|
message(MAYBE_CONSOLE | L_LOG, "init started: %s", bb_banner);
|
2000-02-09 01:28:47 +05:30
|
|
|
|
|
|
|
/* Make sure there is enough memory to do something useful. */
|
2005-08-31 00:20:37 +05:30
|
|
|
if (ENABLE_SWAPONOFF) {
|
|
|
|
struct sysinfo info;
|
|
|
|
|
|
|
|
if (!sysinfo(&info) &&
|
2006-10-27 14:35:02 +05:30
|
|
|
(info.mem_unit ? : 1) * (long long)info.totalram < 1024*1024)
|
2005-08-31 00:20:37 +05:30
|
|
|
{
|
2007-02-21 05:45:20 +05:30
|
|
|
message(L_CONSOLE, "Low memory, forcing swapon");
|
2005-08-31 00:20:37 +05:30
|
|
|
/* swapon -a requires /proc typically */
|
2007-01-21 06:11:04 +05:30
|
|
|
new_init_action(SYSINIT, "mount -t proc proc /proc", "");
|
2005-08-31 00:20:37 +05:30
|
|
|
/* Try to turn on swap */
|
2007-01-21 06:11:04 +05:30
|
|
|
new_init_action(SYSINIT, "swapon -a", "");
|
2005-08-31 00:20:37 +05:30
|
|
|
run_actions(SYSINIT); /* wait and removing */
|
|
|
|
}
|
|
|
|
}
|
2000-02-09 01:28:47 +05:30
|
|
|
|
|
|
|
/* Check if we are supposed to be in single user mode */
|
2006-12-21 18:53:14 +05:30
|
|
|
if (argc > 1
|
|
|
|
&& (!strcmp(argv[1], "single") || !strcmp(argv[1], "-s") || LONE_CHAR(argv[1], '1'))
|
|
|
|
) {
|
2003-01-14 03:39:50 +05:30
|
|
|
/* Start a shell on console */
|
2003-09-02 08:06:18 +05:30
|
|
|
new_init_action(RESPAWN, bb_default_login_shell, "");
|
2000-02-09 01:28:47 +05:30
|
|
|
} else {
|
|
|
|
/* Not in single user mode -- see what inittab says */
|
|
|
|
|
2001-10-24 10:30:29 +05:30
|
|
|
/* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
|
2000-02-09 01:28:47 +05:30
|
|
|
* then parse_inittab() simply adds in some default
|
2004-03-15 13:59:22 +05:30
|
|
|
* actions(i.e., runs INIT_SCRIPT and then starts a pair
|
2000-02-09 01:28:47 +05:30
|
|
|
* of "askfirst" shells */
|
|
|
|
parse_inittab();
|
2000-01-04 06:40:25 +05:30
|
|
|
}
|
2000-04-04 23:44:25 +05:30
|
|
|
|
2007-01-03 08:26:00 +05:30
|
|
|
#if ENABLE_SELINUX
|
2006-03-28 04:39:12 +05:30
|
|
|
if (getenv("SELINUX_INIT") == NULL) {
|
|
|
|
int enforce = 0;
|
|
|
|
|
2007-06-14 13:23:06 +05:30
|
|
|
putenv((char*)"SELINUX_INIT=YES");
|
2006-03-28 04:39:12 +05:30
|
|
|
if (selinux_init_load_policy(&enforce) == 0) {
|
2007-02-03 07:47:41 +05:30
|
|
|
BB_EXECVP(argv[0], argv);
|
2006-03-28 04:39:12 +05:30
|
|
|
} else if (enforce > 0) {
|
|
|
|
/* SELinux in enforcing mode but load_policy failed */
|
|
|
|
/* At this point, we probably can't open /dev/console, so log() won't work */
|
2007-02-28 00:50:00 +05:30
|
|
|
message(L_CONSOLE, "Cannot load SELinux Policy. "
|
|
|
|
"Machine is in enforcing mode. Halting now.");
|
2006-03-28 04:39:12 +05:30
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SELINUX */
|
|
|
|
|
2001-03-20 23:09:08 +05:30
|
|
|
/* Make the command line just say "init" -- thats all, nothing else */
|
2007-06-14 13:23:06 +05:30
|
|
|
fixup_argv(argv);
|
2000-02-09 01:28:47 +05:30
|
|
|
|
|
|
|
/* Now run everything that needs to be run */
|
|
|
|
|
|
|
|
/* First run the sysinit command */
|
2001-09-06 01:48:15 +05:30
|
|
|
run_actions(SYSINIT);
|
2002-03-05 20:42:19 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Next run anything that wants to block */
|
2001-09-06 01:48:15 +05:30
|
|
|
run_actions(WAIT);
|
2002-03-05 20:42:19 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Next run anything to be run only once */
|
2002-03-05 20:42:19 +05:30
|
|
|
run_actions(ONCE);
|
|
|
|
|
2007-01-03 08:26:00 +05:30
|
|
|
#if ENABLE_FEATURE_USE_INITTAB
|
2003-07-22 15:18:56 +05:30
|
|
|
/* Redefine SIGHUP to reread /etc/inittab */
|
|
|
|
signal(SIGHUP, reload_signal);
|
2004-10-08 13:51:54 +05:30
|
|
|
#else
|
|
|
|
signal(SIGHUP, SIG_IGN);
|
2007-01-03 08:26:00 +05:30
|
|
|
#endif /* FEATURE_USE_INITTAB */
|
2004-10-08 13:51:54 +05:30
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Now run the looping stuff for the rest of forever */
|
|
|
|
while (1) {
|
2002-03-05 20:42:19 +05:30
|
|
|
/* 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);
|
|
|
|
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Wait for a child process to exit */
|
2006-05-30 17:46:54 +05:30
|
|
|
wpid = wait(NULL);
|
2004-04-13 00:51:54 +05:30
|
|
|
while (wpid > 0) {
|
2000-02-09 01:28:47 +05:30
|
|
|
/* Find out who died and clean up their corpse */
|
2002-03-05 20:42:19 +05:30
|
|
|
for (a = init_action_list; a; a = a->next) {
|
2000-02-09 01:28:47 +05:30
|
|
|
if (a->pid == wpid) {
|
2002-03-05 20:42:19 +05:30
|
|
|
/* Set the pid to 0 so that the process gets
|
|
|
|
* restarted by run_actions() */
|
2000-02-09 01:28:47 +05:30
|
|
|
a->pid = 0;
|
2007-02-21 05:45:20 +05:30
|
|
|
message(L_LOG, "process '%s' (pid %d) exited. "
|
2003-01-14 03:39:50 +05:30
|
|
|
"Scheduling it for restart.",
|
|
|
|
a->command, wpid);
|
2000-02-09 01:28:47 +05:30
|
|
|
}
|
|
|
|
}
|
2002-12-17 15:18:16 +05:30
|
|
|
/* see if anyone else is waiting to be reaped */
|
2006-09-28 05:01:08 +05:30
|
|
|
wpid = waitpid(-1, NULL, WNOHANG);
|
2000-01-04 06:40:25 +05:30
|
|
|
}
|
1999-10-26 05:48:56 +05:30
|
|
|
}
|
1999-12-30 14:55:17 +05:30
|
|
|
}
|