Implement Signal Handling for Inter-Process Notification

Async Notification

Signals are software interrupts delivered to processes: SIGINT from Ctrl-C, SIGCHLD when children exit, SIGSEGV on bad memory. Handlers run asynchronously unless masked, complicating reentrant code.

Handler Rules

Safe patterns:

• Install handler with sigaction, not signal
• Use volatile sig_atomic_t flags in handler
• Do heavy work in main loop, not handler

For example, a SIGUSR1 handler setting got_signal = 1 lets the main thread drain work cooperatively.

Why This Matters in Production

SIGTERM-triggered graceful shutdown is exactly what systemd sends before SIGKILL when stopping a service, and Kubernetes relies on the same contract to give a pod's main process a chance to drain connections before its termination grace period expires. The volatile sig_atomic_t requirement here isn't pedantic: calling non-async-signal-safe functions like printf or malloc inside a real handler is a documented cause of heap corruption and deadlocks, since a signal can interrupt malloc mid-operation.

Debugging Checklist

Before you call the implementation done, walk failure modes on purpose. Test empty structures, single-element edge cases, maximum concurrency, and errno paths that must not crash the program. OS code usually fails in production when happy-path tests pass but invariants break under contention or memory pressure.

Implementation Notes

Keep structures small and name fields after kernel counterparts when possible. That lets you read man pages and kernel source side by side while you work. Print observable events during development; remove noisy logs once tests pass reliably.

For This Exercise

You will register handlers, send signals with kill, and reap children on SIGCHLD. This exercise requires demonstrating restart of slow syscalls with SA_RESTART vs EINTR.