#include <fxiotargetremote.hpp>

Inheritance diagram for FxIoTargetRemote:

[legend]

Collaboration diagram for FxIoTargetRemote:

[legend]

Public Member Functions
	~FxIoTargetRemote ()

NTSTATUS	InitRemote (__in FxDeviceBase *Device)

NTSTATUS	InitRemoteModeSpecific (__in FxDeviceBase *Device)

_Must_inspect_result_ NTSTATUS	Open (__in PWDF_IO_TARGET_OPEN_PARAMS OpenParams)

VOID	Close (__in FxIoTargetRemoteCloseReason Reason)

NTSTATUS	GetTargetDeviceRelations (_Out_ BOOLEAN *Close)

BOOLEAN	CanRegisterForPnpNotification (VOID)

VOID	ResetTargetNotifyHandle (VOID)

NTSTATUS	OpenTargetHandle (_In_ PWDF_IO_TARGET_OPEN_PARAMS OpenParams, _Inout_ FxIoTargetRemoveOpenParams *pParams)

VOID	CloseTargetHandle (VOID)

HANDLE	GetTargetHandle (VOID)

NTSTATUS	RegisterForPnpNotification (VOID)

VOID	UnregisterForPnpNotification (_In_ MdTargetNotifyHandle Handle)

__inline WDFIOTARGET	GetHandle (VOID)

virtual VOID	Remove (VOID)

VOID	RemoveModeSpecific (VOID)

Public Member Functions inherited from FxIoTarget
	FxIoTarget (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in USHORT ObjectSize)

	FxIoTarget (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in USHORT ObjectSize, __in WDFTYPE WdfType)

virtual _Must_inspect_result_ NTSTATUS	Start (VOID)

virtual VOID	Stop (__in WDF_IO_TARGET_SENT_IO_ACTION Action)

virtual VOID	Purge (__in WDF_IO_TARGET_PURGE_IO_ACTION Action)

virtual VOID	Remove (VOID)

NTSTATUS _Must_inspect_result_	QueryInterface (__inout FxQueryInterfaceParams *Params)

__inline WDF_IO_TARGET_STATE	GetState (VOID)

__inline MdDeviceObject	GetTargetDevice (VOID)

__inline MdDeviceObject	GetTargetPDO (VOID)

__inline MdFileObject	GetTargetFileObject (VOID)

__inline WDFDEVICE	GetDeviceHandle (VOID)

WDFIOTARGET	GetHandle (VOID)

__inline FxDriver *	GetDriver (VOID)

virtual _Must_inspect_result_ MdDeviceObject	GetTargetDeviceObject (_In_ CfxDeviceBase *Device)

_Must_inspect_result_ NTSTATUS	Init (__in CfxDeviceBase *Device)

ULONG	Submit (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS Options, __in_opt ULONG Flags)

	FX_DECLARE_VF_FUNCTION_P1 (NTSTATUS, VerifySubmitLocked, _In_ FxRequestBase *)

ULONG	SubmitLocked (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS Options, __in ULONG Flags)

_Must_inspect_result_ NTSTATUS	SubmitSync (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS Options=NULL, __out_opt PULONG Action=NULL)

VOID	TimerCallback (__in FxRequestBase *Request)

VOID	CompleteCanceledRequest (__in FxRequestBase *Request)

VOID	SubmitPendedRequest (__in FxRequestBase *Request)

VOID	CompletePendedRequest (__in FxRequestBase *Request)

BOOLEAN __inline	HasEnoughStackLocations (__in FxIrp *Irp)

_Must_inspect_result_ NTSTATUS	FormatIoRequest (__inout FxRequestBase Request, __in UCHAR MajorCode, __in FxRequestBuffer IoBuffer, __in_opt PLONGLONG StartingOffset, __in_opt FxFileObject *FileObject=NULL)

_Must_inspect_result_ NTSTATUS	FormatIoctlRequest (__in FxRequestBase Request, __in ULONG Ioctl, __in BOOLEAN Internal, __in FxRequestBuffer InputBuffer, __in FxRequestBuffer OutputBuffer, __in_opt FxFileObject FileObject=NULL)

_Must_inspect_result_ NTSTATUS	FormatInternalIoctlOthersRequest (__in FxRequestBase Request, __in ULONG Ioctl, __in FxRequestBuffer Buffers)

VOID	CancelSentIo (VOID)

_Must_inspect_result_ NTSTATUS	SubmitSyncRequestIgnoreTargetState (__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS RequestOptions)

VOID	UpdateTargetIoType (VOID)

BOOLEAN	HasValidStackSize (VOID)

virtual VOID	Send (_In_ MdIrp Irp)

Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

virtual	~FxNonPagedObject (VOID)

	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)

	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)

	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)

	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)

Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()

void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)

	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

virtual	~FxObject (VOID)

PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)

PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)

VOID	operator delete (__in PVOID Memory)

VOID	SetNoContextHeader (VOID)

PVOID __inline	GetObjectHandle (VOID)

__inline FxContextHeader *	GetContextHeader (VOID)

__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)

WDFTYPE	GetType (VOID)

USHORT	GetObjectSize (VOID)

LONG	GetRefCnt (VOID)

FxTagTracker *	GetTagTracker (VOID)

CfxDevice *	GetDevice (VOID)

CfxDeviceBase *	GetDeviceBase (VOID)

VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)

__inline VOID	CallCleanup (VOID)

ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)

VOID	MarkTraceState (VOID)

BOOLEAN __inline	IsTraceState (VOID)

VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)

VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)

VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)

VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)

BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)

BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)

BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)

VOID	MarkCommitted (VOID)

BOOLEAN	IsCommitted (VOID)

VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)

VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)

BOOLEAN	IsNoDeleteDDI (VOID)

_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT ObjectHandle, __in_opt FxObject Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)

VOID	DeleteFromFailedCreate (VOID)

VOID	ClearEvtCallbacks (VOID)

BOOLEAN	EarlyDispose (VOID)

virtual VOID	DeleteObject (VOID)

virtual BOOLEAN	Dispose (VOID)

_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)

_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader Header, __in PVOID Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)

_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)

_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)

