Multitasking functionality

multitasking
processes
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.

Processes

Process is a running user space program. Kernel starts the first process /sbin/init in function run_init_process _idusing kernel_execve _id. Processes occupy system resources, like memory, CPU time. System calls sys_fork _id and sys_execve _id are used to create new processes from user space. The process exit with an sys_exit _id system call.

Linux inherits from Unix its basic process management system calls (⚲ API ↪ ⚙️ implementations):

man 2 fork ↪ kernel_clone _id creates a new process by duplicating the process invoking it.

man 2 _exit ↪ do_exit _id terminates the calling process "immediately". Any open file descriptors belonging to the process are closed.

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

man 2 execve ↪ do_execve _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

Linux enhances the traditional Unix process API with its own system calls 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).

PID - Process identifier defined as pid_t _id is unique sequential number. man 1 ps -A lists current processes. Syscall man 2 getpid ↪ task_tgid_vnr _id return 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 internal historically is 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.

⚲ API:

unistd.h

sys/types.h

sys/wait.h

⚙️ Internals:

task_struct _id

pid_type _id

kernel/fork.c _src

syscalls:

man 2 set_tid_address – set pointer to thread ID

man 2 fork – create a child process

man 2 vfork – create a child process and block parent

man 2 clone – create a child process

man 2 unshare – disassociate parts of the process execution context

kernel/sys.c _src

syscalls:

man 2 prctl – operations on a process or thread

kernel/pid.c _src

syscalls:

man 2 pidfd_open – obtain a file descriptor that refers to a process

man 2 pidfd_getfd – obtain a duplicate of another process's file descriptor

syscalls:

man 2 pidfd_open – obtain a file descriptor that refers to a process

man 2 pidfd_getfd – obtain a duplicate of another process's file descriptor

kernel/exit.c _src

syscalls:

man 2 exit – terminate the calling process

man 2 exit_group – exit all threads in a process

man 2 waitid – wait for process to change state

man 2 waitpid – wait for process to change state

fs/exec.c _src

📖 References:

fork (system call)

exit (system call)

wait (system call)

exec (system call)

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

🔧 TODO: man 2 sigaction man 2 signal man 2 sigaltstack man 2 sigpending man 2 sigprocmask man 2 sigsuspend man 2 sigwaitinfo man 2 sigtimedwait

kernel/signal.c _src

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

Sys V IPC:

Message queues

Semaphores

Shared memory: man 2 shmget, man 2 shmctl, man 2 shmat, man 2 shmdt

📖 References

Inter-process communication

man 7 sysvipc

Threads or tasks

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

💾 History: Till 2.6.39, kernel mode has only one thread protected by big kernel lock.

⚲ API

linux/sched.h _inc - the main scheduler API

task_struct _id

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

current _id and get_current _id () return current task_struct _id

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

linux/thread_info.h _inc

function 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 wake a thread

kthread_create _id

⚙️ Internals

kthread_run _id ↯ hierarchy:

kernel_thread _id

kernel_clone _id

kernel/kthread.c _src

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.

Linux uses the Completely Fair Scheduler (CFS), the first implementation of a fair queuing process scheduler widely used in a general-purpose operating system. CFS uses a well-studied, classic scheduling algorithm called "fair queuing" originally invented for packet networks. The CFS scheduler has a scheduling complexity of O(log N), where N is the number of tasks in the runqueue. Choosing a task can be done in constant time, but reinserting a task after it has run requires O(log N) operations, because the run queue is implemented as a red–black tree.

In contrast to the previous O(1) scheduler, the CFS scheduler implementation is not based on run queues. Instead, a red-black tree implements a "timeline" of future task execution. Additionally, the scheduler uses nanosecond granularity accounting, the atomic units by which an individual process' share of the CPU was allocated (thus making redundant the previous notion of timeslices). This precise knowledge also means that no specific heuristics are required to determine the interactivity of a process, for example.

Like the old O(1) scheduler, CFS uses a concept called "sleeper fairness", which considers sleeping or waiting tasks equivalent to those on the runqueue. This means that interactive tasks which spend most of their time waiting for user input or other events get a comparable share of CPU time when they need it.

The data structure used for the scheduling algorithm is a red-black tree in which the nodes are scheduler specific structures, entitled sched_entity _id. These are derived from the general task_struct process descriptor, with added scheduler elements. These nodes are indexed by processor execution time in nanoseconds. A maximum execution time is also calculated for each process. This time is based upon the idea that an "ideal processor" would equally share processing power amongst all processes. Thus, the maximum execution time is the time the process has been waiting to run, divided by the total number of processes, or in other words, the maximum execution time is the time the process would have expected to run on an "ideal processor".

