Managing processes in Linux
Thursday, 8 November 2007, adz
As we promised, we continue our “Console tricks” saga covering a bit more advanced topics now. Today we’re going to learn the idea of process in Linux and we’ll excel at managing, prioritizing and… killing them(!) Have a good reading.
Before we begin, it would be reasonable to give a process definition and explain the meaning of a couple of the connected terms. Generally speaking, a process is a program being executed that exists in some particular state. These states are:
- new – the process was just created
- ready – the process is waiting to be executed by the system’s CPU
- running – the process is currently executed by the system’s CPU
- blocked – the process is waiting for an event or for a resource to be assigned
- ended – the process is finishing its action
The process receives access to the system resources such as CPU, storage, files, and I/O devices. Each process has its own Process ID (PID) and Parent Process ID (PPID). Where one may present running processes in a tree-form, a process with PID=0 (the init process) is a root. As in files, each case process has an owner assigned. The owner of the process is a user who has executed a given program. There is one exception:when the program runs with setuid or setgid bit. The process’ access rights depend on a users access rights to the system’s resources (e.g., files in the /dev directory). To communicate with the processes, so called signals are initiated and used. These programs are executed with different priorities, defined by a number nice. The number gets values from -20 (the highest) to 19 (the lowest), the default value being 0.
2. fg, bg, jobs
A terminal enables us to run a couple of programs in the same time. Switching between one terminal to another is done simply by moving one program from “the first plan” to the “background”.: only first-plan-process can receive data from the user. One can compare moving processes to the active window, where it covers other (inactive) windows.
To run a program in the background, it is enough to add an $ (Ampersand) sign at the end of a command.
$ mpg123 -q file.mp3&  638 $
Running mpg123 in the background, I can listen to the music without loosing my access to shell. The shell displayed the job number in the square brackets -1 and its PID – 638.
To display a list of background jobs one should use the jobs command. It has an additional parameter, -l, that additionally gives the PID number of a given job.
$ jobs -l - 638 Running mpg123 -q file.mp3 & + 878 Stopped (tty output) mc
This example shows that two jobs are running in the background: mpg123 is running since it does not need any interaction with user, and mc is being stopped and waiting for data.
To make a specific process run, the first-plan-process one should use the fg %job number command, or fg %?command name, or just a part of the name.
$ fg %1 $ fg %mpg
In the first example, I’ve moved the job to the first-plan using its job number. In the second example, I’ve used a part of the name.
The fg %job number command will run stopped background-process, and — not like fg — will not move this process to the first plan.
$ mpg123 -q file.mp3 Ctrl + z + Stopped mpg123 -q file.mp3 $ bg %3 + mpg123 -q file.mp3 &
It is worth noticing one more thing here: data, sent by the background-program, are displayed on the screen (the standard output). To change this you may use a pipe to redirect the stream to trash, e.g. command > /dev/null
3. ps, pstree
The command jobs presented earlier in this article display processes that are currently executed on a given terminal. To view the full list of processes executed within a system one may use the ps command. This command, used without options, works just like jobs. Full descriptions of all the options used by the ps command are available after typing man ps. Here are the most interesting options:
- -e displays all the processes that are executed by the system
- -l provides a detailed description
- -f provides a detailed description, but shorted than when -l is used
- -H displays all the processes in a ps tree-like form
- a displays all the processes
- x displays all the processes that were run without terminal usage
- u processes the user name
- f displays the processes in tree-like form
We can add options to ps in two formats: either the System V format (options with -) or the BSD format. The output of the command with options aux appear similar to this:
$ ps aux USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.0 0.1 2952 1852 ? Ss 10:49 0:01 /sbin/init adam 5623 0.0 0.6 27892 7100 ? Ssl 10:51 0:00 /usr/bin/gnome-session adam 6815 0.2 1.6 39880 16728 ? S 11:11 0:14 gedit adam 7105 0.0 0.2 5708 3060 pts/1 Ss 11:16 0:00 bash
The meaning of the column headings:
- USER – user name, the process owner
- PID – the process id
- %CPU – estimated percent of CPU usage (it is the time of CPU usage by the process divided by the system uptime)
- %MEM – estimated memory usage
- VSZ – virtual memory usage in KB
- RSS – physical memory usage in KB
- TTY – terminal on which the process were executed
- STAT – the process state, D = I\O data awaiting, R = is executed in the moment, S = sleep, T = stopped, X dead (it should not been displayed), Z = zombie process
- START = – hour when the process started to run
- TIME – the time of CPU usage
- COMMAND – the command that started the process
The pstree command displays processes in a tree-like form. We can add the option -a to display the command that started the process.
$ pstree -a init ├─cupsd ├─dbus-daemon --system ├─gedit └─gnome-terminal ├─bash │ └─man ps │ └─pager -s ├─bash │ └─man ps │ └─pager -s └─bash └─pstree -a
The top command enables the user to see the processes in real time. The option -u user name enables displaying only selected users’ processes, -pPID enables displaying the process with a selected PID (this option can be added up to 20 times).
$ top top - 17:38:09 up 43 min, 2 users, load average: 0.32, 0.17, 0.06 Tasks: 124 total, 1 running, 123 sleeping, 0 stopped, 0 zombie Cpu(s): 1.5%us, 0.2%sy, 0.0%ni, 98.3%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st Mem: 1026304k total, 560996k used, 465308k free, 42120k buffers Swap: 1020116k total, 0k used, 1020116k free, 246652k cached PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 7391 adam 15 0 189m 56m 21m S 3 5.6 0:20.42 firefox-bin 7517 adam 15 0 2368 1164 876 R 1 0.1 0:00.03 top 4029 root 13 -2 1744 384 280 S 0 0.0 0:00.76 ipw3945d-2
To quit this program one should use q. Useful keybinds:
- F or O to change sorting
- space to refresh the screen
- < , > for sorting using displayed columns
- r to change the nice value of the process
- W to save current top settings to file ~/.toprc
- k to send a signal to the process
htop displays the processes list in a more sophisticated graphical form. This program uses the ncurses library. This library is usually it is not available by default.
- cursors – moving between processes
- F1 – help menu
- F2 – settings
- F3 – find a process
- F4 – switch sorting
- F5 – display processes in tree-like form
- F6 – change sorting type
- F7 – decrease the priority of selected process
- F8 – increase the priority of selected process
- F9 – send a signal to a process
- F10 – quit
It sends signals to the processes. Syntax is following: kill signal PID. The default signal is SIGTERM (value: 15). It “gently” ends the program, allowing it to close open files and “clean up” the working environment and any consequences. Stronger is another SIGKILL (value 9). It enforces a program to stop immediately. The SIGSTOP signal stops the SIGKILL execution and the SIGCONT signal brings the execution back online. You can send a signal to a process using its name or its numerical value.
$ kill -SIGKILL 7496 kill -9 7496
In both cases the process with PID 7496 will be “killed”.
Using this command you may use the process’ name (regular expressions might also be used) e.g.:
$ killall mplayer
It kills all the processes named mplayer. An interesting option is -l. This option displays all the possible signals. In some systems, like Solaris, this command kills all the processes that the user can kill. If it is used by root, it shutdowns the system.
This command is connected with a SIGHUP signal. Historically, this signal reported on terminal connection loss. Today, it is used to inform that the pseudo-terminal on which the program is running has stopped working (or has finished), and all the programs have ended their work as well (or have also finished). The process started with the nohup command will ignore this signal.
$ nohup pidgin nohup: add results to `nohup.out'
If the program’s output was not redirected to a file, nohup redirects it to the nohup.out by default.
8. pidof, pgrep
This are small but useful commands, that gives PID of the command.
$ pidof nautilus 5668 $ pgrep nautilus 5668
Pgrep can be used with option -l, that displays the program’s name and PID. We can use also -u users' name, -G group name that displays processes belonging to the selected user or group.
$ kill `pidof mplayer`
In this example, I used pidof to close mplayer without knowing its PID.
This command changes the priority of the process. The highest possible priority is -20 and the lowest is 19. These priority changes can be performed only by root.
$ renice 19 `pidof top` 12344: old priority 0, new priority 19
Option -u users' name changes priority of all processes of that user, where -g group name changes priority of all processes of that group.
$ renice 5 -u adam 1000: old priority 2, new priority 5
Subscribe to RSS feed for this article!
Warning: include(0php’): failed to open stream: No such file or directory in /sites/polishlinux.org/wp-content/themes/jakilinuxorg/page.php on line 70
Warning: include(): Failed opening '0php’' for inclusion (include_path='.:/usr/share/pear:/usr/share/php') in /sites/polishlinux.org/wp-content/themes/jakilinuxorg/page.php on line 70