vmbus_drv.c 53.7 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4 5 6 7
/*
 * Copyright (c) 2009, Microsoft Corporation.
 *
 * Authors:
 *   Haiyang Zhang <haiyangz@microsoft.com>
 *   Hank Janssen  <hjanssen@microsoft.com>
8
 *   K. Y. Srinivasan <kys@microsoft.com>
9
 */
10 11
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

12 13 14 15 16
#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#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 25
#include <linux/sched/task_stack.h>

26
#include <asm/mshyperv.h>
27 28
#include <linux/notifier.h>
#include <linux/ptrace.h>
29
#include <linux/screen_info.h>
30
#include <linux/kdebug.h>
31
#include <linux/efi.h>
32
#include <linux/random.h>
33
#include "hyperv_vmbus.h"
34

35 36 37 38 39
struct vmbus_dynid {
	struct list_head node;
	struct hv_vmbus_device_id id;
};

40
static struct acpi_device  *hv_acpi_dev;
41

42
static struct completion probe_event;
43

44
static int hyperv_cpuhp_online;
45

46 47
static void *hv_panic_page;

48 49 50 51 52 53 54
static int hyperv_panic_event(struct notifier_block *nb, unsigned long val,
			      void *args)
{
	struct pt_regs *regs;

	regs = current_pt_regs();

55
	hyperv_report_panic(regs, val);
56 57 58
	return NOTIFY_DONE;
}

59 60 61 62 63 64
static int hyperv_die_event(struct notifier_block *nb, unsigned long val,
			    void *args)
{
	struct die_args *die = (struct die_args *)args;
	struct pt_regs *regs = die->regs;

65
	hyperv_report_panic(regs, val);
66 67 68 69 70 71
	return NOTIFY_DONE;
}

static struct notifier_block hyperv_die_block = {
	.notifier_call = hyperv_die_event,
};
72 73 74 75
static struct notifier_block hyperv_panic_block = {
	.notifier_call = hyperv_panic_event,
};

76 77
static const char *fb_mmio_name = "fb_range";
static struct resource *fb_mmio;
78 79
static struct resource *hyperv_mmio;
static DEFINE_SEMAPHORE(hyperv_mmio_lock);
80

81 82 83 84 85 86 87 88
static int vmbus_exists(void)
{
	if (hv_acpi_dev == NULL)
		return -ENODEV;

	return 0;
}

89 90 91 92 93 94 95 96
#define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
{
	int i;
	for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
		sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
}

97
static u8 channel_monitor_group(const struct vmbus_channel *channel)
98 99 100 101
{
	return (u8)channel->offermsg.monitorid / 32;
}

102
static u8 channel_monitor_offset(const struct vmbus_channel *channel)
103 104 105 106
{
	return (u8)channel->offermsg.monitorid % 32;
}

107 108
static u32 channel_pending(const struct vmbus_channel *channel,
			   const struct hv_monitor_page *monitor_page)
109 110
{
	u8 monitor_group = channel_monitor_group(channel);
111

112 113 114
	return monitor_page->trigger_group[monitor_group].pending;
}

115 116
static u32 channel_latency(const struct vmbus_channel *channel,
			   const struct hv_monitor_page *monitor_page)
117 118 119
{
	u8 monitor_group = channel_monitor_group(channel);
	u8 monitor_offset = channel_monitor_offset(channel);
120

121 122 123
	return monitor_page->latency[monitor_group][monitor_offset];
}

124 125 126 127 128 129 130 131
static u32 channel_conn_id(struct vmbus_channel *channel,
			   struct hv_monitor_page *monitor_page)
{
	u8 monitor_group = channel_monitor_group(channel);
	u8 monitor_offset = channel_monitor_offset(channel);
	return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
}

132 133 134 135 136 137 138 139 140 141 142
static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
		       char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
}
static DEVICE_ATTR_RO(id);

143 144 145 146 147 148 149 150 151 152 153
static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
			  char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n", hv_dev->channel->state);
}
static DEVICE_ATTR_RO(state);

154 155 156 157 158 159 160 161 162 163 164
static ssize_t monitor_id_show(struct device *dev,
			       struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
}
static DEVICE_ATTR_RO(monitor_id);

165 166 167 168 169 170 171 172 173 174 175 176
static ssize_t class_id_show(struct device *dev,
			       struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "{%pUl}\n",
		       hv_dev->channel->offermsg.offer.if_type.b);
}
static DEVICE_ATTR_RO(class_id);

177 178 179 180 181 182 183 184 185 186 187 188
static ssize_t device_id_show(struct device *dev,
			      struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "{%pUl}\n",
		       hv_dev->channel->offermsg.offer.if_instance.b);
}
static DEVICE_ATTR_RO(device_id);

189 190 191 192 193 194 195 196 197 198 199
static ssize_t modalias_show(struct device *dev,
			     struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	char alias_name[VMBUS_ALIAS_LEN + 1];

	print_alias_name(hv_dev, alias_name);
	return sprintf(buf, "vmbus:%s\n", alias_name);
}
static DEVICE_ATTR_RO(modalias);

200 201 202 203 204 205 206 207 208 209 210 211 212 213
#ifdef CONFIG_NUMA
static ssize_t numa_node_show(struct device *dev,
			      struct device_attribute *attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;

	return sprintf(buf, "%d\n", hv_dev->channel->numa_node);
}
static DEVICE_ATTR_RO(numa_node);
#endif

214 215 216 217 218 219 220 221 222 223
static ssize_t server_monitor_pending_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_pending(hv_dev->channel,
224
				       vmbus_connection.monitor_pages[0]));
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
}
static DEVICE_ATTR_RO(server_monitor_pending);

static ssize_t client_monitor_pending_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_pending(hv_dev->channel,
				       vmbus_connection.monitor_pages[1]));
}
static DEVICE_ATTR_RO(client_monitor_pending);
241

242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
static ssize_t server_monitor_latency_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_latency(hv_dev->channel,
				       vmbus_connection.monitor_pages[0]));
}
static DEVICE_ATTR_RO(server_monitor_latency);

static ssize_t client_monitor_latency_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_latency(hv_dev->channel,
				       vmbus_connection.monitor_pages[1]));
}
static DEVICE_ATTR_RO(client_monitor_latency);

270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
static ssize_t server_monitor_conn_id_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_conn_id(hv_dev->channel,
				       vmbus_connection.monitor_pages[0]));
}
static DEVICE_ATTR_RO(server_monitor_conn_id);

static ssize_t client_monitor_conn_id_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_conn_id(hv_dev->channel,
				       vmbus_connection.monitor_pages[1]));
}
static DEVICE_ATTR_RO(client_monitor_conn_id);

298 299 300 301 302
static ssize_t out_intr_mask_show(struct device *dev,
				  struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct hv_ring_buffer_debug_info outbound;
303
	int ret;
304 305 306

	if (!hv_dev->channel)
		return -ENODEV;
307 308 309 310 311 312

	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
					  &outbound);
	if (ret < 0)
		return ret;

313 314 315 316 317 318 319 320 321
	return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
}
static DEVICE_ATTR_RO(out_intr_mask);

static ssize_t out_read_index_show(struct device *dev,
				   struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct hv_ring_buffer_debug_info outbound;
322
	int ret;
323 324 325

	if (!hv_dev->channel)
		return -ENODEV;
326 327 328 329 330

	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
					  &outbound);
	if (ret < 0)
		return ret;
331 332 333 334 335 336 337 338 339 340
	return sprintf(buf, "%d\n", outbound.current_read_index);
}
static DEVICE_ATTR_RO(out_read_index);

static ssize_t out_write_index_show(struct device *dev,
				    struct device_attribute *dev_attr,
				    char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct hv_ring_buffer_debug_info outbound;
341
	int ret;
342 343 344

	if (!hv_dev->channel)
		return -ENODEV;
345 346 347 348 349

	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
					  &outbound);
	if (ret < 0)
		return ret;
350 351 352 353 354 355 356 357 358 359
	return sprintf(buf, "%d\n", outbound.current_write_index);
}
static DEVICE_ATTR_RO(out_write_index);

static ssize_t out_read_bytes_avail_show(struct device *dev,
					 struct device_attribute *dev_attr,
					 char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct hv_ring_buffer_debug_info outbound;
360
	int ret;
361 362 363

	if (!hv_dev->channel)
		return -ENODEV;
364 365 366 367 368

	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
					  &outbound);
	if (ret < 0)
		return ret;
369 370 371 372 373 374 375 376 377 378
	return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
}
static DEVICE_ATTR_RO(out_read_bytes_avail);

