Processes To Kernels

How to design Operating Systems

51 modules

216 lessons

—

Part 1

Course Setup and the Incremental Ladder

Course Setup and the Incremental LadderSign in
Why "Processes to Kernels"Sign in
How to Use This CourseSign in
The Incremental Ladder (Step 0 to Step 7)Sign in
The Course LensesSign in
Diagram Legend and Notation TypesSign in

Part 2

OS as a Resource Manager and Abstract Machine

OS as a Resource Manager and Abstract MachineSign in
Hardware vs OS vs ApplicationsSign in
The OS as Provider of Virtual ResourcesSign in
The OS as the Machine Below the Language RuntimeSign in

Part 3

Classic OS Abstractions

Classic OS AbstractionsSign in
Processes, Threads, Files, Sockets, DevicesSign in
"Everything Is a File" and Other PhilosophiesSign in
Tradeoffs in Abstraction BoundariesSign in

Part 4

Kernel Space vs User Space

Kernel Space vs User SpaceSign in
Protection Rings and Privilege LevelsSign in
The System Call Boundary and Kernel Entry/ExitSign in
Why Isolation Exists and What It EnablesSign in

Part 5

OS Architecture Families (Conceptual)

OS Architecture Families (Conceptual)Sign in
OS Architecture Families - Monolithic, Microkernel-ish, Hybrid, Exokernel-ishSign in
Tradeoffs - Performance, Simplicity, Extensibility, SafetySign in
Finding Your Place on the SpectrumSign in

Part 6

Diagramming OS Architectures

Diagramming OS ArchitecturesSign in
Process and Thread DiagramsSign in
Memory Maps and Page Layout DiagramsSign in
Driver Stacks, I/O Paths, and System Call FlowsSign in

Part 7

Processes as Executing Programs

Processes as Executing ProgramsSign in
Program vs Process; Code vs Running InstanceSign in
Process Control Blocks (PCBs) and Basic MetadataSign in
Process States: New, Ready, Running, Waiting, TerminatedSign in

Part 8

Threads and Concurrency within a Process

Threads and Concurrency within a ProcessSign in
Threads Sharing Address Space vs Separate ProcessesSign in
User-Level vs Kernel-Level Threads (Conceptual)Sign in
Thread Lifecycle and Scheduling HooksSign in

Part 9

Address Spaces and Layout

Address Spaces and LayoutSign in
Code, Data, Heap, Stack, and Kernel MappingsSign in
Per-Process Address Space vs Shared Memory SegmentsSign in
TLBs and Translation (Conceptual)Sign in

Part 10

Process Creation, Termination, and Hierarchies

Process Creation, Termination, and HierarchiesSign in
Fork-Like vs Spawn-Like ModelsSign in
Parent-Child Relationships, Process Groups, and SessionsSign in
Exit Codes, Zombies, Orphans, and ReapingSign in

Part 11

Virtual Memory Basics

Virtual Memory BasicsSign in
Pages, Frames, and MappingSign in
Page Tables and Translation (Conceptual)Sign in
Benefits - Isolation, Overcommit, and Flexible LayoutSign in

Part 12

Paging, Faults, and Swapping (Conceptual)

Paging, Faults, and Swapping (Conceptual)Sign in
Page Faults and Demand PagingSign in
Swapping Pages to Disk (Conceptual)Sign in
Replacement Policy and Thrashing AvoidanceSign in

Part 13

System Calls and Traps

System Calls and TrapsSign in
From Function Call to Syscall: The Mode SwitchSign in
Syscall Interface Design: Numbers, Stubs, and Calling ConventionsSign in
Validating Arguments and Returning ResultsSign in

Part 14

Core OS APIs

Core OS APIsSign in
Process Management: Create, Load, Exit, WaitSign in
Memory Management APIs: Allocation, Mapping, and ProtectionSign in
Basic I/O APIs: Open, Close, Read, WriteSign in

Part 15

CPU Scheduling Fundamentals

CPU Scheduling FundamentalsSign in
Scheduling Goals: Fairness, Throughput, Latency, ResponsivenessSign in
Basic Scheduling Algorithms: FCFS, Round-Robin, PrioritySign in
Preemption and Time SlicesSign in

Part 16

Multiprocessor and Multicore Scheduling

Multiprocessor and Multicore SchedulingSign in
Per-Core vs Global Run Queues (Conceptual)Sign in
Load Balancing and CPU AffinitySign in
Hyperthreading-Like Concepts (High-Level)Sign in

Part 17

Context Switching and Kernel Data Structures

Context Switching and Kernel Data StructuresSign in
Saving and Restoring Context (Registers and Stack Pointers)Sign in
Ready Queues and Wait Queues (Runnable vs Blocked Work)Sign in
Interrupts vs Scheduled Preemption (Who Triggers a Switch)Sign in

Part 18

Synchronization Primitives (Conceptual)

