Linux Kernel Documentation Index

Every page in the Linux kernel's official documentation, organized by subsystem. From getting your first patch merged to writing device drivers, it's all here.

1393 documentation pages indexed across 56 sections.

Start Here

New to kernel development? Start with these.

HOWTO do Linux kernel development - The place to start before writing your first patch
A Guide to the Kernel Development Process - Release cycles, patch flow, and how the community works
Submitting Patches - How to get your code into the kernel, step by step
Patch Submission Checklist - Things to check before sending a patch
Linux Kernel Coding Style - The formatting and style rules the kernel expects
Code of Conduct - Community guidelines for working together
Linux Kernel README - The original README: what Linux is and how to build it
Unreliable Guide to Hacking the Linux Kernel - Practical tips and tricks for kernel hackers
How to Help Improve Kernel Documentation - A good first contribution if you're just getting started

Development Process

How the kernel is developed, maintained, and governed.

Introduction to Kernel Development

HOWTO Do Linux Kernel Development - Overview of what you need to know to contribute
A Guide to the Kernel Development Process - How patches flow from developer to mainline
Submitting Patches: The Essential Guide - Formatting, sending, and following up on patches
Linux Kernel Patch Submission Checklist - Quick checklist to run through before sending

Tools and Technical Guides

Minimal Requirements to Compile the Kernel - Software versions needed to build the kernel
Programming Language - Which languages the kernel is written in and why
Linux Kernel Coding Style - Tabs, braces, naming, and other formatting rules
Kernel Maintainer PGP Guide - Setting up PGP keys for signing patches and tags
Email Clients Info for Linux - Configuring email clients to send patches correctly
Applying Patches to the Linux Kernel - How to apply patches with git or the patch command
Backporting and Conflict Resolution - Moving fixes to older kernel versions
Adding a New System Call - Steps to add a new syscall to the kernel
Why the "volatile" Type Class Should Not Be Used - Why volatile is almost always wrong in kernel code
Botching Up ioctls - Common mistakes when designing ioctl interfaces

Policy Guides and Developer Statements

Linux Kernel Licensing Rules - SPDX identifiers and licensing requirements for kernel code
Contributor Covenant Code of Conduct - Expected behavior in the kernel community
Code of Conduct Interpretation - How the code of conduct is applied in practice
Contribution Maturity Model - Levels of maturity for kernel contributions
Linux Kernel Enforcement Statement - How license compliance is handled
Linux Kernel Driver Statement - Position on out-of-tree and proprietary drivers
The Linux Kernel Driver Interface - Why the kernel does not have a stable internal API
Everything You Wanted to Know About Stable Releases - Rules for getting patches into stable kernels
Linux Kernel Management Style - How kernel maintainers manage their subsystems
Researcher Guidelines - Rules for researchers studying the kernel community
Generated Content and AI Policy - Policy on AI-generated contributions
Coding Assistants - Using AI coding tools in kernel development
Kernel Maintainer Conclave - Annual meetings of kernel maintainers

Dealing with Bugs

Debugging - Techniques and tools for finding kernel bugs
Handling Regressions - How regressions are tracked and fixed
Security Bugs - How to report security vulnerabilities
CVE Assignment - How CVEs are assigned for kernel issues
Embargoed Hardware Issues - Handling hardware bugs under NDA

Maintainer Information

Subsystem Maintainer Handbooks - Per-subsystem guides from maintainers
List of Maintainers - Who maintains what in the kernel

Other Material

Kernel Documentation References - Books, papers, and external resources about the kernel
Deprecated Interfaces, Language Features, Attributes, and Conventions - Things you should not use in new code

Maintainer Handbook

Guides for kernel subsystem maintainers.

Feature and Driver Maintainers - Roles and responsibilities of driver maintainers
Configuring Git - Recommended git settings for maintainers
Rebasing and Merging - When to rebase vs merge in subsystem trees
Creating Pull Requests - How to send pull requests to Linus and other maintainers
Handling Messy Diffstats - Cleaning up diffstats before sending pulls
Maintainer Entry Profile - Template for documenting subsystem preferences
Modifying Patches - Etiquette for changing other people's patches

Core API

Internal kernel API: data structures, memory management, concurrency, and core utilities.

Core Utilities

The Linux Kernel API - Auto-generated reference for core kernel functions
Concurrency Managed Workqueue - Deferring work to kernel threads
General Notification Mechanism - Delivering kernel notifications to userspace
How to Use printk - Printing messages from kernel code
How to Get printk Format Specifiers Right - Format strings for pointers, devices, and other kernel types
Printk Index - Indexing printk messages for monitoring tools
Symbol Namespaces - Organizing exported symbols into namespaces
Assembler Annotations - Macros for annotating assembly code
Real-Time - PREEMPT_RT and real-time kernel support
Housekeeping - Isolating CPUs from kernel housekeeping tasks

Data Structures and Low-Level Utilities

Everything You Never Wanted to Know About kobjects - The base object type underlying sysfs and the driver model
Adding Reference Counters (krefs) - Simple reference counting for kernel objects
Scope-Based Resource Management - Automatic cleanup using __cleanup and guard() macros
Generic Associative Array - Key-value data structure used by keyrings
Folio Queue - Queue data structure for folios
XArray - Scalable array indexed by unsigned long
Maple Tree - Range-based B-tree used for VMA tracking
ID Allocation - Allocating small integer IDs
Circular Buffers - Lock-free producer/consumer ring buffers
Red-Black Trees (rbtree) - Self-balancing binary tree used throughout the kernel
Generic Radix Trees - Simple radix tree for fixed-size entries
Generic Bitfield Packing and Unpacking - Portable bitfield access for hardware registers
this_cpu Operations - Fast per-CPU variable access without disabling preemption
Timekeeping - Getting wall-clock and monotonic time in the kernel
The errseq_t Datatype - Tracking errors with a sequence counter
Atomic Types - Atomic integer operations and memory ordering
Atomic Bitops - Atomic bit manipulation functions
Floating-Point API - Using floating point safely in kernel context
Union-Find - Disjoint-set data structure
Min Heap - Generic min-heap implementation
Generic Command Line Parser - Parsing mount options and similar key=value strings
Linked Lists - Doubly-linked list and hash list implementations

Low Level Entry and Exit

Entry/Exit Handling for Exceptions, Interrupts, Syscalls, and KVM - Common code path for entering and leaving the kernel

Concurrency Primitives

refcount_t vs atomic_t - Why refcount_t is safer than plain atomic_t for reference counting
IRQ Handling - Interrupt request handling internals
Semantics and Behavior of Local Atomic Operations - Per-CPU atomic operations that avoid global cache bouncing
The padata Parallel Execution Mechanism - Parallelizing work across CPUs with ordering guarantees
RCU Concepts - Read-copy-update synchronization overview
Linux Kernel Memory Barriers - When and how to use memory barriers

Low-Level Hardware Management

Cache and TLB Flushing - Architecture callbacks for cache and TLB maintenance
CPU Hotplug - Adding and removing CPUs at runtime
Memory Hotplug - Adding and removing physical memory at runtime
Linux Generic IRQ Handling - Architecture-independent interrupt handling layer
Memory Protection Keys - Hardware-enforced per-page access permissions

Memory Management

Memory Allocation Guide - kmalloc, vmalloc, and when to use which
Unaligned Memory Accesses - Handling unaligned loads/stores portably
DMA API - Mapping memory for device DMA access
Dynamic DMA Mapping Using the Generic Device - Practical guide to using the DMA mapping API
DMA Attributes - Flags that modify DMA mapping behavior
DMA with ISA and LPC Devices - Legacy DMA for ISA and LPC buses
Software IO TLB - Bounce buffering for devices that can't address all memory
Memory Management APIs - Auto-generated reference for MM functions
Control Groups - Cgroup memory controller kernel API
The genalloc/genpool Subsystem - Generic memory allocator for special-purpose memory regions
pin_user_pages() and Related Calls - Pinning user pages for long-term kernel use
Boot Time Memory Management - memblock and early boot allocators
GFP Masks Used from FS/IO Context - Which GFP flags are safe in filesystem and IO paths
Kernel Handover (KHO) - Preserving memory across kexec for fast reboot

Interfaces for Kernel Debugging

Object Debugging Infrastructure - Tracking object lifecycle to catch use-after-free and double-free
Using the Linux Kernel Tracepoints - Adding static instrumentation points to kernel code
Debugging via OHCI1394 - Remote debugging over FireWire

Everything Else

Reed-Solomon Library - Error correction codes used by MTD and other subsystems
Live Update - Updating the kernel without full reboot
Netlink - Kernel-userspace communication over netlink sockets

Driver API

Interfaces and guides for writing Linux device drivers.

General Information for Driver Authors

Driver Basics - Fundamental concepts every driver author needs
Driver Model - Buses, devices, and drivers in the unified device model
Device Links - Expressing dependencies between devices
Device Drivers Infrastructure - Core infrastructure shared by all drivers
ioctl Based Interfaces - Guidelines for designing ioctl commands
Device Power Management - Suspend, resume, and runtime PM for devices

Useful Support Libraries

Early Userspace - initramfs and early userspace setup
Connector - Netlink-based kernel-to-userspace notification
Device I/O Access - ioread/iowrite and memory-mapped I/O helpers
Device Frequency Scaling - Dynamic frequency scaling for non-CPU devices
Buffer Sharing and Synchronization (dma-buf) - Sharing buffers between devices and drivers
Component Helper - Coordinating multi-component device initialization
IO Mapping - Mapping PCI and other I/O regions into kernel space
Ordering I/O Writes - Ensuring I/O writes reach the device in order
Userspace I/O (UIO) HOWTO - Writing drivers partly in userspace
VFIO Mediated Devices - Virtualizing devices without hardware SR-IOV
VFIO: Virtual Function I/O - Safe device access from userspace and VMs
VFIO PCI Device Specific Drivers - Acceptance criteria for device-specific VFIO drivers

Bus-Level Documentation

Auxiliary Bus - Virtual bus for splitting a device into sub-functions
Compute Express Link (CXL) - Cache-coherent interconnect for accelerators and memory
EISA Bus Support - Legacy Extended ISA bus
FireWire (IEEE 1394) - FireWire bus and device support
I3C Subsystem - Improved Inter-Integrated Circuit bus
ISA Drivers - Legacy ISA bus driver framework
MEN Chameleon Bus - FPGA-based carrier board bus
PCI Bus - PCI and PCIe driver interfaces
RapidIO - High-performance embedded interconnect
SLIMbus - Serial Low-power Inter-chip Media Bus for audio
USB Bus - USB host and gadget driver interfaces
Virtio - Virtualized device interface standard
VME Bus - VMEbus industrial computing standard
1-Wire Bus - Dallas 1-Wire protocol support
Xillybus - Simple FPGA-to-host data streaming

Subsystem-Specific APIs

