1 /*- 2 * Copyright (c) 2009-2012 Microsoft Corp. 3 * Copyright (c) 2012 NetApp Inc. 4 * Copyright (c) 2012 Citrix Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice unmodified, this list of conditions, and the following 12 * disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 * $FreeBSD$ 29 */ 30 31 /** 32 * HyperV definitions for messages that are sent between instances of the 33 * Channel Management Library in separate partitions, or in some cases, 34 * back to itself. 35 */ 36 37 #ifndef __HYPERV_H__ 38 #define __HYPERV_H__ 39 40 #include <sys/param.h> 41 #include <sys/mbuf.h> 42 #include <sys/queue.h> 43 #include <sys/malloc.h> 44 #include <sys/kthread.h> 45 #include <sys/taskqueue.h> 46 #include <sys/systm.h> 47 #include <sys/lock.h> 48 #include <sys/sema.h> 49 #include <sys/smp.h> 50 #include <sys/mutex.h> 51 #include <sys/bus.h> 52 #include <vm/vm.h> 53 #include <vm/vm_param.h> 54 #include <vm/pmap.h> 55 56 #include <amd64/include/xen/synch_bitops.h> 57 #include <amd64/include/atomic.h> 58 59 typedef uint8_t hv_bool_uint8_t; 60 61 #define HV_S_OK 0x00000000 62 #define HV_E_FAIL 0x80004005 63 #define HV_ERROR_NOT_SUPPORTED 0x80070032 64 #define HV_ERROR_MACHINE_LOCKED 0x800704F7 65 66 /* 67 * VMBUS version is 32 bit, upper 16 bit for major_number and lower 68 * 16 bit for minor_number. 69 * 70 * 0.13 -- Windows Server 2008 71 * 1.1 -- Windows 7 72 * 2.4 -- Windows 8 73 * 3.0 -- Windows 8.1 74 */ 75 #define HV_VMBUS_VERSION_WS2008 ((0 << 16) | (13)) 76 #define HV_VMBUS_VERSION_WIN7 ((1 << 16) | (1)) 77 #define HV_VMBUS_VERSION_WIN8 ((2 << 16) | (4)) 78 #define HV_VMBUS_VERSION_WIN8_1 ((3 << 16) | (0)) 79 80 #define HV_VMBUS_VERSION_INVALID -1 81 82 #define HV_VMBUS_VERSION_CURRENT HV_VMBUS_VERSION_WIN8_1 83 84 /* 85 * Make maximum size of pipe payload of 16K 86 */ 87 88 #define HV_MAX_PIPE_DATA_PAYLOAD (sizeof(BYTE) * 16384) 89 90 /* 91 * Define pipe_mode values 92 */ 93 94 #define HV_VMBUS_PIPE_TYPE_BYTE 0x00000000 95 #define HV_VMBUS_PIPE_TYPE_MESSAGE 0x00000004 96 97 /* 98 * The size of the user defined data buffer for non-pipe offers 99 */ 100 101 #define HV_MAX_USER_DEFINED_BYTES 120 102 103 /* 104 * The size of the user defined data buffer for pipe offers 105 */ 106 107 #define HV_MAX_PIPE_USER_DEFINED_BYTES 116 108 109 110 #define HV_MAX_PAGE_BUFFER_COUNT 32 111 #define HV_MAX_MULTIPAGE_BUFFER_COUNT 32 112 113 #define HV_ALIGN_UP(value, align) \ 114 (((value) & (align-1)) ? \ 115 (((value) + (align-1)) & ~(align-1) ) : (value)) 116 117 #define HV_ALIGN_DOWN(value, align) ( (value) & ~(align-1) ) 118 119 #define HV_NUM_PAGES_SPANNED(addr, len) \ 120 ((HV_ALIGN_UP(addr+len, PAGE_SIZE) - \ 121 HV_ALIGN_DOWN(addr, PAGE_SIZE)) >> PAGE_SHIFT ) 122 123 typedef struct hv_guid { 124 unsigned char data[16]; 125 } __packed hv_guid; 126 127 #define HV_NIC_GUID \ 128 .data = {0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46, \ 129 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E} 130 131 #define HV_IDE_GUID \ 132 .data = {0x32, 0x26, 0x41, 0x32, 0xcb, 0x86, 0xa2, 0x44, \ 133 0x9b, 0x5c, 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5} 134 135 #define HV_SCSI_GUID \ 136 .data = {0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d, \ 137 0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f} 138 139 /* 140 * At the center of the Channel Management library is 141 * the Channel Offer. This struct contains the 142 * fundamental information about an offer. 143 */ 144 145 typedef struct hv_vmbus_channel_offer { 146 hv_guid interface_type; 147 hv_guid interface_instance; 148 uint64_t interrupt_latency_in_100ns_units; 149 uint32_t interface_revision; 150 uint32_t server_context_area_size; /* in bytes */ 151 uint16_t channel_flags; 152 uint16_t mmio_megabytes; /* in bytes * 1024 * 1024 */ 153 union 154 { 155 /* 156 * Non-pipes: The user has HV_MAX_USER_DEFINED_BYTES bytes. 157 */ 158 struct { 159 uint8_t user_defined[HV_MAX_USER_DEFINED_BYTES]; 160 } __packed standard; 161 162 /* 163 * Pipes: The following structure is an integrated pipe protocol, which 164 * is implemented on top of standard user-defined data. pipe 165 * clients have HV_MAX_PIPE_USER_DEFINED_BYTES left for their 166 * own use. 167 */ 168 struct { 169 uint32_t pipe_mode; 170 uint8_t user_defined[HV_MAX_PIPE_USER_DEFINED_BYTES]; 171 } __packed pipe; 172 } u; 173 174 /* 175 * Sub_channel_index, newly added in Win8. 176 */ 177 uint16_t sub_channel_index; 178 uint16_t padding; 179 180 } __packed hv_vmbus_channel_offer; 181 182 typedef uint32_t hv_gpadl_handle; 183 184 typedef struct { 185 uint16_t type; 186 uint16_t data_offset8; 187 uint16_t length8; 188 uint16_t flags; 189 uint64_t transaction_id; 190 } __packed hv_vm_packet_descriptor; 191 192 typedef uint32_t hv_previous_packet_offset; 193 194 typedef struct { 195 hv_previous_packet_offset previous_packet_start_offset; 196 hv_vm_packet_descriptor descriptor; 197 } __packed hv_vm_packet_header; 198 199 typedef struct { 200 uint32_t byte_count; 201 uint32_t byte_offset; 202 } __packed hv_vm_transfer_page; 203 204 typedef struct { 205 hv_vm_packet_descriptor d; 206 uint16_t transfer_page_set_id; 207 hv_bool_uint8_t sender_owns_set; 208 uint8_t reserved; 209 uint32_t range_count; 210 hv_vm_transfer_page ranges[1]; 211 } __packed hv_vm_transfer_page_packet_header; 212 213 typedef struct { 214 hv_vm_packet_descriptor d; 215 uint32_t gpadl; 216 uint32_t reserved; 217 } __packed hv_vm_gpadl_packet_header; 218 219 typedef struct { 220 hv_vm_packet_descriptor d; 221 uint32_t gpadl; 222 uint16_t transfer_page_set_id; 223 uint16_t reserved; 224 } __packed hv_vm_add_remove_transfer_page_set; 225 226 /* 227 * This structure defines a range in guest 228 * physical space that can be made 229 * to look virtually contiguous. 230 */ 231 232 typedef struct { 233 uint32_t byte_count; 234 uint32_t byte_offset; 235 uint64_t pfn_array[0]; 236 } __packed hv_gpa_range; 237 238 /* 239 * This is the format for an Establish Gpadl packet, which contains a handle 240 * by which this GPADL will be known and a set of GPA ranges associated with 241 * it. This can be converted to a MDL by the guest OS. If there are multiple 242 * GPA ranges, then the resulting MDL will be "chained," representing multiple 243 * VA ranges. 244 */ 245 246 typedef struct { 247 hv_vm_packet_descriptor d; 248 uint32_t gpadl; 249 uint32_t range_count; 250 hv_gpa_range range[1]; 251 } __packed hv_vm_establish_gpadl; 252 253 /* 254 * This is the format for a Teardown Gpadl packet, which indicates that the 255 * GPADL handle in the Establish Gpadl packet will never be referenced again. 256 */ 257 258 typedef struct { 259 hv_vm_packet_descriptor d; 260 uint32_t gpadl; 261 /* for alignment to a 8-byte boundary */ 262 uint32_t reserved; 263 } __packed hv_vm_teardown_gpadl; 264 265 /* 266 * This is the format for a GPA-Direct packet, which contains a set of GPA 267 * ranges, in addition to commands and/or data. 268 */ 269 270 typedef struct { 271 hv_vm_packet_descriptor d; 272 uint32_t reserved; 273 uint32_t range_count; 274 hv_gpa_range range[1]; 275 } __packed hv_vm_data_gpa_direct; 276 277 /* 278 * This is the format for a Additional data Packet. 279 */ 280 typedef struct { 281 hv_vm_packet_descriptor d; 282 uint64_t total_bytes; 283 uint32_t byte_offset; 284 uint32_t byte_count; 285 uint8_t data[1]; 286 } __packed hv_vm_additional_data; 287 288 typedef union { 289 hv_vm_packet_descriptor simple_header; 290 hv_vm_transfer_page_packet_header transfer_page_header; 291 hv_vm_gpadl_packet_header gpadl_header; 292 hv_vm_add_remove_transfer_page_set add_remove_transfer_page_header; 293 hv_vm_establish_gpadl establish_gpadl_header; 294 hv_vm_teardown_gpadl teardown_gpadl_header; 295 hv_vm_data_gpa_direct data_gpa_direct_header; 296 } __packed hv_vm_packet_largest_possible_header; 297 298 typedef enum { 299 HV_VMBUS_PACKET_TYPE_INVALID = 0x0, 300 HV_VMBUS_PACKET_TYPES_SYNCH = 0x1, 301 HV_VMBUS_PACKET_TYPE_ADD_TRANSFER_PAGE_SET = 0x2, 302 HV_VMBUS_PACKET_TYPE_REMOVE_TRANSFER_PAGE_SET = 0x3, 303 HV_VMBUS_PACKET_TYPE_ESTABLISH_GPADL = 0x4, 304 HV_VMBUS_PACKET_TYPE_TEAR_DOWN_GPADL = 0x5, 305 HV_VMBUS_PACKET_TYPE_DATA_IN_BAND = 0x6, 306 HV_VMBUS_PACKET_TYPE_DATA_USING_TRANSFER_PAGES = 0x7, 307 HV_VMBUS_PACKET_TYPE_DATA_USING_GPADL = 0x8, 308 HV_VMBUS_PACKET_TYPE_DATA_USING_GPA_DIRECT = 0x9, 309 HV_VMBUS_PACKET_TYPE_CANCEL_REQUEST = 0xa, 310 HV_VMBUS_PACKET_TYPE_COMPLETION = 0xb, 311 HV_VMBUS_PACKET_TYPE_DATA_USING_ADDITIONAL_PACKETS = 0xc, 312 HV_VMBUS_PACKET_TYPE_ADDITIONAL_DATA = 0xd 313 } hv_vmbus_packet_type; 314 315 #define HV_VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED 1 316 317 /* 318 * Version 1 messages 319 */ 320 typedef enum { 321 HV_CHANNEL_MESSAGE_INVALID = 0, 322 HV_CHANNEL_MESSAGE_OFFER_CHANNEL = 1, 323 HV_CHANNEL_MESSAGE_RESCIND_CHANNEL_OFFER = 2, 324 HV_CHANNEL_MESSAGE_REQUEST_OFFERS = 3, 325 HV_CHANNEL_MESSAGE_ALL_OFFERS_DELIVERED = 4, 326 HV_CHANNEL_MESSAGE_OPEN_CHANNEL = 5, 327 HV_CHANNEL_MESSAGE_OPEN_CHANNEL_RESULT = 6, 328 HV_CHANNEL_MESSAGE_CLOSE_CHANNEL = 7, 329 HV_CHANNEL_MESSAGEL_GPADL_HEADER = 8, 330 HV_CHANNEL_MESSAGE_GPADL_BODY = 9, 331 HV_CHANNEL_MESSAGE_GPADL_CREATED = 10, 332 HV_CHANNEL_MESSAGE_GPADL_TEARDOWN = 11, 333 HV_CHANNEL_MESSAGE_GPADL_TORNDOWN = 12, 334 HV_CHANNEL_MESSAGE_REL_ID_RELEASED = 13, 335 HV_CHANNEL_MESSAGE_INITIATED_CONTACT = 14, 336 HV_CHANNEL_MESSAGE_VERSION_RESPONSE = 15, 337 HV_CHANNEL_MESSAGE_UNLOAD = 16, 338 339 #ifdef HV_VMBUS_FEATURE_PARENT_OR_PEER_MEMORY_MAPPED_INTO_A_CHILD 340 HV_CHANNEL_MESSAGE_VIEW_RANGE_ADD = 17, 341 HV_CHANNEL_MESSAGE_VIEW_RANGE_REMOVE = 18, 342 #endif 343 HV_CHANNEL_MESSAGE_COUNT 344 } hv_vmbus_channel_msg_type; 345 346 typedef struct { 347 hv_vmbus_channel_msg_type message_type; 348 uint32_t padding; 349 } __packed hv_vmbus_channel_msg_header; 350 351 /* 352 * Query VMBus Version parameters 353 */ 354 typedef struct { 355 hv_vmbus_channel_msg_header header; 356 uint32_t version; 357 } __packed hv_vmbus_channel_query_vmbus_version; 358 359 /* 360 * VMBus Version Supported parameters 361 */ 362 typedef struct { 363 hv_vmbus_channel_msg_header header; 364 hv_bool_uint8_t version_supported; 365 } __packed hv_vmbus_channel_version_supported; 366 367 /* 368 * Channel Offer parameters 369 */ 370 typedef struct { 371 hv_vmbus_channel_msg_header header; 372 hv_vmbus_channel_offer offer; 373 uint32_t child_rel_id; 374 uint8_t monitor_id; 375 /* 376 * This field has been split into a bit field on Win7 377 * and higher. 378 */ 379 uint8_t monitor_allocated:1; 380 uint8_t reserved:7; 381 /* 382 * Following fields were added in win7 and higher. 383 * Make sure to check the version before accessing these fields. 384 * 385 * If "is_dedicated_interrupt" is set, we must not set the 386 * associated bit in the channel bitmap while sending the 387 * interrupt to the host. 388 * 389 * connection_id is used in signaling the host. 390 */ 391 uint16_t is_dedicated_interrupt:1; 392 uint16_t reserved1:15; 393 uint32_t connection_id; 394 } __packed hv_vmbus_channel_offer_channel; 395 396 /* 397 * Rescind Offer parameters 398 */ 399 typedef struct 400 { 401 hv_vmbus_channel_msg_header header; 402 uint32_t child_rel_id; 403 } __packed hv_vmbus_channel_rescind_offer; 404 405 406 /* 407 * Request Offer -- no parameters, SynIC message contains the partition ID 408 * 409 * Set Snoop -- no parameters, SynIC message contains the partition ID 410 * 411 * Clear Snoop -- no parameters, SynIC message contains the partition ID 412 * 413 * All Offers Delivered -- no parameters, SynIC message contains the 414 * partition ID 415 * 416 * Flush Client -- no parameters, SynIC message contains the partition ID 417 */ 418 419 420 /* 421 * Open Channel parameters 422 */ 423 typedef struct 424 { 425 hv_vmbus_channel_msg_header header; 426 427 /* 428 * Identifies the specific VMBus channel that is being opened. 429 */ 430 uint32_t child_rel_id; 431 432 /* 433 * ID making a particular open request at a channel offer unique. 434 */ 435 uint32_t open_id; 436 437 /* 438 * GPADL for the channel's ring buffer. 439 */ 440 hv_gpadl_handle ring_buffer_gpadl_handle; 441 442 /* 443 * Before win8, all incoming channel interrupts are only 444 * delivered on cpu 0. Setting this value to 0 would 445 * preserve the earlier behavior. 446 */ 447 uint32_t target_vcpu; 448 449 /* 450 * The upstream ring buffer begins at offset zero in the memory described 451 * by ring_buffer_gpadl_handle. The downstream ring buffer follows it at 452 * this offset (in pages). 453 */ 454 uint32_t downstream_ring_buffer_page_offset; 455 456 /* 457 * User-specific data to be passed along to the server endpoint. 458 */ 459 uint8_t user_data[HV_MAX_USER_DEFINED_BYTES]; 460 461 } __packed hv_vmbus_channel_open_channel; 462 463 typedef uint32_t hv_nt_status; 464 465 /* 466 * Open Channel Result parameters 467 */ 468 typedef struct 469 { 470 hv_vmbus_channel_msg_header header; 471 uint32_t child_rel_id; 472 uint32_t open_id; 473 hv_nt_status status; 474 } __packed hv_vmbus_channel_open_result; 475 476 /* 477 * Close channel parameters 478 */ 479 typedef struct 480 { 481 hv_vmbus_channel_msg_header header; 482 uint32_t child_rel_id; 483 } __packed hv_vmbus_channel_close_channel; 484 485 /* 486 * Channel Message GPADL 487 */ 488 #define HV_GPADL_TYPE_RING_BUFFER 1 489 #define HV_GPADL_TYPE_SERVER_SAVE_AREA 2 490 #define HV_GPADL_TYPE_TRANSACTION 8 491 492 /* 493 * The number of PFNs in a GPADL message is defined by the number of pages 494 * that would be spanned by byte_count and byte_offset. If the implied number 495 * of PFNs won't fit in this packet, there will be a follow-up packet that 496 * contains more 497 */ 498 499 typedef struct { 500 hv_vmbus_channel_msg_header header; 501 uint32_t child_rel_id; 502 uint32_t gpadl; 503 uint16_t range_buf_len; 504 uint16_t range_count; 505 hv_gpa_range range[0]; 506 } __packed hv_vmbus_channel_gpadl_header; 507 508 /* 509 * This is the follow-up packet that contains more PFNs 510 */ 511 typedef struct { 512 hv_vmbus_channel_msg_header header; 513 uint32_t message_number; 514 uint32_t gpadl; 515 uint64_t pfn[0]; 516 } __packed hv_vmbus_channel_gpadl_body; 517 518 typedef struct { 519 hv_vmbus_channel_msg_header header; 520 uint32_t child_rel_id; 521 uint32_t gpadl; 522 uint32_t creation_status; 523 } __packed hv_vmbus_channel_gpadl_created; 524 525 typedef struct { 526 hv_vmbus_channel_msg_header header; 527 uint32_t child_rel_id; 528 uint32_t gpadl; 529 } __packed hv_vmbus_channel_gpadl_teardown; 530 531 typedef struct { 532 hv_vmbus_channel_msg_header header; 533 uint32_t gpadl; 534 } __packed hv_vmbus_channel_gpadl_torndown; 535 536 typedef struct { 537 hv_vmbus_channel_msg_header header; 538 uint32_t child_rel_id; 539 } __packed hv_vmbus_channel_relid_released; 540 541 typedef struct { 542 hv_vmbus_channel_msg_header header; 543 uint32_t vmbus_version_requested; 544 uint32_t padding2; 545 uint64_t interrupt_page; 546 uint64_t monitor_page_1; 547 uint64_t monitor_page_2; 548 } __packed hv_vmbus_channel_initiate_contact; 549 550 typedef struct { 551 hv_vmbus_channel_msg_header header; 552 hv_bool_uint8_t version_supported; 553 } __packed hv_vmbus_channel_version_response; 554 555 typedef hv_vmbus_channel_msg_header hv_vmbus_channel_unload; 556 557 #define HW_MACADDR_LEN 6 558 559 /* 560 * Fixme: Added to quiet "typeof" errors involving hv_vmbus.h when 561 * the including C file was compiled with "-std=c99". 562 */ 563 #ifndef typeof 564 #define typeof __typeof 565 #endif 566 567 #ifndef NULL 568 #define NULL (void *)0 569 #endif 570 571 typedef void *hv_vmbus_handle; 572 573 #ifndef CONTAINING_RECORD 574 #define CONTAINING_RECORD(address, type, field) ((type *)( \ 575 (uint8_t *)(address) - \ 576 (uint8_t *)(&((type *)0)->field))) 577 #endif /* CONTAINING_RECORD */ 578 579 580 #define container_of(ptr, type, member) ({ \ 581 __typeof__( ((type *)0)->member ) *__mptr = (ptr); \ 582 (type *)( (char *)__mptr - offsetof(type,member) );}) 583 584 enum { 585 HV_VMBUS_IVAR_TYPE, 586 HV_VMBUS_IVAR_INSTANCE, 587 HV_VMBUS_IVAR_NODE, 588 HV_VMBUS_IVAR_DEVCTX 589 }; 590 591 #define HV_VMBUS_ACCESSOR(var, ivar, type) \ 592 __BUS_ACCESSOR(vmbus, var, HV_VMBUS, ivar, type) 593 594 HV_VMBUS_ACCESSOR(type, TYPE, const char *) 595 HV_VMBUS_ACCESSOR(devctx, DEVCTX, struct hv_device *) 596 597 598 /* 599 * Common defines for Hyper-V ICs 600 */ 601 #define HV_ICMSGTYPE_NEGOTIATE 0 602 #define HV_ICMSGTYPE_HEARTBEAT 1 603 #define HV_ICMSGTYPE_KVPEXCHANGE 2 604 #define HV_ICMSGTYPE_SHUTDOWN 3 605 #define HV_ICMSGTYPE_TIMESYNC 4 606 #define HV_ICMSGTYPE_VSS 5 607 608 #define HV_ICMSGHDRFLAG_TRANSACTION 1 609 #define HV_ICMSGHDRFLAG_REQUEST 2 610 #define HV_ICMSGHDRFLAG_RESPONSE 4 611 612 typedef struct hv_vmbus_pipe_hdr { 613 uint32_t flags; 614 uint32_t msgsize; 615 } __packed hv_vmbus_pipe_hdr; 616 617 typedef struct hv_vmbus_ic_version { 618 uint16_t major; 619 uint16_t minor; 620 } __packed hv_vmbus_ic_version; 621 622 typedef struct hv_vmbus_icmsg_hdr { 623 hv_vmbus_ic_version icverframe; 624 uint16_t icmsgtype; 625 hv_vmbus_ic_version icvermsg; 626 uint16_t icmsgsize; 627 uint32_t status; 628 uint8_t ictransaction_id; 629 uint8_t icflags; 630 uint8_t reserved[2]; 631 } __packed hv_vmbus_icmsg_hdr; 632 633 typedef struct hv_vmbus_icmsg_negotiate { 634 uint16_t icframe_vercnt; 635 uint16_t icmsg_vercnt; 636 uint32_t reserved; 637 hv_vmbus_ic_version icversion_data[1]; /* any size array */ 638 } __packed hv_vmbus_icmsg_negotiate; 639 640 typedef struct hv_vmbus_shutdown_msg_data { 641 uint32_t reason_code; 642 uint32_t timeout_seconds; 643 uint32_t flags; 644 uint8_t display_message[2048]; 645 } __packed hv_vmbus_shutdown_msg_data; 646 647 typedef struct hv_vmbus_heartbeat_msg_data { 648 uint64_t seq_num; 649 uint32_t reserved[8]; 650 } __packed hv_vmbus_heartbeat_msg_data; 651 652 typedef struct { 653 /* 654 * offset in bytes from the start of ring data below 655 */ 656 volatile uint32_t write_index; 657 /* 658 * offset in bytes from the start of ring data below 659 */ 660 volatile uint32_t read_index; 661 /* 662 * NOTE: The interrupt_mask field is used only for channels, but 663 * vmbus connection also uses this data structure 664 */ 665 volatile uint32_t interrupt_mask; 666 /* pad it to PAGE_SIZE so that data starts on a page */ 667 uint8_t reserved[4084]; 668 669 /* 670 * WARNING: Ring data starts here + ring_data_start_offset 671 * !!! DO NOT place any fields below this !!! 672 */ 673 uint8_t buffer[0]; /* doubles as interrupt mask */ 674 } __packed hv_vmbus_ring_buffer; 675 676 typedef struct { 677 int length; 678 int offset; 679 uint64_t pfn; 680 } __packed hv_vmbus_page_buffer; 681 682 typedef struct { 683 int length; 684 int offset; 685 uint64_t pfn_array[HV_MAX_MULTIPAGE_BUFFER_COUNT]; 686 } __packed hv_vmbus_multipage_buffer; 687 688 typedef struct { 689 hv_vmbus_ring_buffer* ring_buffer; 690 uint32_t ring_size; /* Include the shared header */ 691 struct mtx ring_lock; 692 uint32_t ring_data_size; /* ring_size */ 693 uint32_t ring_data_start_offset; 694 } hv_vmbus_ring_buffer_info; 695 696 typedef void (*hv_vmbus_pfn_channel_callback)(void *context); 697 typedef void (*hv_vmbus_sc_creation_callback)(void *context); 698 699 typedef enum { 700 HV_CHANNEL_OFFER_STATE, 701 HV_CHANNEL_OPENING_STATE, 702 HV_CHANNEL_OPEN_STATE, 703 HV_CHANNEL_OPENED_STATE, 704 HV_CHANNEL_CLOSING_NONDESTRUCTIVE_STATE, 705 } hv_vmbus_channel_state; 706 707 /* 708 * Connection identifier type 709 */ 710 typedef union { 711 uint32_t as_uint32_t; 712 struct { 713 uint32_t id:24; 714 uint32_t reserved:8; 715 } u; 716 717 } __packed hv_vmbus_connection_id; 718 719 /* 720 * Definition of the hv_vmbus_signal_event hypercall input structure 721 */ 722 typedef struct { 723 hv_vmbus_connection_id connection_id; 724 uint16_t flag_number; 725 uint16_t rsvd_z; 726 } __packed hv_vmbus_input_signal_event; 727 728 typedef struct { 729 uint64_t align8; 730 hv_vmbus_input_signal_event event; 731 } __packed hv_vmbus_input_signal_event_buffer; 732 733 typedef struct hv_vmbus_channel { 734 TAILQ_ENTRY(hv_vmbus_channel) list_entry; 735 struct hv_device* device; 736 hv_vmbus_channel_state state; 737 hv_vmbus_channel_offer_channel offer_msg; 738 /* 739 * These are based on the offer_msg.monitor_id. 740 * Save it here for easy access. 741 */ 742 uint8_t monitor_group; 743 uint8_t monitor_bit; 744 745 uint32_t ring_buffer_gpadl_handle; 746 /* 747 * Allocated memory for ring buffer 748 */ 749 void* ring_buffer_pages; 750 unsigned long ring_buffer_size; 751 uint32_t ring_buffer_page_count; 752 /* 753 * send to parent 754 */ 755 hv_vmbus_ring_buffer_info outbound; 756 /* 757 * receive from parent 758 */ 759 hv_vmbus_ring_buffer_info inbound; 760 761 struct mtx inbound_lock; 762 hv_vmbus_handle control_work_queue; 763 764 hv_vmbus_pfn_channel_callback on_channel_callback; 765 void* channel_callback_context; 766 767 /* 768 * If batched_reading is set to "true", mask the interrupt 769 * and read until the channel is empty. 770 * If batched_reading is set to "false", the channel is not 771 * going to perform batched reading. 772 * 773 * Batched reading is enabled by default; specific 774 * drivers that don't want this behavior can turn it off. 775 */ 776 boolean_t batched_reading; 777 778 boolean_t is_dedicated_interrupt; 779 780 /* 781 * Used as an input param for HV_CALL_SIGNAL_EVENT hypercall. 782 */ 783 hv_vmbus_input_signal_event_buffer signal_event_buffer; 784 /* 785 * 8-bytes aligned of the buffer above 786 */ 787 hv_vmbus_input_signal_event *signal_event_param; 788 789 /* 790 * From Win8, this field specifies the target virtual process 791 * on which to deliver the interupt from the host to guest. 792 * Before Win8, all channel interrupts would only be 793 * delivered on cpu 0. Setting this value to 0 would preserve 794 * the earlier behavior. 795 */ 796 uint32_t target_vcpu; 797 /* The corresponding CPUID in the guest */ 798 uint32_t target_cpu; 799 800 /* 801 * Support for multi-channels. 802 * The initial offer is considered the primary channel and this 803 * offer message will indicate if the host supports multi-channels. 804 * The guest is free to ask for multi-channels to be offerred and can 805 * open these multi-channels as a normal "primary" channel. However, 806 * all multi-channels will have the same type and instance guids as the 807 * primary channel. Requests sent on a given channel will result in a 808 * response on the same channel. 809 */ 810 811 /* 812 * Multi-channel creation callback. This callback will be called in 813 * process context when a Multi-channel offer is received from the host. 814 * The guest can open the Multi-channel in the context of this callback. 815 */ 816 hv_vmbus_sc_creation_callback sc_creation_callback; 817 818 struct mtx sc_lock; 819 820 /* 821 * Link list of all the multi-channels if this is a primary channel 822 */ 823 TAILQ_HEAD(, hv_vmbus_channel) sc_list_anchor; 824 TAILQ_ENTRY(hv_vmbus_channel) sc_list_entry; 825 826 /* 827 * The primary channel this sub-channle belongs to. 828 * This will be NULL for the primary channel. 829 */ 830 struct hv_vmbus_channel *primary_channel; 831 /* 832 * Support per channel state for use by vmbus drivers. 833 */ 834 void *per_channel_state; 835 } hv_vmbus_channel; 836 837 static inline void 838 hv_set_channel_read_state(hv_vmbus_channel* channel, boolean_t state) 839 { 840 channel->batched_reading = state; 841 } 842 843 typedef struct hv_device { 844 hv_guid class_id; 845 hv_guid device_id; 846 device_t device; 847 hv_vmbus_channel* channel; 848 } hv_device; 849 850 851 852 int hv_vmbus_channel_recv_packet( 853 hv_vmbus_channel* channel, 854 void* buffer, 855 uint32_t buffer_len, 856 uint32_t* buffer_actual_len, 857 uint64_t* request_id); 858 859 int hv_vmbus_channel_recv_packet_raw( 860 hv_vmbus_channel* channel, 861 void* buffer, 862 uint32_t buffer_len, 863 uint32_t* buffer_actual_len, 864 uint64_t* request_id); 865 866 int hv_vmbus_channel_open( 867 hv_vmbus_channel* channel, 868 uint32_t send_ring_buffer_size, 869 uint32_t recv_ring_buffer_size, 870 void* user_data, 871 uint32_t user_data_len, 872 hv_vmbus_pfn_channel_callback 873 pfn_on_channel_callback, 874 void* context); 875 876 void hv_vmbus_channel_close(hv_vmbus_channel *channel); 877 878 int hv_vmbus_channel_send_packet( 879 hv_vmbus_channel* channel, 880 void* buffer, 881 uint32_t buffer_len, 882 uint64_t request_id, 883 hv_vmbus_packet_type type, 884 uint32_t flags); 885 886 int hv_vmbus_channel_send_packet_pagebuffer( 887 hv_vmbus_channel* channel, 888 hv_vmbus_page_buffer page_buffers[], 889 uint32_t page_count, 890 void* buffer, 891 uint32_t buffer_len, 892 uint64_t request_id); 893 894 int hv_vmbus_channel_send_packet_multipagebuffer( 895 hv_vmbus_channel* channel, 896 hv_vmbus_multipage_buffer* multi_page_buffer, 897 void* buffer, 898 uint32_t buffer_len, 899 uint64_t request_id); 900 901 int hv_vmbus_channel_establish_gpadl( 902 hv_vmbus_channel* channel, 903 /* must be phys and virt contiguous */ 904 void* contig_buffer, 905 /* page-size multiple */ 906 uint32_t size, 907 uint32_t* gpadl_handle); 908 909 int hv_vmbus_channel_teardown_gpdal( 910 hv_vmbus_channel* channel, 911 uint32_t gpadl_handle); 912 913 struct hv_vmbus_channel* vmbus_select_outgoing_channel(struct hv_vmbus_channel *promary); 914 915 /* 916 * Work abstraction defines 917 */ 918 typedef struct hv_work_queue { 919 struct taskqueue* queue; 920 struct proc* proc; 921 struct sema* work_sema; 922 } hv_work_queue; 923 924 typedef struct hv_work_item { 925 struct task work; 926 void (*callback)(void *); 927 void* context; 928 hv_work_queue* wq; 929 } hv_work_item; 930 931 struct hv_work_queue* hv_work_queue_create(char* name); 932 933 void hv_work_queue_close(struct hv_work_queue* wq); 934 935 int hv_queue_work_item( 936 hv_work_queue* wq, 937 void (*callback)(void *), 938 void* context); 939 /** 940 * @brief Get physical address from virtual 941 */ 942 static inline unsigned long 943 hv_get_phys_addr(void *virt) 944 { 945 unsigned long ret; 946 ret = (vtophys(virt) | ((vm_offset_t) virt & PAGE_MASK)); 947 return (ret); 948 } 949 950 951 /** 952 * KVP related structures 953 * 954 */ 955 typedef struct hv_vmbus_service { 956 hv_guid guid; /* Hyper-V GUID */ 957 char *name; /* name of service */ 958 boolean_t enabled; /* service enabled */ 959 hv_work_queue *work_queue; /* background work queue */ 960 961 /* 962 * function to initialize service 963 */ 964 int (*init)(struct hv_vmbus_service *); 965 966 /* 967 * function to process Hyper-V messages 968 */ 969 void (*callback)(void *); 970 } hv_vmbus_service; 971 972 extern uint8_t* receive_buffer[]; 973 extern hv_vmbus_service service_table[]; 974 extern uint32_t hv_vmbus_protocal_version; 975 976 void hv_kvp_callback(void *context); 977 int hv_kvp_init(hv_vmbus_service *serv); 978 void hv_kvp_deinit(void); 979 980 #endif /* __HYPERV_H__ */ 981 982