6    Using Processes

This chapter explains the operating system processes. After completing this chapter, you will be able to:

• Understand programs and processes

• Redirect process input, output, and errors

• Run processes in the foreground and background

• Check the status of processes

• Cancel processes

• Display information about users and their processes

A good way to learn about the preceding topics is to try the examples in this chapter. You should do each example so that the information on your screen is consistent with the information in this book.

6.1    Understanding Programs and Processes

A program is a set of instructions that a computer can interpret and run. You may think of most programs as belonging to one of two categories:

• Application programs such as text editors, accounting packages, or electronic spreadsheets

• Programs that are components of the operating system such as commands, the shell (or shells), and your login procedure

While a program is running, it is called a process. The operating system assigns every process a unique number known as a process identifier.

The operating system can run a number of different processes at the same time. When more than one process is running, a scheduler built into the operating system gives each process its fair share of the computer's time, based on established priorities.

6.2    Understanding Standard Input, Output, and Error

When a process begins executing, the operating system opens three files for the process: stdin (standard input), stdout (standard output), and stderr (standard error). Programs use these files as follows:

• Standard input is the place from which the program expects to read its input. By default, processes read stdin from the keyboard.

• Standard output is the place to which the program writes its output. By default, processes write stdout to the screen.

• Standard error is the place to which the program writes its error messages. By default, processes write stderr to the screen.

In most cases, the default standard input, output, and error mechanisms will serve you well. However, there are times when it is useful to redirect the standard input, output, and error. The following sections describe these procedures.

6.2.1    Redirecting Input and Output

A command usually reads its input from the keyboard (standard input) and writes its output to the display (standard output). You may want a command to read its input from a file, write its output to a file, or both. You can select input and output files for a command with the shell notation shown in Table 6-1. This notation can be used in all shells.

Table 6-1: Shell Notation for Reading Input and Redirecting Output

The following sections explain how to read input from a file and how to write output to a file.

6.2.1.1    Reading Input from a File

All shells allow you to redirect the standard input of a process so that input is read from a file, instead of from the keyboard.

You can use input redirection with any command that accepts input from stdin (your keyboard). You cannot use input redirection with commands, such as who, that do not accept input. To redirect input, use the left-angle bracket (<), as the following example shows:

$  wc <file3

      3      27     129
$

The wc (word count) command counts the number of lines, words, and bytes in the named file. So file3 contains 3 lines, 27 words, and 129 bytes. If you do not supply an argument, the wc command reads its input from the keyboard. In this example, however, input for wc comes from the file named file3.

Note that in the preceding example, you could have entered the following, and displayed the same output:

wc file3

This is because most commands allow the input file to be specified without the left-angle bracket (<).

However, there are a few commands like mail that require the use of the left-angle bracket (<) for special functions. For example, note the following command:

$  mail juan <report

This command mails to the user juan the file report. For more information about mail, see the mail(1) reference page.

6.2.1.2    Redirecting Output

All shells allow you to redirect the standard output of a process from the screen (the default) to a file. As a result, you can store the text generated by a command into a new or existing file.

To send output to a file, use either a right-angle bracket (>) or two right-angle brackets (>>).

The right-angle bracket (>) causes the shell to:

• Replace the contents of the file with the output of the command, if the file exists.

• Create the file, if the file does not exist and place the output of the command into the file.

Two right-angle brackets (>>) add (append) the output of the command to the end of a file that exists. If you use two right-angle brackets (>>) to write output to a file that does not exist, the shell creates the file containing the output of the command.

In the next example, the output of ls goes to the file named file:

$  ls >file

$

If the file already exists, the shell replaces its contents with the output of ls. If file does not exist, the shell creates it.

In the following example, the shell adds the output of ls to the end of the file named file:

$  ls >>file

$

If file does not exist, the shell creates it.

In addition to their standard output, processes often produce error or status messages known as diagnostic output. For information about redirecting diagnostic output, see the following section.

6.2.2    Redirecting Standard Error to a File

When a command executes successfully, it displays the results on the standard output. When a command executes unsuccessfully, it displays error messages on the default standard error file, the screen. However, the shell allows you to redirect the standard error of a process from the screen to a file.

Redirection symbols and syntax vary among shells. The following sections describe standard error redirection for the Bourne, Korn, and C shells.

6.2.2.1    Bourne and Korn Shell Error Redirection

The general format for Bourne and Korn shell standard error redirection is the following:

