ndis56common.h File Reference

#include <ndis.h>
#include "osdep.h"
#include "kdebugprint.h"
#include "ethernetutils.h"
#include "virtio_pci.h"
#include "VirtIO.h"
#include "virtio_ring.h"
#include "IONetDescriptor.h"
#include "DebugData.h"

Include dependency graph for ndis56common.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_tagBusResource
struct	_tagAdapterResources
struct	_tagOffloadSettingsFlags
struct	_tagOffloadSettings
struct	_tagChecksumCheckResult
struct	_tagNdisStatistics
struct	_tagNdisOffloadParams
struct	_tagOurCounters
struct	_tagMaxPacketSize
struct	_tagCompletePhysicalAddress
struct	_tagMulticastData
struct	_tagIONetDescriptor
struct	_tagPARANDIS_ADAPTER
struct	_tagCopyPacketResult
struct	_tagSynchronizedContext
struct	_tagTxOperationParameters
struct	_tagMapperResult
struct	_tagPhysicalAddressAllocationContext
union	_tagTcpIpPacketParsingResult

Macros
#define	RtlOffsetToPointer(Base, Offset)   ((PCHAR)(((PCHAR)(Base))+((ULONG_PTR)(Offset))))
#define	RtlPointerToOffset(Base, Pointer)   ((ULONG)(((PCHAR)(Pointer))-((PCHAR)(Base))))
#define	MAX_RX_LOOPS   1000
#define	MAX_NUM_OF_QUEUES   3
#define	VIRTIO_NET_F_CSUM   0 /* Host handles pkts w/ partial csum */
#define	VIRTIO_NET_F_GUEST_CSUM   1 /* Guest handles pkts w/ partial csum */
#define	VIRTIO_NET_F_MAC   5 /* Host has given MAC address. */
#define	VIRTIO_NET_F_GSO   6 /* Host handles pkts w/ any GSO type */
#define	VIRTIO_NET_F_GUEST_TSO4   7 /* Guest can handle TSOv4 in. */
#define	VIRTIO_NET_F_GUEST_TSO6   8 /* Guest can handle TSOv6 in. */
#define	VIRTIO_NET_F_GUEST_ECN   9 /* Guest can handle TSO[6] w/ ECN in. */
#define	VIRTIO_NET_F_GUEST_UFO   10 /* Guest can handle UFO in. */
#define	VIRTIO_NET_F_HOST_TSO4   11 /* Host can handle TSOv4 in. */
#define	VIRTIO_NET_F_HOST_TSO6   12 /* Host can handle TSOv6 in. */
#define	VIRTIO_NET_F_HOST_ECN   13 /* Host can handle TSO[6] w/ ECN in. */
#define	VIRTIO_NET_F_HOST_UFO   14 /* Host can handle UFO in. */
#define	VIRTIO_NET_F_MRG_RXBUF   15 /* Host can handle merged Rx buffers and requires bigger header for that. */
#define	VIRTIO_NET_F_STATUS   16
#define	VIRTIO_NET_F_CTRL_VQ   17 /* Control channel available */
#define	VIRTIO_NET_F_CTRL_RX   18 /* Control channel RX mode support */
#define	VIRTIO_NET_F_CTRL_VLAN   19 /* Control channel VLAN filtering */
#define	VIRTIO_NET_F_CTRL_RX_EXTRA   20 /* Extra RX mode control support */
#define	VIRTIO_NET_S_LINK_UP   1 /* Link is up */
#define	VIRTIO_NET_INVALID_INTERRUPT_STATUS   0xFF
#define	PARANDIS_MULTICAST_LIST_SIZE   32
#define	PARANDIS_MEMORY_TAG   '5muQ'
#define	PARANDIS_FORMAL_LINK_SPEED   (pContext->ulFormalLinkSpeed)
#define	PARANDIS_MAXIMUM_TRANSMIT_SPEED   PARANDIS_FORMAL_LINK_SPEED
#define	PARANDIS_MAXIMUM_RECEIVE_SPEED   PARANDIS_FORMAL_LINK_SPEED
#define	PARANDIS_MIN_LSO_SEGMENTS   2
#define	PARANDIS_MAX_LSO_SIZE   0xF800
#define	PARANDIS_UNLIMITED_PACKETS_TO_INDICATE   (~0ul)

Typedefs
typedef enum _tagInterruptSource	tInterruptSource
typedef VOID(*	ONPAUSECOMPLETEPROC) (VOID *)
typedef enum _tagSendReceiveState	tSendReceiveState
typedef struct _tagBusResource	tBusResource
typedef struct _tagAdapterResources	tAdapterResources
typedef enum _tagOffloadSettingsBit	tOffloadSettingsBit
typedef struct _tagOffloadSettingsFlags	tOffloadSettingsFlags
typedef struct _tagOffloadSettings	tOffloadSettings
typedef struct _tagChecksumCheckResult	tChecksumCheckResult
typedef struct _tagNdisStatistics	NDIS_STATISTICS_INFO
typedef PNDIS_PACKET	tPacketType
typedef PNDIS_PACKET	tPacketHolderType
typedef PNDIS_PACKET	tPacketIndicationType
typedef struct _tagNdisOffloadParams	NDIS_OFFLOAD_PARAMETERS
typedef struct _tagOurCounters	tOurCounters
typedef struct _tagMaxPacketSize	tMaxPacketSize
typedef struct _tagCompletePhysicalAddress	tCompletePhysicalAddress
typedef struct _tagMulticastData	tMulticastData
typedef struct _tagIONetDescriptor	IONetDescriptor
typedef struct _tagIONetDescriptor *	pIONetDescriptor
typedef void(*	tReuseReceiveBufferProc) (void *pContext, pIONetDescriptor pDescriptor)
typedef struct _tagPARANDIS_ADAPTER	PARANDIS_ADAPTER
typedef struct _tagPARANDIS_ADAPTER *	PPARANDIS_ADAPTER
typedef struct _tagCopyPacketResult	tCopyPacketResult
typedef struct _tagSynchronizedContext	tSynchronizedContext
typedef BOOLEAN(NTAPI *	tSynchronizedProcedure) (tSynchronizedContext *context)
typedef struct _tagTxOperationParameters	tTxOperationParameters
typedef struct _tagMapperResult	tMapperResult
typedef VOID(*	tOnAdditionalPhysicalMemoryAllocated) (PARANDIS_ADAPTER *pContext, tCompletePhysicalAddress *pAddresses)
typedef struct _tagPhysicalAddressAllocationContext	tPhysicalAddressAllocationContext
typedef enum _tagppResult	ppResult
typedef union _tagTcpIpPacketParsingResult	tTcpIpPacketParsingResult
typedef enum _tagPacketOffloadRequest	tPacketOffloadRequest

Enumerations
enum	_tagInterruptSource {   isControl = VIRTIO_PCI_ISR_CONFIG , isReceive = 0x10 , isTransmit = 0x20 , isUnknown = 0x40 ,   isBothTransmitReceive = isReceive | isTransmit , isAny = isReceive | isTransmit | isControl | isUnknown , isDisable = 0x80 }
enum	_tagSendReceiveState { srsDisabled = 0 , srsPausing , srsEnabled }
enum	_tagOffloadSettingsBit {   osbT4IpChecksum = (1 << 0) , osbT4TcpChecksum = (1 << 1) , osbT4UdpChecksum = (1 << 2) , osbT4TcpOptionsChecksum = (1 << 3) ,   osbT4IpOptionsChecksum = (1 << 4) , osbT4Lso = (1 << 5) , osbT4LsoIp = (1 << 6) , osbT4LsoTcp = (1 << 7) ,   osbT4RxTCPChecksum = (1 << 8) , osbT4RxTCPOptionsChecksum = (1 << 9) , osbT4RxIPChecksum = (1 << 10) , osbT4RxIPOptionsChecksum = (1 << 11) ,   osbT4RxUDPChecksum = (1 << 12) , osbT6TcpChecksum = (1 << 13) , osbT6UdpChecksum = (1 << 14) , osbT6TcpOptionsChecksum = (1 << 15) ,   osbT6IpExtChecksum = (1 << 16) , osbT6Lso = (1 << 17) , osbT6LsoIpExt = (1 << 18) , osbT6LsoTcpOptions = (1 << 19) ,   osbT6RxTCPChecksum = (1 << 20) , osbT6RxTCPOptionsChecksum = (1 << 21) , osbT6RxUDPChecksum = (1 << 22) , osbT6RxIpExtChecksum = (1 << 23) }
enum	tCopyPacketError {   cpeOK , cpeNoBuffer , cpeInternalError , cpeTooLarge ,   cpeNoIndirect }
enum	_tagppResult {   ppresNotTested = 0 , ppresNotIP = 1 , ppresIPV4 = 2 , ppresIPV6 = 3 ,   ppresIPTooShort = 1 , ppresPCSOK = 1 , ppresCSOK = 2 , ppresCSBad = 3 ,   ppresXxpOther = 1 , ppresXxpKnown = 2 , ppresXxpIncomplete = 3 , ppresIsTCP = 0 ,   ppresIsUDP = 1 }
enum	_tagPacketOffloadRequest {   pcrIpChecksum = (1 << 0) , pcrTcpV4Checksum = (1 << 1) , pcrUdpV4Checksum = (1 << 2) , pcrTcpV6Checksum = (1 << 3) ,   pcrUdpV6Checksum = (1 << 4) , pcrTcpChecksum = (pcrTcpV4Checksum | pcrTcpV6Checksum) , pcrUdpChecksum = (pcrUdpV4Checksum | pcrUdpV6Checksum) , pcrAnyChecksum = (pcrIpChecksum | pcrTcpV4Checksum | pcrUdpV4Checksum | pcrTcpV6Checksum | pcrUdpV6Checksum) ,   pcrLSO = (1 << 5) , pcrIsIP = (1 << 6) , pcrFixIPChecksum = (1 << 7) , pcrFixPHChecksum = (1 << 8) ,   pcrFixTcpV4Checksum = (1 << 9) , pcrFixUdpV4Checksum = (1 << 10) , pcrFixTcpV6Checksum = (1 << 11) , pcrFixUdpV6Checksum = (1 << 12) ,   pcrFixXxpChecksum = (pcrFixTcpV4Checksum | pcrFixUdpV4Checksum | pcrFixTcpV6Checksum | pcrFixUdpV6Checksum) , pcrPriorityTag = (1 << 13) , pcrNoIndirect = (1 << 14) }

Functions
static bool	VirtIODeviceGetHostFeature (PARANDIS_ADAPTER *pContext, unsigned uFeature)
static void	VirtIODeviceEnableGuestFeature (PARANDIS_ADAPTER *pContext, unsigned uFeature)
static BOOLEAN FORCEINLINE	IsTimeToReleaseTx (PARANDIS_ADAPTER *pContext)
static BOOLEAN FORCEINLINE	IsValidVlanId (PARANDIS_ADAPTER *pContext, ULONG VlanID)
static BOOLEAN FORCEINLINE	IsVlanSupported (PARANDIS_ADAPTER *pContext)
static BOOLEAN FORCEINLINE	IsPrioritySupported (PARANDIS_ADAPTER *pContext)
BOOLEAN	ParaNdis_ValidateMacAddress (PUCHAR pcMacAddress, BOOLEAN bLocal)
NDIS_STATUS	ParaNdis_InitializeContext (PARANDIS_ADAPTER *pContext, PNDIS_RESOURCE_LIST ResourceList)
NDIS_STATUS	ParaNdis_FinishInitialization (PARANDIS_ADAPTER *pContext)
VOID	ParaNdis_CleanupContext (PARANDIS_ADAPTER *pContext)
UINT	ParaNdis_VirtIONetReleaseTransmitBuffers (PARANDIS_ADAPTER *pContext)
ULONG	ParaNdis_DPCWorkBody (PARANDIS_ADAPTER *pContext, ULONG ulMaxPacketsToIndicate)
NDIS_STATUS	ParaNdis_SetMulticastList (PARANDIS_ADAPTER *pContext, PVOID Buffer, ULONG BufferSize, PUINT pBytesRead, PUINT pBytesNeeded)
VOID	ParaNdis_VirtIOEnableIrqSynchronized (PARANDIS_ADAPTER *pContext, ULONG interruptSource)
VOID	ParaNdis_VirtIODisableIrqSynchronized (PARANDIS_ADAPTER *pContext, ULONG interruptSource)
static __inline struct virtqueue *	ParaNdis_GetQueueForInterrupt (PARANDIS_ADAPTER *pContext, ULONG interruptSource)
static __inline BOOLEAN	ParaNDIS_IsQueueInterruptEnabled (struct virtqueue *_vq)
VOID	ParaNdis_OnPnPEvent (PARANDIS_ADAPTER *pContext, NDIS_DEVICE_PNP_EVENT pEvent, PVOID pInfo, ULONG ulSize)
BOOLEAN	ParaNdis_OnLegacyInterrupt (PARANDIS_ADAPTER *pContext, BOOLEAN *pRunDpc)
BOOLEAN	ParaNdis_OnQueuedInterrupt (PARANDIS_ADAPTER *pContext, BOOLEAN *pRunDpc, ULONG knownInterruptSources)
VOID	ParaNdis_OnShutdown (PARANDIS_ADAPTER *pContext)
BOOLEAN	ParaNdis_CheckForHang (PARANDIS_ADAPTER *pContext)
VOID	ParaNdis_ReportLinkStatus (PARANDIS_ADAPTER *pContext, BOOLEAN bForce)
NDIS_STATUS	ParaNdis_PowerOn (PARANDIS_ADAPTER *pContext)
VOID	ParaNdis_PowerOff (PARANDIS_ADAPTER *pContext)
void	ParaNdis_DebugInitialize (PVOID DriverObject, PVOID RegistryPath)
void	ParaNdis_DebugCleanup (PDRIVER_OBJECT pDriverObject)
void	ParaNdis_DebugRegisterMiniport (PARANDIS_ADAPTER *pContext, BOOLEAN bRegister)
static void FORCEINLINE	ParaNdis_DebugHistory (PARANDIS_ADAPTER *pContext, eHistoryLogOperation op, PVOID pParam1, ULONG lParam2, ULONG lParam3, ULONG lParam4)
tCopyPacketResult	ParaNdis_DoCopyPacketData (PARANDIS_ADAPTER *pContext, tTxOperationParameters *pParams)
tCopyPacketResult	ParaNdis_DoSubmitPacket (PARANDIS_ADAPTER *pContext, tTxOperationParameters *Params)
void	ParaNdis_ResetOffloadSettings (PARANDIS_ADAPTER *pContext, tOffloadSettingsFlags *pDest, PULONG from)
tChecksumCheckResult	ParaNdis_CheckRxChecksum (PARANDIS_ADAPTER *pContext, ULONG virtioFlags, PVOID pRxPacket, ULONG len)
void	ParaNdis_CallOnBugCheck (PARANDIS_ADAPTER *pContext)
PVOID	ParaNdis_AllocateMemory (PARANDIS_ADAPTER *pContext, ULONG ulRequiredSize)
NDIS_STATUS NTAPI	ParaNdis_FinishSpecificInitialization (PARANDIS_ADAPTER *pContext)
VOID	ParaNdis_FinalizeCleanup (PARANDIS_ADAPTER *pContext)
NDIS_HANDLE	ParaNdis_OpenNICConfiguration (PARANDIS_ADAPTER *pContext)
tPacketIndicationType	ParaNdis_IndicateReceivedPacket (PARANDIS_ADAPTER *pContext, PVOID dataBuffer, PULONG pLength, BOOLEAN bPrepareOnly, pIONetDescriptor pBufferDesc)
VOID	ParaNdis_IndicateReceivedBatch (PARANDIS_ADAPTER *pContext, tPacketIndicationType *pBatch, ULONG nofPackets)
VOID	ParaNdis_PacketMapper (PARANDIS_ADAPTER *pContext, tPacketType packet, PVOID Reference, struct VirtIOBufferDescriptor *buffers, pIONetDescriptor pDesc, tMapperResult *pMapperResult)
tCopyPacketResult	ParaNdis_PacketCopier (tPacketType packet, PVOID dest, ULONG maxSize, PVOID refValue, BOOLEAN bPreview)
BOOLEAN	ParaNdis_ProcessTx (PARANDIS_ADAPTER *pContext, BOOLEAN IsDpc, BOOLEAN IsInterrupt)
BOOLEAN	ParaNdis_SetTimer (NDIS_HANDLE timer, LONG millies)
BOOLEAN	ParaNdis_SynchronizeWithInterrupt (PARANDIS_ADAPTER *pContext, ULONG messageId, tSynchronizedProcedure procedure, PVOID parameter)
VOID	ParaNdis_Suspend (PARANDIS_ADAPTER *pContext)
VOID	ParaNdis_Resume (PARANDIS_ADAPTER *pContext)
VOID	ParaNdis_OnTransmitBufferReleased (PARANDIS_ADAPTER *pContext, IONetDescriptor *pDesc)
BOOLEAN	ParaNdis_InitialAllocatePhysicalMemory (PARANDIS_ADAPTER *pContext, tCompletePhysicalAddress *pAddresses)
VOID	ParaNdis_FreePhysicalMemory (PARANDIS_ADAPTER *pContext, tCompletePhysicalAddress *pAddresses)
BOOLEAN	ParaNdis_BindBufferToPacket (PARANDIS_ADAPTER *pContext, pIONetDescriptor pBufferDesc)
void	ParaNdis_UnbindBufferFromPacket (PARANDIS_ADAPTER *pContext, pIONetDescriptor pBufferDesc)
void	ParaNdis_IndicateConnect (PARANDIS_ADAPTER *pContext, BOOLEAN bConnected, BOOLEAN bForce)
void	ParaNdis_RestoreDeviceConfigurationAfterReset (PARANDIS_ADAPTER *pContext)
VOID	ParaNdis_UpdateDeviceFilters (PARANDIS_ADAPTER *pContext)
VOID	ParaNdis_DeviceFiltersUpdateVlanId (PARANDIS_ADAPTER *pContext)
VOID	ParaNdis_SetPowerState (PARANDIS_ADAPTER *pContext, NDIS_DEVICE_POWER_STATE newState)
tTcpIpPacketParsingResult	ParaNdis_CheckSumVerify (PVOID buffer, ULONG size, ULONG flags, LPCSTR caller)
tTcpIpPacketParsingResult	ParaNdis_ReviewIPPacket (PVOID buffer, ULONG size, LPCSTR caller)
void	ParaNdis_PadPacketReceived (PVOID pDataBuffer, PULONG pLength)

Variables
VirtIOSystemOps	ParaNdisSystemOps
static const ULONG	PARANDIS_PACKET_FILTERS

Macro Definition Documentation

MAX_NUM_OF_QUEUES

