fxdeviceapi.cpp File Reference

#include "coreprivshared.hpp"
#include "fxiotarget.hpp"

Include dependency graph for fxdeviceapi.cpp:

Go to the source code of this file.

Classes
struct	FxOffsetAndName

Macros
#define	OFFSET_AND_NAME(type, offset)   { #offset, FIELD_OFFSET(type, offset) }

Functions
	__drv_maxIRQL (DISPATCH_LEVEL) WDFDRIVER STDCALL WDFEXPORT(WdfDeviceGetDriver)(__in PWDF_DRIVER_GLOBALS DriverGlobals
	FxObjectHandleGetPtr (GetFxDriverGlobals(DriverGlobals), Device, FX_TYPE_DEVICE,(PVOID *) &pDevice)
return pDevice	GetDriver () -> GetHandle()
	FxObjectHandleGetPtr (GetFxDriverGlobals(DriverGlobals), Device, FX_TYPE_DEVICE_BASE,(PVOID *) &pDeviceBase)
	if (pTarget !=NULL)
	_IRQL_requires_max_ (DISPATCH_LEVEL) WDFIOTARGET STDCALL WDFEXPORT(WdfDeviceGetSelfIoTarget)(_In_ PWDF_DRIVER_GLOBALS DriverGlobals
_Must_inspect_result_	__drv_maxIRQL (PASSIVE_LEVEL) NTSTATUS STDCALL WDFEXPORT(WdfDeviceRetrieveDeviceName)(__in PWDF_DRIVER_GLOBALS DriverGlobals
	FxObjectHandleGetPtrAndGlobals (GetFxDriverGlobals(DriverGlobals), Device, FX_TYPE_DEVICE,(PVOID *) &pDevice, &pFxDriverGlobals)
	if (!NT_SUCCESS(status))
	FxObjectHandleGetPtr (pFxDriverGlobals, String, FX_TYPE_STRING,(PVOID *) &pString)
	if (pDevice->m_DeviceName.Buffer !=NULL)
	DoTraceLevelMessage (pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP, "Device name for WDFDEVICE 0x%p is NULL. Possibly incorrect " "device handle was passed, %!STATUS!", Device, status)
deviceObject	SetObject (pDevice->GetDeviceObject())
deviceObject	SetCharacteristics (DeviceCharacteristics|FILE_DEVICE_SECURE_OPEN)
return deviceObject	GetCharacteristics ()
deviceObject	SetObject (pDeviceBase->GetDeviceObject())
return deviceObject	GetAlignmentRequirement ()
deviceObject	SetAlignmentRequirement (AlignmentRequirement)
return pDevice	GetDevicePnpState ()
return pDevice	GetDevicePowerState ()
return pDevice	GetDevicePowerPolicyState ()
	FxPointerNotNull (pFxDriverGlobals, Settings)
	if (pDevice->m_PkgPnp->IsPowerPolicyOwner()==FALSE)
	if (Settings->Size !=sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS) &&Settings->Size !=sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_9) &&Settings->Size !=sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_7))
else	if (Settings->DxState< PowerDeviceD1||Settings->DxState > PowerDeviceMaximum||Settings->IdleCaps< IdleCannotWakeFromS0||Settings->IdleCaps > IdleUsbSelectiveSuspend||Settings->UserControlOfIdleSettings< IdleDoNotAllowUserControl||Settings->UserControlOfIdleSettings > IdleAllowUserControl||Settings->Enabled< WdfFalse||Settings->Enabled > WdfUseDefault)
	if (Settings->Size > sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_7))
	if (Settings->Size > sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_9))
return pDevice m_PkgPnp	PowerPolicySetS0IdleSettings (Settings)
else	if (Settings->DxState< PowerDeviceD1||Settings->DxState > PowerDeviceMaximum||Settings->UserControlOfWakeSettings< WakeDoNotAllowUserControl||Settings->UserControlOfWakeSettings > WakeAllowUserControl||Settings->Enabled< WdfFalse||Settings->Enabled > WdfUseDefault)
return pDevice m_PkgPnp	PowerPolicySetSxWakeSettings (Settings, armForWakeIfChildrenAreArmedForWake, indicateChildWakeOnParentWake)
	FxPointerNotNull (pFxDriverGlobals, Key)