BOOLEAN	IsDisposed (VOID)

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	_Create (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_OBJECT_ATTRIBUTES Attributes, __in FxDeviceBase Device, __out FxIoTargetRemote *Target)

Static Public Member Functions inherited from FxIoTarget
static VOID	_CancelSentRequest (__in FxRequestBase *Request)

static FxIoTarget *	_FromEntry (__in FxTransactionedEntry *Entry)

Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)

static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)

static PVOID __inline	_ToHandle (__in FxObject *Object)

static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)

static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)

static PVOID	_GetDebugBase (__in FxObject *Object)

static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)

static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject Object, __in_opt IFxHasCallbacks Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock CallbackLock, __out_opt FxObject CallbackLockObject)

static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject Object, _In_ CONST GUID Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)

Protected Member Functions
	FxIoTargetRemote (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

virtual VOID	ClearTargetPointers (VOID)

_Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)

_Must_inspect_result_ NTSTATUS	OpenLocalTargetByFile (_In_ PWDF_IO_TARGET_OPEN_PARAMS OpenParams)

Protected Member Functions inherited from FxIoTarget
	~FxIoTarget ()

_Must_inspect_result_ NTSTATUS	InitModeSpecific (__in CfxDeviceBase *Device)

virtual BOOLEAN	Dispose (VOID)

VOID	FailPendedRequest (__in FxRequestBase *Request, __in NTSTATUS Status)

VOID	DrainPendedRequestsLocked (__in PLIST_ENTRY RequestListHead, __in BOOLEAN RequestWillBeResent)

VOID	CompletePendedRequestList (__in PLIST_ENTRY RequestListHead)

VOID	SubmitPendedRequests (__in PLIST_ENTRY RequestListHeadHead)

VOID	GetSentRequestsListLocked (__in PSINGLE_LIST_ENTRY RequestListHead, __in PLIST_ENTRY SendList, __out PBOOLEAN AddedToList)

virtual _Must_inspect_result_ NTSTATUS	GotoStartState (__in PLIST_ENTRY RequestListHead, __in BOOLEAN Lock=TRUE)

virtual VOID	GotoStopState (__in WDF_IO_TARGET_SENT_IO_ACTION Action, __in PSINGLE_LIST_ENTRY SentRequestListHead, __out PBOOLEAN Wait, __in BOOLEAN LockSelf)

virtual VOID	GotoPurgeState (__in WDF_IO_TARGET_PURGE_IO_ACTION Action, __in PLIST_ENTRY PendedRequestListHead, __in PSINGLE_LIST_ENTRY SentRequestListHead, __out PBOOLEAN Wait, __in BOOLEAN LockSelf)

_Must_inspect_result_ NTSTATUS	PendRequestLocked (__in FxRequestBase *Request)

__inline VOID	CompleteRequest (__in FxRequestBase *Request)

VOID	HandleFailedResubmit (__in FxRequestBase *Request)

VOID	RequestCompletionRoutine (__in FxRequestBase *Request)

BOOLEAN	RemoveCompletedRequestLocked (__in FxRequestBase *Request)

virtual VOID	ClearTargetPointers (VOID)

UCHAR	GetTargetIoType (VOID)

virtual VOID	GotoRemoveState (__in WDF_IO_TARGET_STATE NewState, __in PLIST_ENTRY PendedRequestListHead, __in PSINGLE_LIST_ENTRY SentRequestListHead, __in BOOLEAN Lock, __out PBOOLEAN Wait)

virtual VOID	WaitForSentIoToComplete (VOID)

virtual VOID	WaitForDisposeEvent (VOID)

virtual VOID	Forward (__in MdIrp Irp)

__inline VOID	CopyFileObjectAndFlags (__in FxRequestBase *Request)

__inline VOID	IncrementIoCount (VOID)

__inline VOID	DecrementIoCount (VOID)

VOID	PrintDisposeMessage (VOID)

Protected Member Functions inherited from FxObject
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

FxObjectDebugExtension *	GetDebugExtension (VOID)

BOOLEAN	IsDebug (VOID)

VOID	AllocateTagTracker (__in WDFTYPE Type)

virtual VOID	SelfDestruct (VOID)

PVOID __inline	GetObjectHandleUnchecked (VOID)

VOID __inline	DestroyChildren (VOID)

VOID	DeleteEarlyDisposedObject (VOID)

Protected Attributes
FxIoTargetRemoveOpenParams	m_OpenParams

Protected Attributes inherited from FxIoTarget
LIST_ENTRY	m_SentIoListHead

LIST_ENTRY	m_IgnoredIoListHead

FxCREvent	m_SentIoEvent

FxCREvent *	m_DisposeEvent

FxCREvent	m_DisposeEventUm

FxIrpQueue	m_PendedQueue

FxDriver *	m_Driver

MdDeviceObject	m_InStackDevice

MdDeviceObject	m_TargetDevice

MdDeviceObject	m_TargetPdo

MdFileObject	m_TargetFileObject

WDF_IO_TARGET_STATE	m_State

LONG	m_IoCount

CCHAR	m_TargetStackSize

UCHAR	m_TargetIoType

BOOLEAN	m_WaitingForSentIo

BOOLEAN	m_Removing

Protected Attributes inherited from FxObject
union {
CfxDeviceBase * m_DeviceBase

CfxDevice * m_Device

};

Static Protected Attributes
static DRIVER_NOTIFICATION_CALLBACK_ROUTINE	_PlugPlayNotification

Static Protected Attributes inherited from FxIoTarget
static MdCompletionRoutineType	_RequestCompletionRoutine

static EVT_WDF_REQUEST_COMPLETION_ROUTINE	_SyncCompletionRoutine

Additional Inherited Members
Static Public Attributes inherited from FxIoTarget
static const PVOID	m_SentRequestTag = (PVOID) 'lcnC'

Static Protected Member Functions inherited from FxIoTarget
static VOID	_CancelSentRequests (__in PSINGLE_LIST_ENTRY RequestListHead)

static VOID	_RequestCancelled (__in FxIrpQueue *Queue, __in MdIrp Irp, __in PMdIoCsqIrpContext pCsqContext, __in KIRQL CallerIrql)

Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Detailed Description

Definition at line 173 of file fxiotargetremote.hpp.

