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