KernelTerimler - Kernel Yenileri

Kernel ile ilgili kısaltmaları ve çeşitli kavramları içeren bir terimler sözlüğüdür. Bir şeyler biliyorsanız, lütfen kendinize bir hesap yaratın (UserPreferences) ve abecesel sırada bir kavram ekleyin. Diğer kişilerin açıklamalarını genişletmekten korkmayın, hedef bu siteyi okuyanlar için yüksek nitelikte bir belge oluşturmak. Eğer bu sayfayı okuyan herkes her hafta bu sayfaya bir kavram eklerse,bu terimler sözlüğü birkaç ayda tamamlanır... Eğer aradığınız kısaltma ya da tanımı bulamadıysanız,aşağıdaki bağlantılara bakabilirsiniz:

Indeks

0-9

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.

A

ABI: 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).
ACPI: Advanced Configuration and Power Interface, replacement for APM that has the advantage of allowing O/S control of power management facilities as well exporting the set of hardware currently present on the system.
AGI: Address Generation Interlocking, on x86. When execution of an instruction requires an address resulting from a non-completed instruction, the CPU must wait - this is known as an AGI stall.
AGP: Accelerated Graphics Port, on x86 boxes.
AIO: 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.
anonymous: 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.
APIC: See local APIC and IO-APIC.
APM: Advanced Power Management, power management standard superseded by ACPI. APM and SMP just don't mix.
ARP: Address Resolution Protocol and this is how a network machine associates an IP Address with a hardware address.
ASN.1: Abstract Syntax Notation, a protocol for structured data, used, for example, in the Q.3 management protocol.
ast: Professor Andrew S. Tanenbaum, author of MINIX and several essential O/S books.
ATAPI: ATA Packet Interface, used by most CD-ROMs, and other devices.

B

balancing: 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.
BAR: Base Address Registers, for PCI devices.
BCD: Binary-Coded Decimal - see a textbook.
bigmem: 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.
brlocks: 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).
BSP: BootStrap Processor, or the CPU which enables the other CPUs in an SMP system.
bss: 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".
BTB: 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).
BUG(): 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: Endianness.

