[T106][ZXW-22]7520V3SCV2.01.01.02P42U09_VEC_V0.8_AP_VEC origin source commit
Change-Id: Ic6e05d89ecd62fc34f82b23dcf306c93764aec4b
diff --git a/ap/app/busybox/src/init/Config.src b/ap/app/busybox/src/init/Config.src
new file mode 100644
index 0000000..5767c93
--- /dev/null
+++ b/ap/app/busybox/src/init/Config.src
@@ -0,0 +1,10 @@
+#
+# For a description of the syntax of this configuration file,
+# see scripts/kbuild/config-language.txt.
+#
+
+menu "Init Utilities"
+
+INSERT
+
+endmenu
diff --git a/ap/app/busybox/src/init/Kbuild.src b/ap/app/busybox/src/init/Kbuild.src
new file mode 100644
index 0000000..6b4fb74
--- /dev/null
+++ b/ap/app/busybox/src/init/Kbuild.src
@@ -0,0 +1,9 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2005 by Erik Andersen <andersen@codepoet.org>
+#
+# Licensed under GPLv2, see file LICENSE in this source tree.
+
+lib-y:=
+
+INSERT
diff --git a/ap/app/busybox/src/init/bootchartd.c b/ap/app/busybox/src/init/bootchartd.c
new file mode 100644
index 0000000..9fd6233
--- /dev/null
+++ b/ap/app/busybox/src/init/bootchartd.c
@@ -0,0 +1,462 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+
+//applet:IF_BOOTCHARTD(APPLET(bootchartd, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_BOOTCHARTD) += bootchartd.o
+
+//config:config BOOTCHARTD
+//config: bool "bootchartd"
+//config: default y
+//config: help
+//config: bootchartd is commonly used to profile the boot process
+//config: for the purpose of speeding it up. In this case, it is started
+//config: by the kernel as the init process. This is configured by adding
+//config: the init=/sbin/bootchartd option to the kernel command line.
+//config:
+//config: It can also be used to monitor the resource usage of a specific
+//config: application or the running system in general. In this case,
+//config: bootchartd is started interactively by running bootchartd start
+//config: and stopped using bootchartd stop.
+//config:
+//config:config FEATURE_BOOTCHARTD_BLOATED_HEADER
+//config: bool "Compatible, bloated header"
+//config: default y
+//config: depends on BOOTCHARTD
+//config: help
+//config: Create extended header file compatible with "big" bootchartd.
+//config: "Big" bootchartd is a shell script and it dumps some
+//config: "convenient" info int the header, such as:
+//config: title = Boot chart for `hostname` (`date`)
+//config: system.uname = `uname -srvm`
+//config: system.release = `cat /etc/DISTRO-release`
+//config: system.cpu = `grep '^model name' /proc/cpuinfo | head -1` ($cpucount)
+//config: system.kernel.options = `cat /proc/cmdline`
+//config: This data is not mandatory for bootchart graph generation,
+//config: and is considered bloat. Nevertheless, this option
+//config: makes bootchartd applet to dump a subset of it.
+//config:
+//config:config FEATURE_BOOTCHARTD_CONFIG_FILE
+//config: bool "Support bootchartd.conf"
+//config: default y
+//config: depends on BOOTCHARTD
+//config: help
+//config: Enable reading and parsing of $PWD/bootchartd.conf
+//config: and /etc/bootchartd.conf files.
+
+#include "libbb.h"
+/* After libbb.h, since it needs sys/types.h on some systems */
+#include <sys/utsname.h>
+
+#ifdef __linux__
+# include <sys/mount.h>
+# ifndef MS_SILENT
+# define MS_SILENT (1 << 15)
+# endif
+# ifndef MNT_DETACH
+# define MNT_DETACH 0x00000002
+# endif
+#endif
+
+#define BC_VERSION_STR "0.8"
+
+/* For debugging, set to 0:
+ * strace won't work with DO_SIGNAL_SYNC set to 1.
+ */
+#define DO_SIGNAL_SYNC 1
+
+
+//$PWD/bootchartd.conf and /etc/bootchartd.conf:
+//supported options:
+//# Sampling period (in seconds)
+//SAMPLE_PERIOD=0.2
+//
+//not yet supported:
+//# tmpfs size
+//# (32 MB should suffice for ~20 minutes worth of log data, but YMMV)
+//TMPFS_SIZE=32m
+//
+//# Whether to enable and store BSD process accounting information. The
+//# kernel needs to be configured to enable v3 accounting
+//# (CONFIG_BSD_PROCESS_ACCT_V3). accton from the GNU accounting utilities
+//# is also required.
+//PROCESS_ACCOUNTING="no"
+//
+//# Tarball for the various boot log files
+//BOOTLOG_DEST=/var/log/bootchart.tgz
+//
+//# Whether to automatically stop logging as the boot process completes.
+//# The logger will look for known processes that indicate bootup completion
+//# at a specific runlevel (e.g. gdm-binary, mingetty, etc.).
+//AUTO_STOP_LOGGER="yes"
+//
+//# Whether to automatically generate the boot chart once the boot logger
+//# completes. The boot chart will be generated in $AUTO_RENDER_DIR.
+//# Note that the bootchart package must be installed.
+//AUTO_RENDER="no"
+//
+//# Image format to use for the auto-generated boot chart
+//# (choose between png, svg and eps).
+//AUTO_RENDER_FORMAT="png"
+//
+//# Output directory for auto-generated boot charts
+//AUTO_RENDER_DIR="/var/log"
+
+
+/* Globals */
+struct globals {
+ char jiffy_line[COMMON_BUFSIZE];
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define INIT_G() do { } while (0)
+
+static void dump_file(FILE *fp, const char *filename)
+{
+ int fd = open(filename, O_RDONLY);
+ if (fd >= 0) {
+ fputs(G.jiffy_line, fp);
+ fflush(fp);
+ bb_copyfd_eof(fd, fileno(fp));
+ close(fd);
+ fputc('\n', fp);
+ }
+}
+
+static int dump_procs(FILE *fp, int look_for_login_process)
+{
+ struct dirent *entry;
+ DIR *dir = opendir("/proc");
+ int found_login_process = 0;
+
+ fputs(G.jiffy_line, fp);
+ while ((entry = readdir(dir)) != NULL) {
+ char name[sizeof("/proc/%u/cmdline") + sizeof(int)*3];
+ int stat_fd;
+ unsigned pid = bb_strtou(entry->d_name, NULL, 10);
+ if (errno)
+ continue;
+
+ /* Android's version reads /proc/PID/cmdline and extracts
+ * non-truncated process name. Do we want to do that? */
+
+ sprintf(name, "/proc/%u/stat", pid);
+ stat_fd = open(name, O_RDONLY);
+ if (stat_fd >= 0) {
+ char *p;
+ char stat_line[4*1024];
+ int rd = safe_read(stat_fd, stat_line, sizeof(stat_line)-2);
+
+ close(stat_fd);
+ if (rd < 0)
+ continue;
+ stat_line[rd] = '\0';
+ p = strchrnul(stat_line, '\n');
+ *p++ = '\n';
+ *p = '\0';
+ fputs(stat_line, fp);
+ if (!look_for_login_process)
+ continue;
+ p = strchr(stat_line, '(');
+ if (!p)
+ continue;
+ p++;
+ strchrnul(p, ')')[0] = '\0';
+ /* Is it gdm, kdm or a getty? */
+ if (((p[0] == 'g' || p[0] == 'k' || p[0] == 'x') && p[1] == 'd' && p[2] == 'm')
+ || strstr(p, "getty")
+ ) {
+ found_login_process = 1;
+ }
+ }
+ }
+ closedir(dir);
+ fputc('\n', fp);
+ return found_login_process;
+}
+
+static char *make_tempdir(void)
+{
+ char template[] = "/tmp/bootchart.XXXXXX";
+ char *tempdir = xstrdup(mkdtemp(template));
+ if (!tempdir) {
+#ifdef __linux__
+ /* /tmp is not writable (happens when we are used as init).
+ * Try to mount a tmpfs, them cd and lazily unmount it.
+ * Since we unmount it at once, we can mount it anywhere.
+ * Try a few locations which are likely ti exist.
+ */
+ static const char dirs[] = "/mnt\0""/tmp\0""/boot\0""/proc\0";
+ const char *try_dir = dirs;
+ while (mount("none", try_dir, "tmpfs", MS_SILENT, "size=16m") != 0) {
+ try_dir += strlen(try_dir) + 1;
+ if (!try_dir[0])
+ bb_perror_msg_and_die("can't %smount tmpfs", "");
+ }
+ //bb_error_msg("mounted tmpfs on %s", try_dir);
+ xchdir(try_dir);
+ if (umount2(try_dir, MNT_DETACH) != 0) {
+ bb_perror_msg_and_die("can't %smount tmpfs", "un");
+ }
+#else
+ bb_perror_msg_and_die("can't create temporary directory");
+#endif
+ } else {
+ xchdir(tempdir);
+ }
+ return tempdir;
+}
+
+static void do_logging(unsigned sample_period_us, int process_accounting)
+{
+ FILE *proc_stat = xfopen("proc_stat.log", "w");
+ FILE *proc_diskstats = xfopen("proc_diskstats.log", "w");
+ //FILE *proc_netdev = xfopen("proc_netdev.log", "w");
+ FILE *proc_ps = xfopen("proc_ps.log", "w");
+ int look_for_login_process = (getppid() == 1);
+ unsigned count = 60*1000*1000 / sample_period_us; /* ~1 minute */
+
+ if (process_accounting) {
+ close(xopen("kernel_pacct", O_WRONLY | O_CREAT | O_TRUNC));
+ acct("kernel_pacct");
+ }
+
+ while (--count && !bb_got_signal) {
+ char *p;
+ int len = open_read_close("/proc/uptime", G.jiffy_line, sizeof(G.jiffy_line)-2);
+ if (len < 0)
+ goto wait_more;
+ /* /proc/uptime has format "NNNNNN.MM NNNNNNN.MM" */
+ /* we convert it to "NNNNNNMM\n" (using first value) */
+ G.jiffy_line[len] = '\0';
+ p = strchr(G.jiffy_line, '.');
+ if (!p)
+ goto wait_more;
+ while (isdigit(*++p))
+ p[-1] = *p;
+ p[-1] = '\n';
+ p[0] = '\0';
+
+ dump_file(proc_stat, "/proc/stat");
+ dump_file(proc_diskstats, "/proc/diskstats");
+ //dump_file(proc_netdev, "/proc/net/dev");
+ if (dump_procs(proc_ps, look_for_login_process)) {
+ /* dump_procs saw a getty or {g,k,x}dm
+ * stop logging in 2 seconds:
+ */
+ if (count > 2*1000*1000 / sample_period_us)
+ count = 2*1000*1000 / sample_period_us;
+ }
+ fflush_all();
+ wait_more:
+ usleep(sample_period_us);
+ }
+}
+
+static void finalize(char *tempdir, const char *prog, int process_accounting)
+{
+ //# Stop process accounting if configured
+ //local pacct=
+ //[ -e kernel_pacct ] && pacct=kernel_pacct
+
+ FILE *header_fp = xfopen("header", "w");
+
+ if (process_accounting)
+ acct(NULL);
+
+ if (prog)
+ fprintf(header_fp, "profile.process = %s\n", prog);
+
+ fputs("version = "BC_VERSION_STR"\n", header_fp);
+ if (ENABLE_FEATURE_BOOTCHARTD_BLOATED_HEADER) {
+ char *hostname;
+ char *kcmdline;
+ time_t t;
+ struct tm tm_time;
+ /* x2 for possible localized weekday/month names */
+ char date_buf[sizeof("Mon Jun 21 05:29:03 CEST 2010") * 2];
+ struct utsname unamebuf;
+
+ hostname = safe_gethostname();
+ time(&t);
+ localtime_r(&t, &tm_time);
+ strftime(date_buf, sizeof(date_buf), "%a %b %e %H:%M:%S %Z %Y", &tm_time);
+ fprintf(header_fp, "title = Boot chart for %s (%s)\n", hostname, date_buf);
+ if (ENABLE_FEATURE_CLEAN_UP)
+ free(hostname);
+
+ uname(&unamebuf); /* never fails */
+ /* same as uname -srvm */
+ fprintf(header_fp, "system.uname = %s %s %s %s\n",
+ unamebuf.sysname,
+ unamebuf.release,
+ unamebuf.version,
+ unamebuf.machine
+ );
+
+ //system.release = `cat /etc/DISTRO-release`
+ //system.cpu = `grep '^model name' /proc/cpuinfo | head -1` ($cpucount)
+
+ kcmdline = xmalloc_open_read_close("/proc/cmdline", NULL);
+ /* kcmdline includes trailing "\n" */
+ fprintf(header_fp, "system.kernel.options = %s", kcmdline);
+ if (ENABLE_FEATURE_CLEAN_UP)
+ free(kcmdline);
+ }
+ fclose(header_fp);
+
+ /* Package log files */
+ system(xasprintf("tar -zcf /var/log/bootlog.tgz header %s *.log", process_accounting ? "kernel_pacct" : ""));
+ /* Clean up (if we are not in detached tmpfs) */
+ if (tempdir) {
+ unlink("header");
+ unlink("proc_stat.log");
+ unlink("proc_diskstats.log");
+ //unlink("proc_netdev.log");
+ unlink("proc_ps.log");
+ if (process_accounting)
+ unlink("kernel_pacct");
+ rmdir(tempdir);
+ }
+
+ /* shell-based bootchartd tries to run /usr/bin/bootchart if $AUTO_RENDER=yes:
+ * /usr/bin/bootchart -o "$AUTO_RENDER_DIR" -f $AUTO_RENDER_FORMAT "$BOOTLOG_DEST"
+ */
+}
+
+//usage:#define bootchartd_trivial_usage
+//usage: "start [PROG ARGS]|stop|init"
+//usage:#define bootchartd_full_usage "\n\n"
+//usage: "Create /var/log/bootchart.tgz with boot chart data\n"
+//usage: "\nstart: start background logging; with PROG, run PROG, then kill logging with USR1"
+//usage: "\nstop: send USR1 to all bootchartd processes"
+//usage: "\ninit: start background logging; stop when getty/xdm is seen (for init scripts)"
+//usage: "\nUnder PID 1: as init, then exec $bootchart_init, /init, /sbin/init"
+
+int bootchartd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int bootchartd_main(int argc UNUSED_PARAM, char **argv)
+{
+ unsigned sample_period_us;
+ pid_t parent_pid, logger_pid;
+ smallint cmd;
+ int process_accounting;
+ enum {
+ CMD_STOP = 0,
+ CMD_START,
+ CMD_INIT,
+ CMD_PID1, /* used to mark pid 1 case */
+ };
+
+ INIT_G();
+
+ parent_pid = getpid();
+ if (argv[1]) {
+ cmd = index_in_strings("stop\0""start\0""init\0", argv[1]);
+ if (cmd < 0)
+ bb_show_usage();
+ if (cmd == CMD_STOP) {
+ pid_t *pidList = find_pid_by_name("bootchartd");
+ while (*pidList != 0) {
+ if (*pidList != parent_pid)
+ kill(*pidList, SIGUSR1);
+ pidList++;
+ }
+ return EXIT_SUCCESS;
+ }
+ } else {
+ if (parent_pid != 1)
+ bb_show_usage();
+ cmd = CMD_PID1;
+ }
+
+ /* Here we are in START, INIT or CMD_PID1 state */
+
+ /* Read config file: */
+ sample_period_us = 200 * 1000;
+ process_accounting = 0;
+ if (ENABLE_FEATURE_BOOTCHARTD_CONFIG_FILE) {
+ char* token[2];
+ parser_t *parser = config_open2("/etc/bootchartd.conf" + 5, fopen_for_read);
+ if (!parser)
+ parser = config_open2("/etc/bootchartd.conf", fopen_for_read);
+ while (config_read(parser, token, 2, 0, "#=", PARSE_NORMAL & ~PARSE_COLLAPSE)) {
+ if (strcmp(token[0], "SAMPLE_PERIOD") == 0 && token[1])
+ sample_period_us = atof(token[1]) * 1000000;
+ if (strcmp(token[0], "PROCESS_ACCOUNTING") == 0 && token[1]
+ && (strcmp(token[1], "on") == 0 || strcmp(token[1], "yes") == 0)
+ ) {
+ process_accounting = 1;
+ }
+ }
+ config_close(parser);
+ if ((int)sample_period_us <= 0)
+ sample_period_us = 1; /* prevent division by 0 */
+ }
+
+ /* Create logger child: */
+ logger_pid = fork_or_rexec(argv);
+
+ if (logger_pid == 0) { /* child */
+ char *tempdir;
+
+ bb_signals(0
+ + (1 << SIGUSR1)
+ + (1 << SIGUSR2)
+ + (1 << SIGTERM)
+ + (1 << SIGQUIT)
+ + (1 << SIGINT)
+ + (1 << SIGHUP)
+ , record_signo);
+
+ if (DO_SIGNAL_SYNC)
+ /* Inform parent that we are ready */
+ raise(SIGSTOP);
+
+ /* If we are started by kernel, PATH might be unset.
+ * In order to find "tar", let's set some sane PATH:
+ */
+ if (cmd == CMD_PID1 && !getenv("PATH"))
+ putenv((char*)bb_PATH_root_path);
+
+ tempdir = make_tempdir();
+ do_logging(sample_period_us, process_accounting);
+ finalize(tempdir, cmd == CMD_START ? argv[2] : NULL, process_accounting);
+ return EXIT_SUCCESS;
+ }
+
+ /* parent */
+
+ USE_FOR_NOMMU(argv[0][0] &= 0x7f); /* undo fork_or_rexec() damage */
+
+ if (DO_SIGNAL_SYNC) {
+ /* Wait for logger child to set handlers, then unpause it.
+ * Otherwise with short-lived PROG (e.g. "bootchartd start true")
+ * we might send SIGUSR1 before logger sets its handler.
+ */
+ waitpid(logger_pid, NULL, WUNTRACED);
+ kill(logger_pid, SIGCONT);
+ }
+
+ if (cmd == CMD_PID1) {
+ char *bootchart_init = getenv("bootchart_init");
+ if (bootchart_init)
+ execl(bootchart_init, bootchart_init, NULL);
+ execl("/init", "init", NULL);
+ execl("/sbin/init", "init", NULL);
+ bb_perror_msg_and_die("can't execute '%s'", "/sbin/init");
+ }
+
+ if (cmd == CMD_START && argv[2]) { /* "start PROG ARGS" */
+ pid_t pid = xvfork();
+ if (pid == 0) { /* child */
+ argv += 2;
+ BB_EXECVP_or_die(argv);
+ }
+ /* parent */
+ waitpid(pid, NULL, 0);
+ kill(logger_pid, SIGUSR1);
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/ap/app/busybox/src/init/halt.c b/ap/app/busybox/src/init/halt.c
new file mode 100644
index 0000000..7974adb
--- /dev/null
+++ b/ap/app/busybox/src/init/halt.c
@@ -0,0 +1,173 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Poweroff reboot and halt, oh my.
+ *
+ * Copyright 2006 by Rob Landley <rob@landley.net>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+
+//applet:IF_HALT(APPLET(halt, BB_DIR_SBIN, BB_SUID_DROP))
+//applet:IF_HALT(APPLET_ODDNAME(poweroff, halt, BB_DIR_SBIN, BB_SUID_DROP, poweroff))
+//applet:IF_HALT(APPLET_ODDNAME(reboot, halt, BB_DIR_SBIN, BB_SUID_DROP, reboot))
+
+//kbuild:lib-$(CONFIG_HALT) += halt.o
+
+//config:config HALT
+//config: bool "poweroff, halt, and reboot"
+//config: default y
+//config: help
+//config: Stop all processes and either halt, reboot, or power off the system.
+//config:
+//config:config FEATURE_CALL_TELINIT
+//config: bool "Call telinit on shutdown and reboot"
+//config: default y
+//config: depends on HALT && !INIT
+//config: help
+//config: Call an external program (normally telinit) to facilitate
+//config: a switch to a proper runlevel.
+//config:
+//config: This option is only available if you selected halt and friends,
+//config: but did not select init.
+//config:
+//config:config TELINIT_PATH
+//config: string "Path to telinit executable"
+//config: default "/sbin/telinit"
+//config: depends on FEATURE_CALL_TELINIT
+//config: help
+//config: When busybox halt and friends have to call external telinit
+//config: to facilitate proper shutdown, this path is to be used when
+//config: locating telinit executable.
+
+//usage:#define halt_trivial_usage
+//usage: "[-d DELAY] [-n] [-f]" IF_FEATURE_WTMP(" [-w]")
+//usage:#define halt_full_usage "\n\n"
+//usage: "Halt the system\n"
+//usage: "\n -d SEC Delay interval"
+//usage: "\n -n Do not sync"
+//usage: "\n -f Force (don't go through init)"
+//usage: IF_FEATURE_WTMP(
+//usage: "\n -w Only write a wtmp record"
+//usage: )
+//usage:
+//usage:#define poweroff_trivial_usage
+//usage: "[-d DELAY] [-n] [-f]"
+//usage:#define poweroff_full_usage "\n\n"
+//usage: "Halt and shut off power\n"
+//usage: "\n -d SEC Delay interval"
+//usage: "\n -n Do not sync"
+//usage: "\n -f Force (don't go through init)"
+//usage:
+//usage:#define reboot_trivial_usage
+//usage: "[-d DELAY] [-n] [-f]"
+//usage:#define reboot_full_usage "\n\n"
+//usage: "Reboot the system\n"
+//usage: "\n -d SEC Delay interval"
+//usage: "\n -n Do not sync"
+//usage: "\n -f Force (don't go through init)"
+
+#include "libbb.h"
+#include "reboot.h"
+
+#if ENABLE_FEATURE_WTMP
+#include <sys/utsname.h>
+
+static void write_wtmp(void)
+{
+ struct utmp utmp;
+ struct utsname uts;
+ /* "man utmp" says wtmp file should *not* be created automagically */
+ /*if (access(bb_path_wtmp_file, R_OK|W_OK) == -1) {
+ close(creat(bb_path_wtmp_file, 0664));
+ }*/
+ memset(&utmp, 0, sizeof(utmp));
+ utmp.ut_tv.tv_sec = time(NULL);
+ strcpy(utmp.ut_user, "shutdown"); /* it is wide enough */
+ utmp.ut_type = RUN_LVL;
+ utmp.ut_id[0] = '~'; utmp.ut_id[1] = '~'; /* = strcpy(utmp.ut_id, "~~"); */
+ utmp.ut_line[0] = '~'; utmp.ut_line[1] = '~'; /* = strcpy(utmp.ut_line, "~~"); */
+ uname(&uts);
+ safe_strncpy(utmp.ut_host, uts.release, sizeof(utmp.ut_host));
+ updwtmp(bb_path_wtmp_file, &utmp);
+}
+#else
+#define write_wtmp() ((void)0)
+#endif
+
+
+int halt_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int halt_main(int argc UNUSED_PARAM, char **argv)
+{
+ static const int magic[] = {
+ RB_HALT_SYSTEM,
+ RB_POWER_OFF,
+ RB_AUTOBOOT
+ };
+ static const smallint signals[] = { SIGUSR1, SIGUSR2, SIGTERM };
+
+ int delay = 0;
+ int which, flags, rc;
+
+ /* Figure out which applet we're running */
+ for (which = 0; "hpr"[which] != applet_name[0]; which++)
+ continue;
+
+ /* Parse and handle arguments */
+ opt_complementary = "d+"; /* -d N */
+ /* We support -w even if !ENABLE_FEATURE_WTMP,
+ * in order to not break scripts.
+ * -i (shut down network interfaces) is ignored.
+ */
+ flags = getopt32(argv, "d:nfwi", &delay);
+
+ sleep(delay);
+
+ write_wtmp();
+
+ if (flags & 8) /* -w */
+ return EXIT_SUCCESS;
+
+ if (!(flags & 2)) /* no -n */
+ sync();
+
+ /* Perform action. */
+ rc = 1;
+ if (!(flags & 4)) { /* no -f */
+//TODO: I tend to think that signalling linuxrc is wrong
+// pity original author didn't comment on it...
+ if (ENABLE_FEATURE_INITRD) {
+ /* talk to linuxrc */
+ /* bbox init/linuxrc assumed */
+ pid_t *pidlist = find_pid_by_name("linuxrc");
+ if (pidlist[0] > 0)
+ rc = kill(pidlist[0], signals[which]);
+ if (ENABLE_FEATURE_CLEAN_UP)
+ free(pidlist);
+ }
+ if (rc) {
+ /* talk to init */
+ if (!ENABLE_FEATURE_CALL_TELINIT) {
+ /* bbox init assumed */
+ rc = kill(1, signals[which]);
+ } else {
+ /* SysV style init assumed */
+ /* runlevels:
+ * 0 == shutdown
+ * 6 == reboot */
+ execlp(CONFIG_TELINIT_PATH,
+ CONFIG_TELINIT_PATH,
+ which == 2 ? "6" : "0",
+ (char *)NULL
+ );
+ bb_perror_msg_and_die("can't execute '%s'",
+ CONFIG_TELINIT_PATH);
+ }
+ }
+ } else {
+ rc = reboot(magic[which]);
+ }
+
+ if (rc)
+ bb_perror_nomsg_and_die();
+ return rc;
+}
diff --git a/ap/app/busybox/src/init/init.c b/ap/app/busybox/src/init/init.c
new file mode 100644
index 0000000..ddb0a95
--- /dev/null
+++ b/ap/app/busybox/src/init/init.c
@@ -0,0 +1,1369 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini init implementation for busybox
+ *
+ * Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
+ * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+ * Adjusted by so many folks, it's impossible to keep track.
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+
+//applet:IF_INIT(APPLET(init, BB_DIR_SBIN, BB_SUID_DROP))
+//applet:IF_FEATURE_INITRD(APPLET_ODDNAME(linuxrc, init, BB_DIR_ROOT, BB_SUID_DROP, linuxrc))
+
+//kbuild:lib-$(CONFIG_INIT) += init.o
+
+//config:config INIT
+//config: bool "init"
+//config: default y
+//config: select FEATURE_SYSLOG
+//config: help
+//config: init is the first program run when the system boots.
+//config:
+//config:config FEATURE_USE_INITTAB
+//config: bool "Support reading an inittab file"
+//config: default y
+//config: depends on INIT
+//config: help
+//config: Allow init to read an inittab file when the system boot.
+//config:
+//config:config FEATURE_KILL_REMOVED
+//config: bool "Support killing processes that have been removed from inittab"
+//config: default n
+//config: depends on FEATURE_USE_INITTAB
+//config: help
+//config: When respawn entries are removed from inittab and a SIGHUP is
+//config: sent to init, this option will make init kill the processes
+//config: that have been removed.
+//config:
+//config:config FEATURE_KILL_DELAY
+//config: int "How long to wait between TERM and KILL (0 - send TERM only)" if FEATURE_KILL_REMOVED
+//config: range 0 1024
+//config: default 0
+//config: depends on FEATURE_KILL_REMOVED
+//config: help
+//config: With nonzero setting, init sends TERM, forks, child waits N
+//config: seconds, sends KILL and exits. Setting it too high is unwise
+//config: (child will hang around for too long and could actually kill
+//config: the wrong process!)
+//config:
+//config:config FEATURE_INIT_SCTTY
+//config: bool "Run commands with leading dash with controlling tty"
+//config: default y
+//config: depends on INIT
+//config: help
+//config: If this option is enabled, init will try to give a controlling
+//config: tty to any command which has leading hyphen (often it's "-/bin/sh").
+//config: More precisely, init will do "ioctl(STDIN_FILENO, TIOCSCTTY, 0)".
+//config: If device attached to STDIN_FILENO can be a ctty but is not yet
+//config: a ctty for other session, it will become this process' ctty.
+//config: This is not the traditional init behavour, but is often what you want
+//config: in an embedded system where the console is only accessed during
+//config: development or for maintenance.
+//config: NB: using cttyhack applet may work better.
+//config:
+//config:config FEATURE_INIT_SYSLOG
+//config: bool "Enable init to write to syslog"
+//config: default y
+//config: depends on INIT
+//config:
+//config:config FEATURE_EXTRA_QUIET
+//config: bool "Be _extra_ quiet on boot"
+//config: default y
+//config: depends on INIT
+//config: help
+//config: Prevent init from logging some messages to the console during boot.
+//config:
+//config:config FEATURE_INIT_COREDUMPS
+//config: bool "Support dumping core for child processes (debugging only)"
+//config: default y
+//config: depends on INIT
+//config: help
+//config: If this option is enabled and the file /.init_enable_core
+//config: exists, then init will call setrlimit() to allow unlimited
+//config: core file sizes. If this option is disabled, processes
+//config: will not generate any core files.
+//config:
+//config:config FEATURE_INITRD
+//config: bool "Support running init from within an initrd (not initramfs)"
+//config: default y
+//config: depends on INIT
+//config: help
+//config: Legacy support for running init under the old-style initrd. Allows
+//config: the name linuxrc to act as init, and it doesn't assume init is PID 1.
+//config:
+//config: This does not apply to initramfs, which runs /init as PID 1 and
+//config: requires no special support.
+//config:
+//config:config INIT_TERMINAL_TYPE
+//config: string "Initial terminal type"
+//config: default "linux"
+//config: depends on INIT
+//config: help
+//config: This is the initial value set by init for the TERM environment
+//config: variable. This variable is used by programs which make use of
+//config: extended terminal capabilities.
+//config:
+//config: Note that on Linux, init attempts to detect serial terminal and
+//config: sets TERM to "vt102" if one is found.
+//config:
+//config:config FEATURE_ETC_RC
+//config: bool "Run /etc/rc before loading /etc/inittab"
+//config: default n
+//config: depends on INIT
+//config: help
+//config: Legacy in case inittab lives in an unmounted filesystem.
+
+#define DEBUG_SEGV_HANDLER 0
+
+#include "libbb.h"
+#include <syslog.h>
+#include <paths.h>
+#include <sys/resource.h>
+#ifdef __linux__
+# include <linux/vt.h>
+# include <sys/sysinfo.h>
+#endif
+#include "reboot.h" /* reboot() constants */
+
+#if DEBUG_SEGV_HANDLER
+# undef _GNU_SOURCE
+# define _GNU_SOURCE 1
+# undef __USE_GNU
+# define __USE_GNU 1
+# include <execinfo.h>
+# include <sys/ucontext.h>
+#endif
+
+/* Used only for sanitizing purposes in set_sane_term() below. On systems where
+ * the baud rate is stored in a separate field, we can safely disable them. */
+#ifndef CBAUD
+# define CBAUD 0
+# define CBAUDEX 0
+#endif
+
+/* Was a CONFIG_xxx option. A lot of people were building
+ * not fully functional init by switching it on! */
+#define DEBUG_INIT 0
+
+#define COMMAND_SIZE 256
+#define CONSOLE_NAME_SIZE 32
+
+/* Default sysinit script. */
+#ifndef INIT_SCRIPT
+#define INIT_SCRIPT "/etc/rc"
+#endif
+
+/* Each type of actions can appear many times. They will be
+ * handled in order. RESTART is an exception, only 1st is used.
+ */
+/* Start these actions first and wait for completion */
+#define SYSINIT 0x01
+/* Start these after SYSINIT and wait for completion */
+#define WAIT 0x02
+/* Start these after WAIT and *dont* wait for completion */
+#define ONCE 0x04
+/*
+ * NB: while SYSINIT/WAIT/ONCE are being processed,
+ * SIGHUP ("reread /etc/inittab") will be processed only after
+ * each group of actions. If new inittab adds, say, a SYSINIT action,
+ * it will not be run, since init is already "past SYSINIT stage".
+ */
+/* Start these after ONCE are started, restart on exit */
+#define RESPAWN 0x08
+/* Like RESPAWN, but wait for <Enter> to be pressed on tty */
+#define ASKFIRST 0x10
+/*
+ * Start these on SIGINT, and wait for completion.
+ * Then go back to respawning RESPAWN and ASKFIRST actions.
+ * NB: kernel sends SIGINT to us if Ctrl-Alt-Del was pressed.
+ */
+#define CTRLALTDEL 0x20
+/*
+ * Start these before killing all processes in preparation for
+ * running RESTART actions or doing low-level halt/reboot/poweroff
+ * (initiated by SIGUSR1/SIGTERM/SIGUSR2).
+ * Wait for completion before proceeding.
+ */
+#define SHUTDOWN 0x40
+/*
+ * exec() on SIGQUIT. SHUTDOWN actions are started and waited for,
+ * then all processes are killed, then init exec's 1st RESTART action,
+ * replacing itself by it. If no RESTART action specified,
+ * SIGQUIT has no effect.
+ */
+#define RESTART 0x80
+
+
+/* A linked list of init_actions, to be read from inittab */
+struct init_action {
+ struct init_action *next;
+ pid_t pid;
+ uint8_t action_type;
+ char terminal[CONSOLE_NAME_SIZE];
+ char command[COMMAND_SIZE];
+};
+
+static struct init_action *init_action_list = NULL;
+
+static const char *log_console = VC_5;
+
+enum {
+ L_LOG = 0x1,
+ L_CONSOLE = 0x2,
+};
+
+/* Print a message to the specified device.
+ * "where" may be bitwise-or'd from L_LOG | L_CONSOLE
+ * NB: careful, we can be called after vfork!
+ */
+#define dbg_message(...) do { if (DEBUG_INIT) message(__VA_ARGS__); } while (0)
+static void message(int where, const char *fmt, ...)
+ __attribute__ ((format(printf, 2, 3)));
+static void message(int where, const char *fmt, ...)
+{
+ va_list arguments;
+ unsigned l;
+ char msg[128];
+
+ msg[0] = '\r';
+ va_start(arguments, fmt);
+ l = 1 + vsnprintf(msg + 1, sizeof(msg) - 2, fmt, arguments);
+ if (l > sizeof(msg) - 1)
+ l = sizeof(msg) - 1;
+ va_end(arguments);
+
+#if ENABLE_FEATURE_INIT_SYSLOG
+ msg[l] = '\0';
+ if (where & L_LOG) {
+ /* Log the message to syslogd */
+ openlog(applet_name, 0, LOG_DAEMON);
+ /* don't print "\r" */
+ syslog(LOG_INFO, "%s", msg + 1);
+ closelog();
+ }
+ msg[l++] = '\n';
+ msg[l] = '\0';
+#else
+ {
+ static int log_fd = -1;
+
+ msg[l++] = '\n';
+ msg[l] = '\0';
+ /* Take full control of the log tty, and never close it.
+ * It's mine, all mine! Muhahahaha! */
+ if (log_fd < 0) {
+ if (!log_console) {
+ log_fd = STDERR_FILENO;
+ } else {
+ 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);
+ where = L_CONSOLE;
+ } else {
+ close_on_exec_on(log_fd);
+ }
+ }
+ }
+ if (where & L_LOG) {
+ full_write(log_fd, msg, l);
+ if (log_fd == STDERR_FILENO)
+ return; /* don't print dup messages */
+ }
+ }
+#endif
+
+ if (where & L_CONSOLE) {
+ /* Send console messages to console so people will see them. */
+ full_write(STDERR_FILENO, msg, l);
+ }
+}
+
+static void console_init(void)
+{
+#ifdef VT_OPENQRY
+ int vtno;
+#endif
+ char *s;
+
+ 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, STDIN_FILENO);
+ dup2(fd, STDOUT_FILENO);
+ xmove_fd(fd, STDERR_FILENO);
+ }
+ dbg_message(L_LOG, "console='%s'", s);
+ } else {
+ /* Make sure fd 0,1,2 are not closed
+ * (so that they won't be used by future opens) */
+ bb_sanitize_stdio();
+// Users report problems
+// /* Make sure init can't be blocked by writing to stderr */
+// fcntl(STDERR_FILENO, F_SETFL, fcntl(STDERR_FILENO, F_GETFL) | O_NONBLOCK);
+ }
+
+ s = getenv("TERM");
+#ifdef VT_OPENQRY
+ if (ioctl(STDIN_FILENO, VT_OPENQRY, &vtno) != 0) {
+ /* Not a linux terminal, probably serial console.
+ * Force the TERM setting to vt102
+ * if TERM is set to linux (the default) */
+ if (!s || strcmp(s, "linux") == 0)
+ putenv((char*)"TERM=vt102");
+ if (!ENABLE_FEATURE_INIT_SYSLOG)
+ log_console = NULL;
+ } else
+#endif
+ if (!s)
+ putenv((char*)"TERM=" CONFIG_INIT_TERMINAL_TYPE);
+}
+
+/* Set terminal settings to reasonable defaults.
+ * NB: careful, we can be called after vfork! */
+static void set_sane_term(void)
+{
+ struct termios tty;
+
+ tcgetattr(STDIN_FILENO, &tty);
+
+ /* set control chars */
+ tty.c_cc[VINTR] = 3; /* C-c */
+ tty.c_cc[VQUIT] = 28; /* C-\ */
+ tty.c_cc[VERASE] = 127; /* C-? */
+ tty.c_cc[VKILL] = 21; /* C-u */
+ tty.c_cc[VEOF] = 4; /* C-d */
+ tty.c_cc[VSTART] = 17; /* C-q */
+ tty.c_cc[VSTOP] = 19; /* C-s */
+ tty.c_cc[VSUSP] = 26; /* C-z */
+
+#ifdef __linux__
+ /* use line discipline 0 */
+ tty.c_line = 0;
+#endif
+
+ /* Make it be sane */
+#ifndef CRTSCTS
+# define CRTSCTS 0
+#endif
+ /* added CRTSCTS to fix Debian bug 528560 */
+ tty.c_cflag &= CBAUD | CBAUDEX | CSIZE | CSTOPB | PARENB | PARODD | CRTSCTS;
+ tty.c_cflag |= CREAD | HUPCL | CLOCAL;
+
+ /* input modes */
+ tty.c_iflag = ICRNL | IXON | IXOFF;
+
+ /* output modes */
+ tty.c_oflag = OPOST | ONLCR;
+
+ /* local modes */
+ tty.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN;
+
+ tcsetattr_stdin_TCSANOW(&tty);
+}
+
+/* Open the new terminal device.
+ * NB: careful, we can be called after vfork! */
+static int open_stdio_to_tty(const char* tty_name)
+{
+ /* empty tty_name means "use init's tty", else... */
+ if (tty_name[0]) {
+ int fd;
+
+ close(STDIN_FILENO);
+ /* fd can be only < 0 or 0: */
+ fd = device_open(tty_name, O_RDWR);
+ if (fd) {
+ message(L_LOG | L_CONSOLE, "can't open %s: %s",
+ tty_name, strerror(errno));
+ return 0; /* failure */
+ }
+ dup2(STDIN_FILENO, STDOUT_FILENO);
+ dup2(STDIN_FILENO, STDERR_FILENO);
+ }
+ set_sane_term();
+ return 1; /* success */
+}
+
+static void reset_sighandlers_and_unblock_sigs(void)
+{
+ bb_signals(0
+ + (1 << SIGUSR1)
+ + (1 << SIGUSR2)
+ + (1 << SIGTERM)
+ + (1 << SIGQUIT)
+ + (1 << SIGINT)
+ + (1 << SIGHUP)
+ + (1 << SIGTSTP)
+ + (1 << SIGSTOP)
+ , SIG_DFL);
+ sigprocmask_allsigs(SIG_UNBLOCK);
+}
+
+/* Wrapper around exec:
+ * Takes string (max COMMAND_SIZE chars).
+ * If chars like '>' detected, execs '[-]/bin/sh -c "exec ......."'.
+ * Otherwise splits words on whitespace, deals with leading dash,
+ * and uses plain exec().
+ * NB: careful, we can be called after vfork!
+ */
+static void init_exec(const char *command)
+{
+ char *cmd[COMMAND_SIZE / 2];
+ char buf[COMMAND_SIZE + 6]; /* COMMAND_SIZE+strlen("exec ")+1 */
+ int dash = (command[0] == '-' /* maybe? && command[1] == '/' */);
+
+ command += dash;
+
+ /* See if any special /bin/sh requiring characters are present */
+ if (strpbrk(command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) {
+ sprintf(buf, "exec %s", command); /* excluding "-" */
+ /* NB: LIBBB_DEFAULT_LOGIN_SHELL define has leading dash */
+ cmd[0] = (char*)(LIBBB_DEFAULT_LOGIN_SHELL + !dash);
+ cmd[1] = (char*)"-c";
+ cmd[2] = buf;
+ cmd[3] = NULL;
+ command = LIBBB_DEFAULT_LOGIN_SHELL + 1;
+ } else {
+ /* Convert command (char*) into cmd (char**, one word per string) */
+ char *word, *next;
+ int i = 0;
+ next = strcpy(buf, command - dash); /* command including "-" */
+ command = next + dash;
+ while ((word = strsep(&next, " \t")) != NULL) {
+ if (*word != '\0') { /* not two spaces/tabs together? */
+ cmd[i] = word;
+ i++;
+ }
+ }
+ cmd[i] = NULL;
+ }
+ /* If we saw leading "-", it is interactive shell.
+ * Try harder to give it a controlling tty.
+ */
+ if (ENABLE_FEATURE_INIT_SCTTY && dash) {
+ /* _Attempt_ to make stdin a controlling tty. */
+ ioctl(STDIN_FILENO, TIOCSCTTY, 0 /*only try, don't steal*/);
+ }
+ /* Here command never contains the dash, cmd[0] might */
+ BB_EXECVP(command, cmd);
+ message(L_LOG | L_CONSOLE, "can't run '%s': %s", command, strerror(errno));
+ /* returns if execvp fails */
+}
+
+/* Used only by run_actions */
+static pid_t run(const struct init_action *a)
+{
+ pid_t pid;
+
+ /* Careful: don't be affected by a signal in vforked child */
+ sigprocmask_allsigs(SIG_BLOCK);
+ if (BB_MMU && (a->action_type & ASKFIRST))
+ pid = fork();
+ else
+ pid = vfork();
+ if (pid < 0)
+ message(L_LOG | L_CONSOLE, "can't fork");
+ if (pid) {
+ sigprocmask_allsigs(SIG_UNBLOCK);
+ return pid; /* Parent or error */
+ }
+
+ /* Child */
+
+ /* Reset signal handlers that were set by the parent process */
+ reset_sighandlers_and_unblock_sigs();
+
+ /* Create a new session and make ourself the process group leader */
+ setsid();
+
+ /* Open the new terminal device */
+ if (!open_stdio_to_tty(a->terminal))
+ _exit(EXIT_FAILURE);
+
+ /* NB: on NOMMU we can't wait for input in child, so
+ * "askfirst" will work the same as "respawn". */
+ if (BB_MMU && (a->action_type & ASKFIRST)) {
+ static const char press_enter[] ALIGN1 =
+#ifdef CUSTOMIZED_BANNER
+#include CUSTOMIZED_BANNER
+#endif
+ "\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.
+ */
+ dbg_message(L_LOG, "waiting for enter to start '%s'"
+ "(pid %d, tty '%s')\n",
+ a->command, getpid(), a->terminal);
+ full_write(STDOUT_FILENO, press_enter, sizeof(press_enter) - 1);
+ while (safe_read(STDIN_FILENO, &c, 1) == 1 && c != '\n')
+ continue;
+ }
+
+ /*
+ * When a file named /.init_enable_core exists, setrlimit is called
+ * before processes are spawned to set core file size as unlimited.
+ * This is for debugging only. Don't use this is production, unless
+ * you want core dumps lying about....
+ */
+ if (ENABLE_FEATURE_INIT_COREDUMPS) {
+ if (access("/.init_enable_core", F_OK) == 0) {
+ struct rlimit limit;
+ limit.rlim_cur = RLIM_INFINITY;
+ limit.rlim_max = RLIM_INFINITY;
+ setrlimit(RLIMIT_CORE, &limit);
+ }
+ }
+
+ /* Log the process name and args */
+ message(L_LOG, "starting pid %d, tty '%s': '%s'",
+ getpid(), a->terminal, a->command);
+
+ /* Now run it. The new program will take over this PID,
+ * so nothing further in init.c should be run. */
+ init_exec(a->command);
+ /* We're still here? Some error happened. */
+ _exit(-1);
+}
+
+static struct init_action *mark_terminated(pid_t pid)
+{
+ struct init_action *a;
+
+ if (pid > 0) {
+ update_utmp(pid, DEAD_PROCESS,
+ /*tty_name:*/ NULL,
+ /*username:*/ NULL,
+ /*hostname:*/ NULL
+ );
+ for (a = init_action_list; a; a = a->next) {
+ if (a->pid == pid) {
+ a->pid = 0;
+ return a;
+ }
+ }
+ }
+ return NULL;
+}
+
+static void waitfor(pid_t pid)
+{
+ /* waitfor(run(x)): protect against failed fork inside run() */
+ if (pid <= 0)
+ return;
+
+ /* Wait for any child (prevent zombies from exiting orphaned processes)
+ * but exit the loop only when specified one has exited. */
+ while (1) {
+ pid_t wpid = wait(NULL);
+ mark_terminated(wpid);
+ /* Unsafe. SIGTSTP handler might have wait'ed it already */
+ /*if (wpid == pid) break;*/
+ /* More reliable: */
+ if (kill(pid, 0))
+ break;
+ }
+}
+
+/* Run all commands of a particular type */
+static void run_actions(int action_type)
+{
+ struct init_action *a;
+
+ for (a = init_action_list; a; a = a->next) {
+ if (!(a->action_type & action_type))
+ continue;
+
+ if (a->action_type & (SYSINIT | WAIT | ONCE | CTRLALTDEL | SHUTDOWN)) {
+ pid_t pid = run(a);
+ if (a->action_type & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN))
+ waitfor(pid);
+ }
+ if (a->action_type & (RESPAWN | ASKFIRST)) {
+ /* Only run stuff with pid == 0. If pid != 0,
+ * it is already running
+ */
+ if (a->pid == 0)
+ a->pid = run(a);
+ }
+ }
+}
+
+static void new_init_action(uint8_t action_type, const char *command, const char *cons)
+{
+ struct init_action *a, **nextp;
+
+ /* Scenario:
+ * old inittab:
+ * ::shutdown:umount -a -r
+ * ::shutdown:swapoff -a
+ * new inittab:
+ * ::shutdown:swapoff -a
+ * ::shutdown:umount -a -r
+ * On reload, we must ensure entries end up in correct order.
+ * To achieve that, if we find a matching entry, we move it
+ * to the end.
+ */
+ nextp = &init_action_list;
+ while ((a = *nextp) != NULL) {
+ /* Don't enter action if it's already in the list.
+ * This prevents losing running RESPAWNs.
+ */
+ if (strcmp(a->command, command) == 0
+ && strcmp(a->terminal, cons) == 0
+ ) {
+ /* Remove from list */
+ *nextp = a->next;
+ /* Find the end of the list */
+ while (*nextp != NULL)
+ nextp = &(*nextp)->next;
+ a->next = NULL;
+ goto append;
+ }
+ nextp = &a->next;
+ }
+
+ a = xzalloc(sizeof(*a));
+
+ /* Append to the end of the list */
+ append:
+ *nextp = a;
+ a->action_type = action_type;
+ safe_strncpy(a->command, command, sizeof(a->command));
+ safe_strncpy(a->terminal, cons, sizeof(a->terminal));
+ dbg_message(L_LOG | L_CONSOLE, "command='%s' action=%d tty='%s'\n",
+ a->command, a->action_type, a->terminal);
+}
+
+/* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
+ * then parse_inittab() simply adds in some default
+ * actions(i.e., runs INIT_SCRIPT and then starts a pair
+ * of "askfirst" shells). If CONFIG_FEATURE_USE_INITTAB
+ * _is_ defined, but /etc/inittab is missing, this
+ * results in the same set of default behaviors.
+ */
+static void parse_inittab(void)
+{
+#if ENABLE_FEATURE_USE_INITTAB
+ char *token[4];
+#if ENABLE_INSTALL_TO_RECOVERY
+ parser_t *parser = config_open2("/recovery/etc/inittab", fopen_for_read);
+#else
+ parser_t *parser = config_open2("/etc/inittab", fopen_for_read);
+#endif
+ if (parser == NULL)
+#endif
+ {
+ /* No inittab file - set up some default behavior */
+ /* Reboot on Ctrl-Alt-Del */
+ new_init_action(CTRLALTDEL, "reboot", "");
+ /* Umount all filesystems on halt/reboot */
+ new_init_action(SHUTDOWN, "umount -a -r", "");
+ /* Swapoff on halt/reboot */
+ if (ENABLE_SWAPONOFF)
+ new_init_action(SHUTDOWN, "swapoff -a", "");
+ /* Prepare to restart init when a QUIT is received */
+ new_init_action(RESTART, "init", "");
+ /* Askfirst shell on tty1-4 */
+ new_init_action(ASKFIRST, bb_default_login_shell, "");
+//TODO: VC_1 instead of ""? "" is console -> ctty problems -> angry users
+ 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);
+ /* sysinit */
+ new_init_action(SYSINIT, INIT_SCRIPT, "");
+ return;
+ }
+
+#if ENABLE_FEATURE_USE_INITTAB
+ /* optional_tty:ignored_runlevel:action:command
+ * Delims are not to be collapsed and need exactly 4 tokens
+ */
+ while (config_read(parser, token, 4, 0, "#:",
+ PARSE_NORMAL & ~(PARSE_TRIM | PARSE_COLLAPSE))) {
+ /* order must correspond to SYSINIT..RESTART constants */
+ static const char actions[] ALIGN1 =
+ "sysinit\0""wait\0""once\0""respawn\0""askfirst\0"
+ "ctrlaltdel\0""shutdown\0""restart\0";
+ int action;
+ char *tty = token[0];
+
+ if (!token[3]) /* less than 4 tokens */
+ goto bad_entry;
+ action = index_in_strings(actions, token[2]);
+ if (action < 0 || !token[3][0]) /* token[3]: command */
+ goto bad_entry;
+ /* turn .*TTY -> /dev/TTY */
+ if (tty[0]) {
+ tty = concat_path_file("/dev/", skip_dev_pfx(tty));
+ }
+ new_init_action(1 << action, token[3], tty);
+ if (tty[0])
+ free(tty);
+ continue;
+ bad_entry:
+ message(L_LOG | L_CONSOLE, "Bad inittab entry at line %d",
+ parser->lineno);
+ }
+ config_close(parser);
+#endif
+}
+
+static void pause_and_low_level_reboot(unsigned magic) NORETURN;
+static void pause_and_low_level_reboot(unsigned magic)
+{
+ pid_t pid;
+
+ /* Allow time for last message to reach serial console, etc */
+ sleep(1);
+
+ /* We have to fork here, since the kernel calls do_exit(EXIT_SUCCESS)
+ * in linux/kernel/sys.c, which can cause the machine to panic when
+ * the init process exits... */
+ pid = vfork();
+ if (pid == 0) { /* child */
+ reboot(magic);
+ _exit(EXIT_SUCCESS);
+ }
+ while (1)
+ sleep(1);
+}
+
+static void run_shutdown_and_kill_processes(void)
+{
+ /* 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);
+
+ message(L_CONSOLE | L_LOG, "The system is going down NOW!");
+
+ /* Send signals to every process _except_ pid 1 */
+ kill(-1, SIGTERM);
+ message(L_CONSOLE | L_LOG, "Sent SIG%s to all processes", "TERM");
+ sync();
+ sleep(1);
+
+ kill(-1, SIGKILL);
+ message(L_CONSOLE, "Sent SIG%s to all processes", "KILL");
+ sync();
+ /*sleep(1); - callers take care about making a pause */
+}
+
+/* Signal handling by init:
+ *
+ * For process with PID==1, on entry kernel sets all signals to SIG_DFL
+ * and unmasks all signals. However, for process with PID==1,
+ * default action (SIG_DFL) on any signal is to ignore it,
+ * even for special signals SIGKILL and SIGCONT.
+ * Also, any signal can be caught or blocked.
+ * (but SIGSTOP is still handled specially, at least in 2.6.20)
+ *
+ * We install two kinds of handlers, "immediate" and "delayed".
+ *
+ * Immediate handlers execute at any time, even while, say, sysinit
+ * is running.
+ *
+ * Delayed handlers just set a flag variable. The variable is checked
+ * in the main loop and acted upon.
+ *
+ * halt/poweroff/reboot and restart have immediate handlers.
+ * They only traverse linked list of struct action's, never modify it,
+ * this should be safe to do even in signal handler. Also they
+ * never return.
+ *
+ * SIGSTOP and SIGTSTP have immediate handlers. They just wait
+ * for SIGCONT to happen.
+ *
+ * SIGHUP has a delayed handler, because modifying linked list
+ * of struct action's from a signal handler while it is manipulated
+ * by the program may be disastrous.
+ *
+ * Ctrl-Alt-Del has a delayed handler. Not a must, but allowing
+ * it to happen even somewhere inside "sysinit" would be a bit awkward.
+ *
+ * There is a tiny probability that SIGHUP and Ctrl-Alt-Del will collide
+ * and only one will be remembered and acted upon.
+ */
+
+/* The SIGUSR[12]/SIGTERM handler */
+static void halt_reboot_pwoff(int sig) NORETURN;
+static void halt_reboot_pwoff(int sig)
+{
+ const char *m;
+ unsigned rb;
+
+ /* We may call run() and it unmasks signals,
+ * including the one masked inside this signal handler.
+ * Testcase which would start multiple reboot scripts:
+ * while true; do reboot; done
+ * Preventing it:
+ */
+ reset_sighandlers_and_unblock_sigs();
+
+ run_shutdown_and_kill_processes();
+
+ m = "halt";
+ rb = RB_HALT_SYSTEM;
+ if (sig == SIGTERM) {
+ m = "reboot";
+ rb = RB_AUTOBOOT;
+ } else if (sig == SIGUSR2) {
+ m = "poweroff";
+ rb = RB_POWER_OFF;
+ }
+ message(L_CONSOLE, "Requesting system %s", m);
+ pause_and_low_level_reboot(rb);
+ /* not reached */
+}
+
+/* Handler for QUIT - exec "restart" action,
+ * else (no such action defined) do nothing */
+static void restart_handler(int sig UNUSED_PARAM)
+{
+ struct init_action *a;
+
+ for (a = init_action_list; a; a = a->next) {
+ if (!(a->action_type & RESTART))
+ continue;
+
+ /* Starting from here, we won't return.
+ * Thus don't need to worry about preserving errno
+ * and such.
+ */
+
+ reset_sighandlers_and_unblock_sigs();
+
+ run_shutdown_and_kill_processes();
+
+#ifdef RB_ENABLE_CAD
+ /* Allow Ctrl-Alt-Del to reboot the system.
+ * This is how kernel sets it up for init, we follow suit.
+ */
+ reboot(RB_ENABLE_CAD); /* misnomer */
+#endif
+
+ if (open_stdio_to_tty(a->terminal)) {
+ dbg_message(L_CONSOLE, "Trying to re-exec %s", a->command);
+ /* Theoretically should be safe.
+ * But in practice, kernel bugs may leave
+ * unkillable processes, and wait() may block forever.
+ * Oh well. Hoping "new" init won't be too surprised
+ * by having children it didn't create.
+ */
+ //while (wait(NULL) > 0)
+ // continue;
+ init_exec(a->command);
+ }
+ /* Open or exec failed */
+ pause_and_low_level_reboot(RB_HALT_SYSTEM);
+ /* not reached */
+ }
+}
+
+/* The SIGSTOP/SIGTSTP handler
+ * NB: inside it, all signals except SIGCONT are masked
+ * via appropriate setup in sigaction().
+ */
+static void stop_handler(int sig UNUSED_PARAM)
+{
+ smallint saved_bb_got_signal;
+ int saved_errno;
+
+ saved_bb_got_signal = bb_got_signal;
+ saved_errno = errno;
+ signal(SIGCONT, record_signo);
+
+ while (1) {
+ pid_t wpid;
+
+ if (bb_got_signal == SIGCONT)
+ break;
+ /* NB: this can accidentally wait() for a process
+ * which we waitfor() elsewhere! waitfor() must have
+ * code which is resilient against this.
+ */
+ wpid = wait_any_nohang(NULL);
+ mark_terminated(wpid);
+ sleep(1);
+ }
+
+ signal(SIGCONT, SIG_DFL);
+ errno = saved_errno;
+ bb_got_signal = saved_bb_got_signal;
+}
+
+#if ENABLE_FEATURE_USE_INITTAB
+static void reload_inittab(void)
+{
+ struct init_action *a, **nextp;
+
+ message(L_LOG, "reloading /etc/inittab");
+
+ /* Disable old entries */
+ for (a = init_action_list; a; a = a->next)
+ a->action_type = 0;
+
+ /* Append new entries, or modify existing entries
+ * (incl. setting a->action_type) if cmd and device name
+ * match new ones. End result: only entries with
+ * a->action_type == 0 are stale.
+ */
+ parse_inittab();
+
+#if ENABLE_FEATURE_KILL_REMOVED
+ /* Kill stale entries */
+ /* Be nice and send SIGTERM first */
+ for (a = init_action_list; a; a = a->next)
+ if (a->action_type == 0 && a->pid != 0)
+ kill(a->pid, SIGTERM);
+ if (CONFIG_FEATURE_KILL_DELAY) {
+ /* NB: parent will wait in NOMMU case */
+ if ((BB_MMU ? fork() : vfork()) == 0) { /* child */
+ sleep(CONFIG_FEATURE_KILL_DELAY);
+ for (a = init_action_list; a; a = a->next)
+ if (a->action_type == 0 && a->pid != 0)
+ kill(a->pid, SIGKILL);
+ _exit(EXIT_SUCCESS);
+ }
+ }
+#endif
+
+ /* Remove stale entries and SYSINIT entries.
+ * We never rerun SYSINIT entries anyway,
+ * removing them too saves a few bytes */
+ nextp = &init_action_list;
+ while ((a = *nextp) != NULL) {
+ if ((a->action_type & ~SYSINIT) == 0) {
+ *nextp = a->next;
+ free(a);
+ } else {
+ nextp = &a->next;
+ }
+ }
+
+ /* Not needed: */
+ /* run_actions(RESPAWN | ASKFIRST); */
+ /* - we return to main loop, which does this automagically */
+}
+#endif
+
+static int check_delayed_sigs(void)
+{
+ int sigs_seen = 0;
+
+ while (1) {
+ smallint sig = bb_got_signal;
+
+ if (!sig)
+ return sigs_seen;
+ bb_got_signal = 0;
+ sigs_seen = 1;
+#if ENABLE_FEATURE_USE_INITTAB
+ if (sig == SIGHUP)
+ reload_inittab();
+#endif
+ if (sig == SIGINT)
+ run_actions(CTRLALTDEL);
+ }
+}
+
+#if DEBUG_SEGV_HANDLER
+static
+void handle_sigsegv(int sig, siginfo_t *info, void *ucontext)
+{
+ long ip;
+ ucontext_t *uc;
+
+ uc = ucontext;
+ ip = uc->uc_mcontext.gregs[REG_EIP];
+ fdprintf(2, "signal:%d address:0x%lx ip:0x%lx\n",
+ sig,
+ /* this is void*, but using %p would print "(null)"
+ * even for ptrs which are not exactly 0, but, say, 0x123:
+ */
+ (long)info->si_addr,
+ ip);
+ {
+ /* glibc extension */
+ void *array[50];
+ int size;
+ size = backtrace(array, 50);
+ backtrace_symbols_fd(array, size, 2);
+ }
+ for (;;) sleep(9999);
+}
+#endif
+
+int init_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int init_main(int argc UNUSED_PARAM, char **argv)
+{
+ if (argv[1] && strcmp(argv[1], "-q") == 0) {
+ return kill(1, SIGHUP);
+ }
+
+#if DEBUG_SEGV_HANDLER
+ {
+ struct sigaction sa;
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_sigaction = handle_sigsegv;
+ sa.sa_flags = SA_SIGINFO;
+ sigaction(SIGSEGV, &sa, NULL);
+ sigaction(SIGILL, &sa, NULL);
+ sigaction(SIGFPE, &sa, NULL);
+ sigaction(SIGBUS, &sa, NULL);
+ }
+#endif
+
+ if (!DEBUG_INIT) {
+ /* Expect to be invoked as init with PID=1 or be invoked as linuxrc */
+ if (getpid() != 1
+ && (!ENABLE_FEATURE_INITRD || applet_name[0] != 'l') /* not linuxrc? */
+ ) {
+ bb_error_msg_and_die("must be run as PID 1");
+ }
+#ifdef RB_DISABLE_CAD
+ /* Turn off rebooting via CTL-ALT-DEL - we get a
+ * SIGINT on CAD so we can shut things down gracefully... */
+ reboot(RB_DISABLE_CAD); /* misnomer */
+#endif
+ }
+
+ /* If, say, xmalloc would ever die, we don't want to oops kernel
+ * by exiting.
+ * NB: we set die_sleep *after* PID 1 check and bb_show_usage.
+ * Otherwise, for example, "init u" ("please rexec yourself"
+ * command for sysvinit) will show help text (which isn't too bad),
+ * *and sleep forever* (which is bad!)
+ */
+ die_sleep = 30 * 24*60*60;
+
+ /* Figure out where the default console should be */
+ console_init();
+ set_sane_term();
+ xchdir("/");
+ setsid();
+
+ /* Make sure environs is set to something sane */
+ putenv((char *) "HOME=/");
+ putenv((char *) bb_PATH_root_path);
+ putenv((char *) "SHELL=/bin/sh");
+ putenv((char *) "USER=root"); /* needed? why? */
+
+ if (argv[1])
+ xsetenv("RUNLEVEL", argv[1]);
+
+#if !ENABLE_FEATURE_EXTRA_QUIET
+ /* Hello world */
+ message(L_CONSOLE | L_LOG, "init started: %s", bb_banner);
+#endif
+
+#if ENABLE_FEATURE_ETC_RC
+ {
+ pid_t pid;
+ pid = vfork();
+ if (pid == 0) { /* child */
+ close(0);
+ execl("/bin/sh", "sh", "/etc/rc", NULL);
+ _exit(0);
+ }
+ waitfor(pid);
+ }
+#endif
+
+/* struct sysinfo is linux-specific */
+#ifdef __linux__
+ /* Make sure there is enough memory to do something useful. */
+ if (ENABLE_SWAPONOFF) {
+ struct sysinfo info;
+
+ if (sysinfo(&info) == 0
+ && (info.mem_unit ? info.mem_unit : 1) * (long long)info.totalram < 1024*1024
+ ) {
+ message(L_CONSOLE, "Low memory, forcing swapon");
+ /* swapon -a requires /proc typically */
+ new_init_action(SYSINIT, "mount -t proc proc /proc", "");
+ /* Try to turn on swap */
+ new_init_action(SYSINIT, "swapon -a", "");
+ run_actions(SYSINIT); /* wait and removing */
+ }
+ }
+#endif
+
+ /* Check if we are supposed to be in single user mode */
+ if (argv[1]
+ && (strcmp(argv[1], "single") == 0 || strcmp(argv[1], "-s") == 0 || LONE_CHAR(argv[1], '1'))
+ ) {
+ /* ??? shouldn't we set RUNLEVEL="b" here? */
+ /* Start a shell on console */
+ new_init_action(RESPAWN, bb_default_login_shell, "");
+ } else {
+ /* Not in single user mode - see what inittab says */
+
+ /* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
+ * then parse_inittab() simply adds in some default
+ * actions(i.e., INIT_SCRIPT and a pair
+ * of "askfirst" shells */
+ parse_inittab();
+ }
+
+#if ENABLE_SELINUX
+ if (getenv("SELINUX_INIT") == NULL) {
+ int enforce = 0;
+
+ putenv((char*)"SELINUX_INIT=YES");
+ if (selinux_init_load_policy(&enforce) == 0) {
+ BB_EXECVP(argv[0], argv);
+ } else if (enforce > 0) {
+ /* SELinux in enforcing mode but load_policy failed */
+ message(L_CONSOLE, "can't load SELinux Policy. "
+ "Machine is in enforcing mode. Halting now.");
+ return EXIT_FAILURE;
+ }
+ }
+#endif
+
+ /* Make the command line just say "init" - thats all, nothing else */
+ strncpy(argv[0], "init", strlen(argv[0]));
+ /* Wipe argv[1]-argv[N] so they don't clutter the ps listing */
+ while (*++argv)
+ memset(*argv, 0, strlen(*argv));
+
+ /* Set up signal handlers */
+ if (!DEBUG_INIT) {
+ struct sigaction sa;
+
+ bb_signals(0
+ + (1 << SIGUSR1) /* halt */
+ + (1 << SIGTERM) /* reboot */
+ + (1 << SIGUSR2) /* poweroff */
+ , halt_reboot_pwoff);
+ signal(SIGQUIT, restart_handler); /* re-exec another init */
+
+ /* Stop handler must allow only SIGCONT inside itself */
+ memset(&sa, 0, sizeof(sa));
+ sigfillset(&sa.sa_mask);
+ sigdelset(&sa.sa_mask, SIGCONT);
+ sa.sa_handler = stop_handler;
+ /* NB: sa_flags doesn't have SA_RESTART.
+ * It must be able to interrupt wait().
+ */
+ sigaction_set(SIGTSTP, &sa); /* pause */
+ /* Does not work as intended, at least in 2.6.20.
+ * SIGSTOP is simply ignored by init:
+ */
+ sigaction_set(SIGSTOP, &sa); /* pause */
+
+ /* SIGINT (Ctrl-Alt-Del) must interrupt wait(),
+ * setting handler without SA_RESTART flag.
+ */
+ bb_signals_recursive_norestart((1 << SIGINT), record_signo);
+ }
+
+ /* Set up "reread /etc/inittab" handler.
+ * Handler is set up without SA_RESTART, it will interrupt syscalls.
+ */
+ if (!DEBUG_INIT && ENABLE_FEATURE_USE_INITTAB)
+ bb_signals_recursive_norestart((1 << SIGHUP), record_signo);
+
+ /* Now run everything that needs to be run */
+ /* First run the sysinit command */
+ run_actions(SYSINIT);
+ check_delayed_sigs();
+ /* Next run anything that wants to block */
+ run_actions(WAIT);
+ check_delayed_sigs();
+ /* Next run anything to be run only once */
+ run_actions(ONCE);
+
+ /* Now run the looping stuff for the rest of forever.
+ */
+ while (1) {
+ int maybe_WNOHANG;
+
+ maybe_WNOHANG = check_delayed_sigs();
+
+ /* (Re)run the respawn/askfirst stuff */
+ run_actions(RESPAWN | ASKFIRST);
+ maybe_WNOHANG |= check_delayed_sigs();
+
+ /* Don't consume all CPU time - sleep a bit */
+ sleep(1);
+ maybe_WNOHANG |= check_delayed_sigs();
+
+ /* Wait for any child process(es) to exit.
+ *
+ * If check_delayed_sigs above reported that a signal
+ * was caught, wait will be nonblocking. This ensures
+ * that if SIGHUP has reloaded inittab, respawn and askfirst
+ * actions will not be delayed until next child death.
+ */
+ if (maybe_WNOHANG)
+ maybe_WNOHANG = WNOHANG;
+ while (1) {
+ pid_t wpid;
+ struct init_action *a;
+
+ /* If signals happen _in_ the wait, they interrupt it,
+ * bb_signals_recursive_norestart set them up that way
+ */
+ wpid = waitpid(-1, NULL, maybe_WNOHANG);
+ if (wpid <= 0)
+ break;
+
+ a = mark_terminated(wpid);
+ if (a) {
+ message(L_LOG, "process '%s' (pid %d) exited. "
+ "Scheduling for restart.",
+ a->command, wpid);
+ }
+ /* See if anyone else is waiting to be reaped */
+ maybe_WNOHANG = WNOHANG;
+ }
+ } /* while (1) */
+}
+
+//usage:#define linuxrc_trivial_usage NOUSAGE_STR
+//usage:#define linuxrc_full_usage ""
+
+//usage:#define init_trivial_usage
+//usage: ""
+//usage:#define init_full_usage "\n\n"
+//usage: "Init is the parent of all processes"
+//usage:
+//usage:#define init_notes_usage
+//usage: "This version of init is designed to be run only by the kernel.\n"
+//usage: "\n"
+//usage: "BusyBox init doesn't support multiple runlevels. The runlevels field of\n"
+//usage: "the /etc/inittab file is completely ignored by BusyBox init. If you want\n"
+//usage: "runlevels, use sysvinit.\n"
+//usage: "\n"
+//usage: "BusyBox init works just fine without an inittab. If no inittab is found,\n"
+//usage: "it has the following default behavior:\n"
+//usage: "\n"
+//usage: " ::sysinit:/etc/init.d/rcS\n"
+//usage: " ::askfirst:/bin/sh\n"
+//usage: " ::ctrlaltdel:/sbin/reboot\n"
+//usage: " ::shutdown:/sbin/swapoff -a\n"
+//usage: " ::shutdown:/bin/umount -a -r\n"
+//usage: " ::restart:/sbin/init\n"
+//usage: "\n"
+//usage: "if it detects that /dev/console is _not_ a serial console, it will also run:\n"
+//usage: "\n"
+//usage: " tty2::askfirst:/bin/sh\n"
+//usage: " tty3::askfirst:/bin/sh\n"
+//usage: " tty4::askfirst:/bin/sh\n"
+//usage: "\n"
+//usage: "If you choose to use an /etc/inittab file, the inittab entry format is as follows:\n"
+//usage: "\n"
+//usage: " <id>:<runlevels>:<action>:<process>\n"
+//usage: "\n"
+//usage: " <id>:\n"
+//usage: "\n"
+//usage: " WARNING: This field has a non-traditional meaning for BusyBox init!\n"
+//usage: " The id field is used by BusyBox init to specify the controlling tty for\n"
+//usage: " the specified process to run on. The contents of this field are\n"
+//usage: " appended to \"/dev/\" and used as-is. There is no need for this field to\n"
+//usage: " be unique, although if it isn't you may have strange results. If this\n"
+//usage: " field is left blank, the controlling tty is set to the console. Also\n"
+//usage: " note that if BusyBox detects that a serial console is in use, then only\n"
+//usage: " entries whose controlling tty is either the serial console or /dev/null\n"
+//usage: " will be run. BusyBox init does nothing with utmp. We don't need no\n"
+//usage: " stinkin' utmp.\n"
+//usage: "\n"
+//usage: " <runlevels>:\n"
+//usage: "\n"
+//usage: " The runlevels field is completely ignored.\n"
+//usage: "\n"
+//usage: " <action>:\n"
+//usage: "\n"
+//usage: " Valid actions include: sysinit, respawn, askfirst, wait,\n"
+//usage: " once, restart, ctrlaltdel, and shutdown.\n"
+//usage: "\n"
+//usage: " The available actions can be classified into two groups: actions\n"
+//usage: " that are run only once, and actions that are re-run when the specified\n"
+//usage: " process exits.\n"
+//usage: "\n"
+//usage: " Run only-once actions:\n"
+//usage: "\n"
+//usage: " 'sysinit' is the first item run on boot. init waits until all\n"
+//usage: " sysinit actions are completed before continuing. Following the\n"
+//usage: " completion of all sysinit actions, all 'wait' actions are run.\n"
+//usage: " 'wait' actions, like 'sysinit' actions, cause init to wait until\n"
+//usage: " the specified task completes. 'once' actions are asynchronous,\n"
+//usage: " therefore, init does not wait for them to complete. 'restart' is\n"
+//usage: " the action taken to restart the init process. By default this should\n"
+//usage: " simply run /sbin/init, but can be a script which runs pivot_root or it\n"
+//usage: " can do all sorts of other interesting things. The 'ctrlaltdel' init\n"
+//usage: " actions are run when the system detects that someone on the system\n"
+//usage: " console has pressed the CTRL-ALT-DEL key combination. Typically one\n"
+//usage: " wants to run 'reboot' at this point to cause the system to reboot.\n"
+//usage: " Finally the 'shutdown' action specifies the actions to taken when\n"
+//usage: " init is told to reboot. Unmounting filesystems and disabling swap\n"
+//usage: " is a very good here.\n"
+//usage: "\n"
+//usage: " Run repeatedly actions:\n"
+//usage: "\n"
+//usage: " 'respawn' actions are run after the 'once' actions. When a process\n"
+//usage: " started with a 'respawn' action exits, init automatically restarts\n"
+//usage: " it. Unlike sysvinit, BusyBox init does not stop processes from\n"
+//usage: " respawning out of control. The 'askfirst' actions acts just like\n"
+//usage: " respawn, except that before running the specified process it\n"
+//usage: " displays the line \"Please press Enter to activate this console.\"\n"
+//usage: " and then waits for the user to press enter before starting the\n"
+//usage: " specified process.\n"
+//usage: "\n"
+//usage: " Unrecognized actions (like initdefault) will cause init to emit an\n"
+//usage: " error message, and then go along with its business. All actions are\n"
+//usage: " run in the order they appear in /etc/inittab.\n"
+//usage: "\n"
+//usage: " <process>:\n"
+//usage: "\n"
+//usage: " Specifies the process to be executed and its command line.\n"
+//usage: "\n"
+//usage: "Example /etc/inittab file:\n"
+//usage: "\n"
+//usage: " # This is run first except when booting in single-user mode\n"
+//usage: " #\n"
+//usage: " ::sysinit:/etc/init.d/rcS\n"
+//usage: " \n"
+//usage: " # /bin/sh invocations on selected ttys\n"
+//usage: " #\n"
+//usage: " # Start an \"askfirst\" shell on the console (whatever that may be)\n"
+//usage: " ::askfirst:-/bin/sh\n"
+//usage: " # Start an \"askfirst\" shell on /dev/tty2-4\n"
+//usage: " tty2::askfirst:-/bin/sh\n"
+//usage: " tty3::askfirst:-/bin/sh\n"
+//usage: " tty4::askfirst:-/bin/sh\n"
+//usage: " \n"
+//usage: " # /sbin/getty invocations for selected ttys\n"
+//usage: " #\n"
+//usage: " tty4::respawn:/sbin/getty 38400 tty4\n"
+//usage: " tty5::respawn:/sbin/getty 38400 tty5\n"
+//usage: " \n"
+//usage: " \n"
+//usage: " # Example of how to put a getty on a serial line (for a terminal)\n"
+//usage: " #\n"
+//usage: " #::respawn:/sbin/getty -L ttyS0 9600 vt100\n"
+//usage: " #::respawn:/sbin/getty -L ttyS1 9600 vt100\n"
+//usage: " #\n"
+//usage: " # Example how to put a getty on a modem line\n"
+//usage: " #::respawn:/sbin/getty 57600 ttyS2\n"
+//usage: " \n"
+//usage: " # Stuff to do when restarting the init process\n"
+//usage: " ::restart:/sbin/init\n"
+//usage: " \n"
+//usage: " # Stuff to do before rebooting\n"
+//usage: " ::ctrlaltdel:/sbin/reboot\n"
+//usage: " ::shutdown:/bin/umount -a -r\n"
+//usage: " ::shutdown:/sbin/swapoff -a\n"
diff --git a/ap/app/busybox/src/init/mesg.c b/ap/app/busybox/src/init/mesg.c
new file mode 100644
index 0000000..45c13b8
--- /dev/null
+++ b/ap/app/busybox/src/init/mesg.c
@@ -0,0 +1,76 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * mesg implementation for busybox
+ *
+ * Copyright (c) 2002 Manuel Novoa III <mjn3@codepoet.org>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+
+//config:config MESG
+//config: bool "mesg"
+//config: default y
+//config: help
+//config: Mesg controls access to your terminal by others. It is typically
+//config: used to allow or disallow other users to write to your terminal
+//config:
+//config:config FEATURE_MESG_ENABLE_ONLY_GROUP
+//config: bool "Enable writing to tty only by group, not by everybody"
+//config: default y
+//config: depends on MESG
+//config: help
+//config: Usually, ttys are owned by group "tty", and "write" tool is
+//config: setgid to this group. This way, "mesg y" only needs to enable
+//config: "write by owning group" bit in tty mode.
+//config:
+//config: If you set this option to N, "mesg y" will enable writing
+//config: by anybody at all. This is not recommended.
+
+//applet:IF_MESG(APPLET(mesg, BB_DIR_USR_BIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_MESG) += mesg.o
+
+//usage:#define mesg_trivial_usage
+//usage: "[y|n]"
+//usage:#define mesg_full_usage "\n\n"
+//usage: "Control write access to your terminal\n"
+//usage: " y Allow write access to your terminal\n"
+//usage: " n Disallow write access to your terminal"
+
+#include "libbb.h"
+
+#if ENABLE_FEATURE_MESG_ENABLE_ONLY_GROUP
+#define S_IWGRP_OR_S_IWOTH S_IWGRP
+#else
+#define S_IWGRP_OR_S_IWOTH (S_IWGRP | S_IWOTH)
+#endif
+
+int mesg_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int mesg_main(int argc UNUSED_PARAM, char **argv)
+{
+ struct stat sb;
+ mode_t m;
+ char c = 0;
+
+ argv++;
+
+ if (argv[0]
+ && (argv[1] || ((c = argv[0][0]) != 'y' && c != 'n'))
+ ) {
+ bb_show_usage();
+ }
+
+ if (!isatty(STDIN_FILENO))
+ bb_error_msg_and_die("not a tty");
+
+ xfstat(STDIN_FILENO, &sb, "stderr");
+ if (c == 0) {
+ puts((sb.st_mode & (S_IWGRP|S_IWOTH)) ? "is y" : "is n");
+ return EXIT_SUCCESS;
+ }
+ m = (c == 'y') ? sb.st_mode | S_IWGRP_OR_S_IWOTH
+ : sb.st_mode & ~(S_IWGRP|S_IWOTH);
+ if (fchmod(STDIN_FILENO, m) != 0)
+ bb_perror_nomsg_and_die();
+ return EXIT_SUCCESS;
+}
diff --git a/ap/app/busybox/src/init/reboot.h b/ap/app/busybox/src/init/reboot.h
new file mode 100644
index 0000000..9497639
--- /dev/null
+++ b/ap/app/busybox/src/init/reboot.h
@@ -0,0 +1,30 @@
+/*
+ * Definitions related to the reboot() system call,
+ * shared between init.c and halt.c.
+ */
+
+#include <sys/reboot.h>
+
+#ifndef RB_HALT_SYSTEM
+# if defined(__linux__)
+# define RB_HALT_SYSTEM 0xcdef0123
+# define RB_ENABLE_CAD 0x89abcdef
+# define RB_DISABLE_CAD 0
+# define RB_POWER_OFF 0x4321fedc
+# define RB_AUTOBOOT 0x01234567
+# elif defined(RB_HALT)
+# define RB_HALT_SYSTEM RB_HALT
+# endif
+#endif
+
+/* Stop system and switch power off if possible. */
+#ifndef RB_POWER_OFF
+# if defined(RB_POWERDOWN)
+# define RB_POWER_OFF RB_POWERDOWN
+# elif defined(__linux__)
+# define RB_POWER_OFF 0x4321fedc
+# else
+# warning "poweroff unsupported, using halt as fallback"
+# define RB_POWER_OFF RB_HALT_SYSTEM
+# endif
+#endif