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/delay.h>
32 #include <linux/hyperv.h>
34 #include "hyperv_vmbus.h"
36 static void init_vp_index(struct vmbus_channel
*channel
, u16 dev_type
);
38 static const struct vmbus_device vmbus_devs
[] = {
46 { .dev_type
= HV_SCSI
,
70 { .dev_type
= HV_PCIE
,
75 /* Synthetic Frame Buffer */
81 /* Synthetic Keyboard */
88 { .dev_type
= HV_MOUSE
,
102 .perf_device
= false,
108 .perf_device
= false,
112 { .dev_type
= HV_SHUTDOWN
,
114 .perf_device
= false,
118 { .dev_type
= HV_FCOPY
,
120 .perf_device
= false,
124 { .dev_type
= HV_BACKUP
,
126 .perf_device
= false,
132 .perf_device
= false,
136 { .dev_type
= HV_UNKOWN
,
137 .perf_device
= false,
141 static u16
hv_get_dev_type(const uuid_le
*guid
)
145 for (i
= HV_IDE
; i
< HV_UNKOWN
; i
++) {
146 if (!uuid_le_cmp(*guid
, vmbus_devs
[i
].guid
))
149 pr_info("Unknown GUID: %pUl\n", guid
);
154 * vmbus_prep_negotiate_resp() - Create default response for Hyper-V Negotiate message
155 * @icmsghdrp: Pointer to msg header structure
156 * @icmsg_negotiate: Pointer to negotiate message structure
157 * @buf: Raw buffer channel data
159 * @icmsghdrp is of type &struct icmsg_hdr.
160 * @negop is of type &struct icmsg_negotiate.
161 * Set up and fill in default negotiate response message.
163 * The fw_version specifies the framework version that
164 * we can support and srv_version specifies the service
165 * version we can support.
167 * Mainly used by Hyper-V drivers.
169 bool vmbus_prep_negotiate_resp(struct icmsg_hdr
*icmsghdrp
,
170 struct icmsg_negotiate
*negop
, u8
*buf
,
171 int fw_version
, int srv_version
)
173 int icframe_major
, icframe_minor
;
174 int icmsg_major
, icmsg_minor
;
175 int fw_major
, fw_minor
;
176 int srv_major
, srv_minor
;
178 bool found_match
= false;
180 icmsghdrp
->icmsgsize
= 0x10;
181 fw_major
= (fw_version
>> 16);
182 fw_minor
= (fw_version
& 0xFFFF);
184 srv_major
= (srv_version
>> 16);
185 srv_minor
= (srv_version
& 0xFFFF);
187 negop
= (struct icmsg_negotiate
*)&buf
[
188 sizeof(struct vmbuspipe_hdr
) +
189 sizeof(struct icmsg_hdr
)];
191 icframe_major
= negop
->icframe_vercnt
;
194 icmsg_major
= negop
->icmsg_vercnt
;
198 * Select the framework version number we will
202 for (i
= 0; i
< negop
->icframe_vercnt
; i
++) {
203 if ((negop
->icversion_data
[i
].major
== fw_major
) &&
204 (negop
->icversion_data
[i
].minor
== fw_minor
)) {
205 icframe_major
= negop
->icversion_data
[i
].major
;
206 icframe_minor
= negop
->icversion_data
[i
].minor
;
216 for (i
= negop
->icframe_vercnt
;
217 (i
< negop
->icframe_vercnt
+ negop
->icmsg_vercnt
); i
++) {
218 if ((negop
->icversion_data
[i
].major
== srv_major
) &&
219 (negop
->icversion_data
[i
].minor
== srv_minor
)) {
220 icmsg_major
= negop
->icversion_data
[i
].major
;
221 icmsg_minor
= negop
->icversion_data
[i
].minor
;
227 * Respond with the framework and service
228 * version numbers we can support.
233 negop
->icframe_vercnt
= 0;
234 negop
->icmsg_vercnt
= 0;
236 negop
->icframe_vercnt
= 1;
237 negop
->icmsg_vercnt
= 1;
240 negop
->icversion_data
[0].major
= icframe_major
;
241 negop
->icversion_data
[0].minor
= icframe_minor
;
242 negop
->icversion_data
[1].major
= icmsg_major
;
243 negop
->icversion_data
[1].minor
= icmsg_minor
;
247 EXPORT_SYMBOL_GPL(vmbus_prep_negotiate_resp
);
250 * alloc_channel - Allocate and initialize a vmbus channel object
252 static struct vmbus_channel
*alloc_channel(void)
254 static atomic_t chan_num
= ATOMIC_INIT(0);
255 struct vmbus_channel
*channel
;
257 channel
= kzalloc(sizeof(*channel
), GFP_ATOMIC
);
261 channel
->id
= atomic_inc_return(&chan_num
);
262 channel
->acquire_ring_lock
= true;
263 spin_lock_init(&channel
->inbound_lock
);
264 spin_lock_init(&channel
->lock
);
266 INIT_LIST_HEAD(&channel
->sc_list
);
267 INIT_LIST_HEAD(&channel
->percpu_list
);
273 * free_channel - Release the resources used by the vmbus channel object
275 static void free_channel(struct vmbus_channel
*channel
)
280 static void percpu_channel_enq(void *arg
)
282 struct vmbus_channel
*channel
= arg
;
283 int cpu
= smp_processor_id();
285 list_add_tail(&channel
->percpu_list
, &hv_context
.percpu_list
[cpu
]);
288 static void percpu_channel_deq(void *arg
)
290 struct vmbus_channel
*channel
= arg
;
292 list_del(&channel
->percpu_list
);
296 static void vmbus_release_relid(u32 relid
)
298 struct vmbus_channel_relid_released msg
;
300 memset(&msg
, 0, sizeof(struct vmbus_channel_relid_released
));
301 msg
.child_relid
= relid
;
302 msg
.header
.msgtype
= CHANNELMSG_RELID_RELEASED
;
303 vmbus_post_msg(&msg
, sizeof(struct vmbus_channel_relid_released
));
306 void hv_process_channel_removal(struct vmbus_channel
*channel
, u32 relid
)
309 struct vmbus_channel
*primary_channel
;
311 vmbus_release_relid(relid
);
313 BUG_ON(!channel
->rescind
);
314 BUG_ON(!mutex_is_locked(&vmbus_connection
.channel_mutex
));
316 if (channel
->target_cpu
!= get_cpu()) {
318 smp_call_function_single(channel
->target_cpu
,
319 percpu_channel_deq
, channel
, true);
321 percpu_channel_deq(channel
);
325 if (channel
->primary_channel
== NULL
) {
326 list_del(&channel
->listentry
);
328 primary_channel
= channel
;
330 primary_channel
= channel
->primary_channel
;
331 spin_lock_irqsave(&primary_channel
->lock
, flags
);
332 list_del(&channel
->sc_list
);
333 primary_channel
->num_sc
--;
334 spin_unlock_irqrestore(&primary_channel
->lock
, flags
);
338 * We need to free the bit for init_vp_index() to work in the case
339 * of sub-channel, when we reload drivers like hv_netvsc.
341 cpumask_clear_cpu(channel
->target_cpu
,
342 &primary_channel
->alloced_cpus_in_node
);
344 free_channel(channel
);
347 void vmbus_free_channels(void)
349 struct vmbus_channel
*channel
, *tmp
;
351 list_for_each_entry_safe(channel
, tmp
, &vmbus_connection
.chn_list
,
353 /* hv_process_channel_removal() needs this */
354 channel
->rescind
= true;
356 vmbus_device_unregister(channel
->device_obj
);
361 * vmbus_process_offer - Process the offer by creating a channel/device
362 * associated with this offer
364 static void vmbus_process_offer(struct vmbus_channel
*newchannel
)
366 struct vmbus_channel
*channel
;
372 /* Make sure this is a new offer */
373 mutex_lock(&vmbus_connection
.channel_mutex
);
375 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
376 if (!uuid_le_cmp(channel
->offermsg
.offer
.if_type
,
377 newchannel
->offermsg
.offer
.if_type
) &&
378 !uuid_le_cmp(channel
->offermsg
.offer
.if_instance
,
379 newchannel
->offermsg
.offer
.if_instance
)) {
386 list_add_tail(&newchannel
->listentry
,
387 &vmbus_connection
.chn_list
);
389 mutex_unlock(&vmbus_connection
.channel_mutex
);
393 * Check to see if this is a sub-channel.
395 if (newchannel
->offermsg
.offer
.sub_channel_index
!= 0) {
397 * Process the sub-channel.
399 newchannel
->primary_channel
= channel
;
400 spin_lock_irqsave(&channel
->lock
, flags
);
401 list_add_tail(&newchannel
->sc_list
, &channel
->sc_list
);
403 spin_unlock_irqrestore(&channel
->lock
, flags
);
408 dev_type
= hv_get_dev_type(&newchannel
->offermsg
.offer
.if_type
);
410 init_vp_index(newchannel
, dev_type
);
412 if (newchannel
->target_cpu
!= get_cpu()) {
414 smp_call_function_single(newchannel
->target_cpu
,
418 percpu_channel_enq(newchannel
);
423 * This state is used to indicate a successful open
424 * so that when we do close the channel normally, we
425 * can cleanup properly
427 newchannel
->state
= CHANNEL_OPEN_STATE
;
430 if (channel
->sc_creation_callback
!= NULL
)
431 channel
->sc_creation_callback(newchannel
);
436 * Start the process of binding this offer to the driver
437 * We need to set the DeviceObject field before calling
438 * vmbus_child_dev_add()
440 newchannel
->device_obj
= vmbus_device_create(
441 &newchannel
->offermsg
.offer
.if_type
,
442 &newchannel
->offermsg
.offer
.if_instance
,
444 if (!newchannel
->device_obj
)
447 newchannel
->device_obj
->device_id
= dev_type
;
449 * Add the new device to the bus. This will kick off device-driver
450 * binding which eventually invokes the device driver's AddDevice()
453 mutex_lock(&vmbus_connection
.channel_mutex
);
454 ret
= vmbus_device_register(newchannel
->device_obj
);
455 mutex_unlock(&vmbus_connection
.channel_mutex
);
458 pr_err("unable to add child device object (relid %d)\n",
459 newchannel
->offermsg
.child_relid
);
460 kfree(newchannel
->device_obj
);
466 vmbus_release_relid(newchannel
->offermsg
.child_relid
);
468 mutex_lock(&vmbus_connection
.channel_mutex
);
469 list_del(&newchannel
->listentry
);
470 mutex_unlock(&vmbus_connection
.channel_mutex
);
472 if (newchannel
->target_cpu
!= get_cpu()) {
474 smp_call_function_single(newchannel
->target_cpu
,
475 percpu_channel_deq
, newchannel
, true);
477 percpu_channel_deq(newchannel
);
482 free_channel(newchannel
);
486 * We use this state to statically distribute the channel interrupt load.
488 static int next_numa_node_id
;
491 * Starting with Win8, we can statically distribute the incoming
492 * channel interrupt load by binding a channel to VCPU.
493 * We do this in a hierarchical fashion:
494 * First distribute the primary channels across available NUMA nodes
495 * and then distribute the subchannels amongst the CPUs in the NUMA
496 * node assigned to the primary channel.
498 * For pre-win8 hosts or non-performance critical channels we assign the
499 * first CPU in the first NUMA node.
501 static void init_vp_index(struct vmbus_channel
*channel
, u16 dev_type
)
504 bool perf_chn
= vmbus_devs
[dev_type
].perf_device
;
505 struct vmbus_channel
*primary
= channel
->primary_channel
;
507 struct cpumask available_mask
;
508 struct cpumask
*alloced_mask
;
510 if ((vmbus_proto_version
== VERSION_WS2008
) ||
511 (vmbus_proto_version
== VERSION_WIN7
) || (!perf_chn
)) {
513 * Prior to win8, all channel interrupts are
514 * delivered on cpu 0.
515 * Also if the channel is not a performance critical
516 * channel, bind it to cpu 0.
518 channel
->numa_node
= 0;
519 channel
->target_cpu
= 0;
520 channel
->target_vp
= hv_context
.vp_index
[0];
525 * We distribute primary channels evenly across all the available
526 * NUMA nodes and within the assigned NUMA node we will assign the
527 * first available CPU to the primary channel.
528 * The sub-channels will be assigned to the CPUs available in the
533 next_node
= next_numa_node_id
++;
534 if (next_node
== nr_node_ids
)
535 next_node
= next_numa_node_id
= 0;
536 if (cpumask_empty(cpumask_of_node(next_node
)))
540 channel
->numa_node
= next_node
;
543 alloced_mask
= &hv_context
.hv_numa_map
[primary
->numa_node
];
545 if (cpumask_weight(alloced_mask
) ==
546 cpumask_weight(cpumask_of_node(primary
->numa_node
))) {
548 * We have cycled through all the CPUs in the node;
549 * reset the alloced map.
551 cpumask_clear(alloced_mask
);
554 cpumask_xor(&available_mask
, alloced_mask
,
555 cpumask_of_node(primary
->numa_node
));
560 * Normally Hyper-V host doesn't create more subchannels than there
561 * are VCPUs on the node but it is possible when not all present VCPUs
562 * on the node are initialized by guest. Clear the alloced_cpus_in_node
565 if (cpumask_equal(&primary
->alloced_cpus_in_node
,
566 cpumask_of_node(primary
->numa_node
)))
567 cpumask_clear(&primary
->alloced_cpus_in_node
);
570 cur_cpu
= cpumask_next(cur_cpu
, &available_mask
);
571 if (cur_cpu
>= nr_cpu_ids
) {
573 cpumask_copy(&available_mask
,
574 cpumask_of_node(primary
->numa_node
));
579 * NOTE: in the case of sub-channel, we clear the sub-channel
580 * related bit(s) in primary->alloced_cpus_in_node in
581 * hv_process_channel_removal(), so when we reload drivers
582 * like hv_netvsc in SMP guest, here we're able to re-allocate
583 * bit from primary->alloced_cpus_in_node.
585 if (!cpumask_test_cpu(cur_cpu
,
586 &primary
->alloced_cpus_in_node
)) {
587 cpumask_set_cpu(cur_cpu
,
588 &primary
->alloced_cpus_in_node
);
589 cpumask_set_cpu(cur_cpu
, alloced_mask
);
594 channel
->target_cpu
= cur_cpu
;
595 channel
->target_vp
= hv_context
.vp_index
[cur_cpu
];
598 static void vmbus_wait_for_unload(void)
600 int cpu
= smp_processor_id();
601 void *page_addr
= hv_context
.synic_message_page
[cpu
];
602 struct hv_message
*msg
= (struct hv_message
*)page_addr
+
604 struct vmbus_channel_message_header
*hdr
;
605 bool unloaded
= false;
608 if (READ_ONCE(msg
->header
.message_type
) == HVMSG_NONE
) {
613 hdr
= (struct vmbus_channel_message_header
*)msg
->u
.payload
;
614 if (hdr
->msgtype
== CHANNELMSG_UNLOAD_RESPONSE
)
617 vmbus_signal_eom(msg
);
625 * vmbus_unload_response - Handler for the unload response.
627 static void vmbus_unload_response(struct vmbus_channel_message_header
*hdr
)
630 * This is a global event; just wakeup the waiting thread.
631 * Once we successfully unload, we can cleanup the monitor state.
633 complete(&vmbus_connection
.unload_event
);
636 void vmbus_initiate_unload(bool crash
)
638 struct vmbus_channel_message_header hdr
;
640 /* Pre-Win2012R2 hosts don't support reconnect */
641 if (vmbus_proto_version
< VERSION_WIN8_1
)
644 init_completion(&vmbus_connection
.unload_event
);
645 memset(&hdr
, 0, sizeof(struct vmbus_channel_message_header
));
646 hdr
.msgtype
= CHANNELMSG_UNLOAD
;
647 vmbus_post_msg(&hdr
, sizeof(struct vmbus_channel_message_header
));
650 * vmbus_initiate_unload() is also called on crash and the crash can be
651 * happening in an interrupt context, where scheduling is impossible.
654 wait_for_completion(&vmbus_connection
.unload_event
);
656 vmbus_wait_for_unload();
660 * vmbus_onoffer - Handler for channel offers from vmbus in parent partition.
663 static void vmbus_onoffer(struct vmbus_channel_message_header
*hdr
)
665 struct vmbus_channel_offer_channel
*offer
;
666 struct vmbus_channel
*newchannel
;
668 offer
= (struct vmbus_channel_offer_channel
*)hdr
;
670 /* Allocate the channel object and save this offer. */
671 newchannel
= alloc_channel();
673 pr_err("Unable to allocate channel object\n");
678 * By default we setup state to enable batched
679 * reading. A specific service can choose to
680 * disable this prior to opening the channel.
682 newchannel
->batched_reading
= true;
685 * Setup state for signalling the host.
687 newchannel
->sig_event
= (struct hv_input_signal_event
*)
688 (ALIGN((unsigned long)
689 &newchannel
->sig_buf
,
690 HV_HYPERCALL_PARAM_ALIGN
));
692 newchannel
->sig_event
->connectionid
.asu32
= 0;
693 newchannel
->sig_event
->connectionid
.u
.id
= VMBUS_EVENT_CONNECTION_ID
;
694 newchannel
->sig_event
->flag_number
= 0;
695 newchannel
->sig_event
->rsvdz
= 0;
697 if (vmbus_proto_version
!= VERSION_WS2008
) {
698 newchannel
->is_dedicated_interrupt
=
699 (offer
->is_dedicated_interrupt
!= 0);
700 newchannel
->sig_event
->connectionid
.u
.id
=
701 offer
->connection_id
;
704 memcpy(&newchannel
->offermsg
, offer
,
705 sizeof(struct vmbus_channel_offer_channel
));
706 newchannel
->monitor_grp
= (u8
)offer
->monitorid
/ 32;
707 newchannel
->monitor_bit
= (u8
)offer
->monitorid
% 32;
709 vmbus_process_offer(newchannel
);
713 * vmbus_onoffer_rescind - Rescind offer handler.
715 * We queue a work item to process this offer synchronously
717 static void vmbus_onoffer_rescind(struct vmbus_channel_message_header
*hdr
)
719 struct vmbus_channel_rescind_offer
*rescind
;
720 struct vmbus_channel
*channel
;
724 rescind
= (struct vmbus_channel_rescind_offer
*)hdr
;
726 mutex_lock(&vmbus_connection
.channel_mutex
);
727 channel
= relid2channel(rescind
->child_relid
);
729 if (channel
== NULL
) {
731 * This is very impossible, because in
732 * vmbus_process_offer(), we have already invoked
733 * vmbus_release_relid() on error.
738 spin_lock_irqsave(&channel
->lock
, flags
);
739 channel
->rescind
= true;
740 spin_unlock_irqrestore(&channel
->lock
, flags
);
742 if (channel
->device_obj
) {
743 if (channel
->chn_rescind_callback
) {
744 channel
->chn_rescind_callback(channel
);
748 * We will have to unregister this device from the
751 dev
= get_device(&channel
->device_obj
->device
);
753 vmbus_device_unregister(channel
->device_obj
);
757 hv_process_channel_removal(channel
,
758 channel
->offermsg
.child_relid
);
762 mutex_unlock(&vmbus_connection
.channel_mutex
);
765 void vmbus_hvsock_device_unregister(struct vmbus_channel
*channel
)
767 mutex_lock(&vmbus_connection
.channel_mutex
);
769 BUG_ON(!is_hvsock_channel(channel
));
771 channel
->rescind
= true;
772 vmbus_device_unregister(channel
->device_obj
);
774 mutex_unlock(&vmbus_connection
.channel_mutex
);
776 EXPORT_SYMBOL_GPL(vmbus_hvsock_device_unregister
);
780 * vmbus_onoffers_delivered -
781 * This is invoked when all offers have been delivered.
783 * Nothing to do here.
785 static void vmbus_onoffers_delivered(
786 struct vmbus_channel_message_header
*hdr
)
791 * vmbus_onopen_result - Open result handler.
793 * This is invoked when we received a response to our channel open request.
794 * Find the matching request, copy the response and signal the requesting
797 static void vmbus_onopen_result(struct vmbus_channel_message_header
*hdr
)
799 struct vmbus_channel_open_result
*result
;
800 struct vmbus_channel_msginfo
*msginfo
;
801 struct vmbus_channel_message_header
*requestheader
;
802 struct vmbus_channel_open_channel
*openmsg
;
805 result
= (struct vmbus_channel_open_result
*)hdr
;
808 * Find the open msg, copy the result and signal/unblock the wait event
810 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
812 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
815 (struct vmbus_channel_message_header
*)msginfo
->msg
;
817 if (requestheader
->msgtype
== CHANNELMSG_OPENCHANNEL
) {
819 (struct vmbus_channel_open_channel
*)msginfo
->msg
;
820 if (openmsg
->child_relid
== result
->child_relid
&&
821 openmsg
->openid
== result
->openid
) {
822 memcpy(&msginfo
->response
.open_result
,
825 struct vmbus_channel_open_result
));
826 complete(&msginfo
->waitevent
);
831 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
835 * vmbus_ongpadl_created - GPADL created handler.
837 * This is invoked when we received a response to our gpadl create request.
838 * Find the matching request, copy the response and signal the requesting
841 static void vmbus_ongpadl_created(struct vmbus_channel_message_header
*hdr
)
843 struct vmbus_channel_gpadl_created
*gpadlcreated
;
844 struct vmbus_channel_msginfo
*msginfo
;
845 struct vmbus_channel_message_header
*requestheader
;
846 struct vmbus_channel_gpadl_header
*gpadlheader
;
849 gpadlcreated
= (struct vmbus_channel_gpadl_created
*)hdr
;
852 * Find the establish msg, copy the result and signal/unblock the wait
855 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
857 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
860 (struct vmbus_channel_message_header
*)msginfo
->msg
;
862 if (requestheader
->msgtype
== CHANNELMSG_GPADL_HEADER
) {
864 (struct vmbus_channel_gpadl_header
*)requestheader
;
866 if ((gpadlcreated
->child_relid
==
867 gpadlheader
->child_relid
) &&
868 (gpadlcreated
->gpadl
== gpadlheader
->gpadl
)) {
869 memcpy(&msginfo
->response
.gpadl_created
,
872 struct vmbus_channel_gpadl_created
));
873 complete(&msginfo
->waitevent
);
878 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
882 * vmbus_ongpadl_torndown - GPADL torndown handler.
884 * This is invoked when we received a response to our gpadl teardown request.
885 * Find the matching request, copy the response and signal the requesting
888 static void vmbus_ongpadl_torndown(
889 struct vmbus_channel_message_header
*hdr
)
891 struct vmbus_channel_gpadl_torndown
*gpadl_torndown
;
892 struct vmbus_channel_msginfo
*msginfo
;
893 struct vmbus_channel_message_header
*requestheader
;
894 struct vmbus_channel_gpadl_teardown
*gpadl_teardown
;
897 gpadl_torndown
= (struct vmbus_channel_gpadl_torndown
*)hdr
;
900 * Find the open msg, copy the result and signal/unblock the wait event
902 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
904 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
907 (struct vmbus_channel_message_header
*)msginfo
->msg
;
909 if (requestheader
->msgtype
== CHANNELMSG_GPADL_TEARDOWN
) {
911 (struct vmbus_channel_gpadl_teardown
*)requestheader
;
913 if (gpadl_torndown
->gpadl
== gpadl_teardown
->gpadl
) {
914 memcpy(&msginfo
->response
.gpadl_torndown
,
917 struct vmbus_channel_gpadl_torndown
));
918 complete(&msginfo
->waitevent
);
923 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
927 * vmbus_onversion_response - Version response handler
929 * This is invoked when we received a response to our initiate contact request.
930 * Find the matching request, copy the response and signal the requesting
933 static void vmbus_onversion_response(
934 struct vmbus_channel_message_header
*hdr
)
936 struct vmbus_channel_msginfo
*msginfo
;
937 struct vmbus_channel_message_header
*requestheader
;
938 struct vmbus_channel_version_response
*version_response
;
941 version_response
= (struct vmbus_channel_version_response
*)hdr
;
942 spin_lock_irqsave(&vmbus_connection
.channelmsg_lock
, flags
);
944 list_for_each_entry(msginfo
, &vmbus_connection
.chn_msg_list
,
947 (struct vmbus_channel_message_header
*)msginfo
->msg
;
949 if (requestheader
->msgtype
==
950 CHANNELMSG_INITIATE_CONTACT
) {
951 memcpy(&msginfo
->response
.version_response
,
953 sizeof(struct vmbus_channel_version_response
));
954 complete(&msginfo
->waitevent
);
957 spin_unlock_irqrestore(&vmbus_connection
.channelmsg_lock
, flags
);
960 /* Channel message dispatch table */
961 struct vmbus_channel_message_table_entry
962 channel_message_table
[CHANNELMSG_COUNT
] = {
963 {CHANNELMSG_INVALID
, 0, NULL
},
964 {CHANNELMSG_OFFERCHANNEL
, 0, vmbus_onoffer
},
965 {CHANNELMSG_RESCIND_CHANNELOFFER
, 0, vmbus_onoffer_rescind
},
966 {CHANNELMSG_REQUESTOFFERS
, 0, NULL
},
967 {CHANNELMSG_ALLOFFERS_DELIVERED
, 1, vmbus_onoffers_delivered
},
968 {CHANNELMSG_OPENCHANNEL
, 0, NULL
},
969 {CHANNELMSG_OPENCHANNEL_RESULT
, 1, vmbus_onopen_result
},
970 {CHANNELMSG_CLOSECHANNEL
, 0, NULL
},
971 {CHANNELMSG_GPADL_HEADER
, 0, NULL
},
972 {CHANNELMSG_GPADL_BODY
, 0, NULL
},
973 {CHANNELMSG_GPADL_CREATED
, 1, vmbus_ongpadl_created
},
974 {CHANNELMSG_GPADL_TEARDOWN
, 0, NULL
},
975 {CHANNELMSG_GPADL_TORNDOWN
, 1, vmbus_ongpadl_torndown
},
976 {CHANNELMSG_RELID_RELEASED
, 0, NULL
},
977 {CHANNELMSG_INITIATE_CONTACT
, 0, NULL
},
978 {CHANNELMSG_VERSION_RESPONSE
, 1, vmbus_onversion_response
},
979 {CHANNELMSG_UNLOAD
, 0, NULL
},
980 {CHANNELMSG_UNLOAD_RESPONSE
, 1, vmbus_unload_response
},
981 {CHANNELMSG_18
, 0, NULL
},
982 {CHANNELMSG_19
, 0, NULL
},
983 {CHANNELMSG_20
, 0, NULL
},
984 {CHANNELMSG_TL_CONNECT_REQUEST
, 0, NULL
},
988 * vmbus_onmessage - Handler for channel protocol messages.
990 * This is invoked in the vmbus worker thread context.
992 void vmbus_onmessage(void *context
)
994 struct hv_message
*msg
= context
;
995 struct vmbus_channel_message_header
*hdr
;
998 hdr
= (struct vmbus_channel_message_header
*)msg
->u
.payload
;
999 size
= msg
->header
.payload_size
;
1001 if (hdr
->msgtype
>= CHANNELMSG_COUNT
) {
1002 pr_err("Received invalid channel message type %d size %d\n",
1003 hdr
->msgtype
, size
);
1004 print_hex_dump_bytes("", DUMP_PREFIX_NONE
,
1005 (unsigned char *)msg
->u
.payload
, size
);
1009 if (channel_message_table
[hdr
->msgtype
].message_handler
)
1010 channel_message_table
[hdr
->msgtype
].message_handler(hdr
);
1012 pr_err("Unhandled channel message type %d\n", hdr
->msgtype
);
1016 * vmbus_request_offers - Send a request to get all our pending offers.
1018 int vmbus_request_offers(void)
1020 struct vmbus_channel_message_header
*msg
;
1021 struct vmbus_channel_msginfo
*msginfo
;
1024 msginfo
= kmalloc(sizeof(*msginfo
) +
1025 sizeof(struct vmbus_channel_message_header
),
1030 msg
= (struct vmbus_channel_message_header
*)msginfo
->msg
;
1032 msg
->msgtype
= CHANNELMSG_REQUESTOFFERS
;
1035 ret
= vmbus_post_msg(msg
,
1036 sizeof(struct vmbus_channel_message_header
));
1038 pr_err("Unable to request offers - %d\n", ret
);
1050 * Retrieve the (sub) channel on which to send an outgoing request.
1051 * When a primary channel has multiple sub-channels, we try to
1052 * distribute the load equally amongst all available channels.
1054 struct vmbus_channel
*vmbus_get_outgoing_channel(struct vmbus_channel
*primary
)
1056 struct list_head
*cur
, *tmp
;
1058 struct vmbus_channel
*cur_channel
;
1059 struct vmbus_channel
*outgoing_channel
= primary
;
1063 if (list_empty(&primary
->sc_list
))
1064 return outgoing_channel
;
1066 next_channel
= primary
->next_oc
++;
1068 if (next_channel
> (primary
->num_sc
)) {
1069 primary
->next_oc
= 0;
1070 return outgoing_channel
;
1073 cur_cpu
= hv_context
.vp_index
[get_cpu()];
1075 list_for_each_safe(cur
, tmp
, &primary
->sc_list
) {
1076 cur_channel
= list_entry(cur
, struct vmbus_channel
, sc_list
);
1077 if (cur_channel
->state
!= CHANNEL_OPENED_STATE
)
1080 if (cur_channel
->target_vp
== cur_cpu
)
1083 if (i
== next_channel
)
1089 return outgoing_channel
;
1091 EXPORT_SYMBOL_GPL(vmbus_get_outgoing_channel
);
1093 static void invoke_sc_cb(struct vmbus_channel
*primary_channel
)
1095 struct list_head
*cur
, *tmp
;
1096 struct vmbus_channel
*cur_channel
;
1098 if (primary_channel
->sc_creation_callback
== NULL
)
1101 list_for_each_safe(cur
, tmp
, &primary_channel
->sc_list
) {
1102 cur_channel
= list_entry(cur
, struct vmbus_channel
, sc_list
);
1104 primary_channel
->sc_creation_callback(cur_channel
);
1108 void vmbus_set_sc_create_callback(struct vmbus_channel
*primary_channel
,
1109 void (*sc_cr_cb
)(struct vmbus_channel
*new_sc
))
1111 primary_channel
->sc_creation_callback
= sc_cr_cb
;
1113 EXPORT_SYMBOL_GPL(vmbus_set_sc_create_callback
);
1115 bool vmbus_are_subchannels_present(struct vmbus_channel
*primary
)
1119 ret
= !list_empty(&primary
->sc_list
);
1123 * Invoke the callback on sub-channel creation.
1124 * This will present a uniform interface to the
1127 invoke_sc_cb(primary
);
1132 EXPORT_SYMBOL_GPL(vmbus_are_subchannels_present
);
1134 void vmbus_set_chn_rescind_callback(struct vmbus_channel
*channel
,
1135 void (*chn_rescind_cb
)(struct vmbus_channel
*))
1137 channel
->chn_rescind_callback
= chn_rescind_cb
;
1139 EXPORT_SYMBOL_GPL(vmbus_set_chn_rescind_callback
);