Shotts Ch. 10

The most commonly used command to view processes (there are several) is ps. The ps program has a lot of options, but in its simplest form it is used like this: [me@linuxbox ~]$ ps PID TTY TIME CMD 5198 pts/1 00:00:00 bash 10129 pts/1 00:00:00 ps The result in this example lists two processes, process 5198 and process 10129, which are bash and ps, respectively. As we can see, by default, ps doesn't show us very much, just

the processes associated with the current terminal session. To see more, we need to add some options; however, before we do that, let's look at the other fields produced by ps. \

ps: Another popular set of options is aux (without a leading dash). This gives us even more information. This set of options displays

the processes belonging to every user. Using the options without the leading dash invokes the command with "BSD-style" behavior. The Linux version of ps can emulate the behavior of the ps program found in several different Unix implementations.

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as (describe)

daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process.

Command to: (Place a job in the foreground)

fg

The top program accepts a number of keyboard commands. The two most interesting are (describe)

h, which displays the program's help screen, and q, which quits top

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without

having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process.

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process. The kernel maintains information about each process to help keep things organized. For example, each process is assigned a number called a process ID (PID). PIDs are assigned in ascending order, with __ always getting PID 1.

init

Process States: Meaning of state: <: A high-priority process. It's possible to grant more importance to a process, giving it more time on the CPU. This property of a process is called

niceness. A process with high priority is said to be less nice because it's taking more of the CPU's time, which leaves less for everybody else

ps: If we add an option, we can get a bigger picture of what the system is doing. Adding the x option (note that there is no leading dash) tells ps to show all of our processes regardless of what terminal (if any) they are controlled by. The presence of a ? in the TTY column indicates

no controlling terminal. Using this option, we see a list of every process that we own.

Process States: Meaning of state: N: A low-priority process. A process with low priority (a nice process) will get processor time only after

other processes with higher priority have been serviced.

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process. The kernel maintains information about each process to help keep things organized. For example, each process is assigned a number called a process ID (PID). PIDs are assigned in ascending order, with init always getting PID 1. The kernel also keeps track of the memory assigned to each process, as well as the processes' readiness to resume execution. Like files, processes also have (3)__ and so on.

owners and user IDs, effective user IDs,

ps: If we add an option, we can get a bigger picture of what the system is doing. Adding the x option (note that there is no leading dash) tells ps to show all of our processes regardless of what terminal (if any) they are controlled by. The presence of a ? in the TTY column indicates no controlling terminal. Using this option, we see a list of every process that we own. Because the system is running a lot of processes, ps produces a long list. It is often helpful to

pipe the output from ps into less for easier viewing. Some option combinations also produce long lines of output, so maximizing the terminal emulator window might be a good idea, too.

The ps program has a lot of options, but in its simplest form it is used like this:

"[me@linuxbox ~]$ ps" Result: PID TTY TIME CMD 5198 pts/1 00:00:00 bash 10129 pts/1 00:00:00 ps

BSD Style ps Column Headers (from ps aux command). Header with meaning: (CPU usage in percent.)

%CPU

BSD Style ps Column Headers (from ps aux command). Header with meaning: (Memory usage in percent.)

%MEM

Process States: Meaning of state: Z

A defunct or "zombie" process. This is a child process that has terminated but has not been cleaned up by its parent.

Process States: Meaning of state: <

A high-priority process. It's possible to grant more importance to a process, giving it more time on the CPU. This property of a process is called niceness. A process with high priority is said to be less nice because it's taking more of the CPU's time, which leaves less for everybody else

Process States: Meaning of state: N

A low-priority process. A process with low priority (a nice process) will get processor time only after other processes with higher priority have been serviced.

PIDs are assigned in what order?

Ascending order

ps: Another popular set of options is aux (without a leading dash). This gives us even more information. This set of options displays the processes belonging to every user. Using the options without the leading dash invokes the command with "__" behavior. The Linux version of ps can emulate the behavior of the ps program found in several different Unix implementations.

BSD-style

BSD Style ps Column Headers (from ps aux command). Meaning of header: %CPU

CPU usage in percent.

Process States: State with meaning: (Uninterruptible sleep. The process is waiting for I/O such as a disk drive.)

D

What this command does: top

Display tasks

top Information Fields: Row 4: Identify field and meaning.

Field: "Mem:". Meaning: This shows how physical RAM is being used.

top Information Fields: Row 5: Identify field and meaning.

Field: "Swap:". Meaning: This shows how swap space (virtual memory) is being used

top Information Fields: Row 2: Field and meaning:

Field: "Tasks:". Meaning: This summarizes the number of processes and their various process states.

What this command does: killall

Kill processes by name

What this command does: jobs

List active jobs

BSD Style ps Column Headers (from ps aux command). Meaning of header: %MEM

Memory usage in percent.

Process States: State with meaning: (A low-priority process. A process with low priority (a nice process) will get processor time only after other processes with higher priority have been serviced.)

N

Indicate the columns displayed from ps x command: (5)

PID; TTY; STAT; TIME; COMMAND

What this command does: bg

Place a job in the background

What this command does: fg

Place a job in the foreground

Process States: State with meaning: (Running. This means the process is running or ready to run.)

R

BSD Style ps Column Headers (from ps aux command). Header with meaning: (Resident set size. This is the amount of physical memory (RAM) the process is using in kilobytes.)

RSS

What this command does: ps

Report a snapshot of current processes

BSD Style ps Column Headers (from ps aux command). Meaning of header: RSS

Resident set size. This is the amount of physical memory (RAM) the process is using in kilobytes.

Process States: Meaning of state: R

Running. This means the process is running or ready to run.

Process States: State with meaning: (Sleeping. The process is not running; rather, it is waiting for an event, such as a keystroke or network packet.)

S

BSD Style ps Column Headers (from ps aux command). Header with meaning: (Time when the process started. For values over 24 hours, a date is used.)

START

What this command does: kill

Send a signal to a process

What this command does: shutdown

Shut down or reboot the system

Process States: Meaning of state: S

Sleeping. The process is not running; rather, it is waiting for an event, such as a keystroke or network packet.

Process States: Meaning of state: T

Stopped. The process has been instructed to stop. You'll learn more about this later in the chapter.

Process States: State with meaning: (Stopped. The process has been instructed to stop.)

T

top Information Fields: Fields in row 1 and their meaning: "load average:" . Meaning: Load average refers to the number of processes that are waiting to run; that is, the number of processes that are in a runnable state and are sharing the CPU. Three values are shown, each for a different period of time. (describe the periods of time)

The first is the average for the last 60 seconds, the next the previous 5 minutes, and finally the previous 15 minutes. Values less than 1.0 indicate that the machine is not busy.

BSD Style ps Column Headers (from ps aux command). Meaning of header: START

Time when the process started. For values over 24 hours, a date is used.

BSD Style ps Column Headers (from ps aux command). Header with meaning: (User ID. This is the owner of the process.)

USER

BSD Style ps Column Headers (from ps aux command). Indicate 6:

USER; %CPU; %MEM; VSZ; RSS; START

Process States: Meaning of state: D

Uninterruptible sleep. The process is waiting for I/O such as a disk drive.

BSD Style ps Column Headers (from ps aux command). Meaning of header: USER

User ID. This is the owner of the process.

BSD Style ps Column Headers (from ps aux command). Header with meaning: (Virtual memory size.)

VSZ

BSD Style ps Column Headers (from ps aux command). Meaning of header: VSZ

Virtual memory size.

Now that we can see and monitor processes, let's gain some control over them. For our experiments, we're going to use a little program called xlogo as our guinea pig. The xlogo program is a sample program supplied with the __ (the underlying engine that makes the graphics on our display go), which simply displays a resizable window containing the X logo.

X Window System

Process States: State with meaning: (A defunct or "zombie" process. This is a child process that has terminated but has not been cleaned up by its parent.)

Z

BSD Style ps Column Headers (from ps aux command). Meaning of header: START: Time when the process started. For values over 24 hours,

a date is used.

Process States: Meaning of state: D: Uninterruptible sleep. The process is waiting for I/O such as

