Glossary

   


absolute pathname
See [pathname]
access control list (ACL)

An access control list replaces the group permissions for a file with a more specific list of the users that are permitted to access the files. The ACL also includes a list of the permissions that each user is granted. These permissions include the traditional read, write, and execute permissions along with other properties such as the right to rename or delete the file.



ACL
See [access control list]
address family

A collection of related address formats, as found in a single communication domain. For example the IPv4 domain uses the Internet address family.



address resolution protocol (ARP)

A communication protocol used to map one network address to another dynamically. For example, ARP is used in FreeBSD to map Internet addresses into Ethernet addresses dynamically.

See also [neighbor discovery]


address translation

A mechanism, typically implemented in hardware, that translates memory addresses supplied by a program into physical memory addresses. This facility is important in supporting multiprogramming because it allows an operating system to load programs into different areas of memory and yet have each program execute as though it were loaded at a single, fixed memory location.

See also [memory-management unit]


advisory lock

A lock that is enforced only when a process explicitly requests its enforcement. An advisory lock is contrasted with a mandatory lock, which is always enforced.

See also [mandatory lock]


ancillary data

Specially interpreted data sent on a network connection. Ancillary data may include protocol-specific data, such as addressing or options.



anonymous object

An anonymous object represents a region of transient backing storage. Pages of an anonymous object are zero-filled on first reference, and modified pages will be stored in the swap area if memory becomes tight. The object is destroyed when no references remain.



ARP
See [address resolution protocol]
association

In the interprocess-communication facilities, a logical binding between two communication endpoints that must be established before communication can take place. Associations may be long lived, such as in stream-based communication, or short lived, such as in a datagram-based communication paradigm.



AST
See [asynchronous system trap]
asymmetric cryptography

A cryptographic system that does not use the same key for decrypting data as it does for encrypting data, sometimes referred to as public key cryptography.

See also [symmetric cryptography]


asynchronous system trap (AST)

A software-initiated interrupt to a service routine. ASTs enable a process to be notified of the occurrence of a specific event asynchronously with respect to its execution. In FreeBSD, ASTs are used to initiate thread rescheduling.



autocontiguration

The probing and identification of hardware attached to the system. Successfully identified hardware is attached to the I/O subsystem. Autoconfiguration is done when the kernel bootstraps itself into operation and any time that a new piece of hardware is attached to the system. In a network protocol, the process by which a system discovers important information about itself and the network (such as its network address and default router) without any help from a user.



background process

In job-control-oriented process-management systems, a process whose process group is different from that of its controlling terminal; thus, this process is currently blocked from most terminal access. Otherwise, a background process is one for which the command interpreter is not waiting that is, the process was set running with the "&" operator. The opposite of a background process is a foreground process.



backing storage

Storage that holds objects that are removed from main memory during paging and swapping operations.

See also [secondary storage]


block

In the filesystem, a unit of allocation. The filesystem allocates space in block-size units or in fragments of block-size units.



block accounting

The process of maintaining a count of the number of disk blocks available for the storage of new data in the Fast Filesystem.



block size

The natural unit of space allocated to a file (filesystem block size) or the smallest unit of I/O that a character device can do (for disk devices, usually the sector size). In FreeBSD, the filesystem block size is a parameter of the filesystem that is fixed at the time that the filesystem is created.



bootstrapping

The task of bringing a system up into an operational state. When a machine is first powered on, it is typically not running any program. Bootstrapping initializes the machine, loads a program from secondary storage into main memory, and sets that program running.



bottom half

With regard to system operation, the collection of routines in the kernel that is invoked as a result of interrupts. These routines cannot depend on any per-process state.

See also [top half]


breakpoint fault

A hardware trap that is generated when a process executes a breakpoint instruction.



broadcast

A transmission to all parties. In a network, a broadcast message is transmitted to all stations attached to a common communication medium.



bss segment

The portion of a program that is to be initialized to zero at the time the program is loaded into memory. The name bss is an abbreviation for "block started by symbol."

See also [data segment]
See also [stack segment]
See also [text segment]


buffer cache

A cache of recently used disk blocks. In FreeBSD, the buffer cache has been merged with the virtual-memory cache.



buffered

As in "buffered I/O"; a technique whereby data are held, or buffered, to minimize the number of I/O operations that are done. For example, the standard I/O library buffers output to files by accumulating data to be written until there is a full filesystem block to write or until the application requests that the data be flushed to disk.



bus

A standardized electrical and mechanical interconnection for components of a computer.



byte

A unit of measure applied to data. A byte is almost always 8 bits.

See also [octet]


callback

In the kernel, a mechanism to notify a subsystem that an asynchronous operation has completed. In NFS, a scheme where a server keeps track of all the objects that each of its clients has cached. When a cached object is held by two or more clients and one of them modifies it, the server sends an eviction notice to all the other clients holding that object so that they can purge it from their cache.

See also [eviction notice]
See also [lease]


callout queue

The kernel data structure that describes waiting events. Each event in the queue is described by a structure that contains a function to be called, a pointer to be passed as an argument to the function, and the number of clock ticks until the event should occur.



canonical mode

A terminal mode. Characters input from a terminal or a pseudo-terminal that is running in canonical mode are processed to provide standard line-oriented editing functions, and input is presented to a process on a line-by-line basis. When the terminal is processing in noncanonical mode, input is passed through to the reading process immediately and without interpretation. Canonical mode is also known as cooked mode, and noncanonical mode is also known as raw mode.



caught signal

A signal the delivery of which to a process results in a signal-handler procedure being invoked. A signal handler is installed by a process with the sigaction system call.



C-block

The buffer that holds the actual data in a C-list data structure.



central processing unit (CPU)

The primary computational unit in a computer. The CPU is the processing unit that executes applications. A multiprocessor will have more than one CPU. Other processing units may be present in a computer for example, for handling I/O.



character

A datum that represents a single printable or control symbol. Characters are usually 8 or 16 bits long.

See also [byte]
See also [octet]


character-at-a-time mode

A mode of operation for a pseudo-terminal device whereby processes reading from the pseudo-terminal receive input immediately as it is typed. This mode differs from raw mode in that certain input processing, such as interpreting the interrupt character, is still performed by the system.

See also [canonical mode]


character device

A device that provides either a character-stream-oriented I/O interface or, alternatively, an unstructured (raw) interface. All devices in FreeBSD use the character-device interface.



character-device interface

The conventions established for accessing devices within the kernel. These conventions include the set of procedures that can be called to do I/O operations and the parameters that must be passed in each call.



checksum

The value of a mathematical function computed for a block of data; used to detect corruption of the data block.



child process

A process that is a direct descendant of another process as a result of being created with a fork system call.



client process

In the client-server model of communication, a process that contacts a server process to request services. A client process is usually unrelated to a server process; the client's only association with the server is through a communication channel.

See also [server process]


C-list

A linked-list data structure, used by the system in supporting serial line I/O.



cloning route

A routing entry that is not used directly but that causes a new instance of a route to be created. For example, the route to a local Ethernet is set up as a cloning route so that individual host routes will be created for each local host when referenced.



cluster

The logical grouping of contiguous pages of virtual memory or a file. In FreeBSD, this grouping is used by the kernel to aggregate pages together when writing or reading them to or from the disk to reduce the number of I/O operations needed to move data in and out of memory.



cold start

The initial phase of a bootstrap procedure. The term is derived from the fact that the software assumes nothing about the state of the machine as though the machine had just been turned on and were cold.



communication domain

An abstraction used by the interprocess-communication facilities to organize the properties of a communication network or similar facility. A communication domain includes a set of protocols, termed the protocol family; rules for manipulating and interpreting names; the address family; and, possibly, other intrinsic properties. The facilities provided by the system for interprocess communication are defined such that they are independent of the communication domains supported by the system. This design makes it possible for applications to be written in a communication-domain-independent manner.



communication protocol

A set of conventions and rules used by two communicating processes. Communication protocols are most often associated with networking.



configuration file

A file that contains parameters for the system-configuration program /usr/sbin/config. This file describes the device drivers that should be configured into the kernel and other basic kernel functionality such as the enabling of symmetric multiprocessing support.



connect request

A request passed to the user-request routine of a communication-protocol module as a result of a process making a connect system call on a socket. The request causes the system to attempt to establish an association between a local and a remote socket.



context switching

The action of interrupting the currently running thread and of switching to another thread. Context switching occurs as one thread after another is scheduled for execution. An interrupted thread's context is saved in that thread's thread control block, and another thread's context is loaded.



continuation style

A style of programming where two or more functions operate cooperatively by calling each other instead of returning directly at the end of execution. When the currently executing function is done with its work it calls another function, which was passed as one of the first function's arguments, as part of its return() call. Programming with continuations has the effect of creating a function chain and is often used when a system wants to submit work to a hardware coprocessor but wishes to have a cleanup routine called by the hardware coprocessor when the coprocessor has completed the job.



continue signal

Signal 19 (SIGCONT). A signal that, when delivered to a stopped or sleeping process, causes that process to resume execution.



controlling process

The session leader that established the connection to the controlling terminal.

See also [session leader]


controlling terminal

The pseudo-terminal associated with a process's session from which keyboard-related signals may be generated. The controlling terminal for a process is normally inherited from the process's parent.



control request

A request passed to a communication-protocol module as a result of a process making an ioctl or setsockopt system call on a socket.



cooked mode
See [canonical mode]
copy-on-write

A technique whereby multiple references to a common object are maintained until the object is modified (written). Before the object is written, a copy is made; the modification is made to the copy rather than to the original. In virtual-memory management, copy-on-write is a common scheme that the kernel uses to manage pages shared by multiple processes. All the page-table entries mapping a shared page are set such that the first write reference to the page causes a page fault. When the page fault is serviced, the faulted page is replaced with a private copy, which is writable.



