sys/dev/hyperv/include/hyperv.h

   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