Staging: hv: add the Hyper-V virtual bus

This is the virtual bus that all of the Linux Hyper-V drivers use.
Signed-off-by: Hank Janssen <hjanssen@microsoft.com>
Signed-off-by: Haiyang Zhang <haiyangz@microsoft.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

drivers/staging/hv/Channel.c

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#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

drivers/staging/hv/Channel.h

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#ifndef _CHANNEL_H_
+#define _CHANNEL_H_
+
+#include "osd.h"
+#include "ChannelMgmt.h"
+
+#pragma pack(push,1)
+
+
+// The format must be the same as VMDATA_GPA_DIRECT
+typedef struct _VMBUS_CHANNEL_PACKET_PAGE_BUFFER {
+    UINT16				Type;
+    UINT16				DataOffset8;
+    UINT16				Length8;
+    UINT16				Flags;
+    UINT64				TransactionId;
+	UINT32				Reserved;
+	UINT32				RangeCount;
+    PAGE_BUFFER			Range[MAX_PAGE_BUFFER_COUNT];
+} VMBUS_CHANNEL_PACKET_PAGE_BUFFER;
+
+
+// The format must be the same as VMDATA_GPA_DIRECT
+typedef struct _VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER {
+    UINT16				Type;
+    UINT16				DataOffset8;
+    UINT16				Length8;
+    UINT16				Flags;
+    UINT64				TransactionId;
+	UINT32				Reserved;
+	UINT32				RangeCount;		// Always 1 in this case
+	MULTIPAGE_BUFFER	Range;
+} VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER;
+
+#pragma pack(pop)
+
+//
+// Routines
+//
+
+INTERNAL int
+VmbusChannelOpen(
+	VMBUS_CHANNEL			*Channel,
+	UINT32					SendRingBufferSize,
+	UINT32					RecvRingBufferSize,
+	PVOID					UserData,
+	UINT32					UserDataLen,
+	PFN_CHANNEL_CALLBACK	pfnOnChannelCallback,
+	PVOID					Context
+	);
+
+INTERNAL void
+VmbusChannelClose(
+	VMBUS_CHANNEL		*Channel
+	);
+
+INTERNAL int
+VmbusChannelSendPacket(
+	VMBUS_CHANNEL		*Channel,
+	const PVOID			Buffer,
+	UINT32				BufferLen,
+	UINT64				RequestId,
+	VMBUS_PACKET_TYPE	Type,
+	UINT32				Flags
+);
+
+INTERNAL int
+VmbusChannelSendPacketPageBuffer(
+	VMBUS_CHANNEL		*Channel,
+	PAGE_BUFFER			PageBuffers[],
+	UINT32				PageCount,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT64				RequestId
+	);
+
+INTERNAL int
+VmbusChannelSendPacketMultiPageBuffer(
+	VMBUS_CHANNEL		*Channel,
+	MULTIPAGE_BUFFER	*MultiPageBuffer,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT64				RequestId
+);
+
+INTERNAL int
+VmbusChannelEstablishGpadl(
+	VMBUS_CHANNEL		*Channel,
+	PVOID				Kbuffer,	// from kmalloc()
+	UINT32				Size,		// page-size multiple
+	UINT32				*GpadlHandle
+	);
+
+INTERNAL int
+VmbusChannelTeardownGpadl(
+	VMBUS_CHANNEL	*Channel,
+	UINT32			GpadlHandle
+	);
+
+INTERNAL int
+VmbusChannelRecvPacket(
+	VMBUS_CHANNEL		*Channel,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT32*				BufferActualLen,
+	UINT64*				RequestId
+	);
+
+INTERNAL int
+VmbusChannelRecvPacketRaw(
+	VMBUS_CHANNEL		*Channel,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT32*				BufferActualLen,
+	UINT64*				RequestId
+	);
+
+INTERNAL void
+VmbusChannelOnChannelEvent(
+	VMBUS_CHANNEL		*Channel
+	);
+
+INTERNAL void
+VmbusChannelGetDebugInfo(
+	VMBUS_CHANNEL				*Channel,
+	VMBUS_CHANNEL_DEBUG_INFO	*DebugInfo
+	);
+
+INTERNAL void
+VmbusChannelOnTimer(
+	void		*Context
+	);
+#endif //_CHANNEL_H_

drivers/staging/hv/ChannelInterface.c

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+#include "VmbusPrivate.h"
+
+INTERNAL int
+IVmbusChannelOpen(
+	PDEVICE_OBJECT		Device,
+	UINT32				SendBufferSize,
+	UINT32				RecvRingBufferSize,
+	PVOID				UserData,
+	UINT32				UserDataLen,
+	VMBUS_CHANNEL_CALLBACK ChannelCallback,
+	PVOID				Context
+	)
+{
+	return VmbusChannelOpen( (VMBUS_CHANNEL*)Device->context,
+								SendBufferSize,
+								RecvRingBufferSize,
+								UserData,
+								UserDataLen,
+								ChannelCallback,
+								Context);
+}
+
+
+INTERNAL void
+IVmbusChannelClose(
+	PDEVICE_OBJECT		Device
+	)
+{
+	VmbusChannelClose((VMBUS_CHANNEL*)Device->context);
+}
+
+
+INTERNAL int
+IVmbusChannelSendPacket(
+	PDEVICE_OBJECT		Device,
+	const PVOID			Buffer,
+	UINT32				BufferLen,
+	UINT64				RequestId,
+	UINT32				Type,
+	UINT32				Flags
+	)
+{
+	return VmbusChannelSendPacket((VMBUS_CHANNEL*)Device->context,
+									Buffer,
+									BufferLen,
+									RequestId,
+									Type,
+									Flags);
+}
+
+INTERNAL int
+IVmbusChannelSendPacketPageBuffer(
+	PDEVICE_OBJECT		Device,
+	PAGE_BUFFER			PageBuffers[],
+	UINT32				PageCount,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT64				RequestId
+	)
+{
+	return VmbusChannelSendPacketPageBuffer((VMBUS_CHANNEL*)Device->context,
+												PageBuffers,
+												PageCount,
+												Buffer,
+												BufferLen,
+												RequestId);
+}
+
+INTERNAL int
+IVmbusChannelSendPacketMultiPageBuffer(
+	PDEVICE_OBJECT		Device,
+	MULTIPAGE_BUFFER	*MultiPageBuffer,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT64				RequestId
+	)
+{
+	return VmbusChannelSendPacketMultiPageBuffer((VMBUS_CHANNEL*)Device->context,
+													MultiPageBuffer,
+													Buffer,
+													BufferLen,
+													RequestId);
+}
+
+INTERNAL int
+IVmbusChannelRecvPacket (
+	PDEVICE_OBJECT		Device,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT32*				BufferActualLen,
+	UINT64*				RequestId
+	)
+{
+	return VmbusChannelRecvPacket((VMBUS_CHANNEL*)Device->context,
+									Buffer,
+									BufferLen,
+									BufferActualLen,
+									RequestId);
+}
+
+INTERNAL int
+IVmbusChannelRecvPacketRaw(
+	PDEVICE_OBJECT		Device,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT32*				BufferActualLen,
+	UINT64*				RequestId
+	)
+{
+	return VmbusChannelRecvPacketRaw((VMBUS_CHANNEL*)Device->context,
+										Buffer,
+										BufferLen,
+										BufferActualLen,
+										RequestId);
+}
+
+INTERNAL int
+IVmbusChannelEstablishGpadl(
+	PDEVICE_OBJECT		Device,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT32*				GpadlHandle
+	)
+{
+	return VmbusChannelEstablishGpadl((VMBUS_CHANNEL*)Device->context,
+										Buffer,
+										BufferLen,
+										GpadlHandle);
+}
+
+INTERNAL int
+IVmbusChannelTeardownGpadl(
+   PDEVICE_OBJECT		Device,
+   UINT32				GpadlHandle
+	)
+{
+	return VmbusChannelTeardownGpadl((VMBUS_CHANNEL*)Device->context,
+										GpadlHandle);
+
+}
+
+INTERNAL void
+GetChannelInterface(
+	VMBUS_CHANNEL_INTERFACE *ChannelInterface
+	)
+{
+	ChannelInterface->Open						= IVmbusChannelOpen;
+	ChannelInterface->Close						= IVmbusChannelClose;
+	ChannelInterface->SendPacket				= IVmbusChannelSendPacket;
+	ChannelInterface->SendPacketPageBuffer		= IVmbusChannelSendPacketPageBuffer;
+	ChannelInterface->SendPacketMultiPageBuffer = IVmbusChannelSendPacketMultiPageBuffer;
+	ChannelInterface->RecvPacket				= IVmbusChannelRecvPacket;
+	ChannelInterface->RecvPacketRaw				= IVmbusChannelRecvPacketRaw;
+	ChannelInterface->EstablishGpadl			= IVmbusChannelEstablishGpadl;
+	ChannelInterface->TeardownGpadl				= IVmbusChannelTeardownGpadl;
+	ChannelInterface->GetInfo					= GetChannelInfo;
+}
+
+
+INTERNAL void
+GetChannelInfo(
+	PDEVICE_OBJECT		Device,
+	DEVICE_INFO			*DeviceInfo
+			   )
+{
+	VMBUS_CHANNEL_DEBUG_INFO debugInfo;
+
+	if (Device->context)
+	{
+		VmbusChannelGetDebugInfo((VMBUS_CHANNEL*)Device->context, &debugInfo);
+
+		DeviceInfo->ChannelId = debugInfo.RelId;
+		DeviceInfo->ChannelState = debugInfo.State;
+		memcpy(&DeviceInfo->ChannelType, &debugInfo.InterfaceType, sizeof(GUID));
+		memcpy(&DeviceInfo->ChannelInstance, &debugInfo.InterfaceInstance, sizeof(GUID));
+
+		DeviceInfo->MonitorId = debugInfo.MonitorId;
+
+		DeviceInfo->ServerMonitorPending = debugInfo.ServerMonitorPending;
+		DeviceInfo->ServerMonitorLatency = debugInfo.ServerMonitorLatency;
+		DeviceInfo->ServerMonitorConnectionId = debugInfo.ServerMonitorConnectionId;
+
+		DeviceInfo->ClientMonitorPending = debugInfo.ClientMonitorPending;
+		DeviceInfo->ClientMonitorLatency = debugInfo.ClientMonitorLatency;
+		DeviceInfo->ClientMonitorConnectionId = debugInfo.ClientMonitorConnectionId;
+
+		DeviceInfo->Inbound.InterruptMask = debugInfo.Inbound.CurrentInterruptMask;
+		DeviceInfo->Inbound.ReadIndex = debugInfo.Inbound.CurrentReadIndex;
+		DeviceInfo->Inbound.WriteIndex = debugInfo.Inbound.CurrentWriteIndex;
+		DeviceInfo->Inbound.BytesAvailToRead = debugInfo.Inbound.BytesAvailToRead;
+		DeviceInfo->Inbound.BytesAvailToWrite = debugInfo.Inbound.BytesAvailToWrite;
+
+		DeviceInfo->Outbound.InterruptMask = debugInfo.Outbound.CurrentInterruptMask;
+		DeviceInfo->Outbound.ReadIndex = debugInfo.Outbound.CurrentReadIndex;
+		DeviceInfo->Outbound.WriteIndex = debugInfo.Outbound.CurrentWriteIndex;
+		DeviceInfo->Outbound.BytesAvailToRead = debugInfo.Outbound.BytesAvailToRead;
+		DeviceInfo->Outbound.BytesAvailToWrite = debugInfo.Outbound.BytesAvailToWrite;
+	}
+}

drivers/staging/hv/ChannelInterface.h

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#ifndef _CHANNEL_INTERFACE_H_
+#define _CHANNEL_INTERFACE_H_
+
+#include "VmbusApi.h"
+
+INTERNAL void
+GetChannelInterface(
+	VMBUS_CHANNEL_INTERFACE *ChannelInterface
+	);
+
+INTERNAL void
+GetChannelInfo(
+	PDEVICE_OBJECT		Device,
+	DEVICE_INFO			*DeviceInfo
+	);
+
+#endif // _CHANNEL_INTERFACE_H_

drivers/staging/hv/ChannelMgmt.c

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#include "osd.h"
+#include "logging.h"
+
+#include "VmbusPrivate.h"
+
+//
+// Defines
+//
+
+//
+// Data types
+//
+
+typedef void (*PFN_CHANNEL_MESSAGE_HANDLER)(VMBUS_CHANNEL_MESSAGE_HEADER* msg);
+
+typedef struct _VMBUS_CHANNEL_MESSAGE_TABLE_ENTRY {
+	VMBUS_CHANNEL_MESSAGE_TYPE	messageType;
+	PFN_CHANNEL_MESSAGE_HANDLER messageHandler;
+} VMBUS_CHANNEL_MESSAGE_TABLE_ENTRY;
+
+//
+// Internal routines
+//
+
+static void
+VmbusChannelOnOffer(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	);
+static void
+VmbusChannelOnOpenResult(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	);
+
+static void
+VmbusChannelOnOfferRescind(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	);
+
+static void
+VmbusChannelOnGpadlCreated(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	);
+
+static void
+VmbusChannelOnGpadlTorndown(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	);
+
+static void
+VmbusChannelOnOffersDelivered(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	);
+
+static void
+VmbusChannelOnVersionResponse(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	);
+
+static void
+VmbusChannelProcessOffer(
+	PVOID context
+	);
+
+static void
+VmbusChannelProcessRescindOffer(
+	PVOID context
+	);
+
+
+//
+// Globals
+//
+
+#define MAX_NUM_DEVICE_CLASSES_SUPPORTED 4
+
+const GUID gSupportedDeviceClasses[MAX_NUM_DEVICE_CLASSES_SUPPORTED]= {
+	//{ba6163d9-04a1-4d29-b605-72e2ffb1dc7f}
+	{.Data  = {0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d, 0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f}},// Storage - SCSI
+	//{F8615163-DF3E-46c5-913F-F2D2F965ED0E}
+	{.Data = {0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46, 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E}},	// Network
+	//{CFA8B69E-5B4A-4cc0-B98B-8BA1A1F3F95A}
+	{.Data = {0x9E, 0xB6, 0xA8, 0xCF, 0x4A, 0x5B, 0xc0, 0x4c, 0xB9, 0x8B, 0x8B, 0xA1, 0xA1, 0xF3, 0xF9, 0x5A}}, // Input
+	//{32412632-86cb-44a2-9b5c-50d1417354f5}
+	{.Data = {0x32, 0x26, 0x41, 0x32, 0xcb, 0x86, 0xa2, 0x44, 0x9b, 0x5c, 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5}}, // IDE
+
+};
+
+// Channel message dispatch table
+VMBUS_CHANNEL_MESSAGE_TABLE_ENTRY gChannelMessageTable[ChannelMessageCount]= {
+    {ChannelMessageInvalid,					NULL},
+    {ChannelMessageOfferChannel,            VmbusChannelOnOffer},
+    {ChannelMessageRescindChannelOffer,     VmbusChannelOnOfferRescind},
+    {ChannelMessageRequestOffers,           NULL},
+    {ChannelMessageAllOffersDelivered,      VmbusChannelOnOffersDelivered},
+    {ChannelMessageOpenChannel,             NULL},
+    {ChannelMessageOpenChannelResult,       VmbusChannelOnOpenResult},
+    {ChannelMessageCloseChannel,            NULL},
+    {ChannelMessageGpadlHeader,             NULL},
+    {ChannelMessageGpadlBody,               NULL},
+	{ChannelMessageGpadlCreated,			VmbusChannelOnGpadlCreated},
+    {ChannelMessageGpadlTeardown,           NULL},
+    {ChannelMessageGpadlTorndown,           VmbusChannelOnGpadlTorndown},
+    {ChannelMessageRelIdReleased,           NULL},
+	{ChannelMessageInitiateContact,			NULL},
+	{ChannelMessageVersionResponse,			VmbusChannelOnVersionResponse},
+	{ChannelMessageUnload,					NULL},
+};
+
+/*++
+
+Name:
+	AllocVmbusChannel()
+
+Description:
+	Allocate and initialize a vmbus channel object
+
+--*/
+VMBUS_CHANNEL* AllocVmbusChannel(void)
+{
+	VMBUS_CHANNEL* channel;
+
+	channel = (VMBUS_CHANNEL*) MemAllocAtomic(sizeof(VMBUS_CHANNEL));
+	if (!channel)
+	{
+		return NULL;
+	}
+
+	memset(channel, 0,sizeof(VMBUS_CHANNEL));
+	channel->InboundLock = SpinlockCreate();
+	if (!channel->InboundLock)
+	{
+		MemFree(channel);
+		return NULL;
+	}
+
+	channel->PollTimer = TimerCreate(VmbusChannelOnTimer, channel);
+	if (!channel->PollTimer)
+	{
+		SpinlockClose(channel->InboundLock);
+		MemFree(channel);
+		return NULL;
+	}
+
+	//channel->dataWorkQueue = WorkQueueCreate("data");
+	channel->ControlWQ = WorkQueueCreate("control");
+	if (!channel->ControlWQ)
+	{
+		TimerClose(channel->PollTimer);
+		SpinlockClose(channel->InboundLock);
+		MemFree(channel);
+		return NULL;
+	}
+
+	return channel;
+}
+
+/*++
+
+Name:
+	ReleaseVmbusChannel()
+
+Description:
+	Release the vmbus channel object itself
+
+--*/
+static inline void ReleaseVmbusChannel(void* Context)
+{
+	VMBUS_CHANNEL* channel = (VMBUS_CHANNEL*)Context;
+
+	DPRINT_ENTER(VMBUS);
+
+	DPRINT_DBG(VMBUS, "releasing channel (%p)", channel);
+	WorkQueueClose(channel->ControlWQ);
+	DPRINT_DBG(VMBUS, "channel released (%p)", channel);
+
+	MemFree(channel);
+
+	DPRINT_EXIT(VMBUS);
+}
+
+/*++
+
+Name:
+	FreeVmbusChannel()
+
+Description:
+	Release the resources used by the vmbus channel object
+
+--*/
+void FreeVmbusChannel(VMBUS_CHANNEL* Channel)
+{
+	SpinlockClose(Channel->InboundLock);
+	TimerClose(Channel->PollTimer);
+
+	// We have to release the channel's workqueue/thread in the vmbus's workqueue/thread context
+	// ie we can't destroy ourselves.
+	WorkQueueQueueWorkItem(gVmbusConnection.WorkQueue, ReleaseVmbusChannel, (void*)Channel);
+}
+
+
+/*++
+
+Name:
+	VmbusChannelProcessOffer()
+
+Description:
+	Process the offer by creating a channel/device associated with this offer
+
+--*/
+static void
+VmbusChannelProcessOffer(
+	PVOID context
+	)
+{
+	int ret=0;
+	VMBUS_CHANNEL* newChannel=(VMBUS_CHANNEL*)context;
+	LIST_ENTRY* anchor;
+	LIST_ENTRY* curr;
+	BOOL fNew=TRUE;
+	VMBUS_CHANNEL* channel;
+
+	DPRINT_ENTER(VMBUS);
+
+	// Make sure this is a new offer
+	SpinlockAcquire(gVmbusConnection.ChannelLock);
+
+	ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelList)
+	{
+		channel = CONTAINING_RECORD(curr, VMBUS_CHANNEL, ListEntry);
+
+		if (!memcmp(&channel->OfferMsg.Offer.InterfaceType, &newChannel->OfferMsg.Offer.InterfaceType,sizeof(GUID)) &&
+			!memcmp(&channel->OfferMsg.Offer.InterfaceInstance, &newChannel->OfferMsg.Offer.InterfaceInstance, sizeof(GUID)))
+		{
+			fNew = FALSE;
+			break;
+		}
+	}
+
+	if (fNew)
+	{
+		INSERT_TAIL_LIST(&gVmbusConnection.ChannelList, &newChannel->ListEntry);
+	}
+	SpinlockRelease(gVmbusConnection.ChannelLock);
+
+	if (!fNew)
+	{
+		DPRINT_DBG(VMBUS, "Ignoring duplicate offer for relid (%d)", newChannel->OfferMsg.ChildRelId);
+		FreeVmbusChannel(newChannel);
+		DPRINT_EXIT(VMBUS);
+		return;
+	}
+
+	// Start the process of binding this offer to the driver
+	// We need to set the DeviceObject field before calling VmbusChildDeviceAdd()
+	newChannel->DeviceObject = VmbusChildDeviceCreate(
+		newChannel->OfferMsg.Offer.InterfaceType,
+		newChannel->OfferMsg.Offer.InterfaceInstance,
+		newChannel);
+
+	DPRINT_DBG(VMBUS, "child device object allocated - %p", newChannel->DeviceObject);
+
+	// Add the new device to the bus. This will kick off device-driver binding
+	// which eventually invokes the device driver's AddDevice() method.
+	ret = VmbusChildDeviceAdd(newChannel->DeviceObject);
+	if (ret != 0)
+	{
+		DPRINT_ERR(VMBUS, "unable to add child device object (relid %d)",
+			newChannel->OfferMsg.ChildRelId);
+
+		SpinlockAcquire(gVmbusConnection.ChannelLock);
+		REMOVE_ENTRY_LIST(&newChannel->ListEntry);
+		SpinlockRelease(gVmbusConnection.ChannelLock);
+
+		FreeVmbusChannel(newChannel);
+	}
+	else
+	{
+		// This state is used to indicate a successful open so that when we do close the channel normally,
+		// we can cleanup properly
+		newChannel->State = CHANNEL_OPEN_STATE;
+	}
+	DPRINT_EXIT(VMBUS);
+}
+
+/*++
+
+Name:
+	VmbusChannelProcessRescindOffer()
+
+Description:
+	Rescind the offer by initiating a device removal
+
+--*/
+static void
+VmbusChannelProcessRescindOffer(
+	PVOID context
+	)
+{
+	VMBUS_CHANNEL* channel=(VMBUS_CHANNEL*)context;
+
+	DPRINT_ENTER(VMBUS);
+
+	VmbusChildDeviceRemove(channel->DeviceObject);
+
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusChannelOnOffer()
+
+Description:
+	Handler for channel offers from vmbus in parent partition. We ignore all offers except
+	network and storage offers. For each network and storage offers, we create a channel object
+	and queue a work item to the channel object to process the offer synchronously
+
+--*/
+static void
+VmbusChannelOnOffer(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	)
+{
+	VMBUS_CHANNEL_OFFER_CHANNEL* offer = (VMBUS_CHANNEL_OFFER_CHANNEL*)hdr;
+	VMBUS_CHANNEL* newChannel;
+
+	GUID *guidType;
+	GUID *guidInstance;
+	int i;
+	int fSupported=0;
+
+	DPRINT_ENTER(VMBUS);
+
+	for (i=0; i<MAX_NUM_DEVICE_CLASSES_SUPPORTED; i++)
+	{
+		if (memcmp(&offer->Offer.InterfaceType, &gSupportedDeviceClasses[i], sizeof(GUID)) == 0)
+		{
+			fSupported = 1;
+			break;
+		}
+	}
+
+	if (!fSupported)
+	{
+		DPRINT_DBG(VMBUS, "Ignoring channel offer notification for child relid %d", offer->ChildRelId);
+		DPRINT_EXIT(VMBUS);
+
+		return;
+	}
+
+	guidType = &offer->Offer.InterfaceType;
+	guidInstance = &offer->Offer.InterfaceInstance;
+
+	DPRINT_INFO(VMBUS, "Channel offer notification - child relid %d monitor id %d allocated %d, "
+		"type {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x} "
+		"instance {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
+		offer->ChildRelId,
+		offer->MonitorId,
+		offer->MonitorAllocated,
+		guidType->Data[3], guidType->Data[2], guidType->Data[1], guidType->Data[0], guidType->Data[5], guidType->Data[4], guidType->Data[7], guidType->Data[6], guidType->Data[8], guidType->Data[9], guidType->Data[10], guidType->Data[11], guidType->Data[12], guidType->Data[13], guidType->Data[14], guidType->Data[15],
+		guidInstance->Data[3], guidInstance->Data[2], guidInstance->Data[1], guidInstance->Data[0], guidInstance->Data[5], guidInstance->Data[4], guidInstance->Data[7], guidInstance->Data[6], guidInstance->Data[8], guidInstance->Data[9], guidInstance->Data[10], guidInstance->Data[11], guidInstance->Data[12], guidInstance->Data[13], guidInstance->Data[14], guidInstance->Data[15]);
+
+	// Allocate the channel object and save this offer.
+	newChannel = AllocVmbusChannel();
+	if (!newChannel)
+	{
+		DPRINT_ERR(VMBUS, "unable to allocate channel object");
+		return;
+	}
+
+	DPRINT_DBG(VMBUS, "channel object allocated - %p", newChannel);
+
+	memcpy(&newChannel->OfferMsg, offer, sizeof(VMBUS_CHANNEL_OFFER_CHANNEL));
+	newChannel->MonitorGroup = (UINT8)offer->MonitorId / 32;
+	newChannel->MonitorBit = (UINT8)offer->MonitorId % 32;
+
+	// TODO: Make sure the offer comes from our parent partition
+	WorkQueueQueueWorkItem(newChannel->ControlWQ, VmbusChannelProcessOffer, newChannel);
+
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusChannelOnOfferRescind()
+
+Description:
+	Rescind offer handler. We queue a work item to process this offer
+	synchronously
+
+--*/
+static void
+VmbusChannelOnOfferRescind(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	)
+{
+	VMBUS_CHANNEL_RESCIND_OFFER* rescind = (VMBUS_CHANNEL_RESCIND_OFFER*)hdr;
+	VMBUS_CHANNEL* channel;
+
+	DPRINT_ENTER(VMBUS);
+
+	channel = GetChannelFromRelId(rescind->ChildRelId);
+	if (channel == NULL)
+	{
+		DPRINT_DBG(VMBUS, "channel not found for relId %d", rescind->ChildRelId);
+		return;
+	}
+
+	WorkQueueQueueWorkItem(channel->ControlWQ, VmbusChannelProcessRescindOffer, channel);
+
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusChannelOnOffersDelivered()
+
+Description:
+	This is invoked when all offers have been delivered.
+	Nothing to do here.
+
+--*/
+static void
+VmbusChannelOnOffersDelivered(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	)
+{
+	DPRINT_ENTER(VMBUS);
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusChannelOnOpenResult()
+
+Description:
+	Open result handler. This is invoked when we received a response
+	to our channel open request. Find the matching request, copy the
+	response and signal the requesting thread.
+
+--*/
+static void
+VmbusChannelOnOpenResult(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	)
+{
+	VMBUS_CHANNEL_OPEN_RESULT* result = (VMBUS_CHANNEL_OPEN_RESULT*)hdr;
+	LIST_ENTRY* anchor;
+	LIST_ENTRY* curr;
+	VMBUS_CHANNEL_MSGINFO* msgInfo;
+	VMBUS_CHANNEL_MESSAGE_HEADER* requestHeader;
+	VMBUS_CHANNEL_OPEN_CHANNEL* openMsg;
+
+	DPRINT_ENTER(VMBUS);
+
+	DPRINT_DBG(VMBUS, "vmbus open result - %d", result->Status);
+
+	// Find the open msg, copy the result and signal/unblock the wait event
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+
+	ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelMsgList)
+	{
+		msgInfo = (VMBUS_CHANNEL_MSGINFO*) curr;
+		requestHeader = (VMBUS_CHANNEL_MESSAGE_HEADER*)msgInfo->Msg;
+
+		if (requestHeader->MessageType == ChannelMessageOpenChannel)
+		{
+			openMsg = (VMBUS_CHANNEL_OPEN_CHANNEL*)msgInfo->Msg;
+			if (openMsg->ChildRelId == result->ChildRelId &&
+				openMsg->OpenId == result->OpenId)
+			{
+				memcpy(&msgInfo->Response.OpenResult, result, sizeof(VMBUS_CHANNEL_OPEN_RESULT));
+				WaitEventSet(msgInfo->WaitEvent);
+				break;
+			}
+		}
+	}
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusChannelOnGpadlCreated()
+
+Description:
+	GPADL created handler. This is invoked when we received a response
+	to our gpadl create request. Find the matching request, copy the
+	response and signal the requesting thread.
+
+--*/
+static void
+VmbusChannelOnGpadlCreated(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	)
+{
+	VMBUS_CHANNEL_GPADL_CREATED *gpadlCreated = (VMBUS_CHANNEL_GPADL_CREATED*)hdr;
+	LIST_ENTRY *anchor;
+	LIST_ENTRY *curr;
+	VMBUS_CHANNEL_MSGINFO *msgInfo;
+	VMBUS_CHANNEL_MESSAGE_HEADER *requestHeader;
+	VMBUS_CHANNEL_GPADL_HEADER *gpadlHeader;
+
+	DPRINT_ENTER(VMBUS);
+
+	DPRINT_DBG(VMBUS, "vmbus gpadl created result - %d", gpadlCreated->CreationStatus);
+
+	// Find the establish msg, copy the result and signal/unblock the wait event
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+
+	ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelMsgList)
+	{
+		msgInfo = (VMBUS_CHANNEL_MSGINFO*) curr;
+		requestHeader = (VMBUS_CHANNEL_MESSAGE_HEADER*)msgInfo->Msg;
+
+		if (requestHeader->MessageType == ChannelMessageGpadlHeader)
+		{
+			gpadlHeader = (VMBUS_CHANNEL_GPADL_HEADER*)requestHeader;
+
+			if ((gpadlCreated->ChildRelId == gpadlHeader->ChildRelId) &&
+					(gpadlCreated->Gpadl == gpadlHeader->Gpadl))
+			{
+				memcpy(&msgInfo->Response.GpadlCreated, gpadlCreated, sizeof(VMBUS_CHANNEL_GPADL_CREATED));
+				WaitEventSet(msgInfo->WaitEvent);
+				break;
+			}
+		}
+	}
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusChannelOnGpadlTorndown()
+
+Description:
+	GPADL torndown handler. This is invoked when we received a response
+	to our gpadl teardown request. Find the matching request, copy the
+	response and signal the requesting thread.
+
+--*/
+static void
+VmbusChannelOnGpadlTorndown(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	)
+{
+	VMBUS_CHANNEL_GPADL_TORNDOWN* gpadlTorndown  = (VMBUS_CHANNEL_GPADL_TORNDOWN*)hdr;
+	LIST_ENTRY* anchor;
+	LIST_ENTRY* curr;
+	VMBUS_CHANNEL_MSGINFO* msgInfo;
+	VMBUS_CHANNEL_MESSAGE_HEADER *requestHeader;
+	VMBUS_CHANNEL_GPADL_TEARDOWN *gpadlTeardown;
+
+	DPRINT_ENTER(VMBUS);
+
+	// Find the open msg, copy the result and signal/unblock the wait event
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+
+	ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelMsgList)
+	{
+		msgInfo = (VMBUS_CHANNEL_MSGINFO*) curr;
+		requestHeader = (VMBUS_CHANNEL_MESSAGE_HEADER*)msgInfo->Msg;
+
+		if (requestHeader->MessageType == ChannelMessageGpadlTeardown)
+		{
+			gpadlTeardown = (VMBUS_CHANNEL_GPADL_TEARDOWN*)requestHeader;
+
+			if (gpadlTorndown->Gpadl == gpadlTeardown->Gpadl)
+			{
+				memcpy(&msgInfo->Response.GpadlTorndown, gpadlTorndown, sizeof(VMBUS_CHANNEL_GPADL_TORNDOWN));
+				WaitEventSet(msgInfo->WaitEvent);
+				break;
+			}
+		}
+	}
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusChannelOnVersionResponse()
+
+Description:
+	Version response handler. This is invoked when we received a response
+	to our initiate contact request. Find the matching request, copy the
+	response and signal the requesting thread.
+
+--*/
+static void
+VmbusChannelOnVersionResponse(
+	PVMBUS_CHANNEL_MESSAGE_HEADER hdr
+	)
+{
+	LIST_ENTRY* anchor;
+	LIST_ENTRY* curr;
+	VMBUS_CHANNEL_MSGINFO *msgInfo;
+	VMBUS_CHANNEL_MESSAGE_HEADER *requestHeader;
+	VMBUS_CHANNEL_INITIATE_CONTACT *initiate;
+	VMBUS_CHANNEL_VERSION_RESPONSE *versionResponse  = (VMBUS_CHANNEL_VERSION_RESPONSE*)hdr;
+
+	DPRINT_ENTER(VMBUS);
+
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+
+	ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelMsgList)
+	{
+		msgInfo = (VMBUS_CHANNEL_MSGINFO*) curr;
+		requestHeader = (VMBUS_CHANNEL_MESSAGE_HEADER*)msgInfo->Msg;
+
+		if (requestHeader->MessageType == ChannelMessageInitiateContact)
+		{
+			initiate = (VMBUS_CHANNEL_INITIATE_CONTACT*)requestHeader;
+			memcpy(&msgInfo->Response.VersionResponse, versionResponse, sizeof(VMBUS_CHANNEL_VERSION_RESPONSE));
+			WaitEventSet(msgInfo->WaitEvent);
+		}
+	}
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusOnChannelMessage()
+
+Description:
+	Handler for channel protocol messages.
+	This is invoked in the vmbus worker thread context.
+
+--*/
+VOID
+VmbusOnChannelMessage(
+	void *Context
+	)
+{
+	HV_MESSAGE *msg=(HV_MESSAGE*)Context;
+	VMBUS_CHANNEL_MESSAGE_HEADER* hdr;
+	int size;
+
+	DPRINT_ENTER(VMBUS);
+
+	hdr = (VMBUS_CHANNEL_MESSAGE_HEADER*)msg->u.Payload;
+	size=msg->Header.PayloadSize;
+
+	DPRINT_DBG(VMBUS, "message type %d size %d", hdr->MessageType, size);
+
+	if (hdr->MessageType >= ChannelMessageCount)
+	{
+		DPRINT_ERR(VMBUS, "Received invalid channel message type %d size %d", hdr->MessageType, size);
+		PrintBytes((unsigned char *)msg->u.Payload, size);
+		MemFree(msg);
+		return;
+	}
+
+	if (gChannelMessageTable[hdr->MessageType].messageHandler)
+	{
+		gChannelMessageTable[hdr->MessageType].messageHandler(hdr);
+	}
+	else
+	{
+		DPRINT_ERR(VMBUS, "Unhandled channel message type %d", hdr->MessageType);
+	}
+
+	// Free the msg that was allocated in VmbusOnMsgDPC()
+	MemFree(msg);
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusChannelRequestOffers()
+
+Description:
+	Send a request to get all our pending offers.
+
+--*/
+int
+VmbusChannelRequestOffers(
+	VOID
+	)
+{
+	int ret=0;
+	VMBUS_CHANNEL_MESSAGE_HEADER* msg;
+	VMBUS_CHANNEL_MSGINFO* msgInfo;
+
+	DPRINT_ENTER(VMBUS);
+
+	msgInfo =
+		(VMBUS_CHANNEL_MSGINFO*)MemAlloc(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_MESSAGE_HEADER));
+	ASSERT(msgInfo != NULL);
+
+	msgInfo->WaitEvent = WaitEventCreate();
+	msg = (VMBUS_CHANNEL_MESSAGE_HEADER*)msgInfo->Msg;
+
+	msg->MessageType = ChannelMessageRequestOffers;
+
+	/*SpinlockAcquire(gVmbusConnection.channelMsgLock);
+	INSERT_TAIL_LIST(&gVmbusConnection.channelMsgList, &msgInfo->msgListEntry);
+	SpinlockRelease(gVmbusConnection.channelMsgLock);*/
+
+	ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_MESSAGE_HEADER));
+	if (ret != 0)
+	{
+		DPRINT_ERR(VMBUS, "Unable to request offers - %d", ret);
+
+		/*SpinlockAcquire(gVmbusConnection.channelMsgLock);
+		REMOVE_ENTRY_LIST(&msgInfo->msgListEntry);
+		SpinlockRelease(gVmbusConnection.channelMsgLock);*/
+
+		goto Cleanup;
+	}
+	//WaitEventWait(msgInfo->waitEvent);
+
+	/*SpinlockAcquire(gVmbusConnection.channelMsgLock);
+	REMOVE_ENTRY_LIST(&msgInfo->msgListEntry);
+	SpinlockRelease(gVmbusConnection.channelMsgLock);*/
+
+
+Cleanup:
+	if (msgInfo)
+	{
+		WaitEventClose(msgInfo->WaitEvent);
+		MemFree(msgInfo);
+	}
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+/*++
+
+Name:
+	VmbusChannelReleaseUnattachedChannels()
+
+Description:
+	Release channels that are unattached/unconnected ie (no drivers associated)
+
+--*/
+void
+VmbusChannelReleaseUnattachedChannels(
+	VOID
+	)
+{
+	LIST_ENTRY *entry;
+	VMBUS_CHANNEL *channel;
+	VMBUS_CHANNEL *start=NULL;
+
+	SpinlockAcquire(gVmbusConnection.ChannelLock);
+
+	while (!IsListEmpty(&gVmbusConnection.ChannelList))
+	{
+		entry = TOP_LIST_ENTRY(&gVmbusConnection.ChannelList);
+		channel = CONTAINING_RECORD(entry, VMBUS_CHANNEL, ListEntry);
+
+		if (channel == start)
+			break;
+
+		if (!channel->DeviceObject->Driver)
+		{
+			REMOVE_ENTRY_LIST(&channel->ListEntry);
+			DPRINT_INFO(VMBUS, "Releasing unattached device object %p", channel->DeviceObject);
+
+			VmbusChildDeviceRemove(channel->DeviceObject);
+			FreeVmbusChannel(channel);
+		}
+		else
+		{
+			if (!start)
+			{
+				start = channel;
+			}
+		}
+	}
+
+	SpinlockRelease(gVmbusConnection.ChannelLock);
+}
+
+// eof
+

drivers/staging/hv/ChannelMgmt.h

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#ifndef _CHANNEL_MGMT_H_
+#define _CHANNEL_MGMT_H_
+
+#include "osd.h"
+#include "List.h"
+#include "RingBuffer.h"
+
+#include "VmbusChannelInterface.h"
+#include "ChannelMessages.h"
+
+
+
+typedef void (*PFN_CHANNEL_CALLBACK)(PVOID context);
+
+typedef enum {
+	CHANNEL_OFFER_STATE,
+	CHANNEL_OPENING_STATE,
+	CHANNEL_OPEN_STATE,
+} VMBUS_CHANNEL_STATE;
+
+typedef struct _VMBUS_CHANNEL {
+	LIST_ENTRY					ListEntry;
+
+	DEVICE_OBJECT*				DeviceObject;
+
+	HANDLE						PollTimer; // SA-111 workaround
+
+	VMBUS_CHANNEL_STATE			State;
+
+	VMBUS_CHANNEL_OFFER_CHANNEL OfferMsg;
+	// These are based on the OfferMsg.MonitorId. Save it here for easy access.
+	UINT8						MonitorGroup;
+	UINT8						MonitorBit;
+
+	UINT32						RingBufferGpadlHandle;
+
+	// Allocated memory for ring buffer
+	VOID*						RingBufferPages;
+	UINT32						RingBufferPageCount;
+	RING_BUFFER_INFO			Outbound;	// send to parent
+	RING_BUFFER_INFO			Inbound;	// receive from parent
+	HANDLE						InboundLock;
+	HANDLE						ControlWQ;
+
+	// Channel callback are invoked in this workqueue context
+	//HANDLE						dataWorkQueue;
+
+	PFN_CHANNEL_CALLBACK		OnChannelCallback;
+	PVOID						ChannelCallbackContext;
+
+} VMBUS_CHANNEL;
+
+
+typedef struct _VMBUS_CHANNEL_DEBUG_INFO {
+	UINT32						RelId;
+	VMBUS_CHANNEL_STATE			State;
+	GUID						InterfaceType;
+    GUID						InterfaceInstance;
+	UINT32						MonitorId;
+	UINT32						ServerMonitorPending;
+	UINT32						ServerMonitorLatency;
+	UINT32						ServerMonitorConnectionId;
+	UINT32						ClientMonitorPending;
+	UINT32						ClientMonitorLatency;
+	UINT32						ClientMonitorConnectionId;
+
+	RING_BUFFER_DEBUG_INFO		Inbound;
+	RING_BUFFER_DEBUG_INFO		Outbound;
+} VMBUS_CHANNEL_DEBUG_INFO;
+
+
+typedef union {
+	VMBUS_CHANNEL_VERSION_SUPPORTED		VersionSupported;
+	VMBUS_CHANNEL_OPEN_RESULT			OpenResult;
+	VMBUS_CHANNEL_GPADL_TORNDOWN		GpadlTorndown;
+	VMBUS_CHANNEL_GPADL_CREATED			GpadlCreated;
+	VMBUS_CHANNEL_VERSION_RESPONSE		VersionResponse;
+} VMBUS_CHANNEL_MESSAGE_RESPONSE;
+
+
+// Represents each channel msg on the vmbus connection
+// This is a variable-size data structure depending on
+// the msg type itself
+typedef struct _VMBUS_CHANNEL_MSGINFO {
+	// Bookkeeping stuff
+	LIST_ENTRY		MsgListEntry;
+
+	// So far, this is only used to handle gpadl body message
+	LIST_ENTRY		SubMsgList;
+
+	// Synchronize the request/response if needed
+	HANDLE			WaitEvent;
+
+	VMBUS_CHANNEL_MESSAGE_RESPONSE Response;
+
+	UINT32			MessageSize;
+	// The channel message that goes out on the "wire".
+	// It will contain at minimum the VMBUS_CHANNEL_MESSAGE_HEADER header
+	unsigned char	Msg[0];
+} VMBUS_CHANNEL_MSGINFO;
+
+
+//
+// Routines
+//
+
+INTERNAL VMBUS_CHANNEL*
+AllocVmbusChannel(
+	void
+	);
+
+INTERNAL void
+FreeVmbusChannel(
+	VMBUS_CHANNEL *Channel
+	);
+
+INTERNAL void
+VmbusOnChannelMessage(
+	void *Context
+	);
+
+INTERNAL int
+VmbusChannelRequestOffers(
+	void
+	);
+
+INTERNAL void
+VmbusChannelReleaseUnattachedChannels(
+	void
+	);
+
+#endif //_CHANNEL_MGMT_H_

drivers/staging/hv/Connection.c

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#include "logging.h"
+
+#include "VmbusPrivate.h"
+
+//
+// Globals
+//
+
+
+VMBUS_CONNECTION gVmbusConnection = {
+	.ConnectState		= Disconnected,
+	.NextGpadlHandle	= 0xE1E10,
+};
+
+
+/*++
+
+Name:
+	VmbusConnect()
+
+Description:
+	Sends a connect request on the partition service connection
+
+--*/
+int
+VmbusConnect(
+	)
+{
+	int ret=0;
+	VMBUS_CHANNEL_MSGINFO *msgInfo=NULL;
+	VMBUS_CHANNEL_INITIATE_CONTACT *msg;
+
+	DPRINT_ENTER(VMBUS);
+
+	// Make sure we are not connecting or connected
+	if (gVmbusConnection.ConnectState != Disconnected)
+		return -1;
+
+	// Initialize the vmbus connection
+	gVmbusConnection.ConnectState = Connecting;
+	gVmbusConnection.WorkQueue = WorkQueueCreate("vmbusQ");
+
+	INITIALIZE_LIST_HEAD(&gVmbusConnection.ChannelMsgList);
+	gVmbusConnection.ChannelMsgLock = SpinlockCreate();
+
+	INITIALIZE_LIST_HEAD(&gVmbusConnection.ChannelList);
+	gVmbusConnection.ChannelLock = SpinlockCreate();
+
+	// Setup the vmbus event connection for channel interrupt abstraction stuff
+	gVmbusConnection.InterruptPage = PageAlloc(1);
+	if (gVmbusConnection.InterruptPage == NULL)
+	{
+		ret = -1;
+		goto Cleanup;
+	}
+
+	gVmbusConnection.RecvInterruptPage = gVmbusConnection.InterruptPage;
+	gVmbusConnection.SendInterruptPage = (void*)((ULONG_PTR)gVmbusConnection.InterruptPage + (PAGE_SIZE >> 1));
+
+	// Setup the monitor notification facility. The 1st page for parent->child and the 2nd page for child->parent
+	gVmbusConnection.MonitorPages = PageAlloc(2);
+	if (gVmbusConnection.MonitorPages == NULL)
+	{
+		ret = -1;
+		goto Cleanup;
+	}
+
+	msgInfo = (VMBUS_CHANNEL_MSGINFO*)MemAllocZeroed(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_INITIATE_CONTACT));
+	if (msgInfo == NULL)
+	{
+		ret = -1;
+		goto Cleanup;
+	}
+
+	msgInfo->WaitEvent = WaitEventCreate();
+	msg = (VMBUS_CHANNEL_INITIATE_CONTACT*)msgInfo->Msg;
+
+	msg->Header.MessageType = ChannelMessageInitiateContact;
+	msg->VMBusVersionRequested = VMBUS_REVISION_NUMBER;
+	msg->InterruptPage = GetPhysicalAddress(gVmbusConnection.InterruptPage);
+	msg->MonitorPage1 = GetPhysicalAddress(gVmbusConnection.MonitorPages);
+	msg->MonitorPage2 = GetPhysicalAddress((PVOID)((ULONG_PTR)gVmbusConnection.MonitorPages + PAGE_SIZE));
+
+	// Add to list before we send the request since we may receive the response
+	// before returning from this routine
+	SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
+	INSERT_TAIL_LIST(&gVmbusConnection.ChannelMsgList, &msgInfo->MsgListEntry);
+	SpinlockRelease(gVmbusConnection.ChannelMsgLock);
+
+	DPRINT_DBG(VMBUS, "Vmbus connection -  interrupt pfn %llx, monitor1 pfn %llx,, monitor2 pfn %llx",
+		msg->InterruptPage, msg->MonitorPage1, msg->MonitorPage2);
+
+	DPRINT_DBG(VMBUS, "Sending channel initiate msg...");
+
+	ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_INITIATE_CONTACT));
+	if (ret != 0)
+	{
+		REMOVE_ENTRY_LIST(&msgInfo->MsgListEntry);
+		goto Cleanup;
+	}
+
+	// Wait for the connection response
+	WaitEventWait(msgInfo->WaitEvent);
+
+	REMOVE_ENTRY_LIST(&msgInfo->MsgListEntry);
+
+	// Check if successful
+	if (msgInfo->Response.VersionResponse.VersionSupported)
+	{
+		DPRINT_INFO(VMBUS, "Vmbus connected!!");
+		gVmbusConnection.ConnectState = Connected;
+
+	}
+	else
+	{
+		DPRINT_ERR(VMBUS, "Vmbus connection failed!!...current version (%d) not supported", VMBUS_REVISION_NUMBER);
+		ret = -1;
+
+		goto Cleanup;
+	}
+
+
+	WaitEventClose(msgInfo->WaitEvent);
+	MemFree(msgInfo);
+	DPRINT_EXIT(VMBUS);
+
+	return 0;
+
+Cleanup:
+
+	gVmbusConnection.ConnectState = Disconnected;
+
+	WorkQueueClose(gVmbusConnection.WorkQueue);
+	SpinlockClose(gVmbusConnection.ChannelLock);
+	SpinlockClose(gVmbusConnection.ChannelMsgLock);
+
+	if (gVmbusConnection.InterruptPage)
+	{
+		PageFree(gVmbusConnection.InterruptPage, 1);
+		gVmbusConnection.InterruptPage = NULL;
+	}
+
+	if (gVmbusConnection.MonitorPages)
+	{
+		PageFree(gVmbusConnection.MonitorPages, 2);
+		gVmbusConnection.MonitorPages = NULL;
+	}
+
+	if (msgInfo)
+	{
+		if (msgInfo->WaitEvent)
+			WaitEventClose(msgInfo->WaitEvent);
+
+		MemFree(msgInfo);
+	}
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+/*++
+
+Name:
+	VmbusDisconnect()
+
+Description:
+	Sends a disconnect request on the partition service connection
+
+--*/
+int
+VmbusDisconnect(
+	VOID
+	)
+{
+	int ret=0;
+	VMBUS_CHANNEL_UNLOAD *msg;
+
+	DPRINT_ENTER(VMBUS);
+
+	// Make sure we are connected
+	if (gVmbusConnection.ConnectState != Connected)
+		return -1;
+
+	msg = MemAllocZeroed(sizeof(VMBUS_CHANNEL_UNLOAD));
+
+	msg->MessageType = ChannelMessageUnload;
+
+	ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_UNLOAD));
+
+	if (ret != 0)
+	{
+		goto Cleanup;
+	}
+
+	PageFree(gVmbusConnection.InterruptPage, 1);
+
+	// TODO: iterate thru the msg list and free up
+
+	SpinlockClose(gVmbusConnection.ChannelMsgLock);
+
+	WorkQueueClose(gVmbusConnection.WorkQueue);
+
+	gVmbusConnection.ConnectState = Disconnected;
+
+	DPRINT_INFO(VMBUS, "Vmbus disconnected!!");
+
+Cleanup:
+	if (msg)
+	{
+		MemFree(msg);
+	}
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+/*++
+
+Name:
+	GetChannelFromRelId()
+
+Description:
+	Get the channel object given its child relative id (ie channel id)
+
+--*/
+VMBUS_CHANNEL*
+GetChannelFromRelId(
+	UINT32 relId
+	)
+{
+	VMBUS_CHANNEL* channel;
+	VMBUS_CHANNEL* foundChannel=NULL;
+	LIST_ENTRY* anchor;
+	LIST_ENTRY* curr;
+
+	SpinlockAcquire(gVmbusConnection.ChannelLock);
+	ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelList)
+	{
+		channel = CONTAINING_RECORD(curr, VMBUS_CHANNEL, ListEntry);
+
+		if (channel->OfferMsg.ChildRelId == relId)
+		{
+			foundChannel = channel;
+			break;
+		}
+	}
+	SpinlockRelease(gVmbusConnection.ChannelLock);
+
+	return foundChannel;
+}
+
+
+
+/*++
+
+Name:
+	VmbusProcessChannelEvent()
+
+Description:
+	Process a channel event notification
+
+--*/
+static void
+VmbusProcessChannelEvent(
+	PVOID context
+	)
+{
+	VMBUS_CHANNEL* channel;
+	UINT32 relId = (UINT32)(ULONG_PTR)context;
+
+	ASSERT(relId > 0);
+
+	// Find the channel based on this relid and invokes
+	// the channel callback to process the event
+	channel = GetChannelFromRelId(relId);
+
+	if (channel)
+	{
+		VmbusChannelOnChannelEvent(channel);
+		//WorkQueueQueueWorkItem(channel->dataWorkQueue, VmbusChannelOnChannelEvent, (void*)channel);
+	}
+	else
+	{
+        DPRINT_ERR(VMBUS, "channel not found for relid - %d.", relId);
+	}
+}
+
+
+/*++
+
+Name:
+	VmbusOnEvents()
+
+Description:
+	Handler for events
+
+--*/
+VOID
+VmbusOnEvents(
+  VOID
+	)
+{
+	int dword;
+	//int maxdword = PAGE_SIZE >> 3; // receive size is 1/2 page and divide that by 4 bytes
+	int maxdword = MAX_NUM_CHANNELS_SUPPORTED >> 5;
+	int bit;
+	int relid;
+	UINT32* recvInterruptPage = gVmbusConnection.RecvInterruptPage;
+	//VMBUS_CHANNEL_MESSAGE* receiveMsg;
+
+	DPRINT_ENTER(VMBUS);
+
+	// Check events
+	if (recvInterruptPage)
+	{
+		for (dword = 0; dword < maxdword; dword++)
+		{
+			if (recvInterruptPage[dword])
+			{
+				for (bit = 0; bit < 32; bit++)
+				{
+					if (BitTestAndClear(&recvInterruptPage[dword], bit))
+					{
+						relid = (dword << 5) + bit;
+
+						DPRINT_DBG(VMBUS, "event detected for relid - %d", relid);
+
+						if (relid == 0) // special case - vmbus channel protocol msg
+						{
+							DPRINT_DBG(VMBUS, "invalid relid - %d", relid);
+
+							continue;						}
+						else
+						{
+							//QueueWorkItem(VmbusProcessEvent, (void*)relid);
+							//ret = WorkQueueQueueWorkItem(gVmbusConnection.workQueue, VmbusProcessChannelEvent, (void*)relid);
+							VmbusProcessChannelEvent((void*)(ULONG_PTR)relid);
+						}
+					}
+				}
+			}
+		 }
+	}
+	DPRINT_EXIT(VMBUS);
+
+	return;
+}
+
+/*++
+
+Name:
+	VmbusPostMessage()
+
+Description:
+	Send a msg on the vmbus's message connection
+
+--*/
+int
+VmbusPostMessage(
+	PVOID			buffer,
+	SIZE_T			bufferLen
+	)
+{
+	int ret=0;
+	HV_CONNECTION_ID connId;
+
+
+	connId.AsUINT32 =0;
+	connId.u.Id = VMBUS_MESSAGE_CONNECTION_ID;
+	ret = HvPostMessage(
+			connId,
+			1,
+			buffer,
+			bufferLen);
+
+	return  ret;
+}
+
+/*++
+
+Name:
+	VmbusSetEvent()
+
+Description:
+	Send an event notification to the parent
+
+--*/
+int
+VmbusSetEvent(UINT32 childRelId)
+{
+	int ret=0;
+
+	DPRINT_ENTER(VMBUS);
+
+	// Each UINT32 represents 32 channels
+	BitSet((UINT32*)gVmbusConnection.SendInterruptPage + (childRelId >> 5), childRelId & 31);
+	ret = HvSignalEvent();
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+// EOF

drivers/staging/hv/Hv.c

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#include "logging.h"
+#include "VmbusPrivate.h"
+
+//
+// Globals
+//
+
+// The one and only
+HV_CONTEXT gHvContext={
+	.SynICInitialized = FALSE,
+	.HypercallPage = NULL,
+	.SignalEventParam = NULL,
+	.SignalEventBuffer = NULL,
+};
+
+
+/*++
+
+Name:
+	HvQueryHypervisorPresence()
+
+Description:
+	Query the cpuid for presense of windows hypervisor
+
+--*/
+static int
+HvQueryHypervisorPresence (
+    void
+    )
+{
+    unsigned int eax;
+    unsigned int ebx;
+    unsigned int ecx;
+    unsigned int edx;
+    unsigned int op;
+
+    eax = 0;
+    ebx = 0;
+    ecx = 0;
+    edx = 0;
+    op = HvCpuIdFunctionVersionAndFeatures;
+    do_cpuid(op, &eax, &ebx, &ecx, &edx);
+
+	return (ecx & HV_PRESENT_BIT);
+}
+
+
+/*++
+
+Name:
+	HvQueryHypervisorInfo()
+
+Description:
+	Get version info of the windows hypervisor
+
+--*/
+static int
+HvQueryHypervisorInfo (
+    void
+    )
+{
+    unsigned int eax;
+    unsigned int ebx;
+    unsigned int ecx;
+    unsigned int edx;
+    unsigned int maxLeaf;
+    unsigned int op;
+
+    //
+    // Its assumed that this is called after confirming that Viridian is present.
+    // Query id and revision.
+    //
+
+    eax = 0;
+    ebx = 0;
+    ecx = 0;
+    edx = 0;
+    op = HvCpuIdFunctionHvVendorAndMaxFunction;
+    do_cpuid(op, &eax, &ebx, &ecx, &edx);
+
+    DPRINT_INFO(VMBUS, "Vendor ID: %c%c%c%c%c%c%c%c%c%c%c%c",
+           (ebx & 0xFF),
+           ((ebx >> 8) & 0xFF),
+           ((ebx >> 16) & 0xFF),
+           ((ebx >> 24) & 0xFF),
+           (ecx & 0xFF),
+           ((ecx >> 8) & 0xFF),
+           ((ecx >> 16) & 0xFF),
+           ((ecx >> 24) & 0xFF),
+           (edx & 0xFF),
+           ((edx >> 8) & 0xFF),
+           ((edx >> 16) & 0xFF),
+           ((edx >> 24) & 0xFF));
+
+    maxLeaf = eax;
+    eax = 0;
+    ebx = 0;
+    ecx = 0;
+    edx = 0;
+    op = HvCpuIdFunctionHvInterface;
+    do_cpuid(op, &eax, &ebx, &ecx, &edx);
+
+    DPRINT_INFO(VMBUS, "Interface ID: %c%c%c%c",
+           (eax & 0xFF),
+           ((eax >> 8) & 0xFF),
+           ((eax >> 16) & 0xFF),
+           ((eax >> 24) & 0xFF));
+
+	 if (maxLeaf >= HvCpuIdFunctionMsHvVersion) {
+        eax = 0;
+        ebx = 0;
+        ecx = 0;
+        edx = 0;
+        op = HvCpuIdFunctionMsHvVersion;
+        do_cpuid(op, &eax, &ebx, &ecx, &edx);
+        DPRINT_INFO(VMBUS, "OS Build:%d-%d.%d-%d-%d.%d",
+               eax,
+               ebx >> 16,
+               ebx & 0xFFFF,
+               ecx,
+               edx >> 24,
+               edx & 0xFFFFFF);
+    }
+    return maxLeaf;
+}
+
+
+/*++
+
+Name:
+	HvDoHypercall()
+
+Description:
+	Invoke the specified hypercall
+
+--*/
+static UINT64
+HvDoHypercall (
+    UINT64  Control,
+    void*   Input,
+    void*   Output
+    )
+{
+#ifdef x86_64
+    UINT64 hvStatus=0;
+    UINT64 inputAddress = (Input)? GetPhysicalAddress(Input) : 0;
+	UINT64 outputAddress = (Output)? GetPhysicalAddress(Output) : 0;
+    volatile void* hypercallPage = gHvContext.HypercallPage;
+
+    DPRINT_DBG(VMBUS, "Hypercall <control %llx input phys %llx virt %p output phys %llx virt %p hypercall %p>",
+		Control,
+		inputAddress,
+		Input,
+		outputAddress,
+		Output,
+		hypercallPage);
+
+	__asm__ __volatile__ ("mov %0, %%r8" : : "r" (outputAddress):  "r8");
+	__asm__ __volatile__ ("call *%3" : "=a"(hvStatus): "c" (Control), "d" (inputAddress), "m" (hypercallPage));
+
+    DPRINT_DBG(VMBUS, "Hypercall <return %llx>",  hvStatus);
+
+    return hvStatus;
+
+#else
+
+    UINT32 controlHi = Control >> 32;
+    UINT32 controlLo = Control & 0xFFFFFFFF;
+    UINT32 hvStatusHi = 1;
+    UINT32 hvStatusLo = 1;
+    UINT64 inputAddress = (Input) ? GetPhysicalAddress(Input) : 0;
+    UINT32 inputAddressHi = inputAddress >> 32;
+    UINT32 inputAddressLo = inputAddress & 0xFFFFFFFF;
+	UINT64 outputAddress = (Output) ?GetPhysicalAddress(Output) : 0;
+    UINT32 outputAddressHi = outputAddress >> 32;
+    UINT32 outputAddressLo = outputAddress & 0xFFFFFFFF;
+    volatile void* hypercallPage = gHvContext.HypercallPage;
+
+    DPRINT_DBG(VMBUS, "Hypercall <control %llx input %p output %p>",
+		Control,
+		Input,
+		Output);
+
+	__asm__ __volatile__ ("call *%8" : "=d"(hvStatusHi), "=a"(hvStatusLo) : "d" (controlHi), "a" (controlLo), "b" (inputAddressHi), "c" (inputAddressLo), "D"(outputAddressHi), "S"(outputAddressLo), "m" (hypercallPage));
+
+
+    DPRINT_DBG(VMBUS, "Hypercall <return %llx>",  hvStatusLo | ((UINT64)hvStatusHi << 32));
+
+    return (hvStatusLo | ((UINT64)hvStatusHi << 32));
+#endif // x86_64
+}
+
+/*++
+
+Name:
+	HvInit()
+
+Description:
+	Main initialization routine. This routine must be called
+	before any other routines in here are called
+
+--*/
+static int
+HvInit (
+    void
+    )
+{
+	int ret=0;
+    int maxLeaf;
+	HV_X64_MSR_HYPERCALL_CONTENTS hypercallMsr;
+	void* virtAddr=0;
+	ULONG_PTR physAddr=0;
+
+	DPRINT_ENTER(VMBUS);
+
+	memset(gHvContext.synICEventPage, 0, sizeof(HANDLE)*MAX_NUM_CPUS);
+	memset(gHvContext.synICMessagePage, 0, sizeof(HANDLE)*MAX_NUM_CPUS);
+
+	if (!HvQueryHypervisorPresence())
+	{
+		DPRINT_ERR(VMBUS, "No Windows hypervisor detected!!");
+		goto Cleanup;
+	}
+
+	DPRINT_INFO(VMBUS, "Windows hypervisor detected! Retrieving more info...");
+
+    maxLeaf = HvQueryHypervisorInfo();
+    //HvQueryHypervisorFeatures(maxLeaf);
+
+	// Determine if we are running on xenlinux (ie x2v shim) or native linux
+	gHvContext.GuestId = ReadMsr(HV_X64_MSR_GUEST_OS_ID);
+
+	if (gHvContext.GuestId == 0)
+	{
+		// Write our OS info
+		WriteMsr(HV_X64_MSR_GUEST_OS_ID, HV_LINUX_GUEST_ID);
+
+		gHvContext.GuestId = HV_LINUX_GUEST_ID;
+	}
+
+	// See if the hypercall page is already set
+	hypercallMsr.AsUINT64 = ReadMsr(HV_X64_MSR_HYPERCALL);
+
+	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
+	{
+		// Allocate the hypercall page memory
+		//virtAddr = PageAlloc(1);
+		virtAddr = VirtualAllocExec(PAGE_SIZE);
+
+		if (!virtAddr)
+		{
+			DPRINT_ERR(VMBUS, "unable to allocate hypercall page!!");
+			goto Cleanup;
+		}
+
+		hypercallMsr.Enable = 1;
+		//hypercallMsr.GuestPhysicalAddress = Logical2PhysicalAddr(virtAddr) >> PAGE_SHIFT;
+		hypercallMsr.GuestPhysicalAddress = Virtual2Physical(virtAddr) >> PAGE_SHIFT;
+		WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
+
+        // Confirm that hypercall page did get setup.
+		hypercallMsr.AsUINT64 = 0;
+		hypercallMsr.AsUINT64 = ReadMsr(HV_X64_MSR_HYPERCALL);
+
+		if (!hypercallMsr.Enable)
+		{
+			DPRINT_ERR(VMBUS, "unable to set hypercall page!!");
+			goto Cleanup;
+		}
+
+		gHvContext.HypercallPage = virtAddr;
+	}
+	else
+	{
+		DPRINT_ERR(VMBUS, "Unknown guest id (0x%llx)!!", gHvContext.GuestId);
+		goto Cleanup;
+	}
+
+    DPRINT_INFO(VMBUS, "Hypercall page VA=0x%08x, PA=0x%08x",
+               (unsigned long)gHvContext.HypercallPage,
+               (unsigned long)hypercallMsr.GuestPhysicalAddress << PAGE_SHIFT);
+
+	// Setup the global signal event param for the signal event hypercall
+	gHvContext.SignalEventBuffer = MemAlloc(sizeof(HV_INPUT_SIGNAL_EVENT_BUFFER));
+	if (!gHvContext.SignalEventBuffer)
+	{
+		goto Cleanup;
+	}
+
+	gHvContext.SignalEventParam = (PHV_INPUT_SIGNAL_EVENT)(ALIGN_UP((ULONG_PTR)gHvContext.SignalEventBuffer, HV_HYPERCALL_PARAM_ALIGN));
+	gHvContext.SignalEventParam->ConnectionId.AsUINT32 = 0;
+	gHvContext.SignalEventParam->ConnectionId.u.Id = VMBUS_EVENT_CONNECTION_ID;
+	gHvContext.SignalEventParam->FlagNumber = 0;
+	gHvContext.SignalEventParam->RsvdZ = 0;
+
+    //DPRINT_DBG(VMBUS, "My id %llu", HvGetCurrentPartitionId());
+
+	DPRINT_EXIT(VMBUS);
+
+    return ret;
+
+Cleanup:
+	if (virtAddr)
+	{
+		if (hypercallMsr.Enable)
+		{
+			hypercallMsr.AsUINT64 = 0;
+			WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
+		}
+
+		VirtualFree(virtAddr);
+	}
+	ret = -1;
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+/*++
+
+Name:
+	HvCleanup()
+
+Description:
+	Cleanup routine. This routine is called normally during driver unloading or exiting.
+
+--*/
+void
+HvCleanup (
+    void
+    )
+{
+	HV_X64_MSR_HYPERCALL_CONTENTS hypercallMsr;
+
+	DPRINT_ENTER(VMBUS);
+
+	if (gHvContext.SignalEventBuffer)
+	{
+		MemFree(gHvContext.SignalEventBuffer);
+		gHvContext.SignalEventBuffer = NULL;
+		gHvContext.SignalEventParam = NULL;
+	}
+
+	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
+	{
+		if (gHvContext.HypercallPage)
+		{
+			hypercallMsr.AsUINT64 = 0;
+			WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
+			VirtualFree(gHvContext.HypercallPage);
+			gHvContext.HypercallPage = NULL;
+		}
+	}
+
+	DPRINT_EXIT(VMBUS);
+
+}
+
+
+/*++
+
+Name:
+	HvPostMessage()
+
+Description:
+	Post a message using the hypervisor message IPC. This
+	involves a hypercall.
+
+--*/
+HV_STATUS
+HvPostMessage(
+	HV_CONNECTION_ID connectionId,
+	HV_MESSAGE_TYPE  messageType,
+	PVOID            payload,
+	SIZE_T           payloadSize
+	)
+{
+	struct alignedInput {
+		UINT64					alignment8;
+		HV_INPUT_POST_MESSAGE	msg;
+	};
+
+	PHV_INPUT_POST_MESSAGE alignedMsg;
+	HV_STATUS status;
+	ULONG_PTR addr;
+
+	if (payloadSize > HV_MESSAGE_PAYLOAD_BYTE_COUNT)
+	{
+		return -1;
+	}
+
+	addr = (ULONG_PTR)MemAllocAtomic(sizeof(struct alignedInput));
+
+	if (!addr)
+	{
+		return -1;
+	}
+
+	alignedMsg = (PHV_INPUT_POST_MESSAGE)(ALIGN_UP(addr, HV_HYPERCALL_PARAM_ALIGN));
+
+	alignedMsg->ConnectionId = connectionId;
+	alignedMsg->MessageType = messageType;
+	alignedMsg->PayloadSize = payloadSize;
+	memcpy((void*)alignedMsg->Payload, payload, payloadSize);
+
+	status = HvDoHypercall(HvCallPostMessage, alignedMsg, 0) & 0xFFFF;
+
+	MemFree((void*)addr);
+
+	return status;
+}
+
+
+/*++
+
+Name:
+	HvSignalEvent()
+
+Description:
+	Signal an event on the specified connection using the hypervisor event IPC. This
+	involves a hypercall.
+
+--*/
+HV_STATUS
+HvSignalEvent(
+	)
+{
+	HV_STATUS status;
+
+	status = HvDoHypercall(HvCallSignalEvent, gHvContext.SignalEventParam, 0) & 0xFFFF;
+
+	return status;
+}
+
+
+/*++
+
+Name:
+	HvSynicInit()
+
+Description:
+	Initialize the Synthethic Interrupt Controller. If it is already initialized by
+	another entity (ie x2v shim), we need to retrieve the initialized message and event pages.
+	Otherwise, we create and initialize the message and event pages.
+
+--*/
+int
+HvSynicInit (
+	UINT32 irqVector
+	)
+{
+	UINT64			version;
+	HV_SYNIC_SIMP	simp;
+	HV_SYNIC_SIEFP	siefp;
+    HV_SYNIC_SINT	sharedSint;
+	HV_SYNIC_SCONTROL sctrl;
+	UINT64			guestID;
+	int ret=0;
+
+	DPRINT_ENTER(VMBUS);
+
+	if (!gHvContext.HypercallPage)
+	{
+		DPRINT_EXIT(VMBUS);
+		return ret;
+	}
+
+	// Check the version
+	version = ReadMsr(HV_X64_MSR_SVERSION);
+
+	DPRINT_INFO(VMBUS, "SynIC version: %llx", version);
+
+	// TODO: Handle SMP
+	if (gHvContext.GuestId == HV_XENLINUX_GUEST_ID)
+	{
+		DPRINT_INFO(VMBUS, "Skipping SIMP and SIEFP setup since it is already set.");
+
+		simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
+		siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
+
+		DPRINT_DBG(VMBUS, "Simp: %llx, Sifep: %llx", simp.AsUINT64, siefp.AsUINT64);
+
+		// Determine if we are running on xenlinux (ie x2v shim) or native linux
+		guestID = ReadMsr(HV_X64_MSR_GUEST_OS_ID);
+
+		if (guestID == HV_LINUX_GUEST_ID)
+		{
+			gHvContext.synICMessagePage[0] = GetVirtualAddress(simp.BaseSimpGpa << PAGE_SHIFT);
+			gHvContext.synICEventPage[0] = GetVirtualAddress(siefp.BaseSiefpGpa << PAGE_SHIFT);
+		}
+		else
+		{
+			DPRINT_ERR(VMBUS, "unknown guest id!!");
+			goto Cleanup;
+		}
+		DPRINT_DBG(VMBUS, "MAPPED: Simp: %p, Sifep: %p", gHvContext.synICMessagePage[0], gHvContext.synICEventPage[0]);
+	}
+	else
+	{
+		gHvContext.synICMessagePage[0] = PageAlloc(1);
+		if (gHvContext.synICMessagePage[0] == NULL)
+		{
+			DPRINT_ERR(VMBUS, "unable to allocate SYNIC message page!!");
+			goto Cleanup;
+		}
+
+		gHvContext.synICEventPage[0] = PageAlloc(1);
+		if (gHvContext.synICEventPage[0] == NULL)
+		{
+			DPRINT_ERR(VMBUS, "unable to allocate SYNIC event page!!");
+			goto Cleanup;
+		}
+
+		//
+		// Setup the Synic's message page
+		//
+		simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
+		simp.SimpEnabled = 1;
+		simp.BaseSimpGpa = GetPhysicalAddress(gHvContext.synICMessagePage[0]) >> PAGE_SHIFT;
+
+		DPRINT_DBG(VMBUS, "HV_X64_MSR_SIMP msr set to: %llx", simp.AsUINT64);
+
+		WriteMsr(HV_X64_MSR_SIMP, simp.AsUINT64);
+
+		//
+		// Setup the Synic's event page
+		//
+		siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
+		siefp.SiefpEnabled = 1;
+		siefp.BaseSiefpGpa = GetPhysicalAddress(gHvContext.synICEventPage[0]) >> PAGE_SHIFT;
+
+		DPRINT_DBG(VMBUS, "HV_X64_MSR_SIEFP msr set to: %llx", siefp.AsUINT64);
+
+		WriteMsr(HV_X64_MSR_SIEFP, siefp.AsUINT64);
+	}
+	//
+    // Setup the interception SINT.
+    //
+	//WriteMsr((HV_X64_MSR_SINT0 + HV_SYNIC_INTERCEPTION_SINT_INDEX),
+    //             interceptionSint.AsUINT64);
+
+    //
+    // Setup the shared SINT.
+    //
+	sharedSint.AsUINT64 = ReadMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT);
+
+	sharedSint.AsUINT64 = 0;
+    sharedSint.Vector = irqVector; //HV_SHARED_SINT_IDT_VECTOR + 0x20;
+    sharedSint.Masked = FALSE;
+    sharedSint.AutoEoi = TRUE;
+
+	DPRINT_DBG(VMBUS, "HV_X64_MSR_SINT1 msr set to: %llx", sharedSint.AsUINT64);
+
+	WriteMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);
+
+	// Enable the global synic bit
+	sctrl.AsUINT64 = ReadMsr(HV_X64_MSR_SCONTROL);
+	sctrl.Enable = 1;
+
+    WriteMsr(HV_X64_MSR_SCONTROL, sctrl.AsUINT64);
+
+	gHvContext.SynICInitialized = TRUE;
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+
+Cleanup:
+	ret = -1;
+
+	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
+	{
+		if (gHvContext.synICEventPage[0])
+		{
+			PageFree(gHvContext.synICEventPage[0],1);
+		}
+
+		if (gHvContext.synICMessagePage[0])
+		{
+			PageFree(gHvContext.synICMessagePage[0], 1);
+		}
+	}
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+
+}
+
+/*++
+
+Name:
+	HvSynicCleanup()
+
+Description:
+	Cleanup routine for HvSynicInit().
+
+--*/
+VOID
+HvSynicCleanup(
+	VOID
+	)
+{
+    HV_SYNIC_SINT	sharedSint;
+	HV_SYNIC_SIMP	simp;
+	HV_SYNIC_SIEFP	siefp;
+
+	DPRINT_ENTER(VMBUS);
+
+	if (!gHvContext.SynICInitialized)
+	{
+		DPRINT_EXIT(VMBUS);
+		return;
+	}
+
+	sharedSint.AsUINT64 = ReadMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT);
+
+	sharedSint.Masked = 1;
+
+	// Disable the interrupt
+    WriteMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);
+
+	// Disable and free the resources only if we are running as native linux
+	// since in xenlinux, we are sharing the resources with the x2v shim
+	if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
+	{
+		simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
+		simp.SimpEnabled = 0;
+		simp.BaseSimpGpa = 0;
+
+		WriteMsr(HV_X64_MSR_SIMP, simp.AsUINT64);
+
+		siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
+		siefp.SiefpEnabled = 0;
+		siefp.BaseSiefpGpa = 0;
+
+		WriteMsr(HV_X64_MSR_SIEFP, siefp.AsUINT64);
+
+		PageFree(gHvContext.synICMessagePage[0], 1);
+		PageFree(gHvContext.synICEventPage[0], 1);
+	}
+
+	DPRINT_EXIT(VMBUS);
+}
+
+
+// eof

