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
);
152 INIT_LIST_HEAD(&channel
->percpu_list
);
154 channel
->controlwq
= create_workqueue("hv_vmbus_ctl");
155 if (!channel
->controlwq
) {
164 * release_hannel - Release the vmbus channel object itself
166 static void release_channel(struct work_struct
*work
)
168 struct vmbus_channel
*channel
= container_of(work
,
169 struct vmbus_channel
,
172 destroy_workqueue(channel
->controlwq
);
178 * free_channel - Release the resources used by the vmbus channel object
180 static void free_channel(struct vmbus_channel
*channel
)
184 * We have to release the channel's workqueue/thread in the vmbus's
185 * workqueue/thread context
186 * ie we can't destroy ourselves.
188 INIT_WORK(&channel
->work
, release_channel
);
189 queue_work(vmbus_connection
.work_queue
, &channel
->work
);
192 static void percpu_channel_enq(void *arg
)
194 struct vmbus_channel
*channel
= arg
;
195 int cpu
= smp_processor_id();
197 list_add_tail(&channel
->percpu_list
, &hv_context
.percpu_list
[cpu
]);
200 static void percpu_channel_deq(void *arg
)
202 struct vmbus_channel
*channel
= arg
;
204 list_del(&channel
->percpu_list
);
208 * vmbus_process_rescind_offer -
209 * Rescind the offer by initiating a device removal
211 static void vmbus_process_rescind_offer(struct work_struct
*work
)
213 struct vmbus_channel
*channel
= container_of(work
,
214 struct vmbus_channel
,
217 struct vmbus_channel
*primary_channel
;
218 struct vmbus_channel_relid_released msg
;
220 if (channel
->device_obj
)
221 vmbus_device_unregister(channel
->device_obj
);
222 memset(&msg
, 0, sizeof(struct vmbus_channel_relid_released
));
223 msg
.child_relid
= channel
->offermsg
.child_relid
;
224 msg
.header
.msgtype
= CHANNELMSG_RELID_RELEASED
;
225 vmbus_post_msg(&msg
, sizeof(struct vmbus_channel_relid_released
));
227 if (channel
->target_cpu
!= smp_processor_id())
228 smp_call_function_single(channel
->target_cpu
,
229 percpu_channel_deq
, channel
, true);
231 percpu_channel_deq(channel
);
233 if (channel
->primary_channel
== NULL
) {
234 spin_lock_irqsave(&vmbus_connection
.channel_lock
, flags
);
235 list_del(&channel
->listentry
);
236 spin_unlock_irqrestore(&vmbus_connection
.channel_lock
, flags
);
238 primary_channel
= channel
->primary_channel
;
239 spin_lock_irqsave(&primary_channel
->sc_lock
, flags
);
240 list_del(&channel
->sc_list
);
241 spin_unlock_irqrestore(&primary_channel
->sc_lock
, flags
);
243 free_channel(channel
);
246 void vmbus_free_channels(void)
248 struct vmbus_channel
*channel
;
250 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
251 vmbus_device_unregister(channel
->device_obj
);
252 kfree(channel
->device_obj
);
253 free_channel(channel
);
258 * vmbus_process_offer - Process the offer by creating a channel/device
259 * associated with this offer
261 static void vmbus_process_offer(struct work_struct
*work
)
263 struct vmbus_channel
*newchannel
= container_of(work
,
264 struct vmbus_channel
,
266 struct vmbus_channel
*channel
;
272 /* The next possible work is rescind handling */
273 INIT_WORK(&newchannel
->work
, vmbus_process_rescind_offer
);
275 /* Make sure this is a new offer */
276 spin_lock_irqsave(&vmbus_connection
.channel_lock
, flags
);
278 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
279 if (!uuid_le_cmp(channel
->offermsg
.offer
.if_type
,
280 newchannel
->offermsg
.offer
.if_type
) &&
281 !uuid_le_cmp(channel
->offermsg
.offer
.if_instance
,
282 newchannel
->offermsg
.offer
.if_instance
)) {
289 list_add_tail(&newchannel
->listentry
,
290 &vmbus_connection
.chn_list
);
294 spin_unlock_irqrestore(&vmbus_connection
.channel_lock
, flags
);
297 if (newchannel
->target_cpu
!= smp_processor_id())
298 smp_call_function_single(newchannel
->target_cpu
,
302 percpu_channel_enq(newchannel
);
306 * Check to see if this is a sub-channel.
308 if (newchannel
->offermsg
.offer
.sub_channel_index
!= 0) {
310 * Process the sub-channel.
312 newchannel
->primary_channel
= channel
;
313 spin_lock_irqsave(&channel
->sc_lock
, flags
);
314 list_add_tail(&newchannel
->sc_list
, &channel
->sc_list
);
315 spin_unlock_irqrestore(&channel
->sc_lock
, flags
);
317 if (newchannel
->target_cpu
!= smp_processor_id())
318 smp_call_function_single(newchannel
->target_cpu
,
322 percpu_channel_enq(newchannel
);
324 newchannel
->state
= CHANNEL_OPEN_STATE
;
325 if (channel
->sc_creation_callback
!= NULL
)
326 channel
->sc_creation_callback(newchannel
);
331 free_channel(newchannel
);
336 * This state is used to indicate a successful open
337 * so that when we do close the channel normally, we
338 * can cleanup properly
340 newchannel
->state
= CHANNEL_OPEN_STATE
;
343 * Start the process of binding this offer to the driver
344 * We need to set the DeviceObject field before calling
345 * vmbus_child_dev_add()
347 newchannel
->device_obj
= vmbus_device_create(
348 &newchannel
->offermsg
.offer
.if_type
,
349 &newchannel
->offermsg
.offer
.if_instance
,
353 * Add the new device to the bus. This will kick off device-driver
354 * binding which eventually invokes the device driver's AddDevice()
357 ret
= vmbus_device_register(newchannel
->device_obj
);
359 pr_err("unable to add child device object (relid %d)\n",
360 newchannel
->offermsg
.child_relid
);
362 spin_lock_irqsave(&vmbus_connection
.channel_lock
, flags
);
363 list_del(&newchannel
->listentry
);
364 spin_unlock_irqrestore(&vmbus_connection
.channel_lock
, flags
);
365 kfree(newchannel
->device_obj
);
367 free_channel(newchannel
);
379 * This is an array of device_ids (device types) that are performance critical.
380 * We attempt to distribute the interrupt load for these devices across
381 * all available CPUs.
383 static const struct hv_vmbus_device_id hp_devs
[] = {
394 * We use this state to statically distribute the channel interrupt load.
399 * Starting with Win8, we can statically distribute the incoming
400 * channel interrupt load by binding a channel to VCPU. We
401 * implement here a simple round robin scheme for distributing
402 * the interrupt load.
403 * We will bind channels that are not performance critical to cpu 0 and
404 * performance critical channels (IDE, SCSI and Network) will be uniformly
405 * distributed across all available CPUs.
407 static void init_vp_index(struct vmbus_channel
*channel
, uuid_le
*type_guid
)
411 bool perf_chn
= false;
412 u32 max_cpus
= num_online_cpus();
414 for (i
= IDE
; i
< MAX_PERF_CHN
; i
++) {
415 if (!memcmp(type_guid
->b
, hp_devs
[i
].guid
,
421 if ((vmbus_proto_version
== VERSION_WS2008
) ||
422 (vmbus_proto_version
== VERSION_WIN7
) || (!perf_chn
)) {
424 * Prior to win8, all channel interrupts are
425 * delivered on cpu 0.
426 * Also if the channel is not a performance critical
427 * channel, bind it to cpu 0.
429 channel
->target_cpu
= 0;
430 channel
->target_vp
= 0;
433 cur_cpu
= (++next_vp
% max_cpus
);
434 channel
->target_cpu
= cur_cpu
;
435 channel
->target_vp
= hv_context
.vp_index
[cur_cpu
];
439 * vmbus_onoffer - Handler for channel offers from vmbus in parent partition.
442 static void vmbus_onoffer(struct vmbus_channel_message_header
*hdr
)
444 struct vmbus_channel_offer_channel
*offer
;
445 struct vmbus_channel
*newchannel
;
447 offer
= (struct vmbus_channel_offer_channel
*)hdr
;
449 /* Allocate the channel object and save this offer. */
450 newchannel
= alloc_channel();
452 pr_err("Unable to allocate channel object\n");
457 * By default we setup state to enable batched
458 * reading. A specific service can choose to
459 * disable this prior to opening the channel.
461 newchannel
->batched_reading
= true;
464 * Setup state for signalling the host.
466 newchannel
->sig_event
= (struct hv_input_signal_event
*)
467 (ALIGN((unsigned long)
468 &newchannel
->sig_buf
,
469 HV_HYPERCALL_PARAM_ALIGN
));
471 newchannel
->sig_event
->connectionid
.asu32
= 0;
472 newchannel
->sig_event
->connectionid
.u
.id
= VMBUS_EVENT_CONNECTION_ID
;
473 newchannel
->sig_event
->flag_number
= 0;
474 newchannel
->sig_event
->rsvdz
= 0;
476 if (vmbus_proto_version
!= VERSION_WS2008
) {
477 newchannel
->is_dedicated_interrupt
=
478 (offer
->is_dedicated_interrupt
!= 0);
479 newchannel
->sig_event
->connectionid
.u
.id
=
480 offer
->connection_id
;
483 init_vp_index(newchannel
, &offer
->offer
.if_type
);
485 memcpy(&newchannel
->offermsg
, offer
,
486 sizeof(struct vmbus_channel_offer_channel
));
487 newchannel
->monitor_grp
= (u8
)offer
->monitorid
/ 32;
488 newchannel
->monitor_bit
= (u8
)offer
->monitorid
% 32;
490 INIT_WORK(&newchannel
->work
, vmbus_process_offer
);
491 queue_work(newchannel
->controlwq
, &newchannel
->work
);
495 * vmbus_onoffer_rescind - Rescind offer handler.
497 * We queue a work item to process this offer synchronously
499 static void vmbus_onoffer_rescind(struct vmbus_channel_message_header
*hdr
)
501 struct vmbus_channel_rescind_offer
*rescind
;
502 struct vmbus_channel
*channel
;
504 rescind
= (struct vmbus_channel_rescind_offer
*)hdr
;
505 channel
= relid2channel(rescind
->child_relid
);
508 /* Just return here, no channel found */
511 /* work is initialized for vmbus_process_rescind_offer() from
512 * vmbus_process_offer() where the channel got created */
513 queue_work(channel
->controlwq
, &channel
->work
);
517 * vmbus_onoffers_delivered -
518 * This is invoked when all offers have been delivered.
520 * Nothing to do here.
522 static void vmbus_onoffers_delivered(
523 struct vmbus_channel_message_header
*hdr
)
528 * vmbus_onopen_result - Open result handler.
530 * This is invoked when we received a response to our channel open request.
531 * Find the matching request, copy the response and signal the requesting
534 static void vmbus_onopen_result(struct vmbus_channel_message_header
*hdr
)
536 struct vmbus_channel_open_result
*result
;
537 struct vmbus_channel_msginfo
*msginfo
;
538 struct vmbus_channel_message_header
*requestheader
;
539 struct vmbus_channel_open_channel
*openmsg
;
542 result
= (struct vmbus_channel_open_result
*)hdr
;
545 * Find the open msg, copy the result and signal/unblock the wait event
547 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
549 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
552 (struct vmbus_channel_message_header
*)msginfo
->msg
;
554 if (requestheader
->msgtype
== CHANNELMSG_OPENCHANNEL
) {
556 (struct vmbus_channel_open_channel
*)msginfo
->msg
;
557 if (openmsg
->child_relid
== result
->child_relid
&&
558 openmsg
->openid
== result
->openid
) {
559 memcpy(&msginfo
->response
.open_result
,
562 struct vmbus_channel_open_result
));
563 complete(&msginfo
->waitevent
);
568 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
572 * vmbus_ongpadl_created - GPADL created handler.
574 * This is invoked when we received a response to our gpadl create request.
575 * Find the matching request, copy the response and signal the requesting
578 static void vmbus_ongpadl_created(struct vmbus_channel_message_header
*hdr
)
580 struct vmbus_channel_gpadl_created
*gpadlcreated
;
581 struct vmbus_channel_msginfo
*msginfo
;
582 struct vmbus_channel_message_header
*requestheader
;
583 struct vmbus_channel_gpadl_header
*gpadlheader
;
586 gpadlcreated
= (struct vmbus_channel_gpadl_created
*)hdr
;
589 * Find the establish msg, copy the result and signal/unblock the wait
592 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
594 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
597 (struct vmbus_channel_message_header
*)msginfo
->msg
;
599 if (requestheader
->msgtype
== CHANNELMSG_GPADL_HEADER
) {
601 (struct vmbus_channel_gpadl_header
*)requestheader
;
603 if ((gpadlcreated
->child_relid
==
604 gpadlheader
->child_relid
) &&
605 (gpadlcreated
->gpadl
== gpadlheader
->gpadl
)) {
606 memcpy(&msginfo
->response
.gpadl_created
,
609 struct vmbus_channel_gpadl_created
));
610 complete(&msginfo
->waitevent
);
615 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
619 * vmbus_ongpadl_torndown - GPADL torndown handler.
621 * This is invoked when we received a response to our gpadl teardown request.
622 * Find the matching request, copy the response and signal the requesting
625 static void vmbus_ongpadl_torndown(
626 struct vmbus_channel_message_header
*hdr
)
628 struct vmbus_channel_gpadl_torndown
*gpadl_torndown
;
629 struct vmbus_channel_msginfo
*msginfo
;
630 struct vmbus_channel_message_header
*requestheader
;
631 struct vmbus_channel_gpadl_teardown
*gpadl_teardown
;
634 gpadl_torndown
= (struct vmbus_channel_gpadl_torndown
*)hdr
;
637 * Find the open msg, copy the result and signal/unblock the wait event
639 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
641 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
644 (struct vmbus_channel_message_header
*)msginfo
->msg
;
646 if (requestheader
->msgtype
== CHANNELMSG_GPADL_TEARDOWN
) {
648 (struct vmbus_channel_gpadl_teardown
*)requestheader
;
650 if (gpadl_torndown
->gpadl
== gpadl_teardown
->gpadl
) {
651 memcpy(&msginfo
->response
.gpadl_torndown
,
654 struct vmbus_channel_gpadl_torndown
));
655 complete(&msginfo
->waitevent
);
660 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
664 * vmbus_onversion_response - Version response handler
666 * This is invoked when we received a response to our initiate contact request.
667 * Find the matching request, copy the response and signal the requesting
670 static void vmbus_onversion_response(
671 struct vmbus_channel_message_header
*hdr
)
673 struct vmbus_channel_msginfo
*msginfo
;
674 struct vmbus_channel_message_header
*requestheader
;
675 struct vmbus_channel_version_response
*version_response
;
678 version_response
= (struct vmbus_channel_version_response
*)hdr
;
679 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
681 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
684 (struct vmbus_channel_message_header
*)msginfo
->msg
;
686 if (requestheader
->msgtype
==
687 CHANNELMSG_INITIATE_CONTACT
) {
688 memcpy(&msginfo
->response
.version_response
,
690 sizeof(struct vmbus_channel_version_response
));
691 complete(&msginfo
->waitevent
);
694 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
697 /* Channel message dispatch table */
698 static struct vmbus_channel_message_table_entry
699 channel_message_table
[CHANNELMSG_COUNT
] = {
700 {CHANNELMSG_INVALID
, NULL
},
701 {CHANNELMSG_OFFERCHANNEL
, vmbus_onoffer
},
702 {CHANNELMSG_RESCIND_CHANNELOFFER
, vmbus_onoffer_rescind
},
703 {CHANNELMSG_REQUESTOFFERS
, NULL
},
704 {CHANNELMSG_ALLOFFERS_DELIVERED
, vmbus_onoffers_delivered
},
705 {CHANNELMSG_OPENCHANNEL
, NULL
},
706 {CHANNELMSG_OPENCHANNEL_RESULT
, vmbus_onopen_result
},
707 {CHANNELMSG_CLOSECHANNEL
, NULL
},
708 {CHANNELMSG_GPADL_HEADER
, NULL
},
709 {CHANNELMSG_GPADL_BODY
, NULL
},
710 {CHANNELMSG_GPADL_CREATED
, vmbus_ongpadl_created
},
711 {CHANNELMSG_GPADL_TEARDOWN
, NULL
},
712 {CHANNELMSG_GPADL_TORNDOWN
, vmbus_ongpadl_torndown
},
713 {CHANNELMSG_RELID_RELEASED
, NULL
},
714 {CHANNELMSG_INITIATE_CONTACT
, NULL
},
715 {CHANNELMSG_VERSION_RESPONSE
, vmbus_onversion_response
},
716 {CHANNELMSG_UNLOAD
, NULL
},
720 * vmbus_onmessage - Handler for channel protocol messages.
722 * This is invoked in the vmbus worker thread context.
724 void vmbus_onmessage(void *context
)
726 struct hv_message
*msg
= context
;
727 struct vmbus_channel_message_header
*hdr
;
730 hdr
= (struct vmbus_channel_message_header
*)msg
->u
.payload
;
731 size
= msg
->header
.payload_size
;
733 if (hdr
->msgtype
>= CHANNELMSG_COUNT
) {
734 pr_err("Received invalid channel message type %d size %d\n",
736 print_hex_dump_bytes("", DUMP_PREFIX_NONE
,
737 (unsigned char *)msg
->u
.payload
, size
);
741 if (channel_message_table
[hdr
->msgtype
].message_handler
)
742 channel_message_table
[hdr
->msgtype
].message_handler(hdr
);
744 pr_err("Unhandled channel message type %d\n", hdr
->msgtype
);
748 * vmbus_request_offers - Send a request to get all our pending offers.
750 int vmbus_request_offers(void)
752 struct vmbus_channel_message_header
*msg
;
753 struct vmbus_channel_msginfo
*msginfo
;
756 msginfo
= kmalloc(sizeof(*msginfo
) +
757 sizeof(struct vmbus_channel_message_header
),
762 init_completion(&msginfo
->waitevent
);
764 msg
= (struct vmbus_channel_message_header
*)msginfo
->msg
;
766 msg
->msgtype
= CHANNELMSG_REQUESTOFFERS
;
769 ret
= vmbus_post_msg(msg
,
770 sizeof(struct vmbus_channel_message_header
));
772 pr_err("Unable to request offers - %d\n", ret
);
777 t
= wait_for_completion_timeout(&msginfo
->waitevent
, 5*HZ
);
792 * Retrieve the (sub) channel on which to send an outgoing request.
793 * When a primary channel has multiple sub-channels, we choose a
794 * channel whose VCPU binding is closest to the VCPU on which
795 * this call is being made.
797 struct vmbus_channel
*vmbus_get_outgoing_channel(struct vmbus_channel
*primary
)
799 struct list_head
*cur
, *tmp
;
800 int cur_cpu
= hv_context
.vp_index
[smp_processor_id()];
801 struct vmbus_channel
*cur_channel
;
802 struct vmbus_channel
*outgoing_channel
= primary
;
803 int cpu_distance
, new_cpu_distance
;
805 if (list_empty(&primary
->sc_list
))
806 return outgoing_channel
;
808 list_for_each_safe(cur
, tmp
, &primary
->sc_list
) {
809 cur_channel
= list_entry(cur
, struct vmbus_channel
, sc_list
);
810 if (cur_channel
->state
!= CHANNEL_OPENED_STATE
)
813 if (cur_channel
->target_vp
== cur_cpu
)
816 cpu_distance
= ((outgoing_channel
->target_vp
> cur_cpu
) ?
817 (outgoing_channel
->target_vp
- cur_cpu
) :
818 (cur_cpu
- outgoing_channel
->target_vp
));
820 new_cpu_distance
= ((cur_channel
->target_vp
> cur_cpu
) ?
821 (cur_channel
->target_vp
- cur_cpu
) :
822 (cur_cpu
- cur_channel
->target_vp
));
824 if (cpu_distance
< new_cpu_distance
)
827 outgoing_channel
= cur_channel
;
830 return outgoing_channel
;
832 EXPORT_SYMBOL_GPL(vmbus_get_outgoing_channel
);
834 static void invoke_sc_cb(struct vmbus_channel
*primary_channel
)
836 struct list_head
*cur
, *tmp
;
837 struct vmbus_channel
*cur_channel
;
839 if (primary_channel
->sc_creation_callback
== NULL
)
842 list_for_each_safe(cur
, tmp
, &primary_channel
->sc_list
) {
843 cur_channel
= list_entry(cur
, struct vmbus_channel
, sc_list
);
845 primary_channel
->sc_creation_callback(cur_channel
);
849 void vmbus_set_sc_create_callback(struct vmbus_channel
*primary_channel
,
850 void (*sc_cr_cb
)(struct vmbus_channel
*new_sc
))
852 primary_channel
->sc_creation_callback
= sc_cr_cb
;
854 EXPORT_SYMBOL_GPL(vmbus_set_sc_create_callback
);
856 bool vmbus_are_subchannels_present(struct vmbus_channel
*primary
)
860 ret
= !list_empty(&primary
->sc_list
);
864 * Invoke the callback on sub-channel creation.
865 * This will present a uniform interface to the
868 invoke_sc_cb(primary
);
873 EXPORT_SYMBOL_GPL(vmbus_are_subchannels_present
);