fxiotargetremotekm.cpp

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft Corporation
 
Module Name:
 
    FxIoTargetRemoteKm.cpp
 
Abstract:
 
Author:
 
Environment:
 
    kernel mode only
 
Revision History:
 
--*/
 
#include "../../fxtargetsshared.hpp"
 
extern "C" {
// #include "FxIoTargetRemoteKm.tmh"
}
 
#include <initguid.h>
#include "wdmguid.h"
 
_Must_inspect_result_
NTSTATUS
STDCALL
FxIoTargetRemote::_PlugPlayNotification(
    __in PVOID NotificationStructure,
    __inout_opt PVOID Context
    )
{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    PTARGET_DEVICE_REMOVAL_NOTIFICATION pNotification;
    FxIoTargetRemote* pThis;
    NTSTATUS status;
 
    ASSERT(Mx::MxGetCurrentIrql() < DISPATCH_LEVEL);
    pNotification = (PTARGET_DEVICE_REMOVAL_NOTIFICATION) NotificationStructure;
    pThis = (FxIoTargetRemote*) Context;
 
    //
    // In one of these callbacks, the driver may decide to delete the target.
    // If that is the case, we need to be able to return and deref the object until
    // we are done.
    //
    pThis->ADDREF((PVOID)_PlugPlayNotification);
 
    pFxDriverGlobals = pThis->GetDriverGlobals();
 
    status = STATUS_SUCCESS;
 
    if (FxIsEqualGuid(&pNotification->Event, &GUID_TARGET_DEVICE_QUERY_REMOVE)) {
 
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "WDFIOTARGET %p: query remove notification", pThis->GetObjectHandle());
 
        //
        // Device is gracefully being removed.  PnP is asking us to close down
        // the target.  If there is a driver callback, there is *no* default
        // behavior.  This is because we don't know what the callback is going
        // to do.  For instance, the driver could reopen the target to a
        // different device in a multi-path scenario.
        //
        if (pThis->m_EvtQueryRemove.m_Method != NULL) {
            status = pThis->m_EvtQueryRemove.Invoke(pThis->GetHandle());
        }
        else {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                "WDFIOTARGET %p: query remove, default action (close for QR)",
                pThis->GetObjectHandle());
 
            //
            // No callback, close it down conditionally.
            //
            pThis->Close(FxIoTargetRemoteCloseReasonQueryRemove);
        }
    }
    else if (FxIsEqualGuid(&pNotification->Event, &GUID_TARGET_DEVICE_REMOVE_COMPLETE)) {
 
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "WDFIOTARGET %p: remove complete notification", pThis->GetObjectHandle());
 
        //
        // The device was surprise removed, close it for good if the driver has
        // no override.
        //
        if (pThis->m_EvtRemoveComplete.m_Method != NULL) {
            pThis->m_EvtRemoveComplete.Invoke(pThis->GetHandle());
        }
        else {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                "WDFIOTARGET %p: remove complete, default action (close)",
                pThis->GetObjectHandle());
 
            //
            // The device is now gone for good.  Close down the target for good.
            //
            pThis->Close(FxIoTargetRemoteCloseReasonPlainClose);
        }
    }
    else if (FxIsEqualGuid(&pNotification->Event, &GUID_TARGET_DEVICE_REMOVE_CANCELLED)) {
 
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "WDFIOTARGET %p: remove canceled notification", pThis->GetObjectHandle());
 
        if (pThis->m_EvtRemoveCanceled.m_Method != NULL) {
            pThis->m_EvtRemoveCanceled.Invoke(pThis->GetHandle());
        }
        else {
            WDF_IO_TARGET_OPEN_PARAMS params;
 
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                "WDFIOTARGET %p: remove canceled, default action (reopen)",
                pThis->GetObjectHandle());
 
            WDF_IO_TARGET_OPEN_PARAMS_INIT_REOPEN(&params);
 
            //
            // Attempt to reopen the target with stored settings
            //
            status = pThis->Open(&params);
        }
    }
 
    pThis->RELEASE((PVOID)_PlugPlayNotification);
 
    return status;
}
 
NTSTATUS
FxIoTargetRemote::RegisterForPnpNotification(
    )
{
    NTSTATUS status;
 
    //
    // Register for PNP notifications on the handle we just opened.
    // This will notify us of pnp state changes on the handle.
    //
    status = IoRegisterPlugPlayNotification(
        EventCategoryTargetDeviceChange,
        0,
        m_TargetFileObject,
        m_Driver->GetDriverObject(),
        _PlugPlayNotification,
        this,
        &m_TargetNotifyHandle);
 
    return status;
}
 
VOID
FxIoTargetRemote::UnregisterForPnpNotification(
    _In_ MdTargetNotifyHandle Handle
    )
{
    if (Handle != NULL) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        if (FxLibraryGlobals.IoUnregisterPlugPlayNotificationEx != NULL) {
            FxLibraryGlobals.IoUnregisterPlugPlayNotificationEx(Handle);
        }
        else {
            IoUnregisterPlugPlayNotification(Handle);
        }
    }
}
 
