]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blame - src/patches/suse-2.6.27.39/patches.drivers/staging-hv-add-the-hyper-v-virtual-network-driver.patch
projects / people / pmueller / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix oinkmaster patch.
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.39 / patches.drivers / staging-hv-add-the-hyper-v-virtual-network-driver.patch
CommitLineData
2cb7cef9
BS		 1From fec8755b6193c93a935423fdd6026b354aa2e15e Mon Sep 17 00:00:00 2001
2From: Hank Janssen <hjanssen@microsoft.com>
3Date: Mon, 13 Jul 2009 15:34:54 -0700
4Subject: Staging: hv: add the Hyper-V virtual network driver
5
6From: Hank Janssen <hjanssen@microsoft.com>
7
8This is the virtual network driver when running Linux on top of Hyper-V.
9
10Signed-off-by: Hank Janssen <hjanssen@microsoft.com>
11Signed-off-by: Haiyang Zhang <haiyangz@microsoft.com>
12Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
13---
14 drivers/staging/hv/NetVsc.c | 1499 +++++++++++++++++++++++++++++++++++++++
15 drivers/staging/hv/NetVsc.h | 91 ++
16 drivers/staging/hv/RndisFilter.c | 1162 ++++++++++++++++++++++++++++++
17 drivers/staging/hv/RndisFilter.h | 61 +
18 drivers/staging/hv/netvsc_drv.c | 720 ++++++++++++++++++
19 5 files changed, 3533 insertions(+)
20 create mode 100644 drivers/staging/hv/netvsc.c
21
22--- /dev/null
23+++ b/drivers/staging/hv/NetVsc.c
24@@ -0,0 +1,1499 @@
25+/*
26+ *
27+ * Copyright (c) 2009, Microsoft Corporation.
28+ *
29+ * This program is free software; you can redistribute it and/or modify it
30+ * under the terms and conditions of the GNU General Public License,
31+ * version 2, as published by the Free Software Foundation.
32+ *
33+ * This program is distributed in the hope it will be useful, but WITHOUT
34+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
35+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
36+ * more details.
37+ *
38+ * You should have received a copy of the GNU General Public License along with
39+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
40+ * Place - Suite 330, Boston, MA 02111-1307 USA.
41+ *
42+ * Authors:
43+ * Hank Janssen <hjanssen@microsoft.com>
44+ *
45+ */
46+
47+
48+#include "logging.h"
49+#include "NetVsc.h"
50+#include "RndisFilter.h"
51+
52+
53+//
54+// Globals
55+//
56+static const char* gDriverName="netvsc";
57+
58+// {F8615163-DF3E-46c5-913F-F2D2F965ED0E}
59+static const GUID gNetVscDeviceType={
60+ .Data = {0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46, 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E}
61+};
62+
63+
64+//
65+// Internal routines
66+//
67+static int
68+NetVscOnDeviceAdd(
69+ DEVICE_OBJECT *Device,
70+ void *AdditionalInfo
71+ );
72+
73+static int
74+NetVscOnDeviceRemove(
75+ DEVICE_OBJECT *Device
76+ );
77+
78+static void
79+NetVscOnCleanup(
80+ DRIVER_OBJECT *Driver
81+ );
82+
83+static void
84+NetVscOnChannelCallback(
85+ PVOID context
86+ );
87+
88+static int
89+NetVscInitializeSendBufferWithNetVsp(
90+ DEVICE_OBJECT *Device
91+ );
92+
93+static int
94+NetVscInitializeReceiveBufferWithNetVsp(
95+ DEVICE_OBJECT *Device
96+ );
97+
98+static int
99+NetVscDestroySendBuffer(
100+ NETVSC_DEVICE *NetDevice
101+ );
102+
103+static int
104+NetVscDestroyReceiveBuffer(
105+ NETVSC_DEVICE *NetDevice
106+ );
107+
108+static int
109+NetVscConnectToVsp(
110+ DEVICE_OBJECT *Device
111+ );
112+
113+static void
114+NetVscOnSendCompletion(
115+ DEVICE_OBJECT *Device,
116+ VMPACKET_DESCRIPTOR *Packet
117+ );
118+
119+static int
120+NetVscOnSend(
121+ DEVICE_OBJECT *Device,
122+ NETVSC_PACKET *Packet
123+ );
124+
125+static void
126+NetVscOnReceive(
127+ DEVICE_OBJECT *Device,
128+ VMPACKET_DESCRIPTOR *Packet
129+ );
130+
131+static void
132+NetVscOnReceiveCompletion(
133+ PVOID Context
134+ );
135+
136+static void
137+NetVscSendReceiveCompletion(
138+ DEVICE_OBJECT *Device,
139+ UINT64 TransactionId
140+ );
141+
142+static inline NETVSC_DEVICE* AllocNetDevice(DEVICE_OBJECT *Device)
143+{
144+ NETVSC_DEVICE *netDevice;
145+
146+ netDevice = MemAllocZeroed(sizeof(NETVSC_DEVICE));
147+ if (!netDevice)
148+ return NULL;
149+
150+ // Set to 2 to allow both inbound and outbound traffic
151+ InterlockedCompareExchange(&netDevice->RefCount, 2, 0);
152+
153+ netDevice->Device = Device;
154+ Device->Extension = netDevice;
155+
156+ return netDevice;
157+}
158+
159+static inline void FreeNetDevice(NETVSC_DEVICE *Device)
160+{
161+ ASSERT(Device->RefCount == 0);
162+ Device->Device->Extension = NULL;
163+ MemFree(Device);
164+}
165+
166+
167+// Get the net device object iff exists and its refcount > 1
168+static inline NETVSC_DEVICE* GetOutboundNetDevice(DEVICE_OBJECT *Device)
169+{
170+ NETVSC_DEVICE *netDevice;
171+
172+ netDevice = (NETVSC_DEVICE*)Device->Extension;
173+ if (netDevice && netDevice->RefCount > 1)
174+ {
175+ InterlockedIncrement(&netDevice->RefCount);
176+ }
177+ else
178+ {
179+ netDevice = NULL;
180+ }
181+
182+ return netDevice;
183+}
184+
185+// Get the net device object iff exists and its refcount > 0
186+static inline NETVSC_DEVICE* GetInboundNetDevice(DEVICE_OBJECT *Device)
187+{
188+ NETVSC_DEVICE *netDevice;
189+
190+ netDevice = (NETVSC_DEVICE*)Device->Extension;
191+ if (netDevice && netDevice->RefCount)
192+ {
193+ InterlockedIncrement(&netDevice->RefCount);
194+ }
195+ else
196+ {
197+ netDevice = NULL;
198+ }
199+
200+ return netDevice;
201+}
202+
203+static inline void PutNetDevice(DEVICE_OBJECT *Device)
204+{
205+ NETVSC_DEVICE *netDevice;
206+
207+ netDevice = (NETVSC_DEVICE*)Device->Extension;
208+ ASSERT(netDevice);
209+
210+ InterlockedDecrement(&netDevice->RefCount);
211+}
212+
213+static inline NETVSC_DEVICE* ReleaseOutboundNetDevice(DEVICE_OBJECT *Device)
214+{
215+ NETVSC_DEVICE *netDevice;
216+
217+ netDevice = (NETVSC_DEVICE*)Device->Extension;
218+ if (netDevice == NULL)
219+ return NULL;
220+
221+ // Busy wait until the ref drop to 2, then set it to 1
222+ while (InterlockedCompareExchange(&netDevice->RefCount, 1, 2) != 2)
223+ {
224+ Sleep(100);
225+ }
226+
227+ return netDevice;
228+}
229+
230+static inline NETVSC_DEVICE* ReleaseInboundNetDevice(DEVICE_OBJECT *Device)
231+{
232+ NETVSC_DEVICE *netDevice;
233+
234+ netDevice = (NETVSC_DEVICE*)Device->Extension;
235+ if (netDevice == NULL)
236+ return NULL;
237+
238+ // Busy wait until the ref drop to 1, then set it to 0
239+ while (InterlockedCompareExchange(&netDevice->RefCount, 0, 1) != 1)
240+ {
241+ Sleep(100);
242+ }
243+
244+ Device->Extension = NULL;
245+ return netDevice;
246+}
247+
248+/*++;
249+
250+
251+Name:
252+ NetVscInitialize()
253+
254+Description:
255+ Main entry point
256+
257+--*/
258+int
259+NetVscInitialize(
260+ DRIVER_OBJECT *drv
261+ )
262+{
263+ NETVSC_DRIVER_OBJECT* driver = (NETVSC_DRIVER_OBJECT*)drv;
264+ int ret=0;
265+
266+ DPRINT_ENTER(NETVSC);
267+
268+ DPRINT_DBG(NETVSC, "sizeof(NETVSC_PACKET)=%d, sizeof(NVSP_MESSAGE)=%d, sizeof(VMTRANSFER_PAGE_PACKET_HEADER)=%d",
269+ sizeof(NETVSC_PACKET), sizeof(NVSP_MESSAGE), sizeof(VMTRANSFER_PAGE_PACKET_HEADER));
270+
271+ // Make sure we are at least 2 pages since 1 page is used for control
272+ ASSERT(driver->RingBufferSize >= (PAGE_SIZE << 1));
273+
274+ drv->name = gDriverName;
275+ memcpy(&drv->deviceType, &gNetVscDeviceType, sizeof(GUID));
276+
277+ // Make sure it is set by the caller
278+ ASSERT(driver->OnReceiveCallback);
279+ ASSERT(driver->OnLinkStatusChanged);
280+
281+ // Setup the dispatch table
282+ driver->Base.OnDeviceAdd = NetVscOnDeviceAdd;
283+ driver->Base.OnDeviceRemove = NetVscOnDeviceRemove;
284+ driver->Base.OnCleanup = NetVscOnCleanup;
285+
286+ driver->OnSend = NetVscOnSend;
287+
288+ RndisFilterInit(driver);
289+
290+ DPRINT_EXIT(NETVSC);
291+
292+ return ret;
293+}
294+
295+static int
296+NetVscInitializeReceiveBufferWithNetVsp(
297+ DEVICE_OBJECT *Device
298+ )
299+{
300+ int ret=0;
301+ NETVSC_DEVICE *netDevice;
302+ NVSP_MESSAGE *initPacket;
303+
304+ DPRINT_ENTER(NETVSC);
305+
306+ netDevice = GetOutboundNetDevice(Device);
307+ if (!netDevice)
308+ {
309+ DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
310+ DPRINT_EXIT(NETVSC);
311+ return -1;
312+ }
313+ ASSERT(netDevice->ReceiveBufferSize > 0);
314+ ASSERT((netDevice->ReceiveBufferSize & (PAGE_SIZE-1)) == 0); // page-size grandularity
315+
316+ netDevice->ReceiveBuffer = PageAlloc(netDevice->ReceiveBufferSize >> PAGE_SHIFT);
317+ if (!netDevice->ReceiveBuffer)
318+ {
319+ DPRINT_ERR(NETVSC, "unable to allocate receive buffer of size %d", netDevice->ReceiveBufferSize);
320+ ret = -1;
321+ goto Cleanup;
322+ }
323+ ASSERT(((ULONG_PTR)netDevice->ReceiveBuffer & (PAGE_SIZE-1)) == 0); // page-aligned buffer
324+
325+ DPRINT_INFO(NETVSC, "Establishing receive buffer's GPADL...");
326+
327+ // Establish the gpadl handle for this buffer on this channel.
328+ // Note: This call uses the vmbus connection rather than the channel to establish
329+ // the gpadl handle.
330+ ret = Device->Driver->VmbusChannelInterface.EstablishGpadl(Device,
331+ netDevice->ReceiveBuffer,
332+ netDevice->ReceiveBufferSize,
333+ &netDevice->ReceiveBufferGpadlHandle);
334+
335+ if (ret != 0)
336+ {
337+ DPRINT_ERR(NETVSC, "unable to establish receive buffer's gpadl");
338+ goto Cleanup;
339+ }
340+
341+ //WaitEventWait(ext->ChannelInitEvent);
342+
343+ // Notify the NetVsp of the gpadl handle
344+ DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendReceiveBuffer...");
345+
346+ initPacket = &netDevice->ChannelInitPacket;
347+
348+ memset(initPacket, 0, sizeof(NVSP_MESSAGE));
349+
350+ initPacket->Header.MessageType = NvspMessage1TypeSendReceiveBuffer;
351+ initPacket->Messages.Version1Messages.SendReceiveBuffer.GpadlHandle = netDevice->ReceiveBufferGpadlHandle;
352+ initPacket->Messages.Version1Messages.SendReceiveBuffer.Id = NETVSC_RECEIVE_BUFFER_ID;
353+
354+ // Send the gpadl notification request
355+ ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
356+ initPacket,
357+ sizeof(NVSP_MESSAGE),
358+ (ULONG_PTR)initPacket,
359+ VmbusPacketTypeDataInBand,
360+ VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
361+ if (ret != 0)
362+ {
363+ DPRINT_ERR(NETVSC, "unable to send receive buffer's gpadl to netvsp");
364+ goto Cleanup;
365+ }
366+
367+ WaitEventWait(netDevice->ChannelInitEvent);
368+
369+ // Check the response
370+ if (initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Status != NvspStatusSuccess)
371+ {
372+ DPRINT_ERR(NETVSC,
373+ "Unable to complete receive buffer initialzation with NetVsp - status %d",
374+ initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Status);
375+ ret = -1;
376+ goto Cleanup;
377+ }
378+
379+ // Parse the response
380+ ASSERT(netDevice->ReceiveSectionCount == 0);
381+ ASSERT(netDevice->ReceiveSections == NULL);
382+
383+ netDevice->ReceiveSectionCount = initPacket->Messages.Version1Messages.SendReceiveBufferComplete.NumSections;
384+
385+ netDevice->ReceiveSections = MemAlloc(netDevice->ReceiveSectionCount * sizeof(NVSP_1_RECEIVE_BUFFER_SECTION));
386+ if (netDevice->ReceiveSections == NULL)
387+ {
388+ ret = -1;
389+ goto Cleanup;
390+ }
391+
392+ memcpy(netDevice->ReceiveSections,
393+ initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Sections,
394+ netDevice->ReceiveSectionCount * sizeof(NVSP_1_RECEIVE_BUFFER_SECTION));
395+
396+ DPRINT_INFO(NETVSC,
397+ "Receive sections info (count %d, offset %d, endoffset %d, suballoc size %d, num suballocs %d)",
398+ netDevice->ReceiveSectionCount, netDevice->ReceiveSections[0].Offset, netDevice->ReceiveSections[0].EndOffset,
399+ netDevice->ReceiveSections[0].SubAllocationSize, netDevice->ReceiveSections[0].NumSubAllocations);
400+
401+
402+ //For 1st release, there should only be 1 section that represents the entire receive buffer
403+ if (netDevice->ReceiveSectionCount != 1 ||
404+ netDevice->ReceiveSections->Offset != 0 )
405+ {
406+ ret = -1;
407+ goto Cleanup;
408+ }
409+
410+ goto Exit;
411+
412+Cleanup:
413+ NetVscDestroyReceiveBuffer(netDevice);
414+
415+Exit:
416+ PutNetDevice(Device);
417+ DPRINT_EXIT(NETVSC);
418+ return ret;
419+}
420+
421+
422+static int
423+NetVscInitializeSendBufferWithNetVsp(
424+ DEVICE_OBJECT *Device
425+ )
426+{
427+ int ret=0;
428+ NETVSC_DEVICE *netDevice;
429+ NVSP_MESSAGE *initPacket;
430+
431+ DPRINT_ENTER(NETVSC);
432+
433+ netDevice = GetOutboundNetDevice(Device);
434+ if (!netDevice)
435+ {
436+ DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
437+ DPRINT_EXIT(NETVSC);
438+ return -1;
439+ }
440+ ASSERT(netDevice->SendBufferSize > 0);
441+ ASSERT((netDevice->SendBufferSize & (PAGE_SIZE-1)) == 0); // page-size grandularity
442+
443+ netDevice->SendBuffer = PageAlloc(netDevice->SendBufferSize >> PAGE_SHIFT);
444+ if (!netDevice->SendBuffer)
445+ {
446+ DPRINT_ERR(NETVSC, "unable to allocate send buffer of size %d", netDevice->SendBufferSize);
447+ ret = -1;
448+ goto Cleanup;
449+ }
450+ ASSERT(((ULONG_PTR)netDevice->SendBuffer & (PAGE_SIZE-1)) == 0); // page-aligned buffer
451+
452+ DPRINT_INFO(NETVSC, "Establishing send buffer's GPADL...");
453+
454+ // Establish the gpadl handle for this buffer on this channel.
455+ // Note: This call uses the vmbus connection rather than the channel to establish
456+ // the gpadl handle.
457+ ret = Device->Driver->VmbusChannelInterface.EstablishGpadl(Device,
458+ netDevice->SendBuffer,
459+ netDevice->SendBufferSize,
460+ &netDevice->SendBufferGpadlHandle);
461+
462+ if (ret != 0)
463+ {
464+ DPRINT_ERR(NETVSC, "unable to establish send buffer's gpadl");
465+ goto Cleanup;
466+ }
467+
468+ //WaitEventWait(ext->ChannelInitEvent);
469+
470+ // Notify the NetVsp of the gpadl handle
471+ DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendSendBuffer...");
472+
473+ initPacket = &netDevice->ChannelInitPacket;
474+
475+ memset(initPacket, 0, sizeof(NVSP_MESSAGE));
476+
477+ initPacket->Header.MessageType = NvspMessage1TypeSendSendBuffer;
478+ initPacket->Messages.Version1Messages.SendReceiveBuffer.GpadlHandle = netDevice->SendBufferGpadlHandle;
479+ initPacket->Messages.Version1Messages.SendReceiveBuffer.Id = NETVSC_SEND_BUFFER_ID;
480+
481+ // Send the gpadl notification request
482+ ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
483+ initPacket,
484+ sizeof(NVSP_MESSAGE),
485+ (ULONG_PTR)initPacket,
486+ VmbusPacketTypeDataInBand,
487+ VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
488+ if (ret != 0)
489+ {
490+ DPRINT_ERR(NETVSC, "unable to send receive buffer's gpadl to netvsp");
491+ goto Cleanup;
492+ }
493+
494+ WaitEventWait(netDevice->ChannelInitEvent);
495+
496+ // Check the response
497+ if (initPacket->Messages.Version1Messages.SendSendBufferComplete.Status != NvspStatusSuccess)
498+ {
499+ DPRINT_ERR(NETVSC,
500+ "Unable to complete send buffer initialzation with NetVsp - status %d",
501+ initPacket->Messages.Version1Messages.SendSendBufferComplete.Status);
502+ ret = -1;
503+ goto Cleanup;
504+ }
505+
506+ netDevice->SendSectionSize = initPacket->Messages.Version1Messages.SendSendBufferComplete.SectionSize;
507+
508+ goto Exit;
509+
510+Cleanup:
511+ NetVscDestroySendBuffer(netDevice);
512+
513+Exit:
514+ PutNetDevice(Device);
515+ DPRINT_EXIT(NETVSC);
516+ return ret;
517+}
518+
519+static int
520+NetVscDestroyReceiveBuffer(
521+ NETVSC_DEVICE *NetDevice
522+ )
523+{
524+ NVSP_MESSAGE *revokePacket;
525+ int ret=0;
526+
527+
528+ DPRINT_ENTER(NETVSC);
529+
530+ // If we got a section count, it means we received a SendReceiveBufferComplete msg
531+ // (ie sent NvspMessage1TypeSendReceiveBuffer msg) therefore, we need to send a revoke msg here
532+ if (NetDevice->ReceiveSectionCount)
533+ {
534+ DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeRevokeReceiveBuffer...");
535+
536+ // Send the revoke receive buffer
537+ revokePacket = &NetDevice->RevokePacket;
538+ memset(revokePacket, 0, sizeof(NVSP_MESSAGE));
539+
540+ revokePacket->Header.MessageType = NvspMessage1TypeRevokeReceiveBuffer;
541+ revokePacket->Messages.Version1Messages.RevokeReceiveBuffer.Id = NETVSC_RECEIVE_BUFFER_ID;
542+
543+ ret = NetDevice->Device->Driver->VmbusChannelInterface.SendPacket(NetDevice->Device,
544+ revokePacket,
545+ sizeof(NVSP_MESSAGE),
546+ (ULONG_PTR)revokePacket,
547+ VmbusPacketTypeDataInBand,
548+ 0);
549+ // If we failed here, we might as well return and have a leak rather than continue and a bugchk
550+ if (ret != 0)
551+ {
552+ DPRINT_ERR(NETVSC, "unable to send revoke receive buffer to netvsp");
553+ DPRINT_EXIT(NETVSC);
554+ return -1;
555+ }
556+ }
557+
558+ // Teardown the gpadl on the vsp end
559+ if (NetDevice->ReceiveBufferGpadlHandle)
560+ {
561+ DPRINT_INFO(NETVSC, "Tearing down receive buffer's GPADL...");
562+
563+ ret = NetDevice->Device->Driver->VmbusChannelInterface.TeardownGpadl(NetDevice->Device,
564+ NetDevice->ReceiveBufferGpadlHandle);
565+
566+ // If we failed here, we might as well return and have a leak rather than continue and a bugchk
567+ if (ret != 0)
568+ {
569+ DPRINT_ERR(NETVSC, "unable to teardown receive buffer's gpadl");
570+ DPRINT_EXIT(NETVSC);
571+ return -1;
572+ }
573+ NetDevice->ReceiveBufferGpadlHandle = 0;
574+ }
575+
576+ if (NetDevice->ReceiveBuffer)
577+ {
578+ DPRINT_INFO(NETVSC, "Freeing up receive buffer...");
579+
580+ // Free up the receive buffer
581+ PageFree(NetDevice->ReceiveBuffer, NetDevice->ReceiveBufferSize >> PAGE_SHIFT);
582+ NetDevice->ReceiveBuffer = NULL;
583+ }
584+
585+ if (NetDevice->ReceiveSections)
586+ {
587+ MemFree(NetDevice->ReceiveSections);
588+ NetDevice->ReceiveSections = NULL;
589+ NetDevice->ReceiveSectionCount = 0;
590+ }
591+
592+ DPRINT_EXIT(NETVSC);
593+
594+ return ret;
595+}
596+
597+
598+
599+
600+static int
601+NetVscDestroySendBuffer(
602+ NETVSC_DEVICE *NetDevice
603+ )
604+{
605+ NVSP_MESSAGE *revokePacket;
606+ int ret=0;
607+
608+
609+ DPRINT_ENTER(NETVSC);
610+
611+ // If we got a section count, it means we received a SendReceiveBufferComplete msg
612+ // (ie sent NvspMessage1TypeSendReceiveBuffer msg) therefore, we need to send a revoke msg here
613+ if (NetDevice->SendSectionSize)
614+ {
615+ DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeRevokeSendBuffer...");
616+
617+ // Send the revoke send buffer
618+ revokePacket = &NetDevice->RevokePacket;
619+ memset(revokePacket, 0, sizeof(NVSP_MESSAGE));
620+
621+ revokePacket->Header.MessageType = NvspMessage1TypeRevokeSendBuffer;
622+ revokePacket->Messages.Version1Messages.RevokeSendBuffer.Id = NETVSC_SEND_BUFFER_ID;
623+
624+ ret = NetDevice->Device->Driver->VmbusChannelInterface.SendPacket(NetDevice->Device,
625+ revokePacket,
626+ sizeof(NVSP_MESSAGE),
627+ (ULONG_PTR)revokePacket,
628+ VmbusPacketTypeDataInBand,
629+ 0);
630+ // If we failed here, we might as well return and have a leak rather than continue and a bugchk
631+ if (ret != 0)
632+ {
633+ DPRINT_ERR(NETVSC, "unable to send revoke send buffer to netvsp");
634+ DPRINT_EXIT(NETVSC);
635+ return -1;
636+ }
637+ }
638+
639+ // Teardown the gpadl on the vsp end
640+ if (NetDevice->SendBufferGpadlHandle)
641+ {
642+ DPRINT_INFO(NETVSC, "Tearing down send buffer's GPADL...");
643+
644+ ret = NetDevice->Device->Driver->VmbusChannelInterface.TeardownGpadl(NetDevice->Device,
645+ NetDevice->SendBufferGpadlHandle);
646+
647+ // If we failed here, we might as well return and have a leak rather than continue and a bugchk
648+ if (ret != 0)
649+ {
650+ DPRINT_ERR(NETVSC, "unable to teardown send buffer's gpadl");
651+ DPRINT_EXIT(NETVSC);
652+ return -1;
653+ }
654+ NetDevice->SendBufferGpadlHandle = 0;
655+ }
656+
657+ if (NetDevice->SendBuffer)
658+ {
659+ DPRINT_INFO(NETVSC, "Freeing up send buffer...");
660+
661+ // Free up the receive buffer
662+ PageFree(NetDevice->SendBuffer, NetDevice->SendBufferSize >> PAGE_SHIFT);
663+ NetDevice->SendBuffer = NULL;
664+ }
665+
666+ DPRINT_EXIT(NETVSC);
667+
668+ return ret;
669+}
670+
671+
672+
673+static int
674+NetVscConnectToVsp(
675+ DEVICE_OBJECT *Device
676+ )
677+{
678+ int ret=0;
679+ NETVSC_DEVICE *netDevice;
680+ NVSP_MESSAGE *initPacket;
681+ int ndisVersion;
682+
683+ DPRINT_ENTER(NETVSC);
684+
685+ netDevice = GetOutboundNetDevice(Device);
686+ if (!netDevice)
687+ {
688+ DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
689+ DPRINT_EXIT(NETVSC);
690+ return -1;
691+ }
692+
693+ initPacket = &netDevice->ChannelInitPacket;
694+
695+ memset(initPacket, 0, sizeof(NVSP_MESSAGE));
696+ initPacket->Header.MessageType = NvspMessageTypeInit;
697+ initPacket->Messages.InitMessages.Init.MinProtocolVersion = NVSP_MIN_PROTOCOL_VERSION;
698+ initPacket->Messages.InitMessages.Init.MaxProtocolVersion = NVSP_MAX_PROTOCOL_VERSION;
699+
700+ DPRINT_INFO(NETVSC, "Sending NvspMessageTypeInit...");
701+
702+ // Send the init request
703+ ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
704+ initPacket,
705+ sizeof(NVSP_MESSAGE),
706+ (ULONG_PTR)initPacket,
707+ VmbusPacketTypeDataInBand,
708+ VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
709+
710+ if( ret != 0)
711+ {
712+ DPRINT_ERR(NETVSC, "unable to send NvspMessageTypeInit");
713+ goto Cleanup;
714+ }
715+
716+ WaitEventWait(netDevice->ChannelInitEvent);
717+
718+ // Now, check the response
719+ //ASSERT(initPacket->Messages.InitMessages.InitComplete.MaximumMdlChainLength <= MAX_MULTIPAGE_BUFFER_COUNT);
720+ DPRINT_INFO(NETVSC, "NvspMessageTypeInit status(%d) max mdl chain (%d)",
721+ initPacket->Messages.InitMessages.InitComplete.Status,
722+ initPacket->Messages.InitMessages.InitComplete.MaximumMdlChainLength);
723+
724+ if (initPacket->Messages.InitMessages.InitComplete.Status != NvspStatusSuccess)
725+ {
726+ DPRINT_ERR(NETVSC, "unable to initialize with netvsp (status 0x%x)", initPacket->Messages.InitMessages.InitComplete.Status);
727+ ret = -1;
728+ goto Cleanup;
729+ }
730+
731+ if (initPacket->Messages.InitMessages.InitComplete.NegotiatedProtocolVersion != NVSP_PROTOCOL_VERSION_1)
732+ {
733+ DPRINT_ERR(NETVSC, "unable to initialize with netvsp (version expected 1 got %d)",
734+ initPacket->Messages.InitMessages.InitComplete.NegotiatedProtocolVersion);
735+ ret = -1;
736+ goto Cleanup;
737+ }
738+ DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendNdisVersion...");
739+
740+ // Send the ndis version
741+ memset(initPacket, 0, sizeof(NVSP_MESSAGE));
742+
743+ ndisVersion = 0x00050000;
744+
745+ initPacket->Header.MessageType = NvspMessage1TypeSendNdisVersion;
746+ initPacket->Messages.Version1Messages.SendNdisVersion.NdisMajorVersion = (ndisVersion & 0xFFFF0000) >> 16;
747+ initPacket->Messages.Version1Messages.SendNdisVersion.NdisMinorVersion = ndisVersion & 0xFFFF;
748+
749+ // Send the init request
750+ ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
751+ initPacket,
752+ sizeof(NVSP_MESSAGE),
753+ (ULONG_PTR)initPacket,
754+ VmbusPacketTypeDataInBand,
755+ 0);
756+ if (ret != 0)
757+ {
758+ DPRINT_ERR(NETVSC, "unable to send NvspMessage1TypeSendNdisVersion");
759+ ret = -1;
760+ goto Cleanup;
761+ }
762+ //
763+ // BUGBUG - We have to wait for the above msg since the netvsp uses KMCL which acknowledges packet (completion packet)
764+ // since our Vmbus always set the VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED flag
765+ //WaitEventWait(NetVscChannel->ChannelInitEvent);
766+
767+ // Post the big receive buffer to NetVSP
768+ ret = NetVscInitializeReceiveBufferWithNetVsp(Device);
769+ if (ret == 0)
770+ {
771+ ret = NetVscInitializeSendBufferWithNetVsp(Device);
772+ }
773+
774+Cleanup:
775+ PutNetDevice(Device);
776+ DPRINT_EXIT(NETVSC);
777+ return ret;
778+}
779+
780+static void
781+NetVscDisconnectFromVsp(
782+ NETVSC_DEVICE *NetDevice
783+ )
784+{
785+ DPRINT_ENTER(NETVSC);
786+
787+ NetVscDestroyReceiveBuffer(NetDevice);
788+ NetVscDestroySendBuffer(NetDevice);
789+
790+ DPRINT_EXIT(NETVSC);
791+}
792+
793+
794+/*++
795+
796+Name:
797+ NetVscOnDeviceAdd()
798+
799+Description:
800+ Callback when the device belonging to this driver is added
801+
802+--*/
803+int
804+NetVscOnDeviceAdd(
805+ DEVICE_OBJECT *Device,
806+ void *AdditionalInfo
807+ )
808+{
809+ int ret=0;
810+ int i;
811+
812+ NETVSC_DEVICE* netDevice;
813+ NETVSC_PACKET* packet;
814+ LIST_ENTRY *entry;
815+
816+ NETVSC_DRIVER_OBJECT *netDriver = (NETVSC_DRIVER_OBJECT*) Device->Driver;;
817+
818+ DPRINT_ENTER(NETVSC);
819+
820+ netDevice = AllocNetDevice(Device);
821+ if (!netDevice)
822+ {
823+ ret = -1;
824+ goto Cleanup;
825+ }
826+
827+ DPRINT_DBG(NETVSC, "netvsc channel object allocated - %p", netDevice);
828+
829+ // Initialize the NetVSC channel extension
830+ netDevice->ReceiveBufferSize = NETVSC_RECEIVE_BUFFER_SIZE;
831+ netDevice->ReceivePacketListLock = SpinlockCreate();
832+
833+ netDevice->SendBufferSize = NETVSC_SEND_BUFFER_SIZE;
834+
835+ INITIALIZE_LIST_HEAD(&netDevice->ReceivePacketList);
836+
837+ for (i=0; i < NETVSC_RECEIVE_PACKETLIST_COUNT; i++)
838+ {
839+ packet = MemAllocZeroed(sizeof(NETVSC_PACKET) + (NETVSC_RECEIVE_SG_COUNT* sizeof(PAGE_BUFFER)));
840+ if (!packet)
841+ {
842+ DPRINT_DBG(NETVSC, "unable to allocate netvsc pkts for receive pool (wanted %d got %d)", NETVSC_RECEIVE_PACKETLIST_COUNT, i);
843+ break;
844+ }
845+
846+ INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &packet->ListEntry);
847+ }
848+ netDevice->ChannelInitEvent = WaitEventCreate();
849+
850+ // Open the channel
851+ ret = Device->Driver->VmbusChannelInterface.Open(Device,
852+ netDriver->RingBufferSize,
853+ netDriver->RingBufferSize,
854+ NULL, 0,
855+ NetVscOnChannelCallback,
856+ Device
857+ );
858+
859+ if (ret != 0)
860+ {
861+ DPRINT_ERR(NETVSC, "unable to open channel: %d", ret);
862+ ret = -1;
863+ goto Cleanup;
864+ }
865+
866+ // Channel is opened
867+ DPRINT_INFO(NETVSC, "*** NetVSC channel opened successfully! ***");
868+
869+ // Connect with the NetVsp
870+ ret = NetVscConnectToVsp(Device);
871+ if (ret != 0)
872+ {
873+ DPRINT_ERR(NETVSC, "unable to connect to NetVSP - %d", ret);
874+ ret = -1;
875+ goto Close;
876+ }
877+
878+ DPRINT_INFO(NETVSC, "*** NetVSC channel handshake result - %d ***", ret);
879+
880+ DPRINT_EXIT(NETVSC);
881+ return ret;
882+
883+Close:
884+ // Now, we can close the channel safely
885+ Device->Driver->VmbusChannelInterface.Close(Device);
886+
887+Cleanup:
888+
889+ if (netDevice)
890+ {
891+ WaitEventClose(netDevice->ChannelInitEvent);
892+
893+ while (!IsListEmpty(&netDevice->ReceivePacketList))
894+ {
895+ entry = REMOVE_HEAD_LIST(&netDevice->ReceivePacketList);
896+ packet = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
897+ MemFree(packet);
898+ }
899+
900+ SpinlockClose(netDevice->ReceivePacketListLock);
901+
902+ ReleaseOutboundNetDevice(Device);
903+ ReleaseInboundNetDevice(Device);
904+
905+ FreeNetDevice(netDevice);
906+ }
907+
908+ DPRINT_EXIT(NETVSC);
909+ return ret;
910+}
911+
912+
913+/*++
914+
915+Name:
916+ NetVscOnDeviceRemove()
917+
918+Description:
919+ Callback when the root bus device is removed
920+
921+--*/
922+int
923+NetVscOnDeviceRemove(
924+ DEVICE_OBJECT *Device
925+ )
926+{
927+ NETVSC_DEVICE *netDevice;
928+ NETVSC_PACKET *netvscPacket;
929+ int ret=0;
930+ LIST_ENTRY *entry;
931+
932+ DPRINT_ENTER(NETVSC);
933+
934+ DPRINT_INFO(NETVSC, "Disabling outbound traffic on net device (%p)...", Device->Extension);
935+
936+ // Stop outbound traffic ie sends and receives completions
937+ netDevice = ReleaseOutboundNetDevice(Device);
938+ if (!netDevice)
939+ {
940+ DPRINT_ERR(NETVSC, "No net device present!!");
941+ return -1;
942+ }
943+
944+ // Wait for all send completions
945+ while (netDevice->NumOutstandingSends)
946+ {
947+ DPRINT_INFO(NETVSC, "waiting for %d requests to complete...", netDevice->NumOutstandingSends);
948+
949+ Sleep(100);
950+ }
951+
952+ DPRINT_INFO(NETVSC, "Disconnecting from netvsp...");
953+
954+ NetVscDisconnectFromVsp(netDevice);
955+
956+ DPRINT_INFO(NETVSC, "Disabling inbound traffic on net device (%p)...", Device->Extension);
957+
958+ // Stop inbound traffic ie receives and sends completions
959+ netDevice = ReleaseInboundNetDevice(Device);
960+
961+ // At this point, no one should be accessing netDevice except in here
962+ DPRINT_INFO(NETVSC, "net device (%p) safe to remove", netDevice);
963+
964+ // Now, we can close the channel safely
965+ Device->Driver->VmbusChannelInterface.Close(Device);
966+
967+ // Release all resources
968+ while (!IsListEmpty(&netDevice->ReceivePacketList))
969+ {
970+ entry = REMOVE_HEAD_LIST(&netDevice->ReceivePacketList);
971+ netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
972+
973+ MemFree(netvscPacket);
974+ }
975+
976+ SpinlockClose(netDevice->ReceivePacketListLock);
977+ WaitEventClose(netDevice->ChannelInitEvent);
978+ FreeNetDevice(netDevice);
979+
980+ DPRINT_EXIT(NETVSC);
981+ return ret;
982+}
983+
984+
985+
986+/*++
987+
988+Name:
989+ NetVscOnCleanup()
990+
991+Description:
992+ Perform any cleanup when the driver is removed
993+
994+--*/
995+void
996+NetVscOnCleanup(
997+ DRIVER_OBJECT *drv
998+ )
999+{
1000+ DPRINT_ENTER(NETVSC);
1001+
1002+ DPRINT_EXIT(NETVSC);
1003+}
1004+
1005+static void
1006+NetVscOnSendCompletion(
1007+ DEVICE_OBJECT *Device,
1008+ VMPACKET_DESCRIPTOR *Packet
1009+ )
1010+{
1011+ NETVSC_DEVICE* netDevice;
1012+ NVSP_MESSAGE *nvspPacket;
1013+ NETVSC_PACKET *nvscPacket;
1014+
1015+ DPRINT_ENTER(NETVSC);
1016+
1017+ netDevice = GetInboundNetDevice(Device);
1018+ if (!netDevice)
1019+ {
1020+ DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
1021+ DPRINT_EXIT(NETVSC);
1022+ return;
1023+ }
1024+
1025+ nvspPacket = (NVSP_MESSAGE*)((ULONG_PTR)Packet + (Packet->DataOffset8 << 3));
1026+
1027+ DPRINT_DBG(NETVSC, "send completion packet - type %d", nvspPacket->Header.MessageType);
1028+
1029+ if (nvspPacket->Header.MessageType == NvspMessageTypeInitComplete ||
1030+ nvspPacket->Header.MessageType == NvspMessage1TypeSendReceiveBufferComplete ||
1031+ nvspPacket->Header.MessageType == NvspMessage1TypeSendSendBufferComplete)
1032+ {
1033+ // Copy the response back
1034+ memcpy(&netDevice->ChannelInitPacket, nvspPacket, sizeof(NVSP_MESSAGE));
1035+ WaitEventSet(netDevice->ChannelInitEvent);
1036+ }
1037+ else if (nvspPacket->Header.MessageType == NvspMessage1TypeSendRNDISPacketComplete)
1038+ {
1039+ // Get the send context
1040+ nvscPacket = (NETVSC_PACKET *)(ULONG_PTR)Packet->TransactionId;
1041+ ASSERT(nvscPacket);
1042+
1043+ // Notify the layer above us
1044+ nvscPacket->Completion.Send.OnSendCompletion(nvscPacket->Completion.Send.SendCompletionContext);
1045+
1046+ InterlockedDecrement(&netDevice->NumOutstandingSends);
1047+ }
1048+ else
1049+ {
1050+ DPRINT_ERR(NETVSC, "Unknown send completion packet type - %d received!!", nvspPacket->Header.MessageType);
1051+ }
1052+
1053+ PutNetDevice(Device);
1054+ DPRINT_EXIT(NETVSC);
1055+}
1056+
1057+
1058+
1059+static int
1060+NetVscOnSend(
1061+ DEVICE_OBJECT *Device,
1062+ NETVSC_PACKET *Packet
1063+ )
1064+{
1065+ NETVSC_DEVICE* netDevice;
1066+ int ret=0;
1067+
1068+ NVSP_MESSAGE sendMessage;
1069+
1070+ DPRINT_ENTER(NETVSC);
1071+
1072+ netDevice = GetOutboundNetDevice(Device);
1073+ if (!netDevice)
1074+ {
1075+ DPRINT_ERR(NETVSC, "net device (%p) shutting down...ignoring outbound packets", netDevice);
1076+ DPRINT_EXIT(NETVSC);
1077+ return -2;
1078+ }
1079+
1080+ sendMessage.Header.MessageType = NvspMessage1TypeSendRNDISPacket;
1081+ if (Packet->IsDataPacket)
1082+ sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 0;// 0 is RMC_DATA;
1083+ else
1084+ sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 1;// 1 is RMC_CONTROL;
1085+
1086+ // Not using send buffer section
1087+ sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionIndex = 0xFFFFFFFF;
1088+ sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionSize = 0;
1089+
1090+ if (Packet->PageBufferCount)
1091+ {
1092+ ret = Device->Driver->VmbusChannelInterface.SendPacketPageBuffer(Device,
1093+ Packet->PageBuffers,
1094+ Packet->PageBufferCount,
1095+ &sendMessage,
1096+ sizeof(NVSP_MESSAGE),
1097+ (ULONG_PTR)Packet);
1098+ }
1099+ else
1100+ {
1101+ ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
1102+ &sendMessage,
1103+ sizeof(NVSP_MESSAGE),
1104+ (ULONG_PTR)Packet,
1105+ VmbusPacketTypeDataInBand,
1106+ VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1107+
1108+ }
1109+
1110+ if (ret != 0)
1111+ {
1112+ DPRINT_ERR(NETVSC, "Unable to send packet %p ret %d", Packet, ret);
1113+ }
1114+
1115+ InterlockedIncrement(&netDevice->NumOutstandingSends);
1116+ PutNetDevice(Device);
1117+
1118+ DPRINT_EXIT(NETVSC);
1119+ return ret;
1120+}
1121+
1122+
1123+static void
1124+NetVscOnReceive(
1125+ DEVICE_OBJECT *Device,
1126+ VMPACKET_DESCRIPTOR *Packet
1127+ )
1128+{
1129+ NETVSC_DEVICE* netDevice;
1130+ VMTRANSFER_PAGE_PACKET_HEADER *vmxferpagePacket;
1131+ NVSP_MESSAGE *nvspPacket;
1132+ NETVSC_PACKET *netvscPacket=NULL;
1133+ LIST_ENTRY* entry;
1134+ ULONG_PTR start;
1135+ ULONG_PTR end, endVirtual;
1136+ //NETVSC_DRIVER_OBJECT *netvscDriver;
1137+ XFERPAGE_PACKET *xferpagePacket=NULL;
1138+ LIST_ENTRY listHead;
1139+
1140+ int i=0, j=0;
1141+ int count=0, bytesRemain=0;
1142+
1143+ DPRINT_ENTER(NETVSC);
1144+
1145+ netDevice = GetInboundNetDevice(Device);
1146+ if (!netDevice)
1147+ {
1148+ DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
1149+ DPRINT_EXIT(NETVSC);
1150+ return;
1151+ }
1152+
1153+ // All inbound packets other than send completion should be xfer page packet
1154+ if (Packet->Type != VmbusPacketTypeDataUsingTransferPages)
1155+ {
1156+ DPRINT_ERR(NETVSC, "Unknown packet type received - %d", Packet->Type);
1157+ PutNetDevice(Device);
1158+ return;
1159+ }
1160+
1161+ nvspPacket = (NVSP_MESSAGE*)((ULONG_PTR)Packet + (Packet->DataOffset8 << 3));
1162+
1163+ // Make sure this is a valid nvsp packet
1164+ if (nvspPacket->Header.MessageType != NvspMessage1TypeSendRNDISPacket )
1165+ {
1166+ DPRINT_ERR(NETVSC, "Unknown nvsp packet type received - %d", nvspPacket->Header.MessageType);
1167+ PutNetDevice(Device);
1168+ return;
1169+ }
1170+
1171+ DPRINT_DBG(NETVSC, "NVSP packet received - type %d", nvspPacket->Header.MessageType);
1172+
1173+ vmxferpagePacket = (VMTRANSFER_PAGE_PACKET_HEADER*)Packet;
1174+
1175+ if (vmxferpagePacket->TransferPageSetId != NETVSC_RECEIVE_BUFFER_ID)
1176+ {
1177+ DPRINT_ERR(NETVSC, "Invalid xfer page set id - expecting %x got %x", NETVSC_RECEIVE_BUFFER_ID, vmxferpagePacket->TransferPageSetId);
1178+ PutNetDevice(Device);
1179+ return;
1180+ }
1181+
1182+ DPRINT_DBG(NETVSC, "xfer page - range count %d", vmxferpagePacket->RangeCount);
1183+
1184+ INITIALIZE_LIST_HEAD(&listHead);
1185+
1186+ // Grab free packets (range count + 1) to represent this xfer page packet. +1 to represent
1187+ // the xfer page packet itself. We grab it here so that we know exactly how many we can fulfil
1188+ SpinlockAcquire(netDevice->ReceivePacketListLock);
1189+ while (!IsListEmpty(&netDevice->ReceivePacketList))
1190+ {
1191+ entry = REMOVE_HEAD_LIST(&netDevice->ReceivePacketList);
1192+ netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
1193+
1194+ INSERT_TAIL_LIST(&listHead, &netvscPacket->ListEntry);
1195+
1196+ if (++count == vmxferpagePacket->RangeCount + 1)
1197+ break;
1198+ }
1199+ SpinlockRelease(netDevice->ReceivePacketListLock);
1200+
1201+ // We need at least 2 netvsc pkts (1 to represent the xfer page and at least 1 for the range)
1202+ // i.e. we can handled some of the xfer page packet ranges...
1203+ if (count < 2)
1204+ {
1205+ DPRINT_ERR(NETVSC, "Got only %d netvsc pkt...needed %d pkts. Dropping this xfer page packet completely!", count, vmxferpagePacket->RangeCount+1);
1206+
1207+ // Return it to the freelist
1208+ SpinlockAcquire(netDevice->ReceivePacketListLock);
1209+ for (i=count; i != 0; i--)
1210+ {
1211+ entry = REMOVE_HEAD_LIST(&listHead);
1212+ netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
1213+
1214+ INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &netvscPacket->ListEntry);
1215+ }
1216+ SpinlockRelease(netDevice->ReceivePacketListLock);
1217+
1218+ NetVscSendReceiveCompletion(Device, vmxferpagePacket->d.TransactionId);
1219+
1220+ PutNetDevice(Device);
1221+ return;
1222+ }
1223+
1224+ // Remove the 1st packet to represent the xfer page packet itself
1225+ entry = REMOVE_HEAD_LIST(&listHead);
1226+ xferpagePacket = CONTAINING_RECORD(entry, XFERPAGE_PACKET, ListEntry);
1227+ xferpagePacket->Count = count - 1; // This is how much we can satisfy
1228+ ASSERT(xferpagePacket->Count > 0 && xferpagePacket->Count <= vmxferpagePacket->RangeCount);
1229+
1230+ if (xferpagePacket->Count != vmxferpagePacket->RangeCount)
1231+ {
1232+ DPRINT_INFO(NETVSC, "Needed %d netvsc pkts to satisy this xfer page...got %d", vmxferpagePacket->RangeCount, xferpagePacket->Count);
1233+ }
1234+
1235+ // Each range represents 1 RNDIS pkt that contains 1 ethernet frame
1236+ for (i=0; i < (count - 1); i++)
1237+ {
1238+ entry = REMOVE_HEAD_LIST(&listHead);
1239+ netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
1240+
1241+ // Initialize the netvsc packet
1242+ netvscPacket->XferPagePacket = xferpagePacket;
1243+ netvscPacket->Completion.Recv.OnReceiveCompletion = NetVscOnReceiveCompletion;
1244+ netvscPacket->Completion.Recv.ReceiveCompletionContext = netvscPacket;
1245+ netvscPacket->Device = Device;
1246+ netvscPacket->Completion.Recv.ReceiveCompletionTid = vmxferpagePacket->d.TransactionId; // Save this so that we can send it back
1247+
1248+ netvscPacket->TotalDataBufferLength = vmxferpagePacket->Ranges[i].ByteCount;
1249+ netvscPacket->PageBufferCount = 1;
1250+
1251+ ASSERT(vmxferpagePacket->Ranges[i].ByteOffset + vmxferpagePacket->Ranges[i].ByteCount < netDevice->ReceiveBufferSize);
1252+
1253+ netvscPacket->PageBuffers[0].Length = vmxferpagePacket->Ranges[i].ByteCount;
1254+
1255+ start = GetPhysicalAddress((void*)((ULONG_PTR)netDevice->ReceiveBuffer + vmxferpagePacket->Ranges[i].ByteOffset));
1256+
1257+ netvscPacket->PageBuffers[0].Pfn = start >> PAGE_SHIFT;
1258+ endVirtual = (ULONG_PTR)netDevice->ReceiveBuffer
1259+ + vmxferpagePacket->Ranges[i].ByteOffset
1260+ + vmxferpagePacket->Ranges[i].ByteCount -1;
1261+ end = GetPhysicalAddress((void*)endVirtual);
1262+
1263+ // Calculate the page relative offset
1264+ netvscPacket->PageBuffers[0].Offset = vmxferpagePacket->Ranges[i].ByteOffset & (PAGE_SIZE -1);
1265+ if ((end >> PAGE_SHIFT) != (start>>PAGE_SHIFT)) {
1266+ //Handle frame across multiple pages:
1267+ netvscPacket->PageBuffers[0].Length =
1268+ (netvscPacket->PageBuffers[0].Pfn <<PAGE_SHIFT) + PAGE_SIZE - start;
1269+ bytesRemain = netvscPacket->TotalDataBufferLength - netvscPacket->PageBuffers[0].Length;
1270+ for (j=1; j<NETVSC_PACKET_MAXPAGE; j++) {
1271+ netvscPacket->PageBuffers[j].Offset = 0;
1272+ if (bytesRemain <= PAGE_SIZE) {
1273+ netvscPacket->PageBuffers[j].Length = bytesRemain;
1274+ bytesRemain = 0;
1275+ } else {
1276+ netvscPacket->PageBuffers[j].Length = PAGE_SIZE;
1277+ bytesRemain -= PAGE_SIZE;
1278+ }
1279+ netvscPacket->PageBuffers[j].Pfn =
1280+ GetPhysicalAddress((void*)(endVirtual - bytesRemain)) >> PAGE_SHIFT;
1281+ netvscPacket->PageBufferCount++;
1282+ if (bytesRemain == 0)
1283+ break;
1284+ }
1285+ ASSERT(bytesRemain == 0);
1286+ }
1287+ DPRINT_DBG(NETVSC, "[%d] - (abs offset %u len %u) => (pfn %llx, offset %u, len %u)",
1288+ i,
1289+ vmxferpagePacket->Ranges[i].ByteOffset,
1290+ vmxferpagePacket->Ranges[i].ByteCount,
1291+ netvscPacket->PageBuffers[0].Pfn,
1292+ netvscPacket->PageBuffers[0].Offset,
1293+ netvscPacket->PageBuffers[0].Length);
1294+
1295+ // Pass it to the upper layer
1296+ ((NETVSC_DRIVER_OBJECT*)Device->Driver)->OnReceiveCallback(Device, netvscPacket);
1297+
1298+ NetVscOnReceiveCompletion(netvscPacket->Completion.Recv.ReceiveCompletionContext);
1299+ }
1300+
1301+ ASSERT(IsListEmpty(&listHead));
1302+
1303+ PutNetDevice(Device);
1304+ DPRINT_EXIT(NETVSC);
1305+}
1306+
1307+
1308+static void
1309+NetVscSendReceiveCompletion(
1310+ DEVICE_OBJECT *Device,
1311+ UINT64 TransactionId
1312+ )
1313+{
1314+ NVSP_MESSAGE recvcompMessage;
1315+ int retries=0;
1316+ int ret=0;
1317+
1318+ DPRINT_DBG(NETVSC, "Sending receive completion pkt - %llx", TransactionId);
1319+
1320+ recvcompMessage.Header.MessageType = NvspMessage1TypeSendRNDISPacketComplete;
1321+
1322+ // FIXME: Pass in the status
1323+ recvcompMessage.Messages.Version1Messages.SendRNDISPacketComplete.Status = NvspStatusSuccess;
1324+
1325+retry_send_cmplt:
1326+ // Send the completion
1327+ ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
1328+ &recvcompMessage,
1329+ sizeof(NVSP_MESSAGE),
1330+ TransactionId,
1331+ VmbusPacketTypeCompletion,
1332+ 0);
1333+ if (ret == 0) // success
1334+ {
1335+ // no-op
1336+ }
1337+ else if (ret == -1) // no more room...wait a bit and attempt to retry 3 times
1338+ {
1339+ retries++;
1340+ DPRINT_ERR(NETVSC, "unable to send receive completion pkt (tid %llx)...retrying %d", TransactionId, retries);
1341+
1342+ if (retries < 4)
1343+ {
1344+ Sleep(100);
1345+ goto retry_send_cmplt;
1346+ }
1347+ else
1348+ {
1349+ DPRINT_ERR(NETVSC, "unable to send receive completion pkt (tid %llx)...give up retrying", TransactionId);
1350+ }
1351+ }
1352+ else
1353+ {
1354+ DPRINT_ERR(NETVSC, "unable to send receive completion pkt - %llx", TransactionId);
1355+ }
1356+}
1357+
1358+//
1359+// Send a receive completion packet to RNDIS device (ie NetVsp)
1360+//
1361+static void
1362+NetVscOnReceiveCompletion(
1363+ PVOID Context)
1364+{
1365+ NETVSC_PACKET *packet = (NETVSC_PACKET*)Context;
1366+ DEVICE_OBJECT *device = (DEVICE_OBJECT*)packet->Device;
1367+ NETVSC_DEVICE* netDevice;
1368+ UINT64 transactionId=0;
1369+ BOOL fSendReceiveComp = FALSE;
1370+
1371+ DPRINT_ENTER(NETVSC);
1372+
1373+ ASSERT(packet->XferPagePacket);
1374+
1375+ // Even though it seems logical to do a GetOutboundNetDevice() here to send out receive completion,
1376+ // we are using GetInboundNetDevice() since we may have disable outbound traffic already.
1377+ netDevice = GetInboundNetDevice(device);
1378+ if (!netDevice)
1379+ {
1380+ DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
1381+ DPRINT_EXIT(NETVSC);
1382+ return;
1383+ }
1384+
1385+ // Overloading use of the lock.
1386+ SpinlockAcquire(netDevice->ReceivePacketListLock);
1387+
1388+ ASSERT(packet->XferPagePacket->Count > 0);
1389+ packet->XferPagePacket->Count--;
1390+
1391+ // Last one in the line that represent 1 xfer page packet.
1392+ // Return the xfer page packet itself to the freelist
1393+ if (packet->XferPagePacket->Count == 0)
1394+ {
1395+ fSendReceiveComp = TRUE;
1396+ transactionId = packet->Completion.Recv.ReceiveCompletionTid;
1397+
1398+ INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &packet->XferPagePacket->ListEntry);
1399+ }
1400+
1401+ // Put the packet back
1402+ INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &packet->ListEntry);
1403+ SpinlockRelease(netDevice->ReceivePacketListLock);
1404+
1405+ // Send a receive completion for the xfer page packet
1406+ if (fSendReceiveComp)
1407+ {
1408+ NetVscSendReceiveCompletion(device, transactionId);
1409+ }
1410+
1411+ PutNetDevice(device);
1412+ DPRINT_EXIT(NETVSC);
1413+}
1414+
1415+
1416+
1417+void
1418+NetVscOnChannelCallback(
1419+ PVOID Context
1420+ )
1421+{
1422+ const int netPacketSize=2048;
1423+ int ret=0;
1424+ DEVICE_OBJECT *device=(DEVICE_OBJECT*)Context;
1425+ NETVSC_DEVICE *netDevice;
1426+
1427+ UINT32 bytesRecvd;
1428+ UINT64 requestId;
1429+ UCHAR packet[netPacketSize];
1430+ VMPACKET_DESCRIPTOR *desc;
1431+ UCHAR *buffer=packet;
1432+ int bufferlen=netPacketSize;
1433+
1434+
1435+ DPRINT_ENTER(NETVSC);
1436+
1437+ ASSERT(device);
1438+
1439+ netDevice = GetInboundNetDevice(device);
1440+ if (!netDevice)
1441+ {
1442+ DPRINT_ERR(NETVSC, "net device (%p) shutting down...ignoring inbound packets", netDevice);
1443+ DPRINT_EXIT(NETVSC);
1444+ return;
1445+ }
1446+
1447+ do
1448+ {
1449+ ret = device->Driver->VmbusChannelInterface.RecvPacketRaw(device,
1450+ buffer,
1451+ bufferlen,
1452+ &bytesRecvd,
1453+ &requestId);
1454+
1455+ if (ret == 0)
1456+ {
1457+ if (bytesRecvd > 0)
1458+ {
1459+ DPRINT_DBG(NETVSC, "receive %d bytes, tid %llx", bytesRecvd, requestId);
1460+
1461+ desc = (VMPACKET_DESCRIPTOR*)buffer;
1462+ switch (desc->Type)
1463+ {
1464+ case VmbusPacketTypeCompletion:
1465+ NetVscOnSendCompletion(device, desc);
1466+ break;
1467+
1468+ case VmbusPacketTypeDataUsingTransferPages:
1469+ NetVscOnReceive(device, desc);
1470+ break;
1471+
1472+ default:
1473+ DPRINT_ERR(NETVSC, "unhandled packet type %d, tid %llx len %d\n", desc->Type, requestId, bytesRecvd);
1474+ break;
1475+ }
1476+
1477+ // reset
1478+ if (bufferlen > netPacketSize)
1479+ {
1480+ MemFree(buffer);
1481+
1482+ buffer = packet;
1483+ bufferlen = netPacketSize;
1484+ }
1485+ }
1486+ else
1487+ {
1488+ //DPRINT_DBG(NETVSC, "nothing else to read...");
1489+
1490+ // reset
1491+ if (bufferlen > netPacketSize)
1492+ {
1493+ MemFree(buffer);
1494+
1495+ buffer = packet;
1496+ bufferlen = netPacketSize;
1497+ }
1498+
1499+ break;
1500+ }
1501+ }
1502+ else if (ret == -2) // Handle large packet
1503+ {
1504+ buffer = MemAllocAtomic(bytesRecvd);
1505+ if (buffer == NULL)
1506+ {
1507+ // Try again next time around
1508+ DPRINT_ERR(NETVSC, "unable to allocate buffer of size (%d)!!", bytesRecvd);
1509+ break;
1510+ }
1511+
1512+ bufferlen = bytesRecvd;
1513+ }
1514+ else
1515+ {
1516+ ASSERT(0);
1517+ }
1518+ } while (1);
1519+
1520+ PutNetDevice(device);
1521+ DPRINT_EXIT(NETVSC);
1522+ return;
1523+}
1524--- /dev/null
1525+++ b/drivers/staging/hv/netvsc_drv.c
1526@@ -0,0 +1,720 @@
1527+/*
1528+ *
1529+ * Copyright (c) 2009, Microsoft Corporation.
1530+ *
1531+ * This program is free software; you can redistribute it and/or modify it
1532+ * under the terms and conditions of the GNU General Public License,
1533+ * version 2, as published by the Free Software Foundation.
1534+ *
1535+ * This program is distributed in the hope it will be useful, but WITHOUT
1536+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1537+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
1538+ * more details.
1539+ *
1540+ * You should have received a copy of the GNU General Public License along with
1541+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
1542+ * Place - Suite 330, Boston, MA 02111-1307 USA.
1543+ *
1544+ * Authors:
1545+ * Hank Janssen <hjanssen@microsoft.com>
1546+ *
1547+ */
1548+
1549+
1550+#include <linux/init.h>
1551+#include <linux/module.h>
1552+#include <linux/highmem.h>
1553+#include <linux/device.h>
1554+#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
1555+#include <asm/io.h>
1556+#else
1557+#include <linux/io.h>
1558+#endif
1559+#include <linux/delay.h>
1560+#include <linux/netdevice.h>
1561+#include <linux/inetdevice.h>
1562+#include <linux/etherdevice.h>
1563+#include <linux/skbuff.h>
1564+#include <linux/in.h>
1565+#include <net/arp.h>
1566+#include <net/route.h>
1567+#include <net/sock.h>
1568+#include <net/pkt_sched.h>
1569+
1570+#include "logging.h"
1571+#include "vmbus.h"
1572+
1573+#include "NetVscApi.h"
1574+
1575+MODULE_LICENSE("GPL");
1576+
1577+//
1578+// Static decl
1579+//
1580+static int netvsc_probe(struct device *device);
1581+static int netvsc_remove(struct device *device);
1582+static int netvsc_open(struct net_device *net);
1583+static void netvsc_xmit_completion(void *context);
1584+static int netvsc_start_xmit (struct sk_buff *skb, struct net_device *net);
1585+static int netvsc_recv_callback(DEVICE_OBJECT *device_obj, NETVSC_PACKET* Packet);
1586+static int netvsc_close(struct net_device *net);
1587+static struct net_device_stats *netvsc_get_stats(struct net_device *net);
1588+static void netvsc_linkstatus_callback(DEVICE_OBJECT *device_obj, unsigned int status);
1589+
1590+//
1591+// Data types
1592+//
1593+struct net_device_context {
1594+ struct device_context *device_ctx; // point back to our device context
1595+ struct net_device_stats stats;
1596+};
1597+
1598+struct netvsc_driver_context {
1599+ // !! These must be the first 2 fields !!
1600+ struct driver_context drv_ctx;
1601+ NETVSC_DRIVER_OBJECT drv_obj;
1602+};
1603+
1604+//
1605+// Globals
1606+//
1607+
1608+static int netvsc_ringbuffer_size = NETVSC_DEVICE_RING_BUFFER_SIZE;
1609+
1610+// The one and only one
1611+static struct netvsc_driver_context g_netvsc_drv;
1612+
1613+//
1614+// Routines
1615+//
1616+
1617+/*++
1618+
1619+Name: netvsc_drv_init()
1620+
1621+Desc: NetVsc driver initialization
1622+
1623+--*/
1624+int netvsc_drv_init(PFN_DRIVERINITIALIZE pfn_drv_init)
1625+{
1626+ int ret=0;
1627+ NETVSC_DRIVER_OBJECT *net_drv_obj=&g_netvsc_drv.drv_obj;
1628+ struct driver_context *drv_ctx=&g_netvsc_drv.drv_ctx;
1629+
1630+ DPRINT_ENTER(NETVSC_DRV);
1631+
1632+ vmbus_get_interface(&net_drv_obj->Base.VmbusChannelInterface);
1633+
1634+ net_drv_obj->RingBufferSize = netvsc_ringbuffer_size;
1635+ net_drv_obj->OnReceiveCallback = netvsc_recv_callback;
1636+ net_drv_obj->OnLinkStatusChanged = netvsc_linkstatus_callback;
1637+
1638+ // Callback to client driver to complete the initialization
1639+ pfn_drv_init(&net_drv_obj->Base);
1640+
1641+ drv_ctx->driver.name = net_drv_obj->Base.name;
1642+ memcpy(&drv_ctx->class_id, &net_drv_obj->Base.deviceType, sizeof(GUID));
1643+
1644+#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
1645+ drv_ctx->driver.probe = netvsc_probe;
1646+ drv_ctx->driver.remove = netvsc_remove;
1647+#else
1648+ drv_ctx->probe = netvsc_probe;
1649+ drv_ctx->remove = netvsc_remove;
1650+#endif
1651+
1652+ // The driver belongs to vmbus
1653+ vmbus_child_driver_register(drv_ctx);
1654+
1655+ DPRINT_EXIT(NETVSC_DRV);
1656+
1657+ return ret;
1658+}
1659+
1660+/*++
1661+
1662+Name: netvsc_get_stats()
1663+
1664+Desc: Get the network stats
1665+
1666+--*/
1667+static struct net_device_stats *netvsc_get_stats(struct net_device *net)
1668+{
1669+ struct net_device_context *net_device_ctx = netdev_priv(net);
1670+
1671+ return &net_device_ctx->stats;
1672+}
1673+
1674+/*++
1675+
1676+Name: netvsc_set_multicast_list()
1677+
1678+Desc: Set the multicast list
1679+
1680+Remark: No-op here
1681+--*/
1682+static void netvsc_set_multicast_list(UNUSED_VAR(struct net_device *net))
1683+{
1684+}
1685+
1686+
1687+/*++
1688+
1689+Name: netvsc_probe()
1690+
1691+Desc: Add the specified new device to this driver
1692+
1693+--*/
1694+static int netvsc_probe(struct device *device)
1695+{
1696+ int ret=0;
1697+
1698+ struct driver_context *driver_ctx = driver_to_driver_context(device->driver);
1699+ struct netvsc_driver_context *net_drv_ctx = (struct netvsc_driver_context*)driver_ctx;
1700+ NETVSC_DRIVER_OBJECT *net_drv_obj = &net_drv_ctx->drv_obj;
1701+
1702+ struct device_context *device_ctx = device_to_device_context(device);
1703+ DEVICE_OBJECT *device_obj = &device_ctx->device_obj;
1704+
1705+ struct net_device *net = NULL;
1706+ struct net_device_context *net_device_ctx;
1707+ NETVSC_DEVICE_INFO device_info;
1708+
1709+ DPRINT_ENTER(NETVSC_DRV);
1710+
1711+ if (!net_drv_obj->Base.OnDeviceAdd)
1712+ {
1713+ return -1;
1714+ }
1715+
1716+ net = alloc_netdev(sizeof(struct net_device_context), "seth%d", ether_setup);
1717+ //net = alloc_etherdev(sizeof(struct net_device_context));
1718+ if (!net)
1719+ {
1720+ return -1;
1721+ }
1722+
1723+ // Set initial state
1724+ netif_carrier_off(net);
1725+ netif_stop_queue(net);
1726+
1727+ net_device_ctx = netdev_priv(net);
1728+ net_device_ctx->device_ctx = device_ctx;
1729+ device->driver_data = net;
1730+
1731+ // Notify the netvsc driver of the new device
1732+ ret = net_drv_obj->Base.OnDeviceAdd(device_obj, (void*)&device_info);
1733+ if (ret != 0)
1734+ {
1735+ free_netdev(net);
1736+ device->driver_data = NULL;
1737+
1738+ DPRINT_ERR(NETVSC_DRV, "unable to add netvsc device (ret %d)", ret);
1739+ return ret;
1740+ }
1741+
1742+ // If carrier is still off ie we did not get a link status callback, update it if necessary
1743+ // FIXME: We should use a atomic or test/set instead to avoid getting out of sync with the device's link status
1744+ if (!netif_carrier_ok(net))
1745+ {
1746+ if (!device_info.LinkState)
1747+ {
1748+ netif_carrier_on(net);
1749+ }
1750+ }
1751+
1752+ memcpy(net->dev_addr, device_info.MacAddr, ETH_ALEN);
1753+
1754+ net->open = netvsc_open;
1755+ net->hard_start_xmit = netvsc_start_xmit;
1756+ net->stop = netvsc_close;
1757+ net->get_stats = netvsc_get_stats;
1758+ net->set_multicast_list = netvsc_set_multicast_list;
1759+
1760+#if !defined(KERNEL_2_6_27)
1761+ SET_MODULE_OWNER(net);
1762+#endif
1763+ SET_NETDEV_DEV(net, device);
1764+
1765+ ret = register_netdev(net);
1766+ if (ret != 0)
1767+ {
1768+ // Remove the device and release the resource
1769+ net_drv_obj->Base.OnDeviceRemove(device_obj);
1770+ free_netdev(net);
1771+ }
1772+
1773+ DPRINT_EXIT(NETVSC_DRV);
1774+
1775+ return ret;
1776+}
1777+
1778+static int netvsc_remove(struct device *device)
1779+{
1780+ int ret=0;
1781+ struct driver_context *driver_ctx = driver_to_driver_context(device->driver);
1782+ struct netvsc_driver_context *net_drv_ctx = (struct netvsc_driver_context*)driver_ctx;
1783+ NETVSC_DRIVER_OBJECT *net_drv_obj = &net_drv_ctx->drv_obj;
1784+
1785+ struct device_context *device_ctx = device_to_device_context(device);
1786+ struct net_device *net = (struct net_device *)device_ctx->device.driver_data;
1787+ DEVICE_OBJECT *device_obj = &device_ctx->device_obj;
1788+
1789+ DPRINT_ENTER(NETVSC_DRV);
1790+
1791+ if (net == NULL)
1792+ {
1793+ DPRINT_INFO(NETVSC, "no net device to remove");
1794+ DPRINT_EXIT(NETVSC_DRV);
1795+ return 0;
1796+ }
1797+
1798+ if (!net_drv_obj->Base.OnDeviceRemove)
1799+ {
1800+ DPRINT_EXIT(NETVSC_DRV);
1801+ return -1;
1802+ }
1803+
1804+ // Stop outbound asap
1805+ netif_stop_queue(net);
1806+ //netif_carrier_off(net);
1807+
1808+ unregister_netdev(net);
1809+
1810+ // Call to the vsc driver to let it know that the device is being removed
1811+ ret = net_drv_obj->Base.OnDeviceRemove(device_obj);
1812+ if (ret != 0)
1813+ {
1814+ // TODO:
1815+ DPRINT_ERR(NETVSC, "unable to remove vsc device (ret %d)", ret);
1816+ }
1817+
1818+ free_netdev(net);
1819+
1820+ DPRINT_EXIT(NETVSC_DRV);
1821+
1822+ return ret;
1823+}
1824+
1825+/*++
1826+
1827+Name: netvsc_open()
1828+
1829+Desc: Open the specified interface device
1830+
1831+--*/
1832+static int netvsc_open(struct net_device *net)
1833+{
1834+ int ret=0;
1835+ struct net_device_context *net_device_ctx = netdev_priv(net);
1836+ struct driver_context *driver_ctx = driver_to_driver_context(net_device_ctx->device_ctx->device.driver);
1837+ struct netvsc_driver_context *net_drv_ctx = (struct netvsc_driver_context*)driver_ctx;
1838+ NETVSC_DRIVER_OBJECT *net_drv_obj = &net_drv_ctx->drv_obj;
1839+
1840+ DEVICE_OBJECT *device_obj = &net_device_ctx->device_ctx->device_obj;
1841+
1842+ DPRINT_ENTER(NETVSC_DRV);
1843+
1844+ if (netif_carrier_ok(net))
1845+ {
1846+ memset(&net_device_ctx->stats, 0 , sizeof(struct net_device_stats));
1847+
1848+ // Open up the device
1849+ ret = net_drv_obj->OnOpen(device_obj);
1850+ if (ret != 0)
1851+ {
1852+ DPRINT_ERR(NETVSC_DRV, "unable to open device (ret %d).", ret);
1853+ return ret;
1854+ }
1855+
1856+ netif_start_queue(net);
1857+ }
1858+ else
1859+ {
1860+ DPRINT_ERR(NETVSC_DRV, "unable to open device...link is down.");
1861+ }
1862+
1863+ DPRINT_EXIT(NETVSC_DRV);
1864+ return ret;
1865+}
1866+
1867+/*++
1868+
1869+Name: netvsc_close()
1870+
1871+Desc: Close the specified interface device
1872+
1873+--*/
1874+static int netvsc_close(struct net_device *net)
1875+{
1876+ int ret=0;
1877+ struct net_device_context *net_device_ctx = netdev_priv(net);
1878+ struct driver_context *driver_ctx = driver_to_driver_context(net_device_ctx->device_ctx->device.driver);
1879+ struct netvsc_driver_context *net_drv_ctx = (struct netvsc_driver_context*)driver_ctx;
1880+ NETVSC_DRIVER_OBJECT *net_drv_obj = &net_drv_ctx->drv_obj;
1881+
1882+ DEVICE_OBJECT *device_obj = &net_device_ctx->device_ctx->device_obj;
1883+
1884+ DPRINT_ENTER(NETVSC_DRV);
1885+
1886+ netif_stop_queue(net);
1887+
1888+ ret = net_drv_obj->OnClose(device_obj);
1889+ if (ret != 0)
1890+ {
1891+ DPRINT_ERR(NETVSC_DRV, "unable to close device (ret %d).", ret);
1892+ }
1893+
1894+ DPRINT_EXIT(NETVSC_DRV);
1895+
1896+ return ret;
1897+}
1898+
1899+
1900+/*++
1901+
1902+Name: netvsc_xmit_completion()
1903+
1904+Desc: Send completion processing
1905+
1906+--*/
1907+static void netvsc_xmit_completion(void *context)
1908+{
1909+ NETVSC_PACKET *packet = (NETVSC_PACKET *)context;
1910+ struct sk_buff *skb = (struct sk_buff *)(ULONG_PTR)packet->Completion.Send.SendCompletionTid;
1911+ struct net_device* net;
1912+
1913+ DPRINT_ENTER(NETVSC_DRV);
1914+
1915+ kfree(packet);
1916+
1917+ if (skb)
1918+ {
1919+ net = skb->dev;
1920+
1921+ dev_kfree_skb_any(skb);
1922+
1923+ if (netif_queue_stopped(net))
1924+ {
1925+ DPRINT_INFO(NETVSC_DRV, "net device (%p) waking up...", net);
1926+
1927+ netif_wake_queue(net);
1928+ }
1929+ }
1930+
1931+ DPRINT_EXIT(NETVSC_DRV);
1932+}
1933+
1934+/*++
1935+
1936+Name: netvsc_start_xmit()
1937+
1938+Desc: Start a send
1939+
1940+--*/
1941+static int netvsc_start_xmit (struct sk_buff *skb, struct net_device *net)
1942+{
1943+ int ret=0;
1944+ struct net_device_context *net_device_ctx = netdev_priv(net);
1945+ struct driver_context *driver_ctx = driver_to_driver_context(net_device_ctx->device_ctx->device.driver);
1946+ struct netvsc_driver_context *net_drv_ctx = (struct netvsc_driver_context*)driver_ctx;
1947+ NETVSC_DRIVER_OBJECT *net_drv_obj = &net_drv_ctx->drv_obj;
1948+
1949+ int i=0;
1950+ NETVSC_PACKET* packet;
1951+ int num_frags;
1952+ int retries=0;
1953+
1954+ DPRINT_ENTER(NETVSC_DRV);
1955+
1956+ // Support only 1 chain of frags
1957+ ASSERT(skb_shinfo(skb)->frag_list == NULL);
1958+ ASSERT(skb->dev == net);
1959+
1960+ DPRINT_DBG(NETVSC_DRV, "xmit packet - len %d data_len %d", skb->len, skb->data_len);
1961+
1962+ // Add 1 for skb->data and any additional ones requested
1963+ num_frags = skb_shinfo(skb)->nr_frags + 1 + net_drv_obj->AdditionalRequestPageBufferCount;
1964+
1965+ // Allocate a netvsc packet based on # of frags.
1966+ packet = kzalloc(sizeof(NETVSC_PACKET) + (num_frags * sizeof(PAGE_BUFFER)) + net_drv_obj->RequestExtSize, GFP_ATOMIC);
1967+ if (!packet)
1968+ {
1969+ DPRINT_ERR(NETVSC_DRV, "unable to allocate NETVSC_PACKET");
1970+ return -1;
1971+ }
1972+
1973+ packet->Extension = (void*)(unsigned long)packet + sizeof(NETVSC_PACKET) + (num_frags * sizeof(PAGE_BUFFER)) ;
1974+
1975+ // Setup the rndis header
1976+ packet->PageBufferCount = num_frags;
1977+
1978+ // TODO: Flush all write buffers/ memory fence ???
1979+ //wmb();
1980+
1981+ // Initialize it from the skb
1982+ ASSERT(skb->data);
1983+ packet->TotalDataBufferLength = skb->len;
1984+
1985+ // Start filling in the page buffers starting at AdditionalRequestPageBufferCount offset
1986+ packet->PageBuffers[net_drv_obj->AdditionalRequestPageBufferCount].Pfn = virt_to_phys(skb->data) >> PAGE_SHIFT;
1987+ packet->PageBuffers[net_drv_obj->AdditionalRequestPageBufferCount].Offset = (unsigned long)skb->data & (PAGE_SIZE -1);
1988+ packet->PageBuffers[net_drv_obj->AdditionalRequestPageBufferCount].Length = skb->len - skb->data_len;
1989+
1990+ ASSERT((skb->len - skb->data_len) <= PAGE_SIZE);
1991+
1992+ for (i=net_drv_obj->AdditionalRequestPageBufferCount+1; i<num_frags; i++)
1993+ {
1994+ packet->PageBuffers[i].Pfn = page_to_pfn(skb_shinfo(skb)->frags[i-(net_drv_obj->AdditionalRequestPageBufferCount+1)].page);
1995+ packet->PageBuffers[i].Offset = skb_shinfo(skb)->frags[i-(net_drv_obj->AdditionalRequestPageBufferCount+1)].page_offset;
1996+ packet->PageBuffers[i].Length = skb_shinfo(skb)->frags[i-(net_drv_obj->AdditionalRequestPageBufferCount+1)].size;
1997+ }
1998+
1999+ // Set the completion routine
2000+ packet->Completion.Send.OnSendCompletion = netvsc_xmit_completion;
2001+ packet->Completion.Send.SendCompletionContext = packet;
2002+ packet->Completion.Send.SendCompletionTid = (ULONG_PTR)skb;
2003+
2004+retry_send:
2005+ ret = net_drv_obj->OnSend(&net_device_ctx->device_ctx->device_obj, packet);
2006+
2007+ if (ret == 0)
2008+ {
2009+#ifdef KERNEL_2_6_5
2010+#define NETDEV_TX_OK 0
2011+#define NETDEV_TX_BUSY 0
2012+#endif
2013+ ret = NETDEV_TX_OK;
2014+ net_device_ctx->stats.tx_bytes += skb->len;
2015+ net_device_ctx->stats.tx_packets++;
2016+ }
2017+ else
2018+ {
2019+ retries++;
2020+ if (retries < 4)
2021+ {
2022+ DPRINT_ERR(NETVSC_DRV, "unable to send...retrying %d...", retries);
2023+ udelay(100);
2024+ goto retry_send;
2025+ }
2026+
2027+ // no more room or we are shutting down
2028+ DPRINT_ERR(NETVSC_DRV, "unable to send (%d)...marking net device (%p) busy", ret, net);
2029+ DPRINT_INFO(NETVSC_DRV, "net device (%p) stopping", net);
2030+
2031+ ret = NETDEV_TX_BUSY;
2032+ net_device_ctx->stats.tx_dropped++;
2033+
2034+ netif_stop_queue(net);
2035+
2036+ // Null it since the caller will free it instead of the completion routine
2037+ packet->Completion.Send.SendCompletionTid = 0;
2038+
2039+ // Release the resources since we will not get any send completion
2040+ netvsc_xmit_completion((void*)packet);
2041+ }
2042+
2043+ DPRINT_DBG(NETVSC_DRV, "# of xmits %lu total size %lu", net_device_ctx->stats.tx_packets, net_device_ctx->stats.tx_bytes);
2044+
2045+ DPRINT_EXIT(NETVSC_DRV);
2046+ return ret;
2047+}
2048+
2049+
2050+/*++
2051+
2052+Name: netvsc_linkstatus_callback()
2053+
2054+Desc: Link up/down notification
2055+
2056+--*/
2057+static void netvsc_linkstatus_callback(DEVICE_OBJECT *device_obj, unsigned int status)
2058+{
2059+ struct device_context* device_ctx = to_device_context(device_obj);
2060+ struct net_device* net = (struct net_device *)device_ctx->device.driver_data;
2061+
2062+ DPRINT_ENTER(NETVSC_DRV);
2063+
2064+ if (!net)
2065+ {
2066+ DPRINT_ERR(NETVSC_DRV, "got link status but net device not initialized yet");
2067+ return;
2068+ }
2069+
2070+ if (status == 1)
2071+ {
2072+ netif_carrier_on(net);
2073+ netif_wake_queue(net);
2074+ }
2075+ else
2076+ {
2077+ netif_carrier_off(net);
2078+ netif_stop_queue(net);
2079+ }
2080+ DPRINT_EXIT(NETVSC_DRV);
2081+}
2082+
2083+
2084+/*++
2085+
2086+Name: netvsc_recv_callback()
2087+
2088+Desc: Callback when we receive a packet from the "wire" on the specify device
2089+
2090+--*/
2091+static int netvsc_recv_callback(DEVICE_OBJECT *device_obj, NETVSC_PACKET* packet)
2092+{
2093+ int ret=0;
2094+ struct device_context *device_ctx = to_device_context(device_obj);
2095+ struct net_device *net = (struct net_device *)device_ctx->device.driver_data;
2096+ struct net_device_context *net_device_ctx;
2097+
2098+ struct sk_buff *skb;
2099+ void *data;
2100+ int i=0;
2101+ unsigned long flags;
2102+
2103+ DPRINT_ENTER(NETVSC_DRV);
2104+
2105+ if (!net)
2106+ {
2107+ DPRINT_ERR(NETVSC_DRV, "got receive callback but net device not initialized yet");
2108+ return 0;
2109+ }
2110+
2111+ net_device_ctx = netdev_priv(net);
2112+
2113+ // Allocate a skb - TODO preallocate this
2114+ //skb = alloc_skb(packet->TotalDataBufferLength, GFP_ATOMIC);
2115+ skb = dev_alloc_skb(packet->TotalDataBufferLength + 2); // Pad 2-bytes to align IP header to 16 bytes
2116+ ASSERT(skb);
2117+ skb_reserve(skb, 2);
2118+ skb->dev = net;
2119+
2120+ // for kmap_atomic
2121+ local_irq_save(flags);
2122+
2123+ // Copy to skb. This copy is needed here since the memory pointed by NETVSC_PACKET
2124+ // cannot be deallocated
2125+ for (i=0; i<packet->PageBufferCount; i++)
2126+ {
2127+ data = kmap_atomic(pfn_to_page(packet->PageBuffers[i].Pfn), KM_IRQ1);
2128+ data = (void*)(unsigned long)data + packet->PageBuffers[i].Offset;
2129+
2130+ memcpy(skb_put(skb, packet->PageBuffers[i].Length), data, packet->PageBuffers[i].Length);
2131+
2132+ kunmap_atomic((void*)((unsigned long)data - packet->PageBuffers[i].Offset), KM_IRQ1);
2133+ }
2134+
2135+ local_irq_restore(flags);
2136+
2137+ skb->protocol = eth_type_trans(skb, net);
2138+
2139+ skb->ip_summed = CHECKSUM_NONE;
2140+
2141+ // Pass the skb back up. Network stack will deallocate the skb when it is done
2142+ ret = netif_rx(skb);
2143+
2144+ switch (ret)
2145+ {
2146+ case NET_RX_DROP:
2147+ net_device_ctx->stats.rx_dropped++;
2148+ break;
2149+ default:
2150+ net_device_ctx->stats.rx_packets++;
2151+ net_device_ctx->stats.rx_bytes += skb->len;
2152+ break;
2153+
2154+ }
2155+ DPRINT_DBG(NETVSC_DRV, "# of recvs %lu total size %lu", net_device_ctx->stats.rx_packets, net_device_ctx->stats.rx_bytes);
2156+
2157+ DPRINT_EXIT(NETVSC_DRV);
2158+
2159+ return 0;
2160+}
2161+
2162+static int netvsc_drv_exit_cb(struct device *dev, void *data)
2163+{
2164+ struct device **curr = (struct device **)data;
2165+ *curr = dev;
2166+ return 1; // stop iterating
2167+}
2168+
2169+/*++
2170+
2171+Name: netvsc_drv_exit()
2172+
2173+Desc:
2174+
2175+--*/
2176+void netvsc_drv_exit(void)
2177+{
2178+ NETVSC_DRIVER_OBJECT *netvsc_drv_obj=&g_netvsc_drv.drv_obj;
2179+ struct driver_context *drv_ctx=&g_netvsc_drv.drv_ctx;
2180+
2181+ struct device *current_dev=NULL;
2182+#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
2183+#define driver_for_each_device(drv, start, data, fn) \
2184+ struct list_head *ptr, *n; \
2185+ list_for_each_safe(ptr, n, &((drv)->devices)) {\
2186+ struct device *curr_dev;\
2187+ curr_dev = list_entry(ptr, struct device, driver_list);\
2188+ fn(curr_dev, data);\
2189+ }
2190+#endif
2191+
2192+ DPRINT_ENTER(NETVSC_DRV);
2193+
2194+ while (1)
2195+ {
2196+ current_dev = NULL;
2197+
2198+ // Get the device
2199+ driver_for_each_device(&drv_ctx->driver, NULL, (void*)&current_dev, netvsc_drv_exit_cb);
2200+
2201+ if (current_dev == NULL)
2202+ break;
2203+
2204+ // Initiate removal from the top-down
2205+ DPRINT_INFO(NETVSC_DRV, "unregistering device (%p)...", current_dev);
2206+
2207+ device_unregister(current_dev);
2208+ }
2209+
2210+ if (netvsc_drv_obj->Base.OnCleanup)
2211+ netvsc_drv_obj->Base.OnCleanup(&netvsc_drv_obj->Base);
2212+
2213+ vmbus_child_driver_unregister(drv_ctx);
2214+
2215+ DPRINT_EXIT(NETVSC_DRV);
2216+
2217+ return;
2218+}
2219+
2220+static int __init netvsc_init(void)
2221+{
2222+ int ret;
2223+
2224+ DPRINT_ENTER(NETVSC_DRV);
2225+ DPRINT_INFO(NETVSC_DRV, "Netvsc initializing....");
2226+
2227+ ret = netvsc_drv_init(NetVscInitialize);
2228+
2229+ DPRINT_EXIT(NETVSC_DRV);
2230+
2231+ return ret;
2232+}
2233+
2234+static void __exit netvsc_exit(void)
2235+{
2236+ DPRINT_ENTER(NETVSC_DRV);
2237+
2238+ netvsc_drv_exit();
2239+
2240+ DPRINT_EXIT(NETVSC_DRV);
2241+}
2242+
2243+module_param(netvsc_ringbuffer_size, int, S_IRUGO);
2244+
2245+module_init(netvsc_init);
2246+module_exit(netvsc_exit);
2247--- /dev/null
2248+++ b/drivers/staging/hv/NetVsc.h
2249@@ -0,0 +1,91 @@
2250+/*
2251+ *
2252+ * Copyright (c) 2009, Microsoft Corporation.
2253+ *
2254+ * This program is free software; you can redistribute it and/or modify it
2255+ * under the terms and conditions of the GNU General Public License,
2256+ * version 2, as published by the Free Software Foundation.
2257+ *
2258+ * This program is distributed in the hope it will be useful, but WITHOUT
2259+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
2260+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
2261+ * more details.
2262+ *
2263+ * You should have received a copy of the GNU General Public License along with
2264+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
2265+ * Place - Suite 330, Boston, MA 02111-1307 USA.
2266+ *
2267+ * Authors:
2268+ * Hank Janssen <hjanssen@microsoft.com>
2269+ *
2270+ */
2271+
2272+
2273+#ifndef _NETVSC_H_
2274+#define _NETVSC_H_
2275+
2276+#include "VmbusPacketFormat.h"
2277+#include "nvspprotocol.h"
2278+
2279+#include "List.h"
2280+
2281+#include "NetVscApi.h"
2282+//
2283+// #defines
2284+//
2285+//#define NVSC_MIN_PROTOCOL_VERSION 1
2286+//#define NVSC_MAX_PROTOCOL_VERSION 1
2287+
2288+#define NETVSC_SEND_BUFFER_SIZE 64*1024 // 64K
2289+#define NETVSC_SEND_BUFFER_ID 0xface
2290+
2291+
2292+#define NETVSC_RECEIVE_BUFFER_SIZE 1024*1024 // 1MB
2293+
2294+#define NETVSC_RECEIVE_BUFFER_ID 0xcafe
2295+
2296+#define NETVSC_RECEIVE_SG_COUNT 1
2297+
2298+// Preallocated receive packets
2299+#define NETVSC_RECEIVE_PACKETLIST_COUNT 256
2300+
2301+//
2302+// Data types
2303+//
2304+
2305+// Per netvsc channel-specific
2306+typedef struct _NETVSC_DEVICE {
2307+ DEVICE_OBJECT *Device;
2308+
2309+ int RefCount;
2310+
2311+ int NumOutstandingSends;
2312+ // List of free preallocated NETVSC_PACKET to represent receive packet
2313+ LIST_ENTRY ReceivePacketList;
2314+ HANDLE ReceivePacketListLock;
2315+
2316+ // Send buffer allocated by us but manages by NetVSP
2317+ PVOID SendBuffer;
2318+ UINT32 SendBufferSize;
2319+ UINT32 SendBufferGpadlHandle;
2320+ UINT32 SendSectionSize;
2321+
2322+ // Receive buffer allocated by us but manages by NetVSP
2323+ PVOID ReceiveBuffer;
2324+ UINT32 ReceiveBufferSize;
2325+ UINT32 ReceiveBufferGpadlHandle;
2326+ UINT32 ReceiveSectionCount;
2327+ PNVSP_1_RECEIVE_BUFFER_SECTION ReceiveSections;
2328+
2329+ // Used for NetVSP initialization protocol
2330+ HANDLE ChannelInitEvent;
2331+ NVSP_MESSAGE ChannelInitPacket;
2332+
2333+ NVSP_MESSAGE RevokePacket;
2334+ //UCHAR HwMacAddr[HW_MACADDR_LEN];
2335+
2336+ // Holds rndis device info
2337+ void *Extension;
2338+} NETVSC_DEVICE;
2339+
2340+#endif // _NETVSC_H_
2341--- /dev/null
2342+++ b/drivers/staging/hv/RndisFilter.c
2343@@ -0,0 +1,1162 @@
2344+/*
2345+ *
2346+ * Copyright (c) 2009, Microsoft Corporation.
2347+ *
2348+ * This program is free software; you can redistribute it and/or modify it
2349+ * under the terms and conditions of the GNU General Public License,
2350+ * version 2, as published by the Free Software Foundation.
2351+ *
2352+ * This program is distributed in the hope it will be useful, but WITHOUT
2353+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
2354+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
2355+ * more details.
2356+ *
2357+ * You should have received a copy of the GNU General Public License along with
2358+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
2359+ * Place - Suite 330, Boston, MA 02111-1307 USA.
2360+ *
2361+ * Authors:
2362+ * Haiyang Zhang <haiyangz@microsoft.com>
2363+ * Hank Janssen <hjanssen@microsoft.com>
2364+ *
2365+ */
2366+
2367+
2368+#include "logging.h"
2369+
2370+#include "NetVscApi.h"
2371+#include "RndisFilter.h"
2372+
2373+//
2374+// Data types
2375+//
2376+
2377+typedef struct _RNDIS_FILTER_DRIVER_OBJECT {
2378+ // The original driver
2379+ NETVSC_DRIVER_OBJECT InnerDriver;
2380+
2381+} RNDIS_FILTER_DRIVER_OBJECT;
2382+
2383+typedef enum {
2384+ RNDIS_DEV_UNINITIALIZED = 0,
2385+ RNDIS_DEV_INITIALIZING,
2386+ RNDIS_DEV_INITIALIZED,
2387+ RNDIS_DEV_DATAINITIALIZED,
2388+} RNDIS_DEVICE_STATE;
2389+
2390+typedef struct _RNDIS_DEVICE {
2391+ NETVSC_DEVICE *NetDevice;
2392+
2393+ RNDIS_DEVICE_STATE State;
2394+ UINT32 LinkStatus;
2395+ UINT32 NewRequestId;
2396+
2397+ HANDLE RequestLock;
2398+ LIST_ENTRY RequestList;
2399+
2400+ UCHAR HwMacAddr[HW_MACADDR_LEN];
2401+} RNDIS_DEVICE;
2402+
2403+
2404+typedef struct _RNDIS_REQUEST {
2405+ LIST_ENTRY ListEntry;
2406+ HANDLE WaitEvent;
2407+
2408+ // FIXME: We assumed a fixed size response here. If we do ever need to handle a bigger response,
2409+ // we can either define a max response message or add a response buffer variable above this field
2410+ RNDIS_MESSAGE ResponseMessage;
2411+
2412+ // Simplify allocation by having a netvsc packet inline
2413+ NETVSC_PACKET Packet;
2414+ PAGE_BUFFER Buffer;
2415+ // FIXME: We assumed a fixed size request here.
2416+ RNDIS_MESSAGE RequestMessage;
2417+} RNDIS_REQUEST;
2418+
2419+
2420+typedef struct _RNDIS_FILTER_PACKET {
2421+ void *CompletionContext;
2422+ PFN_ON_SENDRECVCOMPLETION OnCompletion;
2423+
2424+ RNDIS_MESSAGE Message;
2425+} RNDIS_FILTER_PACKET;
2426+
2427+//
2428+// Internal routines
2429+//
2430+static int
2431+RndisFilterSendRequest(
2432+ RNDIS_DEVICE *Device,
2433+ RNDIS_REQUEST *Request
2434+ );
2435+
2436+static void
2437+RndisFilterReceiveResponse(
2438+ RNDIS_DEVICE *Device,
2439+ RNDIS_MESSAGE *Response
2440+ );
2441+
2442+static void
2443+RndisFilterReceiveIndicateStatus(
2444+ RNDIS_DEVICE *Device,
2445+ RNDIS_MESSAGE *Response
2446+ );
2447+
2448+static void
2449+RndisFilterReceiveData(
2450+ RNDIS_DEVICE *Device,
2451+ RNDIS_MESSAGE *Message,
2452+ NETVSC_PACKET *Packet
2453+ );
2454+
2455+static int
2456+RndisFilterOnReceive(
2457+ DEVICE_OBJECT *Device,
2458+ NETVSC_PACKET *Packet
2459+ );
2460+
2461+static int
2462+RndisFilterQueryDevice(
2463+ RNDIS_DEVICE *Device,
2464+ UINT32 Oid,
2465+ VOID *Result,
2466+ UINT32 *ResultSize
2467+ );
2468+
2469+static inline int
2470+RndisFilterQueryDeviceMac(
2471+ RNDIS_DEVICE *Device
2472+ );
2473+
2474+static inline int
2475+RndisFilterQueryDeviceLinkStatus(
2476+ RNDIS_DEVICE *Device
2477+ );
2478+
2479+static int
2480+RndisFilterSetPacketFilter(
2481+ RNDIS_DEVICE *Device,
2482+ UINT32 NewFilter
2483+ );
2484+
2485+static int
2486+RndisFilterInitDevice(
2487+ RNDIS_DEVICE *Device
2488+ );
2489+
2490+static int
2491+RndisFilterOpenDevice(
2492+ RNDIS_DEVICE *Device
2493+ );
2494+
2495+static int
2496+RndisFilterCloseDevice(
2497+ RNDIS_DEVICE *Device
2498+ );
2499+
2500+static int
2501+RndisFilterOnDeviceAdd(
2502+ DEVICE_OBJECT *Device,
2503+ void *AdditionalInfo
2504+ );
2505+
2506+static int
2507+RndisFilterOnDeviceRemove(
2508+ DEVICE_OBJECT *Device
2509+ );
2510+
2511+static void
2512+RndisFilterOnCleanup(
2513+ DRIVER_OBJECT *Driver
2514+ );
2515+
2516+static int
2517+RndisFilterOnOpen(
2518+ DEVICE_OBJECT *Device
2519+ );
2520+
2521+static int
2522+RndisFilterOnClose(
2523+ DEVICE_OBJECT *Device
2524+ );
2525+
2526+static int
2527+RndisFilterOnSend(
2528+ DEVICE_OBJECT *Device,
2529+ NETVSC_PACKET *Packet
2530+ );
2531+
2532+static void
2533+RndisFilterOnSendCompletion(
2534+ void *Context
2535+ );
2536+
2537+static void
2538+RndisFilterOnSendRequestCompletion(
2539+ void *Context
2540+ );
2541+
2542+//
2543+// Global var
2544+//
2545+
2546+// The one and only
2547+RNDIS_FILTER_DRIVER_OBJECT gRndisFilter;
2548+
2549+static inline RNDIS_DEVICE* GetRndisDevice(void)
2550+{
2551+ RNDIS_DEVICE *device;
2552+
2553+ device = MemAllocZeroed(sizeof(RNDIS_DEVICE));
2554+ if (!device)
2555+ {
2556+ return NULL;
2557+ }
2558+
2559+ device->RequestLock = SpinlockCreate();
2560+ if (!device->RequestLock)
2561+ {
2562+ MemFree(device);
2563+ return NULL;
2564+ }
2565+
2566+ INITIALIZE_LIST_HEAD(&device->RequestList);
2567+
2568+ device->State = RNDIS_DEV_UNINITIALIZED;
2569+
2570+ return device;
2571+}
2572+
2573+static inline void PutRndisDevice(RNDIS_DEVICE *Device)
2574+{
2575+ SpinlockClose(Device->RequestLock);
2576+ MemFree(Device);
2577+}
2578+
2579+static inline RNDIS_REQUEST* GetRndisRequest(RNDIS_DEVICE *Device, UINT32 MessageType, UINT32 MessageLength)
2580+{
2581+ RNDIS_REQUEST *request;
2582+ RNDIS_MESSAGE *rndisMessage;
2583+ RNDIS_SET_REQUEST *set;
2584+
2585+ request = MemAllocZeroed(sizeof(RNDIS_REQUEST));
2586+ if (!request)
2587+ {
2588+ return NULL;
2589+ }
2590+
2591+ request->WaitEvent = WaitEventCreate();
2592+ if (!request->WaitEvent)
2593+ {
2594+ MemFree(request);
2595+ return NULL;
2596+ }
2597+
2598+ rndisMessage = &request->RequestMessage;
2599+ rndisMessage->NdisMessageType = MessageType;
2600+ rndisMessage->MessageLength = MessageLength;
2601+
2602+ // Set the request id. This field is always after the rndis header for request/response packet types so
2603+ // we just used the SetRequest as a template
2604+ set = &rndisMessage->Message.SetRequest;
2605+ set->RequestId = InterlockedIncrement((int*)&Device->NewRequestId);
2606+
2607+ // Add to the request list
2608+ SpinlockAcquire(Device->RequestLock);
2609+ INSERT_TAIL_LIST(&Device->RequestList, &request->ListEntry);
2610+ SpinlockRelease(Device->RequestLock);
2611+
2612+ return request;
2613+}
2614+
2615+static inline void PutRndisRequest(RNDIS_DEVICE *Device, RNDIS_REQUEST *Request)
2616+{
2617+ SpinlockAcquire(Device->RequestLock);
2618+ REMOVE_ENTRY_LIST(&Request->ListEntry);
2619+ SpinlockRelease(Device->RequestLock);
2620+
2621+ WaitEventClose(Request->WaitEvent);
2622+ MemFree(Request);
2623+}
2624+
2625+static inline void DumpRndisMessage(RNDIS_MESSAGE *RndisMessage)
2626+{
2627+ switch (RndisMessage->NdisMessageType)
2628+ {
2629+ case REMOTE_NDIS_PACKET_MSG:
2630+ 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",
2631+ RndisMessage->MessageLength,
2632+ RndisMessage->Message.Packet.DataOffset,
2633+ RndisMessage->Message.Packet.DataLength,
2634+ RndisMessage->Message.Packet.NumOOBDataElements,
2635+ RndisMessage->Message.Packet.OOBDataOffset,
2636+ RndisMessage->Message.Packet.OOBDataLength,
2637+ RndisMessage->Message.Packet.PerPacketInfoOffset,
2638+ RndisMessage->Message.Packet.PerPacketInfoLength);
2639+ break;
2640+
2641+ case REMOTE_NDIS_INITIALIZE_CMPLT:
2642+ 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)",
2643+ RndisMessage->MessageLength,
2644+ RndisMessage->Message.InitializeComplete.RequestId,
2645+ RndisMessage->Message.InitializeComplete.Status,
2646+ RndisMessage->Message.InitializeComplete.MajorVersion,
2647+ RndisMessage->Message.InitializeComplete.MinorVersion,
2648+ RndisMessage->Message.InitializeComplete.DeviceFlags,
2649+ RndisMessage->Message.InitializeComplete.MaxTransferSize,
2650+ RndisMessage->Message.InitializeComplete.MaxPacketsPerMessage,
2651+ RndisMessage->Message.InitializeComplete.PacketAlignmentFactor);
2652+ break;
2653+
2654+ case REMOTE_NDIS_QUERY_CMPLT:
2655+ DPRINT_DBG(NETVSC, "REMOTE_NDIS_QUERY_CMPLT (len %u, id 0x%x, status 0x%x, buf len %u, buf offset %u)",
2656+ RndisMessage->MessageLength,
2657+ RndisMessage->Message.QueryComplete.RequestId,
2658+ RndisMessage->Message.QueryComplete.Status,
2659+ RndisMessage->Message.QueryComplete.InformationBufferLength,
2660+ RndisMessage->Message.QueryComplete.InformationBufferOffset);
2661+ break;
2662+
2663+ case REMOTE_NDIS_SET_CMPLT:
2664+ DPRINT_DBG(NETVSC, "REMOTE_NDIS_SET_CMPLT (len %u, id 0x%x, status 0x%x)",
2665+ RndisMessage->MessageLength,
2666+ RndisMessage->Message.SetComplete.RequestId,
2667+ RndisMessage->Message.SetComplete.Status);
2668+ break;
2669+
2670+ case REMOTE_NDIS_INDICATE_STATUS_MSG:
2671+ DPRINT_DBG(NETVSC, "REMOTE_NDIS_INDICATE_STATUS_MSG (len %u, status 0x%x, buf len %u, buf offset %u)",
2672+ RndisMessage->MessageLength,
2673+ RndisMessage->Message.IndicateStatus.Status,
2674+ RndisMessage->Message.IndicateStatus.StatusBufferLength,
2675+ RndisMessage->Message.IndicateStatus.StatusBufferOffset);
2676+ break;
2677+
2678+ default:
2679+ DPRINT_DBG(NETVSC, "0x%x (len %u)",
2680+ RndisMessage->NdisMessageType,
2681+ RndisMessage->MessageLength);
2682+ break;
2683+ }
2684+}
2685+
2686+static int
2687+RndisFilterSendRequest(
2688+ RNDIS_DEVICE *Device,
2689+ RNDIS_REQUEST *Request
2690+ )
2691+{
2692+ int ret=0;
2693+ NETVSC_PACKET *packet;
2694+
2695+ DPRINT_ENTER(NETVSC);
2696+
2697+ // Setup the packet to send it
2698+ packet = &Request->Packet;
2699+
2700+ packet->IsDataPacket = FALSE;
2701+ packet->TotalDataBufferLength = Request->RequestMessage.MessageLength;
2702+ packet->PageBufferCount = 1;
2703+
2704+ packet->PageBuffers[0].Pfn = GetPhysicalAddress(&Request->RequestMessage) >> PAGE_SHIFT;
2705+ packet->PageBuffers[0].Length = Request->RequestMessage.MessageLength;
2706+ packet->PageBuffers[0].Offset = (ULONG_PTR)&Request->RequestMessage & (PAGE_SIZE -1);
2707+
2708+ packet->Completion.Send.SendCompletionContext = Request;//packet;
2709+ packet->Completion.Send.OnSendCompletion = RndisFilterOnSendRequestCompletion;
2710+ packet->Completion.Send.SendCompletionTid = (ULONG_PTR)Device;
2711+
2712+ ret = gRndisFilter.InnerDriver.OnSend(Device->NetDevice->Device, packet);
2713+ DPRINT_EXIT(NETVSC);
2714+ return ret;
2715+}
2716+
2717+
2718+static void
2719+RndisFilterReceiveResponse(
2720+ RNDIS_DEVICE *Device,
2721+ RNDIS_MESSAGE *Response
2722+ )
2723+{
2724+ LIST_ENTRY *anchor;
2725+ LIST_ENTRY *curr;
2726+ RNDIS_REQUEST *request=NULL;
2727+ BOOL found=FALSE;
2728+
2729+ DPRINT_ENTER(NETVSC);
2730+
2731+ SpinlockAcquire(Device->RequestLock);
2732+ ITERATE_LIST_ENTRIES(anchor, curr, &Device->RequestList)
2733+ {
2734+ request = CONTAINING_RECORD(curr, RNDIS_REQUEST, ListEntry);
2735+
2736+ // All request/response message contains RequestId as the 1st field
2737+ if (request->RequestMessage.Message.InitializeRequest.RequestId == Response->Message.InitializeComplete.RequestId)
2738+ {
2739+ DPRINT_DBG(NETVSC, "found rndis request for this response (id 0x%x req type 0x%x res type 0x%x)",
2740+ request->RequestMessage.Message.InitializeRequest.RequestId, request->RequestMessage.NdisMessageType, Response->NdisMessageType);
2741+
2742+ found = TRUE;
2743+ break;
2744+ }
2745+ }
2746+ SpinlockRelease(Device->RequestLock);
2747+
2748+ if (found)
2749+ {
2750+ if (Response->MessageLength <= sizeof(RNDIS_MESSAGE))
2751+ {
2752+ memcpy(&request->ResponseMessage, Response, Response->MessageLength);
2753+ }
2754+ else
2755+ {
2756+ DPRINT_ERR(NETVSC, "rndis response buffer overflow detected (size %u max %u)", Response->MessageLength, sizeof(RNDIS_FILTER_PACKET));
2757+
2758+ if (Response->NdisMessageType == REMOTE_NDIS_RESET_CMPLT) // does not have a request id field
2759+ {
2760+ request->ResponseMessage.Message.ResetComplete.Status = STATUS_BUFFER_OVERFLOW;
2761+ }
2762+ else
2763+ {
2764+ request->ResponseMessage.Message.InitializeComplete.Status = STATUS_BUFFER_OVERFLOW;
2765+ }
2766+ }
2767+
2768+ WaitEventSet(request->WaitEvent);
2769+ }
2770+ else
2771+ {
2772+ DPRINT_ERR(NETVSC, "no rndis request found for this response (id 0x%x res type 0x%x)",
2773+ Response->Message.InitializeComplete.RequestId, Response->NdisMessageType);
2774+ }
2775+
2776+ DPRINT_EXIT(NETVSC);
2777+}
2778+
2779+static void
2780+RndisFilterReceiveIndicateStatus(
2781+ RNDIS_DEVICE *Device,
2782+ RNDIS_MESSAGE *Response
2783+ )
2784+{
2785+ RNDIS_INDICATE_STATUS *indicate = &Response->Message.IndicateStatus;
2786+
2787+ if (indicate->Status == RNDIS_STATUS_MEDIA_CONNECT)
2788+ {
2789+ gRndisFilter.InnerDriver.OnLinkStatusChanged(Device->NetDevice->Device, 1);
2790+ }
2791+ else if (indicate->Status == RNDIS_STATUS_MEDIA_DISCONNECT)
2792+ {
2793+ gRndisFilter.InnerDriver.OnLinkStatusChanged(Device->NetDevice->Device, 0);
2794+ }
2795+ else
2796+ {
2797+ // TODO:
2798+ }
2799+}
2800+
2801+static void
2802+RndisFilterReceiveData(
2803+ RNDIS_DEVICE *Device,
2804+ RNDIS_MESSAGE *Message,
2805+ NETVSC_PACKET *Packet
2806+ )
2807+{
2808+ RNDIS_PACKET *rndisPacket;
2809+ UINT32 dataOffset;
2810+
2811+ DPRINT_ENTER(NETVSC);
2812+
2813+ // empty ethernet frame ??
2814+ ASSERT(Packet->PageBuffers[0].Length > RNDIS_MESSAGE_SIZE(RNDIS_PACKET));
2815+
2816+ rndisPacket = &Message->Message.Packet;
2817+
2818+ // FIXME: Handle multiple rndis pkt msgs that maybe enclosed in this
2819+ // netvsc packet (ie TotalDataBufferLength != MessageLength)
2820+
2821+ // Remove the rndis header and pass it back up the stack
2822+ dataOffset = RNDIS_HEADER_SIZE + rndisPacket->DataOffset;
2823+
2824+ Packet->TotalDataBufferLength -= dataOffset;
2825+ Packet->PageBuffers[0].Offset += dataOffset;
2826+ Packet->PageBuffers[0].Length -= dataOffset;
2827+
2828+ Packet->IsDataPacket = TRUE;
2829+
2830+ gRndisFilter.InnerDriver.OnReceiveCallback(Device->NetDevice->Device, Packet);
2831+
2832+ DPRINT_EXIT(NETVSC);
2833+}
2834+
2835+static int
2836+RndisFilterOnReceive(
2837+ DEVICE_OBJECT *Device,
2838+ NETVSC_PACKET *Packet
2839+ )
2840+{
2841+ NETVSC_DEVICE *netDevice = (NETVSC_DEVICE*)Device->Extension;
2842+ RNDIS_DEVICE *rndisDevice;
2843+ RNDIS_MESSAGE rndisMessage;
2844+ RNDIS_MESSAGE *rndisHeader;
2845+
2846+ DPRINT_ENTER(NETVSC);
2847+
2848+ ASSERT(netDevice);
2849+ //Make sure the rndis device state is initialized
2850+ if (!netDevice->Extension)
2851+ {
2852+ DPRINT_ERR(NETVSC, "got rndis message but no rndis device...dropping this message!");
2853+ DPRINT_EXIT(NETVSC);
2854+ return -1;
2855+ }
2856+
2857+ rndisDevice = (RNDIS_DEVICE*)netDevice->Extension;
2858+ if (rndisDevice->State == RNDIS_DEV_UNINITIALIZED)
2859+ {
2860+ DPRINT_ERR(NETVSC, "got rndis message but rndis device uninitialized...dropping this message!");
2861+ DPRINT_EXIT(NETVSC);
2862+ return -1;
2863+ }
2864+
2865+ rndisHeader = (RNDIS_MESSAGE*)PageMapVirtualAddress(Packet->PageBuffers[0].Pfn);
2866+
2867+ rndisHeader = (void*)((ULONG_PTR)rndisHeader + Packet->PageBuffers[0].Offset);
2868+
2869+ // Make sure we got a valid rndis message
2870+ // FIXME: There seems to be a bug in set completion msg where its MessageLength is 16 bytes but
2871+ // the ByteCount field in the xfer page range shows 52 bytes
2872+#if 0
2873+ if ( Packet->TotalDataBufferLength != rndisHeader->MessageLength )
2874+ {
2875+ PageUnmapVirtualAddress((void*)(ULONG_PTR)rndisHeader - Packet->PageBuffers[0].Offset);
2876+
2877+ DPRINT_ERR(NETVSC, "invalid rndis message? (expected %u bytes got %u)...dropping this message!",
2878+ rndisHeader->MessageLength, Packet->TotalDataBufferLength);
2879+ DPRINT_EXIT(NETVSC);
2880+ return -1;
2881+ }
2882+#endif
2883+
2884+ if ((rndisHeader->NdisMessageType != REMOTE_NDIS_PACKET_MSG) && (rndisHeader->MessageLength > sizeof(RNDIS_MESSAGE)))
2885+ {
2886+ DPRINT_ERR(NETVSC, "incoming rndis message buffer overflow detected (got %u, max %u)...marking it an error!",
2887+ rndisHeader->MessageLength, sizeof(RNDIS_MESSAGE));
2888+ }
2889+
2890+ memcpy(&rndisMessage, rndisHeader, (rndisHeader->MessageLength > sizeof(RNDIS_MESSAGE))?sizeof(RNDIS_MESSAGE):rndisHeader->MessageLength);
2891+
2892+ PageUnmapVirtualAddress((void*)(ULONG_PTR)rndisHeader - Packet->PageBuffers[0].Offset);
2893+
2894+ DumpRndisMessage(&rndisMessage);
2895+
2896+ switch (rndisMessage.NdisMessageType)
2897+ {
2898+ // data msg
2899+ case REMOTE_NDIS_PACKET_MSG:
2900+ RndisFilterReceiveData(rndisDevice, &rndisMessage, Packet);
2901+ break;
2902+
2903+ // completion msgs
2904+ case REMOTE_NDIS_INITIALIZE_CMPLT:
2905+ case REMOTE_NDIS_QUERY_CMPLT:
2906+ case REMOTE_NDIS_SET_CMPLT:
2907+ //case REMOTE_NDIS_RESET_CMPLT:
2908+ //case REMOTE_NDIS_KEEPALIVE_CMPLT:
2909+ RndisFilterReceiveResponse(rndisDevice, &rndisMessage);
2910+ break;
2911+
2912+ // notification msgs
2913+ case REMOTE_NDIS_INDICATE_STATUS_MSG:
2914+ RndisFilterReceiveIndicateStatus(rndisDevice, &rndisMessage);
2915+ break;
2916+ default:
2917+ DPRINT_ERR(NETVSC, "unhandled rndis message (type %u len %u)", rndisMessage.NdisMessageType, rndisMessage.MessageLength);
2918+ break;
2919+ }
2920+
2921+ DPRINT_EXIT(NETVSC);
2922+ return 0;
2923+}
2924+
2925+
2926+static int
2927+RndisFilterQueryDevice(
2928+ RNDIS_DEVICE *Device,
2929+ UINT32 Oid,
2930+ VOID *Result,
2931+ UINT32 *ResultSize
2932+ )
2933+{
2934+ RNDIS_REQUEST *request;
2935+ UINT32 inresultSize = *ResultSize;
2936+ RNDIS_QUERY_REQUEST *query;
2937+ RNDIS_QUERY_COMPLETE *queryComplete;
2938+ int ret=0;
2939+
2940+ DPRINT_ENTER(NETVSC);
2941+
2942+ ASSERT(Result);
2943+
2944+ *ResultSize = 0;
2945+ request = GetRndisRequest(Device, REMOTE_NDIS_QUERY_MSG, RNDIS_MESSAGE_SIZE(RNDIS_QUERY_REQUEST));
2946+ if (!request)
2947+ {
2948+ ret = -1;
2949+ goto Cleanup;
2950+ }
2951+
2952+ // Setup the rndis query
2953+ query = &request->RequestMessage.Message.QueryRequest;
2954+ query->Oid = Oid;
2955+ query->InformationBufferOffset = sizeof(RNDIS_QUERY_REQUEST);
2956+ query->InformationBufferLength = 0;
2957+ query->DeviceVcHandle = 0;
2958+
2959+ ret = RndisFilterSendRequest(Device, request);
2960+ if (ret != 0)
2961+ {
2962+ goto Cleanup;
2963+ }
2964+
2965+ WaitEventWait(request->WaitEvent);
2966+
2967+ // Copy the response back
2968+ queryComplete = &request->ResponseMessage.Message.QueryComplete;
2969+
2970+ if (queryComplete->InformationBufferLength > inresultSize)
2971+ {
2972+ ret = -1;
2973+ goto Cleanup;
2974+ }
2975+
2976+ memcpy(Result,
2977+ (void*)((ULONG_PTR)queryComplete + queryComplete->InformationBufferOffset),
2978+ queryComplete->InformationBufferLength);
2979+
2980+ *ResultSize = queryComplete->InformationBufferLength;
2981+
2982+Cleanup:
2983+ if (request)
2984+ {
2985+ PutRndisRequest(Device, request);
2986+ }
2987+ DPRINT_EXIT(NETVSC);
2988+
2989+ return ret;
2990+}
2991+
2992+static inline int
2993+RndisFilterQueryDeviceMac(
2994+ RNDIS_DEVICE *Device
2995+ )
2996+{
2997+ UINT32 size=HW_MACADDR_LEN;
2998+
2999+ return RndisFilterQueryDevice(Device,
3000+ RNDIS_OID_802_3_PERMANENT_ADDRESS,
3001+ Device->HwMacAddr,
3002+ &size);
3003+}
3004+
3005+static inline int
3006+RndisFilterQueryDeviceLinkStatus(
3007+ RNDIS_DEVICE *Device
3008+ )
3009+{
3010+ UINT32 size=sizeof(UINT32);
3011+
3012+ return RndisFilterQueryDevice(Device,
3013+ RNDIS_OID_GEN_MEDIA_CONNECT_STATUS,
3014+ &Device->LinkStatus,
3015+ &size);
3016+}
3017+
3018+static int
3019+RndisFilterSetPacketFilter(
3020+ RNDIS_DEVICE *Device,
3021+ UINT32 NewFilter
3022+ )
3023+{
3024+ RNDIS_REQUEST *request;
3025+ RNDIS_SET_REQUEST *set;
3026+ RNDIS_SET_COMPLETE *setComplete;
3027+ UINT32 status;
3028+ int ret;
3029+
3030+ DPRINT_ENTER(NETVSC);
3031+
3032+ ASSERT(RNDIS_MESSAGE_SIZE(RNDIS_SET_REQUEST) + sizeof(UINT32) <= sizeof(RNDIS_MESSAGE));
3033+
3034+ request = GetRndisRequest(Device, REMOTE_NDIS_SET_MSG, RNDIS_MESSAGE_SIZE(RNDIS_SET_REQUEST) + sizeof(UINT32));
3035+ if (!request)
3036+ {
3037+ ret = -1;
3038+ goto Cleanup;
3039+ }
3040+
3041+ // Setup the rndis set
3042+ set = &request->RequestMessage.Message.SetRequest;
3043+ set->Oid = RNDIS_OID_GEN_CURRENT_PACKET_FILTER;
3044+ set->InformationBufferLength = sizeof(UINT32);
3045+ set->InformationBufferOffset = sizeof(RNDIS_SET_REQUEST);
3046+
3047+ memcpy((void*)(ULONG_PTR)set + sizeof(RNDIS_SET_REQUEST), &NewFilter, sizeof(UINT32));
3048+
3049+ ret = RndisFilterSendRequest(Device, request);
3050+ if (ret != 0)
3051+ {
3052+ goto Cleanup;
3053+ }
3054+
3055+ ret = WaitEventWaitEx(request->WaitEvent, 2000/*2sec*/);
3056+ if (!ret)
3057+ {
3058+ ret = -1;
3059+ DPRINT_ERR(NETVSC, "timeout before we got a set response...");
3060+ // We cant deallocate the request since we may still receive a send completion for it.
3061+ goto Exit;
3062+ }
3063+ else
3064+ {
3065+ if (ret > 0)
3066+ {
3067+ ret = 0;
3068+ }
3069+ setComplete = &request->ResponseMessage.Message.SetComplete;
3070+ status = setComplete->Status;
3071+ }
3072+
3073+Cleanup:
3074+ if (request)
3075+ {
3076+ PutRndisRequest(Device, request);
3077+ }
3078+Exit:
3079+ DPRINT_EXIT(NETVSC);
3080+
3081+ return ret;
3082+}
3083+
3084+int
3085+RndisFilterInit(
3086+ NETVSC_DRIVER_OBJECT *Driver
3087+ )
3088+{
3089+ DPRINT_ENTER(NETVSC);
3090+
3091+ DPRINT_DBG(NETVSC, "sizeof(RNDIS_FILTER_PACKET) == %d", sizeof(RNDIS_FILTER_PACKET));
3092+
3093+ Driver->RequestExtSize = sizeof(RNDIS_FILTER_PACKET);
3094+ Driver->AdditionalRequestPageBufferCount = 1; // For rndis header
3095+
3096+ //Driver->Context = rndisDriver;
3097+
3098+ memset(&gRndisFilter, 0, sizeof(RNDIS_FILTER_DRIVER_OBJECT));
3099+
3100+ /*rndisDriver->Driver = Driver;
3101+
3102+ ASSERT(Driver->OnLinkStatusChanged);
3103+ rndisDriver->OnLinkStatusChanged = Driver->OnLinkStatusChanged;*/
3104+
3105+ // Save the original dispatch handlers before we override it
3106+ gRndisFilter.InnerDriver.Base.OnDeviceAdd = Driver->Base.OnDeviceAdd;
3107+ gRndisFilter.InnerDriver.Base.OnDeviceRemove = Driver->Base.OnDeviceRemove;
3108+ gRndisFilter.InnerDriver.Base.OnCleanup = Driver->Base.OnCleanup;
3109+
3110+ ASSERT(Driver->OnSend);
3111+ ASSERT(Driver->OnReceiveCallback);
3112+ gRndisFilter.InnerDriver.OnSend = Driver->OnSend;
3113+ gRndisFilter.InnerDriver.OnReceiveCallback = Driver->OnReceiveCallback;
3114+ gRndisFilter.InnerDriver.OnLinkStatusChanged = Driver->OnLinkStatusChanged;
3115+
3116+ // Override
3117+ Driver->Base.OnDeviceAdd = RndisFilterOnDeviceAdd;
3118+ Driver->Base.OnDeviceRemove = RndisFilterOnDeviceRemove;
3119+ Driver->Base.OnCleanup = RndisFilterOnCleanup;
3120+ Driver->OnSend = RndisFilterOnSend;
3121+ Driver->OnOpen = RndisFilterOnOpen;
3122+ Driver->OnClose = RndisFilterOnClose;
3123+ //Driver->QueryLinkStatus = RndisFilterQueryDeviceLinkStatus;
3124+ Driver->OnReceiveCallback = RndisFilterOnReceive;
3125+
3126+ DPRINT_EXIT(NETVSC);
3127+
3128+ return 0;
3129+}
3130+
3131+static int
3132+RndisFilterInitDevice(
3133+ RNDIS_DEVICE *Device
3134+ )
3135+{
3136+ RNDIS_REQUEST *request;
3137+ RNDIS_INITIALIZE_REQUEST *init;
3138+ RNDIS_INITIALIZE_COMPLETE *initComplete;
3139+ UINT32 status;
3140+ int ret;
3141+
3142+ DPRINT_ENTER(NETVSC);
3143+
3144+ request = GetRndisRequest(Device, REMOTE_NDIS_INITIALIZE_MSG, RNDIS_MESSAGE_SIZE(RNDIS_INITIALIZE_REQUEST));
3145+ if (!request)
3146+ {
3147+ ret = -1;
3148+ goto Cleanup;
3149+ }
3150+
3151+ // Setup the rndis set
3152+ init = &request->RequestMessage.Message.InitializeRequest;
3153+ init->MajorVersion = RNDIS_MAJOR_VERSION;
3154+ init->MinorVersion = RNDIS_MINOR_VERSION;
3155+ init->MaxTransferSize = 2048; // FIXME: Use 1536 - rounded ethernet frame size
3156+
3157+ Device->State = RNDIS_DEV_INITIALIZING;
3158+
3159+ ret = RndisFilterSendRequest(Device, request);
3160+ if (ret != 0)
3161+ {
3162+ Device->State = RNDIS_DEV_UNINITIALIZED;
3163+ goto Cleanup;
3164+ }
3165+
3166+ WaitEventWait(request->WaitEvent);
3167+
3168+ initComplete = &request->ResponseMessage.Message.InitializeComplete;
3169+ status = initComplete->Status;
3170+ if (status == RNDIS_STATUS_SUCCESS)
3171+ {
3172+ Device->State = RNDIS_DEV_INITIALIZED;
3173+ ret = 0;
3174+ }
3175+ else
3176+ {
3177+ Device->State = RNDIS_DEV_UNINITIALIZED;
3178+ ret = -1;
3179+ }
3180+
3181+Cleanup:
3182+ if (request)
3183+ {
3184+ PutRndisRequest(Device, request);
3185+ }
3186+ DPRINT_EXIT(NETVSC);
3187+
3188+ return ret;
3189+}
3190+
3191+static void
3192+RndisFilterHaltDevice(
3193+ RNDIS_DEVICE *Device
3194+ )
3195+{
3196+ RNDIS_REQUEST *request;
3197+ RNDIS_HALT_REQUEST *halt;
3198+
3199+ DPRINT_ENTER(NETVSC);
3200+
3201+ // Attempt to do a rndis device halt
3202+ request = GetRndisRequest(Device, REMOTE_NDIS_HALT_MSG, RNDIS_MESSAGE_SIZE(RNDIS_HALT_REQUEST));
3203+ if (!request)
3204+ {
3205+ goto Cleanup;
3206+ }
3207+
3208+ // Setup the rndis set
3209+ halt = &request->RequestMessage.Message.HaltRequest;
3210+ halt->RequestId = InterlockedIncrement((int*)&Device->NewRequestId);
3211+
3212+ // Ignore return since this msg is optional.
3213+ RndisFilterSendRequest(Device, request);
3214+
3215+ Device->State = RNDIS_DEV_UNINITIALIZED;
3216+
3217+Cleanup:
3218+ if (request)
3219+ {
3220+ PutRndisRequest(Device, request);
3221+ }
3222+ DPRINT_EXIT(NETVSC);
3223+ return;
3224+}
3225+
3226+
3227+static int
3228+RndisFilterOpenDevice(
3229+ RNDIS_DEVICE *Device
3230+ )
3231+{
3232+ int ret=0;
3233+
3234+ DPRINT_ENTER(NETVSC);
3235+
3236+ if (Device->State != RNDIS_DEV_INITIALIZED)
3237+ return 0;
3238+
3239+ ret = RndisFilterSetPacketFilter(Device, NDIS_PACKET_TYPE_BROADCAST|NDIS_PACKET_TYPE_DIRECTED);
3240+ if (ret == 0)
3241+ {
3242+ Device->State = RNDIS_DEV_DATAINITIALIZED;
3243+ }
3244+
3245+ DPRINT_EXIT(NETVSC);
3246+ return ret;
3247+}
3248+
3249+static int
3250+RndisFilterCloseDevice(
3251+ RNDIS_DEVICE *Device
3252+ )
3253+{
3254+ int ret;
3255+
3256+ DPRINT_ENTER(NETVSC);
3257+
3258+ if (Device->State != RNDIS_DEV_DATAINITIALIZED)
3259+ return 0;
3260+
3261+ ret = RndisFilterSetPacketFilter(Device, 0);
3262+ if (ret == 0)
3263+ {
3264+ Device->State = RNDIS_DEV_INITIALIZED;
3265+ }
3266+
3267+ DPRINT_EXIT(NETVSC);
3268+
3269+ return ret;
3270+}
3271+
3272+
3273+int
3274+RndisFilterOnDeviceAdd(
3275+ DEVICE_OBJECT *Device,
3276+ void *AdditionalInfo
3277+ )
3278+{
3279+ int ret;
3280+ NETVSC_DEVICE *netDevice;
3281+ RNDIS_DEVICE *rndisDevice;
3282+ NETVSC_DEVICE_INFO *deviceInfo = (NETVSC_DEVICE_INFO*)AdditionalInfo;
3283+
3284+ DPRINT_ENTER(NETVSC);
3285+
3286+ //rndisDevice = MemAlloc(sizeof(RNDIS_DEVICE));
3287+ rndisDevice = GetRndisDevice();
3288+ if (!rndisDevice)
3289+ {
3290+ DPRINT_EXIT(NETVSC);
3291+ return -1;
3292+ }
3293+
3294+ DPRINT_DBG(NETVSC, "rndis device object allocated - %p", rndisDevice);
3295+
3296+ // Let the inner driver handle this first to create the netvsc channel
3297+ // NOTE! Once the channel is created, we may get a receive callback
3298+ // (RndisFilterOnReceive()) before this call is completed
3299+ ret = gRndisFilter.InnerDriver.Base.OnDeviceAdd(Device, AdditionalInfo);
3300+ if (ret != 0)
3301+ {
3302+ PutRndisDevice(rndisDevice);
3303+ DPRINT_EXIT(NETVSC);
3304+ return ret;
3305+ }
3306+
3307+ //
3308+ // Initialize the rndis device
3309+ //
3310+ netDevice = (NETVSC_DEVICE*)Device->Extension;
3311+ ASSERT(netDevice);
3312+ ASSERT(netDevice->Device);
3313+
3314+ netDevice->Extension = rndisDevice;
3315+ rndisDevice->NetDevice = netDevice;
3316+
3317+ // Send the rndis initialization message
3318+ ret = RndisFilterInitDevice(rndisDevice);
3319+ if (ret != 0)
3320+ {
3321+ // TODO: If rndis init failed, we will need to shut down the channel
3322+ }
3323+
3324+ // Get the mac address
3325+ ret = RndisFilterQueryDeviceMac(rndisDevice);
3326+ if (ret != 0)
3327+ {
3328+ // TODO: shutdown rndis device and the channel
3329+ }
3330+
3331+ DPRINT_INFO(NETVSC, "Device 0x%p mac addr %02x%02x%02x%02x%02x%02x",
3332+ rndisDevice,
3333+ rndisDevice->HwMacAddr[0],
3334+ rndisDevice->HwMacAddr[1],
3335+ rndisDevice->HwMacAddr[2],
3336+ rndisDevice->HwMacAddr[3],
3337+ rndisDevice->HwMacAddr[4],
3338+ rndisDevice->HwMacAddr[5]);
3339+
3340+ memcpy(deviceInfo->MacAddr, rndisDevice->HwMacAddr, HW_MACADDR_LEN);
3341+
3342+ RndisFilterQueryDeviceLinkStatus(rndisDevice);
3343+
3344+ deviceInfo->LinkState = rndisDevice->LinkStatus;
3345+ DPRINT_INFO(NETVSC, "Device 0x%p link state %s", rndisDevice, ((deviceInfo->LinkState)?("down"):("up")));
3346+
3347+ DPRINT_EXIT(NETVSC);
3348+
3349+ return ret;
3350+}
3351+
3352+
3353+static int
3354+RndisFilterOnDeviceRemove(
3355+ DEVICE_OBJECT *Device
3356+ )
3357+{
3358+ NETVSC_DEVICE *netDevice = (NETVSC_DEVICE*)Device->Extension;
3359+ RNDIS_DEVICE *rndisDevice = (RNDIS_DEVICE*)netDevice->Extension;
3360+
3361+ DPRINT_ENTER(NETVSC);
3362+
3363+ // Halt and release the rndis device
3364+ RndisFilterHaltDevice(rndisDevice);
3365+
3366+ PutRndisDevice(rndisDevice);
3367+ netDevice->Extension = NULL;
3368+
3369+ // Pass control to inner driver to remove the device
3370+ gRndisFilter.InnerDriver.Base.OnDeviceRemove(Device);
3371+
3372+ DPRINT_EXIT(NETVSC);
3373+
3374+ return 0;
3375+}
3376+
3377+
3378+static void
3379+RndisFilterOnCleanup(
3380+ DRIVER_OBJECT *Driver
3381+ )
3382+{
3383+ DPRINT_ENTER(NETVSC);
3384+
3385+ DPRINT_EXIT(NETVSC);
3386+}
3387+
3388+static int
3389+RndisFilterOnOpen(
3390+ DEVICE_OBJECT *Device
3391+ )
3392+{
3393+ int ret;
3394+ NETVSC_DEVICE *netDevice = (NETVSC_DEVICE*)Device->Extension;
3395+
3396+ DPRINT_ENTER(NETVSC);
3397+
3398+ ASSERT(netDevice);
3399+ ret = RndisFilterOpenDevice((RNDIS_DEVICE*)netDevice->Extension);
3400+
3401+ DPRINT_EXIT(NETVSC);
3402+
3403+ return ret;
3404+}
3405+
3406+static int
3407+RndisFilterOnClose(
3408+ DEVICE_OBJECT *Device
3409+ )
3410+{
3411+ int ret;
3412+ NETVSC_DEVICE *netDevice = (NETVSC_DEVICE*)Device->Extension;
3413+
3414+ DPRINT_ENTER(NETVSC);
3415+
3416+ ASSERT(netDevice);
3417+ ret = RndisFilterCloseDevice((RNDIS_DEVICE*)netDevice->Extension);
3418+
3419+ DPRINT_EXIT(NETVSC);
3420+
3421+ return ret;
3422+}
3423+
3424+
3425+static int
3426+RndisFilterOnSend(
3427+ DEVICE_OBJECT *Device,
3428+ NETVSC_PACKET *Packet
3429+ )
3430+{
3431+ int ret=0;
3432+ RNDIS_FILTER_PACKET *filterPacket;
3433+ RNDIS_MESSAGE *rndisMessage;
3434+ RNDIS_PACKET *rndisPacket;
3435+ UINT32 rndisMessageSize;
3436+
3437+ DPRINT_ENTER(NETVSC);
3438+
3439+ // Add the rndis header
3440+ filterPacket = (RNDIS_FILTER_PACKET*)Packet->Extension;
3441+ ASSERT(filterPacket);
3442+
3443+ memset(filterPacket, 0, sizeof(RNDIS_FILTER_PACKET));
3444+
3445+ rndisMessage = &filterPacket->Message;
3446+ rndisMessageSize = RNDIS_MESSAGE_SIZE(RNDIS_PACKET);
3447+
3448+ rndisMessage->NdisMessageType = REMOTE_NDIS_PACKET_MSG;
3449+ rndisMessage->MessageLength = Packet->TotalDataBufferLength + rndisMessageSize;
3450+
3451+ rndisPacket = &rndisMessage->Message.Packet;
3452+ rndisPacket->DataOffset = sizeof(RNDIS_PACKET);
3453+ rndisPacket->DataLength = Packet->TotalDataBufferLength;
3454+
3455+ Packet->IsDataPacket = TRUE;
3456+ Packet->PageBuffers[0].Pfn = GetPhysicalAddress(rndisMessage) >> PAGE_SHIFT;
3457+ Packet->PageBuffers[0].Offset = (ULONG_PTR)rndisMessage & (PAGE_SIZE-1);
3458+ Packet->PageBuffers[0].Length = rndisMessageSize;
3459+
3460+ // Save the packet send completion and context
3461+ filterPacket->OnCompletion = Packet->Completion.Send.OnSendCompletion;
3462+ filterPacket->CompletionContext = Packet->Completion.Send.SendCompletionContext;
3463+
3464+ // Use ours
3465+ Packet->Completion.Send.OnSendCompletion = RndisFilterOnSendCompletion;
3466+ Packet->Completion.Send.SendCompletionContext = filterPacket;
3467+
3468+ ret = gRndisFilter.InnerDriver.OnSend(Device, Packet);
3469+ if (ret != 0)
3470+ {
3471+ // Reset the completion to originals to allow retries from above
3472+ Packet->Completion.Send.OnSendCompletion = filterPacket->OnCompletion;
3473+ Packet->Completion.Send.SendCompletionContext = filterPacket->CompletionContext;
3474+ }
3475+
3476+ DPRINT_EXIT(NETVSC);
3477+
3478+ return ret;
3479+}
3480+
3481+static void
3482+RndisFilterOnSendCompletion(
3483+ void *Context)
3484+{
3485+ RNDIS_FILTER_PACKET *filterPacket = (RNDIS_FILTER_PACKET *)Context;
3486+
3487+ DPRINT_ENTER(NETVSC);
3488+
3489+ // Pass it back to the original handler
3490+ filterPacket->OnCompletion(filterPacket->CompletionContext);
3491+
3492+ DPRINT_EXIT(NETVSC);
3493+}
3494+
3495+
3496+static void
3497+RndisFilterOnSendRequestCompletion(
3498+ void *Context
3499+ )
3500+{
3501+ DPRINT_ENTER(NETVSC);
3502+
3503+ // Noop
3504+ DPRINT_EXIT(NETVSC);
3505+}
3506--- /dev/null
3507+++ b/drivers/staging/hv/RndisFilter.h
3508@@ -0,0 +1,61 @@
3509+/*
3510+ *
3511+ * Copyright (c) 2009, Microsoft Corporation.
3512+ *
3513+ * This program is free software; you can redistribute it and/or modify it
3514+ * under the terms and conditions of the GNU General Public License,
3515+ * version 2, as published by the Free Software Foundation.
3516+ *
3517+ * This program is distributed in the hope it will be useful, but WITHOUT
3518+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3519+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
3520+ * more details.
3521+ *
3522+ * You should have received a copy of the GNU General Public License along with
3523+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
3524+ * Place - Suite 330, Boston, MA 02111-1307 USA.
3525+ *
3526+ * Authors:
3527+ * Haiyang Zhang <haiyangz@microsoft.com>
3528+ * Hank Janssen <hjanssen@microsoft.com>
3529+ *
3530+ */
3531+
3532+
3533+#ifndef _RNDISFILTER_H_
3534+#define _RNDISFILTER_H_
3535+
3536+#define __struct_bcount(x)
3537+
3538+#include "osd.h"
3539+#include "NetVsc.h"
3540+
3541+#include "rndis.h"
3542+
3543+#define RNDIS_HEADER_SIZE (sizeof(RNDIS_MESSAGE) - sizeof(RNDIS_MESSAGE_CONTAINER))
3544+
3545+#define NDIS_PACKET_TYPE_DIRECTED 0x00000001
3546+#define NDIS_PACKET_TYPE_MULTICAST 0x00000002
3547+#define NDIS_PACKET_TYPE_ALL_MULTICAST 0x00000004
3548+#define NDIS_PACKET_TYPE_BROADCAST 0x00000008
3549+#define NDIS_PACKET_TYPE_SOURCE_ROUTING 0x00000010
3550+#define NDIS_PACKET_TYPE_PROMISCUOUS 0x00000020
3551+#define NDIS_PACKET_TYPE_SMT 0x00000040
3552+#define NDIS_PACKET_TYPE_ALL_LOCAL 0x00000080
3553+#define NDIS_PACKET_TYPE_GROUP 0x00000100
3554+#define NDIS_PACKET_TYPE_ALL_FUNCTIONAL 0x00000200
3555+#define NDIS_PACKET_TYPE_FUNCTIONAL 0x00000400
3556+#define NDIS_PACKET_TYPE_MAC_FRAME 0x00000800
3557+
3558+
3559+
3560+//
3561+// Interface
3562+//
3563+int
3564+RndisFilterInit(
3565+ NETVSC_DRIVER_OBJECT *Driver
3566+ );
3567+
3568+
3569+#endif // _RNDISFILTER_H_
Peter's tree of IPFire 2.x