#define MAX_NUM_OF_QUEUES   3

Definition at line 93 of file ndis56common.h.

MAX_RX_LOOPS

#define MAX_RX_LOOPS   1000

Definition at line 90 of file ndis56common.h.

PARANDIS_FORMAL_LINK_SPEED

#define PARANDIS_FORMAL_LINK_SPEED   (pContext->ulFormalLinkSpeed)

Definition at line 121 of file ndis56common.h.

PARANDIS_MAX_LSO_SIZE

#define PARANDIS_MAX_LSO_SIZE   0xF800

Definition at line 126 of file ndis56common.h.

PARANDIS_MAXIMUM_RECEIVE_SPEED

#define PARANDIS_MAXIMUM_RECEIVE_SPEED   PARANDIS_FORMAL_LINK_SPEED

Definition at line 123 of file ndis56common.h.

PARANDIS_MAXIMUM_TRANSMIT_SPEED

#define PARANDIS_MAXIMUM_TRANSMIT_SPEED   PARANDIS_FORMAL_LINK_SPEED

Definition at line 122 of file ndis56common.h.

PARANDIS_MEMORY_TAG

#define PARANDIS_MEMORY_TAG   '5muQ'

Definition at line 120 of file ndis56common.h.

PARANDIS_MIN_LSO_SEGMENTS

#define PARANDIS_MIN_LSO_SEGMENTS   2

Definition at line 124 of file ndis56common.h.

PARANDIS_MULTICAST_LIST_SIZE

#define PARANDIS_MULTICAST_LIST_SIZE   32

Definition at line 119 of file ndis56common.h.

PARANDIS_UNLIMITED_PACKETS_TO_INDICATE

#define PARANDIS_UNLIMITED_PACKETS_TO_INDICATE   (~0ul)

Definition at line 128 of file ndis56common.h.

RtlOffsetToPointer

#define RtlOffsetToPointer	(		Base,
			Offset
	)		((PCHAR)(((PCHAR)(Base))+((ULONG_PTR)(Offset))))

Definition at line 50 of file ndis56common.h.

RtlPointerToOffset

#define RtlPointerToOffset	(		Base,
			Pointer
	)		((ULONG)(((PCHAR)(Pointer))-((PCHAR)(Base))))

Definition at line 54 of file ndis56common.h.

VIRTIO_NET_F_CSUM

#define VIRTIO_NET_F_CSUM   0 /* Host handles pkts w/ partial csum */

Definition at line 96 of file ndis56common.h.

VIRTIO_NET_F_CTRL_RX

#define VIRTIO_NET_F_CTRL_RX   18 /* Control channel RX mode support */

Definition at line 111 of file ndis56common.h.

VIRTIO_NET_F_CTRL_RX_EXTRA

#define VIRTIO_NET_F_CTRL_RX_EXTRA   20 /* Extra RX mode control support */

Definition at line 113 of file ndis56common.h.

VIRTIO_NET_F_CTRL_VLAN

#define VIRTIO_NET_F_CTRL_VLAN   19 /* Control channel VLAN filtering */

Definition at line 112 of file ndis56common.h.

VIRTIO_NET_F_CTRL_VQ

#define VIRTIO_NET_F_CTRL_VQ   17 /* Control channel available */

Definition at line 110 of file ndis56common.h.

VIRTIO_NET_F_GSO

#define VIRTIO_NET_F_GSO   6 /* Host handles pkts w/ any GSO type */

Definition at line 99 of file ndis56common.h.

VIRTIO_NET_F_GUEST_CSUM

#define VIRTIO_NET_F_GUEST_CSUM   1 /* Guest handles pkts w/ partial csum */

Definition at line 97 of file ndis56common.h.

VIRTIO_NET_F_GUEST_ECN

#define VIRTIO_NET_F_GUEST_ECN   9 /* Guest can handle TSO[6] w/ ECN in. */

Definition at line 102 of file ndis56common.h.

VIRTIO_NET_F_GUEST_TSO4

#define VIRTIO_NET_F_GUEST_TSO4   7 /* Guest can handle TSOv4 in. */

Definition at line 100 of file ndis56common.h.

VIRTIO_NET_F_GUEST_TSO6

#define VIRTIO_NET_F_GUEST_TSO6   8 /* Guest can handle TSOv6 in. */

Definition at line 101 of file ndis56common.h.

VIRTIO_NET_F_GUEST_UFO

#define VIRTIO_NET_F_GUEST_UFO   10 /* Guest can handle UFO in. */

Definition at line 103 of file ndis56common.h.

VIRTIO_NET_F_HOST_ECN

#define VIRTIO_NET_F_HOST_ECN   13 /* Host can handle TSO[6] w/ ECN in. */

Definition at line 106 of file ndis56common.h.

VIRTIO_NET_F_HOST_TSO4

#define VIRTIO_NET_F_HOST_TSO4   11 /* Host can handle TSOv4 in. */

Definition at line 104 of file ndis56common.h.

VIRTIO_NET_F_HOST_TSO6

#define VIRTIO_NET_F_HOST_TSO6   12 /* Host can handle TSOv6 in. */

Definition at line 105 of file ndis56common.h.

VIRTIO_NET_F_HOST_UFO

#define VIRTIO_NET_F_HOST_UFO   14 /* Host can handle UFO in. */

Definition at line 107 of file ndis56common.h.

VIRTIO_NET_F_MAC

#define VIRTIO_NET_F_MAC   5 /* Host has given MAC address. */

Definition at line 98 of file ndis56common.h.

VIRTIO_NET_F_MRG_RXBUF

#define VIRTIO_NET_F_MRG_RXBUF   15 /* Host can handle merged Rx buffers and requires bigger header for that. */

Definition at line 108 of file ndis56common.h.

VIRTIO_NET_F_STATUS

#define VIRTIO_NET_F_STATUS   16

Definition at line 109 of file ndis56common.h.

VIRTIO_NET_INVALID_INTERRUPT_STATUS

#define VIRTIO_NET_INVALID_INTERRUPT_STATUS   0xFF

Definition at line 117 of file ndis56common.h.

VIRTIO_NET_S_LINK_UP

#define VIRTIO_NET_S_LINK_UP   1 /* Link is up */

Definition at line 115 of file ndis56common.h.

Typedef Documentation

IONetDescriptor

typedef struct _tagIONetDescriptor IONetDescriptor

NDIS_OFFLOAD_PARAMETERS

typedef struct _tagNdisOffloadParams NDIS_OFFLOAD_PARAMETERS

NDIS_STATISTICS_INFO

typedef struct _tagNdisStatistics NDIS_STATISTICS_INFO

ONPAUSECOMPLETEPROC

typedef VOID(* ONPAUSECOMPLETEPROC) (VOID *)

Definition at line 150 of file ndis56common.h.

PARANDIS_ADAPTER

typedef struct _tagPARANDIS_ADAPTER PARANDIS_ADAPTER

pIONetDescriptor

typedef struct _tagIONetDescriptor * pIONetDescriptor

PPARANDIS_ADAPTER

typedef struct _tagPARANDIS_ADAPTER * PPARANDIS_ADAPTER

ppResult

typedef enum _tagppResult ppResult

tAdapterResources

typedef struct _tagAdapterResources tAdapterResources

tBusResource

typedef struct _tagBusResource tBusResource

tChecksumCheckResult

typedef struct _tagChecksumCheckResult tChecksumCheckResult

tCompletePhysicalAddress

typedef struct _tagCompletePhysicalAddress tCompletePhysicalAddress

tCopyPacketResult

typedef struct _tagCopyPacketResult tCopyPacketResult

tInterruptSource

typedef enum _tagInterruptSource tInterruptSource

tMapperResult

typedef struct _tagMapperResult tMapperResult

tMaxPacketSize

typedef struct _tagMaxPacketSize tMaxPacketSize

tMulticastData

typedef struct _tagMulticastData tMulticastData

tOffloadSettings

typedef struct _tagOffloadSettings tOffloadSettings

tOffloadSettingsBit

typedef enum _tagOffloadSettingsBit tOffloadSettingsBit

tOffloadSettingsFlags

typedef struct _tagOffloadSettingsFlags tOffloadSettingsFlags

tOnAdditionalPhysicalMemoryAllocated

typedef VOID(* tOnAdditionalPhysicalMemoryAllocated) (PARANDIS_ADAPTER *pContext, tCompletePhysicalAddress *pAddresses)

Definition at line 772 of file ndis56common.h.

tOurCounters

typedef struct _tagOurCounters tOurCounters

tPacketHolderType

typedef PNDIS_PACKET tPacketHolderType

Definition at line 287 of file ndis56common.h.

tPacketIndicationType

typedef PNDIS_PACKET tPacketIndicationType

Definition at line 288 of file ndis56common.h.

tPacketOffloadRequest

typedef enum _tagPacketOffloadRequest tPacketOffloadRequest

tPacketType

typedef PNDIS_PACKET tPacketType

Definition at line 286 of file ndis56common.h.

tPhysicalAddressAllocationContext

typedef struct _tagPhysicalAddressAllocationContext tPhysicalAddressAllocationContext

tReuseReceiveBufferProc

typedef void(* tReuseReceiveBufferProc) (void *pContext, pIONetDescriptor pDescriptor)

Definition at line 344 of file ndis56common.h.

tSendReceiveState

typedef enum _tagSendReceiveState tSendReceiveState

tSynchronizedContext

typedef struct _tagSynchronizedContext tSynchronizedContext

tSynchronizedProcedure

typedef BOOLEAN(NTAPI * tSynchronizedProcedure) (tSynchronizedContext *context)

Definition at line 503 of file ndis56common.h.

tTcpIpPacketParsingResult

typedef union _tagTcpIpPacketParsingResult tTcpIpPacketParsingResult

tTxOperationParameters

typedef struct _tagTxOperationParameters tTxOperationParameters

Enumeration Type Documentation

_tagInterruptSource

enum _tagInterruptSource

Enumerator
isControl
isReceive
isTransmit
isUnknown
isBothTransmitReceive
isAny
isDisable

Definition at line 132 of file ndis56common.h.

{
    isControl  = VIRTIO_PCI_ISR_CONFIG,
    isReceive  = 0x10,
    isTransmit = 0x20,
    isUnknown  = 0x40,
    isBothTransmitReceive = isReceive | isTransmit,
    isAny      = isReceive | isTransmit | isControl | isUnknown,
    isDisable  = 0x80
}tInterruptSource;

_tagOffloadSettingsBit

enum _tagOffloadSettingsBit

Enumerator
osbT4IpChecksum
osbT4TcpChecksum
osbT4UdpChecksum
osbT4TcpOptionsChecksum
osbT4IpOptionsChecksum
osbT4Lso
osbT4LsoIp
osbT4LsoTcp
osbT4RxTCPChecksum
osbT4RxTCPOptionsChecksum
osbT4RxIPChecksum
osbT4RxIPOptionsChecksum
osbT4RxUDPChecksum
osbT6TcpChecksum
osbT6UdpChecksum
osbT6TcpOptionsChecksum
osbT6IpExtChecksum
osbT6Lso
osbT6LsoIpExt
osbT6LsoTcpOptions
osbT6RxTCPChecksum
osbT6RxTCPOptionsChecksum
osbT6RxUDPChecksum
osbT6RxIpExtChecksum

Definition at line 177 of file ndis56common.h.

{
    osbT4IpChecksum = (1 << 0),
    osbT4TcpChecksum = (1 << 1),
    osbT4UdpChecksum = (1 << 2),
    osbT4TcpOptionsChecksum = (1 << 3),
    osbT4IpOptionsChecksum = (1 << 4),
    osbT4Lso = (1 << 5),
    osbT4LsoIp = (1 << 6),
    osbT4LsoTcp = (1 << 7),
    osbT4RxTCPChecksum = (1 << 8),
    osbT4RxTCPOptionsChecksum = (1 << 9),
    osbT4RxIPChecksum = (1 << 10),
    osbT4RxIPOptionsChecksum = (1 << 11),
    osbT4RxUDPChecksum = (1 << 12),
    osbT6TcpChecksum = (1 << 13),
    osbT6UdpChecksum = (1 << 14),
    osbT6TcpOptionsChecksum = (1 << 15),
    osbT6IpExtChecksum = (1 << 16),
    osbT6Lso = (1 << 17),
    osbT6LsoIpExt = (1 << 18),
    osbT6LsoTcpOptions = (1 << 19),
    osbT6RxTCPChecksum = (1 << 20),
    osbT6RxTCPOptionsChecksum = (1 << 21),
    osbT6RxUDPChecksum = (1 << 22),
    osbT6RxIpExtChecksum = (1 << 23),
}tOffloadSettingsBit;

_tagPacketOffloadRequest

enum _tagPacketOffloadRequest

Enumerator
pcrIpChecksum
pcrTcpV4Checksum
pcrUdpV4Checksum
pcrTcpV6Checksum
pcrUdpV6Checksum
pcrTcpChecksum
pcrUdpChecksum
pcrAnyChecksum
pcrLSO
pcrIsIP
pcrFixIPChecksum
pcrFixPHChecksum
pcrFixTcpV4Checksum
pcrFixUdpV4Checksum
pcrFixTcpV6Checksum
pcrFixUdpV6Checksum
pcrFixXxpChecksum
pcrPriorityTag
pcrNoIndirect

Definition at line 863 of file ndis56common.h.

{
    pcrIpChecksum  = (1 << 0),
    pcrTcpV4Checksum = (1 << 1),
    pcrUdpV4Checksum = (1 << 2),
    pcrTcpV6Checksum = (1 << 3),
    pcrUdpV6Checksum = (1 << 4),
    pcrTcpChecksum = (pcrTcpV4Checksum | pcrTcpV6Checksum),
    pcrUdpChecksum = (pcrUdpV4Checksum | pcrUdpV6Checksum),
    pcrAnyChecksum = (pcrIpChecksum | pcrTcpV4Checksum | pcrUdpV4Checksum | pcrTcpV6Checksum | pcrUdpV6Checksum),
    pcrLSO   = (1 << 5),
    pcrIsIP  = (1 << 6),
    pcrFixIPChecksum = (1 << 7),
    pcrFixPHChecksum = (1 << 8),
    pcrFixTcpV4Checksum = (1 << 9),
    pcrFixUdpV4Checksum = (1 << 10),
    pcrFixTcpV6Checksum = (1 << 11),
    pcrFixUdpV6Checksum = (1 << 12),
    pcrFixXxpChecksum = (pcrFixTcpV4Checksum | pcrFixUdpV4Checksum | pcrFixTcpV6Checksum | pcrFixUdpV6Checksum),
    pcrPriorityTag = (1 << 13),
    pcrNoIndirect  = (1 << 14)
}tPacketOffloadRequest;

_tagppResult

enum _tagppResult

Enumerator
ppresNotTested
ppresNotIP
ppresIPV4
ppresIPV6
ppresIPTooShort
ppresPCSOK
ppresCSOK
ppresCSBad
ppresXxpOther
ppresXxpKnown
ppresXxpIncomplete
ppresIsTCP
ppresIsUDP

Definition at line 822 of file ndis56common.h.

{
    ppresNotTested = 0,
    ppresNotIP     = 1,
    ppresIPV4      = 2,
    ppresIPV6      = 3,
    ppresIPTooShort  = 1,
    ppresPCSOK       = 1,
    ppresCSOK        = 2,
    ppresCSBad       = 3,
    ppresXxpOther    = 1,
    ppresXxpKnown    = 2,
    ppresXxpIncomplete = 3,
    ppresIsTCP         = 0,
    ppresIsUDP         = 1,
}ppResult;

_tagSendReceiveState

enum _tagSendReceiveState

Enumerator
srsDisabled
srsPausing
srsEnabled

Definition at line 153 of file ndis56common.h.

{
    srsDisabled = 0,        // initial state
    srsPausing,
    srsEnabled
} tSendReceiveState;

tCopyPacketError

enum tCopyPacketError

Enumerator
cpeOK
cpeNoBuffer
cpeInternalError
cpeTooLarge
cpeNoIndirect

Definition at line 490 of file ndis56common.h.

{ cpeOK, cpeNoBuffer, cpeInternalError, cpeTooLarge, cpeNoIndirect } tCopyPacketError;

Function Documentation

IsPrioritySupported()

static BOOLEAN FORCEINLINE IsPrioritySupported ( PARANDIS_ADAPTER *  pContext )

static

Definition at line 547 of file ndis56common.h.

{
    return pContext->ulPriorityVlanSetting & 1;
}

Referenced by ParaNdis_DeviceFiltersUpdateVlanId(), ParaNdis_IndicateReceivedPacket(), ParaNdis_OidQueryCommon(), and PrepareSendEntry().

IsTimeToReleaseTx()

static BOOLEAN FORCEINLINE IsTimeToReleaseTx ( PARANDIS_ADAPTER *  pContext )

static

Definition at line 528 of file ndis56common.h.

{
#ifndef LAZY_TX_RELEASE
    return pContext->nofFreeTxDescriptors < pContext->maxFreeTxDescriptors;
#else
    return pContext->nofFreeTxDescriptors == 0;
#endif
}

Referenced by ParaNdis_ProcessTx().

IsValidVlanId()

static BOOLEAN FORCEINLINE IsValidVlanId ( PARANDIS_ADAPTER *  pContext, ULONG  VlanID  )

static

Definition at line 537 of file ndis56common.h.

{
    return pContext->VlanId == 0 || pContext->VlanId == VlanID;
}

Referenced by PrepareSendEntry().

IsVlanSupported()

static BOOLEAN FORCEINLINE IsVlanSupported ( PARANDIS_ADAPTER *  pContext )

static

Definition at line 542 of file ndis56common.h.

{
    return pContext->ulPriorityVlanSetting & 2;
}

Referenced by ParaNdis_DeviceFiltersUpdateVlanId(), ParaNdis_IndicateReceivedPacket(), ParaNdis_OidQueryCommon(), ParaNdis_OnSetVlanId(), PrepareSendEntry(), and ReadNicConfiguration().

ParaNdis_AllocateMemory()

PVOID ParaNdis_AllocateMemory	(	PARANDIS_ADAPTER *	pContext,
		ULONG	ulRequiredSize
	)

Definition at line 78 of file ParaNdis5-Impl.c.

{
    PVOID p;
    UNREFERENCED_PARAMETER(pContext);
    if (NDIS_STATUS_SUCCESS != NdisAllocateMemoryWithTag(&p, ulRequiredSize, PARANDIS_MEMORY_TAG))
        p = NULL;
    if (!p)
    {
        DPrintf(0, ("[%s] failed (%d bytes)", __FUNCTION__, ulRequiredSize));
    }
    return p;
}