core file

A file (named procname.core) that is created by the system when certain signals are delivered to a process. The file contains a record of the state of the process at the time the signal occurred. This record includes the contents of the process's virtual address space and, on most systems, the user structure.



CPU
See [central processing unit]
crash

Among computer scientists, an unexpected system failure.



crash dump

A record of the state of a machine at the time of a crash. This record is usually written to a place on secondary storage that is thought to be safe so that it can be saved until the information can be recovered.



credential

A structure that identifies a user. It contains the real, effective, and saved user and group identifiers.

See also [real user identifier]
See also [real group identifier]
See also [effective user identifier]
See also [effective group identifier]
See also [saved UID]
See also [saved GID]


current working directory

The directory from which relative pathnames are interpreted for a process. The current working directory for a process is set with the chdir or fchdir system call.



cylinder group

In the Fast Filesystem, a collection of blocks on a disk drive that is grouped together to use localizing information. That is, the filesystem allocates inodes and data blocks on a per-cylinder-group basis. Cylinder group is a historic name from the days when the geometry of disks was known.



daemon

A long-lived process that provides a system-related service. There are daemon processes that execute in kernel mode (e.g., the pagedaemon) and daemon processes that execute in user mode (e.g., the routing daemon). The Old English term daemon means "a deified being," as distinguished from the term demon, which means "an evil spirit."



DARPA

Defense Advanced Research Projects Agency. An agency of the U.S. Department of Defense that is responsible for managing defense-sponsored research in the United States.



datagram socket

A type of socket that supports an unreliable message transport that preserves message boundaries.



data segment

The segment of a process's address space that contains the initialized and uninitialized data portions of a program.

See also [bss segment]
See also [stack segment]
See also [text segment]


decapsulation

In network communication, the removal of the outermost header information from a message.

See also [encapsulation]


demand paging

A memory-management technique in which memory is divided into pages and the pages are provided to processes as needed that is, on demand.

See also [pure demand paging]


demon
See [daemon]
denial of service attack

Any attempt to overload a system such that it is unable to do work for legitimate users of the system. For example, sending a system so many packets that it runs out of mbufs and so cannot process any other network traffic.



descriptor

An integer assigned by the system when a file is referenced by the open system call or when a socket is created with the socket, pipe, or socketpair system calls. The integer uniquely identifies an access path to the file or socket from a given process or from any of that process's children. Descriptors can also be duplicated with the dup and fcntl system calls.



descriptor table

A per-process table that holds references to objects on which I/O may be done. I/O descriptors are indices into this table.



device

In UNIX, a peripheral connected to the CPU.



device driver

A software module that is part of the kernel and that supports access to a peripheral device.



device flags

Data specified in a system configuration file and passed to a device driver. The use of these flags varies across device drivers. Device drivers for terminal devices use the flags to indicate the terminal lines on which the driver should ignore modem-control signals on input.



device number

A number that uniquely identifies a device within the character-device class. Historically, a device number comprises two parts: a major device number and a minor device number. In FreeBSD 5.2, device numbers are assigned dynamically and are used only for backward compatibility with older applications.



device special file

A file through which processes can access hardware devices on a machine. For example, a sound card is accessed through such a file.



direct memory access (DMA)

A facility whereby a peripheral device can access main memory without the assistance of the CPU. DMA is typically used to transfer contiguous blocks of data between main memory and a peripheral device.



directory

In UNIX, a special type of file that contains entries that are references to other files. By convention, a directory contains at least two entries: dot (.) and dot-dot (..). Dot refers to the directory itself; dot-dot refers to the parent directory.



directory entry

An entry that is represented by a variable-length record structure in the directory file. Each structure holds an ASCII string that represents the filename, the number of bytes of space provided for the string, the number of bytes of space provided for the entry, the type of the file referenced by the entry, and the number of the inode associated with the filename. By convention, a directory entry with a zero inode number is treated as unallocated, and the space held by the entry is available for use.



directory table

The top level of a two-level hierarchy of data structures used by a forward-mapped page-table algorithm to describe the virtual address space of a process. Each entry in a directory-table points to a page of page-table pages. A two-level mapping hierarchy is used on the PC architectures.

See also [forward-mapped page table]
See also [page-table entry]
See also [page-table pages]


dirty

In computer systems, modified. A system usually tracks whether an object has been modified is dirty because it needs to save the object's contents before reusing the space held by the object. For example, in the virtual-memory system, a page in the virtual-memory cache is dirty if its contents have been modified. Dirty pages must be written to the swap area or filesystem before they are reused.



disk partition

A software scheme that divides a disk drive into one or more linear extents or partitions. Each partition is a contiguous region of a disk drive that is used as a swap area or to hold a filesystem.



distributed program

A program that is partitioned among multiple processes, possibly spread across multiple machines.



DMA
See [direct memory access]
double indirect block
See [indirect block]
effective GID
See [effective group identifier]
effective group identifier (effective GID)

The first entry in the groups array. The effective GID, along with the other GIDs in the groups array, is used by the filesystem to check group access permission. The effective GID is set when a set-group-identifier program is executed. saved group identifier.

See also [credential]
See also [group identifier]
See also [real group identifier]


effective UID
See [effective user identifier]
effective user identifier (effective UID)

The UID that the system uses to check many user permissions. For example, the effective UID is used by the filesystem to check owner access permission on files. The effective UID is set when a set-user-identifier program is executed. saved user identifier

See also [credential]
See also [real user identifier]
See also [user identifier]


elevator sorting algorithm

An algorithm used by the device drivers for I/O requests for moving head disks. The algorithm sorts requests into a cyclic ascending order based on the block number of the request. The name is derived from the fact that the algorithm orders disk requests in a manner similar to the way ride requests for an elevator would be handled most efficiently.



emulate

To simulate. FreeBSD can emulate the system-call interface of other variants of the UNIX operating system. For example, FreeBSD can run binaries compiled for Linux.



encapsulation

In network communication, the procedure by which a message is created that has an existing message enclosed in it as data. A protocol normally encapsulates a message by crafting a leading protocol header that indicates that the original message is to be treated as data.

See also [decapsulation]


erase character

The character that is recognized by the terminal handler, when the latter is running in canonical mode, to mean "delete the last character in the line of input." Each terminal session can have a different erase character, and that erase character can be changed at any time with a tcsetattr system call. The terminal handler does not recognize the erase character on terminals that are in noncanonical mode.

See also [kill character]
See also [word-erase character]


errno

The global variable in C programs that holds an error code that indicates why a system call failed. The value to be placed in errno is returned by the kernel in the standard return register; it is moved from this return register to errno by code in the C run-time library.



event handler

A function that is registered with a software system that is to be called at a later time when a particular event occurs.

See also [callout queue]
See also [kqueue]


eviction notice

A callback message from a server to a client notifying the client that its lease for an object is being terminated. A lease is usually terminated because another client wants to modify the object that the lease represents.

See also [callback]
See also [lease]


extension header

Message header that can be easily added and removed from a packet because it contains its length and some indication of where and how to begin processing the next header, if such exists.



fault rate

The rate at which a process generates page faults. For a reference string, the fault rate is defined to be time independent by its being specified as the number of page faults divided by the length of the reference string.



fetch policy

The policy used by a demand-paged virtual-memory-management system in processing page faults. Fetch policies differ primarily in the way that they handle prepaging of data.



fifo file

In the filesystem, a type of file that can be used for interprocess communication. Data written by one process to a fifo are read by another in the order in which they were sent. The name refers to the fact that data are transferred in a first-in, first-out fashion.



file

An object in the filesystem that is treated as a linear array of bytes. A file has at least one name, and it exists until all its names are deleted explicitly.



file entry
See [file structure]
file handle

A globally unique token created by an NFS server and passed back to an NFS client. The client can then use the file handle to refer to the associated file on the server. A handle is created when a file is first opened; it is passed to the server by the client in later operations, such as read and write, that reference the open file.



filename

A string of ASCII characters that names an ordinary file, special file, or directory. The characters in a filename cannot include null (0) or the ASCII code for slash (/).



file offset

A byte offset associated with an open file descriptor. The file offset for a file descriptor is set explicitly with the lseek system call, or implicitly as a result of a read or write system call.



file structure

The data structure used by the kernel to hold the information associated with one or more open file descriptors that reference a file. Usually, each open file descriptor references a unique file structure. File structures may be shared, however, when open descriptors are duplicated with the dup and dup2 system calls, inherited across a fork system call, or received in a message through the interprocess-communication facilities.



filesystem

A collection of files. The UNIX filesystem is hierarchical, with files organized into directories. Filesystems include facilities for naming files and for controlling access to files. A filesystem resides on a single logical device that may be built from part of a single disk drive or from a set of disk drives that have been aggregated together.



fill-on-demand page fault

The first page fault for an individual page; it must be resolved by retrieval of data from the filesystem or by allocation of a zero-filled page.



first-level bootstrap

The initial code that is executed in a multilevel bootstrapping operation. Usually, the first-level bootstrap is limited in size and does little more than bootstrap into operation a larger, more intelligent program. Typically, the first-level bootstrap loads the /boot program so that /boot can, in turn, bootstrap the kernel.



foreground process

In job-control-oriented process-management systems, a process whose process group is the same as that of its controlling terminal; thus, the process is allowed to read from and to write to the terminal. Otherwise, a foreground process is one for which the command interpreter is currently waiting. The opposite of a foreground process is a background process.



forward

The direction a network packet takes through a system if it is received by a host for which it is not, ultimately, destined.

See also [inbound]
See also [router]


forward-mapped page table

A large, contiguous array indexed by the virtual address that contains one element, or page-table entry, for each virtual page in the address space. This element contains the physical page to which the virtual page is mapped, as well as access permissions and status bits telling whether the page has been referenced or modified, and a bit showing whether the entry contains valid information. Most current memory-management-unit designs for architectures with 32-bit address spaces use some variant of a forward-mapped page table.

See also [inverted page table]
See also [memory-management unit]


fragment

In the filesystem, a part of a block. The filesystem allocates new disk space to a file as a full block or as one or more fragments of a block. The filesystem uses fragments, rather than allocating space in only full block-size units, to reduce wasted space when the size of a full block is large.



fragment-descriptor table

A data structure in the Fast Filesystem that describes the fragments that are free in an entry of the allocation map. The filesystem uses the fragment-descriptor table by taking a byte in the allocation map and using the byte to index into the fragment-descriptor table. The value in the fragment-descriptor table indicates how many fragments of a particular size are available in the entry of the allocation map. By doing a logical AND with the bit corresponding to the desired fragment size, the system can determine quickly whether a desired fragment is contained within the allocation-map entry.



free list

In the memory-management system, the list of available pages of physical memory (also called the memory free list). There is a similar free list in the system for dynamically allocated kernel memory. Many kernel data structures are dynamically allocated, including vnodes, file-table entries, and disk-quota structures.



free-space reserve

A percentage of space in a filesystem that is held in reserve to ensure that certain allocation algorithms used by the filesystem will work well. By default, 8 percent of the available space in the Fast Filesystem is held in reserve.



gateway
See [router]
generation number

The number assigned to an inode each time that the latter is allocated to represent a new file. Each generation number is used only once. To make file handles harder to guess, most NFS implementations, including FreeBSD, use a random-number generator to select a new generation number.



GID
See [group identifier]
global page-replacement algorithm

An algorithm that does page replacement according to systemwide criteria. A global-page-replacement strategy tends to make the most efficient use of the system memory. However, a single process can thrash the entire system by trying to use all the available memory.



group identifier (GID)

An integer value that uniquely identifies a collection of users. GIDs are used in the access-control facilities provided by the filesystem. saved group identifier

See also [credential]
See also [effective group identifier]
See also [real group identifier]
See also [set-group-identifier program]


half-open connection

A connection that is open for communication in one direction between two endpoints. For example, a client may close its sending side of a stream connection because it has no more data to send but leave its receiving half of the connection open so that it can continue to receive data from the server.



handler

A procedure that is invoked in response to an event such as a signal.



hard limit

A limit that cannot be exceeded.

See also [soft limit]


hard link

A directory entry that directly references an inode. If there are multiple hard links to a single inode and if one of the links is deleted, the remaining links still reference the inode. By contrast, a symbolic link is a file that holds a pathname that references a file.

See also [symbolic link]


header prediction

A heuristic used by TCP on incoming packets to detect two common cases: the next expected data segment for an existing connection or an acknowledgment plus a window update for one or more data segments. When one of these two cases arises, and the packet has no additional flags or state indications, the fully general TCP input processing is skipped.



heap

The region of a process that can be expanded dynamically with the sbrk system call (or malloc() C library call). The name is derived from the disorderly fashion in which data are placed in the region.



high watermark

An upper bound on the number of data that may be buffered. In the interprocess-communication facilities, each socket's data buffer has a high watermark that specifies the maximum number of data that may be queued in the data buffer before a request to send data will block the process (or will return an error if nonblocking I/O is being used).

See also [low watermark]


hole

In a file, a region that is part of the file but that has no associated data blocks. The filesystem returns zero-valued data when a process reads from a hole in a file. A hole is created in a file when a process positions the file pointer past the current end-of-file, writes some data, and then closes the file. The hole appears between the previous end-of-file and the beginning of the newly written data.



home directory

The current working directory that is set for a user's shell when the user logs into a system. This directory is usually private to the user. The home directory for a user is specified in a field in the password-file entry for the user.



hop limit

The number of routers through which a network packet may be forwarded before it is dropped.

See also [router]


host-unreachable message

A network layer error message that indicates that the host to which a previous message was directed is unavailable because there is no known path to the desired host.



ICMP
See [Internet control message protocol]
idempotent

An operation that can be repeated several times without changing the final result or causing an error. For example, writing the same data to the same offset in a file is idempotent, because it will yield the same result whether it is done once or many times. However, trying to remove the same file more than once is nonidempotent because the file will no longer exist after the first try.



idle loop

The block of code inside the kernel that is executed when there is nothing else to run. In FreeBSD, the idle loop zeros pages on the free list while it waits for a thread to be added to the run queue.



idle queue

The idle queue is where all idle threads are stored. An idle thread is run only when a CPU has nothing else to do.

See also [run queue]
See also [sleep queue]


inbound

The direction a network packet is traveling if it has reached the system for which it is destined. An inbound network packet is delivered to an application on a system or causes an error if no appropriate application is found.

See also [forward]


indirect block

In the filesystem, an auxiliary data block that holds the number of a data block. The first 12 blocks of a file are pointed to directly by the inode. Additional data blocks are described with a pointer from the inode to an indirect data block; the system must first fetch the indirect block that holds the number of the data block. In FreeBSD, the kernel may have to fetch as many as three indirect blocks to locate the desired data block. An indirect block that contains data-block numbers is termed a single-level indirect block; an indirect block that contains block numbers of single-level indirect blocks is called a double-level indirect block; an indirect block that contains block numbers of double-level indirect blocks is called a triple-level indirect block.



init

The first user program (/sbin/init) that runs when the system is booted.



initial sequence number
See [sequence space]
inode

A data structure used by the filesystem to describe a file. The contents of an inode include the file's type and size, the UID of the file's owner, the GID of the directory in which it was created, and a list of the disk blocks and fragments that make up the file. Note that inodes do not have names; directory entries are used to associate a name with an inode.



input/output (I/O)

The transfer of data between the computer and its peripheral devices.



integrity-check value

A value computed over a range of data by a sender that is used by a receiver to ensure that data transmitted across a network was not corrupted.

See also [checksum]


interactive program

A program that must periodically obtain user input to do its work. A screen-oriented text editor is an example of an interactive program.



Internet control message protocol (ICMP)

A communication protocol used for reporting errors and controlling the operation of the Internet protocols. Each of IPv4 and IPv6 includes its own version of ICMP, called ICMPv4 and ICMPv6, respectively.



Internet key exchange

A network protocol for exchanging keys used in the IPSec security protocols.



Internet protocol

See IPv4.



interpreter

A program that parses and executes a descriptive language in a single step, rather than using the more common two-stage process of compiling the language and executing the resulting binary. The shell is an example of an interpreter; it parses and executes a shell script rather than first compiling it.



interprocess communication (IPC)

The transfer of data between processes. Most facilities for interprocess communication are designed such that data are transferred between objects other than processes. An interprocess-communication model that is not directly process oriented is advantageous because it is possible to model scenarios in which communication endpoints are location independent and, possibly, are migrated dynamically. For example, in FreeBSD, communication is between sockets rather than between processes.



interrupt

In computer systems, an event external to the currently executing process that causes a change in the normal flow of instruction execution. Interrupts usually are generated by hardware devices that are external to the CPU.



interrupt stack

A run-time stack that is used by procedures that are invoked to respond to interrupts and traps. In FreeBSD 5.2, each device has its own thread whose context includes an interrupt stack.



inverted page table (reverse-mapped page table)

A hardware-maintained memory-resident table that contains one entry per physical page and that is indexed by physical address instead of by virtual address. An entry contains the virtual address to which the physical page is currently mapped; the entry also includes protection and status attributes. The hardware does virtual-to-physical address translation by computing a hash function on the virtual address to select an entry in the table. The hardware handles collisions by linking together table entries and making a linear search of this chain until it finds the matching virtual address.

See also [forward-mapped page table]


I/O
See [input/output]
I/O redirection

The redirection of an I/O stream from the default assignment. For example, all the standard shells permit users to redirect the standard output stream to a file or process. I/O redirection is implemented in the shell by first closing the descriptor associated with the I/O stream and then opening or duplicating another descriptor in its place.



I/O stream

A stream of data directed to, or generated from, a process. Most I/O streams in UNIX have a single common data format that permits users to write programs in a tool-oriented fashion and to combine these programs in pipelines by directing the standard output stream of one program to the standard input stream of another.



iovec

A data structure used to specify user I/O requests made to the kernel. Each structure holds the address of a data buffer and the number of bytes of data to be read or written. Arrays of such structures are passed to the kernel in readv and writev system calls.

See also [scatter-gather I/O]


I/O vector
See [iovec]
IPC
See [interprocess communication]
IPSec

The set of protocols that implement network layer security in the Internet protocols, versions 4 and 6.



IPv4 domain

Version 4 of the Internet protocols. IPv4 used to be called the Internet protocols until version 6 was developed.

See also [IPv6 domain]


IPv6 domain

Version 6 of the Internet protocols. The newest version of the Internet protocols with support for larger addresses, security, and autoconfiguration.

See also [IPv4 domain]


job

In UNIX, a set of processes that all have the same process-group identifier. Jobs that have multiple processes are normally created with a pipeline. A job is the fundamental object that is manipulated with job control.



job control

A facility for managing jobs. With job control, a job may be started, stopped, and killed, as well as moved between the foreground and the background. The terminal handler provides facilities for automatically stopping a background job that tries to access the controlling terminal and for notifying a job's controlling process when such an event occurs.



keepalive packet

A type of packet used by TCP to maintain information about whether a destination host is up. Keepalive packets are sent to a remote host, which, if it is up, must respond. If a response is not received in a reasonable time to any of several keepalive packets, then the connection is terminated. Keepalive packets are used on only those TCP connections that have been created for sockets that have the SO_KEEPALIVE option set on them.



keepalive timer

A timer used by the TCP protocol when using keepalive packets. The timer is set when a keepalive packet is transmitted. If a response to the packet is not received before the timer expires several times, then the connection is shut down.



kernel

The central controlling program that provides basic system facilities. The FreeBSD kernel creates and manages processes, provides functions to access the filesystem, and supplies communication facilities. The FreeBSD kernel is the only part of FreeBSD that a user cannot replace.



kernel loadable modules

A collection of software that implements a kernel service but that is not statically linked into the kernel's image. Kernel-loadable modules are brought into the system dynamically, possibly at run time, by actions initiated either by the system or a user. See also permanent kernel modules.



kernel mode

The most privileged processor-access mode. The FreeBSD kernel operates in kernel mode.

See also [user mode]


kernel process

A process that executes with the processor in kernel mode. The pagedaemon and swapper processes are examples of kernel processes.



kernel state

The run-time execution state for the kernel. This state, which includes the program counter, general-purpose registers, and run-time stack, must be saved and restored on each context switch.



key

In the kernel, a piece of data that uniquely identifies some resource in the system. When used by an interprocess communication system, it identifies an endpoint of communication such as a message queue or a shared facility like a region of shared memory.



kill character

The character that is recognized by the terminal handler in canonical mode to mean "delete everything typed on this terminal after the most recent end-of-line character." Each terminal session can have a different kill character, and the user can change that kill character at any time with an tcsetattr system call. The terminal handler does not recognize the kill character on terminals that are in noncanonical mode.

See also [erase character]
See also [word-erase character]


kqueue

A kernel data structure associated with a file descriptor that describes a set of events for which the process referencing the descriptor wants to be notified. Events include both dynamic transitions, such as the arrival of data to read, and state transitions, such as a rename of the file associated with the descriptor.



lease

A ticket permitting an activity that is valid until a specified expiration time. In the NQNFS protocol, a client gets a lease from its server to read, write, or read and write a file. As long as the client holds a valid lease, it knows that the server will notify it if the file status changes. Once the lease has expired, the client must contact the server to request a new lease before using any data that it has cached for the file.

See also [callback]
See also [eviction notice]


least-recently used (LRU)

A policy of reuse whereby the least-recently used items are reused first. For example, in the filesystem, there is a fixed number of vnodes available for accessing files. Vnodes that hold valid file data are reallocated in an LRU order, in the hope that the file referenced by the vnode may be reused by a later open request.



line discipline

A processing module in the kernel that provides semantics for an asynchronous serial interface or for a software emulation of such an interface. Line disciplines are described by a procedural interface whose entry points are stored in the linesw data structure.



line mode
See [canonical mode]
link layer

Layer 2 in the ISO Open Systems Interconnection Reference Model. In this model, the link layer is responsible for the (possibly unreliable) delivery of messages within a single physical network. The link layer corresponds most closely to the network-interface layer of the FreeBSD network subsystem.

See also [network-interface layer]


listen request

A request passed to a communication-protocol module as a result of a process making a listen system call on a socket. This request indicates that the system should listen for requests to establish a connection to the socket. Otherwise, the system will reject any connection requests that it receives for the socket.



load average

A measure of the CPU load on the system. The load average in FreeBSD is an average of the number of processes ready to run or waiting for short-term events such as disk I/O to complete, as sampled once per second over the previous one-minute interval of system operation.



local domain

A communication domain in the interprocess-communication facilities that supports stream- and datagram-oriented styles of communication between processes on a single machine.



locality of reference

A phenomenon whereby memory references of a running program are localized within the virtual address space over short periods. Most programs tend to exhibit some degree of locality of reference. This locality of reference makes it worthwhile for the system to prefetch pages that are adjacent to a page that is faulted, to reduce the fault rate of a running program.



local page-replacement algorithm

An algorithm for page replacement that first chooses a process from which to replace a page and then chooses a page within that process based on per-process criteria. Usually, a process is given a fixed number of pages and must then select from among its own pages when it needs a new page.



logical block

A block defined by dividing a file's linear extent by the underlying filesystem block size. Each logical block of a file is mapped into a physical block. This additional level of mapping permits physical blocks to be placed on disk without concern for the linear organization of the logical blocks in a file.



long-term-scheduling algorithm
See [short-term-scheduling algorithm]
low watermark

A lower bound that specifies the minimum number of data that must be present before an action can be taken. In the interprocess-communication facilities, each socket's data buffer has a low watermark that specifies the minimum number of data that must be present in the data buffer before a reception request will be satisfied.

See also [high watermark]


LRU
See [least-recently used]
MAC
See [mandatory access control]
machine check

An exceptional machine condition that indicates that the CPU detected an error in its operation. For example, a machine check is generated if a parity error is detected in a cache memory.



magic number

The number located in the first few bytes of an executable file that specifies the type of the executable file. Many on-disk data structures have a magic number to help verify their contents.



main memory

The primary memory system on a machine.



major device number

A number that uniquely identifies a device within the character-device class. Historically, the major device number was used as an index into the kernel's device table. In FreeBSD 5.2, device numbers are assigned dynamically and are used only for backward compatibility with older applications.



mandatory access control (MAC)

Mandatory access controls are labels on files that allow additional restrictions to be placed on their use. For example, a file labelled "secret" may only be shown to users with a clearance level of secret or higher.

See also [access control list]


mandatory lock

A lock that cannot be ignored or avoided. A mandatory lock is contrasted with an advisory lock, which is enforced only when a process explicitly requests its enforcement.

See also [advisory lock]


mapped object

An object whose pages are mapped into a process address space. Processes map objects into their virtual address space using the mmap system call.



mapping structure

The machine-dependent state required to describe the translation and access rights of a single page.

See also [page-table entry]


marshalling

Preparing a set of parameters to be sent across a network. Marshalling includes replacing pointers by the data to which they point and converting binary data to the canonical network byte order.

See also [remote procedure call]


masked signal

A signal blocked in a sigprocmask system call. When a signal is masked, its delivery is delayed until it is unmasked. In addition, in FreeBSD, the system automatically masks a caught signal while that signal is being handled.



master device
See [slave device]
maximum segment lifetime (MSL)

The maximum time that a segment of data may exist in the network.

See also [2MSL timer]


mbuf

A data structure that describes a block of data. Mbufs are used in the interprocess-communication facilities for holding network packets, as well as data that are internal to the network protocol modules. "Mbuf" is shorthand for "memory buffer."



memory address

A number that specifies a memory location. Memory addresses are often categorized as physical or virtual according to whether they reference physical or virtual memory.



memory free list
See [free list]
memory-management system

The part of the operating system that is responsible for the management of memory resources available on a machine.



memory-management unit (MMU)

A hardware device that implements memory-management-related tasks, such as address translation and memory protection. Most contemporary memory-management units also provide support for demand-paged virtual-memory management.

See also [address translation]


message queue

A local interprocess communication mechanism that supports in-order delivery of messages. Messages are inserted at one end of the queue and removed from the other and the kernel guarantees their ordering.



metadata

In filesystems, metadata provides pointers and descriptions for linking multiple disk sectors into files and identifying those files. Metadata are the directories, inodes, and free block maps that give structure to raw storage capacity.



minor device number

An integer number that uniquely identifies a subunit of a device. The minor device number is interpreted on a per-device basis. For example, the minor device number for a disk device specifies a subunit termed a partition, whereas the minor device number for a pseudo-terminal device identifies a specific master-slave pair.



MMU
See [memory-management unit]
modem control

For data-communication equipment, the support of a set of signals used to ensure reliable initiation and termination of connections over asynchronous serial lines, defined by the RS-232 standard. Support for modem control is normally important for only serial lines that are accessed via dialup modems.



MSL
See [maximum segment lifetime]
multilevel feedback queue

A queueing scheme in which requests are partitioned into multiple prioritized subqueues, with requests moving between subqueues based on dynamically varying criteria. The FreeBSD kernel uses a multilevel-feedback-queueing scheme for scheduling the execution of threads.



neighbor discovery

The technique by which a system on a network discovers the hardware address of its neighbors, including its router, so that it can send network packets to them. The neighbor discovery protocol is used by IPv6.

See also [address resolution protocol]


network architecture

The collection of protocols, facilities, and conventions (such as the format of a network address) that defines a network. Like machine architectures, network architectures may be realized in different ways. For example, some network architectures are specifically designed to permit their implementation in hardware devices.



network byte order

The order defined by a network for the transmission of protocol fields that are larger than one octet. In IPv4 and IPv6, this order is "most significant octet first."



network-interface layer

The layer of software in the FreeBSD network subsystem that is responsible for transporting messages between hosts connected to a common transmission medium. This layer is mainly concerned with driving the transmission media involved and with doing any necessary link-level protocol encapsulation and decapsulation.

See also [link layer]


network layer

The layer of software in the FreeBSD network subsystem that is responsible for implementing ISO layer 2 functionality. In the IPv4 domain this functionality is implemented in the IP protocol module.



network mask

A value that is used in the Classless Inter-Domain Routing (CIDR) addressing scheme of the Internet. A network mask specifies which bits should be considered significant when extracting the network part from an address.



newbus

The device-driver infrastructure used in FreeBSD to manage the devices on the system. Newbus includes machine-independent routines and data structures for use by machine-dependent layers and provides a framework for dynamic allocation of data structures for each device. See also autoconfiguration.



