Linux Process Management Explained — ps, kill, jobs and signals

#!/usr/bin/env bash
# process_tree_inspection.sh
# Goal: Understand where a process comes from and who owns it

# --- Step 1: Find the PID of the current shell ---
current_shell_pid=$$   # $$ is a special variable holding the current process's PID
echo "Current shell PID: $current_shell_pid"

# --- Step 2: Start a background sleep to give us something to inspect ---
sleep 300 &            # The & sends the process to the background immediately
sleep_pid=$!           # $! captures the PID of the last background command
echo "Background sleep PID: $sleep_pid"

# --- Step 3: Inspect the process in detail using ps ---
# -o lets us choose exactly which columns to display
# pid=process id, ppid=parent process id, stat=state, cmd=full command
echo ""
echo "--- Detailed view of our sleep process ---"
ps -o pid,ppid,stat,user,cmd -p "$sleep_pid"

# --- Step 4: Show how this process fits in the full tree ---
echo ""
echo "--- Process tree rooted at our shell ---"
pstree -p "$current_shell_pid"   # -p shows PIDs next to each process name

# --- Step 5: Clean up — kill our background sleep gracefully ---
kill "$sleep_pid"      # Sends SIGTERM (signal 15) by default — polite shutdown request
echo ""
echo "Sent SIGTERM to sleep process $sleep_pid. It should be gone now."

# --- Step 6: Confirm it's gone ---
sleep 0.2              # Give the kernel a moment to clean up
if ! kill -0 "$sleep_pid" 2>/dev/null; then
  # kill -0 doesn't actually kill — it just checks if the process exists
  echo "Confirmed: PID $sleep_pid no longer exists."
fi

#!/usr/bin/env bash
# process_state_diagnosis.sh
# Goal: Show how to read process states and identify problematic ones

# --- Snapshot of all processes with state info ---
# a = all users, u = user-oriented format, x = include processes without a terminal
echo "=== Full process snapshot (top 20 by CPU) ==="
ps aux --sort=-%cpu | head -20
# Output columns: USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND

echo ""
echo "=== Processes currently in Uninterruptible Sleep (D state) ==="
# These are the dangerous ones — they can't be killed and indicate I/O problems
ps aux | awk '$8 ~ /^D/ { print $0 }'
# awk checks column 8 (STAT) for a value starting with D

echo ""
echo "=== Zombie processes on this system ==="
# Zombies start with Z in the STAT column
zombie_count=$(ps aux | awk '$8 ~ /^Z/ { count++ } END { print count+0 }')
echo "Zombie count: $zombie_count"
if [ "$zombie_count" -gt 0 ]; then
  echo "Zombies found — listing with parent PIDs:"
  ps aux | awk '$8 ~ /^Z/ { print $0 }'
  echo ""
  echo "To fix zombies: identify the parent (PPID) and restart it."
  echo "The parent is responsible for calling wait() to reap its children."
fi

echo ""
echo "=== Top 5 memory consumers ==="
ps aux --sort=-%mem | awk 'NR==1 || NR<=6 { print $0 }'
# NR==1 preserves the header row, NR<=6 gives us 5 data rows

#!/usr/bin/env bash
# signal_management_demo.sh
# Goal: Demonstrate the right signal for each situation

# --- Part 1: Graceful shutdown vs forced kill ---
# Start a simulated long-running service
sleep 600 &
long_running_pid=$!
echo "Started fake service with PID: $long_running_pid"

# The RIGHT first step — ask politely
echo "Sending SIGTERM (graceful shutdown request)..."
kill -SIGTERM "$long_running_pid"   # Same as: kill -15 $long_running_pid

# Wait up to 5 seconds for graceful shutdown
for wait_seconds in 1 2 3 4 5; do
  sleep 1
  if ! kill -0 "$long_running_pid" 2>/dev/null; then
    echo "Process exited cleanly after ${wait_seconds}s. Good."
    break
  fi
  if [ "$wait_seconds" -eq 5 ]; then
    echo "Process didn't respond to SIGTERM after 5s. Now using SIGKILL."
    kill -SIGKILL "$long_running_pid"   # Only escalate when SIGTERM fails
  fi
done

echo ""

# --- Part 2: SIGHUP for zero-downtime config reload ---
# In production you'd do: kill -SIGHUP $(cat /var/run/nginx.pid)
# Let's simulate it with a script that catches SIGHUP
cat > /tmp/signal_catcher.sh << 'SCRIPT'
#!/usr/bin/env bash
trap 'echo "[PID $$] Caught SIGHUP — reloading config (no restart needed)"' SIGHUP
trap 'echo "[PID $$] Caught SIGTERM — shutting down cleanly"; exit 0' SIGTERM
echo "[PID $$] Service started. Waiting for signals..."
while true; do sleep 1; done
SCRIPT
chmod +x /tmp/signal_catcher.sh

/tmp/signal_catcher.sh &
catcher_pid=$!
sleep 0.5   # Give it a moment to start

echo "--- Simulating config reload with SIGHUP ---"
kill -SIGHUP "$catcher_pid"         # nginx does this — reload config, keep serving traffic
sleep 0.3

echo ""
echo "--- Simulating graceful shutdown with SIGTERM ---"
kill -SIGTERM "$catcher_pid"        # Clean exit
wait "$catcher_pid" 2>/dev/null     # Wait for it to finish before exiting this script

echo ""
echo "--- All signals on this system (for reference) ---"
kill -l   # Print all signal names and numbers

#!/usr/bin/env bash
# job_control_workflow.sh
# Goal: Show the complete job control lifecycle including background survival

# --- Part 1: Basic job management ---
echo "=== Starting three background jobs ==="

# Simulate three different long-running tasks
sleep 120 &   # Pretend this is a database backup
backup_pid=$!
echo "Backup job started — PID: $backup_pid, Job: $!"

sleep 240 &   # Pretend this is a data export
export_pid=$!
echo "Export job started — PID: $export_pid"

sleep 360 &   # Pretend this is a log archive
archive_pid=$!
echo "Archive job started — PID: $archive_pid"

echo ""
echo "=== All current jobs in this shell ==="
jobs -l   # -l includes PIDs alongside job numbers

echo ""
echo "=== Suspending the export job (simulating Ctrl+Z) ==="
kill -SIGTSTP "$export_pid"   # Same signal as pressing Ctrl+Z interactively
sleep 0.2

echo "Job state after SIGTSTP:"
jobs -l   # Export should now show as 'Stopped'

echo ""
echo "=== Resuming export in the background ==="
bg %2    # %2 refers to job number 2 (the export). bg sends SIGCONT
sleep 0.2
jobs -l  # Should be back to Running

echo ""
# --- Part 2: Making a job survive terminal closure ---
echo "=== Running a job that survives SSH disconnection ==="

# nohup redirects stdout/stderr to nohup.out and makes process immune to SIGHUP
nohup sleep 9999 > /tmp/persistent_job.log 2>&1 &
persistent_pid=$!
echo "Persistent job PID: $persistent_pid"

# disown removes it from shell job table — terminal closing won't affect it
disown "$persistent_pid"
echo "Job $persistent_pid disowned — it will survive terminal closure"

# Verify it's no longer in the job table
echo ""
echo "Current jobs (persistent_pid should NOT appear):"
jobs -l

echo ""
echo "But it IS still in the process table:"
ps -p "$persistent_pid" -o pid,stat,cmd

# --- Cleanup ---
kill "$backup_pid" "$export_pid" "$archive_pid" "$persistent_pid" 2>/dev/null
wait 2>/dev/null
echo ""
echo "All jobs cleaned up."