command 2> errorfile

The command entry is an operating system command. The errorfile entry is the name of the file to which the process writes the standard error. The 2> is a file descriptor digit combined with the right-angle bracket (>), the output redirection symbol. The file descriptor digit tells the shell what standard file to access so that its contents may be redirected. The file descriptor digit 2 indicates that the standard error file is being redirected.

In fact, for the Bourne and Korn shells, a file descriptor digit is associated with each of the files a command ordinarily uses:

• File descriptor 0 (same as the left-angle bracket [<]) specifies standard input (the keyboard).

• File descriptor 1 (same as the right-angle bracket [>]) specifies standard output (the screen).

• File descriptor 2 specifies standard error (screen).

In the following example, an error is redirected to the error file when the ls command attempts to display the nonexistent file, reportx. The contents of error file are then displayed:

$  ls reportx 2> error
$  cat error

reportx not found
$

Although only standard error is redirected to a file in the preceding example, typically you would redirect both standard error and standard output. See Section 6.2.3 for more information.

For many commands, the difference between standard output and standard error is difficult to see. For instance, if you use the ls command to display a nonexistent file, an error message displays on the screen. If you redirect the error message to a file as in the previous example, the output is identical.

6.2.2.2    C Shell Error Redirection

The general format for C shell standard error redirection is the following:

( command > outfile )>& errorfile

The command entry is any operating system command. The outfile entry is the name of the file to which the process writes the standard output. The right-angle bracket (>) redirects the standard error to a file. The errorfile entry is the name of the file to which the process writes the standard error. Note that in this command format, the parentheses are mandatory.

6.2.3    Redirecting Both Standard Error and Standard Output

In the preceding sections, you learned how to redirect standard output and standard error separately. Usually, however, you would redirect both standard output and standard error at the same time. Standard output and standard error can be written to different files or to the same file.

For the Bourne and Korn shells, the general format for redirecting both standard output and standard error to different files is the following:

command > outfile 2> errorfile

The command entry is an operating system command. The outfile entry is the file to which the process writes the standard output. The 2> symbol redirects the error output. The errorfile entry is the file where the process writes the standard error. For the C shell, the general format for redirecting both standard output and standard error to different files is the following:

( command > outfile )>& errorfile

The command entry is an operating system command. The outfile entry is the file to which the process writes the standard output. The right-angle bracket and ampersand (>&) symbol redirects the error output. The errorfile entry is the file where the process writes the standard error. Note that in this command format, the parentheses are mandatory. See Section 6.2.2.2 for more information.

For the Bourne and Korn shells, the general format for redirecting both standard output and standard error to the same file is the following:

command 1> outfile 2>&1

The command entry is an operating system command. The 1> symbol redirects the standard output. The outfile entry is the file to which the process writes the standard output. The 2>&1 symbol tells the shell to write the standard error (file descriptor 2) in the file associated with the standard output (>&1), outfile.

For the C shell, the general format for redirecting both standard output and standard error to the same file is the following:

command >& outfile

The command entry is an operating system command. The outfile entry is the file to which the process writes the standard output. The right-angle bracket and ampersand (>&) symbol tells the shell to write the standard output and standard error to the same file specified by outfile.

6.3    Running Several Processes Simultaneously

The operating system can run a number of different processes at the same time. This capability makes it a multitasking operating system, which means that the processes of several users can run at the same time.

These different processes can be from one or multiple users. As a result, you do not have to enter commands one at a time at the shell prompt. Instead, you can run both foreground and background processes simultaneously. The following sections describe both foreground and background processes.

6.3.1    Running Foreground Processes

Normally, when you enter a command on the command line, you wait for the results to display on your screen. Commands entered singly at the shell prompt are called foreground processes.

Most commands take a short time to execute - perhaps a second or two. However, some commands require longer execution times. If a long-duration command runs as a foreground process, you cannot execute other commands until the current one finishes. As a result, you may want to run a long-duration command as a background process. The following section describes background processes.

6.3.2    Running Background Processes

Generally, background processes are most useful with commands that take a long time to run. Instead of tying up your screen by entering a long-duration command as a foreground process, you can execute a command as a background process. You can then continue with other work in the foreground.

To run a background process, you end the command with an ampersand (&). Once a process is running in the background, you can perform additional tasks by entering other commands at your workstation.

After you create a background process, the following takes place:

