OSCL-LXR linux-6.0.1/​include/​linux/​vmw_vmci_defs.h	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
  * VMware VMCI Driver
  *
  * Copyright (C) 2012 VMware, Inc. All rights reserved.
  */
 
 #ifndef _VMW_VMCI_DEF_H_
 #define _VMW_VMCI_DEF_H_
 
 #include <linux/atomic.h>
 #include <linux/bits.h>
 
 /* Register offsets. */
 #define VMCI_STATUS_ADDR        0x00
 #define VMCI_CONTROL_ADDR       0x04
 #define VMCI_ICR_ADDR           0x08
 #define VMCI_IMR_ADDR           0x0c
 #define VMCI_DATA_OUT_ADDR      0x10
 #define VMCI_DATA_IN_ADDR       0x14
 #define VMCI_CAPS_ADDR          0x18
 #define VMCI_RESULT_LOW_ADDR    0x1c
 #define VMCI_RESULT_HIGH_ADDR   0x20
 #define VMCI_DATA_OUT_LOW_ADDR  0x24
 #define VMCI_DATA_OUT_HIGH_ADDR 0x28
 #define VMCI_DATA_IN_LOW_ADDR   0x2c
 #define VMCI_DATA_IN_HIGH_ADDR  0x30
 #define VMCI_GUEST_PAGE_SHIFT   0x34
 
 /* Max number of devices. */
 #define VMCI_MAX_DEVICES 1
 
 /* Status register bits. */
 #define VMCI_STATUS_INT_ON     BIT(0)
 
 /* Control register bits. */
 #define VMCI_CONTROL_RESET        BIT(0)
 #define VMCI_CONTROL_INT_ENABLE   BIT(1)
 #define VMCI_CONTROL_INT_DISABLE  BIT(2)
 
 /* Capabilities register bits. */
 #define VMCI_CAPS_HYPERCALL     BIT(0)
 #define VMCI_CAPS_GUESTCALL     BIT(1)
 #define VMCI_CAPS_DATAGRAM      BIT(2)
 #define VMCI_CAPS_NOTIFICATIONS BIT(3)
 #define VMCI_CAPS_PPN64         BIT(4)
 #define VMCI_CAPS_DMA_DATAGRAM  BIT(5)
 
 /* Interrupt Cause register bits. */
 #define VMCI_ICR_DATAGRAM      BIT(0)
 #define VMCI_ICR_NOTIFICATION  BIT(1)
 #define VMCI_ICR_DMA_DATAGRAM  BIT(2)
 
 /* Interrupt Mask register bits. */
 #define VMCI_IMR_DATAGRAM      BIT(0)
 #define VMCI_IMR_NOTIFICATION  BIT(1)
 #define VMCI_IMR_DMA_DATAGRAM  BIT(2)
 
 /*
  * Maximum MSI/MSI-X interrupt vectors in the device.
  * If VMCI_CAPS_DMA_DATAGRAM is supported by the device,
  * VMCI_MAX_INTRS_DMA_DATAGRAM vectors are available,
  * otherwise only VMCI_MAX_INTRS_NOTIFICATION.
  */
 #define VMCI_MAX_INTRS_NOTIFICATION 2
 #define VMCI_MAX_INTRS_DMA_DATAGRAM 3
 #define VMCI_MAX_INTRS              VMCI_MAX_INTRS_DMA_DATAGRAM
 
 /*
  * Supported interrupt vectors.  There is one for each ICR value above,
  * but here they indicate the position in the vector array/message ID.
  */
 enum {
     VMCI_INTR_DATAGRAM = 0,
     VMCI_INTR_NOTIFICATION = 1,
     VMCI_INTR_DMA_DATAGRAM = 2,
 };
 
 /*
  * A single VMCI device has an upper limit of 128MB on the amount of
  * memory that can be used for queue pairs. Since each queue pair
  * consists of at least two pages, the memory limit also dictates the
  * number of queue pairs a guest can create.
  */
 #define VMCI_MAX_GUEST_QP_MEMORY ((size_t)(128 * 1024 * 1024))
 #define VMCI_MAX_GUEST_QP_COUNT  (VMCI_MAX_GUEST_QP_MEMORY / PAGE_SIZE / 2)
 
 /*
  * There can be at most PAGE_SIZE doorbells since there is one doorbell
  * per byte in the doorbell bitmap page.
  */
 #define VMCI_MAX_GUEST_DOORBELL_COUNT PAGE_SIZE
 
 /*
  * Queues with pre-mapped data pages must be small, so that we don't pin
  * too much kernel memory (especially on vmkernel).  We limit a queuepair to
  * 32 KB, or 16 KB per queue for symmetrical pairs.
  */
 #define VMCI_MAX_PINNED_QP_MEMORY ((size_t)(32 * 1024))
 
 /*
  * The version of the VMCI device that supports MMIO access to registers
  * requests 256KB for BAR1 whereas the version of VMCI that supports
  * MSI/MSI-X only requests 8KB. The layout of the larger 256KB region is:
  * - the first 128KB are used for MSI/MSI-X.
  * - the following 64KB are used for MMIO register access.
  * - the remaining 64KB are unused.
  */
 #define VMCI_WITH_MMIO_ACCESS_BAR_SIZE ((size_t)(256 * 1024))
 #define VMCI_MMIO_ACCESS_OFFSET        ((size_t)(128 * 1024))
 #define VMCI_MMIO_ACCESS_SIZE          ((size_t)(64 * 1024))
 
 /*
  * For VMCI devices supporting the VMCI_CAPS_DMA_DATAGRAM capability, the
  * sending and receiving of datagrams can be performed using DMA to/from
  * a driver allocated buffer.
  * Sending and receiving will be handled as follows:
  * - when sending datagrams, the driver initializes the buffer where the
  *   data part will refer to the outgoing VMCI datagram, sets the busy flag
  *   to 1 and writes the address of the buffer to VMCI_DATA_OUT_HIGH_ADDR
  *   and VMCI_DATA_OUT_LOW_ADDR. Writing to VMCI_DATA_OUT_LOW_ADDR triggers
  *   the device processing of the buffer. When the device has processed the
  *   buffer, it will write the result value to the buffer and then clear the
  *   busy flag.
  * - when receiving datagrams, the driver initializes the buffer where the
  *   data part will describe the receive buffer, clears the busy flag and
  *   writes the address of the buffer to VMCI_DATA_IN_HIGH_ADDR and
  *   VMCI_DATA_IN_LOW_ADDR. Writing to VMCI_DATA_IN_LOW_ADDR triggers the
  *   device processing of the buffer. The device will copy as many available
  *   datagrams into the buffer as possible, and then sets the busy flag.
  *   When the busy flag is set, the driver will process the datagrams in the
  *   buffer.
  */
 struct vmci_data_in_out_header {
     uint32_t busy;
     uint32_t opcode;
     uint32_t size;
     uint32_t rsvd;
     uint64_t result;
 };
 
 struct vmci_sg_elem {
     uint64_t addr;
     uint64_t size;
 };
 
 /*
  * We have a fixed set of resource IDs available in the VMX.
  * This allows us to have a very simple implementation since we statically
  * know how many will create datagram handles. If a new caller arrives and
  * we have run out of slots we can manually increment the maximum size of
  * available resource IDs.
  *
  * VMCI reserved hypervisor datagram resource IDs.
  */
 enum {
     VMCI_RESOURCES_QUERY = 0,
     VMCI_GET_CONTEXT_ID = 1,
     VMCI_SET_NOTIFY_BITMAP = 2,
     VMCI_DOORBELL_LINK = 3,
     VMCI_DOORBELL_UNLINK = 4,
     VMCI_DOORBELL_NOTIFY = 5,
     /*
      * VMCI_DATAGRAM_REQUEST_MAP and VMCI_DATAGRAM_REMOVE_MAP are
      * obsoleted by the removal of VM to VM communication.
      */
     VMCI_DATAGRAM_REQUEST_MAP = 6,
     VMCI_DATAGRAM_REMOVE_MAP = 7,
     VMCI_EVENT_SUBSCRIBE = 8,
     VMCI_EVENT_UNSUBSCRIBE = 9,
     VMCI_QUEUEPAIR_ALLOC = 10,
     VMCI_QUEUEPAIR_DETACH = 11,
 
     /*
      * VMCI_VSOCK_VMX_LOOKUP was assigned to 12 for Fusion 3.0/3.1,
      * WS 7.0/7.1 and ESX 4.1
      */
     VMCI_HGFS_TRANSPORT = 13,
     VMCI_UNITY_PBRPC_REGISTER = 14,
     VMCI_RPC_PRIVILEGED = 15,
     VMCI_RPC_UNPRIVILEGED = 16,
     VMCI_RESOURCE_MAX = 17,
 };
 
 /*
  * struct vmci_handle - Ownership information structure
  * @context:    The VMX context ID.
  * @resource:   The resource ID (used for locating in resource hash).
  *
  * The vmci_handle structure is used to track resources used within
  * vmw_vmci.
  */
 struct vmci_handle {
     u32 context;
     u32 resource;
 };
 
 #define vmci_make_handle(_cid, _rid) \
     (struct vmci_handle){ .context = _cid, .resource = _rid }
 
 static inline bool vmci_handle_is_equal(struct vmci_handle h1,
                     struct vmci_handle h2)
 {
     return h1.context == h2.context && h1.resource == h2.resource;
 }
 
 #define VMCI_INVALID_ID ~0
 static const struct vmci_handle VMCI_INVALID_HANDLE = {
     .context = VMCI_INVALID_ID,
     .resource = VMCI_INVALID_ID
 };
 
 static inline bool vmci_handle_is_invalid(struct vmci_handle h)
 {
     return vmci_handle_is_equal(h, VMCI_INVALID_HANDLE);
 }
 
 /*
  * The below defines can be used to send anonymous requests.
  * This also indicates that no response is expected.
  */
 #define VMCI_ANON_SRC_CONTEXT_ID   VMCI_INVALID_ID
 #define VMCI_ANON_SRC_RESOURCE_ID  VMCI_INVALID_ID
 static const struct vmci_handle __maybe_unused VMCI_ANON_SRC_HANDLE = {
     .context = VMCI_ANON_SRC_CONTEXT_ID,
     .resource = VMCI_ANON_SRC_RESOURCE_ID
 };
 
 /* The lowest 16 context ids are reserved for internal use. */
 #define VMCI_RESERVED_CID_LIMIT ((u32) 16)
 
 /*
  * Hypervisor context id, used for calling into hypervisor
  * supplied services from the VM.
  */
 #define VMCI_HYPERVISOR_CONTEXT_ID 0
 
 /*
  * Well-known context id, a logical context that contains a set of
  * well-known services. This context ID is now obsolete.
  */
 #define VMCI_WELL_KNOWN_CONTEXT_ID 1
 
 /*
  * Context ID used by host endpoints.
  */
 #define VMCI_HOST_CONTEXT_ID  2
 
 #define VMCI_CONTEXT_IS_VM(_cid) (VMCI_INVALID_ID != (_cid) &&      \
                   (_cid) > VMCI_HOST_CONTEXT_ID)
 
 /*
  * The VMCI_CONTEXT_RESOURCE_ID is used together with vmci_make_handle to make
  * handles that refer to a specific context.
  */
 #define VMCI_CONTEXT_RESOURCE_ID 0
 
 /*
  * VMCI error codes.
  */
 enum {
     VMCI_SUCCESS_QUEUEPAIR_ATTACH   = 5,
     VMCI_SUCCESS_QUEUEPAIR_CREATE   = 4,
     VMCI_SUCCESS_LAST_DETACH    = 3,
     VMCI_SUCCESS_ACCESS_GRANTED = 2,
     VMCI_SUCCESS_ENTRY_DEAD     = 1,
     VMCI_SUCCESS             = 0,
     VMCI_ERROR_INVALID_RESOURCE  = (-1),
     VMCI_ERROR_INVALID_ARGS      = (-2),
     VMCI_ERROR_NO_MEM        = (-3),
     VMCI_ERROR_DATAGRAM_FAILED   = (-4),
     VMCI_ERROR_MORE_DATA         = (-5),
     VMCI_ERROR_NO_MORE_DATAGRAMS     = (-6),
     VMCI_ERROR_NO_ACCESS         = (-7),
     VMCI_ERROR_NO_HANDLE         = (-8),
     VMCI_ERROR_DUPLICATE_ENTRY   = (-9),
     VMCI_ERROR_DST_UNREACHABLE   = (-10),
     VMCI_ERROR_PAYLOAD_TOO_LARGE     = (-11),
     VMCI_ERROR_INVALID_PRIV      = (-12),
     VMCI_ERROR_GENERIC       = (-13),
     VMCI_ERROR_PAGE_ALREADY_SHARED   = (-14),
     VMCI_ERROR_CANNOT_SHARE_PAGE     = (-15),
     VMCI_ERROR_CANNOT_UNSHARE_PAGE   = (-16),
     VMCI_ERROR_NO_PROCESS        = (-17),
     VMCI_ERROR_NO_DATAGRAM       = (-18),
     VMCI_ERROR_NO_RESOURCES      = (-19),
     VMCI_ERROR_UNAVAILABLE       = (-20),
     VMCI_ERROR_NOT_FOUND         = (-21),
     VMCI_ERROR_ALREADY_EXISTS    = (-22),
     VMCI_ERROR_NOT_PAGE_ALIGNED  = (-23),
     VMCI_ERROR_INVALID_SIZE      = (-24),
     VMCI_ERROR_REGION_ALREADY_SHARED = (-25),
     VMCI_ERROR_TIMEOUT       = (-26),
     VMCI_ERROR_DATAGRAM_INCOMPLETE   = (-27),
     VMCI_ERROR_INCORRECT_IRQL    = (-28),
     VMCI_ERROR_EVENT_UNKNOWN     = (-29),
     VMCI_ERROR_OBSOLETE      = (-30),
     VMCI_ERROR_QUEUEPAIR_MISMATCH    = (-31),
     VMCI_ERROR_QUEUEPAIR_NOTSET  = (-32),
     VMCI_ERROR_QUEUEPAIR_NOTOWNER    = (-33),
     VMCI_ERROR_QUEUEPAIR_NOTATTACHED = (-34),
     VMCI_ERROR_QUEUEPAIR_NOSPACE     = (-35),
     VMCI_ERROR_QUEUEPAIR_NODATA  = (-36),
     VMCI_ERROR_BUSMEM_INVALIDATION   = (-37),
     VMCI_ERROR_MODULE_NOT_LOADED     = (-38),
     VMCI_ERROR_DEVICE_NOT_FOUND  = (-39),
     VMCI_ERROR_QUEUEPAIR_NOT_READY   = (-40),
     VMCI_ERROR_WOULD_BLOCK       = (-41),
 
     /* VMCI clients should return error code within this range */
     VMCI_ERROR_CLIENT_MIN        = (-500),
     VMCI_ERROR_CLIENT_MAX        = (-550),
 
     /* Internal error codes. */
     VMCI_SHAREDMEM_ERROR_BAD_CONTEXT = (-1000),
 };
 
 /* VMCI reserved events. */
 enum {
     /* Only applicable to guest endpoints */
     VMCI_EVENT_CTX_ID_UPDATE  = 0,
 
     /* Applicable to guest and host */
     VMCI_EVENT_CTX_REMOVED    = 1,
 
     /* Only applicable to guest endpoints */
     VMCI_EVENT_QP_RESUMED     = 2,
 
     /* Applicable to guest and host */
     VMCI_EVENT_QP_PEER_ATTACH = 3,
 
     /* Applicable to guest and host */
     VMCI_EVENT_QP_PEER_DETACH = 4,
 
     /*
      * Applicable to VMX and vmk.  On vmk,
      * this event has the Context payload type.
      */
     VMCI_EVENT_MEM_ACCESS_ON  = 5,
 
     /*
      * Applicable to VMX and vmk.  Same as
      * above for the payload type.
      */
     VMCI_EVENT_MEM_ACCESS_OFF = 6,
     VMCI_EVENT_MAX        = 7,
 };
 
 /*
  * Of the above events, a few are reserved for use in the VMX, and
  * other endpoints (guest and host kernel) should not use them. For
  * the rest of the events, we allow both host and guest endpoints to
  * subscribe to them, to maintain the same API for host and guest
  * endpoints.
  */
 #define VMCI_EVENT_VALID_VMX(_event) ((_event) == VMCI_EVENT_MEM_ACCESS_ON || \
                       (_event) == VMCI_EVENT_MEM_ACCESS_OFF)
 
 #define VMCI_EVENT_VALID(_event) ((_event) < VMCI_EVENT_MAX &&      \
                   !VMCI_EVENT_VALID_VMX(_event))
 
 /* Reserved guest datagram resource ids. */
 #define VMCI_EVENT_HANDLER 0
 
 /*
  * VMCI coarse-grained privileges (per context or host
  * process/endpoint. An entity with the restricted flag is only
  * allowed to interact with the hypervisor and trusted entities.
  */
 enum {
     VMCI_NO_PRIVILEGE_FLAGS = 0,
     VMCI_PRIVILEGE_FLAG_RESTRICTED = 1,
     VMCI_PRIVILEGE_FLAG_TRUSTED = 2,
     VMCI_PRIVILEGE_ALL_FLAGS = (VMCI_PRIVILEGE_FLAG_RESTRICTED |
                     VMCI_PRIVILEGE_FLAG_TRUSTED),
     VMCI_DEFAULT_PROC_PRIVILEGE_FLAGS = VMCI_NO_PRIVILEGE_FLAGS,
     VMCI_LEAST_PRIVILEGE_FLAGS = VMCI_PRIVILEGE_FLAG_RESTRICTED,
     VMCI_MAX_PRIVILEGE_FLAGS = VMCI_PRIVILEGE_FLAG_TRUSTED,
 };
 
 /* 0 through VMCI_RESERVED_RESOURCE_ID_MAX are reserved. */
 #define VMCI_RESERVED_RESOURCE_ID_MAX 1023
 
 /*
  * Driver version.
  *
  * Increment major version when you make an incompatible change.
  * Compatibility goes both ways (old driver with new executable
  * as well as new driver with old executable).
  */
 
 /* Never change VMCI_VERSION_SHIFT_WIDTH */
 #define VMCI_VERSION_SHIFT_WIDTH 16
 #define VMCI_MAKE_VERSION(_major, _minor)           \
     ((_major) << VMCI_VERSION_SHIFT_WIDTH | (u16) (_minor))
 
 #define VMCI_VERSION_MAJOR(v)  ((u32) (v) >> VMCI_VERSION_SHIFT_WIDTH)
 #define VMCI_VERSION_MINOR(v)  ((u16) (v))
 
 /*
  * VMCI_VERSION is always the current version.  Subsequently listed
  * versions are ways of detecting previous versions of the connecting
  * application (i.e., VMX).
  *
  * VMCI_VERSION_NOVMVM: This version removed support for VM to VM
  * communication.
  *
  * VMCI_VERSION_NOTIFY: This version introduced doorbell notification
  * support.
  *
  * VMCI_VERSION_HOSTQP: This version introduced host end point support
  * for hosted products.
  *
  * VMCI_VERSION_PREHOSTQP: This is the version prior to the adoption of
  * support for host end-points.
  *
  * VMCI_VERSION_PREVERS2: This fictional version number is intended to
  * represent the version of a VMX which doesn't call into the driver
  * with ioctl VERSION2 and thus doesn't establish its version with the
  * driver.
  */
 
 #define VMCI_VERSION                VMCI_VERSION_NOVMVM
 #define VMCI_VERSION_NOVMVM         VMCI_MAKE_VERSION(11, 0)
 #define VMCI_VERSION_NOTIFY         VMCI_MAKE_VERSION(10, 0)
 #define VMCI_VERSION_HOSTQP         VMCI_MAKE_VERSION(9, 0)
 #define VMCI_VERSION_PREHOSTQP      VMCI_MAKE_VERSION(8, 0)
 #define VMCI_VERSION_PREVERS2       VMCI_MAKE_VERSION(1, 0)
 
 #define VMCI_SOCKETS_MAKE_VERSION(_p)                   \
     ((((_p)[0] & 0xFF) << 24) | (((_p)[1] & 0xFF) << 16) | ((_p)[2]))
 
 /*
  * The VMCI IOCTLs.  We use identity code 7, as noted in ioctl-number.h, and
  * we start at sequence 9f.  This gives us the same values that our shipping
  * products use, starting at 1951, provided we leave out the direction and
  * structure size.  Note that VMMon occupies the block following us, starting
  * at 2001.
  */
 #define IOCTL_VMCI_VERSION          _IO(7, 0x9f)    /* 1951 */
 #define IOCTL_VMCI_INIT_CONTEXT         _IO(7, 0xa0)
 #define IOCTL_VMCI_QUEUEPAIR_SETVA      _IO(7, 0xa4)
 #define IOCTL_VMCI_NOTIFY_RESOURCE      _IO(7, 0xa5)
 #define IOCTL_VMCI_NOTIFICATIONS_RECEIVE    _IO(7, 0xa6)
 #define IOCTL_VMCI_VERSION2         _IO(7, 0xa7)
 #define IOCTL_VMCI_QUEUEPAIR_ALLOC      _IO(7, 0xa8)
 #define IOCTL_VMCI_QUEUEPAIR_SETPAGEFILE    _IO(7, 0xa9)
 #define IOCTL_VMCI_QUEUEPAIR_DETACH     _IO(7, 0xaa)
 #define IOCTL_VMCI_DATAGRAM_SEND        _IO(7, 0xab)
 #define IOCTL_VMCI_DATAGRAM_RECEIVE     _IO(7, 0xac)
 #define IOCTL_VMCI_CTX_ADD_NOTIFICATION     _IO(7, 0xaf)
 #define IOCTL_VMCI_CTX_REMOVE_NOTIFICATION  _IO(7, 0xb0)
 #define IOCTL_VMCI_CTX_GET_CPT_STATE        _IO(7, 0xb1)
 #define IOCTL_VMCI_CTX_SET_CPT_STATE        _IO(7, 0xb2)
 #define IOCTL_VMCI_GET_CONTEXT_ID       _IO(7, 0xb3)
 #define IOCTL_VMCI_SOCKETS_VERSION      _IO(7, 0xb4)
 #define IOCTL_VMCI_SOCKETS_GET_AF_VALUE     _IO(7, 0xb8)
 #define IOCTL_VMCI_SOCKETS_GET_LOCAL_CID    _IO(7, 0xb9)
 #define IOCTL_VMCI_SET_NOTIFY           _IO(7, 0xcb)    /* 1995 */
 /*IOCTL_VMMON_START             _IO(7, 0xd1)*/  /* 2001 */
 
 /*
  * struct vmci_queue_header - VMCI Queue Header information.
  *
  * A Queue cannot stand by itself as designed.  Each Queue's header
  * contains a pointer into itself (the producer_tail) and into its peer
  * (consumer_head).  The reason for the separation is one of
  * accessibility: Each end-point can modify two things: where the next
  * location to enqueue is within its produce_q (producer_tail); and
  * where the next dequeue location is in its consume_q (consumer_head).
  *
  * An end-point cannot modify the pointers of its peer (guest to
  * guest; NOTE that in the host both queue headers are mapped r/w).
  * But, each end-point needs read access to both Queue header
  * structures in order to determine how much space is used (or left)
  * in the Queue.  This is because for an end-point to know how full
  * its produce_q is, it needs to use the consumer_head that points into
  * the produce_q but -that- consumer_head is in the Queue header for
  * that end-points consume_q.
  *
  * Thoroughly confused?  Sorry.
  *
  * producer_tail: the point to enqueue new entrants.  When you approach
  * a line in a store, for example, you walk up to the tail.
  *
  * consumer_head: the point in the queue from which the next element is
  * dequeued.  In other words, who is next in line is he who is at the
  * head of the line.
  *
  * Also, producer_tail points to an empty byte in the Queue, whereas
  * consumer_head points to a valid byte of data (unless producer_tail ==
  * consumer_head in which case consumer_head does not point to a valid
  * byte of data).
  *
  * For a queue of buffer 'size' bytes, the tail and head pointers will be in
  * the range [0, size-1].
  *
  * If produce_q_header->producer_tail == consume_q_header->consumer_head
  * then the produce_q is empty.
  */
 struct vmci_queue_header {
     /* All fields are 64bit and aligned. */
     struct vmci_handle handle;  /* Identifier. */
     u64 producer_tail;  /* Offset in this queue. */
     u64 consumer_head;  /* Offset in peer queue. */
 };
 
 /*
  * struct vmci_datagram - Base struct for vmci datagrams.
  * @dst:        A vmci_handle that tracks the destination of the datagram.
  * @src:        A vmci_handle that tracks the source of the datagram.
  * @payload_size:       The size of the payload.
  *
  * vmci_datagram structs are used when sending vmci datagrams.  They include
  * the necessary source and destination information to properly route
  * the information along with the size of the package.
  */
 struct vmci_datagram {
     struct vmci_handle dst;
     struct vmci_handle src;
     u64 payload_size;
 };
 
 /*
  * Second flag is for creating a well-known handle instead of a per context
  * handle.  Next flag is for deferring datagram delivery, so that the
  * datagram callback is invoked in a delayed context (not interrupt context).
  */
 #define VMCI_FLAG_DG_NONE          0
 #define VMCI_FLAG_WELLKNOWN_DG_HND BIT(0)
 #define VMCI_FLAG_ANYCID_DG_HND    BIT(1)
 #define VMCI_FLAG_DG_DELAYED_CB    BIT(2)
 
 /*
  * Maximum supported size of a VMCI datagram for routable datagrams.
  * Datagrams going to the hypervisor are allowed to be larger.
  */
 #define VMCI_MAX_DG_SIZE (17 * 4096)
 #define VMCI_MAX_DG_PAYLOAD_SIZE (VMCI_MAX_DG_SIZE - \
                   sizeof(struct vmci_datagram))
 #define VMCI_DG_PAYLOAD(_dg) (void *)((char *)(_dg) +           \
                       sizeof(struct vmci_datagram))
 #define VMCI_DG_HEADERSIZE sizeof(struct vmci_datagram)
 #define VMCI_DG_SIZE(_dg) (VMCI_DG_HEADERSIZE + (size_t)(_dg)->payload_size)
 #define VMCI_DG_SIZE_ALIGNED(_dg) ((VMCI_DG_SIZE(_dg) + 7) & (~((size_t) 0x7)))
 #define VMCI_MAX_DATAGRAM_QUEUE_SIZE (VMCI_MAX_DG_SIZE * 2)
 
 struct vmci_event_payload_qp {
     struct vmci_handle handle;  /* queue_pair handle. */
     u32 peer_id;            /* Context id of attaching/detaching VM. */
     u32 _pad;
 };
 
 /* Flags for VMCI queue_pair API. */
 enum {
     /* Fail alloc if QP not created by peer. */
     VMCI_QPFLAG_ATTACH_ONLY = 1 << 0,
 
     /* Only allow attaches from local context. */
     VMCI_QPFLAG_LOCAL = 1 << 1,
 
     /* Host won't block when guest is quiesced. */
     VMCI_QPFLAG_NONBLOCK = 1 << 2,
 
     /* Pin data pages in ESX.  Used with NONBLOCK */
     VMCI_QPFLAG_PINNED = 1 << 3,
 
     /* Update the following flag when adding new flags. */
     VMCI_QP_ALL_FLAGS = (VMCI_QPFLAG_ATTACH_ONLY | VMCI_QPFLAG_LOCAL |
                  VMCI_QPFLAG_NONBLOCK | VMCI_QPFLAG_PINNED),
 
     /* Convenience flags */
     VMCI_QP_ASYMM = (VMCI_QPFLAG_NONBLOCK | VMCI_QPFLAG_PINNED),
     VMCI_QP_ASYMM_PEER = (VMCI_QPFLAG_ATTACH_ONLY | VMCI_QP_ASYMM),
 };
 
 /*
  * We allow at least 1024 more event datagrams from the hypervisor past the
  * normally allowed datagrams pending for a given context.  We define this
  * limit on event datagrams from the hypervisor to guard against DoS attack
  * from a malicious VM which could repeatedly attach to and detach from a queue
  * pair, causing events to be queued at the destination VM.  However, the rate
  * at which such events can be generated is small since it requires a VM exit
  * and handling of queue pair attach/detach call at the hypervisor.  Event
  * datagrams may be queued up at the destination VM if it has interrupts
  * disabled or if it is not draining events for some other reason.  1024
  * datagrams is a grossly conservative estimate of the time for which
  * interrupts may be disabled in the destination VM, but at the same time does
  * not exacerbate the memory pressure problem on the host by much (size of each
  * event datagram is small).
  */
 #define VMCI_MAX_DATAGRAM_AND_EVENT_QUEUE_SIZE              \
     (VMCI_MAX_DATAGRAM_QUEUE_SIZE +                 \
      1024 * (sizeof(struct vmci_datagram) +             \
          sizeof(struct vmci_event_data_max)))
 
 /*
  * Struct used for querying, via VMCI_RESOURCES_QUERY, the availability of
  * hypervisor resources.  Struct size is 16 bytes. All fields in struct are
  * aligned to their natural alignment.
  */
 struct vmci_resource_query_hdr {
     struct vmci_datagram hdr;
     u32 num_resources;
     u32 _padding;
 };
 
 /*
  * Convenience struct for negotiating vectors. Must match layout of
  * VMCIResourceQueryHdr minus the struct vmci_datagram header.
  */
 struct vmci_resource_query_msg {
     u32 num_resources;
     u32 _padding;
     u32 resources[1];
 };
 
 /*
  * The maximum number of resources that can be queried using
  * VMCI_RESOURCE_QUERY is 31, as the result is encoded in the lower 31
  * bits of a positive return value. Negative values are reserved for
  * errors.
  */
 #define VMCI_RESOURCE_QUERY_MAX_NUM 31
 
 /* Maximum size for the VMCI_RESOURCE_QUERY request. */
 #define VMCI_RESOURCE_QUERY_MAX_SIZE                \
     (sizeof(struct vmci_resource_query_hdr) +       \
      sizeof(u32) * VMCI_RESOURCE_QUERY_MAX_NUM)
 
 /*
  * Struct used for setting the notification bitmap.  All fields in
  * struct are aligned to their natural alignment.
  */
 struct vmci_notify_bm_set_msg {
     struct vmci_datagram hdr;
     union {
         u32 bitmap_ppn32;
         u64 bitmap_ppn64;
     };
 };
 
 /*
  * Struct used for linking a doorbell handle with an index in the
  * notify bitmap. All fields in struct are aligned to their natural
  * alignment.
  */
 struct vmci_doorbell_link_msg {
     struct vmci_datagram hdr;
     struct vmci_handle handle;
     u64 notify_idx;
 };
 
 /*
  * Struct used for unlinking a doorbell handle from an index in the
  * notify bitmap. All fields in struct are aligned to their natural
  * alignment.
  */
 struct vmci_doorbell_unlink_msg {
     struct vmci_datagram hdr;
     struct vmci_handle handle;
 };
 
 /*
  * Struct used for generating a notification on a doorbell handle. All
  * fields in struct are aligned to their natural alignment.
  */
 struct vmci_doorbell_notify_msg {
     struct vmci_datagram hdr;
     struct vmci_handle handle;
 };
 
 /*
  * This struct is used to contain data for events.  Size of this struct is a
  * multiple of 8 bytes, and all fields are aligned to their natural alignment.
  */
 struct vmci_event_data {
     u32 event;      /* 4 bytes. */
     u32 _pad;
     /* Event payload is put here. */
 };
 
 /*
  * Define the different VMCI_EVENT payload data types here.  All structs must
  * be a multiple of 8 bytes, and fields must be aligned to their natural
  * alignment.
  */
 struct vmci_event_payld_ctx {
     u32 context_id; /* 4 bytes. */
     u32 _pad;
 };
 
 struct vmci_event_payld_qp {
     struct vmci_handle handle;  /* queue_pair handle. */
     u32 peer_id;        /* Context id of attaching/detaching VM. */
     u32 _pad;
 };
 
 /*
  * We define the following struct to get the size of the maximum event
  * data the hypervisor may send to the guest.  If adding a new event
  * payload type above, add it to the following struct too (inside the
  * union).
  */
 struct vmci_event_data_max {
     struct vmci_event_data event_data;
     union {
         struct vmci_event_payld_ctx context_payload;
         struct vmci_event_payld_qp qp_payload;
     } ev_data_payload;
 };
 
 /*
  * Struct used for VMCI_EVENT_SUBSCRIBE/UNSUBSCRIBE and
  * VMCI_EVENT_HANDLER messages.  Struct size is 32 bytes.  All fields
  * in struct are aligned to their natural alignment.
  */
 struct vmci_event_msg {
     struct vmci_datagram hdr;
 
     /* Has event type and payload. */
     struct vmci_event_data event_data;
 
     /* Payload gets put here. */
 };
 
 /* Event with context payload. */
 struct vmci_event_ctx {
     struct vmci_event_msg msg;
     struct vmci_event_payld_ctx payload;
 };
 
 /* Event with QP payload. */
 struct vmci_event_qp {
     struct vmci_event_msg msg;
     struct vmci_event_payld_qp payload;
 };
 
 /*
  * Structs used for queue_pair alloc and detach messages.  We align fields of
  * these structs to 64bit boundaries.
  */
 struct vmci_qp_alloc_msg {
     struct vmci_datagram hdr;
     struct vmci_handle handle;
     u32 peer;
     u32 flags;
     u64 produce_size;
     u64 consume_size;
     u64 num_ppns;
 
     /* List of PPNs placed here. */
 };
 
 struct vmci_qp_detach_msg {
     struct vmci_datagram hdr;
     struct vmci_handle handle;
 };
 
 /* VMCI Doorbell API. */
 #define VMCI_FLAG_DELAYED_CB BIT(0)
 
 typedef void (*vmci_callback) (void *client_data);
 
 /*
  * struct vmci_qp - A vmw_vmci queue pair handle.
  *
  * This structure is used as a handle to a queue pair created by
  * VMCI.  It is intentionally left opaque to clients.
  */
 struct vmci_qp;
 
 /* Callback needed for correctly waiting on events. */
 typedef int (*vmci_datagram_recv_cb) (void *client_data,
                       struct vmci_datagram *msg);
 
 /* VMCI Event API. */
 typedef void (*vmci_event_cb) (u32 sub_id, const struct vmci_event_data *ed,
                    void *client_data);
 
 /*
  * We use the following inline function to access the payload data
  * associated with an event data.
  */
 static inline const void *
 vmci_event_data_const_payload(const struct vmci_event_data *ev_data)
 {
     return (const char *)ev_data + sizeof(*ev_data);
 }
 
 static inline void *vmci_event_data_payload(struct vmci_event_data *ev_data)
 {
     return (void *)vmci_event_data_const_payload(ev_data);
 }
 
 /*
  * Helper to read a value from a head or tail pointer. For X86_32, the
  * pointer is treated as a 32bit value, since the pointer value
  * never exceeds a 32bit value in this case. Also, doing an
  * atomic64_read on X86_32 uniprocessor systems may be implemented
  * as a non locked cmpxchg8b, that may end up overwriting updates done
  * by the VMCI device to the memory location. On 32bit SMP, the lock
  * prefix will be used, so correctness isn't an issue, but using a
  * 64bit operation still adds unnecessary overhead.
  */
 static inline u64 vmci_q_read_pointer(u64 *var)
 {
     return READ_ONCE(*(unsigned long *)var);
 }
 
 /*
  * Helper to set the value of a head or tail pointer. For X86_32, the
  * pointer is treated as a 32bit value, since the pointer value
  * never exceeds a 32bit value in this case. On 32bit SMP, using a
  * locked cmpxchg8b adds unnecessary overhead.
  */
 static inline void vmci_q_set_pointer(u64 *var, u64 new_val)
 {
     /* XXX buggered on big-endian */
     WRITE_ONCE(*(unsigned long *)var, (unsigned long)new_val);
 }
 
 /*
  * Helper to add a given offset to a head or tail pointer. Wraps the
  * value of the pointer around the max size of the queue.
  */
 static inline void vmci_qp_add_pointer(u64 *var, size_t add, u64 size)
 {
     u64 new_val = vmci_q_read_pointer(var);
 
     if (new_val >= size - add)
         new_val -= size;
 
     new_val += add;
 
     vmci_q_set_pointer(var, new_val);
 }
 
 /*
  * Helper routine to get the Producer Tail from the supplied queue.
  */
 static inline u64
 vmci_q_header_producer_tail(const struct vmci_queue_header *q_header)
 {
     struct vmci_queue_header *qh = (struct vmci_queue_header *)q_header;
     return vmci_q_read_pointer(&qh->producer_tail);
 }
 
 /*
  * Helper routine to get the Consumer Head from the supplied queue.
  */
 static inline u64
 vmci_q_header_consumer_head(const struct vmci_queue_header *q_header)
 {
     struct vmci_queue_header *qh = (struct vmci_queue_header *)q_header;
     return vmci_q_read_pointer(&qh->consumer_head);
 }
 
 /*
  * Helper routine to increment the Producer Tail.  Fundamentally,
  * vmci_qp_add_pointer() is used to manipulate the tail itself.
  */
 static inline void
 vmci_q_header_add_producer_tail(struct vmci_queue_header *q_header,
                 size_t add,
                 u64 queue_size)
 {
     vmci_qp_add_pointer(&q_header->producer_tail, add, queue_size);
 }
 
 /*
  * Helper routine to increment the Consumer Head.  Fundamentally,
  * vmci_qp_add_pointer() is used to manipulate the head itself.
  */
 static inline void
 vmci_q_header_add_consumer_head(struct vmci_queue_header *q_header,
                 size_t add,
                 u64 queue_size)
 {
     vmci_qp_add_pointer(&q_header->consumer_head, add, queue_size);
 }
 
 /*
  * Helper routine for getting the head and the tail pointer for a queue.
  * Both the VMCIQueues are needed to get both the pointers for one queue.
  */
 static inline void
 vmci_q_header_get_pointers(const struct vmci_queue_header *produce_q_header,
                const struct vmci_queue_header *consume_q_header,
                u64 *producer_tail,
                u64 *consumer_head)
 {
     if (producer_tail)
         *producer_tail = vmci_q_header_producer_tail(produce_q_header);
 
     if (consumer_head)
         *consumer_head = vmci_q_header_consumer_head(consume_q_header);
 }
 
 static inline void vmci_q_header_init(struct vmci_queue_header *q_header,
                       const struct vmci_handle handle)
 {
     q_header->handle = handle;
     q_header->producer_tail = 0;
     q_header->consumer_head = 0;
 }
 
 /*
  * Finds available free space in a produce queue to enqueue more
  * data or reports an error if queue pair corruption is detected.
  */
 static s64
 vmci_q_header_free_space(const struct vmci_queue_header *produce_q_header,
              const struct vmci_queue_header *consume_q_header,
              const u64 produce_q_size)
 {
     u64 tail;
     u64 head;
     u64 free_space;
 
     tail = vmci_q_header_producer_tail(produce_q_header);
     head = vmci_q_header_consumer_head(consume_q_header);
 
     if (tail >= produce_q_size || head >= produce_q_size)
         return VMCI_ERROR_INVALID_SIZE;
 
     /*
      * Deduct 1 to avoid tail becoming equal to head which causes
      * ambiguity. If head and tail are equal it means that the
      * queue is empty.
      */
     if (tail >= head)
         free_space = produce_q_size - (tail - head) - 1;
     else
         free_space = head - tail - 1;
 
     return free_space;
 }
 
 /*
  * vmci_q_header_free_space() does all the heavy lifting of
  * determing the number of free bytes in a Queue.  This routine,
  * then subtracts that size from the full size of the Queue so
  * the caller knows how many bytes are ready to be dequeued.
  * Results:
  * On success, available data size in bytes (up to MAX_INT64).
  * On failure, appropriate error code.
  */
 static inline s64
 vmci_q_header_buf_ready(const struct vmci_queue_header *consume_q_header,
             const struct vmci_queue_header *produce_q_header,
             const u64 consume_q_size)
 {
     s64 free_space;
 
     free_space = vmci_q_header_free_space(consume_q_header,
                           produce_q_header, consume_q_size);
     if (free_space < VMCI_SUCCESS)
         return free_space;
 
     return consume_q_size - free_space - 1;
 }
 
 
 #endif /* _VMW_VMCI_DEF_H_ */

This page was automatically generated by the 2.1.0 LXR engine. The LXR team