Process states and transitions in a Unix process

Introduction

A process is a program or an instance of a program being executed in the memory. Any program executed creates a process or multiple processes. A program can be a command, any binary executable, a shell script, or any application program. However, not all the commands end up in the creating process. As you know, there are always exceptions.

Also see, Process v/s Program, Multiprogramming vs Multitasking

Process States

Process states refer to the various conditions that a process can be in during its lifetime within an operating system. These states typically include:

New: The process is being created.
Ready: The process is ready to execute but waiting for the CPU.
Running: The process is currently executing on the CPU.
Blocked (Waiting or Sleep): The process is waiting for an event to occur (e.g., I/O operation) before it can continue.
Terminated: The process has finished execution.

Process Transitions

Process transitions describe how a process moves from one state to another. These transitions are governed by events or conditions within the system, such as:

Creation: Transition from the "New" state to the "Ready" state when the process is ready for execution.
Dispatch: Transition from the "Ready" state to the "Running" state when the operating system allocates CPU time to the process.
Blocking: Transition from the "Running" state to the "Blocked" state when the process requests a resource or encounters an event that requires waiting.
Unblocking (or Wake-up): Transition from the "Blocked" state to the "Ready" state when the required resource becomes available or the event occurs.
Completion: Transition from any state to the "Terminated" state when the process finishes execution.

Types of Processes

The processes in Unix are divided into two categories, that are:

User processes: The processes that are operated in user mode.
Kernel processes: The processes that are operated in kernel mode.

Also see, Introduction to Process Management
Now we will know about user mode and kernel mode.

User mode

User mode is where all processes that aren't part of the kernel (aka "non-kernel processes") run. A process can only directly access its memory in user mode by default. This is to protect processes from each other and prevent a bug in one process from causing another process to crash.

Kernel mode

Kernel mode, also known as system mode, is a central processing unit (CPU) operating mode. While processes run in kernel mode, they have unrestricted access to the hardware.

Now we learn about the process states and transitions in the Unix process.

The lifetime of any process can be divided into a set of different states. The following describes are the complete set of process states and how transitions take place.

The process is executed in user mode; in other words, the process is the user process.
The process is executing in kernel mode, or it is kernel process.
The process is not executing, but it is ready to execute as soon as the kernel schedules it.
The process is sleeping and is in the main memory.
The process is ready to execute (or run), but the swapper must swap the process into the main memory before the kernel may schedule it to execute.
In this state, the process is sleeping, and the swapper has swapped the process to the secondary storage to make room(or space) for other processes in the main memory.
The process is returning from the kernel mode to user mode, but somehow the kernel preempts it and starts scheduling other processes by context switching.
The process is newly created and currently is in the transition state; the process exists, but it is not ready to execute, nor is it sleeping. This state is also the start state for all the processes. You can say it is the beginning as the process is newly created.
The process executed the exit system call, and it is in the zombie state. Now the process no longer exists, but it leaves a record containing an exit code and some timing statistics for its parent process to collect. We will learn about the zombie states in detail. The zombie state is the final stage of the process.

Zombie state

A process will terminate when it calls the 'system exit' API or when someone else kills the process. Whenever a process terminates, it will release all the data structures and the resources it holds during its execution. However, it will not release its slot in the 'process' table. Instead, the process will send a SIGCHLD signal to its parent process.

A SIGCHLD signal in Unix is a trap signal that indicates a process started by the current process has terminated.

Now it's on to the parent process to release its child process slot in the 'process' table. When the child process issues the SIGCHLD signal, the process will be in the ZOMBIE state until the parent process releases the slot in the 'process' table.

“Recommended Topic, procedure call in compiler design and Open Source Operating System."

Advantages of UNIX Process States and Transitions

Efficient Resource Management: UNIX process states and transitions allow for efficient allocation and management of system resources by enabling the operating system to prioritize and schedule processes effectively.
Concurrency Handling: UNIX process states and transitions facilitate concurrent execution of multiple processes by providing mechanisms for process synchronization, communication, and scheduling.
Fault Tolerance: The ability to transition processes between different states allows UNIX systems to handle errors, exceptions, and failures gracefully, enhancing system reliability and fault tolerance.
Resource Utilization: UNIX process states and transitions enable optimal utilization of system resources by efficiently managing the execution lifecycle of processes, minimizing idle time, and maximizing CPU and memory usage.
System Stability: By effectively managing process states and transitions, UNIX systems can maintain system stability and prevent deadlock, livelock, and other concurrency-related issues.

Monitoring and Managing Process States

Monitoring and managing process states involve the following tasks:

Process State Monitoring: Continuously monitor the state of processes in the system using tools like ps or top command in UNIX. This helps in understanding system behavior, identifying bottlenecks, and diagnosing performance issues.
State Transition Analysis: Analyze process state transitions to identify patterns, trends, and anomalies. Understanding how processes transition between states can provide insights into system performance, resource utilization, and potential optimizations.
State Transition Control: Implement strategies to control process state transitions, such as adjusting scheduling policies, optimizing resource allocation, or prioritizing critical processes. This helps in improving system responsiveness, efficiency, and stability.
Automated Management: Utilize automated monitoring and management tools or scripts to streamline process state monitoring and control. Automated processes can help in proactive system management, alerting administrators to potential issues and taking corrective actions.
Resource Allocation: Manage system resources effectively based on process states and requirements. For example, allocate CPU time, memory, and I/O resources dynamically to optimize system performance and responsiveness.

Frequently Asked Questions

What do you mean by process states and transitions in a Unix process?

A process is a program or an instance of a program being executed in the memory. Any program executed creates a process or multiple processes. Process state is the state field in the process descriptor and, a process descriptor is a task_struct - type data structure whose fields contain all of the information about a single process.
On the other hand, Transition is the process in which something changes from one state to another.

What is the Unix process model?

The Unix process model is a hierarchical system where processes are created through forking, forming parent-child relationships.

What are the 4 process states in Linux?

The four process states in Linux are "Running", "Waiting" (or "Blocked"), "Stopped", and "Zombie".

Conclusion

In this blog on process states and transitions of a Unix process, we learned about the concept of processes and how they work; we learn the two types of processes: user process and kernel process, with their brief description. We learn about the process states and transitions of a Unix process, and we also study the different states, which show the life cycle of a process.

Process States and Transitions in a Unix Process