1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24
25#include <linux/init.h>
26#include <linux/module.h>
27#include <linux/device.h>
28#include <linux/interrupt.h>
29#include <linux/sysctl.h>
30#include <linux/slab.h>
31#include <linux/acpi.h>
32#include <linux/completion.h>
33#include <linux/hyperv.h>
34#include <linux/kernel_stat.h>
35#include <linux/clockchips.h>
36#include <linux/cpu.h>
37#include <asm/hyperv.h>
38#include <asm/hypervisor.h>
39#include <asm/mshyperv.h>
40#include <linux/notifier.h>
41#include <linux/ptrace.h>
42#include "hyperv_vmbus.h"
43
44static struct acpi_device *hv_acpi_dev;
45
46static struct tasklet_struct msg_dpc;
47static struct completion probe_event;
48static int irq;
49
50
51static int hyperv_panic_event(struct notifier_block *nb,
52 unsigned long event, void *ptr)
53{
54 struct pt_regs *regs;
55
56 regs = current_pt_regs();
57
58 wrmsrl(HV_X64_MSR_CRASH_P0, regs->ip);
59 wrmsrl(HV_X64_MSR_CRASH_P1, regs->ax);
60 wrmsrl(HV_X64_MSR_CRASH_P2, regs->bx);
61 wrmsrl(HV_X64_MSR_CRASH_P3, regs->cx);
62 wrmsrl(HV_X64_MSR_CRASH_P4, regs->dx);
63
64
65
66
67 wrmsrl(HV_X64_MSR_CRASH_CTL, HV_CRASH_CTL_CRASH_NOTIFY);
68 return NOTIFY_DONE;
69}
70
71static struct notifier_block hyperv_panic_block = {
72 .notifier_call = hyperv_panic_event,
73};
74
75struct resource hyperv_mmio = {
76 .name = "hyperv mmio",
77 .flags = IORESOURCE_MEM,
78};
79EXPORT_SYMBOL_GPL(hyperv_mmio);
80
81static int vmbus_exists(void)
82{
83 if (hv_acpi_dev == NULL)
84 return -ENODEV;
85
86 return 0;
87}
88
89#define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
90static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
91{
92 int i;
93 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
94 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
95}
96
97static u8 channel_monitor_group(struct vmbus_channel *channel)
98{
99 return (u8)channel->offermsg.monitorid / 32;
100}
101
102static u8 channel_monitor_offset(struct vmbus_channel *channel)
103{
104 return (u8)channel->offermsg.monitorid % 32;
105}
106
107static u32 channel_pending(struct vmbus_channel *channel,
108 struct hv_monitor_page *monitor_page)
109{
110 u8 monitor_group = channel_monitor_group(channel);
111 return monitor_page->trigger_group[monitor_group].pending;
112}
113
114static u32 channel_latency(struct vmbus_channel *channel,
115 struct hv_monitor_page *monitor_page)
116{
117 u8 monitor_group = channel_monitor_group(channel);
118 u8 monitor_offset = channel_monitor_offset(channel);
119 return monitor_page->latency[monitor_group][monitor_offset];
120}
121
122static u32 channel_conn_id(struct vmbus_channel *channel,
123 struct hv_monitor_page *monitor_page)
124{
125 u8 monitor_group = channel_monitor_group(channel);
126 u8 monitor_offset = channel_monitor_offset(channel);
127 return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
128}
129
130static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
131 char *buf)
132{
133 struct hv_device *hv_dev = device_to_hv_device(dev);
134
135 if (!hv_dev->channel)
136 return -ENODEV;
137 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
138}
139static DEVICE_ATTR_RO(id);
140
141static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
142 char *buf)
143{
144 struct hv_device *hv_dev = device_to_hv_device(dev);
145
146 if (!hv_dev->channel)
147 return -ENODEV;
148 return sprintf(buf, "%d\n", hv_dev->channel->state);
149}
150static DEVICE_ATTR_RO(state);
151
152static ssize_t monitor_id_show(struct device *dev,
153 struct device_attribute *dev_attr, char *buf)
154{
155 struct hv_device *hv_dev = device_to_hv_device(dev);
156
157 if (!hv_dev->channel)
158 return -ENODEV;
159 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
160}
161static DEVICE_ATTR_RO(monitor_id);
162
163static ssize_t class_id_show(struct device *dev,
164 struct device_attribute *dev_attr, char *buf)
165{
166 struct hv_device *hv_dev = device_to_hv_device(dev);
167
168 if (!hv_dev->channel)
169 return -ENODEV;
170 return sprintf(buf, "{%pUl}\n",
171 hv_dev->channel->offermsg.offer.if_type.b);
172}
173static DEVICE_ATTR_RO(class_id);
174
175static ssize_t device_id_show(struct device *dev,
176 struct device_attribute *dev_attr, char *buf)
177{
178 struct hv_device *hv_dev = device_to_hv_device(dev);
179
180 if (!hv_dev->channel)
181 return -ENODEV;
182 return sprintf(buf, "{%pUl}\n",
183 hv_dev->channel->offermsg.offer.if_instance.b);
184}
185static DEVICE_ATTR_RO(device_id);
186
187static ssize_t modalias_show(struct device *dev,
188 struct device_attribute *dev_attr, char *buf)
189{
190 struct hv_device *hv_dev = device_to_hv_device(dev);
191 char alias_name[VMBUS_ALIAS_LEN + 1];
192
193 print_alias_name(hv_dev, alias_name);
194 return sprintf(buf, "vmbus:%s\n", alias_name);
195}
196static DEVICE_ATTR_RO(modalias);
197
198static ssize_t server_monitor_pending_show(struct device *dev,
199 struct device_attribute *dev_attr,
200 char *buf)
201{
202 struct hv_device *hv_dev = device_to_hv_device(dev);
203
204 if (!hv_dev->channel)
205 return -ENODEV;
206 return sprintf(buf, "%d\n",
207 channel_pending(hv_dev->channel,
208 vmbus_connection.monitor_pages[1]));
209}
210static DEVICE_ATTR_RO(server_monitor_pending);
211
212static ssize_t client_monitor_pending_show(struct device *dev,
213 struct device_attribute *dev_attr,
214 char *buf)
215{
216 struct hv_device *hv_dev = device_to_hv_device(dev);
217
218 if (!hv_dev->channel)
219 return -ENODEV;
220 return sprintf(buf, "%d\n",
221 channel_pending(hv_dev->channel,
222 vmbus_connection.monitor_pages[1]));
223}
224static DEVICE_ATTR_RO(client_monitor_pending);
225
226static ssize_t server_monitor_latency_show(struct device *dev,
227 struct device_attribute *dev_attr,
228 char *buf)
229{
230 struct hv_device *hv_dev = device_to_hv_device(dev);
231
232 if (!hv_dev->channel)
233 return -ENODEV;
234 return sprintf(buf, "%d\n",
235 channel_latency(hv_dev->channel,
236 vmbus_connection.monitor_pages[0]));
237}
238static DEVICE_ATTR_RO(server_monitor_latency);
239
240static ssize_t client_monitor_latency_show(struct device *dev,
241 struct device_attribute *dev_attr,
242 char *buf)
243{
244 struct hv_device *hv_dev = device_to_hv_device(dev);
245
246 if (!hv_dev->channel)
247 return -ENODEV;
248 return sprintf(buf, "%d\n",
249 channel_latency(hv_dev->channel,
250 vmbus_connection.monitor_pages[1]));
251}
252static DEVICE_ATTR_RO(client_monitor_latency);
253
254static ssize_t server_monitor_conn_id_show(struct device *dev,
255 struct device_attribute *dev_attr,
256 char *buf)
257{
258 struct hv_device *hv_dev = device_to_hv_device(dev);
259
260 if (!hv_dev->channel)
261 return -ENODEV;
262 return sprintf(buf, "%d\n",
263 channel_conn_id(hv_dev->channel,
264 vmbus_connection.monitor_pages[0]));
265}
266static DEVICE_ATTR_RO(server_monitor_conn_id);
267
268static ssize_t client_monitor_conn_id_show(struct device *dev,
269 struct device_attribute *dev_attr,
270 char *buf)
271{
272 struct hv_device *hv_dev = device_to_hv_device(dev);
273
274 if (!hv_dev->channel)
275 return -ENODEV;
276 return sprintf(buf, "%d\n",
277 channel_conn_id(hv_dev->channel,
278 vmbus_connection.monitor_pages[1]));
279}
280static DEVICE_ATTR_RO(client_monitor_conn_id);
281
282static ssize_t out_intr_mask_show(struct device *dev,
283 struct device_attribute *dev_attr, char *buf)
284{
285 struct hv_device *hv_dev = device_to_hv_device(dev);
286 struct hv_ring_buffer_debug_info outbound;
287
288 if (!hv_dev->channel)
289 return -ENODEV;
290 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
291 return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
292}
293static DEVICE_ATTR_RO(out_intr_mask);
294
295static ssize_t out_read_index_show(struct device *dev,
296 struct device_attribute *dev_attr, char *buf)
297{
298 struct hv_device *hv_dev = device_to_hv_device(dev);
299 struct hv_ring_buffer_debug_info outbound;
300
301 if (!hv_dev->channel)
302 return -ENODEV;
303 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
304 return sprintf(buf, "%d\n", outbound.current_read_index);
305}
306static DEVICE_ATTR_RO(out_read_index);
307
308static ssize_t out_write_index_show(struct device *dev,
309 struct device_attribute *dev_attr,
310 char *buf)
311{
312 struct hv_device *hv_dev = device_to_hv_device(dev);
313 struct hv_ring_buffer_debug_info outbound;
314
315 if (!hv_dev->channel)
316 return -ENODEV;
317 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
318 return sprintf(buf, "%d\n", outbound.current_write_index);
319}
320static DEVICE_ATTR_RO(out_write_index);
321
322static ssize_t out_read_bytes_avail_show(struct device *dev,
323 struct device_attribute *dev_attr,
324 char *buf)
325{
326 struct hv_device *hv_dev = device_to_hv_device(dev);
327 struct hv_ring_buffer_debug_info outbound;
328
329 if (!hv_dev->channel)
330 return -ENODEV;
331 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
332 return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
333}
334static DEVICE_ATTR_RO(out_read_bytes_avail);
335
336static ssize_t out_write_bytes_avail_show(struct device *dev,
337 struct device_attribute *dev_attr,
338 char *buf)
339{
340 struct hv_device *hv_dev = device_to_hv_device(dev);
341 struct hv_ring_buffer_debug_info outbound;
342
343 if (!hv_dev->channel)
344 return -ENODEV;
345 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
346 return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
347}
348static DEVICE_ATTR_RO(out_write_bytes_avail);
349
350static ssize_t in_intr_mask_show(struct device *dev,
351 struct device_attribute *dev_attr, char *buf)
352{
353 struct hv_device *hv_dev = device_to_hv_device(dev);
354 struct hv_ring_buffer_debug_info inbound;
355
356 if (!hv_dev->channel)
357 return -ENODEV;
358 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
359 return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
360}
361static DEVICE_ATTR_RO(in_intr_mask);
362
363static ssize_t in_read_index_show(struct device *dev,
364 struct device_attribute *dev_attr, char *buf)
365{
366 struct hv_device *hv_dev = device_to_hv_device(dev);
367 struct hv_ring_buffer_debug_info inbound;
368
369 if (!hv_dev->channel)
370 return -ENODEV;
371 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
372 return sprintf(buf, "%d\n", inbound.current_read_index);
373}
374static DEVICE_ATTR_RO(in_read_index);
375
376static ssize_t in_write_index_show(struct device *dev,
377 struct device_attribute *dev_attr, char *buf)
378{
379 struct hv_device *hv_dev = device_to_hv_device(dev);
380 struct hv_ring_buffer_debug_info inbound;
381
382 if (!hv_dev->channel)
383 return -ENODEV;
384 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
385 return sprintf(buf, "%d\n", inbound.current_write_index);
386}
387static DEVICE_ATTR_RO(in_write_index);
388
389static ssize_t in_read_bytes_avail_show(struct device *dev,
390 struct device_attribute *dev_attr,
391 char *buf)
392{
393 struct hv_device *hv_dev = device_to_hv_device(dev);
394 struct hv_ring_buffer_debug_info inbound;
395
396 if (!hv_dev->channel)
397 return -ENODEV;
398 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
399 return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
400}
401static DEVICE_ATTR_RO(in_read_bytes_avail);
402
403static ssize_t in_write_bytes_avail_show(struct device *dev,
404 struct device_attribute *dev_attr,
405 char *buf)
406{
407 struct hv_device *hv_dev = device_to_hv_device(dev);
408 struct hv_ring_buffer_debug_info inbound;
409
410 if (!hv_dev->channel)
411 return -ENODEV;
412 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
413 return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
414}
415static DEVICE_ATTR_RO(in_write_bytes_avail);
416
417
418static struct attribute *vmbus_attrs[] = {
419 &dev_attr_id.attr,
420 &dev_attr_state.attr,
421 &dev_attr_monitor_id.attr,
422 &dev_attr_class_id.attr,
423 &dev_attr_device_id.attr,
424 &dev_attr_modalias.attr,
425 &dev_attr_server_monitor_pending.attr,
426 &dev_attr_client_monitor_pending.attr,
427 &dev_attr_server_monitor_latency.attr,
428 &dev_attr_client_monitor_latency.attr,
429 &dev_attr_server_monitor_conn_id.attr,
430 &dev_attr_client_monitor_conn_id.attr,
431 &dev_attr_out_intr_mask.attr,
432 &dev_attr_out_read_index.attr,
433 &dev_attr_out_write_index.attr,
434 &dev_attr_out_read_bytes_avail.attr,
435 &dev_attr_out_write_bytes_avail.attr,
436 &dev_attr_in_intr_mask.attr,
437 &dev_attr_in_read_index.attr,
438 &dev_attr_in_write_index.attr,
439 &dev_attr_in_read_bytes_avail.attr,
440 &dev_attr_in_write_bytes_avail.attr,
441 NULL,
442};
443ATTRIBUTE_GROUPS(vmbus);
444
445
446
447
448
449
450
451
452
453
454
455
456static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
457{
458 struct hv_device *dev = device_to_hv_device(device);
459 int ret;
460 char alias_name[VMBUS_ALIAS_LEN + 1];
461
462 print_alias_name(dev, alias_name);
463 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
464 return ret;
465}
466
467static const uuid_le null_guid;
468
469static inline bool is_null_guid(const __u8 *guid)
470{
471 if (memcmp(guid, &null_guid, sizeof(uuid_le)))
472 return false;
473 return true;
474}
475
476
477
478
479
480static const struct hv_vmbus_device_id *hv_vmbus_get_id(
481 const struct hv_vmbus_device_id *id,
482 const __u8 *guid)
483{
484 for (; !is_null_guid(id->guid); id++)
485 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
486 return id;
487
488 return NULL;
489}
490
491
492
493
494
495
496static int vmbus_match(struct device *device, struct device_driver *driver)
497{
498 struct hv_driver *drv = drv_to_hv_drv(driver);
499 struct hv_device *hv_dev = device_to_hv_device(device);
500
501 if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
502 return 1;
503
504 return 0;
505}
506
507
508
509
510static int vmbus_probe(struct device *child_device)
511{
512 int ret = 0;
513 struct hv_driver *drv =
514 drv_to_hv_drv(child_device->driver);
515 struct hv_device *dev = device_to_hv_device(child_device);
516 const struct hv_vmbus_device_id *dev_id;
517
518 dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
519 if (drv->probe) {
520 ret = drv->probe(dev, dev_id);
521 if (ret != 0)
522 pr_err("probe failed for device %s (%d)\n",
523 dev_name(child_device), ret);
524
525 } else {
526 pr_err("probe not set for driver %s\n",
527 dev_name(child_device));
528 ret = -ENODEV;
529 }
530 return ret;
531}
532
533
534
535
536static int vmbus_remove(struct device *child_device)
537{
538 struct hv_driver *drv;
539 struct hv_device *dev = device_to_hv_device(child_device);
540 u32 relid = dev->channel->offermsg.child_relid;
541
542 if (child_device->driver) {
543 drv = drv_to_hv_drv(child_device->driver);
544 if (drv->remove)
545 drv->remove(dev);
546 else {
547 hv_process_channel_removal(dev->channel, relid);
548 pr_err("remove not set for driver %s\n",
549 dev_name(child_device));
550 }
551 } else {
552
553
554
555
556 hv_process_channel_removal(dev->channel, relid);
557 }
558
559 return 0;
560}
561
562
563
564
565
566static void vmbus_shutdown(struct device *child_device)
567{
568 struct hv_driver *drv;
569 struct hv_device *dev = device_to_hv_device(child_device);
570
571
572
573 if (!child_device->driver)
574 return;
575
576 drv = drv_to_hv_drv(child_device->driver);
577
578 if (drv->shutdown)
579 drv->shutdown(dev);
580
581 return;
582}
583
584
585
586
587
588static void vmbus_device_release(struct device *device)
589{
590 struct hv_device *hv_dev = device_to_hv_device(device);
591
592 kfree(hv_dev);
593
594}
595
596
597static struct bus_type hv_bus = {
598 .name = "vmbus",
599 .match = vmbus_match,
600 .shutdown = vmbus_shutdown,
601 .remove = vmbus_remove,
602 .probe = vmbus_probe,
603 .uevent = vmbus_uevent,
604 .dev_groups = vmbus_groups,
605};
606
607struct onmessage_work_context {
608 struct work_struct work;
609 struct hv_message msg;
610};
611
612static void vmbus_onmessage_work(struct work_struct *work)
613{
614 struct onmessage_work_context *ctx;
615
616
617 if (vmbus_connection.conn_state == DISCONNECTED)
618 return;
619
620 ctx = container_of(work, struct onmessage_work_context,
621 work);
622 vmbus_onmessage(&ctx->msg);
623 kfree(ctx);
624}
625
626static void hv_process_timer_expiration(struct hv_message *msg, int cpu)
627{
628 struct clock_event_device *dev = hv_context.clk_evt[cpu];
629
630 if (dev->event_handler)
631 dev->event_handler(dev);
632
633 msg->header.message_type = HVMSG_NONE;
634
635
636
637
638
639
640
641
642 mb();
643
644 if (msg->header.message_flags.msg_pending) {
645
646
647
648
649
650 wrmsrl(HV_X64_MSR_EOM, 0);
651 }
652}
653
654static void vmbus_on_msg_dpc(unsigned long data)
655{
656 int cpu = smp_processor_id();
657 void *page_addr = hv_context.synic_message_page[cpu];
658 struct hv_message *msg = (struct hv_message *)page_addr +
659 VMBUS_MESSAGE_SINT;
660 struct vmbus_channel_message_header *hdr;
661 struct vmbus_channel_message_table_entry *entry;
662 struct onmessage_work_context *ctx;
663
664 while (1) {
665 if (msg->header.message_type == HVMSG_NONE)
666
667 break;
668
669 hdr = (struct vmbus_channel_message_header *)msg->u.payload;
670
671 if (hdr->msgtype >= CHANNELMSG_COUNT) {
672 WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype);
673 goto msg_handled;
674 }
675
676 entry = &channel_message_table[hdr->msgtype];
677 if (entry->handler_type == VMHT_BLOCKING) {
678 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
679 if (ctx == NULL)
680 continue;
681
682 INIT_WORK(&ctx->work, vmbus_onmessage_work);
683 memcpy(&ctx->msg, msg, sizeof(*msg));
684
685 queue_work(vmbus_connection.work_queue, &ctx->work);
686 } else
687 entry->message_handler(hdr);
688
689msg_handled:
690 msg->header.message_type = HVMSG_NONE;
691
692
693
694
695
696
697
698
699 mb();
700
701 if (msg->header.message_flags.msg_pending) {
702
703
704
705
706
707 wrmsrl(HV_X64_MSR_EOM, 0);
708 }
709 }
710}
711
712static void vmbus_isr(void)
713{
714 int cpu = smp_processor_id();
715 void *page_addr;
716 struct hv_message *msg;
717 union hv_synic_event_flags *event;
718 bool handled = false;
719
720 page_addr = hv_context.synic_event_page[cpu];
721 if (page_addr == NULL)
722 return;
723
724 event = (union hv_synic_event_flags *)page_addr +
725 VMBUS_MESSAGE_SINT;
726
727
728
729
730
731
732 if ((vmbus_proto_version == VERSION_WS2008) ||
733 (vmbus_proto_version == VERSION_WIN7)) {
734
735
736 if (sync_test_and_clear_bit(0,
737 (unsigned long *) &event->flags32[0])) {
738 handled = true;
739 }
740 } else {
741
742
743
744
745
746
747 handled = true;
748 }
749
750 if (handled)
751 tasklet_schedule(hv_context.event_dpc[cpu]);
752
753
754 page_addr = hv_context.synic_message_page[cpu];
755 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
756
757
758 if (msg->header.message_type != HVMSG_NONE) {
759 if (msg->header.message_type == HVMSG_TIMER_EXPIRED)
760 hv_process_timer_expiration(msg, cpu);
761 else
762 tasklet_schedule(&msg_dpc);
763 }
764}
765
766#ifdef CONFIG_HOTPLUG_CPU
767static int hyperv_cpu_disable(void)
768{
769 return -ENOSYS;
770}
771
772static void hv_cpu_hotplug_quirk(bool vmbus_loaded)
773{
774 static void *previous_cpu_disable;
775
776
777
778
779
780
781
782 if ((vmbus_proto_version == VERSION_WS2008) ||
783 (vmbus_proto_version == VERSION_WIN7))
784 return;
785
786 if (vmbus_loaded) {
787 previous_cpu_disable = smp_ops.cpu_disable;
788 smp_ops.cpu_disable = hyperv_cpu_disable;
789 pr_notice("CPU offlining is not supported by hypervisor\n");
790 } else if (previous_cpu_disable)
791 smp_ops.cpu_disable = previous_cpu_disable;
792}
793#else
794static void hv_cpu_hotplug_quirk(bool vmbus_loaded)
795{
796}
797#endif
798
799
800
801
802
803
804
805
806
807
808static int vmbus_bus_init(int irq)
809{
810 int ret;
811
812
813 ret = hv_init();
814 if (ret != 0) {
815 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
816 return ret;
817 }
818
819 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
820
821 ret = bus_register(&hv_bus);
822 if (ret)
823 goto err_cleanup;
824
825 hv_setup_vmbus_irq(vmbus_isr);
826
827 ret = hv_synic_alloc();
828 if (ret)
829 goto err_alloc;
830
831
832
833
834 on_each_cpu(hv_synic_init, NULL, 1);
835 ret = vmbus_connect();
836 if (ret)
837 goto err_alloc;
838
839 hv_cpu_hotplug_quirk(true);
840
841
842
843
844 if (ms_hyperv.features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
845 atomic_notifier_chain_register(&panic_notifier_list,
846 &hyperv_panic_block);
847 }
848
849 vmbus_request_offers();
850
851 return 0;
852
853err_alloc:
854 hv_synic_free();
855 hv_remove_vmbus_irq();
856
857 bus_unregister(&hv_bus);
858
859err_cleanup:
860 hv_cleanup();
861
862 return ret;
863}
864
865
866
867
868
869
870
871
872
873
874
875
876int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
877{
878 int ret;
879
880 pr_info("registering driver %s\n", hv_driver->name);
881
882 ret = vmbus_exists();
883 if (ret < 0)
884 return ret;
885
886 hv_driver->driver.name = hv_driver->name;
887 hv_driver->driver.owner = owner;
888 hv_driver->driver.mod_name = mod_name;
889 hv_driver->driver.bus = &hv_bus;
890
891 ret = driver_register(&hv_driver->driver);
892
893 return ret;
894}
895EXPORT_SYMBOL_GPL(__vmbus_driver_register);
896
897
898
899
900
901
902
903
904void vmbus_driver_unregister(struct hv_driver *hv_driver)
905{
906 pr_info("unregistering driver %s\n", hv_driver->name);
907
908 if (!vmbus_exists())
909 driver_unregister(&hv_driver->driver);
910}
911EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
912
913
914
915
916
917struct hv_device *vmbus_device_create(const uuid_le *type,
918 const uuid_le *instance,
919 struct vmbus_channel *channel)
920{
921 struct hv_device *child_device_obj;
922
923 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
924 if (!child_device_obj) {
925 pr_err("Unable to allocate device object for child device\n");
926 return NULL;
927 }
928
929 child_device_obj->channel = channel;
930 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
931 memcpy(&child_device_obj->dev_instance, instance,
932 sizeof(uuid_le));
933
934
935 return child_device_obj;
936}
937
938
939
940
941int vmbus_device_register(struct hv_device *child_device_obj)
942{
943 int ret = 0;
944
945 dev_set_name(&child_device_obj->device, "vmbus_%d",
946 child_device_obj->channel->id);
947
948 child_device_obj->device.bus = &hv_bus;
949 child_device_obj->device.parent = &hv_acpi_dev->dev;
950 child_device_obj->device.release = vmbus_device_release;
951
952
953
954
955
956 ret = device_register(&child_device_obj->device);
957
958 if (ret)
959 pr_err("Unable to register child device\n");
960 else
961 pr_debug("child device %s registered\n",
962 dev_name(&child_device_obj->device));
963
964 return ret;
965}
966
967
968
969
970
971void vmbus_device_unregister(struct hv_device *device_obj)
972{
973 pr_debug("child device %s unregistered\n",
974 dev_name(&device_obj->device));
975
976
977
978
979
980 device_unregister(&device_obj->device);
981}
982
983
984
985
986
987
988
989static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
990{
991 switch (res->type) {
992 case ACPI_RESOURCE_TYPE_IRQ:
993 irq = res->data.irq.interrupts[0];
994 break;
995
996 case ACPI_RESOURCE_TYPE_ADDRESS64:
997 hyperv_mmio.start = res->data.address64.address.minimum;
998 hyperv_mmio.end = res->data.address64.address.maximum;
999 break;
1000 }
1001
1002 return AE_OK;
1003}
1004
1005static int vmbus_acpi_add(struct acpi_device *device)
1006{
1007 acpi_status result;
1008 int ret_val = -ENODEV;
1009
1010 hv_acpi_dev = device;
1011
1012 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
1013 vmbus_walk_resources, NULL);
1014
1015 if (ACPI_FAILURE(result))
1016 goto acpi_walk_err;
1017
1018
1019
1020
1021 if (device->parent) {
1022 result = acpi_walk_resources(device->parent->handle,
1023 METHOD_NAME__CRS,
1024 vmbus_walk_resources, NULL);
1025
1026 if (ACPI_FAILURE(result))
1027 goto acpi_walk_err;
1028 if (hyperv_mmio.start && hyperv_mmio.end)
1029 request_resource(&iomem_resource, &hyperv_mmio);
1030 }
1031 ret_val = 0;
1032
1033acpi_walk_err:
1034 complete(&probe_event);
1035 return ret_val;
1036}
1037
1038static const struct acpi_device_id vmbus_acpi_device_ids[] = {
1039 {"VMBUS", 0},
1040 {"VMBus", 0},
1041 {"", 0},
1042};
1043MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
1044
1045static struct acpi_driver vmbus_acpi_driver = {
1046 .name = "vmbus",
1047 .ids = vmbus_acpi_device_ids,
1048 .ops = {
1049 .add = vmbus_acpi_add,
1050 },
1051};
1052
1053static int __init hv_acpi_init(void)
1054{
1055 int ret, t;
1056
1057 if (x86_hyper != &x86_hyper_ms_hyperv)
1058 return -ENODEV;
1059
1060 init_completion(&probe_event);
1061
1062
1063
1064
1065 ret = acpi_bus_register_driver(&vmbus_acpi_driver);
1066
1067 if (ret)
1068 return ret;
1069
1070 t = wait_for_completion_timeout(&probe_event, 5*HZ);
1071 if (t == 0) {
1072 ret = -ETIMEDOUT;
1073 goto cleanup;
1074 }
1075
1076 if (irq <= 0) {
1077 ret = -ENODEV;
1078 goto cleanup;
1079 }
1080
1081 ret = vmbus_bus_init(irq);
1082 if (ret)
1083 goto cleanup;
1084
1085 return 0;
1086
1087cleanup:
1088 acpi_bus_unregister_driver(&vmbus_acpi_driver);
1089 hv_acpi_dev = NULL;
1090 return ret;
1091}
1092
1093static void __exit vmbus_exit(void)
1094{
1095 int cpu;
1096
1097 vmbus_connection.conn_state = DISCONNECTED;
1098 hv_synic_clockevents_cleanup();
1099 hv_remove_vmbus_irq();
1100 vmbus_free_channels();
1101 bus_unregister(&hv_bus);
1102 hv_cleanup();
1103 for_each_online_cpu(cpu)
1104 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1);
1105 acpi_bus_unregister_driver(&vmbus_acpi_driver);
1106 hv_cpu_hotplug_quirk(false);
1107 vmbus_disconnect();
1108}
1109
1110
1111MODULE_LICENSE("GPL");
1112
1113subsys_initcall(hv_acpi_init);
1114module_exit(vmbus_exit);
1115