System Administration Guide: Basic Administration

Chapter 11 Run Levels and Boot Files (Tasks)

This chapter provides overview information and tasks that are related to run levels and boot files.

This is a list of the step-by-step instructions in this chapter.

This is a list of the overview information in this chapter.

Run Levels

A system's run level (also known as an init state) defines what services and resources are available to users. A system can be in only one run level at a time.

The Solaris environment has eight run levels, which are described in the following table. The default run level is specified in the /etc/inittab file as run level 3.

Table 11–1 Solaris Run Levels


Run Level	Init State	Type	Purpose
0	Power-down state	Power-down	To shut down the operating system so that it is safe to turn off power to the system.
s or S	Single-user state	Single-user	To run as a single user with some file systems mounted and accessible.
1	Administrative state	Single-user	To access all available file systems. User logins are disabled.
2	Multiuser state	Multiuser	For normal operations. Multiple users can access the system and all file system. All daemons are running except for the NFS server daemons.
3	Multiuser level with NFS resources shared	Multiuser	For normal operations with NFS resources shared. This is the default run level for the Solaris environment.
4	Alternative multiuser state		Currently unavailable.
5	Power-down state	Power-down	To shut down the operating system so that it is safe to turn off power to the system. If possible, automatically turns off power on systems that support this feature.
6	Reboot state	Reboot	To shut down the system to run level 0, and then reboot to multiuser level with NFS resources shared (or whatever level is the default in the `inittab` file).

How to Determine a System's Run Level

Display run level information by using the who -r command.

$ who -r

Use the who -r command to determine a system's current run level for any level, except run level 0.

Example—Determining a System's Run Level

This example displays information a system's current run level and information about previous run levels.

$ who -r
 .    run-level 3¹  Dec 13 10:10²   3³   0⁴ S⁵
$

Identifies the current run level
Identifies the date of last run level change
Also identifies the current run level
Identifies the number of times the system has been at this run level since the last reboot
Identifies the previous run level

The `/etc/inittab` File

When you boot the system or change run levels with the init or shutdown command, the init daemon starts processes by reading information from the /etc/inittab file. This file defines three important items for the init process:

The system's default run level
What processes to start, monitor, and restart if they terminate
What actions to take when the system enters a new run level

Each entry in the /etc/inittab file has the following fields:

id:rstate:action:process

The following table describes the fields in an inittab entry.

Table 11–2 Fields Descriptions for the inittab File


Field	Description
`id`	Is a unique identifier for the entry.
`rstate`	Lists the run levels to which this entry applies.
`action`	Identifies how the process that is specified in the process field is to be run. Possible values include: `initdefault`, `sysinit`, `boot`, `bootwait`, `wait`, and `respawn`. `initdefault` identifies the default run level. For a description of the other action keywords, see inittab(4).
`process`	Defines the command or script to execute.

Example—Default `inittab` File

The following example shows an annotated default inittab file that is installed with the Solaris release:

 

¹ ap::sysinit:/sbin/autopush -f /etc/iu.ap
² ap::sysinit:/sbin/soconfig -f /etc/sock2path
³ fs::sysinit:/sbin/rcS sysinit   >/dev/msglog 2<>/dev/msglog </dev/console
⁴ is:3:initdefault:
⁵ p3:s1234:powerfail:/usr/sbin/shutdown -y -i5 -g0 >/dev/msglog 2<>/dev/...
⁶ sS:s:wait:/sbin/rcS              >/dev/msglog 2<>/dev/msglog </dev/console
⁷ s0:0:wait:/sbin/rc0              >/dev/msglog 2<>/dev/msglog </dev/console
⁸ s1:1:respawn:/sbin/rc1           >/dev/msglog 2<>/dev/msglog </dev/console
⁹ s2:23:wait:/sbin/rc2             >/dev/msglog 2<>/dev/msglog </dev/console
¹⁰ s3:3:wait:/sbin/rc3             >/dev/msglog 2<>/dev/msglog </dev/console
¹¹ s5:5:wait:/sbin/rc5             >/dev/msglog 2<>/dev/msglog </dev/console
¹² s6:6:wait:/sbin/rc6             >/dev/msglog 2<>/dev/msglog </dev/console
¹³ fw:0:wait:/sbin/uadmin 2 0      >/dev/msglog 2<>/dev/msglog </dev/console
¹⁴ of:5:wait:/sbin/uadmin 2 6      >/dev/msglog 2<>/dev/msglog </dev/console
¹⁵ rb:6:wait:/sbin/uadmin 2 1      >/dev/msglog 2<>/dev/msglog </dev/console
¹⁶ sc:234:respawn:/usr/lib/saf/sac -t 300
¹⁷ co:234:respawn:/usr/lib/saf/ttymon -g -h -p "`uname -n` console login: " 
   -T terminal-type -d /dev/console -l console