_Must_inspect_result_	_IRQL_requires_max_ (PASSIVE_LEVEL) NTSTATUS STDCALL WDFEXPORT(WdfDeviceOpenDevicemapKey)(_In_ PWDF_DRIVER_GLOBALS DriverGlobals
	if (KeyName->Length==0)
	if (pKey==NULL)
pKey	SetDeviceBase (pDevice)
	if (NT_SUCCESS(status))
	FxPointerNotNull (pFxDriverGlobals, DeviceState)
	if (DeviceState->Size !=sizeof(WDF_DEVICE_STATE))
pDevice m_PkgPnp	GetPnpState (DeviceState)
	for (i=0;i< ARRAY_SIZE(offsets);i++)
pDevice m_PkgPnp	SetPnpState (DeviceState)
pDevice	InvalidateDeviceState ()
	FxPointerNotNull (pFxDriverGlobals, DeviceInit)
	FxPointerNotNull (pFxDriverGlobals, *DeviceInit)
	FxPointerNotNull (pFxDriverGlobals, Device)
	if ((*DeviceInit) ->CreatedDevice !=NULL)
	if ((*DeviceInit) ->Security.Sddl !=NULL||(*DeviceInit) ->Security.DeviceClassSet)
	if ((*DeviceInit) ->RequiresSelfIoTarget)
	FxPointerNotNull (pFxDriverGlobals, SymbolicLinkName)
	if (pDevice->m_SymbolicLinkName.Buffer !=NULL)
_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY __in ULONG	__out_bcount_full (BufferLength) PVOID PropertyBuffer
	FxPointerNotNull (pFxDriverGlobals, ResultLength)
	if (BufferLength > 0)
	if (pDevice->IsLegacy())
	DoTraceLevelMessage (pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDEVICE, "exit WDFDEVICE %p, Property %d, %!STATUS!", Device, DeviceProperty, status)
_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY __in	__drv_strictTypeMatch (__drv_typeExpr) POOL_TYPE PoolType
	FxPointerNotNull (pFxDriverGlobals, PropertyMemory)
	FxVerifierCheckNxPoolType (pFxDriverGlobals, PoolType, pFxDriverGlobals->Tag)
	if (Stoppable)
	if (FailedAction< WdfDeviceFailedAttemptRestart||FailedAction > WdfDeviceFailedNoRestart)
	DoTraceLevelMessage (pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGDEVICE, "WDFDEVICE %p, !devobj %p SetFailed %!WDF_DEVICE_FAILED_ACTION!", Device, pDevice->GetDeviceObject(), FailedAction)
pDevice m_PkgPnp	SetDeviceFailed (FailedAction)
__inline NTSTATUS	StopIdleWorker (__in PWDF_DRIVER_GLOBALS DriverGlobals, __in WDFDEVICE Device, __in BOOLEAN WaitForD0, __in PVOID Tag, __in LONG Line, __in PSTR File)
__inline VOID	ResumeIdleWorker (__in PWDF_DRIVER_GLOBALS DriverGlobals, __in WDFDEVICE Device, __in PVOID Tag, __in LONG Line, __in PSTR File)
_Must_inspect_result_	__drv_when (WaitForD0==0, __drv_maxIRQL(DISPATCH_LEVEL)) __drv_when(WaitForD0 !=0
	ResumeIdleWorker (DriverGlobals, Device, NULL, 0, NULL)
	ResumeIdleWorker (DriverGlobals, Device, Tag, Line, File)
	FxPointerNotNull (pFxDriverGlobals, PnpCapabilities)
	if (PnpCapabilities->Size !=sizeof(WDF_DEVICE_PNP_CAPABILITIES))
	FxPointerNotNull (pFxDriverGlobals, PowerCapabilities)
	if (PowerCapabilities->Size !=sizeof(WDF_DEVICE_POWER_CAPABILITIES))
_Must_inspect_result_ __in WDFDEVICE __in WDFQUEUE __in	__drv_strictTypeMatch (__drv_typeCond) WDF_REQUEST_TYPE RequestType)
	if (pFxIoQueue==NULL)
	return (WDFQUEUE) pFxIoQueue -> GetObjectHandle()
	FxObjectHandleGetPtr (pFxDriverGlobals, Device, FX_TYPE_DEVICE,(PVOID *) &pDevice)
	FxObjectHandleGetPtr (pFxDriverGlobals, Request, FX_TYPE_REQUEST,(PVOID *) &pRequest)
return pDevice m_PkgIo	EnqueueRequest (pDevice, pRequest)
return pDevice m_PkgPnp	GetSystemPowerAction ()
_Must_inspect_result_	_IRQL_requires_max_ (APC_LEVEL) WDFAPI NTSTATUS STDCALL WDFEXPORT(WdfDeviceQueryPropertyEx)(_In_ PWDF_DRIVER_GLOBALS DriverGlobals
	FxPointerNotNull (pFxDriverGlobals, DeviceProperty)
	if (DeviceProperty->Size !=sizeof(WDF_DEVICE_PROPERTY_DATA))
	FxPointerNotNull (pFxDriverGlobals, RequiredSize)
	FxPointerNotNull (pFxDriverGlobals, Type)
	if (BufferLength !=0 &&PropertyBuffer==NULL)
	if (BufferLength==0 &&PropertyBuffer !=NULL)
	switch (MajorFunction)
	if (Driver !=NULL)
	FxPointerNotNull (pFxDriverGlobals, EvtDeviceWdmIrpDispatch)
_Must_inspect_result_ NTSTATUS FX_VF_FUNCTION()	VerifyWdfDeviceWdmDispatchIrpToIoQueue (_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_ FxDevice *device, _In_ MdIrp Irp, _In_ FxIoQueue *queue, _In_ ULONG Flags)

Variables
__in WDFDEVICE	Device
FxDevice *	pDevice = NULL
FxIoTarget *	pTarget = pDeviceBase->GetDefaultIoTarget()
FxDeviceBase *	pDeviceBase
return	NULL
_Must_inspect_result_ __in WDFDEVICE __in WDFSTRING	String
PFX_DRIVER_GLOBALS	pFxDriverGlobals = GetFxDriverGlobals(DriverGlobals)
FxString *	pString
NTSTATUS	status = FxVerifierCheckIrqlLevel(pFxDriverGlobals, PASSIVE_LEVEL)
	else
__in WDFDEVICE __in ULONG	DeviceCharacteristics
MxDeviceObject	deviceObject
__in WDFDEVICE __in ULONG	AlignmentRequirement
_Must_inspect_result_ __in WDFDEVICE __in PWDF_DEVICE_POWER_POLICY_IDLE_SETTINGS	Settings
BOOLEAN	armForWakeIfChildrenAreArmedForWake
BOOLEAN	indicateChildWakeOnParentWake
_Must_inspect_result_ __in WDFDEVICE __in ULONG	DeviceInstanceKeyType
_Must_inspect_result_ __in WDFDEVICE __in ULONG __in ACCESS_MASK	DesiredAccess
_Must_inspect_result_ __in WDFDEVICE __in ULONG __in ACCESS_MASK __in_opt PWDF_OBJECT_ATTRIBUTES	KeyAttributes
_Must_inspect_result_ __in WDFDEVICE __in ULONG __in ACCESS_MASK __in_opt PWDF_OBJECT_ATTRIBUTES __out WDFKEY *	Key
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING	KeyName
FxRegKey *	pKey = NULL
WDFKEY	keyHandle
__in WDFDEVICE __out PWDF_DEVICE_STATE	DeviceState
ULONG	i
static const FxOffsetAndName	offsets []
_Must_inspect_result_ __inout PWDFDEVICE_INIT *	DeviceInit
_Must_inspect_result_ __inout PWDFDEVICE_INIT __in_opt PWDF_OBJECT_ATTRIBUTES	DeviceAttributes
_Must_inspect_result_ __in WDFDEVICE __in PCUNICODE_STRING	SymbolicLinkName
FxAutoString	pdoName
_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY	DeviceProperty
_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY __in ULONG	BufferLength
_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY __in ULONG __out PULONG	ResultLength
_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY __in __in_opt PWDF_OBJECT_ATTRIBUTES	PropertyMemoryAttributes
_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY __in __in_opt PWDF_OBJECT_ATTRIBUTES __out WDFMEMORY *	PropertyMemory
__in WDFDEVICE __in BOOLEAN	Stoppable
	return
__in WDFDEVICE __in WDF_DEVICE_FAILED_ACTION	FailedAction
_Must_inspect_result_ __in WDFDEVICE __in BOOLEAN	WaitForD0
_Must_inspect_result_ __in WDFDEVICE __in BOOLEAN __in_opt PVOID	Tag
_Must_inspect_result_ __in WDFDEVICE __in BOOLEAN __in_opt PVOID __in LONG	Line
_Must_inspect_result_ __in WDFDEVICE __in BOOLEAN __in_opt PVOID __in LONG __in PSTR	File
__in WDFDEVICE __in PWDF_DEVICE_PNP_CAPABILITIES	PnpCapabilities
__in WDFDEVICE __in PWDF_DEVICE_POWER_CAPABILITIES	PowerCapabilities
_Must_inspect_result_ __in WDFDEVICE __in WDFQUEUE	Queue
FxPkgIo *	pPkgIo = NULL
FxIoQueue *	pFxIoQueue = NULL
FxDevice *	pFxDevice
_Must_inspect_result_ __in WDFDEVICE __in WDFREQUEST	Request
FxRequest *	pRequest
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID	PropertyBuffer
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG	RequiredSize
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG _Out_ PDEVPROPTYPE	Type
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ _Strict_type_match_ POOL_TYPE	PoolType
_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ WDFDRIVER	Driver
_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ WDFDRIVER _In_ UCHAR	MajorFunction
_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ WDFDRIVER _In_ UCHAR _In_ PFN_WDFDEVICE_WDM_IRP_DISPATCH	EvtDeviceWdmIrpDispatch
_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ WDFDRIVER _In_ UCHAR _In_ PFN_WDFDEVICE_WDM_IRP_DISPATCH _In_opt_ WDFCONTEXT	DriverContext
FxCxDeviceInfo *	pCxDeviceInfo = NULL
ULONG	deviceFlags
exit	__pad5__

Macro Definition Documentation

OFFSET_AND_NAME

#define OFFSET_AND_NAME	(		type,
			offset
	)		{ #offset, FIELD_OFFSET(type, offset) }

Definition at line 37 of file fxdeviceapi.cpp.

Function Documentation

__drv_maxIRQL() [1/2]

__drv_maxIRQL

(

DISPATCH_LEVEL

)

__drv_maxIRQL() [2/2]

_Must_inspect_result_ __drv_maxIRQL

(

PASSIVE_LEVEL

)

__drv_strictTypeMatch() [1/2]

_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY __in __drv_strictTypeMatch

(

__drv_typeExpr

)

__drv_strictTypeMatch() [2/2]

_Must_inspect_result_ __in WDFDEVICE __in WDFQUEUE __in __drv_strictTypeMatch

(

__drv_typeCond

)

Definition at line 1773 of file fxdeviceapi.cpp.

{
    DDI_ENTRY();

    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    NTSTATUS  status;
    FxDevice*  pDevice;
    FxIoQueue* pFxIoQueue;

    pDevice = NULL;
    pFxIoQueue = NULL;

    FxObjectHandleGetPtrAndGlobals(GetFxDriverGlobals(DriverGlobals),
                                   Device,
                                   FX_TYPE_DEVICE,
                                   (PVOID *) &pDevice,
                                   &pFxDriverGlobals);

    if (RequestType != WdfRequestTypeCreate &&
        RequestType != WdfRequestTypeRead &&
        RequestType != WdfRequestTypeWrite &&
        RequestType != WdfRequestTypeDeviceControl &&
        RequestType != WdfRequestTypeDeviceControlInternal) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Invalid RequestType %!WDF_REQUEST_TYPE!, %!STATUS!",
                            RequestType, status);
        return status;
    }

    //
    // Validate the Queue handle
    //
    FxObjectHandleGetPtr(pFxDriverGlobals,
                         Queue,
                         FX_TYPE_QUEUE,
                         (PVOID*)&pFxIoQueue);

    if (pDevice != pFxIoQueue->GetDevice()) {
        status = STATUS_INVALID_DEVICE_REQUEST;

        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
            "Input WDFQUEUE 0x%p doesn't belong to the WDFDEVICE 0x%p, %!STATUS!",
            Queue, Device, status);

        return status;
    }

    if (pDevice->IsLegacy()) {
        //
        // This is a controldevice. Make sure the create is called after the device
        // is initialized and ready to accept I/O.
        //
        MxDeviceObject deviceObject(pDevice->GetDeviceObject());
        if ((deviceObject.GetFlags() & DO_DEVICE_INITIALIZING) == 0x0) {

            status = STATUS_INVALID_DEVICE_STATE;
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "Queue cannot be configured for automatic dispatching"
                " after WdfControlDeviceFinishInitializing"
                "is called on the WDFDEVICE %p is called %!STATUS!",
                Device,
                status);
            return status;
        }
    }
    else {
        //
        // This is either FDO or PDO. Make sure it's not started yet.
        //
        if (pDevice->GetDevicePnpState() != WdfDevStatePnpInit) {
            status = STATUS_INVALID_DEVICE_STATE;
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "Queue cannot be configured for automatic dispatching"
                "after the WDFDEVICE %p is started, %!STATUS!",
                Device, status);
            return status;
        }
    }

    if (RequestType == WdfRequestTypeCreate) {
        status = pDevice->m_PkgGeneral->ConfigureForwarding(pFxIoQueue);
    }
    else {
        status = pDevice->m_PkgIo->ConfigureForwarding(pFxIoQueue, RequestType);
    }

    return status;
}

__drv_when()