nice

A user-controllable process-scheduling parameter. The value of a process's nice variable is used in calculating the scheduling priority of the process's threads. Positive values of nice mean that the process is willing to receive less than its share of the processor. Negative values of nice mean that the process requests more than its share of the processor.



nonblocking I/O

A mode in which a descriptor may be placed, whereby the system will return an error if any I/O operation on the descriptor would cause the process to block. For example, if a read system call is done on a descriptor that is in nonblocking I/O mode, and no data are available, the system will return the error code EAGAIN, rather than block the process until data arrive.

See also [polling I/O]
See also [signal-driven I/O]


noncaching lease

A noncaching lease is issued by an NFS server to a client to require that the client do all file operations synchronously with the server.

See also [read-caching lease]
See also [write-caching lease]


noncanonical mode
See [canonical mode]
nonlocal goto

A transfer in control that circumvents the normal flow of execution in a program across routine boundaries. For example, if procedure A calls procedure B, and B calls C, then a direct transfer of control from C back to A (bypassing B) would be a nonlocal goto.



nonresident object

An object that is not present in main memory. For example, a page in the virtual address space of a process may be nonresident if it has never been referenced.



object
See [virtual-memory object]
octet

A basic unit of data representation; an 8-bit byte. The term octet is used instead of byte in the definition of many network protocols because some machines use other byte sizes.



optimal replacement policy

A replacement policy that optimizes the performance of a demand-paging virtual-memory system. In this book, a policy whereby the full reference string of a program is known in advance, and pages are selected such that the number of page faults is minimized.



orphaned process group

A process group in which the parent of every member is either itself a member of the group or is not a member of the group's session. Such a parent would normally be a job-control shell capable of resuming stopped child processes.



out-of-band data

Data transmitted and received out of the normal flow of data. Stream sockets support a logically separate out-of-band data channel through which at least one message of at least 1 octet of data may be sent. The system immediately notifies a receiving process of the presence of out-of-band data, and out-of-band data may be retrieved from the stream out of the order in which normal data are received.



overlay

In computer systems, a region of code or data that may be replaced with other such regions on demand. Overlays are usually loaded into a process's address space on demand, possibly on top of another overlay. Overlays are a commonly used scheme for programs that are too large to fit in the address space of a machine that does not support virtual memory.



page

In memory management, the fixed-sized unit of measure used to divide a physical or virtual address space.

See also [demand paging]


pagedaemon

In FreeBSD, the name of the kernel process that is responsible for writing parts of the address space of a process to secondary storage, to support the paging facilities of the virtual-memory system.

See also [swapper]


page fault

An exception generated by a process's reference to a page of that process's virtual address space that is not marked as resident in memory.



pagein

An operation done by the virtual-memory system in which the contents of a page are read from secondary storage.



pageout

An operation done by the virtual-memory system in which the contents of a page are written to secondary storage.



pager

A kernel module responsible for providing the data to fill a page and for providing a place to store that page when it has been modified and the memory associated with it is needed for another purpose.



page reclaim

A page fault, where the page that was faulted is located in memory, usually on the inactive or cache list.



page-table entry (PTE)

The machine-dependent data structure that identifies the location and status of a page of a virtual address space. When a virtual page is in memory, the PTE contains the page-frame number that the hardware needs to map the virtual page to a physical page.



page-table pages

The top level of a two-level hierarchy of data structures used by a forward-mapped page-table algorithm to describe the virtual address space of a process. On the PC, page-table pages are stored in an array called the directory table; each entry in a page-table page points to a page of bottom-level page-table entries.

See also [directory table]
See also [forward-mapped page table]
See also [page-table entry]


paging

The actions of bringing pages of an executing process into main memory when they are referenced and of removing them from memory when they are replaced. When a process executes, all its pages are said to reside in virtual memory. Only the actively used pages, however, need to reside in main memory. The remaining pages can reside on disk until they are needed.



panic

In UNIX, an unrecoverable system failure detected by the kernel. FreeBSD automatically recovers from a panic by rebooting the machine, repairing any filesystem damage, and then restarting normal operation.

See also [crash dump]


parent process

A process that is a direct relative of another process as a result of a fork system call.



partition
See [disk partition]
path MTU discovery

An algorithm and set of messages used to find the largest packet that can be sent between two endpoints in the network.



pathname

A null-terminated character string starting with an optional slash (/), followed by zero or more directory names separated by slashes, and optionally followed by a filename. If a pathname begins with a slash, it is said to be an absolute pathname, and the path search begins at the root directory. Otherwise, the pathname is said to be a relative pathname, and the path search begins at the current working directory of the process. A slash by itself names the root directory. A null pathname refers to the current working directory.



permanent kernel module

A collection of software that implements a kernel service that must be present at boot time and may not be removed while the system is running. See also kernel loadable module.



persist timer

A timer used by TCP for maintaining output flow on a connection. This timer is started whenever data are ready to be sent, but the send window is too small to bother sending and no data are already outstanding. If no window update is received before the timer expires, a window probe is sent.



physical block

One or more contiguous disk sectors to which the system maps a logical block.



physical mapping (pmap)

The software state, also referred to as the pmap structure, needed to manage the machine-dependent translation and access tables that are used either directly or indirectly by the memory-management hardware. This mapping state includes information about access rights, in addition to address translation.



PID
See [process identifier]
pipe

An interprocess-communication facility that supports the unidirectional flow of data between related processes. Data transfer is stream-oriented, reliable, and flow controlled. A pipe is specified to the shell with the "I" symbol. For example, to connect the standard output of program a to the standard input of program b, the user would type the command "a I b".



pipeline

A collection of processes in which the standard output of one process is connected to the standard input of the next with a pipe.



placement policy

The policy used by the virtual-memory system to place pages in main memory when servicing a page fault. FreeBSD uses page coloring to optimize the placement of pages.



pmap
See [physical mapping]
point-to-point protocol (PPP)

The point-to-point protocol is a line discipline used by networking software to encapsulate and transfer Internet Protocol datagrams over asynchronous serial lines.

See also [line discipline]


polling I/O

The normal mode for a descriptor whereby the system will block if a read request has no data available or a write request has no buffering available. A process can determine whether an I/O operation will block by polling the kernel using the select or poll system call. The select or poll system call can be requested to return immediately with the information or to block until at least one of the requested I/O operations can be completed. non-blocking I/O

See also [signal-driven I/O]


POSIX

The standards group for P1003, the portable operating-system interfaces established by the IEEE. Its first established standard was the kernel interface, 1003.1, which was ratified in 1988. The final POSIX standard was ratified in 1999. Since 1999, the only changes have been to keep the existing POSIX standards current.



PPP
See [point-to-point protocol]
prefetching

The retrieval of data before they are needed. Many machines prefetch machine instructions so that they can overlap the time spent fetching instructions from memory with the time spent decoding instructions.



prepaging

The prefetching of pages of memory. Prepaging is a technique used by virtual-memory systems to reduce the number of page faults.

See also [cluster]


private mapping

When privately mapping a file in virtual memory, changes made to the memory mapping the file are not written back to the mapped file and are not visible to other processes mapping the file.

See also [shared mapping]


probe

The operation of checking to see whether a hardware device is present on a machine. Newer bus designs have a standardized way to identify the devices that are attached to them.



process

In operating systems, a task that contains one or more threads of execution. In UNIX, user processes are created with the fork system call.



process context

The context of a FreeBSD process consists of user-level state, including the contents of its address space and the run-time environment, and kernel-level state, which includes scheduling parameters, resource controls, and identification information. The process context includes everything used by the kernel in providing services for the process.



process group

A collection of processes on a single machine that all have the same process-group identifier. The kernel uses this grouping to arbitrate among multiple jobs contending for the same terminal.



process-group identifier

A positive integer used to identify uniquely each active process group in the system. Process-group identifiers are typically defined to be the PID of the process-group leader. Process-group identifiers are used by command interpreters in implementing job control, when the command interpreter is broadcasting signals with the killpg system call, and when the command interpreter is altering the scheduling priority of all processes in a process group with the setpriority system call.



process-group leader

The process in a process group whose PID is used as the process-group identifier. This process is typically the first process in a pipeline.



process identifier (PID)

A nonnegative integer used to identify uniquely each active process in the system.



process open-file table
See [descriptor table]
processor affinity

In an SMP system, a desire to run a thread on the same processor. For performance reasons, a thread should not be migrated between processors unnecessarily because of the loss of its cached working memory.



processor group

A set of CPU cores on a processor that supports symmetric multithreading or a set of processors in an SMP system that is treated as a unit by the scheduler.



process priority

A parameter used by the kernel to schedule the execution of the threads within a process. The priority for threads running in the timesharing class changes dynamically according to the operation of the thread. In addition, the nice parameter can be set for a process to weight the overall scheduling priority for its threads.

See also [scheduling class]
See also [scheduling priority]


process structure

A data structure maintained by the kernel for each active process in the system. The process structure for a process is always resident in main memory, as opposed to the user structure, which is moved to secondary storage when the process is swapped out.



/proc fllesystem

A filesystem-based interface to active processes that provides process-debugging facilities. Each process is represented by a directory entry in a pseudo-directory named /proc. Applications access the virtual address space of a process by opening the file in /proc that is associated with the process and then using the read and write system calls as though the process were a regular file.



protocol family

A collection of communication protocols, the members of which are related by being part of a single network architecture. For example, the TCP, UDP, IPv4, and ICMPv4 protocols are part of the protocol family for the IPv4 domain.



protocol-switch structure

A data structure that holds all the entry points for a communication protocol supported by the kernel.



pseudo-terminal

