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