Constructor & Destructor Documentation

◆ ~FxIoTargetRemote()

FxIoTargetRemote::~FxIoTargetRemote ( )

Definition at line 67 of file fxiotargetremote.cpp.

68{

69}

◆ FxIoTargetRemote()

FxIoTargetRemote::FxIoTargetRemote ( __in PFX_DRIVER_GLOBALS FxDriverGlobals )

protected

Definition at line 31 of file fxiotargetremote.cpp.

      :
    FxIoTarget(FxDriverGlobals, sizeof(FxIoTargetRemote)),
    m_EvtQueryRemove(FxDriverGlobals),
    m_EvtRemoveCanceled(FxDriverGlobals),
    m_EvtRemoveComplete(FxDriverGlobals)
{
 
    //
    // No automatic state changes based on the pnp state changes of our own
    // device stack.  The one exception is remove where we need to shut
    // everything down.
    //
    m_InStack = FALSE;
 
    m_ClearedPointers = NULL;
    m_OpenState = FxIoTargetRemoteOpenStateClosed;
 
    m_TargetHandle = NULL;
 
    m_EvtQueryRemove.m_Method = NULL;
    m_EvtRemoveCanceled.m_Method = NULL;
    m_EvtRemoveComplete.m_Method = NULL;
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    m_TargetNotifyHandle = NULL;
#elif (FX_CORE_MODE == FX_CORE_USER_MODE)
    m_TargetNotifyHandle = WUDF_TARGET_CONTEXT_INVALID;
 
    m_pIoDispatcher = NULL;
    m_pRemoteDispatcher = NULL;
    m_NotificationCallback = NULL;
#endif
}

Member Function Documentation

◆ _Create()

_Must_inspect_result_ NTSTATUS FxIoTargetRemote::_Create	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PWDF_OBJECT_ATTRIBUTES	Attributes,
		__in FxDeviceBase *	Device,
		__out FxIoTargetRemote **	Target
	)

static

Definition at line 73 of file fxiotargetremote.cpp.

{
    FxIoTargetRemote* pTarget;
    FxObject* pParent;
    WDFOBJECT hTarget;
    NTSTATUS status;
 
    *Target = NULL;
 
    if (Attributes == NULL || Attributes->ParentObject == NULL) {
        pParent = Device;
    }
    else {
        CfxDeviceBase* pSearchDevice;
 
        FxObjectHandleGetPtr(FxDriverGlobals,
                             Attributes->ParentObject,
                             FX_TYPE_OBJECT,
                             (PVOID*) &pParent);
 
        pSearchDevice = FxDeviceBase::_SearchForDevice(pParent, NULL);
 
        if (pSearchDevice == NULL) {
            status = STATUS_INVALID_DEVICE_REQUEST;
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Attributes->ParentObject 0x%p must have WDFDEVICE as an "
                "eventual ancestor, %!STATUS!",
                Attributes->ParentObject, status);
 
            return status;
        }
        else if (pSearchDevice != Device) {
            status = STATUS_INVALID_DEVICE_REQUEST;
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "Attributes->ParentObject 0x%p ancestor is WDFDEVICE %p, but "
                "not the same WDFDEVICE 0x%p passed to WdfIoTargetCreate, "
                "%!STATUS!",
                Attributes->ParentObject, pSearchDevice->GetHandle(),
                Device->GetHandle(), status);
 
            return status;
        }
    }
 
    pTarget = new (FxDriverGlobals, Attributes)
        FxIoTargetRemote(FxDriverGlobals);
 
    if (pTarget == NULL) {
        status =  STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Could not allocate memory for target, %!STATUS!", status);
        return status;
    }
 
    //
    // initialize the new target
    //
    status = pTarget->InitRemote(Device);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // Commit and apply the attributes
    //
    status = pTarget->Commit(Attributes, &hTarget, pParent);
 
    if (NT_SUCCESS(status)) {
        *Target = pTarget;
    }
    else {
        //
        // This will properly clean up the target's state and free it
        //
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Commit failed for target, %!STATUS!", status);
        pTarget->DeleteFromFailedCreate();
    }
 
    return status;
}

◆ CanRegisterForPnpNotification()

BOOLEAN FxIoTargetRemote::CanRegisterForPnpNotification ( VOID )

inline

Definition at line 216 of file fxiotargetremote.hpp.

    {
        BOOLEAN canRegister = FALSE;
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        if (m_TargetFileObject != NULL) {
            canRegister = TRUE;
        }
#else // FX_CORE_USER_MODE
        if (m_TargetHandle != NULL) {
            canRegister = TRUE;
        }
#endif
        return canRegister;
    }

Referenced by Open().

◆ ClearTargetPointers()

VOID FxIoTargetRemote::ClearTargetPointers ( VOID )

protectedvirtual

Reimplemented from FxIoTarget.

Definition at line 725 of file fxiotargetremote.cpp.

{
    DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
        "WDFIOTARGET %p cleared pointers %p state %!WDF_IO_TARGET_STATE!,"
        " open state %d, pdo %p, fileobj %p, handle %p",
        GetObjectHandle(), m_ClearedPointers, m_State, m_OpenState, m_TargetPdo,
        m_TargetFileObject, m_TargetHandle);
 
    //
    // Check to see if the caller who is changing state wants these pointer
    // values before they being cleared out.
    //
    if (m_ClearedPointers != NULL) {
        m_ClearedPointers->TargetPdo = m_TargetPdo;
        m_ClearedPointers->TargetFileObject = m_TargetFileObject;
        m_ClearedPointers->TargetHandle = m_TargetHandle;
        m_ClearedPointers = NULL;
    }
 
    //
    // m_TargetHandle is only an FxIoTargetRemote field, clear it now
    //
    m_TargetHandle = NULL;
 
    //
    // m_TargetPdo and m_TargetFileObject will be cleared in the following call.
    //
    // m_TargetNotifyHandle is not cleared in the following call and is left
    // valid because we want to receive the notification about query remove being
    // canceled or completing.  When we receive either of those notifications,
    // m_TargetNotifyHandle will be freed then.
    //
    FxIoTarget::ClearTargetPointers(); // __super call
}

◆ Close()

