1 /* 2 * Copyright (c) 2009, Microsoft Corporation. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms and conditions of the GNU General Public License, 6 * version 2, as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope it will be useful, but WITHOUT 9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 11 * more details. 12 * 13 * You should have received a copy of the GNU General Public License along with 14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple 15 * Place - Suite 330, Boston, MA 02111-1307 USA. 16 * 17 * Authors: 18 * Haiyang Zhang <haiyangz@microsoft.com> 19 * Hank Janssen <hjanssen@microsoft.com> 20 * K. Y. Srinivasan <kys@microsoft.com> 21 * 22 */ 23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 24 25 #include <linux/init.h> 26 #include <linux/module.h> 27 #include <linux/device.h> 28 #include <linux/interrupt.h> 29 #include <linux/sysctl.h> 30 #include <linux/slab.h> 31 #include <linux/acpi.h> 32 #include <linux/completion.h> 33 #include <linux/hyperv.h> 34 #include <linux/kernel_stat.h> 35 #include <linux/clockchips.h> 36 #include <linux/cpu.h> 37 #include <linux/sched/task_stack.h> 38 39 #include <asm/hyperv.h> 40 #include <asm/hypervisor.h> 41 #include <asm/mshyperv.h> 42 #include <linux/notifier.h> 43 #include <linux/ptrace.h> 44 #include <linux/screen_info.h> 45 #include <linux/kdebug.h> 46 #include <linux/efi.h> 47 #include <linux/random.h> 48 #include "hyperv_vmbus.h" 49 50 struct vmbus_dynid { 51 struct list_head node; 52 struct hv_vmbus_device_id id; 53 }; 54 55 static struct acpi_device *hv_acpi_dev; 56 57 static struct completion probe_event; 58 59 static int hyperv_cpuhp_online; 60 61 static int hyperv_panic_event(struct notifier_block *nb, unsigned long val, 62 void *args) 63 { 64 struct pt_regs *regs; 65 66 regs = current_pt_regs(); 67 68 hyperv_report_panic(regs); 69 return NOTIFY_DONE; 70 } 71 72 static int hyperv_die_event(struct notifier_block *nb, unsigned long val, 73 void *args) 74 { 75 struct die_args *die = (struct die_args *)args; 76 struct pt_regs *regs = die->regs; 77 78 hyperv_report_panic(regs); 79 return NOTIFY_DONE; 80 } 81 82 static struct notifier_block hyperv_die_block = { 83 .notifier_call = hyperv_die_event, 84 }; 85 static struct notifier_block hyperv_panic_block = { 86 .notifier_call = hyperv_panic_event, 87 }; 88 89 static const char *fb_mmio_name = "fb_range"; 90 static struct resource *fb_mmio; 91 static struct resource *hyperv_mmio; 92 static DEFINE_SEMAPHORE(hyperv_mmio_lock); 93 94 static int vmbus_exists(void) 95 { 96 if (hv_acpi_dev == NULL) 97 return -ENODEV; 98 99 return 0; 100 } 101 102 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2) 103 static void print_alias_name(struct hv_device *hv_dev, char *alias_name) 104 { 105 int i; 106 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2) 107 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]); 108 } 109 110 static u8 channel_monitor_group(struct vmbus_channel *channel) 111 { 112 return (u8)channel->offermsg.monitorid / 32; 113 } 114 115 static u8 channel_monitor_offset(struct vmbus_channel *channel) 116 { 117 return (u8)channel->offermsg.monitorid % 32; 118 } 119 120 static u32 channel_pending(struct vmbus_channel *channel, 121 struct hv_monitor_page *monitor_page) 122 { 123 u8 monitor_group = channel_monitor_group(channel); 124 return monitor_page->trigger_group[monitor_group].pending; 125 } 126 127 static u32 channel_latency(struct vmbus_channel *channel, 128 struct hv_monitor_page *monitor_page) 129 { 130 u8 monitor_group = channel_monitor_group(channel); 131 u8 monitor_offset = channel_monitor_offset(channel); 132 return monitor_page->latency[monitor_group][monitor_offset]; 133 } 134 135 static u32 channel_conn_id(struct vmbus_channel *channel, 136 struct hv_monitor_page *monitor_page) 137 { 138 u8 monitor_group = channel_monitor_group(channel); 139 u8 monitor_offset = channel_monitor_offset(channel); 140 return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id; 141 } 142 143 static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr, 144 char *buf) 145 { 146 struct hv_device *hv_dev = device_to_hv_device(dev); 147 148 if (!hv_dev->channel) 149 return -ENODEV; 150 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid); 151 } 152 static DEVICE_ATTR_RO(id); 153 154 static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr, 155 char *buf) 156 { 157 struct hv_device *hv_dev = device_to_hv_device(dev); 158 159 if (!hv_dev->channel) 160 return -ENODEV; 161 return sprintf(buf, "%d\n", hv_dev->channel->state); 162 } 163 static DEVICE_ATTR_RO(state); 164 165 static ssize_t monitor_id_show(struct device *dev, 166 struct device_attribute *dev_attr, char *buf) 167 { 168 struct hv_device *hv_dev = device_to_hv_device(dev); 169 170 if (!hv_dev->channel) 171 return -ENODEV; 172 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid); 173 } 174 static DEVICE_ATTR_RO(monitor_id); 175 176 static ssize_t class_id_show(struct device *dev, 177 struct device_attribute *dev_attr, char *buf) 178 { 179 struct hv_device *hv_dev = device_to_hv_device(dev); 180 181 if (!hv_dev->channel) 182 return -ENODEV; 183 return sprintf(buf, "{%pUl}\n", 184 hv_dev->channel->offermsg.offer.if_type.b); 185 } 186 static DEVICE_ATTR_RO(class_id); 187 188 static ssize_t device_id_show(struct device *dev, 189 struct device_attribute *dev_attr, char *buf) 190 { 191 struct hv_device *hv_dev = device_to_hv_device(dev); 192 193 if (!hv_dev->channel) 194 return -ENODEV; 195 return sprintf(buf, "{%pUl}\n", 196 hv_dev->channel->offermsg.offer.if_instance.b); 197 } 198 static DEVICE_ATTR_RO(device_id); 199 200 static ssize_t modalias_show(struct device *dev, 201 struct device_attribute *dev_attr, char *buf) 202 { 203 struct hv_device *hv_dev = device_to_hv_device(dev); 204 char alias_name[VMBUS_ALIAS_LEN + 1]; 205 206 print_alias_name(hv_dev, alias_name); 207 return sprintf(buf, "vmbus:%s\n", alias_name); 208 } 209 static DEVICE_ATTR_RO(modalias); 210 211 static ssize_t server_monitor_pending_show(struct device *dev, 212 struct device_attribute *dev_attr, 213 char *buf) 214 { 215 struct hv_device *hv_dev = device_to_hv_device(dev); 216 217 if (!hv_dev->channel) 218 return -ENODEV; 219 return sprintf(buf, "%d\n", 220 channel_pending(hv_dev->channel, 221 vmbus_connection.monitor_pages[1])); 222 } 223 static DEVICE_ATTR_RO(server_monitor_pending); 224 225 static ssize_t client_monitor_pending_show(struct device *dev, 226 struct device_attribute *dev_attr, 227 char *buf) 228 { 229 struct hv_device *hv_dev = device_to_hv_device(dev); 230 231 if (!hv_dev->channel) 232 return -ENODEV; 233 return sprintf(buf, "%d\n", 234 channel_pending(hv_dev->channel, 235 vmbus_connection.monitor_pages[1])); 236 } 237 static DEVICE_ATTR_RO(client_monitor_pending); 238 239 static ssize_t server_monitor_latency_show(struct device *dev, 240 struct device_attribute *dev_attr, 241 char *buf) 242 { 243 struct hv_device *hv_dev = device_to_hv_device(dev); 244 245 if (!hv_dev->channel) 246 return -ENODEV; 247 return sprintf(buf, "%d\n", 248 channel_latency(hv_dev->channel, 249 vmbus_connection.monitor_pages[0])); 250 } 251 static DEVICE_ATTR_RO(server_monitor_latency); 252 253 static ssize_t client_monitor_latency_show(struct device *dev, 254 struct device_attribute *dev_attr, 255 char *buf) 256 { 257 struct hv_device *hv_dev = device_to_hv_device(dev); 258 259 if (!hv_dev->channel) 260 return -ENODEV; 261 return sprintf(buf, "%d\n", 262 channel_latency(hv_dev->channel, 263 vmbus_connection.monitor_pages[1])); 264 } 265 static DEVICE_ATTR_RO(client_monitor_latency); 266 267 static ssize_t server_monitor_conn_id_show(struct device *dev, 268 struct device_attribute *dev_attr, 269 char *buf) 270 { 271 struct hv_device *hv_dev = device_to_hv_device(dev); 272 273 if (!hv_dev->channel) 274 return -ENODEV; 275 return sprintf(buf, "%d\n", 276 channel_conn_id(hv_dev->channel, 277 vmbus_connection.monitor_pages[0])); 278 } 279 static DEVICE_ATTR_RO(server_monitor_conn_id); 280 281 static ssize_t client_monitor_conn_id_show(struct device *dev, 282 struct device_attribute *dev_attr, 283 char *buf) 284 { 285 struct hv_device *hv_dev = device_to_hv_device(dev); 286 287 if (!hv_dev->channel) 288 return -ENODEV; 289 return sprintf(buf, "%d\n", 290 channel_conn_id(hv_dev->channel, 291 vmbus_connection.monitor_pages[1])); 292 } 293 static DEVICE_ATTR_RO(client_monitor_conn_id); 294 295 static ssize_t out_intr_mask_show(struct device *dev, 296 struct device_attribute *dev_attr, char *buf) 297 { 298 struct hv_device *hv_dev = device_to_hv_device(dev); 299 struct hv_ring_buffer_debug_info outbound; 300 301 if (!hv_dev->channel) 302 return -ENODEV; 303 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 304 return sprintf(buf, "%d\n", outbound.current_interrupt_mask); 305 } 306 static DEVICE_ATTR_RO(out_intr_mask); 307 308 static ssize_t out_read_index_show(struct device *dev, 309 struct device_attribute *dev_attr, char *buf) 310 { 311 struct hv_device *hv_dev = device_to_hv_device(dev); 312 struct hv_ring_buffer_debug_info outbound; 313 314 if (!hv_dev->channel) 315 return -ENODEV; 316 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 317 return sprintf(buf, "%d\n", outbound.current_read_index); 318 } 319 static DEVICE_ATTR_RO(out_read_index); 320 321 static ssize_t out_write_index_show(struct device *dev, 322 struct device_attribute *dev_attr, 323 char *buf) 324 { 325 struct hv_device *hv_dev = device_to_hv_device(dev); 326 struct hv_ring_buffer_debug_info outbound; 327 328 if (!hv_dev->channel) 329 return -ENODEV; 330 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 331 return sprintf(buf, "%d\n", outbound.current_write_index); 332 } 333 static DEVICE_ATTR_RO(out_write_index); 334 335 static ssize_t out_read_bytes_avail_show(struct device *dev, 336 struct device_attribute *dev_attr, 337 char *buf) 338 { 339 struct hv_device *hv_dev = device_to_hv_device(dev); 340 struct hv_ring_buffer_debug_info outbound; 341 342 if (!hv_dev->channel) 343 return -ENODEV; 344 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 345 return sprintf(buf, "%d\n", outbound.bytes_avail_toread); 346 } 347 static DEVICE_ATTR_RO(out_read_bytes_avail); 348 349 static ssize_t out_write_bytes_avail_show(struct device *dev, 350 struct device_attribute *dev_attr, 351 char *buf) 352 { 353 struct hv_device *hv_dev = device_to_hv_device(dev); 354 struct hv_ring_buffer_debug_info outbound; 355 356 if (!hv_dev->channel) 357 return -ENODEV; 358 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 359 return sprintf(buf, "%d\n", outbound.bytes_avail_towrite); 360 } 361 static DEVICE_ATTR_RO(out_write_bytes_avail); 362 363 static ssize_t in_intr_mask_show(struct device *dev, 364 struct device_attribute *dev_attr, char *buf) 365 { 366 struct hv_device *hv_dev = device_to_hv_device(dev); 367 struct hv_ring_buffer_debug_info inbound; 368 369 if (!hv_dev->channel) 370 return -ENODEV; 371 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 372 return sprintf(buf, "%d\n", inbound.current_interrupt_mask); 373 } 374 static DEVICE_ATTR_RO(in_intr_mask); 375 376 static ssize_t in_read_index_show(struct device *dev, 377 struct device_attribute *dev_attr, char *buf) 378 { 379 struct hv_device *hv_dev = device_to_hv_device(dev); 380 struct hv_ring_buffer_debug_info inbound; 381 382 if (!hv_dev->channel) 383 return -ENODEV; 384 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 385 return sprintf(buf, "%d\n", inbound.current_read_index); 386 } 387 static DEVICE_ATTR_RO(in_read_index); 388 389 static ssize_t in_write_index_show(struct device *dev, 390 struct device_attribute *dev_attr, char *buf) 391 { 392 struct hv_device *hv_dev = device_to_hv_device(dev); 393 struct hv_ring_buffer_debug_info inbound; 394 395 if (!hv_dev->channel) 396 return -ENODEV; 397 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 398 return sprintf(buf, "%d\n", inbound.current_write_index); 399 } 400 static DEVICE_ATTR_RO(in_write_index); 401 402 static ssize_t in_read_bytes_avail_show(struct device *dev, 403 struct device_attribute *dev_attr, 404 char *buf) 405 { 406 struct hv_device *hv_dev = device_to_hv_device(dev); 407 struct hv_ring_buffer_debug_info inbound; 408 409 if (!hv_dev->channel) 410 return -ENODEV; 411 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 412 return sprintf(buf, "%d\n", inbound.bytes_avail_toread); 413 } 414 static DEVICE_ATTR_RO(in_read_bytes_avail); 415 416 static ssize_t in_write_bytes_avail_show(struct device *dev, 417 struct device_attribute *dev_attr, 418 char *buf) 419 { 420 struct hv_device *hv_dev = device_to_hv_device(dev); 421 struct hv_ring_buffer_debug_info inbound; 422 423 if (!hv_dev->channel) 424 return -ENODEV; 425 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 426 return sprintf(buf, "%d\n", inbound.bytes_avail_towrite); 427 } 428 static DEVICE_ATTR_RO(in_write_bytes_avail); 429 430 static ssize_t channel_vp_mapping_show(struct device *dev, 431 struct device_attribute *dev_attr, 432 char *buf) 433 { 434 struct hv_device *hv_dev = device_to_hv_device(dev); 435 struct vmbus_channel *channel = hv_dev->channel, *cur_sc; 436 unsigned long flags; 437 int buf_size = PAGE_SIZE, n_written, tot_written; 438 struct list_head *cur; 439 440 if (!channel) 441 return -ENODEV; 442 443 tot_written = snprintf(buf, buf_size, "%u:%u\n", 444 channel->offermsg.child_relid, channel->target_cpu); 445 446 spin_lock_irqsave(&channel->lock, flags); 447 448 list_for_each(cur, &channel->sc_list) { 449 if (tot_written >= buf_size - 1) 450 break; 451 452 cur_sc = list_entry(cur, struct vmbus_channel, sc_list); 453 n_written = scnprintf(buf + tot_written, 454 buf_size - tot_written, 455 "%u:%u\n", 456 cur_sc->offermsg.child_relid, 457 cur_sc->target_cpu); 458 tot_written += n_written; 459 } 460 461 spin_unlock_irqrestore(&channel->lock, flags); 462 463 return tot_written; 464 } 465 static DEVICE_ATTR_RO(channel_vp_mapping); 466 467 static ssize_t vendor_show(struct device *dev, 468 struct device_attribute *dev_attr, 469 char *buf) 470 { 471 struct hv_device *hv_dev = device_to_hv_device(dev); 472 return sprintf(buf, "0x%x\n", hv_dev->vendor_id); 473 } 474 static DEVICE_ATTR_RO(vendor); 475 476 static ssize_t device_show(struct device *dev, 477 struct device_attribute *dev_attr, 478 char *buf) 479 { 480 struct hv_device *hv_dev = device_to_hv_device(dev); 481 return sprintf(buf, "0x%x\n", hv_dev->device_id); 482 } 483 static DEVICE_ATTR_RO(device); 484 485 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */ 486 static struct attribute *vmbus_dev_attrs[] = { 487 &dev_attr_id.attr, 488 &dev_attr_state.attr, 489 &dev_attr_monitor_id.attr, 490 &dev_attr_class_id.attr, 491 &dev_attr_device_id.attr, 492 &dev_attr_modalias.attr, 493 &dev_attr_server_monitor_pending.attr, 494 &dev_attr_client_monitor_pending.attr, 495 &dev_attr_server_monitor_latency.attr, 496 &dev_attr_client_monitor_latency.attr, 497 &dev_attr_server_monitor_conn_id.attr, 498 &dev_attr_client_monitor_conn_id.attr, 499 &dev_attr_out_intr_mask.attr, 500 &dev_attr_out_read_index.attr, 501 &dev_attr_out_write_index.attr, 502 &dev_attr_out_read_bytes_avail.attr, 503 &dev_attr_out_write_bytes_avail.attr, 504 &dev_attr_in_intr_mask.attr, 505 &dev_attr_in_read_index.attr, 506 &dev_attr_in_write_index.attr, 507 &dev_attr_in_read_bytes_avail.attr, 508 &dev_attr_in_write_bytes_avail.attr, 509 &dev_attr_channel_vp_mapping.attr, 510 &dev_attr_vendor.attr, 511 &dev_attr_device.attr, 512 NULL, 513 }; 514 ATTRIBUTE_GROUPS(vmbus_dev); 515 516 /* 517 * vmbus_uevent - add uevent for our device 518 * 519 * This routine is invoked when a device is added or removed on the vmbus to 520 * generate a uevent to udev in the userspace. The udev will then look at its 521 * rule and the uevent generated here to load the appropriate driver 522 * 523 * The alias string will be of the form vmbus:guid where guid is the string 524 * representation of the device guid (each byte of the guid will be 525 * represented with two hex characters. 526 */ 527 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env) 528 { 529 struct hv_device *dev = device_to_hv_device(device); 530 int ret; 531 char alias_name[VMBUS_ALIAS_LEN + 1]; 532 533 print_alias_name(dev, alias_name); 534 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name); 535 return ret; 536 } 537 538 static const uuid_le null_guid; 539 540 static inline bool is_null_guid(const uuid_le *guid) 541 { 542 if (uuid_le_cmp(*guid, null_guid)) 543 return false; 544 return true; 545 } 546 547 /* 548 * Return a matching hv_vmbus_device_id pointer. 549 * If there is no match, return NULL. 550 */ 551 static const struct hv_vmbus_device_id *hv_vmbus_get_id(struct hv_driver *drv, 552 const uuid_le *guid) 553 { 554 const struct hv_vmbus_device_id *id = NULL; 555 struct vmbus_dynid *dynid; 556 557 /* Look at the dynamic ids first, before the static ones */ 558 spin_lock(&drv->dynids.lock); 559 list_for_each_entry(dynid, &drv->dynids.list, node) { 560 if (!uuid_le_cmp(dynid->id.guid, *guid)) { 561 id = &dynid->id; 562 break; 563 } 564 } 565 spin_unlock(&drv->dynids.lock); 566 567 if (id) 568 return id; 569 570 id = drv->id_table; 571 if (id == NULL) 572 return NULL; /* empty device table */ 573 574 for (; !is_null_guid(&id->guid); id++) 575 if (!uuid_le_cmp(id->guid, *guid)) 576 return id; 577 578 return NULL; 579 } 580 581 /* vmbus_add_dynid - add a new device ID to this driver and re-probe devices */ 582 static int vmbus_add_dynid(struct hv_driver *drv, uuid_le *guid) 583 { 584 struct vmbus_dynid *dynid; 585 586 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL); 587 if (!dynid) 588 return -ENOMEM; 589 590 dynid->id.guid = *guid; 591 592 spin_lock(&drv->dynids.lock); 593 list_add_tail(&dynid->node, &drv->dynids.list); 594 spin_unlock(&drv->dynids.lock); 595 596 return driver_attach(&drv->driver); 597 } 598 599 static void vmbus_free_dynids(struct hv_driver *drv) 600 { 601 struct vmbus_dynid *dynid, *n; 602 603 spin_lock(&drv->dynids.lock); 604 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) { 605 list_del(&dynid->node); 606 kfree(dynid); 607 } 608 spin_unlock(&drv->dynids.lock); 609 } 610 611 /* Parse string of form: 1b4e28ba-2fa1-11d2-883f-b9a761bde3f */ 612 static int get_uuid_le(const char *str, uuid_le *uu) 613 { 614 unsigned int b[16]; 615 int i; 616 617 if (strlen(str) < 37) 618 return -1; 619 620 for (i = 0; i < 36; i++) { 621 switch (i) { 622 case 8: case 13: case 18: case 23: 623 if (str[i] != '-') 624 return -1; 625 break; 626 default: 627 if (!isxdigit(str[i])) 628 return -1; 629 } 630 } 631 632 /* unparse little endian output byte order */ 633 if (sscanf(str, 634 "%2x%2x%2x%2x-%2x%2x-%2x%2x-%2x%2x-%2x%2x%2x%2x%2x%2x", 635 &b[3], &b[2], &b[1], &b[0], 636 &b[5], &b[4], &b[7], &b[6], &b[8], &b[9], 637 &b[10], &b[11], &b[12], &b[13], &b[14], &b[15]) != 16) 638 return -1; 639 640 for (i = 0; i < 16; i++) 641 uu->b[i] = b[i]; 642 return 0; 643 } 644 645 /* 646 * store_new_id - sysfs frontend to vmbus_add_dynid() 647 * 648 * Allow GUIDs to be added to an existing driver via sysfs. 649 */ 650 static ssize_t new_id_store(struct device_driver *driver, const char *buf, 651 size_t count) 652 { 653 struct hv_driver *drv = drv_to_hv_drv(driver); 654 uuid_le guid = NULL_UUID_LE; 655 ssize_t retval; 656 657 if (get_uuid_le(buf, &guid) != 0) 658 return -EINVAL; 659 660 if (hv_vmbus_get_id(drv, &guid)) 661 return -EEXIST; 662 663 retval = vmbus_add_dynid(drv, &guid); 664 if (retval) 665 return retval; 666 return count; 667 } 668 static DRIVER_ATTR_WO(new_id); 669 670 /* 671 * store_remove_id - remove a PCI device ID from this driver 672 * 673 * Removes a dynamic pci device ID to this driver. 674 */ 675 static ssize_t remove_id_store(struct device_driver *driver, const char *buf, 676 size_t count) 677 { 678 struct hv_driver *drv = drv_to_hv_drv(driver); 679 struct vmbus_dynid *dynid, *n; 680 uuid_le guid = NULL_UUID_LE; 681 size_t retval = -ENODEV; 682 683 if (get_uuid_le(buf, &guid)) 684 return -EINVAL; 685 686 spin_lock(&drv->dynids.lock); 687 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) { 688 struct hv_vmbus_device_id *id = &dynid->id; 689 690 if (!uuid_le_cmp(id->guid, guid)) { 691 list_del(&dynid->node); 692 kfree(dynid); 693 retval = count; 694 break; 695 } 696 } 697 spin_unlock(&drv->dynids.lock); 698 699 return retval; 700 } 701 static DRIVER_ATTR_WO(remove_id); 702 703 static struct attribute *vmbus_drv_attrs[] = { 704 &driver_attr_new_id.attr, 705 &driver_attr_remove_id.attr, 706 NULL, 707 }; 708 ATTRIBUTE_GROUPS(vmbus_drv); 709 710 711 /* 712 * vmbus_match - Attempt to match the specified device to the specified driver 713 */ 714 static int vmbus_match(struct device *device, struct device_driver *driver) 715 { 716 struct hv_driver *drv = drv_to_hv_drv(driver); 717 struct hv_device *hv_dev = device_to_hv_device(device); 718 719 /* The hv_sock driver handles all hv_sock offers. */ 720 if (is_hvsock_channel(hv_dev->channel)) 721 return drv->hvsock; 722 723 if (hv_vmbus_get_id(drv, &hv_dev->dev_type)) 724 return 1; 725 726 return 0; 727 } 728 729 /* 730 * vmbus_probe - Add the new vmbus's child device 731 */ 732 static int vmbus_probe(struct device *child_device) 733 { 734 int ret = 0; 735 struct hv_driver *drv = 736 drv_to_hv_drv(child_device->driver); 737 struct hv_device *dev = device_to_hv_device(child_device); 738 const struct hv_vmbus_device_id *dev_id; 739 740 dev_id = hv_vmbus_get_id(drv, &dev->dev_type); 741 if (drv->probe) { 742 ret = drv->probe(dev, dev_id); 743 if (ret != 0) 744 pr_err("probe failed for device %s (%d)\n", 745 dev_name(child_device), ret); 746 747 } else { 748 pr_err("probe not set for driver %s\n", 749 dev_name(child_device)); 750 ret = -ENODEV; 751 } 752 return ret; 753 } 754 755 /* 756 * vmbus_remove - Remove a vmbus device 757 */ 758 static int vmbus_remove(struct device *child_device) 759 { 760 struct hv_driver *drv; 761 struct hv_device *dev = device_to_hv_device(child_device); 762 763 if (child_device->driver) { 764 drv = drv_to_hv_drv(child_device->driver); 765 if (drv->remove) 766 drv->remove(dev); 767 } 768 769 return 0; 770 } 771 772 773 /* 774 * vmbus_shutdown - Shutdown a vmbus device 775 */ 776 static void vmbus_shutdown(struct device *child_device) 777 { 778 struct hv_driver *drv; 779 struct hv_device *dev = device_to_hv_device(child_device); 780 781 782 /* The device may not be attached yet */ 783 if (!child_device->driver) 784 return; 785 786 drv = drv_to_hv_drv(child_device->driver); 787 788 if (drv->shutdown) 789 drv->shutdown(dev); 790 } 791 792 793 /* 794 * vmbus_device_release - Final callback release of the vmbus child device 795 */ 796 static void vmbus_device_release(struct device *device) 797 { 798 struct hv_device *hv_dev = device_to_hv_device(device); 799 struct vmbus_channel *channel = hv_dev->channel; 800 801 hv_process_channel_removal(channel, 802 channel->offermsg.child_relid); 803 kfree(hv_dev); 804 805 } 806 807 /* The one and only one */ 808 static struct bus_type hv_bus = { 809 .name = "vmbus", 810 .match = vmbus_match, 811 .shutdown = vmbus_shutdown, 812 .remove = vmbus_remove, 813 .probe = vmbus_probe, 814 .uevent = vmbus_uevent, 815 .dev_groups = vmbus_dev_groups, 816 .drv_groups = vmbus_drv_groups, 817 }; 818 819 struct onmessage_work_context { 820 struct work_struct work; 821 struct hv_message msg; 822 }; 823 824 static void vmbus_onmessage_work(struct work_struct *work) 825 { 826 struct onmessage_work_context *ctx; 827 828 /* Do not process messages if we're in DISCONNECTED state */ 829 if (vmbus_connection.conn_state == DISCONNECTED) 830 return; 831 832 ctx = container_of(work, struct onmessage_work_context, 833 work); 834 vmbus_onmessage(&ctx->msg); 835 kfree(ctx); 836 } 837 838 static void hv_process_timer_expiration(struct hv_message *msg, 839 struct hv_per_cpu_context *hv_cpu) 840 { 841 struct clock_event_device *dev = hv_cpu->clk_evt; 842 843 if (dev->event_handler) 844 dev->event_handler(dev); 845 846 vmbus_signal_eom(msg, HVMSG_TIMER_EXPIRED); 847 } 848 849 void vmbus_on_msg_dpc(unsigned long data) 850 { 851 struct hv_per_cpu_context *hv_cpu = (void *)data; 852 void *page_addr = hv_cpu->synic_message_page; 853 struct hv_message *msg = (struct hv_message *)page_addr + 854 VMBUS_MESSAGE_SINT; 855 struct vmbus_channel_message_header *hdr; 856 const struct vmbus_channel_message_table_entry *entry; 857 struct onmessage_work_context *ctx; 858 u32 message_type = msg->header.message_type; 859 860 if (message_type == HVMSG_NONE) 861 /* no msg */ 862 return; 863 864 hdr = (struct vmbus_channel_message_header *)msg->u.payload; 865 866 if (hdr->msgtype >= CHANNELMSG_COUNT) { 867 WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype); 868 goto msg_handled; 869 } 870 871 entry = &channel_message_table[hdr->msgtype]; 872 if (entry->handler_type == VMHT_BLOCKING) { 873 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC); 874 if (ctx == NULL) 875 return; 876 877 INIT_WORK(&ctx->work, vmbus_onmessage_work); 878 memcpy(&ctx->msg, msg, sizeof(*msg)); 879 880 queue_work(vmbus_connection.work_queue, &ctx->work); 881 } else 882 entry->message_handler(hdr); 883 884 msg_handled: 885 vmbus_signal_eom(msg, message_type); 886 } 887 888 889 /* 890 * Direct callback for channels using other deferred processing 891 */ 892 static void vmbus_channel_isr(struct vmbus_channel *channel) 893 { 894 void (*callback_fn)(void *); 895 896 callback_fn = READ_ONCE(channel->onchannel_callback); 897 if (likely(callback_fn != NULL)) 898 (*callback_fn)(channel->channel_callback_context); 899 } 900 901 /* 902 * Schedule all channels with events pending 903 */ 904 static void vmbus_chan_sched(struct hv_per_cpu_context *hv_cpu) 905 { 906 unsigned long *recv_int_page; 907 u32 maxbits, relid; 908 909 if (vmbus_proto_version < VERSION_WIN8) { 910 maxbits = MAX_NUM_CHANNELS_SUPPORTED; 911 recv_int_page = vmbus_connection.recv_int_page; 912 } else { 913 /* 914 * When the host is win8 and beyond, the event page 915 * can be directly checked to get the id of the channel 916 * that has the interrupt pending. 917 */ 918 void *page_addr = hv_cpu->synic_event_page; 919 union hv_synic_event_flags *event 920 = (union hv_synic_event_flags *)page_addr + 921 VMBUS_MESSAGE_SINT; 922 923 maxbits = HV_EVENT_FLAGS_COUNT; 924 recv_int_page = event->flags; 925 } 926 927 if (unlikely(!recv_int_page)) 928 return; 929 930 for_each_set_bit(relid, recv_int_page, maxbits) { 931 struct vmbus_channel *channel; 932 933 if (!sync_test_and_clear_bit(relid, recv_int_page)) 934 continue; 935 936 /* Special case - vmbus channel protocol msg */ 937 if (relid == 0) 938 continue; 939 940 rcu_read_lock(); 941 942 /* Find channel based on relid */ 943 list_for_each_entry_rcu(channel, &hv_cpu->chan_list, percpu_list) { 944 if (channel->offermsg.child_relid != relid) 945 continue; 946 947 switch (channel->callback_mode) { 948 case HV_CALL_ISR: 949 vmbus_channel_isr(channel); 950 break; 951 952 case HV_CALL_BATCHED: 953 hv_begin_read(&channel->inbound); 954 /* fallthrough */ 955 case HV_CALL_DIRECT: 956 tasklet_schedule(&channel->callback_event); 957 } 958 } 959 960 rcu_read_unlock(); 961 } 962 } 963 964 static void vmbus_isr(void) 965 { 966 struct hv_per_cpu_context *hv_cpu 967 = this_cpu_ptr(hv_context.cpu_context); 968 void *page_addr = hv_cpu->synic_event_page; 969 struct hv_message *msg; 970 union hv_synic_event_flags *event; 971 bool handled = false; 972 973 if (unlikely(page_addr == NULL)) 974 return; 975 976 event = (union hv_synic_event_flags *)page_addr + 977 VMBUS_MESSAGE_SINT; 978 /* 979 * Check for events before checking for messages. This is the order 980 * in which events and messages are checked in Windows guests on 981 * Hyper-V, and the Windows team suggested we do the same. 982 */ 983 984 if ((vmbus_proto_version == VERSION_WS2008) || 985 (vmbus_proto_version == VERSION_WIN7)) { 986 987 /* Since we are a child, we only need to check bit 0 */ 988 if (sync_test_and_clear_bit(0, event->flags)) 989 handled = true; 990 } else { 991 /* 992 * Our host is win8 or above. The signaling mechanism 993 * has changed and we can directly look at the event page. 994 * If bit n is set then we have an interrup on the channel 995 * whose id is n. 996 */ 997 handled = true; 998 } 999 1000 if (handled) 1001 vmbus_chan_sched(hv_cpu); 1002 1003 page_addr = hv_cpu->synic_message_page; 1004 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT; 1005 1006 /* Check if there are actual msgs to be processed */ 1007 if (msg->header.message_type != HVMSG_NONE) { 1008 if (msg->header.message_type == HVMSG_TIMER_EXPIRED) 1009 hv_process_timer_expiration(msg, hv_cpu); 1010 else 1011 tasklet_schedule(&hv_cpu->msg_dpc); 1012 } 1013 1014 add_interrupt_randomness(HYPERVISOR_CALLBACK_VECTOR, 0); 1015 } 1016 1017 1018 /* 1019 * vmbus_bus_init -Main vmbus driver initialization routine. 1020 * 1021 * Here, we 1022 * - initialize the vmbus driver context 1023 * - invoke the vmbus hv main init routine 1024 * - retrieve the channel offers 1025 */ 1026 static int vmbus_bus_init(void) 1027 { 1028 int ret; 1029 1030 /* Hypervisor initialization...setup hypercall page..etc */ 1031 ret = hv_init(); 1032 if (ret != 0) { 1033 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret); 1034 return ret; 1035 } 1036 1037 ret = bus_register(&hv_bus); 1038 if (ret) 1039 return ret; 1040 1041 hv_setup_vmbus_irq(vmbus_isr); 1042 1043 ret = hv_synic_alloc(); 1044 if (ret) 1045 goto err_alloc; 1046 /* 1047 * Initialize the per-cpu interrupt state and 1048 * connect to the host. 1049 */ 1050 ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "x86/hyperv:online", 1051 hv_synic_init, hv_synic_cleanup); 1052 if (ret < 0) 1053 goto err_alloc; 1054 hyperv_cpuhp_online = ret; 1055 1056 ret = vmbus_connect(); 1057 if (ret) 1058 goto err_connect; 1059 1060 /* 1061 * Only register if the crash MSRs are available 1062 */ 1063 if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) { 1064 register_die_notifier(&hyperv_die_block); 1065 atomic_notifier_chain_register(&panic_notifier_list, 1066 &hyperv_panic_block); 1067 } 1068 1069 vmbus_request_offers(); 1070 1071 return 0; 1072 1073 err_connect: 1074 cpuhp_remove_state(hyperv_cpuhp_online); 1075 err_alloc: 1076 hv_synic_free(); 1077 hv_remove_vmbus_irq(); 1078 1079 bus_unregister(&hv_bus); 1080 1081 return ret; 1082 } 1083 1084 /** 1085 * __vmbus_child_driver_register() - Register a vmbus's driver 1086 * @hv_driver: Pointer to driver structure you want to register 1087 * @owner: owner module of the drv 1088 * @mod_name: module name string 1089 * 1090 * Registers the given driver with Linux through the 'driver_register()' call 1091 * and sets up the hyper-v vmbus handling for this driver. 1092 * It will return the state of the 'driver_register()' call. 1093 * 1094 */ 1095 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name) 1096 { 1097 int ret; 1098 1099 pr_info("registering driver %s\n", hv_driver->name); 1100 1101 ret = vmbus_exists(); 1102 if (ret < 0) 1103 return ret; 1104 1105 hv_driver->driver.name = hv_driver->name; 1106 hv_driver->driver.owner = owner; 1107 hv_driver->driver.mod_name = mod_name; 1108 hv_driver->driver.bus = &hv_bus; 1109 1110 spin_lock_init(&hv_driver->dynids.lock); 1111 INIT_LIST_HEAD(&hv_driver->dynids.list); 1112 1113 ret = driver_register(&hv_driver->driver); 1114 1115 return ret; 1116 } 1117 EXPORT_SYMBOL_GPL(__vmbus_driver_register); 1118 1119 /** 1120 * vmbus_driver_unregister() - Unregister a vmbus's driver 1121 * @hv_driver: Pointer to driver structure you want to 1122 * un-register 1123 * 1124 * Un-register the given driver that was previous registered with a call to 1125 * vmbus_driver_register() 1126 */ 1127 void vmbus_driver_unregister(struct hv_driver *hv_driver) 1128 { 1129 pr_info("unregistering driver %s\n", hv_driver->name); 1130 1131 if (!vmbus_exists()) { 1132 driver_unregister(&hv_driver->driver); 1133 vmbus_free_dynids(hv_driver); 1134 } 1135 } 1136 EXPORT_SYMBOL_GPL(vmbus_driver_unregister); 1137 1138 /* 1139 * vmbus_device_create - Creates and registers a new child device 1140 * on the vmbus. 1141 */ 1142 struct hv_device *vmbus_device_create(const uuid_le *type, 1143 const uuid_le *instance, 1144 struct vmbus_channel *channel) 1145 { 1146 struct hv_device *child_device_obj; 1147 1148 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL); 1149 if (!child_device_obj) { 1150 pr_err("Unable to allocate device object for child device\n"); 1151 return NULL; 1152 } 1153 1154 child_device_obj->channel = channel; 1155 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le)); 1156 memcpy(&child_device_obj->dev_instance, instance, 1157 sizeof(uuid_le)); 1158 child_device_obj->vendor_id = 0x1414; /* MSFT vendor ID */ 1159 1160 1161 return child_device_obj; 1162 } 1163 1164 /* 1165 * vmbus_device_register - Register the child device 1166 */ 1167 int vmbus_device_register(struct hv_device *child_device_obj) 1168 { 1169 int ret = 0; 1170 1171 dev_set_name(&child_device_obj->device, "%pUl", 1172 child_device_obj->channel->offermsg.offer.if_instance.b); 1173 1174 child_device_obj->device.bus = &hv_bus; 1175 child_device_obj->device.parent = &hv_acpi_dev->dev; 1176 child_device_obj->device.release = vmbus_device_release; 1177 1178 /* 1179 * Register with the LDM. This will kick off the driver/device 1180 * binding...which will eventually call vmbus_match() and vmbus_probe() 1181 */ 1182 ret = device_register(&child_device_obj->device); 1183 1184 if (ret) 1185 pr_err("Unable to register child device\n"); 1186 else 1187 pr_debug("child device %s registered\n", 1188 dev_name(&child_device_obj->device)); 1189 1190 return ret; 1191 } 1192 1193 /* 1194 * vmbus_device_unregister - Remove the specified child device 1195 * from the vmbus. 1196 */ 1197 void vmbus_device_unregister(struct hv_device *device_obj) 1198 { 1199 pr_debug("child device %s unregistered\n", 1200 dev_name(&device_obj->device)); 1201 1202 /* 1203 * Kick off the process of unregistering the device. 1204 * This will call vmbus_remove() and eventually vmbus_device_release() 1205 */ 1206 device_unregister(&device_obj->device); 1207 } 1208 1209 1210 /* 1211 * VMBUS is an acpi enumerated device. Get the information we 1212 * need from DSDT. 1213 */ 1214 #define VTPM_BASE_ADDRESS 0xfed40000 1215 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx) 1216 { 1217 resource_size_t start = 0; 1218 resource_size_t end = 0; 1219 struct resource *new_res; 1220 struct resource **old_res = &hyperv_mmio; 1221 struct resource **prev_res = NULL; 1222 1223 switch (res->type) { 1224 1225 /* 1226 * "Address" descriptors are for bus windows. Ignore 1227 * "memory" descriptors, which are for registers on 1228 * devices. 1229 */ 1230 case ACPI_RESOURCE_TYPE_ADDRESS32: 1231 start = res->data.address32.address.minimum; 1232 end = res->data.address32.address.maximum; 1233 break; 1234 1235 case ACPI_RESOURCE_TYPE_ADDRESS64: 1236 start = res->data.address64.address.minimum; 1237 end = res->data.address64.address.maximum; 1238 break; 1239 1240 default: 1241 /* Unused resource type */ 1242 return AE_OK; 1243 1244 } 1245 /* 1246 * Ignore ranges that are below 1MB, as they're not 1247 * necessary or useful here. 1248 */ 1249 if (end < 0x100000) 1250 return AE_OK; 1251 1252 new_res = kzalloc(sizeof(*new_res), GFP_ATOMIC); 1253 if (!new_res) 1254 return AE_NO_MEMORY; 1255 1256 /* If this range overlaps the virtual TPM, truncate it. */ 1257 if (end > VTPM_BASE_ADDRESS && start < VTPM_BASE_ADDRESS) 1258 end = VTPM_BASE_ADDRESS; 1259 1260 new_res->name = "hyperv mmio"; 1261 new_res->flags = IORESOURCE_MEM; 1262 new_res->start = start; 1263 new_res->end = end; 1264 1265 /* 1266 * If two ranges are adjacent, merge them. 1267 */ 1268 do { 1269 if (!*old_res) { 1270 *old_res = new_res; 1271 break; 1272 } 1273 1274 if (((*old_res)->end + 1) == new_res->start) { 1275 (*old_res)->end = new_res->end; 1276 kfree(new_res); 1277 break; 1278 } 1279 1280 if ((*old_res)->start == new_res->end + 1) { 1281 (*old_res)->start = new_res->start; 1282 kfree(new_res); 1283 break; 1284 } 1285 1286 if ((*old_res)->start > new_res->end) { 1287 new_res->sibling = *old_res; 1288 if (prev_res) 1289 (*prev_res)->sibling = new_res; 1290 *old_res = new_res; 1291 break; 1292 } 1293 1294 prev_res = old_res; 1295 old_res = &(*old_res)->sibling; 1296 1297 } while (1); 1298 1299 return AE_OK; 1300 } 1301 1302 static int vmbus_acpi_remove(struct acpi_device *device) 1303 { 1304 struct resource *cur_res; 1305 struct resource *next_res; 1306 1307 if (hyperv_mmio) { 1308 if (fb_mmio) { 1309 __release_region(hyperv_mmio, fb_mmio->start, 1310 resource_size(fb_mmio)); 1311 fb_mmio = NULL; 1312 } 1313 1314 for (cur_res = hyperv_mmio; cur_res; cur_res = next_res) { 1315 next_res = cur_res->sibling; 1316 kfree(cur_res); 1317 } 1318 } 1319 1320 return 0; 1321 } 1322 1323 static void vmbus_reserve_fb(void) 1324 { 1325 int size; 1326 /* 1327 * Make a claim for the frame buffer in the resource tree under the 1328 * first node, which will be the one below 4GB. The length seems to 1329 * be underreported, particularly in a Generation 1 VM. So start out 1330 * reserving a larger area and make it smaller until it succeeds. 1331 */ 1332 1333 if (screen_info.lfb_base) { 1334 if (efi_enabled(EFI_BOOT)) 1335 size = max_t(__u32, screen_info.lfb_size, 0x800000); 1336 else 1337 size = max_t(__u32, screen_info.lfb_size, 0x4000000); 1338 1339 for (; !fb_mmio && (size >= 0x100000); size >>= 1) { 1340 fb_mmio = __request_region(hyperv_mmio, 1341 screen_info.lfb_base, size, 1342 fb_mmio_name, 0); 1343 } 1344 } 1345 } 1346 1347 /** 1348 * vmbus_allocate_mmio() - Pick a memory-mapped I/O range. 1349 * @new: If successful, supplied a pointer to the 1350 * allocated MMIO space. 1351 * @device_obj: Identifies the caller 1352 * @min: Minimum guest physical address of the 1353 * allocation 1354 * @max: Maximum guest physical address 1355 * @size: Size of the range to be allocated 1356 * @align: Alignment of the range to be allocated 1357 * @fb_overlap_ok: Whether this allocation can be allowed 1358 * to overlap the video frame buffer. 1359 * 1360 * This function walks the resources granted to VMBus by the 1361 * _CRS object in the ACPI namespace underneath the parent 1362 * "bridge" whether that's a root PCI bus in the Generation 1 1363 * case or a Module Device in the Generation 2 case. It then 1364 * attempts to allocate from the global MMIO pool in a way that 1365 * matches the constraints supplied in these parameters and by 1366 * that _CRS. 1367 * 1368 * Return: 0 on success, -errno on failure 1369 */ 1370 int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj, 1371 resource_size_t min, resource_size_t max, 1372 resource_size_t size, resource_size_t align, 1373 bool fb_overlap_ok) 1374 { 1375 struct resource *iter, *shadow; 1376 resource_size_t range_min, range_max, start; 1377 const char *dev_n = dev_name(&device_obj->device); 1378 int retval; 1379 1380 retval = -ENXIO; 1381 down(&hyperv_mmio_lock); 1382 1383 /* 1384 * If overlaps with frame buffers are allowed, then first attempt to 1385 * make the allocation from within the reserved region. Because it 1386 * is already reserved, no shadow allocation is necessary. 1387 */ 1388 if (fb_overlap_ok && fb_mmio && !(min > fb_mmio->end) && 1389 !(max < fb_mmio->start)) { 1390 1391 range_min = fb_mmio->start; 1392 range_max = fb_mmio->end; 1393 start = (range_min + align - 1) & ~(align - 1); 1394 for (; start + size - 1 <= range_max; start += align) { 1395 *new = request_mem_region_exclusive(start, size, dev_n); 1396 if (*new) { 1397 retval = 0; 1398 goto exit; 1399 } 1400 } 1401 } 1402 1403 for (iter = hyperv_mmio; iter; iter = iter->sibling) { 1404 if ((iter->start >= max) || (iter->end <= min)) 1405 continue; 1406 1407 range_min = iter->start; 1408 range_max = iter->end; 1409 start = (range_min + align - 1) & ~(align - 1); 1410 for (; start + size - 1 <= range_max; start += align) { 1411 shadow = __request_region(iter, start, size, NULL, 1412 IORESOURCE_BUSY); 1413 if (!shadow) 1414 continue; 1415 1416 *new = request_mem_region_exclusive(start, size, dev_n); 1417 if (*new) { 1418 shadow->name = (char *)*new; 1419 retval = 0; 1420 goto exit; 1421 } 1422 1423 __release_region(iter, start, size); 1424 } 1425 } 1426 1427 exit: 1428 up(&hyperv_mmio_lock); 1429 return retval; 1430 } 1431 EXPORT_SYMBOL_GPL(vmbus_allocate_mmio); 1432 1433 /** 1434 * vmbus_free_mmio() - Free a memory-mapped I/O range. 1435 * @start: Base address of region to release. 1436 * @size: Size of the range to be allocated 1437 * 1438 * This function releases anything requested by 1439 * vmbus_mmio_allocate(). 1440 */ 1441 void vmbus_free_mmio(resource_size_t start, resource_size_t size) 1442 { 1443 struct resource *iter; 1444 1445 down(&hyperv_mmio_lock); 1446 for (iter = hyperv_mmio; iter; iter = iter->sibling) { 1447 if ((iter->start >= start + size) || (iter->end <= start)) 1448 continue; 1449 1450 __release_region(iter, start, size); 1451 } 1452 release_mem_region(start, size); 1453 up(&hyperv_mmio_lock); 1454 1455 } 1456 EXPORT_SYMBOL_GPL(vmbus_free_mmio); 1457 1458 /** 1459 * vmbus_cpu_number_to_vp_number() - Map CPU to VP. 1460 * @cpu_number: CPU number in Linux terms 1461 * 1462 * This function returns the mapping between the Linux processor 1463 * number and the hypervisor's virtual processor number, useful 1464 * in making hypercalls and such that talk about specific 1465 * processors. 1466 * 1467 * Return: Virtual processor number in Hyper-V terms 1468 */ 1469 int vmbus_cpu_number_to_vp_number(int cpu_number) 1470 { 1471 return hv_context.vp_index[cpu_number]; 1472 } 1473 EXPORT_SYMBOL_GPL(vmbus_cpu_number_to_vp_number); 1474 1475 static int vmbus_acpi_add(struct acpi_device *device) 1476 { 1477 acpi_status result; 1478 int ret_val = -ENODEV; 1479 struct acpi_device *ancestor; 1480 1481 hv_acpi_dev = device; 1482 1483 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS, 1484 vmbus_walk_resources, NULL); 1485 1486 if (ACPI_FAILURE(result)) 1487 goto acpi_walk_err; 1488 /* 1489 * Some ancestor of the vmbus acpi device (Gen1 or Gen2 1490 * firmware) is the VMOD that has the mmio ranges. Get that. 1491 */ 1492 for (ancestor = device->parent; ancestor; ancestor = ancestor->parent) { 1493 result = acpi_walk_resources(ancestor->handle, METHOD_NAME__CRS, 1494 vmbus_walk_resources, NULL); 1495 1496 if (ACPI_FAILURE(result)) 1497 continue; 1498 if (hyperv_mmio) { 1499 vmbus_reserve_fb(); 1500 break; 1501 } 1502 } 1503 ret_val = 0; 1504 1505 acpi_walk_err: 1506 complete(&probe_event); 1507 if (ret_val) 1508 vmbus_acpi_remove(device); 1509 return ret_val; 1510 } 1511 1512 static const struct acpi_device_id vmbus_acpi_device_ids[] = { 1513 {"VMBUS", 0}, 1514 {"VMBus", 0}, 1515 {"", 0}, 1516 }; 1517 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids); 1518 1519 static struct acpi_driver vmbus_acpi_driver = { 1520 .name = "vmbus", 1521 .ids = vmbus_acpi_device_ids, 1522 .ops = { 1523 .add = vmbus_acpi_add, 1524 .remove = vmbus_acpi_remove, 1525 }, 1526 }; 1527 1528 static void hv_kexec_handler(void) 1529 { 1530 hv_synic_clockevents_cleanup(); 1531 vmbus_initiate_unload(false); 1532 vmbus_connection.conn_state = DISCONNECTED; 1533 /* Make sure conn_state is set as hv_synic_cleanup checks for it */ 1534 mb(); 1535 cpuhp_remove_state(hyperv_cpuhp_online); 1536 hyperv_cleanup(); 1537 }; 1538 1539 static void hv_crash_handler(struct pt_regs *regs) 1540 { 1541 vmbus_initiate_unload(true); 1542 /* 1543 * In crash handler we can't schedule synic cleanup for all CPUs, 1544 * doing the cleanup for current CPU only. This should be sufficient 1545 * for kdump. 1546 */ 1547 vmbus_connection.conn_state = DISCONNECTED; 1548 hv_synic_cleanup(smp_processor_id()); 1549 hyperv_cleanup(); 1550 }; 1551 1552 static int __init hv_acpi_init(void) 1553 { 1554 int ret, t; 1555 1556 if (x86_hyper != &x86_hyper_ms_hyperv) 1557 return -ENODEV; 1558 1559 init_completion(&probe_event); 1560 1561 /* 1562 * Get ACPI resources first. 1563 */ 1564 ret = acpi_bus_register_driver(&vmbus_acpi_driver); 1565 1566 if (ret) 1567 return ret; 1568 1569 t = wait_for_completion_timeout(&probe_event, 5*HZ); 1570 if (t == 0) { 1571 ret = -ETIMEDOUT; 1572 goto cleanup; 1573 } 1574 1575 ret = vmbus_bus_init(); 1576 if (ret) 1577 goto cleanup; 1578 1579 hv_setup_kexec_handler(hv_kexec_handler); 1580 hv_setup_crash_handler(hv_crash_handler); 1581 1582 return 0; 1583 1584 cleanup: 1585 acpi_bus_unregister_driver(&vmbus_acpi_driver); 1586 hv_acpi_dev = NULL; 1587 return ret; 1588 } 1589 1590 static void __exit vmbus_exit(void) 1591 { 1592 int cpu; 1593 1594 hv_remove_kexec_handler(); 1595 hv_remove_crash_handler(); 1596 vmbus_connection.conn_state = DISCONNECTED; 1597 hv_synic_clockevents_cleanup(); 1598 vmbus_disconnect(); 1599 hv_remove_vmbus_irq(); 1600 for_each_online_cpu(cpu) { 1601 struct hv_per_cpu_context *hv_cpu 1602 = per_cpu_ptr(hv_context.cpu_context, cpu); 1603 1604 tasklet_kill(&hv_cpu->msg_dpc); 1605 } 1606 vmbus_free_channels(); 1607 1608 if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) { 1609 unregister_die_notifier(&hyperv_die_block); 1610 atomic_notifier_chain_unregister(&panic_notifier_list, 1611 &hyperv_panic_block); 1612 } 1613 bus_unregister(&hv_bus); 1614 1615 cpuhp_remove_state(hyperv_cpuhp_online); 1616 hv_synic_free(); 1617 acpi_bus_unregister_driver(&vmbus_acpi_driver); 1618 } 1619 1620 1621 MODULE_LICENSE("GPL"); 1622 1623 subsys_initcall(hv_acpi_init); 1624 module_exit(vmbus_exit); 1625