Referenced by AllocatePairOfBuffersOnInit(), CreateOffloadInfo5Internal(), ParaNdis5_Initialize(), ParaNdis5_Reset(), ParaNdis_DoSubmitPacket(), ParaNdis_OnSetPower(), ParaNdis_ProcessRxPath(), ParaNdis_VirtIONetInit(), PrepareSendEntry(), and ReadNicConfiguration().

ParaNdis_BindBufferToPacket()

BOOLEAN ParaNdis_BindBufferToPacket	(	PARANDIS_ADAPTER *	pContext,
		pIONetDescriptor	pBufferDesc
	)

Definition at line 390 of file ParaNdis5-Impl.c.

{
    NDIS_STATUS     status;
    PNDIS_BUFFER    pBuffer = NULL;
    PNDIS_PACKET    Packet = NULL;
    NdisAllocatePacket(&status, &Packet, pContext->PacketPool);
    if (status == NDIS_STATUS_SUCCESS)
    {
        NdisReinitializePacket(Packet);
        NdisAllocateBuffer(
            &status,
            &pBuffer,
            pContext->BuffersPool,
            RtlOffsetToPointer(pBufferDesc->DataInfo.Virtual, pContext->bUseMergedBuffers ? pContext->nVirtioHeaderSize : 0),
            MaxNdisBufferDataSize(pContext, pBufferDesc));
    }
    if (status == NDIS_STATUS_SUCCESS)
    {
        PNDIS_PACKET_OOB_DATA pOOB = NDIS_OOB_DATA_FROM_PACKET(Packet);
        NdisZeroMemory(pOOB, sizeof(NDIS_PACKET_OOB_DATA));
        NDIS_SET_PACKET_HEADER_SIZE(Packet, ETH_HEADER_SIZE);
        NdisChainBufferAtFront(Packet, pBuffer);
        pBufferDesc->pHolder = Packet;
    }
    else
    {
        if (pBuffer) NdisFreeBuffer(pBuffer);
        if (Packet)  NdisFreePacket(Packet);
    }
    return status == NDIS_STATUS_SUCCESS;
}

Referenced by AllocatePairOfBuffersOnInit().

ParaNdis_CallOnBugCheck()

void ParaNdis_CallOnBugCheck

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 2867 of file ParaNdis-Common.c.

{
    if (pContext->IODevice.isr)
    {
#ifdef DBG_USE_VIRTIO_PCI_ISR_FOR_HOST_REPORT
        WriteVirtIODeviceByte(pContext->IODevice.isr, 1);
#endif
    }
}

Referenced by FillDataOnBugCheck().

ParaNdis_CheckForHang()

BOOLEAN ParaNdis_CheckForHang

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 2423 of file ParaNdis-Common.c.

{
    static int nHangOn = 0;
    BOOLEAN b = nHangOn >= 3 && nHangOn < 6;
    DEBUG_ENTRY(3);
    b |= CheckRunningDpc(pContext);
    //uncomment to cause 3 consecutive resets
    //nHangOn++;
    DEBUG_EXIT_STATUS(b ? 0 : 6, b);
    return b;
}

Referenced by ParaNdis5_CheckForHang().

ParaNdis_CheckRxChecksum()

tChecksumCheckResult ParaNdis_CheckRxChecksum	(	PARANDIS_ADAPTER *	pContext,
		ULONG	virtioFlags,
		PVOID	pRxPacket,
		ULONG	len
	)

Definition at line 2877 of file ParaNdis-Common.c.

{
    tOffloadSettingsFlags f = pContext->Offload.flags;
    tChecksumCheckResult res, resIp;
    PVOID pIpHeader = RtlOffsetToPointer(pRxPacket, ETH_HEADER_SIZE);
    tTcpIpPacketParsingResult ppr;
    ULONG flagsToCalculate = 0;
    res.value = 0;
    resIp.value = 0;
 
    //VIRTIO_NET_HDR_F_NEEDS_CSUM - we need to calculate TCP/UDP CS
    //VIRTIO_NET_HDR_F_DATA_VALID - host tells us TCP/UDP CS is OK
 
    if (f.fRxIPChecksum) flagsToCalculate |= pcrIpChecksum; // check only
 
    if (!(virtioFlags & VIRTIO_NET_HDR_F_DATA_VALID))
    {
        if (virtioFlags & VIRTIO_NET_HDR_F_NEEDS_CSUM)
        {
            flagsToCalculate |= pcrFixXxpChecksum | pcrTcpChecksum | pcrUdpChecksum;
        }
        else
        {
            if (f.fRxTCPChecksum) flagsToCalculate |= pcrTcpV4Checksum;
            if (f.fRxUDPChecksum) flagsToCalculate |= pcrUdpV4Checksum;
            if (f.fRxTCPv6Checksum) flagsToCalculate |= pcrTcpV6Checksum;
            if (f.fRxUDPv6Checksum) flagsToCalculate |= pcrUdpV6Checksum;
        }
    }
 
    ppr = ParaNdis_CheckSumVerify(pIpHeader, len - ETH_HEADER_SIZE, flagsToCalculate, __FUNCTION__);
 
    if (virtioFlags & VIRTIO_NET_HDR_F_DATA_VALID)
    {
        pContext->extraStatistics.framesRxCSHwOK++;
        ppr.xxpCheckSum = ppresCSOK;
    }
 
    if (ppr.ipStatus == ppresIPV4 && !ppr.IsFragment)
    {
        if (f.fRxIPChecksum)
        {
            res.flags.IpOK =  ppr.ipCheckSum == ppresCSOK;
            res.flags.IpFailed = ppr.ipCheckSum == ppresCSBad;
        }
        if(ppr.xxpStatus == ppresXxpKnown)
        {
            if(ppr.TcpUdp == ppresIsTCP) /* TCP */
            {
                if (f.fRxTCPChecksum)
                {
                    res.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS;
                    res.flags.TcpFailed = !res.flags.TcpOK;
                }
            }
            else /* UDP */
            {
                if (f.fRxUDPChecksum)
                {
                    res.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS;
                    res.flags.UdpFailed = !res.flags.UdpOK;
                }
            }
        }
    }
    else if (ppr.ipStatus == ppresIPV6)
    {
        if(ppr.xxpStatus == ppresXxpKnown)
        {
            if(ppr.TcpUdp == ppresIsTCP) /* TCP */
            {
                if (f.fRxTCPv6Checksum)
                {
                    res.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS;
                    res.flags.TcpFailed = !res.flags.TcpOK;
                }
            }
            else /* UDP */
            {
                if (f.fRxUDPv6Checksum)
                {
                    res.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS;
                    res.flags.UdpFailed = !res.flags.UdpOK;
                }
            }
        }
    }
 
    if (pContext->bDoIPCheckRx &&
        (f.fRxIPChecksum || f.fRxTCPChecksum || f.fRxUDPChecksum || f.fRxTCPv6Checksum || f.fRxUDPv6Checksum))
    {
        ppr = ParaNdis_CheckSumVerify(pIpHeader, len - ETH_HEADER_SIZE, pcrAnyChecksum, __FUNCTION__);
        if (ppr.ipStatus == ppresIPV4 && !ppr.IsFragment)
        {
            resIp.flags.IpOK = !!f.fRxIPChecksum && ppr.ipCheckSum == ppresCSOK;
            resIp.flags.IpFailed = !!f.fRxIPChecksum && ppr.ipCheckSum == ppresCSBad;
            if (f.fRxTCPChecksum && ppr.xxpStatus == ppresXxpKnown && ppr.TcpUdp == ppresIsTCP)
            {
                resIp.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK;
                resIp.flags.TcpFailed = ppr.xxpCheckSum == ppresCSBad;
            }
            if (f.fRxUDPChecksum && ppr.xxpStatus == ppresXxpKnown && ppr.TcpUdp == ppresIsUDP)
            {
                resIp.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK;
                resIp.flags.UdpFailed = ppr.xxpCheckSum == ppresCSBad;
            }
        }
        else if (ppr.ipStatus == ppresIPV6)
        {
            if (f.fRxTCPv6Checksum && ppr.xxpStatus == ppresXxpKnown && ppr.TcpUdp == ppresIsTCP)
            {
                resIp.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK;
                resIp.flags.TcpFailed = ppr.xxpCheckSum == ppresCSBad;
            }
            if (f.fRxUDPv6Checksum && ppr.xxpStatus == ppresXxpKnown && ppr.TcpUdp == ppresIsUDP)
            {
                resIp.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK;
                resIp.flags.UdpFailed = ppr.xxpCheckSum == ppresCSBad;
            }
        }
 
        if (res.value != resIp.value)
        {
            // if HW did not set some bits that IP checker set, it is a mistake:
            // or GOOD CS is not labeled, or BAD checksum is not labeled
            tChecksumCheckResult diff;
            diff.value = resIp.value & ~res.value;
            if (diff.flags.IpFailed || diff.flags.TcpFailed || diff.flags.UdpFailed)
                pContext->extraStatistics.framesRxCSHwMissedBad++;
            if (diff.flags.IpOK || diff.flags.TcpOK || diff.flags.UdpOK)
                pContext->extraStatistics.framesRxCSHwMissedGood++;
            if (diff.value)
            {
                DPrintf(0, ("[%s] real %X <> %X (virtio %X)", __FUNCTION__, resIp.value, res.value, virtioFlags));
            }
            res.value = resIp.value;
        }
    }
 
    return res;
}

Referenced by ParaNdis_IndicateReceivedPacket().

ParaNdis_CheckSumVerify()

tTcpIpPacketParsingResult ParaNdis_CheckSumVerify	(	PVOID	buffer,
		ULONG	size,
		ULONG	flags,
		LPCSTR	caller
	)

Definition at line 565 of file sw-offload.c.

{
    tTcpIpPacketParsingResult res = QualifyIpPacket(buffer, size);
    if (res.ipStatus == ppresIPV4)
    {
        if (flags & pcrIpChecksum)
            res = VerifyIpChecksum(buffer, res, (flags & pcrFixIPChecksum) != 0);
        if(res.xxpStatus == ppresXxpKnown)
        {
            if (res.TcpUdp == ppresIsTCP) /* TCP */
            {
                if(flags & pcrTcpV4Checksum)
                {
                    res = VerifyTcpChecksum(buffer, size, res, flags & (pcrFixPHChecksum | pcrFixTcpV4Checksum));
                }
            }
            else /* UDP */
            {
                if (flags & pcrUdpV4Checksum)
                {
                    res = VerifyUdpChecksum(buffer, size, res, flags & (pcrFixPHChecksum | pcrFixUdpV4Checksum));
                }
            }
        }
    }
    else if (res.ipStatus == ppresIPV6)
    {
        if(res.xxpStatus == ppresXxpKnown)
        {
            if (res.TcpUdp == ppresIsTCP) /* TCP */
            {
                if(flags & pcrTcpV6Checksum)
                {
                    res = VerifyTcpChecksum(buffer, size, res, flags & (pcrFixPHChecksum | pcrFixTcpV6Checksum));
                }
            }
            else /* UDP */
            {
                if (flags & pcrUdpV6Checksum)
                {
                    res = VerifyUdpChecksum(buffer, size, res, flags & (pcrFixPHChecksum | pcrFixUdpV6Checksum));
                }
            }
        }
    }
    PrintOutParsingResult(res, 1, caller);
    return res;
}

Referenced by ParaNdis_CheckRxChecksum(), ParaNdis_DoCopyPacketData(), ParaNdis_DoSubmitPacket(), ParaNdis_PacketMapper(), and PrepareSendEntry().

ParaNdis_CleanupContext()

VOID ParaNdis_CleanupContext

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 1323 of file ParaNdis-Common.c.

{
    UINT i;
 
    /* disable any interrupt generation */
    if (pContext->IODevice.addr)
    {
        //int nActive;
        //nActive = virtio_read_isr_status(&pContext->IODevice);
        /* back compat - remove the OK flag only in legacy mode */
        VirtIODeviceRemoveStatus(&pContext->IODevice, VIRTIO_CONFIG_S_DRIVER_OK);
        JustForCheckClearInterrupt(pContext, "exit 1");
        //nActive += virtio_read_isr_status(&pContext->IODevice);
        //nActive += virtio_read_isr_status(&pContext->IODevice);
        //DPrintf(0, ("cleanup %d", nActive));
    }
 
    PreventDPCServicing(pContext);
 
    /****************************************
    ensure all the incoming packets returned,
    free all the buffers and their descriptors
    *****************************************/
 
    if (pContext->bIODeviceInitialized)
    {
        JustForCheckClearInterrupt(pContext, "exit 2");
        ParaNdis_ResetVirtIONetDevice(pContext);
        JustForCheckClearInterrupt(pContext, "exit 3");
    }
 
    ParaNdis_SetPowerState(pContext, NdisDeviceStateD3);
    VirtIONetRelease(pContext);
 
    ParaNdis_FinalizeCleanup(pContext);
 
    if (pContext->SendLock.SpinLock)
    {
        NdisFreeSpinLock(&pContext->SendLock);
    }
 
#if !defined(UNIFY_LOCKS)
    if (pContext->ReceiveLock.SpinLock)
    {
        NdisFreeSpinLock(&pContext->ReceiveLock);
    }
#endif
 
    /* free queue shared memory */
    for (i = 0; i < MAX_NUM_OF_QUEUES; i++) {
        if (pContext->SharedMemoryRanges[i].pBase != NULL) {
            NdisMFreeSharedMemory(
                pContext->MiniportHandle,
                pContext->SharedMemoryRanges[i].uLength,
                TRUE /* Cached */,
                pContext->SharedMemoryRanges[i].pBase,
                pContext->SharedMemoryRanges[i].BasePA);
            pContext->SharedMemoryRanges[i].pBase = NULL;
        }
    }
 
    /* unmap our port and memory IO resources */
    for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
    {
       tBusResource *pRes = &pContext->AdapterResources.PciBars[i];
       if (pRes->pBase != NULL)
       {
          if (pRes->bPortSpace)
          {
             NdisMDeregisterIoPortRange(
                pContext->MiniportHandle,
                pRes->BasePA.LowPart,
                pRes->uLength,
                pRes->pBase);
          }
          else
          {
             NdisMUnmapIoSpace(
                pContext->MiniportHandle,
                pRes->pBase,
                pRes->uLength);
          }
       }
    }
}

Referenced by ParaNdis5_Halt(), and ParaNdis5_Initialize().

ParaNdis_DebugCleanup()

void ParaNdis_DebugCleanup

(

PDRIVER_OBJECT

pDriverObject

)

Definition at line 239 of file ParaNdis-Debug.c.

{
#ifdef OVERRIDE_DEBUG_BREAK
    if (sizeof(PVOID) == sizeof(ULONG) && pDbgBreakPoint)
    {
        DPrintf(0, ("Restoring original BP handler at %p", pDbgBreakPoint));
        RtlCopyMemory(pDbgBreakPoint, DbgBreakPointChunk, sizeof(DbgBreakPointChunk));
    }
#endif
    BugCheckDeregisterCallback(&CallbackRecord);
    WPP_CLEANUP(pDriverObject);
}

Referenced by ParaVirtualNICUnload().

ParaNdis_DebugHistory()

static void FORCEINLINE ParaNdis_DebugHistory ( PARANDIS_ADAPTER *  pContext, eHistoryLogOperation  op, PVOID  pParam1, ULONG  lParam2, ULONG  lParam3, ULONG  lParam4  )

static

Definition at line 647 of file ndis56common.h.

{
 
}

Referenced by CompletePacket(), OnResetWorkItem(), OnSetPowerWorkItem(), ParaNdis5_Halt(), ParaNdis5_QueryOID(), ParaNdis5_Reset(), ParaNdis5_SendPackets(), ParaNdis5_SetOID(), ParaNdis5_StopReceive(), ParaNdis5_StopSend(), ParaNdis_DPCWorkBody(), ParaNdis_IndicateConnect(), ParaNdis_OnPnPEvent(), ParaNdis_OnTransmitBufferReleased(), ParaNdis_PowerOff(), ParaNdis_PowerOn(), ParaNdis_ProcessRxPath(), ParaNdis_ProcessTx(), ParaNdis_VirtIODisableIrqSynchronized(), ParaNdis_VirtIOEnableIrqSynchronized(), RestartQueueSynchronously(), and ReuseReceiveBufferRegular().

ParaNdis_DebugInitialize()

void ParaNdis_DebugInitialize	(	PVOID	DriverObject,
		PVOID	RegistryPath
	)

Definition at line 194 of file ParaNdis-Debug.c.

{
    NDIS_STRING usRegister, usDeregister, usPrint;
    PVOID pr, pd;
    BOOLEAN res;
    WPP_INIT_TRACING(DriverObject, RegistryPath);
 
    NdisAllocateSpinLock(&CrashLock);
    KeInitializeCallbackRecord(&CallbackRecord);
    ParaNdis_PrepareBugCheckData();
    NdisInitUnicodeString(&usPrint, L"vDbgPrintEx");
    NdisInitUnicodeString(&usRegister, L"KeRegisterBugCheckReasonCallback");
    NdisInitUnicodeString(&usDeregister, L"KeDeregisterBugCheckReasonCallback");
    pd = MmGetSystemRoutineAddress(&usPrint);
    if (pd) PrintProcedure = (vDbgPrintExType)pd;
    pr = MmGetSystemRoutineAddress(&usRegister);
    pd = MmGetSystemRoutineAddress(&usDeregister);
    if (pr && pd)
    {
        BugCheckRegisterCallback = (KeRegisterBugCheckReasonCallbackType)pr;
        BugCheckDeregisterCallback = (KeDeregisterBugCheckReasonCallbackType)pd;
    }
    res = BugCheckRegisterCallback(&CallbackRecord, ParaNdis_OnBugCheck, KbCallbackSecondaryDumpData, "NetKvm");
    DPrintf(0, ("[%s] Crash callback %sregistered", __FUNCTION__, res ? "" : "NOT "));
 
#ifdef OVERRIDE_DEBUG_BREAK
    if (sizeof(PVOID) == sizeof(ULONG))
    {
        UCHAR replace[5] = {0xe9,0,0,0,0};
        ULONG replacement;
        NDIS_STRING usDbgBreakPointName;
        NdisInitUnicodeString(&usDbgBreakPointName, L"DbgBreakPoint");
        pDbgBreakPoint = (PUCHAR)MmGetSystemRoutineAddress(&usDbgBreakPointName);
        if (pDbgBreakPoint)
        {
            DPrintf(0, ("Replacing original BP handler at %p", pDbgBreakPoint));
            replacement = RtlPointerToOffset(pDbgBreakPoint + 5, AnotherDbgBreak);
            RtlCopyMemory(replace + 1, &replacement, sizeof(replacement));
            RtlCopyMemory(DbgBreakPointChunk, pDbgBreakPoint, sizeof(DbgBreakPointChunk));
            RtlCopyMemory(pDbgBreakPoint, replace, sizeof(replace));
        }
    }
#endif
}

