/*--------------------------------------------------------- 函数名称: Antinvader_Unload 函数描述: 卸载驱动程序,关闭通信端口 输入参数: Flags 卸载标志 输出参数: 返回值: STATUS_SUCCESS 成功 其他: 更新维护: 2011.3.20 最初版本 ---------------------------------------------------------*/ NTSTATUS Antinvader_Unload ( __in FLT_FILTER_UNLOAD_FLAGS Flags ) { UNREFERENCED_PARAMETER( Flags ); PAGED_CODE(); DebugTrace(DEBUG_TRACE_LOAD_UNLOAD,"Unload", ("Entered.")); // //关闭通信端口 // if(pfpGlobalServerPort) { DebugTrace(DEBUG_TRACE_LOAD_UNLOAD,"Unload", ("Closing communication port....0x%X",pfpGlobalServerPort)); FltCloseCommunicationPort( pfpGlobalServerPort ); } // //卸载过滤 // if(pfltGlobalFilterHandle) { DebugTrace(DEBUG_TRACE_LOAD_UNLOAD,"Unload", ("Unregistering filter....0x%X",pfltGlobalFilterHandle)); FltUnregisterFilter( pfltGlobalFilterHandle ); } // //销毁释放所有表格 资源 旁视链表等 // PctFreeTable(); // ExDeleteNPagedLookasideList(&nliCallbackContextLookasideList); // ExDeleteNPagedLookasideList(&nliFileStreamContextLookasideList); ExDeleteNPagedLookasideList(&nliNewFileHeaderLookasideList); DebugTrace(DEBUG_TRACE_LOAD_UNLOAD,"Unload", ("All succeed.Leave now.")); return STATUS_SUCCESS; }
VOID DokanUnload(__in PDRIVER_OBJECT DriverObject) /*++ Routine Description: This routine gets called to remove the driver from the system. Arguments: DriverObject - the system supplied driver object. Return Value: NTSTATUS --*/ { PDEVICE_OBJECT deviceObject = DriverObject->DeviceObject; WCHAR symbolicLinkBuf[] = DOKAN_GLOBAL_SYMBOLIC_LINK_NAME; UNICODE_STRING symbolicLinkName; PDOKAN_GLOBAL dokanGlobal; // PAGED_CODE(); DDbgPrint("==> DokanUnload\n"); dokanGlobal = deviceObject->DeviceExtension; if (GetIdentifierType(dokanGlobal) == DGL) { DDbgPrint(" Delete Global DeviceObject\n"); RtlInitUnicodeString(&symbolicLinkName, symbolicLinkBuf); IoDeleteSymbolicLink(&symbolicLinkName); IoUnregisterFileSystem(dokanGlobal->FsDiskDeviceObject); IoUnregisterFileSystem(dokanGlobal->FsCdDeviceObject); IoDeleteDevice(dokanGlobal->FsDiskDeviceObject); IoDeleteDevice(dokanGlobal->FsCdDeviceObject); IoDeleteDevice(deviceObject); } ExDeleteNPagedLookasideList(&DokanIrpEntryLookasideList); DDbgPrint("<== DokanUnload\n"); return; }
VOID OcObDeleteObjectType( IN POC_OBJECT_TYPE PtrObjectType ) /* The function checks the object type's reference count and deletes the object type if the reference count is zero, else the object type is marked and will be deleted when the refrence count drops to zero */ { OcObDeleteObjectTypeMethod DeleteObjectTypeMethod; ASSERT( OcTypeObjectType == PtrObjectType->CommonHeader.Type ); if( 0x0 != InterlockedCompareExchange( &PtrObjectType->RefCount, 0x0, 0x0 ) ){ OcSetFlag( PtrObjectType->Flags, OcObjectTypeMarkedForDeletion ); return; } if( !OcIsFlagOn( PtrObjectType->Flags, OcObjectTypeUseStdPoolAllocator ) ) ExDeleteNPagedLookasideList( &PtrObjectType->LookasideList ); // // get the pointer to the notify routine // DeleteObjectTypeMethod = PtrObjectType->Methods.DeleteObjectType; #if DBG RtlFillMemory( PtrObjectType, sizeof( *PtrObjectType ), 0x0C ); #endif//DBG // // notify about the object type uninitialization // if( NULL != DeleteObjectTypeMethod ){ DeleteObjectTypeMethod( PtrObjectType ); OC_DEBUG_SET_POINTER_TO_INVALID_VALUE( PtrObjectType ); } }
void DestroyNotificationQueue(NOTIFICATION_QUEUE *queue) { while(!IsListEmpty(&queue->notification_list)) { PGNOTIFYNODE *notifynode = (PGNOTIFYNODE*)RemoveHeadList(&queue->notification_list); ExFreeToNPagedLookasideList(&queue->lookaside, notifynode); } while(!IsListEmpty(&queue->irp_list)) { PGIRPNODE *irpnode = (PGIRPNODE*)RemoveHeadList(&queue->irp_list); irpnode->irp->IoStatus.Status = STATUS_CANCELLED; irpnode->irp->IoStatus.Information = 0; IoCompleteRequest(irpnode->irp, IO_NO_INCREMENT); ExFreeToNPagedLookasideList(&queue->lookaside, irpnode); } ExDeleteNPagedLookasideList(&queue->lookaside); }
VOID BalloonEvtDeviceContextCleanup( IN WDFOBJECT Device ) { PDEVICE_CONTEXT devCtx = GetDeviceContext((WDFDEVICE)Device); PAGED_CODE(); TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "--> %s\n", __FUNCTION__); if(devCtx->bListInitialized) { ExDeleteNPagedLookasideList(&devCtx->LookAsideList); devCtx->bListInitialized = FALSE; } if(devCtx->pfns_table) { ExFreePoolWithTag( devCtx->pfns_table, BALLOON_MGMT_POOL_TAG ); devCtx->pfns_table = NULL; } RtlFillMemory(devCtx->MemStats, sizeof(BALLOON_STAT) * VIRTIO_BALLOON_S_NR, -1); if (devCtx->StatVirtQueue) { BalloonMemStats(Device); } if(devCtx->MemStats) { ExFreePoolWithTag( devCtx->MemStats, BALLOON_MGMT_POOL_TAG ); devCtx->MemStats = NULL; } TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "<-- %s\n", __FUNCTION__); }
VOID DokanUnload(__in PDRIVER_OBJECT DriverObject) /*++ Routine Description: This routine gets called to remove the driver from the system. Arguments: DriverObject - the system supplied driver object. Return Value: NTSTATUS --*/ { PDEVICE_OBJECT deviceObject = DriverObject->DeviceObject; PDOKAN_GLOBAL dokanGlobal; DDbgPrint("==> DokanUnload\n"); PAGED_CODE(); dokanGlobal = deviceObject->DeviceExtension; if (GetIdentifierType(dokanGlobal) == DGL) { DDbgPrint(" Delete Global DeviceObject\n"); CleanupGlobalDiskDevice(dokanGlobal); ExFreePool(DriverObject->FastIoDispatch); } ExDeleteNPagedLookasideList(&DokanIrpEntryLookasideList); ExDeleteLookasideListEx(&g_DokanCCBLookasideList); ExDeleteLookasideListEx(&g_DokanFCBLookasideList); ExDeleteLookasideListEx(&g_DokanEResourceLookasideList); DDbgPrint("<== DokanUnload\n"); }
void cp_free_fast_crypt() { int i; /* disable thread pool */ if (lock_xchg(&pool_enabled, 0) == 0) { return; } /* stop all threads */ for (i = 0; i < MAX_CPU_COUNT; i++) { if (pool_threads[i] != NULL) { KeSetEvent(&pool_signal_event, IO_NO_INCREMENT, FALSE); ZwWaitForSingleObject(pool_threads[i], FALSE, NULL); ZwClose(pool_threads[i]); } } /* free memory */ memset(&pool_threads, 0, sizeof(pool_threads)); ExDeleteNPagedLookasideList(&pool_req_mem); }
/* KphProtectDeinit * * Removes process protection and frees associated structures. * * IRQL: <= APC_LEVEL */ NTSTATUS KphProtectDeinit() { NTSTATUS status = STATUS_SUCCESS; KIRQL oldIrql; LARGE_INTEGER waitLi; /* Unhook. */ status = KphObOpenUnhook(&ProcessOpenHook); status = KphObOpenUnhook(&ThreadOpenHook); /* Wait for all activity to finish. */ ExWaitForRundownProtectionRelease(&ProtectedProcessRundownProtect); /* Wait for a bit (some regions of hook target functions are NOT guarded by rundown protection, e.g. prologues and epilogues). */ waitLi.QuadPart = KPH_REL_TIMEOUT_IN_SEC(1); KeDelayExecutionThread(KernelMode, FALSE, &waitLi); /* Free all process protection entries. */ ExDeleteNPagedLookasideList(&ProtectedProcessLookasideList); return status; }
NTSTATUS TCPShutdown(VOID) /* * FUNCTION: Shuts down the TCP subsystem * RETURNS: * Status of operation */ { if (!TCPInitialized) return STATUS_SUCCESS; ExDeleteNPagedLookasideList(&TdiBucketLookasideList); LibIPShutdown(); /* Deregister this protocol with IP layer */ IPRegisterProtocol(IPPROTO_TCP, NULL); TCPInitialized = FALSE; PortsShutdown( &TCPPorts ); return STATUS_SUCCESS; }
void DestroyTable(PHASHTABLE pHashTable) { PTWOWAY pNode = NULL; PTWOWAY pTmpNode = NULL; PLIST_ENTRY pListHead = NULL; PLIST_ENTRY pListLink = NULL; unsigned int i; for (i = 0; i < pHashTable->tableSize; i++) { pListHead = pListLink = pHashTable->pListHeads[i]; if (pListHead == NULL) { DbgPrint("pListHead is NULL!\n"); continue; } if (!IsListEmpty(pListHead)) { do { pNode = CONTAINING_RECORD(pListLink, TWOWAY, linkfield); pListLink = pListLink->Flink; ExFreeToNPagedLookasideList(pLookasideList_TWOWAY, pNode); } while (pListLink != pListHead); } else { pNode = CONTAINING_RECORD(pListHead, TWOWAY, linkfield); ExFreeToNPagedLookasideList(pLookasideList_TWOWAY, pNode); } } ExDeleteNPagedLookasideList(pLookasideList_TWOWAY); ExFreePoolWithTag(pLookasideList_TWOWAY, DRIVERTAG1); ExFreePoolWithTag(pHashTable->pListHeads, DRIVERTAG1); ExFreePoolWithTag(pHashTable, DRIVERTAG1); }
VOID DriverUnload (IN PDRIVER_OBJECT DriverObject) { UNICODE_STRING DosDeviceName; DEBUG(DL_FUN, ( "Ext2Fsd: Unloading routine.\n")); /* * stop reaper thread ... */ /* * removing memory allocations and objects */ RtlInitUnicodeString(&DosDeviceName, DOS_DEVICE_NAME); IoDeleteSymbolicLink(&DosDeviceName); Ext2UnloadAllNls(); ExDeleteResourceLite(&Ext2Global->Resource); ExDeleteNPagedLookasideList(&(Ext2Global->Ext2DentryLookasideList)); ExDeleteNPagedLookasideList(&(Ext2Global->Ext2ExtLookasideList)); ExDeleteNPagedLookasideList(&(Ext2Global->Ext2McbLookasideList)); ExDeleteNPagedLookasideList(&(Ext2Global->Ext2CcbLookasideList)); ExDeleteNPagedLookasideList(&(Ext2Global->Ext2FcbLookasideList)); ExDeleteNPagedLookasideList(&(Ext2Global->Ext2IrpContextLookasideList)); ObDereferenceObject(Ext2Global->DiskdevObject); ObDereferenceObject(Ext2Global->CdromdevObject); /* cleanup journal related caches */ UNLOAD_MODULE(journal_exit); /* cleanup linux lib */ ext2_destroy_linux(); Ext2FreePool(Ext2Global, 'LG2E'); Ext2Global = NULL; }
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 --*/ { #if __NDAS_FAT__ UNICODE_STRING linkString; #endif #if DBG DbgPrint( "FastFat FatUnload %s %s\n", __DATE__, __TIME__ ); #endif ExDeleteNPagedLookasideList (&FatEResourceLookasideList); ExDeleteNPagedLookasideList (&FatNonPagedFcbLookasideList); ExDeleteNPagedLookasideList (&FatIrpContextLookasideList); ExDeleteResourceLite( &FatData.Resource ); IoFreeWorkItem (FatData.FatCloseItem); ObDereferenceObject( FatDiskFileSystemDeviceObject); #if __NDAS_FAT__ if (FatCdromFileSystemDeviceObject) #endif ObDereferenceObject( FatCdromFileSystemDeviceObject); #if __NDAS_FAT__ RtlInitUnicodeString( &linkString, NDAS_FAT_CONTROL_LINK_NAME ); IoDeleteSymbolicLink( &linkString ); DebugTrace2( 0, Dbg2, ("NdasFatUnload occured NdasFatControlDeviceObject->ReferenceCount = %x\n", FatControlDeviceObject->ReferenceCount) ); IoDeleteDevice( FatControlDeviceObject ); DebugTrace2( 0, Dbg2, ("NdasFatUnload occured NdasFatFileSystemDeviceObject->ReferenceCount = %x\n", FatDiskFileSystemDeviceObject->ReferenceCount) ); IoDeleteDevice( FatDiskFileSystemDeviceObject ); if (FatCdromFileSystemDeviceObject) IoDeleteDevice( FatCdromFileSystemDeviceObject ); #endif }
NTSTATUS DriverEntry ( _In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath ) /*++ Routine Description: This routine is called when a driver first loads. Its purpose is to initialize global state and then register with FltMgr to start filtering. Arguments: DriverObject - Pointer to driver object created by the system to represent this driver. RegistryPath - Unicode string identifying where the parameters for this driver are located in the registry. Return Value: Status of the operation. --*/ { PSECURITY_DESCRIPTOR sd; OBJECT_ATTRIBUTES oa; UNICODE_STRING uniString; NTSTATUS status = STATUS_SUCCESS; try { // // Initialize global data structures. // MiniSpyData.LogSequenceNumber = 0; MiniSpyData.MaxRecordsToAllocate = DEFAULT_MAX_RECORDS_TO_ALLOCATE; MiniSpyData.RecordsAllocated = 0; MiniSpyData.NameQueryMethod = DEFAULT_NAME_QUERY_METHOD; MiniSpyData.DriverObject = DriverObject; InitializeListHead( &MiniSpyData.OutputBufferList ); KeInitializeSpinLock( &MiniSpyData.OutputBufferLock ); ExInitializeNPagedLookasideList( &MiniSpyData.FreeBufferList, NULL, NULL, 0, RECORD_SIZE, SPY_TAG, 0 ); #if MINISPY_VISTA // // Dynamically import FilterMgr APIs for transaction support // #pragma warning(push) #pragma warning(disable:4055) // type cast from data pointer to function pointer MiniSpyData.PFltSetTransactionContext = (PFLT_SET_TRANSACTION_CONTEXT) FltGetRoutineAddress( "FltSetTransactionContext" ); MiniSpyData.PFltGetTransactionContext = (PFLT_GET_TRANSACTION_CONTEXT) FltGetRoutineAddress( "FltGetTransactionContext" ); MiniSpyData.PFltEnlistInTransaction = (PFLT_ENLIST_IN_TRANSACTION) FltGetRoutineAddress( "FltEnlistInTransaction" ); #pragma warning(pop) #endif // // Read the custom parameters for MiniSpy from the registry // SpyReadDriverParameters(RegistryPath); // // Now that our global configuration is complete, register with FltMgr. // status = FltRegisterFilter( DriverObject, &FilterRegistration, &MiniSpyData.Filter ); if (!NT_SUCCESS( status )) { leave; } status = FltBuildDefaultSecurityDescriptor( &sd, FLT_PORT_ALL_ACCESS ); if (!NT_SUCCESS( status )) { leave; } RtlInitUnicodeString( &uniString, MINISPY_PORT_NAME ); InitializeObjectAttributes( &oa, &uniString, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, sd ); status = FltCreateCommunicationPort( MiniSpyData.Filter, &MiniSpyData.ServerPort, &oa, NULL, SpyConnect, SpyDisconnect, SpyMessage, 1 ); FltFreeSecurityDescriptor( sd ); if (!NT_SUCCESS( status )) { leave; } // // We are now ready to start filtering // status = FltStartFiltering( MiniSpyData.Filter ); //If all went ok, register a process creation notification cb. if (NT_SUCCESS(status)) { status = PsSetCreateProcessNotifyRoutine(ProcessCreationCB, FALSE); } //If all went ok, register also a register filter. if (NT_SUCCESS(status)) { status = CmRegisterCallback(RegistryCallback, NULL, &g_CmCookie); } } finally { if (!NT_SUCCESS( status ) ) { if (NULL != MiniSpyData.ServerPort) { FltCloseCommunicationPort( MiniSpyData.ServerPort ); } if (NULL != MiniSpyData.Filter) { FltUnregisterFilter( MiniSpyData.Filter ); } ExDeleteNPagedLookasideList( &MiniSpyData.FreeBufferList ); } } return status; }
VOID ReleasePacketLookaside() { ExDeleteNPagedLookasideList(&g_PktLookaside); ExDeleteNPagedLookasideList(&g_DataLookaside); }
VOID AfdUnload ( IN PDRIVER_OBJECT DriverObject ) { PLIST_ENTRY listEntry; PAFD_TRANSPORT_INFO transportInfo; UNREFERENCED_PARAMETER( DriverObject ); PAGED_CODE( ); KdPrint(( "AfdUnload called.\n" )); // // Kill the transport info list. // while( !IsListEmpty( &AfdTransportInfoListHead ) ) { listEntry = RemoveHeadList( &AfdTransportInfoListHead ); transportInfo = CONTAINING_RECORD( listEntry, AFD_TRANSPORT_INFO, TransportInfoListEntry ); AFD_FREE_POOL( transportInfo, AFD_TRANSPORT_INFO_POOL_TAG ); } // // Kill the resource that protects the executive worker thread queue. // if( AfdResource != NULL ) { ExDeleteResource( AfdResource ); AFD_FREE_POOL( AfdResource, AFD_RESOURCE_POOL_TAG ); } // // Destroy the lookaside lists. // if( AfdLookasideLists != NULL ) { ExDeleteNPagedLookasideList( &AfdLookasideLists->WorkQueueList ); ExDeleteNPagedLookasideList( &AfdLookasideLists->LargeBufferList ); ExDeleteNPagedLookasideList( &AfdLookasideLists->MediumBufferList ); ExDeleteNPagedLookasideList( &AfdLookasideLists->SmallBufferList ); AFD_FREE_POOL( AfdLookasideLists, AFD_LOOKASIDE_LISTS_POOL_TAG ); } // // Terminate the group ID manager. // AfdTerminateGroup(); // // Delete our device object. // IoDeleteDevice( AfdDeviceObject ); } // AfdUnload
VOID SpReleaseAdapterResources( IN PADAPTER_EXTENSION Adapter, IN BOOLEAN Surprise ) /*++ Routine Description: This function deletes all of the storage associated with a device extension, disconnects from the timers and interrupts and then deletes the object. This function can be called at any time during the initialization. Arguments: Adapter - Supplies a pointer to the device extesnion to be deleted. Return Value: None. --*/ { PCOMMON_EXTENSION commonExtension = &(Adapter->CommonExtension); ULONG j; PVOID tempPointer; PAGED_CODE(); #if DBG if(!Surprise) { // // Free the Remove tracking lookaside list. // ExDeleteNPagedLookasideList(&(commonExtension->RemoveTrackingLookasideList)); } #endif // // Stop the time and disconnect the interrupt if they have been // initialized. The interrupt object is connected after // timer has been initialized, and the interrupt object is connected, but // before the timer is started. // if(Adapter->DeviceObject->Timer != NULL) { IoStopTimer(Adapter->DeviceObject); KeCancelTimer(&(Adapter->MiniPortTimer)); } if(Adapter->SynchronizeExecution != SpSynchronizeExecution) { if (Adapter->InterruptObject) { IoDisconnectInterrupt(Adapter->InterruptObject); } if (Adapter->InterruptObject2) { IoDisconnectInterrupt(Adapter->InterruptObject2); Adapter->InterruptObject2 = NULL; } // // SpSynchronizeExecution expects to get a pointer to the // adapter extension as the "interrupt" parameter. // Adapter->InterruptObject = (PVOID) Adapter; Adapter->SynchronizeExecution = SpSynchronizeExecution; } // // Delete the miniport's device extension // if (Adapter->HwDeviceExtension != NULL) { PHW_DEVICE_EXTENSION devExt = CONTAINING_RECORD(Adapter->HwDeviceExtension, HW_DEVICE_EXTENSION, HwDeviceExtension); ExFreePool(devExt); Adapter->HwDeviceExtension = NULL; } // // Free the configuration information structure. // if (Adapter->PortConfig) { ExFreePool(Adapter->PortConfig); Adapter->PortConfig = NULL; } // // Deallocate SCSIPORT WMI REGINFO information, if any. // SpWmiDestroySpRegInfo(Adapter->DeviceObject); // // Free the common buffer. // if (Adapter->SrbExtensionBuffer != NULL && Adapter->CommonBufferSize != 0) { if (Adapter->DmaAdapterObject == NULL) { // // Since there is no adapter just free the non-paged pool. // ExFreePool(Adapter->SrbExtensionBuffer); } else { #if defined(_X86_) if(Adapter->UncachedExtensionIsCommonBuffer == FALSE) { MmFreeContiguousMemorySpecifyCache(Adapter->SrbExtensionBuffer, Adapter->CommonBufferSize, MmNonCached); } else #endif { HalFreeCommonBuffer( Adapter->DmaAdapterObject, Adapter->CommonBufferSize, Adapter->PhysicalCommonBuffer, Adapter->SrbExtensionBuffer, FALSE); } } Adapter->SrbExtensionBuffer = NULL; } // // Free the SRB data array. // if (Adapter->SrbDataListInitialized) { if(Adapter->EmergencySrbData != NULL) { ExFreeToNPagedLookasideList( &Adapter->SrbDataLookasideList, Adapter->EmergencySrbData); Adapter->EmergencySrbData = NULL; } ExDeleteNPagedLookasideList(&Adapter->SrbDataLookasideList); Adapter->SrbDataListInitialized = FALSE; } if (Adapter->InquiryBuffer != NULL) { ExFreePool(Adapter->InquiryBuffer); Adapter->InquiryBuffer = NULL; } if (Adapter->InquirySenseBuffer != NULL) { ExFreePool(Adapter->InquirySenseBuffer); Adapter->InquirySenseBuffer = NULL; } if (Adapter->InquiryIrp != NULL) { IoFreeIrp(Adapter->InquiryIrp); Adapter->InquiryIrp = NULL; } if (Adapter->InquiryMdl != NULL) { IoFreeMdl(Adapter->InquiryMdl); Adapter->InquiryMdl = NULL; } // // Free the Scatter Gather lookaside list. // if (Adapter->MediumScatterGatherListInitialized) { ExDeleteNPagedLookasideList( &Adapter->MediumScatterGatherLookasideList); Adapter->MediumScatterGatherListInitialized = FALSE; } // // Unmap any mapped areas. // SpReleaseMappedAddresses(Adapter); // // If we've got any resource lists allocated still we should free them // now. // if(Adapter->AllocatedResources != NULL) { ExFreePool(Adapter->AllocatedResources); Adapter->AllocatedResources = NULL; } if(Adapter->TranslatedResources != NULL) { ExFreePool(Adapter->TranslatedResources); Adapter->TranslatedResources = NULL; } Adapter->CommonExtension.IsInitialized = FALSE; return; }
VOID SpDeleteLogicalUnit( IN PDEVICE_OBJECT LogicalUnit ) /*++ Routine Description: This routine will release any resources held for the logical unit, mark the device extension as deleted, and call the io system to actually delete the object. The device object will be deleted once it's reference count drops to zero. Arguments: LogicalUnit - the device object for the logical unit to be deleted. Return Value: none --*/ { PLOGICAL_UNIT_EXTENSION luExtension = LogicalUnit->DeviceExtension; PCOMMON_EXTENSION commonExtension = LogicalUnit->DeviceExtension; PAGED_CODE(); ASSERT(luExtension->ReadyLogicalUnit == NULL); ASSERT(luExtension->PendingRequest == NULL); ASSERT(luExtension->BusyRequest == NULL); ASSERT(luExtension->QueueCount == 0); // // Unregister with WMI. // if(commonExtension->WmiInitialized == TRUE) { // // Destroy all our WMI resources and unregister with WMI. // IoWMIRegistrationControl(LogicalUnit, WMIREG_ACTION_DEREGISTER); // BUGBUG // We should be asking the WmiFreeRequestList of remove some // free cells. commonExtension->WmiInitialized = FALSE; SpWmiDestroySpRegInfo(LogicalUnit); } SpDeleteDeviceMapEntry(luExtension->DeviceObject); // // Yank this out of the logical unit list. // SpRemoveLogicalUnitFromBin(luExtension->AdapterExtension, luExtension); #if DBG // ASSERT(commonExtension->RemoveTrackingList == NULL); ExDeleteNPagedLookasideList(&(commonExtension->RemoveTrackingLookasideList)); #endif // // If the request sense irp still exists, delete it. // if(luExtension->RequestSenseIrp != NULL) { IoFreeIrp(luExtension->RequestSenseIrp); luExtension->RequestSenseIrp = NULL; } IoDeleteDevice(LogicalUnit); return; }
NTSTATUS CHardwareSimulation:: Stop ( ) /*++ Routine Description: Stop the hardware simulation.... Wait until the hardware simulation has successfully stopped and then return. Arguments: None Return Value: Success / Failure --*/ { KIRQL Irql; // // If the hardware is told to stop while it's running, we need to // halt the interrupts first. If we're already paused, this has // already been done. // if (m_HardwareState == HardwareRunning) { m_StopHardware = TRUE; KeWaitForSingleObject ( &m_HardwareEvent, Suspended, KernelMode, FALSE, NULL ); ASSERT (m_StopHardware == FALSE); } m_HardwareState = HardwareStopped; // // The image synthesizer may still be around. Just for safety's // sake, NULL out the image synthesis buffer and toast it. // m_ImageSynth -> SetBuffer (NULL); if (m_SynthesisBuffer) { ExFreePool (m_SynthesisBuffer); m_SynthesisBuffer = NULL; } // // Protect the S/G list // KeAcquireSpinLock (&m_ListLock, &Irql); // // Free S/G buffer // // while (m_ScatterGatherMappingsQueued > 0) { LIST_ENTRY *listEntry = RemoveHeadList (&m_ScatterGatherMappings); m_ScatterGatherMappingsQueued--; PSCATTER_GATHER_ENTRY SGEntry = reinterpret_cast <PSCATTER_GATHER_ENTRY> ( CONTAINING_RECORD ( listEntry, SCATTER_GATHER_ENTRY, ListEntry ) ); // // Release the scatter / gather entry back to our lookaside. // ExFreeToNPagedLookasideList ( &m_ScatterGatherLookaside, reinterpret_cast <PVOID> (SGEntry) ); } m_NumMappingsCompleted = 0; m_ScatterGatherBytesQueued = 0; // // Delete the scatter / gather lookaside for this run. // ExDeleteNPagedLookasideList (&m_ScatterGatherLookaside); KeReleaseSpinLock (&m_ListLock, Irql); return STATUS_SUCCESS; }
static NTSTATUS NTAPI V4vDispatchPnP(PDEVICE_OBJECT fdo, PIRP irp) { NTSTATUS status = STATUS_SUCCESS; PIO_STACK_LOCATION isl = IoGetCurrentIrpStackLocation(irp); PXENV4V_EXTENSION pde = V4vGetDeviceExtension(fdo); KEVENT kev; TraceVerbose(("====> '%s'.\n", __FUNCTION__)); TraceVerbose((" =PnP= 0x%x\n", isl->MinorFunction)); status = IoAcquireRemoveLock(&pde->removeLock, irp); if (!NT_SUCCESS(status)) { TraceError(("failed to acquire IO lock - error: 0x%x\n", status)); return V4vSimpleCompleteIrp(irp, status); } switch (isl->MinorFunction) { case IRP_MN_START_DEVICE: KeInitializeEvent(&kev, NotificationEvent, FALSE); // Send the start down and wait for it to complete IoCopyCurrentIrpStackLocationToNext(irp); IoSetCompletionRoutine(irp, V4vStartDeviceIoCompletion, &kev, TRUE, TRUE, TRUE); status = IoCallDriver(pde->ldo, irp); if (status == STATUS_PENDING) { // Wait for everything underneath us to complete TraceVerbose(("Device start waiting for lower device.\n")); KeWaitForSingleObject(&kev, Executive, KernelMode, FALSE, NULL); TraceVerbose(("Device start wait finished.\n")); } status = irp->IoStatus.Status; if (!NT_SUCCESS(status)) { TraceError(("Failed to start lower drivers: %x.\n", status)); IoCompleteRequest(irp, IO_NO_INCREMENT); break; } status = STATUS_SUCCESS; // Connect our interrupt (ec). status = V4vInitializeEventChannel(fdo); if (NT_SUCCESS(status)) { InterlockedExchange(&pde->state, XENV4V_DEV_STARTED); } else { TraceError(("failed to initialize event channel - error: 0x%x\n", status)); } irp->IoStatus.Status = status; IoCompleteRequest(irp, IO_NO_INCREMENT); break; case IRP_MN_STOP_DEVICE: // Stop our device's IO processing V4vStopDevice(fdo, pde); // Pass it down irp->IoStatus.Status = STATUS_SUCCESS; IoSkipCurrentIrpStackLocation(irp); status = IoCallDriver(pde->ldo, irp); break; case IRP_MN_REMOVE_DEVICE: // Stop our device's IO processing V4vStopDevice(fdo, pde); // Cleanup anything here that locks for IO IoReleaseRemoveLockAndWait(&pde->removeLock, irp); // Pass it down first IoSkipCurrentIrpStackLocation(irp); status = IoCallDriver(pde->ldo, irp); // Then detach and cleanup our device xenbus_change_state(XBT_NIL, pde->frontendPath, "state", XENBUS_STATE_CLOSED); IoDetachDevice(pde->ldo); ExDeleteNPagedLookasideList(&pde->destLookasideList); XmFreeMemory(pde->frontendPath); IoDeleteSymbolicLink(&pde->symbolicLink); IoDeleteDevice(fdo); InterlockedAnd(&g_deviceCreated, 0); return status; default: // Pass it down TraceVerbose(("IRP_MJ_PNP MinorFunction %d passed down\n", isl->MinorFunction)); IoSkipCurrentIrpStackLocation(irp); status = IoCallDriver(pde->ldo, irp); }; // Everybody but REMOVE IoReleaseRemoveLock(&pde->removeLock, irp); TraceVerbose(("<==== '%s'.\n", __FUNCTION__)); return status; }