xref: /openbmc/linux/drivers/hv/channel_mgmt.c (revision e2f1cf25)
1 /*
2  * Copyright (c) 2009, Microsoft Corporation.
3  *
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.
7  *
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
11  * more details.
12  *
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.
16  *
17  * Authors:
18  *   Haiyang Zhang <haiyangz@microsoft.com>
19  *   Hank Janssen  <hjanssen@microsoft.com>
20  */
21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22 
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
25 #include <linux/wait.h>
26 #include <linux/mm.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>
32 
33 #include "hyperv_vmbus.h"
34 
35 static void init_vp_index(struct vmbus_channel *channel,
36 			  const uuid_le *type_guid);
37 
38 /**
39  * vmbus_prep_negotiate_resp() - Create default response for Hyper-V Negotiate message
40  * @icmsghdrp: Pointer to msg header structure
41  * @icmsg_negotiate: Pointer to negotiate message structure
42  * @buf: Raw buffer channel data
43  *
44  * @icmsghdrp is of type &struct icmsg_hdr.
45  * @negop is of type &struct icmsg_negotiate.
46  * Set up and fill in default negotiate response message.
47  *
48  * The fw_version specifies the  framework version that
49  * we can support and srv_version specifies the service
50  * version we can support.
51  *
52  * Mainly used by Hyper-V drivers.
53  */
54 bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp,
55 				struct icmsg_negotiate *negop, u8 *buf,
56 				int fw_version, int srv_version)
57 {
58 	int icframe_major, icframe_minor;
59 	int icmsg_major, icmsg_minor;
60 	int fw_major, fw_minor;
61 	int srv_major, srv_minor;
62 	int i;
63 	bool found_match = false;
64 
65 	icmsghdrp->icmsgsize = 0x10;
66 	fw_major = (fw_version >> 16);
67 	fw_minor = (fw_version & 0xFFFF);
68 
69 	srv_major = (srv_version >> 16);
70 	srv_minor = (srv_version & 0xFFFF);
71 
72 	negop = (struct icmsg_negotiate *)&buf[
73 		sizeof(struct vmbuspipe_hdr) +
74 		sizeof(struct icmsg_hdr)];
75 
76 	icframe_major = negop->icframe_vercnt;
77 	icframe_minor = 0;
78 
79 	icmsg_major = negop->icmsg_vercnt;
80 	icmsg_minor = 0;
81 
82 	/*
83 	 * Select the framework version number we will
84 	 * support.
85 	 */
86 
87 	for (i = 0; i < negop->icframe_vercnt; i++) {
88 		if ((negop->icversion_data[i].major == fw_major) &&
89 		   (negop->icversion_data[i].minor == fw_minor)) {
90 			icframe_major = negop->icversion_data[i].major;
91 			icframe_minor = negop->icversion_data[i].minor;
92 			found_match = true;
93 		}
94 	}
95 
96 	if (!found_match)
97 		goto fw_error;
98 
99 	found_match = false;
100 
101 	for (i = negop->icframe_vercnt;
102 		 (i < negop->icframe_vercnt + negop->icmsg_vercnt); i++) {
103 		if ((negop->icversion_data[i].major == srv_major) &&
104 		   (negop->icversion_data[i].minor == srv_minor)) {
105 			icmsg_major = negop->icversion_data[i].major;
106 			icmsg_minor = negop->icversion_data[i].minor;
107 			found_match = true;
108 		}
109 	}
110 
111 	/*
112 	 * Respond with the framework and service
113 	 * version numbers we can support.
114 	 */
115 
116 fw_error:
117 	if (!found_match) {
118 		negop->icframe_vercnt = 0;
119 		negop->icmsg_vercnt = 0;
120 	} else {
121 		negop->icframe_vercnt = 1;
122 		negop->icmsg_vercnt = 1;
123 	}
124 
125 	negop->icversion_data[0].major = icframe_major;
126 	negop->icversion_data[0].minor = icframe_minor;
127 	negop->icversion_data[1].major = icmsg_major;
128 	negop->icversion_data[1].minor = icmsg_minor;
129 	return found_match;
130 }
131 
132 EXPORT_SYMBOL_GPL(vmbus_prep_negotiate_resp);
133 
134 /*
135  * alloc_channel - Allocate and initialize a vmbus channel object
136  */
137 static struct vmbus_channel *alloc_channel(void)
138 {
139 	static atomic_t chan_num = ATOMIC_INIT(0);
140 	struct vmbus_channel *channel;
141 
142 	channel = kzalloc(sizeof(*channel), GFP_ATOMIC);
143 	if (!channel)
144 		return NULL;
145 
146 	channel->id = atomic_inc_return(&chan_num);
147 	spin_lock_init(&channel->inbound_lock);
148 	spin_lock_init(&channel->lock);
149 
150 	INIT_LIST_HEAD(&channel->sc_list);
151 	INIT_LIST_HEAD(&channel->percpu_list);
152 
153 	return channel;
154 }
155 
156 /*
157  * free_channel - Release the resources used by the vmbus channel object
158  */
159 static void free_channel(struct vmbus_channel *channel)
160 {
161 	kfree(channel);
162 }
163 
164 static void percpu_channel_enq(void *arg)
165 {
166 	struct vmbus_channel *channel = arg;
167 	int cpu = smp_processor_id();
168 
169 	list_add_tail(&channel->percpu_list, &hv_context.percpu_list[cpu]);
170 }
171 
172 static void percpu_channel_deq(void *arg)
173 {
174 	struct vmbus_channel *channel = arg;
175 
176 	list_del(&channel->percpu_list);
177 }
178 
179 
180 void hv_process_channel_removal(struct vmbus_channel *channel, u32 relid)
181 {
182 	struct vmbus_channel_relid_released msg;
183 	unsigned long flags;
184 	struct vmbus_channel *primary_channel;
185 
186 	memset(&msg, 0, sizeof(struct vmbus_channel_relid_released));
187 	msg.child_relid = relid;
188 	msg.header.msgtype = CHANNELMSG_RELID_RELEASED;
189 	vmbus_post_msg(&msg, sizeof(struct vmbus_channel_relid_released));
190 
191 	if (channel == NULL)
192 		return;
193 
194 	if (channel->target_cpu != get_cpu()) {
195 		put_cpu();
196 		smp_call_function_single(channel->target_cpu,
197 					 percpu_channel_deq, channel, true);
198 	} else {
199 		percpu_channel_deq(channel);
200 		put_cpu();
201 	}
202 
203 	if (channel->primary_channel == NULL) {
204 		spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
205 		list_del(&channel->listentry);
206 		spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
207 	} else {
208 		primary_channel = channel->primary_channel;
209 		spin_lock_irqsave(&primary_channel->lock, flags);
210 		list_del(&channel->sc_list);
211 		primary_channel->num_sc--;
212 		spin_unlock_irqrestore(&primary_channel->lock, flags);
213 	}
214 	free_channel(channel);
215 }
216 
217 void vmbus_free_channels(void)
218 {
219 	struct vmbus_channel *channel, *tmp;
220 
221 	list_for_each_entry_safe(channel, tmp, &vmbus_connection.chn_list,
222 		listentry) {
223 		/* if we don't set rescind to true, vmbus_close_internal()
224 		 * won't invoke hv_process_channel_removal().
225 		 */
226 		channel->rescind = true;
227 
228 		vmbus_device_unregister(channel->device_obj);
229 	}
230 }
231 
232 /*
233  * vmbus_process_offer - Process the offer by creating a channel/device
234  * associated with this offer
235  */
236 static void vmbus_process_offer(struct vmbus_channel *newchannel)
237 {
238 	struct vmbus_channel *channel;
239 	bool fnew = true;
240 	unsigned long flags;
241 
242 	/* Make sure this is a new offer */
243 	spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
244 
245 	list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
246 		if (!uuid_le_cmp(channel->offermsg.offer.if_type,
247 			newchannel->offermsg.offer.if_type) &&
248 			!uuid_le_cmp(channel->offermsg.offer.if_instance,
249 				newchannel->offermsg.offer.if_instance)) {
250 			fnew = false;
251 			break;
252 		}
253 	}
254 
255 	if (fnew)
256 		list_add_tail(&newchannel->listentry,
257 			      &vmbus_connection.chn_list);
258 
259 	spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
260 
261 	if (!fnew) {
262 		/*
263 		 * Check to see if this is a sub-channel.
264 		 */
265 		if (newchannel->offermsg.offer.sub_channel_index != 0) {
266 			/*
267 			 * Process the sub-channel.
268 			 */
269 			newchannel->primary_channel = channel;
270 			spin_lock_irqsave(&channel->lock, flags);
271 			list_add_tail(&newchannel->sc_list, &channel->sc_list);
272 			channel->num_sc++;
273 			spin_unlock_irqrestore(&channel->lock, flags);
274 		} else
275 			goto err_free_chan;
276 	}
277 
278 	init_vp_index(newchannel, &newchannel->offermsg.offer.if_type);
279 
280 	if (newchannel->target_cpu != get_cpu()) {
281 		put_cpu();
282 		smp_call_function_single(newchannel->target_cpu,
283 					 percpu_channel_enq,
284 					 newchannel, true);
285 	} else {
286 		percpu_channel_enq(newchannel);
287 		put_cpu();
288 	}
289 
290 	/*
291 	 * This state is used to indicate a successful open
292 	 * so that when we do close the channel normally, we
293 	 * can cleanup properly
294 	 */
295 	newchannel->state = CHANNEL_OPEN_STATE;
296 
297 	if (!fnew) {
298 		if (channel->sc_creation_callback != NULL)
299 			channel->sc_creation_callback(newchannel);
300 		return;
301 	}
302 
303 	/*
304 	 * Start the process of binding this offer to the driver
305 	 * We need to set the DeviceObject field before calling
306 	 * vmbus_child_dev_add()
307 	 */
308 	newchannel->device_obj = vmbus_device_create(
309 		&newchannel->offermsg.offer.if_type,
310 		&newchannel->offermsg.offer.if_instance,
311 		newchannel);
312 	if (!newchannel->device_obj)
313 		goto err_deq_chan;
314 
315 	/*
316 	 * Add the new device to the bus. This will kick off device-driver
317 	 * binding which eventually invokes the device driver's AddDevice()
318 	 * method.
319 	 */
320 	if (vmbus_device_register(newchannel->device_obj) != 0) {
321 		pr_err("unable to add child device object (relid %d)\n",
322 			newchannel->offermsg.child_relid);
323 		kfree(newchannel->device_obj);
324 		goto err_deq_chan;
325 	}
326 	return;
327 
328 err_deq_chan:
329 	spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
330 	list_del(&newchannel->listentry);
331 	spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
332 
333 	if (newchannel->target_cpu != get_cpu()) {
334 		put_cpu();
335 		smp_call_function_single(newchannel->target_cpu,
336 					 percpu_channel_deq, newchannel, true);
337 	} else {
338 		percpu_channel_deq(newchannel);
339 		put_cpu();
340 	}
341 
342 err_free_chan:
343 	free_channel(newchannel);
344 }
345 
346 enum {
347 	IDE = 0,
348 	SCSI,
349 	NIC,
350 	MAX_PERF_CHN,
351 };
352 
353 /*
354  * This is an array of device_ids (device types) that are performance critical.
355  * We attempt to distribute the interrupt load for these devices across
356  * all available CPUs.
357  */
358 static const struct hv_vmbus_device_id hp_devs[] = {
359 	/* IDE */
360 	{ HV_IDE_GUID, },
361 	/* Storage - SCSI */
362 	{ HV_SCSI_GUID, },
363 	/* Network */
364 	{ HV_NIC_GUID, },
365 	/* NetworkDirect Guest RDMA */
366 	{ HV_ND_GUID, },
367 };
368 
369 
370 /*
371  * We use this state to statically distribute the channel interrupt load.
372  */
373 static int next_numa_node_id;
374 
375 /*
376  * Starting with Win8, we can statically distribute the incoming
377  * channel interrupt load by binding a channel to VCPU.
378  * We do this in a hierarchical fashion:
379  * First distribute the primary channels across available NUMA nodes
380  * and then distribute the subchannels amongst the CPUs in the NUMA
381  * node assigned to the primary channel.
382  *
383  * For pre-win8 hosts or non-performance critical channels we assign the
384  * first CPU in the first NUMA node.
385  */
386 static void init_vp_index(struct vmbus_channel *channel, const uuid_le *type_guid)
387 {
388 	u32 cur_cpu;
389 	int i;
390 	bool perf_chn = false;
391 	struct vmbus_channel *primary = channel->primary_channel;
392 	int next_node;
393 	struct cpumask available_mask;
394 
395 	for (i = IDE; i < MAX_PERF_CHN; i++) {
396 		if (!memcmp(type_guid->b, hp_devs[i].guid,
397 				 sizeof(uuid_le))) {
398 			perf_chn = true;
399 			break;
400 		}
401 	}
402 	if ((vmbus_proto_version == VERSION_WS2008) ||
403 	    (vmbus_proto_version == VERSION_WIN7) || (!perf_chn)) {
404 		/*
405 		 * Prior to win8, all channel interrupts are
406 		 * delivered on cpu 0.
407 		 * Also if the channel is not a performance critical
408 		 * channel, bind it to cpu 0.
409 		 */
410 		channel->numa_node = 0;
411 		cpumask_set_cpu(0, &channel->alloced_cpus_in_node);
412 		channel->target_cpu = 0;
413 		channel->target_vp = hv_context.vp_index[0];
414 		return;
415 	}
416 
417 	/*
418 	 * We distribute primary channels evenly across all the available
419 	 * NUMA nodes and within the assigned NUMA node we will assign the
420 	 * first available CPU to the primary channel.
421 	 * The sub-channels will be assigned to the CPUs available in the
422 	 * NUMA node evenly.
423 	 */
424 	if (!primary) {
425 		while (true) {
426 			next_node = next_numa_node_id++;
427 			if (next_node == nr_node_ids)
428 				next_node = next_numa_node_id = 0;
429 			if (cpumask_empty(cpumask_of_node(next_node)))
430 				continue;
431 			break;
432 		}
433 		channel->numa_node = next_node;
434 		primary = channel;
435 	}
436 
437 	if (cpumask_weight(&primary->alloced_cpus_in_node) ==
438 	    cpumask_weight(cpumask_of_node(primary->numa_node))) {
439 		/*
440 		 * We have cycled through all the CPUs in the node;
441 		 * reset the alloced map.
442 		 */
443 		cpumask_clear(&primary->alloced_cpus_in_node);
444 	}
445 
446 	cpumask_xor(&available_mask, &primary->alloced_cpus_in_node,
447 		    cpumask_of_node(primary->numa_node));
448 
449 	cur_cpu = cpumask_next(-1, &available_mask);
450 	cpumask_set_cpu(cur_cpu, &primary->alloced_cpus_in_node);
451 
452 	channel->target_cpu = cur_cpu;
453 	channel->target_vp = hv_context.vp_index[cur_cpu];
454 }
455 
456 /*
457  * vmbus_unload_response - Handler for the unload response.
458  */
459 static void vmbus_unload_response(struct vmbus_channel_message_header *hdr)
460 {
461 	/*
462 	 * This is a global event; just wakeup the waiting thread.
463 	 * Once we successfully unload, we can cleanup the monitor state.
464 	 */
465 	complete(&vmbus_connection.unload_event);
466 }
467 
468 void vmbus_initiate_unload(void)
469 {
470 	struct vmbus_channel_message_header hdr;
471 
472 	init_completion(&vmbus_connection.unload_event);
473 	memset(&hdr, 0, sizeof(struct vmbus_channel_message_header));
474 	hdr.msgtype = CHANNELMSG_UNLOAD;
475 	vmbus_post_msg(&hdr, sizeof(struct vmbus_channel_message_header));
476 
477 	wait_for_completion(&vmbus_connection.unload_event);
478 }
479 
480 /*
481  * vmbus_onoffer - Handler for channel offers from vmbus in parent partition.
482  *
483  */
484 static void vmbus_onoffer(struct vmbus_channel_message_header *hdr)
485 {
486 	struct vmbus_channel_offer_channel *offer;
487 	struct vmbus_channel *newchannel;
488 
489 	offer = (struct vmbus_channel_offer_channel *)hdr;
490 
491 	/* Allocate the channel object and save this offer. */
492 	newchannel = alloc_channel();
493 	if (!newchannel) {
494 		pr_err("Unable to allocate channel object\n");
495 		return;
496 	}
497 
498 	/*
499 	 * By default we setup state to enable batched
500 	 * reading. A specific service can choose to
501 	 * disable this prior to opening the channel.
502 	 */
503 	newchannel->batched_reading = true;
504 
505 	/*
506 	 * Setup state for signalling the host.
507 	 */
508 	newchannel->sig_event = (struct hv_input_signal_event *)
509 				(ALIGN((unsigned long)
510 				&newchannel->sig_buf,
511 				HV_HYPERCALL_PARAM_ALIGN));
512 
513 	newchannel->sig_event->connectionid.asu32 = 0;
514 	newchannel->sig_event->connectionid.u.id = VMBUS_EVENT_CONNECTION_ID;
515 	newchannel->sig_event->flag_number = 0;
516 	newchannel->sig_event->rsvdz = 0;
517 
518 	if (vmbus_proto_version != VERSION_WS2008) {
519 		newchannel->is_dedicated_interrupt =
520 				(offer->is_dedicated_interrupt != 0);
521 		newchannel->sig_event->connectionid.u.id =
522 				offer->connection_id;
523 	}
524 
525 	memcpy(&newchannel->offermsg, offer,
526 	       sizeof(struct vmbus_channel_offer_channel));
527 	newchannel->monitor_grp = (u8)offer->monitorid / 32;
528 	newchannel->monitor_bit = (u8)offer->monitorid % 32;
529 
530 	vmbus_process_offer(newchannel);
531 }
532 
533 /*
534  * vmbus_onoffer_rescind - Rescind offer handler.
535  *
536  * We queue a work item to process this offer synchronously
537  */
538 static void vmbus_onoffer_rescind(struct vmbus_channel_message_header *hdr)
539 {
540 	struct vmbus_channel_rescind_offer *rescind;
541 	struct vmbus_channel *channel;
542 	unsigned long flags;
543 	struct device *dev;
544 
545 	rescind = (struct vmbus_channel_rescind_offer *)hdr;
546 	channel = relid2channel(rescind->child_relid);
547 
548 	if (channel == NULL) {
549 		hv_process_channel_removal(NULL, rescind->child_relid);
550 		return;
551 	}
552 
553 	spin_lock_irqsave(&channel->lock, flags);
554 	channel->rescind = true;
555 	spin_unlock_irqrestore(&channel->lock, flags);
556 
557 	if (channel->device_obj) {
558 		/*
559 		 * We will have to unregister this device from the
560 		 * driver core.
561 		 */
562 		dev = get_device(&channel->device_obj->device);
563 		if (dev) {
564 			vmbus_device_unregister(channel->device_obj);
565 			put_device(dev);
566 		}
567 	} else {
568 		hv_process_channel_removal(channel,
569 			channel->offermsg.child_relid);
570 	}
571 }
572 
573 /*
574  * vmbus_onoffers_delivered -
575  * This is invoked when all offers have been delivered.
576  *
577  * Nothing to do here.
578  */
579 static void vmbus_onoffers_delivered(
580 			struct vmbus_channel_message_header *hdr)
581 {
582 }
583 
584 /*
585  * vmbus_onopen_result - Open result handler.
586  *
587  * This is invoked when we received a response to our channel open request.
588  * Find the matching request, copy the response and signal the requesting
589  * thread.
590  */
591 static void vmbus_onopen_result(struct vmbus_channel_message_header *hdr)
592 {
593 	struct vmbus_channel_open_result *result;
594 	struct vmbus_channel_msginfo *msginfo;
595 	struct vmbus_channel_message_header *requestheader;
596 	struct vmbus_channel_open_channel *openmsg;
597 	unsigned long flags;
598 
599 	result = (struct vmbus_channel_open_result *)hdr;
600 
601 	/*
602 	 * Find the open msg, copy the result and signal/unblock the wait event
603 	 */
604 	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
605 
606 	list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
607 				msglistentry) {
608 		requestheader =
609 			(struct vmbus_channel_message_header *)msginfo->msg;
610 
611 		if (requestheader->msgtype == CHANNELMSG_OPENCHANNEL) {
612 			openmsg =
613 			(struct vmbus_channel_open_channel *)msginfo->msg;
614 			if (openmsg->child_relid == result->child_relid &&
615 			    openmsg->openid == result->openid) {
616 				memcpy(&msginfo->response.open_result,
617 				       result,
618 				       sizeof(
619 					struct vmbus_channel_open_result));
620 				complete(&msginfo->waitevent);
621 				break;
622 			}
623 		}
624 	}
625 	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
626 }
627 
628 /*
629  * vmbus_ongpadl_created - GPADL created handler.
630  *
631  * This is invoked when we received a response to our gpadl create request.
632  * Find the matching request, copy the response and signal the requesting
633  * thread.
634  */
635 static void vmbus_ongpadl_created(struct vmbus_channel_message_header *hdr)
636 {
637 	struct vmbus_channel_gpadl_created *gpadlcreated;
638 	struct vmbus_channel_msginfo *msginfo;
639 	struct vmbus_channel_message_header *requestheader;
640 	struct vmbus_channel_gpadl_header *gpadlheader;
641 	unsigned long flags;
642 
643 	gpadlcreated = (struct vmbus_channel_gpadl_created *)hdr;
644 
645 	/*
646 	 * Find the establish msg, copy the result and signal/unblock the wait
647 	 * event
648 	 */
649 	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
650 
651 	list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
652 				msglistentry) {
653 		requestheader =
654 			(struct vmbus_channel_message_header *)msginfo->msg;
655 
656 		if (requestheader->msgtype == CHANNELMSG_GPADL_HEADER) {
657 			gpadlheader =
658 			(struct vmbus_channel_gpadl_header *)requestheader;
659 
660 			if ((gpadlcreated->child_relid ==
661 			     gpadlheader->child_relid) &&
662 			    (gpadlcreated->gpadl == gpadlheader->gpadl)) {
663 				memcpy(&msginfo->response.gpadl_created,
664 				       gpadlcreated,
665 				       sizeof(
666 					struct vmbus_channel_gpadl_created));
667 				complete(&msginfo->waitevent);
668 				break;
669 			}
670 		}
671 	}
672 	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
673 }
674 
675 /*
676  * vmbus_ongpadl_torndown - GPADL torndown handler.
677  *
678  * This is invoked when we received a response to our gpadl teardown request.
679  * Find the matching request, copy the response and signal the requesting
680  * thread.
681  */
682 static void vmbus_ongpadl_torndown(
683 			struct vmbus_channel_message_header *hdr)
684 {
685 	struct vmbus_channel_gpadl_torndown *gpadl_torndown;
686 	struct vmbus_channel_msginfo *msginfo;
687 	struct vmbus_channel_message_header *requestheader;
688 	struct vmbus_channel_gpadl_teardown *gpadl_teardown;
689 	unsigned long flags;
690 
691 	gpadl_torndown = (struct vmbus_channel_gpadl_torndown *)hdr;
692 
693 	/*
694 	 * Find the open msg, copy the result and signal/unblock the wait event
695 	 */
696 	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
697 
698 	list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
699 				msglistentry) {
700 		requestheader =
701 			(struct vmbus_channel_message_header *)msginfo->msg;
702 
703 		if (requestheader->msgtype == CHANNELMSG_GPADL_TEARDOWN) {
704 			gpadl_teardown =
705 			(struct vmbus_channel_gpadl_teardown *)requestheader;
706 
707 			if (gpadl_torndown->gpadl == gpadl_teardown->gpadl) {
708 				memcpy(&msginfo->response.gpadl_torndown,
709 				       gpadl_torndown,
710 				       sizeof(
711 					struct vmbus_channel_gpadl_torndown));
712 				complete(&msginfo->waitevent);
713 				break;
714 			}
715 		}
716 	}
717 	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
718 }
719 
720 /*
721  * vmbus_onversion_response - Version response handler
722  *
723  * This is invoked when we received a response to our initiate contact request.
724  * Find the matching request, copy the response and signal the requesting
725  * thread.
726  */
727 static void vmbus_onversion_response(
728 		struct vmbus_channel_message_header *hdr)
729 {
730 	struct vmbus_channel_msginfo *msginfo;
731 	struct vmbus_channel_message_header *requestheader;
732 	struct vmbus_channel_version_response *version_response;
733 	unsigned long flags;
734 
735 	version_response = (struct vmbus_channel_version_response *)hdr;
736 	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
737 
738 	list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
739 				msglistentry) {
740 		requestheader =
741 			(struct vmbus_channel_message_header *)msginfo->msg;
742 
743 		if (requestheader->msgtype ==
744 		    CHANNELMSG_INITIATE_CONTACT) {
745 			memcpy(&msginfo->response.version_response,
746 			      version_response,
747 			      sizeof(struct vmbus_channel_version_response));
748 			complete(&msginfo->waitevent);
749 		}
750 	}
751 	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
752 }
753 
754 /* Channel message dispatch table */
755 struct vmbus_channel_message_table_entry
756 	channel_message_table[CHANNELMSG_COUNT] = {
757 	{CHANNELMSG_INVALID,			0, NULL},
758 	{CHANNELMSG_OFFERCHANNEL,		0, vmbus_onoffer},
759 	{CHANNELMSG_RESCIND_CHANNELOFFER,	0, vmbus_onoffer_rescind},
760 	{CHANNELMSG_REQUESTOFFERS,		0, NULL},
761 	{CHANNELMSG_ALLOFFERS_DELIVERED,	1, vmbus_onoffers_delivered},
762 	{CHANNELMSG_OPENCHANNEL,		0, NULL},
763 	{CHANNELMSG_OPENCHANNEL_RESULT,		1, vmbus_onopen_result},
764 	{CHANNELMSG_CLOSECHANNEL,		0, NULL},
765 	{CHANNELMSG_GPADL_HEADER,		0, NULL},
766 	{CHANNELMSG_GPADL_BODY,			0, NULL},
767 	{CHANNELMSG_GPADL_CREATED,		1, vmbus_ongpadl_created},
768 	{CHANNELMSG_GPADL_TEARDOWN,		0, NULL},
769 	{CHANNELMSG_GPADL_TORNDOWN,		1, vmbus_ongpadl_torndown},
770 	{CHANNELMSG_RELID_RELEASED,		0, NULL},
771 	{CHANNELMSG_INITIATE_CONTACT,		0, NULL},
772 	{CHANNELMSG_VERSION_RESPONSE,		1, vmbus_onversion_response},
773 	{CHANNELMSG_UNLOAD,			0, NULL},
774 	{CHANNELMSG_UNLOAD_RESPONSE,		1, vmbus_unload_response},
775 };
776 
777 /*
778  * vmbus_onmessage - Handler for channel protocol messages.
779  *
780  * This is invoked in the vmbus worker thread context.
781  */
782 void vmbus_onmessage(void *context)
783 {
784 	struct hv_message *msg = context;
785 	struct vmbus_channel_message_header *hdr;
786 	int size;
787 
788 	hdr = (struct vmbus_channel_message_header *)msg->u.payload;
789 	size = msg->header.payload_size;
790 
791 	if (hdr->msgtype >= CHANNELMSG_COUNT) {
792 		pr_err("Received invalid channel message type %d size %d\n",
793 			   hdr->msgtype, size);
794 		print_hex_dump_bytes("", DUMP_PREFIX_NONE,
795 				     (unsigned char *)msg->u.payload, size);
796 		return;
797 	}
798 
799 	if (channel_message_table[hdr->msgtype].message_handler)
800 		channel_message_table[hdr->msgtype].message_handler(hdr);
801 	else
802 		pr_err("Unhandled channel message type %d\n", hdr->msgtype);
803 }
804 
805 /*
806  * vmbus_request_offers - Send a request to get all our pending offers.
807  */
808 int vmbus_request_offers(void)
809 {
810 	struct vmbus_channel_message_header *msg;
811 	struct vmbus_channel_msginfo *msginfo;
812 	int ret;
813 
814 	msginfo = kmalloc(sizeof(*msginfo) +
815 			  sizeof(struct vmbus_channel_message_header),
816 			  GFP_KERNEL);
817 	if (!msginfo)
818 		return -ENOMEM;
819 
820 	msg = (struct vmbus_channel_message_header *)msginfo->msg;
821 
822 	msg->msgtype = CHANNELMSG_REQUESTOFFERS;
823 
824 
825 	ret = vmbus_post_msg(msg,
826 			       sizeof(struct vmbus_channel_message_header));
827 	if (ret != 0) {
828 		pr_err("Unable to request offers - %d\n", ret);
829 
830 		goto cleanup;
831 	}
832 
833 cleanup:
834 	kfree(msginfo);
835 
836 	return ret;
837 }
838 
839 /*
840  * Retrieve the (sub) channel on which to send an outgoing request.
841  * When a primary channel has multiple sub-channels, we try to
842  * distribute the load equally amongst all available channels.
843  */
844 struct vmbus_channel *vmbus_get_outgoing_channel(struct vmbus_channel *primary)
845 {
846 	struct list_head *cur, *tmp;
847 	int cur_cpu;
848 	struct vmbus_channel *cur_channel;
849 	struct vmbus_channel *outgoing_channel = primary;
850 	int next_channel;
851 	int i = 1;
852 
853 	if (list_empty(&primary->sc_list))
854 		return outgoing_channel;
855 
856 	next_channel = primary->next_oc++;
857 
858 	if (next_channel > (primary->num_sc)) {
859 		primary->next_oc = 0;
860 		return outgoing_channel;
861 	}
862 
863 	cur_cpu = hv_context.vp_index[get_cpu()];
864 	put_cpu();
865 	list_for_each_safe(cur, tmp, &primary->sc_list) {
866 		cur_channel = list_entry(cur, struct vmbus_channel, sc_list);
867 		if (cur_channel->state != CHANNEL_OPENED_STATE)
868 			continue;
869 
870 		if (cur_channel->target_vp == cur_cpu)
871 			return cur_channel;
872 
873 		if (i == next_channel)
874 			return cur_channel;
875 
876 		i++;
877 	}
878 
879 	return outgoing_channel;
880 }
881 EXPORT_SYMBOL_GPL(vmbus_get_outgoing_channel);
882 
883 static void invoke_sc_cb(struct vmbus_channel *primary_channel)
884 {
885 	struct list_head *cur, *tmp;
886 	struct vmbus_channel *cur_channel;
887 
888 	if (primary_channel->sc_creation_callback == NULL)
889 		return;
890 
891 	list_for_each_safe(cur, tmp, &primary_channel->sc_list) {
892 		cur_channel = list_entry(cur, struct vmbus_channel, sc_list);
893 
894 		primary_channel->sc_creation_callback(cur_channel);
895 	}
896 }
897 
898 void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel,
899 				void (*sc_cr_cb)(struct vmbus_channel *new_sc))
900 {
901 	primary_channel->sc_creation_callback = sc_cr_cb;
902 }
903 EXPORT_SYMBOL_GPL(vmbus_set_sc_create_callback);
904 
905 bool vmbus_are_subchannels_present(struct vmbus_channel *primary)
906 {
907 	bool ret;
908 
909 	ret = !list_empty(&primary->sc_list);
910 
911 	if (ret) {
912 		/*
913 		 * Invoke the callback on sub-channel creation.
914 		 * This will present a uniform interface to the
915 		 * clients.
916 		 */
917 		invoke_sc_cb(primary);
918 	}
919 
920 	return ret;
921 }
922 EXPORT_SYMBOL_GPL(vmbus_are_subchannels_present);
923