3 * Copyright (c) 2009, Microsoft Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
16 * Place - Suite 330, Boston, MA 02111-1307 USA.
19 * Haiyang Zhang <haiyangz@microsoft.com>
20 * Hank Janssen <hjanssen@microsoft.com>
24 #include <linux/kernel.h>
26 #include "include/logging.h"
28 #include "include/NetVscApi.h"
29 #include "RndisFilter.h"
35 typedef struct _RNDIS_FILTER_DRIVER_OBJECT {
36 /* The original driver */
37 NETVSC_DRIVER_OBJECT InnerDriver;
39 } RNDIS_FILTER_DRIVER_OBJECT;
42 RNDIS_DEV_UNINITIALIZED = 0,
43 RNDIS_DEV_INITIALIZING,
44 RNDIS_DEV_INITIALIZED,
45 RNDIS_DEV_DATAINITIALIZED,
48 typedef struct _RNDIS_DEVICE {
49 struct NETVSC_DEVICE *NetDevice;
51 RNDIS_DEVICE_STATE State;
55 spinlock_t request_lock;
56 LIST_ENTRY RequestList;
58 unsigned char HwMacAddr[HW_MACADDR_LEN];
62 typedef struct _RNDIS_REQUEST {
66 /* FIXME: We assumed a fixed size response here. If we do ever need to handle a bigger response, */
67 /* we can either define a max response message or add a response buffer variable above this field */
68 RNDIS_MESSAGE ResponseMessage;
70 /* Simplify allocation by having a netvsc packet inline */
73 /* FIXME: We assumed a fixed size request here. */
74 RNDIS_MESSAGE RequestMessage;
78 typedef struct _RNDIS_FILTER_PACKET {
79 void *CompletionContext;
80 PFN_ON_SENDRECVCOMPLETION OnCompletion;
82 RNDIS_MESSAGE Message;
83 } RNDIS_FILTER_PACKET;
86 /* Internal routines */
89 RndisFilterSendRequest(
91 RNDIS_REQUEST *Request
95 RndisFilterReceiveResponse(
97 RNDIS_MESSAGE *Response
101 RndisFilterReceiveIndicateStatus(
102 RNDIS_DEVICE *Device,
103 RNDIS_MESSAGE *Response
107 RndisFilterReceiveData(
108 RNDIS_DEVICE *Device,
109 RNDIS_MESSAGE *Message,
110 NETVSC_PACKET *Packet
114 RndisFilterOnReceive(
115 DEVICE_OBJECT *Device,
116 NETVSC_PACKET *Packet
120 RndisFilterQueryDevice(
121 RNDIS_DEVICE *Device,
128 RndisFilterQueryDeviceMac(
133 RndisFilterQueryDeviceLinkStatus(
138 RndisFilterSetPacketFilter(
139 RNDIS_DEVICE *Device,
144 RndisFilterInitDevice(
149 RndisFilterOpenDevice(
154 RndisFilterCloseDevice(
159 RndisFilterOnDeviceAdd(
160 DEVICE_OBJECT *Device,
165 RndisFilterOnDeviceRemove(
166 DEVICE_OBJECT *Device
170 RndisFilterOnCleanup(
171 DRIVER_OBJECT *Driver
176 DEVICE_OBJECT *Device
181 DEVICE_OBJECT *Device
186 DEVICE_OBJECT *Device,
187 NETVSC_PACKET *Packet
191 RndisFilterOnSendCompletion(
196 RndisFilterOnSendRequestCompletion(
204 /* The one and only */
205 RNDIS_FILTER_DRIVER_OBJECT gRndisFilter;
207 static inline RNDIS_DEVICE* GetRndisDevice(void)
209 RNDIS_DEVICE *device;
211 device = kzalloc(sizeof(RNDIS_DEVICE), GFP_KERNEL);
217 spin_lock_init(&device->request_lock);
219 INITIALIZE_LIST_HEAD(&device->RequestList);
221 device->State = RNDIS_DEV_UNINITIALIZED;
226 static inline void PutRndisDevice(RNDIS_DEVICE *Device)
231 static inline RNDIS_REQUEST* GetRndisRequest(RNDIS_DEVICE *Device, u32 MessageType, u32 MessageLength)
233 RNDIS_REQUEST *request;
234 RNDIS_MESSAGE *rndisMessage;
235 RNDIS_SET_REQUEST *set;
238 request = kzalloc(sizeof(RNDIS_REQUEST), GFP_KERNEL);
244 request->WaitEvent = WaitEventCreate();
245 if (!request->WaitEvent)
251 rndisMessage = &request->RequestMessage;
252 rndisMessage->NdisMessageType = MessageType;
253 rndisMessage->MessageLength = MessageLength;
255 /* Set the request id. This field is always after the rndis header for request/response packet types so */
256 /* we just used the SetRequest as a template */
257 set = &rndisMessage->Message.SetRequest;
258 set->RequestId = InterlockedIncrement((int*)&Device->NewRequestId);
260 /* Add to the request list */
261 spin_lock_irqsave(&Device->request_lock, flags);
262 INSERT_TAIL_LIST(&Device->RequestList, &request->ListEntry);
263 spin_unlock_irqrestore(&Device->request_lock, flags);
268 static inline void PutRndisRequest(RNDIS_DEVICE *Device, RNDIS_REQUEST *Request)
272 spin_lock_irqsave(&Device->request_lock, flags);
273 REMOVE_ENTRY_LIST(&Request->ListEntry);
274 spin_unlock_irqrestore(&Device->request_lock, flags);
276 WaitEventClose(Request->WaitEvent);
280 static inline void DumpRndisMessage(RNDIS_MESSAGE *RndisMessage)
282 switch (RndisMessage->NdisMessageType)
284 case REMOTE_NDIS_PACKET_MSG:
285 DPRINT_DBG(NETVSC, "REMOTE_NDIS_PACKET_MSG (len %u, data offset %u data len %u, # oob %u, oob offset %u, oob len %u, pkt offset %u, pkt len %u",
286 RndisMessage->MessageLength,
287 RndisMessage->Message.Packet.DataOffset,
288 RndisMessage->Message.Packet.DataLength,
289 RndisMessage->Message.Packet.NumOOBDataElements,
290 RndisMessage->Message.Packet.OOBDataOffset,
291 RndisMessage->Message.Packet.OOBDataLength,
292 RndisMessage->Message.Packet.PerPacketInfoOffset,
293 RndisMessage->Message.Packet.PerPacketInfoLength);
296 case REMOTE_NDIS_INITIALIZE_CMPLT:
297 DPRINT_DBG(NETVSC, "REMOTE_NDIS_INITIALIZE_CMPLT (len %u, id 0x%x, status 0x%x, major %d, minor %d, device flags %d, max xfer size 0x%x, max pkts %u, pkt aligned %u)",
298 RndisMessage->MessageLength,
299 RndisMessage->Message.InitializeComplete.RequestId,
300 RndisMessage->Message.InitializeComplete.Status,
301 RndisMessage->Message.InitializeComplete.MajorVersion,
302 RndisMessage->Message.InitializeComplete.MinorVersion,
303 RndisMessage->Message.InitializeComplete.DeviceFlags,
304 RndisMessage->Message.InitializeComplete.MaxTransferSize,
305 RndisMessage->Message.InitializeComplete.MaxPacketsPerMessage,
306 RndisMessage->Message.InitializeComplete.PacketAlignmentFactor);
309 case REMOTE_NDIS_QUERY_CMPLT:
310 DPRINT_DBG(NETVSC, "REMOTE_NDIS_QUERY_CMPLT (len %u, id 0x%x, status 0x%x, buf len %u, buf offset %u)",
311 RndisMessage->MessageLength,
312 RndisMessage->Message.QueryComplete.RequestId,
313 RndisMessage->Message.QueryComplete.Status,
314 RndisMessage->Message.QueryComplete.InformationBufferLength,
315 RndisMessage->Message.QueryComplete.InformationBufferOffset);
318 case REMOTE_NDIS_SET_CMPLT:
319 DPRINT_DBG(NETVSC, "REMOTE_NDIS_SET_CMPLT (len %u, id 0x%x, status 0x%x)",
320 RndisMessage->MessageLength,
321 RndisMessage->Message.SetComplete.RequestId,
322 RndisMessage->Message.SetComplete.Status);
325 case REMOTE_NDIS_INDICATE_STATUS_MSG:
326 DPRINT_DBG(NETVSC, "REMOTE_NDIS_INDICATE_STATUS_MSG (len %u, status 0x%x, buf len %u, buf offset %u)",
327 RndisMessage->MessageLength,
328 RndisMessage->Message.IndicateStatus.Status,
329 RndisMessage->Message.IndicateStatus.StatusBufferLength,
330 RndisMessage->Message.IndicateStatus.StatusBufferOffset);
334 DPRINT_DBG(NETVSC, "0x%x (len %u)",
335 RndisMessage->NdisMessageType,
336 RndisMessage->MessageLength);
342 RndisFilterSendRequest(
343 RNDIS_DEVICE *Device,
344 RNDIS_REQUEST *Request
348 NETVSC_PACKET *packet;
350 DPRINT_ENTER(NETVSC);
352 /* Setup the packet to send it */
353 packet = &Request->Packet;
355 packet->IsDataPacket = false;
356 packet->TotalDataBufferLength = Request->RequestMessage.MessageLength;
357 packet->PageBufferCount = 1;
359 packet->PageBuffers[0].Pfn = GetPhysicalAddress(&Request->RequestMessage) >> PAGE_SHIFT;
360 packet->PageBuffers[0].Length = Request->RequestMessage.MessageLength;
361 packet->PageBuffers[0].Offset = (unsigned long)&Request->RequestMessage & (PAGE_SIZE -1);
363 packet->Completion.Send.SendCompletionContext = Request;/* packet; */
364 packet->Completion.Send.OnSendCompletion = RndisFilterOnSendRequestCompletion;
365 packet->Completion.Send.SendCompletionTid = (unsigned long)Device;
367 ret = gRndisFilter.InnerDriver.OnSend(Device->NetDevice->Device, packet);
374 RndisFilterReceiveResponse(
375 RNDIS_DEVICE *Device,
376 RNDIS_MESSAGE *Response
381 RNDIS_REQUEST *request=NULL;
385 DPRINT_ENTER(NETVSC);
387 spin_lock_irqsave(&Device->request_lock, flags);
388 ITERATE_LIST_ENTRIES(anchor, curr, &Device->RequestList)
390 request = CONTAINING_RECORD(curr, RNDIS_REQUEST, ListEntry);
392 /* All request/response message contains RequestId as the 1st field */
393 if (request->RequestMessage.Message.InitializeRequest.RequestId == Response->Message.InitializeComplete.RequestId)
395 DPRINT_DBG(NETVSC, "found rndis request for this response (id 0x%x req type 0x%x res type 0x%x)",
396 request->RequestMessage.Message.InitializeRequest.RequestId, request->RequestMessage.NdisMessageType, Response->NdisMessageType);
402 spin_unlock_irqrestore(&Device->request_lock, flags);
406 if (Response->MessageLength <= sizeof(RNDIS_MESSAGE))
408 memcpy(&request->ResponseMessage, Response, Response->MessageLength);
412 DPRINT_ERR(NETVSC, "rndis response buffer overflow detected (size %u max %lu)", Response->MessageLength, sizeof(RNDIS_FILTER_PACKET));
414 if (Response->NdisMessageType == REMOTE_NDIS_RESET_CMPLT) /* does not have a request id field */
416 request->ResponseMessage.Message.ResetComplete.Status = STATUS_BUFFER_OVERFLOW;
420 request->ResponseMessage.Message.InitializeComplete.Status = STATUS_BUFFER_OVERFLOW;
424 WaitEventSet(request->WaitEvent);
428 DPRINT_ERR(NETVSC, "no rndis request found for this response (id 0x%x res type 0x%x)",
429 Response->Message.InitializeComplete.RequestId, Response->NdisMessageType);
436 RndisFilterReceiveIndicateStatus(
437 RNDIS_DEVICE *Device,
438 RNDIS_MESSAGE *Response
441 RNDIS_INDICATE_STATUS *indicate = &Response->Message.IndicateStatus;
443 if (indicate->Status == RNDIS_STATUS_MEDIA_CONNECT)
445 gRndisFilter.InnerDriver.OnLinkStatusChanged(Device->NetDevice->Device, 1);
447 else if (indicate->Status == RNDIS_STATUS_MEDIA_DISCONNECT)
449 gRndisFilter.InnerDriver.OnLinkStatusChanged(Device->NetDevice->Device, 0);
458 RndisFilterReceiveData(
459 RNDIS_DEVICE *Device,
460 RNDIS_MESSAGE *Message,
461 NETVSC_PACKET *Packet
464 RNDIS_PACKET *rndisPacket;
467 DPRINT_ENTER(NETVSC);
469 /* empty ethernet frame ?? */
470 ASSERT(Packet->PageBuffers[0].Length > RNDIS_MESSAGE_SIZE(RNDIS_PACKET));
472 rndisPacket = &Message->Message.Packet;
474 /* FIXME: Handle multiple rndis pkt msgs that maybe enclosed in this */
475 /* netvsc packet (ie TotalDataBufferLength != MessageLength) */
477 /* Remove the rndis header and pass it back up the stack */
478 dataOffset = RNDIS_HEADER_SIZE + rndisPacket->DataOffset;
480 Packet->TotalDataBufferLength -= dataOffset;
481 Packet->PageBuffers[0].Offset += dataOffset;
482 Packet->PageBuffers[0].Length -= dataOffset;
484 Packet->IsDataPacket = true;
486 gRndisFilter.InnerDriver.OnReceiveCallback(Device->NetDevice->Device, Packet);
492 RndisFilterOnReceive(
493 DEVICE_OBJECT *Device,
494 NETVSC_PACKET *Packet
497 struct NETVSC_DEVICE *netDevice = (struct NETVSC_DEVICE*)Device->Extension;
498 RNDIS_DEVICE *rndisDevice;
499 RNDIS_MESSAGE rndisMessage;
500 RNDIS_MESSAGE *rndisHeader;
502 DPRINT_ENTER(NETVSC);
505 /* Make sure the rndis device state is initialized */
506 if (!netDevice->Extension)
508 DPRINT_ERR(NETVSC, "got rndis message but no rndis device...dropping this message!");
513 rndisDevice = (RNDIS_DEVICE*)netDevice->Extension;
514 if (rndisDevice->State == RNDIS_DEV_UNINITIALIZED)
516 DPRINT_ERR(NETVSC, "got rndis message but rndis device uninitialized...dropping this message!");
521 rndisHeader = (RNDIS_MESSAGE*)PageMapVirtualAddress(Packet->PageBuffers[0].Pfn);
523 rndisHeader = (void*)((unsigned long)rndisHeader + Packet->PageBuffers[0].Offset);
525 /* Make sure we got a valid rndis message */
526 /* FIXME: There seems to be a bug in set completion msg where its MessageLength is 16 bytes but */
527 /* the ByteCount field in the xfer page range shows 52 bytes */
529 if ( Packet->TotalDataBufferLength != rndisHeader->MessageLength )
531 PageUnmapVirtualAddress((void*)(unsigned long)rndisHeader - Packet->PageBuffers[0].Offset);
533 DPRINT_ERR(NETVSC, "invalid rndis message? (expected %u bytes got %u)...dropping this message!",
534 rndisHeader->MessageLength, Packet->TotalDataBufferLength);
540 if ((rndisHeader->NdisMessageType != REMOTE_NDIS_PACKET_MSG) && (rndisHeader->MessageLength > sizeof(RNDIS_MESSAGE)))
542 DPRINT_ERR(NETVSC, "incoming rndis message buffer overflow detected (got %u, max %lu)...marking it an error!",
543 rndisHeader->MessageLength, sizeof(RNDIS_MESSAGE));
546 memcpy(&rndisMessage, rndisHeader, (rndisHeader->MessageLength > sizeof(RNDIS_MESSAGE))?sizeof(RNDIS_MESSAGE):rndisHeader->MessageLength);
548 PageUnmapVirtualAddress((void*)(unsigned long)rndisHeader - Packet->PageBuffers[0].Offset);
550 DumpRndisMessage(&rndisMessage);
552 switch (rndisMessage.NdisMessageType)
555 case REMOTE_NDIS_PACKET_MSG:
556 RndisFilterReceiveData(rndisDevice, &rndisMessage, Packet);
559 /* completion msgs */
560 case REMOTE_NDIS_INITIALIZE_CMPLT:
561 case REMOTE_NDIS_QUERY_CMPLT:
562 case REMOTE_NDIS_SET_CMPLT:
563 /* case REMOTE_NDIS_RESET_CMPLT: */
564 /* case REMOTE_NDIS_KEEPALIVE_CMPLT: */
565 RndisFilterReceiveResponse(rndisDevice, &rndisMessage);
568 /* notification msgs */
569 case REMOTE_NDIS_INDICATE_STATUS_MSG:
570 RndisFilterReceiveIndicateStatus(rndisDevice, &rndisMessage);
573 DPRINT_ERR(NETVSC, "unhandled rndis message (type %u len %u)", rndisMessage.NdisMessageType, rndisMessage.MessageLength);
583 RndisFilterQueryDevice(
584 RNDIS_DEVICE *Device,
590 RNDIS_REQUEST *request;
591 u32 inresultSize = *ResultSize;
592 RNDIS_QUERY_REQUEST *query;
593 RNDIS_QUERY_COMPLETE *queryComplete;
596 DPRINT_ENTER(NETVSC);
601 request = GetRndisRequest(Device, REMOTE_NDIS_QUERY_MSG, RNDIS_MESSAGE_SIZE(RNDIS_QUERY_REQUEST));
608 /* Setup the rndis query */
609 query = &request->RequestMessage.Message.QueryRequest;
611 query->InformationBufferOffset = sizeof(RNDIS_QUERY_REQUEST);
612 query->InformationBufferLength = 0;
613 query->DeviceVcHandle = 0;
615 ret = RndisFilterSendRequest(Device, request);
621 WaitEventWait(request->WaitEvent);
623 /* Copy the response back */
624 queryComplete = &request->ResponseMessage.Message.QueryComplete;
626 if (queryComplete->InformationBufferLength > inresultSize)
633 (void*)((unsigned long)queryComplete + queryComplete->InformationBufferOffset),
634 queryComplete->InformationBufferLength);
636 *ResultSize = queryComplete->InformationBufferLength;
641 PutRndisRequest(Device, request);
649 RndisFilterQueryDeviceMac(
653 u32 size=HW_MACADDR_LEN;
655 return RndisFilterQueryDevice(Device,
656 RNDIS_OID_802_3_PERMANENT_ADDRESS,
662 RndisFilterQueryDeviceLinkStatus(
666 u32 size=sizeof(u32);
668 return RndisFilterQueryDevice(Device,
669 RNDIS_OID_GEN_MEDIA_CONNECT_STATUS,
675 RndisFilterSetPacketFilter(
676 RNDIS_DEVICE *Device,
680 RNDIS_REQUEST *request;
681 RNDIS_SET_REQUEST *set;
682 RNDIS_SET_COMPLETE *setComplete;
686 DPRINT_ENTER(NETVSC);
688 ASSERT(RNDIS_MESSAGE_SIZE(RNDIS_SET_REQUEST) + sizeof(u32) <= sizeof(RNDIS_MESSAGE));
690 request = GetRndisRequest(Device, REMOTE_NDIS_SET_MSG, RNDIS_MESSAGE_SIZE(RNDIS_SET_REQUEST) + sizeof(u32));
697 /* Setup the rndis set */
698 set = &request->RequestMessage.Message.SetRequest;
699 set->Oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
700 set->InformationBufferLength = sizeof(u32);
701 set->InformationBufferOffset = sizeof(RNDIS_SET_REQUEST);
703 memcpy((void*)(unsigned long)set + sizeof(RNDIS_SET_REQUEST), &NewFilter, sizeof(u32));
705 ret = RndisFilterSendRequest(Device, request);
711 ret = WaitEventWaitEx(request->WaitEvent, 2000/*2sec*/);
715 DPRINT_ERR(NETVSC, "timeout before we got a set response...");
716 /* We cant deallocate the request since we may still receive a send completion for it. */
725 setComplete = &request->ResponseMessage.Message.SetComplete;
726 status = setComplete->Status;
732 PutRndisRequest(Device, request);
742 NETVSC_DRIVER_OBJECT *Driver
745 DPRINT_ENTER(NETVSC);
747 DPRINT_DBG(NETVSC, "sizeof(RNDIS_FILTER_PACKET) == %ld", sizeof(RNDIS_FILTER_PACKET));
749 Driver->RequestExtSize = sizeof(RNDIS_FILTER_PACKET);
750 Driver->AdditionalRequestPageBufferCount = 1; /* For rndis header */
752 /* Driver->Context = rndisDriver; */
754 memset(&gRndisFilter, 0, sizeof(RNDIS_FILTER_DRIVER_OBJECT));
756 /*rndisDriver->Driver = Driver;
758 ASSERT(Driver->OnLinkStatusChanged);
759 rndisDriver->OnLinkStatusChanged = Driver->OnLinkStatusChanged;*/
761 /* Save the original dispatch handlers before we override it */
762 gRndisFilter.InnerDriver.Base.OnDeviceAdd = Driver->Base.OnDeviceAdd;
763 gRndisFilter.InnerDriver.Base.OnDeviceRemove = Driver->Base.OnDeviceRemove;
764 gRndisFilter.InnerDriver.Base.OnCleanup = Driver->Base.OnCleanup;
766 ASSERT(Driver->OnSend);
767 ASSERT(Driver->OnReceiveCallback);
768 gRndisFilter.InnerDriver.OnSend = Driver->OnSend;
769 gRndisFilter.InnerDriver.OnReceiveCallback = Driver->OnReceiveCallback;
770 gRndisFilter.InnerDriver.OnLinkStatusChanged = Driver->OnLinkStatusChanged;
773 Driver->Base.OnDeviceAdd = RndisFilterOnDeviceAdd;
774 Driver->Base.OnDeviceRemove = RndisFilterOnDeviceRemove;
775 Driver->Base.OnCleanup = RndisFilterOnCleanup;
776 Driver->OnSend = RndisFilterOnSend;
777 Driver->OnOpen = RndisFilterOnOpen;
778 Driver->OnClose = RndisFilterOnClose;
779 /* Driver->QueryLinkStatus = RndisFilterQueryDeviceLinkStatus; */
780 Driver->OnReceiveCallback = RndisFilterOnReceive;
788 RndisFilterInitDevice(
792 RNDIS_REQUEST *request;
793 RNDIS_INITIALIZE_REQUEST *init;
794 RNDIS_INITIALIZE_COMPLETE *initComplete;
798 DPRINT_ENTER(NETVSC);
800 request = GetRndisRequest(Device, REMOTE_NDIS_INITIALIZE_MSG, RNDIS_MESSAGE_SIZE(RNDIS_INITIALIZE_REQUEST));
807 /* Setup the rndis set */
808 init = &request->RequestMessage.Message.InitializeRequest;
809 init->MajorVersion = RNDIS_MAJOR_VERSION;
810 init->MinorVersion = RNDIS_MINOR_VERSION;
811 init->MaxTransferSize = 2048; /* FIXME: Use 1536 - rounded ethernet frame size */
813 Device->State = RNDIS_DEV_INITIALIZING;
815 ret = RndisFilterSendRequest(Device, request);
818 Device->State = RNDIS_DEV_UNINITIALIZED;
822 WaitEventWait(request->WaitEvent);
824 initComplete = &request->ResponseMessage.Message.InitializeComplete;
825 status = initComplete->Status;
826 if (status == RNDIS_STATUS_SUCCESS)
828 Device->State = RNDIS_DEV_INITIALIZED;
833 Device->State = RNDIS_DEV_UNINITIALIZED;
840 PutRndisRequest(Device, request);
848 RndisFilterHaltDevice(
852 RNDIS_REQUEST *request;
853 RNDIS_HALT_REQUEST *halt;
855 DPRINT_ENTER(NETVSC);
857 /* Attempt to do a rndis device halt */
858 request = GetRndisRequest(Device, REMOTE_NDIS_HALT_MSG, RNDIS_MESSAGE_SIZE(RNDIS_HALT_REQUEST));
864 /* Setup the rndis set */
865 halt = &request->RequestMessage.Message.HaltRequest;
866 halt->RequestId = InterlockedIncrement((int*)&Device->NewRequestId);
868 /* Ignore return since this msg is optional. */
869 RndisFilterSendRequest(Device, request);
871 Device->State = RNDIS_DEV_UNINITIALIZED;
876 PutRndisRequest(Device, request);
884 RndisFilterOpenDevice(
890 DPRINT_ENTER(NETVSC);
892 if (Device->State != RNDIS_DEV_INITIALIZED)
895 ret = RndisFilterSetPacketFilter(Device, NDIS_PACKET_TYPE_BROADCAST|NDIS_PACKET_TYPE_DIRECTED);
898 Device->State = RNDIS_DEV_DATAINITIALIZED;
906 RndisFilterCloseDevice(
912 DPRINT_ENTER(NETVSC);
914 if (Device->State != RNDIS_DEV_DATAINITIALIZED)
917 ret = RndisFilterSetPacketFilter(Device, 0);
920 Device->State = RNDIS_DEV_INITIALIZED;
930 RndisFilterOnDeviceAdd(
931 DEVICE_OBJECT *Device,
936 struct NETVSC_DEVICE *netDevice;
937 RNDIS_DEVICE *rndisDevice;
938 NETVSC_DEVICE_INFO *deviceInfo = (NETVSC_DEVICE_INFO*)AdditionalInfo;
940 DPRINT_ENTER(NETVSC);
942 rndisDevice = GetRndisDevice();
949 DPRINT_DBG(NETVSC, "rndis device object allocated - %p", rndisDevice);
951 /* Let the inner driver handle this first to create the netvsc channel */
952 /* NOTE! Once the channel is created, we may get a receive callback */
953 /* (RndisFilterOnReceive()) before this call is completed */
954 ret = gRndisFilter.InnerDriver.Base.OnDeviceAdd(Device, AdditionalInfo);
957 PutRndisDevice(rndisDevice);
963 /* Initialize the rndis device */
965 netDevice = (struct NETVSC_DEVICE*)Device->Extension;
967 ASSERT(netDevice->Device);
969 netDevice->Extension = rndisDevice;
970 rndisDevice->NetDevice = netDevice;
972 /* Send the rndis initialization message */
973 ret = RndisFilterInitDevice(rndisDevice);
976 /* TODO: If rndis init failed, we will need to shut down the channel */
979 /* Get the mac address */
980 ret = RndisFilterQueryDeviceMac(rndisDevice);
983 /* TODO: shutdown rndis device and the channel */
986 DPRINT_INFO(NETVSC, "Device 0x%p mac addr %02x%02x%02x%02x%02x%02x",
988 rndisDevice->HwMacAddr[0],
989 rndisDevice->HwMacAddr[1],
990 rndisDevice->HwMacAddr[2],
991 rndisDevice->HwMacAddr[3],
992 rndisDevice->HwMacAddr[4],
993 rndisDevice->HwMacAddr[5]);
995 memcpy(deviceInfo->MacAddr, rndisDevice->HwMacAddr, HW_MACADDR_LEN);
997 RndisFilterQueryDeviceLinkStatus(rndisDevice);
999 deviceInfo->LinkState = rndisDevice->LinkStatus;
1000 DPRINT_INFO(NETVSC, "Device 0x%p link state %s", rndisDevice, ((deviceInfo->LinkState)?("down"):("up")));
1002 DPRINT_EXIT(NETVSC);
1009 RndisFilterOnDeviceRemove(
1010 DEVICE_OBJECT *Device
1013 struct NETVSC_DEVICE *netDevice = (struct NETVSC_DEVICE*)Device->Extension;
1014 RNDIS_DEVICE *rndisDevice = (RNDIS_DEVICE*)netDevice->Extension;
1016 DPRINT_ENTER(NETVSC);
1018 /* Halt and release the rndis device */
1019 RndisFilterHaltDevice(rndisDevice);
1021 PutRndisDevice(rndisDevice);
1022 netDevice->Extension = NULL;
1024 /* Pass control to inner driver to remove the device */
1025 gRndisFilter.InnerDriver.Base.OnDeviceRemove(Device);
1027 DPRINT_EXIT(NETVSC);
1034 RndisFilterOnCleanup(
1035 DRIVER_OBJECT *Driver
1038 DPRINT_ENTER(NETVSC);
1040 DPRINT_EXIT(NETVSC);
1045 DEVICE_OBJECT *Device
1049 struct NETVSC_DEVICE *netDevice = (struct NETVSC_DEVICE*)Device->Extension;
1051 DPRINT_ENTER(NETVSC);
1054 ret = RndisFilterOpenDevice((RNDIS_DEVICE*)netDevice->Extension);
1056 DPRINT_EXIT(NETVSC);
1063 DEVICE_OBJECT *Device
1067 struct NETVSC_DEVICE *netDevice = (struct NETVSC_DEVICE*)Device->Extension;
1069 DPRINT_ENTER(NETVSC);
1072 ret = RndisFilterCloseDevice((RNDIS_DEVICE*)netDevice->Extension);
1074 DPRINT_EXIT(NETVSC);
1082 DEVICE_OBJECT *Device,
1083 NETVSC_PACKET *Packet
1087 RNDIS_FILTER_PACKET *filterPacket;
1088 RNDIS_MESSAGE *rndisMessage;
1089 RNDIS_PACKET *rndisPacket;
1090 u32 rndisMessageSize;
1092 DPRINT_ENTER(NETVSC);
1094 /* Add the rndis header */
1095 filterPacket = (RNDIS_FILTER_PACKET*)Packet->Extension;
1096 ASSERT(filterPacket);
1098 memset(filterPacket, 0, sizeof(RNDIS_FILTER_PACKET));
1100 rndisMessage = &filterPacket->Message;
1101 rndisMessageSize = RNDIS_MESSAGE_SIZE(RNDIS_PACKET);
1103 rndisMessage->NdisMessageType = REMOTE_NDIS_PACKET_MSG;
1104 rndisMessage->MessageLength = Packet->TotalDataBufferLength + rndisMessageSize;
1106 rndisPacket = &rndisMessage->Message.Packet;
1107 rndisPacket->DataOffset = sizeof(RNDIS_PACKET);
1108 rndisPacket->DataLength = Packet->TotalDataBufferLength;
1110 Packet->IsDataPacket = true;
1111 Packet->PageBuffers[0].Pfn = GetPhysicalAddress(rndisMessage) >> PAGE_SHIFT;
1112 Packet->PageBuffers[0].Offset = (unsigned long)rndisMessage & (PAGE_SIZE-1);
1113 Packet->PageBuffers[0].Length = rndisMessageSize;
1115 /* Save the packet send completion and context */
1116 filterPacket->OnCompletion = Packet->Completion.Send.OnSendCompletion;
1117 filterPacket->CompletionContext = Packet->Completion.Send.SendCompletionContext;
1120 Packet->Completion.Send.OnSendCompletion = RndisFilterOnSendCompletion;
1121 Packet->Completion.Send.SendCompletionContext = filterPacket;
1123 ret = gRndisFilter.InnerDriver.OnSend(Device, Packet);
1126 /* Reset the completion to originals to allow retries from above */
1127 Packet->Completion.Send.OnSendCompletion = filterPacket->OnCompletion;
1128 Packet->Completion.Send.SendCompletionContext = filterPacket->CompletionContext;
1131 DPRINT_EXIT(NETVSC);
1137 RndisFilterOnSendCompletion(
1140 RNDIS_FILTER_PACKET *filterPacket = (RNDIS_FILTER_PACKET *)Context;
1142 DPRINT_ENTER(NETVSC);
1144 /* Pass it back to the original handler */
1145 filterPacket->OnCompletion(filterPacket->CompletionContext);
1147 DPRINT_EXIT(NETVSC);
1152 RndisFilterOnSendRequestCompletion(
1156 DPRINT_ENTER(NETVSC);
1159 DPRINT_EXIT(NETVSC);