fxiotargetapikm.cpp

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft Corporation
 
Module Name:
 
    FxIoTargetAPIKm.cpp
 
Abstract:
 
    This module implements the IO Target APIs
 
Author:
 
Environment:
 
    kernel mode only
 
Revision History:
 
--*/
 
#include "../../fxtargetsshared.hpp"
 
extern "C" {
// #include "FxIoTargetAPIKm.tmh"
}
 
//
// Extern the entire file
//
extern "C" {
 
__drv_maxIRQL(DISPATCH_LEVEL)
PDEVICE_OBJECT
STDCALL
WDFEXPORT(WdfIoTargetWdmGetTargetDeviceObject)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    WDFIOTARGET IoTarget
    )
/*++
 
Routine Description:
    Returns the PDEVICE_OBJECT.  This is the device which PIRPs are sent to.
    This is not necessarily the PDEVICE_OBJECT that WDFDEVICE is attached to.
 
Arguments:
    IoTarget - target whose WDM device object is being returned
 
Return Value:
    valid PDEVICE_OBJECT or NULL on failure
 
  --*/
{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxIoTarget* pTarget;
    PDEVICE_OBJECT pDevice;
 
    FxObjectHandleGetPtrAndGlobals(GetFxDriverGlobals(DriverGlobals),
                                   IoTarget,
                                   FX_TYPE_IO_TARGET,
                                   (PVOID*) &pTarget,
                                   &pFxDriverGlobals);
 
    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "enter WDFIOTARGET 0x%p", IoTarget);
 
    pDevice = pTarget->GetTargetDevice();
 
    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "exit WDFIOTARGET 0x%p, WDM DevObj 0x%p", IoTarget, pDevice);
 
    return pDevice;
}
 
__drv_maxIRQL(DISPATCH_LEVEL)
PDEVICE_OBJECT
STDCALL
WDFEXPORT(WdfIoTargetWdmGetTargetPhysicalDevice)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    WDFIOTARGET IoTarget
    )
/*++
 
Routine Description:
    Returns the PDO for the target itself.  This is not necessarily the same
    PDO as the WDFDEVICE that owns the target.  Not all targets have a PDO since
    you can open a legacy non pnp PDEVICE_OBJECT which does not have one.
 
Arguments:
    IoTarget - target whose PDO is being returned
 
Return Value:
    A valid PDEVICE_OBJECT or NULL upon success
 
  --*/
{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxIoTarget* pTarget;
    PDEVICE_OBJECT pPdo;
 
    FxObjectHandleGetPtrAndGlobals(GetFxDriverGlobals(DriverGlobals),
                                   IoTarget,
                                   FX_TYPE_IO_TARGET,
                                   (PVOID*) &pTarget,
                                   &pFxDriverGlobals);
 
    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "enter WDFIOTARGET 0x%p", IoTarget);
 
    pPdo = pTarget->GetTargetPDO();
 
    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "exit WDFIOTARGET 0x%p, WDM PDO 0x%p", IoTarget, pPdo);
 
    return pPdo;
}
 
 
__drv_maxIRQL(DISPATCH_LEVEL)
PFILE_OBJECT
STDCALL
WDFEXPORT(WdfIoTargetWdmGetTargetFileObject)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    WDFIOTARGET IoTarget
    )
/*++
 
Routine Description:
    Returns the PFILE_OBJECT associated with the target.  Not all targets have
    an underlying file object so NULL is a valid and successful return value.
 
Arguments:
    IoTarget - the target whose fileobject is being returned
 
Return Value:
    a valid PFILE_OBJECT or NULL upon success
 
  --*/
{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxIoTarget* pTarget;
    MdFileObject pFile;
 
    FxObjectHandleGetPtrAndGlobals(GetFxDriverGlobals(DriverGlobals),
                                   IoTarget,
                                   FX_TYPE_IO_TARGET,
                                   (PVOID*) &pTarget,
                                   &pFxDriverGlobals);
 
    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "enter WDFIOTARGET 0x%p", IoTarget);
 
    pFile = pTarget->GetTargetFileObject();
 
    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "exit WDFIOTARGET 0x%p, WDM FileObj 0x%p", IoTarget, pFile);
 
    return pFile;
}
 
