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
	Queries information details about a security descriptor.
	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
	Probes and locks virtual pages in memory for the specified process.
	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	__pad0__

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 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_strictTypeMatch() [2/2]

_Must_inspect_result_ __in WDFDEVICE __in DEVICE_REGISTRY_PROPERTY __in __drv_strictTypeMatch

(

__drv_typeExpr

)

__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]

_Must_inspect_result_ _IRQL_requires_max_

(

APC_LEVEL

)

Probes and locks virtual pages in memory for the specified process.

Parameters

[in,out]	MemoryDescriptorList	Memory Descriptor List (MDL) containing the buffer to be probed and locked.
[in]	Process	The process for which the buffer should be probed and locked.
[in]	AccessMode	Access mode for probing the pages. Can be KernelMode or UserMode.
[in]	LockOperation	The type of the probing and locking operation. Can be IoReadAccess, IoWriteAccess or IoModifyAccess.

Returns

Nothing.

See also

MmProbeAndLockPages

Remarks

Must be called at IRQL <= APC_LEVEL

Probes and locks virtual pages in memory for the specified process.

Frees previously reserved amount of memory in system virtual address space.

Parameters

[in]	NumberOfBytes	Size, in bytes, of memory to reserve.
[in]	PoolTag	Pool Tag identifying the buffer. Usually consists from 4 characters in reversed order.

Returns

A pointer to the 1st memory block of the reserved buffer in case of success, NULL otherwise.

Remarks

Must be called at IRQL <= APC_LEVEL

Parameters

[in]	BaseAddress	A pointer to the 1st memory block of the reserved buffer.
[in]	PoolTag	Pool Tag identifying the buffer. Usually consists from 4 characters in reversed order.

Returns

Nothing.

See also

MmAllocateMappingAddress

Remarks

Must be called at IRQL <= APC_LEVEL

Definition at line 37 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;
}

_IRQL_requires_max_() [2/3]

_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Definition at line 347 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_() [3/3]

_Must_inspect_result_ _IRQL_requires_max_

(

PASSIVE_LEVEL

)

Queries information details about a security descriptor.

Computes the quota size of a security descriptor.

Assigns a security descriptor for a new object.

An extended function that assigns a security descriptor for a new object.

Frees a security descriptor.

An extended function that sets new information data to a security descriptor.

Modifies some information data about a security descriptor.

Parameters

[in]	SecurityInformation	Security information details to be queried from a security descriptor.
[out]	SecurityDescriptor	The returned security descriptor with security information data.
[in,out]	Length	The returned length of a security descriptor.
[in,out]	ObjectsSecurityDescriptor	The returned object security descriptor.

Returns

Returns STATUS_SUCCESS if the operations have been completed successfully and that the specific information about the security descriptor has been queried. STATUS_BUFFER_TOO_SMALL is returned if the buffer size is too small to contain the queried info about the security descriptor.

Parameters

[in]	Object	If specified, the function will use this arbitrary object that points to an object security descriptor.
[in]	SecurityInformation	Security information details to be set.
[in]	SecurityDescriptor	A security descriptor where its info is to be changed.
[in,out]	ObjectsSecurityDescriptor	The returned pointer to security descriptor objects.
[in]	PoolType	Pool type for the new security descriptor to allocate.
[in]	GenericMapping	The generic mapping of access rights masks.

Returns

See SeSetSecurityDescriptorInfoEx.

Parameters

[in]	Object	If specified, the function will use this arbitrary object that points to an object security descriptor.
[in]	SecurityInformation	Security information details to be set.
[in]	SecurityDescriptor	A security descriptor where its info is to be changed.
[in,out]	ObjectsSecurityDescriptor	The returned pointer to security descriptor objects.
[in]	AutoInheritFlags	Flags bitmask inheritation, influencing how the security descriptor can be inherited and if it can be in the first place.
[in]	PoolType	Pool type for the new security descriptor to allocate.
[in]	GenericMapping	The generic mapping of access rights masks.

Returns

