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