Multitasking functionality

multitasking
execution
threads or tasks
synchronization
Scheduler
interrupts core
CPU specific

Linux kernel is a preemptive multitasking operating system. As a multitasking OS, it allows multiple processes to share processors (CPUs) and other system resources. Each CPU executes a single task at a time. However, multitasking allows each processor to switch between tasks that are being executed without having to wait for each task to finish. For that, the kernel can, at any time, temporarily interrupt a task being carried out by the processor, and replace it by another task that can be new or a previously suspended one. The operation involving the swapping of the running task is called context switch.

Execution

⚲ API ↪ ⚙️ implementations

man 2 execve ↪ do_execveat_common _id runs an executable file in the context of current process, replacing the previous executable. This system call is used by family of functions of libc man 3 exec. The ELF binary format is loaded by fs/binfmt_elf.c _src.

man 2 clone. Clone creates a child process that may share parts of its execution context with the parent. It is often used to implement threads (though programmers will typically use a higher-level interface such as man 7 pthreads, implemented on top of clone).

man 2 wait ↪ kernel_waitid _id suspends the execution of the calling process until one of its child processes terminates.

Syscall man 2 getpid ↪ task_tgid_vnr _id returns PID of the current process which internally is called TGID - thread group id. A process can contain many threads. man 2 gettid ↪ task_pid_vnr _id returns thread id. Which internally is historically called PID. ⚠️ Warning: confusion. User space PID ≠ kernel space PID. man 1 ps -AF lists current processes and thread as LWP. For a single thread process all these IDs are equal.

High-resolution delays:

man 2 nanosleep ↪ sys_nanosleep _id

hrtimer_nanosleep _id

man 2 clock_nanosleep ↪ sys_clock_nanosleep _id

Wait for a signal:

man 2 pause ↪ sys_pause _id

man 2 sigsuspend ↪ sys_sigsuspend _id

🔨 stress-ng --context, --switch

See Processes for process creation and termination.

Inter-process communication

Inter-process communication (IPC) refers specifically to the mechanisms an operating system provides to allow processes it manages to share data. Methods for achieving IPC are divided into categories which vary based on software requirements, such as performance and modularity requirements, and system circumstances. Linux inherited from Unix the following IPC mechanisms:

Signals (⚲ API ↪ ⚙️ implementations):

man 2 kill sends signal to a process

man 2 tgkill ↪ do_tkill _id sends a signal to a thread

man 2 process_vm_readv ↪ process_vm_rw _id - zero-copy data transfer between process address spaces

man 2 sigaction ↪ do_sigaction _id – examine and change a signal action

man 2 sigprocmask – examine and change blocked signals

man 2 sigpending ↪ do_sigpending _id – examine pending signals

man 2 sigsuspend – wait for a signal

man 2 sigaltstack – set or get signal stack context

man 2 sigtimedwait ↪ do_sigtimedwait _id – synchronously wait for queued signals

man 7 signal – overview of signals

linux/sched/signal.h _inc – signal-related task accessors

kernel/signal.c _src – signal delivery and handling

🔨 stress-ng --sigq

Anonymous pipes and named pipes (FIFOs) man 2 mknod ↪ do_mknodat _id S_IFIFO _id

Express Data Path PF_XDP _id

Unix domain socket PF_UNIX _id

Memory-mapped files man 2 mmap ⤑ ksys_mmap_pgoff _id

man 2 eventfd ↪ do_eventfd _id – event notification via file descriptor

man 2 signalfd ↪ do_signalfd4 _id – receive signals via file descriptor

man 2 timerfd_create – timer notification via file descriptor

Sys V IPC:

Message queues: man 2 msgget, man 2 msgsnd, man 2 msgrcv ↪ ipc/msg.c _src

Semaphores

Shared memory: man 2 shmget, man 2 shmctl, man 2 shmat, man 2 shmdt ↪ ipc/shm.c _src

POSIX message queues:

man 7 mq_overview, man 3 mq_open, man 3 mq_send, man 3 mq_receive ↪ ipc/mqueue.c _src 🔨 --mq

📖 References

Inter-process communication

man 7 sysvipc

Threads or tasks

In Linux kernel "thread" and "task" are almost synonyms.

⚲ API

linux/sched.h _inc - the main scheduler API

task_struct _id

arch/x86/include/asm/current.h _src – x86 current task pointer

current _id and get_current _id () return current task_struct _id

uapi/linux/taskstats.h _inc per-task statistics

linux/thread_info.h _inc

current_thread_info _id() returns thread_info _id

linux/sched/task.h _inc - interface between the scheduler and various task lifetime (fork()/exit()) functionality

linux/kthread.h _inc - simple interface for creating and stopping kernel threads without mess.

kthread_run _id creates and wakes a thread

kthread_create _id

⚙️ Internals

kthread_run _id ↯ hierarchy:

kernel/kthread.c _src – kernel thread creation and management

kthreadd _id – parent kernel thread and the creator of all other kernel threads.

Dequeues kthread_create_info _id from kthread_create_list _id.

create_kthread _id

kernel_thread _id

kthread _id – invokes threadfn _id

__kthread_create_on_node _id – enqueues kthread_create_info _id into kthread_create_list _id

kernel/fork.c _src – process creation and cloning

kernel_thread _id

kernel_clone _id

🔨 stress-ng --clone, --fork, --pthread

Scheduler

The scheduler is the part of the operating system that decides which process runs at a certain point in time. It usually has the ability to pause a running process, move it to the back of the running queue and start a new process.

Active processes are placed in an array called a run queue, or runqueue - rq _id. The run queue may contain priority values for each process, which will be used by the scheduler to determine which process to run next. To ensure each program has a fair share of resources, each one is run for some time period (quantum) before it is paused and placed back into the run queue. When a program is stopped to let another run, the program with the highest priority in the run queue is then allowed to execute. Processes are also removed from the run queue when they ask to sleep, are waiting on a resource to become available, or have been terminated.

Since version 6.6 the Linux kernel uses the Earliest eligible virtual deadline first scheduling (EEVDF) algorithm, which replaced the Completely Fair Scheduler (CFS). While much of the CFS infrastructure remains: sched_entity _id, cfs_rq _id, the red-black tree, load balancing, and kernel/sched/fair.c _src — the task selection logic is fundamentally different. EEVDF is based on a classic scheduling algorithm originally designed for packet networks. The scheduler has a scheduling complexity of O(log N), where N is the number of tasks in the runqueue. Both picking and reinserting a task require O(log N) operations, because the run queue is implemented as a red–black tree.

The runqueue (cfs_rq _id) is implemented as a red-black tree representing a "timeline" of future task execution. The scheduler uses nanosecond granularity accounting and requires no heuristics or interactivity estimators.

EEVDF improves sleeper fairness over CFS by tracking lag (vlag _id) — the difference between the service a task was entitled to and the service it actually received. When a sleeping task wakes up, its lag determines eligibility, ensuring interactive tasks get prompt service without starving long-running tasks.

The data structure used for the scheduling algorithm is a red-black tree in which the nodes are sched_entity _id structures, embedded in task_struct _id.

With EEVDF, each task has a time slice (sysctl_sched_base_slice _id, default 0.7ms) that determines its request length. EEVDF computes a virtual deadline for each task: vd_i = ve_i + r_i/w_i, where ve_i is the eligible time, r_i is the request size, and w_i is the weight (determined by nice value). The scheduler picks the eligible task with the earliest virtual deadline via pick_eevdf _id.

The Linux kernel contains different scheduler classes (or policies). The EEVDF scheduler handles SCHED_NORMAL _id (aka SCHED_OTHER). The kernel also contains two additional classes SCHED_BATCH _id and SCHED_IDLE _id, and another two real-time scheduling classes named SCHED_FIFO _id (realtime first-in-first-out) and SCHED_RR _id (realtime round-robin), with a third realtime scheduling policy known as SCHED_DEADLINE _id that implements the earliest deadline first algorithm (EDF) added later. Any realtime scheduler class takes precedence over any of the "normal" —i.e. non realtime— classes. The scheduler class is selected and configured through the man 2 sched_setscheduler ↪ do_sched_setscheduler _id system call.

Properly balancing latency, throughput, and fairness in schedulers is an open problem.

⚲ API

man 1 renice – priority of running processes

man 1 nice – run a program with modified scheduling priority

man 1 chrt – manipulate the real-time attributes of a process

man 2 sched_getattr ↪ sys_sched_getattr _id – get scheduling policy and attributes

linux/sched.h _inc – the main scheduler API

schedule _id

man 2 getpriority, man 2 setpriority

man 2 sched_setscheduler, man 2 sched_getscheduler

/sys/kernel/debug/sched/ – scheduler debugfs tuning directory

features – toggle scheduler feature flags

base_slice_ns – EEVDF base time slice (default 700000)

migration_cost_ns – cost threshold for task migration between CPUs

nr_migrate – max tasks to migrate per balancing pass

debug – dump detailed scheduler state

numa_balancing/ – NUMA balancing scan parameters

⚙️ Internals

sched_init _id is called from start_kernel _id

__schedule _id is the main scheduler function.

runqueues _id, this_rq _id

kernel/sched _src – scheduler subsystem

kernel/sched/core.c _src – core scheduling logic

kernel/sched/fair.c _src implements SCHED_NORMAL _id, SCHED_BATCH _id, SCHED_IDLE _id

pick_eevdf _id – core of EEVDF

sched_setscheduler _id, sched_getscheduler _id

task_struct _id::rt_priority _id and other members with less unique identifiers

🔨 stress-ng --schedpolicy

🛠️ Utilities

man 1 pidstat

man 1 pcp-pidstat

man 1 perf-sched

Understanding Scheduling Behavior with SchedViz

📖 References

man 7 sched

Scheduling _doc

EEVDF Scheduler _doc

An EEVDF CPU scheduler for Linux LWN

Delaying and scheduling routines _doc

CFS

Completely Fair Scheduler _doc

CFS Bandwidth Control _doc

CPU cgroup controller

CPU cgroup interface files _doc

Completely fair scheduler LWN

Tuning the task scheduler

stop using CPU limits on Kubernetes

Deadline Task Scheduler _doc

sched _ltp

sched_setparam _ltp

sched_getscheduler _ltp

sched_setscheduler _ltp

📚 Further reading about the scheduler

Tuning scheduling policy, RHEL

Scheduler tracing

bcc/ebpf CPU and scheduler tools

Preemption

Preemption refers to the ability of the system to interrupt a running task to switch to another task. This is essential for ensuring that high-priority tasks receive the necessary CPU time and for improving the system's responsiveness. In Linux, preemption models define how and when the kernel can preempt tasks. Different models offer varying trade-offs between system responsiveness and throughput.