a disk drive.

Process States: Meaning of state: S: Sleeping. The process is not running; rather, it is waiting for an event, such as __ or __

a keystroke or network packet.

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process. The kernel maintains information about each process to help keep things organized. For example, each process is assigned

a number called a process ID (PID). PIDs are assigned in ascending order, with init always getting PID 1. The kernel also keeps track of the memory assigned to each process, as well as the processes' readiness to resume execution. Like files, processes also have owners and user IDs, effective user IDs, and so on.

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as

a parent process producing a child process. The kernel maintains information about each process to help keep things organized. For example, each process is assigned a number called a process ID (PID). PIDs are assigned in ascending order, with init always getting PID 1. The kernel also keeps track of the memory assigned to each process, as well as the processes' readiness to resume execution. Like files, processes also have owners and user IDs, effective user IDs, and so on

The top program displays a continuously updating (by default, every three seconds) display of the system processes listed in order of process activity. The name top comes from the fact that the top program is used to see the "top" processes on the system. The top display consists of two parts:

a system summary at the top of the display, followed by a table of processes sorted by CPU activity.

Command to: (Place a job in the background)

bg

Let's say we wanted to get the shell prompt back without terminating the xlogo program. We can do this by

placing the program in the background. Think of the terminal as having a foreground (with stuff visible on the surface like the shell prompt) and a background (with stuff hidden behind the surface). To launch a program so that it is immediately placed in the background, we follow the command with an ampersand (&) character.

The top program displays a continuously updating (by default, every three seconds) display of the system processes listed in order of

process activity. The name top comes from the fact that the top program is used to see the "top" processes on the system. The top display consists of two parts: a system summary at the top of the display, followed by a table of processes sorted by CPU activity.

top Information Fields: Row 3: Cpu(s): the character of the activities that the CPU is performing. Identify and describe the fields: -Field: "0.7%us". Meaning: 0.7 percent of the CPU is being used for user processes. This means

processes outside the kernel

Modern operating systems are usually multitasking, meaning they create the illusion of doing more than one thing at once by rapidly switching from one executing program to another. The kernel manages this through the use of

processes. Processes are how Linux organizes the different programs waiting for their turn at the CPU

Command to: (Report a snapshot of current processes)

ps

The most commonly used command to view processes (there are several) is

ps

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn,

runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process. The kernel maintains information about each process to help keep things organized. For example, each process is assigned a number called a process ID (PID). PIDs are assigned in ascending order, with init always getting PID 1. The kernel also keeps track of the memory assigned to each process, as well as the processes' readiness to resume execution. Like files, processes also have owners and user IDs, effective user IDs, and so on

Command to: (Shut down or reboot the system)

shutdown

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which

start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process. The kernel maintains information about each process to help keep things organized. For example, each process is assigned a number called a process ID (PID). PIDs are assigned in ascending order, with init always getting PID 1. The kernel also keeps track of the memory assigned to each process, as well as the processes' readiness to resume execution. Like files, processes also have owners and user IDs, effective user IDs, and so on

ps: If we add an option, we can get a bigger picture of what the system is doing. Adding the x option (note that there is no leading dash) tells ps to show all of our processes regardless of what terminal (if any) they are controlled by. The presence of a ? in the TTY column indicates no controlling terminal. Using this option, we see a list of every process that we own. Because the system is running a lot of processes, ps produces a long list. It is often helpful to pipe the output from ps into less for easier viewing. Some option combinations also produce long lines of output, so maximizing the terminal emulator window might be a good idea, too. A new column titled STAT has been added to the output. STAT is short for __ and...__

state; reveals the current status of the process, as shown in Table 10-1.

The most commonly used command to view processes (there are several) is ps. The ps program has a lot of options, but in its simplest form it is used like this: [me@linuxbox ~]$ ps PID TTY TIME CMD 5198 pts/1 00:00:00 bash 10129 pts/1 00:00:00 ps The result in this example lists two processes, process 5198 and process 10129, which are bash and ps, respectively. As we can see, by default, ps doesn't show us very much, just the processes associated with the current terminal session. To see more, we need to add some options; however, before we do that, let's look at the other fields produced by ps. TTY is short for "__" and refers to __...

