1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#ifndef _HYPERV_H
26#define _HYPERV_H
27
28#include <linux/types.h>
29
30
31
32
33
34
35#define VSS_OP_REGISTER 128
36
37enum hv_vss_op {
38 VSS_OP_CREATE = 0,
39 VSS_OP_DELETE,
40 VSS_OP_HOT_BACKUP,
41 VSS_OP_GET_DM_INFO,
42 VSS_OP_BU_COMPLETE,
43
44
45
46 VSS_OP_FREEZE,
47 VSS_OP_THAW,
48 VSS_OP_AUTO_RECOVER,
49 VSS_OP_COUNT
50};
51
52
53
54
55
56struct hv_vss_hdr {
57 __u8 operation;
58 __u8 reserved[7];
59} __attribute__((packed));
60
61
62
63
64
65
66#define VSS_HBU_NO_AUTO_RECOVERY 0x00000005
67
68struct hv_vss_check_feature {
69 __u32 flags;
70} __attribute__((packed));
71
72struct hv_vss_check_dm_info {
73 __u32 flags;
74} __attribute__((packed));
75
76struct hv_vss_msg {
77 union {
78 struct hv_vss_hdr vss_hdr;
79 int error;
80 };
81 union {
82 struct hv_vss_check_feature vss_cf;
83 struct hv_vss_check_dm_info dm_info;
84 };
85} __attribute__((packed));
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115#define HV_KVP_EXCHANGE_MAX_VALUE_SIZE (2048)
116
117
118
119
120
121
122
123#define HV_KVP_EXCHANGE_MAX_KEY_SIZE (512)
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178#define REG_SZ 1
179#define REG_U32 4
180#define REG_U64 8
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211#define KVP_OP_REGISTER 4
212
213
214
215
216
217
218
219
220#define KVP_OP_REGISTER1 100
221
222enum hv_kvp_exchg_op {
223 KVP_OP_GET = 0,
224 KVP_OP_SET,
225 KVP_OP_DELETE,
226 KVP_OP_ENUMERATE,
227 KVP_OP_GET_IP_INFO,
228 KVP_OP_SET_IP_INFO,
229 KVP_OP_COUNT
230};
231
232enum hv_kvp_exchg_pool {
233 KVP_POOL_EXTERNAL = 0,
234 KVP_POOL_GUEST,
235 KVP_POOL_AUTO,
236 KVP_POOL_AUTO_EXTERNAL,
237 KVP_POOL_AUTO_INTERNAL,
238 KVP_POOL_COUNT
239};
240
241
242
243
244
245#define HV_S_OK 0x00000000
246#define HV_E_FAIL 0x80004005
247#define HV_S_CONT 0x80070103
248#define HV_ERROR_NOT_SUPPORTED 0x80070032
249#define HV_ERROR_MACHINE_LOCKED 0x800704F7
250#define HV_ERROR_DEVICE_NOT_CONNECTED 0x8007048F
251#define HV_INVALIDARG 0x80070057
252#define HV_GUID_NOTFOUND 0x80041002
253
254#define ADDR_FAMILY_NONE 0x00
255#define ADDR_FAMILY_IPV4 0x01
256#define ADDR_FAMILY_IPV6 0x02
257
258#define MAX_ADAPTER_ID_SIZE 128
259#define MAX_IP_ADDR_SIZE 1024
260#define MAX_GATEWAY_SIZE 512
261
262
263struct hv_kvp_ipaddr_value {
264 __u16 adapter_id[MAX_ADAPTER_ID_SIZE];
265 __u8 addr_family;
266 __u8 dhcp_enabled;
267 __u16 ip_addr[MAX_IP_ADDR_SIZE];
268 __u16 sub_net[MAX_IP_ADDR_SIZE];
269 __u16 gate_way[MAX_GATEWAY_SIZE];
270 __u16 dns_addr[MAX_IP_ADDR_SIZE];
271} __attribute__((packed));
272
273
274struct hv_kvp_hdr {
275 __u8 operation;
276 __u8 pool;
277 __u16 pad;
278} __attribute__((packed));
279
280struct hv_kvp_exchg_msg_value {
281 __u32 value_type;
282 __u32 key_size;
283 __u32 value_size;
284 __u8 key[HV_KVP_EXCHANGE_MAX_KEY_SIZE];
285 union {
286 __u8 value[HV_KVP_EXCHANGE_MAX_VALUE_SIZE];
287 __u32 value_u32;
288 __u64 value_u64;
289 };
290} __attribute__((packed));
291
292struct hv_kvp_msg_enumerate {
293 __u32 index;
294 struct hv_kvp_exchg_msg_value data;
295} __attribute__((packed));
296
297struct hv_kvp_msg_get {
298 struct hv_kvp_exchg_msg_value data;
299};
300
301struct hv_kvp_msg_set {
302 struct hv_kvp_exchg_msg_value data;
303};
304
305struct hv_kvp_msg_delete {
306 __u32 key_size;
307 __u8 key[HV_KVP_EXCHANGE_MAX_KEY_SIZE];
308};
309
310struct hv_kvp_register {
311 __u8 version[HV_KVP_EXCHANGE_MAX_KEY_SIZE];
312};
313
314struct hv_kvp_msg {
315 union {
316 struct hv_kvp_hdr kvp_hdr;
317 int error;
318 };
319 union {
320 struct hv_kvp_msg_get kvp_get;
321 struct hv_kvp_msg_set kvp_set;
322 struct hv_kvp_msg_delete kvp_delete;
323 struct hv_kvp_msg_enumerate kvp_enum_data;
324 struct hv_kvp_ipaddr_value kvp_ip_val;
325 struct hv_kvp_register kvp_register;
326 } body;
327} __attribute__((packed));
328
329struct hv_kvp_ip_msg {
330 __u8 operation;
331 __u8 pool;
332 struct hv_kvp_ipaddr_value kvp_ip_val;
333} __attribute__((packed));
334
335#ifdef __KERNEL__
336#include <linux/scatterlist.h>
337#include <linux/list.h>
338#include <linux/uuid.h>
339#include <linux/timer.h>
340#include <linux/workqueue.h>
341#include <linux/completion.h>
342#include <linux/device.h>
343#include <linux/mod_devicetable.h>
344
345
346#define MAX_PAGE_BUFFER_COUNT 19
347#define MAX_MULTIPAGE_BUFFER_COUNT 32
348
349#pragma pack(push, 1)
350
351
352struct hv_page_buffer {
353 u32 len;
354 u32 offset;
355 u64 pfn;
356};
357
358
359struct hv_multipage_buffer {
360
361 u32 len;
362 u32 offset;
363 u64 pfn_array[MAX_MULTIPAGE_BUFFER_COUNT];
364};
365
366
367#define MAX_PAGE_BUFFER_PACKET (0x18 + \
368 (sizeof(struct hv_page_buffer) * \
369 MAX_PAGE_BUFFER_COUNT))
370#define MAX_MULTIPAGE_BUFFER_PACKET (0x18 + \
371 sizeof(struct hv_multipage_buffer))
372
373
374#pragma pack(pop)
375
376struct hv_ring_buffer {
377
378 u32 write_index;
379
380
381 u32 read_index;
382
383 u32 interrupt_mask;
384
385
386
387
388
389
390
391
392
393
394 u32 pending_send_sz;
395
396 u32 reserved1[12];
397
398 union {
399 struct {
400 u32 feat_pending_send_sz:1;
401 };
402 u32 value;
403 } feature_bits;
404
405
406 u8 reserved2[4028];
407
408
409
410
411
412 u8 buffer[0];
413} __packed;
414
415struct hv_ring_buffer_info {
416 struct hv_ring_buffer *ring_buffer;
417 u32 ring_size;
418 spinlock_t ring_lock;
419
420 u32 ring_datasize;
421 u32 ring_data_startoffset;
422};
423
424struct hv_ring_buffer_debug_info {
425 u32 current_interrupt_mask;
426 u32 current_read_index;
427 u32 current_write_index;
428 u32 bytes_avail_toread;
429 u32 bytes_avail_towrite;
430};
431
432
433
434
435
436
437
438
439
440static inline void
441hv_get_ringbuffer_availbytes(struct hv_ring_buffer_info *rbi,
442 u32 *read, u32 *write)
443{
444 u32 read_loc, write_loc, dsize;
445
446 smp_read_barrier_depends();
447
448
449 read_loc = rbi->ring_buffer->read_index;
450 write_loc = rbi->ring_buffer->write_index;
451 dsize = rbi->ring_datasize;
452
453 *write = write_loc >= read_loc ? dsize - (write_loc - read_loc) :
454 read_loc - write_loc;
455 *read = dsize - *write;
456}
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477#define HV_DRV_VERSION "3.1"
478
479
480
481
482
483
484
485
486
487
488#define VERSION_WS2008 ((0 << 16) | (13))
489#define VERSION_WIN7 ((1 << 16) | (1))
490#define VERSION_WIN8 ((2 << 16) | (4))
491
492#define VERSION_INVAL -1
493
494#define VERSION_CURRENT VERSION_WIN8
495
496
497#define MAX_PIPE_DATA_PAYLOAD (sizeof(u8) * 16384)
498
499
500#define VMBUS_PIPE_TYPE_BYTE 0x00000000
501#define VMBUS_PIPE_TYPE_MESSAGE 0x00000004
502
503
504#define MAX_USER_DEFINED_BYTES 120
505
506
507#define MAX_PIPE_USER_DEFINED_BYTES 116
508
509
510
511
512
513struct vmbus_channel_offer {
514 uuid_le if_type;
515 uuid_le if_instance;
516
517
518
519
520 u64 reserved1;
521 u64 reserved2;
522
523 u16 chn_flags;
524 u16 mmio_megabytes;
525
526 union {
527
528 struct {
529 unsigned char user_def[MAX_USER_DEFINED_BYTES];
530 } std;
531
532
533
534
535
536
537
538
539 struct {
540 u32 pipe_mode;
541 unsigned char user_def[MAX_PIPE_USER_DEFINED_BYTES];
542 } pipe;
543 } u;
544
545
546
547 u16 sub_channel_index;
548 u16 reserved3;
549} __packed;
550
551
552#define VMBUS_CHANNEL_ENUMERATE_DEVICE_INTERFACE 1
553#define VMBUS_CHANNEL_SERVER_SUPPORTS_TRANSFER_PAGES 2
554#define VMBUS_CHANNEL_SERVER_SUPPORTS_GPADLS 4
555#define VMBUS_CHANNEL_NAMED_PIPE_MODE 0x10
556#define VMBUS_CHANNEL_LOOPBACK_OFFER 0x100
557#define VMBUS_CHANNEL_PARENT_OFFER 0x200
558#define VMBUS_CHANNEL_REQUEST_MONITORED_NOTIFICATION 0x400
559
560struct vmpacket_descriptor {
561 u16 type;
562 u16 offset8;
563 u16 len8;
564 u16 flags;
565 u64 trans_id;
566} __packed;
567
568struct vmpacket_header {
569 u32 prev_pkt_start_offset;
570 struct vmpacket_descriptor descriptor;
571} __packed;
572
573struct vmtransfer_page_range {
574 u32 byte_count;
575 u32 byte_offset;
576} __packed;
577
578struct vmtransfer_page_packet_header {
579 struct vmpacket_descriptor d;
580 u16 xfer_pageset_id;
581 u8 sender_owns_set;
582 u8 reserved;
583 u32 range_cnt;
584 struct vmtransfer_page_range ranges[1];
585} __packed;
586
587struct vmgpadl_packet_header {
588 struct vmpacket_descriptor d;
589 u32 gpadl;
590 u32 reserved;
591} __packed;
592
593struct vmadd_remove_transfer_page_set {
594 struct vmpacket_descriptor d;
595 u32 gpadl;
596 u16 xfer_pageset_id;
597 u16 reserved;
598} __packed;
599
600
601
602
603
604struct gpa_range {
605 u32 byte_count;
606 u32 byte_offset;
607 u64 pfn_array[0];
608};
609
610
611
612
613
614
615
616
617struct vmestablish_gpadl {
618 struct vmpacket_descriptor d;
619 u32 gpadl;
620 u32 range_cnt;
621 struct gpa_range range[1];
622} __packed;
623
624
625
626
627
628struct vmteardown_gpadl {
629 struct vmpacket_descriptor d;
630 u32 gpadl;
631 u32 reserved;
632} __packed;
633
634
635
636
637
638struct vmdata_gpa_direct {
639 struct vmpacket_descriptor d;
640 u32 reserved;
641 u32 range_cnt;
642 struct gpa_range range[1];
643} __packed;
644
645
646struct vmadditional_data {
647 struct vmpacket_descriptor d;
648 u64 total_bytes;
649 u32 offset;
650 u32 byte_cnt;
651 unsigned char data[1];
652} __packed;
653
654union vmpacket_largest_possible_header {
655 struct vmpacket_descriptor simple_hdr;
656 struct vmtransfer_page_packet_header xfer_page_hdr;
657 struct vmgpadl_packet_header gpadl_hdr;
658 struct vmadd_remove_transfer_page_set add_rm_xfer_page_hdr;
659 struct vmestablish_gpadl establish_gpadl_hdr;
660 struct vmteardown_gpadl teardown_gpadl_hdr;
661 struct vmdata_gpa_direct data_gpa_direct_hdr;
662};
663
664#define VMPACKET_DATA_START_ADDRESS(__packet) \
665 (void *)(((unsigned char *)__packet) + \
666 ((struct vmpacket_descriptor)__packet)->offset8 * 8)
667
668#define VMPACKET_DATA_LENGTH(__packet) \
669 ((((struct vmpacket_descriptor)__packet)->len8 - \
670 ((struct vmpacket_descriptor)__packet)->offset8) * 8)
671
672#define VMPACKET_TRANSFER_MODE(__packet) \
673 (((struct IMPACT)__packet)->type)
674
675enum vmbus_packet_type {
676 VM_PKT_INVALID = 0x0,
677 VM_PKT_SYNCH = 0x1,
678 VM_PKT_ADD_XFER_PAGESET = 0x2,
679 VM_PKT_RM_XFER_PAGESET = 0x3,
680 VM_PKT_ESTABLISH_GPADL = 0x4,
681 VM_PKT_TEARDOWN_GPADL = 0x5,
682 VM_PKT_DATA_INBAND = 0x6,
683 VM_PKT_DATA_USING_XFER_PAGES = 0x7,
684 VM_PKT_DATA_USING_GPADL = 0x8,
685 VM_PKT_DATA_USING_GPA_DIRECT = 0x9,
686 VM_PKT_CANCEL_REQUEST = 0xa,
687 VM_PKT_COMP = 0xb,
688 VM_PKT_DATA_USING_ADDITIONAL_PKT = 0xc,
689 VM_PKT_ADDITIONAL_DATA = 0xd
690};
691
692#define VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED 1
693
694
695
696enum vmbus_channel_message_type {
697 CHANNELMSG_INVALID = 0,
698 CHANNELMSG_OFFERCHANNEL = 1,
699 CHANNELMSG_RESCIND_CHANNELOFFER = 2,
700 CHANNELMSG_REQUESTOFFERS = 3,
701 CHANNELMSG_ALLOFFERS_DELIVERED = 4,
702 CHANNELMSG_OPENCHANNEL = 5,
703 CHANNELMSG_OPENCHANNEL_RESULT = 6,
704 CHANNELMSG_CLOSECHANNEL = 7,
705 CHANNELMSG_GPADL_HEADER = 8,
706 CHANNELMSG_GPADL_BODY = 9,
707 CHANNELMSG_GPADL_CREATED = 10,
708 CHANNELMSG_GPADL_TEARDOWN = 11,
709 CHANNELMSG_GPADL_TORNDOWN = 12,
710 CHANNELMSG_RELID_RELEASED = 13,
711 CHANNELMSG_INITIATE_CONTACT = 14,
712 CHANNELMSG_VERSION_RESPONSE = 15,
713 CHANNELMSG_UNLOAD = 16,
714#ifdef VMBUS_FEATURE_PARENT_OR_PEER_MEMORY_MAPPED_INTO_A_CHILD
715 CHANNELMSG_VIEWRANGE_ADD = 17,
716 CHANNELMSG_VIEWRANGE_REMOVE = 18,
717#endif
718 CHANNELMSG_COUNT
719};
720
721struct vmbus_channel_message_header {
722 enum vmbus_channel_message_type msgtype;
723 u32 padding;
724} __packed;
725
726
727struct vmbus_channel_query_vmbus_version {
728 struct vmbus_channel_message_header header;
729 u32 version;
730} __packed;
731
732
733struct vmbus_channel_version_supported {
734 struct vmbus_channel_message_header header;
735 u8 version_supported;
736} __packed;
737
738
739struct vmbus_channel_offer_channel {
740 struct vmbus_channel_message_header header;
741 struct vmbus_channel_offer offer;
742 u32 child_relid;
743 u8 monitorid;
744
745
746
747 u8 monitor_allocated:1;
748 u8 reserved:7;
749
750
751
752
753
754
755
756
757
758
759
760 u16 is_dedicated_interrupt:1;
761 u16 reserved1:15;
762 u32 connection_id;
763} __packed;
764
765
766struct vmbus_channel_rescind_offer {
767 struct vmbus_channel_message_header header;
768 u32 child_relid;
769} __packed;
770
771
772
773
774
775
776
777
778
779
780
781struct vmbus_channel_open_channel {
782 struct vmbus_channel_message_header header;
783
784
785 u32 child_relid;
786
787
788 u32 openid;
789
790
791 u32 ringbuffer_gpadlhandle;
792
793
794
795
796
797
798
799
800
801 u32 target_vp;
802
803
804
805
806
807
808 u32 downstream_ringbuffer_pageoffset;
809
810
811 unsigned char userdata[MAX_USER_DEFINED_BYTES];
812} __packed;
813
814
815struct vmbus_channel_open_result {
816 struct vmbus_channel_message_header header;
817 u32 child_relid;
818 u32 openid;
819 u32 status;
820} __packed;
821
822
823struct vmbus_channel_close_channel {
824 struct vmbus_channel_message_header header;
825 u32 child_relid;
826} __packed;
827
828
829#define GPADL_TYPE_RING_BUFFER 1
830#define GPADL_TYPE_SERVER_SAVE_AREA 2
831#define GPADL_TYPE_TRANSACTION 8
832
833
834
835
836
837
838
839struct vmbus_channel_gpadl_header {
840 struct vmbus_channel_message_header header;
841 u32 child_relid;
842 u32 gpadl;
843 u16 range_buflen;
844 u16 rangecount;
845 struct gpa_range range[0];
846} __packed;
847
848
849struct vmbus_channel_gpadl_body {
850 struct vmbus_channel_message_header header;
851 u32 msgnumber;
852 u32 gpadl;
853 u64 pfn[0];
854} __packed;
855
856struct vmbus_channel_gpadl_created {
857 struct vmbus_channel_message_header header;
858 u32 child_relid;
859 u32 gpadl;
860 u32 creation_status;
861} __packed;
862
863struct vmbus_channel_gpadl_teardown {
864 struct vmbus_channel_message_header header;
865 u32 child_relid;
866 u32 gpadl;
867} __packed;
868
869struct vmbus_channel_gpadl_torndown {
870 struct vmbus_channel_message_header header;
871 u32 gpadl;
872} __packed;
873
874#ifdef VMBUS_FEATURE_PARENT_OR_PEER_MEMORY_MAPPED_INTO_A_CHILD
875struct vmbus_channel_view_range_add {
876 struct vmbus_channel_message_header header;
877 PHYSICAL_ADDRESS viewrange_base;
878 u64 viewrange_length;
879 u32 child_relid;
880} __packed;
881
882struct vmbus_channel_view_range_remove {
883 struct vmbus_channel_message_header header;
884 PHYSICAL_ADDRESS viewrange_base;
885 u32 child_relid;
886} __packed;
887#endif
888
889struct vmbus_channel_relid_released {
890 struct vmbus_channel_message_header header;
891 u32 child_relid;
892} __packed;
893
894struct vmbus_channel_initiate_contact {
895 struct vmbus_channel_message_header header;
896 u32 vmbus_version_requested;
897 u32 padding2;
898 u64 interrupt_page;
899 u64 monitor_page1;
900 u64 monitor_page2;
901} __packed;
902
903struct vmbus_channel_version_response {
904 struct vmbus_channel_message_header header;
905 u8 version_supported;
906} __packed;
907
908enum vmbus_channel_state {
909 CHANNEL_OFFER_STATE,
910 CHANNEL_OPENING_STATE,
911 CHANNEL_OPEN_STATE,
912};
913
914struct vmbus_channel_debug_info {
915 u32 relid;
916 enum vmbus_channel_state state;
917 uuid_le interfacetype;
918 uuid_le interface_instance;
919 u32 monitorid;
920 u32 servermonitor_pending;
921 u32 servermonitor_latency;
922 u32 servermonitor_connectionid;
923 u32 clientmonitor_pending;
924 u32 clientmonitor_latency;
925 u32 clientmonitor_connectionid;
926
927 struct hv_ring_buffer_debug_info inbound;
928 struct hv_ring_buffer_debug_info outbound;
929};
930
931
932
933
934
935struct vmbus_channel_msginfo {
936
937 struct list_head msglistentry;
938
939
940 struct list_head submsglist;
941
942
943 struct completion waitevent;
944 union {
945 struct vmbus_channel_version_supported version_supported;
946 struct vmbus_channel_open_result open_result;
947 struct vmbus_channel_gpadl_torndown gpadl_torndown;
948 struct vmbus_channel_gpadl_created gpadl_created;
949 struct vmbus_channel_version_response version_response;
950 } response;
951
952 u32 msgsize;
953
954
955
956
957 unsigned char msg[0];
958};
959
960struct vmbus_close_msg {
961 struct vmbus_channel_msginfo info;
962 struct vmbus_channel_close_channel msg;
963};
964
965
966union hv_connection_id {
967 u32 asu32;
968 struct {
969 u32 id:24;
970 u32 reserved:8;
971 } u;
972};
973
974
975struct hv_input_signal_event {
976 union hv_connection_id connectionid;
977 u16 flag_number;
978 u16 rsvdz;
979};
980
981struct hv_input_signal_event_buffer {
982 u64 align8;
983 struct hv_input_signal_event event;
984};
985
986struct vmbus_channel {
987 struct list_head listentry;
988
989 struct hv_device *device_obj;
990
991 struct work_struct work;
992
993 enum vmbus_channel_state state;
994
995 struct vmbus_channel_offer_channel offermsg;
996
997
998
999
1000 u8 monitor_grp;
1001 u8 monitor_bit;
1002
1003 u32 ringbuffer_gpadlhandle;
1004
1005
1006 void *ringbuffer_pages;
1007 u32 ringbuffer_pagecount;
1008 struct hv_ring_buffer_info outbound;
1009 struct hv_ring_buffer_info inbound;
1010 spinlock_t inbound_lock;
1011 struct workqueue_struct *controlwq;
1012
1013 struct vmbus_close_msg close_msg;
1014
1015
1016
1017
1018 void (*onchannel_callback)(void *context);
1019 void *channel_callback_context;
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034 bool batched_reading;
1035
1036 bool is_dedicated_interrupt;
1037 struct hv_input_signal_event_buffer sig_buf;
1038 struct hv_input_signal_event *sig_event;
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048 u32 target_vp;
1049};
1050
1051static inline void set_channel_read_state(struct vmbus_channel *c, bool state)
1052{
1053 c->batched_reading = state;
1054}
1055
1056void vmbus_onmessage(void *context);
1057
1058int vmbus_request_offers(void);
1059
1060
1061struct vmbus_channel_packet_page_buffer {
1062 u16 type;
1063 u16 dataoffset8;
1064 u16 length8;
1065 u16 flags;
1066 u64 transactionid;
1067 u32 reserved;
1068 u32 rangecount;
1069 struct hv_page_buffer range[MAX_PAGE_BUFFER_COUNT];
1070} __packed;
1071
1072
1073struct vmbus_channel_packet_multipage_buffer {
1074 u16 type;
1075 u16 dataoffset8;
1076 u16 length8;
1077 u16 flags;
1078 u64 transactionid;
1079 u32 reserved;
1080 u32 rangecount;
1081 struct hv_multipage_buffer range;
1082} __packed;
1083
1084
1085extern int vmbus_open(struct vmbus_channel *channel,
1086 u32 send_ringbuffersize,
1087 u32 recv_ringbuffersize,
1088 void *userdata,
1089 u32 userdatalen,
1090 void(*onchannel_callback)(void *context),
1091 void *context);
1092
1093extern void vmbus_close(struct vmbus_channel *channel);
1094
1095extern int vmbus_sendpacket(struct vmbus_channel *channel,
1096 const void *buffer,
1097 u32 bufferLen,
1098 u64 requestid,
1099 enum vmbus_packet_type type,
1100 u32 flags);
1101
1102extern int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel,
1103 struct hv_page_buffer pagebuffers[],
1104 u32 pagecount,
1105 void *buffer,
1106 u32 bufferlen,
1107 u64 requestid);
1108
1109extern int vmbus_sendpacket_multipagebuffer(struct vmbus_channel *channel,
1110 struct hv_multipage_buffer *mpb,
1111 void *buffer,
1112 u32 bufferlen,
1113 u64 requestid);
1114
1115extern int vmbus_establish_gpadl(struct vmbus_channel *channel,
1116 void *kbuffer,
1117 u32 size,
1118 u32 *gpadl_handle);
1119
1120extern int vmbus_teardown_gpadl(struct vmbus_channel *channel,
1121 u32 gpadl_handle);
1122
1123extern int vmbus_recvpacket(struct vmbus_channel *channel,
1124 void *buffer,
1125 u32 bufferlen,
1126 u32 *buffer_actual_len,
1127 u64 *requestid);
1128
1129extern int vmbus_recvpacket_raw(struct vmbus_channel *channel,
1130 void *buffer,
1131 u32 bufferlen,
1132 u32 *buffer_actual_len,
1133 u64 *requestid);
1134
1135
1136extern void vmbus_get_debug_info(struct vmbus_channel *channel,
1137 struct vmbus_channel_debug_info *debug);
1138
1139extern void vmbus_ontimer(unsigned long data);
1140
1141struct hv_dev_port_info {
1142 u32 int_mask;
1143 u32 read_idx;
1144 u32 write_idx;
1145 u32 bytes_avail_toread;
1146 u32 bytes_avail_towrite;
1147};
1148
1149
1150struct hv_driver {
1151 const char *name;
1152
1153
1154 uuid_le dev_type;
1155 const struct hv_vmbus_device_id *id_table;
1156
1157 struct device_driver driver;
1158
1159 int (*probe)(struct hv_device *, const struct hv_vmbus_device_id *);
1160 int (*remove)(struct hv_device *);
1161 void (*shutdown)(struct hv_device *);
1162
1163};
1164
1165
1166struct hv_device {
1167
1168 uuid_le dev_type;
1169
1170
1171 uuid_le dev_instance;
1172
1173 struct device device;
1174
1175 struct vmbus_channel *channel;
1176};
1177
1178
1179static inline struct hv_device *device_to_hv_device(struct device *d)
1180{
1181 return container_of(d, struct hv_device, device);
1182}
1183
1184static inline struct hv_driver *drv_to_hv_drv(struct device_driver *d)
1185{
1186 return container_of(d, struct hv_driver, driver);
1187}
1188
1189static inline void hv_set_drvdata(struct hv_device *dev, void *data)
1190{
1191 dev_set_drvdata(&dev->device, data);
1192}
1193
1194static inline void *hv_get_drvdata(struct hv_device *dev)
1195{
1196 return dev_get_drvdata(&dev->device);
1197}
1198
1199
1200#define vmbus_driver_register(driver) \
1201 __vmbus_driver_register(driver, THIS_MODULE, KBUILD_MODNAME)
1202int __must_check __vmbus_driver_register(struct hv_driver *hv_driver,
1203 struct module *owner,
1204 const char *mod_name);
1205void vmbus_driver_unregister(struct hv_driver *hv_driver);
1206
1207
1208
1209
1210
1211
1212
1213#define VMBUS_DEVICE(g0, g1, g2, g3, g4, g5, g6, g7, \
1214 g8, g9, ga, gb, gc, gd, ge, gf) \
1215 .guid = { g0, g1, g2, g3, g4, g5, g6, g7, \
1216 g8, g9, ga, gb, gc, gd, ge, gf },
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226#define HV_NIC_GUID \
1227 .guid = { \
1228 0x63, 0x51, 0x61, 0xf8, 0x3e, 0xdf, 0xc5, 0x46, \
1229 0x91, 0x3f, 0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e \
1230 }
1231
1232
1233
1234
1235
1236#define HV_IDE_GUID \
1237 .guid = { \
1238 0x32, 0x26, 0x41, 0x32, 0xcb, 0x86, 0xa2, 0x44, \
1239 0x9b, 0x5c, 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5 \
1240 }
1241
1242
1243
1244
1245
1246#define HV_SCSI_GUID \
1247 .guid = { \
1248 0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d, \
1249 0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f \
1250 }
1251
1252
1253
1254
1255
1256#define HV_SHUTDOWN_GUID \
1257 .guid = { \
1258 0x31, 0x60, 0x0b, 0x0e, 0x13, 0x52, 0x34, 0x49, \
1259 0x81, 0x8b, 0x38, 0xd9, 0x0c, 0xed, 0x39, 0xdb \
1260 }
1261
1262
1263
1264
1265
1266#define HV_TS_GUID \
1267 .guid = { \
1268 0x30, 0xe6, 0x27, 0x95, 0xae, 0xd0, 0x7b, 0x49, \
1269 0xad, 0xce, 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf \
1270 }
1271
1272
1273
1274
1275
1276#define HV_HEART_BEAT_GUID \
1277 .guid = { \
1278 0x39, 0x4f, 0x16, 0x57, 0x15, 0x91, 0x78, 0x4e, \
1279 0xab, 0x55, 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d \
1280 }
1281
1282
1283
1284
1285
1286#define HV_KVP_GUID \
1287 .guid = { \
1288 0xe7, 0xf4, 0xa0, 0xa9, 0x45, 0x5a, 0x96, 0x4d, \
1289 0xb8, 0x27, 0x8a, 0x84, 0x1e, 0x8c, 0x3, 0xe6 \
1290 }
1291
1292
1293
1294
1295
1296#define HV_DM_GUID \
1297 .guid = { \
1298 0xdc, 0x74, 0x50, 0X52, 0x85, 0x89, 0xe2, 0x46, \
1299 0x80, 0x57, 0xa3, 0x07, 0xdc, 0x18, 0xa5, 0x02 \
1300 }
1301
1302
1303
1304
1305
1306#define HV_MOUSE_GUID \
1307 .guid = { \
1308 0x9e, 0xb6, 0xa8, 0xcf, 0x4a, 0x5b, 0xc0, 0x4c, \
1309 0xb9, 0x8b, 0x8b, 0xa1, 0xa1, 0xf3, 0xf9, 0x5a \
1310 }
1311
1312
1313
1314
1315#define HV_VSS_GUID \
1316 .guid = { \
1317 0x29, 0x2e, 0xfa, 0x35, 0x23, 0xea, 0x36, 0x42, \
1318 0x96, 0xae, 0x3a, 0x6e, 0xba, 0xcb, 0xa4, 0x40 \
1319 }
1320
1321
1322
1323
1324#define HV_SYNTHVID_GUID \
1325 .guid = { \
1326 0x02, 0x78, 0x0a, 0xda, 0x77, 0xe3, 0xac, 0x4a, \
1327 0x8e, 0x77, 0x05, 0x58, 0xeb, 0x10, 0x73, 0xf8 \
1328 }
1329
1330
1331
1332
1333
1334
1335#define ICMSGTYPE_NEGOTIATE 0
1336#define ICMSGTYPE_HEARTBEAT 1
1337#define ICMSGTYPE_KVPEXCHANGE 2
1338#define ICMSGTYPE_SHUTDOWN 3
1339#define ICMSGTYPE_TIMESYNC 4
1340#define ICMSGTYPE_VSS 5
1341
1342#define ICMSGHDRFLAG_TRANSACTION 1
1343#define ICMSGHDRFLAG_REQUEST 2
1344#define ICMSGHDRFLAG_RESPONSE 4
1345
1346
1347
1348
1349
1350
1351
1352
1353struct hv_util_service {
1354 u8 *recv_buffer;
1355 void (*util_cb)(void *);
1356 int (*util_init)(struct hv_util_service *);
1357 void (*util_deinit)(void);
1358};
1359
1360struct vmbuspipe_hdr {
1361 u32 flags;
1362 u32 msgsize;
1363} __packed;
1364
1365struct ic_version {
1366 u16 major;
1367 u16 minor;
1368} __packed;
1369
1370struct icmsg_hdr {
1371 struct ic_version icverframe;
1372 u16 icmsgtype;
1373 struct ic_version icvermsg;
1374 u16 icmsgsize;
1375 u32 status;
1376 u8 ictransaction_id;
1377 u8 icflags;
1378 u8 reserved[2];
1379} __packed;
1380
1381struct icmsg_negotiate {
1382 u16 icframe_vercnt;
1383 u16 icmsg_vercnt;
1384 u32 reserved;
1385 struct ic_version icversion_data[1];
1386} __packed;
1387
1388struct shutdown_msg_data {
1389 u32 reason_code;
1390 u32 timeout_seconds;
1391 u32 flags;
1392 u8 display_message[2048];
1393} __packed;
1394
1395struct heartbeat_msg_data {
1396 u64 seq_num;
1397 u32 reserved[8];
1398} __packed;
1399
1400
1401#define ICTIMESYNCFLAG_PROBE 0
1402#define ICTIMESYNCFLAG_SYNC 1
1403#define ICTIMESYNCFLAG_SAMPLE 2
1404
1405#ifdef __x86_64__
1406#define WLTIMEDELTA 116444736000000000L
1407#else
1408#define WLTIMEDELTA 116444736000000000LL
1409#endif
1410
1411struct ictimesync_data {
1412 u64 parenttime;
1413 u64 childtime;
1414 u64 roundtriptime;
1415 u8 flags;
1416} __packed;
1417
1418struct hyperv_service_callback {
1419 u8 msg_type;
1420 char *log_msg;
1421 uuid_le data;
1422 struct vmbus_channel *channel;
1423 void (*callback) (void *context);
1424};
1425
1426#define MAX_SRV_VER 0x7ffffff
1427extern void vmbus_prep_negotiate_resp(struct icmsg_hdr *,
1428 struct icmsg_negotiate *, u8 *, int,
1429 int);
1430
1431int hv_kvp_init(struct hv_util_service *);
1432void hv_kvp_deinit(void);
1433void hv_kvp_onchannelcallback(void *);
1434
1435int hv_vss_init(struct hv_util_service *);
1436void hv_vss_deinit(void);
1437void hv_vss_onchannelcallback(void *);
1438
1439
1440
1441
1442
1443extern __u32 vmbus_proto_version;
1444
1445#endif
1446#endif
1447