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 */ 21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 22 23 #include <linux/kernel.h> 24 #include <linux/sched.h> 25 #include <linux/wait.h> 26 #include <linux/mm.h> 27 #include <linux/slab.h> 28 #include <linux/list.h> 29 #include <linux/module.h> 30 #include <linux/completion.h> 31 #include <linux/hyperv.h> 32 33 #include "hyperv_vmbus.h" 34 35 static void init_vp_index(struct vmbus_channel *channel, u16 dev_type); 36 37 static const struct vmbus_device vmbus_devs[] = { 38 /* IDE */ 39 { .dev_type = HV_IDE, 40 HV_IDE_GUID, 41 .perf_device = true, 42 }, 43 44 /* SCSI */ 45 { .dev_type = HV_SCSI, 46 HV_SCSI_GUID, 47 .perf_device = true, 48 }, 49 50 /* Fibre Channel */ 51 { .dev_type = HV_FC, 52 HV_SYNTHFC_GUID, 53 .perf_device = true, 54 }, 55 56 /* Synthetic NIC */ 57 { .dev_type = HV_NIC, 58 HV_NIC_GUID, 59 .perf_device = true, 60 }, 61 62 /* Network Direct */ 63 { .dev_type = HV_ND, 64 HV_ND_GUID, 65 .perf_device = true, 66 }, 67 68 /* PCIE */ 69 { .dev_type = HV_PCIE, 70 HV_PCIE_GUID, 71 .perf_device = true, 72 }, 73 74 /* Synthetic Frame Buffer */ 75 { .dev_type = HV_FB, 76 HV_SYNTHVID_GUID, 77 .perf_device = false, 78 }, 79 80 /* Synthetic Keyboard */ 81 { .dev_type = HV_KBD, 82 HV_KBD_GUID, 83 .perf_device = false, 84 }, 85 86 /* Synthetic MOUSE */ 87 { .dev_type = HV_MOUSE, 88 HV_MOUSE_GUID, 89 .perf_device = false, 90 }, 91 92 /* KVP */ 93 { .dev_type = HV_KVP, 94 HV_KVP_GUID, 95 .perf_device = false, 96 }, 97 98 /* Time Synch */ 99 { .dev_type = HV_TS, 100 HV_TS_GUID, 101 .perf_device = false, 102 }, 103 104 /* Heartbeat */ 105 { .dev_type = HV_HB, 106 HV_HEART_BEAT_GUID, 107 .perf_device = false, 108 }, 109 110 /* Shutdown */ 111 { .dev_type = HV_SHUTDOWN, 112 HV_SHUTDOWN_GUID, 113 .perf_device = false, 114 }, 115 116 /* File copy */ 117 { .dev_type = HV_FCOPY, 118 HV_FCOPY_GUID, 119 .perf_device = false, 120 }, 121 122 /* Backup */ 123 { .dev_type = HV_BACKUP, 124 HV_VSS_GUID, 125 .perf_device = false, 126 }, 127 128 /* Dynamic Memory */ 129 { .dev_type = HV_DM, 130 HV_DM_GUID, 131 .perf_device = false, 132 }, 133 134 /* Unknown GUID */ 135 { .dev_type = HV_UNKOWN, 136 .perf_device = false, 137 }, 138 }; 139 140 static u16 hv_get_dev_type(const uuid_le *guid) 141 { 142 u16 i; 143 144 for (i = HV_IDE; i < HV_UNKOWN; i++) { 145 if (!uuid_le_cmp(*guid, vmbus_devs[i].guid)) 146 return i; 147 } 148 pr_info("Unknown GUID: %pUl\n", guid); 149 return i; 150 } 151 152 /** 153 * vmbus_prep_negotiate_resp() - Create default response for Hyper-V Negotiate message 154 * @icmsghdrp: Pointer to msg header structure 155 * @icmsg_negotiate: Pointer to negotiate message structure 156 * @buf: Raw buffer channel data 157 * 158 * @icmsghdrp is of type &struct icmsg_hdr. 159 * @negop is of type &struct icmsg_negotiate. 160 * Set up and fill in default negotiate response message. 161 * 162 * The fw_version specifies the framework version that 163 * we can support and srv_version specifies the service 164 * version we can support. 165 * 166 * Mainly used by Hyper-V drivers. 167 */ 168 bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, 169 struct icmsg_negotiate *negop, u8 *buf, 170 int fw_version, int srv_version) 171 { 172 int icframe_major, icframe_minor; 173 int icmsg_major, icmsg_minor; 174 int fw_major, fw_minor; 175 int srv_major, srv_minor; 176 int i; 177 bool found_match = false; 178 179 icmsghdrp->icmsgsize = 0x10; 180 fw_major = (fw_version >> 16); 181 fw_minor = (fw_version & 0xFFFF); 182 183 srv_major = (srv_version >> 16); 184 srv_minor = (srv_version & 0xFFFF); 185 186 negop = (struct icmsg_negotiate *)&buf[ 187 sizeof(struct vmbuspipe_hdr) + 188 sizeof(struct icmsg_hdr)]; 189 190 icframe_major = negop->icframe_vercnt; 191 icframe_minor = 0; 192 193 icmsg_major = negop->icmsg_vercnt; 194 icmsg_minor = 0; 195 196 /* 197 * Select the framework version number we will 198 * support. 199 */ 200 201 for (i = 0; i < negop->icframe_vercnt; i++) { 202 if ((negop->icversion_data[i].major == fw_major) && 203 (negop->icversion_data[i].minor == fw_minor)) { 204 icframe_major = negop->icversion_data[i].major; 205 icframe_minor = negop->icversion_data[i].minor; 206 found_match = true; 207 } 208 } 209 210 if (!found_match) 211 goto fw_error; 212 213 found_match = false; 214 215 for (i = negop->icframe_vercnt; 216 (i < negop->icframe_vercnt + negop->icmsg_vercnt); i++) { 217 if ((negop->icversion_data[i].major == srv_major) && 218 (negop->icversion_data[i].minor == srv_minor)) { 219 icmsg_major = negop->icversion_data[i].major; 220 icmsg_minor = negop->icversion_data[i].minor; 221 found_match = true; 222 } 223 } 224 225 /* 226 * Respond with the framework and service 227 * version numbers we can support. 228 */ 229 230 fw_error: 231 if (!found_match) { 232 negop->icframe_vercnt = 0; 233 negop->icmsg_vercnt = 0; 234 } else { 235 negop->icframe_vercnt = 1; 236 negop->icmsg_vercnt = 1; 237 } 238 239 negop->icversion_data[0].major = icframe_major; 240 negop->icversion_data[0].minor = icframe_minor; 241 negop->icversion_data[1].major = icmsg_major; 242 negop->icversion_data[1].minor = icmsg_minor; 243 return found_match; 244 } 245 246 EXPORT_SYMBOL_GPL(vmbus_prep_negotiate_resp); 247 248 /* 249 * alloc_channel - Allocate and initialize a vmbus channel object 250 */ 251 static struct vmbus_channel *alloc_channel(void) 252 { 253 static atomic_t chan_num = ATOMIC_INIT(0); 254 struct vmbus_channel *channel; 255 256 channel = kzalloc(sizeof(*channel), GFP_ATOMIC); 257 if (!channel) 258 return NULL; 259 260 channel->id = atomic_inc_return(&chan_num); 261 spin_lock_init(&channel->inbound_lock); 262 spin_lock_init(&channel->lock); 263 264 INIT_LIST_HEAD(&channel->sc_list); 265 INIT_LIST_HEAD(&channel->percpu_list); 266 267 return channel; 268 } 269 270 /* 271 * free_channel - Release the resources used by the vmbus channel object 272 */ 273 static void free_channel(struct vmbus_channel *channel) 274 { 275 kfree(channel); 276 } 277 278 static void percpu_channel_enq(void *arg) 279 { 280 struct vmbus_channel *channel = arg; 281 int cpu = smp_processor_id(); 282 283 list_add_tail(&channel->percpu_list, &hv_context.percpu_list[cpu]); 284 } 285 286 static void percpu_channel_deq(void *arg) 287 { 288 struct vmbus_channel *channel = arg; 289 290 list_del(&channel->percpu_list); 291 } 292 293 294 static void vmbus_release_relid(u32 relid) 295 { 296 struct vmbus_channel_relid_released msg; 297 298 memset(&msg, 0, sizeof(struct vmbus_channel_relid_released)); 299 msg.child_relid = relid; 300 msg.header.msgtype = CHANNELMSG_RELID_RELEASED; 301 vmbus_post_msg(&msg, sizeof(struct vmbus_channel_relid_released)); 302 } 303 304 void hv_process_channel_removal(struct vmbus_channel *channel, u32 relid) 305 { 306 unsigned long flags; 307 struct vmbus_channel *primary_channel; 308 309 vmbus_release_relid(relid); 310 311 BUG_ON(!channel->rescind); 312 313 if (channel->target_cpu != get_cpu()) { 314 put_cpu(); 315 smp_call_function_single(channel->target_cpu, 316 percpu_channel_deq, channel, true); 317 } else { 318 percpu_channel_deq(channel); 319 put_cpu(); 320 } 321 322 if (channel->primary_channel == NULL) { 323 mutex_lock(&vmbus_connection.channel_mutex); 324 list_del(&channel->listentry); 325 mutex_unlock(&vmbus_connection.channel_mutex); 326 327 primary_channel = channel; 328 } else { 329 primary_channel = channel->primary_channel; 330 spin_lock_irqsave(&primary_channel->lock, flags); 331 list_del(&channel->sc_list); 332 primary_channel->num_sc--; 333 spin_unlock_irqrestore(&primary_channel->lock, flags); 334 } 335 336 /* 337 * We need to free the bit for init_vp_index() to work in the case 338 * of sub-channel, when we reload drivers like hv_netvsc. 339 */ 340 cpumask_clear_cpu(channel->target_cpu, 341 &primary_channel->alloced_cpus_in_node); 342 343 free_channel(channel); 344 } 345 346 void vmbus_free_channels(void) 347 { 348 struct vmbus_channel *channel, *tmp; 349 350 list_for_each_entry_safe(channel, tmp, &vmbus_connection.chn_list, 351 listentry) { 352 /* hv_process_channel_removal() needs this */ 353 channel->rescind = true; 354 355 vmbus_device_unregister(channel->device_obj); 356 } 357 } 358 359 /* 360 * vmbus_process_offer - Process the offer by creating a channel/device 361 * associated with this offer 362 */ 363 static void vmbus_process_offer(struct vmbus_channel *newchannel) 364 { 365 struct vmbus_channel *channel; 366 bool fnew = true; 367 unsigned long flags; 368 u16 dev_type; 369 370 /* Make sure this is a new offer */ 371 mutex_lock(&vmbus_connection.channel_mutex); 372 373 list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) { 374 if (!uuid_le_cmp(channel->offermsg.offer.if_type, 375 newchannel->offermsg.offer.if_type) && 376 !uuid_le_cmp(channel->offermsg.offer.if_instance, 377 newchannel->offermsg.offer.if_instance)) { 378 fnew = false; 379 break; 380 } 381 } 382 383 if (fnew) 384 list_add_tail(&newchannel->listentry, 385 &vmbus_connection.chn_list); 386 387 mutex_unlock(&vmbus_connection.channel_mutex); 388 389 if (!fnew) { 390 /* 391 * Check to see if this is a sub-channel. 392 */ 393 if (newchannel->offermsg.offer.sub_channel_index != 0) { 394 /* 395 * Process the sub-channel. 396 */ 397 newchannel->primary_channel = channel; 398 spin_lock_irqsave(&channel->lock, flags); 399 list_add_tail(&newchannel->sc_list, &channel->sc_list); 400 channel->num_sc++; 401 spin_unlock_irqrestore(&channel->lock, flags); 402 } else 403 goto err_free_chan; 404 } 405 406 dev_type = hv_get_dev_type(&newchannel->offermsg.offer.if_type); 407 408 init_vp_index(newchannel, dev_type); 409 410 if (newchannel->target_cpu != get_cpu()) { 411 put_cpu(); 412 smp_call_function_single(newchannel->target_cpu, 413 percpu_channel_enq, 414 newchannel, true); 415 } else { 416 percpu_channel_enq(newchannel); 417 put_cpu(); 418 } 419 420 /* 421 * This state is used to indicate a successful open 422 * so that when we do close the channel normally, we 423 * can cleanup properly 424 */ 425 newchannel->state = CHANNEL_OPEN_STATE; 426 427 if (!fnew) { 428 if (channel->sc_creation_callback != NULL) 429 channel->sc_creation_callback(newchannel); 430 return; 431 } 432 433 /* 434 * Start the process of binding this offer to the driver 435 * We need to set the DeviceObject field before calling 436 * vmbus_child_dev_add() 437 */ 438 newchannel->device_obj = vmbus_device_create( 439 &newchannel->offermsg.offer.if_type, 440 &newchannel->offermsg.offer.if_instance, 441 newchannel); 442 if (!newchannel->device_obj) 443 goto err_deq_chan; 444 445 newchannel->device_obj->device_id = dev_type; 446 /* 447 * Add the new device to the bus. This will kick off device-driver 448 * binding which eventually invokes the device driver's AddDevice() 449 * method. 450 */ 451 if (vmbus_device_register(newchannel->device_obj) != 0) { 452 pr_err("unable to add child device object (relid %d)\n", 453 newchannel->offermsg.child_relid); 454 kfree(newchannel->device_obj); 455 goto err_deq_chan; 456 } 457 return; 458 459 err_deq_chan: 460 vmbus_release_relid(newchannel->offermsg.child_relid); 461 462 mutex_lock(&vmbus_connection.channel_mutex); 463 list_del(&newchannel->listentry); 464 mutex_unlock(&vmbus_connection.channel_mutex); 465 466 if (newchannel->target_cpu != get_cpu()) { 467 put_cpu(); 468 smp_call_function_single(newchannel->target_cpu, 469 percpu_channel_deq, newchannel, true); 470 } else { 471 percpu_channel_deq(newchannel); 472 put_cpu(); 473 } 474 475 err_free_chan: 476 free_channel(newchannel); 477 } 478 479 /* 480 * We use this state to statically distribute the channel interrupt load. 481 */ 482 static int next_numa_node_id; 483 484 /* 485 * Starting with Win8, we can statically distribute the incoming 486 * channel interrupt load by binding a channel to VCPU. 487 * We do this in a hierarchical fashion: 488 * First distribute the primary channels across available NUMA nodes 489 * and then distribute the subchannels amongst the CPUs in the NUMA 490 * node assigned to the primary channel. 491 * 492 * For pre-win8 hosts or non-performance critical channels we assign the 493 * first CPU in the first NUMA node. 494 */ 495 static void init_vp_index(struct vmbus_channel *channel, u16 dev_type) 496 { 497 u32 cur_cpu; 498 bool perf_chn = vmbus_devs[dev_type].perf_device; 499 struct vmbus_channel *primary = channel->primary_channel; 500 int next_node; 501 struct cpumask available_mask; 502 struct cpumask *alloced_mask; 503 504 if ((vmbus_proto_version == VERSION_WS2008) || 505 (vmbus_proto_version == VERSION_WIN7) || (!perf_chn)) { 506 /* 507 * Prior to win8, all channel interrupts are 508 * delivered on cpu 0. 509 * Also if the channel is not a performance critical 510 * channel, bind it to cpu 0. 511 */ 512 channel->numa_node = 0; 513 channel->target_cpu = 0; 514 channel->target_vp = hv_context.vp_index[0]; 515 return; 516 } 517 518 /* 519 * We distribute primary channels evenly across all the available 520 * NUMA nodes and within the assigned NUMA node we will assign the 521 * first available CPU to the primary channel. 522 * The sub-channels will be assigned to the CPUs available in the 523 * NUMA node evenly. 524 */ 525 if (!primary) { 526 while (true) { 527 next_node = next_numa_node_id++; 528 if (next_node == nr_node_ids) 529 next_node = next_numa_node_id = 0; 530 if (cpumask_empty(cpumask_of_node(next_node))) 531 continue; 532 break; 533 } 534 channel->numa_node = next_node; 535 primary = channel; 536 } 537 alloced_mask = &hv_context.hv_numa_map[primary->numa_node]; 538 539 if (cpumask_weight(alloced_mask) == 540 cpumask_weight(cpumask_of_node(primary->numa_node))) { 541 /* 542 * We have cycled through all the CPUs in the node; 543 * reset the alloced map. 544 */ 545 cpumask_clear(alloced_mask); 546 } 547 548 cpumask_xor(&available_mask, alloced_mask, 549 cpumask_of_node(primary->numa_node)); 550 551 cur_cpu = -1; 552 while (true) { 553 cur_cpu = cpumask_next(cur_cpu, &available_mask); 554 if (cur_cpu >= nr_cpu_ids) { 555 cur_cpu = -1; 556 cpumask_copy(&available_mask, 557 cpumask_of_node(primary->numa_node)); 558 continue; 559 } 560 561 /* 562 * NOTE: in the case of sub-channel, we clear the sub-channel 563 * related bit(s) in primary->alloced_cpus_in_node in 564 * hv_process_channel_removal(), so when we reload drivers 565 * like hv_netvsc in SMP guest, here we're able to re-allocate 566 * bit from primary->alloced_cpus_in_node. 567 */ 568 if (!cpumask_test_cpu(cur_cpu, 569 &primary->alloced_cpus_in_node)) { 570 cpumask_set_cpu(cur_cpu, 571 &primary->alloced_cpus_in_node); 572 cpumask_set_cpu(cur_cpu, alloced_mask); 573 break; 574 } 575 } 576 577 channel->target_cpu = cur_cpu; 578 channel->target_vp = hv_context.vp_index[cur_cpu]; 579 } 580 581 /* 582 * vmbus_unload_response - Handler for the unload response. 583 */ 584 static void vmbus_unload_response(struct vmbus_channel_message_header *hdr) 585 { 586 /* 587 * This is a global event; just wakeup the waiting thread. 588 * Once we successfully unload, we can cleanup the monitor state. 589 */ 590 complete(&vmbus_connection.unload_event); 591 } 592 593 void vmbus_initiate_unload(void) 594 { 595 struct vmbus_channel_message_header hdr; 596 597 /* Pre-Win2012R2 hosts don't support reconnect */ 598 if (vmbus_proto_version < VERSION_WIN8_1) 599 return; 600 601 init_completion(&vmbus_connection.unload_event); 602 memset(&hdr, 0, sizeof(struct vmbus_channel_message_header)); 603 hdr.msgtype = CHANNELMSG_UNLOAD; 604 vmbus_post_msg(&hdr, sizeof(struct vmbus_channel_message_header)); 605 606 wait_for_completion(&vmbus_connection.unload_event); 607 } 608 609 /* 610 * vmbus_onoffer - Handler for channel offers from vmbus in parent partition. 611 * 612 */ 613 static void vmbus_onoffer(struct vmbus_channel_message_header *hdr) 614 { 615 struct vmbus_channel_offer_channel *offer; 616 struct vmbus_channel *newchannel; 617 618 offer = (struct vmbus_channel_offer_channel *)hdr; 619 620 /* Allocate the channel object and save this offer. */ 621 newchannel = alloc_channel(); 622 if (!newchannel) { 623 pr_err("Unable to allocate channel object\n"); 624 return; 625 } 626 627 /* 628 * By default we setup state to enable batched 629 * reading. A specific service can choose to 630 * disable this prior to opening the channel. 631 */ 632 newchannel->batched_reading = true; 633 634 /* 635 * Setup state for signalling the host. 636 */ 637 newchannel->sig_event = (struct hv_input_signal_event *) 638 (ALIGN((unsigned long) 639 &newchannel->sig_buf, 640 HV_HYPERCALL_PARAM_ALIGN)); 641 642 newchannel->sig_event->connectionid.asu32 = 0; 643 newchannel->sig_event->connectionid.u.id = VMBUS_EVENT_CONNECTION_ID; 644 newchannel->sig_event->flag_number = 0; 645 newchannel->sig_event->rsvdz = 0; 646 647 if (vmbus_proto_version != VERSION_WS2008) { 648 newchannel->is_dedicated_interrupt = 649 (offer->is_dedicated_interrupt != 0); 650 newchannel->sig_event->connectionid.u.id = 651 offer->connection_id; 652 } 653 654 memcpy(&newchannel->offermsg, offer, 655 sizeof(struct vmbus_channel_offer_channel)); 656 newchannel->monitor_grp = (u8)offer->monitorid / 32; 657 newchannel->monitor_bit = (u8)offer->monitorid % 32; 658 659 vmbus_process_offer(newchannel); 660 } 661 662 /* 663 * vmbus_onoffer_rescind - Rescind offer handler. 664 * 665 * We queue a work item to process this offer synchronously 666 */ 667 static void vmbus_onoffer_rescind(struct vmbus_channel_message_header *hdr) 668 { 669 struct vmbus_channel_rescind_offer *rescind; 670 struct vmbus_channel *channel; 671 unsigned long flags; 672 struct device *dev; 673 674 rescind = (struct vmbus_channel_rescind_offer *)hdr; 675 channel = relid2channel(rescind->child_relid); 676 677 if (channel == NULL) { 678 /* 679 * This is very impossible, because in 680 * vmbus_process_offer(), we have already invoked 681 * vmbus_release_relid() on error. 682 */ 683 return; 684 } 685 686 spin_lock_irqsave(&channel->lock, flags); 687 channel->rescind = true; 688 spin_unlock_irqrestore(&channel->lock, flags); 689 690 if (channel->device_obj) { 691 /* 692 * We will have to unregister this device from the 693 * driver core. 694 */ 695 dev = get_device(&channel->device_obj->device); 696 if (dev) { 697 vmbus_device_unregister(channel->device_obj); 698 put_device(dev); 699 } 700 } else { 701 hv_process_channel_removal(channel, 702 channel->offermsg.child_relid); 703 } 704 } 705 706 /* 707 * vmbus_onoffers_delivered - 708 * This is invoked when all offers have been delivered. 709 * 710 * Nothing to do here. 711 */ 712 static void vmbus_onoffers_delivered( 713 struct vmbus_channel_message_header *hdr) 714 { 715 } 716 717 /* 718 * vmbus_onopen_result - Open result handler. 719 * 720 * This is invoked when we received a response to our channel open request. 721 * Find the matching request, copy the response and signal the requesting 722 * thread. 723 */ 724 static void vmbus_onopen_result(struct vmbus_channel_message_header *hdr) 725 { 726 struct vmbus_channel_open_result *result; 727 struct vmbus_channel_msginfo *msginfo; 728 struct vmbus_channel_message_header *requestheader; 729 struct vmbus_channel_open_channel *openmsg; 730 unsigned long flags; 731 732 result = (struct vmbus_channel_open_result *)hdr; 733 734 /* 735 * Find the open msg, copy the result and signal/unblock the wait event 736 */ 737 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags); 738 739 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list, 740 msglistentry) { 741 requestheader = 742 (struct vmbus_channel_message_header *)msginfo->msg; 743 744 if (requestheader->msgtype == CHANNELMSG_OPENCHANNEL) { 745 openmsg = 746 (struct vmbus_channel_open_channel *)msginfo->msg; 747 if (openmsg->child_relid == result->child_relid && 748 openmsg->openid == result->openid) { 749 memcpy(&msginfo->response.open_result, 750 result, 751 sizeof( 752 struct vmbus_channel_open_result)); 753 complete(&msginfo->waitevent); 754 break; 755 } 756 } 757 } 758 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags); 759 } 760 761 /* 762 * vmbus_ongpadl_created - GPADL created handler. 763 * 764 * This is invoked when we received a response to our gpadl create request. 765 * Find the matching request, copy the response and signal the requesting 766 * thread. 767 */ 768 static void vmbus_ongpadl_created(struct vmbus_channel_message_header *hdr) 769 { 770 struct vmbus_channel_gpadl_created *gpadlcreated; 771 struct vmbus_channel_msginfo *msginfo; 772 struct vmbus_channel_message_header *requestheader; 773 struct vmbus_channel_gpadl_header *gpadlheader; 774 unsigned long flags; 775 776 gpadlcreated = (struct vmbus_channel_gpadl_created *)hdr; 777 778 /* 779 * Find the establish msg, copy the result and signal/unblock the wait 780 * event 781 */ 782 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags); 783 784 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list, 785 msglistentry) { 786 requestheader = 787 (struct vmbus_channel_message_header *)msginfo->msg; 788 789 if (requestheader->msgtype == CHANNELMSG_GPADL_HEADER) { 790 gpadlheader = 791 (struct vmbus_channel_gpadl_header *)requestheader; 792 793 if ((gpadlcreated->child_relid == 794 gpadlheader->child_relid) && 795 (gpadlcreated->gpadl == gpadlheader->gpadl)) { 796 memcpy(&msginfo->response.gpadl_created, 797 gpadlcreated, 798 sizeof( 799 struct vmbus_channel_gpadl_created)); 800 complete(&msginfo->waitevent); 801 break; 802 } 803 } 804 } 805 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags); 806 } 807 808 /* 809 * vmbus_ongpadl_torndown - GPADL torndown handler. 810 * 811 * This is invoked when we received a response to our gpadl teardown request. 812 * Find the matching request, copy the response and signal the requesting 813 * thread. 814 */ 815 static void vmbus_ongpadl_torndown( 816 struct vmbus_channel_message_header *hdr) 817 { 818 struct vmbus_channel_gpadl_torndown *gpadl_torndown; 819 struct vmbus_channel_msginfo *msginfo; 820 struct vmbus_channel_message_header *requestheader; 821 struct vmbus_channel_gpadl_teardown *gpadl_teardown; 822 unsigned long flags; 823 824 gpadl_torndown = (struct vmbus_channel_gpadl_torndown *)hdr; 825 826 /* 827 * Find the open msg, copy the result and signal/unblock the wait event 828 */ 829 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags); 830 831 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list, 832 msglistentry) { 833 requestheader = 834 (struct vmbus_channel_message_header *)msginfo->msg; 835 836 if (requestheader->msgtype == CHANNELMSG_GPADL_TEARDOWN) { 837 gpadl_teardown = 838 (struct vmbus_channel_gpadl_teardown *)requestheader; 839 840 if (gpadl_torndown->gpadl == gpadl_teardown->gpadl) { 841 memcpy(&msginfo->response.gpadl_torndown, 842 gpadl_torndown, 843 sizeof( 844 struct vmbus_channel_gpadl_torndown)); 845 complete(&msginfo->waitevent); 846 break; 847 } 848 } 849 } 850 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags); 851 } 852 853 /* 854 * vmbus_onversion_response - Version response handler 855 * 856 * This is invoked when we received a response to our initiate contact request. 857 * Find the matching request, copy the response and signal the requesting 858 * thread. 859 */ 860 static void vmbus_onversion_response( 861 struct vmbus_channel_message_header *hdr) 862 { 863 struct vmbus_channel_msginfo *msginfo; 864 struct vmbus_channel_message_header *requestheader; 865 struct vmbus_channel_version_response *version_response; 866 unsigned long flags; 867 868 version_response = (struct vmbus_channel_version_response *)hdr; 869 spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags); 870 871 list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list, 872 msglistentry) { 873 requestheader = 874 (struct vmbus_channel_message_header *)msginfo->msg; 875 876 if (requestheader->msgtype == 877 CHANNELMSG_INITIATE_CONTACT) { 878 memcpy(&msginfo->response.version_response, 879 version_response, 880 sizeof(struct vmbus_channel_version_response)); 881 complete(&msginfo->waitevent); 882 } 883 } 884 spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags); 885 } 886 887 /* Channel message dispatch table */ 888 struct vmbus_channel_message_table_entry 889 channel_message_table[CHANNELMSG_COUNT] = { 890 {CHANNELMSG_INVALID, 0, NULL}, 891 {CHANNELMSG_OFFERCHANNEL, 0, vmbus_onoffer}, 892 {CHANNELMSG_RESCIND_CHANNELOFFER, 0, vmbus_onoffer_rescind}, 893 {CHANNELMSG_REQUESTOFFERS, 0, NULL}, 894 {CHANNELMSG_ALLOFFERS_DELIVERED, 1, vmbus_onoffers_delivered}, 895 {CHANNELMSG_OPENCHANNEL, 0, NULL}, 896 {CHANNELMSG_OPENCHANNEL_RESULT, 1, vmbus_onopen_result}, 897 {CHANNELMSG_CLOSECHANNEL, 0, NULL}, 898 {CHANNELMSG_GPADL_HEADER, 0, NULL}, 899 {CHANNELMSG_GPADL_BODY, 0, NULL}, 900 {CHANNELMSG_GPADL_CREATED, 1, vmbus_ongpadl_created}, 901 {CHANNELMSG_GPADL_TEARDOWN, 0, NULL}, 902 {CHANNELMSG_GPADL_TORNDOWN, 1, vmbus_ongpadl_torndown}, 903 {CHANNELMSG_RELID_RELEASED, 0, NULL}, 904 {CHANNELMSG_INITIATE_CONTACT, 0, NULL}, 905 {CHANNELMSG_VERSION_RESPONSE, 1, vmbus_onversion_response}, 906 {CHANNELMSG_UNLOAD, 0, NULL}, 907 {CHANNELMSG_UNLOAD_RESPONSE, 1, vmbus_unload_response}, 908 }; 909 910 /* 911 * vmbus_onmessage - Handler for channel protocol messages. 912 * 913 * This is invoked in the vmbus worker thread context. 914 */ 915 void vmbus_onmessage(void *context) 916 { 917 struct hv_message *msg = context; 918 struct vmbus_channel_message_header *hdr; 919 int size; 920 921 hdr = (struct vmbus_channel_message_header *)msg->u.payload; 922 size = msg->header.payload_size; 923 924 if (hdr->msgtype >= CHANNELMSG_COUNT) { 925 pr_err("Received invalid channel message type %d size %d\n", 926 hdr->msgtype, size); 927 print_hex_dump_bytes("", DUMP_PREFIX_NONE, 928 (unsigned char *)msg->u.payload, size); 929 return; 930 } 931 932 if (channel_message_table[hdr->msgtype].message_handler) 933 channel_message_table[hdr->msgtype].message_handler(hdr); 934 else 935 pr_err("Unhandled channel message type %d\n", hdr->msgtype); 936 } 937 938 /* 939 * vmbus_request_offers - Send a request to get all our pending offers. 940 */ 941 int vmbus_request_offers(void) 942 { 943 struct vmbus_channel_message_header *msg; 944 struct vmbus_channel_msginfo *msginfo; 945 int ret; 946 947 msginfo = kmalloc(sizeof(*msginfo) + 948 sizeof(struct vmbus_channel_message_header), 949 GFP_KERNEL); 950 if (!msginfo) 951 return -ENOMEM; 952 953 msg = (struct vmbus_channel_message_header *)msginfo->msg; 954 955 msg->msgtype = CHANNELMSG_REQUESTOFFERS; 956 957 958 ret = vmbus_post_msg(msg, 959 sizeof(struct vmbus_channel_message_header)); 960 if (ret != 0) { 961 pr_err("Unable to request offers - %d\n", ret); 962 963 goto cleanup; 964 } 965 966 cleanup: 967 kfree(msginfo); 968 969 return ret; 970 } 971 972 /* 973 * Retrieve the (sub) channel on which to send an outgoing request. 974 * When a primary channel has multiple sub-channels, we try to 975 * distribute the load equally amongst all available channels. 976 */ 977 struct vmbus_channel *vmbus_get_outgoing_channel(struct vmbus_channel *primary) 978 { 979 struct list_head *cur, *tmp; 980 int cur_cpu; 981 struct vmbus_channel *cur_channel; 982 struct vmbus_channel *outgoing_channel = primary; 983 int next_channel; 984 int i = 1; 985 986 if (list_empty(&primary->sc_list)) 987 return outgoing_channel; 988 989 next_channel = primary->next_oc++; 990 991 if (next_channel > (primary->num_sc)) { 992 primary->next_oc = 0; 993 return outgoing_channel; 994 } 995 996 cur_cpu = hv_context.vp_index[get_cpu()]; 997 put_cpu(); 998 list_for_each_safe(cur, tmp, &primary->sc_list) { 999 cur_channel = list_entry(cur, struct vmbus_channel, sc_list); 1000 if (cur_channel->state != CHANNEL_OPENED_STATE) 1001 continue; 1002 1003 if (cur_channel->target_vp == cur_cpu) 1004 return cur_channel; 1005 1006 if (i == next_channel) 1007 return cur_channel; 1008 1009 i++; 1010 } 1011 1012 return outgoing_channel; 1013 } 1014 EXPORT_SYMBOL_GPL(vmbus_get_outgoing_channel); 1015 1016 static void invoke_sc_cb(struct vmbus_channel *primary_channel) 1017 { 1018 struct list_head *cur, *tmp; 1019 struct vmbus_channel *cur_channel; 1020 1021 if (primary_channel->sc_creation_callback == NULL) 1022 return; 1023 1024 list_for_each_safe(cur, tmp, &primary_channel->sc_list) { 1025 cur_channel = list_entry(cur, struct vmbus_channel, sc_list); 1026 1027 primary_channel->sc_creation_callback(cur_channel); 1028 } 1029 } 1030 1031 void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel, 1032 void (*sc_cr_cb)(struct vmbus_channel *new_sc)) 1033 { 1034 primary_channel->sc_creation_callback = sc_cr_cb; 1035 } 1036 EXPORT_SYMBOL_GPL(vmbus_set_sc_create_callback); 1037 1038 bool vmbus_are_subchannels_present(struct vmbus_channel *primary) 1039 { 1040 bool ret; 1041 1042 ret = !list_empty(&primary->sc_list); 1043 1044 if (ret) { 1045 /* 1046 * Invoke the callback on sub-channel creation. 1047 * This will present a uniform interface to the 1048 * clients. 1049 */ 1050 invoke_sc_cb(primary); 1051 } 1052 1053 return ret; 1054 } 1055 EXPORT_SYMBOL_GPL(vmbus_are_subchannels_present); 1056