Subject
Operating systems
Processes, threads, scheduling, memory, files and I/O, with the C code behind them.
Start at Level 0Interview questions
Foundations
What an operating system is, how it protects itself and how to watch it work.
Level 0
How an operating system works
What an operating system does, how programs ask it for help, and how to see it at work on Linux.
6 modules · about 1 week
Processes and threads
The running program and its threads: how they are created, connected to others, run on several processors and ended.
Scheduling and synchronisation
Choosing which thread runs next, and making threads share data safely.
Level 3
CPU scheduling
How an operating system chooses which task runs next: the measures, the classic policies, shares, several processors and deadlines, and how Linux does it.
7 modules · about 2 weeks
Level 4
Concurrency and synchronisation
How threads share data safely: the critical-section problem, atomic instructions, mutexes, condition variables, semaphores, the classic problems and the tools that find bugs.
9 modules · about 3 weeks
Level 5
Deadlocks
How threads and processes end up waiting for each other for ever, how to see it, how to prevent, avoid, detect and recover from it, and how to debug a real one.
7 modules · about 2 weeks
Memory
How the system gives each program its own address space, maps it onto real memory and decides which pages stay.
Level 6
Memory management
How each process gets a private address space: protection, allocation, paging, page tables, the TLB, demand paging, page replacement and thrashing.
9 modules · about 3 weeks
Level 7
Memory in practice
How real programs use memory: malloc and the heap, heap bugs and their tools, the stack, memory-mapped files, shared memory, huge pages, swap, overcommit and the OOM killer, and how to trace where memory went.
8 modules · about 3 weeks
Storage and devices
How disks and flash work, how the processor talks to devices, how the kernel layers its I/O code, and how to measure all of it.
Level 8
Storage and I/O devices
How hard disks and flash drives work, how requests are ordered, how the processor talks to a device with polling, interrupts and DMA, how the kernel layers its I/O code, how RAID survives failures, and how to measure and diagnose storage on Linux.
8 modules · about 3 weeks
File systems
How names, inodes and blocks make files, how a file system survives a crash, and how many file systems share one tree.
Level 9
File systems
What a file is, how directories and links work, how an ext-style file system lays out inodes, bitmaps and blocks, how blocks are allocated, how journaling and copy-on-write survive a crash, how the VFS joins many file systems, and how to find where disk space went.
7 modules · about 3 weeks
Security and protection
Who may do what: the access matrix, users and permissions, passwords, capabilities, memory-safety defences and sandboxes.
Level 10
Security and protection
How a system decides who may do what: protection domains and the access matrix, users, groups and file permissions, passwords and how they are stored, Linux capabilities and least privilege, memory-safety attacks and their defences, sandboxes built from limits, filters and policy, and how to find which rule refused an access.
7 modules · about 3 weeks
Virtualisation and containers
How one machine runs many: virtual machines and hypervisors, and containers built from namespaces and control groups.
Level 11
Virtualisation and containers
How a hypervisor runs guest kernels with trap and emulate and hardware help, how the processor, memory and devices are shared (nested paging, ballooning, virtio), and how containers get their own view and limits from namespaces and control groups on a shared kernel.
6 modules · about 3 weeks
Linux in practice and interviews
The tools that show what the kernel is doing, a method for finding performance problems and crashes, and interview practice.
Level 12
Linux in practice and interview prep
The commands that show processes, memory, files and disks, the /proc and /sys files behind them, tracing system calls with strace, finding performance problems with the USE method, signals, crashes and debuggers, and the classic operating-systems interview questions with worked answers.
6 modules · about 2 weeks