2.3. Major services in a UNIX system
This section describes some of the more important UNIX
services, but without much detail. They are described more
thoroughly in later chapters.
The single most important service in a UNIX system is
provided by init init
is started as the first process of every UNIX system, as the last
thing the kernel does when it boots. When init
starts, it continues the boot process by doing various startup
chores (checking and mounting filesystems, starting daemons,
The exact list of things that init
does depends on which flavor it is; there are several to choose
from. init usually provides the concept of
single user mode, in which no one can
log in and root uses a shell at the console; the usual mode is
called multiuser mode. Some flavors
generalize this as run levels; single
and multiuser modes are considered to be two run levels, and
there can be additional ones as well, for example, to run X on
Linux allows for up to 10
runlevels, 0-9, but usually only some of
these are defined by default. Runlevel 0 is defined as ``system
halt''. Runlevel 1 is defined as ``single user mode''. Runlevel 3
is defined as
"multi user" because it is the runlevel that the system boot into
under normal day to day conditions. Runlevel 5 is typically the same as 3 except that a GUI
gets started also.
Runlevel 6 is defined as ``system
reboot''. Other runlevels are
dependent on how your particular distribution has defined them,
and they vary significantly between distributions. Looking at
the contents of /etc/inittab
give some hint what the predefined runlevels are and what they
have been defined as.
In normal operation, init
is working (to allow users to log in)
and to adopt orphan processes (processes whose parent has died; in
UNIX all processes must
be in a single tree, so orphans must be adopted).
When the system is shut down, it is init
that is in charge of killing all other processes, unmounting all
filesystems and stopping the processor, along with anything else
it has been configured to do.
2.3.2. Logins from terminals
Logins from terminals (via serial lines) and the console
(when not running X) are provided by the getty
program. init starts a separate instance of
getty for each terminal upon which logins are to
be allowed. getty reads the username and runs
the loginprogram, which reads the password.
If the username and password are correct, login runs
the shell. When the shell terminates, i.e., the user logs out, or
when login terminated because the username and
password didn't match, init notices this and
starts a new instance of getty. The kernel has no
notion of logins, this is all handled by the
The kernel and many system programs
produce error, warning, and other messages. It is often important
that these messages can be viewed later, even much later, so they
should be written to a file. The program doing this is
syslog . It can be configured to sort the
messages to different files according to writer or degree of
importance. For example, kernel messages are often directed to a
separate file from the others, since kernel messages are often more
important and need to be read
regularly to spot problems.
Chapter 15 will provide more on
2.3.4. Periodic command execution: cron and
Both users and system administrators often need
to run commands periodically. For example, the system administrator
might want to run a command to clean the directories with temporary
files (/tmp and /var/tmp)
from old files, to keep the disks from filling up, since not all
programs clean up after
The cron service is set up to do this.
Each user can have a crontab
file, where she
lists the commands she wishes to execute and the times they should
be executed. The cron daemon takes care of
starting the commands when specified.
The at service is similar to
cron, but it is once only: the command is
executed at the given time, but it is not repeated.
We will go more into this later. See the manual pages
cron(1), crontab(1), crontab(5), at(1) and atd(8) for more in
Chapter 13 will cover this.
2.3.5. Graphical user interface
UNIX and Linux don't incorporate the user interface
into the kernel; instead, they let it be implemented by user level
programs. This applies for both text mode and graphical
This arrangement makes the system more flexible, but has
the disadvantage that it is simple to implement a different user
interface for each program, making the system harder to
The graphical environment primarily used with Linux
is called the X Window System (X for short).
X also does not implement a user interface; it only implements a
window system, i.e., tools with which a graphical user interface can
be implemented. Some popular window managers are: fvwm , icewm
, blackbox , and windowmaker
. There are also two popular desktop managers,
KDE and Gnome.
Networking is the act of connecting two or more computers
so that they can communicate with each other. The actual methods
of connecting and communicating are slightly complicated, but
the end result is very useful.
UNIX operating systems have many networking features.
Most basic services (filesystems, printing, backups, etc) can
be done over the network. This can make system administration
easier, since it allows centralized administration, while
still reaping in the benefits of microcomputing and distributed
computing, such as lower costs and better fault tolerance.
However, this book merely glances at networking; see the
Linux Network Administrators' Guide
more information, including a basic description of how networks
2.3.7. Network logins
Network logins work a little differently
than normal logins. For each person logging in via the network
there is a separate virtual network connection,
and there can be any number of these depending on the available
bandwidth. It is therefore not possible to run a separate
getty for each possible virtual connection.
There are also several different ways to log in via a network,
telnet and ssh
the major ones in TCP/IP networks.
These days many Linux system administrators consider
telnet and rlogin to be
insecure and prefer ssh, the ``secure shell'',
which encrypts traffic going over the network, thereby making it far
less likely that the malicious can ``sniff'' your connection and gain
sensitive data like usernames and passwords. It is highly recommended
you use ssh rather than telnet
Network logins have, instead of a herd
of gettys, a single daemon per way
of logging in
(telnet and ssh
separate daemons) that listens for all incoming login attempts.
When it notices one, it starts a new instance of itself to
handle that single attempt; the original instance continues to
listen for other attempts. The new instance works similarly
2.3.8. Network file systems
One of the more useful things that can be done with
networking services is sharing files via a network
file system. Depending on your network this could
be done over the Network File System (NFS), or over
the Common Internet File System (CIFS).
NFS is typically a 'UNIX' based service. In Linux, NFS is supported
by the kernel. CIFS however is not. In Linux,
CIFS is supported by Samba https://www.samba.org.
With a network file system any file operations done by
a program on one machine are sent over the network to another
computer. This fools the program to think that all the files
on the other computer are actually on the computer the program
is running on. This makes information sharing extremely simple,
since it requires no modifications to programs.
This will be covered in more detail in
Electronic mail is the most popularly used method for
communicating via computer. An electronic letter is stored in a
file using a special format, and special mail programs are used
to send and read the letters.
Each user has an incoming mailbox
(a file in the special format), where all new mail is stored.
When someone sends mail, the mail program locates the receiver's
mailbox and appends the letter to the mailbox file. If the
receiver's mailbox is in another machine, the letter is sent to
the other machine, which delivers it to the mailbox as it best
The mail system consists of many programs. The
delivery of mail to local or remote mailboxes is done by one
program (the mail transfer agent (MTA)
, e.g., sendmail
), while the programs users use are many and varied
(mail user agent (MUA)
, e.g., pine
The mailboxes are usually stored
in /var/spool/mail until the user's MUA
For more information on setting up and running mail services
you can read the Mail Administrator HOWTO at
visit the sendmail or postfix's website.
Only one person can use a printer at one time, but it is
uneconomical not to share printers between users. The printer is
therefore managed by software that implements a print
queue: all print
jobs are put into a queue and
whenever the printer is done with one job, the next one is sent
to it automatically. This relieves the users from organizing
the print queue and fighting over control of the printer.
Instead, they form a new queue at
the printer, waiting for their printouts, since no one ever seems to
be able to get the queue software to know exactly when anyone's printout
is really finished. This is a great boost to intra-office social
The print queue software also spools
the printouts on
disk, i.e., the text is kept in a file while
the job is in the queue. This allows an application program
to spit out the print jobs quickly to the print queue software;
the application does not have to wait until the job is actually
printed to continue. This is really convenient, since it
allows one to print out one version, and not have to wait for
it to be printed before one can make a completely revised new
You can refer to the Printing-HOWTO located at
for more help in setting up printers.
2.3.11. The filesystem layout
The filesystem is divided into many parts;
usually along the lines of a root filesystem with
, and a few others;
programs and unchanging data;
filesystem with changing
data (such as log files); and a
for everyone's personal
files. Depending on the hardware configuration and the decisions
of the system administrator, the division can be different;
it can even be all in one filesystem.
Chapter 3 describes the filesystem
layout in some little detail; the Filesystem Hierarchy Standard
it in somewhat more detail. This can be found on the web at: