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