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