C

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 achieved 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.
CAP_*: These are defined names of capabilities for specific tasks provided by the kernel, e.g. CAP_SYS_NICE.
CBQ: Class Based Queueing, a hierarchical packet fair queueing qdisc. CBQ Homepage
CFQ: Completely Fair Queueing, an alternative to the Anticipatory IO scheduler (and the default from 2.6.18 onwards) which allocates IO priority equally between processes.
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 /.
Classifier: (also: filter or tcf) classifies a network packet by inspecting it, used by QDiscs.
cli/sti: 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).
CML2: 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.
contention: 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.
Copy-on-Write: (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.
CPL: 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.
CSS: Code Storage Segment, aka text section. This is the memory mapping containing the executable code (text) for a binary image.
Current: a kernel variable which points to the task_struct structure of the process currently running on this CPU.

D

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.
DAG: Directed Acyclic Graph
dancing makefiles: An experimental new Makefile set up for configuring and compiling the kernel, written by Michael Elizabeth Chastain.
dcache: The cache of dentry structures. Under UNIX an entry in a particular directory must be searched for linearly, so even if the disk block containing the directory entry list is in-core, there is an associated cost. The dcache stores recent results of these searches which in general speeds up these disk searches by a large factor. Recent 2.3 work uses the dentries to allow multiple mounting, union mount, and more. The hardware data cache is usually referred to as the D-cache.
deadlock: Any of a number of situations where two or more processes cannot proceed because they are both waiting for the other to release some resource. FIXME(give good references).
delayed write: See write behind.
demand zero: In demand paging, where the page is to be zeroed when actually created (common case: bss segment of an executable image, which is uninitialised heap data for the executable). Also called ZFOD.
dentry: Directory entry, in-core structure defining a file's details: inode, parent dentry etc. Cached in a hash table indexed by hashed filename (see dcache).
DF: IP packet bit indicating it should not be fragmented. The remote host will return ICMP notifications if the packet had to be split anyway, and these are used in MTU discovery.
directory notification: Provides hooks for notifying tasks when the contents of a directory has changed. Note "contents" can refer to dentries, the file inodes, or even the file contents themselves (file notification).
DOD: Dial-On-Demand for net connections over POTS.
drop behind: In stream I/O conditions, data that has already been read and processed is not needed again. The VM ideally should recognise this and mark the used pages as un-needed, so they can be discarded first. This technique is called "drop behind".
dss: Data Storage Segment, aka data section. This is the memory mapping containing the initialised data for a binary image.
dual-issue: Processors such as the Pentium Pro, that can decode and execute two instructions simultaneously.
dupe: Abbrev. fr. duplication.
Dwarf: Debugging Information Format
dword: Double word, i.e. 4 bytes on x86.

E

EA: See extended attributes.
eager coalescing: What the buddy allocator currently does, i.e. merge adjacent blocks as soon as possible.
edge-triggered interrupt: The interrupt is triggered by the rising or falling edge of the interrupt line. This makes IRQ line sharing difficult, as an edge may occur whilst an ISR is running, and it could be easily missed; to allow sharing level-triggered interrupts are usually used.
EIP: Extended Instruction Pointer. This register contains the PC value of a task, that is, it points to the next instruction to be fetched, decoded etc.
elevator algorithm: This algorithm, often used in disk accesses, keeps an ordered list of requests. When the current request on the disk (e.g. the disk block) has been satisfied, the next strictly greater request on the list is dealt with. When a new request arrives, it is inserted into the ordered list in position (e.g. if the new requested block number is less than the current handled request, it goes before it in the list). When reaching the end of the list, the elevator changes direction, and the situation is reversed.
ELF: Executable Linkable Format, a popular binary format, the default for Linux on most architectures.
ematch: Extended Match, small classification helper attached to classifiers.
EPIC: Explicitly-Parallel Instruction set Computing, an instruction set architecture where every dependency for an instruction is encoded into the instruction itself. This has the potential to be faster as the compiler can encode the data dependencies in the instructions.
exponential back-off: A general algorithm for dealing with contention cases; for example, collisions on a network bus, or contention for a spinlock.
extended attributes: Also known as multi-part or multi-stream files, files with extended attributes deviate from the principle of files being a simple single data stream. An example of extended attributes is the Macintosh's "resource fork", which is associated with a specific file (known as the "data fork").

F

fair scheduler: A scheduler which ensures fairness between users, such that a user's process count and associated cost only impacts that user, rather than the whole system as currently. Rik van Riel and Borislav Deianov have both produced different patches to implement this.
false sharing: On SMP caches, when two parts of single block are accessed, neither of which collide with the other, the cache coherency protocol may not be able to detect this, and mark the block as "shared" even when it isn't. This is known as false sharing.
fastpath: The code path most commonly taken, often optimised heavily at the expense of less frequently-taken blocks of code. This is the reason you see so many gotos in core functions - it produces common-path code far more efficient than an optimising compiler can manage.
fd: file descriptor
filemap: The mapping of a file's contents into memory.
fixed mmap: A user-space request for a mmap starting at a fixed virtual address. Generally not useful or guaranteed to work; a notable exception is overlayed mmaps, where a mmaped area has further mmaps of different types at fixed positions in the map.
FQDN: Fully-Qualified Domain Name, e.g. martyr.darrenemerson.co.uk.

G

GART: For AGP setups, Graphics Aperture Relocation Table.
gdoc: GNOME's source documentation system (similar to javadoc). Available by CVS from gnome. Kernel driver interface descriptions, built from source using gdoc, are currently being written in 2.3.
gdt: Global Descriptor Table. Something to do with x86 memory segmentation I think (FIXME). See ldt.
get: In the kernel, often means "get a reference to". This may be as simple as incrementing a usage count, or it may imply attempting to retrieve an object from a cache of some sort, or allocating kernel memory. See put.
GKHI: Generalised Kernel Hook Infrastructure, an IBM patch to implement hooks into the kernel code.
GPL: I just had to point out that lkml is for Linux kernel development discussions. Please please don't engage in any threads concerning licensing issues, Microsoft, or Richard Stallman. Please.
group descriptor: On-disk filesystem structure, containing information for a block group, such as the inode bitmap and block bitmap.
GRUB: GRand Unified Bootloader, a popular bootloader for Linux, BSD, and other OSes.

H

Highmem: high memory, or memory that is not permanently mapped into kernel memory. Common on 32 bit x86 systems. See HighMemory.
HPET: High Precision Event Timer (HPET) is a replacement timer for the 8254 Programmable Interval Timer and the Real-time clock's (RTC) periodic interrupt function. HPET is a successor to pmtimer, and is far more efficient to read. The HPET can produce periodic interrupts at a much higher resolution than the RTC and is often used to synchronize multimedia streams, providing smooth playback and reducing the need to use other timestamp calculations such as an x86 cpu's RDTSC instruction. HPET support in linux requires that the BIOS expose the HPET (via acpi).
HTB: Hierarchical Token Bucket, a qdisc based on TBF and CBQ. HTB Theory

I

ISR: Interrupt Service Routine, the function in each device driver that gets called when an interrupt happens.

J

Jiffies: 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".

K

kswapd: a kernel thread that frees up memory by evicting data from caches and paging out userspace memory, part of the virtual memory subsystem.

L

LBA: Logical Block Addressing. A way to address IDE disks without Cylinder/Head/Sector (CHS) coordinates, using linear sector numbers from the start of the disk. Allows for the use of very large IDE disks.
Linux Device Drivers, 3rd Edition: online edition.
LKM: 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.
LKML: Linux Kernel Mailing List. The primary virtual watering hole (meeting ground) for kernel developers to share ideas and bounce opinions off one another during the course of the kernel development process. FAQ at http://www.tux.org/lkml/.
LSM: Linux Security Module. a security framework for providing different security levels.
LVM: 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).
LXR: a cross-reference tool that can be used to navigate the Linux kernel source code, available at lxr.linux.no.

