1 /* 2 * 3 * Copyright (c) 2011, Microsoft Corporation. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms and conditions of the GNU General Public License, 7 * version 2, as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 * You should have received a copy of the GNU General Public License along with 15 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple 16 * Place - Suite 330, Boston, MA 02111-1307 USA. 17 * 18 * Authors: 19 * Haiyang Zhang <haiyangz@microsoft.com> 20 * Hank Janssen <hjanssen@microsoft.com> 21 * K. Y. Srinivasan <kys@microsoft.com> 22 * 23 */ 24 25 #ifndef _HYPERV_H 26 #define _HYPERV_H 27 28 #include <uapi/linux/hyperv.h> 29 30 #include <linux/types.h> 31 #include <linux/scatterlist.h> 32 #include <linux/list.h> 33 #include <linux/timer.h> 34 #include <linux/completion.h> 35 #include <linux/device.h> 36 #include <linux/mod_devicetable.h> 37 #include <linux/interrupt.h> 38 39 #define MAX_PAGE_BUFFER_COUNT 32 40 #define MAX_MULTIPAGE_BUFFER_COUNT 32 /* 128K */ 41 42 #pragma pack(push, 1) 43 44 /* Single-page buffer */ 45 struct hv_page_buffer { 46 u32 len; 47 u32 offset; 48 u64 pfn; 49 }; 50 51 /* Multiple-page buffer */ 52 struct hv_multipage_buffer { 53 /* Length and Offset determines the # of pfns in the array */ 54 u32 len; 55 u32 offset; 56 u64 pfn_array[MAX_MULTIPAGE_BUFFER_COUNT]; 57 }; 58 59 /* 60 * Multiple-page buffer array; the pfn array is variable size: 61 * The number of entries in the PFN array is determined by 62 * "len" and "offset". 63 */ 64 struct hv_mpb_array { 65 /* Length and Offset determines the # of pfns in the array */ 66 u32 len; 67 u32 offset; 68 u64 pfn_array[]; 69 }; 70 71 /* 0x18 includes the proprietary packet header */ 72 #define MAX_PAGE_BUFFER_PACKET (0x18 + \ 73 (sizeof(struct hv_page_buffer) * \ 74 MAX_PAGE_BUFFER_COUNT)) 75 #define MAX_MULTIPAGE_BUFFER_PACKET (0x18 + \ 76 sizeof(struct hv_multipage_buffer)) 77 78 79 #pragma pack(pop) 80 81 struct hv_ring_buffer { 82 /* Offset in bytes from the start of ring data below */ 83 u32 write_index; 84 85 /* Offset in bytes from the start of ring data below */ 86 u32 read_index; 87 88 u32 interrupt_mask; 89 90 /* 91 * Win8 uses some of the reserved bits to implement 92 * interrupt driven flow management. On the send side 93 * we can request that the receiver interrupt the sender 94 * when the ring transitions from being full to being able 95 * to handle a message of size "pending_send_sz". 96 * 97 * Add necessary state for this enhancement. 98 */ 99 u32 pending_send_sz; 100 101 u32 reserved1[12]; 102 103 union { 104 struct { 105 u32 feat_pending_send_sz:1; 106 }; 107 u32 value; 108 } feature_bits; 109 110 /* Pad it to PAGE_SIZE so that data starts on page boundary */ 111 u8 reserved2[4028]; 112 113 /* 114 * Ring data starts here + RingDataStartOffset 115 * !!! DO NOT place any fields below this !!! 116 */ 117 u8 buffer[0]; 118 } __packed; 119 120 struct hv_ring_buffer_info { 121 struct hv_ring_buffer *ring_buffer; 122 u32 ring_size; /* Include the shared header */ 123 spinlock_t ring_lock; 124 125 u32 ring_datasize; /* < ring_size */ 126 u32 priv_read_index; 127 }; 128 129 130 static inline u32 hv_get_bytes_to_read(const struct hv_ring_buffer_info *rbi) 131 { 132 u32 read_loc, write_loc, dsize, read; 133 134 dsize = rbi->ring_datasize; 135 read_loc = rbi->ring_buffer->read_index; 136 write_loc = READ_ONCE(rbi->ring_buffer->write_index); 137 138 read = write_loc >= read_loc ? (write_loc - read_loc) : 139 (dsize - read_loc) + write_loc; 140 141 return read; 142 } 143 144 static inline u32 hv_get_bytes_to_write(const struct hv_ring_buffer_info *rbi) 145 { 146 u32 read_loc, write_loc, dsize, write; 147 148 dsize = rbi->ring_datasize; 149 read_loc = READ_ONCE(rbi->ring_buffer->read_index); 150 write_loc = rbi->ring_buffer->write_index; 151 152 write = write_loc >= read_loc ? dsize - (write_loc - read_loc) : 153 read_loc - write_loc; 154 return write; 155 } 156 157 /* 158 * VMBUS version is 32 bit entity broken up into 159 * two 16 bit quantities: major_number. minor_number. 160 * 161 * 0 . 13 (Windows Server 2008) 162 * 1 . 1 (Windows 7) 163 * 2 . 4 (Windows 8) 164 * 3 . 0 (Windows 8 R2) 165 * 4 . 0 (Windows 10) 166 */ 167 168 #define VERSION_WS2008 ((0 << 16) | (13)) 169 #define VERSION_WIN7 ((1 << 16) | (1)) 170 #define VERSION_WIN8 ((2 << 16) | (4)) 171 #define VERSION_WIN8_1 ((3 << 16) | (0)) 172 #define VERSION_WIN10 ((4 << 16) | (0)) 173 174 #define VERSION_INVAL -1 175 176 #define VERSION_CURRENT VERSION_WIN10 177 178 /* Make maximum size of pipe payload of 16K */ 179 #define MAX_PIPE_DATA_PAYLOAD (sizeof(u8) * 16384) 180 181 /* Define PipeMode values. */ 182 #define VMBUS_PIPE_TYPE_BYTE 0x00000000 183 #define VMBUS_PIPE_TYPE_MESSAGE 0x00000004 184 185 /* The size of the user defined data buffer for non-pipe offers. */ 186 #define MAX_USER_DEFINED_BYTES 120 187 188 /* The size of the user defined data buffer for pipe offers. */ 189 #define MAX_PIPE_USER_DEFINED_BYTES 116 190 191 /* 192 * At the center of the Channel Management library is the Channel Offer. This 193 * struct contains the fundamental information about an offer. 194 */ 195 struct vmbus_channel_offer { 196 uuid_le if_type; 197 uuid_le if_instance; 198 199 /* 200 * These two fields are not currently used. 201 */ 202 u64 reserved1; 203 u64 reserved2; 204 205 u16 chn_flags; 206 u16 mmio_megabytes; /* in bytes * 1024 * 1024 */ 207 208 union { 209 /* Non-pipes: The user has MAX_USER_DEFINED_BYTES bytes. */ 210 struct { 211 unsigned char user_def[MAX_USER_DEFINED_BYTES]; 212 } std; 213 214 /* 215 * Pipes: 216 * The following sructure is an integrated pipe protocol, which 217 * is implemented on top of standard user-defined data. Pipe 218 * clients have MAX_PIPE_USER_DEFINED_BYTES left for their own 219 * use. 220 */ 221 struct { 222 u32 pipe_mode; 223 unsigned char user_def[MAX_PIPE_USER_DEFINED_BYTES]; 224 } pipe; 225 } u; 226 /* 227 * The sub_channel_index is defined in win8. 228 */ 229 u16 sub_channel_index; 230 u16 reserved3; 231 } __packed; 232 233 /* Server Flags */ 234 #define VMBUS_CHANNEL_ENUMERATE_DEVICE_INTERFACE 1 235 #define VMBUS_CHANNEL_SERVER_SUPPORTS_TRANSFER_PAGES 2 236 #define VMBUS_CHANNEL_SERVER_SUPPORTS_GPADLS 4 237 #define VMBUS_CHANNEL_NAMED_PIPE_MODE 0x10 238 #define VMBUS_CHANNEL_LOOPBACK_OFFER 0x100 239 #define VMBUS_CHANNEL_PARENT_OFFER 0x200 240 #define VMBUS_CHANNEL_REQUEST_MONITORED_NOTIFICATION 0x400 241 #define VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER 0x2000 242 243 struct vmpacket_descriptor { 244 u16 type; 245 u16 offset8; 246 u16 len8; 247 u16 flags; 248 u64 trans_id; 249 } __packed; 250 251 struct vmpacket_header { 252 u32 prev_pkt_start_offset; 253 struct vmpacket_descriptor descriptor; 254 } __packed; 255 256 struct vmtransfer_page_range { 257 u32 byte_count; 258 u32 byte_offset; 259 } __packed; 260 261 struct vmtransfer_page_packet_header { 262 struct vmpacket_descriptor d; 263 u16 xfer_pageset_id; 264 u8 sender_owns_set; 265 u8 reserved; 266 u32 range_cnt; 267 struct vmtransfer_page_range ranges[1]; 268 } __packed; 269 270 struct vmgpadl_packet_header { 271 struct vmpacket_descriptor d; 272 u32 gpadl; 273 u32 reserved; 274 } __packed; 275 276 struct vmadd_remove_transfer_page_set { 277 struct vmpacket_descriptor d; 278 u32 gpadl; 279 u16 xfer_pageset_id; 280 u16 reserved; 281 } __packed; 282 283 /* 284 * This structure defines a range in guest physical space that can be made to 285 * look virtually contiguous. 286 */ 287 struct gpa_range { 288 u32 byte_count; 289 u32 byte_offset; 290 u64 pfn_array[0]; 291 }; 292 293 /* 294 * This is the format for an Establish Gpadl packet, which contains a handle by 295 * which this GPADL will be known and a set of GPA ranges associated with it. 296 * This can be converted to a MDL by the guest OS. If there are multiple GPA 297 * ranges, then the resulting MDL will be "chained," representing multiple VA 298 * ranges. 299 */ 300 struct vmestablish_gpadl { 301 struct vmpacket_descriptor d; 302 u32 gpadl; 303 u32 range_cnt; 304 struct gpa_range range[1]; 305 } __packed; 306 307 /* 308 * This is the format for a Teardown Gpadl packet, which indicates that the 309 * GPADL handle in the Establish Gpadl packet will never be referenced again. 310 */ 311 struct vmteardown_gpadl { 312 struct vmpacket_descriptor d; 313 u32 gpadl; 314 u32 reserved; /* for alignment to a 8-byte boundary */ 315 } __packed; 316 317 /* 318 * This is the format for a GPA-Direct packet, which contains a set of GPA 319 * ranges, in addition to commands and/or data. 320 */ 321 struct vmdata_gpa_direct { 322 struct vmpacket_descriptor d; 323 u32 reserved; 324 u32 range_cnt; 325 struct gpa_range range[1]; 326 } __packed; 327 328 /* This is the format for a Additional Data Packet. */ 329 struct vmadditional_data { 330 struct vmpacket_descriptor d; 331 u64 total_bytes; 332 u32 offset; 333 u32 byte_cnt; 334 unsigned char data[1]; 335 } __packed; 336 337 union vmpacket_largest_possible_header { 338 struct vmpacket_descriptor simple_hdr; 339 struct vmtransfer_page_packet_header xfer_page_hdr; 340 struct vmgpadl_packet_header gpadl_hdr; 341 struct vmadd_remove_transfer_page_set add_rm_xfer_page_hdr; 342 struct vmestablish_gpadl establish_gpadl_hdr; 343 struct vmteardown_gpadl teardown_gpadl_hdr; 344 struct vmdata_gpa_direct data_gpa_direct_hdr; 345 }; 346 347 #define VMPACKET_DATA_START_ADDRESS(__packet) \ 348 (void *)(((unsigned char *)__packet) + \ 349 ((struct vmpacket_descriptor)__packet)->offset8 * 8) 350 351 #define VMPACKET_DATA_LENGTH(__packet) \ 352 ((((struct vmpacket_descriptor)__packet)->len8 - \ 353 ((struct vmpacket_descriptor)__packet)->offset8) * 8) 354 355 #define VMPACKET_TRANSFER_MODE(__packet) \ 356 (((struct IMPACT)__packet)->type) 357 358 enum vmbus_packet_type { 359 VM_PKT_INVALID = 0x0, 360 VM_PKT_SYNCH = 0x1, 361 VM_PKT_ADD_XFER_PAGESET = 0x2, 362 VM_PKT_RM_XFER_PAGESET = 0x3, 363 VM_PKT_ESTABLISH_GPADL = 0x4, 364 VM_PKT_TEARDOWN_GPADL = 0x5, 365 VM_PKT_DATA_INBAND = 0x6, 366 VM_PKT_DATA_USING_XFER_PAGES = 0x7, 367 VM_PKT_DATA_USING_GPADL = 0x8, 368 VM_PKT_DATA_USING_GPA_DIRECT = 0x9, 369 VM_PKT_CANCEL_REQUEST = 0xa, 370 VM_PKT_COMP = 0xb, 371 VM_PKT_DATA_USING_ADDITIONAL_PKT = 0xc, 372 VM_PKT_ADDITIONAL_DATA = 0xd 373 }; 374 375 #define VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED 1 376 377 378 /* Version 1 messages */ 379 enum vmbus_channel_message_type { 380 CHANNELMSG_INVALID = 0, 381 CHANNELMSG_OFFERCHANNEL = 1, 382 CHANNELMSG_RESCIND_CHANNELOFFER = 2, 383 CHANNELMSG_REQUESTOFFERS = 3, 384 CHANNELMSG_ALLOFFERS_DELIVERED = 4, 385 CHANNELMSG_OPENCHANNEL = 5, 386 CHANNELMSG_OPENCHANNEL_RESULT = 6, 387 CHANNELMSG_CLOSECHANNEL = 7, 388 CHANNELMSG_GPADL_HEADER = 8, 389 CHANNELMSG_GPADL_BODY = 9, 390 CHANNELMSG_GPADL_CREATED = 10, 391 CHANNELMSG_GPADL_TEARDOWN = 11, 392 CHANNELMSG_GPADL_TORNDOWN = 12, 393 CHANNELMSG_RELID_RELEASED = 13, 394 CHANNELMSG_INITIATE_CONTACT = 14, 395 CHANNELMSG_VERSION_RESPONSE = 15, 396 CHANNELMSG_UNLOAD = 16, 397 CHANNELMSG_UNLOAD_RESPONSE = 17, 398 CHANNELMSG_18 = 18, 399 CHANNELMSG_19 = 19, 400 CHANNELMSG_20 = 20, 401 CHANNELMSG_TL_CONNECT_REQUEST = 21, 402 CHANNELMSG_COUNT 403 }; 404 405 struct vmbus_channel_message_header { 406 enum vmbus_channel_message_type msgtype; 407 u32 padding; 408 } __packed; 409 410 /* Query VMBus Version parameters */ 411 struct vmbus_channel_query_vmbus_version { 412 struct vmbus_channel_message_header header; 413 u32 version; 414 } __packed; 415 416 /* VMBus Version Supported parameters */ 417 struct vmbus_channel_version_supported { 418 struct vmbus_channel_message_header header; 419 u8 version_supported; 420 } __packed; 421 422 /* Offer Channel parameters */ 423 struct vmbus_channel_offer_channel { 424 struct vmbus_channel_message_header header; 425 struct vmbus_channel_offer offer; 426 u32 child_relid; 427 u8 monitorid; 428 /* 429 * win7 and beyond splits this field into a bit field. 430 */ 431 u8 monitor_allocated:1; 432 u8 reserved:7; 433 /* 434 * These are new fields added in win7 and later. 435 * Do not access these fields without checking the 436 * negotiated protocol. 437 * 438 * If "is_dedicated_interrupt" is set, we must not set the 439 * associated bit in the channel bitmap while sending the 440 * interrupt to the host. 441 * 442 * connection_id is to be used in signaling the host. 443 */ 444 u16 is_dedicated_interrupt:1; 445 u16 reserved1:15; 446 u32 connection_id; 447 } __packed; 448 449 /* Rescind Offer parameters */ 450 struct vmbus_channel_rescind_offer { 451 struct vmbus_channel_message_header header; 452 u32 child_relid; 453 } __packed; 454 455 static inline u32 456 hv_ringbuffer_pending_size(const struct hv_ring_buffer_info *rbi) 457 { 458 return rbi->ring_buffer->pending_send_sz; 459 } 460 461 /* 462 * Request Offer -- no parameters, SynIC message contains the partition ID 463 * Set Snoop -- no parameters, SynIC message contains the partition ID 464 * Clear Snoop -- no parameters, SynIC message contains the partition ID 465 * All Offers Delivered -- no parameters, SynIC message contains the partition 466 * ID 467 * Flush Client -- no parameters, SynIC message contains the partition ID 468 */ 469 470 /* Open Channel parameters */ 471 struct vmbus_channel_open_channel { 472 struct vmbus_channel_message_header header; 473 474 /* Identifies the specific VMBus channel that is being opened. */ 475 u32 child_relid; 476 477 /* ID making a particular open request at a channel offer unique. */ 478 u32 openid; 479 480 /* GPADL for the channel's ring buffer. */ 481 u32 ringbuffer_gpadlhandle; 482 483 /* 484 * Starting with win8, this field will be used to specify 485 * the target virtual processor on which to deliver the interrupt for 486 * the host to guest communication. 487 * Prior to win8, incoming channel interrupts would only 488 * be delivered on cpu 0. Setting this value to 0 would 489 * preserve the earlier behavior. 490 */ 491 u32 target_vp; 492 493 /* 494 * The upstream ring buffer begins at offset zero in the memory 495 * described by RingBufferGpadlHandle. The downstream ring buffer 496 * follows it at this offset (in pages). 497 */ 498 u32 downstream_ringbuffer_pageoffset; 499 500 /* User-specific data to be passed along to the server endpoint. */ 501 unsigned char userdata[MAX_USER_DEFINED_BYTES]; 502 } __packed; 503 504 /* Open Channel Result parameters */ 505 struct vmbus_channel_open_result { 506 struct vmbus_channel_message_header header; 507 u32 child_relid; 508 u32 openid; 509 u32 status; 510 } __packed; 511 512 /* Close channel parameters; */ 513 struct vmbus_channel_close_channel { 514 struct vmbus_channel_message_header header; 515 u32 child_relid; 516 } __packed; 517 518 /* Channel Message GPADL */ 519 #define GPADL_TYPE_RING_BUFFER 1 520 #define GPADL_TYPE_SERVER_SAVE_AREA 2 521 #define GPADL_TYPE_TRANSACTION 8 522 523 /* 524 * The number of PFNs in a GPADL message is defined by the number of 525 * pages that would be spanned by ByteCount and ByteOffset. If the 526 * implied number of PFNs won't fit in this packet, there will be a 527 * follow-up packet that contains more. 528 */ 529 struct vmbus_channel_gpadl_header { 530 struct vmbus_channel_message_header header; 531 u32 child_relid; 532 u32 gpadl; 533 u16 range_buflen; 534 u16 rangecount; 535 struct gpa_range range[0]; 536 } __packed; 537 538 /* This is the followup packet that contains more PFNs. */ 539 struct vmbus_channel_gpadl_body { 540 struct vmbus_channel_message_header header; 541 u32 msgnumber; 542 u32 gpadl; 543 u64 pfn[0]; 544 } __packed; 545 546 struct vmbus_channel_gpadl_created { 547 struct vmbus_channel_message_header header; 548 u32 child_relid; 549 u32 gpadl; 550 u32 creation_status; 551 } __packed; 552 553 struct vmbus_channel_gpadl_teardown { 554 struct vmbus_channel_message_header header; 555 u32 child_relid; 556 u32 gpadl; 557 } __packed; 558 559 struct vmbus_channel_gpadl_torndown { 560 struct vmbus_channel_message_header header; 561 u32 gpadl; 562 } __packed; 563 564 struct vmbus_channel_relid_released { 565 struct vmbus_channel_message_header header; 566 u32 child_relid; 567 } __packed; 568 569 struct vmbus_channel_initiate_contact { 570 struct vmbus_channel_message_header header; 571 u32 vmbus_version_requested; 572 u32 target_vcpu; /* The VCPU the host should respond to */ 573 u64 interrupt_page; 574 u64 monitor_page1; 575 u64 monitor_page2; 576 } __packed; 577 578 /* Hyper-V socket: guest's connect()-ing to host */ 579 struct vmbus_channel_tl_connect_request { 580 struct vmbus_channel_message_header header; 581 uuid_le guest_endpoint_id; 582 uuid_le host_service_id; 583 } __packed; 584 585 struct vmbus_channel_version_response { 586 struct vmbus_channel_message_header header; 587 u8 version_supported; 588 } __packed; 589 590 enum vmbus_channel_state { 591 CHANNEL_OFFER_STATE, 592 CHANNEL_OPENING_STATE, 593 CHANNEL_OPEN_STATE, 594 CHANNEL_OPENED_STATE, 595 }; 596 597 /* 598 * Represents each channel msg on the vmbus connection This is a 599 * variable-size data structure depending on the msg type itself 600 */ 601 struct vmbus_channel_msginfo { 602 /* Bookkeeping stuff */ 603 struct list_head msglistentry; 604 605 /* So far, this is only used to handle gpadl body message */ 606 struct list_head submsglist; 607 608 /* Synchronize the request/response if needed */ 609 struct completion waitevent; 610 struct vmbus_channel *waiting_channel; 611 union { 612 struct vmbus_channel_version_supported version_supported; 613 struct vmbus_channel_open_result open_result; 614 struct vmbus_channel_gpadl_torndown gpadl_torndown; 615 struct vmbus_channel_gpadl_created gpadl_created; 616 struct vmbus_channel_version_response version_response; 617 } response; 618 619 u32 msgsize; 620 /* 621 * The channel message that goes out on the "wire". 622 * It will contain at minimum the VMBUS_CHANNEL_MESSAGE_HEADER header 623 */ 624 unsigned char msg[0]; 625 }; 626 627 struct vmbus_close_msg { 628 struct vmbus_channel_msginfo info; 629 struct vmbus_channel_close_channel msg; 630 }; 631 632 /* Define connection identifier type. */ 633 union hv_connection_id { 634 u32 asu32; 635 struct { 636 u32 id:24; 637 u32 reserved:8; 638 } u; 639 }; 640 641 enum hv_numa_policy { 642 HV_BALANCED = 0, 643 HV_LOCALIZED, 644 }; 645 646 enum vmbus_device_type { 647 HV_IDE = 0, 648 HV_SCSI, 649 HV_FC, 650 HV_NIC, 651 HV_ND, 652 HV_PCIE, 653 HV_FB, 654 HV_KBD, 655 HV_MOUSE, 656 HV_KVP, 657 HV_TS, 658 HV_HB, 659 HV_SHUTDOWN, 660 HV_FCOPY, 661 HV_BACKUP, 662 HV_DM, 663 HV_UNKNOWN, 664 }; 665 666 struct vmbus_device { 667 u16 dev_type; 668 uuid_le guid; 669 bool perf_device; 670 }; 671 672 struct vmbus_channel { 673 struct list_head listentry; 674 675 struct hv_device *device_obj; 676 677 enum vmbus_channel_state state; 678 679 struct vmbus_channel_offer_channel offermsg; 680 /* 681 * These are based on the OfferMsg.MonitorId. 682 * Save it here for easy access. 683 */ 684 u8 monitor_grp; 685 u8 monitor_bit; 686 687 bool rescind; /* got rescind msg */ 688 struct completion rescind_event; 689 690 u32 ringbuffer_gpadlhandle; 691 692 /* Allocated memory for ring buffer */ 693 void *ringbuffer_pages; 694 u32 ringbuffer_pagecount; 695 struct hv_ring_buffer_info outbound; /* send to parent */ 696 struct hv_ring_buffer_info inbound; /* receive from parent */ 697 698 struct vmbus_close_msg close_msg; 699 700 /* Statistics */ 701 u64 interrupts; /* Host to Guest interrupts */ 702 u64 sig_events; /* Guest to Host events */ 703 704 /* Channel callback's invoked in softirq context */ 705 struct tasklet_struct callback_event; 706 void (*onchannel_callback)(void *context); 707 void *channel_callback_context; 708 709 /* 710 * A channel can be marked for one of three modes of reading: 711 * BATCHED - callback called from taslket and should read 712 * channel until empty. Interrupts from the host 713 * are masked while read is in process (default). 714 * DIRECT - callback called from tasklet (softirq). 715 * ISR - callback called in interrupt context and must 716 * invoke its own deferred processing. 717 * Host interrupts are disabled and must be re-enabled 718 * when ring is empty. 719 */ 720 enum hv_callback_mode { 721 HV_CALL_BATCHED, 722 HV_CALL_DIRECT, 723 HV_CALL_ISR 724 } callback_mode; 725 726 bool is_dedicated_interrupt; 727 u64 sig_event; 728 729 /* 730 * Starting with win8, this field will be used to specify 731 * the target virtual processor on which to deliver the interrupt for 732 * the host to guest communication. 733 * Prior to win8, incoming channel interrupts would only 734 * be delivered on cpu 0. Setting this value to 0 would 735 * preserve the earlier behavior. 736 */ 737 u32 target_vp; 738 /* The corresponding CPUID in the guest */ 739 u32 target_cpu; 740 /* 741 * State to manage the CPU affiliation of channels. 742 */ 743 struct cpumask alloced_cpus_in_node; 744 int numa_node; 745 /* 746 * Support for sub-channels. For high performance devices, 747 * it will be useful to have multiple sub-channels to support 748 * a scalable communication infrastructure with the host. 749 * The support for sub-channels is implemented as an extention 750 * to the current infrastructure. 751 * The initial offer is considered the primary channel and this 752 * offer message will indicate if the host supports sub-channels. 753 * The guest is free to ask for sub-channels to be offerred and can 754 * open these sub-channels as a normal "primary" channel. However, 755 * all sub-channels will have the same type and instance guids as the 756 * primary channel. Requests sent on a given channel will result in a 757 * response on the same channel. 758 */ 759 760 /* 761 * Sub-channel creation callback. This callback will be called in 762 * process context when a sub-channel offer is received from the host. 763 * The guest can open the sub-channel in the context of this callback. 764 */ 765 void (*sc_creation_callback)(struct vmbus_channel *new_sc); 766 767 /* 768 * Channel rescind callback. Some channels (the hvsock ones), need to 769 * register a callback which is invoked in vmbus_onoffer_rescind(). 770 */ 771 void (*chn_rescind_callback)(struct vmbus_channel *channel); 772 773 /* 774 * The spinlock to protect the structure. It is being used to protect 775 * test-and-set access to various attributes of the structure as well 776 * as all sc_list operations. 777 */ 778 spinlock_t lock; 779 /* 780 * All Sub-channels of a primary channel are linked here. 781 */ 782 struct list_head sc_list; 783 /* 784 * Current number of sub-channels. 785 */ 786 int num_sc; 787 /* 788 * Number of a sub-channel (position within sc_list) which is supposed 789 * to be used as the next outgoing channel. 790 */ 791 int next_oc; 792 /* 793 * The primary channel this sub-channel belongs to. 794 * This will be NULL for the primary channel. 795 */ 796 struct vmbus_channel *primary_channel; 797 /* 798 * Support per-channel state for use by vmbus drivers. 799 */ 800 void *per_channel_state; 801 /* 802 * To support per-cpu lookup mapping of relid to channel, 803 * link up channels based on their CPU affinity. 804 */ 805 struct list_head percpu_list; 806 807 /* 808 * Defer freeing channel until after all cpu's have 809 * gone through grace period. 810 */ 811 struct rcu_head rcu; 812 813 /* 814 * For sysfs per-channel properties. 815 */ 816 struct kobject kobj; 817 818 /* 819 * For performance critical channels (storage, networking 820 * etc,), Hyper-V has a mechanism to enhance the throughput 821 * at the expense of latency: 822 * When the host is to be signaled, we just set a bit in a shared page 823 * and this bit will be inspected by the hypervisor within a certain 824 * window and if the bit is set, the host will be signaled. The window 825 * of time is the monitor latency - currently around 100 usecs. This 826 * mechanism improves throughput by: 827 * 828 * A) Making the host more efficient - each time it wakes up, 829 * potentially it will process morev number of packets. The 830 * monitor latency allows a batch to build up. 831 * B) By deferring the hypercall to signal, we will also minimize 832 * the interrupts. 833 * 834 * Clearly, these optimizations improve throughput at the expense of 835 * latency. Furthermore, since the channel is shared for both 836 * control and data messages, control messages currently suffer 837 * unnecessary latency adversley impacting performance and boot 838 * time. To fix this issue, permit tagging the channel as being 839 * in "low latency" mode. In this mode, we will bypass the monitor 840 * mechanism. 841 */ 842 bool low_latency; 843 844 /* 845 * NUMA distribution policy: 846 * We support two policies: 847 * 1) Balanced: Here all performance critical channels are 848 * distributed evenly amongst all the NUMA nodes. 849 * This policy will be the default policy. 850 * 2) Localized: All channels of a given instance of a 851 * performance critical service will be assigned CPUs 852 * within a selected NUMA node. 853 */ 854 enum hv_numa_policy affinity_policy; 855 856 bool probe_done; 857 858 }; 859 860 static inline bool is_hvsock_channel(const struct vmbus_channel *c) 861 { 862 return !!(c->offermsg.offer.chn_flags & 863 VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER); 864 } 865 866 static inline void set_channel_affinity_state(struct vmbus_channel *c, 867 enum hv_numa_policy policy) 868 { 869 c->affinity_policy = policy; 870 } 871 872 static inline void set_channel_read_mode(struct vmbus_channel *c, 873 enum hv_callback_mode mode) 874 { 875 c->callback_mode = mode; 876 } 877 878 static inline void set_per_channel_state(struct vmbus_channel *c, void *s) 879 { 880 c->per_channel_state = s; 881 } 882 883 static inline void *get_per_channel_state(struct vmbus_channel *c) 884 { 885 return c->per_channel_state; 886 } 887 888 static inline void set_channel_pending_send_size(struct vmbus_channel *c, 889 u32 size) 890 { 891 c->outbound.ring_buffer->pending_send_sz = size; 892 } 893 894 static inline void set_low_latency_mode(struct vmbus_channel *c) 895 { 896 c->low_latency = true; 897 } 898 899 static inline void clear_low_latency_mode(struct vmbus_channel *c) 900 { 901 c->low_latency = false; 902 } 903 904 void vmbus_onmessage(void *context); 905 906 int vmbus_request_offers(void); 907 908 /* 909 * APIs for managing sub-channels. 910 */ 911 912 void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel, 913 void (*sc_cr_cb)(struct vmbus_channel *new_sc)); 914 915 void vmbus_set_chn_rescind_callback(struct vmbus_channel *channel, 916 void (*chn_rescind_cb)(struct vmbus_channel *)); 917 918 /* 919 * Retrieve the (sub) channel on which to send an outgoing request. 920 * When a primary channel has multiple sub-channels, we choose a 921 * channel whose VCPU binding is closest to the VCPU on which 922 * this call is being made. 923 */ 924 struct vmbus_channel *vmbus_get_outgoing_channel(struct vmbus_channel *primary); 925 926 /* 927 * Check if sub-channels have already been offerred. This API will be useful 928 * when the driver is unloaded after establishing sub-channels. In this case, 929 * when the driver is re-loaded, the driver would have to check if the 930 * subchannels have already been established before attempting to request 931 * the creation of sub-channels. 932 * This function returns TRUE to indicate that subchannels have already been 933 * created. 934 * This function should be invoked after setting the callback function for 935 * sub-channel creation. 936 */ 937 bool vmbus_are_subchannels_present(struct vmbus_channel *primary); 938 939 /* The format must be the same as struct vmdata_gpa_direct */ 940 struct vmbus_channel_packet_page_buffer { 941 u16 type; 942 u16 dataoffset8; 943 u16 length8; 944 u16 flags; 945 u64 transactionid; 946 u32 reserved; 947 u32 rangecount; 948 struct hv_page_buffer range[MAX_PAGE_BUFFER_COUNT]; 949 } __packed; 950 951 /* The format must be the same as struct vmdata_gpa_direct */ 952 struct vmbus_channel_packet_multipage_buffer { 953 u16 type; 954 u16 dataoffset8; 955 u16 length8; 956 u16 flags; 957 u64 transactionid; 958 u32 reserved; 959 u32 rangecount; /* Always 1 in this case */ 960 struct hv_multipage_buffer range; 961 } __packed; 962 963 /* The format must be the same as struct vmdata_gpa_direct */ 964 struct vmbus_packet_mpb_array { 965 u16 type; 966 u16 dataoffset8; 967 u16 length8; 968 u16 flags; 969 u64 transactionid; 970 u32 reserved; 971 u32 rangecount; /* Always 1 in this case */ 972 struct hv_mpb_array range; 973 } __packed; 974 975 976 extern int vmbus_open(struct vmbus_channel *channel, 977 u32 send_ringbuffersize, 978 u32 recv_ringbuffersize, 979 void *userdata, 980 u32 userdatalen, 981 void (*onchannel_callback)(void *context), 982 void *context); 983 984 extern void vmbus_close(struct vmbus_channel *channel); 985 986 extern int vmbus_sendpacket(struct vmbus_channel *channel, 987 void *buffer, 988 u32 bufferLen, 989 u64 requestid, 990 enum vmbus_packet_type type, 991 u32 flags); 992 993 extern int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel, 994 struct hv_page_buffer pagebuffers[], 995 u32 pagecount, 996 void *buffer, 997 u32 bufferlen, 998 u64 requestid); 999 1000 extern int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel, 1001 struct vmbus_packet_mpb_array *mpb, 1002 u32 desc_size, 1003 void *buffer, 1004 u32 bufferlen, 1005 u64 requestid); 1006 1007 extern int vmbus_establish_gpadl(struct vmbus_channel *channel, 1008 void *kbuffer, 1009 u32 size, 1010 u32 *gpadl_handle); 1011 1012 extern int vmbus_teardown_gpadl(struct vmbus_channel *channel, 1013 u32 gpadl_handle); 1014 1015 extern int vmbus_recvpacket(struct vmbus_channel *channel, 1016 void *buffer, 1017 u32 bufferlen, 1018 u32 *buffer_actual_len, 1019 u64 *requestid); 1020 1021 extern int vmbus_recvpacket_raw(struct vmbus_channel *channel, 1022 void *buffer, 1023 u32 bufferlen, 1024 u32 *buffer_actual_len, 1025 u64 *requestid); 1026 1027 1028 extern void vmbus_ontimer(unsigned long data); 1029 1030 /* Base driver object */ 1031 struct hv_driver { 1032 const char *name; 1033 1034 /* 1035 * A hvsock offer, which has a VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER 1036 * channel flag, actually doesn't mean a synthetic device because the 1037 * offer's if_type/if_instance can change for every new hvsock 1038 * connection. 1039 * 1040 * However, to facilitate the notification of new-offer/rescind-offer 1041 * from vmbus driver to hvsock driver, we can handle hvsock offer as 1042 * a special vmbus device, and hence we need the below flag to 1043 * indicate if the driver is the hvsock driver or not: we need to 1044 * specially treat the hvosck offer & driver in vmbus_match(). 1045 */ 1046 bool hvsock; 1047 1048 /* the device type supported by this driver */ 1049 uuid_le dev_type; 1050 const struct hv_vmbus_device_id *id_table; 1051 1052 struct device_driver driver; 1053 1054 /* dynamic device GUID's */ 1055 struct { 1056 spinlock_t lock; 1057 struct list_head list; 1058 } dynids; 1059 1060 int (*probe)(struct hv_device *, const struct hv_vmbus_device_id *); 1061 int (*remove)(struct hv_device *); 1062 void (*shutdown)(struct hv_device *); 1063 1064 }; 1065 1066 /* Base device object */ 1067 struct hv_device { 1068 /* the device type id of this device */ 1069 uuid_le dev_type; 1070 1071 /* the device instance id of this device */ 1072 uuid_le dev_instance; 1073 u16 vendor_id; 1074 u16 device_id; 1075 1076 struct device device; 1077 1078 struct vmbus_channel *channel; 1079 struct kset *channels_kset; 1080 }; 1081 1082 1083 static inline struct hv_device *device_to_hv_device(struct device *d) 1084 { 1085 return container_of(d, struct hv_device, device); 1086 } 1087 1088 static inline struct hv_driver *drv_to_hv_drv(struct device_driver *d) 1089 { 1090 return container_of(d, struct hv_driver, driver); 1091 } 1092 1093 static inline void hv_set_drvdata(struct hv_device *dev, void *data) 1094 { 1095 dev_set_drvdata(&dev->device, data); 1096 } 1097 1098 static inline void *hv_get_drvdata(struct hv_device *dev) 1099 { 1100 return dev_get_drvdata(&dev->device); 1101 } 1102 1103 struct hv_ring_buffer_debug_info { 1104 u32 current_interrupt_mask; 1105 u32 current_read_index; 1106 u32 current_write_index; 1107 u32 bytes_avail_toread; 1108 u32 bytes_avail_towrite; 1109 }; 1110 1111 void hv_ringbuffer_get_debuginfo(const struct hv_ring_buffer_info *ring_info, 1112 struct hv_ring_buffer_debug_info *debug_info); 1113 1114 /* Vmbus interface */ 1115 #define vmbus_driver_register(driver) \ 1116 __vmbus_driver_register(driver, THIS_MODULE, KBUILD_MODNAME) 1117 int __must_check __vmbus_driver_register(struct hv_driver *hv_driver, 1118 struct module *owner, 1119 const char *mod_name); 1120 void vmbus_driver_unregister(struct hv_driver *hv_driver); 1121 1122 void vmbus_hvsock_device_unregister(struct vmbus_channel *channel); 1123 1124 int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj, 1125 resource_size_t min, resource_size_t max, 1126 resource_size_t size, resource_size_t align, 1127 bool fb_overlap_ok); 1128 void vmbus_free_mmio(resource_size_t start, resource_size_t size); 1129 1130 /* 1131 * GUID definitions of various offer types - services offered to the guest. 1132 */ 1133 1134 /* 1135 * Network GUID 1136 * {f8615163-df3e-46c5-913f-f2d2f965ed0e} 1137 */ 1138 #define HV_NIC_GUID \ 1139 .guid = UUID_LE(0xf8615163, 0xdf3e, 0x46c5, 0x91, 0x3f, \ 1140 0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e) 1141 1142 /* 1143 * IDE GUID 1144 * {32412632-86cb-44a2-9b5c-50d1417354f5} 1145 */ 1146 #define HV_IDE_GUID \ 1147 .guid = UUID_LE(0x32412632, 0x86cb, 0x44a2, 0x9b, 0x5c, \ 1148 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5) 1149 1150 /* 1151 * SCSI GUID 1152 * {ba6163d9-04a1-4d29-b605-72e2ffb1dc7f} 1153 */ 1154 #define HV_SCSI_GUID \ 1155 .guid = UUID_LE(0xba6163d9, 0x04a1, 0x4d29, 0xb6, 0x05, \ 1156 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f) 1157 1158 /* 1159 * Shutdown GUID 1160 * {0e0b6031-5213-4934-818b-38d90ced39db} 1161 */ 1162 #define HV_SHUTDOWN_GUID \ 1163 .guid = UUID_LE(0x0e0b6031, 0x5213, 0x4934, 0x81, 0x8b, \ 1164 0x38, 0xd9, 0x0c, 0xed, 0x39, 0xdb) 1165 1166 /* 1167 * Time Synch GUID 1168 * {9527E630-D0AE-497b-ADCE-E80AB0175CAF} 1169 */ 1170 #define HV_TS_GUID \ 1171 .guid = UUID_LE(0x9527e630, 0xd0ae, 0x497b, 0xad, 0xce, \ 1172 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf) 1173 1174 /* 1175 * Heartbeat GUID 1176 * {57164f39-9115-4e78-ab55-382f3bd5422d} 1177 */ 1178 #define HV_HEART_BEAT_GUID \ 1179 .guid = UUID_LE(0x57164f39, 0x9115, 0x4e78, 0xab, 0x55, \ 1180 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d) 1181 1182 /* 1183 * KVP GUID 1184 * {a9a0f4e7-5a45-4d96-b827-8a841e8c03e6} 1185 */ 1186 #define HV_KVP_GUID \ 1187 .guid = UUID_LE(0xa9a0f4e7, 0x5a45, 0x4d96, 0xb8, 0x27, \ 1188 0x8a, 0x84, 0x1e, 0x8c, 0x03, 0xe6) 1189 1190 /* 1191 * Dynamic memory GUID 1192 * {525074dc-8985-46e2-8057-a307dc18a502} 1193 */ 1194 #define HV_DM_GUID \ 1195 .guid = UUID_LE(0x525074dc, 0x8985, 0x46e2, 0x80, 0x57, \ 1196 0xa3, 0x07, 0xdc, 0x18, 0xa5, 0x02) 1197 1198 /* 1199 * Mouse GUID 1200 * {cfa8b69e-5b4a-4cc0-b98b-8ba1a1f3f95a} 1201 */ 1202 #define HV_MOUSE_GUID \ 1203 .guid = UUID_LE(0xcfa8b69e, 0x5b4a, 0x4cc0, 0xb9, 0x8b, \ 1204 0x8b, 0xa1, 0xa1, 0xf3, 0xf9, 0x5a) 1205 1206 /* 1207 * Keyboard GUID 1208 * {f912ad6d-2b17-48ea-bd65-f927a61c7684} 1209 */ 1210 #define HV_KBD_GUID \ 1211 .guid = UUID_LE(0xf912ad6d, 0x2b17, 0x48ea, 0xbd, 0x65, \ 1212 0xf9, 0x27, 0xa6, 0x1c, 0x76, 0x84) 1213 1214 /* 1215 * VSS (Backup/Restore) GUID 1216 */ 1217 #define HV_VSS_GUID \ 1218 .guid = UUID_LE(0x35fa2e29, 0xea23, 0x4236, 0x96, 0xae, \ 1219 0x3a, 0x6e, 0xba, 0xcb, 0xa4, 0x40) 1220 /* 1221 * Synthetic Video GUID 1222 * {DA0A7802-E377-4aac-8E77-0558EB1073F8} 1223 */ 1224 #define HV_SYNTHVID_GUID \ 1225 .guid = UUID_LE(0xda0a7802, 0xe377, 0x4aac, 0x8e, 0x77, \ 1226 0x05, 0x58, 0xeb, 0x10, 0x73, 0xf8) 1227 1228 /* 1229 * Synthetic FC GUID 1230 * {2f9bcc4a-0069-4af3-b76b-6fd0be528cda} 1231 */ 1232 #define HV_SYNTHFC_GUID \ 1233 .guid = UUID_LE(0x2f9bcc4a, 0x0069, 0x4af3, 0xb7, 0x6b, \ 1234 0x6f, 0xd0, 0xbe, 0x52, 0x8c, 0xda) 1235 1236 /* 1237 * Guest File Copy Service 1238 * {34D14BE3-DEE4-41c8-9AE7-6B174977C192} 1239 */ 1240 1241 #define HV_FCOPY_GUID \ 1242 .guid = UUID_LE(0x34d14be3, 0xdee4, 0x41c8, 0x9a, 0xe7, \ 1243 0x6b, 0x17, 0x49, 0x77, 0xc1, 0x92) 1244 1245 /* 1246 * NetworkDirect. This is the guest RDMA service. 1247 * {8c2eaf3d-32a7-4b09-ab99-bd1f1c86b501} 1248 */ 1249 #define HV_ND_GUID \ 1250 .guid = UUID_LE(0x8c2eaf3d, 0x32a7, 0x4b09, 0xab, 0x99, \ 1251 0xbd, 0x1f, 0x1c, 0x86, 0xb5, 0x01) 1252 1253 /* 1254 * PCI Express Pass Through 1255 * {44C4F61D-4444-4400-9D52-802E27EDE19F} 1256 */ 1257 1258 #define HV_PCIE_GUID \ 1259 .guid = UUID_LE(0x44c4f61d, 0x4444, 0x4400, 0x9d, 0x52, \ 1260 0x80, 0x2e, 0x27, 0xed, 0xe1, 0x9f) 1261 1262 /* 1263 * Linux doesn't support the 3 devices: the first two are for 1264 * Automatic Virtual Machine Activation, and the third is for 1265 * Remote Desktop Virtualization. 1266 * {f8e65716-3cb3-4a06-9a60-1889c5cccab5} 1267 * {3375baf4-9e15-4b30-b765-67acb10d607b} 1268 * {276aacf4-ac15-426c-98dd-7521ad3f01fe} 1269 */ 1270 1271 #define HV_AVMA1_GUID \ 1272 .guid = UUID_LE(0xf8e65716, 0x3cb3, 0x4a06, 0x9a, 0x60, \ 1273 0x18, 0x89, 0xc5, 0xcc, 0xca, 0xb5) 1274 1275 #define HV_AVMA2_GUID \ 1276 .guid = UUID_LE(0x3375baf4, 0x9e15, 0x4b30, 0xb7, 0x65, \ 1277 0x67, 0xac, 0xb1, 0x0d, 0x60, 0x7b) 1278 1279 #define HV_RDV_GUID \ 1280 .guid = UUID_LE(0x276aacf4, 0xac15, 0x426c, 0x98, 0xdd, \ 1281 0x75, 0x21, 0xad, 0x3f, 0x01, 0xfe) 1282 1283 /* 1284 * Common header for Hyper-V ICs 1285 */ 1286 1287 #define ICMSGTYPE_NEGOTIATE 0 1288 #define ICMSGTYPE_HEARTBEAT 1 1289 #define ICMSGTYPE_KVPEXCHANGE 2 1290 #define ICMSGTYPE_SHUTDOWN 3 1291 #define ICMSGTYPE_TIMESYNC 4 1292 #define ICMSGTYPE_VSS 5 1293 1294 #define ICMSGHDRFLAG_TRANSACTION 1 1295 #define ICMSGHDRFLAG_REQUEST 2 1296 #define ICMSGHDRFLAG_RESPONSE 4 1297 1298 1299 /* 1300 * While we want to handle util services as regular devices, 1301 * there is only one instance of each of these services; so 1302 * we statically allocate the service specific state. 1303 */ 1304 1305 struct hv_util_service { 1306 u8 *recv_buffer; 1307 void *channel; 1308 void (*util_cb)(void *); 1309 int (*util_init)(struct hv_util_service *); 1310 void (*util_deinit)(void); 1311 }; 1312 1313 struct vmbuspipe_hdr { 1314 u32 flags; 1315 u32 msgsize; 1316 } __packed; 1317 1318 struct ic_version { 1319 u16 major; 1320 u16 minor; 1321 } __packed; 1322 1323 struct icmsg_hdr { 1324 struct ic_version icverframe; 1325 u16 icmsgtype; 1326 struct ic_version icvermsg; 1327 u16 icmsgsize; 1328 u32 status; 1329 u8 ictransaction_id; 1330 u8 icflags; 1331 u8 reserved[2]; 1332 } __packed; 1333 1334 struct icmsg_negotiate { 1335 u16 icframe_vercnt; 1336 u16 icmsg_vercnt; 1337 u32 reserved; 1338 struct ic_version icversion_data[1]; /* any size array */ 1339 } __packed; 1340 1341 struct shutdown_msg_data { 1342 u32 reason_code; 1343 u32 timeout_seconds; 1344 u32 flags; 1345 u8 display_message[2048]; 1346 } __packed; 1347 1348 struct heartbeat_msg_data { 1349 u64 seq_num; 1350 u32 reserved[8]; 1351 } __packed; 1352 1353 /* Time Sync IC defs */ 1354 #define ICTIMESYNCFLAG_PROBE 0 1355 #define ICTIMESYNCFLAG_SYNC 1 1356 #define ICTIMESYNCFLAG_SAMPLE 2 1357 1358 #ifdef __x86_64__ 1359 #define WLTIMEDELTA 116444736000000000L /* in 100ns unit */ 1360 #else 1361 #define WLTIMEDELTA 116444736000000000LL 1362 #endif 1363 1364 struct ictimesync_data { 1365 u64 parenttime; 1366 u64 childtime; 1367 u64 roundtriptime; 1368 u8 flags; 1369 } __packed; 1370 1371 struct ictimesync_ref_data { 1372 u64 parenttime; 1373 u64 vmreferencetime; 1374 u8 flags; 1375 char leapflags; 1376 char stratum; 1377 u8 reserved[3]; 1378 } __packed; 1379 1380 struct hyperv_service_callback { 1381 u8 msg_type; 1382 char *log_msg; 1383 uuid_le data; 1384 struct vmbus_channel *channel; 1385 void (*callback)(void *context); 1386 }; 1387 1388 #define MAX_SRV_VER 0x7ffffff 1389 extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf, 1390 const int *fw_version, int fw_vercnt, 1391 const int *srv_version, int srv_vercnt, 1392 int *nego_fw_version, int *nego_srv_version); 1393 1394 void hv_process_channel_removal(u32 relid); 1395 1396 void vmbus_setevent(struct vmbus_channel *channel); 1397 /* 1398 * Negotiated version with the Host. 1399 */ 1400 1401 extern __u32 vmbus_proto_version; 1402 1403 int vmbus_send_tl_connect_request(const uuid_le *shv_guest_servie_id, 1404 const uuid_le *shv_host_servie_id); 1405 void vmbus_set_event(struct vmbus_channel *channel); 1406 1407 /* Get the start of the ring buffer. */ 1408 static inline void * 1409 hv_get_ring_buffer(const struct hv_ring_buffer_info *ring_info) 1410 { 1411 return ring_info->ring_buffer->buffer; 1412 } 1413 1414 /* 1415 * Mask off host interrupt callback notifications 1416 */ 1417 static inline void hv_begin_read(struct hv_ring_buffer_info *rbi) 1418 { 1419 rbi->ring_buffer->interrupt_mask = 1; 1420 1421 /* make sure mask update is not reordered */ 1422 virt_mb(); 1423 } 1424 1425 /* 1426 * Re-enable host callback and return number of outstanding bytes 1427 */ 1428 static inline u32 hv_end_read(struct hv_ring_buffer_info *rbi) 1429 { 1430 1431 rbi->ring_buffer->interrupt_mask = 0; 1432 1433 /* make sure mask update is not reordered */ 1434 virt_mb(); 1435 1436 /* 1437 * Now check to see if the ring buffer is still empty. 1438 * If it is not, we raced and we need to process new 1439 * incoming messages. 1440 */ 1441 return hv_get_bytes_to_read(rbi); 1442 } 1443 1444 /* 1445 * An API to support in-place processing of incoming VMBUS packets. 1446 */ 1447 1448 /* Get data payload associated with descriptor */ 1449 static inline void *hv_pkt_data(const struct vmpacket_descriptor *desc) 1450 { 1451 return (void *)((unsigned long)desc + (desc->offset8 << 3)); 1452 } 1453 1454 /* Get data size associated with descriptor */ 1455 static inline u32 hv_pkt_datalen(const struct vmpacket_descriptor *desc) 1456 { 1457 return (desc->len8 << 3) - (desc->offset8 << 3); 1458 } 1459 1460 1461 struct vmpacket_descriptor * 1462 hv_pkt_iter_first(struct vmbus_channel *channel); 1463 1464 struct vmpacket_descriptor * 1465 __hv_pkt_iter_next(struct vmbus_channel *channel, 1466 const struct vmpacket_descriptor *pkt); 1467 1468 void hv_pkt_iter_close(struct vmbus_channel *channel); 1469 1470 /* 1471 * Get next packet descriptor from iterator 1472 * If at end of list, return NULL and update host. 1473 */ 1474 static inline struct vmpacket_descriptor * 1475 hv_pkt_iter_next(struct vmbus_channel *channel, 1476 const struct vmpacket_descriptor *pkt) 1477 { 1478 struct vmpacket_descriptor *nxt; 1479 1480 nxt = __hv_pkt_iter_next(channel, pkt); 1481 if (!nxt) 1482 hv_pkt_iter_close(channel); 1483 1484 return nxt; 1485 } 1486 1487 #define foreach_vmbus_pkt(pkt, channel) \ 1488 for (pkt = hv_pkt_iter_first(channel); pkt; \ 1489 pkt = hv_pkt_iter_next(channel, pkt)) 1490 1491 #endif /* _HYPERV_H */ 1492