When the scheduler is invoked to run a new processes, the operation of the scheduler is as follows:

1. The left most node of the scheduling tree is chosen (as it will have the lowest spent execution time), and sent for execution.
2. If the process simply completes execution, it is removed from the system and scheduling tree.
3. If the process reaches its maximum execution time or is otherwise stopped (voluntarily or via interrupt) it is reinserted into the scheduling tree based on its new spent execution time.
4. The new left-most node will then be selected from the tree, repeating the iteration.

If the process spends a lot of its time sleeping, then its spent time value is low and it automatically gets the priority boost when it finally needs it. Hence such tasks do not get less processor time than the tasks that are constantly running.

An alternative to CFS is the Brain Fuck Scheduler (BFS) created by Con Kolivas. The objective of BFS, compared to other schedulers, is to provide a scheduler with a simpler algorithm, that does not require adjustment of heuristics or tuning parameters to tailor performance to a specific type of computation workload.

Con Kolivas also maintains another alternative to CFS, the MuQSS scheduler.

The Linux kernel contains different scheduler classes (or policies). The Completely Fair Scheduler used nowadays by default is SCHED_NORMAL _id scheduler class 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

⚙️ 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

kernel/sched/core.c _src

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

sched_setscheduler _id, sched_getscheduler _id

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

🛠️ Utilities

man 1 pidstat

man 1 pcp-pidstat

man 1 perf-sched

Understanding Scheduling Behavior with SchedViz

📖 References

man 7 sched

Scheduling _doc

CFS

Completely Fair Scheduler _doc

CFS Bandwidth Control _doc

Tuning the task scheduler

stop using CPU limits on Kubernetes

Completely fair scheduler LWN

Deadline Task Scheduler _doc

sched _ltp

sched_setparam _ltp

sched_getscheduler _ltp

sched_setscheduler _ltp

📚 Further reading about the scheduler

Scheduler tracing

bcc/ebpf CPU and scheduler tools

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

📖 References:

Handling wait queues

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

Futex