A pseudo-terminal provides a software emulation of a hardware terminal. A pseudo-terminal is built from a pair of character devices, a master device and a slave device. The slave device provides a process with an interface identical to that for a hardware terminal. However, instead of having a hardware device driving it, the slave device has another process manipulating it through the master half of the pseudo-terminal. Anything written on the master device is given to the slave device as input, and anything written on the slave device is presented as input on the master device.



PTE
See [page-table entry]
public key encryption

A cryptographic system in which the keys used to encrypt data can be shared publicly, in contrast to systems that require that all keys be kept secret to guarantee the security of the data.



pure demand paging

Demand paging without prepaging.



push migration

When the scheduler actively moves a thread from one CPU to another to balance the computational load in a system.



race condition

A condition in which two or more actions for an operation occur in an undefined order. Trouble arises if there exists a possible order that results in an incorrect outcome.



rapid connection reuse

A new connection that exactly duplicates the addresses and ports of a recently closed stream socket that is in the TIME_WAIT state.



raw-device interface

The character-device interface for block-oriented devices such as disks. This interface provides raw access to the underlying device, arranging for direct I/O between a process and the device.



raw mode
See [canonical mode]
raw socket

A socket that provides direct access to a communication protocol beneath the transport layer. For example, a raw socket in the IPv4 domain gives the user the ability to read and write IP packets directly without using a transport protocol such as UDP or TCP.



read-caching lease

A read-caching lease is issued by an NFS server to a client to allow the client to do data caching but to prohibit the client from modifing the data.

See also [noncaching lease]
See also [write-caching lease]


real GID
See [real group identifier]
real group identifier (real GID)

The GID that is recorded in the accounting record when a process terminates. The real GID for a process is initially set at the time that a user logs into a system and is then inherited by child processes across later fork and exec system calls (irrespective of whether a program is set-group-identifier). saved group identifier

See also [credential]
See also [effective group identifier]
See also [set-group-identifier program]


real UID
See [real user identifier]
real user identifier (real UID)

With respect to a process, the true identity of the user that is running the process. The real UID for a process is initially set at the time a user logs into a system and is then inherited by child processes across later fork and exec system calls (irrespective of whether a program is set-user-identifier). The real UID is recorded in the accounting record when a process terminates. saved user identifier

See also [credential]
See also [effective user identifier]
See also [set-user-identifier program]


receive window

In TCP, the range of sequence numbers that defines the data that the system will accept for a connection. Any data with sequence numbers outside this range that are received are dropped.

See also [sliding-window scheme]


reclaim
See [page reclaim]
reclaim from inactive

A page reclaim from the inactive list. A page can be reclaimed from the inactive list if that page is freed by the page-replacement algorithm, but the page is not reassigned before a process faults on it.



recovery storm

A failure condition that can occur when a server is congested on returning to service after a period of being unavailable. If there is heavy pent-up demand for the server, it may be inundated with requests. If the server simply ignores requests that it cannot handle, the clients will quickly resend them. So the server typically replies "try again later" to the requests that it is not yet ready to service. Clients receiving such a response will wait considerably longer than a typical timeout period before resending their request.



red zone

A read-only region of memory immediately below the last page of the per-thread kernel-mode run-time stack. The red zone is set up by the system so that a fault will occur if a thread overflows the space allocated for its kernel stack.



referenced page

In the virtual-memory system, a page that is read or written.



reference string

A dataset that describes the pages referenced by a process over the time of the process's execution. This description represents the memory-related behavior of the process at discrete times during that process's lifetime.



region

A range of memory that is being treated in the same way. For example, the text of a program is a region that is read-only and is demand paged from the file on disk that contains it.



relative pathname
See [pathname]
reliably-delivered-message socket

A type of socket that guarantees reliable data delivery and preservation of message boundaries and that is not connection based.



relocation

The copying of a program's contents from one place in an address space to another. This copying may be accompanied by modifications to the image of the program so that memory references encoded in the program remain correct after that program is copied. Code that is not bound to a particular starting memory address is said to be relocatable or position independent.



remote procedure call (RPC)

A procedure call made from a client process to invoke a subroutine in a server process. Typically, the client and server processes are running on different machines. A remote procedure call operates much like a local procedure call: the client makes a procedure call, and then waits for the result while the procedure executes.

See also [marshalling]


replacement policy

The policy that a demand-paged virtual-memory-management system uses to select pages for reuse when memory is otherwise unavailable.



resident object

An object that is present in main memory. For example, a page in the virtual address space of a process is resident if its contents are present in main memory.



resident-set size

The number of pages of physical memory held by a process. In a well-tuned system, the resident-set size of a process will be that process's working set. Usually, the precise working set cannot be calculated, so a process will have additional pages beyond that needed for its working set.



retransmit timer

A timer used by TCP to trigger the retransmission of data. This timer is set each time that data are transmitted to a remote host. It is set to a value that is expected to be greater than the time that it will take the receiving host to receive the data and return an acknowledgment.



reverse-mapped page table
See [inverted page table]
root directory

The directory that the kernel uses in resolving absolute pathnames. Each process has a root directory that can be set with the chroot system call, and the system has a unique root directory, the identity of which is set at the time that the system is bootstrapped.



root filesystem

The filesystem containing the root directory that is considered the root of all filesystems on a machine. The identity of a default root filesystem is compiled into a kernel, although the actual root filesystem used by a system may be set to some other filesystem at the time that a system is bootstrapped.



round robin

In queueing, an algorithm in which each requester is serviced for a fixed time in a first-come, first-served order; requests are placed at the end of the queue if they are incomplete after service.



route

In packet-switched-network communication, a route to a destination specifies the host or hosts through which data must be transmitted to reach the destination.



router

A machine, also known as a gateway, that has two or more network interfaces and that forwards packets between the networks to which it is connected. Typically, a router runs a routing process that gathers information on the network topology; it uses that information to devise a set of next-hop routes that it installs in the kernel's routing table. See also ; routing policy.

See also [routing mechanism]


router solicitation

A message sent by a host in an attempt to discover which machine is its router without human intervention. autoconfiguration

See also [neighbor discovery]


routing daemon

A process in FreeBSD that provides a routing-management service for the system. This service uses a protocol that implements a distributed database of routing information that is updated dynamically to reflect changes in topological connectivity.



routing mechanism

The routing facilities included in the kernel that implement externally defined policies. The routing mechanism uses a lookup mechanism that provides a first-hop route (a specific network interface and immediate destination) for each destination.

See also [router]
See also [routing policies]


routing policies

The routing facilities provided in a user-level process that define external policies. Routing policies include all the components that the routing daemon uses in choosing the first-hop routes, such as discovery of the local network topology, implementation of various routing protocols, and configuration information specifying local policies.

See also [router]
See also [routing mechanism]


routing redirect message

A message generated by a router when the latter recognizes that a message that it has received can be delivered via a more direct route.



RPC
See [remote procedure call]
run queue

The queue of those threads that are ready to execute.

See also [idle queue]
See also [sleep queue]


SA
See [security association]
saved GID

A mechanism that records the identity of a setgid program by copying the value of the effective GID at the time that the program is exec'ed. During its execution, the program may temporarily revoke its setgid privilege by setting its effective GID to its real GID. It can later recover its setgid privilege by setting its effective GID back to its saved GID.

See also [credential]
See also [effective group identifier]


saved UID

A mechanism that records the identity of a setuid program by copying the value of the effective UID at the time that the program is exec'ed. During its execution, the program may temporarily revoke its setuid privilege by setting its effective UID to its real UID. It can later recover its setuid privilege by setting its effective UID back to its saved UID.

See also [credential]
See also [effective user identifier]


scatter-gather I/O

Scatter input allows a single read to be placed in several different buffers. Scatter output allows several different buffers to be written in a single atomic write. Scatter-gather I/O uses an iovec structure, an array of buffers and lengths, to identify the buffers to be used for the I/O.

See also [iovec]


scheduling

In operating systems, the planning used to share a resource. For example, process scheduling shares the CPU and main memory.



scheduling class

The FreeBSD kernel has five scheduling classes: kernel interrupts, system calls, real time, time sharing, and idle. Each process is placed into a scheduling class. Within each class, threads of the process are organized by their scheduling priority.

See also [scheduling priority]
See also [process priority]


scheduling priority

A per-process parameter maintained by the kernel that specifies the priority with which the latter will schedule the execution of the threads of the process. When a thread is executing in user mode in the timesharing class, the system periodically calculates the scheduling priority, using the thread priority and the nice parameter.

See also [process priority]
See also [scheduling class]


secondary storage

Storage that holds data that do not fit in main memory. Secondary storage is usually located on rotating magnetic media, such as disk drives.

See also [backing storage]


sector

The smallest contiguous region on a disk that can be accessed with a single I/O operation.



security association (SA)

The basic channel of secure communication in IPSec. Data is secured only in one direction by a security association, which means that two security associations are required to create a fully secure channel between two hosts.

See also [security-parameter index]


security-parameter index (SPI)

A 32-bit piece of data used to identify the end of a security association on a host using IPSec. The security-parameter index is used as a key when working with security associations in a system's security databases.

See also [security association]


segment

A contiguous range of data defined by a base and an extent. In memory management, a segment describes a region of a process's address space. In the TCP protocol, a segment is a range of bytes within a single connection defined by starting and ending sequence numbers.



semaphores

Data structures and a set of functions used for synchronizing access to a shared resource, such as an area of memory. Semaphores implement two functions: a take and a give, such that once one thread has taken a semaphore, all others that follow the first are blocked until the first thread gives the semaphore back.



send window

