Microsoft Hyper-V drivers for Linux

@@ -0,0 +1,312 @@
+/*
+ *
+ * Copyright (c) 2009, Microsoft Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Authors:
+ *   Haiyang Zhang <[email protected]>
+ *   Hank Janssen  <[email protected]>
+ *
+ */
+
+
+#pragma once
+
+#include <VmbusPacketFormat.h>
+
+#define C_ASSERT(x)
+typedef UINT32 NTSTATUS;
+
+#pragma pack(push,1)
+
+//
+// Version 1 messages
+//
+
+typedef enum _VMBUS_CHANNEL_MESSAGE_TYPE
+{
+    ChannelMessageInvalid                   =  0,
+    ChannelMessageOfferChannel              =  1,
+    ChannelMessageRescindChannelOffer       =  2,
+    ChannelMessageRequestOffers             =  3,
+    ChannelMessageAllOffersDelivered        =  4,
+    ChannelMessageOpenChannel               =  5,
+    ChannelMessageOpenChannelResult         =  6,
+    ChannelMessageCloseChannel              =  7,
+    ChannelMessageGpadlHeader               =  8,
+    ChannelMessageGpadlBody                 =  9,
+    ChannelMessageGpadlCreated              = 10,
+    ChannelMessageGpadlTeardown             = 11,
+    ChannelMessageGpadlTorndown             = 12,
+    ChannelMessageRelIdReleased             = 13,
+    ChannelMessageInitiateContact           = 14,
+    ChannelMessageVersionResponse           = 15,
+    ChannelMessageUnload                    = 16,
+#ifdef VMBUS_FEATURE_PARENT_OR_PEER_MEMORY_MAPPED_INTO_A_CHILD
+    ChannelMessageViewRangeAdd              = 17,
+    ChannelMessageViewRangeRemove           = 18,
+#endif
+    ChannelMessageCount
+} VMBUS_CHANNEL_MESSAGE_TYPE, *PVMBUS_CHANNEL_MESSAGE_TYPE;
+
+// begin_wpp config
+// CUSTOM_TYPE(ChannelMessageType, ItemEnum(_VMBUS_CHANNEL_MESSAGE_TYPE));
+// end_wpp
+
+typedef struct _VMBUS_CHANNEL_MESSAGE_HEADER
+{
+    VMBUS_CHANNEL_MESSAGE_TYPE  MessageType;
+    UINT32                      Padding;
+} VMBUS_CHANNEL_MESSAGE_HEADER, *PVMBUS_CHANNEL_MESSAGE_HEADER;
+
+// Query VMBus Version parameters
+typedef struct _VMBUS_CHANNEL_QUERY_VMBUS_VERSION
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32 Version;
+} VMBUS_CHANNEL_QUERY_VMBUS_VERSION, *PVMBUS_CHANNEL_QUERY_VMBUS_VERSION;
+
+// VMBus Version Supported parameters
+typedef struct _VMBUS_CHANNEL_VERSION_SUPPORTED
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    BOOLEAN VersionSupported;
+} VMBUS_CHANNEL_VERSION_SUPPORTED, *PVMBUS_CHANNEL_VERSION_SUPPORTED;
+
+// Offer Channel parameters
+typedef struct _VMBUS_CHANNEL_OFFER_CHANNEL
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    VMBUS_CHANNEL_OFFER Offer;
+    UINT32  ChildRelId;
+    UINT8   MonitorId;
+    BOOLEAN MonitorAllocated;
+} VMBUS_CHANNEL_OFFER_CHANNEL, *PVMBUS_CHANNEL_OFFER_CHANNEL;
+
+//
+// Make sure VMBUS_CHANNEL_OFFER_CHANNEL fits into Synic message.
+//
+C_ASSERT(sizeof(VMBUS_CHANNEL_OFFER_CHANNEL) <= MAXIMUM_SYNIC_MESSAGE_BYTES);
+
+// Rescind Offer parameters
+typedef struct _VMBUS_CHANNEL_RESCIND_OFFER
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32          ChildRelId;
+} VMBUS_CHANNEL_RESCIND_OFFER, *PVMBUS_CHANNEL_RESCIND_OFFER;
+
+// Request Offer -- no parameters, SynIC message contains the partition ID
+// Set Snoop -- no parameters, SynIC message contains the partition ID
+// Clear Snoop -- no parameters, SynIC message contains the partition ID
+// All Offers Delivered -- no parameters, SynIC message contains the partition ID
+// Flush Client -- no parameters, SynIC message contains the partition ID
+
+// Open Channel parameters
+typedef struct _VMBUS_CHANNEL_OPEN_CHANNEL
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+
+    //
+    // Identifies the specific VMBus channel that is being opened.
+    //
+    UINT32          ChildRelId;
+
+    //
+    // ID making a particular open request at a channel offer unique.
+    //
+    UINT32          OpenId;
+
+    //
+    // GPADL for the channel's ring buffer.
+    //
+    GPADL_HANDLE    RingBufferGpadlHandle;
+
+    //
+    // GPADL for the channel's server context save area.
+    //
+    GPADL_HANDLE    ServerContextAreaGpadlHandle;
+
+    //
+    // The upstream ring buffer begins at offset zero in the memory described
+    // by RingBufferGpadlHandle. The downstream ring buffer follows it at this
+    // offset (in pages).
+    //
+    UINT32          DownstreamRingBufferPageOffset;
+
+    //
+    // User-specific data to be passed along to the server endpoint.
+    //
+    UCHAR           UserData[MAX_USER_DEFINED_BYTES];
+
+} VMBUS_CHANNEL_OPEN_CHANNEL, *PVMBUS_CHANNEL_OPEN_CHANNEL;
+
+// Reopen Channel parameters;
+typedef VMBUS_CHANNEL_OPEN_CHANNEL VMBUS_CHANNEL_REOPEN_CHANNEL, *PVMBUS_CHANNEL_REOPEN_CHANNEL;
+
+// Open Channel Result parameters
+typedef struct _VMBUS_CHANNEL_OPEN_RESULT
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32      ChildRelId;
+    UINT32      OpenId;
+    NTSTATUS    Status;
+} VMBUS_CHANNEL_OPEN_RESULT, *PVMBUS_CHANNEL_OPEN_RESULT;
+
+// Close channel parameters;
+typedef struct _VMBUS_CHANNEL_CLOSE_CHANNEL
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32      ChildRelId;
+} VMBUS_CHANNEL_CLOSE_CHANNEL, *PVMBUS_CHANNEL_CLOSE_CHANNEL;
+
+// Channel Message GPADL
+#define GPADL_TYPE_RING_BUFFER          1
+#define GPADL_TYPE_SERVER_SAVE_AREA     2
+#define GPADL_TYPE_TRANSACTION          8
+
+//
+// The number of PFNs in a GPADL message is defined by the number of pages
+// that would be spanned by ByteCount and ByteOffset.  If the implied number
+// of PFNs won't fit in this packet, there will be a follow-up packet that
+// contains more.
+//
+
+typedef struct _VMBUS_CHANNEL_GPADL_HEADER
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32      ChildRelId;
+    UINT32      Gpadl;
+    UINT16      RangeBufLen;
+    UINT16      RangeCount;
+    GPA_RANGE   Range[0];
+} VMBUS_CHANNEL_GPADL_HEADER, *PVMBUS_CHANNEL_GPADL_HEADER;
+
+
+//
+// This is the followup packet that contains more PFNs.
+//
+
+typedef struct _VMBUS_CHANNEL_GPADL_BODY
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32              MessageNumber;
+    UINT32              Gpadl;
+    UINT64              Pfn[0];
+} VMBUS_CHANNEL_GPADL_BODY, *PVMBUS_CHANNEL_GPADL_BODY;
+
+
+typedef struct _VMBUS_CHANNEL_GPADL_CREATED
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32              ChildRelId;
+    UINT32              Gpadl;
+    UINT32              CreationStatus;
+} VMBUS_CHANNEL_GPADL_CREATED, *PVMBUS_CHANNEL_GPADL_CREATED;
+
+typedef struct _VMBUS_CHANNEL_GPADL_TEARDOWN
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32              ChildRelId;
+    UINT32              Gpadl;
+} VMBUS_CHANNEL_GPADL_TEARDOWN, *PVMBUS_CHANNEL_GPADL_TEARDOWN;
+
+typedef struct _VMBUS_CHANNEL_GPADL_TORNDOWN
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32              Gpadl;
+} VMBUS_CHANNEL_GPADL_TORNDOWN, *PVMBUS_CHANNEL_GPADL_TORNDOWN;
+
+#ifdef VMBUS_FEATURE_PARENT_OR_PEER_MEMORY_MAPPED_INTO_A_CHILD
+typedef struct _VMBUS_CHANNEL_VIEW_RANGE_ADD
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    PHYSICAL_ADDRESS    ViewRangeBase;
+    UINT64              ViewRangeLength;
+    UINT32              ChildRelId;
+} VMBUS_CHANNEL_VIEW_RANGE_ADD, *PVMBUS_CHANNEL_VIEW_RANGE_ADD;
+
+typedef struct _VMBUS_CHANNEL_VIEW_RANGE_REMOVE
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    PHYSICAL_ADDRESS    ViewRangeBase;
+    UINT32              ChildRelId;
+} VMBUS_CHANNEL_VIEW_RANGE_REMOVE, *PVMBUS_CHANNEL_VIEW_RANGE_REMOVE;
+#endif
+
+typedef struct _VMBUS_CHANNEL_RELID_RELEASED
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32              ChildRelId;
+} VMBUS_CHANNEL_RELID_RELEASED, *PVMBUS_CHANNEL_RELID_RELEASED;
+
+typedef struct _VMBUS_CHANNEL_INITIATE_CONTACT
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    UINT32              VMBusVersionRequested;
+    UINT32              Padding2;
+    UINT64              InterruptPage;
+    UINT64              MonitorPage1;
+    UINT64              MonitorPage2;
+} VMBUS_CHANNEL_INITIATE_CONTACT, *PVMBUS_CHANNEL_INITIATE_CONTACT;
+
+typedef struct _VMBUS_CHANNEL_VERSION_RESPONSE
+{
+    VMBUS_CHANNEL_MESSAGE_HEADER Header;
+    BOOLEAN     VersionSupported;
+} VMBUS_CHANNEL_VERSION_RESPONSE, *PVMBUS_CHANNEL_VERSION_RESPONSE;
+
+typedef VMBUS_CHANNEL_MESSAGE_HEADER VMBUS_CHANNEL_UNLOAD, *PVMBUS_CHANNEL_UNLOAD;
+
+//
+// Kind of a table to use the preprocessor to get us the right type for a
+// specified message ID. Used with ChAllocateSendMessage()
+//
+#define ChannelMessageQueryVmbusVersion_TYPE    VMBUS_CHANNEL_MESSAGE_HEADER
+#define ChannelMessageVmbusVersionSupported_TYPE VMBUS_CHANNEL_VERSION_SUPPORTED
+#define ChannelMessageOfferChannel_TYPE         VMBUS_CHANNEL_OFFER_CHANNEL
+#define ChannelMessageRescindChannelOffer_TYPE  VMBUS_CHANNEL_RESCIND_OFFER
+#define ChannelMessageRequestOffers_TYPE        VMBUS_CHANNEL_MESSAGE_HEADER
+#define ChannelMessageAllOffersDelivered_TYPE   VMBUS_CHANNEL_MESSAGE_HEADER
+#define ChannelMessageOpenChannel_TYPE          VMBUS_CHANNEL_OPEN_CHANNEL
+#define ChannelMessageOpenChannelResult_TYPE    VMBUS_CHANNEL_OPEN_RESULT
+#define ChannelMessageCloseChannel_TYPE         VMBUS_CHANNEL_CLOSE_CHANNEL
+#define ChannelMessageAllGpadlsUnmapped_TYPE    VMBUS_CHANNEL_CLOSE_CHANNEL
+#define ChannelMessageGpadlHeader_TYPE          VMBUS_CHANNEL_GPADL_HEADER
+#define ChannelMessageGpadlBody_TYPE            VMBUS_CHANNEL_GPADL_BODY
+#define ChannelMessageGpadlCreated_TYPE         VMBUS_CHANNEL_GPADL_CREATED
+#define ChannelMessageGpadlTeardown_TYPE        VMBUS_CHANNEL_GPADL_TEARDOWN
+#define ChannelMessageGpadlTorndown_TYPE        VMBUS_CHANNEL_GPADL_TORNDOWN
+#define ChannelMessageViewRangeAdd_TYPE         VMBUS_CHANNEL_VIEW_RANGE_ADD
+#define ChannelMessageViewRangeRemove_TYPE      VMBUS_CHANNEL_VIEW_RANGE_REMOVE
+#define ChannelMessageRelIdReleased_TYPE        VMBUS_CHANNEL_RELID_RELEASED
+#define ChannelMessageInitiateContact_TYPE      VMBUS_CHANNEL_INITIATE_CONTACT
+#define ChannelMessageVersionResponse_TYPE      VMBUS_CHANNEL_VERSION_RESPONSE
+#define ChannelMessageUnload_TYPE               VMBUS_CHANNEL_UNLOAD
+
+//
+// Preprocessor wrapper to ChAllocateSendMessageSize() converting the return
+// value to the correct pointer and calculate the needed size.
+//
+// Argument:
+//
+//  Id - the numberic ID (type VMBUS_CHANNEL_MESSAGE_TYPE) of the message to
+//       send.
+//
+#define ChAllocateSendMessage(Id, Fn, Context)   \
+    (Id##_TYPE*)ChAllocateSendMessageSized(sizeof(Id##_TYPE), Id, Fn, Context)
+
+
+#pragma pack(pop)
+

@@ -0,0 +1,32 @@
+/*
+ *
+ * Copyright (c) 2009, Microsoft Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Authors:
+ *   Haiyang Zhang <[email protected]>
+ *   Hank Janssen  <[email protected]>
+ *
+ */
+
+
+#pragma once
+
+
+//
+// Time in the hypervisor is measured in 100 nanosecond units
+//
+typedef UINT64 HV_NANO100_TIME,     *PHV_NANO100_TIME;
+typedef UINT64 HV_NANO100_DURATION, *PHV_NANO100_DURATION;

60 lines not on this page · raw message

86 lines not on this page · raw message

718 lines not on this page · raw message

490 lines not on this page · raw message

@@ -0,0 +1,31 @@
+/*
+ *
+ * Copyright (c) 2009, Microsoft Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Authors:
+ *   Haiyang Zhang <[email protected]>
+ *   Hank Janssen  <[email protected]>
+ *
+ */
+
+
+#pragma once
+
+typedef UINT64 HV_GPA, *PHV_GPA;
+
+#define HV_X64_PAGE_SIZE (4096)
+#define HV_PAGE_SIZE HV_X64_PAGE_SIZE
+

51 lines not on this page · raw message

269 lines not on this page · raw message

306 lines not on this page · raw message

645 lines not on this page · raw message

131 lines not on this page · raw message

322 lines not on this page · raw message

309 lines not on this page · raw message

@@ -0,0 +1,134 @@
+/*
+ *
+ * Copyright (c) 2009, Microsoft Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Authors:
+ *   Haiyang Zhang <[email protected]>
+ *   Hank Janssen  <[email protected]>
+ *
+ */
+
+
+#ifndef _LOGGING_H_
+#define _LOGGING_H_
+
+//#include <linux/init.h>
+//#include <linux/module.h>
+
+#include "osd.h"
+
+#define VMBUS				0x0001
+#define STORVSC				0x0002
+#define NETVSC				0x0004
+#define INPUTVSC			0x0008
+#define BLKVSC				0x0010
+#define VMBUS_DRV			0x0100
+#define STORVSC_DRV			0x0200
+#define NETVSC_DRV			0x0400
+#define INPUTVSC_DRV		0x0800
+#define BLKVSC_DRV			0x1000
+
+#define ALL_MODULES			(VMBUS		|\
+							STORVSC		|\
+							NETVSC		|\
+							INPUTVSC	|\
+							BLKVSC		|\
+							VMBUS_DRV	|\
+							STORVSC_DRV	|\
+							NETVSC_DRV	|\
+							INPUTVSC_DRV|\
+							BLKVSC_DRV)
+
+// Logging Level
+#define CRITICAL_LVL				2
+#define ERROR_LVL					3
+#define WARNING_LVL					4
+#define INFO_LVL					6
+#define DEBUG_LVL					7
+#define DEBUG_LVL_ENTEREXIT			8
+#define DEBUG_RING_LVL				9
+
+extern unsigned int vmbus_loglevel;
+
+#define ASSERT(expr)	\
+        if (!(expr)) {	\
+		LogMsg("<%d>Assertion failed! %s,%s,%s,line=%d\n", CRITICAL_LVL, #expr,__FILE__,__FUNCTION__,__LINE__);	\
+		__asm__ __volatile__("int3");	\
+        }
+
+#define DPRINT(mod, lvl, fmt, args...) do {\
+	if (mod & (HIWORD(vmbus_loglevel))) \
+		(lvl <= LOWORD(vmbus_loglevel))?(LogMsg("<%d>" #mod": %s() " fmt "\n", DEBUG_LVL, __FUNCTION__, ## args)):(0);\
+	} while (0)
+
+#define DPRINT_DBG(mod, fmt, args...) do {\
+	if (mod & (HIWORD(vmbus_loglevel))) \
+		(DEBUG_LVL <= LOWORD(vmbus_loglevel))?(LogMsg("<%d>" #mod": %s() " fmt "\n", DEBUG_LVL, __FUNCTION__, ## args)):(0);\
+	} while (0)
+
+#define DPRINT_INFO(mod, fmt, args...) do {\
+	if (mod & (HIWORD(vmbus_loglevel))) \
+		(INFO_LVL <= LOWORD(vmbus_loglevel))?(LogMsg("<%d>" #mod": " fmt "\n", INFO_LVL, ## args)):(0);\
+	} while (0)
+
+#define DPRINT_WARN(mod, fmt, args...) do {\
+	if (mod & (HIWORD(vmbus_loglevel))) \
+		(WARNING_LVL <= LOWORD(vmbus_loglevel))?(LogMsg("<%d>" #mod": WARNING! " fmt "\n", WARNING_LVL, ## args)):(0);\
+	} while (0)
+
+#define DPRINT_ERR(mod, fmt, args...) do {\
+	if (mod & (HIWORD(vmbus_loglevel))) \
+		(ERROR_LVL <= LOWORD(vmbus_loglevel))?(LogMsg("<%d>" #mod": %s() ERROR!! " fmt "\n", ERROR_LVL, __FUNCTION__, ## args)):(0);\
+	} while (0)
+
+#ifdef DEBUG
+#define DPRINT_ENTER(mod) do {\
+	if (mod & (HIWORD(vmbus_loglevel))) \
+		(DEBUG_LVL_ENTEREXIT <= LOWORD(vmbus_loglevel))?(LogMsg("<%d>" "["#mod"]: %s() enter\n", DEBUG_LVL, __FUNCTION__)):(0);\
+	} while (0)
+
+#define DPRINT_EXIT(mod) do {\
+	if (mod & (HIWORD(vmbus_loglevel))) \
+		(DEBUG_LVL_ENTEREXIT <= LOWORD(vmbus_loglevel))?(LogMsg("<%d>" "["#mod"]: %s() exit\n", DEBUG_LVL, __FUNCTION__)):(0);\
+	} while (0)
+#else
+#define DPRINT_ENTER(mod)
+#define DPRINT_EXIT(mod)
+#endif
+
+static inline void PrintBytes(const unsigned char* bytes, int len)
+{
+	int i=0;
+
+	LogMsg("\n<< ");
+	for (i=0; i< len; i++)
+	{
+		LogMsg("0x%x ", bytes[i]);
+	}
+	LogMsg(">>\n");
+}
+
+//
+// Inline
+//
+//static inline void GuidToStr(const GUID g, char *str)
+//{
+//	sprintf(str, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
+//	g[3], g[2], g[1], g[0], g[5], g[4], g[7], g[6], g[8], g[9], g[10], g[11], g[12], g[13], g[14], g[15]);
+//
+//}
+
+#endif //_LOGGING_H_

145 lines not on this page · raw message

263 lines not on this page · raw message

137 lines not on this page · raw message

262 lines not on this page · raw message

111 lines not on this page · raw message

@@ -0,0 +1,1199 @@
+/*
+ *
+ * Copyright (c) 2009, Microsoft Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Authors:
+ *   Haiyang Zhang <[email protected]>
+ *   Hank Janssen  <[email protected]>
+ *
+ */
+
+
+#include "osd.h"
+#include "logging.h"
+
+#include "VmbusPrivate.h"
+
+//
+// Internal routines
+//
+static int
+VmbusChannelCreateGpadlHeader(
+	PVOID					Kbuffer,	// must be phys and virt contiguous
+	UINT32					Size,		// page-size multiple
+	VMBUS_CHANNEL_MSGINFO	**msgInfo,
+	UINT32					*MessageCount
+	);
+
+static void
+DumpVmbusChannel(
+	VMBUS_CHANNEL			*Channel
+	);
+
+
+static void
+VmbusChannelSetEvent(
+	VMBUS_CHANNEL			*Channel
+	);
+
+
+#if 0
+static void
+DumpMonitorPage(
+	HV_MONITOR_PAGE *MonitorPage
+	)
+{
+	int i=0;
+	int j=0;
+
+	DPRINT_DBG(VMBUS, "monitorPage - %p, trigger state - %d", MonitorPage, MonitorPage->TriggerState);
+
+	for (i=0; i<4; i++)
+	{
+		DPRINT_DBG(VMBUS, "trigger group (%d) - %llx", i, MonitorPage->TriggerGroup[i].AsUINT64);
+	}
+
+	for (i=0; i<4; i++)
+	{
+		for (j=0; j<32; j++)
+		{
+			DPRINT_DBG(VMBUS, "latency (%d)(%d) - %llx", i, j, MonitorPage->Latency[i][j]);
+		}
+	}
+	for (i=0; i<4; i++)
+	{
+		for (j=0; j<32; j++)
+		{
+			DPRINT_DBG(VMBUS, "param-conn id (%d)(%d) - %d", i, j, MonitorPage->Parameter[i][j].ConnectionId.AsUINT32);
+			DPRINT_DBG(VMBUS, "param-flag (%d)(%d) - %d", i, j, MonitorPage->Parameter[i][j].FlagNumber);
+
+		}
+	}
+}
+#endif
+
+/*++
+
+Name:
+	VmbusChannelSetEvent()
+
+Description:
+	Trigger an event notification on the specified channel.
+
+--*/
+static void
+VmbusChannelSetEvent(
+	VMBUS_CHANNEL			*Channel
+	)
+{
+	HV_MONITOR_PAGE *monitorPage;
+
+	DPRINT_ENTER(VMBUS);
+
+	if (Channel->OfferMsg.MonitorAllocated)
+	{
+		// Each UINT32 represents 32 channels
+		BitSet((UINT32*)gVmbusConnection.SendInterruptPage + (Channel->OfferMsg.ChildRelId >> 5), Channel->OfferMsg.ChildRelId & 31);
+
+		monitorPage = (HV_MONITOR_PAGE*)gVmbusConnection.MonitorPages;
+		monitorPage++; // Get the child to parent monitor page
+
+		BitSet((UINT32*) &monitorPage->TriggerGroup[Channel->MonitorGroup].Pending, Channel->MonitorBit);
+	}
+	else
+	{
+		VmbusSetEvent(Channel->OfferMsg.ChildRelId);
+	}
+
+	DPRINT_EXIT(VMBUS);
+}
+
+#if 0
+static void
+VmbusChannelClearEvent(
+	VMBUS_CHANNEL			*Channel
+	)
+{
+	HV_MONITOR_PAGE *monitorPage;
+
+	DPRINT_ENTER(VMBUS);
+
+	if (Channel->OfferMsg.MonitorAllocated)
+	{
+		// Each UINT32 represents 32 channels
+		BitClear((UINT32*)gVmbusConnection.SendInterruptPage + (Channel->OfferMsg.ChildRelId >> 5), Channel->OfferMsg.ChildRelId & 31);
+
+		monitorPage = (HV_MONITOR_PAGE*)gVmbusConnection.MonitorPages;
+		monitorPage++; // Get the child to parent monitor page
+
+		BitClear((UINT32*) &monitorPage->TriggerGroup[Channel->MonitorGroup].Pending, Channel->MonitorBit);
+	}
+
+	DPRINT_EXIT(VMBUS);
+}
+
+#endif
+/*++;
+
+Name:
+	VmbusChannelGetDebugInfo()
+
+Description:
+	Retrieve various channel debug info
+
+--*/
+void
+VmbusChannelGetDebugInfo(
+	VMBUS_CHANNEL				*Channel,
+	VMBUS_CHANNEL_DEBUG_INFO	*DebugInfo
+	)
+{
+	HV_MONITOR_PAGE *monitorPage;
+    UINT8 monitorGroup    = (UINT8)Channel->OfferMsg.MonitorId / 32;
+    UINT8 monitorOffset   = (UINT8)Channel->OfferMsg.MonitorId % 32;
+	//UINT32 monitorBit	= 1 << monitorOffset;
+
+	DebugInfo->RelId = Channel->OfferMsg.ChildRelId;
+	DebugInfo->State = Channel->State;
+	memcpy(&DebugInfo->InterfaceType, &Channel->OfferMsg.Offer.InterfaceType, sizeof(GUID));
+	memcpy(&DebugInfo->InterfaceInstance, &Channel->OfferMsg.Offer.InterfaceInstance, sizeof(GUID));
+
+	monitorPage = (HV_MONITOR_PAGE*)gVmbusConnection.MonitorPages;
+
+	DebugInfo->MonitorId = Channel->OfferMsg.MonitorId;
+
+	DebugInfo->ServerMonitorPending = monitorPage->TriggerGroup[monitorGroup].Pending;
+	DebugInfo->ServerMonitorLatency = monitorPage->Latency[monitorGroup][ monitorOffset];
+	DebugInfo->ServerMonitorConnectionId = monitorPage->Parameter[monitorGroup][ monitorOffset].ConnectionId.u.Id;
+
+	monitorPage++;
+
+	DebugInfo->ClientMonitorPending = monitorPage->TriggerGroup[monitorGroup].Pending;
+	DebugInfo->ClientMonitorLatency = monitorPage->Latency[monitorGroup][ monitorOffset];
+	DebugInfo->ClientMonitorConnectionId = monitorPage->Parameter[monitorGroup][ monitorOffset].ConnectionId.u.Id;
+
+	RingBufferGetDebugInfo(&Channel->Inbound, &DebugInfo->Inbound);
+	RingBufferGetDebugInfo(&Channel->Outbound, &DebugInfo->Outbound);
+}
+
+
+/*++;
+
+Name:
+	VmbusChannelOpen()
+
+Description:
+	Open the specified channel.
+
+--*/
+int
+VmbusChannelOpen(
+	VMBUS_CHANNEL			*NewChannel,
+	UINT32					SendRingBufferSize,
+	UINT32					RecvRingBufferSize,
+	PVOID					UserData,
+	UINT32					UserDataLen,
+	PFN_CHANNEL_CALLBACK	pfnOnChannelCallback,
+	PVOID					Context
+	)
+{
+	int ret=0;
+	VMBUS_CHANNEL_OPEN_CHANNEL* openMsg;
+	VMBUS_CHANNEL_MSGINFO* openInfo;
+	void *in, *out;
+
+	DPRINT_ENTER(VMBUS);
+
+	// Aligned to page size
+	ASSERT(!(SendRingBufferSize & (PAGE_SIZE -1)));
+	ASSERT(!(RecvRingBufferSize & (PAGE_SIZE -1)));
+
+	NewChannel->OnChannelCallback = pfnOnChannelCallback;
+	NewChannel->ChannelCallbackContext = Context;
+
+	// Allocate the ring buffer
+	out = PageAlloc((SendRingBufferSize + RecvRingBufferSize) >> PAGE_SHIFT);
+	//out = MemAllocZeroed(sendRingBufferSize + recvRingBufferSize);
+	ASSERT(out);
+	ASSERT(((ULONG_PTR)out & (PAGE_SIZE-1)) == 0);
+
+	in = (void*)((ULONG_PTR)out + SendRingBufferSize);
+
+	NewChannel->RingBufferPages = out;
+	NewChannel->RingBufferPageCount = (SendRingBufferSize + RecvRingBufferSize) >> PAGE_SHIFT;
+
+	RingBufferInit(&NewChannel->Outbound, out, SendRingBufferSize);
+
+	RingBufferInit(&NewChannel->Inbound, in, RecvRingBufferSize);
+
+	// Establish the gpadl for the ring buffer
+	DPRINT_DBG(VMBUS, "Establishing ring buffer's gpadl for channel %p...", NewChannel);
+
+	NewChannel->RingBufferGpadlHandle = 0;
+
+	ret = VmbusChannelEstablishGpadl(NewChannel,
+		NewChannel->Outbound.RingBuffer,
+		SendRingBufferSize + RecvRingBufferSize,
+		&NewChannel->RingBufferGpadlHandle);
+
+	DPRINT_DBG(VMBUS, "channel %p <relid %d gpadl 0x%x send ring %p size %d recv ring %p size %d, downstreamoffset %d>",
+		NewChannel,
+		NewChannel->OfferMsg.ChildRelId,
+		NewChannel->RingBufferGpadlHandle,
+		NewChannel->Outbound.RingBuffer,
+		NewChannel->Outbound.RingSize,
+		NewChannel->Inbound.RingBuffer,
+		NewChannel->Inbound.RingSize,
+		SendRingBufferSize);
+
+	// Create and init the channel open message
+	openInfo =
+		(VMBUS_CHANNEL_MSGINFO*)MemAlloc(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_OPEN_CHANNEL));
+	ASSERT(openInfo != NULL);
+
+	openInfo->WaitEvent = WaitEventCreate();
+
+	openMsg = (VMBUS_CHANNEL_OPEN_CHANNEL*)openInfo->Msg;
+	openMsg->Header.MessageType				= ChannelMessageOpenChannel;
+	openMsg->OpenId							= NewChannel->OfferMsg.ChildRelId; // FIXME
+    openMsg->ChildRelId						= NewChannel->OfferMsg.ChildRelId;
+    openMsg->RingBufferGpadlHandle			= NewChannel->RingBufferGpadlHandle;
+    ASSERT(openMsg->RingBufferGpadlHandle);
+    openMsg->DownstreamRingBufferPageOffset		= SendRingBufferSize >> PAGE_SHIFT;
+    openMsg->ServerContextAreaGpadlHandle	= 0; // TODO
+
+	ASSERT(UserDataLen <= MAX_USER_DEFINED_BYTES);
+	if (UserDataLen)
+	{
+		memcpy(openMsg->UserData, UserData, UserDataLen);
+	}
+
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+	INSERT_TAIL_LIST(&gVmbusConnection.ChannelMsgList, &openInfo->MsgListEntry);
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	DPRINT_DBG(VMBUS, "Sending channel open msg...");
+
+	ret = VmbusPostMessage(openMsg, sizeof(VMBUS_CHANNEL_OPEN_CHANNEL));
+	if (ret != 0)
+	{
+		DPRINT_ERR(VMBUS, "unable to open channel - %d", ret);
+		goto Cleanup;
+	}
+
+	// FIXME: Need to time-out here
+	WaitEventWait(openInfo->WaitEvent);
+
+	if (openInfo->Response.OpenResult.Status == 0)
+	{
+		DPRINT_INFO(VMBUS, "channel <%p> open success!!", NewChannel);
+	}
+	else
+	{
+		DPRINT_INFO(VMBUS, "channel <%p> open failed - %d!!", NewChannel, openInfo->Response.OpenResult.Status);
+	}
+
+Cleanup:
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+	REMOVE_ENTRY_LIST(&openInfo->MsgListEntry);
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	WaitEventClose(openInfo->WaitEvent);
+	MemFree(openInfo);
+
+	DPRINT_EXIT(VMBUS);
+
+	return 0;
+}
+
+/*++;
+
+Name:
+	DumpGpadlBody()
+
+Description:
+	Dump the gpadl body message to the console for debugging purposes.
+
+--*/
+static void DumpGpadlBody(
+	VMBUS_CHANNEL_GPADL_BODY	*Gpadl,
+	UINT32						Len)
+{
+	int i=0;
+	int pfnCount=0;
+
+	pfnCount = (Len - sizeof(VMBUS_CHANNEL_GPADL_BODY))/ sizeof(UINT64);
+	DPRINT_DBG(VMBUS, "gpadl body - len %d pfn count %d", Len, pfnCount);
+
+	for (i=0; i< pfnCount; i++)
+	{
+		DPRINT_DBG(VMBUS, "gpadl body  - %d) pfn %llu", i, Gpadl->Pfn[i]);
+	}
+}
+
+
+/*++;
+
+Name:
+	DumpGpadlHeader()
+
+Description:
+	Dump the gpadl header message to the console for debugging purposes.
+
+--*/
+static void DumpGpadlHeader(
+	VMBUS_CHANNEL_GPADL_HEADER	*Gpadl
+	)
+{
+	int i=0,j=0;
+	int pageCount=0;
+
+
+	DPRINT_DBG(VMBUS, "gpadl header - relid %d, range count %d, range buflen %d",
+				Gpadl->ChildRelId,
+				Gpadl->RangeCount,
+				Gpadl->RangeBufLen);
+	for (i=0; i< Gpadl->RangeCount; i++)
+	{
+		pageCount = Gpadl->Range[i].ByteCount >> PAGE_SHIFT;
+		pageCount = (pageCount > 26)? 26 : pageCount;
+
+		DPRINT_DBG(VMBUS, "gpadl range %d - len %d offset %d page count %d",
+			i, Gpadl->Range[i].ByteCount, Gpadl->Range[i].ByteOffset, pageCount);
+
+		for (j=0; j< pageCount; j++)
+		{
+			DPRINT_DBG(VMBUS, "%d) pfn %llu", j, Gpadl->Range[i].PfnArray[j]);
+		}
+	}
+}
+
+/*++;
+
+Name:
+	VmbusChannelCreateGpadlHeader()
+
+Description:
+	Creates a gpadl for the specified buffer
+
+--*/
+static int
+VmbusChannelCreateGpadlHeader(
+	PVOID					Kbuffer,	// from kmalloc()
+	UINT32					Size,		// page-size multiple
+	VMBUS_CHANNEL_MSGINFO	**MsgInfo,
+	UINT32					*MessageCount)
+{
+	int i;
+	int pageCount;
+    unsigned long long pfn;
+	VMBUS_CHANNEL_GPADL_HEADER* gpaHeader;
+	VMBUS_CHANNEL_GPADL_BODY* gpadlBody;
+	VMBUS_CHANNEL_MSGINFO* msgHeader;
+	VMBUS_CHANNEL_MSGINFO* msgBody;
+	UINT32				msgSize;
+
+	int pfnSum, pfnCount, pfnLeft, pfnCurr, pfnSize;
+
+	//ASSERT( (kbuffer & (PAGE_SIZE-1)) == 0);
+	ASSERT( (Size & (PAGE_SIZE-1)) == 0);
+
+	pageCount = Size >> PAGE_SHIFT;
+	pfn = GetPhysicalAddress(Kbuffer) >> PAGE_SHIFT;
+
+	// do we need a gpadl body msg
+	pfnSize = MAX_SIZE_CHANNEL_MESSAGE - sizeof(VMBUS_CHANNEL_GPADL_HEADER) - sizeof(GPA_RANGE);
+	pfnCount = pfnSize / sizeof(UINT64);
+
+	if (pageCount > pfnCount) // we need a gpadl body
+	{
+		// fill in the header
+		msgSize = sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_GPADL_HEADER) + sizeof(GPA_RANGE) + pfnCount*sizeof(UINT64);
+		msgHeader =  MemAllocZeroed(msgSize);
+
+		INITIALIZE_LIST_HEAD(&msgHeader->SubMsgList);
+		msgHeader->MessageSize=msgSize;
+
+		gpaHeader = (VMBUS_CHANNEL_GPADL_HEADER*)msgHeader->Msg;
+		gpaHeader->RangeCount = 1;
+		gpaHeader->RangeBufLen = sizeof(GPA_RANGE) + pageCount*sizeof(UINT64);
+		gpaHeader->Range[0].ByteOffset = 0;
+		gpaHeader->Range[0].ByteCount = Size;
+		for (i=0; i<pfnCount; i++)
+		{
+			gpaHeader->Range[0].PfnArray[i] = pfn+i;
+		}
+		*MsgInfo = msgHeader;
+		*MessageCount = 1;
+
+		pfnSum = pfnCount;
+		pfnLeft = pageCount - pfnCount;
+
+		// how many pfns can we fit
+		pfnSize = MAX_SIZE_CHANNEL_MESSAGE - sizeof(VMBUS_CHANNEL_GPADL_BODY);
+		pfnCount = pfnSize / sizeof(UINT64);
+
+		// fill in the body
+		while (pfnLeft)
+		{
+			if (pfnLeft > pfnCount)
+			{
+				pfnCurr = pfnCount;
+			}
+			else
+			{
+				pfnCurr = pfnLeft;
+			}
+
+			msgSize = sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_GPADL_BODY) + pfnCurr*sizeof(UINT64);
+			msgBody =  MemAllocZeroed(msgSize);
+			ASSERT(msgBody);
+			msgBody->MessageSize = msgSize;
+			(*MessageCount)++;
+			gpadlBody = (VMBUS_CHANNEL_GPADL_BODY*)msgBody->Msg;
+
+			// FIXME: Gpadl is UINT32 and we are using a pointer which could be 64-bit
+			//gpadlBody->Gpadl = kbuffer;
+			for (i=0; i<pfnCurr; i++)
+			{
+				gpadlBody->Pfn[i] = pfn + pfnSum + i;
+			}
+
+			// add to msg header
+			INSERT_TAIL_LIST(&msgHeader->SubMsgList, &msgBody->MsgListEntry);
+			pfnSum += pfnCurr;
+			pfnLeft -= pfnCurr;
+		}
+	}
+	else
+	{
+		// everything fits in a header
+		msgSize = sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_GPADL_HEADER) + sizeof(GPA_RANGE) + pageCount*sizeof(UINT64);
+		msgHeader =  MemAllocZeroed(msgSize);
+		msgHeader->MessageSize=msgSize;
+
+		gpaHeader = (VMBUS_CHANNEL_GPADL_HEADER*)msgHeader->Msg;
+		gpaHeader->RangeCount = 1;
+		gpaHeader->RangeBufLen = sizeof(GPA_RANGE) + pageCount*sizeof(UINT64);
+		gpaHeader->Range[0].ByteOffset = 0;
+		gpaHeader->Range[0].ByteCount = Size;
+		for (i=0; i<pageCount; i++)
+		{
+			gpaHeader->Range[0].PfnArray[i] = pfn+i;
+		}
+
+		*MsgInfo = msgHeader;
+		*MessageCount = 1;
+	}
+
+	return 0;
+}
+
+
+/*++;
+
+Name:
+	VmbusChannelEstablishGpadl()
+
+Description:
+	Estabish a GPADL for the specified buffer
+
+--*/
+int
+VmbusChannelEstablishGpadl(
+	VMBUS_CHANNEL	*Channel,
+	PVOID			Kbuffer,	// from kmalloc()
+	UINT32			Size,		// page-size multiple
+	UINT32			*GpadlHandle
+	)
+{
+	int ret=0;
+	VMBUS_CHANNEL_GPADL_HEADER* gpadlMsg;
+	VMBUS_CHANNEL_GPADL_BODY* gpadlBody;
+	//VMBUS_CHANNEL_GPADL_CREATED* gpadlCreated;
+
+	VMBUS_CHANNEL_MSGINFO *msgInfo;
+	VMBUS_CHANNEL_MSGINFO *subMsgInfo;
+
+	UINT32 msgCount;
+	LIST_ENTRY* anchor;
+	LIST_ENTRY* curr;
+	UINT32 nextGpadlHandle;
+
+	DPRINT_ENTER(VMBUS);
+
+	nextGpadlHandle = gVmbusConnection.NextGpadlHandle;
+	InterlockedIncrement((int*)&gVmbusConnection.NextGpadlHandle);
+
+	VmbusChannelCreateGpadlHeader(Kbuffer, Size, &msgInfo, &msgCount);
+	ASSERT(msgInfo != NULL);
+	ASSERT(msgCount >0);
+
+	msgInfo->WaitEvent = WaitEventCreate();
+	gpadlMsg = (VMBUS_CHANNEL_GPADL_HEADER*)msgInfo->Msg;
+	gpadlMsg->Header.MessageType = ChannelMessageGpadlHeader;
+	gpadlMsg->ChildRelId = Channel->OfferMsg.ChildRelId;
+	gpadlMsg->Gpadl = nextGpadlHandle;
+
+	DumpGpadlHeader(gpadlMsg);
+
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+	INSERT_TAIL_LIST(&gVmbusConnection.ChannelMsgList, &msgInfo->MsgListEntry);
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	DPRINT_DBG(VMBUS, "buffer %p, size %d msg cnt %d", Kbuffer, Size, msgCount);
+
+	DPRINT_DBG(VMBUS, "Sending GPADL Header - len %d", msgInfo->MessageSize - sizeof(VMBUS_CHANNEL_MSGINFO));
+
+	ret = VmbusPostMessage(gpadlMsg, msgInfo->MessageSize - sizeof(VMBUS_CHANNEL_MSGINFO));
+	if (ret != 0)
+	{
+		DPRINT_ERR(VMBUS, "Unable to open channel - %d", ret);
+		goto Cleanup;
+	}
+
+	if (msgCount>1)
+	{
+		ITERATE_LIST_ENTRIES(anchor, curr, &msgInfo->SubMsgList)
+		{
+			subMsgInfo = (VMBUS_CHANNEL_MSGINFO*) curr;
+			gpadlBody = (VMBUS_CHANNEL_GPADL_BODY*)subMsgInfo->Msg;
+
+			gpadlBody->Header.MessageType = ChannelMessageGpadlBody;
+			gpadlBody->Gpadl = nextGpadlHandle;
+
+			DPRINT_DBG(VMBUS, "Sending GPADL Body - len %d", subMsgInfo->MessageSize - sizeof(VMBUS_CHANNEL_MSGINFO));
+
+			DumpGpadlBody(gpadlBody, subMsgInfo->MessageSize - sizeof(VMBUS_CHANNEL_MSGINFO));
+			ret = VmbusPostMessage(gpadlBody, subMsgInfo->MessageSize - sizeof(VMBUS_CHANNEL_MSGINFO));
+			ASSERT(ret == 0);
+		}
+	}
+	WaitEventWait(msgInfo->WaitEvent);
+
+	// At this point, we received the gpadl created msg
+	DPRINT_DBG(VMBUS, "Received GPADL created (relid %d, status %d handle %x)",
+		Channel->OfferMsg.ChildRelId,
+		msgInfo->Response.GpadlCreated.CreationStatus,
+		gpadlMsg->Gpadl);
+
+	*GpadlHandle = gpadlMsg->Gpadl;
+
+Cleanup:
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+	REMOVE_ENTRY_LIST(&msgInfo->MsgListEntry);
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	WaitEventClose(msgInfo->WaitEvent);
+	MemFree(msgInfo);
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+
+/*++;
+
+Name:
+	VmbusChannelTeardownGpadl()
+
+Description:
+	Teardown the specified GPADL handle
+
+--*/
+int
+VmbusChannelTeardownGpadl(
+	VMBUS_CHANNEL	*Channel,
+	UINT32			GpadlHandle
+	)
+{
+	int ret=0;
+	VMBUS_CHANNEL_GPADL_TEARDOWN *msg;
+	VMBUS_CHANNEL_MSGINFO* info;
+
+	DPRINT_ENTER(VMBUS);
+
+	ASSERT(GpadlHandle != 0);
+
+	info =
+		(VMBUS_CHANNEL_MSGINFO*)MemAlloc(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_GPADL_TEARDOWN));
+	ASSERT(info != NULL);
+
+	info->WaitEvent = WaitEventCreate();
+
+	msg = (VMBUS_CHANNEL_GPADL_TEARDOWN*)info->Msg;
+
+	msg->Header.MessageType = ChannelMessageGpadlTeardown;
+    msg->ChildRelId  = Channel->OfferMsg.ChildRelId;
+    msg->Gpadl       = GpadlHandle;
+
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+	INSERT_TAIL_LIST(&gVmbusConnection.ChannelMsgList, &info->MsgListEntry);
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_GPADL_TEARDOWN));
+	if (ret != 0)
+	{
+		// TODO:
+	}
+
+	WaitEventWait(info->WaitEvent);
+
+	// Received a torndown response
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+	REMOVE_ENTRY_LIST(&info->MsgListEntry);
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	WaitEventClose(info->WaitEvent);
+	MemFree(info);
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+/*++
+
+Name:
+	VmbusChannelClose()
+
+Description:
+	Close the specified channel
+
+--*/
+VOID
+VmbusChannelClose(
+	VMBUS_CHANNEL	*Channel
+	)
+{
+	int ret=0;
+	VMBUS_CHANNEL_CLOSE_CHANNEL* msg;
+	VMBUS_CHANNEL_MSGINFO* info;
+
+	DPRINT_ENTER(VMBUS);
+
+	// Stop callback and cancel the timer asap
+	Channel->OnChannelCallback = NULL;
+	TimerStop(Channel->PollTimer);
+
+	// Send a closing message
+	info =
+		(VMBUS_CHANNEL_MSGINFO*)MemAlloc(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_CLOSE_CHANNEL));
+	ASSERT(info != NULL);
+
+	//info->waitEvent = WaitEventCreate();
+
+	msg = (VMBUS_CHANNEL_CLOSE_CHANNEL*)info->Msg;
+	msg->Header.MessageType				= ChannelMessageCloseChannel;
+    msg->ChildRelId						= Channel->OfferMsg.ChildRelId;
+
+	ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_CLOSE_CHANNEL));
+	if (ret != 0)
+	{
+		// TODO:
+	}
+
+	// Tear down the gpadl for the channel's ring buffer
+	if (Channel->RingBufferGpadlHandle)
+	{
+		VmbusChannelTeardownGpadl(Channel, Channel->RingBufferGpadlHandle);
+	}
+
+	// TODO: Send a msg to release the childRelId
+
+	// Cleanup the ring buffers for this channel
+	RingBufferCleanup(&Channel->Outbound);
+	RingBufferCleanup(&Channel->Inbound);
+
+	PageFree(Channel->RingBufferPages, Channel->RingBufferPageCount);
+
+	MemFree(info);
+
+	// If we are closing the channel during an error path in opening the channel, don't free the channel
+	// since the caller will free the channel
+	if (Channel->State == CHANNEL_OPEN_STATE)
+	{
+		SpinlockAcquire(gVmbusConnection.ChannelLock);
+		REMOVE_ENTRY_LIST(&Channel->ListEntry);
+		SpinlockRelease(gVmbusConnection.ChannelLock);
+
+		FreeVmbusChannel(Channel);
+	}
+
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusChannelSendPacket()
+
+Description:
+	Send the specified buffer on the given channel
+
+--*/
+int
+VmbusChannelSendPacket(
+	VMBUS_CHANNEL		*Channel,
+	const PVOID			Buffer,
+	UINT32				BufferLen,
+	UINT64				RequestId,
+	VMBUS_PACKET_TYPE	Type,
+	UINT32				Flags
+)
+{
+	int ret=0;
+	VMPACKET_DESCRIPTOR desc;
+	UINT32 packetLen = sizeof(VMPACKET_DESCRIPTOR) + BufferLen;
+	UINT32 packetLenAligned = ALIGN_UP(packetLen, sizeof(UINT64));
+	SG_BUFFER_LIST bufferList[3];
+	UINT64 alignedData=0;
+
+	DPRINT_ENTER(VMBUS);
+	DPRINT_DBG(VMBUS, "channel %p buffer %p len %d", Channel, Buffer, BufferLen);
+
+	DumpVmbusChannel(Channel);
+
+	ASSERT((packetLenAligned - packetLen) < sizeof(UINT64));
+
+	// Setup the descriptor
+	desc.Type = Type;//VmbusPacketTypeDataInBand;
+	desc.Flags = Flags;//VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
+    desc.DataOffset8 = sizeof(VMPACKET_DESCRIPTOR) >> 3; // in 8-bytes granularity
+    desc.Length8 = (UINT16)(packetLenAligned >> 3);
+    desc.TransactionId = RequestId;
+
+	bufferList[0].Data = &desc;
+	bufferList[0].Length = sizeof(VMPACKET_DESCRIPTOR);
+
+	bufferList[1].Data = Buffer;
+	bufferList[1].Length = BufferLen;
+
+	bufferList[2].Data = &alignedData;
+	bufferList[2].Length = packetLenAligned - packetLen;
+
+	ret = RingBufferWrite(
+		&Channel->Outbound,
+		bufferList,
+		3);
+
+	// TODO: We should determine if this is optional
+	if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
+	{
+		VmbusChannelSetEvent(Channel);
+	}
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+/*++
+
+Name:
+	VmbusChannelSendPacketPageBuffer()
+
+Description:
+	Send a range of single-page buffer packets using a GPADL Direct packet type.
+
+--*/
+int
+VmbusChannelSendPacketPageBuffer(
+	VMBUS_CHANNEL		*Channel,
+	PAGE_BUFFER			PageBuffers[],
+	UINT32				PageCount,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT64				RequestId
+)
+{
+	int ret=0;
+	int i=0;
+	VMBUS_CHANNEL_PACKET_PAGE_BUFFER desc;
+	UINT32 descSize;
+	UINT32 packetLen;
+	UINT32 packetLenAligned;
+	SG_BUFFER_LIST bufferList[3];
+	UINT64 alignedData=0;
+
+	DPRINT_ENTER(VMBUS);
+
+	ASSERT(PageCount <= MAX_PAGE_BUFFER_COUNT);
+
+	DumpVmbusChannel(Channel);
+
+	// Adjust the size down since VMBUS_CHANNEL_PACKET_PAGE_BUFFER is the largest size we support
+	descSize = sizeof(VMBUS_CHANNEL_PACKET_PAGE_BUFFER) - ((MAX_PAGE_BUFFER_COUNT - PageCount)*sizeof(PAGE_BUFFER));
+	packetLen = descSize + BufferLen;
+	packetLenAligned = ALIGN_UP(packetLen, sizeof(UINT64));
+
+	ASSERT((packetLenAligned - packetLen) < sizeof(UINT64));
+
+	// Setup the descriptor
+	desc.Type = VmbusPacketTypeDataUsingGpaDirect;
+	desc.Flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
+    desc.DataOffset8 = descSize >> 3; // in 8-bytes grandularity
+    desc.Length8 = (UINT16)(packetLenAligned >> 3);
+    desc.TransactionId = RequestId;
+	desc.RangeCount = PageCount;
+
+	for (i=0; i<PageCount; i++)
+	{
+		desc.Range[i].Length = PageBuffers[i].Length;
+		desc.Range[i].Offset = PageBuffers[i].Offset;
+		desc.Range[i].Pfn	 = PageBuffers[i].Pfn;
+	}
+
+	bufferList[0].Data = &desc;
+	bufferList[0].Length = descSize;
+
+	bufferList[1].Data = Buffer;
+	bufferList[1].Length = BufferLen;
+
+	bufferList[2].Data = &alignedData;
+	bufferList[2].Length = packetLenAligned - packetLen;
+
+	ret = RingBufferWrite(
+		&Channel->Outbound,
+		bufferList,
+		3);
+
+	// TODO: We should determine if this is optional
+	if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
+	{
+		VmbusChannelSetEvent(Channel);
+	}
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+
+/*++
+
+Name:
+	VmbusChannelSendPacketMultiPageBuffer()
+
+Description:
+	Send a multi-page buffer packet using a GPADL Direct packet type.
+
+--*/
+int
+VmbusChannelSendPacketMultiPageBuffer(
+	VMBUS_CHANNEL		*Channel,
+	MULTIPAGE_BUFFER	*MultiPageBuffer,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT64				RequestId
+)
+{
+	int ret=0;
+	VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER desc;
+	UINT32 descSize;
+	UINT32 packetLen;
+	UINT32 packetLenAligned;
+	SG_BUFFER_LIST bufferList[3];
+	UINT64 alignedData=0;
+	UINT32 PfnCount = NUM_PAGES_SPANNED(MultiPageBuffer->Offset, MultiPageBuffer->Length);
+
+	DPRINT_ENTER(VMBUS);
+
+	DumpVmbusChannel(Channel);
+
+	DPRINT_DBG(VMBUS, "data buffer - offset %u len %u pfn count %u", MultiPageBuffer->Offset, MultiPageBuffer->Length, PfnCount);
+
+	ASSERT(PfnCount > 0);
+	ASSERT(PfnCount <= MAX_MULTIPAGE_BUFFER_COUNT);
+
+	// Adjust the size down since VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER is the largest size we support
+	descSize = sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER) - ((MAX_MULTIPAGE_BUFFER_COUNT - PfnCount)*sizeof(UINT64));
+	packetLen = descSize + BufferLen;
+	packetLenAligned = ALIGN_UP(packetLen, sizeof(UINT64));
+
+	ASSERT((packetLenAligned - packetLen) < sizeof(UINT64));
+
+	// Setup the descriptor
+	desc.Type = VmbusPacketTypeDataUsingGpaDirect;
+	desc.Flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
+    desc.DataOffset8 = descSize >> 3; // in 8-bytes grandularity
+    desc.Length8 = (UINT16)(packetLenAligned >> 3);
+    desc.TransactionId = RequestId;
+	desc.RangeCount = 1;
+
+	desc.Range.Length = MultiPageBuffer->Length;
+	desc.Range.Offset = MultiPageBuffer->Offset;
+
+	memcpy(desc.Range.PfnArray, MultiPageBuffer->PfnArray, PfnCount*sizeof(UINT64));
+
+	bufferList[0].Data = &desc;
+	bufferList[0].Length = descSize;
+
+	bufferList[1].Data = Buffer;
+	bufferList[1].Length = BufferLen;
+
+	bufferList[2].Data = &alignedData;
+	bufferList[2].Length = packetLenAligned - packetLen;
+
+	ret = RingBufferWrite(
+		&Channel->Outbound,
+		bufferList,
+		3);
+
+	// TODO: We should determine if this is optional
+	if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
+	{
+		VmbusChannelSetEvent(Channel);
+	}
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+/*++
+
+Name:
+	VmbusChannelRecvPacket()
+
+Description:
+	Retrieve the user packet on the specified channel
+
+--*/
+// TODO: Do we ever receive a gpa direct packet other than the ones we send ?
+int
+VmbusChannelRecvPacket(
+	VMBUS_CHANNEL		*Channel,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT32*				BufferActualLen,
+	UINT64*				RequestId
+	)
+{
+	VMPACKET_DESCRIPTOR desc;
+	UINT32 packetLen;
+	UINT32 userLen;
+	int ret;
+
+	DPRINT_ENTER(VMBUS);
+
+	*BufferActualLen = 0;
+	*RequestId = 0;
+
+	SpinlockAcquire(Channel->InboundLock);
+
+	ret = RingBufferPeek(&Channel->Inbound, &desc, sizeof(VMPACKET_DESCRIPTOR));
+	if (ret != 0)
+	{
+		SpinlockRelease(Channel->InboundLock);
+
+		//DPRINT_DBG(VMBUS, "nothing to read!!");
+		DPRINT_EXIT(VMBUS);
+		return 0;
+	}
+
+	//VmbusChannelClearEvent(Channel);
+
+	packetLen = desc.Length8 << 3;
+	userLen = packetLen - (desc.DataOffset8 << 3);
+	//ASSERT(userLen > 0);
+
+	DPRINT_DBG(VMBUS, "packet received on channel %p relid %d <type %d flag %d tid %llx pktlen %d datalen %d> ",
+		Channel,
+		Channel->OfferMsg.ChildRelId,
+		desc.Type,
+		desc.Flags,
+		desc.TransactionId, packetLen, userLen);
+
+	*BufferActualLen = userLen;
+
+	if (userLen > BufferLen)
+	{
+		SpinlockRelease(Channel->InboundLock);
+
+		DPRINT_ERR(VMBUS, "buffer too small - got %d needs %d", BufferLen, userLen);
+		DPRINT_EXIT(VMBUS);
+
+		return -1;
+	}
+
+	*RequestId = desc.TransactionId;
+
+	// Copy over the packet to the user buffer
+	ret = RingBufferRead(&Channel->Inbound, Buffer, userLen, (desc.DataOffset8 << 3));
+
+	SpinlockRelease(Channel->InboundLock);
+
+	DPRINT_EXIT(VMBUS);
+
+	return 0;
+}
+
+/*++
+
+Name:
+	VmbusChannelRecvPacketRaw()
+
+Description:
+	Retrieve the raw packet on the specified channel
+
+--*/
+int
+VmbusChannelRecvPacketRaw(
+	VMBUS_CHANNEL		*Channel,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT32*				BufferActualLen,
+	UINT64*				RequestId
+	)
+{
+	VMPACKET_DESCRIPTOR desc;
+	UINT32 packetLen;
+	UINT32 userLen;
+	int ret;
+
+	DPRINT_ENTER(VMBUS);
+
+	*BufferActualLen = 0;
+	*RequestId = 0;
+
+	SpinlockAcquire(Channel->InboundLock);
+
+	ret = RingBufferPeek(&Channel->Inbound, &desc, sizeof(VMPACKET_DESCRIPTOR));
+	if (ret != 0)
+	{
+		SpinlockRelease(Channel->InboundLock);
+
+		//DPRINT_DBG(VMBUS, "nothing to read!!");
+		DPRINT_EXIT(VMBUS);
+		return 0;
+	}
+
+	//VmbusChannelClearEvent(Channel);
+
+	packetLen = desc.Length8 << 3;
+	userLen = packetLen - (desc.DataOffset8 << 3);
+
+	DPRINT_DBG(VMBUS, "packet received on channel %p relid %d <type %d flag %d tid %llx pktlen %d datalen %d> ",
+		Channel,
+		Channel->OfferMsg.ChildRelId,
+		desc.Type,
+		desc.Flags,
+		desc.TransactionId, packetLen, userLen);
+
+	*BufferActualLen = packetLen;
+
+	if (packetLen > BufferLen)
+	{
+		SpinlockRelease(Channel->InboundLock);
+
+		DPRINT_ERR(VMBUS, "buffer too small - needed %d bytes but got space for only %d bytes", packetLen, BufferLen);
+		DPRINT_EXIT(VMBUS);
+		return -2;
+	}
+
+	*RequestId = desc.TransactionId;
+
+	// Copy over the entire packet to the user buffer
+	ret = RingBufferRead(&Channel->Inbound, Buffer, packetLen, 0);
+
+	SpinlockRelease(Channel->InboundLock);
+
+	DPRINT_EXIT(VMBUS);
+
+	return 0;
+}
+
+
+/*++
+
+Name:
+	VmbusChannelOnChannelEvent()
+
+Description:
+	Channel event callback
+
+--*/
+void
+VmbusChannelOnChannelEvent(
+	VMBUS_CHANNEL		*Channel
+	)
+{
+	DumpVmbusChannel(Channel);
+	ASSERT(Channel->OnChannelCallback);
+#ifdef ENABLE_POLLING
+	TimerStop(Channel->PollTimer);
+	Channel->OnChannelCallback(Channel->ChannelCallbackContext);
+	TimerStart(Channel->PollTimer, 100 /* 100us */);
+#else
+	Channel->OnChannelCallback(Channel->ChannelCallbackContext);
+#endif
+}
+
+/*++
+
+Name:
+	VmbusChannelOnTimer()
+
+Description:
+	Timer event callback
+
+--*/
+void
+VmbusChannelOnTimer(
+	void		*Context
+	)
+{
+	VMBUS_CHANNEL *channel = (VMBUS_CHANNEL*)Context;
+
+	if (channel->OnChannelCallback)
+	{
+		channel->OnChannelCallback(channel->ChannelCallbackContext);
+#ifdef ENABLE_POLLING
+		TimerStart(channel->PollTimer, 100 /* 100us */);
+#endif
+	}
+}
+
+
+/*++
+
+Name:
+	DumpVmbusChannel()
+
+Description:
+	Dump vmbus channel info to the console
+
+--*/
+static void
+DumpVmbusChannel(
+	VMBUS_CHANNEL		*Channel
+	)
+{
+	DPRINT_DBG(VMBUS, "Channel (%d)", Channel->OfferMsg.ChildRelId);
+	DumpRingInfo(&Channel->Outbound, "Outbound ");
+	DumpRingInfo(&Channel->Inbound, "Inbound ");
+}
+
+
+// eof

157 lines not on this page · raw message

222 lines not on this page · raw message

41 lines not on this page · raw message

826 lines not on this page · raw message

156 lines not on this page · raw message

399 lines not on this page · raw message

672 lines not on this page · raw message

184 lines not on this page · raw message

500 lines not on this page · raw message

630 lines not on this page · raw message

123 lines not on this page · raw message

Lines of this file are not shown. View the raw message.

Lines of this file are not shown. View the raw message.

508 lines not on this page · raw message

1,228 lines not on this page · raw message

170 lines not on this page · raw message

@@ -0,0 +1,107 @@
+/*
+ *
+ * Copyright (c) 2009, Microsoft Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Authors:
+ *   Hank Janssen  <[email protected]>
+ *
+ */
+
+
+#include "../storvsc/StorVsc.c"
+
+static const char* gBlkDriverName="blkvsc";
+
+//{32412632-86cb-44a2-9b5c-50d1417354f5}
+static const GUID gBlkVscDeviceType={
+	.Data = {0x32, 0x26, 0x41, 0x32, 0xcb, 0x86, 0xa2, 0x44, 0x9b, 0x5c, 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5}
+};
+
+// Static routines
+static int
+BlkVscOnDeviceAdd(
+	DEVICE_OBJECT	*Device,
+	void			*AdditionalInfo
+	);
+
+
+int
+BlkVscInitialize(
+	DRIVER_OBJECT *Driver
+	)
+{
+	STORVSC_DRIVER_OBJECT* storDriver = (STORVSC_DRIVER_OBJECT*)Driver;
+	int ret=0;
+
+	DPRINT_ENTER(BLKVSC);
+
+	// Make sure we are at least 2 pages since 1 page is used for control
+	ASSERT(storDriver->RingBufferSize >= (PAGE_SIZE << 1));
+
+	Driver->name = gBlkDriverName;
+	memcpy(&Driver->deviceType, &gBlkVscDeviceType, sizeof(GUID));
+
+	storDriver->RequestExtSize			= sizeof(STORVSC_REQUEST_EXTENSION);
+	// Divide the ring buffer data size (which is 1 page less than the ring buffer size since that page is reserved for the ring buffer indices)
+	// by the max request size (which is VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER + VSTOR_PACKET + UINT64)
+	storDriver->MaxOutstandingRequestsPerChannel =
+		((storDriver->RingBufferSize - PAGE_SIZE) / ALIGN_UP(MAX_MULTIPAGE_BUFFER_PACKET + sizeof(VSTOR_PACKET) + sizeof(UINT64),sizeof(UINT64)));
+
+	DPRINT_INFO(BLKVSC, "max io outstd %u", storDriver->MaxOutstandingRequestsPerChannel);
+
+	// Setup the dispatch table
+	storDriver->Base.OnDeviceAdd		= BlkVscOnDeviceAdd;
+	storDriver->Base.OnDeviceRemove		= StorVscOnDeviceRemove;
+	storDriver->Base.OnCleanup			= StorVscOnCleanup;
+
+	storDriver->OnIORequest				= StorVscOnIORequest;
+
+	DPRINT_EXIT(BLKVSC);
+
+	return ret;
+}
+
+int
+BlkVscOnDeviceAdd(
+	DEVICE_OBJECT	*Device,
+	void			*AdditionalInfo
+	)
+{
+	int ret=0;
+	STORVSC_DEVICE_INFO *deviceInfo = (STORVSC_DEVICE_INFO*)AdditionalInfo;
+
+	DPRINT_ENTER(BLKVSC);
+
+	ret = StorVscOnDeviceAdd(Device, AdditionalInfo);
+
+	if (ret != 0)
+	{
+		DPRINT_EXIT(BLKVSC);
+
+		return ret;
+	}
+
+	// We need to use the device instance guid to set the path and target id. For IDE devices, the
+	// device instance id is formatted as <bus id> - <device id> - 8899 - 000000000000.
+	deviceInfo->PathId = Device->deviceInstance.Data[3] << 24 | Device->deviceInstance.Data[2] << 16 |
+		Device->deviceInstance.Data[1] << 8 |Device->deviceInstance.Data[0];
+
+	deviceInfo->TargetId = Device->deviceInstance.Data[5] << 8 | Device->deviceInstance.Data[4];
+
+	DPRINT_EXIT(BLKVSC);
+
+	return ret;
+}

1,547 lines not on this page · raw message

@@ -0,0 +1,1499 @@
+/*
+ *
+ * Copyright (c) 2009, Microsoft Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Authors:
+ *   Hank Janssen  <[email protected]>
+ *
+ */
+
+
+#include "logging.h"
+#include "NetVsc.h"
+#include "RndisFilter.h"
+
+
+//
+// Globals
+//
+static const char* gDriverName="netvsc";
+
+// {F8615163-DF3E-46c5-913F-F2D2F965ED0E}
+static const GUID gNetVscDeviceType={
+	.Data = {0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46, 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E}
+};
+
+
+//
+// Internal routines
+//
+static int
+NetVscOnDeviceAdd(
+	DEVICE_OBJECT	*Device,
+	void			*AdditionalInfo
+	);
+
+static int
+NetVscOnDeviceRemove(
+	DEVICE_OBJECT *Device
+	);
+
+static void
+NetVscOnCleanup(
+	DRIVER_OBJECT *Driver
+	);
+
+static void
+NetVscOnChannelCallback(
+	PVOID context
+	);
+
+static int
+NetVscInitializeSendBufferWithNetVsp(
+	DEVICE_OBJECT			*Device
+	);
+
+static int
+NetVscInitializeReceiveBufferWithNetVsp(
+	DEVICE_OBJECT			*Device
+	);
+
+static int
+NetVscDestroySendBuffer(
+	NETVSC_DEVICE	*NetDevice
+	);
+
+static int
+NetVscDestroyReceiveBuffer(
+	NETVSC_DEVICE	*NetDevice
+	);
+
+static int
+NetVscConnectToVsp(
+	DEVICE_OBJECT		*Device
+	);
+
+static void
+NetVscOnSendCompletion(
+	DEVICE_OBJECT		*Device,
+	VMPACKET_DESCRIPTOR *Packet
+	);
+
+static int
+NetVscOnSend(
+	DEVICE_OBJECT	*Device,
+	NETVSC_PACKET	*Packet
+	);
+
+static void
+NetVscOnReceive(
+	DEVICE_OBJECT		*Device,
+	VMPACKET_DESCRIPTOR *Packet
+	);
+
+static void
+NetVscOnReceiveCompletion(
+	PVOID Context
+	);
+
+static void
+NetVscSendReceiveCompletion(
+	DEVICE_OBJECT	*Device,
+	UINT64			TransactionId
+	);
+
+static inline NETVSC_DEVICE* AllocNetDevice(DEVICE_OBJECT *Device)
+{
+	NETVSC_DEVICE *netDevice;
+
+	netDevice = MemAllocZeroed(sizeof(NETVSC_DEVICE));
+	if (!netDevice)
+		return NULL;
+
+	// Set to 2 to allow both inbound and outbound traffic
+	InterlockedCompareExchange(&netDevice->RefCount, 2, 0);
+
+	netDevice->Device = Device;
+	Device->Extension = netDevice;
+
+	return netDevice;
+}
+
+static inline void FreeNetDevice(NETVSC_DEVICE *Device)
+{
+	ASSERT(Device->RefCount == 0);
+	Device->Device->Extension = NULL;
+	MemFree(Device);
+}
+
+
+// Get the net device object iff exists and its refcount > 1
+static inline NETVSC_DEVICE* GetOutboundNetDevice(DEVICE_OBJECT	*Device)
+{
+	NETVSC_DEVICE *netDevice;
+
+	netDevice = (NETVSC_DEVICE*)Device->Extension;
+	if (netDevice && netDevice->RefCount > 1)
+	{
+		InterlockedIncrement(&netDevice->RefCount);
+	}
+	else
+	{
+		netDevice = NULL;
+	}
+
+	return netDevice;
+}
+
+// Get the net device object iff exists and its refcount > 0
+static inline NETVSC_DEVICE* GetInboundNetDevice(DEVICE_OBJECT	*Device)
+{
+	NETVSC_DEVICE *netDevice;
+
+	netDevice = (NETVSC_DEVICE*)Device->Extension;
+	if (netDevice && netDevice->RefCount)
+	{
+		InterlockedIncrement(&netDevice->RefCount);
+	}
+	else
+	{
+		netDevice = NULL;
+	}
+
+	return netDevice;
+}
+
+static inline void PutNetDevice(DEVICE_OBJECT *Device)
+{
+	NETVSC_DEVICE *netDevice;
+
+	netDevice = (NETVSC_DEVICE*)Device->Extension;
+	ASSERT(netDevice);
+
+	InterlockedDecrement(&netDevice->RefCount);
+}
+
+static inline NETVSC_DEVICE* ReleaseOutboundNetDevice(DEVICE_OBJECT *Device)
+{
+	NETVSC_DEVICE *netDevice;
+
+	netDevice = (NETVSC_DEVICE*)Device->Extension;
+	if (netDevice == NULL)
+		return NULL;
+
+	// Busy wait until the ref drop to 2, then set it to 1
+	while (InterlockedCompareExchange(&netDevice->RefCount, 1, 2) != 2)
+	{
+		Sleep(100);
+	}
+
+	return netDevice;
+}
+
+static inline NETVSC_DEVICE* ReleaseInboundNetDevice(DEVICE_OBJECT *Device)
+{
+	NETVSC_DEVICE *netDevice;
+
+	netDevice = (NETVSC_DEVICE*)Device->Extension;
+	if (netDevice == NULL)
+		return NULL;
+
+	// Busy wait until the ref drop to 1, then set it to 0
+	while (InterlockedCompareExchange(&netDevice->RefCount, 0, 1) != 1)
+	{
+		Sleep(100);
+	}
+
+	Device->Extension = NULL;
+	return netDevice;
+}
+
+/*++;
+
+
+Name:
+	NetVscInitialize()
+
+Description:
+	Main entry point
+
+--*/
+int
+NetVscInitialize(
+	DRIVER_OBJECT *drv
+	)
+{
+	NETVSC_DRIVER_OBJECT* driver = (NETVSC_DRIVER_OBJECT*)drv;
+	int ret=0;
+
+	DPRINT_ENTER(NETVSC);
+
+	DPRINT_DBG(NETVSC, "sizeof(NETVSC_PACKET)=%d, sizeof(NVSP_MESSAGE)=%d, sizeof(VMTRANSFER_PAGE_PACKET_HEADER)=%d",
+		sizeof(NETVSC_PACKET), sizeof(NVSP_MESSAGE), sizeof(VMTRANSFER_PAGE_PACKET_HEADER));
+
+	// Make sure we are at least 2 pages since 1 page is used for control
+	ASSERT(driver->RingBufferSize >= (PAGE_SIZE << 1));
+
+	drv->name = gDriverName;
+	memcpy(&drv->deviceType, &gNetVscDeviceType, sizeof(GUID));
+
+	// Make sure it is set by the caller
+	ASSERT(driver->OnReceiveCallback);
+	ASSERT(driver->OnLinkStatusChanged);
+
+	// Setup the dispatch table
+	driver->Base.OnDeviceAdd		= NetVscOnDeviceAdd;
+	driver->Base.OnDeviceRemove		= NetVscOnDeviceRemove;
+	driver->Base.OnCleanup			= NetVscOnCleanup;
+
+	driver->OnSend					= NetVscOnSend;
+
+	RndisFilterInit(driver);
+
+	DPRINT_EXIT(NETVSC);
+
+	return ret;
+}
+
+static int
+NetVscInitializeReceiveBufferWithNetVsp(
+	DEVICE_OBJECT	*Device
+	)
+{
+	int ret=0;
+	NETVSC_DEVICE *netDevice;
+	NVSP_MESSAGE *initPacket;
+
+	DPRINT_ENTER(NETVSC);
+
+	netDevice = GetOutboundNetDevice(Device);
+	if (!netDevice)
+	{
+		DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
+		DPRINT_EXIT(NETVSC);
+		return -1;
+	}
+	ASSERT(netDevice->ReceiveBufferSize > 0);
+	ASSERT((netDevice->ReceiveBufferSize & (PAGE_SIZE-1)) == 0); // page-size grandularity
+
+	netDevice->ReceiveBuffer = PageAlloc(netDevice->ReceiveBufferSize >> PAGE_SHIFT);
+	if (!netDevice->ReceiveBuffer)
+	{
+		DPRINT_ERR(NETVSC, "unable to allocate receive buffer of size %d", netDevice->ReceiveBufferSize);
+		ret = -1;
+		goto Cleanup;
+	}
+	ASSERT(((ULONG_PTR)netDevice->ReceiveBuffer & (PAGE_SIZE-1)) == 0); // page-aligned buffer
+
+	DPRINT_INFO(NETVSC, "Establishing receive buffer's GPADL...");
+
+	// Establish the gpadl handle for this buffer on this channel.
+	// Note: This call uses the vmbus connection rather than the channel to establish
+	// the gpadl handle.
+	ret = Device->Driver->VmbusChannelInterface.EstablishGpadl(Device,
+																netDevice->ReceiveBuffer,
+																netDevice->ReceiveBufferSize,
+																&netDevice->ReceiveBufferGpadlHandle);
+
+	if (ret != 0)
+	{
+		DPRINT_ERR(NETVSC, "unable to establish receive buffer's gpadl");
+		goto Cleanup;
+	}
+
+	//WaitEventWait(ext->ChannelInitEvent);
+
+	// Notify the NetVsp of the gpadl handle
+	DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendReceiveBuffer...");
+
+	initPacket = &netDevice->ChannelInitPacket;
+
+	memset(initPacket, 0, sizeof(NVSP_MESSAGE));
+
+    initPacket->Header.MessageType = NvspMessage1TypeSendReceiveBuffer;
+    initPacket->Messages.Version1Messages.SendReceiveBuffer.GpadlHandle = netDevice->ReceiveBufferGpadlHandle;
+    initPacket->Messages.Version1Messages.SendReceiveBuffer.Id = NETVSC_RECEIVE_BUFFER_ID;
+
+	// Send the gpadl notification request
+	ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															initPacket,
+															sizeof(NVSP_MESSAGE),
+															(ULONG_PTR)initPacket,
+															VmbusPacketTypeDataInBand,
+															VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+	if (ret != 0)
+	{
+		DPRINT_ERR(NETVSC, "unable to send receive buffer's gpadl to netvsp");
+		goto Cleanup;
+	}
+
+	WaitEventWait(netDevice->ChannelInitEvent);
+
+	// Check the response
+	if (initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Status != NvspStatusSuccess)
+	{
+		DPRINT_ERR(NETVSC,
+			"Unable to complete receive buffer initialzation with NetVsp - status %d",
+			initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Status);
+		ret = -1;
+		goto Cleanup;
+	}
+
+	// Parse the response
+	ASSERT(netDevice->ReceiveSectionCount == 0);
+	ASSERT(netDevice->ReceiveSections == NULL);
+
+	netDevice->ReceiveSectionCount = initPacket->Messages.Version1Messages.SendReceiveBufferComplete.NumSections;
+
+	netDevice->ReceiveSections = MemAlloc(netDevice->ReceiveSectionCount * sizeof(NVSP_1_RECEIVE_BUFFER_SECTION));
+	if (netDevice->ReceiveSections == NULL)
+	{
+		ret = -1;
+		goto Cleanup;
+	}
+
+	memcpy(netDevice->ReceiveSections,
+		initPacket->Messages.Version1Messages.SendReceiveBufferComplete.Sections,
+		netDevice->ReceiveSectionCount * sizeof(NVSP_1_RECEIVE_BUFFER_SECTION));
+
+	DPRINT_INFO(NETVSC,
+		"Receive sections info (count %d, offset %d, endoffset %d, suballoc size %d, num suballocs %d)",
+		netDevice->ReceiveSectionCount, netDevice->ReceiveSections[0].Offset, netDevice->ReceiveSections[0].EndOffset,
+		netDevice->ReceiveSections[0].SubAllocationSize, netDevice->ReceiveSections[0].NumSubAllocations);
+
+
+	//For 1st release, there should only be 1 section that represents the entire receive buffer
+	if (netDevice->ReceiveSectionCount != 1 ||
+		netDevice->ReceiveSections->Offset != 0 )
+	{
+		ret = -1;
+		goto Cleanup;
+	}
+
+	goto Exit;
+
+Cleanup:
+	NetVscDestroyReceiveBuffer(netDevice);
+
+Exit:
+	PutNetDevice(Device);
+	DPRINT_EXIT(NETVSC);
+	return ret;
+}
+
+
+static int
+NetVscInitializeSendBufferWithNetVsp(
+	DEVICE_OBJECT	*Device
+	)
+{
+	int ret=0;
+	NETVSC_DEVICE *netDevice;
+	NVSP_MESSAGE *initPacket;
+
+	DPRINT_ENTER(NETVSC);
+
+	netDevice = GetOutboundNetDevice(Device);
+	if (!netDevice)
+	{
+		DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
+		DPRINT_EXIT(NETVSC);
+		return -1;
+	}
+	ASSERT(netDevice->SendBufferSize > 0);
+	ASSERT((netDevice->SendBufferSize & (PAGE_SIZE-1)) == 0); // page-size grandularity
+
+	netDevice->SendBuffer = PageAlloc(netDevice->SendBufferSize >> PAGE_SHIFT);
+	if (!netDevice->SendBuffer)
+	{
+		DPRINT_ERR(NETVSC, "unable to allocate send buffer of size %d", netDevice->SendBufferSize);
+		ret = -1;
+		goto Cleanup;
+	}
+	ASSERT(((ULONG_PTR)netDevice->SendBuffer & (PAGE_SIZE-1)) == 0); // page-aligned buffer
+
+	DPRINT_INFO(NETVSC, "Establishing send buffer's GPADL...");
+
+	// Establish the gpadl handle for this buffer on this channel.
+	// Note: This call uses the vmbus connection rather than the channel to establish
+	// the gpadl handle.
+	ret = Device->Driver->VmbusChannelInterface.EstablishGpadl(Device,
+																netDevice->SendBuffer,
+																netDevice->SendBufferSize,
+																&netDevice->SendBufferGpadlHandle);
+
+	if (ret != 0)
+	{
+		DPRINT_ERR(NETVSC, "unable to establish send buffer's gpadl");
+		goto Cleanup;
+	}
+
+	//WaitEventWait(ext->ChannelInitEvent);
+
+	// Notify the NetVsp of the gpadl handle
+	DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendSendBuffer...");
+
+	initPacket = &netDevice->ChannelInitPacket;
+
+	memset(initPacket, 0, sizeof(NVSP_MESSAGE));
+
+    initPacket->Header.MessageType = NvspMessage1TypeSendSendBuffer;
+    initPacket->Messages.Version1Messages.SendReceiveBuffer.GpadlHandle = netDevice->SendBufferGpadlHandle;
+    initPacket->Messages.Version1Messages.SendReceiveBuffer.Id = NETVSC_SEND_BUFFER_ID;
+
+	// Send the gpadl notification request
+	ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															initPacket,
+															sizeof(NVSP_MESSAGE),
+															(ULONG_PTR)initPacket,
+															VmbusPacketTypeDataInBand,
+															VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+	if (ret != 0)
+	{
+		DPRINT_ERR(NETVSC, "unable to send receive buffer's gpadl to netvsp");
+		goto Cleanup;
+	}
+
+	WaitEventWait(netDevice->ChannelInitEvent);
+
+	// Check the response
+	if (initPacket->Messages.Version1Messages.SendSendBufferComplete.Status != NvspStatusSuccess)
+	{
+		DPRINT_ERR(NETVSC,
+			"Unable to complete send buffer initialzation with NetVsp - status %d",
+			initPacket->Messages.Version1Messages.SendSendBufferComplete.Status);
+		ret = -1;
+		goto Cleanup;
+	}
+
+	netDevice->SendSectionSize = initPacket->Messages.Version1Messages.SendSendBufferComplete.SectionSize;
+
+	goto Exit;
+
+Cleanup:
+	NetVscDestroySendBuffer(netDevice);
+
+Exit:
+	PutNetDevice(Device);
+	DPRINT_EXIT(NETVSC);
+	return ret;
+}
+
+static int
+NetVscDestroyReceiveBuffer(
+	NETVSC_DEVICE	*NetDevice
+	)
+{
+	NVSP_MESSAGE *revokePacket;
+	int ret=0;
+
+
+	DPRINT_ENTER(NETVSC);
+
+	// If we got a section count, it means we received a SendReceiveBufferComplete msg
+	// (ie sent NvspMessage1TypeSendReceiveBuffer msg) therefore, we need to send a revoke msg here
+	if (NetDevice->ReceiveSectionCount)
+	{
+		DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeRevokeReceiveBuffer...");
+
+		// Send the revoke receive buffer
+		revokePacket = &NetDevice->RevokePacket;
+		memset(revokePacket, 0, sizeof(NVSP_MESSAGE));
+
+		revokePacket->Header.MessageType = NvspMessage1TypeRevokeReceiveBuffer;
+		revokePacket->Messages.Version1Messages.RevokeReceiveBuffer.Id = NETVSC_RECEIVE_BUFFER_ID;
+
+		ret = NetDevice->Device->Driver->VmbusChannelInterface.SendPacket(NetDevice->Device,
+																			revokePacket,
+																			sizeof(NVSP_MESSAGE),
+																			(ULONG_PTR)revokePacket,
+																			VmbusPacketTypeDataInBand,
+																			0);
+		// If we failed here, we might as well return and have a leak rather than continue and a bugchk
+		if (ret != 0)
+		{
+			DPRINT_ERR(NETVSC, "unable to send revoke receive buffer to netvsp");
+			DPRINT_EXIT(NETVSC);
+			return -1;
+		}
+	}
+
+	// Teardown the gpadl on the vsp end
+	if (NetDevice->ReceiveBufferGpadlHandle)
+	{
+		DPRINT_INFO(NETVSC, "Tearing down receive buffer's GPADL...");
+
+		ret = NetDevice->Device->Driver->VmbusChannelInterface.TeardownGpadl(NetDevice->Device,
+																				NetDevice->ReceiveBufferGpadlHandle);
+
+		// If we failed here, we might as well return and have a leak rather than continue and a bugchk
+		if (ret != 0)
+		{
+			DPRINT_ERR(NETVSC, "unable to teardown receive buffer's gpadl");
+			DPRINT_EXIT(NETVSC);
+			return -1;
+		}
+		NetDevice->ReceiveBufferGpadlHandle = 0;
+	}
+
+	if (NetDevice->ReceiveBuffer)
+	{
+		DPRINT_INFO(NETVSC, "Freeing up receive buffer...");
+
+		// Free up the receive buffer
+		PageFree(NetDevice->ReceiveBuffer, NetDevice->ReceiveBufferSize >> PAGE_SHIFT);
+		NetDevice->ReceiveBuffer = NULL;
+	}
+
+	if (NetDevice->ReceiveSections)
+	{
+		MemFree(NetDevice->ReceiveSections);
+		NetDevice->ReceiveSections = NULL;
+		NetDevice->ReceiveSectionCount = 0;
+	}
+
+	DPRINT_EXIT(NETVSC);
+
+	return ret;
+}
+
+
+
+
+static int
+NetVscDestroySendBuffer(
+	NETVSC_DEVICE	*NetDevice
+	)
+{
+	NVSP_MESSAGE *revokePacket;
+	int ret=0;
+
+
+	DPRINT_ENTER(NETVSC);
+
+	// If we got a section count, it means we received a SendReceiveBufferComplete msg
+	// (ie sent NvspMessage1TypeSendReceiveBuffer msg) therefore, we need to send a revoke msg here
+	if (NetDevice->SendSectionSize)
+	{
+		DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeRevokeSendBuffer...");
+
+		// Send the revoke send buffer
+		revokePacket = &NetDevice->RevokePacket;
+		memset(revokePacket, 0, sizeof(NVSP_MESSAGE));
+
+		revokePacket->Header.MessageType = NvspMessage1TypeRevokeSendBuffer;
+		revokePacket->Messages.Version1Messages.RevokeSendBuffer.Id = NETVSC_SEND_BUFFER_ID;
+
+		ret = NetDevice->Device->Driver->VmbusChannelInterface.SendPacket(NetDevice->Device,
+																			revokePacket,
+																			sizeof(NVSP_MESSAGE),
+																			(ULONG_PTR)revokePacket,
+																			VmbusPacketTypeDataInBand,
+																			0);
+		// If we failed here, we might as well return and have a leak rather than continue and a bugchk
+		if (ret != 0)
+		{
+			DPRINT_ERR(NETVSC, "unable to send revoke send buffer to netvsp");
+			DPRINT_EXIT(NETVSC);
+			return -1;
+		}
+	}
+
+	// Teardown the gpadl on the vsp end
+	if (NetDevice->SendBufferGpadlHandle)
+	{
+		DPRINT_INFO(NETVSC, "Tearing down send buffer's GPADL...");
+
+		ret = NetDevice->Device->Driver->VmbusChannelInterface.TeardownGpadl(NetDevice->Device,
+																				NetDevice->SendBufferGpadlHandle);
+
+		// If we failed here, we might as well return and have a leak rather than continue and a bugchk
+		if (ret != 0)
+		{
+			DPRINT_ERR(NETVSC, "unable to teardown send buffer's gpadl");
+			DPRINT_EXIT(NETVSC);
+			return -1;
+		}
+		NetDevice->SendBufferGpadlHandle = 0;
+	}
+
+	if (NetDevice->SendBuffer)
+	{
+		DPRINT_INFO(NETVSC, "Freeing up send buffer...");
+
+		// Free up the receive buffer
+		PageFree(NetDevice->SendBuffer, NetDevice->SendBufferSize >> PAGE_SHIFT);
+		NetDevice->SendBuffer = NULL;
+	}
+
+	DPRINT_EXIT(NETVSC);
+
+	return ret;
+}
+
+
+
+static int
+NetVscConnectToVsp(
+	DEVICE_OBJECT	*Device
+	)
+{
+	int ret=0;
+	NETVSC_DEVICE *netDevice;
+	NVSP_MESSAGE *initPacket;
+	int ndisVersion;
+
+	DPRINT_ENTER(NETVSC);
+
+	netDevice = GetOutboundNetDevice(Device);
+	if (!netDevice)
+	{
+		DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
+		DPRINT_EXIT(NETVSC);
+		return -1;
+	}
+
+	initPacket = &netDevice->ChannelInitPacket;
+
+	memset(initPacket, 0, sizeof(NVSP_MESSAGE));
+	initPacket->Header.MessageType = NvspMessageTypeInit;
+    initPacket->Messages.InitMessages.Init.MinProtocolVersion = NVSP_MIN_PROTOCOL_VERSION;
+    initPacket->Messages.InitMessages.Init.MaxProtocolVersion = NVSP_MAX_PROTOCOL_VERSION;
+
+	DPRINT_INFO(NETVSC, "Sending NvspMessageTypeInit...");
+
+	// Send the init request
+	ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															initPacket,
+															sizeof(NVSP_MESSAGE),
+															(ULONG_PTR)initPacket,
+															VmbusPacketTypeDataInBand,
+															VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+
+	if( ret != 0)
+	{
+		DPRINT_ERR(NETVSC, "unable to send NvspMessageTypeInit");
+		goto Cleanup;
+	}
+
+	WaitEventWait(netDevice->ChannelInitEvent);
+
+	// Now, check the response
+	//ASSERT(initPacket->Messages.InitMessages.InitComplete.MaximumMdlChainLength <= MAX_MULTIPAGE_BUFFER_COUNT);
+	DPRINT_INFO(NETVSC, "NvspMessageTypeInit status(%d) max mdl chain (%d)",
+		initPacket->Messages.InitMessages.InitComplete.Status,
+		initPacket->Messages.InitMessages.InitComplete.MaximumMdlChainLength);
+
+	if (initPacket->Messages.InitMessages.InitComplete.Status != NvspStatusSuccess)
+	{
+		DPRINT_ERR(NETVSC, "unable to initialize with netvsp (status 0x%x)", initPacket->Messages.InitMessages.InitComplete.Status);
+		ret = -1;
+		goto Cleanup;
+	}
+
+	if (initPacket->Messages.InitMessages.InitComplete.NegotiatedProtocolVersion != NVSP_PROTOCOL_VERSION_1)
+	{
+		DPRINT_ERR(NETVSC, "unable to initialize with netvsp (version expected 1 got %d)",
+			initPacket->Messages.InitMessages.InitComplete.NegotiatedProtocolVersion);
+		ret = -1;
+		goto Cleanup;
+	}
+	DPRINT_INFO(NETVSC, "Sending NvspMessage1TypeSendNdisVersion...");
+
+	// Send the ndis version
+	memset(initPacket, 0, sizeof(NVSP_MESSAGE));
+
+    ndisVersion = 0x00050000;
+
+    initPacket->Header.MessageType = NvspMessage1TypeSendNdisVersion;
+    initPacket->Messages.Version1Messages.SendNdisVersion.NdisMajorVersion = (ndisVersion & 0xFFFF0000) >> 16;
+    initPacket->Messages.Version1Messages.SendNdisVersion.NdisMinorVersion = ndisVersion & 0xFFFF;
+
+	// Send the init request
+	ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															initPacket,
+															sizeof(NVSP_MESSAGE),
+															(ULONG_PTR)initPacket,
+															VmbusPacketTypeDataInBand,
+															0);
+	if (ret != 0)
+	{
+		DPRINT_ERR(NETVSC, "unable to send NvspMessage1TypeSendNdisVersion");
+		ret = -1;
+		goto Cleanup;
+	}
+	//
+	// BUGBUG - We have to wait for the above msg since the netvsp uses KMCL which acknowledges packet (completion packet)
+	// since our Vmbus always set the VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED flag
+	//WaitEventWait(NetVscChannel->ChannelInitEvent);
+
+	// Post the big receive buffer to NetVSP
+	ret = NetVscInitializeReceiveBufferWithNetVsp(Device);
+	if (ret == 0)
+	{
+		ret = NetVscInitializeSendBufferWithNetVsp(Device);
+	}
+
+Cleanup:
+	PutNetDevice(Device);
+	DPRINT_EXIT(NETVSC);
+	return ret;
+}
+
+static void
+NetVscDisconnectFromVsp(
+	NETVSC_DEVICE	*NetDevice
+	)
+{
+	DPRINT_ENTER(NETVSC);
+
+	NetVscDestroyReceiveBuffer(NetDevice);
+	NetVscDestroySendBuffer(NetDevice);
+
+	DPRINT_EXIT(NETVSC);
+}
+
+
+/*++
+
+Name:
+	NetVscOnDeviceAdd()
+
+Description:
+	Callback when the device belonging to this driver is added
+
+--*/
+int
+NetVscOnDeviceAdd(
+	DEVICE_OBJECT	*Device,
+	void			*AdditionalInfo
+	)
+{
+	int ret=0;
+	int i;
+
+	NETVSC_DEVICE* netDevice;
+	NETVSC_PACKET* packet;
+	LIST_ENTRY *entry;
+
+	NETVSC_DRIVER_OBJECT *netDriver = (NETVSC_DRIVER_OBJECT*) Device->Driver;;
+
+	DPRINT_ENTER(NETVSC);
+
+	netDevice = AllocNetDevice(Device);
+	if (!netDevice)
+	{
+		ret = -1;
+		goto Cleanup;
+	}
+
+	DPRINT_DBG(NETVSC, "netvsc channel object allocated - %p", netDevice);
+
+	// Initialize the NetVSC channel extension
+	netDevice->ReceiveBufferSize = NETVSC_RECEIVE_BUFFER_SIZE;
+	netDevice->ReceivePacketListLock = SpinlockCreate();
+
+	netDevice->SendBufferSize = NETVSC_SEND_BUFFER_SIZE;
+
+	INITIALIZE_LIST_HEAD(&netDevice->ReceivePacketList);
+
+	for (i=0; i < NETVSC_RECEIVE_PACKETLIST_COUNT; i++)
+	{
+		packet = MemAllocZeroed(sizeof(NETVSC_PACKET) + (NETVSC_RECEIVE_SG_COUNT* sizeof(PAGE_BUFFER)));
+		if (!packet)
+		{
+			DPRINT_DBG(NETVSC, "unable to allocate netvsc pkts for receive pool (wanted %d got %d)", NETVSC_RECEIVE_PACKETLIST_COUNT, i);
+			break;
+		}
+
+		INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &packet->ListEntry);
+	}
+	netDevice->ChannelInitEvent = WaitEventCreate();
+
+	// Open the channel
+	ret = Device->Driver->VmbusChannelInterface.Open(Device,
+														netDriver->RingBufferSize,
+														netDriver->RingBufferSize,
+														NULL, 0,
+														NetVscOnChannelCallback,
+														Device
+														);
+
+	if (ret != 0)
+	{
+		DPRINT_ERR(NETVSC, "unable to open channel: %d", ret);
+		ret = -1;
+		goto Cleanup;
+	}
+
+	// Channel is opened
+	DPRINT_INFO(NETVSC, "*** NetVSC channel opened successfully! ***");
+
+	// Connect with the NetVsp
+	ret = NetVscConnectToVsp(Device);
+	if (ret != 0)
+	{
+		DPRINT_ERR(NETVSC, "unable to connect to NetVSP - %d", ret);
+		ret = -1;
+		goto Close;
+	}
+
+	DPRINT_INFO(NETVSC, "*** NetVSC channel handshake result - %d ***", ret);
+
+	DPRINT_EXIT(NETVSC);
+	return ret;
+
+Close:
+	// Now, we can close the channel safely
+	Device->Driver->VmbusChannelInterface.Close(Device);
+
+Cleanup:
+
+	if (netDevice)
+	{
+		WaitEventClose(netDevice->ChannelInitEvent);
+
+		while (!IsListEmpty(&netDevice->ReceivePacketList))
+		{
+			entry = REMOVE_HEAD_LIST(&netDevice->ReceivePacketList);
+			packet = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
+			MemFree(packet);
+		}
+
+		SpinlockClose(netDevice->ReceivePacketListLock);
+
+		ReleaseOutboundNetDevice(Device);
+		ReleaseInboundNetDevice(Device);
+
+		FreeNetDevice(netDevice);
+	}
+
+	DPRINT_EXIT(NETVSC);
+	return ret;
+}
+
+
+/*++
+
+Name:
+	NetVscOnDeviceRemove()
+
+Description:
+	Callback when the root bus device is removed
+
+--*/
+int
+NetVscOnDeviceRemove(
+	DEVICE_OBJECT *Device
+	)
+{
+	NETVSC_DEVICE *netDevice;
+	NETVSC_PACKET *netvscPacket;
+	int ret=0;
+	LIST_ENTRY *entry;
+
+	DPRINT_ENTER(NETVSC);
+
+	DPRINT_INFO(NETVSC, "Disabling outbound traffic on net device (%p)...", Device->Extension);
+
+	// Stop outbound traffic ie sends and receives completions
+	netDevice = ReleaseOutboundNetDevice(Device);
+	if (!netDevice)
+	{
+		DPRINT_ERR(NETVSC, "No net device present!!");
+		return -1;
+	}
+
+	// Wait for all send completions
+	while (netDevice->NumOutstandingSends)
+	{
+		DPRINT_INFO(NETVSC, "waiting for %d requests to complete...", netDevice->NumOutstandingSends);
+
+		Sleep(100);
+	}
+
+	DPRINT_INFO(NETVSC, "Disconnecting from netvsp...");
+
+	NetVscDisconnectFromVsp(netDevice);
+
+	DPRINT_INFO(NETVSC, "Disabling inbound traffic on net device (%p)...", Device->Extension);
+
+	// Stop inbound traffic ie receives and sends completions
+	netDevice = ReleaseInboundNetDevice(Device);
+
+	// At this point, no one should be accessing netDevice except in here
+	DPRINT_INFO(NETVSC, "net device (%p) safe to remove", netDevice);
+
+	// Now, we can close the channel safely
+	Device->Driver->VmbusChannelInterface.Close(Device);
+
+	// Release all resources
+	while (!IsListEmpty(&netDevice->ReceivePacketList))
+	{
+		entry = REMOVE_HEAD_LIST(&netDevice->ReceivePacketList);
+		netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
+
+		MemFree(netvscPacket);
+	}
+
+	SpinlockClose(netDevice->ReceivePacketListLock);
+	WaitEventClose(netDevice->ChannelInitEvent);
+	FreeNetDevice(netDevice);
+
+	DPRINT_EXIT(NETVSC);
+	return ret;
+}
+
+
+
+/*++
+
+Name:
+	NetVscOnCleanup()
+
+Description:
+	Perform any cleanup when the driver is removed
+
+--*/
+void
+NetVscOnCleanup(
+	DRIVER_OBJECT *drv
+	)
+{
+	DPRINT_ENTER(NETVSC);
+
+	DPRINT_EXIT(NETVSC);
+}
+
+static void
+NetVscOnSendCompletion(
+	DEVICE_OBJECT		*Device,
+	VMPACKET_DESCRIPTOR *Packet
+	)
+{
+	NETVSC_DEVICE* netDevice;
+	NVSP_MESSAGE *nvspPacket;
+	NETVSC_PACKET *nvscPacket;
+
+	DPRINT_ENTER(NETVSC);
+
+	netDevice = GetInboundNetDevice(Device);
+	if (!netDevice)
+	{
+		DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
+		DPRINT_EXIT(NETVSC);
+		return;
+	}
+
+	nvspPacket = (NVSP_MESSAGE*)((ULONG_PTR)Packet + (Packet->DataOffset8 << 3));
+
+	DPRINT_DBG(NETVSC, "send completion packet - type %d", nvspPacket->Header.MessageType);
+
+	if (nvspPacket->Header.MessageType == NvspMessageTypeInitComplete ||
+		nvspPacket->Header.MessageType == NvspMessage1TypeSendReceiveBufferComplete ||
+		nvspPacket->Header.MessageType == NvspMessage1TypeSendSendBufferComplete)
+	{
+		// Copy the response back
+		memcpy(&netDevice->ChannelInitPacket, nvspPacket, sizeof(NVSP_MESSAGE));
+		WaitEventSet(netDevice->ChannelInitEvent);
+	}
+	else if (nvspPacket->Header.MessageType == NvspMessage1TypeSendRNDISPacketComplete)
+	{
+		// Get the send context
+		nvscPacket = (NETVSC_PACKET *)(ULONG_PTR)Packet->TransactionId;
+		ASSERT(nvscPacket);
+
+		// Notify the layer above us
+		nvscPacket->Completion.Send.OnSendCompletion(nvscPacket->Completion.Send.SendCompletionContext);
+
+		InterlockedDecrement(&netDevice->NumOutstandingSends);
+	}
+	else
+	{
+		DPRINT_ERR(NETVSC, "Unknown send completion packet type - %d received!!", nvspPacket->Header.MessageType);
+	}
+
+	PutNetDevice(Device);
+	DPRINT_EXIT(NETVSC);
+}
+
+
+
+static int
+NetVscOnSend(
+	DEVICE_OBJECT *Device,
+	NETVSC_PACKET *Packet
+	)
+{
+	NETVSC_DEVICE* netDevice;
+	int ret=0;
+
+	NVSP_MESSAGE sendMessage;
+
+	DPRINT_ENTER(NETVSC);
+
+	netDevice = GetOutboundNetDevice(Device);
+	if (!netDevice)
+	{
+		DPRINT_ERR(NETVSC, "net device (%p) shutting down...ignoring outbound packets", netDevice);
+		DPRINT_EXIT(NETVSC);
+		return -2;
+	}
+
+	sendMessage.Header.MessageType = NvspMessage1TypeSendRNDISPacket;
+	if (Packet->IsDataPacket)
+	    sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 0;// 0 is RMC_DATA;
+	else
+		sendMessage.Messages.Version1Messages.SendRNDISPacket.ChannelType = 1;// 1 is RMC_CONTROL;
+
+	// Not using send buffer section
+    sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionIndex = 0xFFFFFFFF;
+    sendMessage.Messages.Version1Messages.SendRNDISPacket.SendBufferSectionSize = 0;
+
+	if (Packet->PageBufferCount)
+	{
+		ret = Device->Driver->VmbusChannelInterface.SendPacketPageBuffer(Device,
+																			Packet->PageBuffers,
+																			Packet->PageBufferCount,
+																			&sendMessage,
+																			sizeof(NVSP_MESSAGE),
+																			(ULONG_PTR)Packet);
+	}
+	else
+	{
+		ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+																&sendMessage,
+																sizeof(NVSP_MESSAGE),
+																(ULONG_PTR)Packet,
+																VmbusPacketTypeDataInBand,
+																VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+
+	}
+
+	if (ret != 0)
+	{
+		DPRINT_ERR(NETVSC, "Unable to send packet %p ret %d", Packet, ret);
+	}
+
+	InterlockedIncrement(&netDevice->NumOutstandingSends);
+	PutNetDevice(Device);
+
+	DPRINT_EXIT(NETVSC);
+	return ret;
+}
+
+
+static void
+NetVscOnReceive(
+	DEVICE_OBJECT		*Device,
+	VMPACKET_DESCRIPTOR *Packet
+	)
+{
+	NETVSC_DEVICE* netDevice;
+	VMTRANSFER_PAGE_PACKET_HEADER *vmxferpagePacket;
+	NVSP_MESSAGE *nvspPacket;
+	NETVSC_PACKET *netvscPacket=NULL;
+	LIST_ENTRY* entry;
+	ULONG_PTR start;
+	ULONG_PTR end, endVirtual;
+	//NETVSC_DRIVER_OBJECT *netvscDriver;
+	XFERPAGE_PACKET *xferpagePacket=NULL;
+	LIST_ENTRY listHead;
+
+	int i=0, j=0;
+	int count=0, bytesRemain=0;
+
+	DPRINT_ENTER(NETVSC);
+
+	netDevice = GetInboundNetDevice(Device);
+	if (!netDevice)
+	{
+		DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
+		DPRINT_EXIT(NETVSC);
+		return;
+	}
+
+	// All inbound packets other than send completion should be xfer page packet
+	if (Packet->Type != VmbusPacketTypeDataUsingTransferPages)
+	{
+		DPRINT_ERR(NETVSC, "Unknown packet type received - %d", Packet->Type);
+		PutNetDevice(Device);
+		return;
+	}
+
+	nvspPacket = (NVSP_MESSAGE*)((ULONG_PTR)Packet + (Packet->DataOffset8 << 3));
+
+	// Make sure this is a valid nvsp packet
+	if (nvspPacket->Header.MessageType != NvspMessage1TypeSendRNDISPacket )
+	{
+		DPRINT_ERR(NETVSC, "Unknown nvsp packet type received - %d", nvspPacket->Header.MessageType);
+		PutNetDevice(Device);
+		return;
+	}
+
+	DPRINT_DBG(NETVSC, "NVSP packet received - type %d", nvspPacket->Header.MessageType);
+
+	vmxferpagePacket = (VMTRANSFER_PAGE_PACKET_HEADER*)Packet;
+
+	if (vmxferpagePacket->TransferPageSetId != NETVSC_RECEIVE_BUFFER_ID)
+	{
+		DPRINT_ERR(NETVSC, "Invalid xfer page set id - expecting %x got %x", NETVSC_RECEIVE_BUFFER_ID, vmxferpagePacket->TransferPageSetId);
+		PutNetDevice(Device);
+		return;
+	}
+
+	DPRINT_DBG(NETVSC, "xfer page - range count %d", vmxferpagePacket->RangeCount);
+
+	INITIALIZE_LIST_HEAD(&listHead);
+
+	// Grab free packets (range count + 1) to represent this xfer page packet. +1 to represent
+	// the xfer page packet itself. We grab it here so that we know exactly how many we can fulfil
+	SpinlockAcquire(netDevice->ReceivePacketListLock);
+	while (!IsListEmpty(&netDevice->ReceivePacketList))
+	{
+		entry = REMOVE_HEAD_LIST(&netDevice->ReceivePacketList);
+		netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
+
+		INSERT_TAIL_LIST(&listHead, &netvscPacket->ListEntry);
+
+		if (++count == vmxferpagePacket->RangeCount + 1)
+			break;
+	}
+	SpinlockRelease(netDevice->ReceivePacketListLock);
+
+	// We need at least 2 netvsc pkts (1 to represent the xfer page and at least 1 for the range)
+	// i.e. we can handled some of the xfer page packet ranges...
+	if (count < 2)
+	{
+		DPRINT_ERR(NETVSC, "Got only %d netvsc pkt...needed %d pkts. Dropping this xfer page packet completely!", count, vmxferpagePacket->RangeCount+1);
+
+		// Return it to the freelist
+		SpinlockAcquire(netDevice->ReceivePacketListLock);
+		for (i=count; i != 0; i--)
+		{
+			entry = REMOVE_HEAD_LIST(&listHead);
+			netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
+
+			INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &netvscPacket->ListEntry);
+		}
+		SpinlockRelease(netDevice->ReceivePacketListLock);
+
+		NetVscSendReceiveCompletion(Device, vmxferpagePacket->d.TransactionId);
+
+		PutNetDevice(Device);
+		return;
+	}
+
+	// Remove the 1st packet to represent the xfer page packet itself
+	entry = REMOVE_HEAD_LIST(&listHead);
+	xferpagePacket = CONTAINING_RECORD(entry, XFERPAGE_PACKET, ListEntry);
+	xferpagePacket->Count = count - 1; // This is how much we can satisfy
+	ASSERT(xferpagePacket->Count > 0 && xferpagePacket->Count <= vmxferpagePacket->RangeCount);
+
+	if (xferpagePacket->Count != vmxferpagePacket->RangeCount)
+	{
+		DPRINT_INFO(NETVSC, "Needed %d netvsc pkts to satisy this xfer page...got %d", vmxferpagePacket->RangeCount, xferpagePacket->Count);
+	}
+
+	// Each range represents 1 RNDIS pkt that contains 1 ethernet frame
+	for (i=0; i < (count - 1); i++)
+	{
+		entry = REMOVE_HEAD_LIST(&listHead);
+		netvscPacket = CONTAINING_RECORD(entry, NETVSC_PACKET, ListEntry);
+
+		// Initialize the netvsc packet
+		netvscPacket->XferPagePacket = xferpagePacket;
+		netvscPacket->Completion.Recv.OnReceiveCompletion = NetVscOnReceiveCompletion;
+		netvscPacket->Completion.Recv.ReceiveCompletionContext = netvscPacket;
+		netvscPacket->Device = Device;
+		netvscPacket->Completion.Recv.ReceiveCompletionTid = vmxferpagePacket->d.TransactionId; // Save this so that we can send it back
+
+		netvscPacket->TotalDataBufferLength = vmxferpagePacket->Ranges[i].ByteCount;
+		netvscPacket->PageBufferCount = 1;
+
+		ASSERT(vmxferpagePacket->Ranges[i].ByteOffset + vmxferpagePacket->Ranges[i].ByteCount < netDevice->ReceiveBufferSize);
+
+		netvscPacket->PageBuffers[0].Length = vmxferpagePacket->Ranges[i].ByteCount;
+
+		start = GetPhysicalAddress((void*)((ULONG_PTR)netDevice->ReceiveBuffer + vmxferpagePacket->Ranges[i].ByteOffset));
+
+		netvscPacket->PageBuffers[0].Pfn = start >> PAGE_SHIFT;
+		endVirtual = (ULONG_PTR)netDevice->ReceiveBuffer
+		    + vmxferpagePacket->Ranges[i].ByteOffset
+		    + vmxferpagePacket->Ranges[i].ByteCount -1;
+		end = GetPhysicalAddress((void*)endVirtual);
+
+		// Calculate the page relative offset
+		netvscPacket->PageBuffers[0].Offset = vmxferpagePacket->Ranges[i].ByteOffset & (PAGE_SIZE -1);
+		if ((end >> PAGE_SHIFT) != (start>>PAGE_SHIFT)) {
+		    //Handle frame across multiple pages:
+		    netvscPacket->PageBuffers[0].Length =
+			(netvscPacket->PageBuffers[0].Pfn <<PAGE_SHIFT) + PAGE_SIZE - start;
+		    bytesRemain = netvscPacket->TotalDataBufferLength - netvscPacket->PageBuffers[0].Length;
+		    for (j=1; j<NETVSC_PACKET_MAXPAGE; j++) {
+			netvscPacket->PageBuffers[j].Offset = 0;
+			if (bytesRemain <= PAGE_SIZE) {
+			    netvscPacket->PageBuffers[j].Length = bytesRemain;
+			    bytesRemain = 0;
+			} else {
+			    netvscPacket->PageBuffers[j].Length = PAGE_SIZE;
+			    bytesRemain -= PAGE_SIZE;
+			}
+			netvscPacket->PageBuffers[j].Pfn =
+			    GetPhysicalAddress((void*)(endVirtual - bytesRemain)) >> PAGE_SHIFT;
+			netvscPacket->PageBufferCount++;
+			if (bytesRemain == 0)
+			    break;
+		    }
+		    ASSERT(bytesRemain == 0);
+		}
+		DPRINT_DBG(NETVSC, "[%d] - (abs offset %u len %u) => (pfn %llx, offset %u, len %u)",
+			i,
+			vmxferpagePacket->Ranges[i].ByteOffset,
+			vmxferpagePacket->Ranges[i].ByteCount,
+			netvscPacket->PageBuffers[0].Pfn,
+			netvscPacket->PageBuffers[0].Offset,
+			netvscPacket->PageBuffers[0].Length);
+
+		// Pass it to the upper layer
+		((NETVSC_DRIVER_OBJECT*)Device->Driver)->OnReceiveCallback(Device, netvscPacket);
+
+		NetVscOnReceiveCompletion(netvscPacket->Completion.Recv.ReceiveCompletionContext);
+	}
+
+	ASSERT(IsListEmpty(&listHead));
+
+	PutNetDevice(Device);
+	DPRINT_EXIT(NETVSC);
+}
+
+
+static void
+NetVscSendReceiveCompletion(
+	DEVICE_OBJECT	*Device,
+	UINT64			TransactionId
+	)
+{
+	NVSP_MESSAGE recvcompMessage;
+	int retries=0;
+	int ret=0;
+
+	DPRINT_DBG(NETVSC, "Sending receive completion pkt - %llx", TransactionId);
+
+	recvcompMessage.Header.MessageType = NvspMessage1TypeSendRNDISPacketComplete;
+
+	// FIXME: Pass in the status
+	recvcompMessage.Messages.Version1Messages.SendRNDISPacketComplete.Status = NvspStatusSuccess;
+
+retry_send_cmplt:
+	// Send the completion
+	ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															&recvcompMessage,
+															sizeof(NVSP_MESSAGE),
+															TransactionId,
+															VmbusPacketTypeCompletion,
+															0);
+	if (ret == 0) // success
+	{
+		// no-op
+	}
+	else if (ret == -1) // no more room...wait a bit and attempt to retry 3 times
+	{
+		retries++;
+		DPRINT_ERR(NETVSC, "unable to send receive completion pkt (tid %llx)...retrying %d", TransactionId, retries);
+
+		if (retries < 4)
+		{
+			Sleep(100);
+			goto retry_send_cmplt;
+		}
+		else
+		{
+			DPRINT_ERR(NETVSC, "unable to send receive completion pkt (tid %llx)...give up retrying", TransactionId);
+		}
+	}
+	else
+	{
+		DPRINT_ERR(NETVSC, "unable to send receive completion pkt - %llx", TransactionId);
+	}
+}
+
+//
+// Send a receive completion packet to RNDIS device (ie NetVsp)
+//
+static void
+NetVscOnReceiveCompletion(
+	PVOID Context)
+{
+	NETVSC_PACKET *packet = (NETVSC_PACKET*)Context;
+	DEVICE_OBJECT *device = (DEVICE_OBJECT*)packet->Device;
+	NETVSC_DEVICE* netDevice;
+	UINT64	transactionId=0;
+	BOOL fSendReceiveComp = FALSE;
+
+	DPRINT_ENTER(NETVSC);
+
+	ASSERT(packet->XferPagePacket);
+
+	// Even though it seems logical to do a GetOutboundNetDevice() here to send out receive completion,
+	// we are using GetInboundNetDevice() since we may have disable outbound traffic already.
+	netDevice = GetInboundNetDevice(device);
+	if (!netDevice)
+	{
+		DPRINT_ERR(NETVSC, "unable to get net device...device being destroyed?");
+		DPRINT_EXIT(NETVSC);
+		return;
+	}
+
+	// Overloading use of the lock.
+	SpinlockAcquire(netDevice->ReceivePacketListLock);
+
+	ASSERT(packet->XferPagePacket->Count > 0);
+	packet->XferPagePacket->Count--;
+
+	// Last one in the line that represent 1 xfer page packet.
+	// Return the xfer page packet itself to the freelist
+	if (packet->XferPagePacket->Count == 0)
+	{
+		fSendReceiveComp = TRUE;
+		transactionId = packet->Completion.Recv.ReceiveCompletionTid;
+
+		INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &packet->XferPagePacket->ListEntry);
+	}
+
+	// Put the packet back
+	INSERT_TAIL_LIST(&netDevice->ReceivePacketList, &packet->ListEntry);
+	SpinlockRelease(netDevice->ReceivePacketListLock);
+
+	// Send a receive completion for the xfer page packet
+	if (fSendReceiveComp)
+	{
+		NetVscSendReceiveCompletion(device, transactionId);
+	}
+
+	PutNetDevice(device);
+	DPRINT_EXIT(NETVSC);
+}
+
+
+
+void
+NetVscOnChannelCallback(
+	PVOID Context
+	)
+{
+	const int netPacketSize=2048;
+	int ret=0;
+	DEVICE_OBJECT *device=(DEVICE_OBJECT*)Context;
+	NETVSC_DEVICE *netDevice;
+
+	UINT32 bytesRecvd;
+	UINT64 requestId;
+	UCHAR packet[netPacketSize];
+	VMPACKET_DESCRIPTOR *desc;
+	UCHAR	*buffer=packet;
+	int		bufferlen=netPacketSize;
+
+
+	DPRINT_ENTER(NETVSC);
+
+	ASSERT(device);
+
+	netDevice = GetInboundNetDevice(device);
+	if (!netDevice)
+	{
+		DPRINT_ERR(NETVSC, "net device (%p) shutting down...ignoring inbound packets", netDevice);
+		DPRINT_EXIT(NETVSC);
+		return;
+	}
+
+	do
+	{
+		ret = device->Driver->VmbusChannelInterface.RecvPacketRaw(device,
+																	buffer,
+																	bufferlen,
+																	&bytesRecvd,
+																	&requestId);
+
+		if (ret == 0)
+		{
+			if (bytesRecvd > 0)
+			{
+				DPRINT_DBG(NETVSC, "receive %d bytes, tid %llx", bytesRecvd, requestId);
+
+				desc = (VMPACKET_DESCRIPTOR*)buffer;
+				switch (desc->Type)
+				{
+					case VmbusPacketTypeCompletion:
+						NetVscOnSendCompletion(device, desc);
+						break;
+
+					case VmbusPacketTypeDataUsingTransferPages:
+						NetVscOnReceive(device, desc);
+						break;
+
+					default:
+						DPRINT_ERR(NETVSC, "unhandled packet type %d, tid %llx len %d\n", desc->Type, requestId, bytesRecvd);
+						break;
+				}
+
+				// reset
+				if (bufferlen > netPacketSize)
+				{
+					MemFree(buffer);
+
+					buffer = packet;
+					bufferlen = netPacketSize;
+				}
+			}
+			else
+			{
+				//DPRINT_DBG(NETVSC, "nothing else to read...");
+
+				// reset
+				if (bufferlen > netPacketSize)
+				{
+					MemFree(buffer);
+
+					buffer = packet;
+					bufferlen = netPacketSize;
+				}
+
+				break;
+			}
+		}
+		else if (ret == -2) // Handle large packet
+		{
+			buffer = MemAllocAtomic(bytesRecvd);
+			if (buffer == NULL)
+			{
+				// Try again next time around
+				DPRINT_ERR(NETVSC, "unable to allocate buffer of size (%d)!!", bytesRecvd);
+				break;
+			}
+
+			bufferlen = bytesRecvd;
+		}
+		else
+		{
+			ASSERT(0);
+		}
+	} while (1);
+
+	PutNetDevice(device);
+	DPRINT_EXIT(NETVSC);
+	return;
+}