VOID FxIoTargetRemote::Close ( __in FxIoTargetRemoteCloseReason Reason )

Definition at line 519 of file fxiotargetremote.cpp.

{
    FxIoTargetClearedPointers pointers;
    MdTargetNotifyHandle pNotifyHandle;
    SINGLE_LIST_ENTRY sent;
    LIST_ENTRY pended;
    WDF_IO_TARGET_STATE removeState;
    KIRQL irql;
    BOOLEAN wait;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    pFxDriverGlobals = GetDriverGlobals();
    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
        "enter:  WDFIOTARGET %p, reason %d", GetObjectHandle(), Reason);
 
    RtlZeroMemory(&pointers, sizeof(pointers));
    pNotifyHandle = NULL;
 
    sent.Next = NULL;
    InitializeListHead(&pended);
 
    wait = FALSE;
 
    //
    // Pick a value that is not used anywhere in the function and make sure that
    // we have changed it, before we go to the Remove state
    //
#pragma prefast(suppress: __WARNING_UNUSED_SCALAR_ASSIGNMENT, "PFD is warning that the following assignement is unused. Suppress it to prevent changing any logic.")
    removeState = WdfIoTargetStarted;
 
CheckState:
    Lock(&irql);
 
    //
    // If we are in the process of opening the target, wait for that to finish.
    //
    if (m_OpenState == FxIoTargetRemoteOpenStateOpening) {
        Unlock(irql);
 
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "Closing WDFIOTARGET %p which is opening, waiting on event %p",
            GetObjectHandle(), m_OpenedEvent.GetEvent());
 
        m_OpenedEvent.EnterCRAndWaitAndLeave();
 
        //
        // Jump back to the top and recheck
        //
        goto CheckState;
    }
 
    if (Reason == FxIoTargetRemoteCloseReasonDelete) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "Closing WDFIOTARGET %p, reason:   delete", GetObjectHandle());
 
        removeState = WdfIoTargetDeleted;
    }
    else if (m_OpenState == FxIoTargetRemoteOpenStateOpen) {
        if (Reason == FxIoTargetRemoteCloseReasonQueryRemove) {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                "Closing WDFIOTARGET %p, reason:   query remove",
                GetObjectHandle());
            //
            // Not really being removed, but that is what the API name is...
            //
            removeState = WdfIoTargetClosedForQueryRemove;
        }
        else {
 
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                "Closing WDFIOTARGET %p, reason:   close", GetObjectHandle());
 
            if (pFxDriverGlobals->IsVersionGreaterThanOrEqualTo(1,9)) {
                removeState = WdfIoTargetClosed;
            }
            else {
                removeState = WdfIoTargetClosedForQueryRemove;
            }
        }
 
        //
        // Either way, we are no longer open for business
        //
        m_OpenState = FxIoTargetRemoteOpenStateClosed;
    }
    else {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "Closing WDFIOTARGET %p which is not open", GetObjectHandle());
 
        //
        // We are not opened, so treat this as a cleanup
        //
        removeState = WdfIoTargetClosed;
    }
 
    DoTraceLevelMessage(
        pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
        "WDFIOTARGET %p:  fileobj %p, devobj %p, handle %p, notify handle %I64d",
        GetObjectHandle(), m_TargetFileObject,
        m_TargetDevice, m_TargetHandle, (UINT64)m_TargetNotifyHandle);
 
    if (Reason != FxIoTargetRemoteCloseReasonQueryRemove) {
        //
        // If we are closing for a query remove, we want to keep the handle
        // around so that we can be notified of the final close or if the close
        // was canceled.
        //
        pNotifyHandle = m_TargetNotifyHandle;
        ResetTargetNotifyHandle();
    }
 
    ASSERT(removeState != WdfIoTargetStarted);
    m_ClearedPointers =  &pointers;
    GotoRemoveState(removeState, &pended, &sent, FALSE, &wait);
 
    Unlock(irql);
 
    UnregisterForPnpNotification(pNotifyHandle);
 
    //
    // Complete any requests we might have pulled off of our lists
    //
    CompletePendedRequestList(&pended);
    _CancelSentRequests(&sent);
 
    //
    // We were just removed, wait for any I/O to complete back if necessary.
    //
    if (wait) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "WDFIOTARGET %p, waiting for stop to complete", GetObjectHandle());
 
        WaitForSentIoToComplete();
    }
 
    switch (Reason) {
    case FxIoTargetRemoteCloseReasonQueryRemove:
        //
        // m_OpenParams is needed for reopen on canceled query remove
        //
        DO_NOTHING();
        break;
 
    case FxIoTargetRemoteCloseReasonDelete:
        m_OpenParams.Clear();
        break;
 
    default:
        //
        // If this object is not about to be deleted, we need to revert some
        // of the state that just changed.
        //
        m_SentIoEvent.Clear();
        break;
    }
 
    if (removeState == WdfIoTargetDeleted) {
       WaitForDisposeEvent();
    }
 
    //
    // Finally, close down our handle and pointers
    //
    if (pointers.TargetPdo != NULL) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFIOTARGET %p derefing PDO %p on close",
            GetObjectHandle(), pointers.TargetPdo);
 
        Mx::MxDereferenceObject(pointers.TargetPdo);
    }
 
    if (pointers.TargetFileObject != NULL) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFIOTARGET %p derefing FileObj %p on close",
            GetObjectHandle(), pointers.TargetFileObject);
        Mx::MxDereferenceObject(pointers.TargetFileObject);
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
        CloseWdfFileObject(pointers.TargetFileObject);
#endif
    }
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
        UnbindHandle(&pointers);
#endif
 
    if (pointers.TargetHandle != NULL) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGIOTARGET,
            "WDFIOTARGET %p closing handle %p on close",
            GetObjectHandle(), pointers.TargetHandle);
        Mx::MxClose(pointers.TargetHandle);
    }
}

Referenced by FxIoTargetRemoteNotificationCallback::OnQueryRemove(), and FxIoTargetRemoteNotificationCallback::OnRemoveComplete().

◆ CloseTargetHandle()

VOID FxIoTargetRemote::CloseTargetHandle ( VOID )

◆ GetHandle()

__inline WDFIOTARGET FxIoTargetRemote::GetHandle ( VOID )