In TCP, the range of sequence numbers that defines the data that the system can transmit on a connection and be assured that the receiving party has space to hold the data on receipt. Any data with sequence numbers before the start of the send window have already been sent and acknowledged. Any data with sequence numbers after the end of the window will not be sent until the send window changes to include them.

See also [sliding-window scheme]


sense request

A request passed to a communication-protocol module as a result of a process making a stat system call on a socket.



sequenced-packet socket

A type of socket that models sequenced, reliable, unduplicated, connection-based communication that preserves message boundaries.



sequence space

The range of sequence numbers that are assigned to data transmitted over a TCP connection. In TCP, sequence numbers are taken from a 32-bit circular space that starts with an arbitrary value called the initial sequence number.



server process

A process that provides services to client processes via an interprocess-communication facility.

See also [client process]


session

A collection of process groups established for job control purposes. Normally, a session is created for each login shell. All processes started by that login shell are part of its session.



session leader

A process that has created a session. The session leader is the controlling process for the session and is permitted to allocate and assign the controlling terminal for the session. Normally, a session is created for each login shell. All processes started by that login shell are part of its session.



set-group-identifier program

A program that runs with an additional group privilege. Set-group-identifier programs are indicated by a bit in the inode of the file. When a process specifies such a file in an exec system call, the GID of the file is made the effective GID of the process.



set-user-identifier program

A program that runs with an UID different from that of the process that started it running. Set-user-identifier programs are indicated by a bit in the inode of the file. When a process specifies such a file in an exec system call, the UID of the file is made the effective UID of the process.



shadow object

An anonymous object that is interposed between a process and an underlying object to prevent changes made by the process from being reflected back to the underlying object. A shadow object is used when a process makes a private mapping of a file so that changes made by the process are not reflected in the file.



shared mapping

When doing a shared mapping to a file in virtual memory, changes made to the memory mapping the file are written back to the mapped file and are visible to other processes mapping the file. See also private mapping.



shared memory

An area of memory that can be read and written by two different processes. The fastest way to share information between processes on the same system. See also semaphore.



shell

A program that interprets and executes user commands. When a user logs into a UNIX system, a shell process is normally created with its standard input, standard output, and standard error descriptors directed to the terminal or pseudo-terminal on which the user logged in.



short-term-scheduling algorithm

The algorithm used by the system to select the next process to run from among the set of processes that are deemed run-nable. The long-term-scheduling algorithm, on the other hand, can influence the set of runnable processes by swapping processes in and out of main memory (and thus in and out of the set of runnable processes).



signal

In UNIX, a software event. In FreeBSD, this event is modeled after a hardware interrupt.



signal-driven I/O

A mode in which a descriptor can be placed, whereby the system will deliver a SIGIO signal to a process whenever I/O is possible on the descriptor.

See also [nonblocking I/O]
See also [polling I/O]


signal handler

A procedure that is invoked in response to a signal.



signal post

A notification to a process that a signal is pending for that process. Since most of the actions associated with a signal are done by the receiving process, a process that is posting a signal usually does little more than to record the pending signal in the receiving process's process structure and to arrange for the receiving process to be run.



signal-trampoline code

A piece of code that invokes a signal handler. The signal-trampoline code contains instructions that set up parameters for calling a signal handler, do the actual call to the signal handler, and, on return, do a sigreturn system call to reset kernel state and resume execution of the process after the signal is handled.



silly-window syndrome

A condition observed in window-based flow-control schemes in which a receiver sends several small (i.e., silly) window allocations rather than waiting for a reasonable-sized window to become available.



single indirect block
See [indirect block]
slave device

A hardware device that is controlled by a master device. For example, a disk drive is a slave device to a SCSI bus controller. The distinction between master and slave devices is used by the autoconfiguration system. A slave device is assumed to be accessible only if its corresponding master device is present.



sleep queue

The queue of those threads that are blocked awaiting an event. The name is derived from the sleep() routine that places threads on this queue.

See also [idle queue]
See also [run queue]


sliding-window scheme

A flow-control scheme in which the receiver limits the number of data that it is willing to receive. This limit is expressed as a contiguous range of sequence numbers termed the receive window. It is periodically communicated to the sender, who is expected to transmit only those data that are within the window. As data are received and acknowledged, the window slides forward in the sequence space.

See also [receive window]
See also [send window]
See also [sequence space]


small-packet avoidance

In networking, avoiding the transmission of a packet so small that its transmission would be inefficient.



SMP
See [symmetric multiprocessing]
SMT
See [symmetric multithreading]
snapshot

A filesystem snapshot is a frozen image of a filesystem at a given instant in time.



socket

In the FreeBSD interprocess-communication model, an endpoint of communication. Also, the data structure that implements the socket abstraction and the system call that creates a socket.



socket address structure

A generic structure for holding addresses for a socket. Many interprocess communication routines, such as connect() and bind(), need to know the network addresses of the communicating endpoints and require that a socket address structure be passed as a parameter.



soft limit

A limit that may be temporarily exceeded, or exceeded a limited number of times. A soft limit is typically used with a hard limit.

See also [hard limit]


soft link
See [symbolic link]
software interrupt

A software-initiated interrupt. It is requested with an asynchronous system trap.



software-interrupt thread

A thread that is set running in response to a software interrupt. In FreeBSD, input processing for each transport-layer communication protocol is embodied in a software-interrupt thread.



special file
See [device special file]
SPI
See [security-parameter index]
spin mutex

A spin mutex will not relinquish the CPU when it cannot immediately get the requested lock, but it will loop, waiting for the mutex to be released by another CPU.



stack

An area of memory set aside for temporary storage or for procedure and interrupt-service linkages. A stack uses the last-in, first-out (LIFO) concept. On most architectures, the stack grows from high memory addresses to low memory addresses. As items are added to (pushed onto) the stack, the stack pointer decrements; as items are retrieved from (popped off) the stack, the stack pointer increments.



stack segment

A segment that holds a stack.

See also [bss segment]
See also [data segment]
See also [text segment]


stale translation

A translation or mapping that was previously true, but is no longer valid. For example, on machines that have a translation lookaside buffer, if a page-table entry in memory is changed to alter the mapping, any address translation for that page that is present in the translation lookaside buffer must be flushed to avoid a stale translation.



standalone device driver

A device driver that is used in a standalone program. A standalone device driver usually differs from a device driver used in an operating system in that it does not have interrupt services, memory management, or full support for virtual-memory mapping. In the FreeBSD standalone I/O library, for example, a standalone device driver polls a device to decide when an operation has completed and is responsible for setting up its own memory mapping when doing transfers between the device and main memory.



standalone I/O library

A library of software that is used in writing standalone programs. This library includes standalone device drivers that are used to do I/O.



standalone program

A program that can run without the support of an operating system.



standard error

The I/O stream on which error messages are conventionally placed. This stream is usually associated with descriptor 2 in a process.



standard input

The I/O stream on which input is conventionally received. This stream is usually associated with descriptor 0 in a process.



standard output

The I/O stream to which output is conventionally directed. This stream is usually associated with descriptor 1 in a process. start routine A device-driver routine that is responsible for starting a device operation after the system has acquired all the resources that are required for the operation.



stateless server

A server that does not need to maintain any information about which clients it is serving or which data have been passed to them. Every request that is received by such a server must be completely self-contained, providing all information needed to fulfill it.



sticky bit

The bit in an inode representing a directory that shows that an unprivileged user may not delete or rename files of other users in that directory. The sticky bit may be set by any user on a directory that the user owns or for which she has appropriate permissions. Historically, the bit in an inode that indicated that the text segment of the program was to be shared and kept memory or swap-space resident because of expected future use. That bit is no longer needed for this use because the virtual-memory system tracks recently used executables.



stream socket

A type of socket that models a reliable, connection-based byte stream that can support out-of-band data transmission.



superblock

A data structure in the on-disk filesystem that specifies the basic parameters of the filesystem.



superuser

The user whose UID is 0. Processes owned by the superuser are granted special privileges by UNIX. The superuser's login name is usually root.



swap area

A region on secondary storage that is used for swapping and paging.



swap device

A device on which a swap area resides.



swapper

In FreeBSD, the name of the kernel process that implements the swapping portion of the memory-management facilities. Historically, the swapper is process 0.

See also [pagedaemon]


swapping

A memory-management algorithm in which entire processes are moved to and from secondary storage when main memory is in short supply.



swap space
See [swap area]
symbolic link

A file whose contents are interpreted as a pathname when it is supplied as a component of a pathname. Also called a soft link.

See also [hard link]


symmetric cryptography

A cryptographic system that uses the same key to encrypt data as it does to decrypt data, sometimes referred to as secret key cryptography.

See also [asymmetric cryptography]


symmetric multiprocessing (SMP)

A multiprocessor consists of two or more CPUs connected to a common main memory. Symmetric multiprocessing describes a kernel that can run simultaneously on all the CPUs at the same time.

See also [symmetric multithreading]


symmetric multithreading (SMT)

A processor that has multiple CPU cores on which threads can be run is said to support symmetric multithreading. Each core acts as a processor itself, but all cores on the CPU share the same cache memory.



synchronous

Synchronized with the currently running process. For example, in UNIX, all I/O operations appear to be synchronous: The read and write system calls do not return until the operation has been completed. (For a write, however, the data may not really be written to their final destination until some time later for example, in writing to a disk file.)



system activity

An entry into the kernel. System activities can be categorized according to the event or action that initiates them: system calls, hardware interrupts, hardware traps, and software-initiated traps or interrupts.



system call

In operating systems, a request to the system for service; also called a system service request.



system clock

The device that maintains the system's notion of time of day. On most systems, this device is an interval timer that periodically interrupts the CPU. The system uses these interrupts to maintain the current time of day and to do periodic functions such as thread scheduling.