teletype; the controlling terminal for the process. Unix is showing its age here. The TIME field is the amount of CPU time consumed by the process. As we can see, neither process makes the computer work very hard.

The most commonly used command to view processes (there are several) is ps. The ps program has a lot of options, but in its simplest form it is used like this: [me@linuxbox ~]$ ps PID TTY TIME CMD 5198 pts/1 00:00:00 bash 10129 pts/1 00:00:00 ps The result in this example lists two processes, process 5198 and process 10129, which are bash and ps, respectively. As we can see, by default, ps doesn't show us very much, just the processes associated with the current terminal session. To see more, we need to add some options; however, before we do that, let's look at the other fields produced by ps. TTY is short for "teletype" and refers to the controlling terminal for the process. Unix is showing its age here. The TIME field is the amount of CPU time consumed by the process. As we can see, neither process makes the computer work very hard. If we add an option, we can get a bigger picture of what the system is doing. Adding the x option (note that there is no leading dash)...

tells ps to show all of our processes regardless of what terminal (if any) they are controlled by. The presence of a ? in the TTY column indicates no controlling terminal. Using this option, we see a list of every process that we own.

The most commonly used command to view processes (there are several) is ps. The ps program has a lot of options, but in its simplest form it is used like this: [me@linuxbox ~]$ ps PID TTY TIME CMD 5198 pts/1 00:00:00 bash 10129 pts/1 00:00:00 ps The result in this example lists two processes, process 5198 and process 10129, which are bash and ps, respectively. As we can see, by default, ps doesn't show us very much, just the processes associated with the current terminal session. To see more, we need to add some options; however, before we do that, let's look at the other fields produced by ps. TTY is short for "teletype" and refers to the controlling terminal for the process. Unix is showing its age here. The TIME field is

the amount of CPU time consumed by the process. As we can see, neither process makes the computer work very hard.

BSD Style ps Column Headers (from ps aux command). Meaning of header: RSS: Resident set size. This is

the amount of physical memory (RAM) the process is using in kilobytes.

top Information Fields: Row 3: Cpu(s): This row describes

the character of the activities that the CPU is performing.

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process. The kernel maintains information about each process to help keep things organized. For example, each process is assigned a number called a process ID (PID). PIDs are assigned in ascending order, with init always getting PID 1. The kernel also keeps track of (2)

the memory assigned to each process, as well as the processes' readiness to resume execution. Like files, processes also have owners and user IDs, effective user IDs, and so on.

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in,

the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process.

While the ps command can reveal a lot about what the machine is doing, it provides only a snapshot of the machine's state at the moment the ps command is executed. To see a more dynamic view of the machine's activity, we use

the top command.

The top program displays a continuously updating (by default, every three seconds) display of the system processes listed in order of process activity. The name top comes from the fact that

the top program is used to see the "top" processes on the system. The top display consists of two parts: a system summary at the top of the display, followed by a table of processes sorted by CPU activity.

Modern operating systems are usually multitasking, meaning

they create the illusion of doing more than one thing at once by rapidly switching from one executing program to another.

Command to: (Display tasks)

top

ps x: The process state may be followed by other characters. These indicate

various exotic process characteristics. See the ps man page for more details.

top Information Fields: Fields in row 1 and their meaning: (5)

- Field: "top". Meaning: This is the name of the program. -Field: "14:59:20". Meaning: This is the current time of day. -Field: "up 6:30". Meaning: This is called uptime. It is the amount of time since the machine was last booted. In this example, the system has been up for six and a half hours. -Field: "2 users". Meaning: There are two users logged in. -Field: "load average:" . Meaning: Load average refers to the number of processes that are waiting to run; that is, the number of processes that are in a runnable state and are sharing the CPU. Three values are shown, each for a different period of time. The first is the average for the last 60 seconds, the next the previous 5 minutes, and finally the previous 15 minutes. Values less than 1.0 indicate that the machine is not busy.

