Developing Windows NT Device Drivers
Addison Wesley (Verlag)
978-0-201-69590-8 (ISBN)
- Titel ist leider vergriffen;
keine Neuauflage - Artikel merken
Developing Windows NT Device Drivers: A Programmer's Handbook offers programmers a comprehensive and in-depth guide to building device drivers for Windows NT. Written by two experienced driver developers, Edward N. Dekker and Joseph M. Newcomer, this book provides detailed coverage of techniques, tools, methods, and pitfalls to help make the often complex and byzantine "black art" of driver development straightforward and accessible. This book is designed for anyone involved in the development of Windows NT Device Drivers, particularly those working on drivers for nonstandard devices that Microsoft has not specifically supported. Because Windows NT does not permit an application program to directly manipulate hardware, a customized kernel mode device driver must be created for these nonstandard devices. And since experience has clearly shown that superficial knowledge can be hazardous when developing device drivers, the authors have taken care to explore each relevant topic in depth. This book's coverage focuses on drivers for polled, programmed I/O, interrupt-driven, and DMA devices.The authors discuss the components of a kernel mode device driver for Windows NT, including background on the two primary bus interfaces used in today's computers: the ISA and PCI buses.
Developers will learn the mechanics of compilation and linking, how the drivers register themselves with the system, experience-based techniques for debugging, and how to build robust, portable, multithread- and multiprocessor-safe device drivers that work as intended and won't crash the system. The authors also show how to call the Windows NT kernel for the many services required to support a device driver and demonstrate some specialized techniques, such as mapping device memory or kernel memory into user space. Thus developers will not only learn the specific mechanics of high-quality device driver development for Windows NT, but will gain a deeper understanding of the foundations of device driver design. 0201695901B04062001
Edward N. Dekker is a well-known authority on device drivers. He heads Eclectic Engineering, Inc., a consulting service that specializes in device drivers, systems programming, and real-time systems. For a number of years, his work has focused on device driver development for Windows NT. He has more than 20 years of computer software experience. Joseph M. Newcomer is head of The Joseph M. Newcomer Company, where he specializes in Windows application design, device drivers, and real-time and embedded systems. He has considerable experience in compiler and operating system design and implementation. A frequent contributor to Dr. Dobb's Journal, he has also written several books, including Win32 Programming (with Brent Rector, Addison-Wesley). In addition to his consulting practice, he serves as adjunct senior scientist at Carnegie Mellon University and has been an active contributor to CompuServe and Internet Windows online forums. Dr. Newcomer is one of the principal authors of IDL: The Language and Its Implementation, and is co-inventor on several patents on distributed information technology. In recognition of these contributions, he was named a Most Valuable Professional (MVP) by Microsoft. 0201695901AB04062001
Preface.
Welcome to the World of Device Drivers.
How This Book Happened.
What We Cover.
What We Don't Cover.
The Physics Model for Software.
About URLs.
Documents on the Web.
Icons for insertions.
A Note on “Hungarian Notation.”
NULL and NUL.
The INs and OUTs of Parameters.
Unicode.
Indentation Style.
Acknowledgments.
About the Authors: Joseph M. Newcomer and Edward N. Dekker.
Contacting Us.
Further Reading/Software Sources.
For More Help.
Course Description: Windows NT 4.0: Device Drivers.
1. Driver Overview.
Historical Overview.
NT Architecture Overview.
The Priority System.
NT System Architecture.
User vs. Kernel mode.
The Hardware Abstraction Layer (HAL).
The BIOS and ARC.
The Kernel.
The Executive Services.
Getting From Here to There.
Overview of Device Drivers.
There's Lots More.
Driver Writing: Getting Started.
Using C++.
Planning a Device Driver.
Further Reading.
2. I/O: User Level Overview.
User Level I/O Basics.
Synchronous vs. Asynchronous I/O.
User Level APIs.
Other I/O Operations.
Further Reading.
3. Planning a Device Driver.
Planning the User Level Interface.
Windows NT Is Not a Real-Time System.
Understanding the Application(s).
Understanding the Hardware.
How Does It Work, Really?
ReadFile, WriteFile, DeviceIoControl, and CancelIo.
Address Mapping.
Paged and Non-Paged Memory.
Buffered and Direct Access.
Handling I/O Requests.
Devices and Device Objects.
Devices and Controllers.
Handling Interrupts.
The Deferred Processing Routine.
Synchronization and Serialization.
Driver Threads.
Polled Devices and Interrupt Frequency.
Full-Duplex Devices.
Device Enumeration.
Power Management.
Unloading Drivers.
The Registry.
Event Logging and Journalling.
International Drivers.
Driver Coding.
Driver Testing.
Further Reading.
4. I/O Hardware: Internal Busses.
Device Registers.
Memory Mapped Device Registers.
Shared Memory.
Bus Structures.
ISA Bus.
The MicroChannel (MCA) Bus.
The EISA Bus.
The PCI Bus.
PCI Bridges.
Planning a Device Driver.
Further Reading.
5. Device Driver Basics.
A Taxonomy of Drivers.
Driver Limitations.
The Registry.
Always Preemptible, Always Interruptible.
Multiprocessor Considerations.
I/O Request Packets (IRPs).
Layered Drivers and IRPs.
Asynchronous I/O.
Object-Oriented Structures.
Further Reading.
6. Overview of Kernel Memory: Caching, Paging and Pipelining.
The Virtual Address Space.
The Physical Memory System.
More Sophisticated Caching.
Cache Management on Intel Hardware.
Pipelining: A Form of Caching.
Caching Page Table Information.
Cache Line Alignment.
Memory Management in NT.
LRU, Working Set, and Thrashing.
Non-paged memory.
Memory Management for Device Drivers: Overview.
The File Cache.
Further Reading.
7. Driver Data Structures.
Loading and Starting a Driver.
Driver Objects.
Driver Loading.
Driver Load Order.
Adding a Driver.
Driver Object Structure.
Device Objects.
Device Object Structure.
Adapter and Controller Objects.
Interrupt Objects.
Timer Objects.
DPC Objects.
Device Queue Objects.
File Objects.
Event Semaphore and Mutex Objects.
I/O Request Packets (IRPs).
IRP_MJ_CREATE.
IRP_MJ_CLEANUP.
IRP_MJ_CLOSE.
IRP_MJ_READ.
IRP_MJ_WRITE.
IRP_MJ_FLUSH_BUFFERS.
IRP_MJ_SHUTDOWN.
IRP_MJ_DEVICE_CONTROL.
IRP_MJ_INTERNAL_DEVICE_CONTROL.
Summary.
8. Device Driver Structure.
The Hello World Driver.
Doing Debug Printout.
The hello.h File.
The hello.c File.
The Test Program.
Building the Driver.
The Checked and Free Build environments.
The BUILD command.
Output from the BUILD Process.
Registry Entries for Hello World.
REGEDIT/REGEDT32.
REGINI.
Running the Hello World Test Program and Driver.
Starting the Driver.
Running the Test Program.
The I/O Explorer.
Further Reading.
9. Debugging a Device Driver.
Debugging Tools Overview.
Application Level: The IDE Debugger.
Application Level: Bounds Checker for Windows.
Kernel: WinDbg.
Kernel: Soft-ICE.
Kernel: kd.
Retail and Checked Builds.
Using the Debugging Tools.
Physical Configuration.
Using AutoLogin.
Installing Your Driver.
Modifying the BOOT.INI File.
Configuring WinDbg.
Starting a Debug Session.
Loading the Driver.
It Crashed. Now What?
Restarting after an Error.
Reading a Crash Dump.
Unhandled Exceptions.
WinDbg Reference.
If in Doubt — Get Hardware Debug Assistance.
Use a PCI Bus Monitor.
Use a Logic Analyzer.
Use an Oscilloscope.
If Still in Doubt Rent an ICE — It's Expensive but So Are You.
Product List.
10. Approaching Reality: Moving Data.
Moving Data.
IRP_MJ_DEVICE_CONTROL and IRP_MJ_INTERNAL_DEVICE_CONTROL.
Buffers for Device Control.
Completion of the Request.
Example: Buffered IOCTL.
Declarations and Interface.
Sample Usage: Application Level.
IRP_MJ_READ and IRP_MJ_WRITE.
Buffers for Read and Write.
Completion of the Request.
Example: Buffered IRP_MJ_READ and IRP_MJ_WRITE Completed in Dispatch.
Example: Birect I/O IRP_MJ_READ and IRP_MJ_WRITE Completed in Dispatch.
11. Approaching Reality: Synchronization.
Synchronization.
Spin Locks.
KeInitializeSpinLock.
KeAcquireSpinLock.
KeReleaseSpinLock.
KeAcquireSpinLockAtDpcLevel.
KeReleaseSpinLockFromDpcLevel.
Mutexes.
ExAcquireFastMutex.
ExTryToAcquireFastMutex.
ExReleaseFastMutex.
ExAcquireFastMutexUnsafe.
ExReleaseFastMutexUnsafe.
KeReleaseMutex.
KeReadStateMutex.
KeWaitForMutexObject.
Semaphores.
KeInitializeSemaphore.
KeReleaseSemaphore.
KeReadStateSemaphore.
The Executive Resource.
ExInitializeResourceLite.
ExAcquireResourceExclusiveLite.
ExTryToAcquireResourceExclusiveLite.
ExAcquireResourceSharedLite.
ExAcquireSharedStarveExclusive.
ExAcquireSharedWaitForExclusive.
ExReleaseResourceForThreadLite.
ExReinitializeResourceLite.
ExIsResourceAcquiredExclusiveLite.
ExIsResourceAcquiredSharedLite.
ExGetExclusiveWaiterCount.
ExGetSharedWaiterCount.
ExConvertExclusiveToSharedLite.
ExGetCurrentResourceThread.
ExReleaseResourceForThreadLite.
ExDeleteResourceLite.
Wait Routines.
KeWaitForSingleObject.
KeWaitForMultipleObjects.
SyncCritSect Routine.
Device Consistency: KeSynchronizeExecution.
The Cancel Spin Lock.
12. Achieving Reality: Memory Management.
Memory Management within the driver.
Mapping Adapter memory and I/O space.
Zone Buffers.
Lookaside lists.
Memory Allocation/Management Operations.
13. Achieving Reality: Touching the Hardware.
Touching the Hardware.
Accessing Ports.
Mapping Ports.
Mapping Device Memory.
The Joy Of Hardware.
14. Achieving Reality: Interrupts and the Driver.
Role of the low-level driver.
Interrupt Processing.
What Is an Interrupt?
Interrupt Levels.
ISR Synchronization: The ISR Spin Lock.
ISR levels and device priority.
Overview of an Interrupt Service Routine.
The Interrupt Service Routine Prototype.
Interrupt Service Routine Requirements.
Registering the Interrupt Service Routine.
Processing the Interrupt.
The Deferred Procedure Call Overview.
DPC for ISR vs. Custom DPC.
Multiple DPC Routines.
DpcForIsr.
Custom DPC routines.
Writing an Interrupt Service Routine.
ISR Prototype.
ISRs and Shared Interrupts.
The Deferred Procedure Call.
ISRs and the Unload Routine.
SyncCritSect Routine.
Resource Allocation Interlocks.
15. Achieving Reality: Timers.
Time Delay.
KeQueryPerformanceCounter.
KeStallExecutionProcessor.
KeDelayExecutionThread.
IoTimer Routines.
IoInitializeTimer.
IoStartTimer.
IoStopTimer.
Example: Use of IoTimer.
Custom Timer Routines.
Waiting on a Custom Timer Object.
Polling a Custom Timer Object.
The CustomTimerDpc routine.
Notification Timers and Synchronization Timers.
KeInitializeTimer.
KeInitializeTimerEx.
KeSetTimer.
KeSetTimerEx.
KeCancelTimer.
KeReadStateTimer.
Example: IoTimer routine.
Time of Day Functions.
KeQuerySystemTime.
KeQueryTickCount.
KeQueryTimeIncrement.
16. Achieving Reality: Driver Initialization.
Initialization Functions.
Driver Initialization Prototype.
DriverEntry.
Setting up the Interrupt Service Routine.
A Discussion of the Functions Used by Initialization.
The Unload Routine.
17. Achieving Reality: Direct Memory Access.
DMA Operations.
Use of DMA.
Scatter/Gather.
Adapter Objects.
Adapter Control.
Doing DMA: overview.
Cache Consistency.
DMA Channel Allocation.
Controller Objects.
Multiple Synchronization Objects and Deadlock.
Creating and Managing Controller Objects.
18. Achieving Reality: The Rest of the Details.
The Unload Function.
Parameterizing a Driver: The Registry.
BugCheck!.
Surviving a Blue Screen of Death.
Summary.
19. Mapping Device Memory to User Space.
Mapping Non-Paged Pool to User Space.
An Overview of the MapMem Driver.
The Registry Entry.
Reading the Registry.
Using the Registry Values.
Initializing the Driver Object.
The mapMem IRP_MJ_CREATE Handler.
The IRP_MJ_CLOSE Handler.
The MJ_IRP_DEVICE_CONTROL Handler.
The mapMem Unload Handler.
The mapSystemLogicalMemory Function.
20. I/O Hardware: The ISA Bus.
ISA Bus Overview.
ISA Bus History.
ISA Architecture Overview.
ISA Bus Problems.
ISA Interrupt Structure.
ISA Plug-and-Play.
Claiming Resources.
ISA DMA.
Further Reading.
21. I/O Hardware: The PCI Bus.
PCI Bus Overview.
The PCI Bus Hardware.
PCI Transactions.
The North Bridge.
Windows NT Support of the PCI Bus.
PCI Device Enumeration.
PCI Configuration Space.
HalGetBusData in More Detail.
Assigning Resources.
Using HalAssignSlotResources.
Claiming Resources.
Using IoAssignResources.
Overriding Assignments.
Mapping Memory.
The PCI Explorer.
The PCISCAN Driver.
The PCI Explorer Source.
Further Reading.
22. Serialization within the Driver.
Introduction to Serialization.
Basic Serialization: StartIo.
Driver Managed queues.
Low Level Primitives.
The Device Queue.
A substitute for StartIo.
A multiqueue Device.
Non-Exclusive Devices.
Cancelling an I/O Request.
Cancel and Layered Drivers.
The Cancel Routine.
Cancel and Cancel Spin Lock Functions.
Cancelling StartIo-Managed IRPs.
Cancelling Device-Managed IRPs.
23. Layered Drivers.
Layered Drivers.
Filter Drivers.
Object Manager.
Reference Counts.
Object Name Space.
The Object Manager Entries.
Creating Object Manager Entries.
Objects and Waiting.
Layered Drivers — Implementation.
Functions.
DriverEntry.
Unload.
Filter Drivers — Implementation.
Functions.
DriverEntry.
Unload.
Implementation Techniques.
The IRP Stack.
IRP Processing.
Calling Lower-Level Drivers.
Passing Buffers to Lower Level Drivers.
Completion routines.
Direct Calls from Driver to Driver.
Layered Driver Examples.
Passing an Allocated IRP to a Lower Level.
Passing the IRP to a Lower Level Driver with a Completion Routine.
24. Driver Threads.
System Worker Thread WorkItems.
Dedicated Driver Threads.
Multi-Processor Systems and Threads.
Waits.
Alertable and Non-Alertable Waits.
Asynchronous Procedure Call.
The Wait Routines.
Event Objects.
Semaphore Objects.
Mutexes.
Resources.
Synchronizing on Thread Objects.
A Multiple Queue Example Using Threads.
Finite-State Machines and Drivers.
Cancelling the Active IRP.
Further Reading.
25. Specialized Drivers in NT: An Overview.
Graphics Drivers.
Display Drivers.
The Miniport.
Surfaces.
OpenGL.
DirectDraw and Direct3D.
Printer Driver.
The SCSI Bus.
The SCSI Physical Bus.
The SCSI Command Set.
SCSI Drivers.
The Class Driver.
The Miniport Driver.
ASPI.
Further Reading.
26. Useful Driver Techniques.
Deferred Procedure Calls.
Threads and DPC Queueing — A Fatal Problem.
Example: DPC Queueing Failure.
The Registry.
Registry Access Functions.
The Windows NT Event Log.
The Event Viewer Utility.
The Message Table.
Creating Driver Events.
Reading and Writing Files.
ZwCreateFile.
Example: Opening a File for Reading.
Discussion: Rebooting.
ZwQueryInformationFile.
FILE_STANDARD_INFORMATION.
Example: Reading the File Size.
ZwReadFile.
ZwWriteFile.
ZwClose.
Pageable Drivers.
Why a Pageable Driver?
Creating a Pageable Driver.
Validating Pageability.
Locking Down Data.
Improving Performance: Locking Down Code.
Paging Entire Drivers.
Product Driver Installation.
The Service Control Manager.
The Registry.
Programming the Service Control Manager.
Further Reading.
27. A Hardware Simulator.
Why a Simulator?
Basic Design of a Simulator.
The Simulator Driver.
Driver Simulator Source Code.
The Simulator Control Panel.
Simulator State Diagram.
Using the Simulator Controller.
The I/O Explorer.
A Sample Driver.
Testing State: Macros, Bitmaps, and Offsets.
A Polled Device Driver.
A Simple Interrupt-Driven Device Driver.
28. NT 5.0 Drivers Overview.
Windows NT 5.0 Enhancements.
New Driver Support Routines.
Obsolete Driver Support Routines.
New DMA Programming Techniques.
DMA Routines Added.
DMA Routines Deleted.
Power Management.
Plug and Play.
The Windows Driver Model (WDM).
The Hardware Installer Wizard.
Other Changes.
The NT 5.0 DriverEntry (and Friends).
Handling IRP_MJ_POWER.
The DEVICE_CAPABILITIES Structure.
The PoCallDriver Function.
The IRP_MJ_PNP Message.
A “Simple” NT 5.0 Driver.
The DriverEntry Handler.
The AddDevice Handler.
The IRP_MJ_PNP Handler.
The IRP_MJ_POWER Handler.
The Unload Handler.
29. I/O Hardware: The Universal Serial Bus.
External Bus Overview.
The Universal Serial Bus (USB).
USB Architecture.
The Root Hub.
Endpoints.
Pipes.
Transfer Types.
Packet Bandwidth.
USB Packet Protocols.
Transaction Details.
Plug and Play Hardware.
Power Management.
USB Device States.
USB Device Requests.
USB Descriptors.
Device Communication.
USB Device Configuration.
Isochronous Transfers.
USB Hubs.
Further Reading.
30. The Windows Driver Model.
How WDM Extends the Basic Driver Model.
The Driver Hierarchy.
The WDM Classes.
The HID Class Driver.
The Streams Class Driver.
The Audio Class Driver.
The Video Class Driver.
The Still Image Class Driver.
Loading WDM Drivers.
A “Monolithic” WDM Driver.
Important Differences.
Design of a Monolithic USB Driver.
A WDM/USB DriverEntry Function.
A WDM/USB AddDevice Function.
Creating a WDM Device Object.
Calling the USB Driver.
USB and WDM.
The USB Subsystem.
The USB Card MiniDriver.
UHCD/OHCI Drivers.
The USB Class Driver.
The USB Hub Class Driver.
The HID/USB Interface.
Communicating to the USBDI.
USB Request Blocks (URBs).
USB and Power Management.
A USB Filter Driver.
The ValueAdd.c file.
The DriverEntry Routine.
The Pass-Thru Routine.
The Create/Close Function.
The AddDevice Function.
The Unload Function.
The PnP.c File.
The Power Dispatch Function.
The Plug and Play Handler.
The Plug and Play Completion Routine.
Starting the Device.
Stopping the Device.
Sending Down the USB Request.
The USB Completion Handler.
Processing the USB Descriptor.
The usb.c File.
The IRP_MJ_INTERNAL_DEVICE_CONTROL Handler.
The URB Handler Completion Routine.
The URB Printout Routine.
USB Support Functions and Structures.
UsbBuildGetDescriptorRequest.
A: Reference.
Support Function Overview.
Support Function and Data Structure Reference.
ASSERT.
ASSERTMSG.
CM_FULL_RESOURCE_DESCRIPTOR.
CM_PARTIAL_RESOURCE_DESCRIPTOR.
CM_PARTIAL_RESOURCE_LIST.
CM_RESOURCE_LIST.
CONFIGURATION_INFORMATION.
CONTAINING_RECORD.
CONTROLLER_OBJECT.
DbgBreakPoint.
DbgPrint.
DEVICE_DESCRIPTION.
DEVICE_OBJECT.
DriverEntry.
DRIVER_OBJECT.
ExAcquireFastMutex.
ExAcquireFastMutexUnsafe.
ExAcquireResourceExclusiveLite.
ExAcquireResourceSharedLite.
ExAcquireSharedStarveExclusive.
ExAcquireSharedWaitForExclusive.
ExAllocateFromNPagedLookasideList.
ExAllocateFromPagedLookasideList.
ExAllocatePool.
ExAllocatePoolWithQuota.
ExAllocatePoolWithQuotaTag.
ExAllocatePoolWithTag.
ExConvertExclusiveToSharedLite.
ExDeleteNPagedLookasideList.
ExDeletePagedLookasideList.
ExDeleteResourceLite.
ExFreePool.
ExFreeToNPagedLookasideList.
ExFreeToPagedLookasideList.
ExGetCurrentResourceThread.
ExInitializeFastMutex.
ExInitializeNPagedLookasideList.
ExInitializePagedLookasideList.
ExInitializeResourceLite.
ExInitializeWorkItem.
ExInterlockedInsertHeadList.
ExInterlockedInsertTailList.
ExInterlockedRemoveHeadList.
ExIsResourceAcquiredExclusiveLite.
ExIsResourceAcquiredSharedLite.
ExQueueWorkItem.
ExReleaseFastMutex.
ExReleaseFastMutexUnsafe.
ExReleaseResourceForThreadLite.
ExTryToAcquireFastMutex.
ExTryToAcquireResourceExclusiveLite.
HalAssignSlotResources.
HalGetAdapter.
HalGetBusData.
HalGetBusDataByOffset.
HalGetInterruptVector.
HalSetBusData.
HalSetBusDataByOffset.
HalTranslateBusAddress.
HKEY_LOCAL_MACHINE.
InitializeListHead.
InitializeObjectAttributes.
InsertHeadList.
InsertTailList.
INTERFACE_TYPE.
InterlockedDecrement.
InterlockedExchange.
InterlockedExchangeAdd.
InterlockedIncrement.
IoAcquireCancelSpinLock.
IoAllocateAdapterChannel.
IoAllocateController.
IoAllocateErrorLogEntry.
IoAllocateIrp.
IoAllocateMdl.
IoAssignResources.
IoAttachDevice.
IoAttachDeviceToDeviceStack.
IoBuildAsynchronousFsdRequest.
IoBuildDeviceIoControlRequest.
IoBuildPartialMdl.
IoBuildSynchronousFSDRequest.
IoCallDriver.
IoCancelIrp.
IoCompleteRequest.
IoConnectInterrupt.
IoCopyCurrentIrpStackLocationToNext.
IoCreateController.
IoCreateDevice.
IoCreateNotificationEvent.
IoCreateSymbolicLink.
IoCreateSynchronizationEvent.
IoDeleteController.
IoDeleteDevice.
IoDeleteSymbolicLink.
IoDetachDevice.
IoDisconnectInterrupt.
IO_ERROR_LOG_PACKET.
IoFlushAdapterBuffers.
IoFreeAdapterChannel.
IoFreeController.
IoFreeIrp.
IoFreeMapRegisters.
IoFreeMdl.
IoGetConfiguationInformation.
IoGetCurrentIrpStackLocation.
IoGetCurrentProcess.
IoGetDeviceObjectPointer.
IoGetNextIrpStackLocation.
IoInitializeDpcRequest.
IoInitializeIrp.
IoInitializeTimer.
IoMakeAssociatedIrp.
IoMapTransfer.
IoMarkIrpPending.
IoRegisterShutdownNotification.
IoReleaseCancelSpinLock.
IoRequestDpc.
IO_RESOURCE_DESCRIPTOR.
IO_RESOURCE_LIST.
IO_RESOURCE_REQUIREMENTS_LIST.
IoSetCancelRoutine.
IoSetCompletionRoutine.
IoSetNextIrpStackLocation.
IoSizeOfIrp.
IoSkipCurrentIrpStackLocation.
IO_STACK_LOCATION.
IoStartNextPacket.
IoStartNextPacketByKey.
IoStartPacket.
IoStartTimer.
IO_STATUS_BLOCK.
IoStopTimer.
IoUnregisterShutdownNotification.
IoWriteErrorLogEntry.
IsListEmpty.
IRP.
KdPrint.
KeAcquireSpinLock.
KeAcquireSpinLockAtDpcLevel.
KeBugCheck.
KeBugCheckEx.
KeCancelTimer.
KeClearEvent.
KeDelayExecutionThread.
KeDeregisterBugCheckCallback.
KeFlushIoBuffers.
KeGetCurrentIrql.
KeGetCurrentProcessorNumber.
KeGetDcacheFillSize.
KeInitializeCallbackRecord.
KeInitializeDeviceQueue.
KeInitializeDpc.
KeInitializeEvent.
KeInitializeMutex.
KeInitializeSemaphore.
KeInitializeSpinLock.
KeInitializeTimer.
KeInitializeTimerEx.
KeInsertByKeyDeviceQueue.
KeInsertDeviceQueue.
KeInsertQueueDpc.
KeLowerIrql.
KeNumberProcessors.
KeQueryPerformanceCounter.
KeQuerySystemTime.
KeQueryTickCount.
KeQueryTimeIncrement.
KeRaiseIrql.
KeReadStateEvent.
KeReadStateMutex.
KeReadStateSemaphore.
KeReadStateTimer.
KeRegisterBugCheckCallback.
KeReleaseMutex.
KeReleaseSemaphore.
KeReleaseSpinLock.
KeReleaseSpinLockFromDpcLevel.
KeRemoveByKeyDeviceQueue.
KeRemoveDeviceQueue.
KeRemoveEntryDeviceQueue.
KeRemoveQueueDpc.
KeResetEvent.
KeSetEvent.
KeSetPriorityThread.
KeSetTimer.
KeSetTimerEx.
KeStallExecutionProcessor.
KeSynchronizeExecution.
KeWaitForMultipleObjects.
KeWaitForMutexObject.
KeWaitForSingleObject.
KEY_BASIC_INFORMATION.
KEY_FULL_INFORMATION.
KEY_NODE_INFORMATION.
KEY_VALUE_BASIC_INFORMATION.
KEY_VALUE_FULL_INFORMATION.
KEY_VALUE_PARTIAL_INFORMATION.
KIRQL.
KSYNCHRONIZE_ROUTINE.
LARGE_INTEGER.
MmAllocateContiguousMemory.
MmAllocateNonCachedMemory.
MmCreateMdl.
MmFreeContiguousMemory.
MmFreeNonCachedMemory.
MmGetMdlByteCount.
MmGetMdlByteOffset.
MmGetMdlVirtualAddress.
MmGetPhysicalAddress.
MmGetSystemAddressForMdl.
MmInitializeMdl.
MmIsAddressValid.
MmMapIoSpace.
MmMapLockedPages.
MmPrepareMdlForReuse.
MmProbeAndLockPages.
MmQuerySystemSize.
MmSizeOfMdl.
MmUnlockPages.
MmUnlockPagableImageSection.
MmUnmapIoSpace.
MmUnmapLockedPages.
NTSTATUS.
ObDereferenceObject.
ObReferenceObjectByHandle.
ObReferenceObjectByPointer.
PCI_COMMON_CONFIG.
PCI_SLOT_NUMBER.
PDRIVER_CONTROL.
PIO_DPC_ROUTINE.
PIO_TIMER_ROUTINE.
PKDEFERRED_ROUTINE.
PKSTART_ROUTINE.
PsCreateSystemThread.
PsGetCurrentProcess.
PsGetCurrentThread.
PsTerminateSystemThread.
READ_PORT_BUFFER_type.
READ_PORT_type.
READ_REGISTER_BUFFER_type.
READ_REGISTER_type.
RemoveEntryList.
RemoveHeadList.
RemoveTailList.
RtlInitUnicodeString.
RtlMoveMemory.
RTL_QUERY_REGISTRY_ROUTINE.
RTL_QUERY_REGISTRY_TABLE.
RtlQueryRegistryValues.
RtlUnicodeStringToAnsiString.
RtlZeroMemory.
UNICODE_STRING.
_URB_CONTROL_DESCRIPTOR_REQUEST.
_URB_HEADER.
UsbBuildGetDescriptorRequest.
WRITE_PORT_BUFFER_type.
WRITE_PORT_type.
WRITE_REGISTER_BUFFER_type.
WRITE_REGISTER_type.
ZwClose.
ZwCreateFile.
ZwCreateKey.
ZwDeleteKey.
ZwEnumerateKey.
ZwEnumerateValueKey.
ZwFlushKey.
ZwMapViewOfSection.
ZwOpenKey.
ZwOpenSection.
ZwQueryKey.
ZwQueryValueKey.
ZwSetInformationThread.
ZwSetValueKey.
ZwUnmapViewOfSection.
Further Reading.
B: Error Codes and Associated NTSTATUS Codes.
Mapping Application Errors to NTSTATUS Codes.
Mapping NTSTATUS Codes to Application Error Codes.
The NTSTATUS Explorer.
The STATUSR Driver.
Index. 0201695901T04062001
| Erscheint lt. Verlag | 19.4.1999 |
|---|---|
| Verlagsort | Boston |
| Sprache | englisch |
| Maße | 192 x 243 mm |
| Gewicht | 2041 g |
| Themenwelt | Informatik ► Betriebssysteme / Server ► Windows |
| Informatik ► Betriebssysteme / Server ► Windows Server | |
| Mathematik / Informatik ► Informatik ► Netzwerke | |
| ISBN-10 | 0-201-69590-1 / 0201695901 |
| ISBN-13 | 978-0-201-69590-8 / 9780201695908 |
| Zustand | Neuware |
| Haben Sie eine Frage zum Produkt? |
aus dem Bereich
