]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blob - src/patches/suse-2.6.27.39/patches.drivers/staging-hv-add-the-hyper-v-virtual-bus.patch
projects / people / pmueller / ipfire-2.x.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix oinkmaster patch.
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.39 / patches.drivers / staging-hv-add-the-hyper-v-virtual-bus.patch
1 From foo@baz Mon Jul 13 16:02:34 PDT 2009
2 Date: Mon, 13 Jul 2009 16:02:34 -0700
3 From: Hank Janssen <hjanssen@microsoft.com>
4 Subject: Staging: hv: add the Hyper-V virtual bus
5
6 From: Hank Janssen <hjanssen@microsoft.com>
7
8 This is the virtual bus that all of the Linux Hyper-V drivers use.
9
10 Signed-off-by: Hank Janssen <hjanssen@microsoft.com>
11 Signed-off-by: Haiyang Zhang <haiyangz@microsoft.com>
12 Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
13
14 ---
15 drivers/staging/hv/Channel.c | 1199 +++++++++++++++++++++++++++++++++
16 drivers/staging/hv/Channel.h | 157 ++++
17 drivers/staging/hv/ChannelInterface.c | 222 ++++++
18 drivers/staging/hv/ChannelInterface.h | 41 +
19 drivers/staging/hv/ChannelMgmt.c | 826 ++++++++++++++++++++++
20 drivers/staging/hv/ChannelMgmt.h | 156 ++++
21 drivers/staging/hv/Connection.c | 432 +++++++++++
22 drivers/staging/hv/Hv.c | 672 ++++++++++++++++++
23 drivers/staging/hv/Hv.h | 184 +++++
24 drivers/staging/hv/RingBuffer.c | 630 +++++++++++++++++
25 drivers/staging/hv/RingBuffer.h | 123 +++
26 drivers/staging/hv/Sources.c | 31
27 drivers/staging/hv/VersionInfo.h | 29
28 drivers/staging/hv/Vmbus.c | 508 ++++++++++++++
29 drivers/staging/hv/VmbusPrivate.h | 170 ++++
30 drivers/staging/hv/osd.c | 500 +++++++++++++
31 drivers/staging/hv/vmbus_drv.c | 1228 ++++++++++++++++++++++++++++++++++
32 17 files changed, 7108 insertions(+)
33
34 --- /dev/null
35 +++ b/drivers/staging/hv/Channel.c
36 @@ -0,0 +1,1199 @@
37 +/*
38 + *
39 + * Copyright (c) 2009, Microsoft Corporation.
40 + *
41 + * This program is free software; you can redistribute it and/or modify it
42 + * under the terms and conditions of the GNU General Public License,
43 + * version 2, as published by the Free Software Foundation.
44 + *
45 + * This program is distributed in the hope it will be useful, but WITHOUT
46 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
47 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
48 + * more details.
49 + *
50 + * You should have received a copy of the GNU General Public License along with
51 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
52 + * Place - Suite 330, Boston, MA 02111-1307 USA.
53 + *
54 + * Authors:
55 + * Haiyang Zhang <haiyangz@microsoft.com>
56 + * Hank Janssen <hjanssen@microsoft.com>
57 + *
58 + */
59 +
60 +
61 +#include "osd.h"
62 +#include "logging.h"
63 +
64 +#include "VmbusPrivate.h"
65 +
66 +//
67 +// Internal routines
68 +//
69 +static int
70 +VmbusChannelCreateGpadlHeader(
71 + PVOID Kbuffer, // must be phys and virt contiguous
72 + UINT32 Size, // page-size multiple
73 + VMBUS_CHANNEL_MSGINFO **msgInfo,
74 + UINT32 *MessageCount
75 + );
76 +
77 +static void
78 +DumpVmbusChannel(
79 + VMBUS_CHANNEL *Channel
80 + );
81 +
82 +
83 +static void
84 +VmbusChannelSetEvent(
85 + VMBUS_CHANNEL *Channel
86 + );
87 +
88 +
89 +#if 0
90 +static void
91 +DumpMonitorPage(
92 + HV_MONITOR_PAGE *MonitorPage
93 + )
94 +{
95 + int i=0;
96 + int j=0;
97 +
98 + DPRINT_DBG(VMBUS, "monitorPage - %p, trigger state - %d", MonitorPage, MonitorPage->TriggerState);
99 +
100 + for (i=0; i<4; i++)
101 + {
102 + DPRINT_DBG(VMBUS, "trigger group (%d) - %llx", i, MonitorPage->TriggerGroup[i].AsUINT64);
103 + }
104 +
105 + for (i=0; i<4; i++)
106 + {
107 + for (j=0; j<32; j++)
108 + {
109 + DPRINT_DBG(VMBUS, "latency (%d)(%d) - %llx", i, j, MonitorPage->Latency[i][j]);
110 + }
111 + }
112 + for (i=0; i<4; i++)
113 + {
114 + for (j=0; j<32; j++)
115 + {
116 + DPRINT_DBG(VMBUS, "param-conn id (%d)(%d) - %d", i, j, MonitorPage->Parameter[i][j].ConnectionId.AsUINT32);
117 + DPRINT_DBG(VMBUS, "param-flag (%d)(%d) - %d", i, j, MonitorPage->Parameter[i][j].FlagNumber);
118 +
119 + }
120 + }
121 +}
122 +#endif
123 +
124 +/*++
125 +
126 +Name:
127 + VmbusChannelSetEvent()
128 +
129 +Description:
130 + Trigger an event notification on the specified channel.
131 +
132 +--*/
133 +static void
134 +VmbusChannelSetEvent(
135 + VMBUS_CHANNEL *Channel
136 + )
137 +{
138 + HV_MONITOR_PAGE *monitorPage;
139 +
140 + DPRINT_ENTER(VMBUS);
141 +
142 + if (Channel->OfferMsg.MonitorAllocated)
143 + {
144 + // Each UINT32 represents 32 channels
145 + BitSet((UINT32*)gVmbusConnection.SendInterruptPage + (Channel->OfferMsg.ChildRelId >> 5), Channel->OfferMsg.ChildRelId & 31);
146 +
147 + monitorPage = (HV_MONITOR_PAGE*)gVmbusConnection.MonitorPages;
148 + monitorPage++; // Get the child to parent monitor page
149 +
150 + BitSet((UINT32*) &monitorPage->TriggerGroup[Channel->MonitorGroup].Pending, Channel->MonitorBit);
151 + }
152 + else
153 + {
154 + VmbusSetEvent(Channel->OfferMsg.ChildRelId);
155 + }
156 +
157 + DPRINT_EXIT(VMBUS);
158 +}
159 +
160 +#if 0
161 +static void
162 +VmbusChannelClearEvent(
163 + VMBUS_CHANNEL *Channel
164 + )
165 +{
166 + HV_MONITOR_PAGE *monitorPage;
167 +
168 + DPRINT_ENTER(VMBUS);
169 +
170 + if (Channel->OfferMsg.MonitorAllocated)
171 + {
172 + // Each UINT32 represents 32 channels
173 + BitClear((UINT32*)gVmbusConnection.SendInterruptPage + (Channel->OfferMsg.ChildRelId >> 5), Channel->OfferMsg.ChildRelId & 31);
174 +
175 + monitorPage = (HV_MONITOR_PAGE*)gVmbusConnection.MonitorPages;
176 + monitorPage++; // Get the child to parent monitor page
177 +
178 + BitClear((UINT32*) &monitorPage->TriggerGroup[Channel->MonitorGroup].Pending, Channel->MonitorBit);
179 + }
180 +
181 + DPRINT_EXIT(VMBUS);
182 +}
183 +
184 +#endif
185 +/*++;
186 +
187 +Name:
188 + VmbusChannelGetDebugInfo()
189 +
190 +Description:
191 + Retrieve various channel debug info
192 +
193 +--*/
194 +void
195 +VmbusChannelGetDebugInfo(
196 + VMBUS_CHANNEL *Channel,
197 + VMBUS_CHANNEL_DEBUG_INFO *DebugInfo
198 + )
199 +{
200 + HV_MONITOR_PAGE *monitorPage;
201 + UINT8 monitorGroup = (UINT8)Channel->OfferMsg.MonitorId / 32;
202 + UINT8 monitorOffset = (UINT8)Channel->OfferMsg.MonitorId % 32;
203 + //UINT32 monitorBit = 1 << monitorOffset;
204 +
205 + DebugInfo->RelId = Channel->OfferMsg.ChildRelId;
206 + DebugInfo->State = Channel->State;
207 + memcpy(&DebugInfo->InterfaceType, &Channel->OfferMsg.Offer.InterfaceType, sizeof(GUID));
208 + memcpy(&DebugInfo->InterfaceInstance, &Channel->OfferMsg.Offer.InterfaceInstance, sizeof(GUID));
209 +
210 + monitorPage = (HV_MONITOR_PAGE*)gVmbusConnection.MonitorPages;
211 +
212 + DebugInfo->MonitorId = Channel->OfferMsg.MonitorId;
213 +
214 + DebugInfo->ServerMonitorPending = monitorPage->TriggerGroup[monitorGroup].Pending;
215 + DebugInfo->ServerMonitorLatency = monitorPage->Latency[monitorGroup][ monitorOffset];
216 + DebugInfo->ServerMonitorConnectionId = monitorPage->Parameter[monitorGroup][ monitorOffset].ConnectionId.u.Id;
217 +
218 + monitorPage++;
219 +
220 + DebugInfo->ClientMonitorPending = monitorPage->TriggerGroup[monitorGroup].Pending;
221 + DebugInfo->ClientMonitorLatency = monitorPage->Latency[monitorGroup][ monitorOffset];
222 + DebugInfo->ClientMonitorConnectionId = monitorPage->Parameter[monitorGroup][ monitorOffset].ConnectionId.u.Id;
223 +
224 + RingBufferGetDebugInfo(&Channel->Inbound, &DebugInfo->Inbound);
225 + RingBufferGetDebugInfo(&Channel->Outbound, &DebugInfo->Outbound);
226 +}
227 +
228 +
229 +/*++;
230 +
231 +Name:
232 + VmbusChannelOpen()
233 +
234 +Description:
235 + Open the specified channel.
236 +
237 +--*/
238 +int
239 +VmbusChannelOpen(
240 + VMBUS_CHANNEL *NewChannel,
241 + UINT32 SendRingBufferSize,
242 + UINT32 RecvRingBufferSize,
243 + PVOID UserData,
244 + UINT32 UserDataLen,
245 + PFN_CHANNEL_CALLBACK pfnOnChannelCallback,
246 + PVOID Context
247 + )
248 +{
249 + int ret=0;
250 + VMBUS_CHANNEL_OPEN_CHANNEL* openMsg;
251 + VMBUS_CHANNEL_MSGINFO* openInfo;
252 + void *in, *out;
253 +
254 + DPRINT_ENTER(VMBUS);
255 +
256 + // Aligned to page size
257 + ASSERT(!(SendRingBufferSize & (PAGE_SIZE -1)));
258 + ASSERT(!(RecvRingBufferSize & (PAGE_SIZE -1)));
259 +
260 + NewChannel->OnChannelCallback = pfnOnChannelCallback;
261 + NewChannel->ChannelCallbackContext = Context;
262 +
263 + // Allocate the ring buffer
264 + out = PageAlloc((SendRingBufferSize + RecvRingBufferSize) >> PAGE_SHIFT);
265 + //out = MemAllocZeroed(sendRingBufferSize + recvRingBufferSize);
266 + ASSERT(out);
267 + ASSERT(((ULONG_PTR)out & (PAGE_SIZE-1)) == 0);
268 +
269 + in = (void*)((ULONG_PTR)out + SendRingBufferSize);
270 +
271 + NewChannel->RingBufferPages = out;
272 + NewChannel->RingBufferPageCount = (SendRingBufferSize + RecvRingBufferSize) >> PAGE_SHIFT;
273 +
274 + RingBufferInit(&NewChannel->Outbound, out, SendRingBufferSize);
275 +
276 + RingBufferInit(&NewChannel->Inbound, in, RecvRingBufferSize);
277 +
278 + // Establish the gpadl for the ring buffer
279 + DPRINT_DBG(VMBUS, "Establishing ring buffer's gpadl for channel %p...", NewChannel);
280 +
281 + NewChannel->RingBufferGpadlHandle = 0;
282 +
283 + ret = VmbusChannelEstablishGpadl(NewChannel,
284 + NewChannel->Outbound.RingBuffer,
285 + SendRingBufferSize + RecvRingBufferSize,
286 + &NewChannel->RingBufferGpadlHandle);
287 +
288 + DPRINT_DBG(VMBUS, "channel %p <relid %d gpadl 0x%x send ring %p size %d recv ring %p size %d, downstreamoffset %d>",
289 + NewChannel,
290 + NewChannel->OfferMsg.ChildRelId,
291 + NewChannel->RingBufferGpadlHandle,
292 + NewChannel->Outbound.RingBuffer,
293 + NewChannel->Outbound.RingSize,
294 + NewChannel->Inbound.RingBuffer,
295 + NewChannel->Inbound.RingSize,
296 + SendRingBufferSize);
297 +
298 + // Create and init the channel open message
299 + openInfo =
300 + (VMBUS_CHANNEL_MSGINFO*)MemAlloc(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_OPEN_CHANNEL));
301 + ASSERT(openInfo != NULL);
302 +
303 + openInfo->WaitEvent = WaitEventCreate();
304 +
305 + openMsg = (VMBUS_CHANNEL_OPEN_CHANNEL*)openInfo->Msg;
306 + openMsg->Header.MessageType = ChannelMessageOpenChannel;
307 + openMsg->OpenId = NewChannel->OfferMsg.ChildRelId; // FIXME
308 + openMsg->ChildRelId = NewChannel->OfferMsg.ChildRelId;
309 + openMsg->RingBufferGpadlHandle = NewChannel->RingBufferGpadlHandle;
310 + ASSERT(openMsg->RingBufferGpadlHandle);
311 + openMsg->DownstreamRingBufferPageOffset = SendRingBufferSize >> PAGE_SHIFT;
312 + openMsg->ServerContextAreaGpadlHandle = 0; // TODO
313 +
314 + ASSERT(UserDataLen <= MAX_USER_DEFINED_BYTES);
315 + if (UserDataLen)
316 + {
317 + memcpy(openMsg->UserData, UserData, UserDataLen);
318 + }
319 +
320 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
321 + INSERT_TAIL_LIST(&gVmbusConnection.ChannelMsgList, &openInfo->MsgListEntry);
322 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
323 +
324 + DPRINT_DBG(VMBUS, "Sending channel open msg...");
325 +
326 + ret = VmbusPostMessage(openMsg, sizeof(VMBUS_CHANNEL_OPEN_CHANNEL));
327 + if (ret != 0)
328 + {
329 + DPRINT_ERR(VMBUS, "unable to open channel - %d", ret);
330 + goto Cleanup;
331 + }
332 +
333 + // FIXME: Need to time-out here
334 + WaitEventWait(openInfo->WaitEvent);
335 +
336 + if (openInfo->Response.OpenResult.Status == 0)
337 + {
338 + DPRINT_INFO(VMBUS, "channel <%p> open success!!", NewChannel);
339 + }
340 + else
341 + {
342 + DPRINT_INFO(VMBUS, "channel <%p> open failed - %d!!", NewChannel, openInfo->Response.OpenResult.Status);
343 + }
344 +
345 +Cleanup:
346 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
347 + REMOVE_ENTRY_LIST(&openInfo->MsgListEntry);
348 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
349 +
350 + WaitEventClose(openInfo->WaitEvent);
351 + MemFree(openInfo);
352 +
353 + DPRINT_EXIT(VMBUS);
354 +
355 + return 0;
356 +}
357 +
358 +/*++;
359 +
360 +Name:
361 + DumpGpadlBody()
362 +
363 +Description:
364 + Dump the gpadl body message to the console for debugging purposes.
365 +
366 +--*/
367 +static void DumpGpadlBody(
368 + VMBUS_CHANNEL_GPADL_BODY *Gpadl,
369 + UINT32 Len)
370 +{
371 + int i=0;
372 + int pfnCount=0;
373 +
374 + pfnCount = (Len - sizeof(VMBUS_CHANNEL_GPADL_BODY))/ sizeof(UINT64);
375 + DPRINT_DBG(VMBUS, "gpadl body - len %d pfn count %d", Len, pfnCount);
376 +
377 + for (i=0; i< pfnCount; i++)
378 + {
379 + DPRINT_DBG(VMBUS, "gpadl body - %d) pfn %llu", i, Gpadl->Pfn[i]);
380 + }
381 +}
382 +
383 +
384 +/*++;
385 +
386 +Name:
387 + DumpGpadlHeader()
388 +
389 +Description:
390 + Dump the gpadl header message to the console for debugging purposes.
391 +
392 +--*/
393 +static void DumpGpadlHeader(
394 + VMBUS_CHANNEL_GPADL_HEADER *Gpadl
395 + )
396 +{
397 + int i=0,j=0;
398 + int pageCount=0;
399 +
400 +
401 + DPRINT_DBG(VMBUS, "gpadl header - relid %d, range count %d, range buflen %d",
402 + Gpadl->ChildRelId,
403 + Gpadl->RangeCount,
404 + Gpadl->RangeBufLen);
405 + for (i=0; i< Gpadl->RangeCount; i++)
406 + {
407 + pageCount = Gpadl->Range[i].ByteCount >> PAGE_SHIFT;
408 + pageCount = (pageCount > 26)? 26 : pageCount;
409 +
410 + DPRINT_DBG(VMBUS, "gpadl range %d - len %d offset %d page count %d",
411 + i, Gpadl->Range[i].ByteCount, Gpadl->Range[i].ByteOffset, pageCount);
412 +
413 + for (j=0; j< pageCount; j++)
414 + {
415 + DPRINT_DBG(VMBUS, "%d) pfn %llu", j, Gpadl->Range[i].PfnArray[j]);
416 + }
417 + }
418 +}
419 +
420 +/*++;
421 +
422 +Name:
423 + VmbusChannelCreateGpadlHeader()
424 +
425 +Description:
426 + Creates a gpadl for the specified buffer
427 +
428 +--*/
429 +static int
430 +VmbusChannelCreateGpadlHeader(
431 + PVOID Kbuffer, // from kmalloc()
432 + UINT32 Size, // page-size multiple
433 + VMBUS_CHANNEL_MSGINFO **MsgInfo,
434 + UINT32 *MessageCount)
435 +{
436 + int i;
437 + int pageCount;
438 + unsigned long long pfn;
439 + VMBUS_CHANNEL_GPADL_HEADER* gpaHeader;
440 + VMBUS_CHANNEL_GPADL_BODY* gpadlBody;
441 + VMBUS_CHANNEL_MSGINFO* msgHeader;
442 + VMBUS_CHANNEL_MSGINFO* msgBody;
443 + UINT32 msgSize;
444 +
445 + int pfnSum, pfnCount, pfnLeft, pfnCurr, pfnSize;
446 +
447 + //ASSERT( (kbuffer & (PAGE_SIZE-1)) == 0);
448 + ASSERT( (Size & (PAGE_SIZE-1)) == 0);
449 +
450 + pageCount = Size >> PAGE_SHIFT;
451 + pfn = GetPhysicalAddress(Kbuffer) >> PAGE_SHIFT;
452 +
453 + // do we need a gpadl body msg
454 + pfnSize = MAX_SIZE_CHANNEL_MESSAGE - sizeof(VMBUS_CHANNEL_GPADL_HEADER) - sizeof(GPA_RANGE);
455 + pfnCount = pfnSize / sizeof(UINT64);
456 +
457 + if (pageCount > pfnCount) // we need a gpadl body
458 + {
459 + // fill in the header
460 + msgSize = sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_GPADL_HEADER) + sizeof(GPA_RANGE) + pfnCount*sizeof(UINT64);
461 + msgHeader = MemAllocZeroed(msgSize);
462 +
463 + INITIALIZE_LIST_HEAD(&msgHeader->SubMsgList);
464 + msgHeader->MessageSize=msgSize;
465 +
466 + gpaHeader = (VMBUS_CHANNEL_GPADL_HEADER*)msgHeader->Msg;
467 + gpaHeader->RangeCount = 1;
468 + gpaHeader->RangeBufLen = sizeof(GPA_RANGE) + pageCount*sizeof(UINT64);
469 + gpaHeader->Range[0].ByteOffset = 0;
470 + gpaHeader->Range[0].ByteCount = Size;
471 + for (i=0; i<pfnCount; i++)
472 + {
473 + gpaHeader->Range[0].PfnArray[i] = pfn+i;
474 + }
475 + *MsgInfo = msgHeader;
476 + *MessageCount = 1;
477 +
478 + pfnSum = pfnCount;
479 + pfnLeft = pageCount - pfnCount;
480 +
481 + // how many pfns can we fit
482 + pfnSize = MAX_SIZE_CHANNEL_MESSAGE - sizeof(VMBUS_CHANNEL_GPADL_BODY);
483 + pfnCount = pfnSize / sizeof(UINT64);
484 +
485 + // fill in the body
486 + while (pfnLeft)
487 + {
488 + if (pfnLeft > pfnCount)
489 + {
490 + pfnCurr = pfnCount;
491 + }
492 + else
493 + {
494 + pfnCurr = pfnLeft;
495 + }
496 +
497 + msgSize = sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_GPADL_BODY) + pfnCurr*sizeof(UINT64);
498 + msgBody = MemAllocZeroed(msgSize);
499 + ASSERT(msgBody);
500 + msgBody->MessageSize = msgSize;
501 + (*MessageCount)++;
502 + gpadlBody = (VMBUS_CHANNEL_GPADL_BODY*)msgBody->Msg;
503 +
504 + // FIXME: Gpadl is UINT32 and we are using a pointer which could be 64-bit
505 + //gpadlBody->Gpadl = kbuffer;
506 + for (i=0; i<pfnCurr; i++)
507 + {
508 + gpadlBody->Pfn[i] = pfn + pfnSum + i;
509 + }
510 +
511 + // add to msg header
512 + INSERT_TAIL_LIST(&msgHeader->SubMsgList, &msgBody->MsgListEntry);
513 + pfnSum += pfnCurr;
514 + pfnLeft -= pfnCurr;
515 + }
516 + }
517 + else
518 + {
519 + // everything fits in a header
520 + msgSize = sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_GPADL_HEADER) + sizeof(GPA_RANGE) + pageCount*sizeof(UINT64);
521 + msgHeader = MemAllocZeroed(msgSize);
522 + msgHeader->MessageSize=msgSize;
523 +
524 + gpaHeader = (VMBUS_CHANNEL_GPADL_HEADER*)msgHeader->Msg;
525 + gpaHeader->RangeCount = 1;
526 + gpaHeader->RangeBufLen = sizeof(GPA_RANGE) + pageCount*sizeof(UINT64);
527 + gpaHeader->Range[0].ByteOffset = 0;
528 + gpaHeader->Range[0].ByteCount = Size;
529 + for (i=0; i<pageCount; i++)
530 + {
531 + gpaHeader->Range[0].PfnArray[i] = pfn+i;
532 + }
533 +
534 + *MsgInfo = msgHeader;
535 + *MessageCount = 1;
536 + }
537 +
538 + return 0;
539 +}
540 +
541 +
542 +/*++;
543 +
544 +Name:
545 + VmbusChannelEstablishGpadl()
546 +
547 +Description:
548 + Estabish a GPADL for the specified buffer
549 +
550 +--*/
551 +int
552 +VmbusChannelEstablishGpadl(
553 + VMBUS_CHANNEL *Channel,
554 + PVOID Kbuffer, // from kmalloc()
555 + UINT32 Size, // page-size multiple
556 + UINT32 *GpadlHandle
557 + )
558 +{
559 + int ret=0;
560 + VMBUS_CHANNEL_GPADL_HEADER* gpadlMsg;
561 + VMBUS_CHANNEL_GPADL_BODY* gpadlBody;
562 + //VMBUS_CHANNEL_GPADL_CREATED* gpadlCreated;
563 +
564 + VMBUS_CHANNEL_MSGINFO *msgInfo;
565 + VMBUS_CHANNEL_MSGINFO *subMsgInfo;
566 +
567 + UINT32 msgCount;
568 + LIST_ENTRY* anchor;
569 + LIST_ENTRY* curr;
570 + UINT32 nextGpadlHandle;
571 +
572 + DPRINT_ENTER(VMBUS);
573 +
574 + nextGpadlHandle = gVmbusConnection.NextGpadlHandle;
575 + InterlockedIncrement((int*)&gVmbusConnection.NextGpadlHandle);
576 +
577 + VmbusChannelCreateGpadlHeader(Kbuffer, Size, &msgInfo, &msgCount);
578 + ASSERT(msgInfo != NULL);
579 + ASSERT(msgCount >0);
580 +
581 + msgInfo->WaitEvent = WaitEventCreate();
582 + gpadlMsg = (VMBUS_CHANNEL_GPADL_HEADER*)msgInfo->Msg;
583 + gpadlMsg->Header.MessageType = ChannelMessageGpadlHeader;
584 + gpadlMsg->ChildRelId = Channel->OfferMsg.ChildRelId;
585 + gpadlMsg->Gpadl = nextGpadlHandle;
586 +
587 + DumpGpadlHeader(gpadlMsg);
588 +
589 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
590 + INSERT_TAIL_LIST(&gVmbusConnection.ChannelMsgList, &msgInfo->MsgListEntry);
591 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
592 +
593 + DPRINT_DBG(VMBUS, "buffer %p, size %d msg cnt %d", Kbuffer, Size, msgCount);
594 +
595 + DPRINT_DBG(VMBUS, "Sending GPADL Header - len %d", msgInfo->MessageSize - sizeof(VMBUS_CHANNEL_MSGINFO));
596 +
597 + ret = VmbusPostMessage(gpadlMsg, msgInfo->MessageSize - sizeof(VMBUS_CHANNEL_MSGINFO));
598 + if (ret != 0)
599 + {
600 + DPRINT_ERR(VMBUS, "Unable to open channel - %d", ret);
601 + goto Cleanup;
602 + }
603 +
604 + if (msgCount>1)
605 + {
606 + ITERATE_LIST_ENTRIES(anchor, curr, &msgInfo->SubMsgList)
607 + {
608 + subMsgInfo = (VMBUS_CHANNEL_MSGINFO*) curr;
609 + gpadlBody = (VMBUS_CHANNEL_GPADL_BODY*)subMsgInfo->Msg;
610 +
611 + gpadlBody->Header.MessageType = ChannelMessageGpadlBody;
612 + gpadlBody->Gpadl = nextGpadlHandle;
613 +
614 + DPRINT_DBG(VMBUS, "Sending GPADL Body - len %d", subMsgInfo->MessageSize - sizeof(VMBUS_CHANNEL_MSGINFO));
615 +
616 + DumpGpadlBody(gpadlBody, subMsgInfo->MessageSize - sizeof(VMBUS_CHANNEL_MSGINFO));
617 + ret = VmbusPostMessage(gpadlBody, subMsgInfo->MessageSize - sizeof(VMBUS_CHANNEL_MSGINFO));
618 + ASSERT(ret == 0);
619 + }
620 + }
621 + WaitEventWait(msgInfo->WaitEvent);
622 +
623 + // At this point, we received the gpadl created msg
624 + DPRINT_DBG(VMBUS, "Received GPADL created (relid %d, status %d handle %x)",
625 + Channel->OfferMsg.ChildRelId,
626 + msgInfo->Response.GpadlCreated.CreationStatus,
627 + gpadlMsg->Gpadl);
628 +
629 + *GpadlHandle = gpadlMsg->Gpadl;
630 +
631 +Cleanup:
632 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
633 + REMOVE_ENTRY_LIST(&msgInfo->MsgListEntry);
634 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
635 +
636 + WaitEventClose(msgInfo->WaitEvent);
637 + MemFree(msgInfo);
638 +
639 + DPRINT_EXIT(VMBUS);
640 +
641 + return ret;
642 +}
643 +
644 +
645 +
646 +/*++;
647 +
648 +Name:
649 + VmbusChannelTeardownGpadl()
650 +
651 +Description:
652 + Teardown the specified GPADL handle
653 +
654 +--*/
655 +int
656 +VmbusChannelTeardownGpadl(
657 + VMBUS_CHANNEL *Channel,
658 + UINT32 GpadlHandle
659 + )
660 +{
661 + int ret=0;
662 + VMBUS_CHANNEL_GPADL_TEARDOWN *msg;
663 + VMBUS_CHANNEL_MSGINFO* info;
664 +
665 + DPRINT_ENTER(VMBUS);
666 +
667 + ASSERT(GpadlHandle != 0);
668 +
669 + info =
670 + (VMBUS_CHANNEL_MSGINFO*)MemAlloc(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_GPADL_TEARDOWN));
671 + ASSERT(info != NULL);
672 +
673 + info->WaitEvent = WaitEventCreate();
674 +
675 + msg = (VMBUS_CHANNEL_GPADL_TEARDOWN*)info->Msg;
676 +
677 + msg->Header.MessageType = ChannelMessageGpadlTeardown;
678 + msg->ChildRelId = Channel->OfferMsg.ChildRelId;
679 + msg->Gpadl = GpadlHandle;
680 +
681 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
682 + INSERT_TAIL_LIST(&gVmbusConnection.ChannelMsgList, &info->MsgListEntry);
683 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
684 +
685 + ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_GPADL_TEARDOWN));
686 + if (ret != 0)
687 + {
688 + // TODO:
689 + }
690 +
691 + WaitEventWait(info->WaitEvent);
692 +
693 + // Received a torndown response
694 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
695 + REMOVE_ENTRY_LIST(&info->MsgListEntry);
696 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
697 +
698 + WaitEventClose(info->WaitEvent);
699 + MemFree(info);
700 +
701 + DPRINT_EXIT(VMBUS);
702 +
703 + return ret;
704 +}
705 +
706 +
707 +/*++
708 +
709 +Name:
710 + VmbusChannelClose()
711 +
712 +Description:
713 + Close the specified channel
714 +
715 +--*/
716 +VOID
717 +VmbusChannelClose(
718 + VMBUS_CHANNEL *Channel
719 + )
720 +{
721 + int ret=0;
722 + VMBUS_CHANNEL_CLOSE_CHANNEL* msg;
723 + VMBUS_CHANNEL_MSGINFO* info;
724 +
725 + DPRINT_ENTER(VMBUS);
726 +
727 + // Stop callback and cancel the timer asap
728 + Channel->OnChannelCallback = NULL;
729 + TimerStop(Channel->PollTimer);
730 +
731 + // Send a closing message
732 + info =
733 + (VMBUS_CHANNEL_MSGINFO*)MemAlloc(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_CLOSE_CHANNEL));
734 + ASSERT(info != NULL);
735 +
736 + //info->waitEvent = WaitEventCreate();
737 +
738 + msg = (VMBUS_CHANNEL_CLOSE_CHANNEL*)info->Msg;
739 + msg->Header.MessageType = ChannelMessageCloseChannel;
740 + msg->ChildRelId = Channel->OfferMsg.ChildRelId;
741 +
742 + ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_CLOSE_CHANNEL));
743 + if (ret != 0)
744 + {
745 + // TODO:
746 + }
747 +
748 + // Tear down the gpadl for the channel's ring buffer
749 + if (Channel->RingBufferGpadlHandle)
750 + {
751 + VmbusChannelTeardownGpadl(Channel, Channel->RingBufferGpadlHandle);
752 + }
753 +
754 + // TODO: Send a msg to release the childRelId
755 +
756 + // Cleanup the ring buffers for this channel
757 + RingBufferCleanup(&Channel->Outbound);
758 + RingBufferCleanup(&Channel->Inbound);
759 +
760 + PageFree(Channel->RingBufferPages, Channel->RingBufferPageCount);
761 +
762 + MemFree(info);
763 +
764 + // If we are closing the channel during an error path in opening the channel, don't free the channel
765 + // since the caller will free the channel
766 + if (Channel->State == CHANNEL_OPEN_STATE)
767 + {
768 + SpinlockAcquire(gVmbusConnection.ChannelLock);
769 + REMOVE_ENTRY_LIST(&Channel->ListEntry);
770 + SpinlockRelease(gVmbusConnection.ChannelLock);
771 +
772 + FreeVmbusChannel(Channel);
773 + }
774 +
775 + DPRINT_EXIT(VMBUS);
776 +}
777 +
778 +
779 +/*++
780 +
781 +Name:
782 + VmbusChannelSendPacket()
783 +
784 +Description:
785 + Send the specified buffer on the given channel
786 +
787 +--*/
788 +int
789 +VmbusChannelSendPacket(
790 + VMBUS_CHANNEL *Channel,
791 + const PVOID Buffer,
792 + UINT32 BufferLen,
793 + UINT64 RequestId,
794 + VMBUS_PACKET_TYPE Type,
795 + UINT32 Flags
796 +)
797 +{
798 + int ret=0;
799 + VMPACKET_DESCRIPTOR desc;
800 + UINT32 packetLen = sizeof(VMPACKET_DESCRIPTOR) + BufferLen;
801 + UINT32 packetLenAligned = ALIGN_UP(packetLen, sizeof(UINT64));
802 + SG_BUFFER_LIST bufferList[3];
803 + UINT64 alignedData=0;
804 +
805 + DPRINT_ENTER(VMBUS);
806 + DPRINT_DBG(VMBUS, "channel %p buffer %p len %d", Channel, Buffer, BufferLen);
807 +
808 + DumpVmbusChannel(Channel);
809 +
810 + ASSERT((packetLenAligned - packetLen) < sizeof(UINT64));
811 +
812 + // Setup the descriptor
813 + desc.Type = Type;//VmbusPacketTypeDataInBand;
814 + desc.Flags = Flags;//VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
815 + desc.DataOffset8 = sizeof(VMPACKET_DESCRIPTOR) >> 3; // in 8-bytes granularity
816 + desc.Length8 = (UINT16)(packetLenAligned >> 3);
817 + desc.TransactionId = RequestId;
818 +
819 + bufferList[0].Data = &desc;
820 + bufferList[0].Length = sizeof(VMPACKET_DESCRIPTOR);
821 +
822 + bufferList[1].Data = Buffer;
823 + bufferList[1].Length = BufferLen;
824 +
825 + bufferList[2].Data = &alignedData;
826 + bufferList[2].Length = packetLenAligned - packetLen;
827 +
828 + ret = RingBufferWrite(
829 + &Channel->Outbound,
830 + bufferList,
831 + 3);
832 +
833 + // TODO: We should determine if this is optional
834 + if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
835 + {
836 + VmbusChannelSetEvent(Channel);
837 + }
838 +
839 + DPRINT_EXIT(VMBUS);
840 +
841 + return ret;
842 +}
843 +
844 +
845 +/*++
846 +
847 +Name:
848 + VmbusChannelSendPacketPageBuffer()
849 +
850 +Description:
851 + Send a range of single-page buffer packets using a GPADL Direct packet type.
852 +
853 +--*/
854 +int
855 +VmbusChannelSendPacketPageBuffer(
856 + VMBUS_CHANNEL *Channel,
857 + PAGE_BUFFER PageBuffers[],
858 + UINT32 PageCount,
859 + PVOID Buffer,
860 + UINT32 BufferLen,
861 + UINT64 RequestId
862 +)
863 +{
864 + int ret=0;
865 + int i=0;
866 + VMBUS_CHANNEL_PACKET_PAGE_BUFFER desc;
867 + UINT32 descSize;
868 + UINT32 packetLen;
869 + UINT32 packetLenAligned;
870 + SG_BUFFER_LIST bufferList[3];
871 + UINT64 alignedData=0;
872 +
873 + DPRINT_ENTER(VMBUS);
874 +
875 + ASSERT(PageCount <= MAX_PAGE_BUFFER_COUNT);
876 +
877 + DumpVmbusChannel(Channel);
878 +
879 + // Adjust the size down since VMBUS_CHANNEL_PACKET_PAGE_BUFFER is the largest size we support
880 + descSize = sizeof(VMBUS_CHANNEL_PACKET_PAGE_BUFFER) - ((MAX_PAGE_BUFFER_COUNT - PageCount)*sizeof(PAGE_BUFFER));
881 + packetLen = descSize + BufferLen;
882 + packetLenAligned = ALIGN_UP(packetLen, sizeof(UINT64));
883 +
884 + ASSERT((packetLenAligned - packetLen) < sizeof(UINT64));
885 +
886 + // Setup the descriptor
887 + desc.Type = VmbusPacketTypeDataUsingGpaDirect;
888 + desc.Flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
889 + desc.DataOffset8 = descSize >> 3; // in 8-bytes grandularity
890 + desc.Length8 = (UINT16)(packetLenAligned >> 3);
891 + desc.TransactionId = RequestId;
892 + desc.RangeCount = PageCount;
893 +
894 + for (i=0; i<PageCount; i++)
895 + {
896 + desc.Range[i].Length = PageBuffers[i].Length;
897 + desc.Range[i].Offset = PageBuffers[i].Offset;
898 + desc.Range[i].Pfn = PageBuffers[i].Pfn;
899 + }
900 +
901 + bufferList[0].Data = &desc;
902 + bufferList[0].Length = descSize;
903 +
904 + bufferList[1].Data = Buffer;
905 + bufferList[1].Length = BufferLen;
906 +
907 + bufferList[2].Data = &alignedData;
908 + bufferList[2].Length = packetLenAligned - packetLen;
909 +
910 + ret = RingBufferWrite(
911 + &Channel->Outbound,
912 + bufferList,
913 + 3);
914 +
915 + // TODO: We should determine if this is optional
916 + if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
917 + {
918 + VmbusChannelSetEvent(Channel);
919 + }
920 +
921 + DPRINT_EXIT(VMBUS);
922 +
923 + return ret;
924 +}
925 +
926 +
927 +
928 +/*++
929 +
930 +Name:
931 + VmbusChannelSendPacketMultiPageBuffer()
932 +
933 +Description:
934 + Send a multi-page buffer packet using a GPADL Direct packet type.
935 +
936 +--*/
937 +int
938 +VmbusChannelSendPacketMultiPageBuffer(
939 + VMBUS_CHANNEL *Channel,
940 + MULTIPAGE_BUFFER *MultiPageBuffer,
941 + PVOID Buffer,
942 + UINT32 BufferLen,
943 + UINT64 RequestId
944 +)
945 +{
946 + int ret=0;
947 + VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER desc;
948 + UINT32 descSize;
949 + UINT32 packetLen;
950 + UINT32 packetLenAligned;
951 + SG_BUFFER_LIST bufferList[3];
952 + UINT64 alignedData=0;
953 + UINT32 PfnCount = NUM_PAGES_SPANNED(MultiPageBuffer->Offset, MultiPageBuffer->Length);
954 +
955 + DPRINT_ENTER(VMBUS);
956 +
957 + DumpVmbusChannel(Channel);
958 +
959 + DPRINT_DBG(VMBUS, "data buffer - offset %u len %u pfn count %u", MultiPageBuffer->Offset, MultiPageBuffer->Length, PfnCount);
960 +
961 + ASSERT(PfnCount > 0);
962 + ASSERT(PfnCount <= MAX_MULTIPAGE_BUFFER_COUNT);
963 +
964 + // Adjust the size down since VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER is the largest size we support
965 + descSize = sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER) - ((MAX_MULTIPAGE_BUFFER_COUNT - PfnCount)*sizeof(UINT64));
966 + packetLen = descSize + BufferLen;
967 + packetLenAligned = ALIGN_UP(packetLen, sizeof(UINT64));
968 +
969 + ASSERT((packetLenAligned - packetLen) < sizeof(UINT64));
970 +
971 + // Setup the descriptor
972 + desc.Type = VmbusPacketTypeDataUsingGpaDirect;
973 + desc.Flags = VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED;
974 + desc.DataOffset8 = descSize >> 3; // in 8-bytes grandularity
975 + desc.Length8 = (UINT16)(packetLenAligned >> 3);
976 + desc.TransactionId = RequestId;
977 + desc.RangeCount = 1;
978 +
979 + desc.Range.Length = MultiPageBuffer->Length;
980 + desc.Range.Offset = MultiPageBuffer->Offset;
981 +
982 + memcpy(desc.Range.PfnArray, MultiPageBuffer->PfnArray, PfnCount*sizeof(UINT64));
983 +
984 + bufferList[0].Data = &desc;
985 + bufferList[0].Length = descSize;
986 +
987 + bufferList[1].Data = Buffer;
988 + bufferList[1].Length = BufferLen;
989 +
990 + bufferList[2].Data = &alignedData;
991 + bufferList[2].Length = packetLenAligned - packetLen;
992 +
993 + ret = RingBufferWrite(
994 + &Channel->Outbound,
995 + bufferList,
996 + 3);
997 +
998 + // TODO: We should determine if this is optional
999 + if (ret == 0 && !GetRingBufferInterruptMask(&Channel->Outbound))
1000 + {
1001 + VmbusChannelSetEvent(Channel);
1002 + }
1003 +
1004 + DPRINT_EXIT(VMBUS);
1005 +
1006 + return ret;
1007 +}
1008 +
1009 +
1010 +/*++
1011 +
1012 +Name:
1013 + VmbusChannelRecvPacket()
1014 +
1015 +Description:
1016 + Retrieve the user packet on the specified channel
1017 +
1018 +--*/
1019 +// TODO: Do we ever receive a gpa direct packet other than the ones we send ?
1020 +int
1021 +VmbusChannelRecvPacket(
1022 + VMBUS_CHANNEL *Channel,
1023 + PVOID Buffer,
1024 + UINT32 BufferLen,
1025 + UINT32* BufferActualLen,
1026 + UINT64* RequestId
1027 + )
1028 +{
1029 + VMPACKET_DESCRIPTOR desc;
1030 + UINT32 packetLen;
1031 + UINT32 userLen;
1032 + int ret;
1033 +
1034 + DPRINT_ENTER(VMBUS);
1035 +
1036 + *BufferActualLen = 0;
1037 + *RequestId = 0;
1038 +
1039 + SpinlockAcquire(Channel->InboundLock);
1040 +
1041 + ret = RingBufferPeek(&Channel->Inbound, &desc, sizeof(VMPACKET_DESCRIPTOR));
1042 + if (ret != 0)
1043 + {
1044 + SpinlockRelease(Channel->InboundLock);
1045 +
1046 + //DPRINT_DBG(VMBUS, "nothing to read!!");
1047 + DPRINT_EXIT(VMBUS);
1048 + return 0;
1049 + }
1050 +
1051 + //VmbusChannelClearEvent(Channel);
1052 +
1053 + packetLen = desc.Length8 << 3;
1054 + userLen = packetLen - (desc.DataOffset8 << 3);
1055 + //ASSERT(userLen > 0);
1056 +
1057 + DPRINT_DBG(VMBUS, "packet received on channel %p relid %d <type %d flag %d tid %llx pktlen %d datalen %d> ",
1058 + Channel,
1059 + Channel->OfferMsg.ChildRelId,
1060 + desc.Type,
1061 + desc.Flags,
1062 + desc.TransactionId, packetLen, userLen);
1063 +
1064 + *BufferActualLen = userLen;
1065 +
1066 + if (userLen > BufferLen)
1067 + {
1068 + SpinlockRelease(Channel->InboundLock);
1069 +
1070 + DPRINT_ERR(VMBUS, "buffer too small - got %d needs %d", BufferLen, userLen);
1071 + DPRINT_EXIT(VMBUS);
1072 +
1073 + return -1;
1074 + }
1075 +
1076 + *RequestId = desc.TransactionId;
1077 +
1078 + // Copy over the packet to the user buffer
1079 + ret = RingBufferRead(&Channel->Inbound, Buffer, userLen, (desc.DataOffset8 << 3));
1080 +
1081 + SpinlockRelease(Channel->InboundLock);
1082 +
1083 + DPRINT_EXIT(VMBUS);
1084 +
1085 + return 0;
1086 +}
1087 +
1088 +/*++
1089 +
1090 +Name:
1091 + VmbusChannelRecvPacketRaw()
1092 +
1093 +Description:
1094 + Retrieve the raw packet on the specified channel
1095 +
1096 +--*/
1097 +int
1098 +VmbusChannelRecvPacketRaw(
1099 + VMBUS_CHANNEL *Channel,
1100 + PVOID Buffer,
1101 + UINT32 BufferLen,
1102 + UINT32* BufferActualLen,
1103 + UINT64* RequestId
1104 + )
1105 +{
1106 + VMPACKET_DESCRIPTOR desc;
1107 + UINT32 packetLen;
1108 + UINT32 userLen;
1109 + int ret;
1110 +
1111 + DPRINT_ENTER(VMBUS);
1112 +
1113 + *BufferActualLen = 0;
1114 + *RequestId = 0;
1115 +
1116 + SpinlockAcquire(Channel->InboundLock);
1117 +
1118 + ret = RingBufferPeek(&Channel->Inbound, &desc, sizeof(VMPACKET_DESCRIPTOR));
1119 + if (ret != 0)
1120 + {
1121 + SpinlockRelease(Channel->InboundLock);
1122 +
1123 + //DPRINT_DBG(VMBUS, "nothing to read!!");
1124 + DPRINT_EXIT(VMBUS);
1125 + return 0;
1126 + }
1127 +
1128 + //VmbusChannelClearEvent(Channel);
1129 +
1130 + packetLen = desc.Length8 << 3;
1131 + userLen = packetLen - (desc.DataOffset8 << 3);
1132 +
1133 + DPRINT_DBG(VMBUS, "packet received on channel %p relid %d <type %d flag %d tid %llx pktlen %d datalen %d> ",
1134 + Channel,
1135 + Channel->OfferMsg.ChildRelId,
1136 + desc.Type,
1137 + desc.Flags,
1138 + desc.TransactionId, packetLen, userLen);
1139 +
1140 + *BufferActualLen = packetLen;
1141 +
1142 + if (packetLen > BufferLen)
1143 + {
1144 + SpinlockRelease(Channel->InboundLock);
1145 +
1146 + DPRINT_ERR(VMBUS, "buffer too small - needed %d bytes but got space for only %d bytes", packetLen, BufferLen);
1147 + DPRINT_EXIT(VMBUS);
1148 + return -2;
1149 + }
1150 +
1151 + *RequestId = desc.TransactionId;
1152 +
1153 + // Copy over the entire packet to the user buffer
1154 + ret = RingBufferRead(&Channel->Inbound, Buffer, packetLen, 0);
1155 +
1156 + SpinlockRelease(Channel->InboundLock);
1157 +
1158 + DPRINT_EXIT(VMBUS);
1159 +
1160 + return 0;
1161 +}
1162 +
1163 +
1164 +/*++
1165 +
1166 +Name:
1167 + VmbusChannelOnChannelEvent()
1168 +
1169 +Description:
1170 + Channel event callback
1171 +
1172 +--*/
1173 +void
1174 +VmbusChannelOnChannelEvent(
1175 + VMBUS_CHANNEL *Channel
1176 + )
1177 +{
1178 + DumpVmbusChannel(Channel);
1179 + ASSERT(Channel->OnChannelCallback);
1180 +#ifdef ENABLE_POLLING
1181 + TimerStop(Channel->PollTimer);
1182 + Channel->OnChannelCallback(Channel->ChannelCallbackContext);
1183 + TimerStart(Channel->PollTimer, 100 /* 100us */);
1184 +#else
1185 + Channel->OnChannelCallback(Channel->ChannelCallbackContext);
1186 +#endif
1187 +}
1188 +
1189 +/*++
1190 +
1191 +Name:
1192 + VmbusChannelOnTimer()
1193 +
1194 +Description:
1195 + Timer event callback
1196 +
1197 +--*/
1198 +void
1199 +VmbusChannelOnTimer(
1200 + void *Context
1201 + )
1202 +{
1203 + VMBUS_CHANNEL *channel = (VMBUS_CHANNEL*)Context;
1204 +
1205 + if (channel->OnChannelCallback)
1206 + {
1207 + channel->OnChannelCallback(channel->ChannelCallbackContext);
1208 +#ifdef ENABLE_POLLING
1209 + TimerStart(channel->PollTimer, 100 /* 100us */);
1210 +#endif
1211 + }
1212 +}
1213 +
1214 +
1215 +/*++
1216 +
1217 +Name:
1218 + DumpVmbusChannel()
1219 +
1220 +Description:
1221 + Dump vmbus channel info to the console
1222 +
1223 +--*/
1224 +static void
1225 +DumpVmbusChannel(
1226 + VMBUS_CHANNEL *Channel
1227 + )
1228 +{
1229 + DPRINT_DBG(VMBUS, "Channel (%d)", Channel->OfferMsg.ChildRelId);
1230 + DumpRingInfo(&Channel->Outbound, "Outbound ");
1231 + DumpRingInfo(&Channel->Inbound, "Inbound ");
1232 +}
1233 +
1234 +
1235 +// eof
1236 --- /dev/null
1237 +++ b/drivers/staging/hv/Channel.h
1238 @@ -0,0 +1,157 @@
1239 +/*
1240 + *
1241 + * Copyright (c) 2009, Microsoft Corporation.
1242 + *
1243 + * This program is free software; you can redistribute it and/or modify it
1244 + * under the terms and conditions of the GNU General Public License,
1245 + * version 2, as published by the Free Software Foundation.
1246 + *
1247 + * This program is distributed in the hope it will be useful, but WITHOUT
1248 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1249 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
1250 + * more details.
1251 + *
1252 + * You should have received a copy of the GNU General Public License along with
1253 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
1254 + * Place - Suite 330, Boston, MA 02111-1307 USA.
1255 + *
1256 + * Authors:
1257 + * Haiyang Zhang <haiyangz@microsoft.com>
1258 + * Hank Janssen <hjanssen@microsoft.com>
1259 + *
1260 + */
1261 +
1262 +
1263 +#ifndef _CHANNEL_H_
1264 +#define _CHANNEL_H_
1265 +
1266 +#include "osd.h"
1267 +#include "ChannelMgmt.h"
1268 +
1269 +#pragma pack(push,1)
1270 +
1271 +
1272 +// The format must be the same as VMDATA_GPA_DIRECT
1273 +typedef struct _VMBUS_CHANNEL_PACKET_PAGE_BUFFER {
1274 + UINT16 Type;
1275 + UINT16 DataOffset8;
1276 + UINT16 Length8;
1277 + UINT16 Flags;
1278 + UINT64 TransactionId;
1279 + UINT32 Reserved;
1280 + UINT32 RangeCount;
1281 + PAGE_BUFFER Range[MAX_PAGE_BUFFER_COUNT];
1282 +} VMBUS_CHANNEL_PACKET_PAGE_BUFFER;
1283 +
1284 +
1285 +// The format must be the same as VMDATA_GPA_DIRECT
1286 +typedef struct _VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER {
1287 + UINT16 Type;
1288 + UINT16 DataOffset8;
1289 + UINT16 Length8;
1290 + UINT16 Flags;
1291 + UINT64 TransactionId;
1292 + UINT32 Reserved;
1293 + UINT32 RangeCount; // Always 1 in this case
1294 + MULTIPAGE_BUFFER Range;
1295 +} VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER;
1296 +
1297 +#pragma pack(pop)
1298 +
1299 +//
1300 +// Routines
1301 +//
1302 +
1303 +INTERNAL int
1304 +VmbusChannelOpen(
1305 + VMBUS_CHANNEL *Channel,
1306 + UINT32 SendRingBufferSize,
1307 + UINT32 RecvRingBufferSize,
1308 + PVOID UserData,
1309 + UINT32 UserDataLen,
1310 + PFN_CHANNEL_CALLBACK pfnOnChannelCallback,
1311 + PVOID Context
1312 + );
1313 +
1314 +INTERNAL void
1315 +VmbusChannelClose(
1316 + VMBUS_CHANNEL *Channel
1317 + );
1318 +
1319 +INTERNAL int
1320 +VmbusChannelSendPacket(
1321 + VMBUS_CHANNEL *Channel,
1322 + const PVOID Buffer,
1323 + UINT32 BufferLen,
1324 + UINT64 RequestId,
1325 + VMBUS_PACKET_TYPE Type,
1326 + UINT32 Flags
1327 +);
1328 +
1329 +INTERNAL int
1330 +VmbusChannelSendPacketPageBuffer(
1331 + VMBUS_CHANNEL *Channel,
1332 + PAGE_BUFFER PageBuffers[],
1333 + UINT32 PageCount,
1334 + PVOID Buffer,
1335 + UINT32 BufferLen,
1336 + UINT64 RequestId
1337 + );
1338 +
1339 +INTERNAL int
1340 +VmbusChannelSendPacketMultiPageBuffer(
1341 + VMBUS_CHANNEL *Channel,
1342 + MULTIPAGE_BUFFER *MultiPageBuffer,
1343 + PVOID Buffer,
1344 + UINT32 BufferLen,
1345 + UINT64 RequestId
1346 +);
1347 +
1348 +INTERNAL int
1349 +VmbusChannelEstablishGpadl(
1350 + VMBUS_CHANNEL *Channel,
1351 + PVOID Kbuffer, // from kmalloc()
1352 + UINT32 Size, // page-size multiple
1353 + UINT32 *GpadlHandle
1354 + );
1355 +
1356 +INTERNAL int
1357 +VmbusChannelTeardownGpadl(
1358 + VMBUS_CHANNEL *Channel,
1359 + UINT32 GpadlHandle
1360 + );
1361 +
1362 +INTERNAL int
1363 +VmbusChannelRecvPacket(
1364 + VMBUS_CHANNEL *Channel,
1365 + PVOID Buffer,
1366 + UINT32 BufferLen,
1367 + UINT32* BufferActualLen,
1368 + UINT64* RequestId
1369 + );
1370 +
1371 +INTERNAL int
1372 +VmbusChannelRecvPacketRaw(
1373 + VMBUS_CHANNEL *Channel,
1374 + PVOID Buffer,
1375 + UINT32 BufferLen,
1376 + UINT32* BufferActualLen,
1377 + UINT64* RequestId
1378 + );
1379 +
1380 +INTERNAL void
1381 +VmbusChannelOnChannelEvent(
1382 + VMBUS_CHANNEL *Channel
1383 + );
1384 +
1385 +INTERNAL void
1386 +VmbusChannelGetDebugInfo(
1387 + VMBUS_CHANNEL *Channel,
1388 + VMBUS_CHANNEL_DEBUG_INFO *DebugInfo
1389 + );
1390 +
1391 +INTERNAL void
1392 +VmbusChannelOnTimer(
1393 + void *Context
1394 + );
1395 +#endif //_CHANNEL_H_
1396 --- /dev/null
1397 +++ b/drivers/staging/hv/ChannelInterface.c
1398 @@ -0,0 +1,222 @@
1399 +/*
1400 + *
1401 + * Copyright (c) 2009, Microsoft Corporation.
1402 + *
1403 + * This program is free software; you can redistribute it and/or modify it
1404 + * under the terms and conditions of the GNU General Public License,
1405 + * version 2, as published by the Free Software Foundation.
1406 + *
1407 + * This program is distributed in the hope it will be useful, but WITHOUT
1408 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1409 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
1410 + * more details.
1411 + *
1412 + * You should have received a copy of the GNU General Public License along with
1413 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
1414 + * Place - Suite 330, Boston, MA 02111-1307 USA.
1415 + *
1416 + * Authors:
1417 + * Haiyang Zhang <haiyangz@microsoft.com>
1418 + * Hank Janssen <hjanssen@microsoft.com>
1419 + *
1420 + */
1421 +
1422 +#include "VmbusPrivate.h"
1423 +
1424 +INTERNAL int
1425 +IVmbusChannelOpen(
1426 + PDEVICE_OBJECT Device,
1427 + UINT32 SendBufferSize,
1428 + UINT32 RecvRingBufferSize,
1429 + PVOID UserData,
1430 + UINT32 UserDataLen,
1431 + VMBUS_CHANNEL_CALLBACK ChannelCallback,
1432 + PVOID Context
1433 + )
1434 +{
1435 + return VmbusChannelOpen( (VMBUS_CHANNEL*)Device->context,
1436 + SendBufferSize,
1437 + RecvRingBufferSize,
1438 + UserData,
1439 + UserDataLen,
1440 + ChannelCallback,
1441 + Context);
1442 +}
1443 +
1444 +
1445 +INTERNAL void
1446 +IVmbusChannelClose(
1447 + PDEVICE_OBJECT Device
1448 + )
1449 +{
1450 + VmbusChannelClose((VMBUS_CHANNEL*)Device->context);
1451 +}
1452 +
1453 +
1454 +INTERNAL int
1455 +IVmbusChannelSendPacket(
1456 + PDEVICE_OBJECT Device,
1457 + const PVOID Buffer,
1458 + UINT32 BufferLen,
1459 + UINT64 RequestId,
1460 + UINT32 Type,
1461 + UINT32 Flags
1462 + )
1463 +{
1464 + return VmbusChannelSendPacket((VMBUS_CHANNEL*)Device->context,
1465 + Buffer,
1466 + BufferLen,
1467 + RequestId,
1468 + Type,
1469 + Flags);
1470 +}
1471 +
1472 +INTERNAL int
1473 +IVmbusChannelSendPacketPageBuffer(
1474 + PDEVICE_OBJECT Device,
1475 + PAGE_BUFFER PageBuffers[],
1476 + UINT32 PageCount,
1477 + PVOID Buffer,
1478 + UINT32 BufferLen,
1479 + UINT64 RequestId
1480 + )
1481 +{
1482 + return VmbusChannelSendPacketPageBuffer((VMBUS_CHANNEL*)Device->context,
1483 + PageBuffers,
1484 + PageCount,
1485 + Buffer,
1486 + BufferLen,
1487 + RequestId);
1488 +}
1489 +
1490 +INTERNAL int
1491 +IVmbusChannelSendPacketMultiPageBuffer(
1492 + PDEVICE_OBJECT Device,
1493 + MULTIPAGE_BUFFER *MultiPageBuffer,
1494 + PVOID Buffer,
1495 + UINT32 BufferLen,
1496 + UINT64 RequestId
1497 + )
1498 +{
1499 + return VmbusChannelSendPacketMultiPageBuffer((VMBUS_CHANNEL*)Device->context,
1500 + MultiPageBuffer,
1501 + Buffer,
1502 + BufferLen,
1503 + RequestId);
1504 +}
1505 +
1506 +INTERNAL int
1507 +IVmbusChannelRecvPacket (
1508 + PDEVICE_OBJECT Device,
1509 + PVOID Buffer,
1510 + UINT32 BufferLen,
1511 + UINT32* BufferActualLen,
1512 + UINT64* RequestId
1513 + )
1514 +{
1515 + return VmbusChannelRecvPacket((VMBUS_CHANNEL*)Device->context,
1516 + Buffer,
1517 + BufferLen,
1518 + BufferActualLen,
1519 + RequestId);
1520 +}
1521 +
1522 +INTERNAL int
1523 +IVmbusChannelRecvPacketRaw(
1524 + PDEVICE_OBJECT Device,
1525 + PVOID Buffer,
1526 + UINT32 BufferLen,
1527 + UINT32* BufferActualLen,
1528 + UINT64* RequestId
1529 + )
1530 +{
1531 + return VmbusChannelRecvPacketRaw((VMBUS_CHANNEL*)Device->context,
1532 + Buffer,
1533 + BufferLen,
1534 + BufferActualLen,
1535 + RequestId);
1536 +}
1537 +
1538 +INTERNAL int
1539 +IVmbusChannelEstablishGpadl(
1540 + PDEVICE_OBJECT Device,
1541 + PVOID Buffer,
1542 + UINT32 BufferLen,
1543 + UINT32* GpadlHandle
1544 + )
1545 +{
1546 + return VmbusChannelEstablishGpadl((VMBUS_CHANNEL*)Device->context,
1547 + Buffer,
1548 + BufferLen,
1549 + GpadlHandle);
1550 +}
1551 +
1552 +INTERNAL int
1553 +IVmbusChannelTeardownGpadl(
1554 + PDEVICE_OBJECT Device,
1555 + UINT32 GpadlHandle
1556 + )
1557 +{
1558 + return VmbusChannelTeardownGpadl((VMBUS_CHANNEL*)Device->context,
1559 + GpadlHandle);
1560 +
1561 +}
1562 +
1563 +INTERNAL void
1564 +GetChannelInterface(
1565 + VMBUS_CHANNEL_INTERFACE *ChannelInterface
1566 + )
1567 +{
1568 + ChannelInterface->Open = IVmbusChannelOpen;
1569 + ChannelInterface->Close = IVmbusChannelClose;
1570 + ChannelInterface->SendPacket = IVmbusChannelSendPacket;
1571 + ChannelInterface->SendPacketPageBuffer = IVmbusChannelSendPacketPageBuffer;
1572 + ChannelInterface->SendPacketMultiPageBuffer = IVmbusChannelSendPacketMultiPageBuffer;
1573 + ChannelInterface->RecvPacket = IVmbusChannelRecvPacket;
1574 + ChannelInterface->RecvPacketRaw = IVmbusChannelRecvPacketRaw;
1575 + ChannelInterface->EstablishGpadl = IVmbusChannelEstablishGpadl;
1576 + ChannelInterface->TeardownGpadl = IVmbusChannelTeardownGpadl;
1577 + ChannelInterface->GetInfo = GetChannelInfo;
1578 +}
1579 +
1580 +
1581 +INTERNAL void
1582 +GetChannelInfo(
1583 + PDEVICE_OBJECT Device,
1584 + DEVICE_INFO *DeviceInfo
1585 + )
1586 +{
1587 + VMBUS_CHANNEL_DEBUG_INFO debugInfo;
1588 +
1589 + if (Device->context)
1590 + {
1591 + VmbusChannelGetDebugInfo((VMBUS_CHANNEL*)Device->context, &debugInfo);
1592 +
1593 + DeviceInfo->ChannelId = debugInfo.RelId;
1594 + DeviceInfo->ChannelState = debugInfo.State;
1595 + memcpy(&DeviceInfo->ChannelType, &debugInfo.InterfaceType, sizeof(GUID));
1596 + memcpy(&DeviceInfo->ChannelInstance, &debugInfo.InterfaceInstance, sizeof(GUID));
1597 +
1598 + DeviceInfo->MonitorId = debugInfo.MonitorId;
1599 +
1600 + DeviceInfo->ServerMonitorPending = debugInfo.ServerMonitorPending;
1601 + DeviceInfo->ServerMonitorLatency = debugInfo.ServerMonitorLatency;
1602 + DeviceInfo->ServerMonitorConnectionId = debugInfo.ServerMonitorConnectionId;
1603 +
1604 + DeviceInfo->ClientMonitorPending = debugInfo.ClientMonitorPending;
1605 + DeviceInfo->ClientMonitorLatency = debugInfo.ClientMonitorLatency;
1606 + DeviceInfo->ClientMonitorConnectionId = debugInfo.ClientMonitorConnectionId;
1607 +
1608 + DeviceInfo->Inbound.InterruptMask = debugInfo.Inbound.CurrentInterruptMask;
1609 + DeviceInfo->Inbound.ReadIndex = debugInfo.Inbound.CurrentReadIndex;
1610 + DeviceInfo->Inbound.WriteIndex = debugInfo.Inbound.CurrentWriteIndex;
1611 + DeviceInfo->Inbound.BytesAvailToRead = debugInfo.Inbound.BytesAvailToRead;
1612 + DeviceInfo->Inbound.BytesAvailToWrite = debugInfo.Inbound.BytesAvailToWrite;
1613 +
1614 + DeviceInfo->Outbound.InterruptMask = debugInfo.Outbound.CurrentInterruptMask;
1615 + DeviceInfo->Outbound.ReadIndex = debugInfo.Outbound.CurrentReadIndex;
1616 + DeviceInfo->Outbound.WriteIndex = debugInfo.Outbound.CurrentWriteIndex;
1617 + DeviceInfo->Outbound.BytesAvailToRead = debugInfo.Outbound.BytesAvailToRead;
1618 + DeviceInfo->Outbound.BytesAvailToWrite = debugInfo.Outbound.BytesAvailToWrite;
1619 + }
1620 +}
1621 --- /dev/null
1622 +++ b/drivers/staging/hv/ChannelInterface.h
1623 @@ -0,0 +1,41 @@
1624 +/*
1625 + *
1626 + * Copyright (c) 2009, Microsoft Corporation.
1627 + *
1628 + * This program is free software; you can redistribute it and/or modify it
1629 + * under the terms and conditions of the GNU General Public License,
1630 + * version 2, as published by the Free Software Foundation.
1631 + *
1632 + * This program is distributed in the hope it will be useful, but WITHOUT
1633 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1634 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
1635 + * more details.
1636 + *
1637 + * You should have received a copy of the GNU General Public License along with
1638 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
1639 + * Place - Suite 330, Boston, MA 02111-1307 USA.
1640 + *
1641 + * Authors:
1642 + * Haiyang Zhang <haiyangz@microsoft.com>
1643 + * Hank Janssen <hjanssen@microsoft.com>
1644 + *
1645 + */
1646 +
1647 +
1648 +#ifndef _CHANNEL_INTERFACE_H_
1649 +#define _CHANNEL_INTERFACE_H_
1650 +
1651 +#include "VmbusApi.h"
1652 +
1653 +INTERNAL void
1654 +GetChannelInterface(
1655 + VMBUS_CHANNEL_INTERFACE *ChannelInterface
1656 + );
1657 +
1658 +INTERNAL void
1659 +GetChannelInfo(
1660 + PDEVICE_OBJECT Device,
1661 + DEVICE_INFO *DeviceInfo
1662 + );
1663 +
1664 +#endif // _CHANNEL_INTERFACE_H_
1665 --- /dev/null
1666 +++ b/drivers/staging/hv/ChannelMgmt.c
1667 @@ -0,0 +1,826 @@
1668 +/*
1669 + *
1670 + * Copyright (c) 2009, Microsoft Corporation.
1671 + *
1672 + * This program is free software; you can redistribute it and/or modify it
1673 + * under the terms and conditions of the GNU General Public License,
1674 + * version 2, as published by the Free Software Foundation.
1675 + *
1676 + * This program is distributed in the hope it will be useful, but WITHOUT
1677 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1678 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
1679 + * more details.
1680 + *
1681 + * You should have received a copy of the GNU General Public License along with
1682 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
1683 + * Place - Suite 330, Boston, MA 02111-1307 USA.
1684 + *
1685 + * Authors:
1686 + * Haiyang Zhang <haiyangz@microsoft.com>
1687 + * Hank Janssen <hjanssen@microsoft.com>
1688 + *
1689 + */
1690 +
1691 +
1692 +#include "osd.h"
1693 +#include "logging.h"
1694 +
1695 +#include "VmbusPrivate.h"
1696 +
1697 +//
1698 +// Defines
1699 +//
1700 +
1701 +//
1702 +// Data types
1703 +//
1704 +
1705 +typedef void (*PFN_CHANNEL_MESSAGE_HANDLER)(VMBUS_CHANNEL_MESSAGE_HEADER* msg);
1706 +
1707 +typedef struct _VMBUS_CHANNEL_MESSAGE_TABLE_ENTRY {
1708 + VMBUS_CHANNEL_MESSAGE_TYPE messageType;
1709 + PFN_CHANNEL_MESSAGE_HANDLER messageHandler;
1710 +} VMBUS_CHANNEL_MESSAGE_TABLE_ENTRY;
1711 +
1712 +//
1713 +// Internal routines
1714 +//
1715 +
1716 +static void
1717 +VmbusChannelOnOffer(
1718 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
1719 + );
1720 +static void
1721 +VmbusChannelOnOpenResult(
1722 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
1723 + );
1724 +
1725 +static void
1726 +VmbusChannelOnOfferRescind(
1727 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
1728 + );
1729 +
1730 +static void
1731 +VmbusChannelOnGpadlCreated(
1732 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
1733 + );
1734 +
1735 +static void
1736 +VmbusChannelOnGpadlTorndown(
1737 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
1738 + );
1739 +
1740 +static void
1741 +VmbusChannelOnOffersDelivered(
1742 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
1743 + );
1744 +
1745 +static void
1746 +VmbusChannelOnVersionResponse(
1747 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
1748 + );
1749 +
1750 +static void
1751 +VmbusChannelProcessOffer(
1752 + PVOID context
1753 + );
1754 +
1755 +static void
1756 +VmbusChannelProcessRescindOffer(
1757 + PVOID context
1758 + );
1759 +
1760 +
1761 +//
1762 +// Globals
1763 +//
1764 +
1765 +#define MAX_NUM_DEVICE_CLASSES_SUPPORTED 4
1766 +
1767 +const GUID gSupportedDeviceClasses[MAX_NUM_DEVICE_CLASSES_SUPPORTED]= {
1768 + //{ba6163d9-04a1-4d29-b605-72e2ffb1dc7f}
1769 + {.Data = {0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d, 0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f}},// Storage - SCSI
1770 + //{F8615163-DF3E-46c5-913F-F2D2F965ED0E}
1771 + {.Data = {0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46, 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E}}, // Network
1772 + //{CFA8B69E-5B4A-4cc0-B98B-8BA1A1F3F95A}
1773 + {.Data = {0x9E, 0xB6, 0xA8, 0xCF, 0x4A, 0x5B, 0xc0, 0x4c, 0xB9, 0x8B, 0x8B, 0xA1, 0xA1, 0xF3, 0xF9, 0x5A}}, // Input
1774 + //{32412632-86cb-44a2-9b5c-50d1417354f5}
1775 + {.Data = {0x32, 0x26, 0x41, 0x32, 0xcb, 0x86, 0xa2, 0x44, 0x9b, 0x5c, 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5}}, // IDE
1776 +
1777 +};
1778 +
1779 +// Channel message dispatch table
1780 +VMBUS_CHANNEL_MESSAGE_TABLE_ENTRY gChannelMessageTable[ChannelMessageCount]= {
1781 + {ChannelMessageInvalid, NULL},
1782 + {ChannelMessageOfferChannel, VmbusChannelOnOffer},
1783 + {ChannelMessageRescindChannelOffer, VmbusChannelOnOfferRescind},
1784 + {ChannelMessageRequestOffers, NULL},
1785 + {ChannelMessageAllOffersDelivered, VmbusChannelOnOffersDelivered},
1786 + {ChannelMessageOpenChannel, NULL},
1787 + {ChannelMessageOpenChannelResult, VmbusChannelOnOpenResult},
1788 + {ChannelMessageCloseChannel, NULL},
1789 + {ChannelMessageGpadlHeader, NULL},
1790 + {ChannelMessageGpadlBody, NULL},
1791 + {ChannelMessageGpadlCreated, VmbusChannelOnGpadlCreated},
1792 + {ChannelMessageGpadlTeardown, NULL},
1793 + {ChannelMessageGpadlTorndown, VmbusChannelOnGpadlTorndown},
1794 + {ChannelMessageRelIdReleased, NULL},
1795 + {ChannelMessageInitiateContact, NULL},
1796 + {ChannelMessageVersionResponse, VmbusChannelOnVersionResponse},
1797 + {ChannelMessageUnload, NULL},
1798 +};
1799 +
1800 +/*++
1801 +
1802 +Name:
1803 + AllocVmbusChannel()
1804 +
1805 +Description:
1806 + Allocate and initialize a vmbus channel object
1807 +
1808 +--*/
1809 +VMBUS_CHANNEL* AllocVmbusChannel(void)
1810 +{
1811 + VMBUS_CHANNEL* channel;
1812 +
1813 + channel = (VMBUS_CHANNEL*) MemAllocAtomic(sizeof(VMBUS_CHANNEL));
1814 + if (!channel)
1815 + {
1816 + return NULL;
1817 + }
1818 +
1819 + memset(channel, 0,sizeof(VMBUS_CHANNEL));
1820 + channel->InboundLock = SpinlockCreate();
1821 + if (!channel->InboundLock)
1822 + {
1823 + MemFree(channel);
1824 + return NULL;
1825 + }
1826 +
1827 + channel->PollTimer = TimerCreate(VmbusChannelOnTimer, channel);
1828 + if (!channel->PollTimer)
1829 + {
1830 + SpinlockClose(channel->InboundLock);
1831 + MemFree(channel);
1832 + return NULL;
1833 + }
1834 +
1835 + //channel->dataWorkQueue = WorkQueueCreate("data");
1836 + channel->ControlWQ = WorkQueueCreate("control");
1837 + if (!channel->ControlWQ)
1838 + {
1839 + TimerClose(channel->PollTimer);
1840 + SpinlockClose(channel->InboundLock);
1841 + MemFree(channel);
1842 + return NULL;
1843 + }
1844 +
1845 + return channel;
1846 +}
1847 +
1848 +/*++
1849 +
1850 +Name:
1851 + ReleaseVmbusChannel()
1852 +
1853 +Description:
1854 + Release the vmbus channel object itself
1855 +
1856 +--*/
1857 +static inline void ReleaseVmbusChannel(void* Context)
1858 +{
1859 + VMBUS_CHANNEL* channel = (VMBUS_CHANNEL*)Context;
1860 +
1861 + DPRINT_ENTER(VMBUS);
1862 +
1863 + DPRINT_DBG(VMBUS, "releasing channel (%p)", channel);
1864 + WorkQueueClose(channel->ControlWQ);
1865 + DPRINT_DBG(VMBUS, "channel released (%p)", channel);
1866 +
1867 + MemFree(channel);
1868 +
1869 + DPRINT_EXIT(VMBUS);
1870 +}
1871 +
1872 +/*++
1873 +
1874 +Name:
1875 + FreeVmbusChannel()
1876 +
1877 +Description:
1878 + Release the resources used by the vmbus channel object
1879 +
1880 +--*/
1881 +void FreeVmbusChannel(VMBUS_CHANNEL* Channel)
1882 +{
1883 + SpinlockClose(Channel->InboundLock);
1884 + TimerClose(Channel->PollTimer);
1885 +
1886 + // We have to release the channel's workqueue/thread in the vmbus's workqueue/thread context
1887 + // ie we can't destroy ourselves.
1888 + WorkQueueQueueWorkItem(gVmbusConnection.WorkQueue, ReleaseVmbusChannel, (void*)Channel);
1889 +}
1890 +
1891 +
1892 +/*++
1893 +
1894 +Name:
1895 + VmbusChannelProcessOffer()
1896 +
1897 +Description:
1898 + Process the offer by creating a channel/device associated with this offer
1899 +
1900 +--*/
1901 +static void
1902 +VmbusChannelProcessOffer(
1903 + PVOID context
1904 + )
1905 +{
1906 + int ret=0;
1907 + VMBUS_CHANNEL* newChannel=(VMBUS_CHANNEL*)context;
1908 + LIST_ENTRY* anchor;
1909 + LIST_ENTRY* curr;
1910 + BOOL fNew=TRUE;
1911 + VMBUS_CHANNEL* channel;
1912 +
1913 + DPRINT_ENTER(VMBUS);
1914 +
1915 + // Make sure this is a new offer
1916 + SpinlockAcquire(gVmbusConnection.ChannelLock);
1917 +
1918 + ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelList)
1919 + {
1920 + channel = CONTAINING_RECORD(curr, VMBUS_CHANNEL, ListEntry);
1921 +
1922 + if (!memcmp(&channel->OfferMsg.Offer.InterfaceType, &newChannel->OfferMsg.Offer.InterfaceType,sizeof(GUID)) &&
1923 + !memcmp(&channel->OfferMsg.Offer.InterfaceInstance, &newChannel->OfferMsg.Offer.InterfaceInstance, sizeof(GUID)))
1924 + {
1925 + fNew = FALSE;
1926 + break;
1927 + }
1928 + }
1929 +
1930 + if (fNew)
1931 + {
1932 + INSERT_TAIL_LIST(&gVmbusConnection.ChannelList, &newChannel->ListEntry);
1933 + }
1934 + SpinlockRelease(gVmbusConnection.ChannelLock);
1935 +
1936 + if (!fNew)
1937 + {
1938 + DPRINT_DBG(VMBUS, "Ignoring duplicate offer for relid (%d)", newChannel->OfferMsg.ChildRelId);
1939 + FreeVmbusChannel(newChannel);
1940 + DPRINT_EXIT(VMBUS);
1941 + return;
1942 + }
1943 +
1944 + // Start the process of binding this offer to the driver
1945 + // We need to set the DeviceObject field before calling VmbusChildDeviceAdd()
1946 + newChannel->DeviceObject = VmbusChildDeviceCreate(
1947 + newChannel->OfferMsg.Offer.InterfaceType,
1948 + newChannel->OfferMsg.Offer.InterfaceInstance,
1949 + newChannel);
1950 +
1951 + DPRINT_DBG(VMBUS, "child device object allocated - %p", newChannel->DeviceObject);
1952 +
1953 + // Add the new device to the bus. This will kick off device-driver binding
1954 + // which eventually invokes the device driver's AddDevice() method.
1955 + ret = VmbusChildDeviceAdd(newChannel->DeviceObject);
1956 + if (ret != 0)
1957 + {
1958 + DPRINT_ERR(VMBUS, "unable to add child device object (relid %d)",
1959 + newChannel->OfferMsg.ChildRelId);
1960 +
1961 + SpinlockAcquire(gVmbusConnection.ChannelLock);
1962 + REMOVE_ENTRY_LIST(&newChannel->ListEntry);
1963 + SpinlockRelease(gVmbusConnection.ChannelLock);
1964 +
1965 + FreeVmbusChannel(newChannel);
1966 + }
1967 + else
1968 + {
1969 + // This state is used to indicate a successful open so that when we do close the channel normally,
1970 + // we can cleanup properly
1971 + newChannel->State = CHANNEL_OPEN_STATE;
1972 + }
1973 + DPRINT_EXIT(VMBUS);
1974 +}
1975 +
1976 +/*++
1977 +
1978 +Name:
1979 + VmbusChannelProcessRescindOffer()
1980 +
1981 +Description:
1982 + Rescind the offer by initiating a device removal
1983 +
1984 +--*/
1985 +static void
1986 +VmbusChannelProcessRescindOffer(
1987 + PVOID context
1988 + )
1989 +{
1990 + VMBUS_CHANNEL* channel=(VMBUS_CHANNEL*)context;
1991 +
1992 + DPRINT_ENTER(VMBUS);
1993 +
1994 + VmbusChildDeviceRemove(channel->DeviceObject);
1995 +
1996 + DPRINT_EXIT(VMBUS);
1997 +}
1998 +
1999 +
2000 +/*++
2001 +
2002 +Name:
2003 + VmbusChannelOnOffer()
2004 +
2005 +Description:
2006 + Handler for channel offers from vmbus in parent partition. We ignore all offers except
2007 + network and storage offers. For each network and storage offers, we create a channel object
2008 + and queue a work item to the channel object to process the offer synchronously
2009 +
2010 +--*/
2011 +static void
2012 +VmbusChannelOnOffer(
2013 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
2014 + )
2015 +{
2016 + VMBUS_CHANNEL_OFFER_CHANNEL* offer = (VMBUS_CHANNEL_OFFER_CHANNEL*)hdr;
2017 + VMBUS_CHANNEL* newChannel;
2018 +
2019 + GUID *guidType;
2020 + GUID *guidInstance;
2021 + int i;
2022 + int fSupported=0;
2023 +
2024 + DPRINT_ENTER(VMBUS);
2025 +
2026 + for (i=0; i<MAX_NUM_DEVICE_CLASSES_SUPPORTED; i++)
2027 + {
2028 + if (memcmp(&offer->Offer.InterfaceType, &gSupportedDeviceClasses[i], sizeof(GUID)) == 0)
2029 + {
2030 + fSupported = 1;
2031 + break;
2032 + }
2033 + }
2034 +
2035 + if (!fSupported)
2036 + {
2037 + DPRINT_DBG(VMBUS, "Ignoring channel offer notification for child relid %d", offer->ChildRelId);
2038 + DPRINT_EXIT(VMBUS);
2039 +
2040 + return;
2041 + }
2042 +
2043 + guidType = &offer->Offer.InterfaceType;
2044 + guidInstance = &offer->Offer.InterfaceInstance;
2045 +
2046 + DPRINT_INFO(VMBUS, "Channel offer notification - child relid %d monitor id %d allocated %d, "
2047 + "type {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x} "
2048 + "instance {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
2049 + offer->ChildRelId,
2050 + offer->MonitorId,
2051 + offer->MonitorAllocated,
2052 + 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],
2053 + 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]);
2054 +
2055 + // Allocate the channel object and save this offer.
2056 + newChannel = AllocVmbusChannel();
2057 + if (!newChannel)
2058 + {
2059 + DPRINT_ERR(VMBUS, "unable to allocate channel object");
2060 + return;
2061 + }
2062 +
2063 + DPRINT_DBG(VMBUS, "channel object allocated - %p", newChannel);
2064 +
2065 + memcpy(&newChannel->OfferMsg, offer, sizeof(VMBUS_CHANNEL_OFFER_CHANNEL));
2066 + newChannel->MonitorGroup = (UINT8)offer->MonitorId / 32;
2067 + newChannel->MonitorBit = (UINT8)offer->MonitorId % 32;
2068 +
2069 + // TODO: Make sure the offer comes from our parent partition
2070 + WorkQueueQueueWorkItem(newChannel->ControlWQ, VmbusChannelProcessOffer, newChannel);
2071 +
2072 + DPRINT_EXIT(VMBUS);
2073 +}
2074 +
2075 +
2076 +/*++
2077 +
2078 +Name:
2079 + VmbusChannelOnOfferRescind()
2080 +
2081 +Description:
2082 + Rescind offer handler. We queue a work item to process this offer
2083 + synchronously
2084 +
2085 +--*/
2086 +static void
2087 +VmbusChannelOnOfferRescind(
2088 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
2089 + )
2090 +{
2091 + VMBUS_CHANNEL_RESCIND_OFFER* rescind = (VMBUS_CHANNEL_RESCIND_OFFER*)hdr;
2092 + VMBUS_CHANNEL* channel;
2093 +
2094 + DPRINT_ENTER(VMBUS);
2095 +
2096 + channel = GetChannelFromRelId(rescind->ChildRelId);
2097 + if (channel == NULL)
2098 + {
2099 + DPRINT_DBG(VMBUS, "channel not found for relId %d", rescind->ChildRelId);
2100 + return;
2101 + }
2102 +
2103 + WorkQueueQueueWorkItem(channel->ControlWQ, VmbusChannelProcessRescindOffer, channel);
2104 +
2105 + DPRINT_EXIT(VMBUS);
2106 +}
2107 +
2108 +
2109 +/*++
2110 +
2111 +Name:
2112 + VmbusChannelOnOffersDelivered()
2113 +
2114 +Description:
2115 + This is invoked when all offers have been delivered.
2116 + Nothing to do here.
2117 +
2118 +--*/
2119 +static void
2120 +VmbusChannelOnOffersDelivered(
2121 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
2122 + )
2123 +{
2124 + DPRINT_ENTER(VMBUS);
2125 + DPRINT_EXIT(VMBUS);
2126 +}
2127 +
2128 +
2129 +/*++
2130 +
2131 +Name:
2132 + VmbusChannelOnOpenResult()
2133 +
2134 +Description:
2135 + Open result handler. This is invoked when we received a response
2136 + to our channel open request. Find the matching request, copy the
2137 + response and signal the requesting thread.
2138 +
2139 +--*/
2140 +static void
2141 +VmbusChannelOnOpenResult(
2142 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
2143 + )
2144 +{
2145 + VMBUS_CHANNEL_OPEN_RESULT* result = (VMBUS_CHANNEL_OPEN_RESULT*)hdr;
2146 + LIST_ENTRY* anchor;
2147 + LIST_ENTRY* curr;
2148 + VMBUS_CHANNEL_MSGINFO* msgInfo;
2149 + VMBUS_CHANNEL_MESSAGE_HEADER* requestHeader;
2150 + VMBUS_CHANNEL_OPEN_CHANNEL* openMsg;
2151 +
2152 + DPRINT_ENTER(VMBUS);
2153 +
2154 + DPRINT_DBG(VMBUS, "vmbus open result - %d", result->Status);
2155 +
2156 + // Find the open msg, copy the result and signal/unblock the wait event
2157 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
2158 +
2159 + ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelMsgList)
2160 + {
2161 + msgInfo = (VMBUS_CHANNEL_MSGINFO*) curr;
2162 + requestHeader = (VMBUS_CHANNEL_MESSAGE_HEADER*)msgInfo->Msg;
2163 +
2164 + if (requestHeader->MessageType == ChannelMessageOpenChannel)
2165 + {
2166 + openMsg = (VMBUS_CHANNEL_OPEN_CHANNEL*)msgInfo->Msg;
2167 + if (openMsg->ChildRelId == result->ChildRelId &&
2168 + openMsg->OpenId == result->OpenId)
2169 + {
2170 + memcpy(&msgInfo->Response.OpenResult, result, sizeof(VMBUS_CHANNEL_OPEN_RESULT));
2171 + WaitEventSet(msgInfo->WaitEvent);
2172 + break;
2173 + }
2174 + }
2175 + }
2176 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
2177 +
2178 + DPRINT_EXIT(VMBUS);
2179 +}
2180 +
2181 +
2182 +/*++
2183 +
2184 +Name:
2185 + VmbusChannelOnGpadlCreated()
2186 +
2187 +Description:
2188 + GPADL created handler. This is invoked when we received a response
2189 + to our gpadl create request. Find the matching request, copy the
2190 + response and signal the requesting thread.
2191 +
2192 +--*/
2193 +static void
2194 +VmbusChannelOnGpadlCreated(
2195 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
2196 + )
2197 +{
2198 + VMBUS_CHANNEL_GPADL_CREATED *gpadlCreated = (VMBUS_CHANNEL_GPADL_CREATED*)hdr;
2199 + LIST_ENTRY *anchor;
2200 + LIST_ENTRY *curr;
2201 + VMBUS_CHANNEL_MSGINFO *msgInfo;
2202 + VMBUS_CHANNEL_MESSAGE_HEADER *requestHeader;
2203 + VMBUS_CHANNEL_GPADL_HEADER *gpadlHeader;
2204 +
2205 + DPRINT_ENTER(VMBUS);
2206 +
2207 + DPRINT_DBG(VMBUS, "vmbus gpadl created result - %d", gpadlCreated->CreationStatus);
2208 +
2209 + // Find the establish msg, copy the result and signal/unblock the wait event
2210 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
2211 +
2212 + ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelMsgList)
2213 + {
2214 + msgInfo = (VMBUS_CHANNEL_MSGINFO*) curr;
2215 + requestHeader = (VMBUS_CHANNEL_MESSAGE_HEADER*)msgInfo->Msg;
2216 +
2217 + if (requestHeader->MessageType == ChannelMessageGpadlHeader)
2218 + {
2219 + gpadlHeader = (VMBUS_CHANNEL_GPADL_HEADER*)requestHeader;
2220 +
2221 + if ((gpadlCreated->ChildRelId == gpadlHeader->ChildRelId) &&
2222 + (gpadlCreated->Gpadl == gpadlHeader->Gpadl))
2223 + {
2224 + memcpy(&msgInfo->Response.GpadlCreated, gpadlCreated, sizeof(VMBUS_CHANNEL_GPADL_CREATED));
2225 + WaitEventSet(msgInfo->WaitEvent);
2226 + break;
2227 + }
2228 + }
2229 + }
2230 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
2231 +
2232 + DPRINT_EXIT(VMBUS);
2233 +}
2234 +
2235 +
2236 +/*++
2237 +
2238 +Name:
2239 + VmbusChannelOnGpadlTorndown()
2240 +
2241 +Description:
2242 + GPADL torndown handler. This is invoked when we received a response
2243 + to our gpadl teardown request. Find the matching request, copy the
2244 + response and signal the requesting thread.
2245 +
2246 +--*/
2247 +static void
2248 +VmbusChannelOnGpadlTorndown(
2249 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
2250 + )
2251 +{
2252 + VMBUS_CHANNEL_GPADL_TORNDOWN* gpadlTorndown = (VMBUS_CHANNEL_GPADL_TORNDOWN*)hdr;
2253 + LIST_ENTRY* anchor;
2254 + LIST_ENTRY* curr;
2255 + VMBUS_CHANNEL_MSGINFO* msgInfo;
2256 + VMBUS_CHANNEL_MESSAGE_HEADER *requestHeader;
2257 + VMBUS_CHANNEL_GPADL_TEARDOWN *gpadlTeardown;
2258 +
2259 + DPRINT_ENTER(VMBUS);
2260 +
2261 + // Find the open msg, copy the result and signal/unblock the wait event
2262 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
2263 +
2264 + ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelMsgList)
2265 + {
2266 + msgInfo = (VMBUS_CHANNEL_MSGINFO*) curr;
2267 + requestHeader = (VMBUS_CHANNEL_MESSAGE_HEADER*)msgInfo->Msg;
2268 +
2269 + if (requestHeader->MessageType == ChannelMessageGpadlTeardown)
2270 + {
2271 + gpadlTeardown = (VMBUS_CHANNEL_GPADL_TEARDOWN*)requestHeader;
2272 +
2273 + if (gpadlTorndown->Gpadl == gpadlTeardown->Gpadl)
2274 + {
2275 + memcpy(&msgInfo->Response.GpadlTorndown, gpadlTorndown, sizeof(VMBUS_CHANNEL_GPADL_TORNDOWN));
2276 + WaitEventSet(msgInfo->WaitEvent);
2277 + break;
2278 + }
2279 + }
2280 + }
2281 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
2282 +
2283 + DPRINT_EXIT(VMBUS);
2284 +}
2285 +
2286 +
2287 +/*++
2288 +
2289 +Name:
2290 + VmbusChannelOnVersionResponse()
2291 +
2292 +Description:
2293 + Version response handler. This is invoked when we received a response
2294 + to our initiate contact request. Find the matching request, copy the
2295 + response and signal the requesting thread.
2296 +
2297 +--*/
2298 +static void
2299 +VmbusChannelOnVersionResponse(
2300 + PVMBUS_CHANNEL_MESSAGE_HEADER hdr
2301 + )
2302 +{
2303 + LIST_ENTRY* anchor;
2304 + LIST_ENTRY* curr;
2305 + VMBUS_CHANNEL_MSGINFO *msgInfo;
2306 + VMBUS_CHANNEL_MESSAGE_HEADER *requestHeader;
2307 + VMBUS_CHANNEL_INITIATE_CONTACT *initiate;
2308 + VMBUS_CHANNEL_VERSION_RESPONSE *versionResponse = (VMBUS_CHANNEL_VERSION_RESPONSE*)hdr;
2309 +
2310 + DPRINT_ENTER(VMBUS);
2311 +
2312 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
2313 +
2314 + ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelMsgList)
2315 + {
2316 + msgInfo = (VMBUS_CHANNEL_MSGINFO*) curr;
2317 + requestHeader = (VMBUS_CHANNEL_MESSAGE_HEADER*)msgInfo->Msg;
2318 +
2319 + if (requestHeader->MessageType == ChannelMessageInitiateContact)
2320 + {
2321 + initiate = (VMBUS_CHANNEL_INITIATE_CONTACT*)requestHeader;
2322 + memcpy(&msgInfo->Response.VersionResponse, versionResponse, sizeof(VMBUS_CHANNEL_VERSION_RESPONSE));
2323 + WaitEventSet(msgInfo->WaitEvent);
2324 + }
2325 + }
2326 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
2327 +
2328 + DPRINT_EXIT(VMBUS);
2329 +}
2330 +
2331 +
2332 +/*++
2333 +
2334 +Name:
2335 + VmbusOnChannelMessage()
2336 +
2337 +Description:
2338 + Handler for channel protocol messages.
2339 + This is invoked in the vmbus worker thread context.
2340 +
2341 +--*/
2342 +VOID
2343 +VmbusOnChannelMessage(
2344 + void *Context
2345 + )
2346 +{
2347 + HV_MESSAGE *msg=(HV_MESSAGE*)Context;
2348 + VMBUS_CHANNEL_MESSAGE_HEADER* hdr;
2349 + int size;
2350 +
2351 + DPRINT_ENTER(VMBUS);
2352 +
2353 + hdr = (VMBUS_CHANNEL_MESSAGE_HEADER*)msg->u.Payload;
2354 + size=msg->Header.PayloadSize;
2355 +
2356 + DPRINT_DBG(VMBUS, "message type %d size %d", hdr->MessageType, size);
2357 +
2358 + if (hdr->MessageType >= ChannelMessageCount)
2359 + {
2360 + DPRINT_ERR(VMBUS, "Received invalid channel message type %d size %d", hdr->MessageType, size);
2361 + PrintBytes((unsigned char *)msg->u.Payload, size);
2362 + MemFree(msg);
2363 + return;
2364 + }
2365 +
2366 + if (gChannelMessageTable[hdr->MessageType].messageHandler)
2367 + {
2368 + gChannelMessageTable[hdr->MessageType].messageHandler(hdr);
2369 + }
2370 + else
2371 + {
2372 + DPRINT_ERR(VMBUS, "Unhandled channel message type %d", hdr->MessageType);
2373 + }
2374 +
2375 + // Free the msg that was allocated in VmbusOnMsgDPC()
2376 + MemFree(msg);
2377 + DPRINT_EXIT(VMBUS);
2378 +}
2379 +
2380 +
2381 +/*++
2382 +
2383 +Name:
2384 + VmbusChannelRequestOffers()
2385 +
2386 +Description:
2387 + Send a request to get all our pending offers.
2388 +
2389 +--*/
2390 +int
2391 +VmbusChannelRequestOffers(
2392 + VOID
2393 + )
2394 +{
2395 + int ret=0;
2396 + VMBUS_CHANNEL_MESSAGE_HEADER* msg;
2397 + VMBUS_CHANNEL_MSGINFO* msgInfo;
2398 +
2399 + DPRINT_ENTER(VMBUS);
2400 +
2401 + msgInfo =
2402 + (VMBUS_CHANNEL_MSGINFO*)MemAlloc(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_MESSAGE_HEADER));
2403 + ASSERT(msgInfo != NULL);
2404 +
2405 + msgInfo->WaitEvent = WaitEventCreate();
2406 + msg = (VMBUS_CHANNEL_MESSAGE_HEADER*)msgInfo->Msg;
2407 +
2408 + msg->MessageType = ChannelMessageRequestOffers;
2409 +
2410 + /*SpinlockAcquire(gVmbusConnection.channelMsgLock);
2411 + INSERT_TAIL_LIST(&gVmbusConnection.channelMsgList, &msgInfo->msgListEntry);
2412 + SpinlockRelease(gVmbusConnection.channelMsgLock);*/
2413 +
2414 + ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_MESSAGE_HEADER));
2415 + if (ret != 0)
2416 + {
2417 + DPRINT_ERR(VMBUS, "Unable to request offers - %d", ret);
2418 +
2419 + /*SpinlockAcquire(gVmbusConnection.channelMsgLock);
2420 + REMOVE_ENTRY_LIST(&msgInfo->msgListEntry);
2421 + SpinlockRelease(gVmbusConnection.channelMsgLock);*/
2422 +
2423 + goto Cleanup;
2424 + }
2425 + //WaitEventWait(msgInfo->waitEvent);
2426 +
2427 + /*SpinlockAcquire(gVmbusConnection.channelMsgLock);
2428 + REMOVE_ENTRY_LIST(&msgInfo->msgListEntry);
2429 + SpinlockRelease(gVmbusConnection.channelMsgLock);*/
2430 +
2431 +
2432 +Cleanup:
2433 + if (msgInfo)
2434 + {
2435 + WaitEventClose(msgInfo->WaitEvent);
2436 + MemFree(msgInfo);
2437 + }
2438 +
2439 + DPRINT_EXIT(VMBUS);
2440 +
2441 + return ret;
2442 +}
2443 +
2444 +/*++
2445 +
2446 +Name:
2447 + VmbusChannelReleaseUnattachedChannels()
2448 +
2449 +Description:
2450 + Release channels that are unattached/unconnected ie (no drivers associated)
2451 +
2452 +--*/
2453 +void
2454 +VmbusChannelReleaseUnattachedChannels(
2455 + VOID
2456 + )
2457 +{
2458 + LIST_ENTRY *entry;
2459 + VMBUS_CHANNEL *channel;
2460 + VMBUS_CHANNEL *start=NULL;
2461 +
2462 + SpinlockAcquire(gVmbusConnection.ChannelLock);
2463 +
2464 + while (!IsListEmpty(&gVmbusConnection.ChannelList))
2465 + {
2466 + entry = TOP_LIST_ENTRY(&gVmbusConnection.ChannelList);
2467 + channel = CONTAINING_RECORD(entry, VMBUS_CHANNEL, ListEntry);
2468 +
2469 + if (channel == start)
2470 + break;
2471 +
2472 + if (!channel->DeviceObject->Driver)
2473 + {
2474 + REMOVE_ENTRY_LIST(&channel->ListEntry);
2475 + DPRINT_INFO(VMBUS, "Releasing unattached device object %p", channel->DeviceObject);
2476 +
2477 + VmbusChildDeviceRemove(channel->DeviceObject);
2478 + FreeVmbusChannel(channel);
2479 + }
2480 + else
2481 + {
2482 + if (!start)
2483 + {
2484 + start = channel;
2485 + }
2486 + }
2487 + }
2488 +
2489 + SpinlockRelease(gVmbusConnection.ChannelLock);
2490 +}
2491 +
2492 +// eof
2493 +
2494 --- /dev/null
2495 +++ b/drivers/staging/hv/ChannelMgmt.h
2496 @@ -0,0 +1,156 @@
2497 +/*
2498 + *
2499 + * Copyright (c) 2009, Microsoft Corporation.
2500 + *
2501 + * This program is free software; you can redistribute it and/or modify it
2502 + * under the terms and conditions of the GNU General Public License,
2503 + * version 2, as published by the Free Software Foundation.
2504 + *
2505 + * This program is distributed in the hope it will be useful, but WITHOUT
2506 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
2507 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
2508 + * more details.
2509 + *
2510 + * You should have received a copy of the GNU General Public License along with
2511 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
2512 + * Place - Suite 330, Boston, MA 02111-1307 USA.
2513 + *
2514 + * Authors:
2515 + * Haiyang Zhang <haiyangz@microsoft.com>
2516 + * Hank Janssen <hjanssen@microsoft.com>
2517 + *
2518 + */
2519 +
2520 +
2521 +#ifndef _CHANNEL_MGMT_H_
2522 +#define _CHANNEL_MGMT_H_
2523 +
2524 +#include "osd.h"
2525 +#include "List.h"
2526 +#include "RingBuffer.h"
2527 +
2528 +#include "VmbusChannelInterface.h"
2529 +#include "ChannelMessages.h"
2530 +
2531 +
2532 +
2533 +typedef void (*PFN_CHANNEL_CALLBACK)(PVOID context);
2534 +
2535 +typedef enum {
2536 + CHANNEL_OFFER_STATE,
2537 + CHANNEL_OPENING_STATE,
2538 + CHANNEL_OPEN_STATE,
2539 +} VMBUS_CHANNEL_STATE;
2540 +
2541 +typedef struct _VMBUS_CHANNEL {
2542 + LIST_ENTRY ListEntry;
2543 +
2544 + DEVICE_OBJECT* DeviceObject;
2545 +
2546 + HANDLE PollTimer; // SA-111 workaround
2547 +
2548 + VMBUS_CHANNEL_STATE State;
2549 +
2550 + VMBUS_CHANNEL_OFFER_CHANNEL OfferMsg;
2551 + // These are based on the OfferMsg.MonitorId. Save it here for easy access.
2552 + UINT8 MonitorGroup;
2553 + UINT8 MonitorBit;
2554 +
2555 + UINT32 RingBufferGpadlHandle;
2556 +
2557 + // Allocated memory for ring buffer
2558 + VOID* RingBufferPages;
2559 + UINT32 RingBufferPageCount;
2560 + RING_BUFFER_INFO Outbound; // send to parent
2561 + RING_BUFFER_INFO Inbound; // receive from parent
2562 + HANDLE InboundLock;
2563 + HANDLE ControlWQ;
2564 +
2565 + // Channel callback are invoked in this workqueue context
2566 + //HANDLE dataWorkQueue;
2567 +
2568 + PFN_CHANNEL_CALLBACK OnChannelCallback;
2569 + PVOID ChannelCallbackContext;
2570 +
2571 +} VMBUS_CHANNEL;
2572 +
2573 +
2574 +typedef struct _VMBUS_CHANNEL_DEBUG_INFO {
2575 + UINT32 RelId;
2576 + VMBUS_CHANNEL_STATE State;
2577 + GUID InterfaceType;
2578 + GUID InterfaceInstance;
2579 + UINT32 MonitorId;
2580 + UINT32 ServerMonitorPending;
2581 + UINT32 ServerMonitorLatency;
2582 + UINT32 ServerMonitorConnectionId;
2583 + UINT32 ClientMonitorPending;
2584 + UINT32 ClientMonitorLatency;
2585 + UINT32 ClientMonitorConnectionId;
2586 +
2587 + RING_BUFFER_DEBUG_INFO Inbound;
2588 + RING_BUFFER_DEBUG_INFO Outbound;
2589 +} VMBUS_CHANNEL_DEBUG_INFO;
2590 +
2591 +
2592 +typedef union {
2593 + VMBUS_CHANNEL_VERSION_SUPPORTED VersionSupported;
2594 + VMBUS_CHANNEL_OPEN_RESULT OpenResult;
2595 + VMBUS_CHANNEL_GPADL_TORNDOWN GpadlTorndown;
2596 + VMBUS_CHANNEL_GPADL_CREATED GpadlCreated;
2597 + VMBUS_CHANNEL_VERSION_RESPONSE VersionResponse;
2598 +} VMBUS_CHANNEL_MESSAGE_RESPONSE;
2599 +
2600 +
2601 +// Represents each channel msg on the vmbus connection
2602 +// This is a variable-size data structure depending on
2603 +// the msg type itself
2604 +typedef struct _VMBUS_CHANNEL_MSGINFO {
2605 + // Bookkeeping stuff
2606 + LIST_ENTRY MsgListEntry;
2607 +
2608 + // So far, this is only used to handle gpadl body message
2609 + LIST_ENTRY SubMsgList;
2610 +
2611 + // Synchronize the request/response if needed
2612 + HANDLE WaitEvent;
2613 +
2614 + VMBUS_CHANNEL_MESSAGE_RESPONSE Response;
2615 +
2616 + UINT32 MessageSize;
2617 + // The channel message that goes out on the "wire".
2618 + // It will contain at minimum the VMBUS_CHANNEL_MESSAGE_HEADER header
2619 + unsigned char Msg[0];
2620 +} VMBUS_CHANNEL_MSGINFO;
2621 +
2622 +
2623 +//
2624 +// Routines
2625 +//
2626 +
2627 +INTERNAL VMBUS_CHANNEL*
2628 +AllocVmbusChannel(
2629 + void
2630 + );
2631 +
2632 +INTERNAL void
2633 +FreeVmbusChannel(
2634 + VMBUS_CHANNEL *Channel
2635 + );
2636 +
2637 +INTERNAL void
2638 +VmbusOnChannelMessage(
2639 + void *Context
2640 + );
2641 +
2642 +INTERNAL int
2643 +VmbusChannelRequestOffers(
2644 + void
2645 + );
2646 +
2647 +INTERNAL void
2648 +VmbusChannelReleaseUnattachedChannels(
2649 + void
2650 + );
2651 +
2652 +#endif //_CHANNEL_MGMT_H_
2653 --- /dev/null
2654 +++ b/drivers/staging/hv/Connection.c
2655 @@ -0,0 +1,432 @@
2656 +/*
2657 + *
2658 + * Copyright (c) 2009, Microsoft Corporation.
2659 + *
2660 + * This program is free software; you can redistribute it and/or modify it
2661 + * under the terms and conditions of the GNU General Public License,
2662 + * version 2, as published by the Free Software Foundation.
2663 + *
2664 + * This program is distributed in the hope it will be useful, but WITHOUT
2665 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
2666 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
2667 + * more details.
2668 + *
2669 + * You should have received a copy of the GNU General Public License along with
2670 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
2671 + * Place - Suite 330, Boston, MA 02111-1307 USA.
2672 + *
2673 + * Authors:
2674 + * Haiyang Zhang <haiyangz@microsoft.com>
2675 + * Hank Janssen <hjanssen@microsoft.com>
2676 + *
2677 + */
2678 +
2679 +
2680 +#include "logging.h"
2681 +
2682 +#include "VmbusPrivate.h"
2683 +
2684 +//
2685 +// Globals
2686 +//
2687 +
2688 +
2689 +VMBUS_CONNECTION gVmbusConnection = {
2690 + .ConnectState = Disconnected,
2691 + .NextGpadlHandle = 0xE1E10,
2692 +};
2693 +
2694 +
2695 +/*++
2696 +
2697 +Name:
2698 + VmbusConnect()
2699 +
2700 +Description:
2701 + Sends a connect request on the partition service connection
2702 +
2703 +--*/
2704 +int
2705 +VmbusConnect(
2706 + )
2707 +{
2708 + int ret=0;
2709 + VMBUS_CHANNEL_MSGINFO *msgInfo=NULL;
2710 + VMBUS_CHANNEL_INITIATE_CONTACT *msg;
2711 +
2712 + DPRINT_ENTER(VMBUS);
2713 +
2714 + // Make sure we are not connecting or connected
2715 + if (gVmbusConnection.ConnectState != Disconnected)
2716 + return -1;
2717 +
2718 + // Initialize the vmbus connection
2719 + gVmbusConnection.ConnectState = Connecting;
2720 + gVmbusConnection.WorkQueue = WorkQueueCreate("vmbusQ");
2721 +
2722 + INITIALIZE_LIST_HEAD(&gVmbusConnection.ChannelMsgList);
2723 + gVmbusConnection.ChannelMsgLock = SpinlockCreate();
2724 +
2725 + INITIALIZE_LIST_HEAD(&gVmbusConnection.ChannelList);
2726 + gVmbusConnection.ChannelLock = SpinlockCreate();
2727 +
2728 + // Setup the vmbus event connection for channel interrupt abstraction stuff
2729 + gVmbusConnection.InterruptPage = PageAlloc(1);
2730 + if (gVmbusConnection.InterruptPage == NULL)
2731 + {
2732 + ret = -1;
2733 + goto Cleanup;
2734 + }
2735 +
2736 + gVmbusConnection.RecvInterruptPage = gVmbusConnection.InterruptPage;
2737 + gVmbusConnection.SendInterruptPage = (void*)((ULONG_PTR)gVmbusConnection.InterruptPage + (PAGE_SIZE >> 1));
2738 +
2739 + // Setup the monitor notification facility. The 1st page for parent->child and the 2nd page for child->parent
2740 + gVmbusConnection.MonitorPages = PageAlloc(2);
2741 + if (gVmbusConnection.MonitorPages == NULL)
2742 + {
2743 + ret = -1;
2744 + goto Cleanup;
2745 + }
2746 +
2747 + msgInfo = (VMBUS_CHANNEL_MSGINFO*)MemAllocZeroed(sizeof(VMBUS_CHANNEL_MSGINFO) + sizeof(VMBUS_CHANNEL_INITIATE_CONTACT));
2748 + if (msgInfo == NULL)
2749 + {
2750 + ret = -1;
2751 + goto Cleanup;
2752 + }
2753 +
2754 + msgInfo->WaitEvent = WaitEventCreate();
2755 + msg = (VMBUS_CHANNEL_INITIATE_CONTACT*)msgInfo->Msg;
2756 +
2757 + msg->Header.MessageType = ChannelMessageInitiateContact;
2758 + msg->VMBusVersionRequested = VMBUS_REVISION_NUMBER;
2759 + msg->InterruptPage = GetPhysicalAddress(gVmbusConnection.InterruptPage);
2760 + msg->MonitorPage1 = GetPhysicalAddress(gVmbusConnection.MonitorPages);
2761 + msg->MonitorPage2 = GetPhysicalAddress((PVOID)((ULONG_PTR)gVmbusConnection.MonitorPages + PAGE_SIZE));
2762 +
2763 + // Add to list before we send the request since we may receive the response
2764 + // before returning from this routine
2765 + SpinlockAcquire(gVmbusConnection.ChannelMsgLock);
2766 + INSERT_TAIL_LIST(&gVmbusConnection.ChannelMsgList, &msgInfo->MsgListEntry);
2767 + SpinlockRelease(gVmbusConnection.ChannelMsgLock);
2768 +
2769 + DPRINT_DBG(VMBUS, "Vmbus connection - interrupt pfn %llx, monitor1 pfn %llx,, monitor2 pfn %llx",
2770 + msg->InterruptPage, msg->MonitorPage1, msg->MonitorPage2);
2771 +
2772 + DPRINT_DBG(VMBUS, "Sending channel initiate msg...");
2773 +
2774 + ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_INITIATE_CONTACT));
2775 + if (ret != 0)
2776 + {
2777 + REMOVE_ENTRY_LIST(&msgInfo->MsgListEntry);
2778 + goto Cleanup;
2779 + }
2780 +
2781 + // Wait for the connection response
2782 + WaitEventWait(msgInfo->WaitEvent);
2783 +
2784 + REMOVE_ENTRY_LIST(&msgInfo->MsgListEntry);
2785 +
2786 + // Check if successful
2787 + if (msgInfo->Response.VersionResponse.VersionSupported)
2788 + {
2789 + DPRINT_INFO(VMBUS, "Vmbus connected!!");
2790 + gVmbusConnection.ConnectState = Connected;
2791 +
2792 + }
2793 + else
2794 + {
2795 + DPRINT_ERR(VMBUS, "Vmbus connection failed!!...current version (%d) not supported", VMBUS_REVISION_NUMBER);
2796 + ret = -1;
2797 +
2798 + goto Cleanup;
2799 + }
2800 +
2801 +
2802 + WaitEventClose(msgInfo->WaitEvent);
2803 + MemFree(msgInfo);
2804 + DPRINT_EXIT(VMBUS);
2805 +
2806 + return 0;
2807 +
2808 +Cleanup:
2809 +
2810 + gVmbusConnection.ConnectState = Disconnected;
2811 +
2812 + WorkQueueClose(gVmbusConnection.WorkQueue);
2813 + SpinlockClose(gVmbusConnection.ChannelLock);
2814 + SpinlockClose(gVmbusConnection.ChannelMsgLock);
2815 +
2816 + if (gVmbusConnection.InterruptPage)
2817 + {
2818 + PageFree(gVmbusConnection.InterruptPage, 1);
2819 + gVmbusConnection.InterruptPage = NULL;
2820 + }
2821 +
2822 + if (gVmbusConnection.MonitorPages)
2823 + {
2824 + PageFree(gVmbusConnection.MonitorPages, 2);
2825 + gVmbusConnection.MonitorPages = NULL;
2826 + }
2827 +
2828 + if (msgInfo)
2829 + {
2830 + if (msgInfo->WaitEvent)
2831 + WaitEventClose(msgInfo->WaitEvent);
2832 +
2833 + MemFree(msgInfo);
2834 + }
2835 +
2836 + DPRINT_EXIT(VMBUS);
2837 +
2838 + return ret;
2839 +}
2840 +
2841 +
2842 +/*++
2843 +
2844 +Name:
2845 + VmbusDisconnect()
2846 +
2847 +Description:
2848 + Sends a disconnect request on the partition service connection
2849 +
2850 +--*/
2851 +int
2852 +VmbusDisconnect(
2853 + VOID
2854 + )
2855 +{
2856 + int ret=0;
2857 + VMBUS_CHANNEL_UNLOAD *msg;
2858 +
2859 + DPRINT_ENTER(VMBUS);
2860 +
2861 + // Make sure we are connected
2862 + if (gVmbusConnection.ConnectState != Connected)
2863 + return -1;
2864 +
2865 + msg = MemAllocZeroed(sizeof(VMBUS_CHANNEL_UNLOAD));
2866 +
2867 + msg->MessageType = ChannelMessageUnload;
2868 +
2869 + ret = VmbusPostMessage(msg, sizeof(VMBUS_CHANNEL_UNLOAD));
2870 +
2871 + if (ret != 0)
2872 + {
2873 + goto Cleanup;
2874 + }
2875 +
2876 + PageFree(gVmbusConnection.InterruptPage, 1);
2877 +
2878 + // TODO: iterate thru the msg list and free up
2879 +
2880 + SpinlockClose(gVmbusConnection.ChannelMsgLock);
2881 +
2882 + WorkQueueClose(gVmbusConnection.WorkQueue);
2883 +
2884 + gVmbusConnection.ConnectState = Disconnected;
2885 +
2886 + DPRINT_INFO(VMBUS, "Vmbus disconnected!!");
2887 +
2888 +Cleanup:
2889 + if (msg)
2890 + {
2891 + MemFree(msg);
2892 + }
2893 +
2894 + DPRINT_EXIT(VMBUS);
2895 +
2896 + return ret;
2897 +}
2898 +
2899 +
2900 +/*++
2901 +
2902 +Name:
2903 + GetChannelFromRelId()
2904 +
2905 +Description:
2906 + Get the channel object given its child relative id (ie channel id)
2907 +
2908 +--*/
2909 +VMBUS_CHANNEL*
2910 +GetChannelFromRelId(
2911 + UINT32 relId
2912 + )
2913 +{
2914 + VMBUS_CHANNEL* channel;
2915 + VMBUS_CHANNEL* foundChannel=NULL;
2916 + LIST_ENTRY* anchor;
2917 + LIST_ENTRY* curr;
2918 +
2919 + SpinlockAcquire(gVmbusConnection.ChannelLock);
2920 + ITERATE_LIST_ENTRIES(anchor, curr, &gVmbusConnection.ChannelList)
2921 + {
2922 + channel = CONTAINING_RECORD(curr, VMBUS_CHANNEL, ListEntry);
2923 +
2924 + if (channel->OfferMsg.ChildRelId == relId)
2925 + {
2926 + foundChannel = channel;
2927 + break;
2928 + }
2929 + }
2930 + SpinlockRelease(gVmbusConnection.ChannelLock);
2931 +
2932 + return foundChannel;
2933 +}
2934 +
2935 +
2936 +
2937 +/*++
2938 +
2939 +Name:
2940 + VmbusProcessChannelEvent()
2941 +
2942 +Description:
2943 + Process a channel event notification
2944 +
2945 +--*/
2946 +static void
2947 +VmbusProcessChannelEvent(
2948 + PVOID context
2949 + )
2950 +{
2951 + VMBUS_CHANNEL* channel;
2952 + UINT32 relId = (UINT32)(ULONG_PTR)context;
2953 +
2954 + ASSERT(relId > 0);
2955 +
2956 + // Find the channel based on this relid and invokes
2957 + // the channel callback to process the event
2958 + channel = GetChannelFromRelId(relId);
2959 +
2960 + if (channel)
2961 + {
2962 + VmbusChannelOnChannelEvent(channel);
2963 + //WorkQueueQueueWorkItem(channel->dataWorkQueue, VmbusChannelOnChannelEvent, (void*)channel);
2964 + }
2965 + else
2966 + {
2967 + DPRINT_ERR(VMBUS, "channel not found for relid - %d.", relId);
2968 + }
2969 +}
2970 +
2971 +
2972 +/*++
2973 +
2974 +Name:
2975 + VmbusOnEvents()
2976 +
2977 +Description:
2978 + Handler for events
2979 +
2980 +--*/
2981 +VOID
2982 +VmbusOnEvents(
2983 + VOID
2984 + )
2985 +{
2986 + int dword;
2987 + //int maxdword = PAGE_SIZE >> 3; // receive size is 1/2 page and divide that by 4 bytes
2988 + int maxdword = MAX_NUM_CHANNELS_SUPPORTED >> 5;
2989 + int bit;
2990 + int relid;
2991 + UINT32* recvInterruptPage = gVmbusConnection.RecvInterruptPage;
2992 + //VMBUS_CHANNEL_MESSAGE* receiveMsg;
2993 +
2994 + DPRINT_ENTER(VMBUS);
2995 +
2996 + // Check events
2997 + if (recvInterruptPage)
2998 + {
2999 + for (dword = 0; dword < maxdword; dword++)
3000 + {
3001 + if (recvInterruptPage[dword])
3002 + {
3003 + for (bit = 0; bit < 32; bit++)
3004 + {
3005 + if (BitTestAndClear(&recvInterruptPage[dword], bit))
3006 + {
3007 + relid = (dword << 5) + bit;
3008 +
3009 + DPRINT_DBG(VMBUS, "event detected for relid - %d", relid);
3010 +
3011 + if (relid == 0) // special case - vmbus channel protocol msg
3012 + {
3013 + DPRINT_DBG(VMBUS, "invalid relid - %d", relid);
3014 +
3015 + continue; }
3016 + else
3017 + {
3018 + //QueueWorkItem(VmbusProcessEvent, (void*)relid);
3019 + //ret = WorkQueueQueueWorkItem(gVmbusConnection.workQueue, VmbusProcessChannelEvent, (void*)relid);
3020 + VmbusProcessChannelEvent((void*)(ULONG_PTR)relid);
3021 + }
3022 + }
3023 + }
3024 + }
3025 + }
3026 + }
3027 + DPRINT_EXIT(VMBUS);
3028 +
3029 + return;
3030 +}
3031 +
3032 +/*++
3033 +
3034 +Name:
3035 + VmbusPostMessage()
3036 +
3037 +Description:
3038 + Send a msg on the vmbus's message connection
3039 +
3040 +--*/
3041 +int
3042 +VmbusPostMessage(
3043 + PVOID buffer,
3044 + SIZE_T bufferLen
3045 + )
3046 +{
3047 + int ret=0;
3048 + HV_CONNECTION_ID connId;
3049 +
3050 +
3051 + connId.AsUINT32 =0;
3052 + connId.u.Id = VMBUS_MESSAGE_CONNECTION_ID;
3053 + ret = HvPostMessage(
3054 + connId,
3055 + 1,
3056 + buffer,
3057 + bufferLen);
3058 +
3059 + return ret;
3060 +}
3061 +
3062 +/*++
3063 +
3064 +Name:
3065 + VmbusSetEvent()
3066 +
3067 +Description:
3068 + Send an event notification to the parent
3069 +
3070 +--*/
3071 +int
3072 +VmbusSetEvent(UINT32 childRelId)
3073 +{
3074 + int ret=0;
3075 +
3076 + DPRINT_ENTER(VMBUS);
3077 +
3078 + // Each UINT32 represents 32 channels
3079 + BitSet((UINT32*)gVmbusConnection.SendInterruptPage + (childRelId >> 5), childRelId & 31);
3080 + ret = HvSignalEvent();
3081 +
3082 + DPRINT_EXIT(VMBUS);
3083 +
3084 + return ret;
3085 +}
3086 +
3087 +// EOF
3088 --- /dev/null
3089 +++ b/drivers/staging/hv/Hv.c
3090 @@ -0,0 +1,672 @@
3091 +/*
3092 + *
3093 + * Copyright (c) 2009, Microsoft Corporation.
3094 + *
3095 + * This program is free software; you can redistribute it and/or modify it
3096 + * under the terms and conditions of the GNU General Public License,
3097 + * version 2, as published by the Free Software Foundation.
3098 + *
3099 + * This program is distributed in the hope it will be useful, but WITHOUT
3100 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3101 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
3102 + * more details.
3103 + *
3104 + * You should have received a copy of the GNU General Public License along with
3105 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
3106 + * Place - Suite 330, Boston, MA 02111-1307 USA.
3107 + *
3108 + * Authors:
3109 + * Haiyang Zhang <haiyangz@microsoft.com>
3110 + * Hank Janssen <hjanssen@microsoft.com>
3111 + *
3112 + */
3113 +
3114 +
3115 +#include "logging.h"
3116 +#include "VmbusPrivate.h"
3117 +
3118 +//
3119 +// Globals
3120 +//
3121 +
3122 +// The one and only
3123 +HV_CONTEXT gHvContext={
3124 + .SynICInitialized = FALSE,
3125 + .HypercallPage = NULL,
3126 + .SignalEventParam = NULL,
3127 + .SignalEventBuffer = NULL,
3128 +};
3129 +
3130 +
3131 +/*++
3132 +
3133 +Name:
3134 + HvQueryHypervisorPresence()
3135 +
3136 +Description:
3137 + Query the cpuid for presense of windows hypervisor
3138 +
3139 +--*/
3140 +static int
3141 +HvQueryHypervisorPresence (
3142 + void
3143 + )
3144 +{
3145 + unsigned int eax;
3146 + unsigned int ebx;
3147 + unsigned int ecx;
3148 + unsigned int edx;
3149 + unsigned int op;
3150 +
3151 + eax = 0;
3152 + ebx = 0;
3153 + ecx = 0;
3154 + edx = 0;
3155 + op = HvCpuIdFunctionVersionAndFeatures;
3156 + do_cpuid(op, &eax, &ebx, &ecx, &edx);
3157 +
3158 + return (ecx & HV_PRESENT_BIT);
3159 +}
3160 +
3161 +
3162 +/*++
3163 +
3164 +Name:
3165 + HvQueryHypervisorInfo()
3166 +
3167 +Description:
3168 + Get version info of the windows hypervisor
3169 +
3170 +--*/
3171 +static int
3172 +HvQueryHypervisorInfo (
3173 + void
3174 + )
3175 +{
3176 + unsigned int eax;
3177 + unsigned int ebx;
3178 + unsigned int ecx;
3179 + unsigned int edx;
3180 + unsigned int maxLeaf;
3181 + unsigned int op;
3182 +
3183 + //
3184 + // Its assumed that this is called after confirming that Viridian is present.
3185 + // Query id and revision.
3186 + //
3187 +
3188 + eax = 0;
3189 + ebx = 0;
3190 + ecx = 0;
3191 + edx = 0;
3192 + op = HvCpuIdFunctionHvVendorAndMaxFunction;
3193 + do_cpuid(op, &eax, &ebx, &ecx, &edx);
3194 +
3195 + DPRINT_INFO(VMBUS, "Vendor ID: %c%c%c%c%c%c%c%c%c%c%c%c",
3196 + (ebx & 0xFF),
3197 + ((ebx >> 8) & 0xFF),
3198 + ((ebx >> 16) & 0xFF),
3199 + ((ebx >> 24) & 0xFF),
3200 + (ecx & 0xFF),
3201 + ((ecx >> 8) & 0xFF),
3202 + ((ecx >> 16) & 0xFF),
3203 + ((ecx >> 24) & 0xFF),
3204 + (edx & 0xFF),
3205 + ((edx >> 8) & 0xFF),
3206 + ((edx >> 16) & 0xFF),
3207 + ((edx >> 24) & 0xFF));
3208 +
3209 + maxLeaf = eax;
3210 + eax = 0;
3211 + ebx = 0;
3212 + ecx = 0;
3213 + edx = 0;
3214 + op = HvCpuIdFunctionHvInterface;
3215 + do_cpuid(op, &eax, &ebx, &ecx, &edx);
3216 +
3217 + DPRINT_INFO(VMBUS, "Interface ID: %c%c%c%c",
3218 + (eax & 0xFF),
3219 + ((eax >> 8) & 0xFF),
3220 + ((eax >> 16) & 0xFF),
3221 + ((eax >> 24) & 0xFF));
3222 +
3223 + if (maxLeaf >= HvCpuIdFunctionMsHvVersion) {
3224 + eax = 0;
3225 + ebx = 0;
3226 + ecx = 0;
3227 + edx = 0;
3228 + op = HvCpuIdFunctionMsHvVersion;
3229 + do_cpuid(op, &eax, &ebx, &ecx, &edx);
3230 + DPRINT_INFO(VMBUS, "OS Build:%d-%d.%d-%d-%d.%d",
3231 + eax,
3232 + ebx >> 16,
3233 + ebx & 0xFFFF,
3234 + ecx,
3235 + edx >> 24,
3236 + edx & 0xFFFFFF);
3237 + }
3238 + return maxLeaf;
3239 +}
3240 +
3241 +
3242 +/*++
3243 +
3244 +Name:
3245 + HvDoHypercall()
3246 +
3247 +Description:
3248 + Invoke the specified hypercall
3249 +
3250 +--*/
3251 +static UINT64
3252 +HvDoHypercall (
3253 + UINT64 Control,
3254 + void* Input,
3255 + void* Output
3256 + )
3257 +{
3258 +#ifdef x86_64
3259 + UINT64 hvStatus=0;
3260 + UINT64 inputAddress = (Input)? GetPhysicalAddress(Input) : 0;
3261 + UINT64 outputAddress = (Output)? GetPhysicalAddress(Output) : 0;
3262 + volatile void* hypercallPage = gHvContext.HypercallPage;
3263 +
3264 + DPRINT_DBG(VMBUS, "Hypercall <control %llx input phys %llx virt %p output phys %llx virt %p hypercall %p>",
3265 + Control,
3266 + inputAddress,
3267 + Input,
3268 + outputAddress,
3269 + Output,
3270 + hypercallPage);
3271 +
3272 + __asm__ __volatile__ ("mov %0, %%r8" : : "r" (outputAddress): "r8");
3273 + __asm__ __volatile__ ("call *%3" : "=a"(hvStatus): "c" (Control), "d" (inputAddress), "m" (hypercallPage));
3274 +
3275 + DPRINT_DBG(VMBUS, "Hypercall <return %llx>", hvStatus);
3276 +
3277 + return hvStatus;
3278 +
3279 +#else
3280 +
3281 + UINT32 controlHi = Control >> 32;
3282 + UINT32 controlLo = Control & 0xFFFFFFFF;
3283 + UINT32 hvStatusHi = 1;
3284 + UINT32 hvStatusLo = 1;
3285 + UINT64 inputAddress = (Input) ? GetPhysicalAddress(Input) : 0;
3286 + UINT32 inputAddressHi = inputAddress >> 32;
3287 + UINT32 inputAddressLo = inputAddress & 0xFFFFFFFF;
3288 + UINT64 outputAddress = (Output) ?GetPhysicalAddress(Output) : 0;
3289 + UINT32 outputAddressHi = outputAddress >> 32;
3290 + UINT32 outputAddressLo = outputAddress & 0xFFFFFFFF;
3291 + volatile void* hypercallPage = gHvContext.HypercallPage;
3292 +
3293 + DPRINT_DBG(VMBUS, "Hypercall <control %llx input %p output %p>",
3294 + Control,
3295 + Input,
3296 + Output);
3297 +
3298 + __asm__ __volatile__ ("call *%8" : "=d"(hvStatusHi), "=a"(hvStatusLo) : "d" (controlHi), "a" (controlLo), "b" (inputAddressHi), "c" (inputAddressLo), "D"(outputAddressHi), "S"(outputAddressLo), "m" (hypercallPage));
3299 +
3300 +
3301 + DPRINT_DBG(VMBUS, "Hypercall <return %llx>", hvStatusLo | ((UINT64)hvStatusHi << 32));
3302 +
3303 + return (hvStatusLo | ((UINT64)hvStatusHi << 32));
3304 +#endif // x86_64
3305 +}
3306 +
3307 +/*++
3308 +
3309 +Name:
3310 + HvInit()
3311 +
3312 +Description:
3313 + Main initialization routine. This routine must be called
3314 + before any other routines in here are called
3315 +
3316 +--*/
3317 +static int
3318 +HvInit (
3319 + void
3320 + )
3321 +{
3322 + int ret=0;
3323 + int maxLeaf;
3324 + HV_X64_MSR_HYPERCALL_CONTENTS hypercallMsr;
3325 + void* virtAddr=0;
3326 + ULONG_PTR physAddr=0;
3327 +
3328 + DPRINT_ENTER(VMBUS);
3329 +
3330 + memset(gHvContext.synICEventPage, 0, sizeof(HANDLE)*MAX_NUM_CPUS);
3331 + memset(gHvContext.synICMessagePage, 0, sizeof(HANDLE)*MAX_NUM_CPUS);
3332 +
3333 + if (!HvQueryHypervisorPresence())
3334 + {
3335 + DPRINT_ERR(VMBUS, "No Windows hypervisor detected!!");
3336 + goto Cleanup;
3337 + }
3338 +
3339 + DPRINT_INFO(VMBUS, "Windows hypervisor detected! Retrieving more info...");
3340 +
3341 + maxLeaf = HvQueryHypervisorInfo();
3342 + //HvQueryHypervisorFeatures(maxLeaf);
3343 +
3344 + // Determine if we are running on xenlinux (ie x2v shim) or native linux
3345 + gHvContext.GuestId = ReadMsr(HV_X64_MSR_GUEST_OS_ID);
3346 +
3347 + if (gHvContext.GuestId == 0)
3348 + {
3349 + // Write our OS info
3350 + WriteMsr(HV_X64_MSR_GUEST_OS_ID, HV_LINUX_GUEST_ID);
3351 +
3352 + gHvContext.GuestId = HV_LINUX_GUEST_ID;
3353 + }
3354 +
3355 + // See if the hypercall page is already set
3356 + hypercallMsr.AsUINT64 = ReadMsr(HV_X64_MSR_HYPERCALL);
3357 +
3358 + if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
3359 + {
3360 + // Allocate the hypercall page memory
3361 + //virtAddr = PageAlloc(1);
3362 + virtAddr = VirtualAllocExec(PAGE_SIZE);
3363 +
3364 + if (!virtAddr)
3365 + {
3366 + DPRINT_ERR(VMBUS, "unable to allocate hypercall page!!");
3367 + goto Cleanup;
3368 + }
3369 +
3370 + hypercallMsr.Enable = 1;
3371 + //hypercallMsr.GuestPhysicalAddress = Logical2PhysicalAddr(virtAddr) >> PAGE_SHIFT;
3372 + hypercallMsr.GuestPhysicalAddress = Virtual2Physical(virtAddr) >> PAGE_SHIFT;
3373 + WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
3374 +
3375 + // Confirm that hypercall page did get setup.
3376 + hypercallMsr.AsUINT64 = 0;
3377 + hypercallMsr.AsUINT64 = ReadMsr(HV_X64_MSR_HYPERCALL);
3378 +
3379 + if (!hypercallMsr.Enable)
3380 + {
3381 + DPRINT_ERR(VMBUS, "unable to set hypercall page!!");
3382 + goto Cleanup;
3383 + }
3384 +
3385 + gHvContext.HypercallPage = virtAddr;
3386 + }
3387 + else
3388 + {
3389 + DPRINT_ERR(VMBUS, "Unknown guest id (0x%llx)!!", gHvContext.GuestId);
3390 + goto Cleanup;
3391 + }
3392 +
3393 + DPRINT_INFO(VMBUS, "Hypercall page VA=0x%08x, PA=0x%08x",
3394 + (unsigned long)gHvContext.HypercallPage,
3395 + (unsigned long)hypercallMsr.GuestPhysicalAddress << PAGE_SHIFT);
3396 +
3397 + // Setup the global signal event param for the signal event hypercall
3398 + gHvContext.SignalEventBuffer = MemAlloc(sizeof(HV_INPUT_SIGNAL_EVENT_BUFFER));
3399 + if (!gHvContext.SignalEventBuffer)
3400 + {
3401 + goto Cleanup;
3402 + }
3403 +
3404 + gHvContext.SignalEventParam = (PHV_INPUT_SIGNAL_EVENT)(ALIGN_UP((ULONG_PTR)gHvContext.SignalEventBuffer, HV_HYPERCALL_PARAM_ALIGN));
3405 + gHvContext.SignalEventParam->ConnectionId.AsUINT32 = 0;
3406 + gHvContext.SignalEventParam->ConnectionId.u.Id = VMBUS_EVENT_CONNECTION_ID;
3407 + gHvContext.SignalEventParam->FlagNumber = 0;
3408 + gHvContext.SignalEventParam->RsvdZ = 0;
3409 +
3410 + //DPRINT_DBG(VMBUS, "My id %llu", HvGetCurrentPartitionId());
3411 +
3412 + DPRINT_EXIT(VMBUS);
3413 +
3414 + return ret;
3415 +
3416 +Cleanup:
3417 + if (virtAddr)
3418 + {
3419 + if (hypercallMsr.Enable)
3420 + {
3421 + hypercallMsr.AsUINT64 = 0;
3422 + WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
3423 + }
3424 +
3425 + VirtualFree(virtAddr);
3426 + }
3427 + ret = -1;
3428 + DPRINT_EXIT(VMBUS);
3429 +
3430 + return ret;
3431 +}
3432 +
3433 +
3434 +/*++
3435 +
3436 +Name:
3437 + HvCleanup()
3438 +
3439 +Description:
3440 + Cleanup routine. This routine is called normally during driver unloading or exiting.
3441 +
3442 +--*/
3443 +void
3444 +HvCleanup (
3445 + void
3446 + )
3447 +{
3448 + HV_X64_MSR_HYPERCALL_CONTENTS hypercallMsr;
3449 +
3450 + DPRINT_ENTER(VMBUS);
3451 +
3452 + if (gHvContext.SignalEventBuffer)
3453 + {
3454 + MemFree(gHvContext.SignalEventBuffer);
3455 + gHvContext.SignalEventBuffer = NULL;
3456 + gHvContext.SignalEventParam = NULL;
3457 + }
3458 +
3459 + if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
3460 + {
3461 + if (gHvContext.HypercallPage)
3462 + {
3463 + hypercallMsr.AsUINT64 = 0;
3464 + WriteMsr(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
3465 + VirtualFree(gHvContext.HypercallPage);
3466 + gHvContext.HypercallPage = NULL;
3467 + }
3468 + }
3469 +
3470 + DPRINT_EXIT(VMBUS);
3471 +
3472 +}
3473 +
3474 +
3475 +/*++
3476 +
3477 +Name:
3478 + HvPostMessage()
3479 +
3480 +Description:
3481 + Post a message using the hypervisor message IPC. This
3482 + involves a hypercall.
3483 +
3484 +--*/
3485 +HV_STATUS
3486 +HvPostMessage(
3487 + HV_CONNECTION_ID connectionId,
3488 + HV_MESSAGE_TYPE messageType,
3489 + PVOID payload,
3490 + SIZE_T payloadSize
3491 + )
3492 +{
3493 + struct alignedInput {
3494 + UINT64 alignment8;
3495 + HV_INPUT_POST_MESSAGE msg;
3496 + };
3497 +
3498 + PHV_INPUT_POST_MESSAGE alignedMsg;
3499 + HV_STATUS status;
3500 + ULONG_PTR addr;
3501 +
3502 + if (payloadSize > HV_MESSAGE_PAYLOAD_BYTE_COUNT)
3503 + {
3504 + return -1;
3505 + }
3506 +
3507 + addr = (ULONG_PTR)MemAllocAtomic(sizeof(struct alignedInput));
3508 +
3509 + if (!addr)
3510 + {
3511 + return -1;
3512 + }
3513 +
3514 + alignedMsg = (PHV_INPUT_POST_MESSAGE)(ALIGN_UP(addr, HV_HYPERCALL_PARAM_ALIGN));
3515 +
3516 + alignedMsg->ConnectionId = connectionId;
3517 + alignedMsg->MessageType = messageType;
3518 + alignedMsg->PayloadSize = payloadSize;
3519 + memcpy((void*)alignedMsg->Payload, payload, payloadSize);
3520 +
3521 + status = HvDoHypercall(HvCallPostMessage, alignedMsg, 0) & 0xFFFF;
3522 +
3523 + MemFree((void*)addr);
3524 +
3525 + return status;
3526 +}
3527 +
3528 +
3529 +/*++
3530 +
3531 +Name:
3532 + HvSignalEvent()
3533 +
3534 +Description:
3535 + Signal an event on the specified connection using the hypervisor event IPC. This
3536 + involves a hypercall.
3537 +
3538 +--*/
3539 +HV_STATUS
3540 +HvSignalEvent(
3541 + )
3542 +{
3543 + HV_STATUS status;
3544 +
3545 + status = HvDoHypercall(HvCallSignalEvent, gHvContext.SignalEventParam, 0) & 0xFFFF;
3546 +
3547 + return status;
3548 +}
3549 +
3550 +
3551 +/*++
3552 +
3553 +Name:
3554 + HvSynicInit()
3555 +
3556 +Description:
3557 + Initialize the Synthethic Interrupt Controller. If it is already initialized by
3558 + another entity (ie x2v shim), we need to retrieve the initialized message and event pages.
3559 + Otherwise, we create and initialize the message and event pages.
3560 +
3561 +--*/
3562 +int
3563 +HvSynicInit (
3564 + UINT32 irqVector
3565 + )
3566 +{
3567 + UINT64 version;
3568 + HV_SYNIC_SIMP simp;
3569 + HV_SYNIC_SIEFP siefp;
3570 + HV_SYNIC_SINT sharedSint;
3571 + HV_SYNIC_SCONTROL sctrl;
3572 + UINT64 guestID;
3573 + int ret=0;
3574 +
3575 + DPRINT_ENTER(VMBUS);
3576 +
3577 + if (!gHvContext.HypercallPage)
3578 + {
3579 + DPRINT_EXIT(VMBUS);
3580 + return ret;
3581 + }
3582 +
3583 + // Check the version
3584 + version = ReadMsr(HV_X64_MSR_SVERSION);
3585 +
3586 + DPRINT_INFO(VMBUS, "SynIC version: %llx", version);
3587 +
3588 + // TODO: Handle SMP
3589 + if (gHvContext.GuestId == HV_XENLINUX_GUEST_ID)
3590 + {
3591 + DPRINT_INFO(VMBUS, "Skipping SIMP and SIEFP setup since it is already set.");
3592 +
3593 + simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
3594 + siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
3595 +
3596 + DPRINT_DBG(VMBUS, "Simp: %llx, Sifep: %llx", simp.AsUINT64, siefp.AsUINT64);
3597 +
3598 + // Determine if we are running on xenlinux (ie x2v shim) or native linux
3599 + guestID = ReadMsr(HV_X64_MSR_GUEST_OS_ID);
3600 +
3601 + if (guestID == HV_LINUX_GUEST_ID)
3602 + {
3603 + gHvContext.synICMessagePage[0] = GetVirtualAddress(simp.BaseSimpGpa << PAGE_SHIFT);
3604 + gHvContext.synICEventPage[0] = GetVirtualAddress(siefp.BaseSiefpGpa << PAGE_SHIFT);
3605 + }
3606 + else
3607 + {
3608 + DPRINT_ERR(VMBUS, "unknown guest id!!");
3609 + goto Cleanup;
3610 + }
3611 + DPRINT_DBG(VMBUS, "MAPPED: Simp: %p, Sifep: %p", gHvContext.synICMessagePage[0], gHvContext.synICEventPage[0]);
3612 + }
3613 + else
3614 + {
3615 + gHvContext.synICMessagePage[0] = PageAlloc(1);
3616 + if (gHvContext.synICMessagePage[0] == NULL)
3617 + {
3618 + DPRINT_ERR(VMBUS, "unable to allocate SYNIC message page!!");
3619 + goto Cleanup;
3620 + }
3621 +
3622 + gHvContext.synICEventPage[0] = PageAlloc(1);
3623 + if (gHvContext.synICEventPage[0] == NULL)
3624 + {
3625 + DPRINT_ERR(VMBUS, "unable to allocate SYNIC event page!!");
3626 + goto Cleanup;
3627 + }
3628 +
3629 + //
3630 + // Setup the Synic's message page
3631 + //
3632 + simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
3633 + simp.SimpEnabled = 1;
3634 + simp.BaseSimpGpa = GetPhysicalAddress(gHvContext.synICMessagePage[0]) >> PAGE_SHIFT;
3635 +
3636 + DPRINT_DBG(VMBUS, "HV_X64_MSR_SIMP msr set to: %llx", simp.AsUINT64);
3637 +
3638 + WriteMsr(HV_X64_MSR_SIMP, simp.AsUINT64);
3639 +
3640 + //
3641 + // Setup the Synic's event page
3642 + //
3643 + siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
3644 + siefp.SiefpEnabled = 1;
3645 + siefp.BaseSiefpGpa = GetPhysicalAddress(gHvContext.synICEventPage[0]) >> PAGE_SHIFT;
3646 +
3647 + DPRINT_DBG(VMBUS, "HV_X64_MSR_SIEFP msr set to: %llx", siefp.AsUINT64);
3648 +
3649 + WriteMsr(HV_X64_MSR_SIEFP, siefp.AsUINT64);
3650 + }
3651 + //
3652 + // Setup the interception SINT.
3653 + //
3654 + //WriteMsr((HV_X64_MSR_SINT0 + HV_SYNIC_INTERCEPTION_SINT_INDEX),
3655 + // interceptionSint.AsUINT64);
3656 +
3657 + //
3658 + // Setup the shared SINT.
3659 + //
3660 + sharedSint.AsUINT64 = ReadMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT);
3661 +
3662 + sharedSint.AsUINT64 = 0;
3663 + sharedSint.Vector = irqVector; //HV_SHARED_SINT_IDT_VECTOR + 0x20;
3664 + sharedSint.Masked = FALSE;
3665 + sharedSint.AutoEoi = TRUE;
3666 +
3667 + DPRINT_DBG(VMBUS, "HV_X64_MSR_SINT1 msr set to: %llx", sharedSint.AsUINT64);
3668 +
3669 + WriteMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);
3670 +
3671 + // Enable the global synic bit
3672 + sctrl.AsUINT64 = ReadMsr(HV_X64_MSR_SCONTROL);
3673 + sctrl.Enable = 1;
3674 +
3675 + WriteMsr(HV_X64_MSR_SCONTROL, sctrl.AsUINT64);
3676 +
3677 + gHvContext.SynICInitialized = TRUE;
3678 +
3679 + DPRINT_EXIT(VMBUS);
3680 +
3681 + return ret;
3682 +
3683 +Cleanup:
3684 + ret = -1;
3685 +
3686 + if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
3687 + {
3688 + if (gHvContext.synICEventPage[0])
3689 + {
3690 + PageFree(gHvContext.synICEventPage[0],1);
3691 + }
3692 +
3693 + if (gHvContext.synICMessagePage[0])
3694 + {
3695 + PageFree(gHvContext.synICMessagePage[0], 1);
3696 + }
3697 + }
3698 +
3699 + DPRINT_EXIT(VMBUS);
3700 +
3701 + return ret;
3702 +
3703 +}
3704 +
3705 +/*++
3706 +
3707 +Name:
3708 + HvSynicCleanup()
3709 +
3710 +Description:
3711 + Cleanup routine for HvSynicInit().
3712 +
3713 +--*/
3714 +VOID
3715 +HvSynicCleanup(
3716 + VOID
3717 + )
3718 +{
3719 + HV_SYNIC_SINT sharedSint;
3720 + HV_SYNIC_SIMP simp;
3721 + HV_SYNIC_SIEFP siefp;
3722 +
3723 + DPRINT_ENTER(VMBUS);
3724 +
3725 + if (!gHvContext.SynICInitialized)
3726 + {
3727 + DPRINT_EXIT(VMBUS);
3728 + return;
3729 + }
3730 +
3731 + sharedSint.AsUINT64 = ReadMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT);
3732 +
3733 + sharedSint.Masked = 1;
3734 +
3735 + // Disable the interrupt
3736 + WriteMsr(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);
3737 +
3738 + // Disable and free the resources only if we are running as native linux
3739 + // since in xenlinux, we are sharing the resources with the x2v shim
3740 + if (gHvContext.GuestId == HV_LINUX_GUEST_ID)
3741 + {
3742 + simp.AsUINT64 = ReadMsr(HV_X64_MSR_SIMP);
3743 + simp.SimpEnabled = 0;
3744 + simp.BaseSimpGpa = 0;
3745 +
3746 + WriteMsr(HV_X64_MSR_SIMP, simp.AsUINT64);
3747 +
3748 + siefp.AsUINT64 = ReadMsr(HV_X64_MSR_SIEFP);
3749 + siefp.SiefpEnabled = 0;
3750 + siefp.BaseSiefpGpa = 0;
3751 +
3752 + WriteMsr(HV_X64_MSR_SIEFP, siefp.AsUINT64);
3753 +
3754 + PageFree(gHvContext.synICMessagePage[0], 1);
3755 + PageFree(gHvContext.synICEventPage[0], 1);
3756 + }
3757 +
3758 + DPRINT_EXIT(VMBUS);
3759 +}
3760 +
3761 +
3762 +// eof
3763 --- /dev/null
3764 +++ b/drivers/staging/hv/Hv.h
3765 @@ -0,0 +1,184 @@
3766 +/*
3767 + *
3768 + * Copyright (c) 2009, Microsoft Corporation.
3769 + *
3770 + * This program is free software; you can redistribute it and/or modify it
3771 + * under the terms and conditions of the GNU General Public License,
3772 + * version 2, as published by the Free Software Foundation.
3773 + *
3774 + * This program is distributed in the hope it will be useful, but WITHOUT
3775 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3776 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
3777 + * more details.
3778 + *
3779 + * You should have received a copy of the GNU General Public License along with
3780 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
3781 + * Place - Suite 330, Boston, MA 02111-1307 USA.
3782 + *
3783 + * Authors:
3784 + * Haiyang Zhang <haiyangz@microsoft.com>
3785 + * Hank Janssen <hjanssen@microsoft.com>
3786 + *
3787 + */
3788 +
3789 +
3790 +#ifndef __HV_H__
3791 +#define __HV_H__
3792 +
3793 +#include "osd.h"
3794 +
3795 +#include "HvTypes.h"
3796 +#include "HvStatus.h"
3797 +//#include "HvVmApi.h"
3798 +//#include "HvKeApi.h"
3799 +//#include "HvMmApi.h"
3800 +//#include "HvCpuApi.h"
3801 +#include "HvHalApi.h"
3802 +#include "HvVpApi.h"
3803 +//#include "HvTrApi.h"
3804 +#include "HvSynicApi.h"
3805 +//#include "HvAmApi.h"
3806 +//#include "HvHkApi.h"
3807 +//#include "HvValApi.h"
3808 +#include "HvHcApi.h"
3809 +#include "HvPtApi.h"
3810 +
3811 +enum
3812 +{
3813 + VMBUS_MESSAGE_CONNECTION_ID = 1,
3814 + VMBUS_MESSAGE_PORT_ID = 1,
3815 + VMBUS_EVENT_CONNECTION_ID = 2,
3816 + VMBUS_EVENT_PORT_ID = 2,
3817 + VMBUS_MONITOR_CONNECTION_ID = 3,
3818 + VMBUS_MONITOR_PORT_ID = 3,
3819 + VMBUS_MESSAGE_SINT = 2
3820 +};
3821 +//
3822 +// #defines
3823 +//
3824 +#define HV_PRESENT_BIT 0x80000000
3825 +
3826 +#define HV_XENLINUX_GUEST_ID_LO 0x00000000
3827 +#define HV_XENLINUX_GUEST_ID_HI 0x0B00B135
3828 +#define HV_XENLINUX_GUEST_ID (((UINT64)HV_XENLINUX_GUEST_ID_HI << 32) | HV_XENLINUX_GUEST_ID_LO)
3829 +
3830 +#define HV_LINUX_GUEST_ID_LO 0x00000000
3831 +#define HV_LINUX_GUEST_ID_HI 0xB16B00B5
3832 +#define HV_LINUX_GUEST_ID (((UINT64)HV_LINUX_GUEST_ID_HI << 32) | HV_LINUX_GUEST_ID_LO)
3833 +
3834 +#define HV_CPU_POWER_MANAGEMENT (1 << 0)
3835 +#define HV_RECOMMENDATIONS_MAX 4
3836 +
3837 +#define HV_X64_MAX 5
3838 +#define HV_CAPS_MAX 8
3839 +
3840 +
3841 +#define HV_HYPERCALL_PARAM_ALIGN sizeof(UINT64)
3842 +
3843 +//
3844 +// Service definitions
3845 +//
3846 +#define HV_SERVICE_PARENT_PORT (0)
3847 +#define HV_SERVICE_PARENT_CONNECTION (0)
3848 +
3849 +#define HV_SERVICE_CONNECT_RESPONSE_SUCCESS (0)
3850 +#define HV_SERVICE_CONNECT_RESPONSE_INVALID_PARAMETER (1)
3851 +#define HV_SERVICE_CONNECT_RESPONSE_UNKNOWN_SERVICE (2)
3852 +#define HV_SERVICE_CONNECT_RESPONSE_CONNECTION_REJECTED (3)
3853 +
3854 +#define HV_SERVICE_CONNECT_REQUEST_MESSAGE_ID (1)
3855 +#define HV_SERVICE_CONNECT_RESPONSE_MESSAGE_ID (2)
3856 +#define HV_SERVICE_DISCONNECT_REQUEST_MESSAGE_ID (3)
3857 +#define HV_SERVICE_DISCONNECT_RESPONSE_MESSAGE_ID (4)
3858 +#define HV_SERVICE_MAX_MESSAGE_ID (4)
3859 +
3860 +#define HV_SERVICE_PROTOCOL_VERSION (0x0010)
3861 +#define HV_CONNECT_PAYLOAD_BYTE_COUNT 64
3862 +
3863 +//#define VMBUS_REVISION_NUMBER 6
3864 +//#define VMBUS_PORT_ID 11 // Our local vmbus's port and connection id. Anything >0 is fine
3865 +
3866 +// 628180B8-308D-4c5e-B7DB-1BEB62E62EF4
3867 +static const GUID VMBUS_SERVICE_ID = {.Data = {0xb8, 0x80, 0x81, 0x62, 0x8d, 0x30, 0x5e, 0x4c, 0xb7, 0xdb, 0x1b, 0xeb, 0x62, 0xe6, 0x2e, 0xf4} };
3868 +
3869 +#define MAX_NUM_CPUS 1
3870 +
3871 +
3872 +typedef struct {
3873 + UINT64 Align8;
3874 + HV_INPUT_SIGNAL_EVENT Event;
3875 +} HV_INPUT_SIGNAL_EVENT_BUFFER;
3876 +
3877 +typedef struct {
3878 + UINT64 GuestId; // XenLinux or native Linux. If XenLinux, the hypercall and synic pages has already been initialized
3879 + void* HypercallPage;
3880 +
3881 + BOOL SynICInitialized;
3882 + // This is used as an input param to HvCallSignalEvent hypercall. The input param is immutable
3883 + // in our usage and must be dynamic mem (vs stack or global).
3884 + HV_INPUT_SIGNAL_EVENT_BUFFER *SignalEventBuffer;
3885 + HV_INPUT_SIGNAL_EVENT *SignalEventParam; // 8-bytes aligned of the buffer above
3886 +
3887 + HANDLE synICMessagePage[MAX_NUM_CPUS];
3888 + HANDLE synICEventPage[MAX_NUM_CPUS];
3889 +} HV_CONTEXT;
3890 +
3891 +extern HV_CONTEXT gHvContext;
3892 +
3893 +
3894 +//
3895 +// Inline routines
3896 +//
3897 +static inline unsigned long long ReadMsr(int msr)
3898 +{
3899 + unsigned long long val;
3900 +
3901 + RDMSR(msr, val);
3902 +
3903 + return val;
3904 +}
3905 +
3906 +static inline void WriteMsr(int msr, UINT64 val)
3907 +{
3908 + WRMSR(msr, val);
3909 +
3910 + return;
3911 +}
3912 +
3913 +//
3914 +// Hv Interface
3915 +//
3916 +INTERNAL int
3917 +HvInit(
3918 + VOID
3919 + );
3920 +
3921 +INTERNAL VOID
3922 +HvCleanup(
3923 + VOID
3924 + );
3925 +
3926 +INTERNAL HV_STATUS
3927 +HvPostMessage(
3928 + HV_CONNECTION_ID connectionId,
3929 + HV_MESSAGE_TYPE messageType,
3930 + PVOID payload,
3931 + SIZE_T payloadSize
3932 + );
3933 +
3934 +INTERNAL HV_STATUS
3935 +HvSignalEvent(
3936 + VOID
3937 + );
3938 +
3939 +INTERNAL int
3940 +HvSynicInit(
3941 + UINT32 irqVector
3942 + );
3943 +
3944 +INTERNAL VOID
3945 +HvSynicCleanup(
3946 + VOID
3947 + );
3948 +
3949 +#endif // __HV_H__
3950 --- /dev/null
3951 +++ b/drivers/staging/hv/osd.c
3952 @@ -0,0 +1,500 @@
3953 +/*
3954 + *
3955 + * Copyright (c) 2009, Microsoft Corporation.
3956 + *
3957 + * This program is free software; you can redistribute it and/or modify it
3958 + * under the terms and conditions of the GNU General Public License,
3959 + * version 2, as published by the Free Software Foundation.
3960 + *
3961 + * This program is distributed in the hope it will be useful, but WITHOUT
3962 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
3963 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
3964 + * more details.
3965 + *
3966 + * You should have received a copy of the GNU General Public License along with
3967 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
3968 + * Place - Suite 330, Boston, MA 02111-1307 USA.
3969 + *
3970 + * Authors:
3971 + * Haiyang Zhang <haiyangz@microsoft.com>
3972 + * Hank Janssen <hjanssen@microsoft.com>
3973 + *
3974 + */
3975 +
3976 +
3977 +#include <linux/module.h>
3978 +#include <linux/init.h>
3979 +#include <linux/types.h>
3980 +#include <linux/mm.h>
3981 +#include <linux/highmem.h>
3982 +#include <linux/vmalloc.h>
3983 +//#include <linux/config.h>
3984 +#include <linux/ioport.h>
3985 +#include <linux/irq.h>
3986 +#include <linux/interrupt.h>
3987 +#include <linux/wait.h>
3988 +#include <linux/spinlock.h>
3989 +#include <linux/workqueue.h>
3990 +#include <linux/kernel.h>
3991 +#include <linux/timer.h>
3992 +#include <linux/jiffies.h>
3993 +#include <linux/delay.h>
3994 +#include <linux/time.h>
3995 +
3996 +#include <asm/io.h>
3997 +#include <asm/bitops.h>
3998 +#include <asm/kmap_types.h>
3999 +#include <asm/atomic.h>
4000 +
4001 +#include "osd.h"
4002 +
4003 +//
4004 +// Data types
4005 +//
4006 +typedef struct _TIMER {
4007 + struct timer_list timer;
4008 + PFN_TIMER_CALLBACK callback;
4009 + void* context;
4010 +}TIMER;
4011 +
4012 +
4013 +typedef struct _WAITEVENT {
4014 + int condition;
4015 + wait_queue_head_t event;
4016 +} WAITEVENT;
4017 +
4018 +typedef struct _SPINLOCK {
4019 + spinlock_t lock;
4020 + unsigned long flags;
4021 +} SPINLOCK;
4022 +
4023 +typedef struct _WORKQUEUE {
4024 + struct workqueue_struct *queue;
4025 +} WORKQUEUE;
4026 +
4027 +typedef struct _WORKITEM {
4028 + struct work_struct work;
4029 + PFN_WORKITEM_CALLBACK callback;
4030 + void* context;
4031 +} WORKITEM;
4032 +
4033 +
4034 +//
4035 +// Global
4036 +//
4037 +
4038 +void LogMsg(const char *fmt, ...)
4039 +{
4040 +#ifdef KERNEL_2_6_5
4041 + char buf[1024];
4042 +#endif
4043 + va_list args;
4044 +
4045 + va_start(args, fmt);
4046 +#ifdef KERNEL_2_6_5
4047 + vsnprintf(buf, 1024, fmt, args);
4048 + va_end(args);
4049 + printk(buf);
4050 +#else
4051 + vprintk(fmt, args);
4052 + va_end(args);
4053 +#endif
4054 +}
4055 +
4056 +void BitSet(unsigned int* addr, int bit)
4057 +{
4058 + set_bit(bit, (unsigned long*)addr);
4059 +}
4060 +
4061 +int BitTest(unsigned int* addr, int bit)
4062 +{
4063 + return test_bit(bit, (unsigned long*)addr);
4064 +}
4065 +
4066 +void BitClear(unsigned int* addr, int bit)
4067 +{
4068 + clear_bit(bit, (unsigned long*)addr);
4069 +}
4070 +
4071 +int BitTestAndClear(unsigned int* addr, int bit)
4072 +{
4073 + return test_and_clear_bit(bit, (unsigned long*)addr);
4074 +}
4075 +
4076 +int BitTestAndSet(unsigned int* addr, int bit)
4077 +{
4078 + return test_and_set_bit(bit, (unsigned long*)addr);
4079 +}
4080 +
4081 +
4082 +int InterlockedIncrement(int *val)
4083 +{
4084 +#ifdef KERNEL_2_6_5
4085 + int i;
4086 + local_irq_disable();
4087 + i = atomic_read((atomic_t*)val);
4088 + atomic_set((atomic_t*)val, i+1);
4089 + local_irq_enable();
4090 + return i+1;
4091 +#else
4092 + return atomic_inc_return((atomic_t*)val);
4093 +#endif
4094 +}
4095 +
4096 +int InterlockedDecrement(int *val)
4097 +{
4098 +#ifdef KERNEL_2_6_5
4099 + int i;
4100 + local_irq_disable();
4101 + i = atomic_read((atomic_t*)val);
4102 + atomic_set((atomic_t*)val, i-1);
4103 + local_irq_enable();
4104 + return i-1;
4105 +#else
4106 + return atomic_dec_return((atomic_t*)val);
4107 +#endif
4108 +}
4109 +
4110 +#ifndef atomic_cmpxchg
4111 +#define atomic_cmpxchg(v, old, new) ((int)cmpxchg(&((v)->counter), old, new))
4112 +#endif
4113 +int InterlockedCompareExchange(int *val, int new, int curr)
4114 +{
4115 + //return ((int)cmpxchg(((atomic_t*)val), curr, new));
4116 + return atomic_cmpxchg((atomic_t*)val, curr, new);
4117 +
4118 +}
4119 +
4120 +void Sleep(unsigned long usecs)
4121 +{
4122 + udelay(usecs);
4123 +}
4124 +
4125 +void* VirtualAllocExec(unsigned int size)
4126 +{
4127 +#ifdef __x86_64__
4128 + return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL_EXEC);
4129 +#else
4130 + return __vmalloc(size, GFP_KERNEL, __pgprot(__PAGE_KERNEL & (~_PAGE_NX)));
4131 +#endif
4132 +}
4133 +
4134 +void VirtualFree(void* VirtAddr)
4135 +{
4136 + return vfree(VirtAddr);
4137 +}
4138 +
4139 +void* PageAlloc(unsigned int count)
4140 +{
4141 + void *p;
4142 + p = (void *)__get_free_pages(GFP_KERNEL, get_order(count * PAGE_SIZE));
4143 + if (p) memset(p, 0, count * PAGE_SIZE);
4144 + return p;
4145 +
4146 + //struct page* page = alloc_page(GFP_KERNEL|__GFP_ZERO);
4147 + //void *p;
4148 +
4149 + ////BUGBUG: We need to use kmap in case we are in HIMEM region
4150 + //p = page_address(page);
4151 + //if (p) memset(p, 0, PAGE_SIZE);
4152 + //return p;
4153 +}
4154 +
4155 +void PageFree(void* page, unsigned int count)
4156 +{
4157 + free_pages((unsigned long)page, get_order(count * PAGE_SIZE));
4158 + /*struct page* p = virt_to_page(page);
4159 + __free_page(p);*/
4160 +}
4161 +
4162 +
4163 +void* PageMapVirtualAddress(unsigned long Pfn)
4164 +{
4165 + return kmap_atomic(pfn_to_page(Pfn), KM_IRQ0);
4166 +}
4167 +
4168 +void PageUnmapVirtualAddress(void* VirtAddr)
4169 +{
4170 + kunmap_atomic(VirtAddr, KM_IRQ0);
4171 +}
4172 +
4173 +void* MemAlloc(unsigned int size)
4174 +{
4175 + return kmalloc(size, GFP_KERNEL);
4176 +}
4177 +
4178 +void* MemAllocZeroed(unsigned int size)
4179 +{
4180 + void *p = kmalloc(size, GFP_KERNEL);
4181 + if (p) memset(p, 0, size);
4182 + return p;
4183 +}
4184 +
4185 +void* MemAllocAtomic(unsigned int size)
4186 +{
4187 + return kmalloc(size, GFP_ATOMIC);
4188 +}
4189 +
4190 +void MemFree(void* buf)
4191 +{
4192 + kfree(buf);
4193 +}
4194 +
4195 +void *MemMapIO(unsigned long phys, unsigned long size)
4196 +{
4197 +#if X2V_LINUX
4198 +#ifdef __x86_64__
4199 + return (void*)(phys + 0xFFFF83000C000000);
4200 +#else // i386
4201 + return (void*)(phys + 0xfb000000);
4202 +#endif
4203 +#else
4204 + return (void*)GetVirtualAddress(phys); //return ioremap_nocache(phys, size);
4205 +#endif
4206 +}
4207 +
4208 +void MemUnmapIO(void *virt)
4209 +{
4210 + //iounmap(virt);
4211 +}
4212 +
4213 +void MemoryFence()
4214 +{
4215 + mb();
4216 +}
4217 +
4218 +void TimerCallback(unsigned long data)
4219 +{
4220 + TIMER* t = (TIMER*)data;
4221 +
4222 + t->callback(t->context);
4223 +}
4224 +
4225 +HANDLE TimerCreate(PFN_TIMER_CALLBACK pfnTimerCB, void* context)
4226 +{
4227 + TIMER* t = kmalloc(sizeof(TIMER), GFP_KERNEL);
4228 + if (!t)
4229 + {
4230 + return NULL;
4231 + }
4232 +
4233 + t->callback = pfnTimerCB;
4234 + t->context = context;
4235 +
4236 + init_timer(&t->timer);
4237 + t->timer.data = (unsigned long)t;
4238 + t->timer.function = TimerCallback;
4239 +
4240 + return t;
4241 +}
4242 +
4243 +void TimerStart(HANDLE hTimer, UINT32 expirationInUs)
4244 +{
4245 + TIMER* t = (TIMER* )hTimer;
4246 +
4247 + t->timer.expires = jiffies + usecs_to_jiffies(expirationInUs);
4248 + add_timer(&t->timer);
4249 +}
4250 +
4251 +int TimerStop(HANDLE hTimer)
4252 +{
4253 + TIMER* t = (TIMER* )hTimer;
4254 +
4255 + return del_timer(&t->timer);
4256 +}
4257 +
4258 +void TimerClose(HANDLE hTimer)
4259 +{
4260 + TIMER* t = (TIMER* )hTimer;
4261 +
4262 + del_timer(&t->timer);
4263 + kfree(t);
4264 +}
4265 +
4266 +SIZE_T GetTickCount(void)
4267 +{
4268 + return jiffies;
4269 +}
4270 +
4271 +signed long long GetTimestamp(void)
4272 +{
4273 + struct timeval t;
4274 +
4275 + do_gettimeofday(&t);
4276 +
4277 + return timeval_to_ns(&t);
4278 +}
4279 +
4280 +HANDLE WaitEventCreate(void)
4281 +{
4282 + WAITEVENT* wait = kmalloc(sizeof(WAITEVENT), GFP_KERNEL);
4283 + if (!wait)
4284 + {
4285 + return NULL;
4286 + }
4287 +
4288 + wait->condition = 0;
4289 + init_waitqueue_head(&wait->event);
4290 + return wait;
4291 +}
4292 +
4293 +void WaitEventClose(HANDLE hWait)
4294 +{
4295 + WAITEVENT* waitEvent = (WAITEVENT* )hWait;
4296 + kfree(waitEvent);
4297 +}
4298 +
4299 +void WaitEventSet(HANDLE hWait)
4300 +{
4301 + WAITEVENT* waitEvent = (WAITEVENT* )hWait;
4302 + waitEvent->condition = 1;
4303 + wake_up_interruptible(&waitEvent->event);
4304 +}
4305 +
4306 +int WaitEventWait(HANDLE hWait)
4307 +{
4308 + int ret=0;
4309 + WAITEVENT* waitEvent = (WAITEVENT* )hWait;
4310 +
4311 + ret= wait_event_interruptible(waitEvent->event,
4312 + waitEvent->condition);
4313 + waitEvent->condition = 0;
4314 + return ret;
4315 +}
4316 +
4317 +int WaitEventWaitEx(HANDLE hWait, UINT32 TimeoutInMs)
4318 +{
4319 + int ret=0;
4320 + WAITEVENT* waitEvent = (WAITEVENT* )hWait;
4321 +
4322 + ret= wait_event_interruptible_timeout(waitEvent->event,
4323 + waitEvent->condition,
4324 + msecs_to_jiffies(TimeoutInMs));
4325 + waitEvent->condition = 0;
4326 + return ret;
4327 +}
4328 +
4329 +HANDLE SpinlockCreate(VOID)
4330 +{
4331 + SPINLOCK* spin = kmalloc(sizeof(SPINLOCK), GFP_KERNEL);
4332 + if (!spin)
4333 + {
4334 + return NULL;
4335 + }
4336 + spin_lock_init(&spin->lock);
4337 +
4338 + return spin;
4339 +}
4340 +
4341 +VOID SpinlockAcquire(HANDLE hSpin)
4342 +{
4343 + SPINLOCK* spin = (SPINLOCK* )hSpin;
4344 +
4345 + spin_lock_irqsave(&spin->lock, spin->flags);
4346 +}
4347 +
4348 +VOID SpinlockRelease(HANDLE hSpin)
4349 +{
4350 + SPINLOCK* spin = (SPINLOCK* )hSpin;
4351 +
4352 + spin_unlock_irqrestore(&spin->lock, spin->flags);
4353 +}
4354 +
4355 +VOID SpinlockClose(HANDLE hSpin)
4356 +{
4357 + SPINLOCK* spin = (SPINLOCK* )hSpin;
4358 + kfree(spin);
4359 +}
4360 +
4361 +void* Physical2LogicalAddr(ULONG_PTR PhysAddr)
4362 +{
4363 + void* logicalAddr = phys_to_virt(PhysAddr);
4364 + BUG_ON(!virt_addr_valid(logicalAddr));
4365 + return logicalAddr;
4366 +}
4367 +
4368 +ULONG_PTR Logical2PhysicalAddr(PVOID LogicalAddr)
4369 +{
4370 + BUG_ON(!virt_addr_valid(LogicalAddr));
4371 + return virt_to_phys(LogicalAddr);
4372 +}
4373 +
4374 +
4375 +ULONG_PTR Virtual2Physical(PVOID VirtAddr)
4376 +{
4377 + ULONG_PTR pfn = vmalloc_to_pfn(VirtAddr);
4378 +
4379 + return pfn << PAGE_SHIFT;
4380 +}
4381 +
4382 +#ifdef KERNEL_2_6_27
4383 +void WorkItemCallback(struct work_struct *work)
4384 +#else
4385 +void WorkItemCallback(void* work)
4386 +#endif
4387 +{
4388 + WORKITEM* w = (WORKITEM*)work;
4389 +
4390 + w->callback(w->context);
4391 +
4392 + kfree(w);
4393 +}
4394 +
4395 +HANDLE WorkQueueCreate(char* name)
4396 +{
4397 + WORKQUEUE *wq = kmalloc(sizeof(WORKQUEUE), GFP_KERNEL);
4398 + if (!wq)
4399 + {
4400 + return NULL;
4401 + }
4402 + wq->queue = create_workqueue(name);
4403 +
4404 + return wq;
4405 +}
4406 +
4407 +void WorkQueueClose(HANDLE hWorkQueue)
4408 +{
4409 + WORKQUEUE *wq = (WORKQUEUE *)hWorkQueue;
4410 +
4411 + destroy_workqueue(wq->queue);
4412 +
4413 + return;
4414 +}
4415 +
4416 +int WorkQueueQueueWorkItem(HANDLE hWorkQueue, PFN_WORKITEM_CALLBACK workItem, void* context)
4417 +{
4418 + WORKQUEUE *wq = (WORKQUEUE *)hWorkQueue;
4419 +
4420 + WORKITEM* w = kmalloc(sizeof(WORKITEM), GFP_ATOMIC);
4421 + if (!w)
4422 + {
4423 + return -1;
4424 + }
4425 +
4426 + w->callback = workItem,
4427 + w->context = context;
4428 +#ifdef KERNEL_2_6_27
4429 + INIT_WORK(&w->work, WorkItemCallback);
4430 +#else
4431 + INIT_WORK(&w->work, WorkItemCallback, w);
4432 +#endif
4433 + return queue_work(wq->queue, &w->work);
4434 +}
4435 +
4436 +void QueueWorkItem(PFN_WORKITEM_CALLBACK workItem, void* context)
4437 +{
4438 + WORKITEM* w = kmalloc(sizeof(WORKITEM), GFP_ATOMIC);
4439 + if (!w)
4440 + {
4441 + return;
4442 + }
4443 +
4444 + w->callback = workItem,
4445 + w->context = context;
4446 +#ifdef KERNEL_2_6_27
4447 + INIT_WORK(&w->work, WorkItemCallback);
4448 +#else
4449 + INIT_WORK(&w->work, WorkItemCallback, w);
4450 +#endif
4451 + schedule_work(&w->work);
4452 +}
4453 --- /dev/null
4454 +++ b/drivers/staging/hv/RingBuffer.c
4455 @@ -0,0 +1,630 @@
4456 +/*
4457 + *
4458 + * Copyright (c) 2009, Microsoft Corporation.
4459 + *
4460 + * This program is free software; you can redistribute it and/or modify it
4461 + * under the terms and conditions of the GNU General Public License,
4462 + * version 2, as published by the Free Software Foundation.
4463 + *
4464 + * This program is distributed in the hope it will be useful, but WITHOUT
4465 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4466 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
4467 + * more details.
4468 + *
4469 + * You should have received a copy of the GNU General Public License along with
4470 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
4471 + * Place - Suite 330, Boston, MA 02111-1307 USA.
4472 + *
4473 + * Authors:
4474 + * Haiyang Zhang <haiyangz@microsoft.com>
4475 + * Hank Janssen <hjanssen@microsoft.com>
4476 + *
4477 + */
4478 +
4479 +
4480 +#include "logging.h"
4481 +#include "RingBuffer.h"
4482 +
4483 +//
4484 +// #defines
4485 +//
4486 +
4487 +// Amount of space to write to
4488 +#define BYTES_AVAIL_TO_WRITE(r, w, z) ((w) >= (r))?((z) - ((w) - (r))):((r) - (w))
4489 +
4490 +
4491 +/*++
4492 +
4493 +Name:
4494 + GetRingBufferAvailBytes()
4495 +
4496 +Description:
4497 + Get number of bytes available to read and to write to
4498 + for the specified ring buffer
4499 +
4500 +--*/
4501 +static inline void
4502 +GetRingBufferAvailBytes(RING_BUFFER_INFO *rbi, UINT32 *read, UINT32 *write)
4503 +{
4504 + UINT32 read_loc,write_loc;
4505 +
4506 + // Capture the read/write indices before they changed
4507 + read_loc = rbi->RingBuffer->ReadIndex;
4508 + write_loc = rbi->RingBuffer->WriteIndex;
4509 +
4510 + *write = BYTES_AVAIL_TO_WRITE(read_loc, write_loc, rbi->RingDataSize);
4511 + *read = rbi->RingDataSize - *write;
4512 +}
4513 +
4514 +/*++
4515 +
4516 +Name:
4517 + GetNextWriteLocation()
4518 +
4519 +Description:
4520 + Get the next write location for the specified ring buffer
4521 +
4522 +--*/
4523 +static inline UINT32
4524 +GetNextWriteLocation(RING_BUFFER_INFO* RingInfo)
4525 +{
4526 + UINT32 next = RingInfo->RingBuffer->WriteIndex;
4527 +
4528 + ASSERT(next < RingInfo->RingDataSize);
4529 +
4530 + return next;
4531 +}
4532 +
4533 +/*++
4534 +
4535 +Name:
4536 + SetNextWriteLocation()
4537 +
4538 +Description:
4539 + Set the next write location for the specified ring buffer
4540 +
4541 +--*/
4542 +static inline void
4543 +SetNextWriteLocation(RING_BUFFER_INFO* RingInfo, UINT32 NextWriteLocation)
4544 +{
4545 + RingInfo->RingBuffer->WriteIndex = NextWriteLocation;
4546 +}
4547 +
4548 +/*++
4549 +
4550 +Name:
4551 + GetNextReadLocation()
4552 +
4553 +Description:
4554 + Get the next read location for the specified ring buffer
4555 +
4556 +--*/
4557 +static inline UINT32
4558 +GetNextReadLocation(RING_BUFFER_INFO* RingInfo)
4559 +{
4560 + UINT32 next = RingInfo->RingBuffer->ReadIndex;
4561 +
4562 + ASSERT(next < RingInfo->RingDataSize);
4563 +
4564 + return next;
4565 +}
4566 +
4567 +/*++
4568 +
4569 +Name:
4570 + GetNextReadLocationWithOffset()
4571 +
4572 +Description:
4573 + Get the next read location + offset for the specified ring buffer.
4574 + This allows the caller to skip
4575 +
4576 +--*/
4577 +static inline UINT32
4578 +GetNextReadLocationWithOffset(RING_BUFFER_INFO* RingInfo, UINT32 Offset)
4579 +{
4580 + UINT32 next = RingInfo->RingBuffer->ReadIndex;
4581 +
4582 + ASSERT(next < RingInfo->RingDataSize);
4583 + next += Offset;
4584 + next %= RingInfo->RingDataSize;
4585 +
4586 + return next;
4587 +}
4588 +
4589 +/*++
4590 +
4591 +Name:
4592 + SetNextReadLocation()
4593 +
4594 +Description:
4595 + Set the next read location for the specified ring buffer
4596 +
4597 +--*/
4598 +static inline void
4599 +SetNextReadLocation(RING_BUFFER_INFO* RingInfo, UINT32 NextReadLocation)
4600 +{
4601 + RingInfo->RingBuffer->ReadIndex = NextReadLocation;
4602 +}
4603 +
4604 +
4605 +/*++
4606 +
4607 +Name:
4608 + GetRingBuffer()
4609 +
4610 +Description:
4611 + Get the start of the ring buffer
4612 +
4613 +--*/
4614 +static inline PVOID
4615 +GetRingBuffer(RING_BUFFER_INFO* RingInfo)
4616 +{
4617 + return (PVOID)RingInfo->RingBuffer->Buffer;
4618 +}
4619 +
4620 +
4621 +/*++
4622 +
4623 +Name:
4624 + GetRingBufferSize()
4625 +
4626 +Description:
4627 + Get the size of the ring buffer
4628 +
4629 +--*/
4630 +static inline UINT32
4631 +GetRingBufferSize(RING_BUFFER_INFO* RingInfo)
4632 +{
4633 + return RingInfo->RingDataSize;
4634 +}
4635 +
4636 +/*++
4637 +
4638 +Name:
4639 + GetRingBufferIndices()
4640 +
4641 +Description:
4642 + Get the read and write indices as UINT64 of the specified ring buffer
4643 +
4644 +--*/
4645 +static inline UINT64
4646 +GetRingBufferIndices(RING_BUFFER_INFO* RingInfo)
4647 +{
4648 + return ((UINT64)RingInfo->RingBuffer->WriteIndex << 32) || RingInfo->RingBuffer->ReadIndex;
4649 +}
4650 +
4651 +
4652 +/*++
4653 +
4654 +Name:
4655 + DumpRingInfo()
4656 +
4657 +Description:
4658 + Dump out to console the ring buffer info
4659 +
4660 +--*/
4661 +void
4662 +DumpRingInfo(RING_BUFFER_INFO* RingInfo, char *Prefix)
4663 +{
4664 + UINT32 bytesAvailToWrite;
4665 + UINT32 bytesAvailToRead;
4666 +
4667 + GetRingBufferAvailBytes(RingInfo, &bytesAvailToRead, &bytesAvailToWrite);
4668 +
4669 + DPRINT(VMBUS, DEBUG_RING_LVL, "%s <<ringinfo %p buffer %p avail write %u avail read %u read idx %u write idx %u>>",
4670 + Prefix,
4671 + RingInfo,
4672 + RingInfo->RingBuffer->Buffer,
4673 + bytesAvailToWrite,
4674 + bytesAvailToRead,
4675 + RingInfo->RingBuffer->ReadIndex,
4676 + RingInfo->RingBuffer->WriteIndex);
4677 +}
4678 +
4679 +//
4680 +// Internal routines
4681 +//
4682 +static UINT32
4683 +CopyToRingBuffer(
4684 + RING_BUFFER_INFO *RingInfo,
4685 + UINT32 StartWriteOffset,
4686 + PVOID Src,
4687 + UINT32 SrcLen);
4688 +
4689 +static UINT32
4690 +CopyFromRingBuffer(
4691 + RING_BUFFER_INFO *RingInfo,
4692 + PVOID Dest,
4693 + UINT32 DestLen,
4694 + UINT32 StartReadOffset);
4695 +
4696 +
4697 +
4698 +/*++
4699 +
4700 +Name:
4701 + RingBufferGetDebugInfo()
4702 +
4703 +Description:
4704 + Get various debug metrics for the specified ring buffer
4705 +
4706 +--*/
4707 +void
4708 +RingBufferGetDebugInfo(
4709 + RING_BUFFER_INFO *RingInfo,
4710 + RING_BUFFER_DEBUG_INFO *DebugInfo
4711 + )
4712 +{
4713 + UINT32 bytesAvailToWrite;
4714 + UINT32 bytesAvailToRead;
4715 +
4716 + if (RingInfo->RingBuffer)
4717 + {
4718 + GetRingBufferAvailBytes(RingInfo, &bytesAvailToRead, &bytesAvailToWrite);
4719 +
4720 + DebugInfo->BytesAvailToRead = bytesAvailToRead;
4721 + DebugInfo->BytesAvailToWrite = bytesAvailToWrite;
4722 + DebugInfo->CurrentReadIndex = RingInfo->RingBuffer->ReadIndex;
4723 + DebugInfo->CurrentWriteIndex = RingInfo->RingBuffer->WriteIndex;
4724 +
4725 + DebugInfo->CurrentInterruptMask = RingInfo->RingBuffer->InterruptMask;
4726 + }
4727 +}
4728 +
4729 +
4730 +/*++
4731 +
4732 +Name:
4733 + GetRingBufferInterruptMask()
4734 +
4735 +Description:
4736 + Get the interrupt mask for the specified ring buffer
4737 +
4738 +--*/
4739 +UINT32
4740 +GetRingBufferInterruptMask(
4741 + RING_BUFFER_INFO *rbi
4742 + )
4743 +{
4744 + return rbi->RingBuffer->InterruptMask;
4745 +}
4746 +
4747 +/*++
4748 +
4749 +Name:
4750 + RingBufferInit()
4751 +
4752 +Description:
4753 + Initialize the ring buffer
4754 +
4755 +--*/
4756 +int
4757 +RingBufferInit(
4758 + RING_BUFFER_INFO *RingInfo,
4759 + VOID *Buffer,
4760 + UINT32 BufferLen
4761 + )
4762 +{
4763 + ASSERT(sizeof(RING_BUFFER) == PAGE_SIZE);
4764 +
4765 + memset(RingInfo, 0, sizeof(RING_BUFFER_INFO));
4766 +
4767 + RingInfo->RingBuffer = (RING_BUFFER*)Buffer;
4768 + RingInfo->RingBuffer->ReadIndex = RingInfo->RingBuffer->WriteIndex = 0;
4769 +
4770 + RingInfo->RingSize = BufferLen;
4771 + RingInfo->RingDataSize = BufferLen - sizeof(RING_BUFFER);
4772 +
4773 + RingInfo->RingLock = SpinlockCreate();
4774 +
4775 + return 0;
4776 +}
4777 +
4778 +/*++
4779 +
4780 +Name:
4781 + RingBufferCleanup()
4782 +
4783 +Description:
4784 + Cleanup the ring buffer
4785 +
4786 +--*/
4787 +void
4788 +RingBufferCleanup(
4789 + RING_BUFFER_INFO* RingInfo
4790 + )
4791 +{
4792 + SpinlockClose(RingInfo->RingLock);
4793 +}
4794 +
4795 +/*++
4796 +
4797 +Name:
4798 + RingBufferWrite()
4799 +
4800 +Description:
4801 + Write to the ring buffer
4802 +
4803 +--*/
4804 +int
4805 +RingBufferWrite(
4806 + RING_BUFFER_INFO* OutRingInfo,
4807 + SG_BUFFER_LIST SgBuffers[],
4808 + UINT32 SgBufferCount
4809 + )
4810 +{
4811 + int i=0;
4812 + UINT32 byteAvailToWrite;
4813 + UINT32 byteAvailToRead;
4814 + UINT32 totalBytesToWrite=0;
4815 +
4816 + volatile UINT32 nextWriteLocation;
4817 + UINT64 prevIndices=0;
4818 +
4819 + DPRINT_ENTER(VMBUS);
4820 +
4821 + for (i=0; i < SgBufferCount; i++)
4822 + {
4823 + totalBytesToWrite += SgBuffers[i].Length;
4824 + }
4825 +
4826 + totalBytesToWrite += sizeof(UINT64);
4827 +
4828 + SpinlockAcquire(OutRingInfo->RingLock);
4829 +
4830 + GetRingBufferAvailBytes(OutRingInfo, &byteAvailToRead, &byteAvailToWrite);
4831 +
4832 + DPRINT_DBG(VMBUS, "Writing %u bytes...", totalBytesToWrite);
4833 +
4834 + //DumpRingInfo(OutRingInfo, "BEFORE ");
4835 +
4836 + // If there is only room for the packet, assume it is full. Otherwise, the next time around, we think the ring buffer
4837 + // is empty since the read index == write index
4838 + if (byteAvailToWrite <= totalBytesToWrite)
4839 + {
4840 + DPRINT_DBG(VMBUS, "No more space left on outbound ring buffer (needed %u, avail %u)", totalBytesToWrite, byteAvailToWrite);
4841 +
4842 + SpinlockRelease(OutRingInfo->RingLock);
4843 +
4844 + DPRINT_EXIT(VMBUS);
4845 +
4846 + return -1;
4847 + }
4848 +
4849 + // Write to the ring buffer
4850 + nextWriteLocation = GetNextWriteLocation(OutRingInfo);
4851 +
4852 + for (i=0; i < SgBufferCount; i++)
4853 + {
4854 + nextWriteLocation = CopyToRingBuffer(OutRingInfo,
4855 + nextWriteLocation,
4856 + SgBuffers[i].Data,
4857 + SgBuffers[i].Length);
4858 + }
4859 +
4860 + // Set previous packet start
4861 + prevIndices = GetRingBufferIndices(OutRingInfo);
4862 +
4863 + nextWriteLocation = CopyToRingBuffer(OutRingInfo,
4864 + nextWriteLocation,
4865 + &prevIndices,
4866 + sizeof(UINT64));
4867 +
4868 + // Make sure we flush all writes before updating the writeIndex
4869 + MemoryFence();
4870 +
4871 + // Now, update the write location
4872 + SetNextWriteLocation(OutRingInfo, nextWriteLocation);
4873 +
4874 + //DumpRingInfo(OutRingInfo, "AFTER ");
4875 +
4876 + SpinlockRelease(OutRingInfo->RingLock);
4877 +
4878 + DPRINT_EXIT(VMBUS);
4879 +
4880 + return 0;
4881 +}
4882 +
4883 +
4884 +/*++
4885 +
4886 +Name:
4887 + RingBufferPeek()
4888 +
4889 +Description:
4890 + Read without advancing the read index
4891 +
4892 +--*/
4893 +int
4894 +RingBufferPeek(
4895 + RING_BUFFER_INFO* InRingInfo,
4896 + void* Buffer,
4897 + UINT32 BufferLen
4898 + )
4899 +{
4900 + UINT32 bytesAvailToWrite;
4901 + UINT32 bytesAvailToRead;
4902 + UINT32 nextReadLocation=0;
4903 +
4904 + SpinlockAcquire(InRingInfo->RingLock);
4905 +
4906 + GetRingBufferAvailBytes(InRingInfo, &bytesAvailToRead, &bytesAvailToWrite);
4907 +
4908 + // Make sure there is something to read
4909 + if (bytesAvailToRead < BufferLen )
4910 + {
4911 + //DPRINT_DBG(VMBUS, "got callback but not enough to read <avail to read %d read size %d>!!", bytesAvailToRead, BufferLen);
4912 +
4913 + SpinlockRelease(InRingInfo->RingLock);
4914 +
4915 + return -1;
4916 + }
4917 +
4918 + // Convert to byte offset
4919 + nextReadLocation = GetNextReadLocation(InRingInfo);
4920 +
4921 + nextReadLocation = CopyFromRingBuffer(InRingInfo,
4922 + Buffer,
4923 + BufferLen,
4924 + nextReadLocation);
4925 +
4926 + SpinlockRelease(InRingInfo->RingLock);
4927 +
4928 + return 0;
4929 +}
4930 +
4931 +
4932 +/*++
4933 +
4934 +Name:
4935 + RingBufferRead()
4936 +
4937 +Description:
4938 + Read and advance the read index
4939 +
4940 +--*/
4941 +int
4942 +RingBufferRead(
4943 + RING_BUFFER_INFO* InRingInfo,
4944 + PVOID Buffer,
4945 + UINT32 BufferLen,
4946 + UINT32 Offset
4947 + )
4948 +{
4949 + UINT32 bytesAvailToWrite;
4950 + UINT32 bytesAvailToRead;
4951 + UINT32 nextReadLocation=0;
4952 + UINT64 prevIndices=0;
4953 +
4954 + ASSERT(BufferLen > 0);
4955 +
4956 + SpinlockAcquire(InRingInfo->RingLock);
4957 +
4958 + GetRingBufferAvailBytes(InRingInfo, &bytesAvailToRead, &bytesAvailToWrite);
4959 +
4960 + DPRINT_DBG(VMBUS, "Reading %u bytes...", BufferLen);
4961 +
4962 + //DumpRingInfo(InRingInfo, "BEFORE ");
4963 +
4964 + // Make sure there is something to read
4965 + if (bytesAvailToRead < BufferLen )
4966 + {
4967 + DPRINT_DBG(VMBUS, "got callback but not enough to read <avail to read %d read size %d>!!", bytesAvailToRead, BufferLen);
4968 +
4969 + SpinlockRelease(InRingInfo->RingLock);
4970 +
4971 + return -1;
4972 + }
4973 +
4974 + nextReadLocation = GetNextReadLocationWithOffset(InRingInfo, Offset);
4975 +
4976 + nextReadLocation = CopyFromRingBuffer(InRingInfo,
4977 + Buffer,
4978 + BufferLen,
4979 + nextReadLocation);
4980 +
4981 + nextReadLocation = CopyFromRingBuffer(InRingInfo,
4982 + &prevIndices,
4983 + sizeof(UINT64),
4984 + nextReadLocation);
4985 +
4986 + // Make sure all reads are done before we update the read index since
4987 + // the writer may start writing to the read area once the read index is updated
4988 + MemoryFence();
4989 +
4990 + // Update the read index
4991 + SetNextReadLocation(InRingInfo, nextReadLocation);
4992 +
4993 + //DumpRingInfo(InRingInfo, "AFTER ");
4994 +
4995 + SpinlockRelease(InRingInfo->RingLock);
4996 +
4997 + return 0;
4998 +}
4999 +
5000 +
5001 +/*++
5002 +
5003 +Name:
5004 + CopyToRingBuffer()
5005 +
5006 +Description:
5007 + Helper routine to copy from source to ring buffer.
5008 + Assume there is enough room. Handles wrap-around in dest case only!!
5009 +
5010 +--*/
5011 +UINT32
5012 +CopyToRingBuffer(
5013 + RING_BUFFER_INFO *RingInfo,
5014 + UINT32 StartWriteOffset,
5015 + PVOID Src,
5016 + UINT32 SrcLen)
5017 +{
5018 + PVOID ringBuffer=GetRingBuffer(RingInfo);
5019 + UINT32 ringBufferSize=GetRingBufferSize(RingInfo);
5020 + UINT32 fragLen;
5021 +
5022 + if (SrcLen > ringBufferSize - StartWriteOffset) // wrap-around detected!
5023 + {
5024 + DPRINT_DBG(VMBUS, "wrap-around detected!");
5025 +
5026 + fragLen = ringBufferSize - StartWriteOffset;
5027 + memcpy(ringBuffer + StartWriteOffset, Src, fragLen);
5028 + memcpy(ringBuffer, Src + fragLen, SrcLen - fragLen);
5029 + }
5030 + else
5031 + {
5032 + memcpy(ringBuffer + StartWriteOffset, Src, SrcLen);
5033 + }
5034 +
5035 + StartWriteOffset += SrcLen;
5036 + StartWriteOffset %= ringBufferSize;
5037 +
5038 + return StartWriteOffset;
5039 +}
5040 +
5041 +
5042 +/*++
5043 +
5044 +Name:
5045 + CopyFromRingBuffer()
5046 +
5047 +Description:
5048 + Helper routine to copy to source from ring buffer.
5049 + Assume there is enough room. Handles wrap-around in src case only!!
5050 +
5051 +--*/
5052 +UINT32
5053 +CopyFromRingBuffer(
5054 + RING_BUFFER_INFO *RingInfo,
5055 + PVOID Dest,
5056 + UINT32 DestLen,
5057 + UINT32 StartReadOffset)
5058 +{
5059 + PVOID ringBuffer=GetRingBuffer(RingInfo);
5060 + UINT32 ringBufferSize=GetRingBufferSize(RingInfo);
5061 +
5062 + UINT32 fragLen;
5063 +
5064 + if (DestLen > ringBufferSize - StartReadOffset) // wrap-around detected at the src
5065 + {
5066 + DPRINT_DBG(VMBUS, "src wrap-around detected!");
5067 +
5068 + fragLen = ringBufferSize - StartReadOffset;
5069 +
5070 + memcpy(Dest, ringBuffer + StartReadOffset, fragLen);
5071 + memcpy(Dest + fragLen, ringBuffer, DestLen - fragLen);
5072 + }
5073 + else
5074 + {
5075 + memcpy(Dest, ringBuffer + StartReadOffset, DestLen);
5076 + }
5077 +
5078 + StartReadOffset += DestLen;
5079 + StartReadOffset %= ringBufferSize;
5080 +
5081 + return StartReadOffset;
5082 +}
5083 +
5084 +
5085 +// eof
5086 --- /dev/null
5087 +++ b/drivers/staging/hv/RingBuffer.h
5088 @@ -0,0 +1,123 @@
5089 +/*
5090 + *
5091 + * Copyright (c) 2009, Microsoft Corporation.
5092 + *
5093 + * This program is free software; you can redistribute it and/or modify it
5094 + * under the terms and conditions of the GNU General Public License,
5095 + * version 2, as published by the Free Software Foundation.
5096 + *
5097 + * This program is distributed in the hope it will be useful, but WITHOUT
5098 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5099 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
5100 + * more details.
5101 + *
5102 + * You should have received a copy of the GNU General Public License along with
5103 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
5104 + * Place - Suite 330, Boston, MA 02111-1307 USA.
5105 + *
5106 + * Authors:
5107 + * Haiyang Zhang <haiyangz@microsoft.com>
5108 + * Hank Janssen <hjanssen@microsoft.com>
5109 + *
5110 + */
5111 +
5112 +
5113 +#ifndef _RING_BUFFER_H_
5114 +#define _RING_BUFFER_H_
5115 +
5116 +#include "osd.h"
5117 +
5118 +typedef struct _SG_BUFFER_LIST {
5119 + PVOID Data;
5120 + UINT32 Length;
5121 +} SG_BUFFER_LIST;
5122 +
5123 +typedef struct _RING_BUFFER {
5124 + volatile UINT32 WriteIndex; // Offset in bytes from the start of ring data below
5125 + volatile UINT32 ReadIndex; // Offset in bytes from the start of ring data below
5126 +
5127 + volatile UINT32 InterruptMask;
5128 + UINT8 Reserved[4084]; // Pad it to PAGE_SIZE so that data starts on page boundary
5129 + // NOTE: The InterruptMask field is used only for channels but since our vmbus connection
5130 + // also uses this data structure and its data starts here, we commented out this field.
5131 + // volatile UINT32 InterruptMask;
5132 + // Ring data starts here + RingDataStartOffset !!! DO NOT place any fields below this !!!
5133 + UINT8 Buffer[0];
5134 +} STRUCT_PACKED RING_BUFFER;
5135 +
5136 +typedef struct _RING_BUFFER_INFO {
5137 + RING_BUFFER* RingBuffer;
5138 + UINT32 RingSize; // Include the shared header
5139 + HANDLE RingLock;
5140 +
5141 + UINT32 RingDataSize; // < ringSize
5142 + UINT32 RingDataStartOffset;
5143 +
5144 +} RING_BUFFER_INFO;
5145 +
5146 +
5147 +typedef struct _RING_BUFFER_DEBUG_INFO {
5148 + UINT32 CurrentInterruptMask;
5149 + UINT32 CurrentReadIndex;
5150 + UINT32 CurrentWriteIndex;
5151 + UINT32 BytesAvailToRead;
5152 + UINT32 BytesAvailToWrite;
5153 +}RING_BUFFER_DEBUG_INFO;
5154 +
5155 +
5156 +//
5157 +// Interface
5158 +//
5159 +
5160 +INTERNAL int
5161 +RingBufferInit(
5162 + RING_BUFFER_INFO *RingInfo,
5163 + PVOID Buffer,
5164 + UINT32 BufferLen
5165 + );
5166 +
5167 +INTERNAL void
5168 +RingBufferCleanup(
5169 + RING_BUFFER_INFO *RingInfo
5170 + );
5171 +
5172 +INTERNAL int
5173 +RingBufferWrite(
5174 + RING_BUFFER_INFO *RingInfo,
5175 + SG_BUFFER_LIST SgBuffers[],
5176 + UINT32 SgBufferCount
5177 + );
5178 +
5179 +INTERNAL int
5180 +RingBufferPeek(
5181 + RING_BUFFER_INFO *RingInfo,
5182 + PVOID Buffer,
5183 + UINT32 BufferLen
5184 + );
5185 +
5186 +INTERNAL int
5187 +RingBufferRead(
5188 + RING_BUFFER_INFO *RingInfo,
5189 + PVOID Buffer,
5190 + UINT32 BufferLen,
5191 + UINT32 Offset
5192 + );
5193 +
5194 +INTERNAL UINT32
5195 +GetRingBufferInterruptMask(
5196 + RING_BUFFER_INFO *RingInfo
5197 + );
5198 +
5199 +INTERNAL void
5200 +DumpRingInfo(
5201 + RING_BUFFER_INFO* RingInfo,
5202 + char *Prefix
5203 + );
5204 +
5205 +INTERNAL void
5206 +RingBufferGetDebugInfo(
5207 + RING_BUFFER_INFO *RingInfo,
5208 + RING_BUFFER_DEBUG_INFO *DebugInfo
5209 + );
5210 +
5211 +#endif // _RING_BUFFER_H_
5212 --- /dev/null
5213 +++ b/drivers/staging/hv/Sources.c
5214 @@ -0,0 +1,31 @@
5215 +/*
5216 + *
5217 + * Copyright (c) 2009, Microsoft Corporation.
5218 + *
5219 + * This program is free software; you can redistribute it and/or modify it
5220 + * under the terms and conditions of the GNU General Public License,
5221 + * version 2, as published by the Free Software Foundation.
5222 + *
5223 + * This program is distributed in the hope it will be useful, but WITHOUT
5224 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5225 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
5226 + * more details.
5227 + *
5228 + * You should have received a copy of the GNU General Public License along with
5229 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
5230 + * Place - Suite 330, Boston, MA 02111-1307 USA.
5231 + *
5232 + * Authors:
5233 + * Haiyang Zhang <haiyangz@microsoft.com>
5234 + * Hank Janssen <hjanssen@microsoft.com>
5235 + *
5236 + */
5237 +
5238 +
5239 +#include "Vmbus.c"
5240 +#include "Hv.c"
5241 +#include "Connection.c"
5242 +#include "Channel.c"
5243 +#include "ChannelMgmt.c"
5244 +#include "ChannelInterface.c"
5245 +#include "RingBuffer.c"
5246 --- /dev/null
5247 +++ b/drivers/staging/hv/VersionInfo.h
5248 @@ -0,0 +1,29 @@
5249 +/*
5250 + *
5251 + * Copyright (c) 2009, Microsoft Corporation.
5252 + *
5253 + * This program is free software; you can redistribute it and/or modify it
5254 + * under the terms and conditions of the GNU General Public License,
5255 + * version 2, as published by the Free Software Foundation.
5256 + *
5257 + * This program is distributed in the hope it will be useful, but WITHOUT
5258 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5259 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
5260 + * more details.
5261 + *
5262 + * You should have received a copy of the GNU General Public License along with
5263 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
5264 + * Place - Suite 330, Boston, MA 02111-1307 USA.
5265 + *
5266 + * Authors:
5267 + * Haiyang Zhang <haiyangz@microsoft.com>
5268 + * Hank Janssen <hjanssen@microsoft.com>
5269 + *
5270 + */
5271 +
5272 +
5273 +#pragma once
5274 +
5275 +const char VersionDate[]=__DATE__;
5276 +const char VersionTime[]=__TIME__;
5277 +const char VersionDesc[]= "Version 2.0";
5278 --- /dev/null
5279 +++ b/drivers/staging/hv/Vmbus.c
5280 @@ -0,0 +1,508 @@
5281 +/*
5282 + *
5283 + * Copyright (c) 2009, Microsoft Corporation.
5284 + *
5285 + * This program is free software; you can redistribute it and/or modify it
5286 + * under the terms and conditions of the GNU General Public License,
5287 + * version 2, as published by the Free Software Foundation.
5288 + *
5289 + * This program is distributed in the hope it will be useful, but WITHOUT
5290 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5291 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
5292 + * more details.
5293 + *
5294 + * You should have received a copy of the GNU General Public License along with
5295 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
5296 + * Place - Suite 330, Boston, MA 02111-1307 USA.
5297 + *
5298 + * Authors:
5299 + * Haiyang Zhang <haiyangz@microsoft.com>
5300 + * Hank Janssen <hjanssen@microsoft.com>
5301 + *
5302 + */
5303 +
5304 +
5305 +#include "logging.h"
5306 +#include "VersionInfo.h"
5307 +#include "VmbusPrivate.h"
5308 +
5309 +//
5310 +// Globals
5311 +//
5312 +static const char* gDriverName="vmbus";
5313 +
5314 +// Windows vmbus does not defined this. We defined this to be consistent with other devices
5315 +//{c5295816-f63a-4d5f-8d1a-4daf999ca185}
5316 +static const GUID gVmbusDeviceType={
5317 + .Data = {0x16, 0x58, 0x29, 0xc5, 0x3a, 0xf6, 0x5f, 0x4d, 0x8d, 0x1a, 0x4d, 0xaf, 0x99, 0x9c, 0xa1, 0x85}
5318 +};
5319 +
5320 +//{ac3760fc-9adf-40aa-9427-a70ed6de95c5}
5321 +static const GUID gVmbusDeviceId={
5322 + .Data = {0xfc, 0x60, 0x37, 0xac, 0xdf, 0x9a, 0xaa, 0x40, 0x94, 0x27, 0xa7, 0x0e, 0xd6, 0xde, 0x95, 0xc5}
5323 +};
5324 +
5325 +static DRIVER_OBJECT* gDriver; // vmbus driver object
5326 +static DEVICE_OBJECT* gDevice; // vmbus root device
5327 +
5328 +
5329 +//
5330 +// Internal routines
5331 +//
5332 +
5333 +static void
5334 +VmbusGetChannelInterface(
5335 + VMBUS_CHANNEL_INTERFACE *Interface
5336 + );
5337 +
5338 +static void
5339 +VmbusGetChannelInfo(
5340 + DEVICE_OBJECT *DeviceObject,
5341 + DEVICE_INFO *DeviceInfo
5342 + );
5343 +
5344 +static void
5345 +VmbusGetChannelOffers(
5346 + void
5347 + );
5348 +
5349 +static int
5350 +VmbusOnDeviceAdd(
5351 + DEVICE_OBJECT *Device,
5352 + void *AdditionalInfo
5353 + );
5354 +
5355 +static int
5356 +VmbusOnDeviceRemove(
5357 + DEVICE_OBJECT* dev
5358 + );
5359 +
5360 +static void
5361 +VmbusOnCleanup(
5362 + DRIVER_OBJECT* drv
5363 + );
5364 +
5365 +static int
5366 +VmbusOnISR(
5367 + DRIVER_OBJECT* drv
5368 + );
5369 +
5370 +static void
5371 +VmbusOnMsgDPC(
5372 + DRIVER_OBJECT* drv
5373 + );
5374 +
5375 +static void
5376 +VmbusOnEventDPC(
5377 + DRIVER_OBJECT* drv
5378 + );
5379 +
5380 +/*++;
5381 +
5382 +Name:
5383 + VmbusInitialize()
5384 +
5385 +Description:
5386 + Main entry point
5387 +
5388 +--*/
5389 +int
5390 +VmbusInitialize(
5391 + DRIVER_OBJECT* drv
5392 + )
5393 +{
5394 + VMBUS_DRIVER_OBJECT* driver = (VMBUS_DRIVER_OBJECT*)drv;
5395 + int ret=0;
5396 +
5397 + DPRINT_ENTER(VMBUS);
5398 +
5399 + DPRINT_INFO(VMBUS, "+++++++ Build Date=%s %s +++++++", VersionDate, VersionTime);
5400 + DPRINT_INFO(VMBUS, "+++++++ Build Description=%s +++++++", VersionDesc);
5401 +
5402 + DPRINT_INFO(VMBUS, "+++++++ Vmbus supported version = %d +++++++", VMBUS_REVISION_NUMBER);
5403 + DPRINT_INFO(VMBUS, "+++++++ Vmbus using SINT %d +++++++", VMBUS_MESSAGE_SINT);
5404 +
5405 + DPRINT_DBG(VMBUS, "sizeof(VMBUS_CHANNEL_PACKET_PAGE_BUFFER)=%d, sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER)=%d",
5406 + sizeof(VMBUS_CHANNEL_PACKET_PAGE_BUFFER), sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER));
5407 +
5408 + drv->name = gDriverName;
5409 + memcpy(&drv->deviceType, &gVmbusDeviceType, sizeof(GUID));
5410 +
5411 + // Setup dispatch table
5412 + driver->Base.OnDeviceAdd = VmbusOnDeviceAdd;
5413 + driver->Base.OnDeviceRemove = VmbusOnDeviceRemove;
5414 + driver->Base.OnCleanup = VmbusOnCleanup;
5415 + driver->OnIsr = VmbusOnISR;
5416 + driver->OnMsgDpc = VmbusOnMsgDPC;
5417 + driver->OnEventDpc = VmbusOnEventDPC;
5418 + driver->GetChannelOffers = VmbusGetChannelOffers;
5419 + driver->GetChannelInterface = VmbusGetChannelInterface;
5420 + driver->GetChannelInfo = VmbusGetChannelInfo;
5421 +
5422 + // Hypervisor initialization...setup hypercall page..etc
5423 + ret = HvInit();
5424 + if (ret != 0)
5425 + {
5426 + DPRINT_ERR(VMBUS, "Unable to initialize the hypervisor - 0x%x", ret);
5427 + }
5428 +
5429 + gDriver = drv;
5430 +
5431 + DPRINT_EXIT(VMBUS);
5432 +
5433 + return ret;
5434 +}
5435 +
5436 +
5437 +/*++;
5438 +
5439 +Name:
5440 + VmbusGetChannelOffers()
5441 +
5442 +Description:
5443 + Retrieve the channel offers from the parent partition
5444 +
5445 +--*/
5446 +
5447 +static void
5448 +VmbusGetChannelOffers(void)
5449 +{
5450 + DPRINT_ENTER(VMBUS);
5451 + VmbusChannelRequestOffers();
5452 + DPRINT_EXIT(VMBUS);
5453 +}
5454 +
5455 +
5456 +/*++;
5457 +
5458 +Name:
5459 + VmbusGetChannelInterface()
5460 +
5461 +Description:
5462 + Get the channel interface
5463 +
5464 +--*/
5465 +static void
5466 +VmbusGetChannelInterface(
5467 + VMBUS_CHANNEL_INTERFACE *Interface
5468 + )
5469 +{
5470 + GetChannelInterface(Interface);
5471 +}
5472 +
5473 +
5474 +/*++;
5475 +
5476 +Name:
5477 + VmbusGetChannelInterface()
5478 +
5479 +Description:
5480 + Get the device info for the specified device object
5481 +
5482 +--*/
5483 +static void
5484 +VmbusGetChannelInfo(
5485 + DEVICE_OBJECT *DeviceObject,
5486 + DEVICE_INFO *DeviceInfo
5487 + )
5488 +{
5489 + GetChannelInfo(DeviceObject, DeviceInfo);
5490 +}
5491 +
5492 +
5493 +
5494 +/*++
5495 +
5496 +Name:
5497 + VmbusCreateChildDevice()
5498 +
5499 +Description:
5500 + Creates the child device on the bus that represents the channel offer
5501 +
5502 +--*/
5503 +
5504 +DEVICE_OBJECT*
5505 +VmbusChildDeviceCreate(
5506 + GUID DeviceType,
5507 + GUID DeviceInstance,
5508 + void *Context)
5509 +{
5510 + VMBUS_DRIVER_OBJECT* vmbusDriver = (VMBUS_DRIVER_OBJECT*)gDriver;
5511 +
5512 + return vmbusDriver->OnChildDeviceCreate(
5513 + DeviceType,
5514 + DeviceInstance,
5515 + Context);
5516 +}
5517 +
5518 +
5519 +/*++
5520 +
5521 +Name:
5522 + VmbusChildDeviceAdd()
5523 +
5524 +Description:
5525 + Registers the child device with the vmbus
5526 +
5527 +--*/
5528 +int
5529 +VmbusChildDeviceAdd(
5530 + DEVICE_OBJECT* ChildDevice)
5531 +{
5532 + VMBUS_DRIVER_OBJECT* vmbusDriver = (VMBUS_DRIVER_OBJECT*)gDriver;
5533 +
5534 + return vmbusDriver->OnChildDeviceAdd(gDevice, ChildDevice);
5535 +}
5536 +
5537 +
5538 +/*++
5539 +
5540 +Name:
5541 + VmbusChildDeviceRemove()
5542 +
5543 +Description:
5544 + Unregisters the child device from the vmbus
5545 +
5546 +--*/
5547 +void
5548 +VmbusChildDeviceRemove(
5549 + DEVICE_OBJECT* ChildDevice)
5550 +{
5551 + VMBUS_DRIVER_OBJECT* vmbusDriver = (VMBUS_DRIVER_OBJECT*)gDriver;
5552 +
5553 + vmbusDriver->OnChildDeviceRemove(ChildDevice);
5554 +}
5555 +
5556 +/*++
5557 +
5558 +Name:
5559 + VmbusChildDeviceDestroy()
5560 +
5561 +Description:
5562 + Release the child device from the vmbus
5563 +
5564 +--*/
5565 +//void
5566 +//VmbusChildDeviceDestroy(
5567 +// DEVICE_OBJECT* ChildDevice
5568 +// )
5569 +//{
5570 +// VMBUS_DRIVER_OBJECT* vmbusDriver = (VMBUS_DRIVER_OBJECT*)gDriver;
5571 +//
5572 +// vmbusDriver->OnChildDeviceDestroy(ChildDevice);
5573 +//}
5574 +
5575 +/*++
5576 +
5577 +Name:
5578 + VmbusOnDeviceAdd()
5579 +
5580 +Description:
5581 + Callback when the root bus device is added
5582 +
5583 +--*/
5584 +static int
5585 +VmbusOnDeviceAdd(
5586 + DEVICE_OBJECT *dev,
5587 + void *AdditionalInfo
5588 + )
5589 +{
5590 + UINT32 *irqvector = (UINT32*) AdditionalInfo;
5591 + int ret=0;
5592 +
5593 + DPRINT_ENTER(VMBUS);
5594 +
5595 + gDevice = dev;
5596 +
5597 + memcpy(&gDevice->deviceType, &gVmbusDeviceType, sizeof(GUID));
5598 + memcpy(&gDevice->deviceInstance, &gVmbusDeviceId, sizeof(GUID));
5599 +
5600 + //strcpy(dev->name, "vmbus");
5601 + // SynIC setup...
5602 + ret = HvSynicInit(*irqvector);
5603 +
5604 + // Connect to VMBus in the root partition
5605 + ret = VmbusConnect();
5606 +
5607 + //VmbusSendEvent(device->localPortId+1);
5608 + DPRINT_EXIT(VMBUS);
5609 +
5610 + return ret;
5611 +}
5612 +
5613 +
5614 +/*++
5615 +
5616 +Name:
5617 + VmbusOnDeviceRemove()
5618 +
5619 +Description:
5620 + Callback when the root bus device is removed
5621 +
5622 +--*/
5623 +int VmbusOnDeviceRemove(
5624 + DEVICE_OBJECT* dev
5625 + )
5626 +{
5627 + int ret=0;
5628 +
5629 + DPRINT_ENTER(VMBUS);
5630 +
5631 + VmbusChannelReleaseUnattachedChannels();
5632 +
5633 + VmbusDisconnect();
5634 +
5635 + HvSynicCleanup();
5636 +
5637 + DPRINT_EXIT(VMBUS);
5638 +
5639 + return ret;
5640 +}
5641 +
5642 +
5643 +/*++
5644 +
5645 +Name:
5646 + VmbusOnCleanup()
5647 +
5648 +Description:
5649 + Perform any cleanup when the driver is removed
5650 +
5651 +--*/
5652 +void
5653 +VmbusOnCleanup(
5654 + DRIVER_OBJECT* drv
5655 + )
5656 +{
5657 + //VMBUS_DRIVER_OBJECT* driver = (VMBUS_DRIVER_OBJECT*)drv;
5658 +
5659 + DPRINT_ENTER(VMBUS);
5660 +
5661 + HvCleanup();
5662 +
5663 + DPRINT_EXIT(VMBUS);
5664 +}
5665 +
5666 +
5667 +/*++
5668 +
5669 +Name:
5670 + VmbusOnMsgDPC()
5671 +
5672 +Description:
5673 + DPC routine to handle messages from the hypervisior
5674 +
5675 +--*/
5676 +void
5677 +VmbusOnMsgDPC(
5678 + DRIVER_OBJECT* drv
5679 + )
5680 +{
5681 + void *page_addr = gHvContext.synICMessagePage[0];
5682 +
5683 + HV_MESSAGE* msg = (HV_MESSAGE*)page_addr + VMBUS_MESSAGE_SINT;
5684 + HV_MESSAGE *copied;
5685 + while (1)
5686 + {
5687 + if (msg->Header.MessageType == HvMessageTypeNone) // no msg
5688 + {
5689 + break;
5690 + }
5691 + else
5692 + {
5693 + copied = MemAllocAtomic(sizeof(HV_MESSAGE));
5694 + if (copied == NULL)
5695 + {
5696 + continue;
5697 + }
5698 +
5699 + memcpy(copied, msg, sizeof(HV_MESSAGE));
5700 + WorkQueueQueueWorkItem(gVmbusConnection.WorkQueue, VmbusOnChannelMessage, (void*)copied);
5701 + }
5702 +
5703 + msg->Header.MessageType = HvMessageTypeNone;
5704 +
5705 + // Make sure the write to MessageType (ie set to HvMessageTypeNone) happens
5706 + // before we read the MessagePending and EOMing. Otherwise, the EOMing will not deliver
5707 + // any more messages since there is no empty slot
5708 + MemoryFence();
5709 +
5710 + if (msg->Header.MessageFlags.MessagePending)
5711 + {
5712 + // This will cause message queue rescan to possibly deliver another msg from the hypervisor
5713 + WriteMsr(HV_X64_MSR_EOM, 0);
5714 + }
5715 + }
5716 +}
5717 +
5718 +/*++
5719 +
5720 +Name:
5721 + VmbusOnEventDPC()
5722 +
5723 +Description:
5724 + DPC routine to handle events from the hypervisior
5725 +
5726 +--*/
5727 +void
5728 +VmbusOnEventDPC(
5729 + DRIVER_OBJECT* drv
5730 + )
5731 +{
5732 + // TODO: Process any events
5733 + VmbusOnEvents();
5734 +}
5735 +
5736 +
5737 +/*++
5738 +
5739 +Name:
5740 + VmbusOnISR()
5741 +
5742 +Description:
5743 + ISR routine
5744 +
5745 +--*/
5746 +int
5747 +VmbusOnISR(
5748 + DRIVER_OBJECT* drv
5749 + )
5750 +{
5751 + //VMBUS_DRIVER_OBJECT* driver = (VMBUS_DRIVER_OBJECT*)drv;
5752 +
5753 + int ret=0;
5754 + //struct page* page;
5755 + void *page_addr;
5756 + HV_MESSAGE* msg;
5757 + HV_SYNIC_EVENT_FLAGS* event;
5758 +
5759 + //page = SynICMessagePage[0];
5760 + //page_addr = page_address(page);
5761 + page_addr = gHvContext.synICMessagePage[0];
5762 + msg = (HV_MESSAGE*)page_addr + VMBUS_MESSAGE_SINT;
5763 +
5764 + DPRINT_ENTER(VMBUS);
5765 +
5766 + // Check if there are actual msgs to be process
5767 + if (msg->Header.MessageType != HvMessageTypeNone)
5768 + {
5769 + DPRINT_DBG(VMBUS, "received msg type %d size %d", msg->Header.MessageType, msg->Header.PayloadSize);
5770 + ret |= 0x1;
5771 + }
5772 +
5773 + // TODO: Check if there are events to be process
5774 + page_addr = gHvContext.synICEventPage[0];
5775 + event = (HV_SYNIC_EVENT_FLAGS*)page_addr + VMBUS_MESSAGE_SINT;
5776 +
5777 + // Since we are a child, we only need to check bit 0
5778 + if (BitTestAndClear(&event->Flags32[0], 0))
5779 + {
5780 + DPRINT_DBG(VMBUS, "received event %d", event->Flags32[0]);
5781 + ret |= 0x2;
5782 + }
5783 +
5784 + DPRINT_EXIT(VMBUS);
5785 + return ret;
5786 +}
5787 +
5788 +// eof
5789 --- /dev/null
5790 +++ b/drivers/staging/hv/vmbus_drv.c
5791 @@ -0,0 +1,1228 @@
5792 +/*
5793 + *
5794 + * Copyright (c) 2009, Microsoft Corporation.
5795 + *
5796 + * This program is free software; you can redistribute it and/or modify it
5797 + * under the terms and conditions of the GNU General Public License,
5798 + * version 2, as published by the Free Software Foundation.
5799 + *
5800 + * This program is distributed in the hope it will be useful, but WITHOUT
5801 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5802 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
5803 + * more details.
5804 + *
5805 + * You should have received a copy of the GNU General Public License along with
5806 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
5807 + * Place - Suite 330, Boston, MA 02111-1307 USA.
5808 + *
5809 + * Authors:
5810 + * Haiyang Zhang <haiyangz@microsoft.com>
5811 + * Hank Janssen <hjanssen@microsoft.com>
5812 + *
5813 + */
5814 +
5815 +
5816 +#include <linux/init.h>
5817 +#include <linux/module.h>
5818 +#include <linux/device.h>
5819 +#include <linux/irq.h>
5820 +#include <linux/interrupt.h>
5821 +#include <linux/sysctl.h>
5822 +
5823 +#include "logging.h"
5824 +#include "vmbus.h"
5825 +
5826 +//
5827 +// Defines
5828 +//
5829 +
5830 +// FIXME! We need to do this dynamically for PIC and APIC system
5831 +#define VMBUS_IRQ 0x5
5832 +#ifdef KERNEL_2_6_27
5833 +#define VMBUS_IRQ_VECTOR IRQ5_VECTOR
5834 +#endif
5835 +//
5836 +// Data types
5837 +//
5838 +
5839 +// Main vmbus driver data structure
5840 +struct vmbus_driver_context {
5841 + // !! These must be the first 2 fields !!
5842 + // The driver field is not used in here. Instead, the bus field is
5843 + // used to represent the driver
5844 + struct driver_context drv_ctx;
5845 + VMBUS_DRIVER_OBJECT drv_obj;
5846 +
5847 + struct bus_type bus;
5848 + struct tasklet_struct msg_dpc;
5849 + struct tasklet_struct event_dpc;
5850 +
5851 + // The bus root device
5852 + struct device_context device_ctx;
5853 +};
5854 +
5855 +//
5856 +// Static decl
5857 +//
5858 +static int vmbus_match(struct device *device, struct device_driver *driver);
5859 +static int vmbus_probe(struct device *device);
5860 +static int vmbus_remove(struct device *device);
5861 +static void vmbus_shutdown(struct device *device);
5862 +#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
5863 +#elif defined(KERNEL_2_6_27)
5864 +static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env);
5865 +#else
5866 +static int vmbus_uevent(struct device *device, char **envp, int num_envp, char *buffer, int buffer_size);
5867 +#endif
5868 +static void vmbus_msg_dpc(unsigned long data);
5869 +static void vmbus_event_dpc(unsigned long data);
5870 +
5871 +#ifdef KERNEL_2_6_27
5872 +static irqreturn_t vmbus_isr(int irq, void* dev_id);
5873 +#else
5874 +static int vmbus_isr(int irq, void* dev_id, struct pt_regs *regs);
5875 +#endif
5876 +
5877 +static void vmbus_device_release(struct device *device);
5878 +static void vmbus_bus_release(struct device *device);
5879 +
5880 +static DEVICE_OBJECT* vmbus_child_device_create(GUID type, GUID instance, void* context);
5881 +static void vmbus_child_device_destroy(DEVICE_OBJECT* device_obj);
5882 +static int vmbus_child_device_register(DEVICE_OBJECT* root_device_obj, DEVICE_OBJECT* child_device_obj);
5883 +static void vmbus_child_device_unregister(DEVICE_OBJECT* child_device_obj);
5884 +static void vmbus_child_device_get_info(DEVICE_OBJECT *device_obj, DEVICE_INFO *device_info);
5885 +
5886 +//static ssize_t vmbus_show_class_id(struct device *dev, struct device_attribute *attr, char *buf);
5887 +//static ssize_t vmbus_show_device_id(struct device *dev, struct device_attribute *attr, char *buf);
5888 +
5889 +static ssize_t vmbus_show_device_attr(struct device *dev, struct device_attribute *dev_attr, char *buf);
5890 +
5891 +//
5892 +// Global
5893 +//
5894 +
5895 +// Global logging setting
5896 +
5897 +//unsigned int vmbus_loglevel= (((VMBUS | VMBUS_DRV)<<16) | DEBUG_LVL_ENTEREXIT);
5898 +//unsigned int vmbus_loglevel= (ALL_MODULES << 16 | DEBUG_LVL_ENTEREXIT);
5899 +unsigned int vmbus_loglevel= (ALL_MODULES << 16 | INFO_LVL);
5900 +EXPORT_SYMBOL(vmbus_loglevel);
5901 +
5902 +static int vmbus_irq = VMBUS_IRQ;
5903 +
5904 +// Setup /proc/sys/bus/vmbus/vmbus_loglevel
5905 +// Allow usage of sysctl cmd to set the logging level
5906 +static struct ctl_table_header *vmbus_ctl_table_hdr;
5907 +
5908 +static ctl_table vmbus_dev_ctl_table[] = {
5909 + { .ctl_name = 8461,
5910 + .procname = "vmbus_loglevel",
5911 + .data = &vmbus_loglevel,
5912 + .maxlen = sizeof(vmbus_loglevel),
5913 + .mode = 0644,
5914 + .proc_handler = &proc_dointvec },
5915 + { }
5916 +};
5917 +
5918 +static ctl_table vmbus_ctl_table[] = {
5919 + { .ctl_name = CTL_DEV,
5920 + .procname = "vmbus",
5921 + .mode = 0555,
5922 + .child = vmbus_dev_ctl_table },
5923 + { }
5924 +};
5925 +
5926 +static ctl_table vmus_root_ctl_table[] = {
5927 + { .ctl_name = CTL_BUS,
5928 + .procname = "bus",
5929 + .mode = 0555,
5930 + .child = vmbus_ctl_table },
5931 + { }
5932 +};
5933 +
5934 +#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
5935 +#else
5936 +//
5937 +// Set up per device attributes in /sys/bus/vmbus/devices/<bus device>
5938 +//
5939 +static struct device_attribute vmbus_device_attrs[] = {
5940 + __ATTR(id, S_IRUGO, vmbus_show_device_attr, NULL),
5941 + __ATTR(state, S_IRUGO, vmbus_show_device_attr, NULL),
5942 + __ATTR(class_id, S_IRUGO, vmbus_show_device_attr, NULL),
5943 + __ATTR(device_id, S_IRUGO, vmbus_show_device_attr, NULL),
5944 + __ATTR(monitor_id, S_IRUGO, vmbus_show_device_attr, NULL),
5945 +
5946 + __ATTR(server_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
5947 + __ATTR(server_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
5948 + __ATTR(server_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
5949 +
5950 + __ATTR(client_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
5951 + __ATTR(client_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
5952 + __ATTR(client_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
5953 +
5954 + __ATTR(out_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
5955 + __ATTR(out_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
5956 + __ATTR(out_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
5957 + __ATTR(out_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
5958 + __ATTR(out_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
5959 +
5960 + __ATTR(in_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
5961 + __ATTR(in_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
5962 + __ATTR(in_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
5963 + __ATTR(in_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
5964 + __ATTR(in_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
5965 + __ATTR_NULL
5966 +};
5967 +#endif
5968 +
5969 +// The one and only one
5970 +static struct vmbus_driver_context g_vmbus_drv={
5971 + .bus.name = "vmbus",
5972 + .bus.match = vmbus_match,
5973 +#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
5974 +#else
5975 + .bus.shutdown = vmbus_shutdown,
5976 + .bus.remove = vmbus_remove,
5977 + .bus.probe = vmbus_probe,
5978 + .bus.uevent = vmbus_uevent,
5979 + .bus.dev_attrs = vmbus_device_attrs,
5980 +#endif
5981 +};
5982 +
5983 +//
5984 +// Routines
5985 +//
5986 +
5987 +
5988 +/*++
5989 +
5990 +Name: vmbus_show_device_attr()
5991 +
5992 +Desc: Show the device attribute in sysfs. This is invoked when user does a "cat /sys/bus/vmbus/devices/<bus device>/<attr name>"
5993 +
5994 +--*/
5995 +static ssize_t vmbus_show_device_attr(struct device *dev, struct device_attribute *dev_attr, char *buf)
5996 +{
5997 + struct device_context *device_ctx = device_to_device_context(dev);
5998 + DEVICE_INFO device_info;
5999 +
6000 + memset(&device_info, 0, sizeof(DEVICE_INFO));
6001 +
6002 + vmbus_child_device_get_info(&device_ctx->device_obj, &device_info);
6003 +
6004 + if (!strcmp(dev_attr->attr.name, "class_id"))
6005 + {
6006 + return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n",
6007 + device_info.ChannelType.Data[3], device_info.ChannelType.Data[2], device_info.ChannelType.Data[1], device_info.ChannelType.Data[0],
6008 + device_info.ChannelType.Data[5], device_info.ChannelType.Data[4],
6009 + device_info.ChannelType.Data[7], device_info.ChannelType.Data[6],
6010 + 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]);
6011 +
6012 + }
6013 + else if (!strcmp(dev_attr->attr.name, "device_id"))
6014 + {
6015 + return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n",
6016 + device_info.ChannelInstance.Data[3], device_info.ChannelInstance.Data[2], device_info.ChannelInstance.Data[1], device_info.ChannelInstance.Data[0],
6017 + device_info.ChannelInstance.Data[5], device_info.ChannelInstance.Data[4],
6018 + device_info.ChannelInstance.Data[7], device_info.ChannelInstance.Data[6],
6019 + 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]);
6020 + }
6021 + else if (!strcmp(dev_attr->attr.name, "state"))
6022 + {
6023 + return sprintf(buf, "%d\n", device_info.ChannelState);
6024 + }
6025 + else if (!strcmp(dev_attr->attr.name, "id"))
6026 + {
6027 + return sprintf(buf, "%d\n", device_info.ChannelId);
6028 + }
6029 + else if (!strcmp(dev_attr->attr.name, "out_intr_mask"))
6030 + {
6031 + return sprintf(buf, "%d\n", device_info.Outbound.InterruptMask);
6032 + }
6033 + else if (!strcmp(dev_attr->attr.name, "out_read_index"))
6034 + {
6035 + return sprintf(buf, "%d\n", device_info.Outbound.ReadIndex);
6036 + }
6037 + else if (!strcmp(dev_attr->attr.name, "out_write_index"))
6038 + {
6039 + return sprintf(buf, "%d\n", device_info.Outbound.WriteIndex);
6040 + }
6041 + else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail"))
6042 + {
6043 + return sprintf(buf, "%d\n", device_info.Outbound.BytesAvailToRead);
6044 + }
6045 + else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail"))
6046 + {
6047 + return sprintf(buf, "%d\n", device_info.Outbound.BytesAvailToWrite);
6048 + }
6049 + else if (!strcmp(dev_attr->attr.name, "in_intr_mask"))
6050 + {
6051 + return sprintf(buf, "%d\n", device_info.Inbound.InterruptMask);
6052 + }
6053 + else if (!strcmp(dev_attr->attr.name, "in_read_index"))
6054 + {
6055 + return sprintf(buf, "%d\n", device_info.Inbound.ReadIndex);
6056 + }
6057 + else if (!strcmp(dev_attr->attr.name, "in_write_index"))
6058 + {
6059 + return sprintf(buf, "%d\n", device_info.Inbound.WriteIndex);
6060 + }
6061 + else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail"))
6062 + {
6063 + return sprintf(buf, "%d\n", device_info.Inbound.BytesAvailToRead);
6064 + }
6065 + else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail"))
6066 + {
6067 + return sprintf(buf, "%d\n", device_info.Inbound.BytesAvailToWrite);
6068 + }
6069 + else if (!strcmp(dev_attr->attr.name, "monitor_id"))
6070 + {
6071 + return sprintf(buf, "%d\n", device_info.MonitorId);
6072 + }
6073 + else if (!strcmp(dev_attr->attr.name, "server_monitor_pending"))
6074 + {
6075 + return sprintf(buf, "%d\n", device_info.ServerMonitorPending);
6076 + }
6077 + else if (!strcmp(dev_attr->attr.name, "server_monitor_latency"))
6078 + {
6079 + return sprintf(buf, "%d\n", device_info.ServerMonitorLatency);
6080 + }
6081 + else if (!strcmp(dev_attr->attr.name, "server_monitor_conn_id"))
6082 + {
6083 + return sprintf(buf, "%d\n", device_info.ServerMonitorConnectionId);
6084 + }
6085 + else if (!strcmp(dev_attr->attr.name, "client_monitor_pending"))
6086 + {
6087 + return sprintf(buf, "%d\n", device_info.ClientMonitorPending);
6088 + }
6089 + else if (!strcmp(dev_attr->attr.name, "client_monitor_latency"))
6090 + {
6091 + return sprintf(buf, "%d\n", device_info.ClientMonitorLatency);
6092 + }
6093 + else if (!strcmp(dev_attr->attr.name, "client_monitor_conn_id"))
6094 + {
6095 + return sprintf(buf, "%d\n", device_info.ClientMonitorConnectionId);
6096 + }
6097 + else
6098 + {
6099 + return 0;
6100 + }
6101 +}
6102 +
6103 +/*++
6104 +
6105 +Name: vmbus_show_class_id()
6106 +
6107 +Desc: Show the device class id in sysfs
6108 +
6109 +--*/
6110 +//static ssize_t vmbus_show_class_id(struct device *dev, struct device_attribute *attr, char *buf)
6111 +//{
6112 +// struct device_context *device_ctx = device_to_device_context(dev);
6113 +// return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n",
6114 +// device_ctx->class_id[3], device_ctx->class_id[2], device_ctx->class_id[1], device_ctx->class_id[0],
6115 +// device_ctx->class_id[5], device_ctx->class_id[4],
6116 +// device_ctx->class_id[7], device_ctx->class_id[6],
6117 +// 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]);
6118 +//}
6119 +
6120 +/*++
6121 +
6122 +Name: vmbus_show_device_id()
6123 +
6124 +Desc: Show the device instance id in sysfs
6125 +
6126 +--*/
6127 +//static ssize_t vmbus_show_device_id(struct device *dev, struct device_attribute *attr, char *buf)
6128 +//{
6129 +// struct device_context *device_ctx = device_to_device_context(dev);
6130 +// return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}\n",
6131 +// device_ctx->device_id[3], device_ctx->device_id[2], device_ctx->device_id[1], device_ctx->device_id[0],
6132 +// device_ctx->device_id[5], device_ctx->device_id[4],
6133 +// device_ctx->device_id[7], device_ctx->device_id[6],
6134 +// 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]);
6135 +//}
6136 +
6137 +/*++
6138 +
6139 +Name: vmbus_bus_init()
6140 +
6141 +Desc: Main vmbus driver initialization routine. Here, we
6142 + - initialize the vmbus driver context
6143 + - setup various driver entry points
6144 + - invoke the vmbus hv main init routine
6145 + - get the irq resource
6146 + - invoke the vmbus to add the vmbus root device
6147 + - setup the vmbus root device
6148 + - retrieve the channel offers
6149 +--*/
6150 +int vmbus_bus_init(PFN_DRIVERINITIALIZE pfn_drv_init)
6151 +{
6152 + int ret=0;
6153 + unsigned int vector=0;
6154 +
6155 + struct vmbus_driver_context *vmbus_drv_ctx=&g_vmbus_drv;
6156 + VMBUS_DRIVER_OBJECT *vmbus_drv_obj=&g_vmbus_drv.drv_obj;
6157 +
6158 + struct device_context *dev_ctx=&g_vmbus_drv.device_ctx;
6159 +
6160 + DPRINT_ENTER(VMBUS_DRV);
6161 +
6162 + // Set this up to allow lower layer to callback to add/remove child devices on the bus
6163 + vmbus_drv_obj->OnChildDeviceCreate = vmbus_child_device_create;
6164 + vmbus_drv_obj->OnChildDeviceDestroy = vmbus_child_device_destroy;
6165 + vmbus_drv_obj->OnChildDeviceAdd = vmbus_child_device_register;
6166 + vmbus_drv_obj->OnChildDeviceRemove = vmbus_child_device_unregister;
6167 +
6168 + // Call to bus driver to initialize
6169 + ret = pfn_drv_init(&vmbus_drv_obj->Base);
6170 + if (ret != 0)
6171 + {
6172 + DPRINT_ERR(VMBUS_DRV, "Unable to initialize vmbus (%d)", ret);
6173 + goto cleanup;
6174 + }
6175 +
6176 + // Sanity checks
6177 + if (!vmbus_drv_obj->Base.OnDeviceAdd)
6178 + {
6179 + DPRINT_ERR(VMBUS_DRV, "OnDeviceAdd() routine not set");
6180 + ret = -1;
6181 + goto cleanup;
6182 + }
6183 +
6184 + vmbus_drv_ctx->bus.name = vmbus_drv_obj->Base.name;
6185 +
6186 + // Initialize the bus context
6187 + tasklet_init(&vmbus_drv_ctx->msg_dpc, vmbus_msg_dpc, (unsigned long)vmbus_drv_obj);
6188 + tasklet_init(&vmbus_drv_ctx->event_dpc, vmbus_event_dpc, (unsigned long)vmbus_drv_obj);
6189 +
6190 + // Now, register the bus driver with LDM
6191 + bus_register(&vmbus_drv_ctx->bus);
6192 +
6193 + // Get the interrupt resource
6194 +#ifdef KERNEL_2_6_27
6195 + ret = request_irq(vmbus_irq,
6196 + vmbus_isr,
6197 + IRQF_SAMPLE_RANDOM,
6198 + vmbus_drv_obj->Base.name,
6199 + NULL);
6200 +#else
6201 + ret = request_irq(vmbus_irq,
6202 + vmbus_isr,
6203 + SA_SAMPLE_RANDOM,
6204 + vmbus_drv_obj->Base.name,
6205 + NULL);
6206 +#endif
6207 +
6208 + if (ret != 0)
6209 + {
6210 + DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to request IRQ %d", vmbus_irq);
6211 +
6212 + bus_unregister(&vmbus_drv_ctx->bus);
6213 +
6214 + ret = -1;
6215 + goto cleanup;
6216 + }
6217 +#ifdef KERNEL_2_6_27
6218 + vector = VMBUS_IRQ_VECTOR;
6219 +#else
6220 +#if X2V_LINUX
6221 + vector = vmbus_irq + FIRST_DEVICE_VECTOR - 2;
6222 +#else
6223 + vector = vmbus_irq + FIRST_EXTERNAL_VECTOR;
6224 +#endif
6225 +#endif
6226 +
6227 + DPRINT_INFO(VMBUS_DRV, "irq 0x%x vector 0x%x", vmbus_irq, vector);
6228 +
6229 + // Call to bus driver to add the root device
6230 + memset(dev_ctx, 0, sizeof(struct device_context));
6231 +
6232 + ret = vmbus_drv_obj->Base.OnDeviceAdd(&dev_ctx->device_obj, &vector);
6233 + if (ret != 0)
6234 + {
6235 + DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to add vmbus root device");
6236 +
6237 + free_irq(vmbus_irq, NULL);
6238 +
6239 + bus_unregister(&vmbus_drv_ctx->bus);
6240 +
6241 + ret = -1;
6242 + goto cleanup;
6243 + }
6244 + //strcpy(dev_ctx->device.bus_id, dev_ctx->device_obj.name);
6245 + sprintf(dev_ctx->device.bus_id, "vmbus_0_0");
6246 + memcpy(&dev_ctx->class_id, &dev_ctx->device_obj.deviceType, sizeof(GUID));
6247 + memcpy(&dev_ctx->device_id, &dev_ctx->device_obj.deviceInstance, sizeof(GUID));
6248 +
6249 + // No need to bind a driver to the root device.
6250 + dev_ctx->device.parent = NULL;
6251 + dev_ctx->device.bus = &vmbus_drv_ctx->bus; //NULL; // vmbus_remove() does not get invoked
6252 +
6253 + // Setup the device dispatch table
6254 + dev_ctx->device.release = vmbus_bus_release;
6255 +
6256 + // Setup the bus as root device
6257 + device_register(&dev_ctx->device);
6258 +
6259 + vmbus_drv_obj->GetChannelOffers();
6260 +
6261 +cleanup:
6262 + DPRINT_EXIT(VMBUS_DRV);
6263 +
6264 + return ret;
6265 +}
6266 +
6267 +
6268 +/*++
6269 +
6270 +Name: vmbus_bus_exit()
6271 +
6272 +Desc: Terminate the vmbus driver. This routine is opposite of vmbus_bus_init()
6273 +
6274 +--*/
6275 +void vmbus_bus_exit(void)
6276 +{
6277 + VMBUS_DRIVER_OBJECT *vmbus_drv_obj=&g_vmbus_drv.drv_obj;
6278 + struct vmbus_driver_context *vmbus_drv_ctx=&g_vmbus_drv;
6279 +
6280 + struct device_context *dev_ctx=&g_vmbus_drv.device_ctx;
6281 +
6282 + DPRINT_ENTER(VMBUS_DRV);
6283 +
6284 + // Remove the root device
6285 + if (vmbus_drv_obj->Base.OnDeviceRemove)
6286 + vmbus_drv_obj->Base.OnDeviceRemove(&dev_ctx->device_obj);
6287 +
6288 + if (vmbus_drv_obj->Base.OnCleanup)
6289 + vmbus_drv_obj->Base.OnCleanup(&vmbus_drv_obj->Base);
6290 +
6291 + // Unregister the root bus device
6292 + device_unregister(&dev_ctx->device);
6293 +
6294 + bus_unregister(&vmbus_drv_ctx->bus);
6295 +
6296 + free_irq(vmbus_irq, NULL);
6297 +
6298 + tasklet_kill(&vmbus_drv_ctx->msg_dpc);
6299 + tasklet_kill(&vmbus_drv_ctx->event_dpc);
6300 +
6301 + DPRINT_EXIT(VMBUS_DRV);
6302 +
6303 + return;
6304 +}
6305 +
6306 +/*++
6307 +
6308 +Name: vmbus_child_driver_register()
6309 +
6310 +Desc: Register a vmbus's child driver
6311 +
6312 +--*/
6313 +void vmbus_child_driver_register(struct driver_context* driver_ctx)
6314 +{
6315 + VMBUS_DRIVER_OBJECT *vmbus_drv_obj=&g_vmbus_drv.drv_obj;
6316 +
6317 + DPRINT_ENTER(VMBUS_DRV);
6318 +
6319 + DPRINT_INFO(VMBUS_DRV, "child driver (%p) registering - name %s", driver_ctx, driver_ctx->driver.name);
6320 +
6321 + // The child driver on this vmbus
6322 + driver_ctx->driver.bus = &g_vmbus_drv.bus;
6323 +
6324 + driver_register(&driver_ctx->driver);
6325 +
6326 + vmbus_drv_obj->GetChannelOffers();
6327 +
6328 + DPRINT_EXIT(VMBUS_DRV);
6329 +}
6330 +
6331 +EXPORT_SYMBOL(vmbus_child_driver_register);
6332 +
6333 +/*++
6334 +
6335 +Name: vmbus_child_driver_unregister()
6336 +
6337 +Desc: Unregister a vmbus's child driver
6338 +
6339 +--*/
6340 +void vmbus_child_driver_unregister(struct driver_context* driver_ctx)
6341 +{
6342 + DPRINT_ENTER(VMBUS_DRV);
6343 +
6344 + DPRINT_INFO(VMBUS_DRV, "child driver (%p) unregistering - name %s", driver_ctx, driver_ctx->driver.name);
6345 +
6346 + driver_unregister(&driver_ctx->driver);
6347 +
6348 + driver_ctx->driver.bus = NULL;
6349 +
6350 + DPRINT_EXIT(VMBUS_DRV);
6351 +}
6352 +
6353 +EXPORT_SYMBOL(vmbus_child_driver_unregister);
6354 +
6355 +/*++
6356 +
6357 +Name: vmbus_get_interface()
6358 +
6359 +Desc: Get the vmbus channel interface. This is invoked by child/client driver that sits
6360 + above vmbus
6361 +--*/
6362 +void vmbus_get_interface(VMBUS_CHANNEL_INTERFACE *interface)
6363 +{
6364 + VMBUS_DRIVER_OBJECT *vmbus_drv_obj=&g_vmbus_drv.drv_obj;
6365 +
6366 + vmbus_drv_obj->GetChannelInterface(interface);
6367 +}
6368 +
6369 +EXPORT_SYMBOL(vmbus_get_interface);
6370 +
6371 +
6372 +/*++
6373 +
6374 +Name: vmbus_child_device_get_info()
6375 +
6376 +Desc: Get the vmbus child device info. This is invoked to display various device attributes in sysfs.
6377 +--*/
6378 +static void vmbus_child_device_get_info(DEVICE_OBJECT *device_obj, DEVICE_INFO *device_info)
6379 +{
6380 + VMBUS_DRIVER_OBJECT *vmbus_drv_obj=&g_vmbus_drv.drv_obj;
6381 +
6382 + vmbus_drv_obj->GetChannelInfo(device_obj, device_info);
6383 +}
6384 +
6385 +
6386 +/*++
6387 +
6388 +Name: vmbus_child_device_create()
6389 +
6390 +Desc: Creates and registers a new child device on the vmbus.
6391 +
6392 +--*/
6393 +static DEVICE_OBJECT* vmbus_child_device_create(GUID type, GUID instance, void* context)
6394 +{
6395 + struct device_context *child_device_ctx;
6396 + DEVICE_OBJECT* child_device_obj;
6397 +
6398 + DPRINT_ENTER(VMBUS_DRV);
6399 +
6400 + // Allocate the new child device
6401 + child_device_ctx = kzalloc(sizeof(struct device_context), GFP_KERNEL);
6402 + if (!child_device_ctx)
6403 + {
6404 + DPRINT_ERR(VMBUS_DRV, "unable to allocate device_context for child device");
6405 + DPRINT_EXIT(VMBUS_DRV);
6406 +
6407 + return NULL;
6408 + }
6409 +
6410 + DPRINT_DBG(VMBUS_DRV, "child device (%p) allocated - "
6411 + "type {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x},"
6412 + "id {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
6413 + &child_device_ctx->device,
6414 + 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],
6415 + 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]);
6416 +
6417 + child_device_obj = &child_device_ctx->device_obj;
6418 + child_device_obj->context = context;
6419 + memcpy(&child_device_obj->deviceType, &type, sizeof(GUID));
6420 + memcpy(&child_device_obj->deviceInstance, &instance, sizeof(GUID));
6421 +
6422 + memcpy(&child_device_ctx->class_id, &type, sizeof(GUID));
6423 + memcpy(&child_device_ctx->device_id, &instance, sizeof(GUID));
6424 +
6425 + DPRINT_EXIT(VMBUS_DRV);
6426 +
6427 + return child_device_obj;
6428 +}
6429 +
6430 +/*++
6431 +
6432 +Name: vmbus_child_device_register()
6433 +
6434 +Desc: Register the child device on the specified bus
6435 +
6436 +--*/
6437 +static int vmbus_child_device_register(DEVICE_OBJECT* root_device_obj, DEVICE_OBJECT* child_device_obj)
6438 +{
6439 + int ret=0;
6440 + struct device_context *root_device_ctx = to_device_context(root_device_obj);
6441 + struct device_context *child_device_ctx = to_device_context(child_device_obj);
6442 + static int device_num=0;
6443 +
6444 + DPRINT_ENTER(VMBUS_DRV);
6445 +
6446 + DPRINT_DBG(VMBUS_DRV, "child device (%p) registering", child_device_ctx);
6447 + //
6448 + // Make sure we are not registered already
6449 + //
6450 + if (child_device_ctx->device.bus_id[0] != '\0')
6451 + {
6452 + DPRINT_ERR(VMBUS_DRV, "child device (%p) already registered - busid %s", child_device_ctx, child_device_ctx->device.bus_id);
6453 +
6454 + ret = -1;
6455 + goto Cleanup;
6456 + }
6457 +
6458 + // Set the device bus id. Otherwise, device_register()will fail.
6459 + sprintf(child_device_ctx->device.bus_id, "vmbus_0_%d", InterlockedIncrement(&device_num));
6460 +
6461 + // The new device belongs to this bus
6462 + child_device_ctx->device.bus = &g_vmbus_drv.bus; //device->dev.bus;
6463 + child_device_ctx->device.parent = &root_device_ctx->device;
6464 + child_device_ctx->device.release = vmbus_device_release;
6465 +
6466 + // Register with the LDM. This will kick off the driver/device binding...which will
6467 + // eventually call vmbus_match() and vmbus_probe()
6468 + ret = device_register(&child_device_ctx->device);
6469 +
6470 + // vmbus_probe() error does not get propergate to device_register().
6471 + ret = child_device_ctx->probe_error;
6472 +
6473 + if (ret)
6474 + DPRINT_ERR(VMBUS_DRV, "unable to register child device (%p) (%d)", &child_device_ctx->device);
6475 + else
6476 + DPRINT_INFO(VMBUS_DRV, "child device (%p) registered", &child_device_ctx->device);
6477 +
6478 +Cleanup:
6479 + DPRINT_EXIT(VMBUS_DRV);
6480 +
6481 + return ret;
6482 +}
6483 +
6484 +/*++
6485 +
6486 +Name: vmbus_child_device_unregister()
6487 +
6488 +Desc: Remove the specified child device from the vmbus.
6489 +
6490 +--*/
6491 +static void vmbus_child_device_unregister(DEVICE_OBJECT* device_obj)
6492 +{
6493 + struct device_context *device_ctx = to_device_context(device_obj);
6494 +
6495 + DPRINT_ENTER(VMBUS_DRV);
6496 +
6497 + DPRINT_INFO(VMBUS_DRV, "unregistering child device (%p)", &device_ctx->device);
6498 +
6499 + // Kick off the process of unregistering the device.
6500 + // This will call vmbus_remove() and eventually vmbus_device_release()
6501 + device_unregister(&device_ctx->device);
6502 +
6503 + DPRINT_INFO(VMBUS_DRV, "child device (%p) unregistered", &device_ctx->device);
6504 +
6505 + DPRINT_EXIT(VMBUS_DRV);
6506 +}
6507 +
6508 +
6509 +/*++
6510 +
6511 +Name: vmbus_child_device_destroy()
6512 +
6513 +Desc: Destroy the specified child device on the vmbus.
6514 +
6515 +--*/
6516 +static void vmbus_child_device_destroy(DEVICE_OBJECT* device_obj)
6517 +{
6518 + DPRINT_ENTER(VMBUS_DRV);
6519 +
6520 + DPRINT_EXIT(VMBUS_DRV);
6521 +}
6522 +
6523 +/*++
6524 +
6525 +Name: vmbus_uevent()
6526 +
6527 +Desc: This routine is invoked when a device is added or removed on the vmbus to generate a uevent to udev in the
6528 + userspace. The udev will then look at its rule and the uevent generated here to load the appropriate driver
6529 +
6530 +--*/
6531 +#if defined(KERNEL_2_6_5) || defined(KERNEL_2_6_9)
6532 +#elif defined(KERNEL_2_6_27)
6533 +static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
6534 +{
6535 + struct device_context *device_ctx = device_to_device_context(device);
6536 + int i=0;
6537 + int len=0;
6538 + int ret;
6539 +
6540 + DPRINT_ENTER(VMBUS_DRV);
6541 +
6542 + 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}",
6543 + device_ctx->class_id.Data[3], device_ctx->class_id.Data[2], device_ctx->class_id.Data[1], device_ctx->class_id.Data[0],
6544 + device_ctx->class_id.Data[5], device_ctx->class_id.Data[4],
6545 + device_ctx->class_id.Data[7], device_ctx->class_id.Data[6],
6546 + device_ctx->class_id.Data[8], device_ctx->class_id.Data[9], device_ctx->class_id.Data[10], device_ctx->class_id.Data[11],
6547 + device_ctx->class_id.Data[12], device_ctx->class_id.Data[13], device_ctx->class_id.Data[14], device_ctx->class_id.Data[15]);
6548 +
6549 + env->envp_idx = i;
6550 + env->buflen = len;
6551 + ret = add_uevent_var(env,
6552 + "VMBUS_DEVICE_CLASS_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
6553 + device_ctx->class_id.Data[3], device_ctx->class_id.Data[2], device_ctx->class_id.Data[1], device_ctx->class_id.Data[0],
6554 + device_ctx->class_id.Data[5], device_ctx->class_id.Data[4],
6555 + device_ctx->class_id.Data[7], device_ctx->class_id.Data[6],
6556 + device_ctx->class_id.Data[8], device_ctx->class_id.Data[9], device_ctx->class_id.Data[10], device_ctx->class_id.Data[11],
6557 + device_ctx->class_id.Data[12], device_ctx->class_id.Data[13], device_ctx->class_id.Data[14], device_ctx->class_id.Data[15]);
6558 +
6559 + if (ret)
6560 + {
6561 + return ret;
6562 + }
6563 +
6564 + ret = add_uevent_var(env,
6565 + "VMBUS_DEVICE_DEVICE_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
6566 + device_ctx->device_id.Data[3], device_ctx->device_id.Data[2], device_ctx->device_id.Data[1], device_ctx->device_id.Data[0],
6567 + device_ctx->device_id.Data[5], device_ctx->device_id.Data[4],
6568 + device_ctx->device_id.Data[7], device_ctx->device_id.Data[6],
6569 + device_ctx->device_id.Data[8], device_ctx->device_id.Data[9], device_ctx->device_id.Data[10], device_ctx->device_id.Data[11],
6570 + device_ctx->device_id.Data[12], device_ctx->device_id.Data[13], device_ctx->device_id.Data[14], device_ctx->device_id.Data[15]);
6571 +
6572 + if (ret)
6573 + {
6574 + return ret;
6575 + }
6576 +
6577 + env->envp[env->envp_idx] = NULL;
6578 +
6579 + DPRINT_EXIT(VMBUS_DRV);
6580 +
6581 + return 0;
6582 +}
6583 +
6584 +#else
6585 +static int vmbus_uevent(struct device *device, char **envp, int num_envp, char *buffer, int buffer_size)
6586 +{
6587 + struct device_context *device_ctx = device_to_device_context(device);
6588 + int i=0;
6589 + int len=0;
6590 + int ret;
6591 +
6592 + DPRINT_ENTER(VMBUS_DRV);
6593 +
6594 + 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}",
6595 + device_ctx->class_id.Data[3], device_ctx->class_id.Data[2], device_ctx->class_id.Data[1], device_ctx->class_id.Data[0],
6596 + device_ctx->class_id.Data[5], device_ctx->class_id.Data[4],
6597 + device_ctx->class_id.Data[7], device_ctx->class_id.Data[6],
6598 + device_ctx->class_id.Data[8], device_ctx->class_id.Data[9], device_ctx->class_id.Data[10], device_ctx->class_id.Data[11],
6599 + device_ctx->class_id.Data[12], device_ctx->class_id.Data[13], device_ctx->class_id.Data[14], device_ctx->class_id.Data[15]);
6600 +
6601 + ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
6602 + "VMBUS_DEVICE_CLASS_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
6603 + device_ctx->class_id.Data[3], device_ctx->class_id.Data[2], device_ctx->class_id.Data[1], device_ctx->class_id.Data[0],
6604 + device_ctx->class_id.Data[5], device_ctx->class_id.Data[4],
6605 + device_ctx->class_id.Data[7], device_ctx->class_id.Data[6],
6606 + device_ctx->class_id.Data[8], device_ctx->class_id.Data[9], device_ctx->class_id.Data[10], device_ctx->class_id.Data[11],
6607 + device_ctx->class_id.Data[12], device_ctx->class_id.Data[13], device_ctx->class_id.Data[14], device_ctx->class_id.Data[15]);
6608 +
6609 + if (ret)
6610 + {
6611 + return ret;
6612 + }
6613 +
6614 + ret = add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
6615 + "VMBUS_DEVICE_DEVICE_GUID={%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x}",
6616 + device_ctx->device_id.Data[3], device_ctx->device_id.Data[2], device_ctx->device_id.Data[1], device_ctx->device_id.Data[0],
6617 + device_ctx->device_id.Data[5], device_ctx->device_id.Data[4],
6618 + device_ctx->device_id.Data[7], device_ctx->device_id.Data[6],
6619 + device_ctx->device_id.Data[8], device_ctx->device_id.Data[9], device_ctx->device_id.Data[10], device_ctx->device_id.Data[11],
6620 + device_ctx->device_id.Data[12], device_ctx->device_id.Data[13], device_ctx->device_id.Data[14], device_ctx->device_id.Data[15]);
6621 +
6622 + if (ret)
6623 + {
6624 + return ret;
6625 + }
6626 +
6627 + envp[i] = NULL;
6628 +
6629 + DPRINT_EXIT(VMBUS_DRV);
6630 +
6631 + return 0;
6632 +}
6633 +#endif
6634 +
6635 +/*++
6636 +
6637 +Name: vmbus_match()
6638 +
6639 +Desc: Attempt to match the specified device to the specified driver
6640 +
6641 +--*/
6642 +static int vmbus_match(struct device *device, struct device_driver *driver)
6643 +{
6644 + int match=0;
6645 + struct driver_context *driver_ctx = driver_to_driver_context(driver);
6646 + struct device_context *device_ctx = device_to_device_context(device);
6647 +
6648 + DPRINT_ENTER(VMBUS_DRV);
6649 +
6650 + // We found our driver ?
6651 + if (memcmp(&device_ctx->class_id, &driver_ctx->class_id, sizeof(GUID)) == 0)
6652 + {
6653 + // !! NOTE: The driver_ctx is not a vmbus_drv_ctx. We typecast it here to access the
6654 + // DRIVER_OBJECT field
6655 + struct vmbus_driver_context *vmbus_drv_ctx = (struct vmbus_driver_context*)driver_ctx;
6656 + device_ctx->device_obj.Driver = &vmbus_drv_ctx->drv_obj.Base;
6657 + DPRINT_INFO(VMBUS_DRV, "device object (%p) set to driver object (%p)", &device_ctx->device_obj, device_ctx->device_obj.Driver);
6658 +
6659 + match = 1;
6660 + }
6661 +
6662 + DPRINT_EXIT(VMBUS_DRV);
6663 +
6664 + return match;
6665 +}
6666 +
6667 +
6668 +/*++
6669 +
6670 +Name: vmbus_probe_failed_cb()
6671 +
6672 +Desc: Callback when a driver probe failed in vmbus_probe(). We need a callback because
6673 + we cannot invoked device_unregister() inside vmbus_probe() since vmbus_probe() may be
6674 + invoked inside device_register() i.e. we cannot call device_unregister() inside
6675 + device_register()
6676 +--*/
6677 +#ifdef KERNEL_2_6_27
6678 +static void vmbus_probe_failed_cb(struct work_struct *context)
6679 +#else
6680 +static void vmbus_probe_failed_cb(void* context)
6681 +#endif
6682 +{
6683 + struct device_context *device_ctx = (struct device_context*)context;
6684 +
6685 +
6686 + DPRINT_ENTER(VMBUS_DRV);
6687 +
6688 + // Kick off the process of unregistering the device.
6689 + // This will call vmbus_remove() and eventually vmbus_device_release()
6690 + device_unregister(&device_ctx->device);
6691 +
6692 + //put_device(&device_ctx->device);
6693 + DPRINT_EXIT(VMBUS_DRV);
6694 +}
6695 +
6696 +
6697 +/*++
6698 +
6699 +Name: vmbus_probe()
6700 +
6701 +Desc: Add the new vmbus's child device
6702 +
6703 +--*/
6704 +static int vmbus_probe(struct device *child_device)
6705 +{
6706 + int ret=0;
6707 + struct driver_context *driver_ctx = driver_to_driver_context(child_device->driver);
6708 + struct device_context *device_ctx = device_to_device_context(child_device);
6709 +
6710 + DPRINT_ENTER(VMBUS_DRV);
6711 +
6712 + // Let the specific open-source driver handles the probe if it can
6713 + if (driver_ctx->probe)
6714 + {
6715 + ret = device_ctx->probe_error = driver_ctx->probe(child_device);
6716 + if (ret != 0)
6717 + {
6718 + 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);
6719 +
6720 +#ifdef KERNEL_2_6_27
6721 + INIT_WORK(&device_ctx->probe_failed_work_item, vmbus_probe_failed_cb);
6722 +#else
6723 + INIT_WORK(&device_ctx->probe_failed_work_item, vmbus_probe_failed_cb, device_ctx);
6724 +#endif
6725 + schedule_work(&device_ctx->probe_failed_work_item);
6726 + }
6727 + }
6728 + else
6729 + {
6730 + DPRINT_ERR(VMBUS_DRV, "probe() method not set for driver - %s", child_device->driver->name);
6731 + ret = -1;
6732 + }
6733 +
6734 + DPRINT_EXIT(VMBUS_DRV);
6735 + return ret;
6736 +}
6737 +
6738 +
6739 +/*++
6740 +
6741 +Name: vmbus_remove()
6742 +
6743 +Desc: Remove a vmbus device
6744 +
6745 +--*/
6746 +static int vmbus_remove(struct device *child_device)
6747 +{
6748 + int ret=0;
6749 + struct driver_context *driver_ctx;
6750 +
6751 + DPRINT_ENTER(VMBUS_DRV);
6752 +
6753 + // Special case root bus device
6754 + if (child_device->parent == NULL)
6755 + {
6756 + // No-op since it is statically defined and handle in vmbus_bus_exit()
6757 + DPRINT_EXIT(VMBUS_DRV);
6758 + return 0;
6759 + }
6760 +
6761 + if (child_device->driver)
6762 + {
6763 + driver_ctx = driver_to_driver_context(child_device->driver);
6764 +
6765 + // Let the specific open-source driver handles the removal if it can
6766 + if (driver_ctx->remove)
6767 + {
6768 + ret = driver_ctx->remove(child_device);
6769 + }
6770 + else
6771 + {
6772 + DPRINT_ERR(VMBUS_DRV, "remove() method not set for driver - %s", child_device->driver->name);
6773 + ret = -1;
6774 + }
6775 + }
6776 + else
6777 + {
6778 +
6779 + }
6780 +
6781 + DPRINT_EXIT(VMBUS_DRV);
6782 +
6783 + return 0;
6784 +}
6785 +
6786 +/*++
6787 +
6788 +Name: vmbus_shutdown()
6789 +
6790 +Desc: Shutdown a vmbus device
6791 +
6792 +--*/
6793 +static void vmbus_shutdown(struct device *child_device)
6794 +{
6795 + struct driver_context *driver_ctx;
6796 +
6797 + DPRINT_ENTER(VMBUS_DRV);
6798 +
6799 + // Special case root bus device
6800 + if (child_device->parent == NULL)
6801 + {
6802 + // No-op since it is statically defined and handle in vmbus_bus_exit()
6803 + DPRINT_EXIT(VMBUS_DRV);
6804 + return;
6805 + }
6806 +
6807 + // The device may not be attached yet
6808 + if (!child_device->driver)
6809 + {
6810 + DPRINT_EXIT(VMBUS_DRV);
6811 + return;
6812 + }
6813 +
6814 + driver_ctx = driver_to_driver_context(child_device->driver);
6815 +
6816 + // Let the specific open-source driver handles the removal if it can
6817 + if (driver_ctx->shutdown)
6818 + {
6819 + driver_ctx->shutdown(child_device);
6820 + }
6821 +
6822 + DPRINT_EXIT(VMBUS_DRV);
6823 +
6824 + return;
6825 +}
6826 +
6827 +/*++
6828 +
6829 +Name: vmbus_bus_release()
6830 +
6831 +Desc: Final callback release of the vmbus root device
6832 +
6833 +--*/
6834 +static void vmbus_bus_release(struct device *device)
6835 +{
6836 + DPRINT_ENTER(VMBUS_DRV);
6837 + DPRINT_EXIT(VMBUS_DRV);
6838 +}
6839 +
6840 +/*++
6841 +
6842 +Name: vmbus_device_release()
6843 +
6844 +Desc: Final callback release of the vmbus child device
6845 +
6846 +--*/
6847 +static void vmbus_device_release(struct device *device)
6848 +{
6849 + struct device_context *device_ctx = device_to_device_context(device);
6850 +
6851 + DPRINT_ENTER(VMBUS_DRV);
6852 +
6853 + //vmbus_child_device_destroy(&device_ctx->device_obj);
6854 + kfree(device_ctx);
6855 +
6856 + // !!DO NOT REFERENCE device_ctx anymore at this point!!
6857 +
6858 + DPRINT_EXIT(VMBUS_DRV);
6859 +
6860 + return;
6861 +}
6862 +
6863 +/*++
6864 +
6865 +Name: vmbus_msg_dpc()
6866 +
6867 +Desc: Tasklet routine to handle hypervisor messages
6868 +
6869 +--*/
6870 +static void vmbus_msg_dpc(unsigned long data)
6871 +{
6872 + VMBUS_DRIVER_OBJECT* vmbus_drv_obj = (VMBUS_DRIVER_OBJECT*)data;
6873 +
6874 + DPRINT_ENTER(VMBUS_DRV);
6875 +
6876 + ASSERT(vmbus_drv_obj->OnMsgDpc != NULL);
6877 +
6878 + // Call to bus driver to handle interrupt
6879 + vmbus_drv_obj->OnMsgDpc(&vmbus_drv_obj->Base);
6880 +
6881 + DPRINT_EXIT(VMBUS_DRV);
6882 +}
6883 +
6884 +/*++
6885 +
6886 +Name: vmbus_msg_dpc()
6887 +
6888 +Desc: Tasklet routine to handle hypervisor events
6889 +
6890 +--*/
6891 +static void vmbus_event_dpc(unsigned long data)
6892 +{
6893 + VMBUS_DRIVER_OBJECT* vmbus_drv_obj = (VMBUS_DRIVER_OBJECT*)data;
6894 +
6895 + DPRINT_ENTER(VMBUS_DRV);
6896 +
6897 + ASSERT(vmbus_drv_obj->OnEventDpc != NULL);
6898 +
6899 + // Call to bus driver to handle interrupt
6900 + vmbus_drv_obj->OnEventDpc(&vmbus_drv_obj->Base);
6901 +
6902 + DPRINT_EXIT(VMBUS_DRV);
6903 +}
6904 +
6905 +/*++
6906 +
6907 +Name: vmbus_msg_dpc()
6908 +
6909 +Desc: ISR routine
6910 +
6911 +--*/
6912 +#ifdef KERNEL_2_6_27
6913 +static irqreturn_t vmbus_isr(int irq, void* dev_id)
6914 +#else
6915 +static int vmbus_isr(int irq, void* dev_id, struct pt_regs *regs)
6916 +#endif
6917 +{
6918 + int ret=0;
6919 + VMBUS_DRIVER_OBJECT* vmbus_driver_obj = &g_vmbus_drv.drv_obj;
6920 +
6921 + DPRINT_ENTER(VMBUS_DRV);
6922 +
6923 + ASSERT(vmbus_driver_obj->OnIsr != NULL);
6924 +
6925 + // Call to bus driver to handle interrupt
6926 + ret = vmbus_driver_obj->OnIsr(&vmbus_driver_obj->Base);
6927 +
6928 + // Schedules a dpc if necessary
6929 + if (ret > 0)
6930 + {
6931 + if (test_bit(0, (unsigned long*)&ret))
6932 + {
6933 + tasklet_schedule(&g_vmbus_drv.msg_dpc);
6934 + }
6935 +
6936 + if (test_bit(1, (unsigned long*)&ret))
6937 + {
6938 + tasklet_schedule(&g_vmbus_drv.event_dpc);
6939 + }
6940 +
6941 + DPRINT_EXIT(VMBUS_DRV);
6942 + return IRQ_HANDLED;
6943 + }
6944 + else
6945 + {
6946 + DPRINT_EXIT(VMBUS_DRV);
6947 + return IRQ_NONE;
6948 + }
6949 +}
6950 +
6951 +MODULE_LICENSE("GPL");
6952 +
6953 +
6954 +/*++
6955 +
6956 +Name: vmbus_init()
6957 +
6958 +Desc: Main vmbus driver entry routine
6959 +
6960 +--*/
6961 +static int __init vmbus_init(void)
6962 +{
6963 + int ret=0;
6964 +
6965 + DPRINT_ENTER(VMBUS_DRV);
6966 +
6967 + DPRINT_INFO(VMBUS_DRV,
6968 + "Vmbus initializing.... current log level 0x%x (%x,%x)",
6969 + vmbus_loglevel, HIWORD(vmbus_loglevel), LOWORD(vmbus_loglevel));
6970 +#ifdef KERNEL_2_6_27
6971 +//Todo: it is used for loglevel, to be ported to new kernel.
6972 +#else
6973 + vmbus_ctl_table_hdr = register_sysctl_table(vmus_root_ctl_table, 0);
6974 + if (!vmbus_ctl_table_hdr)
6975 + {
6976 + DPRINT_EXIT(VMBUS_DRV);
6977 + return -ENOMEM;
6978 + }
6979 +#endif
6980 +
6981 + ret = vmbus_bus_init(VmbusInitialize);
6982 +
6983 + DPRINT_EXIT(VMBUS_DRV);
6984 + return ret;
6985 +}
6986 +
6987 +
6988 +
6989 +/*++
6990 +
6991 +Name: vmbus_init()
6992 +
6993 +Desc: Main vmbus driver exit routine
6994 +
6995 +--*/
6996 +static void __exit vmbus_exit(void)
6997 +{
6998 + DPRINT_ENTER(VMBUS_DRV);
6999 +
7000 + vmbus_bus_exit();
7001 +#ifdef KERNEL_2_6_27
7002 +//Todo: it is used for loglevel, to be ported to new kernel.
7003 +#else
7004 + unregister_sysctl_table(vmbus_ctl_table_hdr);
7005 +#endif
7006 + DPRINT_EXIT(VMBUS_DRV);
7007 +
7008 + return;
7009 +}
7010 +
7011 +#if defined(KERNEL_2_6_5)
7012 +#else
7013 +module_param(vmbus_irq, int, S_IRUGO);
7014 +module_param(vmbus_loglevel, int, S_IRUGO);
7015 +#endif
7016 +
7017 +module_init(vmbus_init);
7018 +module_exit(vmbus_exit);
7019 +// eof
7020 --- /dev/null
7021 +++ b/drivers/staging/hv/VmbusPrivate.h
7022 @@ -0,0 +1,170 @@
7023 +/*
7024 + *
7025 + * Copyright (c) 2009, Microsoft Corporation.
7026 + *
7027 + * This program is free software; you can redistribute it and/or modify it
7028 + * under the terms and conditions of the GNU General Public License,
7029 + * version 2, as published by the Free Software Foundation.
7030 + *
7031 + * This program is distributed in the hope it will be useful, but WITHOUT
7032 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
7033 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
7034 + * more details.
7035 + *
7036 + * You should have received a copy of the GNU General Public License along with
7037 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
7038 + * Place - Suite 330, Boston, MA 02111-1307 USA.
7039 + *
7040 + * Authors:
7041 + * Haiyang Zhang <haiyangz@microsoft.com>
7042 + * Hank Janssen <hjanssen@microsoft.com>
7043 + *
7044 + */
7045 +
7046 +
7047 +#ifndef _VMBUS_PRIVATE_H_
7048 +#define _VMBUS_PRIVATE_H_
7049 +
7050 +#ifndef INTERNAL
7051 +#define INTERNAL static
7052 +#endif
7053 +
7054 +#include "Hv.h"
7055 +#include "VmbusApi.h"
7056 +#include "Channel.h"
7057 +#include "ChannelMgmt.h"
7058 +#include "ChannelInterface.h"
7059 +//#include "ChannelMessages.h"
7060 +#include "RingBuffer.h"
7061 +//#include "Packet.h"
7062 +#include "List.h"
7063 +
7064 +//
7065 +// Defines
7066 +//
7067 +
7068 +// Maximum channels is determined by the size of the interrupt page which is PAGE_SIZE. 1/2 of PAGE_SIZE is for
7069 +// send endpoint interrupt and the other is receive endpoint interrupt
7070 +#define MAX_NUM_CHANNELS (PAGE_SIZE >> 1) << 3 // 16348 channels
7071 +
7072 +// The value here must be in multiple of 32
7073 +// TODO: Need to make this configurable
7074 +#define MAX_NUM_CHANNELS_SUPPORTED 256
7075 +
7076 +//
7077 +// Data types
7078 +//
7079 +
7080 +typedef enum {
7081 + Disconnected,
7082 + Connecting,
7083 + Connected,
7084 + Disconnecting
7085 +} VMBUS_CONNECT_STATE;
7086 +
7087 +#define MAX_SIZE_CHANNEL_MESSAGE HV_MESSAGE_PAYLOAD_BYTE_COUNT
7088 +
7089 +typedef struct _VMBUS_CONNECTION {
7090 +
7091 + VMBUS_CONNECT_STATE ConnectState;
7092 +
7093 + UINT32 NextGpadlHandle;
7094 +
7095 + // Represents channel interrupts. Each bit position
7096 + // represents a channel.
7097 + // When a channel sends an interrupt via VMBUS, it
7098 + // finds its bit in the sendInterruptPage, set it and
7099 + // calls Hv to generate a port event. The other end
7100 + // receives the port event and parse the recvInterruptPage
7101 + // to see which bit is set
7102 + VOID* InterruptPage;
7103 + VOID* SendInterruptPage;
7104 + VOID* RecvInterruptPage;
7105 +
7106 + // 2 pages - 1st page for parent->child notification and 2nd is child->parent notification
7107 + VOID* MonitorPages;
7108 + LIST_ENTRY ChannelMsgList;
7109 + HANDLE ChannelMsgLock;
7110 +
7111 + // List of channels
7112 + LIST_ENTRY ChannelList;
7113 + HANDLE ChannelLock;
7114 +
7115 + HANDLE WorkQueue;
7116 +} VMBUS_CONNECTION;
7117 +
7118 +
7119 +typedef struct _VMBUS_MSGINFO {
7120 + // Bookkeeping stuff
7121 + LIST_ENTRY MsgListEntry;
7122 +
7123 + // Synchronize the request/response if needed
7124 + HANDLE WaitEvent;
7125 +
7126 + // The message itself
7127 + unsigned char Msg[0];
7128 +} VMBUS_MSGINFO;
7129 +
7130 +
7131 +//
7132 +// Externs
7133 +//
7134 +extern VMBUS_CONNECTION gVmbusConnection;
7135 +
7136 +//
7137 +// General vmbus interface
7138 +//
7139 +INTERNAL DEVICE_OBJECT*
7140 +VmbusChildDeviceCreate(
7141 + GUID deviceType,
7142 + GUID deviceInstance,
7143 + void *context);
7144 +
7145 +INTERNAL int
7146 +VmbusChildDeviceAdd(
7147 + DEVICE_OBJECT* Device);
7148 +
7149 +INTERNAL void
7150 +VmbusChildDeviceRemove(
7151 + DEVICE_OBJECT* Device);
7152 +
7153 +//INTERNAL void
7154 +//VmbusChildDeviceDestroy(
7155 +// DEVICE_OBJECT*);
7156 +
7157 +INTERNAL VMBUS_CHANNEL*
7158 +GetChannelFromRelId(
7159 + UINT32 relId
7160 + );
7161 +
7162 +//
7163 +// Connection interface
7164 +//
7165 +INTERNAL int
7166 +VmbusConnect(
7167 + VOID
7168 + );
7169 +
7170 +INTERNAL int
7171 +VmbusDisconnect(
7172 + VOID
7173 + );
7174 +
7175 +INTERNAL int
7176 +VmbusPostMessage(
7177 + PVOID buffer,
7178 + SIZE_T bufSize
7179 + );
7180 +
7181 +INTERNAL int
7182 +VmbusSetEvent(
7183 + UINT32 childRelId
7184 + );
7185 +
7186 +INTERNAL VOID
7187 +VmbusOnEvents(
7188 + VOID
7189 + );
7190 +
7191 +
7192 +#endif // _VMBUS_PRIVATE_H_
Peter's tree of IPFire 2.x