Forward signals to child processes using `trap` and `kill -TERM $!`

Mastering Signal Handling in Linux Bash: Using `trap` and `kill -TERM $!`

Linux provides powerful tools for handling program signals in a script. This capability is crucial for writing robust scripts that can properly clean up after themselves when an unexpected event occurs, such as a user cancellation or a system shutdown. In this article, we’ll answer some common questions on how to forward signals to child processes using trap and kill -TERM $!, and demonstrate how to use these tools effectively.

Q1: What is a signal in Linux?

A: In Linux, a signal is a limited form of inter-process communication used to notify a process that a specific event has occurred. Examples include SIGINT for an interrupt (like pressing Ctrl+C), SIGTERM for a termination request, and SIGKILL for an immediate termination command.

Q2: What do `trap` and `kill` commands do in Bash scripts?

A: The trap command allows you to specify a script or command to execute when the script receives a signal. For example, you can clean up temporary files if the script is interrupted. The kill command is used to send a specific signal to a process. For example, kill -TERM $! sends a SIGTERM signal to the most recently executed background process.

Q3: How can I forward signals to a child process in a Bash script?

A: To forward signals to a child process, you can set a trap in the parent shell script that catches signals and then forwards them to child processes using kill. Here’s a step-by-step guide: 1. Start a child process in the background. 2. Catch signals in the parent using trap. 3. Use kill to send the caught signal to the child process.

Simple Explanation: How Does It All Work?

When a Bash script runs, it can spawn child processes. By default, killing the parent process doesn't necessarily stop its children. Using the trap command, we can define what happens when the parent receives specific signals (like SIGTERM). Then, with kill -TERM $!, we forward that signal to the last job run in the background ($! stores the PID of the last background process).

Executable Script to Demonstrate:

#!/bin/bash

# Function to handle signals
clean_up() {
    echo "Received signal, forwarding to child..."
    kill -TERM $childPID
    wait $childPID
    echo "Child process terminated."
    exit 0
}

# Set traps for SIGTERM and SIGINT
trap 'clean_up' SIGTERM SIGINT

# Start a long-running background process
sleep 300 &
childPID=$!

echo "Started background process with PID $childPID"
echo "Parent PID $$"

# Wait for child process to finish
wait $childPID

Run the script and then send a SIGINT (Ctrl+C) or SIGTERM (kill -TERM [PID of this script]) to test how the signal is caught by the trap and forwarded to the child process.

Summary and Conclusion

Understanding how to handle signals with trap and how to forward them using kill is essential for creating resilient and responsive Bash scripts. This approach ensures that your scripts can handle interruptions gracefully, performing necessary cleanup and ensuring that no stray processes are left running. The technique demonstrated helps maintain control over both foreground and background processes, making your scripts more reliable in a multi-process environment. Being adept at these concepts can significantly enhance the robustness of your system scripts and automation tasks.

Mastering Signal Handling in Linux Bash: Using trap and kill -TERM $!