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);
}
