The PoFxStartDevicePowerManagement routine completes the registration of a device with the power management framework PoFx and starts device power management. The ComponentActiveConditionCallback callback routine notifies the driver that the specified component completed a transition from the idle condition to the active condition.
The ComponentIdleConditionCallback callback routine notifies the driver that the specified component completed a transition from the active condition to the idle condition. The ComponentIdleStateCallback callback routine notifies the driver of a pending change to the Fx power state of the specified component. The ComponentPerfStateCallback callback routine notifies the driver that its request to change the performance state of a component is complete.
The DevicePowerNotRequiredCallback callback routine notifies the device driver that the device is not required to stay in the D0 power state. The DevicePowerRequiredCallback callback routine notifies the device driver that the device must enter and remain in the D0 power state. The PowerControlCallback callback routine performs a power control operation that is requested by the power management framework PoFx.
An EnumerateInterruptSource callback routine supplies a platform extension plug-in PEP with information about an interrupt source. The EnumerateUnmaskedInterrupts routine enumerates interrupt sources whose interrupts are unmasked and enabled. The PlatformIdleVeto routine increments or decrements the veto count for a veto code for a platform idle state.
The ProcessorIdleVeto routine increments or decrements the veto count for a veto code for a processor idle state. The RequestInterrupt routine requests that the operating system replay an edge-triggered interrupt that might have been lost while the hardware platform was in a low-power state.
The RequestWorker routine is called by a platform extension plug-in PEP to inform the Windows power management framework PoFx that the platform extension plug-in PEP has a work request to submit on behalf of the specified device. The UpdatePlatformIdleState routine is called by the platform extension plug-in PEP to update the properties of the specified platform idle state.
The UpdateProcessorIdleState routine is called by the platform extension plug-in PEP to update the properties of the specified processor idle state. The ComponentCriticalTransitionCallback callback routine handles a transition of the specified component between the F0 fully on and low-power Fx component power states.
The ClfsAlignReservedLog routine calculates the size of the space that must be reserved for a specified set of records.
The size calculation includes the space required for headers and the space required for sector alignment. The ClfsCloseAndResetLogFile routine releases all references to a specified log file object and marks its associated stream for reset. If necessary, ClfsCreateLogFile also creates the underlying physical log that holds the stream's records.
The ClfsCreateMarshallingArea routine creates a marshalling area for a CLFS stream and returns a pointer to an opaque context that represents the new marshalling area. The ClfsLsnCreate routine creates a log sequence number LSN , given a container identifier, a block offset, and a record sequence number. The two LSNs must be from the same stream. The ClfsReadLogRecord routine reads a target record in a CLFS stream and returns a read context that the caller can use to read the records preceding or following it in the stream.
The ClfsReadNextLogRecord routine reads the next record in a sequence, relative to the current record in a read context. The ClfsReadPreviousRestartArea routine reads the previous restart record relative to the current record in a read context. The ClfsReserveAndAppendLog routine reserves space in a marshalling area or appends a record to a marshalling area or does both atomically.
The ClfsReserveAndAppendLogAligned routine reserves space in a marshalling area or appends a record to a marshalling area or does both atomically. The record's data is aligned on specified boundaries. The ClfsSetLogFileInformation routine sets metadata and state information for a specified stream and its underlying physical log. The ClfsTerminateReadLog routine invalidates a specified read context after freeing resources associated with the context.
Registers a driver-supplied IoCompletion routine for an IRP, so the IoCompletion routine is called when the next-lower-level driver has completed the requested operation in one or more of the following ways: successfully, with an error, or by canceling the IRP.
Releases the cancel spin lock when the driver has changed the cancelable state of an IRP or releases the cancel spin lock from the driver's Cancel routine. Writes partition tables for a disk, given the device object representing the disk, the sector size, and a pointer to a buffer containing the drive geometry. Allocates and initializes an error log packet; returns a pointer so that the caller can supply error-log data and call IoWriteErrorLogEntry with the packet. Queues a previously allocated and filled-in error log packet to the system error logging thread.
Supplies the device object for which the given IRP was failed due to a user-induced error, such as supplying the incorrect media for the requested operation or changing the media before the requested operation was completed. A file system driver uses the associated device object to notify the user, who can then correct the error or retry the operation. Notifies the user that the given IRP was failed on the given device object for an optional VPB, so that the user can correct the error or retry the operation.
Raises an error status and causes a caller-supplied structured exception handler to be called. Useful only to highest-level drivers that supply exception handlers, in particular to file systems.
Dequeues the next IRP for a device object according to a specified sort-key value, specifies whether the IRP is cancelable, and calls the driver's StartIo routine. Returns the initial base address of the current thread's stack. Useful only to highest-level drivers. Returns the boundaries of the current thread's stack frame. A buffer that will contain the data to be read or that contains the data to be written.
The length of the buffer in bytes. The starting offset on the media. Returns a pointer to the IRP so the caller can set any necessary minor function code and set up its IoCompletion routine before sending the IRP to the target driver. An event object to be set to the Signaled state when the requested operation completes.
The stack location must have been allocated by a preceding call to IoAllocateIrp that specified a stack-size argument large enough to give the caller its own stack location. Drivers that split large transfer requests into a number of smaller transfers can call this routine. Allocates and initializes an IRP to be associated with a master IRP sent to the highest-level driver, allowing the driver to "split" the original request and send associated IRPs on to lower-level drivers or to the device.
Registers a driver-supplied IoCompletion routine with a given IRP, so that the IoCompletion routine is called when lower-level drivers have completed the request. Creates or opens a file object representing a physical, logical, or virtual device, a directory, a data file, or a volume. Returns information about the mapping between generic access rights and specific access rights for file objects. Synchronizes the execution of a driver-supplied SynchCritSection routine with that of the ISR associated with a set of interrupt objects, given a pointer to the interrupt objects.
This routine reserves exclusive access to a DMA channel and map registers for the specified device. Releases an adapter object, representing a system DMA channel, and optionally releases map registers, if any were allocated. Releases a set of map registers that were saved from a call to AllocateAdapterChannel, after the registers have been used by IoMapTransfer and the bus-master DMA transfer is complete. This routine reserves exclusive access to the hardware controller for the specified device.
Releases a controller object, provided that all device operations queued to the controller for the current IRP have completed. Enables the timer for a given device object and calls the driver-supplied IoTimer routine once per second thereafter. Disables the timer for a given device object so that the driver-supplied IoTimer routine is not called unless the driver reenables the timer. Sets the absolute or relative interval at which a timer object will be set to the Signaled state and optionally supplies a timer DPC to be executed after the interval expires.
Sets the absolute or relative interval at which a timer object will be set to the Signaled state, optionally supplies a timer DPC to be executed when the interval expires, and optionally supplies a recurring interval for the timer. Cancels a timer object before the interval passed to KeSetTimer expires; dequeues a timer DPC before the timer interval, if any was set, expires. Dequeues the next IRP, according to the specified sort-key value, for a given device object.
Registers a driver-supplied IoCompletion routine with a given IRP, so the IoCompletion routine is called when the next-lower-level driver has completed the requested operation in one or more of the following ways: successfully, with an error, or by canceling the IRP.
Acquires an initialized resource for exclusive access by the calling thread and optionally waits for the resource to be acquired. Acquires an initialized resource for shared access by the calling thread and optionally waits for the resource to be acquired. Acquires a given resource for shared access without waiting for any pending attempts to acquire exclusive access to the same resource.
Acquires a given resource for shared access, optionally waiting for any pending exclusive waiters to acquire and release the resource first. Reads data from an open file. Writes data to an open file. Sets or clears the Cancel routine in an IRP during a cancelable state transition.
Setting a Cancel routine makes an IRP cancelable. An initialized spin lock also is a required parameter to the ExInterlockedXxx routines. Acquires a spin lock so the caller can synchronize access to shared data safely on multiprocessor platforms. Acquires a queued spin lock so the caller can synchronize access to shared data safely on multiprocessor platforms.
Insert and remove IRPs in a driver-managed internal queue, which is protected by an initialized spin lock for which the driver provides the storage. Insert and remove IRPs in a driver-allocated and managed internal device queue object, which is protected by a built-in spin lock. Adds a value to a variable of type ULONG as an atomic operation, using a spin lock to ensure multiprocessor-safe access to the variable; returns the value of the variable before the call occurred.
Increments a variable of type LONG as an atomic operation. The sign of the return value is the sign of the result of the operation. Decrements a variable of type LONG as an atomic operation. Sets a variable of type LONG to a specified value as an atomic operation; returns the value of the variable before the call occurred. Adds a value to a given integer variable as an atomic operation; returns the value of the variable before the call occurred.
Compares the values referenced by two pointers. If the values are equal, resets one of the values to a caller-supplied value in an atomic operation.
Compares the pointers referenced by two pointers. If the pointer values are equal, resets one of the values to a caller-supplied value in an atomic operation.
Associates a timer with the given device object and registers a driver-supplied IoTimer routine for the device object. Enables the timer for a given device object and calls the driver-supplied IoTimer routine once every second. Disables the timer for a given device object so the driver-supplied IoTimer routine is not called unless the driver reenables the timer.
Initializes a DPC object and sets up a driver-supplied CustomTimerDpc routine that can be called with a given context. Sets the absolute or relative interval at which a timer object will be set to the Signaled state; optionally supplies a timer DPC to be executed when the interval expires.
Sets the absolute or relative interval at which a timer object will be set to the Signaled state; optionally supplies a timer DPC to be executed when the interval expires; and optionally supplies a recurring interval for the timer. Returns the number of nanosecond units that are added to the system time at each interval-timer interrupt. Returns the current value of the system interrupt-time count in nanosecond units, with accuracy to within system clock tick. Returns the current value of the system interrupt-time count in nanosecond units, with accuracy to within a microsecond.
Initializes a resource, for which the caller provides the storage, to be used for synchronization by a set of threads shared readers, exclusive writers. Returns the number of threads currently waiting to acquire a given resource for exclusive access.
Queues an initialized work queue item so the driver-supplied routine will be called when a system worker thread is given control. Sets the absolute or relative interval at which a timer object will be set to the Signaled state, and optionally supplies a timer DPC to be executed when the interval expires.
Sets the absolute or relative interval at which a timer object will be set to the Signaled state. Optionally supplies a timer DPC to be executed when the interval expires and a recurring interval for the timer.
Cancels a timer object before the interval passed to KeSetTimer expires. Dequeues a timer DPC before the timer interval if any expires. Returns the previous state of a given event object and sets the event if not already Signaled to the Signaled state.
Returns the current state nonzero for Signaled or zero for Not-Signaled of a given event object. Acquires an initialized fast mutex, possibly after putting the caller into a wait state until it is acquired, and gives the calling thread ownership with APCs disabled. Acquires an initialized fast mutex, possibly after putting the caller into a wait state until it is acquired. Releases a given mutex object, specifying whether the caller will call one of the KeWaitXxx routines as soon as KeReleaseMutex returns the previous value of the mutex state a zero for Signaled; otherwise, Not-Signaled.
Returns the current state one for Signaled or any other value for Not-Signaled of a given mutex object. Releases a given semaphore object. Supplies a run-time priority boost for waiting threads if the release sets the semaphore to the Signaled state. Augments the semaphore count by a given value and specifies whether the caller will call one of the KeWaitXxx routines as soon as KeReleaseSemaphore returns. Returns the current state zero for Not-Signaled or a positive value for Signaled of a given semaphore object.
Puts the current thread into an alertable or nonalertable wait state until a given dispatcher object is set to the Signaled state or optionally until the wait times out. Puts the current thread into an alertable or nonalertable wait state until a given mutex is set to the Signaled state or optionally until the wait times out. Puts the current thread into an alertable or nonalertable wait state until any one or all of a number of dispatcher objects are set to the Signaled state or optionally until the wait times out.
Special kernel-mode APCs are still delivered. Reenables, as soon as possible, the delivery of normal kernel-mode APCs that were disabled by a preceding call to KeEnterCriticalRegion.
Saves the current thread's nonvolatile floating-point context so that the caller can carry out its own floating-point operations. Restores the previous nonvolatile floating-point context that was saved with KeSaveFloatingPointState. Registers a highest level driver's callback routine that is subsequently executed whenever a new process is created or existing process deleted.
Registers a highest level driver's callback routine that is subsequently executed whenever a new thread is created or an existing thread is deleted.
Registers a callback routine for a highest level system-profiling driver. The callback routine is subsequently executed whenever a new image is loaded for execution.
Allocates optionally cache-aligned pool memory from paged or nonpaged system space. The caller-supplied tag is put into any crash dump of memory that occurs. After successful initialization of the list, fixed-size blocks can be allocated from, and freed to, the lookaside list. Removes the first entry from the specified lookaside list in nonpaged memory. If the lookaside list is empty, allocates an entry from nonpaged pool.
Returns an entry to the specified lookaside list in nonpaged memory. If the list has reached its maximum size, returns the entry to nonpaged pool. After successful initialization of the list, fixed-size blocks can be allocated from and freed to the lookaside list. Removes the first entry from the specified lookaside list in paged memory. If the lookaside list is empty, allocates an entry from paged pool.
Returns an entry to the specified lookaside list in paged memory. If the list has reached its maximum size, returns the entry to paged pool. Returns TRUE if the machine is running as a server.
Allocates a virtual address range of noncached and cache-aligned memory in nonpaged system space pool. Releases a virtual address range of noncached memory in nonpaged system space when the driver unloads. Allocates and maps a logically contiguous region of memory that is simultaneously accessible both from the processor and from a device, given access to an adapter object, the requested length of the memory region to allocate, and access to variables where the starting logical and virtual addresses of the allocated region are returned.
Returns TRUE if the requested length was allocated. Releases an allocated common buffer and unmaps it, given access to the adapter object, the length, and the starting logical and virtual addresses of the region to be freed when the driver unloads. Arguments must match those passed in the call to AllocateCommonBuffer. Compares data, given pointers to caller-supplied buffers and the length in bytes for the comparison.
Returns the number of bytes that are equal. Copies the data from one caller-supplied buffer to another, given pointers to both buffers and the length in bytes to be copied.
Copies the data from one caller-supplied memory range to another, given pointers to the base of both ranges and the length in bytes to be copied. Fills a caller-supplied buffer with the specified UCHAR value, given a pointer to the buffer and the length in bytes to be filled. Fills a buffer with zeros, given a pointer to the caller-supplied buffer and the length in bytes to be filled. Retrieves a USHORT value at a given address, avoiding alignment faults, and stores the value at a given address that is assumed to be aligned.
Retrieves a ULONG value at a given address, avoiding alignment faults, and stores the value at a given address that is assumed to be aligned. Fills in the corresponding physical addresses of a given MDL that specifies a range of virtual addresses in nonpaged pool. Allocates and initializes an MDL describing a buffer specified by the given virtual address and length in bytes; returns a pointer to the MDL.
Returns a possibly invalid virtual address for a buffer described by a given MDL; the returned address, used as an index to a physical address entry in the MDL, can be input to MapTransfer for drivers that use DMA. If no virtual address exists, one is assigned. Initializes a caller-created MDL to describe a buffer specified by the given virtual address and length in bytes. Returns whether a page fault will occur if a read or write operation is done at the given virtual address.
Maps a physical address range to a cached or noncached virtual address range in nonpaged system space. Maps already locked physical pages, described by a given MDL, to a returned virtual address range. Probes the pages specified in an MDL for a particular kind of access, makes the pages resident, and locks them in memory; returns the MDL updated with corresponding physical addresses.
Usually, only highest-level drivers call this routine. Secures a memory-address range so that it cannot be freed and its page protection cannot be made more restrictive. Returns the number of bytes required for an MDL describing the buffer specified by the given virtual address and length in bytes.
Releases a section that was previously locked into system space when the driver is no longer processing IRPs, or when the contents of the section are no longer required.
Lets a driver page all of its code and data regardless of the attributes of the various sections in the driver's image. Resets a driver's pageable status to that specified by the sections making up the driver's image. Maps a view of an open section into the virtual address space of a process.
Returns an offset into the section base of the mapped view and the size mapped. Returns the base address of an instance of a structure given the structure type and the address of a field within it. Notifies the PnP manager that the PnP state of a device has changed. Claims hardware resources in the configuration registry for a legacy device. This routine is for drivers that detect legacy hardware that cannot be enumerated by PnP. Returns a list of device interfaces of a particular device interface class such as all devices on the system that support a HID interface.
Returns the alias device interface of the specified interface class, if the alias exists. Device interfaces are considered aliases if they are exposed by the same underlying device and have identical interface reference strings, but are of different interface classes. Notifies the PnP manager that a custom event has occurred on a device. The PnP manager sends notification of the event to drivers that registered for it. Returns immediately and does not wait while the PnP manager sends notification of the event to drivers that registered for it.
Initializes a remove lock for a device object. Increments the count for a remove lock, indicating that the associated device object should not be detached from the device stack nor deleted.
Releases a remove lock acquired with a previous call to IoAcquireRemoveLock and waits until all acquisitions of the lock have been released. Increments or decrements a caller-supplied page-file counter as an atomic operation. This routine can be used to adjust other counters, such as counters for hibernation files or crash-dump files. Notifies the PnP manager that the device eject button was pressed.
This multiplicity is even without the complication of free and checked builds. The latter are offered by Microsoft as an aid to debugging and since they are explicitly not for real-world use they are all but ignored at this website.
It applies only to bit x86 builds. The point to having separate builds for PAE is that the memory manager is specialised to use bit or bit page table entries. This is not a choice that will change mid-flight and so the loaded kernel is better to have code for only one or the other, not both.
An installed system has either the single-processor kernels or the multi-processor kernels but not both. EXE as if for a single-processor system. Starting with version 6. In the versions that install both, the loader has the two standard names hard-coded. The following bit x86 builds have been inspected for these notes. Most are from MSDN discs. Some, especially since Microsoft greatly reduced its shipment of operating systems on MSDN discs, are from service packs downloaded typically as self-extracting executables from a Microsoft website.
Special mention must be made of the very oldest builds. Even among the many discs that I retain from MSDN subscriptions in the s, what was then the new Windows that is entirely its own operating system rather than a large DOS program goes no further back than Windows NT 3.
H, some do not. These others are miniport drivers. If only in principle, they interact only with a designated port driver, not directly with the kernel. H instead. Moroever, such repetitions are not limited just to headers that get included as standard. H share a run of lines. If there was not some coordination right from the start, there surely was at least a plan that each sequence in common has one master definition.
Some indication is visible in the published headers as comments, which become the second part to this old clue. Some of the repeated sequences are, in some of the affected headers, bracketed by comments in a particular form. Some repeated lines, again only in some of the headers, end with single-line comments in a particular form.
H, reproduced exactly except for being stripped of the single-line comment. H but the reader of the latter is not warned that these lines are shared with the former. More plausible is that the comments are remnants, perhaps left carelessly, of automation. H itself are each prepared from some script or some master header that contains directions to pull in lines from other masters. Signs of what such master headers may even be named, let alone of what they contain, were initially few in any published DDK or SDK.
The relationship is more direct in a new header, SDDL. H, from an SDK dated January That the file extension. Thus have the. By now, after many years, there has been a relative proliferation. Was this reply helpful? Yes No. Sorry this didn't help. Thanks for your feedback. This thread is locked. You can follow the question or vote as helpful, but you cannot reply to this thread.
I have the same question Report abuse.
0コメント