source: branches/3.2/mindi-busybox/init/init.c @ 3232

Last change on this file since 3232 was 3232, checked in by bruno, 5 years ago
  • Update mindi-busybox to 1.21.1
File size: 39.9 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * Mini init implementation for busybox
4 *
5 * Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
6 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
7 * Adjusted by so many folks, it's impossible to keep track.
8 *
9 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
10 */
11
12//applet:IF_INIT(APPLET(init, BB_DIR_SBIN, BB_SUID_DROP))
13//applet:IF_FEATURE_INITRD(APPLET_ODDNAME(linuxrc, init, BB_DIR_ROOT, BB_SUID_DROP, linuxrc))
14
15//kbuild:lib-$(CONFIG_INIT) += init.o
16
17//config:config INIT
18//config:   bool "init"
19//config:   default y
20//config:   select FEATURE_SYSLOG
21//config:   help
22//config:     init is the first program run when the system boots.
23//config:
24//config:config FEATURE_USE_INITTAB
25//config:   bool "Support reading an inittab file"
26//config:   default y
27//config:   depends on INIT
28//config:   help
29//config:     Allow init to read an inittab file when the system boot.
30//config:
31//config:config FEATURE_KILL_REMOVED
32//config:   bool "Support killing processes that have been removed from inittab"
33//config:   default n
34//config:   depends on FEATURE_USE_INITTAB
35//config:   help
36//config:     When respawn entries are removed from inittab and a SIGHUP is
37//config:     sent to init, this option will make init kill the processes
38//config:     that have been removed.
39//config:
40//config:config FEATURE_KILL_DELAY
41//config:   int "How long to wait between TERM and KILL (0 - send TERM only)" if FEATURE_KILL_REMOVED
42//config:   range 0 1024
43//config:   default 0
44//config:   depends on FEATURE_KILL_REMOVED
45//config:   help
46//config:     With nonzero setting, init sends TERM, forks, child waits N
47//config:     seconds, sends KILL and exits. Setting it too high is unwise
48//config:     (child will hang around for too long and could actually kill
49//config:     the wrong process!)
50//config:
51//config:config FEATURE_INIT_SCTTY
52//config:   bool "Run commands with leading dash with controlling tty"
53//config:   default y
54//config:   depends on INIT
55//config:   help
56//config:     If this option is enabled, init will try to give a controlling
57//config:     tty to any command which has leading hyphen (often it's "-/bin/sh").
58//config:     More precisely, init will do "ioctl(STDIN_FILENO, TIOCSCTTY, 0)".
59//config:     If device attached to STDIN_FILENO can be a ctty but is not yet
60//config:     a ctty for other session, it will become this process' ctty.
61//config:     This is not the traditional init behavour, but is often what you want
62//config:     in an embedded system where the console is only accessed during
63//config:     development or for maintenance.
64//config:     NB: using cttyhack applet may work better.
65//config:
66//config:config FEATURE_INIT_SYSLOG
67//config:   bool "Enable init to write to syslog"
68//config:   default y
69//config:   depends on INIT
70//config:
71//config:config FEATURE_EXTRA_QUIET
72//config:   bool "Be _extra_ quiet on boot"
73//config:   default y
74//config:   depends on INIT
75//config:   help
76//config:     Prevent init from logging some messages to the console during boot.
77//config:
78//config:config FEATURE_INIT_COREDUMPS
79//config:   bool "Support dumping core for child processes (debugging only)"
80//config:   default y
81//config:   depends on INIT
82//config:   help
83//config:     If this option is enabled and the file /.init_enable_core
84//config:     exists, then init will call setrlimit() to allow unlimited
85//config:     core file sizes. If this option is disabled, processes
86//config:     will not generate any core files.
87//config:
88//config:config FEATURE_INITRD
89//config:   bool "Support running init from within an initrd (not initramfs)"
90//config:   default y
91//config:   depends on INIT
92//config:   help
93//config:     Legacy support for running init under the old-style initrd. Allows
94//config:     the name linuxrc to act as init, and it doesn't assume init is PID 1.
95//config:
96//config:     This does not apply to initramfs, which runs /init as PID 1 and
97//config:     requires no special support.
98//config:
99//config:config INIT_TERMINAL_TYPE
100//config:   string "Initial terminal type"
101//config:   default "linux"
102//config:   depends on INIT
103//config:   help
104//config:     This is the initial value set by init for the TERM environment
105//config:     variable. This variable is used by programs which make use of
106//config:     extended terminal capabilities.
107//config:
108//config:     Note that on Linux, init attempts to detect serial terminal and
109//config:     sets TERM to "vt102" if one is found.
110
111#define DEBUG_SEGV_HANDLER 0
112
113#include "libbb.h"
114#include <syslog.h>
115#include <paths.h>
116#include <sys/resource.h>
117#ifdef __linux__
118# include <linux/vt.h>
119# include <sys/sysinfo.h>
120#endif
121#include "reboot.h" /* reboot() constants */
122
123#if DEBUG_SEGV_HANDLER
124# undef _GNU_SOURCE
125# define _GNU_SOURCE 1
126# undef __USE_GNU
127# define __USE_GNU 1
128# include <execinfo.h>
129# include <sys/ucontext.h>
130#endif
131
132/* Used only for sanitizing purposes in set_sane_term() below. On systems where
133 * the baud rate is stored in a separate field, we can safely disable them. */
134#ifndef CBAUD
135# define CBAUD 0
136# define CBAUDEX 0
137#endif
138
139/* Was a CONFIG_xxx option. A lot of people were building
140 * not fully functional init by switching it on! */
141#define DEBUG_INIT 0
142
143#define COMMAND_SIZE      256
144#define CONSOLE_NAME_SIZE 32
145
146/* Default sysinit script. */
147#ifndef INIT_SCRIPT
148#define INIT_SCRIPT  "/etc/init.d/rcS"
149#endif
150
151/* Each type of actions can appear many times. They will be
152 * handled in order. RESTART is an exception, only 1st is used.
153 */
154/* Start these actions first and wait for completion */
155#define SYSINIT     0x01
156/* Start these after SYSINIT and wait for completion */
157#define WAIT        0x02
158/* Start these after WAIT and *dont* wait for completion */
159#define ONCE        0x04
160/*
161 * NB: while SYSINIT/WAIT/ONCE are being processed,
162 * SIGHUP ("reread /etc/inittab") will be processed only after
163 * each group of actions. If new inittab adds, say, a SYSINIT action,
164 * it will not be run, since init is already "past SYSINIT stage".
165 */
166/* Start these after ONCE are started, restart on exit */
167#define RESPAWN     0x08
168/* Like RESPAWN, but wait for <Enter> to be pressed on tty */
169#define ASKFIRST    0x10
170/*
171 * Start these on SIGINT, and wait for completion.
172 * Then go back to respawning RESPAWN and ASKFIRST actions.
173 * NB: kernel sends SIGINT to us if Ctrl-Alt-Del was pressed.
174 */
175#define CTRLALTDEL  0x20
176/*
177 * Start these before killing all processes in preparation for
178 * running RESTART actions or doing low-level halt/reboot/poweroff
179 * (initiated by SIGUSR1/SIGTERM/SIGUSR2).
180 * Wait for completion before proceeding.
181 */
182#define SHUTDOWN    0x40
183/*
184 * exec() on SIGQUIT. SHUTDOWN actions are started and waited for,
185 * then all processes are killed, then init exec's 1st RESTART action,
186 * replacing itself by it. If no RESTART action specified,
187 * SIGQUIT has no effect.
188 */
189#define RESTART     0x80
190
191
192/* A linked list of init_actions, to be read from inittab */
193struct init_action {
194    struct init_action *next;
195    pid_t pid;
196    uint8_t action_type;
197    char terminal[CONSOLE_NAME_SIZE];
198    char command[COMMAND_SIZE];
199};
200
201static struct init_action *init_action_list = NULL;
202
203static const char *log_console = VC_5;
204
205enum {
206    L_LOG = 0x1,
207    L_CONSOLE = 0x2,
208};
209
210/* Print a message to the specified device.
211 * "where" may be bitwise-or'd from L_LOG | L_CONSOLE
212 * NB: careful, we can be called after vfork!
213 */
214#define dbg_message(...) do { if (DEBUG_INIT) message(__VA_ARGS__); } while (0)
215static void message(int where, const char *fmt, ...)
216    __attribute__ ((format(printf, 2, 3)));
217static void message(int where, const char *fmt, ...)
218{
219    va_list arguments;
220    unsigned l;
221    char msg[128];
222
223    msg[0] = '\r';
224    va_start(arguments, fmt);
225    l = 1 + vsnprintf(msg + 1, sizeof(msg) - 2, fmt, arguments);
226    if (l > sizeof(msg) - 1)
227        l = sizeof(msg) - 1;
228    va_end(arguments);
229
230#if ENABLE_FEATURE_INIT_SYSLOG
231    msg[l] = '\0';
232    if (where & L_LOG) {
233        /* Log the message to syslogd */
234        openlog(applet_name, 0, LOG_DAEMON);
235        /* don't print "\r" */
236        syslog(LOG_INFO, "%s", msg + 1);
237        closelog();
238    }
239    msg[l++] = '\n';
240    msg[l] = '\0';
241#else
242    {
243        static int log_fd = -1;
244
245        msg[l++] = '\n';
246        msg[l] = '\0';
247        /* Take full control of the log tty, and never close it.
248         * It's mine, all mine!  Muhahahaha! */
249        if (log_fd < 0) {
250            if (!log_console) {
251                log_fd = STDERR_FILENO;
252            } else {
253                log_fd = device_open(log_console, O_WRONLY | O_NONBLOCK | O_NOCTTY);
254                if (log_fd < 0) {
255                    bb_error_msg("can't log to %s", log_console);
256                    where = L_CONSOLE;
257                } else {
258                    close_on_exec_on(log_fd);
259                }
260            }
261        }
262        if (where & L_LOG) {
263            full_write(log_fd, msg, l);
264            if (log_fd == STDERR_FILENO)
265                return; /* don't print dup messages */
266        }
267    }
268#endif
269
270    if (where & L_CONSOLE) {
271        /* Send console messages to console so people will see them. */
272        full_write(STDERR_FILENO, msg, l);
273    }
274}
275
276static void console_init(void)
277{
278#ifdef VT_OPENQRY
279    int vtno;
280#endif
281    char *s;
282
283    s = getenv("CONSOLE");
284    if (!s)
285        s = getenv("console");
286    if (s) {
287        int fd = open(s, O_RDWR | O_NONBLOCK | O_NOCTTY);
288        if (fd >= 0) {
289            dup2(fd, STDIN_FILENO);
290            dup2(fd, STDOUT_FILENO);
291            xmove_fd(fd, STDERR_FILENO);
292        }
293        dbg_message(L_LOG, "console='%s'", s);
294    } else {
295        /* Make sure fd 0,1,2 are not closed
296         * (so that they won't be used by future opens) */
297        bb_sanitize_stdio();
298// Users report problems
299//      /* Make sure init can't be blocked by writing to stderr */
300//      fcntl(STDERR_FILENO, F_SETFL, fcntl(STDERR_FILENO, F_GETFL) | O_NONBLOCK);
301    }
302
303    s = getenv("TERM");
304#ifdef VT_OPENQRY
305    if (ioctl(STDIN_FILENO, VT_OPENQRY, &vtno) != 0) {
306        /* Not a linux terminal, probably serial console.
307         * Force the TERM setting to vt102
308         * if TERM is set to linux (the default) */
309        if (!s || strcmp(s, "linux") == 0)
310            putenv((char*)"TERM=vt102");
311        if (!ENABLE_FEATURE_INIT_SYSLOG)
312            log_console = NULL;
313    } else
314#endif
315    if (!s)
316        putenv((char*)"TERM=" CONFIG_INIT_TERMINAL_TYPE);
317}
318
319/* Set terminal settings to reasonable defaults.
320 * NB: careful, we can be called after vfork! */
321static void set_sane_term(void)
322{
323    struct termios tty;
324
325    tcgetattr(STDIN_FILENO, &tty);
326
327    /* set control chars */
328    tty.c_cc[VINTR] = 3;    /* C-c */
329    tty.c_cc[VQUIT] = 28;   /* C-\ */
330    tty.c_cc[VERASE] = 127; /* C-? */
331    tty.c_cc[VKILL] = 21;   /* C-u */
332    tty.c_cc[VEOF] = 4; /* C-d */
333    tty.c_cc[VSTART] = 17;  /* C-q */
334    tty.c_cc[VSTOP] = 19;   /* C-s */
335    tty.c_cc[VSUSP] = 26;   /* C-z */
336
337#ifdef __linux__
338    /* use line discipline 0 */
339    tty.c_line = 0;
340#endif
341
342    /* Make it be sane */
343#ifndef CRTSCTS
344# define CRTSCTS 0
345#endif
346    /* added CRTSCTS to fix Debian bug 528560 */
347    tty.c_cflag &= CBAUD | CBAUDEX | CSIZE | CSTOPB | PARENB | PARODD | CRTSCTS;
348    tty.c_cflag |= CREAD | HUPCL | CLOCAL;
349
350    /* input modes */
351    tty.c_iflag = ICRNL | IXON | IXOFF;
352
353    /* output modes */
354    tty.c_oflag = OPOST | ONLCR;
355
356    /* local modes */
357    tty.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN;
358
359    tcsetattr_stdin_TCSANOW(&tty);
360}
361
362/* Open the new terminal device.
363 * NB: careful, we can be called after vfork! */
364static int open_stdio_to_tty(const char* tty_name)
365{
366    /* empty tty_name means "use init's tty", else... */
367    if (tty_name[0]) {
368        int fd;
369
370        close(STDIN_FILENO);
371        /* fd can be only < 0 or 0: */
372        fd = device_open(tty_name, O_RDWR);
373        if (fd) {
374            message(L_LOG | L_CONSOLE, "can't open %s: %s",
375                tty_name, strerror(errno));
376            return 0; /* failure */
377        }
378        dup2(STDIN_FILENO, STDOUT_FILENO);
379        dup2(STDIN_FILENO, STDERR_FILENO);
380    }
381    set_sane_term();
382    return 1; /* success */
383}
384
385static void reset_sighandlers_and_unblock_sigs(void)
386{
387    bb_signals(0
388        + (1 << SIGUSR1)
389        + (1 << SIGUSR2)
390        + (1 << SIGTERM)
391        + (1 << SIGQUIT)
392        + (1 << SIGINT)
393        + (1 << SIGHUP)
394        + (1 << SIGTSTP)
395        + (1 << SIGSTOP)
396        , SIG_DFL);
397    sigprocmask_allsigs(SIG_UNBLOCK);
398}
399
400/* Wrapper around exec:
401 * Takes string (max COMMAND_SIZE chars).
402 * If chars like '>' detected, execs '[-]/bin/sh -c "exec ......."'.
403 * Otherwise splits words on whitespace, deals with leading dash,
404 * and uses plain exec().
405 * NB: careful, we can be called after vfork!
406 */
407static void init_exec(const char *command)
408{
409    char *cmd[COMMAND_SIZE / 2];
410    char buf[COMMAND_SIZE + 6];  /* COMMAND_SIZE+strlen("exec ")+1 */
411    int dash = (command[0] == '-' /* maybe? && command[1] == '/' */);
412
413    command += dash;
414
415    /* See if any special /bin/sh requiring characters are present */
416    if (strpbrk(command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) {
417        sprintf(buf, "exec %s", command); /* excluding "-" */
418        /* NB: LIBBB_DEFAULT_LOGIN_SHELL define has leading dash */
419        cmd[0] = (char*)(LIBBB_DEFAULT_LOGIN_SHELL + !dash);
420        cmd[1] = (char*)"-c";
421        cmd[2] = buf;
422        cmd[3] = NULL;
423        command = LIBBB_DEFAULT_LOGIN_SHELL + 1;
424    } else {
425        /* Convert command (char*) into cmd (char**, one word per string) */
426        char *word, *next;
427        int i = 0;
428        next = strcpy(buf, command - dash); /* command including "-" */
429        command = next + dash;
430        while ((word = strsep(&next, " \t")) != NULL) {
431            if (*word != '\0') { /* not two spaces/tabs together? */
432                cmd[i] = word;
433                i++;
434            }
435        }
436        cmd[i] = NULL;
437    }
438    /* If we saw leading "-", it is interactive shell.
439     * Try harder to give it a controlling tty.
440     */
441    if (ENABLE_FEATURE_INIT_SCTTY && dash) {
442        /* _Attempt_ to make stdin a controlling tty. */
443        ioctl(STDIN_FILENO, TIOCSCTTY, 0 /*only try, don't steal*/);
444    }
445    /* Here command never contains the dash, cmd[0] might */
446    BB_EXECVP(command, cmd);
447    message(L_LOG | L_CONSOLE, "can't run '%s': %s", command, strerror(errno));
448    /* returns if execvp fails */
449}
450
451/* Used only by run_actions */
452static pid_t run(const struct init_action *a)
453{
454    pid_t pid;
455
456    /* Careful: don't be affected by a signal in vforked child */
457    sigprocmask_allsigs(SIG_BLOCK);
458    if (BB_MMU && (a->action_type & ASKFIRST))
459        pid = fork();
460    else
461        pid = vfork();
462    if (pid < 0)
463        message(L_LOG | L_CONSOLE, "can't fork");
464    if (pid) {
465        sigprocmask_allsigs(SIG_UNBLOCK);
466        return pid; /* Parent or error */
467    }
468
469    /* Child */
470
471    /* Reset signal handlers that were set by the parent process */
472    reset_sighandlers_and_unblock_sigs();
473
474    /* Create a new session and make ourself the process group leader */
475    setsid();
476
477    /* Open the new terminal device */
478    if (!open_stdio_to_tty(a->terminal))
479        _exit(EXIT_FAILURE);
480
481    /* NB: on NOMMU we can't wait for input in child, so
482     * "askfirst" will work the same as "respawn". */
483    if (BB_MMU && (a->action_type & ASKFIRST)) {
484        static const char press_enter[] ALIGN1 =
485#ifdef CUSTOMIZED_BANNER
486#include CUSTOMIZED_BANNER
487#endif
488            "\nPlease press Enter to activate this console. ";
489        char c;
490        /*
491         * Save memory by not exec-ing anything large (like a shell)
492         * before the user wants it. This is critical if swap is not
493         * enabled and the system has low memory. Generally this will
494         * be run on the second virtual console, and the first will
495         * be allowed to start a shell or whatever an init script
496         * specifies.
497         */
498        dbg_message(L_LOG, "waiting for enter to start '%s'"
499                    "(pid %d, tty '%s')\n",
500                a->command, getpid(), a->terminal);
501        full_write(STDOUT_FILENO, press_enter, sizeof(press_enter) - 1);
502        while (safe_read(STDIN_FILENO, &c, 1) == 1 && c != '\n')
503            continue;
504    }
505
506    /*
507     * When a file named /.init_enable_core exists, setrlimit is called
508     * before processes are spawned to set core file size as unlimited.
509     * This is for debugging only.  Don't use this is production, unless
510     * you want core dumps lying about....
511     */
512    if (ENABLE_FEATURE_INIT_COREDUMPS) {
513        if (access("/.init_enable_core", F_OK) == 0) {
514            struct rlimit limit;
515            limit.rlim_cur = RLIM_INFINITY;
516            limit.rlim_max = RLIM_INFINITY;
517            setrlimit(RLIMIT_CORE, &limit);
518        }
519    }
520
521    /* Log the process name and args */
522    message(L_LOG, "starting pid %d, tty '%s': '%s'",
523            getpid(), a->terminal, a->command);
524
525    /* Now run it.  The new program will take over this PID,
526     * so nothing further in init.c should be run. */
527    init_exec(a->command);
528    /* We're still here?  Some error happened. */
529    _exit(-1);
530}
531
532static struct init_action *mark_terminated(pid_t pid)
533{
534    struct init_action *a;
535
536    if (pid > 0) {
537        update_utmp(pid, DEAD_PROCESS,
538                /*tty_name:*/ NULL,
539                /*username:*/ NULL,
540                /*hostname:*/ NULL
541        );
542        for (a = init_action_list; a; a = a->next) {
543            if (a->pid == pid) {
544                a->pid = 0;
545                return a;
546            }
547        }
548    }
549    return NULL;
550}
551
552static void waitfor(pid_t pid)
553{
554    /* waitfor(run(x)): protect against failed fork inside run() */
555    if (pid <= 0)
556        return;
557
558    /* Wait for any child (prevent zombies from exiting orphaned processes)
559     * but exit the loop only when specified one has exited. */
560    while (1) {
561        pid_t wpid = wait(NULL);
562        mark_terminated(wpid);
563        /* Unsafe. SIGTSTP handler might have wait'ed it already */
564        /*if (wpid == pid) break;*/
565        /* More reliable: */
566        if (kill(pid, 0))
567            break;
568    }
569}
570
571/* Run all commands of a particular type */
572static void run_actions(int action_type)
573{
574    struct init_action *a;
575
576    for (a = init_action_list; a; a = a->next) {
577        if (!(a->action_type & action_type))
578            continue;
579
580        if (a->action_type & (SYSINIT | WAIT | ONCE | CTRLALTDEL | SHUTDOWN)) {
581            pid_t pid = run(a);
582            if (a->action_type & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN))
583                waitfor(pid);
584        }
585        if (a->action_type & (RESPAWN | ASKFIRST)) {
586            /* Only run stuff with pid == 0. If pid != 0,
587             * it is already running
588             */
589            if (a->pid == 0)
590                a->pid = run(a);
591        }
592    }
593}
594
595static void new_init_action(uint8_t action_type, const char *command, const char *cons)
596{
597    struct init_action *a, **nextp;
598
599    /* Scenario:
600     * old inittab:
601     * ::shutdown:umount -a -r
602     * ::shutdown:swapoff -a
603     * new inittab:
604     * ::shutdown:swapoff -a
605     * ::shutdown:umount -a -r
606     * On reload, we must ensure entries end up in correct order.
607     * To achieve that, if we find a matching entry, we move it
608     * to the end.
609     */
610    nextp = &init_action_list;
611    while ((a = *nextp) != NULL) {
612        /* Don't enter action if it's already in the list.
613         * This prevents losing running RESPAWNs.
614         */
615        if (strcmp(a->command, command) == 0
616         && strcmp(a->terminal, cons) == 0
617        ) {
618            /* Remove from list */
619            *nextp = a->next;
620            /* Find the end of the list */
621            while (*nextp != NULL)
622                nextp = &(*nextp)->next;
623            a->next = NULL;
624            goto append;
625        }
626        nextp = &a->next;
627    }
628
629    a = xzalloc(sizeof(*a));
630
631    /* Append to the end of the list */
632 append:
633    *nextp = a;
634    a->action_type = action_type;
635    safe_strncpy(a->command, command, sizeof(a->command));
636    safe_strncpy(a->terminal, cons, sizeof(a->terminal));
637    dbg_message(L_LOG | L_CONSOLE, "command='%s' action=%d tty='%s'\n",
638        a->command, a->action_type, a->terminal);
639}
640
641/* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
642 * then parse_inittab() simply adds in some default
643 * actions(i.e., runs INIT_SCRIPT and then starts a pair
644 * of "askfirst" shells).  If CONFIG_FEATURE_USE_INITTAB
645 * _is_ defined, but /etc/inittab is missing, this
646 * results in the same set of default behaviors.
647 */
648static void parse_inittab(void)
649{
650#if ENABLE_FEATURE_USE_INITTAB
651    char *token[4];
652    parser_t *parser = config_open2("/etc/inittab", fopen_for_read);
653
654    if (parser == NULL)
655#endif
656    {
657        /* No inittab file - set up some default behavior */
658        /* Reboot on Ctrl-Alt-Del */
659        new_init_action(CTRLALTDEL, "reboot", "");
660        /* Umount all filesystems on halt/reboot */
661        new_init_action(SHUTDOWN, "umount -a -r", "");
662        /* Swapoff on halt/reboot */
663        if (ENABLE_SWAPONOFF)
664            new_init_action(SHUTDOWN, "swapoff -a", "");
665        /* Prepare to restart init when a QUIT is received */
666        new_init_action(RESTART, "init", "");
667        /* Askfirst shell on tty1-4 */
668        new_init_action(ASKFIRST, bb_default_login_shell, "");
669//TODO: VC_1 instead of ""? "" is console -> ctty problems -> angry users
670        new_init_action(ASKFIRST, bb_default_login_shell, VC_2);
671        new_init_action(ASKFIRST, bb_default_login_shell, VC_3);
672        new_init_action(ASKFIRST, bb_default_login_shell, VC_4);
673        /* sysinit */
674        new_init_action(SYSINIT, INIT_SCRIPT, "");
675        return;
676    }
677
678#if ENABLE_FEATURE_USE_INITTAB
679    /* optional_tty:ignored_runlevel:action:command
680     * Delims are not to be collapsed and need exactly 4 tokens
681     */
682    while (config_read(parser, token, 4, 0, "#:",
683                PARSE_NORMAL & ~(PARSE_TRIM | PARSE_COLLAPSE))) {
684        /* order must correspond to SYSINIT..RESTART constants */
685        static const char actions[] ALIGN1 =
686            "sysinit\0""wait\0""once\0""respawn\0""askfirst\0"
687            "ctrlaltdel\0""shutdown\0""restart\0";
688        int action;
689        char *tty = token[0];
690
691        if (!token[3]) /* less than 4 tokens */
692            goto bad_entry;
693        action = index_in_strings(actions, token[2]);
694        if (action < 0 || !token[3][0]) /* token[3]: command */
695            goto bad_entry;
696        /* turn .*TTY -> /dev/TTY */
697        if (tty[0]) {
698            tty = concat_path_file("/dev/", skip_dev_pfx(tty));
699        }
700        new_init_action(1 << action, token[3], tty);
701        if (tty[0])
702            free(tty);
703        continue;
704 bad_entry:
705        message(L_LOG | L_CONSOLE, "Bad inittab entry at line %d",
706                parser->lineno);
707    }
708    config_close(parser);
709#endif
710}
711
712static void pause_and_low_level_reboot(unsigned magic) NORETURN;
713static void pause_and_low_level_reboot(unsigned magic)
714{
715    pid_t pid;
716
717    /* Allow time for last message to reach serial console, etc */
718    sleep(1);
719
720    /* We have to fork here, since the kernel calls do_exit(EXIT_SUCCESS)
721     * in linux/kernel/sys.c, which can cause the machine to panic when
722     * the init process exits... */
723    pid = vfork();
724    if (pid == 0) { /* child */
725        reboot(magic);
726        _exit(EXIT_SUCCESS);
727    }
728    while (1)
729        sleep(1);
730}
731
732static void run_shutdown_and_kill_processes(void)
733{
734    /* Run everything to be run at "shutdown".  This is done _prior_
735     * to killing everything, in case people wish to use scripts to
736     * shut things down gracefully... */
737    run_actions(SHUTDOWN);
738
739    message(L_CONSOLE | L_LOG, "The system is going down NOW!");
740
741    /* Send signals to every process _except_ pid 1 */
742    kill(-1, SIGTERM);
743    message(L_CONSOLE | L_LOG, "Sent SIG%s to all processes", "TERM");
744    sync();
745    sleep(1);
746
747    kill(-1, SIGKILL);
748    message(L_CONSOLE, "Sent SIG%s to all processes", "KILL");
749    sync();
750    /*sleep(1); - callers take care about making a pause */
751}
752
753/* Signal handling by init:
754 *
755 * For process with PID==1, on entry kernel sets all signals to SIG_DFL
756 * and unmasks all signals. However, for process with PID==1,
757 * default action (SIG_DFL) on any signal is to ignore it,
758 * even for special signals SIGKILL and SIGCONT.
759 * Also, any signal can be caught or blocked.
760 * (but SIGSTOP is still handled specially, at least in 2.6.20)
761 *
762 * We install two kinds of handlers, "immediate" and "delayed".
763 *
764 * Immediate handlers execute at any time, even while, say, sysinit
765 * is running.
766 *
767 * Delayed handlers just set a flag variable. The variable is checked
768 * in the main loop and acted upon.
769 *
770 * halt/poweroff/reboot and restart have immediate handlers.
771 * They only traverse linked list of struct action's, never modify it,
772 * this should be safe to do even in signal handler. Also they
773 * never return.
774 *
775 * SIGSTOP and SIGTSTP have immediate handlers. They just wait
776 * for SIGCONT to happen.
777 *
778 * SIGHUP has a delayed handler, because modifying linked list
779 * of struct action's from a signal handler while it is manipulated
780 * by the program may be disastrous.
781 *
782 * Ctrl-Alt-Del has a delayed handler. Not a must, but allowing
783 * it to happen even somewhere inside "sysinit" would be a bit awkward.
784 *
785 * There is a tiny probability that SIGHUP and Ctrl-Alt-Del will collide
786 * and only one will be remembered and acted upon.
787 */
788
789/* The SIGUSR[12]/SIGTERM handler */
790static void halt_reboot_pwoff(int sig) NORETURN;
791static void halt_reboot_pwoff(int sig)
792{
793    const char *m;
794    unsigned rb;
795
796    /* We may call run() and it unmasks signals,
797     * including the one masked inside this signal handler.
798     * Testcase which would start multiple reboot scripts:
799     *  while true; do reboot; done
800     * Preventing it:
801     */
802    reset_sighandlers_and_unblock_sigs();
803
804    run_shutdown_and_kill_processes();
805
806    m = "halt";
807    rb = RB_HALT_SYSTEM;
808    if (sig == SIGTERM) {
809        m = "reboot";
810        rb = RB_AUTOBOOT;
811    } else if (sig == SIGUSR2) {
812        m = "poweroff";
813        rb = RB_POWER_OFF;
814    }
815    message(L_CONSOLE, "Requesting system %s", m);
816    pause_and_low_level_reboot(rb);
817    /* not reached */
818}
819
820/* Handler for QUIT - exec "restart" action,
821 * else (no such action defined) do nothing */
822static void restart_handler(int sig UNUSED_PARAM)
823{
824    struct init_action *a;
825
826    for (a = init_action_list; a; a = a->next) {
827        if (!(a->action_type & RESTART))
828            continue;
829
830        /* Starting from here, we won't return.
831         * Thus don't need to worry about preserving errno
832         * and such.
833         */
834
835        reset_sighandlers_and_unblock_sigs();
836
837        run_shutdown_and_kill_processes();
838
839#ifdef RB_ENABLE_CAD
840        /* Allow Ctrl-Alt-Del to reboot the system.
841         * This is how kernel sets it up for init, we follow suit.
842         */
843        reboot(RB_ENABLE_CAD); /* misnomer */
844#endif
845
846        if (open_stdio_to_tty(a->terminal)) {
847            dbg_message(L_CONSOLE, "Trying to re-exec %s", a->command);
848            /* Theoretically should be safe.
849             * But in practice, kernel bugs may leave
850             * unkillable processes, and wait() may block forever.
851             * Oh well. Hoping "new" init won't be too surprised
852             * by having children it didn't create.
853             */
854            //while (wait(NULL) > 0)
855            //  continue;
856            init_exec(a->command);
857        }
858        /* Open or exec failed */
859        pause_and_low_level_reboot(RB_HALT_SYSTEM);
860        /* not reached */
861    }
862}
863
864/* The SIGSTOP/SIGTSTP handler
865 * NB: inside it, all signals except SIGCONT are masked
866 * via appropriate setup in sigaction().
867 */
868static void stop_handler(int sig UNUSED_PARAM)
869{
870    smallint saved_bb_got_signal;
871    int saved_errno;
872
873    saved_bb_got_signal = bb_got_signal;
874    saved_errno = errno;
875    signal(SIGCONT, record_signo);
876
877    while (1) {
878        pid_t wpid;
879
880        if (bb_got_signal == SIGCONT)
881            break;
882        /* NB: this can accidentally wait() for a process
883         * which we waitfor() elsewhere! waitfor() must have
884         * code which is resilient against this.
885         */
886        wpid = wait_any_nohang(NULL);
887        mark_terminated(wpid);
888        sleep(1);
889    }
890
891    signal(SIGCONT, SIG_DFL);
892    errno = saved_errno;
893    bb_got_signal = saved_bb_got_signal;
894}
895
896#if ENABLE_FEATURE_USE_INITTAB
897static void reload_inittab(void)
898{
899    struct init_action *a, **nextp;
900
901    message(L_LOG, "reloading /etc/inittab");
902
903    /* Disable old entries */
904    for (a = init_action_list; a; a = a->next)
905        a->action_type = 0;
906
907    /* Append new entries, or modify existing entries
908     * (incl. setting a->action_type) if cmd and device name
909     * match new ones. End result: only entries with
910     * a->action_type == 0 are stale.
911     */
912    parse_inittab();
913
914#if ENABLE_FEATURE_KILL_REMOVED
915    /* Kill stale entries */
916    /* Be nice and send SIGTERM first */
917    for (a = init_action_list; a; a = a->next)
918        if (a->action_type == 0 && a->pid != 0)
919            kill(a->pid, SIGTERM);
920    if (CONFIG_FEATURE_KILL_DELAY) {
921        /* NB: parent will wait in NOMMU case */
922        if ((BB_MMU ? fork() : vfork()) == 0) { /* child */
923            sleep(CONFIG_FEATURE_KILL_DELAY);
924            for (a = init_action_list; a; a = a->next)
925                if (a->action_type == 0 && a->pid != 0)
926                    kill(a->pid, SIGKILL);
927            _exit(EXIT_SUCCESS);
928        }
929    }
930#endif
931
932    /* Remove stale entries and SYSINIT entries.
933     * We never rerun SYSINIT entries anyway,
934     * removing them too saves a few bytes */
935    nextp = &init_action_list;
936    while ((a = *nextp) != NULL) {
937        if ((a->action_type & ~SYSINIT) == 0) {
938            *nextp = a->next;
939            free(a);
940        } else {
941            nextp = &a->next;
942        }
943    }
944
945    /* Not needed: */
946    /* run_actions(RESPAWN | ASKFIRST); */
947    /* - we return to main loop, which does this automagically */
948}
949#endif
950
951static int check_delayed_sigs(void)
952{
953    int sigs_seen = 0;
954
955    while (1) {
956        smallint sig = bb_got_signal;
957
958        if (!sig)
959            return sigs_seen;
960        bb_got_signal = 0;
961        sigs_seen = 1;
962#if ENABLE_FEATURE_USE_INITTAB
963        if (sig == SIGHUP)
964            reload_inittab();
965#endif
966        if (sig == SIGINT)
967            run_actions(CTRLALTDEL);
968    }
969}
970
971#if DEBUG_SEGV_HANDLER
972static
973void handle_sigsegv(int sig, siginfo_t *info, void *ucontext)
974{
975    long ip;
976    ucontext_t *uc;
977
978    uc = ucontext;
979    ip = uc->uc_mcontext.gregs[REG_EIP];
980    fdprintf(2, "signal:%d address:0x%lx ip:0x%lx\n",
981            sig,
982            /* this is void*, but using %p would print "(null)"
983             * even for ptrs which are not exactly 0, but, say, 0x123:
984             */
985            (long)info->si_addr,
986            ip);
987    {
988        /* glibc extension */
989        void *array[50];
990        int size;
991        size = backtrace(array, 50);
992        backtrace_symbols_fd(array, size, 2);
993    }
994    for (;;) sleep(9999);
995}
996#endif
997
998int init_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
999int init_main(int argc UNUSED_PARAM, char **argv)
1000{
1001    if (argv[1] && strcmp(argv[1], "-q") == 0) {
1002        return kill(1, SIGHUP);
1003    }
1004
1005#if DEBUG_SEGV_HANDLER
1006    {
1007        struct sigaction sa;
1008        memset(&sa, 0, sizeof(sa));
1009        sa.sa_sigaction = handle_sigsegv;
1010        sa.sa_flags = SA_SIGINFO;
1011        sigaction(SIGSEGV, &sa, NULL);
1012        sigaction(SIGILL, &sa, NULL);
1013        sigaction(SIGFPE, &sa, NULL);
1014        sigaction(SIGBUS, &sa, NULL);
1015    }
1016#endif
1017
1018    if (!DEBUG_INIT) {
1019        /* Expect to be invoked as init with PID=1 or be invoked as linuxrc */
1020        if (getpid() != 1
1021         && (!ENABLE_FEATURE_INITRD || applet_name[0] != 'l') /* not linuxrc? */
1022        ) {
1023            bb_error_msg_and_die("must be run as PID 1");
1024        }
1025#ifdef RB_DISABLE_CAD
1026        /* Turn off rebooting via CTL-ALT-DEL - we get a
1027         * SIGINT on CAD so we can shut things down gracefully... */
1028        reboot(RB_DISABLE_CAD); /* misnomer */
1029#endif
1030    }
1031
1032    /* If, say, xmalloc would ever die, we don't want to oops kernel
1033     * by exiting.
1034     * NB: we set die_sleep *after* PID 1 check and bb_show_usage.
1035     * Otherwise, for example, "init u" ("please rexec yourself"
1036     * command for sysvinit) will show help text (which isn't too bad),
1037     * *and sleep forever* (which is bad!)
1038     */
1039    die_sleep = 30 * 24*60*60;
1040
1041    /* Figure out where the default console should be */
1042    console_init();
1043    set_sane_term();
1044    xchdir("/");
1045    setsid();
1046
1047    /* Make sure environs is set to something sane */
1048    putenv((char *) "HOME=/");
1049    putenv((char *) bb_PATH_root_path);
1050    putenv((char *) "SHELL=/bin/sh");
1051    putenv((char *) "USER=root"); /* needed? why? */
1052
1053    if (argv[1])
1054        xsetenv("RUNLEVEL", argv[1]);
1055
1056#if !ENABLE_FEATURE_EXTRA_QUIET
1057    /* Hello world */
1058    message(L_CONSOLE | L_LOG, "init started: %s", bb_banner);
1059#endif
1060
1061/* struct sysinfo is linux-specific */
1062#ifdef __linux__
1063    /* Make sure there is enough memory to do something useful. */
1064    if (ENABLE_SWAPONOFF) {
1065        struct sysinfo info;
1066
1067        if (sysinfo(&info) == 0
1068         && (info.mem_unit ? info.mem_unit : 1) * (long long)info.totalram < 1024*1024
1069        ) {
1070            message(L_CONSOLE, "Low memory, forcing swapon");
1071            /* swapon -a requires /proc typically */
1072            new_init_action(SYSINIT, "mount -t proc proc /proc", "");
1073            /* Try to turn on swap */
1074            new_init_action(SYSINIT, "swapon -a", "");
1075            run_actions(SYSINIT);   /* wait and removing */
1076        }
1077    }
1078#endif
1079
1080    /* Check if we are supposed to be in single user mode */
1081    if (argv[1]
1082     && (strcmp(argv[1], "single") == 0 || strcmp(argv[1], "-s") == 0 || LONE_CHAR(argv[1], '1'))
1083    ) {
1084        /* ??? shouldn't we set RUNLEVEL="b" here? */
1085        /* Start a shell on console */
1086        new_init_action(RESPAWN, bb_default_login_shell, "");
1087    } else {
1088        /* Not in single user mode - see what inittab says */
1089
1090        /* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
1091         * then parse_inittab() simply adds in some default
1092         * actions(i.e., INIT_SCRIPT and a pair
1093         * of "askfirst" shells */
1094        parse_inittab();
1095    }
1096
1097#if ENABLE_SELINUX
1098    if (getenv("SELINUX_INIT") == NULL) {
1099        int enforce = 0;
1100
1101        putenv((char*)"SELINUX_INIT=YES");
1102        if (selinux_init_load_policy(&enforce) == 0) {
1103            BB_EXECVP(argv[0], argv);
1104        } else if (enforce > 0) {
1105            /* SELinux in enforcing mode but load_policy failed */
1106            message(L_CONSOLE, "can't load SELinux Policy. "
1107                "Machine is in enforcing mode. Halting now.");
1108            return EXIT_FAILURE;
1109        }
1110    }
1111#endif
1112
1113    /* Make the command line just say "init"  - thats all, nothing else */
1114    strncpy(argv[0], "init", strlen(argv[0]));
1115    /* Wipe argv[1]-argv[N] so they don't clutter the ps listing */
1116    while (*++argv)
1117        memset(*argv, 0, strlen(*argv));
1118
1119    /* Set up signal handlers */
1120    if (!DEBUG_INIT) {
1121        struct sigaction sa;
1122
1123        bb_signals(0
1124            + (1 << SIGUSR1) /* halt */
1125            + (1 << SIGTERM) /* reboot */
1126            + (1 << SIGUSR2) /* poweroff */
1127            , halt_reboot_pwoff);
1128        signal(SIGQUIT, restart_handler); /* re-exec another init */
1129
1130        /* Stop handler must allow only SIGCONT inside itself */
1131        memset(&sa, 0, sizeof(sa));
1132        sigfillset(&sa.sa_mask);
1133        sigdelset(&sa.sa_mask, SIGCONT);
1134        sa.sa_handler = stop_handler;
1135        /* NB: sa_flags doesn't have SA_RESTART.
1136         * It must be able to interrupt wait().
1137         */
1138        sigaction_set(SIGTSTP, &sa); /* pause */
1139        /* Does not work as intended, at least in 2.6.20.
1140         * SIGSTOP is simply ignored by init:
1141         */
1142        sigaction_set(SIGSTOP, &sa); /* pause */
1143
1144        /* SIGINT (Ctrl-Alt-Del) must interrupt wait(),
1145         * setting handler without SA_RESTART flag.
1146         */
1147        bb_signals_recursive_norestart((1 << SIGINT), record_signo);
1148    }
1149
1150    /* Set up "reread /etc/inittab" handler.
1151     * Handler is set up without SA_RESTART, it will interrupt syscalls.
1152     */
1153    if (!DEBUG_INIT && ENABLE_FEATURE_USE_INITTAB)
1154        bb_signals_recursive_norestart((1 << SIGHUP), record_signo);
1155
1156    /* Now run everything that needs to be run */
1157    /* First run the sysinit command */
1158    run_actions(SYSINIT);
1159    check_delayed_sigs();
1160    /* Next run anything that wants to block */
1161    run_actions(WAIT);
1162    check_delayed_sigs();
1163    /* Next run anything to be run only once */
1164    run_actions(ONCE);
1165
1166    /* Now run the looping stuff for the rest of forever.
1167     */
1168    while (1) {
1169        int maybe_WNOHANG;
1170
1171        maybe_WNOHANG = check_delayed_sigs();
1172
1173        /* (Re)run the respawn/askfirst stuff */
1174        run_actions(RESPAWN | ASKFIRST);
1175        maybe_WNOHANG |= check_delayed_sigs();
1176
1177        /* Don't consume all CPU time - sleep a bit */
1178        sleep(1);
1179        maybe_WNOHANG |= check_delayed_sigs();
1180
1181        /* Wait for any child process(es) to exit.
1182         *
1183         * If check_delayed_sigs above reported that a signal
1184         * was caught, wait will be nonblocking. This ensures
1185         * that if SIGHUP has reloaded inittab, respawn and askfirst
1186         * actions will not be delayed until next child death.
1187         */
1188        if (maybe_WNOHANG)
1189            maybe_WNOHANG = WNOHANG;
1190        while (1) {
1191            pid_t wpid;
1192            struct init_action *a;
1193
1194            /* If signals happen _in_ the wait, they interrupt it,
1195             * bb_signals_recursive_norestart set them up that way
1196             */
1197            wpid = waitpid(-1, NULL, maybe_WNOHANG);
1198            if (wpid <= 0)
1199                break;
1200
1201            a = mark_terminated(wpid);
1202            if (a) {
1203                message(L_LOG, "process '%s' (pid %d) exited. "
1204                        "Scheduling for restart.",
1205                        a->command, wpid);
1206            }
1207            /* See if anyone else is waiting to be reaped */
1208            maybe_WNOHANG = WNOHANG;
1209        }
1210    } /* while (1) */
1211}
1212
1213//usage:#define linuxrc_trivial_usage NOUSAGE_STR
1214//usage:#define linuxrc_full_usage ""
1215
1216//usage:#define init_trivial_usage
1217//usage:       ""
1218//usage:#define init_full_usage "\n\n"
1219//usage:       "Init is the parent of all processes"
1220//usage:
1221//usage:#define init_notes_usage
1222//usage:    "This version of init is designed to be run only by the kernel.\n"
1223//usage:    "\n"
1224//usage:    "BusyBox init doesn't support multiple runlevels. The runlevels field of\n"
1225//usage:    "the /etc/inittab file is completely ignored by BusyBox init. If you want\n"
1226//usage:    "runlevels, use sysvinit.\n"
1227//usage:    "\n"
1228//usage:    "BusyBox init works just fine without an inittab. If no inittab is found,\n"
1229//usage:    "it has the following default behavior:\n"
1230//usage:    "\n"
1231//usage:    "   ::sysinit:/etc/init.d/rcS\n"
1232//usage:    "   ::askfirst:/bin/sh\n"
1233//usage:    "   ::ctrlaltdel:/sbin/reboot\n"
1234//usage:    "   ::shutdown:/sbin/swapoff -a\n"
1235//usage:    "   ::shutdown:/bin/umount -a -r\n"
1236//usage:    "   ::restart:/sbin/init\n"
1237//usage:    "\n"
1238//usage:    "if it detects that /dev/console is _not_ a serial console, it will also run:\n"
1239//usage:    "\n"
1240//usage:    "   tty2::askfirst:/bin/sh\n"
1241//usage:    "   tty3::askfirst:/bin/sh\n"
1242//usage:    "   tty4::askfirst:/bin/sh\n"
1243//usage:    "\n"
1244//usage:    "If you choose to use an /etc/inittab file, the inittab entry format is as follows:\n"
1245//usage:    "\n"
1246//usage:    "   <id>:<runlevels>:<action>:<process>\n"
1247//usage:    "\n"
1248//usage:    "   <id>:\n"
1249//usage:    "\n"
1250//usage:    "       WARNING: This field has a non-traditional meaning for BusyBox init!\n"
1251//usage:    "       The id field is used by BusyBox init to specify the controlling tty for\n"
1252//usage:    "       the specified process to run on. The contents of this field are\n"
1253//usage:    "       appended to \"/dev/\" and used as-is. There is no need for this field to\n"
1254//usage:    "       be unique, although if it isn't you may have strange results. If this\n"
1255//usage:    "       field is left blank, the controlling tty is set to the console. Also\n"
1256//usage:    "       note that if BusyBox detects that a serial console is in use, then only\n"
1257//usage:    "       entries whose controlling tty is either the serial console or /dev/null\n"
1258//usage:    "       will be run. BusyBox init does nothing with utmp. We don't need no\n"
1259//usage:    "       stinkin' utmp.\n"
1260//usage:    "\n"
1261//usage:    "   <runlevels>:\n"
1262//usage:    "\n"
1263//usage:    "       The runlevels field is completely ignored.\n"
1264//usage:    "\n"
1265//usage:    "   <action>:\n"
1266//usage:    "\n"
1267//usage:    "       Valid actions include: sysinit, respawn, askfirst, wait,\n"
1268//usage:    "       once, restart, ctrlaltdel, and shutdown.\n"
1269//usage:    "\n"
1270//usage:    "       The available actions can be classified into two groups: actions\n"
1271//usage:    "       that are run only once, and actions that are re-run when the specified\n"
1272//usage:    "       process exits.\n"
1273//usage:    "\n"
1274//usage:    "       Run only-once actions:\n"
1275//usage:    "\n"
1276//usage:    "           'sysinit' is the first item run on boot. init waits until all\n"
1277//usage:    "           sysinit actions are completed before continuing. Following the\n"
1278//usage:    "           completion of all sysinit actions, all 'wait' actions are run.\n"
1279//usage:    "           'wait' actions, like 'sysinit' actions, cause init to wait until\n"
1280//usage:    "           the specified task completes. 'once' actions are asynchronous,\n"
1281//usage:    "           therefore, init does not wait for them to complete. 'restart' is\n"
1282//usage:    "           the action taken to restart the init process. By default this should\n"
1283//usage:    "           simply run /sbin/init, but can be a script which runs pivot_root or it\n"
1284//usage:    "           can do all sorts of other interesting things. The 'ctrlaltdel' init\n"
1285//usage:    "           actions are run when the system detects that someone on the system\n"
1286//usage:    "           console has pressed the CTRL-ALT-DEL key combination. Typically one\n"
1287//usage:    "           wants to run 'reboot' at this point to cause the system to reboot.\n"
1288//usage:    "           Finally the 'shutdown' action specifies the actions to taken when\n"
1289//usage:    "           init is told to reboot. Unmounting filesystems and disabling swap\n"
1290//usage:    "           is a very good here.\n"
1291//usage:    "\n"
1292//usage:    "       Run repeatedly actions:\n"
1293//usage:    "\n"
1294//usage:    "           'respawn' actions are run after the 'once' actions. When a process\n"
1295//usage:    "           started with a 'respawn' action exits, init automatically restarts\n"
1296//usage:    "           it. Unlike sysvinit, BusyBox init does not stop processes from\n"
1297//usage:    "           respawning out of control. The 'askfirst' actions acts just like\n"
1298//usage:    "           respawn, except that before running the specified process it\n"
1299//usage:    "           displays the line \"Please press Enter to activate this console.\"\n"
1300//usage:    "           and then waits for the user to press enter before starting the\n"
1301//usage:    "           specified process.\n"
1302//usage:    "\n"
1303//usage:    "       Unrecognized actions (like initdefault) will cause init to emit an\n"
1304//usage:    "       error message, and then go along with its business. All actions are\n"
1305//usage:    "       run in the order they appear in /etc/inittab.\n"
1306//usage:    "\n"
1307//usage:    "   <process>:\n"
1308//usage:    "\n"
1309//usage:    "       Specifies the process to be executed and its command line.\n"
1310//usage:    "\n"
1311//usage:    "Example /etc/inittab file:\n"
1312//usage:    "\n"
1313//usage:    "   # This is run first except when booting in single-user mode\n"
1314//usage:    "   #\n"
1315//usage:    "   ::sysinit:/etc/init.d/rcS\n"
1316//usage:    "   \n"
1317//usage:    "   # /bin/sh invocations on selected ttys\n"
1318//usage:    "   #\n"
1319//usage:    "   # Start an \"askfirst\" shell on the console (whatever that may be)\n"
1320//usage:    "   ::askfirst:-/bin/sh\n"
1321//usage:    "   # Start an \"askfirst\" shell on /dev/tty2-4\n"
1322//usage:    "   tty2::askfirst:-/bin/sh\n"
1323//usage:    "   tty3::askfirst:-/bin/sh\n"
1324//usage:    "   tty4::askfirst:-/bin/sh\n"
1325//usage:    "   \n"
1326//usage:    "   # /sbin/getty invocations for selected ttys\n"
1327//usage:    "   #\n"
1328//usage:    "   tty4::respawn:/sbin/getty 38400 tty4\n"
1329//usage:    "   tty5::respawn:/sbin/getty 38400 tty5\n"
1330//usage:    "   \n"
1331//usage:    "   \n"
1332//usage:    "   # Example of how to put a getty on a serial line (for a terminal)\n"
1333//usage:    "   #\n"
1334//usage:    "   #::respawn:/sbin/getty -L ttyS0 9600 vt100\n"
1335//usage:    "   #::respawn:/sbin/getty -L ttyS1 9600 vt100\n"
1336//usage:    "   #\n"
1337//usage:    "   # Example how to put a getty on a modem line\n"
1338//usage:    "   #::respawn:/sbin/getty 57600 ttyS2\n"
1339//usage:    "   \n"
1340//usage:    "   # Stuff to do when restarting the init process\n"
1341//usage:    "   ::restart:/sbin/init\n"
1342//usage:    "   \n"
1343//usage:    "   # Stuff to do before rebooting\n"
1344//usage:    "   ::ctrlaltdel:/sbin/reboot\n"
1345//usage:    "   ::shutdown:/bin/umount -a -r\n"
1346//usage:    "   ::shutdown:/sbin/swapoff -a\n"
Note: See TracBrowser for help on using the repository browser.