📖 References

Proper Locking Under a Preemptible Kernel _doc

preempt_enable _id – decrement the preempt counter

preempt_disable _id – increment the preempt counter

preempt_enable_no_resched _id – decrement, but do not immediately preempt

preempt_check_resched _id – if needed, reschedule

preempt_count _id – return the preempt counter

kernel/Kconfig.preempt _src – preemption model configuration

CONFIG_PREEMPT_NONE _id – no forced preemption for servers

CONFIG_PREEMPT_VOLUNTARY _id – voluntary preemption for desktops

CONFIG_PREEMPT _id – preemptible except for critical sections for low-latency desktops

CONFIG_PREEMPT_RT _id – real-time preemption for highly responsive applications

CONFIG_PREEMPT_DYNAMIC _id – allows runtime switching of preemption model

/sys/kernel/debug/sched/preempt – shows and controls the active preemption model

sched_ext

Since version 6.12 the kernel supports SCHED_EXT _id — an extensible scheduler class whose behavior is defined by a set of eBPF programs. Any scheduling algorithm can be implemented on top of sched_ext, loaded and unloaded dynamically at runtime. The system integrity is maintained no matter what the BPF scheduler does: the default scheduling behavior is restored on error or when a runnable task stalls.

⚙️ Internals

CONFIG_SCHED_CLASS_EXT _id

kernel/sched/ext.c _src – extensible BPF scheduler class

sched_ext_ops _id – BPF scheduler operations

sched_ext_entity _id – per-task sched_ext data, embedded in task_struct _id

👁 Examples

tools/sched_ext _src – in-tree example BPF schedulers

📖 References

Extensible Scheduler Class _doc

sched-ext/scx – production BPF schedulers

Scheduler BPF LWN

Energy Aware Scheduling

🚀 advanced topic

Since version 5.0, Energy Aware Scheduling (EAS) gives the scheduler the ability to predict the impact of its decisions on the energy consumed by CPUs. EAS relies on an Energy Model (EM) to select an energy efficient CPU for each task, with minimal impact on throughput. EAS operates only on heterogeneous CPU topologies (such as ARM big.LITTLE) where the potential for energy savings is highest.

⚲ API

/proc/sys/kernel/sched_energy_aware – enable or disable EAS

linux/energy_model.h _inc

em_perf_domain _id – performance domain descriptor

em_cpu_get _id – get the EM for a given CPU

⚙️ Internals

CONFIG_ENERGY_MODEL _id

find_energy_efficient_cpu _id – find most energy-efficient target CPU for a waking task

kernel/power/energy_model.c _src – CPU energy model framework

📖 References

Energy Aware Scheduling _doc

Energy Model of devices _doc

Wait queues

A wait queue in the kernel is a data structure that allows one or more processes to wait (sleep) until something of interest happens. They are used throughout the kernel to wait for available memory, I/O completion, message arrival, and many other things. In the early days of Linux, a wait queue was a simple list of waiting processes, but various scalability problems (including the thundering herd problem) have led to the addition of a fair amount of complexity since then.

⚲ API

linux/wait.h _inc

wait_queue_head _id consists of double linked list of wait_queue_entry _id and a spinlock.

Waiting for simple events:

Use one of two methods for wait_queue_head _id initialization:

init_waitqueue_head _id initializes wait_queue_head _id in function context

DECLARE_WAIT_QUEUE_HEAD _id - actually defines wait_queue_head _id in global context

Wait alternatives:

wait_event_interruptible _id - preferable wait

wait_event_interruptible_timeout _id

wait_event _id - uninterruptible wait. Can cause deadlock ⚠

wake_up _id etc

👁 For example usage see references to unique suspend_queue _id.

Explicit use of add_wait_queue instead of simple wait_event for complex cases:

DECLARE_WAITQUEUE _id actually defines wait_queue_entry with default_wake_function _id

add_wait_queue _id inserts process in the first position of a wait queue

remove_wait_queue _id

⚙️ Internals

___wait_event _id

__add_wait_queue _id

__wake_up_common _id, try_to_wake_up _id

kernel/sched/wait.c _src – wait queue implementation

Simple wait queues – simplified version with raw spinlock, suitable for RT and restricted contexts:

linux/swait.h _inc

swait_queue_head _id, swait_queue _id

kernel/sched/swait.c _src – simple wait queue implementation

📖 References

Wait queues and Wake events _doc

Real-time

RT preemption

The Linux Foundation's Real-Time Linux (RTL) collaborative project is focused on improving the real-time capabilities of Linux and advancing the adoption of real-time Linux in various industries, including aerospace, automotive, robotics, and telecommunications.

Parameter CONFIG_PREEMPT_RT _id enables real-time preemption.

RT scheduling policies

Scheduling policies for RT:

SCHED_FIFO _id, SCHED_RR _id

implemented in kernel/sched/rt.c _src

SCHED_DEADLINE

implemented in kernel/sched/deadline.c _src

API:

man 1 chrt – manipulate the real-time attributes of a process

man 2 sched_rr_get_interval – get the SCHED_RR interval for the named process

man 2 sched_setscheduler, sched_getscheduler – set and get scheduling policy/parameters

man 2 sched_get_priority_min, sched_get_priority_max – get static priority range

RT scheduler tunables:

/proc/sys/kernel/sched_rt_period_us – period over which RT task bandwidth is measured (default 1000000 µs = 1 s)

/proc/sys/kernel/sched_rt_runtime_us – maximum time RT tasks may consume per period (default 950000 µs); set to -1 to disable the RT bandwidth limit

/sys/kernel/realtime – indicates the running kernel has PREEMPT_RT enabled (present only on RT kernels)

/sys/devices/system/clocksource/clocksource0/current_clocksource – active clocksource, critical for RT timing accuracy

🛠️ Utilities

tuna – view and change thread attributes (affinity, scheduling policy, priority)

RHEL tuna guide

sos kernelrt plugin – diagnostics collection for RT kernel

Priority inversion occurs when a high-priority task blocks on a resource held by a low-priority task, while a medium-priority task preempts the low-priority one indefinitely. The kernel mitigates this with rt_mutex _id which implements Priority inheritance – temporarily boosting the lock holder's priority to that of the highest-priority waiter.

RT synchronization

⚲ APIs

migrate_disable _id + spin_lock _id

local_lock _id calls migrate_disable(); rt_spin_lock _id(this_cpu_ptr _id((__lock)));

📖 References

Usage of migrate_disable

PREEMPT_RT caveats: spinlock_t, rwlock_t, migrate_disable and local_lock _doc

⚙️ Internals

Spinlock

linux/spinlock_rt.h _inc used via linux/spinlock_types.h _inc

spinlock_t _id

rt_mutex_base _id

rt_spin_lock _id ...

__rt_spin_lock _id ...

rtlock_lock _id ...

kernel/locking/spinlock_rt.c _src – RT-aware spinlock implementation

RT Mutex

linux/rtmutex.h _inc used via linux/mutex_types.h _inc

rt_mutex_base _id

rt_mutex _id

rt_mutex_lock _id ...

kernel/locking/rtmutex_api.c _src – RT mutex kernel API

kernel/locking/rtmutex_common.h _src – RT mutex internal definitions

kernel/locking/rtmutex.c _src – RT mutex core with priority inheritance

rwbase_rt

linux/rwbase_rt.h _inc used via linux/rwlock_types.h _inc

rwlock_t _id

rwbase_rt _id – used to implement real-time read/write locks

rt_read_trylock _id ...

kernel/locking/rwbase_rt.c _src – RT rw_semaphore/rwlock base

kernel/locking/spinlock_rt.c _src – RT-aware spinlock implementation

Testing RT capabilities

The testing process for Real-Time Linux typically involves several key aspects. First and foremost, it is crucial to verify the accuracy and stability of the system's timekeeping mechanisms. Precise time management is fundamental to real-time applications, and any inaccuracies can lead to timing errors and compromise the system's real-time capabilities.

Another essential aspect of testing is evaluating the system's scheduling algorithms. Real-Time Linux employs advanced scheduling policies to prioritize critical tasks and ensure their timely execution. Testing the scheduler involves assessing its ability to allocate resources efficiently, handle task prioritization correctly, and prevent resource contention or priority inversion scenarios.

Furthermore, latency measurement is a critical part of Real-Time Linux testing. Latency refers to the time delay between the occurrence of an event and the system's response to it. In real-time applications, minimizing latency is crucial to achieving timely and predictable behavior. Testing latency involves measuring the time it takes for the system to respond to various stimuli and identifying any sources of delay or unpredictability.

Additionally, stress testing plays a significant role in assessing the system's robustness under heavy workloads. It involves subjecting the Real-Time Linux system to high levels of concurrent activities, intense computational loads, and input/output operations to evaluate its performance, responsiveness, and stability. Stress testing helps identify potential bottlenecks, resource limitations, or issues that might degrade the real-time behavior of the system.

RTLA

RTLA – The realtime Linux analysis tool:

rtla timerlat _doc – CLI for the kernel's timerlat tracer _doc

rtla osnoise _doc – CLI for the kernel's osnoise tracer _doc.

Kernel function run_osnoise _id measures time with function trace_clock_local _id in loop.

rtla hwnoise _doc – CLI for the osnoise tracer _doc with interrupts disabled

Implementation: tools/tracing/rtla _src and kernel/trace/trace_osnoise.c _src

Linux scheduling latency debug and analysis

RT-Tests

RT-Tests, source, @gitlab

cyclictest

some RT-Tests man pages:

cyclictest – measures man 2 clock_nanosleep or man 2 nanosleep delay

hwlatdetect – CLI for /sys/kernel/tracing/hwlat_detector _doc / kernel/trace/trace_hwlat.c _src. Kernel function kthread_fn _id measures time delays with function trace_clock_local _id in loop.

oslat – measures delay with RDTSC in busy loop

hackbench – scheduler benchmark/stress test

ftrace

Testing latencies with the ftrace - Function Tracer.

tracing_max_latency

the irqsoff _doc, preemptoff _doc, preemptirqsoff _doc tracers

tools/tracing/latency _src – latency measurement tools

CONFIG_IRQSOFF_TRACER _id – interrupts-off latency tracer

CONFIG_PREEMPT_TRACER _id – preemption-off latency tracer

CONFIG_SCHED_TRACER _id – scheduling latency tracer

Other tests

man 1 perf-intel-pt – Intel Processor Trace for low-overhead instruction-level tracing, tools/perf/Documentation/perf-intel-pt.txt _src