drivers/staging/hv/Hv.h

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#ifndef __HV_H__
+#define __HV_H__
+
+#include "osd.h"
+
+#include "HvTypes.h"
+#include "HvStatus.h"
+//#include "HvVmApi.h"
+//#include "HvKeApi.h"
+//#include "HvMmApi.h"
+//#include "HvCpuApi.h"
+#include "HvHalApi.h"
+#include "HvVpApi.h"
+//#include "HvTrApi.h"
+#include "HvSynicApi.h"
+//#include "HvAmApi.h"
+//#include "HvHkApi.h"
+//#include "HvValApi.h"
+#include "HvHcApi.h"
+#include "HvPtApi.h"
+
+enum
+{
+    VMBUS_MESSAGE_CONNECTION_ID = 1,
+    VMBUS_MESSAGE_PORT_ID       = 1,
+    VMBUS_EVENT_CONNECTION_ID   = 2,
+    VMBUS_EVENT_PORT_ID         = 2,
+    VMBUS_MONITOR_CONNECTION_ID = 3,
+    VMBUS_MONITOR_PORT_ID       = 3,
+    VMBUS_MESSAGE_SINT          = 2
+};
+//
+// #defines
+//
+#define HV_PRESENT_BIT				0x80000000
+
+#define HV_XENLINUX_GUEST_ID_LO     0x00000000
+#define HV_XENLINUX_GUEST_ID_HI		0x0B00B135
+#define HV_XENLINUX_GUEST_ID		(((UINT64)HV_XENLINUX_GUEST_ID_HI << 32) | HV_XENLINUX_GUEST_ID_LO)
+
+#define HV_LINUX_GUEST_ID_LO		0x00000000
+#define HV_LINUX_GUEST_ID_HI		0xB16B00B5
+#define HV_LINUX_GUEST_ID			(((UINT64)HV_LINUX_GUEST_ID_HI << 32) | HV_LINUX_GUEST_ID_LO)
+
+#define HV_CPU_POWER_MANAGEMENT     (1 << 0)
+#define HV_RECOMMENDATIONS_MAX      4
+
+#define HV_X64_MAX                  5
+#define HV_CAPS_MAX                 8
+
+
+#define HV_HYPERCALL_PARAM_ALIGN	sizeof(UINT64)
+
+//
+// Service definitions
+//
+#define HV_SERVICE_PARENT_PORT (0)
+#define HV_SERVICE_PARENT_CONNECTION (0)
+
+#define HV_SERVICE_CONNECT_RESPONSE_SUCCESS             (0)
+#define HV_SERVICE_CONNECT_RESPONSE_INVALID_PARAMETER   (1)
+#define HV_SERVICE_CONNECT_RESPONSE_UNKNOWN_SERVICE     (2)
+#define HV_SERVICE_CONNECT_RESPONSE_CONNECTION_REJECTED (3)
+
+#define HV_SERVICE_CONNECT_REQUEST_MESSAGE_ID		(1)
+#define HV_SERVICE_CONNECT_RESPONSE_MESSAGE_ID		(2)
+#define HV_SERVICE_DISCONNECT_REQUEST_MESSAGE_ID	(3)
+#define HV_SERVICE_DISCONNECT_RESPONSE_MESSAGE_ID	(4)
+#define HV_SERVICE_MAX_MESSAGE_ID					(4)
+
+#define HV_SERVICE_PROTOCOL_VERSION (0x0010)
+#define HV_CONNECT_PAYLOAD_BYTE_COUNT 64
+
+//#define VMBUS_REVISION_NUMBER	6
+//#define VMBUS_PORT_ID			11		// Our local vmbus's port and connection id. Anything >0 is fine
+
+// 628180B8-308D-4c5e-B7DB-1BEB62E62EF4
+static const GUID VMBUS_SERVICE_ID = {.Data = {0xb8, 0x80, 0x81, 0x62, 0x8d, 0x30, 0x5e, 0x4c, 0xb7, 0xdb, 0x1b, 0xeb, 0x62, 0xe6, 0x2e, 0xf4} };
+
+#define MAX_NUM_CPUS	1
+
+
+typedef struct {
+	UINT64					Align8;
+	HV_INPUT_SIGNAL_EVENT	Event;
+} HV_INPUT_SIGNAL_EVENT_BUFFER;
+
+typedef struct {
+	UINT64	GuestId;			// XenLinux or native Linux. If XenLinux, the hypercall and synic pages has already been initialized
+	void*	HypercallPage;
+
+	BOOL	SynICInitialized;
+	// This is used as an input param to HvCallSignalEvent hypercall. The input param is immutable
+	// in our usage and must be dynamic mem (vs stack or global).
+	HV_INPUT_SIGNAL_EVENT_BUFFER *SignalEventBuffer;
+	HV_INPUT_SIGNAL_EVENT *SignalEventParam; // 8-bytes aligned of the buffer above
+
+	HANDLE	synICMessagePage[MAX_NUM_CPUS];
+	HANDLE	synICEventPage[MAX_NUM_CPUS];
+} HV_CONTEXT;
+
+extern HV_CONTEXT gHvContext;
+
+
+//
+// Inline routines
+//
+static inline unsigned long long ReadMsr(int msr)
+{
+	unsigned long long val;
+
+	RDMSR(msr, val);
+
+	return val;
+}
+
+static inline void WriteMsr(int msr, UINT64 val)
+{
+	WRMSR(msr, val);
+
+	return;
+}
+
+//
+// Hv Interface
+//
+INTERNAL int
+HvInit(
+    VOID
+    );
+
+INTERNAL VOID
+HvCleanup(
+    VOID
+    );
+
+INTERNAL HV_STATUS
+HvPostMessage(
+	HV_CONNECTION_ID connectionId,
+	HV_MESSAGE_TYPE  messageType,
+	PVOID            payload,
+	SIZE_T           payloadSize
+	);
+
+INTERNAL HV_STATUS
+HvSignalEvent(
+	VOID
+	);
+
+INTERNAL int
+HvSynicInit(
+	UINT32		irqVector
+	);
+
+INTERNAL VOID
+HvSynicCleanup(
+	VOID
+	);
+
+#endif // __HV_H__

