void BackOut (MINIPORT_ADAPTER *pAdapter) { DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS==> BackOut\r\n"))); DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS==> Releasing all LPC3250 NDIS resources\r\n"))); if (pAdapter->IsInterruptSet) NdisMDeregisterInterrupt(&pAdapter->InterruptInfo); if(pAdapter->pVAEMACBuffers != NULL) { UnMapRegisters (pAdapter->pVAEMACBuffers,pAdapter->dwEMACBuffersSize); pAdapter->pVAEMACBuffers = NULL; } if(pAdapter->pVALookAheadBuffer != NULL) { NdisFreeMemory(pAdapter->pVALookAheadBuffer,pAdapter->dwLookAheadBufferSize,0); pAdapter->pVALookAheadBuffer = NULL; } if(pAdapter->pTXPackets != NULL) { NdisFreeMemory(pAdapter->pTXPackets, sizeof(TX_PACKET) * pAdapter->dwTxStrides, 0); pAdapter->pTXPackets = NULL; } //Release the adapter structure. NdisFreeMemory(pAdapter, MINIPORT_ADAPTER_SIZE, 0); DEBUGMSG(ZONE_INIT, (TEXT("LPC3xxx NDIS<== BackOut\r\n"))); }
static VOID CleanupRSSParameters(PARANDIS_RSS_PARAMS *RSSParameters) { if(RSSParameters->ActiveRSSScalingSettings.CPUIndexMapping != NULL) NdisFreeMemory(RSSParameters->ActiveRSSScalingSettings.CPUIndexMapping, 0, 0); if(RSSParameters->RSSScalingSettings.CPUIndexMapping != NULL) NdisFreeMemory(RSSParameters->RSSScalingSettings.CPUIndexMapping, 0, 0); }
VOID NdisCloseConfiguration( IN NDIS_HANDLE ConfigurationHandle ) /*++ Routine Description: This routine is used to close a configuration database opened by NdisOpenConfiguration. Arguments: ConfigurationHandle - Handle returned by NdisOpenConfiguration. Return Value: None. --*/ { // // Obtain the actual configuration handle structure // PNDIS_CONFIGURATION_HANDLE NdisConfigHandle = (PNDIS_CONFIGURATION_HANDLE)ConfigurationHandle; // // Pointer to a parameter node // PNDIS_CONFIGURATION_PARAMETER_QUEUE ParameterNode; ASSERT (KeGetCurrentIrql() < DISPATCH_LEVEL); // // deallocate the parameter nodes // ParameterNode = NdisConfigHandle->ParameterList; while (ParameterNode != NULL) { NdisConfigHandle->ParameterList = ParameterNode->Next; NdisFreeMemory(ParameterNode, sizeof(NDIS_CONFIGURATION_PARAMETER_QUEUE), 0); ParameterNode = NdisConfigHandle->ParameterList; } NdisFreeMemory(ConfigurationHandle, sizeof(NDIS_CONFIGURATION_HANDLE), 0); }
/* delte a trace object */ INT trc_destroy(VOID *trc_1) { TRC *trc = (TRC*)trc_1; D_LOG(D_ENTRY, ("trc_destroy: entry, trc: 0x%lx", trc)); /* free memory */ NdisFreeMemory(trc->ent_tbl, sizeof(TRC_ENTRY) * trc->stat.depth, 0); NdisFreeMemory(trc, sizeof(*trc), 0); return(TRC_E_SUCC); }
BOOLEAN FilterPacket_ReceiveHandler ( PVOID pHeadBuffer, ULONG ulHeadSize, PNDIS_PACKET pPacket ) /*++ Routine Description: Filters network packets for NDISReceiveHandler. Arguments: ... Return Value: TRUE: This packet should be blocked. FALSE: This packet should pass through. Author: xiaonie 2012/07/12 --*/ { ULONG ulPacketSize; PUCHAR pBuffer = NULL; NDIS_STATUS status; PNDIS_BUFFER pFirstBuffer, pNextBuffer; BOOLEAN bRet = FALSE; NdisQueryPacket(pPacket, NULL, NULL, NULL, &ulPacketSize); if (ulPacketSize == 0) return FALSE; DbgPrint("ulHeadSize == %d, ulPacketSize == %d in FilterPacket_ReceiveHandler!\r\n", ulHeadSize, ulPacketSize); status = NdisAllocateMemoryWithTag(&pBuffer, ulPacketSize + ulHeadSize, '!nmN'); if (status != NDIS_STATUS_SUCCESS/* || pBuffer == NULL */) return FALSE; //obtain content from the packet NdisMoveMemory(pBuffer, pHeadBuffer, ulHeadSize); ReadPacket(pPacket, pBuffer + ulHeadSize, ulPacketSize); bRet = RabbitHole(pBuffer, ulPacketSize + ulHeadSize); NdisFreeMemory(pBuffer, ulPacketSize + ulHeadSize, 0); return bRet; }
/********************************************************** Required NDIS handler for RESET operation Never happens under normal condition, only if OID or other call returns PENDING and not completed or if ParaNdis6_CheckForHang returns true ***********************************************************/ static NDIS_STATUS ParaNdis6_Reset( NDIS_HANDLE miniportAdapterContext, PBOOLEAN pAddressingReset) { NDIS_STATUS status = NDIS_STATUS_FAILURE; PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)miniportAdapterContext; NDIS_HANDLE hwo; tGeneralWorkItem *pwi; DEBUG_ENTRY(0); *pAddressingReset = TRUE; ParaNdis_DebugHistory(pContext, hopSysReset, NULL, 1, 0, 0); hwo = NdisAllocateIoWorkItem(pContext->MiniportHandle); pwi = ParaNdis_AllocateMemory(pContext, sizeof(tGeneralWorkItem)); if (pwi && hwo) { pwi->pContext = pContext; pwi->WorkItem = hwo; NdisQueueIoWorkItem(hwo, OnResetWorkItem, pwi); status = NDIS_STATUS_PENDING; } else { if (pwi) NdisFreeMemory(pwi, 0, 0); if (hwo) NdisFreeIoWorkItem(hwo); ParaNdis_DebugHistory(pContext, hopSysReset, NULL, 0, status, 0); } DEBUG_EXIT_STATUS(0, status); return status; }
static VOID ApplySettings(PPARANDIS_RSS_PARAMS RSSParameters, PARANDIS_RSS_MODE NewRSSMode, PARANDIS_HASHING_SETTINGS *ReceiveHashingSettings, PARANDIS_SCALING_SETTINGS *ReceiveScalingSettings) { NdisAcquireSpinLock(&RSSParameters->RSSSettingsLock); RSSParameters->RSSMode = NewRSSMode; if(NewRSSMode != PARANDIS_RSS_DISABLED) { RSSParameters->ActiveHashingSettings = *ReceiveHashingSettings; if(NewRSSMode == PARANDIS_RSS_FULL) { if(RSSParameters->ActiveRSSScalingSettings.CPUIndexMapping != NULL) NdisFreeMemory(RSSParameters->ActiveRSSScalingSettings.CPUIndexMapping, 0, 0); RSSParameters->ActiveRSSScalingSettings = *ReceiveScalingSettings; ReceiveScalingSettings->CPUIndexMapping = NULL; } } NdisReleaseSpinLock(&RSSParameters->RSSSettingsLock); }
// Free adapter context memory and associated resources. VOID tapAdapterContextFree(__in PTAP_ADAPTER_CONTEXT Adapter) { PLIST_ENTRY listEntry = &Adapter->AdapterListLink; DEBUGP(("[TAP] --> tapAdapterContextFree\n")); // Adapter context should already be removed. ASSERT((listEntry->Flink == listEntry) && (listEntry->Blink == listEntry)); // Insure that adapter context has been removed from global adapter list. RemoveEntryList(&Adapter->AdapterListLink); // Free the adapter lock. NdisFreeSpinLock(&Adapter->AdapterLock); // Free the ANSI NetCfgInstanceId buffer. if (Adapter->NetCfgInstanceIdAnsi.Buffer != NULL) { RtlFreeAnsiString(&Adapter->NetCfgInstanceIdAnsi); } Adapter->NetCfgInstanceIdAnsi.Buffer = NULL; // Free the receive NBL pool. if (Adapter->ReceiveNblPool != NULL) { NdisFreeNetBufferListPool(Adapter->ReceiveNblPool); } Adapter->ReceiveNblPool = NULL; NdisFreeMemory(Adapter, 0, 0); DEBUGP(("[TAP] <-- tapAdapterContextFree\n")); }
void _rtw_mfree(u8 *pbuf, u32 sz) { #ifdef PLATFORM_LINUX #ifdef RTK_DMP_PLATFORM if(sz > 0x4000) dvr_free(pbuf); else #endif kfree(pbuf); #endif #ifdef PLATFORM_FREEBSD free(pbuf,M_DEVBUF); #endif #ifdef PLATFORM_WINDOWS NdisFreeMemory(pbuf,sz, 0); #endif #ifdef DBG_MEMORY_LEAK #ifdef PLATFORM_LINUX atomic_dec(&_malloc_cnt); atomic_sub(sz, &_malloc_size); #endif #endif /* DBG_MEMORY_LEAK */ }
/* * Closes the open adapter * */ BOOL PKTCloseAdapter (POPEN_INSTANCE pOI) { BOOL bRet = TRUE; NDIS_STATUS nsError; // close the adapter NdisCloseAdapter (&nsError, pOI->AdapterHandle); if (nsError == NDIS_STATUS_PENDING) { SuspendExecution (pOI); } else { PacketCloseAdapterComplete (pOI, nsError); } if (pOI->Status != NDIS_STATUS_SUCCESS) { bRet = FALSE; } // set all the events to release the waits SetEvent (pOI->ReadEvent); CloseHandle (pOI->ReadEvent); // Free the open instance memory NdisFreeMemory (pOI, sizeof (OPEN_INSTANCE), 0); // set no instances open g_pDeviceExtension->pOpenInstance = NULL; return bRet; }
/************************************************************* Required NDIS procedure Called when some procedure (like OID handler) returns PENDING and does not complete or when CheckForHang return TRUE *************************************************************/ static NDIS_STATUS ParaNdis5_Reset( OUT PBOOLEAN AddressingReset, IN NDIS_HANDLE MiniportAdapterContext) { NDIS_STATUS status; tGeneralWorkItem *pwi; PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)MiniportAdapterContext; DEBUG_ENTRY(0); ParaNdis_DebugHistory(pContext, hopSysReset, NULL, 1, 0, 0); status = NDIS_STATUS_FAILURE; pwi = ParaNdis_AllocateMemory(pContext, sizeof(tGeneralWorkItem)); if (pwi) { pwi->pContext = pContext; NdisInitializeWorkItem(&pwi->wi, OnResetWorkItem, pwi); if (NdisScheduleWorkItem(&pwi->wi) == NDIS_STATUS_SUCCESS) { status = NDIS_STATUS_PENDING; } else { NdisFreeMemory(pwi, 0, 0); } } if (status != NDIS_STATUS_PENDING) { ParaNdis_DebugHistory(pContext, hopSysReset, NULL, 0, status, 0); } return status; }
/** * This function will dump out the contents of the GlobalMemoryList and free them as well. * Used to dump out leaking memory when driver is exiting * * \sa MpAllocateMemory, MpFreeMemory */ VOID MpFreeAllocatedBlocks () { if (GlobalMemoryManagerInitialized) { NdisAcquireSpinLock (&GlobalMemoryLock); if (!IsListEmpty (&GlobalMemoryList)) { PLIST_ENTRY currentEntry; PMP_MEMORY_BLOCK currentMemory; while (!IsListEmpty (&GlobalMemoryList)) { currentEntry = RemoveHeadList(&GlobalMemoryList); currentMemory = CONTAINING_RECORD (currentEntry, MP_MEMORY_BLOCK, ListEntry); MpTrace(COMP_DBG, DBG_SERIOUS, ("LEAK in %s on line %u\n", currentMemory->File, currentMemory->Line)); NdisFreeMemory (currentMemory, 0, 0); } } NdisReleaseSpinLock (&GlobalMemoryLock); NdisFreeSpinLock(&GlobalMemoryLock); GlobalMemoryManagerInitialized = FALSE; } }
/************************************************************* Required NDIS procedure Stops TX and RX path and finished the function of adapter *************************************************************/ static VOID ParaNdis5_Halt( IN NDIS_HANDLE MiniportAdapterContext) { NDIS_STATUS status = NDIS_STATUS_SUCCESS; BOOLEAN bUnused; PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)MiniportAdapterContext; DEBUG_ENTRY(0); ParaNdis_DebugHistory(pContext, hopHalt, NULL, 1, 0, 0); NdisCancelTimer(&pContext->ConnectTimer, &bUnused); NdisResetEvent(&pContext->HaltEvent); if (NDIS_STATUS_PENDING != ParaNdis5_StopSend(pContext, TRUE, OnSendStopped)) NdisSetEvent(&pContext->HaltEvent); WaitHaltEvent(pContext, "Send"); NdisResetEvent(&pContext->HaltEvent); if (NDIS_STATUS_PENDING != ParaNdis5_StopReceive(pContext, TRUE, OnReceiveStopped)) NdisSetEvent(&pContext->HaltEvent); WaitHaltEvent(pContext, "Receive"); ParaNdis_CleanupContext(pContext); NdisCancelTimer(&pContext->DPCPostProcessTimer, &bUnused); ParaNdis_DebugHistory(pContext, hopHalt, NULL, 0, 0, 0); ParaNdis_DebugRegisterMiniport(pContext, FALSE); NdisFreeMemory(pContext, 0, 0); DEBUG_EXIT_STATUS(0, status); }
VOID NDIS_API PacketUnbindAdapterComplete(IN POPEN_INSTANCE Open, IN NDIS_STATUS Status) { // upcall on NdisCloseAdapter completion // If Open->Status == NDIS_STATUS_PENDING then we must complete the pended unbinding if (Open->Status == NDIS_STATUS_PENDING) { NdisCompleteUnbindAdapter(Open->BindAdapterContext, Status); Open->Status = NDIS_STATUS_SUCCESS; } if (Status != NDIS_STATUS_SUCCESS) return; // Remove Adapter from global list RemoveEntryList(&Open->ListElement); // Free Memory NdisFreeSpinLock(&Open->RequestSpinLock); NdisFreeSpinLock(&Open->RcvQSpinLock); NdisFreeSpinLock(&Open->ResetSpinLock); NdisFreeBufferPool(Open->BufferPool); NdisFreePacketPool(Open->PacketPool); NdisFreeMemory(Open, sizeof(OPEN_INSTANCE), 0); }
/********************************************************** NDIS5.X handler of power management ***********************************************************/ NDIS_STATUS ParaNdis_OnSetPower(PARANDIS_ADAPTER *pContext, tOidDesc *pOid) { NDIS_STATUS status; NDIS_DEVICE_POWER_STATE newState; DEBUG_ENTRY(0); status = ParaNdis_OidSetCopy(pOid, &newState, sizeof(newState)); if (status == NDIS_STATUS_SUCCESS) { tPowerWorkItem *pwi = ParaNdis_AllocateMemory(pContext, sizeof(tPowerWorkItem)); status = NDIS_STATUS_FAILURE; if (pwi) { pwi->pContext = pContext; pwi->state = newState; NdisInitializeWorkItem(&pwi->wi, OnSetPowerWorkItem, pwi); if (NdisScheduleWorkItem(&pwi->wi) == NDIS_STATUS_SUCCESS) { status = NDIS_STATUS_PENDING; } else NdisFreeMemory(pwi, 0, 0); } } return status; }
/****************************************************************** Registered procedure for filtering if resource requirement Required when the device supports MSI, but the driver decides - will it work with MSI or not (currently MSI is supported but does not work, exactly our case). In this case the resource requirement list must be replaced - we need to remove from it all the "message interrupt" resources. When we are ready to work with MSI (VIRTIO_USE_MSIX_INTERRUPT is DEFINED), we just enumerate allocated resources and do not modify them. *******************************************************************/ static NDIS_STATUS ParaNdis6_FilterResource(IN NDIS_HANDLE MiniportAddDeviceContext, IN PIRP Irp) { DPrintf(0, ("[%s] entered\n", __FUNCTION__)); PIO_RESOURCE_REQUIREMENTS_LIST prrl = (PIO_RESOURCE_REQUIREMENTS_LIST)(PVOID)Irp->IoStatus.Information; #ifdef DBG PrintPRRL(prrl); #endif PIO_RESOURCE_REQUIREMENTS_LIST newPrrl = ParseFilterResourceIrp(MiniportAddDeviceContext, prrl, BOOLEAN(bDisableMSI)); if (newPrrl) { Irp->IoStatus.Information = (ULONG_PTR)newPrrl; NdisFreeMemory(prrl, 0, 0); #ifdef DBG PrintPRRL(newPrrl); #endif } else { DPrintf(0, ("[%s] Resource requirement unchanged\n", __FUNCTION__)); } return NDIS_STATUS_SUCCESS; }
NTSTATUS NDIS_API DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath) { // initialiae the driver NDIS_PROTOCOL_CHARACTERISTICS ProtocolChar; NDIS_STRING ProtoName = NDIS_STRING_CONST("EPACKET"); NDIS_STATUS Status; // Because the driver can be loaded once for each Netcard on the system, // and because DriverEntry is called each time, we must ensure that // initialization is performed only once. if (GlobalDeviceExtension != NULL) return NDIS_STATUS_SUCCESS; NdisAllocateMemory((PVOID *)&GlobalDeviceExtension, sizeof(DEVICE_EXTENSION), 0, -1 ); if (GlobalDeviceExtension == NULL) return NDIS_STATUS_RESOURCES; NdisZeroMemory((UCHAR*)GlobalDeviceExtension, sizeof(DEVICE_EXTENSION)); NdisZeroMemory((UCHAR*)&ProtocolChar, sizeof(NDIS_PROTOCOL_CHARACTERISTICS)); ProtocolChar.MajorNdisVersion = 0x03; ProtocolChar.MinorNdisVersion = 0x0a; ProtocolChar.Reserved = 0; ProtocolChar.OpenAdapterCompleteHandler = PacketBindAdapterComplete; ProtocolChar.CloseAdapterCompleteHandler = PacketUnbindAdapterComplete; ProtocolChar.SendCompleteHandler = PacketSendComplete; ProtocolChar.TransferDataCompleteHandler = PacketTransferDataComplete; ProtocolChar.ResetCompleteHandler = PacketResetComplete; ProtocolChar.RequestCompleteHandler = PacketRequestComplete; ProtocolChar.ReceiveHandler = PacketReceiveIndicate; ProtocolChar.ReceiveCompleteHandler = PacketReceiveComplete; ProtocolChar.StatusHandler = PacketStatus; ProtocolChar.StatusCompleteHandler = PacketStatusComplete; ProtocolChar.BindAdapterHandler = PacketBindAdapter; ProtocolChar.UnbindAdapterHandler = PacketUnbindAdapter; ProtocolChar.UnloadProtocolHandler = PacketUnload; ProtocolChar.Name = ProtoName; NdisRegisterProtocol(&Status, &GlobalDeviceExtension->NdisProtocolHandle, &ProtocolChar, sizeof(NDIS_PROTOCOL_CHARACTERISTICS)); if (Status != NDIS_STATUS_SUCCESS) { NdisFreeMemory(GlobalDeviceExtension, sizeof(DEVICE_EXTENSION), 0); return Status; } // initialize open list InitializeListHead(&GlobalDeviceExtension->OpenList); // initialize global device extension GlobalDeviceExtension->DriverObject = DriverObject; return Status; }
VOID RefreshUdpListEntrySafe( VOID ) /*++ Routine Description: Remove stale mapping info from UDP port map list entries. This function is thread-safe. Do NOT acquire id list spin lock around this function. --*/ { LARGE_INTEGER now; PLIST_ENTRY p, temp; NdisAcquireSpinLock(&PortListLock); if (IsListEmpty(&PortListHead)) { // List is empty, nothing to be done. NdisReleaseSpinLock(&PortListLock); return; } NdisGetCurrentSystemTime(&now); p = PortListHead.Flink; while (p != &PortListHead) { PUDP_MAP_CONTEXT Map = CONTAINING_RECORD(p, UDP_MAP_CONTEXT, ListEntry); if (IsTimeOut(&now, &(Map->MapSetTime), &UdpTimeOut)) { // Time out. Release mapping info and reset corresponding hash table entry DBGPRINT(("==> RefreshUdpListEntrySafe: map %d -> %d time out. Delete.\n", Map->OriginalPort, Map->MappedPort)); // Protect the loop from break temp = p; p = p->Flink; // Clear hash table pointer UdpPortMapOutTable[Map->OriginalPort].Map = NULL; UdpPortMapInTable[Map->MappedPort].Map = NULL; // Remove entry and clear memory RemoveEntryList(temp); PortListLength--; NdisFreeMemory(Map, 0, 0); //DBGPRINT(("==> RefreshUdpListEntrySafe: map context memory freed.\n")); // Go to next entry } else { // Go to next entry // Map set time is refreshed when this map is accessed by mapping functions, no need to refresh it here p = p->Flink; } } NdisReleaseSpinLock(&PortListLock); }
/* terminate support */ VOID res_term(VOID) { // DbgPrint ("Resource Term: Entry\n"); // NdisFreeSpinLock(&res__lock); /* free memory */ NdisFreeMemory(res__tbl, (sizeof(RES) * MAX_RES), 0); }
VOID MiniportHalt5( IN NDIS_HANDLE MiniportAdapterContext ) { PADAPTER pAdapt = (PADAPTER)MiniportAdapterContext; NDIS_STATUS Status; // // Delete the ioctl interface that was created when the miniport // was created. // (VOID)ProtocolDeregisterDevice(); #ifdef _DEBUG // 关闭直接包发送接口 if(pAdapt->FileObject) { // // Make sure any threads trying to send have finished. // pAdapt->FileObject->FsContext = NULL; pAdapt->FileObject = NULL; } #endif // // If we have a valid bind, close the miniport below the protocol // if (pAdapt->BindingHandle != NULL) { // // Close the binding below. and wait for it to complete // NdisResetEvent(&pAdapt->Event); NdisCloseAdapter(&Status, pAdapt->BindingHandle); if (Status == NDIS_STATUS_PENDING) { NdisWaitEvent(&pAdapt->Event, 0); Status = pAdapt->Status; } ASSERT (Status == NDIS_STATUS_SUCCESS); pAdapt->BindingHandle = NULL; } // // Free all resources on this adapter structure. // MiniportFreeAllPacketPools5(pAdapt); NdisFreeSpinLock(&pAdapt->Lock); NdisFreeMemory(pAdapt, 0, 0); }
_Use_decl_annotations_ VOID FilterDetach( NDIS_HANDLE FilterModuleContext ) /*++ Routine Description: Filter detach routine. This is a required function that will deallocate all the resources allocated during FilterAttach. NDIS calls FilterAttach to remove a filter instance from a filter stack. Arguments: FilterModuleContext - pointer to the filter context area. Return Value: None. NOTE: Called at PASSIVE_LEVEL and the filter is in paused state --*/ { PMS_FILTER pFilter = (PMS_FILTER)FilterModuleContext; LogFuncEntryMsg(DRIVER_DEFAULT, "Filter: %p", FilterModuleContext); // Filter must be in paused state and pretty much inactive NT_ASSERT(pFilter->State == FilterPaused); NT_ASSERT(pFilter->DeviceStatus == OTLWF_DEVICE_STATUS_UNINTIALIZED); // // Detach must not fail, so do not put any code here that can possibly fail. // // Remove this Filter from the global list NdisAcquireSpinLock(&FilterListLock); RemoveEntryList(&pFilter->FilterModuleLink); NdisReleaseSpinLock(&FilterListLock); // Unregister from address change notifications CancelMibChangeNotify2(pFilter->AddressChangeHandle); pFilter->AddressChangeHandle = NULL; // Close the registry key if (pFilter->InterfaceRegKey) { ZwClose(pFilter->InterfaceRegKey); pFilter->InterfaceRegKey = NULL; } // Free the memory allocated NdisFreeMemory(pFilter, 0, 0); LogFuncExit(DRIVER_DEFAULT); }
void CMiniport::MemoryFree( IN PVOID pMemory) // // Free a block of memory allocated by MemoryAllocate. // { NdisFreeMemory(pMemory, 0, 0); }
CTXVirtQueue::~CTXVirtQueue() { if(m_SGTable != nullptr) { NdisFreeMemory(m_SGTable, 0, 0); } FreeBuffers(); }
/* * Frees the resources allocated * */ VOID PKTFreeResources (POPEN_INSTANCE pOI) { // release the packet buffer if (pOI->Buffer != NULL) { NdisFreeMemory (pOI->Buffer, pOI->BufSize, 0); pOI->Buffer = NULL; } // release the bpf memory if (pOI->bpfprogram != NULL) { NdisFreeMemory (pOI->bpfprogram, pOI->bpfprogramlen, 0); pOI->bpfprogram = NULL; } // free the packet & buffer pools NdisFreeBufferPool (pOI->BufferPool); NdisFreePacketPool (pOI->PacketPool); }
inline void _rtw_vmfree(u8 *pbuf, u32 sz) { #ifdef PLATFORM_LINUX vfree(pbuf); #endif #ifdef PLATFORM_WINDOWS NdisFreeMemory(pbuf,sz, 0); #endif }
void CMiniport::MemoryFree( IN PVOID pMemory) // // Free a block of memory allocated by MemoryAllocate. // { //RETAILMSG(1, (TEXT("builderd:ar6k2:MemoryFree = %x\r\n"), (A_UINT32)pMemory)); NdisFreeMemory(pMemory, 0, 0); }
VOID WAN_RemoveRasLink ( IN PKIP_NDIS_ADAPTER pAdapter, IN PNDIS_WAN_LINE_DOWN pWanLineDown ) { PKIP_RAS_LINK RasLink = NULL; PLIST_ENTRY ListEntry; DBGLOG(( LTrace, "Local MAC: %.2X%.2X%.2X%.2X%.2X%.2X Remote MAC: %.2X%.2X%.2X%.2X%.2X%.2X\n", pWanLineDown->LocalAddress[0], pWanLineDown->LocalAddress[1], pWanLineDown->LocalAddress[2], pWanLineDown->LocalAddress[3], pWanLineDown->LocalAddress[4], pWanLineDown->LocalAddress[5], pWanLineDown->RemoteAddress[0], pWanLineDown->RemoteAddress[1], pWanLineDown->RemoteAddress[2], pWanLineDown->RemoteAddress[3], pWanLineDown->RemoteAddress[4], pWanLineDown->RemoteAddress[5] )); KIP_LOCK_ADAPTER(pAdapter); for( ListEntry = pAdapter->RasLinkList.Flink; ListEntry != &pAdapter->RasLinkList; ListEntry = ListEntry->Flink ) { RasLink = CONTAINING_RECORD(ListEntry,KIP_RAS_LINK,Interface.Link); if ( (RtlCompareMemory(RasLink->RemoteAddress, pWanLineDown->RemoteAddress, ETHARP_HWADDR_LEN) == ETHARP_HWADDR_LEN ) && (RtlCompareMemory(RasLink->Interface.CurrentMacAddress, pWanLineDown->LocalAddress, ETHARP_HWADDR_LEN) == ETHARP_HWADDR_LEN ) ) { RemoveEntryList (&RasLink->Interface.Link); break; } RasLink = NULL; } KIP_UNLOCK_ADAPTER(pAdapter); if ( RasLink ){ // update arp table etharp_remove_static_entry( &RasLink->IpAddr ); etharp_remove_static_entry( &RasLink->RemoteIpAddr ); ProtocolUnBindAdapter( RasLink->Interface.Miniport, &RasLink->Interface, &RasLink->Interface.Protocol ); NdisFreeMemory ( RasLink, sizeof (KIP_RAS_LINK), 0 ); } }
VOID ResetUdpListsSafe( VOID ) /*++ Routine Description: Clear UDP port list entries and reset hash tables. This function is thread-safe. Do NOT acquire port list spin lock around this function. --*/ { PLIST_ENTRY p, temp; NdisAcquireSpinLock(&PortListLock); if (IsListEmpty(&PortListHead)) { // List is empty, nothing to be done. NdisReleaseSpinLock(&PortListLock); return; } p = PortListHead.Flink; while (p != &PortListHead) { PUDP_MAP_CONTEXT Map = CONTAINING_RECORD(p, UDP_MAP_CONTEXT, ListEntry); // Release mapping info and reset corresponding hash table entry DBGPRINT(("==> ResetUdpListsSafe: map %d -> %d removed.\n", Map->OriginalPort, Map->MappedPort)); // Protect the loop from break temp = p; p = p->Flink; // Clear hash table pointer UdpPortMapOutTable[Map->OriginalPort].Map = NULL; UdpPortMapInTable[Map->MappedPort].Map = NULL; // Remove entry and memory RemoveEntryList(temp); PortListLength--; NdisFreeMemory(Map, 0, 0); //DBGPRINT(("==> ResetUdpListsSafe: map context memory freed.\n")); // Go to next entry } if (PortListLength != 0) { // This should not happen PortListLength = 0; } NdisReleaseSpinLock(&PortListLock); }
VOID FilterOidRequestComplete( IN NDIS_HANDLE FilterModuleContext, IN PNDIS_OID_REQUEST Request, IN NDIS_STATUS Status ) { PNETGW_ADAPT pAdapter = (PNETGW_ADAPT)FilterModuleContext; PNDIS_OID_REQUEST OriginalRequest; PINTERNAL_OID_REQUEST pInternalRequest; PFILTER_REQUEST_CONTEXT Context; NdisAcquireSpinLock(&pAdapter->Lock); Context = (PFILTER_REQUEST_CONTEXT)(&Request->SourceReserved[0]); pInternalRequest = (PINTERNAL_OID_REQUEST)(*Context); if (pInternalRequest->bLocal) { NdisReleaseSpinLock(&pAdapter->Lock); NdisFreeMemory(pInternalRequest, 0, 0); return; } OriginalRequest = pInternalRequest->pOrigReq; pAdapter->m_IntReq.Status = Status; pAdapter->m_IntReq.pOrigReq = NULL; pAdapter->m_IntReq.pReq = NULL; NdisReleaseSpinLock(&pAdapter->Lock); switch (Request->RequestType) { case NdisRequestMethod: OriginalRequest->DATA.METHOD_INFORMATION.OutputBufferLength = Request->DATA.METHOD_INFORMATION.OutputBufferLength; OriginalRequest->DATA.METHOD_INFORMATION.BytesRead = Request->DATA.METHOD_INFORMATION.BytesRead; OriginalRequest->DATA.METHOD_INFORMATION.BytesNeeded = Request->DATA.METHOD_INFORMATION.BytesNeeded; OriginalRequest->DATA.METHOD_INFORMATION.BytesWritten = Request->DATA.METHOD_INFORMATION.BytesWritten; break; case NdisRequestSetInformation: OriginalRequest->DATA.SET_INFORMATION.BytesRead = Request->DATA.SET_INFORMATION.BytesRead; OriginalRequest->DATA.SET_INFORMATION.BytesNeeded = Request->DATA.SET_INFORMATION.BytesNeeded; break; case NdisRequestQueryInformation: case NdisRequestQueryStatistics: default: OriginalRequest->DATA.QUERY_INFORMATION.BytesWritten = Request->DATA.QUERY_INFORMATION.BytesWritten; OriginalRequest->DATA.QUERY_INFORMATION.BytesNeeded = Request->DATA.QUERY_INFORMATION.BytesNeeded; break; } (*Context) = NULL; NdisFreeCloneOidRequest(pAdapter->FilterHandle, Request); NdisFOidRequestComplete(pAdapter->FilterHandle, OriginalRequest, Status); }
/********************************************************** called at IRQL = PASSIVE_LEVEL Called on disable, on removal, on standby (if required) ***********************************************************/ static VOID ParaNdis6_Halt(NDIS_HANDLE miniportAdapterContext, NDIS_HALT_ACTION haltAction) { PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)miniportAdapterContext; DEBUG_ENTRY(0); ParaNdis_DebugHistory(pContext, hopHalt, NULL, 1, haltAction, 0); ParaNdis_CleanupContext(pContext); ParaNdis_DebugHistory(pContext, hopHalt, NULL, 0, 0, 0); ParaNdis_DebugRegisterMiniport(pContext, FALSE); NdisFreeMemory(pContext, 0, 0); DEBUG_EXIT_STATUS(2, 0); }