Using rtla with perf processor trace

RT Tracing Tools with eBPF

realtime _ltp

https://www.latencytop.org/, kernel/latencytop.c _src

rteval – RT workload and latency evaluation in a container

RT optimizations

CONFIG_PSI_DEFAULT_DISABLED _id – disable PSI _doc

Check: ls /proc/pressure/ should fail

...

📚 Further reading:

https://lore.kernel.org/linux-rt-users/

https://lore.kernel.org/linux-trace-kernel/

📖 References

Real-time preemption _doc

Documentation for /proc/sys/kernel/ _doc – sched_rt_period_us, sched_rt_runtime_us

https://realtime-linux.org/

Getting Started with PREEMPT_RT Guide

A Checklist for Real-Time Applications in Linux

the Real-Time Linux wiki

CPU partitioning and isolation

linux-stable-rt.git

linux-rt-devel.git

📚 Further reading about real-time Linux:

News from PREEMPT_RT – LPC 2025, post-mainline developments

https://deepwiki.com/torvalds/linux/2.1-process-scheduler

Introduction to Real-Time Linux: Unleashing Deterministic Computing

Power Management and Scheduling in the Linux Kernel (OSPM)

Realtime@LWN

Realtime kernel patchset, Arch Linux

https://www.kernel.org/pub/linux/kernel/projects/rt/ - RT patches for upstream kernel

High Precision Event Timer (HPET)

Demystifying the Real-Time Linux Scheduling Latency

RHEL for RT

Understanding RHEL for RT – affinity, SCHED_DEADLINE cpusets, RT socket options, timerlat, runtime monitors

Optimizing for low latency:

SCHED_DEADLINE parameters

BIOS tuning – disable power management, error correction, SMI

Runtime verification – monitors and reactors

CPU isolation – tuned profiles, isolated_cores, nohz_full

RCU callback offloading

Scheduling problems – throttling, starvation

Linux subsystems related to real-time

Linux kernel scheduling and preemption

Interrupts

Deferred works

Non-maskable interrupt handler (NMI)

System management interrupt (SMI)

man 7 sched

latency @ LKML

PREEMPT_RT @ LKML

QA about PREEMPT_RT, LPC'23, State of the onion, pdf

💾 Historical

The PREEMPT_RT patch has been fully merged into the mainline Linux kernel, starting from version 6.12.

Synchronization

Thread synchronization is defined as a mechanism which ensures that two or more concurrent processes or threads do not simultaneously execute some particular program segment known as mutual exclusion (mutex). When one thread starts executing the critical section (serialized segment of the program) the other thread should wait until the first thread finishes. If proper synchronization techniques are not applied, it may cause a race condition where, the values of variables may be unpredictable and vary depending on the timings of context switches of the processes or threads.

User space synchronization

POSIX Timers

⚲ APIs

man 2 timer_create – creates a POSIX timer

man 2 timer_settime – starts or modifies a timer

man 2 timer_gettime – retrieves the remaining time of a timer

man 2 timer_delete – deletes a POSIX timer

man 2 clock_nanosleep – suspends execution for a specified time

⚙️ Internals

linux/posix-timers.h _inc

kernel/time/itimer.c _src – interval timer (setitimer/getitimer)

kernel/time/posix-timers.c _src – POSIX clock and timer operations

kernel/time/posix-cpu-timers.c _src – per-process/thread CPU timers

posix_cpu_timer_set _id – function setting up CPU timers

Futex

A man 2 futex ↪ do_futex _id (short for "Fast User space muTex") is a kernel system call that programmers can use to implement basic locking, or as a building block for higher-level locking abstractions such as semaphores and POSIX mutexes or condition variables.

A futex consists of a kernel space wait queue that is attached to an aligned integer in user space. Multiple processes or threads operate on the integer entirely in user space (using atomic operations to avoid interfering with one another), and only resort to relatively expensive system calls to request operations on the wait queue (for example to wake up waiting processes, or to put the current process on the wait queue). A properly programmed futex-based lock will not use system calls except when the lock is contended; since most operations do not require arbitration between processes, this will not happen in most cases.

The basic operations of futexes are based on only two central operations futex_wait _id and futex_wake _id though implementation has more operations for more specialized cases.

WAIT (addr, val) checks if the value stored at the address addr is val, and if it is puts the current thread to sleep.

WAKE (addr, val) wakes up val number of threads waiting on the address addr.

⚲ API

uapi/linux/futex.h _inc

linux/futex.h _inc

⚙️ Internals: kernel/futex _src

🔨 stress-ng --futex

📖 References

Futex

man 7 futex

Futex API reference _doc

futex _ltp

File locking

⚲ API: man 2 flock

Semaphore

💾 History: Semaphore is part of System V IPC man 7 sysvipc

⚲ API

man 2 semget

man 2 semctl

man 2 semop

⚙️ Internals: ipc/sem.c _src

🔨 stress-ng --sem

Kernel space synchronization

For kernel mode synchronization Linux provides three categories of locking primitives: sleeping, per CPU local locks and spinning locks.

rust/kernel/sync.rs _src – Rust bindings for locking primitives

Read-Copy-Update

Common mechanism to solve the readers–writers problem is the read-copy-update (RCU) algorithm. Read-copy-update implements a kind of mutual exclusion that is wait-free (non-blocking) for readers, allowing extremely low overhead. However, RCU updates can be expensive, as they must leave the old versions of the data structure in place to accommodate pre-existing readers.

⚲ The core API in linux/rcupdate.h _inc is quite small:

rcu_read_lock _id marks an RCU-protected data structure so that it won't be reclaimed for the full duration of that critical section.

rcu_read_unlock _id is used by a reader to inform the reclaimer that the reader is exiting an RCU read-side critical section. Note that RCU read-side critical sections may be nested and/or overlapping.

synchronize_rcu _id blocks until all pre-existing RCU read-side critical sections on all CPUs have completed. Note that synchronize_rcu will not necessarily wait for any subsequent RCU read-side critical sections to complete.

For example, consider the following sequence of events:

	CPU 0	CPU 1	CPU 2
1.	rcu_read_lock()
2.		enters synchronize_rcu()
3.			rcu_read_lock()
4.	rcu_read_unlock()
5.		exits synchronize_rcu()
6.			rcu_read_unlock()

RCU API communications between the reader, updater, and reclaimer

Since synchronize_rcu is the API that must figure out when readers are done, its implementation is key to RCU. For RCU to be useful in all but the most read-intensive situations, synchronize_rcu's overhead must also be quite small.

Alternatively, instead of blocking, synchronize_rcu may register a callback to be invoked after all ongoing RCU read-side critical sections have completed. This callback variant is called call_rcu _id in the Linux kernel.

rcu_assign_pointer _id - The updater uses this function to assign a new value to an RCU-protected pointer, in order to safely communicate the change in value from the updater to the reader. This function returns the new value, and also executes any Memory barrier instructions required for a given CPU architecture. Perhaps more importantly, it serves to document which pointers are protected by RCU.

rcu_dereference _id - The reader uses this function to fetch an RCU-protected pointer, which returns a value that may then be safely dereferenced. It also executes any directives required by the compiler or the CPU, for example, a volatile cast for gcc, a memory_order_consume load for C/C++11 or the memory-barrier instruction required by the old DEC Alpha CPU. The value returned by rcu_dereference is valid only within the enclosing RCU read-side critical section. As with rcu_assign_pointer, an important function of rcu_dereference is to document which pointers are protected by RCU.

The RCU infrastructure observes the time sequence of rcu_read_lock, rcu_read_unlock, synchronize_rcu, and call_rcu invocations in order to determine when (1) synchronize_rcu invocations may return to their callers and (2) call_rcu callbacks may be invoked. Efficient implementations of the RCU infrastructure make heavy use of batching in order to amortize their overhead over many uses of the corresponding APIs.

⚲ API

rcu_nocbs – no-callback CPUs

linux/rcupdate.h _inc

linux/rculist.h _inc – RCU-protected linked list operations

⚙️ Internals

kernel/rcu _src – read-copy-update implementation

📖 References

Avoiding Locks: Read Copy Update _doc

RCU concepts _doc

RCU initialization

📚 Further reading

Reduce synchronize_rcu() latency

Sleeping locks

Mutexes

⚲ API

linux/mutex.h _inc

linux/completion.h _inc

mutex _id has owner and usage constraints, easier to debug than semaphore

rt_mutex _id blocking mutual exclusion locks with priority inheritance (PI) support

ww_mutex _id Wound/Wait mutexes: blocking mutual exclusion locks with deadlock avoidance

rw_semaphore _id readers–writer semaphores

percpu_rw_semaphore _id

completion _id - use completion for synchronization task with ISR and task or two tasks.

wait_for_completion _id

complete _id

🔨 stress-ng --mutex

💾 Historical

semaphore _id - use mutex instead semaphore if possible

linux/semaphore.h _inc

linux/rwsem.h _inc

📖 References

Completions - “wait for completion” barrier APIs _doc

Mutex API reference _doc

LWN: completion events

per CPU local lock

On normal preemptible kernel local_lock calls preempt_disable _id. On RT preemptible kernel local_lock calls migrate_disable _id and spin_lock _id. Any changes applied to spinlock_t also apply to local_lock.

⚲ API

linux/local_lock.h _inc

local_lock _id, preempt_disable _id

local_lock_irqsave _id, local_irq_save _id

etc

📖 References

local_lock _doc

PREEMPT_RT caveats: spinlock_t, rwlock_t, migrate_disable and local_lock _doc

Proper locking under a preemptive kernel _doc

Local locks in the kernel

Spinning locks

Spinlocks

a spinlock is a lock which causes a thread trying to acquire it to simply wait in a loop ("spin") while repeatedly checking if the lock is available. Since the thread remains active but is not performing a useful task, the use of such a lock is a kind of busy waiting. Once acquired, spinlocks will usually be held until they are explicitly released, although in some implementations they may be automatically released if the thread being waited on (that which holds the lock) blocks, or "goes to sleep".

Spinlocks are commonly used inside kernels because they are efficient if threads are likely to be blocked for only short periods. However, spinlocks become wasteful if held for longer durations, as they may prevent other threads from running and require rescheduling. 👁 For example kobj_kset_join _id uses spinlock to protect assess to the linked list.

Enabling and disabling of kernel preemption replaced spinlocks on uniprocessor systems (disabled CONFIG_SMP _id). Most spinning locks becoming sleeping locks in the CONFIG_PREEMPT_RT _id kernels.

⚲ API

linux/spinlock.h _inc