• The Process Identification Number (PID) is displayed. The operating system creates and assigns PIDs so that all processes currently running on the system can be tracked. (In the Korn or the C shell, job numbers are assigned as well.)

• The prompt returns so that you can enter another command.

• In the C shell, a message is displayed when the background process is complete.

When you create a background process, note its PID number. The PID number helps you to monitor or terminate the process. See Section 6.4 for more information.

Because background processes increase the total amount of work the system is doing, they may also slow down the rest of the system. This may or may not be a problem, depending upon how much the system slows and the nature of the other work you or others do while background processes run.

Most processes direct their output to standard output, even when they run in the background. Unless redirected, standard output goes to your workstation. Because the output from a background process may interfere with your other work on the system, it is usually good practice to redirect the output of a background process to a file or to a printer. Then you can look at the output whenever you are ready. For more information about redirecting output, see the examples later in this chapter as well as Section 6.2. The examples in the remainder of this chapter use a command that takes more than a few seconds to run:

$  find / -type f -print

This command displays the pathnames for all files on your system. You do not need to study the find command in order to complete this chapter - it is used here simply to demonstrate how to work with processes. However, if you want to learn more about the find command, see the find(1) reference page.

In the following example, the find command runs in the background (by entering an ampersand [&]) and redirects its output to a file named dir.paths (by using the right-angle bracket [>] operator):

$  find / -type f -print  >dir.paths &

24
$

When the background process starts, the system assigns it a PID (Process Identification) number (24 in this example), displays it, and then prompts you for another command. Your process number will be different from the one shown in this and following examples.

If you use the Korn or C shell, job numbers are assigned as well. In the C shell, the preceding example looks like this:

% find / -type f -print  >dir.paths &

[1] 24
% _

Note that the job number [1] is displayed to the left of the PID number.

You can check the status of the process with the ps (process status) or the jobs command (Korn and C shell). You can also terminate a process with the kill command. See the following section for more information about these commands.

In the C shell, when the background process is completed, a message is displayed:

[1] 24  Done   find / -type f -print  >dir.paths

The completion message displays the job number and the PID, the status Done, and the command executed.

6.4    Monitoring and Terminating Processes

Use the ps (process status) command to find out which processes are running and to display information about those processes. In the Korn and C shells, you also can use the jobs command to monitor background processes.

If you need to stop a process before it is finished, use the kill command.

The following sections describe how to monitor and terminate processes.

6.4.1    Checking Process Status

The ps command allows you to monitor the status of all active processes, both foreground and background. In the Korn and C shell, you also can use the jobs command to monitor background processes only. The following sections describe the ps and the jobs command.

6.4.1.1    The ps Command

The ps command has the following form:

ps

In the following example, the ps command displays the status of all processes associated with your workstation under the following headings:

$  ps

PID          TT    STAT       TIME    COMMAND
29670        p4    I       0:00.00    -sh (csh)
  515        p5    S       0:00.00    -sh (csh)
28476        p5    R       0:00.00    ps
  790        p6    I       0:00.00    -sh (csh)
$

You interpret the display under these entry headings as follows:

PID

Process identification. The system assigns a process identification number (PID number) to each process when that process starts. There is no relationship between a process and a particular PID number; that is, if you start the same process several times, it will have a different PID number each time.

TT

Controlling terminal device name. On a system with more than one workstation, this field tells you which workstation started the process. On a system with only one workstation, this field can contain the designation console or the designation for one or more virtual terminals.

STAT

Symbolic process status. The system displays the state of the process, with a sequence of up to four alphanumeric characters. For more information, see the ps(1) reference page.

TIME

Time devoted to this process by the computer is displayed in minutes, seconds, and hundredths of seconds starting when you enter ps.

COMMAND

The name of the command (or program) that started the process.

You can also check the status of a particular process by using the -p flag and the PID number with the ps command. The general format for checking the status of a particular process is the following:

ps -p PIDnumber

The ps command also displays the status of background processes. If there are any background processes running, they will be displayed along with the foreground processes. The following example shows how to start a find background process and then check its status:

$  find / -type f -print >dir.paths &

25

PID   TTY         TIME  COMMAND
 25   console  0:40.00  find
$

You can check background process status as often as you like while the process runs. In the following example, the ps command displays the status of the preceding find process five times:

$  ps -p25

PID   TTY         TIME  COMMAND
 25   console  0:18:00  find

PID   TTY         TIME  COMMAND
 25   console  0:29:00  find