_Must_inspect_result_ __drv_when ( WaitForD0  = = 0, __drv_maxIRQL(DISPATCH_LEVEL)    )

pure virtual

__out_bcount_full()

_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY __in ULONG __out_bcount_full

(

BufferLength

)

_IRQL_requires_max_() [1/3]

_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Definition at line 3557 of file common.c.

{
    NTSTATUS                    status;
    BOOLEAN                     requestSent = FALSE;

    BOOLEAN                     shouldRetry = TRUE;
    PCDB                        cdb = (PCDB)DeviceExtension->PowerContext.Srb.Cdb;
    ULONG                       timeoutValue = DeviceExtension->TimeOutValue;
    ULONG                       retryCount = 1;

    // reset some fields.
    DeviceExtension->PowerContext.RetryIntervalIn100ns = 0;
    status = PowerContextReuseRequest(DeviceExtension);
    RequestClearSendTime(DeviceExtension->PowerContext.PowerRequest);

    if (!NT_SUCCESS(status))
    {
        return status;
    }

    // set proper timeout value and max retry count.
    switch(DeviceExtension->PowerContext.PowerChangeState.PowerDown)
    {
    case PowerDownDeviceInitial:
    case PowerDownDeviceQuiesced:
    case PowerDownDeviceStopped:
        break;

    case PowerDownDeviceLocked:
        // Case of issuing SYNC CACHE command. Do not use power irp timeout remaining time in this case
        // as we want to give best try on SYNC CACHE command.
        retryCount = MAXIMUM_RETRIES;
        timeoutValue = DeviceExtension->TimeOutValue;
        break;

    case PowerDownDeviceFlushed:
    {
        // Case of issuing STOP UNIT command
        // As "Imme" bit is set to '1', this command should be completed in short time.
        // This command is at low importance, failure of this command has very small impact.
        ULONG secondsRemaining = 0;

#if (WINVER >= 0x0601)
        // this API is introduced in Windows7
        PoQueryWatchdogTime(DeviceExtension->LowerPdo, &secondsRemaining);
#endif

        if (secondsRemaining == 0)
        {
            // not able to retrieve remaining time from PoQueryWatchdogTime API, use default values.
            retryCount = MAXIMUM_RETRIES;
            timeoutValue = SCSI_CDROM_TIMEOUT;
        }
        else
        {
            // plan to leave about 30 seconds to lower level drivers if possible.
            if (secondsRemaining >= 32)
            {
                retryCount = (secondsRemaining - 30)/SCSI_CDROM_TIMEOUT + 1;
                timeoutValue = SCSI_CDROM_TIMEOUT;

                if (retryCount > MAXIMUM_RETRIES)
                {
                    retryCount = MAXIMUM_RETRIES;
                }

                if (retryCount == 1)
                {
                    timeoutValue = secondsRemaining - 30;
                }
            }
            else
            {
                // issue the command with minimal timeout value and do not retry on it.
                retryCount = 1;
                timeoutValue = 2;
            }
        }
    }
        break;
    default:
        NT_ASSERT( FALSE );
        status = STATUS_NOT_IMPLEMENTED;
        return status;
    }

    DeviceExtension->PowerContext.RetryCount = retryCount;

    // issue command.
    while (shouldRetry)
    {

        // set SRB fields.
        DeviceExtension->PowerContext.Srb.SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
                                                     SRB_FLAGS_DISABLE_SYNCH_TRANSFER |
                                                     SRB_FLAGS_NO_QUEUE_FREEZE |
                                                     SRB_FLAGS_BYPASS_LOCKED_QUEUE |
                                                     SRB_FLAGS_D3_PROCESSING;

        DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
        DeviceExtension->PowerContext.Srb.TimeOutValue = timeoutValue;

        if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceInitial)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_LOCK_QUEUE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceLocked)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_QUIESCE_DEVICE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
        {
            // Case of issuing SYNC CACHE command.
            DeviceExtension->PowerContext.Srb.CdbLength = 10;
            cdb->SYNCHRONIZE_CACHE10.OperationCode = SCSIOP_SYNCHRONIZE_CACHE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceFlushed)
        {
            // Case of issuing STOP UNIT command.
            DeviceExtension->PowerContext.Srb.CdbLength = 6;
            cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
            cdb->START_STOP.Start = 0;
            cdb->START_STOP.Immediate = 1;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceStopped)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_UNLOCK_QUEUE;
        }

        // Set up completion routine and context if requested
        if (CompletionRoutine)
        {
            WdfRequestSetCompletionRoutine(DeviceExtension->PowerContext.PowerRequest,
                                           CompletionRoutine,
                                           Context);
        }

        status = RequestSend(DeviceExtension,
                             DeviceExtension->PowerContext.PowerRequest,
                             DeviceExtension->IoTarget,
                             CompletionRoutine ? 0 : WDF_REQUEST_SEND_OPTION_SYNCHRONOUS,
                             &requestSent);

        if (requestSent)
        {
            if ((CompletionRoutine == NULL) &&
                (SRB_STATUS(DeviceExtension->PowerContext.Srb.SrbStatus) != SRB_STATUS_SUCCESS))
            {
                TracePrint((TRACE_LEVEL_ERROR,
                            TRACE_FLAG_POWER,
                            "%p\tError occured when issuing %s command to device. Srb %p, Status %x\n",
                            DeviceExtension->PowerContext.PowerRequest,
                            (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced) ? "SYNC CACHE" : "STOP UNIT",
                            &DeviceExtension->PowerContext.Srb,
                            DeviceExtension->PowerContext.Srb.SrbStatus));

                NT_ASSERT(!(TEST_FLAG(DeviceExtension->PowerContext.Srb.SrbStatus, SRB_STATUS_QUEUE_FROZEN)));

                shouldRetry = RequestSenseInfoInterpret(DeviceExtension,
                                                        DeviceExtension->PowerContext.PowerRequest,
                                                        &(DeviceExtension->PowerContext.Srb),
                                                        retryCount - DeviceExtension->PowerContext.RetryCount,
                                                        &status,
                                                        &(DeviceExtension->PowerContext.RetryIntervalIn100ns));

                if (shouldRetry && (DeviceExtension->PowerContext.RetryCount-- == 0))
                {
                    shouldRetry = FALSE;
                }
            }
            else
            {
                // succeeded, do not need to retry.
                shouldRetry = FALSE;
            }

        }
        else
        {
            // request failed to be sent
            shouldRetry = FALSE;
        }

        if (shouldRetry)
        {
            LARGE_INTEGER t;
            t.QuadPart = -DeviceExtension->PowerContext.RetryIntervalIn100ns;
            KeDelayExecutionThread(KernelMode, FALSE, &t);

            status = PowerContextReuseRequest(DeviceExtension);
            if (!NT_SUCCESS(status))
            {
                shouldRetry = FALSE;
            }
        }
    }

    if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
    {
        // record SYNC CACHE command completion time stamp.
        KeQueryTickCount(&DeviceExtension->PowerContext.Step1CompleteTime);
    }

    return status;
}

_IRQL_requires_max_() [2/3]

_Must_inspect_result_ _IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 64 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT PortObject;
    NTSTATUS Status;

    /* The caller must allow at least one connection */
    if (MaxConnections == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }

    /* The request must be for a kernel handle */
    if (!(ObjectAttributes->Attributes & OBJ_KERNEL_HANDLE))
    {
        return STATUS_INVALID_PARAMETER;
    }

    /*
     * Get rundown protection on the target to stop the owner
     * from unloading whilst this port object is open. It gets
     * removed in the FltpServerPortClose callback
     */
    Status = FltObjectReference(Filter);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }

    /* Create the server port object for this filter */
    Status = ObCreateObject(KernelMode,
                            ServerPortObjectType,
                            ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(FLT_SERVER_PORT_OBJECT),
                            0,
                            0,
                            (PVOID *)&PortObject);
    if (NT_SUCCESS(Status))
    {
        /* Zero out the struct */
        RtlZeroMemory(PortObject, sizeof(FLT_SERVER_PORT_OBJECT));

        /* Increment the ref count on the target filter */
        FltpObjectPointerReference((PFLT_OBJECT)Filter);

        /* Setup the filter port object */
        PortObject->Filter = Filter;
        PortObject->ConnectNotify = ConnectNotifyCallback;
        PortObject->DisconnectNotify = DisconnectNotifyCallback;
        PortObject->MessageNotify = MessageNotifyCallback;
        PortObject->Cookie = ServerPortCookie;
        PortObject->MaxConnections = MaxConnections;

        /* Insert the object */
        Status = ObInsertObject(PortObject,
                                NULL,
                                STANDARD_RIGHTS_ALL | FILE_READ_DATA,
                                0,
                                NULL,
                                (PHANDLE)ServerPort);
        if (NT_SUCCESS(Status))
        {
            /* Lock the connection list */
            ExAcquireFastMutex(&Filter->ConnectionList.mLock);

            /* Add the new port object to the connection list and increment the count */
            InsertTailList(&Filter->ConnectionList.mList, &PortObject->FilterLink);
            Filter->ConnectionList.mCount++;

            /* Unlock the connection list*/
            ExReleaseFastMutex(&Filter->ConnectionList.mLock);
        }
    }

    if (!NT_SUCCESS(Status))
    {
        /* Allow the filter to be cleaned up */
        FltObjectDereference(Filter);
    }

    return Status;
}

