1
2
3
4
5
6
7
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/hyperv.h>
22#include <asm/mshyperv.h>
23
24#include "hyperv_vmbus.h"
25
26static void init_vp_index(struct vmbus_channel *channel, u16 dev_type);
27
28static const struct vmbus_device vmbus_devs[] = {
29
30 { .dev_type = HV_IDE,
31 HV_IDE_GUID,
32 .perf_device = true,
33 },
34
35
36 { .dev_type = HV_SCSI,
37 HV_SCSI_GUID,
38 .perf_device = true,
39 },
40
41
42 { .dev_type = HV_FC,
43 HV_SYNTHFC_GUID,
44 .perf_device = true,
45 },
46
47
48 { .dev_type = HV_NIC,
49 HV_NIC_GUID,
50 .perf_device = true,
51 },
52
53
54 { .dev_type = HV_ND,
55 HV_ND_GUID,
56 .perf_device = true,
57 },
58
59
60 { .dev_type = HV_PCIE,
61 HV_PCIE_GUID,
62 .perf_device = false,
63 },
64
65
66 { .dev_type = HV_FB,
67 HV_SYNTHVID_GUID,
68 .perf_device = false,
69 },
70
71
72 { .dev_type = HV_KBD,
73 HV_KBD_GUID,
74 .perf_device = false,
75 },
76
77
78 { .dev_type = HV_MOUSE,
79 HV_MOUSE_GUID,
80 .perf_device = false,
81 },
82
83
84 { .dev_type = HV_KVP,
85 HV_KVP_GUID,
86 .perf_device = false,
87 },
88
89
90 { .dev_type = HV_TS,
91 HV_TS_GUID,
92 .perf_device = false,
93 },
94
95
96 { .dev_type = HV_HB,
97 HV_HEART_BEAT_GUID,
98 .perf_device = false,
99 },
100
101
102 { .dev_type = HV_SHUTDOWN,
103 HV_SHUTDOWN_GUID,
104 .perf_device = false,
105 },
106
107
108 { .dev_type = HV_FCOPY,
109 HV_FCOPY_GUID,
110 .perf_device = false,
111 },
112
113
114 { .dev_type = HV_BACKUP,
115 HV_VSS_GUID,
116 .perf_device = false,
117 },
118
119
120 { .dev_type = HV_DM,
121 HV_DM_GUID,
122 .perf_device = false,
123 },
124
125
126 { .dev_type = HV_UNKNOWN,
127 .perf_device = false,
128 },
129};
130
131static const struct {
132 guid_t guid;
133} vmbus_unsupported_devs[] = {
134 { HV_AVMA1_GUID },
135 { HV_AVMA2_GUID },
136 { HV_RDV_GUID },
137};
138
139
140
141
142
143static void vmbus_rescind_cleanup(struct vmbus_channel *channel)
144{
145 struct vmbus_channel_msginfo *msginfo;
146 unsigned long flags;
147
148
149 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
150 channel->rescind = true;
151 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
152 msglistentry) {
153
154 if (msginfo->waiting_channel == channel) {
155 complete(&msginfo->waitevent);
156 break;
157 }
158 }
159 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
160}
161
162static bool is_unsupported_vmbus_devs(const guid_t *guid)
163{
164 int i;
165
166 for (i = 0; i < ARRAY_SIZE(vmbus_unsupported_devs); i++)
167 if (guid_equal(guid, &vmbus_unsupported_devs[i].guid))
168 return true;
169 return false;
170}
171
172static u16 hv_get_dev_type(const struct vmbus_channel *channel)
173{
174 const guid_t *guid = &channel->offermsg.offer.if_type;
175 u16 i;
176
177 if (is_hvsock_channel(channel) || is_unsupported_vmbus_devs(guid))
178 return HV_UNKNOWN;
179
180 for (i = HV_IDE; i < HV_UNKNOWN; i++) {
181 if (guid_equal(guid, &vmbus_devs[i].guid))
182 return i;
183 }
184 pr_info("Unknown GUID: %pUl\n", guid);
185 return i;
186}
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp,
205 u8 *buf, const int *fw_version, int fw_vercnt,
206 const int *srv_version, int srv_vercnt,
207 int *nego_fw_version, int *nego_srv_version)
208{
209 int icframe_major, icframe_minor;
210 int icmsg_major, icmsg_minor;
211 int fw_major, fw_minor;
212 int srv_major, srv_minor;
213 int i, j;
214 bool found_match = false;
215 struct icmsg_negotiate *negop;
216
217 icmsghdrp->icmsgsize = 0x10;
218 negop = (struct icmsg_negotiate *)&buf[
219 sizeof(struct vmbuspipe_hdr) +
220 sizeof(struct icmsg_hdr)];
221
222 icframe_major = negop->icframe_vercnt;
223 icframe_minor = 0;
224
225 icmsg_major = negop->icmsg_vercnt;
226 icmsg_minor = 0;
227
228
229
230
231
232
233 for (i = 0; i < fw_vercnt; i++) {
234 fw_major = (fw_version[i] >> 16);
235 fw_minor = (fw_version[i] & 0xFFFF);
236
237 for (j = 0; j < negop->icframe_vercnt; j++) {
238 if ((negop->icversion_data[j].major == fw_major) &&
239 (negop->icversion_data[j].minor == fw_minor)) {
240 icframe_major = negop->icversion_data[j].major;
241 icframe_minor = negop->icversion_data[j].minor;
242 found_match = true;
243 break;
244 }
245 }
246
247 if (found_match)
248 break;
249 }
250
251 if (!found_match)
252 goto fw_error;
253
254 found_match = false;
255
256 for (i = 0; i < srv_vercnt; i++) {
257 srv_major = (srv_version[i] >> 16);
258 srv_minor = (srv_version[i] & 0xFFFF);
259
260 for (j = negop->icframe_vercnt;
261 (j < negop->icframe_vercnt + negop->icmsg_vercnt);
262 j++) {
263
264 if ((negop->icversion_data[j].major == srv_major) &&
265 (negop->icversion_data[j].minor == srv_minor)) {
266
267 icmsg_major = negop->icversion_data[j].major;
268 icmsg_minor = negop->icversion_data[j].minor;
269 found_match = true;
270 break;
271 }
272 }
273
274 if (found_match)
275 break;
276 }
277
278
279
280
281
282
283fw_error:
284 if (!found_match) {
285 negop->icframe_vercnt = 0;
286 negop->icmsg_vercnt = 0;
287 } else {
288 negop->icframe_vercnt = 1;
289 negop->icmsg_vercnt = 1;
290 }
291
292 if (nego_fw_version)
293 *nego_fw_version = (icframe_major << 16) | icframe_minor;
294
295 if (nego_srv_version)
296 *nego_srv_version = (icmsg_major << 16) | icmsg_minor;
297
298 negop->icversion_data[0].major = icframe_major;
299 negop->icversion_data[0].minor = icframe_minor;
300 negop->icversion_data[1].major = icmsg_major;
301 negop->icversion_data[1].minor = icmsg_minor;
302 return found_match;
303}
304
305EXPORT_SYMBOL_GPL(vmbus_prep_negotiate_resp);
306
307
308
309
310static struct vmbus_channel *alloc_channel(void)
311{
312 struct vmbus_channel *channel;
313
314 channel = kzalloc(sizeof(*channel), GFP_ATOMIC);
315 if (!channel)
316 return NULL;
317
318 spin_lock_init(&channel->lock);
319 init_completion(&channel->rescind_event);
320
321 INIT_LIST_HEAD(&channel->sc_list);
322 INIT_LIST_HEAD(&channel->percpu_list);
323
324 tasklet_init(&channel->callback_event,
325 vmbus_on_event, (unsigned long)channel);
326
327 hv_ringbuffer_pre_init(channel);
328
329 return channel;
330}
331
332
333
334
335static void free_channel(struct vmbus_channel *channel)
336{
337 tasklet_kill(&channel->callback_event);
338 vmbus_remove_channel_attr_group(channel);
339
340 kobject_put(&channel->kobj);
341}
342
343static void percpu_channel_enq(void *arg)
344{
345 struct vmbus_channel *channel = arg;
346 struct hv_per_cpu_context *hv_cpu
347 = this_cpu_ptr(hv_context.cpu_context);
348
349 list_add_tail_rcu(&channel->percpu_list, &hv_cpu->chan_list);
350}
351
352static void percpu_channel_deq(void *arg)
353{
354 struct vmbus_channel *channel = arg;
355
356 list_del_rcu(&channel->percpu_list);
357}
358
359
360static void vmbus_release_relid(u32 relid)
361{
362 struct vmbus_channel_relid_released msg;
363 int ret;
364
365 memset(&msg, 0, sizeof(struct vmbus_channel_relid_released));
366 msg.child_relid = relid;
367 msg.header.msgtype = CHANNELMSG_RELID_RELEASED;
368 ret = vmbus_post_msg(&msg, sizeof(struct vmbus_channel_relid_released),
369 true);
370
371 trace_vmbus_release_relid(&msg, ret);
372}
373
374void hv_process_channel_removal(struct vmbus_channel *channel)
375{
376 struct vmbus_channel *primary_channel;
377 unsigned long flags;
378
379 BUG_ON(!mutex_is_locked(&vmbus_connection.channel_mutex));
380 BUG_ON(!channel->rescind);
381
382 if (channel->target_cpu != get_cpu()) {
383 put_cpu();
384 smp_call_function_single(channel->target_cpu,
385 percpu_channel_deq, channel, true);
386 } else {
387 percpu_channel_deq(channel);
388 put_cpu();
389 }
390
391 if (channel->primary_channel == NULL) {
392 list_del(&channel->listentry);
393
394 primary_channel = channel;
395 } else {
396 primary_channel = channel->primary_channel;
397 spin_lock_irqsave(&primary_channel->lock, flags);
398 list_del(&channel->sc_list);
399 spin_unlock_irqrestore(&primary_channel->lock, flags);
400 }
401
402
403
404
405
406 if (channel->affinity_policy == HV_LOCALIZED)
407 cpumask_clear_cpu(channel->target_cpu,
408 &primary_channel->alloced_cpus_in_node);
409
410
411
412
413
414
415
416
417 if (channel->offermsg.child_relid != INVALID_RELID)
418 vmbus_release_relid(channel->offermsg.child_relid);
419
420 free_channel(channel);
421}
422
423void vmbus_free_channels(void)
424{
425 struct vmbus_channel *channel, *tmp;
426
427 list_for_each_entry_safe(channel, tmp, &vmbus_connection.chn_list,
428 listentry) {
429
430 channel->rescind = true;
431
432 vmbus_device_unregister(channel->device_obj);
433 }
434}
435
436
437static void vmbus_add_channel_work(struct work_struct *work)
438{
439 struct vmbus_channel *newchannel =
440 container_of(work, struct vmbus_channel, add_channel_work);
441 struct vmbus_channel *primary_channel = newchannel->primary_channel;
442 unsigned long flags;
443 u16 dev_type;
444 int ret;
445
446 dev_type = hv_get_dev_type(newchannel);
447
448 init_vp_index(newchannel, dev_type);
449
450 if (newchannel->target_cpu != get_cpu()) {
451 put_cpu();
452 smp_call_function_single(newchannel->target_cpu,
453 percpu_channel_enq,
454 newchannel, true);
455 } else {
456 percpu_channel_enq(newchannel);
457 put_cpu();
458 }
459
460
461
462
463
464
465 newchannel->state = CHANNEL_OPEN_STATE;
466
467 if (primary_channel != NULL) {
468
469 struct hv_device *dev = primary_channel->device_obj;
470
471 if (vmbus_add_channel_kobj(dev, newchannel))
472 goto err_deq_chan;
473
474 if (primary_channel->sc_creation_callback != NULL)
475 primary_channel->sc_creation_callback(newchannel);
476
477 newchannel->probe_done = true;
478 return;
479 }
480
481
482
483
484 newchannel->device_obj = vmbus_device_create(
485 &newchannel->offermsg.offer.if_type,
486 &newchannel->offermsg.offer.if_instance,
487 newchannel);
488 if (!newchannel->device_obj)
489 goto err_deq_chan;
490
491 newchannel->device_obj->device_id = dev_type;
492
493
494
495
496
497 ret = vmbus_device_register(newchannel->device_obj);
498
499 if (ret != 0) {
500 pr_err("unable to add child device object (relid %d)\n",
501 newchannel->offermsg.child_relid);
502 kfree(newchannel->device_obj);
503 goto err_deq_chan;
504 }
505
506 newchannel->probe_done = true;
507 return;
508
509err_deq_chan:
510 mutex_lock(&vmbus_connection.channel_mutex);
511
512
513
514
515
516 newchannel->probe_done = true;
517
518 if (primary_channel == NULL) {
519 list_del(&newchannel->listentry);
520 } else {
521 spin_lock_irqsave(&primary_channel->lock, flags);
522 list_del(&newchannel->sc_list);
523 spin_unlock_irqrestore(&primary_channel->lock, flags);
524 }
525
526 mutex_unlock(&vmbus_connection.channel_mutex);
527
528 if (newchannel->target_cpu != get_cpu()) {
529 put_cpu();
530 smp_call_function_single(newchannel->target_cpu,
531 percpu_channel_deq,
532 newchannel, true);
533 } else {
534 percpu_channel_deq(newchannel);
535 put_cpu();
536 }
537
538 vmbus_release_relid(newchannel->offermsg.child_relid);
539
540 free_channel(newchannel);
541}
542
543
544
545
546
547static void vmbus_process_offer(struct vmbus_channel *newchannel)
548{
549 struct vmbus_channel *channel;
550 struct workqueue_struct *wq;
551 unsigned long flags;
552 bool fnew = true;
553
554 mutex_lock(&vmbus_connection.channel_mutex);
555
556
557 if (is_hvsock_channel(newchannel) || is_sub_channel(newchannel))
558 atomic_inc(&vmbus_connection.nr_chan_close_on_suspend);
559
560
561
562
563
564 atomic_dec(&vmbus_connection.offer_in_progress);
565
566 list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
567 if (guid_equal(&channel->offermsg.offer.if_type,
568 &newchannel->offermsg.offer.if_type) &&
569 guid_equal(&channel->offermsg.offer.if_instance,
570 &newchannel->offermsg.offer.if_instance)) {
571 fnew = false;
572 break;
573 }
574 }
575
576 if (fnew)
577 list_add_tail(&newchannel->listentry,
578 &vmbus_connection.chn_list);
579 else {
580
581
582
583 if (newchannel->offermsg.offer.sub_channel_index == 0) {
584 mutex_unlock(&vmbus_connection.channel_mutex);
585
586
587
588
589 kfree(newchannel);
590 WARN_ON_ONCE(1);
591 return;
592 }
593
594
595
596 newchannel->primary_channel = channel;
597 spin_lock_irqsave(&channel->lock, flags);
598 list_add_tail(&newchannel->sc_list, &channel->sc_list);
599 spin_unlock_irqrestore(&channel->lock, flags);
600 }
601
602 mutex_unlock(&vmbus_connection.channel_mutex);
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625 INIT_WORK(&newchannel->add_channel_work, vmbus_add_channel_work);
626 wq = fnew ? vmbus_connection.handle_primary_chan_wq :
627 vmbus_connection.handle_sub_chan_wq;
628 queue_work(wq, &newchannel->add_channel_work);
629}
630
631
632
633
634static int next_numa_node_id;
635
636
637
638
639
640
641static DEFINE_SPINLOCK(bind_channel_to_cpu_lock);
642
643
644
645
646
647
648
649
650
651
652static void init_vp_index(struct vmbus_channel *channel, u16 dev_type)
653{
654 u32 cur_cpu;
655 bool perf_chn = vmbus_devs[dev_type].perf_device;
656 struct vmbus_channel *primary = channel->primary_channel;
657 int next_node;
658 cpumask_var_t available_mask;
659 struct cpumask *alloced_mask;
660
661 if ((vmbus_proto_version == VERSION_WS2008) ||
662 (vmbus_proto_version == VERSION_WIN7) || (!perf_chn) ||
663 !alloc_cpumask_var(&available_mask, GFP_KERNEL)) {
664
665
666
667
668
669
670
671 channel->numa_node = 0;
672 channel->target_cpu = 0;
673 channel->target_vp = hv_cpu_number_to_vp_number(0);
674 return;
675 }
676
677 spin_lock(&bind_channel_to_cpu_lock);
678
679
680
681
682
683
684 if ((channel->affinity_policy == HV_BALANCED) || (!primary)) {
685 while (true) {
686 next_node = next_numa_node_id++;
687 if (next_node == nr_node_ids) {
688 next_node = next_numa_node_id = 0;
689 continue;
690 }
691 if (cpumask_empty(cpumask_of_node(next_node)))
692 continue;
693 break;
694 }
695 channel->numa_node = next_node;
696 primary = channel;
697 }
698 alloced_mask = &hv_context.hv_numa_map[primary->numa_node];
699
700 if (cpumask_weight(alloced_mask) ==
701 cpumask_weight(cpumask_of_node(primary->numa_node))) {
702
703
704
705
706 cpumask_clear(alloced_mask);
707 }
708
709 cpumask_xor(available_mask, alloced_mask,
710 cpumask_of_node(primary->numa_node));
711
712 cur_cpu = -1;
713
714 if (primary->affinity_policy == HV_LOCALIZED) {
715
716
717
718
719
720
721 if (cpumask_equal(&primary->alloced_cpus_in_node,
722 cpumask_of_node(primary->numa_node)))
723 cpumask_clear(&primary->alloced_cpus_in_node);
724 }
725
726 while (true) {
727 cur_cpu = cpumask_next(cur_cpu, available_mask);
728 if (cur_cpu >= nr_cpu_ids) {
729 cur_cpu = -1;
730 cpumask_copy(available_mask,
731 cpumask_of_node(primary->numa_node));
732 continue;
733 }
734
735 if (primary->affinity_policy == HV_LOCALIZED) {
736
737
738
739
740
741
742
743
744
745 if (!cpumask_test_cpu(cur_cpu,
746 &primary->alloced_cpus_in_node)) {
747 cpumask_set_cpu(cur_cpu,
748 &primary->alloced_cpus_in_node);
749 cpumask_set_cpu(cur_cpu, alloced_mask);
750 break;
751 }
752 } else {
753 cpumask_set_cpu(cur_cpu, alloced_mask);
754 break;
755 }
756 }
757
758 channel->target_cpu = cur_cpu;
759 channel->target_vp = hv_cpu_number_to_vp_number(cur_cpu);
760
761 spin_unlock(&bind_channel_to_cpu_lock);
762
763 free_cpumask_var(available_mask);
764}
765
766static void vmbus_wait_for_unload(void)
767{
768 int cpu;
769 void *page_addr;
770 struct hv_message *msg;
771 struct vmbus_channel_message_header *hdr;
772 u32 message_type;
773
774
775
776
777
778
779
780
781
782
783 while (1) {
784 if (completion_done(&vmbus_connection.unload_event))
785 break;
786
787 for_each_online_cpu(cpu) {
788 struct hv_per_cpu_context *hv_cpu
789 = per_cpu_ptr(hv_context.cpu_context, cpu);
790
791 page_addr = hv_cpu->synic_message_page;
792 msg = (struct hv_message *)page_addr
793 + VMBUS_MESSAGE_SINT;
794
795 message_type = READ_ONCE(msg->header.message_type);
796 if (message_type == HVMSG_NONE)
797 continue;
798
799 hdr = (struct vmbus_channel_message_header *)
800 msg->u.payload;
801
802 if (hdr->msgtype == CHANNELMSG_UNLOAD_RESPONSE)
803 complete(&vmbus_connection.unload_event);
804
805 vmbus_signal_eom(msg, message_type);
806 }
807
808 mdelay(10);
809 }
810
811
812
813
814
815
816 for_each_online_cpu(cpu) {
817 struct hv_per_cpu_context *hv_cpu
818 = per_cpu_ptr(hv_context.cpu_context, cpu);
819
820 page_addr = hv_cpu->synic_message_page;
821 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
822 msg->header.message_type = HVMSG_NONE;
823 }
824}
825
826
827
828
829static void vmbus_unload_response(struct vmbus_channel_message_header *hdr)
830{
831
832
833
834
835 complete(&vmbus_connection.unload_event);
836}
837
838void vmbus_initiate_unload(bool crash)
839{
840 struct vmbus_channel_message_header hdr;
841
842
843 if (vmbus_proto_version < VERSION_WIN8_1)
844 return;
845
846 init_completion(&vmbus_connection.unload_event);
847 memset(&hdr, 0, sizeof(struct vmbus_channel_message_header));
848 hdr.msgtype = CHANNELMSG_UNLOAD;
849 vmbus_post_msg(&hdr, sizeof(struct vmbus_channel_message_header),
850 !crash);
851
852
853
854
855
856 if (!crash)
857 wait_for_completion(&vmbus_connection.unload_event);
858 else
859 vmbus_wait_for_unload();
860}
861
862static void check_ready_for_resume_event(void)
863{
864
865
866
867
868 if (atomic_dec_and_test(&vmbus_connection.nr_chan_fixup_on_resume))
869 complete(&vmbus_connection.ready_for_resume_event);
870}
871
872static void vmbus_setup_channel_state(struct vmbus_channel *channel,
873 struct vmbus_channel_offer_channel *offer)
874{
875
876
877
878 channel->sig_event = VMBUS_EVENT_CONNECTION_ID;
879
880 if (vmbus_proto_version != VERSION_WS2008) {
881 channel->is_dedicated_interrupt =
882 (offer->is_dedicated_interrupt != 0);
883 channel->sig_event = offer->connection_id;
884 }
885
886 memcpy(&channel->offermsg, offer,
887 sizeof(struct vmbus_channel_offer_channel));
888 channel->monitor_grp = (u8)offer->monitorid / 32;
889 channel->monitor_bit = (u8)offer->monitorid % 32;
890}
891
892
893
894
895
896static struct vmbus_channel *
897find_primary_channel_by_offer(const struct vmbus_channel_offer_channel *offer)
898{
899 struct vmbus_channel *channel = NULL, *iter;
900 const guid_t *inst1, *inst2;
901
902
903 if (offer->offer.sub_channel_index != 0)
904 return NULL;
905
906 mutex_lock(&vmbus_connection.channel_mutex);
907
908 list_for_each_entry(iter, &vmbus_connection.chn_list, listentry) {
909 inst1 = &iter->offermsg.offer.if_instance;
910 inst2 = &offer->offer.if_instance;
911
912 if (guid_equal(inst1, inst2)) {
913 channel = iter;
914 break;
915 }
916 }
917
918 mutex_unlock(&vmbus_connection.channel_mutex);
919
920 return channel;
921}
922
923
924
925
926
927static void vmbus_onoffer(struct vmbus_channel_message_header *hdr)
928{
929 struct vmbus_channel_offer_channel *offer;
930 struct vmbus_channel *oldchannel, *newchannel;
931 size_t offer_sz;
932
933 offer = (struct vmbus_channel_offer_channel *)hdr;
934
935 trace_vmbus_onoffer(offer);
936
937 oldchannel = find_primary_channel_by_offer(offer);
938
939 if (oldchannel != NULL) {
940 atomic_dec(&vmbus_connection.offer_in_progress);
941
942
943
944
945
946
947
948
949 WARN_ON(oldchannel->offermsg.child_relid != INVALID_RELID);
950
951 oldchannel->offermsg.child_relid = offer->child_relid;
952
953 offer_sz = sizeof(*offer);
954 if (memcmp(offer, &oldchannel->offermsg, offer_sz) == 0) {
955 check_ready_for_resume_event();
956 return;
957 }
958
959
960
961
962
963
964
965 pr_debug("vmbus offer changed: relid=%d\n",
966 offer->child_relid);
967
968 print_hex_dump_debug("Old vmbus offer: ", DUMP_PREFIX_OFFSET,
969 16, 4, &oldchannel->offermsg, offer_sz,
970 false);
971 print_hex_dump_debug("New vmbus offer: ", DUMP_PREFIX_OFFSET,
972 16, 4, offer, offer_sz, false);
973
974
975 vmbus_setup_channel_state(oldchannel, offer);
976
977 check_ready_for_resume_event();
978
979 return;
980 }
981
982
983 newchannel = alloc_channel();
984 if (!newchannel) {
985 vmbus_release_relid(offer->child_relid);
986 atomic_dec(&vmbus_connection.offer_in_progress);
987 pr_err("Unable to allocate channel object\n");
988 return;
989 }
990
991 vmbus_setup_channel_state(newchannel, offer);
992
993 vmbus_process_offer(newchannel);
994}
995
996static void check_ready_for_suspend_event(void)
997{
998
999
1000
1001
1002 if (atomic_dec_and_test(&vmbus_connection.nr_chan_close_on_suspend))
1003 complete(&vmbus_connection.ready_for_suspend_event);
1004}
1005
1006
1007
1008
1009
1010
1011static void vmbus_onoffer_rescind(struct vmbus_channel_message_header *hdr)
1012{
1013 struct vmbus_channel_rescind_offer *rescind;
1014 struct vmbus_channel *channel;
1015 struct device *dev;
1016 bool clean_up_chan_for_suspend;
1017
1018 rescind = (struct vmbus_channel_rescind_offer *)hdr;
1019
1020 trace_vmbus_onoffer_rescind(rescind);
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035 while (atomic_read(&vmbus_connection.offer_in_progress) != 0) {
1036
1037
1038
1039
1040 msleep(1);
1041 }
1042
1043 mutex_lock(&vmbus_connection.channel_mutex);
1044 channel = relid2channel(rescind->child_relid);
1045 mutex_unlock(&vmbus_connection.channel_mutex);
1046
1047 if (channel == NULL) {
1048
1049
1050
1051
1052
1053 return;
1054 }
1055
1056 clean_up_chan_for_suspend = is_hvsock_channel(channel) ||
1057 is_sub_channel(channel);
1058
1059
1060
1061
1062 vmbus_reset_channel_cb(channel);
1063
1064
1065
1066
1067 vmbus_rescind_cleanup(channel);
1068 while (READ_ONCE(channel->probe_done) == false) {
1069
1070
1071
1072
1073 msleep(1);
1074 }
1075
1076
1077
1078
1079
1080 if (channel->device_obj) {
1081 if (channel->chn_rescind_callback) {
1082 channel->chn_rescind_callback(channel);
1083
1084 if (clean_up_chan_for_suspend)
1085 check_ready_for_suspend_event();
1086
1087 return;
1088 }
1089
1090
1091
1092
1093 dev = get_device(&channel->device_obj->device);
1094 if (dev) {
1095 vmbus_device_unregister(channel->device_obj);
1096 put_device(dev);
1097 }
1098 }
1099 if (channel->primary_channel != NULL) {
1100
1101
1102
1103
1104
1105
1106
1107 mutex_lock(&vmbus_connection.channel_mutex);
1108 if (channel->state == CHANNEL_OPEN_STATE) {
1109
1110
1111
1112
1113 hv_process_channel_removal(channel);
1114 } else {
1115 complete(&channel->rescind_event);
1116 }
1117 mutex_unlock(&vmbus_connection.channel_mutex);
1118 }
1119
1120
1121
1122 if (clean_up_chan_for_suspend)
1123 check_ready_for_suspend_event();
1124}
1125
1126void vmbus_hvsock_device_unregister(struct vmbus_channel *channel)
1127{
1128 BUG_ON(!is_hvsock_channel(channel));
1129
1130
1131 while (!READ_ONCE(channel->probe_done) || !READ_ONCE(channel->rescind))
1132 msleep(1);
1133
1134 vmbus_device_unregister(channel->device_obj);
1135}
1136EXPORT_SYMBOL_GPL(vmbus_hvsock_device_unregister);
1137
1138
1139
1140
1141
1142
1143
1144
1145static void vmbus_onoffers_delivered(
1146 struct vmbus_channel_message_header *hdr)
1147{
1148}
1149
1150
1151
1152
1153
1154
1155
1156
1157static void vmbus_onopen_result(struct vmbus_channel_message_header *hdr)
1158{
1159 struct vmbus_channel_open_result *result;
1160 struct vmbus_channel_msginfo *msginfo;
1161 struct vmbus_channel_message_header *requestheader;
1162 struct vmbus_channel_open_channel *openmsg;
1163 unsigned long flags;
1164
1165 result = (struct vmbus_channel_open_result *)hdr;
1166
1167 trace_vmbus_onopen_result(result);
1168
1169
1170
1171
1172 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
1173
1174 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
1175 msglistentry) {
1176 requestheader =
1177 (struct vmbus_channel_message_header *)msginfo->msg;
1178
1179 if (requestheader->msgtype == CHANNELMSG_OPENCHANNEL) {
1180 openmsg =
1181 (struct vmbus_channel_open_channel *)msginfo->msg;
1182 if (openmsg->child_relid == result->child_relid &&
1183 openmsg->openid == result->openid) {
1184 memcpy(&msginfo->response.open_result,
1185 result,
1186 sizeof(
1187 struct vmbus_channel_open_result));
1188 complete(&msginfo->waitevent);
1189 break;
1190 }
1191 }
1192 }
1193 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
1194}
1195
1196
1197
1198
1199
1200
1201
1202
1203static void vmbus_ongpadl_created(struct vmbus_channel_message_header *hdr)
1204{
1205 struct vmbus_channel_gpadl_created *gpadlcreated;
1206 struct vmbus_channel_msginfo *msginfo;
1207 struct vmbus_channel_message_header *requestheader;
1208 struct vmbus_channel_gpadl_header *gpadlheader;
1209 unsigned long flags;
1210
1211 gpadlcreated = (struct vmbus_channel_gpadl_created *)hdr;
1212
1213 trace_vmbus_ongpadl_created(gpadlcreated);
1214
1215
1216
1217
1218
1219 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
1220
1221 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
1222 msglistentry) {
1223 requestheader =
1224 (struct vmbus_channel_message_header *)msginfo->msg;
1225
1226 if (requestheader->msgtype == CHANNELMSG_GPADL_HEADER) {
1227 gpadlheader =
1228 (struct vmbus_channel_gpadl_header *)requestheader;
1229
1230 if ((gpadlcreated->child_relid ==
1231 gpadlheader->child_relid) &&
1232 (gpadlcreated->gpadl == gpadlheader->gpadl)) {
1233 memcpy(&msginfo->response.gpadl_created,
1234 gpadlcreated,
1235 sizeof(
1236 struct vmbus_channel_gpadl_created));
1237 complete(&msginfo->waitevent);
1238 break;
1239 }
1240 }
1241 }
1242 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
1243}
1244
1245
1246
1247
1248
1249
1250
1251
1252static void vmbus_ongpadl_torndown(
1253 struct vmbus_channel_message_header *hdr)
1254{
1255 struct vmbus_channel_gpadl_torndown *gpadl_torndown;
1256 struct vmbus_channel_msginfo *msginfo;
1257 struct vmbus_channel_message_header *requestheader;
1258 struct vmbus_channel_gpadl_teardown *gpadl_teardown;
1259 unsigned long flags;
1260
1261 gpadl_torndown = (struct vmbus_channel_gpadl_torndown *)hdr;
1262
1263 trace_vmbus_ongpadl_torndown(gpadl_torndown);
1264
1265
1266
1267
1268 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
1269
1270 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
1271 msglistentry) {
1272 requestheader =
1273 (struct vmbus_channel_message_header *)msginfo->msg;
1274
1275 if (requestheader->msgtype == CHANNELMSG_GPADL_TEARDOWN) {
1276 gpadl_teardown =
1277 (struct vmbus_channel_gpadl_teardown *)requestheader;
1278
1279 if (gpadl_torndown->gpadl == gpadl_teardown->gpadl) {
1280 memcpy(&msginfo->response.gpadl_torndown,
1281 gpadl_torndown,
1282 sizeof(
1283 struct vmbus_channel_gpadl_torndown));
1284 complete(&msginfo->waitevent);
1285 break;
1286 }
1287 }
1288 }
1289 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
1290}
1291
1292
1293
1294
1295
1296
1297
1298
1299static void vmbus_onversion_response(
1300 struct vmbus_channel_message_header *hdr)
1301{
1302 struct vmbus_channel_msginfo *msginfo;
1303 struct vmbus_channel_message_header *requestheader;
1304 struct vmbus_channel_version_response *version_response;
1305 unsigned long flags;
1306
1307 version_response = (struct vmbus_channel_version_response *)hdr;
1308
1309 trace_vmbus_onversion_response(version_response);
1310
1311 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
1312
1313 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
1314 msglistentry) {
1315 requestheader =
1316 (struct vmbus_channel_message_header *)msginfo->msg;
1317
1318 if (requestheader->msgtype ==
1319 CHANNELMSG_INITIATE_CONTACT) {
1320 memcpy(&msginfo->response.version_response,
1321 version_response,
1322 sizeof(struct vmbus_channel_version_response));
1323 complete(&msginfo->waitevent);
1324 }
1325 }
1326 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
1327}
1328
1329
1330const struct vmbus_channel_message_table_entry
1331channel_message_table[CHANNELMSG_COUNT] = {
1332 { CHANNELMSG_INVALID, 0, NULL },
1333 { CHANNELMSG_OFFERCHANNEL, 0, vmbus_onoffer },
1334 { CHANNELMSG_RESCIND_CHANNELOFFER, 0, vmbus_onoffer_rescind },
1335 { CHANNELMSG_REQUESTOFFERS, 0, NULL },
1336 { CHANNELMSG_ALLOFFERS_DELIVERED, 1, vmbus_onoffers_delivered },
1337 { CHANNELMSG_OPENCHANNEL, 0, NULL },
1338 { CHANNELMSG_OPENCHANNEL_RESULT, 1, vmbus_onopen_result },
1339 { CHANNELMSG_CLOSECHANNEL, 0, NULL },
1340 { CHANNELMSG_GPADL_HEADER, 0, NULL },
1341 { CHANNELMSG_GPADL_BODY, 0, NULL },
1342 { CHANNELMSG_GPADL_CREATED, 1, vmbus_ongpadl_created },
1343 { CHANNELMSG_GPADL_TEARDOWN, 0, NULL },
1344 { CHANNELMSG_GPADL_TORNDOWN, 1, vmbus_ongpadl_torndown },
1345 { CHANNELMSG_RELID_RELEASED, 0, NULL },
1346 { CHANNELMSG_INITIATE_CONTACT, 0, NULL },
1347 { CHANNELMSG_VERSION_RESPONSE, 1, vmbus_onversion_response },
1348 { CHANNELMSG_UNLOAD, 0, NULL },
1349 { CHANNELMSG_UNLOAD_RESPONSE, 1, vmbus_unload_response },
1350 { CHANNELMSG_18, 0, NULL },
1351 { CHANNELMSG_19, 0, NULL },
1352 { CHANNELMSG_20, 0, NULL },
1353 { CHANNELMSG_TL_CONNECT_REQUEST, 0, NULL },
1354};
1355
1356
1357
1358
1359
1360
1361void vmbus_onmessage(void *context)
1362{
1363 struct hv_message *msg = context;
1364 struct vmbus_channel_message_header *hdr;
1365 int size;
1366
1367 hdr = (struct vmbus_channel_message_header *)msg->u.payload;
1368 size = msg->header.payload_size;
1369
1370 trace_vmbus_on_message(hdr);
1371
1372 if (hdr->msgtype >= CHANNELMSG_COUNT) {
1373 pr_err("Received invalid channel message type %d size %d\n",
1374 hdr->msgtype, size);
1375 print_hex_dump_bytes("", DUMP_PREFIX_NONE,
1376 (unsigned char *)msg->u.payload, size);
1377 return;
1378 }
1379
1380 if (channel_message_table[hdr->msgtype].message_handler)
1381 channel_message_table[hdr->msgtype].message_handler(hdr);
1382 else
1383 pr_err("Unhandled channel message type %d\n", hdr->msgtype);
1384}
1385
1386
1387
1388
1389int vmbus_request_offers(void)
1390{
1391 struct vmbus_channel_message_header *msg;
1392 struct vmbus_channel_msginfo *msginfo;
1393 int ret;
1394
1395 msginfo = kmalloc(sizeof(*msginfo) +
1396 sizeof(struct vmbus_channel_message_header),
1397 GFP_KERNEL);
1398 if (!msginfo)
1399 return -ENOMEM;
1400
1401 msg = (struct vmbus_channel_message_header *)msginfo->msg;
1402
1403 msg->msgtype = CHANNELMSG_REQUESTOFFERS;
1404
1405 ret = vmbus_post_msg(msg, sizeof(struct vmbus_channel_message_header),
1406 true);
1407
1408 trace_vmbus_request_offers(ret);
1409
1410 if (ret != 0) {
1411 pr_err("Unable to request offers - %d\n", ret);
1412
1413 goto cleanup;
1414 }
1415
1416cleanup:
1417 kfree(msginfo);
1418
1419 return ret;
1420}
1421
1422static void invoke_sc_cb(struct vmbus_channel *primary_channel)
1423{
1424 struct list_head *cur, *tmp;
1425 struct vmbus_channel *cur_channel;
1426
1427 if (primary_channel->sc_creation_callback == NULL)
1428 return;
1429
1430 list_for_each_safe(cur, tmp, &primary_channel->sc_list) {
1431 cur_channel = list_entry(cur, struct vmbus_channel, sc_list);
1432
1433 primary_channel->sc_creation_callback(cur_channel);
1434 }
1435}
1436
1437void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel,
1438 void (*sc_cr_cb)(struct vmbus_channel *new_sc))
1439{
1440 primary_channel->sc_creation_callback = sc_cr_cb;
1441}
1442EXPORT_SYMBOL_GPL(vmbus_set_sc_create_callback);
1443
1444bool vmbus_are_subchannels_present(struct vmbus_channel *primary)
1445{
1446 bool ret;
1447
1448 ret = !list_empty(&primary->sc_list);
1449
1450 if (ret) {
1451
1452
1453
1454
1455
1456 invoke_sc_cb(primary);
1457 }
1458
1459 return ret;
1460}
1461EXPORT_SYMBOL_GPL(vmbus_are_subchannels_present);
1462
1463void vmbus_set_chn_rescind_callback(struct vmbus_channel *channel,
1464 void (*chn_rescind_cb)(struct vmbus_channel *))
1465{
1466 channel->chn_rescind_callback = chn_rescind_cb;
1467}
1468EXPORT_SYMBOL_GPL(vmbus_set_chn_rescind_callback);
1469