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