_IRQL_requires_max_() [3/3]

_Must_inspect_result_ _IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 197 of file cddata.c.

{
    THREAD_CONTEXT ThreadContext = {0};
    PIRP_CONTEXT IrpContext = NULL;
    BOOLEAN Wait;

#ifdef CD_SANITY
    PVOID PreviousTopLevel;
#endif

    NTSTATUS Status;

#if DBG

    KIRQL SaveIrql = KeGetCurrentIrql();

#endif

    ASSERT_OPTIONAL_IRP( Irp );

    UNREFERENCED_PARAMETER( DeviceObject );

    FsRtlEnterFileSystem();

#ifdef CD_SANITY
    PreviousTopLevel = IoGetTopLevelIrp();
#endif

    //
    //  Loop until this request has been completed or posted.
    //

    do {

        //
        //  Use a try-except to handle the exception cases.
        //

        _SEH2_TRY {

            //
            //  If the IrpContext is NULL then this is the first pass through
            //  this loop.
            //

            if (IrpContext == NULL) {

                //
                //  Decide if this request is waitable an allocate the IrpContext.
                //  If the file object in the stack location is NULL then this
                //  is a mount which is always waitable.  Otherwise we look at
                //  the file object flags.
                //

                if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {

                    Wait = TRUE;

                } else {

                    Wait = CanFsdWait( Irp );
                }

                IrpContext = CdCreateIrpContext( Irp, Wait );

                //
                //  Update the thread context information.
                //

                CdSetThreadContext( IrpContext, &ThreadContext );

#ifdef CD_SANITY
                NT_ASSERT( !CdTestTopLevel ||
                        SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT );
#endif

            //
            //  Otherwise cleanup the IrpContext for the retry.
            //

            } else {

                //
                //  Set the MORE_PROCESSING flag to make sure the IrpContext
                //  isn't inadvertently deleted here.  Then cleanup the
                //  IrpContext to perform the retry.
                //

                SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
                CdCleanupIrpContext( IrpContext, FALSE );
            }

            //
            //  Case on the major irp code.
            //

            switch (IrpContext->MajorFunction) {

            case IRP_MJ_CREATE :

                Status = CdCommonCreate( IrpContext, Irp );
                break;

            case IRP_MJ_CLOSE :

                Status = CdCommonClose( IrpContext, Irp );
                break;

            case IRP_MJ_READ :

                //
                //  If this is an Mdl complete request, don't go through
                //  common read.
                //

                if (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE )) {

                    Status = CdCompleteMdl( IrpContext, Irp );

                } else {

                    Status = CdCommonRead( IrpContext, Irp );
                }

                break;

            case IRP_MJ_WRITE :

                Status = CdCommonWrite( IrpContext, Irp );
                break;

            case IRP_MJ_QUERY_INFORMATION :

                Status = CdCommonQueryInfo( IrpContext, Irp );
                break;

            case IRP_MJ_SET_INFORMATION :

                Status = CdCommonSetInfo( IrpContext, Irp );
                break;

            case IRP_MJ_QUERY_VOLUME_INFORMATION :

                Status = CdCommonQueryVolInfo( IrpContext, Irp );
                break;

            case IRP_MJ_DIRECTORY_CONTROL :

                Status = CdCommonDirControl( IrpContext, Irp );
                break;

            case IRP_MJ_FILE_SYSTEM_CONTROL :

                Status = CdCommonFsControl( IrpContext, Irp );
                break;

            case IRP_MJ_DEVICE_CONTROL :

                Status = CdCommonDevControl( IrpContext, Irp );
                break;

            case IRP_MJ_LOCK_CONTROL :

                Status = CdCommonLockControl( IrpContext, Irp );
                break;

            case IRP_MJ_CLEANUP :

                Status = CdCommonCleanup( IrpContext, Irp );
                break;

            case IRP_MJ_PNP :

                Status = CdCommonPnp( IrpContext, Irp );
                break;

            case IRP_MJ_SHUTDOWN :
            
                Status = CdCommonShutdown( IrpContext, Irp );
                break;

            default :

                Status = STATUS_INVALID_DEVICE_REQUEST;
                CdCompleteRequest( IrpContext, Irp, Status );
            }

        } _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {

            Status = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
        } _SEH2_END;

    } while (Status == STATUS_CANT_WAIT);

#ifdef CD_SANITY
    NT_ASSERT( !CdTestTopLevel ||
            (PreviousTopLevel == IoGetTopLevelIrp()) );
#endif

    FsRtlExitFileSystem();

    NT_ASSERT( SaveIrql == KeGetCurrentIrql( ));

    return Status;
}

DoTraceLevelMessage() [1/3]

DoTraceLevelMessage	(	pFxDriverGlobals	,
		TRACE_LEVEL_ERROR	,
		TRACINGPNP	,
		"Device name for WDFDEVICE 0x%p is NULL. Possibly incorrect " "device handle was	passed,
		%!STATUS!"	,
		Device	,
		status
	)

Referenced by __drv_strictTypeMatch(), if(), ResumeIdleWorker(), StopIdleWorker(), switch(), and VerifyWdfDeviceWdmDispatchIrpToIoQueue().

DoTraceLevelMessage() [2/3]

DoTraceLevelMessage	(	pFxDriverGlobals	,
		TRACE_LEVEL_VERBOSE	,
		TRACINGDEVICE	,
		"exit WDFDEVICE %	p,
		Property %	d,
		%!STATUS!"	,
		Device	,
		DeviceProperty	,
		status
	)

DoTraceLevelMessage() [3/3]

DoTraceLevelMessage	(	pFxDriverGlobals	,
		TRACE_LEVEL_INFORMATION	,
		TRACINGDEVICE	,
		"WDFDEVICE %	p,
		!devobj %p SetFailed %!WDF_DEVICE_FAILED_ACTION!"	,
		Device	,
		pDevice->	GetDeviceObject(),
		FailedAction
	)

EnqueueRequest()

return pDevice m_PkgIo EnqueueRequest	(	pDevice	,
		pRequest
	)

for()

for

(

)

Definition at line 827 of file fxdeviceapi.cpp.

                                              {
        WDF_TRI_STATE value;

        //
        // This check makes prefast happy
        //
        if (offsets[i].Offset + sizeof(WDF_TRI_STATE) > sizeof(*DeviceState)) {
            return;
        }

        value = *(WDF_TRI_STATE*) WDF_PTR_ADD_OFFSET(DeviceState,
                                                     offsets[i].Offset);

        switch (value) {
        case WdfFalse:
        case WdfTrue:
        case WdfUseDefault:
            break;

        default:
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE 0x%p DeviceState WDF_TRI_STATE %s value out of range, "
                "value is %d", Device, offsets[i].Name, value);
            FxVerifierDbgBreakPoint(pFxDriverGlobals);

            return; // STATUS_INVALID_PARAMETER
        }
    }

FxObjectHandleGetPtr() [1/5]

FxObjectHandleGetPtr	(	GetFxDriverGlobals(DriverGlobals)	,
		Device	,
		FX_TYPE_DEVICE	,
		(PVOID *) &	pDevice
	)

Referenced by __drv_strictTypeMatch(), and if().

FxObjectHandleGetPtr() [2/5]

FxObjectHandleGetPtr	(	GetFxDriverGlobals(DriverGlobals)	,
		Device	,
		FX_TYPE_DEVICE_BASE	,
		(PVOID *) &	pDeviceBase
	)

FxObjectHandleGetPtr() [3/5]

FxObjectHandleGetPtr	(	pFxDriverGlobals	,
		String	,
		FX_TYPE_STRING	,
		(PVOID *) &	pString
	)

FxObjectHandleGetPtr() [4/5]

FxObjectHandleGetPtr	(	pFxDriverGlobals	,
		Device	,
		FX_TYPE_DEVICE	,
		(PVOID *) &	pDevice
	)

FxObjectHandleGetPtr() [5/5]

FxObjectHandleGetPtr	(	pFxDriverGlobals	,
		Request	,
		FX_TYPE_REQUEST	,
		(PVOID *) &	pRequest
	)

FxObjectHandleGetPtrAndGlobals()

FxObjectHandleGetPtrAndGlobals	(	GetFxDriverGlobals(DriverGlobals)	,
		Device	,
		FX_TYPE_DEVICE	,
		(PVOID *) &	pDevice,
		&	pFxDriverGlobals
	)

Referenced by __drv_strictTypeMatch(), ResumeIdleWorker(), and StopIdleWorker().

FxPointerNotNull() [1/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		Settings
	)

Referenced by if().

FxPointerNotNull() [2/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		Key
	)

FxPointerNotNull() [3/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		DeviceState
	)

FxPointerNotNull() [4/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		DeviceInit
	)

FxPointerNotNull() [5/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		*	DeviceInit
	)

