Initial publish

18 files changed, 3189 insertions, 0 deletions

diff --git a/general/echo/umdf/Comsup.cpp b/general/echo/umdf/Comsup.cpp
new file mode 100644
index 00000000..fd298470
--- /dev/null
+++ b/general/echo/umdf/Comsup.cpp
@@ -0,0 +1,344 @@
+/*++
+
+Copyright (C) Microsoft Corporation, All Rights Reserved
+
+Module Name:
+
+    ComSup.cpp
+
+Abstract:
+
+    This module contains implementations for the functions and methods 
+    used for providing COM support.
+
+Environment:
+
+    Windows User-Mode Driver Framework (WUDF)
+
+--*/
+
+#include "internal.h"
+
+#include "comsup.tmh"
+
+//
+// Implementation of CUnknown methods.
+//
+
+CUnknown::CUnknown(
+    VOID
+    ) : m_ReferenceCount(1)
+/*++
+
+  Routine Description:
+
+    Constructor for an instance of the CUnknown class.  This simply initializes
+    the reference count of the object to 1.  The caller is expected to 
+    call Release() if it wants to delete the object once it has been allocated.
+
+  Arguments:
+
+    None
+
+  Return Value:
+
+    None
+
+--*/
+{
+    // do nothing.
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CUnknown::QueryInterface(
+    _In_ REFIID InterfaceId,
+    _Out_ PVOID *Object
+    )
+/*++
+ 
+  Routine Description:
+
+    This method provides the basic support for query interface on CUnknown.
+    If the interface requested is IUnknown it references the object and 
+    returns an interface pointer.  Otherwise it returns an error.
+
+  Arguments:
+
+    InterfaceId - the IID being requested
+
+    Object - a location to store the interface pointer to return.
+
+  Return Value:
+
+    S_OK or E_NOINTERFACE
+
+--*/
+{
+    if (IsEqualIID(InterfaceId, __uuidof(IUnknown)))
+    {
+        *Object = QueryIUnknown();
+        return S_OK;
+    }
+    else
+    {
+        *Object = NULL;
+        return E_NOINTERFACE;
+    }
+}
+
+IUnknown *
+CUnknown::QueryIUnknown(
+    VOID
+    )
+/*++
+ 
+  Routine Description:
+
+    This helper method references the object and returns a pointer to the 
+    object's IUnknown interface.
+
+    This allows other methods to convert a CUnknown pointer into an IUnknown
+    pointer without a typecast and without calling QueryInterface and dealing
+    with the return value.
+
+  Arguments:
+
+    None
+
+  Return Value:
+
+    A pointer to the object's IUnknown interface.
+
+--*/
+{
+    AddRef();
+    return static_cast<IUnknown *>(this);
+}
+
+ULONG
+STDMETHODCALLTYPE
+CUnknown::AddRef(
+    VOID
+    )
+/*++
+ 
+  Routine Description:
+
+    This method adds one to the object's reference count.
+
+  Arguments:
+
+    None
+
+  Return Value:
+
+    The new reference count.   The caller should only use this for debugging
+    as the object's actual reference count can change while the caller
+    examines the return value.
+
+--*/
+{
+    return InterlockedIncrement(&m_ReferenceCount);
+}
+
+ULONG
+STDMETHODCALLTYPE
+CUnknown::Release(
+    VOID
+   )
+/*++
+ 
+  Routine Description:
+
+    This method subtracts one to the object's reference count.  If the count
+    goes to zero, this method deletes the object.
+
+  Arguments:
+
+    None
+
+  Return Value:
+
+    The new reference count.   If the caller uses this value it should only be
+    to check for zero (i.e. this call caused or will cause deletion) or 
+    non-zero (i.e. some other call may have caused deletion, but this one 
+    didn't).
+
+--*/
+{
+    ULONG count = InterlockedDecrement(&m_ReferenceCount);
+
+    if (count == 0)
+    {
+        delete this;
+    }
+    return count;
+}
+
+//
+// Implementation of CClassFactory methods.
+//
+
+//
+// Define storage for the factory's static lock count variable.
+//
+
+LONG CClassFactory::s_LockCount = 0;
+
+IClassFactory *
+CClassFactory::QueryIClassFactory(
+    VOID
+    )
+/*++
+ 
+  Routine Description:
+
+    This helper method references the object and returns a pointer to the 
+    object's IClassFactory interface.
+
+    This allows other methods to convert a CClassFactory pointer into an 
+    IClassFactory pointer without a typecast and without dealing with the 
+    return value QueryInterface.
+
+  Arguments:
+
+    None
+
+  Return Value:
+
+    A referenced pointer to the object's IClassFactory interface.
+
+--*/
+{
+    AddRef();
+    return static_cast<IClassFactory *>(this);
+}
+
+HRESULT
+CClassFactory::QueryInterface(
+    _In_ REFIID InterfaceId,
+    _Out_ PVOID *Object
+    )
+/*++
+ 
+  Routine Description:
+
+    This method attempts to retrieve the requested interface from the object.
+
+    If the interface is found then the reference count on that interface (and
+    thus the object itself) is incremented.
+
+  Arguments:
+
+    InterfaceId - the interface the caller is requesting.
+
+    Object - a location to store the interface pointer.
+
+  Return Value:
+
+    S_OK or E_NOINTERFACE
+
+--*/
+{
+    //
+    // This class only supports IClassFactory so check for that.
+    //
+
+    if (IsEqualIID(InterfaceId, __uuidof(IClassFactory)))
+    {
+        *Object = QueryIClassFactory();
+        return S_OK;
+    }
+    else
+    {
+        //
+        // See if the base class supports the interface.
+        //
+
+        return CUnknown::QueryInterface(InterfaceId, Object);
+    }
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CClassFactory::CreateInstance(
+    _In_opt_ IUnknown * /* OuterObject */,
+    _In_ REFIID InterfaceId,
+    _Out_ PVOID *Object
+    )
+/*++
+ 
+  Routine Description:
+
+    This COM method is the factory routine - it creates instances of the driver
+    callback class and returns the specified interface on them.
+
+  Arguments:
+
+    OuterObject - only used for aggregation, which our driver callback class
+                  does not support.
+
+    InterfaceId - the interface ID the caller would like to get from our 
+                  new object.
+
+    Object - a location to store the referenced interface pointer to the new
+             object.
+
+  Return Value:
+
+    Status.
+
+--*/
+{
+    HRESULT hr;
+
+    PCMyDriver driver;
+
+    *Object = NULL;
+
+    hr = CMyDriver::CreateInstance(&driver);
+
+    if (SUCCEEDED(hr)) 
+    {
+        hr = driver->QueryInterface(InterfaceId, Object);
+        driver->Release();
+    }
+
+    return hr;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CClassFactory::LockServer(
+    _In_ BOOL Lock
+    )
+/*++
+ 
+  Routine Description:
+
+    This COM method can be used to keep the DLL in memory.  However since the
+    driver's DllCanUnloadNow function always returns false, this has little 
+    effect.  Still it tracks the number of lock and unlock operations.
+
+  Arguments:
+
+    Lock - Whether the caller wants to lock or unlock the "server"
+
+  Return Value:
+
+    S_OK
+
+--*/
+{
+    if (Lock)
+    {
+        InterlockedIncrement(&s_LockCount);
+    } 
+    else 
+    {
+        InterlockedDecrement(&s_LockCount);
+    }
+    return S_OK;
+}
+
diff --git a/general/echo/umdf/Comsup.h b/general/echo/umdf/Comsup.h
new file mode 100644
index 00000000..b96fd982
--- /dev/null
+++ b/general/echo/umdf/Comsup.h
@@ -0,0 +1,215 @@
+/*++
+
+Copyright (C) Microsoft Corporation, All Rights Reserved
+
+Module Name:
+
+    ComSup.h
+
+Abstract:
+
+    This module contains classes and functions use for providing COM support
+    code.
+
+Environment:
+
+    Windows User-Mode Driver Framework (WUDF)
+
+--*/
+
+#pragma once
+
+//
+// Forward type declarations.  They are here rather than in internal.h as
+// you only need them if you choose to use these support classes.
+//
+
+typedef class CUnknown *PCUnknown;
+typedef class CClassFactory *PCClassFactory;
+
+//
+// Base class to implement IUnknown.  You can choose to derive your COM
+// classes from this class, or simply implement IUnknown in each of your
+// classes.
+//
+
+class CUnknown : public IUnknown 
+{
+
+//
+// Private data members and methods.  These are only accessible by the methods 
+// of this class.
+//
+private:
+
+    //
+    // The reference count for this object.  Initialized to 1 in the
+    // constructor.
+    //
+
+    LONG m_ReferenceCount;
+
+//
+// Protected data members and methods.  These are accessible by the subclasses 
+// but not by other classes.
+//
+protected:
+
+    //
+    // The constructor and destructor are protected to ensure that only the 
+    // subclasses of CUnknown can create and destroy instances.
+    //
+
+    CUnknown(
+        VOID
+        );
+
+    //
+    // The destructor MUST be virtual.  Since any instance of a CUnknown 
+    // derived class should only be deleted from within CUnknown::Release, 
+    // the destructor MUST be virtual or only CUnknown::~CUnknown will get
+    // invoked on deletion.
+    //
+    // If you see that your CMyDevice specific destructor is never being
+    // called, make sure you haven't deleted the virtual destructor here.
+    //
+
+    virtual 
+    ~CUnknown(
+        VOID
+        )
+    {
+        // Do nothing
+    }
+
+//
+// Public Methods.  These are accessible by any class.
+//
+public:
+
+    IUnknown *
+    QueryIUnknown(
+        VOID
+        );
+
+//
+// COM Methods.
+//
+public:
+
+    //
+    // IUnknown methods
+    //
+
+    virtual
+    ULONG
+    STDMETHODCALLTYPE
+    AddRef(
+        VOID
+        );
+
+    virtual
+    ULONG
+    STDMETHODCALLTYPE
+    Release(
+        VOID
+       );
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    QueryInterface(
+        _In_ REFIID InterfaceId,
+        _Out_ PVOID *Object
+        );
+};
+
+//
+// Class factory support class.  Create an instance of this from your 
+// DllGetClassObject method and modify the implementation to create 
+// an instance of your driver event handler class.
+//
+
+class CClassFactory : public CUnknown, public IClassFactory 
+{
+//
+// Private data members and methods.  These are only accessible by the methods 
+// of this class.
+//
+private:
+
+    //
+    // The lock count.  This is shared across all instances of IClassFactory
+    // and can be queried through the public IsLocked method.
+    //
+
+    static LONG s_LockCount;
+
+//
+// Public Methods.  These are accessible by any class.
+//
+public:
+
+    IClassFactory *
+    QueryIClassFactory(
+        VOID
+        );
+
+//
+// COM Methods.
+//
+public:
+
+    //
+    // IUnknown methods
+    //
+
+    virtual
+    ULONG
+    STDMETHODCALLTYPE
+    AddRef(
+        VOID
+        )
+    {
+        return __super::AddRef();
+    }
+
+    _At_(this, __drv_freesMem(object))
+    virtual
+    ULONG
+    STDMETHODCALLTYPE
+    Release(
+        VOID
+       )
+    {
+        return __super::Release();
+    }
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    QueryInterface(
+        _In_ REFIID InterfaceId,
+        _Out_ PVOID *Object
+        );
+
+    //
+    // IClassFactory methods.
+    //
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    CreateInstance(
+        _In_opt_ IUnknown *OuterObject,
+        _In_ REFIID InterfaceId,
+        _Out_ PVOID *Object
+        );
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    LockServer(
+        _In_ BOOL Lock
+        );
+};
diff --git a/general/echo/umdf/Device.cpp b/general/echo/umdf/Device.cpp
new file mode 100644
index 00000000..77110e8e
--- /dev/null
+++ b/general/echo/umdf/Device.cpp
@@ -0,0 +1,415 @@
+/*++
+
+Copyright (C) Microsoft Corporation, All Rights Reserved.
+
+Module Name:
+
+    Device.cpp
+
+Abstract:
+
+    This module contains the implementation of the sample driver's
+    device callback object.
+
+Environment:
+
+   Windows User-Mode Driver Framework (WUDF)
+
+--*/
+
+#include "internal.h"
+#include "initguid.h"
+
+#include "device.tmh"
+
+DEFINE_GUID (GUID_DEVINTERFACE_ECHO,
+    0xcdc35b6e, 0xbe4, 0x4936, 0xbf, 0x5f, 0x55, 0x37, 0x38, 0xa, 0x7c, 0x1a);
+// {CDC35B6E-0BE4-4936-BF5F-5537380A7C1A}
+
+HRESULT
+CMyDevice::CreateInstance(
+    _In_ IWDFDriver *FxDriver,
+    _In_ IWDFDeviceInitialize * FxDeviceInit,
+    _Out_ PCMyDevice *Device
+    )
+/*++
+
+  Routine Description:
+
+    This method creates and initializs an instance of the driver's
+    device callback object.
+
+  Arguments:
+
+    FxDeviceInit - the settings for the device.
+
+    Device - a location to store the referenced pointer to the device object.
+
+  Return Value:
+
+    Status
+
+--*/
+{
+    PCMyDevice device;
+    HRESULT hr;
+
+    //
+    // Allocate a new instance of the device class.
+    //
+
+    device = new CMyDevice();
+
+    if (NULL == device)
+    {
+        return E_OUTOFMEMORY;
+    }
+
+    //
+    // Initialize the instance.
+    //
+
+    hr = device->Initialize(FxDriver, FxDeviceInit);
+
+    if (SUCCEEDED(hr))
+    {
+        *Device = device;
+    }
+    else
+    {
+        device->Release();
+    }
+
+    return hr;
+}
+
+HRESULT
+CMyDevice::Initialize(
+    _In_ IWDFDriver           * FxDriver,
+    _In_ IWDFDeviceInitialize * FxDeviceInit
+    )
+/*++
+
+  Routine Description:
+
+    This method initializes the device callback object and creates the
+    partner device object.
+
+    The method should perform any device-specific configuration that:
+        *  could fail (these can't be done in the constructor)
+        *  must be done before the partner object is created -or-
+        *  can be done after the partner object is created and which aren't
+           influenced by any device-level parameters the parent (the driver
+           in this case) might set.
+
+  Arguments:
+
+    FxDeviceInit - the settings for this device.
+
+  Return Value:
+
+    status.
+
+--*/
+{
+    IWDFDevice *fxDevice = NULL;
+    IWDFDeviceInitialize2 *fxDeviceInit2;
+    HRESULT hr;
+
+    //
+    // Configure things like the locking model before we go to create our
+    // partner device.
+    //
+
+    //
+    // Set no locking unless you need an automatic callbacks synchronization
+    //
+
+    FxDeviceInit->SetLockingConstraint(None);
+
+    //
+    // TODO: If you're writing a filter driver then indicate that here.
+    //
+    // FxDeviceInit->SetFilter();
+    //
+
+    //
+    // TODO: Any per-device initialization which must be done before
+    //       creating the partner object.
+    //
+
+    //
+    // Create a new FX device object and assign the new callback object to
+    // handle any device level events that occur.
+    //
+
+    //
+    // Set retrieval mode to direct I/O. This needs to be done before the call
+    // to CreateDevice.
+    //
+    hr = FxDeviceInit->QueryInterface(IID_PPV_ARGS(&fxDeviceInit2));
+
+    if (SUCCEEDED(hr))
+    {
+        //
+        // WdfDeviceIoBufferedOrDirect for read/write and ioctrl operations. 
+        // UMDF defaults to direct-I/O when the device is not running in a shared 
+        // wudfhost process, and it defaults to buffered-I/O otherwise. Direct I/O
+        // is not allowed when the device is pooled.
+        //  
+        //
+        fxDeviceInit2->SetIoTypePreference(WdfDeviceIoBufferRetrievalDeferred,
+                                           WdfDeviceIoBufferedOrDirect,
+                                           WdfDeviceIoBufferedOrDirect);
+
+        SAFE_RELEASE(fxDeviceInit2);
+
+        //
+        // QueryIUnknown references the IUnknown interface that it returns
+        // (which is the same as referencing the device).  We pass that to
+        // CreateDevice, which takes its own reference if everything works.
+        //
+        {
+            IUnknown *unknown = this->QueryIUnknown();
+
+            hr = FxDriver->CreateDevice(FxDeviceInit, unknown, &fxDevice);
+
+            unknown->Release();
+        }
+    }
+
+    //
+    // If that succeeded then set our FxDevice member variable.
+    //
+
+    if (SUCCEEDED(hr))
+    {
+        m_FxDevice = fxDevice;
+
+        //
+        // Drop the reference we got from CreateDevice.  Since this object
+        // is partnered with the framework object they have the same
+        // lifespan - there is no need for an additional reference.
+        //
+
+        fxDevice->Release();
+    }
+
+    return hr;
+}
+
+HRESULT
+CMyDevice::Configure(
+    VOID
+    )
+/*++
+
+  Routine Description:
+
+    This method is called after the device callback object has been initialized
+    and returned to the driver.  It would setup the device's queues and their
+    corresponding callback objects.
+
+  Arguments:
+
+    FxDevice - the framework device object for which we're handling events.
+
+  Return Value:
+
+    status
+
+--*/
+{
+    PCMyQueue defaultQueue;
+
+    HRESULT hr;
+
+    hr = CMyQueue::CreateInstance(m_FxDevice, &defaultQueue);
+
+    if (FAILED(hr))
+    {
+        return hr;
+    }
+
+    hr = defaultQueue->Configure();
+
+    if (SUCCEEDED(hr))
+    {
+        //
+        // In case of success store defaultQueue in our member
+        // The reference is transferred to m_DefaultQueue
+        //
+
+        m_Queue = defaultQueue;
+    }
+    else
+    {
+        //
+        // In case of failure release the reference
+        //
+
+        defaultQueue->Release();
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        hr = m_FxDevice->CreateDeviceInterface(&GUID_DEVINTERFACE_ECHO,
+                                               NULL);
+    }
+
+    return hr;
+}
+
+HRESULT
+CMyDevice::QueryInterface(
+    _In_ REFIID InterfaceId,
+    _Out_ PVOID *Object
+    )
+/*++
+
+  Routine Description:
+
+    This method is called to get a pointer to one of the object's callback
+    interfaces.
+
+    Since the sample driver doesn't support any of the device events, this
+    method simply calls the base class's BaseQueryInterface.
+
+    If the sample is extended to include device event interfaces then this
+    method must be changed to check the IID and return pointers to them as
+    appropriate.
+
+  Arguments:
+
+    InterfaceId - the interface being requested
+
+    Object - a location to store the interface pointer if successful
+
+  Return Value:
+
+    S_OK or E_NOINTERFACE
+
+--*/
+{
+    HRESULT hr;
+
+    if (IsEqualIID(InterfaceId, __uuidof(IPnpCallbackSelfManagedIo))) {
+        *Object = QueryIPnpCallbackSelfManagedIo();
+        hr = S_OK;
+    } else {
+        hr = CUnknown::QueryInterface(InterfaceId, Object);
+    }
+
+    return hr;
+}
+
+HRESULT
+CMyDevice::OnSelfManagedIoInit(
+    _In_ IWDFDevice * pWdfDevice
+    )
+/*++
+
+  Routine Description:
+
+    This method is called to allow driver to initialize any resources
+    that driver might need to process I/O.
+
+    Echo driver needs a thread to process completions. We initialize
+    this thread here
+
+  Arguments:
+
+    pWdfDevice - framework device object for which to initialze resources
+
+  Return Value:
+
+    S_OK in case of success
+    HRESULT correponding to error returned by CreateThread, in case of failure
+
+--*/
+{
+    HRESULT hr = S_OK;
+
+    UNREFERENCED_PARAMETER(pWdfDevice);
+
+
+    m_ThreadHandle = CreateThread( NULL,                        // Default Security Attrib.
+                                   0,                           // Initial Stack Size,
+                                   CMyQueue::CompletionThread,  // Thread Func
+                                   (LPVOID)m_Queue,             // Arg to Thread Func is Queue
+                                   0,                           // Creation Flags
+                                   NULL );                      // Don't need the Thread Id.
+
+    if (m_ThreadHandle == NULL) {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+    }
+
+    return hr;
+}
+
+void
+CMyDevice::OnSelfManagedIoCleanup(
+    _In_ IWDFDevice * pWdfDevice
+    )
+/*++
+
+  Routine Description:
+
+    This method is called to allow driver to cleanup any resources
+    that driver allocated to process I/O.
+
+    It is critical that, in this routine driver wait for all of the
+    threads which it created to exit. Otherwise those threads could
+    continue to execute when framework unloads the driver which
+    would lead to a crash.
+
+    Echo driver created a thread to handle completions. We wait for
+    that thread to exit in this routine
+
+  Arguments:
+
+    pWdfDevice - framework device object for which to cleanup resources
+
+  Return Value:
+
+    None
+
+--*/
+{
+    //
+    // Kill the thread and
+    // wait for the thread to die.
+    //
+
+    UNREFERENCED_PARAMETER(pWdfDevice);
+
+    if (m_ThreadHandle) {
+
+        //
+        // Ask queue to set terminate flag which will make
+        // the thread exit
+        //
+        m_Queue->SetExitThread();
+
+        //
+        // Wait for the thread to exit
+        //
+
+        WaitForSingleObject(m_ThreadHandle, INFINITE);
+
+        //
+        // Close the thread handle
+        //
+
+        CloseHandle(m_ThreadHandle);
+        m_ThreadHandle = NULL;
+    }
+
+    //
+    // Release the reference we took on the queue callback object
+    // to keep it alive until the thread exits
+    //
+
+    SAFE_RELEASE(m_Queue);
+}
+
diff --git a/general/echo/umdf/Device.h b/general/echo/umdf/Device.h
new file mode 100644
index 00000000..70147c11
--- /dev/null
+++ b/general/echo/umdf/Device.h
@@ -0,0 +1,217 @@
+/*++
+
+Copyright (C) Microsoft Corporation, All Rights Reserved
+
+Module Name:
+
+    Device.h
+
+Abstract:
+
+    This module contains the type definitions for the UMDF Echo sample
+    driver's device callback class.
+
+Environment:
+
+    Windows User-Mode Driver Framework (WUDF)
+
+--*/
+
+#pragma once
+
+#include "queue.h"
+
+//
+// Class for the iotrace driver.
+//
+
+class CMyDevice : 
+    public CUnknown,
+    public IPnpCallbackSelfManagedIo        
+{
+
+//
+// Private data members.
+//
+private:
+
+    IWDFDevice *m_FxDevice;
+
+    //
+    // Completion Thread handle used by queue callback object
+    //
+    HANDLE      m_ThreadHandle;
+
+    //
+    // Our queue callback object
+    // Strong reference - since we pass it to the thread we create
+    //
+    CMyQueue   *m_Queue;
+
+//
+// Private methods.
+//
+
+private:
+
+    CMyDevice(
+        VOID
+        )
+    {
+        m_FxDevice = NULL;
+    }
+
+    HRESULT
+    Initialize(
+        _In_ IWDFDriver *FxDriver,
+        _In_ IWDFDeviceInitialize *FxDeviceInit
+        );
+
+    IPnpCallbackSelfManagedIo *
+    QueryIPnpCallbackSelfManagedIo(
+        VOID
+        )
+    {
+        AddRef();
+        return static_cast<IPnpCallbackSelfManagedIo *>(this);
+    }
+    
+
+//
+// Public methods
+//
+public:
+
+    //
+    // The factory method used to create an instance of this driver.
+    //
+    
+    static
+    HRESULT
+    CreateInstance(
+        _In_ IWDFDriver *FxDriver,
+        _In_ IWDFDeviceInitialize *FxDeviceInit,
+        _Out_ PCMyDevice *Device
+        );
+
+    HRESULT
+    Configure(
+        VOID
+        );
+
+//
+// COM methods
+//
+public:
+
+    //
+    // IUnknown methods.
+    //
+
+    virtual
+    ULONG
+    STDMETHODCALLTYPE
+    AddRef(
+        VOID
+        )
+    {
+        return __super::AddRef();
+    }
+
+    _At_(this, __drv_freesMem(object))
+    virtual
+    ULONG
+    STDMETHODCALLTYPE
+    Release(
+        VOID
+       )
+    {
+        return __super::Release();
+    }
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    QueryInterface(
+        _In_ REFIID InterfaceId,
+        _Out_ PVOID *Object
+        );
+
+    //
+    // IPnpCallbackSelfManagedIo methods
+    //
+
+    //
+    // We implement this interface to create and tear down
+    // our completion thread
+    //
+    // It is critical that we wait for all the threads we create
+    // to exit during OnSelfManagedIoCleanup, otherwise thread
+    // may continue to execute when framework unloads the driver,
+    // leading to a crash
+    //
+    // We don't manage any I/O separate from the queue, so apart
+    // from OnSelfManagedIoInit and OnSelfManagedIoCleanup, other
+    // methods have token implementations
+    //
+    
+    virtual
+    void
+    STDMETHODCALLTYPE
+    OnSelfManagedIoCleanup(
+        _In_ IWDFDevice * pWdfDevice
+        );
+        
+    virtual
+    void
+    STDMETHODCALLTYPE
+    OnSelfManagedIoFlush(
+        _In_ IWDFDevice * pWdfDevice
+        )
+    {
+        UNREFERENCED_PARAMETER( pWdfDevice );
+    }
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    OnSelfManagedIoInit(
+        _In_ IWDFDevice * pWdfDevice
+        );
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    OnSelfManagedIoSuspend(
+        _In_ IWDFDevice * pWdfDevice
+        )
+    { 
+        UNREFERENCED_PARAMETER( pWdfDevice );
+        
+        return S_OK;
+    }
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    OnSelfManagedIoRestart(
+        _In_ IWDFDevice * pWdfDevice
+        )
+    {
+        UNREFERENCED_PARAMETER( pWdfDevice );
+        
+        return S_OK;
+    }
+    
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    OnSelfManagedIoStop(
+        _In_ IWDFDevice * pWdfDevice
+        )
+    {
+        UNREFERENCED_PARAMETER( pWdfDevice );
+    
+        return S_OK;
+    }    
+};
diff --git a/general/echo/umdf/Driver.cpp b/general/echo/umdf/Driver.cpp
new file mode 100644
index 00000000..1428a08a
--- /dev/null
+++ b/general/echo/umdf/Driver.cpp
@@ -0,0 +1,220 @@
+/*++
+ 
+Copyright (C) Microsoft Corporation, All Rights Reserved.
+
+Module Name:
+
+    Driver.cpp
+
+Abstract:
+
+    This module contains the implementation of the UMDF Sample's 
+    core driver callback object.
+
+Environment:
+
+   Windows User-Mode Driver Framework (WUDF)
+
+--*/
+
+#include "internal.h"
+#include "driver.tmh"
+
+HRESULT
+CMyDriver::CreateInstance(
+    _Out_ PCMyDriver *Driver
+    )
+/*++
+ 
+  Routine Description:
+
+    This static method is invoked in order to create and initialize a new 
+    instance of the driver class.  The caller should arrange for the object
+    to be released when it is no longer in use.
+
+  Arguments:
+
+    Driver - a location to store a referenced pointer to the new instance
+
+  Return Value:
+
+    S_OK if successful, or error otherwise.
+
+--*/
+{
+    PCMyDriver driver;
+    HRESULT hr;
+
+    //
+    // Allocate the callback object.
+    //
+
+    driver = new CMyDriver();
+
+    if (NULL == driver)
+    {
+        return E_OUTOFMEMORY;
+    }
+        
+    //
+    // Initialize the callback object.
+    //
+
+    hr = driver->Initialize();
+
+    if (SUCCEEDED(hr)) 
+    {
+        //
+        // Store a pointer to the new, initialized object in the output 
+        // parameter.
+        //
+
+        *Driver = driver;
+    }
+    else 
+    {
+
+        //
+        // Release the reference on the driver object to get it to delete 
+        // itself.
+        //
+
+        driver->Release();
+    }
+
+    return hr;
+}
+
+HRESULT
+CMyDriver::Initialize(
+    VOID
+    )
+/*++
+ 
+  Routine Description:
+
+    This method is called to initialize a newly created driver callback object
+    before it is returned to the creator.  Unlike the constructor, the 
+    Initialize method contains operations which could potentially fail.
+
+  Arguments:
+
+    None
+
+  Return Value:
+
+    None
+
+--*/
+{
+    return S_OK;
+}
+
+HRESULT
+CMyDriver::QueryInterface(
+    _In_ REFIID InterfaceId,
+    _Out_ PVOID *Interface
+    )
+/*++
+ 
+  Routine Description:
+
+    This method returns a pointer to the requested interface on the callback
+    object..
+
+  Arguments:
+
+    InterfaceId - the IID of the interface to query/reference
+
+    Interface - a location to store the interface pointer.
+
+  Return Value:
+
+    S_OK if the interface is supported.
+    E_NOINTERFACE if it is not supported.
+
+--*/
+{
+    if (IsEqualIID(InterfaceId, __uuidof(IDriverEntry)))
+    {
+        *Interface = QueryIDriverEntry();
+        return S_OK;
+    }
+    else
+    {
+        return CUnknown::QueryInterface(InterfaceId, Interface);
+    }
+}
+
+HRESULT
+CMyDriver::OnDeviceAdd(
+    _In_ IWDFDriver *FxWdfDriver,
+    _In_ IWDFDeviceInitialize *FxDeviceInit
+    )
+/*++
+ 
+  Routine Description:
+
+    The FX invokes this method when it wants to install our driver on a device
+    stack.  This method creates a device callback object, then calls the Fx
+    to create an Fx device object and associate the new callback object with
+    it.
+
+  Arguments:
+
+    FxWdfDriver - the Fx driver object.
+
+    FxDeviceInit - the initialization information for the device.
+
+  Return Value:
+
+    status
+
+--*/
+{
+    HRESULT hr;
+
+    PCMyDevice device = NULL;
+
+    //
+    // TODO: Do any per-device initialization (reading settings from the 
+    //       registry for example) that's necessary before creating your 
+    //       device callback object here.  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 that 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 that it
+    // needs now that the corresponding fx device object has been created.
+    //
+
+    if (SUCCEEDED(hr)) 
+    {
+        hr = device->Configure();
+    }
+
+    // 
+    // Release the reference on the device callback object now that it's been
+    // associated with an fx device object.
+    //
+
+    if (NULL != device)
+    {
+        device->Release();
+    }
+
+    return hr;
+}
diff --git a/general/echo/umdf/Driver.h b/general/echo/umdf/Driver.h
new file mode 100644
index 00000000..643ea5a5
--- /dev/null
+++ b/general/echo/umdf/Driver.h
@@ -0,0 +1,149 @@
+/*++
+
+Copyright (C) Microsoft Corporation, All Rights Reserved
+
+Module Name:
+
+    Driver.h
+
+Abstract:
+
+    This module contains the type definitions for the UMDF sample's
+    driver callback class.
+
+Environment:
+
+    Windows User-Mode Driver Framework (WUDF)
+
+--*/
+
+#pragma once
+
+//
+// This class handles driver events for the sample.  In particular
+// it supports the OnDeviceAdd event, which occurs when the driver is called
+// to setup per-device handlers for a new device stack.
+//
+
+class CMyDriver : public CUnknown, public IDriverEntry
+{
+//
+// Private data members.
+//
+private:
+
+//
+// Private methods.
+//
+private:
+
+    //
+    // Returns a refernced 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
+        )
+    {
+        UNREFERENCED_PARAMETER( FxWdfDriver );
+    
+        return S_OK;
+    }
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    OnDeviceAdd(
+        _In_ IWDFDriver *FxWdfDriver,
+        _In_ IWDFDeviceInitialize *FxDeviceInit
+        );
+
+    virtual
+    VOID
+    STDMETHODCALLTYPE
+    OnDeinitialize(
+        _In_ IWDFDriver *FxWdfDriver
+        )
+    {
+        UNREFERENCED_PARAMETER( FxWdfDriver );
+    
+        return;
+    }
+
+    //
+    // IUnknown methods.
+    //
+    // We have to implement basic ones here that redirect to the 
+    // base class becuase of the multiple inheritance.
+    //
+    
+    virtual
+    ULONG
+    STDMETHODCALLTYPE
+    AddRef(
+        VOID
+        )
+    {
+        return __super::AddRef();
+    }
+
+    _At_(this, __drv_freesMem(object))
+    virtual
+    ULONG
+    STDMETHODCALLTYPE
+    Release(
+        VOID
+       )
+    {
+        return __super::Release();
+    }
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    QueryInterface(
+        _In_ REFIID InterfaceId,
+        _Out_ PVOID *Object
+        );
+};
diff --git a/general/echo/umdf/Echo.rc b/general/echo/umdf/Echo.rc
new file mode 100644
index 00000000..2a26d85c
--- /dev/null
+++ b/general/echo/umdf/Echo.rc
@@ -0,0 +1,21 @@
+//---------------------------------------------------------------------------
+// Echo.rc
+//
+// Copyright (c) Microsoft Corporation, All Rights Reserved
+//---------------------------------------------------------------------------
+
+
+#include <windows.h>
+#include <ntverp.h>
+
+//
+// TODO: Change the file description and file names to match your binary.
+//
+
+#define VER_FILETYPE                VFT_DLL
+#define VER_FILESUBTYPE             VFT_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "WDF:UMDF Echo User-Mode Driver Sample"
+#define VER_INTERNALNAME_STR        "UMDFEcho"
+#define VER_ORIGINALFILENAME_STR    "UMDFEcho.dll"
+
+#include "common.ver"
diff --git a/general/echo/umdf/Queue.cpp b/general/echo/umdf/Queue.cpp
new file mode 100644
index 00000000..f366fe31
--- /dev/null
+++ b/general/echo/umdf/Queue.cpp
@@ -0,0 +1,545 @@
+/*++
+
+Copyright (c) Microsoft Corporation, All Rights Reserved
+
+Module Name:
+
+    queue.cpp
+
+Abstract:
+
+    This file implements the I/O queue interface and performs
+    the read/write/ioctl operations.
+
+Environment:
+
+    Windows User-Mode Driver Framework (WUDF)
+
+--*/
+
+
+#include "internal.h"
+
+//
+// IUnknown implementation
+//
+
+//
+// Queue destructor.
+// Free up the buffer, wait for thread to terminate and 
+// delete critical section.
+//
+
+
+CMyQueue::~CMyQueue(
+    VOID
+    )
+/*++
+
+Routine Description:
+
+
+    IUnknown implementation of Release
+
+Arguments:
+
+
+Return Value:
+
+    ULONG (reference count after Release)
+
+--*/
+{
+    if (m_Buffer) {
+        delete [] m_Buffer;
+    }
+
+    if (m_InitCritSec) {
+        ::DeleteCriticalSection(&m_Crit);
+    }
+}
+
+
+//
+// Initialize 
+HRESULT 
+CMyQueue::CreateInstance(
+    _In_ IWDFDevice *FxDevice,
+    _Out_ PCMyQueue *Queue
+    )
+/*++
+
+Routine Description:
+
+
+    CreateInstance creates an instance of the queue object.
+
+Arguments:
+    
+    ppUkwn - OUT parameter is an IUnknown interface to the queue object
+
+Return Value:
+
+    HRESULT indicating success or failure
+
+--*/
+{
+    CMyQueue *pMyQueue = new CMyQueue;
+    HRESULT hr;
+
+    if (pMyQueue == NULL) {
+        return E_OUTOFMEMORY;
+    }
+
+    hr = pMyQueue->Initialize(FxDevice);
+
+    if (SUCCEEDED(hr)) 
+    {
+        *Queue = pMyQueue;
+    }
+    else
+    {
+        pMyQueue->Release();
+    }
+    return hr;
+}
+
+HRESULT
+CMyQueue::Initialize(
+    _In_ IWDFDevice *FxDevice
+    )
+{
+    IWDFIoQueue *fxQueue;
+    HRESULT hr;
+
+    //
+    // Initialize the critical section before we continue
+    //
+
+    if (!InitializeCriticalSectionAndSpinCount(&m_Crit,0x80000400))
+    {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+        goto Exit;
+    }
+    m_InitCritSec = TRUE;
+
+    //
+    // Create the framework queue
+    //
+
+    {
+        IUnknown *unknown = QueryIUnknown();
+        hr = FxDevice->CreateIoQueue(unknown,
+                                     TRUE,
+                                     WdfIoQueueDispatchSequential,
+                                     TRUE,
+                                     FALSE,
+                                     &fxQueue);
+        unknown->Release();
+    }
+
+    if (FAILED(hr))
+    {
+        goto Exit;
+    }
+
+    m_FxQueue = fxQueue;
+
+    fxQueue->Release();
+
+Exit:
+    return hr;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CMyQueue::QueryInterface(
+    _In_ REFIID InterfaceId,
+    _Out_ PVOID *Object
+    )
+/*++
+
+Routine Description:
+
+
+    Query Interface
+
+Arguments:
+    
+    Follows COM specifications
+
+Return Value:
+
+    HRESULT indicating success or failure
+
+--*/
+{
+    HRESULT hr;
+
+
+    if (IsEqualIID(InterfaceId, __uuidof(IQueueCallbackWrite))) {
+        *Object = QueryIQueueCallbackWrite(); 
+        hr = S_OK;
+    } else if (IsEqualIID(InterfaceId, __uuidof(IQueueCallbackRead))) {
+        *Object = QueryIQueueCallbackRead();
+        hr = S_OK;
+    } else if (IsEqualIID(InterfaceId, __uuidof(IQueueCallbackDeviceIoControl))) {
+        *Object = QueryIQueueCallbackDeviceIoControl();
+        hr = S_OK;
+    } else {
+        hr = CUnknown::QueryInterface(InterfaceId, Object);
+    }
+
+    return hr;
+}
+
+VOID
+STDMETHODCALLTYPE
+CMyQueue::OnDeviceIoControl(
+    _In_ IWDFIoQueue *pWdfQueue,
+    _In_ IWDFIoRequest *pWdfRequest,
+    _In_ ULONG ControlCode,
+    _In_ SIZE_T InputBufferSizeInBytes,
+    _In_ SIZE_T OutputBufferSizeInBytes
+    )
+/*++
+
+Routine Description:
+
+
+    DeviceIoControl dispatch routine
+
+Arguments:
+    
+    pWdfQueue - Framework Queue instance
+    pWdfRequest - Framework Request  instance
+    ControlCode - IO Control Code
+    InputBufferSizeInBytes - Length of input buffer
+    OutputBufferSizeInBytes - Length of output buffer
+
+    Always succeeds DeviceIoIoctl
+Return Value:
+
+    VOID
+
+--*/
+{
+
+    UNREFERENCED_PARAMETER(pWdfQueue);
+    UNREFERENCED_PARAMETER(ControlCode);
+    UNREFERENCED_PARAMETER(InputBufferSizeInBytes);
+    UNREFERENCED_PARAMETER(OutputBufferSizeInBytes);
+
+    pWdfRequest->Complete(S_OK);
+    return;
+}
+
+VOID
+STDMETHODCALLTYPE
+CMyQueue::OnWrite(
+    _In_ IWDFIoQueue *pWdfQueue,
+    _In_ IWDFIoRequest *pWdfRequest,
+    _In_ SIZE_T BytesToWrite
+    )
+/*++
+
+Routine Description:
+
+
+    Write dispatch routine
+    IQueueCallbackWrite
+
+Arguments:
+    
+    pWdfQueue - Framework Queue instance
+    pWdfRequest - Framework Request  instance
+    BytesToWrite - Length of bytes in the write buffer
+
+    Allocate and copy data to local buffer
+Return Value:
+
+    VOID
+
+--*/
+{
+
+    HRESULT     hr;
+    IWDFMemory* pRequestMemory = NULL;
+    IWDFIoRequest2 * pWdfRequest2 = NULL;
+
+    UNREFERENCED_PARAMETER(pWdfQueue);
+
+    //
+    // Handle Zero length writes.
+    //
+
+    if (!BytesToWrite) {
+        pWdfRequest->CompleteWithInformation(S_OK, 0);
+        return;
+    }
+
+    if( BytesToWrite > MAX_WRITE_LENGTH ) {
+
+        pWdfRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_MORE_DATA), 0);
+        return;
+    }
+
+    // Release previous buffer if set
+
+    if( m_Buffer != NULL ) {
+        delete [] m_Buffer;
+        m_Buffer = NULL;
+        m_Length = 0L;
+    }
+
+    // Allocate Buffer
+
+    m_Buffer = new UCHAR[BytesToWrite]; 
+    if (m_Buffer == NULL) {
+        pWdfRequest->Complete(E_OUTOFMEMORY);
+        m_Length = 0L;
+        return;
+    }
+
+    // Get memory object
+    hr = pWdfRequest->QueryInterface(IID_PPV_ARGS(&pWdfRequest2));
+    
+    if (FAILED(hr)) {
+        goto Exit;
+    }
+    
+    hr = pWdfRequest2->RetrieveInputMemory(&pRequestMemory);
+
+    if (FAILED(hr)) {
+        goto Exit;
+    }
+
+    // Copy from memory object to our buffer
+
+    hr = pRequestMemory->CopyToBuffer(0, m_Buffer, BytesToWrite);
+
+    if (FAILED(hr)) {
+        goto Exit;
+    }
+
+    //
+    // Release memory object.
+    //
+    SAFE_RELEASE(pRequestMemory);
+
+    //
+    // Save the information so that we can use it 
+    // to complete the request later.
+    //
+
+    Lock();
+
+    m_Length = (ULONG) BytesToWrite;
+    m_XferredBytes = m_Length;
+    m_CurrentRequest = pWdfRequest2;
+
+    Unlock();
+
+Exit:
+
+    if (FAILED(hr)) {
+        if (pWdfRequest2) {
+            pWdfRequest2->CompleteWithInformation(hr, 0);
+        }
+        delete [] m_Buffer;
+        m_Buffer = NULL;
+        SAFE_RELEASE(pRequestMemory);
+    }
+
+    //
+    // This is an early release. pWdfRequest2 will be released, when the request is completed
+    //
+    SAFE_RELEASE(pWdfRequest2);
+
+    return;
+}
+
+VOID
+STDMETHODCALLTYPE
+CMyQueue::OnRead(
+    _In_ IWDFIoQueue *pWdfQueue,
+    _In_ IWDFIoRequest *pWdfRequest,
+    _In_ SIZE_T SizeInBytes
+    )
+/*++
+
+Routine Description:
+
+
+    Read dispatch routine
+    IQueueCallbackRead
+
+Arguments:
+    
+    pWdfQueue - Framework Queue instance
+    pWdfRequest - Framework Request  instance
+    SizeInBytes - Length of bytes in the read buffer
+
+    Copy available data into the read buffer
+Return Value:
+
+    VOID
+
+--*/
+{
+    IWDFMemory* pRequestMemory = NULL;
+    IWDFIoRequest2 * pWdfRequest2 = NULL;
+    HRESULT     hr;
+
+    UNREFERENCED_PARAMETER(pWdfQueue);
+
+    //
+    // Handle Zero length reads.
+    //
+
+    if (!SizeInBytes) {
+        pWdfRequest->CompleteWithInformation(S_OK, 0);
+        return;
+    }
+
+    if (m_Buffer == NULL) {
+        pWdfRequest->CompleteWithInformation(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), SizeInBytes);
+        return;
+    }
+
+    if (m_Length < SizeInBytes) {
+        SizeInBytes = m_Length;
+    }
+
+    //
+    // Get memory object
+    //
+    
+    hr = pWdfRequest->QueryInterface(IID_PPV_ARGS(&pWdfRequest2));
+
+    if (FAILED(hr)) {
+        goto Exit;
+    }
+
+    hr = pWdfRequest2->RetrieveOutputMemory(&pRequestMemory );
+
+    if (FAILED(hr)) {
+        goto Exit;
+    }
+
+    // Copy from buffer to memory object 
+
+    hr = pRequestMemory->CopyFromBuffer(0, m_Buffer, SizeInBytes);
+
+    if (FAILED(hr)) {
+        goto Exit;
+    }
+
+    //
+    // Release memory object.
+    //
+
+    SAFE_RELEASE(pRequestMemory);
+
+    //
+    // Save the information so that we can use it 
+    // to complete the request later.
+    //
+
+    Lock();
+
+    m_CurrentRequest = pWdfRequest2;
+    m_XferredBytes = SizeInBytes;
+
+    Unlock();
+
+Exit:
+     
+    if (FAILED(hr)) {
+        if (pWdfRequest2) {
+            pWdfRequest2->CompleteWithInformation(hr, 0);
+        }
+        SAFE_RELEASE(pRequestMemory);
+    }
+
+    //
+    // This is an early release. pWdfRequest2 will be released, when the request is completed
+    //
+    SAFE_RELEASE(pWdfRequest2);
+    
+    return;
+}
+
+DWORD 
+CMyQueue::CompletionThread(
+    PVOID ThreadParameter
+    )
+/*++
+
+Routine Description:
+
+
+    This routine is called from the thread started to complete
+    I/O requests. It sleeps for TIMER_PERIOD and then completes
+    the current request. Note that it has to release the lock
+    before it calls the request complete method. 
+
+Arguments:
+    
+    ThreadParameter - This is a pointer to the Queue object.
+    
+Return Value:
+
+    VOID
+
+--*/
+{
+    CMyQueue      *pQueue = (CMyQueue *)ThreadParameter;
+    IWDFIoRequest2 *request;
+    SIZE_T       bytesXferred = 0;
+
+    for (;;) {
+
+        //
+        // Block for a fixed time and then complete the request.
+        //
+
+        Sleep(TIMER_PERIOD);
+
+        pQueue->Lock();
+
+        //
+        // Process the current request.
+        //
+
+        request = pQueue->m_CurrentRequest;
+
+        if (request) {
+            bytesXferred = pQueue->m_XferredBytes;
+        }
+
+        // 
+        // Reset values.
+        //
+
+        pQueue->m_CurrentRequest = NULL;
+        pQueue->m_XferredBytes = 0;
+
+
+        pQueue->Unlock();
+
+        if (request) {
+            request->CompleteWithInformation(S_OK, bytesXferred);
+        }
+
+        //
+        // If thread needs to be terminated
+        //
+
+        if (pQueue->m_ExitThread) {
+            ExitThread(0);
+        }
+
+    }
+
+}
diff --git a/general/echo/umdf/Queue.h b/general/echo/umdf/Queue.h
new file mode 100644
index 00000000..c4b28c97
--- /dev/null
+++ b/general/echo/umdf/Queue.h
@@ -0,0 +1,213 @@
+/*++
+
+Copyright (c) Microsoft Corporation, All Rights Reserved
+
+Module Name:
+
+    queue.h
+
+Abstract:
+
+    This file defines the queue callback interface.
+
+Environment:
+
+    Windows User-Mode Driver Framework (WUDF)
+
+--*/
+
+#pragma once
+
+// Set max write length for testing
+#define MAX_WRITE_LENGTH (40*1024)
+
+// Set timer period in ms
+#define TIMER_PERIOD     100
+
+//
+// Queue Callback Object.
+//
+
+class CMyQueue : 
+    public IQueueCallbackDeviceIoControl,
+    public IQueueCallbackRead,
+    public IQueueCallbackWrite,
+    public CUnknown
+{
+    PVOID           m_Buffer;           // Current buffer
+    ULONG           m_Length;           // Length of the buffer
+    SIZE_T          m_XferredBytes;     // Amount of bytes transferred for the current request
+    IWDFIoRequest2  *m_CurrentRequest;  // Current request
+    CRITICAL_SECTION m_Crit;            // Lock to protect updates to CMyQueue fields
+    BOOLEAN         m_ExitThread;       // If TRUE Terminate thread.
+    BOOLEAN         m_InitCritSec;      // If TRUE lock initialized
+
+    IWDFIoQueue     *m_FxQueue;
+
+    CMyQueue() : 
+        m_Buffer(NULL), 
+        m_Length (0),
+        m_CurrentRequest(NULL),
+        m_XferredBytes(0),
+        m_ExitThread(FALSE),
+        m_InitCritSec(FALSE),
+        m_FxQueue(NULL)
+    {
+    }
+
+    virtual ~CMyQueue();
+
+    _Acquires_lock_(this->m_Crit)
+    __inline 
+    void
+    Lock(
+        )
+    {
+        ::EnterCriticalSection(&m_Crit);
+    }
+
+    _Releases_lock_(this->m_Crit)
+    __inline 
+    void
+    Unlock(
+        )
+    {
+        ::LeaveCriticalSection(&m_Crit);
+    }
+
+    HRESULT
+    Initialize(
+        _In_ IWDFDevice *FxDevice
+        );
+
+public:
+
+    //
+    // Completion thread routine.
+    //
+
+    static DWORD CompletionThread( PVOID ThreadParameter);
+
+    //
+    // Sets the flag to make thread exit
+    //
+    
+    void
+    SetExitThread()
+    {
+        m_ExitThread = TRUE;
+    }
+
+    static 
+    HRESULT 
+    CreateInstance( 
+        _In_ IWDFDevice *FxDevice,
+        _Out_ PCMyQueue *Queue
+        );
+
+    HRESULT
+    Configure(
+        VOID
+        )
+    {
+        return S_OK;
+    }
+
+   
+    IQueueCallbackDeviceIoControl *
+    QueryIQueueCallbackDeviceIoControl(
+        VOID
+        )
+    {
+        AddRef();
+        return static_cast<IQueueCallbackDeviceIoControl *>(this);
+    }
+    
+    IQueueCallbackRead *
+    QueryIQueueCallbackRead(
+        VOID
+        )
+    {
+        AddRef();
+        return static_cast<IQueueCallbackRead *>(this);
+    }
+
+    IQueueCallbackWrite *
+    QueryIQueueCallbackWrite(
+        VOID
+        )
+    {
+        AddRef();
+        return static_cast<IQueueCallbackWrite *>(this);
+    }
+
+    //
+    // IUnknown
+    //
+
+    virtual
+    ULONG 
+    STDMETHODCALLTYPE
+    AddRef(
+        VOID
+        ) {
+        return CUnknown::AddRef();
+    }
+    
+    _At_(this, __drv_freesMem(object))
+    virtual
+    ULONG
+    STDMETHODCALLTYPE
+    Release(
+        VOID
+        ) {
+        return CUnknown::Release();
+    }
+
+    virtual
+    HRESULT
+    STDMETHODCALLTYPE
+    QueryInterface(
+        _In_ REFIID InterfaceId, 
+        _Out_ PVOID *Object
+        );
+
+    //
+    // Wdf Callbacks
+    //
+    
+    // IQueueCallbackDeviceIoControl
+    //
+    virtual
+    VOID
+    STDMETHODCALLTYPE
+    OnDeviceIoControl( 
+        _In_ IWDFIoQueue *pWdfQueue,
+        _In_ IWDFIoRequest *pWdfRequest,
+        _In_ ULONG ControlCode,
+        _In_ SIZE_T InputBufferSizeInBytes,
+        _In_ SIZE_T OutputBufferSizeInBytes
+        );
+
+    // IQueueCallbackWrite
+    //
+    virtual
+    VOID
+    STDMETHODCALLTYPE
+    OnWrite( 
+        _In_ IWDFIoQueue *pWdfQueue,
+        _In_ IWDFIoRequest *pWdfRequest,
+        _In_ SIZE_T NumOfBytesToWrite
+        );
+
+    // IQueueCallbackRead
+    //
+    virtual
+    VOID
+    STDMETHODCALLTYPE
+    OnRead( 
+        _In_ IWDFIoQueue *pWdfQueue,
+        _In_ IWDFIoRequest *pWdfRequest,
+        _In_ SIZE_T NumOfBytesToRead
+        );
+};
diff --git a/general/echo/umdf/ReadMe.md b/general/echo/umdf/ReadMe.md
new file mode 100644
index 00000000..750d34df
--- /dev/null
+++ b/general/echo/umdf/ReadMe.md
@@ -0,0 +1,124 @@
+Echo Sample (UMDF Version 1)
+============================
+
+This sample demonstrates how to use User-Mode Driver Framework (UMDF) version 1 to write a driver and demonstrates best practices.
+
+It also demonstrates the use of a default Serial Dispatch I/O Queue, its request start events, cancellation event, and synchronizing with another thread. The preferred I/O retrieval mode is set to Direct I/O. So, whenever a request is received by the framework, UMDF looks at the size of the buffer and determines, whether it should copy the buffer (if the length is less than 2 full pages) or map it (if the length is greater or equal to 2 full pages).
+
+This sample driver is a minimal driver meant to demonstrate the usage of the User-Mode Driver Framework. It is not intended for use in a production environment.
+
+
+Related technologies
+--------------------
+
+[User-Mode Driver Framework](http://msdn.microsoft.com/en-us/library/windows/hardware/ff560456)
+
+Testing
+-------
+
+To test the Echo driver, you can run echoapp.exe which is built from src\\general\\echo\\exe.
+
+First install the device as described above. Then run echoapp.exe.
+
+``` {.syntax xml:space="preserve"}
+D:\>echoapp /?
+Usage:
+Echoapp.exe --- Send single write and read request synchronously
+Echoapp.exe -Async --- Send 100 reads and writes asynchronously
+Exit the app anytime by pressing Ctrl-C
+ 
+D:\>echoapp
+DevicePath: \\?\root#sample#0000#{cdc35b6e-0be4-4936-bf5f-5537380a7c1a}
+Opened device successfully
+512 Pattern Bytes Written successfully
+512 Pattern Bytes Read successfully
+Pattern Verified successfully
+ 
+D:\>echoapp -Async
+DevicePath: \\?\root#sample#0000#{cdc35b6e-0be4-4936-bf5f-5537380a7c1a}
+Opened device successfully
+Starting AsyncIo
+Number of bytes written by request number 0 is 1024
+Number of bytes read by request number 0 is 1024
+Number of bytes read by request number 1 is 1024
+Number of bytes written by request number 2 is 1024
+Number of bytes read by request number 2 is 1024
+Number of bytes written by request number 3 is 1024
+Number of bytes read by request number 3 is 1024
+Number of bytes written by request number 4 is 1024
+Number of bytes read by request number 4 is 1024
+Number of bytes written by request number 5 is 1024
+Number of bytes read by request number 5 is 1024
+Number of bytes written by request number 6 is 1024
+Number of bytes read by request number 6 is 1024
+Number of bytes written by request number 7 is 1024
+Number of bytes read by request number 7 is 1024
+Number of bytes written by request number 8 is 1024
+Number of bytes read by request number 8 is 1024
+Number of bytes written by request number 9 is 1024
+Number of bytes read by request number 9 is 1024
+Number of bytes written by request number 10 is 1024
+Number of bytes read by request number 10 is 1024
+Number of bytes written by request number 11 is 1024
+...
+```
+
+Note that the reads and writes are performed by independent threads in the echo test application. As a result the order of the output may not exactly match what you see above.
+
+File Manifest
+-------------
+
+File
+
+Description
+
+comsup.cpp & comsup.h
+
+COM Support code - specifically base classes which provide implementations for the standard COM interfaces IUnknown and IClassFactory which are used throughout this sample.
+
+The implementation of IClassFactory is designed to create instances of the CMyDriver class. If you should change the name of your base driver class, you would also need to modify this file.
+
+dllsup.cpp
+
+DLL Support code - provides the DLL's entry point as well as the single required export (DllGetClassObject).
+
+These depend on comsup.cpp to perform the necessary class creation.
+
+exports.def
+
+This file lists the functions that the driver DLL exports.
+
+internal.h
+
+This is the main header file for this driver.
+
+Driver.cpp and Driver.h
+
+DriverEntry and events on the driver object.
+
+Device.cpp and Device.h
+
+The Events on the device object.
+
+Queue.cpp and Queue.h
+
+Contains Events on the I/O Queue Objects.
+
+Echo.rc
+
+Resource file for the driver.
+
+WUDFEchoDriver.inx
+
+File that describes the installation of this driver. The build process converts this into an INF file.
+
+makefile.inc
+
+A makefile that defines custom build actions. This includes the conversion of the .INX file into a .INF file
+
+echodriver.ctl
+
+This file lists the WPP trace control GUID(s) for the sample driver. This file can be used with the tracelog command's -guid flag to enable the collection of these trace events within an established trace session.
+
+These GUIDs must remain in sync with the trace control GUIDs defined in internal.h.
+
diff --git a/general/echo/umdf/WUDFEchoDriver.inx b/general/echo/umdf/WUDFEchoDriver.inx
new file mode 100644
index 00000000..6279783e
--- /dev/null
+++ b/general/echo/umdf/WUDFEchoDriver.inx
@@ -0,0 +1,87 @@
+;
+; WUDFEchoDriver.inf
+;
+
+[Version]
+Signature="$WINDOWS NT$"
+Class=Sample
+ClassGuid={78A1C341-4539-11d3-B88D-00C04FAD5171}
+Provider=%MSFTWUDF%
+CatalogFile=WUDF.cat
+DriverVer=03/20/2003,5.00.3788
+
+[Manufacturer]
+%MSFTWUDF%=Microsoft,NT$ARCH$
+
+[Microsoft.NT$ARCH$]
+%EchoDeviceName%=Echo_Install,WUDF\Echo
+
+[ClassInstall32]
+AddReg=SampleClass_RegistryAdd
+
+[SampleClass_RegistryAdd]
+HKR,,,,%ClassName%
+HKR,,Icon,,"-10"
+
+[SourceDisksFiles]
+WUDFEchoDriver.dll=1
+WudfUpdate_$UMDFCOINSTALLERVERSION$.dll=1
+
+[SourceDisksNames]
+1 = %MediaDescription%
+
+; =================== WUDF Echo Test Driver ==================================
+
+[Echo_Install.NT]
+CopyFiles=UMDriverCopy
+
+[Echo_Install.NT.hw]
+
+[Echo_Install.NT.Services]
+AddService=WUDFRd,0x000001fa,WUDFRD_ServiceInstall
+
+[Echo_Install.NT.CoInstallers]
+AddReg = CoInstallers_AddReg
+CopyFiles = CoInstallers_CopyFiles
+
+[Echo_Install.NT.Wdf]
+UmdfService=WUDFEchoDriver,WUDFEchoDriver_Install
+UmdfServiceOrder=WUDFEchoDriver
+
+; if device can do either direct i/o or buffered transfer mode,
+; umdf defaults to direct i/o if devices is not pooled.
+UmdfHostProcessSharing=ProcessSharingDisabled
+
+[WUDFEchoDriver_Install]
+UmdfLibraryVersion=$UMDFVERSION$
+DriverCLSID={7AB7DCF5-D1D4-4085-9547-1DB968CCA720}
+ServiceBinary=%12%\UMDF\WUDFEchoDriver.dll
+
+[WUDFRD_ServiceInstall]
+DisplayName = %WudfRdDisplayName%
+ServiceType = 1
+StartType = 3
+ErrorControl = 1
+ServiceBinary = %12%\WUDFRd.sys
+
+[CoInstallers_AddReg]
+HKR,,CoInstallers32,0x00010000,"WudfUpdate_$UMDFCOINSTALLERVERSION$.dll"
+
+[CoInstallers_CopyFiles]
+WudfUpdate_$UMDFCOINSTALLERVERSION$.dll
+
+[DestinationDirs]
+UMDriverCopy=12,UMDF ; copy to drivers\UMDF
+CoInstallers_CopyFiles=11
+
+[UMDriverCopy]
+WUDFEchoDriver.dll
+
+; =================== Generic ==================================
+
+[Strings]
+MSFTWUDF="Microsoft Internal (WUDF)"
+MediaDescription="Microsoft WUDF Sample Driver Installation Media"
+ClassName="Sample Device"
+WudfRdDisplayName="Windows Driver Foundation - User-mode Driver Framework Reflector"
+EchoDeviceName="Sample WUDF Echo Driver"
diff --git a/general/echo/umdf/WUDFEchoDriver.vcxproj b/general/echo/umdf/WUDFEchoDriver.vcxproj
new file mode 100644
index 00000000..242f1dda
--- /dev/null
+++ b/general/echo/umdf/WUDFEchoDriver.vcxproj
@@ -0,0 +1,256 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9E7A6816-063C-4560-A31F-C5472D1CE345}</ProjectGuid>
+    <RootNamespace>$(MSBuildProjectName)</RootNamespace>
+    <UMDF_VERSION_MAJOR>1</UMDF_VERSION_MAJOR>
+    <Configuration Condition="'$(Configuration)' == ''">Debug</Configuration>
+    <Platform Condition="'$(Platform)' == ''">Win32</Platform>
+    <SampleGuid>{164B0F80-BB88-48C9-A03F-3F3937D8CCB6}</SampleGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+    <DriverTargetPlatform>Desktop</DriverTargetPlatform>
+    <DriverType>UMDF</DriverType>
+    <PlatformToolset>WindowsUserModeDriver10.0</PlatformToolset>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+    <DriverTargetPlatform>Desktop</DriverTargetPlatform>
+    <DriverType>UMDF</DriverType>
+    <PlatformToolset>WindowsUserModeDriver10.0</PlatformToolset>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>False</UseDebugLibraries>
+    <DriverTargetPlatform>Desktop</DriverTargetPlatform>
+    <DriverType>UMDF</DriverType>
+    <PlatformToolset>WindowsUserModeDriver10.0</PlatformToolset>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>True</UseDebugLibraries>
+    <DriverTargetPlatform>Desktop</DriverTargetPlatform>
+    <DriverType>UMDF</DriverType>
+    <PlatformToolset>WindowsUserModeDriver10.0</PlatformToolset>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <PropertyGroup>
+    <OutDir>$(IntDir)</OutDir>
+  </PropertyGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ItemGroup Label="WrappedTaskItems">
+    <ClCompile Include="dllsup.cpp; comsup.cpp; driver.cpp; device.cpp; queue.cpp">
+      <WppEnabled>true</WppEnabled>
+      <WppDllMacro>true</WppDllMacro>
+      <WppScanConfigurationData>internal.h</WppScanConfigurationData>
+    </ClCompile>
+    <Inf Include="WudfEchoDriver.inx">
+      <Architecture>$(InfArch)</Architecture>
+      <SpecifyArchitecture>true</SpecifyArchitecture>
+      <CopyOutput>.\$(IntDir)\WudfEchoDriver.inf</CopyOutput>
+    </Inf>
+    <OtherWpp Include="Echo.rc">
+      <WppEnabled>true</WppEnabled>
+      <WppDllMacro>true</WppDllMacro>
+      <WppScanConfigurationData>internal.h</WppScanConfigurationData>
+    </OtherWpp>
+  </ItemGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <TargetName>WUDFEchoDriver</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <TargetName>WUDFEchoDriver</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <TargetName>WUDFEchoDriver</TargetName>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <TargetName>WUDFEchoDriver</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </ClCompile>
+    <Midl>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </Midl>
+    <ResourceCompile>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </ResourceCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </ClCompile>
+    <Midl>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </Midl>
+    <ResourceCompile>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </ResourceCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </ClCompile>
+    <Midl>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </Midl>
+    <ResourceCompile>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </ResourceCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </ClCompile>
+    <Midl>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </Midl>
+    <ResourceCompile>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions);_UNICODE;UNICODE</PreprocessorDefinitions>
+    </ResourceCompile>
+  </ItemDefinitionGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <WIN32_WINNT_VERSION>0x0A00</WIN32_WINNT_VERSION>
+    <NTDDI_VERSION>0x0A000000</NTDDI_VERSION>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <WIN32_WINNT_VERSION>0x0A00</WIN32_WINNT_VERSION>
+    <NTDDI_VERSION>0x0A000000</NTDDI_VERSION>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <WIN32_WINNT_VERSION>0x0A00</WIN32_WINNT_VERSION>
+    <NTDDI_VERSION>0x0A000000</NTDDI_VERSION>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <WIN32_WINNT_VERSION>0x0A00</WIN32_WINNT_VERSION>
+    <NTDDI_VERSION>0x0A000000</NTDDI_VERSION>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Link>
+      <EntryPointSymbol Condition="'$(Platform)'=='win32'">_DllMainCRTStartup@12</EntryPointSymbol>
+      <EntryPointSymbol Condition="'$(Platform)'!='win32'">_DllMainCRTStartup</EntryPointSymbol>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Link>
+      <EntryPointSymbol Condition="'$(Platform)'=='win32'">_DllMainCRTStartup@12</EntryPointSymbol>
+      <EntryPointSymbol Condition="'$(Platform)'!='win32'">_DllMainCRTStartup</EntryPointSymbol>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Link>
+      <EntryPointSymbol Condition="'$(Platform)'=='win32'">_DllMainCRTStartup@12</EntryPointSymbol>
+      <EntryPointSymbol Condition="'$(Platform)'!='win32'">_DllMainCRTStartup</EntryPointSymbol>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Link>
+      <EntryPointSymbol Condition="'$(Platform)'=='win32'">_DllMainCRTStartup@12</EntryPointSymbol>
+      <EntryPointSymbol Condition="'$(Platform)'!='win32'">_DllMainCRTStartup</EntryPointSymbol>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <WarningLevel>Level4</WarningLevel>
+      <ExceptionHandling>
+      </ExceptionHandling>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>%(AdditionalDependencies);$(SDK_LIB_PATH)\strsafe.lib;$(SDK_LIB_PATH)\kernel32.lib;$(SDK_LIB_PATH)\advapi32.lib</AdditionalDependencies>
+      <ModuleDefinitionFile>exports.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <WarningLevel>Level4</WarningLevel>
+      <ExceptionHandling>
+      </ExceptionHandling>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>%(AdditionalDependencies);$(SDK_LIB_PATH)\strsafe.lib;$(SDK_LIB_PATH)\kernel32.lib;$(SDK_LIB_PATH)\advapi32.lib</AdditionalDependencies>
+      <ModuleDefinitionFile>exports.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <WarningLevel>Level4</WarningLevel>
+      <ExceptionHandling>
+      </ExceptionHandling>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>%(AdditionalDependencies);$(SDK_LIB_PATH)\strsafe.lib;$(SDK_LIB_PATH)\kernel32.lib;$(SDK_LIB_PATH)\advapi32.lib</AdditionalDependencies>
+      <ModuleDefinitionFile>exports.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <WarningLevel>Level4</WarningLevel>
+      <ExceptionHandling>
+      </ExceptionHandling>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>%(AdditionalDependencies);$(SDK_LIB_PATH)\strsafe.lib;$(SDK_LIB_PATH)\kernel32.lib;$(SDK_LIB_PATH)\advapi32.lib</AdditionalDependencies>
+      <ModuleDefinitionFile>exports.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Echo.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <Inf Exclude="@(Inf)" Include="*.inf" />
+    <FilesToPackage Include="$(TargetPath)" Condition="'$(ConfigurationType)'=='Driver' or '$(ConfigurationType)'=='DynamicLibrary'" />
+    <FilesToPackage Include="@(Inf->'%(CopyOutput)')" Condition="'@(Inf)'!=''" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Exclude="@(None)" Include="*.txt;*.htm;*.html" />
+    <None Exclude="@(None)" Include="*.ico;*.cur;*.bmp;*.dlg;*.rct;*.gif;*.jpg;*.jpeg;*.wav;*.jpe;*.tiff;*.tif;*.png;*.rc2" />
+    <None Exclude="@(None)" Include="*.def;*.bat;*.hpj;*.asmx" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Exclude="@(ClInclude)" Include="*.h;*.hpp;*.hxx;*.hm;*.inl;*.xsd" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>
\ No newline at end of file
diff --git a/general/echo/umdf/WUDFEchoDriver.vcxproj.Filters b/general/echo/umdf/WUDFEchoDriver.vcxproj.Filters
new file mode 100644
index 00000000..b702fb21
--- /dev/null
+++ b/general/echo/umdf/WUDFEchoDriver.vcxproj.Filters
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx;*</Extensions>
+      <UniqueIdentifier>{0FBE107F-4905-4E97-BFF9-8C2A6B03AED8}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files">
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+      <UniqueIdentifier>{9534FE43-2493-4430-A335-97FC2BE106BD}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Resource Files">
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms;man;xml</Extensions>
+      <UniqueIdentifier>{A96A2015-2537-47ED-B43D-8C379EDEC69F}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Driver Files">
+      <Extensions>inf;inv;inx;mof;mc;</Extensions>
+      <UniqueIdentifier>{203FBCD2-49E2-491E-9D3F-03A028ED6CEE}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="comsup.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="device.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="dllsup.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="driver.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="queue.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <None Include="exports.def">
+      <Filter>Source Files</Filter>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <FilesToPackage Include=".\Debug\\WudfEchoDriver.inf">
+      <Filter>Driver Files</Filter>
+    </FilesToPackage>
+    <Inf Include="WudfEchoDriver.inx">
+      <Filter>Driver Files</Filter>
+    </Inf>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Echo.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/general/echo/umdf/dllsup.cpp b/general/echo/umdf/dllsup.cpp
new file mode 100644
index 00000000..e7200a28
--- /dev/null
+++ b/general/echo/umdf/dllsup.cpp
@@ -0,0 +1,176 @@
+/*++
+ 
+Copyright (C) Microsoft Corporation, All Rights Reserved.
+
+Module Name:
+
+    dllsup.cpp
+
+Abstract:
+
+    This module contains the implementation of the UMDF Echo Sample 
+    Driver's entry point and its exported functions for providing COM support.
+
+    This module can be copied without modification to a new UMDF driver.  It
+    depends on some of the code in comsup.cpp & comsup.h to handle DLL 
+    registration and creating the first class factory.
+
+    This module is dependent on the following defines:
+
+        MYDRIVER_TRACING_ID - A wide string passed to WPP when initializing 
+                              tracing.  For example the echo driver uses 
+                              L"Microsoft\\UMDF\\Echo"
+
+        MYDRIVER_CLASS_ID -   A GUID encoded in struct format used to 
+                              initialize the driver's ClassID.     
+
+    These are defined in internal.h for the sample.  If you choose
+    to use a different primary include file, you should ensure they are 
+    defined there as well.
+
+Environment:
+
+    WDF User-Mode Driver Framework (WDF:UMDF)
+
+--*/
+
+#include "internal.h"
+#include "dllsup.tmh"
+
+const GUID CLSID_MyDriverCoClass = MYDRIVER_CLASS_ID;
+
+BOOL
+WINAPI
+DllMain(
+    HINSTANCE ModuleHandle,
+    DWORD Reason,
+    PVOID /* Reserved */
+   )
+/*++
+
+  Routine Description:
+
+    This is the entry point and exit point for the I/O trace driver.  This 
+    does very little as the I/O trace driver has minimal global data.
+
+    This method initializes tracing.
+
+  Arguments:
+
+    ModuleHandle - the DLL handle for this module.
+
+    Reason - the reason this entry point was called.
+
+    Reserved - unused
+
+  Return Value:
+
+    TRUE
+
+--*/
+{
+
+    UNREFERENCED_PARAMETER(ModuleHandle);
+
+    if (DLL_PROCESS_ATTACH == Reason)
+    {
+        //
+        // Initialize tracing.
+        //
+
+        WPP_INIT_TRACING(MYDRIVER_TRACING_ID);
+    }
+    else if (DLL_PROCESS_DETACH == Reason)
+    {
+        //
+        // Cleanup tracing.
+        //
+
+        WPP_CLEANUP();
+    }
+
+    return TRUE;
+}
+
+HRESULT
+STDAPICALLTYPE
+DllGetClassObject(
+    _In_ REFCLSID ClassId,
+    _In_ REFIID InterfaceId,
+    _Outptr_ LPVOID *Interface
+    )
+/*++
+
+  Routine Description:
+
+    This routine is called by COM in order to instantiate the 
+    driver callback object and do an initial query interface on it.
+
+    This method only creates an instance of the driver's class factory, as this
+    is the minimum required to support UMDF.
+
+  Arguments:
+
+    ClassId - the CLSID of the object being "gotten"
+
+    InterfaceId - the interface the caller wants from that object.
+
+    Interface - a location to store the referenced interface pointer
+
+  Return Value:
+
+    S_OK if the function succeeds or error indicating the cause of the 
+    failure.
+
+--*/
+{
+    PCClassFactory factory;
+
+    HRESULT hr = S_OK;
+
+    *Interface = NULL;
+
+    //
+    // If the CLSID doesn't match that of our "coclass" (defined in the IDL 
+    // file) then we can't create the object the caller wants.  This may 
+    // indicate that the COM registration is incorrect, and another CLSID 
+    // is referencing this drvier.
+    //
+
+    if (IsEqualCLSID(ClassId, CLSID_MyDriverCoClass) == false)
+    {
+        Trace(
+            TRACE_LEVEL_ERROR,
+            L"ERROR: Called to create instance of unrecognized class (%!GUID!)",
+            &ClassId
+            );
+
+        return CLASS_E_CLASSNOTAVAILABLE;
+    }
+
+    //
+    // Create an instance of the class factory for the caller.
+    //
+
+    factory = new CClassFactory();
+
+    if (NULL == factory) 
+    {
+        hr = E_OUTOFMEMORY;
+    }
+
+    // 
+    // Query the object we created for the interface the caller wants.  After
+    // that we release the object.  This will drive the reference count to 
+    // 1 (if the QI succeeded an referenced the object) or 0 (if the QI failed).
+    // In the later case the object is automatically deleted.
+    //
+
+    if (SUCCEEDED(hr)) 
+    {
+        hr = factory->QueryInterface(InterfaceId, Interface);
+        factory->Release();
+    }
+
+    return hr;
+}
diff --git a/general/echo/umdf/echo.sln b/general/echo/umdf/echo.sln
new file mode 100644
index 00000000..853b7d55
--- /dev/null
+++ b/general/echo/umdf/echo.sln
@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0
+MinimumVisualStudioVersion = 12.0
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WUDFEchoDriver", "WUDFEchoDriver.vcxproj", "{9E7A6816-063C-4560-A31F-C5472D1CE345}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9E7A6816-063C-4560-A31F-C5472D1CE345}.Debug|Win32.ActiveCfg = Debug|Win32
+		{9E7A6816-063C-4560-A31F-C5472D1CE345}.Debug|Win32.Build.0 = Debug|Win32
+		{9E7A6816-063C-4560-A31F-C5472D1CE345}.Release|Win32.ActiveCfg = Release|Win32
+		{9E7A6816-063C-4560-A31F-C5472D1CE345}.Release|Win32.Build.0 = Release|Win32
+		{9E7A6816-063C-4560-A31F-C5472D1CE345}.Debug|x64.ActiveCfg = Debug|x64
+		{9E7A6816-063C-4560-A31F-C5472D1CE345}.Debug|x64.Build.0 = Debug|x64
+		{9E7A6816-063C-4560-A31F-C5472D1CE345}.Release|x64.ActiveCfg = Release|x64
+		{9E7A6816-063C-4560-A31F-C5472D1CE345}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/general/echo/umdf/echodriver.ctl b/general/echo/umdf/echodriver.ctl
new file mode 100644
index 00000000..a0ce2089
--- /dev/null
+++ b/general/echo/umdf/echodriver.ctl
@@ -0,0 +1 @@
+d93fb470-afb1-4af8-860e-75f726c66f6b WudfEchoDriverTraceGuid
diff --git a/general/echo/umdf/exports.def b/general/echo/umdf/exports.def
new file mode 100644
index 00000000..ec564639
--- /dev/null
+++ b/general/echo/umdf/exports.def
@@ -0,0 +1,10 @@
+; Echo.def : Declares the module parameters.
+
+;
+; TODO: Change the library name here to match your binary name.
+;
+
+LIBRARY      "WUDFEchoDriver.DLL"
+
+EXPORTS
+    DllGetClassObject   PRIVATE
diff --git a/general/echo/umdf/internal.h b/general/echo/umdf/internal.h
new file mode 100644
index 00000000..8e5c2d60
--- /dev/null
+++ b/general/echo/umdf/internal.h
@@ -0,0 +1,114 @@
+/*++
+
+Copyright (C) Microsoft Corporation, All Rights Reserved
+
+Module Name:
+
+    Internal.h
+
+Abstract:
+
+    This module contains the local type definitions for the UMDF Echo
+    driver sample.
+
+Environment:
+
+    Windows User-Mode Driver Framework (WUDF)
+
+--*/
+
+#pragma once
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
+#endif
+
+//
+// Include the WUDF DDI
+//
+
+#include "wudfddi.h"
+
+//
+// Use specstrings for in/out annotation of function parameters.
+//
+
+#include "specstrings.h"
+
+//
+// Forward definitions of classes in the other header files.
+//
+
+typedef class CMyDriver *PCMyDriver;
+typedef class CMyDevice *PCMyDevice;
+typedef class CMyQueue  *PCMyQueue;
+
+//
+// Define the tracing flags.
+//
+// TODO: Choose a different trace control GUID
+//
+
+#define WPP_CONTROL_GUIDS                                                   \
+    WPP_DEFINE_CONTROL_GUID(                                                \
+        MyDriverTraceControl, (d93fb470,afb1,4af8,860e,75f726c66f6b),       \
+                                                                            \
+        WPP_DEFINE_BIT(MYDRIVER_ALL_INFO)                                   \
+        )
+
+#define WPP_FLAG_LEVEL_LOGGER(flag, level)                                  \
+    WPP_LEVEL_LOGGER(flag)
+
+#define WPP_FLAG_LEVEL_ENABLED(flag, level)                                 \
+    (WPP_LEVEL_ENABLED(flag) &&                                             \
+     WPP_CONTROL(WPP_BIT_ ## flag).Level >= level)
+
+//
+// This comment block is scanned by the trace preprocessor to define our
+// Trace function.
+//
+// begin_wpp config
+// FUNC Trace{FLAG=MYDRIVER_ALL_INFO}(LEVEL, MSG, ...);
+// end_wpp
+//
+
+//
+// Driver specific #defines
+//
+// TODO: Change these values to be appropriate for your driver.
+//
+
+#define MYDRIVER_TRACING_ID L"Microsoft\\UMDF\\Echo"
+#define MYDRIVER_CLASS_ID   {0x7ab7dcf5, 0xd1d4, 0x4085, {0x95, 0x47, 0x1d, 0xb9, 0x68, 0xcc, 0xa7, 0x20}}
+
+//
+// Include the type specific headers.
+//
+
+#include "comsup.h"
+#include "driver.h"
+#include "device.h"
+#include "queue.h"
+
+__forceinline 
+#ifdef _PREFAST_
+__declspec(noreturn)
+#endif
+VOID
+WdfTestNoReturn(
+    VOID
+    )
+{
+    // do nothing.
+}
+
+#define WUDF_TEST_DRIVER_ASSERT(p)  \
+{                                   \
+    if ( !(p) )                     \
+    {                               \
+        DebugBreak();               \
+        WdfTestNoReturn();          \
+    }                               \
+}
+
+#define SAFE_RELEASE(p)     {if ((p)) { (p)->Release(); (p) = NULL; }}