top Information Fields: Row 3: Cpu(s): the character of the activities that the CPU is performing. Identify and describe the fields: (5)

-Field: "0.7%us". Meaning: 0.7 percent of the CPU is being used for user processes. This means processes outside the kernel -Field: "1.0%sy". Meaning: 1.0 percent of the CPU is being used for system (kernel) processes. -Field: "0.0%ni". Meaning: 0.0 percent of the CPU is being used by "nice" (low-priority) processes. -Field: "98.3%id". Meaning: 98.3 percent of the CPU is idle. -Field: "0.0%wa". Meaning: 0.0 percent of the CPU is waiting for I/O.

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in __) called init scripts, which start all the system services.

/etc

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process. The kernel maintains information about each process to help keep things organized. For example, each process is assigned a number called a process ID (PID). PIDs are assigned in ascending order, with init always getting PID __(#). The kernel also keeps track of the memory assigned to each process, as well as the processes' readiness to resume execution. Like files, processes also have owners and user IDs, effective user IDs, and so on.

1

top Information Fields: Fields in row 1 and their meaning: "load average:" . Meaning: Load average refers to the number of processes that are waiting to run; that is, the number of processes that are in a runnable state and are sharing the CPU. Three values are shown, each for a different period of time. The first is the average for the last 60 seconds, the next the previous 5 minutes, and finally the previous 15 minutes. Values less than __ indicate that the machine is not busy.

1.0

Process States: State with meaning: ( A high-priority process. It's possible to grant more importance to a process, giving it more time on the CPU. This property of a process is called niceness. A process with high priority is said to be less nice because it's taking more of the CPU's time, which leaves less for everybody else)

<

ps: If we add an option, we can get a bigger picture of what the system is doing. Adding the x option (note that there is no leading dash) tells ps to show all of our processes regardless of what terminal (if any) they are controlled by. The presence of a __ in the TTY column indicates no controlling terminal. Using this option, we see a list of every process that we own.

?

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called init. init, in turn, runs a series of shell scripts (located in /etc) called

init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process. The kernel maintains information about each process to help keep things organized. For example, each process is assigned a number called a process ID (PID). PIDs are assigned in ascending order, with init always getting PID 1. The kernel also keeps track of the memory assigned to each process, as well as the processes' readiness to resume execution. Like files, processes also have owners and user IDs, effective user IDs, and so on

How a Process Works: When a system starts up, the kernel initiates a few of its own activities as processes and launches a program called

init. init, in turn, runs a series of shell scripts (located in /etc) called init scripts, which start all the system services. Many of these services are implemented as daemon programs, programs that just sit in the background and do their thing without having any user interface. So, even if we are not logged in, the system is at least a little busy performing routine stuff. The fact that a program can launch other programs is expressed in the process scheme as a parent process producing a child process. The kernel maintains information about each process to help keep things organized. For example, each process is assigned a number called a process ID (PID). PIDs are assigned in ascending order, with init always getting PID 1. The kernel also keeps track of the memory assigned to each process, as well as the processes' readiness to resume execution. Like files, processes also have owners and user IDs, effective user IDs, and so on

Let's observe what happens when we run xlogo again. First, enter the xlogo command and verify that the program is running. Next, return to the terminal window and press CTRL-C. [me@linuxbox ~]$ xlogo [me@linuxbox ~]$ In a terminal, pressing CTRL-C...

interrupts a program. This means we are politely asking the program to terminate. After we pressed CTRL-C, the xlogo window closed, and the shell prompt returned.

Both major desktop environments provide graphical applications that display information similar to top (in much the same way that Task Manager in Windows works), but top is better than the graphical versions because

it is faster and it consumes far fewer system resources. After all, our system monitor program shouldn't be the source of the system slowdown that we are trying to track

Command to: (List active jobs)

jobs

Command to: (Send a signal to a process)

kill

Command to: (Kill processes by name)

killall

Process States: Meaning of state: <: A high-priority process. It's possible to grant more importance to a process, giving it more time on the CPU. This property of a process is called niceness. A process with high priority is said to be

less nice because it's taking more of the CPU's time, which leaves less for everybody else