You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
983 lines
22 KiB
983 lines
22 KiB
/*++
|
|
|
|
Copyright (c) 1989-1993 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
adapter.c
|
|
|
|
Abstract:
|
|
|
|
This module contains code which implements the ADAPTER object.
|
|
Routines are provided to reference, and dereference transport
|
|
adapter objects.
|
|
|
|
Environment:
|
|
|
|
Kernel mode
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
//
|
|
// local function prototypes
|
|
//
|
|
VOID
|
|
IpxDelayedFreeAdapter(
|
|
IN PVOID Param
|
|
);
|
|
|
|
//********** Pageable Routine Declarations *****
|
|
//************************* PAGEIPX **********************************
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGEIPX, IpxDelayedFreeAdapter)
|
|
#endif
|
|
//********** Pageable Routine Declarations *****
|
|
|
|
|
|
|
|
//
|
|
// These are init only until binding is really dynamic.
|
|
//
|
|
|
|
//
|
|
// [FW] So, later we can change this to pnp-compatible value
|
|
//
|
|
|
|
//
|
|
// ULONG
|
|
// ADAPTER_INDEX_TO_FWCONTEXT(
|
|
// IN ULONG _adapterindex;
|
|
// );
|
|
//
|
|
|
|
#define ADAPTER_INDEX_TO_FWCONTEXT(_adapterindex) _adapterindex
|
|
|
|
|
|
VOID
|
|
IpxRefBinding(
|
|
IN PBINDING Binding
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine increments the reference count on a device context.
|
|
|
|
Arguments:
|
|
|
|
Binding - Pointer to a transport device context object.
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
|
|
{
|
|
CTEAssert (Binding->ReferenceCount > 0); // not perfect, but...
|
|
|
|
(VOID)InterlockedIncrement (&Binding->ReferenceCount);
|
|
|
|
} /* IpxRefBinding */
|
|
|
|
|
|
VOID
|
|
IpxDerefBinding(
|
|
IN PBINDING Binding
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine dereferences a device context by decrementing the
|
|
reference count contained in the structure. Currently, we don't
|
|
do anything special when the reference count drops to zero, but
|
|
we could dynamically unload stuff then.
|
|
|
|
Arguments:
|
|
|
|
Binding - Pointer to a transport device context object.
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG result;
|
|
|
|
result = InterlockedDecrement (&Binding->ReferenceCount);
|
|
|
|
CTEAssert (result >= 0);
|
|
|
|
if (result == 0) {
|
|
IpxDestroyBinding (Binding);
|
|
}
|
|
|
|
} /* IpxDerefBinding */
|
|
|
|
|
|
NTSTATUS
|
|
IpxCreateAdapter(
|
|
IN PDEVICE Device,
|
|
IN PUNICODE_STRING AdapterName,
|
|
IN OUT PADAPTER *AdapterPtr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine creates and initializes a device context structure.
|
|
|
|
Arguments:
|
|
|
|
|
|
DriverObject - pointer to the IO subsystem supplied driver object.
|
|
|
|
Adapter - Pointer to a pointer to a transport device context object.
|
|
|
|
AdapterName - pointer to the name of the device this device object points to.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS if all is well; STATUS_INSUFFICIENT_RESOURCES otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
PADAPTER Adapter;
|
|
#if 0
|
|
UINT i, j;
|
|
#endif
|
|
|
|
Adapter = (PADAPTER)IpxAllocateMemory (sizeof(ADAPTER) + AdapterName->Length + sizeof(WCHAR), MEMORY_ADAPTER, "Adapter");
|
|
|
|
if (Adapter == NULL) {
|
|
if (KeGetCurrentIrql() == 0) {
|
|
IPX_DEBUG (ADAPTER, ("Create adapter %ws failed\n", AdapterName));
|
|
} else {
|
|
IPX_DEBUG (ADAPTER, ("Create adapter %lx failed\n", AdapterName));
|
|
}
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
IPX_DEBUG (ADAPTER, ("Create adapter %lx %lx succeeded\n", Adapter, AdapterName));
|
|
|
|
RtlZeroMemory(Adapter, sizeof(ADAPTER));
|
|
|
|
//
|
|
// Copy over the adapter name.
|
|
//
|
|
|
|
Adapter->AdapterNameLength = AdapterName->Length + sizeof(WCHAR);
|
|
Adapter->AdapterName = (PWCHAR)(Adapter+1);
|
|
RtlCopyMemory(
|
|
Adapter->AdapterName,
|
|
AdapterName->Buffer,
|
|
AdapterName->Length);
|
|
Adapter->AdapterName[AdapterName->Length/sizeof(WCHAR)] = UNICODE_NULL;
|
|
|
|
|
|
#if DBG
|
|
RtlCopyMemory(Adapter->Signature1, "IAD1", 4);
|
|
#endif
|
|
|
|
Adapter->Type = IPX_ADAPTER_SIGNATURE;
|
|
Adapter->Size = sizeof(ADAPTER);
|
|
|
|
CTEInitLock (&Adapter->Lock);
|
|
|
|
InitializeListHead (&Adapter->RequestCompletionQueue);
|
|
|
|
InitializeListHead (&Adapter->ReceiveBufferPoolList);
|
|
|
|
ExInitializeSListHead (&Adapter->ReceiveBufferList);
|
|
|
|
Adapter->Device = Device;
|
|
Adapter->DeviceLock = &Device->Lock;
|
|
IpxReferenceDevice (Device, DREF_ADAPTER);
|
|
|
|
Adapter->Disabled = ENABLED; // used iu NDIS_MEDIA_SENSE ...
|
|
|
|
#if 0
|
|
Adapter->ReceiveBufferPool.Next = NULL;
|
|
for (i = 0; i < ISN_FRAME_TYPE_MAX; i++) {
|
|
Adapter->Bindings[i] = NULL;
|
|
}
|
|
Adapter->BindingCount = 0;
|
|
|
|
for (i = 0; i < IDENTIFIER_TOTAL; i++) {
|
|
for (j = 0; j < SOURCE_ROUTE_HASH_SIZE; j++) {
|
|
Adapter->SourceRoutingHeads[i][j] = (PSOURCE_ROUTE)NULL;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// For the moment, we have to do the source
|
|
// routing operation on any type where broadcast
|
|
// may not be used for discovery -- improve this
|
|
// hopefully.
|
|
//
|
|
|
|
Adapter->SourceRoutingEmpty[IDENTIFIER_RIP] = FALSE;
|
|
Adapter->SourceRoutingEmpty[IDENTIFIER_IPX] = FALSE;
|
|
Adapter->SourceRoutingEmpty[IDENTIFIER_SPX] = FALSE;
|
|
Adapter->SourceRoutingEmpty[IDENTIFIER_NB] = TRUE;
|
|
|
|
//
|
|
// Lock here? Added lock. [TC]
|
|
//
|
|
|
|
KeInitializeEvent(
|
|
&Adapter->NdisEvent,
|
|
NotificationEvent,
|
|
FALSE
|
|
);
|
|
|
|
InterlockedExchange(&(Adapter->ReferenceCount),1);
|
|
#if DBG
|
|
InterlockedExchange(&(Adapter->RefTypes[ADAP_REF_CREATE]),1);
|
|
#endif
|
|
*AdapterPtr = Adapter;
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} /* IpxCreateAdapter */
|
|
|
|
|
|
VOID
|
|
IpxDestroyAdapter(
|
|
IN PADAPTER Adapter
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine destroys a device context structure.
|
|
|
|
Arguments:
|
|
|
|
Adapter - Pointer to a pointer to a transport device context object.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG Database, Hash;
|
|
PSOURCE_ROUTE Current;
|
|
ULONG ReceiveBufferPoolSize;
|
|
PIPX_RECEIVE_BUFFER ReceiveBuffer;
|
|
PIPX_RECEIVE_BUFFER_POOL ReceiveBufferPool;
|
|
PDEVICE Device = Adapter->Device;
|
|
PLIST_ENTRY p;
|
|
UINT i;
|
|
PIPX_DELAYED_FREE_ITEM DelayedFreeItem;
|
|
|
|
IPX_DEBUG (ADAPTER, ("Destroy adapter %lx\n", Adapter));
|
|
|
|
//
|
|
// Free any receive buffer pools this adapter has.
|
|
//
|
|
|
|
ReceiveBufferPoolSize = FIELD_OFFSET (IPX_RECEIVE_BUFFER_POOL, Buffers[0]) +
|
|
(sizeof(IPX_RECEIVE_BUFFER) * Device->InitReceiveBuffers) +
|
|
(Adapter->MaxReceivePacketSize * Device->InitReceiveBuffers);
|
|
|
|
while (!IsListEmpty (&Adapter->ReceiveBufferPoolList)) {
|
|
|
|
p = RemoveHeadList (&Adapter->ReceiveBufferPoolList);
|
|
ReceiveBufferPool = CONTAINING_RECORD (p, IPX_RECEIVE_BUFFER_POOL, Linkage);
|
|
|
|
for (i = 0; i < ReceiveBufferPool->BufferCount; i++) {
|
|
|
|
ReceiveBuffer = &ReceiveBufferPool->Buffers[i];
|
|
IpxDeinitializeReceiveBuffer (Adapter, ReceiveBuffer, Adapter->MaxReceivePacketSize);
|
|
|
|
}
|
|
|
|
IPX_DEBUG (PACKET, ("Free buffer pool %lx\n", ReceiveBufferPool));
|
|
IpxFreeMemory (ReceiveBufferPool, ReceiveBufferPoolSize, MEMORY_PACKET, "ReceiveBufferPool");
|
|
}
|
|
|
|
//
|
|
// Free all the source routing information for this adapter.
|
|
//
|
|
|
|
for (Database = 0; Database < IDENTIFIER_TOTAL; Database++) {
|
|
|
|
for (Hash = 0; Hash < SOURCE_ROUTE_HASH_SIZE; Hash++) {
|
|
|
|
while (Adapter->SourceRoutingHeads[Database][Hash]) {
|
|
|
|
Current = Adapter->SourceRoutingHeads[Database][Hash];
|
|
Adapter->SourceRoutingHeads[Database][Hash] = Current->Next;
|
|
|
|
IpxFreeMemory (Current, SOURCE_ROUTE_SIZE (Current->SourceRoutingLength), MEMORY_SOURCE_ROUTE, "SourceRouting");
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// I am moving the following line to the workerthread, so that
|
|
// the device can go away only after the worker thread completes. [MS]
|
|
//
|
|
// IpxDereferenceDevice (Adapter->Device, DREF_ADAPTER);
|
|
|
|
//
|
|
// Free the adapter on a delayed queue so that all
|
|
// the threads inside this would have come out of it.
|
|
// allocate a work item and queue it on a delayed queue.
|
|
//
|
|
DelayedFreeItem = (PIPX_DELAYED_FREE_ITEM)IpxAllocateMemory (
|
|
sizeof(IPX_DELAYED_FREE_ITEM),
|
|
MEMORY_WORK_ITEM,
|
|
"Work Item");
|
|
if ( DelayedFreeItem ) {
|
|
DelayedFreeItem->Context = (PVOID)Adapter;
|
|
DelayedFreeItem->ContextSize = sizeof(ADAPTER) + Adapter->AdapterNameLength;
|
|
ExInitializeWorkItem(
|
|
&DelayedFreeItem->WorkItem,
|
|
IpxDelayedFreeAdapter,
|
|
(PVOID)DelayedFreeItem);
|
|
|
|
ExQueueWorkItem(
|
|
&DelayedFreeItem->WorkItem,
|
|
DelayedWorkQueue);
|
|
|
|
} else {
|
|
//
|
|
// oh well, tough luck. Just delay this thread and then
|
|
// destroy the adapter.
|
|
//
|
|
LARGE_INTEGER Delay;
|
|
PDEVICE Device;
|
|
|
|
Delay.QuadPart = -10*10000; // Ten second.
|
|
Device = Adapter->Device;
|
|
|
|
KeDelayExecutionThread(
|
|
KernelMode,
|
|
FALSE,
|
|
&Delay);
|
|
|
|
IpxFreeMemory (Adapter, sizeof(ADAPTER) + Adapter->AdapterNameLength, MEMORY_ADAPTER, "Adapter");
|
|
|
|
// We need to dereference the adapter in the failure case as well. [TingCai]
|
|
IpxDereferenceDevice (Device, DREF_ADAPTER);
|
|
}
|
|
|
|
} /* IpxDestroyAdapter */
|
|
|
|
|
|
VOID
|
|
IpxDelayedFreeAdapter(
|
|
IN PVOID Param
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine frees an adapter on the delayed queue. We wait long enough
|
|
before freeing an adapter to make sure that no threads are accessing it
|
|
This allows us to access the Adapter without the use of spinlocks.
|
|
|
|
Arguments:
|
|
|
|
Param - pointer to the work item.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
LARGE_INTEGER Delay;
|
|
PIPX_DELAYED_FREE_ITEM DelayedFreeItem = (PIPX_DELAYED_FREE_ITEM) Param;
|
|
PADAPTER Adapter;
|
|
PDEVICE Device;
|
|
|
|
Adapter = (PADAPTER) DelayedFreeItem->Context;
|
|
|
|
// Keep a pointer, as we need it in IpxDereferenceDevice after we free the memory.[TC]
|
|
Device = Adapter->Device;
|
|
|
|
|
|
Delay.QuadPart = -10*10000; // Ten second.
|
|
|
|
KeDelayExecutionThread(
|
|
KernelMode,
|
|
FALSE,
|
|
&Delay);
|
|
|
|
// IpxFreeMemory needs to access Device structure, so delay the following line
|
|
// to the end of this function.
|
|
// IpxDereferenceDevice (Adapter->Device, DREF_ADAPTER);
|
|
|
|
IpxFreeMemory (
|
|
DelayedFreeItem->Context,
|
|
DelayedFreeItem->ContextSize,
|
|
MEMORY_ADAPTER,
|
|
"Adapter");
|
|
|
|
IpxFreeMemory (
|
|
DelayedFreeItem,
|
|
sizeof (IPX_DELAYED_FREE_ITEM),
|
|
MEMORY_WORK_ITEM,
|
|
"Work Item");
|
|
|
|
IpxDereferenceDevice (Device, DREF_ADAPTER);
|
|
|
|
} /* IpxDelayedFreeAdapter */
|
|
|
|
|
|
|
|
NTSTATUS
|
|
IpxCreateBinding(
|
|
IN PDEVICE Device,
|
|
IN PBINDING_CONFIG ConfigBinding OPTIONAL,
|
|
IN ULONG NetworkNumberIndex,
|
|
IN PWCHAR AdapterName,
|
|
IN OUT PBINDING *BindingPtr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine creates and initializes a binding structure.
|
|
|
|
Arguments:
|
|
|
|
Device - The device.
|
|
|
|
ConfigBinding - Information about this binding. If this is
|
|
NULL then this is a WAN binding and all the relevant
|
|
information will be filled in by the caller.
|
|
|
|
NetworkNumberIndex - The index in the frame type array for
|
|
ConfigBinding indicating which frame type this binding is for.
|
|
Not used if ConfigBinding is not provided.
|
|
|
|
AdapterName - Used for error logging.
|
|
|
|
BindingPtr - Returns the allocated binding structure.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS if all is well; STATUS_INSUFFICIENT_RESOURCES otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
PBINDING Binding;
|
|
PSLIST_ENTRY s;
|
|
|
|
s = IPX_POP_ENTRY_LIST(
|
|
&Device->BindingList,
|
|
&Device->SListsLock);
|
|
|
|
if (s != NULL) {
|
|
goto GotBinding;
|
|
}
|
|
|
|
//
|
|
// This function tries to allocate another packet pool.
|
|
//
|
|
|
|
s = IpxPopBinding(Device);
|
|
|
|
//
|
|
// Possibly we should queue the packet up to wait
|
|
// for one to become free.
|
|
//
|
|
|
|
if (s == NULL) {
|
|
|
|
#if DBG
|
|
if (KeGetCurrentIrql() == 0) {
|
|
IPX_DEBUG (ADAPTER, ("Create binding %ws failed\n", AdapterName));
|
|
} else {
|
|
IPX_DEBUG (ADAPTER, ("Create binding WAN failed\n"));
|
|
}
|
|
#endif
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
GotBinding:
|
|
|
|
Binding = CONTAINING_RECORD (s, BINDING, PoolLinkage);
|
|
|
|
|
|
#if DBG
|
|
if (KeGetCurrentIrql() == 0) {
|
|
IPX_DEBUG (ADAPTER, ("Create binding %ws succeeded, %lx\n", AdapterName, Binding));
|
|
} else {
|
|
IPX_DEBUG (ADAPTER, ("Create binding WAN succeeded\n"));
|
|
}
|
|
#endif
|
|
|
|
RtlZeroMemory(Binding, sizeof(BINDING));
|
|
|
|
//
|
|
// Initialize the reference count.
|
|
//
|
|
|
|
Binding->ReferenceCount = 1;
|
|
#if DBG
|
|
Binding->RefTypes[BREF_BOUND] = 1;
|
|
#endif
|
|
|
|
#if DBG
|
|
RtlCopyMemory(Binding->Signature1, "IBI1", 4);
|
|
#endif
|
|
|
|
Binding->Type = IPX_BINDING_SIGNATURE;
|
|
Binding->Size = sizeof(BINDING);
|
|
|
|
Binding->Device = Device;
|
|
Binding->DeviceLock = &Device->Lock;
|
|
|
|
if (ConfigBinding != NULL) {
|
|
|
|
ULONG Temp = ConfigBinding->NetworkNumber[NetworkNumberIndex];
|
|
Binding->ConfiguredNetworkNumber = REORDER_ULONG (Temp);
|
|
|
|
Binding->AutoDetect = ConfigBinding->AutoDetect[NetworkNumberIndex];
|
|
Binding->DefaultAutoDetect = ConfigBinding->DefaultAutoDetect[NetworkNumberIndex];
|
|
|
|
Binding->AllRouteDirected = (BOOLEAN)ConfigBinding->Parameters[BINDING_ALL_ROUTE_DEF];
|
|
Binding->AllRouteBroadcast = (BOOLEAN)ConfigBinding->Parameters[BINDING_ALL_ROUTE_BC];
|
|
Binding->AllRouteMulticast = (BOOLEAN)ConfigBinding->Parameters[BINDING_ALL_ROUTE_MC];
|
|
|
|
}
|
|
|
|
Binding->ReceiveBroadcast = TRUE;
|
|
IPX_DEBUG(ADAPTER, (" %x set to TRUE\n", Binding));
|
|
|
|
#if 0
|
|
Binding->BindingSetMember = FALSE;
|
|
Binding->NextBinding = (PBINDING)NULL;
|
|
Binding->DialOutAsync = FALSE;
|
|
#endif
|
|
|
|
Binding->TdiRegistrationHandle = NULL;
|
|
Binding->fInfoIndicated = FALSE;
|
|
Binding->PastAutoDetection = FALSE;
|
|
//
|
|
// We set Binding->FrameType later, after we can map it based on the
|
|
// media type of the adapter we bind to.
|
|
//
|
|
|
|
*BindingPtr = Binding;
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} /* IpxCreateBinding */
|
|
|
|
|
|
VOID
|
|
IpxDestroyBinding(
|
|
IN PBINDING Binding
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine destroys a binding structure.
|
|
|
|
Arguments:
|
|
|
|
Binding - Pointer to a transport binding structure.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
IPX_DEBUG (ADAPTER, ("Destroy binding %lx\n", Binding));
|
|
|
|
|
|
IPX_PUSH_ENTRY_LIST(
|
|
&IpxDevice->BindingList,
|
|
&Binding->PoolLinkage,
|
|
&IpxDevice->SListsLock);
|
|
|
|
} /* IpxDestroyBinding */
|
|
|
|
|
|
VOID
|
|
IpxAllocateBindingPool(
|
|
IN PDEVICE Device
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine adds 10 bindings to the pool for this device.
|
|
|
|
Arguments:
|
|
|
|
Device - The device.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PIPX_BINDING_POOL BindingPool;
|
|
UINT BindingPoolSize;
|
|
UINT BindingNum;
|
|
PBINDING Binding;
|
|
CTELockHandle LockHandle;
|
|
|
|
BindingPoolSize = FIELD_OFFSET (IPX_BINDING_POOL, Bindings[0]) +
|
|
(sizeof(BINDING) * Device->InitBindings);
|
|
|
|
BindingPool = (PIPX_BINDING_POOL)IpxAllocateMemory (BindingPoolSize, MEMORY_PACKET, "BindingPool");
|
|
|
|
if (BindingPool == NULL) {
|
|
IPX_DEBUG (PNP, ("Could not allocate binding pool memory\n"));
|
|
return;
|
|
}
|
|
|
|
|
|
IPX_DEBUG (PNP, ("Initializing Binding pool %lx, %d bindings\n",
|
|
BindingPool, Device->InitBindings));
|
|
|
|
BindingPool->BindingCount = Device->InitBindings;
|
|
|
|
CTEGetLock (&Device->Lock, &LockHandle);
|
|
|
|
for (BindingNum = 0; BindingNum < BindingPool->BindingCount; BindingNum++) {
|
|
|
|
Binding = &BindingPool->Bindings[BindingNum];
|
|
IPX_PUSH_ENTRY_LIST (&Device->BindingList, &Binding->PoolLinkage, &Device->SListsLock);
|
|
|
|
#ifdef IPX_TRACK_POOL
|
|
Binding->Pool = BindingPool;
|
|
#endif
|
|
}
|
|
|
|
InsertTailList (&Device->BindingPoolList, &BindingPool->Linkage);
|
|
|
|
Device->AllocatedBindings += BindingPool->BindingCount;
|
|
|
|
CTEFreeLock (&Device->Lock, LockHandle);
|
|
|
|
} /* IpxAllocateBindingPool */
|
|
|
|
|
|
PSLIST_ENTRY
|
|
IpxPopBinding(
|
|
PDEVICE Device
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine allocates a binding from the device context's pool.
|
|
If there are no bindings in the pool, it allocates one up to
|
|
the configured limit.
|
|
|
|
Arguments:
|
|
|
|
Device - Pointer to our device to charge the packet to.
|
|
|
|
Return Value:
|
|
|
|
The pointer to the Linkage field in the allocated binding.
|
|
|
|
--*/
|
|
|
|
{
|
|
PSLIST_ENTRY s;
|
|
|
|
s = IPX_POP_ENTRY_LIST(
|
|
&Device->BindingList,
|
|
&Device->SListsLock);
|
|
|
|
if (s != NULL) {
|
|
return s;
|
|
}
|
|
|
|
//
|
|
// No packets in the pool, see if we can allocate more.
|
|
//
|
|
|
|
if (Device->AllocatedBindings < Device->MaxPoolBindings) {
|
|
|
|
//
|
|
// Allocate a pool and try again.
|
|
//
|
|
|
|
IpxAllocateBindingPool (Device);
|
|
s = IPX_POP_ENTRY_LIST(
|
|
&Device->BindingList,
|
|
&Device->SListsLock);
|
|
|
|
return s;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} /* IpxPopBinding */
|
|
|
|
//
|
|
// [FW]
|
|
//
|
|
#ifdef SUNDOWN
|
|
NTSTATUS
|
|
IpxOpenAdapter(
|
|
IN NIC_HANDLE AdapterIndex1,
|
|
IN ULONG_PTR FwdAdapterContext,
|
|
OUT PNIC_HANDLE IpxAdapterContext
|
|
)
|
|
#else
|
|
NTSTATUS
|
|
IpxOpenAdapter(
|
|
IN NIC_HANDLE AdapterIndex1,
|
|
IN ULONG FwdAdapterContext,
|
|
OUT PNIC_HANDLE IpxAdapterContext
|
|
)
|
|
#endif
|
|
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the Kernel Forwarder to open an adapter
|
|
|
|
Arguments:
|
|
|
|
AdapterIndex - index of the adapter to open (NICid for now - will change to a struct
|
|
with a version number, signature and the NicId
|
|
FwdAdapterContext - Forwarder's context
|
|
IpxAdapterContext - our context (for now we use the NICid - for pnp will change
|
|
this to contain a signature and version #)
|
|
|
|
Return Value:
|
|
|
|
STATUS_INVALID_HANDLE if the AdapterIndex handle was invalid
|
|
STATUS_ADAPTER_ALREADY_OPENED if the Adapter is being opened a second time
|
|
STATUS_SUCCESS
|
|
|
|
--*/
|
|
|
|
{
|
|
PBINDING Binding;
|
|
PDEVICE Device = IpxDevice;
|
|
USHORT AdapterIndex = AdapterIndex1.NicId;
|
|
|
|
IPX_DEBUG(ADAPTER, ("IPX: Entered IpxOpenAdapter\n"));
|
|
|
|
//
|
|
// Return error if the AdapterIndex is out of range.
|
|
// We do indicate the slave bindings to NB/SPX (but not to RIP)
|
|
// Hence, the index should be less than HighestExternalNicId (not ValidBindings)
|
|
//
|
|
|
|
if (AdapterIndex > Device->HighestExternalNicId) {
|
|
return STATUS_INVALID_HANDLE;
|
|
}
|
|
|
|
|
|
//
|
|
// Fill up our context to be returned to the Forwarder
|
|
//
|
|
NIC_HANDLE_FROM_NIC((*IpxAdapterContext), AdapterIndex);
|
|
|
|
//
|
|
// If AdapterIndex is 0, it is for the virtual net
|
|
// Will the forwarder open this at all?
|
|
//
|
|
|
|
if (AdapterIndex == 0) {
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Get the binding pointer
|
|
//
|
|
|
|
Binding = NIC_ID_TO_BINDING(IpxDevice, AdapterIndex);
|
|
|
|
if (Binding == NULL) {
|
|
return STATUS_INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Return error if adapter is being opened a second time (or more times)
|
|
//
|
|
|
|
if (GET_LONG_VALUE(Binding->ReferenceCount) >= 2) {
|
|
return STATUS_ADAPTER_ALREADY_OPENED;
|
|
}
|
|
|
|
//
|
|
// Store the Forwarder's Adapter Context in the binding
|
|
//
|
|
|
|
Binding->FwdAdapterContext = FwdAdapterContext;
|
|
|
|
//
|
|
// Reference the Binding
|
|
//
|
|
|
|
IpxReferenceBinding(Binding, BREF_FWDOPEN);
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
IpxCloseAdapter(
|
|
IN NIC_HANDLE IpxAdapterContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called by the Kernel Forwarder to close an adapter
|
|
|
|
Arguments:
|
|
|
|
IpxAdapterContext - our context (for now we use the NICid - for pnp will change
|
|
this to contain a signature and version#)
|
|
|
|
Return Value:
|
|
|
|
STATUS_ADAPTER_ALREADY_CLOSED - if the adapter is being closed a second time
|
|
STATUS_SUCCESS
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
PBINDING Binding;
|
|
|
|
IPX_DEBUG(ADAPTER, ("IPX: Entered IpxCloseAdapter\n"));
|
|
|
|
Binding = NIC_ID_TO_BINDING(IpxDevice, IpxAdapterContext.NicId);
|
|
|
|
if (Binding == NULL) {
|
|
ASSERT(FALSE);
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
//
|
|
// Either the adapter is around (count = 2)
|
|
// or it went away (count = 1). The latter cannot happen now.
|
|
//
|
|
|
|
if (GET_LONG_VALUE(Binding->ReferenceCount) <= 1) {
|
|
return STATUS_ADAPTER_ALREADY_CLOSED;
|
|
}
|
|
|
|
//
|
|
// Dereference the Binding so it can be deleted
|
|
//
|
|
|
|
IpxDereferenceBinding(Binding, BREF_FWDOPEN);
|
|
|
|
|
|
//
|
|
// Clear the Forwarder's Adapter Context in the binding
|
|
//
|
|
|
|
Binding->FwdAdapterContext = 0;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
VOID
|
|
IpxRefAdapter(
|
|
IN PADAPTER Adapter
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine increments the reference count on a adapter context.
|
|
|
|
Arguments:
|
|
|
|
Adapter - Pointer to a transport adapter context object.
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
|
|
{
|
|
CTEAssert (Adapter->ReferenceCount > 0); // not perfect, but...
|
|
|
|
(VOID)InterlockedIncrement(&Adapter->ReferenceCount);
|
|
|
|
} /* IpxRefAdapter */
|
|
|
|
|
|
VOID
|
|
IpxDerefAdapter(
|
|
IN PADAPTER Adapter
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine dereferences a adapter context by decrementing the
|
|
reference count contained in the structure.
|
|
|
|
Arguments:
|
|
|
|
Adapter - Pointer to a transport adapter context object.
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG result;
|
|
|
|
|
|
result = InterlockedDecrement (&Adapter->ReferenceCount);
|
|
|
|
CTEAssert (result >= 0);
|
|
|
|
if (result == 0) {
|
|
KeSetEvent(&Adapter->NdisEvent, 0L, FALSE);
|
|
}
|
|
|
|
} /* IpxDerefAdapter */
|