1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * VMware VMCI Driver 4 * 5 * Copyright (C) 2012 VMware, Inc. All rights reserved. 6 */ 7 8 #ifndef _VMW_VMCI_DEF_H_ 9 #define _VMW_VMCI_DEF_H_ 10 11 #include <linux/atomic.h> 12 #include <linux/bits.h> 13 14 /* Register offsets. */ 15 #define VMCI_STATUS_ADDR 0x00 16 #define VMCI_CONTROL_ADDR 0x04 17 #define VMCI_ICR_ADDR 0x08 18 #define VMCI_IMR_ADDR 0x0c 19 #define VMCI_DATA_OUT_ADDR 0x10 20 #define VMCI_DATA_IN_ADDR 0x14 21 #define VMCI_CAPS_ADDR 0x18 22 #define VMCI_RESULT_LOW_ADDR 0x1c 23 #define VMCI_RESULT_HIGH_ADDR 0x20 24 25 /* Max number of devices. */ 26 #define VMCI_MAX_DEVICES 1 27 28 /* Status register bits. */ 29 #define VMCI_STATUS_INT_ON BIT(0) 30 31 /* Control register bits. */ 32 #define VMCI_CONTROL_RESET BIT(0) 33 #define VMCI_CONTROL_INT_ENABLE BIT(1) 34 #define VMCI_CONTROL_INT_DISABLE BIT(2) 35 36 /* Capabilities register bits. */ 37 #define VMCI_CAPS_HYPERCALL BIT(0) 38 #define VMCI_CAPS_GUESTCALL BIT(1) 39 #define VMCI_CAPS_DATAGRAM BIT(2) 40 #define VMCI_CAPS_NOTIFICATIONS BIT(3) 41 #define VMCI_CAPS_PPN64 BIT(4) 42 43 /* Interrupt Cause register bits. */ 44 #define VMCI_ICR_DATAGRAM BIT(0) 45 #define VMCI_ICR_NOTIFICATION BIT(1) 46 47 /* Interrupt Mask register bits. */ 48 #define VMCI_IMR_DATAGRAM BIT(0) 49 #define VMCI_IMR_NOTIFICATION BIT(1) 50 51 /* Maximum MSI/MSI-X interrupt vectors in the device. */ 52 #define VMCI_MAX_INTRS 2 53 54 /* 55 * Supported interrupt vectors. There is one for each ICR value above, 56 * but here they indicate the position in the vector array/message ID. 57 */ 58 enum { 59 VMCI_INTR_DATAGRAM = 0, 60 VMCI_INTR_NOTIFICATION = 1, 61 }; 62 63 /* 64 * A single VMCI device has an upper limit of 128MB on the amount of 65 * memory that can be used for queue pairs. Since each queue pair 66 * consists of at least two pages, the memory limit also dictates the 67 * number of queue pairs a guest can create. 68 */ 69 #define VMCI_MAX_GUEST_QP_MEMORY ((size_t)(128 * 1024 * 1024)) 70 #define VMCI_MAX_GUEST_QP_COUNT (VMCI_MAX_GUEST_QP_MEMORY / PAGE_SIZE / 2) 71 72 /* 73 * There can be at most PAGE_SIZE doorbells since there is one doorbell 74 * per byte in the doorbell bitmap page. 75 */ 76 #define VMCI_MAX_GUEST_DOORBELL_COUNT PAGE_SIZE 77 78 /* 79 * Queues with pre-mapped data pages must be small, so that we don't pin 80 * too much kernel memory (especially on vmkernel). We limit a queuepair to 81 * 32 KB, or 16 KB per queue for symmetrical pairs. 82 */ 83 #define VMCI_MAX_PINNED_QP_MEMORY ((size_t)(32 * 1024)) 84 85 /* 86 * We have a fixed set of resource IDs available in the VMX. 87 * This allows us to have a very simple implementation since we statically 88 * know how many will create datagram handles. If a new caller arrives and 89 * we have run out of slots we can manually increment the maximum size of 90 * available resource IDs. 91 * 92 * VMCI reserved hypervisor datagram resource IDs. 93 */ 94 enum { 95 VMCI_RESOURCES_QUERY = 0, 96 VMCI_GET_CONTEXT_ID = 1, 97 VMCI_SET_NOTIFY_BITMAP = 2, 98 VMCI_DOORBELL_LINK = 3, 99 VMCI_DOORBELL_UNLINK = 4, 100 VMCI_DOORBELL_NOTIFY = 5, 101 /* 102 * VMCI_DATAGRAM_REQUEST_MAP and VMCI_DATAGRAM_REMOVE_MAP are 103 * obsoleted by the removal of VM to VM communication. 104 */ 105 VMCI_DATAGRAM_REQUEST_MAP = 6, 106 VMCI_DATAGRAM_REMOVE_MAP = 7, 107 VMCI_EVENT_SUBSCRIBE = 8, 108 VMCI_EVENT_UNSUBSCRIBE = 9, 109 VMCI_QUEUEPAIR_ALLOC = 10, 110 VMCI_QUEUEPAIR_DETACH = 11, 111 112 /* 113 * VMCI_VSOCK_VMX_LOOKUP was assigned to 12 for Fusion 3.0/3.1, 114 * WS 7.0/7.1 and ESX 4.1 115 */ 116 VMCI_HGFS_TRANSPORT = 13, 117 VMCI_UNITY_PBRPC_REGISTER = 14, 118 VMCI_RPC_PRIVILEGED = 15, 119 VMCI_RPC_UNPRIVILEGED = 16, 120 VMCI_RESOURCE_MAX = 17, 121 }; 122 123 /* 124 * struct vmci_handle - Ownership information structure 125 * @context: The VMX context ID. 126 * @resource: The resource ID (used for locating in resource hash). 127 * 128 * The vmci_handle structure is used to track resources used within 129 * vmw_vmci. 130 */ 131 struct vmci_handle { 132 u32 context; 133 u32 resource; 134 }; 135 136 #define vmci_make_handle(_cid, _rid) \ 137 (struct vmci_handle){ .context = _cid, .resource = _rid } 138 139 static inline bool vmci_handle_is_equal(struct vmci_handle h1, 140 struct vmci_handle h2) 141 { 142 return h1.context == h2.context && h1.resource == h2.resource; 143 } 144 145 #define VMCI_INVALID_ID ~0 146 static const struct vmci_handle VMCI_INVALID_HANDLE = { 147 .context = VMCI_INVALID_ID, 148 .resource = VMCI_INVALID_ID 149 }; 150 151 static inline bool vmci_handle_is_invalid(struct vmci_handle h) 152 { 153 return vmci_handle_is_equal(h, VMCI_INVALID_HANDLE); 154 } 155 156 /* 157 * The below defines can be used to send anonymous requests. 158 * This also indicates that no response is expected. 159 */ 160 #define VMCI_ANON_SRC_CONTEXT_ID VMCI_INVALID_ID 161 #define VMCI_ANON_SRC_RESOURCE_ID VMCI_INVALID_ID 162 static const struct vmci_handle __maybe_unused VMCI_ANON_SRC_HANDLE = { 163 .context = VMCI_ANON_SRC_CONTEXT_ID, 164 .resource = VMCI_ANON_SRC_RESOURCE_ID 165 }; 166 167 /* The lowest 16 context ids are reserved for internal use. */ 168 #define VMCI_RESERVED_CID_LIMIT ((u32) 16) 169 170 /* 171 * Hypervisor context id, used for calling into hypervisor 172 * supplied services from the VM. 173 */ 174 #define VMCI_HYPERVISOR_CONTEXT_ID 0 175 176 /* 177 * Well-known context id, a logical context that contains a set of 178 * well-known services. This context ID is now obsolete. 179 */ 180 #define VMCI_WELL_KNOWN_CONTEXT_ID 1 181 182 /* 183 * Context ID used by host endpoints. 184 */ 185 #define VMCI_HOST_CONTEXT_ID 2 186 187 #define VMCI_CONTEXT_IS_VM(_cid) (VMCI_INVALID_ID != (_cid) && \ 188 (_cid) > VMCI_HOST_CONTEXT_ID) 189 190 /* 191 * The VMCI_CONTEXT_RESOURCE_ID is used together with vmci_make_handle to make 192 * handles that refer to a specific context. 193 */ 194 #define VMCI_CONTEXT_RESOURCE_ID 0 195 196 /* 197 * VMCI error codes. 198 */ 199 enum { 200 VMCI_SUCCESS_QUEUEPAIR_ATTACH = 5, 201 VMCI_SUCCESS_QUEUEPAIR_CREATE = 4, 202 VMCI_SUCCESS_LAST_DETACH = 3, 203 VMCI_SUCCESS_ACCESS_GRANTED = 2, 204 VMCI_SUCCESS_ENTRY_DEAD = 1, 205 VMCI_SUCCESS = 0, 206 VMCI_ERROR_INVALID_RESOURCE = (-1), 207 VMCI_ERROR_INVALID_ARGS = (-2), 208 VMCI_ERROR_NO_MEM = (-3), 209 VMCI_ERROR_DATAGRAM_FAILED = (-4), 210 VMCI_ERROR_MORE_DATA = (-5), 211 VMCI_ERROR_NO_MORE_DATAGRAMS = (-6), 212 VMCI_ERROR_NO_ACCESS = (-7), 213 VMCI_ERROR_NO_HANDLE = (-8), 214 VMCI_ERROR_DUPLICATE_ENTRY = (-9), 215 VMCI_ERROR_DST_UNREACHABLE = (-10), 216 VMCI_ERROR_PAYLOAD_TOO_LARGE = (-11), 217 VMCI_ERROR_INVALID_PRIV = (-12), 218 VMCI_ERROR_GENERIC = (-13), 219 VMCI_ERROR_PAGE_ALREADY_SHARED = (-14), 220 VMCI_ERROR_CANNOT_SHARE_PAGE = (-15), 221 VMCI_ERROR_CANNOT_UNSHARE_PAGE = (-16), 222 VMCI_ERROR_NO_PROCESS = (-17), 223 VMCI_ERROR_NO_DATAGRAM = (-18), 224 VMCI_ERROR_NO_RESOURCES = (-19), 225 VMCI_ERROR_UNAVAILABLE = (-20), 226 VMCI_ERROR_NOT_FOUND = (-21), 227 VMCI_ERROR_ALREADY_EXISTS = (-22), 228 VMCI_ERROR_NOT_PAGE_ALIGNED = (-23), 229 VMCI_ERROR_INVALID_SIZE = (-24), 230 VMCI_ERROR_REGION_ALREADY_SHARED = (-25), 231 VMCI_ERROR_TIMEOUT = (-26), 232 VMCI_ERROR_DATAGRAM_INCOMPLETE = (-27), 233 VMCI_ERROR_INCORRECT_IRQL = (-28), 234 VMCI_ERROR_EVENT_UNKNOWN = (-29), 235 VMCI_ERROR_OBSOLETE = (-30), 236 VMCI_ERROR_QUEUEPAIR_MISMATCH = (-31), 237 VMCI_ERROR_QUEUEPAIR_NOTSET = (-32), 238 VMCI_ERROR_QUEUEPAIR_NOTOWNER = (-33), 239 VMCI_ERROR_QUEUEPAIR_NOTATTACHED = (-34), 240 VMCI_ERROR_QUEUEPAIR_NOSPACE = (-35), 241 VMCI_ERROR_QUEUEPAIR_NODATA = (-36), 242 VMCI_ERROR_BUSMEM_INVALIDATION = (-37), 243 VMCI_ERROR_MODULE_NOT_LOADED = (-38), 244 VMCI_ERROR_DEVICE_NOT_FOUND = (-39), 245 VMCI_ERROR_QUEUEPAIR_NOT_READY = (-40), 246 VMCI_ERROR_WOULD_BLOCK = (-41), 247 248 /* VMCI clients should return error code within this range */ 249 VMCI_ERROR_CLIENT_MIN = (-500), 250 VMCI_ERROR_CLIENT_MAX = (-550), 251 252 /* Internal error codes. */ 253 VMCI_SHAREDMEM_ERROR_BAD_CONTEXT = (-1000), 254 }; 255 256 /* VMCI reserved events. */ 257 enum { 258 /* Only applicable to guest endpoints */ 259 VMCI_EVENT_CTX_ID_UPDATE = 0, 260 261 /* Applicable to guest and host */ 262 VMCI_EVENT_CTX_REMOVED = 1, 263 264 /* Only applicable to guest endpoints */ 265 VMCI_EVENT_QP_RESUMED = 2, 266 267 /* Applicable to guest and host */ 268 VMCI_EVENT_QP_PEER_ATTACH = 3, 269 270 /* Applicable to guest and host */ 271 VMCI_EVENT_QP_PEER_DETACH = 4, 272 273 /* 274 * Applicable to VMX and vmk. On vmk, 275 * this event has the Context payload type. 276 */ 277 VMCI_EVENT_MEM_ACCESS_ON = 5, 278 279 /* 280 * Applicable to VMX and vmk. Same as 281 * above for the payload type. 282 */ 283 VMCI_EVENT_MEM_ACCESS_OFF = 6, 284 VMCI_EVENT_MAX = 7, 285 }; 286 287 /* 288 * Of the above events, a few are reserved for use in the VMX, and 289 * other endpoints (guest and host kernel) should not use them. For 290 * the rest of the events, we allow both host and guest endpoints to 291 * subscribe to them, to maintain the same API for host and guest 292 * endpoints. 293 */ 294 #define VMCI_EVENT_VALID_VMX(_event) ((_event) == VMCI_EVENT_MEM_ACCESS_ON || \ 295 (_event) == VMCI_EVENT_MEM_ACCESS_OFF) 296 297 #define VMCI_EVENT_VALID(_event) ((_event) < VMCI_EVENT_MAX && \ 298 !VMCI_EVENT_VALID_VMX(_event)) 299 300 /* Reserved guest datagram resource ids. */ 301 #define VMCI_EVENT_HANDLER 0 302 303 /* 304 * VMCI coarse-grained privileges (per context or host 305 * process/endpoint. An entity with the restricted flag is only 306 * allowed to interact with the hypervisor and trusted entities. 307 */ 308 enum { 309 VMCI_NO_PRIVILEGE_FLAGS = 0, 310 VMCI_PRIVILEGE_FLAG_RESTRICTED = 1, 311 VMCI_PRIVILEGE_FLAG_TRUSTED = 2, 312 VMCI_PRIVILEGE_ALL_FLAGS = (VMCI_PRIVILEGE_FLAG_RESTRICTED | 313 VMCI_PRIVILEGE_FLAG_TRUSTED), 314 VMCI_DEFAULT_PROC_PRIVILEGE_FLAGS = VMCI_NO_PRIVILEGE_FLAGS, 315 VMCI_LEAST_PRIVILEGE_FLAGS = VMCI_PRIVILEGE_FLAG_RESTRICTED, 316 VMCI_MAX_PRIVILEGE_FLAGS = VMCI_PRIVILEGE_FLAG_TRUSTED, 317 }; 318 319 /* 0 through VMCI_RESERVED_RESOURCE_ID_MAX are reserved. */ 320 #define VMCI_RESERVED_RESOURCE_ID_MAX 1023 321 322 /* 323 * Driver version. 324 * 325 * Increment major version when you make an incompatible change. 326 * Compatibility goes both ways (old driver with new executable 327 * as well as new driver with old executable). 328 */ 329 330 /* Never change VMCI_VERSION_SHIFT_WIDTH */ 331 #define VMCI_VERSION_SHIFT_WIDTH 16 332 #define VMCI_MAKE_VERSION(_major, _minor) \ 333 ((_major) << VMCI_VERSION_SHIFT_WIDTH | (u16) (_minor)) 334 335 #define VMCI_VERSION_MAJOR(v) ((u32) (v) >> VMCI_VERSION_SHIFT_WIDTH) 336 #define VMCI_VERSION_MINOR(v) ((u16) (v)) 337 338 /* 339 * VMCI_VERSION is always the current version. Subsequently listed 340 * versions are ways of detecting previous versions of the connecting 341 * application (i.e., VMX). 342 * 343 * VMCI_VERSION_NOVMVM: This version removed support for VM to VM 344 * communication. 345 * 346 * VMCI_VERSION_NOTIFY: This version introduced doorbell notification 347 * support. 348 * 349 * VMCI_VERSION_HOSTQP: This version introduced host end point support 350 * for hosted products. 351 * 352 * VMCI_VERSION_PREHOSTQP: This is the version prior to the adoption of 353 * support for host end-points. 354 * 355 * VMCI_VERSION_PREVERS2: This fictional version number is intended to 356 * represent the version of a VMX which doesn't call into the driver 357 * with ioctl VERSION2 and thus doesn't establish its version with the 358 * driver. 359 */ 360 361 #define VMCI_VERSION VMCI_VERSION_NOVMVM 362 #define VMCI_VERSION_NOVMVM VMCI_MAKE_VERSION(11, 0) 363 #define VMCI_VERSION_NOTIFY VMCI_MAKE_VERSION(10, 0) 364 #define VMCI_VERSION_HOSTQP VMCI_MAKE_VERSION(9, 0) 365 #define VMCI_VERSION_PREHOSTQP VMCI_MAKE_VERSION(8, 0) 366 #define VMCI_VERSION_PREVERS2 VMCI_MAKE_VERSION(1, 0) 367 368 #define VMCI_SOCKETS_MAKE_VERSION(_p) \ 369 ((((_p)[0] & 0xFF) << 24) | (((_p)[1] & 0xFF) << 16) | ((_p)[2])) 370 371 /* 372 * The VMCI IOCTLs. We use identity code 7, as noted in ioctl-number.h, and 373 * we start at sequence 9f. This gives us the same values that our shipping 374 * products use, starting at 1951, provided we leave out the direction and 375 * structure size. Note that VMMon occupies the block following us, starting 376 * at 2001. 377 */ 378 #define IOCTL_VMCI_VERSION _IO(7, 0x9f) /* 1951 */ 379 #define IOCTL_VMCI_INIT_CONTEXT _IO(7, 0xa0) 380 #define IOCTL_VMCI_QUEUEPAIR_SETVA _IO(7, 0xa4) 381 #define IOCTL_VMCI_NOTIFY_RESOURCE _IO(7, 0xa5) 382 #define IOCTL_VMCI_NOTIFICATIONS_RECEIVE _IO(7, 0xa6) 383 #define IOCTL_VMCI_VERSION2 _IO(7, 0xa7) 384 #define IOCTL_VMCI_QUEUEPAIR_ALLOC _IO(7, 0xa8) 385 #define IOCTL_VMCI_QUEUEPAIR_SETPAGEFILE _IO(7, 0xa9) 386 #define IOCTL_VMCI_QUEUEPAIR_DETACH _IO(7, 0xaa) 387 #define IOCTL_VMCI_DATAGRAM_SEND _IO(7, 0xab) 388 #define IOCTL_VMCI_DATAGRAM_RECEIVE _IO(7, 0xac) 389 #define IOCTL_VMCI_CTX_ADD_NOTIFICATION _IO(7, 0xaf) 390 #define IOCTL_VMCI_CTX_REMOVE_NOTIFICATION _IO(7, 0xb0) 391 #define IOCTL_VMCI_CTX_GET_CPT_STATE _IO(7, 0xb1) 392 #define IOCTL_VMCI_CTX_SET_CPT_STATE _IO(7, 0xb2) 393 #define IOCTL_VMCI_GET_CONTEXT_ID _IO(7, 0xb3) 394 #define IOCTL_VMCI_SOCKETS_VERSION _IO(7, 0xb4) 395 #define IOCTL_VMCI_SOCKETS_GET_AF_VALUE _IO(7, 0xb8) 396 #define IOCTL_VMCI_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) 397 #define IOCTL_VMCI_SET_NOTIFY _IO(7, 0xcb) /* 1995 */ 398 /*IOCTL_VMMON_START _IO(7, 0xd1)*/ /* 2001 */ 399 400 /* 401 * struct vmci_queue_header - VMCI Queue Header information. 402 * 403 * A Queue cannot stand by itself as designed. Each Queue's header 404 * contains a pointer into itself (the producer_tail) and into its peer 405 * (consumer_head). The reason for the separation is one of 406 * accessibility: Each end-point can modify two things: where the next 407 * location to enqueue is within its produce_q (producer_tail); and 408 * where the next dequeue location is in its consume_q (consumer_head). 409 * 410 * An end-point cannot modify the pointers of its peer (guest to 411 * guest; NOTE that in the host both queue headers are mapped r/w). 412 * But, each end-point needs read access to both Queue header 413 * structures in order to determine how much space is used (or left) 414 * in the Queue. This is because for an end-point to know how full 415 * its produce_q is, it needs to use the consumer_head that points into 416 * the produce_q but -that- consumer_head is in the Queue header for 417 * that end-points consume_q. 418 * 419 * Thoroughly confused? Sorry. 420 * 421 * producer_tail: the point to enqueue new entrants. When you approach 422 * a line in a store, for example, you walk up to the tail. 423 * 424 * consumer_head: the point in the queue from which the next element is 425 * dequeued. In other words, who is next in line is he who is at the 426 * head of the line. 427 * 428 * Also, producer_tail points to an empty byte in the Queue, whereas 429 * consumer_head points to a valid byte of data (unless producer_tail == 430 * consumer_head in which case consumer_head does not point to a valid 431 * byte of data). 432 * 433 * For a queue of buffer 'size' bytes, the tail and head pointers will be in 434 * the range [0, size-1]. 435 * 436 * If produce_q_header->producer_tail == consume_q_header->consumer_head 437 * then the produce_q is empty. 438 */ 439 struct vmci_queue_header { 440 /* All fields are 64bit and aligned. */ 441 struct vmci_handle handle; /* Identifier. */ 442 u64 producer_tail; /* Offset in this queue. */ 443 u64 consumer_head; /* Offset in peer queue. */ 444 }; 445 446 /* 447 * struct vmci_datagram - Base struct for vmci datagrams. 448 * @dst: A vmci_handle that tracks the destination of the datagram. 449 * @src: A vmci_handle that tracks the source of the datagram. 450 * @payload_size: The size of the payload. 451 * 452 * vmci_datagram structs are used when sending vmci datagrams. They include 453 * the necessary source and destination information to properly route 454 * the information along with the size of the package. 455 */ 456 struct vmci_datagram { 457 struct vmci_handle dst; 458 struct vmci_handle src; 459 u64 payload_size; 460 }; 461 462 /* 463 * Second flag is for creating a well-known handle instead of a per context 464 * handle. Next flag is for deferring datagram delivery, so that the 465 * datagram callback is invoked in a delayed context (not interrupt context). 466 */ 467 #define VMCI_FLAG_DG_NONE 0 468 #define VMCI_FLAG_WELLKNOWN_DG_HND BIT(0) 469 #define VMCI_FLAG_ANYCID_DG_HND BIT(1) 470 #define VMCI_FLAG_DG_DELAYED_CB BIT(2) 471 472 /* 473 * Maximum supported size of a VMCI datagram for routable datagrams. 474 * Datagrams going to the hypervisor are allowed to be larger. 475 */ 476 #define VMCI_MAX_DG_SIZE (17 * 4096) 477 #define VMCI_MAX_DG_PAYLOAD_SIZE (VMCI_MAX_DG_SIZE - \ 478 sizeof(struct vmci_datagram)) 479 #define VMCI_DG_PAYLOAD(_dg) (void *)((char *)(_dg) + \ 480 sizeof(struct vmci_datagram)) 481 #define VMCI_DG_HEADERSIZE sizeof(struct vmci_datagram) 482 #define VMCI_DG_SIZE(_dg) (VMCI_DG_HEADERSIZE + (size_t)(_dg)->payload_size) 483 #define VMCI_DG_SIZE_ALIGNED(_dg) ((VMCI_DG_SIZE(_dg) + 7) & (~((size_t) 0x7))) 484 #define VMCI_MAX_DATAGRAM_QUEUE_SIZE (VMCI_MAX_DG_SIZE * 2) 485 486 struct vmci_event_payload_qp { 487 struct vmci_handle handle; /* queue_pair handle. */ 488 u32 peer_id; /* Context id of attaching/detaching VM. */ 489 u32 _pad; 490 }; 491 492 /* Flags for VMCI queue_pair API. */ 493 enum { 494 /* Fail alloc if QP not created by peer. */ 495 VMCI_QPFLAG_ATTACH_ONLY = 1 << 0, 496 497 /* Only allow attaches from local context. */ 498 VMCI_QPFLAG_LOCAL = 1 << 1, 499 500 /* Host won't block when guest is quiesced. */ 501 VMCI_QPFLAG_NONBLOCK = 1 << 2, 502 503 /* Pin data pages in ESX. Used with NONBLOCK */ 504 VMCI_QPFLAG_PINNED = 1 << 3, 505 506 /* Update the following flag when adding new flags. */ 507 VMCI_QP_ALL_FLAGS = (VMCI_QPFLAG_ATTACH_ONLY | VMCI_QPFLAG_LOCAL | 508 VMCI_QPFLAG_NONBLOCK | VMCI_QPFLAG_PINNED), 509 510 /* Convenience flags */ 511 VMCI_QP_ASYMM = (VMCI_QPFLAG_NONBLOCK | VMCI_QPFLAG_PINNED), 512 VMCI_QP_ASYMM_PEER = (VMCI_QPFLAG_ATTACH_ONLY | VMCI_QP_ASYMM), 513 }; 514 515 /* 516 * We allow at least 1024 more event datagrams from the hypervisor past the 517 * normally allowed datagrams pending for a given context. We define this 518 * limit on event datagrams from the hypervisor to guard against DoS attack 519 * from a malicious VM which could repeatedly attach to and detach from a queue 520 * pair, causing events to be queued at the destination VM. However, the rate 521 * at which such events can be generated is small since it requires a VM exit 522 * and handling of queue pair attach/detach call at the hypervisor. Event 523 * datagrams may be queued up at the destination VM if it has interrupts 524 * disabled or if it is not draining events for some other reason. 1024 525 * datagrams is a grossly conservative estimate of the time for which 526 * interrupts may be disabled in the destination VM, but at the same time does 527 * not exacerbate the memory pressure problem on the host by much (size of each 528 * event datagram is small). 529 */ 530 #define VMCI_MAX_DATAGRAM_AND_EVENT_QUEUE_SIZE \ 531 (VMCI_MAX_DATAGRAM_QUEUE_SIZE + \ 532 1024 * (sizeof(struct vmci_datagram) + \ 533 sizeof(struct vmci_event_data_max))) 534 535 /* 536 * Struct used for querying, via VMCI_RESOURCES_QUERY, the availability of 537 * hypervisor resources. Struct size is 16 bytes. All fields in struct are 538 * aligned to their natural alignment. 539 */ 540 struct vmci_resource_query_hdr { 541 struct vmci_datagram hdr; 542 u32 num_resources; 543 u32 _padding; 544 }; 545 546 /* 547 * Convenience struct for negotiating vectors. Must match layout of 548 * VMCIResourceQueryHdr minus the struct vmci_datagram header. 549 */ 550 struct vmci_resource_query_msg { 551 u32 num_resources; 552 u32 _padding; 553 u32 resources[1]; 554 }; 555 556 /* 557 * The maximum number of resources that can be queried using 558 * VMCI_RESOURCE_QUERY is 31, as the result is encoded in the lower 31 559 * bits of a positive return value. Negative values are reserved for 560 * errors. 561 */ 562 #define VMCI_RESOURCE_QUERY_MAX_NUM 31 563 564 /* Maximum size for the VMCI_RESOURCE_QUERY request. */ 565 #define VMCI_RESOURCE_QUERY_MAX_SIZE \ 566 (sizeof(struct vmci_resource_query_hdr) + \ 567 sizeof(u32) * VMCI_RESOURCE_QUERY_MAX_NUM) 568 569 /* 570 * Struct used for setting the notification bitmap. All fields in 571 * struct are aligned to their natural alignment. 572 */ 573 struct vmci_notify_bm_set_msg { 574 struct vmci_datagram hdr; 575 union { 576 u32 bitmap_ppn32; 577 u64 bitmap_ppn64; 578 }; 579 }; 580 581 /* 582 * Struct used for linking a doorbell handle with an index in the 583 * notify bitmap. All fields in struct are aligned to their natural 584 * alignment. 585 */ 586 struct vmci_doorbell_link_msg { 587 struct vmci_datagram hdr; 588 struct vmci_handle handle; 589 u64 notify_idx; 590 }; 591 592 /* 593 * Struct used for unlinking a doorbell handle from an index in the 594 * notify bitmap. All fields in struct are aligned to their natural 595 * alignment. 596 */ 597 struct vmci_doorbell_unlink_msg { 598 struct vmci_datagram hdr; 599 struct vmci_handle handle; 600 }; 601 602 /* 603 * Struct used for generating a notification on a doorbell handle. All 604 * fields in struct are aligned to their natural alignment. 605 */ 606 struct vmci_doorbell_notify_msg { 607 struct vmci_datagram hdr; 608 struct vmci_handle handle; 609 }; 610 611 /* 612 * This struct is used to contain data for events. Size of this struct is a 613 * multiple of 8 bytes, and all fields are aligned to their natural alignment. 614 */ 615 struct vmci_event_data { 616 u32 event; /* 4 bytes. */ 617 u32 _pad; 618 /* Event payload is put here. */ 619 }; 620 621 /* 622 * Define the different VMCI_EVENT payload data types here. All structs must 623 * be a multiple of 8 bytes, and fields must be aligned to their natural 624 * alignment. 625 */ 626 struct vmci_event_payld_ctx { 627 u32 context_id; /* 4 bytes. */ 628 u32 _pad; 629 }; 630 631 struct vmci_event_payld_qp { 632 struct vmci_handle handle; /* queue_pair handle. */ 633 u32 peer_id; /* Context id of attaching/detaching VM. */ 634 u32 _pad; 635 }; 636 637 /* 638 * We define the following struct to get the size of the maximum event 639 * data the hypervisor may send to the guest. If adding a new event 640 * payload type above, add it to the following struct too (inside the 641 * union). 642 */ 643 struct vmci_event_data_max { 644 struct vmci_event_data event_data; 645 union { 646 struct vmci_event_payld_ctx context_payload; 647 struct vmci_event_payld_qp qp_payload; 648 } ev_data_payload; 649 }; 650 651 /* 652 * Struct used for VMCI_EVENT_SUBSCRIBE/UNSUBSCRIBE and 653 * VMCI_EVENT_HANDLER messages. Struct size is 32 bytes. All fields 654 * in struct are aligned to their natural alignment. 655 */ 656 struct vmci_event_msg { 657 struct vmci_datagram hdr; 658 659 /* Has event type and payload. */ 660 struct vmci_event_data event_data; 661 662 /* Payload gets put here. */ 663 }; 664 665 /* Event with context payload. */ 666 struct vmci_event_ctx { 667 struct vmci_event_msg msg; 668 struct vmci_event_payld_ctx payload; 669 }; 670 671 /* Event with QP payload. */ 672 struct vmci_event_qp { 673 struct vmci_event_msg msg; 674 struct vmci_event_payld_qp payload; 675 }; 676 677 /* 678 * Structs used for queue_pair alloc and detach messages. We align fields of 679 * these structs to 64bit boundaries. 680 */ 681 struct vmci_qp_alloc_msg { 682 struct vmci_datagram hdr; 683 struct vmci_handle handle; 684 u32 peer; 685 u32 flags; 686 u64 produce_size; 687 u64 consume_size; 688 u64 num_ppns; 689 690 /* List of PPNs placed here. */ 691 }; 692 693 struct vmci_qp_detach_msg { 694 struct vmci_datagram hdr; 695 struct vmci_handle handle; 696 }; 697 698 /* VMCI Doorbell API. */ 699 #define VMCI_FLAG_DELAYED_CB BIT(0) 700 701 typedef void (*vmci_callback) (void *client_data); 702 703 /* 704 * struct vmci_qp - A vmw_vmci queue pair handle. 705 * 706 * This structure is used as a handle to a queue pair created by 707 * VMCI. It is intentionally left opaque to clients. 708 */ 709 struct vmci_qp; 710 711 /* Callback needed for correctly waiting on events. */ 712 typedef int (*vmci_datagram_recv_cb) (void *client_data, 713 struct vmci_datagram *msg); 714 715 /* VMCI Event API. */ 716 typedef void (*vmci_event_cb) (u32 sub_id, const struct vmci_event_data *ed, 717 void *client_data); 718 719 /* 720 * We use the following inline function to access the payload data 721 * associated with an event data. 722 */ 723 static inline const void * 724 vmci_event_data_const_payload(const struct vmci_event_data *ev_data) 725 { 726 return (const char *)ev_data + sizeof(*ev_data); 727 } 728 729 static inline void *vmci_event_data_payload(struct vmci_event_data *ev_data) 730 { 731 return (void *)vmci_event_data_const_payload(ev_data); 732 } 733 734 /* 735 * Helper to read a value from a head or tail pointer. For X86_32, the 736 * pointer is treated as a 32bit value, since the pointer value 737 * never exceeds a 32bit value in this case. Also, doing an 738 * atomic64_read on X86_32 uniprocessor systems may be implemented 739 * as a non locked cmpxchg8b, that may end up overwriting updates done 740 * by the VMCI device to the memory location. On 32bit SMP, the lock 741 * prefix will be used, so correctness isn't an issue, but using a 742 * 64bit operation still adds unnecessary overhead. 743 */ 744 static inline u64 vmci_q_read_pointer(u64 *var) 745 { 746 return READ_ONCE(*(unsigned long *)var); 747 } 748 749 /* 750 * Helper to set the value of a head or tail pointer. For X86_32, the 751 * pointer is treated as a 32bit value, since the pointer value 752 * never exceeds a 32bit value in this case. On 32bit SMP, using a 753 * locked cmpxchg8b adds unnecessary overhead. 754 */ 755 static inline void vmci_q_set_pointer(u64 *var, u64 new_val) 756 { 757 /* XXX buggered on big-endian */ 758 WRITE_ONCE(*(unsigned long *)var, (unsigned long)new_val); 759 } 760 761 /* 762 * Helper to add a given offset to a head or tail pointer. Wraps the 763 * value of the pointer around the max size of the queue. 764 */ 765 static inline void vmci_qp_add_pointer(u64 *var, size_t add, u64 size) 766 { 767 u64 new_val = vmci_q_read_pointer(var); 768 769 if (new_val >= size - add) 770 new_val -= size; 771 772 new_val += add; 773 774 vmci_q_set_pointer(var, new_val); 775 } 776 777 /* 778 * Helper routine to get the Producer Tail from the supplied queue. 779 */ 780 static inline u64 781 vmci_q_header_producer_tail(const struct vmci_queue_header *q_header) 782 { 783 struct vmci_queue_header *qh = (struct vmci_queue_header *)q_header; 784 return vmci_q_read_pointer(&qh->producer_tail); 785 } 786 787 /* 788 * Helper routine to get the Consumer Head from the supplied queue. 789 */ 790 static inline u64 791 vmci_q_header_consumer_head(const struct vmci_queue_header *q_header) 792 { 793 struct vmci_queue_header *qh = (struct vmci_queue_header *)q_header; 794 return vmci_q_read_pointer(&qh->consumer_head); 795 } 796 797 /* 798 * Helper routine to increment the Producer Tail. Fundamentally, 799 * vmci_qp_add_pointer() is used to manipulate the tail itself. 800 */ 801 static inline void 802 vmci_q_header_add_producer_tail(struct vmci_queue_header *q_header, 803 size_t add, 804 u64 queue_size) 805 { 806 vmci_qp_add_pointer(&q_header->producer_tail, add, queue_size); 807 } 808 809 /* 810 * Helper routine to increment the Consumer Head. Fundamentally, 811 * vmci_qp_add_pointer() is used to manipulate the head itself. 812 */ 813 static inline void 814 vmci_q_header_add_consumer_head(struct vmci_queue_header *q_header, 815 size_t add, 816 u64 queue_size) 817 { 818 vmci_qp_add_pointer(&q_header->consumer_head, add, queue_size); 819 } 820 821 /* 822 * Helper routine for getting the head and the tail pointer for a queue. 823 * Both the VMCIQueues are needed to get both the pointers for one queue. 824 */ 825 static inline void 826 vmci_q_header_get_pointers(const struct vmci_queue_header *produce_q_header, 827 const struct vmci_queue_header *consume_q_header, 828 u64 *producer_tail, 829 u64 *consumer_head) 830 { 831 if (producer_tail) 832 *producer_tail = vmci_q_header_producer_tail(produce_q_header); 833 834 if (consumer_head) 835 *consumer_head = vmci_q_header_consumer_head(consume_q_header); 836 } 837 838 static inline void vmci_q_header_init(struct vmci_queue_header *q_header, 839 const struct vmci_handle handle) 840 { 841 q_header->handle = handle; 842 q_header->producer_tail = 0; 843 q_header->consumer_head = 0; 844 } 845 846 /* 847 * Finds available free space in a produce queue to enqueue more 848 * data or reports an error if queue pair corruption is detected. 849 */ 850 static s64 851 vmci_q_header_free_space(const struct vmci_queue_header *produce_q_header, 852 const struct vmci_queue_header *consume_q_header, 853 const u64 produce_q_size) 854 { 855 u64 tail; 856 u64 head; 857 u64 free_space; 858 859 tail = vmci_q_header_producer_tail(produce_q_header); 860 head = vmci_q_header_consumer_head(consume_q_header); 861 862 if (tail >= produce_q_size || head >= produce_q_size) 863 return VMCI_ERROR_INVALID_SIZE; 864 865 /* 866 * Deduct 1 to avoid tail becoming equal to head which causes 867 * ambiguity. If head and tail are equal it means that the 868 * queue is empty. 869 */ 870 if (tail >= head) 871 free_space = produce_q_size - (tail - head) - 1; 872 else 873 free_space = head - tail - 1; 874 875 return free_space; 876 } 877 878 /* 879 * vmci_q_header_free_space() does all the heavy lifting of 880 * determing the number of free bytes in a Queue. This routine, 881 * then subtracts that size from the full size of the Queue so 882 * the caller knows how many bytes are ready to be dequeued. 883 * Results: 884 * On success, available data size in bytes (up to MAX_INT64). 885 * On failure, appropriate error code. 886 */ 887 static inline s64 888 vmci_q_header_buf_ready(const struct vmci_queue_header *consume_q_header, 889 const struct vmci_queue_header *produce_q_header, 890 const u64 consume_q_size) 891 { 892 s64 free_space; 893 894 free_space = vmci_q_header_free_space(consume_q_header, 895 produce_q_header, consume_q_size); 896 if (free_space < VMCI_SUCCESS) 897 return free_space; 898 899 return consume_q_size - free_space - 1; 900 } 901 902 903 #endif /* _VMW_VMCI_DEF_H_ */ 904