This document provides a high-level architectural overview of the Linux kernel codebase, focusing on major subsystems, their interactions, and key code structures. It serves as an entry point for understanding the kernel's organization and provides context for the detailed subsystem documentation that follows.
For detailed information about specific subsystems:
The Linux kernel implements a monolithic architecture with modular extensions. All core subsystems run in a single address space with kernel privileges, enabling efficient communication but requiring careful synchronization. The kernel is organized into distinct functional layers that interact through well-defined interfaces.
Sources: kernel/sys_ni.c include/linux/syscalls.h1-300 kernel/sched/core.c1-100 virt/kvm/kvm_main.c1-50 io_uring/io_uring.c1-100
The system call interface provides the primary boundary between user space and kernel space. Applications invoke system calls through the C library, which translates function calls into the appropriate CPU instructions (e.g., syscall on x86-64, svc on ARM64).
The kernel maintains a system call table that dispatches requests to handler functions. Unimplemented system calls are handled by stub functions defined in kernel/sys_ni.c
Key entry points:
Sources: kernel/sys_ni.c1-500 include/linux/syscalls.h1-100
The Linux scheduler implements multiple scheduling classes with different policies, organized as a hierarchy where higher-priority classes preempt lower-priority ones.
The scheduler core in kernel/sched/core.c implements the schedule() function, which selects the next task to run by iterating through scheduling classes in priority order. Each class implements a common interface defined in struct sched_class kernel/sched/sched.h2200-2350
Major scheduling classes:
sched_ext architecture (kernel/sched/ext.c):
scx_ops callback structure for enqueue, dispatch, running, stopping operationsscx_dispatch_q) for task placementscx_bpf_* kfuncs) to BPF programsscx_kf_mask kernel/sched/ext.c274-413For detailed scheduler documentation, see Process Scheduling and sched_ext.
Sources: kernel/sched/core.c1-1000 kernel/sched/ext.c1-700 kernel/sched/fair.c1-300 kernel/sched/sched.h1-2350
Memory management handles physical page allocation, virtual memory, page tables, and memory reclamation. The MM subsystem is split between architecture-independent code in mm/ and architecture-specific implementations in arch/*/mm/ and arch/*/kvm/mmu/.
Key components:
Virtualization memory management:
Sources: arch/x86/kvm/mmu/mmu.c1-100 arch/arm64/kvm/mmu.c
The Kernel-based Virtual Machine (KVM) subsystem provides hardware-assisted virtualization using CPU extensions (Intel VMX/VT-x, AMD SVM/AMD-V, ARM64 VHE).
KVM Architecture:
The KVM subsystem is split into:
x86 KVM [arch/x86/kvm/]:
kvm_x86_ops function pointers arch/x86/kvm/x86.c141-150ARM64 KVM [arch/arm64/kvm/]:
For detailed virtualization documentation, see Virtualization (KVM), KVM x86 Virtualization, and KVM ARM64 Virtualization.
Sources: virt/kvm/kvm_main.c1-100 arch/x86/kvm/x86.c1-150 arch/x86/kvm/vmx/vmx.c1-100 arch/x86/kvm/svm/svm.c1-100 arch/x86/kvm/vmx/tdx.c1-100 arch/arm64/kvm/arm.c1-100 arch/arm64/kvm/sys_regs.c1-100 arch/arm64/kvm/nested.c1-100
The kernel provides multiple I/O interfaces with varying performance characteristics, from traditional blocking I/O to modern asynchronous interfaces.
io_uring io_uring/io_uring.c:
The io_uring subsystem provides a modern asynchronous I/O interface using shared memory ring buffers between user space and kernel space. This design minimizes system call overhead and enables true async I/O.
Key components:
io_uring_sqe entries io_uring/io_uring.c100-200io_uring_cqe entries io_uring/io_uring.c190-250Block layer:
For detailed I/O documentation, see Storage and I/O and io_uring Asynchronous I/O.
Sources: io_uring/io_uring.c1-500 io_uring/zcrx.c1-100 block/blk-mq.c
The Direct Rendering Manager (DRM) subsystem manages GPU devices and display controllers.
Key files:
For GPU driver details, see Graphics and Display and AMDGPU Driver.
Sources: drivers/gpu/drm/
The kernel is primarily written in C (C11 standard with GNU extensions). Core compiler requirements and features are defined in the build system.
Key aspects:
Rust support enables writing kernel code with memory safety guarantees. The Rust integration provides safe abstractions over C kernel APIs.
Rust kernel architecture:
Example drivers:
For Rust integration details, see Rust for Linux and Rust Kernel APIs and Abstractions.
Sources: rust/kernel/lib.rs1-100 rust/helpers.c drivers/gpu/drm/nova/
The kernel uses Kbuild, a sophisticated build system based on GNU Make with support for multiple languages and architectures.
Key components:
Cross-compilation:
CROSS_COMPILE, ARCHRust compilation:
For build system details, see Build System and Kbuild.
Sources: Makefile scripts/Kbuild.include
The kernel provides extensive tracing capabilities for debugging and performance analysis.
Key systems:
For tracing infrastructure, see Tracing and Observability.
Sources: kernel/trace/ include/trace/events/
The MAINTAINERS1-1000 file defines the organizational structure of the kernel, listing maintainers, mailing lists, and file patterns for each subsystem. This file serves as the authoritative source for understanding code ownership and contribution workflows.
Example subsystem entries:
Sources: MAINTAINERS1-1000
The Linux kernel is a complex monolithic system with well-defined subsystem boundaries. Key architectural patterns include:
This document provides entry points into the codebase. For detailed subsystem documentation, refer to the linked pages for Rust, KVM, Scheduling, I/O, and Graphics.
Refresh this wiki