802.11 (Wi-Fi) - mac80211 and cfg80211 wireless stack
ACPI Support - ACPI tables, methods, and device enumeration
Backlight (LP855x) - TI LP855x backlight controller driver
Clock Framework - Common clock framework for managing hardware clocks
Confidential Computing - TEE and confidential VM support in drivers
Console Drivers - Writing drivers for kernel consoles
Crypto Drivers - Hardware crypto accelerator drivers
DMA Engine - Framework for offload DMA engines
DPLL Subsystem - Digital PLL clock recovery and synchronization
Error Detection and Correction (EDAC) - Memory ECC error reporting
External Connector - Detecting cable and accessory connections
Firmware Loading - Requesting and loading firmware files from userspace
FPGA - FPGA manager and bridge framework
Frame Buffer - Legacy framebuffer device API
Aperture Helpers - Managing firmware framebuffer apertures
Generic Counter Interface - Unified counter/encoder/tachometer subsystem
Generic Page Table - Shared page table infrastructure for drivers
GPIO Subsystem - General-purpose I/O pin framework
High Speed Synchronous Serial Interface (HSI) - Serial interface used in cellular modems
Hardware Timestamping Engine (HTE) - Hardware-assisted event timestamping
HW Recoverable Errors - Reporting recoverable hardware errors to userspace
I2C and SMBus - Writing I2C client and adapter drivers
Industrial I/O - ADCs, DACs, accelerometers, and sensor drivers
InfiniBand - RDMA/InfiniBand verbs driver interface
Input Subsystem - Keyboards, mice, touchscreens, and other input devices
Interconnect - On-chip bus bandwidth management
IPMB Driver - Intelligent Platform Management Bus
IPMI Driver - Intelligent Platform Management Interface
libATA - SATA and PATA driver library
Mailbox Framework - Inter-processor communication via hardware mailboxes
MD (RAID) - Software RAID and MD personality drivers
Media Subsystem - V4L2, DVB, and media controller frameworks
Intel Management Engine Interface (MEI) - Communication with Intel ME firmware
Memory Devices - Memory controller and DRAM drivers
Message-Based Devices - Fusion MPT and similar message-passing devices
Misc Devices - The miscdevice helper for simple char devices
Miscellaneous - Odds and ends that don't fit elsewhere
MMC/SD/SDIO - SD card and eMMC host controller drivers
Memory Technology Devices (MTD) - Flash memory, NOR, NAND, and SPI-NOR
MTD NAND Driver - NAND flash controller programming interface
NFC Subsystem - Near-field communication drivers
Non-Transparent Bridge (NTB) - PCIe non-transparent bridges for multi-host systems
NVDIMM - Persistent memory (PMEM) and NVDIMM drivers
NVMEM Framework - Unified API for EEPROM, OTP, and fuse storage
Parallel Port (Low-Level) - Low-level parallel port access
PHY Subsystem - Generic PHY (USB, PCIe, MIPI) framework
Pin Control Subsystem - Pin multiplexing and configuration
PLDM Firmware Update - Platform Level Data Model firmware loading
Pulse-Per-Second (PPS) - PPS signal handling for precision timing
PTP Hardware Clock - IEEE 1588 Precision Time Protocol support
Pulse Width Modulation (PWM) - PWM controller framework
Power Sequencing - Coordinating power-on sequences for devices
Voltage and Current Regulator - Regulator framework for voltage/current control
Reset Controller - Hardware reset line management
RF Kill Switch - Enabling and disabling wireless transmitters
S/390 Device Drivers - IBM mainframe channel-attached device drivers
SCSI Interfaces - SCSI host adapter and transport drivers
Serial/UART - Serial port and UART driver framework
SM501 Multimedia Companion Chip - Silicon Motion SM501 display controller
SoundWire - MIPI SoundWire audio bus
SPI - SPI master and device driver framework
Surface Aggregator - Microsoft Surface embedded controller interface
Switchtec - Microsemi Switchtec PCIe switch management
Sync File API - Fence-based synchronization between drivers
Target (SCSI) - SCSI target mode framework (LIO)
Trusted Execution Environment (TEE) - OP-TEE and other TEE driver interface
Thermal - Thermal zones, cooling devices, and governors
TTY - TTY layer, line disciplines, and serial core
WBRF: Wi-Fi Band RFI Mitigations - Coordinating frequency use between WiFi and display
WMI - Windows Management Instrumentation device interface
Xilinx - Xilinx FPGA platform drivers
Zorro Bus - Amiga Zorro expansion bus

Memory Management

Virtual memory, physical memory, page allocation, reclaim, and swap.

Concepts

Physical Memory Model - How the kernel represents physical RAM
Page Tables - Multi-level page table layout and manipulation
Process Addresses - Virtual address space layout for processes
Boot Memory Allocator - memblock allocator used before slab is ready
Page Allocation - Buddy allocator and alloc_pages()
vmalloc - Allocating virtually contiguous memory
Slab Allocator - SLUB/SLAB cache for small object allocation
High Memory Handling - Accessing memory above the direct-mapped region on 32-bit
Page Reclaim - How the kernel reclaims pages under memory pressure
Swap - Swapping anonymous pages to disk
Swap Table - Swap entry format and swap slot management
Page Cache - Caching file data in memory
Shared Memory Filesystem (shmfs/tmpfs) - tmpfs and shared memory backed by swap
Out of Memory (OOM) Killer - What happens when the system runs out of memory

Advanced Topics

Active MM - Lazy TLB and active_mm for kernel threads
Allocation Profiling - Tracking memory allocation call sites
Architecture Page Table Helpers - Testing arch-specific page table entry operations
Memory Balancing - Balancing memory usage across zones
DAMON: Data Access MONitor - Monitoring memory access patterns for optimization
Free Page Reporting - Reporting free pages to hypervisors for memory overcommit
Heterogeneous Memory Management (HMM) - Sharing address spaces with accelerators like GPUs
HWPoison: Memory Error Handling - Recovering from uncorrectable memory errors
HugeTLBfs Reservation - Reserving huge pages to avoid allocation failures
Kernel Same-Page Merging (KSM) - Deduplicating identical pages across processes
Physical Memory Model - FLATMEM, SPARSEMEM, and memory sections
memfd Preservation - Preserving memfd files across live update
MMU Notifiers - Notifying secondary MMUs of page table changes
Multi-Gen LRU - Generation-based page aging for better reclaim
NUMA Memory Policy - Controlling memory placement on NUMA systems
Overcommit Accounting - How Linux decides whether to allow allocations
Page Migration - Moving pages between NUMA nodes
Page Fragments - Sub-page allocation for networking buffers
Page Owner: Tracking About Who Allocated Each Page - Debug feature to trace page allocation origins
Page Table Check - Runtime checks for page table corruption
remap_file_pages() - Legacy non-linear file mapping (mostly deprecated)
Split Page Table Lock - Per-table locks to reduce contention
Transparent Hugepage Support - Automatic huge page promotion without application changes
Unevictable LRU - Pages that should never be swapped out
Virtually Mapped Kernel Stacks - Guard pages and vmalloc-backed thread stacks
vmemmap Dedup - Sharing struct page memory for huge pages
zsmalloc - Compressed page allocator used by zram

Locking

Locking primitives, lockdep, mutexes, spinlocks, and futexes.

Lock Types and Their Rules - Overview of all lock types and when to use each
Runtime Locking Correctness Validator (lockdep) - How lockdep detects deadlocks and lock ordering violations
Lock Statistics - Measuring lock contention and hold times
Lock Torture Tests - Stress testing locking primitives
Generic Mutex Subsystem - Design and implementation of kernel mutexes
RT-Mutex Design - Priority-inheritance mutexes for real-time
RT-Mutex Implementation - Implementation details of RT mutexes
Sequence Counters and Sequential Locks - Reader-optimized locks using sequence numbers
Locking Lessons - When to use spinlocks vs mutexes vs other primitives
Wound/Wait Mutex Design - Deadlock-avoidance mutexes for GPU and DRM
Proper Locking Under a Preemptible Kernel - Locking considerations with CONFIG_PREEMPT
PI-Futex - Priority-inheritance futexes for userspace
Futex Requeue PI - Requeuing waiters with priority inheritance
Hardware Spinlock Framework - Spinlocks implemented in hardware for multi-processor SoCs
Per-CPU RW Semaphore - Ultra-fast reader path using per-CPU counters
Robust Futexes - Automatically releasing futexes when a thread dies
Robust Futex ABI - Userspace ABI for robust futex lists

Scheduler

CPU scheduling: CFS, EEVDF, deadline, real-time, and energy-aware scheduling.

CFS Scheduler Design - Completely Fair Scheduler using virtual runtime
EEVDF Scheduler - Earliest Eligible Virtual Deadline First scheduler
Deadline Scheduling - SCHED_DEADLINE for hard real-time tasks
Real-Time Group Scheduling - Bandwidth limits for SCHED_FIFO and SCHED_RR groups
CFS Bandwidth Control - Throttling CPU usage per cgroup
Scheduler Domains - Topology-aware load balancing across CPUs
CPU Capacity - Modeling CPU performance differences on big.LITTLE
Energy-Aware Scheduling - Placing tasks to minimize power consumption
Schedutil CPU Frequency Governor - Scheduler-driven CPU frequency selection
Utilization Clamping - Bounding CPU utilization for performance and power hints
Scheduler Nice Design - How nice values map to weights and time slices
Scheduler Statistics - Runtime stats for debugging scheduler behavior
Extensible Scheduler Class (sched_ext) - BPF-programmable scheduling policies
Scheduler Debugging - Debug interfaces for scheduler internals
Completions: Wait for Completion - Simple mechanism for one thread to signal another
membarrier() System Call - Expedited memory barriers across threads
Architecture-Specific Scheduler Support - What architectures need to implement for the scheduler
Scheduler Text Files - Additional text documentation files

Timers

High-resolution timers, timekeeping, and delay functions.

High-Resolution Timers - Nanosecond-precision kernel timers
High Precision Event Timer (HPET) - x86 hardware timer for precise timing
hrtimers: High-Resolution Kernel Timers - Subsystem for sub-jiffy timer resolution
NO_HZ: Reducing Scheduling-Clock Ticks - Tickless operation for idle and busy CPUs
Timekeeping - How the kernel tracks wall-clock and monotonic time
Delay and Sleep Functions - udelay, msleep, usleep_range, and when to use which

Power Management

Suspend, hibernate, runtime PM, power supply, and regulators.

Core Power Management

APM or ACPI? - Choosing between legacy APM and modern ACPI
Debugging Hibernation and Suspend - Troubleshooting suspend/resume failures
Charger Manager - Battery charging policy management
Testing Suspend and Hibernate - How to test your driver's PM callbacks
Energy Model of Devices - Per-device power consumption modeling
Freezing of Tasks - Stopping all userspace and some kernel threads for suspend
Operating Performance Points (OPP) - Voltage/frequency pairs for DVFS
PCI Power Management - PCI D-states and power management
PM QoS Interface - Requesting minimum performance or latency guarantees
Power Supply Class - Battery and charger status reporting
Runtime Power Management - Powering devices on/off while the system is running
How to Triage S2RAM Issues - Debugging suspend-to-RAM problems
Shutdown Debugging - Troubleshooting system shutdown hangs
Suspend and CPU Hotplug - Interaction between suspend and CPU onlining/offlining
Suspend and Interrupts - How interrupts are handled during suspend/resume
Using Swap Files with Software Suspend - Hibernating to a swap file instead of a partition
Software Suspend with dm-crypt - Hibernation when swap is encrypted
Software Suspend - How hibernation saves and restores system state
Video Issues with S3 - Graphics card quirks after resume
Power Management Tricks - Tips for debugging power management
Userland Software Suspend - Hibernate from userspace via /dev/snapshot

Powercap

Power Capping Framework - Limiting power consumption of system components
Dynamic Thermal Power Management (DTPM) - Thermal-aware power budget distribution

Regulator

Regulator Framework Overview - How the kernel manages voltage and current regulators
Regulator Consumer API - Requesting and controlling voltage from driver code
Regulator Design - Design principles of the regulator framework
Regulator Machine Driver Interface - Board-level regulator constraints and connections
Regulator Driver Interface - Writing a driver for a voltage regulator chip

Networking

Network stack, protocols, drivers, and configuration.

Core Networking

