What are the Process States in Linux/Unix?

To understand the inner workings of an operating system like Linux, it is essential to grasp the concept of Linux process states.

In Linux, a process can exist in several states, each representing a specific condition. These states provide crucial information about the current state of execution and resource allocation for each process. This article will explore the five Linux process states:

• The Runnable/Running state.
• The Sleeping state (which includes Interruptible and Uninterruptible sub-states).
• The Stopped state.
• The Zombie state.

Runnable/ Running State

• The Runnable/Running State:
  The Runnable/Running state indicates active CPU usage and task execution. A process in this state is actively progressing towards task completion, ready for scheduling by the operating system to utilize the CPU.
• Transition to the Runnable/Running State:
  A process transitions to the Runnable/Running state when it is ready to execute on the CPU. There are several scenarios where a process can transition to this state:
  • Process Creation:
    When a new process is created, it starts in the Runnable/Running state, waiting for its turn to execute. The process is allocated the necessary resources and is ready to begin its execution.
  • Waiting for Resources:
    If a process is waiting for certain resources, such as input from the user or data from an I/O device, it remains waiting. Once the required resources become available, the process transitions to the Runnable/Running state.
  • Interrupted Execution:
    In some cases, a running process may get interrupted by a signal from the operating system or another process. Once the interruption is handled, the process can resume its execution and transition back to the Runnable/Running state.
• Process Scheduling:
  • In a multitasking environment, multiple processes compete for the CPU's attention. The process scheduler determines the order in which processes are scheduled for execution. It ensures fair allocation of CPU time to each process, allowing them to make progress on their tasks.
  • The process scheduler uses different scheduling algorithms, such as round-robin, priority-based, or real-time scheduling. These algorithms consider factors like process priorities, execution history, and resource requirements to make informed decisions about process scheduling.
• Execution and Resource Utilization:
  • When a process is in the Runnable/Running state, it actively uses the CPU to execute its instructions and perform its tasks. The process utilizes system resources, Like memory, I/O devices, and network connections, to carry out its designated operations.
  • The execution of a process in the Runnable/Running state continues until one of the following occurs:
    • The process voluntarily yields the CPU, allowing other processes to run.
    • The process is preempted by a higher-priority process.
    • The process completes its execution and transitions to a different state.

Sleeping State

The Sleeping state is a process state in Linux where a process voluntarily suspends its execution and waits for a certain condition or event to occur before it can resume. When a process is in this state, it temporarily releases the CPU and enters a state of dormancy until the desired event or condition takes place.

• Interruptible Sleep (S-state):
  The Interruptible Sleep state, also known as the S-state, is a type of Sleeping state where a signal or an interrupt can wake up a process. When a process is in the Interruptible Sleep state, it is waiting for a specific event to occur, such as input from a user, completion of an I/O operation, or resource availability. While in this state, the process can respond to signals and other external events and be scheduled for execution.

• Uninterruptible Sleep (D-state):
  The Uninterruptible Sleep state, also known as the D-state, is a type of Sleeping state where a process is waiting for a particular event or condition to occur. However, unlike the Interruptible Sleep state, a process in the Uninterruptible Sleep state cannot be woken up by a signal or an interrupt. This state is typically used for processes that are waiting for a specific I/O operation to complete, such as reading data from a slow disk. While in this state, the process is unresponsive to signals and remains blocked until the desired event happens.

Difference between Interruptible and Uninterruptible Sleep State:

The difference between the Interruptible Sleep state and the Uninterruptible Sleep state lies in the ability to respond to signals. Processes in the Interruptible Sleep state can be woken up and resume execution upon receiving a signal, whereas processes in the Uninterruptible Sleep state are not responsive to signals until the blocking condition is satisfied.

Stopped State

• The Stopped State:
  • The Stopped state is a process state that represents a process that has been stopped or suspended by a user or a debugger.
  • When a process is in the Stopped state, it is not executing any instructions and is temporarily halted. This state allows for troubleshooting, analysis, and control of processes by users or debugging tools.
• Process Pausing and Examination:
  • When a process is stopped, it means that its execution has been paused, typically to examine its state or to modify its behavior.
  • Processes can be stopped for various reasons, such as debugging, analyzing program execution, or modifying process attributes.
  • Users or debuggers may intentionally stop a process from investigating its memory contents, inspect variable values, or step through the code to understand its behavior.
• Halting Execution without Termination:
  • The Stopped state provides a mechanism to halt the execution of a process without terminating it.
  • This is particularly useful in scenarios where precise control over the execution flow is required for debugging purposes or when certain actions need to be taken on a process before allowing it to continue.
• Transitioning to the Stopped State:
  • A process can transition to the Stopped state in different ways. One common method is through the use of signals.
  • The user or a debugger can send a specific signal, such as the SIGSTOP signal (with signal number 19), to pause the execution of a process.
  • This signal temporarily suspends the process and enters the Stopped state until further action is taken.

Zombie State

• The Zombie State:
  • The Zombie state refers to a terminated process that still has an entry in the process table.
  • When a process completes its execution, it becomes a zombie process until its parent process retrieves its exit status through the wait() system call.
  • Zombie processes consume minimal system resources, but their presence in large numbers can indicate a problem in the system.
  • It is the responsibility of the parent process to properly handle the termination of its child processes and prevent them from becoming zombies.
• Termination of Processes and Zombie State:
  • When a process completes its execution, it transitions to the Zombie state. This transition occurs when the process calls the exit() system call to terminate itself.
  • However, the process remains in the process table until its parent process retrieves its exit status using the wait() system call.
  • The zombie process acts as a placeholder, allowing the parent process to obtain the termination information it needs.
• Retrieving Exit Status and Clearing Zombies:
  • The responsibility of clearing zombie processes lies with the parent process. The parent process can retrieve the exit status of its terminated child processes by calling the wait() or waitpid() system call.
  • These calls allow the parent process to collect the termination information and release the resources associated with the child process.

How to Check Linux Process States?

Now, let's explore how we can check the state of processes running on our system. Linux provides various tools and commands that allow us to monitor and manage processes effectively.

One of the most commonly used commands for checking Linux process states is ps. The ps command displays information about active processes on the system, including their process IDs (PIDs), states, and resource utilization. We can filter and display processes based on their states by using the appropriate options with the ps command.

Another useful command is top, which provides a real-time, dynamic view of the system's processes and resource usage. It displays an interactive table that includes information about process states, CPU usage, memory consumption, and more. With top, you can sort processes based on different criteria and easily identify processes in specific states.

How to Display the Linux Process States?

Let's take a closer look at how we can use the ps and top commands to display the process states in Linux.

Using "ps"

To display the process states using the ps command, we can combine it with the aux options. Open a terminal and enter the following command:

This command will provide a detailed list of all processes running on the system, along with their states. The second column in the output represents the state of each process. The states are represented by single-letter codes, such as "R" for the Runnable state, "S" for the Sleeping state, "T" for the Stopped state, and "Z" for the Zombie state.

Using "top" Command

To display the process states using the top command, open a terminal and enter the following command:

The top command presents an interactive interface that continuously updates the information about processes. By default, it sorts the processes based on CPU usage. To sort the processes based on their states, press "O" (capital O) while the top is running. This will display a list of sorting options. Move the cursor to the "S" (state) option and press Enter. The processes will be sorted based on their states, and you can easily identify them in specific states.