memory.c File Reference

#include "ndissys.h"

Include dependency graph for memory.c:

Go to the source code of this file.

Functions
NDIS_STATUS EXPORT	NdisAllocateMemoryWithTag (OUT PVOID *VirtualAddress, IN UINT Length, IN ULONG Tag)
NDIS_STATUS EXPORT	NdisAllocateMemory (OUT PVOID *VirtualAddress, IN UINT Length, IN UINT MemoryFlags, IN NDIS_PHYSICAL_ADDRESS HighestAcceptableAddress)
VOID EXPORT	NdisFreeMemory (IN PVOID VirtualAddress, IN UINT Length, IN UINT MemoryFlags)
VOID EXPORT	NdisMAllocateSharedMemory (IN NDIS_HANDLE MiniportAdapterHandle, IN ULONG Length, IN BOOLEAN Cached, OUT PVOID *VirtualAddress, OUT PNDIS_PHYSICAL_ADDRESS PhysicalAddress)
VOID NTAPI	NdisMFreeSharedMemoryPassive (PDEVICE_OBJECT DeviceObject, PVOID Context)
VOID EXPORT	NdisMFreeSharedMemory (IN NDIS_HANDLE MiniportAdapterHandle, IN ULONG Length, IN BOOLEAN Cached, IN PVOID VirtualAddress, IN NDIS_PHYSICAL_ADDRESS PhysicalAddress)
VOID NTAPI	NdisMAllocateSharedMemoryPassive (PDEVICE_OBJECT DeviceObject, PVOID Context)
NDIS_STATUS EXPORT	NdisMAllocateSharedMemoryAsync (IN NDIS_HANDLE MiniportAdapterHandle, IN ULONG Length, IN BOOLEAN Cached, IN PVOID Context)
VOID EXPORT	NdisAllocateSharedMemory (IN NDIS_HANDLE NdisAdapterHandle, IN ULONG Length, IN BOOLEAN Cached, OUT PVOID *VirtualAddress, OUT PNDIS_PHYSICAL_ADDRESS PhysicalAddress)
VOID EXPORT	NdisFreeSharedMemory (IN NDIS_HANDLE NdisAdapterHandle, IN ULONG Length, IN BOOLEAN Cached, IN PVOID VirtualAddress, IN NDIS_PHYSICAL_ADDRESS PhysicalAddress)

Function Documentation

NdisAllocateMemory()

NDIS_STATUS EXPORT NdisAllocateMemory	(	OUT PVOID *	VirtualAddress,
		IN UINT	Length,
		IN UINT	MemoryFlags,
		IN NDIS_PHYSICAL_ADDRESS	HighestAcceptableAddress
	)

Definition at line 57 of file memory.c.

