VirtualBox

source: vbox/trunk/include/VBox/VMMDev.h@ 53420

Last change on this file since 53420 was 52789, checked in by vboxsync, 10 years ago

VMMDev/Main, Additions: Guest heartbeat implementation. VMMDev reports to host log if missed heartbeat from the guest.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 66.7 KB
Line 
1/** @file
2 * Virtual Device for Guest <-> VMM/Host communication (ADD,DEV).
3 */
4
5/*
6 * Copyright (C) 2006-2014 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 */
25
26#ifndef ___VBox_VMMDev_h
27#define ___VBox_VMMDev_h
28
29#include <VBox/cdefs.h>
30#include <VBox/param.h> /* for the PCI IDs. */
31#include <VBox/types.h>
32#include <VBox/err.h>
33#include <VBox/ostypes.h>
34#include <VBox/VMMDev2.h>
35#include <iprt/assert.h>
36
37
38#pragma pack(4) /* force structure dword packing here. */
39RT_C_DECLS_BEGIN
40
41
42/** @defgroup grp_vmmdev VMM Device
43 *
44 * Note! This interface cannot be changed, it can only be extended!
45 *
46 * @{
47 */
48
49
50/** Size of VMMDev RAM region accessible by guest.
51 * Must be big enough to contain VMMDevMemory structure (see further down).
52 * For now: 4 megabyte.
53 */
54#define VMMDEV_RAM_SIZE (4 * 256 * PAGE_SIZE)
55
56/** Size of VMMDev heap region accessible by guest.
57 * (Must be a power of two (pci range).)
58 */
59#define VMMDEV_HEAP_SIZE (4 * PAGE_SIZE)
60
61/** Port for generic request interface (relative offset). */
62#define VMMDEV_PORT_OFF_REQUEST 0
63
64
65/** @name VMMDev events.
66 *
67 * Used mainly by VMMDevReq_AcknowledgeEvents/VMMDevEvents and version 1.3 of
68 * VMMDevMemory.
69 *
70 * @{
71 */
72/** Host mouse capabilities has been changed. */
73#define VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED RT_BIT(0)
74/** HGCM event. */
75#define VMMDEV_EVENT_HGCM RT_BIT(1)
76/** A display change request has been issued. */
77#define VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST RT_BIT(2)
78/** Credentials are available for judgement. */
79#define VMMDEV_EVENT_JUDGE_CREDENTIALS RT_BIT(3)
80/** The guest has been restored. */
81#define VMMDEV_EVENT_RESTORED RT_BIT(4)
82/** Seamless mode state changed. */
83#define VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST RT_BIT(5)
84/** Memory balloon size changed. */
85#define VMMDEV_EVENT_BALLOON_CHANGE_REQUEST RT_BIT(6)
86/** Statistics interval changed. */
87#define VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST RT_BIT(7)
88/** VRDP status changed. */
89#define VMMDEV_EVENT_VRDP RT_BIT(8)
90/** New mouse position data available. */
91#define VMMDEV_EVENT_MOUSE_POSITION_CHANGED RT_BIT(9)
92/** CPU hotplug event occurred. */
93#define VMMDEV_EVENT_CPU_HOTPLUG RT_BIT(10)
94/** The mask of valid events, for sanity checking. */
95#define VMMDEV_EVENT_VALID_EVENT_MASK UINT32_C(0x000007ff)
96/** @} */
97
98
99/** @defgroup grp_vmmdev_req VMMDev Generic Request Interface
100 * @{
101 */
102
103/** @name Current version of the VMMDev interface.
104 *
105 * Additions are allowed to work only if
106 * additions_major == vmmdev_current && additions_minor <= vmmdev_current.
107 * Additions version is reported to host (VMMDev) by VMMDevReq_ReportGuestInfo.
108 *
109 * @remarks These defines also live in the 16-bit and assembly versions of this
110 * header.
111 */
112#define VMMDEV_VERSION 0x00010004
113#define VMMDEV_VERSION_MAJOR (VMMDEV_VERSION >> 16)
114#define VMMDEV_VERSION_MINOR (VMMDEV_VERSION & 0xffff)
115/** @} */
116
117/** Maximum request packet size. */
118#define VMMDEV_MAX_VMMDEVREQ_SIZE _1M
119/** Maximum number of HGCM parameters. */
120#define VMMDEV_MAX_HGCM_PARMS 1024
121/** Maximum total size of hgcm buffers in one call. */
122#define VMMDEV_MAX_HGCM_DATA_SIZE UINT32_C(0x7FFFFFFF)
123
124/**
125 * VMMDev request types.
126 * @note when updating this, adjust vmmdevGetRequestSize() as well
127 */
128typedef enum
129{
130 VMMDevReq_InvalidRequest = 0,
131 VMMDevReq_GetMouseStatus = 1,
132 VMMDevReq_SetMouseStatus = 2,
133 VMMDevReq_SetPointerShape = 3,
134 VMMDevReq_GetHostVersion = 4,
135 VMMDevReq_Idle = 5,
136 VMMDevReq_GetHostTime = 10,
137 VMMDevReq_GetHypervisorInfo = 20,
138 VMMDevReq_SetHypervisorInfo = 21,
139 VMMDevReq_RegisterPatchMemory = 22, /* since version 3.0.6 */
140 VMMDevReq_DeregisterPatchMemory = 23, /* since version 3.0.6 */
141 VMMDevReq_SetPowerStatus = 30,
142 VMMDevReq_AcknowledgeEvents = 41,
143 VMMDevReq_CtlGuestFilterMask = 42,
144 VMMDevReq_ReportGuestInfo = 50,
145 VMMDevReq_ReportGuestInfo2 = 58, /* since version 3.2.0 */
146 VMMDevReq_ReportGuestStatus = 59, /* since version 3.2.8 */
147 VMMDevReq_ReportGuestUserState = 74, /* since version 4.3 */
148 /**
149 * Retrieve a display resize request sent by the host using
150 * @a IDisplay:setVideoModeHint. Deprecated.
151 *
152 * Similar to @a VMMDevReq_GetDisplayChangeRequest2, except that it only
153 * considers host requests sent for the first virtual display. This guest
154 * request should not be used in new guest code, and the results are
155 * undefined if a guest mixes calls to this and
156 * @a VMMDevReq_GetDisplayChangeRequest2.
157 */
158 VMMDevReq_GetDisplayChangeRequest = 51,
159 VMMDevReq_VideoModeSupported = 52,
160 VMMDevReq_GetHeightReduction = 53,
161 /**
162 * Retrieve a display resize request sent by the host using
163 * @a IDisplay:setVideoModeHint.
164 *
165 * Queries a display resize request sent from the host. If the
166 * @a eventAck member is sent to true and there is an unqueried
167 * request available for one of the virtual display then that request will
168 * be returned. If several displays have unqueried requests the lowest
169 * numbered display will be chosen first. Only the most recent unseen
170 * request for each display is remembered.
171 * If @a eventAck is set to false, the last host request queried with
172 * @a eventAck set is resent, or failing that the most recent received from
173 * the host. If no host request was ever received then all zeros are
174 * returned.
175 */
176 VMMDevReq_GetDisplayChangeRequest2 = 54,
177 VMMDevReq_ReportGuestCapabilities = 55,
178 VMMDevReq_SetGuestCapabilities = 56,
179 VMMDevReq_VideoModeSupported2 = 57, /* since version 3.2.0 */
180 VMMDevReq_GetDisplayChangeRequestEx = 80, /* since version 4.2.4 */
181#ifdef VBOX_WITH_HGCM
182 VMMDevReq_HGCMConnect = 60,
183 VMMDevReq_HGCMDisconnect = 61,
184#ifdef VBOX_WITH_64_BITS_GUESTS
185 VMMDevReq_HGCMCall32 = 62,
186 VMMDevReq_HGCMCall64 = 63,
187#else
188 VMMDevReq_HGCMCall = 62,
189#endif /* VBOX_WITH_64_BITS_GUESTS */
190 VMMDevReq_HGCMCancel = 64,
191 VMMDevReq_HGCMCancel2 = 65,
192#endif
193 VMMDevReq_VideoAccelEnable = 70,
194 VMMDevReq_VideoAccelFlush = 71,
195 VMMDevReq_VideoSetVisibleRegion = 72,
196 VMMDevReq_GetSeamlessChangeRequest = 73,
197 VMMDevReq_QueryCredentials = 100,
198 VMMDevReq_ReportCredentialsJudgement = 101,
199 VMMDevReq_ReportGuestStats = 110,
200 VMMDevReq_GetMemBalloonChangeRequest = 111,
201 VMMDevReq_GetStatisticsChangeRequest = 112,
202 VMMDevReq_ChangeMemBalloon = 113,
203 VMMDevReq_GetVRDPChangeRequest = 150,
204 VMMDevReq_LogString = 200,
205 VMMDevReq_GetCpuHotPlugRequest = 210,
206 VMMDevReq_SetCpuHotPlugStatus = 211,
207 VMMDevReq_RegisterSharedModule = 212,
208 VMMDevReq_UnregisterSharedModule = 213,
209 VMMDevReq_CheckSharedModules = 214,
210 VMMDevReq_GetPageSharingStatus = 215,
211 VMMDevReq_DebugIsPageShared = 216,
212 VMMDevReq_GetSessionId = 217, /* since version 3.2.8 */
213 VMMDevReq_WriteCoreDump = 218,
214 VMMDevReq_GuestHeartbeat = 219,
215 VMMDevReq_HeartbeatConfigure = 220,
216 VMMDevReq_SizeHack = 0x7fffffff
217} VMMDevRequestType;
218
219#ifdef VBOX_WITH_64_BITS_GUESTS
220/*
221 * Constants and structures are redefined for the guest.
222 *
223 * Host code MUST always use either *32 or *64 variant explicitely.
224 * Host source code will use VBOX_HGCM_HOST_CODE define to catch undefined
225 * data types and constants.
226 *
227 * This redefinition means that the new additions builds will use
228 * the *64 or *32 variants depending on the current architecture bit count (ARCH_BITS).
229 */
230# ifndef VBOX_HGCM_HOST_CODE
231# if ARCH_BITS == 64
232# define VMMDevReq_HGCMCall VMMDevReq_HGCMCall64
233# elif ARCH_BITS == 32
234# define VMMDevReq_HGCMCall VMMDevReq_HGCMCall32
235# else
236# error "Unsupported ARCH_BITS"
237# endif
238# endif /* !VBOX_HGCM_HOST_CODE */
239#endif /* VBOX_WITH_64_BITS_GUESTS */
240
241/** Version of VMMDevRequestHeader structure. */
242#define VMMDEV_REQUEST_HEADER_VERSION (0x10001)
243
244
245/**
246 * Generic VMMDev request header.
247 */
248typedef struct
249{
250 /** IN: Size of the structure in bytes (including body). */
251 uint32_t size;
252 /** IN: Version of the structure. */
253 uint32_t version;
254 /** IN: Type of the request. */
255 VMMDevRequestType requestType;
256 /** OUT: Return code. */
257 int32_t rc;
258 /** Reserved field no.1. MBZ. */
259 uint32_t reserved1;
260 /** Reserved field no.2. MBZ. */
261 uint32_t reserved2;
262} VMMDevRequestHeader;
263AssertCompileSize(VMMDevRequestHeader, 24);
264
265
266/**
267 * Mouse status request structure.
268 *
269 * Used by VMMDevReq_GetMouseStatus and VMMDevReq_SetMouseStatus.
270 */
271typedef struct
272{
273 /** header */
274 VMMDevRequestHeader header;
275 /** Mouse feature mask. See VMMDEV_MOUSE_*. */
276 uint32_t mouseFeatures;
277 /** Mouse x position. */
278 int32_t pointerXPos;
279 /** Mouse y position. */
280 int32_t pointerYPos;
281} VMMDevReqMouseStatus;
282AssertCompileSize(VMMDevReqMouseStatus, 24+12);
283
284/** @name Mouse capability bits (VMMDevReqMouseStatus::mouseFeatures).
285 * @{ */
286/** The guest can (== wants to) handle absolute coordinates. */
287#define VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE RT_BIT(0)
288/** The host can (== wants to) send absolute coordinates.
289 * (Input not captured.) */
290#define VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE RT_BIT(1)
291/** The guest can *NOT* switch to software cursor and therefore depends on the
292 * host cursor.
293 *
294 * When guest additions are installed and the host has promised to display the
295 * cursor itself, the guest installs a hardware mouse driver. Don't ask the
296 * guest to switch to a software cursor then. */
297#define VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR RT_BIT(2)
298/** The host does NOT provide support for drawing the cursor itself. */
299#define VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER RT_BIT(3)
300/** The guest can read VMMDev events to find out about pointer movement */
301#define VMMDEV_MOUSE_NEW_PROTOCOL RT_BIT(4)
302/** If the guest changes the status of the
303 * VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR bit, the host will honour this */
304#define VMMDEV_MOUSE_HOST_RECHECKS_NEEDS_HOST_CURSOR RT_BIT(5)
305/** The host supplies an absolute pointing device. The Guest Additions may
306 * wish to use this to decide whether to install their own driver */
307#define VMMDEV_MOUSE_HOST_HAS_ABS_DEV RT_BIT(6)
308/** The mask of all VMMDEV_MOUSE_* flags */
309#define VMMDEV_MOUSE_MASK UINT32_C(0x0000007f)
310/** The mask of guest capability changes for which notification events should
311 * be sent */
312#define VMMDEV_MOUSE_NOTIFY_HOST_MASK \
313 (VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE | VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR)
314/** The mask of all capabilities which the guest can legitimately change */
315#define VMMDEV_MOUSE_GUEST_MASK \
316 (VMMDEV_MOUSE_NOTIFY_HOST_MASK | VMMDEV_MOUSE_NEW_PROTOCOL)
317/** The mask of host capability changes for which notification events should
318 * be sent */
319#define VMMDEV_MOUSE_NOTIFY_GUEST_MASK \
320 VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE
321/** The mask of all capabilities which the host can legitimately change */
322#define VMMDEV_MOUSE_HOST_MASK \
323 ( VMMDEV_MOUSE_NOTIFY_GUEST_MASK \
324 | VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER \
325 | VMMDEV_MOUSE_HOST_RECHECKS_NEEDS_HOST_CURSOR \
326 | VMMDEV_MOUSE_HOST_HAS_ABS_DEV)
327/** @} */
328
329/** @name Absolute mouse reporting range
330 * @{ */
331/** @todo Should these be here? They are needed by both host and guest. */
332/** The minumum value our pointing device can return. */
333#define VMMDEV_MOUSE_RANGE_MIN 0
334/** The maximum value our pointing device can return. */
335#define VMMDEV_MOUSE_RANGE_MAX 0xFFFF
336/** The full range our pointing device can return. */
337#define VMMDEV_MOUSE_RANGE (VMMDEV_MOUSE_RANGE_MAX - VMMDEV_MOUSE_RANGE_MIN)
338/** @} */
339
340
341/**
342 * Mouse pointer shape/visibility change request.
343 *
344 * Used by VMMDevReq_SetPointerShape. The size is variable.
345 */
346typedef struct VMMDevReqMousePointer
347{
348 /** Header. */
349 VMMDevRequestHeader header;
350 /** VBOX_MOUSE_POINTER_* bit flags. */
351 uint32_t fFlags;
352 /** x coordinate of hot spot. */
353 uint32_t xHot;
354 /** y coordinate of hot spot. */
355 uint32_t yHot;
356 /** Width of the pointer in pixels. */
357 uint32_t width;
358 /** Height of the pointer in scanlines. */
359 uint32_t height;
360 /** Pointer data.
361 *
362 ****
363 * The data consists of 1 bpp AND mask followed by 32 bpp XOR (color) mask.
364 *
365 * For pointers without alpha channel the XOR mask pixels are 32 bit values: (lsb)BGR0(msb).
366 * For pointers with alpha channel the XOR mask consists of (lsb)BGRA(msb) 32 bit values.
367 *
368 * Guest driver must create the AND mask for pointers with alpha channel, so if host does not
369 * support alpha, the pointer could be displayed as a normal color pointer. The AND mask can
370 * be constructed from alpha values. For example alpha value >= 0xf0 means bit 0 in the AND mask.
371 *
372 * The AND mask is 1 bpp bitmap with byte aligned scanlines. Size of AND mask,
373 * therefore, is cbAnd = (width + 7) / 8 * height. The padding bits at the
374 * end of any scanline are undefined.
375 *
376 * The XOR mask follows the AND mask on the next 4 bytes aligned offset:
377 * uint8_t *pXor = pAnd + (cbAnd + 3) & ~3
378 * Bytes in the gap between the AND and the XOR mask are undefined.
379 * XOR mask scanlines have no gap between them and size of XOR mask is:
380 * cXor = width * 4 * height.
381 ****
382 *
383 * Preallocate 4 bytes for accessing actual data as p->pointerData.
384 */
385 char pointerData[4];
386} VMMDevReqMousePointer;
387AssertCompileSize(VMMDevReqMousePointer, 24+24);
388
389/**
390 * Get the size that a VMMDevReqMousePointer request should have for a given
391 * size of cursor, including the trailing cursor image and mask data.
392 * @note an "empty" request still has the four preallocated bytes of data
393 *
394 * @returns the size
395 * @param width the cursor width
396 * @param height the cursor height
397 */
398DECLINLINE(size_t) vmmdevGetMousePointerReqSize(uint32_t width, uint32_t height)
399{
400 size_t cbBase = RT_OFFSETOF(VMMDevReqMousePointer, pointerData);
401 size_t cbMask = (width + 7) / 8 * height;
402 size_t cbArgb = width * height * 4;
403 return RT_MAX(cbBase + ((cbMask + 3) & ~3) + cbArgb,
404 sizeof(VMMDevReqMousePointer));
405}
406
407/** @name VMMDevReqMousePointer::fFlags
408 * @note The VBOX_MOUSE_POINTER_* flags are used in the guest video driver,
409 * values must be <= 0x8000 and must not be changed. (try make more sense
410 * of this, please).
411 * @{
412 */
413/** pointer is visible */
414#define VBOX_MOUSE_POINTER_VISIBLE (0x0001)
415/** pointer has alpha channel */
416#define VBOX_MOUSE_POINTER_ALPHA (0x0002)
417/** pointerData contains new pointer shape */
418#define VBOX_MOUSE_POINTER_SHAPE (0x0004)
419/** @} */
420
421
422/**
423 * String log request structure.
424 *
425 * Used by VMMDevReq_LogString.
426 * @deprecated Use the IPRT logger or VbglR3WriteLog instead.
427 */
428typedef struct
429{
430 /** header */
431 VMMDevRequestHeader header;
432 /** variable length string data */
433 char szString[1];
434} VMMDevReqLogString;
435AssertCompileSize(VMMDevReqLogString, 24+4);
436
437
438/**
439 * VirtualBox host version request structure.
440 *
441 * Used by VMMDevReq_GetHostVersion.
442 *
443 * @remarks VBGL uses this to detect the precense of new features in the
444 * interface.
445 */
446typedef struct
447{
448 /** Header. */
449 VMMDevRequestHeader header;
450 /** Major version. */
451 uint16_t major;
452 /** Minor version. */
453 uint16_t minor;
454 /** Build number. */
455 uint32_t build;
456 /** SVN revision. */
457 uint32_t revision;
458 /** Feature mask. */
459 uint32_t features;
460} VMMDevReqHostVersion;
461AssertCompileSize(VMMDevReqHostVersion, 24+16);
462
463/** @name VMMDevReqHostVersion::features
464 * @{ */
465/** Physical page lists are supported by HGCM. */
466#define VMMDEV_HVF_HGCM_PHYS_PAGE_LIST RT_BIT(0)
467/** @} */
468
469
470/**
471 * Guest capabilities structure.
472 *
473 * Used by VMMDevReq_ReportGuestCapabilities.
474 */
475typedef struct
476{
477 /** Header. */
478 VMMDevRequestHeader header;
479 /** Capabilities (VMMDEV_GUEST_*). */
480 uint32_t caps;
481} VMMDevReqGuestCapabilities;
482AssertCompileSize(VMMDevReqGuestCapabilities, 24+4);
483
484/**
485 * Guest capabilities structure, version 2.
486 *
487 * Used by VMMDevReq_SetGuestCapabilities.
488 */
489typedef struct
490{
491 /** Header. */
492 VMMDevRequestHeader header;
493 /** Mask of capabilities to be added. */
494 uint32_t u32OrMask;
495 /** Mask of capabilities to be removed. */
496 uint32_t u32NotMask;
497} VMMDevReqGuestCapabilities2;
498AssertCompileSize(VMMDevReqGuestCapabilities2, 24+8);
499
500/** @name Guest capability bits.
501 * Used by VMMDevReq_ReportGuestCapabilities and VMMDevReq_SetGuestCapabilities.
502 * @{ */
503/** The guest supports seamless display rendering. */
504#define VMMDEV_GUEST_SUPPORTS_SEAMLESS RT_BIT_32(0)
505/** The guest supports mapping guest to host windows. */
506#define VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING RT_BIT_32(1)
507/** The guest graphical additions are active.
508 * Used for fast activation and deactivation of certain graphical operations
509 * (e.g. resizing & seamless). The legacy VMMDevReq_ReportGuestCapabilities
510 * request sets this automatically, but VMMDevReq_SetGuestCapabilities does
511 * not. */
512#define VMMDEV_GUEST_SUPPORTS_GRAPHICS RT_BIT_32(2)
513/** The mask of valid events, for sanity checking. */
514#define VMMDEV_GUEST_CAPABILITIES_MASK UINT32_C(0x00000007)
515/** @} */
516
517
518/**
519 * Idle request structure.
520 *
521 * Used by VMMDevReq_Idle.
522 */
523typedef struct
524{
525 /** Header. */
526 VMMDevRequestHeader header;
527} VMMDevReqIdle;
528AssertCompileSize(VMMDevReqIdle, 24);
529
530
531/**
532 * Host time request structure.
533 *
534 * Used by VMMDevReq_GetHostTime.
535 */
536typedef struct
537{
538 /** Header */
539 VMMDevRequestHeader header;
540 /** OUT: Time in milliseconds since unix epoch. */
541 uint64_t time;
542} VMMDevReqHostTime;
543AssertCompileSize(VMMDevReqHostTime, 24+8);
544
545
546/**
547 * Hypervisor info structure.
548 *
549 * Used by VMMDevReq_GetHypervisorInfo and VMMDevReq_SetHypervisorInfo.
550 */
551typedef struct
552{
553 /** Header. */
554 VMMDevRequestHeader header;
555 /** Guest virtual address of proposed hypervisor start.
556 * Not used by VMMDevReq_GetHypervisorInfo.
557 * @todo Make this 64-bit compatible? */
558 RTGCPTR32 hypervisorStart;
559 /** Hypervisor size in bytes. */
560 uint32_t hypervisorSize;
561} VMMDevReqHypervisorInfo;
562AssertCompileSize(VMMDevReqHypervisorInfo, 24+8);
563
564/** @name Default patch memory size .
565 * Used by VMMDevReq_RegisterPatchMemory and VMMDevReq_DeregisterPatchMemory.
566 * @{ */
567#define VMMDEV_GUEST_DEFAULT_PATCHMEM_SIZE 8192
568/** @} */
569
570/**
571 * Patching memory structure. (locked executable & read-only page from the guest's perspective)
572 *
573 * Used by VMMDevReq_RegisterPatchMemory and VMMDevReq_DeregisterPatchMemory
574 */
575typedef struct
576{
577 /** Header. */
578 VMMDevRequestHeader header;
579 /** Guest virtual address of the patching page(s). */
580 RTGCPTR64 pPatchMem;
581 /** Patch page size in bytes. */
582 uint32_t cbPatchMem;
583} VMMDevReqPatchMemory;
584AssertCompileSize(VMMDevReqPatchMemory, 24+12);
585
586
587/**
588 * Guest power requests.
589 *
590 * See VMMDevReq_SetPowerStatus and VMMDevPowerStateRequest.
591 */
592typedef enum
593{
594 VMMDevPowerState_Invalid = 0,
595 VMMDevPowerState_Pause = 1,
596 VMMDevPowerState_PowerOff = 2,
597 VMMDevPowerState_SaveState = 3,
598 VMMDevPowerState_SizeHack = 0x7fffffff
599} VMMDevPowerState;
600AssertCompileSize(VMMDevPowerState, 4);
601
602/**
603 * VM power status structure.
604 *
605 * Used by VMMDevReq_SetPowerStatus.
606 */
607typedef struct
608{
609 /** Header. */
610 VMMDevRequestHeader header;
611 /** Power state request. */
612 VMMDevPowerState powerState;
613} VMMDevPowerStateRequest;
614AssertCompileSize(VMMDevPowerStateRequest, 24+4);
615
616
617/**
618 * Pending events structure.
619 *
620 * Used by VMMDevReq_AcknowledgeEvents.
621 */
622typedef struct
623{
624 /** Header. */
625 VMMDevRequestHeader header;
626 /** OUT: Pending event mask. */
627 uint32_t events;
628} VMMDevEvents;
629AssertCompileSize(VMMDevEvents, 24+4);
630
631
632/**
633 * Guest event filter mask control.
634 *
635 * Used by VMMDevReq_CtlGuestFilterMask.
636 */
637typedef struct
638{
639 /** Header. */
640 VMMDevRequestHeader header;
641 /** Mask of events to be added to the filter. */
642 uint32_t u32OrMask;
643 /** Mask of events to be removed from the filter. */
644 uint32_t u32NotMask;
645} VMMDevCtlGuestFilterMask;
646AssertCompileSize(VMMDevCtlGuestFilterMask, 24+8);
647
648
649/**
650 * Guest information structure.
651 *
652 * Used by VMMDevReportGuestInfo and PDMIVMMDEVCONNECTOR::pfnUpdateGuestVersion.
653 */
654typedef struct VBoxGuestInfo
655{
656 /** The VMMDev interface version expected by additions.
657 * *Deprecated*, do not use anymore! Will be removed. */
658 uint32_t interfaceVersion;
659 /** Guest OS type. */
660 VBOXOSTYPE osType;
661} VBoxGuestInfo;
662AssertCompileSize(VBoxGuestInfo, 8);
663
664/**
665 * Guest information report.
666 *
667 * Used by VMMDevReq_ReportGuestInfo.
668 */
669typedef struct
670{
671 /** Header. */
672 VMMDevRequestHeader header;
673 /** Guest information. */
674 VBoxGuestInfo guestInfo;
675} VMMDevReportGuestInfo;
676AssertCompileSize(VMMDevReportGuestInfo, 24+8);
677
678
679/**
680 * Guest information structure, version 2.
681 *
682 * Used by VMMDevReportGuestInfo2 and PDMIVMMDEVCONNECTOR::pfnUpdateGuestVersion2.
683 */
684typedef struct VBoxGuestInfo2
685{
686 /** Major version. */
687 uint16_t additionsMajor;
688 /** Minor version. */
689 uint16_t additionsMinor;
690 /** Build number. */
691 uint32_t additionsBuild;
692 /** SVN revision. */
693 uint32_t additionsRevision;
694 /** Feature mask, currently unused. */
695 uint32_t additionsFeatures;
696 /** The intentional meaning of this field was:
697 * Some additional information, for example 'Beta 1' or something like that.
698 *
699 * The way it was implemented was implemented: VBOX_VERSION_STRING.
700 *
701 * This means the first three members are duplicated in this field (if the guest
702 * build config is sane). So, the user must check this and chop it off before
703 * usage. There is, because of the Main code's blind trust in the field's
704 * content, no way back. */
705 char szName[128];
706} VBoxGuestInfo2;
707AssertCompileSize(VBoxGuestInfo2, 144);
708
709/**
710 * Guest information report, version 2.
711 *
712 * Used by VMMDevReq_ReportGuestInfo2.
713 */
714typedef struct
715{
716 /** Header. */
717 VMMDevRequestHeader header;
718 /** Guest information. */
719 VBoxGuestInfo2 guestInfo;
720} VMMDevReportGuestInfo2;
721AssertCompileSize(VMMDevReportGuestInfo2, 24+144);
722
723
724/**
725 * The guest facility.
726 * This needs to be kept in sync with AdditionsFacilityType of the Main API!
727 */
728typedef enum
729{
730 VBoxGuestFacilityType_Unknown = 0,
731 VBoxGuestFacilityType_VBoxGuestDriver = 20,
732 VBoxGuestFacilityType_AutoLogon = 90, /* VBoxGINA / VBoxCredProv / pam_vbox. */
733 VBoxGuestFacilityType_VBoxService = 100,
734 VBoxGuestFacilityType_VBoxTrayClient = 101, /* VBoxTray (Windows), VBoxClient (Linux, Unix). */
735 VBoxGuestFacilityType_Seamless = 1000,
736 VBoxGuestFacilityType_Graphics = 1100,
737 VBoxGuestFacilityType_All = 0x7ffffffe,
738 VBoxGuestFacilityType_SizeHack = 0x7fffffff
739} VBoxGuestFacilityType;
740AssertCompileSize(VBoxGuestFacilityType, 4);
741
742
743/**
744 * The current guest status of a facility.
745 * This needs to be kept in sync with AdditionsFacilityStatus of the Main API!
746 */
747typedef enum
748{
749 VBoxGuestFacilityStatus_Inactive = 0,
750 VBoxGuestFacilityStatus_Paused = 1,
751 VBoxGuestFacilityStatus_PreInit = 20,
752 VBoxGuestFacilityStatus_Init = 30,
753 VBoxGuestFacilityStatus_Active = 50,
754 VBoxGuestFacilityStatus_Terminating = 100,
755 VBoxGuestFacilityStatus_Terminated = 101,
756 VBoxGuestFacilityStatus_Failed = 800,
757 VBoxGuestFacilityStatus_Unknown = 999,
758 VBoxGuestFacilityStatus_SizeHack = 0x7fffffff
759} VBoxGuestFacilityStatus;
760AssertCompileSize(VBoxGuestFacilityStatus, 4);
761
762
763/**
764 * The facility class.
765 * This needs to be kept in sync with AdditionsFacilityClass of the Main API!
766 */
767typedef enum
768{
769 VBoxGuestFacilityClass_None = 0,
770 VBoxGuestFacilityClass_Driver = 10,
771 VBoxGuestFacilityClass_Service = 30,
772 VBoxGuestFacilityClass_Program = 50,
773 VBoxGuestFacilityClass_Feature = 100,
774 VBoxGuestFacilityClass_ThirdParty = 999,
775 VBoxGuestFacilityClass_All = 0x7ffffffe,
776 VBoxGuestFacilityClass_SizeHack = 0x7fffffff
777} VBoxGuestFacilityClass;
778AssertCompileSize(VBoxGuestFacilityClass, 4);
779
780
781/**
782 * Guest status structure.
783 *
784 * Used by VMMDevReqGuestStatus.
785 */
786typedef struct VBoxGuestStatus
787{
788 /** Facility the status is indicated for. */
789 VBoxGuestFacilityType facility;
790 /** Current guest status. */
791 VBoxGuestFacilityStatus status;
792 /** Flags, not used at the moment. */
793 uint32_t flags;
794} VBoxGuestStatus;
795AssertCompileSize(VBoxGuestStatus, 12);
796
797/**
798 * Guest Additions status structure.
799 *
800 * Used by VMMDevReq_ReportGuestStatus.
801 */
802typedef struct
803{
804 /** Header. */
805 VMMDevRequestHeader header;
806 /** Guest information. */
807 VBoxGuestStatus guestStatus;
808} VMMDevReportGuestStatus;
809AssertCompileSize(VMMDevReportGuestStatus, 24+12);
810
811
812/**
813 * The current status of specific guest user.
814 * This needs to be kept in sync with GuestUserState of the Main API!
815 */
816typedef enum VBoxGuestUserState
817{
818 VBoxGuestUserState_Unknown = 0,
819 VBoxGuestUserState_LoggedIn = 1,
820 VBoxGuestUserState_LoggedOut = 2,
821 VBoxGuestUserState_Locked = 3,
822 VBoxGuestUserState_Unlocked = 4,
823 VBoxGuestUserState_Disabled = 5,
824 VBoxGuestUserState_Idle = 6,
825 VBoxGuestUserState_InUse = 7,
826 VBoxGuestUserState_Created = 8,
827 VBoxGuestUserState_Deleted = 9,
828 VBoxGuestUserState_SessionChanged = 10,
829 VBoxGuestUserState_CredentialsChanged = 11,
830 VBoxGuestUserState_RoleChanged = 12,
831 VBoxGuestUserState_GroupAdded = 13,
832 VBoxGuestUserState_GroupRemoved = 14,
833 VBoxGuestUserState_Elevated = 15,
834 VBoxGuestUserState_SizeHack = 0x7fffffff
835} VBoxGuestUserState;
836AssertCompileSize(VBoxGuestUserState, 4);
837
838
839/**
840 * Guest user status updates.
841 */
842typedef struct VBoxGuestUserStatus
843{
844 /** The guest user state to send. */
845 VBoxGuestUserState state;
846 /** Size (in bytes) of szUser. */
847 uint32_t cbUser;
848 /** Size (in bytes) of szDomain. */
849 uint32_t cbDomain;
850 /** Size (in bytes) of aDetails. */
851 uint32_t cbDetails;
852 /** Note: Here begins the dynamically
853 * allocated region. */
854 /** Guest user to report state for. */
855 char szUser[1];
856 /** Domain the guest user is bound to. */
857 char szDomain[1];
858 /** Optional details of the state. */
859 uint8_t aDetails[1];
860} VBoxGuestUserStatus;
861AssertCompileSize(VBoxGuestUserStatus, 20);
862
863
864/**
865 * Guest user status structure.
866 *
867 * Used by VMMDevReq_ReportGuestUserStatus.
868 */
869typedef struct
870{
871 /** Header. */
872 VMMDevRequestHeader header;
873 /** Guest user status. */
874 VBoxGuestUserStatus status;
875} VMMDevReportGuestUserState;
876AssertCompileSize(VMMDevReportGuestUserState, 24+20);
877
878
879/**
880 * Guest statistics structure.
881 *
882 * Used by VMMDevReportGuestStats and PDMIVMMDEVCONNECTOR::pfnReportStatistics.
883 */
884typedef struct VBoxGuestStatistics
885{
886 /** Virtual CPU ID. */
887 uint32_t u32CpuId;
888 /** Reported statistics. */
889 uint32_t u32StatCaps;
890 /** Idle CPU load (0-100) for last interval. */
891 uint32_t u32CpuLoad_Idle;
892 /** Kernel CPU load (0-100) for last interval. */
893 uint32_t u32CpuLoad_Kernel;
894 /** User CPU load (0-100) for last interval. */
895 uint32_t u32CpuLoad_User;
896 /** Nr of threads. */
897 uint32_t u32Threads;
898 /** Nr of processes. */
899 uint32_t u32Processes;
900 /** Nr of handles. */
901 uint32_t u32Handles;
902 /** Memory load (0-100). */
903 uint32_t u32MemoryLoad;
904 /** Page size of guest system. */
905 uint32_t u32PageSize;
906 /** Total physical memory (in 4KB pages). */
907 uint32_t u32PhysMemTotal;
908 /** Available physical memory (in 4KB pages). */
909 uint32_t u32PhysMemAvail;
910 /** Ballooned physical memory (in 4KB pages). */
911 uint32_t u32PhysMemBalloon;
912 /** Total number of committed memory (which is not necessarily in-use) (in 4KB pages). */
913 uint32_t u32MemCommitTotal;
914 /** Total amount of memory used by the kernel (in 4KB pages). */
915 uint32_t u32MemKernelTotal;
916 /** Total amount of paged memory used by the kernel (in 4KB pages). */
917 uint32_t u32MemKernelPaged;
918 /** Total amount of nonpaged memory used by the kernel (in 4KB pages). */
919 uint32_t u32MemKernelNonPaged;
920 /** Total amount of memory used for the system cache (in 4KB pages). */
921 uint32_t u32MemSystemCache;
922 /** Pagefile size (in 4KB pages). */
923 uint32_t u32PageFileSize;
924} VBoxGuestStatistics;
925AssertCompileSize(VBoxGuestStatistics, 19*4);
926
927/** @name Guest statistics values (VBoxGuestStatistics::u32StatCaps).
928 * @{ */
929#define VBOX_GUEST_STAT_CPU_LOAD_IDLE RT_BIT(0)
930#define VBOX_GUEST_STAT_CPU_LOAD_KERNEL RT_BIT(1)
931#define VBOX_GUEST_STAT_CPU_LOAD_USER RT_BIT(2)
932#define VBOX_GUEST_STAT_THREADS RT_BIT(3)
933#define VBOX_GUEST_STAT_PROCESSES RT_BIT(4)
934#define VBOX_GUEST_STAT_HANDLES RT_BIT(5)
935#define VBOX_GUEST_STAT_MEMORY_LOAD RT_BIT(6)
936#define VBOX_GUEST_STAT_PHYS_MEM_TOTAL RT_BIT(7)
937#define VBOX_GUEST_STAT_PHYS_MEM_AVAIL RT_BIT(8)
938#define VBOX_GUEST_STAT_PHYS_MEM_BALLOON RT_BIT(9)
939#define VBOX_GUEST_STAT_MEM_COMMIT_TOTAL RT_BIT(10)
940#define VBOX_GUEST_STAT_MEM_KERNEL_TOTAL RT_BIT(11)
941#define VBOX_GUEST_STAT_MEM_KERNEL_PAGED RT_BIT(12)
942#define VBOX_GUEST_STAT_MEM_KERNEL_NONPAGED RT_BIT(13)
943#define VBOX_GUEST_STAT_MEM_SYSTEM_CACHE RT_BIT(14)
944#define VBOX_GUEST_STAT_PAGE_FILE_SIZE RT_BIT(15)
945/** @} */
946
947/**
948 * Guest statistics command structure.
949 *
950 * Used by VMMDevReq_ReportGuestStats.
951 */
952typedef struct
953{
954 /** Header. */
955 VMMDevRequestHeader header;
956 /** Guest information. */
957 VBoxGuestStatistics guestStats;
958} VMMDevReportGuestStats;
959AssertCompileSize(VMMDevReportGuestStats, 24+19*4);
960
961
962/** Memory balloon change request structure. */
963#define VMMDEV_MAX_MEMORY_BALLOON(PhysMemTotal) ( (9 * (PhysMemTotal)) / 10 )
964
965/**
966 * Poll for ballooning change request.
967 *
968 * Used by VMMDevReq_GetMemBalloonChangeRequest.
969 */
970typedef struct
971{
972 /** Header. */
973 VMMDevRequestHeader header;
974 /** Balloon size in megabytes. */
975 uint32_t cBalloonChunks;
976 /** Guest ram size in megabytes. */
977 uint32_t cPhysMemChunks;
978 /** Setting this to VMMDEV_EVENT_BALLOON_CHANGE_REQUEST indicates that the
979 * request is a response to that event.
980 * (Don't confuse this with VMMDevReq_AcknowledgeEvents.) */
981 uint32_t eventAck;
982} VMMDevGetMemBalloonChangeRequest;
983AssertCompileSize(VMMDevGetMemBalloonChangeRequest, 24+12);
984
985
986/**
987 * Change the size of the balloon.
988 *
989 * Used by VMMDevReq_ChangeMemBalloon.
990 */
991typedef struct
992{
993 /** Header. */
994 VMMDevRequestHeader header;
995 /** The number of pages in the array. */
996 uint32_t cPages;
997 /** true = inflate, false = deflate. */
998 uint32_t fInflate;
999 /** Physical address (RTGCPHYS) of each page, variable size. */
1000 RTGCPHYS aPhysPage[1];
1001} VMMDevChangeMemBalloon;
1002AssertCompileSize(VMMDevChangeMemBalloon, 24+16);
1003
1004/** @name The ballooning chunk size which VMMDev works at.
1005 * @{ */
1006#define VMMDEV_MEMORY_BALLOON_CHUNK_PAGES (_1M/4096)
1007#define VMMDEV_MEMORY_BALLOON_CHUNK_SIZE (VMMDEV_MEMORY_BALLOON_CHUNK_PAGES*4096)
1008/** @} */
1009
1010
1011/**
1012 * Guest statistics interval change request structure.
1013 *
1014 * Used by VMMDevReq_GetStatisticsChangeRequest.
1015 */
1016typedef struct
1017{
1018 /** Header. */
1019 VMMDevRequestHeader header;
1020 /** The interval in seconds. */
1021 uint32_t u32StatInterval;
1022 /** Setting this to VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST indicates
1023 * that the request is a response to that event.
1024 * (Don't confuse this with VMMDevReq_AcknowledgeEvents.) */
1025 uint32_t eventAck;
1026} VMMDevGetStatisticsChangeRequest;
1027AssertCompileSize(VMMDevGetStatisticsChangeRequest, 24+8);
1028
1029
1030/** The size of a string field in the credentials request (including '\\0').
1031 * @see VMMDevCredentials */
1032#define VMMDEV_CREDENTIALS_SZ_SIZE 128
1033
1034/**
1035 * Credentials request structure.
1036 *
1037 * Used by VMMDevReq_QueryCredentials.
1038 */
1039typedef struct
1040{
1041 /** Header. */
1042 VMMDevRequestHeader header;
1043 /** IN/OUT: Request flags. */
1044 uint32_t u32Flags;
1045 /** OUT: User name (UTF-8). */
1046 char szUserName[VMMDEV_CREDENTIALS_SZ_SIZE];
1047 /** OUT: Password (UTF-8). */
1048 char szPassword[VMMDEV_CREDENTIALS_SZ_SIZE];
1049 /** OUT: Domain name (UTF-8). */
1050 char szDomain[VMMDEV_CREDENTIALS_SZ_SIZE];
1051} VMMDevCredentials;
1052AssertCompileSize(VMMDevCredentials, 24+4+3*128);
1053
1054/** @name Credentials request flag (VMMDevCredentials::u32Flags)
1055 * @{ */
1056/** query from host whether credentials are present */
1057#define VMMDEV_CREDENTIALS_QUERYPRESENCE RT_BIT(1)
1058/** read credentials from host (can be combined with clear) */
1059#define VMMDEV_CREDENTIALS_READ RT_BIT(2)
1060/** clear credentials on host (can be combined with read) */
1061#define VMMDEV_CREDENTIALS_CLEAR RT_BIT(3)
1062/** read credentials for judgement in the guest */
1063#define VMMDEV_CREDENTIALS_READJUDGE RT_BIT(8)
1064/** clear credentials for judegement on the host */
1065#define VMMDEV_CREDENTIALS_CLEARJUDGE RT_BIT(9)
1066/** report credentials acceptance by guest */
1067#define VMMDEV_CREDENTIALS_JUDGE_OK RT_BIT(10)
1068/** report credentials denial by guest */
1069#define VMMDEV_CREDENTIALS_JUDGE_DENY RT_BIT(11)
1070/** report that no judgement could be made by guest */
1071#define VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT RT_BIT(12)
1072
1073/** flag telling the guest that credentials are present */
1074#define VMMDEV_CREDENTIALS_PRESENT RT_BIT(16)
1075/** flag telling guest that local logons should be prohibited */
1076#define VMMDEV_CREDENTIALS_NOLOCALLOGON RT_BIT(17)
1077/** @} */
1078
1079
1080/**
1081 * Seamless mode change request structure.
1082 *
1083 * Used by VMMDevReq_GetSeamlessChangeRequest.
1084 */
1085typedef struct
1086{
1087 /** Header. */
1088 VMMDevRequestHeader header;
1089
1090 /** New seamless mode. */
1091 VMMDevSeamlessMode mode;
1092 /** Setting this to VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST indicates
1093 * that the request is a response to that event.
1094 * (Don't confuse this with VMMDevReq_AcknowledgeEvents.) */
1095 uint32_t eventAck;
1096} VMMDevSeamlessChangeRequest;
1097AssertCompileSize(VMMDevSeamlessChangeRequest, 24+8);
1098AssertCompileMemberOffset(VMMDevSeamlessChangeRequest, eventAck, 24+4);
1099
1100
1101/**
1102 * Display change request structure.
1103 *
1104 * Used by VMMDevReq_GetDisplayChangeRequest.
1105 */
1106typedef struct
1107{
1108 /** Header. */
1109 VMMDevRequestHeader header;
1110 /** Horizontal pixel resolution (0 = do not change). */
1111 uint32_t xres;
1112 /** Vertical pixel resolution (0 = do not change). */
1113 uint32_t yres;
1114 /** Bits per pixel (0 = do not change). */
1115 uint32_t bpp;
1116 /** Setting this to VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST indicates
1117 * that the request is a response to that event.
1118 * (Don't confuse this with VMMDevReq_AcknowledgeEvents.) */
1119 uint32_t eventAck;
1120} VMMDevDisplayChangeRequest;
1121AssertCompileSize(VMMDevDisplayChangeRequest, 24+16);
1122
1123
1124/**
1125 * Display change request structure, version 2.
1126 *
1127 * Used by VMMDevReq_GetDisplayChangeRequest2.
1128 */
1129typedef struct
1130{
1131 /** Header. */
1132 VMMDevRequestHeader header;
1133 /** Horizontal pixel resolution (0 = do not change). */
1134 uint32_t xres;
1135 /** Vertical pixel resolution (0 = do not change). */
1136 uint32_t yres;
1137 /** Bits per pixel (0 = do not change). */
1138 uint32_t bpp;
1139 /** Setting this to VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST indicates
1140 * that the request is a response to that event.
1141 * (Don't confuse this with VMMDevReq_AcknowledgeEvents.) */
1142 uint32_t eventAck;
1143 /** 0 for primary display, 1 for the first secondary, etc. */
1144 uint32_t display;
1145} VMMDevDisplayChangeRequest2;
1146AssertCompileSize(VMMDevDisplayChangeRequest2, 24+20);
1147
1148
1149/**
1150 * Display change request structure, version Extended.
1151 *
1152 * Used by VMMDevReq_GetDisplayChangeRequestEx.
1153 */
1154typedef struct
1155{
1156 /** Header. */
1157 VMMDevRequestHeader header;
1158 /** Horizontal pixel resolution (0 = do not change). */
1159 uint32_t xres;
1160 /** Vertical pixel resolution (0 = do not change). */
1161 uint32_t yres;
1162 /** Bits per pixel (0 = do not change). */
1163 uint32_t bpp;
1164 /** Setting this to VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST indicates
1165 * that the request is a response to that event.
1166 * (Don't confuse this with VMMDevReq_AcknowledgeEvents.) */
1167 uint32_t eventAck;
1168 /** 0 for primary display, 1 for the first secondary, etc. */
1169 uint32_t display;
1170 /** New OriginX of secondary virtual screen */
1171 uint32_t cxOrigin;
1172 /** New OriginY of secondary virtual screen */
1173 uint32_t cyOrigin;
1174 /** Change in origin of the secondary virtaul scree is
1175 * required */
1176 bool fChangeOrigin;
1177 /** secondary virtual screen enabled or disabled */
1178 bool fEnabled;
1179} VMMDevDisplayChangeRequestEx;
1180AssertCompileSize(VMMDevDisplayChangeRequestEx, 24+32);
1181
1182
1183/**
1184 * Video mode supported request structure.
1185 *
1186 * Used by VMMDevReq_VideoModeSupported.
1187 */
1188typedef struct
1189{
1190 /** Header. */
1191 VMMDevRequestHeader header;
1192 /** IN: Horizontal pixel resolution. */
1193 uint32_t width;
1194 /** IN: Vertical pixel resolution. */
1195 uint32_t height;
1196 /** IN: Bits per pixel. */
1197 uint32_t bpp;
1198 /** OUT: Support indicator. */
1199 bool fSupported;
1200} VMMDevVideoModeSupportedRequest;
1201AssertCompileSize(VMMDevVideoModeSupportedRequest, 24+16);
1202
1203/**
1204 * Video mode supported request structure for a specific display.
1205 *
1206 * Used by VMMDevReq_VideoModeSupported2.
1207 */
1208typedef struct
1209{
1210 /** Header. */
1211 VMMDevRequestHeader header;
1212 /** IN: The guest display number. */
1213 uint32_t display;
1214 /** IN: Horizontal pixel resolution. */
1215 uint32_t width;
1216 /** IN: Vertical pixel resolution. */
1217 uint32_t height;
1218 /** IN: Bits per pixel. */
1219 uint32_t bpp;
1220 /** OUT: Support indicator. */
1221 bool fSupported;
1222} VMMDevVideoModeSupportedRequest2;
1223AssertCompileSize(VMMDevVideoModeSupportedRequest2, 24+20);
1224
1225/**
1226 * Video modes height reduction request structure.
1227 *
1228 * Used by VMMDevReq_GetHeightReduction.
1229 */
1230typedef struct
1231{
1232 /** Header. */
1233 VMMDevRequestHeader header;
1234 /** OUT: Height reduction in pixels. */
1235 uint32_t heightReduction;
1236} VMMDevGetHeightReductionRequest;
1237AssertCompileSize(VMMDevGetHeightReductionRequest, 24+4);
1238
1239
1240/**
1241 * VRDP change request structure.
1242 *
1243 * Used by VMMDevReq_GetVRDPChangeRequest.
1244 */
1245typedef struct
1246{
1247 /** Header */
1248 VMMDevRequestHeader header;
1249 /** Whether VRDP is active or not. */
1250 uint8_t u8VRDPActive;
1251 /** The configured experience level for active VRDP. */
1252 uint32_t u32VRDPExperienceLevel;
1253} VMMDevVRDPChangeRequest;
1254AssertCompileSize(VMMDevVRDPChangeRequest, 24+8);
1255AssertCompileMemberOffset(VMMDevVRDPChangeRequest, u8VRDPActive, 24);
1256AssertCompileMemberOffset(VMMDevVRDPChangeRequest, u32VRDPExperienceLevel, 24+4);
1257
1258/** @name VRDP Experience level (VMMDevVRDPChangeRequest::u32VRDPExperienceLevel)
1259 * @{ */
1260#define VRDP_EXPERIENCE_LEVEL_ZERO 0 /**< Theming disabled. */
1261#define VRDP_EXPERIENCE_LEVEL_LOW 1 /**< Full window dragging and desktop wallpaper disabled. */
1262#define VRDP_EXPERIENCE_LEVEL_MEDIUM 2 /**< Font smoothing, gradients. */
1263#define VRDP_EXPERIENCE_LEVEL_HIGH 3 /**< Animation effects disabled. */
1264#define VRDP_EXPERIENCE_LEVEL_FULL 4 /**< Everything enabled. */
1265/** @} */
1266
1267
1268/**
1269 * VBVA enable request structure.
1270 *
1271 * Used by VMMDevReq_VideoAccelEnable.
1272 */
1273typedef struct
1274{
1275 /** Header. */
1276 VMMDevRequestHeader header;
1277 /** 0 - disable, !0 - enable. */
1278 uint32_t u32Enable;
1279 /** The size of VBVAMEMORY::au8RingBuffer expected by driver.
1280 * The host will refuse to enable VBVA if the size is not equal to
1281 * VBVA_RING_BUFFER_SIZE.
1282 */
1283 uint32_t cbRingBuffer;
1284 /** Guest initializes the status to 0. Host sets appropriate VBVA_F_STATUS_ flags. */
1285 uint32_t fu32Status;
1286} VMMDevVideoAccelEnable;
1287AssertCompileSize(VMMDevVideoAccelEnable, 24+12);
1288
1289/** @name VMMDevVideoAccelEnable::fu32Status.
1290 * @{ */
1291#define VBVA_F_STATUS_ACCEPTED (0x01)
1292#define VBVA_F_STATUS_ENABLED (0x02)
1293/** @} */
1294
1295
1296/**
1297 * VBVA flush request structure.
1298 *
1299 * Used by VMMDevReq_VideoAccelFlush.
1300 */
1301typedef struct
1302{
1303 /** Header. */
1304 VMMDevRequestHeader header;
1305} VMMDevVideoAccelFlush;
1306AssertCompileSize(VMMDevVideoAccelFlush, 24);
1307
1308
1309/**
1310 * VBVA set visible region request structure.
1311 *
1312 * Used by VMMDevReq_VideoSetVisibleRegion.
1313 */
1314typedef struct
1315{
1316 /** Header. */
1317 VMMDevRequestHeader header;
1318 /** Number of rectangles */
1319 uint32_t cRect;
1320 /** Rectangle array.
1321 * @todo array is spelled aRects[1]. */
1322 RTRECT Rect;
1323} VMMDevVideoSetVisibleRegion;
1324AssertCompileSize(RTRECT, 16);
1325AssertCompileSize(VMMDevVideoSetVisibleRegion, 24+4+16);
1326
1327/**
1328 * CPU event types.
1329 */
1330typedef enum
1331{
1332 VMMDevCpuStatusType_Invalid = 0,
1333 VMMDevCpuStatusType_Disable = 1,
1334 VMMDevCpuStatusType_Enable = 2,
1335 VMMDevCpuStatusType_SizeHack = 0x7fffffff
1336} VMMDevCpuStatusType;
1337
1338/**
1339 * CPU hotplug event status request.
1340 */
1341typedef struct
1342{
1343 /** Header. */
1344 VMMDevRequestHeader header;
1345 /** Status type */
1346 VMMDevCpuStatusType enmStatusType;
1347} VMMDevCpuHotPlugStatusRequest;
1348AssertCompileSize(VMMDevCpuHotPlugStatusRequest, 24+4);
1349
1350/**
1351 * Get the ID of the changed CPU and event type.
1352 */
1353typedef struct
1354{
1355 /** Header. */
1356 VMMDevRequestHeader header;
1357 /** Event type */
1358 VMMDevCpuEventType enmEventType;
1359 /** core id of the CPU changed */
1360 uint32_t idCpuCore;
1361 /** package id of the CPU changed */
1362 uint32_t idCpuPackage;
1363} VMMDevGetCpuHotPlugRequest;
1364AssertCompileSize(VMMDevGetCpuHotPlugRequest, 24+4+4+4);
1365
1366
1367/**
1368 * Shared region description
1369 */
1370typedef struct VMMDEVSHAREDREGIONDESC
1371{
1372 RTGCPTR64 GCRegionAddr;
1373 uint32_t cbRegion;
1374 uint32_t u32Alignment;
1375} VMMDEVSHAREDREGIONDESC;
1376AssertCompileSize(VMMDEVSHAREDREGIONDESC, 16);
1377
1378#define VMMDEVSHAREDREGIONDESC_MAX 32
1379
1380/**
1381 * Shared module registration
1382 */
1383typedef struct
1384{
1385 /** Header. */
1386 VMMDevRequestHeader header;
1387 /** Shared module size. */
1388 uint32_t cbModule;
1389 /** Number of included region descriptors */
1390 uint32_t cRegions;
1391 /** Base address of the shared module. */
1392 RTGCPTR64 GCBaseAddr;
1393 /** Guest OS type. */
1394 VBOXOSFAMILY enmGuestOS;
1395 /** Alignment. */
1396 uint32_t u32Align;
1397 /** Module name */
1398 char szName[128];
1399 /** Module version */
1400 char szVersion[16];
1401 /** Shared region descriptor(s). */
1402 VMMDEVSHAREDREGIONDESC aRegions[1];
1403} VMMDevSharedModuleRegistrationRequest;
1404AssertCompileSize(VMMDevSharedModuleRegistrationRequest, 24+4+4+8+4+4+128+16+16);
1405
1406
1407/**
1408 * Shared module unregistration
1409 */
1410typedef struct
1411{
1412 /** Header. */
1413 VMMDevRequestHeader header;
1414 /** Shared module size. */
1415 uint32_t cbModule;
1416 /** Align at 8 byte boundary. */
1417 uint32_t u32Alignment;
1418 /** Base address of the shared module. */
1419 RTGCPTR64 GCBaseAddr;
1420 /** Module name */
1421 char szName[128];
1422 /** Module version */
1423 char szVersion[16];
1424} VMMDevSharedModuleUnregistrationRequest;
1425AssertCompileSize(VMMDevSharedModuleUnregistrationRequest, 24+4+4+8+128+16);
1426
1427
1428/**
1429 * Shared module periodic check
1430 */
1431typedef struct
1432{
1433 /** Header. */
1434 VMMDevRequestHeader header;
1435} VMMDevSharedModuleCheckRequest;
1436AssertCompileSize(VMMDevSharedModuleCheckRequest, 24);
1437
1438/**
1439 * Paging sharing enabled query
1440 */
1441typedef struct
1442{
1443 /** Header. */
1444 VMMDevRequestHeader header;
1445 /** Enabled flag (out) */
1446 bool fEnabled;
1447 /** Alignment */
1448 bool fAlignment[3];
1449} VMMDevPageSharingStatusRequest;
1450AssertCompileSize(VMMDevPageSharingStatusRequest, 24+4);
1451
1452
1453/**
1454 * Page sharing status query (debug build only)
1455 */
1456typedef struct
1457{
1458 /** Header. */
1459 VMMDevRequestHeader header;
1460 /** Page address. */
1461 RTGCPTR GCPtrPage;
1462 /** Page flags. */
1463 uint64_t uPageFlags;
1464 /** Shared flag (out) */
1465 bool fShared;
1466 /** Alignment */
1467 bool fAlignment[3];
1468} VMMDevPageIsSharedRequest;
1469
1470/**
1471 * Session id request structure.
1472 *
1473 * Used by VMMDevReq_GetSessionId.
1474 */
1475typedef struct
1476{
1477 /** Header */
1478 VMMDevRequestHeader header;
1479 /** OUT: unique session id; the id will be different after each start, reset or restore of the VM */
1480 uint64_t idSession;
1481} VMMDevReqSessionId;
1482AssertCompileSize(VMMDevReqSessionId, 24+8);
1483
1484
1485/**
1486 * Write Core Dump request.
1487 *
1488 * Used by VMMDevReq_WriteCoreDump.
1489 */
1490typedef struct
1491{
1492 /** Header. */
1493 VMMDevRequestHeader header;
1494 /** Flags (reserved, MBZ). */
1495 uint32_t fFlags;
1496} VMMDevReqWriteCoreDump;
1497AssertCompileSize(VMMDevReqWriteCoreDump, 24+4);
1498
1499/** Heart beat check state structure.
1500 * Used by VMMDevReq_HeartbeatConfigure. */
1501typedef struct
1502{
1503 /** Header. */
1504 VMMDevRequestHeader header;
1505 /** OUT: Guest heartbeat interval in nanosec. */
1506 uint64_t cNsInterval;
1507 /** Heartbeat check flag. */
1508 bool fEnabled;
1509} VMMDevReqHeartbeat;
1510AssertCompileSize(VMMDevReqHeartbeat, 24+12);
1511
1512
1513
1514#ifdef VBOX_WITH_HGCM
1515
1516/** @name HGCM flags.
1517 * @{
1518 */
1519# define VBOX_HGCM_REQ_DONE RT_BIT_32(VBOX_HGCM_REQ_DONE_BIT)
1520# define VBOX_HGCM_REQ_DONE_BIT 0
1521# define VBOX_HGCM_REQ_CANCELLED (0x2)
1522/** @} */
1523
1524/**
1525 * HGCM request header.
1526 */
1527typedef struct VMMDevHGCMRequestHeader
1528{
1529 /** Request header. */
1530 VMMDevRequestHeader header;
1531
1532 /** HGCM flags. */
1533 uint32_t fu32Flags;
1534
1535 /** Result code. */
1536 int32_t result;
1537} VMMDevHGCMRequestHeader;
1538AssertCompileSize(VMMDevHGCMRequestHeader, 24+8);
1539
1540/**
1541 * HGCM connect request structure.
1542 *
1543 * Used by VMMDevReq_HGCMConnect.
1544 */
1545typedef struct
1546{
1547 /** HGCM request header. */
1548 VMMDevHGCMRequestHeader header;
1549
1550 /** IN: Description of service to connect to. */
1551 HGCMServiceLocation loc;
1552
1553 /** OUT: Client identifier assigned by local instance of HGCM. */
1554 uint32_t u32ClientID;
1555} VMMDevHGCMConnect;
1556AssertCompileSize(VMMDevHGCMConnect, 32+132+4);
1557
1558
1559/**
1560 * HGCM disconnect request structure.
1561 *
1562 * Used by VMMDevReq_HGCMDisconnect.
1563 */
1564typedef struct
1565{
1566 /** HGCM request header. */
1567 VMMDevHGCMRequestHeader header;
1568
1569 /** IN: Client identifier. */
1570 uint32_t u32ClientID;
1571} VMMDevHGCMDisconnect;
1572AssertCompileSize(VMMDevHGCMDisconnect, 32+4);
1573
1574/**
1575 * HGCM parameter type.
1576 */
1577typedef enum
1578{
1579 VMMDevHGCMParmType_Invalid = 0,
1580 VMMDevHGCMParmType_32bit = 1,
1581 VMMDevHGCMParmType_64bit = 2,
1582 VMMDevHGCMParmType_PhysAddr = 3, /**< @deprecated Doesn't work, use PageList. */
1583 VMMDevHGCMParmType_LinAddr = 4, /**< In and Out */
1584 VMMDevHGCMParmType_LinAddr_In = 5, /**< In (read; host<-guest) */
1585 VMMDevHGCMParmType_LinAddr_Out = 6, /**< Out (write; host->guest) */
1586 VMMDevHGCMParmType_LinAddr_Locked = 7, /**< Locked In and Out */
1587 VMMDevHGCMParmType_LinAddr_Locked_In = 8, /**< Locked In (read; host<-guest) */
1588 VMMDevHGCMParmType_LinAddr_Locked_Out = 9, /**< Locked Out (write; host->guest) */
1589 VMMDevHGCMParmType_PageList = 10, /**< Physical addresses of locked pages for a buffer. */
1590 VMMDevHGCMParmType_SizeHack = 0x7fffffff
1591} HGCMFunctionParameterType;
1592AssertCompileSize(HGCMFunctionParameterType, 4);
1593
1594# ifdef VBOX_WITH_64_BITS_GUESTS
1595/**
1596 * HGCM function parameter, 32-bit client.
1597 */
1598typedef struct
1599{
1600 HGCMFunctionParameterType type;
1601 union
1602 {
1603 uint32_t value32;
1604 uint64_t value64;
1605 struct
1606 {
1607 uint32_t size;
1608
1609 union
1610 {
1611 RTGCPHYS32 physAddr;
1612 RTGCPTR32 linearAddr;
1613 } u;
1614 } Pointer;
1615 struct
1616 {
1617 uint32_t size; /**< Size of the buffer described by the page list. */
1618 uint32_t offset; /**< Relative to the request header, valid if size != 0. */
1619 } PageList;
1620 } u;
1621# ifdef __cplusplus
1622 void SetUInt32(uint32_t u32)
1623 {
1624 type = VMMDevHGCMParmType_32bit;
1625 u.value64 = 0; /* init unused bits to 0 */
1626 u.value32 = u32;
1627 }
1628
1629 int GetUInt32(uint32_t *pu32)
1630 {
1631 if (type == VMMDevHGCMParmType_32bit)
1632 {
1633 *pu32 = u.value32;
1634 return VINF_SUCCESS;
1635 }
1636 return VERR_INVALID_PARAMETER;
1637 }
1638
1639 void SetUInt64(uint64_t u64)
1640 {
1641 type = VMMDevHGCMParmType_64bit;
1642 u.value64 = u64;
1643 }
1644
1645 int GetUInt64(uint64_t *pu64)
1646 {
1647 if (type == VMMDevHGCMParmType_64bit)
1648 {
1649 *pu64 = u.value64;
1650 return VINF_SUCCESS;
1651 }
1652 return VERR_INVALID_PARAMETER;
1653 }
1654
1655 void SetPtr(void *pv, uint32_t cb)
1656 {
1657 type = VMMDevHGCMParmType_LinAddr;
1658 u.Pointer.size = cb;
1659 u.Pointer.u.linearAddr = (RTGCPTR32)(uintptr_t)pv;
1660 }
1661# endif /* __cplusplus */
1662} HGCMFunctionParameter32;
1663AssertCompileSize(HGCMFunctionParameter32, 4+8);
1664
1665/**
1666 * HGCM function parameter, 64-bit client.
1667 */
1668typedef struct
1669{
1670 HGCMFunctionParameterType type;
1671 union
1672 {
1673 uint32_t value32;
1674 uint64_t value64;
1675 struct
1676 {
1677 uint32_t size;
1678
1679 union
1680 {
1681 RTGCPHYS64 physAddr;
1682 RTGCPTR64 linearAddr;
1683 } u;
1684 } Pointer;
1685 struct
1686 {
1687 uint32_t size; /**< Size of the buffer described by the page list. */
1688 uint32_t offset; /**< Relative to the request header, valid if size != 0. */
1689 } PageList;
1690 } u;
1691# ifdef __cplusplus
1692 void SetUInt32(uint32_t u32)
1693 {
1694 type = VMMDevHGCMParmType_32bit;
1695 u.value64 = 0; /* init unused bits to 0 */
1696 u.value32 = u32;
1697 }
1698
1699 int GetUInt32(uint32_t *pu32)
1700 {
1701 if (type == VMMDevHGCMParmType_32bit)
1702 {
1703 *pu32 = u.value32;
1704 return VINF_SUCCESS;
1705 }
1706 return VERR_INVALID_PARAMETER;
1707 }
1708
1709 void SetUInt64(uint64_t u64)
1710 {
1711 type = VMMDevHGCMParmType_64bit;
1712 u.value64 = u64;
1713 }
1714
1715 int GetUInt64(uint64_t *pu64)
1716 {
1717 if (type == VMMDevHGCMParmType_64bit)
1718 {
1719 *pu64 = u.value64;
1720 return VINF_SUCCESS;
1721 }
1722 return VERR_INVALID_PARAMETER;
1723 }
1724
1725 void SetPtr(void *pv, uint32_t cb)
1726 {
1727 type = VMMDevHGCMParmType_LinAddr;
1728 u.Pointer.size = cb;
1729 u.Pointer.u.linearAddr = (uintptr_t)pv;
1730 }
1731# endif /** __cplusplus */
1732} HGCMFunctionParameter64;
1733AssertCompileSize(HGCMFunctionParameter64, 4+12);
1734
1735/* Redefine the structure type for the guest code. */
1736# ifndef VBOX_HGCM_HOST_CODE
1737# if ARCH_BITS == 64
1738# define HGCMFunctionParameter HGCMFunctionParameter64
1739# elif ARCH_BITS == 32
1740# define HGCMFunctionParameter HGCMFunctionParameter32
1741# else
1742# error "Unsupported sizeof (void *)"
1743# endif
1744# endif /* !VBOX_HGCM_HOST_CODE */
1745
1746# else /* !VBOX_WITH_64_BITS_GUESTS */
1747
1748/**
1749 * HGCM function parameter, 32-bit client.
1750 *
1751 * @todo If this is the same as HGCMFunctionParameter32, why the duplication?
1752 */
1753typedef struct
1754{
1755 HGCMFunctionParameterType type;
1756 union
1757 {
1758 uint32_t value32;
1759 uint64_t value64;
1760 struct
1761 {
1762 uint32_t size;
1763
1764 union
1765 {
1766 RTGCPHYS32 physAddr;
1767 RTGCPTR32 linearAddr;
1768 } u;
1769 } Pointer;
1770 struct
1771 {
1772 uint32_t size; /**< Size of the buffer described by the page list. */
1773 uint32_t offset; /**< Relative to the request header, valid if size != 0. */
1774 } PageList;
1775 } u;
1776# ifdef __cplusplus
1777 void SetUInt32(uint32_t u32)
1778 {
1779 type = VMMDevHGCMParmType_32bit;
1780 u.value64 = 0; /* init unused bits to 0 */
1781 u.value32 = u32;
1782 }
1783
1784 int GetUInt32(uint32_t *pu32)
1785 {
1786 if (type == VMMDevHGCMParmType_32bit)
1787 {
1788 *pu32 = u.value32;
1789 return VINF_SUCCESS;
1790 }
1791 return VERR_INVALID_PARAMETER;
1792 }
1793
1794 void SetUInt64(uint64_t u64)
1795 {
1796 type = VMMDevHGCMParmType_64bit;
1797 u.value64 = u64;
1798 }
1799
1800 int GetUInt64(uint64_t *pu64)
1801 {
1802 if (type == VMMDevHGCMParmType_64bit)
1803 {
1804 *pu64 = u.value64;
1805 return VINF_SUCCESS;
1806 }
1807 return VERR_INVALID_PARAMETER;
1808 }
1809
1810 void SetPtr(void *pv, uint32_t cb)
1811 {
1812 type = VMMDevHGCMParmType_LinAddr;
1813 u.Pointer.size = cb;
1814 u.Pointer.u.linearAddr = (uintptr_t)pv;
1815 }
1816# endif /* __cplusplus */
1817} HGCMFunctionParameter;
1818AssertCompileSize(HGCMFunctionParameter, 4+8);
1819# endif /* !VBOX_WITH_64_BITS_GUESTS */
1820
1821/**
1822 * HGCM call request structure.
1823 *
1824 * Used by VMMDevReq_HGCMCall, VMMDevReq_HGCMCall32 and VMMDevReq_HGCMCall64.
1825 */
1826typedef struct
1827{
1828 /* request header */
1829 VMMDevHGCMRequestHeader header;
1830
1831 /** IN: Client identifier. */
1832 uint32_t u32ClientID;
1833 /** IN: Service function number. */
1834 uint32_t u32Function;
1835 /** IN: Number of parameters. */
1836 uint32_t cParms;
1837 /** Parameters follow in form: HGCMFunctionParameter aParms[X]; */
1838} VMMDevHGCMCall;
1839AssertCompileSize(VMMDevHGCMCall, 32+12);
1840
1841/** @name Direction of data transfer (HGCMPageListInfo::flags). Bit flags.
1842 * @{ */
1843#define VBOX_HGCM_F_PARM_DIRECTION_NONE UINT32_C(0x00000000)
1844#define VBOX_HGCM_F_PARM_DIRECTION_TO_HOST UINT32_C(0x00000001)
1845#define VBOX_HGCM_F_PARM_DIRECTION_FROM_HOST UINT32_C(0x00000002)
1846#define VBOX_HGCM_F_PARM_DIRECTION_BOTH UINT32_C(0x00000003)
1847/** Macro for validating that the specified flags are valid. */
1848#define VBOX_HGCM_F_PARM_ARE_VALID(fFlags) \
1849 ( (fFlags) > VBOX_HGCM_F_PARM_DIRECTION_NONE \
1850 && (fFlags) < VBOX_HGCM_F_PARM_DIRECTION_BOTH )
1851/** @} */
1852
1853/**
1854 * VMMDevHGCMParmType_PageList points to this structure to actually describe the
1855 * buffer.
1856 */
1857typedef struct
1858{
1859 uint32_t flags; /**< VBOX_HGCM_F_PARM_*. */
1860 uint16_t offFirstPage; /**< Offset in the first page where data begins. */
1861 uint16_t cPages; /**< Number of pages. */
1862 RTGCPHYS64 aPages[1]; /**< Page addresses. */
1863} HGCMPageListInfo;
1864AssertCompileSize(HGCMPageListInfo, 4+2+2+8);
1865
1866
1867/** Get the pointer to the first parmater of a HGCM call request. */
1868# define VMMDEV_HGCM_CALL_PARMS(a) ((HGCMFunctionParameter *)((uint8_t *)(a) + sizeof (VMMDevHGCMCall)))
1869/** Get the pointer to the first parmater of a 32-bit HGCM call request. */
1870# define VMMDEV_HGCM_CALL_PARMS32(a) ((HGCMFunctionParameter32 *)((uint8_t *)(a) + sizeof (VMMDevHGCMCall)))
1871
1872# ifdef VBOX_WITH_64_BITS_GUESTS
1873/* Explicit defines for the host code. */
1874# ifdef VBOX_HGCM_HOST_CODE
1875# define VMMDEV_HGCM_CALL_PARMS32(a) ((HGCMFunctionParameter32 *)((uint8_t *)(a) + sizeof (VMMDevHGCMCall)))
1876# define VMMDEV_HGCM_CALL_PARMS64(a) ((HGCMFunctionParameter64 *)((uint8_t *)(a) + sizeof (VMMDevHGCMCall)))
1877# endif /* VBOX_HGCM_HOST_CODE */
1878# endif /* VBOX_WITH_64_BITS_GUESTS */
1879
1880# define VBOX_HGCM_MAX_PARMS 32
1881
1882/**
1883 * HGCM cancel request structure.
1884 *
1885 * The Cancel request is issued using the same physical memory address as was
1886 * used for the corresponding initial HGCMCall.
1887 *
1888 * Used by VMMDevReq_HGCMCancel.
1889 */
1890typedef struct
1891{
1892 /** Header. */
1893 VMMDevHGCMRequestHeader header;
1894} VMMDevHGCMCancel;
1895AssertCompileSize(VMMDevHGCMCancel, 32);
1896
1897/**
1898 * HGCM cancel request structure, version 2.
1899 *
1900 * Used by VMMDevReq_HGCMCancel2.
1901 *
1902 * VINF_SUCCESS when cancelled.
1903 * VERR_NOT_FOUND if the specified request cannot be found.
1904 * VERR_INVALID_PARAMETER if the address is invalid valid.
1905 */
1906typedef struct
1907{
1908 /** Header. */
1909 VMMDevRequestHeader header;
1910 /** The physical address of the request to cancel. */
1911 RTGCPHYS32 physReqToCancel;
1912} VMMDevHGCMCancel2;
1913AssertCompileSize(VMMDevHGCMCancel2, 24+4);
1914
1915#endif /* VBOX_WITH_HGCM */
1916
1917
1918/**
1919 * Inline helper to determine the request size for the given operation.
1920 * Returns 0 if the given operation is not handled and/or supported.
1921 *
1922 * @returns Size.
1923 * @param requestType The VMMDev request type.
1924 */
1925DECLINLINE(size_t) vmmdevGetRequestSize(VMMDevRequestType requestType)
1926{
1927 switch (requestType)
1928 {
1929 case VMMDevReq_GetMouseStatus:
1930 case VMMDevReq_SetMouseStatus:
1931 return sizeof(VMMDevReqMouseStatus);
1932 case VMMDevReq_SetPointerShape:
1933 return sizeof(VMMDevReqMousePointer);
1934 case VMMDevReq_GetHostVersion:
1935 return sizeof(VMMDevReqHostVersion);
1936 case VMMDevReq_Idle:
1937 return sizeof(VMMDevReqIdle);
1938 case VMMDevReq_GetHostTime:
1939 return sizeof(VMMDevReqHostTime);
1940 case VMMDevReq_GetHypervisorInfo:
1941 case VMMDevReq_SetHypervisorInfo:
1942 return sizeof(VMMDevReqHypervisorInfo);
1943 case VMMDevReq_RegisterPatchMemory:
1944 case VMMDevReq_DeregisterPatchMemory:
1945 return sizeof(VMMDevReqPatchMemory);
1946 case VMMDevReq_SetPowerStatus:
1947 return sizeof(VMMDevPowerStateRequest);
1948 case VMMDevReq_AcknowledgeEvents:
1949 return sizeof(VMMDevEvents);
1950 case VMMDevReq_ReportGuestInfo:
1951 return sizeof(VMMDevReportGuestInfo);
1952 case VMMDevReq_ReportGuestInfo2:
1953 return sizeof(VMMDevReportGuestInfo2);
1954 case VMMDevReq_ReportGuestStatus:
1955 return sizeof(VMMDevReportGuestStatus);
1956 case VMMDevReq_ReportGuestUserState:
1957 return sizeof(VMMDevReportGuestUserState);
1958 case VMMDevReq_GetDisplayChangeRequest:
1959 return sizeof(VMMDevDisplayChangeRequest);
1960 case VMMDevReq_GetDisplayChangeRequest2:
1961 return sizeof(VMMDevDisplayChangeRequest2);
1962 case VMMDevReq_GetDisplayChangeRequestEx:
1963 return sizeof(VMMDevDisplayChangeRequestEx);
1964 case VMMDevReq_VideoModeSupported:
1965 return sizeof(VMMDevVideoModeSupportedRequest);
1966 case VMMDevReq_GetHeightReduction:
1967 return sizeof(VMMDevGetHeightReductionRequest);
1968 case VMMDevReq_ReportGuestCapabilities:
1969 return sizeof(VMMDevReqGuestCapabilities);
1970 case VMMDevReq_SetGuestCapabilities:
1971 return sizeof(VMMDevReqGuestCapabilities2);
1972#ifdef VBOX_WITH_HGCM
1973 case VMMDevReq_HGCMConnect:
1974 return sizeof(VMMDevHGCMConnect);
1975 case VMMDevReq_HGCMDisconnect:
1976 return sizeof(VMMDevHGCMDisconnect);
1977#ifdef VBOX_WITH_64_BITS_GUESTS
1978 case VMMDevReq_HGCMCall32:
1979 return sizeof(VMMDevHGCMCall);
1980 case VMMDevReq_HGCMCall64:
1981 return sizeof(VMMDevHGCMCall);
1982#else
1983 case VMMDevReq_HGCMCall:
1984 return sizeof(VMMDevHGCMCall);
1985#endif /* VBOX_WITH_64_BITS_GUESTS */
1986 case VMMDevReq_HGCMCancel:
1987 return sizeof(VMMDevHGCMCancel);
1988#endif /* VBOX_WITH_HGCM */
1989 case VMMDevReq_VideoAccelEnable:
1990 return sizeof(VMMDevVideoAccelEnable);
1991 case VMMDevReq_VideoAccelFlush:
1992 return sizeof(VMMDevVideoAccelFlush);
1993 case VMMDevReq_VideoSetVisibleRegion:
1994 /* The original protocol didn't consider a guest with NO visible
1995 * windows */
1996 return sizeof(VMMDevVideoSetVisibleRegion) - sizeof(RTRECT);
1997 case VMMDevReq_GetSeamlessChangeRequest:
1998 return sizeof(VMMDevSeamlessChangeRequest);
1999 case VMMDevReq_QueryCredentials:
2000 return sizeof(VMMDevCredentials);
2001 case VMMDevReq_ReportGuestStats:
2002 return sizeof(VMMDevReportGuestStats);
2003 case VMMDevReq_GetMemBalloonChangeRequest:
2004 return sizeof(VMMDevGetMemBalloonChangeRequest);
2005 case VMMDevReq_GetStatisticsChangeRequest:
2006 return sizeof(VMMDevGetStatisticsChangeRequest);
2007 case VMMDevReq_ChangeMemBalloon:
2008 return sizeof(VMMDevChangeMemBalloon);
2009 case VMMDevReq_GetVRDPChangeRequest:
2010 return sizeof(VMMDevVRDPChangeRequest);
2011 case VMMDevReq_LogString:
2012 return sizeof(VMMDevReqLogString);
2013 case VMMDevReq_CtlGuestFilterMask:
2014 return sizeof(VMMDevCtlGuestFilterMask);
2015 case VMMDevReq_GetCpuHotPlugRequest:
2016 return sizeof(VMMDevGetCpuHotPlugRequest);
2017 case VMMDevReq_SetCpuHotPlugStatus:
2018 return sizeof(VMMDevCpuHotPlugStatusRequest);
2019 case VMMDevReq_RegisterSharedModule:
2020 return sizeof(VMMDevSharedModuleRegistrationRequest);
2021 case VMMDevReq_UnregisterSharedModule:
2022 return sizeof(VMMDevSharedModuleUnregistrationRequest);
2023 case VMMDevReq_CheckSharedModules:
2024 return sizeof(VMMDevSharedModuleCheckRequest);
2025 case VMMDevReq_GetPageSharingStatus:
2026 return sizeof(VMMDevPageSharingStatusRequest);
2027 case VMMDevReq_DebugIsPageShared:
2028 return sizeof(VMMDevPageIsSharedRequest);
2029 case VMMDevReq_GetSessionId:
2030 return sizeof(VMMDevReqSessionId);
2031 case VMMDevReq_HeartbeatConfigure:
2032 return sizeof(VMMDevReqHeartbeat);
2033 case VMMDevReq_GuestHeartbeat:
2034 return sizeof(VMMDevRequestHeader);
2035 default:
2036 break;
2037 }
2038
2039 return 0;
2040}
2041
2042
2043/**
2044 * Initializes a request structure.
2045 *
2046 * @returns VBox status code.
2047 * @param req The request structure to initialize.
2048 * @param type The request type.
2049 */
2050DECLINLINE(int) vmmdevInitRequest(VMMDevRequestHeader *req, VMMDevRequestType type)
2051{
2052 uint32_t requestSize;
2053 if (!req)
2054 return VERR_INVALID_PARAMETER;
2055 requestSize = (uint32_t)vmmdevGetRequestSize(type);
2056 if (!requestSize)
2057 return VERR_INVALID_PARAMETER;
2058 req->size = requestSize;
2059 req->version = VMMDEV_REQUEST_HEADER_VERSION;
2060 req->requestType = type;
2061 req->rc = VERR_GENERAL_FAILURE;
2062 req->reserved1 = 0;
2063 req->reserved2 = 0;
2064 return VINF_SUCCESS;
2065}
2066
2067/** @} */
2068
2069
2070/**
2071 * VBVA command header.
2072 *
2073 * @todo Where does this fit in?
2074 */
2075typedef struct VBVACMDHDR
2076{
2077 /** Coordinates of affected rectangle. */
2078 int16_t x;
2079 int16_t y;
2080 uint16_t w;
2081 uint16_t h;
2082} VBVACMDHDR;
2083AssertCompileSize(VBVACMDHDR, 8);
2084
2085/** @name VBVA ring defines.
2086 *
2087 * The VBVA ring buffer is suitable for transferring large (< 2GB) amount of
2088 * data. For example big bitmaps which do not fit to the buffer.
2089 *
2090 * Guest starts writing to the buffer by initializing a record entry in the
2091 * aRecords queue. VBVA_F_RECORD_PARTIAL indicates that the record is being
2092 * written. As data is written to the ring buffer, the guest increases off32End
2093 * for the record.
2094 *
2095 * The host reads the aRecords on flushes and processes all completed records.
2096 * When host encounters situation when only a partial record presents and
2097 * cbRecord & ~VBVA_F_RECORD_PARTIAL >= VBVA_RING_BUFFER_SIZE -
2098 * VBVA_RING_BUFFER_THRESHOLD, the host fetched all record data and updates
2099 * off32Head. After that on each flush the host continues fetching the data
2100 * until the record is completed.
2101 *
2102 */
2103#define VBVA_RING_BUFFER_SIZE (_4M - _1K)
2104#define VBVA_RING_BUFFER_THRESHOLD (4 * _1K)
2105
2106#define VBVA_MAX_RECORDS (64)
2107
2108#define VBVA_F_MODE_ENABLED (0x00000001)
2109#define VBVA_F_MODE_VRDP (0x00000002)
2110#define VBVA_F_MODE_VRDP_RESET (0x00000004)
2111#define VBVA_F_MODE_VRDP_ORDER_MASK (0x00000008)
2112
2113#define VBVA_F_STATE_PROCESSING (0x00010000)
2114
2115#define VBVA_F_RECORD_PARTIAL (0x80000000)
2116/** @} */
2117
2118/**
2119 * VBVA record.
2120 */
2121typedef struct VBVARECORD
2122{
2123 /** The length of the record. Changed by guest. */
2124 uint32_t cbRecord;
2125} VBVARECORD;
2126AssertCompileSize(VBVARECORD, 4);
2127
2128
2129/**
2130 * VBVA memory layout.
2131 *
2132 * This is a subsection of the VMMDevMemory structure.
2133 */
2134typedef struct VBVAMEMORY
2135{
2136 /** VBVA_F_MODE_*. */
2137 uint32_t fu32ModeFlags;
2138
2139 /** The offset where the data start in the buffer. */
2140 uint32_t off32Data;
2141 /** The offset where next data must be placed in the buffer. */
2142 uint32_t off32Free;
2143
2144 /** The ring buffer for data. */
2145 uint8_t au8RingBuffer[VBVA_RING_BUFFER_SIZE];
2146
2147 /** The queue of record descriptions. */
2148 VBVARECORD aRecords[VBVA_MAX_RECORDS];
2149 uint32_t indexRecordFirst;
2150 uint32_t indexRecordFree;
2151
2152 /** RDP orders supported by the client. The guest reports only them
2153 * and falls back to DIRTY rects for not supported ones.
2154 *
2155 * (1 << VBVA_VRDP_*)
2156 */
2157 uint32_t fu32SupportedOrders;
2158
2159} VBVAMEMORY;
2160AssertCompileSize(VBVAMEMORY, 12 + (_4M-_1K) + 4*64 + 12);
2161
2162
2163/**
2164 * The layout of VMMDEV RAM region that contains information for guest.
2165 */
2166typedef struct VMMDevMemory
2167{
2168 /** The size of this structure. */
2169 uint32_t u32Size;
2170 /** The structure version. (VMMDEV_MEMORY_VERSION) */
2171 uint32_t u32Version;
2172
2173 union
2174 {
2175 struct
2176 {
2177 /** Flag telling that VMMDev set the IRQ and acknowlegment is required */
2178 bool fHaveEvents;
2179 } V1_04;
2180
2181 struct
2182 {
2183 /** Pending events flags, set by host. */
2184 uint32_t u32HostEvents;
2185 /** Mask of events the guest wants to see, set by guest. */
2186 uint32_t u32GuestEventMask;
2187 } V1_03;
2188 } V;
2189
2190 VBVAMEMORY vbvaMemory;
2191
2192} VMMDevMemory;
2193AssertCompileSize(VMMDevMemory, 8+8 + (12 + (_4M-_1K) + 4*64 + 12) );
2194AssertCompileMemberOffset(VMMDevMemory, vbvaMemory, 16);
2195
2196/** Version of VMMDevMemory structure (VMMDevMemory::u32Version). */
2197#define VMMDEV_MEMORY_VERSION (1)
2198
2199/** @} */
2200
2201RT_C_DECLS_END
2202#pragma pack()
2203
2204#endif
2205
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette