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 <asm/hyperv.h> 38 #include <asm/hypervisor.h> 39 #include <asm/mshyperv.h> 40 #include <linux/notifier.h> 41 #include <linux/ptrace.h> 42 #include "hyperv_vmbus.h" 43 44 static struct acpi_device *hv_acpi_dev; 45 46 static struct tasklet_struct msg_dpc; 47 static struct completion probe_event; 48 static int irq; 49 50 51 static int hyperv_panic_event(struct notifier_block *nb, 52 unsigned long event, void *ptr) 53 { 54 struct pt_regs *regs; 55 56 regs = current_pt_regs(); 57 58 wrmsrl(HV_X64_MSR_CRASH_P0, regs->ip); 59 wrmsrl(HV_X64_MSR_CRASH_P1, regs->ax); 60 wrmsrl(HV_X64_MSR_CRASH_P2, regs->bx); 61 wrmsrl(HV_X64_MSR_CRASH_P3, regs->cx); 62 wrmsrl(HV_X64_MSR_CRASH_P4, regs->dx); 63 64 /* 65 * Let Hyper-V know there is crash data available 66 */ 67 wrmsrl(HV_X64_MSR_CRASH_CTL, HV_CRASH_CTL_CRASH_NOTIFY); 68 return NOTIFY_DONE; 69 } 70 71 static struct notifier_block hyperv_panic_block = { 72 .notifier_call = hyperv_panic_event, 73 }; 74 75 struct resource hyperv_mmio = { 76 .name = "hyperv mmio", 77 .flags = IORESOURCE_MEM, 78 }; 79 EXPORT_SYMBOL_GPL(hyperv_mmio); 80 81 static int vmbus_exists(void) 82 { 83 if (hv_acpi_dev == NULL) 84 return -ENODEV; 85 86 return 0; 87 } 88 89 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2) 90 static void print_alias_name(struct hv_device *hv_dev, char *alias_name) 91 { 92 int i; 93 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2) 94 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]); 95 } 96 97 static u8 channel_monitor_group(struct vmbus_channel *channel) 98 { 99 return (u8)channel->offermsg.monitorid / 32; 100 } 101 102 static u8 channel_monitor_offset(struct vmbus_channel *channel) 103 { 104 return (u8)channel->offermsg.monitorid % 32; 105 } 106 107 static u32 channel_pending(struct vmbus_channel *channel, 108 struct hv_monitor_page *monitor_page) 109 { 110 u8 monitor_group = channel_monitor_group(channel); 111 return monitor_page->trigger_group[monitor_group].pending; 112 } 113 114 static u32 channel_latency(struct vmbus_channel *channel, 115 struct hv_monitor_page *monitor_page) 116 { 117 u8 monitor_group = channel_monitor_group(channel); 118 u8 monitor_offset = channel_monitor_offset(channel); 119 return monitor_page->latency[monitor_group][monitor_offset]; 120 } 121 122 static u32 channel_conn_id(struct vmbus_channel *channel, 123 struct hv_monitor_page *monitor_page) 124 { 125 u8 monitor_group = channel_monitor_group(channel); 126 u8 monitor_offset = channel_monitor_offset(channel); 127 return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id; 128 } 129 130 static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr, 131 char *buf) 132 { 133 struct hv_device *hv_dev = device_to_hv_device(dev); 134 135 if (!hv_dev->channel) 136 return -ENODEV; 137 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid); 138 } 139 static DEVICE_ATTR_RO(id); 140 141 static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr, 142 char *buf) 143 { 144 struct hv_device *hv_dev = device_to_hv_device(dev); 145 146 if (!hv_dev->channel) 147 return -ENODEV; 148 return sprintf(buf, "%d\n", hv_dev->channel->state); 149 } 150 static DEVICE_ATTR_RO(state); 151 152 static ssize_t monitor_id_show(struct device *dev, 153 struct device_attribute *dev_attr, char *buf) 154 { 155 struct hv_device *hv_dev = device_to_hv_device(dev); 156 157 if (!hv_dev->channel) 158 return -ENODEV; 159 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid); 160 } 161 static DEVICE_ATTR_RO(monitor_id); 162 163 static ssize_t class_id_show(struct device *dev, 164 struct device_attribute *dev_attr, 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, "{%pUl}\n", 171 hv_dev->channel->offermsg.offer.if_type.b); 172 } 173 static DEVICE_ATTR_RO(class_id); 174 175 static ssize_t device_id_show(struct device *dev, 176 struct device_attribute *dev_attr, char *buf) 177 { 178 struct hv_device *hv_dev = device_to_hv_device(dev); 179 180 if (!hv_dev->channel) 181 return -ENODEV; 182 return sprintf(buf, "{%pUl}\n", 183 hv_dev->channel->offermsg.offer.if_instance.b); 184 } 185 static DEVICE_ATTR_RO(device_id); 186 187 static ssize_t modalias_show(struct device *dev, 188 struct device_attribute *dev_attr, char *buf) 189 { 190 struct hv_device *hv_dev = device_to_hv_device(dev); 191 char alias_name[VMBUS_ALIAS_LEN + 1]; 192 193 print_alias_name(hv_dev, alias_name); 194 return sprintf(buf, "vmbus:%s\n", alias_name); 195 } 196 static DEVICE_ATTR_RO(modalias); 197 198 static ssize_t server_monitor_pending_show(struct device *dev, 199 struct device_attribute *dev_attr, 200 char *buf) 201 { 202 struct hv_device *hv_dev = device_to_hv_device(dev); 203 204 if (!hv_dev->channel) 205 return -ENODEV; 206 return sprintf(buf, "%d\n", 207 channel_pending(hv_dev->channel, 208 vmbus_connection.monitor_pages[1])); 209 } 210 static DEVICE_ATTR_RO(server_monitor_pending); 211 212 static ssize_t client_monitor_pending_show(struct device *dev, 213 struct device_attribute *dev_attr, 214 char *buf) 215 { 216 struct hv_device *hv_dev = device_to_hv_device(dev); 217 218 if (!hv_dev->channel) 219 return -ENODEV; 220 return sprintf(buf, "%d\n", 221 channel_pending(hv_dev->channel, 222 vmbus_connection.monitor_pages[1])); 223 } 224 static DEVICE_ATTR_RO(client_monitor_pending); 225 226 static ssize_t server_monitor_latency_show(struct device *dev, 227 struct device_attribute *dev_attr, 228 char *buf) 229 { 230 struct hv_device *hv_dev = device_to_hv_device(dev); 231 232 if (!hv_dev->channel) 233 return -ENODEV; 234 return sprintf(buf, "%d\n", 235 channel_latency(hv_dev->channel, 236 vmbus_connection.monitor_pages[0])); 237 } 238 static DEVICE_ATTR_RO(server_monitor_latency); 239 240 static ssize_t client_monitor_latency_show(struct device *dev, 241 struct device_attribute *dev_attr, 242 char *buf) 243 { 244 struct hv_device *hv_dev = device_to_hv_device(dev); 245 246 if (!hv_dev->channel) 247 return -ENODEV; 248 return sprintf(buf, "%d\n", 249 channel_latency(hv_dev->channel, 250 vmbus_connection.monitor_pages[1])); 251 } 252 static DEVICE_ATTR_RO(client_monitor_latency); 253 254 static ssize_t server_monitor_conn_id_show(struct device *dev, 255 struct device_attribute *dev_attr, 256 char *buf) 257 { 258 struct hv_device *hv_dev = device_to_hv_device(dev); 259 260 if (!hv_dev->channel) 261 return -ENODEV; 262 return sprintf(buf, "%d\n", 263 channel_conn_id(hv_dev->channel, 264 vmbus_connection.monitor_pages[0])); 265 } 266 static DEVICE_ATTR_RO(server_monitor_conn_id); 267 268 static ssize_t client_monitor_conn_id_show(struct device *dev, 269 struct device_attribute *dev_attr, 270 char *buf) 271 { 272 struct hv_device *hv_dev = device_to_hv_device(dev); 273 274 if (!hv_dev->channel) 275 return -ENODEV; 276 return sprintf(buf, "%d\n", 277 channel_conn_id(hv_dev->channel, 278 vmbus_connection.monitor_pages[1])); 279 } 280 static DEVICE_ATTR_RO(client_monitor_conn_id); 281 282 static ssize_t out_intr_mask_show(struct device *dev, 283 struct device_attribute *dev_attr, char *buf) 284 { 285 struct hv_device *hv_dev = device_to_hv_device(dev); 286 struct hv_ring_buffer_debug_info outbound; 287 288 if (!hv_dev->channel) 289 return -ENODEV; 290 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 291 return sprintf(buf, "%d\n", outbound.current_interrupt_mask); 292 } 293 static DEVICE_ATTR_RO(out_intr_mask); 294 295 static ssize_t out_read_index_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_read_index); 305 } 306 static DEVICE_ATTR_RO(out_read_index); 307 308 static ssize_t out_write_index_show(struct device *dev, 309 struct device_attribute *dev_attr, 310 char *buf) 311 { 312 struct hv_device *hv_dev = device_to_hv_device(dev); 313 struct hv_ring_buffer_debug_info outbound; 314 315 if (!hv_dev->channel) 316 return -ENODEV; 317 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 318 return sprintf(buf, "%d\n", outbound.current_write_index); 319 } 320 static DEVICE_ATTR_RO(out_write_index); 321 322 static ssize_t out_read_bytes_avail_show(struct device *dev, 323 struct device_attribute *dev_attr, 324 char *buf) 325 { 326 struct hv_device *hv_dev = device_to_hv_device(dev); 327 struct hv_ring_buffer_debug_info outbound; 328 329 if (!hv_dev->channel) 330 return -ENODEV; 331 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 332 return sprintf(buf, "%d\n", outbound.bytes_avail_toread); 333 } 334 static DEVICE_ATTR_RO(out_read_bytes_avail); 335 336 static ssize_t out_write_bytes_avail_show(struct device *dev, 337 struct device_attribute *dev_attr, 338 char *buf) 339 { 340 struct hv_device *hv_dev = device_to_hv_device(dev); 341 struct hv_ring_buffer_debug_info outbound; 342 343 if (!hv_dev->channel) 344 return -ENODEV; 345 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 346 return sprintf(buf, "%d\n", outbound.bytes_avail_towrite); 347 } 348 static DEVICE_ATTR_RO(out_write_bytes_avail); 349 350 static ssize_t in_intr_mask_show(struct device *dev, 351 struct device_attribute *dev_attr, char *buf) 352 { 353 struct hv_device *hv_dev = device_to_hv_device(dev); 354 struct hv_ring_buffer_debug_info inbound; 355 356 if (!hv_dev->channel) 357 return -ENODEV; 358 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 359 return sprintf(buf, "%d\n", inbound.current_interrupt_mask); 360 } 361 static DEVICE_ATTR_RO(in_intr_mask); 362 363 static ssize_t in_read_index_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_read_index); 373 } 374 static DEVICE_ATTR_RO(in_read_index); 375 376 static ssize_t in_write_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_write_index); 386 } 387 static DEVICE_ATTR_RO(in_write_index); 388 389 static ssize_t in_read_bytes_avail_show(struct device *dev, 390 struct device_attribute *dev_attr, 391 char *buf) 392 { 393 struct hv_device *hv_dev = device_to_hv_device(dev); 394 struct hv_ring_buffer_debug_info inbound; 395 396 if (!hv_dev->channel) 397 return -ENODEV; 398 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 399 return sprintf(buf, "%d\n", inbound.bytes_avail_toread); 400 } 401 static DEVICE_ATTR_RO(in_read_bytes_avail); 402 403 static ssize_t in_write_bytes_avail_show(struct device *dev, 404 struct device_attribute *dev_attr, 405 char *buf) 406 { 407 struct hv_device *hv_dev = device_to_hv_device(dev); 408 struct hv_ring_buffer_debug_info inbound; 409 410 if (!hv_dev->channel) 411 return -ENODEV; 412 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 413 return sprintf(buf, "%d\n", inbound.bytes_avail_towrite); 414 } 415 static DEVICE_ATTR_RO(in_write_bytes_avail); 416 417 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */ 418 static struct attribute *vmbus_attrs[] = { 419 &dev_attr_id.attr, 420 &dev_attr_state.attr, 421 &dev_attr_monitor_id.attr, 422 &dev_attr_class_id.attr, 423 &dev_attr_device_id.attr, 424 &dev_attr_modalias.attr, 425 &dev_attr_server_monitor_pending.attr, 426 &dev_attr_client_monitor_pending.attr, 427 &dev_attr_server_monitor_latency.attr, 428 &dev_attr_client_monitor_latency.attr, 429 &dev_attr_server_monitor_conn_id.attr, 430 &dev_attr_client_monitor_conn_id.attr, 431 &dev_attr_out_intr_mask.attr, 432 &dev_attr_out_read_index.attr, 433 &dev_attr_out_write_index.attr, 434 &dev_attr_out_read_bytes_avail.attr, 435 &dev_attr_out_write_bytes_avail.attr, 436 &dev_attr_in_intr_mask.attr, 437 &dev_attr_in_read_index.attr, 438 &dev_attr_in_write_index.attr, 439 &dev_attr_in_read_bytes_avail.attr, 440 &dev_attr_in_write_bytes_avail.attr, 441 NULL, 442 }; 443 ATTRIBUTE_GROUPS(vmbus); 444 445 /* 446 * vmbus_uevent - add uevent for our device 447 * 448 * This routine is invoked when a device is added or removed on the vmbus to 449 * generate a uevent to udev in the userspace. The udev will then look at its 450 * rule and the uevent generated here to load the appropriate driver 451 * 452 * The alias string will be of the form vmbus:guid where guid is the string 453 * representation of the device guid (each byte of the guid will be 454 * represented with two hex characters. 455 */ 456 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env) 457 { 458 struct hv_device *dev = device_to_hv_device(device); 459 int ret; 460 char alias_name[VMBUS_ALIAS_LEN + 1]; 461 462 print_alias_name(dev, alias_name); 463 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name); 464 return ret; 465 } 466 467 static const uuid_le null_guid; 468 469 static inline bool is_null_guid(const __u8 *guid) 470 { 471 if (memcmp(guid, &null_guid, sizeof(uuid_le))) 472 return false; 473 return true; 474 } 475 476 /* 477 * Return a matching hv_vmbus_device_id pointer. 478 * If there is no match, return NULL. 479 */ 480 static const struct hv_vmbus_device_id *hv_vmbus_get_id( 481 const struct hv_vmbus_device_id *id, 482 const __u8 *guid) 483 { 484 for (; !is_null_guid(id->guid); id++) 485 if (!memcmp(&id->guid, guid, sizeof(uuid_le))) 486 return id; 487 488 return NULL; 489 } 490 491 492 493 /* 494 * vmbus_match - Attempt to match the specified device to the specified driver 495 */ 496 static int vmbus_match(struct device *device, struct device_driver *driver) 497 { 498 struct hv_driver *drv = drv_to_hv_drv(driver); 499 struct hv_device *hv_dev = device_to_hv_device(device); 500 501 if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b)) 502 return 1; 503 504 return 0; 505 } 506 507 /* 508 * vmbus_probe - Add the new vmbus's child device 509 */ 510 static int vmbus_probe(struct device *child_device) 511 { 512 int ret = 0; 513 struct hv_driver *drv = 514 drv_to_hv_drv(child_device->driver); 515 struct hv_device *dev = device_to_hv_device(child_device); 516 const struct hv_vmbus_device_id *dev_id; 517 518 dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b); 519 if (drv->probe) { 520 ret = drv->probe(dev, dev_id); 521 if (ret != 0) 522 pr_err("probe failed for device %s (%d)\n", 523 dev_name(child_device), ret); 524 525 } else { 526 pr_err("probe not set for driver %s\n", 527 dev_name(child_device)); 528 ret = -ENODEV; 529 } 530 return ret; 531 } 532 533 /* 534 * vmbus_remove - Remove a vmbus device 535 */ 536 static int vmbus_remove(struct device *child_device) 537 { 538 struct hv_driver *drv; 539 struct hv_device *dev = device_to_hv_device(child_device); 540 u32 relid = dev->channel->offermsg.child_relid; 541 542 if (child_device->driver) { 543 drv = drv_to_hv_drv(child_device->driver); 544 if (drv->remove) 545 drv->remove(dev); 546 else { 547 hv_process_channel_removal(dev->channel, relid); 548 pr_err("remove not set for driver %s\n", 549 dev_name(child_device)); 550 } 551 } else { 552 /* 553 * We don't have a driver for this device; deal with the 554 * rescind message by removing the channel. 555 */ 556 hv_process_channel_removal(dev->channel, relid); 557 } 558 559 return 0; 560 } 561 562 563 /* 564 * vmbus_shutdown - Shutdown a vmbus device 565 */ 566 static void vmbus_shutdown(struct device *child_device) 567 { 568 struct hv_driver *drv; 569 struct hv_device *dev = device_to_hv_device(child_device); 570 571 572 /* The device may not be attached yet */ 573 if (!child_device->driver) 574 return; 575 576 drv = drv_to_hv_drv(child_device->driver); 577 578 if (drv->shutdown) 579 drv->shutdown(dev); 580 581 return; 582 } 583 584 585 /* 586 * vmbus_device_release - Final callback release of the vmbus child device 587 */ 588 static void vmbus_device_release(struct device *device) 589 { 590 struct hv_device *hv_dev = device_to_hv_device(device); 591 592 kfree(hv_dev); 593 594 } 595 596 /* The one and only one */ 597 static struct bus_type hv_bus = { 598 .name = "vmbus", 599 .match = vmbus_match, 600 .shutdown = vmbus_shutdown, 601 .remove = vmbus_remove, 602 .probe = vmbus_probe, 603 .uevent = vmbus_uevent, 604 .dev_groups = vmbus_groups, 605 }; 606 607 struct onmessage_work_context { 608 struct work_struct work; 609 struct hv_message msg; 610 }; 611 612 static void vmbus_onmessage_work(struct work_struct *work) 613 { 614 struct onmessage_work_context *ctx; 615 616 /* Do not process messages if we're in DISCONNECTED state */ 617 if (vmbus_connection.conn_state == DISCONNECTED) 618 return; 619 620 ctx = container_of(work, struct onmessage_work_context, 621 work); 622 vmbus_onmessage(&ctx->msg); 623 kfree(ctx); 624 } 625 626 static void hv_process_timer_expiration(struct hv_message *msg, int cpu) 627 { 628 struct clock_event_device *dev = hv_context.clk_evt[cpu]; 629 630 if (dev->event_handler) 631 dev->event_handler(dev); 632 633 msg->header.message_type = HVMSG_NONE; 634 635 /* 636 * Make sure the write to MessageType (ie set to 637 * HVMSG_NONE) happens before we read the 638 * MessagePending and EOMing. Otherwise, the EOMing 639 * will not deliver any more messages since there is 640 * no empty slot 641 */ 642 mb(); 643 644 if (msg->header.message_flags.msg_pending) { 645 /* 646 * This will cause message queue rescan to 647 * possibly deliver another msg from the 648 * hypervisor 649 */ 650 wrmsrl(HV_X64_MSR_EOM, 0); 651 } 652 } 653 654 static void vmbus_on_msg_dpc(unsigned long data) 655 { 656 int cpu = smp_processor_id(); 657 void *page_addr = hv_context.synic_message_page[cpu]; 658 struct hv_message *msg = (struct hv_message *)page_addr + 659 VMBUS_MESSAGE_SINT; 660 struct vmbus_channel_message_header *hdr; 661 struct vmbus_channel_message_table_entry *entry; 662 struct onmessage_work_context *ctx; 663 664 while (1) { 665 if (msg->header.message_type == HVMSG_NONE) 666 /* no msg */ 667 break; 668 669 hdr = (struct vmbus_channel_message_header *)msg->u.payload; 670 671 if (hdr->msgtype >= CHANNELMSG_COUNT) { 672 WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype); 673 goto msg_handled; 674 } 675 676 entry = &channel_message_table[hdr->msgtype]; 677 if (entry->handler_type == VMHT_BLOCKING) { 678 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC); 679 if (ctx == NULL) 680 continue; 681 682 INIT_WORK(&ctx->work, vmbus_onmessage_work); 683 memcpy(&ctx->msg, msg, sizeof(*msg)); 684 685 queue_work(vmbus_connection.work_queue, &ctx->work); 686 } else 687 entry->message_handler(hdr); 688 689 msg_handled: 690 msg->header.message_type = HVMSG_NONE; 691 692 /* 693 * Make sure the write to MessageType (ie set to 694 * HVMSG_NONE) happens before we read the 695 * MessagePending and EOMing. Otherwise, the EOMing 696 * will not deliver any more messages since there is 697 * no empty slot 698 */ 699 mb(); 700 701 if (msg->header.message_flags.msg_pending) { 702 /* 703 * This will cause message queue rescan to 704 * possibly deliver another msg from the 705 * hypervisor 706 */ 707 wrmsrl(HV_X64_MSR_EOM, 0); 708 } 709 } 710 } 711 712 static void vmbus_isr(void) 713 { 714 int cpu = smp_processor_id(); 715 void *page_addr; 716 struct hv_message *msg; 717 union hv_synic_event_flags *event; 718 bool handled = false; 719 720 page_addr = hv_context.synic_event_page[cpu]; 721 if (page_addr == NULL) 722 return; 723 724 event = (union hv_synic_event_flags *)page_addr + 725 VMBUS_MESSAGE_SINT; 726 /* 727 * Check for events before checking for messages. This is the order 728 * in which events and messages are checked in Windows guests on 729 * Hyper-V, and the Windows team suggested we do the same. 730 */ 731 732 if ((vmbus_proto_version == VERSION_WS2008) || 733 (vmbus_proto_version == VERSION_WIN7)) { 734 735 /* Since we are a child, we only need to check bit 0 */ 736 if (sync_test_and_clear_bit(0, 737 (unsigned long *) &event->flags32[0])) { 738 handled = true; 739 } 740 } else { 741 /* 742 * Our host is win8 or above. The signaling mechanism 743 * has changed and we can directly look at the event page. 744 * If bit n is set then we have an interrup on the channel 745 * whose id is n. 746 */ 747 handled = true; 748 } 749 750 if (handled) 751 tasklet_schedule(hv_context.event_dpc[cpu]); 752 753 754 page_addr = hv_context.synic_message_page[cpu]; 755 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT; 756 757 /* Check if there are actual msgs to be processed */ 758 if (msg->header.message_type != HVMSG_NONE) { 759 if (msg->header.message_type == HVMSG_TIMER_EXPIRED) 760 hv_process_timer_expiration(msg, cpu); 761 else 762 tasklet_schedule(&msg_dpc); 763 } 764 } 765 766 #ifdef CONFIG_HOTPLUG_CPU 767 static int hyperv_cpu_disable(void) 768 { 769 return -ENOSYS; 770 } 771 772 static void hv_cpu_hotplug_quirk(bool vmbus_loaded) 773 { 774 static void *previous_cpu_disable; 775 776 /* 777 * Offlining a CPU when running on newer hypervisors (WS2012R2, Win8, 778 * ...) is not supported at this moment as channel interrupts are 779 * distributed across all of them. 780 */ 781 782 if ((vmbus_proto_version == VERSION_WS2008) || 783 (vmbus_proto_version == VERSION_WIN7)) 784 return; 785 786 if (vmbus_loaded) { 787 previous_cpu_disable = smp_ops.cpu_disable; 788 smp_ops.cpu_disable = hyperv_cpu_disable; 789 pr_notice("CPU offlining is not supported by hypervisor\n"); 790 } else if (previous_cpu_disable) 791 smp_ops.cpu_disable = previous_cpu_disable; 792 } 793 #else 794 static void hv_cpu_hotplug_quirk(bool vmbus_loaded) 795 { 796 } 797 #endif 798 799 /* 800 * vmbus_bus_init -Main vmbus driver initialization routine. 801 * 802 * Here, we 803 * - initialize the vmbus driver context 804 * - invoke the vmbus hv main init routine 805 * - get the irq resource 806 * - retrieve the channel offers 807 */ 808 static int vmbus_bus_init(int irq) 809 { 810 int ret; 811 812 /* Hypervisor initialization...setup hypercall page..etc */ 813 ret = hv_init(); 814 if (ret != 0) { 815 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret); 816 return ret; 817 } 818 819 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0); 820 821 ret = bus_register(&hv_bus); 822 if (ret) 823 goto err_cleanup; 824 825 hv_setup_vmbus_irq(vmbus_isr); 826 827 ret = hv_synic_alloc(); 828 if (ret) 829 goto err_alloc; 830 /* 831 * Initialize the per-cpu interrupt state and 832 * connect to the host. 833 */ 834 on_each_cpu(hv_synic_init, NULL, 1); 835 ret = vmbus_connect(); 836 if (ret) 837 goto err_alloc; 838 839 hv_cpu_hotplug_quirk(true); 840 841 /* 842 * Only register if the crash MSRs are available 843 */ 844 if (ms_hyperv.features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) { 845 atomic_notifier_chain_register(&panic_notifier_list, 846 &hyperv_panic_block); 847 } 848 849 vmbus_request_offers(); 850 851 return 0; 852 853 err_alloc: 854 hv_synic_free(); 855 hv_remove_vmbus_irq(); 856 857 bus_unregister(&hv_bus); 858 859 err_cleanup: 860 hv_cleanup(); 861 862 return ret; 863 } 864 865 /** 866 * __vmbus_child_driver_register - Register a vmbus's driver 867 * @drv: Pointer to driver structure you want to register 868 * @owner: owner module of the drv 869 * @mod_name: module name string 870 * 871 * Registers the given driver with Linux through the 'driver_register()' call 872 * and sets up the hyper-v vmbus handling for this driver. 873 * It will return the state of the 'driver_register()' call. 874 * 875 */ 876 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name) 877 { 878 int ret; 879 880 pr_info("registering driver %s\n", hv_driver->name); 881 882 ret = vmbus_exists(); 883 if (ret < 0) 884 return ret; 885 886 hv_driver->driver.name = hv_driver->name; 887 hv_driver->driver.owner = owner; 888 hv_driver->driver.mod_name = mod_name; 889 hv_driver->driver.bus = &hv_bus; 890 891 ret = driver_register(&hv_driver->driver); 892 893 return ret; 894 } 895 EXPORT_SYMBOL_GPL(__vmbus_driver_register); 896 897 /** 898 * vmbus_driver_unregister() - Unregister a vmbus's driver 899 * @drv: Pointer to driver structure you want to un-register 900 * 901 * Un-register the given driver that was previous registered with a call to 902 * vmbus_driver_register() 903 */ 904 void vmbus_driver_unregister(struct hv_driver *hv_driver) 905 { 906 pr_info("unregistering driver %s\n", hv_driver->name); 907 908 if (!vmbus_exists()) 909 driver_unregister(&hv_driver->driver); 910 } 911 EXPORT_SYMBOL_GPL(vmbus_driver_unregister); 912 913 /* 914 * vmbus_device_create - Creates and registers a new child device 915 * on the vmbus. 916 */ 917 struct hv_device *vmbus_device_create(const uuid_le *type, 918 const uuid_le *instance, 919 struct vmbus_channel *channel) 920 { 921 struct hv_device *child_device_obj; 922 923 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL); 924 if (!child_device_obj) { 925 pr_err("Unable to allocate device object for child device\n"); 926 return NULL; 927 } 928 929 child_device_obj->channel = channel; 930 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le)); 931 memcpy(&child_device_obj->dev_instance, instance, 932 sizeof(uuid_le)); 933 934 935 return child_device_obj; 936 } 937 938 /* 939 * vmbus_device_register - Register the child device 940 */ 941 int vmbus_device_register(struct hv_device *child_device_obj) 942 { 943 int ret = 0; 944 945 dev_set_name(&child_device_obj->device, "vmbus_%d", 946 child_device_obj->channel->id); 947 948 child_device_obj->device.bus = &hv_bus; 949 child_device_obj->device.parent = &hv_acpi_dev->dev; 950 child_device_obj->device.release = vmbus_device_release; 951 952 /* 953 * Register with the LDM. This will kick off the driver/device 954 * binding...which will eventually call vmbus_match() and vmbus_probe() 955 */ 956 ret = device_register(&child_device_obj->device); 957 958 if (ret) 959 pr_err("Unable to register child device\n"); 960 else 961 pr_debug("child device %s registered\n", 962 dev_name(&child_device_obj->device)); 963 964 return ret; 965 } 966 967 /* 968 * vmbus_device_unregister - Remove the specified child device 969 * from the vmbus. 970 */ 971 void vmbus_device_unregister(struct hv_device *device_obj) 972 { 973 pr_debug("child device %s unregistered\n", 974 dev_name(&device_obj->device)); 975 976 /* 977 * Kick off the process of unregistering the device. 978 * This will call vmbus_remove() and eventually vmbus_device_release() 979 */ 980 device_unregister(&device_obj->device); 981 } 982 983 984 /* 985 * VMBUS is an acpi enumerated device. Get the the information we 986 * need from DSDT. 987 */ 988 989 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx) 990 { 991 switch (res->type) { 992 case ACPI_RESOURCE_TYPE_IRQ: 993 irq = res->data.irq.interrupts[0]; 994 break; 995 996 case ACPI_RESOURCE_TYPE_ADDRESS64: 997 hyperv_mmio.start = res->data.address64.address.minimum; 998 hyperv_mmio.end = res->data.address64.address.maximum; 999 break; 1000 } 1001 1002 return AE_OK; 1003 } 1004 1005 static int vmbus_acpi_add(struct acpi_device *device) 1006 { 1007 acpi_status result; 1008 int ret_val = -ENODEV; 1009 1010 hv_acpi_dev = device; 1011 1012 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS, 1013 vmbus_walk_resources, NULL); 1014 1015 if (ACPI_FAILURE(result)) 1016 goto acpi_walk_err; 1017 /* 1018 * The parent of the vmbus acpi device (Gen2 firmware) is the VMOD that 1019 * has the mmio ranges. Get that. 1020 */ 1021 if (device->parent) { 1022 result = acpi_walk_resources(device->parent->handle, 1023 METHOD_NAME__CRS, 1024 vmbus_walk_resources, NULL); 1025 1026 if (ACPI_FAILURE(result)) 1027 goto acpi_walk_err; 1028 if (hyperv_mmio.start && hyperv_mmio.end) 1029 request_resource(&iomem_resource, &hyperv_mmio); 1030 } 1031 ret_val = 0; 1032 1033 acpi_walk_err: 1034 complete(&probe_event); 1035 return ret_val; 1036 } 1037 1038 static const struct acpi_device_id vmbus_acpi_device_ids[] = { 1039 {"VMBUS", 0}, 1040 {"VMBus", 0}, 1041 {"", 0}, 1042 }; 1043 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids); 1044 1045 static struct acpi_driver vmbus_acpi_driver = { 1046 .name = "vmbus", 1047 .ids = vmbus_acpi_device_ids, 1048 .ops = { 1049 .add = vmbus_acpi_add, 1050 }, 1051 }; 1052 1053 static int __init hv_acpi_init(void) 1054 { 1055 int ret, t; 1056 1057 if (x86_hyper != &x86_hyper_ms_hyperv) 1058 return -ENODEV; 1059 1060 init_completion(&probe_event); 1061 1062 /* 1063 * Get irq resources first. 1064 */ 1065 ret = acpi_bus_register_driver(&vmbus_acpi_driver); 1066 1067 if (ret) 1068 return ret; 1069 1070 t = wait_for_completion_timeout(&probe_event, 5*HZ); 1071 if (t == 0) { 1072 ret = -ETIMEDOUT; 1073 goto cleanup; 1074 } 1075 1076 if (irq <= 0) { 1077 ret = -ENODEV; 1078 goto cleanup; 1079 } 1080 1081 ret = vmbus_bus_init(irq); 1082 if (ret) 1083 goto cleanup; 1084 1085 return 0; 1086 1087 cleanup: 1088 acpi_bus_unregister_driver(&vmbus_acpi_driver); 1089 hv_acpi_dev = NULL; 1090 return ret; 1091 } 1092 1093 static void __exit vmbus_exit(void) 1094 { 1095 int cpu; 1096 1097 vmbus_connection.conn_state = DISCONNECTED; 1098 hv_synic_clockevents_cleanup(); 1099 hv_remove_vmbus_irq(); 1100 vmbus_free_channels(); 1101 bus_unregister(&hv_bus); 1102 hv_cleanup(); 1103 for_each_online_cpu(cpu) 1104 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1); 1105 acpi_bus_unregister_driver(&vmbus_acpi_driver); 1106 hv_cpu_hotplug_quirk(false); 1107 vmbus_disconnect(); 1108 } 1109 1110 1111 MODULE_LICENSE("GPL"); 1112 1113 subsys_initcall(hv_acpi_init); 1114 module_exit(vmbus_exit); 1115