1
2
3
4
5
6
7
8
9
10
11
12#ifndef _HYPERV_H
13#define _HYPERV_H
14
15#include <uapi/linux/hyperv.h>
16
17#include <linux/types.h>
18#include <linux/scatterlist.h>
19#include <linux/list.h>
20#include <linux/timer.h>
21#include <linux/completion.h>
22#include <linux/device.h>
23#include <linux/mod_devicetable.h>
24#include <linux/interrupt.h>
25#include <linux/reciprocal_div.h>
26
27#define MAX_PAGE_BUFFER_COUNT 32
28#define MAX_MULTIPAGE_BUFFER_COUNT 32
29
30#pragma pack(push, 1)
31
32
33struct hv_page_buffer {
34 u32 len;
35 u32 offset;
36 u64 pfn;
37};
38
39
40struct hv_multipage_buffer {
41
42 u32 len;
43 u32 offset;
44 u64 pfn_array[MAX_MULTIPAGE_BUFFER_COUNT];
45};
46
47
48
49
50
51
52struct hv_mpb_array {
53
54 u32 len;
55 u32 offset;
56 u64 pfn_array[];
57};
58
59
60#define MAX_PAGE_BUFFER_PACKET (0x18 + \
61 (sizeof(struct hv_page_buffer) * \
62 MAX_PAGE_BUFFER_COUNT))
63#define MAX_MULTIPAGE_BUFFER_PACKET (0x18 + \
64 sizeof(struct hv_multipage_buffer))
65
66
67#pragma pack(pop)
68
69struct hv_ring_buffer {
70
71 u32 write_index;
72
73
74 u32 read_index;
75
76 u32 interrupt_mask;
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104 u32 pending_send_sz;
105 u32 reserved1[12];
106 union {
107 struct {
108 u32 feat_pending_send_sz:1;
109 };
110 u32 value;
111 } feature_bits;
112
113
114 u8 reserved2[4028];
115
116
117
118
119
120 u8 buffer[0];
121} __packed;
122
123struct hv_ring_buffer_info {
124 struct hv_ring_buffer *ring_buffer;
125 u32 ring_size;
126 struct reciprocal_value ring_size_div10_reciprocal;
127 spinlock_t ring_lock;
128
129 u32 ring_datasize;
130 u32 priv_read_index;
131
132
133
134
135 struct mutex ring_buffer_mutex;
136};
137
138
139static inline u32 hv_get_bytes_to_read(const struct hv_ring_buffer_info *rbi)
140{
141 u32 read_loc, write_loc, dsize, read;
142
143 dsize = rbi->ring_datasize;
144 read_loc = rbi->ring_buffer->read_index;
145 write_loc = READ_ONCE(rbi->ring_buffer->write_index);
146
147 read = write_loc >= read_loc ? (write_loc - read_loc) :
148 (dsize - read_loc) + write_loc;
149
150 return read;
151}
152
153static inline u32 hv_get_bytes_to_write(const struct hv_ring_buffer_info *rbi)
154{
155 u32 read_loc, write_loc, dsize, write;
156
157 dsize = rbi->ring_datasize;
158 read_loc = READ_ONCE(rbi->ring_buffer->read_index);
159 write_loc = rbi->ring_buffer->write_index;
160
161 write = write_loc >= read_loc ? dsize - (write_loc - read_loc) :
162 read_loc - write_loc;
163 return write;
164}
165
166static inline u32 hv_get_avail_to_write_percent(
167 const struct hv_ring_buffer_info *rbi)
168{
169 u32 avail_write = hv_get_bytes_to_write(rbi);
170
171 return reciprocal_divide(
172 (avail_write << 3) + (avail_write << 1),
173 rbi->ring_size_div10_reciprocal);
174}
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191#define VERSION_WS2008 ((0 << 16) | (13))
192#define VERSION_WIN7 ((1 << 16) | (1))
193#define VERSION_WIN8 ((2 << 16) | (4))
194#define VERSION_WIN8_1 ((3 << 16) | (0))
195#define VERSION_WIN10 ((4 << 16) | (0))
196#define VERSION_WIN10_V4_1 ((4 << 16) | (1))
197#define VERSION_WIN10_V5 ((5 << 16) | (0))
198#define VERSION_WIN10_V5_1 ((5 << 16) | (1))
199#define VERSION_WIN10_V5_2 ((5 << 16) | (2))
200
201
202#define MAX_PIPE_DATA_PAYLOAD (sizeof(u8) * 16384)
203
204
205#define VMBUS_PIPE_TYPE_BYTE 0x00000000
206#define VMBUS_PIPE_TYPE_MESSAGE 0x00000004
207
208
209#define MAX_USER_DEFINED_BYTES 120
210
211
212#define MAX_PIPE_USER_DEFINED_BYTES 116
213
214
215
216
217
218struct vmbus_channel_offer {
219 guid_t if_type;
220 guid_t if_instance;
221
222
223
224
225 u64 reserved1;
226 u64 reserved2;
227
228 u16 chn_flags;
229 u16 mmio_megabytes;
230
231 union {
232
233 struct {
234 unsigned char user_def[MAX_USER_DEFINED_BYTES];
235 } std;
236
237
238
239
240
241
242
243
244 struct {
245 u32 pipe_mode;
246 unsigned char user_def[MAX_PIPE_USER_DEFINED_BYTES];
247 } pipe;
248 } u;
249
250
251
252
253
254
255 u16 sub_channel_index;
256 u16 reserved3;
257} __packed;
258
259
260#define VMBUS_CHANNEL_ENUMERATE_DEVICE_INTERFACE 1
261#define VMBUS_CHANNEL_SERVER_SUPPORTS_TRANSFER_PAGES 2
262#define VMBUS_CHANNEL_SERVER_SUPPORTS_GPADLS 4
263#define VMBUS_CHANNEL_NAMED_PIPE_MODE 0x10
264#define VMBUS_CHANNEL_LOOPBACK_OFFER 0x100
265#define VMBUS_CHANNEL_PARENT_OFFER 0x200
266#define VMBUS_CHANNEL_REQUEST_MONITORED_NOTIFICATION 0x400
267#define VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER 0x2000
268
269struct vmpacket_descriptor {
270 u16 type;
271 u16 offset8;
272 u16 len8;
273 u16 flags;
274 u64 trans_id;
275} __packed;
276
277struct vmpacket_header {
278 u32 prev_pkt_start_offset;
279 struct vmpacket_descriptor descriptor;
280} __packed;
281
282struct vmtransfer_page_range {
283 u32 byte_count;
284 u32 byte_offset;
285} __packed;
286
287struct vmtransfer_page_packet_header {
288 struct vmpacket_descriptor d;
289 u16 xfer_pageset_id;
290 u8 sender_owns_set;
291 u8 reserved;
292 u32 range_cnt;
293 struct vmtransfer_page_range ranges[1];
294} __packed;
295
296struct vmgpadl_packet_header {
297 struct vmpacket_descriptor d;
298 u32 gpadl;
299 u32 reserved;
300} __packed;
301
302struct vmadd_remove_transfer_page_set {
303 struct vmpacket_descriptor d;
304 u32 gpadl;
305 u16 xfer_pageset_id;
306 u16 reserved;
307} __packed;
308
309
310
311
312
313struct gpa_range {
314 u32 byte_count;
315 u32 byte_offset;
316 u64 pfn_array[0];
317};
318
319
320
321
322
323
324
325
326struct vmestablish_gpadl {
327 struct vmpacket_descriptor d;
328 u32 gpadl;
329 u32 range_cnt;
330 struct gpa_range range[1];
331} __packed;
332
333
334
335
336
337struct vmteardown_gpadl {
338 struct vmpacket_descriptor d;
339 u32 gpadl;
340 u32 reserved;
341} __packed;
342
343
344
345
346
347struct vmdata_gpa_direct {
348 struct vmpacket_descriptor d;
349 u32 reserved;
350 u32 range_cnt;
351 struct gpa_range range[1];
352} __packed;
353
354
355struct vmadditional_data {
356 struct vmpacket_descriptor d;
357 u64 total_bytes;
358 u32 offset;
359 u32 byte_cnt;
360 unsigned char data[1];
361} __packed;
362
363union vmpacket_largest_possible_header {
364 struct vmpacket_descriptor simple_hdr;
365 struct vmtransfer_page_packet_header xfer_page_hdr;
366 struct vmgpadl_packet_header gpadl_hdr;
367 struct vmadd_remove_transfer_page_set add_rm_xfer_page_hdr;
368 struct vmestablish_gpadl establish_gpadl_hdr;
369 struct vmteardown_gpadl teardown_gpadl_hdr;
370 struct vmdata_gpa_direct data_gpa_direct_hdr;
371};
372
373#define VMPACKET_DATA_START_ADDRESS(__packet) \
374 (void *)(((unsigned char *)__packet) + \
375 ((struct vmpacket_descriptor)__packet)->offset8 * 8)
376
377#define VMPACKET_DATA_LENGTH(__packet) \
378 ((((struct vmpacket_descriptor)__packet)->len8 - \
379 ((struct vmpacket_descriptor)__packet)->offset8) * 8)
380
381#define VMPACKET_TRANSFER_MODE(__packet) \
382 (((struct IMPACT)__packet)->type)
383
384enum vmbus_packet_type {
385 VM_PKT_INVALID = 0x0,
386 VM_PKT_SYNCH = 0x1,
387 VM_PKT_ADD_XFER_PAGESET = 0x2,
388 VM_PKT_RM_XFER_PAGESET = 0x3,
389 VM_PKT_ESTABLISH_GPADL = 0x4,
390 VM_PKT_TEARDOWN_GPADL = 0x5,
391 VM_PKT_DATA_INBAND = 0x6,
392 VM_PKT_DATA_USING_XFER_PAGES = 0x7,
393 VM_PKT_DATA_USING_GPADL = 0x8,
394 VM_PKT_DATA_USING_GPA_DIRECT = 0x9,
395 VM_PKT_CANCEL_REQUEST = 0xa,
396 VM_PKT_COMP = 0xb,
397 VM_PKT_DATA_USING_ADDITIONAL_PKT = 0xc,
398 VM_PKT_ADDITIONAL_DATA = 0xd
399};
400
401#define VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED 1
402
403
404
405enum vmbus_channel_message_type {
406 CHANNELMSG_INVALID = 0,
407 CHANNELMSG_OFFERCHANNEL = 1,
408 CHANNELMSG_RESCIND_CHANNELOFFER = 2,
409 CHANNELMSG_REQUESTOFFERS = 3,
410 CHANNELMSG_ALLOFFERS_DELIVERED = 4,
411 CHANNELMSG_OPENCHANNEL = 5,
412 CHANNELMSG_OPENCHANNEL_RESULT = 6,
413 CHANNELMSG_CLOSECHANNEL = 7,
414 CHANNELMSG_GPADL_HEADER = 8,
415 CHANNELMSG_GPADL_BODY = 9,
416 CHANNELMSG_GPADL_CREATED = 10,
417 CHANNELMSG_GPADL_TEARDOWN = 11,
418 CHANNELMSG_GPADL_TORNDOWN = 12,
419 CHANNELMSG_RELID_RELEASED = 13,
420 CHANNELMSG_INITIATE_CONTACT = 14,
421 CHANNELMSG_VERSION_RESPONSE = 15,
422 CHANNELMSG_UNLOAD = 16,
423 CHANNELMSG_UNLOAD_RESPONSE = 17,
424 CHANNELMSG_18 = 18,
425 CHANNELMSG_19 = 19,
426 CHANNELMSG_20 = 20,
427 CHANNELMSG_TL_CONNECT_REQUEST = 21,
428 CHANNELMSG_22 = 22,
429 CHANNELMSG_TL_CONNECT_RESULT = 23,
430 CHANNELMSG_COUNT
431};
432
433
434#define INVALID_RELID U32_MAX
435
436struct vmbus_channel_message_header {
437 enum vmbus_channel_message_type msgtype;
438 u32 padding;
439} __packed;
440
441
442struct vmbus_channel_query_vmbus_version {
443 struct vmbus_channel_message_header header;
444 u32 version;
445} __packed;
446
447
448struct vmbus_channel_version_supported {
449 struct vmbus_channel_message_header header;
450 u8 version_supported;
451} __packed;
452
453
454struct vmbus_channel_offer_channel {
455 struct vmbus_channel_message_header header;
456 struct vmbus_channel_offer offer;
457 u32 child_relid;
458 u8 monitorid;
459
460
461
462 u8 monitor_allocated:1;
463 u8 reserved:7;
464
465
466
467
468
469
470
471
472
473
474
475 u16 is_dedicated_interrupt:1;
476 u16 reserved1:15;
477 u32 connection_id;
478} __packed;
479
480
481struct vmbus_channel_rescind_offer {
482 struct vmbus_channel_message_header header;
483 u32 child_relid;
484} __packed;
485
486static inline u32
487hv_ringbuffer_pending_size(const struct hv_ring_buffer_info *rbi)
488{
489 return rbi->ring_buffer->pending_send_sz;
490}
491
492
493
494
495
496
497
498
499
500
501
502struct vmbus_channel_open_channel {
503 struct vmbus_channel_message_header header;
504
505
506 u32 child_relid;
507
508
509 u32 openid;
510
511
512 u32 ringbuffer_gpadlhandle;
513
514
515
516
517
518
519
520
521
522 u32 target_vp;
523
524
525
526
527
528
529 u32 downstream_ringbuffer_pageoffset;
530
531
532 unsigned char userdata[MAX_USER_DEFINED_BYTES];
533} __packed;
534
535
536struct vmbus_channel_open_result {
537 struct vmbus_channel_message_header header;
538 u32 child_relid;
539 u32 openid;
540 u32 status;
541} __packed;
542
543
544struct vmbus_channel_close_channel {
545 struct vmbus_channel_message_header header;
546 u32 child_relid;
547} __packed;
548
549
550#define GPADL_TYPE_RING_BUFFER 1
551#define GPADL_TYPE_SERVER_SAVE_AREA 2
552#define GPADL_TYPE_TRANSACTION 8
553
554
555
556
557
558
559
560struct vmbus_channel_gpadl_header {
561 struct vmbus_channel_message_header header;
562 u32 child_relid;
563 u32 gpadl;
564 u16 range_buflen;
565 u16 rangecount;
566 struct gpa_range range[0];
567} __packed;
568
569
570struct vmbus_channel_gpadl_body {
571 struct vmbus_channel_message_header header;
572 u32 msgnumber;
573 u32 gpadl;
574 u64 pfn[0];
575} __packed;
576
577struct vmbus_channel_gpadl_created {
578 struct vmbus_channel_message_header header;
579 u32 child_relid;
580 u32 gpadl;
581 u32 creation_status;
582} __packed;
583
584struct vmbus_channel_gpadl_teardown {
585 struct vmbus_channel_message_header header;
586 u32 child_relid;
587 u32 gpadl;
588} __packed;
589
590struct vmbus_channel_gpadl_torndown {
591 struct vmbus_channel_message_header header;
592 u32 gpadl;
593} __packed;
594
595struct vmbus_channel_relid_released {
596 struct vmbus_channel_message_header header;
597 u32 child_relid;
598} __packed;
599
600struct vmbus_channel_initiate_contact {
601 struct vmbus_channel_message_header header;
602 u32 vmbus_version_requested;
603 u32 target_vcpu;
604 union {
605 u64 interrupt_page;
606 struct {
607 u8 msg_sint;
608 u8 padding1[3];
609 u32 padding2;
610 };
611 };
612 u64 monitor_page1;
613 u64 monitor_page2;
614} __packed;
615
616
617struct vmbus_channel_tl_connect_request {
618 struct vmbus_channel_message_header header;
619 guid_t guest_endpoint_id;
620 guid_t host_service_id;
621} __packed;
622
623struct vmbus_channel_version_response {
624 struct vmbus_channel_message_header header;
625 u8 version_supported;
626
627 u8 connection_state;
628 u16 padding;
629
630
631
632
633
634
635
636
637
638 u32 msg_conn_id;
639} __packed;
640
641enum vmbus_channel_state {
642 CHANNEL_OFFER_STATE,
643 CHANNEL_OPENING_STATE,
644 CHANNEL_OPEN_STATE,
645 CHANNEL_OPENED_STATE,
646};
647
648
649
650
651
652struct vmbus_channel_msginfo {
653
654 struct list_head msglistentry;
655
656
657 struct list_head submsglist;
658
659
660 struct completion waitevent;
661 struct vmbus_channel *waiting_channel;
662 union {
663 struct vmbus_channel_version_supported version_supported;
664 struct vmbus_channel_open_result open_result;
665 struct vmbus_channel_gpadl_torndown gpadl_torndown;
666 struct vmbus_channel_gpadl_created gpadl_created;
667 struct vmbus_channel_version_response version_response;
668 } response;
669
670 u32 msgsize;
671
672
673
674
675 unsigned char msg[0];
676};
677
678struct vmbus_close_msg {
679 struct vmbus_channel_msginfo info;
680 struct vmbus_channel_close_channel msg;
681};
682
683
684union hv_connection_id {
685 u32 asu32;
686 struct {
687 u32 id:24;
688 u32 reserved:8;
689 } u;
690};
691
692enum hv_numa_policy {
693 HV_BALANCED = 0,
694 HV_LOCALIZED,
695};
696
697enum vmbus_device_type {
698 HV_IDE = 0,
699 HV_SCSI,
700 HV_FC,
701 HV_NIC,
702 HV_ND,
703 HV_PCIE,
704 HV_FB,
705 HV_KBD,
706 HV_MOUSE,
707 HV_KVP,
708 HV_TS,
709 HV_HB,
710 HV_SHUTDOWN,
711 HV_FCOPY,
712 HV_BACKUP,
713 HV_DM,
714 HV_UNKNOWN,
715};
716
717struct vmbus_device {
718 u16 dev_type;
719 guid_t guid;
720 bool perf_device;
721};
722
723struct vmbus_channel {
724 struct list_head listentry;
725
726 struct hv_device *device_obj;
727
728 enum vmbus_channel_state state;
729
730 struct vmbus_channel_offer_channel offermsg;
731
732
733
734
735 u8 monitor_grp;
736 u8 monitor_bit;
737
738 bool rescind;
739 struct completion rescind_event;
740
741 u32 ringbuffer_gpadlhandle;
742
743
744 struct page *ringbuffer_page;
745 u32 ringbuffer_pagecount;
746 u32 ringbuffer_send_offset;
747 struct hv_ring_buffer_info outbound;
748 struct hv_ring_buffer_info inbound;
749
750 struct vmbus_close_msg close_msg;
751
752
753 u64 interrupts;
754 u64 sig_events;
755
756
757
758
759
760 u64 intr_out_empty;
761
762
763
764
765
766
767 bool out_full_flag;
768
769
770 struct tasklet_struct callback_event;
771 void (*onchannel_callback)(void *context);
772 void *channel_callback_context;
773
774
775
776
777
778
779
780
781
782
783
784
785 enum hv_callback_mode {
786 HV_CALL_BATCHED,
787 HV_CALL_DIRECT,
788 HV_CALL_ISR
789 } callback_mode;
790
791 bool is_dedicated_interrupt;
792 u64 sig_event;
793
794
795
796
797
798
799
800
801
802 u32 target_vp;
803
804 u32 target_cpu;
805
806
807
808 struct cpumask alloced_cpus_in_node;
809 int numa_node;
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830 void (*sc_creation_callback)(struct vmbus_channel *new_sc);
831
832
833
834
835
836 void (*chn_rescind_callback)(struct vmbus_channel *channel);
837
838
839
840
841
842
843 spinlock_t lock;
844
845
846
847 struct list_head sc_list;
848
849
850
851
852 struct vmbus_channel *primary_channel;
853
854
855
856 void *per_channel_state;
857
858
859
860
861 struct list_head percpu_list;
862
863
864
865
866
867 struct rcu_head rcu;
868
869
870
871
872 struct kobject kobj;
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898 bool low_latency;
899
900
901
902
903
904
905
906
907
908
909
910 enum hv_numa_policy affinity_policy;
911
912 bool probe_done;
913
914
915
916
917
918
919
920 struct work_struct add_channel_work;
921
922
923
924
925
926 u64 intr_in_full;
927
928
929
930
931
932 u64 out_full_total;
933
934
935
936
937
938 u64 out_full_first;
939
940
941 bool fuzz_testing_state;
942
943
944
945
946
947
948
949
950
951 u32 fuzz_testing_interrupt_delay;
952 u32 fuzz_testing_message_delay;
953
954};
955
956static inline bool is_hvsock_channel(const struct vmbus_channel *c)
957{
958 return !!(c->offermsg.offer.chn_flags &
959 VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER);
960}
961
962static inline bool is_sub_channel(const struct vmbus_channel *c)
963{
964 return c->offermsg.offer.sub_channel_index != 0;
965}
966
967static inline void set_channel_affinity_state(struct vmbus_channel *c,
968 enum hv_numa_policy policy)
969{
970 c->affinity_policy = policy;
971}
972
973static inline void set_channel_read_mode(struct vmbus_channel *c,
974 enum hv_callback_mode mode)
975{
976 c->callback_mode = mode;
977}
978
979static inline void set_per_channel_state(struct vmbus_channel *c, void *s)
980{
981 c->per_channel_state = s;
982}
983
984static inline void *get_per_channel_state(struct vmbus_channel *c)
985{
986 return c->per_channel_state;
987}
988
989static inline void set_channel_pending_send_size(struct vmbus_channel *c,
990 u32 size)
991{
992 unsigned long flags;
993
994 if (size) {
995 spin_lock_irqsave(&c->outbound.ring_lock, flags);
996 ++c->out_full_total;
997
998 if (!c->out_full_flag) {
999 ++c->out_full_first;
1000 c->out_full_flag = true;
1001 }
1002 spin_unlock_irqrestore(&c->outbound.ring_lock, flags);
1003 } else {
1004 c->out_full_flag = false;
1005 }
1006
1007 c->outbound.ring_buffer->pending_send_sz = size;
1008}
1009
1010static inline void set_low_latency_mode(struct vmbus_channel *c)
1011{
1012 c->low_latency = true;
1013}
1014
1015static inline void clear_low_latency_mode(struct vmbus_channel *c)
1016{
1017 c->low_latency = false;
1018}
1019
1020void vmbus_onmessage(void *context);
1021
1022int vmbus_request_offers(void);
1023
1024
1025
1026
1027
1028void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel,
1029 void (*sc_cr_cb)(struct vmbus_channel *new_sc));
1030
1031void vmbus_set_chn_rescind_callback(struct vmbus_channel *channel,
1032 void (*chn_rescind_cb)(struct vmbus_channel *));
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045bool vmbus_are_subchannels_present(struct vmbus_channel *primary);
1046
1047
1048struct vmbus_channel_packet_page_buffer {
1049 u16 type;
1050 u16 dataoffset8;
1051 u16 length8;
1052 u16 flags;
1053 u64 transactionid;
1054 u32 reserved;
1055 u32 rangecount;
1056 struct hv_page_buffer range[MAX_PAGE_BUFFER_COUNT];
1057} __packed;
1058
1059
1060struct vmbus_channel_packet_multipage_buffer {
1061 u16 type;
1062 u16 dataoffset8;
1063 u16 length8;
1064 u16 flags;
1065 u64 transactionid;
1066 u32 reserved;
1067 u32 rangecount;
1068 struct hv_multipage_buffer range;
1069} __packed;
1070
1071
1072struct vmbus_packet_mpb_array {
1073 u16 type;
1074 u16 dataoffset8;
1075 u16 length8;
1076 u16 flags;
1077 u64 transactionid;
1078 u32 reserved;
1079 u32 rangecount;
1080 struct hv_mpb_array range;
1081} __packed;
1082
1083int vmbus_alloc_ring(struct vmbus_channel *channel,
1084 u32 send_size, u32 recv_size);
1085void vmbus_free_ring(struct vmbus_channel *channel);
1086
1087int vmbus_connect_ring(struct vmbus_channel *channel,
1088 void (*onchannel_callback)(void *context),
1089 void *context);
1090int vmbus_disconnect_ring(struct vmbus_channel *channel);
1091
1092extern int vmbus_open(struct vmbus_channel *channel,
1093 u32 send_ringbuffersize,
1094 u32 recv_ringbuffersize,
1095 void *userdata,
1096 u32 userdatalen,
1097 void (*onchannel_callback)(void *context),
1098 void *context);
1099
1100extern void vmbus_close(struct vmbus_channel *channel);
1101
1102extern int vmbus_sendpacket(struct vmbus_channel *channel,
1103 void *buffer,
1104 u32 bufferLen,
1105 u64 requestid,
1106 enum vmbus_packet_type type,
1107 u32 flags);
1108
1109extern int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel,
1110 struct hv_page_buffer pagebuffers[],
1111 u32 pagecount,
1112 void *buffer,
1113 u32 bufferlen,
1114 u64 requestid);
1115
1116extern int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel,
1117 struct vmbus_packet_mpb_array *mpb,
1118 u32 desc_size,
1119 void *buffer,
1120 u32 bufferlen,
1121 u64 requestid);
1122
1123extern int vmbus_establish_gpadl(struct vmbus_channel *channel,
1124 void *kbuffer,
1125 u32 size,
1126 u32 *gpadl_handle);
1127
1128extern int vmbus_teardown_gpadl(struct vmbus_channel *channel,
1129 u32 gpadl_handle);
1130
1131void vmbus_reset_channel_cb(struct vmbus_channel *channel);
1132
1133extern int vmbus_recvpacket(struct vmbus_channel *channel,
1134 void *buffer,
1135 u32 bufferlen,
1136 u32 *buffer_actual_len,
1137 u64 *requestid);
1138
1139extern int vmbus_recvpacket_raw(struct vmbus_channel *channel,
1140 void *buffer,
1141 u32 bufferlen,
1142 u32 *buffer_actual_len,
1143 u64 *requestid);
1144
1145
1146extern void vmbus_ontimer(unsigned long data);
1147
1148
1149struct hv_driver {
1150 const char *name;
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164 bool hvsock;
1165
1166
1167 guid_t dev_type;
1168 const struct hv_vmbus_device_id *id_table;
1169
1170 struct device_driver driver;
1171
1172
1173 struct {
1174 spinlock_t lock;
1175 struct list_head list;
1176 } dynids;
1177
1178 int (*probe)(struct hv_device *, const struct hv_vmbus_device_id *);
1179 int (*remove)(struct hv_device *);
1180 void (*shutdown)(struct hv_device *);
1181
1182 int (*suspend)(struct hv_device *);
1183 int (*resume)(struct hv_device *);
1184
1185};
1186
1187
1188struct hv_device {
1189
1190 guid_t dev_type;
1191
1192
1193 guid_t dev_instance;
1194 u16 vendor_id;
1195 u16 device_id;
1196
1197 struct device device;
1198 char *driver_override;
1199
1200 struct vmbus_channel *channel;
1201 struct kset *channels_kset;
1202
1203
1204 struct dentry *debug_dir;
1205
1206};
1207
1208
1209static inline struct hv_device *device_to_hv_device(struct device *d)
1210{
1211 return container_of(d, struct hv_device, device);
1212}
1213
1214static inline struct hv_driver *drv_to_hv_drv(struct device_driver *d)
1215{
1216 return container_of(d, struct hv_driver, driver);
1217}
1218
1219static inline void hv_set_drvdata(struct hv_device *dev, void *data)
1220{
1221 dev_set_drvdata(&dev->device, data);
1222}
1223
1224static inline void *hv_get_drvdata(struct hv_device *dev)
1225{
1226 return dev_get_drvdata(&dev->device);
1227}
1228
1229struct hv_ring_buffer_debug_info {
1230 u32 current_interrupt_mask;
1231 u32 current_read_index;
1232 u32 current_write_index;
1233 u32 bytes_avail_toread;
1234 u32 bytes_avail_towrite;
1235};
1236
1237
1238int hv_ringbuffer_get_debuginfo(struct hv_ring_buffer_info *ring_info,
1239 struct hv_ring_buffer_debug_info *debug_info);
1240
1241
1242#define vmbus_driver_register(driver) \
1243 __vmbus_driver_register(driver, THIS_MODULE, KBUILD_MODNAME)
1244int __must_check __vmbus_driver_register(struct hv_driver *hv_driver,
1245 struct module *owner,
1246 const char *mod_name);
1247void vmbus_driver_unregister(struct hv_driver *hv_driver);
1248
1249void vmbus_hvsock_device_unregister(struct vmbus_channel *channel);
1250
1251int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
1252 resource_size_t min, resource_size_t max,
1253 resource_size_t size, resource_size_t align,
1254 bool fb_overlap_ok);
1255void vmbus_free_mmio(resource_size_t start, resource_size_t size);
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265#define HV_NIC_GUID \
1266 .guid = GUID_INIT(0xf8615163, 0xdf3e, 0x46c5, 0x91, 0x3f, \
1267 0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e)
1268
1269
1270
1271
1272
1273#define HV_IDE_GUID \
1274 .guid = GUID_INIT(0x32412632, 0x86cb, 0x44a2, 0x9b, 0x5c, \
1275 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5)
1276
1277
1278
1279
1280
1281#define HV_SCSI_GUID \
1282 .guid = GUID_INIT(0xba6163d9, 0x04a1, 0x4d29, 0xb6, 0x05, \
1283 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f)
1284
1285
1286
1287
1288
1289#define HV_SHUTDOWN_GUID \
1290 .guid = GUID_INIT(0x0e0b6031, 0x5213, 0x4934, 0x81, 0x8b, \
1291 0x38, 0xd9, 0x0c, 0xed, 0x39, 0xdb)
1292
1293
1294
1295
1296
1297#define HV_TS_GUID \
1298 .guid = GUID_INIT(0x9527e630, 0xd0ae, 0x497b, 0xad, 0xce, \
1299 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf)
1300
1301
1302
1303
1304
1305#define HV_HEART_BEAT_GUID \
1306 .guid = GUID_INIT(0x57164f39, 0x9115, 0x4e78, 0xab, 0x55, \
1307 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d)
1308
1309
1310
1311
1312
1313#define HV_KVP_GUID \
1314 .guid = GUID_INIT(0xa9a0f4e7, 0x5a45, 0x4d96, 0xb8, 0x27, \
1315 0x8a, 0x84, 0x1e, 0x8c, 0x03, 0xe6)
1316
1317
1318
1319
1320
1321#define HV_DM_GUID \
1322 .guid = GUID_INIT(0x525074dc, 0x8985, 0x46e2, 0x80, 0x57, \
1323 0xa3, 0x07, 0xdc, 0x18, 0xa5, 0x02)
1324
1325
1326
1327
1328
1329#define HV_MOUSE_GUID \
1330 .guid = GUID_INIT(0xcfa8b69e, 0x5b4a, 0x4cc0, 0xb9, 0x8b, \
1331 0x8b, 0xa1, 0xa1, 0xf3, 0xf9, 0x5a)
1332
1333
1334
1335
1336
1337#define HV_KBD_GUID \
1338 .guid = GUID_INIT(0xf912ad6d, 0x2b17, 0x48ea, 0xbd, 0x65, \
1339 0xf9, 0x27, 0xa6, 0x1c, 0x76, 0x84)
1340
1341
1342
1343
1344#define HV_VSS_GUID \
1345 .guid = GUID_INIT(0x35fa2e29, 0xea23, 0x4236, 0x96, 0xae, \
1346 0x3a, 0x6e, 0xba, 0xcb, 0xa4, 0x40)
1347
1348
1349
1350
1351#define HV_SYNTHVID_GUID \
1352 .guid = GUID_INIT(0xda0a7802, 0xe377, 0x4aac, 0x8e, 0x77, \
1353 0x05, 0x58, 0xeb, 0x10, 0x73, 0xf8)
1354
1355
1356
1357
1358
1359#define HV_SYNTHFC_GUID \
1360 .guid = GUID_INIT(0x2f9bcc4a, 0x0069, 0x4af3, 0xb7, 0x6b, \
1361 0x6f, 0xd0, 0xbe, 0x52, 0x8c, 0xda)
1362
1363
1364
1365
1366
1367
1368#define HV_FCOPY_GUID \
1369 .guid = GUID_INIT(0x34d14be3, 0xdee4, 0x41c8, 0x9a, 0xe7, \
1370 0x6b, 0x17, 0x49, 0x77, 0xc1, 0x92)
1371
1372
1373
1374
1375
1376#define HV_ND_GUID \
1377 .guid = GUID_INIT(0x8c2eaf3d, 0x32a7, 0x4b09, 0xab, 0x99, \
1378 0xbd, 0x1f, 0x1c, 0x86, 0xb5, 0x01)
1379
1380
1381
1382
1383
1384
1385#define HV_PCIE_GUID \
1386 .guid = GUID_INIT(0x44c4f61d, 0x4444, 0x4400, 0x9d, 0x52, \
1387 0x80, 0x2e, 0x27, 0xed, 0xe1, 0x9f)
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398#define HV_AVMA1_GUID \
1399 .guid = GUID_INIT(0xf8e65716, 0x3cb3, 0x4a06, 0x9a, 0x60, \
1400 0x18, 0x89, 0xc5, 0xcc, 0xca, 0xb5)
1401
1402#define HV_AVMA2_GUID \
1403 .guid = GUID_INIT(0x3375baf4, 0x9e15, 0x4b30, 0xb7, 0x65, \
1404 0x67, 0xac, 0xb1, 0x0d, 0x60, 0x7b)
1405
1406#define HV_RDV_GUID \
1407 .guid = GUID_INIT(0x276aacf4, 0xac15, 0x426c, 0x98, 0xdd, \
1408 0x75, 0x21, 0xad, 0x3f, 0x01, 0xfe)
1409
1410
1411
1412
1413
1414#define ICMSGTYPE_NEGOTIATE 0
1415#define ICMSGTYPE_HEARTBEAT 1
1416#define ICMSGTYPE_KVPEXCHANGE 2
1417#define ICMSGTYPE_SHUTDOWN 3
1418#define ICMSGTYPE_TIMESYNC 4
1419#define ICMSGTYPE_VSS 5
1420
1421#define ICMSGHDRFLAG_TRANSACTION 1
1422#define ICMSGHDRFLAG_REQUEST 2
1423#define ICMSGHDRFLAG_RESPONSE 4
1424
1425
1426
1427
1428
1429
1430
1431
1432struct hv_util_service {
1433 u8 *recv_buffer;
1434 void *channel;
1435 void (*util_cb)(void *);
1436 int (*util_init)(struct hv_util_service *);
1437 void (*util_deinit)(void);
1438 int (*util_pre_suspend)(void);
1439 int (*util_pre_resume)(void);
1440};
1441
1442struct vmbuspipe_hdr {
1443 u32 flags;
1444 u32 msgsize;
1445} __packed;
1446
1447struct ic_version {
1448 u16 major;
1449 u16 minor;
1450} __packed;
1451
1452struct icmsg_hdr {
1453 struct ic_version icverframe;
1454 u16 icmsgtype;
1455 struct ic_version icvermsg;
1456 u16 icmsgsize;
1457 u32 status;
1458 u8 ictransaction_id;
1459 u8 icflags;
1460 u8 reserved[2];
1461} __packed;
1462
1463struct icmsg_negotiate {
1464 u16 icframe_vercnt;
1465 u16 icmsg_vercnt;
1466 u32 reserved;
1467 struct ic_version icversion_data[1];
1468} __packed;
1469
1470struct shutdown_msg_data {
1471 u32 reason_code;
1472 u32 timeout_seconds;
1473 u32 flags;
1474 u8 display_message[2048];
1475} __packed;
1476
1477struct heartbeat_msg_data {
1478 u64 seq_num;
1479 u32 reserved[8];
1480} __packed;
1481
1482
1483#define ICTIMESYNCFLAG_PROBE 0
1484#define ICTIMESYNCFLAG_SYNC 1
1485#define ICTIMESYNCFLAG_SAMPLE 2
1486
1487#ifdef __x86_64__
1488#define WLTIMEDELTA 116444736000000000L
1489#else
1490#define WLTIMEDELTA 116444736000000000LL
1491#endif
1492
1493struct ictimesync_data {
1494 u64 parenttime;
1495 u64 childtime;
1496 u64 roundtriptime;
1497 u8 flags;
1498} __packed;
1499
1500struct ictimesync_ref_data {
1501 u64 parenttime;
1502 u64 vmreferencetime;
1503 u8 flags;
1504 char leapflags;
1505 char stratum;
1506 u8 reserved[3];
1507} __packed;
1508
1509struct hyperv_service_callback {
1510 u8 msg_type;
1511 char *log_msg;
1512 guid_t data;
1513 struct vmbus_channel *channel;
1514 void (*callback)(void *context);
1515};
1516
1517#define MAX_SRV_VER 0x7ffffff
1518extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf,
1519 const int *fw_version, int fw_vercnt,
1520 const int *srv_version, int srv_vercnt,
1521 int *nego_fw_version, int *nego_srv_version);
1522
1523void hv_process_channel_removal(struct vmbus_channel *channel);
1524
1525void vmbus_setevent(struct vmbus_channel *channel);
1526
1527
1528
1529
1530extern __u32 vmbus_proto_version;
1531
1532int vmbus_send_tl_connect_request(const guid_t *shv_guest_servie_id,
1533 const guid_t *shv_host_servie_id);
1534void vmbus_set_event(struct vmbus_channel *channel);
1535
1536
1537static inline void *
1538hv_get_ring_buffer(const struct hv_ring_buffer_info *ring_info)
1539{
1540 return ring_info->ring_buffer->buffer;
1541}
1542
1543
1544
1545
1546static inline void hv_begin_read(struct hv_ring_buffer_info *rbi)
1547{
1548 rbi->ring_buffer->interrupt_mask = 1;
1549
1550
1551 virt_mb();
1552}
1553
1554
1555
1556
1557static inline u32 hv_end_read(struct hv_ring_buffer_info *rbi)
1558{
1559
1560 rbi->ring_buffer->interrupt_mask = 0;
1561
1562
1563 virt_mb();
1564
1565
1566
1567
1568
1569
1570 return hv_get_bytes_to_read(rbi);
1571}
1572
1573
1574
1575
1576
1577
1578static inline void *hv_pkt_data(const struct vmpacket_descriptor *desc)
1579{
1580 return (void *)((unsigned long)desc + (desc->offset8 << 3));
1581}
1582
1583
1584static inline u32 hv_pkt_datalen(const struct vmpacket_descriptor *desc)
1585{
1586 return (desc->len8 << 3) - (desc->offset8 << 3);
1587}
1588
1589
1590struct vmpacket_descriptor *
1591hv_pkt_iter_first(struct vmbus_channel *channel);
1592
1593struct vmpacket_descriptor *
1594__hv_pkt_iter_next(struct vmbus_channel *channel,
1595 const struct vmpacket_descriptor *pkt);
1596
1597void hv_pkt_iter_close(struct vmbus_channel *channel);
1598
1599
1600
1601
1602
1603static inline struct vmpacket_descriptor *
1604hv_pkt_iter_next(struct vmbus_channel *channel,
1605 const struct vmpacket_descriptor *pkt)
1606{
1607 struct vmpacket_descriptor *nxt;
1608
1609 nxt = __hv_pkt_iter_next(channel, pkt);
1610 if (!nxt)
1611 hv_pkt_iter_close(channel);
1612
1613 return nxt;
1614}
1615
1616#define foreach_vmbus_pkt(pkt, channel) \
1617 for (pkt = hv_pkt_iter_first(channel); pkt; \
1618 pkt = hv_pkt_iter_next(channel, pkt))
1619
1620
1621
1622
1623
1624
1625
1626
1627#define HV_CONFIG_BLOCK_SIZE_MAX 128
1628
1629int hyperv_read_cfg_blk(struct pci_dev *dev, void *buf, unsigned int buf_len,
1630 unsigned int block_id, unsigned int *bytes_returned);
1631int hyperv_write_cfg_blk(struct pci_dev *dev, void *buf, unsigned int len,
1632 unsigned int block_id);
1633int hyperv_reg_block_invalidate(struct pci_dev *dev, void *context,
1634 void (*block_invalidate)(void *context,
1635 u64 block_mask));
1636
1637struct hyperv_pci_block_ops {
1638 int (*read_block)(struct pci_dev *dev, void *buf, unsigned int buf_len,
1639 unsigned int block_id, unsigned int *bytes_returned);
1640 int (*write_block)(struct pci_dev *dev, void *buf, unsigned int len,
1641 unsigned int block_id);
1642 int (*reg_blk_invalidate)(struct pci_dev *dev, void *context,
1643 void (*block_invalidate)(void *context,
1644 u64 block_mask));
1645};
1646
1647extern struct hyperv_pci_block_ops hvpci_block_ops;
1648
1649#endif
1650