The Linux glossary

The privileged core that manages resources and exposes interfaces to userspace.

Programs and libraries running outside the kernel's privileged execution context.

A userspace command interpreter that starts programs and connects their input and output.

An executing program and its associated resources; Linux represents execution with tasks.

A process-local integer referring to an open file description through its descriptor table.

A kernel open-file object holding state such as file offset and status flags, potentially shared by descriptors.

A filesystem object describing a file independently of any particular pathname.

A cached association between a name and an inode or a negative lookup result.

Owner, group and other access bits interpreted with credentials, ACLs and other access controls.

A process setting that removes permission bits from the mode requested when creating an object.

A value used to designate an object or function; validity depends on type, bounds and lifetime.

The interval during which an object exists and may be accessed under its ownership rules.

A count used to retain an object while references exist; it does not serialize arbitrary mutations.

A synchronization mechanism that protects an invariant or coordinates access; it does not by itself own an object.

The executable and linkable format used for many Linux executables, shared libraries and modules.

A binary contract such as calling conventions, data layout and syscall interfaces, scoped to an architecture and environment.

An entry point through which userspace requests a service from the kernel under an ABI.

An address interpreted in an address space through page tables and architecture translation rules.

An address in the machine's physical address space, distinct from a process virtual address and a device DMA address.

An address supplied to a device by the DMA API; it need not equal a CPU physical address.

Hardware and associated kernel support translating or restricting device DMA accesses.

A processor cache of address translations that must be maintained when relevant mappings change.

A unit of cache transfer and coherence whose size depends on the machine.

The effective Kconfig selections used to build a particular kernel and its features.

The kernel build system's make-based rules for configuration, compilation, linking and generated files.

An optional loadable kernel object subject to symbol, version, configuration and security checks.

An early root filesystem unpacked from an archive, often providing the first userspace init program.

The first userspace process in a PID namespace, with special process-reaping and signal responsibilities.

The kernel scheduling entity represented by a task structure; a process can contain several tasks.

Tasks sharing a process identity in userspace, while each task has its own thread ID.

A strategy that shares data until a write requires an appropriately private copy.

Per-CPU scheduler state holding runnable entities and scheduling-class information.

The fair scheduler's eligible-entity and virtual-deadline selection approach in the v6.12 baseline.

Scheduling policies such as FIFO and RR that use real-time priorities and have resource and privilege constraints.

A per-thread CPU eligibility mask constrained by online CPUs and applicable cpuset rules.

A kernel interrupt identity or interrupt request, distinct from an architecture's hardware vector or interrupt number.

A kernel deferred-interrupt mechanism with context restrictions; its execution is not the same as a workqueue callback.

A facility that runs queued work in worker-thread context with queue-specific concurrency rules.

A counter used to measure elapsed time, converted into time units by timekeeping code.

A hardware or virtual event source programmed to deliver a future timing interrupt.

A sleeping lock with ownership and context rules, used where blocking is permitted.

A lock whose precise implementation and context semantics depend on kernel configuration, including PREEMPT_RT.

A synchronization primitive that records completion events and allows waiters to sleep until an event or timeout.

Constraints on the visibility and order of accesses across compilers and CPUs, beyond individual access atomicity.

An indivisible update operation whose ordering guarantees depend on the specific primitive and outcome.

A synchronization family that permits readers to access protected objects while reclamation waits for a grace period.

An RCU interval sufficient to wait for relevant pre-existing read-side critical sections, under that RCU flavor's rules.

Optional kernel instrumentation that checks observed lock dependencies and context rules for potential deadlocks.

A real-time kernel configuration that changes preemption and the behavior of some locking and interrupt paths.

A process memory view described by an mm structure, VMAs and page tables, subject to sharing rules.

A virtual memory area describing a contiguous range with common mapping properties in an address space.

Architecture-specific translation structures mapping virtual addresses to physical memory or other entries.

An exception requiring the kernel to resolve an access or deliver an error such as a signal.

A physically contiguous, power-of-two group of base pages managed as a unit in many memory paths.

A base unit of memory management whose size and mapping details depend on architecture and configuration.

The physical page allocator that splits and combines power-of-two blocks subject to zones and other constraints.

Allocation flags describing permitted reclaim behavior, context and allocation constraints.

The process of finding memory that can be freed or reused, potentially involving writeback or swap.

Backing storage for eligible anonymous memory pages, distinct from a guarantee that every page can be evicted.

A mechanism that selects a victim under certain unrecoverable memory-allocation constraints.

A machine organization in which memory access cost and allocation policy depend on nodes and topology.

A larger memory allocation or mapping managed opportunistically, subject to configuration and workload conditions.

An explicit huge-page facility with its own pool and accounting semantics, distinct from transparent huge pages.

A kernel allocator for objects, typically using caches backed by pages.

An allocator for virtually contiguous kernel memory that need not be physically contiguous.

Data with CPU-specific instances used to reduce sharing or support CPU-local state.

The kernel cache of file-backed data, represented in modern paths using folios.

The process of submitting dirty cached data or metadata to backing storage; completion is not automatically application durability.