PID   TTY         TIME  COMMAND
 25   console  0:49:00  find

PID   TTY         TIME  COMMAND
 25   console  0:58:00  find

PID   TTY         TIME  COMMAND
 25   console  1:02:00  find

PID   TTY       TIME COMMAND
$

Notice that the sixth ps command returns no status information because the find process ended before the last ps command was entered.

Generally, the simple ps command described here tells you all you need to know about processes. However, you can control the type of information that the ps command displays by using more of its flags. One of the most useful ps flags is -e, which causes ps to return information about all processes, not just those associated with your terminal or workstation. For an explanation of all ps command flags, see the ps(1) reference page.

6.4.1.2    The jobs Command

The Korn shell and the C shell display both a job and a PID when a background process is created. The jobs command reports the status of all background processes only, based upon the job number.

The jobs command has the following form:

jobs

Adding the -l flag displays both the job number and the PID.

The following example shows how to start a find process and then check its status in the C shell with the jobs -l command:

%  find / -type f -print >dir.paths &

[2] 26

[2] +26 Running   find / -type f -print >dir.paths &
% _

The status message displays both the job ([2]) and the PID number (26), the status Running, and the command executed.

6.4.2    Canceling a Foreground Process (Ctrl/C)

To cancel a foreground process (stop an executing command), press Ctrl/C. The command stops executing, and the system displays the shell prompt. Note that canceling a foreground process is the same as stopping command execution (described in Chapter 1).

Most simple operating system commands are not good examples for demonstrating how to cancel a process - they run so quickly that they finish before you have time to cancel them. However, the following find command runs long enough for you to cancel it (after the process runs for a few seconds, you can cancel it by pressing Ctrl/C):

$  find / -type f -print

/usr/sbin/acct/acctcms
/usr/sbin/acct/acctcoN1
/usr/sbin/acct/acctcon2
/usr/sbin/acct/acctdisk
/usr/sbin/acct/acctmerg
/usr/sbin/acct/accton
/usr/sbin/acct/acctprc1
/usr/sbin/acct/acctprc2
/usr/sbin/acct/acctwtmp
/usr/sbin/acct/chargefee
/usr/sbin/acct/ckpacct
/usr/sbin/acct/dodisk
[Ctrl/C]
$

The system returns the shell prompt to the screen. Now you can enter another command.

6.4.3    Canceling a Background Process (kill)

If you decide, after starting a background process, that you do not want the process to finish, you can cancel the process with the kill command. Before you can cancel a background process, however, you must know its PID number.

If you have forgotten the PID number of that process, you can use the ps command to list the PID numbers of all processes. If you are a C or Korn Shell user, it is more efficient to use the jobs command to list background processes only.

The general format for terminating a particular process is the following:

kill PIDnumber

If you want to end all the processes you have started since login, use the kill 0 command. You do not have to know the PID numbers to use kill 0. Because this command deletes all of your processes, use this command carefully.

The following example shows how to start another find process, check its status, and then terminate it:

$  find / -type f -print >dir.paths &

38

PID   TT   STAT       TIME    COMMAND
520   p4   I       0:11:10  sh
38    p5   I       0:10:33  find
1216  p6   S       0:01:14  qdaemon
839   p7   R       0:03:55  ps

38 Terminated
PID   TT   STAT       TIME    COMMAND
520   p4   I       0:11:35  sh
1216  p6   S       0:01:11  qdaemon
839   p7   R       0:03:27  ps
$

The command kill 38 stops the background find process, and the second ps command returns no status information about PID number 38. The system does not display the termination message until you enter your next command.

Note that in this example, kill 38 and kill 0 have the same effect because only one process was started from this terminal or workstation.

In the C shell, the kill command has the following format:

kill % jobnumber

The following example uses the C shell to start another find process, to check its status with the jobs command, and then to terminate it:

%  find / -type f -print >dir.paths &

[3] 40

[3] +40 Running  find / -type f -print >dir.paths &

[3]  +Terminated    find / -type f -print > dir.paths
% _

6.4.4    Suspending and Resuming a Foreground Process (C Shell Only)

Stopping a foreground process and resuming it can be helpful when you have a long-duration process absorbing system resources and you need to do something quickly.

Rather than waiting for process completion, you can stop the process temporarily (suspend it), perform your more critical task, and then resume the process. Suspending a process is available for C shell users only.

To suspend a process, press Ctrl/Z. A message will display listing the job number, the status suspended, and the command executed.

