sys/dev/hyperv/include/hyperv.h

   1 /*-
   2  * Copyright (c) 2009-2012,2016 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 <sys/sysctl.h>
  53 #include <vm/vm.h>
  54 #include <vm/vm_param.h>
  55 #include <vm/pmap.h>
  56
  57 #include <amd64/include/xen/synch_bitops.h>
  58 #include <amd64/include/atomic.h>
  59 #include <dev/hyperv/include/hyperv_busdma.h>
  60
  61 typedef uint8_t hv_bool_uint8_t;
  62
  63 #define HV_S_OK                 0x00000000
  64 #define HV_E_FAIL               0x80004005
  65 #define HV_ERROR_NOT_SUPPORTED  0x80070032
  66 #define HV_ERROR_MACHINE_LOCKED 0x800704F7
  67
  68 /*
  69  * VMBUS version is 32 bit, upper 16 bit for major_number and lower
  70  * 16 bit for minor_number.
  71  *
  72  * 0.13  --  Windows Server 2008
  73  * 1.1   --  Windows 7
  74  * 2.4   --  Windows 8
  75  * 3.0   --  Windows 8.1
  76  */
  77 #define VMBUS_VERSION_WS2008            ((0 << 16) | (13))
  78 #define VMBUS_VERSION_WIN7              ((1 << 16) | (1))
  79 #define VMBUS_VERSION_WIN8              ((2 << 16) | (4))
  80 #define VMBUS_VERSION_WIN8_1            ((3 << 16) | (0))
  81
  82 #define VMBUS_VERSION_MAJOR(ver)        (((uint32_t)(ver)) >> 16)
  83 #define VMBUS_VERSION_MINOR(ver)        (((uint32_t)(ver)) & 0xffff)
  84
  85 /*
  86  * Make maximum size of pipe payload of 16K
  87  */
  88
  89 #define HV_MAX_PIPE_DATA_PAYLOAD        (sizeof(BYTE) * 16384)
  90
  91 /*
  92  * Define pipe_mode values
  93  */
  94
  95 #define HV_VMBUS_PIPE_TYPE_BYTE         0x00000000
  96 #define HV_VMBUS_PIPE_TYPE_MESSAGE      0x00000004
  97
  98 /*
  99  * The size of the user defined data buffer for non-pipe offers
 100  */
 101
 102 #define HV_MAX_USER_DEFINED_BYTES       120
 103
 104 /*
 105  *  The size of the user defined data buffer for pipe offers
 106  */
 107
 108 #define HV_MAX_PIPE_USER_DEFINED_BYTES  116
 109
 110
 111 #define HV_MAX_PAGE_BUFFER_COUNT        32
 112 #define HV_MAX_MULTIPAGE_BUFFER_COUNT   32
 113
 114 #define HV_ALIGN_UP(value, align)                                       \
 115                 (((value) & (align-1)) ?                                \
 116                     (((value) + (align-1)) & ~(align-1) ) : (value))
 117
 118 #define HV_ALIGN_DOWN(value, align) ( (value) & ~(align-1) )
 119
 120 #define HV_NUM_PAGES_SPANNED(addr, len)                                 \
 121                 ((HV_ALIGN_UP(addr+len, PAGE_SIZE) -                    \
 122                     HV_ALIGN_DOWN(addr, PAGE_SIZE)) >> PAGE_SHIFT )
 123
 124 typedef struct hv_guid {
 125         uint8_t data[16];
 126 } __packed hv_guid;
 127
 128 #define HYPERV_GUID_STRLEN      40
 129
 130 int     hyperv_guid2str(const struct hv_guid *, char *, size_t);
 131
 132 #define HV_NIC_GUID                                                     \
 133         .data = {0x63, 0x51, 0x61, 0xF8, 0x3E, 0xDF, 0xc5, 0x46,        \
 134                 0x91, 0x3F, 0xF2, 0xD2, 0xF9, 0x65, 0xED, 0x0E}
 135
 136 #define HV_IDE_GUID                                                     \
 137         .data = {0x32, 0x26, 0x41, 0x32, 0xcb, 0x86, 0xa2, 0x44,        \
 138                  0x9b, 0x5c, 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5}
 139
 140 #define HV_SCSI_GUID                                                    \
 141         .data = {0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d,        \
 142                  0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f}
 143
 144 /*
 145  * At the center of the Channel Management library is
 146  * the Channel Offer. This struct contains the
 147  * fundamental information about an offer.
 148  */
 149
 150 typedef struct hv_vmbus_channel_offer {
 151         hv_guid         interface_type;
 152         hv_guid         interface_instance;
 153         uint64_t        interrupt_latency_in_100ns_units;
 154         uint32_t        interface_revision;
 155         uint32_t        server_context_area_size; /* in bytes */
 156         uint16_t        channel_flags;
 157         uint16_t        mmio_megabytes;           /* in bytes * 1024 * 1024 */
 158         union
 159         {
 160         /*
 161          * Non-pipes: The user has HV_MAX_USER_DEFINED_BYTES bytes.
 162          */
 163                 struct {
 164                         uint8_t user_defined[HV_MAX_USER_DEFINED_BYTES];
 165                 } __packed standard;
 166
 167         /*
 168          * Pipes: The following structure is an integrated pipe protocol, which
 169          *        is implemented on top of standard user-defined data. pipe
 170          *        clients  have HV_MAX_PIPE_USER_DEFINED_BYTES left for their
 171          *        own use.
 172          */
 173                 struct {
 174                         uint32_t        pipe_mode;
 175                         uint8_t user_defined[HV_MAX_PIPE_USER_DEFINED_BYTES];
 176                 } __packed pipe;
 177         } u;
 178
 179         /*
 180          * Sub_channel_index, newly added in Win8.
 181          */
 182         uint16_t        sub_channel_index;
 183         uint16_t        padding;
 184
 185 } __packed hv_vmbus_channel_offer;
 186
 187 typedef struct {
 188         uint16_t type;
 189         uint16_t data_offset8;
 190         uint16_t length8;
 191         uint16_t flags;
 192         uint64_t transaction_id;
 193 } __packed hv_vm_packet_descriptor;
 194
 195 typedef uint32_t hv_previous_packet_offset;
 196
 197 typedef struct {
 198         hv_previous_packet_offset       previous_packet_start_offset;
 199         hv_vm_packet_descriptor         descriptor;
 200 } __packed hv_vm_packet_header;
 201
 202 typedef struct {
 203         uint32_t byte_count;
 204         uint32_t byte_offset;
 205 } __packed hv_vm_transfer_page;
 206
 207 typedef struct {
 208         hv_vm_packet_descriptor d;
 209         uint16_t                transfer_page_set_id;
 210         hv_bool_uint8_t         sender_owns_set;
 211         uint8_t                 reserved;
 212         uint32_t                range_count;
 213         hv_vm_transfer_page     ranges[1];
 214 } __packed hv_vm_transfer_page_packet_header;
 215
 216 typedef struct {
 217         hv_vm_packet_descriptor d;
 218         uint32_t                gpadl;
 219         uint32_t                reserved;
 220 } __packed hv_vm_gpadl_packet_header;
 221
 222 typedef struct {
 223         hv_vm_packet_descriptor d;
 224         uint32_t                gpadl;
 225         uint16_t                transfer_page_set_id;
 226         uint16_t                reserved;
 227 } __packed hv_vm_add_remove_transfer_page_set;
 228
 229 /*
 230  * This structure defines a range in guest
 231  * physical space that can be made
 232  * to look virtually contiguous.
 233  */
 234
 235 typedef struct {
 236         uint32_t byte_count;
 237         uint32_t byte_offset;
 238         uint64_t pfn_array[0];
 239 } __packed hv_gpa_range;
 240
 241 /*
 242  * This is the format for an Establish Gpadl packet, which contains a handle
 243  * by which this GPADL will be known and a set of GPA ranges associated with
 244  * it.  This can be converted to a MDL by the guest OS.  If there are multiple
 245  * GPA ranges, then the resulting MDL will be "chained," representing multiple
 246  * VA ranges.
 247  */
 248
 249 typedef struct {
 250         hv_vm_packet_descriptor d;
 251         uint32_t                gpadl;
 252         uint32_t                range_count;
 253         hv_gpa_range            range[1];
 254 } __packed hv_vm_establish_gpadl;
 255
 256 /*
 257  * This is the format for a Teardown Gpadl packet, which indicates that the
 258  * GPADL handle in the Establish Gpadl packet will never be referenced again.
 259  */
 260
 261 typedef struct {
 262         hv_vm_packet_descriptor d;
 263         uint32_t                gpadl;
 264                                 /* for alignment to a 8-byte boundary */
 265         uint32_t                reserved;
 266 } __packed hv_vm_teardown_gpadl;
 267
 268 /*
 269  * This is the format for a GPA-Direct packet, which contains a set of GPA
 270  * ranges, in addition to commands and/or data.
 271  */
 272
 273 typedef struct {
 274         hv_vm_packet_descriptor d;
 275         uint32_t                reserved;
 276         uint32_t                range_count;
 277         hv_gpa_range            range[1];
 278 } __packed hv_vm_data_gpa_direct;
 279
 280 /*
 281  * This is the format for a Additional data Packet.
 282  */
 283 typedef struct {
 284         hv_vm_packet_descriptor d;
 285         uint64_t                total_bytes;
 286         uint32_t                byte_offset;
 287         uint32_t                byte_count;
 288         uint8_t                 data[1];
 289 } __packed hv_vm_additional_data;
 290
 291 typedef union {
 292         hv_vm_packet_descriptor             simple_header;
 293         hv_vm_transfer_page_packet_header   transfer_page_header;
 294         hv_vm_gpadl_packet_header           gpadl_header;
 295         hv_vm_add_remove_transfer_page_set  add_remove_transfer_page_header;
 296         hv_vm_establish_gpadl               establish_gpadl_header;
 297         hv_vm_teardown_gpadl                teardown_gpadl_header;
 298         hv_vm_data_gpa_direct               data_gpa_direct_header;
 299 } __packed hv_vm_packet_largest_possible_header;
 300
 301 typedef enum {
 302         HV_VMBUS_PACKET_TYPE_INVALID                            = 0x0,
 303         HV_VMBUS_PACKET_TYPES_SYNCH                             = 0x1,
 304         HV_VMBUS_PACKET_TYPE_ADD_TRANSFER_PAGE_SET              = 0x2,
 305         HV_VMBUS_PACKET_TYPE_REMOVE_TRANSFER_PAGE_SET           = 0x3,
 306         HV_VMBUS_PACKET_TYPE_ESTABLISH_GPADL                    = 0x4,
 307         HV_VMBUS_PACKET_TYPE_TEAR_DOWN_GPADL                    = 0x5,
 308         HV_VMBUS_PACKET_TYPE_DATA_IN_BAND                       = 0x6,
 309         HV_VMBUS_PACKET_TYPE_DATA_USING_TRANSFER_PAGES          = 0x7,
 310         HV_VMBUS_PACKET_TYPE_DATA_USING_GPADL                   = 0x8,
 311         HV_VMBUS_PACKET_TYPE_DATA_USING_GPA_DIRECT              = 0x9,
 312         HV_VMBUS_PACKET_TYPE_CANCEL_REQUEST                     = 0xa,
 313         HV_VMBUS_PACKET_TYPE_COMPLETION                         = 0xb,
 314         HV_VMBUS_PACKET_TYPE_DATA_USING_ADDITIONAL_PACKETS      = 0xc,
 315         HV_VMBUS_PACKET_TYPE_ADDITIONAL_DATA = 0xd
 316 } hv_vmbus_packet_type;
 317
 318 #define HV_VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED    1
 319
 320 /*
 321  * Version 1 messages
 322  */
 323 typedef enum {
 324         HV_CHANNEL_MESSAGE_INVALID                      = 0,
 325         HV_CHANNEL_MESSAGE_OFFER_CHANNEL                = 1,
 326         HV_CHANNEL_MESSAGE_RESCIND_CHANNEL_OFFER        = 2,
 327         HV_CHANNEL_MESSAGE_REQUEST_OFFERS               = 3,
 328         HV_CHANNEL_MESSAGE_ALL_OFFERS_DELIVERED         = 4,
 329         HV_CHANNEL_MESSAGE_OPEN_CHANNEL                 = 5,
 330         HV_CHANNEL_MESSAGE_OPEN_CHANNEL_RESULT          = 6,
 331         HV_CHANNEL_MESSAGE_CLOSE_CHANNEL                = 7,
 332         HV_CHANNEL_MESSAGEL_GPADL_HEADER                = 8,
 333         HV_CHANNEL_MESSAGE_GPADL_BODY                   = 9,
 334         HV_CHANNEL_MESSAGE_GPADL_CREATED                = 10,
 335         HV_CHANNEL_MESSAGE_GPADL_TEARDOWN               = 11,
 336         HV_CHANNEL_MESSAGE_GPADL_TORNDOWN               = 12,
 337         HV_CHANNEL_MESSAGE_REL_ID_RELEASED              = 13,
 338         HV_CHANNEL_MESSAGE_INITIATED_CONTACT            = 14,
 339         HV_CHANNEL_MESSAGE_VERSION_RESPONSE             = 15,
 340         HV_CHANNEL_MESSAGE_UNLOAD                       = 16,
 341         HV_CHANNEL_MESSAGE_COUNT
 342 } hv_vmbus_channel_msg_type;
 343
 344 typedef struct {
 345         hv_vmbus_channel_msg_type       message_type;
 346         uint32_t                        padding;
 347 } __packed hv_vmbus_channel_msg_header;
 348
 349 /*
 350  * Query VMBus Version parameters
 351  */
 352 typedef struct {
 353         hv_vmbus_channel_msg_header     header;
 354         uint32_t                        version;
 355 } __packed hv_vmbus_channel_query_vmbus_version;
 356
 357 /*
 358  * Channel Offer parameters
 359  */
 360 typedef struct {
 361         hv_vmbus_channel_msg_header     header;
 362         hv_vmbus_channel_offer          offer;
 363         uint32_t                        child_rel_id;
 364         uint8_t                         monitor_id;
 365         /*
 366          * This field has been split into a bit field on Win7
 367          * and higher.
 368          */
 369         uint8_t                         monitor_allocated:1;
 370         uint8_t                         reserved:7;
 371         /*
 372          * Following fields were added in win7 and higher.
 373          * Make sure to check the version before accessing these fields.
 374          *
 375          * If "is_dedicated_interrupt" is set, we must not set the
 376          * associated bit in the channel bitmap while sending the
 377          * interrupt to the host.
 378          *
 379          * connection_id is used in signaling the host.
 380          */
 381         uint16_t                        is_dedicated_interrupt:1;
 382         uint16_t                        reserved1:15;
 383         uint32_t                        connection_id;
 384 } __packed hv_vmbus_channel_offer_channel;
 385
 386 /*
 387  * Rescind Offer parameters
 388  */
 389 typedef struct
 390 {
 391     hv_vmbus_channel_msg_header header;
 392     uint32_t                    child_rel_id;
 393 } __packed hv_vmbus_channel_rescind_offer;
 394
 395 typedef struct {
 396         hv_vmbus_channel_msg_header     header;
 397         uint32_t                        child_rel_id;
 398 } __packed hv_vmbus_channel_relid_released;
 399
 400 #define HW_MACADDR_LEN  6
 401
 402 /*
 403  * Common defines for Hyper-V ICs
 404  */
 405 #define HV_ICMSGTYPE_NEGOTIATE          0
 406 #define HV_ICMSGTYPE_HEARTBEAT          1
 407 #define HV_ICMSGTYPE_KVPEXCHANGE        2
 408 #define HV_ICMSGTYPE_SHUTDOWN           3
 409 #define HV_ICMSGTYPE_TIMESYNC           4
 410 #define HV_ICMSGTYPE_VSS                5
 411
 412 #define HV_ICMSGHDRFLAG_TRANSACTION     1
 413 #define HV_ICMSGHDRFLAG_REQUEST         2
 414 #define HV_ICMSGHDRFLAG_RESPONSE        4
 415
 416 typedef struct hv_vmbus_pipe_hdr {
 417         uint32_t flags;
 418         uint32_t msgsize;
 419 } __packed hv_vmbus_pipe_hdr;
 420
 421 typedef struct hv_vmbus_ic_version {
 422         uint16_t major;
 423         uint16_t minor;
 424 } __packed hv_vmbus_ic_version;
 425
 426 typedef struct hv_vmbus_icmsg_hdr {
 427         hv_vmbus_ic_version     icverframe;
 428         uint16_t                icmsgtype;
 429         hv_vmbus_ic_version     icvermsg;
 430         uint16_t                icmsgsize;
 431         uint32_t                status;
 432         uint8_t                 ictransaction_id;
 433         uint8_t                 icflags;
 434         uint8_t                 reserved[2];
 435 } __packed hv_vmbus_icmsg_hdr;
 436
 437 typedef struct hv_vmbus_icmsg_negotiate {
 438         uint16_t                icframe_vercnt;
 439         uint16_t                icmsg_vercnt;
 440         uint32_t                reserved;
 441         hv_vmbus_ic_version     icversion_data[1]; /* any size array */
 442 } __packed hv_vmbus_icmsg_negotiate;
 443
 444 typedef struct hv_vmbus_shutdown_msg_data {
 445         uint32_t                reason_code;
 446         uint32_t                timeout_seconds;
 447         uint32_t                flags;
 448         uint8_t                 display_message[2048];
 449 } __packed hv_vmbus_shutdown_msg_data;
 450
 451 typedef struct hv_vmbus_heartbeat_msg_data {
 452         uint64_t                seq_num;
 453         uint32_t                reserved[8];
 454 } __packed hv_vmbus_heartbeat_msg_data;
 455
 456 typedef struct {
 457         /*
 458          * offset in bytes from the start of ring data below
 459          */
 460         volatile uint32_t       write_index;
 461         /*
 462          * offset in bytes from the start of ring data below
 463          */
 464         volatile uint32_t       read_index;
 465         /*
 466          * NOTE: The interrupt_mask field is used only for channels, but
 467          * vmbus connection also uses this data structure
 468          */
 469         volatile uint32_t       interrupt_mask;
 470         /* pad it to PAGE_SIZE so that data starts on a page */
 471         uint8_t                 reserved[4084];
 472
 473         /*
 474          * WARNING: Ring data starts here + ring_data_start_offset
 475          *  !!! DO NOT place any fields below this !!!
 476          */
 477         uint8_t                 buffer[0];      /* doubles as interrupt mask */
 478 } __packed hv_vmbus_ring_buffer;
 479
 480 typedef struct {
 481         int             length;
 482         int             offset;
 483         uint64_t        pfn;
 484 } __packed hv_vmbus_page_buffer;
 485
 486 typedef struct {
 487         int             length;
 488         int             offset;
 489         uint64_t        pfn_array[HV_MAX_MULTIPAGE_BUFFER_COUNT];
 490 } __packed hv_vmbus_multipage_buffer;
 491
 492 typedef struct {
 493         hv_vmbus_ring_buffer*   ring_buffer;
 494         uint32_t                ring_size;      /* Include the shared header */
 495         struct mtx              ring_lock;
 496         uint32_t                ring_data_size; /* ring_size */
 497         uint32_t                ring_data_start_offset;
 498 } hv_vmbus_ring_buffer_info;
 499
 500 typedef void (*hv_vmbus_pfn_channel_callback)(void *context);
 501
 502 typedef enum {
 503         HV_CHANNEL_OFFER_STATE,
 504         HV_CHANNEL_OPENING_STATE,
 505         HV_CHANNEL_OPEN_STATE,
 506         HV_CHANNEL_OPENED_STATE,
 507         HV_CHANNEL_CLOSING_NONDESTRUCTIVE_STATE,
 508 } hv_vmbus_channel_state;
 509
 510 /*
 511  *  Connection identifier type
 512  */
 513 typedef union {
 514         uint32_t                as_uint32_t;
 515         struct {
 516                 uint32_t        id:24;
 517                 uint32_t        reserved:8;
 518         } u;
 519
 520 } __packed hv_vmbus_connection_id;
 521
 522 typedef struct hv_vmbus_channel {
 523         device_t                        ch_dev;
 524         struct vmbus_softc              *vmbus_sc;
 525         hv_vmbus_channel_state          state;
 526         uint32_t                        ch_flags;       /* VMBUS_CHAN_FLAG_ */
 527         uint32_t                        ch_id;          /* channel id */
 528         /*
 529          * These are based on the offer_msg.monitor_id.
 530          * Save it here for easy access.
 531          */
 532         uint8_t                         monitor_group;
 533         uint8_t                         monitor_bit;
 534
 535         uint32_t                        ring_buffer_gpadl_handle;
 536         /*
 537          * Allocated memory for ring buffer
 538          */
 539         void*                           ring_buffer_pages;
 540         unsigned long                   ring_buffer_size;
 541         uint32_t                        ring_buffer_page_count;
 542         /*
 543          * send to parent
 544          */
 545         hv_vmbus_ring_buffer_info       outbound;
 546         /*
 547          * receive from parent
 548          */
 549         hv_vmbus_ring_buffer_info       inbound;
 550
 551         struct taskqueue *              rxq;
 552         struct task                     channel_task;
 553         hv_vmbus_pfn_channel_callback   on_channel_callback;
 554         void*                           channel_callback_context;
 555
 556         /*
 557          * If batched_reading is set to "true", mask the interrupt
 558          * and read until the channel is empty.
 559          * If batched_reading is set to "false", the channel is not
 560          * going to perform batched reading.
 561          *
 562          * Batched reading is enabled by default; specific
 563          * drivers that don't want this behavior can turn it off.
 564          */
 565         boolean_t                       batched_reading;
 566
 567         boolean_t                       is_dedicated_interrupt;
 568
 569         struct hypercall_sigevt_in      *ch_sigevt;
 570         struct hyperv_dma               ch_sigevt_dma;
 571
 572         /*
 573          * From Win8, this field specifies the target virtual process
 574          * on which to deliver the interupt from the host to guest.
 575          * Before Win8, all channel interrupts would only be
 576          * delivered on cpu 0. Setting this value to 0 would preserve
 577          * the earlier behavior.
 578          */
 579         uint32_t                        target_vcpu;
 580         /* The corresponding CPUID in the guest */
 581         uint32_t                        target_cpu;
 582
 583         /*
 584          * Support for multi-channels.
 585          * The initial offer is considered the primary channel and this
 586          * offer message will indicate if the host supports multi-channels.
 587          * The guest is free to ask for multi-channels to be offerred and can
 588          * open these multi-channels as a normal "primary" channel. However,
 589          * all multi-channels will have the same type and instance guids as the
 590          * primary channel. Requests sent on a given channel will result in a
 591          * response on the same channel.
 592          */
 593
 594         struct mtx                      sc_lock;
 595
 596         /*
 597          * Link list of all the multi-channels if this is a primary channel
 598          */
 599         TAILQ_HEAD(, hv_vmbus_channel)  sc_list_anchor;
 600         TAILQ_ENTRY(hv_vmbus_channel)   sc_list_entry;
 601         int                             subchan_cnt;
 602
 603         /*
 604          * The primary channel this sub-channle belongs to.
 605          * This will be NULL for the primary channel.
 606          */
 607         struct hv_vmbus_channel         *primary_channel;
 608
 609         /*
 610          * Driver private data
 611          */
 612         void                            *hv_chan_priv1;
 613         void                            *hv_chan_priv2;
 614         void                            *hv_chan_priv3;
 615
 616         struct task                     ch_detach_task;
 617         TAILQ_ENTRY(hv_vmbus_channel)   ch_link;
 618         uint32_t                        ch_subidx;      /* subchan index */
 619
 620         struct hv_guid                  ch_guid_type;
 621         struct hv_guid                  ch_guid_inst;
 622
 623         struct sysctl_ctx_list          ch_sysctl_ctx;
 624 } hv_vmbus_channel;
 625
 626 #define HV_VMBUS_CHAN_ISPRIMARY(chan)   ((chan)->primary_channel == NULL)
 627
 628 #define VMBUS_CHAN_FLAG_HASMNF          0x0001
 629
 630 static inline void
 631 hv_set_channel_read_state(hv_vmbus_channel* channel, boolean_t state)
 632 {
 633         channel->batched_reading = state;
 634 }
 635
 636 int             hv_vmbus_channel_recv_packet(
 637                                 hv_vmbus_channel*       channel,
 638                                 void*                   buffer,
 639                                 uint32_t                buffer_len,
 640                                 uint32_t*               buffer_actual_len,
 641                                 uint64_t*               request_id);
 642
 643 int             hv_vmbus_channel_recv_packet_raw(
 644                                 hv_vmbus_channel*       channel,
 645                                 void*                   buffer,
 646                                 uint32_t                buffer_len,
 647                                 uint32_t*               buffer_actual_len,
 648                                 uint64_t*               request_id);
 649
 650 int             hv_vmbus_channel_open(
 651                                 hv_vmbus_channel*       channel,
 652                                 uint32_t                send_ring_buffer_size,
 653                                 uint32_t                recv_ring_buffer_size,
 654                                 void*                   user_data,
 655                                 uint32_t                user_data_len,
 656                                 hv_vmbus_pfn_channel_callback
 657                                                         pfn_on_channel_callback,
 658                                 void*                   context);
 659
 660 void            hv_vmbus_channel_close(hv_vmbus_channel *channel);
 661
 662 int             hv_vmbus_channel_send_packet(
 663                                 hv_vmbus_channel*       channel,
 664                                 void*                   buffer,
 665                                 uint32_t                buffer_len,
 666                                 uint64_t                request_id,
 667                                 hv_vmbus_packet_type    type,
 668                                 uint32_t                flags);
 669
 670 int             hv_vmbus_channel_send_packet_pagebuffer(
 671                                 hv_vmbus_channel*       channel,
 672                                 hv_vmbus_page_buffer    page_buffers[],
 673                                 uint32_t                page_count,
 674                                 void*                   buffer,
 675                                 uint32_t                buffer_len,
 676                                 uint64_t                request_id);
 677
 678 int             hv_vmbus_channel_send_packet_multipagebuffer(
 679                                 hv_vmbus_channel*           channel,
 680                                 hv_vmbus_multipage_buffer*  multi_page_buffer,
 681                                 void*                       buffer,
 682                                 uint32_t                    buffer_len,
 683                                 uint64_t                    request_id);
 684
 685 int             hv_vmbus_channel_establish_gpadl(
 686                                 hv_vmbus_channel*       channel,
 687                                 /* must be phys and virt contiguous */
 688                                 void*                   contig_buffer,
 689                                 /*  page-size multiple  */
 690                                 uint32_t                size,
 691                                 uint32_t*               gpadl_handle);
 692
 693 int             hv_vmbus_channel_teardown_gpdal(
 694                                 hv_vmbus_channel*       channel,
 695                                 uint32_t                gpadl_handle);
 696
 697 struct hv_vmbus_channel* vmbus_select_outgoing_channel(struct hv_vmbus_channel *promary);
 698
 699 void            vmbus_channel_cpu_set(struct hv_vmbus_channel *chan, int cpu);
 700 void            vmbus_channel_cpu_rr(struct hv_vmbus_channel *chan);
 701 struct hv_vmbus_channel **
 702                 vmbus_get_subchan(struct hv_vmbus_channel *pri_chan, int subchan_cnt);
 703 void            vmbus_rel_subchan(struct hv_vmbus_channel **subchan, int subchan_cnt);
 704 void            vmbus_drain_subchan(struct hv_vmbus_channel *pri_chan);
 705
 706 /**
 707  * @brief Get physical address from virtual
 708  */
 709 static inline unsigned long
 710 hv_get_phys_addr(void *virt)
 711 {
 712         unsigned long ret;
 713         ret = (vtophys(virt) | ((vm_offset_t) virt & PAGE_MASK));
 714         return (ret);
 715 }
 716
 717 static __inline struct hv_vmbus_channel *
 718 vmbus_get_channel(device_t dev)
 719 {
 720         return device_get_ivars(dev);
 721 }
 722
 723 #endif  /* __HYPERV_H__ */