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