Overview
free

Course Setup and the Incremental Ladder
Why "Processes to Kernels"
How to Use This Course
The Incremental Ladder (Step 0 to Step 7)
The Course Lenses
Diagram Legend and Notation Types

OS as a Resource Manager and Abstract Machine
Hardware vs OS vs Applications
The OS as Provider of Virtual Resources
The OS as the Machine Below the Language Runtime

Classic OS Abstractions
Processes, Threads, Files, Sockets, Devices
"Everything Is a File" and Other Philosophies
Tradeoffs in Abstraction Boundaries

Kernel Space vs User Space
Protection Rings and Privilege Levels
The System Call Boundary and Kernel Entry/Exit
Why Isolation Exists and What It Enables

OS Architecture Families (Conceptual)
OS Architecture Families - Monolithic, Microkernel-ish, Hybrid, Exokernel-ish
Tradeoffs - Performance, Simplicity, Extensibility, Safety
Finding Your Place on the Spectrum

Diagramming OS Architectures
Process and Thread Diagrams
Memory Maps and Page Layout Diagrams
Driver Stacks, I/O Paths, and System Call Flows

Processes as Executing Programs
Program vs Process; Code vs Running Instance
Process Control Blocks (PCBs) and Basic Metadata
Process States: New, Ready, Running, Waiting, Terminated

Threads and Concurrency within a Process
Threads Sharing Address Space vs Separate Processes
User-Level vs Kernel-Level Threads (Conceptual)
Thread Lifecycle and Scheduling Hooks

Address Spaces and Layout
Code, Data, Heap, Stack, and Kernel Mappings
Per-Process Address Space vs Shared Memory Segments
TLBs and Translation (Conceptual)

Process Creation, Termination, and Hierarchies
Fork-Like vs Spawn-Like Models
Parent-Child Relationships, Process Groups, and Sessions
Exit Codes, Zombies, Orphans, and Reaping

Virtual Memory Basics
Pages, Frames, and Mapping
Page Tables and Translation (Conceptual)
Benefits - Isolation, Overcommit, and Flexible Layout

Paging, Faults, and Swapping (Conceptual)
Page Faults and Demand Paging
Swapping Pages to Disk (Conceptual)
Replacement Policy and Thrashing Avoidance

System Calls and Traps
From Function Call to Syscall: The Mode Switch
Syscall Interface Design: Numbers, Stubs, and Calling Conventions
Validating Arguments and Returning Results

Core OS APIs
Process Management: Create, Load, Exit, Wait
Memory Management APIs: Allocation, Mapping, and Protection
Basic I/O APIs: Open, Close, Read, Write

CPU Scheduling Fundamentals
Scheduling Goals: Fairness, Throughput, Latency, Responsiveness
Basic Scheduling Algorithms: FCFS, Round-Robin, Priority
Preemption and Time Slices

Multiprocessor and Multicore Scheduling
Per-Core vs Global Run Queues (Conceptual)
Load Balancing and CPU Affinity
Hyperthreading-Like Concepts (High-Level)

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

Synchronization Primitives (Conceptual)
Race Conditions, Critical Sections, and Mutual Exclusion
Locks, Mutexes, Semaphores, and Condition Variables
Lock-Free and Wait-Free Patterns (High-Level)

Deadlocks, Starvation, and Priority Inversion
Conditions for Deadlock (Conceptual)
Deadlock Avoidance and Detection Strategies
Priority Inversion and Mitigation (Priority Inheritance, Conceptual)

Concurrency Structures in the Kernel
Per-CPU Structures vs Shared Structures
Reader-Writer Patterns and Reference Counting
Balancing Fine-Grained Locking vs Simplicity

Files, Directories, and Namespaces
File Descriptors and Path Resolution
Directory Trees and Mount Points
Multiple Filesystems in a Unified Namespace

Block Devices, Buffers, and Caches
Block Devices vs Character Devices
Buffer Cache and Page Cache Concepts
Read-Ahead, Write-Back, and Consistency Tradeoffs

Filesystem Layout and Metadata (Conceptual)
Inodes or Equivalent Metadata Records
Allocation Strategies for Data Blocks
Journaling vs Copy-on-Write vs Simple Layout (Conceptual)

I/O Paths and VFS Layers
Virtual Filesystem (VFS)-Like Abstraction
Pluggable Filesystem Modules
From Syscall to Driver - The I/O Stack

Special Files, Pipes, and Sockets
Pipes and FIFOs as Kernel Buffers
Device Files Mapping to Drivers
Sockets as Endpoint Abstractions for Network Stacks

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

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

Interrupts and I/O Completion
Interrupt Handling and Deferred Processing
Polled vs Interrupt-Driven I/O
Completion Queues and Notification to User Space