{
  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
  if (MemoryFlags & NDIS_MEMORY_CONTIGUOUS)
  {
      /* Allocate contiguous memory (possibly noncached) */
      *VirtualAddress = MmAllocateContiguousMemorySpecifyCache(Length,
                                                               RtlConvertUlongToLargeInteger(0),
                                                               HighestAcceptableAddress,
                                                               RtlConvertUlongToLargeInteger(0),
                                                               (MemoryFlags & NDIS_MEMORY_NONCACHED) ? MmNonCached : MmCached);
  }
  else if (MemoryFlags & NDIS_MEMORY_NONCACHED)
  {
      /* Allocate noncached noncontiguous memory */
      *VirtualAddress = MmAllocateNonCachedMemory(Length);
  }
  else
  {
      /* Allocate plain nonpaged memory */
      *VirtualAddress = ExAllocatePool(NonPagedPool, Length);
  }
 
  if (!*VirtualAddress) {
    NDIS_DbgPrint(MIN_TRACE, ("Allocation failed (%lx, %lx)\n", MemoryFlags, Length));
    return NDIS_STATUS_FAILURE;
  }
 
  return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportInitialize(), and MiQueryResources().

NdisAllocateMemoryWithTag()

NDIS_STATUS EXPORT NdisAllocateMemoryWithTag	(	OUT PVOID *	VirtualAddress,
		IN UINT	Length,
		IN ULONG	Tag
	)

Definition at line 21 of file memory.c.

{
  PVOID Block;
 
  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
  Block = ExAllocatePoolWithTag(NonPagedPool, Length, Tag);
  *VirtualAddress = Block;
 
  if (!Block) {
    NDIS_DbgPrint(MIN_TRACE, ("Failed to allocate memory (%lx)\n", Length));
    return NDIS_STATUS_FAILURE;
  }
 
  return NDIS_STATUS_SUCCESS;
}

Referenced by AllocateTransmitBlocks(), AllocateTransmitBuffers(), mem_alloc_nonpaged_block(), MiniportInitialize(), NvNetAddWakeUpPattern(), NvNetInitializeAdapterResources(), and ParaNdis_AllocateMemory().

NdisAllocateSharedMemory()

VOID EXPORT NdisAllocateSharedMemory	(	IN NDIS_HANDLE	NdisAdapterHandle,
		IN ULONG	Length,
		IN BOOLEAN	Cached,
		OUT PVOID *	VirtualAddress,
		OUT PNDIS_PHYSICAL_ADDRESS	PhysicalAddress
	)

Definition at line 379 of file memory.c.

{
    NdisMAllocateSharedMemory(NdisAdapterHandle,
                              Length,
                              Cached,
                              VirtualAddress,
                              PhysicalAddress);
}

NdisFreeMemory()

VOID EXPORT NdisFreeMemory	(	IN PVOID	VirtualAddress,
		IN UINT	Length,
		IN UINT	MemoryFlags
	)

Definition at line 110 of file memory.c.

{
  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
  if (MemoryFlags & NDIS_MEMORY_CONTIGUOUS)
  {
      /* Free contiguous memory (possibly noncached) */
      MmFreeContiguousMemorySpecifyCache(VirtualAddress,
                                         Length,
                                         (MemoryFlags & NDIS_MEMORY_NONCACHED) ? MmNonCached : MmCached);
  }
  else if (MemoryFlags & NDIS_MEMORY_NONCACHED)
  {
      /* Free noncached noncontiguous memory */
      MmFreeNonCachedMemory(VirtualAddress, Length);
  }
  else
  {
      /* Free nonpaged pool */
      ExFreePool(VirtualAddress);
  }
}

Referenced by AllocatePairOfBuffersOnInit(), CreateOffloadInfo5Internal(), mem_free_nonpaged_block(), MiniportHalt(), MiniportInitialize(), NvNetFreeAdapter(), NvNetInitializeAdapterResources(), NvNetRemoveWakeUpPattern(), OnOidSetNdis5Offload(), OnResetWorkItem(), OnSetPowerWorkItem(), ParaNdis5_CancelSendPackets(), ParaNdis5_Halt(), ParaNdis5_Initialize(), ParaNdis5_Reset(), ParaNdis5_StopSend(), ParaNdis_DoSubmitPacket(), ParaNdis_InitializeContext(), ParaNdis_OidQuery(), ParaNdis_OidQueryCopy(), ParaNdis_OnSetPower(), ParaNdis_ProcessRxPath(), ParaNdis_ProcessTx(), PrepareSendEntry(), ReadNicConfiguration(), VirtIONetFreeBufferDescriptor(), and VirtIONetRelease().

NdisFreeSharedMemory()

VOID EXPORT NdisFreeSharedMemory	(	IN NDIS_HANDLE	NdisAdapterHandle,
		IN ULONG	Length,
		IN BOOLEAN	Cached,
		IN PVOID	VirtualAddress,
		IN NDIS_PHYSICAL_ADDRESS	PhysicalAddress
	)

Definition at line 399 of file memory.c.

{
    NdisMFreeSharedMemory(NdisAdapterHandle,
                          Length,
                          Cached,
                          VirtualAddress,
                          PhysicalAddress);
}

NdisMAllocateSharedMemory()

VOID EXPORT NdisMAllocateSharedMemory	(	IN NDIS_HANDLE	MiniportAdapterHandle,
		IN ULONG	Length,
		IN BOOLEAN	Cached,
		OUT PVOID *	VirtualAddress,
		OUT PNDIS_PHYSICAL_ADDRESS	PhysicalAddress
	)

Definition at line 148 of file memory.c.

{
  PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)MiniportAdapterHandle;
 
  NDIS_DbgPrint(MAX_TRACE,("Called.\n"));
 
  if (KeGetCurrentIrql() != PASSIVE_LEVEL)
  {
      KeBugCheckEx(BUGCODE_ID_DRIVER,
                   (ULONG_PTR)MiniportAdapterHandle,
                   Length,
                   0,
                   1);
  }
 
  *VirtualAddress = Adapter->NdisMiniportBlock.SystemAdapterObject->DmaOperations->AllocateCommonBuffer(
      Adapter->NdisMiniportBlock.SystemAdapterObject, Length, PhysicalAddress, Cached);
}

