SshInterceptorIoDevice
ssh_interceptor_iodevice_alloc(SshInterceptor interceptor,
const unsigned char *device_name,
Boolean exclusive_access,
SshInterceptorIoDeviceStatusCB status_cb,
SshInterceptorIoDeviceReceiveCB receive_cb,
void *callback_context)
{
SshInterceptorIoDevice io_dev = NULL;
UINT i;
SSH_DEBUG(SSH_D_HIGHSTART,
("Allocating I/O device object '%s'", device_name));
/* Create device object */
io_dev = ssh_calloc(1, sizeof(*io_dev));
if (io_dev == NULL)
{
SSH_DEBUG(SSH_D_FAIL,("Memory allocation failed"));
return NULL;
}
io_dev->notify_event = CreateEvent(NULL, FALSE, FALSE, NULL);
if (io_dev->notify_event == NULL)
{
SSH_DEBUG(SSH_D_FAIL,("Failed to create event object"));
ssh_free(io_dev);
return NULL;
}
/* Initialize variables allocated in the device extension area */
io_dev->open = 0;
io_dev->cancel_io = 0;
io_dev->status_cb = status_cb;
io_dev->receive_cb = receive_cb;
io_dev->cb_context = callback_context;
NdisInitializeListHead(&io_dev->output_queue);
NdisInitializeListHead(&io_dev->unreliable_output_queue);
NdisAllocateSpinLock(&io_dev->output_queue_lock);
NdisInitializeListHead(&io_dev->free_list);
NdisAllocateSpinLock(&io_dev->free_list_lock);
/* Initialize the read critical section. */
InitializeCriticalSection(&io_dev->read_cs);
/* Pre-allocate some "free" SshDeviceBuffers */
for (i = 0; i < SSH_IODEVICE_QUEUE_SIZE; i++)
{
SshDeviceBuffer buf = &(io_dev->pre_allocated_buffers[i]);
buf->pre_allocated = 1;
InsertTailList(&io_dev->free_list, &buf->link);
}
SSH_ASSERT(interceptor->ipm_device == NULL);
interceptor->ipm_device = io_dev;
return io_dev;
}
static NDIS_STATUS
VenetSetupAdapter(PADAPTER a)
{
NDIS_STATUS rc;
NDIS_TIMER_CHARACTERISTICS timer;
a->lookAhead = NIC_MAX_LOOKAHEAD;
a->numTcbs = NIC_MAX_BUSY_SENDS;
a->refCount = 1;
VENET_SET_FLAG(a, VNET_DISCONNECTED);
QueueInit(&a->sendQueue);
NdisInitializeListHead(&a->recvFreeList);
NdisInitializeListHead(&a->recvToProcess);
NdisInitializeListHead(&a->tcbFree);
NdisInitializeListHead(&a->tcbBusy);
NdisAllocateSpinLock(&a->lock);
NdisAllocateSpinLock(&a->recvLock);
NdisAllocateSpinLock(&a->sendLock);
NdisInitializeEvent(&a->removeEvent);
NdisInitializeEvent(&a->sendEvent);
/* We use the opposite sense of the sendEvent,
* SET == No Tx in use
* UNSET == Tx in use
*/
NdisInitializeEvent(&a->sendEvent);
NdisSetEvent(&a->sendEvent);
/* Create Rest and receive timers. */
NdisZeroMemory(&timer, sizeof(NDIS_TIMER_CHARACTERISTICS));
timer.Header.Type = NDIS_OBJECT_TYPE_TIMER_CHARACTERISTICS;
timer.Header.Revision = NDIS_TIMER_CHARACTERISTICS_REVISION_1;
timer.Header.Size = sizeof(NDIS_TIMER_CHARACTERISTICS);
timer.AllocationTag = VNET;
timer.TimerFunction = VenetResetTimerDpc;
timer.FunctionContext = a;
rc = NdisAllocateTimerObject(a->adapterHandle, &timer, &a->resetTimer);
if (rc != NDIS_STATUS_SUCCESS)
goto done;
timer.TimerFunction = VenetReceiveTimerDpc;
rc = NdisAllocateTimerObject(a->adapterHandle, &timer, &a->recvTimer);
if (rc != NDIS_STATUS_SUCCESS)
goto done;
done:
return rc;
}
/*
Cancel routine for queued read operations initiated by user-mode daemons.
*/
void
ssh_interceptor_iodevice_cancel_queued_read(PDEVICE_OBJECT device,
PIRP irp)
{
SshInterceptorIoDevice io_dev;
PLIST_ENTRY entry, next_entry;
LIST_ENTRY cancelled_irps;
/* Cancel processing is protected by queue-specific lock, not by the (one
and only) system-wide Cancel lock */
IoReleaseCancelSpinLock(irp->CancelIrql);
io_dev = SSH_NTDEV_TO_SSHDEV(device);
NdisInitializeListHead(&cancelled_irps);
SSH_DEBUG(SSH_D_MIDSTART,
("ssh_interceptor_iodevice_cancel_queued_read()"));
/* Find and dequeue all canceled IRPs (not just the one given as argument).
Complete the IRPs after releasing the spin lock. */
NdisAcquireSpinLock(&io_dev->read_queue_lock);
entry = io_dev->read_queue.Flink;
while (entry && (entry != &io_dev->read_queue))
{
next_entry = entry->Flink;
irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.ListEntry);
if (irp->Cancel)
{
RemoveEntryList(entry);
InsertTailList(&cancelled_irps, entry);
}
entry = next_entry;
}
NdisReleaseSpinLock(&io_dev->read_queue_lock);
while (!IsListEmpty(&cancelled_irps))
{
entry = RemoveHeadList(&cancelled_irps);
irp = CONTAINING_RECORD(entry, IRP, Tail.Overlay.ListEntry);
irp->IoStatus.Status = STATUS_CANCELLED;
irp->IoStatus.Information = 0;
IoCompleteRequest(irp, IO_NO_INCREMENT);
SSH_DEBUG(SSH_D_NICETOKNOW,
("IoCompleteRequest(irp = 0x%p, status = STATUS_CANCELLED)",
irp));
};
}
void _rtw_init_listhead(_list *list)
{
#ifdef PLATFORM_LINUX
INIT_LIST_HEAD(list);
#endif
#ifdef PLATFORM_WINDOWS
NdisInitializeListHead(list);
#endif
}
void _rtw_init_listhead(_list *list)
{
#ifdef PLATFORM_LINUX
INIT_LIST_HEAD(list);
#endif
#ifdef PLATFORM_FREEBSD
list->next = list;
list->prev = list;
#endif
#ifdef PLATFORM_WINDOWS
NdisInitializeListHead(list);
#endif
}
VOID tapAdapterContextRemoveFromGlobalList(__in PTAP_ADAPTER_CONTEXT Adapter) {
LOCK_STATE lockState;
// Acquire global adapter list lock.
NdisAcquireReadWriteLock(&GlobalData.Lock,
TRUE, // Acquire for write
&lockState);
// Remove the adapter context from the global list.
RemoveEntryList(&Adapter->AdapterListLink);
// Safe for multiple removes.
NdisInitializeListHead(&Adapter->AdapterListLink);
// Remove reference added in tapAdapterContextAddToGlobalList.
tapAdapterContextDereference(Adapter);
// Release global adapter list lock.
NdisReleaseReadWriteLock(&GlobalData.Lock, &lockState);
}
NDIS_STATUS
HelperPortInitializeBSSList(
__in PMP_HELPER_PORT HelperPort
)
{
PMP_BSS_LIST BSSList = &(HelperPort->BSSList);
NDIS_STATUS ndisStatus;
ndisStatus = MP_ALLOCATE_READ_WRITE_LOCK(&(BSSList->ListLock), HELPPORT_GET_MP_PORT(HelperPort)->MiniportAdapterHandle);
if (ndisStatus != NDIS_STATUS_SUCCESS)
{
return ndisStatus;
}
BSSList->MaxNumOfBSSEntries = HelperPort->RegInfo->BSSEntryMaxCount;
BSSList->NumOfBSSEntries = 0;
NdisInitializeListHead(&BSSList->List);
return NDIS_STATUS_SUCCESS;
NTSTATUS
DriverEntry(
__in PDRIVER_OBJECT DriverObject,
__in PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
In the context of its DriverEntry function, a miniport driver associates
itself with NDIS, specifies the NDIS version that it is using, and
registers its entry points.
Arguments:
PVOID DriverObject - pointer to the driver object.
PVOID RegistryPath - pointer to the driver registry path.
Return Value:
NTSTATUS code
--*/
{
NTSTATUS status;
UNREFERENCED_PARAMETER(RegistryPath);
DEBUGP (("[TAP] --> DriverEntry; version [%d.%d] %s %s\n",
TAP_DRIVER_MAJOR_VERSION,
TAP_DRIVER_MINOR_VERSION,
__DATE__,
__TIME__));
DEBUGP (("[TAP] Registry Path: '%wZ'\n", RegistryPath));
//
// Initialize any driver-global variables here.
//
NdisZeroMemory(&GlobalData, sizeof(GlobalData));
//
// The ApaterList in the GlobalData structure is used to track multiple
// adapters controlled by this miniport.
//
NdisInitializeListHead(&GlobalData.AdapterList);
//
// This lock protects the AdapterList.
//
NdisInitializeReadWriteLock(&GlobalData.Lock);
do
{
NDIS_MINIPORT_DRIVER_CHARACTERISTICS miniportCharacteristics;
NdisZeroMemory(&miniportCharacteristics, sizeof(miniportCharacteristics));
{C_ASSERT(sizeof(miniportCharacteristics) >= NDIS_SIZEOF_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2);}
miniportCharacteristics.Header.Type = NDIS_OBJECT_TYPE_MINIPORT_DRIVER_CHARACTERISTICS;
miniportCharacteristics.Header.Size = NDIS_SIZEOF_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2;
miniportCharacteristics.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_2;
miniportCharacteristics.MajorNdisVersion = TAP_NDIS_MAJOR_VERSION;
miniportCharacteristics.MinorNdisVersion = TAP_NDIS_MINOR_VERSION;
miniportCharacteristics.MajorDriverVersion = TAP_DRIVER_MAJOR_VERSION;
miniportCharacteristics.MinorDriverVersion = TAP_DRIVER_MINOR_VERSION;
miniportCharacteristics.Flags = 0;
//miniportCharacteristics.SetOptionsHandler = MPSetOptions; // Optional
miniportCharacteristics.InitializeHandlerEx = AdapterCreate;
miniportCharacteristics.HaltHandlerEx = AdapterHalt;
miniportCharacteristics.UnloadHandler = TapDriverUnload;
miniportCharacteristics.PauseHandler = AdapterPause;
miniportCharacteristics.RestartHandler = AdapterRestart;
miniportCharacteristics.OidRequestHandler = AdapterOidRequest;
miniportCharacteristics.SendNetBufferListsHandler = AdapterSendNetBufferLists;
miniportCharacteristics.ReturnNetBufferListsHandler = AdapterReturnNetBufferLists;
miniportCharacteristics.CancelSendHandler = AdapterCancelSend;
miniportCharacteristics.CheckForHangHandlerEx = AdapterCheckForHangEx;
miniportCharacteristics.ResetHandlerEx = AdapterReset;
miniportCharacteristics.DevicePnPEventNotifyHandler = AdapterDevicePnpEventNotify;
miniportCharacteristics.ShutdownHandlerEx = AdapterShutdownEx;
miniportCharacteristics.CancelOidRequestHandler = AdapterCancelOidRequest;
//
// Associate the miniport driver with NDIS by calling the
// NdisMRegisterMiniportDriver. This function returns an NdisDriverHandle.
// The miniport driver must retain this handle but it should never attempt
// to access or interpret this handle.
//
// By calling NdisMRegisterMiniportDriver, the driver indicates that it
// is ready for NDIS to call the driver's MiniportSetOptions and
// MiniportInitializeEx handlers.
//
DEBUGP (("[TAP] Calling NdisMRegisterMiniportDriver...\n"));
//NDIS_DECLARE_MINIPORT_DRIVER_CONTEXT(TAP_GLOBAL);
status = NdisMRegisterMiniportDriver(
DriverObject,
RegistryPath,
&GlobalData,
&miniportCharacteristics,
&GlobalData.NdisDriverHandle
);
if (NDIS_STATUS_SUCCESS == status)
{
DEBUGP (("[TAP] Registered miniport successfully\n"));
}
else
{
DEBUGP(("[TAP] NdisMRegisterMiniportDriver failed: %8.8X\n", status));
TapDriverUnload(DriverObject);
status = NDIS_STATUS_FAILURE;
break;
}
} while(FALSE);
DEBUGP (("[TAP] <-- DriverEntry; status = %8.8X\n",status));
return status;
}
NDIS_STATUS NICAllocAdapter(
PMP_ADAPTER *pAdapter)
{
PMP_ADAPTER Adapter = NULL;
PNDIS_PACKET Packet;
PNDIS_BUFFER Buffer;
PUCHAR pTCBMem;
PTCB pTCB;
NDIS_STATUS Status;
LONG index;
DEBUGP(MP_TRACE, ("--> NICAllocAdapter\n"));
PAGED_CODE();
*pAdapter = NULL;
do
{
//
// Allocate memory for adapter context
//
Status = NdisAllocateMemoryWithTag(
&Adapter,
sizeof(MP_ADAPTER),
NIC_TAG);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("Failed to allocate memory for adapter context\n"));
break;
}
//
// Zero the memory block
//
NdisZeroMemory(Adapter, sizeof(MP_ADAPTER));
NdisInitializeListHead(&Adapter->List);
//
// Initialize Send & Recv listheads and corresponding
// spinlocks.
//
//NdisInitializeListHead(&Adapter->RecvWaitList);
//NdisInitializeListHead(&Adapter->SendWaitList);
//NdisInitializeListHead(&Adapter->SendFreeList);
NdisAllocateSpinLock(&Adapter->SendLock);
//NdisInitializeListHead(&Adapter->RecvFreeList);
NdisAllocateSpinLock(&Adapter->RecvLock);
//allocate a packet pool
NdisAllocatePacketPool(
&Status,
&Adapter->LdnRecvPacketPoolHandle,
1,
PROTOCOL_RESERVED_SIZE_IN_PACKET);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocatePacketPool failed\n"));
break;
}
//allocate a single packet in the pool
NdisAllocatePacket(
&Status,
&Adapter->LdnRecvPacket,
Adapter->LdnRecvPacketPoolHandle);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocatePacket failed\n"));
break;
}
//allocate a buffer pool
NdisAllocateBufferPool(
&Status,
&Adapter->LdnRecvBufferPoolHandle,
1);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocateBufferPool for recv buffer failed\n"));
break;
}
//allocate a single buffer in the buffer pool
NdisAllocateBuffer(
&Status,
&Adapter->LdnRecvPacketBuffer,
Adapter->LdnRecvBufferPoolHandle,
(PVOID)&Adapter->LdnRecvPacketBufferData[0],
NIC_BUFFER_SIZE);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocateBuffer failed\n"));
break;
}
//chain the buffer to the packet
NdisChainBufferAtBack(Adapter->LdnRecvPacket,
Adapter->LdnRecvPacketBuffer);
NDIS_SET_PACKET_STATUS(Adapter->LdnRecvPacket, NDIS_STATUS_RESOURCES);
NDIS_SET_PACKET_HEADER_SIZE(Adapter->LdnRecvPacket, ETH_HEADER_SIZE);
/*//
// Allocate lookside list for Receive Control blocks.
//
NdisInitializeNPagedLookasideList(
&Adapter->RecvLookaside,
NULL, // No Allocate function
NULL, // No Free function
0, // Reserved for system use
sizeof(RCB),
NIC_TAG,
0); // Reserved for system use
MP_SET_FLAG(Adapter, fMP_ADAPTER_RECV_LOOKASIDE);
//
// Allocate packet pool for receive indications
//
NdisAllocatePacketPool(
&Status,
&Adapter->RecvPacketPoolHandle,
NIC_MAX_BUSY_RECVS,
PROTOCOL_RESERVED_SIZE_IN_PACKET);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocatePacketPool failed\n"));
break;
}
//
// Initialize receive packets
//
for(index=0; index < NIC_MAX_BUSY_RECVS; index++)
{
//
// Allocate a packet descriptor for receive packets
// from a preallocated pool.
//
NdisAllocatePacket(
&Status,
&Packet,
Adapter->RecvPacketPoolHandle);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocatePacket failed\n"));
break;
}
NDIS_SET_PACKET_HEADER_SIZE(Packet, ETH_HEADER_SIZE);
//
// Insert it into the list of free receive packets.
//
NdisInterlockedInsertTailList(
&Adapter->RecvFreeList,
(PLIST_ENTRY)&Packet->MiniportReserved[0],
&Adapter->RecvLock);
}
//
// Allocate a huge block of memory for all TCB's
//
Status = NdisAllocateMemoryWithTag(
&pTCBMem,
sizeof(TCB) * NIC_MAX_BUSY_SENDS,
NIC_TAG);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("Failed to allocate memory for TCB's\n"));
break;
}
NdisZeroMemory(pTCBMem, sizeof(TCB) * NIC_MAX_BUSY_SENDS);
Adapter->TCBMem = pTCBMem;
//
// Allocate a buffer pool for send buffers.
//
NdisAllocateBufferPool(
&Status,
&Adapter->SendBufferPoolHandle,
NIC_MAX_BUSY_SENDS);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocateBufferPool for send buffer failed\n"));
break;
}
//
// Divide the TCBMem blob into TCBs and create a buffer
// descriptor for the Data portion of the TCBs.
//
for(index=0; index < NIC_MAX_BUSY_SENDS; index++)
{
pTCB = (PTCB) pTCBMem;
//
// Create a buffer descriptor for the Data portion of the TCBs.
// Buffer descriptors are nothing but MDLs on NT systems.
//
NdisAllocateBuffer(
&Status,
&Buffer,
Adapter->SendBufferPoolHandle,
(PVOID)&pTCB->Data[0],
NIC_BUFFER_SIZE);
if(Status != NDIS_STATUS_SUCCESS)
{
DEBUGP(MP_ERROR, ("NdisAllocateBuffer failed\n"));
break;
}
//
// Initialize the TCB structure.
//
pTCB->Buffer = Buffer;
pTCB->pData = (PUCHAR) &pTCB->Data[0];
pTCB->Adapter = Adapter;
NdisInterlockedInsertTailList(
&Adapter->SendFreeList,
&pTCB->List,
&Adapter->SendLock);
pTCBMem = pTCBMem + sizeof(TCB);
}*/
} while(FALSE);
*pAdapter = Adapter;
//
// In the failure case, the caller of this routine will end up
// calling NICFreeAdapter to free all the successfully allocated
// resources.
//
DEBUGP(MP_TRACE, ("<-- NICAllocAdapter\n"));
return(Status);
}
SshInterceptorIoDevice
ssh_interceptor_iodevice_alloc(SshInterceptor interceptor,
const unsigned char *device_name,
Boolean exclusive_access,
SshInterceptorIoDeviceStatusCB status_cb,
SshInterceptorIoDeviceReceiveCB receive_cb,
void *callback_context)
{
SshInterceptorIoDevice io_dev;
SSH_DEBUG(SSH_D_HIGHSTART,
("Allocating I/O device object '%s'", device_name));
/* Allocate memory for I/O device object */
io_dev = ssh_calloc(1, sizeof(*io_dev));
if (io_dev != NULL)
{
SshTCBStruct tcb;
UINT i;
io_dev->opened_instances = 0;
io_dev->destroy_after_close = FALSE;
NdisInitializeListHead(&io_dev->read_queue);
NdisAllocateSpinLock(&io_dev->read_queue_lock);
NdisInitializeListHead(&io_dev->output_queue);
NdisInitializeListHead(&io_dev->unreliable_output_queue);
NdisAllocateSpinLock(&io_dev->output_queue_lock);
NdisInitializeListHead(&io_dev->free_list);
NdisAllocateSpinLock(&io_dev->free_list_lock);
#ifdef HAS_IOCTL_HANDLERS
NdisInitializeListHead(&io_dev->ioctl_handler_list);
NdisInitializeListHead(&io_dev->active_ioctl_req_list);
NdisAllocateSpinLock(&io_dev->ioctl_handler_list_lock);
NdisAllocateSpinLock(&io_dev->ioctl_req_list_lock);
#endif /* HAS_IOCTL_HANDLERS */
io_dev->current_read_buf = NULL;
/* Pre-allocate some "free" SshDeviceBuffers */
for (i = 0; i < SSH_IODEVICE_QUEUE_SIZE; i++)
{
SshDeviceBuffer buf = &(io_dev->pre_allocated_buffers[i]);
buf->pre_allocated = 1;
InsertTailList(&io_dev->free_list, &buf->link);
}
/* Initialize worker thread. */
NdisZeroMemory(&tcb, sizeof(tcb));
tcb.priority = SSH_TASK_PRIORITY_NOCHANGE;
tcb.exec_type = SSH_TASK_TYPE_EVENT_MONITOR;
tcb.period_ms = SSH_TASK_EVENT_WAIT_INFINITE;
if (!ssh_task_init(&io_dev->worker_thread,
SSH_IODEVICE_THREAD_ID,
ssh_interceptor_iodevice_do_reads,
io_dev, &tcb))
{
SSH_DEBUG(SSH_D_FAIL, ("Failed to initialize worker thread"));
ssh_interceptor_iodevice_free(io_dev);
return NULL;
}
/* Create device name */
if (!ssh_iodevice_name_compose(&io_dev->device_name,
"\\Device\\", device_name))
{
SSH_DEBUG(SSH_D_FAIL, ("Failed to compose device name!"));
ssh_interceptor_iodevice_free(io_dev);
return NULL;
}
/* Create symbolic link name */
if (!ssh_iodevice_name_compose(&io_dev->symlink_name,
"\\??\\", device_name))
{
SSH_DEBUG(SSH_D_FAIL, ("Failed to compose symbolic link name!"));
ssh_interceptor_iodevice_free(io_dev);
return NULL;
}
SSH_ASSERT(interceptor->ipm_device == NULL);
interceptor->ipm_device = io_dev;
io_dev->interceptor = interceptor;
io_dev->exclusive_access = exclusive_access;
io_dev->status_cb = status_cb;
io_dev->receive_cb = receive_cb;
io_dev->cb_context = callback_context;
SSH_DEBUG(SSH_D_HIGHOK,
("I/O device object 0x%p successfully allocated and "
"initialized", io_dev));
}
else
{
SSH_DEBUG(SSH_D_FAIL,
("Failed to allocate memory for I/O device object!"));
}
return io_dev;
}
// Returns with reference count initialized to one.
PTAP_ADAPTER_CONTEXT
tapAdapterContextAllocate(__in NDIS_HANDLE MiniportAdapterHandle) {
PTAP_ADAPTER_CONTEXT adapter = NULL;
adapter = (PTAP_ADAPTER_CONTEXT)NdisAllocateMemoryWithTagPriority(
GlobalData.NdisDriverHandle, sizeof(TAP_ADAPTER_CONTEXT), TAP_ADAPTER_TAG,
NormalPoolPriority);
if (adapter) {
NET_BUFFER_LIST_POOL_PARAMETERS nblPoolParameters = {0};
NdisZeroMemory(adapter, sizeof(TAP_ADAPTER_CONTEXT));
adapter->MiniportAdapterHandle = MiniportAdapterHandle;
// Initialize cancel-safe IRP queue
tapIrpCsqInitialize(&adapter->PendingReadIrpQueue);
// Initialize TAP send packet queue.
tapPacketQueueInitialize(&adapter->SendPacketQueue);
// Allocate the adapter lock.
NdisAllocateSpinLock(&adapter->AdapterLock);
// NBL pool for making TAP receive indications.
NdisZeroMemory(&nblPoolParameters, sizeof(NET_BUFFER_LIST_POOL_PARAMETERS));
// Initialize event used to determine when all receive NBLs have been returned.
NdisInitializeEvent(&adapter->ReceiveNblInFlightCountZeroEvent);
nblPoolParameters.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
nblPoolParameters.Header.Revision = NET_BUFFER_LIST_POOL_PARAMETERS_REVISION_1;
nblPoolParameters.Header.Size = NDIS_SIZEOF_NET_BUFFER_LIST_POOL_PARAMETERS_REVISION_1;
nblPoolParameters.ProtocolId = NDIS_PROTOCOL_ID_DEFAULT;
nblPoolParameters.ContextSize = 0;
// nblPoolParameters.ContextSize = sizeof(RX_NETBUFLIST_RSVD);
nblPoolParameters.fAllocateNetBuffer = TRUE;
nblPoolParameters.PoolTag = TAP_RX_NBL_TAG;
#pragma warning(suppress : 28197)
adapter->ReceiveNblPool =
NdisAllocateNetBufferListPool(adapter->MiniportAdapterHandle, &nblPoolParameters);
if (adapter->ReceiveNblPool == NULL) {
DEBUGP(("[TAP] Couldn't allocate adapter receive NBL pool\n"));
NdisFreeMemory(adapter, 0, 0);
}
// Add initial reference. Normally removed in AdapterHalt.
adapter->RefCount = 1;
// Safe for multiple removes.
NdisInitializeListHead(&adapter->AdapterListLink);
//
// The miniport adapter is initially powered up
//
adapter->CurrentPowerState = NdisDeviceStateD0;
}
return adapter;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
First entry point to be called, when this driver is loaded.
Register with NDIS as an intermediate driver.
Arguments:
DriverObject - pointer to the system's driver object structure
for this driver
RegistryPath - system's registry path for this driver
Return Value:
STATUS_SUCCESS if all initialization is successful, STATUS_XXX
error code if not.
--*/
{
NDIS_STATUS Status;
NDIS_PROTOCOL_DRIVER_CHARACTERISTICS PChars;
NDIS_MINIPORT_DRIVER_CHARACTERISTICS MChars;
NDIS_HANDLE MiniportDriverContext;
NDIS_HANDLE ProtocolDriverContext;
NDIS_STRING Name;
NdisInitializeListHead(&AdapterList);
NdisInitializeListHead(&VElanList);
MiniportDriverContext=NULL;
ProtocolDriverContext=NULL;
MUX_INIT_MUTEX(&GlobalMutex);
MUX_INIT_MUTEX(&ControlDeviceMutex);
NdisAllocateSpinLock(&GlobalLock);
do
{
//
// Register the miniport with NDIS. Note that it is the
// miniport which was started as a driver and not the protocol.
// Also the miniport must be registered prior to the protocol
// since the protocol's BindAdapter handler can be initiated
// anytime and when it is, it must be ready to
// start driver instances.
//
NdisZeroMemory(&MChars, sizeof(NDIS_MINIPORT_DRIVER_CHARACTERISTICS));
MChars.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
MChars.Header.Size = sizeof(NDIS_MINIPORT_DRIVER_CHARACTERISTICS);
MChars.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_1;
MChars.MajorNdisVersion = MUX_MAJOR_NDIS_VERSION;
MChars.MinorNdisVersion = MUX_MINOR_NDIS_VERSION;
MChars.MajorDriverVersion = MUX_MAJOR_DRIVER_VERSION;
MChars.MinorDriverVersion = MUX_MINOR_DRIVER_VERSION;
MChars.SetOptionsHandler = MpSetOptions;
MChars.InitializeHandlerEx = MPInitialize;
MChars.UnloadHandler = MPUnload;
MChars.HaltHandlerEx = MPHalt;
MChars.OidRequestHandler = MPOidRequest;
MChars.CancelSendHandler = MPCancelSendNetBufferLists;
MChars.DevicePnPEventNotifyHandler = MPDevicePnPEvent;
MChars.ShutdownHandlerEx = MPAdapterShutdown;
MChars.CancelOidRequestHandler = MPCancelOidRequest;
//
// We will disable the check for hang timeout so we do not
// need a check for hang handler!
//
MChars.CheckForHangHandlerEx = NULL;
MChars.ReturnNetBufferListsHandler = MPReturnNetBufferLists;
MChars.SendNetBufferListsHandler = MPSendNetBufferLists;
MChars.PauseHandler = MPPause;
MChars.RestartHandler = MPRestart;
MChars.Flags = NDIS_INTERMEDIATE_DRIVER;
Status = NdisMRegisterMiniportDriver(DriverObject,
RegistryPath,
MiniportDriverContext,
&MChars,
&DriverHandle);
if (Status != NDIS_STATUS_SUCCESS)
{
break;
}
//
// Now register the protocol.
//
NdisZeroMemory(&PChars, sizeof(NDIS_PROTOCOL_DRIVER_CHARACTERISTICS));
PChars.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
PChars.Header.Size = sizeof(NDIS_PROTOCOL_DRIVER_CHARACTERISTICS);
PChars.Header.Revision = NDIS_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_1;
PChars.MajorNdisVersion = MUX_PROT_MAJOR_NDIS_VERSION;
PChars.MinorNdisVersion = MUX_PROT_MINOR_NDIS_VERSION;
PChars.MajorDriverVersion = MUX_MAJOR_DRIVER_VERSION;
PChars.MinorDriverVersion = MUX_MINOR_DRIVER_VERSION;
PChars.SetOptionsHandler = PtSetOptions;
//
// Make sure the protocol-name matches the service-name
// (from the INF) under which this protocol is installed.
// This is needed to ensure that NDIS can correctly determine
// the binding and call us to bind to miniports below.
//
NdisInitUnicodeString(&Name, L"MUXP"); // Protocol name
PChars.Name = Name;
PChars.OpenAdapterCompleteHandlerEx = PtOpenAdapterComplete;
PChars.CloseAdapterCompleteHandlerEx = PtCloseAdapterComplete;
PChars.ReceiveNetBufferListsHandler = PtReceiveNBL;
PChars.SendNetBufferListsCompleteHandler = PtSendNBLComplete;
PChars.OidRequestCompleteHandler = PtRequestComplete;
PChars.StatusHandlerEx = PtStatus;
PChars.BindAdapterHandlerEx = PtBindAdapter;
PChars.UnbindAdapterHandlerEx = PtUnbindAdapter;
PChars.NetPnPEventHandler= PtPNPHandler;
Status = NdisRegisterProtocolDriver(ProtocolDriverContext,
&PChars,
&ProtHandle);
if (Status != NDIS_STATUS_SUCCESS)
{
NdisMDeregisterMiniportDriver(DriverHandle);
break;
}
//
// Let NDIS know of the association between our protocol
// and miniport entities.
//
NdisIMAssociateMiniport(DriverHandle, ProtHandle);
}while (FALSE);
return(Status);
}
VOID
NICFreeBusyRecvPackets(
PMP_ADAPTER Adapter
)
/*++
Routine Description:
This function tries to cancel all the outstanding read IRP if it is not
already completed and frees the RCB block. This routine is called
only by the Halt handler.
Arguments:
Adapter - pointer to the MP_ADAPTER structure
Return value:
VOID
--*/
{
PLIST_ENTRY pEntry = NULL;
PRCB pRCB = NULL;
DEBUGP(MP_TRACE, ("--> NICFreeBusyRecvPackets\n"));
if(!MP_TEST_FLAG(Adapter, fMP_RECV_SIDE_RESOURCE_ALLOCATED)){
return;
}
NdisAcquireSpinLock(&Adapter->RecvLock);
while(!IsListEmpty(&Adapter->RecvBusyList))
{
pEntry = (PLIST_ENTRY)RemoveHeadList(&Adapter->RecvBusyList);
pRCB = CONTAINING_RECORD(pEntry, RCB, List);
NdisInitializeListHead(&pRCB->List);
NdisReleaseSpinLock(&Adapter->RecvLock);
if (InterlockedExchange((PVOID)&pRCB->IrpLock, IRPLOCK_CANCEL_STARTED)
== IRPLOCK_CANCELABLE) {
//
// We got it to the IRP before it was completed. We can cancel
// the IRP without fear of losing it, as the completion routine
// will not let go of the IRP until we say so.
//
IoCancelIrp(pRCB->Irp);
//
// Release the completion routine. If it already got there,
// then we need to free it ourself. Otherwise, we got
// through IoCancelIrp before the IRP completed entirely.
//
if (InterlockedExchange((PVOID)&pRCB->IrpLock, IRPLOCK_CANCEL_COMPLETE)
== IRPLOCK_COMPLETED) {
if(NdisInterlockedDecrement(&pRCB->Ref) == 0) {
NICFreeRCB(pRCB);
} else {
ASSERTMSG("Only we have the right to free RCB\n", FALSE);
}
}
}
NdisAcquireSpinLock(&Adapter->RecvLock);
}
NdisReleaseSpinLock(&Adapter->RecvLock);
DEBUGP(MP_TRACE, ("<-- NICFreeBusyRecvPackets\n"));
return ;
}
NDIS_STATUS
DriverEntry(PVOID obj,PVOID path)
{
NDIS_STATUS rc;
NDIS_MINIPORT_DRIVER_CHARACTERISTICS c;
WDF_DRIVER_CONFIG dc;
NTSTATUS nrc;
WDFDRIVER fw_handle;
vlog("DriverEntry started");
if(NdisGetVersion() <
((VENET_NDIS_MAJOR_VERSION << 16) | VENET_NDIS_MINOR_VERSION)) {
vlog("Invalid version!");
return NDIS_STATUS_FAILURE;
}
WDF_DRIVER_CONFIG_INIT(&dc, WDF_NO_EVENT_CALLBACK);
dc.DriverInitFlags |= WdfDriverInitNoDispatchOverride;
nrc = WdfDriverCreate(obj, path, WDF_NO_OBJECT_ATTRIBUTES,
&dc, &fw_handle);
if(!NT_SUCCESS(nrc)) {
vlog("DriverEntry WdfDriverCreate: %d", nrc);
return NDIS_STATUS_FAILURE;
}
/* For multiple instances */
NdisInitializeListHead(&adapterList);
NdisAllocateSpinLock(&adapterListLock);
NdisZeroMemory(&c, sizeof(c));
c.Header.Type = NDIS_OBJECT_TYPE_MINIPORT_DRIVER_CHARACTERISTICS;
c.Header.Size = sizeof(NDIS_MINIPORT_DRIVER_CHARACTERISTICS);
c.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_1;
c.Flags = NDIS_WDM_DRIVER;
c.MajorNdisVersion = VENET_NDIS_MAJOR_VERSION;
c.MinorNdisVersion = VENET_NDIS_MINOR_VERSION;
c.MajorDriverVersion = VENET_MAJOR_VERSION;
c.MinorDriverVersion = VENET_MINOR_VERSION;
c.InitializeHandlerEx = VenetInitialize;
c.PauseHandler = VenetPause;
c.RestartHandler = VenetRestart;
c.ShutdownHandlerEx = VenetShutdown;
c.DevicePnPEventNotifyHandler = VenetDevicePnPEvent;
c.HaltHandlerEx = VenetHalt;
c.UnloadHandler = VenetUnload;
c.OidRequestHandler = VenetOidRequest;
c.CancelOidRequestHandler = VenetCancelOidRequest;
c.SetOptionsHandler = VenetSetOptions;
c.SendNetBufferListsHandler = VenetSendNetBufs;
c.CancelSendHandler = VenetCancelSend;
c.ReturnNetBufferListsHandler = VenetReturnNetBufs;
c.CheckForHangHandlerEx = VenetCheckHang;
c.ResetHandlerEx = VenetReset;
rc = NdisMRegisterMiniportDriver(obj, path, (PNDIS_HANDLE)
driver_context, &c, &mp_handle);
vlog("DriverEntry return rc = %d", rc);
return rc;
}
NDIS_STATUS
VenetInitialize(NDIS_HANDLE handle, NDIS_HANDLE driver_context,
PNDIS_MINIPORT_INIT_PARAMETERS params)
{
NDIS_STATUS rc = NDIS_STATUS_RESOURCES;
PADAPTER a = NULL;
UNREFERENCED_PARAMETER(driver_context);
UNREFERENCED_PARAMETER(params);
vlog("VenetInitialize started");
a = VenetAlloc(sizeof(ADAPTER));
if (!a)
goto err;
a->adapterHandle = handle;
NdisInitializeListHead(&a->list);
VenetAttach(a);
rc = VenetSetupAdapter(a);
if (rc != NDIS_STATUS_SUCCESS)
goto err;
vlog("interface");
rc = VenetGetInterface(handle, a);
if (rc != NDIS_STATUS_SUCCESS)
goto err;
vlog("rx");
rc = VenetSetupRx(a);
if (rc != NDIS_STATUS_SUCCESS)
goto err;
vlog("tx");
rc = VenetSetupTx(a);
if (rc != NDIS_STATUS_SUCCESS)
goto err;
vlog("mac");
rc = VenetGetMacAddress(a);
if (rc != NDIS_STATUS_SUCCESS)
goto err;
vlog("registry");
rc = VenetRegistryParams(a);
if (rc != NDIS_STATUS_SUCCESS)
goto err;
vlog("reg attr");
rc = VenetSetRegistrationAttributes(handle, a);
if (rc != NDIS_STATUS_SUCCESS)
goto err;
vlog("general attr");
rc = VenetSetGeneralAttributes(handle, a);
if (rc != NDIS_STATUS_SUCCESS)
goto err;
VENET_CLEAR_FLAG(a, VNET_DISCONNECTED);
vlog("VenetInitialize return SUCCESS");
return NDIS_STATUS_SUCCESS;
err:
vlog("VenetInitialize err return!!");
VenetHalt(a, 0);
return rc;
}
NDIS_STATUS
DriverEntry(
PVOID DriverObject,
PVOID RegistryPath)
{
HRESULT hr;
NDIS_STATUS status;
NDIS_MINIPORT_CHARACTERISTICS mpChar;
DEBUGP(MP_TRACE, ("[HT_STARTUP]---> DriverEntry built on "__DATE__" at "__TIME__
"MP_NDIS_MAJOR_VERSION=%d, MP_NDIS_MINOR_VERSION=%d\n",
MP_NDIS_MAJOR_VERSION, MP_NDIS_MINOR_VERSION));
//Associate miniport driver with NDIS
NdisMInitializeWrapper(
&NdisWrapperHandle,
DriverObject,
RegistryPath,
NULL
);
if(!NdisWrapperHandle){
DEBUGP(MP_ERROR, ("NdisMInitializeWrapper failed\n"));
return NDIS_STATUS_FAILURE;
}
NdisZeroMemory(&mpChar, sizeof(mpChar));
mpChar.MajorNdisVersion = MP_NDIS_MAJOR_VERSION;
mpChar.MinorNdisVersion = MP_NDIS_MINOR_VERSION;
mpChar.InitializeHandler = MPInitialize;
mpChar.HaltHandler = MPHalt;
mpChar.SetInformationHandler = MPSetInformation;
mpChar.QueryInformationHandler = MPQueryInformation;
mpChar.SendPacketsHandler = MPSendPackets;
mpChar.ReturnPacketHandler = MPReturnPacket;
#ifdef NDIS51_MINIPORT
mpChar.CancelSendPacketsHandler = MPCancelSendPackets;
mpChar.PnPEventNotifyHandler = MPPnPEventNotify;
mpChar.AdapterShutdownHandler = MPShutdown;
#endif
DEBUGP(MP_LOUD, ("[HT_STARTUP] Calling NdisMRegisterMiniport...\n"));
status = NdisMRegisterMiniport(
NdisWrapperHandle,
&mpChar,
sizeof(NDIS_MINIPORT_CHARACTERISTICS));
if (status != NDIS_STATUS_SUCCESS) {
DEBUGP(MP_ERROR, ("Status = 0x%08x\n", status));
NdisTerminateWrapper(NdisWrapperHandle, NULL);
}
else
{
NdisAllocateSpinLock(&GlobalData.Lock);
NdisInitializeListHead(&GlobalData.AdapterList);
NdisMRegisterUnloadHandler(NdisWrapperHandle, MPUnload);
}
DEBUGP(MP_TRACE, ("[HT_STARTUP]<--- DriverEntry, Status=0x%08x\n", status));
return status;
}