-m ldterm,ttcompat

Initializes STREAMS modules
Configures socket transport providers
Initializes file systems
Defines default run level
Describes a power fail shutdown
Defines single-user level
Defines run level 0
Defines run level 1
Defines run level 2
Defines run level 3
Defines run level 5
Defines run level 6
Defines an unused level, firmware
Defines an unused level, off
Defines an unused level, reboot
Initializes Service Access Controller
Initializes console and identifies the terminal type

What Happens When the System Is Brought to Run Level 3

The init process is started and reads the /etc/default/init file to set any environment variables. By default, only the TIMEZONE variable is set.

Then init reads the inittab file and does the following:

Identifies the initdefault entry, which defines the default run level (3).
Executes any process entries that have sysinit in the action field so that any special initializations can take place before users login.

Executes any process entries that have a 3 in the rstate field, which matches the default run level, 3.

For a detailed description of how the init process uses the inittab file, see init(1M).

The following table describes the keywords used for run level 3's action field.

Table 11–3 Run Level 3 Action Keyword Descriptions


Key Word	Description
`powerfail`	Starts the process when the `init` process receives a power failure signal
`respawn`	Starts the process and restarts it when it dies
`wait`	Starts the process and waits for it to finish before going on to the next entry for this run level

The following table describes the processes (or commands) that are executed at run level 3.

Table 11–4 Command Descriptions for Run Level 3


Command or Script Name	Description
`/usr/sbin/shutdown`	Shuts down the system. The `init` process runs the `shutdown` command only if the system has received a power fail signal.
`/sbin/rcS`	Mounts and checks root (`/`), `/usr`, `/var`, and `/var/adm` file systems.
`/sbin/rc2`	Starts the standard system processes and brings the system up into run level 2 (multiuser level).
`/sbin/rc3`	Starts NFS resource sharing for run level 3.
`/usr/lib/saf/sac -t 30`	Starts the port monitors. This process is restarted if it fails.
/usr/lib/saf/ttymon -g -h -p "`uname -n` console login: " -T`terminal_type` `-d /dev/console -l console`	Starts the `ttymon` process that monitors the console for login requests. This process is restarted if it fails. The `terminal_type` on a SPARC based system is `sun`. The `terminal_type` on an IA based system is `AT386`.

Run Control Scripts

The Solaris software environment provides a detailed series of run control (rc) scripts to control run-level changes. Each run level has an associated rc script that is located in the /sbin directory:

rc0
rc1
rc2
rc3
rc5
rc6
rcS

For each rc script in the /sbin directory, there is a corresponding directory named /etc/rcn.d that contains scripts to perform various actions for that run level. For example, /etc/rc2.d contains files that are used to start and stop processes for run level 2.

# ls /etc/rc2.d
K03samba*          S20sysetup*        S72slpd*            S88utmpd*
K06mipagent*       S21perf*           S73cachefs.daemon*  S89PRESERVE*
K07dmi*            S30sysid.net*      S73nfs.client*      S89bdconfig@
K07snmpdx*         S40llc2*           S74autofs*          S90wbem*
K16apache*         S42ncakmod*        S74syslog*          S91afbinit*
K21dhcp*           S47pppd*           S74xntpd*           S91gfbinit*
K26sshd*           S69inet*           S75cron*            S91ifbinit*
K27boot.server*    S70sckm*           S75flashprom*       S92volmgt*
K28kdc*            S70uucp*           S75savecore*        S93cacheos.finish*
K28kdc.master*     S71ldap.client*    S76nscd*            S94ncalogd*
K28nfs.server*     S71rpc*            S77sf880dr*         S95IIim*
README             S71sysid.sys*      S80lp*              S95svm.sync*
S01MOUNTFSYS*      S72autoinstall*    S80spc*             S98efcode*
S05RMTMPFILES*     S72directory@      S85power*           S99audit*
S10lu*             S72inetsvc*        S88sendmail*        S99dtlogin*