Returns STATUS_SUCCESS if the operations have been completed without problems and that new info has been set to the security descriptor. STATUS_NO_SECURITY_ON_OBJECT is returned if the object does not have a security descriptor. STATUS_INSUFFICIENT_RESOURCES is returned if memory pool allocation for the new security descriptor with new info set has failed.

Parameters

[in]

SecurityDescriptor

A security descriptor to be freed from memory.

Returns

Returns STATUS_SUCCESS.

Parameters

[in]	_ParentDescriptor	A security descriptor of the parent object that is being created.
[in]	_ExplicitDescriptor	An explicit security descriptor that is applied to a new object.
[out]	NewDescriptor	The new allocated security descriptor.
[in]	ObjectType	The type of the new object.
[in]	IsDirectoryObject	Set this to TRUE if the newly created object is a directory object, otherwise set this to FALSE.
[in]	AutoInheritFlags	Automatic inheritance flags that influence how access control entries within ACLs from security descriptors are inherited.
[in]	SubjectContext	Security subject context of the new object.
[in]	GenericMapping	Generic mapping of access mask rights.
[in]	PoolType	This parameter is unused.

Returns

Returns STATUS_SUCCESS if the operations have been completed successfully and that the security descriptor has been assigned to the new object. STATUS_NO_TOKEN is returned if the caller hasn't supplied a valid argument to a security subject context. STATUS_INVALID_OWNER is returned if the caller hasn't supplied a parent descriptor that belongs to the main user (owner). STATUS_INVALID_PRIMARY_GROUP is returned by the same reason as with the previous NTSTATUS code. The two NTSTATUS codes are returned if the calling thread stated that the owner and/or group is defaulted to the parent descriptor (SEF_DEFAULT_OWNER_FROM_PARENT and/or SEF_DEFAULT_GROUP_FROM_PARENT respectively). STATUS_INSUFFICIENT_RESOURCES is returned if memory pool allocation for the descriptor buffer has failed. A failure NTSTATUS is returned otherwise.

Parameters

[in]	ParentDescriptor	A security descriptor of the parent object that is being created.
[in]	ExplicitDescriptor	An explicit security descriptor that is applied to a new object.
[out]	NewDescriptor	The new allocated security descriptor.
[in]	IsDirectoryObject	Set this to TRUE if the newly created object is a directory object, otherwise set this to FALSE.
[in]	SubjectContext	Security subject context of the new object.
[in]	GenericMapping	Generic mapping of access mask rights.
[in]	PoolType	This parameter is unused.

Returns

See SeAssignSecurityEx.

Parameters

[in]	SecurityDescriptor	A security descriptor.
[out]	QuotaInfoSize	The returned quota size of the given security descriptor to the caller. The function may return 0 to this parameter if the descriptor doesn't have a group or a discretionary access control list (DACL) even.

Returns

Returns STATUS_SUCCESS if the quota size of a security descriptor has been computed successfully. STATUS_UNKNOWN_REVISION is returned if the security descriptor has an invalid revision.

Definition at line 923 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;
}

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_INFORMATION	,
		TRACINGDEVICE	,
		"WDFDEVICE %	p,
		!devobj %p SetFailed %!WDF_DEVICE_FAILED_ACTION!"	,
		Device	,
		pDevice->	GetDeviceObject(),
		FailedAction
	)

DoTraceLevelMessage() [3/3]

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

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	,
		Device	,
		FX_TYPE_DEVICE	,
		(PVOID *) &	pDevice
	)

FxObjectHandleGetPtr() [4/5]

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

FxObjectHandleGetPtr() [5/5]

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

FxObjectHandleGetPtrAndGlobals()

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

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

FxPointerNotNull() [1/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		*	DeviceInit
	)

FxPointerNotNull() [2/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		Device
	)

FxPointerNotNull() [3/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		DeviceInit
	)

FxPointerNotNull() [4/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		DeviceProperty
	)

FxPointerNotNull() [5/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		DeviceState
	)

FxPointerNotNull() [6/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		EvtDeviceWdmIrpDispatch
	)

FxPointerNotNull() [7/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		Key
	)

