xref: /openbmc/linux/drivers/hv/vmbus_drv.c (revision 74de3792)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2009, Microsoft Corporation.
4  *
5  * Authors:
6  *   Haiyang Zhang <haiyangz@microsoft.com>
7  *   Hank Janssen  <hjanssen@microsoft.com>
8  *   K. Y. Srinivasan <kys@microsoft.com>
9  */
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 
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>
25 
26 #include <linux/delay.h>
27 #include <linux/notifier.h>
28 #include <linux/panic_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/kernel.h>
35 #include <linux/syscore_ops.h>
36 #include <linux/dma-map-ops.h>
37 #include <clocksource/hyperv_timer.h>
38 #include "hyperv_vmbus.h"
39 
40 struct vmbus_dynid {
41 	struct list_head node;
42 	struct hv_vmbus_device_id id;
43 };
44 
45 static struct acpi_device  *hv_acpi_dev;
46 
47 static struct completion probe_event;
48 
49 static int hyperv_cpuhp_online;
50 
51 static void *hv_panic_page;
52 
53 static long __percpu *vmbus_evt;
54 
55 /* Values parsed from ACPI DSDT */
56 int vmbus_irq;
57 int vmbus_interrupt;
58 
59 /*
60  * Boolean to control whether to report panic messages over Hyper-V.
61  *
62  * It can be set via /proc/sys/kernel/hyperv_record_panic_msg
63  */
64 static int sysctl_record_panic_msg = 1;
65 
66 static int hyperv_report_reg(void)
67 {
68 	return !sysctl_record_panic_msg || !hv_panic_page;
69 }
70 
71 static int hyperv_panic_event(struct notifier_block *nb, unsigned long val,
72 			      void *args)
73 {
74 	struct pt_regs *regs;
75 
76 	vmbus_initiate_unload(true);
77 
78 	/*
79 	 * Hyper-V should be notified only once about a panic.  If we will be
80 	 * doing hyperv_report_panic_msg() later with kmsg data, don't do
81 	 * the notification here.
82 	 */
83 	if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE
84 	    && hyperv_report_reg()) {
85 		regs = current_pt_regs();
86 		hyperv_report_panic(regs, val, false);
87 	}
88 	return NOTIFY_DONE;
89 }
90 
91 static int hyperv_die_event(struct notifier_block *nb, unsigned long val,
92 			    void *args)
93 {
94 	struct die_args *die = args;
95 	struct pt_regs *regs = die->regs;
96 
97 	/* Don't notify Hyper-V if the die event is other than oops */
98 	if (val != DIE_OOPS)
99 		return NOTIFY_DONE;
100 
101 	/*
102 	 * Hyper-V should be notified only once about a panic.  If we will be
103 	 * doing hyperv_report_panic_msg() later with kmsg data, don't do
104 	 * the notification here.
105 	 */
106 	if (hyperv_report_reg())
107 		hyperv_report_panic(regs, val, true);
108 	return NOTIFY_DONE;
109 }
110 
111 static struct notifier_block hyperv_die_block = {
112 	.notifier_call = hyperv_die_event,
113 };
114 static struct notifier_block hyperv_panic_block = {
115 	.notifier_call = hyperv_panic_event,
116 };
117 
118 static const char *fb_mmio_name = "fb_range";
119 static struct resource *fb_mmio;
120 static struct resource *hyperv_mmio;
121 static DEFINE_MUTEX(hyperv_mmio_lock);
122 
123 static int vmbus_exists(void)
124 {
125 	if (hv_acpi_dev == NULL)
126 		return -ENODEV;
127 
128 	return 0;
129 }
130 
131 static u8 channel_monitor_group(const struct vmbus_channel *channel)
132 {
133 	return (u8)channel->offermsg.monitorid / 32;
134 }
135 
136 static u8 channel_monitor_offset(const struct vmbus_channel *channel)
137 {
138 	return (u8)channel->offermsg.monitorid % 32;
139 }
140 
141 static u32 channel_pending(const struct vmbus_channel *channel,
142 			   const struct hv_monitor_page *monitor_page)
143 {
144 	u8 monitor_group = channel_monitor_group(channel);
145 
146 	return monitor_page->trigger_group[monitor_group].pending;
147 }
148 
149 static u32 channel_latency(const struct vmbus_channel *channel,
150 			   const struct hv_monitor_page *monitor_page)
151 {
152 	u8 monitor_group = channel_monitor_group(channel);
153 	u8 monitor_offset = channel_monitor_offset(channel);
154 
155 	return monitor_page->latency[monitor_group][monitor_offset];
156 }
157 
158 static u32 channel_conn_id(struct vmbus_channel *channel,
159 			   struct hv_monitor_page *monitor_page)
160 {
161 	u8 monitor_group = channel_monitor_group(channel);
162 	u8 monitor_offset = channel_monitor_offset(channel);
163 
164 	return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
165 }
166 
167 static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
168 		       char *buf)
169 {
170 	struct hv_device *hv_dev = device_to_hv_device(dev);
171 
172 	if (!hv_dev->channel)
173 		return -ENODEV;
174 	return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
175 }
176 static DEVICE_ATTR_RO(id);
177 
178 static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
179 			  char *buf)
180 {
181 	struct hv_device *hv_dev = device_to_hv_device(dev);
182 
183 	if (!hv_dev->channel)
184 		return -ENODEV;
185 	return sprintf(buf, "%d\n", hv_dev->channel->state);
186 }
187 static DEVICE_ATTR_RO(state);
188 
189 static ssize_t monitor_id_show(struct device *dev,
190 			       struct device_attribute *dev_attr, char *buf)
191 {
192 	struct hv_device *hv_dev = device_to_hv_device(dev);
193 
194 	if (!hv_dev->channel)
195 		return -ENODEV;
196 	return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
197 }
198 static DEVICE_ATTR_RO(monitor_id);
199 
200 static ssize_t class_id_show(struct device *dev,
201 			       struct device_attribute *dev_attr, char *buf)
202 {
203 	struct hv_device *hv_dev = device_to_hv_device(dev);
204 
205 	if (!hv_dev->channel)
206 		return -ENODEV;
207 	return sprintf(buf, "{%pUl}\n",
208 		       &hv_dev->channel->offermsg.offer.if_type);
209 }
210 static DEVICE_ATTR_RO(class_id);
211 
212 static ssize_t device_id_show(struct device *dev,
213 			      struct device_attribute *dev_attr, char *buf)
214 {
215 	struct hv_device *hv_dev = device_to_hv_device(dev);
216 
217 	if (!hv_dev->channel)
218 		return -ENODEV;
219 	return sprintf(buf, "{%pUl}\n",
220 		       &hv_dev->channel->offermsg.offer.if_instance);
221 }
222 static DEVICE_ATTR_RO(device_id);
223 
224 static ssize_t modalias_show(struct device *dev,
225 			     struct device_attribute *dev_attr, char *buf)
226 {
227 	struct hv_device *hv_dev = device_to_hv_device(dev);
228 
229 	return sprintf(buf, "vmbus:%*phN\n", UUID_SIZE, &hv_dev->dev_type);
230 }
231 static DEVICE_ATTR_RO(modalias);
232 
233 #ifdef CONFIG_NUMA
234 static ssize_t numa_node_show(struct device *dev,
235 			      struct device_attribute *attr, char *buf)
236 {
237 	struct hv_device *hv_dev = device_to_hv_device(dev);
238 
239 	if (!hv_dev->channel)
240 		return -ENODEV;
241 
242 	return sprintf(buf, "%d\n", cpu_to_node(hv_dev->channel->target_cpu));
243 }
244 static DEVICE_ATTR_RO(numa_node);
245 #endif
246 
247 static ssize_t server_monitor_pending_show(struct device *dev,
248 					   struct device_attribute *dev_attr,
249 					   char *buf)
250 {
251 	struct hv_device *hv_dev = device_to_hv_device(dev);
252 
253 	if (!hv_dev->channel)
254 		return -ENODEV;
255 	return sprintf(buf, "%d\n",
256 		       channel_pending(hv_dev->channel,
257 				       vmbus_connection.monitor_pages[0]));
258 }
259 static DEVICE_ATTR_RO(server_monitor_pending);
260 
261 static ssize_t client_monitor_pending_show(struct device *dev,
262 					   struct device_attribute *dev_attr,
263 					   char *buf)
264 {
265 	struct hv_device *hv_dev = device_to_hv_device(dev);
266 
267 	if (!hv_dev->channel)
268 		return -ENODEV;
269 	return sprintf(buf, "%d\n",
270 		       channel_pending(hv_dev->channel,
271 				       vmbus_connection.monitor_pages[1]));
272 }
273 static DEVICE_ATTR_RO(client_monitor_pending);
274 
275 static ssize_t server_monitor_latency_show(struct device *dev,
276 					   struct device_attribute *dev_attr,
277 					   char *buf)
278 {
279 	struct hv_device *hv_dev = device_to_hv_device(dev);
280 
281 	if (!hv_dev->channel)
282 		return -ENODEV;
283 	return sprintf(buf, "%d\n",
284 		       channel_latency(hv_dev->channel,
285 				       vmbus_connection.monitor_pages[0]));
286 }
287 static DEVICE_ATTR_RO(server_monitor_latency);
288 
289 static ssize_t client_monitor_latency_show(struct device *dev,
290 					   struct device_attribute *dev_attr,
291 					   char *buf)
292 {
293 	struct hv_device *hv_dev = device_to_hv_device(dev);
294 
295 	if (!hv_dev->channel)
296 		return -ENODEV;
297 	return sprintf(buf, "%d\n",
298 		       channel_latency(hv_dev->channel,
299 				       vmbus_connection.monitor_pages[1]));
300 }
301 static DEVICE_ATTR_RO(client_monitor_latency);
302 
303 static ssize_t server_monitor_conn_id_show(struct device *dev,
304 					   struct device_attribute *dev_attr,
305 					   char *buf)
306 {
307 	struct hv_device *hv_dev = device_to_hv_device(dev);
308 
309 	if (!hv_dev->channel)
310 		return -ENODEV;
311 	return sprintf(buf, "%d\n",
312 		       channel_conn_id(hv_dev->channel,
313 				       vmbus_connection.monitor_pages[0]));
314 }
315 static DEVICE_ATTR_RO(server_monitor_conn_id);
316 
317 static ssize_t client_monitor_conn_id_show(struct device *dev,
318 					   struct device_attribute *dev_attr,
319 					   char *buf)
320 {
321 	struct hv_device *hv_dev = device_to_hv_device(dev);
322 
323 	if (!hv_dev->channel)
324 		return -ENODEV;
325 	return sprintf(buf, "%d\n",
326 		       channel_conn_id(hv_dev->channel,
327 				       vmbus_connection.monitor_pages[1]));
328 }
329 static DEVICE_ATTR_RO(client_monitor_conn_id);
330 
331 static ssize_t out_intr_mask_show(struct device *dev,
332 				  struct device_attribute *dev_attr, char *buf)
333 {
334 	struct hv_device *hv_dev = device_to_hv_device(dev);
335 	struct hv_ring_buffer_debug_info outbound;
336 	int ret;
337 
338 	if (!hv_dev->channel)
339 		return -ENODEV;
340 
341 	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
342 					  &outbound);
343 	if (ret < 0)
344 		return ret;
345 
346 	return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
347 }
348 static DEVICE_ATTR_RO(out_intr_mask);
349 
350 static ssize_t out_read_index_show(struct device *dev,
351 				   struct device_attribute *dev_attr, char *buf)
352 {
353 	struct hv_device *hv_dev = device_to_hv_device(dev);
354 	struct hv_ring_buffer_debug_info outbound;
355 	int ret;
356 
357 	if (!hv_dev->channel)
358 		return -ENODEV;
359 
360 	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
361 					  &outbound);
362 	if (ret < 0)
363 		return ret;
364 	return sprintf(buf, "%d\n", outbound.current_read_index);
365 }
366 static DEVICE_ATTR_RO(out_read_index);
367 
368 static ssize_t out_write_index_show(struct device *dev,
369 				    struct device_attribute *dev_attr,
370 				    char *buf)
371 {
372 	struct hv_device *hv_dev = device_to_hv_device(dev);
373 	struct hv_ring_buffer_debug_info outbound;
374 	int ret;
375 
376 	if (!hv_dev->channel)
377 		return -ENODEV;
378 
379 	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
380 					  &outbound);
381 	if (ret < 0)
382 		return ret;
383 	return sprintf(buf, "%d\n", outbound.current_write_index);
384 }
385 static DEVICE_ATTR_RO(out_write_index);
386 
387 static ssize_t out_read_bytes_avail_show(struct device *dev,
388 					 struct device_attribute *dev_attr,
389 					 char *buf)
390 {
391 	struct hv_device *hv_dev = device_to_hv_device(dev);
392 	struct hv_ring_buffer_debug_info outbound;
393 	int ret;
394 
395 	if (!hv_dev->channel)
396 		return -ENODEV;
397 
398 	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
399 					  &outbound);
400 	if (ret < 0)
401 		return ret;
402 	return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
403 }
404 static DEVICE_ATTR_RO(out_read_bytes_avail);
405 
406 static ssize_t out_write_bytes_avail_show(struct device *dev,
407 					  struct device_attribute *dev_attr,
408 					  char *buf)
409 {
410 	struct hv_device *hv_dev = device_to_hv_device(dev);
411 	struct hv_ring_buffer_debug_info outbound;
412 	int ret;
413 
414 	if (!hv_dev->channel)
415 		return -ENODEV;
416 
417 	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
418 					  &outbound);
419 	if (ret < 0)
420 		return ret;
421 	return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
422 }
423 static DEVICE_ATTR_RO(out_write_bytes_avail);
424 
425 static ssize_t in_intr_mask_show(struct device *dev,
426 				 struct device_attribute *dev_attr, char *buf)
427 {
428 	struct hv_device *hv_dev = device_to_hv_device(dev);
429 	struct hv_ring_buffer_debug_info inbound;
430 	int ret;
431 
432 	if (!hv_dev->channel)
433 		return -ENODEV;
434 
435 	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
436 	if (ret < 0)
437 		return ret;
438 
439 	return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
440 }
441 static DEVICE_ATTR_RO(in_intr_mask);
442 
443 static ssize_t in_read_index_show(struct device *dev,
444 				  struct device_attribute *dev_attr, char *buf)
445 {
446 	struct hv_device *hv_dev = device_to_hv_device(dev);
447 	struct hv_ring_buffer_debug_info inbound;
448 	int ret;
449 
450 	if (!hv_dev->channel)
451 		return -ENODEV;
452 
453 	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
454 	if (ret < 0)
455 		return ret;
456 
457 	return sprintf(buf, "%d\n", inbound.current_read_index);
458 }
459 static DEVICE_ATTR_RO(in_read_index);
460 
461 static ssize_t in_write_index_show(struct device *dev,
462 				   struct device_attribute *dev_attr, char *buf)
463 {
464 	struct hv_device *hv_dev = device_to_hv_device(dev);
465 	struct hv_ring_buffer_debug_info inbound;
466 	int ret;
467 
468 	if (!hv_dev->channel)
469 		return -ENODEV;
470 
471 	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
472 	if (ret < 0)
473 		return ret;
474 
475 	return sprintf(buf, "%d\n", inbound.current_write_index);
476 }
477 static DEVICE_ATTR_RO(in_write_index);
478 
479 static ssize_t in_read_bytes_avail_show(struct device *dev,
480 					struct device_attribute *dev_attr,
481 					char *buf)
482 {
483 	struct hv_device *hv_dev = device_to_hv_device(dev);
484 	struct hv_ring_buffer_debug_info inbound;
485 	int ret;
486 
487 	if (!hv_dev->channel)
488 		return -ENODEV;
489 
490 	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
491 	if (ret < 0)
492 		return ret;
493 
494 	return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
495 }
496 static DEVICE_ATTR_RO(in_read_bytes_avail);
497 
498 static ssize_t in_write_bytes_avail_show(struct device *dev,
499 					 struct device_attribute *dev_attr,
500 					 char *buf)
501 {
502 	struct hv_device *hv_dev = device_to_hv_device(dev);
503 	struct hv_ring_buffer_debug_info inbound;
504 	int ret;
505 
506 	if (!hv_dev->channel)
507 		return -ENODEV;
508 
509 	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
510 	if (ret < 0)
511 		return ret;
512 
513 	return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
514 }
515 static DEVICE_ATTR_RO(in_write_bytes_avail);
516 
517 static ssize_t channel_vp_mapping_show(struct device *dev,
518 				       struct device_attribute *dev_attr,
519 				       char *buf)
520 {
521 	struct hv_device *hv_dev = device_to_hv_device(dev);
522 	struct vmbus_channel *channel = hv_dev->channel, *cur_sc;
523 	int buf_size = PAGE_SIZE, n_written, tot_written;
524 	struct list_head *cur;
525 
526 	if (!channel)
527 		return -ENODEV;
528 
529 	mutex_lock(&vmbus_connection.channel_mutex);
530 
531 	tot_written = snprintf(buf, buf_size, "%u:%u\n",
532 		channel->offermsg.child_relid, channel->target_cpu);
533 
534 	list_for_each(cur, &channel->sc_list) {
535 		if (tot_written >= buf_size - 1)
536 			break;
537 
538 		cur_sc = list_entry(cur, struct vmbus_channel, sc_list);
539 		n_written = scnprintf(buf + tot_written,
540 				     buf_size - tot_written,
541 				     "%u:%u\n",
542 				     cur_sc->offermsg.child_relid,
543 				     cur_sc->target_cpu);
544 		tot_written += n_written;
545 	}
546 
547 	mutex_unlock(&vmbus_connection.channel_mutex);
548 
549 	return tot_written;
550 }
551 static DEVICE_ATTR_RO(channel_vp_mapping);
552 
553 static ssize_t vendor_show(struct device *dev,
554 			   struct device_attribute *dev_attr,
555 			   char *buf)
556 {
557 	struct hv_device *hv_dev = device_to_hv_device(dev);
558 
559 	return sprintf(buf, "0x%x\n", hv_dev->vendor_id);
560 }
561 static DEVICE_ATTR_RO(vendor);
562 
563 static ssize_t device_show(struct device *dev,
564 			   struct device_attribute *dev_attr,
565 			   char *buf)
566 {
567 	struct hv_device *hv_dev = device_to_hv_device(dev);
568 
569 	return sprintf(buf, "0x%x\n", hv_dev->device_id);
570 }
571 static DEVICE_ATTR_RO(device);
572 
573 static ssize_t driver_override_store(struct device *dev,
574 				     struct device_attribute *attr,
575 				     const char *buf, size_t count)
576 {
577 	struct hv_device *hv_dev = device_to_hv_device(dev);
578 	char *driver_override, *old, *cp;
579 
580 	/* We need to keep extra room for a newline */
581 	if (count >= (PAGE_SIZE - 1))
582 		return -EINVAL;
583 
584 	driver_override = kstrndup(buf, count, GFP_KERNEL);
585 	if (!driver_override)
586 		return -ENOMEM;
587 
588 	cp = strchr(driver_override, '\n');
589 	if (cp)
590 		*cp = '\0';
591 
592 	device_lock(dev);
593 	old = hv_dev->driver_override;
594 	if (strlen(driver_override)) {
595 		hv_dev->driver_override = driver_override;
596 	} else {
597 		kfree(driver_override);
598 		hv_dev->driver_override = NULL;
599 	}
600 	device_unlock(dev);
601 
602 	kfree(old);
603 
604 	return count;
605 }
606 
607 static ssize_t driver_override_show(struct device *dev,
608 				    struct device_attribute *attr, char *buf)
609 {
610 	struct hv_device *hv_dev = device_to_hv_device(dev);
611 	ssize_t len;
612 
613 	device_lock(dev);
614 	len = snprintf(buf, PAGE_SIZE, "%s\n", hv_dev->driver_override);
615 	device_unlock(dev);
616 
617 	return len;
618 }
619 static DEVICE_ATTR_RW(driver_override);
620 
621 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
622 static struct attribute *vmbus_dev_attrs[] = {
623 	&dev_attr_id.attr,
624 	&dev_attr_state.attr,
625 	&dev_attr_monitor_id.attr,
626 	&dev_attr_class_id.attr,
627 	&dev_attr_device_id.attr,
628 	&dev_attr_modalias.attr,
629 #ifdef CONFIG_NUMA
630 	&dev_attr_numa_node.attr,
631 #endif
632 	&dev_attr_server_monitor_pending.attr,
633 	&dev_attr_client_monitor_pending.attr,
634 	&dev_attr_server_monitor_latency.attr,
635 	&dev_attr_client_monitor_latency.attr,
636 	&dev_attr_server_monitor_conn_id.attr,
637 	&dev_attr_client_monitor_conn_id.attr,
638 	&dev_attr_out_intr_mask.attr,
639 	&dev_attr_out_read_index.attr,
640 	&dev_attr_out_write_index.attr,
641 	&dev_attr_out_read_bytes_avail.attr,
642 	&dev_attr_out_write_bytes_avail.attr,
643 	&dev_attr_in_intr_mask.attr,
644 	&dev_attr_in_read_index.attr,
645 	&dev_attr_in_write_index.attr,
646 	&dev_attr_in_read_bytes_avail.attr,
647 	&dev_attr_in_write_bytes_avail.attr,
648 	&dev_attr_channel_vp_mapping.attr,
649 	&dev_attr_vendor.attr,
650 	&dev_attr_device.attr,
651 	&dev_attr_driver_override.attr,
652 	NULL,
653 };
654 
655 /*
656  * Device-level attribute_group callback function. Returns the permission for
657  * each attribute, and returns 0 if an attribute is not visible.
658  */
659 static umode_t vmbus_dev_attr_is_visible(struct kobject *kobj,
660 					 struct attribute *attr, int idx)
661 {
662 	struct device *dev = kobj_to_dev(kobj);
663 	const struct hv_device *hv_dev = device_to_hv_device(dev);
664 
665 	/* Hide the monitor attributes if the monitor mechanism is not used. */
666 	if (!hv_dev->channel->offermsg.monitor_allocated &&
667 	    (attr == &dev_attr_monitor_id.attr ||
668 	     attr == &dev_attr_server_monitor_pending.attr ||
669 	     attr == &dev_attr_client_monitor_pending.attr ||
670 	     attr == &dev_attr_server_monitor_latency.attr ||
671 	     attr == &dev_attr_client_monitor_latency.attr ||
672 	     attr == &dev_attr_server_monitor_conn_id.attr ||
673 	     attr == &dev_attr_client_monitor_conn_id.attr))
674 		return 0;
675 
676 	return attr->mode;
677 }
678 
679 static const struct attribute_group vmbus_dev_group = {
680 	.attrs = vmbus_dev_attrs,
681 	.is_visible = vmbus_dev_attr_is_visible
682 };
683 __ATTRIBUTE_GROUPS(vmbus_dev);
684 
685 /* Set up the attribute for /sys/bus/vmbus/hibernation */
686 static ssize_t hibernation_show(struct bus_type *bus, char *buf)
687 {
688 	return sprintf(buf, "%d\n", !!hv_is_hibernation_supported());
689 }
690 
691 static BUS_ATTR_RO(hibernation);
692 
693 static struct attribute *vmbus_bus_attrs[] = {
694 	&bus_attr_hibernation.attr,
695 	NULL,
696 };
697 static const struct attribute_group vmbus_bus_group = {
698 	.attrs = vmbus_bus_attrs,
699 };
700 __ATTRIBUTE_GROUPS(vmbus_bus);
701 
702 /*
703  * vmbus_uevent - add uevent for our device
704  *
705  * This routine is invoked when a device is added or removed on the vmbus to
706  * generate a uevent to udev in the userspace. The udev will then look at its
707  * rule and the uevent generated here to load the appropriate driver
708  *
709  * The alias string will be of the form vmbus:guid where guid is the string
710  * representation of the device guid (each byte of the guid will be
711  * represented with two hex characters.
712  */
713 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
714 {
715 	struct hv_device *dev = device_to_hv_device(device);
716 	const char *format = "MODALIAS=vmbus:%*phN";
717 
718 	return add_uevent_var(env, format, UUID_SIZE, &dev->dev_type);
719 }
720 
721 static const struct hv_vmbus_device_id *
722 hv_vmbus_dev_match(const struct hv_vmbus_device_id *id, const guid_t *guid)
723 {
724 	if (id == NULL)
725 		return NULL; /* empty device table */
726 
727 	for (; !guid_is_null(&id->guid); id++)
728 		if (guid_equal(&id->guid, guid))
729 			return id;
730 
731 	return NULL;
732 }
733 
734 static const struct hv_vmbus_device_id *
735 hv_vmbus_dynid_match(struct hv_driver *drv, const guid_t *guid)
736 {
737 	const struct hv_vmbus_device_id *id = NULL;
738 	struct vmbus_dynid *dynid;
739 
740 	spin_lock(&drv->dynids.lock);
741 	list_for_each_entry(dynid, &drv->dynids.list, node) {
742 		if (guid_equal(&dynid->id.guid, guid)) {
743 			id = &dynid->id;
744 			break;
745 		}
746 	}
747 	spin_unlock(&drv->dynids.lock);
748 
749 	return id;
750 }
751 
752 static const struct hv_vmbus_device_id vmbus_device_null;
753 
754 /*
755  * Return a matching hv_vmbus_device_id pointer.
756  * If there is no match, return NULL.
757  */
758 static const struct hv_vmbus_device_id *hv_vmbus_get_id(struct hv_driver *drv,
759 							struct hv_device *dev)
760 {
761 	const guid_t *guid = &dev->dev_type;
762 	const struct hv_vmbus_device_id *id;
763 
764 	/* When driver_override is set, only bind to the matching driver */
765 	if (dev->driver_override && strcmp(dev->driver_override, drv->name))
766 		return NULL;
767 
768 	/* Look at the dynamic ids first, before the static ones */
769 	id = hv_vmbus_dynid_match(drv, guid);
770 	if (!id)
771 		id = hv_vmbus_dev_match(drv->id_table, guid);
772 
773 	/* driver_override will always match, send a dummy id */
774 	if (!id && dev->driver_override)
775 		id = &vmbus_device_null;
776 
777 	return id;
778 }
779 
780 /* vmbus_add_dynid - add a new device ID to this driver and re-probe devices */
781 static int vmbus_add_dynid(struct hv_driver *drv, guid_t *guid)
782 {
783 	struct vmbus_dynid *dynid;
784 
785 	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
786 	if (!dynid)
787 		return -ENOMEM;
788 
789 	dynid->id.guid = *guid;
790 
791 	spin_lock(&drv->dynids.lock);
792 	list_add_tail(&dynid->node, &drv->dynids.list);
793 	spin_unlock(&drv->dynids.lock);
794 
795 	return driver_attach(&drv->driver);
796 }
797 
798 static void vmbus_free_dynids(struct hv_driver *drv)
799 {
800 	struct vmbus_dynid *dynid, *n;
801 
802 	spin_lock(&drv->dynids.lock);
803 	list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
804 		list_del(&dynid->node);
805 		kfree(dynid);
806 	}
807 	spin_unlock(&drv->dynids.lock);
808 }
809 
810 /*
811  * store_new_id - sysfs frontend to vmbus_add_dynid()
812  *
813  * Allow GUIDs to be added to an existing driver via sysfs.
814  */
815 static ssize_t new_id_store(struct device_driver *driver, const char *buf,
816 			    size_t count)
817 {
818 	struct hv_driver *drv = drv_to_hv_drv(driver);
819 	guid_t guid;
820 	ssize_t retval;
821 
822 	retval = guid_parse(buf, &guid);
823 	if (retval)
824 		return retval;
825 
826 	if (hv_vmbus_dynid_match(drv, &guid))
827 		return -EEXIST;
828 
829 	retval = vmbus_add_dynid(drv, &guid);
830 	if (retval)
831 		return retval;
832 	return count;
833 }
834 static DRIVER_ATTR_WO(new_id);
835 
836 /*
837  * store_remove_id - remove a PCI device ID from this driver
838  *
839  * Removes a dynamic pci device ID to this driver.
840  */
841 static ssize_t remove_id_store(struct device_driver *driver, const char *buf,
842 			       size_t count)
843 {
844 	struct hv_driver *drv = drv_to_hv_drv(driver);
845 	struct vmbus_dynid *dynid, *n;
846 	guid_t guid;
847 	ssize_t retval;
848 
849 	retval = guid_parse(buf, &guid);
850 	if (retval)
851 		return retval;
852 
853 	retval = -ENODEV;
854 	spin_lock(&drv->dynids.lock);
855 	list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
856 		struct hv_vmbus_device_id *id = &dynid->id;
857 
858 		if (guid_equal(&id->guid, &guid)) {
859 			list_del(&dynid->node);
860 			kfree(dynid);
861 			retval = count;
862 			break;
863 		}
864 	}
865 	spin_unlock(&drv->dynids.lock);
866 
867 	return retval;
868 }
869 static DRIVER_ATTR_WO(remove_id);
870 
871 static struct attribute *vmbus_drv_attrs[] = {
872 	&driver_attr_new_id.attr,
873 	&driver_attr_remove_id.attr,
874 	NULL,
875 };
876 ATTRIBUTE_GROUPS(vmbus_drv);
877 
878 
879 /*
880  * vmbus_match - Attempt to match the specified device to the specified driver
881  */
882 static int vmbus_match(struct device *device, struct device_driver *driver)
883 {
884 	struct hv_driver *drv = drv_to_hv_drv(driver);
885 	struct hv_device *hv_dev = device_to_hv_device(device);
886 
887 	/* The hv_sock driver handles all hv_sock offers. */
888 	if (is_hvsock_channel(hv_dev->channel))
889 		return drv->hvsock;
890 
891 	if (hv_vmbus_get_id(drv, hv_dev))
892 		return 1;
893 
894 	return 0;
895 }
896 
897 /*
898  * vmbus_probe - Add the new vmbus's child device
899  */
900 static int vmbus_probe(struct device *child_device)
901 {
902 	int ret = 0;
903 	struct hv_driver *drv =
904 			drv_to_hv_drv(child_device->driver);
905 	struct hv_device *dev = device_to_hv_device(child_device);
906 	const struct hv_vmbus_device_id *dev_id;
907 
908 	dev_id = hv_vmbus_get_id(drv, dev);
909 	if (drv->probe) {
910 		ret = drv->probe(dev, dev_id);
911 		if (ret != 0)
912 			pr_err("probe failed for device %s (%d)\n",
913 			       dev_name(child_device), ret);
914 
915 	} else {
916 		pr_err("probe not set for driver %s\n",
917 		       dev_name(child_device));
918 		ret = -ENODEV;
919 	}
920 	return ret;
921 }
922 
923 /*
924  * vmbus_remove - Remove a vmbus device
925  */
926 static void vmbus_remove(struct device *child_device)
927 {
928 	struct hv_driver *drv;
929 	struct hv_device *dev = device_to_hv_device(child_device);
930 
931 	if (child_device->driver) {
932 		drv = drv_to_hv_drv(child_device->driver);
933 		if (drv->remove)
934 			drv->remove(dev);
935 	}
936 }
937 
938 /*
939  * vmbus_shutdown - Shutdown a vmbus device
940  */
941 static void vmbus_shutdown(struct device *child_device)
942 {
943 	struct hv_driver *drv;
944 	struct hv_device *dev = device_to_hv_device(child_device);
945 
946 
947 	/* The device may not be attached yet */
948 	if (!child_device->driver)
949 		return;
950 
951 	drv = drv_to_hv_drv(child_device->driver);
952 
953 	if (drv->shutdown)
954 		drv->shutdown(dev);
955 }
956 
957 #ifdef CONFIG_PM_SLEEP
958 /*
959  * vmbus_suspend - Suspend a vmbus device
960  */
961 static int vmbus_suspend(struct device *child_device)
962 {
963 	struct hv_driver *drv;
964 	struct hv_device *dev = device_to_hv_device(child_device);
965 
966 	/* The device may not be attached yet */
967 	if (!child_device->driver)
968 		return 0;
969 
970 	drv = drv_to_hv_drv(child_device->driver);
971 	if (!drv->suspend)
972 		return -EOPNOTSUPP;
973 
974 	return drv->suspend(dev);
975 }
976 
977 /*
978  * vmbus_resume - Resume a vmbus device
979  */
980 static int vmbus_resume(struct device *child_device)
981 {
982 	struct hv_driver *drv;
983 	struct hv_device *dev = device_to_hv_device(child_device);
984 
985 	/* The device may not be attached yet */
986 	if (!child_device->driver)
987 		return 0;
988 
989 	drv = drv_to_hv_drv(child_device->driver);
990 	if (!drv->resume)
991 		return -EOPNOTSUPP;
992 
993 	return drv->resume(dev);
994 }
995 #else
996 #define vmbus_suspend NULL
997 #define vmbus_resume NULL
998 #endif /* CONFIG_PM_SLEEP */
999 
1000 /*
1001  * vmbus_device_release - Final callback release of the vmbus child device
1002  */
1003 static void vmbus_device_release(struct device *device)
1004 {
1005 	struct hv_device *hv_dev = device_to_hv_device(device);
1006 	struct vmbus_channel *channel = hv_dev->channel;
1007 
1008 	hv_debug_rm_dev_dir(hv_dev);
1009 
1010 	mutex_lock(&vmbus_connection.channel_mutex);
1011 	hv_process_channel_removal(channel);
1012 	mutex_unlock(&vmbus_connection.channel_mutex);
1013 	kfree(hv_dev);
1014 }
1015 
1016 /*
1017  * Note: we must use the "noirq" ops: see the comment before vmbus_bus_pm.
1018  *
1019  * suspend_noirq/resume_noirq are set to NULL to support Suspend-to-Idle: we
1020  * shouldn't suspend the vmbus devices upon Suspend-to-Idle, otherwise there
1021  * is no way to wake up a Generation-2 VM.
1022  *
1023  * The other 4 ops are for hibernation.
1024  */
1025 
1026 static const struct dev_pm_ops vmbus_pm = {
1027 	.suspend_noirq	= NULL,
1028 	.resume_noirq	= NULL,
1029 	.freeze_noirq	= vmbus_suspend,
1030 	.thaw_noirq	= vmbus_resume,
1031 	.poweroff_noirq	= vmbus_suspend,
1032 	.restore_noirq	= vmbus_resume,
1033 };
1034 
1035 /* The one and only one */
1036 static struct bus_type  hv_bus = {
1037 	.name =		"vmbus",
1038 	.match =		vmbus_match,
1039 	.shutdown =		vmbus_shutdown,
1040 	.remove =		vmbus_remove,
1041 	.probe =		vmbus_probe,
1042 	.uevent =		vmbus_uevent,
1043 	.dev_groups =		vmbus_dev_groups,
1044 	.drv_groups =		vmbus_drv_groups,
1045 	.bus_groups =		vmbus_bus_groups,
1046 	.pm =			&vmbus_pm,
1047 };
1048 
1049 struct onmessage_work_context {
1050 	struct work_struct work;
1051 	struct {
1052 		struct hv_message_header header;
1053 		u8 payload[];
1054 	} msg;
1055 };
1056 
1057 static void vmbus_onmessage_work(struct work_struct *work)
1058 {
1059 	struct onmessage_work_context *ctx;
1060 
1061 	/* Do not process messages if we're in DISCONNECTED state */
1062 	if (vmbus_connection.conn_state == DISCONNECTED)
1063 		return;
1064 
1065 	ctx = container_of(work, struct onmessage_work_context,
1066 			   work);
1067 	vmbus_onmessage((struct vmbus_channel_message_header *)
1068 			&ctx->msg.payload);
1069 	kfree(ctx);
1070 }
1071 
1072 void vmbus_on_msg_dpc(unsigned long data)
1073 {
1074 	struct hv_per_cpu_context *hv_cpu = (void *)data;
1075 	void *page_addr = hv_cpu->synic_message_page;
1076 	struct hv_message msg_copy, *msg = (struct hv_message *)page_addr +
1077 				  VMBUS_MESSAGE_SINT;
1078 	struct vmbus_channel_message_header *hdr;
1079 	enum vmbus_channel_message_type msgtype;
1080 	const struct vmbus_channel_message_table_entry *entry;
1081 	struct onmessage_work_context *ctx;
1082 	__u8 payload_size;
1083 	u32 message_type;
1084 
1085 	/*
1086 	 * 'enum vmbus_channel_message_type' is supposed to always be 'u32' as
1087 	 * it is being used in 'struct vmbus_channel_message_header' definition
1088 	 * which is supposed to match hypervisor ABI.
1089 	 */
1090 	BUILD_BUG_ON(sizeof(enum vmbus_channel_message_type) != sizeof(u32));
1091 
1092 	/*
1093 	 * Since the message is in memory shared with the host, an erroneous or
1094 	 * malicious Hyper-V could modify the message while vmbus_on_msg_dpc()
1095 	 * or individual message handlers are executing; to prevent this, copy
1096 	 * the message into private memory.
1097 	 */
1098 	memcpy(&msg_copy, msg, sizeof(struct hv_message));
1099 
1100 	message_type = msg_copy.header.message_type;
1101 	if (message_type == HVMSG_NONE)
1102 		/* no msg */
1103 		return;
1104 
1105 	hdr = (struct vmbus_channel_message_header *)msg_copy.u.payload;
1106 	msgtype = hdr->msgtype;
1107 
1108 	trace_vmbus_on_msg_dpc(hdr);
1109 
1110 	if (msgtype >= CHANNELMSG_COUNT) {
1111 		WARN_ONCE(1, "unknown msgtype=%d\n", msgtype);
1112 		goto msg_handled;
1113 	}
1114 
1115 	payload_size = msg_copy.header.payload_size;
1116 	if (payload_size > HV_MESSAGE_PAYLOAD_BYTE_COUNT) {
1117 		WARN_ONCE(1, "payload size is too large (%d)\n", payload_size);
1118 		goto msg_handled;
1119 	}
1120 
1121 	entry = &channel_message_table[msgtype];
1122 
1123 	if (!entry->message_handler)
1124 		goto msg_handled;
1125 
1126 	if (payload_size < entry->min_payload_len) {
1127 		WARN_ONCE(1, "message too short: msgtype=%d len=%d\n", msgtype, payload_size);
1128 		goto msg_handled;
1129 	}
1130 
1131 	if (entry->handler_type	== VMHT_BLOCKING) {
1132 		ctx = kmalloc(struct_size(ctx, msg.payload, payload_size), GFP_ATOMIC);
1133 		if (ctx == NULL)
1134 			return;
1135 
1136 		INIT_WORK(&ctx->work, vmbus_onmessage_work);
1137 		memcpy(&ctx->msg, &msg_copy, sizeof(msg->header) + payload_size);
1138 
1139 		/*
1140 		 * The host can generate a rescind message while we
1141 		 * may still be handling the original offer. We deal with
1142 		 * this condition by relying on the synchronization provided
1143 		 * by offer_in_progress and by channel_mutex.  See also the
1144 		 * inline comments in vmbus_onoffer_rescind().
1145 		 */
1146 		switch (msgtype) {
1147 		case CHANNELMSG_RESCIND_CHANNELOFFER:
1148 			/*
1149 			 * If we are handling the rescind message;
1150 			 * schedule the work on the global work queue.
1151 			 *
1152 			 * The OFFER message and the RESCIND message should
1153 			 * not be handled by the same serialized work queue,
1154 			 * because the OFFER handler may call vmbus_open(),
1155 			 * which tries to open the channel by sending an
1156 			 * OPEN_CHANNEL message to the host and waits for
1157 			 * the host's response; however, if the host has
1158 			 * rescinded the channel before it receives the
1159 			 * OPEN_CHANNEL message, the host just silently
1160 			 * ignores the OPEN_CHANNEL message; as a result,
1161 			 * the guest's OFFER handler hangs for ever, if we
1162 			 * handle the RESCIND message in the same serialized
1163 			 * work queue: the RESCIND handler can not start to
1164 			 * run before the OFFER handler finishes.
1165 			 */
1166 			schedule_work(&ctx->work);
1167 			break;
1168 
1169 		case CHANNELMSG_OFFERCHANNEL:
1170 			/*
1171 			 * The host sends the offer message of a given channel
1172 			 * before sending the rescind message of the same
1173 			 * channel.  These messages are sent to the guest's
1174 			 * connect CPU; the guest then starts processing them
1175 			 * in the tasklet handler on this CPU:
1176 			 *
1177 			 * VMBUS_CONNECT_CPU
1178 			 *
1179 			 * [vmbus_on_msg_dpc()]
1180 			 * atomic_inc()  // CHANNELMSG_OFFERCHANNEL
1181 			 * queue_work()
1182 			 * ...
1183 			 * [vmbus_on_msg_dpc()]
1184 			 * schedule_work()  // CHANNELMSG_RESCIND_CHANNELOFFER
1185 			 *
1186 			 * We rely on the memory-ordering properties of the
1187 			 * queue_work() and schedule_work() primitives, which
1188 			 * guarantee that the atomic increment will be visible
1189 			 * to the CPUs which will execute the offer & rescind
1190 			 * works by the time these works will start execution.
1191 			 */
1192 			atomic_inc(&vmbus_connection.offer_in_progress);
1193 			fallthrough;
1194 
1195 		default:
1196 			queue_work(vmbus_connection.work_queue, &ctx->work);
1197 		}
1198 	} else
1199 		entry->message_handler(hdr);
1200 
1201 msg_handled:
1202 	vmbus_signal_eom(msg, message_type);
1203 }
1204 
1205 #ifdef CONFIG_PM_SLEEP
1206 /*
1207  * Fake RESCIND_CHANNEL messages to clean up hv_sock channels by force for
1208  * hibernation, because hv_sock connections can not persist across hibernation.
1209  */
1210 static void vmbus_force_channel_rescinded(struct vmbus_channel *channel)
1211 {
1212 	struct onmessage_work_context *ctx;
1213 	struct vmbus_channel_rescind_offer *rescind;
1214 
1215 	WARN_ON(!is_hvsock_channel(channel));
1216 
1217 	/*
1218 	 * Allocation size is small and the allocation should really not fail,
1219 	 * otherwise the state of the hv_sock connections ends up in limbo.
1220 	 */
1221 	ctx = kzalloc(sizeof(*ctx) + sizeof(*rescind),
1222 		      GFP_KERNEL | __GFP_NOFAIL);
1223 
1224 	/*
1225 	 * So far, these are not really used by Linux. Just set them to the
1226 	 * reasonable values conforming to the definitions of the fields.
1227 	 */
1228 	ctx->msg.header.message_type = 1;
1229 	ctx->msg.header.payload_size = sizeof(*rescind);
1230 
1231 	/* These values are actually used by Linux. */
1232 	rescind = (struct vmbus_channel_rescind_offer *)ctx->msg.payload;
1233 	rescind->header.msgtype = CHANNELMSG_RESCIND_CHANNELOFFER;
1234 	rescind->child_relid = channel->offermsg.child_relid;
1235 
1236 	INIT_WORK(&ctx->work, vmbus_onmessage_work);
1237 
1238 	queue_work(vmbus_connection.work_queue, &ctx->work);
1239 }
1240 #endif /* CONFIG_PM_SLEEP */
1241 
1242 /*
1243  * Schedule all channels with events pending
1244  */
1245 static void vmbus_chan_sched(struct hv_per_cpu_context *hv_cpu)
1246 {
1247 	unsigned long *recv_int_page;
1248 	u32 maxbits, relid;
1249 
1250 	if (vmbus_proto_version < VERSION_WIN8) {
1251 		maxbits = MAX_NUM_CHANNELS_SUPPORTED;
1252 		recv_int_page = vmbus_connection.recv_int_page;
1253 	} else {
1254 		/*
1255 		 * When the host is win8 and beyond, the event page
1256 		 * can be directly checked to get the id of the channel
1257 		 * that has the interrupt pending.
1258 		 */
1259 		void *page_addr = hv_cpu->synic_event_page;
1260 		union hv_synic_event_flags *event
1261 			= (union hv_synic_event_flags *)page_addr +
1262 						 VMBUS_MESSAGE_SINT;
1263 
1264 		maxbits = HV_EVENT_FLAGS_COUNT;
1265 		recv_int_page = event->flags;
1266 	}
1267 
1268 	if (unlikely(!recv_int_page))
1269 		return;
1270 
1271 	for_each_set_bit(relid, recv_int_page, maxbits) {
1272 		void (*callback_fn)(void *context);
1273 		struct vmbus_channel *channel;
1274 
1275 		if (!sync_test_and_clear_bit(relid, recv_int_page))
1276 			continue;
1277 
1278 		/* Special case - vmbus channel protocol msg */
1279 		if (relid == 0)
1280 			continue;
1281 
1282 		/*
1283 		 * Pairs with the kfree_rcu() in vmbus_chan_release().
1284 		 * Guarantees that the channel data structure doesn't
1285 		 * get freed while the channel pointer below is being
1286 		 * dereferenced.
1287 		 */
1288 		rcu_read_lock();
1289 
1290 		/* Find channel based on relid */
1291 		channel = relid2channel(relid);
1292 		if (channel == NULL)
1293 			goto sched_unlock_rcu;
1294 
1295 		if (channel->rescind)
1296 			goto sched_unlock_rcu;
1297 
1298 		/*
1299 		 * Make sure that the ring buffer data structure doesn't get
1300 		 * freed while we dereference the ring buffer pointer.  Test
1301 		 * for the channel's onchannel_callback being NULL within a
1302 		 * sched_lock critical section.  See also the inline comments
1303 		 * in vmbus_reset_channel_cb().
1304 		 */
1305 		spin_lock(&channel->sched_lock);
1306 
1307 		callback_fn = channel->onchannel_callback;
1308 		if (unlikely(callback_fn == NULL))
1309 			goto sched_unlock;
1310 
1311 		trace_vmbus_chan_sched(channel);
1312 
1313 		++channel->interrupts;
1314 
1315 		switch (channel->callback_mode) {
1316 		case HV_CALL_ISR:
1317 			(*callback_fn)(channel->channel_callback_context);
1318 			break;
1319 
1320 		case HV_CALL_BATCHED:
1321 			hv_begin_read(&channel->inbound);
1322 			fallthrough;
1323 		case HV_CALL_DIRECT:
1324 			tasklet_schedule(&channel->callback_event);
1325 		}
1326 
1327 sched_unlock:
1328 		spin_unlock(&channel->sched_lock);
1329 sched_unlock_rcu:
1330 		rcu_read_unlock();
1331 	}
1332 }
1333 
1334 static void vmbus_isr(void)
1335 {
1336 	struct hv_per_cpu_context *hv_cpu
1337 		= this_cpu_ptr(hv_context.cpu_context);
1338 	void *page_addr = hv_cpu->synic_event_page;
1339 	struct hv_message *msg;
1340 	union hv_synic_event_flags *event;
1341 	bool handled = false;
1342 
1343 	if (unlikely(page_addr == NULL))
1344 		return;
1345 
1346 	event = (union hv_synic_event_flags *)page_addr +
1347 					 VMBUS_MESSAGE_SINT;
1348 	/*
1349 	 * Check for events before checking for messages. This is the order
1350 	 * in which events and messages are checked in Windows guests on
1351 	 * Hyper-V, and the Windows team suggested we do the same.
1352 	 */
1353 
1354 	if ((vmbus_proto_version == VERSION_WS2008) ||
1355 		(vmbus_proto_version == VERSION_WIN7)) {
1356 
1357 		/* Since we are a child, we only need to check bit 0 */
1358 		if (sync_test_and_clear_bit(0, event->flags))
1359 			handled = true;
1360 	} else {
1361 		/*
1362 		 * Our host is win8 or above. The signaling mechanism
1363 		 * has changed and we can directly look at the event page.
1364 		 * If bit n is set then we have an interrup on the channel
1365 		 * whose id is n.
1366 		 */
1367 		handled = true;
1368 	}
1369 
1370 	if (handled)
1371 		vmbus_chan_sched(hv_cpu);
1372 
1373 	page_addr = hv_cpu->synic_message_page;
1374 	msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
1375 
1376 	/* Check if there are actual msgs to be processed */
1377 	if (msg->header.message_type != HVMSG_NONE) {
1378 		if (msg->header.message_type == HVMSG_TIMER_EXPIRED) {
1379 			hv_stimer0_isr();
1380 			vmbus_signal_eom(msg, HVMSG_TIMER_EXPIRED);
1381 		} else
1382 			tasklet_schedule(&hv_cpu->msg_dpc);
1383 	}
1384 
1385 	add_interrupt_randomness(vmbus_interrupt);
1386 }
1387 
1388 static irqreturn_t vmbus_percpu_isr(int irq, void *dev_id)
1389 {
1390 	vmbus_isr();
1391 	return IRQ_HANDLED;
1392 }
1393 
1394 /*
1395  * Callback from kmsg_dump. Grab as much as possible from the end of the kmsg
1396  * buffer and call into Hyper-V to transfer the data.
1397  */
1398 static void hv_kmsg_dump(struct kmsg_dumper *dumper,
1399 			 enum kmsg_dump_reason reason)
1400 {
1401 	struct kmsg_dump_iter iter;
1402 	size_t bytes_written;
1403 
1404 	/* We are only interested in panics. */
1405 	if ((reason != KMSG_DUMP_PANIC) || (!sysctl_record_panic_msg))
1406 		return;
1407 
1408 	/*
1409 	 * Write dump contents to the page. No need to synchronize; panic should
1410 	 * be single-threaded.
1411 	 */
1412 	kmsg_dump_rewind(&iter);
1413 	kmsg_dump_get_buffer(&iter, false, hv_panic_page, HV_HYP_PAGE_SIZE,
1414 			     &bytes_written);
1415 	if (!bytes_written)
1416 		return;
1417 	/*
1418 	 * P3 to contain the physical address of the panic page & P4 to
1419 	 * contain the size of the panic data in that page. Rest of the
1420 	 * registers are no-op when the NOTIFY_MSG flag is set.
1421 	 */
1422 	hv_set_register(HV_REGISTER_CRASH_P0, 0);
1423 	hv_set_register(HV_REGISTER_CRASH_P1, 0);
1424 	hv_set_register(HV_REGISTER_CRASH_P2, 0);
1425 	hv_set_register(HV_REGISTER_CRASH_P3, virt_to_phys(hv_panic_page));
1426 	hv_set_register(HV_REGISTER_CRASH_P4, bytes_written);
1427 
1428 	/*
1429 	 * Let Hyper-V know there is crash data available along with
1430 	 * the panic message.
1431 	 */
1432 	hv_set_register(HV_REGISTER_CRASH_CTL,
1433 	       (HV_CRASH_CTL_CRASH_NOTIFY | HV_CRASH_CTL_CRASH_NOTIFY_MSG));
1434 }
1435 
1436 static struct kmsg_dumper hv_kmsg_dumper = {
1437 	.dump = hv_kmsg_dump,
1438 };
1439 
1440 static void hv_kmsg_dump_register(void)
1441 {
1442 	int ret;
1443 
1444 	hv_panic_page = hv_alloc_hyperv_zeroed_page();
1445 	if (!hv_panic_page) {
1446 		pr_err("Hyper-V: panic message page memory allocation failed\n");
1447 		return;
1448 	}
1449 
1450 	ret = kmsg_dump_register(&hv_kmsg_dumper);
1451 	if (ret) {
1452 		pr_err("Hyper-V: kmsg dump register error 0x%x\n", ret);
1453 		hv_free_hyperv_page((unsigned long)hv_panic_page);
1454 		hv_panic_page = NULL;
1455 	}
1456 }
1457 
1458 static struct ctl_table_header *hv_ctl_table_hdr;
1459 
1460 /*
1461  * sysctl option to allow the user to control whether kmsg data should be
1462  * reported to Hyper-V on panic.
1463  */
1464 static struct ctl_table hv_ctl_table[] = {
1465 	{
1466 		.procname       = "hyperv_record_panic_msg",
1467 		.data           = &sysctl_record_panic_msg,
1468 		.maxlen         = sizeof(int),
1469 		.mode           = 0644,
1470 		.proc_handler   = proc_dointvec_minmax,
1471 		.extra1		= SYSCTL_ZERO,
1472 		.extra2		= SYSCTL_ONE
1473 	},
1474 	{}
1475 };
1476 
1477 static struct ctl_table hv_root_table[] = {
1478 	{
1479 		.procname	= "kernel",
1480 		.mode		= 0555,
1481 		.child		= hv_ctl_table
1482 	},
1483 	{}
1484 };
1485 
1486 /*
1487  * vmbus_bus_init -Main vmbus driver initialization routine.
1488  *
1489  * Here, we
1490  *	- initialize the vmbus driver context
1491  *	- invoke the vmbus hv main init routine
1492  *	- retrieve the channel offers
1493  */
1494 static int vmbus_bus_init(void)
1495 {
1496 	int ret;
1497 
1498 	ret = hv_init();
1499 	if (ret != 0) {
1500 		pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
1501 		return ret;
1502 	}
1503 
1504 	ret = bus_register(&hv_bus);
1505 	if (ret)
1506 		return ret;
1507 
1508 	/*
1509 	 * VMbus interrupts are best modeled as per-cpu interrupts. If
1510 	 * on an architecture with support for per-cpu IRQs (e.g. ARM64),
1511 	 * allocate a per-cpu IRQ using standard Linux kernel functionality.
1512 	 * If not on such an architecture (e.g., x86/x64), then rely on
1513 	 * code in the arch-specific portion of the code tree to connect
1514 	 * the VMbus interrupt handler.
1515 	 */
1516 
1517 	if (vmbus_irq == -1) {
1518 		hv_setup_vmbus_handler(vmbus_isr);
1519 	} else {
1520 		vmbus_evt = alloc_percpu(long);
1521 		ret = request_percpu_irq(vmbus_irq, vmbus_percpu_isr,
1522 				"Hyper-V VMbus", vmbus_evt);
1523 		if (ret) {
1524 			pr_err("Can't request Hyper-V VMbus IRQ %d, Err %d",
1525 					vmbus_irq, ret);
1526 			free_percpu(vmbus_evt);
1527 			goto err_setup;
1528 		}
1529 	}
1530 
1531 	ret = hv_synic_alloc();
1532 	if (ret)
1533 		goto err_alloc;
1534 
1535 	/*
1536 	 * Initialize the per-cpu interrupt state and stimer state.
1537 	 * Then connect to the host.
1538 	 */
1539 	ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "hyperv/vmbus:online",
1540 				hv_synic_init, hv_synic_cleanup);
1541 	if (ret < 0)
1542 		goto err_cpuhp;
1543 	hyperv_cpuhp_online = ret;
1544 
1545 	ret = vmbus_connect();
1546 	if (ret)
1547 		goto err_connect;
1548 
1549 	/*
1550 	 * Only register if the crash MSRs are available
1551 	 */
1552 	if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
1553 		u64 hyperv_crash_ctl;
1554 		/*
1555 		 * Sysctl registration is not fatal, since by default
1556 		 * reporting is enabled.
1557 		 */
1558 		hv_ctl_table_hdr = register_sysctl_table(hv_root_table);
1559 		if (!hv_ctl_table_hdr)
1560 			pr_err("Hyper-V: sysctl table register error");
1561 
1562 		/*
1563 		 * Register for panic kmsg callback only if the right
1564 		 * capability is supported by the hypervisor.
1565 		 */
1566 		hyperv_crash_ctl = hv_get_register(HV_REGISTER_CRASH_CTL);
1567 		if (hyperv_crash_ctl & HV_CRASH_CTL_CRASH_NOTIFY_MSG)
1568 			hv_kmsg_dump_register();
1569 
1570 		register_die_notifier(&hyperv_die_block);
1571 	}
1572 
1573 	/*
1574 	 * Always register the panic notifier because we need to unload
1575 	 * the VMbus channel connection to prevent any VMbus
1576 	 * activity after the VM panics.
1577 	 */
1578 	atomic_notifier_chain_register(&panic_notifier_list,
1579 			       &hyperv_panic_block);
1580 
1581 	vmbus_request_offers();
1582 
1583 	return 0;
1584 
1585 err_connect:
1586 	cpuhp_remove_state(hyperv_cpuhp_online);
1587 err_cpuhp:
1588 	hv_synic_free();
1589 err_alloc:
1590 	if (vmbus_irq == -1) {
1591 		hv_remove_vmbus_handler();
1592 	} else {
1593 		free_percpu_irq(vmbus_irq, vmbus_evt);
1594 		free_percpu(vmbus_evt);
1595 	}
1596 err_setup:
1597 	bus_unregister(&hv_bus);
1598 	unregister_sysctl_table(hv_ctl_table_hdr);
1599 	hv_ctl_table_hdr = NULL;
1600 	return ret;
1601 }
1602 
1603 /**
1604  * __vmbus_child_driver_register() - Register a vmbus's driver
1605  * @hv_driver: Pointer to driver structure you want to register
1606  * @owner: owner module of the drv
1607  * @mod_name: module name string
1608  *
1609  * Registers the given driver with Linux through the 'driver_register()' call
1610  * and sets up the hyper-v vmbus handling for this driver.
1611  * It will return the state of the 'driver_register()' call.
1612  *
1613  */
1614 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
1615 {
1616 	int ret;
1617 
1618 	pr_info("registering driver %s\n", hv_driver->name);
1619 
1620 	ret = vmbus_exists();
1621 	if (ret < 0)
1622 		return ret;
1623 
1624 	hv_driver->driver.name = hv_driver->name;
1625 	hv_driver->driver.owner = owner;
1626 	hv_driver->driver.mod_name = mod_name;
1627 	hv_driver->driver.bus = &hv_bus;
1628 
1629 	spin_lock_init(&hv_driver->dynids.lock);
1630 	INIT_LIST_HEAD(&hv_driver->dynids.list);
1631 
1632 	ret = driver_register(&hv_driver->driver);
1633 
1634 	return ret;
1635 }
1636 EXPORT_SYMBOL_GPL(__vmbus_driver_register);
1637 
1638 /**
1639  * vmbus_driver_unregister() - Unregister a vmbus's driver
1640  * @hv_driver: Pointer to driver structure you want to
1641  *             un-register
1642  *
1643  * Un-register the given driver that was previous registered with a call to
1644  * vmbus_driver_register()
1645  */
1646 void vmbus_driver_unregister(struct hv_driver *hv_driver)
1647 {
1648 	pr_info("unregistering driver %s\n", hv_driver->name);
1649 
1650 	if (!vmbus_exists()) {
1651 		driver_unregister(&hv_driver->driver);
1652 		vmbus_free_dynids(hv_driver);
1653 	}
1654 }
1655 EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
1656 
1657 
1658 /*
1659  * Called when last reference to channel is gone.
1660  */
1661 static void vmbus_chan_release(struct kobject *kobj)
1662 {
1663 	struct vmbus_channel *channel
1664 		= container_of(kobj, struct vmbus_channel, kobj);
1665 
1666 	kfree_rcu(channel, rcu);
1667 }
1668 
1669 struct vmbus_chan_attribute {
1670 	struct attribute attr;
1671 	ssize_t (*show)(struct vmbus_channel *chan, char *buf);
1672 	ssize_t (*store)(struct vmbus_channel *chan,
1673 			 const char *buf, size_t count);
1674 };
1675 #define VMBUS_CHAN_ATTR(_name, _mode, _show, _store) \
1676 	struct vmbus_chan_attribute chan_attr_##_name \
1677 		= __ATTR(_name, _mode, _show, _store)
1678 #define VMBUS_CHAN_ATTR_RW(_name) \
1679 	struct vmbus_chan_attribute chan_attr_##_name = __ATTR_RW(_name)
1680 #define VMBUS_CHAN_ATTR_RO(_name) \
1681 	struct vmbus_chan_attribute chan_attr_##_name = __ATTR_RO(_name)
1682 #define VMBUS_CHAN_ATTR_WO(_name) \
1683 	struct vmbus_chan_attribute chan_attr_##_name = __ATTR_WO(_name)
1684 
1685 static ssize_t vmbus_chan_attr_show(struct kobject *kobj,
1686 				    struct attribute *attr, char *buf)
1687 {
1688 	const struct vmbus_chan_attribute *attribute
1689 		= container_of(attr, struct vmbus_chan_attribute, attr);
1690 	struct vmbus_channel *chan
1691 		= container_of(kobj, struct vmbus_channel, kobj);
1692 
1693 	if (!attribute->show)
1694 		return -EIO;
1695 
1696 	return attribute->show(chan, buf);
1697 }
1698 
1699 static ssize_t vmbus_chan_attr_store(struct kobject *kobj,
1700 				     struct attribute *attr, const char *buf,
1701 				     size_t count)
1702 {
1703 	const struct vmbus_chan_attribute *attribute
1704 		= container_of(attr, struct vmbus_chan_attribute, attr);
1705 	struct vmbus_channel *chan
1706 		= container_of(kobj, struct vmbus_channel, kobj);
1707 
1708 	if (!attribute->store)
1709 		return -EIO;
1710 
1711 	return attribute->store(chan, buf, count);
1712 }
1713 
1714 static const struct sysfs_ops vmbus_chan_sysfs_ops = {
1715 	.show = vmbus_chan_attr_show,
1716 	.store = vmbus_chan_attr_store,
1717 };
1718 
1719 static ssize_t out_mask_show(struct vmbus_channel *channel, char *buf)
1720 {
1721 	struct hv_ring_buffer_info *rbi = &channel->outbound;
1722 	ssize_t ret;
1723 
1724 	mutex_lock(&rbi->ring_buffer_mutex);
1725 	if (!rbi->ring_buffer) {
1726 		mutex_unlock(&rbi->ring_buffer_mutex);
1727 		return -EINVAL;
1728 	}
1729 
1730 	ret = sprintf(buf, "%u\n", rbi->ring_buffer->interrupt_mask);
1731 	mutex_unlock(&rbi->ring_buffer_mutex);
1732 	return ret;
1733 }
1734 static VMBUS_CHAN_ATTR_RO(out_mask);
1735 
1736 static ssize_t in_mask_show(struct vmbus_channel *channel, char *buf)
1737 {
1738 	struct hv_ring_buffer_info *rbi = &channel->inbound;
1739 	ssize_t ret;
1740 
1741 	mutex_lock(&rbi->ring_buffer_mutex);
1742 	if (!rbi->ring_buffer) {
1743 		mutex_unlock(&rbi->ring_buffer_mutex);
1744 		return -EINVAL;
1745 	}
1746 
1747 	ret = sprintf(buf, "%u\n", rbi->ring_buffer->interrupt_mask);
1748 	mutex_unlock(&rbi->ring_buffer_mutex);
1749 	return ret;
1750 }
1751 static VMBUS_CHAN_ATTR_RO(in_mask);
1752 
1753 static ssize_t read_avail_show(struct vmbus_channel *channel, char *buf)
1754 {
1755 	struct hv_ring_buffer_info *rbi = &channel->inbound;
1756 	ssize_t ret;
1757 
1758 	mutex_lock(&rbi->ring_buffer_mutex);
1759 	if (!rbi->ring_buffer) {
1760 		mutex_unlock(&rbi->ring_buffer_mutex);
1761 		return -EINVAL;
1762 	}
1763 
1764 	ret = sprintf(buf, "%u\n", hv_get_bytes_to_read(rbi));
1765 	mutex_unlock(&rbi->ring_buffer_mutex);
1766 	return ret;
1767 }
1768 static VMBUS_CHAN_ATTR_RO(read_avail);
1769 
1770 static ssize_t write_avail_show(struct vmbus_channel *channel, char *buf)
1771 {
1772 	struct hv_ring_buffer_info *rbi = &channel->outbound;
1773 	ssize_t ret;
1774 
1775 	mutex_lock(&rbi->ring_buffer_mutex);
1776 	if (!rbi->ring_buffer) {
1777 		mutex_unlock(&rbi->ring_buffer_mutex);
1778 		return -EINVAL;
1779 	}
1780 
1781 	ret = sprintf(buf, "%u\n", hv_get_bytes_to_write(rbi));
1782 	mutex_unlock(&rbi->ring_buffer_mutex);
1783 	return ret;
1784 }
1785 static VMBUS_CHAN_ATTR_RO(write_avail);
1786 
1787 static ssize_t target_cpu_show(struct vmbus_channel *channel, char *buf)
1788 {
1789 	return sprintf(buf, "%u\n", channel->target_cpu);
1790 }
1791 static ssize_t target_cpu_store(struct vmbus_channel *channel,
1792 				const char *buf, size_t count)
1793 {
1794 	u32 target_cpu, origin_cpu;
1795 	ssize_t ret = count;
1796 
1797 	if (vmbus_proto_version < VERSION_WIN10_V4_1)
1798 		return -EIO;
1799 
1800 	if (sscanf(buf, "%uu", &target_cpu) != 1)
1801 		return -EIO;
1802 
1803 	/* Validate target_cpu for the cpumask_test_cpu() operation below. */
1804 	if (target_cpu >= nr_cpumask_bits)
1805 		return -EINVAL;
1806 
1807 	/* No CPUs should come up or down during this. */
1808 	cpus_read_lock();
1809 
1810 	if (!cpu_online(target_cpu)) {
1811 		cpus_read_unlock();
1812 		return -EINVAL;
1813 	}
1814 
1815 	/*
1816 	 * Synchronizes target_cpu_store() and channel closure:
1817 	 *
1818 	 * { Initially: state = CHANNEL_OPENED }
1819 	 *
1820 	 * CPU1				CPU2
1821 	 *
1822 	 * [target_cpu_store()]		[vmbus_disconnect_ring()]
1823 	 *
1824 	 * LOCK channel_mutex		LOCK channel_mutex
1825 	 * LOAD r1 = state		LOAD r2 = state
1826 	 * IF (r1 == CHANNEL_OPENED)	IF (r2 == CHANNEL_OPENED)
1827 	 *   SEND MODIFYCHANNEL		  STORE state = CHANNEL_OPEN
1828 	 *   [...]			  SEND CLOSECHANNEL
1829 	 * UNLOCK channel_mutex		UNLOCK channel_mutex
1830 	 *
1831 	 * Forbids: r1 == r2 == CHANNEL_OPENED (i.e., CPU1's LOCK precedes
1832 	 * 		CPU2's LOCK) && CPU2's SEND precedes CPU1's SEND
1833 	 *
1834 	 * Note.  The host processes the channel messages "sequentially", in
1835 	 * the order in which they are received on a per-partition basis.
1836 	 */
1837 	mutex_lock(&vmbus_connection.channel_mutex);
1838 
1839 	/*
1840 	 * Hyper-V will ignore MODIFYCHANNEL messages for "non-open" channels;
1841 	 * avoid sending the message and fail here for such channels.
1842 	 */
1843 	if (channel->state != CHANNEL_OPENED_STATE) {
1844 		ret = -EIO;
1845 		goto cpu_store_unlock;
1846 	}
1847 
1848 	origin_cpu = channel->target_cpu;
1849 	if (target_cpu == origin_cpu)
1850 		goto cpu_store_unlock;
1851 
1852 	if (vmbus_send_modifychannel(channel,
1853 				     hv_cpu_number_to_vp_number(target_cpu))) {
1854 		ret = -EIO;
1855 		goto cpu_store_unlock;
1856 	}
1857 
1858 	/*
1859 	 * For version before VERSION_WIN10_V5_3, the following warning holds:
1860 	 *
1861 	 * Warning.  At this point, there is *no* guarantee that the host will
1862 	 * have successfully processed the vmbus_send_modifychannel() request.
1863 	 * See the header comment of vmbus_send_modifychannel() for more info.
1864 	 *
1865 	 * Lags in the processing of the above vmbus_send_modifychannel() can
1866 	 * result in missed interrupts if the "old" target CPU is taken offline
1867 	 * before Hyper-V starts sending interrupts to the "new" target CPU.
1868 	 * But apart from this offlining scenario, the code tolerates such
1869 	 * lags.  It will function correctly even if a channel interrupt comes
1870 	 * in on a CPU that is different from the channel target_cpu value.
1871 	 */
1872 
1873 	channel->target_cpu = target_cpu;
1874 
1875 	/* See init_vp_index(). */
1876 	if (hv_is_perf_channel(channel))
1877 		hv_update_allocated_cpus(origin_cpu, target_cpu);
1878 
1879 	/* Currently set only for storvsc channels. */
1880 	if (channel->change_target_cpu_callback) {
1881 		(*channel->change_target_cpu_callback)(channel,
1882 				origin_cpu, target_cpu);
1883 	}
1884 
1885 cpu_store_unlock:
1886 	mutex_unlock(&vmbus_connection.channel_mutex);
1887 	cpus_read_unlock();
1888 	return ret;
1889 }
1890 static VMBUS_CHAN_ATTR(cpu, 0644, target_cpu_show, target_cpu_store);
1891 
1892 static ssize_t channel_pending_show(struct vmbus_channel *channel,
1893 				    char *buf)
1894 {
1895 	return sprintf(buf, "%d\n",
1896 		       channel_pending(channel,
1897 				       vmbus_connection.monitor_pages[1]));
1898 }
1899 static VMBUS_CHAN_ATTR(pending, 0444, channel_pending_show, NULL);
1900 
1901 static ssize_t channel_latency_show(struct vmbus_channel *channel,
1902 				    char *buf)
1903 {
1904 	return sprintf(buf, "%d\n",
1905 		       channel_latency(channel,
1906 				       vmbus_connection.monitor_pages[1]));
1907 }
1908 static VMBUS_CHAN_ATTR(latency, 0444, channel_latency_show, NULL);
1909 
1910 static ssize_t channel_interrupts_show(struct vmbus_channel *channel, char *buf)
1911 {
1912 	return sprintf(buf, "%llu\n", channel->interrupts);
1913 }
1914 static VMBUS_CHAN_ATTR(interrupts, 0444, channel_interrupts_show, NULL);
1915 
1916 static ssize_t channel_events_show(struct vmbus_channel *channel, char *buf)
1917 {
1918 	return sprintf(buf, "%llu\n", channel->sig_events);
1919 }
1920 static VMBUS_CHAN_ATTR(events, 0444, channel_events_show, NULL);
1921 
1922 static ssize_t channel_intr_in_full_show(struct vmbus_channel *channel,
1923 					 char *buf)
1924 {
1925 	return sprintf(buf, "%llu\n",
1926 		       (unsigned long long)channel->intr_in_full);
1927 }
1928 static VMBUS_CHAN_ATTR(intr_in_full, 0444, channel_intr_in_full_show, NULL);
1929 
1930 static ssize_t channel_intr_out_empty_show(struct vmbus_channel *channel,
1931 					   char *buf)
1932 {
1933 	return sprintf(buf, "%llu\n",
1934 		       (unsigned long long)channel->intr_out_empty);
1935 }
1936 static VMBUS_CHAN_ATTR(intr_out_empty, 0444, channel_intr_out_empty_show, NULL);
1937 
1938 static ssize_t channel_out_full_first_show(struct vmbus_channel *channel,
1939 					   char *buf)
1940 {
1941 	return sprintf(buf, "%llu\n",
1942 		       (unsigned long long)channel->out_full_first);
1943 }
1944 static VMBUS_CHAN_ATTR(out_full_first, 0444, channel_out_full_first_show, NULL);
1945 
1946 static ssize_t channel_out_full_total_show(struct vmbus_channel *channel,
1947 					   char *buf)
1948 {
1949 	return sprintf(buf, "%llu\n",
1950 		       (unsigned long long)channel->out_full_total);
1951 }
1952 static VMBUS_CHAN_ATTR(out_full_total, 0444, channel_out_full_total_show, NULL);
1953 
1954 static ssize_t subchannel_monitor_id_show(struct vmbus_channel *channel,
1955 					  char *buf)
1956 {
1957 	return sprintf(buf, "%u\n", channel->offermsg.monitorid);
1958 }
1959 static VMBUS_CHAN_ATTR(monitor_id, 0444, subchannel_monitor_id_show, NULL);
1960 
1961 static ssize_t subchannel_id_show(struct vmbus_channel *channel,
1962 				  char *buf)
1963 {
1964 	return sprintf(buf, "%u\n",
1965 		       channel->offermsg.offer.sub_channel_index);
1966 }
1967 static VMBUS_CHAN_ATTR_RO(subchannel_id);
1968 
1969 static struct attribute *vmbus_chan_attrs[] = {
1970 	&chan_attr_out_mask.attr,
1971 	&chan_attr_in_mask.attr,
1972 	&chan_attr_read_avail.attr,
1973 	&chan_attr_write_avail.attr,
1974 	&chan_attr_cpu.attr,
1975 	&chan_attr_pending.attr,
1976 	&chan_attr_latency.attr,
1977 	&chan_attr_interrupts.attr,
1978 	&chan_attr_events.attr,
1979 	&chan_attr_intr_in_full.attr,
1980 	&chan_attr_intr_out_empty.attr,
1981 	&chan_attr_out_full_first.attr,
1982 	&chan_attr_out_full_total.attr,
1983 	&chan_attr_monitor_id.attr,
1984 	&chan_attr_subchannel_id.attr,
1985 	NULL
1986 };
1987 
1988 /*
1989  * Channel-level attribute_group callback function. Returns the permission for
1990  * each attribute, and returns 0 if an attribute is not visible.
1991  */
1992 static umode_t vmbus_chan_attr_is_visible(struct kobject *kobj,
1993 					  struct attribute *attr, int idx)
1994 {
1995 	const struct vmbus_channel *channel =
1996 		container_of(kobj, struct vmbus_channel, kobj);
1997 
1998 	/* Hide the monitor attributes if the monitor mechanism is not used. */
1999 	if (!channel->offermsg.monitor_allocated &&
2000 	    (attr == &chan_attr_pending.attr ||
2001 	     attr == &chan_attr_latency.attr ||
2002 	     attr == &chan_attr_monitor_id.attr))
2003 		return 0;
2004 
2005 	return attr->mode;
2006 }
2007 
2008 static struct attribute_group vmbus_chan_group = {
2009 	.attrs = vmbus_chan_attrs,
2010 	.is_visible = vmbus_chan_attr_is_visible
2011 };
2012 
2013 static struct kobj_type vmbus_chan_ktype = {
2014 	.sysfs_ops = &vmbus_chan_sysfs_ops,
2015 	.release = vmbus_chan_release,
2016 };
2017 
2018 /*
2019  * vmbus_add_channel_kobj - setup a sub-directory under device/channels
2020  */
2021 int vmbus_add_channel_kobj(struct hv_device *dev, struct vmbus_channel *channel)
2022 {
2023 	const struct device *device = &dev->device;
2024 	struct kobject *kobj = &channel->kobj;
2025 	u32 relid = channel->offermsg.child_relid;
2026 	int ret;
2027 
2028 	kobj->kset = dev->channels_kset;
2029 	ret = kobject_init_and_add(kobj, &vmbus_chan_ktype, NULL,
2030 				   "%u", relid);
2031 	if (ret) {
2032 		kobject_put(kobj);
2033 		return ret;
2034 	}
2035 
2036 	ret = sysfs_create_group(kobj, &vmbus_chan_group);
2037 
2038 	if (ret) {
2039 		/*
2040 		 * The calling functions' error handling paths will cleanup the
2041 		 * empty channel directory.
2042 		 */
2043 		kobject_put(kobj);
2044 		dev_err(device, "Unable to set up channel sysfs files\n");
2045 		return ret;
2046 	}
2047 
2048 	kobject_uevent(kobj, KOBJ_ADD);
2049 
2050 	return 0;
2051 }
2052 
2053 /*
2054  * vmbus_remove_channel_attr_group - remove the channel's attribute group
2055  */
2056 void vmbus_remove_channel_attr_group(struct vmbus_channel *channel)
2057 {
2058 	sysfs_remove_group(&channel->kobj, &vmbus_chan_group);
2059 }
2060 
2061 /*
2062  * vmbus_device_create - Creates and registers a new child device
2063  * on the vmbus.
2064  */
2065 struct hv_device *vmbus_device_create(const guid_t *type,
2066 				      const guid_t *instance,
2067 				      struct vmbus_channel *channel)
2068 {
2069 	struct hv_device *child_device_obj;
2070 
2071 	child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
2072 	if (!child_device_obj) {
2073 		pr_err("Unable to allocate device object for child device\n");
2074 		return NULL;
2075 	}
2076 
2077 	child_device_obj->channel = channel;
2078 	guid_copy(&child_device_obj->dev_type, type);
2079 	guid_copy(&child_device_obj->dev_instance, instance);
2080 	child_device_obj->vendor_id = 0x1414; /* MSFT vendor ID */
2081 
2082 	return child_device_obj;
2083 }
2084 
2085 /*
2086  * vmbus_device_register - Register the child device
2087  */
2088 int vmbus_device_register(struct hv_device *child_device_obj)
2089 {
2090 	struct kobject *kobj = &child_device_obj->device.kobj;
2091 	int ret;
2092 
2093 	dev_set_name(&child_device_obj->device, "%pUl",
2094 		     &child_device_obj->channel->offermsg.offer.if_instance);
2095 
2096 	child_device_obj->device.bus = &hv_bus;
2097 	child_device_obj->device.parent = &hv_acpi_dev->dev;
2098 	child_device_obj->device.release = vmbus_device_release;
2099 
2100 	/*
2101 	 * Register with the LDM. This will kick off the driver/device
2102 	 * binding...which will eventually call vmbus_match() and vmbus_probe()
2103 	 */
2104 	ret = device_register(&child_device_obj->device);
2105 	if (ret) {
2106 		pr_err("Unable to register child device\n");
2107 		return ret;
2108 	}
2109 
2110 	child_device_obj->channels_kset = kset_create_and_add("channels",
2111 							      NULL, kobj);
2112 	if (!child_device_obj->channels_kset) {
2113 		ret = -ENOMEM;
2114 		goto err_dev_unregister;
2115 	}
2116 
2117 	ret = vmbus_add_channel_kobj(child_device_obj,
2118 				     child_device_obj->channel);
2119 	if (ret) {
2120 		pr_err("Unable to register primary channeln");
2121 		goto err_kset_unregister;
2122 	}
2123 	hv_debug_add_dev_dir(child_device_obj);
2124 
2125 	child_device_obj->device.dma_parms = &child_device_obj->dma_parms;
2126 	child_device_obj->device.dma_mask = &child_device_obj->dma_mask;
2127 	dma_set_mask(&child_device_obj->device, DMA_BIT_MASK(64));
2128 	return 0;
2129 
2130 err_kset_unregister:
2131 	kset_unregister(child_device_obj->channels_kset);
2132 
2133 err_dev_unregister:
2134 	device_unregister(&child_device_obj->device);
2135 	return ret;
2136 }
2137 
2138 /*
2139  * vmbus_device_unregister - Remove the specified child device
2140  * from the vmbus.
2141  */
2142 void vmbus_device_unregister(struct hv_device *device_obj)
2143 {
2144 	pr_debug("child device %s unregistered\n",
2145 		dev_name(&device_obj->device));
2146 
2147 	kset_unregister(device_obj->channels_kset);
2148 
2149 	/*
2150 	 * Kick off the process of unregistering the device.
2151 	 * This will call vmbus_remove() and eventually vmbus_device_release()
2152 	 */
2153 	device_unregister(&device_obj->device);
2154 }
2155 
2156 
2157 /*
2158  * VMBUS is an acpi enumerated device. Get the information we
2159  * need from DSDT.
2160  */
2161 #define VTPM_BASE_ADDRESS 0xfed40000
2162 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
2163 {
2164 	resource_size_t start = 0;
2165 	resource_size_t end = 0;
2166 	struct resource *new_res;
2167 	struct resource **old_res = &hyperv_mmio;
2168 	struct resource **prev_res = NULL;
2169 	struct resource r;
2170 
2171 	switch (res->type) {
2172 
2173 	/*
2174 	 * "Address" descriptors are for bus windows. Ignore
2175 	 * "memory" descriptors, which are for registers on
2176 	 * devices.
2177 	 */
2178 	case ACPI_RESOURCE_TYPE_ADDRESS32:
2179 		start = res->data.address32.address.minimum;
2180 		end = res->data.address32.address.maximum;
2181 		break;
2182 
2183 	case ACPI_RESOURCE_TYPE_ADDRESS64:
2184 		start = res->data.address64.address.minimum;
2185 		end = res->data.address64.address.maximum;
2186 		break;
2187 
2188 	/*
2189 	 * The IRQ information is needed only on ARM64, which Hyper-V
2190 	 * sets up in the extended format. IRQ information is present
2191 	 * on x86/x64 in the non-extended format but it is not used by
2192 	 * Linux. So don't bother checking for the non-extended format.
2193 	 */
2194 	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
2195 		if (!acpi_dev_resource_interrupt(res, 0, &r)) {
2196 			pr_err("Unable to parse Hyper-V ACPI interrupt\n");
2197 			return AE_ERROR;
2198 		}
2199 		/* ARM64 INTID for VMbus */
2200 		vmbus_interrupt = res->data.extended_irq.interrupts[0];
2201 		/* Linux IRQ number */
2202 		vmbus_irq = r.start;
2203 		return AE_OK;
2204 
2205 	default:
2206 		/* Unused resource type */
2207 		return AE_OK;
2208 
2209 	}
2210 	/*
2211 	 * Ignore ranges that are below 1MB, as they're not
2212 	 * necessary or useful here.
2213 	 */
2214 	if (end < 0x100000)
2215 		return AE_OK;
2216 
2217 	new_res = kzalloc(sizeof(*new_res), GFP_ATOMIC);
2218 	if (!new_res)
2219 		return AE_NO_MEMORY;
2220 
2221 	/* If this range overlaps the virtual TPM, truncate it. */
2222 	if (end > VTPM_BASE_ADDRESS && start < VTPM_BASE_ADDRESS)
2223 		end = VTPM_BASE_ADDRESS;
2224 
2225 	new_res->name = "hyperv mmio";
2226 	new_res->flags = IORESOURCE_MEM;
2227 	new_res->start = start;
2228 	new_res->end = end;
2229 
2230 	/*
2231 	 * If two ranges are adjacent, merge them.
2232 	 */
2233 	do {
2234 		if (!*old_res) {
2235 			*old_res = new_res;
2236 			break;
2237 		}
2238 
2239 		if (((*old_res)->end + 1) == new_res->start) {
2240 			(*old_res)->end = new_res->end;
2241 			kfree(new_res);
2242 			break;
2243 		}
2244 
2245 		if ((*old_res)->start == new_res->end + 1) {
2246 			(*old_res)->start = new_res->start;
2247 			kfree(new_res);
2248 			break;
2249 		}
2250 
2251 		if ((*old_res)->start > new_res->end) {
2252 			new_res->sibling = *old_res;
2253 			if (prev_res)
2254 				(*prev_res)->sibling = new_res;
2255 			*old_res = new_res;
2256 			break;
2257 		}
2258 
2259 		prev_res = old_res;
2260 		old_res = &(*old_res)->sibling;
2261 
2262 	} while (1);
2263 
2264 	return AE_OK;
2265 }
2266 
2267 static int vmbus_acpi_remove(struct acpi_device *device)
2268 {
2269 	struct resource *cur_res;
2270 	struct resource *next_res;
2271 
2272 	if (hyperv_mmio) {
2273 		if (fb_mmio) {
2274 			__release_region(hyperv_mmio, fb_mmio->start,
2275 					 resource_size(fb_mmio));
2276 			fb_mmio = NULL;
2277 		}
2278 
2279 		for (cur_res = hyperv_mmio; cur_res; cur_res = next_res) {
2280 			next_res = cur_res->sibling;
2281 			kfree(cur_res);
2282 		}
2283 	}
2284 
2285 	return 0;
2286 }
2287 
2288 static void vmbus_reserve_fb(void)
2289 {
2290 	int size;
2291 	/*
2292 	 * Make a claim for the frame buffer in the resource tree under the
2293 	 * first node, which will be the one below 4GB.  The length seems to
2294 	 * be underreported, particularly in a Generation 1 VM.  So start out
2295 	 * reserving a larger area and make it smaller until it succeeds.
2296 	 */
2297 
2298 	if (screen_info.lfb_base) {
2299 		if (efi_enabled(EFI_BOOT))
2300 			size = max_t(__u32, screen_info.lfb_size, 0x800000);
2301 		else
2302 			size = max_t(__u32, screen_info.lfb_size, 0x4000000);
2303 
2304 		for (; !fb_mmio && (size >= 0x100000); size >>= 1) {
2305 			fb_mmio = __request_region(hyperv_mmio,
2306 						   screen_info.lfb_base, size,
2307 						   fb_mmio_name, 0);
2308 		}
2309 	}
2310 }
2311 
2312 /**
2313  * vmbus_allocate_mmio() - Pick a memory-mapped I/O range.
2314  * @new:		If successful, supplied a pointer to the
2315  *			allocated MMIO space.
2316  * @device_obj:		Identifies the caller
2317  * @min:		Minimum guest physical address of the
2318  *			allocation
2319  * @max:		Maximum guest physical address
2320  * @size:		Size of the range to be allocated
2321  * @align:		Alignment of the range to be allocated
2322  * @fb_overlap_ok:	Whether this allocation can be allowed
2323  *			to overlap the video frame buffer.
2324  *
2325  * This function walks the resources granted to VMBus by the
2326  * _CRS object in the ACPI namespace underneath the parent
2327  * "bridge" whether that's a root PCI bus in the Generation 1
2328  * case or a Module Device in the Generation 2 case.  It then
2329  * attempts to allocate from the global MMIO pool in a way that
2330  * matches the constraints supplied in these parameters and by
2331  * that _CRS.
2332  *
2333  * Return: 0 on success, -errno on failure
2334  */
2335 int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
2336 			resource_size_t min, resource_size_t max,
2337 			resource_size_t size, resource_size_t align,
2338 			bool fb_overlap_ok)
2339 {
2340 	struct resource *iter, *shadow;
2341 	resource_size_t range_min, range_max, start;
2342 	const char *dev_n = dev_name(&device_obj->device);
2343 	int retval;
2344 
2345 	retval = -ENXIO;
2346 	mutex_lock(&hyperv_mmio_lock);
2347 
2348 	/*
2349 	 * If overlaps with frame buffers are allowed, then first attempt to
2350 	 * make the allocation from within the reserved region.  Because it
2351 	 * is already reserved, no shadow allocation is necessary.
2352 	 */
2353 	if (fb_overlap_ok && fb_mmio && !(min > fb_mmio->end) &&
2354 	    !(max < fb_mmio->start)) {
2355 
2356 		range_min = fb_mmio->start;
2357 		range_max = fb_mmio->end;
2358 		start = (range_min + align - 1) & ~(align - 1);
2359 		for (; start + size - 1 <= range_max; start += align) {
2360 			*new = request_mem_region_exclusive(start, size, dev_n);
2361 			if (*new) {
2362 				retval = 0;
2363 				goto exit;
2364 			}
2365 		}
2366 	}
2367 
2368 	for (iter = hyperv_mmio; iter; iter = iter->sibling) {
2369 		if ((iter->start >= max) || (iter->end <= min))
2370 			continue;
2371 
2372 		range_min = iter->start;
2373 		range_max = iter->end;
2374 		start = (range_min + align - 1) & ~(align - 1);
2375 		for (; start + size - 1 <= range_max; start += align) {
2376 			shadow = __request_region(iter, start, size, NULL,
2377 						  IORESOURCE_BUSY);
2378 			if (!shadow)
2379 				continue;
2380 
2381 			*new = request_mem_region_exclusive(start, size, dev_n);
2382 			if (*new) {
2383 				shadow->name = (char *)*new;
2384 				retval = 0;
2385 				goto exit;
2386 			}
2387 
2388 			__release_region(iter, start, size);
2389 		}
2390 	}
2391 
2392 exit:
2393 	mutex_unlock(&hyperv_mmio_lock);
2394 	return retval;
2395 }
2396 EXPORT_SYMBOL_GPL(vmbus_allocate_mmio);
2397 
2398 /**
2399  * vmbus_free_mmio() - Free a memory-mapped I/O range.
2400  * @start:		Base address of region to release.
2401  * @size:		Size of the range to be allocated
2402  *
2403  * This function releases anything requested by
2404  * vmbus_mmio_allocate().
2405  */
2406 void vmbus_free_mmio(resource_size_t start, resource_size_t size)
2407 {
2408 	struct resource *iter;
2409 
2410 	mutex_lock(&hyperv_mmio_lock);
2411 	for (iter = hyperv_mmio; iter; iter = iter->sibling) {
2412 		if ((iter->start >= start + size) || (iter->end <= start))
2413 			continue;
2414 
2415 		__release_region(iter, start, size);
2416 	}
2417 	release_mem_region(start, size);
2418 	mutex_unlock(&hyperv_mmio_lock);
2419 
2420 }
2421 EXPORT_SYMBOL_GPL(vmbus_free_mmio);
2422 
2423 static int vmbus_acpi_add(struct acpi_device *device)
2424 {
2425 	acpi_status result;
2426 	int ret_val = -ENODEV;
2427 	struct acpi_device *ancestor;
2428 
2429 	hv_acpi_dev = device;
2430 
2431 	result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
2432 					vmbus_walk_resources, NULL);
2433 
2434 	if (ACPI_FAILURE(result))
2435 		goto acpi_walk_err;
2436 	/*
2437 	 * Some ancestor of the vmbus acpi device (Gen1 or Gen2
2438 	 * firmware) is the VMOD that has the mmio ranges. Get that.
2439 	 */
2440 	for (ancestor = device->parent; ancestor; ancestor = ancestor->parent) {
2441 		result = acpi_walk_resources(ancestor->handle, METHOD_NAME__CRS,
2442 					     vmbus_walk_resources, NULL);
2443 
2444 		if (ACPI_FAILURE(result))
2445 			continue;
2446 		if (hyperv_mmio) {
2447 			vmbus_reserve_fb();
2448 			break;
2449 		}
2450 	}
2451 	ret_val = 0;
2452 
2453 acpi_walk_err:
2454 	complete(&probe_event);
2455 	if (ret_val)
2456 		vmbus_acpi_remove(device);
2457 	return ret_val;
2458 }
2459 
2460 #ifdef CONFIG_PM_SLEEP
2461 static int vmbus_bus_suspend(struct device *dev)
2462 {
2463 	struct vmbus_channel *channel, *sc;
2464 
2465 	while (atomic_read(&vmbus_connection.offer_in_progress) != 0) {
2466 		/*
2467 		 * We wait here until the completion of any channel
2468 		 * offers that are currently in progress.
2469 		 */
2470 		usleep_range(1000, 2000);
2471 	}
2472 
2473 	mutex_lock(&vmbus_connection.channel_mutex);
2474 	list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
2475 		if (!is_hvsock_channel(channel))
2476 			continue;
2477 
2478 		vmbus_force_channel_rescinded(channel);
2479 	}
2480 	mutex_unlock(&vmbus_connection.channel_mutex);
2481 
2482 	/*
2483 	 * Wait until all the sub-channels and hv_sock channels have been
2484 	 * cleaned up. Sub-channels should be destroyed upon suspend, otherwise
2485 	 * they would conflict with the new sub-channels that will be created
2486 	 * in the resume path. hv_sock channels should also be destroyed, but
2487 	 * a hv_sock channel of an established hv_sock connection can not be
2488 	 * really destroyed since it may still be referenced by the userspace
2489 	 * application, so we just force the hv_sock channel to be rescinded
2490 	 * by vmbus_force_channel_rescinded(), and the userspace application
2491 	 * will thoroughly destroy the channel after hibernation.
2492 	 *
2493 	 * Note: the counter nr_chan_close_on_suspend may never go above 0 if
2494 	 * the VM has no sub-channel and hv_sock channel, e.g. a 1-vCPU VM.
2495 	 */
2496 	if (atomic_read(&vmbus_connection.nr_chan_close_on_suspend) > 0)
2497 		wait_for_completion(&vmbus_connection.ready_for_suspend_event);
2498 
2499 	if (atomic_read(&vmbus_connection.nr_chan_fixup_on_resume) != 0) {
2500 		pr_err("Can not suspend due to a previous failed resuming\n");
2501 		return -EBUSY;
2502 	}
2503 
2504 	mutex_lock(&vmbus_connection.channel_mutex);
2505 
2506 	list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
2507 		/*
2508 		 * Remove the channel from the array of channels and invalidate
2509 		 * the channel's relid.  Upon resume, vmbus_onoffer() will fix
2510 		 * up the relid (and other fields, if necessary) and add the
2511 		 * channel back to the array.
2512 		 */
2513 		vmbus_channel_unmap_relid(channel);
2514 		channel->offermsg.child_relid = INVALID_RELID;
2515 
2516 		if (is_hvsock_channel(channel)) {
2517 			if (!channel->rescind) {
2518 				pr_err("hv_sock channel not rescinded!\n");
2519 				WARN_ON_ONCE(1);
2520 			}
2521 			continue;
2522 		}
2523 
2524 		list_for_each_entry(sc, &channel->sc_list, sc_list) {
2525 			pr_err("Sub-channel not deleted!\n");
2526 			WARN_ON_ONCE(1);
2527 		}
2528 
2529 		atomic_inc(&vmbus_connection.nr_chan_fixup_on_resume);
2530 	}
2531 
2532 	mutex_unlock(&vmbus_connection.channel_mutex);
2533 
2534 	vmbus_initiate_unload(false);
2535 
2536 	/* Reset the event for the next resume. */
2537 	reinit_completion(&vmbus_connection.ready_for_resume_event);
2538 
2539 	return 0;
2540 }
2541 
2542 static int vmbus_bus_resume(struct device *dev)
2543 {
2544 	struct vmbus_channel_msginfo *msginfo;
2545 	size_t msgsize;
2546 	int ret;
2547 
2548 	/*
2549 	 * We only use the 'vmbus_proto_version', which was in use before
2550 	 * hibernation, to re-negotiate with the host.
2551 	 */
2552 	if (!vmbus_proto_version) {
2553 		pr_err("Invalid proto version = 0x%x\n", vmbus_proto_version);
2554 		return -EINVAL;
2555 	}
2556 
2557 	msgsize = sizeof(*msginfo) +
2558 		  sizeof(struct vmbus_channel_initiate_contact);
2559 
2560 	msginfo = kzalloc(msgsize, GFP_KERNEL);
2561 
2562 	if (msginfo == NULL)
2563 		return -ENOMEM;
2564 
2565 	ret = vmbus_negotiate_version(msginfo, vmbus_proto_version);
2566 
2567 	kfree(msginfo);
2568 
2569 	if (ret != 0)
2570 		return ret;
2571 
2572 	WARN_ON(atomic_read(&vmbus_connection.nr_chan_fixup_on_resume) == 0);
2573 
2574 	vmbus_request_offers();
2575 
2576 	if (wait_for_completion_timeout(
2577 		&vmbus_connection.ready_for_resume_event, 10 * HZ) == 0)
2578 		pr_err("Some vmbus device is missing after suspending?\n");
2579 
2580 	/* Reset the event for the next suspend. */
2581 	reinit_completion(&vmbus_connection.ready_for_suspend_event);
2582 
2583 	return 0;
2584 }
2585 #else
2586 #define vmbus_bus_suspend NULL
2587 #define vmbus_bus_resume NULL
2588 #endif /* CONFIG_PM_SLEEP */
2589 
2590 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
2591 	{"VMBUS", 0},
2592 	{"VMBus", 0},
2593 	{"", 0},
2594 };
2595 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
2596 
2597 /*
2598  * Note: we must use the "no_irq" ops, otherwise hibernation can not work with
2599  * PCI device assignment, because "pci_dev_pm_ops" uses the "noirq" ops: in
2600  * the resume path, the pci "noirq" restore op runs before "non-noirq" op (see
2601  * resume_target_kernel() -> dpm_resume_start(), and hibernation_restore() ->
2602  * dpm_resume_end()). This means vmbus_bus_resume() and the pci-hyperv's
2603  * resume callback must also run via the "noirq" ops.
2604  *
2605  * Set suspend_noirq/resume_noirq to NULL for Suspend-to-Idle: see the comment
2606  * earlier in this file before vmbus_pm.
2607  */
2608 
2609 static const struct dev_pm_ops vmbus_bus_pm = {
2610 	.suspend_noirq	= NULL,
2611 	.resume_noirq	= NULL,
2612 	.freeze_noirq	= vmbus_bus_suspend,
2613 	.thaw_noirq	= vmbus_bus_resume,
2614 	.poweroff_noirq	= vmbus_bus_suspend,
2615 	.restore_noirq	= vmbus_bus_resume
2616 };
2617 
2618 static struct acpi_driver vmbus_acpi_driver = {
2619 	.name = "vmbus",
2620 	.ids = vmbus_acpi_device_ids,
2621 	.ops = {
2622 		.add = vmbus_acpi_add,
2623 		.remove = vmbus_acpi_remove,
2624 	},
2625 	.drv.pm = &vmbus_bus_pm,
2626 };
2627 
2628 static void hv_kexec_handler(void)
2629 {
2630 	hv_stimer_global_cleanup();
2631 	vmbus_initiate_unload(false);
2632 	/* Make sure conn_state is set as hv_synic_cleanup checks for it */
2633 	mb();
2634 	cpuhp_remove_state(hyperv_cpuhp_online);
2635 };
2636 
2637 static void hv_crash_handler(struct pt_regs *regs)
2638 {
2639 	int cpu;
2640 
2641 	vmbus_initiate_unload(true);
2642 	/*
2643 	 * In crash handler we can't schedule synic cleanup for all CPUs,
2644 	 * doing the cleanup for current CPU only. This should be sufficient
2645 	 * for kdump.
2646 	 */
2647 	cpu = smp_processor_id();
2648 	hv_stimer_cleanup(cpu);
2649 	hv_synic_disable_regs(cpu);
2650 };
2651 
2652 static int hv_synic_suspend(void)
2653 {
2654 	/*
2655 	 * When we reach here, all the non-boot CPUs have been offlined.
2656 	 * If we're in a legacy configuration where stimer Direct Mode is
2657 	 * not enabled, the stimers on the non-boot CPUs have been unbound
2658 	 * in hv_synic_cleanup() -> hv_stimer_legacy_cleanup() ->
2659 	 * hv_stimer_cleanup() -> clockevents_unbind_device().
2660 	 *
2661 	 * hv_synic_suspend() only runs on CPU0 with interrupts disabled.
2662 	 * Here we do not call hv_stimer_legacy_cleanup() on CPU0 because:
2663 	 * 1) it's unnecessary as interrupts remain disabled between
2664 	 * syscore_suspend() and syscore_resume(): see create_image() and
2665 	 * resume_target_kernel()
2666 	 * 2) the stimer on CPU0 is automatically disabled later by
2667 	 * syscore_suspend() -> timekeeping_suspend() -> tick_suspend() -> ...
2668 	 * -> clockevents_shutdown() -> ... -> hv_ce_shutdown()
2669 	 * 3) a warning would be triggered if we call
2670 	 * clockevents_unbind_device(), which may sleep, in an
2671 	 * interrupts-disabled context.
2672 	 */
2673 
2674 	hv_synic_disable_regs(0);
2675 
2676 	return 0;
2677 }
2678 
2679 static void hv_synic_resume(void)
2680 {
2681 	hv_synic_enable_regs(0);
2682 
2683 	/*
2684 	 * Note: we don't need to call hv_stimer_init(0), because the timer
2685 	 * on CPU0 is not unbound in hv_synic_suspend(), and the timer is
2686 	 * automatically re-enabled in timekeeping_resume().
2687 	 */
2688 }
2689 
2690 /* The callbacks run only on CPU0, with irqs_disabled. */
2691 static struct syscore_ops hv_synic_syscore_ops = {
2692 	.suspend = hv_synic_suspend,
2693 	.resume = hv_synic_resume,
2694 };
2695 
2696 static int __init hv_acpi_init(void)
2697 {
2698 	int ret, t;
2699 
2700 	if (!hv_is_hyperv_initialized())
2701 		return -ENODEV;
2702 
2703 	if (hv_root_partition)
2704 		return 0;
2705 
2706 	init_completion(&probe_event);
2707 
2708 	/*
2709 	 * Get ACPI resources first.
2710 	 */
2711 	ret = acpi_bus_register_driver(&vmbus_acpi_driver);
2712 
2713 	if (ret)
2714 		return ret;
2715 
2716 	t = wait_for_completion_timeout(&probe_event, 5*HZ);
2717 	if (t == 0) {
2718 		ret = -ETIMEDOUT;
2719 		goto cleanup;
2720 	}
2721 
2722 	/*
2723 	 * If we're on an architecture with a hardcoded hypervisor
2724 	 * vector (i.e. x86/x64), override the VMbus interrupt found
2725 	 * in the ACPI tables. Ensure vmbus_irq is not set since the
2726 	 * normal Linux IRQ mechanism is not used in this case.
2727 	 */
2728 #ifdef HYPERVISOR_CALLBACK_VECTOR
2729 	vmbus_interrupt = HYPERVISOR_CALLBACK_VECTOR;
2730 	vmbus_irq = -1;
2731 #endif
2732 
2733 	hv_debug_init();
2734 
2735 	ret = vmbus_bus_init();
2736 	if (ret)
2737 		goto cleanup;
2738 
2739 	hv_setup_kexec_handler(hv_kexec_handler);
2740 	hv_setup_crash_handler(hv_crash_handler);
2741 
2742 	register_syscore_ops(&hv_synic_syscore_ops);
2743 
2744 	return 0;
2745 
2746 cleanup:
2747 	acpi_bus_unregister_driver(&vmbus_acpi_driver);
2748 	hv_acpi_dev = NULL;
2749 	return ret;
2750 }
2751 
2752 static void __exit vmbus_exit(void)
2753 {
2754 	int cpu;
2755 
2756 	unregister_syscore_ops(&hv_synic_syscore_ops);
2757 
2758 	hv_remove_kexec_handler();
2759 	hv_remove_crash_handler();
2760 	vmbus_connection.conn_state = DISCONNECTED;
2761 	hv_stimer_global_cleanup();
2762 	vmbus_disconnect();
2763 	if (vmbus_irq == -1) {
2764 		hv_remove_vmbus_handler();
2765 	} else {
2766 		free_percpu_irq(vmbus_irq, vmbus_evt);
2767 		free_percpu(vmbus_evt);
2768 	}
2769 	for_each_online_cpu(cpu) {
2770 		struct hv_per_cpu_context *hv_cpu
2771 			= per_cpu_ptr(hv_context.cpu_context, cpu);
2772 
2773 		tasklet_kill(&hv_cpu->msg_dpc);
2774 	}
2775 	hv_debug_rm_all_dir();
2776 
2777 	vmbus_free_channels();
2778 	kfree(vmbus_connection.channels);
2779 
2780 	if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
2781 		kmsg_dump_unregister(&hv_kmsg_dumper);
2782 		unregister_die_notifier(&hyperv_die_block);
2783 		atomic_notifier_chain_unregister(&panic_notifier_list,
2784 						 &hyperv_panic_block);
2785 	}
2786 
2787 	free_page((unsigned long)hv_panic_page);
2788 	unregister_sysctl_table(hv_ctl_table_hdr);
2789 	hv_ctl_table_hdr = NULL;
2790 	bus_unregister(&hv_bus);
2791 
2792 	cpuhp_remove_state(hyperv_cpuhp_online);
2793 	hv_synic_free();
2794 	acpi_bus_unregister_driver(&vmbus_acpi_driver);
2795 }
2796 
2797 
2798 MODULE_LICENSE("GPL");
2799 MODULE_DESCRIPTION("Microsoft Hyper-V VMBus Driver");
2800 
2801 subsys_initcall(hv_acpi_init);
2802 module_exit(vmbus_exit);
2803