Gemini on Question 14, Oct 1

The idiomatic way to handle this in Bash is to use the trap command coupled with the EXIT pseudo-signal.

However, the specific command you use inside the trap depends on whether you only need to kill direct children, or if you need to kill "grandchildren" (children that spawned their own children).

Here are the two standard approaches.

1. The Safest Way: Kill direct background jobs

If your script spawns background processes using &, the safest and most idiomatic way is to use jobs -p to get their PIDs and kill them on exit. This prevents you from accidentally killing processes outside your script.

#!/bin/bash

# Define the cleanup function
cleanup() {
    # Get PIDs of all background jobs started by this script
    local pids=$(jobs -p)
    if [[ -n "$pids" ]]; then
        echo "Cleaning up orphaned children..."
        kill $pids 2>/dev/null
    fi
}

# Catch the EXIT signal (which triggers on clean exits, errors, SIGINT, SIGTERM, etc.)
trap cleanup EXIT

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

echo "Parent doing work... press Ctrl+C to test."
sleep 10

2. The Aggressive Way: Kill the whole process group

If your child processes spawn their own children, jobs -p will leave orphaned grandchildren. To purge the entire process tree created by your script, you can send a signal to the process group using kill 0 or kill -- -$$.

Note: Be careful with this if your script is being piped to other commands (e.g., script.sh | grep foo), as they might share a process group.

#!/bin/bash

# Enable monitor mode so the script gets its own process group
set -m 

cleanup() {
    echo "Killing entire process group..."
    # 'kill 0' sends SIGTERM to all processes in the current process group
    # We redirect stderr to hide the "Terminated" message for the parent itself
    trap '' EXIT # Remove trap to prevent recursion
    kill 0 2>/dev/null
}

trap cleanup EXIT

# --- Your script logic below ---
# Even if this child spawns its own children, they will all die
(sleep 100; echo "Done") & 

echo "Parent working..."
sleep 10

The Unavoidable Limitation: kill -9 (SIGKILL)

It is important to know that Bash cannot catch kill -9 (SIGKILL). If the OOM (Out of Memory) killer or an angry sysadmin runs kill -9 <parent_pid>, your script will die instantly without running the trap, leaving the children orphaned.

If your script absolutely must guarantee that children die even if the parent receives a SIGKILL, Bash is the wrong tool. You have two options:

• 1.Systemd: Run your script as a systemd service. Systemd manages cgroups and will automatically kill all child processes when the parent service stops.
• 2.Linux prctl (pdeathsig): Use a language like Python, C, or Perl to set the PR_SET_PDEATHSIG flag. This tells the Linux kernel itself to send a signal to the child when the parent thread dies, regardless of how the parent died.