able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/nwlink/ipx/device.c

556 lines
14 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989-1993 Microsoft Corporation
Module Name:
device.c
Abstract:
This module contains code which implements the DEVICE_CONTEXT object.
Routines are provided to reference, and dereference transport device
context objects.
The transport device context object is a structure which contains a
system-defined DEVICE_OBJECT followed by information which is maintained
by the transport provider, called the context.
Environment:
Kernel mode
Revision History:
Sanjay Anand (SanjayAn) - 22-Sept-1995
BackFill optimization changes added under #if BACK_FILL
--*/
#include "precomp.h"
#pragma hdrstop
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT,IpxCreateDevice)
#endif
VOID
IpxRefDevice(
IN PDEVICE Device
)
/*++
Routine Description:
This routine increments the reference count on a device context.
Arguments:
Device - Pointer to a transport device context object.
Return Value:
none.
--*/
{
CTEAssert (Device->ReferenceCount > 0); // not perfect, but...
(VOID)InterlockedIncrement(&Device->ReferenceCount);
} /* IpxRefDevice */
VOID
IpxDerefDevice(
IN PDEVICE Device
)
/*++
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:
Device - Pointer to a transport device context object.
Return Value:
none.
--*/
{
LONG result;
#if DBG
int i;
#endif
result = InterlockedDecrement (&Device->ReferenceCount);
CTEAssert (result >= 0);
if (result == 0) {
#if DBG
for (i = 0; i < DREF_TOTAL; i++) {
CTEAssert(Device->RefTypes[i] == 0);
}
#endif
IpxDestroyDevice (Device);
}
} /* IpxDerefDevice */
NTSTATUS
IpxCreateDevice(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING DeviceName,
IN ULONG SegmentCount,
IN OUT PDEVICE *DevicePtr
)
/*++
Routine Description:
This routine creates and initializes a device context structure.
Arguments:
DriverObject - pointer to the IO subsystem supplied driver object.
Device - Pointer to a pointer to a transport device context object.
SegmentCount - The number of segments in the RIP router table.
DeviceName - pointer to the name of the device this device object points to.
Return Value:
STATUS_SUCCESS if all is well; STATUS_INSUFFICIENT_RESOURCES otherwise.
--*/
{
NTSTATUS status;
PDEVICE_OBJECT deviceObject;
PDEVICE Device;
ULONG DeviceSize;
ULONG LocksOffset;
ULONG SegmentsOffset;
ULONG DeviceNameOffset;
UINT i;
//
// Create the device object for the sample transport, allowing
// room at the end for the device name to be stored (for use
// in logging errors) and the RIP fields.
//
DeviceSize = sizeof(DEVICE) +
(sizeof(CTELock) * SegmentCount) +
(sizeof(ROUTER_SEGMENT) * SegmentCount) +
DeviceName->Length + sizeof(UNICODE_NULL);
status = IoCreateDevice(
DriverObject,
DeviceSize,
DeviceName,
FILE_DEVICE_TRANSPORT,
FILE_DEVICE_SECURE_OPEN,
FALSE,
&deviceObject);
if (!NT_SUCCESS(status)) {
IPX_DEBUG(DEVICE, ("Create device %ws failed %lx\n", DeviceName->Buffer, status));
return status;
}
deviceObject->Flags |= DO_DIRECT_IO;
Device = (PDEVICE)deviceObject->DeviceExtension;
IPX_DEBUG(DEVICE, ("Create device %ws succeeded %lx\n", DeviceName->Buffer,Device));
//
// Initialize our part of the device context.
//
RtlZeroMemory(
((PUCHAR)Device) + sizeof(DEVICE_OBJECT),
sizeof(DEVICE) - sizeof(DEVICE_OBJECT));
Device->DeviceObject = deviceObject;
LocksOffset = sizeof(DEVICE);
SegmentsOffset = LocksOffset + (sizeof(CTELock) * SegmentCount);
DeviceNameOffset = SegmentsOffset + (sizeof(ROUTER_SEGMENT) * SegmentCount);
//
// Set some internal pointers.
//
Device->SegmentLocks = (CTELock *)(((PUCHAR)Device) + LocksOffset);
Device->Segments = (PROUTER_SEGMENT)(((PUCHAR)Device) + SegmentsOffset);
Device->SegmentCount = SegmentCount;
for (i = 0; i < SegmentCount; i++) {
CTEInitLock (&Device->SegmentLocks[i]);
InitializeListHead (&Device->Segments[i].WaitingForRoute);
InitializeListHead (&Device->Segments[i].FindWaitingForRoute);
InitializeListHead (&Device->Segments[i].WaitingLocalTarget);
InitializeListHead (&Device->Segments[i].WaitingReripNetnum);
InitializeListHead (&Device->Segments[i].Entries);
Device->Segments[i].EnumerateLocation = &Device->Segments[i].Entries;
}
//
// Copy over the device name.
//
Device->DeviceNameLength = DeviceName->Length + sizeof(WCHAR);
Device->DeviceName = (PWCHAR)(((PUCHAR)Device) + DeviceNameOffset);
RtlCopyMemory(
Device->DeviceName,
DeviceName->Buffer,
DeviceName->Length);
Device->DeviceName[DeviceName->Length/sizeof(WCHAR)] = UNICODE_NULL;
//
// Initialize the reference count.
//
Device->ReferenceCount = 1;
#if DBG
Device->RefTypes[DREF_CREATE] = 1;
#endif
#if DBG
RtlCopyMemory(Device->Signature1, "IDC1", 4);
RtlCopyMemory(Device->Signature2, "IDC2", 4);
#endif
Device->Information.Version = 0x0100;
Device->Information.MaxSendSize = 0; // no sends allowed
Device->Information.MaxDatagramSize = 500; // 500 bytes
Device->Information.MaxConnectionUserData = 0;
Device->Information.ServiceFlags =
TDI_SERVICE_CONNECTIONLESS_MODE | TDI_SERVICE_BROADCAST_SUPPORTED |
TDI_SERVICE_ROUTE_DIRECTED | TDI_SERVICE_FORCE_ACCESS_CHECK;
Device->Information.MinimumLookaheadData = 128;
Device->Information.NumberOfResources = IPX_TDI_RESOURCES;
KeQuerySystemTime (&Device->Information.StartTime);
Device->Statistics.Version = 0x0100;
#if 0
//
// These will be filled in after all the binding is done.
//
Device->Information.MaxDatagramSize = 0;
Device->Information.MaximumLookaheadData = 0;
Device->SourceRoutingUsed = FALSE;
Device->SourceRoutingTime = 0;
Device->RipPacketCount = 0;
Device->RipShortTimerActive = FALSE;
Device->RipSendTime = 0;
#endif
//
// Initialize the resource that guards address ACLs.
//
ExInitializeResourceLite (&Device->AddressResource);
//
// Init the resource that guards the binding array/indices
//
// CTEInitLock (&Device->BindAccessLock);
InitializeListHead (&Device->WaitingRipPackets);
CTEInitTimer (&Device->RipShortTimer);
CTEInitTimer (&Device->RipLongTimer);
CTEInitTimer (&Device->SourceRoutingTimer);
//
// [FW] Initialize the timer used to update inactivity counters
// on WAN lines.
//
CTEInitTimer (&Device->WanInactivityTimer);
//
// initialize the various fields in the device context
//
CTEInitLock (&Device->Interlock);
CTEInitLock (&Device->Lock);
CTEInitLock (&Device->SListsLock);
Device->ControlChannelIdentifier.QuadPart = 1;
InitializeListHead (&Device->GlobalSendPacketList);
InitializeListHead (&Device->GlobalReceivePacketList);
InitializeListHead (&Device->GlobalReceiveBufferList);
#if BACK_FILL
InitializeListHead (&Device->GlobalBackFillPacketList);
#endif
InitializeListHead (&Device->AddressNotifyQueue);
InitializeListHead (&Device->LineChangeQueue);
for (i = 0; i < IPX_ADDRESS_HASH_COUNT; i++) {
InitializeListHead (&Device->AddressDatabases[i]);
}
#if BACK_FILL
InitializeListHead (&Device->BackFillPoolList);
#endif
InitializeListHead (&Device->SendPoolList);
InitializeListHead (&Device->ReceivePoolList);
InitializeListHead (&Device->BindingPoolList);
ExInitializeSListHead (&Device->SendPacketList);
ExInitializeSListHead (&Device->ReceivePacketList);
#if BACK_FILL
ExInitializeSListHead (&Device->BackFillPacketList);
#endif
ExInitializeSListHead (&Device->BindingList);
#if 0
Device->MemoryUsage = 0;
Device->SendPacketList.Next = NULL;
Device->ReceivePacketList.Next = NULL;
Device->Bindings = NULL;
Device->BindingCount = 0;
#endif
KeQuerySystemTime (&Device->IpxStartTime);
Device->State = DEVICE_STATE_CLOSED;
Device->AutoDetectState = AUTO_DETECT_STATE_INIT;
Device->NetPnPEvent = NULL;
Device->Type = IPX_DEVICE_SIGNATURE;
Device->Size = sizeof (DEVICE);
#ifdef SNMP
//
// what are the values for these?
//
IPX_MIB_ENTRY(Device, SysInstance) = 0;
IPX_MIB_ENTRY(Device, SysExistState) = 0;
#endif SNMP
*DevicePtr = Device;
return STATUS_SUCCESS;
} /* IpxCreateDevice */
VOID
IpxDestroyDevice(
IN PDEVICE Device
)
/*++
Routine Description:
This routine destroys a device context structure.
Arguments:
Device - Pointer to a pointer to a transport device context object.
Return Value:
None.
--*/
{
PLIST_ENTRY p;
PSINGLE_LIST_ENTRY s;
PIPX_SEND_POOL SendPool;
PIPX_SEND_PACKET SendPacket;
PIPX_RECEIVE_POOL ReceivePool;
PIPX_RECEIVE_PACKET ReceivePacket;
PIPX_ROUTE_ENTRY RouteEntry;
UINT SendPoolSize;
UINT ReceivePoolSize;
UINT i;
#if BACK_FILL
PIPX_SEND_POOL BackFillPool;
UINT BackFillPoolSize;
PIPX_SEND_PACKET BackFillPacket;
#endif
PIPX_BINDING_POOL BindingPool;
UINT BindingPoolSize;
PBINDING Binding;
CTELockHandle LockHandle;
IPX_DEBUG (DEVICE, ("Destroy device %lx\n", Device));
//
// Take all the packets out of its pools.
//
BindingPoolSize = FIELD_OFFSET (IPX_BINDING_POOL, Bindings[0]) +
(sizeof(BINDING) * Device->InitBindings);
while (!IsListEmpty (&Device->BindingPoolList)) {
p = RemoveHeadList (&Device->BindingPoolList);
BindingPool = CONTAINING_RECORD (p, IPX_BINDING_POOL, Linkage);
IPX_DEBUG (PACKET, ("Free binding pool %lx\n", BindingPool));
IpxFreeMemory (BindingPool, BindingPoolSize, MEMORY_PACKET, "BindingPool");
}
#if BACK_FILL
while (s = IPX_POP_ENTRY_LIST(&Device->BackFillPacketList, &Device->Lock)) {
PIPX_SEND_RESERVED Reserved = CONTAINING_RECORD (s, IPX_SEND_RESERVED, PoolLinkage);
IPX_SEND_PACKET BackFillPacket;
BackFillPacket.Packet = CONTAINING_RECORD (Reserved, NDIS_PACKET, ProtocolReserved[0]);
IpxDeinitializeBackFillPacket (Device, &BackFillPacket);
Device->MemoryUsage -= sizeof(IPX_SEND_RESERVED);
}
while (!IsListEmpty (&Device->BackFillPoolList)) {
p = RemoveHeadList (&Device->BackFillPoolList);
BackFillPool = CONTAINING_RECORD (p, IPX_SEND_POOL, Linkage);
IPX_DEBUG (PACKET, ("Free packet pool %lx\n", BackFillPool));
NdisFreePacketPool (BackFillPool->PoolHandle);
IpxFreeMemory (BackFillPool, sizeof(IPX_SEND_POOL), MEMORY_PACKET, "BafiPool");
}
#endif
while (s = IPX_POP_ENTRY_LIST(&Device->SendPacketList, &Device->Lock)){
PIPX_SEND_RESERVED Reserved = CONTAINING_RECORD (s, IPX_SEND_RESERVED, PoolLinkage);
IPX_SEND_PACKET SendPacket;
PUCHAR Header = Reserved->Header;
SendPacket.Packet = CONTAINING_RECORD (Reserved, NDIS_PACKET, ProtocolReserved[0]);
IpxDeinitializeSendPacket (Device, &SendPacket);
Device->MemoryUsage -= sizeof(IPX_SEND_RESERVED);
}
while (!IsListEmpty (&Device->SendPoolList)) {
p = RemoveHeadList (&Device->SendPoolList);
SendPool = CONTAINING_RECORD (p, IPX_SEND_POOL, Linkage);
IPX_DEBUG (PACKET, ("Free packet pool %lx\n", SendPool));
NdisFreePacketPool (SendPool->PoolHandle);
IpxFreeMemory (SendPool->Header, PACKET_HEADER_SIZE * Device->InitDatagrams, MEMORY_PACKET, "SendPool");
IpxFreeMemory (SendPool, sizeof(IPX_SEND_POOL), MEMORY_PACKET, "SendPool");
}
while (s = IPX_POP_ENTRY_LIST(&Device->ReceivePacketList, &Device->Lock)){
PIPX_RECEIVE_RESERVED Reserved = CONTAINING_RECORD (s, IPX_RECEIVE_RESERVED, PoolLinkage);
IPX_RECEIVE_PACKET ReceivePacket;
ReceivePacket.Packet = CONTAINING_RECORD (Reserved, NDIS_PACKET, ProtocolReserved[0]);
IpxDeinitializeReceivePacket (Device, &ReceivePacket);
Device->MemoryUsage -= sizeof(IPX_RECEIVE_RESERVED);
}
while (!IsListEmpty (&Device->ReceivePoolList)) {
p = RemoveHeadList (&Device->ReceivePoolList);
ReceivePool = CONTAINING_RECORD (p, IPX_RECEIVE_POOL, Linkage);
IPX_DEBUG (PACKET, ("Free packet pool %lx\n", ReceivePool));
NdisFreePacketPool (ReceivePool->PoolHandle);
IpxFreeMemory (ReceivePool, sizeof(IPX_RECEIVE_POOL), MEMORY_PACKET, "ReceivePool");
}
//
// Destroy all rip table entries.
//
for (i = 0; i < Device->SegmentCount; i++) {
RouteEntry = RipGetFirstRoute(i);
while (RouteEntry != NULL) {
(VOID)RipDeleteRoute(i, RouteEntry);
IpxFreeMemory(RouteEntry, sizeof(IPX_ROUTE_ENTRY), MEMORY_RIP, "RouteEntry");
RouteEntry = RipGetNextRoute(i);
}
}
IPX_DEBUG (DEVICE, ("Final memory use is %d\n", Device->MemoryUsage));
#if DBG
for (i = 0; i < MEMORY_MAX; i++) {
if (IpxMemoryTag[i].BytesAllocated != 0) {
IPX_DEBUG (DEVICE, ("Tag %d: %d bytes left\n", i, IpxMemoryTag[i].BytesAllocated));
}
}
#endif
//
// If we are being unloaded then someone is waiting for this
// event to finish the cleanup, since we may be at DISPATCH_LEVEL;
// otherwise it is during load and we can just kill ourselves here.
//
CTEGetLock (&Device->Lock, &LockHandle);
if (Device->UnloadWaiting) {
CTEFreeLock (&Device->Lock, LockHandle);
KeSetEvent(
&Device->UnloadEvent,
0L,
FALSE);
} else {
CTEFreeLock (&Device->Lock, LockHandle);
CTEAssert (KeGetCurrentIrql() < DISPATCH_LEVEL);
ExDeleteResourceLite (&Device->AddressResource);
IoDeleteDevice (Device->DeviceObject);
}
} /* IpxDestroyDevice */
Reference in a new issue Copy permalink