The virtual filesystem layer that presents common file and filesystem interfaces above individual implementations.

A namespace providing a view of mount topology, subject to propagation and sharing rules.

A filesystem log used to support recovery of selected updates after failure, with behavior determined by the filesystem and mode.

A storage command or operation requesting ordering or persistence of prior writes according to the device contract.

Force Unit Access, a write property requesting persistence for that write under the relevant device contract.

A block-layer I/O description containing data segments and operation metadata.

The block layer's multiqueue infrastructure for dispatching requests to device drivers.

A framework for constructing virtual block devices from configurable mapping targets.

An interface requesting synchronization of file data and relevant metadata, with filesystem and device semantics.

A kernel-buffered unidirectional byte stream connecting file descriptors.

A file descriptor referring to a process for supported operations without relying solely on a reusable numeric PID.

A userspace synchronization interface that lets the kernel coordinate waits on a userspace memory word.

A readiness notification interface for monitoring registered file descriptors.

A shared-ring interface for submitting asynchronous operations and receiving completions.

An endpoint interface for communication whose semantics depend on protocol and socket type.

A kernel packet-buffer structure carrying packet data and metadata through networking paths.

A connection-oriented transport protocol providing an ordered byte stream with reliability and congestion control.

A datagram transport protocol that does not itself provide TCP's ordered reliable byte stream.

A socket-based messaging interface used by userspace and kernel subsystems for configuration and notifications.

A networking mechanism that combines interrupts and polling to process packets with bounded work.

A framework of packet-processing hooks used by filtering, connection tracking and related facilities.

An early network packet processing interface, commonly attached to a device receive path.

A namespace providing an isolated network-stack view, including interfaces and routing state.

A kernel object used in parts of the device model to support lifetime and sysfs representation.

A hardware-description format used by many systems to describe devices and their relationships to software.

Firmware-provided tables and interfaces used to describe and manage hardware on supported systems.

A device interconnect with enumeration, configuration space and resource assignment mechanisms.

A message-signaled interrupt, delivered as a device-originated message rather than a dedicated interrupt wire.

The terminal subsystem interface supporting terminal devices, line disciplines and related process semantics.

A USB request block describing an asynchronous USB transfer and its completion.

A general-purpose input/output line controlled through a hardware-specific controller and kernel interfaces.

Device power management during normal operation, distinct from whole-system suspend.

The Direct Rendering Manager subsystem for graphics devices, display management and related interfaces.

A framework for sharing buffers between devices and subsystems with explicit synchronization needs.

The Linux sound subsystem exposing audio devices and stream interfaces.

A userspace API and subsystem for video capture and related media devices.

The Linux wireless configuration framework used by wireless drivers and userspace interfaces.

The Industrial I/O subsystem for sensors, converters and related data acquisition devices.

The Memory Technology Device subsystem for raw flash and similar memory technologies.

A framework for managing supported remote processors and their firmware lifecycles.

Kernel infrastructure for writing supported components in Rust alongside C, subject to version and configuration limits.

A kernel representation of a task's security identities and related authority.

A fine-grained privilege checked in an applicable user namespace and security context.

The Linux Security Module framework through which security modules participate in access decisions.

A facility for restricting a task's system calls according to an installed policy.

A kernel-managed collection of keys subject to lifetime and permission rules.

Integrity Measurement Architecture, a framework for measuring or appraising selected system objects.

A kernel mechanism providing a scoped view of selected resources to a set of processes.

A hierarchical mechanism for organizing processes and applying supported resource controllers.

Pressure Stall Information, metrics describing time lost to contention for resources such as CPU, memory and I/O.

Kernel virtualization infrastructure that supports guest execution with architecture-specific hardware assistance.

A standardized family of paravirtual device interfaces for communication between guests and implementations.

A framework exposing supported devices to userspace under device and IOMMU isolation constraints.

A kernel facility for loading verified programs for supported programmable hooks and related uses.

The kernel component that checks a BPF program against safety and context rules before acceptance.

BPF Type Format, metadata describing types used by BPF tooling and other kernel interfaces.

Compile Once, Run Everywhere, a BPF relocation approach using type metadata to adapt to compatible kernels.

An instrumentation site that exposes defined event data when tracing is enabled.

A performance-event infrastructure and userspace tool family for observing supported events.

A crash-dump mechanism that boots a capture kernel to preserve memory from a crashed kernel.

A kernel sanitizer that detects classes of invalid memory access when configured and exercised.

An in-kernel unit-testing framework for exercising selected kernel code.

A collection of userspace-driven kernel tests covering particular interfaces and behaviors.

Automated generation of inputs to explore behaviors and find failures, with coverage and environment limits.

A testable explanation that predicts how an intervention or controlled comparison will change an observation.

A userspace packaging and isolation arrangement typically combining namespaces, cgroups and other controls.

A statement of assets, attacker capabilities, trust boundaries and assumptions used to evaluate defenses.

A mechanism for applying supported kernel function changes while the kernel is running, with consistency constraints.

