able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/atm/epvc/sys/protocol.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

5385 lines
136 KiB
C
Raw Blame History

/*++
Copyright(c) 1992 Microsoft Corporation
Module Name:
protocol.c
Abstract:
ATM Ethernet PVC driver.
Author:
ADube - created
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
const WCHAR c_szIMMiniportList[] = L"IMMiniportList";
const WCHAR c_szUpperBindings[] = L"UpperBindings";
#define MAX_PACKET_POOL_SIZE 0x0000FFFF
#define MIN_PACKET_POOL_SIZE 0x000000FF
VOID
EpvcResetComplete(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status
)
/*++
Routine Description:
Completion for the reset.
Arguments:
ProtocolBindingContext Pointer to the adapter structure
Status Completion status
Return Value:
None.
--*/
{
PADAPT pAdapt =(PADAPT)ProtocolBindingContext;
//
// We never issue a reset, so we should not be here.
//
ASSERT(0);
}
VOID
EpvcRequestComplete(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_REQUEST pNdisRequest,
IN NDIS_STATUS Status
)
/*++
Routine Description:
Completion handler for the previously posted request. All OIDS are completed by and sent to
the same miniport that they were requested for.
If Oid == OID_PNP_QUERY_POWER then the data structure needs to returned with all entries =
NdisDeviceStateUnspecified
Arguments:
ProtocolBindingContext Pointer to the adapter structure
NdisRequest The posted request
Status Completion status
Return Value:
None
--*/
{
ENTER("EpvcRequestComplete", 0x44a78b21)
PEPVC_ADAPTER pAdapter =(PEPVC_ADAPTER)ProtocolBindingContext;
PEPVC_NDIS_REQUEST pEpvcRequest = (PEPVC_NDIS_REQUEST )pNdisRequest;
RM_DECLARE_STACK_RECORD(sr)
pEpvcRequest = CONTAINING_RECORD(pNdisRequest, EPVC_NDIS_REQUEST, Request);
pEpvcRequest->Status = Status;
if (pEpvcRequest->pFunc == NULL)
{
//
// Unblock the calling thread
//
NdisSetEvent(&pEpvcRequest ->Event);
}
else
{
//
// Invoke the REquest completion handler
//
(pEpvcRequest->pFunc) (pEpvcRequest, Status);
}
EXIT()
RM_ASSERT_CLEAR(&sr);
}
VOID
PtStatus(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS GeneralStatus,
IN PVOID StatusBuffer,
IN UINT StatusBufferSize
)
/*++
Routine Description:
Status handler for the lower-edge(protocol).
Arguments:
ProtocolBindingContext Pointer to the adapter structure
GeneralStatus Status code
StatusBuffer Status buffer
StatusBufferSize Size of the status buffer
Return Value:
None
--*/
{
PEPVC_ADAPTER pAdapter =(PEPVC_ADAPTER)ProtocolBindingContext;
TRACE (TL_T, TM_Pt, ("== PtStatus Status %x", GeneralStatus));
}
VOID
EpvcStatus(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS GeneralStatus,
IN PVOID StatusBuffer,
IN UINT StatusBufferSize
)
/*++
Routine Description:
Status handler for the lower-edge(protocol).
Call the Status indication function of all the miniports
associated with this adapter
Arguments:
ProtocolBindingContext Pointer to the adapter structure
GeneralStatus Status code
StatusBuffer Status buffer
StatusBufferSize Size of the status buffer
Return Value:
None
--*/
{
ENTER ("EpvcStatus",0x733e2f9e)
PEPVC_ADAPTER pAdapter =(PEPVC_ADAPTER)ProtocolBindingContext;
PEPVC_WORKITEM pWorkItem = NULL;
STATUS_INDICATION_CONTEXT Context;
BOOLEAN bDoNotProcess = FALSE;
BOOLEAN bIsMediaEvent = FALSE;
NDIS_MEDIA_STATE NewMediaState;
RM_DECLARE_STACK_RECORD(SR);
//
// Store the parameter, these will be passed to the miniports
//
Context.StatusBuffer = StatusBuffer ;
Context.StatusBufferSize = StatusBufferSize;
Context.GeneralStatus = GeneralStatus;
do
{
LOCKOBJ(pAdapter, &SR);
//
// Check for 2 conditions i Is it a Media event and
// 2) if it is a repeat indication
//
bIsMediaEvent = (GeneralStatus == NDIS_STATUS_MEDIA_CONNECT ||
GeneralStatus == NDIS_STATUS_MEDIA_DISCONNECT );
//
// Check for repitions next
//
if (GeneralStatus == NDIS_STATUS_MEDIA_CONNECT &&
pAdapter->info.MediaState == NdisMediaStateConnected)
{
bDoNotProcess = TRUE;
}
if (GeneralStatus == NDIS_STATUS_MEDIA_DISCONNECT &&
pAdapter->info.MediaState == NdisMediaStateDisconnected)
{
bDoNotProcess = TRUE;
}
//
// Convert the Media Status into an NdisMediaState
//
if (bIsMediaEvent == TRUE && bDoNotProcess == FALSE)
{
if (GeneralStatus == NDIS_STATUS_MEDIA_DISCONNECT )
{
pAdapter->info.MediaState = NdisMediaStateDisconnected;
}
if (GeneralStatus == NDIS_STATUS_MEDIA_CONNECT)
{
pAdapter->info.MediaState = NdisMediaStateConnected;
}
}
//
// Update the Media state, if we have a new state
//
UNLOCKOBJ(pAdapter, &SR);
if (bDoNotProcess == TRUE)
{
break;
}
epvcEnumerateObjectsInGroup(&pAdapter->MiniportsGroup,
epvcProcessStatusIndication ,
(PVOID)&Context,
&SR);
} while (FALSE);
RM_ASSERT_CLEAR(&SR);
EXIT()
return;
}
INT
epvcProcessStatusIndication (
PRM_OBJECT_HEADER pHdr,
PVOID pvContext,
PRM_STACK_RECORD pSR
)
/*++
Routine Description:
Status handler for the lower-edge(protocol).
If we get a media connect, we queue a task to do the Vc Setup
If we get a media disconnect, we queue a task to tear the VC down
Arguments:
ProtocolBindingContext Pointer to the adapter structure
GeneralStatus Status code
StatusBuffer Status buffer
StatusBufferSize Size of the status buffer
Return Value:
None
--*/
{
PEPVC_I_MINIPORT pMiniport = (PEPVC_I_MINIPORT)pHdr;
PEPVC_ADAPTER pAdapter = pMiniport->pAdapter;
BOOLEAN fIsMiniportActive = FALSE;
PSTATUS_INDICATION_CONTEXT pContext = (PSTATUS_INDICATION_CONTEXT)pvContext ;
NDIS_STATUS GeneralStatus = pContext->GeneralStatus;
do
{
//
// if this is not a media indication pass it up to ndis.
//
fIsMiniportActive = MiniportTestFlag(pMiniport, fMP_MiniportInitialized);
if (fIsMiniportActive == FALSE)
{
break;
}
//
// Only pass up an indication if the miniport has been initialized
//
//
// Filter out a duplicate Indication
//
if (GeneralStatus == NDIS_STATUS_MEDIA_DISCONNECT &&
pMiniport->info.MediaState == NdisMediaStateDisconnected)
{
break;
}
if (GeneralStatus == NDIS_STATUS_MEDIA_DISCONNECT &&
pMiniport->info.MediaState == NdisMediaStateDisconnected)
{
break;
}
//
// Record the status and indicate it up to the protocols
//
if (GeneralStatus == NDIS_STATUS_MEDIA_CONNECT)
{
pMiniport->info.MediaState = NdisMediaStateConnected;
}
if (GeneralStatus == NDIS_STATUS_MEDIA_DISCONNECT )
{
pMiniport->info.MediaState = NdisMediaStateDisconnected;
}
epvcMIndicateStatus(pMiniport,
GeneralStatus,
pContext->StatusBuffer,
pContext->StatusBufferSize
);
} while (FALSE);
//
// As we continue the iteration, return TRUE
//
return TRUE;
}
VOID
epvcMediaWorkItem(
PNDIS_WORK_ITEM pWorkItem,
PVOID Context
)
/*++
Routine Description:
Status handler for the lower-edge(protocol).
If we get a media connect, we queue a task to do the Vc Setup
If we get a media disconnect, we queue a task to tear the VC down
Arguments:
ProtocolBindingContext Pointer to the adapter structure
GeneralStatus Status code
StatusBuffer Status buffer
StatusBufferSize Size of the status buffer
Return Value:
None
--*/
{
ASSERT (0);
}
INT
epvcMiniportIndicateStatusComplete(
PRM_OBJECT_HEADER pHdr,
PVOID pvContext,
PRM_STACK_RECORD pSR
)
/*++
Routine Description:
Indicate the status upto the protocols
Arguments:
Return Value:
--*/
{
PEPVC_I_MINIPORT pMiniport = (PEPVC_I_MINIPORT) pHdr;
BOOLEAN fIsMiniportActive = MiniportTestFlag(pMiniport, fMP_MiniportInitialized);
//
// Only pass up an indication if the miniport has been initialized
//
if (fIsMiniportActive == TRUE )
{
NdisMIndicateStatusComplete(pMiniport->ndis.MiniportAdapterHandle);
}
return TRUE;
}
VOID
PtStatusComplete(
IN NDIS_HANDLE ProtocolBindingContext
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
ENTER("PtStatusComplete", 0x5729d194)
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER) ProtocolBindingContext;
RM_DECLARE_STACK_RECORD(SR);
//
// Iterate through all the miniports and stop them
//
epvcEnumerateObjectsInGroup (&pAdapter->MiniportsGroup,
epvcMiniportIndicateStatusComplete,
NULL,
&SR );
}
VOID
PtTransferDataComplete(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET Packet,
IN NDIS_STATUS Status,
IN UINT BytesTransferred
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
PEPVC_I_MINIPORT pMiniport =(PEPVC_I_MINIPORT )ProtocolBindingContext;
if(pMiniport->ndis.MiniportAdapterHandle)
{
NdisMTransferDataComplete(pMiniport->ndis.MiniportAdapterHandle,
Packet,
Status,
BytesTransferred);
}
}
NDIS_STATUS
PtReceive(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE MacReceiveContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookAheadBuffer,
IN UINT LookAheadBufferSize,
IN UINT PacketSize
)
/*++
Routine Description:
LBFO - need to use primary for all receives
Arguments:
Return Value:
--*/
{
PADAPT pAdapt =(PADAPT)ProtocolBindingContext;
PNDIS_PACKET MyPacket, Packet;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
if(!pAdapt->ndis.MiniportAdapterHandle)
{
Status = NDIS_STATUS_FAILURE;
}
return Status;
}
VOID
PtReceiveComplete(
IN NDIS_HANDLE ProtocolBindingContext
)
/*++
Routine Description:
Called by the adapter below us when it is done indicating a batch of received buffers.
Arguments:
ProtocolBindingContext Pointer to our adapter structure.
Return Value:
None
--*/
{
PADAPT pAdapt =(PADAPT)ProtocolBindingContext;
}
INT
PtReceivePacket(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET Packet
)
/*++
Routine Description:
ReceivePacket handler. Called up by the miniport below when it supports NDIS 4.0 style receives.
Re-package the packet and hand it back to NDIS for protocols above us. The re-package part is
important since NDIS uses the WrapperReserved part of the packet for its own book-keeping. Also
the re-packaging works differently when packets flow-up or down. In the up-path(here) the protocol
reserved is owned by the protocol above. We need to use the miniport reserved here.
Arguments:
ProtocolBindingContext Pointer to our adapter structure.
Packet - Pointer to the packet
Return Value:
== 0 -> We are done with the packet
!= 0 -> We will keep the packet and call NdisReturnPackets() this many times when done.
--*/
{
PADAPT pAdapt =(PADAPT)ProtocolBindingContext;
NDIS_STATUS Status;
PNDIS_PACKET MyPacket;
PEPVC_PKT_CONTEXT Resvd;
return 0;
}
//--------------------------------------------------------------------------------
// //
// Address Family - Entry points and Tasks //
// //
// //
//--------------------------------------------------------------------------------
VOID
EpvcAfRegisterNotify(
IN NDIS_HANDLE ProtocolBindingContext,
IN PCO_ADDRESS_FAMILY pAddressFamily
)
/*++
Routine Description:
This informs us that the Call manager is bound to a NIC. and that the call
manager is telling us that it is ready to accepts calls.
We expect there to be one interesting Address Family per underlying adapter
Arguments:
UserParam for (Code == RM_TASKOP_START) : UnbindContext
--*/
{
ENTER("EpvcAfRegisterNotify", 0xaea79b12)
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER) ProtocolBindingContext;
RM_DECLARE_STACK_RECORD(SR);
TRACE (TL_T, TM_Pt,("==>EpvcAfRegisterNotify\n"));
do
{
if (pAddressFamily->AddressFamily != CO_ADDRESS_FAMILY_Q2931)
{
//
// The call manager is not indicating the address family for an atm
// miniport. We are not interested
//
break;
}
LOCKOBJ(pAdapter, &SR);
RmTmpReferenceObject(&pAdapter->Hdr, &SR);
pAdapter->af.AddressFamily = *pAddressFamily;
//
//Begin a task that will call NdisClOpenAddressFamily asynchronously
//
UNLOCKOBJ(pAdapter, &SR);
epvcEnumerateObjectsInGroup(&pAdapter->MiniportsGroup,
epvcAfInitEnumerate,
NULL, // Context
&SR );
LOCKOBJ(pAdapter, &SR);
RmTmpDereferenceObject(&pAdapter->Hdr, &SR);
UNLOCKOBJ(pAdapter, &SR);
} while (FALSE);
TRACE (TL_T, TM_Pt, ("<==EpvcAfRegisterNotify\n"));
RM_ASSERT_CLEAR(&SR);
EXIT()
}
// Enum function
//
INT
epvcAfInitEnumerate(
PRM_OBJECT_HEADER pHdr,
PVOID pvContext, // Unused
PRM_STACK_RECORD pSR
)
/*++
Routine Description:
We have been notified of an acceptable address family
Iterate through all the miniort structures and open the address family
and InitDeviceInstance on each of the miniports
Arguments:
--*/
{
ENTER("epvcAfInitEnumerate ",0x72eb5b98 )
PEPVC_I_MINIPORT pMiniport = (PEPVC_I_MINIPORT) pHdr;
//
// Get miniport lock and tmpref it.
//
LOCKOBJ(pMiniport, pSR);
RmTmpReferenceObject(&pMiniport->Hdr, pSR);
do
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
PRM_TASK pTask= NULL;
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER)pMiniport->Hdr.pParentObject;
ASSERT (pAdapter->Hdr.Sig == TAG_ADAPTER);
//
// Allocate task to complete the unbind.
//
Status = epvcAllocateTask(
&pMiniport->Hdr, // pParentObject,
epvcTaskStartIMiniport, // pfnHandler,
0, // Timeout,
"Task: Open address Family", // szDescription
&pTask,
pSR
);
if (FAIL(Status))
{
// Ugly situation. We'll just leave things as they are...
//
pTask = NULL;
TR_WARN(("FATAL: couldn't allocate unbind task!\n"));
break;
}
// Start the task to complete the Open Address Family.
// No locks must be held. RmStartTask uses up the tmpref on the task
// which was added by epvcAllocateTask.
//
UNLOCKOBJ(pMiniport, pSR);
((PTASK_AF) pTask)->pAf= &pAdapter->af.AddressFamily ;
((PTASK_AF) pTask)->Cause = TaskCause_AfNotify;
RmStartTask(pTask, 0, pSR);
LOCKOBJ(pMiniport, pSR);
} while(FALSE);
UNLOCKOBJ(pMiniport, pSR);
RmTmpDereferenceObject(&pMiniport->Hdr, pSR);
EXIT()
//
// As we want the enumeration to cotinue
//
return TRUE;
}
NDIS_STATUS
epvcTaskStartIMiniport(
IN struct _RM_TASK * pTask,
IN RM_TASK_OPERATION Code,
IN UINT_PTR UserParam,
IN PRM_STACK_RECORD pSR
)
/*++
Routine Description:
Task handler for opening address families on an underlying adapters.
The number of address families instantiated is determined by the
configuration read in the registry
Arguments:
UserParam for (Code == RM_TASKOP_START) : UnbindContext
--*/
{
ENTER("epvcTaskStartIMiniport", 0xaac34d81)
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
PEPVC_I_MINIPORT pMiniport = (PEPVC_I_MINIPORT ) RM_PARENT_OBJECT(pTask);
NDIS_STATUS InitStatus = NDIS_STATUS_SUCCESS;
PTASK_AF pAfTask = (PTASK_AF) pTask;
NDIS_HANDLE NdisAfHandle = NULL;
PEPVC_ADAPTER pAdapter = pMiniport->pAdapter;
ULONG State = pTask->Hdr.State;
enum
{
Stage_Start =0, // default
Stage_OpenAfComplete,
Stage_CloseAfComplete, // In case of failure
Stage_TaskCompleted,
Stage_End
}; // To be used in pTask->Hdr.State to indicate the state of the Task
TRACE ( TL_T, TM_Pt, ("==>epvcTaskStartIMiniport Code %x", Code) );
TRACE (TL_V, TM_Pt, ("epvcTaskStartIMiniport Task %p Task is in state %x\n", pTask, pTask->Hdr.State));
switch(pTask->Hdr.State)
{
case Stage_Start:
{
//
// is there another open address family task active
//
LOCKOBJ (pMiniport, pSR);
if (epvcIsThisTaskPrimary ( pTask, &(PRM_TASK)(pMiniport->af.pAfTask)) == FALSE)
{
PRM_TASK pOtherTask = (PRM_TASK)(pMiniport->af.pAfTask);
RmTmpReferenceObject (&pOtherTask->Hdr, pSR);
//
// Set The state so we restart this code after main task completes
//
pTask->Hdr.State = Stage_Start;
UNLOCKOBJ(pMiniport, pSR);
RmPendTaskOnOtherTask (pTask, 0, pOtherTask, pSR);
RmTmpDereferenceObject(&pOtherTask->Hdr,pSR);
Status = NDIS_STATUS_PENDING;
break;
}
//
// We are the primary task
//
ASSERT (pMiniport->af.pAfTask == pAfTask);
//
// make sure we are bound to the adapter below. If not exit
//
if (CHECK_AD_PRIMARY_STATE (pAdapter, EPVC_AD_PS_INITED) == FALSE &&
pAdapter->bind.BindingHandle == NULL)
{
//
// quietly exit as the protocol is not bound to the adapter below
//
UNLOCKOBJ(pMiniport, pSR);
pTask->Hdr.State = Stage_TaskCompleted; // we're finished.
Status = NDIS_STATUS_SUCCESS; // Exit
break;
}
//
// Check to see if our work is already done
//
if (MiniportTestFlag (pMiniport, fMP_AddressFamilyOpened) == TRUE)
{
//
// quietly exit as the address family is already Opened
//
UNLOCKOBJ(pMiniport, pSR);
pTask->Hdr.State = Stage_TaskCompleted; // we're finished.
Status = NDIS_STATUS_SUCCESS; // Exit
break;
}
UNLOCKOBJ(pMiniport,pSR);
//
// Get Ready to suspend the task.
// First update the state so that the resume
// will take it to the correct place
//
pTask->Hdr.State = Stage_OpenAfComplete;
RmSuspendTask( pTask, 0 ,pSR);
//
// Call Ndis to open address family
//
Status = epvcClOpenAddressFamily(pAdapter->bind.BindingHandle,
&pAdapter->af.AddressFamily,
(NDIS_HANDLE)pMiniport,
&EpvcGlobals.ndis.CC,
sizeof (EpvcGlobals.ndis.CC),
&NdisAfHandle
);
if (PEND(Status)== FALSE)
{
//
// Call the completion handler
//
EpvcCoOpenAfComplete(Status,
pMiniport,
NdisAfHandle );
Status = NDIS_STATUS_PENDING;
}
//
// Now let this thread exit. Make the Async
// Completion handler complete the task
//
break;
}
case Stage_OpenAfComplete:
{
InitStatus = NDIS_STATUS_SUCCESS;
//
// If the status is success then initialize the miniport
//
do
{
if (pAfTask->ReturnStatus != NDIS_STATUS_SUCCESS)
{
break;
}
//
// Success, so Now initialize the miniport
//
LOCKOBJ (pMiniport, pSR);
//
// Set the appropriate flag
//
MiniportSetFlag(pMiniport, fMP_DevInstanceInitialized);
UNLOCKOBJ (pMiniport, pSR);
RM_ASSERT_NOLOCKS(pSR);
InitStatus = NdisIMInitializeDeviceInstanceEx( EpvcGlobals.driver.DriverHandle,
&pMiniport->ndis.DeviceName,
pMiniport);
} while (FALSE);
//
// Handle Failure
//
if (FAIL(InitStatus) || FAIL(pAfTask->ReturnStatus))
{
TRACE (TL_V, TM_Mp, ("epvcStartImMiniport Failed Status %x, InitStatus %x",Status, InitStatus));
LOCKOBJ (pMiniport, pSR);
//
// Clear the appropriate flags
//
if (MiniportTestFlag(pMiniport, fMP_AddressFamilyOpened)== TRUE)
{
MiniportClearFlag (pMiniport, fMP_AddressFamilyOpened);
}
else
{
ASSERT (pMiniport->af.AfHandle == NULL);
}
UNLOCKOBJ (pMiniport, pSR);
//
// Close the Af if there was one.
//
if (pMiniport->af.AfHandle != NULL)
{
pTask->Hdr.State = Stage_CloseAfComplete;
//
// Prepare to so an Async Close Af
//
RmSuspendTask (pTask, 0, pSR);
//
// Close Address Family
//
Status = epvcClCloseAddressFamily(pMiniport->af.AfHandle);
if (Status != NDIS_STATUS_PENDING)
{
EpvcCoCloseAfComplete(Status,pMiniport );
Status = NDIS_STATUS_PENDING;
}
break;
}
}
//
// We've finished task;
//
//
// Fall through
//
}
case Stage_CloseAfComplete:
{
pTask->Hdr.State = Stage_TaskCompleted;
Status = NDIS_STATUS_SUCCESS;
}
case Stage_End:
{
Status = NDIS_STATUS_SUCCESS;
break;
}
default:
{
ASSERTEX(!"Unknown task op", pTask);
}
}
if (pTask->Hdr.State == Stage_TaskCompleted)
{
pTask->Hdr.State = Stage_End;
LOCKOBJ(pMiniport, pSR);
pMiniport->af.pAfTask = NULL;
UNLOCKOBJ(pMiniport, pSR);
ASSERT (Status == NDIS_STATUS_SUCCESS);
}
RM_ASSERT_NOLOCKS(pSR);
EXIT()
TRACE ( TL_T, TM_Pt, ("<==epvcTaskStartIMiniport Status %x", Status) );
return Status;
}
NDIS_STATUS
epvcTaskCloseIMiniport(
IN struct _RM_TASK * pTask,
IN RM_TASK_OPERATION Code,
IN UINT_PTR UserParam,
IN PRM_STACK_RECORD pSR
)
/*++
Routine Description:
This is the task that Closes the miniport, the Device Instance and
the Address Family/
There are three reason that the task could be called.
1) Miniport Halt -MiniportInstance functions need not be called
2) Protocol Unbind- MiniportInstance functions HAVE to be called
3) CloseAddress Family - Miniport function are already called
Arguments:
UserParam for (Code == RM_TASKOP_START) : UnbindContext
--*/
{
ENTER ("epvcTaskCloseIMiniport", 0x83342651)
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
PEPVC_I_MINIPORT pMiniport = (PEPVC_I_MINIPORT ) RM_PARENT_OBJECT(pTask);
PTASK_AF pAfTask = (PTASK_AF) pTask;
BOOLEAN fNeedToHalt = FALSE;
BOOLEAN fNeedToCancel = FALSE;
ULONG State;
BOOLEAN fAddressFamilyOpened = FALSE;
BOOLEAN fIsDevInstanceInitialized = FALSE;
BOOLEAN fIsMiniportHalting = FALSE;
enum
{
Stage_Start =0, // default
Stage_CloseAddressFamilyCompleted,
Stage_TaskCompleted,
Stage_End
}; // To be used in pTask->Hdr.State to indicate the state of the Task
TRACE ( TL_T, TM_Pt, ("==> epvcTaskCloseIMiniport State %x", pTask->Hdr.State) );
State = pTask->Hdr.State;
switch(pTask->Hdr.State)
{
case Stage_Start:
{
//
// Check to see if the miniport has already opened an address family.
// If so exit
//
LOCKOBJ (pMiniport, pSR );
if (epvcIsThisTaskPrimary ( pTask, &(PRM_TASK)(pMiniport->af.pAfTask)) == FALSE)
{
PRM_TASK pOtherTask = (PRM_TASK)(pMiniport->af.pAfTask);
RmTmpReferenceObject (&pOtherTask->Hdr, pSR);
//
// Set The state so we restart this code after main task completes
//
pTask->Hdr.State = Stage_Start;
UNLOCKOBJ(pMiniport, pSR);
RmPendTaskOnOtherTask (pTask, 0, pOtherTask, pSR);
RmTmpDereferenceObject(&pOtherTask->Hdr,pSR);
Status = NDIS_STATUS_PENDING;
break;
}
//
// We are the primary task
//
ASSERT (pMiniport->af.pAfTask == pAfTask);
//
// Check to see if our work is already done
//
if (MiniportTestFlag (pMiniport, fMP_AddressFamilyOpened) == FALSE)
{
//
// quietly exit as the address family is already closed
//
UNLOCKOBJ(pMiniport, pSR);
State = Stage_TaskCompleted; // we're finished.
Status = NDIS_STATUS_FAILURE; // Exit
break;
}
fIsDevInstanceInitialized = MiniportTestFlag (pMiniport, fMP_DevInstanceInitialized);
fIsMiniportHalting = (pAfTask->Cause == TaskCause_MiniportHalt );
//
// Now do we need to halt the miniport. -
// Q1. Are we are in the middle of a Halt
// Q2. Has Our Miniport Instance been initialized -
// Has miniportInitialize been called - then DeInit the miniport
// If not then - cancel the Device Instance
//
if ((TRUE == fIsDevInstanceInitialized ) &&
( FALSE ==fIsMiniportHalting) )
{
if (MiniportTestFlag (pMiniport, fMP_MiniportInitialized) == TRUE)
{
//
// Our Halt Handler has not been called,
//
fNeedToHalt = TRUE;
}
else
{
//
// Our miniport's initalized handler has not been called
//
//
// We are not in the middle of a halt, so this probably
// an unbind .
//
fNeedToCancel = TRUE;
}
//
// Clear the Device Instance flag.
//
MiniportClearFlag (pMiniport, fMP_DevInstanceInitialized);
}
//
// Mark the address family as closed ,because this task will close it.
//
fAddressFamilyOpened = MiniportTestFlag (pMiniport, fMP_AddressFamilyOpened);
MiniportClearFlag (pMiniport, fMP_AddressFamilyOpened);
UNLOCKOBJ(pMiniport,pSR);
//
// Call Ndis to Deinitialize the miniport, The miniport is already Refed
//
TRACE ( TL_T, TM_Pt, ("epvcTaskCloseIMiniport ----") );
if (TRUE == fNeedToHalt )
{
epvcIMDeInitializeDeviceInstance(pMiniport);
}
if (TRUE== fNeedToCancel)
{
ASSERT (!" Need To cancel in Task close Miniport");
epvcCancelDeviceInstance(pMiniport, pSR);
}
//
// Now close the address family asynchronously.
// First suspend this task
//
pTask->Hdr.State = Stage_CloseAddressFamilyCompleted;
RmSuspendTask (pTask, 0 , pSR);
if (fAddressFamilyOpened == TRUE)
{
//
// We need to start a task to complete the Close Call And DeleteVC
//
Status = epvcClCloseAddressFamily(pMiniport->af.AfHandle);
if (Status != NDIS_STATUS_PENDING)
{
EpvcCoCloseAfComplete(Status, pMiniport);
Status = NDIS_STATUS_PENDING;
}
}
else
{
State = Stage_TaskCompleted; // we're finished.
Status = NDIS_STATUS_SUCCESS; // Exit
}
//
// End this thread. If this thread is closing the addres family
// then we exit. If not, then we do the cleanup below
//
break;
}
case Stage_CloseAddressFamilyCompleted:
{
Status = pAfTask->ReturnStatus;
State = Stage_TaskCompleted ;
break;
}
case Stage_End:
{
Status = NDIS_STATUS_SUCCESS;
break;
}
default:
{
ASSERTEX(!"Unknown task op", pTask);
}
}
if (Stage_TaskCompleted == State )
{
pTask->Hdr.State = Stage_End;
Status = NDIS_STATUS_SUCCESS;
//
// Clear the task here
//
LOCKOBJ (pMiniport, pSR);
pMiniport->af.pAfTask = NULL;
UNLOCKOBJ (pMiniport, pSR);
//
// Set the complete event here
//
if (pAfTask->Cause == TaskCause_ProtocolUnbind)
{
epvcSetEvent (&pAfTask->CompleteEvent);
}
if (pAfTask->Cause == TaskCause_AfCloseRequest)
{
//
// Nothing to do
//
}
}
RM_ASSERT_NOLOCKS(pSR);
TRACE ( TL_T, TM_Pt, ("<== epvcTaskCloseIMiniport Status %x", Status) );
EXIT();
return Status;
}
VOID
epvcInstantiateMiniport(
IN PEPVC_ADAPTER pAdapter,
NDIS_HANDLE MIniportConfigHandle,
PRM_STACK_RECORD pSR
)
/*++
Routine Description:
This routine goes to the registry and reads the device name for the IM miniport.
It then allocates a structure for it.
If the allocation fails, it quietly returns as there is no more work to be done.
(Maybe we should deregister the protocol)
Arguments:
Return Value:
None.
--*/
{
NDIS_STATUS NdisStatus = NDIS_STATUS_FAILURE;
PEPVC_I_MINIPORT pMiniport = NULL;
NDIS_STRING UpperBindings;
PNDIS_CONFIGURATION_PARAMETER pParameterValue = NULL;
EPVC_I_MINIPORT_PARAMS Params;
TRACE (TL_T, TM_Mp, ("==> epvcInstantiateMiniport pAdapter %p KeyName %p \n", pAdapter));
do
{
//
// Now read the upper bindings
//
NdisInitUnicodeString(&UpperBindings, c_szUpperBindings);
NdisReadConfiguration(
&NdisStatus,
&pParameterValue,
MIniportConfigHandle,
&UpperBindings,
NdisParameterString);
if (NDIS_STATUS_SUCCESS != NdisStatus)
{
TRACE (TL_T, TM_Mp, (" epvcInstantiateMiniport NdisReadConfiguration Failed"));
break;
}
TRACE (TL_I, TM_Pt, ("Creating Miniport Adapter %x, KeyName: len %d, max %d, name: [%ws]\n",
pAdapter,
pParameterValue->ParameterData.StringData.Length,
pParameterValue->ParameterData.StringData.MaximumLength,
(unsigned char*)pParameterValue->ParameterData.StringData.Buffer));
//
// Check and see if we already have a miniport
//
RmLookupObjectInGroup( &pAdapter->MiniportsGroup,
0 , // no flags (not locked)
&pParameterValue->ParameterData.StringData,
NULL,
&(PRM_OBJECT_HEADER)pMiniport,
NULL,
pSR
);
if (pMiniport!= NULL)
{
//
// we already have a miniport, therefore exit.
//
break;
}
//
// Create and Initialize the miniport here
//
Params.pDeviceName = &pParameterValue->ParameterData.StringData;
Params.pAdapter = pAdapter;
Params.CurLookAhead = pAdapter->info.MaxAAL5PacketSize;
Params.NumberOfMiniports = (NdisInterlockedIncrement (&pAdapter->info.NumberOfMiniports) - 1);
Params.LinkSpeed = pAdapter->info.LinkSpeed;
Params.MacAddress = pAdapter->info.MacAddress;
Params.MediaState = pAdapter->info.MediaState;
NdisStatus = RM_CREATE_AND_LOCK_OBJECT_IN_GROUP(
&pAdapter->MiniportsGroup,
Params.pDeviceName, // Key
&Params, // Init params
&((PRM_OBJECT_HEADER)pMiniport),
NULL, // pfCreated
pSR
);
if (FAIL(NdisStatus))
{
TR_WARN(("FATAL: Couldn't create adapter object\n"));
pMiniport = NULL;
break;
}
UNLOCKOBJ(pMiniport,pSR);
//
// Initalize new miniport specific events here
//
epvcInitializeEvent (&pMiniport->pnp.HaltCompleteEvent);
epvcInitializeEvent (&pMiniport->pnp.DeInitEvent);
} while (FALSE);
if (FAIL(NdisStatus ) == TRUE)
{
//
// Do nothing
//
ASSERT (FAIL(NdisStatus ) == FALSE);
}
else
{
RmTmpDereferenceObject(&pMiniport->Hdr, pSR);
}
TRACE (TL_T, TM_Mp, ("<== epvcInstantiateMiniport pMiniport %p \n", pMiniport));
}
//--------------------------------------------------------------------------------
// //
// Adapter RM Object - Create, Delete, Hash and Compare functions //
// //
// //
//--------------------------------------------------------------------------------
PRM_OBJECT_HEADER
epvcAdapterCreate(
PRM_OBJECT_HEADER pParentObject,
PVOID pCreateParams,
PRM_STACK_RECORD psr
)
/*++
Routine Description:
Allocate and initialize an object of type EPVC_ADAPTER.
Arguments:
pParentObject - Object that is to be the parent of the adapter.
pCreateParams - Actually a pointer to a EPVC_ADAPTER_PARAMS structure,
which contains information required to create the adapter.
Return Value:
Pointer to the allocated and initialized object on success.
NULL otherwise.
--*/
{
PEPVC_ADAPTER pA;
PEPVC_ADAPTER_PARAMS pBindParams = (PEPVC_ADAPTER_PARAMS)pCreateParams;
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
extern RM_STATIC_OBJECT_INFO EpvcGlobals_AdapterStaticInfo;
extern RM_STATIC_OBJECT_INFO EpvcGlobals_I_MiniportStaticInfo ;
ENTER("AdapterCreate", 0x9cb433f4);
TRACE (TL_V, TM_Pt, ("--> epvcAdapterCreate") );
EPVC_ALLOCSTRUCT(pA, TAG_PROTOCOL);
do
{
if (pA == NULL)
{
break;
}
EPVC_ZEROSTRUCT(pA);
//
// Do all the initialization work here
//
pA->Hdr.Sig = TAG_ADAPTER;
RmInitializeLock(
&pA->Lock,
LOCKLEVEL_ADAPTER
);
RmInitializeHeader(
pParentObject,
&pA->Hdr,
TAG_ADAPTER,
&pA->Lock,
&EpvcGlobals_AdapterStaticInfo,
NULL,
psr
);
//
// Now initialize the adapter structure with the parameters
// that were passed in.
//
// Create up-cased version of the DeviceName and save it.
//
//
Status = epvcCopyUnicodeString(
&(pA->bind.DeviceName),
pBindParams->pDeviceName,
TRUE // Upcase
);
if (FAIL(Status))
{
pA->bind.DeviceName.Buffer=NULL; // so we don't try to free it later
break;
}
pA->bind.pEpvcConfigName = pBindParams->pEpvcConfigName;
Status = epvcCopyUnicodeString(
&(pA->bind.EpvcConfigName),
pBindParams->pEpvcConfigName,
FALSE
);
pA->bind.BindContext = pBindParams->BindContext;
//
// Initialize and allocate a group for all the intermediate miniports that
// will be instantiated over this physical adapter
//
RmInitializeGroup(
&pA->Hdr, // pOwningObject
&EpvcGlobals_I_MiniportStaticInfo ,
&(pA->MiniportsGroup),
"Intermediate miniports", // szDescription
psr
);
Status = NDIS_STATUS_SUCCESS;
}
while(FALSE);
if (FAIL(Status))
{
if (pA != NULL)
{
epvcAdapterDelete ((PRM_OBJECT_HEADER) pA, psr);
pA = NULL;
}
}
TRACE (TL_V, TM_Pt, ("<-- epvcAdapterCreate pAdpater. %p",pA) );
return (PRM_OBJECT_HEADER) pA;
}
VOID
epvcAdapterDelete (
PRM_OBJECT_HEADER pObj,
PRM_STACK_RECORD pSR
)
/*++
Routine Description:
Free an object of type EPVC_ADAPTER.
Arguments:
pHdr - Actually a pointer to the EPVC_ADAPTER to be deleted.
--*/
{
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER) pObj;
TRACE (TL_V, TM_Pt, ("-- epvcAdapterDelete pAdapter %p",pAdapter) );
pAdapter->Hdr.Sig = TAG_FREED;
EPVC_FREE (pAdapter);
}
BOOLEAN
epvcAdapterCompareKey(
PVOID pKey,
PRM_HASH_LINK pItem
)
/*++
Routine Description:
Hash comparison function for EPVC_ADAPTER.
Arguments:
pKey - Points to a Epvc Protocol object.
pItem - Points to EPVC_ADAPTER.Hdr.HashLink.
Return Value:
TRUE IFF the key (adapter name) exactly matches the key of the specified
adapter object.
--*/
{
PEPVC_ADAPTER pA = NULL;
PNDIS_STRING pName = (PNDIS_STRING) pKey;
BOOLEAN fCompare;
pA = CONTAINING_RECORD(pItem, EPVC_ADAPTER, Hdr.HashLink);
//
// TODO: maybe case-insensitive compare?
//
if ( (pA->bind.DeviceName.Length == pName->Length)
&& NdisEqualMemory(pA->bind.DeviceName.Buffer, pName->Buffer, pName->Length))
{
return TRUE;
}
else
{
return FALSE;
}
TRACE (TL_V, TM_Pt, ("-- epvcProtocolCompareKey pAdapter %p, pKey, return %x",pA, pKey, fCompare ) );
return fCompare;
}
ULONG
epvcAdapterHash(
PVOID pKey
)
/*++
Routine Description:
Hash function responsible for returning a hash of pKey, which
we expect to be a pointer to an Epvc Protocol block.
Return Value:
ULONG-sized hash of the string.
--*/
{
PNDIS_STRING pName = (PNDIS_STRING) pKey;
WCHAR *pwch = pName->Buffer;
WCHAR *pwchEnd = pName->Buffer + pName->Length/sizeof(*pwch);
ULONG Hash = 0;
for (;pwch < pwchEnd; pwch++)
{
Hash ^= (Hash<<1) ^ *pwch;
}
return Hash;
}
//--------------------------------------------------------------------------------
// //
// Bind Adapter - Entry Points and Tasks //
// //
// //
//--------------------------------------------------------------------------------
VOID
EpvcBindAdapter(
OUT PNDIS_STATUS pStatus,
IN NDIS_HANDLE BindContext,
IN PNDIS_STRING pDeviceName,
IN PVOID SystemSpecific1,
IN PVOID SystemSpecific2
)
/*++
Routine Description:
This is called by NDIS when it has an adapter for which there is a
binding to the Epvc Protocol.
We first allocate an Adapter structure. Then we open our configuration
section for this adapter and save the handle in the Adapter structure.
Finally, we open the adapter.
We then read the registry and find out how many intermediate Miniports are
sitting on top of this adapter. Data structures are initialized for these Miniports
We don't do anything more for this adapter until NDIS notifies us of
the presence of a Call manager (via our AfRegisterNotify handler).
Arguments:
pStatus - Place to return status of this call
BindContext - Not used, because we don't pend this call
pDeviceName - The name of the adapter we are requested to bind to
SystemSpecific1 - Opaque to us; to be used to access configuration info
SystemSpecific2 - Opaque to us; not used.
Return Value:
Always TRUE. We set *pStatus to an error code if something goes wrong before
we
call NdisOpenAdapter, otherwise NDIS_STATUS_PENDING.
--*/
{
NDIS_STATUS Status;
EPVC_ADAPTER *pAdapter;
#if DBG
KIRQL EntryIrql = KeGetCurrentIrql();
#endif // DBG
ENTER("BindAdapter", 0xa830f919)
RM_DECLARE_STACK_RECORD(SR)
TIMESTAMP("==>BindAdapter");
do
{
PRM_TASK pTask;
EPVC_ADAPTER_PARAMS BindParams;
// Setup initialization parameters
//
BindParams.pDeviceName = pDeviceName;
BindParams.pEpvcConfigName = (PNDIS_STRING) SystemSpecific1;
BindParams.BindContext = BindContext;
// Allocate and initialize adapter object.
// This also sets up ref counts for all linkages, plus one
// tempref for us, which we must deref when done.
//
Status = RM_CREATE_AND_LOCK_OBJECT_IN_GROUP(
&EpvcGlobals.adapters.Group,
pDeviceName, // Key
&BindParams, // Init params
&((PRM_OBJECT_HEADER)pAdapter),
NULL, // pfCreated
&SR
);
if (FAIL(Status))
{
TR_WARN(("FATAL: Couldn't create adapter object\n"));
pAdapter = NULL;
break;
}
// Allocate task to complete the initialization.
// The task is tmp ref'd for us, and we must deref it when we're done here.
// We implicitly do this by calling RmStartTask below.
//
Status = epvcAllocateTask(
&pAdapter->Hdr, // pParentObject,
epvcTaskInitializeAdapter, // pfnHandler,
0, // Timeout,
"Task: Initialize Adapter", // szDescription
&pTask,
&SR
);
if (FAIL(Status))
{
pTask = NULL;
break;
}
UNLOCKOBJ(pAdapter, &SR);
// Start the task to complete this initialization.
// NO locks must be held at this time.
// RmStartTask expect's a tempref on the task, which it deref's when done.
// RmStartTask will free the task automatically, whether it completes
// synchronously or asynchronously.
//
RmStartTask(pTask, 0, &SR);
TRACE (TL_V, TM_Pt, ("Task InitializeAdapter - Start Task returned %x", Status));
LOCKOBJ(pAdapter, &SR);
} while(FALSE);
if (pAdapter)
{
UNLOCKOBJ(pAdapter, &SR);
if (!PEND(Status) && FAIL(Status))
{
// At this point the adapter should be a "zombie object."
//
ASSERTEX(RM_IS_ZOMBIE(pAdapter), pAdapter);
}
RmTmpDereferenceObject(&pAdapter->Hdr, &SR);
*pStatus = NDIS_STATUS_PENDING;
}
else
{
//
// Fail the bind as the adapter was not allocated
//
*pStatus = NDIS_STATUS_FAILURE;
}
#if DBG
{
KIRQL ExitIrql = KeGetCurrentIrql();
TR_INFO(("Exiting. EntryIrql=%lu, ExitIrql = %lu\n", EntryIrql, ExitIrql));
}
#endif //DBG
RM_ASSERT_CLEAR(&SR);
EXIT()
TIMESTAMP("<==BindAdapter");
TRACE (TL_T, TM_Pt, ("<==BindAdapter %x", *pStatus));
RM_ASSERT_CLEAR(&SR);
return ;
}
NDIS_STATUS
epvcTaskInitializeAdapter(
IN struct _RM_TASK * pTask,
IN RM_TASK_OPERATION Code,
IN UINT_PTR UserParam,
IN PRM_STACK_RECORD pSR
)
/*++
Routine Description:
Task handler responsible for initializing an adapter.
Arguments:
UserParam for (Code == RM_TASKOP_START) : unused
--*/
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER) RM_PARENT_OBJECT(pTask);
PTASK_ADAPTERINIT pAdapterInitTask;
enum
{
STAGE_BecomePrimaryTask,
STAGE_ActivateAdapterComplete,
STAGE_DeactivateAdapterComplete,
STAGE_End
} Stage;
ENTER("TaskInitializeAdapter", 0x18f9277a)
pAdapterInitTask = (PTASK_ADAPTERINIT) pTask;
TRACE (TL_T, TM_Pt, ("==>epvcTaskInitializeAdapter Code %x \n", Code));
//
// Message normalizing code
//
switch(Code)
{
case RM_TASKOP_START:
Stage = STAGE_BecomePrimaryTask;
break;
case RM_TASKOP_PENDCOMPLETE:
Status = (NDIS_STATUS) UserParam;
ASSERT(!PEND(Status));
Stage = RM_PEND_CODE(pTask);
break;
case RM_TASKOP_END:
Status = (NDIS_STATUS) UserParam;
Stage= STAGE_End;
break;
default:
ASSERT(FALSE);
return NDIS_STATUS_FAILURE; // ** EARLY RETURN **
}
ASSERTEX(!PEND(Status), pTask);
switch(Stage)
{
case STAGE_BecomePrimaryTask:
{
// If there is a primary task, pend on it, else make ourselves
// the primary task.
//
LOCKOBJ(pAdapter, pSR);
if (pAdapter->bind.pPrimaryTask == NULL)
{
epvcSetPrimaryAdapterTask(pAdapter, pTask, EPVC_AD_PS_INITING, pSR);
UNLOCKOBJ(pAdapter, pSR);
}
else
{
PRM_TASK pOtherTask = pAdapter->bind.pPrimaryTask;
RmTmpReferenceObject(&pOtherTask->Hdr, pSR);
UNLOCKOBJ(pAdapter, pSR);
RmPendTaskOnOtherTask(
pTask,
STAGE_BecomePrimaryTask, // we'll try again...
pOtherTask,
pSR
);
RmTmpDereferenceObject(&pOtherTask->Hdr, pSR);
Status = NDIS_STATUS_PENDING;
break;
}
//
// We're now the primary task. Since we're starting out,
// there should be NO activate/deactivate task.
// (Note: we don't bother getting the adapter lock for these asserts).
//
ASSERT(pAdapter->bind.pPrimaryTask == pTask);
ASSERT(pAdapter->bind.pSecondaryTask == NULL);
//
// Allocate and start the activate adapter task.
//
{
PRM_TASK pActivateTask;
Status = epvcAllocateTask(
&pAdapter->Hdr, // pParentObject,
epvcTaskActivateAdapter, // pfnHandler,
0, // Timeout,
"Task: Activate Adapter(init)", // szDescription
&pActivateTask,
pSR
);
if (FAIL(Status))
{
pActivateTask = NULL;
TR_WARN(("FATAL: couldn't alloc activate task!\n"));
}
else
{
RmPendTaskOnOtherTask(
pTask,
STAGE_ActivateAdapterComplete,
pActivateTask, // task to pend on
pSR
);
// RmStartTask uses up the tmpref on the task
// which was added by arpAllocateTask.
//
Status = RmStartTask(
pActivateTask,
0, // UserParam (unused)
pSR
);
}
}
}
if (PEND(Status)) break;
// FALL THROUGH TO NEXT STAGE
case STAGE_ActivateAdapterComplete:
{
//
// We've run the active-adapter task. On failure, we need to
// cleanup state by calling the deactivate-adapter task.
//
// Save away the failure code for later...
//
pAdapterInitTask->ReturnStatus = Status;
if (FAIL(Status))
{
PRM_TASK pDeactivateTask;
Status = epvcAllocateTask(
&pAdapter->Hdr, // pParentObject,
epvcTaskDeactivateAdapter, // pfnHandler,
0, // Timeout,
"Task: Deactivate Adapter(init)", // szDescription
&pDeactivateTask,
pSR
);
if (FAIL(Status))
{
pDeactivateTask = NULL;
ASSERT(FALSE); // TODO: use special dealloc task pool for this.
TR_WARN(("FATAL: couldn't alloc deactivate task!\n"));
}
else
{
RmPendTaskOnOtherTask(
pTask,
STAGE_DeactivateAdapterComplete,
pDeactivateTask, // task to pend on
pSR
);
//
// RmStartTask uses up the tmpref on the task
// which was added by arpAllocateTask.
//
Status = RmStartTask(
pDeactivateTask,
0, // UserParam (unused)
pSR
);
}
}
}
break;
case STAGE_DeactivateAdapterComplete:
{
//
// We've completed the deactivate adapter task which we started
// because of some init-adapter failure.
//
// In general, we don't expect the deactivate task to return failure.
//
ASSERT(!FAIL(Status));
// We expect the original status of the init to be a failure (that's
// why we started the deinit in the first place!
//
ASSERT(FAIL(pAdapterInitTask->ReturnStatus));
Status = pAdapterInitTask->ReturnStatus;
}
break;
case STAGE_End:
{
NDIS_HANDLE BindContext;
//
// We HAVE to be the primary task at this point, becase we simply
// wait and retry until we become one.
//
// Clear the primary task in the adapter object.
//
LOCKOBJ(pAdapter, pSR);
{
ULONG InitState;
InitState = FAIL(Status) ? EPVC_AD_PS_FAILEDINIT : EPVC_AD_PS_INITED;
epvcClearPrimaryAdapterTask(pAdapter, pTask, InitState, pSR);
}
BindContext = pAdapter->bind.BindContext;
UNLOCKOBJ(pAdapter, pSR);
// On failure, pAdapter should be deallocated.
//
if (FAIL(Status))
{
if(RM_IS_ZOMBIE(pAdapter))
{
TR_WARN(("END: pAdapter is already deallocated.\n"));
}
else
{
//
// On failure, free the adapter here itself, because we're
// not going to call the shutdown task.
//
RmFreeObjectInGroup(
&EpvcGlobals.adapters.Group,
&(pAdapter->Hdr),
NULL, // NULL pTask == synchronous.
pSR
);
pAdapter = NULL;
}
}
//
// Clear out the variables that are valid only
// during the BindAdapter Call
//
if (pAdapter != NULL)
{
pAdapter->bind.pEpvcConfigName = NULL;
}
// Signal Ndis that the bind is complete.
//
NdisCompleteBindAdapter(BindContext ,
Status,
NDIS_STATUS_PENDING);
TIMESTAMP("== Completing the Adapter Bind");
RM_ASSERT_NOLOCKS(pSR);
}
break;
default:
{
ASSERTEX(!"Unknown task op", pTask);
}
break;
} // switch (Code)
RM_ASSERT_NOLOCKS(pSR);
EXIT()
TRACE (TL_T, TM_Pt, ("<==epvcTaskInitializeAdapter Status %x\n", Status));
return Status;
}
NDIS_STATUS
epvcTaskActivateAdapter(
IN struct _RM_TASK * pTask,
IN RM_TASK_OPERATION Code,
IN UINT_PTR UserParam,
IN PRM_STACK_RECORD pSR
)
/*++
Routine Description:
Task handler responsible for initializing an adapter.
Arguments:
UserParam for (Code == RM_TASKOP_START) : unused
--*/
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER) RM_PARENT_OBJECT(pTask);
enum
{
PEND_OpenAdapter,
PEND_GetAdapterInfo
};
ENTER("TaskInitializeAdapter", 0xb6ada31d)
TRACE (TL_T, TM_Pt, ("==>epvcTaskActivateAdapter pAdapter %p Code %x",pAdapter, Code ));
switch(Code)
{
case RM_TASKOP_START:
{
NDIS_MEDIUM Medium = NdisMediumAtm;
UINT SelMediumIndex = 0;
NDIS_STATUS OpenStatus;
TRACE (TL_T, TM_Pt, (" epvcTaskActivateAdapter RM_TASKOP_START "));
// Set ourselves as the secondary task.
//
LOCKOBJ(pAdapter, pSR);
epvcSetSecondaryAdapterTask(pAdapter, pTask, EPVC_AD_AS_ACTIVATING, pSR);
UNLOCKOBJ(pAdapter, pSR);
//
// Suspend task and call NdisOpenAdapter...
//
RmSuspendTask(pTask, PEND_OpenAdapter, pSR);
RM_ASSERT_NOLOCKS(pSR);
epvcOpenAdapter(
&Status,
&OpenStatus,
&pAdapter->bind.BindingHandle,
&SelMediumIndex, // selected medium index
&Medium, // Array of medium types
1, // Size of Media list
EpvcGlobals.driver.ProtocolHandle,
(NDIS_HANDLE)pAdapter, // our adapter bind context
&pAdapter->bind.DeviceName, // pDeviceName
0, // Open options
(PSTRING)NULL, // Addressing Info...
pSR);
if (Status != NDIS_STATUS_PENDING)
{
EpvcOpenAdapterComplete(
(NDIS_HANDLE)pAdapter,
Status,
OpenStatus
);
}
Status = NDIS_STATUS_PENDING;
}
break;
case RM_TASKOP_PENDCOMPLETE:
{
PTASK_ADAPTERACTIVATE pAdapterInitTask;
pAdapterInitTask = (PTASK_ADAPTERACTIVATE) pTask;
Status = (NDIS_STATUS) UserParam;
ASSERT(!PEND(Status));
ASSERT(sizeof(TASK_ADAPTERACTIVATE) <= sizeof(EPVC_TASK));
switch(RM_PEND_CODE(pTask))
{
case PEND_OpenAdapter:
//
// The open adapter operation is complete. Get adapter
// information and notify IP on success. On failure,
// shutdown the adapter if required, and notify IP of
// the failure.
//
TRACE (TL_T, TM_Pt, (" epvcTaskActivateAdapter RM_TASKOP_PENDCOMPLETE - PEND_OpenAdapter "));
if (FAIL(Status))
{
// Set adapter handle to null -- it may not be hull.
// even though the open adapter has succeeded.
//
pAdapter->bind.BindingHandle = NULL;
break;
}
ASSERT (pAdapter->bind.BindingHandle != NULL);
// FALL THROUGH on synchronous completion of arpGetAdapterInfo...
case PEND_GetAdapterInfo:
//
// Done with getting adapter info.
// We need to switch to passive before going further
//
TRACE (TL_T, TM_Pt, (" epvcTaskActivateAdapter RM_TASKOP_PENDCOMPLETE - PEND_GetAdapterInfo "));
ASSERT (KeGetCurrentIrql() == PASSIVE_LEVEL);
if (!EPVC_ATPASSIVE())
{
ASSERT (!"Should not be here");
// We're not at passive level, but we need to be when we
// call IP's add interface. So we switch to passive...
// NOTE: we specify completion code PEND_GetAdapterInfo
// because we want to get back here (except
// we'll be at passive).
//
/*RmSuspendTask(pTask, PEND_GetAdapterInfo, pSR);
RmResumeTaskAsync(
pTask,
Status,
&pAdapterInitTask->WorkItem,
pSR
);
Status = NDIS_STATUS_PENDING;*/
break;
}
if (Status == NDIS_STATUS_SUCCESS)
{
//
// Copy over adapter info into pAdapter->info...
// Then read configuration information.
//
//
// Query the ATM adapter for HW specific Info
//
epvcGetAdapterInfo(pAdapter, pSR, NULL);
// Read Adapter Configuration Information
//
Status = epvcReadAdapterConfiguration(pAdapter, pSR);
Status = NDIS_STATUS_SUCCESS;
}
//
// NOTE: if we fail, a higher level task is responsible
// for "running the compensating transaction", i.e., running
// epvcTaskDeactivateAdapter.
//
// end case PEND_OpenAdapter, PEND_GetAdapterInfo
break;
default:
{
ASSERTEX(!"Unknown pend op", pTask);
}
break;
} // end switch(RM_PEND_CODE(pTask))
} // case RM_TASKOP_PENDCOMPLETE
break;
case RM_TASKOP_END:
{
TRACE (TL_T, TM_Pt, (" epvcTaskActivateAdapter RM_TASKOP_END"));
Status = (NDIS_STATUS) UserParam;
// We're done -- the status had better not be pending!
//
ASSERTEX(!PEND(Status), pTask);
// Clear ourselves as the secondary task in the adapter object.
//
{
ULONG InitState;
LOCKOBJ(pAdapter, pSR);
InitState = FAIL(Status)
? EPVC_AD_AS_FAILEDACTIVATE
: EPVC_AD_AS_ACTIVATED;
epvcClearSecondaryAdapterTask(pAdapter, pTask, InitState, pSR);
UNLOCKOBJ(pAdapter, pSR);
}
Status = NDIS_STATUS_SUCCESS;
}
break;
default:
{
ASSERTEX(!"Unknown task op", pTask);
}
break;
} // switch (Code)
RM_ASSERT_NOLOCKS(pSR);
EXIT()
TRACE (TL_T, TM_Pt, ("<==epvcTaskActivateAdapter Status %x", Status ));
return Status;
}
VOID
EpvcOpenAdapterComplete(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status,
IN NDIS_STATUS OpenErrorStatus
)
/*++
Routine Description:
This is called by NDIS when a previous call to NdisOpenAdapter
that had pended has completed. We now complete the BindAdapter
that lead to this.
Arguments:
ProtocolBindingContext - Our context for this adapter binding, which
is a pointer to an EPVC_ADAPTER structure.
Status - Status of OpenAdapter
OpenErrorStatus - Error code in case of failure.
--*/
{
ENTER("OpenAdapterComplete", 0x06d9342c)
EPVC_ADAPTER * pAdapter = (EPVC_ADAPTER*) ProtocolBindingContext;
RM_DECLARE_STACK_RECORD(SR)
TIMESTAMP("==>OpenAdapterComplete");
TRACE ( TL_T, TM_Mp, ("==>OpenAdapterComplete"));
// We expect a nonzero task here (the bind task), which we unpend.
// No need to grab locks or anything at this stage.
//
{
TR_INFO((
"BindCtxt=0x%p, status=0x%p, OpenErrStatus=0x%p",
ProtocolBindingContext,
Status,
OpenErrorStatus
));
// We don't pass on OpenErrorStatus, so we have just the status
// to pass on, which we do directly as the UINT_PTR "Param".
//
RmResumeTask(pAdapter->bind.pSecondaryTask, (UINT_PTR) Status, &SR);
}
RM_ASSERT_CLEAR(&SR)
EXIT()
TRACE ( TL_T, TM_Mp, ("<==OpenAdapterComplete"));
TIMESTAMP("<==OpenAdapterComplete");
RM_ASSERT_CLEAR(&SR);
}
NDIS_STATUS
epvcTaskDeactivateAdapter(
IN struct _RM_TASK * pTask,
IN RM_TASK_OPERATION Code,
IN UINT_PTR UserParam,
IN PRM_STACK_RECORD pSR
)
/*++
Routine Description:
Task handler responsible for shutting down an IP interface.
Arguments:
UserParam for (Code == RM_TASKOP_START) : UnbindContext
--*/
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
EPVC_ADAPTER * pAdapter = (EPVC_ADAPTER*) RM_PARENT_OBJECT(pTask);
BOOLEAN fContinueShutdown = FALSE;
enum
{
PEND_CloseAdapter
};
ENTER("TaskShutdownAdapter", 0xe262e828)
TRACE ( TL_T, TM_Pt, ("==>epvcTaskDeactivateAdapter Code %x", Code) );
switch(Code)
{
case RM_TASKOP_START:
{
NDIS_HANDLE NdisAdapterHandle;
LOCKOBJ(pAdapter, pSR);
epvcSetSecondaryAdapterTask(pAdapter, pTask, EPVC_AD_AS_DEACTIVATING, pSR);
UNLOCKOBJ(pAdapter, pSR);
fContinueShutdown = TRUE;
//
// Iterate through all the miniports and stop them
//
epvcEnumerateObjectsInGroup (&pAdapter->MiniportsGroup,
epvcMiniportDoUnbind,
NULL,
pSR );
//
// Close the adapter below
//
LOCKOBJ(pAdapter, pSR);
NdisAdapterHandle = pAdapter->bind.BindingHandle;
pAdapter->bind.BindingHandle = NULL;
UNLOCKOBJ(pAdapter, pSR);
if (NdisAdapterHandle != NULL)
{
//
// Suspend task and call NdisCloseAdapter...
//
RmSuspendTask(pTask, PEND_CloseAdapter, pSR);
RM_ASSERT_NOLOCKS(pSR);
epvcCloseAdapter(
&Status,
NdisAdapterHandle,
pSR
);
if (Status != NDIS_STATUS_PENDING)
{
EpvcCloseAdapterComplete(
(NDIS_HANDLE)pAdapter,
Status
);
}
Status = NDIS_STATUS_PENDING;
}
break;
}
case RM_TASKOP_PENDCOMPLETE:
{
switch(RM_PEND_CODE(pTask))
{
case PEND_CloseAdapter:
{
//
// The close adapter operation is complete. Free the the
// adapter and if there is an unbind context, notify NDIS
// of unbind completion.
//
ASSERTEX(pAdapter->bind.BindingHandle == NULL, pAdapter);
Status = (NDIS_STATUS) UserParam;
// Status of the completed operation can't itself be pending!
//
ASSERT(Status != NDIS_STATUS_PENDING);
}
break;
}
}
break;
case RM_TASKOP_END:
{
Status = (NDIS_STATUS) UserParam;
// Clear the secondary task in the adapter object.
//
LOCKOBJ(pAdapter, pSR);
epvcClearSecondaryAdapterTask(pAdapter, pTask, EPVC_AD_AS_DEACTIVATED, pSR);
UNLOCKOBJ(pAdapter, pSR);
}
break;
default:
{
ASSERTEX(!"Unknown task op", pTask);
}
break;
} // switch (Code)
RM_ASSERT_NOLOCKS(pSR);
EXIT()
TRACE ( TL_T, TM_Pt, ("<==epvcTaskDeactivateAdapter Status %x", Status) );
return Status;
}
VOID
EpvcCloseAdapterComplete(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status
)
/*++
Routine Description:
This is called by NDIS when a previous call to NdisCloseAdapter
that had pended has completed. The task that called NdisCloseAdapter
would have suspended itself, so we simply resume it now.
Arguments:
ProtocolBindingContext - Our context for this adapter binding, which
is a pointer to an EPVC_ADAPTER structure.
Status - Status of CloseAdapter
Return Value:
None
--*/
{
ENTER("CloseAdapterComplete", 0xe23bfba7)
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER) ProtocolBindingContext;
RM_DECLARE_STACK_RECORD(sr)
TIMESTAMP("==>CloseAdapterComplete");
TRACE (TL_T, TM_Pt, ("== EpvcCloseAdapterComplete"));
LOCKOBJ (pAdapter, &sr);
AdapterSetFlag (pAdapter,EPVC_AD_INFO_AD_CLOSED);
UNLOCKOBJ (pAdapter, &sr);
// We expect a nonzero task here (UNbind task), which we unpend.
// No need to grab locks or anything at this stage.
//
RmResumeTask(pAdapter->bind.pSecondaryTask, (UINT_PTR) Status, &sr);
TIMESTAMP("<==CloseAdapterComplete");
RM_ASSERT_CLEAR(&sr)
EXIT()
}
NDIS_STATUS
epvcReadAdapterConfiguration(
PEPVC_ADAPTER pAdapter,
PRM_STACK_RECORD pSR
)
/*++
Routine Description:
This function can only be called from the BindAdapter function
Arguments:
pAdapter - Underlying adapter whose configuration is being read/
pSR - Stack Record
Return Value:
None
++*/
{
NDIS_HANDLE AdaptersConfigHandle = NULL;
NDIS_HANDLE MiniportListConfigHandle = NULL;
NDIS_STRING MiniportListKeyName;
NDIS_STATUS NdisStatus = NDIS_STATUS_FAILURE;
ENTER("ReadAdapterConfiguration", 0x83c48ad8)
TRACE(TL_T, TM_Pt, ("==> epvcReadAdapterConfigurationpAdapter %p", pAdapter));
do
{
//
// Start off by opening the config section and reading our instance which we want
// to export for this binding
//
epvcOpenProtocolConfiguration(&NdisStatus,
&AdaptersConfigHandle ,
&pAdapter->bind.EpvcConfigName,
pSR);
if (NDIS_STATUS_SUCCESS != NdisStatus )
{
AdaptersConfigHandle = NULL;
TRACE_BREAK(TM_Pt, ("epvcOpenProtocolConfiguration failed " ) );
}
//
// this should get us to the protocol\paramters\adapters\guid section in the registry
//
//
// Open the Elan List configuration key.
//
NdisInitUnicodeString(&MiniportListKeyName, c_szIMMiniportList);
epvcOpenConfigurationKeyByName(
&NdisStatus,
AdaptersConfigHandle ,
&MiniportListKeyName,
&MiniportListConfigHandle,
pSR);
if (NDIS_STATUS_SUCCESS != NdisStatus)
{
MiniportListConfigHandle = NULL;
NdisStatus = NDIS_STATUS_FAILURE;
TRACE_BREAK(TM_Pt, ("NdisOpenConfigurationKeyByName failed " ) );
}
//
// Allocate and initialize all IM miniport instances that are present
// in the registry under this adapter
//
(VOID)epvcReadIntermediateMiniportConfiguration( pAdapter,
MiniportListConfigHandle,
pSR);
} while (FALSE);
if (MiniportListConfigHandle!= NULL)
{
NdisCloseConfiguration(MiniportListConfigHandle);
MiniportListConfigHandle = NULL;
}
if (AdaptersConfigHandle != NULL)
{
NdisCloseConfiguration(AdaptersConfigHandle );
AdaptersConfigHandle = NULL;
}
if (STATUS_NO_MORE_ENTRIES == NdisStatus )
{
NdisStatus = NDIS_STATUS_SUCCESS;
}
TRACE(TL_T, TM_Pt, ("<== epvcReadAdapterConfiguration Status %x", NdisStatus));
EXIT()
return NdisStatus;
}
NDIS_STATUS
epvcReadIntermediateMiniportConfiguration(
IN PEPVC_ADAPTER pAdapter,
IN NDIS_HANDLE MiniportListConfigHandle,
IN PRM_STACK_RECORD pSR
)
{
NDIS_STATUS NdisStatus = NDIS_STATUS_FAILURE;
ENTER ("ReadMiniportConfiguration", 0xb974a6fa)
TRACE(TL_T, TM_Pt, ("==> epvcReadIntermediateMiniportConfiguration pAdapter %p", pAdapter));
{
NDIS_HANDLE MiniportConfigHandle;
NDIS_STRING MiniportKeyName;
PEPVC_I_MINIPORT pMiniport = NULL;
UINT Index = 0;
//
// Iterate thru the configured Miniport
//
for (Index = 0;
; // Stop only on error or no more Elans
Index++)
{
EPVC_I_MINIPORT_PARAMS Params;
//
// Open the "next" Miniport key
//
epvcOpenConfigurationKeyByIndex(
&NdisStatus,
MiniportListConfigHandle,
Index,
&MiniportKeyName,
&MiniportConfigHandle,
pSR
);
if (NDIS_STATUS_SUCCESS != NdisStatus)
{
MiniportConfigHandle = NULL;
}
//
// If NULL handle, assume no more Miniports.
//
if (MiniportConfigHandle == NULL)
{
break;
}
//
// Creating this Miniport
//
epvcInstantiateMiniport (pAdapter,
MiniportConfigHandle,
pSR);
NdisCloseConfiguration(MiniportConfigHandle);
MiniportConfigHandle = NULL;
}
//
// Close config handles
//
if (NULL != MiniportConfigHandle)
{
NdisCloseConfiguration(MiniportConfigHandle);
MiniportConfigHandle = NULL;
}
}
if (STATUS_NO_MORE_ENTRIES == NdisStatus )
{
NdisStatus = NDIS_STATUS_SUCCESS;
}
TRACE(TL_T, TM_Pt, ("<== epvcReadIntermediateMiniportConfiguration NdisStatus %x", NdisStatus));
EXIT()
return NdisStatus;
}
VOID
EpvcUnbindAdapter(
OUT PNDIS_STATUS pStatus,
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE UnbindContext
)
/*++
Routine Description:
This routine is called by NDIS when it wants us to unbind
from an adapter. Or, this may be called from within our Unload
handler. We undo the sequence of operations we performed
in our BindAdapter handler.
Arguments:
pStatus - Place to return status of this operation
ProtocolBindingContext - Our context for this adapter binding, which
is a pointer to an ATMEPVC Adapter structure.
UnbindContext - This is NULL if this routine is called from
within our Unload handler. Otherwise (i.e.
NDIS called us), we retain this for later use
when calling NdisCompleteUnbindAdapter.
Return Value:
None. We set *pStatus to NDIS_STATUS_PENDING always.
--*/
{
ENTER("UnbindAdapter", 0x3f25396e)
EPVC_ADAPTER * pAdapter = (EPVC_ADAPTER*) ProtocolBindingContext;
RM_DECLARE_STACK_RECORD(sr)
TIMESTAMP("==>UnbindAdapter");
TRACE ( TL_T, TM_Pt, ("==>UnbindAdapter ProtocolBindingContext %x\n", ProtocolBindingContext) );
//
// Get adapter lock and tmpref it.
//
LOCKOBJ(pAdapter, &sr);
RmTmpReferenceObject(&pAdapter->Hdr, &sr);
do
{
NDIS_STATUS Status;
PRM_TASK pTask;
// Allocate task to complete the unbind.
//
Status = epvcAllocateTask(
&pAdapter->Hdr, // pParentObject,
epvcTaskShutdownAdapter, // pfnHandler,
0, // Timeout,
"Task: Shutdown Adapter", // szDescription
&pTask,
&sr
);
if (FAIL(Status))
{
// Ugly situation. We'll just leave things as they are...
//
pTask = NULL;
TR_WARN(("FATAL: couldn't allocate unbind task!\n"));
break;
}
// Start the task to complete the unbind.
// No locks must be held. RmStartTask uses up the tmpref on the task
// which was added by arpAllocateTask.
//
UNLOCKOBJ(pAdapter, &sr);
((PTASK_ADAPTERSHUTDOWN) pTask)->pUnbindContext = UnbindContext;
RmStartTask(pTask, (UINT_PTR) UnbindContext, &sr);
LOCKOBJ(pAdapter, &sr);
} while(FALSE);
UNLOCKOBJ(pAdapter, &sr);
RmTmpDereferenceObject(&pAdapter->Hdr, &sr);
*pStatus = NDIS_STATUS_PENDING;
RM_ASSERT_CLEAR(&sr);
TIMESTAMP("<==UnbindAdapter");
EXIT()
}
NDIS_STATUS
epvcTaskShutdownAdapter(
IN struct _RM_TASK * pTask,
IN RM_TASK_OPERATION Code,
IN UINT_PTR UserParam,
IN PRM_STACK_RECORD pSR
)
/*++
Routine Description:
Task handler responsible for shutting down an ATMEPVC adapter.
Arguments:
UserParam for (Code == RM_TASKOP_START) : UnbindContext
--*/
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
EPVC_ADAPTER * pAdapter = (EPVC_ADAPTER*) RM_PARENT_OBJECT(pTask);
TASK_ADAPTERSHUTDOWN *pMyTask = (TASK_ADAPTERSHUTDOWN*) pTask;
enum
{
STAGE_BecomePrimaryTask,
STAGE_DeactivateAdapterComplete,
STAGE_End
} Stage;
ENTER("TaskShutdownAdapter", 0x3f25396e)
TRACE (TL_T, TM_Pt, ("==>epvcTaskShutdownAdapter Code %x", Code));
//
// Message normalizing code
//
switch(Code)
{
case RM_TASKOP_START:
Stage = STAGE_BecomePrimaryTask;
// Save away the UnbindContext (which we get as UserParam) in
// the task's private context, for use later.
//
pMyTask->pUnbindContext = (NDIS_HANDLE) UserParam;
break;
case RM_TASKOP_PENDCOMPLETE:
Status = (NDIS_STATUS) UserParam;
ASSERT(!PEND(Status));
Stage = RM_PEND_CODE(pTask);
break;
case RM_TASKOP_END:
Status = (NDIS_STATUS) UserParam;
Stage= STAGE_End;
break;
default:
ASSERT(FALSE);
return NDIS_STATUS_FAILURE; // ** EARLY RETURN **
}
ASSERTEX(!PEND(Status), pTask);
switch(Stage)
{
case STAGE_BecomePrimaryTask:
{
// If there is a primary task, pend on it, else make ourselves
// the primary task.
// We could get in this situation if someone does a
// "net stop arp1394" while we're in the middle of initializing or
// shutting down the adapter.
//
//
TRACE (TL_V, TM_Pt, (" epvcTaskShutdownAdapter STAGE_BecomePrimaryTask" ));
LOCKOBJ(pAdapter, pSR);
if (pAdapter->bind.pPrimaryTask == NULL)
{
epvcSetPrimaryAdapterTask(pAdapter, pTask, EPVC_AD_PS_DEINITING, pSR);
UNLOCKOBJ(pAdapter, pSR);
}
else
{
PRM_TASK pOtherTask = pAdapter->bind.pPrimaryTask;
RmTmpReferenceObject(&pOtherTask->Hdr, pSR);
UNLOCKOBJ(pAdapter, pSR);
RmPendTaskOnOtherTask(
pTask,
STAGE_BecomePrimaryTask, // we'll try again...
pOtherTask,
pSR
);
RmTmpDereferenceObject(&pOtherTask->Hdr, pSR);
Status = NDIS_STATUS_PENDING;
break;
}
//
// We're now the primary task. Since we're starting out,
// there should be NO activate/deactivate task.
// (Note: we don't bother getting the adapter lock for these asserts).
//
ASSERT(pAdapter->bind.pPrimaryTask == pTask);
ASSERT(pAdapter->bind.pSecondaryTask == NULL);
//
// Allocate and start the deactivate adapter task.
//
{
PRM_TASK pDeactivateTask;
Status = epvcAllocateTask(
&pAdapter->Hdr, // pParentObject,
epvcTaskDeactivateAdapter, // pfnHandler,
0, // Timeout,
"Task: Deactivate Adapter(shutdown)", // szDescription
&pDeactivateTask,
pSR
);
if (FAIL(Status))
{
pDeactivateTask = NULL;
TR_WARN(("FATAL: couldn't alloc deactivate task!\n"));
}
else
{
RmPendTaskOnOtherTask(
pTask,
STAGE_DeactivateAdapterComplete,
pDeactivateTask, // task to pend on
pSR
);
// RmStartTask uses up the tmpref on the task
// which was added by arpAllocateTask.
//
Status = RmStartTask(
pDeactivateTask,
0, // UserParam (unused)
pSR
);
}
}
}
break;
case STAGE_DeactivateAdapterComplete:
{
TRACE (TL_V, TM_Pt,( " epvcTaskShutdownAdapter STAGE_DeactivateAdapterComplete" ));
// Nothing to do here -- we clean up in STAGE_End.
//
break;
}
case STAGE_End:
{
TRACE (TL_V, TM_Pt, (" epvcTaskShutdownAdapter STAGE_End" ));
//
// We HAVE to be the primary task at this point, becase we simply
// wait and retry until we become one.
//
ASSERT(pAdapter->bind.pPrimaryTask == pTask);
// Clear the primary task in the adapter object.
//
LOCKOBJ(pAdapter, pSR);
epvcClearPrimaryAdapterTask(pAdapter, pTask, EPVC_AD_PS_DEINITED, pSR);
UNLOCKOBJ(pAdapter, pSR);
if(RM_IS_ZOMBIE(pAdapter))
{
TR_WARN(("END: pAdapter is already deallocated.\n"));
}
else
{
// Free the adapter.
// (pAdapter will be allocated, but it will be in a "zombie" state).
//
RmDeinitializeGroup(&(pAdapter->MiniportsGroup), pSR);
RmFreeObjectInGroup(
&EpvcGlobals.adapters.Group,
&(pAdapter->Hdr),
NULL, // NULL pTask == synchronous.
pSR
);
}
// If there is an unbind-context, signal NDIS that the unbind is
// complete.
//
if (pMyTask->pUnbindContext)
{
TR_WARN(("END: Calling NdisCompleteUnbindAdapter. Status= 0x%lx\n",
Status));
RM_ASSERT_NOLOCKS(pSR);
TIMESTAMP("===Calling NdisCompleteUnbindAdapter");
NdisCompleteUnbindAdapter(
pMyTask->pUnbindContext,
Status
);
}
}
break;
default:
{
ASSERTEX(!"Unknown task op", pTask);
}
break;
} // switch (Code)
RM_ASSERT_NOLOCKS(pSR);
EXIT()
return Status;
}
VOID
epvcGetAdapterInfo(
IN PEPVC_ADAPTER pAdapter,
IN PRM_STACK_RECORD pSR,
IN PRM_TASK pTask // OPTIONAL
)
/*++
Routine Description:
Query an adapter for hardware-specific information that we need:
- burnt in hardware address (ESI part)
- Max packet size
- line rate
Arguments:
pAdapter - Pointer to EPVC adapter structure
Return Value:
None
--*/
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
EPVC_NDIS_REQUEST Request;
NDIS_MEDIA_STATE MediaState= NdisMediaStateDisconnected;
do
{
//
// Initialize.
//
NdisZeroMemory(&pAdapter->info.MacAddress, sizeof(MAC_ADDRESS));
pAdapter->info.MediaState = MediaState;
pAdapter->info.MaxAAL5PacketSize = ATMEPVC_DEF_MAX_AAL5_PDU_SIZE;
pAdapter->info.LinkSpeed.Outbound = pAdapter->info.LinkSpeed.Inbound = ATM_USER_DATA_RATE_SONET_155;
//
// MAC Address:
//
Status = epvcPrepareAndSendNdisRequest (pAdapter,
&Request,
NULL, // OPTIONAL
OID_ATM_HW_CURRENT_ADDRESS,
(PVOID)(&pAdapter->info.MacAddress),
sizeof (pAdapter->info.MacAddress),
NdisRequestQueryInformation,
NULL, // No miniport
FALSE, // No request was pended
FALSE, // Pended Request info
pSR);
ASSERT (PEND(Status) == FALSE);
if (FAIL(Status)== TRUE)
{
//
// Don't break .continue on
//
TRACE (TL_I, TM_Pt, ("Oid - Atm Hw Address failed %x", Status));
}
Status = epvcPrepareAndSendNdisRequest(
pAdapter,
&Request,
NULL, // OPTIONAL
OID_ATM_MAX_AAL5_PACKET_SIZE,
(PVOID)(&pAdapter->info.MaxAAL5PacketSize),
sizeof(pAdapter->info.MaxAAL5PacketSize),
NdisRequestQueryInformation,
NULL, // No miniport
FALSE, // No request was pended
FALSE, // Pended Request info
pSR);
if (FAIL(Status)== TRUE)
{
TRACE (TL_I, TM_Pt, ("Oid - Atm Max AAL5 Packet Size failed %x", Status));
}
if (pAdapter->info.MaxAAL5PacketSize > ATMEPVC_DEF_MAX_AAL5_PDU_SIZE)
{
pAdapter->info.MaxAAL5PacketSize = ATMEPVC_DEF_MAX_AAL5_PDU_SIZE;
}
//
// Link speed:
//
Status = epvcPrepareAndSendNdisRequest(
pAdapter,
&Request,
NULL, // OPTIONAL
OID_GEN_CO_LINK_SPEED,
&pAdapter->info.LinkSpeed,
sizeof(pAdapter->info.LinkSpeed),
NdisRequestQueryInformation,
NULL, // No miniport
FALSE, // No request was pended
FALSE, // Pended Request info
pSR);
TRACE (TL_V, TM_Mp, ("Outbound %x Inbound %x",
pAdapter->info.LinkSpeed.Outbound,
pAdapter->info.LinkSpeed.Inbound));
if ((NDIS_STATUS_SUCCESS != Status) ||
(0 == pAdapter->info.LinkSpeed.Inbound) ||
(0 == pAdapter->info.LinkSpeed.Outbound))
{
TRACE (TL_I, TM_Pt, ( "GetAdapterInfo: OID_GEN_CO_LINK_SPEED failed\n"));
//
// Default and assume data rate for 155.52Mbps SONET
//
pAdapter->info.LinkSpeed.Outbound = pAdapter->info.LinkSpeed.Inbound = ATM_USER_DATA_RATE_SONET_155;
}
//
// Link speed:
//
Status = epvcPrepareAndSendNdisRequest(
pAdapter,
&Request,
NULL, // OPTIONAL
OID_GEN_MEDIA_CONNECT_STATUS,
&MediaState,
sizeof(MediaState),
NdisRequestQueryInformation,
NULL, // No miniport
FALSE, // No request was pended
FALSE, // Pended Request info
pSR);
TRACE (TL_V, TM_Mp, ("MediaConnectivity %x ",MediaState));
if (NDIS_STATUS_SUCCESS != Status )
{
TRACE (TL_I, TM_Pt, ( "GetAdapterInfo: OID_GEN_CO_LINK_SPEED failed\n"));
//
// Default and assume data rate for 155.52Mbps SONET
//
MediaState = NdisMediaStateDisconnected;
}
pAdapter->info.MediaState = MediaState ;
TRACE( TL_V, TM_Pt,("GetAdapterInfo: Outbound Linkspeed %d", pAdapter->info.LinkSpeed.Outbound));
TRACE( TL_V, TM_Pt,("GetAdapterInfo: Inbound Linkspeed %d\n", pAdapter->info.LinkSpeed.Inbound));
}while (FALSE);
return;
}
NDIS_STATUS
EpvcPtPNPHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNET_PNP_EVENT pNetPnPEvent
)
/*++
Routine Description:
This is the Protocol PNP handlers.
All PNP Related OIDS(requests) are routed to this function
Arguments:
ProtocolBindingContext Pointer to our adapter structure.
pNetPnPEvent Pointer to a Net_PnP_Event
Return Value:
NDIS_STATUS_SUCCESS: as we do not do much here
--*/
{
ENTER("EpvcPtPnPHandler", 0xacded1ce)
PEPVC_ADAPTER pAdapter =(PEPVC_ADAPTER)ProtocolBindingContext;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
RM_DECLARE_STACK_RECORD (SR);
TRACE (TL_T, TM_Pt, ("==> EpvcPtPNPHandler Adapter %p, pNetPnpEvent %x", pAdapter, pNetPnPEvent));
//
// This will happen when all entities in the system need to be notified
//
switch(pNetPnPEvent->NetEvent)
{
case NetEventReconfigure :
Status = epvcPtNetEventReconfigure(pAdapter, pNetPnPEvent->Buffer, &SR);
break;
default :
Status = NDIS_STATUS_SUCCESS;
break;
}
TRACE (TL_T, TM_Pt, ("<== EpvcPtPNPHandler Status %x", Status));
RM_ASSERT_NOLOCKS(&SR)
EXIT();
return Status;
}
NDIS_STATUS
epvcPtNetEventReconfigure(
IN PEPVC_ADAPTER pAdapter,
IN PVOID pBuffer,
IN PRM_STACK_RECORD pSR
)
/*++
Routine Description:
This is the function that will be called by the PNP handler
whenever a PNPNetEventReconfigure happens
THis will happen if a new physical adapter has come in or the user
has re-enabled a virtual miniport.
To process:
Iterate through all the adapter. If adapters are bound, then make sure that
all of its miniport's are initialized.
If not, then leave it and call NdisReenumerate to connect all our protocol
instances with valid adapters
Arguments:
ProtocolBindingContext Pointer to our adapter structure.
Return Value:
NDIS_STATUS_SUCCESS: as we do not do much here
--*/
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
TRACE (TL_T, TM_Pt, ("==> epvcPtNetEventReconfigure Adapter %p, pBuffer %x", pAdapter, pBuffer));
do
{
//
// The notify object sets the REconfig buffer.
//
if (pBuffer != NULL)
{
ASSERT (!"PnPBuffer != NULL - not implemented yet");
break;
}
if (pAdapter == NULL)
{
//
// Iterate through all the adapters and initialize
// uninitialized miniports
//
epvcEnumerateObjectsInGroup ( &EpvcGlobals.adapters.Group,
epvcReconfigureAdapter,
pBuffer,
pSR);
//
// Re-enumerate the protocol bindings, this will cause us to get
// a BindAdapter on all our unbound adapters, and then we
// will InitDeviceInstance.
// This is called when the protcol is not bound to the physical adapter
//
NdisReEnumerateProtocolBindings(EpvcGlobals.driver.ProtocolHandle);
break;
}
} while (FALSE);
Status = NDIS_STATUS_SUCCESS;
TRACE (TL_T, TM_Pt, ("<== epvcPtNetEventReconfigure " ));
return Status;
}
INT
epvcReconfigureAdapter(
PRM_OBJECT_HEADER pHdr,
PVOID pvContext,
PRM_STACK_RECORD pSR
)
/*++
Routine Description:
When the Protocol's Reconfigure handler is called, this adapter will be in one
of two condtions - Its binding to the adapter below is open or the binding is
closed.
if the blinding is closed, then the protocol will call NdisReEnumerate Bindings
and this will restart the Binding and re-instantiate the miniports.
Arguments:
ProtocolBindingContext Pointer to our adapter structure.
Return Value:
TRUE: so that iteration continues
--*/
{
ENTER("epvcReconfigureAdapter", 0x2906a037)
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER )pHdr;
do
{
if (CHECK_AD_PRIMARY_STATE(pAdapter, EPVC_AD_PS_INITED)== FALSE)
{
//
// no more work to be done on this adapter,
//
break;
}
//
// TODO: Go through the registry and initialize
// all the IM miniports present
//
epvcReadAdapterConfiguration(pAdapter, pSR);
//
// Now go through all the miniports on this group and
// initialize them
//
epvcEnumerateObjectsInGroup ( &pAdapter->MiniportsGroup,
epvcReconfigureMiniport,
NULL,
pSR);
} while (FALSE);
EXIT()
return TRUE;
}
INT
epvcReconfigureMiniport (
PRM_OBJECT_HEADER pHdr,
PVOID pvContext,
PRM_STACK_RECORD pSR
)
/*++
Routine Description:
This should check to see if the InitDev instance has been
called on this miniport. IF not, then queue the task to
do it.
Arguments:
ProtocolBindingContext Pointer to our adapter structure.
Return Value:
TRUE: so that iteration continues
--*/
{
ENTER( "epvcReconfigureMiniport" ,0xdd9ecb01)
PEPVC_I_MINIPORT pMiniport = (PEPVC_I_MINIPORT)pHdr;
PTASK_AF pTask = NULL;
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER)pMiniport->Hdr.pParentObject;
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
LOCKOBJ(pMiniport, pSR);
//
// If the device instance is not initialized (i.e it has been halted)
// then this thread reinitializes the device instance
//
do
{
//
// If the device is already Initialized then exit.
//
if (MiniportTestFlag (pMiniport, fMP_DevInstanceInitialized ) == TRUE)
{
break;
}
//
// Allocate task to Initialize the Device Instance.
//
Status = epvcAllocateTask(
&pMiniport->Hdr, // pParentObject,
epvcTaskStartIMiniport, // pfnHandler,
0, // Timeout,
"Task: Open address Family", // szDescription
&((PRM_TASK)pTask),
pSR
);
if (FAIL(Status))
{
// Ugly situation. We'll just leave things as they are...
//
pTask = NULL;
TR_WARN(("FATAL: couldn't allocate unbind task!\n"));
break;
}
// Start the task to complete the Open Address Family.
// No locks must be held. RmStartTask uses up the tmpref on the task
// which was added by epvcAllocateTask.
//
UNLOCKOBJ(pMiniport, pSR);
pTask->pAf= &pAdapter->af.AddressFamily ;
pTask->Cause = TaskCause_ProtocolBind;
RmStartTask((PRM_TASK)pTask, 0, pSR);
LOCKOBJ(pMiniport, pSR);
} while(FALSE);
UNLOCKOBJ(pMiniport, pSR);
EXIT()
return TRUE;
}
VOID
epvcExtractSendCompleteInfo (
OUT PEPVC_SEND_COMPLETE pStruct,
PEPVC_I_MINIPORT pMiniport,
PNDIS_PACKET pPacket
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
NDIS_HANDLE PoolHandle = NULL;
pStruct->pPacket = pPacket;
PoolHandle = NdisGetPoolFromPacket(pPacket);
if (PoolHandle != pMiniport->PktPool.Send.Handle)
{
//
// We had passed down a packet belonging to the protocol above us.
//
pStruct->fUsedPktStack = TRUE;
}
else
{
pStruct->fUsedPktStack = FALSE;
}
epvcSendCompleteStats();
}
VOID
EpvcPtSendComplete(
IN NDIS_STATUS Status,
IN NDIS_HANDLE ProtocolVcContext,
IN PNDIS_PACKET Packet
)
/*++
Routine Description:
The Vc Context is the miniport block, Use it to complete the send
Arguments:
Return Value:
--*/
{
ENTER("EpvcPtSendComplete", 0x76beac72)
PEPVC_I_MINIPORT pMiniport =(PEPVC_I_MINIPORT)ProtocolVcContext;
EPVC_SEND_COMPLETE Struct;
RM_DECLARE_STACK_RECORD (SR);
TRACE (TL_T, TM_Send, ("EpvcPtSendComplete"));
EPVC_ZEROSTRUCT (&Struct);
#define OUR_EXTERNAL_ENTITY ((UINT_PTR) Packet)
#define szEPVCASSOC_EXTLINK_DEST_TO_PKT_FORMAT " send pkt 0x%p\n"
do
{
epvcExtractSendCompleteInfo (&Struct, pMiniport, Packet);
//
// If we are using the Packetstacking, then this packet is the
// original packet
//
if (Struct.fUsedPktStack == TRUE)
{
BOOLEAN Remaining = FALSE;
Struct.pOrigPkt = Packet;
Struct.pStack = NdisIMGetCurrentPacketStack(Packet, &Remaining);
Struct.pContext = (PEPVC_STACK_CONTEXT)(&Struct.pStack->IMReserved[0]) ;
}
else
{
Struct.pPktContext =(PEPVC_PKT_CONTEXT)(Packet->ProtocolReserved);
Struct.pContext = &Struct.pPktContext->Stack;
Struct.pOrigPkt = Struct.pPktContext->pOriginalPacket;
NdisIMCopySendCompletePerPacketInfo (Struct.pOrigPkt , Packet);
}
LOCKOBJ (pMiniport, &SR);
epvcDerefSendPkt(Packet, &pMiniport->Hdr);
UNLOCKOBJ (pMiniport, &SR);
//
// Make sure the original packet is in the same state
// when it was sent to the miniport
//
Struct.pPacket = Packet;
//
// Remove the ethernet padding - if necessary
//
epvcRemoveEthernetPad (pMiniport, Packet);
//
// Remove the ethernet padding buffer - if necessary
//
epvcRemoveEthernetTail (pMiniport, Packet, Struct.pPktContext);
//
// Remove the LLC Snap headers - if necessary
//
epvcRemoveExtraNdisBuffers (pMiniport, &Struct);
if (Struct.fUsedPktStack == FALSE)
{
epvcDprFreePacket(Packet,
&pMiniport->PktPool.Send);
}
if (Status == NDIS_STATUS_SUCCESS)
{
pMiniport->count.FramesXmitOk ++;
}
} while (FALSE);
//
// Complete the send
//
epvcMSendComplete(pMiniport,
Struct.pOrigPkt,
Status);
EXIT();
RM_ASSERT_CLEAR(&SR);
return;
}
VOID
epvcRemoveExtraNdisBuffers (
IN PEPVC_I_MINIPORT pMiniport,
IN PEPVC_SEND_COMPLETE pStruct
)
/*++
Routine Description:
In the case of IP encapsulation, there will be an extra ndis buffer
that has been made the head of the Ndispacket. Remove it and
reattach the old one.
Arguments:
Return Value:
--*/
{
PNDIS_BUFFER pOldHead = NULL;
UINT OldHeadLength = 0;
do
{
//
// if an LLC header was used, remove it and free the MDL
// use the packet that was completed
//
if (pMiniport->fAddLLCHeader== TRUE)
{
PNDIS_PACKET_PRIVATE pPrivate = &pStruct->pPacket->Private;
PNDIS_BUFFER pHead = pPrivate->Head;
//
// Move the head of the packet past the LLC Header
//
pPrivate->Head = pHead->Next;
//
// Free the Head MDL
//
epvcFreeBuffer(pHead);
}
//
// if we are not doing IP encapsulation, then we are done.
//
if (pMiniport->fDoIpEncapsulation== FALSE)
{
break;
}
//
// if the Ethernet header was stripped off, then put it back
//
pOldHead = pStruct->pContext->ipv4Send.pOldHeadNdisBuffer;
ASSERT (pOldHead != NULL);
OldHeadLength = NdisBufferLength(pOldHead);
//
// two ways this can happen
// 1) if the ethernet header was in a seperate MDL
// then simply take the old Head and make it the Head again
//
if (OldHeadLength == sizeof (EPVC_ETH_HEADER))
{
PNDIS_PACKET_PRIVATE pPrivate = &pStruct->pPacket->Private;
PNDIS_BUFFER pHead = pPrivate->Head;
ASSERT (pOldHead->Next == pPrivate->Head);
pOldHead->Next = pPrivate->Head;
pPrivate->Head = pOldHead ;
break; // we are done
}
//
// 2nd Way 2) A new MDL had been allocated which just points to the
// IP part of the header.
// For this - free the Head in Packet, Take the old Head and put it back
// in the packet as the New Head
//
if (OldHeadLength > sizeof (EPVC_ETH_HEADER))
{
PNDIS_PACKET_PRIVATE pPrivate = &pStruct->pPacket->Private;
ASSERT (pOldHead->Next == pPrivate->Head->Next);
if (pPrivate->Head == pPrivate->Tail)
{
pPrivate->Tail = pOldHead;
pOldHead->Next = NULL;
}
else
{
pOldHead->Next = pPrivate->Head->Next;
}
epvcFreeBuffer(pPrivate->Head );
pPrivate->Head = pOldHead;
break; // we are done
}
} while (FALSE);
}
VOID
EpvcPtReceiveComplete(
IN NDIS_HANDLE ProtocolBindingContext
)
/*++
Routine Description:
Called by the adapter below us when it is done indicating a batch of
received packets.
Arguments:
ProtocolBindingContext Pointer to our adapter structure.
Return Value:
None
--*/
{
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER)ProtocolBindingContext;
return;
}
INT
epvcMiniportDoUnbind(
PRM_OBJECT_HEADER pHdr,
PVOID pvContext,
PRM_STACK_RECORD pSR
)
{
/*++
Routine Description:
This is called from the Protocl Unbind code path
This should halt the current miniport and close the address
family. This is all done in the CloseMiniportTask, so we
will simply start the task and wait for it to complete
Arguments:
Return Value:
TRUE - as we want to iterate to the very end
--*/
ENTER ("epvcMiniportDoUnbind", 0x26dc5d35)
PRM_TASK pRmTask = NULL;
PTASK_AF pAfTask = NULL;
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
PEPVC_I_MINIPORT pMiniport = (PEPVC_I_MINIPORT)pHdr;
PEPVC_ADAPTER pAdapter = (PEPVC_ADAPTER) pMiniport->Hdr.pParentObject;
BOOLEAN fHaltNotCompleted = FALSE;
TRACE (TL_T, TM_Mp, ("==>epvcMiniportDoUnbind pMiniport %x", pMiniport) );
do
{
if (MiniportTestFlag (pMiniport, fMP_AddressFamilyOpened) == TRUE)
{
//
// allocate a close Miniport Task
//
Status = epvcAllocateTask(
&pMiniport->Hdr, // pParentObject,
epvcTaskCloseIMiniport, // pfnHandler,
0, // Timeout,
"Task: CloseIMiniport- Unbind", // szDescription
&pRmTask,
pSR
);
if (Status != NDIS_STATUS_SUCCESS)
{
ASSERT (Status == NDIS_STATUS_SUCCESS);
pAfTask = NULL;
break;
}
pAfTask= (PTASK_AF)pRmTask ;
pAfTask->Cause = TaskCause_ProtocolUnbind;
//
// Reference the task so it is around until our Wait for completion
// is complete
//
RmTmpReferenceObject (&pAfTask->TskHdr.Hdr, pSR);
epvcInitializeEvent (&pAfTask->CompleteEvent);
RmStartTask (pRmTask, 0, pSR);
epvcWaitEvent(&pAfTask->CompleteEvent, WAIT_INFINITE);
RmTmpDereferenceObject (&pAfTask->TskHdr.Hdr, pSR);
}
LOCKOBJ (pMiniport, pSR);
//
// If the Halt has not already completed then, we should wait for it
//
if (MiniportTestFlag(pMiniport ,fMP_MiniportInitialized) == TRUE )
{
//
// prepare to wait for halt
//
epvcResetEvent (&pMiniport->pnp.HaltCompleteEvent);
//
// Set the flag to mark it as waiting for halt
//
MiniportSetFlag (pMiniport, fMP_WaitingForHalt);
fHaltNotCompleted = TRUE;
}
UNLOCKOBJ (pMiniport, pSR);
if (fHaltNotCompleted == TRUE)
{
BOOLEAN bWaitSuccessful;
bWaitSuccessful = epvcWaitEvent (&pMiniport->pnp.HaltCompleteEvent,WAIT_INFINITE);
if (bWaitSuccessful == FALSE)
{
ASSERT (bWaitSuccessful == TRUE);
}
}
//
// Free the miniport object because there should be no more tasks on it.
// this Thread will have either caused the Miniport to Halt and waited
// for its completion (above) or the miniport will already have been halted
//
TRACE ( TL_I, TM_Mp, ("epvcMiniportDoUnbind Freeing miniport %p", pMiniport) );
RmFreeObjectInGroup (&pAdapter->MiniportsGroup,&pMiniport->Hdr, NULL, pSR);
} while (FALSE);
TRACE (TL_T, TM_Mp, ("<==epvcMiniportDoUnbind pMiniport %x", pMiniport) );
EXIT();
return TRUE;
}
NDIS_STATUS
epvcProcessOidCloseAf(
PEPVC_I_MINIPORT pMiniport,
PRM_STACK_RECORD pSR
)
/*++
Routine Description:
This is called from the Af Close Request Code path
This simply starts a worktitem to close the Af, if the
Af is open
Arguments:
Return Value:
--*/
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
PTASK_AF pTaskAf = NULL;
PEPVC_WORK_ITEM pCloseAfWorkItem = NULL;
TRACE (TL_T, TM_Mp, ("==> epvcProcessOidCloseAf pMiniport %x", pMiniport) );
//
// reference the adapter as it is going to passed to a workiter.
// decremented in the workitem
//
do
{
if (MiniportTestFlag( pMiniport, fMP_AddressFamilyOpened) == FALSE)
{
Status = NDIS_STATUS_SUCCESS;
break;
}
Status = epvcAllocateMemoryWithTag (&pCloseAfWorkItem,
sizeof(*pCloseAfWorkItem) ,
TAG_WORKITEM);
if (Status != NDIS_STATUS_SUCCESS)
{
pCloseAfWorkItem= NULL;
break;
}
epvcMiniportQueueWorkItem (pCloseAfWorkItem,
pMiniport,
epvcOidCloseAfWorkItem,
Status, // Ignored
pSR
);
Status = NDIS_STATUS_SUCCESS;
} while (FALSE);
if (Status != NDIS_STATUS_SUCCESS)
{
//
// free locally allocated memory
//
if (pCloseAfWorkItem != NULL)
{
epvcFreeMemory(pCloseAfWorkItem, sizeof (*pCloseAfWorkItem), 0);
}
}
return Status;
}
VOID
epvcOidCloseAfWorkItem(
IN PRM_OBJECT_HEADER pObj,
IN NDIS_STATUS Status,
IN PRM_STACK_RECORD pSR
)
/*++
Routine Description:
This is called from the Af Close Request Code path
This simply starts a worktitem to close the Af, if the
Af is open
Arguments:
Return Value:
--*/
{
PTASK_AF pTaskAf = NULL;
PEPVC_I_MINIPORT pMiniport = (PEPVC_I_MINIPORT)pObj;
TRACE (TL_T, TM_Mp, ("==> epvcProcessOidCloseAf pMiniport %x", pMiniport) );
Status = NDIS_STATUS_FAILURE;
//
// reference the adapter as it is going to passed to a workiter.
// decremented in the workitem
//
do
{
if (MiniportTestFlag( pMiniport, fMP_AddressFamilyOpened) == FALSE)
{
Status = NDIS_STATUS_SUCCESS;
break;
}
Status = epvcAllocateTask(
&pMiniport->Hdr, // pParentObject,
epvcTaskCloseIMiniport, // pfnHandler,
0, // Timeout,
"Task: CloseIMiniport - OID CloseAf", // szDescription
&(PRM_TASK)pTaskAf,
pSR
);
if (FAIL(Status))
{
pTaskAf = NULL;
ASSERT (Status == NDIS_STATUS_SUCCESS);
break;
}
pTaskAf->Cause = TaskCause_AfCloseRequest;
pTaskAf->pRequest = NULL;
RmStartTask ((PRM_TASK)pTaskAf , 0, pSR);
} while (FALSE);
return ;
}
UINT
EpvcCoReceive(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE ProtocolVcContext,
IN PNDIS_PACKET Packet
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
ENTER ("EpvcPtCoReceive", 0x1bfc168e)
PEPVC_ADAPTER pAdapter =(PEPVC_ADAPTER)ProtocolBindingContext;
PEPVC_I_MINIPORT pMiniport = (PEPVC_I_MINIPORT)ProtocolVcContext;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
EPVC_RCV_STRUCT RcvStruct;
RM_DECLARE_STACK_RECORD (SR);
TRACE (TL_T, TM_Pt, ("==> EpvcCoReceive Pkt %x", Packet));
EPVC_ZEROSTRUCT (&RcvStruct);
TRACE (TL_T, TM_Recv, ("EpvcPtCoReceive pAd %p, pMp %p, pPkt %p", pAdapter, pMiniport, Packet));
do
{
if (MiniportTestFlag (pMiniport, fMP_MiniportInitialized) == FALSE)
{
Status = NDIS_STATUS_FAILURE;
break;
}
Status = epvcGetRecvPkt (&RcvStruct,pMiniport, Packet);
if (Status != NDIS_STATUS_SUCCESS)
{
break;
}
ASSERT (RcvStruct.pNewPacket != NULL);
Status = epvcStripHeaderFromNewPacket (&RcvStruct, pMiniport);
if (Status != NDIS_STATUS_SUCCESS)
{
break;
}
Status = epvcAddEthHeaderToNewPacket (&RcvStruct, pMiniport);
if (Status != NDIS_STATUS_SUCCESS)
{
break;
}
//
// Now indicate the packet up
//
NDIS_SET_PACKET_HEADER_SIZE(RcvStruct.pNewPacket,
sizeof (EPVC_ETH_HEADER)) ;
ASSERT (NDIS_GET_PACKET_HEADER_SIZE(RcvStruct.pNewPacket) == 14);
//
// Force protocols above to make a copy if they want to hang
// on to data in this packet. This is because we are in our
// Receive handler (not ReceivePacket) and we can't return a
// ref count from here.
//
RcvStruct.OldPacketStatus = NDIS_GET_PACKET_STATUS(Packet);
NDIS_SET_PACKET_STATUS(RcvStruct.pNewPacket,
RcvStruct.OldPacketStatus );
epvcDumpPkt (RcvStruct.pNewPacket);
epvcValidatePacket (RcvStruct.pNewPacket);
NdisMIndicateReceivePacket(pMiniport->ndis.MiniportAdapterHandle,
&RcvStruct.pNewPacket,
1);
} while (FALSE);
//
// Check if we had indicated up the packet with NDIS_STATUS_RESOURCES
// NOTE -- do not use NDIS_GET_PACKET_STATUS(MyPacket) for this since
// it might have changed! Use the value saved in the local variable.
//
if (RcvStruct.OldPacketStatus == NDIS_STATUS_RESOURCES)
{
epvcProcessReturnPacket (pMiniport, RcvStruct.pNewPacket,NULL, &SR);
Status = NDIS_STATUS_RESOURCES;
}
else if (Status != NDIS_STATUS_SUCCESS)
{
epvcProcessReturnPacket (pMiniport, RcvStruct.pNewPacket,NULL, &SR);
Status = NDIS_STATUS_RESOURCES;
pMiniport->count.RecvDropped ++;
}
RM_ASSERT_CLEAR(&SR);
TRACE (TL_T, TM_Pt, ("<== EpvcCoReceive Pkt %x", Packet))
return((Status != NDIS_STATUS_RESOURCES) ? 1 : 0);
}
NDIS_STATUS
epvcGetRecvPkt (
IN PEPVC_RCV_STRUCT pRcvStruct,
IN PEPVC_I_MINIPORT pMiniport,
IN PNDIS_PACKET Packet
)
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
TRACE (TL_T, TM_Pt, ("==>epvcGetRecvPkt "))
do
{
if (MiniportTestFlag (pMiniport, fMP_MiniportInitialized) == FALSE)
{
Status = NDIS_STATUS_FAILURE;
break;
}
epvcValidatePacket (Packet);
//
// See if the packet is large enough
//
if (epvcIsPacketLengthAcceptable (Packet, pMiniport)== FALSE)
{
Status = NDIS_STATUS_FAILURE;
break;
}
pRcvStruct->pPacket = Packet;
//
// Check if we can reuse the same packet for indicating up.
//
pRcvStruct->pStack = NdisIMGetCurrentPacketStack(Packet, &pRcvStruct->fRemaining);
if (pRcvStruct->fRemaining)
{
//
// We can reuse "Packet".
//
// NOTE: if we needed to keep per-packet information in packets
// indicated up, we can use pStack->IMReserved[].
//
pRcvStruct->pNewPacket = Packet;
pRcvStruct->fUsedPktStacks = TRUE;
pRcvStruct->pPktContext = (PEPVC_PKT_CONTEXT)pRcvStruct->pStack;
// Zero out our context
NdisZeroMemory (&pRcvStruct->pPktContext->Stack, sizeof(EPVC_STACK_CONTEXT));
NDIS_SET_PACKET_HEADER_SIZE(Packet, 14);
Status = NDIS_STATUS_SUCCESS; // We are done
break;
}
//
// Get a packet off the pool and indicate that up
//
epvcDprAllocatePacket(&Status,
&pRcvStruct->pNewPacket,
&pMiniport->PktPool.Recv);
if (Status != NDIS_STATUS_SUCCESS)
{
pRcvStruct->pNewPacket = NULL;
break;
}
{
//
// set up the new packet to look exactly like the old one
//
PNDIS_PACKET MyPacket = pRcvStruct->pNewPacket;
MyPacket->Private.Head = Packet->Private.Head;
MyPacket->Private.Tail = Packet->Private.Tail;
//
// Set the standard Ethernet header size
//
NDIS_SET_PACKET_HEADER_SIZE(MyPacket, 14);
//
// Copy packet flags.
//
NdisGetPacketFlags(MyPacket) = NdisGetPacketFlags(Packet);
//
// Set up the context pointers
//
pRcvStruct->pPktContext = (PEPVC_PKT_CONTEXT)&MyPacket->MiniportReservedEx[0];
NdisZeroMemory (pRcvStruct->pPktContext, sizeof (*pRcvStruct->pPktContext));
pRcvStruct->pPktContext->pOriginalPacket = Packet;
}
Status = NDIS_STATUS_SUCCESS; // We are done
} while (FALSE);
TRACE (TL_T, TM_Pt, ("<==epvcGetRecvPkt Old %p, New %p ",
pRcvStruct->pPacket, pRcvStruct->pNewPacket))
return Status;
}
NDIS_STATUS
epvcStripLLCHeaderFromNewPacket (
IN PEPVC_RCV_STRUCT pRcvStruct,
IN PEPVC_I_MINIPORT pMiniport
)
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
PNDIS_PACKET pPacket = NULL;
PNDIS_BUFFER pHead, pNewHead =NULL;
ULONG CurLength = 0;
PUCHAR pCurVa = NULL;
ULONG LlcHeaderLength = 0;
BOOLEAN fIsCorrectHeader ;
do
{
if (pMiniport->fAddLLCHeader == FALSE)
{
Status = NDIS_STATUS_SUCCESS;
break;
}
pPacket = pRcvStruct->pNewPacket;
pHead = pPacket->Private.Head;
LlcHeaderLength = pMiniport->LlcHeaderLength;
//
// Move the Head past the LLC Header
//
ASSERT (NdisBufferLength (pHead) > LlcHeaderLength);
//
// Adjust the length and start VA of the MDL
//
CurLength = NdisBufferLength(pHead);
pCurVa = NdisBufferVirtualAddress(pHead);
//
// Check arguments
//
if (pCurVa == NULL)
{
break;
}
if (CurLength <= LlcHeaderLength)
{
break;
}
//
// Compare and make sure that it is the right header
//
fIsCorrectHeader = NdisEqualMemory (pCurVa ,
pMiniport->pLllcHeader,
pMiniport->LlcHeaderLength) ;
// If the IsCorrectheader is still false, then there is more to do
if (fIsCorrectHeader == FALSE)
{
break;
}
if (pMiniport->fDoIpEncapsulation == TRUE)
{
//
// In the case of IPEncap + LLC Header, the function
// which adds the Mac Header will strip the LLC Header
//
Status= NDIS_STATUS_SUCCESS;
break;
}
//
// Strip the LLC Header Length
//
CurLength -= pMiniport->LlcHeaderLength;
pCurVa += pMiniport->LlcHeaderLength;
epvcAllocateBuffer(&Status ,
&pNewHead,
NULL,
pCurVa,
CurLength
);
if (Status != NDIS_STATUS_SUCCESS)
{
pNewHead = NULL;
break;
}
//
// Set up the Packet context
//
pPacket->Private.ValidCounts= FALSE;
pRcvStruct->pPktContext->Stack.EthLLC.pOldHead = pHead;
pRcvStruct->pPktContext->Stack.EthLLC.pOldTail = pPacket->Private.Tail;
//
// Set the New Ndis buffer in the Packet
//
pNewHead->Next = pHead->Next;
pPacket->Private.Head = pNewHead;
if (pPacket->Private.Tail == pHead)
{
//
// Update the Tail of the packet as well
//
pPacket->Private.Tail = pNewHead;
}
Status = NDIS_STATUS_SUCCESS;
} while (FALSE);
return Status;
}
NDIS_STATUS
epvcAddEthHeaderToNewPacket (
IN PEPVC_RCV_STRUCT pRcvStruct,
IN PEPVC_I_MINIPORT pMiniport
)
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE ;
PNDIS_BUFFER pOldHead = NULL;
PNDIS_BUFFER pNewBuffer = NULL;
PNDIS_PACKET pNewPacket = NULL;
PUCHAR pStartOfValidData = NULL;
PUCHAR pCurrOffset = NULL;
PEPVC_IP_RCV_BUFFER pIpBuffer = NULL;
extern UCHAR LLCSnapIpv4[8] ;
TRACE (TL_T, TM_Pt, ("==>epvcAddEthHeaderToNewPacket pRcvStruct %p ", pRcvStruct))
do
{
if (pMiniport->fDoIpEncapsulation == FALSE)
{
Status = NDIS_STATUS_SUCCESS;
break;
}
//
// Copy the data into a new buffer. The start of the data is adjusted
// to account for the LLC header and ethernet header
//
pNewPacket = pRcvStruct->pNewPacket;
pOldHead = pNewPacket->Private.Head;
pStartOfValidData = NdisBufferVirtualAddress (pOldHead );
if (pStartOfValidData == NULL)
{
Status = NDIS_STATUS_FAILURE;
break;
}
if (pMiniport->fAddLLCHeader == TRUE)
{
pStartOfValidData += sizeof (LLCSnapIpv4);
pRcvStruct->fLLCHeader = TRUE;
}
pRcvStruct->pStartOfValidData = pStartOfValidData ;
//
// Get a locally allocated buffer to copy the packet into
//
pIpBuffer = epvcGetLookasideBuffer (&pMiniport->rcv.LookasideList);
if (pIpBuffer == NULL)
{
Status = NDIS_STATUS_FAILURE;
break;
}
//
// Start of the data
//
pCurrOffset = pRcvStruct->pLocalMemory = (PUCHAR)(&pIpBuffer->u.Pkt.Eth);
//
// First copy the Ethernet Header into the LocalMemory
//
NdisMoveMemory (pCurrOffset ,
&pMiniport->RcvEnetHeader,
sizeof(pMiniport->RcvEnetHeader));
pCurrOffset += sizeof(pMiniport->RcvEnetHeader);
pRcvStruct->BytesCopied += sizeof(pMiniport->RcvEnetHeader);
//
// Now copy the NdisBufferChain into the Locally allocated memory
//
Status = epvcCopyNdisBufferChain (pRcvStruct,
pOldHead ,
pCurrOffset
);
//
// We have to add an Ethernet Header for this packet.
//
epvcAllocateBuffer (&Status,
&pNewBuffer,
NULL,
pRcvStruct->pLocalMemory,
pRcvStruct->BytesCopied);
if (Status != NDIS_STATUS_SUCCESS)
{
pNewBuffer = NULL;
ASSERTAndBreak(Status == NDIS_STATUS_SUCCESS);
break;
}
//
// Make the new Ndis Buffer the head
//
{
PNDIS_PACKET_PRIVATE pPrivate = &pRcvStruct->pNewPacket->Private;
//
// Save the head and tail of the old packet
//
pIpBuffer->pOldHead = pPrivate->Head ;
pIpBuffer->pOldTail = pPrivate->Tail ;
//
// Now set up the new packet
//
pNewBuffer->Next = NULL;
pPrivate->Head = pNewBuffer;
pPrivate->Tail = pNewBuffer;
pPrivate->ValidCounts= FALSE;
pRcvStruct->pPktContext->Stack.ipv4Recv.pIpBuffer = pIpBuffer;
}
Status = NDIS_STATUS_SUCCESS;
} while (FALSE);
if (Status == NDIS_STATUS_SUCCESS)
{
pRcvStruct->pNewBuffer = pNewBuffer;
pRcvStruct->pIpBuffer = pIpBuffer;
}
else
{
pRcvStruct->pNewBuffer = NULL;
pRcvStruct->pIpBuffer = NULL;
if (pIpBuffer != NULL)
{
epvcFreeToNPagedLookasideList (&pMiniport->rcv.LookasideList,
(PVOID)pIpBuffer);
}
}
TRACE (TL_T, TM_Pt, ("<==epvcAddEthHeaderToNewPacket Status %x ", Status))
return Status;
}
NDIS_STATUS
epvcCopyNdisBufferChain (
IN PEPVC_RCV_STRUCT pRcvStruct,
IN PNDIS_BUFFER pInBuffer,
IN PUCHAR pCurrOffset
)
{
//
// This function copies the data the belongs to the
// pInMdl chain to the local Buffer.
// BufferLength is used for validation purposes only
// Fragmentation and insertion of headers will take place here
//
UINT BufferLength = MAX_ETHERNET_FRAME- sizeof (EPVC_ETH_HEADER);
NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
UINT LocalBufferIndex = 0; // Used as an index to the LocalBuffer, used for validation
UINT MdlLength = 0;
PUCHAR MdlAddress = NULL;
PNDIS_BUFFER pCurrBuffer = pInBuffer;
PUCHAR pLocalBuffer = pCurrOffset;
extern UCHAR LLCSnapIpv4[8];
//
// Use the pStartOfValidData for the first MDL
//
MdlLength = NdisBufferLength(pCurrBuffer);
MdlAddress= NdisBufferVirtualAddress(pCurrBuffer);
//
// Adjust for the LLC Header if any
//
if (pRcvStruct->fLLCHeader == TRUE)
{
//
// We have an LLC encapsulation
//
MdlLength -= sizeof (LLCSnapIpv4);
ASSERT (pRcvStruct->pStartOfValidData - MdlAddress == sizeof (LLCSnapIpv4));
MdlAddress = pRcvStruct->pStartOfValidData;
}
//
// Copy the first buffer Data to local memory.
//
NdisMoveMemory((PVOID)((ULONG_PTR)pLocalBuffer),
MdlAddress,
MdlLength);
LocalBufferIndex += MdlLength;
pCurrBuffer = pCurrBuffer->Next;
//
// now walk through the ndis buffer chain
//
while (pCurrBuffer!= NULL)
{
MdlLength = NdisBufferLength(pCurrBuffer);
MdlAddress= NdisBufferVirtualAddress(pCurrBuffer);
if (MdlLength != 0)
{
if (MdlAddress == NULL)
{
NdisStatus = NDIS_STATUS_FAILURE;
break;
}
if ( LocalBufferIndex + MdlLength > BufferLength)
{
ASSERT(LocalBufferIndex + MdlLength <= BufferLength);
NdisStatus = NDIS_STATUS_BUFFER_TOO_SHORT;
break;
}
//
// Copy the Data to local memory.
//
NdisMoveMemory((PVOID)((ULONG_PTR)pLocalBuffer+LocalBufferIndex),
MdlAddress,
MdlLength);
LocalBufferIndex += MdlLength;
}
pCurrBuffer = pCurrBuffer->Next;
}
pRcvStruct->BytesCopied += LocalBufferIndex;
return NdisStatus;
}
VOID
epvcValidatePacket (
IN PNDIS_PACKET pPacket
)
/*++
Routine Description:
Takes a packet and makes sure that the MDL chain is valid
Arguments:
Return Value:
--*/
{
ULONG TotalLength = 0;
//ASSERT (pPacket->Private.Tail->Next == NULL);
if (pPacket->Private.Head != pPacket->Private.Tail)
{
PNDIS_BUFFER pTemp = pPacket->Private.Head;
while (pTemp != NULL)
{
TotalLength += NdisBufferLength(pTemp);
pTemp = pTemp->Next;
}
}
else
{
TotalLength += NdisBufferLength(pPacket->Private.Head);
}
if (TotalLength != pPacket->Private.TotalLength)
{
ASSERT (pPacket->Private.ValidCounts == FALSE);
}
}
BOOLEAN
epvcIsPacketLengthAcceptable (
IN PNDIS_PACKET Packet,
IN PEPVC_I_MINIPORT pMiniport
)
/*++
Routine Description:
Validates the packet length of an incoming packet
Arguments:
Return Value:
--*/
{
UINT PktLength;
BOOLEAN fValid = FALSE;
epvcQueryPacket (Packet, NULL, NULL, NULL, &PktLength);
fValid = (PktLength >= pMiniport->MinAcceptablePkt);
if (fValid == TRUE)
{
fValid = (PktLength <= pMiniport->MaxAcceptablePkt);
}
return fValid;
}
NDIS_STATUS
epvcStripHeaderFromNewPacket (
IN PEPVC_RCV_STRUCT pRcvStruct,
IN PEPVC_I_MINIPORT pMiniport
)
/*++
Routine Description:
In the pure bridged (ethernet) encapsulation, all ethernet packets
are preceeded by a 0x00, 0x00 header. Check if it is present
in the ethernet/llc case, verify the LLC header is correct.
In both cases, allocate a new Ndis Buffer which does not include the
2684 headers.
Store the old head and tail into the NdisPacket and send it up to the
Arguments:
Return Value:
--*/
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
PNDIS_PACKET pPacket = NULL;
PNDIS_BUFFER pHead, pNewHead =NULL;
ULONG CurLength = 0;
PUCHAR pCurVa = NULL;
ULONG EpvcHeaderLength = 0;
PUCHAR pEpvcHeader = NULL;
BOOLEAN fIsCorrectHeader ;
do
{
//
// we are not interested in the pure ipv4 case
//
if (pMiniport->Encap == IPV4_ENCAP_TYPE)
{
Status = NDIS_STATUS_SUCCESS;
break;
}
pPacket = pRcvStruct->pNewPacket;
pHead = pPacket->Private.Head;
switch (pMiniport->Encap)
{
case IPV4_LLC_SNAP_ENCAP_TYPE:
case ETHERNET_LLC_SNAP_ENCAP_TYPE:
{
EpvcHeaderLength = pMiniport->LlcHeaderLength;
pEpvcHeader = pMiniport->pLllcHeader;
break;
}
case ETHERNET_ENCAP_TYPE:
{
EpvcHeaderLength = ETHERNET_PADDING_LENGTH;
pEpvcHeader = &gPaddingBytes[0];
break;
}
case IPV4_ENCAP_TYPE:
default:
{
//
// pMiniport->Encap is only allowed four values,
// therefore we should never hit the defualt case.
//
Status = NDIS_STATUS_FAILURE;
ASSERT (Status != NDIS_STATUS_FAILURE);
return Status;
}
}
//
// Adjust the length and start VA of the MDL
//
CurLength = NdisBufferLength(pHead);
pCurVa = NdisBufferVirtualAddress(pHead);
//
// Check arguments
//
if (pCurVa == NULL)
{
break;
}
if (CurLength <= EpvcHeaderLength )
{
//
// we do not handle the case where the header is longer than
// the first mdl
//
ASSERT (CurLength > EpvcHeaderLength );
break;
}
//
// Compare and make sure that it is the right header
//
fIsCorrectHeader = NdisEqualMemory (pCurVa ,
pEpvcHeader,
EpvcHeaderLength) ;
// If the IsCorrectheader is still false, then there is more to do
if (fIsCorrectHeader == FALSE)
{
break;
}
if (pMiniport->fDoIpEncapsulation == TRUE)
{
//
// In the case of IPEncap + LLC Header, the function
// which adds the Mac Header will strip the LLC Header
//
Status= NDIS_STATUS_SUCCESS;
break;
}
//
// Strip the LLC Header Length
//
CurLength -= EpvcHeaderLength;
pCurVa += EpvcHeaderLength;
epvcAllocateBuffer(&Status ,
&pNewHead,
NULL,
pCurVa,
CurLength
);
if (Status != NDIS_STATUS_SUCCESS)
{
pNewHead = NULL;
break;
}
//
// Set up the Packet context
//
pPacket->Private.ValidCounts= FALSE;
pRcvStruct->pPktContext->Stack.EthLLC.pOldHead = pHead;
pRcvStruct->pPktContext->Stack.EthLLC.pOldTail = pPacket->Private.Tail;
//
// Set the New Ndis buffer in the Packet
//
pNewHead->Next = pHead->Next;
pPacket->Private.Head = pNewHead;
if (pPacket->Private.Tail == pHead)
{
//
// Update the Tail of the packet as well
//
pPacket->Private.Tail = pNewHead;
}
Status = NDIS_STATUS_SUCCESS;
} while (FALSE);
return Status;
}
Reference in a new issue View git blame Copy permalink