static ssize_t out_write_bytes_avail_show(struct device *dev,
					  struct device_attribute *dev_attr,
					  char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct hv_ring_buffer_debug_info outbound;
379
	int ret;
380 381 382

	if (!hv_dev->channel)
		return -ENODEV;
383 384 385 386 387

	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
					  &outbound);
	if (ret < 0)
		return ret;
388 389 390 391 392 393 394 395 396
	return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
}
static DEVICE_ATTR_RO(out_write_bytes_avail);

static ssize_t in_intr_mask_show(struct device *dev,
				 struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct hv_ring_buffer_debug_info inbound;
397
	int ret;
398 399 400

	if (!hv_dev->channel)
		return -ENODEV;
401 402 403 404 405

	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
	if (ret < 0)
		return ret;

406 407 408 409 410 411 412 413 414
	return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
}
static DEVICE_ATTR_RO(in_intr_mask);

static ssize_t in_read_index_show(struct device *dev,
				  struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct hv_ring_buffer_debug_info inbound;
415
	int ret;
416 417 418

	if (!hv_dev->channel)
		return -ENODEV;
419 420 421 422 423

	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
	if (ret < 0)
		return ret;

424 425 426 427 428 429 430 431 432
	return sprintf(buf, "%d\n", inbound.current_read_index);
}
static DEVICE_ATTR_RO(in_read_index);

static ssize_t in_write_index_show(struct device *dev,
				   struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct hv_ring_buffer_debug_info inbound;
433
	int ret;
434 435 436

	if (!hv_dev->channel)
		return -ENODEV;
437 438 439 440 441

	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
	if (ret < 0)
		return ret;

442 443 444 445 446 447 448 449 450 451
	return sprintf(buf, "%d\n", inbound.current_write_index);
}
static DEVICE_ATTR_RO(in_write_index);

static ssize_t in_read_bytes_avail_show(struct device *dev,
					struct device_attribute *dev_attr,
					char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct hv_ring_buffer_debug_info inbound;
452
	int ret;
453 454 455

	if (!hv_dev->channel)
		return -ENODEV;
456 457 458 459 460

	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
	if (ret < 0)
		return ret;

461 462 463 464 465 466 467 468 469 470
	return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
}
static DEVICE_ATTR_RO(in_read_bytes_avail);

static ssize_t in_write_bytes_avail_show(struct device *dev,
					 struct device_attribute *dev_attr,
					 char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct hv_ring_buffer_debug_info inbound;
471
	int ret;
472 473 474

	if (!hv_dev->channel)
		return -ENODEV;
475 476 477 478 479

	ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
	if (ret < 0)
		return ret;

480 481 482 483
	return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
}
static DEVICE_ATTR_RO(in_write_bytes_avail);

484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
static ssize_t channel_vp_mapping_show(struct device *dev,
				       struct device_attribute *dev_attr,
				       char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	struct vmbus_channel *channel = hv_dev->channel, *cur_sc;
	unsigned long flags;
	int buf_size = PAGE_SIZE, n_written, tot_written;
	struct list_head *cur;

	if (!channel)
		return -ENODEV;

	tot_written = snprintf(buf, buf_size, "%u:%u\n",
		channel->offermsg.child_relid, channel->target_cpu);

	spin_lock_irqsave(&channel->lock, flags);

	list_for_each(cur, &channel->sc_list) {
		if (tot_written >= buf_size - 1)
			break;

		cur_sc = list_entry(cur, struct vmbus_channel, sc_list);
		n_written = scnprintf(buf + tot_written,
				     buf_size - tot_written,
				     "%u:%u\n",
				     cur_sc->offermsg.child_relid,
				     cur_sc->target_cpu);
		tot_written += n_written;
	}

	spin_unlock_irqrestore(&channel->lock, flags);

	return tot_written;
}
static DEVICE_ATTR_RO(channel_vp_mapping);

521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
static ssize_t vendor_show(struct device *dev,
			   struct device_attribute *dev_attr,
			   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	return sprintf(buf, "0x%x\n", hv_dev->vendor_id);
}
static DEVICE_ATTR_RO(vendor);

static ssize_t device_show(struct device *dev,
			   struct device_attribute *dev_attr,
			   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	return sprintf(buf, "0x%x\n", hv_dev->device_id);
}
static DEVICE_ATTR_RO(device);

539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586
static ssize_t driver_override_store(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	char *driver_override, *old, *cp;

	/* We need to keep extra room for a newline */
	if (count >= (PAGE_SIZE - 1))
		return -EINVAL;

	driver_override = kstrndup(buf, count, GFP_KERNEL);
	if (!driver_override)
		return -ENOMEM;

	cp = strchr(driver_override, '\n');
	if (cp)
		*cp = '\0';

	device_lock(dev);
	old = hv_dev->driver_override;
	if (strlen(driver_override)) {
		hv_dev->driver_override = driver_override;
	} else {
		kfree(driver_override);
		hv_dev->driver_override = NULL;
	}
	device_unlock(dev);

	kfree(old);

	return count;
}

static ssize_t driver_override_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	ssize_t len;

	device_lock(dev);
	len = snprintf(buf, PAGE_SIZE, "%s\n", hv_dev->driver_override);
	device_unlock(dev);

	return len;
}
static DEVICE_ATTR_RW(driver_override);

587
/* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
588
static struct attribute *vmbus_dev_attrs[] = {
589
	&dev_attr_id.attr,
590
	&dev_attr_state.attr,
591
	&dev_attr_monitor_id.attr,
592
	&dev_attr_class_id.attr,
593
	&dev_attr_device_id.attr,
594
	&dev_attr_modalias.attr,
595 596 597
#ifdef CONFIG_NUMA
	&dev_attr_numa_node.attr,
#endif
598 599
	&dev_attr_server_monitor_pending.attr,
	&dev_attr_client_monitor_pending.attr,
600 601
	&dev_attr_server_monitor_latency.attr,
	&dev_attr_client_monitor_latency.attr,
602 603
	&dev_attr_server_monitor_conn_id.attr,
	&dev_attr_client_monitor_conn_id.attr,
604 605 606 607 608 609 610 611 612 613
	&dev_attr_out_intr_mask.attr,
	&dev_attr_out_read_index.attr,
	&dev_attr_out_write_index.attr,
	&dev_attr_out_read_bytes_avail.attr,
	&dev_attr_out_write_bytes_avail.attr,
	&dev_attr_in_intr_mask.attr,
	&dev_attr_in_read_index.attr,
	&dev_attr_in_write_index.attr,
	&dev_attr_in_read_bytes_avail.attr,
	&dev_attr_in_write_bytes_avail.attr,
614
	&dev_attr_channel_vp_mapping.attr,
615 616
	&dev_attr_vendor.attr,
	&dev_attr_device.attr,
617
	&dev_attr_driver_override.attr,
618 619
	NULL,
};
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649

/*
 * Device-level attribute_group callback function. Returns the permission for
 * each attribute, and returns 0 if an attribute is not visible.
 */
static umode_t vmbus_dev_attr_is_visible(struct kobject *kobj,
					 struct attribute *attr, int idx)
{
	struct device *dev = kobj_to_dev(kobj);
	const struct hv_device *hv_dev = device_to_hv_device(dev);

	/* Hide the monitor attributes if the monitor mechanism is not used. */
	if (!hv_dev->channel->offermsg.monitor_allocated &&
	    (attr == &dev_attr_monitor_id.attr ||
	     attr == &dev_attr_server_monitor_pending.attr ||
	     attr == &dev_attr_client_monitor_pending.attr ||
	     attr == &dev_attr_server_monitor_latency.attr ||
	     attr == &dev_attr_client_monitor_latency.attr ||
	     attr == &dev_attr_server_monitor_conn_id.attr ||
	     attr == &dev_attr_client_monitor_conn_id.attr))
		return 0;

	return attr->mode;
}

static const struct attribute_group vmbus_dev_group = {
	.attrs = vmbus_dev_attrs,
	.is_visible = vmbus_dev_attr_is_visible
};
__ATTRIBUTE_GROUPS(vmbus_dev);
650

651 652 653 654 655 656
/*
 * vmbus_uevent - add uevent for our device
 *
 * This routine is invoked when a device is added or removed on the vmbus to
 * generate a uevent to udev in the userspace. The udev will then look at its
 * rule and the uevent generated here to load the appropriate driver
657 658 659 660
 *
 * The alias string will be of the form vmbus:guid where guid is the string
 * representation of the device guid (each byte of the guid will be
 * represented with two hex characters.
661 662 663 664
 */
static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
{
	struct hv_device *dev = device_to_hv_device(device);
665 666
	int ret;
	char alias_name[VMBUS_ALIAS_LEN + 1];
667

668
	print_alias_name(dev, alias_name);
669 670
	ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
	return ret;
671 672
}

