include/linux/vmw_vmci_defs.h

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