Skip to content

Click on each book below to review & buy on Amazon.

As an Amazon Associate, I earn from qualifying purchases.

LPI Linux Essentials Exam 010-160 - Topic 4.3 - Processes

Introduction to Linux Processes

Linux, at its core, is a multi-tasking operating system, meaning it can run multiple tasks at the same time. This capability is crucial for both server and desktop environments. In Linux, these tasks are referred to as 'processes'. A process can be as simple as a command you run in your terminal, or as complex as a web server hosting a website.

Understanding Linux processes is vital for anyone using Linux. This knowledge helps you manage what's happening on your Linux system, troubleshoot issues, and optimize performance. Let's delve into the world of Linux processes.

What is a Process?

A process in Linux is an instance of a running program. When you start an application, whether it's a simple command in the terminal or a graphical program like a web browser, Linux creates a process for it. Each process in Linux has a unique identifier called a Process ID (PID). This PID is used by the system and the user to interact with the process.

Processes in Linux can be in one of several states:

  1. Running: The process is either running or ready to run.
  2. Waiting: The process is waiting for an event or for a resource.
  3. Stopped: The process is stopped, usually by receiving a signal.
  4. Zombie: The process has completed execution but still has an entry in the process table.

Processes are also organized in a hierarchical manner. When a process starts another process, the original process becomes the parent, and the new process is its child. This relationship is denoted through Parent Process ID (PPID).

The /proc Directory

In Linux, the /proc directory is a virtual filesystem that provides a window into the kernel's view of the system. It doesn't contain real files but runtime system information (e.g., system memory, devices mounted, hardware configuration, etc). Each process has a folder in /proc with its PID as the name. This folder contains information about the process, such as its current state, memory usage, and more.

Managing Processes

Linux offers several commands to manage processes, each with its unique function. Three common commands are:

  1. ps (Process Status): Displays information about active processes.
  2. top: Provides a dynamic, real-time view of running processes.
  3. free: Shows the amount of free and used memory in the system.

Each of these commands provides vital information about system processes and resource usage, which are essential for system monitoring and troubleshooting.

In the following sections, we will explore these commands in detail, including how to use them and understanding their output. We will also look at concepts like system load, which gives you a sense of how busy your system is, and delve deeper into the intricacies of process management in Linux.

Understanding and Managing Linux Processes

After getting familiar with what processes are in Linux, it's time to explore how to manage and monitor them. This understanding is key to ensuring your Linux system runs efficiently and securely.

Using the ps Command

The ps (process status) command is one of the most frequently used commands for process monitoring. It displays information about active processes running on the system.

To list all running processes, you can use ps -e, and for a more detailed view, ps -ef provides a full-format listing.

Example Output of ps Command

Here's an example of what the ps -e command might output:

  PID TTY          TIME CMD
    1 ?        00:00:02 systemd
    2 ?        00:00:00 kthreadd
    4 ?        00:00:00 kworker/0:0H

Each line represents a process with columns for:

  • PID: Process ID
  • TTY: Terminal type that the user is logged into
  • TIME: Amount of CPU time the process has used
  • CMD: Name of the command that initiated the process

Using the top Command

The top command is dynamic and continuously updates the information it displays. It's great for real-time monitoring of the system's processes. Simply type top in your terminal, and it will display a continuously updating view of the system processes.

Example Output of top Command

top - 08:32:19 up 1 day,  3:43,  2 users,  load average: 0.01, 0.03, 0.05
Tasks: 201 total,   1 running, 200 sleeping,   0 stopped,   0 zombie
%Cpu(s):  2.6 us,  1.0 sy,  0.0 ni, 96.1 id,  0.2 wa,  0.0 hi,  0.1 si,  0.0 st
MiB Mem :   7823.0 total,   4267.3 free,   2123.4 used,   1432.3 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   5412.7 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND     
  937 root      20   0  407692  58288  38084 S   0.3  0.7  18:23.45 Xorg        
 1123 user      20   0 3162480 258980 157296 S   0.7  3.2  35:27.89 gnome-shell 