NTSTATUS
FxIoTargetRemote::OpenTargetHandle(
    _In_ PWDF_IO_TARGET_OPEN_PARAMS OpenParams,
    _Inout_ FxIoTargetRemoveOpenParams* pParams
    )
{
    OBJECT_ATTRIBUTES oa;
    IO_STATUS_BLOCK ioStatus;
    NTSTATUS status;
 
    InitializeObjectAttributes(&oa,
                               &pParams->TargetDeviceName,
                               OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    status = ZwCreateFile(&m_TargetHandle,
                          pParams->DesiredAccess,
                          &oa,
                          &ioStatus,
                          pParams->AllocationSizePointer,
                          pParams->FileAttributes,
                          pParams->ShareAccess,
                          pParams->CreateDisposition,
                          pParams->CreateOptions,
                          pParams->EaBuffer,
                          pParams->EaBufferLength);
 
    OpenParams->FileInformation = (ULONG)ioStatus.Information;
 
    if (NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGIOTARGET,
            "ZwCreateFile for WDFIOTARGET %p returned status %!STATUS!, info 0x%x",
            GetObjectHandle(), status, (ULONG) ioStatus.Information);
 
        //
        // The open operation was successful. Dereference the file handle and
        // obtain a pointer to the device object for the handle.
        //
        status = ObReferenceObjectByHandle(
            m_TargetHandle,
            pParams->DesiredAccess,
            *IoFileObjectType,
            KernelMode,
            (PVOID*) &m_TargetFileObject,
            NULL);
 
        if (NT_SUCCESS(status)) {
            m_TargetDevice = IoGetRelatedDeviceObject(m_TargetFileObject);
 
            if (m_TargetDevice == NULL) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "WDFIOTARGET %p, could not convert filobj %p to devobj",
                    GetObjectHandle(), m_TargetFileObject);
 
                status = STATUS_NO_SUCH_DEVICE;
            }
        }
        else {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "WDFIOTARGET %p, could not convert handle %p to fileobject, "
                "status %!STATUS!",
                GetObjectHandle(), m_TargetHandle, status);
        }
    }
    else {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "ZwCreateFile for WDFIOTARGET %p returned status %!STATUS!, info 0x%x",
            GetObjectHandle(), status, (ULONG) ioStatus.Information);
    }
 
    return status;
}
 
NTSTATUS
FxIoTargetRemote::GetTargetDeviceRelations(
    _Inout_ BOOLEAN* Close
    )
{
    PDEVICE_OBJECT pTopOfStack;
    FxAutoIrp irp(NULL);
    PIRP pIrp;
    NTSTATUS status;
 
    pTopOfStack = IoGetAttachedDeviceReference(m_TargetDevice);
 
    pIrp = IoAllocateIrp(pTopOfStack->StackSize, FALSE);
 
    if (pIrp != NULL) {
        PIO_STACK_LOCATION stack;
 
        irp.SetIrp(pIrp);
 
        stack = irp.GetNextIrpStackLocation();
        stack->MajorFunction = IRP_MJ_PNP;
        stack->MinorFunction = IRP_MN_QUERY_DEVICE_RELATIONS;
        stack->Parameters.QueryDeviceRelations.Type = TargetDeviceRelation;
 
        //
        // Initialize the status to error in case the bus driver decides not
        // to set it correctly.
        //
        irp.SetStatus(STATUS_NOT_SUPPORTED);
 
        status = irp.SendIrpSynchronously(pTopOfStack);
 
        if (NT_SUCCESS(status)) {
            PDEVICE_RELATIONS pRelations;
 
            pRelations = (PDEVICE_RELATIONS) irp.GetInformation();
 
            ASSERT(pRelations != NULL);
 
            //
            // m_TargetPdo was referenced by the bus driver, it will be
            // dereferenced when the target is closed.
            //
            m_TargetPdo = pRelations->Objects[0];
 
            //
            // We, as the caller, are responsible for freeing the relations
            // that the bus driver allocated.
            //
            ExFreePool(pRelations);
        }
        else {
            //
            // Could not retrieve the PDO pointer, error handled later
            //
            DO_NOTHING();
        }
    }
    else {
        //
        // Could not even allocate an irp, failure.
        //
        status = STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
        "Unable to allocate memory for IRP WDFIOTARGET %p, %!STATUS!",
        GetObjectHandle(), status);
    }
 
    //
    // Only fail the open if we cannot allocate an irp or if the lower
    // driver could not allocate a relations.
    //
    if (status == STATUS_INSUFFICIENT_RESOURCES) {
        *Close = TRUE;
    }
    else {
        status = STATUS_SUCCESS;
    }
 
    //
    // Remove the reference taken by IoGetAttachedDeviceReference
    //
    ObDereferenceObject(pTopOfStack);
 
    return status;
}