Referenced by DriverEntry().

ParaNdis_DebugRegisterMiniport()

void ParaNdis_DebugRegisterMiniport	(	PARANDIS_ADAPTER *	pContext,
		BOOLEAN	bRegister
	)

Definition at line 294 of file ParaNdis-Debug.c.

{
    UINT i;
    NdisAcquireSpinLock(&CrashLock);
    for (i = 0; i < MAX_CONTEXTS; ++i)
    {
        UINT64 val1 = bRegister ? 0 : (UINT_PTR)pContext;
        UINT64 val2 = bRegister ? (UINT_PTR)pContext : 0;
        if (BugCheckData.StaticData.PerNicData[i].Context != val1) continue;
        BugCheckData.StaticData.PerNicData[i].Context = val2;
        break;
    }
    NdisReleaseSpinLock(&CrashLock);
}

Referenced by ParaNdis5_Halt(), and ParaNdis5_Initialize().

ParaNdis_DeviceFiltersUpdateVlanId()

VOID ParaNdis_DeviceFiltersUpdateVlanId

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 2684 of file ParaNdis-Common.c.

{
    if (pContext->bHasHardwareFilters)
    {
        ULONG newFilterSet;
        if (IsVlanSupported(pContext))
            newFilterSet = pContext->VlanId ? pContext->VlanId : (MAX_VLAN_ID + 1);
        else
            newFilterSet = IsPrioritySupported(pContext) ? (MAX_VLAN_ID + 1) : 0;
        if (newFilterSet != pContext->ulCurrentVlansFilterSet)
        {
            if (pContext->ulCurrentVlansFilterSet > MAX_VLAN_ID)
                SetAllVlanFilters(pContext, FALSE);
            else if (pContext->ulCurrentVlansFilterSet)
                SetSingleVlanFilter(pContext, pContext->ulCurrentVlansFilterSet, FALSE, 2);
 
            pContext->ulCurrentVlansFilterSet = newFilterSet;
 
            if (pContext->ulCurrentVlansFilterSet > MAX_VLAN_ID)
                SetAllVlanFilters(pContext, TRUE);
            else if (pContext->ulCurrentVlansFilterSet)
                SetSingleVlanFilter(pContext, pContext->ulCurrentVlansFilterSet, TRUE, 2);
        }
    }
}

Referenced by ParaNdis_OnSetVlanId(), and ParaNdis_UpdateDeviceFilters().

ParaNdis_DoCopyPacketData()

tCopyPacketResult ParaNdis_DoCopyPacketData	(	PARANDIS_ADAPTER *	pContext,
		tTxOperationParameters *	pParams
	)

Definition at line 1860 of file ParaNdis-Common.c.

{
    tCopyPacketResult result;
    tCopyPacketResult CopierResult;
    struct VirtIOBufferDescriptor sg[2];
    pIONetDescriptor pBuffersDescriptor = NULL;
    ULONG flags = pParams->flags;
    UINT nRequiredHardwareBuffers = 2;
    result.size  = 0;
    result.error = cpeOK;
    if (pContext->nofFreeHardwareBuffers < nRequiredHardwareBuffers ||
        IsListEmpty(&pContext->NetFreeSendBuffers))
    {
        result.error = cpeNoBuffer;
    }
    if(result.error == cpeOK)
    {
        pBuffersDescriptor = (pIONetDescriptor)RemoveHeadList(&pContext->NetFreeSendBuffers);
        NdisZeroMemory(pBuffersDescriptor->HeaderInfo.Virtual, pBuffersDescriptor->HeaderInfo.size);
        sg[0].physAddr = pBuffersDescriptor->HeaderInfo.Physical;
        sg[0].length = pBuffersDescriptor->HeaderInfo.size;
        sg[1].physAddr = pBuffersDescriptor->DataInfo.Physical;
        CopierResult = ParaNdis_PacketCopier(
            pParams->packet,
            pBuffersDescriptor->DataInfo.Virtual,
            pBuffersDescriptor->DataInfo.size,
            pParams->ReferenceValue,
            FALSE);
        sg[1].length = result.size = CopierResult.size;
        // did NDIS ask us to compute CS?
        if ((flags & (pcrTcpChecksum | pcrUdpChecksum | pcrIpChecksum)) != 0)
        {
            // we asked
            unsigned short addPriorityLen = (pParams->flags & pcrPriorityTag) ? ETH_PRIORITY_HEADER_SIZE : 0;
            PVOID ipPacket = RtlOffsetToPointer(
                pBuffersDescriptor->DataInfo.Virtual, pContext->Offload.ipHeaderOffset + addPriorityLen);
            ULONG ipPacketLength = CopierResult.size - pContext->Offload.ipHeaderOffset - addPriorityLen;
            if (!pParams->tcpHeaderOffset &&
                (flags & (pcrTcpChecksum | pcrUdpChecksum)) )
            {
                pParams->tcpHeaderOffset = QueryTcpHeaderOffset(
                    pBuffersDescriptor->DataInfo.Virtual,
                    pContext->Offload.ipHeaderOffset + addPriorityLen,
                    ipPacketLength);
            }
            else
            {
                pParams->tcpHeaderOffset += addPriorityLen;
            }
 
            if (pContext->bDoHardwareChecksum)
            {
                if (flags & (pcrTcpChecksum | pcrUdpChecksum))
                {
                    // hardware offload
                    virtio_net_hdr_basic *pvnh = (virtio_net_hdr_basic *)pBuffersDescriptor->HeaderInfo.Virtual;
                    pvnh->csum_start = (USHORT)pParams->tcpHeaderOffset;
                    pvnh->csum_offset = (flags & pcrTcpChecksum) ? TCP_CHECKSUM_OFFSET : UDP_CHECKSUM_OFFSET;
                    pvnh->flags |= VIRTIO_NET_HDR_F_NEEDS_CSUM;
                }
                if (flags & (pcrIpChecksum))
                {
                    ParaNdis_CheckSumVerify(
                        ipPacket,
                        ipPacketLength,
                        pcrIpChecksum | pcrFixIPChecksum,
                        __FUNCTION__);
                }
            }
            else if (CopierResult.size > pContext->Offload.ipHeaderOffset)
            {
                ULONG csFlags = 0;
                if (flags & pcrIpChecksum) csFlags |= pcrIpChecksum | pcrFixIPChecksum;
                if (flags & (pcrTcpChecksum | pcrUdpChecksum)) csFlags |= pcrTcpChecksum | pcrUdpChecksum| pcrFixXxpChecksum;
                // software offload
                ParaNdis_CheckSumVerify(
                    ipPacket,
                    ipPacketLength,
                    csFlags,
                    __FUNCTION__);
            }
            else
            {
                DPrintf(0, ("[%s] ERROR: Invalid buffer size for offload!", __FUNCTION__));
                result.size = 0;
                result.error = cpeInternalError;
            }
        }
        pContext->nofFreeTxDescriptors--;
        if (result.size)
        {
            eInspectedPacketType packetType;
            packetType = QueryPacketType(pBuffersDescriptor->DataInfo.Virtual);
            DebugDumpPacket("sending", pBuffersDescriptor->DataInfo.Virtual, 3);
 
            pBuffersDescriptor->nofUsedBuffers = nRequiredHardwareBuffers;
            pContext->nofFreeHardwareBuffers -= nRequiredHardwareBuffers;
            if (pContext->minFreeHardwareBuffers > pContext->nofFreeHardwareBuffers)
                pContext->minFreeHardwareBuffers = pContext->nofFreeHardwareBuffers;
            if (0 > virtqueue_add_buf(
                pContext->NetSendQueue,
                sg,
                2,
                0,
                pBuffersDescriptor,
                NULL,
                0
                ))
            {
                pBuffersDescriptor->nofUsedBuffers = 0;
                pContext->nofFreeHardwareBuffers += nRequiredHardwareBuffers;
                result.error = cpeInternalError;
                result.size  = 0;
                DPrintf(0, ("[%s] Unexpected ERROR adding buffer to TX engine!..", __FUNCTION__));
            }
            else
            {
                DPrintf(2, ("[%s] Submitted %d buffers (%d bytes), avail %d desc, %d bufs",
                    __FUNCTION__, nRequiredHardwareBuffers, result.size,
                    pContext->nofFreeTxDescriptors, pContext->nofFreeHardwareBuffers
                ));
            }
            if (result.error != cpeOK)
            {
                InsertTailList(&pContext->NetFreeSendBuffers, &pBuffersDescriptor->listEntry);
                pContext->nofFreeTxDescriptors++;
            }
            else
            {
                ULONG reportedSize = pParams->ulDataSize;
                pBuffersDescriptor->ReferenceValue = pParams->ReferenceValue;
                InsertTailList(&pContext->NetSendBuffersInUse, &pBuffersDescriptor->listEntry);
                pContext->Statistics.ifHCOutOctets += reportedSize;
                switch (packetType)
                {
                    case iptBroadcast:
                        pContext->Statistics.ifHCOutBroadcastOctets += reportedSize;
                        pContext->Statistics.ifHCOutBroadcastPkts++;
                        break;
                    case iptMulticast:
                        pContext->Statistics.ifHCOutMulticastOctets += reportedSize;
                        pContext->Statistics.ifHCOutMulticastPkts++;
                        break;
                    default:
                        pContext->Statistics.ifHCOutUcastOctets += reportedSize;
                        pContext->Statistics.ifHCOutUcastPkts++;
                        break;
                }
            }
        }
        else
        {
            DPrintf(0, ("[%s] Unexpected ERROR in copying packet data! Continue...", __FUNCTION__));
            InsertTailList(&pContext->NetFreeSendBuffers, &pBuffersDescriptor->listEntry);
            pContext->nofFreeTxDescriptors++;
            // the buffer is not copied and the callback will not be called
            result.error = cpeInternalError;
        }
    }
 
    return result;
}

Referenced by ParaNdis_DoSubmitPacket().

ParaNdis_DoSubmitPacket()

tCopyPacketResult ParaNdis_DoSubmitPacket	(	PARANDIS_ADAPTER *	pContext,
		tTxOperationParameters *	Params
	)

Definition at line 1619 of file ParaNdis-Common.c.

{
    tCopyPacketResult result;
    tMapperResult mapResult = {0,0,0};
    // populating priority tag or LSO MAY require additional SG element
    UINT nRequiredBuffers;
    BOOLEAN bUseCopy = FALSE;
    struct VirtIOBufferDescriptor *sg = pContext->sgTxGatherTable;
 
    nRequiredBuffers = Params->nofSGFragments + 1 + ((Params->flags & (pcrPriorityTag | pcrLSO)) ? 1 : 0);
 
    result.size = 0;
    result.error = cpeOK;
    if (!pContext->bUseScatterGather ||         // only copy available
        Params->nofSGFragments == 0 ||          // theoretical case
        !sg ||                                  // only copy available
        ((~Params->flags & pcrLSO) && nRequiredBuffers > pContext->maxFreeHardwareBuffers) // to many fragments and normal size of packet
        )
    {
        nRequiredBuffers = 2;
        bUseCopy = TRUE;
    }
    else if (pContext->bUseIndirect && !(Params->flags & pcrNoIndirect))
    {
        nRequiredBuffers = 1;
    }
 
    // I do not think this will help, but at least we can try freeing some buffers right now
    if (pContext->nofFreeHardwareBuffers < nRequiredBuffers || !pContext->nofFreeTxDescriptors)
    {
        ParaNdis_VirtIONetReleaseTransmitBuffers(pContext);
    }
 
    if (nRequiredBuffers > pContext->maxFreeHardwareBuffers)
    {
        // LSO and too many buffers, impossible to send
        result.error = cpeTooLarge;
        DPrintf(0, ("[%s] ERROR: too many fragments(%d required, %d max.avail)!", __FUNCTION__,
            nRequiredBuffers, pContext->maxFreeHardwareBuffers));
    }
    else if (pContext->nofFreeHardwareBuffers < nRequiredBuffers || !pContext->nofFreeTxDescriptors)
    {
        virtqueue_enable_cb_delayed(pContext->NetSendQueue);
        result.error = cpeNoBuffer;
    }
    else if (Params->offloadMss && bUseCopy)
    {
        result.error = cpeInternalError;
        DPrintf(0, ("[%s] ERROR: expecting SG for TSO! (%d buffers, %d bytes)", __FUNCTION__,
            Params->nofSGFragments, Params->ulDataSize));
    }
    else if (bUseCopy)
    {
        result = ParaNdis_DoCopyPacketData(pContext, Params);
    }
    else
    {
        UINT nMappedBuffers;
        ULONGLONG paOfIndirectArea = 0;
        PVOID vaOfIndirectArea = NULL;
        pIONetDescriptor pBuffersDescriptor = (pIONetDescriptor)RemoveHeadList(&pContext->NetFreeSendBuffers);
        pContext->nofFreeTxDescriptors--;
        NdisZeroMemory(pBuffersDescriptor->HeaderInfo.Virtual, pBuffersDescriptor->HeaderInfo.size);
        sg[0].physAddr = pBuffersDescriptor->HeaderInfo.Physical;
        sg[0].length = pBuffersDescriptor->HeaderInfo.size;
        ParaNdis_PacketMapper(
            pContext,
            Params->packet,
            Params->ReferenceValue,
            sg + 1,
            pBuffersDescriptor,
            &mapResult);
        nMappedBuffers = mapResult.usBuffersMapped;
        if (nMappedBuffers)
        {
            nMappedBuffers++;
            if (pContext->bUseIndirect && !(Params->flags & pcrNoIndirect))
            {
                ULONG space1 = (mapResult.usBufferSpaceUsed + 7) & ~7;
                ULONG space2 = nMappedBuffers * SIZE_OF_SINGLE_INDIRECT_DESC;
                if (pBuffersDescriptor->DataInfo.size >= (space1 + space2))
                {
                    vaOfIndirectArea = RtlOffsetToPointer(pBuffersDescriptor->DataInfo.Virtual, space1);
                    paOfIndirectArea = pBuffersDescriptor->DataInfo.Physical.QuadPart + space1;
                    pContext->extraStatistics.framesIndirect++;
                }
                else if (nMappedBuffers <= pContext->nofFreeHardwareBuffers)
                {
                    // send as is, no indirect
                }
                else
                {
                    result.error = cpeNoIndirect;
                    DPrintf(0, ("[%s] Unexpected ERROR of placement!", __FUNCTION__));
                }
            }
            if (result.error == cpeOK)
            {
                if (Params->flags & (pcrTcpChecksum | pcrUdpChecksum))
                {
                    unsigned short addPriorityLen = (Params->flags & pcrPriorityTag) ? ETH_PRIORITY_HEADER_SIZE : 0;
                    if (pContext->bDoHardwareChecksum)
                    {
                        virtio_net_hdr_basic *pheader = pBuffersDescriptor->HeaderInfo.Virtual;
                        pheader->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
                        if (!Params->tcpHeaderOffset)
                        {
                            Params->tcpHeaderOffset = QueryTcpHeaderOffset(
                                pBuffersDescriptor->DataInfo.Virtual,
                                pContext->Offload.ipHeaderOffset + addPriorityLen,
                                mapResult.usBufferSpaceUsed - pContext->Offload.ipHeaderOffset - addPriorityLen);
                        }
                        else
                        {
                            Params->tcpHeaderOffset += addPriorityLen;
                        }
                        pheader->csum_start = (USHORT)Params->tcpHeaderOffset;
                        pheader->csum_offset = (Params->flags & pcrTcpChecksum) ? TCP_CHECKSUM_OFFSET : UDP_CHECKSUM_OFFSET;
                    }
                    else
                    {
                        // emulation mode - it is slow and intended only for test of flows
                        // and debugging of WLK test cases
                        PVOID pCopy = ParaNdis_AllocateMemory(pContext, Params->ulDataSize);
                        if (pCopy)
                        {
                            tTcpIpPacketParsingResult ppr;
                            // duplicate entire packet
                            ParaNdis_PacketCopier(Params->packet, pCopy, Params->ulDataSize, Params->ReferenceValue, FALSE);
                            // calculate complete TCP/UDP checksum
                            ppr = ParaNdis_CheckSumVerify(
                                RtlOffsetToPointer(pCopy, pContext->Offload.ipHeaderOffset + addPriorityLen),
                                Params->ulDataSize - pContext->Offload.ipHeaderOffset - addPriorityLen,
                                pcrAnyChecksum | pcrFixXxpChecksum,
                                __FUNCTION__);
                            // data portion in aside buffer contains complete IP+TCP header
                            // rewrite copy of original buffer by one new with calculated data
                            NdisMoveMemory(
                                pBuffersDescriptor->DataInfo.Virtual,
                                pCopy,
                                mapResult.usBufferSpaceUsed);
                            NdisFreeMemory(pCopy, 0, 0);
                        }
                    }
                }
 
                if (0 <= virtqueue_add_buf(
                    pContext->NetSendQueue,
                    sg,
                    nMappedBuffers,
                    0,
                    pBuffersDescriptor,
                    vaOfIndirectArea,
                    paOfIndirectArea))
                {
                    pBuffersDescriptor->nofUsedBuffers = nMappedBuffers;
                    pContext->nofFreeHardwareBuffers -= nMappedBuffers;
                    if (pContext->minFreeHardwareBuffers > pContext->nofFreeHardwareBuffers)
                        pContext->minFreeHardwareBuffers = pContext->nofFreeHardwareBuffers;
                    pBuffersDescriptor->ReferenceValue = Params->ReferenceValue;
                    result.size = Params->ulDataSize;
                    DPrintf(2, ("[%s] Submitted %d buffers (%d bytes), avail %d desc, %d bufs",
                        __FUNCTION__, nMappedBuffers, result.size,
                        pContext->nofFreeTxDescriptors, pContext->nofFreeHardwareBuffers
                    ));
                }
                else
                {
                    result.error = cpeInternalError;
                    DPrintf(0, ("[%s] Unexpected ERROR adding buffer to TX engine!..", __FUNCTION__));
                }
            }
        }
        else
        {
            DPrintf(0, ("[%s] Unexpected ERROR: packet not mapped!", __FUNCTION__));
            result.error = cpeInternalError;
        }
 
        if (result.error == cpeOK)
        {
            UCHAR ethernetHeader[sizeof(ETH_HEADER)];
            eInspectedPacketType packetType;
            /* get the ethernet header for review */
            ParaNdis_PacketCopier(Params->packet, ethernetHeader, sizeof(ethernetHeader), Params->ReferenceValue, TRUE);
            packetType = QueryPacketType(ethernetHeader);
            DebugDumpPacket("sending", ethernetHeader, 3);
            InsertTailList(&pContext->NetSendBuffersInUse, &pBuffersDescriptor->listEntry);
            pContext->Statistics.ifHCOutOctets += result.size;
            switch (packetType)
            {
                case iptBroadcast:
                    pContext->Statistics.ifHCOutBroadcastOctets += result.size;
                    pContext->Statistics.ifHCOutBroadcastPkts++;
                    break;
                case iptMulticast:
                    pContext->Statistics.ifHCOutMulticastOctets += result.size;
                    pContext->Statistics.ifHCOutMulticastPkts++;
                    break;
                default:
                    pContext->Statistics.ifHCOutUcastOctets += result.size;
                    pContext->Statistics.ifHCOutUcastPkts++;
                    break;
            }
 
            if (Params->flags & pcrLSO)
                pContext->extraStatistics.framesLSO++;
        }
        else
        {
            pContext->nofFreeTxDescriptors++;
            InsertHeadList(&pContext->NetFreeSendBuffers, &pBuffersDescriptor->listEntry);
        }
    }
    if (result.error == cpeNoBuffer && pContext->bDoKickOnNoBuffer)
    {
        virtqueue_kick_always(pContext->NetSendQueue);
        pContext->bDoKickOnNoBuffer = FALSE;
    }
    if (result.error == cpeOK)
    {
        if (Params->flags & (pcrTcpChecksum | pcrUdpChecksum))
            pContext->extraStatistics.framesCSOffload++;
    }
    return result;
}

