drivers/hv/hyperv_vmbus.h

   1 /*
   2  *
   3  * Copyright (c) 2011, Microsoft Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  16  * Place - Suite 330, Boston, MA 02111-1307 USA.
  17  *
  18  * Authors:
  19  *   Haiyang Zhang <haiyangz@microsoft.com>
  20  *   Hank Janssen  <hjanssen@microsoft.com>
  21  *   K. Y. Srinivasan <kys@microsoft.com>
  22  *
  23  */
  24
  25 #ifndef _HYPERV_VMBUS_H
  26 #define _HYPERV_VMBUS_H
  27
  28 #include <linux/list.h>
  29 #include <asm/sync_bitops.h>
  30 #include <linux/atomic.h>
  31 #include <linux/hyperv.h>
  32
  33 /*
  34  * Timeout for services such as KVP and fcopy.
  35  */
  36 #define HV_UTIL_TIMEOUT 30
  37
  38 /*
  39  * Timeout for guest-host handshake for services.
  40  */
  41 #define HV_UTIL_NEGO_TIMEOUT 55
  42
  43
  44 /* Define version of the synthetic interrupt controller. */
  45 #define HV_SYNIC_VERSION                (1)
  46
  47 #define HV_ANY_VP                       (0xFFFFFFFF)
  48
  49 /* Define synthetic interrupt controller flag constants. */
  50 #define HV_EVENT_FLAGS_COUNT            (256 * 8)
  51 #define HV_EVENT_FLAGS_BYTE_COUNT       (256)
  52 #define HV_EVENT_FLAGS_DWORD_COUNT      (256 / sizeof(u32))
  53
  54 /* Define invalid partition identifier. */
  55 #define HV_PARTITION_ID_INVALID         ((u64)0x0)
  56
  57 /* Define port type. */
  58 enum hv_port_type {
  59         HVPORT_MSG      = 1,
  60         HVPORT_EVENT            = 2,
  61         HVPORT_MONITOR  = 3
  62 };
  63
  64 /* Define port information structure. */
  65 struct hv_port_info {
  66         enum hv_port_type port_type;
  67         u32 padding;
  68         union {
  69                 struct {
  70                         u32 target_sint;
  71                         u32 target_vp;
  72                         u64 rsvdz;
  73                 } message_port_info;
  74                 struct {
  75                         u32 target_sint;
  76                         u32 target_vp;
  77                         u16 base_flag_number;
  78                         u16 flag_count;
  79                         u32 rsvdz;
  80                 } event_port_info;
  81                 struct {
  82                         u64 monitor_address;
  83                         u64 rsvdz;
  84                 } monitor_port_info;
  85         };
  86 };
  87
  88 struct hv_connection_info {
  89         enum hv_port_type port_type;
  90         u32 padding;
  91         union {
  92                 struct {
  93                         u64 rsvdz;
  94                 } message_connection_info;
  95                 struct {
  96                         u64 rsvdz;
  97                 } event_connection_info;
  98                 struct {
  99                         u64 monitor_address;
 100                 } monitor_connection_info;
 101         };
 102 };
 103
 104 /*
 105  * Timer configuration register.
 106  */
 107 union hv_timer_config {
 108         u64 as_uint64;
 109         struct {
 110                 u64 enable:1;
 111                 u64 periodic:1;
 112                 u64 lazy:1;
 113                 u64 auto_enable:1;
 114                 u64 reserved_z0:12;
 115                 u64 sintx:4;
 116                 u64 reserved_z1:44;
 117         };
 118 };
 119
 120 /* Define the number of message buffers associated with each port. */
 121 #define HV_PORT_MESSAGE_BUFFER_COUNT    (16)
 122
 123 /* Define the synthetic interrupt controller event flags format. */
 124 union hv_synic_event_flags {
 125         u8 flags8[HV_EVENT_FLAGS_BYTE_COUNT];
 126         u32 flags32[HV_EVENT_FLAGS_DWORD_COUNT];
 127 };
 128
 129 /* Define the synthetic interrupt flags page layout. */
 130 struct hv_synic_event_flags_page {
 131         union hv_synic_event_flags sintevent_flags[HV_SYNIC_SINT_COUNT];
 132 };
 133
 134 /* Define SynIC control register. */
 135 union hv_synic_scontrol {
 136         u64 as_uint64;
 137         struct {
 138                 u64 enable:1;
 139                 u64 reserved:63;
 140         };
 141 };
 142
 143 /* Define synthetic interrupt source. */
 144 union hv_synic_sint {
 145         u64 as_uint64;
 146         struct {
 147                 u64 vector:8;
 148                 u64 reserved1:8;
 149                 u64 masked:1;
 150                 u64 auto_eoi:1;
 151                 u64 reserved2:46;
 152         };
 153 };
 154
 155 /* Define the format of the SIMP register */
 156 union hv_synic_simp {
 157         u64 as_uint64;
 158         struct {
 159                 u64 simp_enabled:1;
 160                 u64 preserved:11;
 161                 u64 base_simp_gpa:52;
 162         };
 163 };
 164
 165 /* Define the format of the SIEFP register */
 166 union hv_synic_siefp {
 167         u64 as_uint64;
 168         struct {
 169                 u64 siefp_enabled:1;
 170                 u64 preserved:11;
 171                 u64 base_siefp_gpa:52;
 172         };
 173 };
 174
 175 /* Definitions for the monitored notification facility */
 176 union hv_monitor_trigger_group {
 177         u64 as_uint64;
 178         struct {
 179                 u32 pending;
 180                 u32 armed;
 181         };
 182 };
 183
 184 struct hv_monitor_parameter {
 185         union hv_connection_id connectionid;
 186         u16 flagnumber;
 187         u16 rsvdz;
 188 };
 189
 190 union hv_monitor_trigger_state {
 191         u32 asu32;
 192
 193         struct {
 194                 u32 group_enable:4;
 195                 u32 rsvdz:28;
 196         };
 197 };
 198
 199 /* struct hv_monitor_page Layout */
 200 /* ------------------------------------------------------ */
 201 /* | 0   | TriggerState (4 bytes) | Rsvd1 (4 bytes)     | */
 202 /* | 8   | TriggerGroup[0]                              | */
 203 /* | 10  | TriggerGroup[1]                              | */
 204 /* | 18  | TriggerGroup[2]                              | */
 205 /* | 20  | TriggerGroup[3]                              | */
 206 /* | 28  | Rsvd2[0]                                     | */
 207 /* | 30  | Rsvd2[1]                                     | */
 208 /* | 38  | Rsvd2[2]                                     | */
 209 /* | 40  | NextCheckTime[0][0]    | NextCheckTime[0][1] | */
 210 /* | ...                                                | */
 211 /* | 240 | Latency[0][0..3]                             | */
 212 /* | 340 | Rsvz3[0]                                     | */
 213 /* | 440 | Parameter[0][0]                              | */
 214 /* | 448 | Parameter[0][1]                              | */
 215 /* | ...                                                | */
 216 /* | 840 | Rsvd4[0]                                     | */
 217 /* ------------------------------------------------------ */
 218 struct hv_monitor_page {
 219         union hv_monitor_trigger_state trigger_state;
 220         u32 rsvdz1;
 221
 222         union hv_monitor_trigger_group trigger_group[4];
 223         u64 rsvdz2[3];
 224
 225         s32 next_checktime[4][32];
 226
 227         u16 latency[4][32];
 228         u64 rsvdz3[32];
 229
 230         struct hv_monitor_parameter parameter[4][32];
 231
 232         u8 rsvdz4[1984];
 233 };
 234
 235 /* Definition of the hv_post_message hypercall input structure. */
 236 struct hv_input_post_message {
 237         union hv_connection_id connectionid;
 238         u32 reserved;
 239         u32 message_type;
 240         u32 payload_size;
 241         u64 payload[HV_MESSAGE_PAYLOAD_QWORD_COUNT];
 242 };
 243
 244 /*
 245  * Versioning definitions used for guests reporting themselves to the
 246  * hypervisor, and visa versa.
 247  */
 248
 249 /* Version info reported by guest OS's */
 250 enum hv_guest_os_vendor {
 251         HVGUESTOS_VENDOR_MICROSOFT      = 0x0001
 252 };
 253
 254 enum hv_guest_os_microsoft_ids {
 255         HVGUESTOS_MICROSOFT_UNDEFINED   = 0x00,
 256         HVGUESTOS_MICROSOFT_MSDOS               = 0x01,
 257         HVGUESTOS_MICROSOFT_WINDOWS3X   = 0x02,
 258         HVGUESTOS_MICROSOFT_WINDOWS9X   = 0x03,
 259         HVGUESTOS_MICROSOFT_WINDOWSNT   = 0x04,
 260         HVGUESTOS_MICROSOFT_WINDOWSCE   = 0x05
 261 };
 262
 263 /*
 264  * Declare the MSR used to identify the guest OS.
 265  */
 266 #define HV_X64_MSR_GUEST_OS_ID  0x40000000
 267
 268 union hv_x64_msr_guest_os_id_contents {
 269         u64 as_uint64;
 270         struct {
 271                 u64 build_number:16;
 272                 u64 service_version:8; /* Service Pack, etc. */
 273                 u64 minor_version:8;
 274                 u64 major_version:8;
 275                 u64 os_id:8; /* enum hv_guest_os_microsoft_ids (if Vendor=MS) */
 276                 u64 vendor_id:16; /* enum hv_guest_os_vendor */
 277         };
 278 };
 279
 280 enum {
 281         VMBUS_MESSAGE_CONNECTION_ID     = 1,
 282         VMBUS_MESSAGE_PORT_ID           = 1,
 283         VMBUS_EVENT_CONNECTION_ID       = 2,
 284         VMBUS_EVENT_PORT_ID             = 2,
 285         VMBUS_MONITOR_CONNECTION_ID     = 3,
 286         VMBUS_MONITOR_PORT_ID           = 3,
 287         VMBUS_MESSAGE_SINT              = 2,
 288 };
 289
 290 /* #defines */
 291
 292 #define HV_PRESENT_BIT                  0x80000000
 293
 294
 295 #define HV_CPU_POWER_MANAGEMENT         (1 << 0)
 296 #define HV_RECOMMENDATIONS_MAX          4
 297
 298 #define HV_X64_MAX                      5
 299 #define HV_CAPS_MAX                     8
 300
 301
 302 #define HV_HYPERCALL_PARAM_ALIGN        sizeof(u64)
 303
 304
 305 /* Service definitions */
 306
 307 #define HV_SERVICE_PARENT_PORT                          (0)
 308 #define HV_SERVICE_PARENT_CONNECTION                    (0)
 309
 310 #define HV_SERVICE_CONNECT_RESPONSE_SUCCESS             (0)
 311 #define HV_SERVICE_CONNECT_RESPONSE_INVALID_PARAMETER   (1)
 312 #define HV_SERVICE_CONNECT_RESPONSE_UNKNOWN_SERVICE     (2)
 313 #define HV_SERVICE_CONNECT_RESPONSE_CONNECTION_REJECTED (3)
 314
 315 #define HV_SERVICE_CONNECT_REQUEST_MESSAGE_ID           (1)
 316 #define HV_SERVICE_CONNECT_RESPONSE_MESSAGE_ID          (2)
 317 #define HV_SERVICE_DISCONNECT_REQUEST_MESSAGE_ID        (3)
 318 #define HV_SERVICE_DISCONNECT_RESPONSE_MESSAGE_ID       (4)
 319 #define HV_SERVICE_MAX_MESSAGE_ID                               (4)
 320
 321 #define HV_SERVICE_PROTOCOL_VERSION (0x0010)
 322 #define HV_CONNECT_PAYLOAD_BYTE_COUNT 64
 323
 324 /* #define VMBUS_REVISION_NUMBER        6 */
 325
 326 /* Our local vmbus's port and connection id. Anything >0 is fine */
 327 /* #define VMBUS_PORT_ID                11 */
 328
 329 /* 628180B8-308D-4c5e-B7DB-1BEB62E62EF4 */
 330 static const uuid_le VMBUS_SERVICE_ID = {
 331         .b = {
 332                 0xb8, 0x80, 0x81, 0x62, 0x8d, 0x30, 0x5e, 0x4c,
 333                 0xb7, 0xdb, 0x1b, 0xeb, 0x62, 0xe6, 0x2e, 0xf4
 334         },
 335 };
 336
 337
 338
 339 struct hv_context {
 340         /* We only support running on top of Hyper-V
 341         * So at this point this really can only contain the Hyper-V ID
 342         */
 343         u64 guestid;
 344
 345         void *tsc_page;
 346
 347         bool synic_initialized;
 348
 349         void *synic_message_page[NR_CPUS];
 350         void *synic_event_page[NR_CPUS];
 351         /*
 352          * Hypervisor's notion of virtual processor ID is different from
 353          * Linux' notion of CPU ID. This information can only be retrieved
 354          * in the context of the calling CPU. Setup a map for easy access
 355          * to this information:
 356          *
 357          * vp_index[a] is the Hyper-V's processor ID corresponding to
 358          * Linux cpuid 'a'.
 359          */
 360         u32 vp_index[NR_CPUS];
 361         /*
 362          * Starting with win8, we can take channel interrupts on any CPU;
 363          * we will manage the tasklet that handles events messages on a per CPU
 364          * basis.
 365          */
 366         struct tasklet_struct *event_dpc[NR_CPUS];
 367         struct tasklet_struct *msg_dpc[NR_CPUS];
 368         /*
 369          * To optimize the mapping of relid to channel, maintain
 370          * per-cpu list of the channels based on their CPU affinity.
 371          */
 372         struct list_head percpu_list[NR_CPUS];
 373         /*
 374          * buffer to post messages to the host.
 375          */
 376         void *post_msg_page[NR_CPUS];
 377         /*
 378          * Support PV clockevent device.
 379          */
 380         struct clock_event_device *clk_evt[NR_CPUS];
 381         /*
 382          * To manage allocations in a NUMA node.
 383          * Array indexed by numa node ID.
 384          */
 385         struct cpumask *hv_numa_map;
 386 };
 387
 388 extern struct hv_context hv_context;
 389
 390 struct hv_ring_buffer_debug_info {
 391         u32 current_interrupt_mask;
 392         u32 current_read_index;
 393         u32 current_write_index;
 394         u32 bytes_avail_toread;
 395         u32 bytes_avail_towrite;
 396 };
 397
 398 /* Hv Interface */
 399
 400 extern int hv_init(void);
 401
 402 extern void hv_cleanup(bool crash);
 403
 404 extern int hv_post_message(union hv_connection_id connection_id,
 405                          enum hv_message_type message_type,
 406                          void *payload, size_t payload_size);
 407
 408 extern int hv_synic_alloc(void);
 409
 410 extern void hv_synic_free(void);
 411
 412 extern int hv_synic_init(unsigned int cpu);
 413
 414 extern int hv_synic_cleanup(unsigned int cpu);
 415
 416 extern void hv_synic_clockevents_cleanup(void);
 417
 418 /* Interface */
 419
 420
 421 int hv_ringbuffer_init(struct hv_ring_buffer_info *ring_info,
 422                        struct page *pages, u32 pagecnt);
 423
 424 void hv_ringbuffer_cleanup(struct hv_ring_buffer_info *ring_info);
 425
 426 int hv_ringbuffer_write(struct vmbus_channel *channel,
 427                     struct kvec *kv_list,
 428                     u32 kv_count, bool lock,
 429                     bool kick_q);
 430
 431 int hv_ringbuffer_read(struct vmbus_channel *channel,
 432                        void *buffer, u32 buflen, u32 *buffer_actual_len,
 433                        u64 *requestid, bool raw);
 434
 435 void hv_ringbuffer_get_debuginfo(struct hv_ring_buffer_info *ring_info,
 436                             struct hv_ring_buffer_debug_info *debug_info);
 437
 438 void hv_begin_read(struct hv_ring_buffer_info *rbi);
 439
 440 u32 hv_end_read(struct hv_ring_buffer_info *rbi);
 441
 442 /*
 443  * Maximum channels is determined by the size of the interrupt page
 444  * which is PAGE_SIZE. 1/2 of PAGE_SIZE is for send endpoint interrupt
 445  * and the other is receive endpoint interrupt
 446  */
 447 #define MAX_NUM_CHANNELS        ((PAGE_SIZE >> 1) << 3) /* 16348 channels */
 448
 449 /* The value here must be in multiple of 32 */
 450 /* TODO: Need to make this configurable */
 451 #define MAX_NUM_CHANNELS_SUPPORTED      256
 452
 453
 454 enum vmbus_connect_state {
 455         DISCONNECTED,
 456         CONNECTING,
 457         CONNECTED,
 458         DISCONNECTING
 459 };
 460
 461 #define MAX_SIZE_CHANNEL_MESSAGE        HV_MESSAGE_PAYLOAD_BYTE_COUNT
 462
 463 struct vmbus_connection {
 464         enum vmbus_connect_state conn_state;
 465
 466         atomic_t next_gpadl_handle;
 467
 468         struct completion  unload_event;
 469         /*
 470          * Represents channel interrupts. Each bit position represents a
 471          * channel.  When a channel sends an interrupt via VMBUS, it finds its
 472          * bit in the sendInterruptPage, set it and calls Hv to generate a port
 473          * event. The other end receives the port event and parse the
 474          * recvInterruptPage to see which bit is set
 475          */
 476         void *int_page;
 477         void *send_int_page;
 478         void *recv_int_page;
 479
 480         /*
 481          * 2 pages - 1st page for parent->child notification and 2nd
 482          * is child->parent notification
 483          */
 484         struct hv_monitor_page *monitor_pages[2];
 485         struct list_head chn_msg_list;
 486         spinlock_t channelmsg_lock;
 487
 488         /* List of channels */
 489         struct list_head chn_list;
 490         struct mutex channel_mutex;
 491
 492         struct workqueue_struct *work_queue;
 493 };
 494
 495
 496 struct vmbus_msginfo {
 497         /* Bookkeeping stuff */
 498         struct list_head msglist_entry;
 499
 500         /* The message itself */
 501         unsigned char msg[0];
 502 };
 503
 504
 505 extern struct vmbus_connection vmbus_connection;
 506
 507 enum vmbus_message_handler_type {
 508         /* The related handler can sleep. */
 509         VMHT_BLOCKING = 0,
 510
 511         /* The related handler must NOT sleep. */
 512         VMHT_NON_BLOCKING = 1,
 513 };
 514
 515 struct vmbus_channel_message_table_entry {
 516         enum vmbus_channel_message_type message_type;
 517         enum vmbus_message_handler_type handler_type;
 518         void (*message_handler)(struct vmbus_channel_message_header *msg);
 519 };
 520
 521 extern struct vmbus_channel_message_table_entry
 522         channel_message_table[CHANNELMSG_COUNT];
 523
 524
 525 /* General vmbus interface */
 526
 527 struct hv_device *vmbus_device_create(const uuid_le *type,
 528                                       const uuid_le *instance,
 529                                       struct vmbus_channel *channel);
 530
 531 int vmbus_device_register(struct hv_device *child_device_obj);
 532 void vmbus_device_unregister(struct hv_device *device_obj);
 533
 534 /* static void */
 535 /* VmbusChildDeviceDestroy( */
 536 /* struct hv_device *); */
 537
 538 struct vmbus_channel *relid2channel(u32 relid);
 539
 540 void vmbus_free_channels(void);
 541
 542 /* Connection interface */
 543
 544 int vmbus_connect(void);
 545 void vmbus_disconnect(void);
 546
 547 int vmbus_post_msg(void *buffer, size_t buflen, bool can_sleep);
 548
 549 void vmbus_on_event(unsigned long data);
 550 void vmbus_on_msg_dpc(unsigned long data);
 551
 552 int hv_kvp_init(struct hv_util_service *);
 553 void hv_kvp_deinit(void);
 554 void hv_kvp_onchannelcallback(void *);
 555
 556 int hv_vss_init(struct hv_util_service *);
 557 void hv_vss_deinit(void);
 558 void hv_vss_onchannelcallback(void *);
 559
 560 int hv_fcopy_init(struct hv_util_service *);
 561 void hv_fcopy_deinit(void);
 562 void hv_fcopy_onchannelcallback(void *);
 563 void vmbus_initiate_unload(bool crash);
 564
 565 static inline void hv_poll_channel(struct vmbus_channel *channel,
 566                                    void (*cb)(void *))
 567 {
 568         if (!channel)
 569                 return;
 570
 571         smp_call_function_single(channel->target_cpu, cb, channel, true);
 572 }
 573
 574 enum hvutil_device_state {
 575         HVUTIL_DEVICE_INIT = 0,  /* driver is loaded, waiting for userspace */
 576         HVUTIL_READY,            /* userspace is registered */
 577         HVUTIL_HOSTMSG_RECEIVED, /* message from the host was received */
 578         HVUTIL_USERSPACE_REQ,    /* request to userspace was sent */
 579         HVUTIL_USERSPACE_RECV,   /* reply from userspace was received */
 580         HVUTIL_DEVICE_DYING,     /* driver unload is in progress */
 581 };
 582
 583 #endif /* _HYPERV_VMBUS_H */