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/workqueue.h> 35 #include <linux/completion.h> 36 #include <linux/device.h> 37 #include <linux/mod_devicetable.h> 38 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 * Win8 uses some of the reserved bits to implement 93 * interrupt driven flow management. On the send side 94 * we can request that the receiver interrupt the sender 95 * when the ring transitions from being full to being able 96 * to handle a message of size "pending_send_sz". 97 * 98 * Add necessary state for this enhancement. 99 */ 100 u32 pending_send_sz; 101 102 u32 reserved1[12]; 103 104 union { 105 struct { 106 u32 feat_pending_send_sz:1; 107 }; 108 u32 value; 109 } feature_bits; 110 111 /* Pad it to PAGE_SIZE so that data starts on page boundary */ 112 u8 reserved2[4028]; 113 114 /* 115 * Ring data starts here + RingDataStartOffset 116 * !!! DO NOT place any fields below this !!! 117 */ 118 u8 buffer[0]; 119 } __packed; 120 121 struct hv_ring_buffer_info { 122 struct hv_ring_buffer *ring_buffer; 123 u32 ring_size; /* Include the shared header */ 124 spinlock_t ring_lock; 125 126 u32 ring_datasize; /* < ring_size */ 127 u32 ring_data_startoffset; 128 }; 129 130 /* 131 * 132 * hv_get_ringbuffer_availbytes() 133 * 134 * Get number of bytes available to read and to write to 135 * for the specified ring buffer 136 */ 137 static inline void 138 hv_get_ringbuffer_availbytes(struct hv_ring_buffer_info *rbi, 139 u32 *read, u32 *write) 140 { 141 u32 read_loc, write_loc, dsize; 142 143 smp_read_barrier_depends(); 144 145 /* Capture the read/write indices before they changed */ 146 read_loc = rbi->ring_buffer->read_index; 147 write_loc = rbi->ring_buffer->write_index; 148 dsize = rbi->ring_datasize; 149 150 *write = write_loc >= read_loc ? dsize - (write_loc - read_loc) : 151 read_loc - write_loc; 152 *read = dsize - *write; 153 } 154 155 /* 156 * VMBUS version is 32 bit entity broken up into 157 * two 16 bit quantities: major_number. minor_number. 158 * 159 * 0 . 13 (Windows Server 2008) 160 * 1 . 1 (Windows 7) 161 * 2 . 4 (Windows 8) 162 * 3 . 0 (Windows 8 R2) 163 */ 164 165 #define VERSION_WS2008 ((0 << 16) | (13)) 166 #define VERSION_WIN7 ((1 << 16) | (1)) 167 #define VERSION_WIN8 ((2 << 16) | (4)) 168 #define VERSION_WIN8_1 ((3 << 16) | (0)) 169 170 #define VERSION_INVAL -1 171 172 #define VERSION_CURRENT VERSION_WIN8_1 173 174 /* Make maximum size of pipe payload of 16K */ 175 #define MAX_PIPE_DATA_PAYLOAD (sizeof(u8) * 16384) 176 177 /* Define PipeMode values. */ 178 #define VMBUS_PIPE_TYPE_BYTE 0x00000000 179 #define VMBUS_PIPE_TYPE_MESSAGE 0x00000004 180 181 /* The size of the user defined data buffer for non-pipe offers. */ 182 #define MAX_USER_DEFINED_BYTES 120 183 184 /* The size of the user defined data buffer for pipe offers. */ 185 #define MAX_PIPE_USER_DEFINED_BYTES 116 186 187 /* 188 * At the center of the Channel Management library is the Channel Offer. This 189 * struct contains the fundamental information about an offer. 190 */ 191 struct vmbus_channel_offer { 192 uuid_le if_type; 193 uuid_le if_instance; 194 195 /* 196 * These two fields are not currently used. 197 */ 198 u64 reserved1; 199 u64 reserved2; 200 201 u16 chn_flags; 202 u16 mmio_megabytes; /* in bytes * 1024 * 1024 */ 203 204 union { 205 /* Non-pipes: The user has MAX_USER_DEFINED_BYTES bytes. */ 206 struct { 207 unsigned char user_def[MAX_USER_DEFINED_BYTES]; 208 } std; 209 210 /* 211 * Pipes: 212 * The following sructure is an integrated pipe protocol, which 213 * is implemented on top of standard user-defined data. Pipe 214 * clients have MAX_PIPE_USER_DEFINED_BYTES left for their own 215 * use. 216 */ 217 struct { 218 u32 pipe_mode; 219 unsigned char user_def[MAX_PIPE_USER_DEFINED_BYTES]; 220 } pipe; 221 } u; 222 /* 223 * The sub_channel_index is defined in win8. 224 */ 225 u16 sub_channel_index; 226 u16 reserved3; 227 } __packed; 228 229 /* Server Flags */ 230 #define VMBUS_CHANNEL_ENUMERATE_DEVICE_INTERFACE 1 231 #define VMBUS_CHANNEL_SERVER_SUPPORTS_TRANSFER_PAGES 2 232 #define VMBUS_CHANNEL_SERVER_SUPPORTS_GPADLS 4 233 #define VMBUS_CHANNEL_NAMED_PIPE_MODE 0x10 234 #define VMBUS_CHANNEL_LOOPBACK_OFFER 0x100 235 #define VMBUS_CHANNEL_PARENT_OFFER 0x200 236 #define VMBUS_CHANNEL_REQUEST_MONITORED_NOTIFICATION 0x400 237 238 struct vmpacket_descriptor { 239 u16 type; 240 u16 offset8; 241 u16 len8; 242 u16 flags; 243 u64 trans_id; 244 } __packed; 245 246 struct vmpacket_header { 247 u32 prev_pkt_start_offset; 248 struct vmpacket_descriptor descriptor; 249 } __packed; 250 251 struct vmtransfer_page_range { 252 u32 byte_count; 253 u32 byte_offset; 254 } __packed; 255 256 struct vmtransfer_page_packet_header { 257 struct vmpacket_descriptor d; 258 u16 xfer_pageset_id; 259 u8 sender_owns_set; 260 u8 reserved; 261 u32 range_cnt; 262 struct vmtransfer_page_range ranges[1]; 263 } __packed; 264 265 struct vmgpadl_packet_header { 266 struct vmpacket_descriptor d; 267 u32 gpadl; 268 u32 reserved; 269 } __packed; 270 271 struct vmadd_remove_transfer_page_set { 272 struct vmpacket_descriptor d; 273 u32 gpadl; 274 u16 xfer_pageset_id; 275 u16 reserved; 276 } __packed; 277 278 /* 279 * This structure defines a range in guest physical space that can be made to 280 * look virtually contiguous. 281 */ 282 struct gpa_range { 283 u32 byte_count; 284 u32 byte_offset; 285 u64 pfn_array[0]; 286 }; 287 288 /* 289 * This is the format for an Establish Gpadl packet, which contains a handle by 290 * which this GPADL will be known and a set of GPA ranges associated with it. 291 * This can be converted to a MDL by the guest OS. If there are multiple GPA 292 * ranges, then the resulting MDL will be "chained," representing multiple VA 293 * ranges. 294 */ 295 struct vmestablish_gpadl { 296 struct vmpacket_descriptor d; 297 u32 gpadl; 298 u32 range_cnt; 299 struct gpa_range range[1]; 300 } __packed; 301 302 /* 303 * This is the format for a Teardown Gpadl packet, which indicates that the 304 * GPADL handle in the Establish Gpadl packet will never be referenced again. 305 */ 306 struct vmteardown_gpadl { 307 struct vmpacket_descriptor d; 308 u32 gpadl; 309 u32 reserved; /* for alignment to a 8-byte boundary */ 310 } __packed; 311 312 /* 313 * This is the format for a GPA-Direct packet, which contains a set of GPA 314 * ranges, in addition to commands and/or data. 315 */ 316 struct vmdata_gpa_direct { 317 struct vmpacket_descriptor d; 318 u32 reserved; 319 u32 range_cnt; 320 struct gpa_range range[1]; 321 } __packed; 322 323 /* This is the format for a Additional Data Packet. */ 324 struct vmadditional_data { 325 struct vmpacket_descriptor d; 326 u64 total_bytes; 327 u32 offset; 328 u32 byte_cnt; 329 unsigned char data[1]; 330 } __packed; 331 332 union vmpacket_largest_possible_header { 333 struct vmpacket_descriptor simple_hdr; 334 struct vmtransfer_page_packet_header xfer_page_hdr; 335 struct vmgpadl_packet_header gpadl_hdr; 336 struct vmadd_remove_transfer_page_set add_rm_xfer_page_hdr; 337 struct vmestablish_gpadl establish_gpadl_hdr; 338 struct vmteardown_gpadl teardown_gpadl_hdr; 339 struct vmdata_gpa_direct data_gpa_direct_hdr; 340 }; 341 342 #define VMPACKET_DATA_START_ADDRESS(__packet) \ 343 (void *)(((unsigned char *)__packet) + \ 344 ((struct vmpacket_descriptor)__packet)->offset8 * 8) 345 346 #define VMPACKET_DATA_LENGTH(__packet) \ 347 ((((struct vmpacket_descriptor)__packet)->len8 - \ 348 ((struct vmpacket_descriptor)__packet)->offset8) * 8) 349 350 #define VMPACKET_TRANSFER_MODE(__packet) \ 351 (((struct IMPACT)__packet)->type) 352 353 enum vmbus_packet_type { 354 VM_PKT_INVALID = 0x0, 355 VM_PKT_SYNCH = 0x1, 356 VM_PKT_ADD_XFER_PAGESET = 0x2, 357 VM_PKT_RM_XFER_PAGESET = 0x3, 358 VM_PKT_ESTABLISH_GPADL = 0x4, 359 VM_PKT_TEARDOWN_GPADL = 0x5, 360 VM_PKT_DATA_INBAND = 0x6, 361 VM_PKT_DATA_USING_XFER_PAGES = 0x7, 362 VM_PKT_DATA_USING_GPADL = 0x8, 363 VM_PKT_DATA_USING_GPA_DIRECT = 0x9, 364 VM_PKT_CANCEL_REQUEST = 0xa, 365 VM_PKT_COMP = 0xb, 366 VM_PKT_DATA_USING_ADDITIONAL_PKT = 0xc, 367 VM_PKT_ADDITIONAL_DATA = 0xd 368 }; 369 370 #define VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED 1 371 372 373 /* Version 1 messages */ 374 enum vmbus_channel_message_type { 375 CHANNELMSG_INVALID = 0, 376 CHANNELMSG_OFFERCHANNEL = 1, 377 CHANNELMSG_RESCIND_CHANNELOFFER = 2, 378 CHANNELMSG_REQUESTOFFERS = 3, 379 CHANNELMSG_ALLOFFERS_DELIVERED = 4, 380 CHANNELMSG_OPENCHANNEL = 5, 381 CHANNELMSG_OPENCHANNEL_RESULT = 6, 382 CHANNELMSG_CLOSECHANNEL = 7, 383 CHANNELMSG_GPADL_HEADER = 8, 384 CHANNELMSG_GPADL_BODY = 9, 385 CHANNELMSG_GPADL_CREATED = 10, 386 CHANNELMSG_GPADL_TEARDOWN = 11, 387 CHANNELMSG_GPADL_TORNDOWN = 12, 388 CHANNELMSG_RELID_RELEASED = 13, 389 CHANNELMSG_INITIATE_CONTACT = 14, 390 CHANNELMSG_VERSION_RESPONSE = 15, 391 CHANNELMSG_UNLOAD = 16, 392 CHANNELMSG_UNLOAD_RESPONSE = 17, 393 CHANNELMSG_COUNT 394 }; 395 396 struct vmbus_channel_message_header { 397 enum vmbus_channel_message_type msgtype; 398 u32 padding; 399 } __packed; 400 401 /* Query VMBus Version parameters */ 402 struct vmbus_channel_query_vmbus_version { 403 struct vmbus_channel_message_header header; 404 u32 version; 405 } __packed; 406 407 /* VMBus Version Supported parameters */ 408 struct vmbus_channel_version_supported { 409 struct vmbus_channel_message_header header; 410 u8 version_supported; 411 } __packed; 412 413 /* Offer Channel parameters */ 414 struct vmbus_channel_offer_channel { 415 struct vmbus_channel_message_header header; 416 struct vmbus_channel_offer offer; 417 u32 child_relid; 418 u8 monitorid; 419 /* 420 * win7 and beyond splits this field into a bit field. 421 */ 422 u8 monitor_allocated:1; 423 u8 reserved:7; 424 /* 425 * These are new fields added in win7 and later. 426 * Do not access these fields without checking the 427 * negotiated protocol. 428 * 429 * If "is_dedicated_interrupt" is set, we must not set the 430 * associated bit in the channel bitmap while sending the 431 * interrupt to the host. 432 * 433 * connection_id is to be used in signaling the host. 434 */ 435 u16 is_dedicated_interrupt:1; 436 u16 reserved1:15; 437 u32 connection_id; 438 } __packed; 439 440 /* Rescind Offer parameters */ 441 struct vmbus_channel_rescind_offer { 442 struct vmbus_channel_message_header header; 443 u32 child_relid; 444 } __packed; 445 446 /* 447 * Request Offer -- no parameters, SynIC message contains the partition ID 448 * Set Snoop -- no parameters, SynIC message contains the partition ID 449 * Clear Snoop -- no parameters, SynIC message contains the partition ID 450 * All Offers Delivered -- no parameters, SynIC message contains the partition 451 * ID 452 * Flush Client -- no parameters, SynIC message contains the partition ID 453 */ 454 455 /* Open Channel parameters */ 456 struct vmbus_channel_open_channel { 457 struct vmbus_channel_message_header header; 458 459 /* Identifies the specific VMBus channel that is being opened. */ 460 u32 child_relid; 461 462 /* ID making a particular open request at a channel offer unique. */ 463 u32 openid; 464 465 /* GPADL for the channel's ring buffer. */ 466 u32 ringbuffer_gpadlhandle; 467 468 /* 469 * Starting with win8, this field will be used to specify 470 * the target virtual processor on which to deliver the interrupt for 471 * the host to guest communication. 472 * Prior to win8, incoming channel interrupts would only 473 * be delivered on cpu 0. Setting this value to 0 would 474 * preserve the earlier behavior. 475 */ 476 u32 target_vp; 477 478 /* 479 * The upstream ring buffer begins at offset zero in the memory 480 * described by RingBufferGpadlHandle. The downstream ring buffer 481 * follows it at this offset (in pages). 482 */ 483 u32 downstream_ringbuffer_pageoffset; 484 485 /* User-specific data to be passed along to the server endpoint. */ 486 unsigned char userdata[MAX_USER_DEFINED_BYTES]; 487 } __packed; 488 489 /* Open Channel Result parameters */ 490 struct vmbus_channel_open_result { 491 struct vmbus_channel_message_header header; 492 u32 child_relid; 493 u32 openid; 494 u32 status; 495 } __packed; 496 497 /* Close channel parameters; */ 498 struct vmbus_channel_close_channel { 499 struct vmbus_channel_message_header header; 500 u32 child_relid; 501 } __packed; 502 503 /* Channel Message GPADL */ 504 #define GPADL_TYPE_RING_BUFFER 1 505 #define GPADL_TYPE_SERVER_SAVE_AREA 2 506 #define GPADL_TYPE_TRANSACTION 8 507 508 /* 509 * The number of PFNs in a GPADL message is defined by the number of 510 * pages that would be spanned by ByteCount and ByteOffset. If the 511 * implied number of PFNs won't fit in this packet, there will be a 512 * follow-up packet that contains more. 513 */ 514 struct vmbus_channel_gpadl_header { 515 struct vmbus_channel_message_header header; 516 u32 child_relid; 517 u32 gpadl; 518 u16 range_buflen; 519 u16 rangecount; 520 struct gpa_range range[0]; 521 } __packed; 522 523 /* This is the followup packet that contains more PFNs. */ 524 struct vmbus_channel_gpadl_body { 525 struct vmbus_channel_message_header header; 526 u32 msgnumber; 527 u32 gpadl; 528 u64 pfn[0]; 529 } __packed; 530 531 struct vmbus_channel_gpadl_created { 532 struct vmbus_channel_message_header header; 533 u32 child_relid; 534 u32 gpadl; 535 u32 creation_status; 536 } __packed; 537 538 struct vmbus_channel_gpadl_teardown { 539 struct vmbus_channel_message_header header; 540 u32 child_relid; 541 u32 gpadl; 542 } __packed; 543 544 struct vmbus_channel_gpadl_torndown { 545 struct vmbus_channel_message_header header; 546 u32 gpadl; 547 } __packed; 548 549 struct vmbus_channel_relid_released { 550 struct vmbus_channel_message_header header; 551 u32 child_relid; 552 } __packed; 553 554 struct vmbus_channel_initiate_contact { 555 struct vmbus_channel_message_header header; 556 u32 vmbus_version_requested; 557 u32 target_vcpu; /* The VCPU the host should respond to */ 558 u64 interrupt_page; 559 u64 monitor_page1; 560 u64 monitor_page2; 561 } __packed; 562 563 struct vmbus_channel_version_response { 564 struct vmbus_channel_message_header header; 565 u8 version_supported; 566 } __packed; 567 568 enum vmbus_channel_state { 569 CHANNEL_OFFER_STATE, 570 CHANNEL_OPENING_STATE, 571 CHANNEL_OPEN_STATE, 572 CHANNEL_OPENED_STATE, 573 }; 574 575 /* 576 * Represents each channel msg on the vmbus connection This is a 577 * variable-size data structure depending on the msg type itself 578 */ 579 struct vmbus_channel_msginfo { 580 /* Bookkeeping stuff */ 581 struct list_head msglistentry; 582 583 /* So far, this is only used to handle gpadl body message */ 584 struct list_head submsglist; 585 586 /* Synchronize the request/response if needed */ 587 struct completion waitevent; 588 union { 589 struct vmbus_channel_version_supported version_supported; 590 struct vmbus_channel_open_result open_result; 591 struct vmbus_channel_gpadl_torndown gpadl_torndown; 592 struct vmbus_channel_gpadl_created gpadl_created; 593 struct vmbus_channel_version_response version_response; 594 } response; 595 596 u32 msgsize; 597 /* 598 * The channel message that goes out on the "wire". 599 * It will contain at minimum the VMBUS_CHANNEL_MESSAGE_HEADER header 600 */ 601 unsigned char msg[0]; 602 }; 603 604 struct vmbus_close_msg { 605 struct vmbus_channel_msginfo info; 606 struct vmbus_channel_close_channel msg; 607 }; 608 609 /* Define connection identifier type. */ 610 union hv_connection_id { 611 u32 asu32; 612 struct { 613 u32 id:24; 614 u32 reserved:8; 615 } u; 616 }; 617 618 /* Definition of the hv_signal_event hypercall input structure. */ 619 struct hv_input_signal_event { 620 union hv_connection_id connectionid; 621 u16 flag_number; 622 u16 rsvdz; 623 }; 624 625 struct hv_input_signal_event_buffer { 626 u64 align8; 627 struct hv_input_signal_event event; 628 }; 629 630 struct vmbus_channel { 631 /* Unique channel id */ 632 int id; 633 634 struct list_head listentry; 635 636 struct hv_device *device_obj; 637 638 enum vmbus_channel_state state; 639 640 struct vmbus_channel_offer_channel offermsg; 641 /* 642 * These are based on the OfferMsg.MonitorId. 643 * Save it here for easy access. 644 */ 645 u8 monitor_grp; 646 u8 monitor_bit; 647 648 bool rescind; /* got rescind msg */ 649 650 u32 ringbuffer_gpadlhandle; 651 652 /* Allocated memory for ring buffer */ 653 void *ringbuffer_pages; 654 u32 ringbuffer_pagecount; 655 struct hv_ring_buffer_info outbound; /* send to parent */ 656 struct hv_ring_buffer_info inbound; /* receive from parent */ 657 spinlock_t inbound_lock; 658 659 struct vmbus_close_msg close_msg; 660 661 /* Channel callback are invoked in this workqueue context */ 662 /* HANDLE dataWorkQueue; */ 663 664 void (*onchannel_callback)(void *context); 665 void *channel_callback_context; 666 667 /* 668 * A channel can be marked for efficient (batched) 669 * reading: 670 * If batched_reading is set to "true", we read until the 671 * channel is empty and hold off interrupts from the host 672 * during the entire read process. 673 * If batched_reading is set to "false", the client is not 674 * going to perform batched reading. 675 * 676 * By default we will enable batched reading; specific 677 * drivers that don't want this behavior can turn it off. 678 */ 679 680 bool batched_reading; 681 682 bool is_dedicated_interrupt; 683 struct hv_input_signal_event_buffer sig_buf; 684 struct hv_input_signal_event *sig_event; 685 686 /* 687 * Starting with win8, this field will be used to specify 688 * the target virtual processor on which to deliver the interrupt for 689 * the host to guest communication. 690 * Prior to win8, incoming channel interrupts would only 691 * be delivered on cpu 0. Setting this value to 0 would 692 * preserve the earlier behavior. 693 */ 694 u32 target_vp; 695 /* The corresponding CPUID in the guest */ 696 u32 target_cpu; 697 /* 698 * Support for sub-channels. For high performance devices, 699 * it will be useful to have multiple sub-channels to support 700 * a scalable communication infrastructure with the host. 701 * The support for sub-channels is implemented as an extention 702 * to the current infrastructure. 703 * The initial offer is considered the primary channel and this 704 * offer message will indicate if the host supports sub-channels. 705 * The guest is free to ask for sub-channels to be offerred and can 706 * open these sub-channels as a normal "primary" channel. However, 707 * all sub-channels will have the same type and instance guids as the 708 * primary channel. Requests sent on a given channel will result in a 709 * response on the same channel. 710 */ 711 712 /* 713 * Sub-channel creation callback. This callback will be called in 714 * process context when a sub-channel offer is received from the host. 715 * The guest can open the sub-channel in the context of this callback. 716 */ 717 void (*sc_creation_callback)(struct vmbus_channel *new_sc); 718 719 /* 720 * The spinlock to protect the structure. It is being used to protect 721 * test-and-set access to various attributes of the structure as well 722 * as all sc_list operations. 723 */ 724 spinlock_t lock; 725 /* 726 * All Sub-channels of a primary channel are linked here. 727 */ 728 struct list_head sc_list; 729 /* 730 * Current number of sub-channels. 731 */ 732 int num_sc; 733 /* 734 * Number of a sub-channel (position within sc_list) which is supposed 735 * to be used as the next outgoing channel. 736 */ 737 int next_oc; 738 /* 739 * The primary channel this sub-channel belongs to. 740 * This will be NULL for the primary channel. 741 */ 742 struct vmbus_channel *primary_channel; 743 /* 744 * Support per-channel state for use by vmbus drivers. 745 */ 746 void *per_channel_state; 747 /* 748 * To support per-cpu lookup mapping of relid to channel, 749 * link up channels based on their CPU affinity. 750 */ 751 struct list_head percpu_list; 752 }; 753 754 static inline void set_channel_read_state(struct vmbus_channel *c, bool state) 755 { 756 c->batched_reading = state; 757 } 758 759 static inline void set_per_channel_state(struct vmbus_channel *c, void *s) 760 { 761 c->per_channel_state = s; 762 } 763 764 static inline void *get_per_channel_state(struct vmbus_channel *c) 765 { 766 return c->per_channel_state; 767 } 768 769 void vmbus_onmessage(void *context); 770 771 int vmbus_request_offers(void); 772 773 /* 774 * APIs for managing sub-channels. 775 */ 776 777 void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel, 778 void (*sc_cr_cb)(struct vmbus_channel *new_sc)); 779 780 /* 781 * Retrieve the (sub) channel on which to send an outgoing request. 782 * When a primary channel has multiple sub-channels, we choose a 783 * channel whose VCPU binding is closest to the VCPU on which 784 * this call is being made. 785 */ 786 struct vmbus_channel *vmbus_get_outgoing_channel(struct vmbus_channel *primary); 787 788 /* 789 * Check if sub-channels have already been offerred. This API will be useful 790 * when the driver is unloaded after establishing sub-channels. In this case, 791 * when the driver is re-loaded, the driver would have to check if the 792 * subchannels have already been established before attempting to request 793 * the creation of sub-channels. 794 * This function returns TRUE to indicate that subchannels have already been 795 * created. 796 * This function should be invoked after setting the callback function for 797 * sub-channel creation. 798 */ 799 bool vmbus_are_subchannels_present(struct vmbus_channel *primary); 800 801 /* The format must be the same as struct vmdata_gpa_direct */ 802 struct vmbus_channel_packet_page_buffer { 803 u16 type; 804 u16 dataoffset8; 805 u16 length8; 806 u16 flags; 807 u64 transactionid; 808 u32 reserved; 809 u32 rangecount; 810 struct hv_page_buffer range[MAX_PAGE_BUFFER_COUNT]; 811 } __packed; 812 813 /* The format must be the same as struct vmdata_gpa_direct */ 814 struct vmbus_channel_packet_multipage_buffer { 815 u16 type; 816 u16 dataoffset8; 817 u16 length8; 818 u16 flags; 819 u64 transactionid; 820 u32 reserved; 821 u32 rangecount; /* Always 1 in this case */ 822 struct hv_multipage_buffer range; 823 } __packed; 824 825 /* The format must be the same as struct vmdata_gpa_direct */ 826 struct vmbus_packet_mpb_array { 827 u16 type; 828 u16 dataoffset8; 829 u16 length8; 830 u16 flags; 831 u64 transactionid; 832 u32 reserved; 833 u32 rangecount; /* Always 1 in this case */ 834 struct hv_mpb_array range; 835 } __packed; 836 837 838 extern int vmbus_open(struct vmbus_channel *channel, 839 u32 send_ringbuffersize, 840 u32 recv_ringbuffersize, 841 void *userdata, 842 u32 userdatalen, 843 void(*onchannel_callback)(void *context), 844 void *context); 845 846 extern void vmbus_close(struct vmbus_channel *channel); 847 848 extern int vmbus_sendpacket(struct vmbus_channel *channel, 849 void *buffer, 850 u32 bufferLen, 851 u64 requestid, 852 enum vmbus_packet_type type, 853 u32 flags); 854 855 extern int vmbus_sendpacket_ctl(struct vmbus_channel *channel, 856 void *buffer, 857 u32 bufferLen, 858 u64 requestid, 859 enum vmbus_packet_type type, 860 u32 flags, 861 bool kick_q); 862 863 extern int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel, 864 struct hv_page_buffer pagebuffers[], 865 u32 pagecount, 866 void *buffer, 867 u32 bufferlen, 868 u64 requestid); 869 870 extern int vmbus_sendpacket_pagebuffer_ctl(struct vmbus_channel *channel, 871 struct hv_page_buffer pagebuffers[], 872 u32 pagecount, 873 void *buffer, 874 u32 bufferlen, 875 u64 requestid, 876 u32 flags, 877 bool kick_q); 878 879 extern int vmbus_sendpacket_multipagebuffer(struct vmbus_channel *channel, 880 struct hv_multipage_buffer *mpb, 881 void *buffer, 882 u32 bufferlen, 883 u64 requestid); 884 885 extern int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel, 886 struct vmbus_packet_mpb_array *mpb, 887 u32 desc_size, 888 void *buffer, 889 u32 bufferlen, 890 u64 requestid); 891 892 extern int vmbus_establish_gpadl(struct vmbus_channel *channel, 893 void *kbuffer, 894 u32 size, 895 u32 *gpadl_handle); 896 897 extern int vmbus_teardown_gpadl(struct vmbus_channel *channel, 898 u32 gpadl_handle); 899 900 extern int vmbus_recvpacket(struct vmbus_channel *channel, 901 void *buffer, 902 u32 bufferlen, 903 u32 *buffer_actual_len, 904 u64 *requestid); 905 906 extern int vmbus_recvpacket_raw(struct vmbus_channel *channel, 907 void *buffer, 908 u32 bufferlen, 909 u32 *buffer_actual_len, 910 u64 *requestid); 911 912 913 extern void vmbus_ontimer(unsigned long data); 914 915 /* Base driver object */ 916 struct hv_driver { 917 const char *name; 918 919 /* the device type supported by this driver */ 920 uuid_le dev_type; 921 const struct hv_vmbus_device_id *id_table; 922 923 struct device_driver driver; 924 925 int (*probe)(struct hv_device *, const struct hv_vmbus_device_id *); 926 int (*remove)(struct hv_device *); 927 void (*shutdown)(struct hv_device *); 928 929 }; 930 931 /* Base device object */ 932 struct hv_device { 933 /* the device type id of this device */ 934 uuid_le dev_type; 935 936 /* the device instance id of this device */ 937 uuid_le dev_instance; 938 939 struct device device; 940 941 struct vmbus_channel *channel; 942 }; 943 944 945 static inline struct hv_device *device_to_hv_device(struct device *d) 946 { 947 return container_of(d, struct hv_device, device); 948 } 949 950 static inline struct hv_driver *drv_to_hv_drv(struct device_driver *d) 951 { 952 return container_of(d, struct hv_driver, driver); 953 } 954 955 static inline void hv_set_drvdata(struct hv_device *dev, void *data) 956 { 957 dev_set_drvdata(&dev->device, data); 958 } 959 960 static inline void *hv_get_drvdata(struct hv_device *dev) 961 { 962 return dev_get_drvdata(&dev->device); 963 } 964 965 /* Vmbus interface */ 966 #define vmbus_driver_register(driver) \ 967 __vmbus_driver_register(driver, THIS_MODULE, KBUILD_MODNAME) 968 int __must_check __vmbus_driver_register(struct hv_driver *hv_driver, 969 struct module *owner, 970 const char *mod_name); 971 void vmbus_driver_unregister(struct hv_driver *hv_driver); 972 973 /** 974 * VMBUS_DEVICE - macro used to describe a specific hyperv vmbus device 975 * 976 * This macro is used to create a struct hv_vmbus_device_id that matches a 977 * specific device. 978 */ 979 #define VMBUS_DEVICE(g0, g1, g2, g3, g4, g5, g6, g7, \ 980 g8, g9, ga, gb, gc, gd, ge, gf) \ 981 .guid = { g0, g1, g2, g3, g4, g5, g6, g7, \ 982 g8, g9, ga, gb, gc, gd, ge, gf }, 983 984 /* 985 * GUID definitions of various offer types - services offered to the guest. 986 */ 987 988 /* 989 * Network GUID 990 * {f8615163-df3e-46c5-913f-f2d2f965ed0e} 991 */ 992 #define HV_NIC_GUID \ 993 .guid = { \ 994 0x63, 0x51, 0x61, 0xf8, 0x3e, 0xdf, 0xc5, 0x46, \ 995 0x91, 0x3f, 0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e \ 996 } 997 998 /* 999 * IDE GUID 1000 * {32412632-86cb-44a2-9b5c-50d1417354f5} 1001 */ 1002 #define HV_IDE_GUID \ 1003 .guid = { \ 1004 0x32, 0x26, 0x41, 0x32, 0xcb, 0x86, 0xa2, 0x44, \ 1005 0x9b, 0x5c, 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5 \ 1006 } 1007 1008 /* 1009 * SCSI GUID 1010 * {ba6163d9-04a1-4d29-b605-72e2ffb1dc7f} 1011 */ 1012 #define HV_SCSI_GUID \ 1013 .guid = { \ 1014 0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d, \ 1015 0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f \ 1016 } 1017 1018 /* 1019 * Shutdown GUID 1020 * {0e0b6031-5213-4934-818b-38d90ced39db} 1021 */ 1022 #define HV_SHUTDOWN_GUID \ 1023 .guid = { \ 1024 0x31, 0x60, 0x0b, 0x0e, 0x13, 0x52, 0x34, 0x49, \ 1025 0x81, 0x8b, 0x38, 0xd9, 0x0c, 0xed, 0x39, 0xdb \ 1026 } 1027 1028 /* 1029 * Time Synch GUID 1030 * {9527E630-D0AE-497b-ADCE-E80AB0175CAF} 1031 */ 1032 #define HV_TS_GUID \ 1033 .guid = { \ 1034 0x30, 0xe6, 0x27, 0x95, 0xae, 0xd0, 0x7b, 0x49, \ 1035 0xad, 0xce, 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf \ 1036 } 1037 1038 /* 1039 * Heartbeat GUID 1040 * {57164f39-9115-4e78-ab55-382f3bd5422d} 1041 */ 1042 #define HV_HEART_BEAT_GUID \ 1043 .guid = { \ 1044 0x39, 0x4f, 0x16, 0x57, 0x15, 0x91, 0x78, 0x4e, \ 1045 0xab, 0x55, 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d \ 1046 } 1047 1048 /* 1049 * KVP GUID 1050 * {a9a0f4e7-5a45-4d96-b827-8a841e8c03e6} 1051 */ 1052 #define HV_KVP_GUID \ 1053 .guid = { \ 1054 0xe7, 0xf4, 0xa0, 0xa9, 0x45, 0x5a, 0x96, 0x4d, \ 1055 0xb8, 0x27, 0x8a, 0x84, 0x1e, 0x8c, 0x3, 0xe6 \ 1056 } 1057 1058 /* 1059 * Dynamic memory GUID 1060 * {525074dc-8985-46e2-8057-a307dc18a502} 1061 */ 1062 #define HV_DM_GUID \ 1063 .guid = { \ 1064 0xdc, 0x74, 0x50, 0X52, 0x85, 0x89, 0xe2, 0x46, \ 1065 0x80, 0x57, 0xa3, 0x07, 0xdc, 0x18, 0xa5, 0x02 \ 1066 } 1067 1068 /* 1069 * Mouse GUID 1070 * {cfa8b69e-5b4a-4cc0-b98b-8ba1a1f3f95a} 1071 */ 1072 #define HV_MOUSE_GUID \ 1073 .guid = { \ 1074 0x9e, 0xb6, 0xa8, 0xcf, 0x4a, 0x5b, 0xc0, 0x4c, \ 1075 0xb9, 0x8b, 0x8b, 0xa1, 0xa1, 0xf3, 0xf9, 0x5a \ 1076 } 1077 1078 /* 1079 * VSS (Backup/Restore) GUID 1080 */ 1081 #define HV_VSS_GUID \ 1082 .guid = { \ 1083 0x29, 0x2e, 0xfa, 0x35, 0x23, 0xea, 0x36, 0x42, \ 1084 0x96, 0xae, 0x3a, 0x6e, 0xba, 0xcb, 0xa4, 0x40 \ 1085 } 1086 /* 1087 * Synthetic Video GUID 1088 * {DA0A7802-E377-4aac-8E77-0558EB1073F8} 1089 */ 1090 #define HV_SYNTHVID_GUID \ 1091 .guid = { \ 1092 0x02, 0x78, 0x0a, 0xda, 0x77, 0xe3, 0xac, 0x4a, \ 1093 0x8e, 0x77, 0x05, 0x58, 0xeb, 0x10, 0x73, 0xf8 \ 1094 } 1095 1096 /* 1097 * Synthetic FC GUID 1098 * {2f9bcc4a-0069-4af3-b76b-6fd0be528cda} 1099 */ 1100 #define HV_SYNTHFC_GUID \ 1101 .guid = { \ 1102 0x4A, 0xCC, 0x9B, 0x2F, 0x69, 0x00, 0xF3, 0x4A, \ 1103 0xB7, 0x6B, 0x6F, 0xD0, 0xBE, 0x52, 0x8C, 0xDA \ 1104 } 1105 1106 /* 1107 * Guest File Copy Service 1108 * {34D14BE3-DEE4-41c8-9AE7-6B174977C192} 1109 */ 1110 1111 #define HV_FCOPY_GUID \ 1112 .guid = { \ 1113 0xE3, 0x4B, 0xD1, 0x34, 0xE4, 0xDE, 0xC8, 0x41, \ 1114 0x9A, 0xE7, 0x6B, 0x17, 0x49, 0x77, 0xC1, 0x92 \ 1115 } 1116 1117 /* 1118 * NetworkDirect. This is the guest RDMA service. 1119 * {8c2eaf3d-32a7-4b09-ab99-bd1f1c86b501} 1120 */ 1121 #define HV_ND_GUID \ 1122 .guid = { \ 1123 0x3d, 0xaf, 0x2e, 0x8c, 0xa7, 0x32, 0x09, 0x4b, \ 1124 0xab, 0x99, 0xbd, 0x1f, 0x1c, 0x86, 0xb5, 0x01 \ 1125 } 1126 1127 /* 1128 * Common header for Hyper-V ICs 1129 */ 1130 1131 #define ICMSGTYPE_NEGOTIATE 0 1132 #define ICMSGTYPE_HEARTBEAT 1 1133 #define ICMSGTYPE_KVPEXCHANGE 2 1134 #define ICMSGTYPE_SHUTDOWN 3 1135 #define ICMSGTYPE_TIMESYNC 4 1136 #define ICMSGTYPE_VSS 5 1137 1138 #define ICMSGHDRFLAG_TRANSACTION 1 1139 #define ICMSGHDRFLAG_REQUEST 2 1140 #define ICMSGHDRFLAG_RESPONSE 4 1141 1142 1143 /* 1144 * While we want to handle util services as regular devices, 1145 * there is only one instance of each of these services; so 1146 * we statically allocate the service specific state. 1147 */ 1148 1149 struct hv_util_service { 1150 u8 *recv_buffer; 1151 void (*util_cb)(void *); 1152 int (*util_init)(struct hv_util_service *); 1153 void (*util_deinit)(void); 1154 }; 1155 1156 struct vmbuspipe_hdr { 1157 u32 flags; 1158 u32 msgsize; 1159 } __packed; 1160 1161 struct ic_version { 1162 u16 major; 1163 u16 minor; 1164 } __packed; 1165 1166 struct icmsg_hdr { 1167 struct ic_version icverframe; 1168 u16 icmsgtype; 1169 struct ic_version icvermsg; 1170 u16 icmsgsize; 1171 u32 status; 1172 u8 ictransaction_id; 1173 u8 icflags; 1174 u8 reserved[2]; 1175 } __packed; 1176 1177 struct icmsg_negotiate { 1178 u16 icframe_vercnt; 1179 u16 icmsg_vercnt; 1180 u32 reserved; 1181 struct ic_version icversion_data[1]; /* any size array */ 1182 } __packed; 1183 1184 struct shutdown_msg_data { 1185 u32 reason_code; 1186 u32 timeout_seconds; 1187 u32 flags; 1188 u8 display_message[2048]; 1189 } __packed; 1190 1191 struct heartbeat_msg_data { 1192 u64 seq_num; 1193 u32 reserved[8]; 1194 } __packed; 1195 1196 /* Time Sync IC defs */ 1197 #define ICTIMESYNCFLAG_PROBE 0 1198 #define ICTIMESYNCFLAG_SYNC 1 1199 #define ICTIMESYNCFLAG_SAMPLE 2 1200 1201 #ifdef __x86_64__ 1202 #define WLTIMEDELTA 116444736000000000L /* in 100ns unit */ 1203 #else 1204 #define WLTIMEDELTA 116444736000000000LL 1205 #endif 1206 1207 struct ictimesync_data { 1208 u64 parenttime; 1209 u64 childtime; 1210 u64 roundtriptime; 1211 u8 flags; 1212 } __packed; 1213 1214 struct hyperv_service_callback { 1215 u8 msg_type; 1216 char *log_msg; 1217 uuid_le data; 1218 struct vmbus_channel *channel; 1219 void (*callback) (void *context); 1220 }; 1221 1222 #define MAX_SRV_VER 0x7ffffff 1223 extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *, 1224 struct icmsg_negotiate *, u8 *, int, 1225 int); 1226 1227 void hv_process_channel_removal(struct vmbus_channel *channel, u32 relid); 1228 1229 extern struct resource hyperv_mmio; 1230 1231 /* 1232 * Negotiated version with the Host. 1233 */ 1234 1235 extern __u32 vmbus_proto_version; 1236 1237 #endif /* _HYPERV_H */ 1238