Once you are ready to resume the process, enter:

%   n

To resume the process in the background, enter:

%   n  &

where the n entry is the number of the stopped job.

The following example starts a find process, suspends it, checks its status, resumes it, and then terminates it:

%  find / -type f -print >dir.paths &

[4] 41

[4] +41 Running  find / -type f -print >dir.paths &

Suspended

[4] +Stopped   find / -type f -print > dir.paths

[4] find / -type f -print >dir.paths &

[4] +Terminated   find / -type f -print > dir.paths

Once a process is suspended, you may also resume it by entering the fg command. If a currently running process is taking too long to run and is tying up your keyboard, you can use the bg command to place the process in the background and enter other commands.

The following example starts a find process, suspends it, puts the process in the background, copies a file, and then resumes the process in the foreground:

%  find / -type f -print >dir.paths

[Ctrl/Z]
Suspended

[5]    find / -type f -print > dir.paths &

find / -type f -print > dir.paths
%

6.5    Displaying Information About Users and Their Processes

The operating system provides the following commands that can tell you who is using the system and what they are doing:

who

Displays information about currently logged in users.

w

Displays information about currently logged in users and what they are currently running on their workstations.

ps au

Displays information about currently logged in users and the processes they are running.

The who command allows you to determine who is logged into the system. It may be especially useful, for example, when you want to send a message and want to know whether the person is currently available.

In the following example, information about all currently logged in users is displayed:

$  who

juan    tty01   Jan 15   08:33
chang   tty05   Jan 15   08:45
larry   tty07   Jan 15   08:55
tony    tty09   Jan 15   07:53
lucy    pts/2   Jan 15   11:24   (boston)
$

Note that the who command lists the username of each user on the system, the workstation being used, and when the person logged in. In addition, if a user is logged in from a remote system, the name of the system is listed. For example, lucy logged in remotely from the system boston on Jan 15 at 11:24.

The actual display format of who varies according to your current locale. See Appendix C for more information about locales. .md

The who -u command gives all the information of the who command and also displays the PID of each user and the number of hours and minutes since there was activity at a workstation. Activity for less than a minute is indicated by a dot (.).

In the following example, all currently logged in users are displayed:

$  who -u

juan   tty01   Jan 15   08:33   01:02   50
chang  tty05   Jan 15   08:45     .     52
larry  tty07   Jan 15   08:55     .     58
tony   tty09   Jan 15   07:53   01:20   60
lucy   pts/5   Jan 15   11:24     .     65  (boston)
$

Note that in the preceding example, juan and tony have been inactive for over an hour, while chang, larry, and lucy have been inactive for less than a minute.

Now that you know how to find out who is active on your system, you may want to find out what command each person is currently executing. The w command displays the command that is currently running at each user's workstation.

In the following example, information about all users (the User column) and their current commands (the what column) is displayed:

$  w

11:02 up 3 days, 2:40, 5 users, load average: 0.32, 0.20, 0.00
User     tty       login@  idle   JCPU   PCPU  what
juan     tty01     8:33am    12     54     14  -csh
chang    tty05     8:45am          6:20    26  mail
larry    tty07     8:55            1:58     8  -csh
tony     tty09     7:53    3:10      22     4  mail
lucy     tty02     11:24   1:40      18     4  -csh
$

In addition, the w command displays the following information:

• The tty column: user's workstation

• The login@ column: user's login time

• The idle column: amount of time since the user entered a command

• The JCPU column: total CPU time used during the current login session

• The PCPU column: CPU time used by the command that is currently executing

On certain occasions, you may want to have a detailed listing of current processes (both foreground and background) and the users who are running them. To get such a listing, use the ps au command. In the following example, information about five users and their active processes is displayed:

$  ps au

USER    PID %CPU %MEM   SZ  RSS TT STAT    TIME  COMMAND
juan  26300 16.5  0.8  441  327 p3 R     0:02:01  ps au
chang 25821  7.0  0.2  149   64 p4 R     0:12:23  mail -n
larry 25121  6.1  0.2  107   83 p22 R   26:25:07  tip modem
tony  11240  4.5  0.6  741  225 p19 R    1:57:46  emacs
lucy  26287  0.5  0.1   61   28 p1 S     0:00:00  more
$

The most important fields for the general user are the USER, PID, TIME, and COMMAND fields. For information on the remaining fields, see the ps(1) reference page.