system mode
See [kernel mode]
tags

An extensible system for adding arbitrary data to an mbuf or mbuf cluster for communicating information between different modules in the network stack without having to modify the packet data.



TCB
See [thread control block]
TCP
See [transmission control protocol]
terminal

In computer systems, a device used to enter and receive data interactively from a computer. Most terminals include a CRT, which displays data that are received from a computer. In the Electrical Industry Association (EIA) standard RS-232-C for connecting computers and data-terminal equipment (DTE), a terminal is a device that is placed at the other end of a wire that is connected to data-communications equipment (DCE). In this standard, a terminal might be any type of device, rather than only a device on which people type.



termios structure

The structure used to describe terminal state. Terminal state includes special characters, such as the erase, kill, and word-erase characters; modes of operation, such as canonical or noncanonical; and hardware serial-line parameters, such as parity and baud rate.



text segment

The segment of a program that holds machine instructions. The system usually makes a program's text segment read-only and shareable by multiple processes when the program image is loaded into memory.

See also [bss segment]
See also [data segment]
See also [stack segment]


thrashing

A condition where requested memory utilization far exceeds the memory availability. When a machine is thrashing, it usually spends more time doing system-related tasks than executing application code in user mode.



thread

The unit of execution of a process. A thread requires an address space and other resources, but it can share many of those resources with other threads. Threads sharing an address space and other resources are scheduled independently and can all do system calls simultaneously.



thread control block (TCB)

A data structure used to hold thread context. The hardware-defined TCB contains the hardware portion of this context. The software TCB contains the software portion and is located in memory immediately after the hardware TCB.



tick

An interrupt by the system clock.



time quantum

In a timesharing environment, the period of time that the process scheduler gives a process to run before it preempts that process so that another process can execute. Also called a time slice.



timer backoff

The rate at which a timer value is increased. For example, in TCP, the value of the retransmit timer is determined by a table of multipliers that provide a near-exponential increase in timeout values.



time slice
See [time quantum]
time-stable identifier

An identifier that refers uniquely to some entity both while it exists and for a long time after it is deleted. A time-stable identifier allows a system to remember an identity across transient failures and to detect and report errors for attempts to access deleted entities.



TLB
See [translation lookaside buffer]
top half

With regard to system operation, the routines in the kernel that are invoked synchronously as a result of a system call or trap. These routines depend on per-process state and can block by calling sleep().

See also [bottom half]


trace trap

A trap used by the system to implement single-stepping in program debuggers. On architectures that provide trace-bit support, the kernel sets the hardware-defined trace bit in the context of the thread being debugged and places the thread on the run queue. When the thread next runs, the trace bit causes a trap to be generated after the thread executes one instruction. This trap is fielded by the kernel, which stops the thread and returns control to the debugging process.



track

In computer systems, the sectors of a disk that are accessible by one head at one of its seek positions.



track cache

When the kernel is reading from a disk, memory associated with the disk that holds data that are passing under the disk heads regardless of whether they have been requested explicitly. When the kernel is writing to a disk, memory associated with the disk in which data are stored until the disk heads reach the correct position for writing them.



translation lookaside buffer (TLB)

A processor cache containing translations for recently used virtual addresses.



transmission control protocol (TCP)

A connection-oriented transport protocol used in the Internet. TCP provides for the reliable transfer of data, as well as for the out-of-band indication of urgent data.



transport layer

The layer of software in the network subsystem that is responsible for moving data between two sockets. Depending on the type of transport protocol used, the data may be delivered as a sequenced, in-order stream or as an unordered set of individual messages. See also , unreliable datagram protocol.

See also [transmission control protocol]


transport mode

One of two modes used for secure communications in IPSec. In transport mode only the payload of a packet is protected, whereas the network layer protocol header is left exposed.

See also [tunnel mode]


triple indirect block
See [indirect block]
tty driver

The software module that implements the semantics associated with a terminal or pseudo-terminal device.

See also [line discipline]


tunnel mode

One of two modes used for secure communication in IPSec. In tunnel mode, the packet to be secured is completely contained within another packet that carries the inner packet between two endpoints. The endpoints are the boundaries of the tunnel.

See also [transport mode]


2MSL timer

A timer used by the TCP protocol during connection shutdown. The name refers to the fact that the timer is set for twice the maximum time that a segment may exist in the network. This value is chosen to ensure that future connections will not mistakenly accept late messages from an older connection.

See also [maximum segment lifetime]


type-ahead

Transmission of data to a system, usually by a user typing at a keyboard, before the data are requested by a process.



UDP
See [user datagram protocol]
UID
See [user identifier]
uio

A data structure used by the system to describe an I/O operation. This structure contains an array of iovec structures; the file offset at which the operation should start; the sum of the lengths of the I/O vectors; a flag showing whether the operation is a read or a write; and a flag showing whether the source and destination are both in the kernel's address space or whether the source and destination are split between user and kernel address spaces.

See also [iovec]


update dependency

The required ordering of related updates to separate metadata structures to ensure recoverability in the presence of unpredictable failures. An update that must be done later has an update dependency on an earlier update because it cannot be done until the earlier update is committed to stable storage.

See also [metadata]


urgent data

In TCP, data that are marked for urgent delivery.



user datagram protocol (UDP)

A simple, unreliable datagram protocol used in the Internet protocols. UDP provide peer-to-peer, multicast and broadcast addressing and optional data checksums A single version of UDP works the same way on top of both IPv4 and IPv6.



user identifier (UID)

A nonnegative integer that identifies a user uniquely. UIDs are used in the access-control facilities provided by the filesystem. saved user identifier

See also [credential]
See also [effective user identifier]
See also [real user identifier]
See also [set-user-identifier program]


user mode

The least-privileged processor-access mode. User processes run in user mode.

See also [kernel mode]


user-request routine

A set of routines provided by each communication protocol that directly supports a socket (a protocol that indirectly supports a socket is layered underneath a protocol that directly supports a socket). These routines serve as the main interface between the layer of software that implements sockets and the communication protocol. The interprocess-communication facilities make calls to the user-request routines for most socket-related system calls.

See also [connect request]
See also [control request]
See also [listen request]
See also [sense request]


user structure

A data structure maintained by the kernel for each active process in the system. The user structure contains the process statistics and signal actions. For compatibility with older debuggers, much of the process state is copied to the user structure before generating a core dump. Unlike the process structure, the user structure for a process is moved to secondary storage if the process is swapped out. Also referred to as the u-dot area and user area.



virtual address

An address that references a location in a virtual address space.



virtual-address aliasing

Two or more processes mapping the same physical page at different virtual addresses. When using an inverted page table, there can only be one virtual address mapping any given physical page at any one time. Here, the kernel must invalidate the page-table entry for the aliased page whenever it switches between the processes with the conflicting virtual addresses for that page.

See also [inverted page table]


virtual address space

A contiguous range of virtual-memory locations.



virtual machine

A machine whose architecture is emulated in software.



virtual memory

A facility whereby the effective range of addressable memory locations provided to a process is independent of the size of main memory; that is, the virtual address space of a process is independent of the physical address space of the CPU.



virtual-memory object

A kernel data structure that represents a repository of data for example, a file. An object contains a pager to get and put the data from and to secondary storage, and a list of physical pages that cache pieces of the repository in memory.



vnode

An extensible object-oriented interface containing generic information about a file. Each active file in the system is represented by a vnode, plus filesystem-specific information associated with the vnode by the filesystem containing the file. The kernel maintains a single systemwide table of vnodes that is always resident in main memory. Inactive entries in the table are reused on a least-recently used basis.



wait

The system call that waits for the termination of a descendant process.



wait channel

A value used to identify an event for which a thread is waiting. In most situations, a wait channel is defined as the address of a data structure related to the event for which a thread is waiting. For example, if a thread is waiting for the completion of a disk read, the wait channel is specified as the address of the buffer data structure supplied to the disk I/O system.



wildcard route

A route that is used if there is no explicit route to a destination.



window probe

In TCP, a message that is transmitted when data are queued for transmission, the send window is too small for TCP to bother sending data, and no message containing an update for the send window has been received in a long time. A window-probe message contains a single octet of data.



wired page

Memory that is not subject to replacement by the pageout daemon. A nonpageable range of virtual addresses has physical memory assigned when the addresses are allocated. Wired pages must never cause a page fault that might result in a blocking operation. Wired pages are typically used in the kernel's address space.



word-erase character

The character that is recognized by the terminal handler in canonical mode to mean "delete the most recently typed word on this terminal." By default, preceding whitespace and then a maximal sequence of nonwhitespace characters are erased. Alternatively, an alternate erase algorithm tuned to deleting pathname components may be specified. Each terminal session can have a different word-erase character, and the user can change that character at any time with an tcsetattr system call. The terminal handler does not recognize the word-erase character on terminals that are in non-canonical mode.

See also [erase character]
See also [kill character]


working directory
See [current working directory]
working set

The set of pages in a process's virtual address space to which memory references have been made over the most recent few seconds. Most processes exhibit some locality of reference, and the size of their working set is typically less than one-half of their total virtual-memory size.



write-caching lease

A write-caching lease is issued by an NFS server to a client to allow the client to cache reads and writes for the period of the lease.

See also [noncaching lease]
See also [read-caching lease]


zombie process

A process that has terminated but whose exit status has not yet been received by its parent process (or by init).




   
 


The Design and Implementation of the FreeBSD Operating System
The Design and Implementation of the FreeBSD Operating System
ISBN: 0201702452
EAN: 2147483647
Year: 2003
Pages: 183

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net