inline

Definition at line 274 of file fxiotargetremote.hpp.

    {
        return (WDFIOTARGET) GetObjectHandle();
    }

Referenced by FxIoTargetRemoteNotificationCallback::OnQueryRemove(), FxIoTargetRemoteNotificationCallback::OnRemoveCanceled(), and FxIoTargetRemoteNotificationCallback::OnRemoveComplete().

◆ GetTargetDeviceRelations()

NTSTATUS FxIoTargetRemote::GetTargetDeviceRelations ( _Out_ BOOLEAN * Close )

Definition at line 281 of file fxiotargetremotekm.cpp.

{
    PDEVICE_OBJECT pTopOfStack;
    FxAutoIrp irp(NULL);
    PIRP pIrp;
    NTSTATUS status;
 
    pTopOfStack = IoGetAttachedDeviceReference(m_TargetDevice);
 
    pIrp = IoAllocateIrp(pTopOfStack->StackSize, FALSE);
 
    if (pIrp != NULL) {
        PIO_STACK_LOCATION stack;
 
        irp.SetIrp(pIrp);
 
        stack = irp.GetNextIrpStackLocation();
        stack->MajorFunction = IRP_MJ_PNP;
        stack->MinorFunction = IRP_MN_QUERY_DEVICE_RELATIONS;
        stack->Parameters.QueryDeviceRelations.Type = TargetDeviceRelation;
 
        //
        // Initialize the status to error in case the bus driver decides not
        // to set it correctly.
        //
        irp.SetStatus(STATUS_NOT_SUPPORTED);
 
        status = irp.SendIrpSynchronously(pTopOfStack);
 
        if (NT_SUCCESS(status)) {
            PDEVICE_RELATIONS pRelations;
 
            pRelations = (PDEVICE_RELATIONS) irp.GetInformation();
 
            ASSERT(pRelations != NULL);
 
            //
            // m_TargetPdo was referenced by the bus driver, it will be
            // dereferenced when the target is closed.
            //
            m_TargetPdo = pRelations->Objects[0];
 
            //
            // We, as the caller, are responsible for freeing the relations
            // that the bus driver allocated.
            //
            ExFreePool(pRelations);
        }
        else {
            //
            // Could not retrieve the PDO pointer, error handled later
            //
            DO_NOTHING();
        }
    }
    else {
        //
        // Could not even allocate an irp, failure.
        //
        status = STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(
        GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
        "Unable to allocate memory for IRP WDFIOTARGET %p, %!STATUS!",
        GetObjectHandle(), status);
    }
 
    //
    // Only fail the open if we cannot allocate an irp or if the lower
    // driver could not allocate a relations.
    //
    if (status == STATUS_INSUFFICIENT_RESOURCES) {
        *Close = TRUE;
    }
    else {
        status = STATUS_SUCCESS;
    }
 
    //
    // Remove the reference taken by IoGetAttachedDeviceReference
    //
    ObDereferenceObject(pTopOfStack);
 
    return status;
}

Referenced by Open().

◆ GetTargetHandle()

HANDLE FxIoTargetRemote::GetTargetHandle ( VOID )

Definition at line 74 of file fxiotargetremotekm.hpp.

{
    return m_TargetHandle;
}

◆ InitRemote()

NTSTATUS FxIoTargetRemote::InitRemote ( __in FxDeviceBase * Device )

Definition at line 167 of file fxiotargetremote.cpp.

{
    NTSTATUS status;
 
    //
    // do the base class mode-specific initialization
    //
    status = FxIoTarget::InitModeSpecific(Device); // __super call
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // Do mode-specific initilialization
    //
    status = InitRemoteModeSpecific(Device);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    m_Driver = Device->GetDriver();
 
    SetDeviceBase(Device);
    m_InStackDevice = Device->GetDeviceObject();
 
    (void) Device->AddIoTarget(this);
 
    return STATUS_SUCCESS;
}

◆ InitRemoteModeSpecific()

NTSTATUS FxIoTargetRemote::InitRemoteModeSpecific ( __in FxDeviceBase * Device )

Definition at line 29 of file fxiotargetremotekm.hpp.

{
    UNREFERENCED_PARAMETER(Device);
 
    //
    // Nothing mode-specific work to do for KM here.
    //
    DO_NOTHING();
 
    return STATUS_SUCCESS;
}

Referenced by InitRemote().

◆ Open()

_Must_inspect_result_ NTSTATUS FxIoTargetRemote::Open ( __in PWDF_IO_TARGET_OPEN_PARAMS OpenParams )

Definition at line 201 of file fxiotargetremote.cpp.

