Windows-Server-2003/net/rndis/usb8023/packet.c

429 lines
12 KiB
C

/*++
Copyright (c) 1999 Microsoft Corporation
Module Name:
packet.c
Author:
ervinp
Environment:
Kernel mode
Revision History:
--*/
#include <WDM.H>
#include <usbdi.h>
#include <usbdlib.h>
#include <usbioctl.h>
#include "usb8023.h"
#include "debug.h"
ULONG uniquePacketId = 0;
USBPACKET *NewPacket(ADAPTEREXT *adapter)
{
USBPACKET *packet = AllocPool(sizeof(USBPACKET));
if (packet){
BOOLEAN allAllocsOk;
packet->sig = DRIVER_SIG;
packet->adapter = adapter;
packet->cancelled = FALSE;
InitializeListHead(&packet->listEntry);
packet->irpPtr = IoAllocateIrp(adapter->nextDevObj->StackSize, FALSE);
packet->urbPtr = AllocPool(sizeof(URB));
packet->dataBuffer = AllocPool(PACKET_BUFFER_SIZE);
packet->dataBufferMaxLength = PACKET_BUFFER_SIZE;
if (packet->dataBuffer){
packet->dataBufferMdl = IoAllocateMdl(packet->dataBuffer, PACKET_BUFFER_SIZE, FALSE, FALSE, NULL);
}
packet->dataBufferCurrentLength = 0;
allAllocsOk = (packet->irpPtr && packet->urbPtr && packet->dataBuffer && packet->dataBufferMdl);
if (allAllocsOk){
packet->packetId = ++uniquePacketId;
}
else {
if (packet->irpPtr) IoFreeIrp(packet->irpPtr);
if (packet->urbPtr) FreePool(packet->urbPtr);
if (packet->dataBuffer) FreePool(packet->dataBuffer);
if (packet->dataBufferMdl) IoFreeMdl(packet->dataBufferMdl);
FreePool(packet);
packet = NULL;
}
}
return packet;
}
VOID FreePacket(USBPACKET *packet)
{
PIRP irp = packet->irpPtr;
ASSERT(packet->sig == DRIVER_SIG);
packet->sig = 0xDEADDEAD;
ASSERT(!irp->CancelRoutine);
IoFreeIrp(irp);
FreePool(packet->urbPtr);
ASSERT(packet->dataBufferMdl);
IoFreeMdl(packet->dataBufferMdl);
ASSERT(packet->dataBuffer);
FreePool(packet->dataBuffer);
FreePool(packet);
}
VOID EnqueueFreePacket(USBPACKET *packet)
{
ADAPTEREXT *adapter = packet->adapter;
KIRQL oldIrql;
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
ASSERT(IsListEmpty(&packet->listEntry));
InsertTailList(&adapter->usbFreePacketPool, &packet->listEntry);
adapter->numFreePackets++;
ASSERT(adapter->numFreePackets <= USB_PACKET_POOL_SIZE);
#if DBG
packet->timeStamp = DbgGetSystemTime_msec();
if (adapter->dbgInLowPacketStress){
if (adapter->numFreePackets > USB_PACKET_POOL_SIZE/2){
adapter->dbgInLowPacketStress = FALSE;
DBGWARN(("recovered from low-packet stress"));
}
}
#endif
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
}
USBPACKET *DequeueFreePacket(ADAPTEREXT *adapter)
{
USBPACKET *packet;
KIRQL oldIrql;
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
if (IsListEmpty(&adapter->usbFreePacketPool)){
packet = NULL;
}
else {
PLIST_ENTRY listEntry = RemoveHeadList(&adapter->usbFreePacketPool);
packet = CONTAINING_RECORD(listEntry, USBPACKET, listEntry);
ASSERT(packet->sig == DRIVER_SIG);
InitializeListHead(&packet->listEntry);
ASSERT(adapter->numFreePackets > 0);
adapter->numFreePackets--;
}
#if DBG
if (adapter->numFreePackets < USB_PACKET_POOL_SIZE/8){
if (!adapter->dbgInLowPacketStress){
/*
* We are entering low-packet stress.
* Repeated debug spew can slow the system and actually
* keep the system from recovering the packets.
* So only spew a warning once.
*/
DBGWARN(("low on free packets (%d free, %d reads, %d writes, %d indicated)", adapter->numFreePackets, adapter->numActiveReadPackets, adapter->numActiveWritePackets, adapter->numIndicatedReadPackets));
adapter->dbgInLowPacketStress = TRUE;
}
}
#endif
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
return packet;
}
VOID EnqueuePendingReadPacket(USBPACKET *packet)
{
ADAPTEREXT *adapter = packet->adapter;
KIRQL oldIrql;
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
ASSERT(IsListEmpty(&packet->listEntry));
InsertTailList(&adapter->usbPendingReadPackets, &packet->listEntry);
#if DBG
packet->timeStamp = DbgGetSystemTime_msec();
#endif
adapter->numActiveReadPackets++;
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
}
/*
* DequeuePendingReadPacket
*
*/
VOID DequeuePendingReadPacket(USBPACKET *packet)
{
ADAPTEREXT *adapter = packet->adapter;
KIRQL oldIrql;
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
ASSERT(!IsListEmpty(&adapter->usbPendingReadPackets));
ASSERT(!IsListEmpty(&packet->listEntry));
RemoveEntryList(&packet->listEntry);
ASSERT(packet->sig == DRIVER_SIG);
InitializeListHead(&packet->listEntry);
ASSERT(adapter->numActiveReadPackets > 0);
adapter->numActiveReadPackets--;
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
}
VOID EnqueuePendingWritePacket(USBPACKET *packet)
{
ADAPTEREXT *adapter = packet->adapter;
KIRQL oldIrql;
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
ASSERT(IsListEmpty(&packet->listEntry));
InsertTailList(&adapter->usbPendingWritePackets, &packet->listEntry);
adapter->numActiveWritePackets++;
ASSERT(adapter->numActiveWritePackets <= USB_PACKET_POOL_SIZE);
#if DBG
packet->timeStamp = DbgGetSystemTime_msec();
#endif
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
}
/*
* DequeuePendingWritePacket
*
* Return either the indicated packet or the first packet in the pending queue.
*/
VOID DequeuePendingWritePacket(USBPACKET *packet)
{
ADAPTEREXT *adapter = packet->adapter;
KIRQL oldIrql;
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
ASSERT(!IsListEmpty(&adapter->usbPendingWritePackets));
ASSERT(!IsListEmpty(&packet->listEntry));
RemoveEntryList(&packet->listEntry);
ASSERT(adapter->numActiveWritePackets > 0);
adapter->numActiveWritePackets--;
ASSERT(packet->sig == DRIVER_SIG);
InitializeListHead(&packet->listEntry);
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
}
VOID EnqueueCompletedReadPacket(USBPACKET *packet)
{
ADAPTEREXT *adapter = packet->adapter;
KIRQL oldIrql;
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
ASSERT(IsListEmpty(&packet->listEntry));
InsertTailList(&adapter->usbCompletedReadPackets, &packet->listEntry);
#if DBG
packet->timeStamp = DbgGetSystemTime_msec();
#endif
adapter->numIndicatedReadPackets++;
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
}
VOID DequeueCompletedReadPacket(USBPACKET *packet)
{
ADAPTEREXT *adapter = packet->adapter;
KIRQL oldIrql;
PLIST_ENTRY listEntry;
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
ASSERT(!IsListEmpty(&adapter->usbCompletedReadPackets));
ASSERT(!IsListEmpty(&packet->listEntry));
RemoveEntryList(&packet->listEntry);
InitializeListHead(&packet->listEntry);
ASSERT(adapter->numIndicatedReadPackets > 0);
adapter->numIndicatedReadPackets--;
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
}
VOID CancelAllPendingPackets(ADAPTEREXT *adapter)
{
PLIST_ENTRY listEntry;
USBPACKET *packet;
PIRP irp;
KIRQL oldIrql;
ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
/*
* Cancel all pending READs.
*/
while (!IsListEmpty(&adapter->usbPendingReadPackets)){
listEntry = RemoveHeadList(&adapter->usbPendingReadPackets);
packet = CONTAINING_RECORD(listEntry, USBPACKET, listEntry);
irp = packet->irpPtr;
ASSERT(packet->sig == DRIVER_SIG);
/*
* Leave the IRP in the list when we cancel it so that completion routine
* can move it to the free list.
*/
InsertTailList(&adapter->usbPendingReadPackets, &packet->listEntry);
KeInitializeEvent(&packet->cancelEvent, NotificationEvent, FALSE);
ASSERT(!packet->cancelled);
packet->cancelled = TRUE;
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
DBGVERBOSE((" - cancelling pending read packet #%xh @ %ph, irp=%ph ...", packet->packetId, packet, irp));
IoCancelIrp(irp);
/*
* Wait for the completion routine to run and set the cancelEvent.
* By the time we get done waiting, the packet should be back in the free list.
*/
KeWaitForSingleObject(&packet->cancelEvent, Executive, KernelMode, FALSE, NULL);
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
}
ASSERT(IsListEmpty(&adapter->usbPendingReadPackets));
/*
* Cancel all pending WRITEs.
*/
while (!IsListEmpty(&adapter->usbPendingWritePackets)){
listEntry = RemoveHeadList(&adapter->usbPendingWritePackets);
packet = CONTAINING_RECORD(listEntry, USBPACKET, listEntry);
irp = packet->irpPtr;
ASSERT(packet->sig == DRIVER_SIG);
/*
* Leave the IRP in the list when we cancel it so that completion routine
* can move it to the free list.
*/
InsertTailList(&adapter->usbPendingWritePackets, &packet->listEntry);
KeInitializeEvent(&packet->cancelEvent, NotificationEvent, FALSE);
ASSERT(!packet->cancelled);
packet->cancelled = TRUE;
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
DBGVERBOSE((" - cancelling pending write packet #%xh @ %ph, irp=%ph ...", packet->packetId, packet, irp));
IoCancelIrp(irp);
/*
* Wait for the completion routine to run and set the cancelEvent.
* By the time we get done waiting, the packet should be back in the free list.
*/
KeWaitForSingleObject(&packet->cancelEvent, Executive, KernelMode, FALSE, NULL);
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
}
ASSERT(IsListEmpty(&adapter->usbPendingWritePackets));
/*
* Cancel the read on the NOTIFY pipe.
*/
if (adapter->notifyPipeHandle){
/*
* Make sure we've actually sent the notify irp before trying
* to cancel it; otherwise, we hang forever waiting for it to complete.
*/
if (adapter->initialized){
if (adapter->notifyStopped){
/*
* The notify irp has already stopped looping because it returned with error
* in NotificationCompletion. Don't cancel it because we'll hang forever
* waiting for it to complete.
*/
DBGVERBOSE(("CancelAllPendingPackets: notify irp already stopped, no need to cancel"));
}
else {
KeInitializeEvent(&adapter->notifyCancelEvent, NotificationEvent, FALSE);
adapter->cancellingNotify = TRUE;
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
DBGVERBOSE((" - cancelling notify irp = %ph ...", adapter->notifyIrpPtr));
IoCancelIrp(adapter->notifyIrpPtr);
KeWaitForSingleObject(&adapter->notifyCancelEvent, Executive, KernelMode, FALSE, NULL);
KeAcquireSpinLock(&adapter->adapterSpinLock, &oldIrql);
adapter->cancellingNotify = FALSE;
}
}
}
adapter->readDeficit = 0;
KeReleaseSpinLock(&adapter->adapterSpinLock, oldIrql);
}