__drv_maxIRQL(PASSIVE_LEVEL)
_Must_inspect_result_
NTSTATUS
STDCALL
WDFEXPORT(WdfIoTargetQueryForInterface)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    WDFIOTARGET IoTarget,
    __in
    LPCGUID InterfaceType,
    __out
    PINTERFACE Interface,
    __in
    USHORT Size,
    __in
    USHORT Version,
    __in_opt
    PVOID InterfaceSpecificData
    )
/*++
 
Routine Description:
    Sends a query interface pnp request to the top of the target's stack.
 
Arguments:
    IoTarget - the target which is being queried
 
    InterfaceType - interface type specifier
 
    Interface - Interface block which will be filled in by the component which
                responds to the query interface
 
    Size - size in bytes of Interface
 
    Version - version of InterfaceType being requested
 
    InterfaceSpecificData - Additional data associated with Interface
 
Return Value:
    NTSTATUS
 
  --*/
{
    FxIoTarget* pTarget;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    PDEVICE_OBJECT pTopOfStack;
    NTSTATUS status;
 
    FxObjectHandleGetPtrAndGlobals(GetFxDriverGlobals(DriverGlobals),
                                   IoTarget,
                                   FX_TYPE_IO_TARGET,
                                   (PVOID*) &pTarget,
                                   &pFxDriverGlobals);
 
    FxPointerNotNull(pFxDriverGlobals, InterfaceType);
    FxPointerNotNull(pFxDriverGlobals, Interface);
 
    status = FxVerifierCheckIrqlLevel(pFxDriverGlobals, PASSIVE_LEVEL);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    pTopOfStack = IoGetAttachedDeviceReference(pTarget->GetTargetDevice());
    ASSERT(pTopOfStack != NULL);
 
    status = FxQueryInterface::_QueryForInterface(pTopOfStack,
                                                  InterfaceType,
                                                  Interface,
                                                  Size,
                                                  Version,
                                                  InterfaceSpecificData);
 
    ObDereferenceObject(pTopOfStack);
 
    return status;
}
 
_Must_inspect_result_
__drv_maxIRQL(PASSIVE_LEVEL)
NTSTATUS
STDCALL
WDFEXPORT(WdfIoTargetQueryTargetProperty)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    WDFIOTARGET IoTarget,
    __in
    DEVICE_REGISTRY_PROPERTY  DeviceProperty,
    __in
    ULONG BufferLength,
    __drv_when(BufferLength != 0, __out_bcount_part_opt(BufferLength, *ResultLength))
    __drv_when(BufferLength == 0, __out_opt)
    PVOID PropertyBuffer,
    __deref_out_range(<=,BufferLength)
    PULONG ResultLength
    )
