How to display Linux process details

Introduction

This tutorial will provide a comprehensive overview of Linux processes, covering the essential concepts, lifecycle, attributes, and different types of processes. You will learn how to monitor and manage Linux processes using various commands and tools, empowering you to effectively troubleshoot and optimize your Linux systems.

Linux Process Fundamentals

Linux processes are the fundamental building blocks of the operating system. A process is an instance of a computer program that is being executed. It represents the execution of a set of instructions by the computer's processor. In this section, we will explore the basic concepts of Linux processes, their lifecycle, attributes, and different types.

Process Lifecycle

The lifecycle of a Linux process can be represented using a state diagram. The main states a process can be in are:

graph LR
    NEW --> READY
    READY --> RUNNING
    RUNNING --> WAITING
    WAITING --> READY
    RUNNING --> TERMINATED

When a new process is created, it enters the NEW state. It then transitions to the READY state, waiting to be scheduled for execution. Once scheduled, the process enters the RUNNING state, where it utilizes the CPU. A running process can either transition to the WAITING state, when it is blocked on an I/O operation, or the TERMINATED state, when it finishes execution.

Process Attributes

Each Linux process has a set of attributes that define its state and characteristics. Some of the key process attributes are:

These attributes can be accessed and manipulated using various Linux commands and system calls.

Process Types

Linux supports different types of processes, each with its own characteristics and use cases:

1. Foreground Processes: These are interactive processes that are directly associated with a user's terminal session.
2. Background Processes: These are non-interactive processes that run in the background, without direct user interaction.
3. Daemon Processes: These are background processes that run continuously, providing system-level services.
4. Lightweight Processes (Threads): These are processes that share the same memory space and resources, allowing for efficient parallel execution.

Understanding the different process types and their use cases is crucial for effective process management in a Linux environment.

Monitoring Linux Processes

Effective monitoring and inspection of Linux processes is crucial for system administrators and developers to understand the state of their systems and troubleshoot issues. Linux provides a variety of tools and commands for this purpose. In this section, we will explore some of the commonly used process monitoring utilities.

The ps Command

The ps (process status) command is a fundamental tool for inspecting running processes. It allows you to view information about the current state of processes, such as their process ID (PID), user, CPU and memory usage, and more. Here's an example of using the ps command:

$ ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.4 18240 4424 ? Ss Apr04 0:01 /sbin/init
root 2 0.0 0.0 0 0 ? S Apr04 0:00 [kthreadd]
root 3 0.0 0.0 0 0 ? I 0:00 [rcu_gp] < Apr04

The ps command can be customized with various options to display specific process information.

The top Command

The top command provides a real-time, dynamic view of the running processes on the system. It displays information such as CPU and memory utilization, as well as detailed process-level metrics. The top command updates the display at regular intervals, allowing you to monitor system activity in real-time.

top - 12:34:56 up 123 days, 12:34,  1 user,  load average: 0.15, 0.20, 0.18
Tasks: 295 total,   1 running, 294 sleeping,   0 stopped,   0 zombie
%Cpu(s):  2.0 us,  1.0 sy,  0.0 ni, 97.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :  3921224 total,   378164 free,  1509596 used,  2033464 buff/cache
KiB Swap:  2097148 total,  2097148 free,        0 used.  1728312 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND
    1 root      20   0  118240   4424   2876 S  0.0  0.1   0:01.20 systemd
    2 root      20   0       0      0      0 S  0.0  0.0   0:00.00 kthreadd

The pstree Command

The pstree command displays a hierarchical view of the running processes, showing the parent-child relationships between them. This can be useful for understanding the process structure and dependencies within the system.

$ pstree
systemd─┬─accounts-daemon───2*[{accounts-daemon}]
        ├─agetty
        ├─atd
        ├─cron
        ├─dbus-daemon
        ├─dockerd─┬─containerd─┬─containerd-shim─┬─nginx───2*[nginx]
        │         │            └─2*[containerd-shim]
        │         └─7*[{dockerd}]
        ├─irqbalance
        ├─networkd-dispat
        ├─rsyslogd───2*[{rsyslogd}]
        ├─snapd───14*[{snapd}]
        ├─sshd───sshd───bash───pstree
        ├─systemd-journal
        ├─systemd-logind
        ├─systemd-network
        ├─systemd-resolve
        └─systemd-timesyn

These process monitoring tools provide valuable insights into the state and behavior of your Linux system, enabling you to identify and troubleshoot issues more effectively.

Managing Linux Processes

In addition to monitoring running processes, Linux provides a rich set of tools and techniques for managing processes. This includes creating new processes, controlling their execution, and adjusting their resource allocation. In this section, we will explore the various aspects of process management in a Linux environment.

Process Creation

New processes in Linux are created using the fork() system call, which creates a child process that is a duplicate of the parent process. The child process inherits the parent's environment, including memory, open files, and other resources. After the fork(), the child process can then execute a different program using the exec() system call.

Here's an example of creating a new process in C:

#include <stdio.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();
    if (pid == 0) {
        // Child process
        printf("Child process (PID: %d)\n", getpid());
    } else if (pid > 0) {
        // Parent process
        printf("Parent process (PID: %d, Child PID: %d)\n", getpid(), pid);
    } else {
        // Fork failed
        printf("Fork failed\n");
    }
    return 0;
}

Process Control

Linux provides various commands and system calls for controlling the execution of processes. Some common operations include:

• Sending signals to processes using the kill command or the kill() system call
• Suspending and resuming processes using the stop and continue commands
• Changing the priority of a process using the nice command or the setpriority() system call

These process control mechanisms allow you to manage the behavior and resource allocation of running processes.

Process Scheduling

The Linux kernel uses a preemptive, priority-based scheduling algorithm to determine which process should be executed at any given time. Processes are assigned a priority value, which can be adjusted using the nice command or the setpriority() system call.

The kernel's scheduler is responsible for selecting the next process to run based on factors such as process priority, CPU utilization, and I/O operations. Understanding the process scheduling mechanisms can help you optimize the performance of your Linux system.

By mastering the techniques for creating, controlling, and scheduling processes, you can effectively manage the execution of applications and services on your Linux system, ensuring optimal performance and resource utilization.

Summary

In this tutorial, you have learned the fundamental concepts of Linux processes, including their lifecycle, attributes, and different types. You have also explored the tools and commands used to monitor and manage processes on a Linux system. By understanding the inner workings of Linux processes, you can now effectively troubleshoot and optimize the performance of your Linux systems, ensuring their smooth and efficient operation.