--- name: "init" section: "8" platform: "linux" package: "sysvinit-core" version: "3.14-4" release: "Debian 13 (Trixie)" platforms: ["linux", "freebsd", "openbsd"] url: "https://new.carta.tech/init/8" --- # init(8) process control initialization ## NAME init, telinit - process control initialization ## SYNOPSIS **/sbin/init** \[ **-a** \] \[ **-s** \] \[ **-b** \] \[ **-z** *xxx* \] \[ **0123456Ss** \]\ **/sbin/init** \[ **--version** \]\ **/sbin/telinit** \[ **-t** *SECONDS* \] \[ **0123456sSQqabcUu** \]\ **/sbin/telinit** \[ **-e** *VAR*\[**=***VAL*\] \] ## DESCRIPTION ### Init **init** is the parent of all processes. Its primary role is to create processes from a script stored in the file */etc/inittab* (see [**inittab**(5)](/inittab/5.md)). This file usually has entries which cause **init** to spawn **getty**s on each line that users can log in. It also controls autonomous processes required by any particular system. ## RUNLEVELS A *runlevel* is a software configuration of the system which allows only a selected group of processes to exist. The processes spawned by **init** for each of these runlevels are defined in the */etc/inittab* file. **init** can be in one of eight runlevels: **0–6** and **S** (a.k.a., **s**). The runlevel is changed by having a privileged user run **telinit**, which sends appropriate signals to **init**, telling it which runlevel to change to. Runlevels **S**, **0**, **1**, and **6** are reserved. Runlevel S is used to initialize the system on boot. When starting runlevel S (on boot) or runlevel 1 (switching from a multi-user runlevel) the system is entering \`\`single-user mode'', after which the current runlevel is S. Runlevel 0 is used to halt the system; runlevel 6 is used to reboot the system. After booting through S the system automatically enters one of the multi-user runlevels 2 through 5, unless there was some problem that needs to be fixed by the administrator in single-user mode. Normally after entering single-user mode the administrator performs maintenance and then reboots the system. For more information, see the manpages for [**shutdown**(8)](/shutdown/8.md) and [**inittab**(5)](/inittab/5.md). Runlevels 7–9 are also valid, though not really documented. This is because "traditional" Unix variants don't use them. Runlevels *S* and *s* are the same. Internally they are aliases for the same runlevel. ## BOOTING After **init** is invoked as the last step of the kernel boot sequence, it looks for the file */etc/inittab* to see if there is an entry of the type **initdefault** (see [**inittab**(5)](/inittab/5.md)). The **initdefault** entry determines the initial runlevel of the system. If there is no such entry (or no */etc/inittab* at all), a runlevel must be entered at the system console. Runlevel **S** or **s** initialize the system and do not require an */etc/inittab* file. In single user mode, **/sbin/sulogin** is invoked on */dev/console*. When entering single user mode, **init** initializes the consoles **stty** settings to sane values. Clocal mode is set. Hardware speed and handshaking are not changed. When entering a multi-user mode for the first time, **init** performs the **boot** and **bootwait** entries to allow file systems to be mounted before users can log in. Then all entries matching the runlevel are processed. When starting a new process, **init** first checks whether the file */etc/initscript* exists. If it does, it uses this script to start the process. Each time a child terminates, **init** records the fact and the reason it died in */var/run/utmp* and */var/log/wtmp*, provided that these files exist. ## CHANGING RUNLEVELS After it has spawned all of the processes specified, **init** waits for one of its descendant processes to die, a powerfail signal, or until it is signaled by **telinit** to change the system's runlevel. When one of the above three conditions occurs, it re-examines the */etc/inittab* file. New entries can be added to this file at any time. However, **init** still waits for one of the above three conditions to occur. To provide for an instantaneous response, the **telinit Q** or **q** command can wake up **init** to re-examine (reload) the */etc/inittab* file. If **init** is not in single user mode and receives a powerfail signal (SIGPWR), it reads the file */etc/powerstatus*. It then starts a command based on the contents of this file: - F(AIL) Power is failing, UPS is providing the power. Execute the **powerwait** and **powerfail** entries. - O(K) The power has been restored, execute the **powerokwait** entries. - L(OW) The power is failing and the UPS has a low battery. Execute the **powerfailnow** entries. If */etc/powerstatus* doesn't exist or contains anything else then the letters **F**, **O** or **L**, **init** will behave as if it has read the letter **F**. Usage of **SIGPWR** and */etc/powerstatus* is discouraged. Someone wanting to interact with **init** should use the */run/initctl* control channel – see the **initctl**(5) manual page for more documentation about this. When **init** is requested to change the runlevel, it sends the warning signal **SIGTERM** to all processes that are undefined in the new runlevel. It then waits 3 seconds before forcibly terminating these processes via the **SIGKILL** signal. Note that **init** assumes that all these processes (and their descendants) remain in the same process group which **init** originally created for them. If any process changes its process group affiliation it will not receive these signals. Such processes need to be terminated separately. ## TELINIT **/sbin/telinit** is linked to **/sbin/init**. It takes a one-character argument and signals **init** to perform the appropriate action. The following arguments serve as directives to **telinit**: - **0**, **1**, **2**, **3**, **4**, **5** or **6** tell **init** to switch to the specified run level. - **a**, **b**, **c** tell **init** to process only those **/etc/inittab** file entries having runlevel **a**, **b** or **c**. - **Q** or **q** tell **init** to re-examine the */etc/inittab* file. - **S** or **s** tell **init** to switch to single user mode. - **U** or **u** tell **init** to re-execute itself (preserving the state). No re-examining of */etc/inittab* file happens. Runlevel should be one of **Ss0123456** otherwise request would be silently ignored. **telinit** can tell **init** how long it should wait between sending processes the **SIGTERM** and **SIGKILL** signals. The default is 3 seconds, but this can be changed with the **-t** option. **telinit -e** tells **init** to change the environment for processes it spawns. The argument of **-e** is either of the form *VAR*=*VAL* which sets variable *VAR* to value *VAL*, or of the form *VAR* (without an equality sign) which unsets variable *VAR*. **telinit** can be invoked only by users with appropriate privileges. The **init** binary checks if it is **init** or **telinit** by looking at its *process id*; the real **init**'s process id is always **1**. From this it follows that instead of calling **telinit** one can also just use **init** instead as a shortcut. ## ENVIRONMENT **Init** sets the following environment variables for all its children: - **PATH** */bin:/usr/bin:/sbin:/usr/sbin* - **INIT\_VERSION** As the name says. Useful to determine if a script runs directly from **init**. - **RUNLEVEL** The current system runlevel. - **PREVLEVEL** The previous runlevel (useful after a runlevel switch). - **CONSOLE** The system console. This is really inherited from the kernel; however if it is not set **init** will set it to */dev/console* by default. ## BOOTFLAGS It is possible to pass a number of flags to **init** from the boot monitor (e.g., LILO or GRUB). **init** accepts the following flags: - **-s, S, single** Single user mode boot. In this mode */etc/inittab* is examined and the bootup rc scripts are usually run before the single user mode shell is started. - **1–5** Runlevel to boot into. - **-b, emergency** Boot directly into a single user shell without running any other startup scripts. - **-a, auto** The LILO boot loader adds the word "auto" to the command line if it booted the kernel with the default command line (without user intervention). If this is found **init** sets the "AUTOBOOT" environment variable to "yes". Note that you cannot use this for any security measures – of course the user could specify "auto" or **-a** on the command line manually. - **-z** *xxx* The argument to **-z** is ignored. You can use this to expand the command line a bit, so that it takes some more space on the stack. **init** can then manipulate the command line so that [**ps**(1)](/ps/1.md) shows the current runlevel. - **--version** This argument, when used on its own, displays the current version of **init** to the console/stdout. It is a quick way to determine which **init** software and version is being used. After the version information is displayed, **init** immediately exits with a return code of zero. ## INTERFACE **init** listens on a *fifo* as, */run/initctl*, for messages. **Telinit** uses this to communicate with **init**. The interface is not very well documented or finished. Those interested should study the *initreq.h* file in the *src/* subdirectory of the **init** source code tar archive. ## SIGNALS Init reacts to several signals: - **SIGHUP** Has the same effect as **telinit q**. - **SIGUSR1** On receipt of this signals, **init** closes and re-opens its control fifo, **/run/initctl**. Useful for bootscripts when */dev* is remounted. - **SIGUSR2** When **init** receives **SIGUSR2**, **init** closes and leaves the control fifo, **/run/initctl**, closed. This may be used to make sure **init** is not holding open any files. However, it also prevents **init** from switching runlevels. Which means commands like shutdown no longer work. The fifo can be re-opened by sending **init** the **SIGUSR1** signal. - **SIGINT** Normally the kernel sends this signal to **init** when CTRL-ALT-DEL is pressed. It activates the *ctrlaltdel* action. - **SIGWINCH** The kernel sends this signal when the *KeyboardSignal* key is hit. It activates the *kbrequest* action. ## CONFORMING TO **init** is compatible with the System V init. It works closely together with the scripts in the directories */etc/init.d* and */etc/rc{runlevel}.d*. If your system uses this convention, there should be a *README* file in the directory */etc/init.d* explaining how these scripts work. ## FILES ``` /etc/inittab /etc/initscript /dev/console /var/run/utmp /var/log/wtmp /run/initctl ``` ## WARNINGS **init** assumes that processes and descendants of processes remain in the same process group which was originally created for them. If the processes change their group, **init** can't kill them and you may end up with two processes reading from one terminal line. On a Debian system, entering runlevel 1 causes all processes to be killed except for kernel threads and the script that does the killing and other processes in its session. As a consequence of this, it isn't safe to return from runlevel 1 to a multi-user runlevel: daemons that were started in runlevel S and are needed for normal operation are no longer running. The system should be rebooted. ## DIAGNOSTICS If **init** finds that it is continuously respawning an entry more than 10 times in 2 minutes, it will assume that there is an error in the command string, generate an error message on the system console, and refuse to respawn this entry until either 5 minutes has elapsed or it receives a signal. This prevents it from eating up system resources when someone makes a typographical error in the */etc/inittab* file or the program for the entry is removed. ## AUTHOR Miquel van Smoorenburg ⟨miquels@\\:cistron\\:.nl⟩, initial manual page by Michael Haardt ⟨u31b3hs@\\:pool\\:.informatik\\:.rwth-aachen\\:.de⟩. ## SEE ALSO **getty**(1), [**login**(1)](/login/1.md), [**sh**(1)](/sh/1.md), [**runlevel**(8)](/runlevel/8.md), [**shutdown**(8)](/shutdown/8.md), [**kill**(1)](/kill/1.md), **initctl**(5), [**inittab**(5)](/inittab/5.md), [**initscript**(5)](/initscript/5.md), [**utmp**(5)](/utmp/5.md)