Referenced by AllocateReceiveBuffers(), AllocateReceiveDescriptors(), AllocateTransmitBuffers(), AllocateTransmitDescriptors(), mem_alloc_contiguous_pages(), MiAllocateSharedMemory(), MiniportInitialize(), NdisAllocateSharedMemory(), NICAllocateIoResources(), and ParaNdis_InitialAllocatePhysicalMemory().

NdisMAllocateSharedMemoryAsync()

NDIS_STATUS EXPORT NdisMAllocateSharedMemoryAsync	(	IN NDIS_HANDLE	MiniportAdapterHandle,
		IN ULONG	Length,
		IN BOOLEAN	Cached,
		IN PVOID	Context
	)

Definition at line 330 of file memory.c.

{
  PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)MiniportAdapterHandle;
  PMINIPORT_SHARED_MEMORY Memory;
 
  NDIS_DbgPrint(MAX_TRACE,("Called.\n"));
 
  ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
 
  /* Must be NonpagedPool because by definition we're at DISPATCH_LEVEL */
  Memory = ExAllocatePool(NonPagedPool, sizeof(MINIPORT_SHARED_MEMORY));
 
  if(!Memory)
    {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
      return NDIS_STATUS_FAILURE;
    }
 
  Memory->AdapterObject = Adapter->NdisMiniportBlock.SystemAdapterObject;
  Memory->Length = Length;
  Memory->Cached = Cached;
  Memory->Adapter = &Adapter->NdisMiniportBlock;
  Memory->Context = Context;
 
  Memory->WorkItem = IoAllocateWorkItem(Adapter->NdisMiniportBlock.DeviceObject);
  if (!Memory->WorkItem)
  {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
      ExFreePool(Memory);
      return NDIS_STATUS_FAILURE;
  }
 
  IoQueueWorkItem(Memory->WorkItem,
                  NdisMAllocateSharedMemoryPassive,
                  DelayedWorkQueue,
                  Memory);
 
  return NDIS_STATUS_PENDING;
}

NdisMAllocateSharedMemoryPassive()

VOID NTAPI NdisMAllocateSharedMemoryPassive	(	PDEVICE_OBJECT	DeviceObject,
		PVOID	Context
	)

Definition at line 295 of file memory.c.

{
  PMINIPORT_SHARED_MEMORY Memory = (PMINIPORT_SHARED_MEMORY)Context;
 
  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
  ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
 
  Memory->VirtualAddress = Memory->AdapterObject->DmaOperations->AllocateCommonBuffer(
      Memory->AdapterObject, Memory->Length, &Memory->PhysicalAddress, Memory->Cached);
 
  if (Memory->Adapter->DriverHandle->MiniportCharacteristics.AllocateCompleteHandler)
      Memory->Adapter->DriverHandle->MiniportCharacteristics.AllocateCompleteHandler(
             Memory->Adapter->MiniportAdapterContext, Memory->VirtualAddress,
             &Memory->PhysicalAddress, Memory->Length, Memory->Context);
 
  IoFreeWorkItem(Memory->WorkItem);
  ExFreePool(Memory);
}