spinlock_t _id

raw_spinlock_t _id

linux/bit_spinlock.h _inc

bit_spin_lock _id

📖 References

Introduction to spinlocks

Queued spinlocks

Seqlocks

A seqlock (short for "sequential lock") is a special locking mechanism used in Linux for supporting fast writes of shared variables between two parallel operating system routines. It is a special solution to the readers–writers problem when the number of writers is small.

It is a reader-writer consistent mechanism which avoids the problem of writer starvation. A seqlock_t _id consists of storage for saving a sequence counter seqcount_t _id/seqcount_spinlock_t in addition to a lock. The lock is to support synchronization between two writers and the counter is for indicating consistency in readers. In addition to updating the shared data, the writer increments the sequence counter, both after acquiring the lock and before releasing the lock. Readers read the sequence counter before and after reading the shared data. If the sequence counter is odd on either occasion, a writer had taken the lock while the data was being read and it may have changed. If the sequence counters are different, a writer has changed the data while it was being read. In either case readers simply retry (using a loop) until they read the same even sequence counter before and after.

⚲ API

seqlock_t _id

DEFINE_SEQLOCK _id, seqlock_init _id, read_seqlock_excl _id, write_seqlock _id

seqcount_t _id

seqcount_init _id, read_seqcount_begin _id, read_seqcount_retry _id, write_seqcount_begin _id, write_seqcount_end _id

linux/seqlock.h _inc

👁 Example: mount_lock _id, defined in fs/namespace.c _src

📖 References

Sequence counters and sequential locks _doc

SeqLock

Spinning or sleeping locks

	normal	on preempt RT
spinlock_t,	raw_spinlock_t	rt_mutex_base, rt_spin_lock, sleeping
rwlock_t	spinning	sleeping
local_lock	preempt_disable	migrate_disable, rt_spin_lock, sleeping

Low level

The compiler might optimize away or reorder writes to variables leading to unexpected behavior when variables are accessed concurrently by multiple threads.

⚲ API

asm-generic/rwonce.h _inc – prevent the compiler from merging or refetching reads or writes.

linux/compiler.h _inc

barrier _id – prevents the compiler from reordering instructions around the barrier

asm-generic/barrier.h _inc – generic barrier definitions

arch/x86/include/asm/barrier.h _src – force strict CPU ordering

mb _id – ensures that all memory operations before the barrier are completed before any memory operations after the barrier are started

⚙️ Internals

Atomics _doc

linux/atomic.h _inc – atomic operations wrapper

asm-generic/atomic.h _inc

linux/atomic/atomic-instrumented.h _inc

atomic_dec_and_test _id ...

📚 Further reading

volatile – prevents the compiler from optimizations

Memory barrier – enforces an ordering constraint on memory operations

🔨 stress-ng --lockbus

...

⚙️ Locking internals

linux/lockdep.h _inc – runtime locking correctness validator

linux/debug_locks.h _inc

lib/locking-selftest.c _src – locking correctness self-tests

kernel/locking _src – locking primitives

mutex_waiter _id, timer_list _id, wait_queue_head_t _id

kernel/locking/locktorture.c _src – module-based torture test facility for locking

📖 Locking references

locking _doc

Lock types and their rules _doc

😴 sleeping locks _doc

mutex _id, rt_mutex _id, semaphore _id, rw_semaphore _id, ww_mutex _id, percpu_rw_semaphore _id

on preempt RT: local_lock, spinlock_t, rwlock_t

😵‍💫 spinning locks _doc:

raw_spinlock_t, bit spinlocks

on non preempt RT: spinlock_t, rwlock_t

Unreliable Guide To Locking _doc

LKMPG: Synchronization

Synchronization primitives

Time

⚲ UAPI

uapi/linux/time.h _inc

timespec _id – nanosecond resolution

timeval _id – microsecond resolution

timezone _id

...

uapi/linux/time_types.h _inc

__kernel_timespec _id – nanosecond resolution, used in syscalls

...

⚲ API

linux/delay.h _inc – busy-wait delay functions for timing control

linux/sched/clock.h _inc

sched_clock _id

...

linux/time.h _inc

tm _id

get_timespec64 _id

...

linux/ktime.h _inc

ktime_t _id – nanosecond scalar representation for kernel time values

ktime_sub _id

...

linux/timekeeping.h _inc

ktime_get _id, ktime_get_ns _id

ktime_get_real _id

...

linux/time64.h _inc

timespec64 _id

time64_t _id

ns_to_timespec64 _id

timespec64_sub _id

ktime_to_timespec64 _id

...

uapi/linux/rtc.h _inc

linux/jiffies.h _inc

⚙️ Internals

kernel/time _src – timekeeping, timers and clocks

timekeeper _id – central timekeeping state

tkr_mono _id – monotonic clock, frequency corrected by NTP for accurate real-world seconds

man 8 chronyd → man 2 adjtimex ↪ sys_adjtimex _id

tkr_raw _id – raw monotonic clock, no NTP correction, drifts with crystal error

update_wall_time _id ← tick_periodic _id → timekeeping_advance _id (blocks readers with write_seqcount_begin _id):

tk_clock_read _id – reads clocksource hardware

logarithmic_accumulation _id – accumulates ticks in doubling steps (efficient for NO_HZ)

timekeeping_adjust _id – corrects mult to steer toward NTP frequency

accumulate_nsecs_to_secs _id – rolls nanoseconds into seconds

timekeeping_update_from_shadow _id – publishes shadow timekeeper to live

update_vsyscall _id – copies time data to vDSO page for userspace man 2 clock_gettime without syscall

update_fast_timekeeper _id – NMI-safe copy via write_seqcount_latch_begin _id (two copies, ktime_get_mono_fast_ns _id and other ktime_get*_fast readers spin on read_seqcount_latch_retry _id)

ktime_get _id and all ktime_get* readers spin on read_seqcount_retry _id until consistent

ktime_get _id = tkr_mono _id.base + timekeeping_get_ns _id

timekeeping_get_ns _id → tk_clock_read _id, timekeeping_cycles_to_ns _id – converts cycles to ns (delta only, added to base by caller)

tk_clock_read _id → arch_inlined_clocksource_read _id → rdtsc_ordered _id – x86 TSC fast path via static key

timekeeping_get_ns _id and rdtsc_ordered _id are safe to trace timekeeping (no seqcount), unlike ktime_get _id which would block on read_seqcount_retry _id

🔨 stress-ng --timer, --hrtimers

Precision Time Protocol

PTP provides sub-microsecond clock synchronization over a network using hardware timestamping.

⚲ API

/sys/class/ptp/ – PTP hardware clock devices

ptp4l – PTP boundary/ordinary clock daemon

phc2sys – synchronize system clock to PTP hardware clock

uapi/linux/ptp_clock.h _inc

⚙️ Internals

drivers/ptp _src – PTP hardware clock drivers

📖 References

PTP hardware clock infrastructure for Linux _doc

ktime accessors _doc

Clock sources, Clock events, sched_clock() and delay timers _doc

Time and timer routines _doc

Year 2038 problem

Interrupts

An interrupt is a signal to the processor emitted by hardware or software indicating an event that needs immediate attention. An interrupt alerts the processor to a high-priority condition requiring the interruption of the current code the processor is executing. The processor responds by suspending its current activities, saving its state, and executing a function called an interrupt handler (or an interrupt service routine, ISR) to deal with the event. This interruption is temporary, and, after the interrupt handler finishes, the processor resumes normal activities.

There are two types of interrupts: hardware interrupts and software interrupts. Hardware interrupts are used by devices to communicate that they require attention from the operating system. For example, pressing a key on the keyboard or moving the mouse triggers hardware interrupts that cause the processor to read the keystroke or mouse position. Unlike the software type, hardware interrupts are asynchronous and can occur in the middle of instruction execution, requiring additional care in programming. The act of initiating a hardware interrupt is referred to as an interrupt request - IRQ ↪ IDT ↪ common_interrupt _id on x86.

A software interrupt is caused either by an exceptional condition in the processor itself, or a special instruction in the instruction set which causes an interrupt when it is executed. The former is often called a trap (⚙️ do_trap _id) or exception and is used for errors or events occurring during program execution that are exceptional enough that they cannot be handled within the program itself. For example, if the processor's arithmetic logic unit is commanded to divide a number by zero, this impossible demand will cause a divide-by-zero exception (⚙️ X86_TRAP_DE _id), perhaps causing the computer to abandon the calculation or display an error message. Software interrupt instructions function similarly to subroutine calls and are used for a variety of purposes, such as to request services from low-level system software such as device drivers. For example, computers often use software interrupt instructions to communicate with the disk controller to request data be read or written to the disk.

Each interrupt has its own interrupt handler. The number of hardware interrupts is limited by the number of interrupt request (IRQ) lines to the processor, but there may be hundreds of different software interrupts.

⚲ API

/proc/interrupts

man 1 irqtop – utility to display kernel interrupt information

irqbalance – distribute hardware interrupts across processors on a multiprocessor system

There are many ways to request ISR, two of them

devm_request_threaded_irq _id – preferable, managed device with threaded ISR

devm_request_irq _id – managed version

request_irq _id

request_threaded_irq _id

free_irq _id

linux/interrupt.h _inc – main interrupt support header

irqaction _id – contains handler functions

rust/kernel/irq.rs _src – Rust bindings

linux/irq.h _inc

irq_data _id

linux/irqflags.h _inc

irqs_disabled _id

local_irq_save _id ...

local_irq_disable _id ...

linux/irqdesc.h _inc

irq_desc _id

linux/irqdomain.h _inc

irq_domain _id – hardware interrupt number translation object

irq_domain_get_irq_data _id

linux/msi.h _inc – Message Signaled Interrupts

msi_desc _id

Structure of structures:

irq_desc _id is container of

irq_data _id

irq – interrupt number

irq_common_data _id

list of irqaction _id

⚙️ Internals

kernel/irq/settings.h _src – IRQ descriptor status flags

kernel/irq _src – generic IRQ handling

kernel/irq/internals.h _src – IRQ subsystem internal functions

ls /sys/kernel/debug/irq/domains/

x86_vector_domain _id, x86_vector_domain_ops _id

irq_chip _id

load_idt _id – load Interrupt Descriptor Table

arch/x86/include/asm/idtentry.h _src – interrupt entry/exit definitions

arch/x86/include/asm/hw_irq.h _src – x86 hardware IRQ definitions

irq_entries_start _id – hardware IRQ entry stubs

arch/x86/kernel/irq.c _src – x86 interrupt handling

common_interrupt _id – handles all normal device IRQs on x86