{
    FxIoTargetRemoveOpenParams params, *pParams;
    UNICODE_STRING name;
    LIST_ENTRY pended;
    WDF_IO_TARGET_OPEN_TYPE type;
    NTSTATUS status;
    BOOLEAN close, reopen;
    PVOID pEa;
    ULONG eaLength;
    KIRQL irql;
 
    RtlZeroMemory(&name, sizeof(name));
    close = FALSE;
    reopen = OpenParams->Type == WdfIoTargetOpenReopen ? TRUE : FALSE;
 
    pEa = NULL;
    eaLength = 0;
 
    //
    // We only support reopening using stored settings when we open by name
    //
    if (reopen && m_OpenParams.OpenType != WdfIoTargetOpenByName) {
        status = STATUS_INVALID_DEVICE_REQUEST;
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Reopen only supported if the open type is WdfIoTargetOpenByName WDFIOTARGET %p %!STATUS!",
            GetObjectHandle(), status);
        return status;
    }
 
    //
    // Must preallocate all settings now
    //
    if (reopen) {
        //
        // convert the type into the type used for the previous open
        //
        type = m_OpenParams.OpenType;
        pParams = &m_OpenParams;
    }
    else {
        type = OpenParams->Type;
        pParams = &params;
 
        if (OpenParams->Type == WdfIoTargetOpenByName) {
 
            status = FxDuplicateUnicodeString(GetDriverGlobals(),
                                              &OpenParams->TargetDeviceName,
                                              &name);
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "Could not allocate memory for target name for WDFIOTARGET %p",
                    GetObjectHandle());
                goto Done;
            }
            if (OpenParams->EaBuffer != NULL && OpenParams->EaBufferLength > 0) {
 
                pEa = FxPoolAllocate(GetDriverGlobals(),
                                     PagedPool,
                                     OpenParams->EaBufferLength);
 
                if (pEa == NULL) {
                    DoTraceLevelMessage(
                        GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                        "Could not allocate memory for target name "
                        "for WDFIOTARGET %p", GetObjectHandle());
                    status = STATUS_INSUFFICIENT_RESOURCES;
                    goto Done;
                }
                else {
                    eaLength = OpenParams->EaBufferLength;
                    RtlCopyMemory(pEa, OpenParams->EaBuffer, eaLength);
                }
            }
        }
    }
 
    Lock(&irql);
 
    if (m_State == WdfIoTargetDeleted) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Opening WDFIOTARGET %p which is removed, state %d",
            GetObjectHandle(), m_State);
        status = STATUS_INVALID_DEVICE_STATE;
    }
    else if (m_OpenState != FxIoTargetRemoteOpenStateClosed) {
        //
        // We are either open or are opening
        //
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "Opening an already open WDFIOTARGET %p, open state %d",
            GetObjectHandle(), m_OpenState);
        status = STATUS_INVALID_DEVICE_STATE;
    }
    else {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
            "Opening WDFIOTARGET %p", GetObjectHandle());
 
        //
        // Clear the event so that if something is waiting on the state
        // transition, they will block until we are done.
        //
        m_OpenedEvent.Clear();
 
        m_OpenState = FxIoTargetRemoteOpenStateOpening;
        status = STATUS_SUCCESS;
    }
    Unlock(irql);
 
    if (!NT_SUCCESS(status)) {
        goto Done;
    }
 
    ASSERT(m_TargetFileObject == NULL);
    ASSERT(m_TargetDevice == NULL);
    ASSERT(m_TargetPdo == NULL);
    ASSERT(m_TargetHandle == NULL);
 
    //
    // m_TargetNotifyHandle can be a valid value if the caller has previously
    // opened the target, received a query remove, then a cancel remove, and
    // is now reopening the target.
    //
    UnregisterForPnpNotification(m_TargetNotifyHandle);
    ResetTargetNotifyHandle();
 
    //
    // Only clear the open parameters if we are not attempting a reopen.
    //
    if (reopen == FALSE) {
        m_OpenParams.Clear();
    }
 
    switch (type) {
    case WdfIoTargetOpenUseExistingDevice:
        KMDF_ONLY_CODE_PATH_ASSERT();
 
        //
        // OpenParams must be non NULL b/c we can't reopen a target with a
        // previous device object.
        //
        ASSERT(OpenParams->Type == WdfIoTargetOpenUseExistingDevice);
 
        m_TargetDevice = (MdDeviceObject) OpenParams->TargetDeviceObject;
        m_TargetFileObject = (MdFileObject) OpenParams->TargetFileObject;
        m_TargetHandle = NULL;
 
        //
        // By taking a manual reference here, we simplify the code in
        // FxIoTargetRemote::Close where we can assume there is an outstanding
        // reference on the PFILE_OBJECT at all times as long as we have a non
        // NULL pointer.
        //
        if (m_TargetFileObject != NULL) {
            Mx::MxReferenceObject(m_TargetFileObject);
        }
 
        status = STATUS_SUCCESS;
 
        break;
 
    case WdfIoTargetOpenLocalTargetByFile:
        UMDF_ONLY_CODE_PATH_ASSERT();
 
        status = OpenLocalTargetByFile(OpenParams);
        break;
 
    case WdfIoTargetOpenByName:
        //
        // Only capture the open parameters if we are not reopening.
        //
        if (reopen == FALSE) {
            pParams->Set(OpenParams, &name, pEa, eaLength);
        }
 
        status = OpenTargetHandle(OpenParams, pParams);
        if (NT_SUCCESS(status)) {
            if (reopen == FALSE) {
                m_OpenParams.Set(OpenParams, &name, pEa, eaLength);
 
                //
                // Setting pEa to NULL stops it from being freed later.
                // Zeroing out name stops it from being freed later.
                //
                pEa = NULL;
                RtlZeroMemory(&name, sizeof(name));
            }
        }
        else {
            close = TRUE;
        }
        break;
    }
 
    InitializeListHead(&pended);
 
    //
    // Get Target file object for KMDF. Noop for UMDF.
    //
    if (NT_SUCCESS(status)) {
        status = GetTargetDeviceRelations(&close);
    }
 
    if (NT_SUCCESS(status) && CanRegisterForPnpNotification()) {
        if (reopen == FALSE) {
            //
            // Set the values before the register so that if a notification
            // comes in before the register returns, we have a function to call.
            //
            m_EvtQueryRemove.m_Method = OpenParams->EvtIoTargetQueryRemove;
            m_EvtRemoveCanceled.m_Method = OpenParams->EvtIoTargetRemoveCanceled;
            m_EvtRemoveComplete.m_Method = OpenParams->EvtIoTargetRemoveComplete;
        }
 
        status = RegisterForPnpNotification();
 
        //
        // Even if we can't register, we still are successful in opening
        // up the device and we will proceed from there.
        //
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                "WDFIOTARGET %p, could not register pnp notification, %!STATUS! not "
                "treated as an error", GetObjectHandle(), status);
 
            m_EvtQueryRemove.m_Method = NULL;
            m_EvtRemoveCanceled.m_Method = NULL;
            m_EvtRemoveComplete.m_Method = NULL;
 
            status = STATUS_SUCCESS;
        }
    }
 
    //
    // UMDF only. Bind handle to remote dispatcher.
    //
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
    if (NT_SUCCESS(status) && type != WdfIoTargetOpenLocalTargetByFile) {
        status = BindToHandle();
        if (!NT_SUCCESS(status)) {
            close = TRUE;
        }
    }