The /etc/rcn.d scripts are always run in ASCII sort order. The scripts have names of the form:

[KS][0-9][0-9]*

Files that begin with K are run to terminate (kill) a system service. Files that begin with S are run to start a system service.

Run control scripts are also located in the /etc/init.d directory. These files are linked to corresponding run control scripts in the /etc/rcn.d directories.

The actions of each run control script are summarized in the following section.

Run Control Script Summaries

The following sections summarize the run control scripts that are used to start and stop system services when you change run levels.

The `/sbin/rc0` Script

The /sbin/rc0 script runs the /etc/rc0.d scripts to perform the following tasks:

Stops system services and daemons
Terminates all running processes
Unmounts all file systems

The `/sbin/rc1` Script

The /sbin/rc1 script runs the /etc/rc1.d scripts to perform the following tasks:

Stops system services and daemons
Terminates all running processes
Unmounts all file systems
Brings the system up in single-user level

The `/sbin/rc2` Script

The /sbin/rc2 script runs the /etc/rc2.d scripts to perform the following tasks, grouped by function:

Local system-related tasks:

Mounts all local file systems
Enables disk quotas if at least one file system was mounted with the quota option
Saves temporary editor files in the /usr/preserve directory
Removes any files in the /tmp directory
Starts system activity data collecting, system accounting, and system auditing, if configured
Starts the system logging daemon (syslogd), sets the default dump device, and rotates the /var/adm/messages file
Sets the default scheduling class if the /etc/dispadmin.conf file exists
Starts LP print service (lpsched) if a local printer is configured and cleans up the print queue
Configures power management, if appropriate
Starts the utmpd daemon
Starts the cron and vold daemons
Configures serial device stream
Configures WBEM services
Syncs volumes, if required, and starts the mdmonitord daemon to monitor the physical components of the volumes
Starts the CDE desktop login process, dtlogin, if appropriate

Network service or security-related tasks:

Configures the network interfaces, sets ifconfig netmask, and configures network routing, if appropriate
Starts network service (inetd and rpcbind) daemons
Starts the logical link controller (llc2), if configured
Sets the name service domain name, starts various name services daemons, depending on if the system is configured for a name service, and whether the system is a client or a server
Starts the keyserv, statd, lockd, and xntpd daemons, if appropriate
Mounts all NFS entries
Configures the Solaris Network Cache and Accelerator (NCA) and NCA logging, if appropriate
Starts the Solaris PPP server or client daemons (pppoed or pppd), if configured
Starts LDAP cache manager (ldap_cachemgr), if configured
Starts directory server (slapd) daemon, if configured
Starts DNS (in.named) daemon, if configured
Starts Service Location Protocol (slpd) daemon, if configured
Configures system resource controls and system pools if the /etc/rctladm.conf and /etc/pooladm.conf files exist
Starts the cachefsd, automount, and sendmail daemons, if appropriate
Starts the htt_server process

Install-related tasks:

Configures the boot environment for the Live Upgrade software upon system startup or system shutdown
Checks for the presence of the /etc/.UNCONFIGURE file to see if the system should be reconfigured
Reboots the system from the installation media or a boot server if either /.PREINSTALL or /AUTOINSTALL exists

Hardware-related tasks:

Starts the Sun Fire 15000 key management daemon (sckmd), if appropriate
Starts the Sun Fire 880 Dynamic Reconfiguration daemon (sf880drd), if appropriate
Runs the flash PROM update script
Configures any graphic frame buffers or graphic accelerators
Runs the FCode interpreter daemon (efdaemon), if necessary

Transitions the following services between run-level changes:

Apache (tomcat)
Boot server (in.rarpd), (rpc.bootparamd), or (rpld)
DHCP (in.dhcpd)
Kerberos KDC (krb5kdc ) and Kerberos administration (kadmind)
Mobile IP (mipagent)
NFS server (nfsd), (mountd), (nfslogd)
Samba (smdb) and (nmdb)
Secure shell (sshd)
Solstice Enterprise Agents (dmispd) and (snmpXdmid)

Note –

Many of the system services and applications that are started at run level 2 depend on what software is installed on the system.

The `/sbin/rc3` Script

The /sbin/rc3 script runs the /etc/rc3.d scripts to perform the following tasks:

Starts the Apache server daemon (tomcat), if configured
Starts the DHCP daemon (in.dhcpd), if appropriate
Starts Kerberos KDC (krb5kdc) and Kerberos administration (kadmind) daemons, if configured
Starts Mobile IP daemon (mipagent), if configured
Starts the Samba daemons (smdb and nmdb), if configured
Starts the secure shell daemon (sshd), if appropriate
Starts the Solstice Enterprise Agents (dmispd and snmpXdmid)
Cleans up the /etc/dfs/sharetab file
Starts the NFS server daemons nfsd, mountd, and nfslogd, if appropriate
If the system is a boot server, starts the rarpd, rpc.bootparamd, and rpld daemons

The `/sbin/rc5` and `/sbin/rc6` Scripts

The /sbin/rc5 and /sbin/rc6 scripts run the /etc/rc0.d/K* scripts to perform the following tasks:

Kills all active processes
Unmounts the file systems

The `/sbin/rcS` Script

The /sbin/rcS script runs the /etc/rcS.d scripts to bring the system up to run level S. The following tasks are performed by these scripts:

Establishes a minimal network
Mounts /usr, if necessary
Sets the system name
Checks the root (/) and /usr file systems
Mounts pseudo file systems (/proc and /dev/fd)
Rebuilds the device entries for reconfiguration boots
Checks and mounts other file systems to be mounted in single-user level

Using a Run Control Script to Stop or Start Services

One advantage of having individual scripts for each run level is that you can run scripts in the /etc/init.d directory individually to stop system services without changing a system's run level.

How to Use a Run Control Script to Stop or Start a Service

Become superuser.

Stop the system service.
# /etc/init.d/filename stop

Restart the system service.
# /etc/init.d/filename start

Verify that the service has been stopped or started.
# pgrep -f service

Example—Using a Run Control Script to Stop or Start a Service

For example, you can stop the NFS server daemons by typing the following:

# /etc/init.d/nfs.server stop
# pgrep -f nfs
#

Then, you can restart the NFS server daemons by typing the following:

# /etc/init.d/nfs.server start
# pgrep -f nfs 
141 143 245 247
# pgrep -f nfs -d, | xargs ps -fp
daemon   141    1 40   Jul 31 ?     0:00 /usr/lib/nfs/statd
root     143    1 80   Jul 31?      0:01 /usr/lib/nfs/lockd
root     245    1 34   Jul 31 ?     0:00 /usr/lib/nfs/nfsd -a 16
root     247    1 80   Jul 31 ?     0:02 /usr/lib/nfs/mountd

Adding a Run Control Script

If you want to add a run control script to start and stop a service, copy the script into the /etc/init.d directory. Then, create links in the rcn.d directory where you want the service to start and stop.

See the README file in each /etc/rcn.d directory for more information on naming run control scripts. The following procedure describes how to add a run control script.

How to Add a Run Control Script

Become superuser.

Add the script to the /etc/init.d directory.

# cp filename /etc/init.d
# chmod 0744 /etc/init.d/filename
# chown root:sys /etc/init.d/filename

Create links to the appropriate rcn.d directory.

# cd /etc/init.d
# ln filename /etc/rc2.d/Snnfilename
# ln filename /etc/rcn.d/Knnfilename

Verify that the script has links in the specified directories.
# ls /etc/init.d/ /etc/rc2.d/ /etc/rcn.d/

Example—Adding a Run Control Script

The following example shows how to add a run control script for the xyz service.

# cp xyz /etc/init.d
# chmod 0744 /etc/init.d/xyz
# chown root:sys /etc/init.d/xyz
# cd /etc/init.d
# ln xyz /etc/rc2.d/S100xyz
# ln xyz /etc/rc0.d/K100xyz
# ls /etc/init.d /etc/rc2.d /etc/rc0.d

Disabling a Run Control Script

You can disable a run control script by renaming it with an underscore (_) at the beginning of the file name. Files that begin with an underscore or dot are not executed. If you copy a file by adding a suffix to it, both files will be run.

How to Disable a Run Control Script

Become superuser.

Rename the script by adding an underscore (_) to the beginning of the new file.
# cd /etc/rcn.d # mv filename _filename

Verify that the script has been renamed.
# ls _* # _filename

Example—Disabling a Run Control Script

The following example shows how to rename the S100datainit script.

# cd /etc/rc2.d
# mv S100datainit _S100datainit
# ls _*
# _S100datainit