Glossary

The placement of a data item in memory. For a data item to be aligned, its lowest-addressed byte must reside at an address that is a multiple of the size of the data item (in bytes).

Application programming interface.

A user-mode program that, in the context of this manual, makes various requests to the kernel modules. If a kernel module is part of a device driver, these requests typically perform I/O operations to hardware components.

A variable or constant that is associated with some value that is passed to a routine. Also called a parameter.

A type of serialization that refers to the indivisibility of a small number of actions, such as those that occur during the execution of a single instruction or a small number of instructions.

An array of the cfg_subsys_attr_t data structure, where each instance of cfg_subsys_attr_t represents one table entry that defines some data item for the kernel module.

The series of events and dispatch points that occur as the system boots. For example, at dispatch point CFG_PT_VM_AVAIL virtual memory is available. See also dispatch point.

The mechanism for implementing kernel modules as single binary images. Using callback routines avoids the problem of calling routines that are not yet available-- statically loaded kernel modules register a callback routine that will be called later in the boot timeline. (For a static configuration, callback routines are registered to execute at dispatch points along the boot timeline.) When the routine is called, it will perform the required initialization correctly because the routines it requires will be available. See also static mode.

The class/port driver comprises two drivers. The class driver supports user interfaces while the port driver supports the hardware and handles interrupts. The driver model is always made of more than one module and it can have multiple class drivers, multiple port drivers, and some common code in a middle layer. The structure of this driver eliminates code duplication.

A mechanism for protecting resources in an SMP environment. A complex lock achieves the same result as a simple lock but is used when there are blocking conditions. Routines that implement complex locks synchronize access to kernel data between multiple kernel threads. See also simple lock.

A kernel module that supports one or more hardware components. There are two driver models: the monolithic driver and the class/port driver.

Points along the boot timeline and post-boot that mark when certain resources or capabilities are available. Dispatch points that are initiated from user space can occur in any order. In kernel mode, these points are in strict chronological order. For example, the dispatch point that indicates that virtual memory is available (CFG_PT_VM_AVAIL) always occurs before locks are available (CFG_PT_LOCKAVAIL).

The ability to add or remove software or hardware while the system is operational. For example, dynamic hardware configuration and dynamic module loading occur late in the boot timeline after these features are enabled. Contrast with static mode.

The address of a routine.

The size of neighboring units of memory that can be written independently and atomically by multiple CPUs. See also atomicity.

The tasks that incorporate a kernel module into the kernel after it has been loaded and make it available for use by the system.

A collection of routine definitions and data structures that perform related functions. There are kernel interfaces and user interfaces. For example, the kernel set management (KSM) interface consists of a variety of cfg_ksm_xxx library routines that allow applications to manage the kernel sets. See also routine.

The code and data structures in a .mod file, either statically linked into /vmunix or dynamically loaded as part of the kernel.

A single, sequential flow of control within a program.

The process of bringing a kernel module into memory and calling its configure routine with the CFG_OP_CONFIGURE request code.

A means of protecting a resource from multiple CPU access in an SMP environment. See also simple lock and complex lock.

See kernel module.

The subsystem in the kernel that loads, unloads, makes other management requests, and generally keeps track of modules in the kernel.

Kernel module code that is all-inclusive; supporting everything from user requests to processing interrupts from hardware.

A variable or constant that is associated with some value that is passed to a routine. Also called an argument.

A driver, such as the pty terminal driver, structured like other drivers but that does not operate on a bus and does not control hardware. A pseudodevice driver does not register itself in the hardware topology (system configuration tree). Instead, it relies on the device driver method of the cfgmgr framework to create the associated device special files.

Code that can be called to perform a function. See also interface.

The process of looking for hardware components for the purpose of configuring hardware that is not currently configured.

A general-purpose mechanism for protecting resources in an SMP environment. A simple lock is a spin lock. That is, routines that implement simple locks do not return until the lock has been returned. See also complex lock.

A single .mod file that can be statically loaded as part of /vmunix or dynamically loaded into the kernel any time after a system boots.

See symmetric multiprocessing.

The coordination of events in such a way that only one event happens at a time.

The permanent and nonremovable parts of the kernel. Contrast with dynamic mode.

An array of characters that terminates with a null character.

A collection of code that provides one or more interfaces or performs one or more functions.

A computer environment that uses two or more CPUs. Software applications and the associated kernel modules can operate on two or more of these CPUs.

See kernel thread.

See application