drivers/staging/hv/RingBuffer.c

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#include "logging.h"
+#include "RingBuffer.h"
+
+//
+// #defines
+//
+
+// Amount of space to write to
+#define BYTES_AVAIL_TO_WRITE(r, w, z) ((w) >= (r))?((z) - ((w) - (r))):((r) - (w))
+
+
+/*++
+
+Name:
+	GetRingBufferAvailBytes()
+
+Description:
+	Get number of bytes available to read and to write to
+	for the specified ring buffer
+
+--*/
+static inline void
+GetRingBufferAvailBytes(RING_BUFFER_INFO *rbi, UINT32 *read, UINT32 *write)
+{
+	UINT32 read_loc,write_loc;
+
+	// Capture the read/write indices before they changed
+	read_loc = rbi->RingBuffer->ReadIndex;
+	write_loc = rbi->RingBuffer->WriteIndex;
+
+	*write = BYTES_AVAIL_TO_WRITE(read_loc, write_loc, rbi->RingDataSize);
+	*read = rbi->RingDataSize - *write;
+}
+
+/*++
+
+Name:
+	GetNextWriteLocation()
+
+Description:
+	Get the next write location for the specified ring buffer
+
+--*/
+static inline UINT32
+GetNextWriteLocation(RING_BUFFER_INFO* RingInfo)
+{
+	UINT32 next = RingInfo->RingBuffer->WriteIndex;
+
+	ASSERT(next < RingInfo->RingDataSize);
+
+	return next;
+}
+
+/*++
+
+Name:
+	SetNextWriteLocation()
+
+Description:
+	Set the next write location for the specified ring buffer
+
+--*/
+static inline void
+SetNextWriteLocation(RING_BUFFER_INFO* RingInfo, UINT32 NextWriteLocation)
+{
+	RingInfo->RingBuffer->WriteIndex = NextWriteLocation;
+}
+
+/*++
+
+Name:
+	GetNextReadLocation()
+
+Description:
+	Get the next read location for the specified ring buffer
+
+--*/
+static inline UINT32
+GetNextReadLocation(RING_BUFFER_INFO* RingInfo)
+{
+	UINT32 next = RingInfo->RingBuffer->ReadIndex;
+
+	ASSERT(next < RingInfo->RingDataSize);
+
+	return next;
+}
+
+/*++
+
+Name:
+	GetNextReadLocationWithOffset()
+
+Description:
+	Get the next read location + offset for the specified ring buffer.
+	This allows the caller to skip
+
+--*/
+static inline UINT32
+GetNextReadLocationWithOffset(RING_BUFFER_INFO* RingInfo, UINT32 Offset)
+{
+	UINT32 next = RingInfo->RingBuffer->ReadIndex;
+
+	ASSERT(next < RingInfo->RingDataSize);
+	next += Offset;
+	next %= RingInfo->RingDataSize;
+
+	return next;
+}
+
+/*++
+
+Name:
+	SetNextReadLocation()
+
+Description:
+	Set the next read location for the specified ring buffer
+
+--*/
+static inline void
+SetNextReadLocation(RING_BUFFER_INFO* RingInfo, UINT32 NextReadLocation)
+{
+	RingInfo->RingBuffer->ReadIndex = NextReadLocation;
+}
+
+
+/*++
+
+Name:
+	GetRingBuffer()
+
+Description:
+	Get the start of the ring buffer
+
+--*/
+static inline PVOID
+GetRingBuffer(RING_BUFFER_INFO* RingInfo)
+{
+	return (PVOID)RingInfo->RingBuffer->Buffer;
+}
+
+
+/*++
+
+Name:
+	GetRingBufferSize()
+
+Description:
+	Get the size of the ring buffer
+
+--*/
+static inline UINT32
+GetRingBufferSize(RING_BUFFER_INFO* RingInfo)
+{
+	return RingInfo->RingDataSize;
+}
+
+/*++
+
+Name:
+	GetRingBufferIndices()
+
+Description:
+	Get the read and write indices as UINT64 of the specified ring buffer
+
+--*/
+static inline UINT64
+GetRingBufferIndices(RING_BUFFER_INFO* RingInfo)
+{
+	return ((UINT64)RingInfo->RingBuffer->WriteIndex << 32) || RingInfo->RingBuffer->ReadIndex;
+}
+
+
+/*++
+
+Name:
+	DumpRingInfo()
+
+Description:
+	Dump out to console the ring buffer info
+
+--*/
+void
+DumpRingInfo(RING_BUFFER_INFO* RingInfo, char *Prefix)
+{
+	UINT32 bytesAvailToWrite;
+	UINT32 bytesAvailToRead;
+
+	GetRingBufferAvailBytes(RingInfo, &bytesAvailToRead, &bytesAvailToWrite);
+
+	DPRINT(VMBUS, DEBUG_RING_LVL, "%s <<ringinfo %p buffer %p avail write %u avail read %u read idx %u write idx %u>>",
+		Prefix,
+		RingInfo,
+		RingInfo->RingBuffer->Buffer,
+		bytesAvailToWrite,
+		bytesAvailToRead,
+		RingInfo->RingBuffer->ReadIndex,
+		RingInfo->RingBuffer->WriteIndex);
+}
+
+//
+// Internal routines
+//
+static UINT32
+CopyToRingBuffer(
+	RING_BUFFER_INFO	*RingInfo,
+	UINT32				StartWriteOffset,
+	PVOID				Src,
+	UINT32				SrcLen);
+
+static UINT32
+CopyFromRingBuffer(
+	RING_BUFFER_INFO	*RingInfo,
+	PVOID				Dest,
+	UINT32				DestLen,
+	UINT32				StartReadOffset);
+
+
+
+/*++
+
+Name:
+	RingBufferGetDebugInfo()
+
+Description:
+	Get various debug metrics for the specified ring buffer
+
+--*/
+void
+RingBufferGetDebugInfo(
+	RING_BUFFER_INFO		*RingInfo,
+	RING_BUFFER_DEBUG_INFO	*DebugInfo
+	)
+{
+	UINT32 bytesAvailToWrite;
+	UINT32 bytesAvailToRead;
+
+	if (RingInfo->RingBuffer)
+	{
+		GetRingBufferAvailBytes(RingInfo, &bytesAvailToRead, &bytesAvailToWrite);
+
+		DebugInfo->BytesAvailToRead = bytesAvailToRead;
+		DebugInfo->BytesAvailToWrite = bytesAvailToWrite;
+		DebugInfo->CurrentReadIndex = RingInfo->RingBuffer->ReadIndex;
+		DebugInfo->CurrentWriteIndex = RingInfo->RingBuffer->WriteIndex;
+
+		DebugInfo->CurrentInterruptMask = RingInfo->RingBuffer->InterruptMask;
+	}
+}
+
+
+/*++
+
+Name:
+	GetRingBufferInterruptMask()
+
+Description:
+	Get the interrupt mask for the specified ring buffer
+
+--*/
+UINT32
+GetRingBufferInterruptMask(
+	RING_BUFFER_INFO *rbi
+	)
+{
+	return rbi->RingBuffer->InterruptMask;
+}
+
+/*++
+
+Name:
+	RingBufferInit()
+
+Description:
+	Initialize the ring buffer
+
+--*/
+int
+RingBufferInit(
+	RING_BUFFER_INFO	*RingInfo,
+	VOID				*Buffer,
+	UINT32				BufferLen
+	)
+{
+	ASSERT(sizeof(RING_BUFFER) == PAGE_SIZE);
+
+	memset(RingInfo, 0, sizeof(RING_BUFFER_INFO));
+
+	RingInfo->RingBuffer = (RING_BUFFER*)Buffer;
+	RingInfo->RingBuffer->ReadIndex = RingInfo->RingBuffer->WriteIndex = 0;
+
+	RingInfo->RingSize = BufferLen;
+	RingInfo->RingDataSize = BufferLen - sizeof(RING_BUFFER);
+
+	RingInfo->RingLock = SpinlockCreate();
+
+	return 0;
+}
+
+/*++
+
+Name:
+	RingBufferCleanup()
+
+Description:
+	Cleanup the ring buffer
+
+--*/
+void
+RingBufferCleanup(
+	RING_BUFFER_INFO* RingInfo
+	)
+{
+	SpinlockClose(RingInfo->RingLock);
+}
+
+/*++
+
+Name:
+	RingBufferWrite()
+
+Description:
+	Write to the ring buffer
+
+--*/
+int
+RingBufferWrite(
+	RING_BUFFER_INFO*	OutRingInfo,
+	SG_BUFFER_LIST		SgBuffers[],
+	UINT32				SgBufferCount
+	)
+{
+	int i=0;
+	UINT32 byteAvailToWrite;
+	UINT32 byteAvailToRead;
+	UINT32 totalBytesToWrite=0;
+
+	volatile UINT32 nextWriteLocation;
+	UINT64 prevIndices=0;
+
+	DPRINT_ENTER(VMBUS);
+
+	for (i=0; i < SgBufferCount; i++)
+	{
+		totalBytesToWrite += SgBuffers[i].Length;
+	}
+
+	totalBytesToWrite += sizeof(UINT64);
+
+	SpinlockAcquire(OutRingInfo->RingLock);
+
+	GetRingBufferAvailBytes(OutRingInfo, &byteAvailToRead, &byteAvailToWrite);
+
+	DPRINT_DBG(VMBUS, "Writing %u bytes...", totalBytesToWrite);
+
+	//DumpRingInfo(OutRingInfo, "BEFORE ");
+
+	// If there is only room for the packet, assume it is full. Otherwise, the next time around, we think the ring buffer
+	// is empty since the read index == write index
+	if (byteAvailToWrite <= totalBytesToWrite)
+	{
+		DPRINT_DBG(VMBUS, "No more space left on outbound ring buffer (needed %u, avail %u)", totalBytesToWrite, byteAvailToWrite);
+
+		SpinlockRelease(OutRingInfo->RingLock);
+
+		DPRINT_EXIT(VMBUS);
+
+		return -1;
+	}
+
+	// Write to the ring buffer
+	nextWriteLocation = GetNextWriteLocation(OutRingInfo);
+
+	for (i=0; i < SgBufferCount; i++)
+	{
+		 nextWriteLocation = CopyToRingBuffer(OutRingInfo,
+												nextWriteLocation,
+												SgBuffers[i].Data,
+												SgBuffers[i].Length);
+	}
+
+	// Set previous packet start
+	prevIndices = GetRingBufferIndices(OutRingInfo);
+
+	nextWriteLocation = CopyToRingBuffer(OutRingInfo,
+												nextWriteLocation,
+												&prevIndices,
+												sizeof(UINT64));
+
+	// Make sure we flush all writes before updating the writeIndex
+	MemoryFence();
+
+	// Now, update the write location
+	SetNextWriteLocation(OutRingInfo, nextWriteLocation);
+
+	//DumpRingInfo(OutRingInfo, "AFTER ");
+
+	SpinlockRelease(OutRingInfo->RingLock);
+
+	DPRINT_EXIT(VMBUS);
+
+	return 0;
+}
+
+
+/*++
+
+Name:
+	RingBufferPeek()
+
+Description:
+	Read without advancing the read index
+
+--*/
+int
+RingBufferPeek(
+	RING_BUFFER_INFO*	InRingInfo,
+	void*				Buffer,
+	UINT32				BufferLen
+	)
+{
+	UINT32 bytesAvailToWrite;
+	UINT32 bytesAvailToRead;
+	UINT32 nextReadLocation=0;
+
+	SpinlockAcquire(InRingInfo->RingLock);
+
+	GetRingBufferAvailBytes(InRingInfo, &bytesAvailToRead, &bytesAvailToWrite);
+
+	// Make sure there is something to read
+	if (bytesAvailToRead < BufferLen )
+	{
+		//DPRINT_DBG(VMBUS, "got callback but not enough to read <avail to read %d read size %d>!!", bytesAvailToRead, BufferLen);
+
+		SpinlockRelease(InRingInfo->RingLock);
+
+		return -1;
+	}
+
+	// Convert to byte offset
+	nextReadLocation = GetNextReadLocation(InRingInfo);
+
+	nextReadLocation = CopyFromRingBuffer(InRingInfo,
+											Buffer,
+											BufferLen,
+											nextReadLocation);
+
+	SpinlockRelease(InRingInfo->RingLock);
+
+	return 0;
+}
+
+
+/*++
+
+Name:
+	RingBufferRead()
+
+Description:
+	Read and advance the read index
+
+--*/
+int
+RingBufferRead(
+	RING_BUFFER_INFO*	InRingInfo,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT32				Offset
+	)
+{
+	UINT32 bytesAvailToWrite;
+	UINT32 bytesAvailToRead;
+	UINT32 nextReadLocation=0;
+	UINT64 prevIndices=0;
+
+	ASSERT(BufferLen > 0);
+
+	SpinlockAcquire(InRingInfo->RingLock);
+
+	GetRingBufferAvailBytes(InRingInfo, &bytesAvailToRead, &bytesAvailToWrite);
+
+	DPRINT_DBG(VMBUS, "Reading %u bytes...", BufferLen);
+
+	//DumpRingInfo(InRingInfo, "BEFORE ");
+
+	// Make sure there is something to read
+	if (bytesAvailToRead < BufferLen )
+	{
+		DPRINT_DBG(VMBUS, "got callback but not enough to read <avail to read %d read size %d>!!", bytesAvailToRead, BufferLen);
+
+		SpinlockRelease(InRingInfo->RingLock);
+
+		return -1;
+	}
+
+	nextReadLocation = GetNextReadLocationWithOffset(InRingInfo, Offset);
+
+	nextReadLocation = CopyFromRingBuffer(InRingInfo,
+											Buffer,
+											BufferLen,
+											nextReadLocation);
+
+	nextReadLocation = CopyFromRingBuffer(InRingInfo,
+											&prevIndices,
+											sizeof(UINT64),
+											nextReadLocation);
+
+	// Make sure all reads are done before we update the read index since
+	// the writer may start writing to the read area once the read index is updated
+	MemoryFence();
+
+	// Update the read index
+	SetNextReadLocation(InRingInfo, nextReadLocation);
+
+	//DumpRingInfo(InRingInfo, "AFTER ");
+
+	SpinlockRelease(InRingInfo->RingLock);
+
+	return 0;
+}
+
+
+/*++
+
+Name:
+	CopyToRingBuffer()
+
+Description:
+	Helper routine to copy from source to ring buffer.
+	Assume there is enough room. Handles wrap-around in dest case only!!
+
+--*/
+UINT32
+CopyToRingBuffer(
+	RING_BUFFER_INFO	*RingInfo,
+	UINT32				StartWriteOffset,
+	PVOID				Src,
+	UINT32				SrcLen)
+{
+	PVOID ringBuffer=GetRingBuffer(RingInfo);
+	UINT32 ringBufferSize=GetRingBufferSize(RingInfo);
+	UINT32 fragLen;
+
+	if (SrcLen > ringBufferSize - StartWriteOffset) // wrap-around detected!
+	{
+		DPRINT_DBG(VMBUS, "wrap-around detected!");
+
+		fragLen = ringBufferSize - StartWriteOffset;
+		memcpy(ringBuffer + StartWriteOffset, Src, fragLen);
+		memcpy(ringBuffer, Src + fragLen, SrcLen - fragLen);
+	}
+	else
+	{
+		memcpy(ringBuffer + StartWriteOffset, Src, SrcLen);
+	}
+
+	StartWriteOffset += SrcLen;
+	StartWriteOffset %= ringBufferSize;
+
+	return StartWriteOffset;
+}
+
+
+/*++
+
+Name:
+	CopyFromRingBuffer()
+
+Description:
+	Helper routine to copy to source from ring buffer.
+	Assume there is enough room. Handles wrap-around in src case only!!
+
+--*/
+UINT32
+CopyFromRingBuffer(
+	RING_BUFFER_INFO	*RingInfo,
+	PVOID				Dest,
+	UINT32				DestLen,
+	UINT32				StartReadOffset)
+{
+	PVOID ringBuffer=GetRingBuffer(RingInfo);
+	UINT32 ringBufferSize=GetRingBufferSize(RingInfo);
+
+	UINT32 fragLen;
+
+	if (DestLen > ringBufferSize - StartReadOffset) // wrap-around detected at the src
+	{
+		DPRINT_DBG(VMBUS, "src wrap-around detected!");
+
+		fragLen = ringBufferSize - StartReadOffset;
+
+		memcpy(Dest, ringBuffer + StartReadOffset, fragLen);
+		memcpy(Dest + fragLen, ringBuffer, DestLen - fragLen);
+	}
+	else
+	{
+		memcpy(Dest, ringBuffer + StartReadOffset, DestLen);
+	}
+
+	StartReadOffset += DestLen;
+	StartReadOffset %= ringBufferSize;
+
+	return StartReadOffset;
+}
+
+
+// eof

