1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * 4 * Copyright (c) 2011, Microsoft Corporation. 5 * 6 * Authors: 7 * Haiyang Zhang <haiyangz@microsoft.com> 8 * Hank Janssen <hjanssen@microsoft.com> 9 * K. Y. Srinivasan <kys@microsoft.com> 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/device-id/hv_vmbus.h> 25 #include <linux/interrupt.h> 26 #include <linux/reciprocal_div.h> 27 #include <hyperv/hvhdk.h> 28 29 #define MAX_PAGE_BUFFER_COUNT 32 30 #define MAX_MULTIPAGE_BUFFER_COUNT 32 /* 128K */ 31 32 #pragma pack(push, 1) 33 34 /* 35 * Types for GPADL, decides is how GPADL header is created. 36 * 37 * It doesn't make much difference between BUFFER and RING if PAGE_SIZE is the 38 * same as HV_HYP_PAGE_SIZE. 39 * 40 * If PAGE_SIZE is bigger than HV_HYP_PAGE_SIZE, the headers of ring buffers 41 * will be of PAGE_SIZE, however, only the first HV_HYP_PAGE will be put 42 * into gpadl, therefore the number for HV_HYP_PAGE and the indexes of each 43 * HV_HYP_PAGE will be different between different types of GPADL, for example 44 * if PAGE_SIZE is 64K: 45 * 46 * BUFFER: 47 * 48 * gva: |-- 64k --|-- 64k --| ... | 49 * gpa: | 4k | 4k | ... | 4k | 4k | 4k | ... | 4k | 50 * index: 0 1 2 15 16 17 18 .. 31 32 ... 51 * | | ... | | | ... | ... 52 * v V V V V V 53 * gpadl: | 4k | 4k | ... | 4k | 4k | 4k | ... | 4k | ... | 54 * index: 0 1 2 ... 15 16 17 18 .. 31 32 ... 55 * 56 * RING: 57 * 58 * | header | data | header | data | 59 * gva: |-- 64k --|-- 64k --| ... |-- 64k --|-- 64k --| ... | 60 * gpa: | 4k | .. | 4k | 4k | ... | 4k | ... | 4k | .. | 4k | .. | ... | 61 * index: 0 1 16 17 18 31 ... n n+1 n+16 ... 2n 62 * | / / / | / / 63 * | / / / | / / 64 * | / / ... / ... | / ... / 65 * | / / / | / / 66 * | / / / | / / 67 * V V V V V V v 68 * gpadl: | 4k | 4k | ... | ... | 4k | 4k | ... | 69 * index: 0 1 2 ... 16 ... n-15 n-14 n-13 ... 2n-30 70 */ 71 enum hv_gpadl_type { 72 HV_GPADL_BUFFER, 73 HV_GPADL_RING, 74 HV_GPADL_BUFFER_DECRYPTED 75 }; 76 77 /* Single-page buffer */ 78 struct hv_page_buffer { 79 u32 len; 80 u32 offset; 81 u64 pfn; 82 }; 83 84 /* Multiple-page buffer */ 85 struct hv_multipage_buffer { 86 /* Length and Offset determines the # of pfns in the array */ 87 u32 len; 88 u32 offset; 89 u64 pfn_array[MAX_MULTIPAGE_BUFFER_COUNT]; 90 }; 91 92 /* 93 * Multiple-page buffer array; the pfn array is variable size: 94 * The number of entries in the PFN array is determined by 95 * "len" and "offset". 96 */ 97 struct hv_mpb_array { 98 /* Length and Offset determines the # of pfns in the array */ 99 u32 len; 100 u32 offset; 101 u64 pfn_array[]; 102 }; 103 104 /* 0x18 includes the proprietary packet header */ 105 #define MAX_PAGE_BUFFER_PACKET (0x18 + \ 106 (sizeof(struct hv_page_buffer) * \ 107 MAX_PAGE_BUFFER_COUNT)) 108 #define MAX_MULTIPAGE_BUFFER_PACKET (0x18 + \ 109 sizeof(struct hv_multipage_buffer)) 110 111 112 #pragma pack(pop) 113 114 struct hv_ring_buffer { 115 /* Offset in bytes from the start of ring data below */ 116 u32 write_index; 117 118 /* Offset in bytes from the start of ring data below */ 119 u32 read_index; 120 121 u32 interrupt_mask; 122 123 /* 124 * WS2012/Win8 and later versions of Hyper-V implement interrupt 125 * driven flow management. The feature bit feat_pending_send_sz 126 * is set by the host on the host->guest ring buffer, and by the 127 * guest on the guest->host ring buffer. 128 * 129 * The meaning of the feature bit is a bit complex in that it has 130 * semantics that apply to both ring buffers. If the guest sets 131 * the feature bit in the guest->host ring buffer, the guest is 132 * telling the host that: 133 * 1) It will set the pending_send_sz field in the guest->host ring 134 * buffer when it is waiting for space to become available, and 135 * 2) It will read the pending_send_sz field in the host->guest 136 * ring buffer and interrupt the host when it frees enough space 137 * 138 * Similarly, if the host sets the feature bit in the host->guest 139 * ring buffer, the host is telling the guest that: 140 * 1) It will set the pending_send_sz field in the host->guest ring 141 * buffer when it is waiting for space to become available, and 142 * 2) It will read the pending_send_sz field in the guest->host 143 * ring buffer and interrupt the guest when it frees enough space 144 * 145 * If either the guest or host does not set the feature bit that it 146 * owns, that guest or host must do polling if it encounters a full 147 * ring buffer, and not signal the other end with an interrupt. 148 */ 149 u32 pending_send_sz; 150 u32 reserved1[12]; 151 union { 152 struct { 153 u32 feat_pending_send_sz:1; 154 }; 155 u32 value; 156 } feature_bits; 157 158 /* Pad it to PAGE_SIZE so that data starts on page boundary */ 159 u8 reserved2[PAGE_SIZE - 68]; 160 161 /* 162 * Ring data starts here + RingDataStartOffset 163 * !!! DO NOT place any fields below this !!! 164 */ 165 u8 buffer[]; 166 } __packed; 167 168 169 /* 170 * If the requested ring buffer size is at least 8 times the size of the 171 * header, steal space from the ring buffer for the header. Otherwise, add 172 * space for the header so that is doesn't take too much of the ring buffer 173 * space. 174 * 175 * The factor of 8 is somewhat arbitrary. The goal is to prevent adding a 176 * relatively small header (4 Kbytes on x86) to a large-ish power-of-2 ring 177 * buffer size (such as 128 Kbytes) and so end up making a nearly twice as 178 * large allocation that will be almost half wasted. As a contrasting example, 179 * on ARM64 with 64 Kbyte page size, we don't want to take 64 Kbytes for the 180 * header from a 128 Kbyte allocation, leaving only 64 Kbytes for the ring. 181 * In this latter case, we must add 64 Kbytes for the header and not worry 182 * about what's wasted. 183 */ 184 #define VMBUS_HEADER_ADJ(payload_sz) \ 185 ((payload_sz) >= 8 * sizeof(struct hv_ring_buffer) ? \ 186 0 : sizeof(struct hv_ring_buffer)) 187 188 /* Calculate the proper size of a ringbuffer, it must be page-aligned */ 189 #define VMBUS_RING_SIZE(payload_sz) PAGE_ALIGN(VMBUS_HEADER_ADJ(payload_sz) + \ 190 (payload_sz)) 191 192 struct hv_ring_buffer_info { 193 struct hv_ring_buffer *ring_buffer; 194 u32 ring_size; /* Include the shared header */ 195 struct reciprocal_value ring_size_div10_reciprocal; 196 spinlock_t ring_lock; 197 198 u32 ring_datasize; /* < ring_size */ 199 u32 priv_read_index; 200 /* 201 * The ring buffer mutex lock. This lock prevents the ring buffer from 202 * being freed while the ring buffer is being accessed. 203 */ 204 struct mutex ring_buffer_mutex; 205 206 /* Buffer that holds a copy of an incoming host packet */ 207 void *pkt_buffer; 208 u32 pkt_buffer_size; 209 }; 210 211 212 /* 213 * The indices live in memory shared with the untrusted host, so check a 214 * snapshot of them before using it as an offset or to compute a byte count. 215 */ 216 static inline bool 217 hv_ringbuffer_indices_invalid(const struct hv_ring_buffer_info *rbi, 218 u32 read_loc, u32 write_loc) 219 { 220 return read_loc >= rbi->ring_datasize || 221 write_loc >= rbi->ring_datasize; 222 } 223 224 /* 225 * Byte counts for a caller-supplied snapshot of the indices, so that the 226 * counts and the indices the caller goes on to use describe one state of the 227 * ring. 228 */ 229 static inline u32 230 hv_ringbuffer_avail_write(const struct hv_ring_buffer_info *rbi, 231 u32 read_loc, u32 write_loc) 232 { 233 u32 dsize = rbi->ring_datasize; 234 235 return write_loc >= read_loc ? dsize - (write_loc - read_loc) : 236 read_loc - write_loc; 237 } 238 239 static inline u32 240 hv_ringbuffer_avail_read(const struct hv_ring_buffer_info *rbi, 241 u32 read_loc, u32 write_loc) 242 { 243 return rbi->ring_datasize - 244 hv_ringbuffer_avail_write(rbi, read_loc, write_loc); 245 } 246 247 static inline u32 hv_get_bytes_to_read(const struct hv_ring_buffer_info *rbi) 248 { 249 u32 read_loc, write_loc; 250 251 read_loc = READ_ONCE(rbi->ring_buffer->read_index); 252 write_loc = READ_ONCE(rbi->ring_buffer->write_index); 253 if (unlikely(hv_ringbuffer_indices_invalid(rbi, read_loc, write_loc))) 254 return 0; 255 256 return hv_ringbuffer_avail_read(rbi, read_loc, write_loc); 257 } 258 259 static inline u32 hv_get_bytes_to_write(const struct hv_ring_buffer_info *rbi) 260 { 261 u32 read_loc, write_loc; 262 263 read_loc = READ_ONCE(rbi->ring_buffer->read_index); 264 write_loc = READ_ONCE(rbi->ring_buffer->write_index); 265 if (unlikely(hv_ringbuffer_indices_invalid(rbi, read_loc, write_loc))) 266 return 0; 267 268 return hv_ringbuffer_avail_write(rbi, read_loc, write_loc); 269 } 270 271 static inline u32 hv_get_avail_to_write_percent( 272 const struct hv_ring_buffer_info *rbi) 273 { 274 u32 avail_write = hv_get_bytes_to_write(rbi); 275 276 return reciprocal_divide( 277 (avail_write << 3) + (avail_write << 1), 278 rbi->ring_size_div10_reciprocal); 279 } 280 281 /* 282 * VMBUS version is 32 bit entity broken up into 283 * two 16 bit quantities: major_number. minor_number. 284 * 285 * 0 . 13 (Windows Server 2008) 286 * 1 . 1 (Windows 7, WS2008 R2) 287 * 2 . 4 (Windows 8, WS2012) 288 * 3 . 0 (Windows 8.1, WS2012 R2) 289 * 4 . 0 (Windows 10) 290 * 4 . 1 (Windows 10 RS3) 291 * 5 . 0 (Newer Windows 10) 292 * 5 . 1 (Windows 10 RS4) 293 * 5 . 2 (Windows Server 2019, RS5) 294 * 5 . 3 (Windows Server 2022) 295 * 296 * The WS2008, WIN7, WIN8, and WIN8_1 versions are listed here for 297 * completeness but are no longer supported in the Linux kernel. 298 */ 299 300 #define VMBUS_MAKE_VERSION(MAJ, MIN) ((((u32)MAJ) << 16) | (MIN)) 301 #define VERSION_WS2008 VMBUS_MAKE_VERSION(0, 13) 302 #define VERSION_WIN7 VMBUS_MAKE_VERSION(1, 1) 303 #define VERSION_WIN8 VMBUS_MAKE_VERSION(2, 4) 304 #define VERSION_WIN8_1 VMBUS_MAKE_VERSION(3, 0) 305 #define VERSION_WIN10 VMBUS_MAKE_VERSION(4, 0) 306 #define VERSION_WIN10_V4_1 VMBUS_MAKE_VERSION(4, 1) 307 #define VERSION_WIN10_V5 VMBUS_MAKE_VERSION(5, 0) 308 #define VERSION_WIN10_V5_1 VMBUS_MAKE_VERSION(5, 1) 309 #define VERSION_WIN10_V5_2 VMBUS_MAKE_VERSION(5, 2) 310 #define VERSION_WIN10_V5_3 VMBUS_MAKE_VERSION(5, 3) 311 #define VERSION_WIN10_V6_0 VMBUS_MAKE_VERSION(6, 0) 312 313 /* Make maximum size of pipe payload of 16K */ 314 #define MAX_PIPE_DATA_PAYLOAD (sizeof(u8) * 16384) 315 316 /* Define PipeMode values. */ 317 #define VMBUS_PIPE_TYPE_BYTE 0x00000000 318 #define VMBUS_PIPE_TYPE_MESSAGE 0x00000004 319 320 /* The size of the user defined data buffer for non-pipe offers. */ 321 #define MAX_USER_DEFINED_BYTES 120 322 323 /* The size of the user defined data buffer for pipe offers. */ 324 #define MAX_PIPE_USER_DEFINED_BYTES 116 325 326 /* 327 * At the center of the Channel Management library is the Channel Offer. This 328 * struct contains the fundamental information about an offer. 329 */ 330 struct vmbus_channel_offer { 331 guid_t if_type; 332 guid_t if_instance; 333 334 /* 335 * These two fields are not currently used. 336 */ 337 u64 reserved1; 338 u64 reserved2; 339 340 u16 chn_flags; 341 u16 mmio_megabytes; /* in bytes * 1024 * 1024 */ 342 343 union { 344 /* Non-pipes: The user has MAX_USER_DEFINED_BYTES bytes. */ 345 struct { 346 unsigned char user_def[MAX_USER_DEFINED_BYTES]; 347 } std; 348 349 /* 350 * Pipes: 351 * The following structure is an integrated pipe protocol, which 352 * is implemented on top of standard user-defined data. Pipe 353 * clients have MAX_PIPE_USER_DEFINED_BYTES left for their own 354 * use. 355 */ 356 struct { 357 u32 pipe_mode; 358 unsigned char user_def[MAX_PIPE_USER_DEFINED_BYTES]; 359 } pipe; 360 } u; 361 /* 362 * The sub_channel_index is defined in Win8: a value of zero means a 363 * primary channel and a value of non-zero means a sub-channel. 364 * 365 * Before Win8, the field is reserved, meaning it's always zero. 366 */ 367 u16 sub_channel_index; 368 u16 reserved3; 369 } __packed; 370 371 /* Server Flags */ 372 #define VMBUS_CHANNEL_ENUMERATE_DEVICE_INTERFACE 0x0001 373 /* 374 * This flag indicates that the channel is offered by the paravisor, and must 375 * use encrypted memory for the channel ring buffer. 376 */ 377 #define VMBUS_CHANNEL_CONFIDENTIAL_RING_BUFFER 0x0002 378 /* 379 * This flag indicates that the channel is offered by the paravisor, and must 380 * use encrypted memory for GPA direct packets and additional GPADLs. 381 */ 382 #define VMBUS_CHANNEL_CONFIDENTIAL_EXTERNAL_MEMORY 0x0004 383 #define VMBUS_CHANNEL_NAMED_PIPE_MODE 0x0010 384 #define VMBUS_CHANNEL_LOOPBACK_OFFER 0x0100 385 #define VMBUS_CHANNEL_PARENT_OFFER 0x0200 386 #define VMBUS_CHANNEL_REQUEST_MONITORED_NOTIFICATION 0x0400 387 #define VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER 0x2000 388 389 struct vmpacket_descriptor { 390 u16 type; 391 u16 offset8; 392 u16 len8; 393 u16 flags; 394 u64 trans_id; 395 } __packed; 396 397 struct vmpacket_header { 398 u32 prev_pkt_start_offset; 399 struct vmpacket_descriptor descriptor; 400 } __packed; 401 402 struct vmtransfer_page_range { 403 u32 byte_count; 404 u32 byte_offset; 405 } __packed; 406 407 struct vmtransfer_page_packet_header { 408 struct vmpacket_descriptor d; 409 u16 xfer_pageset_id; 410 u8 sender_owns_set; 411 u8 reserved; 412 u32 range_cnt; 413 struct vmtransfer_page_range ranges[]; 414 } __packed; 415 416 /* 417 * This structure defines a range in guest physical space that can be made to 418 * look virtually contiguous. 419 */ 420 struct gpa_range { 421 u32 byte_count; 422 u32 byte_offset; 423 u64 pfn_array[]; 424 }; 425 426 /* 427 * This is the format for a GPA-Direct packet, which contains a set of GPA 428 * ranges, in addition to commands and/or data. 429 */ 430 struct vmdata_gpa_direct { 431 struct vmpacket_descriptor d; 432 u32 reserved; 433 u32 range_cnt; 434 struct gpa_range range[1]; 435 } __packed; 436 437 #define VMPACKET_DATA_START_ADDRESS(__packet) \ 438 (void *)(((unsigned char *)__packet) + \ 439 ((struct vmpacket_descriptor)__packet)->offset8 * 8) 440 441 #define VMPACKET_DATA_LENGTH(__packet) \ 442 ((((struct vmpacket_descriptor)__packet)->len8 - \ 443 ((struct vmpacket_descriptor)__packet)->offset8) * 8) 444 445 #define VMPACKET_TRANSFER_MODE(__packet) \ 446 (((struct IMPACT)__packet)->type) 447 448 enum vmbus_packet_type { 449 VM_PKT_INVALID = 0x0, 450 VM_PKT_SYNCH = 0x1, 451 VM_PKT_ADD_XFER_PAGESET = 0x2, 452 VM_PKT_RM_XFER_PAGESET = 0x3, 453 VM_PKT_ESTABLISH_GPADL = 0x4, 454 VM_PKT_TEARDOWN_GPADL = 0x5, 455 VM_PKT_DATA_INBAND = 0x6, 456 VM_PKT_DATA_USING_XFER_PAGES = 0x7, 457 VM_PKT_DATA_USING_GPADL = 0x8, 458 VM_PKT_DATA_USING_GPA_DIRECT = 0x9, 459 VM_PKT_CANCEL_REQUEST = 0xa, 460 VM_PKT_COMP = 0xb, 461 VM_PKT_DATA_USING_ADDITIONAL_PKT = 0xc, 462 VM_PKT_ADDITIONAL_DATA = 0xd 463 }; 464 465 #define VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED 1 466 467 468 /* Version 1 messages */ 469 enum vmbus_channel_message_type { 470 CHANNELMSG_INVALID = 0, 471 CHANNELMSG_OFFERCHANNEL = 1, 472 CHANNELMSG_RESCIND_CHANNELOFFER = 2, 473 CHANNELMSG_REQUESTOFFERS = 3, 474 CHANNELMSG_ALLOFFERS_DELIVERED = 4, 475 CHANNELMSG_OPENCHANNEL = 5, 476 CHANNELMSG_OPENCHANNEL_RESULT = 6, 477 CHANNELMSG_CLOSECHANNEL = 7, 478 CHANNELMSG_GPADL_HEADER = 8, 479 CHANNELMSG_GPADL_BODY = 9, 480 CHANNELMSG_GPADL_CREATED = 10, 481 CHANNELMSG_GPADL_TEARDOWN = 11, 482 CHANNELMSG_GPADL_TORNDOWN = 12, 483 CHANNELMSG_RELID_RELEASED = 13, 484 CHANNELMSG_INITIATE_CONTACT = 14, 485 CHANNELMSG_VERSION_RESPONSE = 15, 486 CHANNELMSG_UNLOAD = 16, 487 CHANNELMSG_UNLOAD_RESPONSE = 17, 488 CHANNELMSG_18 = 18, 489 CHANNELMSG_19 = 19, 490 CHANNELMSG_20 = 20, 491 CHANNELMSG_TL_CONNECT_REQUEST = 21, 492 CHANNELMSG_MODIFYCHANNEL = 22, 493 CHANNELMSG_TL_CONNECT_RESULT = 23, 494 CHANNELMSG_MODIFYCHANNEL_RESPONSE = 24, 495 CHANNELMSG_COUNT 496 }; 497 498 /* Hyper-V supports about 2048 channels, and the RELIDs start with 1. */ 499 #define INVALID_RELID U32_MAX 500 501 struct vmbus_channel_message_header { 502 enum vmbus_channel_message_type msgtype; 503 u32 padding; 504 } __packed; 505 506 /* Query VMBus Version parameters */ 507 struct vmbus_channel_query_vmbus_version { 508 struct vmbus_channel_message_header header; 509 u32 version; 510 } __packed; 511 512 /* VMBus Version Supported parameters */ 513 struct vmbus_channel_version_supported { 514 struct vmbus_channel_message_header header; 515 u8 version_supported; 516 } __packed; 517 518 /* Offer Channel parameters */ 519 struct vmbus_channel_offer_channel { 520 struct vmbus_channel_message_header header; 521 struct vmbus_channel_offer offer; 522 u32 child_relid; 523 u8 monitorid; 524 /* 525 * win7 and beyond splits this field into a bit field. 526 */ 527 u8 monitor_allocated:1; 528 u8 reserved:7; 529 /* 530 * These are new fields added in win7 and later. 531 * Do not access these fields without checking the 532 * negotiated protocol. 533 * 534 * If "is_dedicated_interrupt" is set, we must not set the 535 * associated bit in the channel bitmap while sending the 536 * interrupt to the host. 537 * 538 * connection_id is to be used in signaling the host. 539 */ 540 u16 is_dedicated_interrupt:1; 541 u16 reserved1:15; 542 u32 connection_id; 543 } __packed; 544 545 /* Rescind Offer parameters */ 546 struct vmbus_channel_rescind_offer { 547 struct vmbus_channel_message_header header; 548 u32 child_relid; 549 } __packed; 550 551 /* 552 * Request Offer -- no parameters, SynIC message contains the partition ID 553 * Set Snoop -- no parameters, SynIC message contains the partition ID 554 * Clear Snoop -- no parameters, SynIC message contains the partition ID 555 * All Offers Delivered -- no parameters, SynIC message contains the partition 556 * ID 557 * Flush Client -- no parameters, SynIC message contains the partition ID 558 */ 559 560 /* Open Channel parameters */ 561 struct vmbus_channel_open_channel { 562 struct vmbus_channel_message_header header; 563 564 /* Identifies the specific VMBus channel that is being opened. */ 565 u32 child_relid; 566 567 /* ID making a particular open request at a channel offer unique. */ 568 u32 openid; 569 570 /* GPADL for the channel's ring buffer. */ 571 u32 ringbuffer_gpadlhandle; 572 573 /* 574 * Starting with win8, this field will be used to specify 575 * the target virtual processor on which to deliver the interrupt for 576 * the host to guest communication. 577 * Prior to win8, incoming channel interrupts would only 578 * be delivered on cpu 0. Setting this value to 0 would 579 * preserve the earlier behavior. 580 */ 581 u32 target_vp; 582 583 /* 584 * The upstream ring buffer begins at offset zero in the memory 585 * described by RingBufferGpadlHandle. The downstream ring buffer 586 * follows it at this offset (in pages). 587 */ 588 u32 downstream_ringbuffer_pageoffset; 589 590 /* User-specific data to be passed along to the server endpoint. */ 591 unsigned char userdata[MAX_USER_DEFINED_BYTES]; 592 } __packed; 593 594 /* Open Channel Result parameters */ 595 struct vmbus_channel_open_result { 596 struct vmbus_channel_message_header header; 597 u32 child_relid; 598 u32 openid; 599 u32 status; 600 } __packed; 601 602 /* Modify Channel Result parameters */ 603 struct vmbus_channel_modifychannel_response { 604 struct vmbus_channel_message_header header; 605 u32 child_relid; 606 u32 status; 607 } __packed; 608 609 /* Close channel parameters; */ 610 struct vmbus_channel_close_channel { 611 struct vmbus_channel_message_header header; 612 u32 child_relid; 613 } __packed; 614 615 /* Channel Message GPADL */ 616 #define GPADL_TYPE_RING_BUFFER 1 617 #define GPADL_TYPE_SERVER_SAVE_AREA 2 618 #define GPADL_TYPE_TRANSACTION 8 619 620 /* 621 * The number of PFNs in a GPADL message is defined by the number of 622 * pages that would be spanned by ByteCount and ByteOffset. If the 623 * implied number of PFNs won't fit in this packet, there will be a 624 * follow-up packet that contains more. 625 */ 626 struct vmbus_channel_gpadl_header { 627 struct vmbus_channel_message_header header; 628 u32 child_relid; 629 u32 gpadl; 630 u16 range_buflen; 631 u16 rangecount; 632 struct gpa_range range[]; 633 } __packed; 634 635 /* This is the followup packet that contains more PFNs. */ 636 struct vmbus_channel_gpadl_body { 637 struct vmbus_channel_message_header header; 638 u32 msgnumber; 639 u32 gpadl; 640 u64 pfn[]; 641 } __packed; 642 643 struct vmbus_channel_gpadl_created { 644 struct vmbus_channel_message_header header; 645 u32 child_relid; 646 u32 gpadl; 647 u32 creation_status; 648 } __packed; 649 650 struct vmbus_channel_gpadl_teardown { 651 struct vmbus_channel_message_header header; 652 u32 child_relid; 653 u32 gpadl; 654 } __packed; 655 656 struct vmbus_channel_gpadl_torndown { 657 struct vmbus_channel_message_header header; 658 u32 gpadl; 659 } __packed; 660 661 struct vmbus_channel_relid_released { 662 struct vmbus_channel_message_header header; 663 u32 child_relid; 664 } __packed; 665 666 /* 667 * Used by the paravisor only, means that the encrypted ring buffers and 668 * the encrypted external memory are supported 669 */ 670 #define VMBUS_FEATURE_FLAG_CONFIDENTIAL_CHANNELS 0x10 671 672 struct vmbus_channel_initiate_contact { 673 struct vmbus_channel_message_header header; 674 u32 vmbus_version_requested; 675 u32 target_vcpu; /* The VCPU the host should respond to */ 676 union { 677 u64 interrupt_page; 678 struct { 679 u8 msg_sint; 680 u8 msg_vtl; 681 u8 reserved[2]; 682 u32 feature_flags; /* VMBus version 6.0 */ 683 }; 684 }; 685 u64 monitor_page1; 686 u64 monitor_page2; 687 } __packed; 688 689 /* Hyper-V socket: guest's connect()-ing to host */ 690 struct vmbus_channel_tl_connect_request { 691 struct vmbus_channel_message_header header; 692 guid_t guest_endpoint_id; 693 guid_t host_service_id; 694 } __packed; 695 696 /* Modify Channel parameters, cf. vmbus_send_modifychannel() */ 697 struct vmbus_channel_modifychannel { 698 struct vmbus_channel_message_header header; 699 u32 child_relid; 700 u32 target_vp; 701 } __packed; 702 703 struct vmbus_channel_version_response { 704 struct vmbus_channel_message_header header; 705 u8 version_supported; 706 707 u8 connection_state; 708 u16 padding; 709 710 /* 711 * On new hosts that support VMBus protocol 5.0, we must use 712 * VMBUS_MESSAGE_CONNECTION_ID_4 for the Initiate Contact Message, 713 * and for subsequent messages, we must use the Message Connection ID 714 * field in the host-returned Version Response Message. 715 * 716 * On old hosts, we should always use VMBUS_MESSAGE_CONNECTION_ID (1). 717 */ 718 u32 msg_conn_id; 719 } __packed; 720 721 enum vmbus_channel_state { 722 CHANNEL_OFFER_STATE, 723 CHANNEL_OPENING_STATE, 724 CHANNEL_OPEN_STATE, 725 CHANNEL_OPENED_STATE, 726 }; 727 728 /* 729 * Represents each channel msg on the vmbus connection This is a 730 * variable-size data structure depending on the msg type itself 731 */ 732 struct vmbus_channel_msginfo { 733 /* Bookkeeping stuff */ 734 struct list_head msglistentry; 735 736 /* So far, this is only used to handle gpadl body message */ 737 struct list_head submsglist; 738 739 /* Synchronize the request/response if needed */ 740 struct completion waitevent; 741 struct vmbus_channel *waiting_channel; 742 union { 743 struct vmbus_channel_version_supported version_supported; 744 struct vmbus_channel_open_result open_result; 745 struct vmbus_channel_gpadl_torndown gpadl_torndown; 746 struct vmbus_channel_gpadl_created gpadl_created; 747 struct vmbus_channel_version_response version_response; 748 struct vmbus_channel_modifychannel_response modify_response; 749 } response; 750 751 u32 msgsize; 752 /* 753 * The channel message that goes out on the "wire". 754 * It will contain at minimum the VMBUS_CHANNEL_MESSAGE_HEADER header 755 */ 756 unsigned char msg[]; 757 }; 758 759 enum vmbus_device_type { 760 HV_IDE = 0, 761 HV_SCSI, 762 HV_FC, 763 HV_NIC, 764 HV_ND, 765 HV_PCIE, 766 HV_FB, 767 HV_KBD, 768 HV_MOUSE, 769 HV_KVP, 770 HV_TS, 771 HV_HB, 772 HV_SHUTDOWN, 773 HV_FCOPY, 774 HV_BACKUP, 775 HV_DM, 776 HV_UNKNOWN, 777 }; 778 779 /* 780 * Provides request ids for VMBus. Encapsulates guest memory 781 * addresses and stores the next available slot in req_arr 782 * to generate new ids in constant time. 783 */ 784 struct vmbus_requestor { 785 u64 *req_arr; 786 unsigned long *req_bitmap; /* is a given slot available? */ 787 u32 size; 788 u64 next_request_id; 789 spinlock_t req_lock; /* provides atomicity */ 790 }; 791 792 #define VMBUS_NO_RQSTOR U64_MAX 793 #define VMBUS_RQST_ERROR (U64_MAX - 1) 794 #define VMBUS_RQST_ADDR_ANY U64_MAX 795 /* NetVSC-specific */ 796 #define VMBUS_RQST_ID_NO_RESPONSE (U64_MAX - 2) 797 /* StorVSC-specific */ 798 #define VMBUS_RQST_INIT (U64_MAX - 2) 799 #define VMBUS_RQST_RESET (U64_MAX - 3) 800 801 struct vmbus_device { 802 /* preferred ring buffer size in KB, 0 means no preferred size for this device */ 803 size_t pref_ring_size; 804 u16 dev_type; 805 guid_t guid; 806 bool perf_device; 807 bool allowed_in_isolated; 808 }; 809 810 #define VMBUS_DEFAULT_MAX_PKT_SIZE 4096 811 812 struct vmbus_gpadl { 813 u32 gpadl_handle; 814 u32 size; 815 void *buffer; 816 bool decrypted; 817 }; 818 819 struct vmbus_channel { 820 struct list_head listentry; 821 822 struct hv_device *device_obj; 823 824 enum vmbus_channel_state state; 825 826 struct vmbus_channel_offer_channel offermsg; 827 /* 828 * These are based on the OfferMsg.MonitorId. 829 * Save it here for easy access. 830 */ 831 u8 monitor_grp; 832 u8 monitor_bit; 833 834 bool rescind; /* got rescind msg */ 835 bool rescind_ref; /* got rescind msg, got channel reference */ 836 struct completion rescind_event; 837 838 struct vmbus_gpadl ringbuffer_gpadlhandle; 839 840 /* Allocated memory for ring buffer */ 841 struct page *ringbuffer_page; 842 u32 ringbuffer_pagecount; 843 u32 ringbuffer_send_offset; 844 struct hv_ring_buffer_info outbound; /* send to parent */ 845 struct hv_ring_buffer_info inbound; /* receive from parent */ 846 847 struct vmbus_channel_close_channel close_msg; 848 849 /* Statistics */ 850 u64 interrupts; /* Host to Guest interrupts */ 851 u64 sig_events; /* Guest to Host events */ 852 853 /* 854 * Guest to host interrupts caused by the outbound ring buffer changing 855 * from empty to not empty. 856 */ 857 u64 intr_out_empty; 858 859 /* 860 * Indicates that a full outbound ring buffer was encountered. The flag 861 * is set to true when a full outbound ring buffer is encountered and 862 * set to false when a write to the outbound ring buffer is completed. 863 */ 864 bool out_full_flag; 865 866 /* Channel callback's invoked in softirq context */ 867 struct tasklet_struct callback_event; 868 void (*onchannel_callback)(void *context); 869 void *channel_callback_context; 870 871 void (*change_target_cpu_callback)(struct vmbus_channel *channel, 872 u32 old, u32 new); 873 874 /* 875 * Synchronize channel scheduling and channel removal; see the inline 876 * comments in vmbus_chan_sched() and vmbus_reset_channel_cb(). 877 */ 878 spinlock_t sched_lock; 879 880 /* 881 * A channel can be marked for one of three modes of reading: 882 * BATCHED - callback called from taslket and should read 883 * channel until empty. Interrupts from the host 884 * are masked while read is in process (default). 885 * DIRECT - callback called from tasklet (softirq). 886 * ISR - callback called in interrupt context and must 887 * invoke its own deferred processing. 888 * Host interrupts are disabled and must be re-enabled 889 * when ring is empty. 890 */ 891 enum hv_callback_mode { 892 HV_CALL_BATCHED, 893 HV_CALL_DIRECT, 894 HV_CALL_ISR 895 } callback_mode; 896 897 bool is_dedicated_interrupt; 898 u64 sig_event; 899 900 /* 901 * Starting with win8, this field will be used to specify the 902 * target CPU on which to deliver the interrupt for the host 903 * to guest communication. 904 * 905 * Prior to win8, incoming channel interrupts would only be 906 * delivered on CPU 0. Setting this value to 0 would preserve 907 * the earlier behavior. 908 */ 909 u32 target_cpu; 910 /* 911 * Support for sub-channels. For high performance devices, 912 * it will be useful to have multiple sub-channels to support 913 * a scalable communication infrastructure with the host. 914 * The support for sub-channels is implemented as an extension 915 * to the current infrastructure. 916 * The initial offer is considered the primary channel and this 917 * offer message will indicate if the host supports sub-channels. 918 * The guest is free to ask for sub-channels to be offered and can 919 * open these sub-channels as a normal "primary" channel. However, 920 * all sub-channels will have the same type and instance guids as the 921 * primary channel. Requests sent on a given channel will result in a 922 * response on the same channel. 923 */ 924 925 /* 926 * Sub-channel creation callback. This callback will be called in 927 * process context when a sub-channel offer is received from the host. 928 * The guest can open the sub-channel in the context of this callback. 929 */ 930 void (*sc_creation_callback)(struct vmbus_channel *new_sc); 931 932 /* 933 * Channel rescind callback. Some channels (the hvsock ones), need to 934 * register a callback which is invoked in vmbus_onoffer_rescind(). 935 */ 936 void (*chn_rescind_callback)(struct vmbus_channel *channel); 937 938 /* 939 * All Sub-channels of a primary channel are linked here. 940 */ 941 struct list_head sc_list; 942 /* 943 * The primary channel this sub-channel belongs to. 944 * This will be NULL for the primary channel. 945 */ 946 struct vmbus_channel *primary_channel; 947 /* 948 * Support per-channel state for use by vmbus drivers. 949 */ 950 void *per_channel_state; 951 952 /* 953 * Defer freeing channel until after all cpu's have 954 * gone through grace period. 955 */ 956 struct rcu_head rcu; 957 958 /* 959 * For sysfs per-channel properties. 960 */ 961 struct kobject kobj; 962 963 /* 964 * For performance critical channels (storage, networking 965 * etc,), Hyper-V has a mechanism to enhance the throughput 966 * at the expense of latency: 967 * When the host is to be signaled, we just set a bit in a shared page 968 * and this bit will be inspected by the hypervisor within a certain 969 * window and if the bit is set, the host will be signaled. The window 970 * of time is the monitor latency - currently around 100 usecs. This 971 * mechanism improves throughput by: 972 * 973 * A) Making the host more efficient - each time it wakes up, 974 * potentially it will process more number of packets. The 975 * monitor latency allows a batch to build up. 976 * B) By deferring the hypercall to signal, we will also minimize 977 * the interrupts. 978 * 979 * Clearly, these optimizations improve throughput at the expense of 980 * latency. Furthermore, since the channel is shared for both 981 * control and data messages, control messages currently suffer 982 * unnecessary latency adversely impacting performance and boot 983 * time. To fix this issue, permit tagging the channel as being 984 * in "low latency" mode. In this mode, we will bypass the monitor 985 * mechanism. 986 */ 987 bool low_latency; 988 989 bool probe_done; 990 991 /* 992 * Cache the device ID here for easy access; this is useful, in 993 * particular, in situations where the channel's device_obj has 994 * not been allocated/initialized yet. 995 */ 996 u16 device_id; 997 998 /* 999 * We must offload the handling of the primary/sub channels 1000 * from the single-threaded vmbus_connection.work_queue to 1001 * two different workqueue, otherwise we can block 1002 * vmbus_connection.work_queue and hang: see vmbus_process_offer(). 1003 */ 1004 struct work_struct add_channel_work; 1005 1006 /* 1007 * Guest to host interrupts caused by the inbound ring buffer changing 1008 * from full to not full while a packet is waiting. 1009 */ 1010 u64 intr_in_full; 1011 1012 /* 1013 * The total number of write operations that encountered a full 1014 * outbound ring buffer. 1015 */ 1016 u64 out_full_total; 1017 1018 /* 1019 * The number of write operations that were the first to encounter a 1020 * full outbound ring buffer. 1021 */ 1022 u64 out_full_first; 1023 1024 /* enabling/disabling fuzz testing on the channel (default is false)*/ 1025 bool fuzz_testing_state; 1026 1027 /* 1028 * Interrupt delay will delay the guest from emptying the ring buffer 1029 * for a specific amount of time. The delay is in microseconds and will 1030 * be between 1 to a maximum of 1000, its default is 0 (no delay). 1031 * The Message delay will delay guest reading on a per message basis 1032 * in microseconds between 1 to 1000 with the default being 0 1033 * (no delay). 1034 */ 1035 u32 fuzz_testing_interrupt_delay; 1036 u32 fuzz_testing_message_delay; 1037 1038 /* callback to generate a request ID from a request address */ 1039 u64 (*next_request_id_callback)(struct vmbus_channel *channel, u64 rqst_addr); 1040 /* callback to retrieve a request address from a request ID */ 1041 u64 (*request_addr_callback)(struct vmbus_channel *channel, u64 rqst_id); 1042 1043 /* request/transaction ids for VMBus */ 1044 struct vmbus_requestor requestor; 1045 u32 rqstor_size; 1046 1047 /* The max size of a packet on this channel */ 1048 u32 max_pkt_size; 1049 1050 /* function to mmap ring buffer memory to the channel's sysfs ring attribute */ 1051 int (*mmap_prepare_ring_buffer)(struct vmbus_channel *channel, struct vm_area_desc *desc); 1052 1053 /* boolean to control visibility of sysfs for ring buffer */ 1054 bool ring_sysfs_visible; 1055 /* The ring buffer is encrypted */ 1056 bool co_ring_buffer; 1057 /* The external memory is encrypted */ 1058 bool co_external_memory; 1059 }; 1060 1061 #define lock_requestor(channel, flags) \ 1062 do { \ 1063 struct vmbus_requestor *rqstor = &(channel)->requestor; \ 1064 \ 1065 spin_lock_irqsave(&rqstor->req_lock, flags); \ 1066 } while (0) 1067 1068 static __always_inline void unlock_requestor(struct vmbus_channel *channel, 1069 unsigned long flags) 1070 { 1071 struct vmbus_requestor *rqstor = &channel->requestor; 1072 1073 spin_unlock_irqrestore(&rqstor->req_lock, flags); 1074 } 1075 1076 u64 vmbus_next_request_id(struct vmbus_channel *channel, u64 rqst_addr); 1077 u64 __vmbus_request_addr_match(struct vmbus_channel *channel, u64 trans_id, 1078 u64 rqst_addr); 1079 u64 vmbus_request_addr_match(struct vmbus_channel *channel, u64 trans_id, 1080 u64 rqst_addr); 1081 u64 vmbus_request_addr(struct vmbus_channel *channel, u64 trans_id); 1082 1083 static inline bool is_co_ring_buffer(const struct vmbus_channel_offer_channel *o) 1084 { 1085 return !!(o->offer.chn_flags & VMBUS_CHANNEL_CONFIDENTIAL_RING_BUFFER); 1086 } 1087 1088 static inline bool is_co_external_memory(const struct vmbus_channel_offer_channel *o) 1089 { 1090 return !!(o->offer.chn_flags & VMBUS_CHANNEL_CONFIDENTIAL_EXTERNAL_MEMORY); 1091 } 1092 1093 static inline bool is_hvsock_offer(const struct vmbus_channel_offer_channel *o) 1094 { 1095 return !!(o->offer.chn_flags & VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER); 1096 } 1097 1098 static inline bool is_hvsock_channel(const struct vmbus_channel *c) 1099 { 1100 return is_hvsock_offer(&c->offermsg); 1101 } 1102 1103 static inline bool is_sub_channel(const struct vmbus_channel *c) 1104 { 1105 return c->offermsg.offer.sub_channel_index != 0; 1106 } 1107 1108 static inline void set_channel_read_mode(struct vmbus_channel *c, 1109 enum hv_callback_mode mode) 1110 { 1111 c->callback_mode = mode; 1112 } 1113 1114 static inline void set_per_channel_state(struct vmbus_channel *c, void *s) 1115 { 1116 c->per_channel_state = s; 1117 } 1118 1119 static inline void *get_per_channel_state(struct vmbus_channel *c) 1120 { 1121 return c->per_channel_state; 1122 } 1123 1124 static inline void set_channel_pending_send_size(struct vmbus_channel *c, 1125 u32 size) 1126 { 1127 unsigned long flags; 1128 1129 if (size) { 1130 spin_lock_irqsave(&c->outbound.ring_lock, flags); 1131 ++c->out_full_total; 1132 1133 if (!c->out_full_flag) { 1134 ++c->out_full_first; 1135 c->out_full_flag = true; 1136 } 1137 spin_unlock_irqrestore(&c->outbound.ring_lock, flags); 1138 } else { 1139 c->out_full_flag = false; 1140 } 1141 1142 c->outbound.ring_buffer->pending_send_sz = size; 1143 } 1144 1145 void vmbus_onmessage(struct vmbus_channel_message_header *hdr); 1146 1147 int vmbus_request_offers(void); 1148 1149 /* 1150 * APIs for managing sub-channels. 1151 */ 1152 1153 void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel, 1154 void (*sc_cr_cb)(struct vmbus_channel *new_sc)); 1155 1156 void vmbus_set_chn_rescind_callback(struct vmbus_channel *channel, 1157 void (*chn_rescind_cb)(struct vmbus_channel *)); 1158 1159 /* The format must be the same as struct vmdata_gpa_direct */ 1160 struct vmbus_channel_packet_page_buffer { 1161 u16 type; 1162 u16 dataoffset8; 1163 u16 length8; 1164 u16 flags; 1165 u64 transactionid; 1166 u32 reserved; 1167 u32 rangecount; 1168 struct hv_page_buffer range[MAX_PAGE_BUFFER_COUNT]; 1169 } __packed; 1170 1171 /* The format must be the same as struct vmdata_gpa_direct */ 1172 struct vmbus_channel_packet_multipage_buffer { 1173 u16 type; 1174 u16 dataoffset8; 1175 u16 length8; 1176 u16 flags; 1177 u64 transactionid; 1178 u32 reserved; 1179 u32 rangecount; /* Always 1 in this case */ 1180 struct hv_multipage_buffer range; 1181 } __packed; 1182 1183 /* The format must be the same as struct vmdata_gpa_direct */ 1184 struct vmbus_packet_mpb_array { 1185 u16 type; 1186 u16 dataoffset8; 1187 u16 length8; 1188 u16 flags; 1189 u64 transactionid; 1190 u32 reserved; 1191 u32 rangecount; /* Always 1 in this case */ 1192 struct hv_mpb_array range; 1193 } __packed; 1194 1195 int vmbus_alloc_ring(struct vmbus_channel *channel, 1196 u32 send_size, u32 recv_size); 1197 void vmbus_free_ring(struct vmbus_channel *channel); 1198 1199 int vmbus_connect_ring(struct vmbus_channel *channel, 1200 void (*onchannel_callback)(void *context), 1201 void *context); 1202 int vmbus_disconnect_ring(struct vmbus_channel *channel); 1203 1204 extern int vmbus_open(struct vmbus_channel *channel, 1205 u32 send_ringbuffersize, 1206 u32 recv_ringbuffersize, 1207 void *userdata, 1208 u32 userdatalen, 1209 void (*onchannel_callback)(void *context), 1210 void *context); 1211 1212 extern void vmbus_close(struct vmbus_channel *channel); 1213 1214 extern int vmbus_sendpacket_getid(struct vmbus_channel *channel, 1215 void *buffer, 1216 u32 bufferLen, 1217 u64 requestid, 1218 u64 *trans_id, 1219 enum vmbus_packet_type type, 1220 u32 flags); 1221 extern int vmbus_sendpacket(struct vmbus_channel *channel, 1222 void *buffer, 1223 u32 bufferLen, 1224 u64 requestid, 1225 enum vmbus_packet_type type, 1226 u32 flags); 1227 1228 extern int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel, 1229 struct vmbus_packet_mpb_array *mpb, 1230 u32 desc_size, 1231 void *buffer, 1232 u32 bufferlen, 1233 u64 requestid); 1234 1235 extern int vmbus_establish_gpadl(struct vmbus_channel *channel, 1236 void *kbuffer, 1237 u32 size, 1238 struct vmbus_gpadl *gpadl); 1239 1240 extern int vmbus_establish_gpadl_caller_decrypted(struct vmbus_channel *channel, 1241 void *kbuffer, 1242 u32 size, 1243 struct vmbus_gpadl *gpadl); 1244 1245 extern int vmbus_teardown_gpadl(struct vmbus_channel *channel, 1246 struct vmbus_gpadl *gpadl); 1247 1248 extern void *vmbus_alloc_buffer(struct vmbus_channel *channel, 1249 u32 size, 1250 struct page ***chunks_out, 1251 u32 *chunk_cnt_out); 1252 1253 extern void vmbus_free_buffer(void *addr, struct page **chunks, u32 chunk_cnt); 1254 1255 void vmbus_reset_channel_cb(struct vmbus_channel *channel); 1256 1257 extern int vmbus_recvpacket(struct vmbus_channel *channel, 1258 void *buffer, 1259 u32 bufferlen, 1260 u32 *buffer_actual_len, 1261 u64 *requestid); 1262 1263 extern int vmbus_recvpacket_raw(struct vmbus_channel *channel, 1264 void *buffer, 1265 u32 bufferlen, 1266 u32 *buffer_actual_len, 1267 u64 *requestid); 1268 1269 /* Base driver object */ 1270 struct hv_driver { 1271 const char *name; 1272 1273 /* 1274 * A hvsock offer, which has a VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER 1275 * channel flag, actually doesn't mean a synthetic device because the 1276 * offer's if_type/if_instance can change for every new hvsock 1277 * connection. 1278 * 1279 * However, to facilitate the notification of new-offer/rescind-offer 1280 * from vmbus driver to hvsock driver, we can handle hvsock offer as 1281 * a special vmbus device, and hence we need the below flag to 1282 * indicate if the driver is the hvsock driver or not: we need to 1283 * specially treat the hvosck offer & driver in vmbus_match(). 1284 */ 1285 bool hvsock; 1286 1287 /* the device type supported by this driver */ 1288 guid_t dev_type; 1289 const struct hv_vmbus_device_id *id_table; 1290 1291 struct device_driver driver; 1292 1293 /* dynamic device GUID's */ 1294 struct { 1295 spinlock_t lock; 1296 struct list_head list; 1297 } dynids; 1298 1299 int (*probe)(struct hv_device *, const struct hv_vmbus_device_id *); 1300 void (*remove)(struct hv_device *dev); 1301 void (*shutdown)(struct hv_device *); 1302 1303 int (*suspend)(struct hv_device *); 1304 int (*resume)(struct hv_device *); 1305 1306 }; 1307 1308 /* Base device object */ 1309 struct hv_device { 1310 /* the device type id of this device */ 1311 guid_t dev_type; 1312 1313 /* the device instance id of this device */ 1314 guid_t dev_instance; 1315 u16 vendor_id; 1316 u16 device_id; 1317 1318 struct device device; 1319 1320 struct vmbus_channel *channel; 1321 struct kset *channels_kset; 1322 struct device_dma_parameters dma_parms; 1323 u64 dma_mask; 1324 1325 /* place holder to keep track of the dir for hv device in debugfs */ 1326 struct dentry *debug_dir; 1327 1328 }; 1329 1330 1331 #define device_to_hv_device(d) container_of_const(d, struct hv_device, device) 1332 #define drv_to_hv_drv(d) container_of_const(d, struct hv_driver, driver) 1333 1334 static inline u32 hv_build_logical_dev_id_prefix(struct hv_device *hdev) 1335 { 1336 return ((u32)hdev->dev_instance.b[5] << 24) | 1337 ((u32)hdev->dev_instance.b[4] << 16) | 1338 ((u32)hdev->dev_instance.b[7] << 8) | 1339 (hdev->dev_instance.b[6] & 0xf8u); 1340 } 1341 1342 static inline void hv_set_drvdata(struct hv_device *dev, void *data) 1343 { 1344 dev_set_drvdata(&dev->device, data); 1345 } 1346 1347 static inline void *hv_get_drvdata(struct hv_device *dev) 1348 { 1349 return dev_get_drvdata(&dev->device); 1350 } 1351 1352 struct device *hv_get_vmbus_root_device(void); 1353 1354 #if IS_ENABLED(CONFIG_HYPERV_VMBUS) 1355 bool hv_vmbus_exists(void); 1356 #else 1357 static inline bool hv_vmbus_exists(void) { return false; } 1358 #endif 1359 1360 struct hv_ring_buffer_debug_info { 1361 u32 current_interrupt_mask; 1362 u32 current_read_index; 1363 u32 current_write_index; 1364 u32 bytes_avail_toread; 1365 u32 bytes_avail_towrite; 1366 }; 1367 1368 1369 int hv_ringbuffer_get_debuginfo(struct hv_ring_buffer_info *ring_info, 1370 struct hv_ring_buffer_debug_info *debug_info); 1371 1372 bool hv_ringbuffer_spinlock_busy(struct vmbus_channel *channel); 1373 1374 /* Vmbus interface */ 1375 #define vmbus_driver_register(driver) \ 1376 __vmbus_driver_register(driver, THIS_MODULE, KBUILD_MODNAME) 1377 int __must_check __vmbus_driver_register(struct hv_driver *hv_driver, 1378 struct module *owner, 1379 const char *mod_name); 1380 void vmbus_driver_unregister(struct hv_driver *hv_driver); 1381 1382 void vmbus_hvsock_device_unregister(struct vmbus_channel *channel); 1383 1384 int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj, 1385 resource_size_t min, resource_size_t max, 1386 resource_size_t size, resource_size_t align, 1387 bool fb_overlap_ok); 1388 void vmbus_free_mmio(resource_size_t start, resource_size_t size); 1389 1390 void vmbus_initiate_unload(bool crash); 1391 void vmbus_set_skip_unload(bool skip); 1392 1393 /* 1394 * GUID definitions of various offer types - services offered to the guest. 1395 */ 1396 1397 /* 1398 * Network GUID 1399 * {f8615163-df3e-46c5-913f-f2d2f965ed0e} 1400 */ 1401 #define HV_NIC_GUID \ 1402 .guid = GUID_INIT(0xf8615163, 0xdf3e, 0x46c5, 0x91, 0x3f, \ 1403 0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e) 1404 1405 /* 1406 * IDE GUID 1407 * {32412632-86cb-44a2-9b5c-50d1417354f5} 1408 */ 1409 #define HV_IDE_GUID \ 1410 .guid = GUID_INIT(0x32412632, 0x86cb, 0x44a2, 0x9b, 0x5c, \ 1411 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5) 1412 1413 /* 1414 * SCSI GUID 1415 * {ba6163d9-04a1-4d29-b605-72e2ffb1dc7f} 1416 */ 1417 #define HV_SCSI_GUID \ 1418 .guid = GUID_INIT(0xba6163d9, 0x04a1, 0x4d29, 0xb6, 0x05, \ 1419 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f) 1420 1421 /* 1422 * Shutdown GUID 1423 * {0e0b6031-5213-4934-818b-38d90ced39db} 1424 */ 1425 #define HV_SHUTDOWN_GUID \ 1426 .guid = GUID_INIT(0x0e0b6031, 0x5213, 0x4934, 0x81, 0x8b, \ 1427 0x38, 0xd9, 0x0c, 0xed, 0x39, 0xdb) 1428 1429 /* 1430 * Time Synch GUID 1431 * {9527E630-D0AE-497b-ADCE-E80AB0175CAF} 1432 */ 1433 #define HV_TS_GUID \ 1434 .guid = GUID_INIT(0x9527e630, 0xd0ae, 0x497b, 0xad, 0xce, \ 1435 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf) 1436 1437 /* 1438 * Heartbeat GUID 1439 * {57164f39-9115-4e78-ab55-382f3bd5422d} 1440 */ 1441 #define HV_HEART_BEAT_GUID \ 1442 .guid = GUID_INIT(0x57164f39, 0x9115, 0x4e78, 0xab, 0x55, \ 1443 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d) 1444 1445 /* 1446 * KVP GUID 1447 * {a9a0f4e7-5a45-4d96-b827-8a841e8c03e6} 1448 */ 1449 #define HV_KVP_GUID \ 1450 .guid = GUID_INIT(0xa9a0f4e7, 0x5a45, 0x4d96, 0xb8, 0x27, \ 1451 0x8a, 0x84, 0x1e, 0x8c, 0x03, 0xe6) 1452 1453 /* 1454 * Dynamic memory GUID 1455 * {525074dc-8985-46e2-8057-a307dc18a502} 1456 */ 1457 #define HV_DM_GUID \ 1458 .guid = GUID_INIT(0x525074dc, 0x8985, 0x46e2, 0x80, 0x57, \ 1459 0xa3, 0x07, 0xdc, 0x18, 0xa5, 0x02) 1460 1461 /* 1462 * Mouse GUID 1463 * {cfa8b69e-5b4a-4cc0-b98b-8ba1a1f3f95a} 1464 */ 1465 #define HV_MOUSE_GUID \ 1466 .guid = GUID_INIT(0xcfa8b69e, 0x5b4a, 0x4cc0, 0xb9, 0x8b, \ 1467 0x8b, 0xa1, 0xa1, 0xf3, 0xf9, 0x5a) 1468 1469 /* 1470 * Keyboard GUID 1471 * {f912ad6d-2b17-48ea-bd65-f927a61c7684} 1472 */ 1473 #define HV_KBD_GUID \ 1474 .guid = GUID_INIT(0xf912ad6d, 0x2b17, 0x48ea, 0xbd, 0x65, \ 1475 0xf9, 0x27, 0xa6, 0x1c, 0x76, 0x84) 1476 1477 /* 1478 * VSS (Backup/Restore) GUID 1479 */ 1480 #define HV_VSS_GUID \ 1481 .guid = GUID_INIT(0x35fa2e29, 0xea23, 0x4236, 0x96, 0xae, \ 1482 0x3a, 0x6e, 0xba, 0xcb, 0xa4, 0x40) 1483 /* 1484 * Synthetic Video GUID 1485 * {DA0A7802-E377-4aac-8E77-0558EB1073F8} 1486 */ 1487 #define HV_SYNTHVID_GUID \ 1488 .guid = GUID_INIT(0xda0a7802, 0xe377, 0x4aac, 0x8e, 0x77, \ 1489 0x05, 0x58, 0xeb, 0x10, 0x73, 0xf8) 1490 1491 /* 1492 * Synthetic FC GUID 1493 * {2f9bcc4a-0069-4af3-b76b-6fd0be528cda} 1494 */ 1495 #define HV_SYNTHFC_GUID \ 1496 .guid = GUID_INIT(0x2f9bcc4a, 0x0069, 0x4af3, 0xb7, 0x6b, \ 1497 0x6f, 0xd0, 0xbe, 0x52, 0x8c, 0xda) 1498 1499 /* 1500 * Guest File Copy Service 1501 * {34D14BE3-DEE4-41c8-9AE7-6B174977C192} 1502 */ 1503 1504 #define HV_FCOPY_GUID \ 1505 .guid = GUID_INIT(0x34d14be3, 0xdee4, 0x41c8, 0x9a, 0xe7, \ 1506 0x6b, 0x17, 0x49, 0x77, 0xc1, 0x92) 1507 1508 /* 1509 * NetworkDirect. This is the guest RDMA service. 1510 * {8c2eaf3d-32a7-4b09-ab99-bd1f1c86b501} 1511 */ 1512 #define HV_ND_GUID \ 1513 .guid = GUID_INIT(0x8c2eaf3d, 0x32a7, 0x4b09, 0xab, 0x99, \ 1514 0xbd, 0x1f, 0x1c, 0x86, 0xb5, 0x01) 1515 1516 /* 1517 * PCI Express Pass Through 1518 * {44C4F61D-4444-4400-9D52-802E27EDE19F} 1519 */ 1520 1521 #define HV_PCIE_GUID \ 1522 .guid = GUID_INIT(0x44c4f61d, 0x4444, 0x4400, 0x9d, 0x52, \ 1523 0x80, 0x2e, 0x27, 0xed, 0xe1, 0x9f) 1524 1525 /* 1526 * Linux doesn't support these 4 devices: the first two are for 1527 * Automatic Virtual Machine Activation, the third is for 1528 * Remote Desktop Virtualization, and the fourth is Initial 1529 * Machine Configuration (IMC) used only by Windows guests. 1530 * {f8e65716-3cb3-4a06-9a60-1889c5cccab5} 1531 * {3375baf4-9e15-4b30-b765-67acb10d607b} 1532 * {276aacf4-ac15-426c-98dd-7521ad3f01fe} 1533 * {c376c1c3-d276-48d2-90a9-c04748072c60} 1534 */ 1535 1536 #define HV_AVMA1_GUID \ 1537 .guid = GUID_INIT(0xf8e65716, 0x3cb3, 0x4a06, 0x9a, 0x60, \ 1538 0x18, 0x89, 0xc5, 0xcc, 0xca, 0xb5) 1539 1540 #define HV_AVMA2_GUID \ 1541 .guid = GUID_INIT(0x3375baf4, 0x9e15, 0x4b30, 0xb7, 0x65, \ 1542 0x67, 0xac, 0xb1, 0x0d, 0x60, 0x7b) 1543 1544 #define HV_RDV_GUID \ 1545 .guid = GUID_INIT(0x276aacf4, 0xac15, 0x426c, 0x98, 0xdd, \ 1546 0x75, 0x21, 0xad, 0x3f, 0x01, 0xfe) 1547 1548 #define HV_IMC_GUID \ 1549 .guid = GUID_INIT(0xc376c1c3, 0xd276, 0x48d2, 0x90, 0xa9, \ 1550 0xc0, 0x47, 0x48, 0x07, 0x2c, 0x60) 1551 1552 /* 1553 * Common header for Hyper-V ICs 1554 */ 1555 1556 #define ICMSGTYPE_NEGOTIATE 0 1557 #define ICMSGTYPE_HEARTBEAT 1 1558 #define ICMSGTYPE_KVPEXCHANGE 2 1559 #define ICMSGTYPE_SHUTDOWN 3 1560 #define ICMSGTYPE_TIMESYNC 4 1561 #define ICMSGTYPE_VSS 5 1562 #define ICMSGTYPE_FCOPY 7 1563 1564 #define ICMSGHDRFLAG_TRANSACTION 1 1565 #define ICMSGHDRFLAG_REQUEST 2 1566 #define ICMSGHDRFLAG_RESPONSE 4 1567 1568 1569 /* 1570 * While we want to handle util services as regular devices, 1571 * there is only one instance of each of these services; so 1572 * we statically allocate the service specific state. 1573 */ 1574 1575 struct hv_util_service { 1576 u8 *recv_buffer; 1577 void *channel; 1578 void (*util_cb)(void *); 1579 int (*util_init)(struct hv_util_service *); 1580 int (*util_init_transport)(void); 1581 void (*util_deinit)(void); 1582 int (*util_pre_suspend)(void); 1583 int (*util_pre_resume)(void); 1584 }; 1585 1586 struct vmbuspipe_hdr { 1587 u32 flags; 1588 u32 msgsize; 1589 } __packed; 1590 1591 struct ic_version { 1592 u16 major; 1593 u16 minor; 1594 } __packed; 1595 1596 struct icmsg_hdr { 1597 struct ic_version icverframe; 1598 u16 icmsgtype; 1599 struct ic_version icvermsg; 1600 u16 icmsgsize; 1601 u32 status; 1602 u8 ictransaction_id; 1603 u8 icflags; 1604 u8 reserved[2]; 1605 } __packed; 1606 1607 #define IC_VERSION_NEGOTIATION_MAX_VER_COUNT 100 1608 #define ICMSG_HDR (sizeof(struct vmbuspipe_hdr) + sizeof(struct icmsg_hdr)) 1609 #define ICMSG_NEGOTIATE_PKT_SIZE(icframe_vercnt, icmsg_vercnt) \ 1610 (ICMSG_HDR + sizeof(struct icmsg_negotiate) + \ 1611 (((icframe_vercnt) + (icmsg_vercnt)) * sizeof(struct ic_version))) 1612 1613 struct icmsg_negotiate { 1614 u16 icframe_vercnt; 1615 u16 icmsg_vercnt; 1616 u32 reserved; 1617 struct ic_version icversion_data[]; /* any size array */ 1618 } __packed; 1619 1620 struct shutdown_msg_data { 1621 u32 reason_code; 1622 u32 timeout_seconds; 1623 u32 flags; 1624 u8 display_message[2048]; 1625 } __packed; 1626 1627 struct heartbeat_msg_data { 1628 u64 seq_num; 1629 u32 reserved[8]; 1630 } __packed; 1631 1632 /* Time Sync IC defs */ 1633 #define ICTIMESYNCFLAG_PROBE 0 1634 #define ICTIMESYNCFLAG_SYNC 1 1635 #define ICTIMESYNCFLAG_SAMPLE 2 1636 1637 #ifdef __x86_64__ 1638 #define WLTIMEDELTA 116444736000000000L /* in 100ns unit */ 1639 #else 1640 #define WLTIMEDELTA 116444736000000000LL 1641 #endif 1642 1643 struct ictimesync_data { 1644 u64 parenttime; 1645 u64 childtime; 1646 u64 roundtriptime; 1647 u8 flags; 1648 } __packed; 1649 1650 struct ictimesync_ref_data { 1651 u64 parenttime; 1652 u64 vmreferencetime; 1653 u8 flags; 1654 char leapflags; 1655 char stratum; 1656 u8 reserved[3]; 1657 } __packed; 1658 1659 struct hyperv_service_callback { 1660 u8 msg_type; 1661 char *log_msg; 1662 guid_t data; 1663 struct vmbus_channel *channel; 1664 void (*callback)(void *context); 1665 }; 1666 1667 struct hv_dma_range { 1668 dma_addr_t dma; 1669 u32 mapping_size; 1670 }; 1671 1672 #define MAX_SRV_VER 0x7ffffff 1673 extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf, u32 buflen, 1674 const int *fw_version, int fw_vercnt, 1675 const int *srv_version, int srv_vercnt, 1676 int *nego_fw_version, int *nego_srv_version); 1677 1678 void hv_process_channel_removal(struct vmbus_channel *channel); 1679 1680 void vmbus_setevent(struct vmbus_channel *channel); 1681 /* 1682 * Negotiated version with the Host. 1683 */ 1684 1685 extern __u32 vmbus_proto_version; 1686 1687 int vmbus_send_tl_connect_request(const guid_t *shv_guest_servie_id, 1688 const guid_t *shv_host_servie_id); 1689 int vmbus_send_modifychannel(struct vmbus_channel *channel, u32 target_vp); 1690 void vmbus_set_event(struct vmbus_channel *channel); 1691 int vmbus_channel_set_cpu(struct vmbus_channel *channel, u32 target_cpu); 1692 1693 /* Get the start of the ring buffer. */ 1694 static inline void * 1695 hv_get_ring_buffer(const struct hv_ring_buffer_info *ring_info) 1696 { 1697 return ring_info->ring_buffer->buffer; 1698 } 1699 1700 /* 1701 * Mask off host interrupt callback notifications 1702 */ 1703 static inline void hv_begin_read(struct hv_ring_buffer_info *rbi) 1704 { 1705 rbi->ring_buffer->interrupt_mask = 1; 1706 1707 /* make sure mask update is not reordered */ 1708 virt_mb(); 1709 } 1710 1711 /* 1712 * Re-enable host callback and return number of outstanding bytes 1713 */ 1714 static inline u32 hv_end_read(struct hv_ring_buffer_info *rbi) 1715 { 1716 1717 rbi->ring_buffer->interrupt_mask = 0; 1718 1719 /* make sure mask update is not reordered */ 1720 virt_mb(); 1721 1722 /* 1723 * Now check to see if the ring buffer is still empty. 1724 * If it is not, we raced and we need to process new 1725 * incoming messages. 1726 */ 1727 return hv_get_bytes_to_read(rbi); 1728 } 1729 1730 /* 1731 * An API to support in-place processing of incoming VMBUS packets. 1732 */ 1733 1734 /* Get data payload associated with descriptor */ 1735 static inline void *hv_pkt_data(const struct vmpacket_descriptor *desc) 1736 { 1737 return (void *)((unsigned long)desc + (desc->offset8 << 3)); 1738 } 1739 1740 /* Get data size associated with descriptor */ 1741 static inline u32 hv_pkt_datalen(const struct vmpacket_descriptor *desc) 1742 { 1743 return (desc->len8 << 3) - (desc->offset8 << 3); 1744 } 1745 1746 /* Get packet length associated with descriptor */ 1747 static inline u32 hv_pkt_len(const struct vmpacket_descriptor *desc) 1748 { 1749 return desc->len8 << 3; 1750 } 1751 1752 struct vmpacket_descriptor * 1753 hv_pkt_iter_first(struct vmbus_channel *channel); 1754 1755 struct vmpacket_descriptor * 1756 __hv_pkt_iter_next(struct vmbus_channel *channel, 1757 const struct vmpacket_descriptor *pkt); 1758 1759 void hv_pkt_iter_close(struct vmbus_channel *channel); 1760 1761 static inline struct vmpacket_descriptor * 1762 hv_pkt_iter_next(struct vmbus_channel *channel, 1763 const struct vmpacket_descriptor *pkt) 1764 { 1765 struct vmpacket_descriptor *nxt; 1766 1767 nxt = __hv_pkt_iter_next(channel, pkt); 1768 if (!nxt) 1769 hv_pkt_iter_close(channel); 1770 1771 return nxt; 1772 } 1773 1774 #define foreach_vmbus_pkt(pkt, channel) \ 1775 for (pkt = hv_pkt_iter_first(channel); pkt; \ 1776 pkt = hv_pkt_iter_next(channel, pkt)) 1777 1778 /* 1779 * Interface for passing data between SR-IOV PF and VF drivers. The VF driver 1780 * sends requests to read and write blocks. Each block must be 128 bytes or 1781 * smaller. Optionally, the VF driver can register a callback function which 1782 * will be invoked when the host says that one or more of the first 64 block 1783 * IDs is "invalid" which means that the VF driver should reread them. 1784 */ 1785 #define HV_CONFIG_BLOCK_SIZE_MAX 128 1786 1787 int hyperv_read_cfg_blk(struct pci_dev *dev, void *buf, unsigned int buf_len, 1788 unsigned int block_id, unsigned int *bytes_returned); 1789 int hyperv_write_cfg_blk(struct pci_dev *dev, void *buf, unsigned int len, 1790 unsigned int block_id); 1791 int hyperv_reg_block_invalidate(struct pci_dev *dev, void *context, 1792 void (*block_invalidate)(void *context, 1793 u64 block_mask)); 1794 1795 struct hyperv_pci_block_ops { 1796 int (*read_block)(struct pci_dev *dev, void *buf, unsigned int buf_len, 1797 unsigned int block_id, unsigned int *bytes_returned); 1798 int (*write_block)(struct pci_dev *dev, void *buf, unsigned int len, 1799 unsigned int block_id); 1800 int (*reg_blk_invalidate)(struct pci_dev *dev, void *context, 1801 void (*block_invalidate)(void *context, 1802 u64 block_mask)); 1803 }; 1804 1805 extern struct hyperv_pci_block_ops hvpci_block_ops; 1806 1807 static inline unsigned long virt_to_hvpfn(void *addr) 1808 { 1809 phys_addr_t paddr; 1810 1811 if (is_vmalloc_addr(addr)) 1812 paddr = page_to_phys(vmalloc_to_page(addr)) + 1813 offset_in_page(addr); 1814 else 1815 paddr = __pa(addr); 1816 1817 return paddr >> HV_HYP_PAGE_SHIFT; 1818 } 1819 1820 #define NR_HV_HYP_PAGES_IN_PAGE (PAGE_SIZE / HV_HYP_PAGE_SIZE) 1821 #define offset_in_hvpage(ptr) ((unsigned long)(ptr) & ~HV_HYP_PAGE_MASK) 1822 #define HVPFN_UP(x) (((x) + HV_HYP_PAGE_SIZE-1) >> HV_HYP_PAGE_SHIFT) 1823 #define HVPFN_DOWN(x) ((x) >> HV_HYP_PAGE_SHIFT) 1824 #define page_to_hvpfn(page) (page_to_pfn(page) * NR_HV_HYP_PAGES_IN_PAGE) 1825 1826 #endif /* _HYPERV_H */ 1827