673
static const struct hv_vmbus_device_id *
674
hv_vmbus_dev_match(const struct hv_vmbus_device_id *id, const guid_t *guid)
675 676 677 678
{
	if (id == NULL)
		return NULL; /* empty device table */

679 680
	for (; !guid_is_null(&id->guid); id++)
		if (guid_equal(&id->guid, guid))
681 682 683 684 685 686
			return id;

	return NULL;
}

static const struct hv_vmbus_device_id *
687
hv_vmbus_dynid_match(struct hv_driver *drv, const guid_t *guid)
688
{
689 690 691 692 693
	const struct hv_vmbus_device_id *id = NULL;
	struct vmbus_dynid *dynid;

	spin_lock(&drv->dynids.lock);
	list_for_each_entry(dynid, &drv->dynids.list, node) {
694
		if (guid_equal(&dynid->id.guid, guid)) {
695 696 697 698 699 700
			id = &dynid->id;
			break;
		}
	}
	spin_unlock(&drv->dynids.lock);

701 702
	return id;
}
703

704
static const struct hv_vmbus_device_id vmbus_device_null;
705

706 707 708 709 710 711 712
/*
 * Return a matching hv_vmbus_device_id pointer.
 * If there is no match, return NULL.
 */
static const struct hv_vmbus_device_id *hv_vmbus_get_id(struct hv_driver *drv,
							struct hv_device *dev)
{
713
	const guid_t *guid = &dev->dev_type;
714
	const struct hv_vmbus_device_id *id;
715

716 717 718 719 720 721 722 723 724 725 726 727 728 729
	/* When driver_override is set, only bind to the matching driver */
	if (dev->driver_override && strcmp(dev->driver_override, drv->name))
		return NULL;

	/* Look at the dynamic ids first, before the static ones */
	id = hv_vmbus_dynid_match(drv, guid);
	if (!id)
		id = hv_vmbus_dev_match(drv->id_table, guid);

	/* driver_override will always match, send a dummy id */
	if (!id && dev->driver_override)
		id = &vmbus_device_null;

	return id;
730 731
}

732
/* vmbus_add_dynid - add a new device ID to this driver and re-probe devices */
733
static int vmbus_add_dynid(struct hv_driver *drv, guid_t *guid)
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770
{
	struct vmbus_dynid *dynid;

	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
	if (!dynid)
		return -ENOMEM;

	dynid->id.guid = *guid;

	spin_lock(&drv->dynids.lock);
	list_add_tail(&dynid->node, &drv->dynids.list);
	spin_unlock(&drv->dynids.lock);

	return driver_attach(&drv->driver);
}

static void vmbus_free_dynids(struct hv_driver *drv)
{
	struct vmbus_dynid *dynid, *n;

	spin_lock(&drv->dynids.lock);
	list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
		list_del(&dynid->node);
		kfree(dynid);
	}
	spin_unlock(&drv->dynids.lock);
}

/*
 * store_new_id - sysfs frontend to vmbus_add_dynid()
 *
 * Allow GUIDs to be added to an existing driver via sysfs.
 */
static ssize_t new_id_store(struct device_driver *driver, const char *buf,
			    size_t count)
{
	struct hv_driver *drv = drv_to_hv_drv(driver);
771
	guid_t guid;
772 773
	ssize_t retval;

774
	retval = guid_parse(buf, &guid);
775 776
	if (retval)
		return retval;
777

778
	if (hv_vmbus_dynid_match(drv, &guid))
779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
		return -EEXIST;

	retval = vmbus_add_dynid(drv, &guid);
	if (retval)
		return retval;
	return count;
}
static DRIVER_ATTR_WO(new_id);

/*
 * store_remove_id - remove a PCI device ID from this driver
 *
 * Removes a dynamic pci device ID to this driver.
 */
static ssize_t remove_id_store(struct device_driver *driver, const char *buf,
			       size_t count)
{
	struct hv_driver *drv = drv_to_hv_drv(driver);
	struct vmbus_dynid *dynid, *n;
798
	guid_t guid;
799
	ssize_t retval;
800

801
	retval = guid_parse(buf, &guid);
802 803
	if (retval)
		return retval;
804

805
	retval = -ENODEV;
806 807 808 809
	spin_lock(&drv->dynids.lock);
	list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
		struct hv_vmbus_device_id *id = &dynid->id;

810
		if (guid_equal(&id->guid, &guid)) {
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
			list_del(&dynid->node);
			kfree(dynid);
			retval = count;
			break;
		}
	}
	spin_unlock(&drv->dynids.lock);

	return retval;
}
static DRIVER_ATTR_WO(remove_id);

static struct attribute *vmbus_drv_attrs[] = {
	&driver_attr_new_id.attr,
	&driver_attr_remove_id.attr,
	NULL,
};
ATTRIBUTE_GROUPS(vmbus_drv);
829

830 831 832 833 834 835 836

/*
 * vmbus_match - Attempt to match the specified device to the specified driver
 */
static int vmbus_match(struct device *device, struct device_driver *driver)
{
	struct hv_driver *drv = drv_to_hv_drv(driver);
837
	struct hv_device *hv_dev = device_to_hv_device(device);
838

839 840 841 842
	/* The hv_sock driver handles all hv_sock offers. */
	if (is_hvsock_channel(hv_dev->channel))
		return drv->hvsock;

843
	if (hv_vmbus_get_id(drv, hv_dev))
844
		return 1;
845

846
	return 0;
847 848
}

849 850 851 852 853 854 855 856
/*
 * vmbus_probe - Add the new vmbus's child device
 */
static int vmbus_probe(struct device *child_device)
{
	int ret = 0;
	struct hv_driver *drv =
			drv_to_hv_drv(child_device->driver);
857
	struct hv_device *dev = device_to_hv_device(child_device);
858
	const struct hv_vmbus_device_id *dev_id;
859

860
	dev_id = hv_vmbus_get_id(drv, dev);
861
	if (drv->probe) {
862
		ret = drv->probe(dev, dev_id);
863
		if (ret != 0)
864 865
			pr_err("probe failed for device %s (%d)\n",
			       dev_name(child_device), ret);
866 867

	} else {
868 869
		pr_err("probe not set for driver %s\n",
		       dev_name(child_device));
870
		ret = -ENODEV;
871 872 873 874
	}
	return ret;
}

875 876 877 878 879
/*
 * vmbus_remove - Remove a vmbus device
 */
static int vmbus_remove(struct device *child_device)
{
880
	struct hv_driver *drv;
881
	struct hv_device *dev = device_to_hv_device(child_device);
882

883 884 885 886 887
	if (child_device->driver) {
		drv = drv_to_hv_drv(child_device->driver);
		if (drv->remove)
			drv->remove(dev);
	}
888 889 890 891

	return 0;
}

892 893 894 895 896 897 898

/*
 * vmbus_shutdown - Shutdown a vmbus device
 */
static void vmbus_shutdown(struct device *child_device)
{
	struct hv_driver *drv;
899
	struct hv_device *dev = device_to_hv_device(child_device);
900 901 902 903 904 905 906 907


	/* The device may not be attached yet */
	if (!child_device->driver)
		return;

	drv = drv_to_hv_drv(child_device->driver);

908 909
	if (drv->shutdown)
		drv->shutdown(dev);
910 911
}

912 913 914 915 916 917

/*
 * vmbus_device_release - Final callback release of the vmbus child device
 */
static void vmbus_device_release(struct device *device)
{
918
	struct hv_device *hv_dev = device_to_hv_device(device);
919
	struct vmbus_channel *channel = hv_dev->channel;
920

921
	mutex_lock(&vmbus_connection.channel_mutex);
922
	hv_process_channel_removal(channel);
923
	mutex_unlock(&vmbus_connection.channel_mutex);
924
	kfree(hv_dev);
925 926
}

927
/* The one and only one */
928 929 930 931 932 933 934
static struct bus_type  hv_bus = {
	.name =		"vmbus",
	.match =		vmbus_match,
	.shutdown =		vmbus_shutdown,
	.remove =		vmbus_remove,
	.probe =		vmbus_probe,
	.uevent =		vmbus_uevent,
935 936
	.dev_groups =		vmbus_dev_groups,
	.drv_groups =		vmbus_drv_groups,
937 938
};

939 940 941 942 943 944 945 946 947
struct onmessage_work_context {
	struct work_struct work;
	struct hv_message msg;
};

static void vmbus_onmessage_work(struct work_struct *work)
{
	struct onmessage_work_context *ctx;

948 949 950 951
	/* Do not process messages if we're in DISCONNECTED state */
	if (vmbus_connection.conn_state == DISCONNECTED)
		return;

952 953 954 955 956 957
	ctx = container_of(work, struct onmessage_work_context,
			   work);
	vmbus_onmessage(&ctx->msg);
	kfree(ctx);
}