#endif
 
    Lock(&irql);
 
    if (NT_SUCCESS(status)) {
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        m_TargetStackSize = m_TargetDevice->StackSize;
        m_TargetIoType = GetTargetIoType();
#endif
 
        m_OpenState = FxIoTargetRemoteOpenStateOpen;
 
        //
        // Set our state to started.  This will also resend any pended requests
        // due to a query remove.
        //
        status = GotoStartState(&pended, FALSE);
 
        //
        // We could not successfully start, close back down
        //
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
                "WDFIOTARGET %p could not transition to started state, %!STATUS!",
                GetObjectHandle(), status);
 
            close = TRUE;
        }
    }
    else {
        m_OpenState = FxIoTargetRemoteOpenStateClosed;
    }
 
    //
    // No matter what, indicate to any waiters that our state change has
    // completed.
    //
    m_OpenedEvent.Set();
 
    Unlock(irql);
 
Done:
    //
    // Resubmit any reads that were pended until now.
    //
    if (NT_SUCCESS(status)) {
        SubmitPendedRequests(&pended);
    }
    else if (close) {
        Close(FxIoTargetRemoteCloseReasonPlainClose);
    }
 
    if (name.Buffer != NULL) {
        FxPoolFree(name.Buffer);
    }
 
    if (pEa != NULL) {
        FxPoolFree(pEa);
    }
 
    return status;
}

Referenced by FxIoTargetRemoteNotificationCallback::OnRemoveCanceled().

◆ OpenLocalTargetByFile()

NTSTATUS FxIoTargetRemote::OpenLocalTargetByFile ( _In_ PWDF_IO_TARGET_OPEN_PARAMS OpenParams )

protected

Definition at line 58 of file fxiotargetremotekm.hpp.

{
    UNREFERENCED_PARAMETER(OpenParams);
 
    //
    // Nothing mode-specific work to do for KM here.
    //
    DO_NOTHING();
 
    return STATUS_SUCCESS;
}

Referenced by Open().

◆ OpenTargetHandle()

NTSTATUS FxIoTargetRemote::OpenTargetHandle	(	_In_ PWDF_IO_TARGET_OPEN_PARAMS	OpenParams,
		_Inout_ FxIoTargetRemoveOpenParams *	pParams
	)

Definition at line 203 of file fxiotargetremotekm.cpp.

{
    OBJECT_ATTRIBUTES oa;
    IO_STATUS_BLOCK ioStatus;
    NTSTATUS status;
 
    InitializeObjectAttributes(&oa,
                               &pParams->TargetDeviceName,
                               OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    status = ZwCreateFile(&m_TargetHandle,
                          pParams->DesiredAccess,
                          &oa,
                          &ioStatus,
                          pParams->AllocationSizePointer,
                          pParams->FileAttributes,
                          pParams->ShareAccess,
                          pParams->CreateDisposition,
                          pParams->CreateOptions,
                          pParams->EaBuffer,
                          pParams->EaBufferLength);
 
    OpenParams->FileInformation = (ULONG)ioStatus.Information;
 
    if (NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_WARNING, TRACINGIOTARGET,
            "ZwCreateFile for WDFIOTARGET %p returned status %!STATUS!, info 0x%x",
            GetObjectHandle(), status, (ULONG) ioStatus.Information);
 
        //
        // The open operation was successful. Dereference the file handle and
        // obtain a pointer to the device object for the handle.
        //
        status = ObReferenceObjectByHandle(
            m_TargetHandle,
            pParams->DesiredAccess,
            *IoFileObjectType,
            KernelMode,
            (PVOID*) &m_TargetFileObject,
            NULL);
 
        if (NT_SUCCESS(status)) {
            m_TargetDevice = IoGetRelatedDeviceObject(m_TargetFileObject);
 
            if (m_TargetDevice == NULL) {
                DoTraceLevelMessage(
                    GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                    "WDFIOTARGET %p, could not convert filobj %p to devobj",
                    GetObjectHandle(), m_TargetFileObject);
 
                status = STATUS_NO_SUCH_DEVICE;
            }
        }
        else {
            DoTraceLevelMessage(
                GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
                "WDFIOTARGET %p, could not convert handle %p to fileobject, "
                "status %!STATUS!",
                GetObjectHandle(), m_TargetHandle, status);
        }
    }
    else {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET,
            "ZwCreateFile for WDFIOTARGET %p returned status %!STATUS!, info 0x%x",
            GetObjectHandle(), status, (ULONG) ioStatus.Information);
    }
 
    return status;
}

Referenced by Open().

◆ QueryInterface()

_Must_inspect_result_ NTSTATUS FxIoTargetRemote::QueryInterface ( __in FxQueryInterfaceParams * Params )

inlineprotectedvirtual

Reimplemented from FxObject.

Definition at line 305 of file fxiotargetremote.hpp.

    {
        if (Params->Type == FX_TYPE_IO_TARGET_REMOTE) {
            *Params->Object = (FxIoTargetRemote*) this;
            return STATUS_SUCCESS;
        }
        else {
            return FxIoTarget::QueryInterface(Params); // __super call
        }
    }

◆ RegisterForPnpNotification()

NTSTATUS FxIoTargetRemote::RegisterForPnpNotification ( VOID )

Definition at line 143 of file fxiotargetremotekm.cpp.

{
    NTSTATUS status;
 
    //
    // Register for PNP notifications on the handle we just opened.
    // This will notify us of pnp state changes on the handle.
    //
    status = IoRegisterPlugPlayNotification(
        EventCategoryTargetDeviceChange,
        0,
        m_TargetFileObject,
        m_Driver->GetDriverObject(),
        _PlugPlayNotification,
        this,
        &m_TargetNotifyHandle);
 
    return status;
}

Referenced by Open().

◆ Remove()

VOID FxIoTargetRemote::Remove ( VOID )

virtual

Reimplemented from FxIoTarget.

Definition at line 764 of file fxiotargetremote.cpp.

{
    //
    // Close is the same as remove in this object
    //
    Close(FxIoTargetRemoteCloseReasonDelete);
 
    //
    // Do mode-specific work
    //
    RemoveModeSpecific();
 
    return ;
}

◆ RemoveModeSpecific()

VOID FxIoTargetRemote::RemoveModeSpecific ( VOID )

Definition at line 45 of file fxiotargetremotekm.hpp.

{
    //
    // Nothing mode-specific work to do for KM here.
    //
    DO_NOTHING();
}

Referenced by Remove().

