It's a DLL

A UMDF driver is a Dynamic Link Library (DLL) and a COM object wrapped into one. Since it's a DLL, it should support DllMain, which is a well-known entry point for a DLL. Figure 1 contains the code for DllMain.

BOOL WINAPI DllMain(         HINSTANCE ModuleHandle,         DWORD Reason,         PVOID /* Reserved */) {     if (DLL_PROCESS_ATTACH == Reason) {         //        // Initialize tracing.        //           WPP_INIT_TRACING(MYDRIVER_TRACING_ID);          //        // Save the DLL handle for use when        // registering & unregistering the server.        //        g_ModuleHandle = ModuleHandle;     }     else if (DLL_PROCESS_DETACH == Reason) {         //         // Cleanup tracing.         //           WPP_CLEANUP();     }      return TRUE; }   Figure 1 - DllMain

Creating an Instance of IWDFDriver Derived Class

Since we're creating a driver, the driver "object" has to first get created somehow. If this was a kernel mode driver, the I/O Manager would create a Driver Object, and then load the driver. In the case of a UMDF driver, the DLL gets loaded and eventually a routine in comsup.cpp called CClassFactory::CreateInstance would be called. This routine is shown in Figure 2.

HRESULT STDMETHODCALLTYPE CClassFactory::CreateInstance(     __in_opt IUnknown * /* OuterObject */,     __in REFIID InterfaceId,     __out PVOID *Object     ){     HRESULT hr;     PCMyDriver driver;     hr = CMyDriver::CreateInstance(&driver);     if (S_OK == hr)     {         hr = driver->QueryInterface(InterfaceId, Object);         driver->Release();     }     return hr; }  Figure 2 - CClassFactory::CreateInstance

CClassFactory::CreateInstance is responsible for creating an instance of the COM object that supports IWDFDriver interfaces, which in our case is part of the CMyDriverClass shown in Figure 3. It does this by calling the CMyDriver::CreateInstance routine, which is a static function in the CMyDriver class.

class CMyDriver : public CUnknown, public IDriverEntry { // Private methods. private:     // Returns a referenced pointer to the IDriverEntry interface.     IDriverEntry * QueryIDriverEntry(VOID){         AddRef();         return static_cast<IDriverEntry*>(this);     }     HRESULT Initialize(VOID); // // Public methods // public:     // The factory method used to create an instance of this driver.     static HRESULT CreateInstance(__out PCMyDriver *Driver); // // COM methods //                                                            public:     //     // IDriverEntry methods     //     virtual HRESULT STDMETHODCALLTYPE     OnInitialize(__in IWDFDriver *FxWdfDriver) {         return S_OK;     }     virtual HRESULTSTDMETHODCALLTYPE     OnDeviceAdd(__in IWDFDriver *FxWdfDriver,         __in IWDFDeviceInitialize *FxDeviceInit);     virtual VOID STDMETHODCALLTYPE     OnDeinitialize(__in IWDFDriver *FxWdfDriver) {         return;     }     // IUnknown methods.     // We have to implement basic ones here that redirect to the     // base class because of the multiple inheritance.     // virtual ULONG STDMETHODCALLTYPE AddRef(VOID){         return __super::AddRef();     }     virtual ULONG STDMETHODCALLTYPE Release(VOID){         return __super::Release();     }     virtual HRESULTSTDMETHODCALLTYPE QueryInterface(         __in REFIID InterfaceId,         __out PVOID *Object); };   Figure 3 - CMyDriver Class Definition

The CMyDriver::CreateInstance shown in Figure 4 creates an instance of the CMyDriver class and does any initialization of this object's data members that may be required. Once the instance is created, the CClassFactory::CreateInstance routine in Figure 2 calls the QueryInterface method of the newly created instance of CMyDriver.

HRESULT CMyDriver::CreateInstance(__out PCMyDriver *Driver) {     PCMyDriver driver;     HRESULT hr;     //     // Allocate the callback object.     //     driver = new CMyDriver();     // Do driver object initialization ..........Rest of the code intentionally omitted..... Figure 4 - CMyDriver::CreateInstance

HHRESULT CMyDriver::OnDeviceAdd(     __in IWDFDriver *FxWdfDriver,     __in IWDFDeviceInitialize *FxDeviceInit) {     HRESULT hr;     PCMyDevice device = NULL;     //     // TODO: Do any per-device initialization (reading settings from the     //       registry for example) necessary before creating your     //       device callback object. Otherwise you can leave such     //       initialization to the initialization of the device event handler.     // Create a new instance of our device callback object     //     hr = CMyDevice::CreateInstance(FxWdfDriver, FxDeviceInit, &device);     //     // TODO: Change any per-device settings the object exposes before     //       calling Configure to let it complete its initialization.     //     // If that succeeded, then call the device's construct method. This     // allows the device to create any queues or other structures it     // needs now that the corresponding fx device object has been created.     //     if (S_OK == hr) {         hr = device->Configure();     } .................Code intentionally omitted.  Figure 6 - CMyDriver::OnDeviceAdd