SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/hv/NetVsc.c

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