FxPointerNotNull() [8/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		PnpCapabilities
	)

FxPointerNotNull() [9/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		PowerCapabilities
	)

FxPointerNotNull() [10/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		PropertyMemory
	)

FxPointerNotNull() [11/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		RequiredSize
	)

FxPointerNotNull() [12/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		ResultLength
	)

FxPointerNotNull() [13/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		Settings
	)

FxPointerNotNull() [14/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		SymbolicLinkName
	)

FxPointerNotNull() [15/15]

FxPointerNotNull	(	pFxDriverGlobals	,
		Type
	)

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()

Referenced by FxPkgIo::ConfigureDynamicDispatching(), and FxDevice::GetCxDriver().

GetPnpState()

pDevice m_PkgPnp GetPnpState

(

DeviceState

)

GetSystemPowerAction()

return pDevice m_PkgPnp GetSystemPowerAction

(

)

if() [1/28]

if

(

!

NT_SUCCESSstatus

)

Definition at line 190 of file fxdeviceapi.cpp.

                             {
        return status;
    }

if() [2/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() [3/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() [4/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() [5/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() [6/28]

if	(	BufferLength	,
		0
	)

Definition at line 1092 of file fxdeviceapi.cpp.

                          {
        FxPointerNotNull(pFxDriverGlobals, PropertyBuffer);
    }

if() [7/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() [8/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() [9/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() [10/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);
    }

if() [11/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() [12/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() [13/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() [14/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() [15/28]

if

(

pDevice->m_DeviceName.Buffer !

= NULL

)

Definition at line 199 of file fxdeviceapi.cpp.

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

if() [16/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() [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

(

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() [19/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() [20/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() [21/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() [22/28]

if

(

pTarget !

= NULL

)

Definition at line 107 of file fxdeviceapi.cpp.

                         {
        return pTarget->GetHandle();
    }

if() [23/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() [24/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() [25/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() [26/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() [27/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() [28/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);
    }

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

)

Referenced by FxMemoryPagedBufferFromPoolLookaside::FxMemoryPagedBufferFromPoolLookaside(), and FxRequestFromLookaside::FxRequestFromLookaside().

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

__pad0__

exit __pad0__

Definition at line 2602 of file fxdeviceapi.cpp.

AlignmentRequirement

__in WDFDEVICE __in ULONG AlignmentRequirement

Initial value:

{
    DDI_ENTRY()

Definition at line 299 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 1051 of file fxdeviceapi.cpp.

DesiredAccess

_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING _In_ ACCESS_MASK DesiredAccess

Definition at line 604 of file fxdeviceapi.cpp.

Device

_Must_inspect_result_ _In_ WDFDEVICE Device

Initial value:

{
    DDI_ENTRY()

Definition at line 51 of file fxdeviceapi.cpp.

DeviceAttributes

_Must_inspect_result_ __inout PWDFDEVICE_INIT __in_opt PWDF_OBJECT_ATTRIBUTES DeviceAttributes

Definition at line 876 of file fxdeviceapi.cpp.

DeviceCharacteristics

__in WDFDEVICE __in ULONG DeviceCharacteristics

Initial value:

{
    DDI_ENTRY()

Definition at line 222 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 602 of file fxdeviceapi.cpp.

deviceObject

MxDeviceObject deviceObject

Definition at line 228 of file fxdeviceapi.cpp.

Referenced by __drv_strictTypeMatch(), Bus_AddDevice(), CreateFlopDeviceObject(), 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(), FxIrp::RequestPowerIrp(), SetD3ColdSupport(), UDFCheckOtherFS(), and UDFCheckOtherFSByName().

DeviceProperty

_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA DeviceProperty

Definition at line 1049 of file fxdeviceapi.cpp.

DeviceState

__in WDFDEVICE __in PWDF_DEVICE_STATE DeviceState

Initial value:

{
    DDI_ENTRY()

Definition at line 752 of file fxdeviceapi.cpp.

Driver

_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ WDFDRIVER Driver

Definition at line 2452 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 2458 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 2456 of file fxdeviceapi.cpp.

Referenced by FxPkgIo::ConfigureDynamicDispatching().

FailedAction

__in WDFDEVICE __in WDF_DEVICE_FAILED_ACTION FailedAction

Initial value:

{
    DDI_ENTRY()

Definition at line 1267 of file fxdeviceapi.cpp.

File

__in WDFDEVICE __in_opt PVOID __in LONG __in PSTR File

Initial value:

{
    DDI_ENTRY()

Definition at line 1433 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 608 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 606 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 659 of file fxdeviceapi.cpp.

Line

__in WDFDEVICE __in_opt PVOID __in LONG Line

Definition at line 1431 of file fxdeviceapi.cpp.

MajorFunction

_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ WDFDRIVER _In_ UCHAR MajorFunction

Definition at line 2454 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.

Referenced by __RTDynamicCast(), _test_caret_item_ScriptXtoCP(), _test_item_ScriptXtoX(), cid_read_subrs(), DECLARE_INTERFACE_(), fi_set(), FT_Raccess_Get_DataOffsets(), FT_Raccess_Guess(), MimeBody_set_offsets(), MimeMessage_Load(), mpg123_index(), mpg123_set_index(), pcf_get_bitmaps(), test_CreateBody(), test_CreateMessage(), test_ScriptXtoX(), WMSFT_compile_typeinfo_aux(), and write_lb_ranges().

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 1925 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 1924 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(), 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 1503 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 2231 of file fxdeviceapi.cpp.

PowerCapabilities

__in WDFDEVICE __in PWDF_DEVICE_POWER_CAPABILITIES PowerCapabilities

Initial value:

{
    DDI_ENTRY()

Definition at line 1601 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 2100 of file fxdeviceapi.cpp.

PropertyMemory

* PropertyMemory

Initial value:

{
    DDI_ENTRY()

Definition at line 1144 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(), CTipbarWnd::_CreateThread(), CTipbarWnd::_FindThread(), _IsNonwritableInCurrentImage(), FxDeviceBase::AllocateTarget(), FxRequestBase::CompleteSubmitted(), COutputPin::ConvertTimeFormat(), CKsProxy::ConvertTimeFormat(), CopyIpAddrString(), CTipbarAccessible::GetIDOfItem(), GetNetworkParams(), if(), CTipbarWnd::IsInItemChangeOrDirty(), MediaSeeking_ConvertTimeFormat(), MediaSeekingPassThru_ConvertTimeFormat(), NtfsWSubString(), CTipbarWnd::RemoveThredFromThreadCreatingList(), SourceSeekingImpl_ConvertTimeFormat(), FxUsbDevice::Start(), CTipbarWnd::StartDoAccDefaultActionTimer(), and CUTBMenuWnd::StartDoAccDefaultActionTimer().

Queue

_Must_inspect_result_ __in WDFDEVICE __in WDFQUEUE Queue

Definition at line 1771 of file fxdeviceapi.cpp.

Request

_Must_inspect_result_ __in WDFDEVICE __in WDFREQUEST Request

Initial value:

{
    DDI_ENTRY()

Definition at line 1966 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 2102 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 1055 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 393 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 1230 of file fxdeviceapi.cpp.

String

_Must_inspect_result_ __in WDFDEVICE __in WDFSTRING String

Initial value:

{
    DDI_ENTRY()

Definition at line 173 of file fxdeviceapi.cpp.

SymbolicLinkName

_Must_inspect_result_ __in WDFDEVICE __in PCUNICODE_STRING SymbolicLinkName

Initial value:

{
    DDI_ENTRY()

Definition at line 985 of file fxdeviceapi.cpp.

Tag

__in WDFDEVICE __in_opt PVOID Tag

Definition at line 1429 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 2104 of file fxdeviceapi.cpp.

WaitForD0

_Must_inspect_result_ __in WDFDEVICE __in BOOLEAN WaitForD0

Initial value:

{
    DDI_ENTRY()

Definition at line 1399 of file fxdeviceapi.cpp.