arch/x86/kernel/apic _src – APIC

arch/x86/kernel/apic/apic.c _src – local APIC core (timer, calibration, spurious interrupt)

arch/x86/kernel/apic/io_apic.c _src – I/O APIC, routes device IRQs to CPUs

arch/x86/kernel/apic/x2apic_cluster.c _src – x2APIC (>256 CPUs)

arch/x86/kernel/apic/ipi.c _src – IPI, see IPI

arch/x86/kernel/apic/hw_nmi.c _src – hardware NMI watchdog via APIC

arch/x86/kernel/apic/vector.c _src – IRQ vector allocation

arch/x86/kernel/apic/msi.c _src – MSI via APIC

📖 References

IRQs _doc

The irq_domain interrupt number mapping library _doc

Linux generic IRQ handling _doc

Message Signaled Interrupts: The MSI Driver Guide _doc

Lock types and their rules _doc

Hard IRQ Context _doc

Interrupts

👁 Examples

dummy_irq_chip _id – dummy interrupt chip implementation

lib/locking-selftest.c _src – locking correctness self-tests

IRQ affinity

⚲ API

/proc/irq/default_smp_affinity

/proc/irq/*/smp_affinity and /proc/irq/*/smp_affinity_list

Common types and functions:

struct irq_affinity _id – description for automatic irq affinity assignments, see devm_platform_get_irqs_affinity _id

struct irq_affinity_desc _id – interrupt affinity descriptor, see irq_update_affinity_desc _id, irq_create_affinity_masks _id

irq_set_affinity _id

irq_get_affinity_mask _id

irq_can_set_affinity _id

irq_set_affinity_hint _id

irqd_affinity_is_managed _id

irq_data_get_affinity_mask _id

irq_data_get_effective_affinity_mask _id

irq_data_update_effective_affinity _id

irq_set_affinity_notifier _id

irq_affinity_notify _id

irq_chip_set_affinity_parent _id

irq_set_vcpu_affinity _id

🛠️ Utilities

irqbalance – distributes hardware interrupts across CPUs

📖 References

SMP IRQ affinity _doc

IRQ affinity, LF

managed_irq kernel parameter, @LKML

irqaffinity kernel parameter, @LKML

Non-maskable interrupts

⚲ API

linux/nmi.h _inc

in_nmi _id

touch_nmi_watchdog _id

...

trace/events/nmi.h _inc

arch/x86/include/asm/nmi.h _src – x86 NMI handler registration

register_nmi_handler _id

unregister_nmi_handler _id

⚙️ Internals

arch/x86/kernel/nmi.c _src – x86 NMI handler

arch/x86/kernel/apic/hw_nmi.c _src – hardware NMI watchdog via APIC

arch/x86/kernel/nmi_selftest.c _src – NMI IPI self-tests

📖 References

NMI Trace Events _doc

📚 Further reading

Non-maskable interrupt handler (NMI)

...

📚 Further reading about interrupts

IDT – Interrupt descriptor table

LGDT/LIDT – Load Global/Interrupt Descriptor Table Register asm instruction

Deferred works

Scheduler context

kthread work

This framework simplifies the use of kernel kthreads. A kthread_work _id item can be queued with kthread_queue_work _id and flushed using kthread_flush_work _id. All queued kthread_work items are processed by a dedicated kernel thread executing the kthread_worker_fn _id function.

⚲ API

kthread_work _id – contains kthread_work_func_t _id to execute

kthread_init_work _id

kthread_flush_work _id

kthread_worker _id – links a kthread_work and a task

kthread_run_worker _id – creates and wakes a kthread worker

kthread_create_worker _id

kthread_flush_worker _id

kthread_destroy_worker _id

kthread_queue_work _id – queues a kthread_work on a kthread_worker

⚙️ Internals

__kthread_create_worker_on_node _id

kthread_worker_fn _id – executes work's function

👁 Example usages

watchdog_kworker _id, pwq_release_worker _id, pump_messages _id

Threaded IRQ

⚲ API devm_request_threaded_irq _id, request_threaded_irq _id ISR should return IRQ_WAKE_THREAD to run thread function

⚙️ Internals

setup_irq_thread _id, irq_thread _id

kernel/irq/manage.c _src – IRQ request, free and affinity management

📖 References

request_threaded_irq _doc

Work and workqueue

Generic async execution with shared worker pool.

⚲ API

PF_WQ_WORKER _id – workqueue worker process flag

linux/workqueue.h _inc, linux/workqueue_types.h _inc

rust/kernel/workqueue.rs _src – Rust bindings

work_struct _id, INIT_WORK _id

delayed_work _id, INIT_DELAYED_WORK _id, cancel_delayed_work_sync _id

workqueue_struct _id

devm_alloc_workqueue _id

alloc_workqueue _id

destroy_workqueue _id

schedule_work _id – queues work on the system workqueue ↯

queue_work _id – queues work on a workqueue

queue_work_on _id – on a specific CPU

show_all_workqueues _id

show_one_workqueue _id

system_power_efficient_wq _id ...

👁 Example usage samples/ftrace/sample-trace-array.c _src

⚙️ Internals

kernel/workqueue.c _src – generic async execution with shared worker pool

workqueue_init _id

create_worker _id

worker_thread _id

process_one_work _id

format_worker_id _id – names kworker kthreads

pool_workqueue _id

worker_pool _id

📖 References

Concurrency Managed Workqueue _doc

LKMPG: Work queues

Interrupt context

linux/irq_work.h _inc – run callbacks from hardirq or NMI context where normal work queues can't be used

irq_work_queue _id – enqueue work on the current CPU, triggers IRQ_WORK_VECTOR _id IPI if needed

irq_work_sync _id – wait for completion

kernel/irq_work.c _src – irq_work implementation

👁 samples/trace_printk/trace-printk.c _src

Timers

Not to be confused with POSIX timer – userspace API, watchdog timer – hang detection, local APIC timer – per-CPU hardware, drives the tick.

timer softirq

Not to be confused with nanosecond-resolution high-resolution timer.

This timer is a softirq for periodical tasks with jiffies resolution. Also known as kernel timer or timer wheel.

⚲ API

linux/timer.h _inc

timer_list _id, DEFINE_TIMER _id, timer_setup _id

mod_timer _id — sets expiration time in jiffies.

timer_delete _id

⚙️ Internals

kernel/time/timer.c _src – kernel internal timers

timer_bases _id – per-CPU array of timer_base _id (timing wheel):

BASE_LOCAL – pinned to this CPU (TIMER_PINNED _id)

BASE_GLOBAL – can be run remotely by migrator via timer_expire_remote _id

BASE_DEF – deferrable, can be delayed indefinitely

run_timer_softirq _id – TIMER_SOFTIRQ _id handler

__run_timer_base _id – iterate expired timers and call callbacks

👁 Examples

input_enable_softrepeat _id and input_start_autorepeat _id

📚 References

Time and timer routines _doc

timer_init_key ... _doc

High-resolution timer

Not to be confused with jiffies-resolution timer softirq.

⚲ API

/proc/timer_list

/proc/sys/kernel/timer_migration _doc – enable/disable hrtimer migration

linux/hrtimer_defs.h _inc

linux/hrtimer.h _inc

hrtimer _id, hrtimer.function — callback

hrtimer_setup _id

hrtimer_start _id — starts a timer with nanosecond resolution

hrtimer_cancel _id

👁 Examples alarm_init _id, watchdog_enable _id

⚙️ Internals

CONFIG_HIGH_RES_TIMERS _id

kernel/time/tick-internal.h _src – tick and timer internal definitions

hrtimer_bases _id – per-CPU hrtimer_cpu_base _id, contains 8 clock bases:

hrtimer_clock_base _id – timerqueue per clock type per CPU

hrtimer_base_type _id – MONOTONIC, REALTIME, BOOTTIME, TAI (× hardirq + softirq = 8)

kernel/time/hrtimer.c _src – high-resolution timer implementation

hrtimer_interrupt _id – called from clock event device, expires hardirq timers

__hrtimer_run_queues _id – walk timerqueue, call expired callbacks

hrtimer_run_softirq _id – HRTIMER_SOFTIRQ _id handler, expires HRTIMER_MODE_SOFT timers

__hrtimer_run_queues _id

kernel/time/itimer.c _src – interval timers

kernel/time/timer_list.c _src – /proc/timer_list debugfs

📚 HR timers references

High-resolution timers _doc

hrtimers - subsystem for high-resolution kernel timers _doc

high resolution timers and dynamic ticks design notes _doc

Tick and NO_HZ

The tick is the periodic timer interrupt that drives scheduling, timekeeping, and RCU. The NO_HZ subsystem reduces or eliminates tick interrupts to save power and reduce latency.

⚲ API

/sys/devices/system/cpu/nohz_full – active nohz_full CPUs

nohz_full= boot parameter – list of CPUs to run tickless

linux/tick.h _inc – tick control API

tick_nohz_full_running _id – true if any CPU runs tickless

tick_nohz_full_cpu _id – true if given CPU runs tickless

enum tick_dep_bits _id – reasons a CPU/task/signal may need the tick (posix timer, perf events, sched, unstable clock, RCU, RCU expedited)

tick_nohz_dep_set _id ... – modify a global tick dependency bit, used by perf for unstable clocks; kicks all full-nohz CPUs to restart their tick

sched_tick_remote _id – remote CPU updates scheduler stats (load, timeslice) for nohz_full CPUs via delayed work

/proc/sys/kernel/timer_migration _doc – enable/disable hrtimer migration

🪛 Compile-time configurations (kernel/time/Kconfig _src)

CONFIG_HZ_PERIODIC _id – constant-rate tick, always firing

CONFIG_NO_HZ_IDLE _id – stop tick when CPU is idle (default on most distros)

CONFIG_NO_HZ_FULL _id – stop tick even when running a single task, for RT and latency-sensitive workloads, see CPU isolation

⚙️ Internals

kernel/time/tick-common.c _src – periodic tick setup

kernel/time/tick-oneshot.c _src – oneshot mode for hrtimers and NO_HZ

kernel/time/tick-sched.c _src – NO_HZ tick scheduling logic

tick_nohz_handler _id – hrtimer callback driving the tick, rearmed at TICK_NSEC until idle/full-dynticks stops it

tick_nohz_init _id – enable full nohz on boot if requested and supported

kernel/time/tick-broadcast.c _src – broadcast tick for CPUs in deep idle where local timer stops (C3+)

tick_dependency:

sched_update_tick_dependency _id – modifies the TICK_DEP_BIT_SCHED _id scheduler tick dependency bit in tick_dep_mask _id