958 959
static void hv_process_timer_expiration(struct hv_message *msg,
					struct hv_per_cpu_context *hv_cpu)
960
{
961
	struct clock_event_device *dev = hv_cpu->clk_evt;
962 963 964 965

	if (dev->event_handler)
		dev->event_handler(dev);

966
	vmbus_signal_eom(msg, HVMSG_TIMER_EXPIRED);
967 968
}

969
void vmbus_on_msg_dpc(unsigned long data)
G
Greg Kroah-Hartman 已提交
970
{
971 972
	struct hv_per_cpu_context *hv_cpu = (void *)data;
	void *page_addr = hv_cpu->synic_message_page;
G
Greg Kroah-Hartman 已提交
973 974
	struct hv_message *msg = (struct hv_message *)page_addr +
				  VMBUS_MESSAGE_SINT;
975
	struct vmbus_channel_message_header *hdr;
976
	const struct vmbus_channel_message_table_entry *entry;
977
	struct onmessage_work_context *ctx;
978
	u32 message_type = msg->header.message_type;
G
Greg Kroah-Hartman 已提交
979

980
	if (message_type == HVMSG_NONE)
981 982
		/* no msg */
		return;
983

984
	hdr = (struct vmbus_channel_message_header *)msg->u.payload;
985

986 987
	trace_vmbus_on_msg_dpc(hdr);

988 989 990 991
	if (hdr->msgtype >= CHANNELMSG_COUNT) {
		WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype);
		goto msg_handled;
	}
992

993 994 995 996 997
	entry = &channel_message_table[hdr->msgtype];
	if (entry->handler_type	== VMHT_BLOCKING) {
		ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
		if (ctx == NULL)
			return;
998

999 1000
		INIT_WORK(&ctx->work, vmbus_onmessage_work);
		memcpy(&ctx->msg, msg, sizeof(*msg));
1001

1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
		/*
		 * The host can generate a rescind message while we
		 * may still be handling the original offer. We deal with
		 * this condition by ensuring the processing is done on the
		 * same CPU.
		 */
		switch (hdr->msgtype) {
		case CHANNELMSG_RESCIND_CHANNELOFFER:
			/*
			 * If we are handling the rescind message;
			 * schedule the work on the global work queue.
			 */
			schedule_work_on(vmbus_connection.connect_cpu,
					 &ctx->work);
			break;

		case CHANNELMSG_OFFERCHANNEL:
			atomic_inc(&vmbus_connection.offer_in_progress);
			queue_work_on(vmbus_connection.connect_cpu,
				      vmbus_connection.work_queue,
				      &ctx->work);
			break;

		default:
			queue_work(vmbus_connection.work_queue, &ctx->work);
		}
1028 1029
	} else
		entry->message_handler(hdr);
G
Greg Kroah-Hartman 已提交
1030

1031
msg_handled:
1032
	vmbus_signal_eom(msg, message_type);
G
Greg Kroah-Hartman 已提交
1033 1034
}

1035

1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
/*
 * Direct callback for channels using other deferred processing
 */
static void vmbus_channel_isr(struct vmbus_channel *channel)
{
	void (*callback_fn)(void *);

	callback_fn = READ_ONCE(channel->onchannel_callback);
	if (likely(callback_fn != NULL))
		(*callback_fn)(channel->channel_callback_context);
}

1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
/*
 * Schedule all channels with events pending
 */
static void vmbus_chan_sched(struct hv_per_cpu_context *hv_cpu)
{
	unsigned long *recv_int_page;
	u32 maxbits, relid;

	if (vmbus_proto_version < VERSION_WIN8) {
		maxbits = MAX_NUM_CHANNELS_SUPPORTED;
		recv_int_page = vmbus_connection.recv_int_page;
	} else {
		/*
		 * When the host is win8 and beyond, the event page
		 * can be directly checked to get the id of the channel
		 * that has the interrupt pending.
		 */
		void *page_addr = hv_cpu->synic_event_page;
		union hv_synic_event_flags *event
			= (union hv_synic_event_flags *)page_addr +
						 VMBUS_MESSAGE_SINT;

		maxbits = HV_EVENT_FLAGS_COUNT;
		recv_int_page = event->flags;
	}

	if (unlikely(!recv_int_page))
		return;

	for_each_set_bit(relid, recv_int_page, maxbits) {
		struct vmbus_channel *channel;

		if (!sync_test_and_clear_bit(relid, recv_int_page))
			continue;

		/* Special case - vmbus channel protocol msg */
		if (relid == 0)
			continue;

1087 1088
		rcu_read_lock();

1089
		/* Find channel based on relid */
1090
		list_for_each_entry_rcu(channel, &hv_cpu->chan_list, percpu_list) {
1091 1092 1093
			if (channel->offermsg.child_relid != relid)
				continue;

1094 1095 1096
			if (channel->rescind)
				continue;

V
Vitaly Kuznetsov 已提交
1097 1098
			trace_vmbus_chan_sched(channel);

1099 1100
			++channel->interrupts;

1101 1102 1103
			switch (channel->callback_mode) {
			case HV_CALL_ISR:
				vmbus_channel_isr(channel);
1104
				break;
1105 1106 1107 1108 1109 1110

			case HV_CALL_BATCHED:
				hv_begin_read(&channel->inbound);
				/* fallthrough */
			case HV_CALL_DIRECT:
				tasklet_schedule(&channel->callback_event);
1111 1112
			}
		}
1113 1114

		rcu_read_unlock();
1115 1116 1117
	}
}

1118
static void vmbus_isr(void)
G
Greg Kroah-Hartman 已提交
1119
{
1120 1121 1122
	struct hv_per_cpu_context *hv_cpu
		= this_cpu_ptr(hv_context.cpu_context);
	void *page_addr = hv_cpu->synic_event_page;
G
Greg Kroah-Hartman 已提交
1123 1124
	struct hv_message *msg;
	union hv_synic_event_flags *event;
1125
	bool handled = false;
G
Greg Kroah-Hartman 已提交
1126

1127
	if (unlikely(page_addr == NULL))
1128
		return;
1129 1130 1131

	event = (union hv_synic_event_flags *)page_addr +
					 VMBUS_MESSAGE_SINT;
1132 1133 1134 1135 1136
	/*
	 * Check for events before checking for messages. This is the order
	 * in which events and messages are checked in Windows guests on
	 * Hyper-V, and the Windows team suggested we do the same.
	 */
G
Greg Kroah-Hartman 已提交
1137

1138 1139
	if ((vmbus_proto_version == VERSION_WS2008) ||
		(vmbus_proto_version == VERSION_WIN7)) {
G
Greg Kroah-Hartman 已提交
1140

1141
		/* Since we are a child, we only need to check bit 0 */
1142
		if (sync_test_and_clear_bit(0, event->flags))
1143 1144 1145 1146 1147 1148 1149 1150
			handled = true;
	} else {
		/*
		 * Our host is win8 or above. The signaling mechanism
		 * has changed and we can directly look at the event page.
		 * If bit n is set then we have an interrup on the channel
		 * whose id is n.
		 */
1151 1152
		handled = true;
	}
1153

1154
	if (handled)
1155
		vmbus_chan_sched(hv_cpu);
1156

1157
	page_addr = hv_cpu->synic_message_page;
1158 1159 1160
	msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;

	/* Check if there are actual msgs to be processed */
1161 1162
	if (msg->header.message_type != HVMSG_NONE) {
		if (msg->header.message_type == HVMSG_TIMER_EXPIRED)
1163
			hv_process_timer_expiration(msg, hv_cpu);
1164
		else
1165
			tasklet_schedule(&hv_cpu->msg_dpc);
1166
	}
1167 1168

	add_interrupt_randomness(HYPERVISOR_CALLBACK_VECTOR, 0);
1169 1170
}

1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
/*
 * Boolean to control whether to report panic messages over Hyper-V.
 *
 * It can be set via /proc/sys/kernel/hyperv/record_panic_msg
 */
static int sysctl_record_panic_msg = 1;

/*
 * Callback from kmsg_dump. Grab as much as possible from the end of the kmsg
 * buffer and call into Hyper-V to transfer the data.
 */
static void hv_kmsg_dump(struct kmsg_dumper *dumper,
			 enum kmsg_dump_reason reason)
{
	size_t bytes_written;
	phys_addr_t panic_pa;

	/* We are only interested in panics. */
	if ((reason != KMSG_DUMP_PANIC) || (!sysctl_record_panic_msg))
		return;

	panic_pa = virt_to_phys(hv_panic_page);

