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