Synchronization Primitives (Conceptual)Sign in
Race Conditions, Critical Sections, and Mutual ExclusionSign in
Locks, Mutexes, Semaphores, and Condition VariablesSign in
Lock-Free and Wait-Free Patterns (High-Level)Sign in

Part 19

Deadlocks, Starvation, and Priority Inversion

Deadlocks, Starvation, and Priority InversionSign in
Conditions for Deadlock (Conceptual)Sign in
Deadlock Avoidance and Detection StrategiesSign in
Priority Inversion and Mitigation (Priority Inheritance, Conceptual)Sign in

Part 20

Concurrency Structures in the Kernel

Concurrency Structures in the KernelSign in
Per-CPU Structures vs Shared StructuresSign in
Reader-Writer Patterns and Reference CountingSign in
Balancing Fine-Grained Locking vs SimplicitySign in

Part 21

Files, Directories, and Namespaces

Files, Directories, and NamespacesSign in
File Descriptors and Path ResolutionSign in
Directory Trees and Mount PointsSign in
Multiple Filesystems in a Unified NamespaceSign in

Part 22

Block Devices, Buffers, and Caches

Block Devices, Buffers, and CachesSign in
Block Devices vs Character DevicesSign in
Buffer Cache and Page Cache ConceptsSign in
Read-Ahead, Write-Back, and Consistency TradeoffsSign in

Part 23

Filesystem Layout and Metadata (Conceptual)

Filesystem Layout and Metadata (Conceptual)Sign in
Inodes or Equivalent Metadata RecordsSign in
Allocation Strategies for Data BlocksSign in
Journaling vs Copy-on-Write vs Simple Layout (Conceptual)Sign in

Part 24

I/O Paths and VFS Layers

I/O Paths and VFS LayersSign in
Virtual Filesystem (VFS)-Like AbstractionSign in
Pluggable Filesystem ModulesSign in
From Syscall to Driver - The I/O StackSign in

Part 25

Special Files, Pipes, and Sockets

Special Files, Pipes, and SocketsSign in
Pipes and FIFOs as Kernel BuffersSign in
Device Files Mapping to DriversSign in
Sockets as Endpoint Abstractions for Network StacksSign in

Part 26

Storage Devices and Performance Considerations

Storage Devices and Performance ConsiderationsSign in
Storage Media as a Boundary (HDDs, SSDs, and Beyond)Sign in
Alignment, Access Patterns, and WearSign in
Kernel I/O Strategy (Batching, Queues, and Scheduling)Sign in

Part 27

Drivers as OS Extensions

Drivers as OS ExtensionsSign in
The Role of Drivers in the OSSign in
Driver Models and Frameworks (Conceptual)Sign in
Kernel-Mode vs User-Mode Drivers (Where Applicable)Sign in

Part 28

Interrupts and I/O Completion

Interrupts and I/O CompletionSign in
Interrupt Handling and Deferred ProcessingSign in
Polled vs Interrupt-Driven I/OSign in
Completion Queues and Notification to User SpaceSign in

Part 29

Buses, Enumerations, and Plug-and-Play

Buses, Enumerations, and Plug-and-PlaySign in
Peripheral Buses (Conceptual)Sign in
Device Enumeration and Resource AssignmentSign in
Handling Hot-Plug and Hot-Unplug EventsSign in

Part 30

Hardware Abstraction Layers

Hardware Abstraction LayersSign in
HALs for Portability Across HardwareSign in
Abstracting Timers, Clocks, and Low-Level ResourcesSign in
Pros and Cons of Thick vs Thin HALsSign in

Part 31

Power Management and Performance States

Power Management and Performance StatesSign in
Performance States and Idle States (Conceptual)Sign in
OS Control Over Power vs Device-Level HeuristicsSign in
Impact on Scheduling and Device BehaviorSign in

Part 32

Robustness and Driver Isolation Strategies

Robustness and Driver Isolation StrategiesSign in
Kernel Driver Failures vs User-Visible CrashesSign in
Strategies for Containing Driver Faults (Conceptual)Sign in
Testing and Validating Drivers as Part of OS ReliabilitySign in

Part 33

Users, Permissions, and Access Control

Users, Permissions, and Access ControlSign in
Users, Groups, and IdentitiesSign in
File Permissions, ACLs, and CapabilitiesSign in
Mapping the OS Security Model to System Design GoalsSign in

Part 34

Process Isolation and Protection Mechanisms

Process Isolation and Protection MechanismsSign in
Memory Protection With Address Spaces and PermissionsSign in
Kernel vs User Memory Access Rules at the System Call BoundarySign in
Preventing Cross-Process Interference Through Mediation and Controlled SharingSign in

Part 35

Sandboxing and Namespaces (Conceptual)

Sandboxing and Namespaces (Conceptual)Sign in
Per-Process Views of Shared ResourcesSign in
Namespaces as Isolation MechanismsSign in
Containers as Packaging Around OS Isolation FeaturesSign in

Part 36

Resource Accounting and Limits