Referenced by ParaNdis_ProcessTx().

ParaNdis_DPCWorkBody()

ULONG ParaNdis_DPCWorkBody	(	PARANDIS_ADAPTER *	pContext,
		ULONG	ulMaxPacketsToIndicate
	)

Definition at line 2230 of file ParaNdis-Common.c.

{
    ULONG stillRequiresProcessing = 0;
    ULONG interruptSources;
    UINT uIndicatedRXPackets = 0;
    UINT numOfPacketsToIndicate = min(ulMaxPacketsToIndicate, pContext->uNumberOfHandledRXPacketsInDPC);
 
    DEBUG_ENTRY(5);
    if (pContext->bEnableInterruptHandlingDPC)
    {
        InterlockedIncrement(&pContext->counterDPCInside);
        if (pContext->bEnableInterruptHandlingDPC)
        {
            BOOLEAN bDoKick = FALSE;
 
            InterlockedExchange(&pContext->bDPCInactive, 0);
            interruptSources = InterlockedExchange(&pContext->InterruptStatus, 0);
            ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)1, interruptSources, 0, 0);
            if ((interruptSources & isControl) && pContext->bLinkDetectSupported)
            {
                ParaNdis_ReportLinkStatus(pContext, FALSE);
            }
            if (interruptSources & isTransmit)
            {
                bDoKick = ParaNdis_ProcessTx(pContext, TRUE, TRUE);
            }
            if (interruptSources & isReceive)
            {
                int nRestartResult = 0;
 
                do
                {
                    LONG rxActive = InterlockedIncrement(&pContext->dpcReceiveActive);
                    if (rxActive == 1)
                    {
                        uIndicatedRXPackets += ParaNdis_ProcessRxPath(pContext, numOfPacketsToIndicate - uIndicatedRXPackets);
                        InterlockedDecrement(&pContext->dpcReceiveActive);
                        NdisAcquireSpinLock(&pContext->ReceiveLock);
                        nRestartResult = ParaNdis_SynchronizeWithInterrupt(
                            pContext, pContext->ulRxMessage, RestartQueueSynchronously, pContext->NetReceiveQueue);
                        ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)3, nRestartResult, 0, 0);
                        NdisReleaseSpinLock(&pContext->ReceiveLock);
                        DPrintf(nRestartResult ? 2 : 6, ("[%s] queue restarted%s", __FUNCTION__, nRestartResult ? "(Rerun)" : "(Done)"));
 
                        if (uIndicatedRXPackets < numOfPacketsToIndicate)
                        {
 
                        }
                        else if (uIndicatedRXPackets == numOfPacketsToIndicate)
                        {
                            DPrintf(1, ("[%s] Breaking Rx loop after %d indications", __FUNCTION__, uIndicatedRXPackets));
                            ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)4, nRestartResult, 0, 0);
                            break;
                        }
                        else
                        {
                            DPrintf(0, ("[%s] Glitch found: %d allowed, %d indicated", __FUNCTION__, numOfPacketsToIndicate, uIndicatedRXPackets));
                            ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)6, nRestartResult, 0, 0);
                        }
                    }
                    else
                    {
                        InterlockedDecrement(&pContext->dpcReceiveActive);
                        if (!nRestartResult)
                        {
                            NdisAcquireSpinLock(&pContext->ReceiveLock);
                            nRestartResult = ParaNdis_SynchronizeWithInterrupt(
                                pContext, pContext->ulRxMessage, RestartQueueSynchronously, pContext->NetReceiveQueue);
                            ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)5, nRestartResult, 0, 0);
                            NdisReleaseSpinLock(&pContext->ReceiveLock);
                        }
                        DPrintf(1, ("[%s] Skip Rx processing no.%d", __FUNCTION__, rxActive));
                        break;
                    }
                } while (nRestartResult);
 
                if (nRestartResult) stillRequiresProcessing |= isReceive;
            }
 
            if (interruptSources & isTransmit)
            {
                NdisAcquireSpinLock(&pContext->SendLock);
                if (ParaNdis_SynchronizeWithInterrupt(pContext, pContext->ulTxMessage, RestartQueueSynchronously, pContext->NetSendQueue))
                    stillRequiresProcessing |= isTransmit;
                if(bDoKick)
                {
#ifdef PARANDIS_TEST_TX_KICK_ALWAYS
                    virtqueue_kick_always(pContext->NetSendQueue);
#else
                    virtqueue_kick(pContext->NetSendQueue);
#endif
                }
                NdisReleaseSpinLock(&pContext->SendLock);
            }
        }
        InterlockedDecrement(&pContext->counterDPCInside);
        ParaNdis_DebugHistory(pContext, hopDPC, NULL, stillRequiresProcessing, pContext->nofFreeHardwareBuffers, pContext->nofFreeTxDescriptors);
    }
    return stillRequiresProcessing;
}

Referenced by CheckRunningDpc(), OnDPCPostProcessTimer(), and ParaNdis5_HandleDPC().

ParaNdis_FinalizeCleanup()

VOID ParaNdis_FinalizeCleanup

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 348 of file ParaNdis5-Impl.c.

{
    if (pContext->Interrupt.InterruptObject)
    {
        NdisMDeregisterInterrupt(&pContext->Interrupt);
    }
    if (pContext->BuffersPool)
    {
        NdisFreeBufferPool(pContext->BuffersPool);
    }
    if (pContext->PacketPool)
    {
        NdisFreePacketPool(pContext->PacketPool);
    }
#if DO_MAP_REGISTERS
    if (pContext->bDmaInitialized)
    {
        NdisMFreeMapRegisters(pContext->MiniportHandle);
    }
#endif
}

Referenced by ParaNdis_CleanupContext().

ParaNdis_FinishInitialization()

NDIS_STATUS ParaNdis_FinishInitialization

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 1196 of file ParaNdis-Common.c.

{
    NDIS_STATUS status = NDIS_STATUS_SUCCESS;
    DEBUG_ENTRY(0);
 
    NdisAllocateSpinLock(&pContext->SendLock);
#if !defined(UNIFY_LOCKS)
    NdisAllocateSpinLock(&pContext->ReceiveLock);
#endif
 
    InitializeListHead(&pContext->NetReceiveBuffers);
    InitializeListHead(&pContext->NetReceiveBuffersWaiting);
    InitializeListHead(&pContext->NetSendBuffersInUse);
    InitializeListHead(&pContext->NetFreeSendBuffers);
 
    status = ParaNdis_FinishSpecificInitialization(pContext);
 
    if (status == NDIS_STATUS_SUCCESS)
    {
        status = ParaNdis_VirtIONetInit(pContext);
    }
 
    pContext->Limits.nReusedRxBuffers = pContext->NetMaxReceiveBuffers / 4 + 1;
 
    if (status == NDIS_STATUS_SUCCESS)
    {
        JustForCheckClearInterrupt(pContext, "start 3");
        pContext->bEnableInterruptHandlingDPC = TRUE;
        ParaNdis_SetPowerState(pContext, NdisDeviceStateD0);
        virtio_device_ready(&pContext->IODevice);
        JustForCheckClearInterrupt(pContext, "start 4");
        ParaNdis_UpdateDeviceFilters(pContext);
    }
    else
    {
        virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_FAILED);
    }
    DEBUG_EXIT_STATUS(0, status);
    return status;
}

Referenced by ParaNdis5_Initialize().

ParaNdis_FinishSpecificInitialization()

NDIS_STATUS NTAPI ParaNdis_FinishSpecificInitialization

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 275 of file ParaNdis5-Impl.c.

{
    NDIS_STATUS     status;
    UINT            nPackets = pContext->NetMaxReceiveBuffers * 2;
    DEBUG_ENTRY(2);
    NdisInitializeEvent(&pContext->HaltEvent);
    InitializeListHead(&pContext->SendQueue);
    InitializeListHead(&pContext->TxWaitingList);
    NdisInitializeTimer(&pContext->ConnectTimer, OnConnectTimer, pContext);
    NdisInitializeTimer(&pContext->DPCPostProcessTimer, OnDPCPostProcessTimer, pContext);
 
    status = NdisMRegisterInterrupt(
        &pContext->Interrupt,
        pContext->MiniportHandle,
        pContext->AdapterResources.Vector,
        pContext->AdapterResources.Level,
        TRUE,
        TRUE,
        NdisInterruptLevelSensitive);
 
    if (status == NDIS_STATUS_SUCCESS)
    {
        NdisAllocatePacketPool(
            &status,
            &pContext->PacketPool,
            nPackets,
            PROTOCOL_RESERVED_SIZE_IN_PACKET );
    }
    if (status == NDIS_STATUS_SUCCESS)
    {
        NdisAllocateBufferPool(
            &status,
            &pContext->BuffersPool,
            nPackets);
    }
 
#if !DO_MAP_REGISTERS
    if (status == NDIS_STATUS_SUCCESS)
    {
        status = NdisMInitializeScatterGatherDma(
            pContext->MiniportHandle,
            TRUE,
            0x10000);
        pContext->bDmaInitialized = status == NDIS_STATUS_SUCCESS;
    }
#else
    if (status == NDIS_STATUS_SUCCESS)
    {
        status = NdisMAllocateMapRegisters(
            pContext->MiniportHandle,
            0,
            NDIS_DMA_32BITS,
            64,
            PAGE_SIZE);
        pContext->bDmaInitialized = status == NDIS_STATUS_SUCCESS;
    }
#endif
    if (status == NDIS_STATUS_SUCCESS)
    {
        DebugParseOffloadBits();
    }
    DEBUG_EXIT_STATUS(status ? 0 : 2, status);
    return status;
}

Referenced by ParaNdis_FinishInitialization().

ParaNdis_FreePhysicalMemory()

VOID ParaNdis_FreePhysicalMemory	(	PARANDIS_ADAPTER *	pContext,
		tCompletePhysicalAddress *	pAddresses
	)

Definition at line 220 of file ParaNdis5-Impl.c.

{
 
    NdisMFreeSharedMemory(
        pContext->MiniportHandle,
        pAddresses->size,
        (BOOLEAN)pAddresses->IsCached,
        pAddresses->Virtual,
        pAddresses->Physical);
}

Referenced by AllocatePairOfBuffersOnInit(), VirtIONetFreeBufferDescriptor(), and VirtIONetRelease().

ParaNdis_GetQueueForInterrupt()

static __inline struct virtqueue * ParaNdis_GetQueueForInterrupt ( PARANDIS_ADAPTER *  pContext, ULONG  interruptSource  )

static

Definition at line 590 of file ndis56common.h.

{
    if (interruptSource & isTransmit)
        return pContext->NetSendQueue;
    if (interruptSource & isReceive)
        return pContext->NetReceiveQueue;
 
    return NULL;
}

Referenced by ParaNdis_OnQueuedInterrupt().

ParaNdis_IndicateConnect()

void ParaNdis_IndicateConnect	(	PARANDIS_ADAPTER *	pContext,
		BOOLEAN	bConnected,
		BOOLEAN	bForce
	)

Definition at line 123 of file ParaNdis5-Impl.c.

{
    // indicate disconnect always
    if (bConnected != pContext->bConnected || bForce)
    {
        pContext->bConnected = bConnected;
        DPrintf(0, ("Indicating %sconnect", bConnected ? "" : "dis"));
        ParaNdis_DebugHistory(pContext, hopConnectIndication, NULL, bConnected, 0, 0);
        NdisMIndicateStatus(
            pContext->MiniportHandle,
            bConnected ? NDIS_STATUS_MEDIA_CONNECT : NDIS_STATUS_MEDIA_DISCONNECT,
            0,
            0);
        NdisMIndicateStatusComplete(pContext->MiniportHandle);
    }
}

Referenced by OnResetWorkItem(), ParaNdis5_Initialize(), ParaNdis_PowerOff(), and ParaNdis_ReportLinkStatus().

ParaNdis_IndicateReceivedBatch()

VOID ParaNdis_IndicateReceivedBatch	(	PARANDIS_ADAPTER *	pContext,
		tPacketIndicationType *	pBatch,
		ULONG	nofPackets
	)

Definition at line 568 of file ParaNdis5-Impl.c.

{
    NdisMIndicateReceivePacket(
        pContext->MiniportHandle,
        pBatch,
        nofPackets);
}

Referenced by ParaNdis_ProcessRxPath().

ParaNdis_IndicateReceivedPacket()

tPacketIndicationType ParaNdis_IndicateReceivedPacket	(	PARANDIS_ADAPTER *	pContext,
		PVOID	dataBuffer,
		PULONG	pLength,
		BOOLEAN	bPrepareOnly,
		pIONetDescriptor	pBufferDesc
	)

Definition at line 465 of file ParaNdis5-Impl.c.

{
    PNDIS_BUFFER    pBuffer = NULL;
    PNDIS_BUFFER    pNoBuffer = NULL;
    PNDIS_PACKET    Packet = pBuffersDesc->pHolder;
    ULONG length = *pLength;
    if (Packet) NdisUnchainBufferAtFront(Packet, &pBuffer);
    if (Packet) NdisUnchainBufferAtFront(Packet, &pNoBuffer);
    if (pBuffer)
    {
        UINT uTotalLength;
        NDIS_PACKET_8021Q_INFO qInfo;
        qInfo.Value = NULL;
        if ((pContext->ulPriorityVlanSetting && length > (ETH_PRIORITY_HEADER_OFFSET + ETH_PRIORITY_HEADER_SIZE)) ||
            length > pContext->MaxPacketSize.nMaxFullSizeOS)
        {
            PUCHAR pPriority = (PUCHAR)dataBuffer + ETH_PRIORITY_HEADER_OFFSET;
            if (ETH_HAS_PRIO_HEADER(dataBuffer))
            {
                if (IsPrioritySupported(pContext))
                    qInfo.TagHeader.UserPriority = (pPriority[2] & 0xE0) >> 5;
                if (IsVlanSupported(pContext))
                {
                    qInfo.TagHeader.VlanId = (((USHORT)(pPriority[2] & 0x0F)) << 8) | pPriority[3];
                    if (pContext->VlanId && pContext->VlanId != qInfo.TagHeader.VlanId)
                    {
                        DPrintf(0, ("[%s] Failing unexpected VlanID %d", __FUNCTION__, qInfo.TagHeader.VlanId));
                        pContext->extraStatistics.framesFilteredOut++;
                        pBuffer = NULL;
                    }
                }
                RtlMoveMemory(
                    pPriority,
                    pPriority + ETH_PRIORITY_HEADER_SIZE,
                    length - ETH_PRIORITY_HEADER_OFFSET - ETH_PRIORITY_HEADER_SIZE);
                length -= ETH_PRIORITY_HEADER_SIZE;
                if (length > pContext->MaxPacketSize.nMaxFullSizeOS)
                {
                    DPrintf(0, ("[%s] Can not indicate up packet of %d", __FUNCTION__, length));
                    pBuffer = NULL;
                }
                DPrintf(1, ("[%s] Found priority data %p", __FUNCTION__, qInfo.Value));
                pContext->extraStatistics.framesRxPriority++;
            }
        }
 
        if (pBuffer)
        {
            PVOID headerBuffer = pContext->bUseMergedBuffers ? pBuffersDesc->DataInfo.Virtual:pBuffersDesc->HeaderInfo.Virtual;
            virtio_net_hdr_basic *pHeader = (virtio_net_hdr_basic *)headerBuffer;
            tChecksumCheckResult csRes;
            NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, Ieee8021QInfo) = qInfo.Value;
            NDIS_SET_PACKET_STATUS(Packet, STATUS_SUCCESS);
            ParaNdis_PadPacketReceived(dataBuffer, &length);
            NdisAdjustBufferLength(pBuffer, length);
            NdisChainBufferAtFront(Packet, pBuffer);
            NdisQueryPacket(Packet, NULL, NULL, NULL, &uTotalLength);
            *REF_MINIPORT(Packet) = pBuffersDesc;
            csRes = ParaNdis_CheckRxChecksum(pContext, pHeader->flags, dataBuffer, length);
            if (csRes.value)
            {
                NDIS_TCP_IP_CHECKSUM_PACKET_INFO qCSInfo;
                qCSInfo.Value = 0;
                qCSInfo.Receive.NdisPacketIpChecksumFailed = csRes.flags.IpFailed;
                qCSInfo.Receive.NdisPacketIpChecksumSucceeded = csRes.flags.IpOK;
                qCSInfo.Receive.NdisPacketTcpChecksumFailed = csRes.flags.TcpFailed;
                qCSInfo.Receive.NdisPacketTcpChecksumSucceeded = csRes.flags.TcpOK;
                qCSInfo.Receive.NdisPacketUdpChecksumFailed = csRes.flags.UdpFailed;
                qCSInfo.Receive.NdisPacketUdpChecksumSucceeded = csRes.flags.UdpOK;
                NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, TcpIpChecksumPacketInfo) = (PVOID) (ULONG_PTR) qCSInfo.Value;
                DPrintf(1, ("Reporting CS %X->%X", csRes.value, qCSInfo.Value));
            }
 
            DPrintf(4, ("[%s] buffer %p(%d b.)", __FUNCTION__, pBuffersDesc, length));
            if (!bPrepareOnly)
            {
                NdisMIndicateReceivePacket(
                    pContext->MiniportHandle,
                    &Packet,
                    1);
            }
        }
        *pLength = length;
    }
    if (!pBuffer)
    {
        DPrintf(0, ("[%s] Error: %p(%d b.) with packet %p", __FUNCTION__,
            pBuffersDesc, length, Packet));
        Packet = NULL;
    }
    if (pNoBuffer)
    {
        DPrintf(0, ("[%s] Error: %p(%d b.) with packet %p, buf %p,%p", __FUNCTION__,
            pBuffersDesc, length, Packet, pBuffer, pNoBuffer));
    }
    return Packet;
}

