2 * Copyright (c) 2009, Microsoft Corporation.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307 USA.
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
20 * K. Y. Srinivasan <kys@microsoft.com>
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
39 #include <asm/hyperv.h>
40 #include <asm/hypervisor.h>
41 #include <asm/mshyperv.h>
42 #include <linux/notifier.h>
43 #include <linux/ptrace.h>
44 #include <linux/screen_info.h>
45 #include <linux/kdebug.h>
46 #include <linux/efi.h>
47 #include <linux/random.h>
48 #include "hyperv_vmbus.h"
51 struct list_head node
;
52 struct hv_vmbus_device_id id
;
55 static struct acpi_device
*hv_acpi_dev
;
57 static struct completion probe_event
;
59 static int hyperv_cpuhp_online
;
61 static int hyperv_panic_event(struct notifier_block
*nb
, unsigned long val
,
66 regs
= current_pt_regs();
68 hyperv_report_panic(regs
, val
);
72 static int hyperv_die_event(struct notifier_block
*nb
, unsigned long val
,
75 struct die_args
*die
= (struct die_args
*)args
;
76 struct pt_regs
*regs
= die
->regs
;
78 hyperv_report_panic(regs
, val
);
82 static struct notifier_block hyperv_die_block
= {
83 .notifier_call
= hyperv_die_event
,
85 static struct notifier_block hyperv_panic_block
= {
86 .notifier_call
= hyperv_panic_event
,
89 static const char *fb_mmio_name
= "fb_range";
90 static struct resource
*fb_mmio
;
91 static struct resource
*hyperv_mmio
;
92 static DEFINE_SEMAPHORE(hyperv_mmio_lock
);
94 static int vmbus_exists(void)
96 if (hv_acpi_dev
== NULL
)
102 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
103 static void print_alias_name(struct hv_device
*hv_dev
, char *alias_name
)
106 for (i
= 0; i
< VMBUS_ALIAS_LEN
; i
+= 2)
107 sprintf(&alias_name
[i
], "%02x", hv_dev
->dev_type
.b
[i
/2]);
110 static u8
channel_monitor_group(const struct vmbus_channel
*channel
)
112 return (u8
)channel
->offermsg
.monitorid
/ 32;
115 static u8
channel_monitor_offset(const struct vmbus_channel
*channel
)
117 return (u8
)channel
->offermsg
.monitorid
% 32;
120 static u32
channel_pending(const struct vmbus_channel
*channel
,
121 const struct hv_monitor_page
*monitor_page
)
123 u8 monitor_group
= channel_monitor_group(channel
);
125 return monitor_page
->trigger_group
[monitor_group
].pending
;
128 static u32
channel_latency(const struct vmbus_channel
*channel
,
129 const struct hv_monitor_page
*monitor_page
)
131 u8 monitor_group
= channel_monitor_group(channel
);
132 u8 monitor_offset
= channel_monitor_offset(channel
);
134 return monitor_page
->latency
[monitor_group
][monitor_offset
];
137 static u32
channel_conn_id(struct vmbus_channel
*channel
,
138 struct hv_monitor_page
*monitor_page
)
140 u8 monitor_group
= channel_monitor_group(channel
);
141 u8 monitor_offset
= channel_monitor_offset(channel
);
142 return monitor_page
->parameter
[monitor_group
][monitor_offset
].connectionid
.u
.id
;
145 static ssize_t
id_show(struct device
*dev
, struct device_attribute
*dev_attr
,
148 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
150 if (!hv_dev
->channel
)
152 return sprintf(buf
, "%d\n", hv_dev
->channel
->offermsg
.child_relid
);
154 static DEVICE_ATTR_RO(id
);
156 static ssize_t
state_show(struct device
*dev
, struct device_attribute
*dev_attr
,
159 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
161 if (!hv_dev
->channel
)
163 return sprintf(buf
, "%d\n", hv_dev
->channel
->state
);
165 static DEVICE_ATTR_RO(state
);
167 static ssize_t
monitor_id_show(struct device
*dev
,
168 struct device_attribute
*dev_attr
, char *buf
)
170 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
172 if (!hv_dev
->channel
)
174 return sprintf(buf
, "%d\n", hv_dev
->channel
->offermsg
.monitorid
);
176 static DEVICE_ATTR_RO(monitor_id
);
178 static ssize_t
class_id_show(struct device
*dev
,
179 struct device_attribute
*dev_attr
, char *buf
)
181 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
183 if (!hv_dev
->channel
)
185 return sprintf(buf
, "{%pUl}\n",
186 hv_dev
->channel
->offermsg
.offer
.if_type
.b
);
188 static DEVICE_ATTR_RO(class_id
);
190 static ssize_t
device_id_show(struct device
*dev
,
191 struct device_attribute
*dev_attr
, char *buf
)
193 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
195 if (!hv_dev
->channel
)
197 return sprintf(buf
, "{%pUl}\n",
198 hv_dev
->channel
->offermsg
.offer
.if_instance
.b
);
200 static DEVICE_ATTR_RO(device_id
);
202 static ssize_t
modalias_show(struct device
*dev
,
203 struct device_attribute
*dev_attr
, char *buf
)
205 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
206 char alias_name
[VMBUS_ALIAS_LEN
+ 1];
208 print_alias_name(hv_dev
, alias_name
);
209 return sprintf(buf
, "vmbus:%s\n", alias_name
);
211 static DEVICE_ATTR_RO(modalias
);
213 static ssize_t
server_monitor_pending_show(struct device
*dev
,
214 struct device_attribute
*dev_attr
,
217 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
219 if (!hv_dev
->channel
)
221 return sprintf(buf
, "%d\n",
222 channel_pending(hv_dev
->channel
,
223 vmbus_connection
.monitor_pages
[1]));
225 static DEVICE_ATTR_RO(server_monitor_pending
);
227 static ssize_t
client_monitor_pending_show(struct device
*dev
,
228 struct device_attribute
*dev_attr
,
231 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
233 if (!hv_dev
->channel
)
235 return sprintf(buf
, "%d\n",
236 channel_pending(hv_dev
->channel
,
237 vmbus_connection
.monitor_pages
[1]));
239 static DEVICE_ATTR_RO(client_monitor_pending
);
241 static ssize_t
server_monitor_latency_show(struct device
*dev
,
242 struct device_attribute
*dev_attr
,
245 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
247 if (!hv_dev
->channel
)
249 return sprintf(buf
, "%d\n",
250 channel_latency(hv_dev
->channel
,
251 vmbus_connection
.monitor_pages
[0]));
253 static DEVICE_ATTR_RO(server_monitor_latency
);
255 static ssize_t
client_monitor_latency_show(struct device
*dev
,
256 struct device_attribute
*dev_attr
,
259 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
261 if (!hv_dev
->channel
)
263 return sprintf(buf
, "%d\n",
264 channel_latency(hv_dev
->channel
,
265 vmbus_connection
.monitor_pages
[1]));
267 static DEVICE_ATTR_RO(client_monitor_latency
);
269 static ssize_t
server_monitor_conn_id_show(struct device
*dev
,
270 struct device_attribute
*dev_attr
,
273 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
275 if (!hv_dev
->channel
)
277 return sprintf(buf
, "%d\n",
278 channel_conn_id(hv_dev
->channel
,
279 vmbus_connection
.monitor_pages
[0]));
281 static DEVICE_ATTR_RO(server_monitor_conn_id
);
283 static ssize_t
client_monitor_conn_id_show(struct device
*dev
,
284 struct device_attribute
*dev_attr
,
287 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
289 if (!hv_dev
->channel
)
291 return sprintf(buf
, "%d\n",
292 channel_conn_id(hv_dev
->channel
,
293 vmbus_connection
.monitor_pages
[1]));
295 static DEVICE_ATTR_RO(client_monitor_conn_id
);
297 static ssize_t
out_intr_mask_show(struct device
*dev
,
298 struct device_attribute
*dev_attr
, char *buf
)
300 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
301 struct hv_ring_buffer_debug_info outbound
;
303 if (!hv_dev
->channel
)
305 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
306 return sprintf(buf
, "%d\n", outbound
.current_interrupt_mask
);
308 static DEVICE_ATTR_RO(out_intr_mask
);
310 static ssize_t
out_read_index_show(struct device
*dev
,
311 struct device_attribute
*dev_attr
, char *buf
)
313 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
314 struct hv_ring_buffer_debug_info outbound
;
316 if (!hv_dev
->channel
)
318 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
319 return sprintf(buf
, "%d\n", outbound
.current_read_index
);
321 static DEVICE_ATTR_RO(out_read_index
);
323 static ssize_t
out_write_index_show(struct device
*dev
,
324 struct device_attribute
*dev_attr
,
327 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
328 struct hv_ring_buffer_debug_info outbound
;
330 if (!hv_dev
->channel
)
332 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
333 return sprintf(buf
, "%d\n", outbound
.current_write_index
);
335 static DEVICE_ATTR_RO(out_write_index
);
337 static ssize_t
out_read_bytes_avail_show(struct device
*dev
,
338 struct device_attribute
*dev_attr
,
341 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
342 struct hv_ring_buffer_debug_info outbound
;
344 if (!hv_dev
->channel
)
346 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
347 return sprintf(buf
, "%d\n", outbound
.bytes_avail_toread
);
349 static DEVICE_ATTR_RO(out_read_bytes_avail
);
351 static ssize_t
out_write_bytes_avail_show(struct device
*dev
,
352 struct device_attribute
*dev_attr
,
355 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
356 struct hv_ring_buffer_debug_info outbound
;
358 if (!hv_dev
->channel
)
360 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
361 return sprintf(buf
, "%d\n", outbound
.bytes_avail_towrite
);
363 static DEVICE_ATTR_RO(out_write_bytes_avail
);
365 static ssize_t
in_intr_mask_show(struct device
*dev
,
366 struct device_attribute
*dev_attr
, char *buf
)
368 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
369 struct hv_ring_buffer_debug_info inbound
;
371 if (!hv_dev
->channel
)
373 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
374 return sprintf(buf
, "%d\n", inbound
.current_interrupt_mask
);
376 static DEVICE_ATTR_RO(in_intr_mask
);
378 static ssize_t
in_read_index_show(struct device
*dev
,
379 struct device_attribute
*dev_attr
, char *buf
)
381 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
382 struct hv_ring_buffer_debug_info inbound
;
384 if (!hv_dev
->channel
)
386 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
387 return sprintf(buf
, "%d\n", inbound
.current_read_index
);
389 static DEVICE_ATTR_RO(in_read_index
);
391 static ssize_t
in_write_index_show(struct device
*dev
,
392 struct device_attribute
*dev_attr
, char *buf
)
394 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
395 struct hv_ring_buffer_debug_info inbound
;
397 if (!hv_dev
->channel
)
399 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
400 return sprintf(buf
, "%d\n", inbound
.current_write_index
);
402 static DEVICE_ATTR_RO(in_write_index
);
404 static ssize_t
in_read_bytes_avail_show(struct device
*dev
,
405 struct device_attribute
*dev_attr
,
408 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
409 struct hv_ring_buffer_debug_info inbound
;
411 if (!hv_dev
->channel
)
413 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
414 return sprintf(buf
, "%d\n", inbound
.bytes_avail_toread
);
416 static DEVICE_ATTR_RO(in_read_bytes_avail
);
418 static ssize_t
in_write_bytes_avail_show(struct device
*dev
,
419 struct device_attribute
*dev_attr
,
422 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
423 struct hv_ring_buffer_debug_info inbound
;
425 if (!hv_dev
->channel
)
427 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
428 return sprintf(buf
, "%d\n", inbound
.bytes_avail_towrite
);
430 static DEVICE_ATTR_RO(in_write_bytes_avail
);
432 static ssize_t
channel_vp_mapping_show(struct device
*dev
,
433 struct device_attribute
*dev_attr
,
436 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
437 struct vmbus_channel
*channel
= hv_dev
->channel
, *cur_sc
;
439 int buf_size
= PAGE_SIZE
, n_written
, tot_written
;
440 struct list_head
*cur
;
445 tot_written
= snprintf(buf
, buf_size
, "%u:%u\n",
446 channel
->offermsg
.child_relid
, channel
->target_cpu
);
448 spin_lock_irqsave(&channel
->lock
, flags
);
450 list_for_each(cur
, &channel
->sc_list
) {
451 if (tot_written
>= buf_size
- 1)
454 cur_sc
= list_entry(cur
, struct vmbus_channel
, sc_list
);
455 n_written
= scnprintf(buf
+ tot_written
,
456 buf_size
- tot_written
,
458 cur_sc
->offermsg
.child_relid
,
460 tot_written
+= n_written
;
463 spin_unlock_irqrestore(&channel
->lock
, flags
);
467 static DEVICE_ATTR_RO(channel_vp_mapping
);
469 static ssize_t
vendor_show(struct device
*dev
,
470 struct device_attribute
*dev_attr
,
473 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
474 return sprintf(buf
, "0x%x\n", hv_dev
->vendor_id
);
476 static DEVICE_ATTR_RO(vendor
);
478 static ssize_t
device_show(struct device
*dev
,
479 struct device_attribute
*dev_attr
,
482 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
483 return sprintf(buf
, "0x%x\n", hv_dev
->device_id
);
485 static DEVICE_ATTR_RO(device
);
487 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
488 static struct attribute
*vmbus_dev_attrs
[] = {
490 &dev_attr_state
.attr
,
491 &dev_attr_monitor_id
.attr
,
492 &dev_attr_class_id
.attr
,
493 &dev_attr_device_id
.attr
,
494 &dev_attr_modalias
.attr
,
495 &dev_attr_server_monitor_pending
.attr
,
496 &dev_attr_client_monitor_pending
.attr
,
497 &dev_attr_server_monitor_latency
.attr
,
498 &dev_attr_client_monitor_latency
.attr
,
499 &dev_attr_server_monitor_conn_id
.attr
,
500 &dev_attr_client_monitor_conn_id
.attr
,
501 &dev_attr_out_intr_mask
.attr
,
502 &dev_attr_out_read_index
.attr
,
503 &dev_attr_out_write_index
.attr
,
504 &dev_attr_out_read_bytes_avail
.attr
,
505 &dev_attr_out_write_bytes_avail
.attr
,
506 &dev_attr_in_intr_mask
.attr
,
507 &dev_attr_in_read_index
.attr
,
508 &dev_attr_in_write_index
.attr
,
509 &dev_attr_in_read_bytes_avail
.attr
,
510 &dev_attr_in_write_bytes_avail
.attr
,
511 &dev_attr_channel_vp_mapping
.attr
,
512 &dev_attr_vendor
.attr
,
513 &dev_attr_device
.attr
,
516 ATTRIBUTE_GROUPS(vmbus_dev
);
519 * vmbus_uevent - add uevent for our device
521 * This routine is invoked when a device is added or removed on the vmbus to
522 * generate a uevent to udev in the userspace. The udev will then look at its
523 * rule and the uevent generated here to load the appropriate driver
525 * The alias string will be of the form vmbus:guid where guid is the string
526 * representation of the device guid (each byte of the guid will be
527 * represented with two hex characters.
529 static int vmbus_uevent(struct device
*device
, struct kobj_uevent_env
*env
)
531 struct hv_device
*dev
= device_to_hv_device(device
);
533 char alias_name
[VMBUS_ALIAS_LEN
+ 1];
535 print_alias_name(dev
, alias_name
);
536 ret
= add_uevent_var(env
, "MODALIAS=vmbus:%s", alias_name
);
540 static const uuid_le null_guid
;
542 static inline bool is_null_guid(const uuid_le
*guid
)
544 if (uuid_le_cmp(*guid
, null_guid
))
550 * Return a matching hv_vmbus_device_id pointer.
551 * If there is no match, return NULL.
553 static const struct hv_vmbus_device_id
*hv_vmbus_get_id(struct hv_driver
*drv
,
556 const struct hv_vmbus_device_id
*id
= NULL
;
557 struct vmbus_dynid
*dynid
;
559 /* Look at the dynamic ids first, before the static ones */
560 spin_lock(&drv
->dynids
.lock
);
561 list_for_each_entry(dynid
, &drv
->dynids
.list
, node
) {
562 if (!uuid_le_cmp(dynid
->id
.guid
, *guid
)) {
567 spin_unlock(&drv
->dynids
.lock
);
574 return NULL
; /* empty device table */
576 for (; !is_null_guid(&id
->guid
); id
++)
577 if (!uuid_le_cmp(id
->guid
, *guid
))
583 /* vmbus_add_dynid - add a new device ID to this driver and re-probe devices */
584 static int vmbus_add_dynid(struct hv_driver
*drv
, uuid_le
*guid
)
586 struct vmbus_dynid
*dynid
;
588 dynid
= kzalloc(sizeof(*dynid
), GFP_KERNEL
);
592 dynid
->id
.guid
= *guid
;
594 spin_lock(&drv
->dynids
.lock
);
595 list_add_tail(&dynid
->node
, &drv
->dynids
.list
);
596 spin_unlock(&drv
->dynids
.lock
);
598 return driver_attach(&drv
->driver
);
601 static void vmbus_free_dynids(struct hv_driver
*drv
)
603 struct vmbus_dynid
*dynid
, *n
;
605 spin_lock(&drv
->dynids
.lock
);
606 list_for_each_entry_safe(dynid
, n
, &drv
->dynids
.list
, node
) {
607 list_del(&dynid
->node
);
610 spin_unlock(&drv
->dynids
.lock
);
614 * store_new_id - sysfs frontend to vmbus_add_dynid()
616 * Allow GUIDs to be added to an existing driver via sysfs.
618 static ssize_t
new_id_store(struct device_driver
*driver
, const char *buf
,
621 struct hv_driver
*drv
= drv_to_hv_drv(driver
);
625 retval
= uuid_le_to_bin(buf
, &guid
);
629 if (hv_vmbus_get_id(drv
, &guid
))
632 retval
= vmbus_add_dynid(drv
, &guid
);
637 static DRIVER_ATTR_WO(new_id
);
640 * store_remove_id - remove a PCI device ID from this driver
642 * Removes a dynamic pci device ID to this driver.
644 static ssize_t
remove_id_store(struct device_driver
*driver
, const char *buf
,
647 struct hv_driver
*drv
= drv_to_hv_drv(driver
);
648 struct vmbus_dynid
*dynid
, *n
;
652 retval
= uuid_le_to_bin(buf
, &guid
);
657 spin_lock(&drv
->dynids
.lock
);
658 list_for_each_entry_safe(dynid
, n
, &drv
->dynids
.list
, node
) {
659 struct hv_vmbus_device_id
*id
= &dynid
->id
;
661 if (!uuid_le_cmp(id
->guid
, guid
)) {
662 list_del(&dynid
->node
);
668 spin_unlock(&drv
->dynids
.lock
);
672 static DRIVER_ATTR_WO(remove_id
);
674 static struct attribute
*vmbus_drv_attrs
[] = {
675 &driver_attr_new_id
.attr
,
676 &driver_attr_remove_id
.attr
,
679 ATTRIBUTE_GROUPS(vmbus_drv
);
683 * vmbus_match - Attempt to match the specified device to the specified driver
685 static int vmbus_match(struct device
*device
, struct device_driver
*driver
)
687 struct hv_driver
*drv
= drv_to_hv_drv(driver
);
688 struct hv_device
*hv_dev
= device_to_hv_device(device
);
690 /* The hv_sock driver handles all hv_sock offers. */
691 if (is_hvsock_channel(hv_dev
->channel
))
694 if (hv_vmbus_get_id(drv
, &hv_dev
->dev_type
))
701 * vmbus_probe - Add the new vmbus's child device
703 static int vmbus_probe(struct device
*child_device
)
706 struct hv_driver
*drv
=
707 drv_to_hv_drv(child_device
->driver
);
708 struct hv_device
*dev
= device_to_hv_device(child_device
);
709 const struct hv_vmbus_device_id
*dev_id
;
711 dev_id
= hv_vmbus_get_id(drv
, &dev
->dev_type
);
713 ret
= drv
->probe(dev
, dev_id
);
715 pr_err("probe failed for device %s (%d)\n",
716 dev_name(child_device
), ret
);
719 pr_err("probe not set for driver %s\n",
720 dev_name(child_device
));
727 * vmbus_remove - Remove a vmbus device
729 static int vmbus_remove(struct device
*child_device
)
731 struct hv_driver
*drv
;
732 struct hv_device
*dev
= device_to_hv_device(child_device
);
734 if (child_device
->driver
) {
735 drv
= drv_to_hv_drv(child_device
->driver
);
745 * vmbus_shutdown - Shutdown a vmbus device
747 static void vmbus_shutdown(struct device
*child_device
)
749 struct hv_driver
*drv
;
750 struct hv_device
*dev
= device_to_hv_device(child_device
);
753 /* The device may not be attached yet */
754 if (!child_device
->driver
)
757 drv
= drv_to_hv_drv(child_device
->driver
);
765 * vmbus_device_release - Final callback release of the vmbus child device
767 static void vmbus_device_release(struct device
*device
)
769 struct hv_device
*hv_dev
= device_to_hv_device(device
);
770 struct vmbus_channel
*channel
= hv_dev
->channel
;
772 mutex_lock(&vmbus_connection
.channel_mutex
);
773 hv_process_channel_removal(channel
->offermsg
.child_relid
);
774 mutex_unlock(&vmbus_connection
.channel_mutex
);
779 /* The one and only one */
780 static struct bus_type hv_bus
= {
782 .match
= vmbus_match
,
783 .shutdown
= vmbus_shutdown
,
784 .remove
= vmbus_remove
,
785 .probe
= vmbus_probe
,
786 .uevent
= vmbus_uevent
,
787 .dev_groups
= vmbus_dev_groups
,
788 .drv_groups
= vmbus_drv_groups
,
791 struct onmessage_work_context
{
792 struct work_struct work
;
793 struct hv_message msg
;
796 static void vmbus_onmessage_work(struct work_struct
*work
)
798 struct onmessage_work_context
*ctx
;
800 /* Do not process messages if we're in DISCONNECTED state */
801 if (vmbus_connection
.conn_state
== DISCONNECTED
)
804 ctx
= container_of(work
, struct onmessage_work_context
,
806 vmbus_onmessage(&ctx
->msg
);
810 static void hv_process_timer_expiration(struct hv_message
*msg
,
811 struct hv_per_cpu_context
*hv_cpu
)
813 struct clock_event_device
*dev
= hv_cpu
->clk_evt
;
815 if (dev
->event_handler
)
816 dev
->event_handler(dev
);
818 vmbus_signal_eom(msg
, HVMSG_TIMER_EXPIRED
);
821 void vmbus_on_msg_dpc(unsigned long data
)
823 struct hv_per_cpu_context
*hv_cpu
= (void *)data
;
824 void *page_addr
= hv_cpu
->synic_message_page
;
825 struct hv_message
*msg
= (struct hv_message
*)page_addr
+
827 struct vmbus_channel_message_header
*hdr
;
828 const struct vmbus_channel_message_table_entry
*entry
;
829 struct onmessage_work_context
*ctx
;
830 u32 message_type
= msg
->header
.message_type
;
832 if (message_type
== HVMSG_NONE
)
836 hdr
= (struct vmbus_channel_message_header
*)msg
->u
.payload
;
838 trace_vmbus_on_msg_dpc(hdr
);
840 if (hdr
->msgtype
>= CHANNELMSG_COUNT
) {
841 WARN_ONCE(1, "unknown msgtype=%d\n", hdr
->msgtype
);
845 entry
= &channel_message_table
[hdr
->msgtype
];
846 if (entry
->handler_type
== VMHT_BLOCKING
) {
847 ctx
= kmalloc(sizeof(*ctx
), GFP_ATOMIC
);
851 INIT_WORK(&ctx
->work
, vmbus_onmessage_work
);
852 memcpy(&ctx
->msg
, msg
, sizeof(*msg
));
855 * The host can generate a rescind message while we
856 * may still be handling the original offer. We deal with
857 * this condition by ensuring the processing is done on the
860 switch (hdr
->msgtype
) {
861 case CHANNELMSG_RESCIND_CHANNELOFFER
:
863 * If we are handling the rescind message;
864 * schedule the work on the global work queue.
866 schedule_work_on(vmbus_connection
.connect_cpu
,
870 case CHANNELMSG_OFFERCHANNEL
:
871 atomic_inc(&vmbus_connection
.offer_in_progress
);
872 queue_work_on(vmbus_connection
.connect_cpu
,
873 vmbus_connection
.work_queue
,
878 queue_work(vmbus_connection
.work_queue
, &ctx
->work
);
881 entry
->message_handler(hdr
);
884 vmbus_signal_eom(msg
, message_type
);
889 * Direct callback for channels using other deferred processing
891 static void vmbus_channel_isr(struct vmbus_channel
*channel
)
893 void (*callback_fn
)(void *);
895 callback_fn
= READ_ONCE(channel
->onchannel_callback
);
896 if (likely(callback_fn
!= NULL
))
897 (*callback_fn
)(channel
->channel_callback_context
);
901 * Schedule all channels with events pending
903 static void vmbus_chan_sched(struct hv_per_cpu_context
*hv_cpu
)
905 unsigned long *recv_int_page
;
908 if (vmbus_proto_version
< VERSION_WIN8
) {
909 maxbits
= MAX_NUM_CHANNELS_SUPPORTED
;
910 recv_int_page
= vmbus_connection
.recv_int_page
;
913 * When the host is win8 and beyond, the event page
914 * can be directly checked to get the id of the channel
915 * that has the interrupt pending.
917 void *page_addr
= hv_cpu
->synic_event_page
;
918 union hv_synic_event_flags
*event
919 = (union hv_synic_event_flags
*)page_addr
+
922 maxbits
= HV_EVENT_FLAGS_COUNT
;
923 recv_int_page
= event
->flags
;
926 if (unlikely(!recv_int_page
))
929 for_each_set_bit(relid
, recv_int_page
, maxbits
) {
930 struct vmbus_channel
*channel
;
932 if (!sync_test_and_clear_bit(relid
, recv_int_page
))
935 /* Special case - vmbus channel protocol msg */
941 /* Find channel based on relid */
942 list_for_each_entry_rcu(channel
, &hv_cpu
->chan_list
, percpu_list
) {
943 if (channel
->offermsg
.child_relid
!= relid
)
946 if (channel
->rescind
)
949 trace_vmbus_chan_sched(channel
);
951 ++channel
->interrupts
;
953 switch (channel
->callback_mode
) {
955 vmbus_channel_isr(channel
);
958 case HV_CALL_BATCHED
:
959 hv_begin_read(&channel
->inbound
);
962 tasklet_schedule(&channel
->callback_event
);
970 static void vmbus_isr(void)
972 struct hv_per_cpu_context
*hv_cpu
973 = this_cpu_ptr(hv_context
.cpu_context
);
974 void *page_addr
= hv_cpu
->synic_event_page
;
975 struct hv_message
*msg
;
976 union hv_synic_event_flags
*event
;
977 bool handled
= false;
979 if (unlikely(page_addr
== NULL
))
982 event
= (union hv_synic_event_flags
*)page_addr
+
985 * Check for events before checking for messages. This is the order
986 * in which events and messages are checked in Windows guests on
987 * Hyper-V, and the Windows team suggested we do the same.
990 if ((vmbus_proto_version
== VERSION_WS2008
) ||
991 (vmbus_proto_version
== VERSION_WIN7
)) {
993 /* Since we are a child, we only need to check bit 0 */
994 if (sync_test_and_clear_bit(0, event
->flags
))
998 * Our host is win8 or above. The signaling mechanism
999 * has changed and we can directly look at the event page.
1000 * If bit n is set then we have an interrup on the channel
1007 vmbus_chan_sched(hv_cpu
);
1009 page_addr
= hv_cpu
->synic_message_page
;
1010 msg
= (struct hv_message
*)page_addr
+ VMBUS_MESSAGE_SINT
;
1012 /* Check if there are actual msgs to be processed */
1013 if (msg
->header
.message_type
!= HVMSG_NONE
) {
1014 if (msg
->header
.message_type
== HVMSG_TIMER_EXPIRED
)
1015 hv_process_timer_expiration(msg
, hv_cpu
);
1017 tasklet_schedule(&hv_cpu
->msg_dpc
);
1020 add_interrupt_randomness(HYPERVISOR_CALLBACK_VECTOR
, 0);
1025 * vmbus_bus_init -Main vmbus driver initialization routine.
1028 * - initialize the vmbus driver context
1029 * - invoke the vmbus hv main init routine
1030 * - retrieve the channel offers
1032 static int vmbus_bus_init(void)
1036 /* Hypervisor initialization...setup hypercall page..etc */
1039 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret
);
1043 ret
= bus_register(&hv_bus
);
1047 hv_setup_vmbus_irq(vmbus_isr
);
1049 ret
= hv_synic_alloc();
1053 * Initialize the per-cpu interrupt state and
1054 * connect to the host.
1056 ret
= cpuhp_setup_state(CPUHP_AP_ONLINE_DYN
, "x86/hyperv:online",
1057 hv_synic_init
, hv_synic_cleanup
);
1060 hyperv_cpuhp_online
= ret
;
1062 ret
= vmbus_connect();
1067 * Only register if the crash MSRs are available
1069 if (ms_hyperv
.misc_features
& HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE
) {
1070 register_die_notifier(&hyperv_die_block
);
1071 atomic_notifier_chain_register(&panic_notifier_list
,
1072 &hyperv_panic_block
);
1075 vmbus_request_offers();
1080 cpuhp_remove_state(hyperv_cpuhp_online
);
1083 hv_remove_vmbus_irq();
1085 bus_unregister(&hv_bus
);
1091 * __vmbus_child_driver_register() - Register a vmbus's driver
1092 * @hv_driver: Pointer to driver structure you want to register
1093 * @owner: owner module of the drv
1094 * @mod_name: module name string
1096 * Registers the given driver with Linux through the 'driver_register()' call
1097 * and sets up the hyper-v vmbus handling for this driver.
1098 * It will return the state of the 'driver_register()' call.
1101 int __vmbus_driver_register(struct hv_driver
*hv_driver
, struct module
*owner
, const char *mod_name
)
1105 pr_info("registering driver %s\n", hv_driver
->name
);
1107 ret
= vmbus_exists();
1111 hv_driver
->driver
.name
= hv_driver
->name
;
1112 hv_driver
->driver
.owner
= owner
;
1113 hv_driver
->driver
.mod_name
= mod_name
;
1114 hv_driver
->driver
.bus
= &hv_bus
;
1116 spin_lock_init(&hv_driver
->dynids
.lock
);
1117 INIT_LIST_HEAD(&hv_driver
->dynids
.list
);
1119 ret
= driver_register(&hv_driver
->driver
);
1123 EXPORT_SYMBOL_GPL(__vmbus_driver_register
);
1126 * vmbus_driver_unregister() - Unregister a vmbus's driver
1127 * @hv_driver: Pointer to driver structure you want to
1130 * Un-register the given driver that was previous registered with a call to
1131 * vmbus_driver_register()
1133 void vmbus_driver_unregister(struct hv_driver
*hv_driver
)
1135 pr_info("unregistering driver %s\n", hv_driver
->name
);
1137 if (!vmbus_exists()) {
1138 driver_unregister(&hv_driver
->driver
);
1139 vmbus_free_dynids(hv_driver
);
1142 EXPORT_SYMBOL_GPL(vmbus_driver_unregister
);
1146 * Called when last reference to channel is gone.
1148 static void vmbus_chan_release(struct kobject
*kobj
)
1150 struct vmbus_channel
*channel
1151 = container_of(kobj
, struct vmbus_channel
, kobj
);
1153 kfree_rcu(channel
, rcu
);
1156 struct vmbus_chan_attribute
{
1157 struct attribute attr
;
1158 ssize_t (*show
)(const struct vmbus_channel
*chan
, char *buf
);
1159 ssize_t (*store
)(struct vmbus_channel
*chan
,
1160 const char *buf
, size_t count
);
1162 #define VMBUS_CHAN_ATTR(_name, _mode, _show, _store) \
1163 struct vmbus_chan_attribute chan_attr_##_name \
1164 = __ATTR(_name, _mode, _show, _store)
1165 #define VMBUS_CHAN_ATTR_RW(_name) \
1166 struct vmbus_chan_attribute chan_attr_##_name = __ATTR_RW(_name)
1167 #define VMBUS_CHAN_ATTR_RO(_name) \
1168 struct vmbus_chan_attribute chan_attr_##_name = __ATTR_RO(_name)
1169 #define VMBUS_CHAN_ATTR_WO(_name) \
1170 struct vmbus_chan_attribute chan_attr_##_name = __ATTR_WO(_name)
1172 static ssize_t
vmbus_chan_attr_show(struct kobject
*kobj
,
1173 struct attribute
*attr
, char *buf
)
1175 const struct vmbus_chan_attribute
*attribute
1176 = container_of(attr
, struct vmbus_chan_attribute
, attr
);
1177 const struct vmbus_channel
*chan
1178 = container_of(kobj
, struct vmbus_channel
, kobj
);
1180 if (!attribute
->show
)
1183 return attribute
->show(chan
, buf
);
1186 static const struct sysfs_ops vmbus_chan_sysfs_ops
= {
1187 .show
= vmbus_chan_attr_show
,
1190 static ssize_t
out_mask_show(const struct vmbus_channel
*channel
, char *buf
)
1192 const struct hv_ring_buffer_info
*rbi
= &channel
->outbound
;
1194 return sprintf(buf
, "%u\n", rbi
->ring_buffer
->interrupt_mask
);
1196 VMBUS_CHAN_ATTR_RO(out_mask
);
1198 static ssize_t
in_mask_show(const struct vmbus_channel
*channel
, char *buf
)
1200 const struct hv_ring_buffer_info
*rbi
= &channel
->inbound
;
1202 return sprintf(buf
, "%u\n", rbi
->ring_buffer
->interrupt_mask
);
1204 VMBUS_CHAN_ATTR_RO(in_mask
);
1206 static ssize_t
read_avail_show(const struct vmbus_channel
*channel
, char *buf
)
1208 const struct hv_ring_buffer_info
*rbi
= &channel
->inbound
;
1210 return sprintf(buf
, "%u\n", hv_get_bytes_to_read(rbi
));
1212 VMBUS_CHAN_ATTR_RO(read_avail
);
1214 static ssize_t
write_avail_show(const struct vmbus_channel
*channel
, char *buf
)
1216 const struct hv_ring_buffer_info
*rbi
= &channel
->outbound
;
1218 return sprintf(buf
, "%u\n", hv_get_bytes_to_write(rbi
));
1220 VMBUS_CHAN_ATTR_RO(write_avail
);
1222 static ssize_t
show_target_cpu(const struct vmbus_channel
*channel
, char *buf
)
1224 return sprintf(buf
, "%u\n", channel
->target_cpu
);
1226 VMBUS_CHAN_ATTR(cpu
, S_IRUGO
, show_target_cpu
, NULL
);
1228 static ssize_t
channel_pending_show(const struct vmbus_channel
*channel
,
1231 return sprintf(buf
, "%d\n",
1232 channel_pending(channel
,
1233 vmbus_connection
.monitor_pages
[1]));
1235 VMBUS_CHAN_ATTR(pending
, S_IRUGO
, channel_pending_show
, NULL
);
1237 static ssize_t
channel_latency_show(const struct vmbus_channel
*channel
,
1240 return sprintf(buf
, "%d\n",
1241 channel_latency(channel
,
1242 vmbus_connection
.monitor_pages
[1]));
1244 VMBUS_CHAN_ATTR(latency
, S_IRUGO
, channel_latency_show
, NULL
);
1246 static ssize_t
channel_interrupts_show(const struct vmbus_channel
*channel
, char *buf
)
1248 return sprintf(buf
, "%llu\n", channel
->interrupts
);
1250 VMBUS_CHAN_ATTR(interrupts
, S_IRUGO
, channel_interrupts_show
, NULL
);
1252 static ssize_t
channel_events_show(const struct vmbus_channel
*channel
, char *buf
)
1254 return sprintf(buf
, "%llu\n", channel
->sig_events
);
1256 VMBUS_CHAN_ATTR(events
, S_IRUGO
, channel_events_show
, NULL
);
1258 static struct attribute
*vmbus_chan_attrs
[] = {
1259 &chan_attr_out_mask
.attr
,
1260 &chan_attr_in_mask
.attr
,
1261 &chan_attr_read_avail
.attr
,
1262 &chan_attr_write_avail
.attr
,
1263 &chan_attr_cpu
.attr
,
1264 &chan_attr_pending
.attr
,
1265 &chan_attr_latency
.attr
,
1266 &chan_attr_interrupts
.attr
,
1267 &chan_attr_events
.attr
,
1271 static struct kobj_type vmbus_chan_ktype
= {
1272 .sysfs_ops
= &vmbus_chan_sysfs_ops
,
1273 .release
= vmbus_chan_release
,
1274 .default_attrs
= vmbus_chan_attrs
,
1278 * vmbus_add_channel_kobj - setup a sub-directory under device/channels
1280 int vmbus_add_channel_kobj(struct hv_device
*dev
, struct vmbus_channel
*channel
)
1282 struct kobject
*kobj
= &channel
->kobj
;
1283 u32 relid
= channel
->offermsg
.child_relid
;
1286 kobj
->kset
= dev
->channels_kset
;
1287 ret
= kobject_init_and_add(kobj
, &vmbus_chan_ktype
, NULL
,
1292 kobject_uevent(kobj
, KOBJ_ADD
);
1298 * vmbus_device_create - Creates and registers a new child device
1301 struct hv_device
*vmbus_device_create(const uuid_le
*type
,
1302 const uuid_le
*instance
,
1303 struct vmbus_channel
*channel
)
1305 struct hv_device
*child_device_obj
;
1307 child_device_obj
= kzalloc(sizeof(struct hv_device
), GFP_KERNEL
);
1308 if (!child_device_obj
) {
1309 pr_err("Unable to allocate device object for child device\n");
1313 child_device_obj
->channel
= channel
;
1314 memcpy(&child_device_obj
->dev_type
, type
, sizeof(uuid_le
));
1315 memcpy(&child_device_obj
->dev_instance
, instance
,
1317 child_device_obj
->vendor_id
= 0x1414; /* MSFT vendor ID */
1320 return child_device_obj
;
1324 * vmbus_device_register - Register the child device
1326 int vmbus_device_register(struct hv_device
*child_device_obj
)
1328 struct kobject
*kobj
= &child_device_obj
->device
.kobj
;
1331 dev_set_name(&child_device_obj
->device
, "%pUl",
1332 child_device_obj
->channel
->offermsg
.offer
.if_instance
.b
);
1334 child_device_obj
->device
.bus
= &hv_bus
;
1335 child_device_obj
->device
.parent
= &hv_acpi_dev
->dev
;
1336 child_device_obj
->device
.release
= vmbus_device_release
;
1339 * Register with the LDM. This will kick off the driver/device
1340 * binding...which will eventually call vmbus_match() and vmbus_probe()
1342 ret
= device_register(&child_device_obj
->device
);
1344 pr_err("Unable to register child device\n");
1348 child_device_obj
->channels_kset
= kset_create_and_add("channels",
1350 if (!child_device_obj
->channels_kset
) {
1352 goto err_dev_unregister
;
1355 ret
= vmbus_add_channel_kobj(child_device_obj
,
1356 child_device_obj
->channel
);
1358 pr_err("Unable to register primary channeln");
1359 goto err_kset_unregister
;
1364 err_kset_unregister
:
1365 kset_unregister(child_device_obj
->channels_kset
);
1368 device_unregister(&child_device_obj
->device
);
1373 * vmbus_device_unregister - Remove the specified child device
1376 void vmbus_device_unregister(struct hv_device
*device_obj
)
1378 pr_debug("child device %s unregistered\n",
1379 dev_name(&device_obj
->device
));
1381 kset_unregister(device_obj
->channels_kset
);
1384 * Kick off the process of unregistering the device.
1385 * This will call vmbus_remove() and eventually vmbus_device_release()
1387 device_unregister(&device_obj
->device
);
1392 * VMBUS is an acpi enumerated device. Get the information we
1395 #define VTPM_BASE_ADDRESS 0xfed40000
1396 static acpi_status
vmbus_walk_resources(struct acpi_resource
*res
, void *ctx
)
1398 resource_size_t start
= 0;
1399 resource_size_t end
= 0;
1400 struct resource
*new_res
;
1401 struct resource
**old_res
= &hyperv_mmio
;
1402 struct resource
**prev_res
= NULL
;
1404 switch (res
->type
) {
1407 * "Address" descriptors are for bus windows. Ignore
1408 * "memory" descriptors, which are for registers on
1411 case ACPI_RESOURCE_TYPE_ADDRESS32
:
1412 start
= res
->data
.address32
.address
.minimum
;
1413 end
= res
->data
.address32
.address
.maximum
;
1416 case ACPI_RESOURCE_TYPE_ADDRESS64
:
1417 start
= res
->data
.address64
.address
.minimum
;
1418 end
= res
->data
.address64
.address
.maximum
;
1422 /* Unused resource type */
1427 * Ignore ranges that are below 1MB, as they're not
1428 * necessary or useful here.
1433 new_res
= kzalloc(sizeof(*new_res
), GFP_ATOMIC
);
1435 return AE_NO_MEMORY
;
1437 /* If this range overlaps the virtual TPM, truncate it. */
1438 if (end
> VTPM_BASE_ADDRESS
&& start
< VTPM_BASE_ADDRESS
)
1439 end
= VTPM_BASE_ADDRESS
;
1441 new_res
->name
= "hyperv mmio";
1442 new_res
->flags
= IORESOURCE_MEM
;
1443 new_res
->start
= start
;
1447 * If two ranges are adjacent, merge them.
1455 if (((*old_res
)->end
+ 1) == new_res
->start
) {
1456 (*old_res
)->end
= new_res
->end
;
1461 if ((*old_res
)->start
== new_res
->end
+ 1) {
1462 (*old_res
)->start
= new_res
->start
;
1467 if ((*old_res
)->start
> new_res
->end
) {
1468 new_res
->sibling
= *old_res
;
1470 (*prev_res
)->sibling
= new_res
;
1476 old_res
= &(*old_res
)->sibling
;
1483 static int vmbus_acpi_remove(struct acpi_device
*device
)
1485 struct resource
*cur_res
;
1486 struct resource
*next_res
;
1490 __release_region(hyperv_mmio
, fb_mmio
->start
,
1491 resource_size(fb_mmio
));
1495 for (cur_res
= hyperv_mmio
; cur_res
; cur_res
= next_res
) {
1496 next_res
= cur_res
->sibling
;
1504 static void vmbus_reserve_fb(void)
1508 * Make a claim for the frame buffer in the resource tree under the
1509 * first node, which will be the one below 4GB. The length seems to
1510 * be underreported, particularly in a Generation 1 VM. So start out
1511 * reserving a larger area and make it smaller until it succeeds.
1514 if (screen_info
.lfb_base
) {
1515 if (efi_enabled(EFI_BOOT
))
1516 size
= max_t(__u32
, screen_info
.lfb_size
, 0x800000);
1518 size
= max_t(__u32
, screen_info
.lfb_size
, 0x4000000);
1520 for (; !fb_mmio
&& (size
>= 0x100000); size
>>= 1) {
1521 fb_mmio
= __request_region(hyperv_mmio
,
1522 screen_info
.lfb_base
, size
,
1529 * vmbus_allocate_mmio() - Pick a memory-mapped I/O range.
1530 * @new: If successful, supplied a pointer to the
1531 * allocated MMIO space.
1532 * @device_obj: Identifies the caller
1533 * @min: Minimum guest physical address of the
1535 * @max: Maximum guest physical address
1536 * @size: Size of the range to be allocated
1537 * @align: Alignment of the range to be allocated
1538 * @fb_overlap_ok: Whether this allocation can be allowed
1539 * to overlap the video frame buffer.
1541 * This function walks the resources granted to VMBus by the
1542 * _CRS object in the ACPI namespace underneath the parent
1543 * "bridge" whether that's a root PCI bus in the Generation 1
1544 * case or a Module Device in the Generation 2 case. It then
1545 * attempts to allocate from the global MMIO pool in a way that
1546 * matches the constraints supplied in these parameters and by
1549 * Return: 0 on success, -errno on failure
1551 int vmbus_allocate_mmio(struct resource
**new, struct hv_device
*device_obj
,
1552 resource_size_t min
, resource_size_t max
,
1553 resource_size_t size
, resource_size_t align
,
1556 struct resource
*iter
, *shadow
;
1557 resource_size_t range_min
, range_max
, start
;
1558 const char *dev_n
= dev_name(&device_obj
->device
);
1562 down(&hyperv_mmio_lock
);
1565 * If overlaps with frame buffers are allowed, then first attempt to
1566 * make the allocation from within the reserved region. Because it
1567 * is already reserved, no shadow allocation is necessary.
1569 if (fb_overlap_ok
&& fb_mmio
&& !(min
> fb_mmio
->end
) &&
1570 !(max
< fb_mmio
->start
)) {
1572 range_min
= fb_mmio
->start
;
1573 range_max
= fb_mmio
->end
;
1574 start
= (range_min
+ align
- 1) & ~(align
- 1);
1575 for (; start
+ size
- 1 <= range_max
; start
+= align
) {
1576 *new = request_mem_region_exclusive(start
, size
, dev_n
);
1584 for (iter
= hyperv_mmio
; iter
; iter
= iter
->sibling
) {
1585 if ((iter
->start
>= max
) || (iter
->end
<= min
))
1588 range_min
= iter
->start
;
1589 range_max
= iter
->end
;
1590 start
= (range_min
+ align
- 1) & ~(align
- 1);
1591 for (; start
+ size
- 1 <= range_max
; start
+= align
) {
1592 shadow
= __request_region(iter
, start
, size
, NULL
,
1597 *new = request_mem_region_exclusive(start
, size
, dev_n
);
1599 shadow
->name
= (char *)*new;
1604 __release_region(iter
, start
, size
);
1609 up(&hyperv_mmio_lock
);
1612 EXPORT_SYMBOL_GPL(vmbus_allocate_mmio
);
1615 * vmbus_free_mmio() - Free a memory-mapped I/O range.
1616 * @start: Base address of region to release.
1617 * @size: Size of the range to be allocated
1619 * This function releases anything requested by
1620 * vmbus_mmio_allocate().
1622 void vmbus_free_mmio(resource_size_t start
, resource_size_t size
)
1624 struct resource
*iter
;
1626 down(&hyperv_mmio_lock
);
1627 for (iter
= hyperv_mmio
; iter
; iter
= iter
->sibling
) {
1628 if ((iter
->start
>= start
+ size
) || (iter
->end
<= start
))
1631 __release_region(iter
, start
, size
);
1633 release_mem_region(start
, size
);
1634 up(&hyperv_mmio_lock
);
1637 EXPORT_SYMBOL_GPL(vmbus_free_mmio
);
1639 static int vmbus_acpi_add(struct acpi_device
*device
)
1642 int ret_val
= -ENODEV
;
1643 struct acpi_device
*ancestor
;
1645 hv_acpi_dev
= device
;
1647 result
= acpi_walk_resources(device
->handle
, METHOD_NAME__CRS
,
1648 vmbus_walk_resources
, NULL
);
1650 if (ACPI_FAILURE(result
))
1653 * Some ancestor of the vmbus acpi device (Gen1 or Gen2
1654 * firmware) is the VMOD that has the mmio ranges. Get that.
1656 for (ancestor
= device
->parent
; ancestor
; ancestor
= ancestor
->parent
) {
1657 result
= acpi_walk_resources(ancestor
->handle
, METHOD_NAME__CRS
,
1658 vmbus_walk_resources
, NULL
);
1660 if (ACPI_FAILURE(result
))
1670 complete(&probe_event
);
1672 vmbus_acpi_remove(device
);
1676 static const struct acpi_device_id vmbus_acpi_device_ids
[] = {
1681 MODULE_DEVICE_TABLE(acpi
, vmbus_acpi_device_ids
);
1683 static struct acpi_driver vmbus_acpi_driver
= {
1685 .ids
= vmbus_acpi_device_ids
,
1687 .add
= vmbus_acpi_add
,
1688 .remove
= vmbus_acpi_remove
,
1692 static void hv_kexec_handler(void)
1694 hv_synic_clockevents_cleanup();
1695 vmbus_initiate_unload(false);
1696 vmbus_connection
.conn_state
= DISCONNECTED
;
1697 /* Make sure conn_state is set as hv_synic_cleanup checks for it */
1699 cpuhp_remove_state(hyperv_cpuhp_online
);
1703 static void hv_crash_handler(struct pt_regs
*regs
)
1705 vmbus_initiate_unload(true);
1707 * In crash handler we can't schedule synic cleanup for all CPUs,
1708 * doing the cleanup for current CPU only. This should be sufficient
1711 vmbus_connection
.conn_state
= DISCONNECTED
;
1712 hv_synic_cleanup(smp_processor_id());
1716 static int __init
hv_acpi_init(void)
1720 if (x86_hyper_type
!= X86_HYPER_MS_HYPERV
)
1723 init_completion(&probe_event
);
1726 * Get ACPI resources first.
1728 ret
= acpi_bus_register_driver(&vmbus_acpi_driver
);
1733 t
= wait_for_completion_timeout(&probe_event
, 5*HZ
);
1739 ret
= vmbus_bus_init();
1743 hv_setup_kexec_handler(hv_kexec_handler
);
1744 hv_setup_crash_handler(hv_crash_handler
);
1749 acpi_bus_unregister_driver(&vmbus_acpi_driver
);
1754 static void __exit
vmbus_exit(void)
1758 hv_remove_kexec_handler();
1759 hv_remove_crash_handler();
1760 vmbus_connection
.conn_state
= DISCONNECTED
;
1761 hv_synic_clockevents_cleanup();
1763 hv_remove_vmbus_irq();
1764 for_each_online_cpu(cpu
) {
1765 struct hv_per_cpu_context
*hv_cpu
1766 = per_cpu_ptr(hv_context
.cpu_context
, cpu
);
1768 tasklet_kill(&hv_cpu
->msg_dpc
);
1770 vmbus_free_channels();
1772 if (ms_hyperv
.misc_features
& HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE
) {
1773 unregister_die_notifier(&hyperv_die_block
);
1774 atomic_notifier_chain_unregister(&panic_notifier_list
,
1775 &hyperv_panic_block
);
1777 bus_unregister(&hv_bus
);
1779 cpuhp_remove_state(hyperv_cpuhp_online
);
1781 acpi_bus_unregister_driver(&vmbus_acpi_driver
);
1785 MODULE_LICENSE("GPL");
1787 subsys_initcall(hv_acpi_init
);
1788 module_exit(vmbus_exit
);