The top command shows:

  • A summary of system information, like uptime, number of users, load average.
  • A list of processes with details like PID, user, priority, memory usage.

Using the free Command

The free command provides information about the total amount of free and used physical and swap memory on the system, as well as the buffers used by the kernel.

Typing free in your terminal provides a snapshot of memory usage, and for a more human-readable format, use free -h.

Example Output of free Command

Running the free command gives you a snapshot of the system's memory usage. Here's an example of the output, particularly using free -h for human-readable format:

              total        used        free      shared  buff/cache   available
Mem:           7.6G        3.1G        1.2G        598M        3.3G        3.0G
Swap:          2.0G          0B        2.0G

The output includes:

  • Total: Total amount of physical RAM and swap space.
  • Used: Amount of memory in use.
  • Free: Amount of free memory.
  • Shared: Memory used (mostly) by tmpfs.
  • Buff/Cache: Memory used as buffers and cache.
  • Available: Estimation of how much memory is available for starting new applications.

Understanding these commands and their outputs is fundamental in monitoring and managing the processes on your Linux system. As you get more comfortable with these commands, you'll be able to keep a closer eye on your system's health and performance.

Detailed Understanding of System Load in Linux

System load in Linux is a critical metric that reflects the amount of computational work your system is handling. It's not just a measure of CPU usage but an indicator of how many processes are actively using or waiting for CPU resources. This metric is crucial for assessing system performance and planning for capacity.

What Does System Load Represent?

The system load is expressed as three numbers, each representing the average load over the last one, five, and fifteen minutes. These numbers provide a snapshot of the system's state over time, offering insight into its performance trends.

  • 1 minute Load Average: Shows the immediate workload. It's a real-time indicator of how busy the system is.
  • 5 minute Load Average: Gives a medium-term trend, smoothing out short-term spikes.
  • 15 minute Load Average: Presents a long-term trend, indicating the overall system load over a more extended period.

Interpreting System Load Relative to CPU Cores

Understanding system load requires considering the number of CPU cores in your system. This context is key to accurately interpreting the load average values.

  1. Load Average Below Number of Cores: Indicates under utilization of CPU resources. If your system has 4 cores and the load average is below 4.00, it suggests that the CPU has idle time and is handling the workload efficiently.
  2. Load Average Around Number of Cores: Implies optimal utilization. For a system with 4 cores, a load average close to 4.00 means the CPU is fully utilized without being overloaded. There's little to no idle time, but the system isn't overwhelmed.
  3. Load Average Above Number of Cores: Suggests over utilization. Continuing with the 4-core example, a load average above 4.00 indicates that the CPU is overloaded, and processes are likely waiting for CPU time. This could lead to a slowdown in task execution and potentially impact system performance.

Factors Affecting System Load

System load is influenced not just by CPU-bound tasks but also by processes waiting for I/O operations (like disk access or network communication). High load averages might not always indicate CPU issues but could also point to I/O bottlenecks or other resource constraints.

In conclusion, the system load average in Linux is a multifaceted indicator that goes beyond CPU usage, encompassing overall system resource demand. Proper interpretation, especially in relation to the number of CPU cores, is essential for maintaining optimal system performance and health.

Process ID (PID) & Parent Process ID (PPID)

In Linux, every process is governed by two critical identifiers: the Process ID (PID) and the Parent Process ID (PPID). These identifiers are more than just numbers; they are essential to the Linux operating system's process management and system administration.

Process ID (PID)

The PID is a unique numerical identifier assigned to each process by the Linux kernel. This identifier is central to many system operations involving processes. It is used to distinguish each process in the system, enabling administrators and the system itself to track, manage, and interact with processes. For instance, when terminating a process, modifying its priority, or viewing its status, the PID is the key reference. PIDs are recycled over time, and there is an upper limit to the range of PIDs, set in the system kernel.

Parent Process ID (PPID)