A behavior that became incorrect or worse relative to a specified earlier baseline and test conditions.

A systematic search through ordered revisions to locate a change associated with a reproducible behavior.

A libc mechanism for selecting configured sources for name and service lookups.

A framework through which applications invoke configured authentication, account, credential and session modules.

An authorization framework through which services can ask about a subject performing a named action.

A typed messaging protocol used by applications and services, often through a message bus.

A bus-assigned name identifying one connection for that connection's lifetime.

A named configuration and runtime object managed by systemd, such as a service or socket.

A manager operation requested for a unit, with its own state and result.

A unit grouping externally created processes for management and accounting.

A unit organizing a hierarchical group of units for resource management.

The configured event by which a service manager considers startup complete; it may differ from application health.

Userspace device-event processing that applies rules and maintains device properties.

A systemd service that manages session, user and seat state under configured policy.

A time-limited allocation of network configuration whose renewal and expiry follow protocol and client rules.

A resolver's candidate context for a query, such as a link and its associated routing domains.

A domain used to select a DNS routing scope without necessarily being a search suffix.

A system of DNS data validation using signatures and chains of trust, distinct from transport encryption.

A family of encrypted-storage metadata formats supporting keyslots and volume-key management.

Metadata and protected key material used to unlock an appropriate volume key with a credential.

A kernel-to-userspace filesystem interface in which a daemon handles supported filesystem requests.

A count of kernel lookup references communicated to a low-level filesystem daemon and reduced through forget operations.

A file-transfer protocol carried over SSH that has its own request, handle and server semantics.

A server key whose verified association with an intended host supports server authentication.

A process that can perform permitted signing operations using managed keys without exporting their private material.

A protocol object identified within a client connection and used for requests and events under an interface.

A client-facing object whose committed state is interpreted by a compositor for presentation.

A protocol object referring to image storage whose reuse depends on the applicable release and synchronization rules.

A protocol-provided identifier used to associate certain requests or acknowledgments with events; scope depends on the protocol.

A protocol notification that permits buffer reuse under the applicable release and synchronization contract.

A display server component that combines or presents client surfaces and routes input according to its policy.

An X server that runs as a Wayland client to support X11 applications in a Wayland environment.

A kernel-mediated grant of selected display resources to a lessee for permitted display operations.

A graphics synchronization approach that communicates dependencies or completion through explicit synchronization objects.

The conversion of text and script context into positioned glyph selections for a font and layout.

GLib's object system providing type, reference and lifecycle mechanisms used by many GTK applications.

An event-dispatch context managing sources and callbacks under GLib's ownership and threading rules.

A Qt object supporting ownership relationships, events and signal-slot behavior under Qt's threading rules.

A mediated interface through which applications request selected desktop resources or actions from a backend.

An asynchronous portal operation with an identity, response and cancellation lifetime.

One sample for each channel at a single instant in a PCM audio stream.

A stream underflow or overflow condition indicating that audio data was not supplied or consumed in time.

A typed data representation used by PipeWire's SPA interfaces to describe structured values and parameters.

A graph object that participates in processing or routing media through its ports.

An endpoint on a PipeWire node through which graph data can flow.

A graph relationship connecting compatible ports under the active graph and policy.

A number of frames processed per graph scheduling cycle under a particular configuration.

A PipeWire session manager that applies configured policy to graph objects and routing.

Linux userspace Bluetooth protocol and service software with interfaces used by clients and integrations.

A chain or graph of components passing media buffers and events through processing stages.

A collection of protocols and implementations for real-time communication whose capture and network boundaries require separate permissions.

A combination of isolation and policy mechanisms that restricts an application's access under a stated threat model.

Software that creates and starts containers from an OCI runtime configuration and associated filesystem bundle.

QEMU Machine Protocol, a structured interface for controlling and observing supported QEMU operations.

Internet Printing Protocol, a protocol for submitting and managing print jobs and printer information.

A write-ahead log mode in which changes are recorded in a separate log before later checkpointing into the database.

A directory containing Wine configuration and Windows-like state; it is not a security sandbox.

An executable and object-file format used by Windows programs and supported by compatibility loaders.

A Windows-facing library layer whose Wine implementation bridges selected NT interfaces to Wine and Unix-side components.

A Wine process that manages selected shared objects and coordination for clients associated with its environment.

A process-scoped reference to a Wine-managed object, subject to access checks and object lifetime rules.

A Windows compatibility environment for running supported 32-bit code on a 64-bit system, with implementation-specific boundaries.

Structured Exception Handling, a Windows exception mechanism mapped by compatibility implementations under architecture-specific rules.

A component model with interface, reference-counting and apartment rules for supported Windows APIs.

A project translating supported Direct3D interfaces to Vulkan, with version and feature limitations.

A project implementing supported Direct3D 12 functionality using Vulkan and related runtime components.

A compatibility distribution combining Wine-derived and other components for supported Steam runtime use cases.

A declaration of an external symbol or library dependency used during PE image loading and resolution.

A conformance-oriented test of selected Wine behavior under its recorded environment, not proof of universal Windows compatibility.