OSR Learning Library

Windows Driver Foundation (WDF) including both KMDF and UMDF

• Receiving and Sorting I/O Requests in Your Driver Using WDF Queues
  How to use receive and sort Requests that are sent to your driver, using WDFQUEUEs.
• Limiting the Number of Simultaneous Requests from Parallel Dispatched Queues
  Using Sequential Dispatching, you can get one Request delivered to your driver at a time. With parallel Dispatching, you get an unlimited number of Requests delivered to your driver at once by default. This article describes how to set a maximum number of simultaneously active parallel Requests.
• Sending Requests to Other Devices/Drivers is Easy… If You Follow These Simple Rules
  If your WDF driver needs to send a Request to another device/driver for processing, you’ll call WdfRequestSend to send the Request to a WDFIOTARGET. Like most things in WDF, these features aren’t hard to use, but they can be surprisingly easy to unintentionally use incorrectly… leading to rare or difficult to diagnose errors. This article gives you easy guidance so you can’t go wrong.
• Understanding Sync Scope in WDF Drivers
  All Windows drivers need to be “thread safe.” This can lead to complexity, potentially dealing with different types of locks (Mutex? Spin lock?) and multiple different locking levels. The WDF designers recognized this and created what they hoped would be a simplifying concept called Sync Scope. This article provides a detailed dive into Sync Scope, discussing both how to use it and when it might not be the best solution for your needs.
• Surprising Side-Effects of Sync Scope and Using Timers and/or Work Items
  If you use a Sync Scope other than “none” in your driver, beware of the unintended consequences this can have on timers and/or work items that you may also be using.
• Making User Access to Your Driver Easy… and SAFE
  There are two potential ways users can access the device(s) your driver makes available: Using a Device Interface GUID, or using a device name. Each way has advantages and disadvantages. And naming your device can introduce surprising security challenges. It’s definitely not as simple as just calling WdfDeviceIniteAssignSddlString. This is the definitive article on how to make your Device Objects accessible and properly protected. We got some big surprises when writing it. We’re willing to be almost every Windows driver dev will get similar surprises reading it.
• FileObject Callbacks Demystified
  When a user calls CreateFile targeting one of your devices, what callback is invoked in your WDF driver? Do you need to handle this callback? Similarly, what callback is invoked with a user calls CloseHandle and do you need to implement this callback? This article answers these questions.
• What Happens When an App Exits With I/O In Progress? Handling Cleanup, Close and Cancel in your WDF Driver
  Cleanup, Close, and Cancel operations in Windows drivers are very commonly misunderstood. Not handling them properly can lead to crashes or the classic “application hangs on exit” problem that new Windows driver devs so often see. This article teaches you the difference between these three operations, and when you need to handle each. It also provides guidance for best practices regarding handling these functions in your WDF driver.
• I²C and SPI Devices on Windows: Intro to SPB Devices and Drivers
  The I²C and SPI buses provide simple, inexpensive, ways to connect devices to a system. Despite their having been around for many years, support for these buses has only been added to Windows in recent years. This article gives you a quick introduction to writing WDF drivers for devices that are connected via I²C and SPI.
• How a Driver Tells an Application That “Something” Happened
  How can my driver inform an application that “something has happened” that the application might be interested in? How can my driver make a “callback” to user-mode? There’s a standard model for doing this in the world of Windows drivers, and it’s called “the inverted call model.” This article explains that model, and even points off to some sample code we put on GitHub that can get you started.
• The WDFSTRING Object
  Did you know that there’s a WDFSTRING object? There is! And sometimes it’s even useful.
• Be Careful When Calling WdfIoQueuePurgeSynchronously
  A brief reminder that you can’t call WdfIoQueuePurgeSynchronously from an EvtIoXxx Event Processing Callback. And that means, any Queue’s EvtIo Event Processing Callback.
• Are All Three Variants of WdfRequestSend Useful?
  WdfRequestSend seems so easy. And there seem to be three equally useful ways to use it: synchrnous, asynchronous with a callback, and send-and-forget. But are these three variants really equally useful?
• Understanding WDFMEMORY Objects
  Is it a buffer? An object? A Memory Descriptor? We describe the differences between these features in WDF.
• Driver to Driver Communication in WDF Made Easy: Using Bus Interfaces
  What’s the best way for two drivers to “interact”, aside from having one send a Request to the other? How can DriverA call a function in DriverB? There are many ways to do this. But one of the easiest ways to do this in WDF is to use a Bus Interface. This article gives you the details.
• Understanding EvtIoStop, Bugcheck 9F and Related SDV Errors
  Does your WDF driver get a 0x9F bugcheck? I bet you’re not handling EvtIoStop. This article explains why you probably need to implement this callback.
• Creating Custom WDF Objects
  Did you ever find yourself wishing that you could extend the WDF Framework? Add your own, custom, type of WDF Object for a specific purpose? Well, you can. This article tells you how.
• The Three Most Common Errors in Shipping WDF Drivers
  One of the things we do a lot here at OSR is review code written by other driver devs. When reviewing WDF drivers, we most often see three errors that are easily avoidable if the dev who wrote the code was aware of the issue. And the biggest problem with these errors is that you can test your driver, and it seem like it works properly. But, in fact, your driver is broken. Don’t make these mistakes.
• Five Basic Hints for Successful WDF Testing and Debugging
  You write code. Sometimes it doesn’t work the first time. We often see folks struggle with the process of debugging more than they do even with the initial design and coding of their driver. Here, we give you five basic tips to ensure your debugging activities get started on the right track.