Signals and Interrupts
Interrupts are how hardware talks to software; signals are how the kernel talks to your process. Both arrive unannounced, and both force a detour in execution. This video traces the full path: the device raises an IRQ line, the CPU interrupts, the kernel runs the handler, and — for signals — your process returns to user mode only to find a handler to run first.
Topics covered:
- Interrupt lines, the IDT, and what the CPU saves on an interrupt
- Top half vs. bottom half: why handlers must be short
- Signals as software interrupts: the pending mask and the signal trampoline
- Which syscalls get interrupted and the EINTR convention
- Async-signal-safety: why you can't call malloc() in a signal handler
sigaction, handler chaining, and how runtimes like Node's libuv use signals- How the kernel delivers SIGSEGV on bad memory and SIGCHLD on exit
Related articles
The OOM Killer and Memory Pressure: Who Dies and Why
When reclaim fails, the kernel executes: how oom_score picks the victim, why overcommit makes malloc lie, and why killing innocent processes is a feature, not a bug.
What Really Happens During a System Call
Trap, ring transition, and the syscall table — the cost of asking the kernel for help and why it's never free.
cgroups and Container Isolation: Why Docker Is Not a VM
Namespaces change what a container sees; cgroups control what it gets — CPU shares, memory limits, the freezer — and the shared-kernel security reality behind Docker.
More in Operating Systems
Virtual Memory in One Diagram
Page tables, TLB, demand paging, and copy-on-write — how your 16GB laptop 'has' 128GB of addressable memory.
WatchContainer Isolation in Linux
What Docker and Kubernetes containers actually are — namespaces, cgroups, and the syscalls that make isolated processes without a VM.
DetailsLocks and Synchronization Primitives
Mutexes, spinlocks, semaphores, and condition variables — how they map to hardware atomics and futexes, and when each one is the right tool.
DetailsMemory-Mapped Files
How mmap() maps a file into your address space — demand paging from disk, the page cache, and why mapped I/O beats read() and write().
DetailsFile Systems Explained
How a file system stores your data — inodes, directory entries, extents, and journaling — and what actually happens on read and write.
DetailsThread Pools Explained
How thread pools work under the hood — worker threads, work queues, and why reusing threads beats spawning them for every request.
DetailsSyscalls Under the Hood
What actually happens when your program calls read(), open(), or fork() — the trap, the kernel mode switch, and the return path.
DetailsVirtual Memory Explained
Address translation, page tables, and the TLB — the full path from a virtual address to the physical RAM cell, including why the translation is cached.
DetailsProcess Scheduling, Visualized
How the Linux scheduler picks the next runnable process — time slices, priorities, CFS virtual runtime, and why your busy server still feels responsive.
DetailsDepth, delivered weekly
One technical dispatch a week — articles and episode notes before they go public.
One technical dispatch per week. No noise.