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 * The below CPUID leaves are present if VersionAndFeatures.HypervisorPresent 35 * is set by CPUID(HVCPUID_VERSION_FEATURES). 36 */ 37 enum hv_cpuid_function { 38 HVCPUID_VERSION_FEATURES = 0x00000001, 39 HVCPUID_VENDOR_MAXFUNCTION = 0x40000000, 40 HVCPUID_INTERFACE = 0x40000001, 41 42 /* 43 * The remaining functions depend on the value of 44 * HVCPUID_INTERFACE 45 */ 46 HVCPUID_VERSION = 0x40000002, 47 HVCPUID_FEATURES = 0x40000003, 48 HVCPUID_ENLIGHTENMENT_INFO = 0x40000004, 49 HVCPUID_IMPLEMENTATION_LIMITS = 0x40000005, 50 }; 51 52 #define HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE 0x400 53 54 #define HV_X64_MSR_CRASH_P0 0x40000100 55 #define HV_X64_MSR_CRASH_P1 0x40000101 56 #define HV_X64_MSR_CRASH_P2 0x40000102 57 #define HV_X64_MSR_CRASH_P3 0x40000103 58 #define HV_X64_MSR_CRASH_P4 0x40000104 59 #define HV_X64_MSR_CRASH_CTL 0x40000105 60 61 #define HV_CRASH_CTL_CRASH_NOTIFY (1ULL << 63) 62 63 /* Define version of the synthetic interrupt controller. */ 64 #define HV_SYNIC_VERSION (1) 65 66 /* Define the expected SynIC version. */ 67 #define HV_SYNIC_VERSION_1 (0x1) 68 69 /* Define synthetic interrupt controller message constants. */ 70 #define HV_MESSAGE_SIZE (256) 71 #define HV_MESSAGE_PAYLOAD_BYTE_COUNT (240) 72 #define HV_MESSAGE_PAYLOAD_QWORD_COUNT (30) 73 #define HV_ANY_VP (0xFFFFFFFF) 74 75 /* Define synthetic interrupt controller flag constants. */ 76 #define HV_EVENT_FLAGS_COUNT (256 * 8) 77 #define HV_EVENT_FLAGS_BYTE_COUNT (256) 78 #define HV_EVENT_FLAGS_DWORD_COUNT (256 / sizeof(u32)) 79 80 /* Define hypervisor message types. */ 81 enum hv_message_type { 82 HVMSG_NONE = 0x00000000, 83 84 /* Memory access messages. */ 85 HVMSG_UNMAPPED_GPA = 0x80000000, 86 HVMSG_GPA_INTERCEPT = 0x80000001, 87 88 /* Timer notification messages. */ 89 HVMSG_TIMER_EXPIRED = 0x80000010, 90 91 /* Error messages. */ 92 HVMSG_INVALID_VP_REGISTER_VALUE = 0x80000020, 93 HVMSG_UNRECOVERABLE_EXCEPTION = 0x80000021, 94 HVMSG_UNSUPPORTED_FEATURE = 0x80000022, 95 96 /* Trace buffer complete messages. */ 97 HVMSG_EVENTLOG_BUFFERCOMPLETE = 0x80000040, 98 99 /* Platform-specific processor intercept messages. */ 100 HVMSG_X64_IOPORT_INTERCEPT = 0x80010000, 101 HVMSG_X64_MSR_INTERCEPT = 0x80010001, 102 HVMSG_X64_CPUID_INTERCEPT = 0x80010002, 103 HVMSG_X64_EXCEPTION_INTERCEPT = 0x80010003, 104 HVMSG_X64_APIC_EOI = 0x80010004, 105 HVMSG_X64_LEGACY_FP_ERROR = 0x80010005 106 }; 107 108 /* Define the number of synthetic interrupt sources. */ 109 #define HV_SYNIC_SINT_COUNT (16) 110 #define HV_SYNIC_STIMER_COUNT (4) 111 112 /* Define invalid partition identifier. */ 113 #define HV_PARTITION_ID_INVALID ((u64)0x0) 114 115 /* Define port identifier type. */ 116 union hv_port_id { 117 u32 asu32; 118 struct { 119 u32 id:24; 120 u32 reserved:8; 121 } u ; 122 }; 123 124 /* Define port type. */ 125 enum hv_port_type { 126 HVPORT_MSG = 1, 127 HVPORT_EVENT = 2, 128 HVPORT_MONITOR = 3 129 }; 130 131 /* Define port information structure. */ 132 struct hv_port_info { 133 enum hv_port_type port_type; 134 u32 padding; 135 union { 136 struct { 137 u32 target_sint; 138 u32 target_vp; 139 u64 rsvdz; 140 } message_port_info; 141 struct { 142 u32 target_sint; 143 u32 target_vp; 144 u16 base_flag_number; 145 u16 flag_count; 146 u32 rsvdz; 147 } event_port_info; 148 struct { 149 u64 monitor_address; 150 u64 rsvdz; 151 } monitor_port_info; 152 }; 153 }; 154 155 struct hv_connection_info { 156 enum hv_port_type port_type; 157 u32 padding; 158 union { 159 struct { 160 u64 rsvdz; 161 } message_connection_info; 162 struct { 163 u64 rsvdz; 164 } event_connection_info; 165 struct { 166 u64 monitor_address; 167 } monitor_connection_info; 168 }; 169 }; 170 171 /* Define synthetic interrupt controller message flags. */ 172 union hv_message_flags { 173 u8 asu8; 174 struct { 175 u8 msg_pending:1; 176 u8 reserved:7; 177 }; 178 }; 179 180 /* Define synthetic interrupt controller message header. */ 181 struct hv_message_header { 182 enum hv_message_type message_type; 183 u8 payload_size; 184 union hv_message_flags message_flags; 185 u8 reserved[2]; 186 union { 187 u64 sender; 188 union hv_port_id port; 189 }; 190 }; 191 192 /* 193 * Timer configuration register. 194 */ 195 union hv_timer_config { 196 u64 as_uint64; 197 struct { 198 u64 enable:1; 199 u64 periodic:1; 200 u64 lazy:1; 201 u64 auto_enable:1; 202 u64 reserved_z0:12; 203 u64 sintx:4; 204 u64 reserved_z1:44; 205 }; 206 }; 207 208 209 /* Define timer message payload structure. */ 210 struct hv_timer_message_payload { 211 u32 timer_index; 212 u32 reserved; 213 u64 expiration_time; /* When the timer expired */ 214 u64 delivery_time; /* When the message was delivered */ 215 }; 216 217 /* Define synthetic interrupt controller message format. */ 218 struct hv_message { 219 struct hv_message_header header; 220 union { 221 u64 payload[HV_MESSAGE_PAYLOAD_QWORD_COUNT]; 222 } u ; 223 }; 224 225 /* Define the number of message buffers associated with each port. */ 226 #define HV_PORT_MESSAGE_BUFFER_COUNT (16) 227 228 /* Define the synthetic interrupt message page layout. */ 229 struct hv_message_page { 230 struct hv_message sint_message[HV_SYNIC_SINT_COUNT]; 231 }; 232 233 /* Define the synthetic interrupt controller event flags format. */ 234 union hv_synic_event_flags { 235 u8 flags8[HV_EVENT_FLAGS_BYTE_COUNT]; 236 u32 flags32[HV_EVENT_FLAGS_DWORD_COUNT]; 237 }; 238 239 /* Define the synthetic interrupt flags page layout. */ 240 struct hv_synic_event_flags_page { 241 union hv_synic_event_flags sintevent_flags[HV_SYNIC_SINT_COUNT]; 242 }; 243 244 /* Define SynIC control register. */ 245 union hv_synic_scontrol { 246 u64 as_uint64; 247 struct { 248 u64 enable:1; 249 u64 reserved:63; 250 }; 251 }; 252 253 /* Define synthetic interrupt source. */ 254 union hv_synic_sint { 255 u64 as_uint64; 256 struct { 257 u64 vector:8; 258 u64 reserved1:8; 259 u64 masked:1; 260 u64 auto_eoi:1; 261 u64 reserved2:46; 262 }; 263 }; 264 265 /* Define the format of the SIMP register */ 266 union hv_synic_simp { 267 u64 as_uint64; 268 struct { 269 u64 simp_enabled:1; 270 u64 preserved:11; 271 u64 base_simp_gpa:52; 272 }; 273 }; 274 275 /* Define the format of the SIEFP register */ 276 union hv_synic_siefp { 277 u64 as_uint64; 278 struct { 279 u64 siefp_enabled:1; 280 u64 preserved:11; 281 u64 base_siefp_gpa:52; 282 }; 283 }; 284 285 /* Definitions for the monitored notification facility */ 286 union hv_monitor_trigger_group { 287 u64 as_uint64; 288 struct { 289 u32 pending; 290 u32 armed; 291 }; 292 }; 293 294 struct hv_monitor_parameter { 295 union hv_connection_id connectionid; 296 u16 flagnumber; 297 u16 rsvdz; 298 }; 299 300 union hv_monitor_trigger_state { 301 u32 asu32; 302 303 struct { 304 u32 group_enable:4; 305 u32 rsvdz:28; 306 }; 307 }; 308 309 /* struct hv_monitor_page Layout */ 310 /* ------------------------------------------------------ */ 311 /* | 0 | TriggerState (4 bytes) | Rsvd1 (4 bytes) | */ 312 /* | 8 | TriggerGroup[0] | */ 313 /* | 10 | TriggerGroup[1] | */ 314 /* | 18 | TriggerGroup[2] | */ 315 /* | 20 | TriggerGroup[3] | */ 316 /* | 28 | Rsvd2[0] | */ 317 /* | 30 | Rsvd2[1] | */ 318 /* | 38 | Rsvd2[2] | */ 319 /* | 40 | NextCheckTime[0][0] | NextCheckTime[0][1] | */ 320 /* | ... | */ 321 /* | 240 | Latency[0][0..3] | */ 322 /* | 340 | Rsvz3[0] | */ 323 /* | 440 | Parameter[0][0] | */ 324 /* | 448 | Parameter[0][1] | */ 325 /* | ... | */ 326 /* | 840 | Rsvd4[0] | */ 327 /* ------------------------------------------------------ */ 328 struct hv_monitor_page { 329 union hv_monitor_trigger_state trigger_state; 330 u32 rsvdz1; 331 332 union hv_monitor_trigger_group trigger_group[4]; 333 u64 rsvdz2[3]; 334 335 s32 next_checktime[4][32]; 336 337 u16 latency[4][32]; 338 u64 rsvdz3[32]; 339 340 struct hv_monitor_parameter parameter[4][32]; 341 342 u8 rsvdz4[1984]; 343 }; 344 345 /* Declare the various hypercall operations. */ 346 enum hv_call_code { 347 HVCALL_POST_MESSAGE = 0x005c, 348 HVCALL_SIGNAL_EVENT = 0x005d, 349 }; 350 351 /* Definition of the hv_post_message hypercall input structure. */ 352 struct hv_input_post_message { 353 union hv_connection_id connectionid; 354 u32 reserved; 355 enum hv_message_type message_type; 356 u32 payload_size; 357 u64 payload[HV_MESSAGE_PAYLOAD_QWORD_COUNT]; 358 }; 359 360 /* 361 * Versioning definitions used for guests reporting themselves to the 362 * hypervisor, and visa versa. 363 */ 364 365 /* Version info reported by guest OS's */ 366 enum hv_guest_os_vendor { 367 HVGUESTOS_VENDOR_MICROSOFT = 0x0001 368 }; 369 370 enum hv_guest_os_microsoft_ids { 371 HVGUESTOS_MICROSOFT_UNDEFINED = 0x00, 372 HVGUESTOS_MICROSOFT_MSDOS = 0x01, 373 HVGUESTOS_MICROSOFT_WINDOWS3X = 0x02, 374 HVGUESTOS_MICROSOFT_WINDOWS9X = 0x03, 375 HVGUESTOS_MICROSOFT_WINDOWSNT = 0x04, 376 HVGUESTOS_MICROSOFT_WINDOWSCE = 0x05 377 }; 378 379 /* 380 * Declare the MSR used to identify the guest OS. 381 */ 382 #define HV_X64_MSR_GUEST_OS_ID 0x40000000 383 384 union hv_x64_msr_guest_os_id_contents { 385 u64 as_uint64; 386 struct { 387 u64 build_number:16; 388 u64 service_version:8; /* Service Pack, etc. */ 389 u64 minor_version:8; 390 u64 major_version:8; 391 u64 os_id:8; /* enum hv_guest_os_microsoft_ids (if Vendor=MS) */ 392 u64 vendor_id:16; /* enum hv_guest_os_vendor */ 393 }; 394 }; 395 396 /* 397 * Declare the MSR used to setup pages used to communicate with the hypervisor. 398 */ 399 #define HV_X64_MSR_HYPERCALL 0x40000001 400 401 union hv_x64_msr_hypercall_contents { 402 u64 as_uint64; 403 struct { 404 u64 enable:1; 405 u64 reserved:11; 406 u64 guest_physical_address:52; 407 }; 408 }; 409 410 411 enum { 412 VMBUS_MESSAGE_CONNECTION_ID = 1, 413 VMBUS_MESSAGE_PORT_ID = 1, 414 VMBUS_EVENT_CONNECTION_ID = 2, 415 VMBUS_EVENT_PORT_ID = 2, 416 VMBUS_MONITOR_CONNECTION_ID = 3, 417 VMBUS_MONITOR_PORT_ID = 3, 418 VMBUS_MESSAGE_SINT = 2, 419 }; 420 421 /* #defines */ 422 423 #define HV_PRESENT_BIT 0x80000000 424 425 /* 426 * The guest OS needs to register the guest ID with the hypervisor. 427 * The guest ID is a 64 bit entity and the structure of this ID is 428 * specified in the Hyper-V specification: 429 * 430 * http://msdn.microsoft.com/en-us/library/windows/hardware/ff542653%28v=vs.85%29.aspx 431 * 432 * While the current guideline does not specify how Linux guest ID(s) 433 * need to be generated, our plan is to publish the guidelines for 434 * Linux and other guest operating systems that currently are hosted 435 * on Hyper-V. The implementation here conforms to this yet 436 * unpublished guidelines. 437 * 438 * 439 * Bit(s) 440 * 63 - Indicates if the OS is Open Source or not; 1 is Open Source 441 * 62:56 - Os Type; Linux is 0x100 442 * 55:48 - Distro specific identification 443 * 47:16 - Linux kernel version number 444 * 15:0 - Distro specific identification 445 * 446 * 447 */ 448 449 #define HV_LINUX_VENDOR_ID 0x8100 450 451 /* 452 * Generate the guest ID based on the guideline described above. 453 */ 454 455 static inline __u64 generate_guest_id(__u8 d_info1, __u32 kernel_version, 456 __u16 d_info2) 457 { 458 __u64 guest_id = 0; 459 460 guest_id = (((__u64)HV_LINUX_VENDOR_ID) << 48); 461 guest_id |= (((__u64)(d_info1)) << 48); 462 guest_id |= (((__u64)(kernel_version)) << 16); 463 guest_id |= ((__u64)(d_info2)); 464 465 return guest_id; 466 } 467 468 469 #define HV_CPU_POWER_MANAGEMENT (1 << 0) 470 #define HV_RECOMMENDATIONS_MAX 4 471 472 #define HV_X64_MAX 5 473 #define HV_CAPS_MAX 8 474 475 476 #define HV_HYPERCALL_PARAM_ALIGN sizeof(u64) 477 478 479 /* Service definitions */ 480 481 #define HV_SERVICE_PARENT_PORT (0) 482 #define HV_SERVICE_PARENT_CONNECTION (0) 483 484 #define HV_SERVICE_CONNECT_RESPONSE_SUCCESS (0) 485 #define HV_SERVICE_CONNECT_RESPONSE_INVALID_PARAMETER (1) 486 #define HV_SERVICE_CONNECT_RESPONSE_UNKNOWN_SERVICE (2) 487 #define HV_SERVICE_CONNECT_RESPONSE_CONNECTION_REJECTED (3) 488 489 #define HV_SERVICE_CONNECT_REQUEST_MESSAGE_ID (1) 490 #define HV_SERVICE_CONNECT_RESPONSE_MESSAGE_ID (2) 491 #define HV_SERVICE_DISCONNECT_REQUEST_MESSAGE_ID (3) 492 #define HV_SERVICE_DISCONNECT_RESPONSE_MESSAGE_ID (4) 493 #define HV_SERVICE_MAX_MESSAGE_ID (4) 494 495 #define HV_SERVICE_PROTOCOL_VERSION (0x0010) 496 #define HV_CONNECT_PAYLOAD_BYTE_COUNT 64 497 498 /* #define VMBUS_REVISION_NUMBER 6 */ 499 500 /* Our local vmbus's port and connection id. Anything >0 is fine */ 501 /* #define VMBUS_PORT_ID 11 */ 502 503 /* 628180B8-308D-4c5e-B7DB-1BEB62E62EF4 */ 504 static const uuid_le VMBUS_SERVICE_ID = { 505 .b = { 506 0xb8, 0x80, 0x81, 0x62, 0x8d, 0x30, 0x5e, 0x4c, 507 0xb7, 0xdb, 0x1b, 0xeb, 0x62, 0xe6, 0x2e, 0xf4 508 }, 509 }; 510 511 512 513 struct hv_context { 514 /* We only support running on top of Hyper-V 515 * So at this point this really can only contain the Hyper-V ID 516 */ 517 u64 guestid; 518 519 void *hypercall_page; 520 void *tsc_page; 521 522 bool synic_initialized; 523 524 void *synic_message_page[NR_CPUS]; 525 void *synic_event_page[NR_CPUS]; 526 /* 527 * Hypervisor's notion of virtual processor ID is different from 528 * Linux' notion of CPU ID. This information can only be retrieved 529 * in the context of the calling CPU. Setup a map for easy access 530 * to this information: 531 * 532 * vp_index[a] is the Hyper-V's processor ID corresponding to 533 * Linux cpuid 'a'. 534 */ 535 u32 vp_index[NR_CPUS]; 536 /* 537 * Starting with win8, we can take channel interrupts on any CPU; 538 * we will manage the tasklet that handles events on a per CPU 539 * basis. 540 */ 541 struct tasklet_struct *event_dpc[NR_CPUS]; 542 /* 543 * To optimize the mapping of relid to channel, maintain 544 * per-cpu list of the channels based on their CPU affinity. 545 */ 546 struct list_head percpu_list[NR_CPUS]; 547 /* 548 * buffer to post messages to the host. 549 */ 550 void *post_msg_page[NR_CPUS]; 551 /* 552 * Support PV clockevent device. 553 */ 554 struct clock_event_device *clk_evt[NR_CPUS]; 555 /* 556 * To manage allocations in a NUMA node. 557 * Array indexed by numa node ID. 558 */ 559 struct cpumask *hv_numa_map; 560 }; 561 562 extern struct hv_context hv_context; 563 564 struct ms_hyperv_tsc_page { 565 volatile u32 tsc_sequence; 566 u32 reserved1; 567 volatile u64 tsc_scale; 568 volatile s64 tsc_offset; 569 u64 reserved2[509]; 570 }; 571 572 struct hv_ring_buffer_debug_info { 573 u32 current_interrupt_mask; 574 u32 current_read_index; 575 u32 current_write_index; 576 u32 bytes_avail_toread; 577 u32 bytes_avail_towrite; 578 }; 579 580 /* Hv Interface */ 581 582 extern int hv_init(void); 583 584 extern void hv_cleanup(void); 585 586 extern int hv_post_message(union hv_connection_id connection_id, 587 enum hv_message_type message_type, 588 void *payload, size_t payload_size); 589 590 extern u16 hv_signal_event(void *con_id); 591 592 extern int hv_synic_alloc(void); 593 594 extern void hv_synic_free(void); 595 596 extern void hv_synic_init(void *irqarg); 597 598 extern void hv_synic_cleanup(void *arg); 599 600 extern void hv_synic_clockevents_cleanup(void); 601 602 /* 603 * Host version information. 604 */ 605 extern unsigned int host_info_eax; 606 extern unsigned int host_info_ebx; 607 extern unsigned int host_info_ecx; 608 extern unsigned int host_info_edx; 609 610 /* Interface */ 611 612 613 int hv_ringbuffer_init(struct hv_ring_buffer_info *ring_info, void *buffer, 614 u32 buflen); 615 616 void hv_ringbuffer_cleanup(struct hv_ring_buffer_info *ring_info); 617 618 int hv_ringbuffer_write(struct hv_ring_buffer_info *ring_info, 619 struct kvec *kv_list, 620 u32 kv_count, bool *signal); 621 622 int hv_ringbuffer_peek(struct hv_ring_buffer_info *ring_info, void *buffer, 623 u32 buflen); 624 625 int hv_ringbuffer_read(struct hv_ring_buffer_info *ring_info, 626 void *buffer, 627 u32 buflen, 628 u32 offset, bool *signal); 629 630 631 void hv_ringbuffer_get_debuginfo(struct hv_ring_buffer_info *ring_info, 632 struct hv_ring_buffer_debug_info *debug_info); 633 634 void hv_begin_read(struct hv_ring_buffer_info *rbi); 635 636 u32 hv_end_read(struct hv_ring_buffer_info *rbi); 637 638 /* 639 * Maximum channels is determined by the size of the interrupt page 640 * which is PAGE_SIZE. 1/2 of PAGE_SIZE is for send endpoint interrupt 641 * and the other is receive endpoint interrupt 642 */ 643 #define MAX_NUM_CHANNELS ((PAGE_SIZE >> 1) << 3) /* 16348 channels */ 644 645 /* The value here must be in multiple of 32 */ 646 /* TODO: Need to make this configurable */ 647 #define MAX_NUM_CHANNELS_SUPPORTED 256 648 649 650 enum vmbus_connect_state { 651 DISCONNECTED, 652 CONNECTING, 653 CONNECTED, 654 DISCONNECTING 655 }; 656 657 #define MAX_SIZE_CHANNEL_MESSAGE HV_MESSAGE_PAYLOAD_BYTE_COUNT 658 659 struct vmbus_connection { 660 enum vmbus_connect_state conn_state; 661 662 atomic_t next_gpadl_handle; 663 664 struct completion unload_event; 665 /* 666 * Represents channel interrupts. Each bit position represents a 667 * channel. When a channel sends an interrupt via VMBUS, it finds its 668 * bit in the sendInterruptPage, set it and calls Hv to generate a port 669 * event. The other end receives the port event and parse the 670 * recvInterruptPage to see which bit is set 671 */ 672 void *int_page; 673 void *send_int_page; 674 void *recv_int_page; 675 676 /* 677 * 2 pages - 1st page for parent->child notification and 2nd 678 * is child->parent notification 679 */ 680 struct hv_monitor_page *monitor_pages[2]; 681 struct list_head chn_msg_list; 682 spinlock_t channelmsg_lock; 683 684 /* List of channels */ 685 struct list_head chn_list; 686 spinlock_t channel_lock; 687 688 struct workqueue_struct *work_queue; 689 }; 690 691 692 struct vmbus_msginfo { 693 /* Bookkeeping stuff */ 694 struct list_head msglist_entry; 695 696 /* The message itself */ 697 unsigned char msg[0]; 698 }; 699 700 701 extern struct vmbus_connection vmbus_connection; 702 703 enum vmbus_message_handler_type { 704 /* The related handler can sleep. */ 705 VMHT_BLOCKING = 0, 706 707 /* The related handler must NOT sleep. */ 708 VMHT_NON_BLOCKING = 1, 709 }; 710 711 struct vmbus_channel_message_table_entry { 712 enum vmbus_channel_message_type message_type; 713 enum vmbus_message_handler_type handler_type; 714 void (*message_handler)(struct vmbus_channel_message_header *msg); 715 }; 716 717 extern struct vmbus_channel_message_table_entry 718 channel_message_table[CHANNELMSG_COUNT]; 719 720 /* General vmbus interface */ 721 722 struct hv_device *vmbus_device_create(const uuid_le *type, 723 const uuid_le *instance, 724 struct vmbus_channel *channel); 725 726 int vmbus_device_register(struct hv_device *child_device_obj); 727 void vmbus_device_unregister(struct hv_device *device_obj); 728 729 /* static void */ 730 /* VmbusChildDeviceDestroy( */ 731 /* struct hv_device *); */ 732 733 struct vmbus_channel *relid2channel(u32 relid); 734 735 void vmbus_free_channels(void); 736 737 /* Connection interface */ 738 739 int vmbus_connect(void); 740 void vmbus_disconnect(void); 741 742 int vmbus_post_msg(void *buffer, size_t buflen); 743 744 int vmbus_set_event(struct vmbus_channel *channel); 745 746 void vmbus_on_event(unsigned long data); 747 748 int hv_kvp_init(struct hv_util_service *); 749 void hv_kvp_deinit(void); 750 void hv_kvp_onchannelcallback(void *); 751 752 int hv_vss_init(struct hv_util_service *); 753 void hv_vss_deinit(void); 754 void hv_vss_onchannelcallback(void *); 755 756 int hv_fcopy_init(struct hv_util_service *); 757 void hv_fcopy_deinit(void); 758 void hv_fcopy_onchannelcallback(void *); 759 void vmbus_initiate_unload(void); 760 761 static inline void hv_poll_channel(struct vmbus_channel *channel, 762 void (*cb)(void *)) 763 { 764 if (!channel) 765 return; 766 767 if (channel->target_cpu != smp_processor_id()) 768 smp_call_function_single(channel->target_cpu, 769 cb, channel, true); 770 else 771 cb(channel); 772 } 773 774 enum hvutil_device_state { 775 HVUTIL_DEVICE_INIT = 0, /* driver is loaded, waiting for userspace */ 776 HVUTIL_READY, /* userspace is registered */ 777 HVUTIL_HOSTMSG_RECEIVED, /* message from the host was received */ 778 HVUTIL_USERSPACE_REQ, /* request to userspace was sent */ 779 HVUTIL_USERSPACE_RECV, /* reply from userspace was received */ 780 HVUTIL_DEVICE_DYING, /* driver unload is in progress */ 781 }; 782 783 #endif /* _HYPERV_VMBUS_H */ 784