Referenced by ParaNdis_ProcessRxPath().

ParaNdis_InitialAllocatePhysicalMemory()

BOOLEAN ParaNdis_InitialAllocatePhysicalMemory	(	PARANDIS_ADAPTER *	pContext,
		tCompletePhysicalAddress *	pAddresses
	)

Definition at line 174 of file ParaNdis5-Impl.c.

{
    NdisMAllocateSharedMemory(
        pContext->MiniportHandle,
        pAddresses->size,
        (BOOLEAN)pAddresses->IsCached,
        &pAddresses->Virtual,
        &pAddresses->Physical);
    return pAddresses->Virtual != NULL;
}

Referenced by AllocatePairOfBuffersOnInit(), and ParaNdis_VirtIONetInit().

ParaNdis_InitializeContext()

NDIS_STATUS ParaNdis_InitializeContext	(	PARANDIS_ADAPTER *	pContext,
		PNDIS_RESOURCE_LIST	ResourceList
	)

Definition at line 657 of file ParaNdis-Common.c.

{
    NDIS_STATUS status = NDIS_STATUS_SUCCESS;
    PUCHAR pNewMacAddress = NULL;
    USHORT linkStatus = 0;
    NTSTATUS nt_status;
 
    DEBUG_ENTRY(0);
    /* read first PCI IO bar*/
    //ulIOAddress = ReadPCIConfiguration(miniportAdapterHandle, 0x10);
    /* check this is IO and assigned */
    ReadNicConfiguration(pContext, &pNewMacAddress);
    if (pNewMacAddress)
    {
        if (ParaNdis_ValidateMacAddress(pNewMacAddress, TRUE))
        {
            DPrintf(0, ("[%s] WARNING: MAC address reloaded", __FUNCTION__));
            NdisMoveMemory(pContext->CurrentMacAddress, pNewMacAddress, sizeof(pContext->CurrentMacAddress));
        }
        else
        {
            DPrintf(0, ("[%s] WARNING: Invalid MAC address ignored", __FUNCTION__));
        }
        NdisFreeMemory(pNewMacAddress, 0, 0);
    }
 
    pContext->MaxPacketSize.nMaxFullSizeOS = pContext->MaxPacketSize.nMaxDataSize + ETH_HEADER_SIZE;
    pContext->MaxPacketSize.nMaxFullSizeHwTx = pContext->MaxPacketSize.nMaxFullSizeOS;
    pContext->MaxPacketSize.nMaxFullSizeHwRx = pContext->MaxPacketSize.nMaxFullSizeOS + ETH_PRIORITY_HEADER_SIZE;
    if (pContext->ulPriorityVlanSetting)
        pContext->MaxPacketSize.nMaxFullSizeHwTx = pContext->MaxPacketSize.nMaxFullSizeHwRx;
 
    if (GetAdapterResources(pContext->MiniportHandle, pResourceList, &pContext->AdapterResources))
    {
        if (pContext->AdapterResources.InterruptFlags & CM_RESOURCE_INTERRUPT_MESSAGE)
        {
            DPrintf(0, ("[%s] Message interrupt assigned", __FUNCTION__));
            pContext->bUsingMSIX = TRUE;
        }
 
        nt_status = virtio_device_initialize(
            &pContext->IODevice,
            &ParaNdisSystemOps,
            pContext,
            pContext->bUsingMSIX);
        if (!NT_SUCCESS(nt_status)) {
            DPrintf(0, ("[%s] virtio_device_initialize failed with %x\n", __FUNCTION__, nt_status));
            status = NTStatusToNdisStatus(nt_status);
            DEBUG_EXIT_STATUS(0, status);
            return status;
        }
 
        pContext->bIODeviceInitialized = TRUE;
        JustForCheckClearInterrupt(pContext, "init 0");
        ParaNdis_ResetVirtIONetDevice(pContext);
        JustForCheckClearInterrupt(pContext, "init 1");
        virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_ACKNOWLEDGE);
        JustForCheckClearInterrupt(pContext, "init 2");
        virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_DRIVER);
        pContext->ullHostFeatures = virtio_get_features(&pContext->IODevice);
        DumpVirtIOFeatures(pContext);
        JustForCheckClearInterrupt(pContext, "init 3");
        pContext->bLinkDetectSupported = 0 != VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_STATUS);
 
        if(pContext->bLinkDetectSupported) {
            virtio_get_config(&pContext->IODevice, sizeof(pContext->CurrentMacAddress), &linkStatus, sizeof(linkStatus));
            pContext->bConnected = (linkStatus & VIRTIO_NET_S_LINK_UP) != 0;
            DPrintf(0, ("[%s] Link status on driver startup: %d", __FUNCTION__, pContext->bConnected));
        }
 
        if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_VERSION_1))
        {
            // virtio 1.0 always uses the extended header
            pContext->nVirtioHeaderSize = sizeof(virtio_net_hdr_ext);
            VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_VERSION_1);
        }
        else
        {
            pContext->nVirtioHeaderSize = sizeof(virtio_net_hdr_basic);
        }
 
        if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_ANY_LAYOUT))
        {
            VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_ANY_LAYOUT);
        }
        if (VirtIODeviceGetHostFeature(pContext, VIRTIO_RING_F_EVENT_IDX))
        {
            VirtIODeviceEnableGuestFeature(pContext, VIRTIO_RING_F_EVENT_IDX);
        }
 
        if (!pContext->bUseMergedBuffers && VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_MRG_RXBUF))
        {
            DPrintf(0, ("[%s] Not using mergeable buffers", __FUNCTION__));
        }
        else
        {
            pContext->bUseMergedBuffers = VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_MRG_RXBUF) != 0;
            if (pContext->bUseMergedBuffers)
            {
                pContext->nVirtioHeaderSize = sizeof(virtio_net_hdr_ext);
                VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_MRG_RXBUF);
            }
        }
        if (VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_MAC))
        {
            virtio_get_config(
                &pContext->IODevice,
                0, // + offsetof(struct virtio_net_config, mac)
                &pContext->PermanentMacAddress,
                ETH_LENGTH_OF_ADDRESS);
            if (!ParaNdis_ValidateMacAddress(pContext->PermanentMacAddress, FALSE))
            {
                DPrintf(0,("Invalid device MAC ignored(%02x-%02x-%02x-%02x-%02x-%02x)",
                    pContext->PermanentMacAddress[0],
                    pContext->PermanentMacAddress[1],
                    pContext->PermanentMacAddress[2],
                    pContext->PermanentMacAddress[3],
                    pContext->PermanentMacAddress[4],
                    pContext->PermanentMacAddress[5]));
                NdisZeroMemory(pContext->PermanentMacAddress, sizeof(pContext->PermanentMacAddress));
            }
        }
 
        if (ETH_IS_EMPTY(pContext->PermanentMacAddress))
        {
            DPrintf(0, ("No device MAC present, use default"));
            pContext->PermanentMacAddress[0] = 0x02;
            pContext->PermanentMacAddress[1] = 0x50;
            pContext->PermanentMacAddress[2] = 0xF2;
            pContext->PermanentMacAddress[3] = 0x00;
            pContext->PermanentMacAddress[4] = 0x01;
            pContext->PermanentMacAddress[5] = 0x80 | (UCHAR)(pContext->ulUniqueID & 0xFF);
        }
        DPrintf(0,("Device MAC = %02x-%02x-%02x-%02x-%02x-%02x",
            pContext->PermanentMacAddress[0],
            pContext->PermanentMacAddress[1],
            pContext->PermanentMacAddress[2],
            pContext->PermanentMacAddress[3],
            pContext->PermanentMacAddress[4],
            pContext->PermanentMacAddress[5]));
 
        if (ETH_IS_EMPTY(pContext->CurrentMacAddress))
        {
            NdisMoveMemory(
                &pContext->CurrentMacAddress,
                &pContext->PermanentMacAddress,
                ETH_LENGTH_OF_ADDRESS);
        }
        else
        {
            DPrintf(0,("Current MAC = %02x-%02x-%02x-%02x-%02x-%02x",
                pContext->CurrentMacAddress[0],
                pContext->CurrentMacAddress[1],
                pContext->CurrentMacAddress[2],
                pContext->CurrentMacAddress[3],
                pContext->CurrentMacAddress[4],
                pContext->CurrentMacAddress[5]));
        }
        if (VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_CTRL_VQ)) {
            pContext->bHasControlQueue = TRUE;
            VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_CTRL_VQ);
        }
    }
    else
    {
        DPrintf(0, ("[%s] Error: Incomplete resources", __FUNCTION__));
        status = NDIS_STATUS_RESOURCE_CONFLICT;
    }
 
 
    if (pContext->bDoHardwareChecksum)
    {
        ULONG dependentOptions;
        dependentOptions = osbT4TcpChecksum | osbT4UdpChecksum | osbT4TcpOptionsChecksum;
        if (!VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_CSUM) &&
            (pContext->Offload.flagsValue & dependentOptions))
        {
            DPrintf(0, ("[%s] Host does not support CSUM, disabling CS offload", __FUNCTION__) );
            pContext->Offload.flagsValue &= ~dependentOptions;
        }
    }
 
    if (pContext->bDoGuestChecksumOnReceive && VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_GUEST_CSUM))
    {
        DPrintf(0, ("[%s] Enabling guest checksum", __FUNCTION__) );
        VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_GUEST_CSUM);
    }
    else
    {
        pContext->bDoGuestChecksumOnReceive = FALSE;
    }
 
    // now, after we checked the capabilities, we can initialize current
    // configuration of offload tasks
    ParaNdis_ResetOffloadSettings(pContext, NULL, NULL);
    if (pContext->Offload.flags.fTxLso && !pContext->bUseScatterGather)
    {
        DisableBothLSOPermanently(pContext, __FUNCTION__, "SG is not active");
    }
    if (pContext->Offload.flags.fTxLso &&
        !VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_HOST_TSO4))
    {
        DisableLSOv4Permanently(pContext, __FUNCTION__, "Host does not support TSOv4");
    }
    if (pContext->Offload.flags.fTxLsov6 &&
        !VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_HOST_TSO6))
    {
        DisableLSOv6Permanently(pContext, __FUNCTION__, "Host does not support TSOv6");
    }
    if (pContext->bUseIndirect)
    {
        const char *reason = "";
        if (!VirtIODeviceGetHostFeature(pContext, VIRTIO_RING_F_INDIRECT_DESC))
        {
            pContext->bUseIndirect = FALSE;
            reason = "Host support";
        }
        else if (!pContext->bUseScatterGather)
        {
            pContext->bUseIndirect = FALSE;
            reason = "SG";
        }
        DPrintf(0, ("[%s] %sable indirect Tx(!%s)", __FUNCTION__, pContext->bUseIndirect ? "En" : "Dis", reason) );
    }
 
    if (VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_CTRL_RX_EXTRA) &&
        pContext->bDoHwPacketFiltering)
    {
        DPrintf(0, ("[%s] Using hardware packet filtering", __FUNCTION__));
        pContext->bHasHardwareFilters = TRUE;
    }
 
    status = FinalizeFeatures(pContext);
 
    pContext->ReuseBufferProc = (tReuseReceiveBufferProc)ReuseReceiveBufferRegular;
 
    NdisInitializeEvent(&pContext->ResetEvent);
    DEBUG_EXIT_STATUS(0, status);
    return status;
}

Referenced by ParaNdis5_Initialize().

ParaNDIS_IsQueueInterruptEnabled()

static __inline BOOLEAN ParaNDIS_IsQueueInterruptEnabled ( struct virtqueue *  _vq )

static

Definition at line 601 of file ndis56common.h.

{
    return virtqueue_is_interrupt_enabled(_vq);
}

Referenced by ParaNdis_OnQueuedInterrupt().

ParaNdis_OnLegacyInterrupt()

BOOLEAN ParaNdis_OnLegacyInterrupt	(	PARANDIS_ADAPTER *	pContext,
		BOOLEAN *	pRunDpc
	)

Referenced by ParaNdis5_MiniportISR().

ParaNdis_OnPnPEvent()

VOID ParaNdis_OnPnPEvent	(	PARANDIS_ADAPTER *	pContext,
		NDIS_DEVICE_PNP_EVENT	pEvent,
		PVOID	pInfo,
		ULONG	ulSize
	)

Definition at line 2508 of file ParaNdis-Common.c.

{
    const char *pName = "";
    DEBUG_ENTRY(0);
#undef MAKECASE
#define MAKECASE(x) case (x): pName = #x; break;
    switch (pEvent)
    {
        MAKECASE(NdisDevicePnPEventQueryRemoved)
        MAKECASE(NdisDevicePnPEventRemoved)
        MAKECASE(NdisDevicePnPEventSurpriseRemoved)
        MAKECASE(NdisDevicePnPEventQueryStopped)
        MAKECASE(NdisDevicePnPEventStopped)
        MAKECASE(NdisDevicePnPEventPowerProfileChanged)
        default:
            break;
    }
    ParaNdis_DebugHistory(pContext, hopPnpEvent, NULL, pEvent, 0, 0);
    DPrintf(0, ("[%s] (%s)", __FUNCTION__, pName));
    if (pEvent == NdisDevicePnPEventSurpriseRemoved)
    {
        // on simulated surprise removal (under PnpTest) we need to reset the device
        // to prevent any access of device queues to memory buffers
        pContext->bSurprizeRemoved = TRUE;
        ParaNdis_ResetVirtIONetDevice(pContext);
    }
    pContext->PnpEvents[pContext->nPnpEventIndex++] = pEvent;
    if (pContext->nPnpEventIndex > sizeof(pContext->PnpEvents)/sizeof(pContext->PnpEvents[0]))
        pContext->nPnpEventIndex = 0;
}

Referenced by ParaNdis5_PnPEventNotify().

ParaNdis_OnQueuedInterrupt()

BOOLEAN ParaNdis_OnQueuedInterrupt	(	PARANDIS_ADAPTER *	pContext,
		BOOLEAN *	pRunDpc,
		ULONG	knownInterruptSources
	)

ParaNdis_OnShutdown()

VOID ParaNdis_OnShutdown

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 1415 of file ParaNdis-Common.c.

{
    DEBUG_ENTRY(0); // this is only for kdbg :)
    ParaNdis_ResetVirtIONetDevice(pContext);
}

Referenced by ParaNdis5_Shutdown().

ParaNdis_OnTransmitBufferReleased()

VOID ParaNdis_OnTransmitBufferReleased	(	PARANDIS_ADAPTER *	pContext,
		IONetDescriptor *	pDesc
	)

Definition at line 688 of file ParaNdis5-Impl.c.

{
    tSendEntry *pEntry = (tSendEntry *)pDesc->ReferenceValue;
    if (pEntry)
    {
        DPrintf(2, ("[%s] Entry %p (packet %p, %d buffers) ready!", __FUNCTION__, pEntry, pEntry->packet, pDesc->nofUsedBuffers));
        pEntry->flags |= SEND_ENTRY_FLAG_READY;
        pDesc->ReferenceValue = NULL;
        ParaNdis_DebugHistory(pContext, hopBufferSent, pEntry->packet, 0, pContext->nofFreeHardwareBuffers, pContext->nofFreeTxDescriptors);
    }
    else
    {
        ParaNdis_DebugHistory(pContext, hopBufferSent, NULL, 0, pContext->nofFreeHardwareBuffers, pContext->nofFreeTxDescriptors);
        DPrintf(0, ("[%s] ERROR: Send Entry not set!", __FUNCTION__));
    }
}

Referenced by ParaNdis_VirtIONetReleaseTransmitBuffers().

ParaNdis_OpenNICConfiguration()

NDIS_HANDLE ParaNdis_OpenNICConfiguration

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 98 of file ParaNdis5-Impl.c.

{
    NDIS_STATUS status;
    NDIS_HANDLE cfg;
    DEBUG_ENTRY(2);
    NdisOpenConfiguration(&status, &cfg, pContext->WrapperConfigurationHandle);
    if (status != NDIS_STATUS_SUCCESS)
        cfg = NULL;
    DEBUG_EXIT_STATUS(0, status);
    return cfg;
}

Referenced by ReadNicConfiguration().

ParaNdis_PacketCopier()

tCopyPacketResult ParaNdis_PacketCopier	(	tPacketType	packet,
		PVOID	dest,
		ULONG	maxSize,
		PVOID	refValue,
		BOOLEAN	bPreview
	)

Definition at line 616 of file ParaNdis5-Impl.c.

{
    PNDIS_BUFFER pBuffer;
    ULONG PriorityDataLong = ((tSendEntry *)refValue)->PriorityDataLong;
    tCopyPacketResult result;
    /* the copier called also for getting Ethernet header
       for statistics, when the transfer uses SG table */
    UINT uLength = 0;
    ULONG nCopied  = 0;
    ULONG ulToCopy = 0;
    if (bPreview) PriorityDataLong = 0;
    NdisQueryPacket(Packet,
                    NULL,
                    NULL,
                    &pBuffer,
                    (PUINT)&ulToCopy);
 
    if (ulToCopy > maxSize) ulToCopy = bPreview ? maxSize : 0;
    while (pBuffer && ulToCopy)
    {
        PVOID VirtualAddress = NULL;
        NdisQueryBufferSafe(pBuffer,
                            &VirtualAddress,
                            &uLength,
                            NormalPagePriority);
        if (!VirtualAddress)
        {
            /* the packet copy failed */
            nCopied = 0;
            break;
        }
        if(uLength)
        {
            // Copy the data.
            if (uLength > ulToCopy) uLength = ulToCopy;
            ulToCopy -= uLength;
            if ((PriorityDataLong & 0xFFFF) &&
                nCopied < ETH_PRIORITY_HEADER_OFFSET &&
                (nCopied + uLength) >= ETH_PRIORITY_HEADER_OFFSET)
            {
                ULONG ulCopyNow = ETH_PRIORITY_HEADER_OFFSET - nCopied;
                NdisMoveMemory(dest, VirtualAddress, ulCopyNow);
                dest = (PUCHAR)dest + ulCopyNow;
                VirtualAddress = (PUCHAR)VirtualAddress + ulCopyNow;
                NdisMoveMemory(dest, &PriorityDataLong, 4);
                nCopied += 4;
                dest = (PCHAR)dest + 4;
                ulCopyNow = uLength - ulCopyNow;
                if (ulCopyNow) NdisMoveMemory(dest, VirtualAddress, ulCopyNow);
                dest = (PCHAR)dest + ulCopyNow;
                nCopied += uLength;
            }
            else
            {
                NdisMoveMemory(dest, VirtualAddress, uLength);
                nCopied += uLength;
                dest = (PUCHAR)dest + uLength;
            }
        }
        NdisGetNextBuffer(pBuffer, &pBuffer);
    }
 
    DEBUG_EXIT_STATUS(4, nCopied);
    result.size = nCopied;
    return result;
}