FxPointerNotNull() [6/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		Device
	)

FxPointerNotNull() [7/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		SymbolicLinkName
	)

FxPointerNotNull() [8/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		ResultLength
	)

FxPointerNotNull() [9/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		PropertyMemory
	)

FxPointerNotNull() [10/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		PnpCapabilities
	)

FxPointerNotNull() [11/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		PowerCapabilities
	)

FxPointerNotNull() [12/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		DeviceProperty
	)

FxPointerNotNull() [13/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		RequiredSize
	)

FxPointerNotNull() [14/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		Type
	)

FxPointerNotNull() [15/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		EvtDeviceWdmIrpDispatch
	)

FxVerifierCheckNxPoolType()

FxVerifierCheckNxPoolType	(	pFxDriverGlobals	,
		PoolType	,
		pFxDriverGlobals->	Tag
	)

GetAlignmentRequirement()

return deviceObject GetAlignmentRequirement

(

)

GetCharacteristics()

return deviceObject GetCharacteristics

(

)

Referenced by DECLARE_INTERFACE_().

GetDevicePnpState()

return pDevice GetDevicePnpState

(

)

GetDevicePowerPolicyState()

return pDevice GetDevicePowerPolicyState

(

)

GetDevicePowerState()

return pDevice GetDevicePowerState

(

)

GetDriver()

return pDevice GetDriver

(

)

-> GetHandle()

GetPnpState()

pDevice m_PkgPnp GetPnpState

(

DeviceState

)

GetSystemPowerAction()

return pDevice m_PkgPnp GetSystemPowerAction

(

)

if() [1/28]

if

(

pTarget !

= NULL

)

Definition at line 107 of file fxdeviceapi.cpp.

                         {
        return pTarget->GetHandle();
    }

if() [2/28]

if

(

!

NT_SUCCESSstatus

)

Definition at line 190 of file fxdeviceapi.cpp.

                             {
        return status;
    }

if() [3/28]

if

(

pDevice->m_DeviceName.Buffer !

= NULL

)

Definition at line 199 of file fxdeviceapi.cpp.

                                              {
        status = pString->Assign(&pDevice->m_DeviceName);
    }

if() [4/28]

if

(

pDevice->m_PkgPnp->

IsPowerPolicyOwner() = = FALSE

)

Definition at line 410 of file fxdeviceapi.cpp.

                                                          {
        status = STATUS_INVALID_DEVICE_REQUEST;

        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
            "Device 0x%p is not the power policy owner, caller cannot set S0"
            " idle settings %!STATUS!", Device, status);

        return status;
    }

if() [5/28]

if

(

Settings->Size !

= sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS) && Settings->Size != sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_9) && Settings->Size != sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_7)

)

Definition at line 424 of file fxdeviceapi.cpp.

                                                                              {
        status = STATUS_INFO_LENGTH_MISMATCH;
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "Expected Settings Size %d, got %d, %!STATUS!",
            sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS), Settings->Size,
            status);
        return status;
    }

if() [6/28]

else if	(	Settings->DxState< PowerDeviceD1||Settings->	DxState,
		PowerDeviceMaximum||Settings->IdleCaps< IdleCannotWakeFromS0||Settings->	IdleCaps,
		IdleUsbSelectiveSuspend||Settings->UserControlOfIdleSettings< IdleDoNotAllowUserControl||Settings->	UserControlOfIdleSettings,
		IdleAllowUserControl||Settings->Enabled< WdfFalse||Settings->	Enabled,
		WdfUseDefault
	)

Definition at line 435 of file fxdeviceapi.cpp.

                                                {

        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "a field (DxState, IdleCaps, Enabled, or UserControlOfIdleSettings)"
            " is out range, %!STATUS!", status);
        return status;
    }

if() [7/28]

if	(	Settings->	Size,
		sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_7)
	)

Definition at line 456 of file fxdeviceapi.cpp.

                                                                             {
        if (Settings->PowerUpIdleDeviceOnSystemWake < WdfFalse ||
            Settings->PowerUpIdleDeviceOnSystemWake > WdfUseDefault) {

            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "value of field PowerUpIdleDeviceOnSystemWake is out of range,"
                " %!STATUS!", status);
            return status;
        }
        else if (Settings->IdleCaps != IdleCannotWakeFromS0 &&
            Settings->PowerUpIdleDeviceOnSystemWake != WdfUseDefault) {

            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "value of field PowerUpIdleDeviceOnSystemWake should be set only when"
                " IdleCaps is IdleCannotWakeFromS0, %!STATUS!", status);
            return status;
        }
    }

if() [8/28]

if	(	Settings->	Size,
		sizeof(WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_V1_9)
	)

Definition at line 482 of file fxdeviceapi.cpp.

                                                                             {
        if (Settings->IdleTimeoutType > SystemManagedIdleTimeoutWithHint) {
            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WDFDEVICE %p, value of field IdleTimeoutType is out of range,"
                " %!STATUS!", Device, status);
            return status;
        }
    }

if() [9/28]

else if	(	Settings->DxState< PowerDeviceD1||Settings->	DxState,
		PowerDeviceMaximum||Settings->UserControlOfWakeSettings< WakeDoNotAllowUserControl||Settings->	UserControlOfWakeSettings,
		WakeAllowUserControl||Settings->Enabled< WdfFalse||Settings->	Enabled,
		WdfUseDefault
	)

Definition at line 549 of file fxdeviceapi.cpp.

                                                {

        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "a field (DxState, Enabled, or UserControlOfIdleSettings) is out "
            "range, %!STATUS!", status);
        return status;
    }

if() [10/28]

if

(

KeyName->

Length = = 0

)

Definition at line 691 of file fxdeviceapi.cpp.

                              {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "The subkey cannot be of length zero, %!STATUS!", status);
        return status;
    }

if() [11/28]

if

(

pKey

= = NULL

)

Definition at line 713 of file fxdeviceapi.cpp.

                      {
        status = STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "Unable to allocate memory for WDFKEY object, %!STATUS!", status);
            return status;
    }

if() [12/28]

if

(

NT_SUCCESS(status)

)

Definition at line 724 of file fxdeviceapi.cpp.

                            {

        status = pDevice->OpenDevicemapKeyWorker(pFxDriverGlobals,
                                                 KeyName,
                                                 DesiredAccess,
                                                 pKey);
        if (NT_SUCCESS(status)) {
            *Key = keyHandle;
        }
    }

if() [13/28]

if

(

DeviceState->Size !

= sizeof(WDF_DEVICE_STATE)

)

Definition at line 768 of file fxdeviceapi.cpp.

                                                       {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WDFDEVICE 0x%p DeviceState Size %d, expected %d",
            Device, DeviceState->Size, sizeof(WDF_DEVICE_STATE));

        FxVerifierDbgBreakPoint(pFxDriverGlobals);

        return; // STATUS_INFO_LENGTH_MISMATCH;
    }

if() [14/28]

if

(

*DeviceInit->CreatedDevice !

= NULL

)

Definition at line 918 of file fxdeviceapi.cpp.

                                              {
        //
        // Already created the device!
        //
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "WDFDEVICE 0x%p   already created"
                            "STATUS_INVALID_DEVICE_STATE",
                            Device);

        return STATUS_INVALID_DEVICE_STATE;
    }

if() [15/28]

if

(

*DeviceInit->Security.Sddl !

= NULL || (*DeviceInit)->Security.DeviceClassSet

)

Definition at line 934 of file fxdeviceapi.cpp.

                                                                                        {
        if ((*DeviceInit)->HasName()) {
            //
            // Driver writer specified a name, all is good
            //
            DO_NOTHING();
        }
        else {
            status = STATUS_INVALID_SECURITY_DESCR;

            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "Device init: has device class or SDDL set, but does not have "
                "a name, %!STATUS!", status);

            return status;
        }
    }

if() [16/28]

if

(

*DeviceInit->

RequiresSelfIoTarget

)

Definition at line 953 of file fxdeviceapi.cpp.

                                             {
        if ((*DeviceInit)->InitType != FxDeviceInitTypeFdo) {
            status = STATUS_INVALID_DEVICE_REQUEST;
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "Client called WdfDeviceInitAllowSelfTarget. Self "
                "IO Targets are supported only for FDOs, %!STATUS!", status);
            return status;
        }
    }

if() [17/28]

if

(

pDevice->m_SymbolicLinkName.Buffer !

= NULL

)

Definition at line 1023 of file fxdeviceapi.cpp.

                                                    {
        status = STATUS_INVALID_DEVICE_REQUEST;

        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WDFDEVICE %p already has a symbolic link associated with it, %!STATUS!",
            Device, status);

        return status;
    }

if() [18/28]

if	(	BufferLength	,
		0
	)

Definition at line 1092 of file fxdeviceapi.cpp.

                          {
        FxPointerNotNull(pFxDriverGlobals, PropertyBuffer);
    }

if() [19/28]

if

(

pDevice->

IsLegacy()

)

Definition at line 1101 of file fxdeviceapi.cpp.

                             {
        status = STATUS_INVALID_DEVICE_REQUEST;

        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "WDFDEVICE 0x%p is not a PnP device %!STATUS!",
                            Device, status);

        return status;
    }