Linux Networking API - Kernel networking function reference
Network Device Drivers - How to write a network device driver
Network Devices - Rules and conventions for net_device
Netdev Features - Feature flags on network devices
Scaling in the Linux Networking Stack - RSS, RPS, RFS, XPS, and multi-queue scaling
NAPI - Polling-based packet receive for high throughput
sk_buff: Network Buffer - The core data structure holding network packets
Page Pool - Recycling pages for fast network buffer allocation
Net DIM: Adaptive Interrupt Coalescing - Dynamically tuning interrupt moderation
Generic Statistics - Shared statistics infrastructure for qdisc and filters
Statistics - Network device statistics guidelines
Network Interface Message Level - Controlling driver debug message verbosity
Netmem - Network memory descriptor abstraction
Multiqueue - Multi-queue transmit support
Multi-PF Netdev - Single netdev backed by multiple physical functions
Net Cachelines - Cache line layout analysis for networking structs
Net Failover - Automatic failover between VF and paravirt NIC
Failover - Generic network failover module

Configuration and Management

IP Aliases - Multiple IP addresses on a single interface
Linux Ethernet Bonding - Link aggregation and failover for NICs
Ethernet Bridging - Software Ethernet bridge/switch
Dynamic IP Address - Handling dynamically assigned IP addresses
IP Sysctl - Tunable parameters in /proc/sys/net/ipv4 and ipv6
IPv6 - IPv6 implementation notes and configuration
IPVLAN - IP-based virtual LAN device
Netconsole - Logging kernel messages over the network
Operational States - Link state (up/down) tracking for network interfaces
Wireless Regulatory Infrastructure - Country-specific wireless frequency regulation
Sysfs Tagging - Per-network-namespace sysfs filtering
Virtual Routing and Forwarding (VRF) - Multiple routing tables on a single host
VXLAN - Virtual Extensible LAN overlay network
Team Driver - Userspace-controlled link aggregation
TUN/TAP - Virtual network devices for userspace networking
Representors - Representing switch ports as netdevs for offloading
Switchdev - Offloading the bridge and router to hardware switches
Packet Generator (pktgen) - In-kernel high-speed packet generator for testing

Protocols

CAN Bus - Controller Area Network used in vehicles and industrial systems
CAN UCAN Protocol - USB-CAN adapter protocol
Dell Systems Management - Dell OpenManage system management base driver
DataCenter TCP (DCTCP) - ECN-based congestion control for data centers
DNS Resolver - In-kernel DNS name resolution via userspace helper
GTP (GPRS Tunneling Protocol) - Mobile network tunneling used in LTE/5G
Identifier Locator Addressing (ILA) - IPv6 address translation for scalable networking
IPsec - IP-level encryption and authentication
Kernel Connection Multiplexor (KCM) - Multiplexing application protocol messages over TCP
L2TP - Layer 2 tunneling for PPP and Ethernet
Management Component Transport Protocol (MCTP) - Management protocol for platform components
MPLS Sysctl - Sysctl tunables for MPLS label switching
Multipath TCP (MPTCP) - Using multiple paths for a single TCP connection
MPTCP Sysctl - Sysctl tunables for MPTCP
Phonet Protocol Family - Nokia modem communication protocol
PLIP: Parallel Line IP - IP networking over parallel port cables
PPP Generic - Point-to-Point Protocol kernel layer
Reliable Datagram Sockets (RDS) - High-performance inter-node messaging over RDMA or TCP
RxRPC Protocol - AFS remote procedure call protocol
SCTP - Stream Control Transmission Protocol
TCP-AO - TCP Authentication Option (RFC 5925)
Thin Streams (TCP) - Optimizations for interactive thin TCP streams
Transparent Inter Process Communication (TIPC) - Cluster-level messaging protocol
UDP-Lite - UDP with partial checksum coverage
X.25 Protocol - Legacy packet-switched network protocol
X.25 Interface - X.25 device driver interface

Offloading and Optimization

Checksum Offloads - Offloading IP/TCP/UDP checksums to hardware
Segmentation Offloads - TSO, GSO, GRO, and related offloads
Zero-Copy Networking - Sending data without copying to kernel buffers
In-Kernel TLS - TLS record layer in the kernel for offloading
TLS Offload - Offloading TLS crypto to network hardware
TLS Handshake - Kernel-initiated TLS handshakes via userspace
Device Memory TCP - Zero-copy receive directly into device memory
Stream Parser - Application-layer message framing in the kernel
SR-IOV - Single Root I/O Virtualization for network cards

Filtering and Traffic Control

Linux Socket Filtering (BPF) - Packet filtering with classic and extended BPF
Netfilter Sysctl - Sysctl tunables for netfilter
Conntrack Sysctl - Sysctl tunables for connection tracking
Flowtable - Accelerating forwarded flows past conntrack
TC Actions Environment Rules - Rules for TC action execution environment
TC Queue and Filters - Traffic control queue disciplines and classifiers
Transparent Proxy - Redirecting traffic without client awareness

XDP and AF_XDP

AF_XDP - Ultra-fast packet processing in userspace via XDP sockets
XDP RX Metadata - Passing NIC metadata to XDP programs
XSK TX Metadata - Passing metadata from AF_XDP to NICs on transmit

Timestamping and PTP

Network Timestamping - Hardware and software packet timestamps
PTP Hardware Clock - IEEE 1588 precision time protocol clocks
Pulse-Per-Second - PPS signals for time synchronization

Wireless and Mobile

IEEE 802.15.4 - Low-rate wireless personal area networks (Zigbee PHY)
6LoWPAN - IPv6 over low-power wireless networks
mac80211 Packet Injection - Injecting raw 802.11 frames for testing
NFC - Near-field communication networking
CDC MBIM - USB mobile broadband interface model

XFRM and IPsec

XFRM: IPsec Transformation - IPsec security association and policy framework
Security ID - Mapping security labels to network packets

Device Driver Infrastructure

Network Device Drivers - Documentation for specific NIC drivers
Devlink - Device management and configuration for smart NICs
Distributed Switch Architecture (DSA) - In-kernel framework for Ethernet switch chips
Ethtool Netlink Interface - Modern netlink-based ethtool API
PHY Abstraction Layer - Ethernet PHY driver framework
SFP/Phylink - SFP module and phylink integration
PHY Link Topology - Representing complex PHY topologies
PHY Port - Physical port abstraction
PSE/PD (Power Sourcing Equipment) - Power over Ethernet source/device drivers
Network Diagnostics - Standardized link and cable diagnostics

Miscellaneous

Bare UDP Tunnels - Lightweight UDP tunneling for MPLS and IP
B.A.T.M.A.N. Advanced - Layer 2 mesh networking protocol
CAIF - ST-Ericsson modem communication protocol
Generic HDLC - WAN interfaces using HDLC framing
Generic Netlink - Extensible netlink family for custom protocols
ISO 15765-2 - CAN transport protocol for automotive diagnostics
SAE J1939 - CAN protocol for heavy vehicles
LAPB Module - Link Access Procedure Balanced for X.25
Open vSwitch - Programmable virtual switch for SDN
Packet MMAP - Zero-copy packet capture via shared ring buffer
/proc/net/tcp - Format of TCP socket information in /proc
PSP Security Protocol - Google's PSP encryption for data center traffic
Radiotap Headers - Metadata format for captured 802.11 frames
Segment Routing v6 Sysctl - Sysctl tunables for SRv6
SMC Sysctl - Sysctl tunables for SMC (Shared Memory Communication)
SNMP Counters - Kernel SNMP MIB statistics
OA TC6 Framework - Open Alliance 10BASE-T1x MAC-PHY serial interface
io_uring Zero-Copy RX - Zero-copy receive via io_uring
IOAM6 Sysctl - In-situ OAM for IPv6 tunables
Resilient Nexthop Groups - ECMP groups that minimize flow disruption on changes
FIB Trie - LC-trie implementation for routing table lookups
EQL: Traffic Equalizer - Load balancing across multiple slow links
ATM - Asynchronous Transfer Mode networking
ARCnet - Attached Resource Computer Network
ARCnet Hardware - ARCnet hardware compatibility information
AX.25 - Amateur radio packet protocol
6PACK Protocol - TNC protocol for amateur radio packet networking
Netlink Specs - Machine-readable netlink protocol specifications

Filesystems

VFS internals, filesystem implementations, and support layers.

Core VFS Documentation

Overview of the Linux Virtual File System - How VFS ties all filesystems together
Pathname Lookup - How the kernel resolves /path/to/file
VFS API Summary - Reference for VFS functions and data structures
Splice - Moving data between file descriptors without copying
VFS Locking - Locking rules for inode, dentry, and superblock
Directory Locking - Locking order for directory operations like rename
devpts - Pseudo-terminal device filesystem
dnotify - Legacy directory change notification
FIEMAP ioctl - Querying file extent mappings
File Management - File descriptor table and struct file internals
File Locking - POSIX locks, flock, and lease locks
Multi-Grain Timestamps - Coarse and fine-grained file timestamps
Filesystem Mount API - New mount API using fsopen/fsconfig/fsmount
Disk Quotas - Per-user and per-group disk space limits
The seq_file Interface - Helper for creating /proc and other read-only files
Shared Subtrees - Mount propagation: shared, private, slave, unbindable
ID Mappings - UID/GID remapping for containers and mounts
iomap - Modern block mapping interface replacing buffer_heads
Automount Support - Automatic mounting of filesystems on access
Filesystem Caching - fscache and cachefiles for network filesystem caching
Porting Filesystems to New APIs - Guide for updating filesystems to newer VFS interfaces

Filesystem Support Layers

Buffer Heads - Legacy block buffer cache (being replaced by iomap)
Journalling - JBD2 journaling layer used by ext4 and others
Filesystem-Level Encryption (fscrypt) - Per-file encryption for ext4, f2fs, and ubifs
fs-verity - Read-only file integrity verification using Merkle trees
Network Filesystem Helper Library - Shared read/write helpers for NFS, CIFS, AFS, and friends

Filesystems

9P (Plan 9) - Plan 9 resource sharing protocol
ADFS - Acorn Disc Filing System from RISC OS
AFFS (Amiga Fast File System) - Amiga-compatible filesystem
AFS (Andrew File System) - Distributed network filesystem from CMU/OpenAFS
autofs - Automounter filesystem for on-demand mounts
autofs Mount Control - Ioctl interface for automount management
BeFS (BeOS File System) - Read-only support for BeOS partitions
BFS - Boot Filesystem used by SCO UnixWare
Btrfs - Copy-on-write filesystem with snapshots, RAID, and compression
Ceph Distributed File System - POSIX filesystem backed by Ceph storage cluster
Coda - Distributed filesystem with disconnected operation
configfs - User-created kernel objects via a filesystem interface
cramfs - Compressed read-only filesystem for embedded
DAX: Direct Access - Accessing persistent memory without the page cache
debugfs - Simple filesystem for kernel debugging interfaces
dlmfs - Filesystem interface to the OCFS2 distributed lock manager
eCryptfs - Stacked encrypted filesystem (legacy, prefer fscrypt)
efivarfs - Filesystem for reading and writing EFI variables
EROFS - Enhanced Read-Only File System for Android and containers
ext2 - Classic Linux filesystem without journaling
ext3 - ext2 with journaling (largely superseded by ext4)
ext4 - Default Linux filesystem with extents, delayed alloc, and journaling
F2FS (Flash-Friendly File System) - Log-structured filesystem optimized for flash storage
GFS2 (Global File System 2) - Shared-disk cluster filesystem
HFS - Classic Mac OS filesystem
HFS+ - Mac OS X filesystem (read-write support)
HPFS - OS/2 High Performance File System
FUSE - Filesystem in Userspace
inotify - File and directory change notification API
isofs (ISO 9660) - CD-ROM filesystem
NILFS2 - Log-structured filesystem with continuous snapshotting
NFS - Network File System client and server
NTFS3 - Full read-write NTFS support (Paragon driver)
OCFS2 - Oracle Cluster File System 2
OCFS2 Online File Check - Online consistency checking for OCFS2
OMFS - Optimized MPEG Filesystem from ReplayTV
OrangeFS - Parallel distributed filesystem for HPC
Overlay Filesystem - Union mount with upper and lower layers (used by containers)
The /proc Filesystem - Process and kernel information pseudo-filesystem
QNX6 Filesystem - QNX Neutrino power-safe filesystem
ramfs, rootfs, and initramfs - RAM-based filesystems used during early boot
Relay (High-Speed Data Relay) - Efficient bulk data transfer from kernel to userspace
Resource Control - Cache and memory bandwidth partitioning via resctrl
romfs - Simple read-only filesystem for embedded systems
SMB3 (CIFS) - Windows/Samba file sharing client
SPU Filesystem - Cell Broadband Engine SPU access
SquashFS - Compressed read-only filesystem for live CDs and embedded
sysfs - Kernel object hierarchy exported to userspace
tmpfs - RAM-backed filesystem that can swap to disk
UBIFS - Unsorted Block Image File System for raw flash
UBIFS Authentication - Integrity protection for UBIFS using HMAC
UDF - Universal Disk Format used on DVDs and Blu-ray
virtiofs - Sharing host directories with VMs via virtio
VFAT (FAT32) - FAT filesystem with long filename support
XFS - High-performance journaling filesystem from SGI
zonefs - Filesystem exposing zoned block device zones as files