Referenced by ParaNdis_DoCopyPacketData(), ParaNdis_DoSubmitPacket(), ParaNdis_PacketMapper(), and PrepareSendEntry().

ParaNdis_PacketMapper()

VOID ParaNdis_PacketMapper	(	PARANDIS_ADAPTER *	pContext,
		tPacketType	packet,
		PVOID	Reference,
		struct VirtIOBufferDescriptor *	buffers,
		pIONetDescriptor	pDesc,
		tMapperResult *	pMapperResult
	)

Definition at line 743 of file ParaNdis5-Impl.c.

{
    tSendEntry *pSendEntry = (tSendEntry *)ReferenceValue;
    ULONG PriorityDataLong = pSendEntry->PriorityDataLong;
    PSCATTER_GATHER_LIST pSGList = NDIS_PER_PACKET_INFO_FROM_PACKET(packet, ScatterGatherListPacketInfo);
    SCATTER_GATHER_ELEMENT *pSGElements = pSGList->Elements;
 
 
    if (pSGList && pSGList->NumberOfElements)
    {
        UINT i, lengthGet = 0, lengthPut = 0, nCompleteBuffersToSkip = 0, nBytesSkipInFirstBuffer = 0;
        if (pSendEntry->flags & (SEND_ENTRY_TSO_USED | SEND_ENTRY_TCP_CS | SEND_ENTRY_UDP_CS | SEND_ENTRY_IP_CS))
            lengthGet = pContext->Offload.ipHeaderOffset + MAX_IPV4_HEADER_SIZE + sizeof(TCPHeader);
        if (PriorityDataLong && !lengthGet)
            lengthGet = ETH_HEADER_SIZE;
        if (lengthGet)
        {
            ULONG len = 0;
            for (i = 0; i < pSGList->NumberOfElements; ++i)
            {
                len += pSGElements[i].Length;
                if (len > lengthGet)
                {
                    nBytesSkipInFirstBuffer = pSGList->Elements[i].Length - (len - lengthGet);
                    break;
                }
                DPrintf(2, ("[%s] skipping buffer %d of %d", __FUNCTION__, nCompleteBuffersToSkip, pSGElements[i].Length));
                nCompleteBuffersToSkip++;
            }
            // just for case of UDP packet shorter than TCP header
            if (lengthGet > len) lengthGet = len;
            lengthPut = lengthGet + (PriorityDataLong ? ETH_PRIORITY_HEADER_SIZE : 0);
        }
 
        if (lengthPut > pDesc->DataInfo.size)
        {
            DPrintf(0, ("[%s] ERROR: can not substitute %d bytes, sending as is", __FUNCTION__, lengthPut));
            nCompleteBuffersToSkip = 0;
            nBytesSkipInFirstBuffer = 0;
            lengthGet = lengthPut = 0;
        }
 
        if (lengthPut)
        {
            // we replace 1 or more HW buffers with one buffer preallocated for data
            buffers->physAddr = pDesc->DataInfo.Physical;
            buffers->length   = lengthPut;
            pMapperResult->usBufferSpaceUsed = (USHORT)lengthPut;
            pMapperResult->ulDataSize += lengthGet;
            pMapperResult->usBuffersMapped = (USHORT)(pSGList->NumberOfElements - nCompleteBuffersToSkip + 1);
            pSGElements += nCompleteBuffersToSkip;
            buffers++;
            DPrintf(1, ("[%s](%d bufs) skip %d buffers + %d bytes",
                __FUNCTION__, pSGList->NumberOfElements, nCompleteBuffersToSkip, nBytesSkipInFirstBuffer));
        }
        else
        {
            pMapperResult->usBuffersMapped = (USHORT)pSGList->NumberOfElements;
        }
 
        for (i = nCompleteBuffersToSkip; i < pSGList->NumberOfElements; ++i)
        {
            if (nBytesSkipInFirstBuffer)
            {
                buffers->physAddr.QuadPart = pSGElements->Address.QuadPart + nBytesSkipInFirstBuffer;
                buffers->length   = pSGElements->Length - nBytesSkipInFirstBuffer;
                DPrintf(2, ("[%s] using HW buffer %d of %d-%d", __FUNCTION__, i, pSGElements->Length, nBytesSkipInFirstBuffer));
                nBytesSkipInFirstBuffer = 0;
            }
            else
            {
                buffers->physAddr = pSGElements->Address;
                buffers->length   = pSGElements->Length;
            }
            pMapperResult->ulDataSize += buffers->length;
            pSGElements++;
            buffers++;
        }
 
        if (lengthPut)
        {
            PVOID pBuffer = pDesc->DataInfo.Virtual;
            PVOID pIpHeader = RtlOffsetToPointer(pBuffer, pContext->Offload.ipHeaderOffset);
            ParaNdis_PacketCopier(packet, pBuffer, lengthGet, ReferenceValue, TRUE);
 
            if (pSendEntry->flags & SEND_ENTRY_TSO_USED)
            {
                tTcpIpPacketParsingResult packetReview;
                ULONG dummyTransferSize = 0;
                USHORT saveBuffers = pMapperResult->usBuffersMapped;
                ULONG flags = pcrIpChecksum | pcrTcpChecksum | pcrFixIPChecksum | pcrFixPHChecksum;
                pMapperResult->usBuffersMapped = 0;
                packetReview = ParaNdis_CheckSumVerify(
                    pIpHeader,
                    lengthGet - pContext->Offload.ipHeaderOffset,
                    flags,
                    __FUNCTION__);
                /* uncomment to verify */
                /*
                packetReview = ParaNdis_CheckSumVerify(
                    pIpHeader,
                    lengthGet - pContext->Offload.ipHeaderOffset,
                    pcrIpChecksum | pcrTcpChecksum,
                    __FUNCTION__);
                */
                if (packetReview.ipCheckSum == ppresCSOK || packetReview.fixedIpCS)
                {
                    dummyTransferSize = CalculateTotalOffloadSize(
                        pMapperResult->ulDataSize,
                        pSendEntry->ipTransferUnit,
                        pContext->Offload.ipHeaderOffset,
                        pContext->MaxPacketSize.nMaxFullSizeOS,
                        packetReview);
                }
                else
                {
                    DPrintf(0, ("[%s] ERROR locating IP header in %d bytes(IP header of %d)", __FUNCTION__,
                        lengthGet, packetReview.ipHeaderSize));
                }
                NDIS_PER_PACKET_INFO_FROM_PACKET(packet, TcpLargeSendPacketInfo) = (PVOID)(ULONG_PTR)dummyTransferSize;
                if (dummyTransferSize)
                {
                    virtio_net_hdr_basic *pheader = pDesc->HeaderInfo.Virtual;
                    unsigned short addPriorityLen = PriorityDataLong ? ETH_PRIORITY_HEADER_SIZE : 0;
                    pheader->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
                    pheader->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
                    pheader->hdr_len  = (USHORT)(packetReview.XxpIpHeaderSize + pContext->Offload.ipHeaderOffset) + addPriorityLen;
                    pheader->gso_size = (USHORT)pSendEntry->ipTransferUnit;
                    pheader->csum_start = (USHORT)pContext->Offload.ipHeaderOffset + (USHORT)packetReview.ipHeaderSize + addPriorityLen;
                    pheader->csum_offset = TCP_CHECKSUM_OFFSET;
                    pMapperResult->usBuffersMapped = saveBuffers;
                }
            }
            else if (pSendEntry->flags & SEND_ENTRY_IP_CS)
            {
                ParaNdis_CheckSumVerify(
                    pIpHeader,
                    lengthGet - pContext->Offload.ipHeaderOffset,
                    pcrIpChecksum | pcrFixIPChecksum,
                    __FUNCTION__);
            }
 
            if (PriorityDataLong && pMapperResult->usBuffersMapped)
            {
                RtlMoveMemory(
                    RtlOffsetToPointer(pBuffer, ETH_PRIORITY_HEADER_OFFSET + ETH_PRIORITY_HEADER_SIZE),
                    RtlOffsetToPointer(pBuffer, ETH_PRIORITY_HEADER_OFFSET),
                    lengthGet - ETH_PRIORITY_HEADER_OFFSET
                    );
                NdisMoveMemory(
                    RtlOffsetToPointer(pBuffer, ETH_PRIORITY_HEADER_OFFSET),
                    &PriorityDataLong,
                    sizeof(ETH_PRIORITY_HEADER_SIZE));
                DPrintf(1, ("[%s] Populated priority value %lX", __FUNCTION__, PriorityDataLong));
            }
        }
    }
 
}

Referenced by ParaNdis_DoSubmitPacket().

ParaNdis_PadPacketReceived()

void ParaNdis_PadPacketReceived	(	PVOID	pDataBuffer,
		PULONG	pLength
	)

Definition at line 2065 of file ParaNdis-Common.c.

{
    // Ethernet standard declares minimal possible packet size
    // Packets smaller than that must be padded before transfer
    // Ethernet HW pads packets on transmit, however in our case
    // some packets do not travel over Ethernet but being routed
    // guest-to-guest by virtual switch.
    // In this case padding is not performed and we may
    // receive packet smaller than minimal allowed size. This is not
    // a problem for real life scenarios however WHQL/HCK contains
    // tests that check padding of received packets.
    // To make these tests happy we have to pad small packets on receive
 
    //NOTE: This function assumes that VLAN header has been already stripped out
 
    if(*pLength < ETH_MIN_PACKET_SIZE)
    {
        RtlZeroMemory(RtlOffsetToPointer(pDataBuffer, *pLength), ETH_MIN_PACKET_SIZE - *pLength);
        *pLength = ETH_MIN_PACKET_SIZE;
    }
}

Referenced by ParaNdis_IndicateReceivedPacket().

ParaNdis_PowerOff()

VOID ParaNdis_PowerOff

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 2805 of file ParaNdis-Common.c.

{
    DEBUG_ENTRY(0);
    ParaNdis_DebugHistory(pContext, hopPowerOff, NULL, 1, 0, 0);
 
    ParaNdis_IndicateConnect(pContext, FALSE, FALSE);
 
    // if bFastSuspendInProcess is set by Win8 power-off procedure
    // the ParaNdis_Suspend does fast Rx stop without waiting (=>srsPausing, if there are some RX packets in Ndis)
    pContext->bFastSuspendInProcess = pContext->bNoPauseOnSuspend && pContext->ReceiveState == srsEnabled;
    ParaNdis_Suspend(pContext);
    if (pContext->IODevice.addr)
    {
        /* back compat - remove the OK flag only in legacy mode */
        VirtIODeviceRemoveStatus(&pContext->IODevice, VIRTIO_CONFIG_S_DRIVER_OK);
    }
 
    if (pContext->bFastSuspendInProcess)
    {
        NdisAcquireSpinLock(&pContext->ReceiveLock);
        pContext->ReuseBufferProc = (tReuseReceiveBufferProc)ReuseReceiveBufferPowerOff;
        NdisReleaseSpinLock(&pContext->ReceiveLock);
    }
 
    ParaNdis_SetPowerState(pContext, NdisDeviceStateD3);
 
    PreventDPCServicing(pContext);
 
    /*******************************************************************
        shutdown queues to have all the receive buffers under our control
        all the transmit buffers move to list of free buffers
    ********************************************************************/
 
    NdisAcquireSpinLock(&pContext->SendLock);
    virtqueue_shutdown(pContext->NetSendQueue);
    while (!IsListEmpty(&pContext->NetSendBuffersInUse))
    {
        pIONetDescriptor pBufferDescriptor =
            (pIONetDescriptor)RemoveHeadList(&pContext->NetSendBuffersInUse);
        InsertTailList(&pContext->NetFreeSendBuffers, &pBufferDescriptor->listEntry);
        pContext->nofFreeTxDescriptors++;
        pContext->nofFreeHardwareBuffers += pBufferDescriptor->nofUsedBuffers;
    }
    NdisReleaseSpinLock(&pContext->SendLock);
 
    NdisAcquireSpinLock(&pContext->ReceiveLock);
    virtqueue_shutdown(pContext->NetReceiveQueue);
    NdisReleaseSpinLock(&pContext->ReceiveLock);
    if (pContext->NetControlQueue) {
        virtqueue_shutdown(pContext->NetControlQueue);
    }
 
    DPrintf(0, ("WARNING: deleting queues!!!!!!!!!"));
    DeleteNetQueues(pContext);
    pContext->NetSendQueue = NULL;
    pContext->NetReceiveQueue = NULL;
    pContext->NetControlQueue = NULL;
 
    ParaNdis_ResetVirtIONetDevice(pContext);
    ParaNdis_DebugHistory(pContext, hopPowerOff, NULL, 0, 0, 0);
}

Referenced by OnSetPowerWorkItem().

ParaNdis_PowerOn()

NDIS_STATUS ParaNdis_PowerOn

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 2720 of file ParaNdis-Common.c.

{
    LIST_ENTRY TempList;
    NDIS_STATUS status;
    DEBUG_ENTRY(0);
    ParaNdis_DebugHistory(pContext, hopPowerOn, NULL, 1, 0, 0);
    ParaNdis_ResetVirtIONetDevice(pContext);
    virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER);
    /* virtio_get_features must be called once upon device initialization:
     otherwise the device will not work properly */
    (void)virtio_get_features(&pContext->IODevice);
 
    if (pContext->bUseMergedBuffers)
        VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_MRG_RXBUF);
    if (VirtIODeviceGetHostFeature(pContext, VIRTIO_RING_F_EVENT_IDX))
        VirtIODeviceEnableGuestFeature(pContext, VIRTIO_RING_F_EVENT_IDX);
    if (pContext->bDoGuestChecksumOnReceive)
        VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_GUEST_CSUM);
    if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_VERSION_1))
        VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_VERSION_1);
    if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_ANY_LAYOUT))
        VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_ANY_LAYOUT);
 
    status = FinalizeFeatures(pContext);
    if (status == NDIS_STATUS_SUCCESS) {
        status = FindNetQueues(pContext);
    }
    if (status != NDIS_STATUS_SUCCESS) {
        virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_FAILED);
        return status;
    }
 
    ParaNdis_RestoreDeviceConfigurationAfterReset(pContext);
 
    ParaNdis_UpdateDeviceFilters(pContext);
 
    InitializeListHead(&TempList);
 
    /* submit all the receive buffers */
    NdisAcquireSpinLock(&pContext->ReceiveLock);
 
    pContext->ReuseBufferProc = (tReuseReceiveBufferProc)ReuseReceiveBufferRegular;
 
    while (!IsListEmpty(&pContext->NetReceiveBuffers))
    {
        pIONetDescriptor pBufferDescriptor =
            (pIONetDescriptor)RemoveHeadList(&pContext->NetReceiveBuffers);
        InsertTailList(&TempList, &pBufferDescriptor->listEntry);
    }
    pContext->NetNofReceiveBuffers = 0;
    while (!IsListEmpty(&TempList))
    {
        pIONetDescriptor pBufferDescriptor =
            (pIONetDescriptor)RemoveHeadList(&TempList);
        if (AddRxBufferToQueue(pContext, pBufferDescriptor))
        {
            InsertTailList(&pContext->NetReceiveBuffers, &pBufferDescriptor->listEntry);
            pContext->NetNofReceiveBuffers++;
        }
        else
        {
            DPrintf(0, ("FAILED TO REUSE THE BUFFER!!!!"));
            VirtIONetFreeBufferDescriptor(pContext, pBufferDescriptor);
            pContext->NetMaxReceiveBuffers--;
        }
    }
    virtqueue_kick(pContext->NetReceiveQueue);
    ParaNdis_SetPowerState(pContext, NdisDeviceStateD0);
    pContext->bEnableInterruptHandlingDPC = TRUE;
    virtio_device_ready(&pContext->IODevice);
 
    NdisReleaseSpinLock(&pContext->ReceiveLock);
 
    // if bFastSuspendInProcess is set by Win8 power-off procedure,
    // the ParaNdis_Resume enables Tx and RX
    // otherwise it does not do anything in Vista+ (Tx and RX are enabled after power-on by Restart)
    ParaNdis_Resume(pContext);
    pContext->bFastSuspendInProcess = FALSE;
 
    ParaNdis_ReportLinkStatus(pContext, TRUE);
    ParaNdis_DebugHistory(pContext, hopPowerOn, NULL, 0, 0, 0);
 
    return status;
}

Referenced by OnSetPowerWorkItem().

ParaNdis_ProcessTx()

BOOLEAN ParaNdis_ProcessTx	(	PARANDIS_ADAPTER *	pContext,
		BOOLEAN	IsDpc,
		BOOLEAN	IsInterrupt
	)

Definition at line 941 of file ParaNdis5-Impl.c.