sched_can_stop_tick _id – true if a runqueue has at most one runnable task and can go tickless

can_stop_full_tick _id – decide if a full-dynticks CPU can stop its tick, checking CPU online state and the tick_dep_mask _id tick dependencies

check_tick_dependency _id – test one tick dependency mask (global, CPU, task, signal) for a pending reason to keep the tick running

kernel/time/timer_migration.h _src, kernel/time/timer_migration.c _src – migrate timer softirq (BASE_GLOBAL) from idle to busy CPUs via hierarchical groups

tmigr_cpu_activate _id – CPU joins migration hierarchy on online

tmigr_handle_remote _id – migrator CPU fires expired timers on behalf of idle CPUs

timer_expire_remote _id → __run_timer_base _id

tmigr_update_events _id – propagate timer events up/down the hierarchy

/sys/kernel/debug/tracing/events/timer_migration/ – tracepoints

/proc/sys/kernel/timer_migration _doc – enable/disable hrtimer migration

timers_migration_enabled _id

Used in:

switch_hrtimer_base _id – move hrtimer to target CPU base at enqueue time

get_target_base _id – select hrtimer_cpu_base, migrates to busy CPU if not pinned

get_nohz_timer_target _id – pick busy CPU

hrtimer_prefer_local _id

📖 References

NO_HZ: Reducing Scheduling-Clock Ticks _doc

Tickless kernel, RT wiki

high resolution timers and dynamic ticks design notes _doc

Clock infrastructure

Not to be confused with drivers/clk framework – SoC clock tree management.

Clocksources read current time (passive counters). Clock event devices fire interrupts at a programmed time (active). Together they are the foundation for timekeeping, timers, tick, and NO_HZ.

⚲ Clocksources – "what time is it?"

/sys/devices/system/clocksource/clocksource0/current_clocksource

/sys/devices/system/clocksource/clocksource0/available_clocksource

TSC – fastest, per-CPU, x86

HPET – system-wide, MMIO

ACPI PM timer – never stops in any C-state, slow

linux/clocksource.h _inc – clocksource _id, clocksource_register_hz _id

⚲ Clock event devices – "wake me at time X"

linux/clockchips.h _inc – clock_event_device _id, clockevents_config_and_register _id

Local APIC timer – per-CPU, fastest, stops in C3+, local_apic_timer_interrupt _id

HPET – system-wide, used as broadcast fallback

⚙️ Internals

kernel/time/clocksource.c _src – clocksource selection and watchdog

kernel/time/clockevents.c _src – clock event device framework

kernel/time/jiffies.c _src – jiffies clocksource (fallback)

...

📖 Timers references

Timers _doc

Better CPU selection for timer expiration

Tasklet

tasklet is a softirq, for time critical operations

⚲ API is deprecated in favor of threaded IRQs: devm_request_threaded_irq _id

tasklet_struct _id, tasklet_init _id, tasklet_schedule _id

⚙️ Internals: tasklet_action_common _id HI_SOFTIRQ, TASKLET_SOFTIRQ

Softirq

softirq is internal system facility and should not be used directly. Use tasklet or threaded IRQs

⚲ API

linux/interrupt.h _inc

cat /proc/softirqs

open_softirq _id registers softirq_action _id

raise_softirq _id

tasklet_schedule _id

__tasklet_schedule _id

⚙️ Internals

kernel/softirq.c _src – software interrupt handling

__do_softirq _id – main softirq processing loop

📖 References

Introduction to deferred interrupts (Softirq, Tasklets and Workqueues)

Timers and time management

Deferred work, linux-kernel-labs

Chapter 7. Time, Delays, and Deferred Work

CPU specific

🖱️ GUI

tuna – program for tuning running processes

⚲ API

cat /proc/cpuinfo

/sys/devices/system/cpu/

/sys/devices/system/node/

/sys/cpu/

/sys/fs/cgroup/cpu/

grep -i cpu /proc/self/status

rdmsr – tool for reading CPU machine specific registers (MSR)

man 1 lscpu – display information about the CPU architecture

linux/arch_topology.h _inc – arch specific cpu topology information

linux/cpu.h _inc – generic cpu definition

linux/cpu_cooling.h _inc

linux/cpu_pm.h _inc

linux/cpufeature.h _inc

arch/x86/include/asm/cpufeature.h _src – x86 CPU feature detection

linux/peci-cpu.h _inc

linux/sched/cputime.h _inc – cputime accounting APIs

linux/clk.h _inc – interfaces for managing hardware clocks in device drivers

⚙️ Internals

drivers/base/cpu.c _src – CPU driver model subsystem

cpu_dev_init _id

Cache

linux/cacheflush.h _inc

arch/x86/include/asm/cacheflush.h _src: clflush_cache_range _id

linux/cache.h _inc – cache line alignment macros

____cacheline_aligned _id – align to cache line boundary to avoid false sharing

__cacheline_aligned _id – same, plus place in .data..cacheline_aligned section

____cacheline_aligned_in_smp _id – same, but no-op on uniprocessor builds

__read_mostly _id – place in a cache-friendly section for rarely written data

__ro_after_init _id – writable during init, read-only after boot (security hardening)

DEFINE_PER_CPU_CACHE_HOT _id – per-CPU variable in .data..hot section, used for current_task _id, __preempt_count _id

L1_CACHE_BYTES _id, SMP_CACHE_BYTES _id – 64 bytes typically

arch/x86/include/asm/cache.h _src – x86 cache line size definitions

🔨 stress-ng --cache

⚙️ Internals

arch/x86/mm/pat/set_memory.c _src – page attribute table memory type control

arch/x86/kernel/cpu/mtrr/ _src – memory type range register driver

📚 Further reading

MTRR – Memory type range register

CPU cache

SMP

This chapter is about multiprocessing and multi-core aspects of Linux kernel.

Key concepts and features of Linux SMP include:

• Symmetry: In an SMP system, all processors are considered the same without hardware hierarchy in contradiction to use of coprocessors.
• Load balancing: The Linux kernel employs load balancing mechanisms to distribute tasks evenly among available CPU cores. This prevents any one core from becoming overwhelmed while others remain underutilized.
• Parallelism: SMP enables parallel processing, where multiple threads or processes can execute simultaneously on different CPU cores. This can significantly improve the execution speed of applications that are designed to take advantage of multiple threads.
• Thread scheduling: The Linux kernel scheduler is responsible for determining which threads or processes run on which CPU cores and for how long. It aims to optimize performance by minimizing contention and maximizing CPU utilization.
• Shared memory: In an SMP system, all CPU cores typically share the same physical memory space. This allows processes and threads running on different cores to communicate and share data more efficiently.
• NUMA – Non-Uniform Memory Access: In larger SMP systems, memory access times might not be uniform due to the physical arrangement of memory banks and processors. Linux has mechanisms to handle NUMA architectures efficiently, allowing processes to be scheduled on CPUs closer to their associated memory.
• Cache coherency: SMP systems require mechanisms to ensure that all CPU cores have consistent views of memory. Cache coherency protocols ensure that changes made to shared memory locations are correctly propagated to all cores.
• Scalability: SMP systems can be scaled up to include more CPU cores, enhancing the overall computing power of the system. However, as the number of cores increases, challenges related to memory access, contention, and communication between cores may arise.
• Kernel and user space: Linux applications running in user space can take advantage of SMP without needing to be aware of the underlying hardware details. The kernel handles the management of CPU cores and resource allocation.

⚲ API

ps -PLe – lists threads with processor that the thread last executed on (the third column PSR).

man 2 getcpu – determine CPU and NUMA node on which the calling thread is running

man 8 chcpu – configure CPUs

man 3 CPU_SET – macros for manipulating CPU sets

linux/smp.h _inc

The most commonly used functions:

crash_smp_send_stop _id – halts all CPUs except the calling one in a crash context

get_cpu _id – disables preemption and returns the current processor ID

panic_smp_self_stop _id – stops the local CPU during a panic while ensuring others halt

put_cpu _id – re-enables preemption after a previous get_cpu call

raw_smp_processor_id _id – returns the current CPU ID without preemption safety

setup_max_cpus _id – sets up the maximum number of CPUs to be brought online

smp_init _id – initializes core SMP structures and state during boot

smp_prepare_boot_cpu _id – prepares the boot CPU during early SMP initialization

smp_prepare_cpus _id – prepares all CPUs for booting before secondary CPUs are started

smp_processor_id _id – returns the ID of the current CPU with preemption checks

smp_send_stop _id – stops all other CPUs in response to critical events

wake_up_all_idle_cpus _id – wakes all idle CPUs to ensure prompt task execution

linux/cpu.h _inc

linux/group_cpus.h _inc: group_cpus_evenly _id – groups all CPUs evenly per NUMA/CPU locality

asm-generic/percpu.h _inc

linux/percpu-defs.h _inc – basic definitions for percpu areas

this_cpu_ptr _id

linux/percpu.h _inc

linux/percpu-refcount.h _inc

linux/percpu-rwsem.h _inc

linux/preempt.h _inc

migrate_disable _id, migrate_enable _id

/sys/bus/cpu

per CPU local_lock

linux/topology.h _inc – cpu_to_node _id, numa_node_id _id

arch/x86/include/asm/topology.h _src – x86 NUMA and CPU topology