M

mem_map: A contiguous virtual array of struct pages representing the entirety of physical memory pages available within a system.
MMU: Memory Management Unit, part of the CPU hardware that enforces memory boundaries, and throw page faults, upon which the OS builds its coherent protection. The MMU maps virtual memory to actual, where protections allow.
MUTEX: MUTual EXclusion locks. This locking primitive is simpler and semantically tighter than the others, and hence is easier to make faster, and to prove correct. Some constraints are; lock has one owner at a time, the locker, who must also be the unlocker. Read Documentation/mutex-design.txt for much more.
MSI: Message Signaled Interrupts. A PCI mode where the interrupt numbers are extended from 8 bits to 32. These also use the normal pci data lanes not some magic all over the chipset; which means that a device can basically have as many interrupts as it wants rather than 4 (1 in practice) for legacy PCI interrupts, and there are also no interrupt sharing issues, since there are just so many numbers for interrupts... For more, see http://en.wikipedia.org/wiki/Message_Signaled_Interrupts

N

netlink: Communication protocol between kernel and userspace

O

P

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.
PFN: Page Frame Number, index into the mem_map[] array which describes physical memory pages.
PGD: Page Global Directory, the top level of the page table tree. The page table hierarchy is pgd -> pud -> pmd -> pte.
PID: Process IDentifier (POSIX thread identifier)
PMD: 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.
PTE: Page Table Entry
PUD: Page Upper Directory, note that puds are folded into pmds, except on systems with 4-levels page tables.

Q

QDisc: Queueing Discipline, queues packets before they are sent out to the network device, enforces QoS requirements, provides traffic shaping and prioritizing capabilities.
QoS: Quality of Service, method to define the importance/priority of network services

R

RCU: Read Copy Update, a mechanism for SMPSynchronisation
Rlimit: resource limit, eg. "maximum amount of virtual memory" or "maximum number of processes". Can be per process or per user.

S

Semaphore: a lock mechanism that works per process context, see SMPSynchronisation
Scheduler: the part of the kernel that chooses a suitable process to run on the cpu, see the 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.
SoftIRQ: 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 Token Based Thrashing Control paper by Song Jiang and the Linux-MM wiki.
System call: (also: syscall) the way a program transitions from userspace into kernel space, to call a kernel space function.
sysenter/sysexit: A pair of instructions on Pentium2+ that replace older INT instruction based syscall mechanism. See [http://manugarg.googlepages.com/systemcallinlinux2_6.html
System.map: symbol table used by ksymoops to resolve numbers to function names in Oops. Also used by ps and top for WCHAN field.

T

TASK_RUNNING: State of the task that can run but is not necessarily running.
TBF: Token Bucket Filter, a qdisc used for rate limiting
TGID: Task Group IDentifier (POSIX process identifier)

U

Use-once: the page replacement algorithm used by the Linux 2.6 kernel, based on the ideas behind the 2Q page replacement algorithm, also see the AdvancedPageReplacement page.

V

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 choosing the most efficient syscall mechanism. Also called the "vsyscall page".
VFS: 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, independent of the other processes.
Vsyscall page: see VDSO.

W

X

Xen: A paravirtualisation engine for Linux, an efficient way to run multiple Linux OSes on one computer. Also runs BSD, Plan9 and other OSes. (See website for more information.)
XIP: eXecute In Place, the ability to run an executable directly from the filesystem (usually ROM or flash), instead of loading it into memory.

Y

Z

Zero-Copy: 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.