{
    LIST_ENTRY DoneList;
    BOOLEAN bDoKick = FALSE;
    UINT nBuffersSent = 0, nBytesSent = 0;
    BOOLEAN bDataAvailable = FALSE;
    tSendEntry *pEntry;
    ONPAUSECOMPLETEPROC CallbackToCall = NULL;
    InitializeListHead(&DoneList);
    UNREFERENCED_PARAMETER(IsDpc);
    NdisAcquireSpinLock(&pContext->SendLock);
 
    ParaNdis_DebugHistory(pContext, hopTxProcess, NULL, 1, pContext->nofFreeHardwareBuffers, pContext->nofFreeTxDescriptors);
    do
    {
        if(IsTimeToReleaseTx(pContext))
        {
            // release some buffers
            ParaNdis_VirtIONetReleaseTransmitBuffers(pContext);
        }
        pEntry = NULL;
        if (!IsListEmpty(&pContext->SendQueue))
        {
            tCopyPacketResult result;
            tTxOperationParameters Params;
            pEntry = (tSendEntry *)RemoveHeadList(&pContext->SendQueue);
            InitializeTransferParameters(&Params, pEntry);
            bDataAvailable = TRUE;
            result = ParaNdis_DoSubmitPacket(pContext, &Params);
            if (result.error == cpeNoBuffer)
            {
                // can not send now, try next time
                InsertHeadList(&pContext->SendQueue, &pEntry->list);
                pEntry = NULL;
            }
            else if (result.error == cpeNoIndirect)
            {
                InsertHeadList(&pContext->SendQueue, &pEntry->list);
                pEntry->flags |= SEND_ENTRY_NO_INDIRECT;
            }
            else
            {
                InsertTailList(&pContext->TxWaitingList, &pEntry->list);
                ParaNdis_DebugHistory(pContext, hopSubmittedPacket, pEntry->packet, 0, result.error, Params.flags);
                if (!result.size)
                {
                    NDIS_STATUS status = NDIS_STATUS_FAILURE;
                    DPrintf(0, ("[%s] ERROR %d copying packet!", __FUNCTION__, result.error));
                    if (result.error == cpeTooLarge)
                    {
                        status = NDIS_STATUS_BUFFER_OVERFLOW;
                        pContext->Statistics.ifOutErrors++;
                    }
                    NDIS_SET_PACKET_STATUS(pEntry->packet, status);
                    pEntry->flags |= SEND_ENTRY_FLAG_READY;
                    // do not worry, go to the next one
 
                }
                else
                {
                    nBuffersSent++;
                    nBytesSent += result.size;
                    DPrintf(2, ("[%s] Scheduled packet %p, entry %p(%d bytes)!", __FUNCTION__,
                        pEntry->packet, pEntry, result.size));
                }
            }
        }
    } while (pEntry);
 
    if (nBuffersSent)
    {
        if(IsInterrupt)
        {
            bDoKick = TRUE;
        }
        else
        {
#ifdef PARANDIS_TEST_TX_KICK_ALWAYS
            virtqueue_kick_always(pContext->NetSendQueue);
#else
            virtqueue_kick(pContext->NetSendQueue);
#endif
        }
        DPrintf(2, ("[%s] sent down %d p.(%d b.)", __FUNCTION__, nBuffersSent, nBytesSent));
    }
    else if (bDataAvailable)
    {
        DPrintf(2, ("[%s] nothing sent", __FUNCTION__));
    }
 
    /* now check the waiting list of packets */
    while (!IsListEmpty(&pContext->TxWaitingList))
    {
        pEntry = (tSendEntry *)RemoveHeadList(&pContext->TxWaitingList);
        if (pEntry->flags & SEND_ENTRY_FLAG_READY)
        {
            InsertTailList(&DoneList, &pEntry->list);
        }
        else
        {
            InsertHeadList(&pContext->TxWaitingList, &pEntry->list);
            break;
        }
    }
 
    if (IsListEmpty(&pContext->TxWaitingList) && pContext->SendState == srsPausing && pContext->SendPauseCompletionProc)
    {
        CallbackToCall = pContext->SendPauseCompletionProc;
        pContext->SendPauseCompletionProc = NULL;
        pContext->SendState = srsDisabled;
        ParaNdis_DebugHistory(pContext, hopInternalSendPause, NULL, 0, 0, 0);
    }
    NdisReleaseSpinLock(&pContext->SendLock);
 
    while (!IsListEmpty(&DoneList))
    {
        pEntry = (tSendEntry *)RemoveHeadList(&DoneList);
        CompletePacket(pContext, pEntry->packet);
        NdisFreeMemory(pEntry, 0, 0);
    }
    if (CallbackToCall) CallbackToCall(pContext);
 
    return bDoKick;
}

Referenced by ParaNdis5_SendPackets(), and ParaNdis_DPCWorkBody().

ParaNdis_ReportLinkStatus()

VOID ParaNdis_ReportLinkStatus	(	PARANDIS_ADAPTER *	pContext,
		BOOLEAN	bForce
	)

Definition at line 2198 of file ParaNdis-Common.c.

{
    BOOLEAN bConnected = TRUE;
    if (pContext->bLinkDetectSupported)
    {
        USHORT linkStatus = 0;
        USHORT offset = sizeof(pContext->CurrentMacAddress);
        // link changed
        virtio_get_config(&pContext->IODevice, offset, &linkStatus, sizeof(linkStatus));
        bConnected = (linkStatus & VIRTIO_NET_S_LINK_UP) != 0;
    }
    ParaNdis_IndicateConnect(pContext, bConnected, bForce);
}

Referenced by OnConnectTimer(), OnResetWorkItem(), ParaNdis5_Initialize(), ParaNdis_DPCWorkBody(), and ParaNdis_PowerOn().

ParaNdis_ResetOffloadSettings()

void ParaNdis_ResetOffloadSettings	(	PARANDIS_ADAPTER *	pContext,
		tOffloadSettingsFlags *	pDest,
		PULONG	from
	)

Definition at line 411 of file ParaNdis-Common.c.

{
    if (!pDest) pDest = &pContext->Offload.flags;
    if (!from)  from = &pContext->Offload.flagsValue;
 
    pDest->fTxIPChecksum = !!(*from & osbT4IpChecksum);
    pDest->fTxTCPChecksum = !!(*from & osbT4TcpChecksum);
    pDest->fTxUDPChecksum = !!(*from & osbT4UdpChecksum);
    pDest->fTxTCPOptions = !!(*from & osbT4TcpOptionsChecksum);
    pDest->fTxIPOptions = !!(*from & osbT4IpOptionsChecksum);
 
    pDest->fTxLso = !!(*from & osbT4Lso);
    pDest->fTxLsoIP = !!(*from & osbT4LsoIp);
    pDest->fTxLsoTCP = !!(*from & osbT4LsoTcp);
 
    pDest->fRxIPChecksum = !!(*from & osbT4RxIPChecksum);
    pDest->fRxIPOptions = !!(*from & osbT4RxIPOptionsChecksum);
    pDest->fRxTCPChecksum = !!(*from & osbT4RxTCPChecksum);
    pDest->fRxTCPOptions = !!(*from & osbT4RxTCPOptionsChecksum);
    pDest->fRxUDPChecksum = !!(*from & osbT4RxUDPChecksum);
 
    pDest->fTxTCPv6Checksum = !!(*from & osbT6TcpChecksum);
    pDest->fTxTCPv6Options = !!(*from & osbT6TcpOptionsChecksum);
    pDest->fTxUDPv6Checksum = !!(*from & osbT6UdpChecksum);
    pDest->fTxIPv6Ext = !!(*from & osbT6IpExtChecksum);
 
    pDest->fTxLsov6 = !!(*from & osbT6Lso);
    pDest->fTxLsov6IP = !!(*from & osbT6LsoIpExt);
    pDest->fTxLsov6TCP = !!(*from & osbT6LsoTcpOptions);
 
    pDest->fRxTCPv6Checksum = !!(*from & osbT6RxTCPChecksum);
    pDest->fRxTCPv6Options = !!(*from & osbT6RxTCPOptionsChecksum);
    pDest->fRxUDPv6Checksum = !!(*from & osbT6RxUDPChecksum);
    pDest->fRxIPv6Ext = !!(*from & osbT6RxIpExtChecksum);
}

Referenced by DisableBothLSOPermanently(), DisableLSOv4Permanently(), DisableLSOv6Permanently(), GetLargeSendCapabilities(), GetTcpIpCheckSumCapabilities(), IsValidPcs(), IsValidPls(), ParaNdis_InitializeContext(), and ParseOffload().

ParaNdis_RestoreDeviceConfigurationAfterReset()

void ParaNdis_RestoreDeviceConfigurationAfterReset

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 110 of file ParaNdis5-Impl.c.

{
 
}

Referenced by ParaNdis_PowerOn().

ParaNdis_Resume()

VOID ParaNdis_Resume

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 209 of file ParaNdis5-Driver.c.

{
    ParaNdis5_StopSend(pContext, FALSE, NULL);
    ParaNdis5_StopReceive(pContext, FALSE, NULL);
    DEBUG_EXIT_STATUS(0, 0);
}

Referenced by OnResetWorkItem(), and ParaNdis_PowerOn().

ParaNdis_ReviewIPPacket()

tTcpIpPacketParsingResult ParaNdis_ReviewIPPacket	(	PVOID	buffer,
		ULONG	size,
		LPCSTR	caller
	)

Definition at line 614 of file sw-offload.c.

{
    tTcpIpPacketParsingResult res = QualifyIpPacket(buffer, size);
    PrintOutParsingResult(res, 1, caller);
    return res;
}

Referenced by QueryTcpHeaderOffset().

ParaNdis_SetMulticastList()

NDIS_STATUS ParaNdis_SetMulticastList	(	PARANDIS_ADAPTER *	pContext,
		PVOID	Buffer,
		ULONG	BufferSize,
		PUINT	pBytesRead,
		PUINT	pBytesNeeded
	)

Definition at line 2445 of file ParaNdis-Common.c.

{
    NDIS_STATUS status;
    ULONG length = BufferSize;
    if (length > sizeof(pContext->MulticastData.MulticastList))
    {
        status = NDIS_STATUS_MULTICAST_FULL;
        *pBytesNeeded = sizeof(pContext->MulticastData.MulticastList);
    }
    else if (length % ETH_LENGTH_OF_ADDRESS)
    {
        status = NDIS_STATUS_INVALID_LENGTH;
        *pBytesNeeded = (length / ETH_LENGTH_OF_ADDRESS) * ETH_LENGTH_OF_ADDRESS;
    }
    else
    {
        NdisZeroMemory(pContext->MulticastData.MulticastList, sizeof(pContext->MulticastData.MulticastList));
        if (length)
            NdisMoveMemory(pContext->MulticastData.MulticastList, Buffer, length);
        pContext->MulticastData.nofMulticastEntries = length / ETH_LENGTH_OF_ADDRESS;
        DPrintf(1, ("[%s] New multicast list of %d bytes", __FUNCTION__, length));
        *pBytesRead = length;
        status = NDIS_STATUS_SUCCESS;
    }
    return status;
}

Referenced by ParaNdis_OnOidSetMulticastList().

ParaNdis_SetPowerState()

VOID ParaNdis_SetPowerState	(	PARANDIS_ADAPTER *	pContext,
		NDIS_DEVICE_POWER_STATE	newState
	)

Definition at line 140 of file ParaNdis5-Impl.c.

{
    //NDIS_DEVICE_POWER_STATE prev = pContext->powerState;
    pContext->powerState = newState;
}

Referenced by ParaNdis_CleanupContext(), ParaNdis_FinishInitialization(), ParaNdis_PowerOff(), and ParaNdis_PowerOn().

ParaNdis_SetTimer()

BOOLEAN ParaNdis_SetTimer	(	NDIS_HANDLE	timer,
		LONG	millies
	)

ParaNdis_Suspend()

VOID ParaNdis_Suspend

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 190 of file ParaNdis5-Driver.c.

{
    DEBUG_ENTRY(0);
    NdisResetEvent(&pContext->ResetEvent);
    if (NDIS_STATUS_PENDING != ParaNdis5_StopSend(pContext, TRUE, OnSendStoppedOnReset))
    {
        NdisSetEvent(&pContext->ResetEvent);
    }
    NdisWaitEvent(&pContext->ResetEvent, 0);
    NdisResetEvent(&pContext->ResetEvent);
    if (NDIS_STATUS_PENDING != ParaNdis5_StopReceive(pContext, TRUE, OnReceiveStoppedOnReset))
    {
        NdisSetEvent(&pContext->ResetEvent);
    }
    NdisWaitEvent(&pContext->ResetEvent, 0);
    NdisResetEvent(&pContext->ResetEvent);
    DEBUG_EXIT_STATUS(0, 0);
}

Referenced by OnResetWorkItem(), and ParaNdis_PowerOff().

ParaNdis_SynchronizeWithInterrupt()

BOOLEAN ParaNdis_SynchronizeWithInterrupt	(	PARANDIS_ADAPTER *	pContext,
		ULONG	messageId,
		tSynchronizedProcedure	procedure,
		PVOID	parameter
	)

Definition at line 1464 of file ParaNdis5-Impl.c.

{
    tSynchronizedContext SyncContext;
    SyncContext.pContext  = pContext;
    SyncContext.Parameter = parameter;
    return NdisMSynchronizeWithInterrupt(&pContext->Interrupt, procedure, &SyncContext);
}

Referenced by ParaNdis_DPCWorkBody().

ParaNdis_UnbindBufferFromPacket()

void ParaNdis_UnbindBufferFromPacket	(	PARANDIS_ADAPTER *	pContext,
		pIONetDescriptor	pBufferDesc
	)

Definition at line 432 of file ParaNdis5-Impl.c.

{
    if (pBufferDesc->pHolder)
    {
        PNDIS_BUFFER    pBuffer = NULL;
        PNDIS_PACKET    Packet = pBufferDesc->pHolder;
        pBufferDesc->pHolder = NULL;
        NdisUnchainBufferAtFront(Packet, &pBuffer);
        if (pBuffer)
        {
            NdisAdjustBufferLength(pBuffer, MaxNdisBufferDataSize(pContext, pBufferDesc));
            NdisFreeBuffer(pBuffer);
        }
        NdisFreePacket(Packet);
    }
}

Referenced by VirtIONetFreeBufferDescriptor().

ParaNdis_UpdateDeviceFilters()

VOID ParaNdis_UpdateDeviceFilters

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 2710 of file ParaNdis-Common.c.

{
    if (pContext->bHasHardwareFilters)
    {
        ParaNdis_DeviceFiltersUpdateRxMode(pContext);
        ParaNdis_DeviceFiltersUpdateAddresses(pContext);
        ParaNdis_DeviceFiltersUpdateVlanId(pContext);
    }
}

Referenced by ParaNdis_FinishInitialization(), ParaNdis_OnOidSetMulticastList(), ParaNdis_OnSetPacketFilter(), and ParaNdis_PowerOn().

ParaNdis_ValidateMacAddress()

BOOLEAN ParaNdis_ValidateMacAddress	(	PUCHAR	pcMacAddress,
		BOOLEAN	bLocal
	)

Definition at line 68 of file ParaNdis-Common.c.

{
    BOOLEAN bLA = FALSE, bEmpty, bBroadcast, bMulticast = FALSE;
    bBroadcast = ETH_IS_BROADCAST(pcMacAddress);
    bLA = !bBroadcast && ETH_IS_LOCALLY_ADMINISTERED(pcMacAddress);
    bMulticast = !bBroadcast && ETH_IS_MULTICAST(pcMacAddress);
    bEmpty = ETH_IS_EMPTY(pcMacAddress);
    return !bBroadcast && !bEmpty && !bMulticast && (!bLocal || bLA);
}

Referenced by ParaNdis_InitializeContext().

ParaNdis_VirtIODisableIrqSynchronized()

VOID ParaNdis_VirtIODisableIrqSynchronized	(	PARANDIS_ADAPTER *	pContext,
		ULONG	interruptSource
	)

Definition at line 2494 of file ParaNdis-Common.c.

{
    if (interruptSource & isTransmit)
        virtqueue_disable_cb(pContext->NetSendQueue);
    if (interruptSource & isReceive)
        virtqueue_disable_cb(pContext->NetReceiveQueue);
    ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)0x10, interruptSource, FALSE, 0);
}

Referenced by ParaNdis_OnLegacyInterrupt(), and ParaNdis_OnQueuedInterrupt().

ParaNdis_VirtIOEnableIrqSynchronized()

VOID ParaNdis_VirtIOEnableIrqSynchronized	(	PARANDIS_ADAPTER *	pContext,
		ULONG	interruptSource
	)

Definition at line 2485 of file ParaNdis-Common.c.

{
    if (interruptSource & isTransmit)
        virtqueue_enable_cb(pContext->NetSendQueue);
    if (interruptSource & isReceive)
        virtqueue_enable_cb(pContext->NetReceiveQueue);
    ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)0x10, interruptSource, TRUE, 0);
}

ParaNdis_VirtIONetReleaseTransmitBuffers()

UINT ParaNdis_VirtIONetReleaseTransmitBuffers

(

PARANDIS_ADAPTER *

pContext

)

Definition at line 1562 of file ParaNdis-Common.c.

{
    UINT len, i = 0;
    pIONetDescriptor pBufferDescriptor;
 
    DEBUG_ENTRY(4);
 
    while(NULL != (pBufferDescriptor = virtqueue_get_buf(pContext->NetSendQueue, &len)))
    {
        RemoveEntryList(&pBufferDescriptor->listEntry);
        pContext->nofFreeTxDescriptors++;
        if (!pBufferDescriptor->nofUsedBuffers)
        {
            DPrintf(0, ("[%s] ERROR: nofUsedBuffers not set!", __FUNCTION__));
        }
        pContext->nofFreeHardwareBuffers += pBufferDescriptor->nofUsedBuffers;
        ParaNdis_OnTransmitBufferReleased(pContext, pBufferDescriptor);
        InsertTailList(&pContext->NetFreeSendBuffers, &pBufferDescriptor->listEntry);
        DPrintf(3, ("[%s] Free Tx: desc %d, buff %d", __FUNCTION__, pContext->nofFreeTxDescriptors, pContext->nofFreeHardwareBuffers));
        pBufferDescriptor->nofUsedBuffers = 0;
        ++i;
    }
    if (i)
    {
        NdisGetCurrentSystemTime(&pContext->LastTxCompletionTimeStamp);
        pContext->bDoKickOnNoBuffer = TRUE;
        pContext->nDetectedStoppedTx = 0;
    }
    DEBUG_EXIT_STATUS((i ? 3 : 5), i);
    return i;
}

Referenced by ParaNdis_DoSubmitPacket(), and ParaNdis_ProcessTx().

VirtIODeviceEnableGuestFeature()

static void VirtIODeviceEnableGuestFeature ( PARANDIS_ADAPTER *  pContext, unsigned  uFeature  )

inlinestatic

Definition at line 521 of file ndis56common.h.

{
   DPrintf(4, ("%s\n", __FUNCTION__));
 
   virtio_feature_enable(pContext->ullGuestFeatures, uFeature);
}

Referenced by ParaNdis_InitializeContext(), and ParaNdis_PowerOn().

VirtIODeviceGetHostFeature()

static bool VirtIODeviceGetHostFeature ( PARANDIS_ADAPTER *  pContext, unsigned  uFeature  )

inlinestatic

Definition at line 514 of file ndis56common.h.

{
   DPrintf(4, ("%s\n", __FUNCTION__));
 
   return virtio_is_feature_enabled(pContext->ullHostFeatures, uFeature);
}

Referenced by DumpVirtIOFeatures(), ParaNdis_InitializeContext(), and ParaNdis_PowerOn().

Variable Documentation

PARANDIS_PACKET_FILTERS

const ULONG PARANDIS_PACKET_FILTERS

static

Initial value:

=
    NDIS_PACKET_TYPE_DIRECTED |
    NDIS_PACKET_TYPE_MULTICAST |
    NDIS_PACKET_TYPE_BROADCAST |
    NDIS_PACKET_TYPE_PROMISCUOUS |
    NDIS_PACKET_TYPE_ALL_MULTICAST

Definition at line 143 of file ndis56common.h.

Referenced by ParaNdis_OnSetPacketFilter().

ParaNdisSystemOps

VirtIOSystemOps ParaNdisSystemOps

extern

Definition at line 370 of file ParaNdis-VirtIO.c.

Referenced by ParaNdis_InitializeContext().