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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
25 #include <linux/wait.h>
27 #include <linux/slab.h>
28 #include <linux/module.h>
29 #include <linux/hyperv.h>
30 #include <linux/uio.h>
31 #include <linux/interrupt.h>
33 #include "hyperv_vmbus.h"
35 #define NUM_PAGES_SPANNED(addr, len) \
36 ((PAGE_ALIGN(addr + len) >> PAGE_SHIFT) - (addr >> PAGE_SHIFT))
39 * vmbus_setevent- Trigger an event notification on the specified
42 void vmbus_setevent(struct vmbus_channel
*channel
)
44 struct hv_monitor_page
*monitorpage
;
47 * For channels marked as in "low latency" mode
48 * bypass the monitor page mechanism.
50 if (channel
->offermsg
.monitor_allocated
&& !channel
->low_latency
) {
51 vmbus_send_interrupt(channel
->offermsg
.child_relid
);
53 /* Get the child to parent monitor page */
54 monitorpage
= vmbus_connection
.monitor_pages
[1];
56 sync_set_bit(channel
->monitor_bit
,
57 (unsigned long *)&monitorpage
->trigger_group
58 [channel
->monitor_grp
].pending
);
61 vmbus_set_event(channel
);
64 EXPORT_SYMBOL_GPL(vmbus_setevent
);
67 * vmbus_open - Open the specified channel.
69 int vmbus_open(struct vmbus_channel
*newchannel
, u32 send_ringbuffer_size
,
70 u32 recv_ringbuffer_size
, void *userdata
, u32 userdatalen
,
71 void (*onchannelcallback
)(void *context
), void *context
)
73 struct vmbus_channel_open_channel
*open_msg
;
74 struct vmbus_channel_msginfo
*open_info
= NULL
;
79 if (send_ringbuffer_size
% PAGE_SIZE
||
80 recv_ringbuffer_size
% PAGE_SIZE
)
83 spin_lock_irqsave(&newchannel
->lock
, flags
);
84 if (newchannel
->state
== CHANNEL_OPEN_STATE
) {
85 newchannel
->state
= CHANNEL_OPENING_STATE
;
87 spin_unlock_irqrestore(&newchannel
->lock
, flags
);
90 spin_unlock_irqrestore(&newchannel
->lock
, flags
);
92 newchannel
->onchannel_callback
= onchannelcallback
;
93 newchannel
->channel_callback_context
= context
;
95 /* Allocate the ring buffer */
96 page
= alloc_pages_node(cpu_to_node(newchannel
->target_cpu
),
97 GFP_KERNEL
|__GFP_ZERO
,
98 get_order(send_ringbuffer_size
+
99 recv_ringbuffer_size
));
102 page
= alloc_pages(GFP_KERNEL
|__GFP_ZERO
,
103 get_order(send_ringbuffer_size
+
104 recv_ringbuffer_size
));
108 goto error_set_chnstate
;
111 newchannel
->ringbuffer_pages
= page_address(page
);
112 newchannel
->ringbuffer_pagecount
= (send_ringbuffer_size
+
113 recv_ringbuffer_size
) >> PAGE_SHIFT
;
115 ret
= hv_ringbuffer_init(&newchannel
->outbound
, page
,
116 send_ringbuffer_size
>> PAGE_SHIFT
);
120 goto error_free_pages
;
123 ret
= hv_ringbuffer_init(&newchannel
->inbound
,
124 &page
[send_ringbuffer_size
>> PAGE_SHIFT
],
125 recv_ringbuffer_size
>> PAGE_SHIFT
);
128 goto error_free_pages
;
132 /* Establish the gpadl for the ring buffer */
133 newchannel
->ringbuffer_gpadlhandle
= 0;
135 ret
= vmbus_establish_gpadl(newchannel
,
137 send_ringbuffer_size
+
138 recv_ringbuffer_size
,
139 &newchannel
->ringbuffer_gpadlhandle
);
143 goto error_free_pages
;
146 /* Create and init the channel open message */
147 open_info
= kmalloc(sizeof(*open_info
) +
148 sizeof(struct vmbus_channel_open_channel
),
152 goto error_free_gpadl
;
155 init_completion(&open_info
->waitevent
);
156 open_info
->waiting_channel
= newchannel
;
158 open_msg
= (struct vmbus_channel_open_channel
*)open_info
->msg
;
159 open_msg
->header
.msgtype
= CHANNELMSG_OPENCHANNEL
;
160 open_msg
->openid
= newchannel
->offermsg
.child_relid
;
161 open_msg
->child_relid
= newchannel
->offermsg
.child_relid
;
162 open_msg
->ringbuffer_gpadlhandle
= newchannel
->ringbuffer_gpadlhandle
;
163 open_msg
->downstream_ringbuffer_pageoffset
= send_ringbuffer_size
>>
165 open_msg
->target_vp
= newchannel
->target_vp
;
167 if (userdatalen
> MAX_USER_DEFINED_BYTES
) {
169 goto error_free_gpadl
;
173 memcpy(open_msg
->userdata
, userdata
, userdatalen
);
175 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
176 list_add_tail(&open_info
->msglistentry
,
177 &vmbus_connection
.chn_msg_list
);
178 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
180 if (newchannel
->rescind
) {
182 goto error_free_gpadl
;
185 ret
= vmbus_post_msg(open_msg
,
186 sizeof(struct vmbus_channel_open_channel
), true);
190 goto error_clean_msglist
;
193 wait_for_completion(&open_info
->waitevent
);
195 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
196 list_del(&open_info
->msglistentry
);
197 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
199 if (newchannel
->rescind
) {
201 goto error_free_gpadl
;
204 if (open_info
->response
.open_result
.status
) {
206 goto error_free_gpadl
;
209 newchannel
->state
= CHANNEL_OPENED_STATE
;
214 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
215 list_del(&open_info
->msglistentry
);
216 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
219 vmbus_teardown_gpadl(newchannel
, newchannel
->ringbuffer_gpadlhandle
);
222 hv_ringbuffer_cleanup(&newchannel
->outbound
);
223 hv_ringbuffer_cleanup(&newchannel
->inbound
);
225 get_order(send_ringbuffer_size
+ recv_ringbuffer_size
));
227 newchannel
->state
= CHANNEL_OPEN_STATE
;
230 EXPORT_SYMBOL_GPL(vmbus_open
);
232 /* Used for Hyper-V Socket: a guest client's connect() to the host */
233 int vmbus_send_tl_connect_request(const uuid_le
*shv_guest_servie_id
,
234 const uuid_le
*shv_host_servie_id
)
236 struct vmbus_channel_tl_connect_request conn_msg
;
238 memset(&conn_msg
, 0, sizeof(conn_msg
));
239 conn_msg
.header
.msgtype
= CHANNELMSG_TL_CONNECT_REQUEST
;
240 conn_msg
.guest_endpoint_id
= *shv_guest_servie_id
;
241 conn_msg
.host_service_id
= *shv_host_servie_id
;
243 return vmbus_post_msg(&conn_msg
, sizeof(conn_msg
), true);
245 EXPORT_SYMBOL_GPL(vmbus_send_tl_connect_request
);
248 * create_gpadl_header - Creates a gpadl for the specified buffer
250 static int create_gpadl_header(void *kbuffer
, u32 size
,
251 struct vmbus_channel_msginfo
**msginfo
)
255 struct vmbus_channel_gpadl_header
*gpadl_header
;
256 struct vmbus_channel_gpadl_body
*gpadl_body
;
257 struct vmbus_channel_msginfo
*msgheader
;
258 struct vmbus_channel_msginfo
*msgbody
= NULL
;
261 int pfnsum
, pfncount
, pfnleft
, pfncurr
, pfnsize
;
263 pagecount
= size
>> PAGE_SHIFT
;
265 /* do we need a gpadl body msg */
266 pfnsize
= MAX_SIZE_CHANNEL_MESSAGE
-
267 sizeof(struct vmbus_channel_gpadl_header
) -
268 sizeof(struct gpa_range
);
269 pfncount
= pfnsize
/ sizeof(u64
);
271 if (pagecount
> pfncount
) {
272 /* we need a gpadl body */
273 /* fill in the header */
274 msgsize
= sizeof(struct vmbus_channel_msginfo
) +
275 sizeof(struct vmbus_channel_gpadl_header
) +
276 sizeof(struct gpa_range
) + pfncount
* sizeof(u64
);
277 msgheader
= kzalloc(msgsize
, GFP_KERNEL
);
281 INIT_LIST_HEAD(&msgheader
->submsglist
);
282 msgheader
->msgsize
= msgsize
;
284 gpadl_header
= (struct vmbus_channel_gpadl_header
*)
286 gpadl_header
->rangecount
= 1;
287 gpadl_header
->range_buflen
= sizeof(struct gpa_range
) +
288 pagecount
* sizeof(u64
);
289 gpadl_header
->range
[0].byte_offset
= 0;
290 gpadl_header
->range
[0].byte_count
= size
;
291 for (i
= 0; i
< pfncount
; i
++)
292 gpadl_header
->range
[0].pfn_array
[i
] = slow_virt_to_phys(
293 kbuffer
+ PAGE_SIZE
* i
) >> PAGE_SHIFT
;
294 *msginfo
= msgheader
;
297 pfnleft
= pagecount
- pfncount
;
299 /* how many pfns can we fit */
300 pfnsize
= MAX_SIZE_CHANNEL_MESSAGE
-
301 sizeof(struct vmbus_channel_gpadl_body
);
302 pfncount
= pfnsize
/ sizeof(u64
);
304 /* fill in the body */
306 if (pfnleft
> pfncount
)
311 msgsize
= sizeof(struct vmbus_channel_msginfo
) +
312 sizeof(struct vmbus_channel_gpadl_body
) +
313 pfncurr
* sizeof(u64
);
314 msgbody
= kzalloc(msgsize
, GFP_KERNEL
);
317 struct vmbus_channel_msginfo
*pos
= NULL
;
318 struct vmbus_channel_msginfo
*tmp
= NULL
;
320 * Free up all the allocated messages.
322 list_for_each_entry_safe(pos
, tmp
,
323 &msgheader
->submsglist
,
326 list_del(&pos
->msglistentry
);
333 msgbody
->msgsize
= msgsize
;
335 (struct vmbus_channel_gpadl_body
*)msgbody
->msg
;
338 * Gpadl is u32 and we are using a pointer which could
340 * This is governed by the guest/host protocol and
341 * so the hypervisor guarantees that this is ok.
343 for (i
= 0; i
< pfncurr
; i
++)
344 gpadl_body
->pfn
[i
] = slow_virt_to_phys(
345 kbuffer
+ PAGE_SIZE
* (pfnsum
+ i
)) >>
348 /* add to msg header */
349 list_add_tail(&msgbody
->msglistentry
,
350 &msgheader
->submsglist
);
355 /* everything fits in a header */
356 msgsize
= sizeof(struct vmbus_channel_msginfo
) +
357 sizeof(struct vmbus_channel_gpadl_header
) +
358 sizeof(struct gpa_range
) + pagecount
* sizeof(u64
);
359 msgheader
= kzalloc(msgsize
, GFP_KERNEL
);
360 if (msgheader
== NULL
)
363 INIT_LIST_HEAD(&msgheader
->submsglist
);
364 msgheader
->msgsize
= msgsize
;
366 gpadl_header
= (struct vmbus_channel_gpadl_header
*)
368 gpadl_header
->rangecount
= 1;
369 gpadl_header
->range_buflen
= sizeof(struct gpa_range
) +
370 pagecount
* sizeof(u64
);
371 gpadl_header
->range
[0].byte_offset
= 0;
372 gpadl_header
->range
[0].byte_count
= size
;
373 for (i
= 0; i
< pagecount
; i
++)
374 gpadl_header
->range
[0].pfn_array
[i
] = slow_virt_to_phys(
375 kbuffer
+ PAGE_SIZE
* i
) >> PAGE_SHIFT
;
377 *msginfo
= msgheader
;
388 * vmbus_establish_gpadl - Establish a GPADL for the specified buffer
390 * @channel: a channel
391 * @kbuffer: from kmalloc or vmalloc
392 * @size: page-size multiple
393 * @gpadl_handle: some funky thing
395 int vmbus_establish_gpadl(struct vmbus_channel
*channel
, void *kbuffer
,
396 u32 size
, u32
*gpadl_handle
)
398 struct vmbus_channel_gpadl_header
*gpadlmsg
;
399 struct vmbus_channel_gpadl_body
*gpadl_body
;
400 struct vmbus_channel_msginfo
*msginfo
= NULL
;
401 struct vmbus_channel_msginfo
*submsginfo
, *tmp
;
402 struct list_head
*curr
;
403 u32 next_gpadl_handle
;
408 (atomic_inc_return(&vmbus_connection
.next_gpadl_handle
) - 1);
410 ret
= create_gpadl_header(kbuffer
, size
, &msginfo
);
414 init_completion(&msginfo
->waitevent
);
415 msginfo
->waiting_channel
= channel
;
417 gpadlmsg
= (struct vmbus_channel_gpadl_header
*)msginfo
->msg
;
418 gpadlmsg
->header
.msgtype
= CHANNELMSG_GPADL_HEADER
;
419 gpadlmsg
->child_relid
= channel
->offermsg
.child_relid
;
420 gpadlmsg
->gpadl
= next_gpadl_handle
;
423 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
424 list_add_tail(&msginfo
->msglistentry
,
425 &vmbus_connection
.chn_msg_list
);
427 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
429 if (channel
->rescind
) {
434 ret
= vmbus_post_msg(gpadlmsg
, msginfo
->msgsize
-
435 sizeof(*msginfo
), true);
439 list_for_each(curr
, &msginfo
->submsglist
) {
440 submsginfo
= (struct vmbus_channel_msginfo
*)curr
;
442 (struct vmbus_channel_gpadl_body
*)submsginfo
->msg
;
444 gpadl_body
->header
.msgtype
=
445 CHANNELMSG_GPADL_BODY
;
446 gpadl_body
->gpadl
= next_gpadl_handle
;
448 ret
= vmbus_post_msg(gpadl_body
,
449 submsginfo
->msgsize
- sizeof(*submsginfo
),
455 wait_for_completion(&msginfo
->waitevent
);
457 if (channel
->rescind
) {
462 /* At this point, we received the gpadl created msg */
463 *gpadl_handle
= gpadlmsg
->gpadl
;
466 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
467 list_del(&msginfo
->msglistentry
);
468 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
469 list_for_each_entry_safe(submsginfo
, tmp
, &msginfo
->submsglist
,
477 EXPORT_SYMBOL_GPL(vmbus_establish_gpadl
);
480 * vmbus_teardown_gpadl -Teardown the specified GPADL handle
482 int vmbus_teardown_gpadl(struct vmbus_channel
*channel
, u32 gpadl_handle
)
484 struct vmbus_channel_gpadl_teardown
*msg
;
485 struct vmbus_channel_msginfo
*info
;
489 info
= kmalloc(sizeof(*info
) +
490 sizeof(struct vmbus_channel_gpadl_teardown
), GFP_KERNEL
);
494 init_completion(&info
->waitevent
);
495 info
->waiting_channel
= channel
;
497 msg
= (struct vmbus_channel_gpadl_teardown
*)info
->msg
;
499 msg
->header
.msgtype
= CHANNELMSG_GPADL_TEARDOWN
;
500 msg
->child_relid
= channel
->offermsg
.child_relid
;
501 msg
->gpadl
= gpadl_handle
;
503 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
504 list_add_tail(&info
->msglistentry
,
505 &vmbus_connection
.chn_msg_list
);
506 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
508 if (channel
->rescind
)
511 ret
= vmbus_post_msg(msg
, sizeof(struct vmbus_channel_gpadl_teardown
),
517 wait_for_completion(&info
->waitevent
);
521 * If the channel has been rescinded;
522 * we will be awakened by the rescind
523 * handler; set the error code to zero so we don't leak memory.
525 if (channel
->rescind
)
528 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
529 list_del(&info
->msglistentry
);
530 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
535 EXPORT_SYMBOL_GPL(vmbus_teardown_gpadl
);
537 static void reset_channel_cb(void *arg
)
539 struct vmbus_channel
*channel
= arg
;
541 channel
->onchannel_callback
= NULL
;
544 static int vmbus_close_internal(struct vmbus_channel
*channel
)
546 struct vmbus_channel_close_channel
*msg
;
550 * vmbus_on_event(), running in the per-channel tasklet, can race
551 * with vmbus_close_internal() in the case of SMP guest, e.g., when
552 * the former is accessing channel->inbound.ring_buffer, the latter
553 * could be freeing the ring_buffer pages, so here we must stop it
556 tasklet_disable(&channel
->callback_event
);
559 * In case a device driver's probe() fails (e.g.,
560 * util_probe() -> vmbus_open() returns -ENOMEM) and the device is
561 * rescinded later (e.g., we dynamically disable an Integrated Service
562 * in Hyper-V Manager), the driver's remove() invokes vmbus_close():
563 * here we should skip most of the below cleanup work.
565 if (channel
->state
!= CHANNEL_OPENED_STATE
) {
570 channel
->state
= CHANNEL_OPEN_STATE
;
571 channel
->sc_creation_callback
= NULL
;
572 /* Stop callback and cancel the timer asap */
573 if (channel
->target_cpu
!= get_cpu()) {
575 smp_call_function_single(channel
->target_cpu
, reset_channel_cb
,
578 reset_channel_cb(channel
);
582 /* Send a closing message */
584 msg
= &channel
->close_msg
.msg
;
586 msg
->header
.msgtype
= CHANNELMSG_CLOSECHANNEL
;
587 msg
->child_relid
= channel
->offermsg
.child_relid
;
589 ret
= vmbus_post_msg(msg
, sizeof(struct vmbus_channel_close_channel
),
593 pr_err("Close failed: close post msg return is %d\n", ret
);
595 * If we failed to post the close msg,
596 * it is perhaps better to leak memory.
601 /* Tear down the gpadl for the channel's ring buffer */
602 if (channel
->ringbuffer_gpadlhandle
) {
603 ret
= vmbus_teardown_gpadl(channel
,
604 channel
->ringbuffer_gpadlhandle
);
606 pr_err("Close failed: teardown gpadl return %d\n", ret
);
608 * If we failed to teardown gpadl,
609 * it is perhaps better to leak memory.
615 /* Cleanup the ring buffers for this channel */
616 hv_ringbuffer_cleanup(&channel
->outbound
);
617 hv_ringbuffer_cleanup(&channel
->inbound
);
619 free_pages((unsigned long)channel
->ringbuffer_pages
,
620 get_order(channel
->ringbuffer_pagecount
* PAGE_SIZE
));
623 /* re-enable tasklet for use on re-open */
624 tasklet_enable(&channel
->callback_event
);
629 * vmbus_close - Close the specified channel
631 void vmbus_close(struct vmbus_channel
*channel
)
633 struct list_head
*cur
, *tmp
;
634 struct vmbus_channel
*cur_channel
;
636 if (channel
->primary_channel
!= NULL
) {
638 * We will only close sub-channels when
639 * the primary is closed.
643 mutex_lock(&vmbus_connection
.channel_mutex
);
645 * Close all the sub-channels first and then close the
648 list_for_each_safe(cur
, tmp
, &channel
->sc_list
) {
649 cur_channel
= list_entry(cur
, struct vmbus_channel
, sc_list
);
650 vmbus_close_internal(cur_channel
);
651 if (cur_channel
->rescind
) {
652 hv_process_channel_removal(
653 cur_channel
->offermsg
.child_relid
);
657 * Now close the primary.
659 vmbus_close_internal(channel
);
660 mutex_unlock(&vmbus_connection
.channel_mutex
);
662 EXPORT_SYMBOL_GPL(vmbus_close
);
664 int vmbus_sendpacket_ctl(struct vmbus_channel
*channel
, void *buffer
,
665 u32 bufferlen
, u64 requestid
,
666 enum vmbus_packet_type type
, u32 flags
)
668 struct vmpacket_descriptor desc
;
669 u32 packetlen
= sizeof(struct vmpacket_descriptor
) + bufferlen
;
670 u32 packetlen_aligned
= ALIGN(packetlen
, sizeof(u64
));
671 struct kvec bufferlist
[3];
672 u64 aligned_data
= 0;
673 int num_vecs
= ((bufferlen
!= 0) ? 3 : 1);
676 /* Setup the descriptor */
677 desc
.type
= type
; /* VmbusPacketTypeDataInBand; */
678 desc
.flags
= flags
; /* VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED; */
679 /* in 8-bytes granularity */
680 desc
.offset8
= sizeof(struct vmpacket_descriptor
) >> 3;
681 desc
.len8
= (u16
)(packetlen_aligned
>> 3);
682 desc
.trans_id
= requestid
;
684 bufferlist
[0].iov_base
= &desc
;
685 bufferlist
[0].iov_len
= sizeof(struct vmpacket_descriptor
);
686 bufferlist
[1].iov_base
= buffer
;
687 bufferlist
[1].iov_len
= bufferlen
;
688 bufferlist
[2].iov_base
= &aligned_data
;
689 bufferlist
[2].iov_len
= (packetlen_aligned
- packetlen
);
691 return hv_ringbuffer_write(channel
, bufferlist
, num_vecs
);
693 EXPORT_SYMBOL(vmbus_sendpacket_ctl
);
696 * vmbus_sendpacket() - Send the specified buffer on the given channel
697 * @channel: Pointer to vmbus_channel structure.
698 * @buffer: Pointer to the buffer you want to receive the data into.
699 * @bufferlen: Maximum size of what the the buffer will hold
700 * @requestid: Identifier of the request
701 * @type: Type of packet that is being send e.g. negotiate, time
704 * Sends data in @buffer directly to hyper-v via the vmbus
705 * This will send the data unparsed to hyper-v.
707 * Mainly used by Hyper-V drivers.
709 int vmbus_sendpacket(struct vmbus_channel
*channel
, void *buffer
,
710 u32 bufferlen
, u64 requestid
,
711 enum vmbus_packet_type type
, u32 flags
)
713 return vmbus_sendpacket_ctl(channel
, buffer
, bufferlen
, requestid
,
716 EXPORT_SYMBOL(vmbus_sendpacket
);
719 * vmbus_sendpacket_pagebuffer_ctl - Send a range of single-page buffer
720 * packets using a GPADL Direct packet type. This interface allows you
721 * to control notifying the host. This will be useful for sending
722 * batched data. Also the sender can control the send flags
725 int vmbus_sendpacket_pagebuffer_ctl(struct vmbus_channel
*channel
,
726 struct hv_page_buffer pagebuffers
[],
727 u32 pagecount
, void *buffer
, u32 bufferlen
,
728 u64 requestid
, u32 flags
)
731 struct vmbus_channel_packet_page_buffer desc
;
734 u32 packetlen_aligned
;
735 struct kvec bufferlist
[3];
736 u64 aligned_data
= 0;
738 if (pagecount
> MAX_PAGE_BUFFER_COUNT
)
742 * Adjust the size down since vmbus_channel_packet_page_buffer is the
743 * largest size we support
745 descsize
= sizeof(struct vmbus_channel_packet_page_buffer
) -
746 ((MAX_PAGE_BUFFER_COUNT
- pagecount
) *
747 sizeof(struct hv_page_buffer
));
748 packetlen
= descsize
+ bufferlen
;
749 packetlen_aligned
= ALIGN(packetlen
, sizeof(u64
));
751 /* Setup the descriptor */
752 desc
.type
= VM_PKT_DATA_USING_GPA_DIRECT
;
754 desc
.dataoffset8
= descsize
>> 3; /* in 8-bytes granularity */
755 desc
.length8
= (u16
)(packetlen_aligned
>> 3);
756 desc
.transactionid
= requestid
;
757 desc
.rangecount
= pagecount
;
759 for (i
= 0; i
< pagecount
; i
++) {
760 desc
.range
[i
].len
= pagebuffers
[i
].len
;
761 desc
.range
[i
].offset
= pagebuffers
[i
].offset
;
762 desc
.range
[i
].pfn
= pagebuffers
[i
].pfn
;
765 bufferlist
[0].iov_base
= &desc
;
766 bufferlist
[0].iov_len
= descsize
;
767 bufferlist
[1].iov_base
= buffer
;
768 bufferlist
[1].iov_len
= bufferlen
;
769 bufferlist
[2].iov_base
= &aligned_data
;
770 bufferlist
[2].iov_len
= (packetlen_aligned
- packetlen
);
772 return hv_ringbuffer_write(channel
, bufferlist
, 3);
774 EXPORT_SYMBOL_GPL(vmbus_sendpacket_pagebuffer_ctl
);
777 * vmbus_sendpacket_pagebuffer - Send a range of single-page buffer
778 * packets using a GPADL Direct packet type.
780 int vmbus_sendpacket_pagebuffer(struct vmbus_channel
*channel
,
781 struct hv_page_buffer pagebuffers
[],
782 u32 pagecount
, void *buffer
, u32 bufferlen
,
785 u32 flags
= VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
;
787 return vmbus_sendpacket_pagebuffer_ctl(channel
, pagebuffers
, pagecount
,
792 EXPORT_SYMBOL_GPL(vmbus_sendpacket_pagebuffer
);
795 * vmbus_sendpacket_multipagebuffer - Send a multi-page buffer packet
796 * using a GPADL Direct packet type.
797 * The buffer includes the vmbus descriptor.
799 int vmbus_sendpacket_mpb_desc(struct vmbus_channel
*channel
,
800 struct vmbus_packet_mpb_array
*desc
,
802 void *buffer
, u32 bufferlen
, u64 requestid
)
805 u32 packetlen_aligned
;
806 struct kvec bufferlist
[3];
807 u64 aligned_data
= 0;
809 packetlen
= desc_size
+ bufferlen
;
810 packetlen_aligned
= ALIGN(packetlen
, sizeof(u64
));
812 /* Setup the descriptor */
813 desc
->type
= VM_PKT_DATA_USING_GPA_DIRECT
;
814 desc
->flags
= VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
;
815 desc
->dataoffset8
= desc_size
>> 3; /* in 8-bytes granularity */
816 desc
->length8
= (u16
)(packetlen_aligned
>> 3);
817 desc
->transactionid
= requestid
;
818 desc
->rangecount
= 1;
820 bufferlist
[0].iov_base
= desc
;
821 bufferlist
[0].iov_len
= desc_size
;
822 bufferlist
[1].iov_base
= buffer
;
823 bufferlist
[1].iov_len
= bufferlen
;
824 bufferlist
[2].iov_base
= &aligned_data
;
825 bufferlist
[2].iov_len
= (packetlen_aligned
- packetlen
);
827 return hv_ringbuffer_write(channel
, bufferlist
, 3);
829 EXPORT_SYMBOL_GPL(vmbus_sendpacket_mpb_desc
);
832 * vmbus_sendpacket_multipagebuffer - Send a multi-page buffer packet
833 * using a GPADL Direct packet type.
835 int vmbus_sendpacket_multipagebuffer(struct vmbus_channel
*channel
,
836 struct hv_multipage_buffer
*multi_pagebuffer
,
837 void *buffer
, u32 bufferlen
, u64 requestid
)
839 struct vmbus_channel_packet_multipage_buffer desc
;
842 u32 packetlen_aligned
;
843 struct kvec bufferlist
[3];
844 u64 aligned_data
= 0;
845 u32 pfncount
= NUM_PAGES_SPANNED(multi_pagebuffer
->offset
,
846 multi_pagebuffer
->len
);
848 if (pfncount
> MAX_MULTIPAGE_BUFFER_COUNT
)
852 * Adjust the size down since vmbus_channel_packet_multipage_buffer is
853 * the largest size we support
855 descsize
= sizeof(struct vmbus_channel_packet_multipage_buffer
) -
856 ((MAX_MULTIPAGE_BUFFER_COUNT
- pfncount
) *
858 packetlen
= descsize
+ bufferlen
;
859 packetlen_aligned
= ALIGN(packetlen
, sizeof(u64
));
862 /* Setup the descriptor */
863 desc
.type
= VM_PKT_DATA_USING_GPA_DIRECT
;
864 desc
.flags
= VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
;
865 desc
.dataoffset8
= descsize
>> 3; /* in 8-bytes granularity */
866 desc
.length8
= (u16
)(packetlen_aligned
>> 3);
867 desc
.transactionid
= requestid
;
870 desc
.range
.len
= multi_pagebuffer
->len
;
871 desc
.range
.offset
= multi_pagebuffer
->offset
;
873 memcpy(desc
.range
.pfn_array
, multi_pagebuffer
->pfn_array
,
874 pfncount
* sizeof(u64
));
876 bufferlist
[0].iov_base
= &desc
;
877 bufferlist
[0].iov_len
= descsize
;
878 bufferlist
[1].iov_base
= buffer
;
879 bufferlist
[1].iov_len
= bufferlen
;
880 bufferlist
[2].iov_base
= &aligned_data
;
881 bufferlist
[2].iov_len
= (packetlen_aligned
- packetlen
);
883 return hv_ringbuffer_write(channel
, bufferlist
, 3);
885 EXPORT_SYMBOL_GPL(vmbus_sendpacket_multipagebuffer
);
888 * vmbus_recvpacket() - Retrieve the user packet on the specified channel
889 * @channel: Pointer to vmbus_channel structure.
890 * @buffer: Pointer to the buffer you want to receive the data into.
891 * @bufferlen: Maximum size of what the the buffer will hold
892 * @buffer_actual_len: The actual size of the data after it was received
893 * @requestid: Identifier of the request
895 * Receives directly from the hyper-v vmbus and puts the data it received
896 * into Buffer. This will receive the data unparsed from hyper-v.
898 * Mainly used by Hyper-V drivers.
901 __vmbus_recvpacket(struct vmbus_channel
*channel
, void *buffer
,
902 u32 bufferlen
, u32
*buffer_actual_len
, u64
*requestid
,
905 return hv_ringbuffer_read(channel
, buffer
, bufferlen
,
906 buffer_actual_len
, requestid
, raw
);
910 int vmbus_recvpacket(struct vmbus_channel
*channel
, void *buffer
,
911 u32 bufferlen
, u32
*buffer_actual_len
,
914 return __vmbus_recvpacket(channel
, buffer
, bufferlen
,
915 buffer_actual_len
, requestid
, false);
917 EXPORT_SYMBOL(vmbus_recvpacket
);
920 * vmbus_recvpacket_raw - Retrieve the raw packet on the specified channel
922 int vmbus_recvpacket_raw(struct vmbus_channel
*channel
, void *buffer
,
923 u32 bufferlen
, u32
*buffer_actual_len
,
926 return __vmbus_recvpacket(channel
, buffer
, bufferlen
,
927 buffer_actual_len
, requestid
, true);
929 EXPORT_SYMBOL_GPL(vmbus_recvpacket_raw
);