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 <linux/sched/task_stack.h>
38
39#include <asm/mshyperv.h>
40#include <linux/notifier.h>
41#include <linux/ptrace.h>
42#include <linux/screen_info.h>
43#include <linux/kdebug.h>
44#include <linux/efi.h>
45#include <linux/random.h>
46#include "hyperv_vmbus.h"
47
48struct vmbus_dynid {
49 struct list_head node;
50 struct hv_vmbus_device_id id;
51};
52
53static struct acpi_device *hv_acpi_dev;
54
55static struct completion probe_event;
56
57static int hyperv_cpuhp_online;
58
59static int hyperv_panic_event(struct notifier_block *nb, unsigned long val,
60 void *args)
61{
62 struct pt_regs *regs;
63
64 regs = current_pt_regs();
65
66 hyperv_report_panic(regs, val);
67 return NOTIFY_DONE;
68}
69
70static int hyperv_die_event(struct notifier_block *nb, unsigned long val,
71 void *args)
72{
73 struct die_args *die = (struct die_args *)args;
74 struct pt_regs *regs = die->regs;
75
76 hyperv_report_panic(regs, val);
77 return NOTIFY_DONE;
78}
79
80static struct notifier_block hyperv_die_block = {
81 .notifier_call = hyperv_die_event,
82};
83static struct notifier_block hyperv_panic_block = {
84 .notifier_call = hyperv_panic_event,
85};
86
87static const char *fb_mmio_name = "fb_range";
88static struct resource *fb_mmio;
89static struct resource *hyperv_mmio;
90static DEFINE_SEMAPHORE(hyperv_mmio_lock);
91
92static int vmbus_exists(void)
93{
94 if (hv_acpi_dev == NULL)
95 return -ENODEV;
96
97 return 0;
98}
99
100#define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
101static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
102{
103 int i;
104 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
105 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
106}
107
108static u8 channel_monitor_group(const struct vmbus_channel *channel)
109{
110 return (u8)channel->offermsg.monitorid / 32;
111}
112
113static u8 channel_monitor_offset(const struct vmbus_channel *channel)
114{
115 return (u8)channel->offermsg.monitorid % 32;
116}
117
118static u32 channel_pending(const struct vmbus_channel *channel,
119 const struct hv_monitor_page *monitor_page)
120{
121 u8 monitor_group = channel_monitor_group(channel);
122
123 return monitor_page->trigger_group[monitor_group].pending;
124}
125
126static u32 channel_latency(const struct vmbus_channel *channel,
127 const struct hv_monitor_page *monitor_page)
128{
129 u8 monitor_group = channel_monitor_group(channel);
130 u8 monitor_offset = channel_monitor_offset(channel);
131
132 return monitor_page->latency[monitor_group][monitor_offset];
133}
134
135static u32 channel_conn_id(struct vmbus_channel *channel,
136 struct hv_monitor_page *monitor_page)
137{
138 u8 monitor_group = channel_monitor_group(channel);
139 u8 monitor_offset = channel_monitor_offset(channel);
140 return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
141}
142
143static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
144 char *buf)
145{
146 struct hv_device *hv_dev = device_to_hv_device(dev);
147
148 if (!hv_dev->channel)
149 return -ENODEV;
150 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
151}
152static DEVICE_ATTR_RO(id);
153
154static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
155 char *buf)
156{
157 struct hv_device *hv_dev = device_to_hv_device(dev);
158
159 if (!hv_dev->channel)
160 return -ENODEV;
161 return sprintf(buf, "%d\n", hv_dev->channel->state);
162}
163static DEVICE_ATTR_RO(state);
164
165static ssize_t monitor_id_show(struct device *dev,
166 struct device_attribute *dev_attr, char *buf)
167{
168 struct hv_device *hv_dev = device_to_hv_device(dev);
169
170 if (!hv_dev->channel)
171 return -ENODEV;
172 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
173}
174static DEVICE_ATTR_RO(monitor_id);
175
176static ssize_t class_id_show(struct device *dev,
177 struct device_attribute *dev_attr, char *buf)
178{
179 struct hv_device *hv_dev = device_to_hv_device(dev);
180
181 if (!hv_dev->channel)
182 return -ENODEV;
183 return sprintf(buf, "{%pUl}\n",
184 hv_dev->channel->offermsg.offer.if_type.b);
185}
186static DEVICE_ATTR_RO(class_id);
187
188static ssize_t device_id_show(struct device *dev,
189 struct device_attribute *dev_attr, char *buf)
190{
191 struct hv_device *hv_dev = device_to_hv_device(dev);
192
193 if (!hv_dev->channel)
194 return -ENODEV;
195 return sprintf(buf, "{%pUl}\n",
196 hv_dev->channel->offermsg.offer.if_instance.b);
197}
198static DEVICE_ATTR_RO(device_id);
199
200static ssize_t modalias_show(struct device *dev,
201 struct device_attribute *dev_attr, char *buf)
202{
203 struct hv_device *hv_dev = device_to_hv_device(dev);
204 char alias_name[VMBUS_ALIAS_LEN + 1];
205
206 print_alias_name(hv_dev, alias_name);
207 return sprintf(buf, "vmbus:%s\n", alias_name);
208}
209static DEVICE_ATTR_RO(modalias);
210
211static ssize_t server_monitor_pending_show(struct device *dev,
212 struct device_attribute *dev_attr,
213 char *buf)
214{
215 struct hv_device *hv_dev = device_to_hv_device(dev);
216
217 if (!hv_dev->channel)
218 return -ENODEV;
219 return sprintf(buf, "%d\n",
220 channel_pending(hv_dev->channel,
221 vmbus_connection.monitor_pages[1]));
222}
223static DEVICE_ATTR_RO(server_monitor_pending);
224
225static ssize_t client_monitor_pending_show(struct device *dev,
226 struct device_attribute *dev_attr,
227 char *buf)
228{
229 struct hv_device *hv_dev = device_to_hv_device(dev);
230
231 if (!hv_dev->channel)
232 return -ENODEV;
233 return sprintf(buf, "%d\n",
234 channel_pending(hv_dev->channel,
235 vmbus_connection.monitor_pages[1]));
236}
237static DEVICE_ATTR_RO(client_monitor_pending);
238
239static ssize_t server_monitor_latency_show(struct device *dev,
240 struct device_attribute *dev_attr,
241 char *buf)
242{
243 struct hv_device *hv_dev = device_to_hv_device(dev);
244
245 if (!hv_dev->channel)
246 return -ENODEV;
247 return sprintf(buf, "%d\n",
248 channel_latency(hv_dev->channel,
249 vmbus_connection.monitor_pages[0]));
250}
251static DEVICE_ATTR_RO(server_monitor_latency);
252
253static ssize_t client_monitor_latency_show(struct device *dev,
254 struct device_attribute *dev_attr,
255 char *buf)
256{
257 struct hv_device *hv_dev = device_to_hv_device(dev);
258
259 if (!hv_dev->channel)
260 return -ENODEV;
261 return sprintf(buf, "%d\n",
262 channel_latency(hv_dev->channel,
263 vmbus_connection.monitor_pages[1]));
264}
265static DEVICE_ATTR_RO(client_monitor_latency);
266
267static ssize_t server_monitor_conn_id_show(struct device *dev,
268 struct device_attribute *dev_attr,
269 char *buf)
270{
271 struct hv_device *hv_dev = device_to_hv_device(dev);
272
273 if (!hv_dev->channel)
274 return -ENODEV;
275 return sprintf(buf, "%d\n",
276 channel_conn_id(hv_dev->channel,
277 vmbus_connection.monitor_pages[0]));
278}
279static DEVICE_ATTR_RO(server_monitor_conn_id);
280
281static ssize_t client_monitor_conn_id_show(struct device *dev,
282 struct device_attribute *dev_attr,
283 char *buf)
284{
285 struct hv_device *hv_dev = device_to_hv_device(dev);
286
287 if (!hv_dev->channel)
288 return -ENODEV;
289 return sprintf(buf, "%d\n",
290 channel_conn_id(hv_dev->channel,
291 vmbus_connection.monitor_pages[1]));
292}
293static DEVICE_ATTR_RO(client_monitor_conn_id);
294
295static ssize_t out_intr_mask_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_interrupt_mask);
305}
306static DEVICE_ATTR_RO(out_intr_mask);
307
308static ssize_t out_read_index_show(struct device *dev,
309 struct device_attribute *dev_attr, char *buf)
310{
311 struct hv_device *hv_dev = device_to_hv_device(dev);
312 struct hv_ring_buffer_debug_info outbound;
313
314 if (!hv_dev->channel)
315 return -ENODEV;
316 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
317 return sprintf(buf, "%d\n", outbound.current_read_index);
318}
319static DEVICE_ATTR_RO(out_read_index);
320
321static ssize_t out_write_index_show(struct device *dev,
322 struct device_attribute *dev_attr,
323 char *buf)
324{
325 struct hv_device *hv_dev = device_to_hv_device(dev);
326 struct hv_ring_buffer_debug_info outbound;
327
328 if (!hv_dev->channel)
329 return -ENODEV;
330 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
331 return sprintf(buf, "%d\n", outbound.current_write_index);
332}
333static DEVICE_ATTR_RO(out_write_index);
334
335static ssize_t out_read_bytes_avail_show(struct device *dev,
336 struct device_attribute *dev_attr,
337 char *buf)
338{
339 struct hv_device *hv_dev = device_to_hv_device(dev);
340 struct hv_ring_buffer_debug_info outbound;
341
342 if (!hv_dev->channel)
343 return -ENODEV;
344 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
345 return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
346}
347static DEVICE_ATTR_RO(out_read_bytes_avail);
348
349static ssize_t out_write_bytes_avail_show(struct device *dev,
350 struct device_attribute *dev_attr,
351 char *buf)
352{
353 struct hv_device *hv_dev = device_to_hv_device(dev);
354 struct hv_ring_buffer_debug_info outbound;
355
356 if (!hv_dev->channel)
357 return -ENODEV;
358 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
359 return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
360}
361static DEVICE_ATTR_RO(out_write_bytes_avail);
362
363static ssize_t in_intr_mask_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_interrupt_mask);
373}
374static DEVICE_ATTR_RO(in_intr_mask);
375
376static ssize_t in_read_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_read_index);
386}
387static DEVICE_ATTR_RO(in_read_index);
388
389static ssize_t in_write_index_show(struct device *dev,
390 struct device_attribute *dev_attr, char *buf)
391{
392 struct hv_device *hv_dev = device_to_hv_device(dev);
393 struct hv_ring_buffer_debug_info inbound;
394
395 if (!hv_dev->channel)
396 return -ENODEV;
397 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
398 return sprintf(buf, "%d\n", inbound.current_write_index);
399}
400static DEVICE_ATTR_RO(in_write_index);
401
402static ssize_t in_read_bytes_avail_show(struct device *dev,
403 struct device_attribute *dev_attr,
404 char *buf)
405{
406 struct hv_device *hv_dev = device_to_hv_device(dev);
407 struct hv_ring_buffer_debug_info inbound;
408
409 if (!hv_dev->channel)
410 return -ENODEV;
411 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
412 return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
413}
414static DEVICE_ATTR_RO(in_read_bytes_avail);
415
416static ssize_t in_write_bytes_avail_show(struct device *dev,
417 struct device_attribute *dev_attr,
418 char *buf)
419{
420 struct hv_device *hv_dev = device_to_hv_device(dev);
421 struct hv_ring_buffer_debug_info inbound;
422
423 if (!hv_dev->channel)
424 return -ENODEV;
425 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
426 return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
427}
428static DEVICE_ATTR_RO(in_write_bytes_avail);
429
430static ssize_t channel_vp_mapping_show(struct device *dev,
431 struct device_attribute *dev_attr,
432 char *buf)
433{
434 struct hv_device *hv_dev = device_to_hv_device(dev);
435 struct vmbus_channel *channel = hv_dev->channel, *cur_sc;
436 unsigned long flags;
437 int buf_size = PAGE_SIZE, n_written, tot_written;
438 struct list_head *cur;
439
440 if (!channel)
441 return -ENODEV;
442
443 tot_written = snprintf(buf, buf_size, "%u:%u\n",
444 channel->offermsg.child_relid, channel->target_cpu);
445
446 spin_lock_irqsave(&channel->lock, flags);
447
448 list_for_each(cur, &channel->sc_list) {
449 if (tot_written >= buf_size - 1)
450 break;
451
452 cur_sc = list_entry(cur, struct vmbus_channel, sc_list);
453 n_written = scnprintf(buf + tot_written,
454 buf_size - tot_written,
455 "%u:%u\n",
456 cur_sc->offermsg.child_relid,
457 cur_sc->target_cpu);
458 tot_written += n_written;
459 }
460
461 spin_unlock_irqrestore(&channel->lock, flags);
462
463 return tot_written;
464}
465static DEVICE_ATTR_RO(channel_vp_mapping);
466
467static ssize_t vendor_show(struct device *dev,
468 struct device_attribute *dev_attr,
469 char *buf)
470{
471 struct hv_device *hv_dev = device_to_hv_device(dev);
472 return sprintf(buf, "0x%x\n", hv_dev->vendor_id);
473}
474static DEVICE_ATTR_RO(vendor);
475
476static ssize_t device_show(struct device *dev,
477 struct device_attribute *dev_attr,
478 char *buf)
479{
480 struct hv_device *hv_dev = device_to_hv_device(dev);
481 return sprintf(buf, "0x%x\n", hv_dev->device_id);
482}
483static DEVICE_ATTR_RO(device);
484
485
486static struct attribute *vmbus_dev_attrs[] = {
487 &dev_attr_id.attr,
488 &dev_attr_state.attr,
489 &dev_attr_monitor_id.attr,
490 &dev_attr_class_id.attr,
491 &dev_attr_device_id.attr,
492 &dev_attr_modalias.attr,
493 &dev_attr_server_monitor_pending.attr,
494 &dev_attr_client_monitor_pending.attr,
495 &dev_attr_server_monitor_latency.attr,
496 &dev_attr_client_monitor_latency.attr,
497 &dev_attr_server_monitor_conn_id.attr,
498 &dev_attr_client_monitor_conn_id.attr,
499 &dev_attr_out_intr_mask.attr,
500 &dev_attr_out_read_index.attr,
501 &dev_attr_out_write_index.attr,
502 &dev_attr_out_read_bytes_avail.attr,
503 &dev_attr_out_write_bytes_avail.attr,
504 &dev_attr_in_intr_mask.attr,
505 &dev_attr_in_read_index.attr,
506 &dev_attr_in_write_index.attr,
507 &dev_attr_in_read_bytes_avail.attr,
508 &dev_attr_in_write_bytes_avail.attr,
509 &dev_attr_channel_vp_mapping.attr,
510 &dev_attr_vendor.attr,
511 &dev_attr_device.attr,
512 NULL,
513};
514ATTRIBUTE_GROUPS(vmbus_dev);
515
516
517
518
519
520
521
522
523
524
525
526
527static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
528{
529 struct hv_device *dev = device_to_hv_device(device);
530 int ret;
531 char alias_name[VMBUS_ALIAS_LEN + 1];
532
533 print_alias_name(dev, alias_name);
534 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
535 return ret;
536}
537
538static const uuid_le null_guid;
539
540static inline bool is_null_guid(const uuid_le *guid)
541{
542 if (uuid_le_cmp(*guid, null_guid))
543 return false;
544 return true;
545}
546
547
548
549
550
551static const struct hv_vmbus_device_id *hv_vmbus_get_id(struct hv_driver *drv,
552 const uuid_le *guid)
553{
554 const struct hv_vmbus_device_id *id = NULL;
555 struct vmbus_dynid *dynid;
556
557
558 spin_lock(&drv->dynids.lock);
559 list_for_each_entry(dynid, &drv->dynids.list, node) {
560 if (!uuid_le_cmp(dynid->id.guid, *guid)) {
561 id = &dynid->id;
562 break;
563 }
564 }
565 spin_unlock(&drv->dynids.lock);
566
567 if (id)
568 return id;
569
570 id = drv->id_table;
571 if (id == NULL)
572 return NULL;
573
574 for (; !is_null_guid(&id->guid); id++)
575 if (!uuid_le_cmp(id->guid, *guid))
576 return id;
577
578 return NULL;
579}
580
581
582static int vmbus_add_dynid(struct hv_driver *drv, uuid_le *guid)
583{
584 struct vmbus_dynid *dynid;
585
586 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
587 if (!dynid)
588 return -ENOMEM;
589
590 dynid->id.guid = *guid;
591
592 spin_lock(&drv->dynids.lock);
593 list_add_tail(&dynid->node, &drv->dynids.list);
594 spin_unlock(&drv->dynids.lock);
595
596 return driver_attach(&drv->driver);
597}
598
599static void vmbus_free_dynids(struct hv_driver *drv)
600{
601 struct vmbus_dynid *dynid, *n;
602
603 spin_lock(&drv->dynids.lock);
604 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
605 list_del(&dynid->node);
606 kfree(dynid);
607 }
608 spin_unlock(&drv->dynids.lock);
609}
610
611
612
613
614
615
616static ssize_t new_id_store(struct device_driver *driver, const char *buf,
617 size_t count)
618{
619 struct hv_driver *drv = drv_to_hv_drv(driver);
620 uuid_le guid;
621 ssize_t retval;
622
623 retval = uuid_le_to_bin(buf, &guid);
624 if (retval)
625 return retval;
626
627 if (hv_vmbus_get_id(drv, &guid))
628 return -EEXIST;
629
630 retval = vmbus_add_dynid(drv, &guid);
631 if (retval)
632 return retval;
633 return count;
634}
635static DRIVER_ATTR_WO(new_id);
636
637
638
639
640
641
642static ssize_t remove_id_store(struct device_driver *driver, const char *buf,
643 size_t count)
644{
645 struct hv_driver *drv = drv_to_hv_drv(driver);
646 struct vmbus_dynid *dynid, *n;
647 uuid_le guid;
648 ssize_t retval;
649
650 retval = uuid_le_to_bin(buf, &guid);
651 if (retval)
652 return retval;
653
654 retval = -ENODEV;
655 spin_lock(&drv->dynids.lock);
656 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
657 struct hv_vmbus_device_id *id = &dynid->id;
658
659 if (!uuid_le_cmp(id->guid, guid)) {
660 list_del(&dynid->node);
661 kfree(dynid);
662 retval = count;
663 break;
664 }
665 }
666 spin_unlock(&drv->dynids.lock);
667
668 return retval;
669}
670static DRIVER_ATTR_WO(remove_id);
671
672static struct attribute *vmbus_drv_attrs[] = {
673 &driver_attr_new_id.attr,
674 &driver_attr_remove_id.attr,
675 NULL,
676};
677ATTRIBUTE_GROUPS(vmbus_drv);
678
679
680
681
682
683static int vmbus_match(struct device *device, struct device_driver *driver)
684{
685 struct hv_driver *drv = drv_to_hv_drv(driver);
686 struct hv_device *hv_dev = device_to_hv_device(device);
687
688
689 if (is_hvsock_channel(hv_dev->channel))
690 return drv->hvsock;
691
692 if (hv_vmbus_get_id(drv, &hv_dev->dev_type))
693 return 1;
694
695 return 0;
696}
697
698
699
700
701static int vmbus_probe(struct device *child_device)
702{
703 int ret = 0;
704 struct hv_driver *drv =
705 drv_to_hv_drv(child_device->driver);
706 struct hv_device *dev = device_to_hv_device(child_device);
707 const struct hv_vmbus_device_id *dev_id;
708
709 dev_id = hv_vmbus_get_id(drv, &dev->dev_type);
710 if (drv->probe) {
711 ret = drv->probe(dev, dev_id);
712 if (ret != 0)
713 pr_err("probe failed for device %s (%d)\n",
714 dev_name(child_device), ret);
715
716 } else {
717 pr_err("probe not set for driver %s\n",
718 dev_name(child_device));
719 ret = -ENODEV;
720 }
721 return ret;
722}
723
724
725
726
727static int vmbus_remove(struct device *child_device)
728{
729 struct hv_driver *drv;
730 struct hv_device *dev = device_to_hv_device(child_device);
731
732 if (child_device->driver) {
733 drv = drv_to_hv_drv(child_device->driver);
734 if (drv->remove)
735 drv->remove(dev);
736 }
737
738 return 0;
739}
740
741
742
743
744
745static void vmbus_shutdown(struct device *child_device)
746{
747 struct hv_driver *drv;
748 struct hv_device *dev = device_to_hv_device(child_device);
749
750
751
752 if (!child_device->driver)
753 return;
754
755 drv = drv_to_hv_drv(child_device->driver);
756
757 if (drv->shutdown)
758 drv->shutdown(dev);
759}
760
761
762
763
764
765static void vmbus_device_release(struct device *device)
766{
767 struct hv_device *hv_dev = device_to_hv_device(device);
768 struct vmbus_channel *channel = hv_dev->channel;
769
770 mutex_lock(&vmbus_connection.channel_mutex);
771 hv_process_channel_removal(channel->offermsg.child_relid);
772 mutex_unlock(&vmbus_connection.channel_mutex);
773 kfree(hv_dev);
774
775}
776
777
778static struct bus_type hv_bus = {
779 .name = "vmbus",
780 .match = vmbus_match,
781 .shutdown = vmbus_shutdown,
782 .remove = vmbus_remove,
783 .probe = vmbus_probe,
784 .uevent = vmbus_uevent,
785 .dev_groups = vmbus_dev_groups,
786 .drv_groups = vmbus_drv_groups,
787};
788
789struct onmessage_work_context {
790 struct work_struct work;
791 struct hv_message msg;
792};
793
794static void vmbus_onmessage_work(struct work_struct *work)
795{
796 struct onmessage_work_context *ctx;
797
798
799 if (vmbus_connection.conn_state == DISCONNECTED)
800 return;
801
802 ctx = container_of(work, struct onmessage_work_context,
803 work);
804 vmbus_onmessage(&ctx->msg);
805 kfree(ctx);
806}
807
808static void hv_process_timer_expiration(struct hv_message *msg,
809 struct hv_per_cpu_context *hv_cpu)
810{
811 struct clock_event_device *dev = hv_cpu->clk_evt;
812
813 if (dev->event_handler)
814 dev->event_handler(dev);
815
816 vmbus_signal_eom(msg, HVMSG_TIMER_EXPIRED);
817}
818
819void vmbus_on_msg_dpc(unsigned long data)
820{
821 struct hv_per_cpu_context *hv_cpu = (void *)data;
822 void *page_addr = hv_cpu->synic_message_page;
823 struct hv_message *msg = (struct hv_message *)page_addr +
824 VMBUS_MESSAGE_SINT;
825 struct vmbus_channel_message_header *hdr;
826 const struct vmbus_channel_message_table_entry *entry;
827 struct onmessage_work_context *ctx;
828 u32 message_type = msg->header.message_type;
829
830 if (message_type == HVMSG_NONE)
831
832 return;
833
834 hdr = (struct vmbus_channel_message_header *)msg->u.payload;
835
836 trace_vmbus_on_msg_dpc(hdr);
837
838 if (hdr->msgtype >= CHANNELMSG_COUNT) {
839 WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype);
840 goto msg_handled;
841 }
842
843 entry = &channel_message_table[hdr->msgtype];
844 if (entry->handler_type == VMHT_BLOCKING) {
845 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
846 if (ctx == NULL)
847 return;
848
849 INIT_WORK(&ctx->work, vmbus_onmessage_work);
850 memcpy(&ctx->msg, msg, sizeof(*msg));
851
852
853
854
855
856
857
858 switch (hdr->msgtype) {
859 case CHANNELMSG_RESCIND_CHANNELOFFER:
860
861
862
863
864 schedule_work_on(vmbus_connection.connect_cpu,
865 &ctx->work);
866 break;
867
868 case CHANNELMSG_OFFERCHANNEL:
869 atomic_inc(&vmbus_connection.offer_in_progress);
870 queue_work_on(vmbus_connection.connect_cpu,
871 vmbus_connection.work_queue,
872 &ctx->work);
873 break;
874
875 default:
876 queue_work(vmbus_connection.work_queue, &ctx->work);
877 }
878 } else
879 entry->message_handler(hdr);
880
881msg_handled:
882 vmbus_signal_eom(msg, message_type);
883}
884
885
886
887
888
889static void vmbus_channel_isr(struct vmbus_channel *channel)
890{
891 void (*callback_fn)(void *);
892
893 callback_fn = READ_ONCE(channel->onchannel_callback);
894 if (likely(callback_fn != NULL))
895 (*callback_fn)(channel->channel_callback_context);
896}
897
898
899
900
901static void vmbus_chan_sched(struct hv_per_cpu_context *hv_cpu)
902{
903 unsigned long *recv_int_page;
904 u32 maxbits, relid;
905
906 if (vmbus_proto_version < VERSION_WIN8) {
907 maxbits = MAX_NUM_CHANNELS_SUPPORTED;
908 recv_int_page = vmbus_connection.recv_int_page;
909 } else {
910
911
912
913
914
915 void *page_addr = hv_cpu->synic_event_page;
916 union hv_synic_event_flags *event
917 = (union hv_synic_event_flags *)page_addr +
918 VMBUS_MESSAGE_SINT;
919
920 maxbits = HV_EVENT_FLAGS_COUNT;
921 recv_int_page = event->flags;
922 }
923
924 if (unlikely(!recv_int_page))
925 return;
926
927 for_each_set_bit(relid, recv_int_page, maxbits) {
928 struct vmbus_channel *channel;
929
930 if (!sync_test_and_clear_bit(relid, recv_int_page))
931 continue;
932
933
934 if (relid == 0)
935 continue;
936
937 rcu_read_lock();
938
939
940 list_for_each_entry_rcu(channel, &hv_cpu->chan_list, percpu_list) {
941 if (channel->offermsg.child_relid != relid)
942 continue;
943
944 if (channel->rescind)
945 continue;
946
947 trace_vmbus_chan_sched(channel);
948
949 ++channel->interrupts;
950
951 switch (channel->callback_mode) {
952 case HV_CALL_ISR:
953 vmbus_channel_isr(channel);
954 break;
955
956 case HV_CALL_BATCHED:
957 hv_begin_read(&channel->inbound);
958
959 case HV_CALL_DIRECT:
960 tasklet_schedule(&channel->callback_event);
961 }
962 }
963
964 rcu_read_unlock();
965 }
966}
967
968static void vmbus_isr(void)
969{
970 struct hv_per_cpu_context *hv_cpu
971 = this_cpu_ptr(hv_context.cpu_context);
972 void *page_addr = hv_cpu->synic_event_page;
973 struct hv_message *msg;
974 union hv_synic_event_flags *event;
975 bool handled = false;
976
977 if (unlikely(page_addr == NULL))
978 return;
979
980 event = (union hv_synic_event_flags *)page_addr +
981 VMBUS_MESSAGE_SINT;
982
983
984
985
986
987
988 if ((vmbus_proto_version == VERSION_WS2008) ||
989 (vmbus_proto_version == VERSION_WIN7)) {
990
991
992 if (sync_test_and_clear_bit(0, event->flags))
993 handled = true;
994 } else {
995
996
997
998
999
1000
1001 handled = true;
1002 }
1003
1004 if (handled)
1005 vmbus_chan_sched(hv_cpu);
1006
1007 page_addr = hv_cpu->synic_message_page;
1008 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
1009
1010
1011 if (msg->header.message_type != HVMSG_NONE) {
1012 if (msg->header.message_type == HVMSG_TIMER_EXPIRED)
1013 hv_process_timer_expiration(msg, hv_cpu);
1014 else
1015 tasklet_schedule(&hv_cpu->msg_dpc);
1016 }
1017
1018 add_interrupt_randomness(HYPERVISOR_CALLBACK_VECTOR, 0);
1019}
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030static int vmbus_bus_init(void)
1031{
1032 int ret;
1033
1034
1035 ret = hv_init();
1036 if (ret != 0) {
1037 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
1038 return ret;
1039 }
1040
1041 ret = bus_register(&hv_bus);
1042 if (ret)
1043 return ret;
1044
1045 hv_setup_vmbus_irq(vmbus_isr);
1046
1047 ret = hv_synic_alloc();
1048 if (ret)
1049 goto err_alloc;
1050
1051
1052
1053
1054 ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "hyperv/vmbus:online",
1055 hv_synic_init, hv_synic_cleanup);
1056 if (ret < 0)
1057 goto err_alloc;
1058 hyperv_cpuhp_online = ret;
1059
1060 ret = vmbus_connect();
1061 if (ret)
1062 goto err_connect;
1063
1064
1065
1066
1067 if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
1068 register_die_notifier(&hyperv_die_block);
1069 atomic_notifier_chain_register(&panic_notifier_list,
1070 &hyperv_panic_block);
1071 }
1072
1073 vmbus_request_offers();
1074
1075 return 0;
1076
1077err_connect:
1078 cpuhp_remove_state(hyperv_cpuhp_online);
1079err_alloc:
1080 hv_synic_free();
1081 hv_remove_vmbus_irq();
1082
1083 bus_unregister(&hv_bus);
1084
1085 return ret;
1086}
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
1100{
1101 int ret;
1102
1103 pr_info("registering driver %s\n", hv_driver->name);
1104
1105 ret = vmbus_exists();
1106 if (ret < 0)
1107 return ret;
1108
1109 hv_driver->driver.name = hv_driver->name;
1110 hv_driver->driver.owner = owner;
1111 hv_driver->driver.mod_name = mod_name;
1112 hv_driver->driver.bus = &hv_bus;
1113
1114 spin_lock_init(&hv_driver->dynids.lock);
1115 INIT_LIST_HEAD(&hv_driver->dynids.list);
1116
1117 ret = driver_register(&hv_driver->driver);
1118
1119 return ret;
1120}
1121EXPORT_SYMBOL_GPL(__vmbus_driver_register);
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131void vmbus_driver_unregister(struct hv_driver *hv_driver)
1132{
1133 pr_info("unregistering driver %s\n", hv_driver->name);
1134
1135 if (!vmbus_exists()) {
1136 driver_unregister(&hv_driver->driver);
1137 vmbus_free_dynids(hv_driver);
1138 }
1139}
1140EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
1141
1142
1143
1144
1145
1146static void vmbus_chan_release(struct kobject *kobj)
1147{
1148 struct vmbus_channel *channel
1149 = container_of(kobj, struct vmbus_channel, kobj);
1150
1151 kfree_rcu(channel, rcu);
1152}
1153
1154struct vmbus_chan_attribute {
1155 struct attribute attr;
1156 ssize_t (*show)(const struct vmbus_channel *chan, char *buf);
1157 ssize_t (*store)(struct vmbus_channel *chan,
1158 const char *buf, size_t count);
1159};
1160#define VMBUS_CHAN_ATTR(_name, _mode, _show, _store) \
1161 struct vmbus_chan_attribute chan_attr_##_name \
1162 = __ATTR(_name, _mode, _show, _store)
1163#define VMBUS_CHAN_ATTR_RW(_name) \
1164 struct vmbus_chan_attribute chan_attr_##_name = __ATTR_RW(_name)
1165#define VMBUS_CHAN_ATTR_RO(_name) \
1166 struct vmbus_chan_attribute chan_attr_##_name = __ATTR_RO(_name)
1167#define VMBUS_CHAN_ATTR_WO(_name) \
1168 struct vmbus_chan_attribute chan_attr_##_name = __ATTR_WO(_name)
1169
1170static ssize_t vmbus_chan_attr_show(struct kobject *kobj,
1171 struct attribute *attr, char *buf)
1172{
1173 const struct vmbus_chan_attribute *attribute
1174 = container_of(attr, struct vmbus_chan_attribute, attr);
1175 const struct vmbus_channel *chan
1176 = container_of(kobj, struct vmbus_channel, kobj);
1177
1178 if (!attribute->show)
1179 return -EIO;
1180
1181 return attribute->show(chan, buf);
1182}
1183
1184static const struct sysfs_ops vmbus_chan_sysfs_ops = {
1185 .show = vmbus_chan_attr_show,
1186};
1187
1188static ssize_t out_mask_show(const struct vmbus_channel *channel, char *buf)
1189{
1190 const struct hv_ring_buffer_info *rbi = &channel->outbound;
1191
1192 return sprintf(buf, "%u\n", rbi->ring_buffer->interrupt_mask);
1193}
1194static VMBUS_CHAN_ATTR_RO(out_mask);
1195
1196static ssize_t in_mask_show(const struct vmbus_channel *channel, char *buf)
1197{
1198 const struct hv_ring_buffer_info *rbi = &channel->inbound;
1199
1200 return sprintf(buf, "%u\n", rbi->ring_buffer->interrupt_mask);
1201}
1202static VMBUS_CHAN_ATTR_RO(in_mask);
1203
1204static ssize_t read_avail_show(const struct vmbus_channel *channel, char *buf)
1205{
1206 const struct hv_ring_buffer_info *rbi = &channel->inbound;
1207
1208 return sprintf(buf, "%u\n", hv_get_bytes_to_read(rbi));
1209}
1210static VMBUS_CHAN_ATTR_RO(read_avail);
1211
1212static ssize_t write_avail_show(const struct vmbus_channel *channel, char *buf)
1213{
1214 const struct hv_ring_buffer_info *rbi = &channel->outbound;
1215
1216 return sprintf(buf, "%u\n", hv_get_bytes_to_write(rbi));
1217}
1218static VMBUS_CHAN_ATTR_RO(write_avail);
1219
1220static ssize_t show_target_cpu(const struct vmbus_channel *channel, char *buf)
1221{
1222 return sprintf(buf, "%u\n", channel->target_cpu);
1223}
1224static VMBUS_CHAN_ATTR(cpu, S_IRUGO, show_target_cpu, NULL);
1225
1226static ssize_t channel_pending_show(const struct vmbus_channel *channel,
1227 char *buf)
1228{
1229 return sprintf(buf, "%d\n",
1230 channel_pending(channel,
1231 vmbus_connection.monitor_pages[1]));
1232}
1233static VMBUS_CHAN_ATTR(pending, S_IRUGO, channel_pending_show, NULL);
1234
1235static ssize_t channel_latency_show(const struct vmbus_channel *channel,
1236 char *buf)
1237{
1238 return sprintf(buf, "%d\n",
1239 channel_latency(channel,
1240 vmbus_connection.monitor_pages[1]));
1241}
1242static VMBUS_CHAN_ATTR(latency, S_IRUGO, channel_latency_show, NULL);
1243
1244static ssize_t channel_interrupts_show(const struct vmbus_channel *channel, char *buf)
1245{
1246 return sprintf(buf, "%llu\n", channel->interrupts);
1247}
1248static VMBUS_CHAN_ATTR(interrupts, S_IRUGO, channel_interrupts_show, NULL);
1249
1250static ssize_t channel_events_show(const struct vmbus_channel *channel, char *buf)
1251{
1252 return sprintf(buf, "%llu\n", channel->sig_events);
1253}
1254static VMBUS_CHAN_ATTR(events, S_IRUGO, channel_events_show, NULL);
1255
1256static ssize_t subchannel_monitor_id_show(const struct vmbus_channel *channel,
1257 char *buf)
1258{
1259 return sprintf(buf, "%u\n", channel->offermsg.monitorid);
1260}
1261static VMBUS_CHAN_ATTR(monitor_id, S_IRUGO, subchannel_monitor_id_show, NULL);
1262
1263static ssize_t subchannel_id_show(const struct vmbus_channel *channel,
1264 char *buf)
1265{
1266 return sprintf(buf, "%u\n",
1267 channel->offermsg.offer.sub_channel_index);
1268}
1269static VMBUS_CHAN_ATTR_RO(subchannel_id);
1270
1271static struct attribute *vmbus_chan_attrs[] = {
1272 &chan_attr_out_mask.attr,
1273 &chan_attr_in_mask.attr,
1274 &chan_attr_read_avail.attr,
1275 &chan_attr_write_avail.attr,
1276 &chan_attr_cpu.attr,
1277 &chan_attr_pending.attr,
1278 &chan_attr_latency.attr,
1279 &chan_attr_interrupts.attr,
1280 &chan_attr_events.attr,
1281 &chan_attr_monitor_id.attr,
1282 &chan_attr_subchannel_id.attr,
1283 NULL
1284};
1285
1286static struct kobj_type vmbus_chan_ktype = {
1287 .sysfs_ops = &vmbus_chan_sysfs_ops,
1288 .release = vmbus_chan_release,
1289 .default_attrs = vmbus_chan_attrs,
1290};
1291
1292
1293
1294
1295int vmbus_add_channel_kobj(struct hv_device *dev, struct vmbus_channel *channel)
1296{
1297 struct kobject *kobj = &channel->kobj;
1298 u32 relid = channel->offermsg.child_relid;
1299 int ret;
1300
1301 kobj->kset = dev->channels_kset;
1302 ret = kobject_init_and_add(kobj, &vmbus_chan_ktype, NULL,
1303 "%u", relid);
1304 if (ret)
1305 return ret;
1306
1307 kobject_uevent(kobj, KOBJ_ADD);
1308
1309 return 0;
1310}
1311
1312
1313
1314
1315
1316struct hv_device *vmbus_device_create(const uuid_le *type,
1317 const uuid_le *instance,
1318 struct vmbus_channel *channel)
1319{
1320 struct hv_device *child_device_obj;
1321
1322 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
1323 if (!child_device_obj) {
1324 pr_err("Unable to allocate device object for child device\n");
1325 return NULL;
1326 }
1327
1328 child_device_obj->channel = channel;
1329 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
1330 memcpy(&child_device_obj->dev_instance, instance,
1331 sizeof(uuid_le));
1332 child_device_obj->vendor_id = 0x1414;
1333
1334
1335 return child_device_obj;
1336}
1337
1338
1339
1340
1341int vmbus_device_register(struct hv_device *child_device_obj)
1342{
1343 struct kobject *kobj = &child_device_obj->device.kobj;
1344 int ret;
1345
1346 dev_set_name(&child_device_obj->device, "%pUl",
1347 child_device_obj->channel->offermsg.offer.if_instance.b);
1348
1349 child_device_obj->device.bus = &hv_bus;
1350 child_device_obj->device.parent = &hv_acpi_dev->dev;
1351 child_device_obj->device.release = vmbus_device_release;
1352
1353
1354
1355
1356
1357 ret = device_register(&child_device_obj->device);
1358 if (ret) {
1359 pr_err("Unable to register child device\n");
1360 return ret;
1361 }
1362
1363 child_device_obj->channels_kset = kset_create_and_add("channels",
1364 NULL, kobj);
1365 if (!child_device_obj->channels_kset) {
1366 ret = -ENOMEM;
1367 goto err_dev_unregister;
1368 }
1369
1370 ret = vmbus_add_channel_kobj(child_device_obj,
1371 child_device_obj->channel);
1372 if (ret) {
1373 pr_err("Unable to register primary channeln");
1374 goto err_kset_unregister;
1375 }
1376
1377 return 0;
1378
1379err_kset_unregister:
1380 kset_unregister(child_device_obj->channels_kset);
1381
1382err_dev_unregister:
1383 device_unregister(&child_device_obj->device);
1384 return ret;
1385}
1386
1387
1388
1389
1390
1391void vmbus_device_unregister(struct hv_device *device_obj)
1392{
1393 pr_debug("child device %s unregistered\n",
1394 dev_name(&device_obj->device));
1395
1396 kset_unregister(device_obj->channels_kset);
1397
1398
1399
1400
1401
1402 device_unregister(&device_obj->device);
1403}
1404
1405
1406
1407
1408
1409
1410#define VTPM_BASE_ADDRESS 0xfed40000
1411static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
1412{
1413 resource_size_t start = 0;
1414 resource_size_t end = 0;
1415 struct resource *new_res;
1416 struct resource **old_res = &hyperv_mmio;
1417 struct resource **prev_res = NULL;
1418
1419 switch (res->type) {
1420
1421
1422
1423
1424
1425
1426 case ACPI_RESOURCE_TYPE_ADDRESS32:
1427 start = res->data.address32.address.minimum;
1428 end = res->data.address32.address.maximum;
1429 break;
1430
1431 case ACPI_RESOURCE_TYPE_ADDRESS64:
1432 start = res->data.address64.address.minimum;
1433 end = res->data.address64.address.maximum;
1434 break;
1435
1436 default:
1437
1438 return AE_OK;
1439
1440 }
1441
1442
1443
1444
1445 if (end < 0x100000)
1446 return AE_OK;
1447
1448 new_res = kzalloc(sizeof(*new_res), GFP_ATOMIC);
1449 if (!new_res)
1450 return AE_NO_MEMORY;
1451
1452
1453 if (end > VTPM_BASE_ADDRESS && start < VTPM_BASE_ADDRESS)
1454 end = VTPM_BASE_ADDRESS;
1455
1456 new_res->name = "hyperv mmio";
1457 new_res->flags = IORESOURCE_MEM;
1458 new_res->start = start;
1459 new_res->end = end;
1460
1461
1462
1463
1464 do {
1465 if (!*old_res) {
1466 *old_res = new_res;
1467 break;
1468 }
1469
1470 if (((*old_res)->end + 1) == new_res->start) {
1471 (*old_res)->end = new_res->end;
1472 kfree(new_res);
1473 break;
1474 }
1475
1476 if ((*old_res)->start == new_res->end + 1) {
1477 (*old_res)->start = new_res->start;
1478 kfree(new_res);
1479 break;
1480 }
1481
1482 if ((*old_res)->start > new_res->end) {
1483 new_res->sibling = *old_res;
1484 if (prev_res)
1485 (*prev_res)->sibling = new_res;
1486 *old_res = new_res;
1487 break;
1488 }
1489
1490 prev_res = old_res;
1491 old_res = &(*old_res)->sibling;
1492
1493 } while (1);
1494
1495 return AE_OK;
1496}
1497
1498static int vmbus_acpi_remove(struct acpi_device *device)
1499{
1500 struct resource *cur_res;
1501 struct resource *next_res;
1502
1503 if (hyperv_mmio) {
1504 if (fb_mmio) {
1505 __release_region(hyperv_mmio, fb_mmio->start,
1506 resource_size(fb_mmio));
1507 fb_mmio = NULL;
1508 }
1509
1510 for (cur_res = hyperv_mmio; cur_res; cur_res = next_res) {
1511 next_res = cur_res->sibling;
1512 kfree(cur_res);
1513 }
1514 }
1515
1516 return 0;
1517}
1518
1519static void vmbus_reserve_fb(void)
1520{
1521 int size;
1522
1523
1524
1525
1526
1527
1528
1529 if (screen_info.lfb_base) {
1530 if (efi_enabled(EFI_BOOT))
1531 size = max_t(__u32, screen_info.lfb_size, 0x800000);
1532 else
1533 size = max_t(__u32, screen_info.lfb_size, 0x4000000);
1534
1535 for (; !fb_mmio && (size >= 0x100000); size >>= 1) {
1536 fb_mmio = __request_region(hyperv_mmio,
1537 screen_info.lfb_base, size,
1538 fb_mmio_name, 0);
1539 }
1540 }
1541}
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
1567 resource_size_t min, resource_size_t max,
1568 resource_size_t size, resource_size_t align,
1569 bool fb_overlap_ok)
1570{
1571 struct resource *iter, *shadow;
1572 resource_size_t range_min, range_max, start;
1573 const char *dev_n = dev_name(&device_obj->device);
1574 int retval;
1575
1576 retval = -ENXIO;
1577 down(&hyperv_mmio_lock);
1578
1579
1580
1581
1582
1583
1584 if (fb_overlap_ok && fb_mmio && !(min > fb_mmio->end) &&
1585 !(max < fb_mmio->start)) {
1586
1587 range_min = fb_mmio->start;
1588 range_max = fb_mmio->end;
1589 start = (range_min + align - 1) & ~(align - 1);
1590 for (; start + size - 1 <= range_max; start += align) {
1591 *new = request_mem_region_exclusive(start, size, dev_n);
1592 if (*new) {
1593 retval = 0;
1594 goto exit;
1595 }
1596 }
1597 }
1598
1599 for (iter = hyperv_mmio; iter; iter = iter->sibling) {
1600 if ((iter->start >= max) || (iter->end <= min))
1601 continue;
1602
1603 range_min = iter->start;
1604 range_max = iter->end;
1605 start = (range_min + align - 1) & ~(align - 1);
1606 for (; start + size - 1 <= range_max; start += align) {
1607 shadow = __request_region(iter, start, size, NULL,
1608 IORESOURCE_BUSY);
1609 if (!shadow)
1610 continue;
1611
1612 *new = request_mem_region_exclusive(start, size, dev_n);
1613 if (*new) {
1614 shadow->name = (char *)*new;
1615 retval = 0;
1616 goto exit;
1617 }
1618
1619 __release_region(iter, start, size);
1620 }
1621 }
1622
1623exit:
1624 up(&hyperv_mmio_lock);
1625 return retval;
1626}
1627EXPORT_SYMBOL_GPL(vmbus_allocate_mmio);
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637void vmbus_free_mmio(resource_size_t start, resource_size_t size)
1638{
1639 struct resource *iter;
1640
1641 down(&hyperv_mmio_lock);
1642 for (iter = hyperv_mmio; iter; iter = iter->sibling) {
1643 if ((iter->start >= start + size) || (iter->end <= start))
1644 continue;
1645
1646 __release_region(iter, start, size);
1647 }
1648 release_mem_region(start, size);
1649 up(&hyperv_mmio_lock);
1650
1651}
1652EXPORT_SYMBOL_GPL(vmbus_free_mmio);
1653
1654static int vmbus_acpi_add(struct acpi_device *device)
1655{
1656 acpi_status result;
1657 int ret_val = -ENODEV;
1658 struct acpi_device *ancestor;
1659
1660 hv_acpi_dev = device;
1661
1662 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
1663 vmbus_walk_resources, NULL);
1664
1665 if (ACPI_FAILURE(result))
1666 goto acpi_walk_err;
1667
1668
1669
1670
1671 for (ancestor = device->parent; ancestor; ancestor = ancestor->parent) {
1672 result = acpi_walk_resources(ancestor->handle, METHOD_NAME__CRS,
1673 vmbus_walk_resources, NULL);
1674
1675 if (ACPI_FAILURE(result))
1676 continue;
1677 if (hyperv_mmio) {
1678 vmbus_reserve_fb();
1679 break;
1680 }
1681 }
1682 ret_val = 0;
1683
1684acpi_walk_err:
1685 complete(&probe_event);
1686 if (ret_val)
1687 vmbus_acpi_remove(device);
1688 return ret_val;
1689}
1690
1691static const struct acpi_device_id vmbus_acpi_device_ids[] = {
1692 {"VMBUS", 0},
1693 {"VMBus", 0},
1694 {"", 0},
1695};
1696MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
1697
1698static struct acpi_driver vmbus_acpi_driver = {
1699 .name = "vmbus",
1700 .ids = vmbus_acpi_device_ids,
1701 .ops = {
1702 .add = vmbus_acpi_add,
1703 .remove = vmbus_acpi_remove,
1704 },
1705};
1706
1707static void hv_kexec_handler(void)
1708{
1709 hv_synic_clockevents_cleanup();
1710 vmbus_initiate_unload(false);
1711 vmbus_connection.conn_state = DISCONNECTED;
1712
1713 mb();
1714 cpuhp_remove_state(hyperv_cpuhp_online);
1715 hyperv_cleanup();
1716};
1717
1718static void hv_crash_handler(struct pt_regs *regs)
1719{
1720 vmbus_initiate_unload(true);
1721
1722
1723
1724
1725
1726 vmbus_connection.conn_state = DISCONNECTED;
1727 hv_synic_cleanup(smp_processor_id());
1728 hyperv_cleanup();
1729};
1730
1731static int __init hv_acpi_init(void)
1732{
1733 int ret, t;
1734
1735 if (!hv_is_hyperv_initialized())
1736 return -ENODEV;
1737
1738 init_completion(&probe_event);
1739
1740
1741
1742
1743 ret = acpi_bus_register_driver(&vmbus_acpi_driver);
1744
1745 if (ret)
1746 return ret;
1747
1748 t = wait_for_completion_timeout(&probe_event, 5*HZ);
1749 if (t == 0) {
1750 ret = -ETIMEDOUT;
1751 goto cleanup;
1752 }
1753
1754 ret = vmbus_bus_init();
1755 if (ret)
1756 goto cleanup;
1757
1758 hv_setup_kexec_handler(hv_kexec_handler);
1759 hv_setup_crash_handler(hv_crash_handler);
1760
1761 return 0;
1762
1763cleanup:
1764 acpi_bus_unregister_driver(&vmbus_acpi_driver);
1765 hv_acpi_dev = NULL;
1766 return ret;
1767}
1768
1769static void __exit vmbus_exit(void)
1770{
1771 int cpu;
1772
1773 hv_remove_kexec_handler();
1774 hv_remove_crash_handler();
1775 vmbus_connection.conn_state = DISCONNECTED;
1776 hv_synic_clockevents_cleanup();
1777 vmbus_disconnect();
1778 hv_remove_vmbus_irq();
1779 for_each_online_cpu(cpu) {
1780 struct hv_per_cpu_context *hv_cpu
1781 = per_cpu_ptr(hv_context.cpu_context, cpu);
1782
1783 tasklet_kill(&hv_cpu->msg_dpc);
1784 }
1785 vmbus_free_channels();
1786
1787 if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
1788 unregister_die_notifier(&hyperv_die_block);
1789 atomic_notifier_chain_unregister(&panic_notifier_list,
1790 &hyperv_panic_block);
1791 }
1792 bus_unregister(&hv_bus);
1793
1794 cpuhp_remove_state(hyperv_cpuhp_online);
1795 hv_synic_free();
1796 acpi_bus_unregister_driver(&vmbus_acpi_driver);
1797}
1798
1799
1800MODULE_LICENSE("GPL");
1801
1802subsys_initcall(hv_acpi_init);
1803module_exit(vmbus_exit);
1804