	/*
	 * Write dump contents to the page. No need to synchronize; panic should
	 * be single-threaded.
	 */
1198 1199 1200 1201
	kmsg_dump_get_buffer(dumper, true, hv_panic_page, PAGE_SIZE,
			     &bytes_written);
	if (bytes_written)
		hyperv_report_panic_msg(panic_pa, bytes_written);
1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
}

static struct kmsg_dumper hv_kmsg_dumper = {
	.dump = hv_kmsg_dump,
};

static struct ctl_table_header *hv_ctl_table_hdr;
static int zero;
static int one = 1;

/*
 * sysctl option to allow the user to control whether kmsg data should be
 * reported to Hyper-V on panic.
 */
static struct ctl_table hv_ctl_table[] = {
	{
		.procname       = "hyperv_record_panic_msg",
		.data           = &sysctl_record_panic_msg,
		.maxlen         = sizeof(int),
		.mode           = 0644,
		.proc_handler   = proc_dointvec_minmax,
		.extra1		= &zero,
		.extra2		= &one
	},
	{}
};

static struct ctl_table hv_root_table[] = {
	{
		.procname	= "kernel",
		.mode		= 0555,
		.child		= hv_ctl_table
	},
	{}
};
1237

1238
/*
1239 1240 1241
 * vmbus_bus_init -Main vmbus driver initialization routine.
 *
 * Here, we
1242 1243 1244
 *	- initialize the vmbus driver context
 *	- invoke the vmbus hv main init routine
 *	- retrieve the channel offers
1245
 */
1246
static int vmbus_bus_init(void)
1247
{
1248
	int ret;
1249

1250 1251
	/* Hypervisor initialization...setup hypercall page..etc */
	ret = hv_init();
1252
	if (ret != 0) {
1253
		pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
1254
		return ret;
1255 1256
	}

1257
	ret = bus_register(&hv_bus);
1258
	if (ret)
1259
		return ret;
1260

1261
	hv_setup_vmbus_irq(vmbus_isr);
1262

1263 1264 1265
	ret = hv_synic_alloc();
	if (ret)
		goto err_alloc;
1266
	/*
1267
	 * Initialize the per-cpu interrupt state and
1268 1269
	 * connect to the host.
	 */
1270
	ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "hyperv/vmbus:online",
1271 1272 1273 1274 1275
				hv_synic_init, hv_synic_cleanup);
	if (ret < 0)
		goto err_alloc;
	hyperv_cpuhp_online = ret;

1276
	ret = vmbus_connect();
1277
	if (ret)
1278
		goto err_connect;
1279

1280 1281 1282
	/*
	 * Only register if the crash MSRs are available
	 */
1283
	if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
		u64 hyperv_crash_ctl;
		/*
		 * Sysctl registration is not fatal, since by default
		 * reporting is enabled.
		 */
		hv_ctl_table_hdr = register_sysctl_table(hv_root_table);
		if (!hv_ctl_table_hdr)
			pr_err("Hyper-V: sysctl table register error");

		/*
		 * Register for panic kmsg callback only if the right
		 * capability is supported by the hypervisor.
		 */
1297
		hv_get_crash_ctl(hyperv_crash_ctl);
1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
		if (hyperv_crash_ctl & HV_CRASH_CTL_CRASH_NOTIFY_MSG) {
			hv_panic_page = (void *)get_zeroed_page(GFP_KERNEL);
			if (hv_panic_page) {
				ret = kmsg_dump_register(&hv_kmsg_dumper);
				if (ret)
					pr_err("Hyper-V: kmsg dump register "
						"error 0x%x\n", ret);
			} else
				pr_err("Hyper-V: panic message page memory "
					"allocation failed");
		}

1310
		register_die_notifier(&hyperv_die_block);
1311 1312 1313 1314
		atomic_notifier_chain_register(&panic_notifier_list,
					       &hyperv_panic_block);
	}

1315
	vmbus_request_offers();
1316

1317
	return 0;
1318

1319
err_connect:
1320
	cpuhp_remove_state(hyperv_cpuhp_online);
1321 1322
err_alloc:
	hv_synic_free();
1323
	hv_remove_vmbus_irq();
1324 1325

	bus_unregister(&hv_bus);
1326
	free_page((unsigned long)hv_panic_page);
1327 1328
	unregister_sysctl_table(hv_ctl_table_hdr);
	hv_ctl_table_hdr = NULL;
1329
	return ret;
1330 1331
}

1332
/**
1333 1334
 * __vmbus_child_driver_register() - Register a vmbus's driver
 * @hv_driver: Pointer to driver structure you want to register
1335 1336
 * @owner: owner module of the drv
 * @mod_name: module name string
1337 1338
 *
 * Registers the given driver with Linux through the 'driver_register()' call
1339
 * and sets up the hyper-v vmbus handling for this driver.
1340 1341
 * It will return the state of the 'driver_register()' call.
 *
1342
 */
1343
int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
1344
{
1345
	int ret;
1346

1347
	pr_info("registering driver %s\n", hv_driver->name);
1348

1349 1350 1351 1352
	ret = vmbus_exists();
	if (ret < 0)
		return ret;

1353 1354 1355 1356
	hv_driver->driver.name = hv_driver->name;
	hv_driver->driver.owner = owner;
	hv_driver->driver.mod_name = mod_name;
	hv_driver->driver.bus = &hv_bus;
1357

1358 1359 1360
	spin_lock_init(&hv_driver->dynids.lock);
	INIT_LIST_HEAD(&hv_driver->dynids.list);

1361
	ret = driver_register(&hv_driver->driver);
1362

1363
	return ret;
1364
}
1365
EXPORT_SYMBOL_GPL(__vmbus_driver_register);
1366

1367
/**
1368
 * vmbus_driver_unregister() - Unregister a vmbus's driver
1369 1370
 * @hv_driver: Pointer to driver structure you want to
 *             un-register
1371
 *
1372 1373
 * Un-register the given driver that was previous registered with a call to
 * vmbus_driver_register()
1374
 */
1375
void vmbus_driver_unregister(struct hv_driver *hv_driver)
1376
{
1377
	pr_info("unregistering driver %s\n", hv_driver->name);
1378

1379
	if (!vmbus_exists()) {
1380
		driver_unregister(&hv_driver->driver);
1381 1382
		vmbus_free_dynids(hv_driver);
	}
1383
}
1384
EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
1385

1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399

/*
 * Called when last reference to channel is gone.
 */
static void vmbus_chan_release(struct kobject *kobj)
{
	struct vmbus_channel *channel
		= container_of(kobj, struct vmbus_channel, kobj);

	kfree_rcu(channel, rcu);
}

struct vmbus_chan_attribute {
	struct attribute attr;
1400
	ssize_t (*show)(struct vmbus_channel *chan, char *buf);
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
	ssize_t (*store)(struct vmbus_channel *chan,
			 const char *buf, size_t count);
};
#define VMBUS_CHAN_ATTR(_name, _mode, _show, _store) \
	struct vmbus_chan_attribute chan_attr_##_name \
		= __ATTR(_name, _mode, _show, _store)
#define VMBUS_CHAN_ATTR_RW(_name) \
	struct vmbus_chan_attribute chan_attr_##_name = __ATTR_RW(_name)
#define VMBUS_CHAN_ATTR_RO(_name) \
	struct vmbus_chan_attribute chan_attr_##_name = __ATTR_RO(_name)
#define VMBUS_CHAN_ATTR_WO(_name) \
	struct vmbus_chan_attribute chan_attr_##_name = __ATTR_WO(_name)

static ssize_t vmbus_chan_attr_show(struct kobject *kobj,
				    struct attribute *attr, char *buf)
{
	const struct vmbus_chan_attribute *attribute
		= container_of(attr, struct vmbus_chan_attribute, attr);
1419
	struct vmbus_channel *chan
1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
		= container_of(kobj, struct vmbus_channel, kobj);

	if (!attribute->show)
		return -EIO;

	return attribute->show(chan, buf);
}

static const struct sysfs_ops vmbus_chan_sysfs_ops = {
	.show = vmbus_chan_attr_show,
};

1432
static ssize_t out_mask_show(struct vmbus_channel *channel, char *buf)
1433
{
1434 1435
	struct hv_ring_buffer_info *rbi = &channel->outbound;
	ssize_t ret;
1436

1437 1438 1439
	mutex_lock(&rbi->ring_buffer_mutex);
	if (!rbi->ring_buffer) {
		mutex_unlock(&rbi->ring_buffer_mutex);
1440
		return -EINVAL;
1441
	}
1442

1443 1444 1445
	ret = sprintf(buf, "%u\n", rbi->ring_buffer->interrupt_mask);
	mutex_unlock(&rbi->ring_buffer_mutex);
	return ret;
1446
}
1447
static VMBUS_CHAN_ATTR_RO(out_mask);
1448