Resource Accounting and LimitsSign in
Quotas on CPU, Memory, I/O, and Other ResourcesSign in
Cgroup-Like Resource Grouping and Control (High-Level)Sign in
Preventing Starvation and Denial-of-Service with Local ControlsSign in

Part 37

Authentication, Authorization, and Auditing Hooks

Authentication, Authorization, and Auditing HooksSign in
API Hooks for Auth/Authz Decisions (Conceptual)Sign in
Logging and Audit Trails at the Kernel/User BoundarySign in
Providing Primitives for Security ToolingSign in

Part 38

Secure Boot and Integrity (OS Perspective)

Secure Boot and Integrity (OS Perspective)Sign in
OS Role in Boot Integrity (In Cooperation with Lower Layers)Sign in
Protecting System Binaries and ConfigurationSign in
Runtime Integrity Monitoring (Conceptual)Sign in

Part 39

Init Systems and Service Management

Init Systems and Service ManagementSign in
System Startup - From Kernel Handoff to User SpaceSign in
Init and Service Managers (Conceptual)Sign in
Service Lifecycles, Restarts, and DependenciesSign in

Part 40

Shells, Terminals, and Command Environments

Shells, Terminals, and Command EnvironmentsSign in
The Shell as the User's Programming EnvironmentSign in
Terminals, TTYs, and Pseudo-TerminalsSign in
CLI and GUI as Two Faces of the Same Operating SystemSign in

Part 41

Package Management and Software Distribution

Package Management and Software DistributionSign in
Bundling Software for the OSSign in
Dependency Management and VersioningSign in
Repositories vs Manual DeploymentSign in

Part 42

Logs, Metrics, and Observability Tools

Logs, Metrics, and Observability ToolsSign in
Logging from Kernel and ServicesSign in
Basic Observation Tools for a Running SystemSign in
Tracing and Profiling Across the User-Kernel BoundarySign in

Part 43

Debugging and Development Tooling

Debugging and Development ToolingSign in
User-Level Debugging vs Kernel-Level DebuggingSign in
System Call Tracing and Core DumpsSign in
Tooling as Part of the OS ProductSign in

Part 44

Configuration, Policy, and System Management

Configuration, Policy, and System ManagementSign in
Centralized vs Distributed ConfigurationSign in
Policy Layers for Security, Resource Use, and BehaviorSign in
Admin Tooling to Configure the OS "Personality"Sign in

Part 45

Choosing an OS Architecture

Choosing an OS ArchitectureSign in
Monolithic vs Microkernel-ish vs Hybrid Tradeoffs, RevisitedSign in
Use-Case Driven Design - Embedded, General-Purpose, and Specialized OS ChoicesSign in
Constraints - Hardware, Performance, and Development Team RealitiesSign in

Part 46

Bootstrapping a New Kernel

Bootstrapping a New KernelSign in
Early Boot Bring-Up and the Minimal Kernel EnvironmentSign in
The Initial Process, a Simple Scheduler, and Early Memory ManagementSign in
Incrementally Layering Features Without Collapsing Failure DomainsSign in

Part 47

Building Out Core Subsystems

Building Out Core SubsystemsSign in
Iterating on Process and Thread ManagementSign in
Adding Virtual Memory SophisticationSign in
Integrating Device Drivers and I/O SubsystemsSign in

Part 48

Stability, Testing, and Release Engineering

Stability, Testing, and Release EngineeringSign in
Testing Strategies for a Kernel and OSSign in
Compatibility and ABI Stability PoliciesSign in
Release Cadence and Patching StrategiesSign in

Part 49

Ecosystem and Community

Ecosystem and CommunitySign in
Encouraging Driver and Application DevelopmentSign in
Documentation, SDKs, and Sample Code as Interface ContractsSign in
Governance Structures for Evolving an OS EcosystemSign in

Part 50

Long-Term Evolution and Portability

Long-Term Evolution and PortabilitySign in
Porting to New Hardware ArchitecturesSign in
Deprecating Features and Managing LegacySign in
Planning for Decades of EvolutionSign in

Part 51

Reference OS Design Patterns

Reference OS Design PatternsSign in
Reference Patterns - Embedded, Server, and Desktop OS ShapesSign in
Mapping the Incremental Ladder Steps to a RoadmapSign in
Design Checklists as Boundary ReviewsSign in
Appendix A - Diagram Templates by StepSign in
Appendix A - Concrete Diagram TemplatesSign in
Appendix B - Mapping Concepts to OS Architecture FamiliesSign in
Appendix B - Reading OS Documentation Through BoundariesSign in
Appendix B - The Same Concepts Under Different NamesSign in
Appendix C - Readiness as Failure-Domain DisciplineSign in
Appendix C - "Are We Ready to Move from Step N to Step N+1?"Sign in
Appendix C - From Toy Kernel to Operable PlatformSign in
Appendix D - Glossary as a Contract ToolSign in
Appendix D - Glossary of Core OS TermsSign in

Course overview