720 lines not on this page · raw message

91 lines not on this page · raw message

690 lines not on this page · raw message

61 lines not on this page · raw message

@@ -0,0 +1,967 @@
+/*
+ *
+ * Copyright (c) 2009, Microsoft Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Authors:
+ *   Haiyang Zhang <[email protected]>
+ *   Hank Janssen  <[email protected]>
+ *
+ */
+
+
+#include "logging.h"
+
+#include "StorVscApi.h"
+#include "VmbusPacketFormat.h"
+#include "vstorage.h"
+
+
+//
+// #defines
+//
+
+//
+// Data types
+//
+
+typedef struct _STORVSC_REQUEST_EXTENSION {
+	//LIST_ENTRY						ListEntry;
+
+	STORVSC_REQUEST					*Request;
+	DEVICE_OBJECT					*Device;
+
+	// Synchronize the request/response if needed
+	HANDLE							WaitEvent;
+
+	VSTOR_PACKET					VStorPacket;
+} STORVSC_REQUEST_EXTENSION;
+
+
+// A storvsc device is a device object that contains a vmbus channel
+typedef struct _STORVSC_DEVICE{
+	DEVICE_OBJECT				*Device;
+
+	int							RefCount; // 0 indicates the device is being destroyed
+
+	int							NumOutstandingRequests;
+
+	//  Each unique Port/Path/Target represents 1 channel ie scsi controller. In reality, the pathid, targetid is always 0
+	// and the port is set by us
+	ULONG						PortNumber;
+    UCHAR						PathId;
+    UCHAR						TargetId;
+
+	//LIST_ENTRY					OutstandingRequestList;
+	//HANDLE						OutstandingRequestLock;
+
+	// Used for vsc/vsp channel reset process
+	STORVSC_REQUEST_EXTENSION	InitRequest;
+
+	STORVSC_REQUEST_EXTENSION	ResetRequest;
+
+} STORVSC_DEVICE;
+
+
+//
+// Globals
+//
+static const char* gDriverName="storvsc";
+
+//{ba6163d9-04a1-4d29-b605-72e2ffb1dc7f}
+static const GUID gStorVscDeviceType={
+	.Data = {0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d, 0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f}
+};
+
+//
+// Internal routines
+//
+static int
+StorVscOnDeviceAdd(
+	DEVICE_OBJECT	*Device,
+	void			*AdditionalInfo
+	);
+
+static int
+StorVscOnDeviceRemove(
+	DEVICE_OBJECT	*Device
+	);
+
+static int
+StorVscOnIORequest(
+	DEVICE_OBJECT	*Device,
+	STORVSC_REQUEST	*Request
+	);
+
+static int
+StorVscOnHostReset(
+	DEVICE_OBJECT	*Device
+	);
+
+static void
+StorVscOnCleanup(
+	DRIVER_OBJECT	*Device
+	);
+
+static void
+StorVscOnChannelCallback(
+	PVOID Context
+	);
+
+static void
+StorVscOnIOCompletion(
+	DEVICE_OBJECT	*Device,
+	VSTOR_PACKET	*VStorPacket,
+	STORVSC_REQUEST_EXTENSION *RequestExt
+	);
+
+static void
+StorVscOnReceive(
+	DEVICE_OBJECT	*Device,
+	VSTOR_PACKET	*VStorPacket,
+	STORVSC_REQUEST_EXTENSION *RequestExt
+	);
+
+static int
+StorVscConnectToVsp(
+	DEVICE_OBJECT	*Device
+	);
+
+static inline STORVSC_DEVICE* AllocStorDevice(DEVICE_OBJECT *Device)
+{
+	STORVSC_DEVICE *storDevice;
+
+	storDevice = MemAllocZeroed(sizeof(STORVSC_DEVICE));
+	if (!storDevice)
+		return NULL;
+
+	// Set to 2 to allow both inbound and outbound traffics
+	// (ie GetStorDevice() and MustGetStorDevice()) to proceed.
+	InterlockedCompareExchange(&storDevice->RefCount, 2, 0);
+
+	storDevice->Device = Device;
+	Device->Extension = storDevice;
+
+	return storDevice;
+}
+
+static inline void FreeStorDevice(STORVSC_DEVICE *Device)
+{
+	ASSERT(Device->RefCount == 0);
+	MemFree(Device);
+}
+
+// Get the stordevice object iff exists and its refcount > 1
+static inline STORVSC_DEVICE* GetStorDevice(DEVICE_OBJECT *Device)
+{
+	STORVSC_DEVICE *storDevice;
+
+	storDevice = (STORVSC_DEVICE*)Device->Extension;
+	if (storDevice && storDevice->RefCount > 1)
+	{
+		InterlockedIncrement(&storDevice->RefCount);
+	}
+	else
+	{
+		storDevice = NULL;
+	}
+
+	return storDevice;
+}
+
+// Get the stordevice object iff exists and its refcount > 0
+static inline STORVSC_DEVICE* MustGetStorDevice(DEVICE_OBJECT *Device)
+{
+	STORVSC_DEVICE *storDevice;
+
+	storDevice = (STORVSC_DEVICE*)Device->Extension;
+	if (storDevice && storDevice->RefCount)
+	{
+		InterlockedIncrement(&storDevice->RefCount);
+	}
+	else
+	{
+		storDevice = NULL;
+	}
+
+	return storDevice;
+}
+
+static inline void PutStorDevice(DEVICE_OBJECT *Device)
+{
+	STORVSC_DEVICE *storDevice;
+
+	storDevice = (STORVSC_DEVICE*)Device->Extension;
+	ASSERT(storDevice);
+
+	InterlockedDecrement(&storDevice->RefCount);
+	ASSERT(storDevice->RefCount);
+}
+
+// Drop ref count to 1 to effectively disable GetStorDevice()
+static inline STORVSC_DEVICE* ReleaseStorDevice(DEVICE_OBJECT *Device)
+{
+	STORVSC_DEVICE *storDevice;
+
+	storDevice = (STORVSC_DEVICE*)Device->Extension;
+	ASSERT(storDevice);
+
+	// Busy wait until the ref drop to 2, then set it to 1
+	while (InterlockedCompareExchange(&storDevice->RefCount, 1, 2) != 2)
+	{
+		Sleep(100);
+	}
+
+	return storDevice;
+}
+
+// Drop ref count to 0. No one can use StorDevice object.
+static inline STORVSC_DEVICE* FinalReleaseStorDevice(DEVICE_OBJECT *Device)
+{
+	STORVSC_DEVICE *storDevice;
+
+	storDevice = (STORVSC_DEVICE*)Device->Extension;
+	ASSERT(storDevice);
+
+	// Busy wait until the ref drop to 1, then set it to 0
+	while (InterlockedCompareExchange(&storDevice->RefCount, 0, 1) != 1)
+	{
+		Sleep(100);
+	}
+
+	Device->Extension = NULL;
+	return storDevice;
+}
+
+/*++;
+
+
+Name:
+	StorVscInitialize()
+
+Description:
+	Main entry point
+
+--*/
+int
+StorVscInitialize(
+	DRIVER_OBJECT *Driver
+	)
+{
+	STORVSC_DRIVER_OBJECT* storDriver = (STORVSC_DRIVER_OBJECT*)Driver;
+	int ret=0;
+
+	DPRINT_ENTER(STORVSC);
+
+	DPRINT_DBG(STORVSC, "sizeof(STORVSC_REQUEST)=%d sizeof(STORVSC_REQUEST_EXTENSION)=%d sizeof(VSTOR_PACKET)=%d, sizeof(VMSCSI_REQUEST)=%d",
+		sizeof(STORVSC_REQUEST), sizeof(STORVSC_REQUEST_EXTENSION), sizeof(VSTOR_PACKET), sizeof(VMSCSI_REQUEST));
+
+	// Make sure we are at least 2 pages since 1 page is used for control
+	ASSERT(storDriver->RingBufferSize >= (PAGE_SIZE << 1));
+
+	Driver->name = gDriverName;
+	memcpy(&Driver->deviceType, &gStorVscDeviceType, sizeof(GUID));
+
+	storDriver->RequestExtSize			= sizeof(STORVSC_REQUEST_EXTENSION);
+
+	// Divide the ring buffer data size (which is 1 page less than the ring buffer size since that page is reserved for the ring buffer indices)
+	// by the max request size (which is VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER + VSTOR_PACKET + UINT64)
+	storDriver->MaxOutstandingRequestsPerChannel =
+		((storDriver->RingBufferSize - PAGE_SIZE) / ALIGN_UP(MAX_MULTIPAGE_BUFFER_PACKET + sizeof(VSTOR_PACKET) + sizeof(UINT64),sizeof(UINT64)));
+
+	DPRINT_INFO(STORVSC, "max io %u, currently %u\n", storDriver->MaxOutstandingRequestsPerChannel, STORVSC_MAX_IO_REQUESTS);
+
+	// Setup the dispatch table
+	storDriver->Base.OnDeviceAdd			= StorVscOnDeviceAdd;
+	storDriver->Base.OnDeviceRemove		= StorVscOnDeviceRemove;
+	storDriver->Base.OnCleanup			= StorVscOnCleanup;
+
+	storDriver->OnIORequest				= StorVscOnIORequest;
+	storDriver->OnHostReset				= StorVscOnHostReset;
+
+	DPRINT_EXIT(STORVSC);
+
+	return ret;
+}
+
+/*++
+
+Name:
+	StorVscOnDeviceAdd()
+
+Description:
+	Callback when the device belonging to this driver is added
+
+--*/
+int
+StorVscOnDeviceAdd(
+	DEVICE_OBJECT	*Device,
+	void			*AdditionalInfo
+	)
+{
+	int ret=0;
+	STORVSC_DEVICE *storDevice;
+	//VMSTORAGE_CHANNEL_PROPERTIES *props;
+	STORVSC_DEVICE_INFO *deviceInfo = (STORVSC_DEVICE_INFO*)AdditionalInfo;
+
+	DPRINT_ENTER(STORVSC);
+
+	storDevice = AllocStorDevice(Device);
+	if (!storDevice)
+	{
+		ret = -1;
+		goto Cleanup;
+	}
+
+	// Save the channel properties to our storvsc channel
+	//props = (VMSTORAGE_CHANNEL_PROPERTIES*) channel->offerMsg.Offer.u.Standard.UserDefined;
+
+	// FIXME:
+	// If we support more than 1 scsi channel, we need to set the port number here
+	// to the scsi channel but how do we get the scsi channel prior to the bus scan
+	/*storChannel->PortNumber = 0;
+	storChannel->PathId = props->PathId;
+	storChannel->TargetId = props->TargetId;*/
+
+	storDevice->PortNumber = deviceInfo->PortNumber;
+	// Send it back up
+	ret = StorVscConnectToVsp(Device);
+
+	//deviceInfo->PortNumber = storDevice->PortNumber;
+	deviceInfo->PathId = storDevice->PathId;
+	deviceInfo->TargetId = storDevice->TargetId;
+
+	DPRINT_DBG(STORVSC, "assigned port %u, path %u target %u\n", storDevice->PortNumber, storDevice->PathId, storDevice->TargetId);
+
+Cleanup:
+	DPRINT_EXIT(STORVSC);
+
+	return ret;
+}
+
+static int StorVscChannelInit(DEVICE_OBJECT *Device)
+{
+	int ret=0;
+	STORVSC_DEVICE *storDevice;
+	STORVSC_REQUEST_EXTENSION *request;
+	VSTOR_PACKET *vstorPacket;
+
+	storDevice = GetStorDevice(Device);
+	if (!storDevice)
+	{
+		DPRINT_ERR(STORVSC, "unable to get stor device...device being destroyed?");
+		DPRINT_EXIT(STORVSC);
+		return -1;
+	}
+
+	request = &storDevice->InitRequest;
+	vstorPacket = &request->VStorPacket;
+
+	// Now, initiate the vsc/vsp initialization protocol on the open channel
+
+	memset(request, sizeof(STORVSC_REQUEST_EXTENSION), 0);
+	request->WaitEvent = WaitEventCreate();
+
+	vstorPacket->Operation = VStorOperationBeginInitialization;
+	vstorPacket->Flags = REQUEST_COMPLETION_FLAG;
+
+	/*SpinlockAcquire(gDriverExt.packetListLock);
+	INSERT_TAIL_LIST(&gDriverExt.packetList, &packet->listEntry.entry);
+	SpinlockRelease(gDriverExt.packetListLock);*/
+
+	DPRINT_INFO(STORVSC, "BEGIN_INITIALIZATION_OPERATION...");
+
+	ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															vstorPacket,
+															sizeof(VSTOR_PACKET),
+															(ULONG_PTR)request,
+															VmbusPacketTypeDataInBand,
+															VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+	if ( ret != 0)
+	{
+		DPRINT_ERR(STORVSC, "unable to send BEGIN_INITIALIZATION_OPERATION");
+		goto Cleanup;
+	}
+
+	WaitEventWait(request->WaitEvent);
+
+	if (vstorPacket->Operation != VStorOperationCompleteIo || vstorPacket->Status != 0)
+	{
+		DPRINT_ERR(STORVSC, "BEGIN_INITIALIZATION_OPERATION failed (op %d status 0x%x)", vstorPacket->Operation, vstorPacket->Status);
+		goto Cleanup;
+	}
+
+	DPRINT_INFO(STORVSC, "QUERY_PROTOCOL_VERSION_OPERATION...");
+
+	// reuse the packet for version range supported
+	memset(vstorPacket, sizeof(VSTOR_PACKET), 0);
+	vstorPacket->Operation = VStorOperationQueryProtocolVersion;
+	vstorPacket->Flags = REQUEST_COMPLETION_FLAG;
+
+    vstorPacket->Version.MajorMinor = VMSTOR_PROTOCOL_VERSION_CURRENT;
+    FILL_VMSTOR_REVISION(vstorPacket->Version.Revision);
+
+	ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															vstorPacket,
+															sizeof(VSTOR_PACKET),
+															(ULONG_PTR)request,
+															VmbusPacketTypeDataInBand,
+															VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+	if ( ret != 0)
+	{
+		DPRINT_ERR(STORVSC, "unable to send BEGIN_INITIALIZATION_OPERATION");
+		goto Cleanup;
+	}
+
+	WaitEventWait(request->WaitEvent);
+
+	// TODO: Check returned version
+	if (vstorPacket->Operation != VStorOperationCompleteIo || vstorPacket->Status != 0)
+	{
+		DPRINT_ERR(STORVSC, "QUERY_PROTOCOL_VERSION_OPERATION failed (op %d status 0x%x)", vstorPacket->Operation, vstorPacket->Status);
+		goto Cleanup;
+	}
+
+	// Query channel properties
+	DPRINT_INFO(STORVSC, "QUERY_PROPERTIES_OPERATION...");
+
+	memset(vstorPacket, sizeof(VSTOR_PACKET), 0);
+    vstorPacket->Operation = VStorOperationQueryProperties;
+	vstorPacket->Flags = REQUEST_COMPLETION_FLAG;
+    vstorPacket->StorageChannelProperties.PortNumber = storDevice->PortNumber;
+
+	ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															vstorPacket,
+															sizeof(VSTOR_PACKET),
+															(ULONG_PTR)request,
+															VmbusPacketTypeDataInBand,
+															VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+
+	if ( ret != 0)
+	{
+		DPRINT_ERR(STORVSC, "unable to send QUERY_PROPERTIES_OPERATION");
+		goto Cleanup;
+	}
+
+	WaitEventWait(request->WaitEvent);
+
+	// TODO: Check returned version
+	if (vstorPacket->Operation != VStorOperationCompleteIo || vstorPacket->Status != 0)
+	{
+		DPRINT_ERR(STORVSC, "QUERY_PROPERTIES_OPERATION failed (op %d status 0x%x)", vstorPacket->Operation, vstorPacket->Status);
+		goto Cleanup;
+	}
+
+	//storDevice->PortNumber = vstorPacket->StorageChannelProperties.PortNumber;
+	storDevice->PathId = vstorPacket->StorageChannelProperties.PathId;
+	storDevice->TargetId = vstorPacket->StorageChannelProperties.TargetId;
+
+	DPRINT_DBG(STORVSC, "channel flag 0x%x, max xfer len 0x%x", vstorPacket->StorageChannelProperties.Flags, vstorPacket->StorageChannelProperties.MaxTransferBytes);
+
+	DPRINT_INFO(STORVSC, "END_INITIALIZATION_OPERATION...");
+
+	memset(vstorPacket, sizeof(VSTOR_PACKET), 0);
+    vstorPacket->Operation = VStorOperationEndInitialization;
+	vstorPacket->Flags = REQUEST_COMPLETION_FLAG;
+
+	ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															vstorPacket,
+															sizeof(VSTOR_PACKET),
+															(ULONG_PTR)request,
+															VmbusPacketTypeDataInBand,
+															VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+
+	if ( ret != 0)
+	{
+		DPRINT_ERR(STORVSC, "unable to send END_INITIALIZATION_OPERATION");
+		goto Cleanup;
+	}
+
+	WaitEventWait(request->WaitEvent);
+
+	if (vstorPacket->Operation != VStorOperationCompleteIo || vstorPacket->Status != 0)
+	{
+		DPRINT_ERR(STORVSC, "END_INITIALIZATION_OPERATION failed (op %d status 0x%x)", vstorPacket->Operation, vstorPacket->Status);
+		goto Cleanup;
+	}
+
+	DPRINT_INFO(STORVSC, "**** storage channel up and running!! ****");
+
+Cleanup:
+	if (request->WaitEvent)
+	{
+		WaitEventClose(request->WaitEvent);
+		request->WaitEvent = NULL;
+	}
+
+	PutStorDevice(Device);
+
+	DPRINT_EXIT(STORVSC);
+	return ret;
+}
+
+
+int
+StorVscConnectToVsp(
+	DEVICE_OBJECT	*Device
+	)
+{
+	int ret=0;
+    VMSTORAGE_CHANNEL_PROPERTIES props;
+
+	STORVSC_DRIVER_OBJECT *storDriver = (STORVSC_DRIVER_OBJECT*) Device->Driver;;
+
+	memset(&props, sizeof(VMSTORAGE_CHANNEL_PROPERTIES), 0);
+
+	// Open the channel
+	ret = Device->Driver->VmbusChannelInterface.Open(Device,
+		storDriver->RingBufferSize,
+		storDriver->RingBufferSize,
+		(PVOID)&props,
+		sizeof(VMSTORAGE_CHANNEL_PROPERTIES),
+		StorVscOnChannelCallback,
+		Device
+		);
+
+	DPRINT_DBG(STORVSC, "storage props: path id %d, tgt id %d, max xfer %d", props.PathId, props.TargetId, props.MaxTransferBytes);
+
+	if (ret != 0)
+	{
+		DPRINT_ERR(STORVSC, "unable to open channel: %d", ret);
+		return -1;
+	}
+
+	ret = StorVscChannelInit(Device);
+
+	return ret;
+}
+
+
+/*++
+
+Name:
+	StorVscOnDeviceRemove()
+
+Description:
+	Callback when the our device is being removed
+
+--*/
+int
+StorVscOnDeviceRemove(
+	DEVICE_OBJECT *Device
+	)
+{
+	STORVSC_DEVICE *storDevice;
+	int ret=0;
+
+	DPRINT_ENTER(STORVSC);
+
+	DPRINT_INFO(STORVSC, "disabling storage device (%p)...", Device->Extension);
+
+	storDevice = ReleaseStorDevice(Device);
+
+	// At this point, all outbound traffic should be disable. We only allow inbound traffic (responses) to proceed
+	// so that outstanding requests can be completed.
+	while (storDevice->NumOutstandingRequests)
+	{
+		DPRINT_INFO(STORVSC, "waiting for %d requests to complete...", storDevice->NumOutstandingRequests);
+
+		Sleep(100);
+	}
+
+	DPRINT_INFO(STORVSC, "removing storage device (%p)...", Device->Extension);
+
+	storDevice = FinalReleaseStorDevice(Device);
+
+	DPRINT_INFO(STORVSC, "storage device (%p) safe to remove", storDevice);
+
+	// Close the channel
+	Device->Driver->VmbusChannelInterface.Close(Device);
+
+	FreeStorDevice(storDevice);
+
+	DPRINT_EXIT(STORVSC);
+	return ret;
+}
+
+
+//static void
+//StorVscOnTargetRescan(
+//	void *Context
+//	)
+//{
+//	DEVICE_OBJECT *device=(DEVICE_OBJECT*)Context;
+//	STORVSC_DRIVER_OBJECT *storDriver;
+//
+//	DPRINT_ENTER(STORVSC);
+//
+//	storDriver = (STORVSC_DRIVER_OBJECT*) device->Driver;
+//	storDriver->OnHostRescan(device);
+//
+//	DPRINT_EXIT(STORVSC);
+//}
+
+int
+StorVscOnHostReset(
+	DEVICE_OBJECT *Device
+	)
+{
+	int ret=0;
+
+	STORVSC_DEVICE *storDevice;
+	STORVSC_REQUEST_EXTENSION *request;
+	VSTOR_PACKET *vstorPacket;
+
+	DPRINT_ENTER(STORVSC);
+
+	DPRINT_INFO(STORVSC, "resetting host adapter...");
+
+	storDevice = GetStorDevice(Device);
+	if (!storDevice)
+	{
+		DPRINT_ERR(STORVSC, "unable to get stor device...device being destroyed?");
+		DPRINT_EXIT(STORVSC);
+		return -1;
+	}
+
+	request = &storDevice->ResetRequest;
+	vstorPacket = &request->VStorPacket;
+
+	request->WaitEvent = WaitEventCreate();
+
+    vstorPacket->Operation = VStorOperationResetBus;
+    vstorPacket->Flags = REQUEST_COMPLETION_FLAG;
+    vstorPacket->VmSrb.PathId = storDevice->PathId;
+
+	ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															vstorPacket,
+															sizeof(VSTOR_PACKET),
+															(ULONG_PTR)&storDevice->ResetRequest,
+															VmbusPacketTypeDataInBand,
+															VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+	if (ret != 0)
+	{
+		DPRINT_ERR(STORVSC, "Unable to send reset packet %p ret %d", vstorPacket, ret);
+		goto Cleanup;
+	}
+
+	// FIXME: Add a timeout
+	WaitEventWait(request->WaitEvent);
+
+	WaitEventClose(request->WaitEvent);
+	DPRINT_INFO(STORVSC, "host adapter reset completed");
+
+	// At this point, all outstanding requests in the adapter should have been flushed out and return to us
+
+Cleanup:
+	PutStorDevice(Device);
+	DPRINT_EXIT(STORVSC);
+	return ret;
+}
+
+/*++
+
+Name:
+	StorVscOnIORequest()
+
+Description:
+	Callback to initiate an I/O request
+
+--*/
+int
+StorVscOnIORequest(
+	DEVICE_OBJECT	*Device,
+	STORVSC_REQUEST	*Request
+	)
+{
+	STORVSC_DEVICE *storDevice;
+	STORVSC_REQUEST_EXTENSION* requestExtension = (STORVSC_REQUEST_EXTENSION*) Request->Extension;
+	VSTOR_PACKET* vstorPacket =&requestExtension->VStorPacket;
+	int ret=0;
+
+	DPRINT_ENTER(STORVSC);
+
+	storDevice = GetStorDevice(Device);
+
+	DPRINT_DBG(STORVSC, "enter - Device %p, DeviceExt %p, Request %p, Extension %p",
+		Device, storDevice, Request, requestExtension);
+
+	DPRINT_DBG(STORVSC, "req %p len %d bus %d, target %d, lun %d cdblen %d",
+		Request, Request->DataBuffer.Length, Request->Bus, Request->TargetId, Request->LunId, Request->CdbLen);
+
+	if (!storDevice)
+	{
+		DPRINT_ERR(STORVSC, "unable to get stor device...device being destroyed?");
+		DPRINT_EXIT(STORVSC);
+		return -2;
+	}
+
+	//PrintBytes(Request->Cdb, Request->CdbLen);
+
+	requestExtension->Request = Request;
+	requestExtension->Device  = Device;
+
+	memset(vstorPacket, 0 , sizeof(VSTOR_PACKET));
+
+	vstorPacket->Flags |= REQUEST_COMPLETION_FLAG;
+
+    vstorPacket->VmSrb.Length = sizeof(VMSCSI_REQUEST);
+
+	vstorPacket->VmSrb.PortNumber = Request->Host;
+    vstorPacket->VmSrb.PathId = Request->Bus;
+    vstorPacket->VmSrb.TargetId = Request->TargetId;
+    vstorPacket->VmSrb.Lun = Request->LunId;
+
+	vstorPacket->VmSrb.SenseInfoLength = SENSE_BUFFER_SIZE;
+
+	// Copy over the scsi command descriptor block
+    vstorPacket->VmSrb.CdbLength = Request->CdbLen;
+	memcpy(&vstorPacket->VmSrb.Cdb, Request->Cdb, Request->CdbLen);
+
+	vstorPacket->VmSrb.DataIn = Request->Type;
+	vstorPacket->VmSrb.DataTransferLength = Request->DataBuffer.Length;
+
+	vstorPacket->Operation = VStorOperationExecuteSRB;
+
+	DPRINT_DBG(STORVSC, "srb - len %d port %d, path %d, target %d, lun %d senselen %d cdblen %d",
+		vstorPacket->VmSrb.Length,
+		vstorPacket->VmSrb.PortNumber,
+		vstorPacket->VmSrb.PathId,
+		vstorPacket->VmSrb.TargetId,
+		vstorPacket->VmSrb.Lun,
+		vstorPacket->VmSrb.SenseInfoLength,
+		vstorPacket->VmSrb.CdbLength);
+
+	if (requestExtension->Request->DataBuffer.Length)
+	{
+		ret = Device->Driver->VmbusChannelInterface.SendPacketMultiPageBuffer(Device,
+				&requestExtension->Request->DataBuffer,
+				vstorPacket,
+				sizeof(VSTOR_PACKET),
+				(ULONG_PTR)requestExtension);
+	}
+	else
+	{
+		ret = Device->Driver->VmbusChannelInterface.SendPacket(Device,
+															vstorPacket,
+															sizeof(VSTOR_PACKET),
+															(ULONG_PTR)requestExtension,
+															VmbusPacketTypeDataInBand,
+															VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+	}
+
+	if (ret != 0)
+	{
+		DPRINT_DBG(STORVSC, "Unable to send packet %p ret %d", vstorPacket, ret);
+	}
+
+	InterlockedIncrement(&storDevice->NumOutstandingRequests);
+
+	PutStorDevice(Device);
+
+	DPRINT_EXIT(STORVSC);
+	return ret;
+}
+
+/*++
+
+Name:
+	StorVscOnCleanup()
+
+Description:
+	Perform any cleanup when the driver is removed
+
+--*/
+void
+StorVscOnCleanup(
+	DRIVER_OBJECT *Driver
+	)
+{
+	DPRINT_ENTER(STORVSC);
+	DPRINT_EXIT(STORVSC);
+}
+
+
+static void
+StorVscOnIOCompletion(
+	DEVICE_OBJECT	*Device,
+	VSTOR_PACKET	*VStorPacket,
+	STORVSC_REQUEST_EXTENSION *RequestExt
+	)
+{
+	STORVSC_REQUEST *request;
+	STORVSC_DEVICE *storDevice;
+
+	DPRINT_ENTER(STORVSC);
+
+	storDevice = MustGetStorDevice(Device);
+	if (!storDevice)
+	{
+		DPRINT_ERR(STORVSC, "unable to get stor device...device being destroyed?");
+		DPRINT_EXIT(STORVSC);
+		return;
+	}
+
+	DPRINT_DBG(STORVSC, "IO_COMPLETE_OPERATION - request extension %p completed bytes xfer %u",
+		RequestExt, VStorPacket->VmSrb.DataTransferLength);
+
+	ASSERT(RequestExt != NULL);
+	ASSERT(RequestExt->Request != NULL);
+
+	request = RequestExt->Request;
+
+	ASSERT(request->OnIOCompletion != NULL);
+
+	// Copy over the status...etc
+	request->Status = VStorPacket->VmSrb.ScsiStatus;
+
+	if (request->Status != 0 || VStorPacket->VmSrb.SrbStatus != 1)
+	{
+		DPRINT_WARN(STORVSC, "cmd 0x%x scsi status 0x%x srb status 0x%x\n",
+			request->Cdb[0],
+			VStorPacket->VmSrb.ScsiStatus,
+			VStorPacket->VmSrb.SrbStatus);
+	}
+
+	if ((request->Status & 0xFF) == 0x02) // CHECK_CONDITION
+	{
+		if (VStorPacket->VmSrb.SrbStatus & 0x80) // autosense data available
+		{
+			DPRINT_WARN(STORVSC, "storvsc pkt %p autosense data valid - len %d\n",
+				RequestExt, VStorPacket->VmSrb.SenseInfoLength);
+
+			ASSERT(VStorPacket->VmSrb.SenseInfoLength <=  request->SenseBufferSize);
+			memcpy(request->SenseBuffer,
+				VStorPacket->VmSrb.SenseData,
+				VStorPacket->VmSrb.SenseInfoLength);
+
+			request->SenseBufferSize = VStorPacket->VmSrb.SenseInfoLength;
+		}
+	}
+
+	// TODO:
+	request->BytesXfer = VStorPacket->VmSrb.DataTransferLength;
+
+	request->OnIOCompletion(request);
+
+	InterlockedDecrement(&storDevice->NumOutstandingRequests);
+
+	PutStorDevice(Device);
+
+	DPRINT_EXIT(STORVSC);
+}
+
+
+static void
+StorVscOnReceive(
+	DEVICE_OBJECT	*Device,
+	VSTOR_PACKET	*VStorPacket,
+	STORVSC_REQUEST_EXTENSION *RequestExt
+	)
+{
+	switch(VStorPacket->Operation)
+	{
+		case VStorOperationCompleteIo:
+
+			DPRINT_DBG(STORVSC, "IO_COMPLETE_OPERATION");
+			StorVscOnIOCompletion(Device, VStorPacket, RequestExt);
+			break;
+
+		//case ENUMERATE_DEVICE_OPERATION:
+
+		//	DPRINT_INFO(STORVSC, "ENUMERATE_DEVICE_OPERATION");
+
+		//	StorVscOnTargetRescan(Device);
+		//	break;
+
+        case VStorOperationRemoveDevice:
+
+			DPRINT_INFO(STORVSC, "REMOVE_DEVICE_OPERATION");
+			// TODO:
+			break;
+
+		default:
+			DPRINT_INFO(STORVSC, "Unknown operation received - %d", VStorPacket->Operation);
+			break;
+	}
+}
+
+void
+StorVscOnChannelCallback(
+	PVOID Context
+	)
+{
+	int ret=0;
+	DEVICE_OBJECT *device = (DEVICE_OBJECT*)Context;
+	STORVSC_DEVICE *storDevice;
+	UINT32 bytesRecvd;
+	UINT64 requestId;
+	UCHAR packet[ALIGN_UP(sizeof(VSTOR_PACKET),8)];
+	STORVSC_REQUEST_EXTENSION *request;
+
+	DPRINT_ENTER(STORVSC);
+
+	ASSERT(device);
+
+	storDevice = MustGetStorDevice(device);
+	if (!storDevice)
+	{
+		DPRINT_ERR(STORVSC, "unable to get stor device...device being destroyed?");
+		DPRINT_EXIT(STORVSC);
+		return;
+	}
+
+	do
+	{
+		ret = device->Driver->VmbusChannelInterface.RecvPacket(device,
+																packet,
+																ALIGN_UP(sizeof(VSTOR_PACKET),8),
+																&bytesRecvd,
+																&requestId);
+		if (ret == 0 && bytesRecvd > 0)
+		{
+			DPRINT_DBG(STORVSC, "receive %d bytes - tid %llx", bytesRecvd, requestId);
+
+			//ASSERT(bytesRecvd == sizeof(VSTOR_PACKET));
+
+			request = (STORVSC_REQUEST_EXTENSION*)(ULONG_PTR)requestId;
+			ASSERT(request);
+
+			//if (vstorPacket.Flags & SYNTHETIC_FLAG)
+			if ((request == &storDevice->InitRequest) || (request == &storDevice->ResetRequest))
+			{
+				//DPRINT_INFO(STORVSC, "reset completion - operation %u status %u", vstorPacket.Operation, vstorPacket.Status);
+
+				memcpy(&request->VStorPacket, packet, sizeof(VSTOR_PACKET));
+
+				WaitEventSet(request->WaitEvent);
+			}
+			else
+			{
+				StorVscOnReceive(device, (VSTOR_PACKET*)packet, request);
+			}
+		}
+		else
+		{
+			//DPRINT_DBG(STORVSC, "nothing else to read...");
+			break;
+		}
+	} while (1);
+
+	PutStorDevice(device);
+
+	DPRINT_EXIT(STORVSC);
+	return;
+}