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