drivers/staging/hv/RingBuffer.h

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#ifndef _RING_BUFFER_H_
+#define _RING_BUFFER_H_
+
+#include "osd.h"
+
+typedef struct _SG_BUFFER_LIST {
+	PVOID	Data;
+	UINT32	Length;
+} SG_BUFFER_LIST;
+
+typedef struct _RING_BUFFER {
+    volatile UINT32	WriteIndex;     // Offset in bytes from the start of ring data below
+    volatile UINT32	ReadIndex;      // Offset in bytes from the start of ring data below
+
+	volatile UINT32 InterruptMask;
+	UINT8	Reserved[4084];			// Pad it to PAGE_SIZE so that data starts on page boundary
+	// NOTE: The InterruptMask field is used only for channels but since our vmbus connection
+	// also uses this data structure and its data starts here, we commented out this field.
+	// volatile UINT32 InterruptMask;
+	// Ring data starts here + RingDataStartOffset !!! DO NOT place any fields below this !!!
+    UINT8		Buffer[0];
+} STRUCT_PACKED RING_BUFFER;
+
+typedef struct _RING_BUFFER_INFO {
+    RING_BUFFER*	RingBuffer;
+    UINT32			RingSize;			// Include the shared header
+	HANDLE			RingLock;
+
+    UINT32			RingDataSize;		// < ringSize
+	UINT32			RingDataStartOffset;
+
+} RING_BUFFER_INFO;
+
+
+typedef struct _RING_BUFFER_DEBUG_INFO {
+	UINT32		CurrentInterruptMask;
+	UINT32		CurrentReadIndex;
+	UINT32		CurrentWriteIndex;
+	UINT32		BytesAvailToRead;
+	UINT32		BytesAvailToWrite;
+}RING_BUFFER_DEBUG_INFO;
+
+
+//
+// Interface
+//
+
+INTERNAL int
+RingBufferInit(
+	RING_BUFFER_INFO	*RingInfo,
+	PVOID				Buffer,
+	UINT32				BufferLen
+	);
+
+INTERNAL void
+RingBufferCleanup(
+	RING_BUFFER_INFO	*RingInfo
+	);
+
+INTERNAL int
+RingBufferWrite(
+	RING_BUFFER_INFO	*RingInfo,
+	SG_BUFFER_LIST		SgBuffers[],
+	UINT32				SgBufferCount
+	);
+
+INTERNAL int
+RingBufferPeek(
+	RING_BUFFER_INFO	*RingInfo,
+	PVOID				Buffer,
+	UINT32				BufferLen
+	);
+
+INTERNAL int
+RingBufferRead(
+	RING_BUFFER_INFO	*RingInfo,
+	PVOID				Buffer,
+	UINT32				BufferLen,
+	UINT32				Offset
+	);
+
+INTERNAL UINT32
+GetRingBufferInterruptMask(
+	RING_BUFFER_INFO *RingInfo
+	);
+
+INTERNAL void
+DumpRingInfo(
+	RING_BUFFER_INFO* RingInfo,
+	char *Prefix
+	);
+
+INTERNAL void
+RingBufferGetDebugInfo(
+	RING_BUFFER_INFO		*RingInfo,
+	RING_BUFFER_DEBUG_INFO	*DebugInfo
+	);
+
+#endif // _RING_BUFFER_H_

drivers/staging/hv/Sources.c

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#include "Vmbus.c"
+#include "Hv.c"
+#include "Connection.c"
+#include "Channel.c"
+#include "ChannelMgmt.c"
+#include "ChannelInterface.c"
+#include "RingBuffer.c"

drivers/staging/hv/VersionInfo.h

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#pragma once
+
+const char VersionDate[]=__DATE__;
+const char VersionTime[]=__TIME__;
+const char VersionDesc[]= "Version 2.0";

