1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2009, Microsoft Corporation.
6 * Haiyang Zhang <haiyangz@microsoft.com>
7 * Hank Janssen <hjanssen@microsoft.com>
8 * K. Y. Srinivasan <kys@microsoft.com>
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/device.h>
15 #include <linux/interrupt.h>
16 #include <linux/sysctl.h>
17 #include <linux/slab.h>
18 #include <linux/acpi.h>
19 #include <linux/completion.h>
20 #include <linux/hyperv.h>
21 #include <linux/kernel_stat.h>
22 #include <linux/clockchips.h>
23 #include <linux/cpu.h>
24 #include <linux/sched/task_stack.h>
26 #include <asm/mshyperv.h>
27 #include <linux/delay.h>
28 #include <linux/notifier.h>
29 #include <linux/ptrace.h>
30 #include <linux/screen_info.h>
31 #include <linux/kdebug.h>
32 #include <linux/efi.h>
33 #include <linux/random.h>
34 #include <linux/syscore_ops.h>
35 #include <clocksource/hyperv_timer.h>
36 #include "hyperv_vmbus.h"
39 struct list_head node
;
40 struct hv_vmbus_device_id id
;
43 static struct acpi_device
*hv_acpi_dev
;
45 static struct completion probe_event
;
47 static int hyperv_cpuhp_online
;
49 static void *hv_panic_page
;
51 static int hyperv_panic_event(struct notifier_block
*nb
, unsigned long val
,
56 regs
= current_pt_regs();
58 hyperv_report_panic(regs
, val
);
62 static int hyperv_die_event(struct notifier_block
*nb
, unsigned long val
,
65 struct die_args
*die
= (struct die_args
*)args
;
66 struct pt_regs
*regs
= die
->regs
;
68 hyperv_report_panic(regs
, val
);
72 static struct notifier_block hyperv_die_block
= {
73 .notifier_call
= hyperv_die_event
,
75 static struct notifier_block hyperv_panic_block
= {
76 .notifier_call
= hyperv_panic_event
,
79 static const char *fb_mmio_name
= "fb_range";
80 static struct resource
*fb_mmio
;
81 static struct resource
*hyperv_mmio
;
82 static DEFINE_MUTEX(hyperv_mmio_lock
);
84 static int vmbus_exists(void)
86 if (hv_acpi_dev
== NULL
)
92 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
93 static void print_alias_name(struct hv_device
*hv_dev
, char *alias_name
)
96 for (i
= 0; i
< VMBUS_ALIAS_LEN
; i
+= 2)
97 sprintf(&alias_name
[i
], "%02x", hv_dev
->dev_type
.b
[i
/2]);
100 static u8
channel_monitor_group(const struct vmbus_channel
*channel
)
102 return (u8
)channel
->offermsg
.monitorid
/ 32;
105 static u8
channel_monitor_offset(const struct vmbus_channel
*channel
)
107 return (u8
)channel
->offermsg
.monitorid
% 32;
110 static u32
channel_pending(const struct vmbus_channel
*channel
,
111 const struct hv_monitor_page
*monitor_page
)
113 u8 monitor_group
= channel_monitor_group(channel
);
115 return monitor_page
->trigger_group
[monitor_group
].pending
;
118 static u32
channel_latency(const struct vmbus_channel
*channel
,
119 const struct hv_monitor_page
*monitor_page
)
121 u8 monitor_group
= channel_monitor_group(channel
);
122 u8 monitor_offset
= channel_monitor_offset(channel
);
124 return monitor_page
->latency
[monitor_group
][monitor_offset
];
127 static u32
channel_conn_id(struct vmbus_channel
*channel
,
128 struct hv_monitor_page
*monitor_page
)
130 u8 monitor_group
= channel_monitor_group(channel
);
131 u8 monitor_offset
= channel_monitor_offset(channel
);
132 return monitor_page
->parameter
[monitor_group
][monitor_offset
].connectionid
.u
.id
;
135 static ssize_t
id_show(struct device
*dev
, struct device_attribute
*dev_attr
,
138 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
140 if (!hv_dev
->channel
)
142 return sprintf(buf
, "%d\n", hv_dev
->channel
->offermsg
.child_relid
);
144 static DEVICE_ATTR_RO(id
);
146 static ssize_t
state_show(struct device
*dev
, struct device_attribute
*dev_attr
,
149 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
151 if (!hv_dev
->channel
)
153 return sprintf(buf
, "%d\n", hv_dev
->channel
->state
);
155 static DEVICE_ATTR_RO(state
);
157 static ssize_t
monitor_id_show(struct device
*dev
,
158 struct device_attribute
*dev_attr
, char *buf
)
160 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
162 if (!hv_dev
->channel
)
164 return sprintf(buf
, "%d\n", hv_dev
->channel
->offermsg
.monitorid
);
166 static DEVICE_ATTR_RO(monitor_id
);
168 static ssize_t
class_id_show(struct device
*dev
,
169 struct device_attribute
*dev_attr
, char *buf
)
171 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
173 if (!hv_dev
->channel
)
175 return sprintf(buf
, "{%pUl}\n",
176 hv_dev
->channel
->offermsg
.offer
.if_type
.b
);
178 static DEVICE_ATTR_RO(class_id
);
180 static ssize_t
device_id_show(struct device
*dev
,
181 struct device_attribute
*dev_attr
, char *buf
)
183 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
185 if (!hv_dev
->channel
)
187 return sprintf(buf
, "{%pUl}\n",
188 hv_dev
->channel
->offermsg
.offer
.if_instance
.b
);
190 static DEVICE_ATTR_RO(device_id
);
192 static ssize_t
modalias_show(struct device
*dev
,
193 struct device_attribute
*dev_attr
, char *buf
)
195 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
196 char alias_name
[VMBUS_ALIAS_LEN
+ 1];
198 print_alias_name(hv_dev
, alias_name
);
199 return sprintf(buf
, "vmbus:%s\n", alias_name
);
201 static DEVICE_ATTR_RO(modalias
);
204 static ssize_t
numa_node_show(struct device
*dev
,
205 struct device_attribute
*attr
, char *buf
)
207 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
209 if (!hv_dev
->channel
)
212 return sprintf(buf
, "%d\n", hv_dev
->channel
->numa_node
);
214 static DEVICE_ATTR_RO(numa_node
);
217 static ssize_t
server_monitor_pending_show(struct device
*dev
,
218 struct device_attribute
*dev_attr
,
221 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
223 if (!hv_dev
->channel
)
225 return sprintf(buf
, "%d\n",
226 channel_pending(hv_dev
->channel
,
227 vmbus_connection
.monitor_pages
[0]));
229 static DEVICE_ATTR_RO(server_monitor_pending
);
231 static ssize_t
client_monitor_pending_show(struct device
*dev
,
232 struct device_attribute
*dev_attr
,
235 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
237 if (!hv_dev
->channel
)
239 return sprintf(buf
, "%d\n",
240 channel_pending(hv_dev
->channel
,
241 vmbus_connection
.monitor_pages
[1]));
243 static DEVICE_ATTR_RO(client_monitor_pending
);
245 static ssize_t
server_monitor_latency_show(struct device
*dev
,
246 struct device_attribute
*dev_attr
,
249 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
251 if (!hv_dev
->channel
)
253 return sprintf(buf
, "%d\n",
254 channel_latency(hv_dev
->channel
,
255 vmbus_connection
.monitor_pages
[0]));
257 static DEVICE_ATTR_RO(server_monitor_latency
);
259 static ssize_t
client_monitor_latency_show(struct device
*dev
,
260 struct device_attribute
*dev_attr
,
263 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
265 if (!hv_dev
->channel
)
267 return sprintf(buf
, "%d\n",
268 channel_latency(hv_dev
->channel
,
269 vmbus_connection
.monitor_pages
[1]));
271 static DEVICE_ATTR_RO(client_monitor_latency
);
273 static ssize_t
server_monitor_conn_id_show(struct device
*dev
,
274 struct device_attribute
*dev_attr
,
277 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
279 if (!hv_dev
->channel
)
281 return sprintf(buf
, "%d\n",
282 channel_conn_id(hv_dev
->channel
,
283 vmbus_connection
.monitor_pages
[0]));
285 static DEVICE_ATTR_RO(server_monitor_conn_id
);
287 static ssize_t
client_monitor_conn_id_show(struct device
*dev
,
288 struct device_attribute
*dev_attr
,
291 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
293 if (!hv_dev
->channel
)
295 return sprintf(buf
, "%d\n",
296 channel_conn_id(hv_dev
->channel
,
297 vmbus_connection
.monitor_pages
[1]));
299 static DEVICE_ATTR_RO(client_monitor_conn_id
);
301 static ssize_t
out_intr_mask_show(struct device
*dev
,
302 struct device_attribute
*dev_attr
, char *buf
)
304 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
305 struct hv_ring_buffer_debug_info outbound
;
308 if (!hv_dev
->channel
)
311 ret
= hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
,
316 return sprintf(buf
, "%d\n", outbound
.current_interrupt_mask
);
318 static DEVICE_ATTR_RO(out_intr_mask
);
320 static ssize_t
out_read_index_show(struct device
*dev
,
321 struct device_attribute
*dev_attr
, char *buf
)
323 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
324 struct hv_ring_buffer_debug_info outbound
;
327 if (!hv_dev
->channel
)
330 ret
= hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
,
334 return sprintf(buf
, "%d\n", outbound
.current_read_index
);
336 static DEVICE_ATTR_RO(out_read_index
);
338 static ssize_t
out_write_index_show(struct device
*dev
,
339 struct device_attribute
*dev_attr
,
342 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
343 struct hv_ring_buffer_debug_info outbound
;
346 if (!hv_dev
->channel
)
349 ret
= hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
,
353 return sprintf(buf
, "%d\n", outbound
.current_write_index
);
355 static DEVICE_ATTR_RO(out_write_index
);
357 static ssize_t
out_read_bytes_avail_show(struct device
*dev
,
358 struct device_attribute
*dev_attr
,
361 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
362 struct hv_ring_buffer_debug_info outbound
;
365 if (!hv_dev
->channel
)
368 ret
= hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
,
372 return sprintf(buf
, "%d\n", outbound
.bytes_avail_toread
);
374 static DEVICE_ATTR_RO(out_read_bytes_avail
);
376 static ssize_t
out_write_bytes_avail_show(struct device
*dev
,
377 struct device_attribute
*dev_attr
,
380 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
381 struct hv_ring_buffer_debug_info outbound
;
384 if (!hv_dev
->channel
)
387 ret
= hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
,
391 return sprintf(buf
, "%d\n", outbound
.bytes_avail_towrite
);
393 static DEVICE_ATTR_RO(out_write_bytes_avail
);
395 static ssize_t
in_intr_mask_show(struct device
*dev
,
396 struct device_attribute
*dev_attr
, char *buf
)
398 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
399 struct hv_ring_buffer_debug_info inbound
;
402 if (!hv_dev
->channel
)
405 ret
= hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
409 return sprintf(buf
, "%d\n", inbound
.current_interrupt_mask
);
411 static DEVICE_ATTR_RO(in_intr_mask
);
413 static ssize_t
in_read_index_show(struct device
*dev
,
414 struct device_attribute
*dev_attr
, char *buf
)
416 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
417 struct hv_ring_buffer_debug_info inbound
;
420 if (!hv_dev
->channel
)
423 ret
= hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
427 return sprintf(buf
, "%d\n", inbound
.current_read_index
);
429 static DEVICE_ATTR_RO(in_read_index
);
431 static ssize_t
in_write_index_show(struct device
*dev
,
432 struct device_attribute
*dev_attr
, char *buf
)
434 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
435 struct hv_ring_buffer_debug_info inbound
;
438 if (!hv_dev
->channel
)
441 ret
= hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
445 return sprintf(buf
, "%d\n", inbound
.current_write_index
);
447 static DEVICE_ATTR_RO(in_write_index
);
449 static ssize_t
in_read_bytes_avail_show(struct device
*dev
,
450 struct device_attribute
*dev_attr
,
453 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
454 struct hv_ring_buffer_debug_info inbound
;
457 if (!hv_dev
->channel
)
460 ret
= hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
464 return sprintf(buf
, "%d\n", inbound
.bytes_avail_toread
);
466 static DEVICE_ATTR_RO(in_read_bytes_avail
);
468 static ssize_t
in_write_bytes_avail_show(struct device
*dev
,
469 struct device_attribute
*dev_attr
,
472 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
473 struct hv_ring_buffer_debug_info inbound
;
476 if (!hv_dev
->channel
)
479 ret
= hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
483 return sprintf(buf
, "%d\n", inbound
.bytes_avail_towrite
);
485 static DEVICE_ATTR_RO(in_write_bytes_avail
);
487 static ssize_t
channel_vp_mapping_show(struct device
*dev
,
488 struct device_attribute
*dev_attr
,
491 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
492 struct vmbus_channel
*channel
= hv_dev
->channel
, *cur_sc
;
494 int buf_size
= PAGE_SIZE
, n_written
, tot_written
;
495 struct list_head
*cur
;
500 tot_written
= snprintf(buf
, buf_size
, "%u:%u\n",
501 channel
->offermsg
.child_relid
, channel
->target_cpu
);
503 spin_lock_irqsave(&channel
->lock
, flags
);
505 list_for_each(cur
, &channel
->sc_list
) {
506 if (tot_written
>= buf_size
- 1)
509 cur_sc
= list_entry(cur
, struct vmbus_channel
, sc_list
);
510 n_written
= scnprintf(buf
+ tot_written
,
511 buf_size
- tot_written
,
513 cur_sc
->offermsg
.child_relid
,
515 tot_written
+= n_written
;
518 spin_unlock_irqrestore(&channel
->lock
, flags
);
522 static DEVICE_ATTR_RO(channel_vp_mapping
);
524 static ssize_t
vendor_show(struct device
*dev
,
525 struct device_attribute
*dev_attr
,
528 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
529 return sprintf(buf
, "0x%x\n", hv_dev
->vendor_id
);
531 static DEVICE_ATTR_RO(vendor
);
533 static ssize_t
device_show(struct device
*dev
,
534 struct device_attribute
*dev_attr
,
537 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
538 return sprintf(buf
, "0x%x\n", hv_dev
->device_id
);
540 static DEVICE_ATTR_RO(device
);
542 static ssize_t
driver_override_store(struct device
*dev
,
543 struct device_attribute
*attr
,
544 const char *buf
, size_t count
)
546 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
547 char *driver_override
, *old
, *cp
;
549 /* We need to keep extra room for a newline */
550 if (count
>= (PAGE_SIZE
- 1))
553 driver_override
= kstrndup(buf
, count
, GFP_KERNEL
);
554 if (!driver_override
)
557 cp
= strchr(driver_override
, '\n');
562 old
= hv_dev
->driver_override
;
563 if (strlen(driver_override
)) {
564 hv_dev
->driver_override
= driver_override
;
566 kfree(driver_override
);
567 hv_dev
->driver_override
= NULL
;
576 static ssize_t
driver_override_show(struct device
*dev
,
577 struct device_attribute
*attr
, char *buf
)
579 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
583 len
= snprintf(buf
, PAGE_SIZE
, "%s\n", hv_dev
->driver_override
);
588 static DEVICE_ATTR_RW(driver_override
);
590 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
591 static struct attribute
*vmbus_dev_attrs
[] = {
593 &dev_attr_state
.attr
,
594 &dev_attr_monitor_id
.attr
,
595 &dev_attr_class_id
.attr
,
596 &dev_attr_device_id
.attr
,
597 &dev_attr_modalias
.attr
,
599 &dev_attr_numa_node
.attr
,
601 &dev_attr_server_monitor_pending
.attr
,
602 &dev_attr_client_monitor_pending
.attr
,
603 &dev_attr_server_monitor_latency
.attr
,
604 &dev_attr_client_monitor_latency
.attr
,
605 &dev_attr_server_monitor_conn_id
.attr
,
606 &dev_attr_client_monitor_conn_id
.attr
,
607 &dev_attr_out_intr_mask
.attr
,
608 &dev_attr_out_read_index
.attr
,
609 &dev_attr_out_write_index
.attr
,
610 &dev_attr_out_read_bytes_avail
.attr
,
611 &dev_attr_out_write_bytes_avail
.attr
,
612 &dev_attr_in_intr_mask
.attr
,
613 &dev_attr_in_read_index
.attr
,
614 &dev_attr_in_write_index
.attr
,
615 &dev_attr_in_read_bytes_avail
.attr
,
616 &dev_attr_in_write_bytes_avail
.attr
,
617 &dev_attr_channel_vp_mapping
.attr
,
618 &dev_attr_vendor
.attr
,
619 &dev_attr_device
.attr
,
620 &dev_attr_driver_override
.attr
,
625 * Device-level attribute_group callback function. Returns the permission for
626 * each attribute, and returns 0 if an attribute is not visible.
628 static umode_t
vmbus_dev_attr_is_visible(struct kobject
*kobj
,
629 struct attribute
*attr
, int idx
)
631 struct device
*dev
= kobj_to_dev(kobj
);
632 const struct hv_device
*hv_dev
= device_to_hv_device(dev
);
634 /* Hide the monitor attributes if the monitor mechanism is not used. */
635 if (!hv_dev
->channel
->offermsg
.monitor_allocated
&&
636 (attr
== &dev_attr_monitor_id
.attr
||
637 attr
== &dev_attr_server_monitor_pending
.attr
||
638 attr
== &dev_attr_client_monitor_pending
.attr
||
639 attr
== &dev_attr_server_monitor_latency
.attr
||
640 attr
== &dev_attr_client_monitor_latency
.attr
||
641 attr
== &dev_attr_server_monitor_conn_id
.attr
||
642 attr
== &dev_attr_client_monitor_conn_id
.attr
))
648 static const struct attribute_group vmbus_dev_group
= {
649 .attrs
= vmbus_dev_attrs
,
650 .is_visible
= vmbus_dev_attr_is_visible
652 __ATTRIBUTE_GROUPS(vmbus_dev
);
655 * vmbus_uevent - add uevent for our device
657 * This routine is invoked when a device is added or removed on the vmbus to
658 * generate a uevent to udev in the userspace. The udev will then look at its
659 * rule and the uevent generated here to load the appropriate driver
661 * The alias string will be of the form vmbus:guid where guid is the string
662 * representation of the device guid (each byte of the guid will be
663 * represented with two hex characters.
665 static int vmbus_uevent(struct device
*device
, struct kobj_uevent_env
*env
)
667 struct hv_device
*dev
= device_to_hv_device(device
);
669 char alias_name
[VMBUS_ALIAS_LEN
+ 1];
671 print_alias_name(dev
, alias_name
);
672 ret
= add_uevent_var(env
, "MODALIAS=vmbus:%s", alias_name
);
676 static const struct hv_vmbus_device_id
*
677 hv_vmbus_dev_match(const struct hv_vmbus_device_id
*id
, const guid_t
*guid
)
680 return NULL
; /* empty device table */
682 for (; !guid_is_null(&id
->guid
); id
++)
683 if (guid_equal(&id
->guid
, guid
))
689 static const struct hv_vmbus_device_id
*
690 hv_vmbus_dynid_match(struct hv_driver
*drv
, const guid_t
*guid
)
692 const struct hv_vmbus_device_id
*id
= NULL
;
693 struct vmbus_dynid
*dynid
;
695 spin_lock(&drv
->dynids
.lock
);
696 list_for_each_entry(dynid
, &drv
->dynids
.list
, node
) {
697 if (guid_equal(&dynid
->id
.guid
, guid
)) {
702 spin_unlock(&drv
->dynids
.lock
);
707 static const struct hv_vmbus_device_id vmbus_device_null
;
710 * Return a matching hv_vmbus_device_id pointer.
711 * If there is no match, return NULL.
713 static const struct hv_vmbus_device_id
*hv_vmbus_get_id(struct hv_driver
*drv
,
714 struct hv_device
*dev
)
716 const guid_t
*guid
= &dev
->dev_type
;
717 const struct hv_vmbus_device_id
*id
;
719 /* When driver_override is set, only bind to the matching driver */
720 if (dev
->driver_override
&& strcmp(dev
->driver_override
, drv
->name
))
723 /* Look at the dynamic ids first, before the static ones */
724 id
= hv_vmbus_dynid_match(drv
, guid
);
726 id
= hv_vmbus_dev_match(drv
->id_table
, guid
);
728 /* driver_override will always match, send a dummy id */
729 if (!id
&& dev
->driver_override
)
730 id
= &vmbus_device_null
;
735 /* vmbus_add_dynid - add a new device ID to this driver and re-probe devices */
736 static int vmbus_add_dynid(struct hv_driver
*drv
, guid_t
*guid
)
738 struct vmbus_dynid
*dynid
;
740 dynid
= kzalloc(sizeof(*dynid
), GFP_KERNEL
);
744 dynid
->id
.guid
= *guid
;
746 spin_lock(&drv
->dynids
.lock
);
747 list_add_tail(&dynid
->node
, &drv
->dynids
.list
);
748 spin_unlock(&drv
->dynids
.lock
);
750 return driver_attach(&drv
->driver
);
753 static void vmbus_free_dynids(struct hv_driver
*drv
)
755 struct vmbus_dynid
*dynid
, *n
;
757 spin_lock(&drv
->dynids
.lock
);
758 list_for_each_entry_safe(dynid
, n
, &drv
->dynids
.list
, node
) {
759 list_del(&dynid
->node
);
762 spin_unlock(&drv
->dynids
.lock
);
766 * store_new_id - sysfs frontend to vmbus_add_dynid()
768 * Allow GUIDs to be added to an existing driver via sysfs.
770 static ssize_t
new_id_store(struct device_driver
*driver
, const char *buf
,
773 struct hv_driver
*drv
= drv_to_hv_drv(driver
);
777 retval
= guid_parse(buf
, &guid
);
781 if (hv_vmbus_dynid_match(drv
, &guid
))
784 retval
= vmbus_add_dynid(drv
, &guid
);
789 static DRIVER_ATTR_WO(new_id
);
792 * store_remove_id - remove a PCI device ID from this driver
794 * Removes a dynamic pci device ID to this driver.
796 static ssize_t
remove_id_store(struct device_driver
*driver
, const char *buf
,
799 struct hv_driver
*drv
= drv_to_hv_drv(driver
);
800 struct vmbus_dynid
*dynid
, *n
;
804 retval
= guid_parse(buf
, &guid
);
809 spin_lock(&drv
->dynids
.lock
);
810 list_for_each_entry_safe(dynid
, n
, &drv
->dynids
.list
, node
) {
811 struct hv_vmbus_device_id
*id
= &dynid
->id
;
813 if (guid_equal(&id
->guid
, &guid
)) {
814 list_del(&dynid
->node
);
820 spin_unlock(&drv
->dynids
.lock
);
824 static DRIVER_ATTR_WO(remove_id
);
826 static struct attribute
*vmbus_drv_attrs
[] = {
827 &driver_attr_new_id
.attr
,
828 &driver_attr_remove_id
.attr
,
831 ATTRIBUTE_GROUPS(vmbus_drv
);
835 * vmbus_match - Attempt to match the specified device to the specified driver
837 static int vmbus_match(struct device
*device
, struct device_driver
*driver
)
839 struct hv_driver
*drv
= drv_to_hv_drv(driver
);
840 struct hv_device
*hv_dev
= device_to_hv_device(device
);
842 /* The hv_sock driver handles all hv_sock offers. */
843 if (is_hvsock_channel(hv_dev
->channel
))
846 if (hv_vmbus_get_id(drv
, hv_dev
))
853 * vmbus_probe - Add the new vmbus's child device
855 static int vmbus_probe(struct device
*child_device
)
858 struct hv_driver
*drv
=
859 drv_to_hv_drv(child_device
->driver
);
860 struct hv_device
*dev
= device_to_hv_device(child_device
);
861 const struct hv_vmbus_device_id
*dev_id
;
863 dev_id
= hv_vmbus_get_id(drv
, dev
);
865 ret
= drv
->probe(dev
, dev_id
);
867 pr_err("probe failed for device %s (%d)\n",
868 dev_name(child_device
), ret
);
871 pr_err("probe not set for driver %s\n",
872 dev_name(child_device
));
879 * vmbus_remove - Remove a vmbus device
881 static int vmbus_remove(struct device
*child_device
)
883 struct hv_driver
*drv
;
884 struct hv_device
*dev
= device_to_hv_device(child_device
);
886 if (child_device
->driver
) {
887 drv
= drv_to_hv_drv(child_device
->driver
);
897 * vmbus_shutdown - Shutdown a vmbus device
899 static void vmbus_shutdown(struct device
*child_device
)
901 struct hv_driver
*drv
;
902 struct hv_device
*dev
= device_to_hv_device(child_device
);
905 /* The device may not be attached yet */
906 if (!child_device
->driver
)
909 drv
= drv_to_hv_drv(child_device
->driver
);
915 #ifdef CONFIG_PM_SLEEP
917 * vmbus_suspend - Suspend a vmbus device
919 static int vmbus_suspend(struct device
*child_device
)
921 struct hv_driver
*drv
;
922 struct hv_device
*dev
= device_to_hv_device(child_device
);
924 /* The device may not be attached yet */
925 if (!child_device
->driver
)
928 drv
= drv_to_hv_drv(child_device
->driver
);
932 return drv
->suspend(dev
);
936 * vmbus_resume - Resume a vmbus device
938 static int vmbus_resume(struct device
*child_device
)
940 struct hv_driver
*drv
;
941 struct hv_device
*dev
= device_to_hv_device(child_device
);
943 /* The device may not be attached yet */
944 if (!child_device
->driver
)
947 drv
= drv_to_hv_drv(child_device
->driver
);
951 return drv
->resume(dev
);
953 #endif /* CONFIG_PM_SLEEP */
956 * vmbus_device_release - Final callback release of the vmbus child device
958 static void vmbus_device_release(struct device
*device
)
960 struct hv_device
*hv_dev
= device_to_hv_device(device
);
961 struct vmbus_channel
*channel
= hv_dev
->channel
;
963 hv_debug_rm_dev_dir(hv_dev
);
965 mutex_lock(&vmbus_connection
.channel_mutex
);
966 hv_process_channel_removal(channel
);
967 mutex_unlock(&vmbus_connection
.channel_mutex
);
972 * Note: we must use SET_NOIRQ_SYSTEM_SLEEP_PM_OPS rather than
973 * SET_SYSTEM_SLEEP_PM_OPS: see the comment before vmbus_bus_pm.
975 static const struct dev_pm_ops vmbus_pm
= {
976 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(vmbus_suspend
, vmbus_resume
)
979 /* The one and only one */
980 static struct bus_type hv_bus
= {
982 .match
= vmbus_match
,
983 .shutdown
= vmbus_shutdown
,
984 .remove
= vmbus_remove
,
985 .probe
= vmbus_probe
,
986 .uevent
= vmbus_uevent
,
987 .dev_groups
= vmbus_dev_groups
,
988 .drv_groups
= vmbus_drv_groups
,
992 struct onmessage_work_context
{
993 struct work_struct work
;
994 struct hv_message msg
;
997 static void vmbus_onmessage_work(struct work_struct
*work
)
999 struct onmessage_work_context
*ctx
;
1001 /* Do not process messages if we're in DISCONNECTED state */
1002 if (vmbus_connection
.conn_state
== DISCONNECTED
)
1005 ctx
= container_of(work
, struct onmessage_work_context
,
1007 vmbus_onmessage(&ctx
->msg
);
1011 void vmbus_on_msg_dpc(unsigned long data
)
1013 struct hv_per_cpu_context
*hv_cpu
= (void *)data
;
1014 void *page_addr
= hv_cpu
->synic_message_page
;
1015 struct hv_message
*msg
= (struct hv_message
*)page_addr
+
1017 struct vmbus_channel_message_header
*hdr
;
1018 const struct vmbus_channel_message_table_entry
*entry
;
1019 struct onmessage_work_context
*ctx
;
1020 u32 message_type
= msg
->header
.message_type
;
1022 if (message_type
== HVMSG_NONE
)
1026 hdr
= (struct vmbus_channel_message_header
*)msg
->u
.payload
;
1028 trace_vmbus_on_msg_dpc(hdr
);
1030 if (hdr
->msgtype
>= CHANNELMSG_COUNT
) {
1031 WARN_ONCE(1, "unknown msgtype=%d\n", hdr
->msgtype
);
1035 entry
= &channel_message_table
[hdr
->msgtype
];
1036 if (entry
->handler_type
== VMHT_BLOCKING
) {
1037 ctx
= kmalloc(sizeof(*ctx
), GFP_ATOMIC
);
1041 INIT_WORK(&ctx
->work
, vmbus_onmessage_work
);
1042 memcpy(&ctx
->msg
, msg
, sizeof(*msg
));
1045 * The host can generate a rescind message while we
1046 * may still be handling the original offer. We deal with
1047 * this condition by ensuring the processing is done on the
1050 switch (hdr
->msgtype
) {
1051 case CHANNELMSG_RESCIND_CHANNELOFFER
:
1053 * If we are handling the rescind message;
1054 * schedule the work on the global work queue.
1056 schedule_work_on(vmbus_connection
.connect_cpu
,
1060 case CHANNELMSG_OFFERCHANNEL
:
1061 atomic_inc(&vmbus_connection
.offer_in_progress
);
1062 queue_work_on(vmbus_connection
.connect_cpu
,
1063 vmbus_connection
.work_queue
,
1068 queue_work(vmbus_connection
.work_queue
, &ctx
->work
);
1071 entry
->message_handler(hdr
);
1074 vmbus_signal_eom(msg
, message_type
);
1077 #ifdef CONFIG_PM_SLEEP
1079 * Fake RESCIND_CHANNEL messages to clean up hv_sock channels by force for
1080 * hibernation, because hv_sock connections can not persist across hibernation.
1082 static void vmbus_force_channel_rescinded(struct vmbus_channel
*channel
)
1084 struct onmessage_work_context
*ctx
;
1085 struct vmbus_channel_rescind_offer
*rescind
;
1087 WARN_ON(!is_hvsock_channel(channel
));
1090 * sizeof(*ctx) is small and the allocation should really not fail,
1091 * otherwise the state of the hv_sock connections ends up in limbo.
1093 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
| __GFP_NOFAIL
);
1096 * So far, these are not really used by Linux. Just set them to the
1097 * reasonable values conforming to the definitions of the fields.
1099 ctx
->msg
.header
.message_type
= 1;
1100 ctx
->msg
.header
.payload_size
= sizeof(*rescind
);
1102 /* These values are actually used by Linux. */
1103 rescind
= (struct vmbus_channel_rescind_offer
*)ctx
->msg
.u
.payload
;
1104 rescind
->header
.msgtype
= CHANNELMSG_RESCIND_CHANNELOFFER
;
1105 rescind
->child_relid
= channel
->offermsg
.child_relid
;
1107 INIT_WORK(&ctx
->work
, vmbus_onmessage_work
);
1109 queue_work_on(vmbus_connection
.connect_cpu
,
1110 vmbus_connection
.work_queue
,
1113 #endif /* CONFIG_PM_SLEEP */
1116 * Direct callback for channels using other deferred processing
1118 static void vmbus_channel_isr(struct vmbus_channel
*channel
)
1120 void (*callback_fn
)(void *);
1122 callback_fn
= READ_ONCE(channel
->onchannel_callback
);
1123 if (likely(callback_fn
!= NULL
))
1124 (*callback_fn
)(channel
->channel_callback_context
);
1128 * Schedule all channels with events pending
1130 static void vmbus_chan_sched(struct hv_per_cpu_context
*hv_cpu
)
1132 unsigned long *recv_int_page
;
1135 if (vmbus_proto_version
< VERSION_WIN8
) {
1136 maxbits
= MAX_NUM_CHANNELS_SUPPORTED
;
1137 recv_int_page
= vmbus_connection
.recv_int_page
;
1140 * When the host is win8 and beyond, the event page
1141 * can be directly checked to get the id of the channel
1142 * that has the interrupt pending.
1144 void *page_addr
= hv_cpu
->synic_event_page
;
1145 union hv_synic_event_flags
*event
1146 = (union hv_synic_event_flags
*)page_addr
+
1149 maxbits
= HV_EVENT_FLAGS_COUNT
;
1150 recv_int_page
= event
->flags
;
1153 if (unlikely(!recv_int_page
))
1156 for_each_set_bit(relid
, recv_int_page
, maxbits
) {
1157 struct vmbus_channel
*channel
;
1159 if (!sync_test_and_clear_bit(relid
, recv_int_page
))
1162 /* Special case - vmbus channel protocol msg */
1168 /* Find channel based on relid */
1169 list_for_each_entry_rcu(channel
, &hv_cpu
->chan_list
, percpu_list
) {
1170 if (channel
->offermsg
.child_relid
!= relid
)
1173 if (channel
->rescind
)
1176 trace_vmbus_chan_sched(channel
);
1178 ++channel
->interrupts
;
1180 switch (channel
->callback_mode
) {
1182 vmbus_channel_isr(channel
);
1185 case HV_CALL_BATCHED
:
1186 hv_begin_read(&channel
->inbound
);
1188 case HV_CALL_DIRECT
:
1189 tasklet_schedule(&channel
->callback_event
);
1197 static void vmbus_isr(void)
1199 struct hv_per_cpu_context
*hv_cpu
1200 = this_cpu_ptr(hv_context
.cpu_context
);
1201 void *page_addr
= hv_cpu
->synic_event_page
;
1202 struct hv_message
*msg
;
1203 union hv_synic_event_flags
*event
;
1204 bool handled
= false;
1206 if (unlikely(page_addr
== NULL
))
1209 event
= (union hv_synic_event_flags
*)page_addr
+
1212 * Check for events before checking for messages. This is the order
1213 * in which events and messages are checked in Windows guests on
1214 * Hyper-V, and the Windows team suggested we do the same.
1217 if ((vmbus_proto_version
== VERSION_WS2008
) ||
1218 (vmbus_proto_version
== VERSION_WIN7
)) {
1220 /* Since we are a child, we only need to check bit 0 */
1221 if (sync_test_and_clear_bit(0, event
->flags
))
1225 * Our host is win8 or above. The signaling mechanism
1226 * has changed and we can directly look at the event page.
1227 * If bit n is set then we have an interrup on the channel
1234 vmbus_chan_sched(hv_cpu
);
1236 page_addr
= hv_cpu
->synic_message_page
;
1237 msg
= (struct hv_message
*)page_addr
+ VMBUS_MESSAGE_SINT
;
1239 /* Check if there are actual msgs to be processed */
1240 if (msg
->header
.message_type
!= HVMSG_NONE
) {
1241 if (msg
->header
.message_type
== HVMSG_TIMER_EXPIRED
) {
1243 vmbus_signal_eom(msg
, HVMSG_TIMER_EXPIRED
);
1245 tasklet_schedule(&hv_cpu
->msg_dpc
);
1248 add_interrupt_randomness(HYPERVISOR_CALLBACK_VECTOR
, 0);
1252 * Boolean to control whether to report panic messages over Hyper-V.
1254 * It can be set via /proc/sys/kernel/hyperv/record_panic_msg
1256 static int sysctl_record_panic_msg
= 1;
1259 * Callback from kmsg_dump. Grab as much as possible from the end of the kmsg
1260 * buffer and call into Hyper-V to transfer the data.
1262 static void hv_kmsg_dump(struct kmsg_dumper
*dumper
,
1263 enum kmsg_dump_reason reason
)
1265 size_t bytes_written
;
1266 phys_addr_t panic_pa
;
1268 /* We are only interested in panics. */
1269 if ((reason
!= KMSG_DUMP_PANIC
) || (!sysctl_record_panic_msg
))
1272 panic_pa
= virt_to_phys(hv_panic_page
);
1275 * Write dump contents to the page. No need to synchronize; panic should
1276 * be single-threaded.
1278 kmsg_dump_get_buffer(dumper
, true, hv_panic_page
, HV_HYP_PAGE_SIZE
,
1281 hyperv_report_panic_msg(panic_pa
, bytes_written
);
1284 static struct kmsg_dumper hv_kmsg_dumper
= {
1285 .dump
= hv_kmsg_dump
,
1288 static struct ctl_table_header
*hv_ctl_table_hdr
;
1291 * sysctl option to allow the user to control whether kmsg data should be
1292 * reported to Hyper-V on panic.
1294 static struct ctl_table hv_ctl_table
[] = {
1296 .procname
= "hyperv_record_panic_msg",
1297 .data
= &sysctl_record_panic_msg
,
1298 .maxlen
= sizeof(int),
1300 .proc_handler
= proc_dointvec_minmax
,
1301 .extra1
= SYSCTL_ZERO
,
1302 .extra2
= SYSCTL_ONE
1307 static struct ctl_table hv_root_table
[] = {
1309 .procname
= "kernel",
1311 .child
= hv_ctl_table
1317 * vmbus_bus_init -Main vmbus driver initialization routine.
1320 * - initialize the vmbus driver context
1321 * - invoke the vmbus hv main init routine
1322 * - retrieve the channel offers
1324 static int vmbus_bus_init(void)
1328 /* Hypervisor initialization...setup hypercall page..etc */
1331 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret
);
1335 ret
= bus_register(&hv_bus
);
1339 hv_setup_vmbus_irq(vmbus_isr
);
1341 ret
= hv_synic_alloc();
1346 * Initialize the per-cpu interrupt state and stimer state.
1347 * Then connect to the host.
1349 ret
= cpuhp_setup_state(CPUHP_AP_ONLINE_DYN
, "hyperv/vmbus:online",
1350 hv_synic_init
, hv_synic_cleanup
);
1353 hyperv_cpuhp_online
= ret
;
1355 ret
= vmbus_connect();
1360 * Only register if the crash MSRs are available
1362 if (ms_hyperv
.misc_features
& HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE
) {
1363 u64 hyperv_crash_ctl
;
1365 * Sysctl registration is not fatal, since by default
1366 * reporting is enabled.
1368 hv_ctl_table_hdr
= register_sysctl_table(hv_root_table
);
1369 if (!hv_ctl_table_hdr
)
1370 pr_err("Hyper-V: sysctl table register error");
1373 * Register for panic kmsg callback only if the right
1374 * capability is supported by the hypervisor.
1376 hv_get_crash_ctl(hyperv_crash_ctl
);
1377 if (hyperv_crash_ctl
& HV_CRASH_CTL_CRASH_NOTIFY_MSG
) {
1378 hv_panic_page
= (void *)hv_alloc_hyperv_zeroed_page();
1379 if (hv_panic_page
) {
1380 ret
= kmsg_dump_register(&hv_kmsg_dumper
);
1382 pr_err("Hyper-V: kmsg dump register "
1383 "error 0x%x\n", ret
);
1385 pr_err("Hyper-V: panic message page memory "
1386 "allocation failed");
1389 register_die_notifier(&hyperv_die_block
);
1390 atomic_notifier_chain_register(&panic_notifier_list
,
1391 &hyperv_panic_block
);
1394 vmbus_request_offers();
1399 cpuhp_remove_state(hyperv_cpuhp_online
);
1403 hv_remove_vmbus_irq();
1405 bus_unregister(&hv_bus
);
1406 hv_free_hyperv_page((unsigned long)hv_panic_page
);
1407 unregister_sysctl_table(hv_ctl_table_hdr
);
1408 hv_ctl_table_hdr
= NULL
;
1413 * __vmbus_child_driver_register() - Register a vmbus's driver
1414 * @hv_driver: Pointer to driver structure you want to register
1415 * @owner: owner module of the drv
1416 * @mod_name: module name string
1418 * Registers the given driver with Linux through the 'driver_register()' call
1419 * and sets up the hyper-v vmbus handling for this driver.
1420 * It will return the state of the 'driver_register()' call.
1423 int __vmbus_driver_register(struct hv_driver
*hv_driver
, struct module
*owner
, const char *mod_name
)
1427 pr_info("registering driver %s\n", hv_driver
->name
);
1429 ret
= vmbus_exists();
1433 hv_driver
->driver
.name
= hv_driver
->name
;
1434 hv_driver
->driver
.owner
= owner
;
1435 hv_driver
->driver
.mod_name
= mod_name
;
1436 hv_driver
->driver
.bus
= &hv_bus
;
1438 spin_lock_init(&hv_driver
->dynids
.lock
);
1439 INIT_LIST_HEAD(&hv_driver
->dynids
.list
);
1441 ret
= driver_register(&hv_driver
->driver
);
1445 EXPORT_SYMBOL_GPL(__vmbus_driver_register
);
1448 * vmbus_driver_unregister() - Unregister a vmbus's driver
1449 * @hv_driver: Pointer to driver structure you want to
1452 * Un-register the given driver that was previous registered with a call to
1453 * vmbus_driver_register()
1455 void vmbus_driver_unregister(struct hv_driver
*hv_driver
)
1457 pr_info("unregistering driver %s\n", hv_driver
->name
);
1459 if (!vmbus_exists()) {
1460 driver_unregister(&hv_driver
->driver
);
1461 vmbus_free_dynids(hv_driver
);
1464 EXPORT_SYMBOL_GPL(vmbus_driver_unregister
);
1468 * Called when last reference to channel is gone.
1470 static void vmbus_chan_release(struct kobject
*kobj
)
1472 struct vmbus_channel
*channel
1473 = container_of(kobj
, struct vmbus_channel
, kobj
);
1475 kfree_rcu(channel
, rcu
);
1478 struct vmbus_chan_attribute
{
1479 struct attribute attr
;
1480 ssize_t (*show
)(struct vmbus_channel
*chan
, char *buf
);
1481 ssize_t (*store
)(struct vmbus_channel
*chan
,
1482 const char *buf
, size_t count
);
1484 #define VMBUS_CHAN_ATTR(_name, _mode, _show, _store) \
1485 struct vmbus_chan_attribute chan_attr_##_name \
1486 = __ATTR(_name, _mode, _show, _store)
1487 #define VMBUS_CHAN_ATTR_RW(_name) \
1488 struct vmbus_chan_attribute chan_attr_##_name = __ATTR_RW(_name)
1489 #define VMBUS_CHAN_ATTR_RO(_name) \
1490 struct vmbus_chan_attribute chan_attr_##_name = __ATTR_RO(_name)
1491 #define VMBUS_CHAN_ATTR_WO(_name) \
1492 struct vmbus_chan_attribute chan_attr_##_name = __ATTR_WO(_name)
1494 static ssize_t
vmbus_chan_attr_show(struct kobject
*kobj
,
1495 struct attribute
*attr
, char *buf
)
1497 const struct vmbus_chan_attribute
*attribute
1498 = container_of(attr
, struct vmbus_chan_attribute
, attr
);
1499 struct vmbus_channel
*chan
1500 = container_of(kobj
, struct vmbus_channel
, kobj
);
1502 if (!attribute
->show
)
1505 return attribute
->show(chan
, buf
);
1508 static const struct sysfs_ops vmbus_chan_sysfs_ops
= {
1509 .show
= vmbus_chan_attr_show
,
1512 static ssize_t
out_mask_show(struct vmbus_channel
*channel
, char *buf
)
1514 struct hv_ring_buffer_info
*rbi
= &channel
->outbound
;
1517 mutex_lock(&rbi
->ring_buffer_mutex
);
1518 if (!rbi
->ring_buffer
) {
1519 mutex_unlock(&rbi
->ring_buffer_mutex
);
1523 ret
= sprintf(buf
, "%u\n", rbi
->ring_buffer
->interrupt_mask
);
1524 mutex_unlock(&rbi
->ring_buffer_mutex
);
1527 static VMBUS_CHAN_ATTR_RO(out_mask
);
1529 static ssize_t
in_mask_show(struct vmbus_channel
*channel
, char *buf
)
1531 struct hv_ring_buffer_info
*rbi
= &channel
->inbound
;
1534 mutex_lock(&rbi
->ring_buffer_mutex
);
1535 if (!rbi
->ring_buffer
) {
1536 mutex_unlock(&rbi
->ring_buffer_mutex
);
1540 ret
= sprintf(buf
, "%u\n", rbi
->ring_buffer
->interrupt_mask
);
1541 mutex_unlock(&rbi
->ring_buffer_mutex
);
1544 static VMBUS_CHAN_ATTR_RO(in_mask
);
1546 static ssize_t
read_avail_show(struct vmbus_channel
*channel
, char *buf
)
1548 struct hv_ring_buffer_info
*rbi
= &channel
->inbound
;
1551 mutex_lock(&rbi
->ring_buffer_mutex
);
1552 if (!rbi
->ring_buffer
) {
1553 mutex_unlock(&rbi
->ring_buffer_mutex
);
1557 ret
= sprintf(buf
, "%u\n", hv_get_bytes_to_read(rbi
));
1558 mutex_unlock(&rbi
->ring_buffer_mutex
);
1561 static VMBUS_CHAN_ATTR_RO(read_avail
);
1563 static ssize_t
write_avail_show(struct vmbus_channel
*channel
, char *buf
)
1565 struct hv_ring_buffer_info
*rbi
= &channel
->outbound
;
1568 mutex_lock(&rbi
->ring_buffer_mutex
);
1569 if (!rbi
->ring_buffer
) {
1570 mutex_unlock(&rbi
->ring_buffer_mutex
);
1574 ret
= sprintf(buf
, "%u\n", hv_get_bytes_to_write(rbi
));
1575 mutex_unlock(&rbi
->ring_buffer_mutex
);
1578 static VMBUS_CHAN_ATTR_RO(write_avail
);
1580 static ssize_t
show_target_cpu(struct vmbus_channel
*channel
, char *buf
)
1582 return sprintf(buf
, "%u\n", channel
->target_cpu
);
1584 static VMBUS_CHAN_ATTR(cpu
, S_IRUGO
, show_target_cpu
, NULL
);
1586 static ssize_t
channel_pending_show(struct vmbus_channel
*channel
,
1589 return sprintf(buf
, "%d\n",
1590 channel_pending(channel
,
1591 vmbus_connection
.monitor_pages
[1]));
1593 static VMBUS_CHAN_ATTR(pending
, S_IRUGO
, channel_pending_show
, NULL
);
1595 static ssize_t
channel_latency_show(struct vmbus_channel
*channel
,
1598 return sprintf(buf
, "%d\n",
1599 channel_latency(channel
,
1600 vmbus_connection
.monitor_pages
[1]));
1602 static VMBUS_CHAN_ATTR(latency
, S_IRUGO
, channel_latency_show
, NULL
);
1604 static ssize_t
channel_interrupts_show(struct vmbus_channel
*channel
, char *buf
)
1606 return sprintf(buf
, "%llu\n", channel
->interrupts
);
1608 static VMBUS_CHAN_ATTR(interrupts
, S_IRUGO
, channel_interrupts_show
, NULL
);
1610 static ssize_t
channel_events_show(struct vmbus_channel
*channel
, char *buf
)
1612 return sprintf(buf
, "%llu\n", channel
->sig_events
);
1614 static VMBUS_CHAN_ATTR(events
, S_IRUGO
, channel_events_show
, NULL
);
1616 static ssize_t
channel_intr_in_full_show(struct vmbus_channel
*channel
,
1619 return sprintf(buf
, "%llu\n",
1620 (unsigned long long)channel
->intr_in_full
);
1622 static VMBUS_CHAN_ATTR(intr_in_full
, 0444, channel_intr_in_full_show
, NULL
);
1624 static ssize_t
channel_intr_out_empty_show(struct vmbus_channel
*channel
,
1627 return sprintf(buf
, "%llu\n",
1628 (unsigned long long)channel
->intr_out_empty
);
1630 static VMBUS_CHAN_ATTR(intr_out_empty
, 0444, channel_intr_out_empty_show
, NULL
);
1632 static ssize_t
channel_out_full_first_show(struct vmbus_channel
*channel
,
1635 return sprintf(buf
, "%llu\n",
1636 (unsigned long long)channel
->out_full_first
);
1638 static VMBUS_CHAN_ATTR(out_full_first
, 0444, channel_out_full_first_show
, NULL
);
1640 static ssize_t
channel_out_full_total_show(struct vmbus_channel
*channel
,
1643 return sprintf(buf
, "%llu\n",
1644 (unsigned long long)channel
->out_full_total
);
1646 static VMBUS_CHAN_ATTR(out_full_total
, 0444, channel_out_full_total_show
, NULL
);
1648 static ssize_t
subchannel_monitor_id_show(struct vmbus_channel
*channel
,
1651 return sprintf(buf
, "%u\n", channel
->offermsg
.monitorid
);
1653 static VMBUS_CHAN_ATTR(monitor_id
, S_IRUGO
, subchannel_monitor_id_show
, NULL
);
1655 static ssize_t
subchannel_id_show(struct vmbus_channel
*channel
,
1658 return sprintf(buf
, "%u\n",
1659 channel
->offermsg
.offer
.sub_channel_index
);
1661 static VMBUS_CHAN_ATTR_RO(subchannel_id
);
1663 static struct attribute
*vmbus_chan_attrs
[] = {
1664 &chan_attr_out_mask
.attr
,
1665 &chan_attr_in_mask
.attr
,
1666 &chan_attr_read_avail
.attr
,
1667 &chan_attr_write_avail
.attr
,
1668 &chan_attr_cpu
.attr
,
1669 &chan_attr_pending
.attr
,
1670 &chan_attr_latency
.attr
,
1671 &chan_attr_interrupts
.attr
,
1672 &chan_attr_events
.attr
,
1673 &chan_attr_intr_in_full
.attr
,
1674 &chan_attr_intr_out_empty
.attr
,
1675 &chan_attr_out_full_first
.attr
,
1676 &chan_attr_out_full_total
.attr
,
1677 &chan_attr_monitor_id
.attr
,
1678 &chan_attr_subchannel_id
.attr
,
1683 * Channel-level attribute_group callback function. Returns the permission for
1684 * each attribute, and returns 0 if an attribute is not visible.
1686 static umode_t
vmbus_chan_attr_is_visible(struct kobject
*kobj
,
1687 struct attribute
*attr
, int idx
)
1689 const struct vmbus_channel
*channel
=
1690 container_of(kobj
, struct vmbus_channel
, kobj
);
1692 /* Hide the monitor attributes if the monitor mechanism is not used. */
1693 if (!channel
->offermsg
.monitor_allocated
&&
1694 (attr
== &chan_attr_pending
.attr
||
1695 attr
== &chan_attr_latency
.attr
||
1696 attr
== &chan_attr_monitor_id
.attr
))
1702 static struct attribute_group vmbus_chan_group
= {
1703 .attrs
= vmbus_chan_attrs
,
1704 .is_visible
= vmbus_chan_attr_is_visible
1707 static struct kobj_type vmbus_chan_ktype
= {
1708 .sysfs_ops
= &vmbus_chan_sysfs_ops
,
1709 .release
= vmbus_chan_release
,
1713 * vmbus_add_channel_kobj - setup a sub-directory under device/channels
1715 int vmbus_add_channel_kobj(struct hv_device
*dev
, struct vmbus_channel
*channel
)
1717 const struct device
*device
= &dev
->device
;
1718 struct kobject
*kobj
= &channel
->kobj
;
1719 u32 relid
= channel
->offermsg
.child_relid
;
1722 kobj
->kset
= dev
->channels_kset
;
1723 ret
= kobject_init_and_add(kobj
, &vmbus_chan_ktype
, NULL
,
1728 ret
= sysfs_create_group(kobj
, &vmbus_chan_group
);
1732 * The calling functions' error handling paths will cleanup the
1733 * empty channel directory.
1735 dev_err(device
, "Unable to set up channel sysfs files\n");
1739 kobject_uevent(kobj
, KOBJ_ADD
);
1745 * vmbus_remove_channel_attr_group - remove the channel's attribute group
1747 void vmbus_remove_channel_attr_group(struct vmbus_channel
*channel
)
1749 sysfs_remove_group(&channel
->kobj
, &vmbus_chan_group
);
1753 * vmbus_device_create - Creates and registers a new child device
1756 struct hv_device
*vmbus_device_create(const guid_t
*type
,
1757 const guid_t
*instance
,
1758 struct vmbus_channel
*channel
)
1760 struct hv_device
*child_device_obj
;
1762 child_device_obj
= kzalloc(sizeof(struct hv_device
), GFP_KERNEL
);
1763 if (!child_device_obj
) {
1764 pr_err("Unable to allocate device object for child device\n");
1768 child_device_obj
->channel
= channel
;
1769 guid_copy(&child_device_obj
->dev_type
, type
);
1770 guid_copy(&child_device_obj
->dev_instance
, instance
);
1771 child_device_obj
->vendor_id
= 0x1414; /* MSFT vendor ID */
1773 return child_device_obj
;
1777 * vmbus_device_register - Register the child device
1779 int vmbus_device_register(struct hv_device
*child_device_obj
)
1781 struct kobject
*kobj
= &child_device_obj
->device
.kobj
;
1784 dev_set_name(&child_device_obj
->device
, "%pUl",
1785 child_device_obj
->channel
->offermsg
.offer
.if_instance
.b
);
1787 child_device_obj
->device
.bus
= &hv_bus
;
1788 child_device_obj
->device
.parent
= &hv_acpi_dev
->dev
;
1789 child_device_obj
->device
.release
= vmbus_device_release
;
1792 * Register with the LDM. This will kick off the driver/device
1793 * binding...which will eventually call vmbus_match() and vmbus_probe()
1795 ret
= device_register(&child_device_obj
->device
);
1797 pr_err("Unable to register child device\n");
1801 child_device_obj
->channels_kset
= kset_create_and_add("channels",
1803 if (!child_device_obj
->channels_kset
) {
1805 goto err_dev_unregister
;
1808 ret
= vmbus_add_channel_kobj(child_device_obj
,
1809 child_device_obj
->channel
);
1811 pr_err("Unable to register primary channeln");
1812 goto err_kset_unregister
;
1814 hv_debug_add_dev_dir(child_device_obj
);
1818 err_kset_unregister
:
1819 kset_unregister(child_device_obj
->channels_kset
);
1822 device_unregister(&child_device_obj
->device
);
1827 * vmbus_device_unregister - Remove the specified child device
1830 void vmbus_device_unregister(struct hv_device
*device_obj
)
1832 pr_debug("child device %s unregistered\n",
1833 dev_name(&device_obj
->device
));
1835 kset_unregister(device_obj
->channels_kset
);
1838 * Kick off the process of unregistering the device.
1839 * This will call vmbus_remove() and eventually vmbus_device_release()
1841 device_unregister(&device_obj
->device
);
1846 * VMBUS is an acpi enumerated device. Get the information we
1849 #define VTPM_BASE_ADDRESS 0xfed40000
1850 static acpi_status
vmbus_walk_resources(struct acpi_resource
*res
, void *ctx
)
1852 resource_size_t start
= 0;
1853 resource_size_t end
= 0;
1854 struct resource
*new_res
;
1855 struct resource
**old_res
= &hyperv_mmio
;
1856 struct resource
**prev_res
= NULL
;
1858 switch (res
->type
) {
1861 * "Address" descriptors are for bus windows. Ignore
1862 * "memory" descriptors, which are for registers on
1865 case ACPI_RESOURCE_TYPE_ADDRESS32
:
1866 start
= res
->data
.address32
.address
.minimum
;
1867 end
= res
->data
.address32
.address
.maximum
;
1870 case ACPI_RESOURCE_TYPE_ADDRESS64
:
1871 start
= res
->data
.address64
.address
.minimum
;
1872 end
= res
->data
.address64
.address
.maximum
;
1876 /* Unused resource type */
1881 * Ignore ranges that are below 1MB, as they're not
1882 * necessary or useful here.
1887 new_res
= kzalloc(sizeof(*new_res
), GFP_ATOMIC
);
1889 return AE_NO_MEMORY
;
1891 /* If this range overlaps the virtual TPM, truncate it. */
1892 if (end
> VTPM_BASE_ADDRESS
&& start
< VTPM_BASE_ADDRESS
)
1893 end
= VTPM_BASE_ADDRESS
;
1895 new_res
->name
= "hyperv mmio";
1896 new_res
->flags
= IORESOURCE_MEM
;
1897 new_res
->start
= start
;
1901 * If two ranges are adjacent, merge them.
1909 if (((*old_res
)->end
+ 1) == new_res
->start
) {
1910 (*old_res
)->end
= new_res
->end
;
1915 if ((*old_res
)->start
== new_res
->end
+ 1) {
1916 (*old_res
)->start
= new_res
->start
;
1921 if ((*old_res
)->start
> new_res
->end
) {
1922 new_res
->sibling
= *old_res
;
1924 (*prev_res
)->sibling
= new_res
;
1930 old_res
= &(*old_res
)->sibling
;
1937 static int vmbus_acpi_remove(struct acpi_device
*device
)
1939 struct resource
*cur_res
;
1940 struct resource
*next_res
;
1944 __release_region(hyperv_mmio
, fb_mmio
->start
,
1945 resource_size(fb_mmio
));
1949 for (cur_res
= hyperv_mmio
; cur_res
; cur_res
= next_res
) {
1950 next_res
= cur_res
->sibling
;
1958 static void vmbus_reserve_fb(void)
1962 * Make a claim for the frame buffer in the resource tree under the
1963 * first node, which will be the one below 4GB. The length seems to
1964 * be underreported, particularly in a Generation 1 VM. So start out
1965 * reserving a larger area and make it smaller until it succeeds.
1968 if (screen_info
.lfb_base
) {
1969 if (efi_enabled(EFI_BOOT
))
1970 size
= max_t(__u32
, screen_info
.lfb_size
, 0x800000);
1972 size
= max_t(__u32
, screen_info
.lfb_size
, 0x4000000);
1974 for (; !fb_mmio
&& (size
>= 0x100000); size
>>= 1) {
1975 fb_mmio
= __request_region(hyperv_mmio
,
1976 screen_info
.lfb_base
, size
,
1983 * vmbus_allocate_mmio() - Pick a memory-mapped I/O range.
1984 * @new: If successful, supplied a pointer to the
1985 * allocated MMIO space.
1986 * @device_obj: Identifies the caller
1987 * @min: Minimum guest physical address of the
1989 * @max: Maximum guest physical address
1990 * @size: Size of the range to be allocated
1991 * @align: Alignment of the range to be allocated
1992 * @fb_overlap_ok: Whether this allocation can be allowed
1993 * to overlap the video frame buffer.
1995 * This function walks the resources granted to VMBus by the
1996 * _CRS object in the ACPI namespace underneath the parent
1997 * "bridge" whether that's a root PCI bus in the Generation 1
1998 * case or a Module Device in the Generation 2 case. It then
1999 * attempts to allocate from the global MMIO pool in a way that
2000 * matches the constraints supplied in these parameters and by
2003 * Return: 0 on success, -errno on failure
2005 int vmbus_allocate_mmio(struct resource
**new, struct hv_device
*device_obj
,
2006 resource_size_t min
, resource_size_t max
,
2007 resource_size_t size
, resource_size_t align
,
2010 struct resource
*iter
, *shadow
;
2011 resource_size_t range_min
, range_max
, start
;
2012 const char *dev_n
= dev_name(&device_obj
->device
);
2016 mutex_lock(&hyperv_mmio_lock
);
2019 * If overlaps with frame buffers are allowed, then first attempt to
2020 * make the allocation from within the reserved region. Because it
2021 * is already reserved, no shadow allocation is necessary.
2023 if (fb_overlap_ok
&& fb_mmio
&& !(min
> fb_mmio
->end
) &&
2024 !(max
< fb_mmio
->start
)) {
2026 range_min
= fb_mmio
->start
;
2027 range_max
= fb_mmio
->end
;
2028 start
= (range_min
+ align
- 1) & ~(align
- 1);
2029 for (; start
+ size
- 1 <= range_max
; start
+= align
) {
2030 *new = request_mem_region_exclusive(start
, size
, dev_n
);
2038 for (iter
= hyperv_mmio
; iter
; iter
= iter
->sibling
) {
2039 if ((iter
->start
>= max
) || (iter
->end
<= min
))
2042 range_min
= iter
->start
;
2043 range_max
= iter
->end
;
2044 start
= (range_min
+ align
- 1) & ~(align
- 1);
2045 for (; start
+ size
- 1 <= range_max
; start
+= align
) {
2046 shadow
= __request_region(iter
, start
, size
, NULL
,
2051 *new = request_mem_region_exclusive(start
, size
, dev_n
);
2053 shadow
->name
= (char *)*new;
2058 __release_region(iter
, start
, size
);
2063 mutex_unlock(&hyperv_mmio_lock
);
2066 EXPORT_SYMBOL_GPL(vmbus_allocate_mmio
);
2069 * vmbus_free_mmio() - Free a memory-mapped I/O range.
2070 * @start: Base address of region to release.
2071 * @size: Size of the range to be allocated
2073 * This function releases anything requested by
2074 * vmbus_mmio_allocate().
2076 void vmbus_free_mmio(resource_size_t start
, resource_size_t size
)
2078 struct resource
*iter
;
2080 mutex_lock(&hyperv_mmio_lock
);
2081 for (iter
= hyperv_mmio
; iter
; iter
= iter
->sibling
) {
2082 if ((iter
->start
>= start
+ size
) || (iter
->end
<= start
))
2085 __release_region(iter
, start
, size
);
2087 release_mem_region(start
, size
);
2088 mutex_unlock(&hyperv_mmio_lock
);
2091 EXPORT_SYMBOL_GPL(vmbus_free_mmio
);
2093 static int vmbus_acpi_add(struct acpi_device
*device
)
2096 int ret_val
= -ENODEV
;
2097 struct acpi_device
*ancestor
;
2099 hv_acpi_dev
= device
;
2101 result
= acpi_walk_resources(device
->handle
, METHOD_NAME__CRS
,
2102 vmbus_walk_resources
, NULL
);
2104 if (ACPI_FAILURE(result
))
2107 * Some ancestor of the vmbus acpi device (Gen1 or Gen2
2108 * firmware) is the VMOD that has the mmio ranges. Get that.
2110 for (ancestor
= device
->parent
; ancestor
; ancestor
= ancestor
->parent
) {
2111 result
= acpi_walk_resources(ancestor
->handle
, METHOD_NAME__CRS
,
2112 vmbus_walk_resources
, NULL
);
2114 if (ACPI_FAILURE(result
))
2124 complete(&probe_event
);
2126 vmbus_acpi_remove(device
);
2130 #ifdef CONFIG_PM_SLEEP
2131 static int vmbus_bus_suspend(struct device
*dev
)
2133 struct vmbus_channel
*channel
, *sc
;
2134 unsigned long flags
;
2136 while (atomic_read(&vmbus_connection
.offer_in_progress
) != 0) {
2138 * We wait here until the completion of any channel
2139 * offers that are currently in progress.
2144 mutex_lock(&vmbus_connection
.channel_mutex
);
2145 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
2146 if (!is_hvsock_channel(channel
))
2149 vmbus_force_channel_rescinded(channel
);
2151 mutex_unlock(&vmbus_connection
.channel_mutex
);
2154 * Wait until all the sub-channels and hv_sock channels have been
2155 * cleaned up. Sub-channels should be destroyed upon suspend, otherwise
2156 * they would conflict with the new sub-channels that will be created
2157 * in the resume path. hv_sock channels should also be destroyed, but
2158 * a hv_sock channel of an established hv_sock connection can not be
2159 * really destroyed since it may still be referenced by the userspace
2160 * application, so we just force the hv_sock channel to be rescinded
2161 * by vmbus_force_channel_rescinded(), and the userspace application
2162 * will thoroughly destroy the channel after hibernation.
2164 * Note: the counter nr_chan_close_on_suspend may never go above 0 if
2165 * the VM has no sub-channel and hv_sock channel, e.g. a 1-vCPU VM.
2167 if (atomic_read(&vmbus_connection
.nr_chan_close_on_suspend
) > 0)
2168 wait_for_completion(&vmbus_connection
.ready_for_suspend_event
);
2170 WARN_ON(atomic_read(&vmbus_connection
.nr_chan_fixup_on_resume
) != 0);
2172 mutex_lock(&vmbus_connection
.channel_mutex
);
2174 list_for_each_entry(channel
, &vmbus_connection
.chn_list
, listentry
) {
2176 * Invalidate the field. Upon resume, vmbus_onoffer() will fix
2177 * up the field, and the other fields (if necessary).
2179 channel
->offermsg
.child_relid
= INVALID_RELID
;
2181 if (is_hvsock_channel(channel
)) {
2182 if (!channel
->rescind
) {
2183 pr_err("hv_sock channel not rescinded!\n");
2189 spin_lock_irqsave(&channel
->lock
, flags
);
2190 list_for_each_entry(sc
, &channel
->sc_list
, sc_list
) {
2191 pr_err("Sub-channel not deleted!\n");
2194 spin_unlock_irqrestore(&channel
->lock
, flags
);
2196 atomic_inc(&vmbus_connection
.nr_chan_fixup_on_resume
);
2199 mutex_unlock(&vmbus_connection
.channel_mutex
);
2201 vmbus_initiate_unload(false);
2203 vmbus_connection
.conn_state
= DISCONNECTED
;
2205 /* Reset the event for the next resume. */
2206 reinit_completion(&vmbus_connection
.ready_for_resume_event
);
2211 static int vmbus_bus_resume(struct device
*dev
)
2213 struct vmbus_channel_msginfo
*msginfo
;
2218 * We only use the 'vmbus_proto_version', which was in use before
2219 * hibernation, to re-negotiate with the host.
2221 if (!vmbus_proto_version
) {
2222 pr_err("Invalid proto version = 0x%x\n", vmbus_proto_version
);
2226 msgsize
= sizeof(*msginfo
) +
2227 sizeof(struct vmbus_channel_initiate_contact
);
2229 msginfo
= kzalloc(msgsize
, GFP_KERNEL
);
2231 if (msginfo
== NULL
)
2234 ret
= vmbus_negotiate_version(msginfo
, vmbus_proto_version
);
2241 WARN_ON(atomic_read(&vmbus_connection
.nr_chan_fixup_on_resume
) == 0);
2243 vmbus_request_offers();
2245 wait_for_completion(&vmbus_connection
.ready_for_resume_event
);
2247 /* Reset the event for the next suspend. */
2248 reinit_completion(&vmbus_connection
.ready_for_suspend_event
);
2252 #endif /* CONFIG_PM_SLEEP */
2254 static const struct acpi_device_id vmbus_acpi_device_ids
[] = {
2259 MODULE_DEVICE_TABLE(acpi
, vmbus_acpi_device_ids
);
2262 * Note: we must use SET_NOIRQ_SYSTEM_SLEEP_PM_OPS rather than
2263 * SET_SYSTEM_SLEEP_PM_OPS, otherwise NIC SR-IOV can not work, because the
2264 * "pci_dev_pm_ops" uses the "noirq" callbacks: in the resume path, the
2265 * pci "noirq" restore callback runs before "non-noirq" callbacks (see
2266 * resume_target_kernel() -> dpm_resume_start(), and hibernation_restore() ->
2267 * dpm_resume_end()). This means vmbus_bus_resume() and the pci-hyperv's
2268 * resume callback must also run via the "noirq" callbacks.
2270 static const struct dev_pm_ops vmbus_bus_pm
= {
2271 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(vmbus_bus_suspend
, vmbus_bus_resume
)
2274 static struct acpi_driver vmbus_acpi_driver
= {
2276 .ids
= vmbus_acpi_device_ids
,
2278 .add
= vmbus_acpi_add
,
2279 .remove
= vmbus_acpi_remove
,
2281 .drv
.pm
= &vmbus_bus_pm
,
2284 static void hv_kexec_handler(void)
2286 hv_stimer_global_cleanup();
2287 vmbus_initiate_unload(false);
2288 vmbus_connection
.conn_state
= DISCONNECTED
;
2289 /* Make sure conn_state is set as hv_synic_cleanup checks for it */
2291 cpuhp_remove_state(hyperv_cpuhp_online
);
2295 static void hv_crash_handler(struct pt_regs
*regs
)
2299 vmbus_initiate_unload(true);
2301 * In crash handler we can't schedule synic cleanup for all CPUs,
2302 * doing the cleanup for current CPU only. This should be sufficient
2305 vmbus_connection
.conn_state
= DISCONNECTED
;
2306 cpu
= smp_processor_id();
2307 hv_stimer_cleanup(cpu
);
2308 hv_synic_disable_regs(cpu
);
2312 static int hv_synic_suspend(void)
2315 * When we reach here, all the non-boot CPUs have been offlined.
2316 * If we're in a legacy configuration where stimer Direct Mode is
2317 * not enabled, the stimers on the non-boot CPUs have been unbound
2318 * in hv_synic_cleanup() -> hv_stimer_legacy_cleanup() ->
2319 * hv_stimer_cleanup() -> clockevents_unbind_device().
2321 * hv_synic_suspend() only runs on CPU0 with interrupts disabled.
2322 * Here we do not call hv_stimer_legacy_cleanup() on CPU0 because:
2323 * 1) it's unnecessary as interrupts remain disabled between
2324 * syscore_suspend() and syscore_resume(): see create_image() and
2325 * resume_target_kernel()
2326 * 2) the stimer on CPU0 is automatically disabled later by
2327 * syscore_suspend() -> timekeeping_suspend() -> tick_suspend() -> ...
2328 * -> clockevents_shutdown() -> ... -> hv_ce_shutdown()
2329 * 3) a warning would be triggered if we call
2330 * clockevents_unbind_device(), which may sleep, in an
2331 * interrupts-disabled context.
2334 hv_synic_disable_regs(0);
2339 static void hv_synic_resume(void)
2341 hv_synic_enable_regs(0);
2344 * Note: we don't need to call hv_stimer_init(0), because the timer
2345 * on CPU0 is not unbound in hv_synic_suspend(), and the timer is
2346 * automatically re-enabled in timekeeping_resume().
2350 /* The callbacks run only on CPU0, with irqs_disabled. */
2351 static struct syscore_ops hv_synic_syscore_ops
= {
2352 .suspend
= hv_synic_suspend
,
2353 .resume
= hv_synic_resume
,
2356 static int __init
hv_acpi_init(void)
2360 if (!hv_is_hyperv_initialized())
2363 init_completion(&probe_event
);
2366 * Get ACPI resources first.
2368 ret
= acpi_bus_register_driver(&vmbus_acpi_driver
);
2373 t
= wait_for_completion_timeout(&probe_event
, 5*HZ
);
2380 ret
= vmbus_bus_init();
2384 hv_setup_kexec_handler(hv_kexec_handler
);
2385 hv_setup_crash_handler(hv_crash_handler
);
2387 register_syscore_ops(&hv_synic_syscore_ops
);
2392 acpi_bus_unregister_driver(&vmbus_acpi_driver
);
2397 static void __exit
vmbus_exit(void)
2401 unregister_syscore_ops(&hv_synic_syscore_ops
);
2403 hv_remove_kexec_handler();
2404 hv_remove_crash_handler();
2405 vmbus_connection
.conn_state
= DISCONNECTED
;
2406 hv_stimer_global_cleanup();
2408 hv_remove_vmbus_irq();
2409 for_each_online_cpu(cpu
) {
2410 struct hv_per_cpu_context
*hv_cpu
2411 = per_cpu_ptr(hv_context
.cpu_context
, cpu
);
2413 tasklet_kill(&hv_cpu
->msg_dpc
);
2415 hv_debug_rm_all_dir();
2417 vmbus_free_channels();
2419 if (ms_hyperv
.misc_features
& HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE
) {
2420 kmsg_dump_unregister(&hv_kmsg_dumper
);
2421 unregister_die_notifier(&hyperv_die_block
);
2422 atomic_notifier_chain_unregister(&panic_notifier_list
,
2423 &hyperv_panic_block
);
2426 free_page((unsigned long)hv_panic_page
);
2427 unregister_sysctl_table(hv_ctl_table_hdr
);
2428 hv_ctl_table_hdr
= NULL
;
2429 bus_unregister(&hv_bus
);
2431 cpuhp_remove_state(hyperv_cpuhp_online
);
2433 acpi_bus_unregister_driver(&vmbus_acpi_driver
);
2437 MODULE_LICENSE("GPL");
2438 MODULE_DESCRIPTION("Microsoft Hyper-V VMBus Driver");
2440 subsys_initcall(hv_acpi_init
);
2441 module_exit(vmbus_exit
);