if() [20/28]

if

(

Stoppable

)

Definition at line 1242 of file fxdeviceapi.cpp.

                   {
        //
        // Stoppable means that query stop / query remove can succeed.
        // This means m_DeviceStopCount == 0 (eventually if there are nested
        // calls to this function).
        //
        ASSERT(pDevice->m_PkgPnp->m_DeviceStopCount > 0);
        InterlockedDecrement((PLONG) &pDevice->m_PkgPnp->m_DeviceStopCount);
    }

if() [21/28]

if

(

FailedAction< WdfDeviceFailedAttemptRestart||FailedAction >

WdfDeviceFailedNoRestart

)

Definition at line 1281 of file fxdeviceapi.cpp.

                                                 {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "Invalid FailedAction %d", FailedAction);
        FxVerifierDbgBreakPoint(pDevice->GetDriverGlobals());
        return;
    }

if() [22/28]

if

(

PnpCapabilities->Size !

= sizeof(WDF_DEVICE_PNP_CAPABILITIES)

)

Definition at line 1548 of file fxdeviceapi.cpp.

                                                                      {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WDFDEVICE 0x%p PnpCapabilities Size %d, expected %d",
            Device, PnpCapabilities->Size, sizeof(WDF_DEVICE_PNP_CAPABILITIES));
        FxVerifierDbgBreakPoint(pFxDriverGlobals);

        return; // STATUS_INFO_LENGTH_MISMATCH;
    }

if() [23/28]

if

(

PowerCapabilities->Size !

= sizeof(WDF_DEVICE_POWER_CAPABILITIES)

)

Definition at line 1643 of file fxdeviceapi.cpp.

                                                                          {

        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WDFDEVICE 0x%p PowerCapabilities Size %d, expected %d",
            Device, PowerCapabilities->Size,
            sizeof(WDF_DEVICE_POWER_CAPABILITIES));

        FxVerifierDbgBreakPoint(pFxDriverGlobals);

        return; // STATUS_INFO_LENGTH_MISMATCH;
    }

if() [24/28]

if

(

pFxIoQueue

= = NULL

)

Definition at line 1946 of file fxdeviceapi.cpp.

                            {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_WARNING, TRACINGIO,
                            "No default Queue configured "
                            "for Device 0x%p", Device);
        return NULL;
    }

if() [25/28]

if

(

DeviceProperty->Size !

= sizeof(WDF_DEVICE_PROPERTY_DATA)

)

Definition at line 2171 of file fxdeviceapi.cpp.

                                                                  {
        status = STATUS_INFO_LENGTH_MISMATCH;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                     "PropertyData size (%d) incorrect, expected %d, %!STATUS!",
                     DeviceProperty->Size,
                     sizeof(WDF_DEVICE_PROPERTY_DATA), status);
        return status;
    }

if() [26/28]

if

(

BufferLength !

= 0 && PropertyBuffer == NULL

)

Definition at line 2189 of file fxdeviceapi.cpp.

                                                     {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "Property buffer size is non-zero, while the buffer is NULL"
                    ", %!STATUS!", status);
        return status;
    }

if() [27/28]

if

(

BufferLength

= = 0 && PropertyBuffer != NULL

)

Definition at line 2197 of file fxdeviceapi.cpp.

                                                     {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "Property buffer size is zero, while the buffer is non-NULL"
                    ", %!STATUS!", status);
        return status;
    }

if() [28/28]

if

(

Driver !

= NULL

)

Definition at line 2532 of file fxdeviceapi.cpp.

                        {
        FxDriver*   pDriver;

        FxObjectHandleGetPtr(pFxDriverGlobals,
                             Driver,
                             FX_TYPE_DRIVER,
                             (PVOID*)&pDriver);

        //
        // Find the driver's cx info if it's not the main driver for this device.
        // cx struct info can be NULL if cx acts as client driver.
        //
        pCxDeviceInfo = pDevice->GetCxDeviceInfo(pDriver);
    }

InvalidateDeviceState()

pDevice InvalidateDeviceState

(

)

PowerPolicySetS0IdleSettings()

return pDevice m_PkgPnp PowerPolicySetS0IdleSettings

(

Settings

)

PowerPolicySetSxWakeSettings()

return pDevice m_PkgPnp PowerPolicySetSxWakeSettings	(	Settings	,
		armForWakeIfChildrenAreArmedForWake	,
		indicateChildWakeOnParentWake
	)

ResumeIdleWorker() [1/3]

__inline VOID ResumeIdleWorker	(	__in PWDF_DRIVER_GLOBALS	DriverGlobals,
		__in WDFDEVICE	Device,
		__in PVOID	Tag,
		__in LONG	Line,
		__in PSTR	File
	)

Definition at line 1355 of file fxdeviceapi.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxDevice *pDevice;

    FxObjectHandleGetPtrAndGlobals(GetFxDriverGlobals(DriverGlobals),
                                   Device,
                                   FX_TYPE_DEVICE,
                                   (PVOID *) &pDevice,
                                   &pFxDriverGlobals);

    if (pDevice->m_PkgPnp->IsPowerPolicyOwner() == FALSE) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WdfDeviceResumeIdle does nothing if you are not the power "
            "policy owner for the stack");
        return;
    }

    pDevice->m_PkgPnp->PowerDereference(Tag, Line, File);
}

ResumeIdleWorker() [2/3]

ResumeIdleWorker	(	DriverGlobals	,
		Device	,
		NULL	,
		0	,
		NULL
	)

ResumeIdleWorker() [3/3]

ResumeIdleWorker	(	DriverGlobals	,
		Device	,
		Tag	,
		Line	,
		File
	)

return()

return

(

WDFQUEUE

)

-> GetObjectHandle()

SetAlignmentRequirement()

deviceObject SetAlignmentRequirement

(

AlignmentRequirement

)

SetCharacteristics()

deviceObject SetCharacteristics

(

DeviceCharacteristics|

FILE_DEVICE_SECURE_OPEN

)

SetDeviceBase()

pKey SetDeviceBase

(

pDevice

)

SetDeviceFailed()

pDevice m_PkgPnp SetDeviceFailed

(

FailedAction

)

SetObject() [1/2]

deviceObject SetObject

(

pDevice->

GetDeviceObject()

)

SetObject() [2/2]

deviceObject SetObject

(

pDeviceBase->

GetDeviceObject()

)

SetPnpState()

pDevice m_PkgPnp SetPnpState

(

DeviceState

)

StopIdleWorker()

__inline NTSTATUS StopIdleWorker	(	__in PWDF_DRIVER_GLOBALS	DriverGlobals,
		__in WDFDEVICE	Device,
		__in BOOLEAN	WaitForD0,
		__in PVOID	Tag,
		__in LONG	Line,
		__in PSTR	File
	)

Definition at line 1300 of file fxdeviceapi.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    NTSTATUS status;
    FxDevice *pDevice;

    FxObjectHandleGetPtrAndGlobals(GetFxDriverGlobals(DriverGlobals),
                                   Device,
                                   FX_TYPE_DEVICE,
                                   (PVOID *) &pDevice,
                                   &pFxDriverGlobals);

    if (WaitForD0) {
        status = FxVerifierCheckIrqlLevel(pFxDriverGlobals,
                                          PASSIVE_LEVEL);
        if (!NT_SUCCESS(status)) {
            return status;
        }
    }


    if (pDevice->m_PkgPnp->IsPowerPolicyOwner() == FALSE) {
        status = STATUS_INVALID_DEVICE_STATE;
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WDFDEVICE %p WdfDeviceStopIdle does nothing if you are not the power "
            "policy owner for the stack, %!STATUS!", Device, status);
        return status;
    }

    status = pDevice->m_PkgPnp->PowerReference(WaitForD0, Tag, Line, File);

    DoTraceLevelMessage(
        pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDEVICE,
        "WDFDEVICE %p WdfDeviceStopIdle, WaitForD0 %d %!STATUS!",
        Device, WaitForD0, status);

    return status;
}

switch()

switch

(

MajorFunction

)

Definition at line 2512 of file fxdeviceapi.cpp.

                           {
        case IRP_MJ_WRITE:
        case IRP_MJ_READ:
        case IRP_MJ_DEVICE_CONTROL:
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        case IRP_MJ_INTERNAL_DEVICE_CONTROL:
#endif
            break;
        default:
            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "Invalid MajorFunction provided %!IRPMJ!, %!STATUS!",
                MajorFunction, status);
            goto exit;
    }

VerifyWdfDeviceWdmDispatchIrpToIoQueue()

_Must_inspect_result_ NTSTATUS FX_VF_FUNCTION() VerifyWdfDeviceWdmDispatchIrpToIoQueue	(	_In_ PFX_DRIVER_GLOBALS	FxDriverGlobals,
		_In_ FxDevice *	device,
		_In_ MdIrp	Irp,
		_In_ FxIoQueue *	queue,
		_In_ ULONG	Flags
	)

Definition at line 2608 of file fxdeviceapi.cpp.