Each process in Linux, except for the init process (PID 1), is created by another process. The creating process is known as the parent process, and its PID is the PPID of the new process. This parent-child relationship forms a hierarchy that is fundamental to process management in Linux. If a parent process terminates, its child processes are not left stranded; instead, they are adopted by the init process, ensuring a continuous and structured process tree. This hierarchy also plays a role in handling orphan and zombie processes—situations where child processes lose their parent or remain in the system after execution completion, respectively.

Operational Significance of PID and PPID

Understanding and utilizing PIDs and PPIDs is crucial in various aspects of system management:

  • In routine process management and troubleshooting, PIDs and PPIDs are used to monitor and manage the performance and behavior of processes.
  • In scripting and automation, accurately targeting processes based on their PIDs ensures effective execution of tasks.
  • From a security perspective, tracking the lineage and behavior of processes via their PIDs and PPIDs can be vital in auditing and detecting unauthorized or anomalous activities.

Tools and Commands Involving PID and PPID

Several commands and tools in Linux are designed to interact with and utilize PIDs and PPIDs, such as pstree for visualizing the process tree, and pgrep and pkill for searching and signaling processes based on various attributes. These tools enhance the ability to manage and oversee processes efficiently.

In essence, PIDs and PPIDs are fundamental to the Linux environment, serving as the backbone for process management, monitoring, and security. Their proper understanding and usage are indispensable for anyone operating within Linux systems.

The /proc Directory Revisited

The /proc directory is a pseudo-filesystem that contains a wealth of information about the system's processes and is essential for process management.

Exploring Process-Specific Information in /proc

Each process has its own directory in /proc, named after its PID. For example, /proc/1234 contains information about the process with PID 1234. These directories contain various files that hold different pieces of information about the process, such as:

  • /proc/<pid>/cmdline: Command line arguments of the process.
  • /proc/<pid>/environ: Environment variables for the process.
  • /proc/<pid>/status: Provides a brief overview of the process status.

System-Wide Information in /proc

Apart from process-specific information, /proc also contains files that provide system-wide information, such as:

  • cpuinfo: Information about the CPU, like its type, make, model, and performance.
  • meminfo: Details about the system's memory usage.
  • loadavg: Shows the system load average, similar to the top command.

Understanding these aspects of Linux processes allows for more effective monitoring and management of your system. With this knowledge, you can diagnose issues, optimize performance, and ensure that your system runs smoothly.


Here's a summary of the essential concepts in Linux process management, focusing on the key areas we discussed:

Understanding Linux Processes

  • Processes in Linux: These are the instances of running programs, each identified by a unique Process ID (PID). They are the basic units of task execution in the Linux operating system.
  • Process States: Processes in Linux can be in various states such as running, waiting, stopped, or zombie, each indicating the process's current status in the system.

Key Commands for Monitoring and Managing Processes

  • ps Command: Used to display information about the active processes on the system. It provides details like PID, command name, and process status.
  • top Command: Offers a dynamic, real-time overview of all running processes, along with system information such as CPU and memory usage.
  • free Command: Shows the total amount of free and used physical and swap memory in the system, which is vital for assessing the system's memory utilization.

System Load

  • System Load: A critical metric that shows the amount of computational work being handled by the system. It's represented by three numbers that reflect the average load over the past one, five, and fifteen minutes.

Process IDs

  • PID & PPID: Process ID (PID) is a unique number assigned to each process, while Parent Process ID (PPID) refers to the ID of the process that initiated it. Understanding these IDs is crucial for process identification and management.
  • /proc Directory: A virtual filesystem in Linux that provides detailed information about the system and its processes, including memory usage, configuration, and specific process details.

In this guide, we've covered the foundational aspects of Linux process management. These concepts are vital for anyone looking to understand or manage processes in a Linux environment.

Support DTV Linux

Click on each book below to review & buy on Amazon. As an Amazon Associate, I earn from qualifying purchases.

NordVPN ®: Elevate your online privacy and security. Grab our Special Offer to safeguard your data on public Wi-Fi and secure your devices. I may earn a commission on purchases made through this link.