WDFINTERRUPT GetHandle( VOID ) { return (WDFINTERRUPT) GetObjectHandle(); }
BOOL CEngineEffect::Init(char* filename,CObjectBase* pObject) { m_CurMotionNum = -1; m_bMotionPause = FALSE; m_pObject = pObject; DIRECTORYMGR->SetLoadMode(eLM_Effect); m_GXOHandle = GetObjectHandle(filename,MHEffectPROC,this,GXOBJECT_CREATE_TYPE_EFFECT); strcpy(m_ObjectName,filename); if(m_GXOHandle == NULL) { char temp[256]; sprintf(temp,"¿ÀºêÁ§Æ® »ý¼º ½ÇÆÐ : %s",filename); MessageBox(NULL,temp,NULL,NULL); DIRECTORYMGR->SetLoadMode(eLM_Root); return FALSE; } //g_pExecutive->DisablePick(m_GXOHandle); //EnableShadow(FALSE); m_AniInfo = new ANIINFO[2]; for(WORD n=0;n<2;++n) { m_AniInfo[n].EngineMotionIndex = n; m_AniInfo[n].StartFrame = 0; m_AniInfo[n].EndFrame = USHRT_MAX; } DIRECTORYMGR->SetLoadMode(eLM_Root); return TRUE; }
WDFCHILDLIST GetHandle( VOID ) { return (WDFCHILDLIST) GetObjectHandle(); }
__forceinline WDFDMAENABLER GetHandle( VOID ) { return (WDFDMAENABLER) GetObjectHandle(); }
FORCEINLINE WDFFILEOBJECT GetHandle( VOID ) { return (WDFFILEOBJECT) GetObjectHandle(); }
FORCEINLINE WDFDRIVER GetHandle( VOID ) { return (WDFDRIVER) GetObjectHandle(); }
_Must_inspect_result_ NTSTATUS FxIoTarget::InitModeSpecific( __in CfxDeviceBase* Device ) { NTSTATUS status; // // FxCREvent can fail in UMDF so it is initialized outside of constuctor // for UMDF. It always succeeds for KMDF so it gets initialized in // event's constructor. // status = m_SentIoEvent.Initialize(SynchronizationEvent, FALSE); if (!NT_SUCCESS(status)) { DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET, "Could not initialize m_SentIoEvent event for " "WFIOTARGET %p, %!STATUS!", GetObjectHandle(), status); return status; } status = m_DisposeEventUm.Initialize(); if (!NT_SUCCESS(status)) { DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET, "Could not initialize m_DisposeEventUm event for " "WFIOTARGET %p, %!STATUS!", GetObjectHandle(), status); return status; } return STATUS_SUCCESS; }
logical pc_ADK_Button :: SetupButton ( ) { PropertyHandle *pbc = GetParentProperty(); char *names = NULL; logical term = NO; DBObjectHandle dbo; names = strdup(GPH("sys_ident")->GetString()); SetupFromParent(); *GPH("auto_open") = YES; dbo = GetObjectHandle(); PropertyHandle buttons(dbo,"ADK_EventActionControl",PI_Read); PropertyHandle ph_default("_default"); if ( buttons(*GPH("sys_ident")) || buttons.Get(ph_default) ) GPH("button_control")->Add(buttons.ExtractKey()); return(term); }
logical pc_ADK_Field :: SetupColumn ( ) { PropertyHandle *pfc = GetParentProperty(); PropertyHandle *my_class = pfc->GPH("class"); PropertyHandle *member; logical coll_opt; char *type; char *propnames = NULL; logical term = NO; BEGINSEQ if ( IsInitialized() ) LEAVESEQ propnames = strdup(GPH("sys_ident")->GetString()); if ( !my_class->Get(FIRST_INSTANCE) ) ERROR pc_ADK_Class structure(*my_class); if ( member = structure.GetMember(propnames) ) coll_opt = pc0_SDB_Member(member).IsMultipleRef() ? YES : NO; else { pc_ADK_Class all_class(GetObjectHandle(),PI_Read); PropertyHandle phpropnames(propnames); if ( all_class.Get(phpropnames) ) { type = "DRT_Extent"; coll_opt = YES; } } *GPH("auto_open") = YES; *GPH("size.oszwdth") = -1; *GPH("size.oszhgth") = 20; SetupDataSource(propnames,type,coll_opt); SetupTitle(propnames); RECOVER term = YES; ENDSEQ if ( propnames ) free(propnames); return(term); }
VOID FxIoTargetRemote::ClearTargetPointers( VOID ) { 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. // __super::ClearTargetPointers(); }
logical pc_ADK_EventAction :: Setup ( ) { char *names = NULL; logical term = NO; names = strdup(GPH("sys_ident")->GetString()); PropertyHandle *pphAllign = GPH("allign"); pc_ADK_Allign(pphAllign).Setup(NO,NO); *GPH("auto_open") = YES; PropertyHandle actions(GetObjectHandle(),"ADK_EventActionControl",PI_Read); PropertyHandle ph_default("_default"); if ( actions(*GPH("sys_ident")) || actions.Get(ph_default) ) GPH("action_control")->Add(actions.ExtractKey()); else { *GPH("default_action.action_type") = "ACT_Function"; *names = toupper(*names); STRExchange(names,"_"," ",UNDEF); *GPH("text_definitions.title") = names; } return(term); }
VOID FxIoTargetRemote::Close( __in FxIoTargetRemoteCloseReason Reason ) { 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); } }
_Must_inspect_result_ NTSTATUS FxIoTargetRemote::Open( __in PWDF_IO_TARGET_OPEN_PARAMS OpenParams ) { 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 = ¶ms; 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; }
logical pc_ADK_Field :: SetupField ( ) { PropertyHandle *pfc = GetParentProperty(); PropertyHandle *my_class = pfc->GPH("class"); PropertyHandle *member; PropertyHandle *fc; logical vgrow = YES; logical hgrow = YES; logical coll_opt; char *ref_type; char *propnames = NULL; char strnames[ID_SIZE+1]; logical term = NO; BEGINSEQ if ( IsInitialized() ) LEAVESEQ propnames = strdup(GPH("sys_ident")->GetString()); SetupFromParent(); if ( !my_class->Get(FIRST_INSTANCE) ) ERROR pc_ADK_Class new_class(GetObjectHandle(),PI_Update); PropertyHandle extent(GetObjectHandle(),"SDB_Extend",PI_Read); PropertyHandle phpropnames(propnames); pc_ADK_Class structure(*my_class); if ( member = structure.GetMember(propnames) ) { if ( !(fc = new_class.ProvideDefaultControl(member,hgrow,vgrow)) || !fc->Exist() ) ERROR coll_opt = pc0_SDB_Member(member).IsMultipleRef() ? YES : NO; ref_type = "DRT_PropertyPath"; strcpy(strnames,member->GetString("ddetype")); } else if ( extent.Get(phpropnames) ) { if ( !(fc = new_class.ProvideDefaultControl(&extent,hgrow,vgrow)) || !fc->Exist() ) ERROR coll_opt = YES; ref_type = "DRT_Extent"; strcpy(strnames,extent.GetString("ddetype")); } else ERROR if ( !hgrow ) *GPH("allign.hori_sizing") = "SIZE_Fixed"; if ( !vgrow ) *GPH("allign.vert_sizing") = "SIZE_Fixed"; *GPH("auto_open") = YES; SetupDataSource(propnames,ref_type,coll_opt); SetupFromFieldControl(fc); SetupTitle(propnames); GPH("class")->Add(new_class.ExtractKey()); CTXCERR GPH("field_control")->Add(fc->ExtractKey()); CTXCERR RECOVER term = YES; ENDSEQ if ( propnames ) free(propnames); return(term); }
VOID FxIoTargetSelf::Send( _In_ MdIrp Irp ) /*++ Routine Description: send an MdIrp to the Self IO Target. Arguments: MdIrp for IRP_MJ_READ, IRP_MJ_WRITE, or IRP_MJ_DEVICE_CONTROL Returns: VOID Implementation Note: Function body inspired by WdfDeviceWdmDispatchIrpToIoQueue API. --*/ { FxIrp irp(Irp); FxIoQueue* queue; NTSTATUS status; UCHAR majorFunction; FxIoInCallerContext* ioInCallerCtx; #if (FX_CORE_MODE == FX_CORE_USER_MODE) // // Prepare the request to forward to the inteternal target. // (static_cast<IWudfIoIrp2*>(Irp))->PrepareToForwardToSelf(); #else // // Set Next Stack Location // irp.SetNextIrpStackLocation(); // // Set Device Object. // irp.SetCurrentDeviceObject(m_Device->GetDeviceObject()); #endif majorFunction = irp.GetMajorFunction(); // // Retrieve Queue // queue = GetDispatchQueue(majorFunction); if (queue == NULL) { DoTraceLevelMessage( GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET, "Send WDFIOTARGET %p, No Dispatch Queue Found for Major Function %d", GetObjectHandle(), majorFunction); status = STATUS_INVALID_DEVICE_STATE; goto Fail; } // // Only read/writes/ctrls/internal_ctrls IRPs are allowed to be sent to // Self IO Target // if (m_Device->GetDispatchPackage(majorFunction) != m_Device->m_PkgIo) { status = STATUS_INVALID_PARAMETER; DoTraceLevelMessage( GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGIOTARGET, "Only Read/Write/Control/Internal-Control IRPs can be " "forwarded to Self IO Target 0x%p, %!IRPMJ!, " "IRP_MN %x, Device 0x%p, %!STATUS!", GetHandle(), majorFunction, irp.GetMinorFunction(), m_Device->GetObjectHandle(), status); FxVerifierDbgBreakPoint(GetDriverGlobals()); goto Fail; } // // Retrieve the InContextCallback function // ioInCallerCtx = m_Device->m_PkgIo->GetIoInCallerContextCallback( queue->GetCxDeviceInfo()); // // DispatchStep2 will convert the IRP into a WDFREQUEST, queue it and if // possible dispatch the request to the driver. // If a failure occurs, DispatchStep2 completes teh Irp // (VOID) m_Device->m_PkgIo->DispatchStep2(Irp, ioInCallerCtx, queue); return; Fail: irp.SetStatus(status); irp.SetInformation(0); irp.CompleteRequest(IO_NO_INCREMENT); return; }