/*++
 
Routine Description:
    Retrieves the requested device property for the given target
 
Arguments:
    IoTarget - the target whose PDO whose will be queried
 
    DeviceProperty - the property being queried
 
    BufferLength - length of PropertyBuffer in bytes
 
    PropertyBuffer - Buffer which will receive the property being queried
 
    ResultLength - if STATUS_BUFFER_TOO_SMALL is returned, then this will contain
                   the required length
 
Return Value:
    NTSTATUS
 
  --*/
{
    DDI_ENTRY();
 
    PFX_DRIVER_GLOBALS pGlobals;
    NTSTATUS status;
    FxIoTarget* pTarget;
    MdDeviceObject pPdo;
 
    FxObjectHandleGetPtrAndGlobals(GetFxDriverGlobals(DriverGlobals),
                                   IoTarget,
                                   FX_TYPE_IO_TARGET,
                                   (PVOID*) &pTarget,
                                   &pGlobals);
 
    FxPointerNotNull(pGlobals, ResultLength);
    if (BufferLength > 0) {
        FxPointerNotNull(pGlobals, PropertyBuffer);
    }
 
    status = FxVerifierCheckIrqlLevel(pGlobals, PASSIVE_LEVEL);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    pPdo = pTarget->GetTargetPDO();
 
    if (pPdo == NULL) {
        status = STATUS_INVALID_DEVICE_REQUEST;
 
        DoTraceLevelMessage(pGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "WDFIOTARGET 0x%p has no PDO (not opened yet?), %!STATUS!",
                            IoTarget, status);
 
        return status;
    }
 
    status = FxDevice::_GetDeviceProperty(pPdo,
                                          DeviceProperty,
                                          BufferLength,
                                          PropertyBuffer,
                                          ResultLength);
 
    DoTraceLevelMessage(pGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "exit WDFIOTARGET 0x%p, Property %d, %!STATUS!",
                        IoTarget, DeviceProperty, status);
 
 
 
    return status;
}
 
_Must_inspect_result_
__drv_maxIRQL(PASSIVE_LEVEL)
WDFAPI
NTSTATUS
STDCALL
WDFEXPORT(WdfIoTargetAllocAndQueryTargetProperty)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    WDFIOTARGET IoTarget,
    __in
    DEVICE_REGISTRY_PROPERTY DeviceProperty,
    __in
    __drv_strictTypeMatch(1)
    POOL_TYPE PoolType,
    __in_opt
    PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes,
    __out
    WDFMEMORY*  PropertyMemory
    )
/*++
 
Routine Description:
    Allocates and retrieves the requested device property for the given target
 
Arguments:
    IoTarget - the target whose PDO whose will be queried
 
    DeviceProperty - the property being queried
 
    PoolType - what type of pool to allocate
 
    PropertyMemoryAttributes - attributes to associate with PropertyMemory
 
    PropertyMemory - handle which will receive the property buffer
 
Return Value:
    NTSTATUS
 
  --*/
{
    DDI_ENTRY();
 
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    NTSTATUS status;
    FxIoTarget* pTarget;
    MdDeviceObject pPdo;
 
    FxObjectHandleGetPtrAndGlobals(GetFxDriverGlobals(DriverGlobals),
                                   IoTarget,
                                   FX_TYPE_IO_TARGET,
                                   (PVOID*) &pTarget,
                                   &pFxDriverGlobals);
 
    FxPointerNotNull(pFxDriverGlobals, PropertyMemory);
 
    *PropertyMemory = NULL;
 
    status = FxVerifierCheckIrqlLevel(pFxDriverGlobals, PASSIVE_LEVEL);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    FxVerifierCheckNxPoolType(pFxDriverGlobals, PoolType, pFxDriverGlobals->Tag);
 
    status = FxValidateObjectAttributes(pFxDriverGlobals, PropertyMemoryAttributes);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    pPdo = pTarget->GetTargetPDO();
 
    if (pPdo == NULL) {
        status = STATUS_INVALID_DEVICE_REQUEST;
 
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                            "WDFIOTARGET %p has no PDO (not opened yet?), %!STATUS!",
                            IoTarget, status);
 
        return status;
    }
 
    //
    // Worker function which does the 2 passes.  First pass to query the size,
    // the second pass w/the correctly sized buffer.
    //
    status = FxDevice::_AllocAndQueryProperty(pFxDriverGlobals,
                                              NULL,
                                              NULL,
                                              pPdo,
                                              DeviceProperty,
                                              PoolType,
                                              PropertyMemoryAttributes,
                                              PropertyMemory);
 
    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                        "exit WDFIOTARGET 0x%p, Property %d, %!STATUS!",
                        IoTarget, DeviceProperty, status);
 
    return status;
}
 
}