See also [[../../Memory#NUMA|NUMA memory section]]

⚙️ Internals

boot_cpu_init _id activates the first CPU

smp_prepare_cpus _id initializes rest CPUs during boot

cpu_number _id

CONFIG_SMP _id

CONFIG_NUMA _id

trace/events/percpu.h _inc

drivers/base/cpu.c _src – CPU driver model subsystem support

kernel/cpu.c _src – CPU hotplug state machine

smpboot

linux/smpboot.h _inc

kernel/smpboot.c _src – common SMP CPU bringup/teardown

arch/x86/kernel/smpboot.c _src – x86 SMP booting

lib/group_cpus.c _src – distribute CPUs evenly across groups

🛠️ Utilities

irqbalance – distributes hardware interrupts across CPUs

man 8 numactl – controls NUMA policy for processes or shared memory

📖 References

Per-CPU Data _doc

How CPU topology info is exported via sysfs _doc

📚 Further reading

Functionalities of the scheduler TuneD plugin

tuned-adm – command line tool for switching between different tuning profiles

IPI

An inter-processor interrupt is a signal sent from one CPU to another to request an action such as rescheduling, TLB flush, or function execution.

⚲ API

smp_send_reschedule _id – sends a reschedule IPI to a target CPU

smp_call_function _id – invokes a function on all other CPUs via IPI

smp_call_function_many _id – on a specified set of CPUs

smp_call_function_single _id – on a single target CPU

smp_call_function_single_async _id – asynchronous variant

smp_call_on_cpu _id – execute on a specific CPU and wait for result

on_each_cpu _id – run a function on all CPUs

on_each_cpu_mask _id – on a specified set of CPUs

on_each_cpu_cond_mask _id – conditionally on selected CPUs

smp_call_func_t _id – callback typedef

⚙️ Internals

trace/events/ipi.h _inc

kernel/irq/ipi.c _src – generic IPI helpers

ipi_send_single _id, ipi_send_mask _id

arch/x86/kernel/apic/ipi.c _src – x86 IPI via APIC

arch/x86/include/asm/irq_vectors.h _src – x86 IPI vector types:

RESCHEDULE_VECTOR _id – used by smp_send_reschedule _id

CALL_FUNCTION_VECTOR _id – used by smp_call_function_many _id

CALL_FUNCTION_SINGLE_VECTOR _id – used by smp_call_function_single _id

IRQ_WORK_VECTOR _id – used by irq_work_queue _id, see Interrupt context

NMI_VECTOR _id – used by watchdog, crash_smp_send_stop _id

CPU affinity

Affinity refers to assigning a process or thread to specific CPU cores. This helps control which CPUs execute tasks, potentially improving performance by reducing data movement between cores. It can be managed using system calls or commands. Affinity can be represented as CPU bitmask: cpumask_t _id or CPU affinity list: cpulist_parse _id.

⚲ API

man 1 taskset – set or retrieve a process's CPU affinity

grep Cpus_allowed /proc/self/status

man 2 sched_setaffinity man 2 sched_getaffinity – set and get a thread's CPU affinity mask

↪ sched_setaffinity _id

set_cpus_allowed_ptr _id – common kernel function to change a task's affinity mask

linux/cpu_rmap.h _inc – CPU affinity reverse-map support

linux/cpumask_types.h _inc

struct cpumask, cpumask_t _id – CPUs bitmap, can be very big

cpumask_var_t _id – type for local cpumask variable, see alloc_cpumask_var _id, free_cpumask_var _id.

linux/cpumask.h _inc – Cpumasks provide a bitmap suitable for representing the set of CPU's in a system, one bit position per CPU number

for_each_possible_cpu _id

num_online_cpus _id

cpumask_set_cpu _id

cpumask_test_cpu _id

for_each_cpu _id

⚙️ Internals

cpus_mask _id – affinity of task_struct _id

cpus_allowed _id – affinity of cpuset _id

📚 Further reading

Processor affinity

Affinity mask

CPU hotplug

CPU hotplugging in Linux refers to the ability to dynamically add or remove CPUs from the system without needing a reboot. This feature is crucial in environments requiring high availability and resource flexibility, such as data centers, virtualized systems, and systems that use power management aggressively.

🗝️ Acronyms

BP – Bootstrap Processor

AP – Application Processor

⚲ API

/sys/devices/system/cpu/cpu*/online

/sys/devices/system/cpu/cpu*/hotplug/

linux/cpu.h _inc

add_cpu _id ...

linux/cpuhotplug.h _inc

cpuhp_state _id – CPU hotplug states

cpuhp_setup_state _id ... – setups hotplug state callbacks

cpuhp_setup_state_multi _id

cpuhp_setup_state_nocalls _id

linux/cpuhplock.h _inc – CPU hotplug locking

cpus_read_lock _id ...

remove_cpu _id ...

⚙️ Internals

kernel/cpu.c _src – CPU hotplug state machine

cpuhp_state _id – from CPUHP_OFFLINE to CPUHP_AP_ACTIVE and CPUHP_ONLINE.

cpuhp_hp_states _id

boot_cpu_hotplug_init _id

cpuhp_threads_init _id

... cpuhp_invoke_callback_range _id ...

kernel/irq/cpuhotplug.c _src – IRQ migration on CPU hotunplug

drivers/base/cpu.c _src – CPU subsystem support

cpu_dev_init _id

... cpu_subsys_online _id

trace/events/cpuhp.h _inc

linux/cpuhplock.h _inc

👁️ Examples

torture_onoff _id

tools/testing/selftests/sched_ext/hotplug.c _src – sched_ext CPU hotplug test

📖 References

CPU hotplug in the Kernel _doc

Introduction _doc

Command Line Switches _doc

CPU maps _doc

Using CPU hotplug _doc

The CPU hotplug coordination _doc

The CPU hotplug API _doc

CPU hotplug state machine _doc

CPU online/offline operations _doc

Allocating a state _doc

Setup of a CPU hotplug state _doc

Removal of a CPU hotplug state _doc

Multi-Instance state instance management _doc

Examples _doc

Testing of hotplug states _doc

Architecture’s requirements _doc

User Space Notification _doc

Kernel Inline Documentations Reference _doc

🔨 stress-ng --cpu-online

📚 Further reading

CONFIG_CPU_HOTPLUG_STATE_CONTROL _id – enables the ability to write incremental steps between "offline" and "online" states to the CPU's sysfs target file, allowing for more granular control of state transitions.

target_store _id: cpu_up _id/cpu_down _id

cpuhotplug, cpuhp @LKML

CPU isolation

CPU isolation ensures that specific tasks run on dedicated CPUs, reducing contention and latency.

Housekeeping CPUs refer to the CPUs that are reserved for various system tasks. See hk_type _id.

Isolated CPUs are dedicated to real-time applications, such as DPDK.

⚲ API

/sys/devices/system/cpu/isolated

/sys/devices/system/cpu/nohz_full

/sys/fs/cgroup/cpuset.cpus.isolated

/sys/fs/cgroup/.../cpuset.cpus.partition

linux/sched/isolation.h _inc

hk_type _id – housekeeping type

housekeeping_cpumask _id – returns CPUs available for housekeeping of a given type

cpu_is_isolated _id

linux/cpuset.h _inc – cpuset interface

man 7 cpuset – confine processes to processor and memory node subsets

⚙️ Internals

CONFIG_CPU_ISOLATION _id

kernel/sched/isolation.c _src – housekeeping CPU management

housekeeping_init _id, housekeeping_update _id

CONFIG_CPUSETS _id

kernel/cgroup/cpuset.c _src – cpuset cgroup controller

cpuset_init _id

cpuset_init_smp _id

isolated_cpus _id

partition_xcpus_add _id, partition_xcpus_del _id

📖 References

CPU lists in command-line parameters _doc

nohz_full clears housekeeping.cpumasks _id for tick, wq, timer, rcu, misc, and kthread in housekeeping_nohz_full_setup _id

isolcpus clears housekeeping.cpumasks _id for domain (by default), nohz, and managed_irq in housekeeping_isolcpus_setup _id

Housekeeping _doc

NO_HZ: Reducing Scheduling-Clock Ticks _doc

CPUSETS of cgroup v2 _doc

CPUSETS of cgroup v1 _doc

📚 Further reading

CPU Isolation state of the art, LPC'23

CPU Isolation and IPI interference, LPC'25

CPU Isolation

isolcpus @LKML

housekeeping @LKML

Explicitly Reserved CPU List, Kubernetes Documentation

CPU Partitioning

Scheduler Domains _doc – the Scheduler balances CPUs (scheduling groups) within a sched domain

nohz_full @LKML

💾 Historical since v7.0

cpuset_cpu_is_isolated _id – removed, use cpu_is_isolated _id instead

Runtime code patching

The kernel patches its own machine code at boot or runtime to optimize hot paths. Static keys patch a NOP to a jump (or vice versa); static calls patch indirect calls to direct calls; alternatives replace instructions based on CPU features.

⚲ API

linux/jump_label.h _inc – static keys

DEFINE_STATIC_KEY_FALSE _id – define a key, initially false

static_branch_unlikely _id – zero-cost branch check (NOP when key is false)

static_branch_enable _id – patch all sites to take the branch (expensive, rare use)

linux/static_call.h _inc – static calls

DEFINE_STATIC_CALL _id – define a call site with initial target function

static_call _id – invoke the patched direct call

static_call_update _id – change target function, patch all sites

arch/x86/include/asm/alternative.h _src – alternatives

ALTERNATIVE _id – replace instructions at boot based on CPU features

arch/x86/include/asm/cpufeatures.h _src – X86_FEATURE_* flags

⚙️ Internals

CONFIG_JUMP_LABEL _id

kernel/jump_label.c _src – static key patching core

arch/x86/kernel/jump_label.c _src – x86 static key patching

CONFIG_HAVE_STATIC_CALL _id

kernel/static_call_inline.c _src – static call core

arch/x86/kernel/static_call.c _src – x86 static call patching

arch/x86/include/asm/alternative.h _src – runtime instruction patching

arch/x86/kernel/alternative.c _src – x86 alternatives engine

smp_text_poke_single _id – safely patch code on SMP using INT3 breakpoints; used by static keys, static calls, ftrace, kprobes

smp_text_poke_batch_add _id

smp_text_poke_batch_finish _id

👁 Examples

housekeeping_overridden _id

preempt_schedule _id

tracepoints

📖 References

Static Keys _doc

x86 CPU feature flags _doc

Memory barriers

Memory barriers (MB) are synchronization mechanisms used to ensure proper ordering of memory operations in a SMP environment. They play a crucial role in maintaining the consistency and correctness of data shared among different CPU cores or processors. MBs prevent unexpected and potentially harmful reordering of memory access instructions by the compiler or CPU, which can lead to data corruption and race conditions in a concurrent software system.

⚲ API

man 2 membarrier

asm-generic/barrier.h _inc

mb _id, rmb _id, wmb _id

smp_mb _id, smp_rmb _id, smp_wmb _id

⚙️ Internals

arch/x86/include/asm/barrier.h _src – x86 memory barrier instructions

kernel/sched/membarrier.c _src – membarrier system call

📖 References

Memory barriers _doc

States

C-states and P-states are features in modern CPUs designed to improve energy efficiency.

🗝️ Acronyms

C-states – CPU(?) states, aka idle states

EPP – Energy Performance Preference _doc

HWP – hardware-managed P-states, see hwp_only

P-states – Performance states, see CPU Power and frequency scaling

⚲ API

cpupower

📖 References

Working-State Power Management _doc

https://lwn.net/Kernel/Index/#Power_management

Idle

C-states, power states:

C0 – operating, executing instructions.

C1 (Halt) – internal clocks stopped.

C1E (Enhanced Halt) – clocks stopped, voltage and frequency reduced.

C2 (Stop-Clock) – internal and external clocks stopped.

C3 (Deep Sleep) – clocks stopped, L1/L2 cache may flush, local APIC timer stops, requiring tick broadcast.

C4 (Deeper Sleep) – voltage reduced.

C6 (Deep Power Down) – state saved to SRAM, voltage can drop to 0V.

C7 (Deeper Power Down) – C6 + L3 cache flushed.

Modern Intel typically uses C1/C1E and C6, skipping C2–C5.

⚠️ ACPI state names (C1_ACPI, C2_ACPI, C3_ACPI) may not match actual hardware C-states. The MWAIT hint reveals the real state: e.g. MWAIT 0x60 = hardware C6 may appear as "C3_ACPI".

⚲ API

turbostat --show CPU --quiet -n 1 --interval 0.1 --show sysfs

idle=

/dev/cpu_dma_latency – see set_cpu_dma_latency _id

C-states interfaces:

cpupower idle-info – show driver, governor, states with latency and residency

/sys/devices/system/cpu/cpuidle/

/sys/devices/system/cpu/cpu*/cpuidle/

cat /sys/devices/system/cpu/cpu0/cpuidle/state*/name – list available C-states

linux/cpuidle.h _inc – generic framework for CPU idle power management

linux/pm_qos.h _inc

⚙️ Internals

drivers/cpuidle _src – CPU idle governors and drivers

drivers/idle/intel_idle.c _src – intel_idle _doc, hardcoded C-states per CPU model, modern Intel (C1/C1E/C6)

drivers/acpi/processor_idle.c _src – acpi_idle, reads C-states from ACPI tables, generic fallback (C1/C2/C3)

kernel/power/qos.c _src – PM quality of service

cpu_latency_qos_miscdev _id – implementation of /dev/cpu_dma_latency

📖 References

CPU Idle Time Management _doc

Intel C-states reference

HPE C-states reference

📚 Further reading

https://lwn.net/Kernel/Index/#Power_management-cpuidle

PM Quality Of Service Interface _doc

Power and frequency

P-states, performance states:

P0 – maximum power and frequency

Pn – less power and frequency

...

⚲ API

Reliable measurement of actual CPU frequency

turbostat --quiet --show CPU,Bzy_MHz -n 1 --interval 0.1

Bzy_MHz – average clock rate while the CPU was not idle (ie. in "c0" state).

intel_pstate=

Kernel Command Line Options for intel_pstate _doc

cpufreq.default_governor=

P-states interfaces:

/sys/devices/system/cpu/cpufreq/

/sys/devices/system/cpu/cpu*/cpufreq/

scaling_cur_freq – unreliable assumption on CPU frequency

/sys/devices/system/cpu/intel_pstate/

linux/cpufreq.h _inc

rust/kernel/cpufreq.rs _src – Rust bindings

linux/sched/cpufreq.h _inc – interface between cpufreq drivers and the scheduler

⚙️ Internals

drivers/cpufreq _src – CPU frequency scaling drivers

intel_pstate _id

acpi_cpufreq_driver _id

kernel/sched/cpufreq_schedutil.c _src – implementation of cpufreq.default_governor=schedutil

arch/x86/kernel/cpu/intel_epb.c _src – Intel Performance and Energy Bias Hint support

📖 References

CPU Performance Scaling _doc

Device Frequency Scaling _doc

CPUFreq Governor

CPUFreq - CPU frequency and voltage scaling _doc

Intel Performance and Energy Bias Hint _doc

intel_pstate CPU Performance Scaling Driver _doc

General Information _doc

Operation Modes _doc

Active Mode _doc

Passive Mode _doc

Turbo P-states Support _doc

Processor Support _doc

Support for Hybrid Processors _doc

Hybrid Processors with SMT _doc

Capacity-Aware Scheduling Support _doc

Energy-Aware Scheduling Support _doc

User Space Interface in sysfs _doc

Global Attributes _doc

Interpretation of Policy Attributes _doc

Coordination of P-State Limits _doc

Energy vs Performance Hints _doc

intel_pstate vs acpi-cpufreq _doc

Kernel Command Line Options for intel_pstate _doc

Diagnostics and Tuning _doc

Trace Events _doc

ftrace _doc

📚 Further reading

https://lwn.net/Kernel/Index/#Power_management-Frequency_scaling

CPU frequency scaling

cpufreq _ltp

How to use cpufrequtils

cpufreq-info

cpufreq-set

https://github.com/intel/power-optimization-library

https://github.com/intel/kubernetes-power-manager

Architectures

Linux CPU architectures refer to the different types of central processing units (CPUs) that are compatible with the Linux operating system. Linux is designed to run on a wide range of CPU architectures, which allows it to be utilized on various devices, from smartphones to servers and supercomputers. Each architecture has its own unique features, advantages, and design considerations.

Architectures are classified by family (e.g. x86, ARM), word or long int size (e.g. CONFIG_32BIT _id, CONFIG_64BIT _id).

Some functions with different implementations for different CPU architectures:

do_boot_cpu _id > start_secondary _id > cpu_init _id

setup_arch _id, start_thread _id, get_current _id, current _id

⚲ API

BITS_PER_LONG _id, __BITS_PER_LONG _id,

⚙️ Internals

arch _src – architecture-specific code

📖 References

CPU Architectures _doc

x86

CONFIG_X86 _id

arch/x86 _src – x86 architecture support

arch/x86/kernel _src – core (SMP boot, traps, IRQ, TSC, reboot), x86 Topology _doc

arch/x86/kernel/apic _src – APIC (local APIC, I/O APIC, IPI delivery)

arch/x86/kernel/cpu/bugs.c _src – CPU vulnerability mitigations, see Security

arch/x86/kernel/cpu/mce _src – Machine-check exception handling

arch/x86/kernel/cpu/microcode _src – The Linux Microcode Loader _doc

arch/x86/kernel/cpu/mtrr _src – MTRR driver

arch/x86/mm _src – TLB, PAT, MTRR, SME, see Memory

arch/x86/entry _src – syscall and interrupt entry points, see Syscalls

arch/x86/boot _src – boot protocol and early setup, x86 Feature Flags _doc, see Booting

arch/x86/kvm _src – KVM, see Virtualization

arch/x86/crypto _src – AES-NI, SHA, CRC, see Crypto

arch/x86/coco _src – confidential computing (TDX, SEV)

arch/x86/events _src – PMU drivers for perf, see Perf

arch/x86/net _src – x86 BPF JIT compiler, see eBPF

arch/x86/xen _src – Xen paravirtualization

arch/x86/hyperv _src – Hyper-V support

drivers/platform/x86 _src – x86 platform drivers

man 1 perf-intel-pt – support for Intel Processor Trace within perf

CPU feature flags

CPU features detected at boot from CPUID, visible in /proc/cpuinfo flags.

arch/x86/include/asm/cpufeatures.h _src

arch/x86/include/generated/asm/cpufeaturemasks.h _src

man 4 cpuid – x86 CPUID device

tools/arch/x86/kcpuid _src – kernel CPUID dumping tool

cd tools/arch/x86/kcpuid && make && ./kcpuid --detail | grep $'^\t' – list local CPU features with descriptions

https://gitlab.com/x86-cpuid.org/x86-cpuid-db – CPUID feature database

Extended features (newest first):

Compute:

AMX – Advanced Matrix Extensions for AI/ML workloads, 2023

AVX-512 – 512-bit SIMD, 2016

Security:

X86_FEATURE_SHSTK _id – CET Shadow Stack, control-flow integrity, 2020

X86_FEATURE_IBT _id – CET Indirect Branch Tracking, 2020

X86_FEATURE_UMIP _id – User-Mode Instruction Prevention, 2017

X86_FEATURE_PKU _id – Memory Protection Keys for user pages, 2016

Memory management:

X86_FEATURE_LA57 _id – 5-level paging, 57-bit virtual addresses (128 PB), 2019

Timing:

X86_FEATURE_ART _id – Always Running Timer, fixed TSC/crystal ratio for PTP, 2016

X86_FEATURE_TSC_DEADLINE_TIMER _id – APIC timer in TSC-deadline mode, 2011

Virtualization:

X86_FEATURE_FRED _id – Flexible Return and Event Delivery, replaces IDT, 2025

Additional baseline not in microarchitecture levels but present on all post-2017 CPUs:

adx – multi-precision arithmetic

aes – hardware AES acceleration

apic – APIC on-chip

clflush – CLFLUSH instruction

clflushopt – optimized cache line flush

constant_tsc – TSC ticks at constant rate across P-states and C-states

de – Debugging Extensions

fsgsbase – direct FS/GS base access from userspace

ht – Hyper-threading

invpcid – selective PCID TLB invalidation

mca – Machine Check Architecture

mce – Machine-check exception

msr – Model-Specific Registers (RDMSR/WRMSR)

mtrr – Memory Type Range Registers

nonstop_tsc – TSC does not stop in C-states

nx – No-execute page protection

pat – Page attribute table

pcid – avoids full TLB flush on context switch

pse36 – Page Size Extension (36-bit)

rdrand – hardware random number generator

rdseed – hardware random seed

rdtscp – RDTSCP instruction

sep – SYSENTER/SYSEXIT

smap – blocks kernel accessing user pages

smep – blocks kernel executing user pages

tsc – Time Stamp Counter

x2apic – extended APIC, supports >256 CPUs

x86-64-v4 – AVX-512, ~2017

x86-64-v3 – AVX/AVX2, FMA, BMI, ~2015

x86-64-v2 – SSE3/SSSE3/SSE4, POPCNT, ~2009

x86-64-v1 – SSE/SSE2, required by kernel

Can be disabled at compile time:

CENTAUR_MCR, CYRIX_ARR, ENQCMD, FRED, K6_MTRR, LAM, SEV_SNP, SGX, TDX_GUEST, USER_SHSTK, VME, XENPV

VMX / SVM – hardware virtualization, 2005/2006

📖 References

x86-specific _doc

x86_64 Support _doc

architecture-specific initialization

https://lwn.net/Kernel/Index/#Architectures-x86

ARM

CONFIG_ARM _id – 32-bit, CONFIG_ARM64 _id – 64-bit (AArch64)

arch/arm _src – 32-bit ARM

arch/arm64 _src – 64-bit ARM (AArch64)

ARM big.LITTLE – heterogeneous multiprocessing, see EAS

📖 References

ARM Architecture _doc

ARM64 Architecture _doc

Memory Tagging Extension (MTE) _doc – hardware memory safety

Scalable Vector Extension (SVE) _doc

https://lwn.net/Kernel/Index/#Architectures-ARM