Block Layer

Block I/O scheduling, inline encryption, and multiqueue.

BFQ I/O Scheduler - Budget Fair Queueing for low-latency desktop I/O
Block IO Vectors (biovecs) - Representing scatter-gather I/O in the block layer
Multi-Queue Block IO Queueing (blk-mq) - Modern multi-queue block I/O framework
Command-Line Partition - Specifying disk partitions via kernel command line
Data Integrity - End-to-end data integrity with DIF/DIX
Deadline I/O Scheduler - Guaranteeing I/O request latency bounds
Inline Encryption - Hardware-accelerated encryption at the block layer
Block I/O Priorities - Per-process I/O scheduling priority
Kyber I/O Scheduler - Token-based scheduler targeting read/write latency
Null Block Driver - In-memory block device for testing and benchmarking
Persistent Reservations - SCSI persistent reservations for shared storage
Block Layer Statistics - I/O statistics in /sys/block/*/stat
Switching I/O Schedulers - Changing the I/O scheduler at runtime
Writeback Cache Control - Flush and FUA for data integrity on write caches
ublk: Userspace Block Driver - Implementing block devices in userspace via io_uring

Security

Kernel security modules, credentials, keys, and integrity measurement.

Credentials in Linux - UIDs, GIDs, capabilities, and keyrings attached to tasks
SNP/TDX Threat Model - Threat model for AMD SEV-SNP and Intel TDX confidential VMs
IMA Templates - Integrity Measurement Architecture template formats
Kernel Keys - In-kernel keyring service for cryptographic keys
Linux Security Module Framework - Pluggable security hooks (SELinux, AppArmor, etc.)
LSM Development - Writing a new Linux Security Module
Secure Attention Key (SAK) - Killing all processes on a terminal to ensure a trusted login
SCTP Security - Security considerations for SCTP connections
Kernel Self-Protection - Hardening the kernel against its own bugs
SipHash - Fast keyed hash for hash tables and network cookies
TPM (Trusted Platform Module) - Hardware root of trust and measured boot
Digital Signature Verification - Verifying signatures on kernel modules and IMA
Landlock LSM - Unprivileged sandboxing by restricting filesystem access
Secrets - Confidential computing secret injection
Integrity Policy Enforcement (IPE) - Allowlisting executables based on integrity properties

Crypto

Cryptographic API, algorithms, and hardware acceleration.

Kernel Crypto API Introduction - Overview of the in-kernel cryptography framework
Crypto API Architecture - Layers and components of the crypto subsystem
Kernel Crypto API Architecture - Detailed design of cipher, hash, and AEAD transforms
Async TX API - Asynchronous DMA-offloaded operations for RAID and crypto
Asymmetric/Public-Key Cryptography - RSA, ECDSA, and public key handling in the kernel
Developing Cipher Algorithms - How to add a new cipher or hash to the kernel
Userspace Interface - AF_ALG socket interface for userspace crypto
Crypto Engine - Queuing and scheduling crypto requests for hardware
Programming Interface - Function-level API reference for the crypto subsystem
Code Examples - Example code showing how to use the crypto API
DES and 3DES - DES implementation notes (legacy, avoid in new code)
Crypto Device Drivers - Hardware crypto accelerator driver documentation
Kerberos 5 Support - Kerberos crypto operations in the kernel for NFS and AFS
SHA-3 - SHA-3 (Keccak) hash implementation

BPF

eBPF subsystem: verifier, programs, maps, and tooling.

eBPF Verifier - How the verifier ensures BPF programs are safe
libbpf - C library for loading and interacting with BPF programs
BPF Standardization - IETF standardization of the BPF instruction set
BPF Type Format (BTF) - Type information for BPF programs and the kernel
BPF FAQ - Frequently asked questions about BPF
BPF Syscall API - The bpf() system call and its commands
BPF Helper Functions - Kernel functions callable from BPF programs
BPF Kernel Functions (kfuncs) - Modern replacement for BPF helpers with BTF signatures
BPF cpumask kfuncs - CPU mask manipulation from BPF programs
BPF Filesystem kfuncs - Filesystem operations available to BPF
BPF Program Types - All BPF program types and their attach points
BPF Maps - Key-value stores shared between BPF programs and userspace
BPF_PROG_RUN - Running BPF programs from userspace for testing
Classic BPF vs Extended BPF - Differences between legacy cBPF and modern eBPF
BPF Iterators - Iterating over kernel data structures from BPF
BPF Licensing - License requirements for BPF programs
BPF Testing and Debugging - Tools and techniques for debugging BPF code
Clang Notes for BPF - Compiling BPF programs with Clang
Linux Notes for BPF - Kernel-specific BPF notes and tips
Other BPF Documentation - Additional BPF resources and references
BPF Redirect - Redirecting packets between interfaces with BPF

Tracing

Ftrace, kprobes, uprobes, events, and hardware tracing.

Introduction to Tracing

Kernel Debugging with Tracing - Using tracing tools to find and fix kernel bugs
Using Tracepoints - Static instrumentation hooks in the kernel
Tracepoint Analysis - Analyzing tracepoint output
Ring Buffer Memory Mapping - Mapping the trace ring buffer into userspace

Core Tracing Frameworks

ftrace: Function Tracer - The primary kernel function tracing framework
ftrace Design - How ftrace is implemented internally
Using ftrace to Hook to Functions - Registering callbacks on kernel function entry/exit
Kernel Probes (kprobes) - Dynamic instrumentation at any kernel instruction
Kprobe-Based Event Tracing - Creating trace events from kprobe attach points
Fprobe-Based Event Tracing - Function-level probe events using fprobe
Event-Probe Based Tracing - Probing trace events to create derived events
Fprobe: Function Entry/Exit Probe - Lightweight function entry and exit tracing
Ring Buffer Design - Lock-free ring buffer used by ftrace

Event Tracing and Analysis

Event Tracing - Tracing predefined kernel events via tracefs
Kmem Events - Memory allocation and page events
Power Events - CPU frequency and power state transitions
NMI Events - Non-maskable interrupt tracing
MSR Events - Model-specific register access tracing
PCI Events - PCI power state and error events
Boot-Time Tracing - Configuring tracing from the kernel command line
Event Histograms - Aggregating event data into histograms in-kernel
Histogram Design - Implementation details of the histogram trigger

Hardware and Performance Tracing

Intel Trace Hub - Intel hardware trace capture and routing
System Trace Module (STM) - Generic hardware trace source interface
MIPI SyS-T - MIPI System Software Trace protocol
ARM CoreSight - ARM hardware debug and trace infrastructure
Runtime Verification - Verifying kernel behavior against formal models
HiSilicon PTT - HiSilicon PCIe Tune and Trace
MMIO Tracing - Recording memory-mapped I/O for driver debugging
Hardware Latency Detector - Finding platform-caused latency spikes (SMIs, etc.)
OS Noise Tracer - Measuring operating system noise on CPUs
Timer Latency Tracer - Measuring wakeup latency for real-time analysis

User-Space Tracing

User Events - Userspace-defined trace events visible in ftrace
Uprobe-Based Tracing - Dynamic instrumentation of userspace applications

GPU/DRM

Direct Rendering Manager, kernel mode setting, and GPU drivers.

Introduction to GPU and Display Subsystem - Overview of the DRM/KMS graphics stack
DRM Internals - Core DRM data structures and driver registration
DRM Memory Management - GEM objects, TTM, and GPU memory management
Kernel Mode Setting (KMS) - CRTCs, connectors, encoders, and planes
KMS Helpers - Common helpers for atomic modesetting and probing
DRM Userspace API - DRM ioctls exposed to userspace
DRM Usage Statistics - Per-client GPU usage tracking via fdinfo
Driver-Specific UAPI - Per-driver userspace interfaces
DRM Client - In-kernel DRM clients (fbdev emulation, console)
DRM Compute - GPU compute scheduling and dispatch
GPU Driver Documentation - Documentation for individual GPU drivers
Backlight - Display backlight control
VGA Switcheroo - Switching between discrete and integrated GPUs
VGA Arbiter - Arbitrating legacy VGA I/O between multiple GPUs
Automated Testing - CI and testing for the DRM subsystem
Implementation Guidelines - Best practices for DRM driver developers
TODO List - Open tasks and improvement ideas for DRM
RFCs - Request for comments on proposed DRM changes

Sound

ALSA kernel API, HD-Audio, ASoC, and sound card drivers.

ALSA Kernel API - PCM, control, sequencer, and other ALSA interfaces
Sound Subsystem Design - Design documents for the sound subsystem
ASoC: ALSA System on Chip - Framework for embedded audio with codec, platform, and machine drivers
ALSA Driver Configuration - Module parameters for ALSA sound drivers
HD-Audio - Intel/AMD High Definition Audio codec and controller support
Sound Card Drivers - Driver docs for specific sound cards
Audio Codec Drivers - Individual audio codec chip drivers
Userspace Timers - Timer devices for userspace audio scheduling

Input

Input subsystem for keyboards, mice, touchscreens, and other input devices.

Input Subsystem Userspace API - evdev and input event interfaces for applications
Input Subsystem Kernel API - Registering input devices and reporting events
Input Device Drivers - Individual input device driver documentation

USB

USB host controllers, gadget framework, and device class drivers.

USB ACM (Abstract Control Model) - USB serial via CDC ACM (used by many USB modems)
USB Authorization - Controlling which USB devices are allowed to connect
ChipIdea USB - ChipIdea dual-role USB controller driver
DesignWare USB3 (DWC3) - Synopsys DesignWare USB 3.0 controller
EHCI Host Controller - USB 2.0 Enhanced Host Controller Interface
FunctionFS - User-defined USB gadget functions via a filesystem
FunctionFS Descriptors - Descriptor format for FunctionFS endpoints
USB Gadget ConfigFS - Configuring USB gadget devices from userspace
USB Gadget HID - Emulating a USB keyboard/mouse from Linux
USB Gadget Multi - Composite gadget combining multiple functions
USB Gadget Printer - Emulating a USB printer
USB Gadget Serial - Emulating a USB serial port
USB Gadget UVC - Emulating a USB webcam
USB Gadget Testing - Testing USB gadget functions
IUU Phoenix USB - Infinity USB smartcard reader
USB Mass Storage - USB storage class driver and gadget
USB 7-Segment Display - USB seven-segment display controller
USB Touchscreen - MicroTouch USB touchscreen driver
OHCI Host Controller - USB 1.1 Open Host Controller Interface
USB Raw Gadget - Low-level USB gadget access for fuzzing and testing
USB/IP Protocol - Sharing USB devices over the network
USB Monitor (usbmon) - Capturing USB traffic for debugging
USB Serial - USB-to-serial converter drivers
USB Help Resources - Where to find USB-related help
USB Text Files - Additional USB documentation files

PCI

PCI bus, PCIe, SR-IOV, MSI, and endpoint framework.

How to Write Linux PCI Drivers - Getting started with PCI driver development
PCI Express Port Bus Driver - Services provided by the PCIe port bus driver
PCI SR-IOV HOWTO - Using Single Root I/O Virtualization
MSI/MSI-X HOWTO - Setting up Message Signaled Interrupts
PCI Sysfs Interface - PCI device attributes exposed in sysfs
ACPI Considerations for PCI - How ACPI interacts with PCI device discovery
PCI Error Recovery - Handling and recovering from PCI bus errors
PCIe Advanced Error Reporting (AER) - Detecting and reporting PCIe errors
PCI Endpoint Framework - Building PCI endpoint (target) devices
PCI Controller Drivers - PCI host bridge/controller driver documentation
PCI Boot Interrupts - Legacy boot interrupt quirks
TLP Processing Hints (TPH) - Hinting cache placement for PCI transactions

I2C

I2C and SMBus protocol, device instantiation, and driver writing.

Introduction

I2C and SMBus Introduction - What I2C and SMBus are and how they differ
I2C Protocol - Wire-level I2C protocol details
SMBus Protocol - System Management Bus transaction types
Instantiating I2C Devices - Ways to tell the kernel about I2C devices
I2C Bus Drivers - I2C adapter/controller drivers
I2C Topology - Muxes, gates, and complex I2C bus topologies
I2C GPIO Mux - GPIO-controlled I2C bus multiplexer
I2C Sysfs Interface - I2C device and bus attributes in sysfs
I2C Address Translators - Remapping I2C addresses through bridges

Writing Device Drivers

Implementing I2C Device Drivers - How to write an I2C client driver
I2C /dev Interface - Accessing I2C from userspace via /dev/i2c-*
I2C DMA Considerations - Using DMA-safe buffers with I2C
I2C Fault Codes - Error codes returned by I2C operations
I2C Functionality - Querying what an I2C adapter supports

Debugging and Slave I2C

I2C GPIO Fault Injection - Simulating I2C bus errors for testing
I2C Stub Driver - Virtual I2C adapter for testing without hardware
I2C Slave Interface - Implementing I2C target/slave mode
I2C Slave EEPROM Backend - Emulating an I2C EEPROM in the kernel
I2C Slave Test Unit Backend - I2C slave test unit for testing master drivers
I2C 10-Bit Addresses - Support for extended I2C addressing
I2C Old Module Parameters - Legacy module parameters (use DT or ACPI instead)

SPI

Serial Peripheral Interface bus.

SPI Overview - How the SPI subsystem works
SPI Userspace API (spidev) - Accessing SPI devices from userspace via /dev/spidev*
SPI Multiple Data Lanes - Dual, quad, and octal SPI modes
SPI Butterfly - AVR Butterfly SPI programming adapter
SPI LM70 LLP - National LM70 temperature sensor on parallel port
SPI SC18IS602 - NXP I2C-to-SPI bridge

HID

Human Interface Devices: core, transport, BPF, and sensor hub.

Introduction to HID - Overview of the HID protocol and subsystem
HID Device Interface - Userspace access to parsed HID reports
HID Raw Interface - Raw HID report access from userspace
HID Sensor Hub - Sensors exposed via HID protocol (accelerometers, etc.)
HID Transport Drivers - USB, Bluetooth, and I2C HID transport layers
HID-BPF - Fixing and extending HID devices with BPF programs
UHID: User-Space HID I/O - Creating virtual HID devices from userspace
ALPS HID - ALPS touchpad HID driver
Intel ISH HID - Intel Integrated Sensor Hub
Intel THC HID - Intel Touch Host Controller
AMD SFH HID - AMD Sensor Fusion Hub

IIO

Industrial I/O: ADCs, accelerometers, gyroscopes, and other sensors.

General

IIO ADC Interface - Using the IIO framework for analog-to-digital converters
IIO ConfigFS - Creating software IIO triggers and devices via configfs
IIO Device Buffers - Buffered data capture from IIO devices
IIO DMA Buffer API - DMA-based high-speed data transfer for IIO
IIO Tools - Userspace utilities for IIO testing and data capture

Device Drivers

AD3552R - Analog Devices 16-bit DAC
AD4000 - Analog Devices precision SAR ADC
AD4030 - Analog Devices 24-bit simultaneous sampling ADC
AD4062 - Analog Devices precision ADC
AD4695 - Analog Devices 16-bit multiplexed SAR ADC
AD7191 - Analog Devices 24-bit sigma-delta ADC
AD7380 - Analog Devices dual simultaneous sampling ADC
AD7606 - Analog Devices 8-channel DAS
AD7625 - Analog Devices 16-bit high-speed SAR ADC
AD7944 - Analog Devices 14-bit SAR ADC
ADE9000 - Analog Devices polyphase energy metering IC
ADIS16475 - Analog Devices precision IMU
ADIS16480 - Analog Devices tactical-grade IMU
ADIS16550 - Analog Devices high-performance IMU
ADXL313 - Analog Devices low-power 3-axis accelerometer
ADXL380 - Analog Devices wide bandwidth accelerometer
ADXL345 - Analog Devices 3-axis digital accelerometer
BNO055 - Bosch absolute orientation sensor
EP93xx ADC - Cirrus EP93xx SoC ADC
OPT4060 - TI high-speed RGBW color sensor

Hardware Monitoring (hwmon)

Drivers for temperature, voltage, fan speed, and power sensors. See hwmon sysfs interface for the common attribute naming convention used by all drivers below.

Core Framework

Hardware Monitoring Kernel API - Registering hwmon devices and attributes
PMBus Core - Shared framework for PMBus power management devices
Submitting hwmon Patches - Guidelines specific to hwmon driver patches
Sysfs Interface - Standard naming for temp, fan, voltage, and power attributes
Userspace Tools - lm-sensors and other tools for reading hwmon data

Sensor Drivers (A-D)

abituguru - Abit uGuru motherboard monitoring
abituguru3 - Abit uGuru version 3 monitoring
acbel-fsg032 - AcBel FSG032 power supply
ACPI Power Meter - ACPI-defined power metering device
AD7314 - Analog Devices SPI temperature sensor
ADC128D818 - TI 12-bit 8-channel ADC system monitor
ADM1025 - Analog Devices voltage and temperature monitor
ADM1026 - Analog Devices system monitor with fan control
ADM1031 - Analog Devices fan controller with temperature sensing
ADM1177 - Analog Devices hot-swap controller and digital monitor
ADM1266 - Analog Devices sequencer and system health monitor
ADM1275 - Analog Devices hot-swap controller with PMBus
ADM9240 - Analog Devices hardware monitoring IC
ADP1050 - Analog Devices digital power controller
ADS7828 - TI 12-bit 8-channel I2C ADC
ADT7410 - Analog Devices 16-bit digital temperature sensor
ADT7411 - Analog Devices voltage and temperature monitor
ADT7462 - Analog Devices sensor and fan controller
ADT7470 - Analog Devices temperature and fan controller
ADT7475 - Analog Devices temperature, voltage, and fan monitor
AHT10 - Aosong temperature and humidity sensor
AMC6821 - TI fan monitor and controller
Aquacomputer D5 Next - Aquacomputer water cooling device monitoring
ASB100 - Asus ASB100 hardware monitor
ASC7621 - Andigilog temperature and fan controller
Aspeed G6 PWM/Tach - Aspeed AST2600 PWM and tachometer
Aspeed PWM/Tacho - Aspeed SoC PWM fan controller
ASUS EC Sensors - ASUS motherboard EC-based sensor readings
ASUS ROG Ryujin - ASUS ROG Ryujin AIO cooler monitoring
ASUS WMI Sensors - ASUS motherboard WMI-based sensor readings
BCM54140 - Broadcom quad-port PHY with temperature sensor
BEL PFE - BEL Power PMBus power supply
BPA-RS600 - BluTek BPA-RS600 power supply
BT1 PVT - Baikal-T1 process/voltage/temperature sensor
CGBC hwmon - Congatec board controller monitoring
ChipCap2 - Amphenol temperature and humidity sensor
Intel Core Temperature - Intel CPU core digital thermal sensor
Corsair Commander Pro - Corsair Commander Pro fan and LED controller
Corsair PSU - Corsair power supply USB monitoring
ChromeOS EC hwmon - ChromeOS Embedded Controller sensors
CRPS - Common Redundant Power Supply monitoring
DA9052 - Dialog DA9052 PMIC ADC channels
DA9055 - Dialog DA9055 PMIC ADC channels
Dell SMM hwmon - Dell laptop SMM BIOS fan and temperature
DME1737 - SMSC DME1737 hardware monitor and fan controller
DPS920AB - Delta DPS920AB power shelf
Drive Temperature - HDD/SSD temperature via SMART
DS1621 - Dallas/Maxim I2C thermometer and thermostat
DS620 - Dallas/Maxim digital thermometer and thermostat

Sensor Drivers (E-K)

EMC1403 - SMSC multi-channel temperature sensor
EMC2103 - SMSC fan controller with temperature sensing
EMC2305 - Microchip RPM-based PWM fan controller
EMC6W201 - SMSC hardware monitoring IC
F71805F - Fintek Super I/O hardware monitor
F71882FG - Fintek Super I/O hardware monitor
AMD Family 15h Power - AMD processor power consumption reporting
FSP-3Y - FSP/3Y Power PMBus power supply
Fujitsu Teutates - Fujitsu server board management controller
G760A - GMT G760A fan speed controller
G762 - GMT G762 fan speed PWM controller
Gigabyte Waterforce - Gigabyte AORUS Waterforce AIO cooler
GSC hwmon - Gateworks System Controller sensors
GL518SM - Genesys Logic system monitoring IC
GPD Fan - GPD handheld device fan control
GXP Fan Control - HPE GXP SoC fan controller
HAC300S - Infineon voltage regulator monitoring
HIH6130 - Honeywell humidity and temperature sensor
HP WMI Sensors - HP server WMI-based sensor data
HS3001 - Renesas humidity and temperature sensor
HTU31 - TE Connectivity humidity and temperature sensor
IBM AEM - IBM Active Energy Manager power monitoring
IBM CFFPS - IBM Common Form Factor Power Supply
IBM PowerNV - IBM POWER platform sensors via OPAL
INA209 - TI bidirectional current/power monitor with alerts
INA2xx - TI current/power monitors (INA219, INA226, etc.)
INA233 - TI PMBus current/power monitor
INA238 - TI 85V, 16-bit high-precision power monitor
INA3221 - TI triple-channel current/voltage monitor
Inspur IPSPS1 - Inspur Power System Power Supply
Intel M10 BMC hwmon - Intel MAX10 board management controller sensors
IR35221 - Infineon dual-loop digital voltage regulator
IR38064 - Infineon voltage regulator
IR36021 - Infineon voltage regulator
ISL28022 - Renesas digital power monitor
ISL68137 - Renesas multi-phase voltage regulator
IT87 - ITE Super I/O hardware monitor and fan controller
JC42 - JEDEC JC 42.4 DIMM temperature sensor
AMD K10 Temperature - AMD CPU temperature (Family 10h+)
AMD K8 Temperature - AMD Athlon 64/Opteron temperature
KBATT - Kernel battery monitoring
KFAN - Kernel fan monitoring

Sensor Drivers (L-N)

LAN966x - Microchip LAN966x SoC temperature sensor
Lineage PEM - Lineage Power Entry Module monitoring
LM25066 - TI PMBus power management IC
LM63 - National remote diode temperature sensor with fan control
LM70 - National SPI temperature sensor
LM73 - National I2C temperature sensor
LM75 - National I2C temperature sensor (very widely used)
LM77 - National temperature sensor with window comparator
LM78 - National hardware monitor (voltage, temp, fan)
LM80 - National I2C hardware monitor
LM83 - National quad temperature sensor
LM85 - National temperature and fan controller
LM87 - National system hardware monitor
LM90 - National I2C dual temperature sensor
LM92 - National high-accuracy temperature sensor
LM93 - National hardware monitor with dual temp/fan control
LM95234 - National quad remote temperature sensor
LM95245 - National dual temperature sensor
Lochnagar - Cirrus Logic audio development board sensors
LT3074 - Analog Devices linear regulator with telemetry
LT7182S - Analog Devices dual-output step-down regulator
LTC2992 - Analog Devices dual power monitor
LTC2945 - Analog Devices wide range power monitor
LTC2947 - Analog Devices power/energy monitor
LTC2978 - Analog Devices PMBus multi-channel power supply manager
LTC2990 - Analog Devices quad I2C voltage/current/temperature monitor
LTC2991 - Analog Devices octal I2C voltage/temperature monitor
LTC3815 - Analog Devices PMBus step-down regulator
LTC4151 - Analog Devices high-voltage I2C current/voltage monitor
LTC4215 - Analog Devices hot-swap controller with I2C monitoring
LTC4245 - Analog Devices multi-supply hot-swap controller
LTC4260 - Analog Devices positive high-voltage hot-swap controller
LTC4261 - Analog Devices negative voltage hot-swap controller
LTC4282 - Analog Devices high-current hot-swap controller with telemetry
LTC4286 - Analog Devices PMBus hot-swap controller
Apple Mac SMC hwmon - Apple Silicon Mac System Management Controller sensors
MAX127 - Maxim 12-bit 8-channel ADC
MAX15301 - Maxim PMBus voltage regulator
MAX16064 - Maxim quad power supply sequencer and monitor
MAX16065 - Maxim multi-channel voltage monitor
MAX1619 - Maxim remote/local temperature sensor
MAX16601 - Maxim PMBus multi-phase voltage regulator
MAX1668 - Maxim multi-channel temperature sensor
MAX17616 - Maxim PMBus hot-swap controller
MAX197 - Maxim multi-range ADC
MAX20730 - Maxim integrated voltage regulator with PMBus
MAX20751 - Maxim multi-phase voltage regulator
MAX31722 - Maxim SPI temperature sensor
MAX31730 - Maxim multi-channel remote temperature sensor
MAX31760 - Maxim precision fan speed controller
MAX31785 - Maxim intelligent fan controller with PMBus
MAX31790 - Maxim 6-channel fan speed controller
MAX31827 - Maxim low-power temperature switch
MAX34440 - Maxim PMBus 6-channel power monitor
MAX6620 - Maxim 4-channel fan controller
MAX6639 - Maxim dual-channel temperature and fan controller
MAX6650 - Maxim fan speed regulator and monitor
MAX6697 - Maxim multi-channel remote temperature sensor
MAX77705 - Maxim PMIC temperature monitor
MAX8688 - Maxim PMBus digital power controller
MC13783 ADC - Freescale MC13783 PMIC ADC
MC33XS2410 - NXP high-side switch with diagnostics
MC34VR500 - NXP PMIC voltage monitor
MCP3021 - Microchip 10-bit A/D converter
MEN F21BMC - MEN board management controller
Mellanox Reg Fan - Mellanox system fan control
MP2856 - MPS dual-loop digital voltage regulator
MP2869 - MPS dual-output voltage regulator
MP2888 - MPS multi-phase voltage regulator
MP2891 - MPS dual-output PMBus regulator
MP2925 - MPS dual-output PMBus regulator
MP29502 - MPS PMBus voltage regulator
MP2975 - MPS multi-phase PMBus voltage regulator
MP2993 - MPS dual-output PMBus regulator
MP5023 - MPS PMBus hot-swap controller
MP5920 - MPS PMBus power monitor
MP5926 - MPS PMBus power monitor
MP5990 - MPS PMBus hot-swap controller
MP9941 - MPS step-down converter with PMBus
MP9945 - MPS PMBus voltage regulator
MPQ8785 - MPS step-down converter
NCT6683 - Nuvoton Super I/O hardware monitor
NCT6775 - Nuvoton Super I/O hardware monitor and fan controller
NCT7363 - Nuvoton fan and GPIO controller
NCT7802 - Nuvoton hardware monitoring IC
NCT7904 - Nuvoton hardware monitoring IC
Nuvoton NPCM750 PWM Fan - Nuvoton BMC SoC fan controller
NSA320 - ZyXEL NSA320 media server sensors
NTC Thermistor - Generic NTC thermistor temperature sensing
NZXT Kraken 2 - NZXT Kraken X42/X52/X62/X72 AIO cooler
NZXT Kraken 3 - NZXT Kraken X53/X63/X73/Z-series AIO cooler
NZXT Smart Device 2 - NZXT Smart Device V2 fan and LED controller

Sensor Drivers (O-Z)

OCC - IBM On-Chip Controller power and temperature
PC87360 - National Super I/O hardware monitor
PC87427 - National Super I/O hardware monitor
PCF8591 - NXP 8-bit A/D and D/A converter
PIM4328 - Flex PMBus power interface module
PLI1209BC - Vicor voltage regulator module
PM6764TR - ST PMBus voltage regulator
PECI CPU Temperature - CPU temperature via Intel PECI interface
PECI DIMM Temperature - DIMM temperature via Intel PECI interface
PMBus Drivers - Generic PMBus device monitoring
PowerZ - ChargerLAB PowerZ USB power meter
POWR1220 - Lattice power manager monitoring
PT5161L - Astera Labs PCIe retimer telemetry
PXE1610 - Infineon PMBus voltage regulator
PWM Fan - Generic PWM-controlled fan
Q54SJ108A2 - Delta power module
QNAP MCU hwmon - QNAP NAS microcontroller sensors
Raspberry Pi hwmon - Raspberry Pi firmware-based monitoring
SB-RMI - AMD sideband remote management interface
SB-TSI Temperature - AMD sideband temperature sensor interface
SCH5627 - SMSC Super I/O hardware monitor
SCH5636 - SMSC Super I/O hardware monitor
SCPI hwmon - ARM SCPI-based SoC sensors
SFC Temperature - StarFive SoC temperature sensor
SG2042 MCU - Sophgo SG2042 board MCU monitoring
SHT15 - Sensirion temperature and humidity sensor
SHT21 - Sensirion temperature and humidity sensor
SHT3x - Sensirion temperature and humidity sensor
SHT4x - Sensirion high-accuracy temperature and humidity sensor
SHTC1 - Sensirion compact humidity and temperature sensor
SIS5595 - SiS 5595 hardware monitor
SL28CPLD - Kontron sl28 board CPLD sensors
STEF48H28 - ST PMBus voltage regulator
SMPro hwmon - Ampere Altra SoC monitoring via SMPro
SMSC47B397 - SMSC Super I/O hardware monitor
SMSC47M192 - SMSC voltage and temperature monitor
SMSC47M1 - SMSC fan speed monitor
Sparx5 Temperature - Microchip Sparx5 switch temperature sensor
SPD5118 - JEDEC SPD5118 DDR5 SPD hub temperature sensor
STPDDC60 - ST PMBus voltage regulator
Surface Fan - Microsoft Surface device fan monitoring
SY7636A hwmon - Silergy e-ink display PMIC temperature
TC654 - Microchip fan speed controller
TC74 - Microchip serial digital thermal sensor
THMC50 - TI analog temperature sensor
TMP102 - TI low-power digital temperature sensor
TMP103 - TI low-power I2C temperature sensor
TMP108 - TI digital temperature sensor with hysteresis
TMP401 - TI remote temperature sensor
TMP421 - TI multi-channel remote temperature sensor
TMP464 - TI multi-channel remote temperature sensor
TMP513 - TI power and temperature monitor
TPS23861 - TI PoE PSE controller
TPS25990 - TI eFuse with PMBus monitoring
TPS40422 - TI PMBus dual-output controller
TPS53679 - TI dual-output PMBus voltage regulator
TPS546D24 - TI PMBus step-down converter
TSC1641 - Semtech high-voltage power monitor
TWL4030 MADC hwmon - TI TWL4030 PMIC ADC channels
UCD9000 - TI PMBus power sequencer and monitor
UCD9200 - TI PMBus multi-rail power supply controller
V-Express - ARM Versatile Express platform sensors
VIA686A - VIA VT82C686A hardware monitor
VT1211 - VIA VT1211 Super I/O hardware monitor
W83627EHF - Winbond Super I/O hardware monitor
W83627HF - Winbond Super I/O hardware monitor
W83773G - Nuvoton dual remote temperature sensor
W83781D - Winbond hardware monitor
W83791D - Winbond hardware monitor with fan control
W83792D - Winbond hardware monitor with PWM fan control
W83793 - Winbond/Nuvoton hardware monitor
W83795 - Nuvoton hardware monitor with smart fan control
W83L785TS - Winbond digital temperature sensor
W83L786NG - Winbond hardware monitor with fan control
WM831x - Wolfson Micro PMIC auxiliary ADC
WM8350 - Wolfson Micro PMIC auxiliary ADC
X-Gene hwmon - APM X-Gene SoC power and temperature
XDP710 - Infineon hot-swap controller with PMBus
XDPE12284 - Infineon multi-phase PMBus voltage regulator
XDPE152C4 - Infineon PMBus voltage regulator
ZL6100 - Intersil/Renesas PMBus voltage regulator

LEDs

LED class drivers, triggers, and LED controller chips.

LED Class - Core LED abstraction and sysfs interface
LED Flash Class - Camera flash LED support
LED Multicolor Class - RGB and multi-color LED grouping
LED One-Shot Trigger - Trigger that blinks once per activation
LED Transient Trigger - Timer-based one-shot LED activation
LED USB Port Trigger - LED blinks on USB port activity
Userspace LEDs - Virtual LEDs controllable from userspace
BlinkM - BlinkM I2C RGB LED
CHT Whiskey Cove - Intel Cherry Trail Whiskey Cove PMIC LED
EL15203000 - Crane Merchandising LED controller
LM3556 - TI camera flash LED driver
LP3944 - National LED driver
LP5521 - TI programmable LED driver
LP5523 - TI programmable 9-channel LED driver
LP5562 - TI programmable 4-channel LED driver
LP55xx Common - Shared framework for TI LP55xx LED drivers
LP5812 - TI 12-channel LED driver
Mellanox CPLD - Mellanox switch system LED controller
MT6370 RGB - MediaTek MT6370 PMIC RGB LED
SC27xx - Spreadtrum SC27xx PMIC LED driver
ST1202 - ST LED1202 12-channel LED driver
Qualcomm LPG - Qualcomm Light Pulse Generator for RGB LEDs

Watchdog

Watchdog timer subsystem and drivers.

Watchdog API - Userspace /dev/watchdog interface
Watchdog Kernel API - Writing watchdog timer drivers
Watchdog Parameters - Common module parameters for watchdog drivers
Watchdog Power Management - How watchdogs behave across suspend/resume
Converting Watchdog Drivers - Migrating legacy drivers to the new watchdog API
HP Watchdog - HP ProLiant iLO NMI watchdog
Mellanox Watchdog - Mellanox switch platform watchdog
PCWD Watchdog - Berkshire PC Watchdog card
WDT - ICS WDT500/501 watchdog card

CPU Frequency

CPU frequency scaling framework and governors.

CPUFreq Core - Core framework for dynamic frequency scaling
CPUFreq Drivers - Writing a CPUFreq scaling driver
CPUFreq Statistics - Time-in-state and transition statistics

RCU

Read-Copy-Update: the kernel's primary read-mostly synchronization mechanism.

What Is RCU? - Introduction to RCU concepts and usage patterns
RCU Concepts - Core ideas behind read-copy-update
RCU Checklist - Things to verify when using RCU
Using RCU to Protect Read-Mostly Linked Lists - RCU patterns for linked list traversal
Using RCU to Protect Dynamic NMI Handlers - Safe NMI handler registration with RCU
RCU on Uniprocessor Systems - How RCU works on single-CPU systems
RCU and lockdep Checking - Using lockdep to validate RCU usage
RCU lockdep Splats - Understanding and fixing RCU lockdep warnings
RCU Barrier - Waiting for all pending RCU callbacks to complete
Proper Use of rcu_dereference() - Rules for safely dereferencing RCU-protected pointers
Using hlist_nulls to Protect Read-Mostly Linked Lists - Lock-free hash table traversal with null markers
Reference-Count Design for Elements of Lists/Arrays Protected by RCU - Combining reference counting with RCU
RCU Torture Tests - Stress testing RCU implementations
RCU Stall Warnings - Diagnosing RCU CPU stall warnings
Tree RCU Memory Ordering - Memory ordering guarantees in Tree RCU
Expedited Grace Periods - Fast grace periods using IPI rather than waiting
RCU Requirements - Formal requirements for any RCU implementation
RCU Data Structures - Internal data structures of Tree RCU

Virtualization

KVM, paravirtualization, Hyper-V, and confidential computing.

KVM: Kernel Virtual Machine - Hardware-assisted virtualization in the kernel
User Mode Linux (UML) - Running a Linux kernel as a userspace process
Paravirt Ops - Paravirtualization hooks for running under hypervisors
Guest Halt Polling - Busy-waiting instead of halting in VMs for low latency
Nitro Enclaves - AWS Nitro isolated execution environments
ACRN Hypervisor - Open-source hypervisor for embedded and IoT
AMD SEV Guest - Running as a guest under AMD Secure Encrypted Virtualization
Intel TDX Guest - Running as a guest under Intel Trust Domain Extensions
Hyper-V - Running Linux on Microsoft Hyper-V

Device Tree

Devicetree usage, overlays, and bindings.

Kernel Devicetree Usage

Linux and the Devicetree - How Linux uses devicetree to discover hardware
Devicetree Unit Tests - Self-tests for the devicetree framework
Devicetree Kernel API - Functions for reading devicetree properties

Devicetree Overlays

Devicetree Changesets - Applying groups of devicetree changes atomically
Dynamic Resolution Notes - Resolving phandle references in overlays at runtime
Devicetree Overlay Notes - Adding and removing hardware descriptions at runtime

Devicetree Bindings

Devicetree Bindings Index - All devicetree binding schemas for Linux drivers

Firmware

Platform firmware interfaces.

ACPI Support for Firmware - ACPI tables, methods, and firmware interaction

Architectures

CPU architecture-specific documentation.

ARC - Synopsys ARC embedded processor
ARM - 32-bit ARM (ARMv7 and earlier)
ARM64 (AArch64) - 64-bit ARM (ARMv8+), used in phones, servers, and Apple Silicon
LoongArch - Loongson CPU architecture used in Chinese processors
M68K - Motorola 68000 series (classic Macs, Amigas, etc.)
MIPS - MIPS processors used in routers and embedded systems
Nios II - Altera/Intel soft-core FPGA processor
OpenRISC - Open-source RISC CPU architecture
PA-RISC - HP Precision Architecture RISC
PowerPC - IBM POWER and PowerPC processors
RISC-V - Open-standard RISC instruction set architecture
S/390 (IBM Z) - IBM mainframe architecture
SuperH - Renesas SuperH embedded processor
SPARC - Sun/Oracle SPARC processors
x86 - Intel and AMD 32/64-bit processors
Xtensa - Cadence configurable processor (used in ESP32)

Accelerators

Compute accelerator subsystem.

Compute Accelerators Introduction - Framework for AI/ML and other compute accelerator devices
AMD XDNA - AMD AI Engine / Neural Processing Unit
Qualcomm Cloud AI (QAIC) - Qualcomm Cloud AI 100 inference accelerator
Rocket - Open-source DRM accelerator driver

Framebuffer

Legacy framebuffer console and display drivers.

General

Framebuffer API - Userspace ioctl and mmap interface
Color Map for xfbdev - Color map handling in X framebuffer driver
Deferred I/O - Batching framebuffer updates for slow displays
Framebuffer Console - Text console rendered on the framebuffer
Frame Buffer Devices - Overview of the framebuffer device abstraction
Framebuffer Internals - Internal data structures and callbacks
Mode Database - Standard video mode definitions

Drivers

arkfb - ARK Logic 2000PV graphics
ATY128FB - ATI Rage 128 framebuffer
CirrusFB - Cirrus Logic GD5446/GD5480 framebuffer
EFI Framebuffer - UEFI GOP framebuffer
EP93xx FB - Cirrus EP93xx SoC framebuffer
GXFB - AMD Geode GX framebuffer
Intel 810 - Intel i810/i815 framebuffer
LXFB - AMD Geode LX framebuffer
MatroxFB - Matrox Millennium/Mystique framebuffer
MetronomeFB - Metronome e-ink display controller
PVR2FB - PowerVR2 framebuffer (Sega Dreamcast)
PXA FB - Intel PXA LCD controller
S3FB - S3 Savage framebuffer
SA1100 FB - Intel StrongARM SA1100 LCD controller
SH7760 FB - Renesas SH7760 LCD controller
SiS FB - SiS 300/540/630/730 framebuffer
SM501 - Silicon Motion SM501 framebuffer
SM712FB - Silicon Motion SM712 framebuffer
SST FB - 3dfx Voodoo1/Voodoo2 framebuffer
TGA FB - DEC TGA framebuffer (Alpha)
TridentFB - Trident graphics framebuffer
DisplayLink USB FB - DisplayLink USB-attached displays
UVESA FB - Userspace VESA framebuffer
VESA FB - VESA BIOS Extensions framebuffer
VIA FB - VIA Unichrome framebuffer
VT8623FB - VIA VT8623 framebuffer

InfiniBand

InfiniBand and RDMA subsystem documentation.

InfiniBand Core Locking - Locking rules in the RDMA core
IP over InfiniBand (IPoIB) - Running TCP/IP over InfiniBand fabric
OPA VNIC - Omni-Path virtual NIC support
InfiniBand Sysfs Interface - InfiniBand device and port attributes in sysfs
Tag Matching - Hardware-offloaded MPI tag matching
User Capabilities - Fine-grained RDMA permissions for unprivileged users
Userspace MAD Access - Sending and receiving management datagrams from userspace
User Verbs - Userspace RDMA verbs interface (uverbs)

Livepatch

Applying kernel fixes without rebooting.

Livepatch Overview - How live kernel patching works
Livepatch Callbacks - Pre/post patch and unpatch hooks
Cumulative Patches - Replacing livepatches atomically
Livepatch Module ELF Format - ELF section requirements for livepatch modules
Shadow Variables - Attaching new data to existing kernel objects
System State Changes - Tracking system state across livepatch transitions
Reliable Stacktrace - Architecture requirements for safe function replacement
Livepatch API - Kernel API for creating and managing live patches

Fault Injection

Testing error paths by injecting failures.

Fault Injection Framework - Forcing memory allocation, disk I/O, and other failures
Notifier Error Injection - Injecting errors into notifier chains
NVMe Fault Injection - Simulating NVMe command failures
Provoke Crashes - Intentionally triggering panics and BUGs for testing

Development Tools

Testing, static analysis, sanitizers, and debugging tools for kernel developers.

Kernel Testing Overview - Overview of testing frameworks available for the kernel
checkpatch.pl - Script that checks patches for coding style violations
clang-format - Automatic code formatting for kernel style
Coccinelle - Semantic patching for large-scale code transformations
Context Analysis - Detecting incorrect sleeping-in-atomic-context bugs
Sparse - Static analysis tool for finding type errors and lock issues
kcov: Code Coverage - Per-task code coverage for fuzzing (used by syzkaller)
gcov: Code Coverage with GCC - GCC-based whole-kernel code coverage
KASAN: Kernel Address Sanitizer - Finds use-after-free, out-of-bounds, and other memory bugs
KMSAN: Kernel Memory Sanitizer - Detects uses of uninitialized memory
UBSAN: Undefined Behavior Sanitizer - Catches undefined behavior like signed overflow
kmemleak: Memory Leak Detector - Finds unreferenced kernel memory allocations
KCSAN: Concurrency Sanitizer - Detects data races at runtime
Linux Kernel Memory Model (LKMM) - Formal memory model for reasoning about concurrent code
KFENCE: Kernel Electric-Fence - Low-overhead sampling-based memory error detector
kselftest: Kernel Selftests - User-space test suite for kernel features
KUnit: Kernel Unit Testing - In-kernel unit test framework
KTAP: Kernel Test Anything Protocol - Standardized test output format for kernel tests
UAPI Header Checker - Verifying userspace API header compatibility
GPIO Sloppy Logic Analyzer - Using GPIOs as a poor man's logic analyzer
AutoFDO - Profile-guided optimization using perf data
Propeller - Post-link optimization for binary layout
Container - Development container setup for kernel builds

Kernel Build System (Kbuild)

Kconfig, Makefiles, modules, and the build process.

Kconfig Language - Syntax for writing Kconfig configuration files
Kconfig Macro Language - Macro expansion in Kconfig files
Kbuild - How the kernel build system works internally
Kconfig Make Config - Using make menuconfig, oldconfig, and friends
Linux Kernel Makefiles - Writing Makefiles for kernel objects and modules
Building External Modules - Compiling out-of-tree kernel modules
Exporting Kernel Headers - Installing sanitized headers for userspace
Kbuild Known Issues - Known problems and workarounds
Reproducible Builds - Building identical kernel binaries from the same source
GCC Plugins - Compiler plugins for additional kernel hardening and analysis
Building with Clang/LLVM - Using Clang instead of GCC to build the kernel
gendwarfksyms - Generating symbol versions from DWARF debug info
Bash Completion - Tab completion for make targets and config options

Rust

Rust programming language support in the Linux kernel.

Quick Start - Setting up your environment to build Rust kernel code
General Information - Status and scope of Rust in the kernel
Coding Guidelines - Rust coding conventions specific to the kernel
Architecture Support - Which architectures support Rust code
Testing - Testing Rust kernel code with KUnit and doctests

Documentation Guide

How to write and build kernel documentation.

Using Sphinx for Kernel Documentation - Building the docs with Sphinx and reStructuredText
Writing kernel-doc Comments - Documenting functions and types in source code
Including UAPI Header Files - Auto-generating docs from userspace header files
How to Help Improve Kernel Documentation - Ways to contribute to the documentation
Documentation Subsystem Maintainer Profile - How the documentation subsystem is maintained
Checking Translation Updates - Keeping translated documentation in sync

Kernel Hacking

Practical guides for kernel hackers.

Unreliable Guide to Hacking the Linux Kernel - Useful but self-deprecating guide to kernel internals
Unreliable Guide to Locking - When and how to use each type of lock
False Sharing - Avoiding performance loss from cache line contention

Userspace API

Kernel interfaces exposed to userspace: syscalls, ioctls, and device APIs.

System Calls

unshare() - Disassociating parts of the process execution context
futex2 - Next-generation futex interface with variable sizes
eBPF Userspace API - The bpf() syscall and related interfaces
ioctl Definitions - Userspace ioctl numbers and their meanings
mseal(): Memory Sealing - Preventing further changes to memory mappings
Restartable Sequences (rseq) - Per-CPU atomic operations without locks from userspace

Security-Related Interfaces

no_new_privs - Preventing privilege escalation through exec
Seccomp BPF - Filtering system calls with BPF programs
Landlock - Unprivileged filesystem sandboxing
LSM Userspace API - Security module interfaces for applications
memfd_create(): No-Execute Sealing - Creating memory-backed fds that can't be executed
Speculation Control - Controlling speculative execution mitigations
TEE Userspace API - Interacting with Trusted Execution Environments
check_exec - Checking if a file can be executed

Devices and I/O

OpenCAPI Accelerator (OCXL) - Userspace interface for OpenCAPI accelerators
DMA-BUF Heaps - Allocating DMA-capable buffers from userspace
DMA-BUF Allocation and Exchange - Sharing GPU/camera/display buffers between devices
Firmware Control (fwctl) - Userspace interface for device firmware management
GPIO Userspace API - Controlling GPIO pins from userspace (libgpiod)
IOMMU FD - Userspace-controlled IOMMU for VFIO and device passthrough
Media Userspace API - V4L2, DVB, and media controller userspace interfaces
Dell DCDBAS - Dell systems management base driver
VDUSE: vDPA Device in Userspace - Implementing vDPA devices in userspace processes
ISA PnP - ISA Plug and Play configuration from userspace

Everything Else

ELF - Linux-specific ELF extensions and features
Live Update - Userspace interface for kernel live update
Netlink - Netlink socket family for kernel-userspace communication
Platform Profile via Sysfs - Switching between performance/balanced/low-power modes
Perf Ring Buffer - Shared ring buffer for perf event data
NT Synchronization Primitives - Windows-compatible sync primitives for Wine

Admin Guide

System administration: booting, troubleshooting, filesystems, and devices.

General

Linux Kernel README - What Linux is, how to build it, and where to report bugs
Linux Allocated Devices - Major and minor device number allocations
Feature Status - Maturity status of kernel features

Proc and Sysfs

Rules on How to Access sysfs - Stable rules for reading sysfs from userspace
Sysctl Documentation - All /proc/sys tunables documented
CPU Topology - Reading CPU topology from sysfs
ABI Stability - Kernel ABI stability guarantees for userspace

Security

Hardware Vulnerabilities - Mitigations for Spectre, Meltdown, and other CPU bugs
Linux Security Modules - Configuring SELinux, AppArmor, and other LSMs
Perf Events Security - Controlling who can use perf_event_open

Booting

Boot Configuration - Extending kernel command line with structured boot config
Kernel Parameters - Complete list of kernel command-line parameters
EFI Stub - Booting the kernel directly from UEFI
Using initrd - Initial ramdisk setup for early boot

Troubleshooting and Debugging

Reporting Issues - How to report kernel bugs effectively
Reporting Regressions - Reporting things that used to work but now don't
Quickly Build a Trimmed Linux - Fast way to build a minimal kernel for testing
Verify Bugs and Bisect Regressions - Using git bisect to find the commit that broke things
Bug Hunting - Techniques for tracking down kernel bugs
Bug Bisecting - Step-by-step guide to git bisect for the kernel
Tainted Kernels - What taint flags mean and why they matter for bug reports
Ramoops (Persistent RAM Logging) - Preserving kernel logs across reboots via RAM
Dynamic Debug HOWTO - Enabling debug messages at runtime without rebuilding
Kernel Init - What happens from kernel start to init execution
Kdump: Kernel Crash Dumps - Capturing memory dumps on kernel panic
Perf Tool - Performance monitoring and profiling with perf
Pstore Block - Storing kernel logs on block devices across crashes
Clearing WARN_ONCE - Resetting one-shot kernel warnings
Per-CPU Kernel Threads - Managing kernel threads bound to specific CPUs
Lockup Watchdogs - Soft and hard lockup detection
Reliability, Availability, Serviceability (RAS) - Hardware error logging and handling
SysRq - Magic SysRq key for emergency system control

Core Kernel Subsystems

Control Group v2 - Unified cgroup hierarchy for resource management
Control Group v1 - Legacy per-controller cgroup hierarchies
CPU Load - Understanding and interpreting CPU load averages
Memory Management Admin Guide - Tuning VM, swap, hugepages, and NUMA from userspace
Kernel Module Signing - Signing modules and enforcing signature verification
Namespaces - Process isolation with PID, net, mount, and other namespaces
NUMA Statistics - Reading NUMA memory allocation statistics
Power Management Admin Guide - Configuring sleep states and CPU governors
Syscall User Dispatch - Redirecting syscalls to userspace (for Wine, etc.)

Non-Native Binary Formats

binfmt_misc - Running arbitrary binary formats via interpreter registration
Java Binary Support - Running Java .class files directly
Mono Binary Support - Running .NET/Mono binaries directly

Block Layer and Filesystems

bcache - SSD caching for slow spinning disks
binderfs - Filesystem for Android Binder IPC devices
Block Devices - Block device configuration and management
CIFS/SMB - Mounting Windows/Samba shares
Device Mapper - LVM, dm-crypt, dm-raid, and other device mapper targets
ext4 Admin Guide - ext4 mount options and admin tasks
Filesystem Monitoring - fanotify and other filesystem monitoring tools
NFS Admin Guide - NFS client and server configuration
I/O Statistics - Understanding /proc/diskstats and I/O counters
JFS - IBM Journaled File System administration
MD (RAID) - Software RAID with mdadm
UFS - Unix File System (BSD) read support
XFS Admin Guide - XFS filesystem administration and tuning

Device-Specific Guides

ACPI Admin Guide - ACPI debugging and configuration
ATA over Ethernet (AoE) - Block storage over Ethernet
Auxiliary Display - Character LCDs and small auxiliary displays
Braille Console - Kernel console on Braille devices
Marvell Bluetooth - Marvell Bluetooth driver configuration
Dell BIOS Update - Updating Dell BIOS from Linux
EDID - Overriding display EDID data
GPIO Admin Guide - Userspace GPIO access and debugging
Hardware Random Number Generator - Using hardware RNG devices
Laptop Specific - Laptop quirks, hotkeys, and platform drivers
LCD Panel CGRAM - Programming custom characters on character LCDs
Media Admin Guide - Configuring V4L2, DVB, and IR devices
NVMe Multipath - Multipath I/O for NVMe devices
Parallel Port - Parallel port configuration and sharing
Plug and Play - ISA Plug and Play configuration
RapidIO - RapidIO fabric configuration
Real-Time Clock (RTC) - Hardware clock and wake alarm configuration
Serial Console - Using a serial port as the system console
SVGA - VESA SVGA text mode selection at boot
Thermal Admin Guide - Thermal zone configuration and cooling policies
Thunderbolt - Thunderbolt/USB4 device authorization and networking
VGA Softcursor - Software cursor on VGA text console
Video Output - Video output switching (laptop display/projector)

Workload Analysis

Workload Tracing - Tracing system activity for performance analysis

Everything Else

LDM: Windows Dynamic Disks - Reading Windows dynamic disk partitions
Unicode Support - Unicode console and filesystem support

Misc Devices

Miscellaneous device drivers.

AD525x Digital Potentiometers - Analog Devices I2C/SPI digital potentiometers
AMD SBI - AMD sideband interface
APDS990X - Avago ambient light and proximity sensor
BH1770GLC - ROHM ambient light and proximity sensor
C2 Port - Silicon Labs C2 flash programming interface
DesignWare xData PCIe - Synopsys PCIe traffic generator for testing
IBM VMC - IBM virtual management channel
ICS932S401 - IDT ICS932S401 clock generator
ISL29003 - Intersil ambient light sensor
LIS3LV02D - ST accelerometer (used for laptop hard drive protection)
MAX6875 - Maxim EEPROM-programmable I/O expander
Marvell CN10K DPI - Marvell DMA performance interface
Oxford Semi Tornado - Oxford Semiconductor PCIe serial/parallel adapter
PCI Endpoint Test - Testing PCI endpoint subsystem functionality
SPEAr PCIe Gadget - ST SPEAr SoC PCIe endpoint mode
TPS6594 PFSM - TI TPS6594 PMIC pre-configurable FSM
Unified Accelerator Framework (UACCE) - Userspace access to hardware accelerators
Xilinx SDFEC - Xilinx Soft-Decision FEC engine

PCMCIA

PCMCIA/CardBus driver interface.

PCMCIA Driver Guide - Writing PCMCIA/CardBus device drivers
PCMCIA Device Table - Matching PCMCIA devices to drivers
PCMCIA Locking - Locking rules for the PCMCIA subsystem
PCMCIA Driver Changes - API changes affecting PCMCIA drivers

1-Wire

1-Wire bus protocol, masters, and slave devices.

1-Wire Generic - Overview of the 1-Wire bus subsystem
1-Wire Netlink Interface - Controlling 1-Wire from userspace via netlink
1-Wire Masters - 1-Wire bus master controller drivers
1-Wire Slaves - 1-Wire slave device drivers (temperature, EEPROM, etc.)

MHI

Modem Host Interface for Qualcomm modems.

MHI Overview - Communication protocol between host and Qualcomm modem
MHI Topology - MHI bus topology and channel layout

WMI

Windows Management Instrumentation in Linux.

WMI ACPI Interface - How WMI maps to ACPI methods
WMI Driver Development Guide - Writing drivers for WMI-based platform features
WMI Devices - Known WMI device documentation

FPGA

FPGA subsystem.

FPGA Device Feature List (DFL) Framework - Enumerating and managing FPGA accelerator functions

Target

SCSI target subsystem (LIO).

TCM Userspace Design - Implementing SCSI targets in userspace
TCM Module Builder - Generating fabric module scaffolding
Target Scripts - Helper scripts for LIO target configuration

Staging

Unsorted and legacy documentation.

CRC32 - CRC32 computation algorithms and performance
LZO Compression - LZO data compression used in zram and btrfs
Linux Magic Numbers - Magic number registry for kernel data structures
Remote Processor Framework - Loading firmware on and controlling remote processors
Remote Processor Messaging (rpmsg) - Message passing between main CPU and remote processors
Speculation - Speculative execution and how the kernel handles it
Static Keys - Self-modifying code for near-zero-cost runtime branches
XZ Compression - XZ/LZMA2 compression for kernel and initramfs

Translations

Kernel documentation translated into other languages.

Chinese (Simplified) - Simplified Chinese translation of key documents
Chinese (Traditional) - Traditional Chinese translation
Italian - Italian translation
Korean - Korean translation
Japanese - Japanese translation
Spanish - Spanish translation

Name		Name	Last commit message	Last commit date
Latest commit History 1 Commit
src		src
LICENSE		LICENSE
README.md		README.md
go.mod		go.mod

Folders and files

Latest commit

History

Repository files navigation

Linux Kernel Documentation Index

Contents

Start Here

Development Process

Introduction to Kernel Development

Tools and Technical Guides

Policy Guides and Developer Statements

Dealing with Bugs

Maintainer Information

Other Material

Maintainer Handbook

Core API

Core Utilities

Data Structures and Low-Level Utilities

Low Level Entry and Exit

Concurrency Primitives

Low-Level Hardware Management

Memory Management

Interfaces for Kernel Debugging

Everything Else

Driver API

General Information for Driver Authors

Useful Support Libraries

Bus-Level Documentation

Subsystem-Specific APIs

Memory Management

Concepts

Advanced Topics

Locking

Scheduler

Timers

Power Management

Core Power Management

Powercap

Regulator

Networking

Core Networking

Configuration and Management

Protocols

Offloading and Optimization

Filtering and Traffic Control

XDP and AF_XDP

Timestamping and PTP

Wireless and Mobile

XFRM and IPsec

Device Driver Infrastructure

Miscellaneous

Filesystems

Core VFS Documentation

Filesystem Support Layers

Filesystems

Block Layer

Security

Crypto

BPF

Tracing

Introduction to Tracing

Core Tracing Frameworks

Event Tracing and Analysis

Hardware and Performance Tracing

User-Space Tracing

GPU/DRM

Sound

Input

USB

PCI

I2C

Introduction

Writing Device Drivers

Debugging and Slave I2C

SPI

HID

IIO

General

Device Drivers

Hardware Monitoring (hwmon)

Packages