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 */ 37enum 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. */ 81enum 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. */ 116union hv_port_id { 117 u32 asu32; 118 struct { 119 u32 id:24; 120 u32 reserved:8; 121 } u ; 122}; 123 124/* Define port type. */ 125enum hv_port_type { 126 HVPORT_MSG = 1, 127 HVPORT_EVENT = 2, 128 HVPORT_MONITOR = 3 129}; 130 131/* Define port information structure. */ 132struct 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_bumber; 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 155struct 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. */ 172union 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. */ 181struct 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 */ 195union 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. */ 210struct 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. */ 218struct 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. */ 229struct hv_message_page { 230 struct hv_message sint_message[HV_SYNIC_SINT_COUNT]; 231}; 232 233/* Define the synthetic interrupt controller event flags format. */ 234union 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. */ 240struct hv_synic_event_flags_page { 241 union hv_synic_event_flags sintevent_flags[HV_SYNIC_SINT_COUNT]; 242}; 243 244/* Define SynIC control register. */ 245union 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. */ 254union 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 */ 266union 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 */ 276union 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 */ 286union hv_monitor_trigger_group { 287 u64 as_uint64; 288 struct { 289 u32 pending; 290 u32 armed; 291 }; 292}; 293 294struct hv_monitor_parameter { 295 union hv_connection_id connectionid; 296 u16 flagnumber; 297 u16 rsvdz; 298}; 299 300union 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/* ------------------------------------------------------ */ 328struct 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. */ 346enum 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. */ 352struct 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 */ 366enum hv_guest_os_vendor { 367 HVGUESTOS_VENDOR_MICROSOFT = 0x0001 368}; 369 370enum 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 384union 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 401union 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 411enum { 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 455static 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 */ 504static 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 513struct 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 521 bool synic_initialized; 522 523 void *synic_message_page[NR_CPUS]; 524 void *synic_event_page[NR_CPUS]; 525 /* 526 * Hypervisor's notion of virtual processor ID is different from 527 * Linux' notion of CPU ID. This information can only be retrieved 528 * in the context of the calling CPU. Setup a map for easy access 529 * to this information: 530 * 531 * vp_index[a] is the Hyper-V's processor ID corresponding to 532 * Linux cpuid 'a'. 533 */ 534 u32 vp_index[NR_CPUS]; 535 /* 536 * Starting with win8, we can take channel interrupts on any CPU; 537 * we will manage the tasklet that handles events on a per CPU 538 * basis. 539 */ 540 struct tasklet_struct *event_dpc[NR_CPUS]; 541 /* 542 * To optimize the mapping of relid to channel, maintain 543 * per-cpu list of the channels based on their CPU affinity. 544 */ 545 struct list_head percpu_list[NR_CPUS]; 546 /* 547 * buffer to post messages to the host. 548 */ 549 void *post_msg_page[NR_CPUS]; 550 /* 551 * Support PV clockevent device. 552 */ 553 struct clock_event_device *clk_evt[NR_CPUS]; 554}; 555 556extern struct hv_context hv_context; 557 558struct hv_ring_buffer_debug_info { 559 u32 current_interrupt_mask; 560 u32 current_read_index; 561 u32 current_write_index; 562 u32 bytes_avail_toread; 563 u32 bytes_avail_towrite; 564}; 565 566/* Hv Interface */ 567 568extern int hv_init(void); 569 570extern void hv_cleanup(void); 571 572extern int hv_post_message(union hv_connection_id connection_id, 573 enum hv_message_type message_type, 574 void *payload, size_t payload_size); 575 576extern u16 hv_signal_event(void *con_id); 577 578extern int hv_synic_alloc(void); 579 580extern void hv_synic_free(void); 581 582extern void hv_synic_init(void *irqarg); 583 584extern void hv_synic_cleanup(void *arg); 585 586extern void hv_synic_clockevents_cleanup(void); 587 588/* 589 * Host version information. 590 */ 591extern unsigned int host_info_eax; 592extern unsigned int host_info_ebx; 593extern unsigned int host_info_ecx; 594extern unsigned int host_info_edx; 595 596/* Interface */ 597 598 599int hv_ringbuffer_init(struct hv_ring_buffer_info *ring_info, void *buffer, 600 u32 buflen); 601 602void hv_ringbuffer_cleanup(struct hv_ring_buffer_info *ring_info); 603 604int hv_ringbuffer_write(struct hv_ring_buffer_info *ring_info, 605 struct kvec *kv_list, 606 u32 kv_count, bool *signal); 607 608int hv_ringbuffer_peek(struct hv_ring_buffer_info *ring_info, void *buffer, 609 u32 buflen); 610 611int hv_ringbuffer_read(struct hv_ring_buffer_info *ring_info, 612 void *buffer, 613 u32 buflen, 614 u32 offset, bool *signal); 615 616 617void hv_ringbuffer_get_debuginfo(struct hv_ring_buffer_info *ring_info, 618 struct hv_ring_buffer_debug_info *debug_info); 619 620void hv_begin_read(struct hv_ring_buffer_info *rbi); 621 622u32 hv_end_read(struct hv_ring_buffer_info *rbi); 623 624/* 625 * Maximum channels is determined by the size of the interrupt page 626 * which is PAGE_SIZE. 1/2 of PAGE_SIZE is for send endpoint interrupt 627 * and the other is receive endpoint interrupt 628 */ 629#define MAX_NUM_CHANNELS ((PAGE_SIZE >> 1) << 3) /* 16348 channels */ 630 631/* The value here must be in multiple of 32 */ 632/* TODO: Need to make this configurable */ 633#define MAX_NUM_CHANNELS_SUPPORTED 256 634 635 636enum vmbus_connect_state { 637 DISCONNECTED, 638 CONNECTING, 639 CONNECTED, 640 DISCONNECTING 641}; 642 643#define MAX_SIZE_CHANNEL_MESSAGE HV_MESSAGE_PAYLOAD_BYTE_COUNT 644 645struct vmbus_connection { 646 enum vmbus_connect_state conn_state; 647 648 atomic_t next_gpadl_handle; 649 650 /* 651 * Represents channel interrupts. Each bit position represents a 652 * channel. When a channel sends an interrupt via VMBUS, it finds its 653 * bit in the sendInterruptPage, set it and calls Hv to generate a port 654 * event. The other end receives the port event and parse the 655 * recvInterruptPage to see which bit is set 656 */ 657 void *int_page; 658 void *send_int_page; 659 void *recv_int_page; 660 661 /* 662 * 2 pages - 1st page for parent->child notification and 2nd 663 * is child->parent notification 664 */ 665 struct hv_monitor_page *monitor_pages[2]; 666 struct list_head chn_msg_list; 667 spinlock_t channelmsg_lock; 668 669 /* List of channels */ 670 struct list_head chn_list; 671 spinlock_t channel_lock; 672 673 struct workqueue_struct *work_queue; 674}; 675 676 677struct vmbus_msginfo { 678 /* Bookkeeping stuff */ 679 struct list_head msglist_entry; 680 681 /* The message itself */ 682 unsigned char msg[0]; 683}; 684 685 686extern struct vmbus_connection vmbus_connection; 687 688enum vmbus_message_handler_type { 689 /* The related handler can sleep. */ 690 VMHT_BLOCKING = 0, 691 692 /* The related handler must NOT sleep. */ 693 VMHT_NON_BLOCKING = 1, 694}; 695 696struct vmbus_channel_message_table_entry { 697 enum vmbus_channel_message_type message_type; 698 enum vmbus_message_handler_type handler_type; 699 void (*message_handler)(struct vmbus_channel_message_header *msg); 700}; 701 702extern struct vmbus_channel_message_table_entry 703 channel_message_table[CHANNELMSG_COUNT]; 704 705/* General vmbus interface */ 706 707struct hv_device *vmbus_device_create(const uuid_le *type, 708 const uuid_le *instance, 709 struct vmbus_channel *channel); 710 711int vmbus_device_register(struct hv_device *child_device_obj); 712void vmbus_device_unregister(struct hv_device *device_obj); 713 714/* static void */ 715/* VmbusChildDeviceDestroy( */ 716/* struct hv_device *); */ 717 718struct vmbus_channel *relid2channel(u32 relid); 719 720void vmbus_free_channels(void); 721 722/* Connection interface */ 723 724int vmbus_connect(void); 725void vmbus_disconnect(void); 726 727int vmbus_post_msg(void *buffer, size_t buflen); 728 729int vmbus_set_event(struct vmbus_channel *channel); 730 731void vmbus_on_event(unsigned long data); 732 733int hv_fcopy_init(struct hv_util_service *); 734void hv_fcopy_deinit(void); 735void hv_fcopy_onchannelcallback(void *); 736 737 738#endif /* _HYPERV_VMBUS_H */ 739