Gemini on Question 14, Sep 16

The idiomatic way to handle cleanup in a Bash script when it exits (or dies) is to use the trap command tied to the EXIT pseudo-signal.

Here are the two most common and safest approaches, depending on how your script spawns children.

1. The Built-in Way (Using Job Control)

If your script spawns processes in the background using &, the safest and most idiomatic way is to kill them using Bash's built-in jobs -p command. This ensures you only kill processes directly started by your script.

#!/bin/bash

# Define the cleanup function
cleanup() {
    echo "Parent exiting, purging children..."
    
    # Get all background job PIDs and kill them.
    # Suppress errors in case some have already finished.
    kill $(jobs -p) 2>/dev/null
}

# Trap the EXIT signal
trap cleanup EXIT

# --- Your script logic below ---
echo "Starting background workers..."
sleep 100 &
sleep 200 &

# Simulate doing some work, then crashing or exiting
sleep 2
echo "Done."

Why this is good:

• •trap ... EXIT fires whether the script exits normally, crashes due to a syntax error, or receives a termination signal like SIGINT (Ctrl+C) or SIGTERM.
• •jobs -p is a Bash built-in, so it doesn't rely on external tools.

2. The pkill Way (For deeper process trees)

If your children spawn their own children (grandchildren) or detach from Bash's job control, jobs -p might not be enough. You can use pkill to target any process whose Parent PID (PPID) is your script's PID ($$).

#!/bin/bash

trap 'pkill -P $$' EXIT

# --- Your script logic below ---
sleep 100 &
sleep 200 &
sleep 2

Note: pkill -P $$ only kills direct children. If you need to kill an entire process tree (grandchildren included), it gets significantly more complex in plain Bash.

Advanced: The Process Group Way (Kill Everything)

If you want to absolutely ensure that every child and grandchild process spawned by your script dies, you can kill the entire process group by sending a signal to PID 0.

Warning: You must enable job control (set -m) so your script gets its own process group, otherwise kill 0 might kill your terminal session or SSH connection!

#!/bin/bash
set -m # Enable job control so this script gets its own process group

trap 'kill -- -$$ 2>/dev/null' EXIT

sleep 100 &
sleep 200 &
sleep 2

The Unavoidable Caveat: SIGKILL (kill -9)

No matter how perfectly you write your trap, it cannot catch SIGKILL (kill -9).
If the OOM (Out of Memory) killer or an angry sysadmin sends kill -9 to your parent script, it will die instantly, the trap will not execute, and the children will be orphaned.

If preventing orphans in a kill -9 scenario is absolutely critical, you cannot rely entirely on Bash. You would need to use a Linux-specific feature called prctl(PR_SET_PDEATHSIG, ...), which forces the kernel to send a signal to a child when its parent dies. Because Bash cannot make system calls easily, this is usually done by wrapping your child commands in a tiny Python, Perl, or C script.