1449
static ssize_t in_mask_show(struct vmbus_channel *channel, char *buf)
1450
{
1451 1452
	struct hv_ring_buffer_info *rbi = &channel->inbound;
	ssize_t ret;
1453

1454 1455 1456
	mutex_lock(&rbi->ring_buffer_mutex);
	if (!rbi->ring_buffer) {
		mutex_unlock(&rbi->ring_buffer_mutex);
1457
		return -EINVAL;
1458
	}
1459

1460 1461 1462
	ret = sprintf(buf, "%u\n", rbi->ring_buffer->interrupt_mask);
	mutex_unlock(&rbi->ring_buffer_mutex);
	return ret;
1463
}
1464
static VMBUS_CHAN_ATTR_RO(in_mask);
1465

1466
static ssize_t read_avail_show(struct vmbus_channel *channel, char *buf)
1467
{
1468 1469
	struct hv_ring_buffer_info *rbi = &channel->inbound;
	ssize_t ret;
1470

1471 1472 1473
	mutex_lock(&rbi->ring_buffer_mutex);
	if (!rbi->ring_buffer) {
		mutex_unlock(&rbi->ring_buffer_mutex);
1474
		return -EINVAL;
1475
	}
1476

1477 1478 1479
	ret = sprintf(buf, "%u\n", hv_get_bytes_to_read(rbi));
	mutex_unlock(&rbi->ring_buffer_mutex);
	return ret;
1480
}
1481
static VMBUS_CHAN_ATTR_RO(read_avail);
1482

1483
static ssize_t write_avail_show(struct vmbus_channel *channel, char *buf)
1484
{
1485 1486
	struct hv_ring_buffer_info *rbi = &channel->outbound;
	ssize_t ret;
1487

1488 1489 1490
	mutex_lock(&rbi->ring_buffer_mutex);
	if (!rbi->ring_buffer) {
		mutex_unlock(&rbi->ring_buffer_mutex);
1491
		return -EINVAL;
1492
	}
1493

1494 1495 1496
	ret = sprintf(buf, "%u\n", hv_get_bytes_to_write(rbi));
	mutex_unlock(&rbi->ring_buffer_mutex);
	return ret;
1497
}
1498
static VMBUS_CHAN_ATTR_RO(write_avail);
1499

1500
static ssize_t show_target_cpu(struct vmbus_channel *channel, char *buf)
1501 1502 1503
{
	return sprintf(buf, "%u\n", channel->target_cpu);
}
1504
static VMBUS_CHAN_ATTR(cpu, S_IRUGO, show_target_cpu, NULL);
1505

1506
static ssize_t channel_pending_show(struct vmbus_channel *channel,
1507 1508 1509 1510 1511 1512
				    char *buf)
{
	return sprintf(buf, "%d\n",
		       channel_pending(channel,
				       vmbus_connection.monitor_pages[1]));
}
1513
static VMBUS_CHAN_ATTR(pending, S_IRUGO, channel_pending_show, NULL);
1514

1515
static ssize_t channel_latency_show(struct vmbus_channel *channel,
1516 1517 1518 1519 1520 1521
				    char *buf)
{
	return sprintf(buf, "%d\n",
		       channel_latency(channel,
				       vmbus_connection.monitor_pages[1]));
}
1522
static VMBUS_CHAN_ATTR(latency, S_IRUGO, channel_latency_show, NULL);
1523

1524
static ssize_t channel_interrupts_show(struct vmbus_channel *channel, char *buf)
1525 1526 1527
{
	return sprintf(buf, "%llu\n", channel->interrupts);
}
1528
static VMBUS_CHAN_ATTR(interrupts, S_IRUGO, channel_interrupts_show, NULL);
1529

1530
static ssize_t channel_events_show(struct vmbus_channel *channel, char *buf)
1531 1532 1533
{
	return sprintf(buf, "%llu\n", channel->sig_events);
}
1534
static VMBUS_CHAN_ATTR(events, S_IRUGO, channel_events_show, NULL);
1535

1536
static ssize_t channel_intr_in_full_show(struct vmbus_channel *channel,
1537 1538 1539 1540 1541 1542 1543
					 char *buf)
{
	return sprintf(buf, "%llu\n",
		       (unsigned long long)channel->intr_in_full);
}
static VMBUS_CHAN_ATTR(intr_in_full, 0444, channel_intr_in_full_show, NULL);

1544
static ssize_t channel_intr_out_empty_show(struct vmbus_channel *channel,
1545 1546 1547 1548 1549 1550 1551
					   char *buf)
{
	return sprintf(buf, "%llu\n",
		       (unsigned long long)channel->intr_out_empty);
}
static VMBUS_CHAN_ATTR(intr_out_empty, 0444, channel_intr_out_empty_show, NULL);

1552
static ssize_t channel_out_full_first_show(struct vmbus_channel *channel,
1553 1554 1555 1556 1557 1558 1559
					   char *buf)
{
	return sprintf(buf, "%llu\n",
		       (unsigned long long)channel->out_full_first);
}
static VMBUS_CHAN_ATTR(out_full_first, 0444, channel_out_full_first_show, NULL);

1560
static ssize_t channel_out_full_total_show(struct vmbus_channel *channel,
1561 1562 1563 1564 1565 1566 1567
					   char *buf)
{
	return sprintf(buf, "%llu\n",
		       (unsigned long long)channel->out_full_total);
}
static VMBUS_CHAN_ATTR(out_full_total, 0444, channel_out_full_total_show, NULL);

1568
static ssize_t subchannel_monitor_id_show(struct vmbus_channel *channel,
1569 1570 1571 1572 1573 1574
					  char *buf)
{
	return sprintf(buf, "%u\n", channel->offermsg.monitorid);
}
static VMBUS_CHAN_ATTR(monitor_id, S_IRUGO, subchannel_monitor_id_show, NULL);

1575
static ssize_t subchannel_id_show(struct vmbus_channel *channel,
1576 1577 1578 1579 1580 1581 1582
				  char *buf)
{
	return sprintf(buf, "%u\n",
		       channel->offermsg.offer.sub_channel_index);
}
static VMBUS_CHAN_ATTR_RO(subchannel_id);

1583 1584 1585 1586 1587 1588 1589 1590
static struct attribute *vmbus_chan_attrs[] = {
	&chan_attr_out_mask.attr,
	&chan_attr_in_mask.attr,
	&chan_attr_read_avail.attr,
	&chan_attr_write_avail.attr,
	&chan_attr_cpu.attr,
	&chan_attr_pending.attr,
	&chan_attr_latency.attr,
1591 1592
	&chan_attr_interrupts.attr,
	&chan_attr_events.attr,
1593 1594 1595 1596
	&chan_attr_intr_in_full.attr,
	&chan_attr_intr_out_empty.attr,
	&chan_attr_out_full_first.attr,
	&chan_attr_out_full_total.attr,
1597 1598
	&chan_attr_monitor_id.attr,
	&chan_attr_subchannel_id.attr,
1599 1600 1601
	NULL
};

1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626
/*
 * Channel-level attribute_group callback function. Returns the permission for
 * each attribute, and returns 0 if an attribute is not visible.
 */
static umode_t vmbus_chan_attr_is_visible(struct kobject *kobj,
					  struct attribute *attr, int idx)
{
	const struct vmbus_channel *channel =
		container_of(kobj, struct vmbus_channel, kobj);

	/* Hide the monitor attributes if the monitor mechanism is not used. */
	if (!channel->offermsg.monitor_allocated &&
	    (attr == &chan_attr_pending.attr ||
	     attr == &chan_attr_latency.attr ||
	     attr == &chan_attr_monitor_id.attr))
		return 0;

	return attr->mode;
}

static struct attribute_group vmbus_chan_group = {
	.attrs = vmbus_chan_attrs,
	.is_visible = vmbus_chan_attr_is_visible
};

1627 1628 1629 1630 1631 1632 1633 1634 1635 1636
static struct kobj_type vmbus_chan_ktype = {
	.sysfs_ops = &vmbus_chan_sysfs_ops,
	.release = vmbus_chan_release,
};

/*
 * vmbus_add_channel_kobj - setup a sub-directory under device/channels
 */
int vmbus_add_channel_kobj(struct hv_device *dev, struct vmbus_channel *channel)
{
1637
	const struct device *device = &dev->device;
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647
	struct kobject *kobj = &channel->kobj;
	u32 relid = channel->offermsg.child_relid;
	int ret;

	kobj->kset = dev->channels_kset;
	ret = kobject_init_and_add(kobj, &vmbus_chan_ktype, NULL,
				   "%u", relid);
	if (ret)
		return ret;

1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658
	ret = sysfs_create_group(kobj, &vmbus_chan_group);

	if (ret) {
		/*
		 * The calling functions' error handling paths will cleanup the
		 * empty channel directory.
		 */
		dev_err(device, "Unable to set up channel sysfs files\n");
		return ret;
	}

1659 1660 1661 1662 1663
	kobject_uevent(kobj, KOBJ_ADD);

	return 0;
}

