Operating Systems Workbook

The three jobs of an OS — virtualize hardware, manage concurrency, persist state — and why each one matters.

Abstractions, low overhead, protection and isolation, reliability. The criteria every kernel decision is weighed against.

Hardware privilege levels, system calls, trap-and-emulate, and the cost of crossing the boundary.

How the CPU runs user code at full speed while the OS still keeps control — traps, trampolines, timer interrupts.

Process state (running / ready / blocked), address space, PCB, and the kernel's view of a running program.

The UNIX trio that creates and controls processes. Why fork+exec is the standard idiom and what dup/pipe add on top.

Saving and restoring CPU state across processes — register sets, kernel stack, the cost paid every preemption.

Four classic scheduling disciplines, their turnaround / response-time trade-offs, and where each breaks down.

Adaptive priority queues, priority boosts to prevent starvation, accounting tricks to defeat gaming.

Probabilistic fair-share scheduling, ticket mechanisms, and how CFS uses red-black trees for O(log n) operations.

Cache affinity, single-queue vs per-CPU queues, load balancing, and why scaling beyond one core is hard.

Code / heap / stack layout, why each process gets its own view, and the three goals (transparency, efficiency, protection).

Heap allocation in user space, common errors (use-after-free, double-free, leaks), and how the allocator talks to the OS via brk / mmap.

The simplest hardware mechanism for memory virtualization — relocation registers, bounds checks, OS responsibilities.

Generalised base/bounds per code/heap/stack segment, sharing across processes, fragmentation as the recurring cost.

Allocator strategies — first-fit, best-fit, worst-fit, next-fit, segregated free lists, buddy, slab — and what fragmentation actually costs.

Fixed-size pages, page tables, valid / present / protection bits, and the cost paid on every memory access without a cache.

The cache that makes paging fast. Miss handling (HW vs SW), context-switch invalidation, ASIDs, and a real TLB entry's bits.

Sparse address spaces, x86_64's 4-level walk, the time-space trade-off, inverted page tables, hashed alternatives.

Swap space, the present bit, page fault control flow, copy-on-write, prefetching, and when replacements actually happen.

The classic algorithms, why OPT is unachievable, how CLOCK approximates LRU cheaply, and the thrashing wall.

The Linux address space layout, four-level page tables, page cache, huge pages, KASLR — what a real production VM stack looks like.

Why threads, the heart of the problem (uncontrolled scheduling), atomicity, and the wish that motivates every primitive.

pthread_create / join / mutex / cond — the canonical thread surface and the gotchas around using it correctly.

Test-and-set, compare-and-swap, fetch-and-add, two-phase locks, and why a spinlock is rarely the right answer in user space.

Concurrent counters, linked lists, queues, and hash tables — coarse-grained vs hand-over-hand vs lock-free, and where each one breaks under contention.

Wait / signal / broadcast, the always-use-while rule, the producer-consumer pattern, covering conditions.

Counting semaphores as a generalisation of locks; binary semaphores; ordering; readers-writers; dining philosophers.

Non-deadlock vs deadlock bugs; the four conditions for deadlock; prevention, avoidance, detection-and-recovery.

Event loops, select / poll / epoll, async I/O, the manual state-management cost, and why JS, Nginx, and Node landed here.

The canonical device protocol, interrupts vs polling, DMA, memory-mapped I/O, and the driver as an OS abstraction.

Geometry, seek + rotational latency + transfer time, disk scheduling (SSTF, SCAN, C-SCAN), and the I/O-cost math.

RAID 0/1/4/5/6 — capacity, performance, reliability trade-offs and where parity-based schemes break down.

The UNIX file abstraction, descriptors, inodes, hard vs symbolic links, fsync, mount, and the permission-bit model.

Inode + data-block layout, free-space tracking, directory structures, access paths, caching, and the I/O cost per system call.

Cylinder groups, locality policy, large-file exception — the design that made UNIX file systems orders of magnitude faster.

Write-ahead logging, metadata-only vs full journaling, ordered mode, soft updates, and why fsck stopped scaling.

Sequential writes, segments, inode maps, garbage collection — the design that influenced flash file systems and modern databases.

Cells, banks, planes; erase-before-write; the FTL log-structured mapping; garbage collection; wear leveling; trim.

Latent sector errors, silent corruption, checksums, mismatched-write protection, periodic scrubbing — bit-rot defense.

How a 'wrong terminal' rm on a primary led to ~6 hours of data loss; backups that didn't work; the public postmortem.

Unreliable vs reliable channels, RPC, idempotency, timeout / retry / at-most-once / at-least-once semantics.

Stateless protocol, idempotent operations, client-side caching, the cache-consistency problem, server-write buffering.

Whole-file caching, callbacks for invalidation, last-writer-wins, and how AFS achieved campus-scale before the cloud.