Buses, Enumerations, and Plug-and-Play
Peripheral Buses (Conceptual)
Device Enumeration and Resource Assignment
Handling Hot-Plug and Hot-Unplug Events

Hardware Abstraction Layers
HALs for Portability Across Hardware
Abstracting Timers, Clocks, and Low-Level Resources
Pros and Cons of Thick vs Thin HALs

Power Management and Performance States
Performance States and Idle States (Conceptual)
OS Control Over Power vs Device-Level Heuristics
Impact on Scheduling and Device Behavior

Robustness and Driver Isolation Strategies
Kernel Driver Failures vs User-Visible Crashes
Strategies for Containing Driver Faults (Conceptual)
Testing and Validating Drivers as Part of OS Reliability

Users, Permissions, and Access Control
Users, Groups, and Identities
File Permissions, ACLs, and Capabilities
Mapping the OS Security Model to System Design Goals

Process Isolation and Protection Mechanisms
Memory Protection With Address Spaces and Permissions
Kernel vs User Memory Access Rules at the System Call Boundary
Preventing Cross-Process Interference Through Mediation and Controlled Sharing

Sandboxing and Namespaces (Conceptual)
Per-Process Views of Shared Resources
Namespaces as Isolation Mechanisms
Containers as Packaging Around OS Isolation Features

Resource Accounting and Limits
Quotas on CPU, Memory, I/O, and Other Resources
Cgroup-Like Resource Grouping and Control (High-Level)
Preventing Starvation and Denial-of-Service with Local Controls

Authentication, Authorization, and Auditing Hooks
API Hooks for Auth/Authz Decisions (Conceptual)
Logging and Audit Trails at the Kernel/User Boundary
Providing Primitives for Security Tooling

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

Init Systems and Service Management
System Startup - From Kernel Handoff to User Space
Init and Service Managers (Conceptual)
Service Lifecycles, Restarts, and Dependencies

Shells, Terminals, and Command Environments
The Shell as the User's Programming Environment
Terminals, TTYs, and Pseudo-Terminals
CLI and GUI as Two Faces of the Same Operating System

Package Management and Software Distribution
Bundling Software for the OS
Dependency Management and Versioning
Repositories vs Manual Deployment

Logs, Metrics, and Observability Tools
Logging from Kernel and Services
Basic Observation Tools for a Running System
Tracing and Profiling Across the User-Kernel Boundary

Debugging and Development Tooling
User-Level Debugging vs Kernel-Level Debugging
System Call Tracing and Core Dumps
Tooling as Part of the OS Product

Configuration, Policy, and System Management
Centralized vs Distributed Configuration
Policy Layers for Security, Resource Use, and Behavior
Admin Tooling to Configure the OS "Personality"

Choosing an OS Architecture
Monolithic vs Microkernel-ish vs Hybrid Tradeoffs, Revisited
Use-Case Driven Design - Embedded, General-Purpose, and Specialized OS Choices
Constraints - Hardware, Performance, and Development Team Realities

Bootstrapping a New Kernel
Early Boot Bring-Up and the Minimal Kernel Environment
The Initial Process, a Simple Scheduler, and Early Memory Management
Incrementally Layering Features Without Collapsing Failure Domains

Building Out Core Subsystems
Iterating on Process and Thread Management
Adding Virtual Memory Sophistication
Integrating Device Drivers and I/O Subsystems

Stability, Testing, and Release Engineering
Testing Strategies for a Kernel and OS
Compatibility and ABI Stability Policies
Release Cadence and Patching Strategies

Ecosystem and Community
Encouraging Driver and Application Development
Documentation, SDKs, and Sample Code as Interface Contracts
Governance Structures for Evolving an OS Ecosystem

Long-Term Evolution and Portability
Porting to New Hardware Architectures
Deprecating Features and Managing Legacy
Planning for Decades of Evolution

Reference OS Design Patterns
Reference Patterns - Embedded, Server, and Desktop OS Shapes
Mapping the Incremental Ladder Steps to a Roadmap
Design Checklists as Boundary Reviews
Appendix A - Diagram Templates by Step
Appendix A - Concrete Diagram Templates
Appendix B - Mapping Concepts to OS Architecture Families
Appendix B - Reading OS Documentation Through Boundaries
Appendix B - The Same Concepts Under Different Names
Appendix C - Readiness as Failure-Domain Discipline
Appendix C - "Are We Ready to Move from Step N to Step N+1?"
Appendix C - From Toy Kernel to Operable Platform
Appendix D - Glossary as a Contract Tool
Appendix D - Glossary of Core OS Terms

/processes-to-kernels/processes-to-kernels

The Shell as the User's Programming Environment

Sign in to access this lesson.

Sign in Create account