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/list.h>
29 #include <linux/module.h>
30 #include <linux/completion.h>
31 #include <linux/hyperv.h>
33 #include "hyperv_vmbus.h"
35 struct vmbus_channel_message_table_entry
{
36 enum vmbus_channel_message_type message_type
;
37 void (*message_handler
)(struct vmbus_channel_message_header
*msg
);
42 * vmbus_prep_negotiate_resp() - Create default response for Hyper-V Negotiate message
43 * @icmsghdrp: Pointer to msg header structure
44 * @icmsg_negotiate: Pointer to negotiate message structure
45 * @buf: Raw buffer channel data
47 * @icmsghdrp is of type &struct icmsg_hdr.
48 * @negop is of type &struct icmsg_negotiate.
49 * Set up and fill in default negotiate response message.
51 * The fw_version specifies the framework version that
52 * we can support and srv_version specifies the service
53 * version we can support.
55 * Mainly used by Hyper-V drivers.
57 bool vmbus_prep_negotiate_resp(struct icmsg_hdr
*icmsghdrp
,
58 struct icmsg_negotiate
*negop
, u8
*buf
,
59 int fw_version
, int srv_version
)
61 int icframe_major
, icframe_minor
;
62 int icmsg_major
, icmsg_minor
;
63 int fw_major
, fw_minor
;
64 int srv_major
, srv_minor
;
66 bool found_match
= false;
68 icmsghdrp
->icmsgsize
= 0x10;
69 fw_major
= (fw_version
>> 16);
70 fw_minor
= (fw_version
& 0xFFFF);
72 srv_major
= (srv_version
>> 16);
73 srv_minor
= (srv_version
& 0xFFFF);
75 negop
= (struct icmsg_negotiate
*)&buf
[
76 sizeof(struct vmbuspipe_hdr
) +
77 sizeof(struct icmsg_hdr
)];
79 icframe_major
= negop
->icframe_vercnt
;
82 icmsg_major
= negop
->icmsg_vercnt
;
86 * Select the framework version number we will
90 for (i
= 0; i
< negop
->icframe_vercnt
; i
++) {
91 if ((negop
->icversion_data
[i
].major
== fw_major
) &&
92 (negop
->icversion_data
[i
].minor
== fw_minor
)) {
93 icframe_major
= negop
->icversion_data
[i
].major
;
94 icframe_minor
= negop
->icversion_data
[i
].minor
;
104 for (i
= negop
->icframe_vercnt
;
105 (i
< negop
->icframe_vercnt
+ negop
->icmsg_vercnt
); i
++) {
106 if ((negop
->icversion_data
[i
].major
== srv_major
) &&
107 (negop
->icversion_data
[i
].minor
== srv_minor
)) {
108 icmsg_major
= negop
->icversion_data
[i
].major
;
109 icmsg_minor
= negop
->icversion_data
[i
].minor
;
115 * Respond with the framework and service
116 * version numbers we can support.
121 negop
->icframe_vercnt
= 0;
122 negop
->icmsg_vercnt
= 0;
124 negop
->icframe_vercnt
= 1;
125 negop
->icmsg_vercnt
= 1;
128 negop
->icversion_data
[0].major
= icframe_major
;
129 negop
->icversion_data
[0].minor
= icframe_minor
;
130 negop
->icversion_data
[1].major
= icmsg_major
;
131 negop
->icversion_data
[1].minor
= icmsg_minor
;
135 EXPORT_SYMBOL_GPL(vmbus_prep_negotiate_resp
);
138 * alloc_channel - Allocate and initialize a vmbus channel object
140 static struct vmbus_channel
*alloc_channel(void)
142 struct vmbus_channel
*channel
;
144 channel
= kzalloc(sizeof(*channel
), GFP_ATOMIC
);
148 spin_lock_init(&channel
->inbound_lock
);
149 spin_lock_init(&channel
->sc_lock
);
151 INIT_LIST_HEAD(&channel
->sc_list
);
153 channel
->controlwq
= create_workqueue("hv_vmbus_ctl");
154 if (!channel
->controlwq
) {
163 * release_hannel - Release the vmbus channel object itself
165 static void release_channel(struct work_struct
*work
)
167 struct vmbus_channel
*channel
= container_of(work
,
168 struct vmbus_channel
,
171 destroy_workqueue(channel
->controlwq
);
177 * free_channel - Release the resources used by the vmbus channel object
179 static void free_channel(struct vmbus_channel
*channel
)
183 * We have to release the channel's workqueue/thread in the vmbus's
184 * workqueue/thread context
185 * ie we can't destroy ourselves.
187 INIT_WORK(&channel
->work
, release_channel
);
188 queue_work(vmbus_connection
.work_queue
, &channel
->work
);
194 * vmbus_process_rescind_offer -
195 * Rescind the offer by initiating a device removal
197 static void vmbus_process_rescind_offer(struct work_struct
*work
)
199 struct vmbus_channel
*channel
= container_of(work
,
200 struct vmbus_channel
,
203 struct vmbus_channel
*primary_channel
;
204 struct vmbus_channel_relid_released msg
;
206 vmbus_device_unregister(channel
->device_obj
);
207 memset(&msg
, 0, sizeof(struct vmbus_channel_relid_released
));
208 msg
.child_relid
= channel
->offermsg
.child_relid
;
209 msg
.header
.msgtype
= CHANNELMSG_RELID_RELEASED
;
210 vmbus_post_msg(&msg
, sizeof(struct vmbus_channel_relid_released
));
212 if (channel
->primary_channel
== NULL
) {
213 spin_lock_irqsave(&vmbus_connection
.channel_lock
, flags
);
214 list_del(&channel
->listentry
);
215 spin_unlock_irqrestore(&vmbus_connection
.channel_lock
, flags
);
217 primary_channel
= channel
->primary_channel
;
218 spin_lock_irqsave(&primary_channel
->sc_lock
, flags
);
219 list_del(&channel
->listentry
);
220 spin_unlock_irqrestore(&primary_channel
->sc_lock
, flags
);
222 free_channel(channel
);
225 void vmbus_free_channels(void)
227 struct vmbus_channel
*channel
;
229 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
230 vmbus_device_unregister(channel
->device_obj
);
231 kfree(channel
->device_obj
);
232 free_channel(channel
);
237 * vmbus_process_offer - Process the offer by creating a channel/device
238 * associated with this offer
240 static void vmbus_process_offer(struct work_struct
*work
)
242 struct vmbus_channel
*newchannel
= container_of(work
,
243 struct vmbus_channel
,
245 struct vmbus_channel
*channel
;
250 /* The next possible work is rescind handling */
251 INIT_WORK(&newchannel
->work
, vmbus_process_rescind_offer
);
253 /* Make sure this is a new offer */
254 spin_lock_irqsave(&vmbus_connection
.channel_lock
, flags
);
256 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
257 if (!uuid_le_cmp(channel
->offermsg
.offer
.if_type
,
258 newchannel
->offermsg
.offer
.if_type
) &&
259 !uuid_le_cmp(channel
->offermsg
.offer
.if_instance
,
260 newchannel
->offermsg
.offer
.if_instance
)) {
267 list_add_tail(&newchannel
->listentry
,
268 &vmbus_connection
.chn_list
);
270 spin_unlock_irqrestore(&vmbus_connection
.channel_lock
, flags
);
274 * Check to see if this is a sub-channel.
276 if (newchannel
->offermsg
.offer
.sub_channel_index
!= 0) {
278 * Process the sub-channel.
280 newchannel
->primary_channel
= channel
;
281 spin_lock_irqsave(&channel
->sc_lock
, flags
);
282 list_add_tail(&newchannel
->sc_list
, &channel
->sc_list
);
283 spin_unlock_irqrestore(&channel
->sc_lock
, flags
);
284 newchannel
->state
= CHANNEL_OPEN_STATE
;
285 if (channel
->sc_creation_callback
!= NULL
)
286 channel
->sc_creation_callback(newchannel
);
291 free_channel(newchannel
);
296 * This state is used to indicate a successful open
297 * so that when we do close the channel normally, we
298 * can cleanup properly
300 newchannel
->state
= CHANNEL_OPEN_STATE
;
303 * Start the process of binding this offer to the driver
304 * We need to set the DeviceObject field before calling
305 * vmbus_child_dev_add()
307 newchannel
->device_obj
= vmbus_device_create(
308 &newchannel
->offermsg
.offer
.if_type
,
309 &newchannel
->offermsg
.offer
.if_instance
,
313 * Add the new device to the bus. This will kick off device-driver
314 * binding which eventually invokes the device driver's AddDevice()
317 ret
= vmbus_device_register(newchannel
->device_obj
);
319 pr_err("unable to add child device object (relid %d)\n",
320 newchannel
->offermsg
.child_relid
);
322 spin_lock_irqsave(&vmbus_connection
.channel_lock
, flags
);
323 list_del(&newchannel
->listentry
);
324 spin_unlock_irqrestore(&vmbus_connection
.channel_lock
, flags
);
325 kfree(newchannel
->device_obj
);
327 free_channel(newchannel
);
339 * This is an array of device_ids (device types) that are performance critical.
340 * We attempt to distribute the interrupt load for these devices across
341 * all available CPUs.
343 static const struct hv_vmbus_device_id hp_devs
[] = {
354 * We use this state to statically distribute the channel interrupt load.
359 * Starting with Win8, we can statically distribute the incoming
360 * channel interrupt load by binding a channel to VCPU. We
361 * implement here a simple round robin scheme for distributing
362 * the interrupt load.
363 * We will bind channels that are not performance critical to cpu 0 and
364 * performance critical channels (IDE, SCSI and Network) will be uniformly
365 * distributed across all available CPUs.
367 static u32
get_vp_index(uuid_le
*type_guid
)
371 bool perf_chn
= false;
372 u32 max_cpus
= num_online_cpus();
374 for (i
= IDE
; i
< MAX_PERF_CHN
; i
++) {
375 if (!memcmp(type_guid
->b
, hp_devs
[i
].guid
,
381 if ((vmbus_proto_version
== VERSION_WS2008
) ||
382 (vmbus_proto_version
== VERSION_WIN7
) || (!perf_chn
)) {
384 * Prior to win8, all channel interrupts are
385 * delivered on cpu 0.
386 * Also if the channel is not a performance critical
387 * channel, bind it to cpu 0.
391 cur_cpu
= (++next_vp
% max_cpus
);
392 return hv_context
.vp_index
[cur_cpu
];
396 * vmbus_onoffer - Handler for channel offers from vmbus in parent partition.
399 static void vmbus_onoffer(struct vmbus_channel_message_header
*hdr
)
401 struct vmbus_channel_offer_channel
*offer
;
402 struct vmbus_channel
*newchannel
;
404 offer
= (struct vmbus_channel_offer_channel
*)hdr
;
406 /* Allocate the channel object and save this offer. */
407 newchannel
= alloc_channel();
409 pr_err("Unable to allocate channel object\n");
414 * By default we setup state to enable batched
415 * reading. A specific service can choose to
416 * disable this prior to opening the channel.
418 newchannel
->batched_reading
= true;
421 * Setup state for signalling the host.
423 newchannel
->sig_event
= (struct hv_input_signal_event
*)
424 (ALIGN((unsigned long)
425 &newchannel
->sig_buf
,
426 HV_HYPERCALL_PARAM_ALIGN
));
428 newchannel
->sig_event
->connectionid
.asu32
= 0;
429 newchannel
->sig_event
->connectionid
.u
.id
= VMBUS_EVENT_CONNECTION_ID
;
430 newchannel
->sig_event
->flag_number
= 0;
431 newchannel
->sig_event
->rsvdz
= 0;
433 if (vmbus_proto_version
!= VERSION_WS2008
) {
434 newchannel
->is_dedicated_interrupt
=
435 (offer
->is_dedicated_interrupt
!= 0);
436 newchannel
->sig_event
->connectionid
.u
.id
=
437 offer
->connection_id
;
440 newchannel
->target_vp
= get_vp_index(&offer
->offer
.if_type
);
442 memcpy(&newchannel
->offermsg
, offer
,
443 sizeof(struct vmbus_channel_offer_channel
));
444 newchannel
->monitor_grp
= (u8
)offer
->monitorid
/ 32;
445 newchannel
->monitor_bit
= (u8
)offer
->monitorid
% 32;
447 INIT_WORK(&newchannel
->work
, vmbus_process_offer
);
448 queue_work(newchannel
->controlwq
, &newchannel
->work
);
452 * vmbus_onoffer_rescind - Rescind offer handler.
454 * We queue a work item to process this offer synchronously
456 static void vmbus_onoffer_rescind(struct vmbus_channel_message_header
*hdr
)
458 struct vmbus_channel_rescind_offer
*rescind
;
459 struct vmbus_channel
*channel
;
461 rescind
= (struct vmbus_channel_rescind_offer
*)hdr
;
462 channel
= relid2channel(rescind
->child_relid
);
465 /* Just return here, no channel found */
468 /* work is initialized for vmbus_process_rescind_offer() from
469 * vmbus_process_offer() where the channel got created */
470 queue_work(channel
->controlwq
, &channel
->work
);
474 * vmbus_onoffers_delivered -
475 * This is invoked when all offers have been delivered.
477 * Nothing to do here.
479 static void vmbus_onoffers_delivered(
480 struct vmbus_channel_message_header
*hdr
)
485 * vmbus_onopen_result - Open result handler.
487 * This is invoked when we received a response to our channel open request.
488 * Find the matching request, copy the response and signal the requesting
491 static void vmbus_onopen_result(struct vmbus_channel_message_header
*hdr
)
493 struct vmbus_channel_open_result
*result
;
494 struct vmbus_channel_msginfo
*msginfo
;
495 struct vmbus_channel_message_header
*requestheader
;
496 struct vmbus_channel_open_channel
*openmsg
;
499 result
= (struct vmbus_channel_open_result
*)hdr
;
502 * Find the open msg, copy the result and signal/unblock the wait event
504 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
506 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
509 (struct vmbus_channel_message_header
*)msginfo
->msg
;
511 if (requestheader
->msgtype
== CHANNELMSG_OPENCHANNEL
) {
513 (struct vmbus_channel_open_channel
*)msginfo
->msg
;
514 if (openmsg
->child_relid
== result
->child_relid
&&
515 openmsg
->openid
== result
->openid
) {
516 memcpy(&msginfo
->response
.open_result
,
519 struct vmbus_channel_open_result
));
520 complete(&msginfo
->waitevent
);
525 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
529 * vmbus_ongpadl_created - GPADL created handler.
531 * This is invoked when we received a response to our gpadl create request.
532 * Find the matching request, copy the response and signal the requesting
535 static void vmbus_ongpadl_created(struct vmbus_channel_message_header
*hdr
)
537 struct vmbus_channel_gpadl_created
*gpadlcreated
;
538 struct vmbus_channel_msginfo
*msginfo
;
539 struct vmbus_channel_message_header
*requestheader
;
540 struct vmbus_channel_gpadl_header
*gpadlheader
;
543 gpadlcreated
= (struct vmbus_channel_gpadl_created
*)hdr
;
546 * Find the establish msg, copy the result and signal/unblock the wait
549 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
551 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
554 (struct vmbus_channel_message_header
*)msginfo
->msg
;
556 if (requestheader
->msgtype
== CHANNELMSG_GPADL_HEADER
) {
558 (struct vmbus_channel_gpadl_header
*)requestheader
;
560 if ((gpadlcreated
->child_relid
==
561 gpadlheader
->child_relid
) &&
562 (gpadlcreated
->gpadl
== gpadlheader
->gpadl
)) {
563 memcpy(&msginfo
->response
.gpadl_created
,
566 struct vmbus_channel_gpadl_created
));
567 complete(&msginfo
->waitevent
);
572 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
576 * vmbus_ongpadl_torndown - GPADL torndown handler.
578 * This is invoked when we received a response to our gpadl teardown request.
579 * Find the matching request, copy the response and signal the requesting
582 static void vmbus_ongpadl_torndown(
583 struct vmbus_channel_message_header
*hdr
)
585 struct vmbus_channel_gpadl_torndown
*gpadl_torndown
;
586 struct vmbus_channel_msginfo
*msginfo
;
587 struct vmbus_channel_message_header
*requestheader
;
588 struct vmbus_channel_gpadl_teardown
*gpadl_teardown
;
591 gpadl_torndown
= (struct vmbus_channel_gpadl_torndown
*)hdr
;
594 * Find the open msg, copy the result and signal/unblock the wait event
596 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
598 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
601 (struct vmbus_channel_message_header
*)msginfo
->msg
;
603 if (requestheader
->msgtype
== CHANNELMSG_GPADL_TEARDOWN
) {
605 (struct vmbus_channel_gpadl_teardown
*)requestheader
;
607 if (gpadl_torndown
->gpadl
== gpadl_teardown
->gpadl
) {
608 memcpy(&msginfo
->response
.gpadl_torndown
,
611 struct vmbus_channel_gpadl_torndown
));
612 complete(&msginfo
->waitevent
);
617 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
621 * vmbus_onversion_response - Version response handler
623 * This is invoked when we received a response to our initiate contact request.
624 * Find the matching request, copy the response and signal the requesting
627 static void vmbus_onversion_response(
628 struct vmbus_channel_message_header
*hdr
)
630 struct vmbus_channel_msginfo
*msginfo
;
631 struct vmbus_channel_message_header
*requestheader
;
632 struct vmbus_channel_version_response
*version_response
;
635 version_response
= (struct vmbus_channel_version_response
*)hdr
;
636 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
638 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
641 (struct vmbus_channel_message_header
*)msginfo
->msg
;
643 if (requestheader
->msgtype
==
644 CHANNELMSG_INITIATE_CONTACT
) {
645 memcpy(&msginfo
->response
.version_response
,
647 sizeof(struct vmbus_channel_version_response
));
648 complete(&msginfo
->waitevent
);
651 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
654 /* Channel message dispatch table */
655 static struct vmbus_channel_message_table_entry
656 channel_message_table
[CHANNELMSG_COUNT
] = {
657 {CHANNELMSG_INVALID
, NULL
},
658 {CHANNELMSG_OFFERCHANNEL
, vmbus_onoffer
},
659 {CHANNELMSG_RESCIND_CHANNELOFFER
, vmbus_onoffer_rescind
},
660 {CHANNELMSG_REQUESTOFFERS
, NULL
},
661 {CHANNELMSG_ALLOFFERS_DELIVERED
, vmbus_onoffers_delivered
},
662 {CHANNELMSG_OPENCHANNEL
, NULL
},
663 {CHANNELMSG_OPENCHANNEL_RESULT
, vmbus_onopen_result
},
664 {CHANNELMSG_CLOSECHANNEL
, NULL
},
665 {CHANNELMSG_GPADL_HEADER
, NULL
},
666 {CHANNELMSG_GPADL_BODY
, NULL
},
667 {CHANNELMSG_GPADL_CREATED
, vmbus_ongpadl_created
},
668 {CHANNELMSG_GPADL_TEARDOWN
, NULL
},
669 {CHANNELMSG_GPADL_TORNDOWN
, vmbus_ongpadl_torndown
},
670 {CHANNELMSG_RELID_RELEASED
, NULL
},
671 {CHANNELMSG_INITIATE_CONTACT
, NULL
},
672 {CHANNELMSG_VERSION_RESPONSE
, vmbus_onversion_response
},
673 {CHANNELMSG_UNLOAD
, NULL
},
677 * vmbus_onmessage - Handler for channel protocol messages.
679 * This is invoked in the vmbus worker thread context.
681 void vmbus_onmessage(void *context
)
683 struct hv_message
*msg
= context
;
684 struct vmbus_channel_message_header
*hdr
;
687 hdr
= (struct vmbus_channel_message_header
*)msg
->u
.payload
;
688 size
= msg
->header
.payload_size
;
690 if (hdr
->msgtype
>= CHANNELMSG_COUNT
) {
691 pr_err("Received invalid channel message type %d size %d\n",
693 print_hex_dump_bytes("", DUMP_PREFIX_NONE
,
694 (unsigned char *)msg
->u
.payload
, size
);
698 if (channel_message_table
[hdr
->msgtype
].message_handler
)
699 channel_message_table
[hdr
->msgtype
].message_handler(hdr
);
701 pr_err("Unhandled channel message type %d\n", hdr
->msgtype
);
705 * vmbus_request_offers - Send a request to get all our pending offers.
707 int vmbus_request_offers(void)
709 struct vmbus_channel_message_header
*msg
;
710 struct vmbus_channel_msginfo
*msginfo
;
713 msginfo
= kmalloc(sizeof(*msginfo
) +
714 sizeof(struct vmbus_channel_message_header
),
719 init_completion(&msginfo
->waitevent
);
721 msg
= (struct vmbus_channel_message_header
*)msginfo
->msg
;
723 msg
->msgtype
= CHANNELMSG_REQUESTOFFERS
;
726 ret
= vmbus_post_msg(msg
,
727 sizeof(struct vmbus_channel_message_header
));
729 pr_err("Unable to request offers - %d\n", ret
);
734 t
= wait_for_completion_timeout(&msginfo
->waitevent
, 5*HZ
);
749 * Retrieve the (sub) channel on which to send an outgoing request.
750 * When a primary channel has multiple sub-channels, we choose a
751 * channel whose VCPU binding is closest to the VCPU on which
752 * this call is being made.
754 struct vmbus_channel
*vmbus_get_outgoing_channel(struct vmbus_channel
*primary
)
756 struct list_head
*cur
, *tmp
;
757 int cur_cpu
= hv_context
.vp_index
[smp_processor_id()];
758 struct vmbus_channel
*cur_channel
;
759 struct vmbus_channel
*outgoing_channel
= primary
;
760 int cpu_distance
, new_cpu_distance
;
762 if (list_empty(&primary
->sc_list
))
763 return outgoing_channel
;
765 list_for_each_safe(cur
, tmp
, &primary
->sc_list
) {
766 cur_channel
= list_entry(cur
, struct vmbus_channel
, sc_list
);
767 if (cur_channel
->state
!= CHANNEL_OPENED_STATE
)
770 if (cur_channel
->target_vp
== cur_cpu
)
773 cpu_distance
= ((outgoing_channel
->target_vp
> cur_cpu
) ?
774 (outgoing_channel
->target_vp
- cur_cpu
) :
775 (cur_cpu
- outgoing_channel
->target_vp
));
777 new_cpu_distance
= ((cur_channel
->target_vp
> cur_cpu
) ?
778 (cur_channel
->target_vp
- cur_cpu
) :
779 (cur_cpu
- cur_channel
->target_vp
));
781 if (cpu_distance
< new_cpu_distance
)
784 outgoing_channel
= cur_channel
;
787 return outgoing_channel
;
789 EXPORT_SYMBOL_GPL(vmbus_get_outgoing_channel
);
791 static void invoke_sc_cb(struct vmbus_channel
*primary_channel
)
793 struct list_head
*cur
, *tmp
;
794 struct vmbus_channel
*cur_channel
;
796 if (primary_channel
->sc_creation_callback
== NULL
)
799 list_for_each_safe(cur
, tmp
, &primary_channel
->sc_list
) {
800 cur_channel
= list_entry(cur
, struct vmbus_channel
, sc_list
);
802 primary_channel
->sc_creation_callback(cur_channel
);
806 void vmbus_set_sc_create_callback(struct vmbus_channel
*primary_channel
,
807 void (*sc_cr_cb
)(struct vmbus_channel
*new_sc
))
809 primary_channel
->sc_creation_callback
= sc_cr_cb
;
811 EXPORT_SYMBOL_GPL(vmbus_set_sc_create_callback
);
813 bool vmbus_are_subchannels_present(struct vmbus_channel
*primary
)
817 ret
= !list_empty(&primary
->sc_list
);
821 * Invoke the callback on sub-channel creation.
822 * This will present a uniform interface to the
825 invoke_sc_cb(primary
);
830 EXPORT_SYMBOL_GPL(vmbus_are_subchannels_present
);