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 return; 792 } 793 794 795 /* 796 * vmbus_device_release - Final callback release of the vmbus child device 797 */ 798 static void vmbus_device_release(struct device *device) 799 { 800 struct hv_device *hv_dev = device_to_hv_device(device); 801 struct vmbus_channel *channel = hv_dev->channel; 802 803 hv_process_channel_removal(channel, 804 channel->offermsg.child_relid); 805 kfree(hv_dev); 806 807 } 808 809 /* The one and only one */ 810 static struct bus_type hv_bus = { 811 .name = "vmbus", 812 .match = vmbus_match, 813 .shutdown = vmbus_shutdown, 814 .remove = vmbus_remove, 815 .probe = vmbus_probe, 816 .uevent = vmbus_uevent, 817 .dev_groups = vmbus_dev_groups, 818 .drv_groups = vmbus_drv_groups, 819 }; 820 821 struct onmessage_work_context { 822 struct work_struct work; 823 struct hv_message msg; 824 }; 825 826 static void vmbus_onmessage_work(struct work_struct *work) 827 { 828 struct onmessage_work_context *ctx; 829 830 /* Do not process messages if we're in DISCONNECTED state */ 831 if (vmbus_connection.conn_state == DISCONNECTED) 832 return; 833 834 ctx = container_of(work, struct onmessage_work_context, 835 work); 836 vmbus_onmessage(&ctx->msg); 837 kfree(ctx); 838 } 839 840 static void hv_process_timer_expiration(struct hv_message *msg, 841 struct hv_per_cpu_context *hv_cpu) 842 { 843 struct clock_event_device *dev = hv_cpu->clk_evt; 844 845 if (dev->event_handler) 846 dev->event_handler(dev); 847 848 vmbus_signal_eom(msg, HVMSG_TIMER_EXPIRED); 849 } 850 851 void vmbus_on_msg_dpc(unsigned long data) 852 { 853 struct hv_per_cpu_context *hv_cpu = (void *)data; 854 void *page_addr = hv_cpu->synic_message_page; 855 struct hv_message *msg = (struct hv_message *)page_addr + 856 VMBUS_MESSAGE_SINT; 857 struct vmbus_channel_message_header *hdr; 858 struct vmbus_channel_message_table_entry *entry; 859 struct onmessage_work_context *ctx; 860 u32 message_type = msg->header.message_type; 861 862 if (message_type == HVMSG_NONE) 863 /* no msg */ 864 return; 865 866 hdr = (struct vmbus_channel_message_header *)msg->u.payload; 867 868 if (hdr->msgtype >= CHANNELMSG_COUNT) { 869 WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype); 870 goto msg_handled; 871 } 872 873 entry = &channel_message_table[hdr->msgtype]; 874 if (entry->handler_type == VMHT_BLOCKING) { 875 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC); 876 if (ctx == NULL) 877 return; 878 879 INIT_WORK(&ctx->work, vmbus_onmessage_work); 880 memcpy(&ctx->msg, msg, sizeof(*msg)); 881 882 queue_work(vmbus_connection.work_queue, &ctx->work); 883 } else 884 entry->message_handler(hdr); 885 886 msg_handled: 887 vmbus_signal_eom(msg, message_type); 888 } 889 890 891 /* 892 * Direct callback for channels using other deferred processing 893 */ 894 static void vmbus_channel_isr(struct vmbus_channel *channel) 895 { 896 void (*callback_fn)(void *); 897 898 callback_fn = READ_ONCE(channel->onchannel_callback); 899 if (likely(callback_fn != NULL)) 900 (*callback_fn)(channel->channel_callback_context); 901 } 902 903 /* 904 * Schedule all channels with events pending 905 */ 906 static void vmbus_chan_sched(struct hv_per_cpu_context *hv_cpu) 907 { 908 unsigned long *recv_int_page; 909 u32 maxbits, relid; 910 911 if (vmbus_proto_version < VERSION_WIN8) { 912 maxbits = MAX_NUM_CHANNELS_SUPPORTED; 913 recv_int_page = vmbus_connection.recv_int_page; 914 } else { 915 /* 916 * When the host is win8 and beyond, the event page 917 * can be directly checked to get the id of the channel 918 * that has the interrupt pending. 919 */ 920 void *page_addr = hv_cpu->synic_event_page; 921 union hv_synic_event_flags *event 922 = (union hv_synic_event_flags *)page_addr + 923 VMBUS_MESSAGE_SINT; 924 925 maxbits = HV_EVENT_FLAGS_COUNT; 926 recv_int_page = event->flags; 927 } 928 929 if (unlikely(!recv_int_page)) 930 return; 931 932 for_each_set_bit(relid, recv_int_page, maxbits) { 933 struct vmbus_channel *channel; 934 935 if (!sync_test_and_clear_bit(relid, recv_int_page)) 936 continue; 937 938 /* Special case - vmbus channel protocol msg */ 939 if (relid == 0) 940 continue; 941 942 rcu_read_lock(); 943 944 /* Find channel based on relid */ 945 list_for_each_entry_rcu(channel, &hv_cpu->chan_list, percpu_list) { 946 if (channel->offermsg.child_relid != relid) 947 continue; 948 949 switch (channel->callback_mode) { 950 case HV_CALL_ISR: 951 vmbus_channel_isr(channel); 952 break; 953 954 case HV_CALL_BATCHED: 955 hv_begin_read(&channel->inbound); 956 /* fallthrough */ 957 case HV_CALL_DIRECT: 958 tasklet_schedule(&channel->callback_event); 959 } 960 } 961 962 rcu_read_unlock(); 963 } 964 } 965 966 static void vmbus_isr(void) 967 { 968 struct hv_per_cpu_context *hv_cpu 969 = this_cpu_ptr(hv_context.cpu_context); 970 void *page_addr = hv_cpu->synic_event_page; 971 struct hv_message *msg; 972 union hv_synic_event_flags *event; 973 bool handled = false; 974 975 if (unlikely(page_addr == NULL)) 976 return; 977 978 event = (union hv_synic_event_flags *)page_addr + 979 VMBUS_MESSAGE_SINT; 980 /* 981 * Check for events before checking for messages. This is the order 982 * in which events and messages are checked in Windows guests on 983 * Hyper-V, and the Windows team suggested we do the same. 984 */ 985 986 if ((vmbus_proto_version == VERSION_WS2008) || 987 (vmbus_proto_version == VERSION_WIN7)) { 988 989 /* Since we are a child, we only need to check bit 0 */ 990 if (sync_test_and_clear_bit(0, event->flags)) 991 handled = true; 992 } else { 993 /* 994 * Our host is win8 or above. The signaling mechanism 995 * has changed and we can directly look at the event page. 996 * If bit n is set then we have an interrup on the channel 997 * whose id is n. 998 */ 999 handled = true; 1000 } 1001 1002 if (handled) 1003 vmbus_chan_sched(hv_cpu); 1004 1005 page_addr = hv_cpu->synic_message_page; 1006 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT; 1007 1008 /* Check if there are actual msgs to be processed */ 1009 if (msg->header.message_type != HVMSG_NONE) { 1010 if (msg->header.message_type == HVMSG_TIMER_EXPIRED) 1011 hv_process_timer_expiration(msg, hv_cpu); 1012 else 1013 tasklet_schedule(&hv_cpu->msg_dpc); 1014 } 1015 1016 add_interrupt_randomness(HYPERVISOR_CALLBACK_VECTOR, 0); 1017 } 1018 1019 1020 /* 1021 * vmbus_bus_init -Main vmbus driver initialization routine. 1022 * 1023 * Here, we 1024 * - initialize the vmbus driver context 1025 * - invoke the vmbus hv main init routine 1026 * - retrieve the channel offers 1027 */ 1028 static int vmbus_bus_init(void) 1029 { 1030 int ret; 1031 1032 /* Hypervisor initialization...setup hypercall page..etc */ 1033 ret = hv_init(); 1034 if (ret != 0) { 1035 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret); 1036 return ret; 1037 } 1038 1039 ret = bus_register(&hv_bus); 1040 if (ret) 1041 return ret; 1042 1043 hv_setup_vmbus_irq(vmbus_isr); 1044 1045 ret = hv_synic_alloc(); 1046 if (ret) 1047 goto err_alloc; 1048 /* 1049 * Initialize the per-cpu interrupt state and 1050 * connect to the host. 1051 */ 1052 ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "x86/hyperv:online", 1053 hv_synic_init, hv_synic_cleanup); 1054 if (ret < 0) 1055 goto err_alloc; 1056 hyperv_cpuhp_online = ret; 1057 1058 ret = vmbus_connect(); 1059 if (ret) 1060 goto err_connect; 1061 1062 /* 1063 * Only register if the crash MSRs are available 1064 */ 1065 if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) { 1066 register_die_notifier(&hyperv_die_block); 1067 atomic_notifier_chain_register(&panic_notifier_list, 1068 &hyperv_panic_block); 1069 } 1070 1071 vmbus_request_offers(); 1072 1073 return 0; 1074 1075 err_connect: 1076 cpuhp_remove_state(hyperv_cpuhp_online); 1077 err_alloc: 1078 hv_synic_free(); 1079 hv_remove_vmbus_irq(); 1080 1081 bus_unregister(&hv_bus); 1082 1083 return ret; 1084 } 1085 1086 /** 1087 * __vmbus_child_driver_register() - Register a vmbus's driver 1088 * @hv_driver: Pointer to driver structure you want to register 1089 * @owner: owner module of the drv 1090 * @mod_name: module name string 1091 * 1092 * Registers the given driver with Linux through the 'driver_register()' call 1093 * and sets up the hyper-v vmbus handling for this driver. 1094 * It will return the state of the 'driver_register()' call. 1095 * 1096 */ 1097 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name) 1098 { 1099 int ret; 1100 1101 pr_info("registering driver %s\n", hv_driver->name); 1102 1103 ret = vmbus_exists(); 1104 if (ret < 0) 1105 return ret; 1106 1107 hv_driver->driver.name = hv_driver->name; 1108 hv_driver->driver.owner = owner; 1109 hv_driver->driver.mod_name = mod_name; 1110 hv_driver->driver.bus = &hv_bus; 1111 1112 spin_lock_init(&hv_driver->dynids.lock); 1113 INIT_LIST_HEAD(&hv_driver->dynids.list); 1114 1115 ret = driver_register(&hv_driver->driver); 1116 1117 return ret; 1118 } 1119 EXPORT_SYMBOL_GPL(__vmbus_driver_register); 1120 1121 /** 1122 * vmbus_driver_unregister() - Unregister a vmbus's driver 1123 * @hv_driver: Pointer to driver structure you want to 1124 * un-register 1125 * 1126 * Un-register the given driver that was previous registered with a call to 1127 * vmbus_driver_register() 1128 */ 1129 void vmbus_driver_unregister(struct hv_driver *hv_driver) 1130 { 1131 pr_info("unregistering driver %s\n", hv_driver->name); 1132 1133 if (!vmbus_exists()) { 1134 driver_unregister(&hv_driver->driver); 1135 vmbus_free_dynids(hv_driver); 1136 } 1137 } 1138 EXPORT_SYMBOL_GPL(vmbus_driver_unregister); 1139 1140 /* 1141 * vmbus_device_create - Creates and registers a new child device 1142 * on the vmbus. 1143 */ 1144 struct hv_device *vmbus_device_create(const uuid_le *type, 1145 const uuid_le *instance, 1146 struct vmbus_channel *channel) 1147 { 1148 struct hv_device *child_device_obj; 1149 1150 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL); 1151 if (!child_device_obj) { 1152 pr_err("Unable to allocate device object for child device\n"); 1153 return NULL; 1154 } 1155 1156 child_device_obj->channel = channel; 1157 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le)); 1158 memcpy(&child_device_obj->dev_instance, instance, 1159 sizeof(uuid_le)); 1160 child_device_obj->vendor_id = 0x1414; /* MSFT vendor ID */ 1161 1162 1163 return child_device_obj; 1164 } 1165 1166 /* 1167 * vmbus_device_register - Register the child device 1168 */ 1169 int vmbus_device_register(struct hv_device *child_device_obj) 1170 { 1171 int ret = 0; 1172 1173 dev_set_name(&child_device_obj->device, "%pUl", 1174 child_device_obj->channel->offermsg.offer.if_instance.b); 1175 1176 child_device_obj->device.bus = &hv_bus; 1177 child_device_obj->device.parent = &hv_acpi_dev->dev; 1178 child_device_obj->device.release = vmbus_device_release; 1179 1180 /* 1181 * Register with the LDM. This will kick off the driver/device 1182 * binding...which will eventually call vmbus_match() and vmbus_probe() 1183 */ 1184 ret = device_register(&child_device_obj->device); 1185 1186 if (ret) 1187 pr_err("Unable to register child device\n"); 1188 else 1189 pr_debug("child device %s registered\n", 1190 dev_name(&child_device_obj->device)); 1191 1192 return ret; 1193 } 1194 1195 /* 1196 * vmbus_device_unregister - Remove the specified child device 1197 * from the vmbus. 1198 */ 1199 void vmbus_device_unregister(struct hv_device *device_obj) 1200 { 1201 pr_debug("child device %s unregistered\n", 1202 dev_name(&device_obj->device)); 1203 1204 /* 1205 * Kick off the process of unregistering the device. 1206 * This will call vmbus_remove() and eventually vmbus_device_release() 1207 */ 1208 device_unregister(&device_obj->device); 1209 } 1210 1211 1212 /* 1213 * VMBUS is an acpi enumerated device. Get the information we 1214 * need from DSDT. 1215 */ 1216 #define VTPM_BASE_ADDRESS 0xfed40000 1217 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx) 1218 { 1219 resource_size_t start = 0; 1220 resource_size_t end = 0; 1221 struct resource *new_res; 1222 struct resource **old_res = &hyperv_mmio; 1223 struct resource **prev_res = NULL; 1224 1225 switch (res->type) { 1226 1227 /* 1228 * "Address" descriptors are for bus windows. Ignore 1229 * "memory" descriptors, which are for registers on 1230 * devices. 1231 */ 1232 case ACPI_RESOURCE_TYPE_ADDRESS32: 1233 start = res->data.address32.address.minimum; 1234 end = res->data.address32.address.maximum; 1235 break; 1236 1237 case ACPI_RESOURCE_TYPE_ADDRESS64: 1238 start = res->data.address64.address.minimum; 1239 end = res->data.address64.address.maximum; 1240 break; 1241 1242 default: 1243 /* Unused resource type */ 1244 return AE_OK; 1245 1246 } 1247 /* 1248 * Ignore ranges that are below 1MB, as they're not 1249 * necessary or useful here. 1250 */ 1251 if (end < 0x100000) 1252 return AE_OK; 1253 1254 new_res = kzalloc(sizeof(*new_res), GFP_ATOMIC); 1255 if (!new_res) 1256 return AE_NO_MEMORY; 1257 1258 /* If this range overlaps the virtual TPM, truncate it. */ 1259 if (end > VTPM_BASE_ADDRESS && start < VTPM_BASE_ADDRESS) 1260 end = VTPM_BASE_ADDRESS; 1261 1262 new_res->name = "hyperv mmio"; 1263 new_res->flags = IORESOURCE_MEM; 1264 new_res->start = start; 1265 new_res->end = end; 1266 1267 /* 1268 * If two ranges are adjacent, merge them. 1269 */ 1270 do { 1271 if (!*old_res) { 1272 *old_res = new_res; 1273 break; 1274 } 1275 1276 if (((*old_res)->end + 1) == new_res->start) { 1277 (*old_res)->end = new_res->end; 1278 kfree(new_res); 1279 break; 1280 } 1281 1282 if ((*old_res)->start == new_res->end + 1) { 1283 (*old_res)->start = new_res->start; 1284 kfree(new_res); 1285 break; 1286 } 1287 1288 if ((*old_res)->start > new_res->end) { 1289 new_res->sibling = *old_res; 1290 if (prev_res) 1291 (*prev_res)->sibling = new_res; 1292 *old_res = new_res; 1293 break; 1294 } 1295 1296 prev_res = old_res; 1297 old_res = &(*old_res)->sibling; 1298 1299 } while (1); 1300 1301 return AE_OK; 1302 } 1303 1304 static int vmbus_acpi_remove(struct acpi_device *device) 1305 { 1306 struct resource *cur_res; 1307 struct resource *next_res; 1308 1309 if (hyperv_mmio) { 1310 if (fb_mmio) { 1311 __release_region(hyperv_mmio, fb_mmio->start, 1312 resource_size(fb_mmio)); 1313 fb_mmio = NULL; 1314 } 1315 1316 for (cur_res = hyperv_mmio; cur_res; cur_res = next_res) { 1317 next_res = cur_res->sibling; 1318 kfree(cur_res); 1319 } 1320 } 1321 1322 return 0; 1323 } 1324 1325 static void vmbus_reserve_fb(void) 1326 { 1327 int size; 1328 /* 1329 * Make a claim for the frame buffer in the resource tree under the 1330 * first node, which will be the one below 4GB. The length seems to 1331 * be underreported, particularly in a Generation 1 VM. So start out 1332 * reserving a larger area and make it smaller until it succeeds. 1333 */ 1334 1335 if (screen_info.lfb_base) { 1336 if (efi_enabled(EFI_BOOT)) 1337 size = max_t(__u32, screen_info.lfb_size, 0x800000); 1338 else 1339 size = max_t(__u32, screen_info.lfb_size, 0x4000000); 1340 1341 for (; !fb_mmio && (size >= 0x100000); size >>= 1) { 1342 fb_mmio = __request_region(hyperv_mmio, 1343 screen_info.lfb_base, size, 1344 fb_mmio_name, 0); 1345 } 1346 } 1347 } 1348 1349 /** 1350 * vmbus_allocate_mmio() - Pick a memory-mapped I/O range. 1351 * @new: If successful, supplied a pointer to the 1352 * allocated MMIO space. 1353 * @device_obj: Identifies the caller 1354 * @min: Minimum guest physical address of the 1355 * allocation 1356 * @max: Maximum guest physical address 1357 * @size: Size of the range to be allocated 1358 * @align: Alignment of the range to be allocated 1359 * @fb_overlap_ok: Whether this allocation can be allowed 1360 * to overlap the video frame buffer. 1361 * 1362 * This function walks the resources granted to VMBus by the 1363 * _CRS object in the ACPI namespace underneath the parent 1364 * "bridge" whether that's a root PCI bus in the Generation 1 1365 * case or a Module Device in the Generation 2 case. It then 1366 * attempts to allocate from the global MMIO pool in a way that 1367 * matches the constraints supplied in these parameters and by 1368 * that _CRS. 1369 * 1370 * Return: 0 on success, -errno on failure 1371 */ 1372 int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj, 1373 resource_size_t min, resource_size_t max, 1374 resource_size_t size, resource_size_t align, 1375 bool fb_overlap_ok) 1376 { 1377 struct resource *iter, *shadow; 1378 resource_size_t range_min, range_max, start; 1379 const char *dev_n = dev_name(&device_obj->device); 1380 int retval; 1381 1382 retval = -ENXIO; 1383 down(&hyperv_mmio_lock); 1384 1385 /* 1386 * If overlaps with frame buffers are allowed, then first attempt to 1387 * make the allocation from within the reserved region. Because it 1388 * is already reserved, no shadow allocation is necessary. 1389 */ 1390 if (fb_overlap_ok && fb_mmio && !(min > fb_mmio->end) && 1391 !(max < fb_mmio->start)) { 1392 1393 range_min = fb_mmio->start; 1394 range_max = fb_mmio->end; 1395 start = (range_min + align - 1) & ~(align - 1); 1396 for (; start + size - 1 <= range_max; start += align) { 1397 *new = request_mem_region_exclusive(start, size, dev_n); 1398 if (*new) { 1399 retval = 0; 1400 goto exit; 1401 } 1402 } 1403 } 1404 1405 for (iter = hyperv_mmio; iter; iter = iter->sibling) { 1406 if ((iter->start >= max) || (iter->end <= min)) 1407 continue; 1408 1409 range_min = iter->start; 1410 range_max = iter->end; 1411 start = (range_min + align - 1) & ~(align - 1); 1412 for (; start + size - 1 <= range_max; start += align) { 1413 shadow = __request_region(iter, start, size, NULL, 1414 IORESOURCE_BUSY); 1415 if (!shadow) 1416 continue; 1417 1418 *new = request_mem_region_exclusive(start, size, dev_n); 1419 if (*new) { 1420 shadow->name = (char *)*new; 1421 retval = 0; 1422 goto exit; 1423 } 1424 1425 __release_region(iter, start, size); 1426 } 1427 } 1428 1429 exit: 1430 up(&hyperv_mmio_lock); 1431 return retval; 1432 } 1433 EXPORT_SYMBOL_GPL(vmbus_allocate_mmio); 1434 1435 /** 1436 * vmbus_free_mmio() - Free a memory-mapped I/O range. 1437 * @start: Base address of region to release. 1438 * @size: Size of the range to be allocated 1439 * 1440 * This function releases anything requested by 1441 * vmbus_mmio_allocate(). 1442 */ 1443 void vmbus_free_mmio(resource_size_t start, resource_size_t size) 1444 { 1445 struct resource *iter; 1446 1447 down(&hyperv_mmio_lock); 1448 for (iter = hyperv_mmio; iter; iter = iter->sibling) { 1449 if ((iter->start >= start + size) || (iter->end <= start)) 1450 continue; 1451 1452 __release_region(iter, start, size); 1453 } 1454 release_mem_region(start, size); 1455 up(&hyperv_mmio_lock); 1456 1457 } 1458 EXPORT_SYMBOL_GPL(vmbus_free_mmio); 1459 1460 /** 1461 * vmbus_cpu_number_to_vp_number() - Map CPU to VP. 1462 * @cpu_number: CPU number in Linux terms 1463 * 1464 * This function returns the mapping between the Linux processor 1465 * number and the hypervisor's virtual processor number, useful 1466 * in making hypercalls and such that talk about specific 1467 * processors. 1468 * 1469 * Return: Virtual processor number in Hyper-V terms 1470 */ 1471 int vmbus_cpu_number_to_vp_number(int cpu_number) 1472 { 1473 return hv_context.vp_index[cpu_number]; 1474 } 1475 EXPORT_SYMBOL_GPL(vmbus_cpu_number_to_vp_number); 1476 1477 static int vmbus_acpi_add(struct acpi_device *device) 1478 { 1479 acpi_status result; 1480 int ret_val = -ENODEV; 1481 struct acpi_device *ancestor; 1482 1483 hv_acpi_dev = device; 1484 1485 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS, 1486 vmbus_walk_resources, NULL); 1487 1488 if (ACPI_FAILURE(result)) 1489 goto acpi_walk_err; 1490 /* 1491 * Some ancestor of the vmbus acpi device (Gen1 or Gen2 1492 * firmware) is the VMOD that has the mmio ranges. Get that. 1493 */ 1494 for (ancestor = device->parent; ancestor; ancestor = ancestor->parent) { 1495 result = acpi_walk_resources(ancestor->handle, METHOD_NAME__CRS, 1496 vmbus_walk_resources, NULL); 1497 1498 if (ACPI_FAILURE(result)) 1499 continue; 1500 if (hyperv_mmio) { 1501 vmbus_reserve_fb(); 1502 break; 1503 } 1504 } 1505 ret_val = 0; 1506 1507 acpi_walk_err: 1508 complete(&probe_event); 1509 if (ret_val) 1510 vmbus_acpi_remove(device); 1511 return ret_val; 1512 } 1513 1514 static const struct acpi_device_id vmbus_acpi_device_ids[] = { 1515 {"VMBUS", 0}, 1516 {"VMBus", 0}, 1517 {"", 0}, 1518 }; 1519 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids); 1520 1521 static struct acpi_driver vmbus_acpi_driver = { 1522 .name = "vmbus", 1523 .ids = vmbus_acpi_device_ids, 1524 .ops = { 1525 .add = vmbus_acpi_add, 1526 .remove = vmbus_acpi_remove, 1527 }, 1528 }; 1529 1530 static void hv_kexec_handler(void) 1531 { 1532 hv_synic_clockevents_cleanup(); 1533 vmbus_initiate_unload(false); 1534 vmbus_connection.conn_state = DISCONNECTED; 1535 /* Make sure conn_state is set as hv_synic_cleanup checks for it */ 1536 mb(); 1537 cpuhp_remove_state(hyperv_cpuhp_online); 1538 hyperv_cleanup(); 1539 }; 1540 1541 static void hv_crash_handler(struct pt_regs *regs) 1542 { 1543 vmbus_initiate_unload(true); 1544 /* 1545 * In crash handler we can't schedule synic cleanup for all CPUs, 1546 * doing the cleanup for current CPU only. This should be sufficient 1547 * for kdump. 1548 */ 1549 vmbus_connection.conn_state = DISCONNECTED; 1550 hv_synic_cleanup(smp_processor_id()); 1551 hyperv_cleanup(); 1552 }; 1553 1554 static int __init hv_acpi_init(void) 1555 { 1556 int ret, t; 1557 1558 if (x86_hyper != &x86_hyper_ms_hyperv) 1559 return -ENODEV; 1560 1561 init_completion(&probe_event); 1562 1563 /* 1564 * Get ACPI resources first. 1565 */ 1566 ret = acpi_bus_register_driver(&vmbus_acpi_driver); 1567 1568 if (ret) 1569 return ret; 1570 1571 t = wait_for_completion_timeout(&probe_event, 5*HZ); 1572 if (t == 0) { 1573 ret = -ETIMEDOUT; 1574 goto cleanup; 1575 } 1576 1577 ret = vmbus_bus_init(); 1578 if (ret) 1579 goto cleanup; 1580 1581 hv_setup_kexec_handler(hv_kexec_handler); 1582 hv_setup_crash_handler(hv_crash_handler); 1583 1584 return 0; 1585 1586 cleanup: 1587 acpi_bus_unregister_driver(&vmbus_acpi_driver); 1588 hv_acpi_dev = NULL; 1589 return ret; 1590 } 1591 1592 static void __exit vmbus_exit(void) 1593 { 1594 int cpu; 1595 1596 hv_remove_kexec_handler(); 1597 hv_remove_crash_handler(); 1598 vmbus_connection.conn_state = DISCONNECTED; 1599 hv_synic_clockevents_cleanup(); 1600 vmbus_disconnect(); 1601 hv_remove_vmbus_irq(); 1602 for_each_online_cpu(cpu) { 1603 struct hv_per_cpu_context *hv_cpu 1604 = per_cpu_ptr(hv_context.cpu_context, cpu); 1605 1606 tasklet_kill(&hv_cpu->msg_dpc); 1607 } 1608 vmbus_free_channels(); 1609 1610 if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) { 1611 unregister_die_notifier(&hyperv_die_block); 1612 atomic_notifier_chain_unregister(&panic_notifier_list, 1613 &hyperv_panic_block); 1614 } 1615 bus_unregister(&hv_bus); 1616 1617 cpuhp_remove_state(hyperv_cpuhp_online); 1618 hv_synic_free(); 1619 acpi_bus_unregister_driver(&vmbus_acpi_driver); 1620 } 1621 1622 1623 MODULE_LICENSE("GPL"); 1624 1625 subsys_initcall(hv_acpi_init); 1626 module_exit(vmbus_exit); 1627