A man 2 futex ↪ do_futex _id (short for "fast userspace 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 kernelspace wait queue that is attached to an aligned integer in userspace. Multiple processes or threads operate on the integer entirely in userspace (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 a 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.c _src

📖 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 semget

⚙️ Internals: ipc/sem.c _src

Kernel space synchronization

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

Sleeping locks

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.

💾 History: RCU was added to Linux in October 2002. Since then, there are thousandths uses of the RCU API within the kernel including the networking protocol stacks and the memory-management system. The implementation of RCU in version 2.6 of the Linux kernel is among the better-known RCU implementations.

⚲ 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.

⚙️ Internals:

kernel/rcu _src

📖 References:

Avoiding Locks: Read Copy Update _doc

RCU concepts _doc

RCU initialization

Mutexes

⚲ API:

linux/mutex.h _inc

linux/completion.h _inc

mutex _id has owner and usage constrains, more easy to debug then 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

💾 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

local_lock _id, preempt_disable _id

local_lock_irqsave _id, local_irq_save _id

etc

⚲ API:

linux/local_lock.h _inc

📖 References:

Proper locking under a preemptive kernel _doc

Local locks in the kernel

💾 History: Prior to kernel version 2.6, Linux disabled interrupt to implement short critical sections. Since version 2.6 and later, Linux is fully preemptive.

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.

📖 References:

spinlock_t _id

raw_spinlock_t _id

bit_spin_lock _id

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.

💾 History: The semantics stabilized as of version 2.5.59, and they are present in the 2.6.x stable kernel series. The seqlocks were developed by Stephen Hemminger and originally called frlocks, based on earlier work by Andrea Arcangeli. The first implementation was in the x86-64 time code where it was needed to synchronize with user space where it was not possible to use a real lock.

⚲ 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

	on server	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

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/time.h _inc

tm _id

get_timespec64 _id

...

linux/ktime.h _inc

ktime _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

📖 References:

ktime accessors _doc

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

Year 2038 problem

---

⚙️ Locking internals:

kernel/locking _src

timer_list _id wait_queue_head_t _id

atomic operations

asm-generic/atomic.h _inc

atomic_dec_and_test _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

Synchronization (computer science)

Synchronization primitives

Tickless (Full dynticks), CONFIG_NO_HZ_FULL _id

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 (⚙️ do_IRQ _id).

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 function to allocate an interrupt line for a managed device with a threaded ISR

request_irq _id, free_irq _id - old and common functions to add and remove a handler for an interrupt line

linux/interrupt.h _inc

⚙️ Internals:

irq_desc _id, irq_data _id

kernel/irq _src

📖 References

IRQs _doc

Linux generic IRQ handling _doc

Interrupts

IRQ affinity

⚲ API

/proc/irq/default_smp_affinity

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

Common functions:

irq_affinity _id

irq_set_affinity _id

irq_get_affinity_mask _id

irq_can_set_affinity _idirq_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_desc _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

Deferred works

Scheduler context

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

📖 References

request_threaded_irq _doc

Work

work is a workqueue wrapper

⚲ API:

linux/workqueue.h _inc

work_struct _id, INIT_WORK _id, schedule_work _id,

delayed_work _id, INIT_DELAYED_WORK _id, schedule_delayed_work _id, cancel_delayed_work_sync _id

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

⚙️ Internals: system_wq _id

Workqueue

⚲ API:

linux/workqueue.h _inc

workqueue_struct _id, alloc_workqueue _id, queue_work _id

⚙️ Internals:

workqueue_init _id, create_worker _id, pool_workqueue _id

kernel/workqueue.c _src

📖 References:

Concurrency Managed Workqueue _doc

Interrupt context

linux/irq_work.h _inc – framework for enqueueing and running callbacks from hardirq context

samples/trace_printk/trace-printk.c _src

Timers

softirq timer

This timer is a softirq for periodical tasks with jiffies resolution

⚲ API:

linux/timer.h _inc

timer_list _id, DEFINE_TIMER _id, timer_setup _id

mod_timer _id — sets expiration time in jiffies.

del_timer _id

⚙️ Internals:

kernel/time/timer.c _src

👁 Examples:

input_enable_softrepeat _id and input_start_autorepeat _id

High-resolution timer

⚲ API

linux/hrtimer.h _inc

hrtimer _id, hrtimer.function — callback

hrtimer_init _id, hrtimer_cancel _id

hrtimer_start _id starts a timer with nanosecond resolution

👁 Example watchdog_enable _id

⚙️ Internals

CONFIG_HIGH_RES_TIMERS _id

kernel/time/hrtimer.c _src

📚 HR timers references

hrtimers - subsystem for high-resolution kernel timers _doc

high resolution timers and dynamic ticks design notes _doc

---

📚 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

cat /proc/softirqs

open_softirq _id registers softirq_action _id

⚙️ Internals:

kernel/softirq.c _src

⚲ API:

linux/interrupt.h _inc

📖 References:

Introduction to deferred interrupts (Softirq, Tasklets and Workqueues)

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/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

linux/cpufreq.h _inc

linux/cpuhotplug.h _inc – CPU hotplug states

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

linux/peci-cpu.h _inc

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

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

⚙️ Internals

drivers/cpufreq _src

intel_pstate _id

acpi_cpufreq_driver _id

drivers/cpuidle _src

Cache

linux/cacheflush.h _inc

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

linux/cache.h _inc

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

⚙️ Internals

arch/x86/mm/pat/set_memory.c _src

📖 References

Working-State Power Management _doc

https://www.thinkwiki.org/wiki/How_to_use_cpufrequtils

cpufreq _ltp

SMP

This chapter is about multiprocessing and muti-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.

🗝️ Key terms

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

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

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

man 8 chcpu – configure CPUs

man 3 CPU_SET – macros for manipulating CPU sets

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.h _inc

linux/cpuset.h _inc – cpuset interface

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

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

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

⚙️ Internals

cpuset_init _id

cpu_number _id

cpus_mask _id – affinity of task_struct _id

CONFIG_SMP _id

CONFIG_CPUSETS _id

CONFIG_CPU_ISOLATION _id

CONFIG_NUMA _id

trace/events/percpu.h _inc

IPI – Inter-processor interrupt

trace/events/ipi.h _inc

kernel/irq/ipi.c _src

ipi_send_single _id, ipi_send_mask _id ...

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

kernel/cpu.c _src

🛠️ Utilities

irqbalance – distributes hardware interrupts across CPUs

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

📖 References

CPUSETS of cgroup v1 _doc

CPU lists in command-line parameters _doc

📚 Further reading

CPU hotplug in the Kernel _doc

CPU Partitioning

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

CPU Isolation

Functionalities of the scheduler TuneD plugin

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

kernel/sched/membarrier.c _src

📖 References

Memory barriers _doc

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,

⚙️ Arch internals

arch _src

x86

CONFIG_X86 _id

arch/x86 _src

drivers/platform/x86 _src

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

ARM

CONFIG_ARM _id

arch/arm _src, ARM Architecture _doc

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

arch/arm64 _src, ARM64 Architecture _doc

architecture-specific initialization

📖 References

CPU Architectures _doc

x86-specific _doc

x86_64 Support _doc

📚 Further reading about multitasking, scheduling and CPU

bcc/ebpf CPU and scheduler tools