1664 1665 1666 1667 1668 1669 1670 1671
/*
 * vmbus_remove_channel_attr_group - remove the channel's attribute group
 */
void vmbus_remove_channel_attr_group(struct vmbus_channel *channel)
{
	sysfs_remove_group(&channel->kobj, &vmbus_chan_group);
}

1672
/*
1673
 * vmbus_device_create - Creates and registers a new child device
1674
 * on the vmbus.
1675
 */
1676 1677
struct hv_device *vmbus_device_create(const guid_t *type,
				      const guid_t *instance,
S
stephen hemminger 已提交
1678
				      struct vmbus_channel *channel)
1679
{
1680
	struct hv_device *child_device_obj;
1681

1682 1683
	child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
	if (!child_device_obj) {
1684
		pr_err("Unable to allocate device object for child device\n");
1685 1686 1687
		return NULL;
	}

1688
	child_device_obj->channel = channel;
1689 1690
	guid_copy(&child_device_obj->dev_type, type);
	guid_copy(&child_device_obj->dev_instance, instance);
1691
	child_device_obj->vendor_id = 0x1414; /* MSFT vendor ID */
1692 1693 1694 1695

	return child_device_obj;
}

1696
/*
1697
 * vmbus_device_register - Register the child device
1698
 */
1699
int vmbus_device_register(struct hv_device *child_device_obj)
1700
{
1701 1702
	struct kobject *kobj = &child_device_obj->device.kobj;
	int ret;
1703

1704
	dev_set_name(&child_device_obj->device, "%pUl",
1705
		     child_device_obj->channel->offermsg.offer.if_instance.b);
1706

1707
	child_device_obj->device.bus = &hv_bus;
1708
	child_device_obj->device.parent = &hv_acpi_dev->dev;
1709
	child_device_obj->device.release = vmbus_device_release;
1710

1711 1712 1713 1714
	/*
	 * Register with the LDM. This will kick off the driver/device
	 * binding...which will eventually call vmbus_match() and vmbus_probe()
	 */
1715
	ret = device_register(&child_device_obj->device);
1716
	if (ret) {
1717
		pr_err("Unable to register child device\n");
1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738
		return ret;
	}

	child_device_obj->channels_kset = kset_create_and_add("channels",
							      NULL, kobj);
	if (!child_device_obj->channels_kset) {
		ret = -ENOMEM;
		goto err_dev_unregister;
	}

	ret = vmbus_add_channel_kobj(child_device_obj,
				     child_device_obj->channel);
	if (ret) {
		pr_err("Unable to register primary channeln");
		goto err_kset_unregister;
	}

	return 0;

err_kset_unregister:
	kset_unregister(child_device_obj->channels_kset);
1739

1740 1741
err_dev_unregister:
	device_unregister(&child_device_obj->device);
1742 1743 1744
	return ret;
}

1745
/*
1746
 * vmbus_device_unregister - Remove the specified child device
1747
 * from the vmbus.
1748
 */
1749
void vmbus_device_unregister(struct hv_device *device_obj)
1750
{
1751 1752 1753
	pr_debug("child device %s unregistered\n",
		dev_name(&device_obj->device));

1754 1755
	kset_unregister(device_obj->channels_kset);

1756 1757 1758 1759
	/*
	 * Kick off the process of unregistering the device.
	 * This will call vmbus_remove() and eventually vmbus_device_release()
	 */
1760
	device_unregister(&device_obj->device);
1761 1762 1763
}


1764
/*
1765
 * VMBUS is an acpi enumerated device. Get the information we
1766
 * need from DSDT.
1767
 */
1768
#define VTPM_BASE_ADDRESS 0xfed40000
1769
static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
1770
{
1771 1772 1773 1774 1775 1776
	resource_size_t start = 0;
	resource_size_t end = 0;
	struct resource *new_res;
	struct resource **old_res = &hyperv_mmio;
	struct resource **prev_res = NULL;

1777
	switch (res->type) {
1778 1779 1780 1781 1782 1783 1784 1785 1786

	/*
	 * "Address" descriptors are for bus windows. Ignore
	 * "memory" descriptors, which are for registers on
	 * devices.
	 */
	case ACPI_RESOURCE_TYPE_ADDRESS32:
		start = res->data.address32.address.minimum;
		end = res->data.address32.address.maximum;
G
Gerd Hoffmann 已提交
1787
		break;
1788

1789
	case ACPI_RESOURCE_TYPE_ADDRESS64:
1790 1791
		start = res->data.address64.address.minimum;
		end = res->data.address64.address.maximum;
G
Gerd Hoffmann 已提交
1792
		break;
1793 1794 1795 1796 1797

	default:
		/* Unused resource type */
		return AE_OK;

1798
	}
1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
	/*
	 * Ignore ranges that are below 1MB, as they're not
	 * necessary or useful here.
	 */
	if (end < 0x100000)
		return AE_OK;

	new_res = kzalloc(sizeof(*new_res), GFP_ATOMIC);
	if (!new_res)
		return AE_NO_MEMORY;

	/* If this range overlaps the virtual TPM, truncate it. */
	if (end > VTPM_BASE_ADDRESS && start < VTPM_BASE_ADDRESS)
		end = VTPM_BASE_ADDRESS;

	new_res->name = "hyperv mmio";
	new_res->flags = IORESOURCE_MEM;
	new_res->start = start;
	new_res->end = end;

1819 1820 1821
	/*
	 * If two ranges are adjacent, merge them.
	 */
1822 1823 1824 1825 1826 1827
	do {
		if (!*old_res) {
			*old_res = new_res;
			break;
		}

1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839
		if (((*old_res)->end + 1) == new_res->start) {
			(*old_res)->end = new_res->end;
			kfree(new_res);
			break;
		}

		if ((*old_res)->start == new_res->end + 1) {
			(*old_res)->start = new_res->start;
			kfree(new_res);
			break;
		}

1840
		if ((*old_res)->start > new_res->end) {
1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
			new_res->sibling = *old_res;
			if (prev_res)
				(*prev_res)->sibling = new_res;
			*old_res = new_res;
			break;
		}

		prev_res = old_res;
		old_res = &(*old_res)->sibling;

	} while (1);
1852 1853 1854 1855

	return AE_OK;
}

1856 1857 1858 1859 1860 1861
static int vmbus_acpi_remove(struct acpi_device *device)
{
	struct resource *cur_res;
	struct resource *next_res;

	if (hyperv_mmio) {
1862 1863 1864 1865 1866 1867
		if (fb_mmio) {
			__release_region(hyperv_mmio, fb_mmio->start,
					 resource_size(fb_mmio));
			fb_mmio = NULL;
		}

1868 1869 1870 1871 1872 1873 1874 1875 1876
		for (cur_res = hyperv_mmio; cur_res; cur_res = next_res) {
			next_res = cur_res->sibling;
			kfree(cur_res);
		}
	}

	return 0;
}

1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
static void vmbus_reserve_fb(void)
{
	int size;
	/*
	 * Make a claim for the frame buffer in the resource tree under the
	 * first node, which will be the one below 4GB.  The length seems to
	 * be underreported, particularly in a Generation 1 VM.  So start out
	 * reserving a larger area and make it smaller until it succeeds.
	 */

	if (screen_info.lfb_base) {
		if (efi_enabled(EFI_BOOT))
			size = max_t(__u32, screen_info.lfb_size, 0x800000);
		else
			size = max_t(__u32, screen_info.lfb_size, 0x4000000);

		for (; !fb_mmio && (size >= 0x100000); size >>= 1) {
			fb_mmio = __request_region(hyperv_mmio,
						   screen_info.lfb_base, size,
						   fb_mmio_name, 0);
		}
	}
}

1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
/**
 * vmbus_allocate_mmio() - Pick a memory-mapped I/O range.
 * @new:		If successful, supplied a pointer to the
 *			allocated MMIO space.
 * @device_obj:		Identifies the caller
 * @min:		Minimum guest physical address of the
 *			allocation
 * @max:		Maximum guest physical address
 * @size:		Size of the range to be allocated
 * @align:		Alignment of the range to be allocated
 * @fb_overlap_ok:	Whether this allocation can be allowed
 *			to overlap the video frame buffer.
 *
 * This function walks the resources granted to VMBus by the
 * _CRS object in the ACPI namespace underneath the parent
 * "bridge" whether that's a root PCI bus in the Generation 1
 * case or a Module Device in the Generation 2 case.  It then
 * attempts to allocate from the global MMIO pool in a way that
 * matches the constraints supplied in these parameters and by
 * that _CRS.
 *
 * Return: 0 on success, -errno on failure
 */
