Find, control and stop processes

There are shell jobs (started from your terminal) and daemons (services started by systemd). You manage them in different ways.

A command with & at the end runs in the background, so your terminal stays free.

$sleep 600 &
[1] 4123
$dd if=/dev/zero of=/dev/null &
$jobs
[1]-  Running                 sleep 600 &
[2]+  Running                 dd if=/dev/zero of=/dev/null &

Every process is started by a parent. When the parent ends, the children usually end too — except daemons, which belong to systemd (PID 1).

$ps -ef --forest | grep -A2 sshd
$pstree -p | head -20
$systemd-cgls --no-pager | head -30

ps takes a snapshot of the processes. Two styles are common: ps aux (BSD) and ps -ef (UNIX).

$ps aux | head -5
USER   PID %CPU %MEM    VSZ   RSS TTY  STAT START   TIME COMMAND
root     1  0.0  0.4 174876 16420 ?    Ss   07:58   0:02 /usr/lib/systemd/systemd --switched-root --system
$ps -ef | grep httpd
$ps -fp 1010
$ps -eo pid,ppid,user,%cpu,%mem,cmd --sort=-%mem | head

A process can have many threads that share its memory. The kernel schedules threads; ps and top can show them.

$ps -eLf | grep chronyd
$ps -o nlwp,cmd -p $(pidof chronyd)
$top -H -p $(pidof chronyd)

The nice value goes from -20 (highest priority) to 19 (lowest). A process with a higher nice value is "nicer" to others: it gets less CPU when the CPU is busy.

nice starts a command with a nice value; renice changes a running process.

$nice -n 10 tar -czf /tmp/backup.tgz /home
#nice -n -5 important-task
#renice -n 5 -p 4123
#renice -n -10 -p $(pidof myapp)
$ps -o pid,ni,cmd -p 4123

systemd puts every process in a cgroup. Processes are grouped into slices: system.slice (services), user.slice (logged-in users) and machine.slice (VMs, containers). CPU is shared between the slices first.

$systemd-cgls --no-pager | head -25
$systemd-cgtop
$systemctl status user.slice

kill sends a signal to a process. The default signal asks the process to stop in a clean way.

$kill 4123
$kill -9 4123
$kill -l
$killall dd
$pkill -u lisa
$pkill -HUP sshd
$pgrep -l -u apache

A zombie (state Z) is a process that ended, but its parent did not read the exit status yet. It uses no CPU or memory, only a place in the process table. You cannot kill a zombie — it is already dead.

$ps -eo pid,ppid,stat,cmd | awk '$3 ~ /Z/'
$ps -o ppid= -p ZOMBIE_PID

top shows the processes live, sorted by CPU, with the load and memory at the top. You can also kill and renice from it.

$top
$top -u apache
$top -b -n 1 | head -15

$uptime
 10:52:01 up  2:54,  2 users,  load average: 0.15, 0.10, 0.09
$nproc
2
$free -h

tuned sets many kernel and hardware settings at once with a profile for a type of system.

#dnf install -y tuned
#systemctl enable --now tuned
$tuned-adm list
$tuned-adm active
$tuned-adm recommend
#tuned-adm profile virtual-guest
#tuned-adm off

The most important facts of this chapter, in short.

The words of this chapter in simple English.

Think about the answer first, then open it.