2 * Copyright (c) 2009, Microsoft Corporation.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307 USA.
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
21 #include <linux/kernel.h>
25 #include "VmbusPrivate.h"
27 /* Internal routines */
28 static int VmbusChannelCreateGpadlHeader(
29 void *Kbuffer
, /* must be phys and virt contiguous */
30 u32 Size
, /* page-size multiple */
31 struct vmbus_channel_msginfo
**msgInfo
,
33 static void DumpVmbusChannel(struct vmbus_channel
*channel
);
34 static void VmbusChannelSetEvent(struct vmbus_channel
*channel
);
38 static void DumpMonitorPage(struct hv_monitor_page
*MonitorPage
)
43 DPRINT_DBG(VMBUS
, "monitorPage - %p, trigger state - %d",
44 MonitorPage
, MonitorPage
->TriggerState
);
46 for (i
= 0; i
< 4; i
++)
47 DPRINT_DBG(VMBUS
, "trigger group (%d) - %llx", i
,
48 MonitorPage
->TriggerGroup
[i
].AsUINT64
);
50 for (i
= 0; i
< 4; i
++) {
51 for (j
= 0; j
< 32; j
++) {
52 DPRINT_DBG(VMBUS
, "latency (%d)(%d) - %llx", i
, j
,
53 MonitorPage
->Latency
[i
][j
]);
56 for (i
= 0; i
< 4; i
++) {
57 for (j
= 0; j
< 32; j
++) {
58 DPRINT_DBG(VMBUS
, "param-conn id (%d)(%d) - %d", i
, j
,
59 MonitorPage
->Parameter
[i
][j
].ConnectionId
.Asu32
);
60 DPRINT_DBG(VMBUS
, "param-flag (%d)(%d) - %d", i
, j
,
61 MonitorPage
->Parameter
[i
][j
].FlagNumber
);
68 * VmbusChannelSetEvent - Trigger an event notification on the specified channel.
70 static void VmbusChannelSetEvent(struct vmbus_channel
*Channel
)
72 struct hv_monitor_page
*monitorPage
;
76 if (Channel
->OfferMsg
.MonitorAllocated
) {
77 /* Each u32 represents 32 channels */
78 set_bit(Channel
->OfferMsg
.ChildRelId
& 31,
79 (unsigned long *) gVmbusConnection
.SendInterruptPage
+
80 (Channel
->OfferMsg
.ChildRelId
>> 5));
82 monitorPage
= gVmbusConnection
.MonitorPages
;
83 monitorPage
++; /* Get the child to parent monitor page */
85 set_bit(Channel
->MonitorBit
,
86 (unsigned long *)&monitorPage
->TriggerGroup
87 [Channel
->MonitorGroup
].Pending
);
90 VmbusSetEvent(Channel
->OfferMsg
.ChildRelId
);
97 static void VmbusChannelClearEvent(struct vmbus_channel
*channel
)
99 struct hv_monitor_page
*monitorPage
;
103 if (Channel
->OfferMsg
.MonitorAllocated
) {
104 /* Each u32 represents 32 channels */
105 clear_bit(Channel
->OfferMsg
.ChildRelId
& 31,
106 (unsigned long *)gVmbusConnection
.SendInterruptPage
+
107 (Channel
->OfferMsg
.ChildRelId
>> 5));
110 (struct hv_monitor_page
*)gVmbusConnection
.MonitorPages
;
111 monitorPage
++; /* Get the child to parent monitor page */
113 clear_bit(Channel
->MonitorBit
,
114 (unsigned long *)&monitorPage
->TriggerGroup
115 [Channel
->MonitorGroup
].Pending
);
123 * VmbusChannelGetDebugInfo -Retrieve various channel debug info
125 void VmbusChannelGetDebugInfo(struct vmbus_channel
*Channel
,
126 struct vmbus_channel_debug_info
*DebugInfo
)
128 struct hv_monitor_page
*monitorPage
;
129 u8 monitorGroup
= (u8
)Channel
->OfferMsg
.MonitorId
/ 32;
130 u8 monitorOffset
= (u8
)Channel
->OfferMsg
.MonitorId
% 32;
131 /* u32 monitorBit = 1 << monitorOffset; */
133 DebugInfo
->RelId
= Channel
->OfferMsg
.ChildRelId
;
134 DebugInfo
->State
= Channel
->State
;
135 memcpy(&DebugInfo
->InterfaceType
,
136 &Channel
->OfferMsg
.Offer
.InterfaceType
, sizeof(struct hv_guid
));
137 memcpy(&DebugInfo
->InterfaceInstance
,
138 &Channel
->OfferMsg
.Offer
.InterfaceInstance
,
139 sizeof(struct hv_guid
));
141 monitorPage
= (struct hv_monitor_page
*)gVmbusConnection
.MonitorPages
;
143 DebugInfo
->MonitorId
= Channel
->OfferMsg
.MonitorId
;
145 DebugInfo
->ServerMonitorPending
=
146 monitorPage
->TriggerGroup
[monitorGroup
].Pending
;
147 DebugInfo
->ServerMonitorLatency
=
148 monitorPage
->Latency
[monitorGroup
][monitorOffset
];
149 DebugInfo
->ServerMonitorConnectionId
=
150 monitorPage
->Parameter
[monitorGroup
]
151 [monitorOffset
].ConnectionId
.u
.Id
;
155 DebugInfo
->ClientMonitorPending
=
156 monitorPage
->TriggerGroup
[monitorGroup
].Pending
;
157 DebugInfo
->ClientMonitorLatency
=
158 monitorPage
->Latency
[monitorGroup
][monitorOffset
];
159 DebugInfo
->ClientMonitorConnectionId
=
160 monitorPage
->Parameter
[monitorGroup
]
161 [monitorOffset
].ConnectionId
.u
.Id
;
163 RingBufferGetDebugInfo(&Channel
->Inbound
, &DebugInfo
->Inbound
);
164 RingBufferGetDebugInfo(&Channel
->Outbound
, &DebugInfo
->Outbound
);
168 * VmbusChannelOpen - Open the specified channel.
170 int VmbusChannelOpen(struct vmbus_channel
*NewChannel
, u32 SendRingBufferSize
,
171 u32 RecvRingBufferSize
, void *UserData
, u32 UserDataLen
,
172 PFN_CHANNEL_CALLBACK pfnOnChannelCallback
, void *Context
)
174 struct vmbus_channel_open_channel
*openMsg
;
175 struct vmbus_channel_msginfo
*openInfo
;
182 /* Aligned to page size */
183 ASSERT(!(SendRingBufferSize
& (PAGE_SIZE
- 1)));
184 ASSERT(!(RecvRingBufferSize
& (PAGE_SIZE
- 1)));
186 NewChannel
->OnChannelCallback
= pfnOnChannelCallback
;
187 NewChannel
->ChannelCallbackContext
= Context
;
189 /* Allocate the ring buffer */
190 out
= osd_PageAlloc((SendRingBufferSize
+ RecvRingBufferSize
)
193 ASSERT(((unsigned long)out
& (PAGE_SIZE
-1)) == 0);
195 in
= (void *)((unsigned long)out
+ SendRingBufferSize
);
197 NewChannel
->RingBufferPages
= out
;
198 NewChannel
->RingBufferPageCount
= (SendRingBufferSize
+
199 RecvRingBufferSize
) >> PAGE_SHIFT
;
201 RingBufferInit(&NewChannel
->Outbound
, out
, SendRingBufferSize
);
203 RingBufferInit(&NewChannel
->Inbound
, in
, RecvRingBufferSize
);
205 /* Establish the gpadl for the ring buffer */
206 DPRINT_DBG(VMBUS
, "Establishing ring buffer's gpadl for channel %p...",
209 NewChannel
->RingBufferGpadlHandle
= 0;
211 ret
= VmbusChannelEstablishGpadl(NewChannel
,
212 NewChannel
->Outbound
.RingBuffer
,
215 &NewChannel
->RingBufferGpadlHandle
);
217 DPRINT_DBG(VMBUS
, "channel %p <relid %d gpadl 0x%x send ring %p "
218 "size %d recv ring %p size %d, downstreamoffset %d>",
219 NewChannel
, NewChannel
->OfferMsg
.ChildRelId
,
220 NewChannel
->RingBufferGpadlHandle
,
221 NewChannel
->Outbound
.RingBuffer
,
222 NewChannel
->Outbound
.RingSize
,
223 NewChannel
->Inbound
.RingBuffer
,
224 NewChannel
->Inbound
.RingSize
,
227 /* Create and init the channel open message */
228 openInfo
= kmalloc(sizeof(*openInfo
) +
229 sizeof(struct vmbus_channel_open_channel
),
231 ASSERT(openInfo
!= NULL
);
233 openInfo
->WaitEvent
= osd_WaitEventCreate();
235 openMsg
= (struct vmbus_channel_open_channel
*)openInfo
->Msg
;
236 openMsg
->Header
.MessageType
= ChannelMessageOpenChannel
;
237 openMsg
->OpenId
= NewChannel
->OfferMsg
.ChildRelId
; /* FIXME */
238 openMsg
->ChildRelId
= NewChannel
->OfferMsg
.ChildRelId
;
239 openMsg
->RingBufferGpadlHandle
= NewChannel
->RingBufferGpadlHandle
;
240 ASSERT(openMsg
->RingBufferGpadlHandle
);
241 openMsg
->DownstreamRingBufferPageOffset
= SendRingBufferSize
>>
243 openMsg
->ServerContextAreaGpadlHandle
= 0; /* TODO */
245 ASSERT(UserDataLen
<= MAX_USER_DEFINED_BYTES
);
247 memcpy(openMsg
->UserData
, UserData
, UserDataLen
);
249 spin_lock_irqsave(&gVmbusConnection
.channelmsg_lock
, flags
);
250 INSERT_TAIL_LIST(&gVmbusConnection
.ChannelMsgList
,
251 &openInfo
->MsgListEntry
);
252 spin_unlock_irqrestore(&gVmbusConnection
.channelmsg_lock
, flags
);
254 DPRINT_DBG(VMBUS
, "Sending channel open msg...");
256 ret
= VmbusPostMessage(openMsg
,
257 sizeof(struct vmbus_channel_open_channel
));
259 DPRINT_ERR(VMBUS
, "unable to open channel - %d", ret
);
263 /* FIXME: Need to time-out here */
264 osd_WaitEventWait(openInfo
->WaitEvent
);
266 if (openInfo
->Response
.OpenResult
.Status
== 0)
267 DPRINT_INFO(VMBUS
, "channel <%p> open success!!", NewChannel
);
269 DPRINT_INFO(VMBUS
, "channel <%p> open failed - %d!!",
270 NewChannel
, openInfo
->Response
.OpenResult
.Status
);
273 spin_lock_irqsave(&gVmbusConnection
.channelmsg_lock
, flags
);
274 REMOVE_ENTRY_LIST(&openInfo
->MsgListEntry
);
275 spin_unlock_irqrestore(&gVmbusConnection
.channelmsg_lock
, flags
);
277 kfree(openInfo
->WaitEvent
);
286 * DumpGpadlBody - Dump the gpadl body message to the console for debugging purposes.
288 static void DumpGpadlBody(struct vmbus_channel_gpadl_body
*Gpadl
, u32 Len
)
293 pfnCount
= (Len
- sizeof(struct vmbus_channel_gpadl_body
)) /
295 DPRINT_DBG(VMBUS
, "gpadl body - len %d pfn count %d", Len
, pfnCount
);
297 for (i
= 0; i
< pfnCount
; i
++)
298 DPRINT_DBG(VMBUS
, "gpadl body - %d) pfn %llu",
303 * DumpGpadlHeader - Dump the gpadl header message to the console for debugging purposes.
305 static void DumpGpadlHeader(struct vmbus_channel_gpadl_header
*Gpadl
)
311 "gpadl header - relid %d, range count %d, range buflen %d",
312 Gpadl
->ChildRelId
, Gpadl
->RangeCount
, Gpadl
->RangeBufLen
);
313 for (i
= 0; i
< Gpadl
->RangeCount
; i
++) {
314 pageCount
= Gpadl
->Range
[i
].ByteCount
>> PAGE_SHIFT
;
315 pageCount
= (pageCount
> 26) ? 26 : pageCount
;
317 DPRINT_DBG(VMBUS
, "gpadl range %d - len %d offset %d "
318 "page count %d", i
, Gpadl
->Range
[i
].ByteCount
,
319 Gpadl
->Range
[i
].ByteOffset
, pageCount
);
321 for (j
= 0; j
< pageCount
; j
++)
322 DPRINT_DBG(VMBUS
, "%d) pfn %llu", j
,
323 Gpadl
->Range
[i
].PfnArray
[j
]);
328 * VmbusChannelCreateGpadlHeader - Creates a gpadl for the specified buffer
330 static int VmbusChannelCreateGpadlHeader(void *Kbuffer
, u32 Size
,
331 struct vmbus_channel_msginfo
**MsgInfo
,
336 unsigned long long pfn
;
337 struct vmbus_channel_gpadl_header
*gpaHeader
;
338 struct vmbus_channel_gpadl_body
*gpadlBody
;
339 struct vmbus_channel_msginfo
*msgHeader
;
340 struct vmbus_channel_msginfo
*msgBody
;
343 int pfnSum
, pfnCount
, pfnLeft
, pfnCurr
, pfnSize
;
345 /* ASSERT((kbuffer & (PAGE_SIZE-1)) == 0); */
346 ASSERT((Size
& (PAGE_SIZE
-1)) == 0);
348 pageCount
= Size
>> PAGE_SHIFT
;
349 pfn
= virt_to_phys(Kbuffer
) >> PAGE_SHIFT
;
351 /* do we need a gpadl body msg */
352 pfnSize
= MAX_SIZE_CHANNEL_MESSAGE
-
353 sizeof(struct vmbus_channel_gpadl_header
) -
354 sizeof(struct gpa_range
);
355 pfnCount
= pfnSize
/ sizeof(u64
);
357 if (pageCount
> pfnCount
) {
358 /* we need a gpadl body */
359 /* fill in the header */
360 msgSize
= sizeof(struct vmbus_channel_msginfo
) +
361 sizeof(struct vmbus_channel_gpadl_header
) +
362 sizeof(struct gpa_range
) + pfnCount
* sizeof(u64
);
363 msgHeader
= kzalloc(msgSize
, GFP_KERNEL
);
365 INITIALIZE_LIST_HEAD(&msgHeader
->SubMsgList
);
366 msgHeader
->MessageSize
= msgSize
;
368 gpaHeader
= (struct vmbus_channel_gpadl_header
*)msgHeader
->Msg
;
369 gpaHeader
->RangeCount
= 1;
370 gpaHeader
->RangeBufLen
= sizeof(struct gpa_range
) +
371 pageCount
* sizeof(u64
);
372 gpaHeader
->Range
[0].ByteOffset
= 0;
373 gpaHeader
->Range
[0].ByteCount
= Size
;
374 for (i
= 0; i
< pfnCount
; i
++)
375 gpaHeader
->Range
[0].PfnArray
[i
] = pfn
+i
;
376 *MsgInfo
= msgHeader
;
380 pfnLeft
= pageCount
- pfnCount
;
382 /* how many pfns can we fit */
383 pfnSize
= MAX_SIZE_CHANNEL_MESSAGE
-
384 sizeof(struct vmbus_channel_gpadl_body
);
385 pfnCount
= pfnSize
/ sizeof(u64
);
387 /* fill in the body */
389 if (pfnLeft
> pfnCount
)
394 msgSize
= sizeof(struct vmbus_channel_msginfo
) +
395 sizeof(struct vmbus_channel_gpadl_body
) +
396 pfnCurr
* sizeof(u64
);
397 msgBody
= kzalloc(msgSize
, GFP_KERNEL
);
399 msgBody
->MessageSize
= msgSize
;
402 (struct vmbus_channel_gpadl_body
*)msgBody
->Msg
;
406 * Gpadl is u32 and we are using a pointer which could
409 /* gpadlBody->Gpadl = kbuffer; */
410 for (i
= 0; i
< pfnCurr
; i
++)
411 gpadlBody
->Pfn
[i
] = pfn
+ pfnSum
+ i
;
413 /* add to msg header */
414 INSERT_TAIL_LIST(&msgHeader
->SubMsgList
,
415 &msgBody
->MsgListEntry
);
420 /* everything fits in a header */
421 msgSize
= sizeof(struct vmbus_channel_msginfo
) +
422 sizeof(struct vmbus_channel_gpadl_header
) +
423 sizeof(struct gpa_range
) + pageCount
* sizeof(u64
);
424 msgHeader
= kzalloc(msgSize
, GFP_KERNEL
);
425 msgHeader
->MessageSize
= msgSize
;
427 gpaHeader
= (struct vmbus_channel_gpadl_header
*)msgHeader
->Msg
;
428 gpaHeader
->RangeCount
= 1;
429 gpaHeader
->RangeBufLen
= sizeof(struct gpa_range
) +
430 pageCount
* sizeof(u64
);
431 gpaHeader
->Range
[0].ByteOffset
= 0;
432 gpaHeader
->Range
[0].ByteCount
= Size
;
433 for (i
= 0; i
< pageCount
; i
++)
434 gpaHeader
->Range
[0].PfnArray
[i
] = pfn
+i
;
436 *MsgInfo
= msgHeader
;
444 * VmbusChannelEstablishGpadl - Estabish a GPADL for the specified buffer
446 * @Channel: a channel
447 * @Kbuffer: from kmalloc
448 * @Size: page-size multiple
449 * @GpadlHandle: some funky thing
451 int VmbusChannelEstablishGpadl(struct vmbus_channel
*Channel
, void *Kbuffer
,
452 u32 Size
, u32
*GpadlHandle
)
454 struct vmbus_channel_gpadl_header
*gpadlMsg
;
455 struct vmbus_channel_gpadl_body
*gpadlBody
;
456 /* struct vmbus_channel_gpadl_created *gpadlCreated; */
457 struct vmbus_channel_msginfo
*msgInfo
;
458 struct vmbus_channel_msginfo
*subMsgInfo
;
468 nextGpadlHandle
= atomic_read(&gVmbusConnection
.NextGpadlHandle
);
469 atomic_inc(&gVmbusConnection
.NextGpadlHandle
);
471 VmbusChannelCreateGpadlHeader(Kbuffer
, Size
, &msgInfo
, &msgCount
);
472 ASSERT(msgInfo
!= NULL
);
473 ASSERT(msgCount
> 0);
475 msgInfo
->WaitEvent
= osd_WaitEventCreate();
476 gpadlMsg
= (struct vmbus_channel_gpadl_header
*)msgInfo
->Msg
;
477 gpadlMsg
->Header
.MessageType
= ChannelMessageGpadlHeader
;
478 gpadlMsg
->ChildRelId
= Channel
->OfferMsg
.ChildRelId
;
479 gpadlMsg
->Gpadl
= nextGpadlHandle
;
481 DumpGpadlHeader(gpadlMsg
);
483 spin_lock_irqsave(&gVmbusConnection
.channelmsg_lock
, flags
);
484 INSERT_TAIL_LIST(&gVmbusConnection
.ChannelMsgList
,
485 &msgInfo
->MsgListEntry
);
486 spin_unlock_irqrestore(&gVmbusConnection
.channelmsg_lock
, flags
);
488 DPRINT_DBG(VMBUS
, "buffer %p, size %d msg cnt %d",
489 Kbuffer
, Size
, msgCount
);
491 DPRINT_DBG(VMBUS
, "Sending GPADL Header - len %zd",
492 msgInfo
->MessageSize
- sizeof(*msgInfo
));
494 ret
= VmbusPostMessage(gpadlMsg
, msgInfo
->MessageSize
-
497 DPRINT_ERR(VMBUS
, "Unable to open channel - %d", ret
);
502 ITERATE_LIST_ENTRIES(anchor
, curr
, &msgInfo
->SubMsgList
) {
503 subMsgInfo
= (struct vmbus_channel_msginfo
*)curr
;
505 (struct vmbus_channel_gpadl_body
*)subMsgInfo
->Msg
;
507 gpadlBody
->Header
.MessageType
= ChannelMessageGpadlBody
;
508 gpadlBody
->Gpadl
= nextGpadlHandle
;
510 DPRINT_DBG(VMBUS
, "Sending GPADL Body - len %zd",
511 subMsgInfo
->MessageSize
-
512 sizeof(*subMsgInfo
));
514 DumpGpadlBody(gpadlBody
, subMsgInfo
->MessageSize
-
515 sizeof(*subMsgInfo
));
516 ret
= VmbusPostMessage(gpadlBody
,
517 subMsgInfo
->MessageSize
-
518 sizeof(*subMsgInfo
));
522 osd_WaitEventWait(msgInfo
->WaitEvent
);
524 /* At this point, we received the gpadl created msg */
525 DPRINT_DBG(VMBUS
, "Received GPADL created "
526 "(relid %d, status %d handle %x)",
527 Channel
->OfferMsg
.ChildRelId
,
528 msgInfo
->Response
.GpadlCreated
.CreationStatus
,
531 *GpadlHandle
= gpadlMsg
->Gpadl
;
534 spin_lock_irqsave(&gVmbusConnection
.channelmsg_lock
, flags
);
535 REMOVE_ENTRY_LIST(&msgInfo
->MsgListEntry
);
536 spin_unlock_irqrestore(&gVmbusConnection
.channelmsg_lock
, flags
);
538 kfree(msgInfo
->WaitEvent
);
547 * VmbusChannelTeardownGpadl -Teardown the specified GPADL handle
549 int VmbusChannelTeardownGpadl(struct vmbus_channel
*Channel
, u32 GpadlHandle
)
551 struct vmbus_channel_gpadl_teardown
*msg
;
552 struct vmbus_channel_msginfo
*info
;
558 ASSERT(GpadlHandle
!= 0);
560 info
= kmalloc(sizeof(*info
) +
561 sizeof(struct vmbus_channel_gpadl_teardown
), GFP_KERNEL
);
562 ASSERT(info
!= NULL
);
564 info
->WaitEvent
= osd_WaitEventCreate();
566 msg
= (struct vmbus_channel_gpadl_teardown
*)info
->Msg
;
568 msg
->Header
.MessageType
= ChannelMessageGpadlTeardown
;
569 msg
->ChildRelId
= Channel
->OfferMsg
.ChildRelId
;
570 msg
->Gpadl
= GpadlHandle
;
572 spin_lock_irqsave(&gVmbusConnection
.channelmsg_lock
, flags
);
573 INSERT_TAIL_LIST(&gVmbusConnection
.ChannelMsgList
, &info
->MsgListEntry
);
574 spin_unlock_irqrestore(&gVmbusConnection
.channelmsg_lock
, flags
);
576 ret
= VmbusPostMessage(msg
,
577 sizeof(struct vmbus_channel_gpadl_teardown
));
583 osd_WaitEventWait(info
->WaitEvent
);
585 /* Received a torndown response */
586 spin_lock_irqsave(&gVmbusConnection
.channelmsg_lock
, flags
);
587 REMOVE_ENTRY_LIST(&info
->MsgListEntry
);
588 spin_unlock_irqrestore(&gVmbusConnection
.channelmsg_lock
, flags
);
590 kfree(info
->WaitEvent
);
599 * VmbusChannelClose - Close the specified channel
601 void VmbusChannelClose(struct vmbus_channel
*Channel
)
603 struct vmbus_channel_close_channel
*msg
;
604 struct vmbus_channel_msginfo
*info
;
610 /* Stop callback and cancel the timer asap */
611 Channel
->OnChannelCallback
= NULL
;
612 del_timer(&Channel
->poll_timer
);
614 /* Send a closing message */
615 info
= kmalloc(sizeof(*info
) +
616 sizeof(struct vmbus_channel_close_channel
), GFP_KERNEL
);
617 ASSERT(info
!= NULL
);
619 /* info->waitEvent = osd_WaitEventCreate(); */
621 msg
= (struct vmbus_channel_close_channel
*)info
->Msg
;
622 msg
->Header
.MessageType
= ChannelMessageCloseChannel
;
623 msg
->ChildRelId
= Channel
->OfferMsg
.ChildRelId
;
625 ret
= VmbusPostMessage(msg
, sizeof(struct vmbus_channel_close_channel
));
631 /* Tear down the gpadl for the channel's ring buffer */
632 if (Channel
->RingBufferGpadlHandle
)
633 VmbusChannelTeardownGpadl(Channel
,
634 Channel
->RingBufferGpadlHandle
);
636 /* TODO: Send a msg to release the childRelId */
638 /* Cleanup the ring buffers for this channel */
639 RingBufferCleanup(&Channel
->Outbound
);
640 RingBufferCleanup(&Channel
->Inbound
);
642 osd_PageFree(Channel
->RingBufferPages
, Channel
->RingBufferPageCount
);
647 * If we are closing the channel during an error path in
648 * opening the channel, don't free the channel since the
649 * caller will free the channel
652 if (Channel
->State
== CHANNEL_OPEN_STATE
) {
653 spin_lock_irqsave(&gVmbusConnection
.channel_lock
, flags
);
654 REMOVE_ENTRY_LIST(&Channel
->ListEntry
);
655 spin_unlock_irqrestore(&gVmbusConnection
.channel_lock
, flags
);
657 FreeVmbusChannel(Channel
);
664 * VmbusChannelSendPacket - Send the specified buffer on the given channel
666 int VmbusChannelSendPacket(struct vmbus_channel
*Channel
, const void *Buffer
,
667 u32 BufferLen
, u64 RequestId
,
668 enum vmbus_packet_type Type
, u32 Flags
)
670 struct vmpacket_descriptor desc
;
671 u32 packetLen
= sizeof(struct vmpacket_descriptor
) + BufferLen
;
672 u32 packetLenAligned
= ALIGN_UP(packetLen
, sizeof(u64
));
673 struct scatterlist bufferList
[3];
678 DPRINT_DBG(VMBUS
, "channel %p buffer %p len %d",
679 Channel
, Buffer
, BufferLen
);
681 DumpVmbusChannel(Channel
);
683 ASSERT((packetLenAligned
- packetLen
) < sizeof(u64
));
685 /* Setup the descriptor */
686 desc
.Type
= Type
; /* VmbusPacketTypeDataInBand; */
687 desc
.Flags
= Flags
; /* VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED; */
688 /* in 8-bytes granularity */
689 desc
.DataOffset8
= sizeof(struct vmpacket_descriptor
) >> 3;
690 desc
.Length8
= (u16
)(packetLenAligned
>> 3);
691 desc
.TransactionId
= RequestId
;
693 sg_init_table(bufferList
, 3);
694 sg_set_buf(&bufferList
[0], &desc
, sizeof(struct vmpacket_descriptor
));
695 sg_set_buf(&bufferList
[1], Buffer
, BufferLen
);
696 sg_set_buf(&bufferList
[2], &alignedData
, packetLenAligned
- packetLen
);
698 ret
= RingBufferWrite(&Channel
->Outbound
, bufferList
, 3);
700 /* TODO: We should determine if this is optional */
701 if (ret
== 0 && !GetRingBufferInterruptMask(&Channel
->Outbound
))
702 VmbusChannelSetEvent(Channel
);
710 * VmbusChannelSendPacketPageBuffer - Send a range of single-page buffer packets using a GPADL Direct packet type.
712 int VmbusChannelSendPacketPageBuffer(struct vmbus_channel
*Channel
,
713 struct hv_page_buffer PageBuffers
[],
714 u32 PageCount
, void *Buffer
, u32 BufferLen
,
719 struct VMBUS_CHANNEL_PACKET_PAGE_BUFFER desc
;
722 u32 packetLenAligned
;
723 struct scatterlist bufferList
[3];
728 ASSERT(PageCount
<= MAX_PAGE_BUFFER_COUNT
);
730 DumpVmbusChannel(Channel
);
733 * Adjust the size down since VMBUS_CHANNEL_PACKET_PAGE_BUFFER is the
734 * largest size we support
736 descSize
= sizeof(struct VMBUS_CHANNEL_PACKET_PAGE_BUFFER
) -
737 ((MAX_PAGE_BUFFER_COUNT
- PageCount
) *
738 sizeof(struct hv_page_buffer
));
739 packetLen
= descSize
+ BufferLen
;
740 packetLenAligned
= ALIGN_UP(packetLen
, sizeof(u64
));
742 ASSERT((packetLenAligned
- packetLen
) < sizeof(u64
));
744 /* Setup the descriptor */
745 desc
.Type
= VmbusPacketTypeDataUsingGpaDirect
;
746 desc
.Flags
= VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
;
747 desc
.DataOffset8
= descSize
>> 3; /* in 8-bytes grandularity */
748 desc
.Length8
= (u16
)(packetLenAligned
>> 3);
749 desc
.TransactionId
= RequestId
;
750 desc
.RangeCount
= PageCount
;
752 for (i
= 0; i
< PageCount
; i
++) {
753 desc
.Range
[i
].Length
= PageBuffers
[i
].Length
;
754 desc
.Range
[i
].Offset
= PageBuffers
[i
].Offset
;
755 desc
.Range
[i
].Pfn
= PageBuffers
[i
].Pfn
;
758 sg_init_table(bufferList
, 3);
759 sg_set_buf(&bufferList
[0], &desc
, descSize
);
760 sg_set_buf(&bufferList
[1], Buffer
, BufferLen
);
761 sg_set_buf(&bufferList
[2], &alignedData
, packetLenAligned
- packetLen
);
763 ret
= RingBufferWrite(&Channel
->Outbound
, bufferList
, 3);
765 /* TODO: We should determine if this is optional */
766 if (ret
== 0 && !GetRingBufferInterruptMask(&Channel
->Outbound
))
767 VmbusChannelSetEvent(Channel
);
775 * VmbusChannelSendPacketMultiPageBuffer - Send a multi-page buffer packet using a GPADL Direct packet type.
777 int VmbusChannelSendPacketMultiPageBuffer(struct vmbus_channel
*Channel
,
778 struct hv_multipage_buffer
*MultiPageBuffer
,
779 void *Buffer
, u32 BufferLen
, u64 RequestId
)
782 struct VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER desc
;
785 u32 packetLenAligned
;
786 struct scatterlist bufferList
[3];
788 u32 PfnCount
= NUM_PAGES_SPANNED(MultiPageBuffer
->Offset
,
789 MultiPageBuffer
->Length
);
793 DumpVmbusChannel(Channel
);
795 DPRINT_DBG(VMBUS
, "data buffer - offset %u len %u pfn count %u",
796 MultiPageBuffer
->Offset
, MultiPageBuffer
->Length
, PfnCount
);
798 ASSERT(PfnCount
> 0);
799 ASSERT(PfnCount
<= MAX_MULTIPAGE_BUFFER_COUNT
);
802 * Adjust the size down since VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER is
803 * the largest size we support
805 descSize
= sizeof(struct VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER
) -
806 ((MAX_MULTIPAGE_BUFFER_COUNT
- PfnCount
) *
808 packetLen
= descSize
+ BufferLen
;
809 packetLenAligned
= ALIGN_UP(packetLen
, sizeof(u64
));
811 ASSERT((packetLenAligned
- packetLen
) < sizeof(u64
));
813 /* Setup the descriptor */
814 desc
.Type
= VmbusPacketTypeDataUsingGpaDirect
;
815 desc
.Flags
= VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
;
816 desc
.DataOffset8
= descSize
>> 3; /* in 8-bytes grandularity */
817 desc
.Length8
= (u16
)(packetLenAligned
>> 3);
818 desc
.TransactionId
= RequestId
;
821 desc
.Range
.Length
= MultiPageBuffer
->Length
;
822 desc
.Range
.Offset
= MultiPageBuffer
->Offset
;
824 memcpy(desc
.Range
.PfnArray
, MultiPageBuffer
->PfnArray
,
825 PfnCount
* sizeof(u64
));
827 sg_init_table(bufferList
, 3);
828 sg_set_buf(&bufferList
[0], &desc
, descSize
);
829 sg_set_buf(&bufferList
[1], Buffer
, BufferLen
);
830 sg_set_buf(&bufferList
[2], &alignedData
, packetLenAligned
- packetLen
);
832 ret
= RingBufferWrite(&Channel
->Outbound
, bufferList
, 3);
834 /* TODO: We should determine if this is optional */
835 if (ret
== 0 && !GetRingBufferInterruptMask(&Channel
->Outbound
))
836 VmbusChannelSetEvent(Channel
);
844 * VmbusChannelRecvPacket - Retrieve the user packet on the specified channel
846 /* TODO: Do we ever receive a gpa direct packet other than the ones we send ? */
847 int VmbusChannelRecvPacket(struct vmbus_channel
*Channel
, void *Buffer
,
848 u32 BufferLen
, u32
*BufferActualLen
, u64
*RequestId
)
850 struct vmpacket_descriptor desc
;
858 *BufferActualLen
= 0;
861 spin_lock_irqsave(&Channel
->inbound_lock
, flags
);
863 ret
= RingBufferPeek(&Channel
->Inbound
, &desc
,
864 sizeof(struct vmpacket_descriptor
));
866 spin_unlock_irqrestore(&Channel
->inbound_lock
, flags
);
868 /* DPRINT_DBG(VMBUS, "nothing to read!!"); */
873 /* VmbusChannelClearEvent(Channel); */
875 packetLen
= desc
.Length8
<< 3;
876 userLen
= packetLen
- (desc
.DataOffset8
<< 3);
877 /* ASSERT(userLen > 0); */
879 DPRINT_DBG(VMBUS
, "packet received on channel %p relid %d <type %d "
880 "flag %d tid %llx pktlen %d datalen %d> ",
881 Channel
, Channel
->OfferMsg
.ChildRelId
, desc
.Type
,
882 desc
.Flags
, desc
.TransactionId
, packetLen
, userLen
);
884 *BufferActualLen
= userLen
;
886 if (userLen
> BufferLen
) {
887 spin_unlock_irqrestore(&Channel
->inbound_lock
, flags
);
889 DPRINT_ERR(VMBUS
, "buffer too small - got %d needs %d",
896 *RequestId
= desc
.TransactionId
;
898 /* Copy over the packet to the user buffer */
899 ret
= RingBufferRead(&Channel
->Inbound
, Buffer
, userLen
,
900 (desc
.DataOffset8
<< 3));
902 spin_unlock_irqrestore(&Channel
->inbound_lock
, flags
);
910 * VmbusChannelRecvPacketRaw - Retrieve the raw packet on the specified channel
912 int VmbusChannelRecvPacketRaw(struct vmbus_channel
*Channel
, void *Buffer
,
913 u32 BufferLen
, u32
*BufferActualLen
,
916 struct vmpacket_descriptor desc
;
924 *BufferActualLen
= 0;
927 spin_lock_irqsave(&Channel
->inbound_lock
, flags
);
929 ret
= RingBufferPeek(&Channel
->Inbound
, &desc
,
930 sizeof(struct vmpacket_descriptor
));
932 spin_unlock_irqrestore(&Channel
->inbound_lock
, flags
);
934 /* DPRINT_DBG(VMBUS, "nothing to read!!"); */
939 /* VmbusChannelClearEvent(Channel); */
941 packetLen
= desc
.Length8
<< 3;
942 userLen
= packetLen
- (desc
.DataOffset8
<< 3);
944 DPRINT_DBG(VMBUS
, "packet received on channel %p relid %d <type %d "
945 "flag %d tid %llx pktlen %d datalen %d> ",
946 Channel
, Channel
->OfferMsg
.ChildRelId
, desc
.Type
,
947 desc
.Flags
, desc
.TransactionId
, packetLen
, userLen
);
949 *BufferActualLen
= packetLen
;
951 if (packetLen
> BufferLen
) {
952 spin_unlock_irqrestore(&Channel
->inbound_lock
, flags
);
954 DPRINT_ERR(VMBUS
, "buffer too small - needed %d bytes but "
955 "got space for only %d bytes", packetLen
, BufferLen
);
960 *RequestId
= desc
.TransactionId
;
962 /* Copy over the entire packet to the user buffer */
963 ret
= RingBufferRead(&Channel
->Inbound
, Buffer
, packetLen
, 0);
965 spin_unlock_irqrestore(&Channel
->inbound_lock
, flags
);
973 * VmbusChannelOnChannelEvent - Channel event callback
975 void VmbusChannelOnChannelEvent(struct vmbus_channel
*Channel
)
977 DumpVmbusChannel(Channel
);
978 ASSERT(Channel
->OnChannelCallback
);
979 #ifdef ENABLE_POLLING
980 del_timer(&Channel
->poll_timer
);
981 Channel
->OnChannelCallback(Channel
->ChannelCallbackContext
);
982 channel
->poll_timer
.expires(jiffies
+ usecs_to_jiffies(100);
983 add_timer(&channel
->poll_timer
);
985 Channel
->OnChannelCallback(Channel
->ChannelCallbackContext
);
990 * VmbusChannelOnTimer - Timer event callback
992 void VmbusChannelOnTimer(unsigned long data
)
994 struct vmbus_channel
*channel
= (struct vmbus_channel
*)data
;
996 if (channel
->OnChannelCallback
) {
997 channel
->OnChannelCallback(channel
->ChannelCallbackContext
);
998 #ifdef ENABLE_POLLING
999 channel
->poll_timer
.expires(jiffies
+ usecs_to_jiffies(100);
1000 add_timer(&channel
->poll_timer
);
1006 * DumpVmbusChannel - Dump vmbus channel info to the console
1008 static void DumpVmbusChannel(struct vmbus_channel
*Channel
)
1010 DPRINT_DBG(VMBUS
, "Channel (%d)", Channel
->OfferMsg
.ChildRelId
);
1011 DumpRingInfo(&Channel
->Outbound
, "Outbound ");
1012 DumpRingInfo(&Channel
->Inbound
, "Inbound ");