Referenced by NdisMAllocateSharedMemoryAsync().

NdisMFreeSharedMemory()

VOID EXPORT NdisMFreeSharedMemory	(	IN NDIS_HANDLE	MiniportAdapterHandle,
		IN ULONG	Length,
		IN BOOLEAN	Cached,
		IN PVOID	VirtualAddress,
		IN NDIS_PHYSICAL_ADDRESS	PhysicalAddress
	)

Definition at line 215 of file memory.c.

{
  PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)MiniportAdapterHandle;
  PMINIPORT_SHARED_MEMORY Memory;
  PDMA_ADAPTER DmaAdapter = Adapter->NdisMiniportBlock.SystemAdapterObject;
 
  NDIS_DbgPrint(MAX_TRACE,("Called.\n"));
 
  ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
 
  /* Call FreeCommonBuffer synchronously if we are at PASSIVE_LEVEL */
  if (KeGetCurrentIrql() == PASSIVE_LEVEL)
  {
      /* We need this case because we free shared memory asynchronously
       * and the miniport (and DMA adapter object) could be freed before
       * our work item executes. Lucky for us, the scenarios where the
       * freeing needs to be synchronous (failed init, MiniportHalt,
       * and driver unload) are all at PASSIVE_LEVEL so we can just
       * call FreeCommonBuffer synchronously and not have to worry
       * about the miniport falling out from under us */
 
      NDIS_DbgPrint(MID_TRACE,("Freeing shared memory synchronously\n"));
 
      DmaAdapter->DmaOperations->FreeCommonBuffer(DmaAdapter,
                                                  Length,
                                                  PhysicalAddress,
                                                  VirtualAddress,
                                                  Cached);
      return;
  }
 
  /* Must be NonpagedPool because by definition we're at DISPATCH_LEVEL */
  Memory = ExAllocatePool(NonPagedPool, sizeof(MINIPORT_SHARED_MEMORY));
 
  if(!Memory)
    {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
      return;
    }
 
  Memory->AdapterObject = Adapter->NdisMiniportBlock.SystemAdapterObject;
  Memory->Length = Length;
  Memory->PhysicalAddress = PhysicalAddress;
  Memory->VirtualAddress = VirtualAddress;
  Memory->Cached = Cached;
  Memory->Adapter = &Adapter->NdisMiniportBlock;
 
  Memory->WorkItem = IoAllocateWorkItem(Adapter->NdisMiniportBlock.DeviceObject);
  if (!Memory->WorkItem)
  {
      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources\n"));
      ExFreePool(Memory);
      return;
  }
 
  IoQueueWorkItem(Memory->WorkItem,
                  NdisMFreeSharedMemoryPassive,
                  CriticalWorkQueue,
                  Memory);
}

Referenced by MiFreeSharedMemory(), MiniportHalt(), NdisFreeSharedMemory(), NICReleaseIoResources(), NvNetFreeAdapter(), ParaNdis_CleanupContext(), and ParaNdis_FreePhysicalMemory().

NdisMFreeSharedMemoryPassive()

VOID NTAPI NdisMFreeSharedMemoryPassive	(	PDEVICE_OBJECT	DeviceObject,
		PVOID	Context
	)

Definition at line 185 of file memory.c.

{
  PMINIPORT_SHARED_MEMORY Memory = (PMINIPORT_SHARED_MEMORY)Context;
 
  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
  ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
 
  Memory->AdapterObject->DmaOperations->FreeCommonBuffer(
      Memory->AdapterObject, Memory->Length, Memory->PhysicalAddress,
      Memory->VirtualAddress, Memory->Cached);
 
  IoFreeWorkItem(Memory->WorkItem);
  ExFreePool(Memory);
}

Referenced by NdisMFreeSharedMemory().