drivers/staging/hv/Vmbus.c

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#include "logging.h"
+#include "VersionInfo.h"
+#include "VmbusPrivate.h"
+
+//
+// Globals
+//
+static const char* gDriverName="vmbus";
+
+// Windows vmbus does not defined this. We defined this to be consistent with other devices
+//{c5295816-f63a-4d5f-8d1a-4daf999ca185}
+static const GUID gVmbusDeviceType={
+	.Data = {0x16, 0x58, 0x29, 0xc5, 0x3a, 0xf6, 0x5f, 0x4d, 0x8d, 0x1a, 0x4d, 0xaf, 0x99, 0x9c, 0xa1, 0x85}
+};
+
+//{ac3760fc-9adf-40aa-9427-a70ed6de95c5}
+static const GUID gVmbusDeviceId={
+	.Data = {0xfc, 0x60, 0x37, 0xac, 0xdf, 0x9a, 0xaa, 0x40, 0x94, 0x27, 0xa7, 0x0e, 0xd6, 0xde, 0x95, 0xc5}
+};
+
+static DRIVER_OBJECT* gDriver; // vmbus driver object
+static DEVICE_OBJECT* gDevice; // vmbus root device
+
+
+//
+// Internal routines
+//
+
+static void
+VmbusGetChannelInterface(
+	VMBUS_CHANNEL_INTERFACE *Interface
+	);
+
+static void
+VmbusGetChannelInfo(
+	DEVICE_OBJECT	*DeviceObject,
+	DEVICE_INFO		*DeviceInfo
+	);
+
+static void
+VmbusGetChannelOffers(
+	void
+	);
+
+static int
+VmbusOnDeviceAdd(
+	DEVICE_OBJECT	*Device,
+	void			*AdditionalInfo
+	);
+
+static int
+VmbusOnDeviceRemove(
+	DEVICE_OBJECT* dev
+	);
+
+static void
+VmbusOnCleanup(
+	DRIVER_OBJECT* drv
+	);
+
+static int
+VmbusOnISR(
+	DRIVER_OBJECT* drv
+	);
+
+static void
+VmbusOnMsgDPC(
+	DRIVER_OBJECT* drv
+	);
+
+static void
+VmbusOnEventDPC(
+	DRIVER_OBJECT* drv
+	);
+
+/*++;
+
+Name:
+	VmbusInitialize()
+
+Description:
+	Main entry point
+
+--*/
+int
+VmbusInitialize(
+	DRIVER_OBJECT* drv
+	)
+{
+	VMBUS_DRIVER_OBJECT* driver = (VMBUS_DRIVER_OBJECT*)drv;
+	int ret=0;
+
+	DPRINT_ENTER(VMBUS);
+
+	DPRINT_INFO(VMBUS, "+++++++ Build Date=%s %s +++++++", VersionDate, VersionTime);
+	DPRINT_INFO(VMBUS, "+++++++ Build Description=%s +++++++", VersionDesc);
+
+	DPRINT_INFO(VMBUS, "+++++++ Vmbus supported version = %d +++++++", VMBUS_REVISION_NUMBER);
+	DPRINT_INFO(VMBUS, "+++++++ Vmbus using SINT %d +++++++", VMBUS_MESSAGE_SINT);
+
+	DPRINT_DBG(VMBUS, "sizeof(VMBUS_CHANNEL_PACKET_PAGE_BUFFER)=%d, sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER)=%d",
+		sizeof(VMBUS_CHANNEL_PACKET_PAGE_BUFFER), sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER));
+
+	drv->name = gDriverName;
+	memcpy(&drv->deviceType, &gVmbusDeviceType, sizeof(GUID));
+
+	// Setup dispatch table
+	driver->Base.OnDeviceAdd		= VmbusOnDeviceAdd;
+	driver->Base.OnDeviceRemove		= VmbusOnDeviceRemove;
+	driver->Base.OnCleanup			= VmbusOnCleanup;
+	driver->OnIsr					= VmbusOnISR;
+	driver->OnMsgDpc				= VmbusOnMsgDPC;
+	driver->OnEventDpc				= VmbusOnEventDPC;
+	driver->GetChannelOffers		= VmbusGetChannelOffers;
+	driver->GetChannelInterface		= VmbusGetChannelInterface;
+	driver->GetChannelInfo			= VmbusGetChannelInfo;
+
+	// Hypervisor initialization...setup hypercall page..etc
+	ret = HvInit();
+	if (ret != 0)
+	{
+		DPRINT_ERR(VMBUS, "Unable to initialize the hypervisor - 0x%x", ret);
+	}
+
+	gDriver = drv;
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+/*++;
+
+Name:
+	VmbusGetChannelOffers()
+
+Description:
+	Retrieve the channel offers from the parent partition
+
+--*/
+
+static void
+VmbusGetChannelOffers(void)
+{
+	DPRINT_ENTER(VMBUS);
+	VmbusChannelRequestOffers();
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++;
+
+Name:
+	VmbusGetChannelInterface()
+
+Description:
+	Get the channel interface
+
+--*/
+static void
+VmbusGetChannelInterface(
+	VMBUS_CHANNEL_INTERFACE *Interface
+	)
+{
+	GetChannelInterface(Interface);
+}
+
+
+/*++;
+
+Name:
+	VmbusGetChannelInterface()
+
+Description:
+	Get the device info for the specified device object
+
+--*/
+static void
+VmbusGetChannelInfo(
+	DEVICE_OBJECT	*DeviceObject,
+	DEVICE_INFO		*DeviceInfo
+	)
+{
+	GetChannelInfo(DeviceObject, DeviceInfo);
+}
+
+
+
+/*++
+
+Name:
+	VmbusCreateChildDevice()
+
+Description:
+	Creates the child device on the bus that represents the channel offer
+
+--*/
+
+DEVICE_OBJECT*
+VmbusChildDeviceCreate(
+	GUID DeviceType,
+	GUID DeviceInstance,
+	void *Context)
+{
+	VMBUS_DRIVER_OBJECT* vmbusDriver = (VMBUS_DRIVER_OBJECT*)gDriver;
+
+	return vmbusDriver->OnChildDeviceCreate(
+		DeviceType,
+		DeviceInstance,
+		Context);
+}
+
+
+/*++
+
+Name:
+	VmbusChildDeviceAdd()
+
+Description:
+	Registers the child device with the vmbus
+
+--*/
+int
+VmbusChildDeviceAdd(
+   DEVICE_OBJECT* ChildDevice)
+{
+	VMBUS_DRIVER_OBJECT* vmbusDriver = (VMBUS_DRIVER_OBJECT*)gDriver;
+
+	return vmbusDriver->OnChildDeviceAdd(gDevice, ChildDevice);
+}
+
+
+/*++
+
+Name:
+	VmbusChildDeviceRemove()
+
+Description:
+	Unregisters the child device from the vmbus
+
+--*/
+void
+VmbusChildDeviceRemove(
+   DEVICE_OBJECT* ChildDevice)
+{
+	VMBUS_DRIVER_OBJECT* vmbusDriver = (VMBUS_DRIVER_OBJECT*)gDriver;
+
+	vmbusDriver->OnChildDeviceRemove(ChildDevice);
+}
+
+/*++
+
+Name:
+	VmbusChildDeviceDestroy()
+
+Description:
+	Release the child device from the vmbus
+
+--*/
+//void
+//VmbusChildDeviceDestroy(
+//	DEVICE_OBJECT* ChildDevice
+//	)
+//{
+//	VMBUS_DRIVER_OBJECT* vmbusDriver = (VMBUS_DRIVER_OBJECT*)gDriver;
+//
+//	vmbusDriver->OnChildDeviceDestroy(ChildDevice);
+//}
+
+/*++
+
+Name:
+	VmbusOnDeviceAdd()
+
+Description:
+	Callback when the root bus device is added
+
+--*/
+static int
+VmbusOnDeviceAdd(
+	DEVICE_OBJECT	*dev,
+	void			*AdditionalInfo
+	)
+{
+	UINT32 *irqvector = (UINT32*) AdditionalInfo;
+	int ret=0;
+
+	DPRINT_ENTER(VMBUS);
+
+	gDevice = dev;
+
+	memcpy(&gDevice->deviceType, &gVmbusDeviceType, sizeof(GUID));
+	memcpy(&gDevice->deviceInstance, &gVmbusDeviceId, sizeof(GUID));
+
+	//strcpy(dev->name, "vmbus");
+	// SynIC setup...
+	ret = HvSynicInit(*irqvector);
+
+	// Connect to VMBus in the root partition
+	ret = VmbusConnect();
+
+	//VmbusSendEvent(device->localPortId+1);
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+/*++
+
+Name:
+	VmbusOnDeviceRemove()
+
+Description:
+	Callback when the root bus device is removed
+
+--*/
+int VmbusOnDeviceRemove(
+	DEVICE_OBJECT* dev
+	)
+{
+	int ret=0;
+
+	DPRINT_ENTER(VMBUS);
+
+	VmbusChannelReleaseUnattachedChannels();
+
+	VmbusDisconnect();
+
+	HvSynicCleanup();
+
+	DPRINT_EXIT(VMBUS);
+
+	return ret;
+}
+
+
+/*++
+
+Name:
+	VmbusOnCleanup()
+
+Description:
+	Perform any cleanup when the driver is removed
+
+--*/
+void
+VmbusOnCleanup(
+	DRIVER_OBJECT* drv
+	)
+{
+	//VMBUS_DRIVER_OBJECT* driver = (VMBUS_DRIVER_OBJECT*)drv;
+
+	DPRINT_ENTER(VMBUS);
+
+	HvCleanup();
+
+	DPRINT_EXIT(VMBUS);
+}
+
+
+/*++
+
+Name:
+	VmbusOnMsgDPC()
+
+Description:
+	DPC routine to handle messages from the hypervisior
+
+--*/
+void
+VmbusOnMsgDPC(
+	DRIVER_OBJECT* drv
+	)
+{
+	void *page_addr = gHvContext.synICMessagePage[0];
+
+	HV_MESSAGE* msg = (HV_MESSAGE*)page_addr + VMBUS_MESSAGE_SINT;
+	HV_MESSAGE *copied;
+	while (1)
+	{
+		if (msg->Header.MessageType == HvMessageTypeNone) // no msg
+		{
+			break;
+		}
+		else
+		{
+			copied = MemAllocAtomic(sizeof(HV_MESSAGE));
+			if (copied == NULL)
+			{
+				continue;
+			}
+
+			memcpy(copied, msg, sizeof(HV_MESSAGE));
+			WorkQueueQueueWorkItem(gVmbusConnection.WorkQueue, VmbusOnChannelMessage, (void*)copied);
+		}
+
+		msg->Header.MessageType = HvMessageTypeNone;
+
+		// Make sure the write to MessageType (ie set to HvMessageTypeNone) happens
+		// before we read the MessagePending and EOMing. Otherwise, the EOMing will not deliver
+		// any more messages since there is no empty slot
+		MemoryFence();
+
+		if (msg->Header.MessageFlags.MessagePending)
+		{
+			// This will cause message queue rescan to possibly deliver another msg from the hypervisor
+			WriteMsr(HV_X64_MSR_EOM, 0);
+		}
+	}
+}
+
+/*++
+
+Name:
+	VmbusOnEventDPC()
+
+Description:
+	DPC routine to handle events from the hypervisior
+
+--*/
+void
+VmbusOnEventDPC(
+	DRIVER_OBJECT* drv
+	)
+{
+	// TODO: Process any events
+	VmbusOnEvents();
+}
+
+
+/*++
+
+Name:
+	VmbusOnISR()
+
+Description:
+	ISR routine
+
+--*/
+int
+VmbusOnISR(
+	DRIVER_OBJECT* drv
+	)
+{
+	//VMBUS_DRIVER_OBJECT* driver = (VMBUS_DRIVER_OBJECT*)drv;
+
+	int ret=0;
+	//struct page* page;
+	void *page_addr;
+	HV_MESSAGE* msg;
+	HV_SYNIC_EVENT_FLAGS* event;
+
+	//page = SynICMessagePage[0];
+	//page_addr = page_address(page);
+	page_addr = gHvContext.synICMessagePage[0];
+	msg = (HV_MESSAGE*)page_addr + VMBUS_MESSAGE_SINT;
+
+	DPRINT_ENTER(VMBUS);
+
+	// Check if there are actual msgs to be process
+	if (msg->Header.MessageType != HvMessageTypeNone)
+    {
+		DPRINT_DBG(VMBUS, "received msg type %d size %d", msg->Header.MessageType, msg->Header.PayloadSize);
+		ret |= 0x1;
+    }
+
+	// TODO: Check if there are events to be process
+	page_addr = gHvContext.synICEventPage[0];
+	event = (HV_SYNIC_EVENT_FLAGS*)page_addr + VMBUS_MESSAGE_SINT;
+
+	// Since we are a child, we only need to check bit 0
+	if (BitTestAndClear(&event->Flags32[0], 0))
+	{
+		DPRINT_DBG(VMBUS, "received event %d", event->Flags32[0]);
+		ret |= 0x2;
+	}
+
+	DPRINT_EXIT(VMBUS);
+	return ret;
+}
+
+// eof

drivers/staging/hv/VmbusPrivate.h

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#ifndef _VMBUS_PRIVATE_H_
+#define _VMBUS_PRIVATE_H_
+
+#ifndef INTERNAL
+#define INTERNAL static
+#endif
+
+#include "Hv.h"
+#include "VmbusApi.h"
+#include "Channel.h"
+#include "ChannelMgmt.h"
+#include "ChannelInterface.h"
+//#include "ChannelMessages.h"
+#include "RingBuffer.h"
+//#include "Packet.h"
+#include "List.h"
+
+//
+// Defines
+//
+
+// Maximum channels is determined by the size of the interrupt page which is PAGE_SIZE. 1/2 of PAGE_SIZE is for
+// send endpoint interrupt and the other is receive endpoint interrupt
+#define MAX_NUM_CHANNELS				(PAGE_SIZE >> 1) << 3  // 16348 channels
+
+// The value here must be in multiple of 32
+// TODO: Need to make this configurable
+#define MAX_NUM_CHANNELS_SUPPORTED		256
+
+//
+// Data types
+//
+
+typedef enum {
+	Disconnected,
+	Connecting,
+	Connected,
+	Disconnecting
+} VMBUS_CONNECT_STATE;
+
+#define MAX_SIZE_CHANNEL_MESSAGE			HV_MESSAGE_PAYLOAD_BYTE_COUNT
+
+typedef struct _VMBUS_CONNECTION {
+
+	VMBUS_CONNECT_STATE					ConnectState;
+
+	UINT32								NextGpadlHandle;
+
+	// Represents channel interrupts. Each bit position
+	// represents a channel.
+	// When a channel sends an interrupt via VMBUS, it
+	// finds its bit in the sendInterruptPage, set it and
+	// calls Hv to generate a port event. The other end
+	// receives the port event and parse the recvInterruptPage
+	// to see which bit is set
+	VOID*								InterruptPage;
+	VOID*								SendInterruptPage;
+	VOID*								RecvInterruptPage;
+
+	// 2 pages - 1st page for parent->child notification and 2nd is child->parent notification
+	VOID*								MonitorPages;
+	LIST_ENTRY							ChannelMsgList;
+	HANDLE								ChannelMsgLock;
+
+	// List of channels
+	LIST_ENTRY							ChannelList;
+	HANDLE								ChannelLock;
+
+	HANDLE								WorkQueue;
+} VMBUS_CONNECTION;
+
+
+typedef struct _VMBUS_MSGINFO {
+	// Bookkeeping stuff
+	LIST_ENTRY			MsgListEntry;
+
+	// Synchronize the request/response if needed
+	HANDLE				WaitEvent;
+
+	// The message itself
+	unsigned char		Msg[0];
+} VMBUS_MSGINFO;
+
+
+//
+// Externs
+//
+extern VMBUS_CONNECTION gVmbusConnection;
+
+//
+// General vmbus interface
+//
+INTERNAL DEVICE_OBJECT*
+VmbusChildDeviceCreate(
+	GUID deviceType,
+	GUID deviceInstance,
+	void *context);
+
+INTERNAL int
+VmbusChildDeviceAdd(
+	DEVICE_OBJECT* Device);
+
+INTERNAL void
+VmbusChildDeviceRemove(
+   DEVICE_OBJECT* Device);
+
+//INTERNAL void
+//VmbusChildDeviceDestroy(
+//	DEVICE_OBJECT*);
+
+INTERNAL VMBUS_CHANNEL*
+GetChannelFromRelId(
+	UINT32 relId
+	);
+
+//
+// Connection interface
+//
+INTERNAL int
+VmbusConnect(
+	VOID
+	);
+
+INTERNAL int
+VmbusDisconnect(
+	VOID
+	);
+
+INTERNAL int
+VmbusPostMessage(
+	PVOID			buffer,
+	SIZE_T			bufSize
+	);
+
+INTERNAL int
+VmbusSetEvent(
+	UINT32 childRelId
+	);
+
+INTERNAL VOID
+VmbusOnEvents(
+  VOID
+	);
+
+
+#endif // _VMBUS_PRIVATE_H_

drivers/staging/hv/osd.c

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/mm.h>
+#include <linux/highmem.h>
+#include <linux/vmalloc.h>
+//#include <linux/config.h>
+#include <linux/ioport.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/wait.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <linux/kernel.h>
+#include <linux/timer.h>
+#include <linux/jiffies.h>
+#include <linux/delay.h>
+#include <linux/time.h>
+
+#include <asm/io.h>
+#include <asm/bitops.h>
+#include <asm/kmap_types.h>
+#include <asm/atomic.h>
+
+#include "osd.h"
+
+//
+// Data types
+//
+typedef struct _TIMER {
+	struct timer_list timer;
+	PFN_TIMER_CALLBACK callback;
+	void* context;
+}TIMER;
+
+
+typedef struct _WAITEVENT {
+	int	condition;
+	wait_queue_head_t event;
+} WAITEVENT;
+
+typedef struct _SPINLOCK {
+	spinlock_t		lock;
+	unsigned long	flags;
+} SPINLOCK;
+
+typedef struct _WORKQUEUE {
+	struct workqueue_struct *queue;
+} WORKQUEUE;
+
+typedef struct _WORKITEM {
+	struct work_struct work;
+	PFN_WORKITEM_CALLBACK callback;
+	void* context;
+} WORKITEM;
+
+
+//
+// Global
+//
+
+void LogMsg(const char *fmt, ...)
+{
+#ifdef KERNEL_2_6_5
+	char buf[1024];
+#endif
+	va_list args;
+
+	va_start(args, fmt);
+#ifdef KERNEL_2_6_5
+	vsnprintf(buf, 1024, fmt, args);
+	va_end(args);
+	printk(buf);
+#else
+	vprintk(fmt, args);
+	va_end(args);
+#endif
+}
+
+void BitSet(unsigned int* addr, int bit)
+{
+	set_bit(bit, (unsigned long*)addr);
+}
+
+int BitTest(unsigned int* addr, int bit)
+{
+	return test_bit(bit, (unsigned long*)addr);
+}
+
+void BitClear(unsigned int* addr, int bit)
+{
+	clear_bit(bit, (unsigned long*)addr);
+}
+
+int BitTestAndClear(unsigned int* addr, int bit)
+{
+	return test_and_clear_bit(bit, (unsigned long*)addr);
+}
+
+int BitTestAndSet(unsigned int* addr, int bit)
+{
+	return test_and_set_bit(bit, (unsigned long*)addr);
+}
+
+
+int InterlockedIncrement(int *val)
+{
+#ifdef KERNEL_2_6_5
+	int i;
+	local_irq_disable();
+	i = atomic_read((atomic_t*)val);
+	atomic_set((atomic_t*)val, i+1);
+	local_irq_enable();
+	return i+1;
+#else
+	return atomic_inc_return((atomic_t*)val);
+#endif
+}
+
+int InterlockedDecrement(int *val)
+{
+#ifdef KERNEL_2_6_5
+	int i;
+	local_irq_disable();
+	i = atomic_read((atomic_t*)val);
+	atomic_set((atomic_t*)val, i-1);
+	local_irq_enable();
+	return i-1;
+#else
+	return atomic_dec_return((atomic_t*)val);
+#endif
+}
+
+#ifndef atomic_cmpxchg
+#define atomic_cmpxchg(v, old, new) ((int)cmpxchg(&((v)->counter), old, new))
+#endif
+int InterlockedCompareExchange(int *val, int new, int curr)
+{
+	//return ((int)cmpxchg(((atomic_t*)val), curr, new));
+	return atomic_cmpxchg((atomic_t*)val, curr, new);
+
+}
+
+void Sleep(unsigned long usecs)
+{
+	udelay(usecs);
+}
+
+void* VirtualAllocExec(unsigned int size)
+{
+#ifdef __x86_64__
+	return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL_EXEC);
+#else
+	return __vmalloc(size, GFP_KERNEL, __pgprot(__PAGE_KERNEL & (~_PAGE_NX)));
+#endif
+}
+
+void VirtualFree(void* VirtAddr)
+{
+	return vfree(VirtAddr);
+}
+
+void* PageAlloc(unsigned int count)
+{
+	void *p;
+	p = (void *)__get_free_pages(GFP_KERNEL, get_order(count * PAGE_SIZE));
+	if (p) memset(p, 0, count * PAGE_SIZE);
+	return p;
+
+	//struct page* page = alloc_page(GFP_KERNEL|__GFP_ZERO);
+	//void *p;
+
+	////BUGBUG: We need to use kmap in case we are in HIMEM region
+	//p = page_address(page);
+	//if (p) memset(p, 0, PAGE_SIZE);
+	//return p;
+}
+
+void PageFree(void* page, unsigned int count)
+{
+	free_pages((unsigned long)page, get_order(count * PAGE_SIZE));
+	/*struct page* p = virt_to_page(page);
+	__free_page(p);*/
+}
+
+
+void* PageMapVirtualAddress(unsigned long Pfn)
+{
+	return kmap_atomic(pfn_to_page(Pfn), KM_IRQ0);
+}
+
+void PageUnmapVirtualAddress(void* VirtAddr)
+{
+	kunmap_atomic(VirtAddr, KM_IRQ0);
+}
+
+void* MemAlloc(unsigned int size)
+{
+	return kmalloc(size, GFP_KERNEL);
+}
+
+void* MemAllocZeroed(unsigned int size)
+{
+	void *p = kmalloc(size, GFP_KERNEL);
+	if (p) memset(p, 0, size);
+	return p;
+}
+
+void* MemAllocAtomic(unsigned int size)
+{
+	return kmalloc(size, GFP_ATOMIC);
+}
+
+void MemFree(void* buf)
+{
+	kfree(buf);
+}
+
+void *MemMapIO(unsigned long phys, unsigned long size)
+{
+#if X2V_LINUX
+#ifdef __x86_64__
+	return (void*)(phys + 0xFFFF83000C000000);
+#else // i386
+	return (void*)(phys + 0xfb000000);
+#endif
+#else
+	return (void*)GetVirtualAddress(phys); //return ioremap_nocache(phys, size);
+#endif
+}
+
+void MemUnmapIO(void *virt)
+{
+	//iounmap(virt);
+}
+
+void MemoryFence()
+{
+	mb();
+}
+
+void TimerCallback(unsigned long data)
+{
+	TIMER* t = (TIMER*)data;
+
+	t->callback(t->context);
+}
+
+HANDLE TimerCreate(PFN_TIMER_CALLBACK pfnTimerCB, void* context)
+{
+	TIMER* t = kmalloc(sizeof(TIMER), GFP_KERNEL);
+	if (!t)
+	{
+		return NULL;
+	}
+
+	t->callback = pfnTimerCB;
+	t->context = context;
+
+	init_timer(&t->timer);
+	t->timer.data = (unsigned long)t;
+	t->timer.function = TimerCallback;
+
+	return t;
+}
+
+void TimerStart(HANDLE hTimer, UINT32 expirationInUs)
+{
+	TIMER* t  = (TIMER* )hTimer;
+
+	t->timer.expires = jiffies + usecs_to_jiffies(expirationInUs);
+	add_timer(&t->timer);
+}
+
+int TimerStop(HANDLE hTimer)
+{
+	TIMER* t  = (TIMER* )hTimer;
+
+	return del_timer(&t->timer);
+}
+
+void TimerClose(HANDLE hTimer)
+{
+	TIMER* t  = (TIMER* )hTimer;
+
+	del_timer(&t->timer);
+	kfree(t);
+}
+
+SIZE_T GetTickCount(void)
+{
+	return jiffies;
+}
+
+signed long long GetTimestamp(void)
+{
+	struct timeval t;
+
+	do_gettimeofday(&t);
+
+	return  timeval_to_ns(&t);
+}
+
+HANDLE WaitEventCreate(void)
+{
+	WAITEVENT* wait = kmalloc(sizeof(WAITEVENT), GFP_KERNEL);
+	if (!wait)
+	{
+		return NULL;
+	}
+
+	wait->condition = 0;
+	init_waitqueue_head(&wait->event);
+	return wait;
+}
+
+void WaitEventClose(HANDLE hWait)
+{
+	WAITEVENT* waitEvent = (WAITEVENT* )hWait;
+	kfree(waitEvent);
+}
+
+void WaitEventSet(HANDLE hWait)
+{
+	WAITEVENT* waitEvent = (WAITEVENT* )hWait;
+	waitEvent->condition = 1;
+	wake_up_interruptible(&waitEvent->event);
+}
+
+int WaitEventWait(HANDLE hWait)
+{
+	int ret=0;
+	WAITEVENT* waitEvent = (WAITEVENT* )hWait;
+
+	ret= wait_event_interruptible(waitEvent->event,
+		waitEvent->condition);
+	waitEvent->condition = 0;
+	return ret;
+}
+
+int WaitEventWaitEx(HANDLE hWait, UINT32 TimeoutInMs)
+{
+	int ret=0;
+	WAITEVENT* waitEvent = (WAITEVENT* )hWait;
+
+	ret= wait_event_interruptible_timeout(waitEvent->event,
+											waitEvent->condition,
+											msecs_to_jiffies(TimeoutInMs));
+	waitEvent->condition = 0;
+	return ret;
+}
+
+HANDLE SpinlockCreate(VOID)
+{
+	SPINLOCK* spin = kmalloc(sizeof(SPINLOCK), GFP_KERNEL);
+	if (!spin)
+	{
+		return NULL;
+	}
+	spin_lock_init(&spin->lock);
+
+	return spin;
+}
+
+VOID SpinlockAcquire(HANDLE hSpin)
+{
+	SPINLOCK* spin = (SPINLOCK* )hSpin;
+
+	spin_lock_irqsave(&spin->lock, spin->flags);
+}
+
+VOID SpinlockRelease(HANDLE hSpin)
+{
+	SPINLOCK* spin = (SPINLOCK* )hSpin;
+
+	spin_unlock_irqrestore(&spin->lock, spin->flags);
+}
+
+VOID SpinlockClose(HANDLE hSpin)
+{
+	SPINLOCK* spin = (SPINLOCK* )hSpin;
+	kfree(spin);
+}
+
+void* Physical2LogicalAddr(ULONG_PTR PhysAddr)
+{
+	void* logicalAddr = phys_to_virt(PhysAddr);
+	BUG_ON(!virt_addr_valid(logicalAddr));
+	return logicalAddr;
+}
+
+ULONG_PTR Logical2PhysicalAddr(PVOID LogicalAddr)
+{
+	BUG_ON(!virt_addr_valid(LogicalAddr));
+	return virt_to_phys(LogicalAddr);
+}
+
+
+ULONG_PTR Virtual2Physical(PVOID VirtAddr)
+{
+	ULONG_PTR pfn = vmalloc_to_pfn(VirtAddr);
+
+	return pfn << PAGE_SHIFT;
+}
+
+#ifdef KERNEL_2_6_27
+void WorkItemCallback(struct work_struct *work)
+#else
+void WorkItemCallback(void* work)
+#endif
+{
+	WORKITEM* w = (WORKITEM*)work;
+
+	w->callback(w->context);
+
+	kfree(w);
+}
+
+HANDLE WorkQueueCreate(char* name)
+{
+	WORKQUEUE *wq = kmalloc(sizeof(WORKQUEUE), GFP_KERNEL);
+	if (!wq)
+	{
+		return NULL;
+	}
+	wq->queue = create_workqueue(name);
+
+	return wq;
+}
+
+void WorkQueueClose(HANDLE hWorkQueue)
+{
+	WORKQUEUE *wq = (WORKQUEUE *)hWorkQueue;
+
+	destroy_workqueue(wq->queue);
+
+	return;
+}
+
+int WorkQueueQueueWorkItem(HANDLE hWorkQueue, PFN_WORKITEM_CALLBACK workItem, void* context)
+{
+	WORKQUEUE *wq = (WORKQUEUE *)hWorkQueue;
+
+	WORKITEM* w = kmalloc(sizeof(WORKITEM), GFP_ATOMIC);
+	if (!w)
+	{
+		return -1;
+	}
+
+	w->callback = workItem,
+	w->context = context;
+#ifdef KERNEL_2_6_27
+	INIT_WORK(&w->work, WorkItemCallback);
+#else
+	INIT_WORK(&w->work, WorkItemCallback, w);
+#endif
+	return queue_work(wq->queue, &w->work);
+}
+
+void QueueWorkItem(PFN_WORKITEM_CALLBACK workItem, void* context)
+{
+	WORKITEM* w = kmalloc(sizeof(WORKITEM), GFP_ATOMIC);
+	if (!w)
+	{
+		return;
+	}
+
+	w->callback = workItem,
+	w->context = context;
+#ifdef KERNEL_2_6_27
+	INIT_WORK(&w->work, WorkItemCallback);
+#else
+	INIT_WORK(&w->work, WorkItemCallback, w);
+#endif
+	schedule_work(&w->work);
+}

drivers/staging/hv/vmbus_drv.c

+/*
+ *
+ * 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 <haiyangz@microsoft.com>
+ *   Hank Janssen  <hjanssen@microsoft.com>
+ *
+ */
+
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/sysctl.h>
+
+#include "logging.h"
+#include "vmbus.h"
+
+//
+// Defines
+//
+
+// FIXME! We need to do this dynamically for PIC and APIC system
+#define VMBUS_IRQ				0x5
+#ifdef KERNEL_2_6_27
+#define VMBUS_IRQ_VECTOR     IRQ5_VECTOR
+#endif
+//
+// Data types
+//
+
+// Main vmbus driver data structure
+struct vmbus_driver_context {
+	// !! These must be the first 2 fields !!
+	// The driver field is not used in here. Instead, the bus field is
+	// used to represent the driver
+	struct driver_context	drv_ctx;
+	VMBUS_DRIVER_OBJECT		drv_obj;
+
+	struct bus_type			bus;
+	struct tasklet_struct	msg_dpc;
+	struct tasklet_struct	event_dpc;
+
+	// The bus root device
+	struct device_context	device_ctx;
+};
+
+//
+// Static decl
+//
+static int vmbus_match(struct device *device, struct device_driver *driver);
+static int vmbus_probe(struct device *device);
+static int vmbus_remove(struct device *device);
+static void vmbus_shutdown(struct device *device);
+#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
+#elif defined(KERNEL_2_6_27)
+static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env);
+#else
+static int vmbus_uevent(struct device *device, char **envp, int num_envp, char *buffer, int buffer_size);
+#endif
+static void vmbus_msg_dpc(unsigned long data);
+static void vmbus_event_dpc(unsigned long data);
+
+#ifdef KERNEL_2_6_27
+static irqreturn_t vmbus_isr(int irq, void* dev_id);
+#else
+static int vmbus_isr(int irq, void* dev_id, struct pt_regs *regs);
+#endif
+
+static void vmbus_device_release(struct device *device);
+static void vmbus_bus_release(struct device *device);
+
+static DEVICE_OBJECT* vmbus_child_device_create(GUID type, GUID instance, void* context);
+static void vmbus_child_device_destroy(DEVICE_OBJECT* device_obj);
+static int vmbus_child_device_register(DEVICE_OBJECT* root_device_obj, DEVICE_OBJECT* child_device_obj);
+static void vmbus_child_device_unregister(DEVICE_OBJECT* child_device_obj);
+static void vmbus_child_device_get_info(DEVICE_OBJECT *device_obj, DEVICE_INFO *device_info);
+
+//static ssize_t vmbus_show_class_id(struct device *dev, struct device_attribute *attr, char *buf);
+//static ssize_t vmbus_show_device_id(struct device *dev, struct device_attribute *attr, char *buf);
+
+static ssize_t vmbus_show_device_attr(struct device *dev, struct device_attribute *dev_attr, char *buf);
+
+//
+// Global
+//
+
+// Global logging setting
+
+//unsigned int vmbus_loglevel= (((VMBUS | VMBUS_DRV)<<16) | DEBUG_LVL_ENTEREXIT);
+//unsigned int vmbus_loglevel= (ALL_MODULES << 16 | DEBUG_LVL_ENTEREXIT);
+unsigned int vmbus_loglevel= (ALL_MODULES << 16 | INFO_LVL);
+EXPORT_SYMBOL(vmbus_loglevel);
+
+static int vmbus_irq = VMBUS_IRQ;
+
+// Setup /proc/sys/bus/vmbus/vmbus_loglevel
+// Allow usage of sysctl cmd to set the logging level
+static struct ctl_table_header *vmbus_ctl_table_hdr;
+
+static ctl_table vmbus_dev_ctl_table[] = {
+	{ .ctl_name	= 8461,
+	  .procname	= "vmbus_loglevel",
+	  .data		= &vmbus_loglevel,
+	  .maxlen	= sizeof(vmbus_loglevel),
+	  .mode		= 0644,
+	  .proc_handler	= &proc_dointvec },
+	{ }
+};
+
+static ctl_table vmbus_ctl_table[] = {
+	{ .ctl_name	= CTL_DEV,
+	  .procname	= "vmbus",
+	  .mode		= 0555,
+	  .child	= vmbus_dev_ctl_table },
+	{ }
+};
+
+static ctl_table vmus_root_ctl_table[] = {
+	{ .ctl_name	= CTL_BUS,
+	  .procname	= "bus",
+	  .mode		= 0555,
+	  .child	= vmbus_ctl_table },
+	{ }
+};
+
+#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
+#else
+//
+// Set up per device attributes in /sys/bus/vmbus/devices/<bus device>
+//
+static struct device_attribute vmbus_device_attrs[] = {
+	__ATTR(id, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(state, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(class_id, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(device_id, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(monitor_id, S_IRUGO, vmbus_show_device_attr, NULL),
+
+	__ATTR(server_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(server_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(server_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
+
+	__ATTR(client_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(client_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(client_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
+
+	__ATTR(out_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(out_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(out_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(out_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(out_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
+
+	__ATTR(in_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(in_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(in_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(in_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR(in_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
+	__ATTR_NULL
+};
+#endif
+
+// The one and only one
+static struct vmbus_driver_context g_vmbus_drv={
+	.bus.name	= "vmbus",
+	.bus.match	= vmbus_match,
+#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
+#else
+	.bus.shutdown = vmbus_shutdown,
+	.bus.remove = vmbus_remove,
+	.bus.probe	= vmbus_probe,
+	.bus.uevent = vmbus_uevent,
+	.bus.dev_attrs = vmbus_device_attrs,
+#endif
+};
+
+//
+// Routines
+//
+
+
+/*++
+
+Name:	vmbus_show_device_attr()
+
+Desc:	Show the device attribute in sysfs. This is invoked when user does a "cat /sys/bus/vmbus/devices/<bus device>/<attr name>"
+
+--*/
+static ssize_t vmbus_show_device_attr(struct device *dev, struct device_attribute *dev_attr, char *buf)
+{
+	struct device_context *device_ctx = device_to_device_context(dev);
+	DEVICE_INFO device_info;
+
+	memset(&device_info, 0, sizeof(DEVICE_INFO));
+
+	vmbus_child_device_get_info(&device_ctx->device_obj, &device_info);
+
+	if (!strcmp(dev_attr->attr.name, "class_id"))
+	{
+		return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n",
+			device_info.ChannelType.Data[3], device_info.ChannelType.Data[2], device_info.ChannelType.Data[1], device_info.ChannelType.Data[0],
+			device_info.ChannelType.Data[5], device_info.ChannelType.Data[4],
+			device_info.ChannelType.Data[7], device_info.ChannelType.Data[6],
+			device_info.ChannelType.Data[8], device_info.ChannelType.Data[9], device_info.ChannelType.Data[10], device_info.ChannelType.Data[11], device_info.ChannelType.Data[12], device_info.ChannelType.Data[13], device_info.ChannelType.Data[14], device_info.ChannelType.Data[15]);
+
+	}
+	else if (!strcmp(dev_attr->attr.name, "device_id"))
+	{
+		return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n",
+			device_info.ChannelInstance.Data[3], device_info.ChannelInstance.Data[2], device_info.ChannelInstance.Data[1], device_info.ChannelInstance.Data[0],
+			device_info.ChannelInstance.Data[5], device_info.ChannelInstance.Data[4],
+			device_info.ChannelInstance.Data[7], device_info.ChannelInstance.Data[6],
+			device_info.ChannelInstance.Data[8], device_info.ChannelInstance.Data[9], device_info.ChannelInstance.Data[10], device_info.ChannelInstance.Data[11], device_info.ChannelInstance.Data[12], device_info.ChannelInstance.Data[13], device_info.ChannelInstance.Data[14], device_info.ChannelInstance.Data[15]);
+	}
+	else if (!strcmp(dev_attr->attr.name, "state"))
+	{
+		return sprintf(buf, "%d\n", device_info.ChannelState);
+	}
+	else if (!strcmp(dev_attr->attr.name, "id"))
+	{
+		return sprintf(buf, "%d\n", device_info.ChannelId);
+	}
+	else if (!strcmp(dev_attr->attr.name, "out_intr_mask"))
+	{
+		return sprintf(buf, "%d\n", device_info.Outbound.InterruptMask);
+	}
+	else if (!strcmp(dev_attr->attr.name, "out_read_index"))
+	{
+		return sprintf(buf, "%d\n", device_info.Outbound.ReadIndex);
+	}
+	else if (!strcmp(dev_attr->attr.name, "out_write_index"))
+	{
+		return sprintf(buf, "%d\n", device_info.Outbound.WriteIndex);
+	}
+	else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail"))
+	{
+		return sprintf(buf, "%d\n", device_info.Outbound.BytesAvailToRead);
+	}
+	else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail"))
+	{
+		return sprintf(buf, "%d\n", device_info.Outbound.BytesAvailToWrite);
+	}
+	else if (!strcmp(dev_attr->attr.name, "in_intr_mask"))
+	{
+		return sprintf(buf, "%d\n", device_info.Inbound.InterruptMask);
+	}
+	else if (!strcmp(dev_attr->attr.name, "in_read_index"))
+	{
+		return sprintf(buf, "%d\n", device_info.Inbound.ReadIndex);
+	}
+	else if (!strcmp(dev_attr->attr.name, "in_write_index"))
+	{
+		return sprintf(buf, "%d\n", device_info.Inbound.WriteIndex);
+	}
+	else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail"))
+	{
+		return sprintf(buf, "%d\n", device_info.Inbound.BytesAvailToRead);
+	}
+	else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail"))
+	{
+		return sprintf(buf, "%d\n", device_info.Inbound.BytesAvailToWrite);
+	}
+	else if (!strcmp(dev_attr->attr.name, "monitor_id"))
+	{
+		return sprintf(buf, "%d\n", device_info.MonitorId);
+	}
+	else if (!strcmp(dev_attr->attr.name, "server_monitor_pending"))
+	{
+		return sprintf(buf, "%d\n", device_info.ServerMonitorPending);
+	}
+	else if (!strcmp(dev_attr->attr.name, "server_monitor_latency"))
+	{
+		return sprintf(buf, "%d\n", device_info.ServerMonitorLatency);
+	}
+	else if (!strcmp(dev_attr->attr.name, "server_monitor_conn_id"))
+	{
+		return sprintf(buf, "%d\n", device_info.ServerMonitorConnectionId);
+	}
+	else if (!strcmp(dev_attr->attr.name, "client_monitor_pending"))
+	{
+		return sprintf(buf, "%d\n", device_info.ClientMonitorPending);
+	}
+	else if (!strcmp(dev_attr->attr.name, "client_monitor_latency"))
+	{
+		return sprintf(buf, "%d\n", device_info.ClientMonitorLatency);
+	}
+	else if (!strcmp(dev_attr->attr.name, "client_monitor_conn_id"))
+	{
+		return sprintf(buf, "%d\n", device_info.ClientMonitorConnectionId);
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+/*++
+
+Name:	vmbus_show_class_id()
+
+Desc:	Show the device class id in sysfs
+
+--*/
+//static ssize_t vmbus_show_class_id(struct device *dev, struct device_attribute *attr, char *buf)
+//{
+//	struct device_context *device_ctx = device_to_device_context(dev);
+//	return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n",
+//		device_ctx->class_id[3], device_ctx->class_id[2], device_ctx->class_id[1], device_ctx->class_id[0],
+//		device_ctx->class_id[5], device_ctx->class_id[4],
+//		device_ctx->class_id[7], device_ctx->class_id[6],
+//		device_ctx->class_id[8], device_ctx->class_id[9], device_ctx->class_id[10], device_ctx->class_id[11], device_ctx->class_id[12], device_ctx->class_id[13], device_ctx->class_id[14], device_ctx->class_id[15]);
+//}
+
+/*++
+
+Name:	vmbus_show_device_id()
+
+Desc:	Show the device instance id in sysfs
+
+--*/
+//static ssize_t vmbus_show_device_id(struct device *dev, struct device_attribute *attr, char *buf)
+//{
+//	struct device_context *device_ctx = device_to_device_context(dev);
+//	return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n",
+//		device_ctx->device_id[3], device_ctx->device_id[2], device_ctx->device_id[1], device_ctx->device_id[0],
+//		device_ctx->device_id[5], device_ctx->device_id[4],
+//		device_ctx->device_id[7], device_ctx->device_id[6],
+//		device_ctx->device_id[8], device_ctx->device_id[9], device_ctx->device_id[10], device_ctx->device_id[11], device_ctx->device_id[12], device_ctx->device_id[13], device_ctx->device_id[14], device_ctx->device_id[15]);
+//}
+
+/*++
+
+Name:	vmbus_bus_init()
+
+Desc:	Main vmbus driver initialization routine. Here, we
+		- initialize the vmbus driver context
+		- setup various driver entry points
+		- invoke the vmbus hv main init routine
+		- get the irq resource
+		- invoke the vmbus to add the vmbus root device
+		- setup the vmbus root device
+		- retrieve the channel offers
+--*/
+int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init)
+{
+	int ret=0;
+	unsigned int vector=0;
+
+	struct vmbus_driver_context *vmbus_drv_ctx=&g_vmbus_drv;
+	VMBUS_DRIVER_OBJECT *vmbus_drv_obj=&g_vmbus_drv.drv_obj;
+
+	struct device_context *dev_ctx=&g_vmbus_drv.device_ctx;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	// Set this up to allow lower layer to callback to add/remove child devices on the bus
+	vmbus_drv_obj->OnChildDeviceCreate = vmbus_child_device_create;
+	vmbus_drv_obj->OnChildDeviceDestroy = vmbus_child_device_destroy;
+	vmbus_drv_obj->OnChildDeviceAdd = vmbus_child_device_register;
+	vmbus_drv_obj->OnChildDeviceRemove = vmbus_child_device_unregister;
+
+	// Call to bus driver to initialize
+	ret = pfn_drv_init(&vmbus_drv_obj->Base);
+	if (ret != 0)
+	{
+		DPRINT_ERR(VMBUS_DRV, "Unable to initialize vmbus (%d)", ret);
+		goto cleanup;
+	}
+
+	// Sanity checks
+	if (!vmbus_drv_obj->Base.OnDeviceAdd)
+	{
+		DPRINT_ERR(VMBUS_DRV, "OnDeviceAdd() routine not set");
+		ret = -1;
+		goto cleanup;
+	}
+
+	vmbus_drv_ctx->bus.name = vmbus_drv_obj->Base.name;
+
+	// Initialize the bus context
+	tasklet_init(&vmbus_drv_ctx->msg_dpc, vmbus_msg_dpc, (unsigned long)vmbus_drv_obj);
+	tasklet_init(&vmbus_drv_ctx->event_dpc, vmbus_event_dpc, (unsigned long)vmbus_drv_obj);
+
+	// Now, register the bus driver with LDM
+	bus_register(&vmbus_drv_ctx->bus);
+
+	// Get the interrupt resource
+#ifdef KERNEL_2_6_27
+	ret = request_irq(vmbus_irq,
+			  vmbus_isr,
+			  IRQF_SAMPLE_RANDOM,
+			  vmbus_drv_obj->Base.name,
+			  NULL);
+#else
+	ret = request_irq(vmbus_irq,
+			  vmbus_isr,
+			  SA_SAMPLE_RANDOM,
+			  vmbus_drv_obj->Base.name,
+			  NULL);
+#endif
+
+	if (ret != 0)
+	{
+		DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to request IRQ %d", vmbus_irq);
+
+		bus_unregister(&vmbus_drv_ctx->bus);
+
+		ret = -1;
+		goto cleanup;
+	}
+#ifdef KERNEL_2_6_27
+	vector = VMBUS_IRQ_VECTOR;
+#else
+#if X2V_LINUX
+	vector = vmbus_irq + FIRST_DEVICE_VECTOR - 2;
+#else
+	vector = vmbus_irq + FIRST_EXTERNAL_VECTOR;
+#endif
+#endif
+
+	DPRINT_INFO(VMBUS_DRV, "irq 0x%x vector 0x%x", vmbus_irq, vector);
+
+	// Call to bus driver to add the root device
+	memset(dev_ctx, 0, sizeof(struct device_context));
+
+	ret = vmbus_drv_obj->Base.OnDeviceAdd(&dev_ctx->device_obj, &vector);
+	if (ret != 0)
+	{
+		DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to add vmbus root device");
+
+		free_irq(vmbus_irq, NULL);
+
+		bus_unregister(&vmbus_drv_ctx->bus);
+
+		ret = -1;
+		goto cleanup;
+	}
+	//strcpy(dev_ctx->device.bus_id, dev_ctx->device_obj.name);
+	sprintf(dev_ctx->device.bus_id, "vmbus_0_0");
+	memcpy(&dev_ctx->class_id, &dev_ctx->device_obj.deviceType, sizeof(GUID));
+	memcpy(&dev_ctx->device_id, &dev_ctx->device_obj.deviceInstance, sizeof(GUID));
+
+	// No need to bind a driver to the root device.
+	dev_ctx->device.parent = NULL;
+	dev_ctx->device.bus = &vmbus_drv_ctx->bus; //NULL; // vmbus_remove() does not get invoked
+
+	// Setup the device dispatch table
+	dev_ctx->device.release = vmbus_bus_release;
+
+	// Setup the bus as root device
+	device_register(&dev_ctx->device);
+
+	vmbus_drv_obj->GetChannelOffers();
+
+cleanup:
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return ret;
+}
+
+
+/*++
+
+Name:	vmbus_bus_exit()
+
+Desc:	Terminate the vmbus driver. This routine is opposite of vmbus_bus_init()
+
+--*/
+void vmbus_bus_exit(void)
+{
+	VMBUS_DRIVER_OBJECT *vmbus_drv_obj=&g_vmbus_drv.drv_obj;
+	struct vmbus_driver_context *vmbus_drv_ctx=&g_vmbus_drv;
+
+	struct device_context *dev_ctx=&g_vmbus_drv.device_ctx;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	// Remove the root device
+	if (vmbus_drv_obj->Base.OnDeviceRemove)
+		vmbus_drv_obj->Base.OnDeviceRemove(&dev_ctx->device_obj);
+
+	if (vmbus_drv_obj->Base.OnCleanup)
+		vmbus_drv_obj->Base.OnCleanup(&vmbus_drv_obj->Base);
+
+	// Unregister the root bus device
+	device_unregister(&dev_ctx->device);
+
+	bus_unregister(&vmbus_drv_ctx->bus);
+
+	free_irq(vmbus_irq, NULL);
+
+	tasklet_kill(&vmbus_drv_ctx->msg_dpc);
+	tasklet_kill(&vmbus_drv_ctx->event_dpc);
+
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return;
+}
+
+/*++
+
+Name:	vmbus_child_driver_register()
+
+Desc:	Register a vmbus's child driver
+
+--*/
+void vmbus_child_driver_register(struct driver_context* driver_ctx)
+{
+	VMBUS_DRIVER_OBJECT *vmbus_drv_obj=&g_vmbus_drv.drv_obj;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	DPRINT_INFO(VMBUS_DRV, "child driver (%p) registering - name %s", driver_ctx, driver_ctx->driver.name);
+
+	// The child driver on this vmbus
+	driver_ctx->driver.bus = &g_vmbus_drv.bus;
+
+	driver_register(&driver_ctx->driver);
+
+	vmbus_drv_obj->GetChannelOffers();
+
+	DPRINT_EXIT(VMBUS_DRV);
+}
+
+EXPORT_SYMBOL(vmbus_child_driver_register);
+
+/*++
+
+Name:	vmbus_child_driver_unregister()
+
+Desc:	Unregister a vmbus's child driver
+
+--*/
+void vmbus_child_driver_unregister(struct driver_context* driver_ctx)
+{
+	DPRINT_ENTER(VMBUS_DRV);
+
+	DPRINT_INFO(VMBUS_DRV, "child driver (%p) unregistering - name %s", driver_ctx, driver_ctx->driver.name);
+
+	driver_unregister(&driver_ctx->driver);
+
+	driver_ctx->driver.bus = NULL;
+
+	DPRINT_EXIT(VMBUS_DRV);
+}
+
+EXPORT_SYMBOL(vmbus_child_driver_unregister);
+
+/*++
+
+Name:	vmbus_get_interface()
+
+Desc:	Get the vmbus channel interface. This is invoked by child/client driver that sits
+		above vmbus
+--*/
+void vmbus_get_interface(VMBUS_CHANNEL_INTERFACE *interface)
+{
+	VMBUS_DRIVER_OBJECT *vmbus_drv_obj=&g_vmbus_drv.drv_obj;
+
+	vmbus_drv_obj->GetChannelInterface(interface);
+}
+
+EXPORT_SYMBOL(vmbus_get_interface);
+
+
+/*++
+
+Name:	vmbus_child_device_get_info()
+
+Desc:	Get the vmbus child device info. This is invoked to display various device attributes in sysfs.
+--*/
+static void vmbus_child_device_get_info(DEVICE_OBJECT *device_obj, DEVICE_INFO *device_info)
+{
+	VMBUS_DRIVER_OBJECT *vmbus_drv_obj=&g_vmbus_drv.drv_obj;
+
+	vmbus_drv_obj->GetChannelInfo(device_obj, device_info);
+}
+
+
+/*++
+
+Name:	vmbus_child_device_create()
+
+Desc:	Creates and registers a new child device on the vmbus.
+
+--*/
+static DEVICE_OBJECT* vmbus_child_device_create(GUID type, GUID instance, void* context)
+{
+	struct device_context *child_device_ctx;
+	DEVICE_OBJECT* child_device_obj;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	// Allocate the new child device
+	child_device_ctx = kzalloc(sizeof(struct device_context), GFP_KERNEL);
+	if (!child_device_ctx)
+	{
+		DPRINT_ERR(VMBUS_DRV, "unable to allocate device_context for child device");
+		DPRINT_EXIT(VMBUS_DRV);
+
+		return NULL;
+	}
+
+	DPRINT_DBG(VMBUS_DRV, "child device (%p) allocated - "
+		"type {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x},"
+		"id {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
+		&child_device_ctx->device,
+		type.Data[3], type.Data[2], type.Data[1], type.Data[0], type.Data[5], type.Data[4], type.Data[7], type.Data[6], type.Data[8], type.Data[9], type.Data[10], type.Data[11], type.Data[12], type.Data[13], type.Data[14], type.Data[15],
+		instance.Data[3], instance.Data[2], instance.Data[1], instance.Data[0], instance.Data[5], instance.Data[4], instance.Data[7], instance.Data[6], instance.Data[8], instance.Data[9], instance.Data[10], instance.Data[11], instance.Data[12], instance.Data[13], instance.Data[14], instance.Data[15]);
+
+	child_device_obj = &child_device_ctx->device_obj;
+	child_device_obj->context = context;
+	memcpy(&child_device_obj->deviceType, &type, sizeof(GUID));
+	memcpy(&child_device_obj->deviceInstance, &instance, sizeof(GUID));
+
+	memcpy(&child_device_ctx->class_id, &type, sizeof(GUID));
+	memcpy(&child_device_ctx->device_id, &instance, sizeof(GUID));
+
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return child_device_obj;
+}
+
+/*++
+
+Name:	vmbus_child_device_register()
+
+Desc:	Register the child device on the specified bus
+
+--*/
+static int vmbus_child_device_register(DEVICE_OBJECT* root_device_obj, DEVICE_OBJECT* child_device_obj)
+{
+	int ret=0;
+	struct device_context *root_device_ctx = to_device_context(root_device_obj);
+	struct device_context *child_device_ctx = to_device_context(child_device_obj);
+	static int device_num=0;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	DPRINT_DBG(VMBUS_DRV, "child device (%p) registering", child_device_ctx);
+	//
+	// Make sure we are not registered already
+	//
+	if (child_device_ctx->device.bus_id[0] != '\0')
+	{
+		DPRINT_ERR(VMBUS_DRV, "child device (%p) already registered - busid %s", child_device_ctx, child_device_ctx->device.bus_id);
+
+		ret = -1;
+		goto Cleanup;
+	}
+
+	// Set the device bus id. Otherwise, device_register()will fail.
+	sprintf(child_device_ctx->device.bus_id, "vmbus_0_%d", InterlockedIncrement(&device_num));
+
+	// The new device belongs to this bus
+	child_device_ctx->device.bus = &g_vmbus_drv.bus; //device->dev.bus;
+	child_device_ctx->device.parent = &root_device_ctx->device;
+	child_device_ctx->device.release = vmbus_device_release;
+
+	// Register with the LDM. This will kick off the driver/device binding...which will
+	// eventually call vmbus_match() and vmbus_probe()
+	ret = device_register(&child_device_ctx->device);
+
+	// vmbus_probe() error does not get propergate to device_register().
+	ret = child_device_ctx->probe_error;
+
+	if (ret)
+		DPRINT_ERR(VMBUS_DRV, "unable to register child device (%p) (%d)", &child_device_ctx->device);
+	else
+		DPRINT_INFO(VMBUS_DRV, "child device (%p) registered", &child_device_ctx->device);
+
+Cleanup:
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return ret;
+}
+
+/*++
+
+Name:	vmbus_child_device_unregister()
+
+Desc:	Remove the specified child device from the vmbus.
+
+--*/
+static void vmbus_child_device_unregister(DEVICE_OBJECT* device_obj)
+{
+	struct device_context *device_ctx = to_device_context(device_obj);
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	DPRINT_INFO(VMBUS_DRV, "unregistering child device (%p)", &device_ctx->device);
+
+	// Kick off the process of unregistering the device.
+	// This will call vmbus_remove() and eventually vmbus_device_release()
+	device_unregister(&device_ctx->device);
+
+	DPRINT_INFO(VMBUS_DRV, "child device (%p) unregistered", &device_ctx->device);
+
+	DPRINT_EXIT(VMBUS_DRV);
+}
+
+
+/*++
+
+Name:	vmbus_child_device_destroy()
+
+Desc:	Destroy the specified child device on the vmbus.
+
+--*/
+static void vmbus_child_device_destroy(DEVICE_OBJECT* device_obj)
+{
+	DPRINT_ENTER(VMBUS_DRV);
+
+	DPRINT_EXIT(VMBUS_DRV);
+}
+
+/*++
+
+Name:	vmbus_uevent()
+
+Desc:	This routine is invoked when a device is added or removed on the vmbus to generate a uevent to udev in the
+		userspace. The udev will then look at its rule and the uevent generated here to load the appropriate driver
+
+--*/
+#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
+#elif defined(KERNEL_2_6_27)
+static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
+{
+	struct device_context *device_ctx = device_to_device_context(device);
+	int i=0;
+	int len=0;
+	int ret;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	DPRINT_INFO(VMBUS_DRV, "generating uevent - VMBUS_DEVICE_CLASS_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
+		device_ctx->class_id.Data[3], device_ctx->class_id.Data[2], device_ctx->class_id.Data[1], device_ctx->class_id.Data[0],
+		device_ctx->class_id.Data[5], device_ctx->class_id.Data[4],
+		device_ctx->class_id.Data[7], device_ctx->class_id.Data[6],
+		device_ctx->class_id.Data[8], device_ctx->class_id.Data[9], device_ctx->class_id.Data[10], device_ctx->class_id.Data[11],
+		device_ctx->class_id.Data[12], device_ctx->class_id.Data[13], device_ctx->class_id.Data[14], device_ctx->class_id.Data[15]);
+
+	env->envp_idx = i;
+	env->buflen = len;
+	ret = add_uevent_var(env,
+		"VMBUS_DEVICE_CLASS_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
+		device_ctx->class_id.Data[3], device_ctx->class_id.Data[2], device_ctx->class_id.Data[1], device_ctx->class_id.Data[0],
+		device_ctx->class_id.Data[5], device_ctx->class_id.Data[4],
+		device_ctx->class_id.Data[7], device_ctx->class_id.Data[6],
+		device_ctx->class_id.Data[8], device_ctx->class_id.Data[9], device_ctx->class_id.Data[10], device_ctx->class_id.Data[11],
+		device_ctx->class_id.Data[12], device_ctx->class_id.Data[13], device_ctx->class_id.Data[14], device_ctx->class_id.Data[15]);
+
+	if (ret)
+	{
+		return ret;
+	}
+
+	ret = add_uevent_var(env,
+		"VMBUS_DEVICE_DEVICE_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
+		device_ctx->device_id.Data[3], device_ctx->device_id.Data[2], device_ctx->device_id.Data[1], device_ctx->device_id.Data[0],
+		device_ctx->device_id.Data[5], device_ctx->device_id.Data[4],
+		device_ctx->device_id.Data[7], device_ctx->device_id.Data[6],
+		device_ctx->device_id.Data[8], device_ctx->device_id.Data[9], device_ctx->device_id.Data[10], device_ctx->device_id.Data[11],
+		device_ctx->device_id.Data[12], device_ctx->device_id.Data[13], device_ctx->device_id.Data[14], device_ctx->device_id.Data[15]);
+
+	if (ret)
+	{
+		return ret;
+	}
+
+	env->envp[env->envp_idx] = NULL;
+
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return 0;
+}
+
+#else
+static int vmbus_uevent(struct device *device, char **envp, int num_envp, char *buffer, int buffer_size)
+{
+	struct device_context *device_ctx = device_to_device_context(device);
+	int i=0;
+	int len=0;
+	int ret;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	DPRINT_INFO(VMBUS_DRV, "generating uevent - VMBUS_DEVICE_CLASS_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
+		device_ctx->class_id.Data[3], device_ctx->class_id.Data[2], device_ctx->class_id.Data[1], device_ctx->class_id.Data[0],
+		device_ctx->class_id.Data[5], device_ctx->class_id.Data[4],
+		device_ctx->class_id.Data[7], device_ctx->class_id.Data[6],
+		device_ctx->class_id.Data[8], device_ctx->class_id.Data[9], device_ctx->class_id.Data[10], device_ctx->class_id.Data[11],
+		device_ctx->class_id.Data[12], device_ctx->class_id.Data[13], device_ctx->class_id.Data[14], device_ctx->class_id.Data[15]);
+
+	ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
+		"VMBUS_DEVICE_CLASS_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
+		device_ctx->class_id.Data[3], device_ctx->class_id.Data[2], device_ctx->class_id.Data[1], device_ctx->class_id.Data[0],
+		device_ctx->class_id.Data[5], device_ctx->class_id.Data[4],
+		device_ctx->class_id.Data[7], device_ctx->class_id.Data[6],
+		device_ctx->class_id.Data[8], device_ctx->class_id.Data[9], device_ctx->class_id.Data[10], device_ctx->class_id.Data[11],
+		device_ctx->class_id.Data[12], device_ctx->class_id.Data[13], device_ctx->class_id.Data[14], device_ctx->class_id.Data[15]);
+
+	if (ret)
+	{
+		return ret;
+	}
+
+	ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
+		"VMBUS_DEVICE_DEVICE_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
+		device_ctx->device_id.Data[3], device_ctx->device_id.Data[2], device_ctx->device_id.Data[1], device_ctx->device_id.Data[0],
+		device_ctx->device_id.Data[5], device_ctx->device_id.Data[4],
+		device_ctx->device_id.Data[7], device_ctx->device_id.Data[6],
+		device_ctx->device_id.Data[8], device_ctx->device_id.Data[9], device_ctx->device_id.Data[10], device_ctx->device_id.Data[11],
+		device_ctx->device_id.Data[12], device_ctx->device_id.Data[13], device_ctx->device_id.Data[14], device_ctx->device_id.Data[15]);
+
+	if (ret)
+	{
+		return ret;
+	}
+
+	envp[i] = NULL;
+
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return 0;
+}
+#endif
+
+/*++
+
+Name:	vmbus_match()
+
+Desc:	Attempt to match the specified device to the specified driver
+
+--*/
+static int vmbus_match(struct device *device, struct device_driver *driver)
+{
+	int match=0;
+	struct driver_context *driver_ctx = driver_to_driver_context(driver);
+	struct device_context *device_ctx = device_to_device_context(device);
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	// We found our driver ?
+	if (memcmp(&device_ctx->class_id, &driver_ctx->class_id, sizeof(GUID)) == 0)
+	{
+		// !! NOTE: The driver_ctx is not a vmbus_drv_ctx. We typecast it here to access the
+		// DRIVER_OBJECT field
+		struct vmbus_driver_context *vmbus_drv_ctx = (struct vmbus_driver_context*)driver_ctx;
+		device_ctx->device_obj.Driver = &vmbus_drv_ctx->drv_obj.Base;
+		DPRINT_INFO(VMBUS_DRV, "device object (%p) set to driver object (%p)", &device_ctx->device_obj, device_ctx->device_obj.Driver);
+
+		match = 1;
+	}
+
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return match;
+}
+
+
+/*++
+
+Name:	vmbus_probe_failed_cb()
+
+Desc:	Callback when a driver probe failed in vmbus_probe(). We need a callback because
+		we cannot invoked device_unregister() inside vmbus_probe() since vmbus_probe() may be
+		invoked inside device_register() i.e. we cannot call device_unregister() inside
+		device_register()
+--*/
+#ifdef KERNEL_2_6_27
+static void vmbus_probe_failed_cb(struct work_struct *context)
+#else
+static void vmbus_probe_failed_cb(void* context)
+#endif
+{
+	struct device_context *device_ctx = (struct device_context*)context;
+
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	// Kick off the process of unregistering the device.
+	// This will call vmbus_remove() and eventually vmbus_device_release()
+	device_unregister(&device_ctx->device);
+
+	//put_device(&device_ctx->device);
+	DPRINT_EXIT(VMBUS_DRV);
+}
+
+
+/*++
+
+Name:	vmbus_probe()
+
+Desc:	Add the new vmbus's child device
+
+--*/
+static int vmbus_probe(struct device *child_device)
+{
+	int ret=0;
+	struct driver_context *driver_ctx = driver_to_driver_context(child_device->driver);
+	struct device_context *device_ctx = device_to_device_context(child_device);
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	// Let the specific open-source driver handles the probe if it can
+	if (driver_ctx->probe)
+	{
+		ret = device_ctx->probe_error = driver_ctx->probe(child_device);
+		if (ret != 0)
+		{
+			DPRINT_ERR(VMBUS_DRV, "probe() failed for device %s (%p) on driver %s (%d)...", child_device->bus_id, child_device, child_device->driver->name, ret);
+
+#ifdef KERNEL_2_6_27
+			INIT_WORK(&device_ctx->probe_failed_work_item, vmbus_probe_failed_cb);
+#else
+			INIT_WORK(&device_ctx->probe_failed_work_item, vmbus_probe_failed_cb, device_ctx);
+#endif
+			schedule_work(&device_ctx->probe_failed_work_item);
+		}
+	}
+	else
+	{
+		DPRINT_ERR(VMBUS_DRV, "probe() method not set for driver - %s", child_device->driver->name);
+		ret = -1;
+	}
+
+	DPRINT_EXIT(VMBUS_DRV);
+	return ret;
+}
+
+
+/*++
+
+Name:	vmbus_remove()
+
+Desc:	Remove a vmbus device
+
+--*/
+static int vmbus_remove(struct device *child_device)
+{
+	int ret=0;
+	struct driver_context *driver_ctx;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	// Special case root bus device
+	if (child_device->parent == NULL)
+	{
+		// No-op since it is statically defined and handle in vmbus_bus_exit()
+		DPRINT_EXIT(VMBUS_DRV);
+		return 0;
+	}
+
+	if (child_device->driver)
+	{
+		driver_ctx = driver_to_driver_context(child_device->driver);
+
+		// Let the specific open-source driver handles the removal if it can
+		if (driver_ctx->remove)
+		{
+			ret = driver_ctx->remove(child_device);
+		}
+		else
+		{
+			DPRINT_ERR(VMBUS_DRV, "remove() method not set for driver - %s", child_device->driver->name);
+			ret = -1;
+		}
+	}
+	else
+	{
+
+	}
+
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return 0;
+}
+
+/*++
+
+Name:	vmbus_shutdown()
+
+Desc:	Shutdown a vmbus device
+
+--*/
+static void vmbus_shutdown(struct device *child_device)
+{
+	struct driver_context *driver_ctx;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	// Special case root bus device
+	if (child_device->parent == NULL)
+	{
+		// No-op since it is statically defined and handle in vmbus_bus_exit()
+		DPRINT_EXIT(VMBUS_DRV);
+		return;
+	}
+
+	// The device may not be attached yet
+	if (!child_device->driver)
+	{
+		DPRINT_EXIT(VMBUS_DRV);
+		return;
+	}
+
+	driver_ctx = driver_to_driver_context(child_device->driver);
+
+	// Let the specific open-source driver handles the removal if it can
+	if (driver_ctx->shutdown)
+	{
+		driver_ctx->shutdown(child_device);
+	}
+
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return;
+}
+
+/*++
+
+Name:	vmbus_bus_release()
+
+Desc:	Final callback release of the vmbus root device
+
+--*/
+static void vmbus_bus_release(struct device *device)
+{
+	DPRINT_ENTER(VMBUS_DRV);
+	DPRINT_EXIT(VMBUS_DRV);
+}
+
+/*++
+
+Name:	vmbus_device_release()
+
+Desc:	Final callback release of the vmbus child device
+
+--*/
+static void vmbus_device_release(struct device *device)
+{
+	struct device_context *device_ctx = device_to_device_context(device);
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	//vmbus_child_device_destroy(&device_ctx->device_obj);
+	kfree(device_ctx);
+
+	// !!DO NOT REFERENCE device_ctx anymore at this point!!
+
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return;
+}
+
+/*++
+
+Name:	vmbus_msg_dpc()
+
+Desc:	Tasklet routine to handle hypervisor messages
+
+--*/
+static void vmbus_msg_dpc(unsigned long data)
+{
+	VMBUS_DRIVER_OBJECT* vmbus_drv_obj = (VMBUS_DRIVER_OBJECT*)data;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	ASSERT(vmbus_drv_obj->OnMsgDpc != NULL);
+
+	// Call to bus driver to handle interrupt
+	vmbus_drv_obj->OnMsgDpc(&vmbus_drv_obj->Base);
+
+	DPRINT_EXIT(VMBUS_DRV);
+}
+
+/*++
+
+Name:	vmbus_msg_dpc()
+
+Desc:	Tasklet routine to handle hypervisor events
+
+--*/
+static void vmbus_event_dpc(unsigned long data)
+{
+	VMBUS_DRIVER_OBJECT* vmbus_drv_obj = (VMBUS_DRIVER_OBJECT*)data;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	ASSERT(vmbus_drv_obj->OnEventDpc != NULL);
+
+	// Call to bus driver to handle interrupt
+	vmbus_drv_obj->OnEventDpc(&vmbus_drv_obj->Base);
+
+	DPRINT_EXIT(VMBUS_DRV);
+}
+
+/*++
+
+Name:	vmbus_msg_dpc()
+
+Desc:	ISR routine
+
+--*/
+#ifdef KERNEL_2_6_27
+static irqreturn_t vmbus_isr(int irq, void* dev_id)
+#else
+static int vmbus_isr(int irq, void* dev_id, struct pt_regs *regs)
+#endif
+{
+	int ret=0;
+	VMBUS_DRIVER_OBJECT* vmbus_driver_obj = &g_vmbus_drv.drv_obj;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	ASSERT(vmbus_driver_obj->OnIsr != NULL);
+
+	// Call to bus driver to handle interrupt
+	ret = vmbus_driver_obj->OnIsr(&vmbus_driver_obj->Base);
+
+	// Schedules a dpc if necessary
+	if (ret > 0)
+	{
+		if (test_bit(0, (unsigned long*)&ret))
+		{
+			tasklet_schedule(&g_vmbus_drv.msg_dpc);
+		}
+
+		if (test_bit(1, (unsigned long*)&ret))
+		{
+			tasklet_schedule(&g_vmbus_drv.event_dpc);
+		}
+
+		DPRINT_EXIT(VMBUS_DRV);
+		return IRQ_HANDLED;
+	}
+	else
+	{
+		DPRINT_EXIT(VMBUS_DRV);
+		return IRQ_NONE;
+	}
+}
+
+MODULE_LICENSE("GPL");
+
+
+/*++
+
+Name:	vmbus_init()
+
+Desc:	Main vmbus driver entry routine
+
+--*/
+static int __init vmbus_init(void)
+{
+	int ret=0;
+
+	DPRINT_ENTER(VMBUS_DRV);
+
+	DPRINT_INFO(VMBUS_DRV,
+		"Vmbus initializing.... current log level 0x%x (%x,%x)",
+		vmbus_loglevel, HIWORD(vmbus_loglevel), LOWORD(vmbus_loglevel));
+#ifdef KERNEL_2_6_27
+//Todo: it is used for loglevel, to be ported to new kernel.
+#else
+	vmbus_ctl_table_hdr = register_sysctl_table(vmus_root_ctl_table, 0);
+	if (!vmbus_ctl_table_hdr)
+	{
+		DPRINT_EXIT(VMBUS_DRV);
+		return -ENOMEM;
+	}
+#endif
+
+	ret = vmbus_bus_init(VmbusInitialize);
+
+	DPRINT_EXIT(VMBUS_DRV);
+	return ret;
+}
+
+
+
+/*++
+
+Name:	vmbus_init()
+
+Desc:	Main vmbus driver exit routine
+
+--*/
+static void __exit vmbus_exit(void)
+{
+	DPRINT_ENTER(VMBUS_DRV);
+
+	vmbus_bus_exit();
+#ifdef KERNEL_2_6_27
+//Todo: it is used for loglevel, to be ported to new kernel.
+#else
+	unregister_sysctl_table(vmbus_ctl_table_hdr);
+#endif
+	DPRINT_EXIT(VMBUS_DRV);
+
+	return;
+}
+
+#if defined(KERNEL_2_6_5)
+#else
+module_param(vmbus_irq, int, S_IRUGO);
+module_param(vmbus_loglevel, int, S_IRUGO);
+#endif
+
+module_init(vmbus_init);
+module_exit(vmbus_exit);
+// eof