◆ ResetTargetNotifyHandle()

VOID FxIoTargetRemote::ResetTargetNotifyHandle ( VOID )

inline

Definition at line 235 of file fxiotargetremote.hpp.

    {
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    m_TargetNotifyHandle = NULL;
#else // FX_CORE_USER_MODE
    m_TargetNotifyHandle = WUDF_TARGET_CONTEXT_INVALID;
#endif
    }

Referenced by Close(), and Open().

◆ UnregisterForPnpNotification()

VOID FxIoTargetRemote::UnregisterForPnpNotification ( _In_ MdTargetNotifyHandle Handle )

Definition at line 165 of file fxiotargetremotekm.cpp.

{
    if (Handle != NULL) {
 
        if (FxLibraryGlobals.IoUnregisterPlugPlayNotificationEx != NULL) {
            FxLibraryGlobals.IoUnregisterPlugPlayNotificationEx(Handle);
        }
        else {
            IoUnregisterPlugPlayNotification(Handle);
        }
    }
}

Referenced by Close(), and Open().

Member Data Documentation

◆ _PlugPlayNotification

_Must_inspect_result_ NTSTATUS STDCALL FxIoTargetRemote::_PlugPlayNotification

staticprotected

Definition at line 327 of file fxiotargetremote.hpp.

Referenced by RegisterForPnpNotification().

◆ m_ClearedPointers

FxIoTargetClearedPointers* FxIoTargetRemote::m_ClearedPointers

Definition at line 423 of file fxiotargetremote.hpp.

Referenced by ClearTargetPointers(), Close(), and FxIoTargetRemote().

◆ m_EvtQueryRemove

FxIoTargetQueryRemove FxIoTargetRemote::m_EvtQueryRemove

Definition at line 417 of file fxiotargetremote.hpp.

Referenced by FxIoTargetRemote(), FxIoTargetRemoteNotificationCallback::OnQueryRemove(), and Open().

◆ m_EvtRemoveCanceled

FxIoTargetRemoveCanceled FxIoTargetRemote::m_EvtRemoveCanceled

Definition at line 418 of file fxiotargetremote.hpp.

Referenced by FxIoTargetRemote(), FxIoTargetRemoteNotificationCallback::OnRemoveCanceled(), and Open().

◆ m_EvtRemoveComplete

FxIoTargetRemoveComplete FxIoTargetRemote::m_EvtRemoveComplete

Definition at line 419 of file fxiotargetremote.hpp.

Referenced by FxIoTargetRemote(), FxIoTargetRemoteNotificationCallback::OnRemoveComplete(), and Open().

◆ m_OpenedEvent

FxCREvent FxIoTargetRemote::m_OpenedEvent

Definition at line 421 of file fxiotargetremote.hpp.

Referenced by Close(), and Open().

◆ m_OpenParams

FxIoTargetRemoveOpenParams FxIoTargetRemote::m_OpenParams

protected

Definition at line 431 of file fxiotargetremote.hpp.

Referenced by Close(), and Open().

◆ m_OpenState

UCHAR FxIoTargetRemote::m_OpenState

Definition at line 428 of file fxiotargetremote.hpp.

Referenced by ClearTargetPointers(), Close(), FxIoTargetRemote(), and Open().

◆ m_TargetHandle

HANDLE FxIoTargetRemote::m_TargetHandle

Definition at line 404 of file fxiotargetremote.hpp.

Referenced by CanRegisterForPnpNotification(), ClearTargetPointers(), Close(), FxIoTargetRemote(), GetTargetHandle(), Open(), and OpenTargetHandle().

◆ m_TargetNotifyHandle

MdTargetNotifyHandle FxIoTargetRemote::m_TargetNotifyHandle

Definition at line 412 of file fxiotargetremote.hpp.

Referenced by Close(), FxIoTargetRemote(), FxIoTargetRemoteNotificationCallback::GetRegistrationId(), Open(), RegisterForPnpNotification(), and ResetTargetNotifyHandle().

The documentation for this class was generated from the following files:

sdk/lib/drivers/wdf/shared/inc/private/common/fxiotargetremote.hpp
sdk/lib/drivers/wdf/shared/inc/private/km/fxiotargetremotekm.hpp
sdk/lib/drivers/wdf/shared/targets/general/fxiotargetremote.cpp
sdk/lib/drivers/wdf/shared/targets/general/km/fxiotargetremotekm.cpp
sdk/lib/drivers/wdf/shared/targets/general/um/fxiotargetremoteum.cpp

Public Attributes
HANDLE	m_TargetHandle

MdTargetNotifyHandle	m_TargetNotifyHandle

FxIoTargetQueryRemove	m_EvtQueryRemove

FxIoTargetRemoveCanceled	m_EvtRemoveCanceled

FxIoTargetRemoveComplete	m_EvtRemoveComplete

FxCREvent	m_OpenedEvent

FxIoTargetClearedPointers *	m_ClearedPointers

UCHAR	m_OpenState

Public Attributes inherited from FxIoTarget
FxTransactionedEntry	m_TransactionedEntry

BOOLEAN	m_InStack

BOOLEAN	m_AddedToDeviceList

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~FxIoTargetRemote()

◆ FxIoTargetRemote()

Member Function Documentation

◆ _Create()

◆ CanRegisterForPnpNotification()

◆ ClearTargetPointers()

◆ Close()

◆ CloseTargetHandle()

◆ GetHandle()

◆ GetTargetDeviceRelations()

◆ GetTargetHandle()

◆ InitRemote()

◆ InitRemoteModeSpecific()

◆ Open()

◆ OpenLocalTargetByFile()

◆ OpenTargetHandle()

◆ QueryInterface()

◆ RegisterForPnpNotification()

◆ Remove()

◆ RemoveModeSpecific()

◆ ResetTargetNotifyHandle()

◆ UnregisterForPnpNotification()

Member Data Documentation

◆ _PlugPlayNotification

◆ m_ClearedPointers

◆ m_EvtQueryRemove

◆ m_EvtRemoveCanceled

◆ m_EvtRemoveComplete

◆ m_OpenedEvent

◆ m_OpenParams

◆ m_OpenState

◆ m_TargetHandle

◆ m_TargetNotifyHandle