static VOID XenNet_ResumeWorkItem(PDEVICE_OBJECT device_object, PVOID context) { struct xennet_info *xi = context; KIRQL old_irql; UNREFERENCED_PARAMETER(device_object); FUNCTION_ENTER(); ASSERT(xi->resume_work_item); IoFreeWorkItem(xi->resume_work_item); XenNet_TxResumeStart(xi); XenNet_RxResumeStart(xi); XenNet_ConnectBackend(xi); XenNet_RxResumeEnd(xi); XenNet_TxResumeEnd(xi); KeAcquireSpinLock(&xi->resume_lock, &old_irql); xi->resume_work_item = NULL; KdPrint((__DRIVER_NAME " *Setting suspend_resume_state_fdo = %d\n", xi->device_state->suspend_resume_state_pdo)); xi->device_state->suspend_resume_state_fdo = xi->device_state->suspend_resume_state_pdo; KdPrint((__DRIVER_NAME " *Notifying event channel %d\n", xi->device_state->pdo_event_channel)); xi->vectors.EvtChn_Notify(xi->vectors.context, xi->device_state->pdo_event_channel); KeReleaseSpinLock(&xi->resume_lock, old_irql); FUNCTION_EXIT(); }
VOID UnplugWorker( IN PDEVICE_OBJECT DeviceObject, IN PVOID Context ){ NTSTATUS status; PNDBUS_UNPLUGWORKER ctx = (PNDBUS_UNPLUGWORKER)Context; NDASBUS_UNPLUG_HARDWARE unplug; UNREFERENCED_PARAMETER(DeviceObject); // // IO_WORKITEM is rare resource, give it back to the system now. // IoFreeWorkItem(ctx->IoWorkItem); // // Start unplug // unplug.Size = sizeof(unplug); unplug.SlotNo = ctx->SlotNo; status = Bus_UnPlugDevice(&unplug, ctx->FdoData); ASSERT(NT_SUCCESS(status)); ExFreePool(Context); }
KWorkItem:: ~KWorkItem() /*++ Routine Description: Destructor. Blocks until all references are released, then frees the workitem. Arguments: None. Return Value: None. --*/ { // Make sure the work item has been run down. Wait(); // Now delete it. if( m_WorkItem ) { IoFreeWorkItem( m_WorkItem ); } }
VOID NTAPI CdRomDeAllocateMmcResources( IN PDEVICE_OBJECT Fdo ) { PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension; PCDROM_DATA cddata = commonExtension->DriverData; PCDROM_MMC_EXTENSION mmcData = &cddata->Mmc; //NTSTATUS status; if (mmcData->CapabilitiesWorkItem) { IoFreeWorkItem(mmcData->CapabilitiesWorkItem); mmcData->CapabilitiesWorkItem = NULL; } if (mmcData->CapabilitiesIrp) { IoFreeIrp(mmcData->CapabilitiesIrp); mmcData->CapabilitiesIrp = NULL; } if (mmcData->CapabilitiesMdl) { IoFreeMdl(mmcData->CapabilitiesMdl); mmcData->CapabilitiesMdl = NULL; } if (mmcData->CapabilitiesBuffer) { ExFreePool(mmcData->CapabilitiesBuffer); mmcData->CapabilitiesBuffer = NULL; } mmcData->CapabilitiesBuffer = 0; mmcData->IsMmc = FALSE; mmcData->WriteAllowed = FALSE; return; }
_IRQL_requires_same_ inline VOID KrnlHlprWorkItemDataPurge(_Inout_ WORKITEM_DATA* pWorkItemData) { #if DBG DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_INFO_LEVEL, " ---> KrnlHlprWorkItemDataPurge()\n"); #endif /// DBG NT_ASSERT(pWorkItemData); if(pWorkItemData->pIOWorkItem) IoFreeWorkItem(pWorkItemData->pIOWorkItem); RtlZeroMemory(pWorkItemData, sizeof(WORKITEM_DATA)); #if DBG DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_INFO_LEVEL, " <--- KrnlHlprWorkItemDataPurge()\n"); #endif /// DBG return; }
static NTSTATUS Pkt0DispatchWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp) { PIO_WORKITEM work_item; KIRQL old_irql; NTSTATUS status; work_item = IoAllocateWorkItem(DeviceObject); if (work_item == NULL) { return Pkt0CompleteIrp(Irp, STATUS_INSUFFICIENT_RESOURCES, 0); } KeAcquireSpinLock(&Pkt0ContextLock, &old_irql); if (Pkt0Context->closing) { status = Pkt0CompleteIrp(Irp, STATUS_PIPE_CLOSING, 0); } else { InsertTailList(&Pkt0Context->irp_write_queue, &Irp->Tail.Overlay.ListEntry); IoMarkIrpPending(Irp); status = STATUS_PENDING; } KeReleaseSpinLock(&Pkt0ContextLock, old_irql); if (status == STATUS_PENDING) { IoQueueWorkItemEx(work_item, Pkt0DeferredWrite, DelayedWorkQueue, NULL); } else { IoFreeWorkItem(work_item); } return status; }
VOID Secondary_Dereference ( IN PSECONDARY Secondary ) { LONG result; result = InterlockedDecrement (&Secondary->ReferenceCount); ASSERT (result >= 0); if (result == 0) { PVOLUME_DEVICE_OBJECT volDo = Secondary->VolDo; ASSERT( Secondary->TryCloseActive == FALSE ); if (Secondary->TryCloseWorkItem) IoFreeWorkItem( Secondary->TryCloseWorkItem ); NDAS_ASSERT( Secondary->ThreadHandle == NULL ); ExFreePoolWithTag( Secondary, NDASFAT_ALLOC_TAG ); DebugTrace2( 0, Dbg2, ("Secondary_Dereference: Secondary is Freed Secondary = %p\n", Secondary) ); DebugTrace2( 0, Dbg2, ("Secondary_Dereference: voldo->Reference = %d\n", volDo->ReferenceCount) ); VolDo_Dereference( volDo ); } }
VOID DDKAPI LklDequeueRequest(IN PDEVICE_OBJECT device, IN PVOID context) { NTSTATUS status; PIRPCONTEXT irp_context; irp_context = (PIRPCONTEXT) context; ASSERT(irp_context); ASSERT(irp_context->id.type == IRP_CONTEXT && irp_context->id.size == sizeof(IRPCONTEXT)); IoFreeWorkItem(irp_context->work_item); if (FLAG_ON(irp_context->flags, VFS_IRP_CONTEXT_NOT_TOP_LEVEL)) IoSetTopLevelIrp((PIRP)FSRTL_FSP_TOP_LEVEL_IRP); SET_FLAG(irp_context->flags, VFS_IRP_CONTEXT_CAN_BLOCK); FsRtlEnterFileSystem(); status = LklDispatchRequest(irp_context); FsRtlExitFileSystem(); IoSetTopLevelIrp(NULL); }
VOID FatUnload( _In_ _Unreferenced_parameter_ PDRIVER_OBJECT DriverObject ) /*++ Routine Description: This is the unload routine for the filesystem Arguments: DriverObject - Pointer to driver object created by the system. Return Value: None --*/ { UNREFERENCED_PARAMETER( DriverObject ); ExDeleteNPagedLookasideList (&FatEResourceLookasideList); ExDeleteNPagedLookasideList (&FatNonPagedFcbLookasideList); ExDeleteNPagedLookasideList (&FatIrpContextLookasideList); ExDeleteResourceLite( &FatData.Resource ); IoFreeWorkItem (FatData.FatCloseItem); ObDereferenceObject( FatDiskFileSystemDeviceObject); ObDereferenceObject( FatCdromFileSystemDeviceObject); }
NTSTATUS ResponsePortAskWorkerForIndicateupPacket(PDEVICE_OBJECT DeviceObject, PVOID pContext) { PASKUserWorkItemContext pPAskContext=NULL; NTSTATUS status = STATUS_SUCCESS; PAcceptedPort pIndicateContext=NULL; KIRQL CIrql=0, CIrql2=0; //__asm int 3 CIrql = KeGetCurrentIrql(); pPAskContext = (PASKUserWorkItemContext)pContext; if (pPAskContext==NULL) { return status; } pIndicateContext = (PAcceptedPort)pPAskContext->pContext; IoFreeWorkItem(pPAskContext->pWorkItem); kfree(pPAskContext); //自定义向上提交一份 status = BypassTcpipArpRcv((NDIS_HANDLE)pIndicateContext->ProtocolBindingContext, (NDIS_HANDLE)pIndicateContext->MacReceiveContext, pIndicateContext->HeaderBuffer, pIndicateContext->HeaderBufferSize,\ pIndicateContext->LookAheadBuffer, pIndicateContext->LookAheadBufferSize, pIndicateContext->LookAheadBufferSize); if (KeGetCurrentIrql()>CIrql) { KeLowerIrql(CIrql); } if (KeGetCurrentIrql()<CIrql) { KeRaiseIrql(CIrql, &CIrql2); } kfree(pIndicateContext); return status; }
VOID IoctlWorkItemEx( _In_ PVOID IoObject, _In_opt_ PVOID Context, _In_ PIO_WORKITEM IoWorkItem ) { PDEVICE_OBJECT device = (PDEVICE_OBJECT) IoObject; PIRP irp = (PIRP) Context; NTSTATUS status; PAGED_CODE(); // // Process the IOCTL. // if (irp != NULL) { status = HidUmdfInternalIoctlWorker(device, irp); if (!NT_SUCCESS(status)) { // // The IRP has either been sent down the stack or been completed by the // HidUmdfInternalIoctlWorker function. Also, we already returned pending // status from original thread so ignore status here. // } } // // Free the workitem // IoFreeWorkItem(IoWorkItem); }
void DtraceUnload(PDRIVER_OBJECT DrvObj) { NTSTATUS st; LARGE_INTEGER tm; ZwUnloadDriver(&fbtsys); ZwUnloadDriver(&profilesys); ZwUnloadDriver(&fttpsys); while (dtrace_ref != 0 || dtrace_unload(DrvObj) != 0) { tm.QuadPart = UNLOAD_RETRY_DELAY_TIME; dprintf("dtrace.sys: Unload failed. Retry in %ds\n", abs(UNLOAD_RETRY_DELAY_TIME)/10000000); KeDelayExecutionThread(KernelMode, FALSE, &tm); } PsRemoveLoadImageNotifyRoutine(ProcKernelModuleLoaded); free_thread_list(); free_proc_list(); IoFreeWorkItem(WorkItem1); int_freecore(); IoDeleteSymbolicLink(&deviceLink); IoDeleteSymbolicLink(&deviceHelperLink); IoDeleteDevice(DrvObj->DeviceObject); }
VOID EXPORT NdisFreeIoWorkItem( IN NDIS_HANDLE NdisIoWorkItemHandle) { PNDIS_IO_WORKITEM WorkItem = NdisIoWorkItemHandle; IoFreeWorkItem(WorkItem); }
VOID Secondary_Dereference ( IN PSECONDARY Secondary ) { LONG result; result = InterlockedDecrement (&Secondary->ReferenceCount); ASSERT (result >= 0); if (result == 0) { PVOLUME_DEVICE_OBJECT volDo = Secondary->VolDo; #if __NDAS_NTFS_DBG__ BOOLEAN acquired; acquired = SecondaryAcquireResourceExclusiveLite( NULL, &volDo->RecoveryResource, TRUE ); if (acquired) SecondaryReleaseResourceLite( NULL, &volDo->RecoveryResource ); else ASSERT( FALSE ); acquired = SecondaryAcquireResourceExclusiveLite( NULL, &volDo->Resource, TRUE ); if (acquired) SecondaryReleaseResourceLite( NULL, &volDo->Resource ); else ASSERT( FALSE ); acquired = SecondaryAcquireResourceExclusiveLite( NULL, &volDo->CreateResource, TRUE ); if (acquired) SecondaryReleaseResourceLite( NULL, &volDo->CreateResource ); else ASSERT( FALSE ); acquired = SecondaryAcquireResourceExclusiveLite( NULL, &volDo->SessionResource, TRUE ); if (acquired) SecondaryReleaseResourceLite( NULL, &volDo->SessionResource ); else ASSERT( FALSE ); #endif ASSERT( Secondary->TryCloseActive == FALSE ); if (Secondary->TryCloseWorkItem) IoFreeWorkItem( Secondary->TryCloseWorkItem ); NDASNTFS_ASSERT( Secondary->ThreadHandle == NULL ); ExFreePoolWithTag( Secondary, NDASNTFS_ALLOC_TAG ); DebugTrace2( 0, Dbg2, ("Secondary_Dereference: Secondary is Freed Secondary = %p\n", Secondary) ); DebugTrace2( 0, Dbg2, ("Secondary_Dereference: voldo->Reference = %d\n", volDo->ReferenceCount) ); VolDo_Dereference( volDo ); } }
VOID GetSysModInfo( IN PDEVICE_OBJECT DeviceObject, IN PVOID Context ) { PIO_WORKITEM wi = (PIO_WORKITEM)Context; UpdateSysModuleList(); IoFreeWorkItem(wi); }
VOID TunerScanWorkItem(IN PDEVICE_OBJECT DeviceObject,IN PVOID Context) { HANDLE handle; NTSTATUS WaitStatus; UNREFERENCED_PARAMETER(DeviceObject); PEventHandlerData EventBlock= static_cast<PEventHandlerData>( Context); DbgPrint("MY-Event::TunerScanWorkItem"); OBJECT_ATTRIBUTES oa; InitializeObjectAttributes(&oa, NULL, OBJ_KERNEL_HANDLE, NULL, NULL); if (STATUS_SUCCESS != PsCreateSystemThread(&handle, THREAD_ALL_ACCESS, &oa, NULL, NULL, ScanThread, EventBlock)) { return; } ObReferenceObjectByHandle(handle, THREAD_ALL_ACCESS, NULL, KernelMode, (PVOID*) &EventBlock->thread, NULL); KeSetEvent(&(EventBlock->InitEvent), 0,FALSE); ZwClose(handle); do { WaitStatus = KeWaitForSingleObject(&(EventBlock->TuneEvent), Executive, KernelMode, FALSE, NULL); if (!NT_SUCCESS(WaitStatus)) { break; } if(EventBlock->bStopScan) { StopPollingThread(); KsGenerateEvent(EventBlock->EventEntry);//fire an Event to the app that we are stopped break; } CEncoderDevice* EncDevice = EventBlock->pDevice; EncDevice->CurrentFrequency = EventBlock->CurrentFrequency; KeClearEvent(&(EventBlock->TuneEvent)); DbgPrint( "MY-TunerScanWorkItem : Firing an event from driver to the app\n"); KsGenerateEvent(EventBlock->EventEntry); #pragma warning(push) #pragma warning(disable:4127) }while(1); #pragma warning (pop) DbgPrint( "MY-TunerScanWorkItem terminating\n"); IoFreeWorkItem(EventHandler->ThreadItem); // Release Work Item EventHandler->EventEntry = NULL; ExFreePoolWithTag(EventHandler, MS_SAMPLE_ANALOG_POOL_TAG); EventHandler = NULL; }
NTSTATUS KrnlHlprWorkItemQueue(_In_ PDEVICE_OBJECT pWDMDevice, _In_ IO_WORKITEM_ROUTINE* pWorkItemFn) { #if DBG DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_INFO_LEVEL, " ---> KrnlHlprWorkItemQueue()\n"); #endif /// DBG NT_ASSERT(pWDMDevice); NT_ASSERT(pWorkItemFn); NTSTATUS status = STATUS_SUCCESS; PIO_WORKITEM pIOWorkItem = 0; #pragma warning(push) #pragma warning(disable: 6014) /// pIOWorkItem is cleaned up in pWorkItemFn pIOWorkItem = IoAllocateWorkItem(pWDMDevice); if(pIOWorkItem == 0) { status = STATUS_UNSUCCESSFUL; DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_ERROR_LEVEL, " !!!! KrnlHlprWorkItemQueue : IoAllocateWorkItem() [status: %#x]\n", status); HLPR_BAIL; } #pragma warning(pop) IoQueueWorkItem(pIOWorkItem, pWorkItemFn, DelayedWorkQueue, (PVOID)pIOWorkItem); HLPR_BAIL_LABEL: if(status != STATUS_SUCCESS && pIOWorkItem) IoFreeWorkItem(pIOWorkItem); #if DBG DbgPrintEx(DPFLTR_IHVNETWORK_ID, DPFLTR_INFO_LEVEL, " <--- KrnlHlprWorkItemQueue() [status: %#x]\n", status); #endif /// DBG return status; }
VOID FatUnload( IN PDRIVER_OBJECT DriverObject ) /*++ Routine Description: This is the unload routine for the filesystem Arguments: DriverObject - Pointer to driver object created by the system. Return Value: None --*/ { #ifdef __ND_FAT__ UNICODE_STRING linkString; #endif #if DBG DbgPrint( "NdNtfs FatUnload %s %s\n", __DATE__, __TIME__ ); #endif ExDeleteNPagedLookasideList (&FatEResourceLookasideList); ExDeleteNPagedLookasideList (&FatNonPagedFcbLookasideList); ExDeleteNPagedLookasideList (&FatIrpContextLookasideList); ExDeleteResourceLite( &FatData.Resource ); IoFreeWorkItem (FatData.FatCloseItem); ObDereferenceObject( FatDiskFileSystemDeviceObject); ObDereferenceObject( FatCdromFileSystemDeviceObject); #ifdef __ND_FAT__ RtlInitUnicodeString( &linkString, L"\\DosDevices\\NdFatControl" ); IoDeleteSymbolicLink( &linkString ); DebugTrace2( 0, Dbg2, ("NdFatUnload occured NdFatControlDeviceObject->ReferenceCount = %x\n", FatControlDeviceObject->ReferenceCount) ); IoDeleteDevice( FatControlDeviceObject ); DebugTrace2( 0, Dbg2, ("NdFatUnload occured NdFatFileSystemDeviceObject->ReferenceCount = %x\n", FatDiskFileSystemDeviceObject->ReferenceCount) ); IoDeleteDevice( FatDiskFileSystemDeviceObject ); IoDeleteDevice( FatCdromFileSystemDeviceObject ); #endif }
static VOID vboxUsbPwrIoWaitCompletionAndPostAsyncWorker(IN PDEVICE_OBJECT pDeviceObject, IN PVOID pvContext) { PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pDeviceObject->DeviceExtension; PVBOXUSB_IOASYNC_CTX pCtx = (PVBOXUSB_IOASYNC_CTX)pvContext; PIRP pIrp = pCtx->pIrp; vboxUsbPwrIoPostDev(pDevExt, pIrp); IoFreeWorkItem(pCtx->pWrkItem); vboxUsbMemFree(pCtx); }
VOID NTAPI HoldIoRequestsWorkerRoutine(IN PDEVICE_OBJECT DeviceObject, IN PVOID Context) { PIRP irp; NTSTATUS ntStatus; PDEVICE_EXTENSION deviceExtension; PWORKER_THREAD_CONTEXT context; FreeBT_DbgPrint(3, ("FBTUSB: HoldIoRequestsWorkerRoutine: Entered\n")); deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension; context = (PWORKER_THREAD_CONTEXT) Context; irp = (PIRP) context->Irp; // wait for I/O in progress to finish. // the stop event is signalled when the counter drops to 1. // invoke FreeBT_IoDecrement twice: once each for the S-Irp and D-Irp. FreeBT_DbgPrint(3, ("FBTUSB: HoldIoRequestsWorkerRoutine::")); FreeBT_IoDecrement(deviceExtension); FreeBT_DbgPrint(3, ("FBTUSB: HoldIoRequestsWorkerRoutine::")); FreeBT_IoDecrement(deviceExtension); KeWaitForSingleObject(&deviceExtension->StopEvent, Executive, KernelMode, FALSE, NULL); // Increment twice to restore the count FreeBT_DbgPrint(3, ("FBTUSB: HoldIoRequestsWorkerRoutine::")); FreeBT_IoIncrement(deviceExtension); FreeBT_DbgPrint(3, ("FBTUSB: HoldIoRequestsWorkerRoutine::")); FreeBT_IoIncrement(deviceExtension); // now send the Irp down IoCopyCurrentIrpStackLocationToNext(irp); IoSetCompletionRoutine( irp, (PIO_COMPLETION_ROUTINE) FinishDevPoDnIrp, deviceExtension, TRUE, TRUE, TRUE); ntStatus = PoCallDriver(deviceExtension->TopOfStackDeviceObject, irp); if(!NT_SUCCESS(ntStatus)) { FreeBT_DbgPrint(1, ("FBTUSB: HoldIoRequestsWorkerRoutine: Lower driver fail a power Irp\n")); } IoFreeWorkItem(context->WorkItem); ExFreePool((PVOID)context); FreeBT_DbgPrint(3, ("FBTUSB: HoldIoRequestsWorkerRoutine: Leaving\n")); }
static VOID XenNet_SuspendResume(PKDPC dpc, PVOID context, PVOID arg1, PVOID arg2) { struct xennet_info *xi = context; KIRQL old_irql; PIO_WORKITEM resume_work_item; UNREFERENCED_PARAMETER(dpc); UNREFERENCED_PARAMETER(arg1); UNREFERENCED_PARAMETER(arg2); FUNCTION_ENTER(); switch (xi->device_state->suspend_resume_state_pdo) { case SR_STATE_SUSPENDING: KdPrint((__DRIVER_NAME " New state SUSPENDING\n")); KeAcquireSpinLock(&xi->rx_lock, &old_irql); if (xi->rx_id_free == NET_RX_RING_SIZE) { xi->device_state->suspend_resume_state_fdo = SR_STATE_SUSPENDING; KdPrint((__DRIVER_NAME " Notifying event channel %d\n", xi->device_state->pdo_event_channel)); xi->vectors.EvtChn_Notify(xi->vectors.context, xi->device_state->pdo_event_channel); } KeReleaseSpinLock(&xi->rx_lock, old_irql); break; case SR_STATE_RESUMING: KdPrint((__DRIVER_NAME " New state SR_STATE_RESUMING\n")); /* do it like this so we don't race and double-free the work item */ resume_work_item = IoAllocateWorkItem(xi->fdo); KeAcquireSpinLock(&xi->resume_lock, &old_irql); if (xi->resume_work_item || xi->device_state->suspend_resume_state_fdo == SR_STATE_RESUMING) { KeReleaseSpinLock(&xi->resume_lock, old_irql); IoFreeWorkItem(resume_work_item); return; } xi->resume_work_item = resume_work_item; KeReleaseSpinLock(&xi->resume_lock, old_irql); IoQueueWorkItem(xi->resume_work_item, XenNet_ResumeWorkItem, DelayedWorkQueue, xi); break; default: KdPrint((__DRIVER_NAME " New state %d\n", xi->device_state->suspend_resume_state_fdo)); xi->device_state->suspend_resume_state_fdo = xi->device_state->suspend_resume_state_pdo; KdPrint((__DRIVER_NAME " Notifying event channel %d\n", xi->device_state->pdo_event_channel)); xi->vectors.EvtChn_Notify(xi->vectors.context, xi->device_state->pdo_event_channel); break; } KeMemoryBarrier(); FUNCTION_EXIT(); }
//.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.- DtWorkItemStructDelete -.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-. // static DtStatus DtWorkItemStructDelete(DtWorkItemStruct* pWorkItemStruct) { #ifdef WINBUILD #ifdef USES_NDIS // Nothing to do #else IoFreeWorkItem(pWorkItemStruct->m_pIoWorkItem); #endif // USES_NDIS #else //kfree(pWorkItemStruct->m_pWork); #endif return DT_STATUS_OK; }
VOID Log_WriteWorker(_In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PVOID Context, _In_ PIO_WORKITEM IoWorkItem) { UNREFERENCED_PARAMETER(DeviceObject); PLOG_COUNTED_STRING line = Context; ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL); Log_WriteLine(line); InterlockedDecrement(&LogScheduledPrints); IoFreeWorkItem(IoWorkItem); ExFreePoolWithTag(Context, LogAllocationTag); }
static VOID NTAPI V4vDehibernateWorkItem(PDEVICE_OBJECT fdo, PVOID ctx) { PIO_WORKITEM wi = (PIO_WORKITEM)ctx; if (xenbus_await_initialisation()) { (VOID)V4vInitializeEventChannel(fdo); TraceNotice(("dehibrination work item initialized VIRQ.\n")); } else { TraceError(("wait for XENBUS initialization failed, cannot connect VIRQ.\n")); } IoFreeWorkItem(wi); }
static VOID WriteErrorLogWorker( IN PDEVICE_OBJECT DeviceObject, IN PVOID Context ){ PLSU_ERRORLOGCTX errorLogCtx = (PLSU_ERRORLOGCTX)Context; UNREFERENCED_PARAMETER(DeviceObject); _WriteLogErrorEntry(DeviceObject, &errorLogCtx->ErrorLogEntry); IoFreeWorkItem(errorLogCtx->IoWorkItem); ExFreePoolWithTag(errorLogCtx, LSU_POOLTAG_ERRORLOGWORKER); }
VOID NTAPI ChewWorkItem(PDEVICE_OBJECT DeviceObject, PVOID ChewItem) { PWORK_ITEM WorkItem = ChewItem; KIRQL OldIrql; WorkItem->Worker(WorkItem->WorkerContext); IoFreeWorkItem(WorkItem->WorkItem); KeAcquireSpinLock(&WorkQueueLock, &OldIrql); RemoveEntryList(&WorkItem->Entry); if (IsListEmpty(&WorkQueue)) KeSetEvent(&WorkQueueClear, 0, FALSE); KeReleaseSpinLock(&WorkQueueLock, OldIrql); ExFreePoolWithTag(WorkItem, CHEW_TAG); }
static VOID NTAPI SerialReadWorkItem( IN PDEVICE_OBJECT DeviceObject, IN PVOID pWorkItemData /* real type PWORKITEM_DATA */) { PWORKITEM_DATA WorkItemData; PIRP Irp; TRACE_(SERIAL, "SerialReadWorkItem() called\n"); WorkItemData = (PWORKITEM_DATA)pWorkItemData; Irp = WorkItemData->Irp; ReadBytes(DeviceObject, Irp, WorkItemData); IoCompleteRequest(Irp, IO_NO_INCREMENT); IoFreeWorkItem(WorkItemData->IoWorkItem); ExFreePoolWithTag(pWorkItemData, SERIAL_TAG); }
VOID CdUnload( __in PDRIVER_OBJECT DriverObject ) /*++ Routine Description: This routine unload routine for CDFS. Arguments: DriverObject - Supplies the driver object for CDFS. Return Value: None. --*/ { PIRP_CONTEXT IrpContext; PAGED_CODE(); UNREFERENCED_PARAMETER( DriverObject ); // // Free any IRP contexts // while (1) { IrpContext = (PIRP_CONTEXT) PopEntryList( &CdData.IrpContextList) ; if (IrpContext == NULL) { break; } CdFreePool(&IrpContext); } IoFreeWorkItem (CdData.CloseItem); ExDeleteResourceLite( &CdData.DataResource ); ObDereferenceObject (CdData.FileSystemDeviceObject); }
//============================================================================= void CSaveData::DestroyWorkItems ( void ) { PAGED_CODE(); if (m_pWorkItems) { for (int i = 0; i < MAX_WORKER_ITEM_COUNT; i++) { if (m_pWorkItems[i].WorkItem!=NULL) { IoFreeWorkItem(m_pWorkItems[i].WorkItem); m_pWorkItems[i].WorkItem = NULL; } } ExFreePoolWithTag(m_pWorkItems, SAVEDATA_POOLTAG); m_pWorkItems = NULL; } } // DestroyWorkItems
VOID NTAPI i8042SendHookWorkItem( IN PDEVICE_OBJECT DeviceObject, IN PVOID Context) { PI8042_HOOK_WORKITEM WorkItemData; PFDO_DEVICE_EXTENSION FdoDeviceExtension; PPORT_DEVICE_EXTENSION PortDeviceExtension; PDEVICE_OBJECT TopOfStack = NULL; ULONG IoControlCode; PVOID InputBuffer; ULONG InputBufferLength; IO_STATUS_BLOCK IoStatus; KEVENT Event; PIRP NewIrp; NTSTATUS Status; TRACE_(I8042PRT, "i8042SendHookWorkItem(%p %p)\n", DeviceObject, Context); WorkItemData = (PI8042_HOOK_WORKITEM)Context; FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension; PortDeviceExtension = FdoDeviceExtension->PortDeviceExtension; switch (FdoDeviceExtension->Type) { case Keyboard: { PI8042_KEYBOARD_EXTENSION DeviceExtension; DeviceExtension = (PI8042_KEYBOARD_EXTENSION)FdoDeviceExtension; IoControlCode = IOCTL_INTERNAL_I8042_HOOK_KEYBOARD; InputBuffer = &DeviceExtension->KeyboardHook; InputBufferLength = sizeof(INTERNAL_I8042_HOOK_KEYBOARD); break; } case Mouse: { PI8042_MOUSE_EXTENSION DeviceExtension; DeviceExtension = (PI8042_MOUSE_EXTENSION)FdoDeviceExtension; IoControlCode = IOCTL_INTERNAL_I8042_HOOK_MOUSE; InputBuffer = &DeviceExtension->MouseHook; InputBufferLength = sizeof(INTERNAL_I8042_HOOK_MOUSE); break; } default: { ERR_(I8042PRT, "Unknown FDO type %u\n", FdoDeviceExtension->Type); ASSERT(FALSE); WorkItemData->Irp->IoStatus.Status = STATUS_INTERNAL_ERROR; goto cleanup; } } KeInitializeEvent(&Event, NotificationEvent, FALSE); TopOfStack = IoGetAttachedDeviceReference(DeviceObject); NewIrp = IoBuildDeviceIoControlRequest( IoControlCode, TopOfStack, InputBuffer, InputBufferLength, NULL, 0, TRUE, &Event, &IoStatus); if (!NewIrp) { WARN_(I8042PRT, "IoBuildDeviceIoControlRequest() failed\n"); WorkItemData->Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } Status = IoCallDriver(TopOfStack, NewIrp); if (Status == STATUS_PENDING) { KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL); Status = IoStatus.Status; } if (!NT_SUCCESS(Status)) { WARN_(I8042PRT, "IoCallDriver() failed with status 0x%08lx\n", Status); goto cleanup; } if (FdoDeviceExtension->Type == Keyboard) { PI8042_KEYBOARD_EXTENSION DeviceExtension; DeviceExtension = (PI8042_KEYBOARD_EXTENSION)FdoDeviceExtension; /* Call the hooked initialization if it exists */ if (DeviceExtension->KeyboardHook.InitializationRoutine) { Status = DeviceExtension->KeyboardHook.InitializationRoutine( DeviceExtension->KeyboardHook.Context, PortDeviceExtension, i8042SynchReadPort, i8042SynchWritePortKbd, FALSE); if (!NT_SUCCESS(Status)) { WARN_(I8042PRT, "KeyboardHook.InitializationRoutine() failed with status 0x%08lx\n", Status); WorkItemData->Irp->IoStatus.Status = Status; goto cleanup; } } } WorkItemData->Irp->IoStatus.Status = STATUS_SUCCESS; cleanup: if (TopOfStack != NULL) ObDereferenceObject(TopOfStack); WorkItemData->Irp->IoStatus.Information = 0; IoCompleteRequest(WorkItemData->Irp, IO_NO_INCREMENT); IoFreeWorkItem(WorkItemData->WorkItem); ExFreePoolWithTag(WorkItemData, I8042PRT_TAG); }