Linux Signals and Process Management Tools

Linux signals are an essential concept for anyone looking to understand how processes communicate and interact within a Unix-like operating system. Signals are a form of inter-process communication (IPC) used to notify a process that a specific event has occurred. This blog post will explore signals, the tools kill, pkill, and pidof, and how to create a Python script that reacts differently to various signals sent using the kill command.

What Are Linux Signals?

A signal is a limited form of message that can be sent to a process. It informs the process to perform some action, such as termination or reloading its configuration. Each signal has a unique integer number and a symbolic name, such as:

• SIGHUP (1): Hangup detected on controlling terminal or death of controlling process.
• SIGINT (2): Interrupt from keyboard (Ctrl+C).
• SIGTERM (15): Termination signal.
• SIGKILL (9): Kill signal, cannot be caught or ignored.
• SIGUSR1 (10) and SIGUSR2 (12): User-defined signals for custom purposes.

Processes can handle some signals programmatically, while others (like SIGKILL) are not catchable.

List of Standard Linux Signals

You can list all signals with the following command:

bash📋
kill -L

But here is the organized list of signals with their descriptions:

Commands for Managing Signals

1. kill

The kill command sends a signal to a process. By default, it sends the SIGTERM signal. To specify a signal:

bash📋
kill -SIGKILL <pid>
kill -9 <pid> # You can use number as well

2. pkill

The pkill command allows you to send signals to processes by name:

bash📋
pkill -SIGUSR1 python
pkill -10 python

3. pidof

The pidof command retrieves the PID(s) of a process by name:

bash📋
pidof python

Combine it with kill to send a signal:

bash📋
kill -9 $(pidof python)

Exit Codes

This blog is not about exit codes. But we must mention that when a process is terminated by a signal, it will exit with a specific exit code unless the program is designed to handle with another exit code. The exit code is calculated as 128 + signal number. For example:

• SIGINT means 2 and it will exit with 128 + 2 = 130
• SIGKILL means 9 and it will exit with 128 + 9 = 137
• SIGTERM means 15 and it will exit with 128 + 15 = 143

Reacting to Signals in Python

Python provides the signal module, which allows a script to handle signals programmatically. Here is an example script that handles SIGINT, SIGTERM, and SIGUSR1 differently:

python📋
import signal
import os
import time

def handle_signal(signum, frame):
    if signum == signal.SIGINT:
        print("Received SIGINT (Ctrl+C). I don't want to exit.")
    elif signum == signal.SIGTERM:
        print("Received SIGTERM. Cleaning up before termination.")
        countdown = 5
        while countdown > 0:
            print(f"Exiting in {countdown} seconds...")
            time.sleep(1)
            countdown -= 1
        exit(128 + signum)
    elif signum == signal.SIGUSR1:
        print("Received SIGUSR1. Performing user-defined action.")
        print("I'm doing something...")
        time.sleep(3)
        print("I'm done.")
        exit(128 + signum)
    else:
        print(f"Received unknown signal: {signum}")

# Register signal handlers
signal.signal(signal.SIGINT, handle_signal)
signal.signal(signal.SIGTERM, handle_signal)
signal.signal(signal.SIGUSR1, handle_signal)

print(f"Process PID: {os.getpid()}")
print("Waiting for signals. Use kill or pkill to send signals to this process.")

try:
    while True:
        time.sleep(1)  # Keep the program running to receive signals
except KeyboardInterrupt:
    print("Program interrupted. Exiting.")

How to Test the Script

1. Save the script to a file, e.g., signal_handler.py.
2. Run the script:

bash📋
python3 signal_handler.py

3. Send signals to the process using its PID:

bash📋
kill -2 <pid>
kill -15 <pid>
kill -10 <pid>

You can also use pkill or combine pidof with kill to achieve the same.

Conclusion

Linux signals are a powerful tool for managing processes and enabling inter-process communication. Commands like kill, pkill, and pidof make it easier to work with signals in practice. By writing scripts that handle signals, you can add resilience and customization to your applications, allowing them to respond intelligently to system events. Experiment with the provided Python script to deepen your understanding of Linux signals!