A glossary of various terms and acronyms related to the Linux kernel. If you know something, please create yourself an account (UserPreferences) and add a term in alphabetical order. Don't be afraid to improve other people's explanations, the goal is to have a high quality document for the readers of this site. If everybody who reads this page adds a term each week, this glossary should be complete within a few months...
If you don't find the definition of the term or acronym that you're looking for on this page, you might try the following:
[http://foldoc.doc.ic.ac.uk Free On-Line Dictionary Of Computing]
[http://hissa.nist.gov/dads/ Dictionary of Algorithms, Data Structures, and Problems]
[http://www.xanalys.com/software_tools/mm/glossary/full.html Memory Management Glossary]
- 2Q algorithm
- MM algorithm based on two areas, one managed as a FIFO queue, and one as an LRU list.
- 8259 PIC
- Outdated interrupt controller present on Intel hardware.
Application Binary Interface, the interface of passed structures between the user processes (and libraries) and the kernel. For compatibility, it is important that these remain as static as possible (i.e. making sure that variables and structure members have the same bytesize as before, and in the same ordering). Occasionally breakage is necessary, requiring re-compilation of the user-space sources (note that this does not affect source-compatibility; that is a separate issue).
Advanced Configuration and Power Interface, replacement for APM that has the advantage of allowing O/S control of power management facilities.
Address Generation Interlocking, on x86. When execution of an instruction requires an address resulting from a non-completed instrcution, the CPU must wait - this is known as an AGI stall.
Accelerated Graphics Port, on x86 boxes.
Asynchronous IO, IO that is performed without the issuing process blocking on IO completion.
- Anticipatory Scheduler
- A disk IO scheduler that leaves the disk idle after a read, in anticipation of the next read.
- Generally, used for something which doesn't have the usual associated object. For example an anonymous address space is not interested in user address space (that is, no process context). Some common ones are :
- Anonymous page
- A page of memory that is not associated with a file on a file system. This can come from expanding the process's data segment with brk(), shared memory segments, or mmap() with a MAP_ANON or MAP_PRIVATE flag. MAP_PRIVATE, although it maps in data from a file, is considered anonymous because any changes do not get written back to the file (any dirty pages have to be moved to swap if the page is freed from main memory).
- Anonymous buffer
- The buffer cache contains buffers of data on their way to/from the disk. An anonymous buffer is not associated with a file. One example of this is data from a deleted file - it will not be written to any file, but is kept around until it is flushed.
- See local APIC and IO-APIC.
Advanced Power Management, power management standard superceded by ACPI. APM and SMP just don't mix.
Address Resolution Protocol and this is how a network machine associates an IP Address with a hardware address.
Abstract Syntax Notation, a protocol for structured data, used, for example, in the Q.3 managament protocol.
Professor Andrew S. Tanenbaum, writer of MINIX and several essential O/S books.
ATA Packet Interface, used by most CD-ROMs, and other devices.
- Technique used in the VM code, referring to balancing various parameters such as the number of pages currently free, to avoid thrashing and other bad memory capacity artefacts. See zones, kswapd bug.
Base Address Registers, for PCI devices.
Binary-Coded Decimal - see a textbook.
- See highmem.
- big lock
- kernel_lock, which locks the entire kernel from entry (no other task may run in the kernel code). It is recursive per process and dropped automatically when a process gives up the CPU, then regained on wake-up, in contrast to other spinlocks.
- bit error
- Used colloquially to mean a single bit error in some memory address. Often due to faulty memory (ECC memory can correct single bit errors). Often results in fake oopsen, with addresses like 0x0008000. Also seen are values some small offset from zero, plus a bit error, which is where the value passed a NULL check due to the bit error, and then the kernel tried to access a structure member by means of the pointer, leading to the offset.
- block bitmap
- In UNIX-like filesystems, the usage of disks blocks is recorded in the block bitmap, where each set bit indicates a specific allocated block.
- bottom-half handler
- A set of standard kernel threads that execute tasks on a queue that have been registered with that type of bottom-half handler for execution. The code is run on return to user space or at the end of a hardware interrupt. In 2.3.43 a more general solution with softirqs and tasklets was implemented. Sometimes abbreviated to "bh", which should not be confused with buffer head, which is also abbreviated to "bh".
- bounce buffer
- An intermediate buffer. Used for example, in "faking" alignment to a client from non-aligned resources.
- Big-reader locks, used when there are many contending for read access to a resource, and very few contending for writes (thus the balance is towards very fast read locking, and very slow write locking).
BootStrap Processor, or the CPU which enables the other CPUs in an SMP system.
Block Storage Segment. This is the memory mapping section containing the data allocated for a binary image at execution time. Also known as "Block Started by Symbol" and "Bull-Shit Storage".
Branch Target Buffer, on x86 processors, the cache of recent conditional jump results.
- buddy allocator
- The memory allocation scheme used in the kernel. A vector of lists of free pages is kept, ordered by the size of the chunk (in powers of two). When a chunk is allocated, it is removed from the relevant list. When a chunk is freed back to the free pages pool, it is placed in the relevant list, starting from the top. If it is physically contiguous with a present chunk, they are merged and placed in the list above (i.e. where the chunks are twice the size), and this operation percolates up the vector. As regions are merged whenever possible, this design helps to reduce memory fragmentation. FIXME
- buffer cache
- The buffer cache is a hash table of buffers, indexed by device and block number. LRU lists are maintained for the buffers in the various states, with separate lists for buffers of different sizes. With 2.3's unification of the buffer and page caches, each buffer head points to part or all of a page structure, through which the buffer's actual contents are available. FIXME
- buffer head
- A structure containing information on I/O for some page in real memory. A buffer can be locked during I/O, or in several other states depending on its usage or whether it is free. Each buffer is associated with one page, but every page may have several buffers (consider the floppy on x86, where the I/O blocksize is 512 bytes, but each page is commonly 4096 bytes).
- Used in kernel code in tests for "impossible" conditions. Signify a kernel bug or faulty hardware.
- bus mastering
- Giving a card on a bus (e.g. ISA,PCI) the ability to read/write directly to main memory. This is how DMA is performed on PCI busses.
- byte sex
- cache affinity
- Where the cache of a CPU represents the current memory set used by a task, there is said to be cache affinity with that task. A good thing if the task is regularly scheduled on that CPU. See processor affinity.
- cache coherency
- On an SMP system, ensuring that the local memory cache of each CPU is consistent with respect to the values which may be stored in other CPUs' caches, avoiding coherency problems such as the "lost update". This is acheived by the hardware in concert with the operating system.
- cache line
- A section of the hardware cache, around 32 bytes large. Kernel structures are often designed such that the commonly-accessed members all fit into one cache-line, which reduces cache pollution. Structures such as this are cache line aligned.
- cache ping-pong
- A hardware phenomenon in an SMP system, where two tasks on different CPUs are both accessing the same physical memory in a cache line. This means as each task runs, when it changes the memory, it must invalidate the other CPU's relevant cache line (to ensure cache coherency). Then, when the task on the other CPU runs, it must reload the cache line (as it's set invalid), before changing it. Repeat ad jocularum. A bad thing (TM). A common reason for putting a lock on a different cache line than the data mutexed by the lock : then the "other" task can grab and drop the lock without having to necessarily invalidate the cache line on the first CPU. FIXME
- cache pollution
- Where during execution of a task, another task is scheduled onto that CPU which disrupts useful lines of the current cache contents, which will be used soon. That is, cache pollution is a non-optimal situation where the other process would have been bettered scheduled on a different CPU or at a different time. The aim is to minimise the need to replace cache lines, obviously increasing efficiency.
- call gate
- x86 hardware support for mode switch to kernel (i.e. system call). In Linux, int 0x80 will trigger the call gate.
- These are defined names of capabilities for specific tasks provided by the kernel, e.g. CAP_SYS_NICE.
Class Based Queueing, a hierarchical packet fair queueing qdisc. [http://www.icir.org/floyd/cbq.html CBQ Homepage]
- chroot jail
- A process under the aegis of a chroot() syscall is in a chroot jail, and cannot access the file system above its notion of root directory /.
- (also: filter or tcf) classifies a network packet by inspecting it, used by QDiscs.
- x86 assembler instructions for disabling and enabling interrupts, respectively. There are CPU-local and global variants of these. Code running with interrupts disabled must be fast, for obvious reasons (this is called interrupt latency).
Eric Raymond's proposal for a replacement to the current kernel build system. See http://www.tuxedo.org/~esr/kbuild.
- cold cache
- A cache whose content is invalid or irrelevant with respect to some task to be run.
- completion ports
- I/O interface used in O/S's such as Windows NT. Userspace notifies the kernel of each file descriptor the program is interested. The O/S uses a callback for each fd to indicate that I/O is ready.
- Where two tasks each want an exclusive resource. You may hear talk of, for example, spinlock contention, which is where one or more tasks is commonly busy-waiting for a spinlock to become unlocked, as it is being taken by other tasks.
- Context switch
- switching the CPU from running one thread to running another thread. Refers to the changes necessary in the CPU when the scheduler schedules a different process to run on the CPU. This involves invalidating the TLB, loading the registers with the saved values, etc. There is an associated cost with such a switch, so it is best to avoid un-necessary context switch when possible. Note that the division of kernel-mode and user-mode means a similar, but simpler, operation is necessary when a syscall moves into kernel mode. However this is not called a context switch, as the mode switch doesn't change the current process. See lazy TLB. One good of feature of Linux is its extremely low context and mode switch cost, compared to an operating system like Solaris.
- (also: COW) reuse and share existing objects and copy them not until a modification is required. Copy-On-Write, efficiency method where a page or other resource is shared until an attempt to write is made. In that case a copy is made, and the write is done to the copy.
Current Privilege Level
- critical path
- A vital code path which should be optimised for the common case. Critical paths are executed frequently and form the important trunk routes of various kernel operations. An example would be buffer head manipulation during file I/O.
Code Storage Segment, aka text section. This is the memory mapping containing the executable code (text) for a binary image.
- a kernel variable which points to the task_struct structure of the process currently running on this CPU.
- Device Mapper
- A technology for presenting arbitrary groupings of underlying sectors on physical devices in a consistent logical fashion usable by higher level algorithms. Heavily used by kernel technologies such as LVM.
- Debugging Information Format
Executable Linkable Format, a popular binary format, the default for Linux on most architectures.
- Extended Match, small classification helper attached to classifiers.
GRand Unified Bootloader, a popular bootloader for Linux, BSD, and other OSes.
Hierachical Token Bucket, a qdisc based on TBF and CBQ. [http://luxik.cdi.cz/~devik/qos/htb/manual/theory.htm HTB Theory]
Interrupt Service Routine, the function in each device driver that gets called when an interrupt happens.
- An incrementing counter representing system "uptime" in ticks - or the number of timer interrupts since boot. Ultimately the entire original concept of a jiffy will likely vanish as systems use timer events only when necessary and become "jiffyless".
- a kernel thread that frees up memory by evicting data from caches and paging out userspace memory, part of the virtual memory subsystem.
- Linux Device Drivers, 3rd Edition
[http://lwn.net/Kernel/LDD3/ online edition].
Linux Kernel Module. A (often dynamically loadable at system runtime) kernel extension ("driver") to support, for example, some kind of new hardware device or generic software abstraction.
Linux Kernel Mailing List. The primary virtual watering hole (meeting ground) for kernel developers to share ideas and bounce opinions off oneanother during the course of the kernel development process. FAQ at [http://www.tux.org/lkml/].
- Linux Security Module. a security framework for providing different security levels.
Logical Volume Management. A technology for providing an arbitrary logical view of underlying data storage in a fashion supporting resizing and restructuring of storage on the fly. Currently in version 2, originally written by Sistina (now Redhat).
a cross-reference tool that can be used to navigate the Linux kernel source code, available at [http://lxr.linux.no/ lxr.linux.no].
- A contiguous virtual array of struct pages representing the entirity of physical memory pages available within a system.
Memory Management Unit, part of the CPU that is needed for virtual memory.
- Communication protocol between kernel and userspace
- Page cache
- a cache of file data and filesystem metadata, dynamically grown an shrunk depending on other memory use.
- Page table
- data structure used by the MMU to translate virtual memory addresses to physical memory addresses.
Page Frame Number, index into the mem_map array which describes physical memory pages.
Page Global Directory, the top level of the page table tree. The page table hierarchy is pgd -> pud -> pmd -> pte.
Process IDentifier (POSIX thread identifier)
Page Mid-level Directory, note that pmds are folded into pgds on systems with 2 level page tables.
- Process descriptor
- kernel data structure that describes/accounts process data related to a single process.
Page Table Entry
Page Upper Directory, note that puds are folded into pmds, except on systems with 4-levels page tables.
[http://lartc.org/howto/lartc.qdisc.html Queueing Discipline], queues packets before they are sent out to the network device, enforces QoS requirements, provides traffic shaping and prioritizing capabilities.
Quality of Service, method to define the importance/priority of network services
Read Copy Update, a mechanism for ["SMPSynchronisation"]
- resource limit, eg. "maximum amount of virtual memory" or "maximum number of processes". Can be per process or per user.
- a lock mechanism that works per process context, see ["SMPSynchronisation"]
the part of the kernel that chooses a suitable process to run on the cpu, see the [http://lxr.linux.no/ident?i=schedule schedule()] function.
- Shared/Paged Socket Buffer
- (also: pskb) Socket Buffer with uncontinuous data buffer, used for zero copy, TSO and Scatter/Gather capable network cards.
- Slab cache
- a fast, SMP scalable kernel memory allocator.
- Socket Buffer
- (also: skb) data structure used to hold the data and attributes of a network packet.
- kind of bottom half rarely used.
- Spin lock
- a simple SMP lock, see ["SMPSynchronisation"]
- Swap token
a token to temporarily protect a process from pageout, an alternative approach to memory scheduling, thrashing control. See the [http://www.cs.wm.edu/~sjiang/token.pdf Token Based Thrashing Control] paper by Song Jiang and the [http://linux-mm.org/wiki/SwapTokenTuning Linux-MM wiki].
- System call
- (also: syscall) the way a program transitions from userspace into kernel space, to call a kernel space function.
- symbol table used by ksymoops to resolve numbers to function names in Oops. Also used by ps and top for WCHAN field.
- State of the task that can run but is not necessarily running.
Token Bucket Filter, a qdisc used for rate limiting
Task Group IDentifier (POSIX process identifier)
the page replacement algorithm used by the Linux 2.6 kernel, based on the ideas behind the 2Q page replacement algorithm, also see the [http://linux-mm.org/wiki/AdvancedPageReplacement AdvancedPageReplacement] page.
Anchor(VDSO)Virtual Dynamically-linked Shared Object, a kernel-provided shared library that helps userspace perform a few kernel actions without the overhead of a system call, as well as automatically chosing the most efficient syscall mechanism. Also called the "vsyscall page".
Virtual File System, an interface through which multiple filesystems can be hooked into the kernel.
- Virtual memory
- every process in the system gets its own memory address space, independant of the other processes.
- Vsyscall page
- see [#VDSO VDSO].
A paravirtualisation engine for Linux, an efficient way to run multiple Linux OSes on one computer. Also runs BSD, Plan9 and other OSes. (See [http://xen.sf.net website] for more information.)
eXecute In Place, the ability to run an executable directly from the filesystem (usually ROM or flash), instead of loading it into memory.
- A special networking code path where data is sent to the network directly from userspace memory; this avoids unnecessary copying of data and improves performance.