Buy Developing Windows NT Device Drivers by Edward N. Dekker
Book 1
Book 2
Book 3
Book 1
Book 2
Book 3
Book 1
Book 2
Book 3
Book 1
Book 2
Book 3
Home > Computing and Information Technology > Computer programming / software engineering > Developing Windows NT Device Drivers: A Programmer's Handbook
Developing Windows NT Device Drivers: A Programmer's Handbook

Developing Windows NT Device Drivers: A Programmer's Handbook


     0     
5
4
3
2
1



Out of Stock


Notify me when this book is in stock
X
About the Book

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

Table of Contents:
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

About the Author :
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


Best Sellers


Product Details
  • ISBN-13: 9780201695908
  • Publisher: Pearson Education (US)
  • Publisher Imprint: Addison Wesley
  • Height: 243 mm
  • No of Pages: 1280
  • Sub Title: A Programmer's Handbook
  • Width: 192 mm
  • ISBN-10: 0201695901
  • Publisher Date: 19 Apr 1999
  • Binding: Hardback
  • Language: English
  • Spine Width: 51 mm
  • Weight: 2041 gr


Similar Products

Add Photo
Add Photo

Customer Reviews

REVIEWS      0     
Click Here To Be The First to Review this Product
Developing Windows NT Device Drivers: A Programmer's Handbook
Pearson Education (US) -
Developing Windows NT Device Drivers: A Programmer's Handbook
Writing guidlines
We want to publish your review, so please:
  • keep your review on the product. Review's that defame author's character will be rejected.
  • Keep your review focused on the product.
  • Avoid writing about customer service. contact us instead if you have issue requiring immediate attention.
  • Refrain from mentioning competitors or the specific price you paid for the product.
  • Do not include any personally identifiable information, such as full names.

Developing Windows NT Device Drivers: A Programmer's Handbook

Required fields are marked with *

Review Title*
Review
    Add Photo Add up to 6 photos
    Would you recommend this product to a friend?
    Tag this Book Read more
    Does your review contain spoilers?
    What type of reader best describes you?
    I agree to the terms & conditions
    You may receive emails regarding this submission. Any emails will include the ability to opt-out of future communications.

    CUSTOMER RATINGS AND REVIEWS AND QUESTIONS AND ANSWERS TERMS OF USE

    These Terms of Use govern your conduct associated with the Customer Ratings and Reviews and/or Questions and Answers service offered by Bookswagon (the "CRR Service").


    By submitting any content to Bookswagon, you guarantee that:
    • You are the sole author and owner of the intellectual property rights in the content;
    • All "moral rights" that you may have in such content have been voluntarily waived by you;
    • All content that you post is accurate;
    • You are at least 13 years old;
    • Use of the content you supply does not violate these Terms of Use and will not cause injury to any person or entity.
    You further agree that you may not submit any content:
    • That is known by you to be false, inaccurate or misleading;
    • That infringes any third party's copyright, patent, trademark, trade secret or other proprietary rights or rights of publicity or privacy;
    • That violates any law, statute, ordinance or regulation (including, but not limited to, those governing, consumer protection, unfair competition, anti-discrimination or false advertising);
    • That is, or may reasonably be considered to be, defamatory, libelous, hateful, racially or religiously biased or offensive, unlawfully threatening or unlawfully harassing to any individual, partnership or corporation;
    • For which you were compensated or granted any consideration by any unapproved third party;
    • That includes any information that references other websites, addresses, email addresses, contact information or phone numbers;
    • That contains any computer viruses, worms or other potentially damaging computer programs or files.
    You agree to indemnify and hold Bookswagon (and its officers, directors, agents, subsidiaries, joint ventures, employees and third-party service providers, including but not limited to Bazaarvoice, Inc.), harmless from all claims, demands, and damages (actual and consequential) of every kind and nature, known and unknown including reasonable attorneys' fees, arising out of a breach of your representations and warranties set forth above, or your violation of any law or the rights of a third party.


    For any content that you submit, you grant Bookswagon a perpetual, irrevocable, royalty-free, transferable right and license to use, copy, modify, delete in its entirety, adapt, publish, translate, create derivative works from and/or sell, transfer, and/or distribute such content and/or incorporate such content into any form, medium or technology throughout the world without compensation to you. Additionally,  Bookswagon may transfer or share any personal information that you submit with its third-party service providers, including but not limited to Bazaarvoice, Inc. in accordance with  Privacy Policy


    All content that you submit may be used at Bookswagon's sole discretion. Bookswagon reserves the right to change, condense, withhold publication, remove or delete any content on Bookswagon's website that Bookswagon deems, in its sole discretion, to violate the content guidelines or any other provision of these Terms of Use.  Bookswagon does not guarantee that you will have any recourse through Bookswagon to edit or delete any content you have submitted. Ratings and written comments are generally posted within two to four business days. However, Bookswagon reserves the right to remove or to refuse to post any submission to the extent authorized by law. You acknowledge that you, not Bookswagon, are responsible for the contents of your submission. None of the content that you submit shall be subject to any obligation of confidence on the part of Bookswagon, its agents, subsidiaries, affiliates, partners or third party service providers (including but not limited to Bazaarvoice, Inc.)and their respective directors, officers and employees.

    Accept

    Fresh on the Shelf


    Inspired by your browsing history


    Your review has been submitted!

    You've already reviewed this product!