{
    NTSTATUS status = STATUS_SUCCESS;
    UCHAR majorFunction, minorFunction;
    FxIrp fxIrp(Irp);

    PAGED_CODE_LOCKED();

    majorFunction = fxIrp.GetMajorFunction();
    minorFunction = fxIrp.GetMinorFunction();

    DoTraceLevelMessage(
        FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
        "WDFDEVICE 0x%p !devobj 0x%p %!IRPMJ!, IRP_MN %x, IRP 0x%p",
        device->GetHandle(), device->GetDeviceObject(),
        majorFunction, minorFunction, Irp);

    //
    // Validate Flags. For UMDF, this field is reserved and must be zero.
    //
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    if (Flags & ~FX_DISPATCH_IRP_TO_IO_QUEUE_FLAGS_MASK) {
#else
    if (Flags != WDF_DISPATCH_IRP_TO_IO_QUEUE_NO_FLAGS) {
#endif
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                "Flags 0x%x are invalid, %!STATUS!",
                Flags, status);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        goto Done;
    }

    //
    // Only read/writes/ctrls/internal_ctrls IRPs are allowed, i.e., the I/O request set.
    //
    if (device->GetDispatchPackage(majorFunction) != device->m_PkgIo) {
        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                "Only Read/Write/Control/Internal-Control IRPs can be "
                "forwarded to I/O Queue 0x%p, Irp 0x%p, %!IRPMJ!, "
                "IRP_MN %x, Device 0x%p, %!STATUS!",
                 queue->GetHandle(), Irp, majorFunction, minorFunction,
                 device->GetObjectHandle(), status);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        goto Done;
    }

    //
    // Make sure queue can handle the request.
    //
    if (FALSE == queue->IsIoEventHandlerRegistered(
                            (WDF_REQUEST_TYPE)majorFunction)) {

        status = STATUS_INVALID_PARAMETER;
        DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                "I/O Queue 0x%p cannot handle Irp 0x%p, %!IRPMJ!, "
                "IRP_MN %x, Device 0x%p, %!STATUS!",
                 queue->GetHandle(), Irp, majorFunction, minorFunction,
                 device->GetObjectHandle(), status);
        FxVerifierDbgBreakPoint(FxDriverGlobals);
        goto Done;
    }

    if (device->m_ParentDevice == queue->GetDevice()) {
        //
        // Send to parent device's queue validation.
        //
        if (device->m_ParentDevice == NULL) {
            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                    "No parent device for Device 0x%p, %!STATUS!",
                     device->GetObjectHandle(), status);
            FxVerifierDbgBreakPoint(FxDriverGlobals);
            goto Done;
        }

        //
        // Make sure the child device is a PDO
        //
        ASSERT(device->IsPdo());

        //
        // Check if the WdfPdoInitSetForwardRequestToParent was called to
        // increase the StackSize of the child Device  to include the stack
        // size of the parent Device
        //
        if (device->IsPnp() &&
            device->GetPdoPkg()->m_AllowForwardRequestToParent == FALSE) {
            status = STATUS_INVALID_DEVICE_REQUEST;
            DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                    "WdfPdoInitSetForwardRequestToParent not called on "
                    "Device 0x%p, %!STATUS!",
                    device->GetObjectHandle(), status);
            FxVerifierDbgBreakPoint(FxDriverGlobals);
            goto Done;
        }
    }
    else {
        //
        // Send to current device's queue validation.
        //
        if (device != queue->GetDevice()) {
            status = STATUS_INVALID_PARAMETER;
            DoTraceLevelMessage(
                    FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                    "Cannot forward a request to "
                    "a different Device 0x%p, %!STATUS!",
                    queue->GetDevice()->GetObjectHandle(), status);
            FxVerifierDbgBreakPoint(FxDriverGlobals);
            goto Done;
        }
    }

Done:
    return status;
}

Variable Documentation

__pad5__

exit __pad5__

Definition at line 2603 of file fxdeviceapi.cpp.

AlignmentRequirement

__in WDFDEVICE __in ULONG AlignmentRequirement

Initial value:

{
    DDI_ENTRY()

Definition at line 301 of file fxdeviceapi.cpp.

armForWakeIfChildrenAreArmedForWake

armForWakeIfChildrenAreArmedForWake

Initial value:

=
        (Settings->Size > sizeof(WDF_DEVICE_POWER_POLICY_WAKE_SETTINGS_V1_5)) ?
            Settings->ArmForWakeIfChildrenAreArmedForWake :
            FALSE

Definition at line 514 of file fxdeviceapi.cpp.

BufferLength

_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG BufferLength

Definition at line 1047 of file fxdeviceapi.cpp.

DesiredAccess

_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING _In_ ACCESS_MASK DesiredAccess

Definition at line 600 of file fxdeviceapi.cpp.

Device

_Must_inspect_result_ _In_ WDFDEVICE Device

Initial value:

{
    DDI_ENTRY()

Definition at line 68 of file fxdeviceapi.cpp.

DeviceAttributes

_Must_inspect_result_ __inout PWDFDEVICE_INIT __in_opt PWDF_OBJECT_ATTRIBUTES DeviceAttributes

Definition at line 874 of file fxdeviceapi.cpp.

DeviceCharacteristics

__in WDFDEVICE __in ULONG DeviceCharacteristics

Initial value:

{
    DDI_ENTRY()

Definition at line 224 of file fxdeviceapi.cpp.

deviceFlags

ULONG deviceFlags

Definition at line 2497 of file fxdeviceapi.cpp.

DeviceInit

_Must_inspect_result_ __inout PWDFDEVICE_INIT* DeviceInit

Definition at line 874 of file fxdeviceapi.cpp.

DeviceInstanceKeyType

_Must_inspect_result_ __in WDFDEVICE __in ULONG DeviceInstanceKeyType

Definition at line 600 of file fxdeviceapi.cpp.

deviceObject

MxDeviceObject deviceObject

Definition at line 228 of file fxdeviceapi.cpp.

Referenced by __drv_strictTypeMatch(), Bus_AddDevice(), CreateCdRomDeviceObject(), CreateDiskDeviceObject(), CreateFlopDeviceObject(), CreatePartitionDeviceObjects(), DiskCreateFdo(), DiskReregWorker(), DiskSendFailurePredictIoctl(), FxPkgFdo::DispatchSystemSetPower(), FxPkgPdo::DispatchSystemSetPower(), DpcRoutine(), FreeBT_AddDevice(), GetStackCapabilities(), FxIoTarget::GetTargetIoType(), if(), FxIoTarget::Init(), PartMgrAddDevice(), FxPkgPnp::PnpDeviceUsageNotification(), FxPkgPnp::PowerPolCheckPowerPageable(), FxPkgPnp::PowerPolicySetS0IdleSettings(), FxPkgPnp::PowerSetDevicePowerState(), FxPkgPnp::QueryForCapabilities(), FxPkgPnp::QueryForD3ColdInterface(), ReportToMountMgr(), FxIrp::RequestPowerIrp(), ScsiClassCreateDeviceObject(), SetD3ColdSupport(), UDFCheckOtherFS(), UDFCheckOtherFSByName(), and UpdateDeviceObjects().

DeviceProperty

_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA DeviceProperty

Definition at line 1047 of file fxdeviceapi.cpp.

DeviceState

__in WDFDEVICE __in PWDF_DEVICE_STATE DeviceState

Initial value:

{
    DDI_ENTRY()

Definition at line 754 of file fxdeviceapi.cpp.

Driver

_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ WDFDRIVER Driver

Definition at line 2450 of file fxdeviceapi.cpp.

DriverContext

_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ WDFDRIVER _In_ UCHAR _In_ PFN_WDFDEVICE_WDM_IRP_DISPATCH _In_opt_ WDFCONTEXT DriverContext

Initial value:

{
    PFX_DRIVER_GLOBALS  pFxDriverGlobals

Definition at line 2492 of file fxdeviceapi.cpp.

else

else

Initial value:

{
        status = STATUS_INVALID_PARAMETER

Definition at line 202 of file fxdeviceapi.cpp.

EvtDeviceWdmIrpDispatch

_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ WDFDRIVER _In_ UCHAR _In_ PFN_WDFDEVICE_WDM_IRP_DISPATCH EvtDeviceWdmIrpDispatch

Definition at line 2450 of file fxdeviceapi.cpp.

Referenced by FxPkgIo::ConfigureDynamicDispatching().

FailedAction

__in WDFDEVICE __in WDF_DEVICE_FAILED_ACTION FailedAction

Initial value:

{
    DDI_ENTRY()

Definition at line 1269 of file fxdeviceapi.cpp.

File

__in WDFDEVICE __in_opt PVOID __in LONG __in PSTR File

Initial value:

{
    DDI_ENTRY()

Definition at line 1435 of file fxdeviceapi.cpp.

i

ULONG i

Definition at line 798 of file fxdeviceapi.cpp.

indicateChildWakeOnParentWake

indicateChildWakeOnParentWake

Initial value:

=
        (Settings->Size > sizeof(WDF_DEVICE_POWER_POLICY_WAKE_SETTINGS_V1_5)) ?
            Settings->IndicateChildWakeOnParentWake :
            FALSE

Definition at line 515 of file fxdeviceapi.cpp.

Key

* Key

Initial value:

{
    DDI_ENTRY()

Definition at line 610 of file fxdeviceapi.cpp.

KeyAttributes

_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING _In_ ACCESS_MASK _In_opt_ PWDF_OBJECT_ATTRIBUTES KeyAttributes

Definition at line 600 of file fxdeviceapi.cpp.

keyHandle

WDFKEY keyHandle

Definition at line 674 of file fxdeviceapi.cpp.

Referenced by FxDevice::_OpenKey(), and if().

KeyName

_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName

Definition at line 657 of file fxdeviceapi.cpp.

Line

__in WDFDEVICE __in_opt PVOID __in LONG Line

Definition at line 1425 of file fxdeviceapi.cpp.

MajorFunction

_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ WDFDRIVER _In_ UCHAR MajorFunction

Definition at line 2450 of file fxdeviceapi.cpp.

NULL

return NULL

Definition at line 111 of file fxdeviceapi.cpp.

Referenced by __drv_strictTypeMatch(), if(), and VerifyWdfDeviceWdmDispatchIrpToIoQueue().

offsets

static const FxOffsetAndName offsets

static

Initial value:

= {
        OFFSET_AND_NAME(WDF_DEVICE_STATE, Disabled),
        OFFSET_AND_NAME(WDF_DEVICE_STATE, DontDisplayInUI),
        OFFSET_AND_NAME(WDF_DEVICE_STATE, Failed),
        OFFSET_AND_NAME(WDF_DEVICE_STATE, NotDisableable),
        OFFSET_AND_NAME(WDF_DEVICE_STATE, Removed),
        OFFSET_AND_NAME(WDF_DEVICE_STATE, ResourcesChanged),
    }

Definition at line 800 of file fxdeviceapi.cpp.

pCxDeviceInfo

pCxDeviceInfo = NULL

Definition at line 2496 of file fxdeviceapi.cpp.

Referenced by if().

pDevice

pDevice = NULL

Definition at line 71 of file fxdeviceapi.cpp.

Referenced by __drv_strictTypeMatch(), if(), ResumeIdleWorker(), and StopIdleWorker().

pDeviceBase

FxDeviceBase* pDeviceBase

Definition at line 98 of file fxdeviceapi.cpp.

pdoName

FxAutoString pdoName

Definition at line 991 of file fxdeviceapi.cpp.

Referenced by FxDevice::CreateSymbolicLink().

pFxDevice

FxDevice* pFxDevice

Definition at line 1924 of file fxdeviceapi.cpp.

pFxDriverGlobals

PFX_DRIVER_GLOBALS pFxDriverGlobals = GetFxDriverGlobals(DriverGlobals)

Definition at line 178 of file fxdeviceapi.cpp.

Referenced by __drv_strictTypeMatch(), if(), ResumeIdleWorker(), StopIdleWorker(), and switch().

pFxIoQueue

pFxIoQueue = NULL

Definition at line 1923 of file fxdeviceapi.cpp.

Referenced by __drv_strictTypeMatch().

pKey

FxRegKey * pKey = NULL

Definition at line 673 of file fxdeviceapi.cpp.

Referenced by FxDevice::_OpenKey(), _SHOpenProfilesKey(), if(), FxDevice::OpenDevicemapKeyWorker(), read_key_value(), RfsdBuildBDL2(), RfsdLoadInode(), RSAENH_CPHashSessionKey(), store_key_pair(), store_key_permissions(), test_GetDeviceInfo(), and test_save_settings().

PnpCapabilities

__in WDFDEVICE __in PWDF_DEVICE_PNP_CAPABILITIES PnpCapabilities

Initial value:

{
    DDI_ENTRY()

Definition at line 1521 of file fxdeviceapi.cpp.

PoolType

_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ _Strict_type_match_ POOL_TYPE PoolType

Definition at line 2226 of file fxdeviceapi.cpp.

PowerCapabilities

__in WDFDEVICE __in PWDF_DEVICE_POWER_CAPABILITIES PowerCapabilities

Initial value:

{
    DDI_ENTRY()

Definition at line 1619 of file fxdeviceapi.cpp.

pPkgIo

pPkgIo = NULL

Definition at line 1923 of file fxdeviceapi.cpp.

Referenced by FxPkgGeneral::OnCleanup().

pRequest

FxRequest* pRequest

Definition at line 2001 of file fxdeviceapi.cpp.

PropertyBuffer

_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG _In_opt_ PVOID PropertyBuffer

Initial value:

{
    DDI_ENTRY()

Definition at line 2094 of file fxdeviceapi.cpp.

PropertyMemory

* PropertyMemory

Initial value:

{
    DDI_ENTRY()

Definition at line 1166 of file fxdeviceapi.cpp.

PropertyMemoryAttributes

_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ _Strict_type_match_ POOL_TYPE _In_opt_ PWDF_OBJECT_ATTRIBUTES PropertyMemoryAttributes

Definition at line 1142 of file fxdeviceapi.cpp.

pString

FxString * pString

Definition at line 180 of file fxdeviceapi.cpp.

Referenced by ATL::CStringT< BaseType, StringTraits >::Construct(), FileGetString(), FxCalculateTotalStringSize(), FxDriver::GetRegistryPath(), GetStringValue(), if(), IntUnicodeStringToBuffer(), load_string(), LoadAllocStringW(), NetrJobEnum(), pSetupGuidFromString(), pSetupStringFromGuid(), FxDeviceInterface::Register(), ScmCreateOrReferenceServiceImage(), ScriptStringAnalyse(), TiWriteErrorLog(), ToMultiSz(), and WDML_QueryString().

pTarget

FxIoTarget * pTarget = pDeviceBase->GetDefaultIoTarget()

Definition at line 97 of file fxdeviceapi.cpp.

Referenced by FxIoTargetRemote::_Create(), _IsNonwritableInCurrentImage(), FxDeviceBase::AllocateTarget(), FxRequestBase::CompleteSubmitted(), CKsProxy::ConvertTimeFormat(), COutputPin::ConvertTimeFormat(), CopyIpAddrString(), FFSAddEntry(), FFSIsDirectoryEmpty(), FFSRemoveEntry(), GetNetworkParams(), if(), MediaSeeking_ConvertTimeFormat(), MediaSeekingPassThru_ConvertTimeFormat(), NtfsWSubString(), RfsdIsDirectoryEmpty(), SourceSeekingImpl_ConvertTimeFormat(), and FxUsbDevice::Start().

Queue

_Must_inspect_result_ __in WDFDEVICE __in WDFQUEUE Queue

Definition at line 1769 of file fxdeviceapi.cpp.

Request

_Must_inspect_result_ __in WDFDEVICE __in WDFREQUEST Request

Initial value:

{
    DDI_ENTRY()

Definition at line 1996 of file fxdeviceapi.cpp.

RequiredSize

_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG RequiredSize

Definition at line 2094 of file fxdeviceapi.cpp.

ResultLength

_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY __in ULONG __out PULONG ResultLength

Initial value:

{
    DDI_ENTRY()

Definition at line 1078 of file fxdeviceapi.cpp.

return

return

Definition at line 1255 of file fxdeviceapi.cpp.

Settings

_Must_inspect_result_ __in WDFDEVICE __in PWDF_DEVICE_POWER_POLICY_WAKE_SETTINGS Settings

Initial value:

{
    DDI_ENTRY()

Definition at line 395 of file fxdeviceapi.cpp.

status

NTSTATUS status = FxVerifierCheckIrqlLevel(pFxDriverGlobals, PASSIVE_LEVEL)

Definition at line 181 of file fxdeviceapi.cpp.

Referenced by __drv_strictTypeMatch(), if(), StopIdleWorker(), and VerifyWdfDeviceWdmDispatchIrpToIoQueue().

Stoppable

__in WDFDEVICE __in BOOLEAN Stoppable

Initial value:

{
    DDI_ENTRY()

Definition at line 1232 of file fxdeviceapi.cpp.

String

_Must_inspect_result_ __in WDFDEVICE __in WDFSTRING String

Initial value:

{
    DDI_ENTRY()

Definition at line 175 of file fxdeviceapi.cpp.

SymbolicLinkName

_Must_inspect_result_ __in WDFDEVICE __in PCUNICODE_STRING SymbolicLinkName

Initial value:

{
    DDI_ENTRY()

Definition at line 987 of file fxdeviceapi.cpp.

Tag

__in WDFDEVICE __in_opt PVOID Tag

Definition at line 1425 of file fxdeviceapi.cpp.

Type

_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE Type

Initial value:

{
    DDI_ENTRY()

Definition at line 2153 of file fxdeviceapi.cpp.

WaitForD0

_Must_inspect_result_ __in WDFDEVICE __in BOOLEAN WaitForD0

Initial value:

{
    DDI_ENTRY()

Definition at line 1401 of file fxdeviceapi.cpp.