A block of contiguous physical memory used to store the contents of a virtual page. Note that the virtual page size and page frame size are usually identical, but that a page frame size is actually microprocessor-dependent.
See pool memory.
A system file containing the contents of virtual pages that have been paged out of memory. See also backing store and system paging file.
Peripheral component interconnect
A dynamically configurable I/O bus, described by the PCI Local Bus Specification published by the PCI SIG.
Personal computer memory card international association
Processor control registers
An internal data structure in which the Kernel stores per-processor information.
Process environment block
Page frame number
Also, the database in which the NT Memory Manager maintains information about every physical page in the system. Each PFN is an index for a physical page in the array of records that makes up the PFN database. See also PTE.
Programmed I/O (a.k.a. abbreviation for “parallel input/output”)
A technique of making data transfers between a device and system memory using remapped system-space virtual addresses, rather than DMA.
A pernicious, but sometimes necessary, coding technique that wastes CPU cycles in a driver until the physical device updates its registers. NT device drivers should never implement polling loops and should minimize the interval they specify in calls to KeStallExecutionProcessor (no longer than 50 microseconds) if they must poll their devices.
Regions located in kernel space from which memory blocks can be allocated and deallocated dynamically. (Some other systems call this “heap memory.”) The NT Memory Manager creates two kinds of pools for system use and for use by drivers via Ex(ecutive) Support routine calls:
· Paged pool is a based region that can be paged in and out of a process’s working set. Each process has its own set of PTEs that map paged pool into its address space. Touching a page in this pool can cause a page fault at any time, so NT drivers should allocate only those data structures accessed exclusively at IRQL PASSIVE_LEVEL or APC_LEVEL (see IDT) from paged pool.
· Nonpaged pool is a based region for which all processes share a set of PTEs. The NT Memory Manager guarantees that nonpaged pool is resident in physical memory at all times; therefore, this region can be accessed from any process’s address space without causing a page fault. However, nonpaged pool is a limited system resource.
NT drivers should allocate from paged pool for entities that are accessed exclusively at or below IRQL APC_LEVEL and in a nonarbitrary thread context. They should minimize their usage of nonpaged pool by “saving” it for data that must be accessed at or above IRQL DISPATCH_LEVEL. Allocations of contiguous or noncached memory come from nonpaged pool.
The Memory Manager allocates entities from both pools using a buddy scheme. See also kernel space.
An instance of an object type representing a conduit for messages between local (server/client) processes. It is used in the LPC (Local Procedure Call) model of NT as an object accessible to user-mode processes through system services. The server (callee) process defines a named connection port object and sets up two (unnamed) communication port objects when a client (caller) process connects to the named port.
A lowest-level NT driver that responds to a set of system-defined device control requests and, possibly, to an additional set of driver-defined (private) device control requests, sent down by a corresponding class driver. A port driver insulates class drivers from the specifics of HBAs and synchronizes operations for all its class drivers. Some examples of system-supplied port drivers include the following:
(1) The NT SCSI port driver that supports a set of device-type-specific class drivers, and possibly SFDs, above it and one or more HBA-specific miniport drivers, and possibly nonSCSI mass-storage device drivers, which link themselves to this OS-dependent port driver (implemented as a dynamic-link library) and call its ScsiPortXxx routines.
(2) The NT video port driver that supports display drivers and adapter-specific, kernel-mode miniport drivers, which link themselves to the NT-dependent port driver (implemented as a dynamic-link library) and call its VideoPortXxx routines.
(3) The NT parallel port driver.
In general, any driver of a device that is a so-called “intelligent controller” or a bus adapter can be a port driver if it communicates with one or more class drivers according to an established protocol and synchronizes access to the controller or bus.
See also class driver, miniport driver, ScsiPort routines, and VideoPort routines.
Portable operating system for (UN)IX
A Windows NT protected subsystem that supports the POSIX standard.
Processor control block
An extension of the PCR.
An attribute of a thread that determines when and how often it is scheduled to run. For a running thread, its priority falls into either of two classes, each class with sixteen levels:
· Variable priority class has values in the range 0 to 15. This class is used by most threads.
Threads with variable priority are always preemptible; that is, they are scheduled to run round-robin with other threads at the same level. In general, the Kernel manages a variable-priority thread as follows: when the thread is interactive with a user, its priority is high (given a boost); otherwise, its priority decays by one level per quantum the thread runs until it reaches its original programmer-defined base priority level.
· Real-time priority class has values in the range 16 to 31. This class is used by time-critical threads, making such a thread preemptible only by a thread with higher priority.
Note that any thread, whatever its priority attribute, is always preemptible by a software or hardware interrupt.
A set of system-defined constant values, supplied when NT drivers complete an IRP. For example, drivers for interactive devices usually call IoCompleteRequest with a device-type-specific priority boost value. The boost is added to the priority of the user-mode thread that originally requested the I/O operation to compensate for that thread’s wait on the I/O.
To check whether a memory access of a particular kind (such as read) to a data entity, such as a handle for an object or a buffer, is allowed without causing an access violation. Note that user-supplied parameter values are always probed and captured on the kernel stack before an NT system service gets control in kernel mode. The system service is responsible for probing whatever a captured pointer accesses.
A Kernel-defined control object type, representing the virtual address space and control information necessary for the execution of a set of thread objects. A user-mode process object defines the base priority, default affinity, and directory table base value for its threads and for any child processes it creates. Every user-visible process object is implemented through the use of an embedded kernel-mode process object.
A kernel-mode-only process object must be initialized before any thread objects that belong to the process.
A server that appears to perform operating system functions for its native applications and subsystem-specific drivers by calling system services. A protected subsystem runs in user mode and its interface to end users emulates another operating system, such as Windows or POSIX, on top of NT. See also integral subsystem.
Page table entry
The Memory Manager uses a PTE to represent the state of a virtual page.
To set an event to the Signaled state, satisfy as many waiters on the event as possible, and to reset the event to the Not-Signaled state.