mirror of https://github.com/lianthony/NT4.0
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.
599 lines
16 KiB
599 lines
16 KiB
/*++
|
|
|
|
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;
|
|
|
|
result = InterlockedDecrement (&Device->ReferenceCount);
|
|
|
|
CTEAssert (result >= 0);
|
|
|
|
if (result == 0) {
|
|
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,
|
|
0,
|
|
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));
|
|
|
|
//
|
|
// 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.MaxConnectionUserData = 0;
|
|
Device->Information.ServiceFlags =
|
|
TDI_SERVICE_CONNECTIONLESS_MODE | TDI_SERVICE_BROADCAST_SUPPORTED |
|
|
TDI_SERVICE_ROUTE_DIRECTED;
|
|
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.
|
|
//
|
|
|
|
ExInitializeResource (&Device->AddressResource);
|
|
|
|
#ifdef _PNP_POWER
|
|
//
|
|
// Init the resource that guards the binding array/indices
|
|
//
|
|
CTEInitLock (&Device->BindAccessLock);
|
|
#endif _PNP_POWER
|
|
|
|
InitializeListHead (&Device->WaitingRipPackets);
|
|
CTEInitTimer (&Device->RipShortTimer);
|
|
CTEInitTimer (&Device->RipLongTimer);
|
|
|
|
CTEInitTimer (&Device->SourceRoutingTimer);
|
|
|
|
//
|
|
// 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);
|
|
|
|
#ifdef _PNP_POWER
|
|
InitializeListHead (&Device->BindingPoolList);
|
|
#endif
|
|
|
|
ExInitializeSListHead (&Device->SendPacketList);
|
|
ExInitializeSListHead (&Device->ReceivePacketList);
|
|
#if BACK_FILL
|
|
ExInitializeSListHead (&Device->BackFillPacketList);
|
|
#endif
|
|
|
|
#ifdef _PNP_POWER
|
|
ExInitializeSListHead (&Device->BindingList);
|
|
#endif
|
|
|
|
#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->Type = IPX_DEVICE_SIGNATURE;
|
|
Device->Size = sizeof (DEVICE);
|
|
|
|
|
|
*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
|
|
|
|
#ifdef _PNP_POWER
|
|
PIPX_BINDING_POOL BindingPool;
|
|
UINT BindingPoolSize;
|
|
PBINDING Binding;
|
|
#endif
|
|
|
|
IPX_DEBUG (DEVICE, ("Destroy device %lx\n", Device));
|
|
|
|
//
|
|
// Take all the packets out of its pools.
|
|
//
|
|
|
|
#if _PNP_POWER
|
|
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");
|
|
|
|
}
|
|
#endif
|
|
|
|
#ifdef IPX_OWN_PACKETS
|
|
|
|
#if BACK_FILL
|
|
BackFillPoolSize = FIELD_OFFSET (IPX_SEND_POOL, Packets[0]) +
|
|
(sizeof(IPX_SEND_PACKET) * Device->InitDatagrams);
|
|
while (!IsListEmpty (&Device->BackFillPoolList)) {
|
|
|
|
p = RemoveHeadList (&Device->BackFillPoolList);
|
|
BackFillPool = CONTAINING_RECORD (p, IPX_SEND_POOL, Linkage);
|
|
|
|
for (i = 0; i < BackFillPool->PacketCount; i++) {
|
|
BackFillPacket = &BackFillPool->Packets[i];
|
|
IpxDeinitializeBackFillPacket (Device, BackFillPacket);
|
|
}
|
|
|
|
IPX_DEBUG (PACKET, ("Free packet pool %lx\n", BackFillPool));
|
|
IpxFreeMemory (BackFillPool, BackFillPoolSize, MEMORY_PACKET, "BackPool");
|
|
}
|
|
#endif
|
|
|
|
SendPoolSize = FIELD_OFFSET (IPX_SEND_POOL, Packets[0]) +
|
|
(sizeof(IPX_SEND_PACKET) * Device->InitDatagrams) +
|
|
(((IPX_MAXIMUM_MAC + sizeof(IPX_HEADER) + 3) & ~3) * Device->InitDatagrams);
|
|
|
|
while (!IsListEmpty (&Device->SendPoolList)) {
|
|
|
|
p = RemoveHeadList (&Device->SendPoolList);
|
|
SendPool = CONTAINING_RECORD (p, IPX_SEND_POOL, Linkage);
|
|
|
|
for (i = 0; i < SendPool->PacketCount; i++) {
|
|
|
|
SendPacket = &SendPool->Packets[i];
|
|
IpxDeinitializeSendPacket (Device, SendPacket);
|
|
|
|
}
|
|
|
|
IPX_DEBUG (PACKET, ("Free packet pool %lx\n", SendPool));
|
|
IpxFreeMemory (SendPool, SendPoolSize, MEMORY_PACKET, "SendPool");
|
|
}
|
|
|
|
ReceivePoolSize = FIELD_OFFSET (IPX_RECEIVE_POOL, Packets[0]) +
|
|
(sizeof(IPX_RECEIVE_PACKET) * Device->InitReceivePackets);
|
|
|
|
while (!IsListEmpty (&Device->ReceivePoolList)) {
|
|
|
|
p = RemoveHeadList (&Device->ReceivePoolList);
|
|
ReceivePool = CONTAINING_RECORD (p, IPX_RECEIVE_POOL, Linkage);
|
|
|
|
for (i = 0; i < ReceivePool->PacketCount; i++) {
|
|
|
|
ReceivePacket = &ReceivePool->Packets[i];
|
|
IpxDeinitializeReceivePacket (Device, ReceivePacket);
|
|
|
|
}
|
|
|
|
IPX_DEBUG (PACKET, ("Free receive packet pool %lx\n", ReceivePool));
|
|
IpxFreeMemory (ReceivePool, ReceivePoolSize, MEMORY_PACKET, "ReceivePool");
|
|
}
|
|
#else
|
|
|
|
#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 -= (FIELD_OFFSET(NDIS_PACKET,ProtocolReserved[0]) + 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);
|
|
Device->MemoryUsage -= FIELD_OFFSET(NDIS_PACKET_POOL,Buffer[0]);
|
|
|
|
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 -= (FIELD_OFFSET(NDIS_PACKET,ProtocolReserved[0]) + 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);
|
|
Device->MemoryUsage -= FIELD_OFFSET(NDIS_PACKET_POOL,Buffer[0]);
|
|
|
|
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 -= (FIELD_OFFSET(NDIS_PACKET,ProtocolReserved[0]) + 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);
|
|
Device->MemoryUsage -= FIELD_OFFSET(NDIS_PACKET_POOL,Buffer[0]);
|
|
|
|
IpxFreeMemory (ReceivePool, sizeof(IPX_RECEIVE_POOL), MEMORY_PACKET, "ReceivePool");
|
|
}
|
|
|
|
#endif IPX_OWN_PACKETS
|
|
//
|
|
// 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.
|
|
//
|
|
|
|
if (Device->UnloadWaiting) {
|
|
|
|
KeSetEvent(
|
|
&Device->UnloadEvent,
|
|
0L,
|
|
FALSE);
|
|
|
|
} else {
|
|
|
|
CTEAssert (KeGetCurrentIrql() < DISPATCH_LEVEL);
|
|
ExDeleteResource (&Device->AddressResource);
|
|
IoDeleteDevice (Device->DeviceObject);
|
|
}
|
|
|
|
} /* IpxDestroyDevice */
|
|
|