projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Staging: hv: remove VOID typedef
[linux-2.6-block.git] / drivers / staging / hv / NetVsc.c
CommitLineData
fceaf24a
HJ		 1/*
2 *
3 * Copyright (c) 2009, Microsoft Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
16 * Place - Suite 330, Boston, MA 02111-1307 USA.
17 *
18 * Authors:
19 * Hank Janssen <hjanssen@microsoft.com>
20 *
21 */
22
c86f3e2a 23#define KERNEL_2_6_27
fceaf24a 24
c86f3e2a 25#include "include/logging.h"
fceaf24a
HJ		 26#include "NetVsc.h"
27#include "RndisFilter.h"
28
29
30//
31// Globals
32//
33static const char* gDriverName="netvsc";
34
35// {F8615163-DF3E-46c5-913F-F2D2F965ED0E}
36static const GUID gNetVscDeviceType={
37 .Data = {0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46, 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E}
38};
39
40
41//
42// Internal routines
43//
44static int
45NetVscOnDeviceAdd(
46 DEVICE_OBJECT *Device,
47 void *AdditionalInfo
48 );
49
50static int
51NetVscOnDeviceRemove(
52 DEVICE_OBJECT *Device
53 );
54
55static void
56NetVscOnCleanup(
57 DRIVER_OBJECT *Driver
58 );
59
60static void
61NetVscOnChannelCallback(
8282c400 62 void * context
fceaf24a
HJ		 63 );
64
65static int
66NetVscInitializeSendBufferWithNetVsp(
67 DEVICE_OBJECT *Device
68 );
69
70static int
71NetVscInitializeReceiveBufferWithNetVsp(
72 DEVICE_OBJECT *Device
73 );
74
75static int
76NetVscDestroySendBuffer(
77 NETVSC_DEVICE *NetDevice
78 );
79
80static int
81NetVscDestroyReceiveBuffer(
82 NETVSC_DEVICE *NetDevice
83 );
84
85static int
86NetVscConnectToVsp(
87 DEVICE_OBJECT *Device
88 );
89
90static void
91NetVscOnSendCompletion(
92 DEVICE_OBJECT *Device,
93 VMPACKET_DESCRIPTOR *Packet
94 );
95
96static int
97NetVscOnSend(
98 DEVICE_OBJECT *Device,
99 NETVSC_PACKET *Packet
100 );
101
102static void
103NetVscOnReceive(
104 DEVICE_OBJECT *Device,
105 VMPACKET_DESCRIPTOR *Packet
106 );
107
108static void
109NetVscOnReceiveCompletion(
8282c400 110 void * Context
fceaf24a
HJ		 111 );
112
113static void
114NetVscSendReceiveCompletion(
115 DEVICE_OBJECT *Device,
116 UINT64 TransactionId
117 );
118
119static inline NETVSC_DEVICE* AllocNetDevice(DEVICE_OBJECT *Device)
120{
121 NETVSC_DEVICE *netDevice;
122
123 netDevice = MemAllocZeroed(sizeof(NETVSC_DEVICE));
124 if (!netDevice)
125 return NULL;
126
127 // Set to 2 to allow both inbound and outbound traffic
128 InterlockedCompareExchange(&netDevice->RefCount, 2, 0);
129
130 netDevice->Device = Device;
131 Device->Extension = netDevice;
132
133 return netDevice;
134}
135
136static inline void FreeNetDevice(NETVSC_DEVICE *Device)
137{
138 ASSERT(Device->RefCount == 0);
139 Device->Device->Extension = NULL;
140 MemFree(Device);
141}
142
143
144// Get the net device object iff exists and its refcount > 1
145static inline NETVSC_DEVICE* GetOutboundNetDevice(DEVICE_OBJECT *Device)
146{
147 NETVSC_DEVICE *netDevice;
148
149 netDevice = (NETVSC_DEVICE*)Device->Extension;
150 if (netDevice && netDevice->RefCount > 1)
151 {
152 InterlockedIncrement(&netDevice->RefCount);
153 }
154 else
155 {
156 netDevice = NULL;
157 }
158
159 return netDevice;
160}
161
162// Get the net device object iff exists and its refcount > 0
163static inline NETVSC_DEVICE* GetInboundNetDevice(DEVICE_OBJECT *Device)
164{
165 NETVSC_DEVICE *netDevice;
166
167 netDevice = (NETVSC_DEVICE*)Device->Extension;
168 if (netDevice && netDevice->RefCount)
169 {
170 InterlockedIncrement(&netDevice->RefCount);
171 }
172 else
173 {
174 netDevice = NULL;
175 }
176
177 return netDevice;
178}
179
180static inline void PutNetDevice(DEVICE_OBJECT *Device)
181{
182 NETVSC_DEVICE *netDevice;
183
184 netDevice = (NETVSC_DEVICE*)Device->Extension;
185 ASSERT(netDevice);
186
187 InterlockedDecrement(&netDevice->RefCount);
188}
189
190static inline NETVSC_DEVICE* ReleaseOutboundNetDevice(DEVICE_OBJECT *Device)
191{
192 NETVSC_DEVICE *netDevice;
193
194 netDevice = (NETVSC_DEVICE*)Device->Extension;
195 if (netDevice == NULL)
196 return NULL;
197
198 // Busy wait until the ref drop to 2, then set it to 1
199 while (InterlockedCompareExchange(&netDevice->RefCount, 1, 2) != 2)
200 {
201 Sleep(100);
202 }
203
204 return netDevice;
205}
206
207static inline NETVSC_DEVICE* ReleaseInboundNetDevice(DEVICE_OBJECT *Device)
208{
209 NETVSC_DEVICE *netDevice;
210
211 netDevice = (NETVSC_DEVICE*)Device->Extension;
212 if (netDevice == NULL)
213 return NULL;
214
215 // Busy wait until the ref drop to 1, then set it to 0
216 while (InterlockedCompareExchange(&netDevice->RefCount, 0, 1) != 1)
217 {
218 Sleep(100);
219 }
220
221 Device->Extension = NULL;
222 return netDevice;
223}
224
225/*++;
226
227
228Name:
229 NetVscInitialize()
230
231Description:
232 Main entry point
233
234--*/
235int
236NetVscInitialize(
237 DRIVER_OBJECT *drv
238 )
239{
240 NETVSC_DRIVER_OBJECT* driver = (NETVSC_DRIVER_OBJECT*)drv;
241 int ret=0;
242
243 DPRINT_ENTER(NETVSC);
244
245 DPRINT_DBG(NETVSC, "sizeof(NETVSC_PACKET)=%d, sizeof(NVSP_MESSAGE)=%d, sizeof(VMTRANSFER_PAGE_PACKET_HEADER)=%d",
246 sizeof(NETVSC_PACKET), sizeof(NVSP_MESSAGE), sizeof(VMTRANSFER_PAGE_PACKET_HEADER));
247
248 // Make sure we are at least 2 pages since 1 page is used for control
249 ASSERT(driver->RingBufferSize >= (PAGE_SIZE << 1));
250
251 drv->name = gDriverName;
252 memcpy(&drv->deviceType, &gNetVscDeviceType, sizeof(GUID));
253
254 // Make sure it is set by the caller
255 ASSERT(driver->OnReceiveCallback);
256 ASSERT(driver->OnLinkStatusChanged);
257
258 // Setup the dispatch table
259 driver->Base.OnDeviceAdd = NetVscOnDeviceAdd;
260 driver->Base.OnDeviceRemove = NetVscOnDeviceRemove;
261 driver->Base.OnCleanup = NetVscOnCleanup;
262
263 driver->OnSend = NetVscOnSend;
264
265 RndisFilterInit(driver);
266
267 DPRINT_EXIT(NETVSC);
268
269 return ret;
270}
271
272static int
273NetVscInitializeReceiveBufferWithNetVsp(
274 DEVICE_OBJECT *Device
275 )
276{
277 int ret=0;
278 NETVSC_DEVICE *netDevice;
279 NVSP_MESSAGE *initPacket;
280
281 DPRINT_ENTER(NETVSC);
282
283 netDevice = GetOutboundNetDevice(Device);
284 if (!netDevice)
285 {
286 DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
287 DPRINT_EXIT(NETVSC);
288 return -1;
289 }
290 ASSERT(netDevice->ReceiveBufferSize > 0);
291 ASSERT((netDevice->ReceiveBufferSize & (PAGE_SIZE-1)) == 0); // page-size grandularity
292
293 netDevice->ReceiveBuffer = PageAlloc(netDevice->ReceiveBufferSize >> PAGE_SHIFT);
294 if (!netDevice->ReceiveBuffer)
295 {
296 DPRINT_ERR(NETVSC, "unable to allocate receive buffer of size %d", netDevice->ReceiveBufferSize);
297 ret = -1;
298 goto Cleanup;
299 }
300 ASSERT(((ULONG_PTR)netDevice->ReceiveBuffer & (PAGE_SIZE-1)) == 0); // page-aligned buffer
301
302 DPRINT_INFO(NETVSC, "Establishing receive buffer's GPADL...");
303
304 // Establish the gpadl handle for this buffer on this channel.
305 // Note: This call uses the vmbus connection rather than the channel to establish
306 // the gpadl handle.
307 ret = Device->Driver->VmbusChannelInterface.EstablishGpadl(Device,
308 netDevice->ReceiveBuffer,
309 netDevice->ReceiveBufferSize,
310 &netDevice->ReceiveBufferGpadlHandle);
311
312 if (ret != 0)
313 {
314 DPRINT_ERR(NETVSC, "unable to establish receive buffer's gpadl");
315 goto Cleanup;
316 }
317
318 //WaitEventWait(ext->ChannelInitEvent);
319
320 // Notify the NetVsp of the gpadl handle
321 DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendReceiveBuffer...");
322
323 initPacket = &netDevice->ChannelInitPacket;
324
325 memset(initPacket, 0, sizeof(NVSP_MESSAGE));
326
327 initPacket->Header.MessageType = NvspMessage1TypeSendReceiveBuffer;
328 initPacket->Messages.Version1Messages.SendReceiveBuffer.GpadlHandle = netDevice->ReceiveBufferGpadlHandle;
329 initPacket->Messages.Version1Messages.SendReceiveBuffer.Id = NETVSC_RECEIVE_BUFFER_ID;
330
331 // Send the gpadl notification request
332 ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
333 initPacket,
334 sizeof(NVSP_MESSAGE),
335 (ULONG_PTR)initPacket,
336 VmbusPacketTypeDataInBand,
337 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
338 if (ret != 0)
339 {
340 DPRINT_ERR(NETVSC, "unable to send receive buffer's gpadl to netvsp");
341 goto Cleanup;
342 }
343
344 WaitEventWait(netDevice->ChannelInitEvent);
345
346 // Check the response
347 if (initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Status != NvspStatusSuccess)
348 {
349 DPRINT_ERR(NETVSC,
350 "Unable to complete receive buffer initialzation with NetVsp - status %d",
351 initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Status);
352 ret = -1;
353 goto Cleanup;
354 }
355
356 // Parse the response
357 ASSERT(netDevice->ReceiveSectionCount == 0);
358 ASSERT(netDevice->ReceiveSections == NULL);
359
360 netDevice->ReceiveSectionCount = initPacket->Messages.Version1Messages.SendReceiveBufferComplete.NumSections;
361
362 netDevice->ReceiveSections = MemAlloc(netDevice->ReceiveSectionCount * sizeof(NVSP_1_RECEIVE_BUFFER_SECTION));
363 if (netDevice->ReceiveSections == NULL)
364 {
365 ret = -1;
366 goto Cleanup;
367 }
368
369 memcpy(netDevice->ReceiveSections,
370 initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Sections,
371 netDevice->ReceiveSectionCount * sizeof(NVSP_1_RECEIVE_BUFFER_SECTION));
372
373 DPRINT_INFO(NETVSC,
374 "Receive sections info (count %d, offset %d, endoffset %d, suballoc size %d, num suballocs %d)",
375 netDevice->ReceiveSectionCount, netDevice->ReceiveSections[0].Offset, netDevice->ReceiveSections[0].EndOffset,
376 netDevice->ReceiveSections[0].SubAllocationSize, netDevice->ReceiveSections[0].NumSubAllocations);
377
378
379 //For 1st release, there should only be 1 section that represents the entire receive buffer
380 if (netDevice->ReceiveSectionCount != 1 ||
381 netDevice->ReceiveSections->Offset != 0 )
382 {
383 ret = -1;
384 goto Cleanup;
385 }
386
387 goto Exit;
388
389Cleanup:
390 NetVscDestroyReceiveBuffer(netDevice);
391
392Exit:
393 PutNetDevice(Device);
394 DPRINT_EXIT(NETVSC);
395 return ret;
396}
397
398
399static int
400NetVscInitializeSendBufferWithNetVsp(
401 DEVICE_OBJECT *Device
402 )
403{
404 int ret=0;
405 NETVSC_DEVICE *netDevice;
406 NVSP_MESSAGE *initPacket;
407
408 DPRINT_ENTER(NETVSC);
409
410 netDevice = GetOutboundNetDevice(Device);
411 if (!netDevice)
412 {
413 DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
414 DPRINT_EXIT(NETVSC);
415 return -1;
416 }
417 ASSERT(netDevice->SendBufferSize > 0);
418 ASSERT((netDevice->SendBufferSize & (PAGE_SIZE-1)) == 0); // page-size grandularity
419
420 netDevice->SendBuffer = PageAlloc(netDevice->SendBufferSize >> PAGE_SHIFT);
421 if (!netDevice->SendBuffer)
422 {
423 DPRINT_ERR(NETVSC, "unable to allocate send buffer of size %d", netDevice->SendBufferSize);
424 ret = -1;
425 goto Cleanup;
426 }
427 ASSERT(((ULONG_PTR)netDevice->SendBuffer & (PAGE_SIZE-1)) == 0); // page-aligned buffer
428
429 DPRINT_INFO(NETVSC, "Establishing send buffer's GPADL...");
430
431 // Establish the gpadl handle for this buffer on this channel.
432 // Note: This call uses the vmbus connection rather than the channel to establish
433 // the gpadl handle.
434 ret = Device->Driver->VmbusChannelInterface.EstablishGpadl(Device,
435 netDevice->SendBuffer,
436 netDevice->SendBufferSize,
437 &netDevice->SendBufferGpadlHandle);
438
439 if (ret != 0)
440 {
441 DPRINT_ERR(NETVSC, "unable to establish send buffer's gpadl");
442 goto Cleanup;
443 }
444
445 //WaitEventWait(ext->ChannelInitEvent);
446
447 // Notify the NetVsp of the gpadl handle
448 DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendSendBuffer...");
449
450 initPacket = &netDevice->ChannelInitPacket;
451
452 memset(initPacket, 0, sizeof(NVSP_MESSAGE));
453
454 initPacket->Header.MessageType = NvspMessage1TypeSendSendBuffer;
455 initPacket->Messages.Version1Messages.SendReceiveBuffer.GpadlHandle = netDevice->SendBufferGpadlHandle;
456 initPacket->Messages.Version1Messages.SendReceiveBuffer.Id = NETVSC_SEND_BUFFER_ID;
457
458 // Send the gpadl notification request
459 ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
460 initPacket,
461 sizeof(NVSP_MESSAGE),
462 (ULONG_PTR)initPacket,
463 VmbusPacketTypeDataInBand,
464 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
465 if (ret != 0)
466 {
467 DPRINT_ERR(NETVSC, "unable to send receive buffer's gpadl to netvsp");
468 goto Cleanup;
469 }
470
471 WaitEventWait(netDevice->ChannelInitEvent);
472
473 // Check the response
474 if (initPacket->Messages.Version1Messages.SendSendBufferComplete.Status != NvspStatusSuccess)
475 {
476 DPRINT_ERR(NETVSC,
477 "Unable to complete send buffer initialzation with NetVsp - status %d",
478 initPacket->Messages.Version1Messages.SendSendBufferComplete.Status);
479 ret = -1;
480 goto Cleanup;
481 }
482
483 netDevice->SendSectionSize = initPacket->Messages.Version1Messages.SendSendBufferComplete.SectionSize;
484
485 goto Exit;
486
487Cleanup:
488 NetVscDestroySendBuffer(netDevice);
489
490Exit:
491 PutNetDevice(Device);
492 DPRINT_EXIT(NETVSC);
493 return ret;
494}
495
496static int
497NetVscDestroyReceiveBuffer(
498 NETVSC_DEVICE *NetDevice
499 )
500{
501 NVSP_MESSAGE *revokePacket;
502 int ret=0;
503
504
505 DPRINT_ENTER(NETVSC);
506
507 // If we got a section count, it means we received a SendReceiveBufferComplete msg
508 // (ie sent NvspMessage1TypeSendReceiveBuffer msg) therefore, we need to send a revoke msg here
509 if (NetDevice->ReceiveSectionCount)
510 {
511 DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeRevokeReceiveBuffer...");
512
513 // Send the revoke receive buffer
514 revokePacket = &NetDevice->RevokePacket;
515 memset(revokePacket, 0, sizeof(NVSP_MESSAGE));
516
517 revokePacket->Header.MessageType = NvspMessage1TypeRevokeReceiveBuffer;
518 revokePacket->Messages.Version1Messages.RevokeReceiveBuffer.Id = NETVSC_RECEIVE_BUFFER_ID;
519
520 ret = NetDevice->Device->Driver->VmbusChannelInterface.SendPacket(NetDevice->Device,
521 revokePacket,
522 sizeof(NVSP_MESSAGE),
523 (ULONG_PTR)revokePacket,
524 VmbusPacketTypeDataInBand,
525 0);
526 // If we failed here, we might as well return and have a leak rather than continue and a bugchk
527 if (ret != 0)
528 {
529 DPRINT_ERR(NETVSC, "unable to send revoke receive buffer to netvsp");
530 DPRINT_EXIT(NETVSC);
531 return -1;
532 }
533 }
534
535 // Teardown the gpadl on the vsp end
536 if (NetDevice->ReceiveBufferGpadlHandle)
537 {
538 DPRINT_INFO(NETVSC, "Tearing down receive buffer's GPADL...");
539
540 ret = NetDevice->Device->Driver->VmbusChannelInterface.TeardownGpadl(NetDevice->Device,
541 NetDevice->ReceiveBufferGpadlHandle);
542
543 // If we failed here, we might as well return and have a leak rather than continue and a bugchk
544 if (ret != 0)
545 {
546 DPRINT_ERR(NETVSC, "unable to teardown receive buffer's gpadl");
547 DPRINT_EXIT(NETVSC);
548 return -1;
549 }
550 NetDevice->ReceiveBufferGpadlHandle = 0;
551 }
552
553 if (NetDevice->ReceiveBuffer)
554 {
555 DPRINT_INFO(NETVSC, "Freeing up receive buffer...");
556
557 // Free up the receive buffer
558 PageFree(NetDevice->ReceiveBuffer, NetDevice->ReceiveBufferSize >> PAGE_SHIFT);
559 NetDevice->ReceiveBuffer = NULL;
560 }
561
562 if (NetDevice->ReceiveSections)
563 {
564 MemFree(NetDevice->ReceiveSections);
565 NetDevice->ReceiveSections = NULL;
566 NetDevice->ReceiveSectionCount = 0;
567 }
568
569 DPRINT_EXIT(NETVSC);
570
571 return ret;
572}
573
574
575
576
577static int
578NetVscDestroySendBuffer(
579 NETVSC_DEVICE *NetDevice
580 )
581{
582 NVSP_MESSAGE *revokePacket;
583 int ret=0;
584
585
586 DPRINT_ENTER(NETVSC);
587
588 // If we got a section count, it means we received a SendReceiveBufferComplete msg
589 // (ie sent NvspMessage1TypeSendReceiveBuffer msg) therefore, we need to send a revoke msg here
590 if (NetDevice->SendSectionSize)
591 {
592 DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeRevokeSendBuffer...");
593
594 // Send the revoke send buffer
595 revokePacket = &NetDevice->RevokePacket;
596 memset(revokePacket, 0, sizeof(NVSP_MESSAGE));
597
598 revokePacket->Header.MessageType = NvspMessage1TypeRevokeSendBuffer;
599 revokePacket->Messages.Version1Messages.RevokeSendBuffer.Id = NETVSC_SEND_BUFFER_ID;
600
601 ret = NetDevice->Device->Driver->VmbusChannelInterface.SendPacket(NetDevice->Device,
602 revokePacket,
603 sizeof(NVSP_MESSAGE),
604 (ULONG_PTR)revokePacket,
605 VmbusPacketTypeDataInBand,
606 0);
607 // If we failed here, we might as well return and have a leak rather than continue and a bugchk
608 if (ret != 0)
609 {
610 DPRINT_ERR(NETVSC, "unable to send revoke send buffer to netvsp");
611 DPRINT_EXIT(NETVSC);
612 return -1;
613 }
614 }
615
616 // Teardown the gpadl on the vsp end
617 if (NetDevice->SendBufferGpadlHandle)
618 {
619 DPRINT_INFO(NETVSC, "Tearing down send buffer's GPADL...");
620
621 ret = NetDevice->Device->Driver->VmbusChannelInterface.TeardownGpadl(NetDevice->Device,
622 NetDevice->SendBufferGpadlHandle);
623
624 // If we failed here, we might as well return and have a leak rather than continue and a bugchk
625 if (ret != 0)
626 {
627 DPRINT_ERR(NETVSC, "unable to teardown send buffer's gpadl");
628 DPRINT_EXIT(NETVSC);
629 return -1;
630 }
631 NetDevice->SendBufferGpadlHandle = 0;
632 }
633
634 if (NetDevice->SendBuffer)
635 {
636 DPRINT_INFO(NETVSC, "Freeing up send buffer...");
637
638 // Free up the receive buffer
639 PageFree(NetDevice->SendBuffer, NetDevice->SendBufferSize >> PAGE_SHIFT);
640 NetDevice->SendBuffer = NULL;
641 }
642
643 DPRINT_EXIT(NETVSC);
644
645 return ret;
646}
647
648
649
650static int
651NetVscConnectToVsp(
652 DEVICE_OBJECT *Device
653 )
654{
655 int ret=0;
656 NETVSC_DEVICE *netDevice;
657 NVSP_MESSAGE *initPacket;
658 int ndisVersion;
659
660 DPRINT_ENTER(NETVSC);
661
662 netDevice = GetOutboundNetDevice(Device);
663 if (!netDevice)
664 {
665 DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
666 DPRINT_EXIT(NETVSC);
667 return -1;
668 }
669
670 initPacket = &netDevice->ChannelInitPacket;
671
672 memset(initPacket, 0, sizeof(NVSP_MESSAGE));
673 initPacket->Header.MessageType = NvspMessageTypeInit;
674 initPacket->Messages.InitMessages.Init.MinProtocolVersion = NVSP_MIN_PROTOCOL_VERSION;
675 initPacket->Messages.InitMessages.Init.MaxProtocolVersion = NVSP_MAX_PROTOCOL_VERSION;
676
677 DPRINT_INFO(NETVSC, "Sending NvspMessageTypeInit...");
678
679 // Send the init request
680 ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
681 initPacket,
682 sizeof(NVSP_MESSAGE),
683 (ULONG_PTR)initPacket,
684 VmbusPacketTypeDataInBand,
685 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
686
687 if( ret != 0)
688 {
689 DPRINT_ERR(NETVSC, "unable to send NvspMessageTypeInit");
690 goto Cleanup;
691 }
692
693 WaitEventWait(netDevice->ChannelInitEvent);
694
695 // Now, check the response
696 //ASSERT(initPacket->Messages.InitMessages.InitComplete.MaximumMdlChainLength <= MAX_MULTIPAGE_BUFFER_COUNT);
697 DPRINT_INFO(NETVSC, "NvspMessageTypeInit status(%d) max mdl chain (%d)",
698 initPacket->Messages.InitMessages.InitComplete.Status,
699 initPacket->Messages.InitMessages.InitComplete.MaximumMdlChainLength);
700
701 if (initPacket->Messages.InitMessages.InitComplete.Status != NvspStatusSuccess)
702 {
703 DPRINT_ERR(NETVSC, "unable to initialize with netvsp (status 0x%x)", initPacket->Messages.InitMessages.InitComplete.Status);
704 ret = -1;
705 goto Cleanup;
706 }
707
708 if (initPacket->Messages.InitMessages.InitComplete.NegotiatedProtocolVersion != NVSP_PROTOCOL_VERSION_1)
709 {
710 DPRINT_ERR(NETVSC, "unable to initialize with netvsp (version expected 1 got %d)",
711 initPacket->Messages.InitMessages.InitComplete.NegotiatedProtocolVersion);
712 ret = -1;
713 goto Cleanup;
714 }
715 DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendNdisVersion...");
716
717 // Send the ndis version
718 memset(initPacket, 0, sizeof(NVSP_MESSAGE));
719
720 ndisVersion = 0x00050000;
721
722 initPacket->Header.MessageType = NvspMessage1TypeSendNdisVersion;
723 initPacket->Messages.Version1Messages.SendNdisVersion.NdisMajorVersion = (ndisVersion & 0xFFFF0000) >> 16;
724 initPacket->Messages.Version1Messages.SendNdisVersion.NdisMinorVersion = ndisVersion & 0xFFFF;
725
726 // Send the init request
727 ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
728 initPacket,
729 sizeof(NVSP_MESSAGE),
730 (ULONG_PTR)initPacket,
731 VmbusPacketTypeDataInBand,
732 0);
733 if (ret != 0)
734 {
735 DPRINT_ERR(NETVSC, "unable to send NvspMessage1TypeSendNdisVersion");
736 ret = -1;
737 goto Cleanup;
738 }
739 //
740 // BUGBUG - We have to wait for the above msg since the netvsp uses KMCL which acknowledges packet (completion packet)
741 // since our Vmbus always set the VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED flag
742 //WaitEventWait(NetVscChannel->ChannelInitEvent);
743
744 // Post the big receive buffer to NetVSP
745 ret = NetVscInitializeReceiveBufferWithNetVsp(Device);
746 if (ret == 0)
747 {
748 ret = NetVscInitializeSendBufferWithNetVsp(Device);
749 }
750
751Cleanup:
752 PutNetDevice(Device);
753 DPRINT_EXIT(NETVSC);
754 return ret;
755}
756
757static void
758NetVscDisconnectFromVsp(
759 NETVSC_DEVICE *NetDevice
760 )
761{
762 DPRINT_ENTER(NETVSC);
763
764 NetVscDestroyReceiveBuffer(NetDevice);
765 NetVscDestroySendBuffer(NetDevice);
766
767 DPRINT_EXIT(NETVSC);
768}
769
770
771/*++
772
773Name:
774 NetVscOnDeviceAdd()
775
776Description:
777 Callback when the device belonging to this driver is added
778
779--*/
780int
781NetVscOnDeviceAdd(
782 DEVICE_OBJECT *Device,
783 void *AdditionalInfo
784 )
785{
786 int ret=0;
787 int i;
788
789 NETVSC_DEVICE* netDevice;
790 NETVSC_PACKET* packet;
791 LIST_ENTRY *entry;
792
793 NETVSC_DRIVER_OBJECT *netDriver = (NETVSC_DRIVER_OBJECT*) Device->Driver;;
794
795 DPRINT_ENTER(NETVSC);
796
797 netDevice = AllocNetDevice(Device);
798 if (!netDevice)
799 {
800 ret = -1;
801 goto Cleanup;
802 }
803
804 DPRINT_DBG(NETVSC, "netvsc channel object allocated - %p", netDevice);
805
806 // Initialize the NetVSC channel extension
807 netDevice->ReceiveBufferSize = NETVSC_RECEIVE_BUFFER_SIZE;
808 netDevice->ReceivePacketListLock = SpinlockCreate();
809
810 netDevice->SendBufferSize = NETVSC_SEND_BUFFER_SIZE;
811
812 INITIALIZE_LIST_HEAD(&netDevice->ReceivePacketList);
813
814 for (i=0; i < NETVSC_RECEIVE_PACKETLIST_COUNT; i++)
815 {
816 packet = MemAllocZeroed(sizeof(NETVSC_PACKET) + (NETVSC_RECEIVE_SG_COUNT* sizeof(PAGE_BUFFER)));
817 if (!packet)
818 {
819 DPRINT_DBG(NETVSC, "unable to allocate netvsc pkts for receive pool (wanted %d got %d)", NETVSC_RECEIVE_PACKETLIST_COUNT, i);
820 break;
821 }
822
823 INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &packet->ListEntry);
824 }
825 netDevice->ChannelInitEvent = WaitEventCreate();
826
827 // Open the channel
828 ret = Device->Driver->VmbusChannelInterface.Open(Device,
829 netDriver->RingBufferSize,
830 netDriver->RingBufferSize,
831 NULL, 0,
832 NetVscOnChannelCallback,
833 Device
834 );
835
836 if (ret != 0)
837 {
838 DPRINT_ERR(NETVSC, "unable to open channel: %d", ret);
839 ret = -1;
840 goto Cleanup;
841 }
842
843 // Channel is opened
844 DPRINT_INFO(NETVSC, "*** NetVSC channel opened successfully! ***");
845
846 // Connect with the NetVsp
847 ret = NetVscConnectToVsp(Device);
848 if (ret != 0)
849 {
850 DPRINT_ERR(NETVSC, "unable to connect to NetVSP - %d", ret);
851 ret = -1;
852 goto Close;
853 }
854
855 DPRINT_INFO(NETVSC, "*** NetVSC channel handshake result - %d ***", ret);
856
857 DPRINT_EXIT(NETVSC);
858 return ret;
859
860Close:
861 // Now, we can close the channel safely
862 Device->Driver->VmbusChannelInterface.Close(Device);
863
864Cleanup:
865
866 if (netDevice)
867 {
868 WaitEventClose(netDevice->ChannelInitEvent);
869
870 while (!IsListEmpty(&netDevice->ReceivePacketList))
871 {
872 entry = REMOVE_HEAD_LIST(&netDevice->ReceivePacketList);
873 packet = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
874 MemFree(packet);
875 }
876
877 SpinlockClose(netDevice->ReceivePacketListLock);
878
879 ReleaseOutboundNetDevice(Device);
880 ReleaseInboundNetDevice(Device);
881
882 FreeNetDevice(netDevice);
883 }
884
885 DPRINT_EXIT(NETVSC);
886 return ret;
887}
888
889
890/*++
891
892Name:
893 NetVscOnDeviceRemove()
894
895Description:
896 Callback when the root bus device is removed
897
898--*/
899int
900NetVscOnDeviceRemove(
901 DEVICE_OBJECT *Device
902 )
903{
904 NETVSC_DEVICE *netDevice;
905 NETVSC_PACKET *netvscPacket;
906 int ret=0;
907 LIST_ENTRY *entry;
908
909 DPRINT_ENTER(NETVSC);
910
911 DPRINT_INFO(NETVSC, "Disabling outbound traffic on net device (%p)...", Device->Extension);
912
913 // Stop outbound traffic ie sends and receives completions
914 netDevice = ReleaseOutboundNetDevice(Device);
915 if (!netDevice)
916 {
917 DPRINT_ERR(NETVSC, "No net device present!!");
918 return -1;
919 }
920
921 // Wait for all send completions
922 while (netDevice->NumOutstandingSends)
923 {
924 DPRINT_INFO(NETVSC, "waiting for %d requests to complete...", netDevice->NumOutstandingSends);
925
926 Sleep(100);
927 }
928
929 DPRINT_INFO(NETVSC, "Disconnecting from netvsp...");
930
931 NetVscDisconnectFromVsp(netDevice);
932
933 DPRINT_INFO(NETVSC, "Disabling inbound traffic on net device (%p)...", Device->Extension);
934
935 // Stop inbound traffic ie receives and sends completions
936 netDevice = ReleaseInboundNetDevice(Device);
937
938 // At this point, no one should be accessing netDevice except in here
939 DPRINT_INFO(NETVSC, "net device (%p) safe to remove", netDevice);
940
941 // Now, we can close the channel safely
942 Device->Driver->VmbusChannelInterface.Close(Device);
943
944 // Release all resources
945 while (!IsListEmpty(&netDevice->ReceivePacketList))
946 {
947 entry = REMOVE_HEAD_LIST(&netDevice->ReceivePacketList);
948 netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
949
950 MemFree(netvscPacket);
951 }
952
953 SpinlockClose(netDevice->ReceivePacketListLock);
954 WaitEventClose(netDevice->ChannelInitEvent);
955 FreeNetDevice(netDevice);
956
957 DPRINT_EXIT(NETVSC);
958 return ret;
959}
960
961
962
963/*++
964
965Name:
966 NetVscOnCleanup()
967
968Description:
969 Perform any cleanup when the driver is removed
970
971--*/
972void
973NetVscOnCleanup(
974 DRIVER_OBJECT *drv
975 )
976{
977 DPRINT_ENTER(NETVSC);
978
979 DPRINT_EXIT(NETVSC);
980}
981
982static void
983NetVscOnSendCompletion(
984 DEVICE_OBJECT *Device,
985 VMPACKET_DESCRIPTOR *Packet
986 )
987{
988 NETVSC_DEVICE* netDevice;
989 NVSP_MESSAGE *nvspPacket;
990 NETVSC_PACKET *nvscPacket;
991
992 DPRINT_ENTER(NETVSC);
993
994 netDevice = GetInboundNetDevice(Device);
995 if (!netDevice)
996 {
997 DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
998 DPRINT_EXIT(NETVSC);
999 return;
1000 }
1001
1002 nvspPacket = (NVSP_MESSAGE*)((ULONG_PTR)Packet + (Packet->DataOffset8 << 3));
1003
1004 DPRINT_DBG(NETVSC, "send completion packet - type %d", nvspPacket->Header.MessageType);
1005
1006 if (nvspPacket->Header.MessageType == NvspMessageTypeInitComplete ||
1007 nvspPacket->Header.MessageType == NvspMessage1TypeSendReceiveBufferComplete ||
1008 nvspPacket->Header.MessageType == NvspMessage1TypeSendSendBufferComplete)
1009 {
1010 // Copy the response back
1011 memcpy(&netDevice->ChannelInitPacket, nvspPacket, sizeof(NVSP_MESSAGE));
1012 WaitEventSet(netDevice->ChannelInitEvent);
1013 }
1014 else if (nvspPacket->Header.MessageType == NvspMessage1TypeSendRNDISPacketComplete)
1015 {
1016 // Get the send context
1017 nvscPacket = (NETVSC_PACKET *)(ULONG_PTR)Packet->TransactionId;
1018 ASSERT(nvscPacket);
1019
1020 // Notify the layer above us
1021 nvscPacket->Completion.Send.OnSendCompletion(nvscPacket->Completion.Send.SendCompletionContext);
1022
1023 InterlockedDecrement(&netDevice->NumOutstandingSends);
1024 }
1025 else
1026 {
1027 DPRINT_ERR(NETVSC, "Unknown send completion packet type - %d received!!", nvspPacket->Header.MessageType);
1028 }
1029
1030 PutNetDevice(Device);
1031 DPRINT_EXIT(NETVSC);
1032}
1033
1034
1035
1036static int
1037NetVscOnSend(
1038 DEVICE_OBJECT *Device,
1039 NETVSC_PACKET *Packet
1040 )
1041{
1042 NETVSC_DEVICE* netDevice;
1043 int ret=0;
1044
1045 NVSP_MESSAGE sendMessage;
1046
1047 DPRINT_ENTER(NETVSC);
1048
1049 netDevice = GetOutboundNetDevice(Device);
1050 if (!netDevice)
1051 {
1052 DPRINT_ERR(NETVSC, "net device (%p) shutting down...ignoring outbound packets", netDevice);
1053 DPRINT_EXIT(NETVSC);
1054 return -2;
1055 }
1056
1057 sendMessage.Header.MessageType = NvspMessage1TypeSendRNDISPacket;
1058 if (Packet->IsDataPacket)
1059 sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 0;// 0 is RMC_DATA;
1060 else
1061 sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 1;// 1 is RMC_CONTROL;
1062
1063 // Not using send buffer section
1064 sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionIndex = 0xFFFFFFFF;
1065 sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionSize = 0;
1066
1067 if (Packet->PageBufferCount)
1068 {
1069 ret = Device->Driver->VmbusChannelInterface.SendPacketPageBuffer(Device,
1070 Packet->PageBuffers,
1071 Packet->PageBufferCount,
1072 &sendMessage,
1073 sizeof(NVSP_MESSAGE),
1074 (ULONG_PTR)Packet);
1075 }
1076 else
1077 {
1078 ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
1079 &sendMessage,
1080 sizeof(NVSP_MESSAGE),
1081 (ULONG_PTR)Packet,
1082 VmbusPacketTypeDataInBand,
1083 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
1084
1085 }
1086
1087 if (ret != 0)
1088 {
1089 DPRINT_ERR(NETVSC, "Unable to send packet %p ret %d", Packet, ret);
1090 }
1091
1092 InterlockedIncrement(&netDevice->NumOutstandingSends);
1093 PutNetDevice(Device);
1094
1095 DPRINT_EXIT(NETVSC);
1096 return ret;
1097}
1098
1099
1100static void
1101NetVscOnReceive(
1102 DEVICE_OBJECT *Device,
1103 VMPACKET_DESCRIPTOR *Packet
1104 )
1105{
1106 NETVSC_DEVICE* netDevice;
1107 VMTRANSFER_PAGE_PACKET_HEADER *vmxferpagePacket;
1108 NVSP_MESSAGE *nvspPacket;
1109 NETVSC_PACKET *netvscPacket=NULL;
1110 LIST_ENTRY* entry;
1111 ULONG_PTR start;
1112 ULONG_PTR end, endVirtual;
1113 //NETVSC_DRIVER_OBJECT *netvscDriver;
1114 XFERPAGE_PACKET *xferpagePacket=NULL;
1115 LIST_ENTRY listHead;
1116
1117 int i=0, j=0;
1118 int count=0, bytesRemain=0;
1119
1120 DPRINT_ENTER(NETVSC);
1121
1122 netDevice = GetInboundNetDevice(Device);
1123 if (!netDevice)
1124 {
1125 DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
1126 DPRINT_EXIT(NETVSC);
1127 return;
1128 }
1129
1130 // All inbound packets other than send completion should be xfer page packet
1131 if (Packet->Type != VmbusPacketTypeDataUsingTransferPages)
1132 {
1133 DPRINT_ERR(NETVSC, "Unknown packet type received - %d", Packet->Type);
1134 PutNetDevice(Device);
1135 return;
1136 }
1137
1138 nvspPacket = (NVSP_MESSAGE*)((ULONG_PTR)Packet + (Packet->DataOffset8 << 3));
1139
1140 // Make sure this is a valid nvsp packet
1141 if (nvspPacket->Header.MessageType != NvspMessage1TypeSendRNDISPacket )
1142 {
1143 DPRINT_ERR(NETVSC, "Unknown nvsp packet type received - %d", nvspPacket->Header.MessageType);
1144 PutNetDevice(Device);
1145 return;
1146 }
1147
1148 DPRINT_DBG(NETVSC, "NVSP packet received - type %d", nvspPacket->Header.MessageType);
1149
1150 vmxferpagePacket = (VMTRANSFER_PAGE_PACKET_HEADER*)Packet;
1151
1152 if (vmxferpagePacket->TransferPageSetId != NETVSC_RECEIVE_BUFFER_ID)
1153 {
1154 DPRINT_ERR(NETVSC, "Invalid xfer page set id - expecting %x got %x", NETVSC_RECEIVE_BUFFER_ID, vmxferpagePacket->TransferPageSetId);
1155 PutNetDevice(Device);
1156 return;
1157 }
1158
1159 DPRINT_DBG(NETVSC, "xfer page - range count %d", vmxferpagePacket->RangeCount);
1160
1161 INITIALIZE_LIST_HEAD(&listHead);
1162
1163 // Grab free packets (range count + 1) to represent this xfer page packet. +1 to represent
1164 // the xfer page packet itself. We grab it here so that we know exactly how many we can fulfil
1165 SpinlockAcquire(netDevice->ReceivePacketListLock);
1166 while (!IsListEmpty(&netDevice->ReceivePacketList))
1167 {
1168 entry = REMOVE_HEAD_LIST(&netDevice->ReceivePacketList);
1169 netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
1170
1171 INSERT_TAIL_LIST(&listHead, &netvscPacket->ListEntry);
1172
1173 if (++count == vmxferpagePacket->RangeCount + 1)
1174 break;
1175 }
1176 SpinlockRelease(netDevice->ReceivePacketListLock);
1177
1178 // We need at least 2 netvsc pkts (1 to represent the xfer page and at least 1 for the range)
1179 // i.e. we can handled some of the xfer page packet ranges...
1180 if (count < 2)
1181 {
1182 DPRINT_ERR(NETVSC, "Got only %d netvsc pkt...needed %d pkts. Dropping this xfer page packet completely!", count, vmxferpagePacket->RangeCount+1);
1183
1184 // Return it to the freelist
1185 SpinlockAcquire(netDevice->ReceivePacketListLock);
1186 for (i=count; i != 0; i--)
1187 {
1188 entry = REMOVE_HEAD_LIST(&listHead);
1189 netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
1190
1191 INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &netvscPacket->ListEntry);
1192 }
1193 SpinlockRelease(netDevice->ReceivePacketListLock);
1194
1195 NetVscSendReceiveCompletion(Device, vmxferpagePacket->d.TransactionId);
1196
1197 PutNetDevice(Device);
1198 return;
1199 }
1200
1201 // Remove the 1st packet to represent the xfer page packet itself
1202 entry = REMOVE_HEAD_LIST(&listHead);
1203 xferpagePacket = CONTAINING_RECORD(entry, XFERPAGE_PACKET, ListEntry);
1204 xferpagePacket->Count = count - 1; // This is how much we can satisfy
1205 ASSERT(xferpagePacket->Count > 0 && xferpagePacket->Count <= vmxferpagePacket->RangeCount);
1206
1207 if (xferpagePacket->Count != vmxferpagePacket->RangeCount)
1208 {
1209 DPRINT_INFO(NETVSC, "Needed %d netvsc pkts to satisy this xfer page...got %d", vmxferpagePacket->RangeCount, xferpagePacket->Count);
1210 }
1211
1212 // Each range represents 1 RNDIS pkt that contains 1 ethernet frame
1213 for (i=0; i < (count - 1); i++)
1214 {
1215 entry = REMOVE_HEAD_LIST(&listHead);
1216 netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
1217
1218 // Initialize the netvsc packet
1219 netvscPacket->XferPagePacket = xferpagePacket;
1220 netvscPacket->Completion.Recv.OnReceiveCompletion = NetVscOnReceiveCompletion;
1221 netvscPacket->Completion.Recv.ReceiveCompletionContext = netvscPacket;
1222 netvscPacket->Device = Device;
1223 netvscPacket->Completion.Recv.ReceiveCompletionTid = vmxferpagePacket->d.TransactionId; // Save this so that we can send it back
1224
1225 netvscPacket->TotalDataBufferLength = vmxferpagePacket->Ranges[i].ByteCount;
1226 netvscPacket->PageBufferCount = 1;
1227
1228 ASSERT(vmxferpagePacket->Ranges[i].ByteOffset + vmxferpagePacket->Ranges[i].ByteCount < netDevice->ReceiveBufferSize);
1229
1230 netvscPacket->PageBuffers[0].Length = vmxferpagePacket->Ranges[i].ByteCount;
1231
1232 start = GetPhysicalAddress((void*)((ULONG_PTR)netDevice->ReceiveBuffer + vmxferpagePacket->Ranges[i].ByteOffset));
1233
1234 netvscPacket->PageBuffers[0].Pfn = start >> PAGE_SHIFT;
1235 endVirtual = (ULONG_PTR)netDevice->ReceiveBuffer
1236 + vmxferpagePacket->Ranges[i].ByteOffset
1237 + vmxferpagePacket->Ranges[i].ByteCount -1;
1238 end = GetPhysicalAddress((void*)endVirtual);
1239
1240 // Calculate the page relative offset
1241 netvscPacket->PageBuffers[0].Offset = vmxferpagePacket->Ranges[i].ByteOffset & (PAGE_SIZE -1);
1242 if ((end >> PAGE_SHIFT) != (start>>PAGE_SHIFT)) {
1243 //Handle frame across multiple pages:
1244 netvscPacket->PageBuffers[0].Length =
1245 (netvscPacket->PageBuffers[0].Pfn <<PAGE_SHIFT) + PAGE_SIZE - start;
1246 bytesRemain = netvscPacket->TotalDataBufferLength - netvscPacket->PageBuffers[0].Length;
1247 for (j=1; j<NETVSC_PACKET_MAXPAGE; j++) {
1248 netvscPacket->PageBuffers[j].Offset = 0;
1249 if (bytesRemain <= PAGE_SIZE) {
1250 netvscPacket->PageBuffers[j].Length = bytesRemain;
1251 bytesRemain = 0;
1252 } else {
1253 netvscPacket->PageBuffers[j].Length = PAGE_SIZE;
1254 bytesRemain -= PAGE_SIZE;
1255 }
1256 netvscPacket->PageBuffers[j].Pfn =
1257 GetPhysicalAddress((void*)(endVirtual - bytesRemain)) >> PAGE_SHIFT;
1258 netvscPacket->PageBufferCount++;
1259 if (bytesRemain == 0)
1260 break;
1261 }
1262 ASSERT(bytesRemain == 0);
1263 }
1264 DPRINT_DBG(NETVSC, "[%d] - (abs offset %u len %u) => (pfn %llx, offset %u, len %u)",
1265 i,
1266 vmxferpagePacket->Ranges[i].ByteOffset,
1267 vmxferpagePacket->Ranges[i].ByteCount,
1268 netvscPacket->PageBuffers[0].Pfn,
1269 netvscPacket->PageBuffers[0].Offset,
1270 netvscPacket->PageBuffers[0].Length);
1271
1272 // Pass it to the upper layer
1273 ((NETVSC_DRIVER_OBJECT*)Device->Driver)->OnReceiveCallback(Device, netvscPacket);
1274
1275 NetVscOnReceiveCompletion(netvscPacket->Completion.Recv.ReceiveCompletionContext);
1276 }
1277
1278 ASSERT(IsListEmpty(&listHead));
1279
1280 PutNetDevice(Device);
1281 DPRINT_EXIT(NETVSC);
1282}
1283
1284
1285static void
1286NetVscSendReceiveCompletion(
1287 DEVICE_OBJECT *Device,
1288 UINT64 TransactionId
1289 )
1290{
1291 NVSP_MESSAGE recvcompMessage;
1292 int retries=0;
1293 int ret=0;
1294
1295 DPRINT_DBG(NETVSC, "Sending receive completion pkt - %llx", TransactionId);
1296
1297 recvcompMessage.Header.MessageType = NvspMessage1TypeSendRNDISPacketComplete;
1298
1299 // FIXME: Pass in the status
1300 recvcompMessage.Messages.Version1Messages.SendRNDISPacketComplete.Status = NvspStatusSuccess;
1301
1302retry_send_cmplt:
1303 // Send the completion
1304 ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
1305 &recvcompMessage,
1306 sizeof(NVSP_MESSAGE),
1307 TransactionId,
1308 VmbusPacketTypeCompletion,
1309 0);
1310 if (ret == 0) // success
1311 {
1312 // no-op
1313 }
1314 else if (ret == -1) // no more room...wait a bit and attempt to retry 3 times
1315 {
1316 retries++;
1317 DPRINT_ERR(NETVSC, "unable to send receive completion pkt (tid %llx)...retrying %d", TransactionId, retries);
1318
1319 if (retries < 4)
1320 {
1321 Sleep(100);
1322 goto retry_send_cmplt;
1323 }
1324 else
1325 {
1326 DPRINT_ERR(NETVSC, "unable to send receive completion pkt (tid %llx)...give up retrying", TransactionId);
1327 }
1328 }
1329 else
1330 {
1331 DPRINT_ERR(NETVSC, "unable to send receive completion pkt - %llx", TransactionId);
1332 }
1333}
1334
1335//
1336// Send a receive completion packet to RNDIS device (ie NetVsp)
1337//
1338static void
1339NetVscOnReceiveCompletion(
8282c400 1340 void * Context)
fceaf24a
HJ		 1341{
1342 NETVSC_PACKET *packet = (NETVSC_PACKET*)Context;
1343 DEVICE_OBJECT *device = (DEVICE_OBJECT*)packet->Device;
1344 NETVSC_DEVICE* netDevice;
1345 UINT64 transactionId=0;
1346 BOOL fSendReceiveComp = FALSE;
1347
1348 DPRINT_ENTER(NETVSC);
1349
1350 ASSERT(packet->XferPagePacket);
1351
1352 // Even though it seems logical to do a GetOutboundNetDevice() here to send out receive completion,
1353 // we are using GetInboundNetDevice() since we may have disable outbound traffic already.
1354 netDevice = GetInboundNetDevice(device);
1355 if (!netDevice)
1356 {
1357 DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
1358 DPRINT_EXIT(NETVSC);
1359 return;
1360 }
1361
1362 // Overloading use of the lock.
1363 SpinlockAcquire(netDevice->ReceivePacketListLock);
1364
1365 ASSERT(packet->XferPagePacket->Count > 0);
1366 packet->XferPagePacket->Count--;
1367
1368 // Last one in the line that represent 1 xfer page packet.
1369 // Return the xfer page packet itself to the freelist
1370 if (packet->XferPagePacket->Count == 0)
1371 {
1372 fSendReceiveComp = TRUE;
1373 transactionId = packet->Completion.Recv.ReceiveCompletionTid;
1374
1375 INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &packet->XferPagePacket->ListEntry);
1376 }
1377
1378 // Put the packet back
1379 INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &packet->ListEntry);
1380 SpinlockRelease(netDevice->ReceivePacketListLock);
1381
1382 // Send a receive completion for the xfer page packet
1383 if (fSendReceiveComp)
1384 {
1385 NetVscSendReceiveCompletion(device, transactionId);
1386 }
1387
1388 PutNetDevice(device);
1389 DPRINT_EXIT(NETVSC);
1390}
1391
1392
1393
1394void
1395NetVscOnChannelCallback(
8282c400 1396 void * Context
fceaf24a
HJ		 1397 )
1398{
1399 const int netPacketSize=2048;
1400 int ret=0;
1401 DEVICE_OBJECT *device=(DEVICE_OBJECT*)Context;
1402 NETVSC_DEVICE *netDevice;
1403
1404 UINT32 bytesRecvd;
1405 UINT64 requestId;
1406 UCHAR packet[netPacketSize];
1407 VMPACKET_DESCRIPTOR *desc;
1408 UCHAR *buffer=packet;
1409 int bufferlen=netPacketSize;
1410
1411
1412 DPRINT_ENTER(NETVSC);
1413
1414 ASSERT(device);
1415
1416 netDevice = GetInboundNetDevice(device);
1417 if (!netDevice)
1418 {
1419 DPRINT_ERR(NETVSC, "net device (%p) shutting down...ignoring inbound packets", netDevice);
1420 DPRINT_EXIT(NETVSC);
1421 return;
1422 }
1423
1424 do
1425 {
1426 ret = device->Driver->VmbusChannelInterface.RecvPacketRaw(device,
1427 buffer,
1428 bufferlen,
1429 &bytesRecvd,
1430 &requestId);
1431
1432 if (ret == 0)
1433 {
1434 if (bytesRecvd > 0)
1435 {
1436 DPRINT_DBG(NETVSC, "receive %d bytes, tid %llx", bytesRecvd, requestId);
1437
1438 desc = (VMPACKET_DESCRIPTOR*)buffer;
1439 switch (desc->Type)
1440 {
1441 case VmbusPacketTypeCompletion:
1442 NetVscOnSendCompletion(device, desc);
1443 break;
1444
1445 case VmbusPacketTypeDataUsingTransferPages:
1446 NetVscOnReceive(device, desc);
1447 break;
1448
1449 default:
1450 DPRINT_ERR(NETVSC, "unhandled packet type %d, tid %llx len %d\n", desc->Type, requestId, bytesRecvd);
1451 break;
1452 }
1453
1454 // reset
1455 if (bufferlen > netPacketSize)
1456 {
1457 MemFree(buffer);
1458
1459 buffer = packet;
1460 bufferlen = netPacketSize;
1461 }
1462 }
1463 else
1464 {
1465 //DPRINT_DBG(NETVSC, "nothing else to read...");
1466
1467 // reset
1468 if (bufferlen > netPacketSize)
1469 {
1470 MemFree(buffer);
1471
1472 buffer = packet;
1473 bufferlen = netPacketSize;
1474 }
1475
1476 break;
1477 }
1478 }
1479 else if (ret == -2) // Handle large packet
1480 {
1481 buffer = MemAllocAtomic(bytesRecvd);
1482 if (buffer == NULL)
1483 {
1484 // Try again next time around
1485 DPRINT_ERR(NETVSC, "unable to allocate buffer of size (%d)!!", bytesRecvd);
1486 break;
1487 }
1488
1489 bufferlen = bytesRecvd;
1490 }
1491 else
1492 {
1493 ASSERT(0);
1494 }
1495 } while (1);
1496
1497 PutNetDevice(device);
1498 DPRINT_EXIT(NETVSC);
1499 return;
1500}
Linux 6.x block layer and io_uring tree(s)