Claude on Question 14, Oct 1

For most scripts, the idiom is a trap that kills your tracked children on exit:

#!/usr/bin/env bash
set -euo pipefail

pids=()
cleanup() {
  # negate PIDs if children spawn their own grandchildren (see below)
  kill "${pids[@]}" 2>/dev/null || true
  wait "${pids[@]}" 2>/dev/null || true
}
trap cleanup EXIT INT TERM

worker_one &  pids+=("$!")
worker_two &  pids+=("$!")

wait

Explicit PID tracking is preferable to kill $(jobs -p) because jobs -p is empty-prone (kill with no args errors) and only sees current-shell jobs.

The process-group shortcut

You'll see this a lot:

trap 'kill 0' EXIT

kill 0 signals the entire current process group, which conveniently catches grandchildren too. The catch: it's only safe if your script is the process-group leader. An interactive shell with job control puts each script in its own group, so it works when you test it by hand — but if someone later invokes your script from another script, it shares the caller's group and kill 0 takes out the parent too. Guard it:

if [[ "$(ps -o pgid= -p $$ | tr -d ' ')" == "$$" ]]; then
  trap 'kill 0' EXIT
fi

Or force your own group up front with setsid.

Two gotchas worth knowing

Traps don't fire on SIGKILL. If the parent is kill -9'd or OOM-killed, no cleanup runs and the children get reparented to PID 1. Traps are best-effort only.

Killing a child doesn't kill its descendants. If your worker is itself a shell or a supervisor, signaling the direct child leaves the grandchildren running. Use kill -- -"$pid" on a process group (requires the child be a group leader, e.g. started via setsid), or go the cgroup route.

SIGKILL-proof on Linux

Have the kernel do it with PR_SET_PDEATHSIG, exposed by util-linux 2.33+:

setpriv --pdeathsig TERM -- long_running_cmd &

The child now gets SIGTERM the moment its parent dies, regardless of how the parent died. Caveat: it fires when the thread that forked exits, and it's cleared across setuid execs — but for ordinary scripts it behaves as expected.

Heavier duty

For anything where leaked processes are genuinely costly, use a cgroup and let the kernel account for the whole tree:

systemd-run --user --scope --collect -- ./my_script.sh

Everything spawned inside lands in one scope; when the scope dies the cgroup is reaped, no cooperation from children required. This is what you want for CI runners, test harnesses, and anything spawning containers or JVMs.

Defense in depth

If you can modify the child, a liveness poll is a decent backstop:

while kill -0 "$PPID" 2>/dev/null; do
  do_work
  sleep 1
done

Checking [[ $PPID -eq 1 ]] is a common variant, though it's unreliable under modern init systems and subreapers, which may reparent to something other than PID 1.

My usual default: tracked PIDs plus trap for the common path, setpriv --pdeathsig when I control how children are spawned and need the SIGKILL guarantee.