int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
			resource_size_t min, resource_size_t max,
			resource_size_t size, resource_size_t align,
			bool fb_overlap_ok)
{
1929
	struct resource *iter, *shadow;
1930
	resource_size_t range_min, range_max, start;
1931
	const char *dev_n = dev_name(&device_obj->device);
1932
	int retval;
1933 1934 1935

	retval = -ENXIO;
	down(&hyperv_mmio_lock);
1936

1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
	/*
	 * If overlaps with frame buffers are allowed, then first attempt to
	 * make the allocation from within the reserved region.  Because it
	 * is already reserved, no shadow allocation is necessary.
	 */
	if (fb_overlap_ok && fb_mmio && !(min > fb_mmio->end) &&
	    !(max < fb_mmio->start)) {

		range_min = fb_mmio->start;
		range_max = fb_mmio->end;
		start = (range_min + align - 1) & ~(align - 1);
		for (; start + size - 1 <= range_max; start += align) {
			*new = request_mem_region_exclusive(start, size, dev_n);
			if (*new) {
				retval = 0;
				goto exit;
			}
		}
	}

1957 1958 1959 1960 1961 1962
	for (iter = hyperv_mmio; iter; iter = iter->sibling) {
		if ((iter->start >= max) || (iter->end <= min))
			continue;

		range_min = iter->start;
		range_max = iter->end;
1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974
		start = (range_min + align - 1) & ~(align - 1);
		for (; start + size - 1 <= range_max; start += align) {
			shadow = __request_region(iter, start, size, NULL,
						  IORESOURCE_BUSY);
			if (!shadow)
				continue;

			*new = request_mem_region_exclusive(start, size, dev_n);
			if (*new) {
				shadow->name = (char *)*new;
				retval = 0;
				goto exit;
1975 1976
			}

1977
			__release_region(iter, start, size);
1978 1979 1980
		}
	}

1981 1982 1983
exit:
	up(&hyperv_mmio_lock);
	return retval;
1984 1985 1986
}
EXPORT_SYMBOL_GPL(vmbus_allocate_mmio);

1987 1988 1989 1990 1991 1992 1993 1994 1995 1996
/**
 * vmbus_free_mmio() - Free a memory-mapped I/O range.
 * @start:		Base address of region to release.
 * @size:		Size of the range to be allocated
 *
 * This function releases anything requested by
 * vmbus_mmio_allocate().
 */
void vmbus_free_mmio(resource_size_t start, resource_size_t size)
{
1997 1998 1999 2000 2001 2002 2003 2004 2005
	struct resource *iter;

	down(&hyperv_mmio_lock);
	for (iter = hyperv_mmio; iter; iter = iter->sibling) {
		if ((iter->start >= start + size) || (iter->end <= start))
			continue;

		__release_region(iter, start, size);
	}
2006
	release_mem_region(start, size);
2007
	up(&hyperv_mmio_lock);
2008 2009 2010 2011

}
EXPORT_SYMBOL_GPL(vmbus_free_mmio);

2012 2013 2014
static int vmbus_acpi_add(struct acpi_device *device)
{
	acpi_status result;
2015
	int ret_val = -ENODEV;
2016
	struct acpi_device *ancestor;
2017

2018 2019
	hv_acpi_dev = device;

2020
	result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
2021
					vmbus_walk_resources, NULL);
2022

2023 2024 2025
	if (ACPI_FAILURE(result))
		goto acpi_walk_err;
	/*
2026 2027
	 * Some ancestor of the vmbus acpi device (Gen1 or Gen2
	 * firmware) is the VMOD that has the mmio ranges. Get that.
2028
	 */
2029 2030 2031
	for (ancestor = device->parent; ancestor; ancestor = ancestor->parent) {
		result = acpi_walk_resources(ancestor->handle, METHOD_NAME__CRS,
					     vmbus_walk_resources, NULL);
2032 2033

		if (ACPI_FAILURE(result))
2034
			continue;
2035 2036
		if (hyperv_mmio) {
			vmbus_reserve_fb();
2037
			break;
2038
		}
2039
	}
2040 2041 2042
	ret_val = 0;

acpi_walk_err:
2043
	complete(&probe_event);
2044 2045
	if (ret_val)
		vmbus_acpi_remove(device);
2046
	return ret_val;
2047 2048 2049 2050
}

static const struct acpi_device_id vmbus_acpi_device_ids[] = {
	{"VMBUS", 0},
2051
	{"VMBus", 0},
2052 2053 2054 2055 2056 2057 2058 2059 2060
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);

static struct acpi_driver vmbus_acpi_driver = {
	.name = "vmbus",
	.ids = vmbus_acpi_device_ids,
	.ops = {
		.add = vmbus_acpi_add,
2061
		.remove = vmbus_acpi_remove,
2062 2063 2064
	},
};

2065 2066 2067
static void hv_kexec_handler(void)
{
	hv_synic_clockevents_cleanup();
2068
	vmbus_initiate_unload(false);
2069 2070 2071
	vmbus_connection.conn_state = DISCONNECTED;
	/* Make sure conn_state is set as hv_synic_cleanup checks for it */
	mb();
2072
	cpuhp_remove_state(hyperv_cpuhp_online);
2073
	hyperv_cleanup();
2074 2075
};

2076 2077
static void hv_crash_handler(struct pt_regs *regs)
{
2078
	vmbus_initiate_unload(true);
2079 2080 2081 2082 2083
	/*
	 * In crash handler we can't schedule synic cleanup for all CPUs,
	 * doing the cleanup for current CPU only. This should be sufficient
	 * for kdump.
	 */
2084
	vmbus_connection.conn_state = DISCONNECTED;
2085
	hv_synic_cleanup(smp_processor_id());
2086
	hyperv_cleanup();
2087 2088
};

2089
static int __init hv_acpi_init(void)
2090
{
2091
	int ret, t;
2092

2093
	if (!hv_is_hyperv_initialized())
2094 2095
		return -ENODEV;

2096 2097 2098
	init_completion(&probe_event);

	/*
2099
	 * Get ACPI resources first.
2100
	 */
2101 2102
	ret = acpi_bus_register_driver(&vmbus_acpi_driver);

2103 2104 2105
	if (ret)
		return ret;

2106 2107 2108 2109 2110
	t = wait_for_completion_timeout(&probe_event, 5*HZ);
	if (t == 0) {
		ret = -ETIMEDOUT;
		goto cleanup;
	}
2111

2112
	ret = vmbus_bus_init();
2113
	if (ret)
2114 2115
		goto cleanup;

2116
	hv_setup_kexec_handler(hv_kexec_handler);
2117
	hv_setup_crash_handler(hv_crash_handler);
2118

2119 2120 2121 2122
	return 0;

cleanup:
	acpi_bus_unregister_driver(&vmbus_acpi_driver);
2123
	hv_acpi_dev = NULL;
2124
	return ret;
2125 2126
}

2127 2128
static void __exit vmbus_exit(void)
{
2129 2130
	int cpu;

2131
	hv_remove_kexec_handler();
2132
	hv_remove_crash_handler();
2133
	vmbus_connection.conn_state = DISCONNECTED;
2134
	hv_synic_clockevents_cleanup();
2135
	vmbus_disconnect();
2136
	hv_remove_vmbus_irq();
2137 2138 2139 2140 2141 2142
	for_each_online_cpu(cpu) {
		struct hv_per_cpu_context *hv_cpu
			= per_cpu_ptr(hv_context.cpu_context, cpu);

		tasklet_kill(&hv_cpu->msg_dpc);
	}
2143
	vmbus_free_channels();
2144

2145
	if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
2146
		kmsg_dump_unregister(&hv_kmsg_dumper);
2147
		unregister_die_notifier(&hyperv_die_block);
2148 2149 2150
		atomic_notifier_chain_unregister(&panic_notifier_list,
						 &hyperv_panic_block);
	}
2151 2152

	free_page((unsigned long)hv_panic_page);
2153 2154
	unregister_sysctl_table(hv_ctl_table_hdr);
	hv_ctl_table_hdr = NULL;
2155
	bus_unregister(&hv_bus);
2156

2157
	cpuhp_remove_state(hyperv_cpuhp_online);
2158
	hv_synic_free();
2159 2160 2161
	acpi_bus_unregister_driver(&vmbus_acpi_driver);
}

2162

2163
MODULE_LICENSE("GPL");
2164

2165
subsys_initcall(hv_acpi_init);
2166
module_exit(vmbus_exit);