Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2009, Microsoft Corporation.
4 *
5 * Authors:
6 * Haiyang Zhang <haiyangz@microsoft.com>
7 * Hank Janssen <hjanssen@microsoft.com>
8 */
9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11#include <linux/kernel.h>
12#include <linux/interrupt.h>
13#include <linux/sched.h>
14#include <linux/wait.h>
15#include <linux/mm.h>
16#include <linux/slab.h>
17#include <linux/list.h>
18#include <linux/module.h>
19#include <linux/completion.h>
20#include <linux/delay.h>
21#include <linux/cpu.h>
22#include <linux/hyperv.h>
23#include <asm/mshyperv.h>
24#include <linux/sched/isolation.h>
25
26#include "hyperv_vmbus.h"
27
28static void init_vp_index(struct vmbus_channel *channel);
29
30const struct vmbus_device vmbus_devs[] = {
31 /* IDE */
32 { .dev_type = HV_IDE,
33 HV_IDE_GUID,
34 .perf_device = true,
35 .allowed_in_isolated = false,
36 },
37
38 /* SCSI */
39 { .dev_type = HV_SCSI,
40 HV_SCSI_GUID,
41 .perf_device = true,
42 .allowed_in_isolated = true,
43 },
44
45 /* Fibre Channel */
46 { .dev_type = HV_FC,
47 HV_SYNTHFC_GUID,
48 .perf_device = true,
49 .allowed_in_isolated = false,
50 },
51
52 /* Synthetic NIC */
53 { .dev_type = HV_NIC,
54 HV_NIC_GUID,
55 .perf_device = true,
56 .allowed_in_isolated = true,
57 },
58
59 /* Network Direct */
60 { .dev_type = HV_ND,
61 HV_ND_GUID,
62 .perf_device = true,
63 .allowed_in_isolated = false,
64 },
65
66 /* PCIE */
67 { .dev_type = HV_PCIE,
68 HV_PCIE_GUID,
69 .perf_device = false,
70 .allowed_in_isolated = true,
71 },
72
73 /* Synthetic Frame Buffer */
74 { .dev_type = HV_FB,
75 HV_SYNTHVID_GUID,
76 .perf_device = false,
77 .allowed_in_isolated = false,
78 },
79
80 /* Synthetic Keyboard */
81 { .dev_type = HV_KBD,
82 HV_KBD_GUID,
83 .perf_device = false,
84 .allowed_in_isolated = false,
85 },
86
87 /* Synthetic MOUSE */
88 { .dev_type = HV_MOUSE,
89 HV_MOUSE_GUID,
90 .perf_device = false,
91 .allowed_in_isolated = false,
92 },
93
94 /* KVP */
95 { .dev_type = HV_KVP,
96 HV_KVP_GUID,
97 .perf_device = false,
98 .allowed_in_isolated = false,
99 },
100
101 /* Time Synch */
102 { .dev_type = HV_TS,
103 HV_TS_GUID,
104 .perf_device = false,
105 .allowed_in_isolated = true,
106 },
107
108 /* Heartbeat */
109 { .dev_type = HV_HB,
110 HV_HEART_BEAT_GUID,
111 .perf_device = false,
112 .allowed_in_isolated = true,
113 },
114
115 /* Shutdown */
116 { .dev_type = HV_SHUTDOWN,
117 HV_SHUTDOWN_GUID,
118 .perf_device = false,
119 .allowed_in_isolated = true,
120 },
121
122 /* File copy */
123 { .dev_type = HV_FCOPY,
124 HV_FCOPY_GUID,
125 .perf_device = false,
126 .allowed_in_isolated = false,
127 },
128
129 /* Backup */
130 { .dev_type = HV_BACKUP,
131 HV_VSS_GUID,
132 .perf_device = false,
133 .allowed_in_isolated = false,
134 },
135
136 /* Dynamic Memory */
137 { .dev_type = HV_DM,
138 HV_DM_GUID,
139 .perf_device = false,
140 .allowed_in_isolated = false,
141 },
142
143 /* Unknown GUID */
144 { .dev_type = HV_UNKNOWN,
145 .perf_device = false,
146 .allowed_in_isolated = false,
147 },
148};
149
150static const struct {
151 guid_t guid;
152} vmbus_unsupported_devs[] = {
153 { HV_AVMA1_GUID },
154 { HV_AVMA2_GUID },
155 { HV_RDV_GUID },
156 { HV_IMC_GUID },
157};
158
159/*
160 * The rescinded channel may be blocked waiting for a response from the host;
161 * take care of that.
162 */
163static void vmbus_rescind_cleanup(struct vmbus_channel *channel)
164{
165 struct vmbus_channel_msginfo *msginfo;
166 unsigned long flags;
167
168
169 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
170 channel->rescind = true;
171 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
172 msglistentry) {
173
174 if (msginfo->waiting_channel == channel) {
175 complete(&msginfo->waitevent);
176 break;
177 }
178 }
179 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
180}
181
182static bool is_unsupported_vmbus_devs(const guid_t *guid)
183{
184 int i;
185
186 for (i = 0; i < ARRAY_SIZE(vmbus_unsupported_devs); i++)
187 if (guid_equal(guid, &vmbus_unsupported_devs[i].guid))
188 return true;
189 return false;
190}
191
192static u16 hv_get_dev_type(const struct vmbus_channel *channel)
193{
194 const guid_t *guid = &channel->offermsg.offer.if_type;
195 u16 i;
196
197 if (is_hvsock_channel(channel) || is_unsupported_vmbus_devs(guid))
198 return HV_UNKNOWN;
199
200 for (i = HV_IDE; i < HV_UNKNOWN; i++) {
201 if (guid_equal(guid, &vmbus_devs[i].guid))
202 return i;
203 }
204 pr_info("Unknown GUID: %pUl\n", guid);
205 return i;
206}
207
208/**
209 * vmbus_prep_negotiate_resp() - Create default response for Negotiate message
210 * @icmsghdrp: Pointer to msg header structure
211 * @buf: Raw buffer channel data
212 * @buflen: Length of the raw buffer channel data.
213 * @fw_version: The framework versions we can support.
214 * @fw_vercnt: The size of @fw_version.
215 * @srv_version: The service versions we can support.
216 * @srv_vercnt: The size of @srv_version.
217 * @nego_fw_version: The selected framework version.
218 * @nego_srv_version: The selected service version.
219 *
220 * Note: Versions are given in decreasing order.
221 *
222 * Set up and fill in default negotiate response message.
223 * Mainly used by Hyper-V drivers.
224 */
225bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf,
226 u32 buflen, const int *fw_version, int fw_vercnt,
227 const int *srv_version, int srv_vercnt,
228 int *nego_fw_version, int *nego_srv_version)
229{
230 int icframe_major, icframe_minor;
231 int icmsg_major, icmsg_minor;
232 int fw_major, fw_minor;
233 int srv_major, srv_minor;
234 int i, j;
235 bool found_match = false;
236 struct icmsg_negotiate *negop;
237
238 /* Check that there's enough space for icframe_vercnt, icmsg_vercnt */
239 if (buflen < ICMSG_HDR + offsetof(struct icmsg_negotiate, reserved)) {
240 pr_err_ratelimited("Invalid icmsg negotiate\n");
241 return false;
242 }
243
244 icmsghdrp->icmsgsize = 0x10;
245 negop = (struct icmsg_negotiate *)&buf[ICMSG_HDR];
246
247 icframe_major = negop->icframe_vercnt;
248 icframe_minor = 0;
249
250 icmsg_major = negop->icmsg_vercnt;
251 icmsg_minor = 0;
252
253 /* Validate negop packet */
254 if (icframe_major > IC_VERSION_NEGOTIATION_MAX_VER_COUNT ||
255 icmsg_major > IC_VERSION_NEGOTIATION_MAX_VER_COUNT ||
256 ICMSG_NEGOTIATE_PKT_SIZE(icframe_major, icmsg_major) > buflen) {
257 pr_err_ratelimited("Invalid icmsg negotiate - icframe_major: %u, icmsg_major: %u\n",
258 icframe_major, icmsg_major);
259 goto fw_error;
260 }
261
262 /*
263 * Select the framework version number we will
264 * support.
265 */
266
267 for (i = 0; i < fw_vercnt; i++) {
268 fw_major = (fw_version[i] >> 16);
269 fw_minor = (fw_version[i] & 0xFFFF);
270
271 for (j = 0; j < negop->icframe_vercnt; j++) {
272 if ((negop->icversion_data[j].major == fw_major) &&
273 (negop->icversion_data[j].minor == fw_minor)) {
274 icframe_major = negop->icversion_data[j].major;
275 icframe_minor = negop->icversion_data[j].minor;
276 found_match = true;
277 break;
278 }
279 }
280
281 if (found_match)
282 break;
283 }
284
285 if (!found_match)
286 goto fw_error;
287
288 found_match = false;
289
290 for (i = 0; i < srv_vercnt; i++) {
291 srv_major = (srv_version[i] >> 16);
292 srv_minor = (srv_version[i] & 0xFFFF);
293
294 for (j = negop->icframe_vercnt;
295 (j < negop->icframe_vercnt + negop->icmsg_vercnt);
296 j++) {
297
298 if ((negop->icversion_data[j].major == srv_major) &&
299 (negop->icversion_data[j].minor == srv_minor)) {
300
301 icmsg_major = negop->icversion_data[j].major;
302 icmsg_minor = negop->icversion_data[j].minor;
303 found_match = true;
304 break;
305 }
306 }
307
308 if (found_match)
309 break;
310 }
311
312 /*
313 * Respond with the framework and service
314 * version numbers we can support.
315 */
316
317fw_error:
318 if (!found_match) {
319 negop->icframe_vercnt = 0;
320 negop->icmsg_vercnt = 0;
321 } else {
322 negop->icframe_vercnt = 1;
323 negop->icmsg_vercnt = 1;
324 }
325
326 if (nego_fw_version)
327 *nego_fw_version = (icframe_major << 16) | icframe_minor;
328
329 if (nego_srv_version)
330 *nego_srv_version = (icmsg_major << 16) | icmsg_minor;
331
332 negop->icversion_data[0].major = icframe_major;
333 negop->icversion_data[0].minor = icframe_minor;
334 negop->icversion_data[1].major = icmsg_major;
335 negop->icversion_data[1].minor = icmsg_minor;
336 return found_match;
337}
338EXPORT_SYMBOL_GPL(vmbus_prep_negotiate_resp);
339
340/*
341 * alloc_channel - Allocate and initialize a vmbus channel object
342 */
343static struct vmbus_channel *alloc_channel(void)
344{
345 struct vmbus_channel *channel;
346
347 channel = kzalloc(sizeof(*channel), GFP_ATOMIC);
348 if (!channel)
349 return NULL;
350
351 spin_lock_init(&channel->sched_lock);
352 init_completion(&channel->rescind_event);
353
354 INIT_LIST_HEAD(&channel->sc_list);
355
356 tasklet_init(&channel->callback_event,
357 vmbus_on_event, (unsigned long)channel);
358
359 hv_ringbuffer_pre_init(channel);
360
361 return channel;
362}
363
364/*
365 * free_channel - Release the resources used by the vmbus channel object
366 */
367static void free_channel(struct vmbus_channel *channel)
368{
369 tasklet_kill(&channel->callback_event);
370 vmbus_remove_channel_attr_group(channel);
371
372 kobject_put(&channel->kobj);
373}
374
375void vmbus_channel_map_relid(struct vmbus_channel *channel)
376{
377 if (WARN_ON(channel->offermsg.child_relid >= MAX_CHANNEL_RELIDS))
378 return;
379 /*
380 * The mapping of the channel's relid is visible from the CPUs that
381 * execute vmbus_chan_sched() by the time that vmbus_chan_sched() will
382 * execute:
383 *
384 * (a) In the "normal (i.e., not resuming from hibernation)" path,
385 * the full barrier in virt_store_mb() guarantees that the store
386 * is propagated to all CPUs before the add_channel_work work
387 * is queued. In turn, add_channel_work is queued before the
388 * channel's ring buffer is allocated/initialized and the
389 * OPENCHANNEL message for the channel is sent in vmbus_open().
390 * Hyper-V won't start sending the interrupts for the channel
391 * before the OPENCHANNEL message is acked. The memory barrier
392 * in vmbus_chan_sched() -> sync_test_and_clear_bit() ensures
393 * that vmbus_chan_sched() must find the channel's relid in
394 * recv_int_page before retrieving the channel pointer from the
395 * array of channels.
396 *
397 * (b) In the "resuming from hibernation" path, the virt_store_mb()
398 * guarantees that the store is propagated to all CPUs before
399 * the VMBus connection is marked as ready for the resume event
400 * (cf. check_ready_for_resume_event()). The interrupt handler
401 * of the VMBus driver and vmbus_chan_sched() can not run before
402 * vmbus_bus_resume() has completed execution (cf. resume_noirq).
403 */
404 virt_store_mb(
405 vmbus_connection.channels[channel->offermsg.child_relid],
406 channel);
407}
408
409void vmbus_channel_unmap_relid(struct vmbus_channel *channel)
410{
411 if (WARN_ON(channel->offermsg.child_relid >= MAX_CHANNEL_RELIDS))
412 return;
413 WRITE_ONCE(
414 vmbus_connection.channels[channel->offermsg.child_relid],
415 NULL);
416}
417
418static void vmbus_release_relid(u32 relid)
419{
420 struct vmbus_channel_relid_released msg;
421 int ret;
422
423 memset(&msg, 0, sizeof(struct vmbus_channel_relid_released));
424 msg.child_relid = relid;
425 msg.header.msgtype = CHANNELMSG_RELID_RELEASED;
426 ret = vmbus_post_msg(&msg, sizeof(struct vmbus_channel_relid_released),
427 true);
428
429 trace_vmbus_release_relid(&msg, ret);
430}
431
432void hv_process_channel_removal(struct vmbus_channel *channel)
433{
434 lockdep_assert_held(&vmbus_connection.channel_mutex);
435 BUG_ON(!channel->rescind);
436
437 /*
438 * hv_process_channel_removal() could find INVALID_RELID only for
439 * hv_sock channels. See the inline comments in vmbus_onoffer().
440 */
441 WARN_ON(channel->offermsg.child_relid == INVALID_RELID &&
442 !is_hvsock_channel(channel));
443
444 /*
445 * Upon suspend, an in-use hv_sock channel is removed from the array of
446 * channels and the relid is invalidated. After hibernation, when the
447 * user-space application destroys the channel, it's unnecessary and
448 * unsafe to remove the channel from the array of channels. See also
449 * the inline comments before the call of vmbus_release_relid() below.
450 */
451 if (channel->offermsg.child_relid != INVALID_RELID)
452 vmbus_channel_unmap_relid(channel);
453
454 if (channel->primary_channel == NULL)
455 list_del(&channel->listentry);
456 else
457 list_del(&channel->sc_list);
458
459 /*
460 * If this is a "perf" channel, updates the hv_numa_map[] masks so that
461 * init_vp_index() can (re-)use the CPU.
462 */
463 if (hv_is_perf_channel(channel))
464 hv_clear_allocated_cpu(channel->target_cpu);
465
466 /*
467 * Upon suspend, an in-use hv_sock channel is marked as "rescinded" and
468 * the relid is invalidated; after hibernation, when the user-space app
469 * destroys the channel, the relid is INVALID_RELID, and in this case
470 * it's unnecessary and unsafe to release the old relid, since the same
471 * relid can refer to a completely different channel now.
472 */
473 if (channel->offermsg.child_relid != INVALID_RELID)
474 vmbus_release_relid(channel->offermsg.child_relid);
475
476 free_channel(channel);
477}
478
479void vmbus_free_channels(void)
480{
481 struct vmbus_channel *channel, *tmp;
482
483 list_for_each_entry_safe(channel, tmp, &vmbus_connection.chn_list,
484 listentry) {
485 /* hv_process_channel_removal() needs this */
486 channel->rescind = true;
487
488 vmbus_device_unregister(channel->device_obj);
489 }
490}
491
492/* Note: the function can run concurrently for primary/sub channels. */
493static void vmbus_add_channel_work(struct work_struct *work)
494{
495 struct vmbus_channel *newchannel =
496 container_of(work, struct vmbus_channel, add_channel_work);
497 struct vmbus_channel *primary_channel = newchannel->primary_channel;
498 int ret;
499
500 /*
501 * This state is used to indicate a successful open
502 * so that when we do close the channel normally, we
503 * can cleanup properly.
504 */
505 newchannel->state = CHANNEL_OPEN_STATE;
506
507 if (primary_channel != NULL) {
508 /* newchannel is a sub-channel. */
509 struct hv_device *dev = primary_channel->device_obj;
510
511 if (vmbus_add_channel_kobj(dev, newchannel))
512 goto err_deq_chan;
513
514 if (primary_channel->sc_creation_callback != NULL)
515 primary_channel->sc_creation_callback(newchannel);
516
517 newchannel->probe_done = true;
518 return;
519 }
520
521 /*
522 * Start the process of binding the primary channel to the driver
523 */
524 newchannel->device_obj = vmbus_device_create(
525 &newchannel->offermsg.offer.if_type,
526 &newchannel->offermsg.offer.if_instance,
527 newchannel);
528 if (!newchannel->device_obj)
529 goto err_deq_chan;
530
531 newchannel->device_obj->device_id = newchannel->device_id;
532 /*
533 * Add the new device to the bus. This will kick off device-driver
534 * binding which eventually invokes the device driver's AddDevice()
535 * method.
536 *
537 * If vmbus_device_register() fails, the 'device_obj' is freed in
538 * vmbus_device_release() as called by device_unregister() in the
539 * error path of vmbus_device_register(). In the outside error
540 * path, there's no need to free it.
541 */
542 ret = vmbus_device_register(newchannel->device_obj);
543
544 if (ret != 0) {
545 pr_err("unable to add child device object (relid %d)\n",
546 newchannel->offermsg.child_relid);
547 goto err_deq_chan;
548 }
549
550 newchannel->probe_done = true;
551 return;
552
553err_deq_chan:
554 mutex_lock(&vmbus_connection.channel_mutex);
555
556 /*
557 * We need to set the flag, otherwise
558 * vmbus_onoffer_rescind() can be blocked.
559 */
560 newchannel->probe_done = true;
561
562 if (primary_channel == NULL)
563 list_del(&newchannel->listentry);
564 else
565 list_del(&newchannel->sc_list);
566
567 /* vmbus_process_offer() has mapped the channel. */
568 vmbus_channel_unmap_relid(newchannel);
569
570 mutex_unlock(&vmbus_connection.channel_mutex);
571
572 vmbus_release_relid(newchannel->offermsg.child_relid);
573
574 free_channel(newchannel);
575}
576
577/*
578 * vmbus_process_offer - Process the offer by creating a channel/device
579 * associated with this offer
580 */
581static void vmbus_process_offer(struct vmbus_channel *newchannel)
582{
583 struct vmbus_channel *channel;
584 struct workqueue_struct *wq;
585 bool fnew = true;
586
587 /*
588 * Synchronize vmbus_process_offer() and CPU hotplugging:
589 *
590 * CPU1 CPU2
591 *
592 * [vmbus_process_offer()] [Hot removal of the CPU]
593 *
594 * CPU_READ_LOCK CPUS_WRITE_LOCK
595 * LOAD cpu_online_mask SEARCH chn_list
596 * STORE target_cpu LOAD target_cpu
597 * INSERT chn_list STORE cpu_online_mask
598 * CPUS_READ_UNLOCK CPUS_WRITE_UNLOCK
599 *
600 * Forbids: CPU1's LOAD from *not* seing CPU2's STORE &&
601 * CPU2's SEARCH from *not* seeing CPU1's INSERT
602 *
603 * Forbids: CPU2's SEARCH from seeing CPU1's INSERT &&
604 * CPU2's LOAD from *not* seing CPU1's STORE
605 */
606 cpus_read_lock();
607
608 /*
609 * Serializes the modifications of the chn_list list as well as
610 * the accesses to next_numa_node_id in init_vp_index().
611 */
612 mutex_lock(&vmbus_connection.channel_mutex);
613
614 list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
615 if (guid_equal(&channel->offermsg.offer.if_type,
616 &newchannel->offermsg.offer.if_type) &&
617 guid_equal(&channel->offermsg.offer.if_instance,
618 &newchannel->offermsg.offer.if_instance)) {
619 fnew = false;
620 newchannel->primary_channel = channel;
621 break;
622 }
623 }
624
625 init_vp_index(newchannel);
626
627 /* Remember the channels that should be cleaned up upon suspend. */
628 if (is_hvsock_channel(newchannel) || is_sub_channel(newchannel))
629 atomic_inc(&vmbus_connection.nr_chan_close_on_suspend);
630
631 /*
632 * Now that we have acquired the channel_mutex,
633 * we can release the potentially racing rescind thread.
634 */
635 atomic_dec(&vmbus_connection.offer_in_progress);
636
637 if (fnew) {
638 list_add_tail(&newchannel->listentry,
639 &vmbus_connection.chn_list);
640 } else {
641 /*
642 * Check to see if this is a valid sub-channel.
643 */
644 if (newchannel->offermsg.offer.sub_channel_index == 0) {
645 mutex_unlock(&vmbus_connection.channel_mutex);
646 cpus_read_unlock();
647 /*
648 * Don't call free_channel(), because newchannel->kobj
649 * is not initialized yet.
650 */
651 kfree(newchannel);
652 WARN_ON_ONCE(1);
653 return;
654 }
655 /*
656 * Process the sub-channel.
657 */
658 list_add_tail(&newchannel->sc_list, &channel->sc_list);
659 }
660
661 vmbus_channel_map_relid(newchannel);
662
663 mutex_unlock(&vmbus_connection.channel_mutex);
664 cpus_read_unlock();
665
666 /*
667 * vmbus_process_offer() mustn't call channel->sc_creation_callback()
668 * directly for sub-channels, because sc_creation_callback() ->
669 * vmbus_open() may never get the host's response to the
670 * OPEN_CHANNEL message (the host may rescind a channel at any time,
671 * e.g. in the case of hot removing a NIC), and vmbus_onoffer_rescind()
672 * may not wake up the vmbus_open() as it's blocked due to a non-zero
673 * vmbus_connection.offer_in_progress, and finally we have a deadlock.
674 *
675 * The above is also true for primary channels, if the related device
676 * drivers use sync probing mode by default.
677 *
678 * And, usually the handling of primary channels and sub-channels can
679 * depend on each other, so we should offload them to different
680 * workqueues to avoid possible deadlock, e.g. in sync-probing mode,
681 * NIC1's netvsc_subchan_work() can race with NIC2's netvsc_probe() ->
682 * rtnl_lock(), and causes deadlock: the former gets the rtnl_lock
683 * and waits for all the sub-channels to appear, but the latter
684 * can't get the rtnl_lock and this blocks the handling of
685 * sub-channels.
686 */
687 INIT_WORK(&newchannel->add_channel_work, vmbus_add_channel_work);
688 wq = fnew ? vmbus_connection.handle_primary_chan_wq :
689 vmbus_connection.handle_sub_chan_wq;
690 queue_work(wq, &newchannel->add_channel_work);
691}
692
693/*
694 * Check if CPUs used by other channels of the same device.
695 * It should only be called by init_vp_index().
696 */
697static bool hv_cpuself_used(u32 cpu, struct vmbus_channel *chn)
698{
699 struct vmbus_channel *primary = chn->primary_channel;
700 struct vmbus_channel *sc;
701
702 lockdep_assert_held(&vmbus_connection.channel_mutex);
703
704 if (!primary)
705 return false;
706
707 if (primary->target_cpu == cpu)
708 return true;
709
710 list_for_each_entry(sc, &primary->sc_list, sc_list)
711 if (sc != chn && sc->target_cpu == cpu)
712 return true;
713
714 return false;
715}
716
717/*
718 * We use this state to statically distribute the channel interrupt load.
719 */
720static int next_numa_node_id;
721
722/*
723 * We can statically distribute the incoming channel interrupt load
724 * by binding a channel to VCPU.
725 *
726 * For non-performance critical channels we assign the VMBUS_CONNECT_CPU.
727 * Performance critical channels will be distributed evenly among all
728 * the available NUMA nodes. Once the node is assigned, we will assign
729 * the CPU based on a simple round robin scheme.
730 */
731static void init_vp_index(struct vmbus_channel *channel)
732{
733 bool perf_chn = hv_is_perf_channel(channel);
734 u32 i, ncpu = num_online_cpus();
735 cpumask_var_t available_mask;
736 struct cpumask *allocated_mask;
737 const struct cpumask *hk_mask = housekeeping_cpumask(HK_TYPE_MANAGED_IRQ);
738 u32 target_cpu;
739 int numa_node;
740
741 if (!perf_chn ||
742 !alloc_cpumask_var(&available_mask, GFP_KERNEL) ||
743 cpumask_empty(hk_mask)) {
744 /*
745 * If the channel is not a performance critical
746 * channel, bind it to VMBUS_CONNECT_CPU.
747 * In case alloc_cpumask_var() fails, bind it to
748 * VMBUS_CONNECT_CPU.
749 * If all the cpus are isolated, bind it to
750 * VMBUS_CONNECT_CPU.
751 */
752 channel->target_cpu = VMBUS_CONNECT_CPU;
753 if (perf_chn)
754 hv_set_allocated_cpu(VMBUS_CONNECT_CPU);
755 return;
756 }
757
758 for (i = 1; i <= ncpu + 1; i++) {
759 while (true) {
760 numa_node = next_numa_node_id++;
761 if (numa_node == nr_node_ids) {
762 next_numa_node_id = 0;
763 continue;
764 }
765 if (cpumask_empty(cpumask_of_node(numa_node)))
766 continue;
767 break;
768 }
769 allocated_mask = &hv_context.hv_numa_map[numa_node];
770
771retry:
772 cpumask_xor(available_mask, allocated_mask, cpumask_of_node(numa_node));
773 cpumask_and(available_mask, available_mask, hk_mask);
774
775 if (cpumask_empty(available_mask)) {
776 /*
777 * We have cycled through all the CPUs in the node;
778 * reset the allocated map.
779 */
780 cpumask_clear(allocated_mask);
781 goto retry;
782 }
783
784 target_cpu = cpumask_first(available_mask);
785 cpumask_set_cpu(target_cpu, allocated_mask);
786
787 if (channel->offermsg.offer.sub_channel_index >= ncpu ||
788 i > ncpu || !hv_cpuself_used(target_cpu, channel))
789 break;
790 }
791
792 channel->target_cpu = target_cpu;
793
794 free_cpumask_var(available_mask);
795}
796
797#define UNLOAD_DELAY_UNIT_MS 10 /* 10 milliseconds */
798#define UNLOAD_WAIT_MS (100*1000) /* 100 seconds */
799#define UNLOAD_WAIT_LOOPS (UNLOAD_WAIT_MS/UNLOAD_DELAY_UNIT_MS)
800#define UNLOAD_MSG_MS (5*1000) /* Every 5 seconds */
801#define UNLOAD_MSG_LOOPS (UNLOAD_MSG_MS/UNLOAD_DELAY_UNIT_MS)
802
803static void vmbus_wait_for_unload(void)
804{
805 int cpu;
806 void *page_addr;
807 struct hv_message *msg;
808 struct vmbus_channel_message_header *hdr;
809 u32 message_type, i;
810
811 /*
812 * CHANNELMSG_UNLOAD_RESPONSE is always delivered to the CPU which was
813 * used for initial contact or to CPU0 depending on host version. When
814 * we're crashing on a different CPU let's hope that IRQ handler on
815 * the cpu which receives CHANNELMSG_UNLOAD_RESPONSE is still
816 * functional and vmbus_unload_response() will complete
817 * vmbus_connection.unload_event. If not, the last thing we can do is
818 * read message pages for all CPUs directly.
819 *
820 * Wait up to 100 seconds since an Azure host must writeback any dirty
821 * data in its disk cache before the VMbus UNLOAD request will
822 * complete. This flushing has been empirically observed to take up
823 * to 50 seconds in cases with a lot of dirty data, so allow additional
824 * leeway and for inaccuracies in mdelay(). But eventually time out so
825 * that the panic path can't get hung forever in case the response
826 * message isn't seen.
827 */
828 for (i = 1; i <= UNLOAD_WAIT_LOOPS; i++) {
829 if (completion_done(&vmbus_connection.unload_event))
830 goto completed;
831
832 for_each_present_cpu(cpu) {
833 struct hv_per_cpu_context *hv_cpu
834 = per_cpu_ptr(hv_context.cpu_context, cpu);
835
836 /*
837 * In a CoCo VM the synic_message_page is not allocated
838 * in hv_synic_alloc(). Instead it is set/cleared in
839 * hv_synic_enable_regs() and hv_synic_disable_regs()
840 * such that it is set only when the CPU is online. If
841 * not all present CPUs are online, the message page
842 * might be NULL, so skip such CPUs.
843 */
844 page_addr = hv_cpu->synic_message_page;
845 if (!page_addr)
846 continue;
847
848 msg = (struct hv_message *)page_addr
849 + VMBUS_MESSAGE_SINT;
850
851 message_type = READ_ONCE(msg->header.message_type);
852 if (message_type == HVMSG_NONE)
853 continue;
854
855 hdr = (struct vmbus_channel_message_header *)
856 msg->u.payload;
857
858 if (hdr->msgtype == CHANNELMSG_UNLOAD_RESPONSE)
859 complete(&vmbus_connection.unload_event);
860
861 vmbus_signal_eom(msg, message_type);
862 }
863
864 /*
865 * Give a notice periodically so someone watching the
866 * serial output won't think it is completely hung.
867 */
868 if (!(i % UNLOAD_MSG_LOOPS))
869 pr_notice("Waiting for VMBus UNLOAD to complete\n");
870
871 mdelay(UNLOAD_DELAY_UNIT_MS);
872 }
873 pr_err("Continuing even though VMBus UNLOAD did not complete\n");
874
875completed:
876 /*
877 * We're crashing and already got the UNLOAD_RESPONSE, cleanup all
878 * maybe-pending messages on all CPUs to be able to receive new
879 * messages after we reconnect.
880 */
881 for_each_present_cpu(cpu) {
882 struct hv_per_cpu_context *hv_cpu
883 = per_cpu_ptr(hv_context.cpu_context, cpu);
884
885 page_addr = hv_cpu->synic_message_page;
886 if (!page_addr)
887 continue;
888
889 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
890 msg->header.message_type = HVMSG_NONE;
891 }
892}
893
894/*
895 * vmbus_unload_response - Handler for the unload response.
896 */
897static void vmbus_unload_response(struct vmbus_channel_message_header *hdr)
898{
899 /*
900 * This is a global event; just wakeup the waiting thread.
901 * Once we successfully unload, we can cleanup the monitor state.
902 *
903 * NB. A malicious or compromised Hyper-V could send a spurious
904 * message of type CHANNELMSG_UNLOAD_RESPONSE, and trigger a call
905 * of the complete() below. Make sure that unload_event has been
906 * initialized by the time this complete() is executed.
907 */
908 complete(&vmbus_connection.unload_event);
909}
910
911void vmbus_initiate_unload(bool crash)
912{
913 struct vmbus_channel_message_header hdr;
914
915 if (xchg(&vmbus_connection.conn_state, DISCONNECTED) == DISCONNECTED)
916 return;
917
918 /* Pre-Win2012R2 hosts don't support reconnect */
919 if (vmbus_proto_version < VERSION_WIN8_1)
920 return;
921
922 reinit_completion(&vmbus_connection.unload_event);
923 memset(&hdr, 0, sizeof(struct vmbus_channel_message_header));
924 hdr.msgtype = CHANNELMSG_UNLOAD;
925 vmbus_post_msg(&hdr, sizeof(struct vmbus_channel_message_header),
926 !crash);
927
928 /*
929 * vmbus_initiate_unload() is also called on crash and the crash can be
930 * happening in an interrupt context, where scheduling is impossible.
931 */
932 if (!crash)
933 wait_for_completion(&vmbus_connection.unload_event);
934 else
935 vmbus_wait_for_unload();
936}
937
938static void check_ready_for_resume_event(void)
939{
940 /*
941 * If all the old primary channels have been fixed up, then it's safe
942 * to resume.
943 */
944 if (atomic_dec_and_test(&vmbus_connection.nr_chan_fixup_on_resume))
945 complete(&vmbus_connection.ready_for_resume_event);
946}
947
948static void vmbus_setup_channel_state(struct vmbus_channel *channel,
949 struct vmbus_channel_offer_channel *offer)
950{
951 /*
952 * Setup state for signalling the host.
953 */
954 channel->sig_event = VMBUS_EVENT_CONNECTION_ID;
955
956 channel->is_dedicated_interrupt =
957 (offer->is_dedicated_interrupt != 0);
958 channel->sig_event = offer->connection_id;
959
960 memcpy(&channel->offermsg, offer,
961 sizeof(struct vmbus_channel_offer_channel));
962 channel->monitor_grp = (u8)offer->monitorid / 32;
963 channel->monitor_bit = (u8)offer->monitorid % 32;
964 channel->device_id = hv_get_dev_type(channel);
965}
966
967/*
968 * find_primary_channel_by_offer - Get the channel object given the new offer.
969 * This is only used in the resume path of hibernation.
970 */
971static struct vmbus_channel *
972find_primary_channel_by_offer(const struct vmbus_channel_offer_channel *offer)
973{
974 struct vmbus_channel *channel = NULL, *iter;
975 const guid_t *inst1, *inst2;
976
977 /* Ignore sub-channel offers. */
978 if (offer->offer.sub_channel_index != 0)
979 return NULL;
980
981 mutex_lock(&vmbus_connection.channel_mutex);
982
983 list_for_each_entry(iter, &vmbus_connection.chn_list, listentry) {
984 inst1 = &iter->offermsg.offer.if_instance;
985 inst2 = &offer->offer.if_instance;
986
987 if (guid_equal(inst1, inst2)) {
988 channel = iter;
989 break;
990 }
991 }
992
993 mutex_unlock(&vmbus_connection.channel_mutex);
994
995 return channel;
996}
997
998static bool vmbus_is_valid_offer(const struct vmbus_channel_offer_channel *offer)
999{
1000 const guid_t *guid = &offer->offer.if_type;
1001 u16 i;
1002
1003 if (!hv_is_isolation_supported())
1004 return true;
1005
1006 if (is_hvsock_offer(offer))
1007 return true;
1008
1009 for (i = 0; i < ARRAY_SIZE(vmbus_devs); i++) {
1010 if (guid_equal(guid, &vmbus_devs[i].guid))
1011 return vmbus_devs[i].allowed_in_isolated;
1012 }
1013 return false;
1014}
1015
1016/*
1017 * vmbus_onoffer - Handler for channel offers from vmbus in parent partition.
1018 *
1019 */
1020static void vmbus_onoffer(struct vmbus_channel_message_header *hdr)
1021{
1022 struct vmbus_channel_offer_channel *offer;
1023 struct vmbus_channel *oldchannel, *newchannel;
1024 size_t offer_sz;
1025
1026 offer = (struct vmbus_channel_offer_channel *)hdr;
1027
1028 trace_vmbus_onoffer(offer);
1029
1030 if (!vmbus_is_valid_offer(offer)) {
1031 pr_err_ratelimited("Invalid offer %d from the host supporting isolation\n",
1032 offer->child_relid);
1033 atomic_dec(&vmbus_connection.offer_in_progress);
1034 return;
1035 }
1036
1037 oldchannel = find_primary_channel_by_offer(offer);
1038
1039 if (oldchannel != NULL) {
1040 /*
1041 * We're resuming from hibernation: all the sub-channel and
1042 * hv_sock channels we had before the hibernation should have
1043 * been cleaned up, and now we must be seeing a re-offered
1044 * primary channel that we had before the hibernation.
1045 */
1046
1047 /*
1048 * { Initially: channel relid = INVALID_RELID,
1049 * channels[valid_relid] = NULL }
1050 *
1051 * CPU1 CPU2
1052 *
1053 * [vmbus_onoffer()] [vmbus_device_release()]
1054 *
1055 * LOCK channel_mutex LOCK channel_mutex
1056 * STORE channel relid = valid_relid LOAD r1 = channel relid
1057 * MAP_RELID channel if (r1 != INVALID_RELID)
1058 * UNLOCK channel_mutex UNMAP_RELID channel
1059 * UNLOCK channel_mutex
1060 *
1061 * Forbids: r1 == valid_relid &&
1062 * channels[valid_relid] == channel
1063 *
1064 * Note. r1 can be INVALID_RELID only for an hv_sock channel.
1065 * None of the hv_sock channels which were present before the
1066 * suspend are re-offered upon the resume. See the WARN_ON()
1067 * in hv_process_channel_removal().
1068 */
1069 mutex_lock(&vmbus_connection.channel_mutex);
1070
1071 atomic_dec(&vmbus_connection.offer_in_progress);
1072
1073 WARN_ON(oldchannel->offermsg.child_relid != INVALID_RELID);
1074 /* Fix up the relid. */
1075 oldchannel->offermsg.child_relid = offer->child_relid;
1076
1077 offer_sz = sizeof(*offer);
1078 if (memcmp(offer, &oldchannel->offermsg, offer_sz) != 0) {
1079 /*
1080 * This is not an error, since the host can also change
1081 * the other field(s) of the offer, e.g. on WS RS5
1082 * (Build 17763), the offer->connection_id of the
1083 * Mellanox VF vmbus device can change when the host
1084 * reoffers the device upon resume.
1085 */
1086 pr_debug("vmbus offer changed: relid=%d\n",
1087 offer->child_relid);
1088
1089 print_hex_dump_debug("Old vmbus offer: ",
1090 DUMP_PREFIX_OFFSET, 16, 4,
1091 &oldchannel->offermsg, offer_sz,
1092 false);
1093 print_hex_dump_debug("New vmbus offer: ",
1094 DUMP_PREFIX_OFFSET, 16, 4,
1095 offer, offer_sz, false);
1096
1097 /* Fix up the old channel. */
1098 vmbus_setup_channel_state(oldchannel, offer);
1099 }
1100
1101 /* Add the channel back to the array of channels. */
1102 vmbus_channel_map_relid(oldchannel);
1103 check_ready_for_resume_event();
1104
1105 mutex_unlock(&vmbus_connection.channel_mutex);
1106 return;
1107 }
1108
1109 /* Allocate the channel object and save this offer. */
1110 newchannel = alloc_channel();
1111 if (!newchannel) {
1112 vmbus_release_relid(offer->child_relid);
1113 atomic_dec(&vmbus_connection.offer_in_progress);
1114 pr_err("Unable to allocate channel object\n");
1115 return;
1116 }
1117
1118 vmbus_setup_channel_state(newchannel, offer);
1119
1120 vmbus_process_offer(newchannel);
1121}
1122
1123static void check_ready_for_suspend_event(void)
1124{
1125 /*
1126 * If all the sub-channels or hv_sock channels have been cleaned up,
1127 * then it's safe to suspend.
1128 */
1129 if (atomic_dec_and_test(&vmbus_connection.nr_chan_close_on_suspend))
1130 complete(&vmbus_connection.ready_for_suspend_event);
1131}
1132
1133/*
1134 * vmbus_onoffer_rescind - Rescind offer handler.
1135 *
1136 * We queue a work item to process this offer synchronously
1137 */
1138static void vmbus_onoffer_rescind(struct vmbus_channel_message_header *hdr)
1139{
1140 struct vmbus_channel_rescind_offer *rescind;
1141 struct vmbus_channel *channel;
1142 struct device *dev;
1143 bool clean_up_chan_for_suspend;
1144
1145 rescind = (struct vmbus_channel_rescind_offer *)hdr;
1146
1147 trace_vmbus_onoffer_rescind(rescind);
1148
1149 /*
1150 * The offer msg and the corresponding rescind msg
1151 * from the host are guranteed to be ordered -
1152 * offer comes in first and then the rescind.
1153 * Since we process these events in work elements,
1154 * and with preemption, we may end up processing
1155 * the events out of order. We rely on the synchronization
1156 * provided by offer_in_progress and by channel_mutex for
1157 * ordering these events:
1158 *
1159 * { Initially: offer_in_progress = 1 }
1160 *
1161 * CPU1 CPU2
1162 *
1163 * [vmbus_onoffer()] [vmbus_onoffer_rescind()]
1164 *
1165 * LOCK channel_mutex WAIT_ON offer_in_progress == 0
1166 * DECREMENT offer_in_progress LOCK channel_mutex
1167 * STORE channels[] LOAD channels[]
1168 * UNLOCK channel_mutex UNLOCK channel_mutex
1169 *
1170 * Forbids: CPU2's LOAD from *not* seeing CPU1's STORE
1171 */
1172
1173 while (atomic_read(&vmbus_connection.offer_in_progress) != 0) {
1174 /*
1175 * We wait here until any channel offer is currently
1176 * being processed.
1177 */
1178 msleep(1);
1179 }
1180
1181 mutex_lock(&vmbus_connection.channel_mutex);
1182 channel = relid2channel(rescind->child_relid);
1183 if (channel != NULL) {
1184 /*
1185 * Guarantee that no other instance of vmbus_onoffer_rescind()
1186 * has got a reference to the channel object. Synchronize on
1187 * &vmbus_connection.channel_mutex.
1188 */
1189 if (channel->rescind_ref) {
1190 mutex_unlock(&vmbus_connection.channel_mutex);
1191 return;
1192 }
1193 channel->rescind_ref = true;
1194 }
1195 mutex_unlock(&vmbus_connection.channel_mutex);
1196
1197 if (channel == NULL) {
1198 /*
1199 * We failed in processing the offer message;
1200 * we would have cleaned up the relid in that
1201 * failure path.
1202 */
1203 return;
1204 }
1205
1206 clean_up_chan_for_suspend = is_hvsock_channel(channel) ||
1207 is_sub_channel(channel);
1208 /*
1209 * Before setting channel->rescind in vmbus_rescind_cleanup(), we
1210 * should make sure the channel callback is not running any more.
1211 */
1212 vmbus_reset_channel_cb(channel);
1213
1214 /*
1215 * Now wait for offer handling to complete.
1216 */
1217 vmbus_rescind_cleanup(channel);
1218 while (READ_ONCE(channel->probe_done) == false) {
1219 /*
1220 * We wait here until any channel offer is currently
1221 * being processed.
1222 */
1223 msleep(1);
1224 }
1225
1226 /*
1227 * At this point, the rescind handling can proceed safely.
1228 */
1229
1230 if (channel->device_obj) {
1231 if (channel->chn_rescind_callback) {
1232 channel->chn_rescind_callback(channel);
1233
1234 if (clean_up_chan_for_suspend)
1235 check_ready_for_suspend_event();
1236
1237 return;
1238 }
1239 /*
1240 * We will have to unregister this device from the
1241 * driver core.
1242 */
1243 dev = get_device(&channel->device_obj->device);
1244 if (dev) {
1245 vmbus_device_unregister(channel->device_obj);
1246 put_device(dev);
1247 }
1248 } else if (channel->primary_channel != NULL) {
1249 /*
1250 * Sub-channel is being rescinded. Following is the channel
1251 * close sequence when initiated from the driveri (refer to
1252 * vmbus_close() for details):
1253 * 1. Close all sub-channels first
1254 * 2. Then close the primary channel.
1255 */
1256 mutex_lock(&vmbus_connection.channel_mutex);
1257 if (channel->state == CHANNEL_OPEN_STATE) {
1258 /*
1259 * The channel is currently not open;
1260 * it is safe for us to cleanup the channel.
1261 */
1262 hv_process_channel_removal(channel);
1263 } else {
1264 complete(&channel->rescind_event);
1265 }
1266 mutex_unlock(&vmbus_connection.channel_mutex);
1267 }
1268
1269 /* The "channel" may have been freed. Do not access it any longer. */
1270
1271 if (clean_up_chan_for_suspend)
1272 check_ready_for_suspend_event();
1273}
1274
1275void vmbus_hvsock_device_unregister(struct vmbus_channel *channel)
1276{
1277 BUG_ON(!is_hvsock_channel(channel));
1278
1279 /* We always get a rescind msg when a connection is closed. */
1280 while (!READ_ONCE(channel->probe_done) || !READ_ONCE(channel->rescind))
1281 msleep(1);
1282
1283 vmbus_device_unregister(channel->device_obj);
1284}
1285EXPORT_SYMBOL_GPL(vmbus_hvsock_device_unregister);
1286
1287
1288/*
1289 * vmbus_onoffers_delivered -
1290 * This is invoked when all offers have been delivered.
1291 *
1292 * Nothing to do here.
1293 */
1294static void vmbus_onoffers_delivered(
1295 struct vmbus_channel_message_header *hdr)
1296{
1297}
1298
1299/*
1300 * vmbus_onopen_result - Open result handler.
1301 *
1302 * This is invoked when we received a response to our channel open request.
1303 * Find the matching request, copy the response and signal the requesting
1304 * thread.
1305 */
1306static void vmbus_onopen_result(struct vmbus_channel_message_header *hdr)
1307{
1308 struct vmbus_channel_open_result *result;
1309 struct vmbus_channel_msginfo *msginfo;
1310 struct vmbus_channel_message_header *requestheader;
1311 struct vmbus_channel_open_channel *openmsg;
1312 unsigned long flags;
1313
1314 result = (struct vmbus_channel_open_result *)hdr;
1315
1316 trace_vmbus_onopen_result(result);
1317
1318 /*
1319 * Find the open msg, copy the result and signal/unblock the wait event
1320 */
1321 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
1322
1323 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
1324 msglistentry) {
1325 requestheader =
1326 (struct vmbus_channel_message_header *)msginfo->msg;
1327
1328 if (requestheader->msgtype == CHANNELMSG_OPENCHANNEL) {
1329 openmsg =
1330 (struct vmbus_channel_open_channel *)msginfo->msg;
1331 if (openmsg->child_relid == result->child_relid &&
1332 openmsg->openid == result->openid) {
1333 memcpy(&msginfo->response.open_result,
1334 result,
1335 sizeof(
1336 struct vmbus_channel_open_result));
1337 complete(&msginfo->waitevent);
1338 break;
1339 }
1340 }
1341 }
1342 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
1343}
1344
1345/*
1346 * vmbus_ongpadl_created - GPADL created handler.
1347 *
1348 * This is invoked when we received a response to our gpadl create request.
1349 * Find the matching request, copy the response and signal the requesting
1350 * thread.
1351 */
1352static void vmbus_ongpadl_created(struct vmbus_channel_message_header *hdr)
1353{
1354 struct vmbus_channel_gpadl_created *gpadlcreated;
1355 struct vmbus_channel_msginfo *msginfo;
1356 struct vmbus_channel_message_header *requestheader;
1357 struct vmbus_channel_gpadl_header *gpadlheader;
1358 unsigned long flags;
1359
1360 gpadlcreated = (struct vmbus_channel_gpadl_created *)hdr;
1361
1362 trace_vmbus_ongpadl_created(gpadlcreated);
1363
1364 /*
1365 * Find the establish msg, copy the result and signal/unblock the wait
1366 * event
1367 */
1368 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
1369
1370 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
1371 msglistentry) {
1372 requestheader =
1373 (struct vmbus_channel_message_header *)msginfo->msg;
1374
1375 if (requestheader->msgtype == CHANNELMSG_GPADL_HEADER) {
1376 gpadlheader =
1377 (struct vmbus_channel_gpadl_header *)requestheader;
1378
1379 if ((gpadlcreated->child_relid ==
1380 gpadlheader->child_relid) &&
1381 (gpadlcreated->gpadl == gpadlheader->gpadl)) {
1382 memcpy(&msginfo->response.gpadl_created,
1383 gpadlcreated,
1384 sizeof(
1385 struct vmbus_channel_gpadl_created));
1386 complete(&msginfo->waitevent);
1387 break;
1388 }
1389 }
1390 }
1391 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
1392}
1393
1394/*
1395 * vmbus_onmodifychannel_response - Modify Channel response handler.
1396 *
1397 * This is invoked when we received a response to our channel modify request.
1398 * Find the matching request, copy the response and signal the requesting thread.
1399 */
1400static void vmbus_onmodifychannel_response(struct vmbus_channel_message_header *hdr)
1401{
1402 struct vmbus_channel_modifychannel_response *response;
1403 struct vmbus_channel_msginfo *msginfo;
1404 unsigned long flags;
1405
1406 response = (struct vmbus_channel_modifychannel_response *)hdr;
1407
1408 trace_vmbus_onmodifychannel_response(response);
1409
1410 /*
1411 * Find the modify msg, copy the response and signal/unblock the wait event.
1412 */
1413 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
1414
1415 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list, msglistentry) {
1416 struct vmbus_channel_message_header *responseheader =
1417 (struct vmbus_channel_message_header *)msginfo->msg;
1418
1419 if (responseheader->msgtype == CHANNELMSG_MODIFYCHANNEL) {
1420 struct vmbus_channel_modifychannel *modifymsg;
1421
1422 modifymsg = (struct vmbus_channel_modifychannel *)msginfo->msg;
1423 if (modifymsg->child_relid == response->child_relid) {
1424 memcpy(&msginfo->response.modify_response, response,
1425 sizeof(*response));
1426 complete(&msginfo->waitevent);
1427 break;
1428 }
1429 }
1430 }
1431 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
1432}
1433
1434/*
1435 * vmbus_ongpadl_torndown - GPADL torndown handler.
1436 *
1437 * This is invoked when we received a response to our gpadl teardown request.
1438 * Find the matching request, copy the response and signal the requesting
1439 * thread.
1440 */
1441static void vmbus_ongpadl_torndown(
1442 struct vmbus_channel_message_header *hdr)
1443{
1444 struct vmbus_channel_gpadl_torndown *gpadl_torndown;
1445 struct vmbus_channel_msginfo *msginfo;
1446 struct vmbus_channel_message_header *requestheader;
1447 struct vmbus_channel_gpadl_teardown *gpadl_teardown;
1448 unsigned long flags;
1449
1450 gpadl_torndown = (struct vmbus_channel_gpadl_torndown *)hdr;
1451
1452 trace_vmbus_ongpadl_torndown(gpadl_torndown);
1453
1454 /*
1455 * Find the open msg, copy the result and signal/unblock the wait event
1456 */
1457 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
1458
1459 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
1460 msglistentry) {
1461 requestheader =
1462 (struct vmbus_channel_message_header *)msginfo->msg;
1463
1464 if (requestheader->msgtype == CHANNELMSG_GPADL_TEARDOWN) {
1465 gpadl_teardown =
1466 (struct vmbus_channel_gpadl_teardown *)requestheader;
1467
1468 if (gpadl_torndown->gpadl == gpadl_teardown->gpadl) {
1469 memcpy(&msginfo->response.gpadl_torndown,
1470 gpadl_torndown,
1471 sizeof(
1472 struct vmbus_channel_gpadl_torndown));
1473 complete(&msginfo->waitevent);
1474 break;
1475 }
1476 }
1477 }
1478 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
1479}
1480
1481/*
1482 * vmbus_onversion_response - Version response handler
1483 *
1484 * This is invoked when we received a response to our initiate contact request.
1485 * Find the matching request, copy the response and signal the requesting
1486 * thread.
1487 */
1488static void vmbus_onversion_response(
1489 struct vmbus_channel_message_header *hdr)
1490{
1491 struct vmbus_channel_msginfo *msginfo;
1492 struct vmbus_channel_message_header *requestheader;
1493 struct vmbus_channel_version_response *version_response;
1494 unsigned long flags;
1495
1496 version_response = (struct vmbus_channel_version_response *)hdr;
1497
1498 trace_vmbus_onversion_response(version_response);
1499
1500 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
1501
1502 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
1503 msglistentry) {
1504 requestheader =
1505 (struct vmbus_channel_message_header *)msginfo->msg;
1506
1507 if (requestheader->msgtype ==
1508 CHANNELMSG_INITIATE_CONTACT) {
1509 memcpy(&msginfo->response.version_response,
1510 version_response,
1511 sizeof(struct vmbus_channel_version_response));
1512 complete(&msginfo->waitevent);
1513 }
1514 }
1515 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
1516}
1517
1518/* Channel message dispatch table */
1519const struct vmbus_channel_message_table_entry
1520channel_message_table[CHANNELMSG_COUNT] = {
1521 { CHANNELMSG_INVALID, 0, NULL, 0},
1522 { CHANNELMSG_OFFERCHANNEL, 0, vmbus_onoffer,
1523 sizeof(struct vmbus_channel_offer_channel)},
1524 { CHANNELMSG_RESCIND_CHANNELOFFER, 0, vmbus_onoffer_rescind,
1525 sizeof(struct vmbus_channel_rescind_offer) },
1526 { CHANNELMSG_REQUESTOFFERS, 0, NULL, 0},
1527 { CHANNELMSG_ALLOFFERS_DELIVERED, 1, vmbus_onoffers_delivered, 0},
1528 { CHANNELMSG_OPENCHANNEL, 0, NULL, 0},
1529 { CHANNELMSG_OPENCHANNEL_RESULT, 1, vmbus_onopen_result,
1530 sizeof(struct vmbus_channel_open_result)},
1531 { CHANNELMSG_CLOSECHANNEL, 0, NULL, 0},
1532 { CHANNELMSG_GPADL_HEADER, 0, NULL, 0},
1533 { CHANNELMSG_GPADL_BODY, 0, NULL, 0},
1534 { CHANNELMSG_GPADL_CREATED, 1, vmbus_ongpadl_created,
1535 sizeof(struct vmbus_channel_gpadl_created)},
1536 { CHANNELMSG_GPADL_TEARDOWN, 0, NULL, 0},
1537 { CHANNELMSG_GPADL_TORNDOWN, 1, vmbus_ongpadl_torndown,
1538 sizeof(struct vmbus_channel_gpadl_torndown) },
1539 { CHANNELMSG_RELID_RELEASED, 0, NULL, 0},
1540 { CHANNELMSG_INITIATE_CONTACT, 0, NULL, 0},
1541 { CHANNELMSG_VERSION_RESPONSE, 1, vmbus_onversion_response,
1542 sizeof(struct vmbus_channel_version_response)},
1543 { CHANNELMSG_UNLOAD, 0, NULL, 0},
1544 { CHANNELMSG_UNLOAD_RESPONSE, 1, vmbus_unload_response, 0},
1545 { CHANNELMSG_18, 0, NULL, 0},
1546 { CHANNELMSG_19, 0, NULL, 0},
1547 { CHANNELMSG_20, 0, NULL, 0},
1548 { CHANNELMSG_TL_CONNECT_REQUEST, 0, NULL, 0},
1549 { CHANNELMSG_MODIFYCHANNEL, 0, NULL, 0},
1550 { CHANNELMSG_TL_CONNECT_RESULT, 0, NULL, 0},
1551 { CHANNELMSG_MODIFYCHANNEL_RESPONSE, 1, vmbus_onmodifychannel_response,
1552 sizeof(struct vmbus_channel_modifychannel_response)},
1553};
1554
1555/*
1556 * vmbus_onmessage - Handler for channel protocol messages.
1557 *
1558 * This is invoked in the vmbus worker thread context.
1559 */
1560void vmbus_onmessage(struct vmbus_channel_message_header *hdr)
1561{
1562 trace_vmbus_on_message(hdr);
1563
1564 /*
1565 * vmbus_on_msg_dpc() makes sure the hdr->msgtype here can not go
1566 * out of bound and the message_handler pointer can not be NULL.
1567 */
1568 channel_message_table[hdr->msgtype].message_handler(hdr);
1569}
1570
1571/*
1572 * vmbus_request_offers - Send a request to get all our pending offers.
1573 */
1574int vmbus_request_offers(void)
1575{
1576 struct vmbus_channel_message_header *msg;
1577 struct vmbus_channel_msginfo *msginfo;
1578 int ret;
1579
1580 msginfo = kzalloc(sizeof(*msginfo) +
1581 sizeof(struct vmbus_channel_message_header),
1582 GFP_KERNEL);
1583 if (!msginfo)
1584 return -ENOMEM;
1585
1586 msg = (struct vmbus_channel_message_header *)msginfo->msg;
1587
1588 msg->msgtype = CHANNELMSG_REQUESTOFFERS;
1589
1590 ret = vmbus_post_msg(msg, sizeof(struct vmbus_channel_message_header),
1591 true);
1592
1593 trace_vmbus_request_offers(ret);
1594
1595 if (ret != 0) {
1596 pr_err("Unable to request offers - %d\n", ret);
1597
1598 goto cleanup;
1599 }
1600
1601cleanup:
1602 kfree(msginfo);
1603
1604 return ret;
1605}
1606
1607void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel,
1608 void (*sc_cr_cb)(struct vmbus_channel *new_sc))
1609{
1610 primary_channel->sc_creation_callback = sc_cr_cb;
1611}
1612EXPORT_SYMBOL_GPL(vmbus_set_sc_create_callback);
1613
1614void vmbus_set_chn_rescind_callback(struct vmbus_channel *channel,
1615 void (*chn_rescind_cb)(struct vmbus_channel *))
1616{
1617 channel->chn_rescind_callback = chn_rescind_cb;
1618}
1619EXPORT_SYMBOL_GPL(vmbus_set_chn_rescind_callback);
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
35struct vmbus_channel_message_table_entry {
36 enum vmbus_channel_message_type message_type;
37 void (*message_handler)(struct vmbus_channel_message_header *msg);
38};
39
40
41/**
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
46 *
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.
50 *
51 * The fw_version specifies the framework version that
52 * we can support and srv_version specifies the service
53 * version we can support.
54 *
55 * Mainly used by Hyper-V drivers.
56 */
57bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp,
58 struct icmsg_negotiate *negop, u8 *buf,
59 int fw_version, int srv_version)
60{
61 int icframe_major, icframe_minor;
62 int icmsg_major, icmsg_minor;
63 int fw_major, fw_minor;
64 int srv_major, srv_minor;
65 int i;
66 bool found_match = false;
67
68 icmsghdrp->icmsgsize = 0x10;
69 fw_major = (fw_version >> 16);
70 fw_minor = (fw_version & 0xFFFF);
71
72 srv_major = (srv_version >> 16);
73 srv_minor = (srv_version & 0xFFFF);
74
75 negop = (struct icmsg_negotiate *)&buf[
76 sizeof(struct vmbuspipe_hdr) +
77 sizeof(struct icmsg_hdr)];
78
79 icframe_major = negop->icframe_vercnt;
80 icframe_minor = 0;
81
82 icmsg_major = negop->icmsg_vercnt;
83 icmsg_minor = 0;
84
85 /*
86 * Select the framework version number we will
87 * support.
88 */
89
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;
95 found_match = true;
96 }
97 }
98
99 if (!found_match)
100 goto fw_error;
101
102 found_match = false;
103
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;
110 found_match = true;
111 }
112 }
113
114 /*
115 * Respond with the framework and service
116 * version numbers we can support.
117 */
118
119fw_error:
120 if (!found_match) {
121 negop->icframe_vercnt = 0;
122 negop->icmsg_vercnt = 0;
123 } else {
124 negop->icframe_vercnt = 1;
125 negop->icmsg_vercnt = 1;
126 }
127
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;
132 return found_match;
133}
134
135EXPORT_SYMBOL_GPL(vmbus_prep_negotiate_resp);
136
137/*
138 * alloc_channel - Allocate and initialize a vmbus channel object
139 */
140static struct vmbus_channel *alloc_channel(void)
141{
142 struct vmbus_channel *channel;
143
144 channel = kzalloc(sizeof(*channel), GFP_ATOMIC);
145 if (!channel)
146 return NULL;
147
148 spin_lock_init(&channel->inbound_lock);
149 spin_lock_init(&channel->sc_lock);
150
151 INIT_LIST_HEAD(&channel->sc_list);
152
153 channel->controlwq = create_workqueue("hv_vmbus_ctl");
154 if (!channel->controlwq) {
155 kfree(channel);
156 return NULL;
157 }
158
159 return channel;
160}
161
162/*
163 * release_hannel - Release the vmbus channel object itself
164 */
165static void release_channel(struct work_struct *work)
166{
167 struct vmbus_channel *channel = container_of(work,
168 struct vmbus_channel,
169 work);
170
171 destroy_workqueue(channel->controlwq);
172
173 kfree(channel);
174}
175
176/*
177 * free_channel - Release the resources used by the vmbus channel object
178 */
179static void free_channel(struct vmbus_channel *channel)
180{
181
182 /*
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.
186 */
187 INIT_WORK(&channel->work, release_channel);
188 queue_work(vmbus_connection.work_queue, &channel->work);
189}
190
191
192
193/*
194 * vmbus_process_rescind_offer -
195 * Rescind the offer by initiating a device removal
196 */
197static void vmbus_process_rescind_offer(struct work_struct *work)
198{
199 struct vmbus_channel *channel = container_of(work,
200 struct vmbus_channel,
201 work);
202 unsigned long flags;
203 struct vmbus_channel *primary_channel;
204 struct vmbus_channel_relid_released msg;
205
206 if (channel->device_obj)
207 vmbus_device_unregister(channel->device_obj);
208 memset(&msg, 0, sizeof(struct vmbus_channel_relid_released));
209 msg.child_relid = channel->offermsg.child_relid;
210 msg.header.msgtype = CHANNELMSG_RELID_RELEASED;
211 vmbus_post_msg(&msg, sizeof(struct vmbus_channel_relid_released));
212
213 if (channel->primary_channel == NULL) {
214 spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
215 list_del(&channel->listentry);
216 spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
217 } else {
218 primary_channel = channel->primary_channel;
219 spin_lock_irqsave(&primary_channel->sc_lock, flags);
220 list_del(&channel->sc_list);
221 spin_unlock_irqrestore(&primary_channel->sc_lock, flags);
222 }
223 free_channel(channel);
224}
225
226void vmbus_free_channels(void)
227{
228 struct vmbus_channel *channel;
229
230 list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
231 vmbus_device_unregister(channel->device_obj);
232 kfree(channel->device_obj);
233 free_channel(channel);
234 }
235}
236
237/*
238 * vmbus_process_offer - Process the offer by creating a channel/device
239 * associated with this offer
240 */
241static void vmbus_process_offer(struct work_struct *work)
242{
243 struct vmbus_channel *newchannel = container_of(work,
244 struct vmbus_channel,
245 work);
246 struct vmbus_channel *channel;
247 bool fnew = true;
248 int ret;
249 unsigned long flags;
250
251 /* The next possible work is rescind handling */
252 INIT_WORK(&newchannel->work, vmbus_process_rescind_offer);
253
254 /* Make sure this is a new offer */
255 spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
256
257 list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
258 if (!uuid_le_cmp(channel->offermsg.offer.if_type,
259 newchannel->offermsg.offer.if_type) &&
260 !uuid_le_cmp(channel->offermsg.offer.if_instance,
261 newchannel->offermsg.offer.if_instance)) {
262 fnew = false;
263 break;
264 }
265 }
266
267 if (fnew)
268 list_add_tail(&newchannel->listentry,
269 &vmbus_connection.chn_list);
270
271 spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
272
273 if (!fnew) {
274 /*
275 * Check to see if this is a sub-channel.
276 */
277 if (newchannel->offermsg.offer.sub_channel_index != 0) {
278 /*
279 * Process the sub-channel.
280 */
281 newchannel->primary_channel = channel;
282 spin_lock_irqsave(&channel->sc_lock, flags);
283 list_add_tail(&newchannel->sc_list, &channel->sc_list);
284 spin_unlock_irqrestore(&channel->sc_lock, flags);
285 newchannel->state = CHANNEL_OPEN_STATE;
286 if (channel->sc_creation_callback != NULL)
287 channel->sc_creation_callback(newchannel);
288
289 return;
290 }
291
292 free_channel(newchannel);
293 return;
294 }
295
296 /*
297 * This state is used to indicate a successful open
298 * so that when we do close the channel normally, we
299 * can cleanup properly
300 */
301 newchannel->state = CHANNEL_OPEN_STATE;
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
313 /*
314 * Add the new device to the bus. This will kick off device-driver
315 * binding which eventually invokes the device driver's AddDevice()
316 * method.
317 */
318 ret = vmbus_device_register(newchannel->device_obj);
319 if (ret != 0) {
320 pr_err("unable to add child device object (relid %d)\n",
321 newchannel->offermsg.child_relid);
322
323 spin_lock_irqsave(&vmbus_connection.channel_lock, flags);
324 list_del(&newchannel->listentry);
325 spin_unlock_irqrestore(&vmbus_connection.channel_lock, flags);
326 kfree(newchannel->device_obj);
327
328 free_channel(newchannel);
329 }
330}
331
332enum {
333 IDE = 0,
334 SCSI,
335 NIC,
336 MAX_PERF_CHN,
337};
338
339/*
340 * This is an array of device_ids (device types) that are performance critical.
341 * We attempt to distribute the interrupt load for these devices across
342 * all available CPUs.
343 */
344static const struct hv_vmbus_device_id hp_devs[] = {
345 /* IDE */
346 { HV_IDE_GUID, },
347 /* Storage - SCSI */
348 { HV_SCSI_GUID, },
349 /* Network */
350 { HV_NIC_GUID, },
351};
352
353
354/*
355 * We use this state to statically distribute the channel interrupt load.
356 */
357static u32 next_vp;
358
359/*
360 * Starting with Win8, we can statically distribute the incoming
361 * channel interrupt load by binding a channel to VCPU. We
362 * implement here a simple round robin scheme for distributing
363 * the interrupt load.
364 * We will bind channels that are not performance critical to cpu 0 and
365 * performance critical channels (IDE, SCSI and Network) will be uniformly
366 * distributed across all available CPUs.
367 */
368static u32 get_vp_index(uuid_le *type_guid)
369{
370 u32 cur_cpu;
371 int i;
372 bool perf_chn = false;
373 u32 max_cpus = num_online_cpus();
374
375 for (i = IDE; i < MAX_PERF_CHN; i++) {
376 if (!memcmp(type_guid->b, hp_devs[i].guid,
377 sizeof(uuid_le))) {
378 perf_chn = true;
379 break;
380 }
381 }
382 if ((vmbus_proto_version == VERSION_WS2008) ||
383 (vmbus_proto_version == VERSION_WIN7) || (!perf_chn)) {
384 /*
385 * Prior to win8, all channel interrupts are
386 * delivered on cpu 0.
387 * Also if the channel is not a performance critical
388 * channel, bind it to cpu 0.
389 */
390 return 0;
391 }
392 cur_cpu = (++next_vp % max_cpus);
393 return hv_context.vp_index[cur_cpu];
394}
395
396/*
397 * vmbus_onoffer - Handler for channel offers from vmbus in parent partition.
398 *
399 */
400static void vmbus_onoffer(struct vmbus_channel_message_header *hdr)
401{
402 struct vmbus_channel_offer_channel *offer;
403 struct vmbus_channel *newchannel;
404
405 offer = (struct vmbus_channel_offer_channel *)hdr;
406
407 /* Allocate the channel object and save this offer. */
408 newchannel = alloc_channel();
409 if (!newchannel) {
410 pr_err("Unable to allocate channel object\n");
411 return;
412 }
413
414 /*
415 * By default we setup state to enable batched
416 * reading. A specific service can choose to
417 * disable this prior to opening the channel.
418 */
419 newchannel->batched_reading = true;
420
421 /*
422 * Setup state for signalling the host.
423 */
424 newchannel->sig_event = (struct hv_input_signal_event *)
425 (ALIGN((unsigned long)
426 &newchannel->sig_buf,
427 HV_HYPERCALL_PARAM_ALIGN));
428
429 newchannel->sig_event->connectionid.asu32 = 0;
430 newchannel->sig_event->connectionid.u.id = VMBUS_EVENT_CONNECTION_ID;
431 newchannel->sig_event->flag_number = 0;
432 newchannel->sig_event->rsvdz = 0;
433
434 if (vmbus_proto_version != VERSION_WS2008) {
435 newchannel->is_dedicated_interrupt =
436 (offer->is_dedicated_interrupt != 0);
437 newchannel->sig_event->connectionid.u.id =
438 offer->connection_id;
439 }
440
441 newchannel->target_vp = get_vp_index(&offer->offer.if_type);
442
443 memcpy(&newchannel->offermsg, offer,
444 sizeof(struct vmbus_channel_offer_channel));
445 newchannel->monitor_grp = (u8)offer->monitorid / 32;
446 newchannel->monitor_bit = (u8)offer->monitorid % 32;
447
448 INIT_WORK(&newchannel->work, vmbus_process_offer);
449 queue_work(newchannel->controlwq, &newchannel->work);
450}
451
452/*
453 * vmbus_onoffer_rescind - Rescind offer handler.
454 *
455 * We queue a work item to process this offer synchronously
456 */
457static void vmbus_onoffer_rescind(struct vmbus_channel_message_header *hdr)
458{
459 struct vmbus_channel_rescind_offer *rescind;
460 struct vmbus_channel *channel;
461
462 rescind = (struct vmbus_channel_rescind_offer *)hdr;
463 channel = relid2channel(rescind->child_relid);
464
465 if (channel == NULL)
466 /* Just return here, no channel found */
467 return;
468
469 /* work is initialized for vmbus_process_rescind_offer() from
470 * vmbus_process_offer() where the channel got created */
471 queue_work(channel->controlwq, &channel->work);
472}
473
474/*
475 * vmbus_onoffers_delivered -
476 * This is invoked when all offers have been delivered.
477 *
478 * Nothing to do here.
479 */
480static void vmbus_onoffers_delivered(
481 struct vmbus_channel_message_header *hdr)
482{
483}
484
485/*
486 * vmbus_onopen_result - Open result handler.
487 *
488 * This is invoked when we received a response to our channel open request.
489 * Find the matching request, copy the response and signal the requesting
490 * thread.
491 */
492static void vmbus_onopen_result(struct vmbus_channel_message_header *hdr)
493{
494 struct vmbus_channel_open_result *result;
495 struct vmbus_channel_msginfo *msginfo;
496 struct vmbus_channel_message_header *requestheader;
497 struct vmbus_channel_open_channel *openmsg;
498 unsigned long flags;
499
500 result = (struct vmbus_channel_open_result *)hdr;
501
502 /*
503 * Find the open msg, copy the result and signal/unblock the wait event
504 */
505 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
506
507 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
508 msglistentry) {
509 requestheader =
510 (struct vmbus_channel_message_header *)msginfo->msg;
511
512 if (requestheader->msgtype == CHANNELMSG_OPENCHANNEL) {
513 openmsg =
514 (struct vmbus_channel_open_channel *)msginfo->msg;
515 if (openmsg->child_relid == result->child_relid &&
516 openmsg->openid == result->openid) {
517 memcpy(&msginfo->response.open_result,
518 result,
519 sizeof(
520 struct vmbus_channel_open_result));
521 complete(&msginfo->waitevent);
522 break;
523 }
524 }
525 }
526 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
527}
528
529/*
530 * vmbus_ongpadl_created - GPADL created handler.
531 *
532 * This is invoked when we received a response to our gpadl create request.
533 * Find the matching request, copy the response and signal the requesting
534 * thread.
535 */
536static void vmbus_ongpadl_created(struct vmbus_channel_message_header *hdr)
537{
538 struct vmbus_channel_gpadl_created *gpadlcreated;
539 struct vmbus_channel_msginfo *msginfo;
540 struct vmbus_channel_message_header *requestheader;
541 struct vmbus_channel_gpadl_header *gpadlheader;
542 unsigned long flags;
543
544 gpadlcreated = (struct vmbus_channel_gpadl_created *)hdr;
545
546 /*
547 * Find the establish msg, copy the result and signal/unblock the wait
548 * event
549 */
550 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
551
552 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
553 msglistentry) {
554 requestheader =
555 (struct vmbus_channel_message_header *)msginfo->msg;
556
557 if (requestheader->msgtype == CHANNELMSG_GPADL_HEADER) {
558 gpadlheader =
559 (struct vmbus_channel_gpadl_header *)requestheader;
560
561 if ((gpadlcreated->child_relid ==
562 gpadlheader->child_relid) &&
563 (gpadlcreated->gpadl == gpadlheader->gpadl)) {
564 memcpy(&msginfo->response.gpadl_created,
565 gpadlcreated,
566 sizeof(
567 struct vmbus_channel_gpadl_created));
568 complete(&msginfo->waitevent);
569 break;
570 }
571 }
572 }
573 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
574}
575
576/*
577 * vmbus_ongpadl_torndown - GPADL torndown handler.
578 *
579 * This is invoked when we received a response to our gpadl teardown request.
580 * Find the matching request, copy the response and signal the requesting
581 * thread.
582 */
583static void vmbus_ongpadl_torndown(
584 struct vmbus_channel_message_header *hdr)
585{
586 struct vmbus_channel_gpadl_torndown *gpadl_torndown;
587 struct vmbus_channel_msginfo *msginfo;
588 struct vmbus_channel_message_header *requestheader;
589 struct vmbus_channel_gpadl_teardown *gpadl_teardown;
590 unsigned long flags;
591
592 gpadl_torndown = (struct vmbus_channel_gpadl_torndown *)hdr;
593
594 /*
595 * Find the open msg, copy the result and signal/unblock the wait event
596 */
597 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
598
599 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
600 msglistentry) {
601 requestheader =
602 (struct vmbus_channel_message_header *)msginfo->msg;
603
604 if (requestheader->msgtype == CHANNELMSG_GPADL_TEARDOWN) {
605 gpadl_teardown =
606 (struct vmbus_channel_gpadl_teardown *)requestheader;
607
608 if (gpadl_torndown->gpadl == gpadl_teardown->gpadl) {
609 memcpy(&msginfo->response.gpadl_torndown,
610 gpadl_torndown,
611 sizeof(
612 struct vmbus_channel_gpadl_torndown));
613 complete(&msginfo->waitevent);
614 break;
615 }
616 }
617 }
618 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
619}
620
621/*
622 * vmbus_onversion_response - Version response handler
623 *
624 * This is invoked when we received a response to our initiate contact request.
625 * Find the matching request, copy the response and signal the requesting
626 * thread.
627 */
628static void vmbus_onversion_response(
629 struct vmbus_channel_message_header *hdr)
630{
631 struct vmbus_channel_msginfo *msginfo;
632 struct vmbus_channel_message_header *requestheader;
633 struct vmbus_channel_version_response *version_response;
634 unsigned long flags;
635
636 version_response = (struct vmbus_channel_version_response *)hdr;
637 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
638
639 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
640 msglistentry) {
641 requestheader =
642 (struct vmbus_channel_message_header *)msginfo->msg;
643
644 if (requestheader->msgtype ==
645 CHANNELMSG_INITIATE_CONTACT) {
646 memcpy(&msginfo->response.version_response,
647 version_response,
648 sizeof(struct vmbus_channel_version_response));
649 complete(&msginfo->waitevent);
650 }
651 }
652 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
653}
654
655/* Channel message dispatch table */
656static struct vmbus_channel_message_table_entry
657 channel_message_table[CHANNELMSG_COUNT] = {
658 {CHANNELMSG_INVALID, NULL},
659 {CHANNELMSG_OFFERCHANNEL, vmbus_onoffer},
660 {CHANNELMSG_RESCIND_CHANNELOFFER, vmbus_onoffer_rescind},
661 {CHANNELMSG_REQUESTOFFERS, NULL},
662 {CHANNELMSG_ALLOFFERS_DELIVERED, vmbus_onoffers_delivered},
663 {CHANNELMSG_OPENCHANNEL, NULL},
664 {CHANNELMSG_OPENCHANNEL_RESULT, vmbus_onopen_result},
665 {CHANNELMSG_CLOSECHANNEL, NULL},
666 {CHANNELMSG_GPADL_HEADER, NULL},
667 {CHANNELMSG_GPADL_BODY, NULL},
668 {CHANNELMSG_GPADL_CREATED, vmbus_ongpadl_created},
669 {CHANNELMSG_GPADL_TEARDOWN, NULL},
670 {CHANNELMSG_GPADL_TORNDOWN, vmbus_ongpadl_torndown},
671 {CHANNELMSG_RELID_RELEASED, NULL},
672 {CHANNELMSG_INITIATE_CONTACT, NULL},
673 {CHANNELMSG_VERSION_RESPONSE, vmbus_onversion_response},
674 {CHANNELMSG_UNLOAD, NULL},
675};
676
677/*
678 * vmbus_onmessage - Handler for channel protocol messages.
679 *
680 * This is invoked in the vmbus worker thread context.
681 */
682void vmbus_onmessage(void *context)
683{
684 struct hv_message *msg = context;
685 struct vmbus_channel_message_header *hdr;
686 int size;
687
688 hdr = (struct vmbus_channel_message_header *)msg->u.payload;
689 size = msg->header.payload_size;
690
691 if (hdr->msgtype >= CHANNELMSG_COUNT) {
692 pr_err("Received invalid channel message type %d size %d\n",
693 hdr->msgtype, size);
694 print_hex_dump_bytes("", DUMP_PREFIX_NONE,
695 (unsigned char *)msg->u.payload, size);
696 return;
697 }
698
699 if (channel_message_table[hdr->msgtype].message_handler)
700 channel_message_table[hdr->msgtype].message_handler(hdr);
701 else
702 pr_err("Unhandled channel message type %d\n", hdr->msgtype);
703}
704
705/*
706 * vmbus_request_offers - Send a request to get all our pending offers.
707 */
708int vmbus_request_offers(void)
709{
710 struct vmbus_channel_message_header *msg;
711 struct vmbus_channel_msginfo *msginfo;
712 int ret, t;
713
714 msginfo = kmalloc(sizeof(*msginfo) +
715 sizeof(struct vmbus_channel_message_header),
716 GFP_KERNEL);
717 if (!msginfo)
718 return -ENOMEM;
719
720 init_completion(&msginfo->waitevent);
721
722 msg = (struct vmbus_channel_message_header *)msginfo->msg;
723
724 msg->msgtype = CHANNELMSG_REQUESTOFFERS;
725
726
727 ret = vmbus_post_msg(msg,
728 sizeof(struct vmbus_channel_message_header));
729 if (ret != 0) {
730 pr_err("Unable to request offers - %d\n", ret);
731
732 goto cleanup;
733 }
734
735 t = wait_for_completion_timeout(&msginfo->waitevent, 5*HZ);
736 if (t == 0) {
737 ret = -ETIMEDOUT;
738 goto cleanup;
739 }
740
741
742
743cleanup:
744 kfree(msginfo);
745
746 return ret;
747}
748
749/*
750 * Retrieve the (sub) channel on which to send an outgoing request.
751 * When a primary channel has multiple sub-channels, we choose a
752 * channel whose VCPU binding is closest to the VCPU on which
753 * this call is being made.
754 */
755struct vmbus_channel *vmbus_get_outgoing_channel(struct vmbus_channel *primary)
756{
757 struct list_head *cur, *tmp;
758 int cur_cpu = hv_context.vp_index[smp_processor_id()];
759 struct vmbus_channel *cur_channel;
760 struct vmbus_channel *outgoing_channel = primary;
761 int cpu_distance, new_cpu_distance;
762
763 if (list_empty(&primary->sc_list))
764 return outgoing_channel;
765
766 list_for_each_safe(cur, tmp, &primary->sc_list) {
767 cur_channel = list_entry(cur, struct vmbus_channel, sc_list);
768 if (cur_channel->state != CHANNEL_OPENED_STATE)
769 continue;
770
771 if (cur_channel->target_vp == cur_cpu)
772 return cur_channel;
773
774 cpu_distance = ((outgoing_channel->target_vp > cur_cpu) ?
775 (outgoing_channel->target_vp - cur_cpu) :
776 (cur_cpu - outgoing_channel->target_vp));
777
778 new_cpu_distance = ((cur_channel->target_vp > cur_cpu) ?
779 (cur_channel->target_vp - cur_cpu) :
780 (cur_cpu - cur_channel->target_vp));
781
782 if (cpu_distance < new_cpu_distance)
783 continue;
784
785 outgoing_channel = cur_channel;
786 }
787
788 return outgoing_channel;
789}
790EXPORT_SYMBOL_GPL(vmbus_get_outgoing_channel);
791
792static void invoke_sc_cb(struct vmbus_channel *primary_channel)
793{
794 struct list_head *cur, *tmp;
795 struct vmbus_channel *cur_channel;
796
797 if (primary_channel->sc_creation_callback == NULL)
798 return;
799
800 list_for_each_safe(cur, tmp, &primary_channel->sc_list) {
801 cur_channel = list_entry(cur, struct vmbus_channel, sc_list);
802
803 primary_channel->sc_creation_callback(cur_channel);
804 }
805}
806
807void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel,
808 void (*sc_cr_cb)(struct vmbus_channel *new_sc))
809{
810 primary_channel->sc_creation_callback = sc_cr_cb;
811}
812EXPORT_SYMBOL_GPL(vmbus_set_sc_create_callback);
813
814bool vmbus_are_subchannels_present(struct vmbus_channel *primary)
815{
816 bool ret;
817
818 ret = !list_empty(&primary->sc_list);
819
820 if (ret) {
821 /*
822 * Invoke the callback on sub-channel creation.
823 * This will present a uniform interface to the
824 * clients.
825 */
826 invoke_sc_cb(primary);
827 }
828
829 return ret;
830}
831EXPORT_SYMBOL_GPL(vmbus_are_subchannels_present);